schain-jc Commit - r11:0b04e9cb0675 · Jicamarca Repository

Miguel Valdez -

r11:0b04e9cb0675

parent child

Context file:

r11:0b04e9cb0675

schainpy/Graphics/VoltagePlot.py created 644 +17 0

@@ -0,0 +1,17
	1	'''
	2	Created on Feb 7, 2012
	3
	4	@author: roj-idl71
	5	'''
	6
	7	class VoltagePlot(object):
	8	'''
	9	classdocs
	10	'''
	11
	12
	13	def __init__(self):
	14	'''
	15	Constructor
	16	'''
	17	pass No newline at end of file

schainpy/Graphics/SpectraPlot.py +18 -4

             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):
+                def setup(self, subpage, title, xlabel, ylabel, colormap, showColorbar, showPowerProfile):
                     pass
-                def plotData(self):
+                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/IO/TestReader.py +11 -8

             '''
             Created on 23/01/2012
             @author: danielangelsuarezmunoz
             '''
-            import VoltageReader
+            import Voltage
             import datetime
             import time
-            objReader = VoltageReader.VoltageReader()
+            objReader = Voltage.VoltageReader()
-            path = '/Users/danielangelsuarezmunoz/Documents/Projects'
-            startDateTime = datetime.datetime(2007,1,1,16,0,0)
+            path = '/home/roj-idl71/Data/RAWDATA/DP_Faraday/'
-            endDateTime = datetime.datetime(2007,12,1,17,1,0)
+            startDateTime = datetime.datetime(2011,3,11,16,0,0)
+            endDateTime = datetime.datetime(2011,3,11,20,1,0)
             set = None
             expLabel = ''
             ext = '*.r'
             t0 = time.time()
-            objReader.setup(path, startDateTime, endDateTime, set, expLabel, ext)
+            objReader.setup(path, startDateTime, endDateTime)
-            print time.time() - t0
+            #print time.time() - t0
             while(not(objReader.noMoreFiles)):
                 objReader.getData()
+            #    if objReader.flagIsNewFile:
+            #        print objReader.m_BasicHeader.dataBlock
                 #print objReader.objStructShortHeader.dataBlock
-                #print time.localtime(objReader.objStructShortHeader.universalTime)
+                #print time.localtime(objReader.m_BasicHeader.utc)
   No newline at end of file

schainpy/IO/Voltage.py +54 -43

             '''
             Created on 23/01/2012
             @author: danielangelsuarezmunoz
             '''
             import os, sys
             import numpy
             import glob
             import fnmatch
             import time
             import datetime
             from Header import *
             from Data import DataReader
             from Data import DataWriter
             path = os.path.split(os.getcwd())[0]
-            sys.path.append(os.path.join(path,"Model"))
+            sys.path.append(path)
-            from Voltage import Voltage
+            from Model.Voltage import Voltage
             class VoltageReader(DataReader):
-                __idFile = 0
+                __idFile = None
-                __fp = 0
+                __fp = None
-                __startDateTime = 0
+                __startDateTime = None
-                __endDateTime = 0
+                __endDateTime = None
-                __dataType = 0
+                __dataType = None
-                __sizeOfFileByHeader = 0
+                __fileSizeByHeader = 0
                 __pathList = []
                 filenameList = []
                 __lastUTTime = 0
                 __maxTimeStep = 5
                 flagResetProcessing = 0
                 __flagIsNewFile = 0
                 noMoreFiles = 0
                 online = 0
-                filename = ''
+                filename = None
-                fileSize = 0
+                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):
+                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"):
+                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
-                    rangeOfYears = range(startYear,endYear+1)
+                    yearRange = range(startYear,endYear+1)
-                    listOfListDoys = []
+                    doyDoubleList = []
                     if startYear == endYear:
                         doyList = range(startDoy,endDoy+1)
                     else:
-                        for year in rangeOfYears:
+                        for year in yearRange:
                             if (year == startYear):
-                                listOfListDoys.append(range(startDoy,365+1))
+                                doyDoubleList.append(range(startDoy,365+1))
                             elif (year == endYear):
-                                listOfListDoys.append(range(1,endDoy+1))
+                                doyDoubleList.append(range(1,endDoy+1))
                             else:
-                                listOfListDoys.append(range(1,365+1))
+                                doyDoubleList.append(range(1,365+1))
                         doyList = []
-                        for list in listOfListDoys:
+                        for list in doyDoubleList:
                             doyList = doyList + list
-                    folders = []
+                    doyPathList = []
                     for thisPath in os.listdir(path):
                         if os.path.isdir(os.path.join(path,thisPath)):
-                            #folders.append(os.path.join(path,thisPath))
+                            #doyPathList.append(os.path.join(path,thisPath))
-                            folders.append(thisPath)
+                            doyPathList.append(thisPath)
                     pathList = []
-                    dicOfPath = {}
+                    pathDict = {}
-                    for year in rangeOfYears:
+                    for year in yearRange:
                         for doy in doyList:
-                            tmp = fnmatch.filter(folders, 'D' + '%4.4d%3.3d' % (year,doy))
+                            match = fnmatch.filter(doyPathList, 'D' + '%4.4d%3.3d' % (year,doy))
-                            if len(tmp) == 0:
+                            if len(match) == 0:
-                                continue
+                                match = fnmatch.filter(doyPathList, 'd' + '%4.4d%3.3d' % (year,doy))
+                                if len(match) == 0: continue
                             if expLabel == '':
-                                pathList.append(os.path.join(path,tmp[0]))
+                                pathList.append(os.path.join(path,match[0]))
-                                dicOfPath.setdefault(os.path.join(path,tmp[0]))
+                                pathDict.setdefault(os.path.join(path,match[0]))
-                                dicOfPath[os.path.join(path,tmp[0])] = []
+                                pathDict[os.path.join(path,match[0])] = []
                             else:
-                                pathList.append(os.path.join(path,os.path.join(tmp[0],expLabel)))
+                                pathList.append(os.path.join(path,os.path.join(match[0],expLabel)))
-                                dicOfPath.setdefault(os.path.join(path,os.path.join(tmp[0],expLabel)))
+                                pathDict.setdefault(os.path.join(path,os.path.join(match[0],expLabel)))
-                                dicOfPath[os.path.join(path,os.path.join(tmp[0],expLabel))] = []
+                                pathDict[os.path.join(path,os.path.join(match[0],expLabel))] = []
                     filenameList = []
                     for thisPath in pathList:
-                        fileList = glob.glob1(thisPath, ext)
+                        fileList = glob.glob1(thisPath, "*%s" %ext)
-                        #dicOfPath[thisPath].append(fileList)
+                        #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:
                         print 'no define data type'
                         tmp = 0
                     self.__dataType = tmp
-                    self.__sizeOfFileByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
+                    self.__fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
                 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
                     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.__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 "Data"
                     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
                     "__readBlock"
                     """
                     self.flagResetProcessing = 0
                     if self.__hasNotDataInBuffer():
                         self.readNextBlock()
                     if self.noMoreFiles == 1:
-                        print 'read finished'
+                        print 'Process finished'
                         return None
                     data = self.__buffer[self.__buffer_id,:,:]
                     time = 111
-                    self.m_Voltage.data = data
+            #        self.m_Voltage.data = data
-                    self.m_Voltage.timeProfile = time
+            #        self.m_Voltage.timeProfile = time
-                    self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy()
+            #        self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy()
-                    self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy()
+            #        self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy()
-                    self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
+            #        self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
-                    self.m_Voltage.m_SystemHeader = self.m_systemHeader.copy()
+            #        self.m_Voltage.m_SystemHeader = self.m_systemHeader.copy()
                     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/Model/Voltage.py +7 0

             '''
             Created on Feb 7, 2012
             @author: roj-idl71
             '''
+            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()
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     pass
                 def copy(self):
                     pass
   No newline at end of file

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