VoltageIO.py
432 lines
| 12.0 KiB
| text/x-python
|
PythonLexer
Miguel Valdez
|
r9 | ''' | |
| Created on 23/01/2012 | |||
Daniel Valdez
|
r16 | @author $Author$ | |
| @version $Id$ | |||
|
Miguel Valdez
|
r9 | ''' | |
| import os, sys | |||
| import numpy | |||
| import glob | |||
| import fnmatch | |||
|
Miguel Valdez
|
r20 | import time, datetime | |
|
Miguel Valdez
|
r9 | ||
|
Miguel Valdez
|
r18 | path = os.path.split(os.getcwd())[0] | |
| sys.path.append(path) | |||
|
Miguel Valdez
|
r49 | from Model.JROHeader import * | |
|
Miguel Valdez
|
r11 | from Model.Voltage import Voltage | |
|
Miguel Valdez
|
r9 | ||
|
Miguel Valdez
|
r89 | from IO.JRODataIO import JRODataReader | |
| from IO.JRODataIO import JRODataWriter | |||
Victor Sarmiento
|
r37 | ||
|
Victor Sarmiento
|
r59 | ||
|
Miguel Valdez
|
r49 | class VoltageReader(JRODataReader): | |
|
Miguel Valdez
|
r20 | """ | |
| Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura | |||
| de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones: | |||
| perfiles*alturas*canales) son almacenados en la variable "buffer". | |||
|
Victor Sarmiento
|
r66 | perfiles * alturas * canales | |
|
Victor Sarmiento
|
r59 | ||
|
Miguel Valdez
|
r20 | Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader, | |
| RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la | |||
| cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de | |||
| datos desde el "buffer" cada vez que se ejecute el metodo "getData". | |||
| Example: | |||
| dpath = "/home/myuser/data" | |||
| startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0) | |||
| endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0) | |||
| readerObj = VoltageReader() | |||
| readerObj.setup(dpath, startTime, endTime) | |||
| while(True): | |||
|
Miguel Valdez
|
r25 | #to get one profile | |
| profile = readerObj.getData() | |||
|
Miguel Valdez
|
r89 | ||
|
Miguel Valdez
|
r25 | #print the profile | |
| print profile | |||
| #If you want to see all datablock | |||
| print readerObj.datablock | |||
|
Miguel Valdez
|
r20 | ||
|
Victor Sarmiento
|
r59 | if readerObj.flagNoMoreFiles: | |
|
Miguel Valdez
|
r20 | break | |
| """ | |||
|
Daniel Valdez
|
r107 | dataOutObj = None | |
|
Victor Sarmiento
|
r59 | ||
| datablock = None | |||
|
Victor Sarmiento
|
r46 | ||
|
Victor Sarmiento
|
r66 | ext = ".r" | |
| optchar = "D" | |||
|
Miguel Valdez
|
r9 | ||
|
Daniel Valdez
|
r107 | def __init__(self, dataOutObj=None): | |
|
Miguel Valdez
|
r20 | """ | |
| Inicializador de la clase VoltageReader para la lectura de datos de voltage. | |||
| Input: | |||
|
Daniel Valdez
|
r107 | dataOutObj : Objeto de la clase Voltage. Este objeto sera utilizado para | |
|
Miguel Valdez
|
r20 | almacenar un perfil de datos cada vez que se haga un requerimiento | |
| (getData). El perfil sera obtenido a partir del buffer de datos, | |||
| si el buffer esta vacio se hara un nuevo proceso de lectura de un | |||
| bloque de datos. | |||
| Si este parametro no es pasado se creara uno internamente. | |||
| Variables afectadas: | |||
|
Daniel Valdez
|
r107 | self.dataOutObj | |
|
Miguel Valdez
|
r9 | ||
|
Miguel Valdez
|
r20 | Return: | |
|
Victor Sarmiento
|
r59 | None | |
|
Miguel Valdez
|
r20 | """ | |
|
Victor Sarmiento
|
r80 | ||
| self.datablock = None | |||
| self.utc = 0 | |||
| self.ext = ".r" | |||
| self.optchar = "D" | |||
| self.m_BasicHeader = BasicHeader() | |||
|
Miguel Valdez
|
r164 | self.systemHeaderObj = SystemHeader() | |
|
Victor Sarmiento
|
r80 | ||
|
Miguel Valdez
|
r164 | self.radarControllerHeaderObj = RadarControllerHeader() | |
|
Victor Sarmiento
|
r80 | ||
| self.m_ProcessingHeader = ProcessingHeader() | |||
| self.online = 0 | |||
| self.fp = None | |||
| self.idFile = None | |||
| self.startDateTime = None | |||
| self.endDateTime = None | |||
| self.dataType = None | |||
| self.fileSizeByHeader = None | |||
| self.filenameList = [] | |||
| self.filename = None | |||
| self.fileSize = None | |||
| self.firstHeaderSize = 0 | |||
| self.basicHeaderSize = 24 | |||
| self.pathList = [] | |||
| self.filenameList = [] | |||
| self.lastUTTime = 0 | |||
| self.maxTimeStep = 30 | |||
| self.flagNoMoreFiles = 0 | |||
| self.set = 0 | |||
| self.path = None | |||
|
Miguel Valdez
|
r89 | self.profileIndex = 9999 | |
|
Victor Sarmiento
|
r80 | ||
|
Miguel Valdez
|
r164 | self.delay = 60 #seconds | |
|
Victor Sarmiento
|
r80 | ||
| self.nTries = 3 #quantity tries | |||
| self.nFiles = 3 #number of files for searching | |||
|
Miguel Valdez
|
r89 | self.nReadBlocks = 0 | |
|
Victor Sarmiento
|
r80 | ||
| self.flagIsNewFile = 1 | |||
| self.ippSeconds = 0 | |||
| self.flagResetProcessing = 0 | |||
| self.flagIsNewBlock = 0 | |||
|
Miguel Valdez
|
r89 | self.nTotalBlocks = 0 | |
|
Victor Sarmiento
|
r80 | ||
| self.blocksize = 0 | |||
|
Victor Sarmiento
|
r37 | ||
|
Daniel Valdez
|
r107 | def createObjByDefault(self): | |
| dataObj = Voltage() | |||
| return dataObj | |||
|
Victor Sarmiento
|
r59 | def __hasNotDataInBuffer(self): | |
|
Miguel Valdez
|
r89 | if self.profileIndex >= self.m_ProcessingHeader.profilesPerBlock: | |
|
Miguel Valdez
|
r9 | return 1 | |
|
Miguel Valdez
|
r53 | return 0 | |
|
Victor Sarmiento
|
r37 | ||
|
Victor Sarmiento
|
r59 | ||
|
Miguel Valdez
|
r53 | def getBlockDimension(self): | |
|
Victor Sarmiento
|
r59 | """ | |
| Obtiene la cantidad de puntos a leer por cada bloque de datos | |||
|
Miguel Valdez
|
r9 | ||
|
Victor Sarmiento
|
r59 | Affected: | |
| self.blocksize | |||
| Return: | |||
| None | |||
| """ | |||
|
Miguel Valdez
|
r164 | pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.systemHeaderObj.numChannels | |
|
Miguel Valdez
|
r89 | self.blocksize = pts2read | |
|
Victor Sarmiento
|
r59 | ||
|
Miguel Valdez
|
r9 | ||
|
Miguel Valdez
|
r53 | def readBlock(self): | |
|
Miguel Valdez
|
r20 | """ | |
|
Miguel Valdez
|
r53 | readBlock lee el bloque de datos desde la posicion actual del puntero del archivo | |
| (self.fp) y actualiza todos los parametros relacionados al bloque de datos | |||
|
Miguel Valdez
|
r20 | (metadata + data). La data leida es almacenada en el buffer y el contador del buffer | |
| es seteado a 0 | |||
| Inputs: | |||
| None | |||
| Return: | |||
| None | |||
|
Victor Sarmiento
|
r46 | Affected: | |
|
Miguel Valdez
|
r89 | self.profileIndex | |
|
Miguel Valdez
|
r25 | self.datablock | |
|
Miguel Valdez
|
r53 | self.flagIsNewFile | |
|
Miguel Valdez
|
r20 | self.flagIsNewBlock | |
|
Miguel Valdez
|
r89 | self.nTotalBlocks | |
|
Miguel Valdez
|
r20 | ||
|
Victor Sarmiento
|
r46 | Exceptions: | |
| Si un bloque leido no es un bloque valido | |||
|
Miguel Valdez
|
r9 | """ | |
|
Miguel Valdez
|
r89 | ||
| junk = numpy.fromfile( self.fp, self.dataType, self.blocksize ) | |||
|
Victor Sarmiento
|
r37 | ||
|
Victor Sarmiento
|
r46 | try: | |
|
Miguel Valdez
|
r164 | junk = junk.reshape( (self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.systemHeaderObj.numChannels) ) | |
|
Victor Sarmiento
|
r46 | except: | |
|
Miguel Valdez
|
r89 | print "The read block (%3d) has not enough data" %self.nReadBlocks | |
|
Victor Sarmiento
|
r46 | return 0 | |
|
Miguel Valdez
|
r9 | ||
|
Daniel Valdez
|
r73 | junk = numpy.transpose(junk, (2,0,1)) | |
|
Victor Sarmiento
|
r46 | self.datablock = junk['real'] + junk['imag']*1j | |
|
Miguel Valdez
|
r20 | ||
|
Miguel Valdez
|
r89 | self.profileIndex = 0 | |
|
Miguel Valdez
|
r53 | self.flagIsNewFile = 0 | |
|
Miguel Valdez
|
r13 | self.flagIsNewBlock = 1 | |
|
Victor Sarmiento
|
r46 | ||
|
Miguel Valdez
|
r89 | self.nTotalBlocks += 1 | |
|
Miguel Valdez
|
r13 | self.nReadBlocks += 1 | |
|
Victor Sarmiento
|
r46 | ||
| return 1 | |||
|
Victor Sarmiento
|
r59 | ||
|
Victor Sarmiento
|
r46 | ||
| def getData(self): | |||
|
Miguel Valdez
|
r20 | """ | |
| getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage" | |||
| con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de | |||
|
Miguel Valdez
|
r12 | lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock" | |
|
Miguel Valdez
|
r20 | ||
| Ademas incrementa el contador del buffer en 1. | |||
| Return: | |||
| data : retorna un perfil de voltages (alturas * canales) copiados desde el | |||
| buffer. Si no hay mas archivos a leer retorna None. | |||
| Variables afectadas: | |||
|
Daniel Valdez
|
r107 | self.dataOutObj | |
|
Miguel Valdez
|
r89 | self.profileIndex | |
|
Miguel Valdez
|
r20 | ||
|
Victor Sarmiento
|
r37 | Affected: | |
|
Daniel Valdez
|
r107 | self.dataOutObj | |
|
Miguel Valdez
|
r89 | self.profileIndex | |
|
Victor Sarmiento
|
r37 | self.flagResetProcessing | |
| self.flagIsNewBlock | |||
|
Miguel Valdez
|
r9 | """ | |
|
Victor Sarmiento
|
r59 | if self.flagNoMoreFiles: return 0 | |
|
Victor Sarmiento
|
r46 | ||
|
Miguel Valdez
|
r9 | self.flagResetProcessing = 0 | |
|
Miguel Valdez
|
r13 | self.flagIsNewBlock = 0 | |
|
Miguel Valdez
|
r9 | ||
|
Victor Sarmiento
|
r59 | if self.__hasNotDataInBuffer(): | |
|
Victor Sarmiento
|
r37 | ||
|
Victor Sarmiento
|
r46 | if not( self.readNextBlock() ): | |
| return 0 | |||
|
Miguel Valdez
|
r23 | ||
|
Miguel Valdez
|
r89 | self.updateDataHeader() | |
|
Miguel Valdez
|
r23 | ||
|
Victor Sarmiento
|
r59 | if self.flagNoMoreFiles == 1: | |
|
Miguel Valdez
|
r11 | print 'Process finished' | |
|
Victor Sarmiento
|
r46 | return 0 | |
|
Miguel Valdez
|
r9 | ||
|
Miguel Valdez
|
r18 | #data es un numpy array de 3 dmensiones (perfiles, alturas y canales) | |
|
Daniel Valdez
|
r15 | ||
|
Victor Sarmiento
|
r46 | if self.datablock == None: | |
|
Daniel Valdez
|
r107 | self.dataOutObj.flagNoData = True | |
|
Victor Sarmiento
|
r46 | return 0 | |
|
Miguel Valdez
|
r89 | time = self.m_BasicHeader.utc + self.profileIndex * self.ippSeconds | |
|
Daniel Valdez
|
r107 | self.dataOutObj.m_BasicHeader.utc = time | |
|
Victor Sarmiento
|
r37 | ||
|
Daniel Valdez
|
r107 | self.dataOutObj.flagNoData = False | |
| self.dataOutObj.flagResetProcessing = self.flagResetProcessing | |||
|
Miguel Valdez
|
r23 | ||
|
Daniel Valdez
|
r107 | self.dataOutObj.data = self.datablock[:,self.profileIndex,:] | |
|
Miguel Valdez
|
r23 | ||
|
Miguel Valdez
|
r89 | self.profileIndex += 1 | |
|
Miguel Valdez
|
r9 | ||
| #call setData - to Data Object | |||
|
Daniel Valdez
|
r107 | return 1 #self.dataOutObj.data | |
|
Miguel Valdez
|
r9 | ||
|
Victor Sarmiento
|
r59 | ||
|
Miguel Valdez
|
r98 | class VoltageWriter(JRODataWriter): | |
|
Victor Sarmiento
|
r37 | """ | |
| Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura | |||
| de los datos siempre se realiza por bloques. | |||
| """ | |||
|
Daniel Valdez
|
r22 | __configHeaderFile = 'wrSetHeadet.txt' | |
|
Miguel Valdez
|
r9 | ||
|
Daniel Valdez
|
r107 | dataOutObj = None | |
|
Victor Sarmiento
|
r59 | ||
| ext = ".r" | |||
| optchar = "D" | |||
|
Victor Sarmiento
|
r66 | datablock = None | |
|
Miguel Valdez
|
r89 | profileIndex = 0 | |
|
Victor Sarmiento
|
r66 | ||
|
Victor Sarmiento
|
r59 | shapeBuffer = None | |
|
Daniel Valdez
|
r107 | def __init__(self, dataOutObj=None): | |
|
Victor Sarmiento
|
r37 | """ | |
| Inicializador de la clase VoltageWriter para la escritura de datos de espectros. | |||
| Affected: | |||
|
Daniel Valdez
|
r107 | self.dataOutObj | |
|
Victor Sarmiento
|
r37 | ||
| Return: None | |||
| """ | |||
|
Daniel Valdez
|
r107 | if dataOutObj == None: | |
| dataOutObj = Voltage() | |||
|
Miguel Valdez
|
r9 | ||
|
Daniel Valdez
|
r107 | if not( isinstance(dataOutObj, Voltage) ): | |
| raise ValueError, "in VoltageReader, dataOutObj must be an Spectra class object" | |||
|
Victor Sarmiento
|
r59 | ||
|
Daniel Valdez
|
r107 | self.dataOutObj = dataOutObj | |
|
Victor Sarmiento
|
r59 | ||
|
Victor Sarmiento
|
r37 | ||
|
Miguel Valdez
|
r53 | def hasAllDataInBuffer(self): | |
|
Miguel Valdez
|
r89 | if self.profileIndex >= self.m_ProcessingHeader.profilesPerBlock: | |
|
Miguel Valdez
|
r53 | return 1 | |
| return 0 | |||
|
Victor Sarmiento
|
r37 | ||
|
Victor Sarmiento
|
r59 | ||
|
Miguel Valdez
|
r53 | def setBlockDimension(self): | |
|
Victor Sarmiento
|
r59 | """ | |
| Obtiene las formas dimensionales del los subbloques de datos que componen un bloque | |||
| Affected: | |||
| self.shape_spc_Buffer | |||
| self.shape_cspc_Buffer | |||
| self.shape_dc_Buffer | |||
| Return: None | |||
| """ | |||
| self.shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock, | |||
| self.m_ProcessingHeader.numHeights, | |||
|
Miguel Valdez
|
r164 | self.systemHeaderObj.numChannels ) | |
|
Daniel Valdez
|
r22 | ||
|
Miguel Valdez
|
r164 | self.datablock = numpy.zeros((self.systemHeaderObj.numChannels, | |
|
Daniel Valdez
|
r73 | self.m_ProcessingHeader.profilesPerBlock, | |
|
Victor Sarmiento
|
r80 | self.m_ProcessingHeader.numHeights), | |
| dtype=numpy.dtype('complex')) | |||
|
Victor Sarmiento
|
r59 | ||
|
Daniel Valdez
|
r19 | ||
|
Miguel Valdez
|
r53 | def writeBlock(self): | |
|
Victor Sarmiento
|
r37 | """ | |
| Escribe el buffer en el file designado | |||
| Affected: | |||
|
Miguel Valdez
|
r89 | self.profileIndex | |
|
Miguel Valdez
|
r53 | self.flagIsNewFile | |
|
Victor Sarmiento
|
r37 | self.flagIsNewBlock | |
|
Miguel Valdez
|
r89 | self.nTotalBlocks | |
| self.nWriteBlocks | |||
|
Victor Sarmiento
|
r37 | ||
| Return: None | |||
| """ | |||
|
Miguel Valdez
|
r53 | data = numpy.zeros( self.shapeBuffer, self.dataType ) | |
|
Miguel Valdez
|
r23 | ||
|
Daniel Valdez
|
r73 | junk = numpy.transpose(self.datablock, (1,2,0)) | |
| data['real'] = junk.real | |||
| data['imag'] = junk.imag | |||
|
Miguel Valdez
|
r23 | ||
|
Victor Sarmiento
|
r37 | data = data.reshape( (-1) ) | |
|
Miguel Valdez
|
r23 | ||
|
Miguel Valdez
|
r53 | data.tofile( self.fp ) | |
|
Miguel Valdez
|
r23 | ||
|
Miguel Valdez
|
r25 | self.datablock.fill(0) | |
|
Miguel Valdez
|
r89 | self.profileIndex = 0 | |
|
Miguel Valdez
|
r53 | self.flagIsNewFile = 0 | |
|
Daniel Valdez
|
r19 | self.flagIsNewBlock = 1 | |
|
Miguel Valdez
|
r89 | self.nTotalBlocks += 1 | |
|
Daniel Valdez
|
r19 | self.nWriteBlocks += 1 | |
|
Victor Sarmiento
|
r59 | ||
|
Victor Sarmiento
|
r46 | def putData(self): | |
|
Victor Sarmiento
|
r37 | """ | |
| Setea un bloque de datos y luego los escribe en un file | |||
| Affected: | |||
| self.flagIsNewBlock | |||
|
Miguel Valdez
|
r89 | self.profileIndex | |
|
Victor Sarmiento
|
r37 | ||
| Return: | |||
| 0 : Si no hay data o no hay mas files que puedan escribirse | |||
| 1 : Si se escribio la data de un bloque en un file | |||
| """ | |||
|
Daniel Valdez
|
r19 | self.flagIsNewBlock = 0 | |
|
Daniel Valdez
|
r107 | if self.dataOutObj.flagNoData: | |
|
Miguel Valdez
|
r23 | return 0 | |
|
Daniel Valdez
|
r19 | ||
|
Daniel Valdez
|
r107 | if self.dataOutObj.flagResetProcessing: | |
|
Miguel Valdez
|
r23 | ||
|
Miguel Valdez
|
r25 | self.datablock.fill(0) | |
|
Miguel Valdez
|
r89 | self.profileIndex = 0 | |
|
Miguel Valdez
|
r53 | self.setNextFile() | |
|
Daniel Valdez
|
r22 | ||
|
Daniel Valdez
|
r107 | self.datablock[:,self.profileIndex,:] = self.dataOutObj.data | |
|
Daniel Valdez
|
r19 | ||
|
Miguel Valdez
|
r89 | self.profileIndex += 1 | |
|
Daniel Valdez
|
r19 | ||
|
Miguel Valdez
|
r53 | if self.hasAllDataInBuffer(): | |
|
Victor Sarmiento
|
r59 | #if self.flagIsNewFile: | |
|
Miguel Valdez
|
r89 | self.getDataHeader() | |
|
Daniel Valdez
|
r19 | self.writeNextBlock() | |
|
Victor Sarmiento
|
r59 | if self.flagNoMoreFiles: | |
|
Miguel Valdez
|
r23 | #print 'Process finished' | |
| return 0 | |||
|
Daniel Valdez
|
r19 | ||
| return 1 | |||
|
Daniel Valdez
|
r22 |