schain-jc Commit - r26:0d3203b6912d · Jicamarca Repository

Desplazamiento automatico de los puntos de FFT en el modulo de lectura de espectros.

Miguel Valdez -

r26:0d3203b6912d

parent child

Context file:

r26:0d3203b6912d

Collapse all files

schainpy/Graphics/BaseGraph.py +13 -5

             """
             Created on Feb 7, 2012
             @autor $Author$
             @version $Id$
             """
             import numpy
             import plplot
             def cmap1_init(colormap="gray"):
                 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
             class BaseGraph:
                 """
                 """
                 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):
+                def plotBox(self, xmin, xmax, ymin, ymax, xopt=None, yopt=None):
                     """
                     """
                     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)
                                   )
-                    plplot.plbox(self.__xopt, 0.0, 0, self.__yopt, 0.0, 0)
+                    if xopt == None: xopt = self.__xopt
+                    if yopt == None: yopt = self.__yopt
+                    plplot.plbox(xopt, 0.0, 0, yopt, 0.0, 0)
                     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():
                 __szchar = 1.0
                 __xrange = None
                 __yrange = None
                 m_BaseGraph = None
                 def __init__(self):
                     key = "linearplot"
                     self.m_BaseGraph = BaseGraph()
                     self.m_BaseGraph.setName(key)
                     self.__subpage = 0
                 def setColormap(self, colormap="br_green"):
                     if colormap == None:
                         colormap = self.__colormap
                     cmap1_init(colormap)
                 def iniSubpage(self):
                     if plplot.plgdev() == '':
                         raise ValueError, "Plot device has not been initialize"
                     plplot.pladv(self.__subpage)
                     plplot.plschr(0.0, self.__szchar)
                     self.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.m_BaseGraph.setScreenPos([xi, xf], [yi, yf])
                 def setup(self, subpage, title="", xlabel="", ylabel="", XAxisAsTime=False):
                     """
                     """
                     self.m_BaseGraph.setOpt("bcnts","bcntsv")
                     self.m_BaseGraph.setup(title,
                                            xlabel,
                                            ylabel
                                            )
                     self.setScreenPos(width='medium')
                     if XAxisAsTime:
                         self.m_BaseGraph.setXAxisAsTime()
                     self.__subpage = subpage
             #    def setRanges(self, xrange, yrange, zrange):
             #
             #        self.m_BaseGraph.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.m_BaseGraph.plotBox(xmin, xmax, ymin, ymax)
                     self.m_BaseGraph.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.m_BaseGraph.plotBox(xmin, xmax, ymin, ymax)
                     if type.lower() == 'power':
                         self.m_BaseGraph.basicLineTimePlot(x, abs(y), xmin, xmax, ymin, ymax, colline)
                     if type.lower() == 'iq':
                         self.m_BaseGraph.basicLineTimePlot(x, y.real, xmin, xmax, ymin, ymax, colline)
                         self.m_BaseGraph.basicLineTimePlot(x, y.imag, xmin, xmax, ymin, ymax, colline+1)
             class ColorPlot():
                 def __init__(self):
                     self.graphObjDict = {}
                     self.__subpage = 0
                     self.__showColorbar = False
                     self.__showPowerProfile = True
                     self.__szchar = 0.7
                     self.__xrange = None
                     self.__yrange = None
                     self.__zrange = None
                     key = "colorplot"
                     self.m_BaseGraph = BaseGraph()
                     self.m_BaseGraph.setName(key)
                 def setup(self, subpage, title="", xlabel="Frequency", ylabel="Range", colormap="jet", showColorbar=False, showPowerProfile=False, XAxisAsTime=False):
                     """
                     """
                     self.m_BaseGraph.setOpt("bcnts","bcntsv")
                     self.m_BaseGraph.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","bcmt")
                         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="dBs",
+                                     xlabel="dB",
                                      ylabel="")
                         self.graphObjDict[key] = powObj
                     self.setScreenPos(width='small')
                     if XAxisAsTime:
                         self.m_BaseGraph.setXAxisAsTime()
                 def setColormap(self, colormap="br_green"):
                     if colormap == None:
                         colormap = self.__colormap
                     cmap1_init(colormap)
                 def iniSubpage(self):
                     if plplot.plgdev() == '':
                         raise ValueError, "Plot device has not been initialize"
                     plplot.pladv(self.__subpage)
                     plplot.plschr(0.0, self.__szchar)
                     self.setColormap()
                 def setScreenPos(self, width='small'):
                     if width == 'small':
-                        xi = 0.12; yi = 0.12; xw = 0.86; yw = 0.70; xcmapw = 0.05; xpoww = 0.26; deltaxcmap = 0.02; deltaxpow = 0.06
+                        xi = 0.13; yi = 0.12; xw = 0.86; yw = 0.70; xcmapw = 0.05; xpoww = 0.26; deltaxcmap = 0.02; deltaxpow = 0.05
                     if width == 'medium':
                         xi = 0.07; yi = 0.10; xw = 0.90; yw = 0.60; 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.m_BaseGraph.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):
                     """
                     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)
                     self.m_BaseGraph.plotBox(xmin, xmax, ymin, ymax)
                     self.m_BaseGraph.basicPcolorPlot(data, x, y, xmin, xmax, ymin, ymax, zmin, zmax)
                     if self.__showColorbar:
                         key = "colorbar"
                         cmapObj = self.graphObjDict[key]
                         cmapObj.plotBox(0., 1., zmin, zmax)
                         cmapObj.colorbarPlot(0., 1., zmin, zmax)
                     if self.__showPowerProfile:
-                        power = numpy.average(data, axis=0)
+                        power = numpy.max(data, axis=0)
                         step = (ymax - ymin)/(nY-1)
                         heis = numpy.arange(ymin, ymax + step, step)
                         key = "powerprof"
                         powObj = self.graphObjDict[key]
                         plplot.pllsty(2)
                         powObj.plotBox(zmin, zmax, ymin, ymax)
                         plplot.pllsty(1)
+                        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
                 m_BaseGraph = BaseGraph()
                 def __init__(self):
                     key = "colorplot"
                     self.m_BaseGraph.setName(key)
                     self.__subpage = 0
                     self.graphObjDict[key] = self.m_BaseGraph
                 def setColormap(self, colormap="br_green"):
                     if colormap == None:
                         colormap = self.__colormap
                     cmap1_init(colormap)
                 def iniSubpage(self):
                     if plplot.plgdev() == '':
                         raise ValueError, "Plot device has not been initialize"
                     plplot.pladv(self.__subpage)
                     plplot.plschr(0.0, self.__szchar)
                     self.setColormap()
                 def setup(self, subpage, title="", xlabel="", ylabel="", colormap="jet", showColorbar=False, showPowerProfile=False, XAxisAsTime=False):
                     """
                     """
                     self.m_BaseGraph.setSubpage(subpage)
                     self.m_BaseGraph.setSzchar(self.__szchar)
                     self.m_BaseGraph.setOpt("bcnts","bcntsv")
                     self.m_BaseGraph.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.m_BaseGraph.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 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.m_BaseGraph.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.m_BaseGraph.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 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.m_BaseGraph.hasNotRange:
                         self.setRanges([xmin, xmax], [ymin,ymax], [zmin,zmax])
                     self.m_BaseGraph.initSubpage()
                     self.m_BaseGraph.basicPcolorPlot(data, x, y, xmin, xmax, ymin, ymax, self.m_BaseGraph.zrange[0], self.m_BaseGraph.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.iniSubpage()
                 baseObj.plotData(data)
                 specObj.iniSubpage()
                 specObj.plotData(data)
                 baseObj1.iniSubpage()
                 baseObj1.plotData(data)
                 specObj1.iniSubpage()
                 specObj1.plotData(data)
                 plplot.plflush()
                 plplot.plspause(1)
                 plplot.plend()
                 exit(0)

schainpy/Graphics/SpectraPlot.py +14 -7

             '''
             Created on Feb 7, 2012
             @author $Author$
             @version $Id$
             '''
             import os, sys
             import numpy
             import plplot
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from Graphics.BaseGraph import *
             from Model.Spectra import Spectra
             class Spectrum():
                 def __init__(self, Spectra):
                     """
                     Inputs:
                         type:   "power" ->> Potencia
                                 "iq"    ->> Real + Imaginario
                     """
                     self.__isPlotConfig = False
                     self.__isPlotIni = False
                     self.__xrange = None
                     self.__yrange = None
                     self.nGraphs = 0
                     self.graphObjList = []
                     self.m_Spectra = 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.m_Spectra.m_SystemHeader.numChannels)
+                    channels = range(nChan)
-                    myTitle = ""
+                    myXlabel = "Radial Velocity (m/s)"
-                    myXlabel = ""
+                    myYlabel = "Range (km)"
-                    myYlabel = ""
-                    for i in range(nChan):
+                    for i in channels:
                         if titleList != None:
                             myTitle = titleList[i]
                             myXlabel = xlabelList[i]
                             myYlabel = ylabelList[i]
+                        if self.m_Spectra.noise != None:
+                            noise = '%4.2fdB' %(self.m_Spectra.noise[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):
                     nx = int(numpy.sqrt(self.nGraphs)+1)
                     #ny = int(self.nGraphs/nx)
-                    plplot.plsetopt("geometry", "%dx%d" %(400*nx, 300*nx))
+                    plplot.plsetopt("geometry", "%dx%d" %(300*nx, 240*nx))
                     plplot.plsdev("xcairo")
                     plplot.plscolbg(255,255,255)
                     plplot.plscol0(1,0,0,0)
                     plplot.plinit()
                     plplot.plspause(False)
                     plplot.pladv(0)
                     plplot.plssub(nx, 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):
                     if not(self.__isPlotConfig):
                         self.setup(titleList,
                                    xlabelList,
                                    ylabelList,
                                    showColorbar,
                                    showPowerProfile,
                                    XAxisAsTime)
                     if not(self.__isPlotIni):
                         self.iniPlot()
-                    data = numpy.log10(self.m_Spectra.data_spc)
+                    data = 10.*numpy.log10(self.m_Spectra.data_spc)
                     nX, nY, nChan = numpy.shape(data)
                     x = numpy.arange(nX)
                     y = self.m_Spectra.heights
                     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()
                     for i in range(self.nGraphs):
                         self.graphObjList[i].iniSubpage()
-                        self.graphObjList[i].plotData(data[:,:,i],
+                        self.graphObjList[i].plotData(data[i,:,:],
                                                       x,
                                                       y,
                                                       xmin=xmin,
                                                       xmax=xmax,
                                                       ymin=ymin,
                                                       ymax=ymax,
                                                       zmin=zmin,
                                                       zmax=zmax)
                     plplot.plflush()
                     plplot.pleop()
                 def end(self):
                     plplot.plend()
             if __name__ == '__main__':
                 pass

schainpy/IO/HeaderIO.py +7 0

             '''
             Created on 23/01/2012
             @author $Author$
             @version $Id$
             '''
             import numpy
             class BasicHeader:
                 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')
                                           ])
                     pass
                 def read(self, fp):
                     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]
                     return 1
                 def copy(self):
                     obj = BasicHeader()
                     obj.size = self.size
                     obj.version = self.version
                     obj.dataBlock = self.dataBlock
                     obj.utc = self.utc
                     obj.miliSecond = self.miliSecond
                     obj.timeZone = self.timeZone
                     obj.dstFlag = self.dstFlag
                     obj.errorCount = self.errorCount
                     return obj
                 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:
                 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):
                     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]
                     return 1
                 def copy(self):
                     obj = SystemHeader()
                     obj.size = self.size
                     obj.numSamples = self.numSamples
                     obj.numProfiles = self.numProfiles
                     obj.numChannels = self.numChannels
                     obj.adcResolution = self.adcResolution
                     self.pciDioBusWidth = self.pciDioBusWidth
                     return obj
                 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:
                 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.dynamic = numpy.array([],numpy.dtype('byte'))
                 def read(self, fp):
                     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
                     jumpHeader = self.size - 116
                     self.dynamic = numpy.fromfile(fp,numpy.dtype('byte'),jumpHeader)
                     return 1
                 def copy(self):
                     obj = RadarControllerHeader()
                     obj.size = self.size
                     obj.expType = self.expType
                     obj.nTx = self.nTx
                     obj.ipp = self.ipp
                     obj.txA = self.txA
                     obj.txB = self.txB
                     obj.numWindows = self.numWindows
                     obj.numTaus = self.numTaus
                     obj.codeType = self.codeType
                     obj.line6Function = self.line6Function
                     obj.line5Function = self.line5Function
                     obj.fClock = self.fClock
                     obj.prePulseBefore = self.prePulseBefore
                     obj.prePulserAfter = self.prePulserAfter
                     obj.rangeIpp = self.rangeIpp
                     obj.rangeTxA = self.rangeTxA
                     obj.rangeTxB = self.rangeTxB
                     obj.dynamic = self.dynamic
                     return obj
                 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:
                 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.codes = 0
                     self.numBaud = 0
                 def read(self, fp):
                     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.codes = 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
                     return 1
                 def copy(self):
                     obj = ProcessingHeader()
                     obj.size = self.size
                     obj.dataType = self.dataType
                     obj.blockSize = self.blockSize
                     obj.profilesPerBlock = self.profilesPerBlock
                     obj.dataBlocksPerFile = self.dataBlocksPerFile
                     obj.numWindows = self.numWindows
                     obj.processFlags = self.processFlags
                     obj.coherentInt = self.coherentInt
                     obj.incoherentInt = self.incoherentInt
                     obj.totalSpectra = self.totalSpectra
                     obj.samplingWindow = self.samplingWindow
                     obj.numHeights = self.numHeights
                     obj.firstHeight = self.firstHeight
                     obj.deltaHeight = self.deltaHeight
                     obj.samplesWin = self.samplesWin
                     obj.spectraComb = self.spectraComb
                     obj.numCode = self.numCode
                     obj.numBaud = self.numBaud
                     obj.codes = self.codes
+                    obj.shif_fft = self.shif_fft
                     return obj
                 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)
                         codes = self.codes.reshape(numCode*numBaud)
                         codes.tofile(fp)
                     return 1
             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/IO/SpectraIO.py +11 -3

             '''
             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 HeaderIO import *
             from DataIO import DataReader
             from DataIO import DataWriter
             from Model.Spectra import Spectra
             def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
                 """
                 Esta funcion determina si un archivo de datos  en formato Jicamarca(.r) 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)
                 if not(m_BasicHeader.read(fp)):
                     raise IOError, "The file %s has not a valid header" %(filename)
                 fp.close()
                 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)):
                     return 0
                 return 1
             class SpectraReader(DataReader):
                 """
                 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:
                 perfiless*alturas*canales) son almacenados en la variable "buffer".
                 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
                         if readerObj.noMoreFiles:
                             break
                 """
                 #speed of light
                 __c = 3E8
                 def __init__( self, m_Spectra = None ):
                     """
                     Inicializador de la clase SpectraReader para la lectura de datos de espectros.
                     Input:
                         m_Spectra    :    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.
                     Variables afectadas:
                         self.m_Spectra
                         self.m_BasicHeader
                         self.m_SystemHeader
                         self.m_RadarControllerHeader
                         self.m_ProcessingHeader
                     Return:
                         Void
                     """
                     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_Spectra = m_Spectra
                     self.m_BasicHeader = BasicHeader()
                     self.m_SystemHeader = SystemHeader()
                     self.m_RadarControllerHeader = RadarControllerHeader()
                     self.m_ProcessingHeader = ProcessingHeader()
                     self.__fp = None
                     self.__idFile = None
                     self.__startDateTime = None
                     self.__endDateTime = None
                     self.__dataType = None
                     self.__fileSizeByHeader = 0
                     self.__pathList = []
                     self.filenameList = []
                     self.__lastUTTime = 0
                     self.__maxTimeStep = 30
                     self.__flagIsNewFile = 0
                     self.flagResetProcessing = 0
                     self.flagIsNewBlock = 0
                     self.noMoreFiles = 0
                     self.nReadBlocks = 0
                     self.online = 0
                     self.firstHeaderSize = 0
                     self.basicHeaderSize = 24
                     self.filename = None
                     self.fileSize = None
                     self.__buffer_spc = None
                     self.__buffer_cspc = None
                     self.__buffer_dc  = None
                     self.__buffer_id = 0
                     self.__ippSeconds = 0
                     self.nSelfChannels = 0
                     self.nCrossPairs = 0
                     self.nChannels = 0
                 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 ):
                     self.__rdBasicHeader()
                     self.__rdSystemHeader()
                     self.__rdRadarControllerHeader()
                     self.__rdProcessingHeader()
                     self.firstHeaderSize = self.m_BasicHeader.size
                     data_type = int( numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR) )
                     if data_type == 0:
                         tmp = numpy.dtype([('real','<i1'),('imag','<i1')])
                     elif data_type == 1:
                         tmp = numpy.dtype([('real','<i2'),('imag','<i2')])
                     elif data_type == 2:
                         tmp = numpy.dtype([('real','<i4'),('imag','<i4')])
                     elif data_type == 3:
                         tmp = numpy.dtype([('real','<i8'),('imag','<i8')])
                     elif data_type == 4:
                         tmp = numpy.dtype([('real','<f4'),('imag','<f4')])
                     elif data_type == 5:
                         tmp = numpy.dtype([('real','<f8'),('imag','<f8')])
                     else:
                         raise ValueError, 'Data type was not defined'
                     xi   = self.m_ProcessingHeader.firstHeight
                     step = self.m_ProcessingHeader.deltaHeight
                     xf   = xi + self.m_ProcessingHeader.numHeights*step
                     self.__heights          = numpy.arange(xi, xf, step)
                     self.__dataType         = tmp
                     self.__fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
                     self.__ippSeconds       = 2 * 1000 * self.m_RadarControllerHeader.ipp/self.__c
                 def __setNextFileOnline( self ):
                     return 1
                 def __setNextFileOffline( self ):
                     idFile = self.__idFile
                     while(True):
                         idFile += 1
                         if not( idFile < len(self.filenameList) ):
                             self.noMoreFiles = 1
                             return 0
                         filename = self.filenameList[idFile]
                         fileSize = os.path.getsize(filename)
                         try:
                             fp = open( filename, 'rb' )
                         except:
                             raise IOError, "The file %s can't be opened" %filename
                         currentSize = fileSize - fp.tell()
                         neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
                         if (currentSize < neededSize):
                             print "Skipping the file %s due to it hasn't enough data" %filename
                             continue
                         break
                     self.__flagIsNewFile = 1
                     self.__idFile = idFile
                     self.filename = filename
                     self.fileSize = fileSize
                     self.__fp = fp
                     print 'Setting the file: %s'%self.filename
                     return 1
                 def __setNextFile(self):
                     if self.online:
                         newFile = self.__setNextFileOnline()
                     else:
                         newFile = self.__setNextFileOffline()
                     if not(newFile):
                         return 0
                     self.__readFirstHeader()
                     return 1
                 def __setNewBlock( self ):
                     if self.__fp == None:
                         return 0
                     if self.__flagIsNewFile:
                         return 1
                     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
                     #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
                         self.ns = 0
                     return 1
                 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
                     Variables afectadas:
                         self.__buffer_id
                         self.__buffer_sspc
                         self.__flagIsNewFile
                         self.flagIsNewBlock
                         self.nReadBlocks
                     """
                     Npair_SelfSpectra = 0
                     Npair_CrossSpectra = 0
                     for i in range( 0,self.m_ProcessingHeader.totalSpectra*2,2 ):
                         if self.m_ProcessingHeader.spectraComb[i] == self.m_ProcessingHeader.spectraComb[i+1]:
                             Npair_SelfSpectra = Npair_SelfSpectra + 1
                         else:
                             Npair_CrossSpectra = Npair_CrossSpectra + 1
             #        self.__buffer_sspc = numpy.concatenate( (data_sspc,data_cspc,data_dcc), axis=0 )
                     self.__buffer_id = 0
                     self.__flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     pts2read = self.m_ProcessingHeader.profilesPerBlock*self.m_ProcessingHeader.numHeights
                     spc  = numpy.fromfile(self.__fp, self.__dataType[0], int(pts2read*Npair_SelfSpectra))
                     cspc  = numpy.fromfile(self.__fp, self.__dataType, int(pts2read*Npair_CrossSpectra))
                     dc  = numpy.fromfile(self.__fp, self.__dataType, int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
-                    spc = spc.reshape((self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, Npair_SelfSpectra))
+                    spc = spc.reshape((Npair_SelfSpectra, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock))
-                    cspc = cspc.reshape((self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, Npair_CrossSpectra))
+                    cspc = cspc.reshape((Npair_CrossSpectra, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock))
-                    dc = dc.reshape((self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels))
+                    dc = dc.reshape((self.m_SystemHeader.numChannels, self.m_ProcessingHeader.numHeights))
+                    if not(self.m_ProcessingHeader.shif_fft):
+                        spc = numpy.roll(spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2)
+                        cspc = numpy.roll(cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2)
+                    spc = numpy.transpose(spc, (0,2,1))
+                    cspc = numpy.transpose(cspc, (0,2,1))
+                    #dc = numpy.transpose(dc, (0,2,1))
                     data_spc = spc
                     data_cspc = cspc['real'] + cspc['imag']*1j
                     data_dc = dc['real'] + dc['imag']*1j
                     self.__buffer_spc = data_spc
                     self.__buffer_cspc = data_cspc
                     self.__buffer_dc  = data_dc
                     self.__flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nReadBlocks += 1
                 def __hasNotDataInBuffer(self):
                     return 1
                 def __searchFiles(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".pdata"):
                     """
                     __searchFiles 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 (objeto 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)
                     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)
                     self.filenameList = filenameList
                     return pathList, filenameList
                 def setup( self, path, startDateTime, endDateTime=None, set=None, expLabel = "", ext = ".pdata", online = 0 ):
                     """
                     setup configura los parametros de lectura de la clase SpectraReader.
                     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 (objeto datetime.datetime)
                         endDateTime         :    Fecha final. Si no es None, rechaza todos los archivos donde
                                                  file end time < startDatetime (objeto 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              :
                     Return:
                     Affected:
                     Excepciones:
                     Example:
                     """
                     if online == 0:
                         pathList, filenameList = self.__searchFiles(path, startDateTime, endDateTime, set, expLabel, ext)
                     self.__idFile = -1
                     if not(self.__setNextFile()):
                         print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
                         return 0
                     self.startUTCSeconds = time.mktime(startDateTime.timetuple())
                     self.endUTCSeconds = time.mktime(endDateTime.timetuple())
                     self.startYear = startDateTime.timetuple().tm_year
                     self.endYear = endDateTime.timetuple().tm_year
                     self.startDoy = startDateTime.timetuple().tm_yday
                     self.endDoy = endDateTime.timetuple().tm_yday
                     #call fillHeaderValues() - to Data Object
                     self.__pathList = pathList
                     self.filenameList = filenameList
                     self.online = online
                     return 1
                 def readNextBlock(self):
                     """
                     readNextBlock 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.
                     """
                     if not( self.__setNewBlock() ):
                         return 0
                     self.__readBlock()
                     self.__lastUTTime = self.m_BasicHeader.utc
                     return 1
                 def getData(self):
                     """
                     getData 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"
                     Inputs:
                         None
                     Return:
                         data    :    retorna un bloque de datos (nFFTs * alturas * canales) copiados desde el
                                      buffer. Si no hay mas archivos a leer retorna None.
                     Variables afectadas:
                         self.m_Spectra
                         self.__buffer_id
                     Excepciones:
                     """
                     self.flagResetProcessing = 0
                     self.flagIsNewBlock = 0
                     if self.__hasNotDataInBuffer():
                         self.readNextBlock()
                         self.m_Spectra.m_BasicHeader = self.m_BasicHeader.copy()
                         self.m_Spectra.m_ProcessingHeader = self.m_ProcessingHeader.copy()
                         self.m_Spectra.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
                         self.m_Spectra.m_SystemHeader = self.m_SystemHeader.copy()
                         self.m_Spectra.heights = self.__heights
                         self.m_Spectra.dataType = self.__dataType
                     if self.noMoreFiles == 1:
                         print 'Process finished'
                         return 0
                     #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
                     #print type(self.__buffer_sspc)
                     time = self.m_BasicHeader.utc + self.__buffer_id*self.__ippSeconds
                     self.m_Spectra.m_BasicHeader.utc = time
                     self.m_Spectra.data_spc = self.__buffer_spc
                     self.m_Spectra.data_cspc = self.__buffer_cspc
                     self.m_Spectra.data_dc = self.__buffer_dc
                     #call setData - to Data Object
                     return 1
             class SpectraWriter(DataWriter):
                 def __init__(self):
                     if m_Spectra == None:
                         m_Spectra = Spectra()
                     self.m_Spectra = m_Spectra
                     self.__fp = None
                     self.__blocksCounter = 0
                     self.__setFile = None
                     self.__flagIsNewFile = 0
                     self.__buffer_sspc = 0
                     self.__buffer_id = 0
                     self.__dataType = None
                     self.__ext = None
                     self.nWriteBlocks = 0
                     self.flagIsNewBlock = 0
                     self.noMoreFiles = 0
                     self.filename = None
                     self.m_BasicHeader= BasicHeader()
                     self.m_SystemHeader = SystemHeader()
                     self.m_RadarControllerHeader = RadarControllerHeader()
                     self.m_ProcessingHeader = ProcessingHeader()
                 def __setNextFile(self):
                     setFile = self.__setFile
                     ext = self.__ext
                     path = self.__path
                     setFile += 1
                     if not(self.__blocksCounter >= self.m_ProcessingHeader.dataBlocksPerFile):
                         self.__fp.close()
                         return 0
                     timeTuple = time.localtime(self.m_Spectra.m_BasicHeader.utc) # utc from m_Spectra
                     file = 'D%4.4d%3.3d%3.3d%s' % (timeTuple.tm_year,timeTuple.tm_doy,setFile,ext)
                     subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_doy)
                     tmp = os.path.join(path,subfolder)
                     if not(os.path.exists(tmp)):
                         os.mkdir(tmp)
                     filename = os.path.join(path,subfolder,file)
                     fp = open(filename,'wb')
                     #guardando atributos
                     self.filename = filename
                     self.__subfolder = subfolder
                     self.__fp = fp
                     self.__setFile = setFile
                     self.__flagIsNewFile = 1
                     print 'Writing the file: %s'%self.filename
                     return 1
                 def __setNewBlock(self):
                     if self.__fp == None:
                         return 0
                     if self.__flagIsNewFile:
                         return 1
                     #Bloques completados?
                     if self.__blocksCounter < self.m_ProcessingHeader.profilesPerBlock:
                         self.__writeBasicHeader()
                         return 1
                     if not(self.__setNextFile()):
                         return 0
                     self.__writeFirstHeader()
                     return 1
                 def __writeBlock(self):
                     numpy.save(self.__fp,self.__buffer_sspc)
                     self.__buffer_sspc = numpy.array([],self.__dataType)
                     self.__buffer_id = 0
                     self.__flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nWriteBlocks += 1
                     self.__blocksCounter += 1
                 def writeNextBlock(self):
                     if not(self.__setNewBlock()):
                         return 0
                     self.__writeBlock()
                     return 1
                 def __hasAllDataInBuffer(self):
                     if self.__buffer_id >= self.m_ProcessingHeader.profilesPerBlock:
                         return 1
                     return 0
                 def putData(self):
                     self.flagIsNewBlock = 0
                     if self.m_Spectra.noData:
                         return None
                     shape = self.m_Spectra.data.shape
                     data = numpy.zeros(shape,self.__dataType)
                     data['real'] = self.m_Spectra.data.real
                     data['imag'] = self.m_Spectra.data.imag
                     data = data.reshape((-1))
                     self.__buffer_sspc = numpy.hstack((self.__buffer_sspc,data))
                     self.__buffer_id += 1
                     if __hasAllDataInBuffer():
                         self.writeNextBlock()
                     if self.noMoreFiles:
                         print 'Process finished'
                         return None
                     return 1
                 def setup(self,path,set=None,format=None):
                     if set == None:
                         set = -1
                     else:
                         set -= 1
                     if format == 'hdf5':
                         ext = '.hdf5'
                         print 'call hdf5 library'
                         return 0
                     if format == 'rawdata':
                         ext = '.r'
                     #call to config_headers
                     self.__setFile = set
                     if not(self.__setNextFile()):
                         print "zzzzzzzzzzzz"
                         return 0
                     self.__writeFirstHeader() # dentro de esta funcion se debe setear e __dataType
                     self.__buffer_sspc = numpy.array([],self.__dataType)
                 def __writeBasicHeader(self):
                     pass
                 def __writeFirstHeader(self):
                     pass

schainpy/Model/Spectra.py +4 0

             '''
             Created on Feb 7, 2012
             @author $Author$
             @version $Id$
             '''
             import os, sys
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from Model.Data import Data
             from IO.HeaderIO import *
             class Spectra(Data):
                 '''
                 classdocs
                 '''
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.m_RadarControllerHeader = RadarControllerHeader()
                     self.m_ProcessingHeader      = ProcessingHeader()
                     self.m_SystemHeader          = SystemHeader()
                     self.m_BasicHeader           = BasicHeader()
                     #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.heights  = None
                     self.noData = True
                     self.nProfiles = None
                     self.dataType = None
+                    self.noise = None
                 def copy(self):
                     obj = Spectra()
                     obj.m_BasicHeader = self.m_BasicHeader.copy()
                     obj.m_SystemHeader = self.m_SystemHeader.copy()
                     obj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
                     obj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
                     obj.data_spc = self.data_spc
                     obj.data_cspc = self.data_cspc
                     obj.data_dc = self.data_dc
                     obj.heights = self.heights
                     obj.noData = self.noData
                     obj.nProfiles = self.nProfiles
+                    obj.noise = self.noise
                     return obj
   No newline at end of file

schainpy/Model/Voltage.py +4 0

             '''
             Created on Feb 7, 2012
             @author $Author$
             @version $Id$
             '''
             import os, sys
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from Model.Data import Data
             from IO.HeaderIO import *
             class Voltage(Data):
                 '''
                 classdocs
                 '''
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.m_RadarControllerHeader= RadarControllerHeader()
                     self.m_ProcessingHeader= ProcessingHeader()
                     self.m_SystemHeader= SystemHeader()
                     self.m_BasicHeader= BasicHeader()
                     #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
                     self.data = None
                     self.heights = None
                     self.flagNoData = True
                     self.nProfiles = None
                     self.idProfile = None
                     self.dataType = None
                     self.flagResetProcessing = False
+                    self.noise = noise
                 def copy(self):
                     obj = Voltage()
                     obj.m_BasicHeader = self.m_BasicHeader.copy()
                     obj.m_SystemHeader = self.m_SystemHeader.copy()
                     obj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
                     obj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
                     obj.data = self.data
                     obj.heights = self.heights
                     obj.flagNoData = self.flagNoData
                     obj.nProfiles = self.nProfiles
                     obj.idProfile = self.idProfile
                     obj.dataType = self.dataType
                     obj.flagResetProcessing = self.flagResetProcessing
+                    obj.noise = self.noise
                     return obj
   No newline at end of file

schainpy/TestSChain.py +2 -2

             '''
             Created on 23/01/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 Graphics.SpectraPlot import Spectrum
             class TestSChain():
                 def __init__(self):
                     self.setValues()
                     self.createObjects()
                     self.testSChain()
                     pass
                 def setValues(self):
                     self.path = '/home/roj-idl71/Data/RAWDATA/DP_Faraday/'
                     self.path = '/Users/danielangelsuarezmunoz/Documents/Projects/testWR'
                     self.path = '/home/roj-idl71/Data/RAWDATA/IMAGING'
             #        self.path = '/home/roj-idl71/tmp/data'
                     #self.path = '/remote/puma/2004_11/DVD/'
                     self.ppath = "/home/roj-idl71/tmp/data"
-                    self.startDateTime = datetime.datetime(2011,1,1,17,49,0)
+                    self.startDateTime = datetime.datetime(2011,1,24,18,20,0)
                     self.endDateTime = datetime.datetime(2011,1,30,18,10,0)
                 def createObjects(self):
                     self.Obj = Spectra()
                     self.readerObj = SpectraReader(self.Obj)
                     self.plotObj = Spectrum(self.Obj)
             #        self.writerObj = SpectraWriter(self.Obj)
                     if not(self.readerObj.setup(self.path, self.startDateTime, self.endDateTime, expLabel='')):
                         sys.exit(0)
             #        if not(self.writerObj.setup(self.ppath)):
             #            sys.exit(0)
                 def testSChain(self):
                     ini = time.time()
                     while(True):
                         self.readerObj.getData()
-                        self.plotObj.plotData(showColorbar=False, showPowerProfile=True)
+                        self.plotObj.plotData(zmin=40, zmax=140, showColorbar=True, showPowerProfile=True)
             #            self.writerObj.putData()
                         if self.readerObj.noMoreFiles:
                             break
                         if self.readerObj.flagIsNewBlock:
                             print 'Block No %04d, Time: %s' %(self.readerObj.nReadBlocks,
                                                               datetime.datetime.fromtimestamp(self.readerObj.m_BasicHeader.utc),)
                             fin = time.time()
                             print 'Tiempo de un bloque leido y escrito: [%6.5f]' %(fin - ini)
                             ini = time.time()
                         #time.sleep(0.5)
                     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