jroIO_voltage.py
764 lines
| 24.8 KiB
| text/x-python
|
PythonLexer
|
r487 | ''' | ||
|
r568 | Created on Jul 2, 2014 | ||
|
r487 | |||
|
r568 | @author: roj-idl71 | ||
|
r487 | ''' | ||
|
r568 | |||
|
r487 | import numpy | ||
from jroIO_base import LOCALTIME, JRODataReader, JRODataWriter | ||||
|
r568 | from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation | ||
from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader | ||||
from schainpy.model.data.jrodata import Voltage | ||||
|
r1061 | import zmq | ||
import tempfile | ||||
from StringIO import StringIO | ||||
|
r834 | # from _sha import blocksize | ||
|
r487 | |||
|
r1082 | |||
|
r487 | class VoltageReader(JRODataReader, ProcessingUnit): | ||
""" | ||||
Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura | ||||
|
r1061 | de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones: | ||
|
r487 | perfiles*alturas*canales) son almacenados en la variable "buffer". | ||
|
r1061 | perfiles * alturas * canales | ||
Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader, | ||||
|
r487 | 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". | ||||
|
r1061 | |||
|
r487 | Example: | ||
|
r1061 | |||
|
r487 | dpath = "/home/myuser/data" | ||
|
r1061 | |||
|
r487 | startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0) | ||
|
r1061 | |||
|
r487 | endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0) | ||
|
r1061 | |||
|
r487 | readerObj = VoltageReader() | ||
|
r1061 | |||
|
r487 | readerObj.setup(dpath, startTime, endTime) | ||
|
r1061 | |||
|
r487 | while(True): | ||
|
r1061 | |||
#to get one profile | ||||
|
r487 | profile = readerObj.getData() | ||
|
r1061 | |||
|
r487 | #print the profile | ||
print profile | ||||
|
r1061 | |||
|
r487 | #If you want to see all datablock | ||
print readerObj.datablock | ||||
|
r1061 | |||
|
r487 | if readerObj.flagNoMoreFiles: | ||
break | ||||
|
r1061 | |||
|
r487 | """ | ||
ext = ".r" | ||||
|
r1061 | |||
|
r487 | optchar = "D" | ||
dataOut = None | ||||
|
r1061 | |||
def __init__(self, **kwargs): | ||||
|
r487 | """ | ||
Inicializador de la clase VoltageReader para la lectura de datos de voltage. | ||||
|
r1061 | |||
|
r487 | Input: | ||
dataOut : Objeto de la clase Voltage. Este objeto sera utilizado para | ||||
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. | ||||
|
r1061 | |||
|
r487 | Variables afectadas: | ||
self.dataOut | ||||
|
r1061 | |||
|
r487 | Return: | ||
None | ||||
""" | ||||
|
r1061 | |||
ProcessingUnit.__init__(self, **kwargs) | ||||
|
r487 | self.isConfig = False | ||
|
r1061 | |||
|
r487 | self.datablock = None | ||
|
r1061 | |||
|
r487 | self.utc = 0 | ||
|
r1061 | |||
|
r487 | self.ext = ".r" | ||
|
r1061 | |||
|
r487 | self.optchar = "D" | ||
self.basicHeaderObj = BasicHeader(LOCALTIME) | ||||
|
r1061 | |||
|
r487 | self.systemHeaderObj = SystemHeader() | ||
|
r1061 | |||
|
r487 | self.radarControllerHeaderObj = RadarControllerHeader() | ||
|
r1061 | |||
|
r487 | self.processingHeaderObj = ProcessingHeader() | ||
|
r1061 | |||
|
r487 | self.online = 0 | ||
|
r1061 | |||
|
r487 | self.fp = None | ||
|
r1061 | |||
|
r487 | self.idFile = None | ||
|
r1061 | |||
|
r487 | self.dtype = None | ||
|
r1061 | |||
|
r487 | self.fileSizeByHeader = None | ||
|
r1061 | |||
|
r487 | self.filenameList = [] | ||
|
r1061 | |||
|
r487 | self.filename = None | ||
|
r1061 | |||
|
r487 | self.fileSize = None | ||
|
r1061 | |||
|
r487 | self.firstHeaderSize = 0 | ||
|
r1061 | |||
|
r487 | self.basicHeaderSize = 24 | ||
|
r1061 | |||
|
r487 | self.pathList = [] | ||
|
r1061 | |||
|
r487 | self.filenameList = [] | ||
|
r1061 | |||
|
r487 | self.lastUTTime = 0 | ||
|
r1061 | |||
|
r487 | self.maxTimeStep = 30 | ||
|
r1061 | |||
|
r487 | self.flagNoMoreFiles = 0 | ||
|
r1061 | |||
|
r487 | self.set = 0 | ||
|
r1061 | |||
|
r487 | self.path = None | ||
|
r1061 | |||
|
r1082 | self.profileIndex = 2**32 - 1 | ||
|
r487 | |||
|
r1082 | self.delay = 3 # seconds | ||
|
r1061 | |||
|
r1082 | self.nTries = 3 # quantity tries | ||
|
r1061 | |||
|
r1082 | self.nFiles = 3 # number of files for searching | ||
|
r1061 | |||
|
r487 | self.nReadBlocks = 0 | ||
|
r1061 | |||
|
r487 | self.flagIsNewFile = 1 | ||
|
r1061 | |||
|
r487 | self.__isFirstTimeOnline = 1 | ||
|
r1061 | |||
|
r487 | # self.ippSeconds = 0 | ||
|
r1061 | |||
self.flagDiscontinuousBlock = 0 | ||||
|
r487 | self.flagIsNewBlock = 0 | ||
|
r1061 | |||
|
r487 | self.nTotalBlocks = 0 | ||
|
r1061 | |||
|
r487 | self.blocksize = 0 | ||
|
r1061 | |||
|
r487 | self.dataOut = self.createObjByDefault() | ||
|
r1061 | |||
|
r534 | self.nTxs = 1 | ||
|
r1061 | |||
|
r534 | self.txIndex = 0 | ||
|
r1061 | |||
|
r487 | def createObjByDefault(self): | ||
|
r1061 | |||
|
r487 | dataObj = Voltage() | ||
|
r1061 | |||
|
r487 | return dataObj | ||
|
r1061 | |||
|
r487 | def __hasNotDataInBuffer(self): | ||
|
r1061 | |||
|
r1082 | if self.profileIndex >= self.processingHeaderObj.profilesPerBlock * self.nTxs: | ||
|
r487 | return 1 | ||
|
r1061 | |||
|
r487 | return 0 | ||
def getBlockDimension(self): | ||||
""" | ||||
|
r1019 | Obtiene la cantidad de puntos a leer por cada bloque de datos | ||
|
r1082 | |||
|
r1019 | Affected: | ||
self.blocksize | ||||
|
r487 | |||
|
r1019 | Return: | ||
None | ||||
|
r487 | """ | ||
|
r1082 | pts2read = self.processingHeaderObj.profilesPerBlock * \ | ||
self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels | ||||
|
r487 | self.blocksize = pts2read | ||
def readBlock(self): | ||||
""" | ||||
|
r1019 | 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 | ||||
(metadata + data). La data leida es almacenada en el buffer y el contador del buffer | ||||
es seteado a 0 | ||||
|
r1082 | |||
|
r1019 | Inputs: | ||
None | ||||
|
r1082 | |||
|
r1019 | Return: | ||
None | ||||
|
r1082 | |||
|
r1019 | Affected: | ||
self.profileIndex | ||||
self.datablock | ||||
self.flagIsNewFile | ||||
self.flagIsNewBlock | ||||
self.nTotalBlocks | ||||
|
r1082 | |||
|
r1019 | Exceptions: | ||
Si un bloque leido no es un bloque valido | ||||
|
r487 | """ | ||
|
r1082 | |||
|
r975 | # if self.server is not None: | ||
# self.zBlock = self.receiver.recv() | ||||
# self.zHeader = self.zBlock[:24] | ||||
# self.zDataBlock = self.zBlock[24:] | ||||
# junk = numpy.fromstring(self.zDataBlock, numpy.dtype([('real','<i4'),('imag','<i4')])) | ||||
# self.processingHeaderObj.profilesPerBlock = 240 | ||||
# self.processingHeaderObj.nHeights = 248 | ||||
# self.systemHeaderObj.nChannels | ||||
# else: | ||||
current_pointer_location = self.fp.tell() | ||||
|
r1082 | junk = numpy.fromfile(self.fp, self.dtype, self.blocksize) | ||
|
r1061 | |||
|
r487 | try: | ||
|
r1082 | junk = junk.reshape((self.processingHeaderObj.profilesPerBlock, | ||
self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels)) | ||||
|
r487 | except: | ||
|
r1082 | # print "The read block (%3d) has not enough data" %self.nReadBlocks | ||
|
r1061 | |||
|
r487 | if self.waitDataBlock(pointer_location=current_pointer_location): | ||
|
r1082 | junk = numpy.fromfile(self.fp, self.dtype, self.blocksize) | ||
junk = junk.reshape((self.processingHeaderObj.profilesPerBlock, | ||||
self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels)) | ||||
|
r1017 | # return 0 | ||
|
r616 | |||
|
r1082 | # Dimensions : nChannels, nProfiles, nSamples | ||
|
r1061 | |||
|
r1082 | junk = numpy.transpose(junk, (2, 0, 1)) | ||
self.datablock = junk['real'] + junk['imag'] * 1j | ||||
|
r1061 | |||
|
r487 | self.profileIndex = 0 | ||
|
r1061 | |||
|
r487 | self.flagIsNewFile = 0 | ||
self.flagIsNewBlock = 1 | ||||
self.nTotalBlocks += 1 | ||||
self.nReadBlocks += 1 | ||||
|
r1061 | |||
|
r487 | return 1 | ||
def getFirstHeader(self): | ||||
|
r1061 | |||
|
r616 | self.getBasicHeader() | ||
|
r1061 | |||
|
r1103 | self.dataOut.processingHeaderObj = self.processingHeaderObj.copy() | ||
|
r487 | self.dataOut.systemHeaderObj = self.systemHeaderObj.copy() | ||
|
r1061 | |||
|
r487 | self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy() | ||
|
r1061 | |||
|
r534 | if self.nTxs > 1: | ||
|
r1082 | self.dataOut.radarControllerHeaderObj.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs | ||
# Time interval and code are propierties of dataOut. Its value depends of radarControllerHeaderObj. | ||||
|
r897 | |||
|
r1017 | # self.dataOut.timeInterval = self.radarControllerHeaderObj.ippSeconds * self.processingHeaderObj.nCohInt | ||
# | ||||
# if self.radarControllerHeaderObj.code is not None: | ||||
# | ||||
# self.dataOut.nCode = self.radarControllerHeaderObj.nCode | ||||
# | ||||
# self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud | ||||
# | ||||
# self.dataOut.code = self.radarControllerHeaderObj.code | ||||
|
r897 | |||
|
r487 | self.dataOut.dtype = self.dtype | ||
|
r1061 | |||
|
r748 | self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock | ||
|
r1061 | |||
|
r1082 | self.dataOut.heightList = numpy.arange( | ||
self.processingHeaderObj.nHeights) * self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight | ||||
|
r1061 | |||
|
r487 | self.dataOut.channelList = range(self.systemHeaderObj.nChannels) | ||
|
r1061 | |||
|
r487 | self.dataOut.nCohInt = self.processingHeaderObj.nCohInt | ||
|
r1061 | |||
|
r1082 | # asumo q la data no esta decodificada | ||
self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode | ||||
|
r487 | |||
|
r1082 | # asumo q la data no esta sin flip | ||
self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip | ||||
|
r1061 | |||
|
r624 | self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft | ||
|
r1061 | |||
|
r748 | def reshapeData(self): | ||
|
r1061 | |||
|
r748 | if self.nTxs < 0: | ||
return | ||||
|
r1061 | |||
|
r748 | if self.nTxs == 1: | ||
return | ||||
|
r1061 | |||
|
r1082 | if self.nTxs < 1 and self.processingHeaderObj.profilesPerBlock % (1. / self.nTxs) != 0: | ||
raise ValueError, "1./nTxs (=%f), should be a multiple of nProfiles (=%d)" % ( | ||||
1. / self.nTxs, self.processingHeaderObj.profilesPerBlock) | ||||
|
r1061 | |||
|
r748 | if self.nTxs > 1 and self.processingHeaderObj.nHeights % self.nTxs != 0: | ||
|
r1082 | raise ValueError, "nTxs (=%d), should be a multiple of nHeights (=%d)" % ( | ||
self.nTxs, self.processingHeaderObj.nHeights) | ||||
|
r1061 | |||
|
r1082 | self.datablock = self.datablock.reshape( | ||
(self.systemHeaderObj.nChannels, self.processingHeaderObj.profilesPerBlock * self.nTxs, self.processingHeaderObj.nHeights / self.nTxs)) | ||||
|
r1061 | |||
|
r1082 | self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock * self.nTxs | ||
self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights / self.nTxs) * \ | ||||
self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight | ||||
self.dataOut.radarControllerHeaderObj.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs | ||||
|
r897 | |||
|
r1056 | return | ||
|
r897 | |||
|
r975 | def readFirstHeaderFromServer(self): | ||
|
r1082 | |||
|
r975 | self.getFirstHeader() | ||
self.firstHeaderSize = self.basicHeaderObj.size | ||||
|
r1082 | datatype = int(numpy.log2((self.processingHeaderObj.processFlags & | ||
PROCFLAG.DATATYPE_MASK)) - numpy.log2(PROCFLAG.DATATYPE_CHAR)) | ||||
|
r975 | if datatype == 0: | ||
|
r1082 | datatype_str = numpy.dtype([('real', '<i1'), ('imag', '<i1')]) | ||
|
r975 | elif datatype == 1: | ||
|
r1082 | datatype_str = numpy.dtype([('real', '<i2'), ('imag', '<i2')]) | ||
|
r975 | elif datatype == 2: | ||
|
r1082 | datatype_str = numpy.dtype([('real', '<i4'), ('imag', '<i4')]) | ||
|
r975 | elif datatype == 3: | ||
|
r1082 | datatype_str = numpy.dtype([('real', '<i8'), ('imag', '<i8')]) | ||
|
r975 | elif datatype == 4: | ||
|
r1082 | datatype_str = numpy.dtype([('real', '<f4'), ('imag', '<f4')]) | ||
|
r975 | elif datatype == 5: | ||
|
r1082 | datatype_str = numpy.dtype([('real', '<f8'), ('imag', '<f8')]) | ||
|
r975 | else: | ||
raise ValueError, 'Data type was not defined' | ||||
self.dtype = datatype_str | ||||
#self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c | ||||
|
r1082 | self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + \ | ||
self.firstHeaderSize + self.basicHeaderSize * \ | ||||
(self.processingHeaderObj.dataBlocksPerFile - 1) | ||||
|
r1017 | # self.dataOut.channelList = numpy.arange(self.systemHeaderObj.numChannels) | ||
# self.dataOut.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels) | ||||
|
r975 | self.getBlockDimension() | ||
|
r1082 | def getFromServer(self): | ||
|
r975 | self.flagDiscontinuousBlock = 0 | ||
self.profileIndex = 0 | ||||
self.flagIsNewBlock = 1 | ||||
self.dataOut.flagNoData = False | ||||
self.nTotalBlocks += 1 | ||||
self.nReadBlocks += 1 | ||||
self.blockPointer = 0 | ||||
block = self.receiver.recv() | ||||
|
r1017 | |||
|
r975 | self.basicHeaderObj.read(block[self.blockPointer:]) | ||
self.blockPointer += self.basicHeaderObj.length | ||||
self.systemHeaderObj.read(block[self.blockPointer:]) | ||||
self.blockPointer += self.systemHeaderObj.length | ||||
self.radarControllerHeaderObj.read(block[self.blockPointer:]) | ||||
self.blockPointer += self.radarControllerHeaderObj.length | ||||
self.processingHeaderObj.read(block[self.blockPointer:]) | ||||
self.blockPointer += self.processingHeaderObj.length | ||||
self.readFirstHeaderFromServer() | ||||
|
r1082 | |||
|
r975 | timestamp = self.basicHeaderObj.get_datatime() | ||
print '[Reading] - Block {} - {}'.format(self.nTotalBlocks, timestamp) | ||||
current_pointer_location = self.blockPointer | ||||
|
r1082 | junk = numpy.fromstring( | ||
block[self.blockPointer:], self.dtype, self.blocksize) | ||||
|
r975 | |||
try: | ||||
|
r1082 | junk = junk.reshape((self.processingHeaderObj.profilesPerBlock, | ||
self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels)) | ||||
|
r975 | except: | ||
|
r1082 | # print "The read block (%3d) has not enough data" %self.nReadBlocks | ||
|
r975 | if self.waitDataBlock(pointer_location=current_pointer_location): | ||
|
r1082 | junk = numpy.fromstring( | ||
block[self.blockPointer:], self.dtype, self.blocksize) | ||||
junk = junk.reshape((self.processingHeaderObj.profilesPerBlock, | ||||
self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels)) | ||||
|
r1017 | # return 0 | ||
|
r975 | |||
|
r1082 | # Dimensions : nChannels, nProfiles, nSamples | ||
|
r975 | |||
|
r1082 | junk = numpy.transpose(junk, (2, 0, 1)) | ||
self.datablock = junk['real'] + junk['imag'] * 1j | ||||
|
r975 | self.profileIndex = 0 | ||
|
r1082 | if self.selBlocksize == None: | ||
self.selBlocksize = self.dataOut.nProfiles | ||||
|
r975 | if self.selBlocktime != None: | ||
if self.dataOut.nCohInt is not None: | ||||
nCohInt = self.dataOut.nCohInt | ||||
else: | ||||
nCohInt = 1 | ||||
|
r1082 | self.selBlocksize = int(self.dataOut.nProfiles * round(self.selBlocktime / ( | ||
nCohInt * self.dataOut.ippSeconds * self.dataOut.nProfiles))) | ||||
self.dataOut.data = self.datablock[:, | ||||
self.profileIndex:self.profileIndex + self.selBlocksize, :] | ||||
|
r975 | datasize = self.dataOut.data.shape[1] | ||
if datasize < self.selBlocksize: | ||||
|
r1082 | buffer = numpy.zeros( | ||
(self.dataOut.data.shape[0], self.selBlocksize, self.dataOut.data.shape[2]), dtype='complex') | ||||
buffer[:, :datasize, :] = self.dataOut.data | ||||
|
r975 | self.dataOut.data = buffer | ||
self.profileIndex = blockIndex | ||||
self.dataOut.flagDataAsBlock = True | ||||
self.flagIsNewBlock = 1 | ||||
self.dataOut.realtime = self.online | ||||
return self.dataOut.data | ||||
|
r487 | def getData(self): | ||
""" | ||||
|
r1019 | getData obtiene una unidad de datos del buffer de lectura, un perfil, y la copia al objeto self.dataOut | ||
del tipo "Voltage" con todos los parametros asociados a este (metadata). cuando no hay datos | ||||
en el buffer de lectura es necesario hacer una nueva lectura de los bloques de datos usando | ||||
"readNextBlock" | ||||
|
r1082 | |||
|
r1019 | Ademas incrementa el contador del buffer "self.profileIndex" en 1. | ||
|
r1082 | |||
|
r1019 | Return: | ||
|
r1082 | |||
|
r1019 | Si el flag self.getByBlock ha sido seteado el bloque completo es copiado a self.dataOut y el self.profileIndex | ||
es igual al total de perfiles leidos desde el archivo. | ||||
|
r1082 | |||
|
r1019 | Si self.getByBlock == False: | ||
|
r1082 | |||
|
r1019 | self.dataOut.data = buffer[:, thisProfile, :] | ||
|
r1082 | |||
|
r1019 | shape = [nChannels, nHeis] | ||
|
r1082 | |||
|
r1019 | Si self.getByBlock == True: | ||
|
r1082 | |||
|
r1019 | self.dataOut.data = buffer[:, :, :] | ||
|
r1082 | |||
|
r1019 | shape = [nChannels, nProfiles, nHeis] | ||
|
r1082 | |||
|
r1019 | Variables afectadas: | ||
self.dataOut | ||||
self.profileIndex | ||||
|
r1082 | |||
|
r1019 | Affected: | ||
self.dataOut | ||||
self.profileIndex | ||||
self.flagDiscontinuousBlock | ||||
self.flagIsNewBlock | ||||
|
r487 | """ | ||
if self.flagNoMoreFiles: | ||||
self.dataOut.flagNoData = True | ||||
print 'Process finished' | ||||
return 0 | ||||
|
r568 | self.flagDiscontinuousBlock = 0 | ||
|
r487 | self.flagIsNewBlock = 0 | ||
if self.__hasNotDataInBuffer(): | ||||
|
r1082 | if not(self.readNextBlock()): | ||
|
r487 | return 0 | ||
|
r1061 | |||
|
r487 | self.getFirstHeader() | ||
|
r1061 | |||
|
r748 | self.reshapeData() | ||
|
r611 | if self.datablock is None: | ||
|
r487 | self.dataOut.flagNoData = True | ||
return 0 | ||||
|
r1061 | |||
|
r534 | if not self.getByBlock: | ||
""" | ||||
|
r1019 | Return profile by profile | ||
If nTxs > 1 then one profile is divided by nTxs and number of total | ||||
blocks is increased by nTxs (nProfiles *= nTxs) | ||||
|
r534 | """ | ||
|
r605 | self.dataOut.flagDataAsBlock = False | ||
|
r1082 | self.dataOut.data = self.datablock[:, self.profileIndex, :] | ||
|
r748 | self.dataOut.profileIndex = self.profileIndex | ||
|
r1061 | |||
|
r748 | self.profileIndex += 1 | ||
|
r1082 | |||
|
r1019 | # elif self.selBlocksize==None or self.selBlocksize==self.dataOut.nProfiles: | ||
# """ | ||||
# Return all block | ||||
# """ | ||||
# self.dataOut.flagDataAsBlock = True | ||||
# self.dataOut.data = self.datablock | ||||
# self.dataOut.profileIndex = self.dataOut.nProfiles - 1 | ||||
|
r1082 | # | ||
|
r1019 | # self.profileIndex = self.dataOut.nProfiles | ||
|
r1082 | |||
|
r534 | else: | ||
""" | ||||
|
r1019 | Return a block | ||
|
r534 | """ | ||
|
r1082 | if self.selBlocksize == None: | ||
self.selBlocksize = self.dataOut.nProfiles | ||||
|
r849 | if self.selBlocktime != None: | ||
if self.dataOut.nCohInt is not None: | ||||
nCohInt = self.dataOut.nCohInt | ||||
else: | ||||
|
r1061 | nCohInt = 1 | ||
|
r1082 | self.selBlocksize = int(self.dataOut.nProfiles * round(self.selBlocktime / ( | ||
nCohInt * self.dataOut.ippSeconds * self.dataOut.nProfiles))) | ||||
|
r1061 | |||
|
r1082 | self.dataOut.data = self.datablock[:, | ||
self.profileIndex:self.profileIndex + self.selBlocksize, :] | ||||
|
r833 | self.profileIndex += self.selBlocksize | ||
|
r834 | datasize = self.dataOut.data.shape[1] | ||
|
r1061 | |||
if datasize < self.selBlocksize: | ||||
|
r1082 | buffer = numpy.zeros( | ||
(self.dataOut.data.shape[0], self.selBlocksize, self.dataOut.data.shape[2]), dtype='complex') | ||||
buffer[:, :datasize, :] = self.dataOut.data | ||||
|
r1061 | |||
|
r1082 | while datasize < self.selBlocksize: # Not enough profiles to fill the block | ||
if not(self.readNextBlock()): | ||||
|
r1061 | return 0 | ||
|
r834 | self.getFirstHeader() | ||
self.reshapeData() | ||||
if self.datablock is None: | ||||
self.dataOut.flagNoData = True | ||||
return 0 | ||||
|
r1082 | # stack data | ||
|
r834 | blockIndex = self.selBlocksize - datasize | ||
|
r1082 | datablock1 = self.datablock[:, :blockIndex, :] | ||
|
r1061 | |||
|
r1082 | buffer[:, datasize:datasize + | ||
datablock1.shape[1], :] = datablock1 | ||||
|
r834 | datasize += datablock1.shape[1] | ||
|
r1061 | |||
|
r834 | self.dataOut.data = buffer | ||
self.profileIndex = blockIndex | ||||
|
r833 | self.dataOut.flagDataAsBlock = True | ||
|
r836 | self.dataOut.nProfiles = self.dataOut.data.shape[1] | ||
|
r1061 | |||
|
r487 | self.dataOut.flagNoData = False | ||
|
r1061 | |||
|
r487 | self.getBasicHeader() | ||
|
r1061 | |||
|
r487 | self.dataOut.realtime = self.online | ||
|
r1061 | |||
|
r487 | return self.dataOut.data | ||
|
r1082 | |||
|
r487 | class VoltageWriter(JRODataWriter, Operation): | ||
|
r1061 | """ | ||
|
r487 | Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura | ||
|
r1061 | de los datos siempre se realiza por bloques. | ||
|
r487 | """ | ||
|
r1061 | |||
|
r487 | ext = ".r" | ||
|
r1061 | |||
|
r487 | optchar = "D" | ||
|
r1061 | |||
|
r487 | shapeBuffer = None | ||
|
r1061 | def __init__(self, **kwargs): | ||
""" | ||||
|
r487 | Inicializador de la clase VoltageWriter para la escritura de datos de espectros. | ||
|
r1061 | |||
Affected: | ||||
|
r487 | self.dataOut | ||
Return: None | ||||
""" | ||||
|
r1061 | Operation.__init__(self, **kwargs) | ||
|
r487 | self.nTotalBlocks = 0 | ||
self.profileIndex = 0 | ||||
|
r1061 | |||
|
r487 | self.isConfig = False | ||
|
r1061 | |||
|
r487 | self.fp = None | ||
self.flagIsNewFile = 1 | ||||
|
r1061 | |||
self.blockIndex = 0 | ||||
|
r487 | self.flagIsNewBlock = 0 | ||
self.setFile = None | ||||
|
r1061 | |||
|
r487 | self.dtype = None | ||
|
r1061 | |||
|
r487 | self.path = None | ||
|
r1061 | |||
|
r487 | self.filename = None | ||
|
r1061 | |||
|
r487 | self.basicHeaderObj = BasicHeader(LOCALTIME) | ||
|
r1061 | |||
|
r487 | self.systemHeaderObj = SystemHeader() | ||
|
r1061 | |||
|
r487 | self.radarControllerHeaderObj = RadarControllerHeader() | ||
|
r1061 | |||
|
r487 | self.processingHeaderObj = ProcessingHeader() | ||
def hasAllDataInBuffer(self): | ||||
if self.profileIndex >= self.processingHeaderObj.profilesPerBlock: | ||||
return 1 | ||||
return 0 | ||||
def setBlockDimension(self): | ||||
""" | ||||
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.processingHeaderObj.profilesPerBlock, | ||||
self.processingHeaderObj.nHeights, | ||||
self.systemHeaderObj.nChannels) | ||||
|
r1061 | |||
|
r487 | self.datablock = numpy.zeros((self.systemHeaderObj.nChannels, | ||
|
r1082 | self.processingHeaderObj.profilesPerBlock, | ||
self.processingHeaderObj.nHeights), | ||||
|
r487 | dtype=numpy.dtype('complex64')) | ||
|
r1061 | |||
|
r487 | def writeBlock(self): | ||
""" | ||||
Escribe el buffer en el file designado | ||||
|
r1061 | |||
|
r487 | Affected: | ||
|
r1061 | self.profileIndex | ||
|
r487 | self.flagIsNewFile | ||
self.flagIsNewBlock | ||||
self.nTotalBlocks | ||||
|
r1061 | self.blockIndex | ||
|
r487 | Return: None | ||
""" | ||||
|
r1082 | data = numpy.zeros(self.shapeBuffer, self.dtype) | ||
|
r1061 | |||
|
r1082 | junk = numpy.transpose(self.datablock, (1, 2, 0)) | ||
|
r1061 | |||
|
r487 | data['real'] = junk.real | ||
data['imag'] = junk.imag | ||||
|
r1061 | |||
|
r1082 | data = data.reshape((-1)) | ||
|
r1061 | |||
|
r1082 | data.tofile(self.fp) | ||
|
r1061 | |||
|
r487 | self.datablock.fill(0) | ||
|
r1061 | |||
self.profileIndex = 0 | ||||
|
r487 | self.flagIsNewFile = 0 | ||
self.flagIsNewBlock = 1 | ||||
|
r1061 | |||
|
r487 | self.blockIndex += 1 | ||
self.nTotalBlocks += 1 | ||||
|
r1061 | |||
|
r585 | # print "[Writing] Block = %04d" %self.blockIndex | ||
|
r1061 | |||
|
r487 | def putData(self): | ||
""" | ||||
|
r1061 | Setea un bloque de datos y luego los escribe en un file | ||
|
r487 | Affected: | ||
self.flagIsNewBlock | ||||
self.profileIndex | ||||
|
r1061 | Return: | ||
0 : Si no hay data o no hay mas files que puedan escribirse | ||||
|
r487 | 1 : Si se escribio la data de un bloque en un file | ||
""" | ||||
if self.dataOut.flagNoData: | ||||
return 0 | ||||
|
r1061 | |||
|
r487 | self.flagIsNewBlock = 0 | ||
|
r1061 | |||
|
r568 | if self.dataOut.flagDiscontinuousBlock: | ||
|
r487 | self.datablock.fill(0) | ||
self.profileIndex = 0 | ||||
self.setNextFile() | ||||
|
r1061 | |||
|
r487 | if self.profileIndex == 0: | ||
self.setBasicHeader() | ||||
|
r1061 | |||
|
r1082 | self.datablock[:, self.profileIndex, :] = self.dataOut.data | ||
|
r1061 | |||
|
r487 | self.profileIndex += 1 | ||
|
r1061 | |||
|
r487 | if self.hasAllDataInBuffer(): | ||
|
r1082 | # if self.flagIsNewFile: | ||
|
r487 | self.writeNextBlock() | ||
# self.setFirstHeader() | ||||
|
r1061 | |||
|
r487 | return 1 | ||
|
r1061 | |||
|
r487 | def __getBlockSize(self): | ||
''' | ||||
Este metodos determina el cantidad de bytes para un bloque de datos de tipo Voltage | ||||
''' | ||||
|
r1061 | |||
|
r616 | dtype_width = self.getDtypeWidth() | ||
|
r1061 | |||
|
r1082 | blocksize = int(self.dataOut.nHeights * self.dataOut.nChannels * | ||
self.profilesPerBlock * dtype_width * 2) | ||||
|
r1061 | |||
|
r487 | return blocksize | ||
|
r1061 | |||
|
r487 | def setFirstHeader(self): | ||
""" | ||||
Obtiene una copia del First Header | ||||
|
r1061 | |||
|
r487 | Affected: | ||
self.systemHeaderObj | ||||
self.radarControllerHeaderObj | ||||
self.dtype | ||||
|
r1061 | Return: | ||
|
r487 | None | ||
""" | ||||
|
r1061 | |||
|
r487 | self.systemHeaderObj = self.dataOut.systemHeaderObj.copy() | ||
self.systemHeaderObj.nChannels = self.dataOut.nChannels | ||||
self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy() | ||||
|
r1061 | |||
|
r1082 | self.processingHeaderObj.dtype = 0 # Voltage | ||
|
r487 | self.processingHeaderObj.blockSize = self.__getBlockSize() | ||
self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock | ||||
self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile | ||||
|
r1082 | # podria ser 1 o self.dataOut.processingHeaderObj.nWindows | ||
self.processingHeaderObj.nWindows = 1 | ||||
|
r487 | self.processingHeaderObj.nCohInt = self.dataOut.nCohInt | ||
|
r1082 | # Cuando la data de origen es de tipo Voltage | ||
self.processingHeaderObj.nIncohInt = 1 | ||||
# Cuando la data de origen es de tipo Voltage | ||||
self.processingHeaderObj.totalSpectra = 0 | ||||
|
r1061 | |||
|
r624 | if self.dataOut.code is not None: | ||
self.processingHeaderObj.code = self.dataOut.code | ||||
self.processingHeaderObj.nCode = self.dataOut.nCode | ||||
self.processingHeaderObj.nBaud = self.dataOut.nBaud | ||||
|
r1061 | |||
|
r487 | if self.processingHeaderObj.nWindows != 0: | ||
self.processingHeaderObj.firstHeight = self.dataOut.heightList[0] | ||||
|
r1082 | self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - \ | ||
self.dataOut.heightList[0] | ||||
|
r487 | self.processingHeaderObj.nHeights = self.dataOut.nHeights | ||
self.processingHeaderObj.samplesWin = self.dataOut.nHeights | ||||
|
r1061 | |||
|
r624 | self.processingHeaderObj.processFlags = self.getProcessFlags() | ||
|
r1061 | |||
self.setBasicHeader() | ||||