schain Commit - r1377:5453f456345b · Jicamarca Repository

isr commit

rflores -

r1377:5453f456345b

parent child

Context file:

r1377:5453f456345b

Expand all files

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

schainpy/model/graphics/jroplot_voltage_lags.py created 644 +1156 0

This diff has been collapsed as it changes many lines, (1156 lines changed) Show them Hide them
	@@ -0,0 +1,1156
		1
		2	import os
		3	import datetime
		4	import numpy
		5	from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator #YONG
		6
		7	from .jroplot_spectra import RTIPlot, NoisePlot
		8
		9	from schainpy.utils import log
		10	from .plotting_codes import *
		11
		12	from schainpy.model.graphics.jroplot_base import Plot, plt
		13
		14	import matplotlib.pyplot as plt
		15	import matplotlib.colors as colors
		16
		17	import time
		18	import math
		19
		20
		21	from matplotlib.ticker import MultipleLocator
		22
		23
		24
		25	class RTIDPPlot(RTIPlot):
		26
		27	'''
		28	Plot for RTI Double Pulse Experiment
		29	'''
		30
		31	CODE = 'RTIDP'
		32	colormap = 'jro'
		33	plot_name = 'RTI'
		34
		35	#cb_label = 'Ne Electron Density (1/cm3)'
		36
		37	def setup(self):
		38	self.xaxis = 'time'
		39	self.ncols = 1
		40	self.nrows = 3
		41	self.nplots = self.nrows
		42	#self.height=10
		43	if self.showSNR:
		44	self.nrows += 1
		45	self.nplots += 1
		46
		47	self.ylabel = 'Height [km]'
		48	self.xlabel = 'Time (LT)'
		49
		50	self.cb_label = 'Intensity (dB)'
		51
		52
		53	#self.cb_label = cb_label
		54
		55	self.titles = ['{} Channel {}'.format(
		56	self.plot_name.upper(), '0x1'),'{} Channel {}'.format(
		57	self.plot_name.upper(), '0'),'{} Channel {}'.format(
		58	self.plot_name.upper(), '1')]
		59
		60
		61	def plot(self):
		62
		63	self.data.normalize_heights()
		64	self.x = self.data.times
		65	self.y = self.data.heights[0:self.data.NDP]
		66
		67	if self.showSNR:
		68	self.z = numpy.concatenate(
		69	(self.data[self.CODE], self.data['snr'])
		70	)
		71	else:
		72
		73	self.z = self.data[self.CODE]
		74	#print(numpy.max(self.z[0,0:]))
		75
		76	self.z = numpy.ma.masked_invalid(self.z)
		77
		78	if self.decimation is None:
		79	x, y, z = self.fill_gaps(self.x, self.y, self.z)
		80	else:
		81	x, y, z = self.fill_gaps(*self.decimate())
		82
		83	for n, ax in enumerate(self.axes):
		84
		85
		86	self.zmax = self.zmax if self.zmax is not None else numpy.max(
		87	self.z[1][0,12:40])
		88	self.zmin = self.zmin if self.zmin is not None else numpy.min(
		89	self.z[1][0,12:40])
		90
		91
		92
		93	if ax.firsttime:
		94
		95	if self.zlimits is not None:
		96	self.zmin, self.zmax = self.zlimits[n]
		97
		98
		99	ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
		100	vmin=self.zmin,
		101	vmax=self.zmax,
		102	cmap=self.cmaps[n]
		103	)
		104	#plt.tight_layout()
		105	else:
		106	if self.zlimits is not None:
		107	self.zmin, self.zmax = self.zlimits[n]
		108	ax.collections.remove(ax.collections[0])
		109	ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
		110	vmin=self.zmin,
		111	vmax=self.zmax,
		112	cmap=self.cmaps[n]
		113	)
		114	#plt.tight_layout()
		115
		116
		117	class RTILPPlot(RTIPlot):
		118
		119	'''
		120	Plot for RTI Long Pulse
		121	'''
		122
		123	CODE = 'RTILP'
		124	colormap = 'jro'
		125	plot_name = 'RTI LP'
		126
		127	#cb_label = 'Ne Electron Density (1/cm3)'
		128
		129	def setup(self):
		130	self.xaxis = 'time'
		131	self.ncols = 1
		132	self.nrows = 4
		133	self.nplots = self.nrows
		134	if self.showSNR:
		135	self.nrows += 1
		136	self.nplots += 1
		137
		138	self.ylabel = 'Height [km]'
		139	self.xlabel = 'Time (LT)'
		140
		141	self.cb_label = 'Intensity (dB)'
		142
		143
		144
		145	#self.cb_label = cb_label
		146
		147	self.titles = ['{} Channel {}'.format(
		148	self.plot_name.upper(), '0'),'{} Channel {}'.format(
		149	self.plot_name.upper(), '1'),'{} Channel {}'.format(
		150	self.plot_name.upper(), '2'),'{} Channel {}'.format(
		151	self.plot_name.upper(), '3')]
		152
		153
		154	def plot(self):
		155
		156	self.data.normalize_heights()
		157	self.x = self.data.times
		158	self.y = self.data.heights[0:self.data.NRANGE]
		159
		160	if self.showSNR:
		161	self.z = numpy.concatenate(
		162	(self.data[self.CODE], self.data['snr'])
		163	)
		164	else:
		165
		166	self.z = self.data[self.CODE]
		167	#print(numpy.max(self.z[0,0:]))
		168
		169	self.z = numpy.ma.masked_invalid(self.z)
		170
		171	if self.decimation is None:
		172	x, y, z = self.fill_gaps(self.x, self.y, self.z)
		173	else:
		174	x, y, z = self.fill_gaps(*self.decimate())
		175
		176	for n, ax in enumerate(self.axes):
		177
		178
		179	self.zmax = self.zmax if self.zmax is not None else numpy.max(
		180	self.z[1][0,12:40])
		181	self.zmin = self.zmin if self.zmin is not None else numpy.min(
		182	self.z[1][0,12:40])
		183
		184	if ax.firsttime:
		185
		186	if self.zlimits is not None:
		187	self.zmin, self.zmax = self.zlimits[n]
		188
		189
		190	ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
		191	vmin=self.zmin,
		192	vmax=self.zmax,
		193	cmap=self.cmaps[n]
		194	)
		195	#plt.tight_layout()
		196	else:
		197	if self.zlimits is not None:
		198	self.zmin, self.zmax = self.zlimits[n]
		199	ax.collections.remove(ax.collections[0])
		200	ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
		201	vmin=self.zmin,
		202	vmax=self.zmax,
		203	cmap=self.cmaps[n]
		204	)
		205	#plt.tight_layout()
		206
		207
		208	class DenRTIPlot(RTIPlot):
		209
		210	'''
		211	Plot for Den
		212	'''
		213
		214	CODE = 'denrti'
		215	colormap = 'jro'
		216	plot_name = 'Electron Density'
		217
		218	#cb_label = 'Ne Electron Density (1/cm3)'
		219
		220	def setup(self):
		221	self.xaxis = 'time'
		222	self.ncols = 1
		223	self.nrows = self.data.shape(self.CODE)[0]
		224	self.nplots = self.nrows
		225	if self.showSNR:
		226	self.nrows += 1
		227	self.nplots += 1
		228
		229	self.ylabel = 'Height [km]'
		230	self.xlabel = 'Time (LT)'
		231
		232	self.plots_adjust.update({'wspace': 0.8, 'hspace':0.2, 'left': 0.2, 'right': 0.9, 'bottom': 0.18})
		233
		234	if self.CODE == 'denrti' or self.CODE=='denrtiLP':
		235	self.cb_label = r'$\mathrm{N_e}$ Electron Density ($\mathrm{1/cm^3}$)'
		236
		237	#self.cb_label = cb_label
		238	if not self.titles:
		239	self.titles = self.data.parameters \
		240	if self.data.parameters else ['{}'.format(self.plot_name)]
		241	if self.showSNR:
		242	self.titles.append('SNR')
		243
		244	def plot(self):
		245
		246	self.data.normalize_heights()
		247	self.x = self.data.times
		248	self.y = self.data.heights
		249
		250
		251
		252	if self.showSNR:
		253	self.z = numpy.concatenate(
		254	(self.data[self.CODE], self.data['snr'])
		255	)
		256	else:
		257	self.z = self.data[self.CODE]
		258
		259	self.z = numpy.ma.masked_invalid(self.z)
		260
		261	if self.decimation is None:
		262	x, y, z = self.fill_gaps(self.x, self.y, self.z)
		263	else:
		264	x, y, z = self.fill_gaps(*self.decimate())
		265
		266	for n, ax in enumerate(self.axes):
		267
		268	self.zmax = self.zmax if self.zmax is not None else numpy.max(
		269	self.z[n])
		270	self.zmin = self.zmin if self.zmin is not None else numpy.min(
		271	self.z[n])
		272
		273	if ax.firsttime:
		274
		275	if self.zlimits is not None:
		276	self.zmin, self.zmax = self.zlimits[n]
		277	if numpy.log10(self.zmin)<0:
		278	self.zmin=1
		279	ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
		280	vmin=self.zmin,
		281	vmax=self.zmax,
		282	cmap=self.cmaps[n],
		283	norm=colors.LogNorm()
		284	)
		285	#plt.tight_layout()
		286
		287	else:
		288	if self.zlimits is not None:
		289	self.zmin, self.zmax = self.zlimits[n]
		290	ax.collections.remove(ax.collections[0])
		291	ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
		292	vmin=self.zmin,
		293	vmax=self.zmax,
		294	cmap=self.cmaps[n],
		295	norm=colors.LogNorm()
		296	)
		297	#plt.tight_layout()
		298
		299
		300
		301	class DenRTILPPlot(DenRTIPlot):
		302
		303	'''
		304	Plot for Electron Temperature
		305	'''
		306
		307	CODE = 'denrtiLP'
		308	colormap = 'jro'
		309	plot_name = 'Electron Density'
		310
		311
		312	class ETempRTIPlot(RTIPlot):
		313
		314	'''
		315	Plot for Electron Temperature
		316	'''
		317
		318	CODE = 'ETemp'
		319	colormap = 'jet'
		320	plot_name = 'Electron Temperature'
		321
		322	#cb_label = 'Ne Electron Density (1/cm3)'
		323
		324	def setup(self):
		325	self.xaxis = 'time'
		326	self.ncols = 1
		327	self.nrows = self.data.shape(self.CODE)[0]
		328	self.nplots = self.nrows
		329	if self.showSNR:
		330	self.nrows += 1
		331	self.nplots += 1
		332
		333	self.ylabel = 'Height [km]'
		334	self.xlabel = 'Time (LT)'
		335	self.plots_adjust.update({'wspace': 0.8, 'hspace':0.2, 'left': 0.2, 'right': 0.9, 'bottom': 0.18})
		336	if self.CODE == 'ETemp' or self.CODE == 'ETempLP':
		337	self.cb_label = 'Electron Temperature (K)'
		338	if self.CODE == 'ITemp' or self.CODE == 'ITempLP':
		339	self.cb_label = 'Ion Temperature (K)'
		340
		341
		342	if not self.titles:
		343	self.titles = self.data.parameters \
		344	if self.data.parameters else ['{}'.format(self.plot_name)]
		345	if self.showSNR:
		346	self.titles.append('SNR')
		347
		348	def plot(self):
		349
		350	self.data.normalize_heights()
		351	self.x = self.data.times
		352	self.y = self.data.heights
		353
		354	if self.showSNR:
		355	self.z = numpy.concatenate(
		356	(self.data[self.CODE], self.data['snr'])
		357	)
		358	else:
		359	self.z = self.data[self.CODE]
		360
		361	self.z = numpy.ma.masked_invalid(self.z)
		362
		363	if self.decimation is None:
		364	x, y, z = self.fill_gaps(self.x, self.y, self.z)
		365	else:
		366	x, y, z = self.fill_gaps(*self.decimate())
		367
		368	for n, ax in enumerate(self.axes):
		369
		370	self.zmax = self.zmax if self.zmax is not None else numpy.max(
		371	self.z[n])
		372	self.zmin = self.zmin if self.zmin is not None else numpy.min(
		373	self.z[n])
		374
		375	if ax.firsttime:
		376
		377	if self.zlimits is not None:
		378	self.zmin, self.zmax = self.zlimits[n]
		379
		380	ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
		381	vmin=self.zmin,
		382	vmax=self.zmax,
		383	cmap=self.cmaps[n]
		384	)
		385	#plt.tight_layout()
		386
		387	else:
		388	if self.zlimits is not None:
		389	self.zmin, self.zmax = self.zlimits[n]
		390	ax.collections.remove(ax.collections[0])
		391	ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
		392	vmin=self.zmin,
		393	vmax=self.zmax,
		394	cmap=self.cmaps[n]
		395	)
		396	#plt.tight_layout()
		397
		398
		399
		400	class ITempRTIPlot(ETempRTIPlot):
		401
		402	'''
		403	Plot for Ion Temperature
		404	'''
		405
		406	CODE = 'ITemp'
		407	colormap = 'jet'
		408	plot_name = 'Ion Temperature'
		409
		410
		411	class ElectronTempLPPlot(ETempRTIPlot):
		412
		413	'''
		414	Plot for Electron Temperature LP
		415	'''
		416
		417	CODE = 'ETempLP'
		418	colormap = 'jet'
		419	plot_name = 'Electron Temperature'
		420
		421
		422	class IonTempLPPlot(ETempRTIPlot):
		423
		424	'''
		425	Plot for Ion Temperature LP
		426	'''
		427
		428	CODE = 'ITempLP'
		429	colormap = 'jet'
		430	plot_name = 'Ion Temperature'
		431
		432
		433	class HFracRTIPlot(ETempRTIPlot):
		434
		435	'''
		436	Plot for H+ LP
		437	'''
		438
		439	CODE = 'HFracLP'
		440	colormap = 'jet'
		441	plot_name = 'H+ Frac'
		442
		443
		444	class HeFracRTIPlot(ETempRTIPlot):
		445
		446	'''
		447	Plot for He+ LP
		448	'''
		449
		450	CODE = 'HeFracLP'
		451	colormap = 'jet'
		452	plot_name = 'He+ Frac'
		453
		454
		455	class TempsDPPlot(Plot):
		456	'''
		457	Plot for Electron - Ion Temperatures
		458	'''
		459
		460	CODE = 'tempsDP'
		461	plot_name = 'Temperatures'
		462	plot_type = 'scatterbuffer'
		463
		464
		465	def setup(self):
		466
		467	self.ncols = 1
		468	self.nrows = 1
		469	self.nplots = 1
		470	self.ylabel = 'Range [km]'
		471	self.xlabel = 'Temperature (K)'
		472	self.width = 3.5
		473	self.height = 5.5
		474	self.colorbar = False
		475	self.plots_adjust.update({'wspace': 0.8, 'hspace':0.2, 'left': 0.2, 'right': 0.9, 'bottom': 0.18})
		476	if not self.titles:
		477	self.titles = self.data.parameters \
		478	if self.data.parameters else ['{}'.format(self.CODE.upper())]
		479
		480	def plot(self):
		481
		482	self.x = self.data['tempsDP'][:,-1]
		483	self.y = self.data.heights[0:self.data.NSHTS]
		484
		485	self.xmin = -100
		486	self.xmax = 5000
		487	ax = self.axes[0]
		488
		489	if ax.firsttime:
		490
		491	ax.errorbar(self.x, self.y, xerr=self.data.ete2, fmt='r^',elinewidth=1.0,color='b',linewidth=2.0, label='Te')
		492	ax.errorbar(self.data.ti2, self.y, fmt='k^', xerr=self.data.eti2,elinewidth=1.0,color='b',linewidth=2.0, label='Ti')
		493	plt.legend(loc='lower right')
		494	self.ystep_given = 50
		495	ax.yaxis.set_minor_locator(MultipleLocator(15))
		496	ax.grid(which='minor')
		497	#plt.tight_layout()
		498
		499
		500	else:
		501	self.clear_figures()
		502	ax.errorbar(self.x, self.y, xerr=self.data.ete2, fmt='r^',elinewidth=1.0,color='b',linewidth=2.0, label='Te')
		503	ax.errorbar(self.data.ti2, self.y, fmt='k^', xerr=self.data.eti2,elinewidth=1.0,color='b',linewidth=2.0, label='Ti')
		504	plt.legend(loc='lower right')
		505	ax.yaxis.set_minor_locator(MultipleLocator(15))
		506	#plt.tight_layout()
		507
		508
		509	class TempsHPPlot(Plot):
		510	'''
		511	Plot for Temperatures Hybrid Experiment
		512	'''
		513
		514	CODE = 'temps_LP'
		515	plot_name = 'Temperatures'
		516	plot_type = 'scatterbuffer'
		517
		518
		519	def setup(self):
		520
		521	self.ncols = 1
		522	self.nrows = 1
		523	self.nplots = 1
		524	self.ylabel = 'Range [km]'
		525	self.xlabel = 'Temperature (K)'
		526	self.width = 3.5
		527	self.height = 6.5
		528	self.colorbar = False
		529	if not self.titles:
		530	self.titles = self.data.parameters \
		531	if self.data.parameters else ['{}'.format(self.CODE.upper())]
		532
		533	def plot(self):
		534
		535	self.x = self.data['temps_LP'][:,-1]
		536	self.y = self.data.heights[0:self.data.NACF]
		537	self.xmin = -100
		538	self.xmax = 4500
		539	ax = self.axes[0]
		540
		541	if ax.firsttime:
		542
		543	ax.errorbar(self.x, self.y, xerr=self.data.ete, fmt='r^',elinewidth=1.0,color='b',linewidth=2.0, label='Te')
		544	ax.errorbar(self.data.ti, self.y, fmt='k^', xerr=self.data.eti,elinewidth=1.0,color='b',linewidth=2.0, label='Ti')
		545	plt.legend(loc='lower right')
		546	self.ystep_given = 200
		547	ax.yaxis.set_minor_locator(MultipleLocator(15))
		548	ax.grid(which='minor')
		549	#plt.tight_layout()
		550
		551
		552	else:
		553	self.clear_figures()
		554	ax.errorbar(self.x, self.y, xerr=self.data.ete, fmt='r^',elinewidth=1.0,color='b',linewidth=2.0, label='Te')
		555	ax.errorbar(self.data.ti, self.y, fmt='k^', xerr=self.data.eti,elinewidth=1.0,color='b',linewidth=2.0, label='Ti')
		556	plt.legend(loc='lower right')
		557	ax.yaxis.set_minor_locator(MultipleLocator(15))
		558	#plt.tight_layout()
		559
		560
		561	class FracsHPPlot(Plot):
		562	'''
		563	Plot for Composition LP
		564	'''
		565
		566	CODE = 'fracs_LP'
		567	plot_name = 'Composition'
		568	plot_type = 'scatterbuffer'
		569
		570
		571	def setup(self):
		572
		573	self.ncols = 1
		574	self.nrows = 1
		575	self.nplots = 1
		576	self.ylabel = 'Range [km]'
		577	self.xlabel = 'Frac'
		578	self.width = 3.5
		579	self.height = 6.5
		580	self.colorbar = False
		581	if not self.titles:
		582	self.titles = self.data.parameters \
		583	if self.data.parameters else ['{}'.format(self.CODE.upper())]
		584
		585	def plot(self):
		586
		587	self.x = self.data['fracs_LP'][:,-1]
		588	self.y = self.data.heights[0:self.data.NACF]
		589
		590	self.xmin = 0
		591	self.xmax = 1
		592	ax = self.axes[0]
		593
		594	if ax.firsttime:
		595
		596	ax.errorbar(self.x, self.y[self.data.cut:], xerr=self.data.eph, fmt='r^',elinewidth=1.0,color='b',linewidth=2.0, label='H+')
		597	ax.errorbar(self.data.phe, self.y[self.data.cut:], fmt='k^', xerr=self.data.ephe,elinewidth=1.0,color='b',linewidth=2.0, label='He+')
		598	plt.legend(loc='lower right')
		599	self.xstep_given = 0.2
		600	self.ystep_given = 200
		601	ax.yaxis.set_minor_locator(MultipleLocator(15))
		602	ax.grid(which='minor')
		603	#plt.tight_layout()
		604
		605
		606	else:
		607	self.clear_figures()
		608	ax.errorbar(self.x, self.y[self.data.cut:], xerr=self.data.eph, fmt='r^',elinewidth=1.0,color='b',linewidth=2.0, label='H+')
		609	ax.errorbar(self.data.phe, self.y[self.data.cut:], fmt='k^', xerr=self.data.ephe,elinewidth=1.0,color='b',linewidth=2.0, label='He+')
		610	plt.legend(loc='lower right')
		611	ax.yaxis.set_minor_locator(MultipleLocator(15))
		612	#plt.tight_layout()
		613
		614
		615
		616	class EDensityPlot(Plot):
		617	'''
		618	Plot for electron density
		619	'''
		620
		621	CODE = 'den'
		622	plot_name = 'Electron Density'
		623	plot_type = 'scatterbuffer'
		624
		625
		626	def setup(self):
		627
		628	self.ncols = 1
		629	self.nrows = 1
		630	self.nplots = 1
		631	self.ylabel = 'Range [km]'
		632	self.xlabel = r'$\mathrm{N_e}$ Electron Density ($\mathrm{1/cm^3}$)'
		633	self.width = 4
		634	self.height = 6.5
		635	self.colorbar = False
		636	self.plots_adjust.update({'wspace': 0.8, 'hspace':0.2, 'left': 0.2, 'right': 0.9, 'bottom': 0.18})
		637	if not self.titles:
		638	self.titles = self.data.parameters \
		639	if self.data.parameters else ['{}'.format(self.CODE.upper())]
		640
		641	def plot(self):
		642
		643
		644	self.x = self.data[self.CODE]
		645	self.y = self.data.heights
		646	self.xmin = 1000
		647	self.xmax = 10000000
		648	ax = self.axes[0]
		649
		650	if ax.firsttime:
		651	self.autoxticks=False
		652	#if self.CODE=='den':
		653	ax.errorbar(self.data.dphi, self.y[:self.data.NSHTS], xerr=1, fmt='h-',elinewidth=1.0,color='g',linewidth=1.0, label='Faraday Profile',markersize=2)
		654	#ax.errorbar(self.data.dphi, self.y[:self.data.NSHTS], xerr=self.data.sdn1, fmt='h-',elinewidth=1.0,color='g',linewidth=1.0, label='Faraday Profile',markersize=2)
		655
		656	ax.errorbar(self.x[:,-1], self.y[:self.data.NSHTS], fmt='k^-', xerr=self.data.sdp2,elinewidth=1.0,color='b',linewidth=1.0, label='Power Profile',markersize=2)
		657	#else:
		658	#ax.errorbar(self.data.dphi[:self.data.cut], self.y[:self.data.cut], xerr=1, fmt='h-',elinewidth=1.0,color='g',linewidth=1.0, label='Faraday Profile',markersize=2)
		659	#ax.errorbar(self.x[:self.data.cut,-1], self.y[:self.data.cut], fmt='k^-', xerr=self.data.sdp2[:self.data.cut],elinewidth=1.0,color='b',linewidth=1.0, label='Power Profile',markersize=2)
		660
		661	if self.CODE=='denLP':
		662	ax.errorbar(self.data.ne[self.data.cut:], self.y[self.data.cut:], xerr=self.data.ene[self.data.cut:], fmt='r^-',elinewidth=1.0,color='r',linewidth=1.0, label='LP Profile',markersize=2)
		663
		664	plt.legend(loc='upper right')
		665	ax.set_xscale("log", nonposx='clip')
		666	grid_y_ticks=numpy.arange(numpy.nanmin(self.y),numpy.nanmax(self.y),50)
		667	self.ystep_given=100
		668	if self.CODE=='denLP':
		669	self.ystep_given=200
		670	ax.set_yticks(grid_y_ticks,minor=True)
		671	ax.grid(which='minor')
		672	#plt.tight_layout()
		673
		674
		675
		676	else:
		677
		678	self.clear_figures()
		679	#if self.CODE=='den':
		680	ax.errorbar(self.data.dphi, self.y[:self.data.NSHTS], xerr=1, fmt='h-',elinewidth=1.0,color='g',linewidth=1.0, label='Faraday Profile',markersize=2)
		681	#ax.errorbar(self.data.dphi, self.y[:self.data.NSHTS], xerr=self.data.sdn1, fmt='h-',elinewidth=1.0,color='g',linewidth=1.0, label='Faraday Profile',markersize=2)
		682
		683	ax.errorbar(self.x[:,-1], self.y[:self.data.NSHTS], fmt='k^-', xerr=self.data.sdp2,elinewidth=1.0,color='b',linewidth=1.0, label='Power Profile',markersize=2)
		684	ax.errorbar(self.x[:,-2], self.y[:self.data.NSHTS], elinewidth=1.0,color='r',linewidth=0.5,linestyle="dashed")
		685	#else:
		686	#ax.errorbar(self.data.dphi[:self.data.cut], self.y[:self.data.cut], xerr=1, fmt='h-',elinewidth=1.0,color='g',linewidth=1.0, label='Faraday Profile',markersize=2)
		687	#ax.errorbar(self.x[:self.data.cut,-1], self.y[:self.data.cut], fmt='k^-', xerr=self.data.sdp2[:self.data.cut],elinewidth=1.0,color='b',linewidth=1.0, label='Power Profile',markersize=2)
		688	#ax.errorbar(self.x[:self.data.cut,-2], self.y[:self.data.cut], elinewidth=1.0,color='r',linewidth=0.5,linestyle="dashed")
		689
		690	if self.CODE=='denLP':
		691	ax.errorbar(self.data.ne[self.data.cut:], self.y[self.data.cut:], fmt='r^-', xerr=self.data.ene[self.data.cut:],elinewidth=1.0,color='r',linewidth=1.0, label='LP Profile',markersize=2)
		692
		693	ax.set_xscale("log", nonposx='clip')
		694	grid_y_ticks=numpy.arange(numpy.nanmin(self.y),numpy.nanmax(self.y),50)
		695	ax.set_yticks(grid_y_ticks,minor=True)
		696	ax.grid(which='minor')
		697	plt.legend(loc='upper right')
		698	#plt.tight_layout()
		699
		700	class FaradayAnglePlot(Plot):
		701	'''
		702	Plot for electron density
		703	'''
		704
		705	CODE = 'FaradayAngle'
		706	plot_name = 'Faraday Angle'
		707	plot_type = 'scatterbuffer'
		708
		709
		710	def setup(self):
		711
		712	self.ncols = 1
		713	self.nrows = 1
		714	self.nplots = 1
		715	self.ylabel = 'Range [km]'
		716	self.xlabel = 'Faraday Angle (º)'
		717	self.width = 4
		718	self.height = 6.5
		719	self.colorbar = False
		720	if not self.titles:
		721	self.titles = self.data.parameters \
		722	if self.data.parameters else ['{}'.format(self.CODE.upper())]
		723
		724	def plot(self):
		725
		726
		727	self.x = self.data[self.CODE]
		728	self.y = self.data.heights
		729	self.xmin = -180
		730	self.xmax = 180
		731	ax = self.axes[0]
		732
		733	if ax.firsttime:
		734	self.autoxticks=False
		735	#if self.CODE=='den':
		736	ax.plot(self.x, self.y,marker='o',color='g',linewidth=1.0,markersize=2)
		737
		738	grid_y_ticks=numpy.arange(numpy.nanmin(self.y),numpy.nanmax(self.y),50)
		739	self.ystep_given=100
		740	if self.CODE=='denLP':
		741	self.ystep_given=200
		742	ax.set_yticks(grid_y_ticks,minor=True)
		743	ax.grid(which='minor')
		744	#plt.tight_layout()
		745	else:
		746
		747	self.clear_figures()
		748	#if self.CODE=='den':
		749	#print(numpy.shape(self.x))
		750	ax.plot(self.x[:,-1], self.y, marker='o',color='g',linewidth=1.0, markersize=2)
		751
		752	grid_y_ticks=numpy.arange(numpy.nanmin(self.y),numpy.nanmax(self.y),50)
		753	ax.set_yticks(grid_y_ticks,minor=True)
		754	ax.grid(which='minor')
		755
		756	class EDensityHPPlot(EDensityPlot):
		757
		758	'''
		759	Plot for Electron Density Hybrid Experiment
		760	'''
		761
		762	CODE = 'denLP'
		763	plot_name = 'Electron Density'
		764	plot_type = 'scatterbuffer'
		765
		766
		767	class ACFsPlot(Plot):
		768	'''
		769	Plot for ACFs Double Pulse Experiment
		770	'''
		771
		772	CODE = 'acfs'
		773	plot_name = 'ACF'
		774	plot_type = 'scatterbuffer'
		775
		776
		777	def setup(self):
		778	#self.xaxis = 'time'
		779	self.ncols = 1
		780	self.nrows = 1
		781	self.nplots = 1
		782	self.ylabel = 'Range [km]'
		783	self.xlabel = 'lags (ms)'
		784	self.width = 3.5
		785	self.height = 6
		786	self.colorbar = False
		787	self.plots_adjust.update({'wspace': 0.8, 'hspace':0.2, 'left': 0.2, 'right': 0.9, 'bottom': 0.18})
		788	if not self.titles:
		789	self.titles = self.data.parameters \
		790	if self.data.parameters else ['{}'.format(self.CODE.upper())]
		791
		792	def plot(self):
		793
		794	self.x = self.data.lags_to_plot
		795	self.y = self.data['acfs'][:,-1]
		796
		797
		798	self.xmin = 0.0
		799	self.xmax = 2.0
		800
		801	ax = self.axes[0]
		802
		803	if ax.firsttime:
		804
		805	for i in range(self.data.NSHTS):
		806	x_aux = numpy.isfinite(self.x[i,:])
		807	y_aux = numpy.isfinite(self.y[i,:])
		808	yerr_aux = numpy.isfinite(self.data.acfs_error_to_plot[i,:])
		809	x_igcej_aux = numpy.isfinite(self.data.x_igcej_to_plot[i,:])
		810	y_igcej_aux = numpy.isfinite(self.data.y_igcej_to_plot[i,:])
		811	x_ibad_aux = numpy.isfinite(self.data.x_ibad_to_plot[i,:])
		812	y_ibad_aux = numpy.isfinite(self.data.y_ibad_to_plot[i,:])
		813	if self.x[i,:][~numpy.isnan(self.x[i,:])].shape[0]>2:
		814	ax.errorbar(self.x[i,x_aux], self.y[i,y_aux], yerr=self.data.acfs_error_to_plot[i,x_aux],color='b',marker='o',linewidth=1.0,markersize=2)
		815	ax.plot(self.data.x_igcej_to_plot[i,x_igcej_aux],self.data.y_igcej_to_plot[i,y_igcej_aux],'x',color='red',markersize=2)
		816	ax.plot(self.data.x_ibad_to_plot[i,x_ibad_aux],self.data.y_ibad_to_plot[i,y_ibad_aux],'X',color='red',markersize=2)
		817
		818	self.xstep_given = (self.xmax-self.xmin)/(self.data.DPL-1)
		819	self.ystep_given = 50
		820	ax.yaxis.set_minor_locator(MultipleLocator(15))
		821	ax.grid(which='minor')
		822
		823
		824
		825	else:
		826	self.clear_figures()
		827
		828	for i in range(self.data.NSHTS):
		829	x_aux = numpy.isfinite(self.x[i,:])
		830	y_aux = numpy.isfinite(self.y[i,:])
		831	yerr_aux = numpy.isfinite(self.data.acfs_error_to_plot[i,:])
		832	x_igcej_aux = numpy.isfinite(self.data.x_igcej_to_plot[i,:])
		833	y_igcej_aux = numpy.isfinite(self.data.y_igcej_to_plot[i,:])
		834	x_ibad_aux = numpy.isfinite(self.data.x_ibad_to_plot[i,:])
		835	y_ibad_aux = numpy.isfinite(self.data.y_ibad_to_plot[i,:])
		836	if self.x[i,:][~numpy.isnan(self.x[i,:])].shape[0]>2:
		837	ax.errorbar(self.x[i,x_aux], self.y[i,y_aux], yerr=self.data.acfs_error_to_plot[i,x_aux],linewidth=1.0,markersize=2,color='b',marker='o')
		838	ax.plot(self.data.x_igcej_to_plot[i,x_igcej_aux],self.data.y_igcej_to_plot[i,y_igcej_aux],'x',color='red',markersize=2)
		839	ax.plot(self.data.x_ibad_to_plot[i,x_ibad_aux],self.data.y_ibad_to_plot[i,y_ibad_aux],'X',color='red',markersize=2)
		840	ax.yaxis.set_minor_locator(MultipleLocator(15))
		841
		842
		843
		844
		845	class ACFsLPPlot(Plot):
		846	'''
		847	Plot for ACFs Double Pulse Experiment
		848	'''
		849
		850	CODE = 'acfs_LP'
		851	plot_name = 'ACF'
		852	plot_type = 'scatterbuffer'
		853
		854
		855	def setup(self):
		856	#self.xaxis = 'time'
		857	self.ncols = 1
		858	self.nrows = 1
		859	self.nplots = 1
		860	self.ylabel = 'Range [km]'
		861	self.xlabel = 'lags (ms)'
		862	self.width = 3.5
		863	self.height = 7
		864	self.colorbar = False
		865	if not self.titles:
		866	self.titles = self.data.parameters \
		867	if self.data.parameters else ['{}'.format(self.CODE.upper())]
		868
		869
		870
		871	def plot(self):
		872
		873	self.x = self.data.lags_LP_to_plot
		874	self.y = self.data['acfs_LP'][:,-1]
		875
		876	self.xmin = 0.0
		877	self.xmax = 1.5
		878
		879	ax = self.axes[0]
		880
		881	if ax.firsttime:
		882
		883	for i in range(self.data.NACF):
		884	x_aux = numpy.isfinite(self.x[i,:])
		885	y_aux = numpy.isfinite(self.y[i,:])
		886	yerr_aux = numpy.isfinite(self.data.errors[i,:])
		887
		888	if self.x[i,:][~numpy.isnan(self.x[i,:])].shape[0]>2:
		889	ax.errorbar(self.x[i,x_aux], self.y[i,y_aux], yerr=self.data.errors[i,x_aux],color='b',linewidth=1.0,markersize=2,ecolor='r')
		890
		891	#self.xstep_given = (self.xmax-self.xmin)/(self.data.NLAG-1)
		892	self.xstep_given=0.3
		893	self.ystep_given = 200
		894	ax.yaxis.set_minor_locator(MultipleLocator(15))
		895	ax.grid(which='minor')
		896
		897	else:
		898	self.clear_figures()
		899
		900	for i in range(self.data.NACF):
		901	x_aux = numpy.isfinite(self.x[i,:])
		902	y_aux = numpy.isfinite(self.y[i,:])
		903	yerr_aux = numpy.isfinite(self.data.errors[i,:])
		904
		905	if self.x[i,:][~numpy.isnan(self.x[i,:])].shape[0]>2:
		906	ax.errorbar(self.x[i,x_aux], self.y[i,y_aux], yerr=self.data.errors[i,x_aux],color='b',linewidth=1.0,markersize=2,ecolor='r')
		907
		908	ax.yaxis.set_minor_locator(MultipleLocator(15))
		909
		910
		911	class CrossProductsPlot(Plot):
		912	'''
		913	Plot for cross products
		914	'''
		915
		916	CODE = 'crossprod'
		917	plot_name = 'Cross Products'
		918	plot_type = 'scatterbuffer'
		919
		920
		921	def setup(self):
		922
		923	self.ncols = 3
		924	self.nrows = 1
		925	self.nplots = 3
		926	self.ylabel = 'Range [km]'
		927
		928	self.width = 3.5*self.nplots
		929	self.height = 5.5
		930	self.colorbar = False
		931	self.titles = []
		932
		933	def plot(self):
		934
		935	self.x = self.data['crossprod'][:,-1,:,:,:,:]
		936
		937
		938
		939
		940	self.y = self.data.heights[0:self.data.NDP]
		941
		942
		943
		944	for n, ax in enumerate(self.axes):
		945
		946	self.xmin=numpy.min(numpy.concatenate((self.x[n][0,20:30,0,0],self.x[n][1,20:30,0,0],self.x[n][2,20:30,0,0],self.x[n][3,20:30,0,0])))
		947	self.xmax=numpy.max(numpy.concatenate((self.x[n][0,20:30,0,0],self.x[n][1,20:30,0,0],self.x[n][2,20:30,0,0],self.x[n][3,20:30,0,0])))
		948
		949
		950	if ax.firsttime:
		951
		952	self.autoxticks=False
		953	if n==0:
		954	label1='kax'
		955	label2='kay'
		956	label3='kbx'
		957	label4='kby'
		958	self.xlimits=[(self.xmin,self.xmax)]
		959	elif n==1:
		960	label1='kax2'
		961	label2='kay2'
		962	label3='kbx2'
		963	label4='kby2'
		964	self.xlimits.append((self.xmin,self.xmax))
		965	elif n==2:
		966	label1='kaxay'
		967	label2='kbxby'
		968	label3='kaxbx'
		969	label4='kaxby'
		970	self.xlimits.append((self.xmin,self.xmax))
		971
		972
		973	ax.plotline1 = ax.plot(self.x[n][0,:,0,0], self.y, color='r',linewidth=2.0, label=label1)
		974	ax.plotline2 = ax.plot(self.x[n][1,:,0,0], self.y, color='k',linewidth=2.0, label=label2)
		975	ax.plotline3 = ax.plot(self.x[n][2,:,0,0], self.y, color='b',linewidth=2.0, label=label3)
		976	ax.plotline4 = ax.plot(self.x[n][3,:,0,0], self.y, color='m',linewidth=2.0, label=label4)
		977	ax.legend(loc='upper right')
		978	ax.set_xlim(self.xmin, self.xmax)
		979	self.titles.append('{}'.format(self.plot_name.upper()))
		980	#plt.tight_layout()
		981
		982
		983	else:
		984
		985	if n==0:
		986	self.xlimits=[(self.xmin,self.xmax)]
		987	else:
		988	self.xlimits.append((self.xmin,self.xmax))
		989
		990	ax.set_xlim(self.xmin, self.xmax)
		991
		992
		993	ax.plotline1[0].set_data(self.x[n][0,:,0,0],self.y)
		994	ax.plotline2[0].set_data(self.x[n][1,:,0,0],self.y)
		995	ax.plotline3[0].set_data(self.x[n][2,:,0,0],self.y)
		996	ax.plotline4[0].set_data(self.x[n][3,:,0,0],self.y)
		997	self.titles.append('{}'.format(self.plot_name.upper()))
		998	#plt.tight_layout()
		999
		1000
		1001
		1002	class CrossProductsLPPlot(Plot):
		1003	'''
		1004	Plot for cross products LP
		1005	'''
		1006
		1007	CODE = 'crossprodlp'
		1008	plot_name = 'Cross Products LP'
		1009	plot_type = 'scatterbuffer'
		1010
		1011
		1012	def setup(self):
		1013
		1014	self.ncols = 2
		1015	self.nrows = 1
		1016	self.nplots = 2
		1017	self.ylabel = 'Range [km]'
		1018	self.xlabel = 'dB'
		1019	self.width = 3.5*self.nplots
		1020	self.height = 5.5
		1021	self.colorbar = False
		1022	self.titles = []
		1023	self.plotline_array=numpy.zeros((2,self.data.NLAG),dtype=object)
		1024	def plot(self):
		1025
		1026
		1027	self.x = self.data[self.CODE][:,-1,:,:]
		1028
		1029
		1030	self.y = self.data.heights[0:self.data.NRANGE]
		1031
		1032
		1033	label_array=numpy.array(['lag '+ str(x) for x in range(self.data.NLAG)])
		1034	color_array=['r','k','g','b','c','m','y','orange','steelblue','purple','peru','darksalmon','grey','limegreen','olive','midnightblue']
		1035
		1036
		1037	for n, ax in enumerate(self.axes):
		1038
		1039	self.xmin=30
		1040	self.xmax=70
		1041	#print(self.x[0,12:15,n])
		1042	#input()
		1043	#self.xmin=numpy.min(numpy.concatenate((self.x[0,:,n],self.x[1,:,n])))
		1044	#self.xmax=numpy.max(numpy.concatenate((self.x[0,:,n],self.x[1,:,n])))
		1045
		1046	#print("before",self.plotline_array)
		1047
		1048	if ax.firsttime:
		1049
		1050	self.autoxticks=False
		1051
		1052
		1053	for i in range(self.data.NLAG):
		1054	#print(i)
		1055	#print(numpy.shape(self.x))
		1056	self.plotline_array[n,i], = ax.plot(self.x[i,:,n], self.y, color=color_array[i],linewidth=1.0, label=label_array[i])
		1057	#ax.plotline1 = ax.plot(self.x[0,:,n], self.y, color='r',linewidth=2.0, label=label_array[0])
		1058	#ax.plotline2 = ax.plot(self.x[n][1,:,0,0], self.y, color='k',linewidth=2.0, label=label2)
		1059	#ax.plotline3 = ax.plot(self.x[n][2,:,0,0], self.y, color='b',linewidth=2.0, label=label3)
		1060	#ax.plotline4 = ax.plot(self.x[n][3,:,0,0], self.y, color='m',linewidth=2.0, label=label4)
		1061
		1062
		1063	#print(self.plotline_array)
		1064
		1065
		1066
		1067	ax.legend(loc='upper right')
		1068	ax.set_xlim(self.xmin, self.xmax)
		1069	if n==0:
		1070	self.titles.append('{} CH0'.format(self.plot_name.upper()))
		1071	if n==1:
		1072	self.titles.append('{} CH1'.format(self.plot_name.upper()))
		1073
		1074	#plt.tight_layout()
		1075
		1076	else:
		1077	#print(self.plotline_array)
		1078	for i in range(self.data.NLAG):
		1079
		1080	self.plotline_array[n,i].set_data(self.x[i,:,n],self.y)
		1081
		1082
		1083
		1084	#ax.plotline1[0].set_data(self.x[n][0,:,0,0],self.y)
		1085	#ax.plotline2[0].set_data(self.x[n][1,:,0,0],self.y)
		1086	#ax.plotline3[0].set_data(self.x[n][2,:,0,0],self.y)
		1087	#ax.plotline4[0].set_data(self.x[n][3,:,0,0],self.y)
		1088
		1089	if n==0:
		1090	self.titles.append('{} CH0'.format(self.plot_name.upper()))
		1091	if n==1:
		1092	self.titles.append('{} CH1'.format(self.plot_name.upper()))
		1093
		1094	#plt.tight_layout()
		1095
		1096
		1097	class NoiseDPPlot(NoisePlot):
		1098	'''
		1099	Plot for noise Double Pulse
		1100	'''
		1101
		1102	CODE = 'noisedp'
		1103	plot_name = 'Noise'
		1104	plot_type = 'scatterbuffer'
		1105
		1106
		1107	class XmitWaveformPlot(Plot):
		1108	'''
		1109	Plot for xmit waveform
		1110	'''
		1111
		1112	CODE = 'xmit'
		1113	plot_name = 'Xmit Waveform'
		1114	plot_type = 'scatterbuffer'
		1115
		1116
		1117	def setup(self):
		1118
		1119	self.ncols = 1
		1120	self.nrows = 1
		1121	self.nplots = 1
		1122	self.ylabel = ''
		1123	self.xlabel = 'Number of Lag'
		1124	self.width = 5.5
		1125	self.height = 3.5
		1126	self.colorbar = False
		1127	if not self.titles:
		1128	self.titles = self.data.parameters \
		1129	if self.data.parameters else ['{}'.format(self.plot_name.upper())]
		1130
		1131	def plot(self):
		1132
		1133	self.x = numpy.arange(0,self.data.NLAG,1,'float32')
		1134	self.y = self.data['xmit'][:,-1,:]
		1135
		1136	self.xmin = 0
		1137	self.xmax = self.data.NLAG-1
		1138	self.ymin = -1.0
		1139	self.ymax = 1.0
		1140	ax = self.axes[0]
		1141
		1142	if ax.firsttime:
		1143	ax.plotline0=ax.plot(self.x,self.y[0,:],color='blue')
		1144	ax.plotline1=ax.plot(self.x,self.y[1,:],color='red')
		1145	secax=ax.secondary_xaxis(location=0.5)
		1146	secax.xaxis.tick_bottom()
		1147	secax.tick_params( labelleft=False, labeltop=False,
		1148	labelright=False, labelbottom=False)
		1149
		1150	self.xstep_given = 3
		1151	self.ystep_given = .25
		1152	secax.set_xticks(numpy.linspace(self.xmin, self.xmax, 6)) #only works on matplotlib.version>3.2
		1153
		1154	else:
		1155	ax.plotline0[0].set_data(self.x,self.y[0,:])
		1156	ax.plotline1[0].set_data(self.x,self.y[1,:])

schainpy/model/io/jroIO_dat.py created 644 +683 0

This diff has been collapsed as it changes many lines, (683 lines changed) Show them Hide them
	@@ -0,0 +1,683
		1	'''
		2	Created on Jun 9, 2020
		3
		4	@author: Roberto Flores
		5	'''
		6
		7	import os
		8	import sys
		9	import time
		10
		11	import struct
		12
		13
		14	import datetime
		15
		16	import numpy
		17
		18
		19	import schainpy.admin
		20	from schainpy.model.io.jroIO_base import LOCALTIME, Reader
		21	from schainpy.model.data.jroheaderIO import BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
		22	from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
		23	from schainpy.model.data.jrodata import Voltage, Parameters
		24	from schainpy.utils import log
		25
		26
		27	class DatReader(Reader, ProcessingUnit):
		28
		29	def __init__(self):
		30
		31	ProcessingUnit.__init__(self)
		32	self.basicHeaderObj = BasicHeader(LOCALTIME)
		33	self.systemHeaderObj = SystemHeader()
		34	self.radarControllerHeaderObj = RadarControllerHeader()
		35	self.processingHeaderObj = ProcessingHeader()
		36	self.dataOut = Parameters()
		37	#print(self.basicHeaderObj.timezone)
		38	#self.counter_block=0
		39	self.format='dat'
		40	self.flagNoMoreFiles = 0
		41	self.filename = None
		42	self.intervals = set()
		43	#self.datatime = datetime.datetime(1900,1,1)
		44
		45	self.filefmt = "*%Y%m%d*****"
		46
		47	self.padding=numpy.zeros(1,'int32')
		48	self.hsize=numpy.zeros(1,'int32')
		49	self.bufsize=numpy.zeros(1,'int32')
		50	self.nr=numpy.zeros(1,'int32')
		51	self.ngates=numpy.zeros(1,'int32') ### ### ### 2
		52	self.time1=numpy.zeros(1,'uint64') # pos 3
		53	self.time2=numpy.zeros(1,'uint64') # pos 4
		54	self.lcounter=numpy.zeros(1,'int32')
		55	self.groups=numpy.zeros(1,'int32')
		56	self.system=numpy.zeros(4,'int8') # pos 7
		57	self.h0=numpy.zeros(1,'float32')
		58	self.dh=numpy.zeros(1,'float32')
		59	self.ipp=numpy.zeros(1,'float32')
		60	self.process=numpy.zeros(1,'int32')
		61	self.tx=numpy.zeros(1,'int32')
		62
		63	self.ngates1=numpy.zeros(1,'int32') ### ### ### 13
		64	self.time0=numpy.zeros(1,'uint64') # pos 14
		65	self.nlags=numpy.zeros(1,'int32')
		66	self.nlags1=numpy.zeros(1,'int32')
		67	self.txb=numpy.zeros(1,'float32') ### ### ### 17
		68	self.time3=numpy.zeros(1,'uint64') # pos 18
		69	self.time4=numpy.zeros(1,'uint64') # pos 19
		70	self.h0_=numpy.zeros(1,'float32')
		71	self.dh_=numpy.zeros(1,'float32')
		72	self.ipp_=numpy.zeros(1,'float32')
		73	self.txa_=numpy.zeros(1,'float32')
		74
		75	self.pad=numpy.zeros(100,'int32')
		76
		77	self.nbytes=numpy.zeros(1,'int32')
		78	self.limits=numpy.zeros(1,'int32')
		79	self.ngroups=numpy.zeros(1,'int32') ### ### ### 27
		80	#Make the header list
		81	#header=[hsize,bufsize,nr,ngates,time1,time2,lcounter,groups,system,h0,dh,ipp,process,tx,padding,ngates1,time0,nlags,nlags1,padding,txb,time3,time4,h0_,dh_,ipp_,txa_,pad,nbytes,limits,padding,ngroups]
		82	self.header=[self.hsize,self.bufsize,self.nr,self.ngates,self.time1,self.time2,self.lcounter,self.groups,self.system,self.h0,self.dh,self.ipp,self.process,self.tx,self.ngates1,self.padding,self.time0,self.nlags,self.nlags1,self.padding,self.txb,self.time3,self.time4,self.h0_,self.dh_,self.ipp_,self.txa_,self.pad,self.nbytes,self.limits,self.padding,self.ngroups]
		83
		84
		85
		86	def setup(self, **kwargs):
		87
		88	self.set_kwargs(**kwargs)
		89
		90
		91	if self.path is None:
		92	raise ValueError('The path is not valid')
		93
		94	self.open_file = open
		95	self.open_mode = 'rb'
		96
		97
		98
		99	if self.format is None:
		100	raise ValueError('The format is not valid')
		101	elif self.format.lower() in ('dat'):
		102	self.ext = '.dat'
		103	elif self.format.lower() in ('out'):
		104	self.ext = '.out'
		105
		106
		107	log.log("Searching files in {}".format(self.path), self.name)
		108	self.filenameList = self.searchFilesOffLine(self.path, self.startDate,
		109	self.endDate, self.expLabel, self.ext, self.walk, self.filefmt, self.folderfmt)
		110	#print(self.path)
		111	#print(self.filenameList)
		112	#input()
		113
		114
		115	self.setNextFile()
		116
		117	def readFirstHeader(self):
		118	'''Read header and data'''
		119
		120	#self.flag_same_file=1
		121	self.counter_block=0
		122	self.parseHeader()
		123	self.parseData()
		124	self.blockIndex = 0
		125
		126	return
		127
		128	def parseHeader(self):
		129	'''
		130	'''
		131
		132	for i in range(len(self.header)):
		133	for j in range(len(self.header[i])):
		134	#print("len(header[i]) ",len(header[i]))
		135	#input()
		136	temp=self.fp.read(int(self.header[i].itemsize))
		137	if isinstance(self.header[i][0], numpy.int32):
		138	#print(struct.unpack('i', temp)[0])
		139	self.header[i][0]=struct.unpack('i', temp)[0]
		140	if isinstance(self.header[i][0], numpy.uint64):
		141	self.header[i][0]=struct.unpack('q', temp)[0]
		142	if isinstance(self.header[i][0], numpy.int8):
		143	self.header[i][0]=struct.unpack('B', temp)[0]
		144	if isinstance(self.header[i][0], numpy.float32):
		145	self.header[i][0]=struct.unpack('f', temp)[0]
		146
		147	self.fp.seek(0,0)
		148	if int(self.header[1][0])==int(81864):
		149	self.experiment='DP'
		150
		151	elif int(self.header[1][0])==int(185504):
		152	self.experiment='HP'
		153
		154
		155	self.total_blocks=os.stat(self.filename).st_size//self.header[1][0]
		156
		157
		158	def parseData(self):
		159	'''
		160	'''
		161	if self.experiment=='DP':
		162	self.header[15][0]=66
		163	self.header[18][0]=16
		164	self.header[17][0]=11
		165	self.header[2][0]=2
		166
		167
		168	self.noise=numpy.zeros(self.header[2][0],'float32') #self.header[2][0]
		169	#tmpx=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32')
		170	self.kax=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32')
		171	self.kay=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32')
		172	self.kbx=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32')
		173	self.kby=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32')
		174	self.kax2=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32')
		175	self.kay2=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32')
		176	self.kbx2=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32')
		177	self.kby2=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32')
		178	self.kaxbx=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32')
		179	self.kaxby=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32')
		180	self.kaybx=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32')
		181	self.kayby=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32')
		182	self.kaxay=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32')
		183	self.kbxby=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32')
		184	self.output_LP_real=numpy.zeros((self.header[18][0],200,self.header[2][0]),'float32')
		185	self.output_LP_imag=numpy.zeros((self.header[18][0],200,self.header[2][0]),'float32')
		186	self.final_cross_products=[self.kax,self.kay,self.kbx,self.kby,self.kax2,self.kay2,self.kbx2,self.kby2,self.kaxbx,self.kaxby,self.kaybx,self.kayby,self.kaxay,self.kbxby]
		187	#self.final_cross_products=[tmpx,tmpx,tmpx,tmpx,tmpx,tmpx,tmpx,tmpx,tmpx,tmpx,tmpx,tmpx,tmpx,tmpx]
		188
		189	#print("pos: ",self.fp.tell())
		190
		191
		192	def readNextBlock(self):
		193
		194	while True:
		195	self.flagDiscontinuousBlock = 0
		196	#print(os.stat(self.filename).st_size)
		197	#print(os.stat(self.filename).st_size//self.header[1][0])
		198	#os.stat(self.fp)
		199	if self.counter_block == self.total_blocks:
		200
		201	self.setNextFile()
		202
		203	self.readBlock()
		204	#self.counter_block+=1
		205
		206	if (self.datatime < datetime.datetime.combine(self.startDate, self.startTime)) or \
		207	(self.datatime > datetime.datetime.combine(self.endDate, self.endTime)):
		208
		209	#print(self.datatime)
		210	#print(datetime.datetime.combine(self.startDate, self.startTime))
		211	#print(datetime.datetime.combine(self.endDate, self.endTime))
		212	#print("warning")
		213	log.warning(
		214	'Reading Block No. {}/{} -> {} [Skipping]'.format(
		215	self.counter_block,
		216	self.total_blocks,
		217	self.datatime.ctime()),
		218	'DATReader')
		219	continue
		220	break
		221
		222	log.log(
		223	'Reading Block No. {}/{} -> {}'.format(
		224	self.counter_block,
		225	self.total_blocks,
		226	self.datatime.ctime()),
		227	'DATReader')
		228
		229	return 1
		230
		231	def readBlock(self):
		232	'''
		233	'''
		234
		235	self.npos=self.counter_block*self.header[1][0]
		236	#print(self.counter_block)
		237	self.fp.seek(self.npos, 0)
		238	self.counter_block+=1
		239	#print("fpos1: ",self.fp.tell())
		240
		241	self.read_header()
		242
		243	#put by hand because old files didn't save it in the header
		244	if self.experiment=='DP':
		245	self.header[15][0]=66
		246	self.header[18][0]=16
		247	self.header[17][0]=11
		248	self.header[2][0]=2
		249	#########################################
		250
		251	if self.experiment=="HP":
		252	self.long_pulse_products()
		253
		254	self.read_cross_products()
		255
		256
		257	self.read_noise()
		258
		259
		260	return
		261
		262
		263
		264	def read_header(self):
		265
		266
		267	for i in range(len(self.header)):
		268	for j in range(len(self.header[i])):
		269	#print("len(header[i]) ",len(header[i]))
		270	#input()
		271	temp=self.fp.read(int(self.header[i].itemsize))
		272	#if(b''==temp):
		273	# self.setNextFile()
		274	# self.flag_same_file=0
		275	if isinstance(self.header[i][0], numpy.int32):
		276	#print(struct.unpack('i', temp)[0])
		277	self.header[i][0]=struct.unpack('i', temp)[0]
		278	if isinstance(self.header[i][0], numpy.uint64):
		279	self.header[i][0]=struct.unpack('q', temp)[0]
		280	if isinstance(self.header[i][0], numpy.int8):
		281	self.header[i][0]=struct.unpack('B', temp)[0]
		282	if isinstance(self.header[i][0], numpy.float32):
		283	self.header[i][0]=struct.unpack('f', temp)[0]
		284	#else:
		285	# continue
		286	#self.fp.seek(self.npos_aux, 0)
		287	# break
		288
		289	#print("fpos2: ",self.fp.tell())
		290	#log.success('Parameters found: {}'.format(self.parameters),
		291	# 'DATReader')
		292	#print("Success")
		293	#self.TimeBlockSeconds_for_dp_power = self.header[4][0]#-((self.dataOut.nint-1)self.dataOut.NAVG2)
		294	#print(dataOut.TimeBlockSeconds_for_dp_power)
		295
		296	#self.datatime=datetime.datetime.fromtimestamp(self.header[4][0]).strftime("%Y-%m-%d %H:%M:%S")
		297	#print(self.header[4][0])
		298	self.datatime=datetime.datetime.fromtimestamp(self.header[4][0])
		299	#print(self.header[1][0])
		300
		301	def long_pulse_products(self):
		302	temp=self.fp.read(self.header[18][0]self.header[2][0]200*8)
		303	ii=0
		304
		305	for l in range(self.header[18][0]): #lag
		306	for r in range(self.header[2][0]): # channels
		307	for k in range(200): #RANGE## generalizar
		308	self.output_LP_real[l,k,r]=struct.unpack('f', temp[ii:ii+4])[0]
		309	ii=ii+4
		310	self.output_LP_imag[l,k,r]=struct.unpack('f', temp[ii:ii+4])[0]
		311	ii=ii+4
		312
		313	#print(self.output_LP_real[1,1,1])
		314	#print(self.output_LP_imag[1,1,1])
		315	def read_cross_products(self):
		316
		317	for ind in range(len(self.final_cross_products)): #final cross products
		318	temp=self.fp.read(self.header[17][0]2self.header[15][0]4) #4 bytes
		319	#if(b''==temp):
		320	# self.setNextFile()
		321	# self.flag_same_file=0
		322	ii=0
		323	#print("kabxys.shape ",kabxys.shape)
		324	#print(kabxys)
		325	#print("fpos3: ",self.fp.tell())
		326	for l in range(self.header[17][0]): #lag
		327	#print("fpos3: ",self.fp.tell())
		328	for fl in range(2): # unflip and flip
		329	for k in range(self.header[15][0]): #RANGE
		330	#print("fpos3: ",self.fp.tell())
		331	self.final_cross_products[ind][k,l,fl]=struct.unpack('f', temp[ii:ii+4])[0]
		332	ii=ii+4
		333	#print("fpos2: ",self.fp.tell())
		334
		335
		336
		337	def read_noise(self):
		338
		339	temp=self.fp.read(self.header[2][0]4) #4 bytes self.header[2][0]
		340	for ii in range(self.header[2][0]): #self.header[2][0]
		341	self.noise[ii]=struct.unpack('f', temp[ii4:(ii+1)4])[0]
		342
		343	#print("fpos5: ",self.fp.tell())
		344
		345
		346
		347	def set_output(self):
		348	'''
		349	Storing data from buffer to dataOut object
		350	'''
		351	#print("fpos2: ",self.fp.tell())
		352	##self.dataOut.header = self.header
		353	#this is put by hand because it isn't saved in the header
		354	if self.experiment=='DP':
		355	self.dataOut.NRANGE=0
		356	self.dataOut.NSCAN=132
		357	self.dataOut.heightList=self.header[10][0]*(numpy.arange(self.header[15][0]))
		358	elif self.experiment=='HP':
		359	self.dataOut.output_LP=self.output_LP_real+1.j*self.output_LP_imag
		360	self.dataOut.NRANGE=200
		361	self.dataOut.NSCAN=128
		362	self.dataOut.heightList=self.header[10][0]*(numpy.arange(90)) #NEEEDS TO BE GENERALIZED
		363	#########################################
		364	#print(self.dataOut.output_LP[1,1,1])
		365	self.dataOut.MAXNRANGENDT=self.header[3][0]
		366	self.dataOut.NDP=self.header[15][0]
		367	self.dataOut.DPL=self.header[17][0]
		368	self.dataOut.DH=self.header[10][0]
		369	self.dataOut.NAVG=self.header[7][0]
		370	self.dataOut.H0=self.header[9][0]
		371	self.dataOut.NR=self.header[2][0]
		372	self.dataOut.NLAG=self.header[18][0]
		373	#self.dataOut.tmpx=self.tmpx
		374	#self.dataOut.timeZone = 5
		375	#self.dataOut.final_cross_products=self.final_cross_products
		376	self.dataOut.kax=self.kax
		377	#print(self.dataOut.kax[1,1,1])
		378	self.dataOut.kay=self.kay
		379	self.dataOut.kbx=self.kbx
		380	self.dataOut.kby=self.kby
		381	self.dataOut.kax2=self.kax2
		382	self.dataOut.kay2=self.kay2
		383	self.dataOut.kbx2=self.kbx2
		384	self.dataOut.kby2=self.kby2
		385	self.dataOut.kaxbx=self.kaxbx
		386	self.dataOut.kaxby=self.kaxby
		387	self.dataOut.kaybx=self.kaybx
		388	self.dataOut.kayby=self.kayby
		389	self.dataOut.kaxay=self.kaxay
		390	self.dataOut.kbxby=self.kbxby
		391	self.dataOut.noise_final=self.noise
		392	#print("NOISE",self.noise)
		393
		394
		395	self.dataOut.useLocalTime=True
		396
		397	#self.dataOut.experiment=self.experiment
		398	#print(self.datatime)
		399	#print(self.dataOut.datatime)
		400
		401
		402	#self.dataOut.utctime = (self.datatime - datetime.datetime(1970, 1, 1)).total_seconds()
		403	#self.dataOut.utctimeInit = self.dataOut.utctime
		404
		405
		406
		407	self.dataOut.lt=self.datatime.hour
		408
		409
		410	#print(RadarControllerHeader().ippSeconds)
		411	#print(RadarControllerHeader().ipp)
		412	#self.dataOut.utctime=time.gmtime(self.header[4][0])- datetime.datetime(1970, 1, 1)
		413	#self.dataOut.utctime=self.dataOut.utctime.total_seconds()
		414	#time1 = self.header[4][0] # header.time1
		415	#print("time1: ",time1)
		416	#print(self.header[4][0])
		417	#date = time.ctime(time1)
		418	#print("DADSADA",time.strptime(date))
		419	#print("date_before: ",date)
		420	#bd_time=time.gmtime(time1)
		421	#print(time.mktime(bd_time))
		422	#self.dataOut.utctime=time.mktime(bd_time)
		423	self.dataOut.utctime = self.header[4][0]
		424	#self.dataOut.datatime=a
		425	#print(datetime.datetime.utcfromtimestamp(self.dataOut.utctime))
		426	#self.dataOut.TimeBlockDate=self.datatime.ctime()
		427	self.dataOut.TimeBlockSeconds=time.mktime(time.strptime(self.dataOut.datatime.ctime()))
		428
		429	#self.dataOut.heightList = self.ranges
		430	#self.dataOut.utctime = (self.datatime - datetime.datetime(1970, 1, 1)).total_seconds()
		431	#self.dataOut.utctimeInit = self.dataOut.utctime
		432	#self.dataOut.paramInterval = min(self.intervals)
		433	#self.dataOut.useLocalTime = False
		434	self.dataOut.flagNoData = False
		435	self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock
		436	#print(self.dataOut.channelIndexList)
		437	self.dataOut.channelList=list(range(0,self.header[2][0]))
		438	#print(self.dataOut.channelList)
		439	#print(self.datatime)
		440	#print(self.dataOut.final_cross_products[0])
		441
		442
		443	#self.dataOut.heightList=self.header[10][0]*(numpy.arange(self.header[15][0]))
		444
		445	#print(numpy.shape(self.dataOut.heightList))
		446
		447
		448	def getData(self):
		449	'''
		450	Storing data from databuffer to dataOut object
		451	'''
		452
		453	if not self.readNextBlock():
		454	self.dataOut.flagNoData = True
		455	return 0
		456
		457	self.set_output()
		458
		459	return 1
		460
		461	def run(self, **kwargs):
		462
		463	if not(self.isConfig):
		464	self.setup(**kwargs)
		465	self.isConfig = True
		466	#print("fpos1: ",self.fp.tell())
		467	self.getData()
		468
		469	return
		470
		471	@MPDecorator
		472	class DatWriter(Operation):
		473
		474
		475	def __init__(self):
		476
		477	Operation.__init__(self)
		478	#self.dataOut = Voltage()
		479	self.counter = 0
		480	self.path = None
		481	self.fp = None
		482	return
		483	#self.ext= '.dat'
		484
		485	def run(self, dataOut, path, format='dat', experiment=None, **kwargs):
		486	print(dataOut.flagNoData)
		487	print(dataOut.datatime.ctime())
		488	print(dataOut.TimeBlockDate)
		489	input()
		490	#if dataOut.flag_save:
		491	self.experiment=experiment
		492	self.path=path
		493	if self.experiment=='DP':
		494	dataOut.header[1][0]=81864
		495	elif self.experiment=='HP':
		496	dataOut.header[1][0]=185504#173216
		497	#dataOut.header[1][0]=bufsize
		498	self.dataOut = dataOut
		499	#print(self.dataOut.nint)
		500	#self.bufsize=bufsize
		501	if format == 'dat':
		502	self.ext = '.dat'
		503	if format == 'out':
		504	self.ext = '.out'
		505	self.putData()
		506
		507	return
		508
		509
		510
		511	def setFile(self):
		512	'''
		513	Create new out file object
		514	'''
		515
		516	#self.dataOut.TimeBlockSeconds=time.mktime(time.strptime(self.dataOut.TimeBlockDate))
		517	date = datetime.datetime.fromtimestamp(self.dataOut.TimeBlockSeconds)
		518
		519	#print("date",date)
		520
		521	filename = '{}{}{}'.format('jro',
		522	date.strftime('%Y%m%d_%H%M%S'),
		523	self.ext)
		524	#print(filename)
		525	#print(self.path)
		526
		527	self.fullname = os.path.join(self.path, filename)
		528
		529	if os.path.isfile(self.fullname) :
		530	log.warning(
		531	'Destination file {} already exists, previous file deleted.'.format(
		532	self.fullname),
		533	'DatWriter')
		534	os.remove(self.fullname)
		535
		536	try:
		537	log.success(
		538	'Creating file: {}'.format(self.fullname),
		539	'DatWriter')
		540	if not os.path.exists(self.path):
		541	os.makedirs(self.path)
		542	#self.fp = madrigal.cedar.MadrigalCedarFile(self.fullname, True)
		543	self.fp = open(self.fullname,'wb')
		544
		545	except ValueError as e:
		546	log.error(
		547	'Impossible to create *.out file',
		548	'DatWriter')
		549	return
		550
		551	return 1
		552
		553	def writeBlock(self):
		554
		555	#self.dataOut.paramInterval=2
		556	#startTime = datetime.datetime.utcfromtimestamp(self.dataOut.utctime)
		557	#print(startTime)
		558	#endTime = startTime + datetime.timedelta(seconds=self.dataOut.paramInterval)
		559
		560	self.dataOut.header[0].astype('int32').tofile(self.fp)
		561	self.dataOut.header[1].astype('int32').tofile(self.fp)
		562	self.dataOut.header[2].astype('int32').tofile(self.fp)
		563	self.dataOut.header[3].astype('int32').tofile(self.fp)
		564	self.dataOut.header[4].astype('uint64').tofile(self.fp)
		565	self.dataOut.header[5].astype('uint64').tofile(self.fp)
		566	self.dataOut.header[6].astype('int32').tofile(self.fp)
		567	self.dataOut.header[7].astype('int32').tofile(self.fp)
		568	#print(dataOut.header[7])
		569	self.dataOut.header[8].astype('int8').tofile(self.fp)
		570	self.dataOut.header[9].astype('float32').tofile(self.fp)
		571	self.dataOut.header[10].astype('float32').tofile(self.fp)
		572	self.dataOut.header[11].astype('float32').tofile(self.fp)
		573	self.dataOut.header[12].astype('int32').tofile(self.fp)
		574	self.dataOut.header[13].astype('int32').tofile(self.fp)
		575	self.dataOut.header[14].astype('int32').tofile(self.fp)
		576	self.dataOut.header[15].astype('int32').tofile(self.fp)
		577	self.dataOut.header[16].astype('uint64').tofile(self.fp)
		578	self.dataOut.header[17].astype('int32').tofile(self.fp)
		579	self.dataOut.header[18].astype('int32').tofile(self.fp)
		580	self.dataOut.header[19].astype('int32').tofile(self.fp)
		581	self.dataOut.header[20].astype('float32').tofile(self.fp)
		582	self.dataOut.header[21].astype('uint64').tofile(self.fp)
		583	self.dataOut.header[22].astype('uint64').tofile(self.fp)
		584	self.dataOut.header[23].astype('float32').tofile(self.fp)
		585	self.dataOut.header[24].astype('float32').tofile(self.fp)
		586	self.dataOut.header[25].astype('float32').tofile(self.fp)
		587	self.dataOut.header[26].astype('float32').tofile(self.fp)
		588	self.dataOut.header[27].astype('int32').tofile(self.fp)
		589	self.dataOut.header[28].astype('int32').tofile(self.fp)
		590	self.dataOut.header[29].astype('int32').tofile(self.fp)
		591	self.dataOut.header[30].astype('int32').tofile(self.fp)
		592	self.dataOut.header[31].astype('int32').tofile(self.fp)
		593	#print("tell before 1 ",self.fp.tell())
		594	#input()
		595
		596	if self.experiment=="HP":
		597	#print("INSIDE")
		598	#tmp=numpy.zeros(1,dtype='complex64')
		599	#print("tmp ",tmp)
		600	#input()
		601	#print(dataOut.NLAG)
		602	#print(dataOut.NR)
		603	#print(dataOut.NRANGE)
		604	for l in range(self.dataOut.NLAG): #lag
		605	for r in range(self.dataOut.NR): # unflip and flip
		606	for k in range(self.dataOut.NRANGE): #RANGE
		607	self.dataOut.output_LP.real[l,k,r].astype('float32').tofile(self.fp)
		608	self.dataOut.output_LP.imag[l,k,r].astype('float32').tofile(self.fp)
		609
		610
		611	#print("tell before 2 ",self.outputfile.tell())
		612
		613
		614
		615
		616
		617	#print(self.dataOut.output_LP[1,1,1])
		618
		619	#print(self.dataOut.kax)
		620	final_cross_products=[self.dataOut.kax,self.dataOut.kay,self.dataOut.kbx,self.dataOut.kby,
		621	self.dataOut.kax2,self.dataOut.kay2,self.dataOut.kbx2,self.dataOut.kby2,
		622	self.dataOut.kaxbx,self.dataOut.kaxby,self.dataOut.kaybx,self.dataOut.kayby,
		623	self.dataOut.kaxay,self.dataOut.kbxby]
		624
		625	#print(self.dataOut.kax)
		626	#print("tell before crossp saving ",self.outputfile.tell())
		627	for kabxys in final_cross_products:
		628
		629	for l in range(self.dataOut.DPL): #lag
		630	for fl in range(2): # unflip and flip
		631	for k in range(self.dataOut.NDT): #RANGE
		632	kabxys[k,l,fl].astype('float32').tofile(self.fp)
		633
		634
		635	#print("tell before noise saving ",self.outputfile.tell())
		636
		637
		638	for nch in range(self.dataOut.NR):
		639	self.dataOut.noise_final[nch].astype('float32').tofile(self.fp)
		640
		641	#print("tell before noise saving ",self.fp.tell())
		642	#input()
		643
		644
		645
		646
		647	log.log(
		648	'Writing {} blocks'.format(
		649	self.counter+1),
		650	'DatWriter')
		651
		652
		653
		654
		655
		656
		657	def putData(self):
		658	#print("flagNoData",self.dataOut.flagNoData)
		659	#print("flagDiscontinuousBlock",self.dataOut.flagDiscontinuousBlock)
		660	#print(self.dataOut.flagNoData)
		661
		662	if self.dataOut.flagNoData:
		663	return 0
		664
		665	if self.dataOut.flagDiscontinuousBlock:
		666
		667	self.counter = 0
		668
		669	if self.counter == 0:
		670	self.setFile()
		671	#if self.experiment=="HP":
		672	#if self.dataOut.debris_activated==0:
		673	#self.writeBlock()
		674	#self.counter += 1
		675	#else:
		676	self.writeBlock()
		677	self.counter += 1
		678
		679	def close(self):
		680
		681	if self.counter > 0:
		682	self.fp.close()
		683	log.success('Closing file {}'.format(self.fullname), 'DatWriter')

schainpy/model/proc/jroproc_voltage_lags.py created 644 0 0

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

schainpy/model/data/jrodata.py +401 -2

             # Copyright (c) 2012-2020 Jicamarca Radio Observatory
             # All rights reserved.
             #
             # Distributed under the terms of the BSD 3-clause license.
             """Definition of diferent Data objects for different types of data
             Here you will find the diferent data objects for the different types
             of data, this data objects must be used as dataIn or dataOut objects in
             processing units and operations. Currently the supported data objects are:
             Voltage, Spectra, SpectraHeis, Fits, Correlation and Parameters
             """
             import copy
             import numpy
             import datetime
             import json
             import schainpy.admin
             from schainpy.utils import log
             from .jroheaderIO import SystemHeader, RadarControllerHeader
             from schainpy.model.data import _noise
             def getNumpyDtype(dataTypeCode):
                 if dataTypeCode == 0:
                     numpyDtype = numpy.dtype([('real', '<i1'), ('imag', '<i1')])
                 elif dataTypeCode == 1:
                     numpyDtype = numpy.dtype([('real', '<i2'), ('imag', '<i2')])
                 elif dataTypeCode == 2:
                     numpyDtype = numpy.dtype([('real', '<i4'), ('imag', '<i4')])
                 elif dataTypeCode == 3:
                     numpyDtype = numpy.dtype([('real', '<i8'), ('imag', '<i8')])
                 elif dataTypeCode == 4:
                     numpyDtype = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
                 elif dataTypeCode == 5:
                     numpyDtype = numpy.dtype([('real', '<f8'), ('imag', '<f8')])
                 else:
                     raise ValueError('dataTypeCode was not defined')
                 return numpyDtype
             def getDataTypeCode(numpyDtype):
                 if numpyDtype == numpy.dtype([('real', '<i1'), ('imag', '<i1')]):
                     datatype = 0
                 elif numpyDtype == numpy.dtype([('real', '<i2'), ('imag', '<i2')]):
                     datatype = 1
                 elif numpyDtype == numpy.dtype([('real', '<i4'), ('imag', '<i4')]):
                     datatype = 2
                 elif numpyDtype == numpy.dtype([('real', '<i8'), ('imag', '<i8')]):
                     datatype = 3
                 elif numpyDtype == numpy.dtype([('real', '<f4'), ('imag', '<f4')]):
                     datatype = 4
                 elif numpyDtype == numpy.dtype([('real', '<f8'), ('imag', '<f8')]):
                     datatype = 5
                 else:
                     datatype = None
                 return datatype
             def hildebrand_sekhon(data, navg):
                 """
                 This method is for the objective determination of the noise level in Doppler spectra. This
                 implementation technique is based on the fact that the standard deviation of the spectral
                 densities is equal to the mean spectral density for white Gaussian noise
                 Inputs:
                     Data    :    heights
                     navg    :    numbers of averages
                 Return:
                     mean    :    noise's level
                 """
                 sortdata = numpy.sort(data, axis=None)
+                #print(numpy.shape(data))
+                #exit()
                 '''
                 lenOfData = len(sortdata)
                 nums_min = lenOfData*0.2
                 if nums_min <= 5:
                     nums_min = 5
                 sump = 0.
                 sumq = 0.
                 j = 0
                 cont = 1
                 while((cont == 1)and(j < lenOfData)):
                     sump += sortdata[j]
                     sumq += sortdata[j]**2
                     if j > nums_min:
                         rtest = float(j)/(j-1) + 1.0/navg
                         if ((sumq*j) > (rtest*sump**2)):
                             j = j - 1
                             sump = sump - sortdata[j]
                             sumq = sumq - sortdata[j]**2
                             cont = 0
                     j += 1
                 lnoise = sump / j
                 '''
                 return _noise.hildebrand_sekhon(sortdata, navg)
             class Beam:
                 def __init__(self):
                     self.codeList = []
                     self.azimuthList = []
                     self.zenithList = []
             class GenericData(object):
                 flagNoData = True
                 def copy(self, inputObj=None):
                     if inputObj == None:
                         return copy.deepcopy(self)
                     for key in list(inputObj.__dict__.keys()):
                         attribute = inputObj.__dict__[key]
                         # If this attribute is a tuple or list
                         if type(inputObj.__dict__[key]) in (tuple, list):
                             self.__dict__[key] = attribute[:]
                             continue
                         # If this attribute is another object or instance
                         if hasattr(attribute, '__dict__'):
                             self.__dict__[key] = attribute.copy()
                             continue
                         self.__dict__[key] = inputObj.__dict__[key]
                 def deepcopy(self):
                     return copy.deepcopy(self)
                 def isEmpty(self):
                     return self.flagNoData
                 def isReady(self):
                     return not self.flagNoData
             class JROData(GenericData):
                 systemHeaderObj = SystemHeader()
                 radarControllerHeaderObj = RadarControllerHeader()
                 type = None
                 datatype = None  # dtype but in string
                 nProfiles = None
                 heightList = None
                 channelList = None
                 flagDiscontinuousBlock = False
                 useLocalTime = False
                 utctime = None
                 timeZone = None
                 dstFlag = None
                 errorCount = None
                 blocksize = None
                 flagDecodeData = False  # asumo q la data no esta decodificada
                 flagDeflipData = False  # asumo q la data no esta sin flip
                 flagShiftFFT = False
                 nCohInt = None
                 windowOfFilter = 1
                 C = 3e8
                 frequency = 49.92e6
                 realtime = False
                 beacon_heiIndexList = None
                 last_block = None
                 blocknow = None
                 azimuth = None
                 zenith = None
                 beam = Beam()
                 profileIndex = None
                 error = None
                 data = None
                 nmodes = None
                 metadata_list = ['heightList', 'timeZone', 'type']
                 def __str__(self):
                     return '{} - {}'.format(self.type, self.datatime())
                 def getNoise(self):
                     raise NotImplementedError
                 @property
                 def nChannels(self):
                     return len(self.channelList)
                 @property
                 def channelIndexList(self):
                     return list(range(self.nChannels))
                 @property
                 def nHeights(self):
                     return len(self.heightList)
                 def getDeltaH(self):
                     return self.heightList[1] - self.heightList[0]
                 @property
                 def ltctime(self):
                     if self.useLocalTime:
                         return self.utctime - self.timeZone * 60
                     return self.utctime
                 @property
                 def datatime(self):
                     datatimeValue = datetime.datetime.utcfromtimestamp(self.ltctime)
                     return datatimeValue
                 def getTimeRange(self):
                     datatime = []
                     datatime.append(self.ltctime)
                     datatime.append(self.ltctime + self.timeInterval + 1)
                     datatime = numpy.array(datatime)
                     return datatime
                 def getFmaxTimeResponse(self):
                     period = (10**-6) * self.getDeltaH() / (0.15)
                     PRF = 1. / (period * self.nCohInt)
                     fmax = PRF
                     return fmax
                 def getFmax(self):
                     PRF = 1. / (self.ippSeconds * self.nCohInt)
                     fmax = PRF
                     return fmax
                 def getVmax(self):
                     _lambda = self.C / self.frequency
                     vmax = self.getFmax() * _lambda / 2
                     return vmax
                 @property
                 def ippSeconds(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.ippSeconds
                 @ippSeconds.setter
                 def ippSeconds(self, ippSeconds):
                     '''
                     '''
                     self.radarControllerHeaderObj.ippSeconds = ippSeconds
                 @property
                 def code(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.code
                 @code.setter
                 def code(self, code):
                     '''
                     '''
                     self.radarControllerHeaderObj.code = code
                 @property
                 def nCode(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.nCode
                 @nCode.setter
                 def nCode(self, ncode):
                     '''
                     '''
                     self.radarControllerHeaderObj.nCode = ncode
                 @property
                 def nBaud(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.nBaud
                 @nBaud.setter
                 def nBaud(self, nbaud):
                     '''
                     '''
                     self.radarControllerHeaderObj.nBaud = nbaud
                 @property
                 def ipp(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.ipp
                 @ipp.setter
                 def ipp(self, ipp):
                     '''
                     '''
                     self.radarControllerHeaderObj.ipp = ipp
                 @property
                 def metadata(self):
                     '''
                     '''
                     return {attr: getattr(self, attr) for attr in self.metadata_list}
             class Voltage(JROData):
                 dataPP_POW   = None
                 dataPP_DOP   = None
                 dataPP_WIDTH = None
                 dataPP_SNR   = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.useLocalTime = True
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Voltage"
                     self.data = None
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.timeZone = 0
                     self.dstFlag = None
                     self.errorCount = None
                     self.nCohInt = None
                     self.blocksize = None
                     self.flagCohInt = False
                     self.flagDecodeData = False  # asumo q la data no esta decodificada
                     self.flagDeflipData = False  # asumo q la data no esta sin flip
                     self.flagShiftFFT = False
                     self.flagDataAsBlock = False  # Asumo que la data es leida perfil a perfil
                     self.profileIndex = 0
                     self.metadata_list = ['type', 'heightList', 'timeZone', 'nProfiles', 'channelList', 'nCohInt',
                         'code', 'nCode', 'nBaud', 'ippSeconds', 'ipp']
                 def getNoisebyHildebrand(self, channel=None):
                     """
                     Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
                     Return:
                         noiselevel
                     """
                     if channel != None:
                         data = self.data[channel]
                         nChannels = 1
                     else:
                         data = self.data
                         nChannels = self.nChannels
                     noise = numpy.zeros(nChannels)
                     power = data * numpy.conjugate(data)
                     for thisChannel in range(nChannels):
                         if nChannels == 1:
                             daux = power[:].real
                         else:
                             daux = power[thisChannel, :].real
                         noise[thisChannel] = hildebrand_sekhon(daux, self.nCohInt)
                     return noise
                 def getNoise(self, type=1, channel=None):
                     if type == 1:
                         noise = self.getNoisebyHildebrand(channel)
                     return noise
                 def getPower(self, channel=None):
                     if channel != None:
                         data = self.data[channel]
                     else:
                         data = self.data
                     power = data * numpy.conjugate(data)
                     powerdB = 10 * numpy.log10(power.real)
                     powerdB = numpy.squeeze(powerdB)
                     return powerdB
                 @property
                 def timeInterval(self):
                     return self.ippSeconds * self.nCohInt
                 noise = property(getNoise, "I'm the 'nHeights' property.")
+            class CrossProds(JROData):
+                # data es un numpy array de 2 dmensiones (canales, alturas)
+                data = None
+                def __init__(self):
+                    '''
+                    Constructor
+                    '''
+                    self.useLocalTime = True
+                    '''
+                    self.radarControllerHeaderObj = RadarControllerHeader()
+                    self.systemHeaderObj = SystemHeader()
+                    self.type = "Voltage"
+                    self.data = None
+            #         self.dtype = None
+            #        self.nChannels = 0
+            #        self.nHeights = 0
+                    self.nProfiles = None
+                    self.heightList = None
+                    self.channelList = None
+            #        self.channelIndexList = None
+                    self.flagNoData = True
+                    self.flagDiscontinuousBlock = False
+                    self.utctime = None
+                    self.timeZone = None
+                    self.dstFlag = None
+                    self.errorCount = None
+                    self.nCohInt = None
+                    self.blocksize = None
+                    self.flagDecodeData = False  # asumo q la data no esta decodificada
+                    self.flagDeflipData = False  # asumo q la data no esta sin flip
+                    self.flagShiftFFT = False
+                    self.flagDataAsBlock = False  # Asumo que la data es leida perfil a perfil
+                    self.profileIndex = 0
+                def getNoisebyHildebrand(self, channel=None):
+                    if channel != None:
+                        data = self.data[channel]
+                        nChannels = 1
+                    else:
+                        data = self.data
+                        nChannels = self.nChannels
+                    noise = numpy.zeros(nChannels)
+                    power = data * numpy.conjugate(data)
+                    for thisChannel in range(nChannels):
+                        if nChannels == 1:
+                            daux = power[:].real
+                        else:
+                            daux = power[thisChannel, :].real
+                        noise[thisChannel] = hildebrand_sekhon(daux, self.nCohInt)
+                    return noise
+                def getNoise(self, type=1, channel=None):
+                    if type == 1:
+                        noise = self.getNoisebyHildebrand(channel)
+                    return noise
+                def getPower(self, channel=None):
+                    if channel != None:
+                        data = self.data[channel]
+                    else:
+                        data = self.data
+                    power = data * numpy.conjugate(data)
+                    powerdB = 10 * numpy.log10(power.real)
+                    powerdB = numpy.squeeze(powerdB)
+                    return powerdB
+                def getTimeInterval(self):
+                    timeInterval = self.ippSeconds * self.nCohInt
+                    return timeInterval
+                noise = property(getNoise, "I'm the 'nHeights' property.")
+                timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
+                '''
+                def getTimeInterval(self):
+                    timeInterval = self.ippSeconds * self.nCohInt
+                    return timeInterval
             class Spectra(JROData):
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.useLocalTime = True
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Spectra"
                     self.timeZone = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
                     self.pairsList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.nCohInt = None
                     self.nIncohInt = None
                     self.blocksize = None
                     self.nFFTPoints = None
                     self.wavelength = None
                     self.flagDecodeData = False  # asumo q la data no esta decodificada
                     self.flagDeflipData = False  # asumo q la data no esta sin flip
                     self.flagShiftFFT = False
                     self.ippFactor = 1
                     self.beacon_heiIndexList = []
                     self.noise_estimation = None
                     self.metadata_list = ['type', 'heightList', 'timeZone', 'pairsList', 'channelList', 'nCohInt',
                         'code', 'nCode', 'nBaud', 'ippSeconds', 'ipp','nIncohInt', 'nFFTPoints', 'nProfiles']
                 def getNoisebyHildebrand(self, xmin_index=None, xmax_index=None, ymin_index=None, ymax_index=None):
                     """
                     Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
                     Return:
                         noiselevel
                     """
                     noise = numpy.zeros(self.nChannels)
                     for channel in range(self.nChannels):
                         daux = self.data_spc[channel,
                                              xmin_index:xmax_index, ymin_index:ymax_index]
                         noise[channel] = hildebrand_sekhon(daux, self.nIncohInt)
                     return noise
                 def getNoise(self, xmin_index=None, xmax_index=None, ymin_index=None, ymax_index=None):
                     if self.noise_estimation is not None:
                         # this was estimated by getNoise Operation defined in jroproc_spectra.py
                         return self.noise_estimation
                     else:
                         noise = self.getNoisebyHildebrand(
                             xmin_index, xmax_index, ymin_index, ymax_index)
                         return noise
                 def getFreqRangeTimeResponse(self, extrapoints=0):
                     deltafreq = self.getFmaxTimeResponse() / (self.nFFTPoints * self.ippFactor)
                     freqrange = deltafreq * (numpy.arange(self.nFFTPoints + extrapoints) - self.nFFTPoints / 2.) - deltafreq / 2
                     return freqrange
                 def getAcfRange(self, extrapoints=0):
                     deltafreq = 10. / (self.getFmax() / (self.nFFTPoints * self.ippFactor))
                     freqrange = deltafreq * (numpy.arange(self.nFFTPoints + extrapoints) -self.nFFTPoints / 2.) - deltafreq / 2
                     return freqrange
                 def getFreqRange(self, extrapoints=0):
                     deltafreq = self.getFmax() / (self.nFFTPoints * self.ippFactor)
                     freqrange = deltafreq * (numpy.arange(self.nFFTPoints + extrapoints) -self.nFFTPoints / 2.) - deltafreq / 2
                     return freqrange
                 def getVelRange(self, extrapoints=0):
                     deltav = self.getVmax() / (self.nFFTPoints * self.ippFactor)
                     velrange = deltav * (numpy.arange(self.nFFTPoints + extrapoints) - self.nFFTPoints / 2.)
                     if self.nmodes:
                         return velrange/self.nmodes
                     else:
                         return velrange
                 @property
                 def nPairs(self):
                     return len(self.pairsList)
                 @property
                 def pairsIndexList(self):
                     return list(range(self.nPairs))
                 @property
                 def normFactor(self):
                     pwcode = 1
                     if self.flagDecodeData:
                         pwcode = numpy.sum(self.code[0]**2)
                     #normFactor = min(self.nFFTPoints,self.nProfiles)*self.nIncohInt*self.nCohInt*pwcode*self.windowOfFilter
                     normFactor = self.nProfiles * self.nIncohInt * self.nCohInt * pwcode * self.windowOfFilter
                     return normFactor
                 @property
                 def flag_cspc(self):
                     if self.data_cspc is None:
                         return True
                     return False
                 @property
                 def flag_dc(self):
                     if self.data_dc is None:
                         return True
                     return False
                 @property
                 def timeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt * self.nProfiles * self.ippFactor
                     if self.nmodes:
                         return self.nmodes*timeInterval
                     else:
                         return timeInterval
                 def getPower(self):
                     factor = self.normFactor
                     z = self.data_spc / factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     avg = numpy.average(z, axis=1)
                     return 10 * numpy.log10(avg)
                 def getCoherence(self, pairsList=None, phase=False):
                     z = []
                     if pairsList is None:
                         pairsIndexList = self.pairsIndexList
                     else:
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in self.pairsList:
                                 raise ValueError("Pair %s is not in dataOut.pairsList" % (
                                     pair))
                             pairsIndexList.append(self.pairsList.index(pair))
                     for i in range(len(pairsIndexList)):
                         pair = self.pairsList[pairsIndexList[i]]
                         ccf = numpy.average(self.data_cspc[pairsIndexList[i], :, :], axis=0)
                         powa = numpy.average(self.data_spc[pair[0], :, :], axis=0)
                         powb = numpy.average(self.data_spc[pair[1], :, :], axis=0)
                         avgcoherenceComplex = ccf / numpy.sqrt(powa * powb)
                         if phase:
                             data = numpy.arctan2(avgcoherenceComplex.imag,
                                                  avgcoherenceComplex.real) * 180 / numpy.pi
                         else:
                             data = numpy.abs(avgcoherenceComplex)
                         z.append(data)
                     return numpy.array(z)
                 def setValue(self, value):
                     print("This property should not be initialized")
                     return
                 noise = property(getNoise, setValue, "I'm the 'nHeights' property.")
             class SpectraHeis(Spectra):
                 def __init__(self):
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "SpectraHeis"
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.blocksize = None
                     self.profileIndex = 0
                     self.nCohInt = 1
                     self.nIncohInt = 1
                 @property
                 def normFactor(self):
                     pwcode = 1
                     if self.flagDecodeData:
                         pwcode = numpy.sum(self.code[0]**2)
                     normFactor = self.nIncohInt * self.nCohInt * pwcode
                     return normFactor
                 @property
                 def timeInterval(self):
                     return self.ippSeconds * self.nCohInt * self.nIncohInt
             class Fits(JROData):
                 def __init__(self):
                     self.type = "Fits"
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
                     self.flagNoData = True
                     self.utctime = None
                     self.nCohInt = 1
                     self.nIncohInt = 1
                     self.useLocalTime = True
                     self.profileIndex = 0
                     self.timeZone = 0
                 def getTimeRange(self):
                     datatime = []
                     datatime.append(self.ltctime)
                     datatime.append(self.ltctime + self.timeInterval)
                     datatime = numpy.array(datatime)
                     return datatime
                 def getChannelIndexList(self):
                     return list(range(self.nChannels))
                 def getNoise(self, type=1):
                     if type == 1:
                         noise = self.getNoisebyHildebrand()
                     if type == 2:
                         noise = self.getNoisebySort()
                     if type == 3:
                         noise = self.getNoisebyWindow()
                     return noise
                 @property
                 def timeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
                     return timeInterval
                 @property
                 def ippSeconds(self):
                     '''
                     '''
                     return self.ipp_sec
                 noise = property(getNoise, "I'm the 'nHeights' property.")
             class Correlation(JROData):
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Correlation"
                     self.data = None
                     self.dtype = None
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.timeZone = 0
                     self.dstFlag = None
                     self.errorCount = None
                     self.blocksize = None
                     self.flagDecodeData = False  # asumo q la data no esta decodificada
                     self.flagDeflipData = False  # asumo q la data no esta sin flip
                     self.pairsList = None
                     self.nPoints = None
                 def getPairsList(self):
                     return self.pairsList
                 def getNoise(self, mode=2):
                     indR = numpy.where(self.lagR == 0)[0][0]
                     indT = numpy.where(self.lagT == 0)[0][0]
                     jspectra0 = self.data_corr[:, :, indR, :]
                     jspectra = copy.copy(jspectra0)
                     num_chan = jspectra.shape[0]
                     num_hei = jspectra.shape[2]
                     freq_dc = jspectra.shape[1] / 2
                     ind_vel = numpy.array([-2, -1, 1, 2]) + freq_dc
                     if ind_vel[0] < 0:
                         ind_vel[list(range(0, 1))] = ind_vel[list(
                             range(0, 1))] + self.num_prof
                     if mode == 1:
                         jspectra[:, freq_dc, :] = (
                             jspectra[:, ind_vel[1], :] + jspectra[:, ind_vel[2], :]) / 2  # CORRECCION
                     if mode == 2:
                         vel = numpy.array([-2, -1, 1, 2])
                         xx = numpy.zeros([4, 4])
                         for fil in range(4):
                             xx[fil, :] = vel[fil]**numpy.asarray(list(range(4)))
                         xx_inv = numpy.linalg.inv(xx)
                         xx_aux = xx_inv[0, :]
                         for ich in range(num_chan):
                             yy = jspectra[ich, ind_vel, :]
                             jspectra[ich, freq_dc, :] = numpy.dot(xx_aux, yy)
                             junkid = jspectra[ich, freq_dc, :] <= 0
                             cjunkid = sum(junkid)
                             if cjunkid.any():
                                 jspectra[ich, freq_dc, junkid.nonzero()] = (
                                     jspectra[ich, ind_vel[1], junkid] + jspectra[ich, ind_vel[2], junkid]) / 2
                     noise = jspectra0[:, freq_dc, :] - jspectra[:, freq_dc, :]
                     return noise
                 @property
                 def timeInterval(self):
                     return self.ippSeconds * self.nCohInt * self.nProfiles
                 def splitFunctions(self):
                     pairsList = self.pairsList
                     ccf_pairs = []
                     acf_pairs = []
                     ccf_ind = []
                     acf_ind = []
                     for l in range(len(pairsList)):
                         chan0 = pairsList[l][0]
                         chan1 = pairsList[l][1]
                         # Obteniendo pares de Autocorrelacion
                         if chan0 == chan1:
                             acf_pairs.append(chan0)
                             acf_ind.append(l)
                         else:
                             ccf_pairs.append(pairsList[l])
                             ccf_ind.append(l)
                     data_acf = self.data_cf[acf_ind]
                     data_ccf = self.data_cf[ccf_ind]
                     return acf_ind, ccf_ind, acf_pairs, ccf_pairs, data_acf, data_ccf
                 @property
                 def normFactor(self):
                     acf_ind, ccf_ind, acf_pairs, ccf_pairs, data_acf, data_ccf = self.splitFunctions()
                     acf_pairs = numpy.array(acf_pairs)
                     normFactor = numpy.zeros((self.nPairs, self.nHeights))
                     for p in range(self.nPairs):
                         pair = self.pairsList[p]
                         ch0 = pair[0]
                         ch1 = pair[1]
                         ch0_max = numpy.max(data_acf[acf_pairs == ch0, :, :], axis=1)
                         ch1_max = numpy.max(data_acf[acf_pairs == ch1, :, :], axis=1)
                         normFactor[p, :] = numpy.sqrt(ch0_max * ch1_max)
                     return normFactor
             class Parameters(Spectra):
                 groupList = None  # List of Pairs, Groups, etc
                 data_param = None  # Parameters obtained
                 data_pre = None  # Data Pre Parametrization
                 data_SNR = None  # Signal to Noise Ratio
                 abscissaList = None  # Abscissa, can be velocities, lags or time
                 utctimeInit = None  # Initial UTC time
                 paramInterval = None  # Time interval to calculate Parameters in seconds
                 useLocalTime = True
                 # Fitting
                 data_error = None  # Error of the estimation
                 constants = None
                 library = None
                 # Output signal
                 outputInterval = None  # Time interval to calculate output signal in seconds
                 data_output = None  # Out signal
                 nAvg = None
                 noise_estimation = None
                 GauSPC = None  # Fit gaussian SPC
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Parameters"
                     self.timeZone = 0
                 def getTimeRange1(self, interval):
                     datatime = []
                     if self.useLocalTime:
                         time1 = self.utctimeInit - self.timeZone * 60
                     else:
                         time1 = self.utctimeInit
                     datatime.append(time1)
                     datatime.append(time1 + interval)
                     datatime = numpy.array(datatime)
                     return datatime
                 @property
                 def timeInterval(self):
                     if hasattr(self, 'timeInterval1'):
                         return self.timeInterval1
                     else:
                         return self.paramInterval
                 def setValue(self, value):
                     print("This property should not be initialized")
                     return
                 def getNoise(self):
                     return self.spc_noise
                 noise = property(getNoise, setValue, "I'm the 'Noise' property.")
             class PlotterData(object):
                 '''
                 Object to hold data to be plotted
                 '''
                 MAXNUMX = 200
                 MAXNUMY = 200
                 def __init__(self, code, throttle_value, exp_code, localtime=True, buffering=True, snr=False):
                     self.key = code
                     self.throttle = throttle_value
                     self.exp_code = exp_code
                     self.buffering = buffering
                     self.ready = False
                     self.flagNoData = False
                     self.localtime = localtime
                     self.data = {}
                     self.meta = {}
                     self.__heights = []
                     if 'snr' in code:
                         self.plottypes = ['snr']
                     elif code == 'spc':
                         self.plottypes = ['spc', 'noise', 'rti']
                     elif code == 'cspc':
                         self.plottypes = ['cspc', 'spc', 'noise', 'rti']
                     elif code == 'rti':
                         self.plottypes = ['noise', 'rti']
+                    elif code == 'crossprod':
+                        self.plottypes = ['crossprod', 'kay']
+                    elif code == 'spectrogram':
+                        self.plottypes = ['spc', 'spectrogram']
                     else:
                         self.plottypes = [code]
                     if 'snr' not in self.plottypes and snr:
                         self.plottypes.append('snr')
                     for plot in self.plottypes:
                         self.data[plot] = {}
                 def __str__(self):
                     dum = ['{}{}'.format(key, self.shape(key)) for key in self.data]
                     return 'Data[{}][{}]'.format(';'.join(dum), len(self.times))
                 def __len__(self):
                     return len(self.data[self.key])
                 def __getitem__(self, key):
                     if key not in self.data:
                         raise KeyError(log.error('Missing key: {}'.format(key)))
                     if 'spc' in key or not self.buffering:
                         ret = self.data[key][self.tm]
                     elif 'scope' in key:
                         ret = numpy.array(self.data[key][float(self.tm)])
                     else:
                         ret = numpy.array([self.data[key][x] for x in self.times])
                         if ret.ndim > 1:
                             ret = numpy.swapaxes(ret, 0, 1)
                     return ret
                 def __contains__(self, key):
                     return key in self.data
                 def setup(self):
                     '''
                     Configure object
                     '''
                     self.type = ''
                     self.ready = False
                     del self.data
                     self.data = {}
                     self.__heights = []
                     self.__all_heights = set()
                     for plot in self.plottypes:
                         if 'snr' in plot:
                             plot = 'snr'
                         elif 'spc_moments' == plot:
                             plot = 'moments'
+                        elif 'spc_oblique' == plot:
+                            plot = 'oblique'
                         self.data[plot] = {}
-                    if 'spc' in self.data or 'rti' in self.data or 'cspc' in self.data or 'moments' in self.data:
+                    if 'spc' in self.data or 'rti' in self.data or 'cspc' in self.data or 'moments' in self.data or 'oblique' in self.data:
                         self.data['noise'] = {}
                         self.data['rti'] = {}
                         if 'noise' not in self.plottypes:
                             self.plottypes.append('noise')
                         if 'rti' not in self.plottypes:
                             self.plottypes.append('rti')
                 def shape(self, key):
                     '''
                     Get the shape of the one-element data for the given key
                     '''
                     if len(self.data[key]):
                         if 'spc' in key or not self.buffering:
                             return self.data[key].shape
                         return self.data[key][self.times[0]].shape
                     return (0,)
                 def update(self, dataOut, tm):
                     '''
                     Update data object with new dataOut
                     '''
                     self.profileIndex = dataOut.profileIndex
                     self.tm = tm
                     self.type = dataOut.type
                     self.parameters = getattr(dataOut, 'parameters', [])
                     if hasattr(dataOut, 'meta'):
                         self.meta.update(dataOut.meta)
                     if hasattr(dataOut, 'pairsList'):
                         self.pairs = dataOut.pairsList
                     self.interval = dataOut.timeInterval
                     if True in ['spc' in ptype for ptype in self.plottypes]:
                         self.xrange = (dataOut.getFreqRange(1)/1000.,
                                        dataOut.getAcfRange(1), dataOut.getVelRange(1))
                     self.__heights.append(dataOut.heightList)
                     self.__all_heights.update(dataOut.heightList)
                     for plot in self.plottypes:
-                        if plot in ('spc', 'spc_moments', 'spc_cut'):
+                        if plot in ('spc', 'spc_moments', 'spc_cut', 'spc_oblique'):
+                            self.shift1 = dataOut.Oblique_params[0][1]
+                            self.shift2 = dataOut.Oblique_params[0][4]
+                            self.shift1_error = dataOut.Oblique_param_errors[0][1]
+                            self.shift2_error = dataOut.Oblique_param_errors[0][4]
                             z = dataOut.data_spc/dataOut.normFactor
+                            #print(dataOut.normFactor)
+                            #print(z[0,3,15])
+                            #print("here")
+                            #print(dataOut.data_spc[0,0,0])
+                            #exit()
                             buffer = 10*numpy.log10(z)
                         if plot == 'cspc':
                             buffer = (dataOut.data_spc, dataOut.data_cspc)
+                            self.nFactor=dataOut.normFactor
                         if plot == 'noise':
                             buffer = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
                         if plot in ('rti', 'spcprofile'):
                             buffer = dataOut.getPower()
+                            #print(buffer[0,0])
+                            #exit()
                         if plot == 'snr_db':
                             buffer = dataOut.data_SNR
                         if plot == 'snr':
                             buffer = 10*numpy.log10(dataOut.data_SNR)
                         if plot == 'dop':
                             buffer = dataOut.data_DOP
                         if plot == 'pow':
                             buffer = 10*numpy.log10(dataOut.data_POW)
                         if plot == 'width':
                             buffer = dataOut.data_WIDTH
                         if plot == 'coh':
                             buffer = dataOut.getCoherence()
                         if plot == 'phase':
                             buffer = dataOut.getCoherence(phase=True)
                         if plot == 'output':
                             buffer = dataOut.data_output
                         if plot == 'param':
                             buffer = dataOut.data_param
+                        if plot == 'spectrogram':
+                            maxHei = 1350 #11
+                            #maxHei = 2500
+                            maxHei = 0
+                            #maxHei = 990 #12
+                            ###maxHei = 990
+                            indb = numpy.where(dataOut.heightList <= maxHei)
+                            hei = indb[0][-1]
+                            #hei = 19
+                            print(hei)
+                            #hei = 0
+                            factor = dataOut.nIncohInt
+                            #print(factor)
+                            #exit(1)
+                            z = dataOut.data_spc[:,:,hei] / factor
+                            #for j in range(z.shape[1]):
+                                #z[:,j] = z[:,j]/hildebrand_sekhon(z[], self.nCohInt)
+                            ##z = z/hildebrand_sekhon(z, factor)
+                            noise  = numpy.zeros(dataOut.nChannels)
+                            for i in range(dataOut.nChannels):
+                                #daux         = numpy.sort(pair0[i,:,:],axis= None)
+                                noise[i]=hildebrand_sekhon( z[i,:] ,dataOut.nIncohInt)
+                            #for j in range(z.shape[1]):
+                                #z[:,j] = z[:,j]/noise
+                            #print(z.shape[1])
+                            norm_factor = numpy.copy(z[:,int(z.shape[1]/2)])#/z[:,int(z.shape[1]/2)])*8000
+                            #print(norm_factor)
+                            #print(z[0,315:325])
+                            #norm_factor = norm_factor.reshape((z.shape[0],z.shape[1]))
+                            #print(norm_factor)
+                            #exit(1)
+                            #print(z.shape[1])
+                            #for j in range(z.shape[1]):
+                                #z[:,j] = z[:,j]/norm_factor
+                            #print(z[0,315:325])
+                            #exit(1)
+                            #z = numpy.mean(dataOut.data_spc[:,:,:],axis=2) / factor
+                            z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
+                            #avg = numpy.average(z, axis=1)
+                            #print((dataOut.data_spc.shape))
+                            #exit(1)
+                            self.hei = hei
+                            self.heightList = dataOut.heightList
+                            self.DH = (dataOut.heightList[1] - dataOut.heightList[0])/dataOut.step
+                            self.nProfiles = dataOut.nProfiles
+                            #print(dataOut.heightList)
+                            buffer = 10 * numpy.log10(z)
+                            ###buffer = z
+                            import matplotlib.pyplot as plt
+                            fig, axes = plt.subplots(figsize=(14, 10))
+                            x = numpy.linspace(0,20,numpy.shape(buffer)[1])
+                            x = numpy.fft.fftfreq(numpy.shape(buffer)[1],0.00001)
+                            x = numpy.fft.fftshift(x)
+                            plt.plot(x,buffer[0,:])
+                            axes = plt.gca()
+                            axes.set_xlim([-10000,10000])
+                            #axes.set_xlim([0,30000])
+                            #axes.set_ylim([-100,0.0025*1e10])
+                            plt.show()
+                            import time
+                            #time.sleep(20)
+                            #exit(1)
+                            #if dataOut.profileIndex
+                        if plot == 'xmit':
+                            y_1=numpy.arctan2(dataOut.output_LP[:,0,2].imag,dataOut.output_LP[:,0,2].real)* 180 / (numpy.pi*10)
+                            y_2=numpy.abs(dataOut.output_LP[:,0,2])
+                            norm=numpy.max(y_2)
+                            norm=max(norm,0.1)
+                            y_2=y_2/norm
+                            buffer = numpy.vstack((y_1,y_2))
+                            self.NLAG = dataOut.NLAG
+                        if plot == 'crossprod':
+                            buffer = dataOut.crossprods
+                            self.NDP = dataOut.NDP
+                        if plot == 'crossprodlp':
+                            buffer = 10*numpy.log10(numpy.abs(dataOut.output_LP))
+                            self.NRANGE = dataOut.NRANGE
+                            self.NLAG = dataOut.NLAG
+                        if plot == 'noisedp':
+                            buffer = 10*numpy.log10(dataOut.noise_final)
+                            #print(buffer)
+                        if plot == 'FaradayAngle':
+                            buffer = numpy.degrees(dataOut.phi)
+                            #print(buffer)
+                        if plot == 'RTIDP':
+                            buffer = dataOut.data_for_RTI_DP
+                            self.NDP = dataOut.NDP
+                        if plot == 'RTILP':
+                            buffer = dataOut.data_for_RTI_LP
+                            self.NRANGE = dataOut.NRANGE
+                        if plot == 'denrti':
+                            buffer = dataOut.DensityFinal
+                        if plot == 'denrtiLP':
+                            #buffer = numpy.reshape(numpy.concatenate((dataOut.ph2[:dataOut.cut],dataOut.ne[dataOut.cut:dataOut.NACF])),(1,-1))
+                            buffer = dataOut.DensityFinal
+                            #self.flagDataAsBlock = dataOut.flagDataAsBlock
+                            #self.NDP = dataOut.NDP
+                        if plot == 'den':
+                            buffer = dataOut.ph2[:dataOut.NSHTS]
+                            self.dphi=dataOut.dphi[:dataOut.NSHTS]
+                            self.sdp2=dataOut.sdp2[:dataOut.NSHTS]
+                            self.sdn1=dataOut.sdn1[:dataOut.NSHTS]#/self.dphi
+                            self.NSHTS=dataOut.NSHTS
+                            '''
+                            flag1=False
+                            flag0=True
+                            for i in range(12,dataOut.NSHTS):
+                                print("H: ",i*15)
+                                print(abs((dataOut.sdn1[i]/(dataOut.dphi[i]**2))*100))
+                                if flag0:
+                                    if abs((dataOut.sdn1[i]/dataOut.dphi[i]))<0.0005*abs(dataOut.dphi[i]):
+                                        print("***************************** FIRST: ",(i)*15,"*****************************")
+                                        flag1=True
+                                        flag0=False
+                                    #pass
+                                    #print("****************************************GOOD****************************************")
+                                #else:
+                                    #print("****************************************",(i-1)*15,"****************************************")
+                                    #break
+                                if flag1:
+                                    if abs((dataOut.sdn1[i]/dataOut.dphi[i]))>0.0005*abs(dataOut.dphi[i]):
+                                        print("***************************** LAST: ",(i-1)*15,"*****************************")
+                                        break
+                                    #print("H: ",i*15)
+                                    #print(dataOut.sdn1[i])
+                                    '''
+                        if plot == 'denLP':
+                            buffer = dataOut.ph2[:dataOut.NSHTS]
+                            self.dphi=dataOut.dphi[:dataOut.NSHTS]
+                            self.sdp2=dataOut.sdp2[:dataOut.NSHTS]
+                            self.ne=dataOut.ne[:dataOut.NACF]
+                            self.ene=dataOut.ene[:dataOut.NACF]*dataOut.ne[:dataOut.NACF]*0.434
+                            #self.ene=10**dataOut.ene[:dataOut.NACF]
+                            self.NSHTS=dataOut.NSHTS
+                            self.cut=dataOut.cut
+                        if plot == 'ETemp':
+                            #buffer = dataOut.ElecTempClean
+                            buffer = dataOut.ElecTempFinal
+                        if plot == 'ITemp':
+                            #buffer = dataOut.IonTempClean
+                            buffer = dataOut.IonTempFinal
+                        if plot == 'ETempLP':
+                            #buffer = dataOut.IonTempClean
+                            #buffer = numpy.reshape(numpy.concatenate((dataOut.te2[:dataOut.cut],dataOut.te[dataOut.cut:])),(1,-1))
+                            buffer = dataOut.ElecTempFinal
+                            #print(buffer)
+                        if plot == 'ITempLP':
+                            #buffer = dataOut.IonTempClean
+                            #buffer = numpy.reshape(numpy.concatenate((dataOut.ti2[:dataOut.cut],dataOut.ti[dataOut.cut:])),(1,-1))
+                            buffer = dataOut.IonTempFinal
+                        if plot == 'HFracLP':
+                            #buffer = dataOut.IonTempClean
+                            #buffer = numpy.reshape(numpy.concatenate((dataOut.phy2[:dataOut.cut],dataOut.ph[dataOut.cut:])),(1,-1))
+                            buffer = dataOut.PhyFinal
+                        if plot == 'HeFracLP':
+                            #buffer = dataOut.IonTempClean
+                            #nan_array=numpy.empty((dataOut.cut))
+                            #nan_array[:]=numpy.nan
+                            #buffer = numpy.reshape(numpy.concatenate((nan_array,dataOut.phe[dataOut.cut:])),(1,-1))
+                            buffer = dataOut.PheFinal
+                        if plot =='acfs':
+                            buffer = dataOut.acfs_to_plot
+                            self.acfs_error_to_plot=dataOut.acfs_error_to_plot
+                            self.lags_to_plot=dataOut.lags_to_plot
+                            self.x_igcej_to_plot=dataOut.x_igcej_to_plot
+                            self.x_ibad_to_plot=dataOut.x_ibad_to_plot
+                            self.y_igcej_to_plot=dataOut.y_igcej_to_plot
+                            self.y_ibad_to_plot=dataOut.y_ibad_to_plot
+                            self.NSHTS = dataOut.NSHTS
+                            self.DPL = dataOut.DPL
+                        if plot =='acfs_LP':
+                            aux=numpy.zeros((dataOut.NACF,dataOut.IBITS),'float32')
+                            self.errors=numpy.zeros((dataOut.NACF,dataOut.IBITS),'float32')
+                            self.lags_LP_to_plot=numpy.zeros((dataOut.NACF,dataOut.IBITS),'float32')
+                            '''
+                            for i in range(dataOut.NACF):
+                                for j in range(dataOut.IBITS):
+                                    aux[i,j]=dataOut.fit_array_real[i,j]/dataOut.fit_array_real[i,0]
+                                    aux[i,j]=max(min(aux[i,j],1.0),-1.0)*dataOut.DH+dataOut.heightList[i]
+                                    '''
+                            for i in range(dataOut.NACF):
+                                for j in range(dataOut.IBITS):
+                                    if numpy.abs(dataOut.errors[j,i]/dataOut.output_LP_integrated.real[0,i,0])<1.0:
+                                        aux[i,j]=dataOut.output_LP_integrated.real[j,i,0]/dataOut.output_LP_integrated.real[0,i,0]
+                                        aux[i,j]=max(min(aux[i,j],1.0),-1.0)*dataOut.DH+dataOut.heightList[i]
+                                        self.lags_LP_to_plot[i,j]=dataOut.lags_LP[j]
+                                        self.errors[i,j]=dataOut.errors[j,i]/dataOut.output_LP_integrated.real[0,i,0]*dataOut.DH
+                                    else:
+                                        aux[i,j]=numpy.nan
+                                        self.lags_LP_to_plot[i,j]=numpy.nan
+                                        self.errors[i,j]=numpy.nan
+                            buffer = aux
+                            #self.lags_LP_to_plot=dataOut.lags_LP
+                            self.NACF = dataOut.NACF
+                            self.NLAG = dataOut.NLAG
+                        if plot == 'tempsDP':
+                            buffer = dataOut.te2
+                            self.ete2 = dataOut.ete2
+                            self.ti2 = dataOut.ti2
+                            self.eti2 = dataOut.eti2
+                            self.NSHTS = dataOut.NSHTS
+                        if plot == 'temps_LP':
+                            buffer = numpy.concatenate((dataOut.te2[:dataOut.cut],dataOut.te[dataOut.cut:]))
+                            self.ete = numpy.concatenate((dataOut.ete2[:dataOut.cut],dataOut.ete[dataOut.cut:]))
+                            self.ti = numpy.concatenate((dataOut.ti2[:dataOut.cut],dataOut.ti[dataOut.cut:]))
+                            self.eti = numpy.concatenate((dataOut.eti2[:dataOut.cut],dataOut.eti[dataOut.cut:]))
+                            self.NACF = dataOut.NACF
+                        if plot == 'fracs_LP':
+                            aux_nan=numpy.zeros(dataOut.cut,'float32')
+                            aux_nan[:]=numpy.nan
+                            buffer = numpy.concatenate((aux_nan,dataOut.ph[dataOut.cut:]))
+                            self.eph = numpy.concatenate((aux_nan,dataOut.eph[dataOut.cut:]))
+                            self.phe = dataOut.phe[dataOut.cut:]
+                            self.ephe = dataOut.ephe[dataOut.cut:]
+                            self.NACF = dataOut.NACF
+                            self.cut = dataOut.cut
                         if plot == 'scope':
                             buffer = dataOut.data
                             self.flagDataAsBlock = dataOut.flagDataAsBlock
                             self.nProfiles = dataOut.nProfiles
                         if plot == 'pp_power':
                             buffer = dataOut.dataPP_POWER
                             self.flagDataAsBlock = dataOut.flagDataAsBlock
                             self.nProfiles = dataOut.nProfiles
                         if plot == 'pp_signal':
                             buffer = dataOut.dataPP_POW
                             self.flagDataAsBlock = dataOut.flagDataAsBlock
                             self.nProfiles = dataOut.nProfiles
                         if plot == 'pp_velocity':
                             buffer = dataOut.dataPP_DOP
                             self.flagDataAsBlock = dataOut.flagDataAsBlock
                             self.nProfiles = dataOut.nProfiles
                         if plot == 'pp_specwidth':
                             buffer = dataOut.dataPP_WIDTH
                             self.flagDataAsBlock = dataOut.flagDataAsBlock
                             self.nProfiles = dataOut.nProfiles
                         if plot == 'spc':
                             self.data['spc'][tm] = buffer
                         elif plot == 'cspc':
                             self.data['cspc'][tm] = buffer
                         elif plot == 'spc_moments':
                             self.data['spc'][tm] = buffer
                             self.data['moments'][tm] = dataOut.moments
+                        elif plot == 'spc_oblique':
+                            self.data['spc'][tm] = buffer
+                            self.data['shift1'][tm] = dataOut.Oblique_params[0]
+                            self.data['shift2'][tm] = dataOut.Oblique_params[3]
                         else:
                             if self.buffering:
                                 self.data[plot][tm] = buffer
                             else:
                                 self.data[plot][tm] = buffer
                     if dataOut.channelList is None:
                         self.channels = range(buffer.shape[0])
                     else:
                         self.channels = dataOut.channelList
                     if buffer is None:
                         self.flagNoData = True
                         raise schainpy.admin.SchainWarning('Attribute data_{} is empty'.format(self.key))
                 def normalize_heights(self):
                     '''
                     Ensure same-dimension of the data for different heighList
                     '''
                     H = numpy.array(list(self.__all_heights))
                     H.sort()
                     for key in self.data:
                         shape = self.shape(key)[:-1] + H.shape
                         for tm, obj in list(self.data[key].items()):
                             h = self.__heights[self.times.tolist().index(tm)]
                             if H.size == h.size:
                                 continue
                             index = numpy.where(numpy.in1d(H, h))[0]
                             dummy = numpy.zeros(shape) + numpy.nan
                             if len(shape) == 2:
                                 dummy[:, index] = obj
                             else:
                                 dummy[index] = obj
                             self.data[key][tm] = dummy
                     self.__heights = [H for tm in self.times]
                 def jsonify(self, tm, plot_name, plot_type, decimate=False):
                     '''
                     Convert data to json
                     '''
                     dy = int(self.heights.size/self.MAXNUMY) + 1
                     if self.key in ('spc', 'cspc'):
                         dx = int(self.data[self.key][tm].shape[1]/self.MAXNUMX) + 1
                         data = self.roundFloats(
                             self.data[self.key][tm][::, ::dx, ::dy].tolist())
                     else:
                         if self.key is 'noise':
                             data = [[x] for x in self.roundFloats(self.data[self.key][tm].tolist())]
                         else:
                             data = self.roundFloats(self.data[self.key][tm][::, ::dy].tolist())
                     meta = {}
                     ret = {
                         'plot': plot_name,
                         'code': self.exp_code,
                         'time': float(tm),
                         'data': data,
                         }
                     meta['type'] = plot_type
                     meta['interval'] = float(self.interval)
                     meta['localtime'] = self.localtime
                     meta['yrange'] = self.roundFloats(self.heights[::dy].tolist())
                     if 'spc' in self.data or 'cspc' in self.data:
                         meta['xrange'] = self.roundFloats(self.xrange[2][::dx].tolist())
                     else:
                         meta['xrange'] = []
                     meta.update(self.meta)
                     ret['metadata'] = meta
                     return json.dumps(ret)
                 @property
                 def times(self):
                     '''
                     Return the list of times of the current data
                     '''
                     ret = numpy.array([t for t in self.data[self.key]])
                     if self:
                         ret.sort()
                     return ret
                 @property
                 def min_time(self):
                     '''
                     Return the minimun time value
                     '''
                     return self.times[0]
                 @property
                 def max_time(self):
                     '''
                     Return the maximun time value
                     '''
                     return self.times[-1]
                 @property
                 def heights(self):
                     '''
                     Return the list of heights of the current data
                     '''
                     return numpy.array(self.__heights[-1])
                 @staticmethod
                 def roundFloats(obj):
                     if isinstance(obj, list):
                         return list(map(PlotterData.roundFloats, obj))
                     elif isinstance(obj, float):
                         return round(obj, 2)

schainpy/model/data/jroheaderIO.py +4 -1

             '''
             $Author: murco $
             $Id: JROHeaderIO.py 151 2012-10-31 19:00:51Z murco $
             '''
             import sys
             import numpy
             import copy
             import datetime
             import inspect
             from schainpy.utils import log
             SPEED_OF_LIGHT = 299792458
             SPEED_OF_LIGHT = 3e8
             BASIC_STRUCTURE = numpy.dtype([
                 ('nSize', '<u4'),
                 ('nVersion', '<u2'),
                 ('nDataBlockId', '<u4'),
                 ('nUtime', '<u4'),
                 ('nMilsec', '<u2'),
                 ('nTimezone', '<i2'),
                 ('nDstflag', '<i2'),
                 ('nErrorCount', '<u4')
             ])
             SYSTEM_STRUCTURE = numpy.dtype([
                 ('nSize', '<u4'),
                 ('nNumSamples', '<u4'),
                 ('nNumProfiles', '<u4'),
                 ('nNumChannels', '<u4'),
                 ('nADCResolution', '<u4'),
                 ('nPCDIOBusWidth', '<u4'),
             ])
             RADAR_STRUCTURE = numpy.dtype([
                                          ('nSize', '<u4'),
                                          ('nExpType', '<u4'),
                                          ('nNTx', '<u4'),
                                          ('fIpp', '<f4'),
                                          ('fTxA', '<f4'),
                                          ('fTxB', '<f4'),
                                          ('nNumWindows', '<u4'),
                                          ('nNumTaus', '<u4'),
                                          ('nCodeType', '<u4'),
                                          ('nLine6Function', '<u4'),
                                          ('nLine5Function', '<u4'),
                                          ('fClock', '<f4'),
                                          ('nPrePulseBefore', '<u4'),
                                          ('nPrePulseAfter', '<u4'),
                                          ('sRangeIPP', '<a20'),
                                          ('sRangeTxA', '<a20'),
                                          ('sRangeTxB', '<a20'),
             ])
             SAMPLING_STRUCTURE = numpy.dtype(
                 [('h0', '<f4'), ('dh', '<f4'), ('nsa', '<u4')])
             PROCESSING_STRUCTURE = numpy.dtype([
                 ('nSize', '<u4'),
                 ('nDataType', '<u4'),
                 ('nSizeOfDataBlock', '<u4'),
                 ('nProfilesperBlock', '<u4'),
                 ('nDataBlocksperFile', '<u4'),
                 ('nNumWindows', '<u4'),
                 ('nProcessFlags', '<u4'),
                 ('nCoherentIntegrations', '<u4'),
                 ('nIncoherentIntegrations', '<u4'),
                 ('nTotalSpectra', '<u4')
             ])
             class Header(object):
                 def __init__(self):
                     raise NotImplementedError
                 def copy(self):
                     return copy.deepcopy(self)
                 def read(self):
                     raise NotImplementedError
                 def write(self):
                     raise NotImplementedError
                 def getAllowedArgs(self):
                     args = inspect.getargspec(self.__init__).args
                     try:
                         args.remove('self')
                     except:
                         pass
                     return args
                 def getAsDict(self):
                     args = self.getAllowedArgs()
                     asDict = {}
                     for x in args:
                         asDict[x] = self[x]
                     return asDict
                 def __getitem__(self, name):
                     return getattr(self, name)
                 def printInfo(self):
                     message = "#" * 50 + "\n"
                     message += self.__class__.__name__.upper() + "\n"
                     message += "#" * 50 + "\n"
                     keyList = list(self.__dict__.keys())
                     keyList.sort()
                     for key in keyList:
                         message += "%s = %s" % (key, self.__dict__[key]) + "\n"
                     if "size" not in keyList:
                         attr = getattr(self, "size")
                         if attr:
                             message += "%s = %s" % ("size", attr) + "\n"
                     print(message)
             class BasicHeader(Header):
                 size = None
                 version = None
                 dataBlock = None
                 utc = None
                 ltc = None
                 miliSecond = None
                 timeZone = None
                 dstFlag = None
                 errorCount = None
-                datatime = None
+                F = None
                 structure = BASIC_STRUCTURE
                 __LOCALTIME = None
                 def __init__(self, useLocalTime=True):
                     self.size = 24
                     self.version = 0
                     self.dataBlock = 0
                     self.utc = 0
                     self.miliSecond = 0
                     self.timeZone = 0
                     self.dstFlag = 0
                     self.errorCount = 0
                     self.useLocalTime = useLocalTime
                 def read(self, fp):
                     self.length = 0
                     try:
                         if hasattr(fp, 'read'):
                             header = numpy.fromfile(fp, BASIC_STRUCTURE, 1)
                         else:
                             header = numpy.fromstring(fp, BASIC_STRUCTURE, 1)
                     except Exception as e:
                         print("BasicHeader: ")
                         print(e)
                         return 0
                     self.size = int(header['nSize'][0])
                     self.version = int(header['nVersion'][0])
                     self.dataBlock = int(header['nDataBlockId'][0])
                     self.utc = int(header['nUtime'][0])
                     self.miliSecond = int(header['nMilsec'][0])
                     self.timeZone = int(header['nTimezone'][0])
                     self.dstFlag = int(header['nDstflag'][0])
                     self.errorCount = int(header['nErrorCount'][0])
                     if self.size < 24:
                         return 0
                     self.length = header.nbytes
                     return 1
                 def write(self, fp):
                     headerTuple = (self.size, self.version, self.dataBlock, self.utc,
                                    self.miliSecond, self.timeZone, self.dstFlag, self.errorCount)
                     header = numpy.array(headerTuple, BASIC_STRUCTURE)
                     header.tofile(fp)
                     return 1
                 def get_ltc(self):
                     return self.utc - self.timeZone * 60
                 def set_ltc(self, value):
                     self.utc = value + self.timeZone * 60
                 def get_datatime(self):
                     return datetime.datetime.utcfromtimestamp(self.ltc)
                 ltc = property(get_ltc, set_ltc)
                 datatime = property(get_datatime)
             class SystemHeader(Header):
                 size = None
                 nSamples = None
                 nProfiles = None
                 nChannels = None
                 adcResolution = None
                 pciDioBusWidth = None
                 structure = SYSTEM_STRUCTURE
                 def __init__(self, nSamples=0, nProfiles=0, nChannels=0, adcResolution=14, pciDioBusWidth=0):
                     self.size = 24
                     self.nSamples = nSamples
                     self.nProfiles = nProfiles
                     self.nChannels = nChannels
                     self.adcResolution = adcResolution
                     self.pciDioBusWidth = pciDioBusWidth
                 def read(self, fp):
                     self.length = 0
                     try:
                         startFp = fp.tell()
                     except Exception as e:
                         startFp = None
                         pass
                     try:
                         if hasattr(fp, 'read'):
                             header = numpy.fromfile(fp, SYSTEM_STRUCTURE, 1)
                         else:
                             header = numpy.fromstring(fp, SYSTEM_STRUCTURE, 1)
                     except Exception as e:
                         print("System Header: " + str(e))
                         return 0
                     self.size = header['nSize'][0]
                     self.nSamples = header['nNumSamples'][0]
                     self.nProfiles = header['nNumProfiles'][0]
                     self.nChannels = header['nNumChannels'][0]
                     self.adcResolution = header['nADCResolution'][0]
                     self.pciDioBusWidth = header['nPCDIOBusWidth'][0]
                     if startFp is not None:
                         endFp = self.size + startFp
                         if fp.tell() > endFp:
                             sys.stderr.write(
                                 "Warning %s: Size value read from System Header is lower than it has to be\n" % fp.name)
                             return 0
                         if fp.tell() < endFp:
                             sys.stderr.write(
                                 "Warning %s: Size value read from System Header size is greater than it has to be\n" % fp.name)
                             return 0
                     self.length = header.nbytes
                     return 1
                 def write(self, fp):
                     headerTuple = (self.size, self.nSamples, self.nProfiles,
                                    self.nChannels, self.adcResolution, self.pciDioBusWidth)
                     header = numpy.array(headerTuple, SYSTEM_STRUCTURE)
                     header.tofile(fp)
                     return 1
             class RadarControllerHeader(Header):
                 expType = None
                 nTx = None
                 ipp = None
                 txA = None
                 txB = None
                 nWindows = None
                 numTaus = None
                 codeType = None
                 line6Function = None
                 line5Function = None
                 fClock = None
                 prePulseBefore = None
                 prePulseAfter = None
                 rangeIpp = None
                 rangeTxA = None
                 rangeTxB = None
                 structure = RADAR_STRUCTURE
                 __size = None
                 def __init__(self, expType=2, nTx=1,
                              ipp=None, txA=0, txB=0,
                              nWindows=None, nHeights=None, firstHeight=None, deltaHeight=None,
                              numTaus=0, line6Function=0, line5Function=0, fClock=None,
                              prePulseBefore=0, prePulseAfter=0,
                              codeType=0, nCode=0, nBaud=0, code=None,
                              flip1=0, flip2=0):
                     #         self.size = 116
                     self.expType = expType
                     self.nTx = nTx
                     self.ipp = ipp
                     self.txA = txA
                     self.txB = txB
                     self.rangeIpp = ipp
                     self.rangeTxA = txA
                     self.rangeTxB = txB
                     self.nWindows = nWindows
                     self.numTaus = numTaus
                     self.codeType = codeType
                     self.line6Function = line6Function
                     self.line5Function = line5Function
                     self.fClock = fClock
                     self.prePulseBefore = prePulseBefore
                     self.prePulseAfter = prePulseAfter
                     self.nHeights = nHeights
                     self.firstHeight = firstHeight
                     self.deltaHeight = deltaHeight
                     self.samplesWin = nHeights
                     self.nCode = nCode
                     self.nBaud = nBaud
                     self.code = code
                     self.flip1 = flip1
                     self.flip2 = flip2
                     self.code_size = int(numpy.ceil(self.nBaud / 32.)) * self.nCode * 4
             #         self.dynamic = numpy.array([],numpy.dtype('byte'))
                     if self.fClock is None and self.deltaHeight is not None:
                         self.fClock = 0.15 / (deltaHeight * 1e-6)  # 0.15Km / (height * 1u)
                 def read(self, fp):
                     self.length = 0
                     try:
                         startFp = fp.tell()
                     except Exception as e:
                         startFp = None
                         pass
                     try:
                         if hasattr(fp, 'read'):
                             header = numpy.fromfile(fp, RADAR_STRUCTURE, 1)
                         else:
                             header = numpy.fromstring(fp, RADAR_STRUCTURE, 1)
                         self.length += header.nbytes
                     except Exception as e:
                         print("RadarControllerHeader: " + str(e))
                         return 0
                     size = int(header['nSize'][0])
                     self.expType = int(header['nExpType'][0])
                     self.nTx = int(header['nNTx'][0])
                     self.ipp = float(header['fIpp'][0])
+                    #print(self.ipp)
                     self.txA = float(header['fTxA'][0])
                     self.txB = float(header['fTxB'][0])
                     self.nWindows = int(header['nNumWindows'][0])
                     self.numTaus = int(header['nNumTaus'][0])
                     self.codeType = int(header['nCodeType'][0])
                     self.line6Function = int(header['nLine6Function'][0])
                     self.line5Function = int(header['nLine5Function'][0])
                     self.fClock = float(header['fClock'][0])
                     self.prePulseBefore = int(header['nPrePulseBefore'][0])
                     self.prePulseAfter = int(header['nPrePulseAfter'][0])
                     self.rangeIpp = header['sRangeIPP'][0]
                     self.rangeTxA = header['sRangeTxA'][0]
                     self.rangeTxB = header['sRangeTxB'][0]
                     try:
                         if hasattr(fp, 'read'):
                             samplingWindow = numpy.fromfile(
                                 fp, SAMPLING_STRUCTURE, self.nWindows)
                         else:
                             samplingWindow = numpy.fromstring(
                                 fp[self.length:], SAMPLING_STRUCTURE, self.nWindows)
                         self.length += samplingWindow.nbytes
                     except Exception as e:
                         print("RadarControllerHeader: " + str(e))
                         return 0
                     self.nHeights = int(numpy.sum(samplingWindow['nsa']))
                     self.firstHeight = samplingWindow['h0']
                     self.deltaHeight = samplingWindow['dh']
                     self.samplesWin = samplingWindow['nsa']
                     try:
                         if hasattr(fp, 'read'):
                             self.Taus = numpy.fromfile(fp, '<f4', self.numTaus)
                         else:
                             self.Taus = numpy.fromstring(
                                 fp[self.length:], '<f4', self.numTaus)
                         self.length += self.Taus.nbytes
                     except Exception as e:
                         print("RadarControllerHeader: " + str(e))
                         return 0
                     self.code_size = 0
                     if self.codeType != 0:
                         try:
                             if hasattr(fp, 'read'):
                                 self.nCode = numpy.fromfile(fp, '<u4', 1)[0]
                                 self.length += self.nCode.nbytes
                                 self.nBaud = numpy.fromfile(fp, '<u4', 1)[0]
                                 self.length += self.nBaud.nbytes
                             else:
                                 self.nCode = numpy.fromstring(
                                     fp[self.length:], '<u4', 1)[0]
                                 self.length += self.nCode.nbytes
                                 self.nBaud = numpy.fromstring(
                                     fp[self.length:], '<u4', 1)[0]
                                 self.length += self.nBaud.nbytes
                         except Exception as e:
                             print("RadarControllerHeader: " + str(e))
                             return 0
                         code = numpy.empty([self.nCode, self.nBaud], dtype='i1')
                         for ic in range(self.nCode):
                             try:
                                 if hasattr(fp, 'read'):
                                     temp = numpy.fromfile(fp, 'u4', int(
                                         numpy.ceil(self.nBaud / 32.)))
                                 else:
                                     temp = numpy.fromstring(
                                         fp, 'u4', int(numpy.ceil(self.nBaud / 32.)))
                                 self.length += temp.nbytes
                             except Exception as e:
                                 print("RadarControllerHeader: " + str(e))
                                 return 0
                             for ib in range(self.nBaud - 1, -1, -1):
                                 code[ic, ib] = temp[int(ib / 32)] % 2
                                 temp[int(ib / 32)] = temp[int(ib / 32)] / 2
                         self.code = 2.0 * code - 1.0
                         self.code_size = int(numpy.ceil(self.nBaud / 32.)) * self.nCode * 4
             #             if self.line5Function == RCfunction.FLIP:
             #                 self.flip1 = numpy.fromfile(fp,'<u4',1)
             #
             #             if self.line6Function == RCfunction.FLIP:
             #                 self.flip2 = numpy.fromfile(fp,'<u4',1)
                     if startFp is not None:
                         endFp = size + startFp
                         if fp.tell() != endFp:
                             #             fp.seek(endFp)
                             print("%s: Radar Controller Header size is not consistent: from data [%d] != from header field [%d]" % (fp.name, fp.tell() - startFp, size))
                 #             return 0
                         if fp.tell() > endFp:
                             sys.stderr.write(
                                 "Warning %s: Size value read from Radar Controller header is lower than it has to be\n" % fp.name)
                 #             return 0
                         if fp.tell() < endFp:
                             sys.stderr.write(
                                 "Warning %s: Size value read from Radar Controller header is greater than it has to be\n" % fp.name)
                     return 1
                 def write(self, fp):
                     headerTuple = (self.size,
                                    self.expType,
                                    self.nTx,
                                    self.ipp,
                                    self.txA,
                                    self.txB,
                                    self.nWindows,
                                    self.numTaus,
                                    self.codeType,
                                    self.line6Function,
                                    self.line5Function,
                                    self.fClock,
                                    self.prePulseBefore,
                                    self.prePulseAfter,
                                    self.rangeIpp,
                                    self.rangeTxA,
                                    self.rangeTxB)
                     header = numpy.array(headerTuple, RADAR_STRUCTURE)
                     header.tofile(fp)
                     sampleWindowTuple = (
                         self.firstHeight, self.deltaHeight, self.samplesWin)
                     samplingWindow = numpy.array(sampleWindowTuple, SAMPLING_STRUCTURE)
                     samplingWindow.tofile(fp)
                     if self.numTaus > 0:
                         self.Taus.tofile(fp)
                     if self.codeType != 0:
                         nCode = numpy.array(self.nCode, '<u4')
                         nCode.tofile(fp)
                         nBaud = numpy.array(self.nBaud, '<u4')
                         nBaud.tofile(fp)
                         code1 = (self.code + 1.0) / 2.
                         for ic in range(self.nCode):
                             tempx = numpy.zeros(int(numpy.ceil(self.nBaud / 32.)))
                             start = 0
                             end = 32
                             for i in range(len(tempx)):
                                 code_selected = code1[ic, start:end]
                                 for j in range(len(code_selected) - 1, -1, -1):
                                     if code_selected[j] == 1:
                                         tempx[i] = tempx[i] + \
 **(len(code_selected) - 1 - j)
                                 start = start + 32
                                 end = end + 32
                             tempx = tempx.astype('u4')
                             tempx.tofile(fp)
             #         if self.line5Function == RCfunction.FLIP:
             #             self.flip1.tofile(fp)
             #
             #         if self.line6Function == RCfunction.FLIP:
             #             self.flip2.tofile(fp)
                     return 1
                 def get_ippSeconds(self):
                     '''
                     '''
                     ippSeconds = 2.0 * 1000 * self.ipp / SPEED_OF_LIGHT
                     return ippSeconds
                 def set_ippSeconds(self, ippSeconds):
                     '''
                     '''
                     self.ipp = ippSeconds * SPEED_OF_LIGHT / (2.0 * 1000)
                     return
                 def get_size(self):
                     self.__size = 116 + 12 * self.nWindows + 4 * self.numTaus
                     if self.codeType != 0:
                         self.__size += 4 + 4 + 4 * self.nCode * \
                             numpy.ceil(self.nBaud / 32.)
                     return self.__size
                 def set_size(self, value):
                     raise IOError("size is a property and it cannot be set, just read")
                     return
                 ippSeconds = property(get_ippSeconds, set_ippSeconds)
                 size = property(get_size, set_size)
             class ProcessingHeader(Header):
                 #     size = None
                 dtype = None
                 blockSize = None
                 profilesPerBlock = None
                 dataBlocksPerFile = None
                 nWindows = None
                 processFlags = None
                 nCohInt = None
                 nIncohInt = None
                 totalSpectra = None
                 structure = PROCESSING_STRUCTURE
                 flag_dc = None
                 flag_cspc = None
                 def __init__(self, dtype=0, blockSize=0, profilesPerBlock=0, dataBlocksPerFile=0, nWindows=0, processFlags=0, nCohInt=0,
                              nIncohInt=0, totalSpectra=0, nHeights=0, firstHeight=0, deltaHeight=0, samplesWin=0, spectraComb=0, nCode=0,
                              code=0, nBaud=None, shif_fft=False, flag_dc=False, flag_cspc=False, flag_decode=False, flag_deflip=False
                              ):
                     #         self.size = 0
                     self.dtype = dtype
                     self.blockSize = blockSize
                     self.profilesPerBlock = 0
                     self.dataBlocksPerFile = 0
                     self.nWindows = 0
                     self.processFlags = 0
                     self.nCohInt = 0
                     self.nIncohInt = 0
                     self.totalSpectra = 0
                     self.nHeights = 0
                     self.firstHeight = 0
                     self.deltaHeight = 0
                     self.samplesWin = 0
                     self.spectraComb = 0
                     self.nCode = None
                     self.code = None
                     self.nBaud = None
                     self.shif_fft = False
                     self.flag_dc = False
                     self.flag_cspc = False
                     self.flag_decode = False
                     self.flag_deflip = False
                     self.length = 0
                 def read(self, fp):
                     self.length = 0
                     try:
                         startFp = fp.tell()
                     except Exception as e:
                         startFp = None
                         pass
                     try:
                         if hasattr(fp, 'read'):
                             header = numpy.fromfile(fp, PROCESSING_STRUCTURE, 1)
                         else:
                             header = numpy.fromstring(fp, PROCESSING_STRUCTURE, 1)
                         self.length += header.nbytes
                     except Exception as e:
                         print("ProcessingHeader: " + str(e))
                         return 0
                     size = int(header['nSize'][0])
                     self.dtype = int(header['nDataType'][0])
                     self.blockSize = int(header['nSizeOfDataBlock'][0])
                     self.profilesPerBlock = int(header['nProfilesperBlock'][0])
                     self.dataBlocksPerFile = int(header['nDataBlocksperFile'][0])
                     self.nWindows = int(header['nNumWindows'][0])
                     self.processFlags = header['nProcessFlags']
                     self.nCohInt = int(header['nCoherentIntegrations'][0])
                     self.nIncohInt = int(header['nIncoherentIntegrations'][0])
                     self.totalSpectra = int(header['nTotalSpectra'][0])
                     try:
                         if hasattr(fp, 'read'):
                             samplingWindow = numpy.fromfile(
                                 fp, SAMPLING_STRUCTURE, self.nWindows)
                         else:
                             samplingWindow = numpy.fromstring(
                                 fp[self.length:], SAMPLING_STRUCTURE, self.nWindows)
                         self.length += samplingWindow.nbytes
                     except Exception as e:
                         print("ProcessingHeader: " + str(e))
                         return 0
                     self.nHeights = int(numpy.sum(samplingWindow['nsa']))
                     self.firstHeight = float(samplingWindow['h0'][0])
                     self.deltaHeight = float(samplingWindow['dh'][0])
                     self.samplesWin = samplingWindow['nsa'][0]
                     try:
                         if hasattr(fp, 'read'):
                             self.spectraComb = numpy.fromfile(
                                 fp, 'u1', 2 * self.totalSpectra)
                         else:
                             self.spectraComb = numpy.fromstring(
                                 fp[self.length:], 'u1', 2 * self.totalSpectra)
                         self.length += self.spectraComb.nbytes
                     except Exception as e:
                         print("ProcessingHeader: " + str(e))
                         return 0
                     if ((self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE) == PROCFLAG.DEFINE_PROCESS_CODE):
                         self.nCode = int(numpy.fromfile(fp, '<u4', 1))
                         self.nBaud = int(numpy.fromfile(fp, '<u4', 1))
                         self.code = numpy.fromfile(
                             fp, '<f4', self.nCode * self.nBaud).reshape(self.nCode, self.nBaud)
                     if ((self.processFlags & PROCFLAG.EXP_NAME_ESP) == PROCFLAG.EXP_NAME_ESP):
                         exp_name_len = int(numpy.fromfile(fp, '<u4', 1))
                         exp_name = numpy.fromfile(fp, 'u1', exp_name_len + 1)
                     if ((self.processFlags & PROCFLAG.SHIFT_FFT_DATA) == PROCFLAG.SHIFT_FFT_DATA):
                         self.shif_fft = True
                     else:
                         self.shif_fft = False
                     if ((self.processFlags & PROCFLAG.SAVE_CHANNELS_DC) == PROCFLAG.SAVE_CHANNELS_DC):
                         self.flag_dc = True
                     else:
                         self.flag_dc = False
                     if ((self.processFlags & PROCFLAG.DECODE_DATA) == PROCFLAG.DECODE_DATA):
                         self.flag_decode = True
                     else:
                         self.flag_decode = False
                     if ((self.processFlags & PROCFLAG.DEFLIP_DATA) == PROCFLAG.DEFLIP_DATA):
                         self.flag_deflip = True
                     else:
                         self.flag_deflip = False
                     nChannels = 0
                     nPairs = 0
                     pairList = []
                     for i in range(0, self.totalSpectra * 2, 2):
                         if self.spectraComb[i] == self.spectraComb[i + 1]:
                             nChannels = nChannels + 1  # par de canales iguales
                         else:
                             nPairs = nPairs + 1  # par de canales diferentes
                             pairList.append((self.spectraComb[i], self.spectraComb[i + 1]))
                     self.flag_cspc = False
                     if nPairs > 0:
                         self.flag_cspc = True
                     if startFp is not None:
                         endFp = size + startFp
                         if fp.tell() > endFp:
                             sys.stderr.write(
                                 "Warning: Processing header size is lower than it has to be")
                             return 0
                         if fp.tell() < endFp:
                             sys.stderr.write(
                                 "Warning: Processing header size is greater than it is considered")
                     return 1
                 def write(self, fp):
                     # Clear DEFINE_PROCESS_CODE
                     self.processFlags = self.processFlags & (~PROCFLAG.DEFINE_PROCESS_CODE)
                     headerTuple = (self.size,
                                    self.dtype,
                                    self.blockSize,
                                    self.profilesPerBlock,
                                    self.dataBlocksPerFile,
                                    self.nWindows,
                                    self.processFlags,
                                    self.nCohInt,
                                    self.nIncohInt,
                                    self.totalSpectra)
                     header = numpy.array(headerTuple, PROCESSING_STRUCTURE)
                     header.tofile(fp)
                     if self.nWindows != 0:
                         sampleWindowTuple = (
                             self.firstHeight, self.deltaHeight, self.samplesWin)
                         samplingWindow = numpy.array(sampleWindowTuple, SAMPLING_STRUCTURE)
                         samplingWindow.tofile(fp)
                     if self.totalSpectra != 0:
                         #             spectraComb = numpy.array([],numpy.dtype('u1'))
                         spectraComb = self.spectraComb
                         spectraComb.tofile(fp)
             #         if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
             #             nCode = numpy.array([self.nCode], numpy.dtype('u4')) #Probar con un dato que almacene codigo, hasta el momento no se hizo la prueba
             #             nCode.tofile(fp)
             #
             #             nBaud = numpy.array([self.nBaud], numpy.dtype('u4'))
             #             nBaud.tofile(fp)
             #
             #             code = self.code.reshape(self.nCode*self.nBaud)
             #             code = code.astype(numpy.dtype('<f4'))
             #             code.tofile(fp)
                     return 1
                 def get_size(self):
                     self.__size = 40 + 12 * self.nWindows + 2 * self.totalSpectra
             #         if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
             #             self.__size += 4 + 4 + 4*self.nCode*numpy.ceil(self.nBaud/32.)
             #             self.__size += 4 + 4 + 4 * self.nCode * self.nBaud
                     return self.__size
                 def set_size(self, value):
                     raise IOError("size is a property and it cannot be set, just read")
                     return
                 size = property(get_size, set_size)
             class RCfunction:
                 NONE = 0
                 FLIP = 1
                 CODE = 2
                 SAMPLING = 3
                 LIN6DIV256 = 4
                 SYNCHRO = 5
             class nCodeType:
                 NONE = 0
                 USERDEFINE = 1
                 BARKER2 = 2
                 BARKER3 = 3
                 BARKER4 = 4
                 BARKER5 = 5
                 BARKER7 = 6
                 BARKER11 = 7
                 BARKER13 = 8
                 AC128 = 9
                 COMPLEMENTARYCODE2 = 10
                 COMPLEMENTARYCODE4 = 11
                 COMPLEMENTARYCODE8 = 12
                 COMPLEMENTARYCODE16 = 13
                 COMPLEMENTARYCODE32 = 14
                 COMPLEMENTARYCODE64 = 15
                 COMPLEMENTARYCODE128 = 16
                 CODE_BINARY28 = 17
             class PROCFLAG:
                 COHERENT_INTEGRATION = numpy.uint32(0x00000001)
                 DECODE_DATA = numpy.uint32(0x00000002)
                 SPECTRA_CALC = numpy.uint32(0x00000004)
                 INCOHERENT_INTEGRATION = numpy.uint32(0x00000008)
                 POST_COHERENT_INTEGRATION = numpy.uint32(0x00000010)
                 SHIFT_FFT_DATA = numpy.uint32(0x00000020)
                 DATATYPE_CHAR = numpy.uint32(0x00000040)
                 DATATYPE_SHORT = numpy.uint32(0x00000080)
                 DATATYPE_LONG = numpy.uint32(0x00000100)
                 DATATYPE_INT64 = numpy.uint32(0x00000200)
                 DATATYPE_FLOAT = numpy.uint32(0x00000400)
                 DATATYPE_DOUBLE = numpy.uint32(0x00000800)
                 DATAARRANGE_CONTIGUOUS_CH = numpy.uint32(0x00001000)
                 DATAARRANGE_CONTIGUOUS_H = numpy.uint32(0x00002000)
                 DATAARRANGE_CONTIGUOUS_P = numpy.uint32(0x00004000)
                 SAVE_CHANNELS_DC = numpy.uint32(0x00008000)
                 DEFLIP_DATA = numpy.uint32(0x00010000)
                 DEFINE_PROCESS_CODE = numpy.uint32(0x00020000)
                 ACQ_SYS_NATALIA = numpy.uint32(0x00040000)
                 ACQ_SYS_ECHOTEK = numpy.uint32(0x00080000)
                 ACQ_SYS_ADRXD = numpy.uint32(0x000C0000)
                 ACQ_SYS_JULIA = numpy.uint32(0x00100000)
                 ACQ_SYS_XXXXXX = numpy.uint32(0x00140000)
                 EXP_NAME_ESP = numpy.uint32(0x00200000)
                 CHANNEL_NAMES_ESP = numpy.uint32(0x00400000)
                 OPERATION_MASK = numpy.uint32(0x0000003F)
                 DATATYPE_MASK = numpy.uint32(0x00000FC0)
                 DATAARRANGE_MASK = numpy.uint32(0x00007000)
                 ACQ_SYS_MASK = numpy.uint32(0x001C0000)
             dtype0 = numpy.dtype([('real', '<i1'), ('imag', '<i1')])
             dtype1 = numpy.dtype([('real', '<i2'), ('imag', '<i2')])
             dtype2 = numpy.dtype([('real', '<i4'), ('imag', '<i4')])
             dtype3 = numpy.dtype([('real', '<i8'), ('imag', '<i8')])
             dtype4 = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
             dtype5 = numpy.dtype([('real', '<f8'), ('imag', '<f8')])
             NUMPY_DTYPE_LIST = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
             PROCFLAG_DTYPE_LIST = [PROCFLAG.DATATYPE_CHAR,
                                    PROCFLAG.DATATYPE_SHORT,
                                    PROCFLAG.DATATYPE_LONG,
                                    PROCFLAG.DATATYPE_INT64,
                                    PROCFLAG.DATATYPE_FLOAT,
                                    PROCFLAG.DATATYPE_DOUBLE]
             DTYPE_WIDTH = [1, 2, 4, 8, 4, 8]
             def get_dtype_index(numpy_dtype):
                 index = None
                 for i in range(len(NUMPY_DTYPE_LIST)):
                     if numpy_dtype == NUMPY_DTYPE_LIST[i]:
                         index = i
                         break
                 return index
             def get_numpy_dtype(index):
                 return NUMPY_DTYPE_LIST[index]
             def get_procflag_dtype(index):
                 return PROCFLAG_DTYPE_LIST[index]
             def get_dtype_width(index):
                 return DTYPE_WIDTH[index]

schainpy/model/graphics/__init__.py +1 0

             from .jroplot_voltage import *
             from .jroplot_spectra import *
             from .jroplot_heispectra import *
             from .jroplot_correlation import *
             from .jroplot_parameters import *
+            from .jroplot_voltage_lags import *

schainpy/model/graphics/jroplot_base.py +6 -2

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

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

             import os
             import datetime
             import numpy
             from schainpy.model.graphics.jroplot_base import Plot, plt
             from schainpy.model.graphics.jroplot_spectra import SpectraPlot, RTIPlot, CoherencePlot
             from schainpy.utils import log
             EARTH_RADIUS = 6.3710e3
             def ll2xy(lat1, lon1, lat2, lon2):
                 p = 0.017453292519943295
                 a = 0.5 - numpy.cos((lat2 - lat1) * p)/2 + numpy.cos(lat1 * p) * \
                     numpy.cos(lat2 * p) * (1 - numpy.cos((lon2 - lon1) * p)) / 2
                 r = 12742 * numpy.arcsin(numpy.sqrt(a))
                 theta = numpy.arctan2(numpy.sin((lon2-lon1)*p)*numpy.cos(lat2*p), numpy.cos(lat1*p)
                                       * numpy.sin(lat2*p)-numpy.sin(lat1*p)*numpy.cos(lat2*p)*numpy.cos((lon2-lon1)*p))
                 theta = -theta + numpy.pi/2
                 return r*numpy.cos(theta), r*numpy.sin(theta)
             def km2deg(km):
                 '''
                 Convert distance in km to degrees
                 '''
                 return numpy.rad2deg(km/EARTH_RADIUS)
             class SpectralMomentsPlot(SpectraPlot):
                 '''
                 Plot for Spectral Moments
                 '''
                 CODE = 'spc_moments'
                 colormap = 'jet'
                 plot_type = 'pcolor'
+            class SpectralFitObliquePlot(SpectraPlot):
+                '''
+                Plot for Spectral Oblique
+                '''
+                CODE = 'spc_moments'
+                colormap = 'jet'
+                plot_type = 'pcolor'
             class SnrPlot(RTIPlot):
                 '''
                 Plot for SNR Data
                 '''
                 CODE = 'snr'
                 colormap = 'jet'
             class DopplerPlot(RTIPlot):
                 '''
                 Plot for DOPPLER Data (1st moment)
                 '''
                 CODE = 'dop'
                 colormap = 'jet'
             class PowerPlot(RTIPlot):
                 '''
                 Plot for Power Data (0 moment)
                 '''
                 CODE = 'pow'
                 colormap = 'jet'
             class SpectralWidthPlot(RTIPlot):
                 '''
                 Plot for Spectral Width Data (2nd moment)
                 '''
                 CODE = 'width'
                 colormap = 'jet'
             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 ParametersPlot(RTIPlot):
                 '''
                 Plot for data_param object
                 '''
                 CODE = 'param'
                 colormap = 'seismic'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = self.data.shape(self.CODE)[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'
                     if self.showSNR:
                         self.nrows += 1
                         self.nplots += 1
                     self.ylabel = 'Height [km]'
                     if not self.titles:
                         self.titles = self.data.parameters \
                             if self.data.parameters else ['Param {}'.format(x) for x in range(self.nrows)]
                         if self.showSNR:
                             self.titles.append('SNR')
                 def plot(self):
                     self.data.normalize_heights()
                     self.x = self.data.times
                     self.y = self.data.heights
                     if self.showSNR:
                         self.z = numpy.concatenate(
                             (self.data[self.CODE], self.data['snr'])
                         )
                     else:
                         self.z = self.data[self.CODE]
                     self.z = numpy.ma.masked_invalid(self.z)
                     if self.decimation is None:
                         x, y, z = self.fill_gaps(self.x, self.y, self.z)
                     else:
                         x, y, z = self.fill_gaps(*self.decimate())
                     for n, ax in enumerate(self.axes):
                         self.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 OutputPlot(ParametersPlot):
                 '''
                 Plot data_output object
                 '''
                 CODE = 'output'
                 colormap = 'seismic'
             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.heights)+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.heights)
                             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]

schainpy/model/graphics/jroplot_spectra.py +535 -5

             '''
             Created on Jul 9, 2014
             Modified on May 10, 2020
             @author: Juan C. Espinoza
             '''
             import os
             import datetime
             import numpy
             from schainpy.model.graphics.jroplot_base import Plot, plt
             class SpectraPlot(Plot):
                 '''
                 Plot for Spectra data
                 '''
                 CODE = 'spc'
                 colormap = 'jet'
                 plot_type = 'pcolor'
                 def setup(self):
                     self.nplots = len(self.data.channels)
                     self.ncols = int(numpy.sqrt(self.nplots) + 0.9)
                     self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
                     self.height = 2.6 * self.nrows
                     self.cb_label = 'dB'
                     if self.showprofile:
                         self.width = 4 * self.ncols
                     else:
                         self.width = 3.5 * self.ncols
-                    self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
+                    self.plots_adjust.update({'wspace': 0.8, 'hspace':0.2, 'left': 0.2, 'right': 0.9, 'bottom': 0.18})
                     self.ylabel = 'Range [km]'
                 def plot(self):
+                    #print(self.xaxis)
+                    #exit(1)
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     if self.CODE == 'spc_moments':
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.heights
                     self.y = y
                     z = self.data['spc']
+                    self.CODE2 = 'spc_oblique'
                     for n, ax in enumerate(self.axes):
                         noise = self.data['noise'][n][-1]
                         if self.CODE == 'spc_moments':
                             mean = self.data['moments'][n, :, 1, :][-1]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
+                            #print(numpy.shape(x))
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
                                 ax.plt_profile = self.pf_axes[n].plot(
                                     self.data['rti'][n][-1], y)[0]
                                 ax.plt_noise = self.pf_axes[n].plot(numpy.repeat(noise, len(y)), y,
                                                                     color="k", linestyle="dashed", lw=1)[0]
                             if self.CODE == 'spc_moments':
                                 ax.plt_mean = ax.plot(mean, y, color='k')[0]
                         else:
                             ax.plt.set_array(z[n].T.ravel())
                             if self.showprofile:
                                 ax.plt_profile.set_data(self.data['rti'][n][-1], y)
                                 ax.plt_noise.set_data(numpy.repeat(noise, len(y)), y)
                             if self.CODE == 'spc_moments':
                                 ax.plt_mean.set_data(mean, y)
                         self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
+            class SpectraObliquePlot(Plot):
+                '''
+                Plot for Spectra data
+                '''
+                CODE = 'spc'
+                colormap = 'jet'
+                plot_type = 'pcolor'
+                def setup(self):
+                    self.xaxis = "oblique"
+                    self.nplots = len(self.data.channels)
+                    self.ncols = int(numpy.sqrt(self.nplots) + 0.9)
+                    self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
+                    self.height = 2.6 * self.nrows
+                    self.cb_label = 'dB'
+                    if self.showprofile:
+                        self.width = 4 * self.ncols
+                    else:
+                        self.width = 3.5 * self.ncols
+                    self.plots_adjust.update({'wspace': 0.8, 'hspace':0.2, 'left': 0.2, 'right': 0.9, 'bottom': 0.18})
+                    self.ylabel = 'Range [km]'
+                def plot(self):
+                    #print(self.xaxis)
+                    #exit(1)
+                    if self.xaxis == "frequency":
+                        x = self.data.xrange[0]
+                        self.xlabel = "Frequency (kHz)"
+                    elif self.xaxis == "time":
+                        x = self.data.xrange[1]
+                        self.xlabel = "Time (ms)"
+                    else:
+                        x = self.data.xrange[2]
+                        self.xlabel = "Velocity (m/s)"
+                    if self.CODE == 'spc_moments':
+                        x = self.data.xrange[2]
+                        self.xlabel = "Velocity (m/s)"
+                    self.titles = []
+                    #self.xlabel = "Velocidad (m/s)"
+                    #self.ylabel = 'Rango (km)'
+                    y = self.data.heights
+                    self.y = y
+                    z = self.data['spc']
+                    self.CODE2 = 'spc_oblique'
+                    for n, ax in enumerate(self.axes):
+                        noise = self.data['noise'][n][-1]
+                        if self.CODE == 'spc_moments':
+                            mean = self.data['moments'][n, :, 1, :][-1]
+                        if self.CODE2 == 'spc_oblique':
+                            shift1 = self.data.shift1
+                            shift2 = self.data.shift2
+                        if ax.firsttime:
+                            self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
+                            self.xmin = self.xmin if self.xmin else -self.xmax
+                            self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
+                            self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
+                            #print(numpy.shape(x))
+                            ax.plt = ax.pcolormesh(x, y, z[n].T,
+                                                   vmin=self.zmin,
+                                                   vmax=self.zmax,
+                                                   cmap=plt.get_cmap(self.colormap)
+                                                   )
+                            if self.showprofile:
+                                ax.plt_profile = self.pf_axes[n].plot(
+                                    self.data['rti'][n][-1], y)[0]
+                                ax.plt_noise = self.pf_axes[n].plot(numpy.repeat(noise, len(y)), y,
+                                                                    color="k", linestyle="dashed", lw=1)[0]
+                            if self.CODE == 'spc_moments':
+                                ax.plt_mean = ax.plot(mean, y, color='k')[0]
+                            if self.CODE2 == 'spc_oblique':
+                                #ax.plt_shift1 = ax.plot(shift1, y, color='k', marker='x', linestyle='None', markersize=0.5)[0]
+                                #ax.plt_shift2 = ax.plot(shift2, y, color='m', marker='x', linestyle='None', markersize=0.5)[0]
+                                self.ploterr1 = ax.errorbar(shift1, y, xerr=self.data.shift1_error,fmt='k^',elinewidth=0.2,marker='x',linestyle='None',markersize=0.5,capsize=0.3,markeredgewidth=0.2)
+                                self.ploterr2 = ax.errorbar(shift2, y, xerr=self.data.shift2_error,fmt='m^',elinewidth=0.2,marker='x',linestyle='None',markersize=0.5,capsize=0.3,markeredgewidth=0.2)
+                        else:
+                            self.ploterr1.remove()
+                            self.ploterr2.remove()
+                            ax.plt.set_array(z[n].T.ravel())
+                            if self.showprofile:
+                                ax.plt_profile.set_data(self.data['rti'][n][-1], y)
+                                ax.plt_noise.set_data(numpy.repeat(noise, len(y)), y)
+                            if self.CODE == 'spc_moments':
+                                ax.plt_mean.set_data(mean, y)
+                            if self.CODE2 == 'spc_oblique':
+                                #ax.plt_shift1.set_data(shift1, y)
+                                #ax.plt_shift2.set_data(shift2, y)
+                                #ax.clf()
+                                self.ploterr1 = ax.errorbar(shift1, y, xerr=self.data.shift1_error,fmt='k^',elinewidth=0.2,marker='x',linestyle='None',markersize=0.5,capsize=0.3,markeredgewidth=0.2)
+                                self.ploterr2 = ax.errorbar(shift2, y, xerr=self.data.shift2_error,fmt='m^',elinewidth=0.2,marker='x',linestyle='None',markersize=0.5,capsize=0.3,markeredgewidth=0.2)
+                        self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
+                        #self.titles.append('{}'.format('Velocidad Doppler'))
             class CrossSpectraPlot(Plot):
                 CODE = 'cspc'
                 colormap = 'jet'
                 plot_type = 'pcolor'
                 zmin_coh = None
                 zmax_coh = None
                 zmin_phase = None
                 zmax_phase = None
                 def setup(self):
                     self.ncols = 4
                     self.nrows = len(self.data.pairs)
                     self.nplots = self.nrows * 4
                     self.width = 3.1 * self.ncols
-                    self.height = 2.6 * self.nrows
+                    self.height = 5 * self.nrows
                     self.ylabel = 'Range [km]'
                     self.showprofile = False
                     self.plots_adjust.update({'left': 0.08, 'right': 0.92, 'wspace': 0.5, 'hspace':0.4, 'top':0.95, 'bottom': 0.08})
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.heights
                     self.y = y
                     nspc = self.data['spc']
+                    #print(numpy.shape(self.data['spc']))
                     spc = self.data['cspc'][0]
+                    #print(numpy.shape(spc))
+                    #exit()
                     cspc = self.data['cspc'][1]
+                    #print(numpy.shape(cspc))
+                    #exit()
                     for n in range(self.nrows):
                         noise = self.data['noise'][:,-1]
                         pair = self.data.pairs[n]
+                        #print(pair)
+                        #exit()
                         ax = self.axes[4 * n]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
-                            self.xmin = self.xmin if self.xmin else -self.xmax
+                            #self.xmin = self.xmin if self.xmin else -self.xmax
+                            self.xmin = self.xmin if self.xmin else numpy.nanmin(x)
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(nspc)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(nspc)
+                            #print(numpy.nanmin(x))
+                            #print(self.xmax)
+                            #print(self.xmin)
+                            #exit()
+                            #self.xmin=-.1
                             ax.plt = ax.pcolormesh(x , y , nspc[pair[0]].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.set_array(nspc[pair[0]].T.ravel())
                         self.titles.append('CH {}: {:3.2f}dB'.format(pair[0], noise[pair[0]]))
                         ax = self.axes[4 * n + 1]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x , y, nspc[pair[1]].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.set_array(nspc[pair[1]].T.ravel())
                         self.titles.append('CH {}: {:3.2f}dB'.format(pair[1], noise[pair[1]]))
                         out = cspc[n] / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
                         coh = numpy.abs(out)
                         phase = numpy.arctan2(out.imag, out.real) * 180 / numpy.pi
                         ax = self.axes[4 * n + 2]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, coh.T,
                                                    vmin=0,
                                                    vmax=1,
                                                    cmap=plt.get_cmap(self.colormap_coh)
                                                    )
                         else:
                             ax.plt.set_array(coh.T.ravel())
                         self.titles.append(
                             'Coherence Ch{} * Ch{}'.format(pair[0], pair[1]))
                         ax = self.axes[4 * n + 3]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, phase.T,
                                                    vmin=-180,
                                                    vmax=180,
                                                    cmap=plt.get_cmap(self.colormap_phase)
                                                    )
                         else:
                             ax.plt.set_array(phase.T.ravel())
                         self.titles.append('Phase CH{} * CH{}'.format(pair[0], pair[1]))
+            class CrossSpectra4Plot(Plot):
+                CODE = 'cspc'
+                colormap = 'jet'
+                plot_type = 'pcolor'
+                zmin_coh = None
+                zmax_coh = None
+                zmin_phase = None
+                zmax_phase = None
+                def setup(self):
+                    self.ncols = 4
+                    self.nrows = len(self.data.pairs)
+                    self.nplots = self.nrows * 4
+                    self.width = 3.1 * self.ncols
+                    self.height = 5 * self.nrows
+                    self.ylabel = 'Range [km]'
+                    self.showprofile = False
+                    self.plots_adjust.update({'left': 0.08, 'right': 0.92, 'wspace': 0.5, 'hspace':0.4, 'top':0.95, 'bottom': 0.08})
+                def plot(self):
+                    if self.xaxis == "frequency":
+                        x = self.data.xrange[0]
+                        self.xlabel = "Frequency (kHz)"
+                    elif self.xaxis == "time":
+                        x = self.data.xrange[1]
+                        self.xlabel = "Time (ms)"
+                    else:
+                        x = self.data.xrange[2]
+                        self.xlabel = "Velocity (m/s)"
+                    self.titles = []
+                    y = self.data.heights
+                    self.y = y
+                    nspc = self.data['spc']
+                    #print(numpy.shape(self.data['spc']))
+                    spc = self.data['cspc'][0]
+                    #print(numpy.shape(nspc))
+                    #exit()
+                    #nspc[1,:,:] = numpy.flip(nspc[1,:,:],axis=0)
+                    #print(numpy.shape(spc))
+                    #exit()
+                    cspc = self.data['cspc'][1]
+                    #xflip=numpy.flip(x)
+                    #print(numpy.shape(cspc))
+                    #exit()
+                    for n in range(self.nrows):
+                        noise = self.data['noise'][:,-1]
+                        pair = self.data.pairs[n]
+                        #print(pair)
+                        #exit()
+                        ax = self.axes[4 * n]
+                        if ax.firsttime:
+                            self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
+                            self.xmin = self.xmin if self.xmin else -self.xmax
+                            self.zmin = self.zmin if self.zmin else numpy.nanmin(nspc)
+                            self.zmax = self.zmax if self.zmax else numpy.nanmax(nspc)
+                            ax.plt = ax.pcolormesh(x , y , nspc[pair[0]].T,
+                                                   vmin=self.zmin,
+                                                   vmax=self.zmax,
+                                                   cmap=plt.get_cmap(self.colormap)
+                                                   )
+                        else:
+                            #print(numpy.shape(nspc[pair[0]].T))
+                            #exit()
+                            ax.plt.set_array(nspc[pair[0]].T.ravel())
+                        self.titles.append('CH {}: {:3.2f}dB'.format(pair[0], noise[pair[0]]))
+                        ax = self.axes[4 * n + 1]
+                        if ax.firsttime:
+                            ax.plt = ax.pcolormesh(x , y, numpy.flip(nspc[pair[1]],axis=0).T,
+                                                   vmin=self.zmin,
+                                                   vmax=self.zmax,
+                                                   cmap=plt.get_cmap(self.colormap)
+                                                   )
+                        else:
+                            ax.plt.set_array(numpy.flip(nspc[pair[1]],axis=0).T.ravel())
+                        self.titles.append('CH {}: {:3.2f}dB'.format(pair[1], noise[pair[1]]))
+                        out = cspc[n] / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
+                        coh = numpy.abs(out)
+                        phase = numpy.arctan2(out.imag, out.real) * 180 / numpy.pi
+                        ax = self.axes[4 * n + 2]
+                        if ax.firsttime:
+                            ax.plt = ax.pcolormesh(x, y, numpy.flip(coh,axis=0).T,
+                                                   vmin=0,
+                                                   vmax=1,
+                                                   cmap=plt.get_cmap(self.colormap_coh)
+                                                   )
+                        else:
+                            ax.plt.set_array(numpy.flip(coh,axis=0).T.ravel())
+                        self.titles.append(
+                            'Coherence Ch{} * Ch{}'.format(pair[0], pair[1]))
+                        ax = self.axes[4 * n + 3]
+                        if ax.firsttime:
+                            ax.plt = ax.pcolormesh(x, y, numpy.flip(phase,axis=0).T,
+                                                   vmin=-180,
+                                                   vmax=180,
+                                                   cmap=plt.get_cmap(self.colormap_phase)
+                                                   )
+                        else:
+                            ax.plt.set_array(numpy.flip(phase,axis=0).T.ravel())
+                        self.titles.append('Phase CH{} * CH{}'.format(pair[0], pair[1]))
+            class CrossSpectra2Plot(Plot):
+                CODE = 'cspc'
+                colormap = 'jet'
+                plot_type = 'pcolor'
+                zmin_coh = None
+                zmax_coh = None
+                zmin_phase = None
+                zmax_phase = None
+                def setup(self):
+                    self.ncols = 1
+                    self.nrows = len(self.data.pairs)
+                    self.nplots = self.nrows * 1
+                    self.width = 3.1 * self.ncols
+                    self.height = 5 * self.nrows
+                    self.ylabel = 'Range [km]'
+                    self.showprofile = False
+                    self.plots_adjust.update({'left': 0.22, 'right': .90, 'wspace': 0.5, 'hspace':0.4, 'top':0.95, 'bottom': 0.08})
+                def plot(self):
+                    if self.xaxis == "frequency":
+                        x = self.data.xrange[0]
+                        self.xlabel = "Frequency (kHz)"
+                    elif self.xaxis == "time":
+                        x = self.data.xrange[1]
+                        self.xlabel = "Time (ms)"
+                    else:
+                        x = self.data.xrange[2]
+                        self.xlabel = "Velocity (m/s)"
+                    self.titles = []
+                    y = self.data.heights
+                    self.y = y
+                    #nspc = self.data['spc']
+                    #print(numpy.shape(self.data['spc']))
+                    #spc = self.data['cspc'][0]
+                    #print(numpy.shape(spc))
+                    #exit()
+                    cspc = self.data['cspc'][1]
+                    #print(numpy.shape(cspc))
+                    #exit()
+                    for n in range(self.nrows):
+                        noise = self.data['noise'][:,-1]
+                        pair = self.data.pairs[n]
+                        #print(pair)            #exit()
+                        out = cspc[n]# / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
+                        #print(out[:,53])
+                        #exit()
+                        cross = numpy.abs(out)
+                        z = cross/self.data.nFactor
+                        #print("here")
+                        #print(dataOut.data_spc[0,0,0])
+                        #exit()
+                        cross = 10*numpy.log10(z)
+                        #print(numpy.shape(cross))
+                        #print(cross[0,:])
+                        #print(self.data.nFactor)
+                        #exit()
+                        #phase = numpy.arctan2(out.imag, out.real) * 180 / numpy.pi
+                        ax = self.axes[1 * n]
+                        if ax.firsttime:
+                            self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
+                            self.xmin = self.xmin if self.xmin else -self.xmax
+                            self.zmin = self.zmin if self.zmin else numpy.nanmin(cross)
+                            self.zmax = self.zmax if self.zmax else numpy.nanmax(cross)
+                            ax.plt = ax.pcolormesh(x, y, cross.T,
+                                                   vmin=self.zmin,
+                                                   vmax=self.zmax,
+                                                   cmap=plt.get_cmap(self.colormap)
+                                                   )
+                        else:
+                            ax.plt.set_array(cross.T.ravel())
+                        self.titles.append(
+                            'Cross Spectra Power Ch{} * Ch{}'.format(pair[0], pair[1]))
+            class CrossSpectra3Plot(Plot):
+                CODE = 'cspc'
+                colormap = 'jet'
+                plot_type = 'pcolor'
+                zmin_coh = None
+                zmax_coh = None
+                zmin_phase = None
+                zmax_phase = None
+                def setup(self):
+                    self.ncols = 3
+                    self.nrows = len(self.data.pairs)
+                    self.nplots = self.nrows * 3
+                    self.width = 3.1 * self.ncols
+                    self.height = 5 * self.nrows
+                    self.ylabel = 'Range [km]'
+                    self.showprofile = False
+                    self.plots_adjust.update({'left': 0.22, 'right': .90, 'wspace': 0.5, 'hspace':0.4, 'top':0.95, 'bottom': 0.08})
+                def plot(self):
+                    if self.xaxis == "frequency":
+                        x = self.data.xrange[0]
+                        self.xlabel = "Frequency (kHz)"
+                    elif self.xaxis == "time":
+                        x = self.data.xrange[1]
+                        self.xlabel = "Time (ms)"
+                    else:
+                        x = self.data.xrange[2]
+                        self.xlabel = "Velocity (m/s)"
+                    self.titles = []
+                    y = self.data.heights
+                    self.y = y
+                    #nspc = self.data['spc']
+                    #print(numpy.shape(self.data['spc']))
+                    #spc = self.data['cspc'][0]
+                    #print(numpy.shape(spc))
+                    #exit()
+                    cspc = self.data['cspc'][1]
+                    #print(numpy.shape(cspc))
+                    #exit()
+                    for n in range(self.nrows):
+                        noise = self.data['noise'][:,-1]
+                        pair = self.data.pairs[n]
+                        #print(pair)            #exit()
+                        out = cspc[n]# / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
+                        #print(out[:,53])
+                        #exit()
+                        cross = numpy.abs(out)
+                        z = cross/self.data.nFactor
+                        cross = 10*numpy.log10(z)
+                        out_r= out.real/self.data.nFactor
+                        #out_r = 10*numpy.log10(out_r)
+                        out_i= out.imag/self.data.nFactor
+                        #out_i = 10*numpy.log10(out_i)
+                        #print(numpy.shape(cross))
+                        #print(cross[0,:])
+                        #print(self.data.nFactor)
+                        #exit()
+                        #phase = numpy.arctan2(out.imag, out.real) * 180 / numpy.pi
+                        ax = self.axes[3 * n]
+                        if ax.firsttime:
+                            self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
+                            self.xmin = self.xmin if self.xmin else -self.xmax
+                            self.zmin = self.zmin if self.zmin else numpy.nanmin(cross)
+                            self.zmax = self.zmax if self.zmax else numpy.nanmax(cross)
+                            ax.plt = ax.pcolormesh(x, y, cross.T,
+                                                   vmin=self.zmin,
+                                                   vmax=self.zmax,
+                                                   cmap=plt.get_cmap(self.colormap)
+                                                   )
+                        else:
+                            ax.plt.set_array(cross.T.ravel())
+                        self.titles.append(
+                            'Cross Spectra Power Ch{} * Ch{}'.format(pair[0], pair[1]))
+                        ax = self.axes[3 * n + 1]
+                        if ax.firsttime:
+                            self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
+                            self.xmin = self.xmin if self.xmin else -self.xmax
+                            self.zmin = self.zmin if self.zmin else numpy.nanmin(cross)
+                            self.zmax = self.zmax if self.zmax else numpy.nanmax(cross)
+                            ax.plt = ax.pcolormesh(x, y, out_r.T,
+                                                   vmin=-1.e6,
+                                                   vmax=0,
+                                                   cmap=plt.get_cmap(self.colormap)
+                                                   )
+                        else:
+                            ax.plt.set_array(out_r.T.ravel())
+                        self.titles.append(
+                            'Cross Spectra Real Ch{} * Ch{}'.format(pair[0], pair[1]))
+                        ax = self.axes[3 * n + 2]
+                        if ax.firsttime:
+                            self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
+                            self.xmin = self.xmin if self.xmin else -self.xmax
+                            self.zmin = self.zmin if self.zmin else numpy.nanmin(cross)
+                            self.zmax = self.zmax if self.zmax else numpy.nanmax(cross)
+                            ax.plt = ax.pcolormesh(x, y, out_i.T,
+                                                   vmin=-1.e6,
+                                                   vmax=1.e6,
+                                                   cmap=plt.get_cmap(self.colormap)
+                                                   )
+                        else:
+                            ax.plt.set_array(out_i.T.ravel())
+                        self.titles.append(
+                            'Cross Spectra Imag Ch{} * Ch{}'.format(pair[0], pair[1]))
             class RTIPlot(Plot):
                 '''
                 Plot for RTI data
                 '''
                 CODE = 'rti'
                 colormap = 'jet'
                 plot_type = 'pcolorbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = len(self.data.channels)
                     self.nplots = len(self.data.channels)
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Time'
                     self.cb_label = 'dB'
-                    self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.08, 'right':0.95})
+                    self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.1, 'right':0.95})
                     self.titles = ['{} Channel {}'.format(
                         self.CODE.upper(), x) for x in range(self.nrows)]
                 def plot(self):
                     self.x = self.data.times
                     self.y = self.data.heights
                     self.z = self.data[self.CODE]
+                    self.z = numpy.ma.masked_invalid(self.z)
+                    if self.decimation is None:
+                        x, y, z = self.fill_gaps(self.x, self.y, self.z)
+                    else:
+                        x, y, z = self.fill_gaps(*self.decimate())
+                    for n, ax in enumerate(self.axes):
+                        self.zmin = self.zmin if self.zmin else numpy.min(self.z)
+                        self.zmax = self.zmax if self.zmax else numpy.max(self.z)
+                        if ax.firsttime:
+                            ax.plt = ax.pcolormesh(x, y, z[n].T,
+                                                   vmin=self.zmin,
+                                                   vmax=self.zmax,
+                                                   cmap=plt.get_cmap(self.colormap)
+                                                   )
+                            if self.showprofile:
+                                ax.plot_profile = self.pf_axes[n].plot(
+                                    self.data['rti'][n][-1], self.y)[0]
+                                ax.plot_noise = self.pf_axes[n].plot(numpy.repeat(self.data['noise'][n][-1], len(self.y)), self.y,
+                                                                     color="k", linestyle="dashed", lw=1)[0]
+                        else:
+                            ax.collections.remove(ax.collections[0])
+                            ax.plt = ax.pcolormesh(x, y, z[n].T,
+                                                   vmin=self.zmin,
+                                                   vmax=self.zmax,
+                                                   cmap=plt.get_cmap(self.colormap)
+                                                   )
+                            if self.showprofile:
+                                ax.plot_profile.set_data(self.data['rti'][n][-1], self.y)
+                                ax.plot_noise.set_data(numpy.repeat(
+                                    self.data['noise'][n][-1], len(self.y)), self.y)
+            class SpectrogramPlot(Plot):
+                '''
+                Plot for Spectrogram data
+                '''
+                CODE = 'spectrogram'
+                colormap = 'binary'
+                plot_type = 'pcolorbuffer'
+                def setup(self):
+                    self.xaxis = 'time'
+                    self.ncols = 1
+                    self.nrows = len(self.data.channels)
+                    self.nplots = len(self.data.channels)
+                    #print(self.dataOut.heightList)
+                    #self.ylabel = 'Range [km]'
+                    self.xlabel = 'Time'
+                    self.cb_label = 'dB'
+                    self.plots_adjust.update({'hspace':1.2, 'left': 0.1, 'bottom': 0.12, 'right':0.95})
+                    self.titles = ['{} Channel {} \n H = {} km ({} - {})'.format(
+                        self.CODE.upper(), x, self.data.heightList[self.data.hei], self.data.heightList[self.data.hei],self.data.heightList[self.data.hei]+(self.data.DH*self.data.nProfiles)) for x in range(self.nrows)]
+                def plot(self):
+                    self.x = self.data.times
+                    #self.y = self.data.heights
+                    self.z = self.data[self.CODE]
+                    self.y = self.data.xrange[0]
+                    #import time
+                    #print(time.ctime(self.x))
+                    '''
+                    print(numpy.shape(self.x))
+                    print(numpy.shape(self.y))
+                    print(numpy.shape(self.z))
+                    '''
+                    self.ylabel = "Frequency (kHz)"
                     self.z = numpy.ma.masked_invalid(self.z)
                     if self.decimation is None:
                         x, y, z = self.fill_gaps(self.x, self.y, self.z)
                     else:
                         x, y, z = self.fill_gaps(*self.decimate())
                     for n, ax in enumerate(self.axes):
                         self.zmin = self.zmin if self.zmin else numpy.min(self.z)
                         self.zmax = self.zmax if self.zmax else numpy.max(self.z)
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
                                 ax.plot_profile = self.pf_axes[n].plot(
                                     self.data['rti'][n][-1], self.y)[0]
                                 ax.plot_noise = self.pf_axes[n].plot(numpy.repeat(self.data['noise'][n][-1], len(self.y)), self.y,
                                                                      color="k", linestyle="dashed", lw=1)[0]
                         else:
                             ax.collections.remove(ax.collections[0])
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
                                 ax.plot_profile.set_data(self.data['rti'][n][-1], self.y)
                                 ax.plot_noise.set_data(numpy.repeat(
                                     self.data['noise'][n][-1], len(self.y)), self.y)
             class CoherencePlot(RTIPlot):
                 '''
                 Plot for Coherence data
                 '''
                 CODE = 'coh'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = len(self.data.pairs)
                     self.nplots = len(self.data.pairs)
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Time'
                     self.plots_adjust.update({'hspace':0.6, 'left': 0.1, 'bottom': 0.1,'right':0.95})
                     if self.CODE == 'coh':
                         self.cb_label = ''
                         self.titles = [
                             'Coherence Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
                     else:
                         self.cb_label = 'Degrees'
                         self.titles = [
                             'Phase Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
             class PhasePlot(CoherencePlot):
                 '''
                 Plot for Phase map data
                 '''
                 CODE = 'phase'
                 colormap = 'seismic'
             class NoisePlot(Plot):
                 '''
                 Plot for noise
                 '''
                 CODE = 'noise'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Intensity [dB]'
                     self.xlabel = 'Time'
                     self.titles = ['Noise']
                     self.colorbar = False
+                    self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.17, 'right':0.95})
                 def plot(self):
                     x = self.data.times
                     xmin = self.data.min_time
                     xmax = xmin + self.xrange * 60 * 60
                     Y = self.data[self.CODE]
                     if self.axes[0].firsttime:
                         for ch in self.data.channels:
                             y = Y[ch]
                             self.axes[0].plot(x, y, lw=1, label='Ch{}'.format(ch))
                         plt.legend()
                     else:
                         for ch in self.data.channels:
                             y = Y[ch]
                             self.axes[0].lines[ch].set_data(x, y)
                     self.ymin = numpy.nanmin(Y) - 5
-                    self.ymax = numpy.nanmax(Y) + 5
+                    self.ymax = numpy.nanmax(Y) + 10
             class PowerProfilePlot(Plot):
                 CODE = 'spcprofile'
                 plot_type = 'scatter'
                 buffering = False
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.height = 4
                     self.width = 3
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Intensity [dB]'
                     self.titles = ['Power Profile']
                     self.colorbar = False
                 def plot(self):
                     y = self.data.heights
                     self.y = y
                     x = self.data['spcprofile']
                     if self.xmin is None: self.xmin = numpy.nanmin(x)*0.9
                     if self.xmax is None: self.xmax = numpy.nanmax(x)*1.1
                     if self.axes[0].firsttime:
                         for ch in self.data.channels:
                             self.axes[0].plot(x[ch], y, lw=1, label='Ch{}'.format(ch))
                         plt.legend()
                     else:
                         for ch in self.data.channels:
                             self.axes[0].lines[ch].set_data(x[ch], y)
             class SpectraCutPlot(Plot):
                 CODE = 'spc_cut'
                 plot_type = 'scatter'
                 buffering = False
                 def setup(self):
                     self.nplots = len(self.data.channels)
                     self.ncols = int(numpy.sqrt(self.nplots) + 0.9)
                     self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
                     self.width = 3.4 * self.ncols + 1.5
                     self.height = 3 * self.nrows
                     self.ylabel = 'Power [dB]'
                     self.colorbar = False
                     self.plots_adjust.update({'left':0.1, 'hspace':0.3, 'right': 0.75, 'bottom':0.08})
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0][1:]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.heights
                     #self.y = y
                     z = self.data['spc_cut']
                     if self.height_index:
                         index = numpy.array(self.height_index)
                     else:
                         index = numpy.arange(0, len(y), int((len(y))/9))
                     for n, ax in enumerate(self.axes):
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.ymin = self.ymin if self.ymin else numpy.nanmin(z)
                             self.ymax = self.ymax if self.ymax else numpy.nanmax(z)
                             ax.plt = ax.plot(x, z[n, :, index].T)
                             labels = ['Range = {:2.1f}km'.format(y[i]) for i in index]
                             self.figures[0].legend(ax.plt, labels, loc='center right')
                         else:
                             for i, line in enumerate(ax.plt):
                                 line.set_data(x, z[n, :, i])
                         self.titles.append('CH {}'.format(n))
             class BeaconPhase(Plot):
                 __isConfig = None
                 __nsubplots = None
                 PREFIX = 'beacon_phase'
                 def __init__(self):
                     Plot.__init__(self)
                     self.timerange = 24*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.counter_imagwr = 0
                     self.WIDTH = 800
                     self.HEIGHT = 400
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.xdata = None
                     self.ydata = None
                     self.PLOT_CODE = BEACON_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.filename_phase = None
                     self.figfile = None
                     self.xmin = None
                     self.xmax = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 7
                     colspan = 6
                     self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH+self.WIDTHPROF,
                                       heightplot = self.HEIGHT+self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
                 def save_phase(self, filename_phase):
                     f = open(filename_phase,'w+')
                     f.write('\n\n')
                     f.write('JICAMARCA RADIO OBSERVATORY - Beacon Phase \n')
                     f.write('DD MM YYYY  HH MM SS   pair(2,0) pair(2,1) pair(2,3) pair(2,4)\n\n' )
                     f.close()
                 def save_data(self, filename_phase, data, data_datetime):
                     f=open(filename_phase,'a')
                     timetuple_data = data_datetime.timetuple()
                     day = str(timetuple_data.tm_mday)
                     month = str(timetuple_data.tm_mon)
                     year = str(timetuple_data.tm_year)
                     hour = str(timetuple_data.tm_hour)
                     minute = str(timetuple_data.tm_min)
                     second = str(timetuple_data.tm_sec)
                     f.write(day+' '+month+' '+year+'  '+hour+' '+minute+' '+second+'   '+str(data[0])+'   '+str(data[1])+'   '+str(data[2])+'   '+str(data[3])+'\n')
                     f.close()
                 def plot(self):
                     log.warning('TODO: Not yet implemented...')
                 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None, hmin=None, hmax=None,
                         timerange=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     if dataOut.flagNoData:
                         return dataOut
                     if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
                         return
                     if pairsList == None:
                         pairsIndexList = dataOut.pairsIndexList[:10]
                     else:
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in dataOut.pairsList:
                                 raise ValueError("Pair %s is not in dataOut.pairsList" %(pair))
                             pairsIndexList.append(dataOut.pairsList.index(pair))
                     if pairsIndexList == []:
                         return
              #         if len(pairsIndexList) > 4:
              #             pairsIndexList = pairsIndexList[0:4]
                     hmin_index = None
                     hmax_index = None
                     if hmin != None and hmax != None:
                         indexes = numpy.arange(dataOut.nHeights)
                         hmin_list = indexes[dataOut.heightList >= hmin]
                         hmax_list = indexes[dataOut.heightList <= hmax]
                         if hmin_list.any():
                             hmin_index = hmin_list[0]
                         if hmax_list.any():
                             hmax_index = hmax_list[-1]+1
                     x = dataOut.getTimeRange()
                     thisDatetime = dataOut.datatime
                     title = wintitle + " Signal Phase" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = "Local Time"
                     ylabel = "Phase (degrees)"
                     update_figfile = False
                     nplots = len(pairsIndexList)
                     #phase = numpy.zeros((len(pairsIndexList),len(dataOut.beacon_heiIndexList)))
                     phase_beacon = numpy.zeros(len(pairsIndexList))
                     for i in range(nplots):
                         pair = dataOut.pairsList[pairsIndexList[i]]
                         ccf = numpy.average(dataOut.data_cspc[pairsIndexList[i], :, hmin_index:hmax_index], axis=0)
                         powa = numpy.average(dataOut.data_spc[pair[0], :, hmin_index:hmax_index], axis=0)
                         powb = numpy.average(dataOut.data_spc[pair[1], :, hmin_index:hmax_index], axis=0)
                         avgcoherenceComplex = ccf/numpy.sqrt(powa*powb)
                         phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
                         if dataOut.beacon_heiIndexList:
                             phase_beacon[i] = numpy.average(phase[dataOut.beacon_heiIndexList])
                         else:
                             phase_beacon[i] = numpy.average(phase)
                     if not self.isConfig:
                         nplots = len(pairsIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = 0
                         if ymax == None: ymax = 360
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                         self.xdata = numpy.array([])
                         self.ydata = numpy.array([])
                         update_figfile = True
                         #open file beacon phase
                         path = '%s%03d' %(self.PREFIX, self.id)
                         beacon_file = os.path.join(path,'%s.txt'%self.name)
                         self.filename_phase = os.path.join(figpath,beacon_file)
                         #self.save_phase(self.filename_phase)
                     #store data beacon phase
                     #self.save_data(self.filename_phase, phase_beacon, thisDatetime)
                     self.setWinTitle(title)
                     title = "Phase Plot %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                     legendlabels = ["Pair (%d,%d)"%(pair[0], pair[1]) for pair in dataOut.pairsList]
                     axes = self.axesList[0]
                     self.xdata = numpy.hstack((self.xdata, x[0:1]))
                     if len(self.ydata)==0:
                         self.ydata = phase_beacon.reshape(-1,1)
                     else:
                         self.ydata = numpy.hstack((self.ydata, phase_beacon.reshape(-1,1)))
                     axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
                                 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax,
                                 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
                                 XAxisAsTime=True, grid='both'
                                 )
                     self.draw()
                     if dataOut.ltctime >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
                     return dataOut

schainpy/model/io/__init__.py +5 0

             '''
             $Author: murco $
             $Id: JRODataIO.py 169 2012-11-19 21:57:03Z murco $
             '''
             from .jroIO_voltage import *
             from .jroIO_spectra import *
             from .jroIO_heispectra import *
             from .jroIO_usrp import *
             from .jroIO_digitalRF import *
             from .jroIO_kamisr import *
             from .jroIO_param import *
             from .jroIO_hf import *
             from .jroIO_madrigal import *
             from .bltrIO_param import *
             from .bltrIO_spectra import *
             from .jroIO_mira35c import *
             from .julIO_param import *
             from .pxIO_param import *
             from .jroIO_simulator import *
+            ############DP############
+            from .jroIO_dat import *
+            ############DP############

schainpy/model/io/jroIO_base.py +42 -2

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

schainpy/model/io/jroIO_madrigal.py +37 -3

             '''
             Created on Aug 1, 2017
             @author: Juan C. Espinoza
             '''
             import os
             import sys
             import time
             import json
             import glob
             import datetime
             import numpy
             import h5py
             import schainpy.admin
             from schainpy.model.io.jroIO_base import LOCALTIME, Reader
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
             from schainpy.model.data.jrodata import Parameters
             from schainpy.utils import log
             try:
                 import madrigal.cedar
             except:
                 pass
             try:
                 basestring
             except:
                 basestring = str
             DEF_CATALOG = {
                 'principleInvestigator': 'Marco Milla',
                 'expPurpose': '',
                 'cycleTime': '',
                 'correlativeExp': '',
                 'sciRemarks': '',
                 'instRemarks': ''
                 }
             DEF_HEADER = {
                 'kindatDesc': '',
                 'analyst': 'Jicamarca User',
                 'comments': '',
                 'history': ''
                 }
             MNEMONICS = {
 : 'jro',
 : 'jbr',
 : 'jul',
 : 'jas',
 : 'pbr',
 : 'hbr',
 : 'obr',
 : 'clr'
             }
             UT1970 = datetime.datetime(1970, 1, 1) - datetime.timedelta(seconds=time.timezone)
             def load_json(obj):
                 '''
                 Parse json as string instead of unicode
                 '''
                 if isinstance(obj, str):
                     iterable = json.loads(obj)
                 else:
                     iterable = obj
                 if isinstance(iterable, dict):
                     return {str(k): load_json(v) if isinstance(v, dict) else str(v) if isinstance(v, basestring) else v
                         for k, v in list(iterable.items())}
                 elif isinstance(iterable, (list, tuple)):
                     return [str(v) if isinstance(v, basestring) else v for v in iterable]
                 return iterable
             class MADReader(Reader, ProcessingUnit):
                 def __init__(self):
                     ProcessingUnit.__init__(self)
                     self.dataOut = Parameters()
                     self.counter_records = 0
                     self.nrecords = None
                     self.flagNoMoreFiles = 0
                     self.filename = None
                     self.intervals = set()
                     self.datatime = datetime.datetime(1900,1,1)
                     self.format = None
                     self.filefmt = "***%Y%m%d*******"
                 def setup(self, **kwargs):
                     self.set_kwargs(**kwargs)
                     self.oneDDict = load_json(self.oneDDict)
                     self.twoDDict = load_json(self.twoDDict)
                     self.ind2DList = load_json(self.ind2DList)
                     self.independentParam = self.ind2DList[0]
                     if self.path is None:
                         raise ValueError('The path is not valid')
                     self.open_file = open
                     self.open_mode = 'rb'
                     if self.format is None:
                         raise ValueError('The format is not valid choose simple or hdf5')
                     elif self.format.lower() in ('simple', 'txt'):
                         self.ext = '.txt'
                     elif self.format.lower() in ('cedar',):
                         self.ext = '.001'
                     else:
                         self.ext = '.hdf5'
                         self.open_file = h5py.File
                         self.open_mode = 'r'
                     if self.online:
                         log.log("Searching files in online mode...", self.name)
                         for nTries in range(self.nTries):
                             fullpath = self.searchFilesOnLine(self.path, self.startDate,
                                 self.endDate, self.expLabel, self.ext, self.walk,
                                 self.filefmt, self.folderfmt)
                             try:
                                 fullpath = next(fullpath)
                             except:
                                 fullpath = None
                             if fullpath:
                                 break
                             log.warning(
                                 'Waiting {} sec for a valid file in {}: try {} ...'.format(
                                     self.delay, self.path, nTries + 1),
                                 self.name)
                             time.sleep(self.delay)
                         if not(fullpath):
                             raise schainpy.admin.SchainError(
                                 'There isn\'t any valid file in {}'.format(self.path))
                     else:
                         log.log("Searching files in {}".format(self.path), self.name)
                         self.filenameList = self.searchFilesOffLine(self.path, self.startDate,
                             self.endDate, self.expLabel, self.ext, self.walk, self.filefmt, self.folderfmt)
                     self.setNextFile()
                 def readFirstHeader(self):
                     '''Read header and data'''
                     self.parseHeader()
                     self.parseData()
                     self.blockIndex = 0
                     return
                 def parseHeader(self):
                     '''
                     '''
                     self.output = {}
                     self.version = '2'
                     s_parameters = None
                     if self.ext == '.txt':
                         self.parameters = [s.strip().lower() for s in self.fp.readline().decode().strip().split(' ') if s]
                     elif self.ext == '.hdf5':
                         self.metadata = self.fp['Metadata']
                         if '_record_layout' in self.metadata:
                             s_parameters = [s[0].lower().decode() for s in self.metadata['Independent Spatial Parameters']]
                             self.version = '3'
                         self.parameters = [s[0].lower().decode() for s in self.metadata['Data Parameters']]
                     log.success('Parameters found: {}'.format(self.parameters),
                                 'MADReader')
                     if s_parameters:
                         log.success('Spatial parameters found: {}'.format(s_parameters),
                                     'MADReader')
                     for param in list(self.oneDDict.keys()):
                         if param.lower() not in self.parameters:
                             log.warning(
                                 'Parameter {} not found will be ignored'.format(
                                     param),
                                 'MADReader')
                             self.oneDDict.pop(param, None)
                     for param, value in list(self.twoDDict.items()):
                         if param.lower() not in self.parameters:
                             log.warning(
                                 'Parameter {} not found, it will be ignored'.format(
                                     param),
                                 'MADReader')
                             self.twoDDict.pop(param, None)
                             continue
                         if isinstance(value, list):
                             if value[0] not in self.output:
                                 self.output[value[0]] = []
                             self.output[value[0]].append([])
                 def parseData(self):
                     '''
                     '''
                     if self.ext == '.txt':
                         self.data = numpy.genfromtxt(self.fp, missing_values=('missing'))
                         self.nrecords = self.data.shape[0]
                         self.ranges = numpy.unique(self.data[:,self.parameters.index(self.independentParam.lower())])
                         self.counter_records = 0
                     elif self.ext == '.hdf5':
                         self.data = self.fp['Data']
                         self.ranges = numpy.unique(self.data['Table Layout'][self.independentParam.lower()])
                         self.times = numpy.unique(self.data['Table Layout']['ut1_unix'])
                         self.counter_records = int(self.data['Table Layout']['recno'][0])
                         self.nrecords = int(self.data['Table Layout']['recno'][-1])
                 def readNextBlock(self):
                     while True:
                         self.flagDiscontinuousBlock = 0
                         if self.counter_records == self.nrecords:
                             self.setNextFile()
                         self.readBlock()
                         if (self.datatime < datetime.datetime.combine(self.startDate, self.startTime)) or \
                            (self.datatime > datetime.datetime.combine(self.endDate, self.endTime)):
                             log.warning(
                                 'Reading Record No. {}/{} -> {} [Skipping]'.format(
                                     self.counter_records,
                                     self.nrecords,
                                     self.datatime.ctime()),
                                 'MADReader')
                             continue
                         break
                     log.log(
                         'Reading Record No. {}/{} -> {}'.format(
                             self.counter_records,
                             self.nrecords,
                             self.datatime.ctime()),
                         'MADReader')
                     return 1
                 def readBlock(self):
                     '''
                     '''
                     dum = []
                     if self.ext == '.txt':
                         dt = self.data[self.counter_records][:6].astype(int)
                         if datetime.datetime(dt[0], dt[1], dt[2], dt[3], dt[4], dt[5]).date() > self.datatime.date():
                             self.flagDiscontinuousBlock = 1
                         self.datatime = datetime.datetime(dt[0], dt[1], dt[2], dt[3], dt[4], dt[5])
                         while True:
                             dt = self.data[self.counter_records][:6].astype(int)
                             datatime = datetime.datetime(dt[0], dt[1], dt[2], dt[3], dt[4], dt[5])
                             if datatime == self.datatime:
                                 dum.append(self.data[self.counter_records])
                                 self.counter_records += 1
                                 if self.counter_records == self.nrecords:
                                     break
                                 continue
                             self.intervals.add((datatime-self.datatime).seconds)
                             break
                     elif self.ext == '.hdf5':
                         datatime = datetime.datetime.utcfromtimestamp(
                             self.times[self.counter_records])
                         dum = self.data['Table Layout'][self.data['Table Layout']['recno']==self.counter_records]
                         self.intervals.add((datatime-self.datatime).seconds)
                         if datatime.date()>self.datatime.date():
                             self.flagDiscontinuousBlock = 1
                         self.datatime = datatime
                         self.counter_records += 1
                     self.buffer = numpy.array(dum)
                     return
                 def set_output(self):
                     '''
                     Storing data from buffer to dataOut object
                     '''
                     parameters = [None for __ in self.parameters]
                     for param, attr in list(self.oneDDict.items()):
                         x = self.parameters.index(param.lower())
                         setattr(self.dataOut, attr, self.buffer[0][x])
                     for param, value in list(self.twoDDict.items()):
                         dummy = numpy.zeros(self.ranges.shape) + numpy.nan
                         if self.ext == '.txt':
                             x = self.parameters.index(param.lower())
                             y = self.parameters.index(self.independentParam.lower())
                             ranges = self.buffer[:,y]
                             #if self.ranges.size == ranges.size:
                             #    continue
                             index = numpy.where(numpy.in1d(self.ranges, ranges))[0]
                             dummy[index] = self.buffer[:,x]
                         else:
                             ranges = self.buffer[self.independentParam.lower()]
                             index = numpy.where(numpy.in1d(self.ranges, ranges))[0]
                             dummy[index] = self.buffer[param.lower()]
                         if isinstance(value, str):
                             if value not in self.independentParam:
                                 setattr(self.dataOut, value, dummy.reshape(1,-1))
                         elif isinstance(value, list):
                             self.output[value[0]][value[1]] = dummy
                             parameters[value[1]] = param
                     for key, value in list(self.output.items()):
                         setattr(self.dataOut, key, numpy.array(value))
                     self.dataOut.parameters = [s for s in parameters if s]
                     self.dataOut.heightList = self.ranges
                     self.dataOut.utctime = (self.datatime - datetime.datetime(1970, 1, 1)).total_seconds()
                     self.dataOut.utctimeInit = self.dataOut.utctime
                     self.dataOut.paramInterval = min(self.intervals)
                     self.dataOut.useLocalTime = False
                     self.dataOut.flagNoData = False
                     self.dataOut.nrecords = self.nrecords
                     self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock
                 def getData(self):
                     '''
                     Storing data from databuffer to dataOut object
                     '''
                     if not  self.readNextBlock():
                         self.dataOut.flagNoData = True
                         return 0
                     self.set_output()
                     return 1
                 def run(self, **kwargs):
                     if not(self.isConfig):
                         self.setup(**kwargs)
                         self.isConfig = True
                     self.getData()
                     return
             @MPDecorator
             class MADWriter(Operation):
                 '''Writing module for Madrigal files
             type: external
             Inputs:
                         path        path where files will be created
                         oneDDict    json of one-dimensional parameters in record where keys
                                     are Madrigal codes (integers or mnemonics) and values the corresponding
                                     dataOut attribute e.g: {
                                         'gdlatr': 'lat',
                                         'gdlonr': 'lon',
                                         'gdlat2':'lat',
                                         'glon2':'lon'}
                         ind2DList   list of independent spatial two-dimensional parameters e.g:
                                     ['heigthList']
                         twoDDict    json of two-dimensional parameters in record where keys
                                     are Madrigal codes (integers or mnemonics) and values the corresponding
                                     dataOut attribute if multidimensional array specify as tupple
                                     ('attr', pos) e.g: {
                                         'gdalt': 'heightList',
                                         'vn1p2': ('data_output', 0),
                                         'vn2p2': ('data_output', 1),
                                         'vn3': ('data_output', 2),
                                         'snl': ('data_SNR', 'db')
                                         }
                         metadata    json of madrigal metadata (kinst, kindat, catalog and header)
                         format      hdf5, cedar
                         blocks      number of blocks per file'''
                 __attrs__ = ['path', 'oneDDict', 'ind2DList', 'twoDDict','metadata', 'format', 'blocks']
                 missing = -32767
                 def __init__(self):
                     Operation.__init__(self)
                     self.dataOut = Parameters()
                     self.counter = 0
                     self.path = None
                     self.fp = None
                 def run(self, dataOut, path, oneDDict, ind2DList='[]', twoDDict='{}',
                         metadata='{}', format='cedar', **kwargs):
+                    #if dataOut.AUX==1: #Modified
                     if not self.isConfig:
                         self.setup(path, oneDDict, ind2DList, twoDDict, metadata, format, **kwargs)
                         self.isConfig = True
                     self.dataOut = dataOut
                     self.putData()
                     return 1
                 def setup(self, path, oneDDict, ind2DList, twoDDict, metadata, format, **kwargs):
                     '''
                     Configure Operation
                     '''
                     self.path = path
                     self.blocks = kwargs.get('blocks', None)
                     self.counter = 0
                     self.oneDDict = load_json(oneDDict)
                     self.twoDDict = load_json(twoDDict)
                     self.ind2DList = load_json(ind2DList)
                     meta = load_json(metadata)
                     self.kinst = meta.get('kinst')
                     self.kindat = meta.get('kindat')
                     self.catalog = meta.get('catalog', DEF_CATALOG)
                     self.header = meta.get('header', DEF_HEADER)
                     if format == 'cedar':
                         self.ext = '.dat'
                         self.extra_args = {}
                     elif format == 'hdf5':
                         self.ext = '.hdf5'
                         self.extra_args = {'ind2DList': self.ind2DList}
                     self.keys = [k.lower() for k in self.twoDDict]
                     if 'range' in self.keys:
                         self.keys.remove('range')
                     if 'gdalt' in self.keys:
                         self.keys.remove('gdalt')
                 def setFile(self):
                     '''
                     Create new cedar file object
                     '''
                     self.mnemonic = MNEMONICS[self.kinst]   #TODO get mnemonic from madrigal
                     date = datetime.datetime.utcfromtimestamp(self.dataOut.utctime)
+                    #if self.dataOut.input_dat_type:
+                        #date=datetime.datetime.fromtimestamp(self.dataOut.TimeBlockSeconds_for_dp_power)
+                    #print("date",date)
                     filename = '{}{}{}'.format(self.mnemonic,
                                                date.strftime('%Y%m%d_%H%M%S'),
                                                self.ext)
                     self.fullname = os.path.join(self.path, filename)
                     if os.path.isfile(self.fullname) :
                         log.warning(
                             'Destination file {} already exists, previous file deleted.'.format(
                                 self.fullname),
                             'MADWriter')
                         os.remove(self.fullname)
                     try:
                         log.success(
                             'Creating file: {}'.format(self.fullname),
                             'MADWriter')
                         if not os.path.exists(self.path):
                             os.makedirs(self.path)
                         self.fp = madrigal.cedar.MadrigalCedarFile(self.fullname, True)
                     except ValueError as e:
                         log.error(
                             'Impossible to create a cedar object with "madrigal.cedar.MadrigalCedarFile"',
                             'MADWriter')
                         return
                     return 1
                 def writeBlock(self):
                     '''
                     Add data records to cedar file taking data from oneDDict and twoDDict
                     attributes.
                     Allowed parameters in: parcodes.tab
                     '''
+                    #self.dataOut.paramInterval=2
                     startTime = datetime.datetime.utcfromtimestamp(self.dataOut.utctime)
                     endTime = startTime + datetime.timedelta(seconds=self.dataOut.paramInterval)
+                    #if self.dataOut.input_dat_type:
+                    #if self.dataOut.experiment=="DP":
+                        #startTime=datetime.datetime.fromtimestamp(self.dataOut.TimeBlockSeconds_for_dp_power)
+                        #endTime = startTime + datetime.timedelta(seconds=self.dataOut.paramInterval)
+                    #print("2: ",startTime)
+                    #print(endTime)
                     heights = self.dataOut.heightList
+                    #print(self.blocks)
+                    #print(startTime)
+                    #print(endTime)
+                    #print(heights)
+                    #input()
                     if self.ext == '.dat':
                         for key, value in list(self.twoDDict.items()):
                             if isinstance(value, str):
                                 data = getattr(self.dataOut, value)
                                 invalid = numpy.isnan(data)
                                 data[invalid] = self.missing
                             elif isinstance(value, (tuple, list)):
                                 attr, key = value
                                 data = getattr(self.dataOut, attr)
                                 invalid = numpy.isnan(data)
                                 data[invalid] = self.missing
                     out = {}
                     for key, value in list(self.twoDDict.items()):
                         key = key.lower()
                         if isinstance(value, str):
                             if 'db' in value.lower():
                                 tmp = getattr(self.dataOut, value.replace('_db', ''))
                                 SNRavg = numpy.average(tmp, axis=0)
                                 tmp = 10*numpy.log10(SNRavg)
                             else:
                                 tmp = getattr(self.dataOut, value)
                             out[key] = tmp.flatten()[:len(heights)]
                         elif isinstance(value, (tuple, list)):
                             attr, x = value
                             data = getattr(self.dataOut, attr)
+                            #print(x)
+                            #print(len(heights))
+                            #print(data[int(x)][:len(heights)])
+                            #print(numpy.shape(out))
+                            #print(numpy.shape(data))
                             out[key] = data[int(x)][:len(heights)]
                     a = numpy.array([out[k] for k in self.keys])
+                    #print(a)
                     nrows = numpy.array([numpy.isnan(a[:, x]).all() for x in range(len(heights))])
                     index = numpy.where(nrows == False)[0]
+                    #print(startTime.minute)
                     rec = madrigal.cedar.MadrigalDataRecord(
                         self.kinst,
                         self.kindat,
                         startTime.year,
                         startTime.month,
                         startTime.day,
                         startTime.hour,
                         startTime.minute,
                         startTime.second,
                         startTime.microsecond/10000,
                         endTime.year,
                         endTime.month,
                         endTime.day,
                         endTime.hour,
                         endTime.minute,
                         endTime.second,
                         endTime.microsecond/10000,
                         list(self.oneDDict.keys()),
                         list(self.twoDDict.keys()),
                         len(index),
                         **self.extra_args
                     )
+                    #print("rec",rec)
                     # Setting 1d values
                     for key in self.oneDDict:
                         rec.set1D(key, getattr(self.dataOut, self.oneDDict[key]))
                     # Setting 2d values
                     nrec = 0
                     for n in index:
                         for key in out:
                             rec.set2D(key, nrec, out[key][n])
                         nrec += 1
                     self.fp.append(rec)
-                    if self.ext == '.hdf5' and self.counter % 500 == 0 and self.counter > 0:
+                    if self.ext == '.hdf5' and self.counter %2 == 0 and self.counter > 0:
+                        #print("here")
                         self.fp.dump()
                     if self.counter % 20 == 0 and self.counter > 0:
+                        #self.fp.write()
                         log.log(
                             'Writing {} records'.format(
                                 self.counter),
                             'MADWriter')
                 def setHeader(self):
                     '''
                     Create an add catalog and header to cedar file
                     '''
                     log.success('Closing file {}'.format(self.fullname), 'MADWriter')
                     if self.ext == '.dat':
                         self.fp.write()
                     else:
                         self.fp.dump()
                         self.fp.close()
                     header = madrigal.cedar.CatalogHeaderCreator(self.fullname)
                     header.createCatalog(**self.catalog)
                     header.createHeader(**self.header)
                     header.write()
                 def putData(self):
                     if self.dataOut.flagNoData:
                         return 0
                     if self.dataOut.flagDiscontinuousBlock or self.counter == self.blocks:
                         if self.counter > 0:
                             self.setHeader()
                         self.counter = 0
                     if self.counter == 0:
                         self.setFile()
                     self.writeBlock()
                     self.counter += 1
                 def close(self):
                     if self.counter > 0:
                         self.setHeader()

schainpy/model/io/jroIO_param.py +2 -1

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

schainpy/model/io/jroIO_voltage.py +23 -7

             '''
             Created on Jul 2, 2014
             @author: roj-idl71
             '''
             import numpy
             from .jroIO_base import LOCALTIME, JRODataReader, JRODataWriter
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
             from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
             from schainpy.model.data.jrodata import Voltage
             class VoltageReader(JRODataReader, ProcessingUnit):
                 """
                 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
                 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
                 perfiles*alturas*canales) son almacenados en la variable "buffer".
                                          perfiles * alturas * canales
                 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
                 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
                 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
                 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
                 Example:
                     dpath = "/home/myuser/data"
                     startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
                     endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
                     readerObj = VoltageReader()
                     readerObj.setup(dpath, startTime, endTime)
                     while(True):
                         #to get one profile
                         profile =  readerObj.getData()
                         #print the profile
                         print profile
                         #If you want to see all datablock
                         print readerObj.datablock
                         if readerObj.flagNoMoreFiles:
                             break
                 """
                 def __init__(self):
                     """
                     Inicializador de la clase VoltageReader para la lectura de datos de voltage.
                     Input:
                         dataOut    :    Objeto de la clase Voltage. Este objeto sera utilizado para
                                           almacenar un perfil de datos cada vez que se haga un requerimiento
                                           (getData). El perfil sera obtenido a partir del buffer de datos,
                                           si el buffer esta vacio se hara un nuevo proceso de lectura de un
                                           bloque de datos.
                                           Si este parametro no es pasado se creara uno internamente.
                     Variables afectadas:
                         self.dataOut
                     Return:
                         None
                     """
                     ProcessingUnit.__init__(self)
                     self.ext = ".r"
                     self.optchar = "D"
                     self.basicHeaderObj = BasicHeader(LOCALTIME)
                     self.systemHeaderObj = SystemHeader()
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.processingHeaderObj = ProcessingHeader()
                     self.lastUTTime = 0
                     self.profileIndex = 2**32 - 1
                     self.dataOut = Voltage()
                     self.selBlocksize = None
                     self.selBlocktime = None
+                    ##print("1--OKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK")
                 def createObjByDefault(self):
+                    ##print("2--OKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK")
                     dataObj = Voltage()
                     return dataObj
                 def __hasNotDataInBuffer(self):
+                    ##print("3--OKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK")
                     if self.profileIndex >= self.processingHeaderObj.profilesPerBlock * self.nTxs:
                         return 1
                     return 0
                 def getBlockDimension(self):
                     """
                         Obtiene la cantidad de puntos a leer por cada bloque de datos
                         Affected:
                             self.blocksize
                         Return:
                             None
                     """
+                    ##print("4--OKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK")
                     pts2read = self.processingHeaderObj.profilesPerBlock * \
                         self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels
                     self.blocksize = pts2read
                 def readBlock(self):
                     """
                         readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
                         (self.fp) y actualiza todos los parametros relacionados al bloque de datos
                         (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
                         es seteado a 0
                         Inputs:
                             None
                         Return:
                             None
                         Affected:
                             self.profileIndex
                             self.datablock
                             self.flagIsNewFile
                             self.flagIsNewBlock
                             self.nTotalBlocks
                         Exceptions:
                             Si un bloque leido no es un bloque valido
                     """
+                    ##print("5--OKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK")
                     # if self.server is not None:
                     #     self.zBlock = self.receiver.recv()
                     #     self.zHeader = self.zBlock[:24]
                     #     self.zDataBlock = self.zBlock[24:]
                     #     junk = numpy.fromstring(self.zDataBlock, numpy.dtype([('real','<i4'),('imag','<i4')]))
                     #     self.processingHeaderObj.profilesPerBlock = 240
                     #     self.processingHeaderObj.nHeights = 248
                     #     self.systemHeaderObj.nChannels
                     # else:
                     current_pointer_location = self.fp.tell()
                     junk = numpy.fromfile(self.fp, self.dtype, self.blocksize)
                     try:
                         junk = junk.reshape((self.processingHeaderObj.profilesPerBlock,
                                              self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels))
                     except:
                         # print "The read block (%3d) has not enough data" %self.nReadBlocks
                         if self.waitDataBlock(pointer_location=current_pointer_location):
                             junk = numpy.fromfile(self.fp, self.dtype, self.blocksize)
                             junk = junk.reshape((self.processingHeaderObj.profilesPerBlock,
                                                  self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels))
                     #             return 0
                     # Dimensions : nChannels, nProfiles, nSamples
                     junk = numpy.transpose(junk, (2, 0, 1))
                     self.datablock = junk['real'] + junk['imag'] * 1j
                     self.profileIndex = 0
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks += 1
                     self.nReadBlocks += 1
                     return 1
                 def getFirstHeader(self):
+                    ##print("6--OKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK")
                     self.getBasicHeader()
                     self.dataOut.processingHeaderObj = self.processingHeaderObj.copy()
                     self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
                     self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
+                    #self.dataOut.ippSeconds_general=self.radarControllerHeaderObj.ippSeconds
+                    #print(self.nTxs)
                     if self.nTxs > 1:
+                        #print(self.radarControllerHeaderObj.ippSeconds)
                         self.dataOut.radarControllerHeaderObj.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs
+                        #print(self.radarControllerHeaderObj.ippSeconds)
                     # Time interval and code are propierties of dataOut. Its value depends of radarControllerHeaderObj.
                     #         self.dataOut.timeInterval = self.radarControllerHeaderObj.ippSeconds * self.processingHeaderObj.nCohInt
                     #
                     #         if self.radarControllerHeaderObj.code is not None:
                     #
                     #             self.dataOut.nCode = self.radarControllerHeaderObj.nCode
                     #
                     #             self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud
                     #
                     #             self.dataOut.code = self.radarControllerHeaderObj.code
                     self.dataOut.dtype = self.dtype
                     self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
                     self.dataOut.heightList = numpy.arange(
                         self.processingHeaderObj.nHeights) * self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
                     self.dataOut.channelList = list(range(self.systemHeaderObj.nChannels))
                     self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
                     # asumo q la data no esta decodificada
                     self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode
                     # asumo q la data no esta sin flip
                     self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip
                     self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft
                 def reshapeData(self):
+                    ##print("7--OKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK")
                     if self.nTxs < 0:
                         return
                     if self.nTxs == 1:
                         return
                     if self.nTxs < 1 and self.processingHeaderObj.profilesPerBlock % (1. / self.nTxs) != 0:
                         raise ValueError("1./nTxs (=%f), should be a multiple of nProfiles (=%d)" % (
 . / self.nTxs, self.processingHeaderObj.profilesPerBlock))
                     if self.nTxs > 1 and self.processingHeaderObj.nHeights % self.nTxs != 0:
                         raise ValueError("nTxs (=%d), should be a multiple of nHeights (=%d)" % (
                             self.nTxs, self.processingHeaderObj.nHeights))
                     self.datablock = self.datablock.reshape(
                         (self.systemHeaderObj.nChannels, self.processingHeaderObj.profilesPerBlock * self.nTxs, int(self.processingHeaderObj.nHeights / self.nTxs)))
                     self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock * self.nTxs
                     self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights / self.nTxs) * \
                         self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
                     self.dataOut.radarControllerHeaderObj.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs
                     return
                 def readFirstHeaderFromServer(self):
+                    ##print("8--OKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK")
                     self.getFirstHeader()
                     self.firstHeaderSize = self.basicHeaderObj.size
                     datatype = int(numpy.log2((self.processingHeaderObj.processFlags &
                                                PROCFLAG.DATATYPE_MASK)) - numpy.log2(PROCFLAG.DATATYPE_CHAR))
                     if datatype == 0:
                         datatype_str = numpy.dtype([('real', '<i1'), ('imag', '<i1')])
                     elif datatype == 1:
                         datatype_str = numpy.dtype([('real', '<i2'), ('imag', '<i2')])
                     elif datatype == 2:
                         datatype_str = numpy.dtype([('real', '<i4'), ('imag', '<i4')])
                     elif datatype == 3:
                         datatype_str = numpy.dtype([('real', '<i8'), ('imag', '<i8')])
                     elif datatype == 4:
                         datatype_str = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
                     elif datatype == 5:
                         datatype_str = numpy.dtype([('real', '<f8'), ('imag', '<f8')])
                     else:
                         raise ValueError('Data type was not defined')
                     self.dtype = datatype_str
                     #self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
                     self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + \
                         self.firstHeaderSize + self.basicHeaderSize * \
                         (self.processingHeaderObj.dataBlocksPerFile - 1)
                     #        self.dataOut.channelList = numpy.arange(self.systemHeaderObj.numChannels)
                     #        self.dataOut.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
                     self.getBlockDimension()
                 def getFromServer(self):
+                    ##print("9--OKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK")
                     self.flagDiscontinuousBlock = 0
                     self.profileIndex = 0
                     self.flagIsNewBlock = 1
                     self.dataOut.flagNoData = False
                     self.nTotalBlocks += 1
                     self.nReadBlocks += 1
                     self.blockPointer = 0
                     block = self.receiver.recv()
                     self.basicHeaderObj.read(block[self.blockPointer:])
                     self.blockPointer += self.basicHeaderObj.length
                     self.systemHeaderObj.read(block[self.blockPointer:])
                     self.blockPointer += self.systemHeaderObj.length
                     self.radarControllerHeaderObj.read(block[self.blockPointer:])
                     self.blockPointer += self.radarControllerHeaderObj.length
                     self.processingHeaderObj.read(block[self.blockPointer:])
                     self.blockPointer += self.processingHeaderObj.length
                     self.readFirstHeaderFromServer()
                     timestamp = self.basicHeaderObj.get_datatime()
                     print('[Reading] - Block {} - {}'.format(self.nTotalBlocks, timestamp))
                     current_pointer_location = self.blockPointer
                     junk = numpy.fromstring(
                         block[self.blockPointer:], self.dtype, self.blocksize)
                     try:
                         junk = junk.reshape((self.processingHeaderObj.profilesPerBlock,
                                              self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels))
                     except:
                         # print "The read block (%3d) has not enough data" %self.nReadBlocks
                         if self.waitDataBlock(pointer_location=current_pointer_location):
                             junk = numpy.fromstring(
                                 block[self.blockPointer:], self.dtype, self.blocksize)
                             junk = junk.reshape((self.processingHeaderObj.profilesPerBlock,
                                                  self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels))
                     #               return 0
                     # Dimensions : nChannels, nProfiles, nSamples
                     junk = numpy.transpose(junk, (2, 0, 1))
                     self.datablock = junk['real'] + junk['imag'] * 1j
                     self.profileIndex = 0
                     if self.selBlocksize == None:
                         self.selBlocksize = self.dataOut.nProfiles
                     if self.selBlocktime != None:
                         if self.dataOut.nCohInt is not None:
                             nCohInt = self.dataOut.nCohInt
                         else:
                             nCohInt = 1
                         self.selBlocksize = int(self.dataOut.nProfiles * round(self.selBlocktime / (
                             nCohInt * self.dataOut.ippSeconds * self.dataOut.nProfiles)))
                     self.dataOut.data = self.datablock[:,
                                                        self.profileIndex:self.profileIndex + self.selBlocksize, :]
                     datasize = self.dataOut.data.shape[1]
                     if datasize < self.selBlocksize:
                         buffer = numpy.zeros(
                             (self.dataOut.data.shape[0], self.selBlocksize, self.dataOut.data.shape[2]), dtype='complex')
                         buffer[:, :datasize, :] = self.dataOut.data
                         self.dataOut.data = buffer
                         self.profileIndex = blockIndex
                     self.dataOut.flagDataAsBlock = True
                     self.flagIsNewBlock = 1
                     self.dataOut.realtime = self.online
                     return self.dataOut.data
                 def getData(self):
                     """
                         getData obtiene una unidad de datos del buffer de lectura, un perfil,  y la copia al objeto self.dataOut
                         del tipo "Voltage" con todos los parametros asociados a este (metadata). cuando no hay datos
                         en el buffer de lectura es necesario hacer una nueva lectura de los bloques de datos usando
                         "readNextBlock"
                         Ademas incrementa el contador del buffer "self.profileIndex" en 1.
                         Return:
                             Si el flag self.getByBlock ha sido seteado el bloque completo es copiado a self.dataOut y el self.profileIndex
                             es igual al total de perfiles leidos desde el archivo.
                             Si self.getByBlock == False:
                                 self.dataOut.data = buffer[:, thisProfile, :]
                                 shape = [nChannels, nHeis]
                             Si self.getByBlock == True:
                                 self.dataOut.data = buffer[:, :, :]
                                 shape = [nChannels, nProfiles, nHeis]
                         Variables afectadas:
                             self.dataOut
                             self.profileIndex
                         Affected:
                             self.dataOut
                             self.profileIndex
                             self.flagDiscontinuousBlock
                             self.flagIsNewBlock
                     """
+                    ##print("10--OKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK")
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNoData = True
                         return 0
                     self.flagDiscontinuousBlock = 0
                     self.flagIsNewBlock = 0
                     if self.__hasNotDataInBuffer():
                         if not(self.readNextBlock()):
                             return 0
                         self.getFirstHeader()
                         self.reshapeData()
                     if self.datablock is None:
                         self.dataOut.flagNoData = True
                         return 0
                     if not self.getByBlock:
                         """
                             Return profile by profile
                             If nTxs > 1 then one profile is divided by nTxs and number of total
                             blocks is increased by nTxs (nProfiles *= nTxs)
                         """
                         self.dataOut.flagDataAsBlock = False
                         self.dataOut.data = self.datablock[:, self.profileIndex, :]
                         self.dataOut.profileIndex = self.profileIndex
                         self.profileIndex += 1
                     else:
                         """
                             Return a block
                         """
                         if self.selBlocksize == None:
                             self.selBlocksize = self.dataOut.nProfiles
                         if self.selBlocktime != None:
                             if self.dataOut.nCohInt is not None:
                                 nCohInt = self.dataOut.nCohInt
                             else:
                                 nCohInt = 1
                             self.selBlocksize = int(self.dataOut.nProfiles * round(self.selBlocktime / (
                                 nCohInt * self.dataOut.ippSeconds * self.dataOut.nProfiles)))
                         self.dataOut.data = self.datablock[:,
                                                            self.profileIndex:self.profileIndex + self.selBlocksize, :]
                         self.profileIndex += self.selBlocksize
                         datasize = self.dataOut.data.shape[1]
                         if datasize < self.selBlocksize:
                             buffer = numpy.zeros(
                                 (self.dataOut.data.shape[0], self.selBlocksize, self.dataOut.data.shape[2]), dtype='complex')
                             buffer[:, :datasize, :] = self.dataOut.data
                             while datasize < self.selBlocksize:  # Not enough profiles to fill the block
                                 if not(self.readNextBlock()):
                                     return 0
                                 self.getFirstHeader()
                                 self.reshapeData()
                                 if self.datablock is None:
                                     self.dataOut.flagNoData = True
                                     return 0
                                 # stack data
                                 blockIndex = self.selBlocksize - datasize
                                 datablock1 = self.datablock[:, :blockIndex, :]
                                 buffer[:, datasize:datasize +
                                        datablock1.shape[1], :] = datablock1
                                 datasize += datablock1.shape[1]
                             self.dataOut.data = buffer
                             self.profileIndex = blockIndex
                         self.dataOut.flagDataAsBlock = True
                         self.dataOut.nProfiles = self.dataOut.data.shape[1]
+            #######################DP#######################
+                    self.dataOut.CurrentBlock=self.nReadBlocks
+                    self.dataOut.LastBlock=self.processingHeaderObj.dataBlocksPerFile
+            #######################DP#######################
                     self.dataOut.flagNoData = False
-                    self.getBasicHeader()
+                    #self.getBasicHeader()
                     self.dataOut.realtime = self.online
                     return self.dataOut.data
             @MPDecorator
             class VoltageWriter(JRODataWriter, Operation):
                 """
                 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 ext = ".r"
                 optchar = "D"
                 shapeBuffer = None
                 def __init__(self):#, **kwargs):
                     """
                     Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
                     Affected:
                         self.dataOut
                     Return: None
                     """
                     Operation.__init__(self)#, **kwargs)
                     self.nTotalBlocks = 0
                     self.profileIndex = 0
                     self.isConfig = False
                     self.fp = None
                     self.flagIsNewFile = 1
                     self.blockIndex = 0
                     self.flagIsNewBlock = 0
                     self.setFile = None
                     self.dtype = None
                     self.path = None
                     self.filename = None
                     self.basicHeaderObj = BasicHeader(LOCALTIME)
                     self.systemHeaderObj = SystemHeader()
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.processingHeaderObj = ProcessingHeader()
                 def hasAllDataInBuffer(self):
                     if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
                         return 1
                     return 0
                 def setBlockDimension(self):
                     """
                     Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
                     Affected:
                         self.shape_spc_Buffer
                         self.shape_cspc_Buffer
                         self.shape_dc_Buffer
                     Return: None
                     """
                     self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,
                                         self.processingHeaderObj.nHeights,
                                         self.systemHeaderObj.nChannels)
                     self.datablock = numpy.zeros((self.systemHeaderObj.nChannels,
                                                   self.processingHeaderObj.profilesPerBlock,
                                                   self.processingHeaderObj.nHeights),
                                                  dtype=numpy.dtype('complex64'))
                 def writeBlock(self):
                     """
                     Escribe el buffer en el file designado
                     Affected:
                         self.profileIndex
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                         self.blockIndex
                     Return: None
                     """
                     data = numpy.zeros(self.shapeBuffer, self.dtype)
                     junk = numpy.transpose(self.datablock, (1, 2, 0))
                     data['real'] = junk.real
                     data['imag'] = junk.imag
                     data = data.reshape((-1))
                     data.tofile(self.fp)
                     self.datablock.fill(0)
                     self.profileIndex = 0
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.blockIndex += 1
                     self.nTotalBlocks += 1
             #         print "[Writing] Block = %04d" %self.blockIndex
                 def putData(self):
                     """
                     Setea un bloque de datos y luego los escribe en un file
                     Affected:
                         self.flagIsNewBlock
                         self.profileIndex
                     Return:
 :    Si no hay data o no hay mas files que puedan escribirse
 :    Si se escribio la data de un bloque en un file
                     """
                     if self.dataOut.flagNoData:
                         return 0
                     self.flagIsNewBlock = 0
                     if self.dataOut.flagDiscontinuousBlock:
                         self.datablock.fill(0)
                         self.profileIndex = 0
                         self.setNextFile()
                     if self.profileIndex == 0:
                         self.setBasicHeader()
                     self.datablock[:, self.profileIndex, :] = self.dataOut.data
                     self.profileIndex += 1
                     if self.hasAllDataInBuffer():
                         # if self.flagIsNewFile:
                         self.writeNextBlock()
             #            self.setFirstHeader()
                     return 1
                 def __getBlockSize(self):
                     '''
                     Este metodos determina el cantidad de bytes para un bloque de datos de tipo Voltage
                     '''
                     dtype_width = self.getDtypeWidth()
                     blocksize = int(self.dataOut.nHeights * self.dataOut.nChannels *
                                     self.profilesPerBlock * dtype_width * 2)
                     return blocksize
                 def setFirstHeader(self):
                     """
                     Obtiene una copia del First Header
                     Affected:
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.dtype
                     Return:
                         None
                     """
                     self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
                     self.systemHeaderObj.nChannels = self.dataOut.nChannels
                     self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
                     self.processingHeaderObj.dtype = 0  # Voltage
                     self.processingHeaderObj.blockSize = self.__getBlockSize()
                     self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock
                     self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
                     # podria ser 1 o self.dataOut.processingHeaderObj.nWindows
                     self.processingHeaderObj.nWindows = 1
                     self.processingHeaderObj.nCohInt = self.dataOut.nCohInt
                     # Cuando la data de origen es de tipo Voltage
                     self.processingHeaderObj.nIncohInt = 1
                     # Cuando la data de origen es de tipo Voltage
                     self.processingHeaderObj.totalSpectra = 0
                     if self.dataOut.code is not None:
                         self.processingHeaderObj.code = self.dataOut.code
                         self.processingHeaderObj.nCode = self.dataOut.nCode
                         self.processingHeaderObj.nBaud = self.dataOut.nBaud
                     if self.processingHeaderObj.nWindows != 0:
                         self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
                         self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - \
                             self.dataOut.heightList[0]
                         self.processingHeaderObj.nHeights = self.dataOut.nHeights
                         self.processingHeaderObj.samplesWin = self.dataOut.nHeights
                     self.processingHeaderObj.processFlags = self.getProcessFlags()
                     self.setBasicHeader()
-  No newline at end of file

schainpy/model/proc/__init__.py +6 0

             '''
             $Author: murco $
             $Id: Processor.py 1 2012-11-12 18:56:07Z murco $
             '''
             from .jroproc_voltage import *
             from .jroproc_spectra import *
             from .jroproc_heispectra import *
             from .jroproc_amisr import *
             from .jroproc_correlation import *
             from .jroproc_parameters import *
             from .jroproc_spectra_lags import *
             from .jroproc_spectra_acf import *
             from .bltrproc_parameters import *
             from .pxproc_parameters import *
+            ###########DP###########
+            from .jroproc_voltage_lags import *
+            ###########DP###########
+            from .jroproc_spectra_lags_faraday import *

schainpy/model/proc/jroproc_base.py 0 0

NO CONTENT: modified file

schainpy/model/proc/jroproc_parameters.py 755 ➡ 644 0 0

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

schainpy/model/proc/jroproc_spectra.py 0 0

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

schainpy/model/proc/jroproc_spectra_lags.py 0 0

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

schainpy/model/proc/jroproc_voltage.py 0 0

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

schainpy/model/proc/pxproc_parameters.py 0 0

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

schainpy/scripts/PPD.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