schain-jc Commit - r8:cd80c0608691 · Jicamarca Repository

En esta version se corrigieron los bugs de lectura, la lectura se ha implementado para modo offline, el script TestReader.py es un ejemplo que muestra como debe hacerse la lectura de rawdata usando estas librerias.

Daniel Valdez -

r8:cd80c0608691

parent child

Context file:

r8:cd80c0608691

Collapse all files

schainpy/IO/Header.py +2 0

+            import numpy
             class PROCFLAG:
                 COHERENT_INTEGRATION = numpy.uint32(0x00000001)
                 DECODE_DATA = numpy.uint32(0x00000002)

schainpy/IO/Voltage.py +41 -31

             from Data import DataWriter
             class VoltageReader(DataReader):
-                # Este flag indica que la data leida no es continua
-                __jumpDataFlag = False
                 __idFile = 0
                 __maxTimeStep = 5
-                __flagResetProcessing = 0
+                flagResetProcessing = 0
                 __flagIsNewFile = 0
                 basicHeaderSize = 24
-                objBasicHeader = BasicHeader()
+                basicHeaderObj = BasicHeader()
-                objSystemHeader = SystemHeader()
+                systemHeaderObj = SystemHeader()
-                objRadarControllerHeader = RadarControllerHeader()
+                radarControllerHeaderObj = RadarControllerHeader()
-                objProcessingHeader = ProcessingHeader()
+                processingHeaderObj = ProcessingHeader()
                 __buffer = 0
                 __buffer_id = 9999
-                m_Voltage= Voltage()
+                #m_Voltage= Voltage()
                 def __init__(self):
                     if fp == None:
                         fp = self.__fp
-                    self.objSystemHeader.read(fp)
+                    self.systemHeaderObj.read(fp)
                 def __rdRadarControllerHeader(self,fp=None):
                     if fp == None:
                         fp = self.__fp
-                    self.objRadarControllerHeader.read(fp)
+                    self.radarControllerHeaderObj.read(fp)
                 def __rdProcessingHeader(self,fp=None):
                     if fp == None:
                         fp = self.__fp
-                    self.objProcessingHeader.read(fp)
+                    self.processingHeaderObj.read(fp)
                 def __searchFiles(self,path, startDateTime, endDateTime, set=None, expLabel = "", ext = "*.r"):
                     if endUTSeconds==None:
                         endUTSeconds = self.endUTCSeconds
-                    objBasicHeader = BasicHeader()
+                    basicHeaderObj = BasicHeader()
-                    if not(objBasicHeader.read(fp)):
+                    if not(basicHeaderObj.read(fp)):
                         return 0
                     fp.close()
-                    if not ((startUTSeconds <= objBasicHeader.utc) and (endUTSeconds >= objBasicHeader.utc)):
+                    if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds >= basicHeaderObj.utc)):
                         return 0
                     return 1
                     if fp == None:
                         fp = self.__fp
-                    self.objBasicHeader.read(fp)
+                    self.basicHeaderObj.read(fp)
                 def __readFirstHeader(self):
                     self.__rdSystemHeader()
                     self.__rdRadarControllerHeader()
                     self.__rdProcessingHeader()
-                    self.firstHeaderSize = self.objBasicHeader.size
+                    self.firstHeaderSize = self.basicHeaderObj.size
-                    data_type=int(numpy.log2((self.objProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
+                    data_type=int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
                     if data_type == 0:
                         tmp=numpy.dtype([('real','<i1'),('imag','<i1')])
                     elif data_type == 1:
                         print 'no define data type'
                         tmp = 0
-                    self.__flagIsNewFile = 0
                     self.__dataType = tmp
-                    self.__sizeOfFileByHeader = self.objProcessingHeader.dataBlocksPerFile * self.objProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.objProcessingHeader.dataBlocksPerFile - 1)
+                    self.__sizeOfFileByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)
                 def __setNextFileOnline(self):
                     return 0
                         fp = open(filename,'rb')
                         currentSize = fileSize - fp.tell()
-                        neededSize = self.objProcessingHeader.blockSize + self.firstHeaderSize
+                        neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize
                         if (currentSize < neededSize):
                             continue
                 def __setNewBlock(self):
+                    if self.__flagIsNewFile:
+                        return 1
                     currentSize = self.fileSize - self.__fp.tell()
-                    neededSize = self.objProcessingHeader.blockSize + self.basicHeaderSize
+                    neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
                     # Bloque Completo
                     if (currentSize >= neededSize):
                         self.__readBasicHeader()
                         return 1
-                    self.__setNextFile()
+                    if not(self.__setNextFile()):
+                        return 0
                     self.__readFirstHeader()
-                    deltaTime = self.objBasicHeader.utc - self.__lastUTTime # check this
+                    deltaTime = self.basicHeaderObj.utc - self.__lastUTTime # check this
+                    self.flagResetProcessing = 0
                     if deltaTime > self.__maxTimeStep:
-                        self.__flagResetProcessing = 1
+                        self.flagResetProcessing = 1
                     return 1
                     seteado a 0
                     """
-                    pts2read = self.objProcessingHeader.profilesPerBlock*self.objProcessingHeader.numHeights*self.objSystemHeader.numChannels
+                    pts2read = self.processingHeaderObj.profilesPerBlock*self.processingHeaderObj.numHeights*self.systemHeaderObj.numChannels
                     data = numpy.fromfile(self.__fp,self.__dataType,pts2read)
-                    data = data.reshape((self.objProcessingHeader.profilesPerBlock, self.objProcessingHeader.numHeights, self.objSystemHeader.numChannels))
+                    data = data.reshape((self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.numHeights, self.systemHeaderObj.numChannels))
+                    self.__flagIsNewFile = 0
                     self.__buffer = data
                 def readNextBlock(self):
-                    self.__setNewBlock()
+                    if not(self.__setNewBlock()):
+                        return 0
                     self.__readBlock()
-                    self.__lastUTTime = self.objBasicHeader.utc
+                    self.__lastUTTime = self.basicHeaderObj.utc
+                    return 1
                 def __hasNotDataInBuffer(self):
-                    if self.__buffer_id >= self.objProcessingHeader.profilesPerBlock:
+                    if self.__buffer_id >= self.processingHeaderObj.profilesPerBlock:
                         return 1
                     return 0
                     lectura es necesario hacer una nueva lectura de los bloques de datos
                     "__readBlock"
                     """
+                    self.flagResetProcessing = 0
                     if self.__hasNotDataInBuffer():
                         self.readNextBlock()
                         return None
                     data = self.__buffer[self.__buffer_id,:,:]
+                    #time = timeblock + n*ipp
                     #print self.__buffer_id
                     self.__buffer_id += 1
                     #call setData - to Data Object
                     return 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