schain Commit - r162:71384e4bf352 · Jicamarca Repository

Daniel Valdez -

r162:71384e4bf352

parent child

Context file:

r162:71384e4bf352

schainpy2/Data/JROData.py +2 0

                 nIncohInt = None
+                nCohInt = None #se requiere para determinar el valor de timeInterval
                 def __init__(self):
                     '''
                     Constructor

schainpy2/IO/SpectraIO.py +1 -1

                     self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
                     self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOutObj.processingHeaderObj.nWindows
                     self.processingHeaderObj.processFlags = self.__getProcessFlags()
-                    self.processingHeaderObj.nCohInt = 1# Cuando la data de origen es de tipo Spectra
+                    self.processingHeaderObj.nCohInt = self.dataOutObj.nCohInt# Se requiere para determinar el valor de timeInterval
                     self.processingHeaderObj.nIncohInt = self.dataOutObj.nIncohInt
                     self.processingHeaderObj.totalSpectra = self.dataOutObj.nPairs + self.dataOutObj.nChannels

schainpy2/Processing/SpectraProcessor.py +51 -12

             from Data.JROData import Spectra, SpectraHeis
             from IO.SpectraIO import SpectraWriter
-            from Graphics.schainPlotTypes import ScopeFigure, SpcFigure
+            from Graphics.schainPlotTypes import ScopeFigure, SpcFigure, RTIFigure
             #from JRONoise import Noise
             class SpectraProcessor:
                 profIndex = 0 # Se emplea cuando el objeto de entrada es un Voltage
+                firstdatatime = None
                 def __init__(self):
                     '''
                     self.noiseObj = []
                     self.writerObjList = []
                     self.buffer = None
+                    self.firstdatatime = None
                     self.profIndex = 0
                 def setup(self, dataInObj=None, dataOutObj=None, nFFTPoints=None, pairsList=None):
                         self.buffer[:,self.profIndex,:] = self.dataInObj.data
                         self.profIndex += 1
+                        if self.firstdatatime == None:
+                            self.firstdatatime = self.dataInObj.utctime
                         if self.profIndex == self.dataOutObj.nFFTPoints:
                             self.__updateObjFromInput()
                             self.dataOutObj.flagNoData = False
                             self.buffer = None
+                            self.firstdatatime = None
                             self.profIndex = 0
                         return
                     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.utctime = self.firstdatatime
                     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.nCohInt = self.dataInObj.nCohInt
                     self.dataOutObj.nIncohInt = 1
                     self.dataOutObj.ippSeconds = self.dataInObj.ippSeconds
-                    self.dataOutObj.timeInterval = self.dataInObj.timeInterval
+                    self.dataOutObj.timeInterval = self.dataInObj.timeInterval*self.dataOutObj.nFFTPoints
                 def addWriter(self, wrpath, blocksPerFile):
                     y = self.dataOutObj.heightList
+                    data_spc = self.dataOutObj.data_spc
+                    data_cspc = self.dataOutObj.data_cspc
+                    data = []
                     if len(self.plotObjList) <= self.plotObjIndex:
                         self.addSpc(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
                 def addRti(self, idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile):
                     rtiObj = RTIFigure(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
                     data = 10.*numpy.log10(self.dataOutObj.data_spc[channelList,:,:])
+                    data = numpy.average(data, axis=1)
                     currenttime = self.dataOutObj.utctime - time.timezone
                     range = self.dataOutObj.heightList
                     plotObj = self.plotObjList[self.plotObjIndex]
+                    plotObj.plotPcolor(data=data,
+                                       x=currenttime,
+                                       y=range,
+                                       channelList=channelList,
+                                       xmin=starttime,
+                                       xmax=endtime,
+                                       ymin=rangemin,
+                                       ymax=rangemax,
+                                       minvalue=minvalue,
+                                       maxvalue=maxvalue,
+                                       figuretitle=figuretitle,
+                                       xrangestep=xrangestep,
+                                       deltax=deltax,
+                                       save=save,
+                                       gpath=gpath,
+                                       ratio=ratio,
+                                       cleardata=cleardata
+                                       )
                         self.addIntegrator(N,timeInterval)
                     myIncohIntObj = self.integratorObjList[self.integratorObjIndex]
-                    myIncohIntObj.exe(data=self.dataOutObj.data_spc,timeOfData=self.dataOutObj.m_BasicHeader.utc)
+                    myIncohIntObj.exe(data=self.dataOutObj.data_spc,datatime=self.dataOutObj.utctime)
                     if myIncohIntObj.isReady:
                         self.dataOutObj.data_spc = myIncohIntObj.data
-                        self.dataOutObj.nAvg = myIncohIntObj.navg
+                        self.dataOutObj.timeInterval *= myCohIntObj.nIncohInt
-                        self.dataOutObj.m_ProcessingHeader.incoherentInt = self.dataInObj.m_ProcessingHeader.incoherentInt*myIncohIntObj.navg
+                        self.dataOutObj.nIncohInt = myIncohIntObj.navg * self.dataInObj.nIncohInt
+                        self.dataOutObj.utctime = myIncohIntObj.firstdatatime
                         self.dataOutObj.flagNoData = False
                         """Calcular el ruido"""
                 navg = None
                 buffer = None
                 nIncohInt = None
+                firstdatatime = None
                 def __init__(self, N = None, timeInterval = None):
                     """
                     self.isReady = False
                     self.nIncohInt = N
                     self.integ_counter = 0
+                    self.firstdatatime = None
                     if timeInterval!=None:
                         self.timeIntervalInSeconds = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
                         self.timeFlag = True
-                def exe(self,data,timeOfData):
+                def exe(self,data,datatime):
                     """
                     data
-                    timeOfData [seconds]
+                    datatime [seconds]
                     """
+                    if self.firstdatatime == None or self.isReady:
+                        self.firstdatatime = datatime
                     if self.timeFlag:
                         if self.timeOut == None:
-                            self.timeOut = timeOfData + self.timeIntervalInSeconds
+                            self.timeOut = datatime + self.timeIntervalInSeconds
-                        if timeOfData < self.timeOut:
+                        if datatime < self.timeOut:
                             if self.buffer == None:
                                 self.buffer = data
                             else:
                         if self.timeFlag:
                             self.buffer = data
-                            self.timeOut = timeOfData + self.timeIntervalInSeconds
+                            self.timeOut = datatime + self.timeIntervalInSeconds
                     else:
                         self.isReady = False
   No newline at end of file

schainpy2/Processing/VoltageProcessor.py +13 -3

                         self.addIntegrator(nCohInt, timeInterval, overlapping)
                     myCohIntObj = self.integratorObjList[self.integratorObjIndex]
-                    myCohIntObj.exe(data = self.dataOutObj.data, datatime=None)
+                    myCohIntObj.exe(data = self.dataOutObj.data, datatime=self.dataOutObj.utctime)
             #        self.dataOutObj.timeInterval *= nCohInt
                     self.dataOutObj.flagNoData = True
                     if myCohIntObj.isReady:
-                        self.dataOutObj.timeInterval = myCohIntObj.nCohInt * self.dataOutObj.timeInterval
+                        self.dataOutObj.data = myCohIntObj.data
+                        self.dataOutObj.timeInterval *= myCohIntObj.nCohInt
+                        self.dataOutObj.nCohInt = myCohIntObj.nCohInt * self.dataInObj.nCohInt
+                        self.dataOutObj.utctime = myCohIntObj.firstdatatime
                         self.dataOutObj.flagNoData = False
                 def selectChannels(self, channelList):
                 isReady = False
                 nCohInt = None
+                firstdatatime = None
                 def __init__(self, nCohInt=None, timeInterval=None, overlapping=False):
                         self.__buffer = 0
                     self.__profIndex = 0
+                    firstdatatime = None
                 def putData(self, data):
                 def exe(self, data, datatime=None):
+                    if self.firstdatatime == None or self.isReady:
+                        self.firstdatatime = datatime
                     if not self.__isByTime:
                         avg_data = self.byProfiles(data)
                     else:
                     self.data = avg_data
                     return avg_data

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