schain Commit - r148:1305f08c51fd · Jicamarca Repository

-Actualización de los nombres de los objetos systemHeader y radaraControllerHeader...

Miguel Valdez -

r148:1305f08c51fd

parent child

Context file:

r148:1305f08c51fd

Collapse all files

schainpy2/Data/JROData.py +6 -6

             '''
             $Author$
             $Id$
             '''
             import os, sys
             import copy
             import numpy
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from IO.JROHeaderIO import SystemHeader, RadarControllerHeader
             class JROData:
             #    m_BasicHeader = BasicHeader()
             #    m_ProcessingHeader = ProcessingHeader()
                 systemHeaderObj = SystemHeader()
                 radarControllerHeaderObj = RadarControllerHeader()
             #    data = None
                 type = None
                 dtype = None
                 nChannels = None
                 nHeights = None
                 nProfiles = None
                 heightList = None
                 channelList = None
                 channelIndexList = None
                 flagNoData = False
                 flagTimeBlock = False
                 dataUtcTime = None
                 nCode = None
                 nBaud = None
                 code = None
                 flagDecodeData = True #asumo q la data esta decodificada
                 flagDeflipData = True #asumo q la data esta sin flip
                 flagShiftFFT = False
                 ippSeconds = None
                 def __init__(self):
                     raise ValueError, "This class has not been implemented"
                 def copy(self, inputObj=None):
                     if inputObj == None:
                         return copy.deepcopy(self)
                     for key in inputObj.__dict__.keys():
                         self.__dict__[key] = inputObj.__dict__[key]
                 def deepcopy(self):
                     return copy.deepcopy(self)
             class Voltage(JROData):
                 nCohInt = None
                 #data es un numpy array de 2 dmensiones (canales, alturas)
                 data = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
-                    self.m_RadarControllerHeader = RadarControllerHeader()
+                    self.radarControllerHeaderObj = RadarControllerHeader()
-                    self.m_SystemHeader = SystemHeader()
+                    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.flagTimeBlock = False
                     self.dataUtcTime = None
                     self.nCohInt = None
             class Spectra(JROData):
                 #data es un numpy array de 2 dmensiones (canales, perfiles, alturas)
                 data_spc = None
                 #data es un numpy array de 2 dmensiones (canales, pares, alturas)
                 data_cspc = None
                 #data es un numpy array de 2 dmensiones (canales, alturas)
                 data_dc = None
                 nFFTPoints = None
                 nPairs = None
                 pairsList = None
                 nIncohInt = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
-                    self.m_RadarControllerHeader = RadarControllerHeader()
+                    self.radarControllerHeaderObj = RadarControllerHeader()
-                    self.m_SystemHeader = SystemHeader()
+                    self.systemHeaderObj = SystemHeader()
                     self.type = "Spectra"
             #        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.flagTimeBlock = False
                     self.dataUtcTime = None
                     self.nIncohInt = None
             class SpectraHeis(JROData):
                 data_spc = None
                 data_cspc = None
                 data_dc = None
                 nFFTPoints = None
                 nPairs = None
                 pairsList = None
                 def __init__(self):
-                    self.m_RadarControllerHeader = RadarControllerHeader()
+                    self.radarControllerHeaderObj = RadarControllerHeader()
-                    self.m_SystemHeader = SystemHeader()
+                    self.systemHeaderObj = SystemHeader()
                     self.type = "SpectraHeis"
                     self.dataType = None
                     self.nHeights = 0
                     self.nChannels = 0
                     self.channelList = None
                     self.heightList = None
                     self.flagNoData = True
                     self.flagResetProcessing = False
                     #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
                     self.data_spc = None
                     self.data_cspc = None
                     self.data_dc = None
                     self.nFFTPoints = None
                     self.nAvg = None
                     self.nPairs = 0
                     self.pairsList = None

schainpy2/Graphics/BaseGraph_mpl.py +2 -2

             '''
             Created on Feb 7, 2012
             @autor $Author: dsuarez $
             @version $Id: BaseGraph.py 117 2012-09-04 21:16:59Z dsuarez $
             '''
             #from __future__ import division
             #import os
             import numpy
             #import sys
             import time
             import datetime
             #import plplot
             import matplotlib as mpl
-            mpl.use('TKAgg')
+             #mpl.use('TKAgg')
             import matplotlib.pyplot as plt
-            import scitools.numpyutils as sn
+            #import scitools.numpyutils as sn
             def cmap1_init(colormap='gray'):
             #	if colormap == None:
             #		return
             #
             #	ncolor = None
             #	rgb_lvl = None
             #
             #	# Routine for defining a specific color map 1 in HLS space.
             #	# if gray is true, use basic grayscale variation from half-dark to light.
             #	# otherwise use false color variation from blue (240 deg) to red (360 deg).
             #
             #	# Independent variable of control points.
             #	i = numpy.array((0., 1.))
             #	if colormap=='gray':
             #		ncolor = 256
             #		# Hue for control points.  Doesn't matter since saturation is zero.
             #		h = numpy.array((0., 0.))
             #		# Lightness ranging from half-dark (for interest) to light.
             #		l = numpy.array((0.5, 1.))
             #		# Gray scale has zero saturation
             #		s = numpy.array((0., 0.))
             #
             #		# number of cmap1 colours is 256 in this case.
             #		plplot.plscmap1n(ncolor)
             #		# Interpolate between control points to set up cmap1.
             #		plplot.plscmap1l(0, i, h, l, s)
             #
             #		return None
             #
             #	if colormap == 'jet':
             #		ncolor = 256
             #		pos = numpy.zeros((ncolor))
             #		r = numpy.zeros((ncolor))
             #		g = numpy.zeros((ncolor))
             #		b = numpy.zeros((ncolor))
             #
             #		for i in range(ncolor):
             #			if(i <= 35.0/100*(ncolor-1)): rf = 0.0
             #			elif (i <= 66.0/100*(ncolor-1)): rf = (100.0/31)*i/(ncolor-1) - 35.0/31
             #			elif (i <= 89.0/100*(ncolor-1)): rf = 1.0
             #			else: rf = (-100.0/22)*i/(ncolor-1) + 111.0/22
             #
             #			if(i <= 12.0/100*(ncolor-1)): gf = 0.0
             #			elif(i <= 38.0/100*(ncolor-1)): gf = (100.0/26)*i/(ncolor-1) - 12.0/26
             #			elif(i <= 64.0/100*(ncolor-1)): gf = 1.0
             #			elif(i <= 91.0/100*(ncolor-1)): gf = (-100.0/27)*i/(ncolor-1) + 91.0/27
             #			else: gf = 0.0
             #
             #			if(i <= 11.0/100*(ncolor-1)): bf = (50.0/11)*i/(ncolor-1) + 0.5
             #			elif(i <= 34.0/100*(ncolor-1)): bf = 1.0
             #			elif(i <= 65.0/100*(ncolor-1)): bf = (-100.0/31)*i/(ncolor-1) + 65.0/31
             #			else: bf = 0
             #
             #			r[i] = rf
             #			g[i] = gf
             #			b[i] = bf
             #
             #			pos[i] = float(i)/float(ncolor-1)
             #
             #
             #		plplot.plscmap1n(ncolor)
             #		plplot.plscmap1l(1, pos, r, g, b)
             #
             #
             #
             #	if colormap=='br_green':
             #		ncolor = 256
             #		# Hue ranges from blue (240 deg) to red (0 or 360 deg)
             #		h = numpy.array((240., 0.))
             #		# Lightness and saturation are constant (values taken from C example).
             #		l = numpy.array((0.6, 0.6))
             #		s = numpy.array((0.8, 0.8))
             #
             #		# number of cmap1 colours is 256 in this case.
             #		plplot.plscmap1n(ncolor)
             #		# Interpolate between control points to set up cmap1.
             #		plplot.plscmap1l(0, i, h, l, s)
             #
             #		return None
             #
             #	if colormap=='tricolor':
             #		ncolor = 3
             #		# Hue ranges from blue (240 deg) to red (0 or 360 deg)
             #		h = numpy.array((240., 0.))
             #		# Lightness and saturation are constant (values taken from C example).
             #		l = numpy.array((0.6, 0.6))
             #		s = numpy.array((0.8, 0.8))
             #
             #		# number of cmap1 colours is 256 in this case.
             #		plplot.plscmap1n(ncolor)
             #		# Interpolate between control points to set up cmap1.
             #		plplot.plscmap1l(0, i, h, l, s)
             #
             #		return None
             #
             #	if colormap == 'rgb' or colormap == 'rgb666':
             #
             #		color_sz = 6
             #		ncolor = color_sz*color_sz*color_sz
             #		pos = numpy.zeros((ncolor))
             #		r = numpy.zeros((ncolor))
             #		g = numpy.zeros((ncolor))
             #		b = numpy.zeros((ncolor))
             #		ind = 0
             #		for ri in range(color_sz):
             #			for gi in range(color_sz):
             #				for bi in range(color_sz):
             #					r[ind] = ri/(color_sz-1.0)
             #					g[ind] = gi/(color_sz-1.0)
             #					b[ind] = bi/(color_sz-1.0)
             #					pos[ind] = ind/(ncolor-1.0)
             #					ind += 1
             #		rgb_lvl = [6,6,6]  #Levels for RGB colors
             #
             #	if colormap == 'rgb676':
             #		ncolor = 6*7*6
             #		pos = numpy.zeros((ncolor))
             #		r = numpy.zeros((ncolor))
             #		g = numpy.zeros((ncolor))
             #		b = numpy.zeros((ncolor))
             #		ind = 0
             #		for ri in range(8):
             #			for gi in range(8):
             #				for bi in range(4):
             #					r[ind] = ri/(6-1.0)
             #					g[ind] = gi/(7-1.0)
             #					b[ind] = bi/(6-1.0)
             #					pos[ind] = ind/(ncolor-1.0)
             #					ind += 1
             #		rgb_lvl = [6,7,6]  #Levels for RGB colors
             #
             #	if colormap == 'rgb685':
             #		ncolor = 6*8*5
             #		pos = numpy.zeros((ncolor))
             #		r = numpy.zeros((ncolor))
             #		g = numpy.zeros((ncolor))
             #		b = numpy.zeros((ncolor))
             #		ind = 0
             #		for ri in range(8):
             #			for gi in range(8):
             #				for bi in range(4):
             #					r[ind] = ri/(6-1.0)
             #					g[ind] = gi/(8-1.0)
             #					b[ind] = bi/(5-1.0)
             #					pos[ind] = ind/(ncolor-1.0)
             #					ind += 1
             #		rgb_lvl = [6,8,5]  #Levels for RGB colors
             #
             #	if colormap == 'rgb884':
             #		ncolor = 8*8*4
             #		pos = numpy.zeros((ncolor))
             #		r = numpy.zeros((ncolor))
             #		g = numpy.zeros((ncolor))
             #		b = numpy.zeros((ncolor))
             #		ind = 0
             #		for ri in range(8):
             #			for gi in range(8):
             #				for bi in range(4):
             #					r[ind] = ri/(8-1.0)
             #					g[ind] = gi/(8-1.0)
             #					b[ind] = bi/(4-1.0)
             #					pos[ind] = ind/(ncolor-1.0)
             #					ind += 1
             #		rgb_lvl = [8,8,4]  #Levels for RGB colors
             #
             #	if ncolor == None:
             #		raise ValueError, 'The colormap selected is not valid'
             #
             #	plplot.plscmap1n(ncolor)
             #	plplot.plscmap1l(1, pos, r, g, b)
             #
             #	return rgb_lvl
             	pass
             def setColormap(colormap='jet'):
             #	cmap1_init(colormap)
             	pass
             def savePlplot(filename,width,height):
             #	curr_strm = plplot.plgstrm()
             #	save_strm = plplot.plmkstrm()
             #	plplot.plsetopt('geometry', '%dx%d'%(width,height))
             #	plplot.plsdev('png')
             #	plplot.plsfnam(filename)
             #	plplot.plcpstrm(curr_strm,0)
             #	plplot.plreplot()
             #	plplot.plend1()
             #	plplot.plsstrm(curr_strm)
             	pass
             def initMatplotlib(indexFig,ncol,nrow,winTitle,width,height):
             	plt.ioff()
             	fig = plt.figure(indexFig)
             	fig.canvas.manager.set_window_title(winTitle)
             	fig.canvas.manager.resize(width,height)
             #	fig.add_subplot(nrow,ncol,1)
             	plt.ion()
             def setNewPage():
             #	plplot.plbop()
             #	plplot.pladv(0)
             	plt.clf()
             def closePage():
             #	plplot.pleop()
             	pass
             def clearData(objGraph):
             	objGraph.plotBox(objGraph.xrange[0], objGraph.xrange[1], objGraph.yrange[0], objGraph.yrange[1], 'bc', 'bc')
             	objGraph.setColor(15) #Setting Line Color to White
             	if objGraph.datatype == 'complex':
             		objGraph.basicXYPlot(objGraph.xdata,objGraph.ydata.real)
             		objGraph.basicXYPlot(objGraph.xdata,objGraph.ydata.imag)
             	if objGraph.datatype == 'real':
             		objGraph.basicXYPlot(objGraph.xdata,objGraph.ydata)
             	objGraph.setColor(1) #Setting Line Color to Black
             #	objGraph.setLineStyle(2)
             #	objGraph.plotBox(objGraph.xrange[0], objGraph.xrange[1], objGraph.yrange[0], objGraph.yrange[1], 'bcntg', 'bc')
             #	objGraph.setLineStyle(1)
             def setFigure(indexFig):
             #	plplot.plsstrm(indexFig)
             	plt.figure(indexFig)
             def refresh():
             #	plplot.refresh()
             	plt.draw()
             def show():
             #	plplot.plspause(True)
             #	plplot.plend()
             	plt.ioff()
             	plt.show()
             	plt.ion()
             def setPlTitle(pltitle,color, szchar=0.7):
             #	setSubpages(1, 0)
             #	plplot.pladv(0)
             #	plplot.plvpor(0., 1., 0., 1.)
             #
             #	if color == 'black':
             #		plplot.plcol0(1)
             #	if color == 'white':
             #		plplot.plcol0(15)
             #
             #	plplot.plschr(0.0,szchar)
             #	plplot.plmtex('t',-1., 0.5, 0.5, pltitle)
             	pass
             def setSubpages(ncol,nrow):
             #	plplot.plssub(ncol,nrow)
             	pass
             class BaseGraph:
             	__name = None
             	__xpos = None
             	__ypos = None
             	__subplot = None
             	__xg = None
             	__yg = None
             	__axesId = None
             	xdata = None
             	ydata = None
             	getGrid = True
             	xaxisIsTime = False
             	deltax = None
             	xmin = None
             	xmax = None
             	def __init__(self,name,subplot,xpos,ypos,xlabel,ylabel,title,szchar,xrange,yrange,zrange=None,deltax=1.0):
             		self.setName(name)
             		self.setScreenPos(xpos, ypos)
             		self.setSubPlot(subplot)
             		self.setXYZrange(xrange,yrange,zrange)
             		self.setSizeOfChar(szchar)
             		self.setLabels(xlabel,ylabel,title)
             		self.getGrid = True
             		self.xaxisIsTime = False
             		self.deltax = deltax
             		pass
             	def makeAxes(self,indexFig,nrow,ncol,subplot):
             		fig = plt.figure(indexFig)
             		self.__axesId = fig.add_subplot(nrow,ncol,subplot)
             	def setParentAxesId(self,parent):
             		self.__axesId = parent.__axesId
             	def setName(self, name):
             		self.__name = name
             	def setScreenPos(self,xpos,ypos):
             		self.__xpos = xpos
             		self.__ypos = ypos
             	def setSubPlot(self,subplot):
             		self.__subplot = subplot
             	def setXYZrange(self,xrange,yrange,zrange):
             		self.xrange = xrange
             		self.yrange = yrange
             		self.zrange = zrange
             	def setSizeOfChar(self,szchar):
             		self.__szchar = szchar
             	def setLabels(self,xlabel=None,ylabel=None,title=None):
             		if xlabel != None: self.xlabel = xlabel
             		if ylabel != None: self.ylabel = ylabel
             		if title != None: self.title = title
             	def setXYData(self,xdata=None,ydata=None,datatype='real'):
             		if ((xdata != None) and (ydata != None)):
             			self.xdata = xdata
             			self.ydata = ydata
             			self.datatype = datatype
             		if ((self.xdata == None) and (self.ydata == None)):
             			return None
             		return 1
             	def setLineStyle(self, style):
             #		plplot.pllsty(style)
             		pass
             	def setColor(self, color):
             #		plplot.plcol0(color)
             		pass
             	def setXAxisAsTime(self, value=False):
             		self.xaxisIsTime = value
             	def basicLineTimePlot(self, x, y, colline=1):
             #		plplot.plcol0(colline)
             #		plplot.plline(x, y)
             #		plplot.plcol0(1)
             		ax = self.__axesId
             		if self.setXYData() == None:
             			ax.plot(x,y)
             		else:
             			ax.lines[0].set_data(x,y)
             	def basicXYPlot(self, x, y):
             #		plplot.plline(x, y)
             		ax = self.__axesId
             		if self.setXYData() == None:
             			ax.plot(x,y)
             		else:
             			ax.lines[0].set_data(x,y)
             	def basicPcolorPlot(self, data, x, y, xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None):
             #
             #		if xmin == None: xmin = x[0]
             #		if xmax == None: xmax = x[-1]
             #		if ymin == None: ymin = y[0]
             #		if ymax == None: ymax = y[-1]
             #		if zmin == None: zmin = numpy.nanmin(data)
             #		if zmax == None: zmax = numpy.nanmax(data)
             #
             #		plplot.plimage(data,
             #					   float(x[0]),
             #					   float(x[-1]),
             #					   float(y[0]),
             #					   float(y[-1]),
             #					   float(zmin),
             #					   float(zmax),
             #					   float(xmin),
             #					   float(xmax),
             #					   float(ymin),
             #					   float(ymax)
             #					   )
             		pass
             	def __getBoxpltr(self, x, y, deltax=None, deltay=None):
             #		if not(len(x)>0 and len(y)>0):
             #			raise ValueError, 'x axis and y axis are empty'
             #
             #		if deltax == None: deltax = x[-1] - x[-2]
             #		if deltay == None: deltay = y[-1] - y[-2]
             #
             #		x1 = numpy.append(x, x[-1] + deltax)
             #		y1 = numpy.append(y, y[-1] + deltay)
             #
             #		xg = (numpy.multiply.outer(x1, numpy.ones(len(y1))))
             #		yg = (numpy.multiply.outer(numpy.ones(len(x1)), y1))
             #
             #		self.__xg = xg
             #		self.__yg = yg
             #
             #		return xg, yg
             		pass
             	def advPcolorPlot(self, data, x, y, xmin=None, xmax=None, ymin=None, ymax=None, zmin=0., zmax=0., deltax=1.0, deltay=None, getGrid = True):
             	#	if getGrid:
             	#		xg, yg = self.__getBoxpltr(x, y, deltax, deltay)
             	#	else:
             	#		xg = self.__xg
             	#		yg = self.__yg
             	#
             	#	plplot.plimagefr(data,
             	#					 float(xmin),
             	#					 float(xmax),
             	#					 float(ymin),
             	#					 float(ymax),
             	#					 0.,
             	#					 0.,
             	#					 float(zmin),
             	#					 float(zmax),
             	#					 plplot.pltr2,
             	#					 xg,
             	#					 yg)
             		ax = self.__axesId
             #		if self.setXYData() == None:
             		ax.pcolormesh(x,y,data.T,vmin=zmin,vmax=zmax)
             #		else:
             #			ax.lines[0].set_data(x,y)
             	def colorbarPlot(self, xmin=0., xmax=1., ymin=0., ymax=1.):
             #		data = numpy.arange(256)
             #		data = numpy.reshape(data, (1,-1))
             #		plplot.plimage(data,
             #					   float(xmin),
             #					   float(xmax),
             #					   float(ymin),
             #					   float(ymax),
             #					   0.,
             #					   255.,
             #					   float(xmin),
             #					   float(xmax),
             #					   float(ymin),
             #					   float(ymax))
             		ax = self.__axesId
             		cax, kw = mpl.colorbar.make_axes(ax)
             		norm = mpl.colors.Normalize(vmin=ymin, vmax=ymax)
             		cb = mpl.colorbar.ColorbarBase(cax,norm=norm,**kw)
             		self.__colorbarId = cb
             		cb.set_label(self.title)
             	def plotBox(self, xmin, xmax, ymin, ymax, xopt, yopt, nolabels=False):
             #		plplot.plschr(0.0,self.__szchar-0.05)
             #		plplot.pladv(self.__subplot)
             #		plplot.plvpor(self.__xpos[0], self.__xpos[1], self.__ypos[0], self.__ypos[1])
             #		plplot.plwind(float(xmin), # self.xrange[0]
             #					  float(xmax), # self.xrange[1]
             #					  float(ymin), # self.yrange[0]
             #					  float(ymax) # self.yrange[1]
             #					  )
             #
             #
             #
             #		if self.xaxisIsTime:
             #			plplot.pltimefmt('%H:%M')
             #			timedelta = (xmax - xmin + 1)/8.
             #			plplot.plbox(xopt, timedelta, 3, yopt, 0.0, 0)
             #		else:
             #			plplot.plbox(xopt, 0.0, 0, yopt, 0.0, 0)
             #
             #
             #		if not(nolabels):
             #			plplot.pllab(self.xlabel, self.ylabel, self.title)
             		ax = self.__axesId
             		ax.set_xlim([xmin,xmax])
             		ax.set_ylim([ymin,ymax])
             		if not(nolabels):
             			ax.set_xlabel(self.xlabel)
             			ax.set_ylabel(self.ylabel)
             			ax.set_title(self.title)
             #		fig = plt.gcf()
             #		nrows = self.
             #		fig.add_subplot
             #		print
             		pass
             	def delLabels(self):
             #		self.setColor(15) #Setting Line Color to White
             #		plplot.pllab(self.xlabel, self.ylabel, self.title)
             #		self.setColor(1) #Setting Line Color to Black
             		pass
             	def plotImage(self,x,y,z,xrange,yrange,zrange):
             #		xi = x[0]
             #		xf = x[-1]
             #		yi = y[0]
             #		yf = y[-1]
             #
             #		plplot.plimage(z,
             #					   float(xi),
             #					   float(xf),
             #					   float(yi),
             #					   float(yf),
             #					   float(zrange[0]),
             #					   float(zrange[1]),
             #					   float(xi),
             #					   float(xf),
             #					   float(yrange[0]),
             #					   yrange[1])
             		pass
             class LinearPlot:
             	linearObjDic = {}
             	__xpos = None
             	__ypos = None
             	def __init__(self,indexFig,nsubplot,winTitle):
             		self.width = 700
             		self.height = 150
             		self.indexFig = indexFig
             		self.ncol = 1
             		self.nrow = nsubplot
             		initMatplotlib(indexFig,self.ncol,self.nrow,winTitle,self.width,self.height)
             	def setFigure(self,indexFig):
             		setFigure(indexFig)
             	def setPosition(self):
             		xi = 0.07; xf = 0.9 #0.8,0.7,0.5
             		yi = 0.15; yf = 0.8
             		xpos = [xi,xf]
             		ypos = [yi,yf]
             		self.__xpos = xpos
             		self.__ypos = ypos
             		return xpos,ypos
             	def show(self):
             		show()
             	def refresh(self):
             		refresh()
             	def setup(self,subplot,xmin,xmax,ymin,ymax,title,xlabel,ylabel):
             		szchar = 1.10
             		name = 'linear'
             		key = name + '%d'%subplot
             		xrange = [xmin,xmax]
             		yrange = [ymin,ymax]
             		xpos,ypos = self.setPosition()
             		linearObj = BaseGraph(name,subplot,xpos,ypos,xlabel,ylabel,title,szchar,xrange,yrange)
             		linearObj.makeAxes(self.indexFig,self.nrow,self.ncol,subplot)
             		linearObj.plotBox(linearObj.xrange[0], linearObj.xrange[1], linearObj.yrange[0], linearObj.yrange[1], 'bcnst', 'bcnstv')
             		self.linearObjDic[key] = linearObj
             	def plot(self,subplot,x,y,type='abs'):
             		name = 'linear'
             		key = name + '%d'%subplot
             		linearObj = self.linearObjDic[key]
             		#linearObj.plotBox(linearObj.xrange[0], linearObj.xrange[1], linearObj.yrange[0], linearObj.yrange[1], 'bcst', 'bcst')
             #		if linearObj.setXYData() != None:
             #				clearData(linearObj)
             #		else:
             #			if type.lower() == 'simple':
             #				linearObj.setXYData(x,y,'real')
             #			if type.lower() == 'power':
             #				linearObj.setXYData(x,abs(y),'real')
             #			if type.lower() == 'iq':
             #				linearObj.setXYData(x,y,'complex')
             		if type.lower() == 'simple':
             			colline = 9
             			linearObj.basicLineTimePlot(x, y)
             			linearObj.setXYData(x,y,'real')
             		if type.lower() == 'abs':
             			colline = 9
             			linearObj.basicLineTimePlot(x, abs(y), colline)
             			linearObj.setXYData(x,abs(y),'real')
             		if type.lower() == 'iq':
             			colline = 9
             			linearObj.basicLineTimePlot(x=x, y=y.real, colline=colline)
             			colline = 13
             			linearObj.basicLineTimePlot(x=x, y=y.imag, colline=colline)
             			linearObj.setXYData(x,y,'complex')
             #		linearObj.plotBox(linearObj.xrange[0], linearObj.xrange[1], linearObj.yrange[0], linearObj.yrange[1], 'bcst', 'bcst')
             		pass
             class PcolorPlot:
             	pcolorObjDic = {}
             	colorbarObjDic = {}
             	pwprofileObjDic = {}
             	showColorbar = None
             	showPowerProfile = None
             	XAxisAsTime = None
             	width = None
             	height = None
             	__spcxpos = None
             	__spcypos = None
             	__cmapxpos = None
             	__cmapypos = None
             	__profxpos = None
             	__profypos = None
             	__lastTitle = None
             	def __init__(self,indexFig,nsubplot,winTitle,colormap,showColorbar,showPowerProfile,XAxisAsTime):
             		self.width = 460
             		self.height = 300
             		self.showColorbar = showColorbar
             		self.showPowerProfile = showPowerProfile
             		self.XAxisAsTime = XAxisAsTime
             		ncol = int(numpy.sqrt(nsubplot)+0.9)
             		nrow = int(nsubplot*1./ncol + 0.9)
             		self.ncol = ncol
             		self.nrow = nrow
             		self.indexFig = indexFig
             		initMatplotlib(indexFig,ncol,nrow,winTitle,self.width,self.height)
             		setColormap(colormap)
             	def setFigure(self,indexFig):
             		setFigure(indexFig)
             	def setSpectraPos(self): #modificar valores de acuerdo al colorbar y pwprofile
             		if self.showPowerProfile: xi = 0.09; xf = 0.6 #0.075
             		else:   xi = 0.15; xf = 0.8 #0.8,0.7,0.5
             		yi = 0.15; yf = 0.80
             		xpos = [xi,xf]
             		ypos = [yi,yf]
             		self.__spcxpos = xpos
             		self.__spcypos = ypos
             		return xpos,ypos
             	def setColorbarScreenPos(self):
             		xi = self.__spcxpos[1] + 0.03; xf = xi + 0.03
             		yi = self.__spcypos[0]; yf = self.__spcypos[1]
             		xpos = [xi,xf]
             		ypos = [yi,yf]
             		self.__cmapxpos = xpos
             		self.__cmapypos = ypos
             		return xpos,ypos
             	def setPowerprofileScreenPos(self):
             		xi = self.__cmapxpos[1] + 0.07; xf = xi + 0.25
             		yi = self.__spcypos[0]; yf = self.__spcypos[1]
             		xpos = [xi,xf]
             		ypos = [yi,yf]
             		self.__profxpos = [xi,xf]
             		self.__profypos = [yi,yf]
             		return xpos,ypos
             	def createObjects(self,subplot,xmin,xmax,ymin,ymax,zmin,zmax,title,xlabel,ylabel):
             		'''
             		Crea los objetos necesarios para un subplot
             		'''
             		# Config Spectra plot
             		szchar = 0.7
             		name = 'spc'
             		key = name + '%d'%subplot
             		xrange = [xmin,xmax]
             		yrange = [ymin,ymax]
             		zrange = [zmin,zmax]
             		xpos,ypos = self.setSpectraPos()
             		pcolorObj = BaseGraph(name,subplot,xpos,ypos,xlabel,ylabel,title,szchar,xrange,yrange,zrange)
             		#pcolorObj.makeAxes(self.indexFig,self.nrow,self.ncol,subplot)
             		self.pcolorObjDic[key] = pcolorObj
             		# Config Colorbar
             		if self.showColorbar:
             			szchar = 0.65
             			name = 'colorbar'
             			key = name + '%d'%subplot
             			xpos,ypos = self.setColorbarScreenPos()
             			xrange = [0.,1.]
             			yrange = [zmin,zmax]
             			cmapObj = BaseGraph(name,subplot,xpos,ypos,'','','dB',szchar,xrange,yrange)
             			self.colorbarObjDic[key] = cmapObj
             		# Config Power profile
             		if self.showPowerProfile:
             			szchar = 0.55
             			name = 'pwprofile'
             			key = name + '%d'%subplot
             			xpos,ypos = self.setPowerprofileScreenPos()
             			xrange = [zmin,zmax]
             			yrange = [ymin,ymax]
             			powObj = BaseGraph(name,subplot,xpos,ypos,'dB','','Power Profile',szchar,xrange,yrange)
             			#powObj.makeAxes(self.indexFig,self.nrow,self.ncol,subplot)
             			self.pwprofileObjDic[key] = powObj
             	def setNewPage(self, pltitle='No title'):
             		szchar = 0.7
             		setNewPage()
             		setPlTitle(pltitle,'black', szchar=szchar)
             		setSubpages(self.ncol, self.nrow)
             	def closePage(self):
             		closePage()
             	def show(self):
             		show()
             	def iniPlot(self,subplot):
             		'''
             		Inicializa los subplots con su frame, titulo, etc
             		'''
             		# Config Spectra plot
             		name = 'spc'
             		key = name + '%d'%subplot
             		pcolorObj = self.pcolorObjDic[key]
             		pcolorObj.makeAxes(self.indexFig,self.nrow,self.ncol,subplot)
             		pcolorObj.plotBox(pcolorObj.xrange[0], pcolorObj.xrange[1], pcolorObj.yrange[0], pcolorObj.yrange[1], 'bcnst', 'bcnstv')
             		# Config Colorbar
             		if self.showColorbar:
             			name = 'colorbar'
             			key = name + '%d'%subplot
             			cmapObj = self.colorbarObjDic[key]
             			cmapObj.setParentAxesId(pcolorObj)
             #			cmapObj.plotBox(cmapObj.xrange[0], cmapObj.xrange[1], cmapObj.yrange[0], cmapObj.yrange[1], 'bc', 'bcmtsv')
             			cmapObj.colorbarPlot(cmapObj.xrange[0], cmapObj.xrange[1], cmapObj.yrange[0], cmapObj.yrange[1])
             #			cmapObj.plotBox(cmapObj.xrange[0], cmapObj.xrange[1], cmapObj.yrange[0], cmapObj.yrange[1], 'bc', 'bcmtsv')
             		# Config Power profile
             		if self.showPowerProfile:
             			name = 'pwprofile'
             			key = name + '%d'%subplot
             			powObj = self.pwprofileObjDic[key]
             			powObj.setLineStyle(2)
             			powObj.plotBox(powObj.xrange[0], powObj.xrange[1], powObj.yrange[0], powObj.yrange[1], 'bcntg', 'bc')
             			powObj.setLineStyle(1)
             			powObj.plotBox(powObj.xrange[0], powObj.xrange[1], powObj.yrange[0], powObj.yrange[1], 'bc', 'bc')
             	def printTitle(self,pltitle):
             #		if self.__lastTitle != None:
             #			setPlTitle(self.__lastTitle,'white')
             #
             #		self.__lastTitle = pltitle
             		setPlTitle(pltitle,'black')
             #		setSubpages(self.ncol,self.nrow)
             	def plot(self,subplot,x,y,z,subtitle=''):
             		# Spectra plot
             		name = 'spc'
             		key = name + '%d'%subplot
             #		newx = [x[0],x[-1]]
             		pcolorObj = self.pcolorObjDic[key]
             #		pcolorObj.plotBox(pcolorObj.xrange[0], pcolorObj.xrange[1], pcolorObj.yrange[0], pcolorObj.yrange[1], 'bcst', 'bcst')
             		#pcolorObj.delLabels()
             		pcolorObj.setLabels(title=subtitle)
             		deltax = None; deltay = None
             		pcolorObj.advPcolorPlot(z,
             								x,
             								y,
             								xmin=pcolorObj.xrange[0],
             								xmax=pcolorObj.xrange[1],
             								ymin=pcolorObj.yrange[0],
             								ymax=pcolorObj.yrange[1],
             								zmin=pcolorObj.zrange[0],
             								zmax=pcolorObj.zrange[1],
             								deltax=deltax,
             								deltay=deltay,
             								getGrid=pcolorObj.getGrid)
             		#Solo se calcula la primera vez que se ingresa a la funcion
             		pcolorObj.getGrid = False
             		#pcolorObj.plotBox(pcolorObj.xrange[0], pcolorObj.xrange[1], pcolorObj.yrange[0], pcolorObj.yrange[1], 'bcst', 'bcst', nolabels=True)
             		# Power Profile
             		if self.showPowerProfile:
             			power = numpy.average(z, axis=0)
             			name = 'pwprofile'
             			key = name + '%d'%subplot
             			powObj = self.pwprofileObjDic[key]
             			if powObj.setXYData() != None:
             				#clearData(powObj)
             				powObj.setLineStyle(2)
             				powObj.plotBox(powObj.xrange[0], powObj.xrange[1], powObj.yrange[0], powObj.yrange[1], 'bcntg', 'bc')
             				powObj.setLineStyle(1)
             			else:
             				powObj.setXYData(power,y)
             			powObj.plotBox(powObj.xrange[0], powObj.xrange[1], powObj.yrange[0], powObj.yrange[1], 'bc', 'bc')
             			powObj.basicXYPlot(power,y)
             			powObj.setXYData(power,y)
             	def savePlot(self,indexFig,filename):
             		width = self.width*self.ncol
             		hei = self.height*self.nrow
             		savePlplot(filename,width,hei)
             	def refresh(self):
             		refresh()
             class RtiPlot:
             	pcolorObjDic = {}
             	colorbarObjDic = {}
             	pwprofileObjDic = {}
             	showColorbar = None
             	showPowerProfile = None
             	XAxisAsTime = None
             	widht = None
             	height = None
             	__rtixpos = None
             	__rtiypos = None
             	__cmapxpos = None
             	__cmapypos = None
             	__profxpos = None
             	__profypos = None
             	def __init__(self,indexFig,nsubplot,winTitle,colormap,showColorbar,showPowerProfile,XAxisAsTime):
             		self.width = 700
             		self.height = 150
             		self.showColorbar = showColorbar
             		self.showPowerProfile = showPowerProfile
             		self.XAxisAsTime = XAxisAsTime
             		ncol = 1
             		nrow = nsubplot
             		initMatplotlib(indexFig,ncol,nrow,winTitle,self.width,self.height)
             		setColormap(colormap)
             		self.ncol = ncol
             		self.nrow = nrow
             	def setFigure(self,indexFig):
             		setFigure(indexFig)
             	def setRtiScreenPos(self):
             		if self.showPowerProfile: xi = 0.07; xf = 0.65
             		else:   xi = 0.07; xf = 0.9
             		yi = 0.15; yf = 0.80
             		xpos = [xi,xf]
             		ypos = [yi,yf]
             		self.__rtixpos = xpos
             		self.__rtiypos = ypos
             		return xpos,ypos
             	def setColorbarScreenPos(self):
             		xi = self.__rtixpos[1] + 0.03; xf = xi + 0.03
             		yi = self.__rtiypos[0]; yf = self.__rtiypos[1]
             		xpos = [xi,xf]
             		ypos = [yi,yf]
             		self.__cmapxpos = xpos
             		self.__cmapypos = ypos
             		return xpos,ypos
             	def setPowerprofileScreenPos(self):
             		xi = self.__cmapxpos[1] + 0.05; xf = xi + 0.20
             		yi = self.__rtiypos[0]; yf = self.__rtiypos[1]
             		xpos = [xi,xf]
             		ypos = [yi,yf]
             		self.__profxpos = [xi,xf]
             		self.__profypos = [yi,yf]
             		return xpos,ypos
             	def setup(self,subplot,xmin,xmax,ymin,ymax,zmin,zmax,title,xlabel,ylabel,timedata,timezone='lt',npoints=100):
             		# Config Rti plot
             		szchar = 1.10
             		name = 'rti'
             		key = name + '%d'%subplot
             		# xmin, xmax --> minHour, max Hour : valores que definen el ejex x=[horaInicio,horaFinal]
             		thisDateTime = datetime.datetime.fromtimestamp(timedata)
             		startDateTime = datetime.datetime(thisDateTime.year,thisDateTime.month,thisDateTime.day,xmin,0,0)
             		endDateTime = datetime.datetime(thisDateTime.year,thisDateTime.month,thisDateTime.day,xmax,59,59)
             		deltaTime = 0
             		if timezone == 'lt':
             			deltaTime = time.timezone
             		startTimeInSecs = time.mktime(startDateTime.timetuple()) - deltaTime
             		endTimeInSecs = time.mktime(endDateTime.timetuple()) - deltaTime
             		xrange = [startTimeInSecs,endTimeInSecs]
             		totalTimeInXrange = endTimeInSecs - startTimeInSecs + 1.
             		deltax = totalTimeInXrange / npoints
             		yrange = [ymin,ymax]
             		zrange = [zmin,zmax]
             		xpos,ypos = self.setRtiScreenPos()
             		pcolorObj = BaseGraph(name,subplot,xpos,ypos,xlabel,ylabel,title,szchar,xrange,yrange,zrange,deltax)
             		if self.XAxisAsTime:
             			pcolorObj.setXAxisAsTime(self.XAxisAsTime)
             			xopt = 'bcnstd'
             			yopt = 'bcnstv'
             		else:
             			xopt = 'bcnst'
             			yopt = 'bcnstv'
             		pcolorObj.plotBox(pcolorObj.xrange[0], pcolorObj.xrange[1], pcolorObj.yrange[0], pcolorObj.yrange[1], xopt, yopt)
             		self.pcolorObjDic[key] = pcolorObj
             		# Config Colorbar
             		if self.showColorbar:
             			szchar = 0.9
             			name = 'colorbar'
             			key = name + '%d'%subplot
             			xpos,ypos = self.setColorbarScreenPos()
             			xrange = [0.,1.]
             			yrange = [zmin,zmax]
             			cmapObj = BaseGraph(name,subplot,xpos,ypos,'','','dB',szchar,xrange,yrange)
             			cmapObj.plotBox(cmapObj.xrange[0], cmapObj.xrange[1], cmapObj.yrange[0], cmapObj.yrange[1], 'bc', 'bcm')
             			cmapObj.colorbarPlot(cmapObj.xrange[0], cmapObj.xrange[1], cmapObj.yrange[0], cmapObj.yrange[1])
             			cmapObj.plotBox(cmapObj.xrange[0], cmapObj.xrange[1], cmapObj.yrange[0], cmapObj.yrange[1], 'bc', 'bcmtsv')
             			self.colorbarObjDic[key] = cmapObj
             		# Config Power profile
             		if self.showPowerProfile:
             			szchar = 0.8
             			name = 'pwprofile'
             			key = name + '%d'%subplot
             			xpos,ypos = self.setPowerprofileScreenPos()
             			xrange = [zmin,zmax]
             			yrange = [ymin,ymax]
             			powObj = BaseGraph(name,subplot,xpos,ypos,'dB','','Power Profile',szchar,xrange,yrange)
             			powObj.setLineStyle(2)
             			powObj.plotBox(powObj.xrange[0], powObj.xrange[1], powObj.yrange[0], powObj.yrange[1], 'bcntg', 'bc')
             			powObj.setLineStyle(1)
             			powObj.plotBox(powObj.xrange[0], powObj.xrange[1], powObj.yrange[0], powObj.yrange[1], 'bc', 'bc')
             			self.pwprofileObjDic[key] = powObj
             	def plot(self,subplot,x,y,z):
             		# RTI plot
             		name = 'rti'
             		key = name + '%d'%subplot
             		data = numpy.reshape(z, (1,-1))
             		data = numpy.abs(data)
             		data = 10*numpy.log10(data)
             		newx = [x,x+1]
             		pcolorObj = self.pcolorObjDic[key]
             		if pcolorObj.xaxisIsTime:
             			xopt = 'bcstd'
             			yopt = 'bcst'
             		else:
             			xopt = 'bcst'
             			yopt = 'bcst'
             		pcolorObj.plotBox(pcolorObj.xrange[0], pcolorObj.xrange[1], pcolorObj.yrange[0], pcolorObj.yrange[1], xopt, yopt)
             		deltax = pcolorObj.deltax
             		deltay = None
             		if pcolorObj.xmin == None and pcolorObj.xmax == None:
             			pcolorObj.xmin = x
             			pcolorObj.xmax = x
             		if x >= pcolorObj.xmax:
             			xmin = x
             			xmax = x + deltax
             			x = [x]
             			pcolorObj.advPcolorPlot(data,
             									x,
             									y,
             									xmin=xmin,
             									xmax=xmax,
             									ymin=pcolorObj.yrange[0],
             									ymax=pcolorObj.yrange[1],
             									zmin=pcolorObj.zrange[0],
             									zmax=pcolorObj.zrange[1],
             									deltax=deltax,
             									deltay=deltay,
             									getGrid=pcolorObj.getGrid)
             			pcolorObj.xmin = xmin
             			pcolorObj.xmax = xmax
             		# Power Profile
             		if self.showPowerProfile:
             			data = numpy.reshape(data,(numpy.size(data)))
             			name = 'pwprofile'
             			key = name + '%d'%subplot
             			powObj = self.pwprofileObjDic[key]
             			if powObj.setXYData() != None:
             				clearData(powObj)
             				powObj.setLineStyle(2)
             				powObj.plotBox(powObj.xrange[0], powObj.xrange[1], powObj.yrange[0], powObj.yrange[1], 'bcntg', 'bc')
             				powObj.setLineStyle(1)
             			else:
             				powObj.setXYData(data,y)
             			powObj.plotBox(powObj.xrange[0], powObj.xrange[1], powObj.yrange[0], powObj.yrange[1], 'bc', 'bc')
             			powObj.basicXYPlot(data,y)
             			powObj.setXYData(data,y)
             	def savePlot(self,indexFig,filename):
             		width = self.width*self.ncol
             		hei = self.height*self.nrow
             		savePlplot(filename,width,hei)
             	def refresh(self):
             		refresh()
             if __name__ == '__main__':
             	"""
             	Ejemplo1
             	"""
             	#Setting the signal
             	fs = 8000
             	f0 = 200
             	f1 = 400
             	T = 1./fs
             	x = numpy.arange(160)
             	y1 = numpy.sin(2*numpy.pi*f0*x*T)
             	y2 = numpy.sin(2*numpy.pi*f1*x*T)
             	signalList = [y1,y2]
             	xmin = numpy.min(x)
             	xmax = numpy.max(x)
             	ymin = numpy.min(y1)
             	ymax = numpy.max(y1)
             	# Creating Object
             	indexPlot = 1
             	nsubplot = 2
             	winTitle = "mi grafico v1"
             	subplotTitle = "subplot - No."
             	xlabel = ""
             	ylabel = ""
             	linearObj = LinearPlot(indexPlot,nsubplot,winTitle)
             	#Config SubPlots
             	for subplot in range(nsubplot):
             		indexplot = subplot + 1
             		title = subplotTitle + '%d'%indexplot
             		linearObj.setup(indexplot, xmin, xmax, ymin, ymax, title, xlabel, ylabel)
             	#Plotting
             	type = "simple"
             	for subplot in range(nsubplot):
             		indexplot = subplot + 1
             		y = signalList[subplot]
             		linearObj.plot(indexplot, x, y, type)
             	linearObj.refresh()
             	linearObj.show()
             #	"""
             #	Ejemplo2
             #	"""
             #
             #	# make these smaller to increase the resolution
             #	dx, dy = 0.05, 0.05
             #	x = numpy.arange(-3.0, 3.0001, dx)
             #	y = numpy.arange(-2.0, 2.0001, dy)
             ##	X,Y = numpy.meshgrid(x, y)
             #	X,Y = sn.ndgrid(x, y)
             #	Z = (1- X/2 + X**5 + Y**3)*numpy.exp(-X**2-Y**2)
             #
             #	# Creating Object
             #	indexPlot = 2
             #	nsubplot = 1
             #	winTitle = "mi grafico pcolor"
             #	colormap = "br_green"
             #	showColorbar = True
             #	showPowerProfile = False
             #	XAxisAsTime = False
             #
             #	subplotTitle = "subplot no. "
             #	xlabel = ""
             #	ylabel = ""
             #
             #	xmin = -3.0
             #	xmax = 3.0
             #	ymin = -2.0
             #	ymax = 2.0
             #	zmin = -0.3
             #	zmax = 1.0
             #
             #	isPlotIni = False
             #	isPlotConfig = False
             #	ntimes = 10
             #
             #
             #	for i in range(ntimes):
             #
             #		# Instancia del objeto
             #		if not(isPlotConfig):
             #			pcolorObj = PcolorPlot(indexPlot, nsubplot, winTitle, colormap, showColorbar, showPowerProfile, XAxisAsTime)
             #			isPlotConfig = True
             #
             #		# Crea los subplots
             #		if not(isPlotIni):
             #			for index in range(nsubplot):
             #				indexplot = index + 1
             #				title = subplotTitle + '%d'%indexplot
             #				subplot = index
             #				pcolorObj.createObjects(indexplot,xmin,xmax,ymin,ymax,zmin,zmax,title,xlabel,ylabel)
             #			isPlotIni = True
             #
             #		# Inicializa el grafico en cada iteracion
             #		pcolorObj.setFigure(indexPlot)
             #		pcolorObj.setNewPage("")
             #
             #		for index in range(nsubplot):
             #			subplot = index
             #			pcolorObj.iniPlot(subplot+1)
             #
             #		#plotea los datos
             #		for channel in range(nsubplot):
             #			data = Z+0.1*numpy.random.randn(len(x),len(y))
             #			pcolorObj.plot(channel+1, x, y, data)
             #
             #		pcolorObj.refresh()
             #
             ##		pcolorObj.closePage() #descomentar esta linea para mas iteraciones
             #
             #		time.sleep(1)
             #
             #	pcolorObj.show()
             #
             #	print "end"

schainpy2/IO/JROHeaderIO.py +3 -3

             '''
             $Author$
             $Id$
             '''
             import numpy
             import copy
             class Header:
                 def __init__(self):
                     raise
                 def copy(self):
                     return copy.deepcopy(self)
                 def read():
                     pass
                 def write():
                     pass
             class BasicHeader(Header):
                 size = None
                 version = None
                 dataBlock = None
                 utc = None
                 miliSecond = None
                 timeZone = None
                 dstFlag = None
                 errorCount = None
                 struct = None
                 def __init__(self):
                     self.size = 0
                     self.version = 0
                     self.dataBlock = 0
                     self.utc = 0
                     self.miliSecond = 0
                     self.timeZone = 0
                     self.dstFlag = 0
                     self.errorCount = 0
                     self.struct = numpy.dtype([
                                           ('nSize','<u4'),
                                           ('nVersion','<u2'),
                                           ('nDataBlockId','<u4'),
                                           ('nUtime','<u4'),
                                           ('nMilsec','<u2'),
                                           ('nTimezone','<i2'),
                                           ('nDstflag','<i2'),
                                           ('nErrorCount','<u4')
                                           ])
                 def read(self, fp):
                     try:
                         header = numpy.fromfile(fp, self.struct,1)
                         self.size = header['nSize'][0]
                         self.version = header['nVersion'][0]
                         self.dataBlock = header['nDataBlockId'][0]
                         self.utc = header['nUtime'][0]
                         self.miliSecond = header['nMilsec'][0]
                         self.timeZone = header['nTimezone'][0]
                         self.dstFlag = header['nDstflag'][0]
                         self.errorCount = header['nErrorCount'][0]
                     except:
                         return 0
                     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,self.struct)
                     header.tofile(fp)
                     return 1
             class SystemHeader(Header):
                 size = None
                 nSamples = None
                 nProfiles = None
                 nChannels = None
                 adcResolution = None
                 pciDioBusWidth = None
                 struct = None
                 def __init__(self):
                     self.size = 0
                     self.nSamples = 0
                     self.nProfiles = 0
                     self.nChannels = 0
                     self.adcResolution = 0
                     self.pciDioBusWidth = 0
                     self.struct = numpy.dtype([
                                         ('nSize','<u4'),
                                         ('nNumSamples','<u4'),
                                         ('nNumProfiles','<u4'),
                                         ('nNumChannels','<u4'),
                                         ('nADCResolution','<u4'),
                                         ('nPCDIOBusWidth','<u4'),
                                         ])
                 def read(self, fp):
                     try:
                         header = numpy.fromfile(fp,self.struct,1)
                         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]
                     except:
                         return 0
                     return 1
                 def write(self, fp):
                     headerTuple = (self.size,self.nSamples,self.nProfiles,self.nChannels,self.adcResolution,self.pciDioBusWidth)
                     header = numpy.array(headerTuple,self.struct)
                     header.tofile(fp)
                     return 1
             class RadarControllerHeader(Header):
                 size = None
                 expType = None
                 nTx = None
                 ipp = None
                 txA = None
                 txB = None
                 nWindows = None
                 numTaus = None
                 codeType = None
                 line6Function = None
                 line5Function = None
                 fClock = None
                 prePulseBefore = None
                 prePulserAfter = None
                 rangeIpp = None
                 rangeTxA = None
                 rangeTxB = None
                 struct = None
                 def __init__(self):
                     self.size = 0
                     self.expType = 0
                     self.nTx = 0
                     self.ipp = 0
                     self.txA = 0
                     self.txB = 0
                     self.nWindows = 0
                     self.numTaus = 0
                     self.codeType = 0
                     self.line6Function = 0
                     self.line5Function = 0
                     self.fClock = 0
                     self.prePulseBefore = 0
                     self.prePulserAfter = 0
                     self.rangeIpp = 0
                     self.rangeTxA = 0
                     self.rangeTxB = 0
                     self.struct = 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'),
                                          ])
                     self.samplingWindowStruct = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
                     self.samplingWindow = None
                     self.nHeights = None
                     self.firstHeight = None
                     self.deltaHeight = None
                     self.samplesWin = None
                     self.nCode = None
                     self.nBaud = None
                     self.code = None
                     self.flip1 = None
                     self.flip2 = None
                     self.dynamic = numpy.array([],numpy.dtype('byte'))
                 def read(self, fp):
                     try:
                         startFp = fp.tell()
                         header = numpy.fromfile(fp,self.struct,1)
                         self.size = header['nSize'][0]
                         self.expType = header['nExpType'][0]
                         self.nTx = header['nNTx'][0]
                         self.ipp = header['fIpp'][0]
                         self.txA = header['fTxA'][0]
                         self.txB = header['fTxB'][0]
                         self.nWindows = header['nNumWindows'][0]
                         self.numTaus = header['nNumTaus'][0]
                         self.codeType = header['nCodeType'][0]
                         self.line6Function = header['nLine6Function'][0]
                         self.line5Function = header['nLine5Function'][0]
                         self.fClock = header['fClock'][0]
                         self.prePulseBefore = header['nPrePulseBefore'][0]
                         self.prePulserAfter = header['nPrePulseAfter'][0]
                         self.rangeIpp = header['sRangeIPP'][0]
                         self.rangeTxA = header['sRangeTxA'][0]
                         self.rangeTxB = header['sRangeTxB'][0]
                         # jump Dynamic Radar Controller Header
                         jumpFp =  self.size - 116
                         self.dynamic = numpy.fromfile(fp,numpy.dtype('byte'),jumpFp)
                         #pointer backward to dynamic header and read
                         backFp = fp.tell() - jumpFp
                         fp.seek(backFp)
                         self.samplingWindow = numpy.fromfile(fp,self.samplingWindowStruct,self.nWindows)
                         self.nHeights = numpy.sum(self.samplingWindow['nsa'])
                         self.firstHeight = self.samplingWindow['h0']
                         self.deltaHeight = self.samplingWindow['dh']
                         self.samplesWin = self.samplingWindow['nsa']
                         self.Taus = numpy.fromfile(fp,'<f4',self.numTaus)
                         if self.codeType != 0:
                             self.nCode = numpy.fromfile(fp,'<u4',1)
                             self.nBaud = numpy.fromfile(fp,'<u4',1)
                             self.code = numpy.empty([self.nCode,self.nBaud],dtype='u1')
                             tempList = []
                             for ic in range(self.nCode):
                                 temp = numpy.fromfile(fp,'u1',4*numpy.ceil(self.nBaud/32.))
                                 tempList.append(temp)
                                 self.code[ic] = numpy.unpackbits(temp[::-1])[-1*self.nBaud:]
                             self.code = 2.0*self.code - 1.0
                         if self.line5Function == RCfunction.FLIP:
                             self.flip1 = numpy.fromfile(fp,'<u4',1)
                         if self.line6Function == RCfunction.FLIP:
                             self.flip2 = numpy.fromfile(fp,'<u4',1)
                         endFp = self.size + startFp
                         jumpFp =  endFp - fp.tell()
                         if jumpFp > 0:
                             fp.seek(jumpFp)
                     except:
                         return 0
                     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.prePulserAfter,
                                    self.rangeIpp,
                                    self.rangeTxA,
                                    self.rangeTxB)
                     header = numpy.array(headerTuple,self.struct)
                     header.tofile(fp)
                     dynamic = self.dynamic
                     dynamic.tofile(fp)
                     return 1
             class ProcessingHeader(Header):
                 size = None
                 dtype = None
                 blockSize = None
                 profilesPerBlock = None
                 dataBlocksPerFile = None
                 nWindows = None
                 processFlags = None
                 nCohInt = None
                 nIncohInt = None
                 totalSpectra = None
                 struct = None
                 flag_dc = None
                 flag_cspc = None
                 def __init__(self):
                     self.size = 0
-                    self.dataType = 0
+                    self.dtype = 0
                     self.blockSize = 0
                     self.profilesPerBlock = 0
                     self.dataBlocksPerFile = 0
                     self.nWindows = 0
                     self.processFlags = 0
                     self.nCohInt = 0
                     self.nIncohInt = 0
                     self.totalSpectra = 0
                     self.struct = numpy.dtype([
                                            ('nSize','<u4'),
                                            ('nDataType','<u4'),
                                            ('nSizeOfDataBlock','<u4'),
                                            ('nProfilesperBlock','<u4'),
                                            ('nDataBlocksperFile','<u4'),
                                            ('nNumWindows','<u4'),
                                            ('nProcessFlags','<u4'),
                                            ('nCoherentIntegrations','<u4'),
                                            ('nIncoherentIntegrations','<u4'),
                                            ('nTotalSpectra','<u4')
                                            ])
                     self.samplingWindow = 0
                     self.structSamplingWindow = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
                     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
                 def read(self, fp):
                     try:
                         header = numpy.fromfile(fp,self.struct,1)
                         self.size = header['nSize'][0]
-                        self.dataType = header['nDataType'][0]
+                        self.dtype = header['nDataType'][0]
                         self.blockSize = header['nSizeOfDataBlock'][0]
                         self.profilesPerBlock = header['nProfilesperBlock'][0]
                         self.dataBlocksPerFile = header['nDataBlocksperFile'][0]
                         self.nWindows = header['nNumWindows'][0]
                         self.processFlags = header['nProcessFlags']
                         self.nCohInt = header['nCoherentIntegrations'][0]
                         self.nIncohInt = header['nIncoherentIntegrations'][0]
                         self.totalSpectra = header['nTotalSpectra'][0]
                         self.samplingWindow = numpy.fromfile(fp,self.structSamplingWindow,self.nWindows)
                         self.nHeights = numpy.sum(self.samplingWindow['nsa'])
                         self.firstHeight = self.samplingWindow['h0'][0]
                         self.deltaHeight = self.samplingWindow['dh'][0]
                         self.samplesWin = self.samplingWindow['nsa']
                         self.spectraComb = numpy.fromfile(fp,'u1',2*self.totalSpectra)
                         if ((self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE) == PROCFLAG.DEFINE_PROCESS_CODE):
                             self.nCode = numpy.fromfile(fp,'<u4',1)
                             self.nBaud = numpy.fromfile(fp,'<u4',1)
                             self.code = numpy.fromfile(fp,'<f4',self.nCode*self.nBaud).reshape(self.nBaud,self.nCode)
                         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
                         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
                     except:
                         return 0
                     return 1
                 def write(self, fp):
                     headerTuple = (self.size,
-                                   self.dataType,
+                                   self.dtype,
                                    self.blockSize,
                                    self.profilesPerBlock,
                                    self.dataBlocksPerFile,
                                    self.nWindows,
                                    self.processFlags,
                                    self.nCohInt,
                                    self.nIncohInt,
                                    self.totalSpectra)
                     header = numpy.array(headerTuple,self.struct)
                     header.tofile(fp)
                     if self.nWindows != 0:
                         sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
                         samplingWindow = numpy.array(sampleWindowTuple,self.structSamplingWindow)
                         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 = self.nCode #Probar con un dato que almacene codigo, hasta el momento no se hizo la prueba
                         nCode.tofile(fp)
                         nBaud = self.nBaud
                         nBaud.tofile(fp)
                         code = self.code.reshape(nCode*nBaud)
                         code.tofile(fp)
                     return 1
             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)

schainpy2/Processing/SpectraProcessor.py +54 -40

             '''
             $Author$
             $Id$
             '''
             import os, sys
             import numpy
             import time
             import datetime
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from Data.JROData import SpectraHeis
             from IO.SpectraIO import SpectraWriter
             #from Graphics.schainPlotTypes import SpcFigure
             #from JRONoise import Noise
             class SpectraProcessor:
                 '''
                 classdocs
                 '''
                 dataInObj = None
                 dataOutObj = None
                 noiseObj = None
                 integratorObjList = []
                 writerObjList = []
                 integratorObjIndex = None
                 writerObjIndex = None
                 profIndex = 0 # Se emplea cuando el objeto de entrada es un Voltage
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.integratorObjIndex = None
                     self.writerObjIndex = None
                     self.plotObjIndex = None
                     self.integratorOst = []
                     self.plotObjList = []
                     self.noiseObj = bjList = []
                     self.writerObjLiNone
                     self.buffer = None
                     self.profIndex = 0
                 def setup(self, dataInObj=None, dataOutObj=None, nFFTPoints=None, pairList=None):
                     if dataInObj == None:
                         raise ValueError, "This SpectraProcessor.setup() function needs dataInObj input variable"
                     if dataInObj.type == "Voltage":
                         if nFFTPoints == None:
                             raise ValueError, "This SpectraProcessor.setup() function needs nFFTPoints input variable"
                     else:
                         nFFTPoints = dataInObj.nFFTPoints
                     self.dataInObj = dataInObj
                     if dataOutObj == None:
                         dataOutObj = Spectra()
                     self.dataOutObj = dataOutObj
                     return self.dataOutObj
                 def init(self):
                     self.integratorObjIndex = 0
                     self.writerObjIndex = 0
                     self.plotObjIndex = 0
                     if self.dataInObj.type == "Voltage":
                         if self.buffer == None:
                             self.buffer = numpy.zeros((self.nChannels,
                                                        self.nFFTPoints,
                                                        self.dataInObj.nHeights),
                                                       dtype='complex')
                         self.buffer[:,self.profIndex,:] = self.dataInObj.data
                         self.profIndex += 1
                         if self.profIndex == self.nFFTPoints:
                             self.__getFft()
                             self.dataOutObj.flagNoData = False
                             self.buffer = None
                             self.profIndex = 0
                             return
                         self.dataOutObj.flagNoData = True
                         return
                     #Other kind of data
                     if self.dataInObj.type == "Spectra":
                         self.dataOutObj.copy(self.dataInObj)
                         self.dataOutObj.flagNoData = False
                         return
-                    raise ValueError, "The datatype is not valid"
+                    raise ValueError, "The dtype is not valid"
                 def __getFft(self):
                     """
                     Convierte valores de Voltaje a Spectra
                     Affected:
                         self.dataOutObj.data_spc
                         self.dataOutObj.data_cspc
                         self.dataOutObj.data_dc
                         self.dataOutObj.heightList
                         self.dataOutObj.m_BasicHeader
                         self.dataOutObj.m_ProcessingHeader
-                        self.dataOutObj.m_RadarControllerHeader
+                        self.dataOutObj.radarControllerHeaderObj
-                        self.dataOutObj.m_SystemHeader
+                        self.dataOutObj.systemHeaderObj
                         self.profIndex
                         self.buffer
                         self.dataOutObj.flagNoData
-                        self.dataOutObj.dataType
+                        self.dataOutObj.dtype
                         self.dataOutObj.nPairs
                         self.dataOutObj.nChannels
                         self.dataOutObj.nProfiles
-                        self.dataOutObj.m_SystemHeader.numChannels
+                        self.dataOutObj.systemHeaderObj.numChannels
                         self.dataOutObj.m_ProcessingHeader.totalSpectra
                         self.dataOutObj.m_ProcessingHeader.profilesPerBlock
                         self.dataOutObj.m_ProcessingHeader.numHeights
                         self.dataOutObj.m_ProcessingHeader.spectraComb
                         self.dataOutObj.m_ProcessingHeader.shif_fft
                     """
                     if self.dataInObj.flagNoData:
                         return 0
                     fft_volt = numpy.fft.fft(self.buffer,axis=1)
                     dc = fft_volt[:,0,:]
                     #calculo de self-spectra
                     fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
                     spc = fft_volt * numpy.conjugate(fft_volt)
                     spc = spc.real
                     blocksize = 0
                     blocksize += dc.size
                     blocksize += spc.size
                     cspc = None
                     pairIndex = 0
                     if self.pairList != None:
                         #calculo de cross-spectra
                         cspc = numpy.zeros((self.nPairs, self.nFFTPoints, self.nHeights), dtype='complex')
                         for pair in self.pairList:
                             cspc[pairIndex,:,:] = numpy.abs(fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:]))
                             pairIndex += 1
                         blocksize += cspc.size
                     self.dataOutObj.data_spc = spc
                     self.dataOutObj.data_cspc = cspc
                     self.dataOutObj.data_dc = dc
                     self.dataOutObj.m_ProcessingHeader.blockSize = blocksize
                     self.dataOutObj.m_BasicHeader.utc = self.dataInObj.m_BasicHeader.utc
             #        self.getNoise()
                 def addWriter(self, wrpath, blocksPerFile):
                     objWriter = SpectraWriter(self.dataOutObj)
                     objWriter.setup(wrpath, blocksPerFile)
                     self.writerObjList.append(objWriter)
                 def addIntegrator(self,N,timeInterval):
                     objIncohInt = IncoherentIntegration(N,timeInterval)
                     self.integratorObjList.append(objIncohInt)
                 def addSpc(self, idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile):
                     spcObj = SpcFigure(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
                     self.plotObjList.append(spcObj)
                 def plotSpc(self, idfigure=None,
                                 xmin=None,
                                 xmax=None,
                                 ymin=None,
                                 ymax=None,
                                 minvalue=None,
                                 maxvalue=None,
                                 wintitle='',
                                 driver='plplot',
                                 colormap='br_greeen',
                                 colorbar=True,
                                 showprofile=False,
                                 save=False,
                                 gpath=None):
                     if self.dataOutObj.flagNoData:
                         return 0
                     nframes = len(self.dataOutObj.channelList)
                     if len(self.plotObjList) <= self.plotObjIndex:
                         self.addSpc(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
                     x = numpy.arange(self.dataOutObj.nFFTPoints)
                     y = self.dataOutObj.heightList
                     channelList = self.dataOutObj.channelList
                     data = 10.*numpy.log10(self.dataOutObj.data_spc[channelList,:,:])
             #        noisedB = 10.*numpy.log10(noise)
                     noisedB = numpy.arange(len(channelList)+1)
                     noisedB = noisedB *1.2
                     titleList = []
                     for i in range(len(noisedB)):
                         title = "%.2f"%noisedB[i]
                         titleList.append(title)
                     thisdatetime = datetime.datetime.fromtimestamp(self.dataOutObj.dataUtcTime)
                     dateTime = "%s"%(thisdatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     figuretitle = "Spc Radar Data: %s"%dateTime
                     cleardata = True
                     plotObj = self.plotObjList[self.plotObjIndex]
                     plotObj.plotPcolor(data,
                                        x,
                                        y,
                                        channelList,
                                        xmin,
                                        xmax,
                                        ymin,
                                        ymax,
                                        minvalue,
                                        maxvalue,
                                        figuretitle,
                                        None,
                                        save,
                                        gpath,
                                        cleardata,
                                        titleList)
                     self.plotObjIndex += 1
                 def writeData(self, wrpath, blocksPerFile):
                     if self.dataOutObj.flagNoData:
                             return 0
                     if len(self.writerObjList) <= self.writerObjIndex:
                         self.addWriter(wrpath, blocksPerFile)
                     self.writerObjList[self.writerObjIndex].putData()
                     self.writerObjIndex += 1
                 def integrator(self, N=None, timeInterval=None):
                     if self.dataOutObj.flagNoData:
                             return 0
                     if len(self.integratorObjList) <= self.integratorObjIndex:
                         self.addIntegrator(N,timeInterval)
                     myIncohIntObj = self.integratorObjList[self.integratorObjIndex]
                     myIncohIntObj.exe(data=self.dataOutObj.data_spc,timeOfData=self.dataOutObj.m_BasicHeader.utc)
                     if myIncohIntObj.isReady:
                         self.dataOutObj.data_spc = myIncohIntObj.data
                         self.dataOutObj.nAvg = myIncohIntObj.navg
                         self.dataOutObj.m_ProcessingHeader.incoherentInt = self.dataInObj.m_ProcessingHeader.incoherentInt*myIncohIntObj.navg
                         self.dataOutObj.flagNoData = False
                         """Calcular el ruido"""
                         self.getNoise()
                     else:
                         self.dataOutObj.flagNoData = True
                     self.integratorObjIndex += 1
             class SpectraHeisProcessor:
                 def __init__(self):
                     self.integratorObjIndex = None
                     self.writerObjIndex = None
                     self.plotterObjIndex = None
                     self.integratorObjList = []
                     self.writerObjList = []
                     self.plotterObjList = []
                     #self.noiseObj = Noise()
-                def setup(self,dataInObj=None, dataOutObj=None, nFFTPoints=None, pairList=None):
+                def setup(self, dataInObj, dataOutObj=None, nFFTPoints=None, pairList=None):
-                    if dataInObj == None:
-                        raise ValueError, ""
                     if nFFTPoints == None:
-                        raise ValueError, ""
+                        nFFTPoints = self.dataInObj.nHeights
                     self.dataInObj = dataInObj
                     if dataOutObj == None:
                         dataOutObj = SpectraHeis()
                     self.dataOutObj = dataOutObj
               #      self.noiseObj = Noise()
                     ##########################################
                     self.nFFTPoints = nFFTPoints
                     self.nChannels = self.dataInObj.nChannels
                     self.nHeights = self.dataInObj.nHeights
                     self.pairList = pairList
                     if pairList != None:
                         self.nPairs = len(pairList)
                     else:
                         self.nPairs = 0
-                    self.dataOutObj.heightList = self.dataInObj.heightList
+                    self.dataOutObj.radarControllerHeaderObj = self.dataInObj.radarControllerHeaderObj.copy()
-                    self.dataOutObj.channelIndexList = self.dataInObj.channelIndexList
+                    self.dataOutObj.systemHeaderObj = self.dataInObj.systemHeaderObj.copy()
-                    self.dataOutObj.m_RadarControllerHeader = self.dataInObj.m_RadarControllerHeader.copy()
-                    self.dataOutObj.m_SystemHeader = self.dataInObj.m_SystemHeader.copy()
+                    self.dataOutObj.type = "SpectraHeis"
+                    self.dataOutObj.dtype = self.dataInObj.dtype
-                    self.dataOutObj.dataType = self.dataInObj.dataType
-                    self.dataOutObj.nPairs = self.nPairs
                     self.dataOutObj.nChannels = self.nChannels
-                    self.dataOutObj.nProfiles = self.nFFTPoints
                     self.dataOutObj.nHeights = self.nHeights
-                    self.dataOutObj.nFFTPoints = self.nFFTPoints
-                    #self.dataOutObj.data = None
-                    self.dataOutObj.m_SystemHeader.numChannels = self.nChannels
+                    self.dataOutObj.nProfiles = self.nFFTPoints
-                    self.dataOutObj.m_SystemHeader.nProfiles = self.nFFTPoints
+                    self.dataOutObj.heightList = None
+                    self.dataOutObj.channelList = None
+                    self.dataOutObj.channelIndexList = None
+                    self.dataOutObj.flagNoData = False
+                    self.dataOutObj.flagTimeBlock = False
+                    self.dataOutObj.dataUtcTime = None
-                    self.dataOutObj.m_ProcessingHeader.totalSpectra = self.nChannels + self.nPairs
+                    self.dataOutObj.nCode = None
-                    self.dataOutObj.m_ProcessingHeader.profilesPerBlock = self.nFFTPoints
-                    self.dataOutObj.m_ProcessingHeader.numHeights = self.nHeights
-                    self.dataOutObj.m_ProcessingHeader.shif_fft = True
-                    spectraComb = numpy.zeros( (self.nChannels+self.nPairs)*2,numpy.dtype('u1'))
+                    self.dataOutObj.nBaud = None
-                    k = 0
-                    for i in range( 0,self.nChannels*2,2 ):
-                        spectraComb[i]   = k
-                        spectraComb[i+1] = k
-                        k += 1
-                    k *= 2
+                    self.dataOutObj.code = None
+                    self.dataOutObj.flagDecodeData = True #asumo q la data esta decodificada
+                    self.dataOutObj.flagDeflipData = True #asumo q la data esta sin flip
+                    self.dataOutObj.flagShiftFFT = False
+                    self.dataOutObj.ippSeconds = None
-                    if self.pairList != None:
+                    self.dataOutObjdata_spc = None
-                        for pair in self.pairList:
+                    self.dataOutObjdata_cspc = None
-                            spectraComb[k]   = pair[0]
-                            spectraComb[k+1] = pair[1]
+                    self.dataOutObjdata_dc = None
-                            k += 2
+                    self.dataOutObjnFFTPoints = None
-                    self.dataOutObj.m_ProcessingHeader.spectraComb = spectraComb
+                    self.dataOutObjnPairs = None
+                    self.dataOutObjpairsList = None
                     return self.dataOutObj
                 def init(self):
                     self.integratorObjIndex = 0
                     self.writerObjIndex = 0
                     self.plotterObjIndex = 0
                     if self.dataInObj.type == "Voltage":
                         self.__getFft()
                         self.dataOutObj.flagNoData = False
                         return
                     #Other kind of data
                     if self.dataInObj.type == "SpectraHeis":
                         self.dataOutObj.copy(self.dataInObj)
                         self.dataOutObj.flagNoData = False
                         return
-                    raise ValueError, "The datatype is not valid"
+                    raise ValueError, "The type is not valid"
                 def __getFft(self):
                     if self.dataInObj.flagNoData:
                        return 0
                     fft_volt = numpy.fft.fft(self.dataInObj.data, axis=1)
                     #print fft_volt
                     #calculo de self-spectra
                     fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
                     spc = numpy.abs(fft_volt * numpy.conjugate(fft_volt))
                     self.dataOutObj.data_spc = spc
                     #print spc
                 def getSpectra(self):
                     return self.dataOutObj.data_spc
                 def getFrecuencies(self):
                     print self.nFFTPoints
                     return numpy.arange(int(self.nFFTPoints))
                 def addIntegrator(self,N,timeInterval):
                     objIncohInt = IncoherentIntegration(N,timeInterval)
                     self.integratorObjList.append(objIncohInt)
                 def integrator(self, N=None, timeInterval=None):
                     if self.dataOutObj.flagNoData:
                             return 0
                     if len(self.integratorObjList) <= self.integratorObjIndex:
                         self.addIntegrator(N,timeInterval)
                     myIncohIntObj = self.integratorObjList[self.integratorObjIndex]
                     myIncohIntObj.exe(data=self.dataOutObj.data_spc,timeOfData=self.dataOutObj.m_BasicHeader.utc)
                     if myIncohIntObj.isReady:
                         self.dataOutObj.data_spc = myIncohIntObj.data
                         self.dataOutObj.nAvg = myIncohIntObj.navg
                         self.dataOutObj.m_ProcessingHeader.incoherentInt *= myIncohIntObj.navg
                         #print "myIncohIntObj.navg: ",myIncohIntObj.navg
                         self.dataOutObj.flagNoData = False
                         #self.getNoise(type="hildebrand",parm=myIncohIntObj.navg)
             #            self.getNoise(type="sort", parm=16)
                     else:
                         self.dataOutObj.flagNoData = True
                     self.integratorObjIndex += 1
             class IncoherentIntegration:
                 integ_counter = None
                 data = None
                 navg = None
                 buffer = None
                 nIncohInt = None
                 def __init__(self, N = None, timeInterval = None):
                     """
                     N
                     timeInterval - interval time [min], integer value
                     """
                     self.data = None
                     self.navg = None
                     self.buffer = None
                     self.timeOut = None
                     self.exitCondition = False
                     self.isReady = False
                     self.nIncohInt = N
                     self.integ_counter = 0
                     if timeInterval!=None:
                         self.timeIntervalInSeconds = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
                     if ((timeInterval==None) and (N==None)):
                          print 'N = None ; timeInterval = None'
                          sys.exit(0)
                     elif timeInterval == None:
                         self.timeFlag = False
                     else:
                         self.timeFlag = True
                 def exe(self,data,timeOfData):
                     """
                     data
                     timeOfData [seconds]
                     """
                     if self.timeFlag:
                         if self.timeOut == None:
                             self.timeOut = timeOfData + self.timeIntervalInSeconds
                         if timeOfData < self.timeOut:
                             if self.buffer == None:
                                 self.buffer = data
                             else:
                                 self.buffer = self.buffer + data
                             self.integ_counter += 1
                         else:
                             self.exitCondition = True
                     else:
                         if self.integ_counter < self.nIncohInt:
                             if self.buffer == None:
                                 self.buffer = data
                             else:
                                 self.buffer = self.buffer + data
                             self.integ_counter += 1
                         if self.integ_counter == self.nIncohInt:
                             self.exitCondition = True
                     if self.exitCondition:
                         self.data = self.buffer
                         self.navg = self.integ_counter
                         self.isReady = True
                         self.buffer = None
                         self.timeOut = None
                         self.integ_counter = 0
                         self.exitCondition = False
                         if self.timeFlag:
                             self.buffer = data
                             self.timeOut = timeOfData + self.timeIntervalInSeconds
                     else:
                         self.isReady = False
   No newline at end of file

schainpy2/Processing/VoltageProcessor.py +2 -2

             '''
             $Author$
             $Id$
             '''
             import os
             import sys
             import numpy
             import datetime
             import time
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from Data.JROData import Voltage
             from IO.VoltageIO import VoltageWriter
             from Graphics.schainPlotTypes import ScopeFigure, RTIFigure
             class VoltageProcessor:
                 dataInObj = None
                 dataOutObj = None
                 integratorObjIndex = None
                 writerObjIndex = None
                 integratorObjList = None
                 writerObjList = None
                 def __init__(self):
                     self.integratorObjIndex = None
                     self.writerObjIndex = None
                     self.plotObjIndex = None
                     self.integratorObjList = []
                     self.writerObjList = []
                     self.plotObjList = []
                 def setup(self,dataInObj=None,dataOutObj=None):
                     self.dataInObj = dataInObj
                     if self.dataOutObj == None:
                         dataOutObj = Voltage()
                     self.dataOutObj = dataOutObj
                     return self.dataOutObj
                 def init(self):
                     self.integratorObjIndex = 0
                     self.writerObjIndex = 0
                     self.plotObjIndex = 0
                     if not(self.dataInObj.flagNoData):
                         self.dataOutObj.copy(self.dataInObj)
                     # No necesita copiar en cada init() los atributos de dataInObj
                     # la copia deberia hacerse por cada nuevo bloque de datos
                 def addRti(self, idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile):
                     rtiObj = RTIFigure(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
                     self.plotObjList.append(rtiObj)
                 def plotRti(self, idfigure=None,
                                 starttime=None,
                                 endtime=None,
                                 rangemin=None,
                                 rangemax=None,
                                 minvalue=None,
                                 maxvalue=None,
                                 wintitle='',
                                 driver='plplot',
                                 colormap='br_greeen',
                                 colorbar=True,
                                 showprofile=False,
                                 xrangestep=None,
                                 save=False,
                                 gpath=None):
                     if self.dataOutObj.flagNoData:
                         return 0
                     nframes = len(self.dataOutObj.channelList)
                     if len(self.plotObjList) <= self.plotObjIndex:
                         self.addRti(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
                     data = self.dataOutObj.data * numpy.conjugate(self.dataOutObj.data)
                     data = 10*numpy.log10(data.real)
             #        currenttime = self.dataOutObj.dataUtcTime
             #        if timezone == "lt":
                     currenttime = self.dataOutObj.dataUtcTime - time.timezone
                     range = self.dataOutObj.heightList
                     channelList = self.dataOutObj.channelList
                     thisdatetime = datetime.datetime.fromtimestamp(self.dataOutObj.dataUtcTime)
                     dateTime = "%s"%(thisdatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     date = "%s"%(thisdatetime.strftime("%d-%b-%Y"))
                     figuretitle = "RTI Plot Radar Data" #+ date
                     plotObj = self.plotObjList[self.plotObjIndex]
                     cleardata = False
                     plotObj.plotPcolor(data,
                                        currenttime,
                                        range,
                                        channelList,
                                        starttime,
                                        endtime,
                                        rangemin,
                                        rangemax,
                                        minvalue,
                                        maxvalue,
                                        figuretitle,
                                        xrangestep,
                                        save,
                                        gpath,
                                        cleardata)
                     self.plotObjIndex += 1
                 def addScope(self, idfigure, nframes, wintitle, driver):
                     if idfigure==None:
                         idfigure = self.plotObjIndex
                     scopeObj = ScopeFigure(idfigure, nframes, wintitle, driver)
                     self.plotObjList.append(scopeObj)
                 def plotScope(self,
                                 idfigure=None,
                                 minvalue=None,
                                 maxvalue=None,
                                 xmin=None,
                                 xmax=None,
                                 wintitle='',
                                 driver='plplot',
                                 save=False,
                                 gpath=None,
                                 titleList=None,
                                 xlabelList=None,
                                 ylabelList=None,
                                 type="power"):
                     if self.dataOutObj.flagNoData:
                         return 0
                     nframes = len(self.dataOutObj.channelList)
                     if len(self.plotObjList) <= self.plotObjIndex:
                         self.addScope(idfigure, nframes, wintitle, driver)
                     if type=="power":
                         data1D = self.dataOutObj.data * numpy.conjugate(self.dataOutObj.data)
                         data1D = data1D.real
                     if type =="iq":
                         data1D = self.dataOutObj.data
                     thisDatetime = datetime.datetime.fromtimestamp(self.dataOutObj.dataUtcTime)
                     dateTime = "%s"%(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     date = "%s"%(thisDatetime.strftime("%d-%b-%Y"))
                     figureTitle = "Scope Plot Radar Data: " + date
                     plotObj = self.plotObjList[self.plotObjIndex]
                     plotObj.plot1DArray(data1D,
                                          self.dataOutObj.heightList,
                                          self.dataOutObj.channelList,
                                          xmin,
                                          xmax,
                                          minvalue,
                                          maxvalue,
                                          figureTitle,
                                          save,
                                          gpath)
                     self.plotObjIndex += 1
                 def addIntegrator(self, *args):
                     objCohInt = CoherentIntegrator(*args)
                     self.integratorObjList.append(objCohInt)
                 def addWriter(self, *args):
                     writerObj = VoltageWriter(self.dataOutObj)
                     writerObj.setup(*args)
                     self.writerObjList.append(writerObj)
                 def writeData(self, wrpath, blocksPerFile, profilesPerBlock):
                     if self.dataOutObj.flagNoData:
                         return 0
                     if len(self.writerObjList) <= self.writerObjIndex:
                         self.addWriter(wrpath, blocksPerFile, profilesPerBlock)
                     self.writerObjList[self.writerObjIndex].putData()
                     self.writerObjIndex += 1
                 def integrator(self, nCohInt=None, timeInterval=None, overlapping=False):
                     if self.dataOutObj.flagNoData:
                         return 0
                     if len(self.integratorObjList) <= self.integratorObjIndex:
                         self.addIntegrator(nCohInt, timeInterval, overlapping)
                     myCohIntObj = self.integratorObjList[self.integratorObjIndex]
                     myCohIntObj.exe(data = self.dataOutObj.data, datatime=None)
                     self.dataOutObj.flagNoData = True
                     if myCohIntObj.isReady:
                         self.dataOutObj.flagNoData = False
             class CoherentIntegrator:
                 __profIndex = 0
                 __withOverapping  = False
                 __isByTime = False
                 __initime = None
                 __integrationtime = None
                 __buffer = None
                 isReady = False
                 nCohInt = None
                 def __init__(self, nCohInt=None, timeInterval=None, overlapping=False):
                     """
                     Set the parameters of the integration class.
                     Inputs:
                         nCohInt        :    Number of coherent integrations
                         timeInterval   :    Time of integration. If nCohInt is selected this parameter does not work
                         overlapping    :
                     """
                     self.__buffer = None
                     self.isReady = False
                     if nCohInt == None and timeInterval == None:
                         raise ValueError, "nCohInt or timeInterval should be specified ..."
                     if nCohInt != None:
                         self.nCohInt = nCohInt
                         self.__isByTime = False
                     else:
                         self.__integrationtime = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
                         self.__isByTime = True
                     if overlapping:
                         self.__withOverapping = True
                         self.__buffer = None
                     else:
                         self.__withOverapping = False
                         self.__buffer = 0
                     self.__profIndex = 0
                 def putData(self, data):
                     """
                     Add a profile to the __buffer and increase in one the __profileIndex
                     """
                     if not self.__withOverapping:
                         self.__buffer += data
                         self.__profIndex += 1
                         return
                     #Overlapping data
-                    nChannels, nProfiles = data.shape
+                    nChannels, nHeis = data.shape
-                    data = numpy.reshape(data, (1, nChannels, nProfiles))
+                    data = numpy.reshape(data, (1, nChannels, nHeis))
                     if self.__buffer == None:
                         self.__buffer = data
                         self.__profIndex += 1
                         return
                     if self.__profIndex < self.nCohInt:
                         self.__buffer = numpy.vstack((self.__buffer, data))
                         self.__profIndex += 1
                         return
                     self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
                     self.__buffer[self.nCohInt-1] = data
                     #self.__profIndex = self.nCohInt
                     return
                 def pushData(self):
                     """
                     Return the sum of the last profiles and the profiles used in the sum.
                     Affected:
                     self.__profileIndex
                     """
                     if not self.__withOverapping:
                         data = self.__buffer
                         nCohInt = self.__profIndex
                         self.__buffer = 0
                         self.__profIndex = 0
                         return data, nCohInt
                     #Overlapping data
                     data = numpy.sum(self.__buffer, axis=0)
                     nCohInt = self.__profIndex
                     return data, nCohInt
                 def byProfiles(self, data):
                     self.isReady = False
                     avg_data = None
                     self.putData(data)
                     if self.__profIndex == self.nCohInt:
                         avg_data, nCohInt = self.pushData()
                         self.isReady = True
                     return avg_data
                 def byTime(self, data, datatime):
                     self.isReady = False
                     avg_data = None
                     if self.__initime == None:
                         self.__initime = datatime
                     self.putData(data)
                     if (datatime - self.__initime) >= self.__integrationtime:
                         avg_data, nCohInt = self.pushData()
                         self.nCohInt = nCohInt
                         self.isReady = True
                     return avg_data
                 def exe(self, data, datatime=None):
                     if not self.__isByTime:
                         avg_data = self.byProfiles(data)
                     else:
                         avg_data = self.byTime(data, datatime)
                     self.data = avg_data
                     return avg_data

schainpy2/TestSpectraHeis.py +1 0

             '''
             Created on Jul 31, 2012
             @author $Author$
             @version $Id$
             '''
             import os, sys
             import time, datetime
             #import pylab as pl
             from Data.JROData import Voltage
             from IO.VoltageIO import *
             from Data.JROData import SpectraHeis
             from IO.SpectraIO import *
             from Processing.VoltageProcessor import *
             from Processing.SpectraProcessor import *
             from  Graphics.BaseGraph_mpl import LinearPlot
             class TestHeis():
                 i=None
                 def __init__(self):
                     self.setValues()
                     self.createObjects()
                     self.testSChain()
                     self.i=0
                 def setValues( self ):
                     self.path="C:\data2"
                     self.startDate = datetime.date(2012,4,1)
                     self.endDate = datetime.date(2012,6,30)
                     self.startTime = datetime.time(0,0,0)
                     self.endTime = datetime.time(23,0,0)
                     #self.N = 4
                     #self.npts = 8
                 def createObjects( self ):
                     self.readerObj = VoltageReader()
                     self.specProcObj = SpectraHeisProcessor()
                     self.voltObj1 = self.readerObj.setup(
                                                path = self.path,
                                                startDate = self.startDate,
                                                endDate = self.endDate,
                                                startTime = self.startTime,
                                                endTime = self.endTime,
                                                expLabel = '',
                                                online = 0)
                     if not(self.voltObj1):
                         sys.exit(0)
                     print "voltaje o alturas:   %03d"%(self.voltObj1.nHeights)
                     #print "perfiles:   %03d"%(self.voltObj1.nProfiles)
                     self.specObj1 = self.specProcObj.setup(dataInObj = self.voltObj1,nFFTPoints=self.voltObj1.nHeights)
                     print "nChannels: %03d"%(self.specObj1.nChannels)
                     print "nHeights: %03d"%( self.specObj1.nHeights)
                     print "nFFTPoints: %03d"% int(self.specObj1.nFFTPoints)
                 def testSChain( self ):
                      ini = time.time()
                      while(True):
                         self.readerObj.getData()
                         #print self.readerObj.datablock
                         #self.voltProcObj.init()
                         self.specProcObj.init()
                         self.specProcObj.integrator(N=32) ## return self.dataOutObj
                         self.plot()
                         #print self.readerObj.dataOutObj.data
                         #CON TODO ESTO PLoTEO
                         #freq = self.specProcObj.getFrecuencies()
                         #spc = self.specProcObj.getSpectra()
             #            print freq
             #            print spc, spc.shape
             #            pl.plot(freq, spc[2])
             #            pl.show()
                         if self.readerObj.flagNoMoreFiles:
                             break
                         if self.readerObj.flagIsNewBlock:
                             print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
                                                               datetime.datetime.fromtimestamp(self.readerObj.m_BasicHeader.utc),)
                 def plot(self):
             #            x = self.specProcObj.getFrecuencies()
                         x = numpy.arange(self.specObj1.nFFTPoints)
                         spc = self.specObj1.data_spc
             #            spc = self.specProcObj.getSpectra()
                         nchannels = self.specObj1.nChannels
             #            y1=spc[0]
             #            y2=spc[1]
             #            y3=spc[2]
             #            y4=spc[3]
             #            signalList=[y1,y2,y3,y4]
             #            xmin = numpy.min(x)
             #            xmax = numpy.max(x)
                        #Creating Object
                         indexPlot = 1
                         nsubplot = nchannels
                         #nsubplot = 1
                         print "nsubplot:%d"%(nsubplot)
                         winTitle = "mi grafico de Espectrov1"
                         subplotTitle = "subplot-Espectro - No Channel."
                         xlabel = ""
                         ylabel = ""
                         linearObj = LinearPlot(indexPlot,nsubplot,winTitle)
                        #Config SubPlots
                         print "ConfigSubPlots"
                         print "nsubplot:  %d "%nsubplot
                         for subplot in range(nsubplot):
                             indexplot = subplot + 1
                             name=subplot+1
                             print "Channel:  %d"%(name)
                             title = subplotTitle + '%d'%name
                             xmin = numpy.min(x)
                             xmax = numpy.max(x)
                             ymin = numpy.min(spc[subplot])
                             ymax = numpy.max(spc[subplot])
                             linearObj.setup(indexplot, xmin, xmax, ymin, ymax, title, xlabel, ylabel)
                        #Plotting
                         type = "simple"
                         print "Ploteando"
                         print "nsubplot:  %d  "%nsubplot
                         for subplot in range(nsubplot):
                             indexplot = subplot + 1
                             y = spc[subplot,:]
                             linearObj.plot(indexplot, x, y, type)
                         linearObj.refresh()
                         linearObj.show()
             if __name__ == '__main__':
                 TestHeis()
   No newline at end of file

schainpy2/testSchainExp.py +16 -22

             '''
             $Author$
             $Id$
             '''
             import os, sys
             import time, datetime
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
-            from Data.Voltage import Voltage
+            from Data.JROData import Voltage
             from IO.VoltageIO import *
             from Processing.VoltageProcessor import *
             class TestSChain():
                 def __init__(self):
                     self.setValues()
                     self.createObjects()
                     self.testSChain()
                 def setValues(self):
-                    self.path = "/home/dsuarez/RadarData/EW_DRIFTS"
+                    self.path = "/home/roj-idl71/Data/RAWDATA/Meteors"
-                    self.startDate = datetime.date(2012,6,1)
-                    self.endDate = datetime.date(2012,7,30)
-            #        self.path = "/Users/danielangelsuarezmunoz/Data/Imaging_rawdata"
+                    self.startDate = datetime.date(2005,1,1)
-            #        self.startDate = datetime.date(2011,10,4)
+                    self.endDate = datetime.date(2012,7,30)
-            #        self.endDate = datetime.date(2011,10,4)
-                    # Probando los escritos por Signal Chain
-            #        self.path = "/home/dsuarez/RadaData"
-            #        self.startDate = datetime.date(2011,11,28)
-            #        self.endDate = datetime.date(2011,11,30)
                     self.startTime = datetime.time(0,0,0)
                     self.endTime = datetime.time(23,59,59)
-                    self.wrpath = "/home/dsuarez/RadarData"
+                    self.wrpath = "/home/roj-idl71/tmp/results"
                     self.profilesPerBlock = 40
                     self.blocksPerFile = 50
                 def createObjects(self):
                     self.readerObj = VoltageReader()
+                    self.voltProcObj = VoltageProcessor()
+                    self.specProcObj = SpectraProcessor()
                     self.voltObj1 = self.readerObj.setup(
                                                path = self.path,
                                                startDate = self.startDate,
                                                endDate = self.endDate,
                                                startTime = self.startTime,
                                                endTime = self.endTime,
                                                expLabel = '',
                                                online = 0)
-                    self.voltObjProc = VoltageProcessor()
-                    self.voltObj2 = self.voltObjProc.setup(dataInObj = self.voltObj1)
+                    self.voltObj2 = self.voltProcObj.setup(dataInObj = self.voltObj1)
                 def testSChain(self):
                     ini = time.time()
                     while(True):
                         self.readerObj.getData()
-                        self.voltObjProc.init()
+                        self.voltProcObj.init()
+                        self.voltProcObj.integrator(1000, overlapping=True)
             #
-            #            self.voltObjProc.writeData(self.wrpath,self.profilesPerBlock,self.blocksPerFile)
+            #            self.voltProcObj.writeData(self.wrpath,self.profilesPerBlock,self.blocksPerFile)
-                        self.voltObjProc.plotScope(idfigure=1,
+                        self.voltProcObj.plotScope(idfigure=1,
                                                     wintitle='test plot library',
                                                     driver='plplot',
                                                     save=False,
                                                     gpath=None,
                                                     type="power")
                         if self.readerObj.flagNoMoreFiles:
                             break
                         if self.readerObj.flagIsNewBlock:
             #                print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks, datetime.datetime.fromtimestamp(self.readerObj.basicHeaderObj.utc),)
                             print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
                                                               datetime.datetime.utcfromtimestamp(self.readerObj.basicHeaderObj.utc + self.readerObj.basicHeaderObj.miliSecond/1000.0),)
             if __name__ == '__main__':
                 TestSChain()

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