schain-jc Commit - r107:33fbc5472d1b

Changing the Model for the input Objects in Processing package...

Daniel Valdez -

r107:33fbc5472d1b

parent child

Context file:

r107:33fbc5472d1b

Collapse all files

schainpy/Controller/experiment.cfg +4 -14

@@ -1,23 +1,13
1	[Read0]	1	[Read0]
2	id = 0	2	id = 0
3	type = VoltageReader	3	type = VoltageReader
4	setup = str,/Users/jro/Documents/RadarData/~~EW_Drifts~~,datetime,20~~11-11-20~~-0-0-1,datetime,2011-12-31-0-0-1,int,0,str,,str,None,int,0	4	setup = str,/Users/jro/Documents/RadarData/MST_ISR/MST,datetime,2009-01-01-0-0-1,datetime,2009-12-31-0-0-1,int,0,str,,str,None,int,0
5	getData = None,None	5	getData = None,None
6		6
7	[Processing0]	7	[Processing0]
8	id = 1	8	id = 1
9	type = Voltage
10	input = 0
11	setup = None,None
12	init = None,None
13	integrator = int,4,None,None
14	plotData = float,None,float,None,float,None,float,None,str,iq,str,Test Data Voltage 2,int,1
15
16	[Processing1]
17	id = 2
18	type = Spectra	9	type = Spectra
19	input = 1	10	input = 0
20	setup = int,8,None,None	11	setup = int,16,None,None
21	init = None,None	12	init = None,None
22	integrator = int,4,int,3	13	plotData = float,None,float,None,float,None,float,None,str,Test Spectra Data,int,1
23	plotData = float,None,float,None,float,None,float,None,str,Test Spectra Data,int,2

schainpy/Graphics/BaseGraph.py +3 -2

             """
             Created on Feb 7, 2012
             @autor $Author$
             @version $Id$
             """
             import numpy
             import plplot
             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=="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
             def setColormap(colormap="br_green"):
                     cmap1_init(colormap)
             class BaseGraph:
                 """
                 """
                 hasNotRange = True
                 xrange = None
                 yrange = None
                 zrange = None
                 xlabel = None
                 ylabel = None
                 title = None
                 legends = None
                 __name = None
                 __colormap = None
                 __colbox  = None
                 __colleg = None
                 __xpos = None
                 __ypos = None
                 __xopt = None #"bcnst"
                 __yopt = None #"bcnstv"
                 __xlpos = None
                 __ylpos = None
                 __xrangeIsTime = False
                 #Advanced
                 __xg = None
                 __yg = None
                 def __init__(self):
                     """
                     """
                     self.hasNotRange = True
                     self.xrange = None
                     self.yrange = None
                     self.zrange = None
                     self.xlabel = None
                     self.ylabel = None
                     self.title = None
                     self.legends = None
                     self.__name = None
                     self.__colormap = None
                     self.__colbox  = None
                     self.__colleg = None
                     self.__xpos = None
                     self.__ypos = None
                     self.__xopt = None #"bcnst"
                     self.__yopt = None #"bcnstv"
                     self.__xlpos = None
                     self.__ylpos = None
                     self.__xrangeIsTime = False
                     #Advanced
                     self.__xg = None
                     self.__yg = None
                 def setName(self, name):
                     self.__name = name
                 def setScreenPos(self, xpos, ypos):
                     self.__xpos = xpos
                     self.__ypos = ypos
                 def setOpt(self, xopt, yopt):
                     self.__xopt = xopt
                     self.__yopt = yopt
                 def setXAxisAsTime(self):
                     self.__xrangeIsTime = True
                 def setup(self, title=None, xlabel=None, ylabel=None, colormap=None):
                     """
                     """
                     self.title = title
                     self.xlabel = xlabel
                     self.ylabel = ylabel
                     self.__colormap = colormap
                 def plotBox(self, xmin, xmax, ymin, ymax, xopt=None, yopt=None, nolabels=False):
                     """
                     """
                     if self.__xrangeIsTime:
                         plplot.pltimefmt("%H:%M")
                     plplot.plvpor(self.__xpos[0], self.__xpos[1], self.__ypos[0], self.__ypos[1])
                     plplot.plwind(float(xmin),
                                   float(xmax),
                                   float(ymin),
                                   float(ymax)
                                   )
                     if xopt == None: xopt = self.__xopt
                     if yopt == None: yopt = self.__yopt
                     plplot.plbox(xopt, 0.0, 0, yopt, 0.0, 0)
                     if not(nolabels):
                         plplot.pllab(self.xlabel, self.ylabel, self.title)
                 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),
 .,
 .,
                                    float(xmin),
                                    float(xmax),
                                    float(ymin),
                                    float(ymax))
                 def basicXYPlot(self, x, y, xmin=None, xmax=None, ymin=None, ymax=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]
                     plplot.plline(x, y)
                 def basicXYwithErrorPlot(self):
                     pass
                 def basicLineTimePlot(self, x, y, xmin=None, xmax=None, ymin=None, ymax=None, colline=1):
                     if xmin == None: xmin = x[0]
                     if xmax == None: xmax = x[-1]
                     if ymin == None: ymin = y[0]
                     if ymax == None: ymax = y[-1]
                     plplot.plcol0(colline)
                     plplot.plline(x, y)
                     plplot.plcol0(1)
                 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)
                                    )
                 def __getBoxpltr(self, x, y, deltax=None, deltay=None):
                     if not(len(x)>1 and len(y)>1):
                         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
                 def advPcolorPlot(self, data, x, y, zmin=0., zmax=0.):
                     """
                     """
                     if self.__xg == None and self.__yg == None:
                         self.__getBoxpltr(x, y)
                     plplot.plimagefr(data, x[0], x[-1], y[0], y[-1], 0., 0., zmin, zmax, plplot.pltr2, self.__xg, self.__yg)
             class LinearPlot:
                 linearGraphObj = BaseGraph()
                 __szchar = 1.0
                 __xrange = None
                 __yrange = None
                 __subpage = 0
                 m_BaseGraph= BaseGraph()
                 def __init__(self):
                     key = "linearplot"
                     self.linearGraphObj = BaseGraph()
                     self.linearGraphObj.setName(key)
                     self.__subpage = 0
                 def __iniSubpage(self):
                     if plplot.plgdev() == '':
                         raise ValueError, "Plot device has not been initialize"
                     plplot.pladv(self.__subpage)
                     plplot.plschr(0.0, self.__szchar)
                     setColormap()
                 def setScreenPos(self, width='small'):
                     if width == 'small':
                         xi = 0.12; yi = 0.14; xw = 0.78; yw = 0.80
                     if width == 'medium':
                         xi = 0.07; yi = 0.10; xw = 0.90; yw = 0.60
                     xf = xi + xw
                     yf = yi + yw
                     self.linearGraphObj.setScreenPos([xi, xf], [yi, yf])
                 def setup(self, subpage, title="", xlabel="", ylabel="", XAxisAsTime=False):
                     """
                     """
                     self.linearGraphObj.setOpt("bcnts","bcntsv")
                     self.linearGraphObj.setup(title,
                                            xlabel,
                                            ylabel
                                            )
                     self.setScreenPos(width='medium')
                     if XAxisAsTime:
                         self.linearGraphObj.setXAxisAsTime()
                     self.__subpage = subpage
             #    def setRanges(self, xrange, yrange, zrange):
             #
             #        self.linearGraphObj.setRanges(xrange, yrange, zrange)
                 def plotData(self, x, y=None, xmin=None, xmax=None, ymin=None, ymax=None, colline=1):
                     """
                     Inputs:
                         x    :    Numpy array of dimension 1
                         y    :    Numpy array of dimension 1
                     """
                     try:
                         nX = numpy.shape(x)
                     except:
                         raise ValueError, "x is not a numpy array"
                     if y == None: y = numpy.arange(nX)
                     if xmin == None: xmin = x[0]
                     if xmax == None: xmax = x[-1]
                     if ymin == None: ymin = y[0]
                     if ymax == None: ymax = y[-1]
                     self.__iniSubpage()
                     self.linearGraphObj.plotBox(xmin, xmax, ymin, ymax)
                     self.linearGraphObj.basicLineTimePlot(x, y, xmin, xmax, ymin, ymax, colline)
                 def plotComplexData(self, x, y, xmin=None, xmax=None, ymin=None, ymax=None, colline=1, type='power'):
                     """
                     Inputs:
                         x    :    Numpy array of dimension 1
                         y    :    Complex numpy array of dimension 1
                     """
                     try:
                         nX = numpy.shape(x)
                     except:
                         raise ValueError, "x is not a numpy array"
                     try:
                         nY = numpy.shape(y)
                     except:
                         raise ValueError, "y is not a numpy array"
                     if xmin == None: xmin = x[0]
                     if xmax == None: xmax = x[-1]
                     if ymin == None: ymin = y[0]
                     if ymax == None: ymax = y[-1]
                     self.__iniSubpage()
                     self.linearGraphObj.plotBox(xmin, xmax, ymin, ymax)
                     if type.lower() == 'power':
                         self.linearGraphObj.basicLineTimePlot(x, abs(y), xmin, xmax, ymin, ymax, colline)
                     if type.lower() == 'iq':
                         self.linearGraphObj.basicLineTimePlot(x, y.real, xmin, xmax, ymin, ymax, colline)
                         self.linearGraphObj.basicLineTimePlot(x, y.imag, xmin, xmax, ymin, ymax, colline+1)
             class ColorPlot:
                 colorGraphObj = BaseGraph()
                 graphObjDict = {}
                 __subpage = 0
                 __showColorbar = False
                 __showPowerProfile = True
                 __szchar = 0.65
                 __xrange = None
                 __yrange = None
                 __zrange = None
                 m_BaseGraph= BaseGraph()
                 def __init__(self):
                     self.graphObjDict = {}
                     self.__subpage = 0
                     self.__showColorbar = False
                     self.__showPowerProfile = True
                     self.__szchar = 0.65
                     self.__xrange = None
                     self.__yrange = None
                     self.__zrange = None
                     key = "colorplot"
                     self.colorGraphObj = BaseGraph()
                     self.colorGraphObj.setName(key)
                 def setup(self, subpage, title="", xlabel="Frequency", ylabel="Range", colormap="br_green", showColorbar=False, showPowerProfile=False, XAxisAsTime=False):
                     """
                     """
                     self.colorGraphObj.setOpt("bcnts","bcntsv")
                     self.colorGraphObj.setup(title,
                                            xlabel,
                                            ylabel
                                            )
                     self.__subpage = subpage
                     self.__colormap = colormap
                     self.__showColorbar = showColorbar
                     self.__showPowerProfile = showPowerProfile
                     if showColorbar:
                         key = "colorbar"
                         cmapObj = BaseGraph()
                         cmapObj.setName(key)
                         cmapObj.setOpt("bc","bcmtv")
                         cmapObj.setup(title="dBs",
                                       xlabel="",
                                       ylabel="",
                                       colormap=colormap)
                         self.graphObjDict[key] = cmapObj
                     if showPowerProfile:
                         key = "powerprof"
                         powObj = BaseGraph()
                         powObj.setName(key)
                         powObj.setOpt("bcntg","bc")
                         powObj.setup(title="Power Profile",
                                      xlabel="dB",
                                      ylabel="")
                         self.graphObjDict[key] = powObj
                     self.setScreenPos(width='small')
                     if XAxisAsTime:
                         self.colorGraphObj.setXAxisAsTime()
                 def __iniSubpage(self):
                     if plplot.plgdev() == '':
                         raise ValueError, "Plot device has not been initialize"
                     plplot.pladv(self.__subpage)
                     plplot.plschr(0.0, self.__szchar)
                     setColormap(self.__colormap)
                 def setScreenPos(self, width='small'):
                     if width == 'small':
                         xi = 0.13; yi = 0.12; xw = 0.86; yw = 0.70; xcmapw = 0.04; xpoww = 0.25; deltaxcmap = 0.02; deltaxpow = 0.06
                     if width == 'medium':
                         xi = 0.07; yi = 0.10; xw = 0.90; yw = 0.60; xcmapw = 0.04; xpoww = 0.24; deltaxcmap = 0.02; deltaxpow = 0.06
                     if self.__showColorbar:
                         xw -= xcmapw + deltaxcmap
                     if self.__showPowerProfile:
                         xw -= xpoww + deltaxpow
                     xf = xi + xw
                     yf = yi + yw
                     xcmapf = xf
                     self.colorGraphObj.setScreenPos([xi, xf], [yi, yf])
                     if self.__showColorbar:
                         xcmapi = xf + deltaxcmap
                         xcmapf = xcmapi + xcmapw
                         key = "colorbar"
                         cmapObj = self.graphObjDict[key]
                         cmapObj.setScreenPos([xcmapi, xcmapf], [yi, yf])
                     if self.__showPowerProfile:
                         xpowi = xcmapf + deltaxpow
                         xpowf = xpowi + xpoww
                         key = "powerprof"
                         powObj = self.graphObjDict[key]
                         powObj.setScreenPos([xpowi, xpowf], [yi, yf])
-                def plotData(self, data, x=None, y=None, xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None):
+                def plotData(self, data, x=None, y=None, xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None, title = ''):
                     """
                     Inputs:
                         x    :    Numpy array of dimension 1
                         y    :    Numpy array of dimension 1
                     """
                     try:
                         nX, nY = numpy.shape(data)
                     except:
                         raise ValueError, "data is not a numpy array"
                     if x == None: x = numpy.arange(nX)
                     if y == None: y = numpy.arange(nY)
                     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.plschr(0.0, self.__szchar)
                     self.__iniSubpage()
+                    self.colorGraphObj.title =  title
                     self.colorGraphObj.plotBox(xmin, xmax, ymin, ymax)
                     self.colorGraphObj.basicPcolorPlot(data, x, y, xmin, xmax, ymin, ymax, zmin, zmax)
                     if self.__showColorbar:
                         key = "colorbar"
                         cmapObj = self.graphObjDict[key]
                         plplot.plschr(0.0, self.__szchar-0.05)
                         cmapObj.plotBox(0., 1., zmin, zmax)
                         cmapObj.colorbarPlot(0., 1., zmin, zmax)
                     if self.__showPowerProfile:
-                        power = numpy.max(data, axis=0)
+                        power = numpy.average(data, axis=0)
                         step = (ymax - ymin)/(nY-1)
                         heis = numpy.arange(ymin, ymax + step, step)
                         key = "powerprof"
                         powObj = self.graphObjDict[key]
                         plplot.pllsty(2)
                         plplot.plschr(0.0, self.__szchar-0.05)
                         powObj.plotBox(zmin, zmax, ymin, ymax, nolabels=True)
                         plplot.pllsty(1)
                         plplot.plschr(0.0, self.__szchar)
                         powObj.plotBox(zmin, zmax, ymin, ymax, xopt='bc', yopt='bc')
                         plplot.plcol0(9)
                         powObj.basicXYPlot(power, heis)
                         plplot.plcol0(1)
             class ColorPlotX:
                 graphObjDict = {}
                 showColorbar = False
                 showPowerProfile = True
                 __szchar = 0.7
                 __xrange = None
                 __yrange = None
                 __zrange = None
                 colorGraphObj = BaseGraph()
                 def __init__(self):
                     key = "colorplot"
                     self.colorGraphObj.setName(key)
                     self.__subpage = 0
                     self.graphObjDict[key] = self.colorGraphObj
                 def __iniSubpage(self):
                     if plplot.plgdev() == '':
                         raise ValueError, "Plot device has not been initialize"
                     plplot.pladv(self.__subpage)
                     plplot.plschr(0.0, self.__szchar)
                     setColormap(self.__colormap)
                 def setScreenPos(self, xi = 0.12, yi = 0.14, xw = 0.78, yw = 0.80, xcmapw = 0.05, xpoww = 0.24, deltaxcmap = 0.02, deltaxpow = 0.06):
                     if self.showColorbar:
                         xw -= xcmapw + deltaxcmap
                     if self.showPowerProfile:
                         xw -= xpoww + deltaxpow
                     xf = xi + xw
                     yf = yi + yw
                     xcmapf = xf
                     self.colorGraphObj.setScreenPos([xi, xf], [yi, yf])
                     if self.showColorbar:
                         xcmapi = xf + deltaxcmap
                         xcmapf = xcmapi + xcmapw
                         key = "colorbar"
                         cmapObj = self.graphObjDict[key]
                         cmapObj.setScreenPos([xcmapi, xcmapf], [yi, yf])
                     if self.showPowerProfile:
                         xpowi = xcmapf + deltaxpow
                         xpowf = xpowi + xpoww
                         key = "powerprof"
                         powObj = self.graphObjDict[key]
                         powObj.setScreenPos([xpowi, xpowf], [yi, yf])
                 def setRanges(self, xrange, yrange, zrange):
                     self.colorGraphObj.setRanges(xrange, yrange, zrange)
                     keyList = self.graphObjDict.keys()
                     key = "colorbar"
                     if key in keyList:
                         cmapObj = self.graphObjDict[key]
                         cmapObj.setRanges([0., 1.], zrange)
                     key = "powerprof"
                     if key in keyList:
                         powObj = self.graphObjDict[key]
                         powObj.setRanges(zrange, yrange)
                 def setup(self, subpage, title="", xlabel="", ylabel="", colormap="jet", showColorbar=False, showPowerProfile=False, XAxisAsTime=False):
                     """
                     """
                     self.colorGraphObj.setSubpage(subpage)
                     self.colorGraphObj.setSzchar(self.__szchar)
                     self.colorGraphObj.setOpt("bcnts","bcntsv")
                     self.colorGraphObj.setup(title,
                                   xlabel,
                                   ylabel,
                                   colormap)
                     if showColorbar:
                         key = "colorbar"
                         cmapObj = BaseGraph()
                         cmapObj.setName(key)
                         cmapObj.setSubpage(subpage)
                         cmapObj.setSzchar(self.__szchar)
                         cmapObj.setOpt("bc","bcmt")
                         cmapObj.setup(title="dBs",
                                       xlabel="",
                                       ylabel="",
                                       colormap=colormap)
                         self.graphObjDict[key] = cmapObj
                     if showPowerProfile:
                         key = "powerprof"
                         powObj = BaseGraph()
                         powObj.setName(key)
                         powObj.setSubpage(subpage)
                         powObj.setSzchar(self.__szchar)
                         plplot.pllsty(2)
                         powObj.setOpt("bcntg","bc")
                         plplot.pllsty(1)
                         powObj.setup(title="Power Profile",
                                      xlabel="dBs",
                                      ylabel="")
                         self.graphObjDict[key] = powObj
                     self.showColorbar = showColorbar
                     self.showPowerProfile = showPowerProfile
                     self.setScreenPos()
                     if XAxisAsTime:
                         self.colorGraphObj.setXAxisAsTime()
                     #self.setScreenPos(xi = 0.05, yi = 0.18, xw = 0.92, yw = 0.74, xcmapw = 0.015, xpoww = 0.14, deltaxcmap = 0.01, deltaxpow = 0.02)
                 def plotData(self, data, x=None, y=None, xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None):
                     """
                     """
                     try:
                         nX, nY = numpy.shape(data)
                     except:
                         raise ValueError, "data is not a numpy array"
                     if x == None: x = numpy.arange(nX)
                     if y == None: y = numpy.arange(nY)
                     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)
                     if self.colorGraphObj.hasNotRange:
                         self.setRanges([xmin, xmax], [ymin,ymax], [zmin,zmax])
                     self.colorGraphObj.initSubpage()
                     self.colorGraphObj.basicPcolorPlot(data, x, y, xmin, xmax, ymin, ymax, self.colorGraphObj.zrange[0], self.colorGraphObj.zrange[1])
                     if self.showColorbar:
                         key = "colorbar"
                         cmapObj = self.graphObjDict[key]
                         cmapObj.colorbarPlot()
                     if self.showPowerProfile:
                         power = numpy.average(data, axis=1)
                         step = (ymax - ymin)/(nY-1)
                         heis = numpy.arange(ymin, ymax + step, step)
                         key = "powerprof"
                         powObj = self.graphObjDict[key]
                         powObj.basicXYPlot(power, heis)
             if __name__ == '__main__':
                 import numpy
                 plplot.plsetopt("geometry", "%dx%d" %(350*2, 300*2))
                 plplot.plsdev("xwin")
                 plplot.plscolbg(255,255,255)
                 plplot.plscol0(1,0,0,0)
                 plplot.plspause(False)
                 plplot.plinit()
                 plplot.plssub(2, 2)
                 nx = 64
                 ny = 100
                 data = numpy.random.uniform(-50,50,(nx,ny))
                 baseObj = ColorPlot()
                 specObj = ColorPlot()
                 baseObj1 = ColorPlot()
                 specObj1 = ColorPlot()
                 baseObj.setup(1, "Spectrum", "Frequency", "Range", "br_green", True, True)
                 specObj.setup(2, "Spectrum", "Frequency", "Range", "br_green", False, True)
                 baseObj1.setup(3, "Spectrum", "Frequency", "Range", "br_green", False, True)
                 specObj1.setup(4, "Spectrum", "Frequency", "Range", "br_green", False, True)
                 data = numpy.random.uniform(-50,50,(nx,ny))
                 plplot.plbop()
                 baseObj.plotData(data)
                 specObj.plotData(data)
                 baseObj1.plotData(data)
                 specObj1.plotData(data)
                 plplot.plflush()
                 plplot.plspause(1)
                 plplot.plend()
                 exit(0)

schainpy/Graphics/SpectraPlot.py +3 -2

             '''
             Created on Feb 7, 2012
             @author $Author$
             @version $Id$
             '''
             import os, sys
             import numpy
             import datetime
             import plplot
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from Graphics.BaseGraph import *
             from Model.Spectra import Spectra
             class Spectrum:
                 __isPlotConfig = False
                 __isPlotIni = False
                 __xrange = None
                 __yrange = None
                 nGraphs = 0
                 indexPlot = None
                 graphObjList = []
                 spectraObj = Spectra
                 colorGraphObj = ColorPlot()
                 m_Spectra= Spectra()
                 m_ColorPlot= ColorPlot()
                 def __init__(self, Spectra, index=0):
                     """
                     Inputs:
                         type:   "power" ->> Potencia
                                 "iq"    ->> Real + Imaginario
                     """
                     self.__isPlotConfig = False
                     self.__isPlotIni = False
                     self.__xrange = None
                     self.__yrange = None
                     self.nGraphs = 0
                     self.indexPlot = index
                     self.graphObjList = []
                     self.spectraObj = Spectra
                 def __addGraph(self, subpage, title="", xlabel="", ylabel="", showColorbar=False, showPowerProfile=True, XAxisAsTime=False):
                     graphObj = ColorPlot()
                     graphObj.setup(subpage,
                                    title,
                                    xlabel,
                                    ylabel,
                                    showColorbar=showColorbar,
                                    showPowerProfile=showPowerProfile,
                                    XAxisAsTime=XAxisAsTime)
                     self.graphObjList.append(graphObj)
                 def setup(self, titleList=None, xlabelList=None, ylabelList=None, showColorbar=False, showPowerProfile=True, XAxisAsTime=False):
                     nChan = int(self.spectraObj.m_SystemHeader.numChannels)
                     channels = range(nChan)
                     myXlabel = "Radial Velocity (m/s)"
                     myYlabel = "Range (km)"
                     for i in channels:
                         if titleList != None:
                             myTitle = titleList[i]
                             myXlabel = xlabelList[i]
                             myYlabel = ylabelList[i]
             #            if self.spectraObj.m_NoiseObj != None:
             #                noise = '%4.2fdB' %(self.spectraObj.m_NoiseObj[i])
             #            else:
                         noise = '--'
                         myTitle = "Channel: %d - Noise: %s" %(i, noise)
                         self.__addGraph(i+1,
                                         title=myTitle,
                                         xlabel=myXlabel,
                                         ylabel=myYlabel,
                                         showColorbar=showColorbar,
                                         showPowerProfile=showPowerProfile,
                                         XAxisAsTime=XAxisAsTime)
                     self.nGraphs = nChan
                     self.__isPlotConfig = True
                 def iniPlot(self, winTitle=""):
                     nx = int(numpy.sqrt(self.nGraphs)+1)
                     #ny = int(self.nGraphs/nx)
                     plplot.plsstrm(self.indexPlot)
                     plplot.plparseopts([winTitle], plplot.PL_PARSE_FULL)
                     plplot.plsetopt("geometry", "%dx%d" %(300*nx, 240*nx))
                     plplot.plsdev("xwin")
                     plplot.plscolbg(255,255,255)
                     plplot.plscol0(1,0,0,0)
                     plplot.plinit()
                     plplot.plspause(False)
                     plplot.pladv(0)
                     plplot.plssub(nx, nx)
                     self.__nx = nx
                     self.__ny = nx
                     self.__isPlotIni = True
                 def plotData(self, xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None, titleList=None, xlabelList=None, ylabelList=None, showColorbar=False, showPowerProfile=True, XAxisAsTime=False, winTitle="Spectra"):
                     if not(self.__isPlotConfig):
                         self.setup(titleList,
                                    xlabelList,
                                    ylabelList,
                                    showColorbar,
                                    showPowerProfile,
                                    XAxisAsTime)
                     if not(self.__isPlotIni):
                         self.iniPlot(winTitle)
                     plplot.plsstrm(self.indexPlot)
                     data = 10.*numpy.log10(self.spectraObj.data_spc)
+                    noise = 10.*numpy.log10(self.spectraObj.noise)
                     #data.shape = Channels x Heights x Profiles
             #        data = numpy.transpose( data, (0,2,1) )
                     #data.shape = Channels x Profiles x Heights
                     nChan, nX, nY = numpy.shape(data)
                     x = numpy.arange(nX)
                     y = self.spectraObj.heightList
                     thisDatetime = datetime.datetime.fromtimestamp(self.spectraObj.m_BasicHeader.utc)
                     txtDate = "Self Spectra - Date: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     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(abs(data))
                     if zmax == None: zmax = numpy.nanmax(abs(data))
                     plplot.plbop()
                     plplot.plssub(self.__nx, self.__ny)
                     for i in range(self.nGraphs):
                         self.graphObjList[i].plotData(data[i,:,:],
                                                       x,
                                                       y,
                                                       xmin=xmin,
                                                       xmax=xmax,
                                                       ymin=ymin,
                                                       ymax=ymax,
                                                       zmin=zmin,
-                                                      zmax=zmax)
+                                                      zmax=zmax,
+                                                      title = "Channel: %d - Noise: %.2f" %(i, noise[i]))
                     plplot.plssub(1,0)
                     plplot.pladv(0)
                     plplot.plvpor(0., 1., 0., 1.)
                     plplot.plmtex("t",-1., 0.5, 0.5, txtDate)
                     plplot.plflush()
                     plplot.pleop()
                 def end(self):
                     plplot.plend()
             if __name__ == '__main__':
                 pass

schainpy/IO/JRODataIO.py +144 -128

             '''
             Created on 23/01/2012
             @author $Author$
             @version $Id$
             @version $Id$
             '''
             import os, sys
             import glob
             import time
             import numpy
             import fnmatch
             import time, datetime
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from Model.JROHeader import *
             from Model.JROData import JROData
             def checkForRealPath(path, year, doy, set, ext):
                 """
                 Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path,
                 Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
                 el path exacto de un determinado file.
                 Example    :
                     nombre correcto del file es  .../.../D2009307/P2009307367.ext
                     Entonces la funcion prueba con las siguientes combinaciones
                         .../.../x2009307/y2009307367.ext
                         .../.../x2009307/Y2009307367.ext
                         .../.../X2009307/y2009307367.ext
                         .../.../X2009307/Y2009307367.ext
                     siendo para este caso, la ultima combinacion de letras, identica al file buscado
                 Return:
                     Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file
                     caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas
                     para el filename
                 """
                 filepath = None
                 find_flag = False
                 filename = None
                 if ext.lower() == ".r": #voltage
                     header1 = "dD"
                     header2 = "dD"
                 elif ext.lower() == ".pdata": #spectra
                     header1 = "dD"
                     header2 = "pP"
                 else:
                     return None, filename
                 for dir in header1: #barrido por las dos combinaciones posibles de "D"
                     for fil in header2: #barrido por las dos combinaciones posibles de "D"
                         doypath = "%s%04d%03d" % ( dir, year, doy ) #formo el nombre del directorio xYYYYDDD (x=d o x=D)
                         filename = "%s%04d%03d%03d%s" % ( fil, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext
                         filepath = os.path.join( path, doypath, filename ) #formo el path completo
                         if os.path.exists( filepath ): #verifico que exista
                             find_flag = True
                             break
                     if find_flag:
                         break
                 if not(find_flag):
                     return None, filename
                 return filepath, filename
             def isNumber(str):
                 """
                 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
                 Excepciones:
                     Si un determinado string no puede ser convertido a numero
                 Input:
                     str, string al cual se le analiza para determinar si convertible a un numero o no
                 Return:
                     True    :    si el string es uno numerico
                     False   :    no es un string numerico
                 """
                 try:
                     float( str )
                     return True
                 except:
                     return False
             def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
                 """
                 Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
                 Inputs:
                     filename            :    nombre completo del archivo de datos en formato Jicamarca (.r)
                     startUTSeconds      :    fecha inicial del rango seleccionado. La fecha esta dada en
                                              segundos contados desde 01/01/1970.
                     endUTSeconds        :    fecha final del rango seleccionado. La fecha esta dada en
                                              segundos contados desde 01/01/1970.
                 Return:
                     Boolean    :    Retorna True si el archivo de datos contiene datos en el rango de
                                     fecha especificado, de lo contrario retorna False.
                 Excepciones:
                     Si el archivo no existe o no puede ser abierto
                     Si la cabecera no puede ser leida.
                 """
                 m_BasicHeader = BasicHeader()
                 try:
                     fp = open(filename,'rb')
                 except:
                     raise IOError, "The file %s can't be opened" %(filename)
                 sts = m_BasicHeader.read(fp)
                 fp.close()
                 if not(sts):
                     print "Skipping the file %s because it has not a valid header" %(filename)
                     return 0
                 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds > m_BasicHeader.utc)):
                     return 0
                 return 1
             def getlastFileFromPath(path, ext):
                 """
                 Depura el fileList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
                 al final de la depuracion devuelve el ultimo file de la lista que quedo.
                 Input:
                     fileList    :    lista conteniendo todos los files (sin path) que componen una determinada carpeta
                     ext         :    extension de los files contenidos en una carpeta
                 Return:
                     El ultimo file de una determinada carpeta, no se considera el path.
                 """
                 validFilelist = []
                 fileList = os.listdir(path)
                 # 0 1234 567 89A BCDE
                 # H YYYY DDD SSS .ext
                 for file in fileList:
                     try:
                         year = int(file[1:5])
                         doy  = int(file[5:8])
                         if (os.path.splitext(file)[-1].upper() != ext.upper()) : continue
                     except:
                         continue
                     validFilelist.append(file)
                 if validFilelist:
                     validFilelist = sorted( validFilelist, key=str.lower )
                     return validFilelist[-1]
                 return None
             class JRODataIO:
                 #speed of light
                 c = 3E8
                 m_BasicHeader = BasicHeader()
                 m_SystemHeader = SystemHeader()
                 m_RadarControllerHeader = RadarControllerHeader()
                 m_ProcessingHeader = ProcessingHeader()
-                m_DataObj = None
+                dataOutObj = None
                 online = 0
                 fp = None
                 dataType = None
                 fileSizeByHeader = None
                 filenameList = []
                 filename = None
                 fileSize = None
                 firstHeaderSize = 0
                 basicHeaderSize = 24
                 nTotalBlocks = 0
                 ippSeconds = 0
                 blocksize = 0
                 set = 0
                 ext = None
                 path = None
                 maxTimeStep = 30
                 delay  = 3   #seconds
                 nTries  = 3  #quantity tries
                 nFiles = 3   #number of files for searching
                 flagNoMoreFiles = 0
                 flagIsNewFile = 1
                 flagResetProcessing = 0
                 flagIsNewBlock = 0
                 def __init__(self):
                     pass
             class JRODataReader(JRODataIO):
                 """
                 Esta clase es usada como la clase padre de las clases VoltageReader y SpectraReader.
                 Contiene todos lo metodos necesarios para leer datos desde archivos en formato
                 jicamarca o pdata (.r o .pdata). La lectura de los datos siempre se realiza por bloques. Los datos
                 leidos son array de 3 dimensiones:
                                   Para Voltajes  -  perfiles * alturas * canales
                                   Para Spectra   -  paresCanalesIguales    * alturas * perfiles  (Self Spectra)
                                                     paresCanalesDiferentes * alturas * perfiles  (Cross Spectra)
                                                     canales * alturas                            (DC Channels)
                 y son almacenados en su buffer respectivo.
                 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
                 RadarControllerHeader y DataObj. Los tres primeros se usan para almacenar informacion de la
                 cabecera de datos (metadata), y el cuarto (DataObj) para obtener y almacenar los datos desde
                 el buffer de datos cada vez que se ejecute el metodo "getData".
                 """
                 nReadBlocks = 0
-                def __init__(self, m_DataObj=None):
+                def __init__(self, dataOutObj=None):
                     raise ValueError, "This class can't be instanced"
                 def hasNotDataInBuffer(self):
                     raise ValueError, "Not implemented"
                 def getBlockDimension(self):
                     raise ValueError, "No implemented"
                 def readBlock(self):
                     self.nTotalBlocks += 1
                     self.nReadBlocks += 1
                     raise ValueError, "This method has not been implemented"
                 def getData( self ):
                     raise ValueError, "This method has not been implemented"
+                def createObjByDefault(self):
+                    """
+                    Los objetos creados por defecto por cada clase (Voltaje o Espectro) difieren en el tipo
+                    raise ValueError, "This method has not been implemented
+                    """
+                    raise ValueError, "This method has not been implemented"
+                def setup(self, dataOutObj=None, path=None, startDateTime=None, endDateTime=None, set=0, expLabel = "", ext = None, online = 0):
+                    """
+                    setup configura los parametros de lectura de la clase DataReader.
+                    Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
+                    que coincidan con los parametros especificados; esta lista de archivos son almacenados en
+                    self.filenameList.
+                    Input:
+                        path                :    Directorios donde se ubican los datos a leer. Dentro de este
+                                                 directorio deberia de estar subdirectorios de la forma:
+                                                 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
+                        startDateTime       :    Fecha inicial. Rechaza todos los archivos donde
+                                                 file end time < startDatetime (obejto datetime.datetime)
+                        endDateTime         :    Fecha final. Si no es None, rechaza todos los archivos donde
+                                                 file end time < startDatetime (obejto datetime.datetime)
+                        set                 :    Set del primer archivo a leer. Por defecto None
+                        expLabel            :    Nombre del subdirectorio de datos.  Por defecto ""
+                        ext                 :    Extension de los archivos a leer. Por defecto .r
+                        online              :    Si es == a 0 entonces busca files que cumplan con las condiciones dadas
+                    Return:
+:    Si no encuentra files que cumplan con las condiciones dadas
+:    Si encuentra files que cumplan con las condiciones dadas
+                    Affected:
+                        self.startUTCSeconds
+                        self.endUTCSeconds
+                        self.startYear
+                        self.endYear
+                        self.startDoy
+                        self.endDoy
+                        self.pathList
+                        self.filenameList
+                        self.online
+                    """
+                    if path == None:
+                        raise ValueError, "The path is not valid"
+                    if ext == None:
+                        ext = self.ext
+                    if dataOutObj == None:
+                        dataOutObj = self.createObjByDefault()
+                    self.dataOutObj = dataOutObj
+                    if online:
+                        print "Searching files ..."
+                        doypath, file, year, doy, set = self.__searchFilesOnLine(path, startDateTime, endDateTime, expLabel, ext)
+                        if not(doypath):
+                            for nTries in range( self.nTries ):
+                                print '\tWaiting %0.2f sec for valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
+                                time.sleep( self.delay )
+                                doypath, file, year, doy, set = self.__searchFilesOnLine(path, startDateTime, endDateTime, expLabel, ext)
+                                if doypath:
+                                    break
+                        if not(doypath):
+                            print "There 'isn't valied files in %s" % path
+                            return None
+                        self.year = year
+                        self.doy  = doy
+                        self.set  = set - 1
+                        self.path = path
+                    else: # offline
+                        pathList, filenameList = self.__searchFilesOffLine(path, startDateTime, endDateTime, set, expLabel, ext)
+                        if not(pathList):
+                            print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
+                            return None
+                        self.fileIndex = -1
+                        self.pathList = pathList
+                        self.filenameList = filenameList
+                    self.online = online
+                    self.ext = ext
+                    ext = ext.lower()
+                    if not( self.setNextFile() ):
+                        if (startDateTime != None) and (endDateTime != None):
+                            print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
+                        elif startDateTime != None:
+                            print "No files in : %s" % startDateTime.ctime()
+                        else:
+                            print "No files"
+                        return None
+                    if startDateTime != None:
+                        self.startUTCSeconds = time.mktime(startDateTime.timetuple())
+                        self.startYear = startDateTime.timetuple().tm_year
+                        self.startDoy = startDateTime.timetuple().tm_yday
+                    if endDateTime != None:
+                        self.endUTCSeconds = time.mktime(endDateTime.timetuple())
+                        self.endYear = endDateTime.timetuple().tm_year
+                        self.endDoy = endDateTime.timetuple().tm_yday
+                    #call fillHeaderValues() - to Data Object
+                    self.updateDataHeader()
+                    return self.dataOutObj
                 def __rdSystemHeader(self, fp=None):
                     if fp == None:
                         fp = self.fp
                     self.m_SystemHeader.read(fp)
                 def __rdRadarControllerHeader(self, fp=None):
                     if fp == None:
                         fp = self.fp
                     self.m_RadarControllerHeader.read(fp)
                 def __rdProcessingHeader(self, fp=None):
                     if fp == None:
                         fp = self.fp
                     self.m_ProcessingHeader.read(fp)
                 def __rdBasicHeader(self, fp=None):
                     if fp == None:
                         fp = self.fp
                     self.m_BasicHeader.read(fp)
                 def __readFirstHeader(self):
                     """
                     Lectura del First Header, es decir el Basic Header y el Long Header
                     Affected:
                         self.m_BasicHeader
                         self.m_SystemHeader
                         self.m_RadarControllerHeader
                         self.m_ProcessingHeader
                         self.firstHeaderSize
                         self.dataType
                         self.fileSizeByHeader
                         self.ippSeconds
                     Return:
                         None
                     """
                     self.__rdBasicHeader()
                     self.__rdSystemHeader()
                     self.__rdRadarControllerHeader()
                     self.__rdProcessingHeader()
                     self.firstHeaderSize = self.m_BasicHeader.size
                     datatype = int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
                     if datatype == 0:
                         datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
                     elif datatype == 1:
                         datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])
                     elif datatype == 2:
                         datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])
                     elif datatype == 3:
                         datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])
                     elif datatype == 4:
                         datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])
                     elif datatype == 5:
                         datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])
                     else:
                         raise ValueError, 'Data type was not defined'
                     self.dataType = datatype_str
                     self.ippSeconds = 2 * 1000 * self.m_RadarControllerHeader.ipp / self.c
                     self.fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
+                    self.dataOutObj.channelList = numpy.arange(self.m_SystemHeader.numChannels)
+                    self.dataOutObj.channelIndexList = numpy.arange(self.m_SystemHeader.numChannels)
                     self.getBlockDimension()
                 def __setNewBlock(self):
                     """
                     Lee el Basic Header y posiciona le file pointer en la posicion inicial del bloque a leer
                     Affected:
                         self.m_BasicHeader
                         self.flagNoContinuousBlock
                         self.ns
                     Return:
 :    Si el file no tiene un Basic Header que pueda ser leido
 :    Si se pudo leer el Basic Header
                     """
                     if self.fp == None:
                         return 0
                     if self.flagIsNewFile:
                         return 1
                     self.lastUTTime = self.m_BasicHeader.utc
                     currentSize = self.fileSize - self.fp.tell()
                     neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
                     #If there is enough data setting new data block
                     if ( currentSize >= neededSize ):
                         self.__rdBasicHeader()
                         return 1
                     #si es OnLine y ademas aun no se han leido un bloque completo entonces se espera por uno valido
                     if self.online and (self.nReadBlocks < self.m_ProcessingHeader.dataBlocksPerFile):
                         fpointer = self.fp.tell()
                         for nTries in range( self.nTries ):
                             #self.fp.close()
                             print "\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
                             time.sleep( self.delay )
                             #self.fp = open( self.filename, 'rb' )
                             #self.fp.seek( fpointer )
                             self.fileSize = os.path.getsize( self.filename )
                             currentSize = self.fileSize - fpointer
                             if ( currentSize >= neededSize ):
                                 self.__rdBasicHeader()
                                 return 1
                     #Setting new file
                     if not( self.setNextFile() ):
                         return 0
                     deltaTime = self.m_BasicHeader.utc - self.lastUTTime # check this
                     self.flagResetProcessing = 0
                     if deltaTime > self.maxTimeStep:
                         self.flagResetProcessing = 1
                     return 1
                 def readNextBlock(self):
                     """
                     Establece un nuevo bloque de datos a leer y los lee, si es que no existiese
                     mas bloques disponibles en el archivo actual salta al siguiente.
                     Affected:
                         self.lastUTTime
                     Return: None
                     """
                     if not(self.__setNewBlock()):
                         return 0
                     if not(self.readBlock()):
                         return 0
                     return 1
                 def __setNextFileOnline(self):
                     """
                     Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
                     no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
                     siguientes.
                     Affected:
                         self.flagIsNewFile
                         self.filename
                         self.fileSize
                         self.fp
                         self.set
                         self.flagNoMoreFiles
                     Return:
 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
 : si el file fue abierto con exito y esta listo a ser leido
                     Excepciones:
                         Si un determinado file no puede ser abierto
                     """
                     nFiles = 0
                     fileOk_flag = False
                     firstTime_flag = True
                     self.set += 1
                     #busca el 1er file disponible
                     file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )
                     if file:
                         if self.__verifyFile(file, False):
                             fileOk_flag = True
                     #si no encuentra un file entonces espera y vuelve a buscar
                     if not(fileOk_flag):
                         for nFiles in range(self.nFiles+1): #busco en los siguientes self.nFiles+1 files posibles
                             if firstTime_flag: #si es la 1era vez entonces hace el for self.nTries veces
                                 tries = self.nTries
                             else:
                                 tries = 1 #si no es la 1era vez entonces solo lo hace una vez
                             for nTries in range( tries ):
                                 if firstTime_flag:
                                     print "\tWaiting %0.2f sec for new \"%s\" file, try %03d ..." % ( self.delay, filename, nTries+1 )
                                     time.sleep( self.delay )
                                 else:
                                     print "\tSearching next \"%s%04d%03d%03d%s\" file ..." % (self.optchar, self.year, self.doy, self.set, self.ext)
                                 file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )
                                 if file:
                                     if self.__verifyFile(file):
                                         fileOk_flag = True
                                         break
                             if fileOk_flag:
                                 break
                             firstTime_flag = False
                             print "\tSkipping the file \"%s\" due to this file doesn't exist yet" % filename
                             self.set += 1
                             if nFiles == (self.nFiles-1): #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
                                 self.set = 0
                                 self.doy += 1
                     if fileOk_flag:
                         self.fileSize = os.path.getsize( file )
                         self.filename = file
                         self.flagIsNewFile = 1
                         if self.fp != None: self.fp.close()
                         self.fp = open(file)
                         self.flagNoMoreFiles = 0
                         print 'Setting the file: %s' % file
                     else:
                         self.fileSize = 0
                         self.filename = None
                         self.flagIsNewFile = 0
                         self.fp = None
                         self.flagNoMoreFiles = 1
                         print 'No more Files'
                     return fileOk_flag
                 def __setNextFileOffline(self):
                     """
                     Busca el siguiente file dentro de un folder que tenga suficiente data para ser leida
                     Affected:
                         self.flagIsNewFile
                         self.fileIndex
                         self.filename
                         self.fileSize
                         self.fp
                     Return:
 : si un determinado file no puede ser abierto
 : si el file fue abierto con exito
                     Excepciones:
                         Si un determinado file no puede ser abierto
                     """
                     idFile = self.fileIndex
                     while(True):
                         idFile += 1
                         if not(idFile < len(self.filenameList)):
                             self.flagNoMoreFiles = 1
                             print 'No more Files'
                             return 0
                         filename = self.filenameList[idFile]
                         if not(self.__verifyFile(filename)):
                             continue
                         fileSize = os.path.getsize(filename)
                         fp = open(filename,'rb')
                         break
                     self.flagIsNewFile = 1
                     self.fileIndex = idFile
                     self.filename = filename
                     self.fileSize = fileSize
                     self.fp = fp
                     print 'Setting the file: %s'%self.filename
                     return 1
                 def setNextFile(self):
                     """
                     Determina el siguiente file a leer y si hay uno disponible lee el First Header
                     Affected:
                         self.m_BasicHeader
                         self.m_SystemHeader
                         self.m_RadarControllerHeader
                         self.m_ProcessingHeader
                         self.firstHeaderSize
                     Return:
 :    Si no hay files disponibles
 :    Si hay mas files disponibles
                     """
                     if self.fp != None:
                         self.fp.close()
                     if self.online:
                         newFile = self.__setNextFileOnline()
                     else:
                         newFile = self.__setNextFileOffline()
                     if not(newFile):
                         return 0
                     self.__readFirstHeader()
                     self.nReadBlocks = 0
                     return 1
                 def __searchFilesOnLine(self, path, startDateTime=None, endDateTime=None, expLabel = "", ext = None):
                     """
                     Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
                     devuelve el archivo encontrado ademas de otros datos.
                     Input:
                         path             :    carpeta donde estan contenidos los files que contiene data
                         startDateTime    :    punto especifico en el tiempo del cual se requiere la data
                         ext              :    extension de los files
                     Return:
                         year        :    el anho
                         doy         :    el numero de dia del anho
                         set         :    el set del archivo
                         filename    :    el ultimo file de una determinada carpeta
                         directory   :    eL directorio donde esta el file encontrado
                     """
                     dirList = []
                     pathList = []
                     directory = None
                     for thisPath in os.listdir(path):
                         if os.path.isdir(os.path.join(path,thisPath)):
                             dirList.append(thisPath)
                     if not(dirList):
                         return None, None, None, None, None
                     dirList = sorted( dirList, key=str.lower )
                     if startDateTime:
                         thisDateTime = startDateTime
                         if endDateTime == None: endDateTime = startDateTime
                         while(thisDateTime <= endDateTime):
                             year = thisDateTime.timetuple().tm_year
                             doy = thisDateTime.timetuple().tm_yday
                             match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
                             if len(match) == 0:
                                 thisDateTime += datetime.timedelta(1)
                                 continue
                             pathList.append(os.path.join(path,match[0], expLabel))
                             thisDateTime += datetime.timedelta(1)
                         if not(pathList):
                             print "\tNo files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
                             return None, None, None, None, None
                         directory = pathList[0]
                     else:
                         directory = dirList[-1]
                         directory = os.path.join(path,directory)
                     filename = getlastFileFromPath(directory, ext)
                     if not(filename):
                         return None, None, None, None, None
                     if not(self.__verifyFile(os.path.join(directory, filename))):
                         return None, None, None, None, None
                     year = int( filename[1:5] )
                     doy  = int( filename[5:8] )
                     set  = int( filename[8:11] )
                     return directory, filename, year, doy, set
                 def __searchFilesOffLine(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".r"):
                     """
                     Realiza una busqueda de los archivos que coincidan con los parametros
                     especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
                     correcta la estructura de directorios debe ser la siguiente:
                     ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
                     [yyyy]: anio
                     [ddd] : dia del anio
                     [sss] : set del archivo
                     Inputs:
                         path           :    Directorio de datos donde se realizara la busqueda. Todos los
                                             ficheros que concidan con el criterio de busqueda seran
                                             almacenados en una lista y luego retornados.
                         startDateTime  :    Fecha inicial. Rechaza todos los archivos donde
                                             file end time < startDateTime (obejto datetime.datetime)
                         endDateTime    :    Fecha final. Rechaza todos los archivos donde
                                             file start time > endDateTime (obejto datetime.datetime)
                         set            :    Set del primer archivo a leer. Por defecto None
                         expLabel       :    Nombre del subdirectorio de datos.  Por defecto ""
                         ext            :    Extension de los archivos a leer. Por defecto .r
                     Return:
                         (pathList, filenameList)
                         pathList        :    Lista de directorios donde se encontraron archivos dentro
                                              de los parametros especificados
                         filenameList    :    Lista de archivos (ruta completa) que coincidieron con los
                                              parametros especificados.
                     Variables afectadas:
                         self.filenameList:    Lista de archivos (ruta completa) que la clase utiliza
                                               como fuente para leer los bloque de datos, si se termina
                                               de leer todos los bloques de datos de un determinado
                                               archivo se pasa al siguiente archivo de la lista.
                     Excepciones:
                     """
                     print "Searching files ..."
                     dirList = []
                     for thisPath in os.listdir(path):
                         if os.path.isdir(os.path.join(path,thisPath)):
                             dirList.append(thisPath)
                     if not(dirList):
                         return None, None
                     pathList = []
                     thisDateTime = startDateTime
                     while(thisDateTime <= endDateTime):
                         year = thisDateTime.timetuple().tm_year
                         doy = thisDateTime.timetuple().tm_yday
                         match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
                         if len(match) == 0:
                             thisDateTime += datetime.timedelta(1)
                             continue
                         pathList.append(os.path.join(path,match[0],expLabel))
                         thisDateTime += datetime.timedelta(1)
                     startUtSeconds = time.mktime(startDateTime.timetuple())
                     endUtSeconds = time.mktime(endDateTime.timetuple())
                     filenameList = []
                     for thisPath in pathList:
                         fileList = glob.glob1(thisPath, "*%s" %ext)
                         fileList.sort()
                         for file in fileList:
                             filename = os.path.join(thisPath,file)
                             if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
                                 filenameList.append(filename)
                     if not(filenameList):
                         return None, None
                     self.filenameList = filenameList
                     return pathList, filenameList
                 def __verifyFile(self, filename, msgFlag=True):
                     """
                     Verifica que el filename tenga data valida, para ello leo el FirstHeader del file
                     Return:
 :    file no valido para ser leido
 :    file valido para ser leido
                     """
                     msg = None
                     try:
                         fp = open( filename,'rb' ) #lectura binaria
                         currentPosition = fp.tell()
                     except:
                         if msgFlag:
                             print "The file %s can't be opened" % (filename)
                         return False
                     neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
                     if neededSize == 0:
                         m_BasicHeader = BasicHeader()
                         m_SystemHeader = SystemHeader()
                         m_RadarControllerHeader = RadarControllerHeader()
                         m_ProcessingHeader = ProcessingHeader()
                         try:
                             if not( m_BasicHeader.read(fp) ): raise ValueError
                             if not( m_SystemHeader.read(fp) ): raise ValueError
                             if not( m_RadarControllerHeader.read(fp) ): raise ValueError
                             if not( m_ProcessingHeader.read(fp) ): raise ValueError
                             data_type = int(numpy.log2((m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
                             neededSize = m_ProcessingHeader.blockSize + m_BasicHeader.size
                         except:
                             if msgFlag:
                                 print "\tThe file %s is empty or it hasn't enough data" % filename
                             fp.close()
                             return False
                     else:
                         msg = "\tSkipping the file %s due to it hasn't enough data" %filename
                     fp.close()
                     fileSize = os.path.getsize(filename)
                     currentSize = fileSize - currentPosition
                     if currentSize < neededSize:
                         if msgFlag and (msg != None):
                             print msg #print"\tSkipping the file %s due to it hasn't enough data" %filename
                         return False
                     return True
                 def updateDataHeader(self):
-                    self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
+                    self.dataOutObj.m_BasicHeader = self.m_BasicHeader.copy()
-                    self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
+                    self.dataOutObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
-                    self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
+                    self.dataOutObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
-                    self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy()
+                    self.dataOutObj.m_SystemHeader = self.m_SystemHeader.copy()
-                    self.m_DataObj.dataType = self.dataType
-                    self.m_DataObj.updateObjFromHeader()
-                def setup(self, path, startDateTime=None, endDateTime=None, set=0, expLabel = "", ext = None, online = 0):
-                    """
-                    setup configura los parametros de lectura de la clase DataReader.
-                    Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
-                    que coincidan con los parametros especificados; esta lista de archivos son almacenados en
-                    self.filenameList.
-                    Input:
-                        path                :    Directorios donde se ubican los datos a leer. Dentro de este
-                                                 directorio deberia de estar subdirectorios de la forma:
-                                                 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
-                        startDateTime       :    Fecha inicial. Rechaza todos los archivos donde
-                                                 file end time < startDatetime (obejto datetime.datetime)
-                        endDateTime         :    Fecha final. Si no es None, rechaza todos los archivos donde
-                                                 file end time < startDatetime (obejto datetime.datetime)
-                        set                 :    Set del primer archivo a leer. Por defecto None
-                        expLabel            :    Nombre del subdirectorio de datos.  Por defecto ""
-                        ext                 :    Extension de los archivos a leer. Por defecto .r
-                        online              :    Si es == a 0 entonces busca files que cumplan con las condiciones dadas
-                    Return:
-:    Si no encuentra files que cumplan con las condiciones dadas
-:    Si encuentra files que cumplan con las condiciones dadas
-                    Affected:
-                        self.startUTCSeconds
-                        self.endUTCSeconds
-                        self.startYear
-                        self.endYear
-                        self.startDoy
-                        self.endDoy
-                        self.pathList
-                        self.filenameList
-                        self.online
-                    """
-                    if ext == None:
+                    self.dataOutObj.dataType = self.dataType
-                        ext = self.ext
+                    self.dataOutObj.updateObjFromHeader()
-                    if online:
-                        print "Searching files ..."
-                        doypath, file, year, doy, set = self.__searchFilesOnLine(path, startDateTime, endDateTime, expLabel, ext)
-                        if not(doypath):
-                            for nTries in range( self.nTries ):
-                                print '\tWaiting %0.2f sec for valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
-                                time.sleep( self.delay )
-                                doypath, file, year, doy, set = self.__searchFilesOnLine(path, startDateTime, endDateTime, expLabel, ext)
-                                if doypath:
-                                    break
-                        if not(doypath):
-                            print "There 'isn't valied files in %s" % path
-                            return 0
-                        self.year = year
-                        self.doy  = doy
-                        self.set  = set - 1
-                        self.path = path
-                    else: # offline
-                        pathList, filenameList = self.__searchFilesOffLine(path, startDateTime, endDateTime, set, expLabel, ext)
-                        if not(pathList):
-                            print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
-                            return 0
-                        self.fileIndex = -1
-                        self.pathList = pathList
-                        self.filenameList = filenameList
-                    self.online = online
-                    self.ext = ext
-                    ext = ext.lower()
-                    if not( self.setNextFile() ):
-                        if (startDateTime != None) and (endDateTime != None):
-                            print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
-                        elif startDateTime != None:
-                            print "No files in : %s" % startDateTime.ctime()
-                        else:
-                            print "No files"
-                        return 0
-                    if startDateTime != None:
-                        self.startUTCSeconds = time.mktime(startDateTime.timetuple())
-                        self.startYear = startDateTime.timetuple().tm_year
-                        self.startDoy = startDateTime.timetuple().tm_yday
-                    if endDateTime != None:
-                        self.endUTCSeconds = time.mktime(endDateTime.timetuple())
-                        self.endYear = endDateTime.timetuple().tm_year
-                        self.endDoy = endDateTime.timetuple().tm_yday
-                    #call fillHeaderValues() - to Data Object
-                    self.updateDataHeader()
-                    return 1
             class JRODataWriter(JRODataIO):
                 """
                 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 nWriteBlocks = 0
                 setFile = None
-                def __init__(self, m_DataObj=None):
+                def __init__(self, dataOutObj=None):
                     raise ValueError, "Not implemented"
                 def hasAllDataInBuffer(self):
                     raise ValueError, "Not implemented"
                 def setBlockDimension(self):
                     raise ValueError, "Not implemented"
                 def writeBlock(self):
                     raise ValueError, "No implemented"
                 def putData(self):
                     raise ValueError, "No implemented"
                 def __writeFirstHeader(self):
                     """
                     Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
                     Affected:
                         __dataType
                     Return:
                         None
                     """
                     self.__writeBasicHeader()
                     self.__wrSystemHeader()
                     self.__wrRadarControllerHeader()
                     self.__wrProcessingHeader()
-                    self.dataType = self.m_DataObj.dataType
+                    self.dataType = self.dataOutObj.dataType
                 def __writeBasicHeader(self, fp=None):
                     """
                     Escribe solo el Basic header en el file creado
                     Return:
                         None
                     """
                     if fp == None:
                         fp = self.fp
-                    self.m_DataObj.m_BasicHeader.write(fp)
+                    self.dataOutObj.m_BasicHeader.write(fp)
                 def __wrSystemHeader(self, fp=None):
                     """
                     Escribe solo el System header en el file creado
                     Return:
                         None
                     """
                     if fp == None:
                         fp = self.fp
-                    self.m_DataObj.m_SystemHeader.write(fp)
+                    self.dataOutObj.m_SystemHeader.write(fp)
                 def __wrRadarControllerHeader(self, fp=None):
                     """
                     Escribe solo el RadarController header en el file creado
                     Return:
                         None
                     """
                     if fp == None:
                         fp = self.fp
-                    self.m_DataObj.m_RadarControllerHeader.write(fp)
+                    self.dataOutObj.m_RadarControllerHeader.write(fp)
                 def __wrProcessingHeader(self, fp=None):
                     """
                     Escribe solo el Processing header en el file creado
                     Return:
                         None
                     """
                     if fp == None:
                         fp = self.fp
-                    self.m_DataObj.m_ProcessingHeader.write(fp)
+                    self.dataOutObj.m_ProcessingHeader.write(fp)
                 def setNextFile(self):
                     """
                     Determina el siguiente file que sera escrito
                     Affected:
                         self.filename
                         self.subfolder
                         self.fp
                         self.setFile
                         self.flagIsNewFile
                     Return:
 :    Si el archivo no puede ser escrito
 :    Si el archivo esta listo para ser escrito
                     """
                     ext = self.ext
                     path = self.path
                     if self.fp != None:
                         self.fp.close()
-                    timeTuple = time.localtime( self.m_DataObj.m_BasicHeader.utc )
+                    timeTuple = time.localtime( self.dataOutObj.m_BasicHeader.utc )
                     subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
                     doypath = os.path.join( path, subfolder )
                     if not( os.path.exists(doypath) ):
                         os.mkdir(doypath)
                         self.setFile = -1 #inicializo mi contador de seteo
                     else:
                         filesList = os.listdir( doypath )
                         if len( filesList ) > 0:
                             filesList = sorted( filesList, key=str.lower )
                             filen = filesList[-1]
                             # el filename debera tener el siguiente formato
                             # 0 1234 567 89A BCDE (hex)
                             # x YYYY DDD SSS .ext
                             if isNumber( filen[8:11] ):
                                 self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
                             else:
                                 self.setFile = -1
                         else:
                             self.setFile = -1 #inicializo mi contador de seteo
                     setFile = self.setFile
                     setFile += 1
                     file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
                                                     timeTuple.tm_year,
                                                     timeTuple.tm_yday,
                                                     setFile,
                                                     ext )
                     filename = os.path.join( path, subfolder, file )
                     fp = open( filename,'wb' )
                     self.nWriteBlocks = 0
                     #guardando atributos
                     self.filename = filename
                     self.subfolder = subfolder
                     self.fp = fp
                     self.setFile = setFile
                     self.flagIsNewFile = 1
                     print 'Writing the file: %s'%self.filename
                     self.__writeFirstHeader()
                     return 1
                 def __setNewBlock(self):
                     """
                     Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
                     Return:
 :    si no pudo escribir nada
 :    Si escribio el Basic el First Header
                     """
                     if self.fp == None:
                         self.setNextFile()
                     if self.flagIsNewFile:
                         return 1
                     if self.nWriteBlocks < self.m_ProcessingHeader.dataBlocksPerFile:
                         self.__writeBasicHeader()
                         return 1
                     if not( self.setNextFile() ):
                         return 0
                     return 1
                 def writeNextBlock(self):
                     """
                     Selecciona el bloque siguiente de datos y los escribe en un file
                     Return:
 :    Si no hizo pudo escribir el bloque de datos
 :    Si no pudo escribir el bloque de datos
                     """
                     if not( self.__setNewBlock() ):
                         return 0
                     self.writeBlock()
                     return 1
                 def getDataHeader(self):
                     """
                     Obtiene una copia del First Header
                     Affected:
                         self.m_BasicHeader
                         self.m_SystemHeader
                         self.m_RadarControllerHeader
                         self.m_ProcessingHeader
                         self.dataType
                     Return:
                         None
                     """
-                    self.m_DataObj.updateHeaderFromObj()
+                    self.dataOutObj.updateHeaderFromObj()
-                    self.m_BasicHeader = self.m_DataObj.m_BasicHeader.copy()
+                    self.m_BasicHeader = self.dataOutObj.m_BasicHeader.copy()
-                    self.m_SystemHeader = self.m_DataObj.m_SystemHeader.copy()
+                    self.m_SystemHeader = self.dataOutObj.m_SystemHeader.copy()
-                    self.m_RadarControllerHeader = self.m_DataObj.m_RadarControllerHeader.copy()
+                    self.m_RadarControllerHeader = self.dataOutObj.m_RadarControllerHeader.copy()
-                    self.m_ProcessingHeader = self.m_DataObj.m_ProcessingHeader.copy()
+                    self.m_ProcessingHeader = self.dataOutObj.m_ProcessingHeader.copy()
-                    self.dataType = self.m_DataObj.dataType
+                    self.dataType = self.dataOutObj.dataType
                 def setup(self, path, set=0, ext=None):
                     """
                     Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
                     Inputs:
                         path      :    el path destino en el cual se escribiran los files a crear
                         format    :    formato en el cual sera salvado un file
                         set       :    el setebo del file
                     Return:
 :    Si no realizo un buen seteo
 :    Si realizo un buen seteo
                     """
                     if ext == None:
                         ext = self.ext
                     ext = ext.lower()
                     self.path = path
                     self.setFile = set - 1
                     self.ext = ext
                     #self.format = format
                     self.getDataHeader()
                     self.setBlockDimension()
                     if not( self.setNextFile() ):
                         print "There isn't a next file"
                         return 0
                     return 1

schainpy/IO/SpectraIO.py +36 -52

             '''
             File: SpectraIO.py
             Created on 20/02/2012
             @author $Author$
             @version $Id$
             '''
             import os, sys
             import numpy
             import glob
             import fnmatch
             import time, datetime
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from Model.JROHeader import *
             from Model.Spectra import Spectra
             from JRODataIO import JRODataReader
             from JRODataIO import JRODataWriter
             from JRODataIO import isNumber
             class SpectraReader(JRODataReader):
                 """
                 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
                 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
                 son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
                                     paresCanalesIguales    * alturas * perfiles  (Self Spectra)
                                     paresCanalesDiferentes * alturas * perfiles  (Cross Spectra)
                                     canales * alturas                            (DC Channels)
                 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
                 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
                 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
                 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
                 Example:
                     dpath = "/home/myuser/data"
                     startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
                     endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
                     readerObj = SpectraReader()
                     readerObj.setup(dpath, startTime, endTime)
                     while(True):
                         readerObj.getData()
-                        print readerObj.m_Spectra.data
+                        print readerObj.dataOutObj.data
                         if readerObj.flagNoMoreFiles:
                             break
                 """
-                m_DataObj = None
+                dataOutObj = None
                 data_spc = None
                 data_cspc = None
                 data_dc = None
                 pts2read_SelfSpectra = 0
                 pts2read_CrossSpectra = 0
                 pts2read_DCchannels = 0
                 nChannels = 0
                 nPairs = 0
-                #pairList = None
+                flag_cspc = False
-                channelList = None
-                def __init__(self, m_Spectra=None):
+                def __init__(self, dataOutObj=None):
                     """
                     Inicializador de la clase SpectraReader para la lectura de datos de espectros.
                     Inputs:
-                        m_Spectra    :    Objeto de la clase Spectra. Este objeto sera utilizado para
+                        dataOutObj    :    Objeto de la clase Spectra. Este objeto sera utilizado para
                                           almacenar un perfil de datos cada vez que se haga un requerimiento
                                           (getData). El perfil sera obtenido a partir del buffer de datos,
                                           si el buffer esta vacio se hara un nuevo proceso de lectura de un
                                           bloque de datos.
                                           Si este parametro no es pasado se creara uno internamente.
                     Affected:
-                        self.m_DataObj
+                        self.dataOutObj
                     Return      : None
                     """
-                    if m_Spectra == None:
-                        m_Spectra = Spectra()
-                    if not( isinstance(m_Spectra, Spectra) ):
-                        raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
-                    self.m_DataObj = m_Spectra
                     self.data_spc = None
                     self.data_cspc = None
                     self.data_dc = None
                     self.pts2read_SelfSpectra = 0
                     self.pts2read_CrossSpectra = 0
                     self.pts2read_DCs = 0
                     self.nChannels = 0
                     self.nPairs = 0
                     self.ext = ".pdata"
                     self.optchar = "P"
                     ######################
                     self.m_BasicHeader = BasicHeader()
                     self.m_SystemHeader = SystemHeader()
                     self.m_RadarControllerHeader = RadarControllerHeader()
                     self.m_ProcessingHeader = ProcessingHeader()
                     self.online = 0
                     self.fp = None
                     self.fileSizeByHeader = None
                     self.filenameList = []
                     self.filename = None
                     self.fileSize = None
                     self.firstHeaderSize = 0
                     self.basicHeaderSize = 24
                     self.dataType = None
                     self.maxTimeStep = 30
                     self.flagNoMoreFiles = 0
                     self.set = 0
                     self.path = None
                     self.delay  = 3  #seconds
                     self.nTries = 3  #quantity tries
                     self.nFiles = 3  #number of files for searching
                     self.nReadBlocks = 0
                     self.flagIsNewFile = 1
                     self.ippSeconds = 0
                     self.flagResetProcessing = 0
                     self.flagIsNewBlock = 0
                     self.nTotalBlocks = 0
                     self.blocksize = 0
-                    #pairList = None
+                def createObjByDefault(self):
-                    channelList = None
-                    self.flag_cspc = False
+                    dataObj = Spectra()
+                    return dataObj
                 def __hasNotDataInBuffer(self):
                     return 1
                 def getBlockDimension(self):
                     """
                     Obtiene la cantidad de puntos a leer por cada bloque de datos
                     Affected:
                         self.nChannels
                         self.nPairs
                         self.pts2read_SelfSpectra
                         self.pts2read_CrossSpectra
                         self.pts2read_DCchannels
                         self.blocksize
-                        self.m_DataObj.nChannels
+                        self.dataOutObj.nChannels
-                        self.m_DataObj.nPairs
+                        self.dataOutObj.nPairs
                     Return:
                         None
                     """
                     self.nChannels = 0
                     self.nPairs = 0
                     self.pairList = []
                     for i in range( 0, self.m_ProcessingHeader.totalSpectra*2, 2 ):
                         if self.m_ProcessingHeader.spectraComb[i] == self.m_ProcessingHeader.spectraComb[i+1]:
                             self.nChannels = self.nChannels + 1   #par de canales iguales
                         else:
                             self.nPairs = self.nPairs + 1 #par de canales diferentes
                             self.pairList.append( (self.m_ProcessingHeader.spectraComb[i], self.m_ProcessingHeader.spectraComb[i+1]) )
-                    if self.nPairs > 0:
-                        self.flag_cspc = True
                     pts2read = self.m_ProcessingHeader.numHeights * self.m_ProcessingHeader.profilesPerBlock
                     self.pts2read_SelfSpectra = int(self.nChannels * pts2read)
                     self.blocksize = self.pts2read_SelfSpectra
-                    if self.flag_cspc:
+                    if self.m_ProcessingHeader.flag_cspc:
                         self.pts2read_CrossSpectra = int(self.nPairs * pts2read)
                         self.blocksize += self.pts2read_CrossSpectra
                     if self.m_ProcessingHeader.flag_dc:
                         self.pts2read_DCchannels = int(self.m_SystemHeader.numChannels * self.m_ProcessingHeader.numHeights)
                         self.blocksize += self.pts2read_DCchannels
             #        self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
-                    self.channelList = numpy.arange(self.nChannels)
                 def readBlock(self):
                     """
                     Lee el bloque de datos desde la posicion actual del puntero del archivo
                     (self.fp) y actualiza todos los parametros relacionados al bloque de datos
                     (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
                     es seteado a 0
                     Return: None
                     Variables afectadas:
                         self.datablockIndex
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                         self.data_spc
                         self.data_cspc
                         self.data_dc
                     Exceptions:
                         Si un bloque leido no es un bloque valido
                     """
                     blockOk_flag = False
                     fpointer = self.fp.tell()
                     spc = numpy.fromfile( self.fp, self.dataType[0], self.pts2read_SelfSpectra )
                     spc = spc.reshape( (self.nChannels, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
                     if self.flag_cspc:
                         cspc = numpy.fromfile( self.fp, self.dataType, self.pts2read_CrossSpectra )
                         cspc = cspc.reshape( (self.nPairs, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
                     if self.m_ProcessingHeader.flag_dc:
                         dc = numpy.fromfile( self.fp, self.dataType, self.pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
                         dc = dc.reshape( (self.m_SystemHeader.numChannels, self.m_ProcessingHeader.numHeights) ) #transforma a un arreglo 2D
                     if not(self.m_ProcessingHeader.shif_fft):
                         spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
                         if self.flag_cspc:
                             cspc = numpy.roll( cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
                     spc = numpy.transpose( spc, (0,2,1) )
                     self.data_spc = spc
                     if self.flag_cspc:
                         cspc = numpy.transpose( cspc, (0,2,1) )
                         self.data_cspc = cspc['real'] + cspc['imag']*1j
                     else:
                         self.data_cspc = None
                     if self.m_ProcessingHeader.flag_dc:
                         self.data_dc = dc['real'] + dc['imag']*1j
                     else:
                         self.data_dc = None
                     self.datablockIndex = 0
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks += 1
                     self.nReadBlocks += 1
                     return 1
                 def getData(self):
                     """
                     Copia el buffer de lectura a la clase "Spectra",
                     con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
                     lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
                     Return:
 :    Si no hay mas archivos disponibles
 :    Si hizo una buena copia del buffer
                     Affected:
-                        self.m_DataObj
+                        self.dataOutObj
                         self.datablockIndex
                         self.flagResetProcessing
                         self.flagIsNewBlock
                     """
                     if self.flagNoMoreFiles: return 0
                     self.flagResetProcessing = 0
                     self.flagIsNewBlock = 0
                     if self.__hasNotDataInBuffer():
                         if not( self.readNextBlock() ):
                             return 0
                         self.updateDataHeader()
                     if self.flagNoMoreFiles == 1:
                         print 'Process finished'
                         return 0
                     #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
                     if self.data_dc == None:
-                        self.m_DataObj.flagNoData = True
+                        self.dataOutObj.flagNoData = True
                         return 0
-                    self.m_DataObj.flagNoData = False
+                    self.dataOutObj.flagNoData = False
-                    self.m_DataObj.flagResetProcessing = self.flagResetProcessing
+                    self.dataOutObj.flagResetProcessing = self.flagResetProcessing
-                    self.m_DataObj.data_spc = self.data_spc
+                    self.dataOutObj.data_spc = self.data_spc
-                    self.m_DataObj.data_cspc = self.data_cspc
+                    self.dataOutObj.data_cspc = self.data_cspc
-                    self.m_DataObj.data_dc = self.data_dc
+                    self.dataOutObj.data_dc = self.data_dc
                     return 1
             class SpectraWriter(JRODataWriter):
                 """
                 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
                 de los datos siempre se realiza por bloques.
                 """
-                m_DataObj = None
+                dataOutObj = None
                 shape_spc_Buffer = None
                 shape_cspc_Buffer = None
                 shape_dc_Buffer = None
                 data_spc = None
                 data_cspc = None
                 data_dc = None
-                def __init__(self, m_Spectra=None):
+                def __init__(self, dataOutObj=None):
                     """
                     Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
                     Affected:
-                        self.m_DataObj
+                        self.dataOutObj
                         self.m_BasicHeader
                         self.m_SystemHeader
                         self.m_RadarControllerHeader
                         self.m_ProcessingHeader
                     Return: None
                     """
-                    if m_Spectra == None:
+                    if dataOutObj == None:
-                        m_Spectra = Spectra()
+                        dataOutObj = Spectra()
-                    if not( isinstance(m_Spectra, Spectra) ):
+                    if not( isinstance(dataOutObj, Spectra) ):
-                        raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
+                        raise ValueError, "in SpectraReader, dataOutObj must be an Spectra class object"
-                    self.m_DataObj = m_Spectra
+                    self.dataOutObj = dataOutObj
                     self.ext = ".pdata"
                     self.optchar = "P"
                     self.shape_spc_Buffer = None
                     self.shape_cspc_Buffer = None
                     self.shape_dc_Buffer = None
                     self.data_spc = None
                     self.data_cspc = None
                     self.data_dc = None
                     ####################################
                     self.fp = None
                     self.nWriteBlocks = 0
                     self.flagIsNewFile = 1
                     self.nTotalBlocks = 0
                     self.flagIsNewBlock = 0
                     self.flagNoMoreFiles = 0
                     self.setFile = None
                     self.dataType = None
                     self.path = None
                     self.noMoreFiles = 0
                     self.filename = None
                     self.m_BasicHeader= BasicHeader()
                     self.m_SystemHeader = SystemHeader()
                     self.m_RadarControllerHeader = RadarControllerHeader()
                     self.m_ProcessingHeader = ProcessingHeader()
                 def hasAllDataInBuffer(self):
                     return 1
                 def setBlockDimension(self):
                     """
                     Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
                     Affected:
                         self.shape_spc_Buffer
                         self.shape_cspc_Buffer
                         self.shape_dc_Buffer
                     Return: None
                     """
-                    self.shape_spc_Buffer = (self.m_DataObj.nChannels,
+                    self.shape_spc_Buffer = (self.dataOutObj.nChannels,
                                              self.m_ProcessingHeader.numHeights,
                                              self.m_ProcessingHeader.profilesPerBlock)
-                    self.shape_cspc_Buffer = (self.m_DataObj.nPairs,
+                    self.shape_cspc_Buffer = (self.dataOutObj.nPairs,
                                               self.m_ProcessingHeader.numHeights,
                                               self.m_ProcessingHeader.profilesPerBlock)
                     self.shape_dc_Buffer = (self.m_SystemHeader.numChannels,
                                             self.m_ProcessingHeader.numHeights)
                 def writeBlock(self):
                     """
                     Escribe el buffer en el file designado
                     Affected:
                         self.data_spc
                         self.data_cspc
                         self.data_dc
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                         self.nWriteBlocks
                     Return: None
                     """
                     spc = numpy.transpose( self.data_spc, (0,2,1) )
                     if not( self.m_ProcessingHeader.shif_fft ):
                         spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
                     data = spc.reshape((-1))
                     data.tofile(self.fp)
                     if self.data_cspc != None:
                         data = numpy.zeros( self.shape_cspc_Buffer, self.dataType )
                         cspc = numpy.transpose( self.data_cspc, (0,2,1) )
                         if not( self.m_ProcessingHeader.shif_fft ):
                             cspc = numpy.roll( cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
                         data['real'] = cspc.real
                         data['imag'] = cspc.imag
                         data = data.reshape((-1))
                         data.tofile(self.fp)
                     data = numpy.zeros( self.shape_dc_Buffer, self.dataType )
                     dc = self.data_dc
                     data['real'] = dc.real
                     data['imag'] = dc.imag
                     data = data.reshape((-1))
                     data.tofile(self.fp)
                     self.data_spc.fill(0)
                     self.data_dc.fill(0)
                     if self.data_cspc != None:
                         self.data_cspc.fill(0)
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks += 1
                     self.nWriteBlocks += 1
                 def putData(self):
                     """
                     Setea un bloque de datos y luego los escribe en un file
                     Affected:
                         self.data_spc
                         self.data_cspc
                         self.data_dc
                     Return:
 :    Si no hay data o no hay mas files que puedan escribirse
 :    Si se escribio la data de un bloque en un file
                     """
                     self.flagIsNewBlock = 0
-                    if self.m_DataObj.flagNoData:
+                    if self.dataOutObj.flagNoData:
                         return 0
-                    if self.m_DataObj.flagResetProcessing:
+                    if self.dataOutObj.flagResetProcessing:
                         self.data_spc.fill(0)
                         self.data_cspc.fill(0)
                         self.data_dc.fill(0)
                         self.setNextFile()
-                    self.data_spc = self.m_DataObj.data_spc
+                    self.data_spc = self.dataOutObj.data_spc
-                    self.data_cspc = self.m_DataObj.data_cspc
+                    self.data_cspc = self.dataOutObj.data_cspc
-                    self.data_dc = self.m_DataObj.data_dc
+                    self.data_dc = self.dataOutObj.data_dc
                     # #self.m_ProcessingHeader.dataBlocksPerFile)
                     if self.hasAllDataInBuffer():
                         self.getDataHeader()
                         self.writeNextBlock()
                     if self.flagNoMoreFiles:
                         #print 'Process finished'
                         return 0
                     return 1

schainpy/IO/VoltageIO.py +29 -30

             '''
             Created on 23/01/2012
             @author $Author$
             @version $Id$
             '''
             import os, sys
             import numpy
             import glob
             import fnmatch
             import time, datetime
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from Model.JROHeader import *
             from Model.Voltage import Voltage
             from IO.JRODataIO import JRODataReader
             from IO.JRODataIO import JRODataWriter
             class VoltageReader(JRODataReader):
                 """
                 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
                 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
                 perfiles*alturas*canales) son almacenados en la variable "buffer".
                                          perfiles * alturas * canales
                 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
                 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
                 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
                 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
                 Example:
                     dpath = "/home/myuser/data"
                     startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
                     endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
                     readerObj = VoltageReader()
                     readerObj.setup(dpath, startTime, endTime)
                     while(True):
                         #to get one profile
                         profile =  readerObj.getData()
                         #print the profile
                         print profile
                         #If you want to see all datablock
                         print readerObj.datablock
                         if readerObj.flagNoMoreFiles:
                             break
                 """
-                m_DataObj = None
+                dataOutObj = None
                 datablock = None
                 ext = ".r"
                 optchar = "D"
-                def __init__(self, m_Voltage=None):
+                def __init__(self, dataOutObj=None):
                     """
                     Inicializador de la clase VoltageReader para la lectura de datos de voltage.
                     Input:
-                        m_Voltage    :    Objeto de la clase Voltage. Este objeto sera utilizado para
+                        dataOutObj    :    Objeto de la clase Voltage. Este objeto sera utilizado para
                                           almacenar un perfil de datos cada vez que se haga un requerimiento
                                           (getData). El perfil sera obtenido a partir del buffer de datos,
                                           si el buffer esta vacio se hara un nuevo proceso de lectura de un
                                           bloque de datos.
                                           Si este parametro no es pasado se creara uno internamente.
                     Variables afectadas:
-                        self.m_DataObj
+                        self.dataOutObj
                     Return:
                         None
                     """
-                    if m_Voltage == None:
-                        m_Voltage = Voltage()
-                    if not(isinstance(m_Voltage, Voltage)):
-                        raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
-                    self.m_DataObj = m_Voltage
                     self.datablock = None
                     self.utc = 0
                     self.ext = ".r"
                     self.optchar = "D"
                     self.m_BasicHeader = BasicHeader()
                     self.m_SystemHeader = SystemHeader()
                     self.m_RadarControllerHeader = RadarControllerHeader()
                     self.m_ProcessingHeader = ProcessingHeader()
                     self.online = 0
                     self.fp = None
                     self.idFile = None
                     self.startDateTime = None
                     self.endDateTime = None
                     self.dataType = None
                     self.fileSizeByHeader = None
                     self.filenameList = []
                     self.filename = None
                     self.fileSize = None
                     self.firstHeaderSize = 0
                     self.basicHeaderSize = 24
                     self.pathList = []
                     self.filenameList = []
                     self.lastUTTime = 0
                     self.maxTimeStep = 30
                     self.flagNoMoreFiles = 0
                     self.set = 0
                     self.path = None
                     self.profileIndex = 9999
                     self.delay  = 3   #seconds
                     self.nTries  = 3  #quantity tries
                     self.nFiles = 3   #number of files for searching
                     self.nReadBlocks = 0
                     self.flagIsNewFile = 1
                     self.ippSeconds = 0
                     self.flagResetProcessing = 0
                     self.flagIsNewBlock = 0
                     self.nTotalBlocks = 0
                     self.blocksize = 0
+                def createObjByDefault(self):
+                    dataObj = Voltage()
+                    return dataObj
                 def __hasNotDataInBuffer(self):
                     if self.profileIndex >= self.m_ProcessingHeader.profilesPerBlock:
                         return 1
                     return 0
                 def getBlockDimension(self):
                     """
                     Obtiene la cantidad de puntos a leer por cada bloque de datos
                     Affected:
                         self.blocksize
                     Return:
                         None
                     """
                     pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
                     self.blocksize = pts2read
                 def readBlock(self):
                     """
                     readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
                     (self.fp) y actualiza todos los parametros relacionados al bloque de datos
                     (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
                     es seteado a 0
                     Inputs:
                         None
                     Return:
                         None
                     Affected:
                         self.profileIndex
                         self.datablock
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                     Exceptions:
                         Si un bloque leido no es un bloque valido
                     """
                     junk = numpy.fromfile( self.fp, self.dataType, self.blocksize )
                     try:
                         junk = junk.reshape( (self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels) )
                     except:
                         print "The read block (%3d) has not enough data" %self.nReadBlocks
                         return 0
                     junk = numpy.transpose(junk, (2,0,1))
                     self.datablock = junk['real'] + junk['imag']*1j
                     self.profileIndex = 0
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks += 1
                     self.nReadBlocks += 1
                     return 1
                 def getData(self):
                     """
                     getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
                     con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
                     lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
                     Ademas incrementa el contador del buffer en 1.
                     Return:
                         data    :    retorna un perfil de voltages (alturas * canales) copiados desde el
                                      buffer. Si no hay mas archivos a leer retorna None.
                     Variables afectadas:
-                        self.m_DataObj
+                        self.dataOutObj
                         self.profileIndex
                     Affected:
-                        self.m_DataObj
+                        self.dataOutObj
                         self.profileIndex
                         self.flagResetProcessing
                         self.flagIsNewBlock
                     """
                     if self.flagNoMoreFiles: return 0
                     self.flagResetProcessing = 0
                     self.flagIsNewBlock = 0
                     if self.__hasNotDataInBuffer():
                         if not( self.readNextBlock() ):
                             return 0
                         self.updateDataHeader()
                     if self.flagNoMoreFiles == 1:
                         print 'Process finished'
                         return 0
                     #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
                     if self.datablock == None:
-                        self.m_DataObj.flagNoData = True
+                        self.dataOutObj.flagNoData = True
                         return 0
                     time = self.m_BasicHeader.utc + self.profileIndex * self.ippSeconds
-                    self.m_DataObj.m_BasicHeader.utc = time
+                    self.dataOutObj.m_BasicHeader.utc = time
-                    self.m_DataObj.flagNoData = False
+                    self.dataOutObj.flagNoData = False
-                    self.m_DataObj.flagResetProcessing = self.flagResetProcessing
+                    self.dataOutObj.flagResetProcessing = self.flagResetProcessing
-                    self.m_DataObj.data = self.datablock[:,self.profileIndex,:]
+                    self.dataOutObj.data = self.datablock[:,self.profileIndex,:]
                     self.profileIndex += 1
                     #call setData - to Data Object
-                    return 1 #self.m_DataObj.data
+                    return 1 #self.dataOutObj.data
             class VoltageWriter(JRODataWriter):
                 """
                 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 __configHeaderFile = 'wrSetHeadet.txt'
-                m_DataObj = None
+                dataOutObj = None
                 ext = ".r"
                 optchar = "D"
                 datablock = None
                 profileIndex = 0
                 shapeBuffer = None
-                def __init__(self, m_Voltage=None):
+                def __init__(self, dataOutObj=None):
                     """
                     Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
                     Affected:
-                        self.m_DataObj
+                        self.dataOutObj
                     Return: None
                     """
-                    if m_Voltage == None:
+                    if dataOutObj == None:
-                        m_Voltage = Voltage()
+                        dataOutObj = Voltage()
-                    if not( isinstance(m_Voltage, Voltage) ):
+                    if not( isinstance(dataOutObj, Voltage) ):
-                        raise ValueError, "in VoltageReader, m_Voltage must be an Spectra class object"
+                        raise ValueError, "in VoltageReader, dataOutObj must be an Spectra class object"
-                    self.m_DataObj = m_Voltage
+                    self.dataOutObj = dataOutObj
                 def hasAllDataInBuffer(self):
                     if self.profileIndex >= self.m_ProcessingHeader.profilesPerBlock:
                         return 1
                     return 0
                 def setBlockDimension(self):
                     """
                     Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
                     Affected:
                         self.shape_spc_Buffer
                         self.shape_cspc_Buffer
                         self.shape_dc_Buffer
                     Return: None
                     """
                     self.shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock,
                                         self.m_ProcessingHeader.numHeights,
                                         self.m_SystemHeader.numChannels )
                     self.datablock = numpy.zeros((self.m_SystemHeader.numChannels,
                                                  self.m_ProcessingHeader.profilesPerBlock,
                                                  self.m_ProcessingHeader.numHeights),
                                                  dtype=numpy.dtype('complex'))
                 def writeBlock(self):
                     """
                     Escribe el buffer en el file designado
                     Affected:
                         self.profileIndex
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                         self.nWriteBlocks
                     Return: None
                     """
                     data = numpy.zeros( self.shapeBuffer, self.dataType )
                     junk = numpy.transpose(self.datablock, (1,2,0))
                     data['real'] = junk.real
                     data['imag'] = junk.imag
                     data = data.reshape( (-1) )
                     data.tofile( self.fp )
                     self.datablock.fill(0)
                     self.profileIndex = 0
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks += 1
                     self.nWriteBlocks += 1
                 def putData(self):
                     """
                     Setea un bloque de datos y luego los escribe en un file
                     Affected:
                         self.flagIsNewBlock
                         self.profileIndex
                     Return:
 :    Si no hay data o no hay mas files que puedan escribirse
 :    Si se escribio la data de un bloque en un file
                     """
                     self.flagIsNewBlock = 0
-                    if self.m_DataObj.flagNoData:
+                    if self.dataOutObj.flagNoData:
                         return 0
-                    if self.m_DataObj.flagResetProcessing:
+                    if self.dataOutObj.flagResetProcessing:
                         self.datablock.fill(0)
                         self.profileIndex = 0
                         self.setNextFile()
-                    self.datablock[:,self.profileIndex,:] = self.m_DataObj.data
+                    self.datablock[:,self.profileIndex,:] = self.dataOutObj.data
                     self.profileIndex += 1
                     if self.hasAllDataInBuffer():
                         #if self.flagIsNewFile:
                         self.getDataHeader()
                         self.writeNextBlock()
                     if self.flagNoMoreFiles:
                         #print 'Process finished'
                         return 0
                     return 1
   No newline at end of file

schainpy/Model/JROData.py +6 -10

             '''
             Created on Feb 7, 2012
             @author $Author$
             @version $Id$
             '''
             import copy
             import numpy
             from JROHeader import RadarControllerHeader, ProcessingHeader, SystemHeader, BasicHeader
             class Data:
                 '''
                 classdocs
                 '''
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     raise ValueError, "This class has not been implemented"
                 def copy(self, objIn=None):
                     if objIn == None:
                         return copy.deepcopy(self)
                     for key in objIn.__dict__.keys():
                         self.__dict__[key] = objIn.__dict__[key]
                 def deepcopy(self):
                     return copy.deepcopy(self)
-            class Noise(Data):
-                '''
-                classdocs
-                '''
-                def __init__(self):
-                    '''
-                    Constructor
-                    '''
-                    pass
             class JROData(Data):
                 '''
                 classdocs
                 '''
                 m_RadarControllerHeader = RadarControllerHeader()
                 m_ProcessingHeader = ProcessingHeader()
                 m_SystemHeader = SystemHeader()
                 m_BasicHeader = BasicHeader()
-                m_NoiseObj = Noise()
+                noise = None
                 type = None
                 dataType = None
                 nHeights = None
                 nProfiles = None
                 nChannels = None
                 heightList = None
                 channelList = None
+                channelIndexList = None
+                pairList = None
                 flagNoData = False
                 flagResetProcessing = False
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     raise ValueError, "This class has not been implemented"
                 def updateHeaderFromObj(self):
                     xi = self.heightList[0]
                     step = self.heightList[1] - self.heightList[0]
                     self.m_ProcessingHeader.firstHeight = xi
                     self.m_ProcessingHeader.deltaHeight = step
                     self.m_ProcessingHeader.numHeights = self.nHeights
                     self.m_SystemHeader.numChannels = self.nChannels
                     self.m_SystemHeader.numProfiles = self.nProfiles
                 def updateObjFromHeader(self):
                     xi = self.m_ProcessingHeader.firstHeight
                     step = self.m_ProcessingHeader.deltaHeight
                     xf = xi + self.m_ProcessingHeader.numHeights*step
                     self.heightList = numpy.arange(xi, xf, step)
+                    self.channelIndexList = numpy.arange(self.m_SystemHeader.numChannels)
                     self.channelList = numpy.arange(self.m_SystemHeader.numChannels)
                     self.nHeights = len(self.heightList)
                     self.nProfiles = self.m_SystemHeader.numProfiles
                     self.nChannels = len(self.channelList)
   No newline at end of file

schainpy/Model/JROHeader.py +19 0

             '''
             Created on 23/01/2012
             @author $Author: vsarmiento $
             @version $Id: HeaderIO.py 37 2012-03-26 22:55:13Z vsarmiento $
             '''
             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
                 numSamples = None
                 numProfiles = None
                 numChannels = None
                 adcResolution = None
                 pciDioBusWidth = None
                 struct = None
                 def __init__(self):
                     self.size = 0
                     self.numSamples = 0
                     self.numProfiles = 0
                     self.numChannels = 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.numSamples = header['nNumSamples'][0]
                         self.numProfiles = header['nNumProfiles'][0]
                         self.numChannels = 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.numSamples,self.numProfiles,self.numChannels,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
                 numWindows = 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.numWindows = 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.numHeights = None
                     self.firstHeight = None
                     self.deltaHeight = None
                     self.samplesWin = None
                     self.numCode = None
                     self.numBaud = 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.numWindows = 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.numWindows)
                         self.numHeights = 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.numCode = numpy.fromfile(fp,'<u4',1)
                             self.numBaud = numpy.fromfile(fp,'<u4',1)
                             self.code = numpy.empty([self.numCode,self.numBaud],dtype='u1')
                             tempList = []
                             for ic in range(self.numCode):
                                 temp = numpy.fromfile(fp,'u1',4*numpy.ceil(self.numBaud/32.))
                                 tempList.append(temp)
                                 self.code[ic] = numpy.unpackbits(temp[::-1])[-1*self.numBaud:]
                             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.numWindows,
                                    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
                 dataType = None
                 blockSize = None
                 profilesPerBlock = None
                 dataBlocksPerFile = None
                 numWindows = None
                 processFlags = None
                 coherentInt = None
                 incoherentInt = None
                 totalSpectra = None
                 struct = None
+                flag_dc = None
+                flag_cspc = None
                 def __init__(self):
                     self.size = 0
                     self.dataType = 0
                     self.blockSize = 0
                     self.profilesPerBlock = 0
                     self.dataBlocksPerFile = 0
                     self.numWindows = 0
                     self.processFlags = 0
                     self.coherentInt = 0
                     self.incoherentInt = 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.numHeights = 0
                     self.firstHeight = 0
                     self.deltaHeight = 0
                     self.samplesWin = 0
                     self.spectraComb = 0
                     self.numCode = 0
                     self.code = 0
                     self.numBaud = 0
                     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.blockSize = header['nSizeOfDataBlock'][0]
                         self.profilesPerBlock = header['nProfilesperBlock'][0]
                         self.dataBlocksPerFile = header['nDataBlocksperFile'][0]
                         self.numWindows = header['nNumWindows'][0]
                         self.processFlags = header['nProcessFlags']
                         self.coherentInt = header['nCoherentIntegrations'][0]
                         self.incoherentInt = header['nIncoherentIntegrations'][0]
                         self.totalSpectra = header['nTotalSpectra'][0]
                         self.samplingWindow = numpy.fromfile(fp,self.structSamplingWindow,self.numWindows)
                         self.numHeights = numpy.sum(self.samplingWindow['nsa'])
                         self.firstHeight = self.samplingWindow['h0']
                         self.deltaHeight = self.samplingWindow['dh']
                         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.numCode = numpy.fromfile(fp,'<u4',1)
                             self.numBaud = numpy.fromfile(fp,'<u4',1)
                             self.code = numpy.fromfile(fp,'<f4',self.numCode*self.numBaud).reshape(self.numBaud,self.numCode)
                         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.blockSize,
                                    self.profilesPerBlock,
                                    self.dataBlocksPerFile,
                                    self.numWindows,
                                    self.processFlags,
                                    self.coherentInt,
                                    self.incoherentInt,
                                    self.totalSpectra)
                     header = numpy.array(headerTuple,self.struct)
                     header.tofile(fp)
                     if self.numWindows != 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:
                         numCode = self.numCode
                         numCode.tofile(fp)
                         numBaud = self.numBaud
                         numBaud.tofile(fp)
                         code = self.code.reshape(numCode*numBaud)
                         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)

schainpy/Model/Spectra.py +1 -3

             '''
             Created on Feb 7, 2012
             @author $Author$
             @version $Id$
             '''
-            from JROData import JROData, Noise
+            from JROData import JROData
             from JROHeader import RadarControllerHeader, ProcessingHeader, SystemHeader, BasicHeader
             class Spectra(JROData):
                 '''
                 classdocs
                 '''
                 data_spc = None
                 data_cspc = None
                 data_dc = None
                 nFFTPoints = None
                 nPairs = None
                 pairsList = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.m_RadarControllerHeader = RadarControllerHeader()
                     self.m_ProcessingHeader = ProcessingHeader()
                     self.m_SystemHeader = SystemHeader()
                     self.m_BasicHeader = BasicHeader()
-                    self.m_NoiseObj = Noise()
                     self.type = "Spectra"
                     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
   No newline at end of file

schainpy/Model/Voltage.py +1 -3

             '''
             Created on Feb 7, 2012
             @author $Author$
             @version $Id$
             '''
-            from JROData import JROData, Noise
+            from JROData import JROData
             from JROHeader import RadarControllerHeader, ProcessingHeader, SystemHeader, BasicHeader
             class Voltage(JROData):
                 '''
                 classdocs
                 '''
                 data = None
                 nProfiles = None
                 profileIndex = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.m_RadarControllerHeader = RadarControllerHeader()
                     self.m_ProcessingHeader = ProcessingHeader()
                     self.m_SystemHeader = SystemHeader()
                     self.m_BasicHeader = BasicHeader()
-                    self.m_NoiseObj = Noise()
                     self.type = "Voltage"
                     #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
                     self.data = None
                     self.dataType = None
                     self.nHeights = 0
                     self.nChannels = 0
                     self.channelList = None
                     self.heightList = None
                     self.flagNoData = True
                     self.flagResetProcessing = False
                     self.nAvg = None
                     self.profileIndex = None
                     self.nProfiles = None
   No newline at end of file

schainpy/Processing/JRONoise.py ~~schainpy/Processing/Noise.py~~ renamed +120 -19

             import numpy
             from Model.Spectra import Spectra
-            def hildebrand_sekhon(Data, navg=1):
+            def hildebrand_sekhon(Data, navg):
                 """
                 This method is for the objective determination of de noise level in Doppler spectra. This
                 implementation technique is based on the fact that the standard deviation of the spectral
                 densities is equal to the mean spectral density for white Gaussian noise
                 Inputs:
                     Data    :    heights
                     navg    :    numbers of averages
                 Return:
                     -1        :    any error
                     anoise    :    noise's level
                 """
                 divisor = 8
                 ratio = 7 / divisor
                 data = Data.reshape(-1)
                 npts = data.size #numbers of points of the data
                 if npts < 32:
                     print "error in noise - requires at least 32 points"
                     return -1.0
                 # data sorted in ascending order
                 nmin = int(npts/divisor + ratio);
                 s = 0.0
                 s2 = 0.0
                 data2 = data[:npts]
                 data2.sort()
                 for i in range(nmin):
                     s  += data2[i]
                     s2 += data2[i]**2;
                 icount = nmin
                 iflag = 0
                 for i in range(nmin, npts):
                     s  += data2[i];
                     s2 += data2[i]**2
                     icount=icount+1;
                     p  = s / float(icount);
                     p2 = p**2;
                     q  = s2 / float(icount) - p2;
                     leftc = p2;
                     rightc = q * float(navg);
                     if leftc > rightc:
                         iflag = 1; #No weather signal
                     # Signal detect: R2 < 1 (R2 = leftc/rightc)
                     if(leftc < rightc):
                         if iflag:
                             break
                 anoise = 0.0;
                 for j in range(i):
                     anoise += data2[j];
                 anoise = anoise / float(i);
                 return anoise;
+            def sorting_bruce(Data, navg):
+                sortdata = numpy.sort(Data)
+                lenOfData = len(Data)
+                nums_min = lenOfData/10
+                if (lenOfData/10) > 0:
+                    nums_min = lenOfData/10
+                else:
+                    nums_min = 0
+                rtest = 1.0 + 1.0/navg
+                sum = 0.
+                sumq = 0.
+                j = 0
+                cont = 1
+                while((cont==1)and(j<lenOfData)):
+                    sum += sortdata[j]
+                    sumq += sortdata[j]**2
+                    j += 1
+                    if j > nums_min:
+                        if ((sumq*j) <= (rtest*sum**2)):
+                            lnoise = sum / j
+                        else:
+                            j = j - 1
+                            sum  = sum - sordata[j]
+                            sumq =  sumq - sordata[j]**2
+                            cont = 0
+                    if j == nums_min:
+                        lnoise = sum /j
+                return lnoise
             class Noise:
                 """
                 Clase que implementa los metodos necesarios para deternimar el nivel de ruido en un Spectro Doppler
                 """
-                m_DataObj = None
+                data = None
+                noise = None
+                dim = None
+                def __init__(self, data=None):
+                    """
+                    Inicializador de la clase Noise para la la determinacion del nivel de ruido en un Spectro Doppler.
-                def __init__(self, m_Spectra=None):
+                    Inputs:
+                        data: Numpy array de la forma nChan x nHeis x nProfiles
+                    Affected:
+                        self.noise
+                    Return:
+                        None
+                    """
+                    self.data = data
+                    self.dim = None
+                    self.nChannels = None
+                    self.noise = None
+                def setNoise(self, data):
                     """
                     Inicializador de la clase Noise para la la determinacion del nivel de ruido en un Spectro Doppler.
+                    Inputs:
+                        data: Numpy array de la forma nChan x nHeis x nProfiles
                     Affected:
-                        self.m_DataObj
+                        self.noise
                     Return:
                         None
                     """
-                    if m_Spectra == None:
-                        m_Spectra = Spectra()
-                    if not(isinstance(m_Spectra, Spectra)):
+                    if data == None:
-                        raise ValueError, "in Noise class, m_Spectra must be an Spectra class object"
+                        return 0
+                    shape = data.shape
+                    self.dim = len(shape)
+                    if self.dim == 3:
+                        nChan, nProfiles, nHeis = shape
+                    elif self.dim == 2:
+                        nChan, nHeis = shape
+                    else:
+                        raise ValueError, ""
-                    self.m_DataObj = m_Spectra
+                    self.nChannels = nChan
+                    self.data = data.copy()
+                    self.noise = numpy.zeros(nChan)
+                    return 1
-                def getNoiseLevelByHildebrandSekhon(self):
+                def byHildebrand(self, navg=1):
                     """
                     Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
                     Return:
-                        noise level
+                        noiselevel
                     """
-                    data = self.m_DataObj.data_spc
                     daux = None
-                    for channel in range(self.m_DataObj.nChannels):
+                    for channel in range(self.nChannels):
+                        daux = self.data[channel,:,:]
+                        self.noise[channel] = hildebrand_sekhon(daux, navg)
+                    return self.noise
+                def byWindow(self, heiIndexMin, heiIndexMax, freqIndexMin, freqIndexMax):
+                    """
+                    Determina el ruido del canal utilizando la ventana indicada con las coordenadas:
+                    (heiIndexMIn, freqIndexMin) hasta (heiIndexMax, freqIndexMAx)
+                    Inputs:
+                        heiIndexMin: Limite inferior del eje de alturas
+                        heiIndexMax: Limite superior del eje de alturas
+                        freqIndexMin: Limite inferior del eje de frecuencia
+                        freqIndexMax: Limite supoerior del eje de frecuencia
+                    """
+                    data = self.data[:, heiIndexMin:heiIndexMax, freqIndexMin:freqIndexMax]
+                    for channel in range(self.nChannels):
                         daux = data[channel,:,:]
-                        noiselevel = hildebrand_sekhon(daux)
+                        self.noise[channel] = numpy.average(daux)
-                        print noiselevel
+                    return self.noise
+                def bySort(self,navg = 1):
+                    daux = None
+                    for channel in range(self.nChannels):
+                        daux = self.data[channel,:,:]
+                        self.noise[channel] = sorting_bruce(daux, navg)
+                    return self.noise
-                    for pair in range(self.m_DataObj.nPairs):
+  No newline at end of file
-                        daux = data[pair,:,:]
-                        noiselevel = hildebrand_sekhon(daux)
-                        print noiselevel

schainpy/Processing/SpectraProcessor.py +215 -175

             '''
             Created on Feb 7, 2012
             @author $Author$
             @version $Id$
             '''
             import os, sys
             import numpy
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from Model.Spectra import Spectra
             from IO.SpectraIO import SpectraWriter
             from Graphics.SpectraPlot import Spectrum
+            from JRONoise import Noise
             class SpectraProcessor:
                 '''
                 classdocs
                 '''
                 dataInObj = None
                 dataOutObj = None
-                integratorObjIndex = None
+                noiseObj = None
-                decoderObjIndex = None
-                writerObjIndex = None
-                plotterObjIndex = None
                 integratorObjList = []
                 decoderObjList = []
                 writerObjList = []
                 plotterObjList = []
+                integratorObjIndex = None
+                decoderObjIndex = None
+                writerObjIndex = None
+                plotterObjIndex = None
                 buffer = None
-                ptsId = 0
+                profIndex = 0
                 nFFTPoints = None
+                nChannels = None
+                nHeights = None
+                nPairs = None
                 pairList = None
-                def __init__(self, dataInObj=None, dataOutObj=None):
+                def __init__(self):
                     '''
                     Constructor
                     '''
-                    self.dataInObj = dataInObj
-                    if dataOutObj == None:
-                        self.dataOutObj = Spectra()
-                    else:
-                        self.dataOutObj = dataOutObj
                     self.integratorObjIndex = None
                     self.decoderObjIndex = None
                     self.writerObjIndex = None
                     self.plotterObjIndex = None
                     self.integratorObjList = []
                     self.decoderObjList = []
                     self.writerObjList = []
                     self.plotterObjList = []
+                    self.noiseObj = Noise()
                     self.buffer = None
-                    self.ptsId = 0
+                    self.profIndex = 0
-                def setIO(self,inputObject, outputObject):
-            #        if not( isinstance(inputObject, Voltage) ):
-            #            print 'InputObject must be an instance from Voltage()'
-            #            sys.exit(0)
-                    if not( isinstance(outputObject, Spectra) ):
+                def setup(self, dataInObj=None, dataOutObj=None, nFFTPoints=None, pairList=None):
-                        print 'OutputObject must be an instance from Spectra()'
-                        sys.exit(0)
-                    self.dataInObj = inputObject
+                    if dataInObj == None:
-                    self.dataOutObj = outputObject
+                        raise ValueError, ""
-                def setup(self,nFFTPoints=None, pairList=None):
                     if nFFTPoints == None:
-                        nFFTPoints = self.dataOutObj.nFFTPoints
+                        raise ValueError, ""
+                    self.dataInObj = dataInObj
+                    if dataOutObj == None:
+                        dataOutObj = Spectra()
+                    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.channelIndexList = self.dataInObj.channelIndexList
+                    self.dataOutObj.m_BasicHeader = self.dataInObj.m_BasicHeader.copy()
+                    self.dataOutObj.m_ProcessingHeader = self.dataInObj.m_ProcessingHeader.copy()
+                    self.dataOutObj.m_RadarControllerHeader = self.dataInObj.m_RadarControllerHeader.copy()
+                    self.dataOutObj.m_SystemHeader = self.dataInObj.m_SystemHeader.copy()
+                    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.m_SystemHeader.nProfiles = self.nFFTPoints
+                    self.dataOutObj.m_ProcessingHeader.totalSpectra = self.nChannels + self.nPairs
+                    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'))
+                    k = 0
+                    for i in range( 0,self.nChannels*2,2 ):
+                        spectraComb[i]   = k
+                        spectraComb[i+1] = k
+                        k += 1
+                    k *= 2
+                    if self.pairList != None:
+                        for pair in self.pairList:
+                            spectraComb[k]   = pair[0]
+                            spectraComb[k+1] = pair[1]
+                            k += 2
+                    self.dataOutObj.m_ProcessingHeader.spectraComb = spectraComb
+                    return self.dataOutObj
-            #    def init(self, nFFTPoints, pairList=None):
                 def init(self):
                     self.integratorObjIndex = 0
                     self.decoderObjIndex = 0
                     self.writerObjIndex = 0
                     self.plotterObjIndex = 0
-            #        if nFFTPoints == None:
+                    if self.dataInObj.type == "Voltage":
-            #            nFFTPoints = self.dataOutObj.nFFTPoints
+                        if self.buffer == None:
-            #        self.nFFTPoints = nFFTPoints
+                            self.buffer = numpy.zeros((self.nChannels,
-            #        self.pairList = pairList
+                                                       self.nFFTPoints,
+                                                       self.nHeights),
-                    if not( isinstance(self.dataInObj, Spectra) ):
+                                                      dtype='complex')
-                        self.__getFft()
-                    else:
+                        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"
                 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.m_SystemHeader
-                        self.ptsId
+                        self.profIndex
                         self.buffer
                         self.dataOutObj.flagNoData
                         self.dataOutObj.dataType
                         self.dataOutObj.nPairs
                         self.dataOutObj.nChannels
                         self.dataOutObj.nProfiles
                         self.dataOutObj.m_SystemHeader.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
-                    blocksize = 0
-                    nFFTPoints = self.nFFTPoints
-                    nChannels, nheis = self.dataInObj.data.shape
-                    if self.buffer == None:
-                        self.buffer = numpy.zeros((nChannels, nFFTPoints, nheis), dtype='complex')
-                    self.buffer[:,self.ptsId,:] = self.dataInObj.data
-                    self.ptsId += 1
-                    if self.ptsId < self.nFFTPoints:
-                        self.dataOutObj.flagNoData = True
-                        return
                     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 = numpy.abs(fft_volt * numpy.conjugate(fft_volt))
+                    blocksize = 0
                     blocksize += dc.size
                     blocksize += spc.size
                     cspc = None
-                    nPair = 0
+                    pairIndex = 0
                     if self.pairList != None:
                         #calculo de cross-spectra
-                        nPairs = len(self.pairList)
+                        cspc = numpy.zeros((self.nPairs, self.nFFTPoints, self.nHeights), dtype='complex')
-                        cspc = numpy.zeros((nPairs, nFFTPoints, nheis), dtype='complex')
                         for pair in self.pairList:
-                            cspc[nPair,:,:] = numpy.abs(fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:]))
+                            cspc[pairIndex,:,:] = numpy.abs(fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:]))
-                            nPair += 1
+                            pairIndex += 1
                         blocksize += cspc.size
                     self.dataOutObj.data_spc = spc
                     self.dataOutObj.data_cspc = cspc
                     self.dataOutObj.data_dc = dc
-                    self.ptsId = 0
-                    self.buffer = None
-                    self.dataOutObj.flagNoData = False
-                    self.dataOutObj.heightList = self.dataInObj.heightList
-                    self.dataOutObj.channelList = self.dataInObj.channelList
-                    self.dataOutObj.m_BasicHeader = self.dataInObj.m_BasicHeader.copy()
-                    self.dataOutObj.m_ProcessingHeader = self.dataInObj.m_ProcessingHeader.copy()
-                    self.dataOutObj.m_RadarControllerHeader = self.dataInObj.m_RadarControllerHeader.copy()
-                    self.dataOutObj.m_SystemHeader = self.dataInObj.m_SystemHeader.copy()
-                    self.dataOutObj.dataType = self.dataInObj.dataType
-                    self.dataOutObj.nPairs = nPair
-                    self.dataOutObj.nChannels = nChannels
-                    self.dataOutObj.nProfiles = nFFTPoints
-                    self.dataOutObj.nHeights = nheis
-                    self.dataOutObj.nFFTPoints = nFFTPoints
-                    #self.dataOutObj.data = None
-                    self.dataOutObj.m_SystemHeader.numChannels = nChannels
-                    self.dataOutObj.m_SystemHeader.nProfiles = nFFTPoints
                     self.dataOutObj.m_ProcessingHeader.blockSize = blocksize
-                    self.dataOutObj.m_ProcessingHeader.totalSpectra = nChannels + nPair
-                    self.dataOutObj.m_ProcessingHeader.profilesPerBlock = nFFTPoints
-                    self.dataOutObj.m_ProcessingHeader.numHeights = nheis
-                    self.dataOutObj.m_ProcessingHeader.shif_fft = True
-                    spectraComb = numpy.zeros( (nChannels+nPair)*2,numpy.dtype('u1'))
-                    k = 0
-                    for i in range( 0,nChannels*2,2 ):
-                        spectraComb[i]   = k
-                        spectraComb[i+1] = k
-                        k += 1
-                    k *= 2
-                    if self.pairList != None:
-                        for pair in self.pairList:
-                            spectraComb[k]   = pair[0]
-                            spectraComb[k+1] = pair[1]
-                            k += 2
-                    self.dataOutObj.m_ProcessingHeader.spectraComb = spectraComb
                 def addWriter(self,wrpath):
                     objWriter = SpectraWriter(self.dataOutObj)
                     objWriter.setup(wrpath)
                     self.writerObjList.append(objWriter)
                 def addPlotter(self, index=None):
                     if index==None:
                         index = self.plotterObjIndex
                     plotObj = Spectrum(self.dataOutObj, index)
                     self.plotterObjList.append(plotObj)
                 def addIntegrator(self,N,timeInterval):
                     objIncohInt = IncoherentIntegration(N,timeInterval)
                     self.integratorObjList.append(objIncohInt)
                 def writeData(self, wrpath):
                     if self.dataOutObj.flagNoData:
                             return 0
                     if len(self.writerObjList) <= self.writerObjIndex:
                         self.addWriter(wrpath)
                     self.writerObjList[self.writerObjIndex].putData()
                     self.writerObjIndex += 1
                 def plotData(self,xmin=None, xmax=None, ymin=None, ymax=None, winTitle='', index=None):
                     if self.dataOutObj.flagNoData:
                         return 0
                     if len(self.plotterObjList) <= self.plotterObjIndex:
                         self.addPlotter(index)
                     self.plotterObjList[self.plotterObjIndex].plotData(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,winTitle=winTitle)
                     self.plotterObjIndex += 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 *= 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
+                    """Calcular el ruido"""
+            #        self.getNoise(type="hildebrand", parm=1)
                 def removeDC(self, type):
                     if self.dataOutObj.flagNoData:
                         return 0
-                    pass
                 def removeInterference(self):
                     if self.dataOutObj.flagNoData:
                         return 0
-                    pass
                 def removeSatellites(self):
                     if self.dataOutObj.flagNoData:
                         return 0
-                    pass
-                def selectChannels(self, channelList, pairList=None):
+                def getNoise(self, type="hildebrand", parm=None):
+                    self.noiseObj.setNoise(self.dataOutObj.data_spc)
+                    if type == "hildebrand":
+                        noise = self.noiseObj.byHildebrand(parm)
+                    if type == "window":
+                        noise = self.noiseObj.byWindow(parm)
+                    if type == "sort":
+                        noise = self.noiseObj.bySort(parm)
+                    self.dataOutObj.noise = noise
+                    print 10*numpy.log10(noise)
+                def selectChannels(self, channelList, pairList=[]):
+                    channelIndexList = []
+                    for channel in channelList:
+                        if channel in self.dataOutObj.channelList:
+                            index = self.dataOutObj.channelList.index(channel)
+                            channelIndexList.append(index)
+                    pairIndexList = []
+                    for pair in pairList:
+                        if pair in self.dataOutObj.pairList:
+                            index = self.dataOutObj.pairList.index(pair)
+                            pairIndexList.append(index)
+                    self.selectChannelsByIndex(channelIndexList, pairIndexList)
+                def selectChannelsByIndex(self, channelIndexList, pairIndexList=[]):
                     """
-                    Selecciona un bloque de datos en base a canales y pares segun el channelList y el pairList
+                    Selecciona un bloque de datos en base a canales y pares segun el
+                    channelIndexList y el pairIndexList
                     Input:
-                        channelList    :    lista sencilla de canales a seleccionar por ej. (2,3,7)
+                        channelIndexList :    lista de indices de los canales a seleccionar por ej.
-                        pairList       :    tupla de pares que se desea selecionar por ej. ( (0,1), (0,2) )
+                                                 Si tenemos los canales
+                                                         self.channelList = (2,3,5,7)
+                                                y deseamos escoger los canales (3,7)
+                                                entonces colocaremos el parametro
+                                                        channelndexList = (1,3)
+                        pairIndexList   :    tupla de indice depares que se desea selecionar por ej.
+                                                Si tenemos los pares :
+                                                        ( (0,1), (0,2), (1,3), (2,5) )
+                                                y deseamos seleccionar los pares ((0,2), (2,5))
+                                                entonces colocaremos el parametro
+                                                        pairIndexList = (1,3)
                     Affected:
                         self.dataOutObj.data_spc
                         self.dataOutObj.data_cspc
                         self.dataOutObj.data_dc
                         self.dataOutObj.nChannels
                         self.dataOutObj.nPairs
                         self.dataOutObj.m_ProcessingHeader.spectraComb
                         self.dataOutObj.m_SystemHeader.numChannels
+                        self.dataOutObj.noise
                     Return:
                         None
                     """
                     if self.dataOutObj.flagNoData:
                         return 0
-                    channelIndexList = []
+                    if pairIndexList == []:
-                    for channel in channelList:
+                        pairIndexList = numpy.arange(len(self.dataOutObj.pairList))
-                        if channel in self.dataOutObj.channelList:
-                            index = self.dataOutObj.channelList.index(channel)
-                            channelIndexList.append(index)
-                            continue
-                        raise ValueError, "The value %d in channelList is not valid" %channel
-                    nProfiles = self.dataOutObj.nProfiles
-                    #dataType = self.dataOutObj.dataType
-                    nHeights  = self.dataOutObj.nHeights #m_ProcessingHeader.numHeights
-                    blocksize = 0
-                    #self spectra
                     nChannels = len(channelIndexList)
-                    spc = numpy.zeros( (nChannels,nProfiles,nHeights), dtype='float' ) #dataType[0] )
+                    nPairs = len(pairIndexList)
-                    for index, channel in enumerate(channelIndexList):
-                        spc[index,:,:] = self.dataOutObj.data_spc[index,:,:]
-                    #DC channel
+                    blocksize = 0
-                    dc = numpy.zeros( (nChannels,nHeights), dtype='complex' )
+                    #self spectra
-                    for index, channel in enumerate(channelIndexList):
+                    spc = self.dataOutObj.data_spc[channelIndexList,:,:]
-                        dc[index,:] = self.dataOutObj.data_dc[channel,:]
-                    blocksize += dc.size
                     blocksize += spc.size
-                    nPairs = 0
-                    cspc = None
-                    if pairList == None:
+                    cspc = None
-                        pairList = self.pairList
+                    if pairIndexList != []:
+                        cspc = self.dataOutObj.data_cspc[pairIndexList,:,:]
-                    if (pairList != None) and (self.dataOutObj.data_cspc != None):
-                        #cross spectra
-                        nPairs = len(pairList)
-                        cspc = numpy.zeros( (nPairs,nProfiles,nHeights), dtype='complex' )
-                        spectraComb = self.dataOutObj.m_ProcessingHeader.spectraComb
-                        totalSpectra = len(spectraComb)
-                        nchan = self.dataOutObj.nChannels
-                        pairIndexList = []
-                        for pair in pairList: #busco el par en la lista de pares del Spectra Combinations
-                            for index in range(0,totalSpectra,2):
-                                if pair[0] == spectraComb[index] and pair[1] == spectraComb[index+1]:
-                                    pairIndexList.append( index/2 - nchan )
-                        for index, pair in enumerate(pairIndexList):
-                            cspc[index,:,:] = self.dataOutObj.data_cspc[pair,:,:]
                         blocksize += cspc.size
-                    else:
-                        pairList = self.pairList
-                        cspc = self.dataOutObj.data_cspc
-                        if cspc != None:
-                            blocksize += cspc.size
+                    #DC channel
+                    dc = None
+                    if self.dataOutObj.m_ProcessingHeader.flag_dc:
+                        dc = self.dataOutObj.data_dc[channelIndexList,:]
+                        blocksize += dc.size
+                    #Almacenar las combinaciones de canales y cros espectros
                     spectraComb = numpy.zeros( (nChannels+nPairs)*2,numpy.dtype('u1'))
                     i = 0
-                    for val in channelList:
+                    for spcChannel in channelIndexList:
-                        spectraComb[i]   = val
+                        spectraComb[i]   = spcChannel
-                        spectraComb[i+1] = val
+                        spectraComb[i+1] = spcChannel
                         i += 2
                     if pairList != None:
                         for pair in pairList:
                             spectraComb[i]   = pair[0]
                             spectraComb[i+1] = pair[1]
                             i += 2
+                    #######
                     self.dataOutObj.data_spc = spc
                     self.dataOutObj.data_cspc = cspc
                     self.dataOutObj.data_dc = dc
                     self.dataOutObj.nChannels = nChannels
                     self.dataOutObj.nPairs = nPairs
-                    self.dataOutObj.channelList = channelList
+                    self.dataOutObj.channelIndexList = channelIndexList
                     self.dataOutObj.m_ProcessingHeader.spectraComb = spectraComb
                     self.dataOutObj.m_ProcessingHeader.totalSpectra = nChannels + nPairs
                     self.dataOutObj.m_SystemHeader.numChannels = nChannels
                     self.dataOutObj.nChannels = nChannels
                     self.dataOutObj.m_ProcessingHeader.blockSize = blocksize
+                    if cspc == None:
+                        self.dataOutObj.m_ProcessingHeader.flag_dc = False
+                    if dc == None:
+                        self.dataOutObj.m_ProcessingHeader.flag_cpsc = False
                 def selectHeightsByValue(self, minHei, maxHei):
                     """
                     Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
                     minHei <= height <= maxHei
                     Input:
                         minHei    :    valor minimo de altura a considerar
                         maxHei    :    valor maximo de altura a considerar
                     Affected:
                         Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
                     Return:
                         None
                     """
                     if self.dataOutObj.flagNoData:
                         return 0
                     if (minHei < self.dataOutObj.heightList[0]) or (minHei > maxHei):
                         raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
                     if (maxHei > self.dataOutObj.heightList[-1]):
                         raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
                     minIndex = 0
                     maxIndex = 0
                     data = self.dataOutObj.heightList
                     for i,val in enumerate(data):
                         if val < minHei:
                             continue
                         else:
                             minIndex = i;
                             break
                     for i,val in enumerate(data):
                         if val <= maxHei:
                             maxIndex = i;
                         else:
                             break
                     self.selectHeightsByIndex(minIndex, maxIndex)
                 def selectHeightsByIndex(self, minIndex, maxIndex):
                     """
                     Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
                     minIndex <= index <= maxIndex
                     Input:
                         minIndex    :    valor minimo de altura a considerar
                         maxIndex    :    valor maximo de altura a considerar
                     Affected:
                         self.dataOutObj.data_spc
                         self.dataOutObj.data_cspc
                         self.dataOutObj.data_dc
                         self.dataOutObj.heightList
                         self.dataOutObj.nHeights
                         self.dataOutObj.m_ProcessingHeader.numHeights
                         self.dataOutObj.m_ProcessingHeader.blockSize
                         self.dataOutObj.m_ProcessingHeader.firstHeight
                         self.dataOutObj.m_RadarControllerHeader.numHeights
                     Return:
                         None
                     """
                     if self.dataOutObj.flagNoData:
                         return 0
                     if (minIndex < 0) or (minIndex > maxIndex):
                         raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
                     if (maxIndex >= self.dataOutObj.nHeights):
                         raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
                     nChannels = self.dataOutObj.nChannels
                     nPairs = self.dataOutObj.nPairs
                     nProfiles = self.dataOutObj.nProfiles
                     dataType = self.dataOutObj.dataType
                     nHeights = maxIndex - minIndex + 1
                     blockSize = 0
                     #self spectra
                     spc = self.dataOutObj.data_spc[:,:,minIndex:maxIndex+1]
                     blockSize += spc.size
                     #cross spectra
                     cspc = None
                     if self.dataOutObj.data_cspc != None:
                         cspc = self.dataOutObj.data_cspc[:,:,minIndex:maxIndex+1]
                         blockSize += cspc.size
                     #DC channel
                     dc = self.dataOutObj.data_dc[:,minIndex:maxIndex+1]
                     blockSize += dc.size
                     self.dataOutObj.data_spc = spc
                     if cspc != None:
                         self.dataOutObj.data_cspc = cspc
                     self.dataOutObj.data_dc = dc
                     firstHeight = self.dataOutObj.heightList[minIndex]
                     self.dataOutObj.nHeights = nHeights
                     self.dataOutObj.m_ProcessingHeader.blockSize = blockSize
                     self.dataOutObj.m_ProcessingHeader.numHeights = nHeights
                     self.dataOutObj.m_ProcessingHeader.firstHeight = firstHeight
                     self.dataOutObj.m_RadarControllerHeader.numHeights = nHeights
                     self.dataOutObj.heightList = self.dataOutObj.heightList[minIndex:maxIndex+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

schainpy/Processing/VoltageProcessor.py +25 -31

             '''
             Created on Feb 7, 2012
             @author $Author$
             @version $Id$
             '''
             import os, sys
             import numpy
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from Model.Voltage import Voltage
             from IO.VoltageIO import VoltageWriter
             from Graphics.VoltagePlot import Osciloscope
             class VoltageProcessor:
                 '''
                 classdocs
                 '''
                 dataInObj = None
                 dataOutObj = None
                 integratorObjIndex = None
                 decoderObjIndex = None
                 profSelectorObjIndex = None
                 writerObjIndex = None
                 plotterObjIndex = None
                 flipIndex = None
                 integratorObjList = []
                 decoderObjList = []
                 profileSelectorObjList = []
                 writerObjList = []
                 plotterObjList = []
                 m_Voltage= Voltage()
-                def __init__(self, dataInObj=None, dataOutObj=None):
+                def __init__(self):
                     '''
                     Constructor
                     '''
-                    self.dataInObj = dataInObj
-                    if dataOutObj == None:
-                        self.dataOutObj = Voltage()
-                    else:
-                        self.dataOutObj = dataOutObj
                     self.integratorObjIndex = None
                     self.decoderObjIndex = None
                     self.profSelectorObjIndex = None
                     self.writerObjIndex = None
                     self.plotterObjIndex = None
                     self.flipIndex = 1
                     self.integratorObjList = []
                     self.decoderObjList = []
                     self.profileSelectorObjList = []
                     self.writerObjList = []
                     self.plotterObjList = []
-                def setIO(self,inputObject, outputObject):
-                    if not( isinstance(inputObject, Voltage) ):
+                def setup(self, dataInObj=None, dataOutObj=None):
-                        print 'InputObject must be an instance from Voltage()'
-                        sys.exit(0)
-                    if not( isinstance(outputObject, Voltage) ):
+                    self.dataInObj = dataInObj
-                        print 'OutputObject must be an instance from Voltage()'
-                        sys.exit(0)
+                    if dataOutObj == None:
+                        dataOutObj = Voltage()
-                    self.dataInObj = inputObject
+                    dataOutObj.copy(dataInObj)
-                    self.dataOutObj = outputObject
+                    self.dataOutObj = dataOutObj
+                    return self.dataOutObj
-                def setup(self):
-                    pass
                 def init(self):
                     self.integratorObjIndex = 0
                     self.decoderObjIndex = 0
                     self.profSelectorObjIndex = 0
                     self.writerObjIndex = 0
                     self.plotterObjIndex = 0
                     self.dataOutObj.copy(self.dataInObj)
                     if self.profSelectorObjIndex != None:
                         for profSelObj in self.profileSelectorObjList:
                             profSelObj.incIndex()
                 def addWriter(self, wrpath):
                     objWriter = VoltageWriter(self.dataOutObj)
                     objWriter.setup(wrpath)
                     self.writerObjList.append(objWriter)
                 def addPlotter(self, index=None):
                     if index==None:
                         index = self.plotterObjIndex
                     plotObj = Osciloscope(self.dataOutObj, index)
                     self.plotterObjList.append(plotObj)
                 def addIntegrator(self, N,timeInterval):
                     objCohInt = CoherentIntegrator(N,timeInterval)
                     self.integratorObjList.append(objCohInt)
                 def addDecoder(self, code, ncode, nbaud):
                     objDecoder = Decoder(code,ncode,nbaud)
                     self.decoderObjList.append(objDecoder)
                 def addProfileSelector(self, nProfiles):
                     objProfSelector = ProfileSelector(nProfiles)
                     self.profileSelectorObjList.append(objProfSelector)
                 def writeData(self,wrpath):
                     if self.dataOutObj.flagNoData:
                         return 0
                     if len(self.writerObjList) <= self.writerObjIndex:
                         self.addWriter(wrpath)
                     self.writerObjList[self.writerObjIndex].putData()
             #        myWrObj = self.writerObjList[self.writerObjIndex]
             #        myWrObj.putData()
                     self.writerObjIndex += 1
                 def plotData(self,xmin=None, xmax=None, ymin=None, ymax=None, type='iq', winTitle='', index=None):
                     if self.dataOutObj.flagNoData:
                         return 0
                     if len(self.plotterObjList) <= self.plotterObjIndex:
                         self.addPlotter(index)
                     self.plotterObjList[self.plotterObjIndex].plotData(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,type=type, winTitle=winTitle)
                     self.plotterObjIndex += 1
                 def integrator(self, N=None, timeInterval=None):
                     if self.dataOutObj.flagNoData:
                         return 0
                     if len(self.integratorObjList) <= self.integratorObjIndex:
                         self.addIntegrator(N,timeInterval)
                     myCohIntObj = self.integratorObjList[self.integratorObjIndex]
                     myCohIntObj.exe(data=self.dataOutObj.data,timeOfData=self.dataOutObj.m_BasicHeader.utc)
                     if myCohIntObj.isReady:
                         self.dataOutObj.data = myCohIntObj.data
                         self.dataOutObj.nAvg = myCohIntObj.navg
                         self.dataOutObj.m_ProcessingHeader.coherentInt *= myCohIntObj.navg
                         #print "myCohIntObj.navg: ",myCohIntObj.navg
                         self.dataOutObj.flagNoData = False
                     else:
                         self.dataOutObj.flagNoData = True
                     self.integratorObjIndex += 1
                 def decoder(self,code=None,type = 0):
                     if self.dataOutObj.flagNoData:
                         return 0
                     if code == None:
                         code = self.dataOutObj.m_RadarControllerHeader.code
                     ncode, nbaud = code.shape
                     if len(self.decoderObjList) <= self.decoderObjIndex:
                         self.addDecoder(code,ncode,nbaud)
                     myDecodObj = self.decoderObjList[self.decoderObjIndex]
                     myDecodObj.exe(data=self.dataOutObj.data,type=type)
                     if myDecodObj.flag:
                         self.dataOutObj.data = myDecodObj.data
                         self.dataOutObj.flagNoData = False
                     else:
                         self.dataOutObj.flagNoData = True
                     self.decoderObjIndex += 1
                 def filterByHei(self, window):
                     if window == None:
                         window = self.dataOutObj.m_RadarControllerHeader.txA / self.dataOutObj.m_ProcessingHeader.deltaHeight[0]
                     newdelta = self.dataOutObj.m_ProcessingHeader.deltaHeight[0] * window
                     dim1 = self.dataOutObj.data.shape[0]
                     dim2 = self.dataOutObj.data.shape[1]
                     r = dim2 % window
                     buffer = self.dataOutObj.data[:,0:dim2-r]
                     buffer = buffer.reshape(dim1,dim2/window,window)
                     buffer = numpy.sum(buffer,2)
                     self.dataOutObj.data = buffer
                     self.dataOutObj.m_ProcessingHeader.deltaHeight = newdelta
                     self.dataOutObj.m_ProcessingHeader.numHeights = buffer.shape[1]
                     self.dataOutObj.nHeights = self.dataOutObj.m_ProcessingHeader.numHeights
                     #self.dataOutObj.heightList es un numpy.array
                     self.dataOutObj.heightList = numpy.arange(self.dataOutObj.m_ProcessingHeader.firstHeight[0],newdelta*self.dataOutObj.nHeights,newdelta)
                 def deFlip(self):
                     self.dataOutObj.data *= self.flipIndex
                     self.flipIndex *= -1.
                 def selectChannels(self, channelList):
+                    pass
+                def selectChannelsByIndex(self, channelIndexList):
                     """
-                    Selecciona un bloque de datos en base a canales segun el channelList
+                    Selecciona un bloque de datos en base a canales segun el channelIndexList
                     Input:
-                        channelList    :    lista sencilla de canales a seleccionar por ej. [2,3,7]
+                        channelIndexList    :    lista sencilla de canales a seleccionar por ej. [2,3,7]
                     Affected:
                         self.dataOutObj.data
-                        self.dataOutObj.channelList
+                        self.dataOutObj.channelIndexList
                         self.dataOutObj.nChannels
                         self.dataOutObj.m_ProcessingHeader.totalSpectra
                         self.dataOutObj.m_SystemHeader.numChannels
                         self.dataOutObj.m_ProcessingHeader.blockSize
                     Return:
                         None
                     """
                     if self.dataOutObj.flagNoData:
                         return 0
-                    for channel in channelList:
+                    for channel in channelIndexList:
-                        if channel not in self.dataOutObj.channelList:
+                        if channel not in self.dataOutObj.channelIndexList:
-                            raise ValueError, "The value %d in channelList is not valid" %channel
+                            raise ValueError, "The value %d in channelIndexList is not valid" %channel
-                    nChannels = len(channelList)
+                    nChannels = len(channelIndexList)
-                    data = self.dataOutObj.data[channelList,:]
+                    data = self.dataOutObj.data[channelIndexList,:]
                     self.dataOutObj.data = data
-                    self.dataOutObj.channelList = channelList
+                    self.dataOutObj.channelIndexList = channelIndexList
                     self.dataOutObj.nChannels = nChannels
-                    self.dataOutObj.m_ProcessingHeader.totalSpectra = nChannels
+                    self.dataOutObj.m_ProcessingHeader.totalSpectra = 0
                     self.dataOutObj.m_SystemHeader.numChannels = nChannels
                     self.dataOutObj.m_ProcessingHeader.blockSize = data.size
                     return 1
                 def selectHeightsByValue(self, minHei, maxHei):
                     """
                     Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
                     minHei <= height <= maxHei
                     Input:
                         minHei    :    valor minimo de altura a considerar
                         maxHei    :    valor maximo de altura a considerar
                     Affected:
                         Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
                     Return:
 si el metodo se ejecuto con exito caso contrario devuelve 0
                     """
                     if self.dataOutObj.flagNoData:
                         return 0
                     if (minHei < self.dataOutObj.heightList[0]) or (minHei > maxHei):
                         raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
                     if (maxHei > self.dataOutObj.heightList[-1]):
                         raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
                     minIndex = 0
                     maxIndex = 0
                     data = self.dataOutObj.heightList
                     for i,val in enumerate(data):
                         if val < minHei:
                             continue
                         else:
                             minIndex = i;
                             break
                     for i,val in enumerate(data):
                         if val <= maxHei:
                             maxIndex = i;
                         else:
                             break
                     self.selectHeightsByIndex(minIndex, maxIndex)
                     return 1
                 def selectHeightsByIndex(self, minIndex, maxIndex):
                     """
                     Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
                     minIndex <= index <= maxIndex
                     Input:
                         minIndex    :    valor de indice minimo de altura a considerar
                         maxIndex    :    valor de indice maximo de altura a considerar
                     Affected:
                         self.dataOutObj.data
                         self.dataOutObj.heightList
                         self.dataOutObj.nHeights
                         self.dataOutObj.m_ProcessingHeader.blockSize
                         self.dataOutObj.m_ProcessingHeader.numHeights
                         self.dataOutObj.m_ProcessingHeader.firstHeight
                         self.dataOutObj.m_RadarControllerHeader
                     Return:
 si el metodo se ejecuto con exito caso contrario devuelve 0
                     """
                     if self.dataOutObj.flagNoData:
                         return 0
                     if (minIndex < 0) or (minIndex > maxIndex):
                         raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
                     if (maxIndex >= self.dataOutObj.nHeights):
                         raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
                     nHeights = maxIndex - minIndex + 1
                     #voltage
                     data = self.dataOutObj.data[:,minIndex:maxIndex+1]
                     firstHeight = self.dataOutObj.heightList[minIndex]
                     self.dataOutObj.data = data
                     self.dataOutObj.heightList = self.dataOutObj.heightList[minIndex:maxIndex+1]
                     self.dataOutObj.nHeights = nHeights
                     self.dataOutObj.m_ProcessingHeader.blockSize = data.size
                     self.dataOutObj.m_ProcessingHeader.numHeights = nHeights
                     self.dataOutObj.m_ProcessingHeader.firstHeight = firstHeight
                     self.dataOutObj.m_RadarControllerHeader.numHeights = nHeights
                     return 1
                 def selectProfilesByValue(self,indexList, nProfiles):
                     if self.dataOutObj.flagNoData:
                         return 0
                     if self.profSelectorObjIndex >= len(self.profileSelectorObjList):
                         self.addProfileSelector(nProfiles)
                     profileSelectorObj = self.profileSelectorObjList[self.profSelectorObjIndex]
                     if not(profileSelectorObj.isProfileInList(indexList)):
                         self.dataOutObj.flagNoData = True
                         self.profSelectorObjIndex += 1
                         return 0
                     self.dataOutObj.flagNoData = False
                     self.profSelectorObjIndex += 1
                     return 1
                 def selectProfilesByIndex(self, minIndex, maxIndex, nProfiles):
                     """
                     Selecciona un bloque de datos en base a un grupo indices de perfiles segun el rango
                     minIndex <= index <= maxIndex
                     Input:
                         minIndex    :    valor de indice minimo de perfil a considerar
                         maxIndex    :    valor de indice maximo de perfil a considerar
                         nProfiles   :    numero de profiles
                     Affected:
                         self.dataOutObj.flagNoData
                         self.profSelectorObjIndex
                     Return:
 si el metodo se ejecuto con exito caso contrario devuelve 0
                     """
                     if self.dataOutObj.flagNoData:
                         return 0
                     if self.profSelectorObjIndex >= len(self.profileSelectorObjList):
                         self.addProfileSelector(nProfiles)
                     profileSelectorObj = self.profileSelectorObjList[self.profSelectorObjIndex]
                     if not(profileSelectorObj.isProfileInRange(minIndex, maxIndex)):
                         self.dataOutObj.flagNoData = True
                         self.profSelectorObjIndex += 1
                         return 0
                     self.dataOutObj.flagNoData = False
                     self.profSelectorObjIndex += 1
                     return 1
                 def selectNtxs(self, ntx):
                     pass
             class Decoder:
                 data = None
                 profCounter = 1
                 nCode = None
                 nBaud = None
                 codeIndex = 0
                 code = None
                 flag = False
                 def __init__(self,code, ncode, nbaud):
                     self.data = None
                     self.profCounter = 1
                     self.nCode = ncode
                     self.nBaud = nbaud
                     self.codeIndex = 0
                     self.code = code #this is a List
                     self.flag = False
                 def exe(self, data, ndata=None, type = 0):
                     if ndata == None: ndata = data.shape[1]
                     if type == 0:
                         self.convolutionInFreq(data,ndata)
                     if type == 1:
                         self.convolutionInTime(data, ndata)
                 def convolutionInFreq(self,data, ndata):
                     newcode = numpy.zeros(ndata)
                     newcode[0:self.nBaud] = self.code[self.codeIndex]
                     self.codeIndex += 1
                     fft_data = numpy.fft.fft(data, axis=1)
                     fft_code = numpy.conj(numpy.fft.fft(newcode))
                     fft_code = fft_code.reshape(1,len(fft_code))
                     conv = fft_data.copy()
                     conv.fill(0)
                     conv = fft_data*fft_code
                     self.data = numpy.fft.ifft(conv,axis=1)
                     self.flag = True
                     if self.profCounter == self.nCode:
                         self.profCounter = 0
                         self.codeIndex = 0
                     self.profCounter += 1
                 def convolutionInTime(self, data, ndata):
                     nchannel = data.shape[1]
                     newcode = self.code[self.codeIndex]
                     self.codeIndex += 1
                     conv = data.copy()
                     for i in range(nchannel):
                         conv[i,:] = numpy.correlate(data[i,:], newcode, 'same')
                     self.data = conv
                     self.flag = True
                     if self.profCounter == self.nCode:
                         self.profCounter = 0
                         self.codeIndex = 0
                     self.profCounter += 1
             class CoherentIntegrator:
                 integ_counter = None
                 data = None
                 navg = None
                 buffer = None
                 nCohInt = None
                 def __init__(self, N=None,timeInterval=None):
                     self.data = None
                     self.navg = None
                     self.buffer = None
                     self.timeOut = None
                     self.exitCondition = False
                     self.isReady = False
                     self.nCohInt = 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):
                     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.nCohInt:
                             if self.buffer == None:
                                 self.buffer = data
                             else:
                                 self.buffer = self.buffer + data
                             self.integ_counter += 1
                         if self.integ_counter == self.nCohInt:
                             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
             class ProfileSelector:
                 profileIndex = None
                 # Tamanho total de los perfiles
                 nProfiles = None
                 def __init__(self, nProfiles):
                     self.profileIndex = 0
                     self.nProfiles = nProfiles
                 def incIndex(self):
                     self.profileIndex += 1
                     if self.profileIndex >= self.nProfiles:
                         self.profileIndex = 0
                 def isProfileInRange(self, minIndex, maxIndex):
                     if self.profileIndex < minIndex:
                         return False
                     if self.profileIndex > maxIndex:
                         return False
                     return True
                 def isProfileInList(self, profileList):
                     if self.profileIndex not in profileList:
                         return False
                     return True
   No newline at end of file

schainpy/TestSVoltageChain.py +39 -21

             '''
             Created on 27/03/2012
             @author $Author$
             @version $Id$
             '''
             import os, sys
             import time, datetime
             from Model.Voltage import Voltage
             from IO.VoltageIO import *
             #from Graphics.VoltagePlot import Osciloscope
             from Model.Spectra import Spectra
             from IO.SpectraIO import *
             from Processing.VoltageProcessor import *
             from Processing.SpectraProcessor import *
             class TestSChain():
                 def __init__(self):
                     self.setValues()
                     self.createObjects()
                     self.testSChain()
                 def setValues( self ):
                     self.path = "/home/dsuarez/Projects"  #1
                     self.path = "/Users/jro/Documents/RadarData/EW_Drifts"
-            #        self.path = "/Users/jro/Documents/RadarData/JULIA"
+                    self.path = "/Users/jro/Documents/RadarData/MST_ISR/MST"
             #        self.startDateTime = datetime.datetime(2007,5,1,15,49,0)
             #        self.endDateTime = datetime.datetime(2007,5,1,23,0,0)
-                    self.startDateTime = datetime.datetime(2011,10,1,0,0,0)
+                    self.startDateTime = datetime.datetime(2009,01,1,0,0,0)
-                    self.endDateTime = datetime.datetime(2011,12,31,0,20,0)
+                    self.endDateTime = datetime.datetime(2009,01,31,0,20,0)
+            #        self.startDateTime = datetime.datetime(2011,11,1,0,0,0)
+            #        self.endDateTime = datetime.datetime(2011,12,31,0,20,0)
                     self.N = 4
                     self.npts = 8
                 def createObjects( self ):
-                    self.voltObj1 = Voltage()
+                    self.readerObj = VoltageReader()
-                    self.voltObj2 = Voltage()
+                    self.voltProcObj = VoltageProcessor()
-                    self.specObj1 = Spectra()
+                    self.specProcObj = SpectraProcessor()
-                    self.readerObj = VoltageReader(self.voltObj1)
-                    self.voltProcObj = VoltageProcessor(self.voltObj1, self.voltObj2)
-                    self.specProcObj = SpectraProcessor(self.voltObj2, self.specObj1)
-                    if not(self.readerObj.setup( self.path, self.startDateTime, self.endDateTime, expLabel='', online =0) ):
+                    voltObj1 = self.readerObj.setup(
+                                               path = self.path,
+                                               startDateTime = self.startDateTime,
+                                               endDateTime = self.endDateTime,
+                                               expLabel = '',
+                                               online = 0)
+                    if not(voltObj1):
                         sys.exit(0)
-                    self.specProcObj.setup(nFFTPoints=8)
+                    voltObj2 = self.voltProcObj.setup(dataInObj = voltObj1)
+                    specObj1 = self.specProcObj.setup(dataInObj = voltObj2,
+                                                      nFFTPoints = 16)
+            #        voltObj2 = self.voltProcObj.setup(dataInObj = voltObj1,
+            #                                          dataOutObj = voltObj2)
+            #
+            #        specObj1 = self.specProcObj.setup(dataInObj = voltObj2,
+            #                                          dataOutObj =specObj1,
+            #                                          nFFTPoints=16)
                 def testSChain( self ):
                     ini = time.time()
                     while(True):
                         self.readerObj.getData()
                         self.voltProcObj.init()
-                        self.voltProcObj.plotData(winTitle='VOLTAGE INPUT', index=1)
+            #            self.voltProcObj.plotData(winTitle='VOLTAGE INPUT', index=1)
+            #
-                        self.voltProcObj.integrator(4)
+            #            self.voltProcObj.integrator(4)
+            #
-                        self.voltProcObj.plotData(winTitle='VOLTAGE AVG', index=2)
+            #            self.voltProcObj.plotData(winTitle='VOLTAGE AVG', index=2)
+            #
                         self.specProcObj.init()
-                        self.specProcObj.integrator(N=2)
+                        self.specProcObj.integrator(N=1)
-                        self.specProcObj.plotData(winTitle='Spectra 1', index=3)
+                        self.specProcObj.plotData(winTitle='Spectra 1', index=1)
                         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),)
             #        self.plotObj.end()
             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