schain-jc Commit - r16:c320d9a338b2 · Jicamarca Repository

Fijando variables svn:keywords Author Id

Daniel Valdez -

r16:c320d9a338b2

parent child

Context file:

r16:c320d9a338b2

Expand all files

schainpy/Graphics/BasicGraph.py +7 0

+            '''
+            Created on Feb 7, 2012
+            @author $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 BasicGraph:
                 """
                 """
                 hasRange = False
                 xrange = None
                 yrange = None
                 zrange = None
                 xlabel = None
                 ylabel = None
                 title = None
                 legends = None
                 __name = None
                 __subpage = None
                 __szchar = None
                 __colormap = None
                 __colbox  = None
                 __colleg = None
                 __xpos = None
                 __ypos = None
                 __xopt = None #"bcnst"
                 __yopt = None #"bcnstv"
                 __xlpos = None
                 __ylpos = None
                 __xrangeIsTime = None
                 #Advanced
                 __xg = None
                 __yg = None
                 def __init__(self):
                     """
                     """
                     pass
                 def hasNotXrange(self):
                     if self.xrange == None:
                         return 1
                     return 0
                 def hasNotYrange(self):
                     if self.yrange == None:
                         return 1
                     return 0
                 def hasNotZrange(self):
                     if self.zrange == None:
                         return 1
                     return 0
                 def setName(self, name):
                     self.__name = name
                 def setScreenPos(self, xpos, ypos):
                     self.__xpos = xpos
                     self.__ypos = ypos
                 def setScreenPosbyWidth(self, xoff, yoff, xw, yw):
                     self.__xpos = [xoff, xoff + xw]
                     self.__ypos = [yoff, yoff + yw]
                 def setSubpage(self, subpage):
                     self.__subpage = subpage
                 def setSzchar(self, szchar):
                     self.__szchar = szchar
                 def setOpt(self, xopt, yopt):
                     self.__xopt = xopt
                     self.__yopt = yopt
                 def setRanges(self, xrange, yrange, zrange=None):
                     """
                     """
                     self.xrange = xrange
                     self.yrange = yrange
                     if zrange != None:
                         self.zrange = zrange
                 def setColormap(self, colormap=None):
                     if colormap == None:
                         colormap = self.__colormap
                     cmap1_init(colormap)
                 def plotBox(self):
                     """
                     """
                     plplot.plvpor(self.__xpos[0], self.__xpos[1], self.__ypos[0], self.__ypos[1])
                     plplot.plwind(self.xrange[0], self.xrange[1], self.yrange[0], self.yrange[1])
                     plplot.plbox(self.__xopt, 0.0, 0, self.__yopt, 0.0, 0)
                     plplot.pllab(self.xlabel, self.ylabel, self.title)
                 def setup(self, title=None, xlabel=None, ylabel=None, colormap=None):
                     """
                     """
                     self.title = title
                     self.xlabel = xlabel
                     self.ylabel = ylabel
                     self.__colormap = colormap
                 def initSubpage(self):
                     if plplot.plgdev() == '':
                         raise ValueError, "Plot device has not been initialize"
                     plplot.pladv(self.__subpage)
                     plplot.plschr(0.0, self.__szchar)
                     if self.__xrangeIsTime:
                         plplot.pltimefmt("%H:%M")
                     self.setColormap()
                     self.initPlot()
                 def initPlot(self):
                     """
                     """
                     if plplot.plgdev() == '':
                         raise ValueError, "Plot device has not been initialize"
                     xrange = self.xrange
                     if xrange == None:
                         xrange = [0., 1.]
                     yrange = self.yrange
                     if yrange == None:
                         yrange = [0., 1.]
                     plplot.plvpor(self.__xpos[0], self.__xpos[1], self.__ypos[0], self.__ypos[1])
                     plplot.plwind(xrange[0], xrange[1], yrange[0], yrange[1])
                     plplot.plbox(self.__xopt, 0.0, 0, self.__yopt, 0.0, 0)
                     plplot.pllab(self.xlabel, self.ylabel, self.title)
                 def colorbarPlot(self):
                     data = numpy.arange(256)
                     data = numpy.reshape(data, (1,-1))
                     self.plotBox()
                     plplot.plimage(data,
                                    self.xrange[0],
                                    self.xrange[1],
                                    self.yrange[0],
                                    self.yrange[1],
 .,
 .,
                                    self.xrange[0],
                                    self.xrange[1],
                                    self.yrange[0],
                                    self.yrange[1],)
                 def basicXYPlot(self, x, y):
                     self.plotBox()
                     plplot.plline(x, y)
                 def basicXYwithErrorPlot(self):
                     pass
                 def basicLineTimePlot(self):
                     pass
                 def basicPcolorPlot(self, data, xmin, xmax, ymin, ymax, zmin, zmax):
                     """
                     """
                     self.plotBox()
                     plplot.plimage(data, xmin, xmax, ymin, ymax, zmin, zmax, xmin, xmax, ymin, 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)

schainpy/Graphics/SpectraPlot.py +7 0

+            '''
+            Created on Feb 7, 2012
+            @author $Author$
+            @version $Id$
+            '''
             import numpy
             import plplot
             from BasicGraph import *
             class Spectrum:
                 graphObjDict = {}
                 showColorbar = False
                 showPowerProfile = True
                 __szchar = 0.7
                 __xrange = None
                 __yrange = None
                 __zrange = None
                 specObj = BasicGraph()
                 def __init__(self):
                     key = "spec"
                     specObj = BasicGraph()
                     specObj.setName(key)
                     self.graphObjDict[key] = specObj
                 def setup(self, subpage, title="", xlabel="", ylabel="", colormap="jet", showColorbar=False, showPowerProfile=False):
                     """
                     """
                     xi = 0.12; xw = 0.78; xf = xi + xw
                     yi = 0.14; yw = 0.80; yf = yi + yw
                     xcmapi = xcmapf = 0.; xpowi = xpowf = 0.
                     key = "spec"
                     specObj = self.graphObjDict[key]
                     specObj.setSubpage(subpage)
                     specObj.setSzchar(self.__szchar)
                     specObj.setOpt("bcnts","bcnts")
                     specObj.setup(title,
                                   xlabel,
                                   ylabel,
                                   colormap)
                     if showColorbar:
                         key = "colorbar"
                         cmapObj = BasicGraph()
                         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
                         xcmapi = 0.
                         xcmapw = 0.05
                         xw -= xcmapw
                     if showPowerProfile:
                         key = "powerprof"
                         powObj = BasicGraph()
                         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
                         xpowi = 0.
                         xpoww = 0.24
                         xw -= xpoww
                     xf = xi + xw
                     yf = yi + yw
                     xcmapf = xf
                     specObj.setScreenPos([xi, xf], [yi, yf])
                     if showColorbar:
                         xcmapi = xf + 0.02
                         xcmapf = xcmapi + xcmapw
                         cmapObj.setScreenPos([xcmapi, xcmapf], [yi, yf])
                     if showPowerProfile:
                         xpowi = xcmapf + 0.06
                         xpowf = xpowi + xpoww
                         powObj.setScreenPos([xpowi, xpowf], [yi, yf])
             #        specObj.initSubpage()
             #
             #        if showColorbar:
             #            cmapObj.initPlot()
             #
             #        if showPowerProfile:
             #            powObj.initPlot()
                     self.showColorbar = showColorbar
                     self.showPowerProfile = showPowerProfile
                 def setRanges(self, xrange, yrange, zrange):
                     key = "spec"
                     specObj = self.graphObjDict[key]
                     specObj.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 , xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None):
                     key = "spec"
                     specObj = self.graphObjDict[key]
                     specObj.initSubpage()
                     if xmin == None:
                         xmin = 0.
                     if xmax == None:
                         xmax = 1.
                     if ymin == None:
                         ymin = 0.
                     if ymax == None:
                         ymax = 1.
                     if zmin == None:
                         zmin = numpy.nanmin(data)
                     if zmax == None:
                         zmax = numpy.nanmax(data)
                     if not(specObj.hasRange):
                         self.setRanges([xmin, xmax], [ymin,ymax], [zmin,zmax])
                     specObj.basicPcolorPlot(data, xmin, xmax, ymin, ymax, specObj.zrange[0], specObj.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)/(power.shape[0]-1)
                         heis = numpy.arange(ymin, ymax + step, step)
                         key = "powerprof"
                         powObj = self.graphObjDict[key]
                         powObj.basicXYPlot(power, heis)
             class CrossSpectrum:
                 graphObjDict = {}
                 showColorbar = False
                 showPowerProfile = True
                 __szchar = 0.7
                 __showPhase = False
                 __xrange = None
                 __yrange = None
                 __zrange = None
                 m_BasicGraph= BasicGraph()
                 def __init__(self):
                     pass
                 def setup(self, subpage, title, xlabel, ylabel, colormap, showColorbar, showPowerProfile):
                     pass
                 def setRanges(self, xrange, yrange, zrange):
                     pass
                 def plotData(self, data, xmin, xmax, ymin, ymax, zmin, zmax):
                     pass
             if __name__ == '__main__':
                 import numpy
                 plplot.plsetopt("geometry", "%dx%d" %(350*2, 300*2))
                 plplot.plsdev("xcairo")
                 plplot.plscolbg(255,255,255)
                 plplot.plscol0(1,0,0,0)
                 plplot.plinit()
                 plplot.plssub(2, 2)
                 nx = 64
                 ny = 100
                 data = numpy.random.uniform(-50,50,(nx,ny))
                 specObj = Spectrum()
                 specObj.setup(1, "Spectrum", "Frequency", "Range", "br_green", False, False)
                 specObj.plotData(data)
                 data = numpy.random.uniform(-50,50,(nx,ny))
                 spec2Obj = Spectrum()
                 spec2Obj.setup(2, "Spectrum", "Frequency", "Range", "br_green", True, True)
                 spec2Obj.plotData(data)
                 plplot.plend()
                 exit(0)

schainpy/Graphics/VoltagePlot.py +2 -1

             '''
             Created on Feb 7, 2012
-            @author: roj-idl71
+            @author $Author$
+            @version $Id$
             '''
             class VoltagePlot(object):
                 '''
                 classdocs
                 '''
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     pass

schainpy/Graphics/__init__.py +5 0

@@ -1,1 +1,6
	1	'''
	2	Created on Feb 7, 2012
1	3
	4	@author $Author$
	5	@version $Id$
	6	'''

schainpy/IO/Correlation.py +2 -1

             '''
             Created on 23/01/2012
-            @author: danielangelsuarezmunoz
+            @author $Author$
+            @version $Id$
             '''
             from Data import DataReader
             from Data import DataWriter
             class CorrelationReader(DataReader):
                 def __init__(self):
                     pass
             class CorrelationWriter(DataWriter):
                 def __init__(self):
                     pass

schainpy/IO/Data.py +2 -1

             '''
             Created on 23/01/2012
-            @author: danielangelsuarezmunoz
+            @author $Author$
+            @version $Id$
             '''
             class DataReader:
                 __buffer = 0
                 __buffer_count = 0
                 def __init__(self):
                     pass
             class DataWriter:
                 __buffer = 0
                 __buffer_count = 0
                 def __init__(self):
                     pass

schainpy/IO/Header.py +7 0

+            '''
+            Created on 23/01/2012
+            @author $Author$
+            @version $Id$
+            '''
             import numpy
             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)
             class BasicHeader:
                 size = 0
                 version = 0
                 dataBlock = 0
                 utc = 0
                 miliSecond = 0
                 timeZone = 0
                 dstFlag = 0
                 errorCount = 0
                 struct = numpy.dtype([
                                       ('nSize','<u4'),
                                       ('nVersion','<u2'),
                                       ('nDataBlockId','<u4'),
                                       ('nUtime','<u4'),
                                       ('nMilsec','<u2'),
                                       ('nTimezone','<i2'),
                                       ('nDstflag','<i2'),
                                       ('nErrorCount','<u4')
                                       ])
                 def __init__(self):
                     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
             class SystemHeader:
                 size = 0
                 numSamples = 0
                 numProfiles = 0
                 numChannels = 0
                 adcResolution = 0
                 pciDioBusWidth = 0
                 struct = numpy.dtype([
                                     ('nSize','<u4'),
                                     ('nNumSamples','<u4'),
                                     ('nNumProfiles','<u4'),
                                     ('nNumChannels','<u4'),
                                     ('nADCResolution','<u4'),
                                     ('nPCDIOBusWidth','<u4'),
                                     ])
                 def __init__(self):
                     pass
                 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
             class RadarControllerHeader:
                 size = 0
                 expType = 0
                 nTx = 0
                 ipp = 0
                 txA = 0
                 txB = 0
                 numWindows = 0
                 numTaus = 0
                 codeType = 0
                 line6Function = 0
                 line5Fuction = 0
                 fClock = 0
                 prePulseBefore = 0
                 prePulserAfter = 0
                 rangeIpp = 0
                 rangeTxA = 0
                 rangeTxB = 0
                 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'),
                                      ])
                 def __init__(self):
                     pass
                 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.line5Fuction = 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
                     fp.seek(fp.tell() + 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.line5Fuction = self.line5Fuction
                     obj.fClock = self.fClock
                     obj.prePulseBefore = self.prePulseBefore
                     obj.prePulserAfter = self.prePulserAfter
                     obj.rangeIpp = self.rangeIpp
                     obj.rangeTxA = self.rangeTxA
                     obj.rangeTxB = self.rangeTxB
                     return obj
             class ProcessingHeader:
                 size = 0
                 dataType = 0
                 blockSize = 0
                 profilesPerBlock = 0
                 dataBlocksPerFile = 0
                 numWindows = 0
                 processFlags = 0
                 coherentInt = 0
                 incoherentInt = 0
                 totalSpectra = 0
                 struct = numpy.dtype([
                                        ('nSize','<u4'),
                                        ('nDataType','<u4'),
                                        ('nSizeOfDataBlock','<u4'),
                                        ('nProfilesperBlock','<u4'),
                                        ('nDataBlocksperFile','<u4'),
                                        ('nNumWindows','<u4'),
                                        ('nProcessFlags','<u4'),
                                        ('nCoherentIntegrations','<u4'),
                                        ('nIncoherentIntegrations','<u4'),
                                        ('nTotalSpectra','<u4')
                                        ])
                 samplingWindow = 0
                 structSamplingWindow = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
                 numHeights = 0
                 firstHeight = 0
                 deltaHeight = 0
                 samplesWin = 0
                 spectraComb = 0
                 numCode = 0
                 codes = 0
                 numBaud = 0
                 def __init__(self):
                     pass
                 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)
                     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
                     return obj

schainpy/IO/Spectra.py +2 -1

             '''
             Created on 23/01/2012
-            @author: danielangelsuarezmunoz
+            @author $Author$
+            @version $Id$
             '''
             from Header import *
             from Data import DataReader
             from Data import DataWriter
             class SpectraReader(DataReader):
                 def __init__(self):
                     pass
             class SpectraWriter(DataWriter):
                 def __init__(self):
                     pass

schainpy/IO/TestIO.py +2 -1

             '''
             Created on 23/01/2012
-            @author: danielangelsuarezmunoz
+            @author $Author$
+            @version $Id$
             '''
             import os
             import sys
             import datetime
             import time
             class TestIO():
                 def __init__(self):
                     self.setValues()
                     self.createVoltageObjects()
                     self.testReadVoltage()
                     pass
                 def setValues(self):
                     self.path = '/Users/danielangelsuarezmunoz/Documents/Projects'
                     self.startDateTime = datetime.datetime(2007,5,1,17,49,0)
                     self.endDateTime = datetime.datetime(2007,5,1,18,10,0)
                 def createVoltageObjects(self):
                     path = os.path.split(os.getcwd())[0]
                     sys.path.append(path)
                     from IO.Voltage import VoltageReader
                     from Model.Voltage import Voltage
                     self.voltageModelObj = Voltage()
                     self.voltageReaderObj = VoltageReader(self.voltageModelObj)
                     self.voltageReaderObj.setup(self.path, self.startDateTime, self.endDateTime)
                 def testReadVoltage(self):
                     while(not(self.voltageReaderObj.noMoreFiles)):
                         self.voltageReaderObj.getData()
                         if self.voltageReaderObj.flagResetProcessing:
                             print 'jump'
                         if self.voltageReaderObj.flagIsNewBlock:
                             print 'Block No %04d, Time: %s'%(self.voltageReaderObj.nReadBlocks,
                                                              datetime.datetime.fromtimestamp(self.voltageReaderObj.m_BasicHeader.utc))
             if __name__ == '__main__':
                 TestIO()

schainpy/IO/Voltage.py +2 -2

             '''
             Created on 23/01/2012
-            @author: danielangelsuarezmunoz
+            @author $Author$
+            @version $Id$
             '''
             import os, sys
             import numpy
             import glob
             import fnmatch
             import time
             import datetime
             from IO.Header import *
             from IO.Data import DataReader
             from IO.Data import DataWriter
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from Model.Voltage import Voltage
             class VoltageReader(DataReader):
                 __idFile = None
                 __fp = None
                 __startDateTime = None
                 __endDateTime = None
                 __dataType = None
                 __fileSizeByHeader = 0
                 __pathList = []
                 filenameList = []
                 __lastUTTime = 0
                 __maxTimeStep = 5
                 __flagIsNewFile = 0
                 __ippSeconds = 0
                 flagResetProcessing = 0
                 flagIsNewBlock = 0
                 noMoreFiles = 0
                 nReadBlocks = 0
                 online = 0
                 filename = None
                 fileSize = None
                 firstHeaderSize = 0
                 basicHeaderSize = 24
                 m_BasicHeader = BasicHeader()
                 m_SystemHeader = SystemHeader()
                 m_RadarControllerHeader = RadarControllerHeader()
                 m_ProcessingHeader = ProcessingHeader()
                 m_Voltage = None
                 __buffer = 0
                 __buffer_id = 9999
                 def __init__(self, m_Voltage = None):
                     if m_Voltage == None:
                         m_Voltage = Voltage()
                     self.m_Voltage = m_Voltage
                 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 __searchFiles(self,path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".r"):
                     print "Searching files ..."
                     startUtSeconds = time.mktime(startDateTime.timetuple())
                     endUtSeconds = time.mktime(endDateTime.timetuple())
             #        startYear = startDateTime.timetuple().tm_year
             #        endYear = endDateTime.timetuple().tm_year
             #
             #        startDoy = startDateTime.timetuple().tm_yday
             #        endDoy = endDateTime.timetuple().tm_yday
             #
             #        yearRange = range(startYear,endYear+1)
             #
             #        doyDoubleList = []
             #        if startYear == endYear:
             #            doyList = range(startDoy,endDoy+1)
             #        else:
             #            for year in yearRange:
             #                if (year == startYear):
             #                    doyDoubleList.append(range(startDoy,365+1))
             #                elif (year == endYear):
             #                    doyDoubleList.append(range(1,endDoy+1))
             #                else:
             #                    doyDoubleList.append(range(1,365+1))
             #            doyList = []
             #            for list in doyDoubleList:
             #                doyList = doyList + list
             #
             #        dirList = []
             #        for thisPath in os.listdir(path):
             #            if os.path.isdir(os.path.join(path,thisPath)):
             #                #dirList.append(os.path.join(path,thisPath))
             #                dirList.append(thisPath)
             #
             #        pathList = []
             #        pathDict = {}
             #        for year in yearRange:
             #            for doy in doyList:
             #                match = fnmatch.filter(dirList, 'D' + '%4.4d%3.3d' % (year,doy))
             #                if len(match) == 0:
             #                    match = fnmatch.filter(dirList, 'd' + '%4.4d%3.3d' % (year,doy))
             #                    if len(match) == 0: continue
             #                if expLabel == '':
             #                    pathList.append(os.path.join(path,match[0]))
             #                    pathDict.setdefault(os.path.join(path,match[0]))
             #                    pathDict[os.path.join(path,match[0])] = []
             #                else:
             #                    pathList.append(os.path.join(path,os.path.join(match[0],expLabel)))
             #                    pathDict.setdefault(os.path.join(path,os.path.join(match[0],expLabel)))
             #                    pathDict[os.path.join(path,os.path.join(match[0],expLabel))] = []
                     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)
                     filenameList = []
                     for thisPath in pathList:
                         fileList = glob.glob1(thisPath, "*%s" %ext)
                         #pathDict[thisPath].append(fileList)
                         fileList.sort()
                         for file in fileList:
                             filename = os.path.join(thisPath,file)
                             if self.isThisFileinRange(filename, startUtSeconds, endUtSeconds):
                                 filenameList.append(filename)
                     self.filenameList = filenameList
                     return pathList, filenameList
                 def isThisFileinRange(self, filename, startUTSeconds=None, endUTSeconds=None):
                     try:
                         fp = open(filename,'rb')
                     except:
                         raise IOError, "The file %s can't be opened" %(filename)
                     if startUTSeconds==None:
                         startUTSeconds = self.startUTCSeconds
                     if endUTSeconds==None:
                         endUTSeconds = self.endUTCSeconds
                     m_BasicHeader = BasicHeader()
                     if not(m_BasicHeader.read(fp)):
                         return 0
                     fp.close()
                     if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)):
                         return 0
                     return 1
                 def __readBasicHeader(self, fp=None):
                     if fp == None:
                         fp = self.__fp
                     self.m_BasicHeader.read(fp)
                 def __readFirstHeader(self):
                     self.__readBasicHeader()
                     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'
                     self.__dataType = tmp
                     self.__fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
                     c=3E8
                     self.__ippSeconds = 2*1000*self.m_RadarControllerHeader.ipp/c
                 def __setNextFileOnline(self):
                     return 0
                 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)
                         fp = open(filename,'rb')
                         currentSize = fileSize - fp.tell()
                         neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
                         if (currentSize < neededSize):
                             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:
                         return self.__setNextFileOnline()
                     else:
                         return self.__setNextFileOffline()
                 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
                     # Bloque Completo
                     if (currentSize >= neededSize):
                         self.__readBasicHeader()
                         return 1
                     if not(self.__setNextFile()):
                         return 0
                     self.__readFirstHeader()
                     deltaTime = self.m_BasicHeader.utc - self.__lastUTTime # check this
                     self.flagResetProcessing = 0
                     if deltaTime > self.__maxTimeStep:
                         self.flagResetProcessing = 1
                         self.nReadBlocks = 0
                     return 1
                 def __readBlock(self):
                     """Lee el bloque de datos desde la posicion actual del puntero del archivo y
                     actualiza todos los parametros relacionados al bloque de datos (data, time,
                     etc). La data leida es almacenada en el buffer y el contador de datos leidos es
                     seteado a 0
                     """
                     pts2read = self.m_ProcessingHeader.profilesPerBlock*self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels
                     data = numpy.fromfile(self.__fp,self.__dataType,pts2read)
                     data = data.reshape((self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels))
                     self.__flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nReadBlocks += 1
                     self.__buffer = data
                     self.__buffer_id = 0
                 def readNextBlock(self):
                     if not(self.__setNewBlock()):
                         return 0
                     self.__readBlock()
                     self.__lastUTTime = self.m_BasicHeader.utc
                     return 1
                 def __hasNotDataInBuffer(self):
                     if self.__buffer_id >= self.m_ProcessingHeader.profilesPerBlock:
                         return 1
                     return 0
                 def getData(self):
                     """Obtiene un unidad de datos del buffer de lectura y es copiada a la clase "Voltage"
                     con todos los parametros asociados a este. cuando no hay datos en el buffer de
                     lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
                     """
                     self.flagResetProcessing = 0
                     self.flagIsNewBlock = 0
                     if self.__hasNotDataInBuffer():
                         self.readNextBlock()
                     if self.noMoreFiles == 1:
                         print 'Process finished'
                         return None
                     data = self.__buffer[self.__buffer_id,:,:]
                     time = self.m_BasicHeader.utc + self.__buffer_id*self.__ippSeconds
                     self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy()
                     self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy()
                     self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
                     self.m_Voltage.m_SystemHeader = self.m_SystemHeader.copy()
                     self.m_Voltage.m_BasicHeader.utc = time
                     self.m_Voltage.data = data
                     self.__buffer_id += 1
                     #call setData - to Data Object
                     return data
                 def setup(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".r", online = 0):
                     if online == 0:
                         pathList, filenameList = self.__searchFiles(path, startDateTime, endDateTime, set, expLabel, ext)
                         if len(filenameList) == 0:
                             self.__fp = None
                             self.noMoreFiles = 1
                             print 'Do not exist files in range: %s - %s'%(startDateTime.ctime(), endDateTime.ctime())
                             return 0
             #        for thisFile in filenameList:
             #            print thisFile
                     self.__idFile = -1
                     if not(self.__setNextFile()):
                         print "No more files"
                         return 0
                     self.__readFirstHeader()
                     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
             class VoltageWriter(DataWriter):
                 m_BasicHeader= BasicHeader()
                 m_SystemHeader = SystemHeader()
                 m_RadarControllerHeader = RadarControllerHeader()
                 m_ProcessingHeader = ProcessingHeader()
                 m_Voltage = None
                 def __init__(self, m_Voltage):
                     self.m_Voltage = m_Voltage
   No newline at end of file

schainpy/IO/__init__.py +5 0

@@ -1,1 +1,6
	1	'''
	2	Created on 23/01/2012
1	3
	4	@author $Author$
	5	@version $Id$
	6	'''

schainpy/Model/Correlation.py +2 -1

             '''
             Created on Feb 7, 2012
-            @author: roj-idl71
+            @author $Author$
+            @version $Id$
             '''
             class Correlation(Data):
                 '''
                 classdocs
                 '''
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     pass
                 def copy(self):
                     pass

schainpy/Model/Data.py +2 -1

             '''
             Created on Feb 7, 2012
-            @author: roj-idl71
+            @author $Author$
+            @version $Id$
             '''
             class Data:
                 '''
                 classdocs
                 '''
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     pass
                 def copy(self):
                     pass
   No newline at end of file

schainpy/Model/Noise.py +2 -1

             '''
             Created on Feb 7, 2012
-            @author: roj-idl71
+            @author $Author$
+            @version $Id$
             '''
             class Noise:
                 '''
                 classdocs
                 '''
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     pass
   No newline at end of file

schainpy/Model/Spectra.py +2 -1

             '''
             Created on Feb 7, 2012
-            @author: roj-idl71
+            @author $Author$
+            @version $Id$
             '''
             class Spectra(Data):
                 '''
                 classdocs
                 '''
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     pass
                 def copy(self):
                     pass
   No newline at end of file

schainpy/Model/Voltage.py +2 -1

             '''
             Created on Feb 7, 2012
-            @author: roj-idl71
+            @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.Header import *
             class Voltage(Data):
                 '''
                 classdocs
                 '''
                 m_RadarControllerHeader= RadarControllerHeader()
                 m_ProcessingHeader= ProcessingHeader()
                 m_SystemHeader= SystemHeader()
                 m_BasicHeader= BasicHeader()
                 data = None
                 noData = True
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     pass
                 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()
                     return obj
   No newline at end of file

schainpy/Model/__init__.py +6 0

@@ -0,0 +1,6
	1	'''
	2	Created on Feb 7, 2012
	3
	4	@author $Author$
	5	@version $Id$
	6	''' No newline at end of file

schainpy/Processing/CorrelationProcessor.py +2 -1

             '''
             Created on Feb 7, 2012
-            @author: roj-idl71
+            @author $Author$
+            @version $Id$
             '''
             class CorrelationProcessor:
                 '''
                 classdocs
                 '''
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     pass

schainpy/Processing/SpectraProcessor.py +2 -1

             '''
             Created on Feb 7, 2012
-            @author: roj-idl71
+            @author $Author$
+            @version $Id$
             '''
             class SpectraProcessor:
                 '''
                 classdocs
                 '''
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     pass

schainpy/Processing/VoltageProcessor.py +2 -1

             '''
             Created on Feb 7, 2012
-            @author: roj-idl71
+            @author $Author$
+            @version $Id$
             '''
             class VoltageProcessor:
                 '''
                 classdocs
                 '''
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     pass

schainpy/Processing/__init__.py +6 0

@@ -0,0 +1,6
	1	'''
	2	Created on Feb 7, 2012
	3
	4	@author $Author$
	5	@version $Id$
	6	''' No newline at end of file

schainpy/Utilities/FtpServer.py +2 -1

             '''
             Created on Feb 7, 2012
-            @author: roj-idl71
+            @author $Author$
+            @version $Id$
             '''
             class FtpServer:
                 '''
                 classdocs
                 '''
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     pass
   No newline at end of file

schainpy/Utilities/FtpServerList.py +2 -1

             '''
             Created on Feb 7, 2012
-            @author: roj-idl71
+            @author $Author$
+            @version $Id$
             '''
             class FtpServerList:
                 '''
                 classdocs
                 '''
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     pass
                 m_FtpServer= FtpServer()

schainpy/Utilities/__init__.py +6 0

@@ -0,0 +1,6
	1	'''
	2	Created on Feb 7, 2012
	3
	4	@author $Author$
	5	@version $Id$
	6	''' No newline at end of file

schainpy/__init__.py +5 0

@@ -1,1 +1,6
	1	'''
	2	Created on Feb 7, 2012
1	3
	4	@author $Author$
	5	@version $Id$
	6	'''

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