schain Commit - r153:e56dcbb72a43 · Jicamarca Repository

-Actualización del modulo SpectraProcessor, SchainPlot y schainPlotLib...

Miguel Valdez -

r153:e56dcbb72a43

parent child

Context file:

r153:e56dcbb72a43

Collapse all files

schainpy2/Data/JROData.py +14 -4

                 channelIndexList = None
-                flagNoData = False
+                flagNoData = True
                 flagTimeBlock = False
-                dataUtcTime = None
+                utctime = None
+                blocksize = None
                 nCode = None
                     self.flagTimeBlock = False
-                    self.dataUtcTime = None
+                    self.utctime = None
                     self.nCohInt = None
+                    self.blocksize = None
             class Spectra(JROData):
                     self.flagTimeBlock = False
-                    self.dataUtcTime = None
+                    self.utctime = None
                     self.nIncohInt = None
+                    self.blocksize = None
             class SpectraHeis(JROData):
                     self.flagTimeBlock = False
                     self.nPairs = 0
+                    self.utctime = None
+                    self.blocksize = None

schainpy2/Graphics/schainPlot.py +50 -8

             from schainPlotLib import Driver
             class Figure:
                 __isDriverOpen = False
                 __isFigureOpen = False
                 __isConfig = False
                 drvObj = None
+                driver = None
                 idfigure = None
                 nframes = None
                 wintitle = None
                 colormap = None
-                driver = None
                 overplot = None
+                colorbar = None
+                frameObjList = []
+                xw = None
+                yw = None
                 xmin = None
                 xmax = None
                 ymin = None
                 ymax = None
                 minvalue = None
                 maxvalue = None
                 deltax = None
                 deltay = None
-                frameObjList = []
                 figuretitle = ""
                 xrangestep = None
                 def __init__(self,idfigure, nframes, wintitle, xw=600, yw=800, overplot=0, driver='plplot', colormap=None, colorbar= True, *args):
+                    self.__isDriverOpen = False
+                    self.__isFigureOpen = False
+                    self.__isConfig = False
                     self.drvObj = Driver(driver, idfigure, xw, yw, wintitle, overplot, colormap, colorbar)
                     self.driver = driver
                     self.idfigure = idfigure
-                    self.xw = xw
-                    self.yw = yw
                     self.nframes = nframes
                     self.wintitle = wintitle
                     self.colormap = colormap
                     self.overplot = overplot
                     self.colorbar = colorbar
+                    self.xw = xw
+                    self.yw = yw
+                    self.frameObjList = []
             #        self.showGraph1 = args[0]
             #        self.showGraph2 = args[1]
                     self.drvObj.driver.setFigure()
                     self.drvObj.driver.setColormap(colormap)
                 def __openDriver(self):
                     self.drvObj.driver.openDriver()
                 def __initFigure(self):
                     nrows, ncolumns = self.getSubplots()
                     self.drvObj.driver.openFigure()
                     self.drvObj.driver.setFigTitle(self.figuretitle)
                     self.drvObj.driver.setSubPlots(nrows, ncolumns)
+                def selectFigure(self):
+                    self.drvObj.driver.selectFigure()
                 def __isOutOfXRange(self,x):
                     try:
                         if ((x>=self.xmin) and (x<self.xmax)):
                     raise ValueError, "No implemented"
                 def save(self,filename):
                     self.drvObj.driver.save(filename)
                 def plot1DArray(self, data1D, x=None, channelList=None, xmin=None, xmax=None, minvalue=None, maxvalue=None, figuretitle=None, save=False, gpath='./'):
                             self.drvObj.driver.closePage()
                             self.__isFigureOpen = False
+                    self.selectFigure()
                     self.__initFigure()
                     for channel in channelList:
                         frameObj = self.frameObjList[channel]
                         frameObj.init(xmin=self.xmin,
                                           self.deltay,
                                           self.colorbar,
                                           value)
+                    self.selectFigure()
                     for channel in channelList:
                         dataCh = data[channel,:]
             class Frame:
+                drvObj = None
+                idFrame = None
                 nplots = None
                 plotObjList = []
                 title = ""
                 def __init__(self,drvObj, idframe):
                     self.drvObj = drvObj
                     self.idframe = idframe
+                    nplots = None
+                    self.plotObjList = []
                     self.createPlots()
                 def createPlots(self):
             class Plot:
+                drvObj = None
+                idframe = None
+                idplot = None
+                xi = None
+                yi = None
+                xw = None
+                yw = None
                 title = ""
                 xlabel = ""
                 ylabel = ""
                 cbypos = None
                 def __init__(self, drvObj, idframe, idplot, xi, yi, xw, yw):
                     self.drvObj = drvObj
                     self.idframe = idframe
                     self.idplot = idplot

schainpy2/Graphics/schainPlotLib.py +4 -1

                     plplot.plparseopts([self.wintitle],plplot.PL_PARSE_FULL)
                     plplot.plsetopt("geometry", "%dx%d"%(self.xw, self.yw))
+                def selectFigure(self):
+                    plplot.plsstrm(self.idfigure)
                 def openDriver(self, pldriver=None):
                     if pldriver == None:
                         rgb_lvl = [8,8,4]  #Levels for RGB colors
                     if ncolor == None:
-                        raise ValueError, "The colormap selected is not valid"
+                        raise ValueError, "The colormap selected (%s) is not valid" %(colormap)
                     plplot.plscmap1n(ncolor)
                     plplot.plscmap1l(1, pos, r, g, b)

schainpy2/IO/JRODataIO.py +1 -1

                         pass
                     else:
-                        print "Searching files in offline mode"
+                        print "Searching files in offline mode ..."
                         pathList, filenameList = self.__searchFilesOffLine(path, startDate, endDate, startTime, endTime, set, expLabel, ext)
                         if not(pathList):

schainpy2/IO/SpectraIO.py +3 -3

                     self.dataOutObj.channelIndexList = range(self.systemHeaderObj.nChannels)
-                    self.dataOutObj.dataUtcTime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000.#+ self.profileIndex * self.ippSeconds
+                    self.dataOutObj.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000.#+ self.profileIndex * self.ippSeconds
                     self.dataOutObj.flagShiftFFT = self.processingHeaderObj.shif_fft
                     self.basicHeaderObj.version = self.versionFile
                     self.basicHeaderObj.dataBlock = self.nTotalBlocks
-                    utc = numpy.floor(self.dataOutObj.dataUtcTime)
+                    utc = numpy.floor(self.dataOutObj.utctime)
-                    milisecond  = (self.dataOutObj.dataUtcTime - utc)* 1000.0
+                    milisecond  = (self.dataOutObj.utctime - utc)* 1000.0
                     self.basicHeaderObj.utc = utc
                     self.basicHeaderObj.miliSecond = milisecond

schainpy2/IO/VoltageIO.py +3 -3

                     self.dataOutObj.flagTimeBlock = self.flagTimeBlock
-                    self.dataOutObj.dataUtcTime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.ippSeconds
+                    self.dataOutObj.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.ippSeconds
                     self.dataOutObj.nCohInt = self.processingHeaderObj.nCohInt
                     self.basicHeaderObj.version = self.versionFile
                     self.basicHeaderObj.dataBlock = self.nTotalBlocks
-                    utc = numpy.floor(self.dataOutObj.dataUtcTime)
+                    utc = numpy.floor(self.dataOutObj.utctime)
-                    milisecond  = (self.dataOutObj.dataUtcTime - utc)* 1000.0
+                    milisecond  = (self.dataOutObj.utctime - utc)* 1000.0
                     self.basicHeaderObj.utc = utc
                     self.basicHeaderObj.miliSecond = milisecond

schainpy2/Processing/SpectraProcessor.py +94 -39

             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
-            from Data.JROData import SpectraHeis
+            from Data.JROData import Spectra, SpectraHeis
             from IO.SpectraIO import SpectraWriter
             from Graphics.schainPlotTypes import ScopeFigure, SpcFigure
             #from JRONoise import Noise
                     self.plotObjIndex = None
                     self.integratorOst = []
                     self.plotObjList = []
-                    self.noiseObj = bjList = []
+                    self.noiseObj = []
-                    self.writerObjLiNone
+                    self.writerObjList = []
                     self.buffer = None
                     self.profIndex = 0
                         raise ValueError, "This SpectraProcessor.setup() function needs dataInObj input variable"
                     if dataInObj.type == "Voltage":
                         if nFFTPoints == None:
                             raise ValueError, "This SpectraProcessor.setup() function needs nFFTPoints input variable"
-                    else:
+                    if dataInObj.type == "Spectra":
+                        if nFFTPoints != None:
+                            raise ValueError, "The nFFTPoints cannot be selected to this object type"
                         nFFTPoints = dataInObj.nFFTPoints
+                        if pairList == None:
+                            pairList = self.dataInObj.pairList
+                    if pairList == None:
+                        nPairs = 0
+                    else:
+                        nPairs = len(pairList)
                     self.dataInObj = dataInObj
                         dataOutObj = Spectra()
                     self.dataOutObj = dataOutObj
+                    self.dataOutObj.nFFTPoints = nFFTPoints
+                    self.dataOutObj.pairList = pairList
+                    self.dataOutObj.nPairs = nPairs
                     return self.dataOutObj
                 def init(self):
+                    self.dataOutObj.flagNoData = True
+                    if self.dataInObj.flagNoData:
+                        return 0
                     self.integratorObjIndex = 0
                     self.writerObjIndex = 0
                     self.plotObjIndex = 0
+                    if self.dataInObj.type == "Spectra":
+                        self.dataOutObj.copy(self.dataInObj)
+                        self.dataOutObj.flagNoData = False
+                        return
                     if self.dataInObj.type == "Voltage":
                         if self.buffer == None:
-                            self.buffer = numpy.zeros((self.nChannels,
+                            self.buffer = numpy.zeros((self.dataInObj.nChannels,
-                                                       self.nFFTPoints,
+                                                       self.dataOutObj.nFFTPoints,
                                                        self.dataInObj.nHeights),
                                                       dtype='complex')
                         self.buffer[:,self.profIndex,:] = self.dataInObj.data
                         self.profIndex += 1
-                        if self.profIndex == self.nFFTPoints:
+                        if self.profIndex == self.dataOutObj.nFFTPoints:
+                            self.__updateObjFromInput()
                             self.__getFft()
                             self.dataOutObj.flagNoData = False
                             self.buffer = None
                             self.profIndex = 0
-                            return
-                        self.dataOutObj.flagNoData = True
-                        return
-                    #Other kind of data
-                    if self.dataInObj.type == "Spectra":
-                        self.dataOutObj.copy(self.dataInObj)
-                        self.dataOutObj.flagNoData = False
                         return
-                    raise ValueError, "The dtype is not valid"
+                    #Other kind of data
+                    raise ValueError, "The type object %(s) is not valid " %(self.dataOutObj.type)
                 def __getFft(self):
                     """
                         self.dataOutObj.m_ProcessingHeader.spectraComb
                         self.dataOutObj.m_ProcessingHeader.shif_fft
                     """
-                    if self.dataInObj.flagNoData:
-                        return 0
                     fft_volt = numpy.fft.fft(self.buffer,axis=1)
                     dc = fft_volt[:,0,:]
                     cspc = None
                     pairIndex = 0
-                    if self.pairList != None:
+                    if self.dataOutObj.pairList != None:
                         #calculo de cross-spectra
-                        cspc = numpy.zeros((self.nPairs, self.nFFTPoints, self.nHeights), dtype='complex')
+                        cspc = numpy.zeros((self.dataOutObj.nPairs, self.dataOutObj.nFFTPoints, self.dataOutObj.nHeights), dtype='complex')
                         for pair in self.pairList:
                             cspc[pairIndex,:,:] = numpy.abs(fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:]))
                             pairIndex += 1
                     self.dataOutObj.data_spc = spc
                     self.dataOutObj.data_cspc = cspc
                     self.dataOutObj.data_dc = dc
-                    self.dataOutObj.m_ProcessingHeader.blockSize = blocksize
+                    self.dataOutObj.blockSize = blocksize
-                    self.dataOutObj.m_BasicHeader.utc = self.dataInObj.m_BasicHeader.utc
             #        self.getNoise()
+                def __updateObjFromInput(self):
+                    self.dataOutObj.radarControllerHeaderObj = self.dataInObj.radarControllerHeaderObj.copy()
+                    self.dataOutObj.systemHeaderObj = self.dataInObj.systemHeaderObj.copy()
+                    self.dataOutObj.channelList = self.dataInObj.channelList
+                    self.dataOutObj.heightList = self.dataInObj.heightList
+                    self.dataOutObj.dtype = self.dataInObj.dtype
+                    self.dataOutObj.nHeights = self.dataInObj.nHeights
+                    self.dataOutObj.nChannels = self.dataInObj.nChannels
+                    self.dataOutObj.nBaud = self.dataInObj.nBaud
+                    self.dataOutObj.nCode = self.dataInObj.nCode
+                    self.dataOutObj.code = self.dataInObj.code
+                    self.dataOutObj.nProfiles = self.dataOutObj.nFFTPoints
+                    self.dataOutObj.channelIndexList = self.dataInObj.channelIndexList
+                    self.dataOutObj.flagTimeBlock = self.dataInObj.flagTimeBlock
+                    self.dataOutObj.utctime = self.dataInObj.utctime
+                    self.dataOutObj.flagDecodeData = self.dataInObj.flagDecodeData #asumo q la data esta decodificada
+                    self.dataOutObj.flagDeflipData = self.dataInObj.flagDeflipData #asumo q la data esta sin flip
+                    self.dataOutObj.flagShiftFFT = self.dataInObj.flagShiftFFT
+                    self.dataOutObj.nIncohInt = 1
                 def addWriter(self, wrpath, blocksPerFile):
                     objWriter = SpectraWriter(self.dataOutObj)
                     objWriter.setup(wrpath, blocksPerFile)
                     self.writerObjList.append(objWriter)
                     self.integratorObjList.append(objIncohInt)
                 def addSpc(self, idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile):
                     spcObj = SpcFigure(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
                     self.plotObjList.append(spcObj)
                                 maxvalue=None,
                                 wintitle='',
                                 driver='plplot',
-                                colormap='br_greeen',
+                                colormap='br_green',
                                 colorbar=True,
                                 showprofile=False,
                                 save=False,
-                                gpath=None):
+                                gpath=None,
+                                channelList = None):
                     if self.dataOutObj.flagNoData:
                         return 0
-                    nframes = len(self.dataOutObj.channelList)
+                    if channelList == None:
+                        channelList = self.dataOutObj.channelList
+                    nframes = len(channelList)
                     if len(self.plotObjList) <= self.plotObjIndex:
                         self.addSpc(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
                     y = self.dataOutObj.heightList
-                    channelList = self.dataOutObj.channelList
                     data = 10.*numpy.log10(self.dataOutObj.data_spc[channelList,:,:])
             #        noisedB = 10.*numpy.log10(noise)
                     noisedB = numpy.arange(len(channelList)+1)
                         title = "%.2f"%noisedB[i]
                         titleList.append(title)
-                    thisdatetime = datetime.datetime.fromtimestamp(self.dataOutObj.dataUtcTime)
+                    thisdatetime = datetime.datetime.fromtimestamp(self.dataOutObj.utctime)
                     dateTime = "%s"%(thisdatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     figuretitle = "Spc Radar Data: %s"%dateTime
                 def writeData(self, wrpath, blocksPerFile):
                     if self.dataOutObj.flagNoData:
-                            return 0
+                        return 0
                     if len(self.writerObjList) <= self.writerObjIndex:
                         self.addWriter(wrpath, blocksPerFile)
                     return self.dataOutObj
                 def init(self):
+                    self.dataOutObj.flagNoData = True
+                    if self.dataInObj.flagNoData:
+                        return 0
                     self.integratorObjIndex = 0
                     self.writerObjIndex = 0
                     self.plotObjIndex = 0
                     if self.dataInObj.type == "Voltage":
+                        self.__updateObjFromInput()
                         self.__getFft()
-                        self.__updateFromObj()
                         self.dataOutObj.flagNoData = False
                         return
                     raise ValueError, "The type is not valid"
-                def __updateFromObj(self):
+                def __updateObjFromInput(self):
                     self.dataOutObj.radarControllerHeaderObj = self.dataInObj.radarControllerHeaderObj.copy()
                     self.dataOutObj.systemHeaderObj = self.dataInObj.systemHeaderObj.copy()
                     self.dataOutObj.channelList = self.dataInObj.channelList
                     self.dataOutObj.channelIndexList = self.dataInObj.channelIndexList
                     self.dataOutObj.flagNoData = self.dataInObj.flagNoData
                     self.dataOutObj.flagTimeBlock = self.dataInObj.flagTimeBlock
-                    self.dataOutObj.dataUtcTime = self.dataInObj.dataUtcTime
+                    self.dataOutObj.utctime = self.dataInObj.utctime
                     self.dataOutObj.flagDecodeData = self.dataInObj.flagDecodeData #asumo q la data esta decodificada
                     self.dataOutObj.flagDeflipData = self.dataInObj.flagDeflipData #asumo q la data esta sin flip
                     self.dataOutObj.flagShiftFFT = self.dataInObj.flagShiftFFT
                     self.dataOutObj.nIncohInt = 1
                 def __getFft(self):
-                    if self.dataInObj.flagNoData:
-                       return 0
                     fft_volt = numpy.fft.fft(self.dataInObj.data, axis=1)
                     #print fft_volt
                     return numpy.arange(int(self.nFFTPoints))
                 def addIntegrator(self,N,timeInterval):
                     objIncohInt = IncoherentIntegration(N,timeInterval)
                     self.integratorObjList.append(objIncohInt)
                 def integrator(self, N=None, timeInterval=None):
                     if self.dataOutObj.flagNoData:
                             return 0
                         self.addIntegrator(N,timeInterval)
                     myIncohIntObj = self.integratorObjList[self.integratorObjIndex]
-                    myIncohIntObj.exe(data=self.dataOutObj.data_spc,timeOfData=self.dataOutObj.dataUtcTime)
+                    myIncohIntObj.exe(data=self.dataOutObj.data_spc,timeOfData=self.dataOutObj.utctime)
                     if myIncohIntObj.isReady:
                         self.dataOutObj.data_spc = myIncohIntObj.data
                 def addScope(self, idfigure, nframes, wintitle, driver):
                     if idfigure==None:
                         idfigure = self.plotObjIndex
                     x = numpy.arange(self.dataOutObj.nHeights)
-                    thisDatetime = datetime.datetime.fromtimestamp(self.dataOutObj.dataUtcTime)
+                    thisDatetime = datetime.datetime.fromtimestamp(self.dataOutObj.utctime)
                     dateTime = "%s"%(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     date = "%s"%(thisDatetime.strftime("%d-%b-%Y"))

schainpy2/Processing/VoltageProcessor.py +4 -4

                     data = self.dataOutObj.data * numpy.conjugate(self.dataOutObj.data)
                     data = 10*numpy.log10(data.real)
-            #        currenttime = self.dataOutObj.dataUtcTime
+            #        currenttime = self.dataOutObj.utctime
             #        if timezone == "lt":
-                    currenttime = self.dataOutObj.dataUtcTime - time.timezone
+                    currenttime = self.dataOutObj.utctime - time.timezone
                     range = self.dataOutObj.heightList
                     channelList = self.dataOutObj.channelList
-                    thisdatetime = datetime.datetime.fromtimestamp(self.dataOutObj.dataUtcTime)
+                    thisdatetime = datetime.datetime.fromtimestamp(self.dataOutObj.utctime)
                     dateTime = "%s"%(thisdatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     date = "%s"%(thisdatetime.strftime("%d-%b-%Y"))
                     if type =="iq":
                         data1D = self.dataOutObj.data
-                    thisDatetime = datetime.datetime.fromtimestamp(self.dataOutObj.dataUtcTime)
+                    thisDatetime = datetime.datetime.fromtimestamp(self.dataOutObj.utctime)
                     dateTime = "%s"%(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     date = "%s"%(thisDatetime.strftime("%d-%b-%Y"))

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