schain-jc Commit - r1116:277434aacbd1

sumado de stride en stride. ej 96 -> 24x4 -> 1

José Chávez -

r1116:277434aacbd1

parent child

Context file:

r1116:277434aacbd1

Collapse all files

schainpy/model/proc/jroproc_voltage.py +57 -17

             class CohInt(Operation):
                 isConfig = False
                 __profIndex = 0
-                __withOverapping  = False
                 __byTime = False
                 __initime = None
                 __lastdatatime = None
                 __integrationtime = None
                 __buffer = None
+                __bufferStride = []
                 __dataReady = False
+                __profIndexStride = 0
+                __dataToPutStride = False
                 n = None
                 def __init__(self, **kwargs):
                     #   self.isConfig = False
-                def setup(self, n=None, timeInterval=None, overlapping=False, byblock=False):
+                def setup(self, n=None, timeInterval=None, stride=None, overlapping=False, byblock=False):
                     """
                     Set the parameters of the integration class.
                     self.__buffer = None
                     self.__dataReady = False
                     self.byblock = byblock
+                    self.stride = stride
                     if n == None and timeInterval == None:
                         raise ValueError, "n or timeInterval should be specified ..."
                         self.__byTime = True
                     if overlapping:
-                        self.__withOverapping = True
+                        self.__withOverlapping = True
                         self.__buffer = None
                     else:
-                        self.__withOverapping = False
+                        self.__withOverlapping = False
                         self.__buffer = 0
                     self.__profIndex = 0
                     """
-                    if not self.__withOverapping:
+                    if not self.__withOverlapping:
                         self.__buffer += data.copy()
                         self.__profIndex += 1
                         return
                     """
-                    if not self.__withOverapping:
+                    if not self.__withOverlapping:
                         data = self.__buffer
                         n = self.__profIndex
                     #Integration with Overlapping
                     data = numpy.sum(self.__buffer, axis=0)
+                    # print data
+                    # raise
                     n = self.__profIndex
                     return data, n
                     self.__dataReady = False
                     avgdata = None
                     #         n = None
+                    # print data
+                    # raise
                     self.putData(data)
                     if self.__profIndex == self.n:
                         avgdata, n = self.pushData()
                         self.__dataReady = True
                     return avgdata
+                def integrateByStride(self, data, datatime):
+                    # print data
+                    if self.__profIndex == 0:
+                        self.__buffer = [[data.copy(), datatime]]
+                    else:
+                        self.__buffer.append([data.copy(), datatime])
+                    self.__profIndex += 1
+                    self.__dataReady = False
+                    if self.__profIndex == self.n * self.stride :
+                        self.__dataToPutStride = True
+                        self.__profIndexStride = 0
+                        self.__profIndex = 0
+                        self.__bufferStride = []
+                        for i in range(self.stride):
+                            current = self.__buffer[i::self.stride]
+                            data = numpy.sum([t[0] for t in current], axis=0)
+                            avgdatatime = numpy.average([t[1] for t in current])
+                            # print data
+                            self.__bufferStride.append((data, avgdatatime))
+                    if self.__dataToPutStride:
+                        self.__dataReady = False
+                        self.__profIndexStride += 1
+                        if self.__profIndexStride == self.stride:
+                            self.__dataReady = True
+                            self.__dataToPutStride = False
+                            self.__profIndexStride = 0
+                        # print self.__bufferStride[self.__profIndexStride - 1]
+                        # raise
+                            return (numpy.sum([t[0] for t in self.__bufferStride], axis=0), numpy.average([t[1] for t in self.__bufferStride]))
+                    return None, None
                 def integrate(self, data, datatime=None):
                     if self.__initime == None:
                     deltatime = datatime - self.__lastdatatime
-                    if not self.__withOverapping:
+                    if not self.__withOverlapping:
                         self.__initime = datatime
                     else:
                         self.__initime += deltatime
                     self.__dataReady = True
                     return avgdata, avgdatatime
+                def run(self, dataOut, n=None, timeInterval=None, stride=None, overlapping=False, byblock=False, **kwargs):
-                def run(self, dataOut, n=None, timeInterval=None, overlapping=False, byblock=False, **kwargs):
                     if not self.isConfig:
-                        self.setup(n=n, timeInterval=timeInterval, overlapping=overlapping, byblock=byblock, **kwargs)
+                        self.setup(n=n, stride=stride, timeInterval=timeInterval, overlapping=overlapping, byblock=byblock, **kwargs)
                         self.isConfig = True
                     if dataOut.flagDataAsBlock:
                         avgdata, avgdatatime = self.integrateByBlock(dataOut)
                         dataOut.nProfiles /= self.n
                     else:
+                        if stride is None:
                             avgdata, avgdatatime = self.integrate(dataOut.data, dataOut.utctime)
+                        else:
+                            avgdata, avgdatatime = self.integrateByStride(dataOut.data, dataOut.utctime)
                     #   dataOut.timeInterval *= n
                     dataOut.flagNoData = True
                         dataOut.data = avgdata
                         dataOut.nCohInt *= self.n
                         dataOut.utctime = avgdatatime
+                        # print avgdata, avgdatatime
+                        # raise
                         #   dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt
                         dataOut.flagNoData = False

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