##// END OF EJS Templates
schain-jc
RSS
merged into schain_mp
merged into schain_mp
ebocanegra - - Load All Authors

File last commit:

r969:0ac79dee3b6c merge
r969:0ac79dee3b6c merge
Show More
jroIO_spectra.py
1237 lines | 35.7 KiB | text/x-python | PythonLexer
/ schainpy / model / io / jroIO_spectra.py
History | Annotation | Raw |Copy content |Copy permalink
'''
Created on Jul 2, 2014
@author: roj-idl71
'''
import numpy
from jroIO_base import LOCALTIME, JRODataReader, JRODataWriter
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 Spectra
class SpectraReader(JRODataReader, ProcessingUnit):
<<<<<<< HEAD
"""
Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
=======
"""
Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
paresCanalesIguales * alturas * perfiles (Self Spectra)
paresCanalesDiferentes * alturas * perfiles (Cross Spectra)
canales * alturas (DC Channels)
<<<<<<< HEAD
Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque 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 = SpectraReader()
readerObj.setup(dpath, startTime, endTime)
while(True):
readerObj.getData()
print readerObj.data_spc
print readerObj.data_cspc
print readerObj.data_dc
if readerObj.flagNoMoreFiles:
break
"""
pts2read_SelfSpectra = 0
pts2read_CrossSpectra = 0
pts2read_DCchannels = 0
ext = ".pdata"
optchar = "P"
dataOut = None
nRdChannels = None
nRdPairs = None
rdPairList = []
def __init__(self, **kwargs):
"""
Inicializador de la clase SpectraReader para la lectura de datos de espectros.
Inputs:
=======
Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque 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 = SpectraReader()
readerObj.setup(dpath, startTime, endTime)
while(True):
readerObj.getData()
print readerObj.data_spc
print readerObj.data_cspc
print readerObj.data_dc
if readerObj.flagNoMoreFiles:
break
"""
pts2read_SelfSpectra = 0
pts2read_CrossSpectra = 0
pts2read_DCchannels = 0
ext = ".pdata"
optchar = "P"
dataOut = None
nRdChannels = None
nRdPairs = None
rdPairList = []
def __init__(self):
"""
Inicializador de la clase SpectraReader para la lectura de datos de espectros.
Inputs:
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
dataOut : Objeto de la clase Spectra. 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.
<<<<<<< HEAD
Affected:
=======
Affected:
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
self.dataOut
Return : None
"""
<<<<<<< HEAD
#Eliminar de la base la herencia
ProcessingUnit.__init__(self, **kwargs)
# self.isConfig = False
self.pts2read_SelfSpectra = 0
self.pts2read_CrossSpectra = 0
self.pts2read_DCchannels = 0
self.datablock = None
self.utc = None
self.ext = ".pdata"
self.optchar = "P"
self.basicHeaderObj = BasicHeader(LOCALTIME)
self.systemHeaderObj = SystemHeader()
self.radarControllerHeaderObj = RadarControllerHeader()
self.processingHeaderObj = ProcessingHeader()
self.online = 0
self.fp = None
self.idFile = None
self.dtype = None
self.fileSizeByHeader = None
self.filenameList = []
self.filename = None
self.fileSize = None
self.firstHeaderSize = 0
self.basicHeaderSize = 24
self.pathList = []
self.lastUTTime = 0
self.maxTimeStep = 30
self.flagNoMoreFiles = 0
self.set = 0
self.path = None
self.delay = 60 #seconds
self.nTries = 3 #quantity tries
self.nFiles = 3 #number of files for searching
self.nReadBlocks = 0
self.flagIsNewFile = 1
self.__isFirstTimeOnline = 1
# self.ippSeconds = 0
self.flagDiscontinuousBlock = 0
self.flagIsNewBlock = 0
self.nTotalBlocks = 0
self.blocksize = 0
self.dataOut = self.createObjByDefault()
=======
#Eliminar de la base la herencia
ProcessingUnit.__init__(self)
# self.isConfig = False
self.pts2read_SelfSpectra = 0
self.pts2read_CrossSpectra = 0
self.pts2read_DCchannels = 0
self.datablock = None
self.utc = None
self.ext = ".pdata"
self.optchar = "P"
self.basicHeaderObj = BasicHeader(LOCALTIME)
self.systemHeaderObj = SystemHeader()
self.radarControllerHeaderObj = RadarControllerHeader()
self.processingHeaderObj = ProcessingHeader()
self.online = 0
self.fp = None
self.idFile = None
self.dtype = None
self.fileSizeByHeader = None
self.filenameList = []
self.filename = None
self.fileSize = None
self.firstHeaderSize = 0
self.basicHeaderSize = 24
self.pathList = []
self.lastUTTime = 0
self.maxTimeStep = 30
self.flagNoMoreFiles = 0
self.set = 0
self.path = None
self.delay = 60 #seconds
self.nTries = 3 #quantity tries
self.nFiles = 3 #number of files for searching
self.nReadBlocks = 0
self.flagIsNewFile = 1
self.__isFirstTimeOnline = 1
# self.ippSeconds = 0
self.flagDiscontinuousBlock = 0
self.flagIsNewBlock = 0
self.nTotalBlocks = 0
self.blocksize = 0
self.dataOut = self.createObjByDefault()
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
self.profileIndex = 1 #Always
def createObjByDefault(self):
<<<<<<< HEAD
dataObj = Spectra()
return dataObj
=======
dataObj = Spectra()
return dataObj
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
def __hasNotDataInBuffer(self):
return 1
def getBlockDimension(self):
"""
Obtiene la cantidad de puntos a leer por cada bloque de datos
<<<<<<< HEAD
=======
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
Affected:
self.nRdChannels
self.nRdPairs
self.pts2read_SelfSpectra
self.pts2read_CrossSpectra
self.pts2read_DCchannels
self.blocksize
self.dataOut.nChannels
self.dataOut.nPairs
Return:
None
"""
self.nRdChannels = 0
self.nRdPairs = 0
self.rdPairList = []
<<<<<<< HEAD
for i in range(0, self.processingHeaderObj.totalSpectra*2, 2):
if self.processingHeaderObj.spectraComb[i] == self.processingHeaderObj.spectraComb[i+1]:
self.nRdChannels = self.nRdChannels + 1 #par de canales iguales
=======
for i in range(0, self.processingHeaderObj.totalSpectra*2, 2):
if self.processingHeaderObj.spectraComb[i] == self.processingHeaderObj.spectraComb[i+1]:
self.nRdChannels = self.nRdChannels + 1 #par de canales iguales
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
else:
self.nRdPairs = self.nRdPairs + 1 #par de canales diferentes
self.rdPairList.append((self.processingHeaderObj.spectraComb[i], self.processingHeaderObj.spectraComb[i+1]))
pts2read = self.processingHeaderObj.nHeights * self.processingHeaderObj.profilesPerBlock
<<<<<<< HEAD
self.pts2read_SelfSpectra = int(self.nRdChannels * pts2read)
self.blocksize = self.pts2read_SelfSpectra
if self.processingHeaderObj.flag_cspc:
self.pts2read_CrossSpectra = int(self.nRdPairs * pts2read)
self.blocksize += self.pts2read_CrossSpectra
if self.processingHeaderObj.flag_dc:
self.pts2read_DCchannels = int(self.systemHeaderObj.nChannels * self.processingHeaderObj.nHeights)
self.blocksize += self.pts2read_DCchannels
# self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
=======
self.pts2read_SelfSpectra = int(self.nRdChannels * pts2read)
self.blocksize = self.pts2read_SelfSpectra
if self.processingHeaderObj.flag_cspc:
self.pts2read_CrossSpectra = int(self.nRdPairs * pts2read)
self.blocksize += self.pts2read_CrossSpectra
if self.processingHeaderObj.flag_dc:
self.pts2read_DCchannels = int(self.systemHeaderObj.nChannels * self.processingHeaderObj.nHeights)
self.blocksize += self.pts2read_DCchannels
# self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
def readBlock(self):
"""
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
<<<<<<< HEAD
Return: None
Variables afectadas:
=======
Return: None
Variables afectadas:
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
self.flagIsNewFile
self.flagIsNewBlock
self.nTotalBlocks
self.data_spc
self.data_cspc
self.data_dc
<<<<<<< HEAD
Exceptions:
Si un bloque leido no es un bloque valido
"""
=======
Exceptions:
Si un bloque leido no es un bloque valido
"""
print ' ======================================================== '
print ' '
print ' '
print self.processingHeaderObj.totalSpectra, 'TotalSpectra', type(self.processingHeaderObj.totalSpectra)
print self.processingHeaderObj.spectraComb, 'SpectraComb', type(self.processingHeaderObj.spectraComb)
print ' '
print ' '
print ' ======================================================== '
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
blockOk_flag = False
fpointer = self.fp.tell()
spc = numpy.fromfile( self.fp, self.dtype[0], self.pts2read_SelfSpectra )
spc = spc.reshape( (self.nRdChannels, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
<<<<<<< HEAD
if self.processingHeaderObj.flag_cspc:
cspc = numpy.fromfile( self.fp, self.dtype, self.pts2read_CrossSpectra )
cspc = cspc.reshape( (self.nRdPairs, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
if self.processingHeaderObj.flag_dc:
dc = numpy.fromfile( self.fp, self.dtype, self.pts2read_DCchannels ) #int(self.processingHeaderObj.nHeights*self.systemHeaderObj.nChannels) )
dc = dc.reshape( (self.systemHeaderObj.nChannels, self.processingHeaderObj.nHeights) ) #transforma a un arreglo 2D
=======
if self.processingHeaderObj.flag_cspc:
cspc = numpy.fromfile( self.fp, self.dtype, self.pts2read_CrossSpectra )
cspc = cspc.reshape( (self.nRdPairs, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
if self.processingHeaderObj.flag_dc:
dc = numpy.fromfile( self.fp, self.dtype, self.pts2read_DCchannels ) #int(self.processingHeaderObj.nHeights*self.systemHeaderObj.nChannels) )
dc = dc.reshape( (self.systemHeaderObj.nChannels, self.processingHeaderObj.nHeights) ) #transforma a un arreglo 2D
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
if not(self.processingHeaderObj.shif_fft):
#desplaza a la derecha en el eje 2 determinadas posiciones
shift = int(self.processingHeaderObj.profilesPerBlock/2)
spc = numpy.roll( spc, shift , axis=2 )
<<<<<<< HEAD
if self.processingHeaderObj.flag_cspc:
#desplaza a la derecha en el eje 2 determinadas posiciones
cspc = numpy.roll( cspc, shift, axis=2 )
#Dimensions : nChannels, nProfiles, nSamples
spc = numpy.transpose( spc, (0,2,1) )
self.data_spc = spc
if self.processingHeaderObj.flag_cspc:
=======
if self.processingHeaderObj.flag_cspc:
#desplaza a la derecha en el eje 2 determinadas posiciones
cspc = numpy.roll( cspc, shift, axis=2 )
#Dimensions : nChannels, nProfiles, nSamples
spc = numpy.transpose( spc, (0,2,1) )
self.data_spc = spc
if self.processingHeaderObj.flag_cspc:
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
cspc = numpy.transpose( cspc, (0,2,1) )
self.data_cspc = cspc['real'] + cspc['imag']*1j
else:
self.data_cspc = None
<<<<<<< HEAD
=======
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
if self.processingHeaderObj.flag_dc:
self.data_dc = dc['real'] + dc['imag']*1j
else:
self.data_dc = None
self.flagIsNewFile = 0
self.flagIsNewBlock = 1
self.nTotalBlocks += 1
self.nReadBlocks += 1
return 1
<<<<<<< HEAD
def getFirstHeader(self):
self.getBasicHeader()
self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
# self.dataOut.ippSeconds = self.ippSeconds
# self.dataOut.timeInterval = self.radarControllerHeaderObj.ippSeconds * self.processingHeaderObj.nCohInt * self.processingHeaderObj.nIncohInt * self.processingHeaderObj.profilesPerBlock
self.dataOut.dtype = self.dtype
# self.dataOut.nPairs = self.nPairs
self.dataOut.pairsList = self.rdPairList
self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock
self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt
xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
self.dataOut.flagShiftFFT = True #Data is always shifted
self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode #asumo q la data no esta decodificada
self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip #asumo q la data esta sin flip
def getData(self):
"""
First method to execute before "RUN" is called.
Copia el buffer de lectura a la clase "Spectra",
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"
Return:
0 : Si no hay mas archivos disponibles
1 : Si hizo una buena copia del buffer
Affected:
self.dataOut
=======
def getFirstHeader(self):
self.getBasicHeader()
self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
# self.dataOut.ippSeconds = self.ippSeconds
# self.dataOut.timeInterval = self.radarControllerHeaderObj.ippSeconds * self.processingHeaderObj.nCohInt * self.processingHeaderObj.nIncohInt * self.processingHeaderObj.profilesPerBlock
self.dataOut.dtype = self.dtype
# self.dataOut.nPairs = self.nPairs
self.dataOut.pairsList = self.rdPairList
self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock
self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt
xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
self.dataOut.flagShiftFFT = True #Data is always shifted
self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode #asumo q la data no esta decodificada
self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip #asumo q la data esta sin flip
def getData(self):
"""
First method to execute before "RUN" is called.
Copia el buffer de lectura a la clase "Spectra",
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"
Return:
0 : Si no hay mas archivos disponibles
1 : Si hizo una buena copia del buffer
Affected:
self.dataOut
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
self.flagDiscontinuousBlock
self.flagIsNewBlock
"""
if self.flagNoMoreFiles:
self.dataOut.flagNoData = True
print 'Process finished'
return 0
<<<<<<< HEAD
self.flagDiscontinuousBlock = 0
self.flagIsNewBlock = 0
if self.__hasNotDataInBuffer():
=======
self.flagDiscontinuousBlock = 0
self.flagIsNewBlock = 0
if self.__hasNotDataInBuffer():
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
if not( self.readNextBlock() ):
self.dataOut.flagNoData = True
return 0
<<<<<<< HEAD
=======
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
#data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
if self.data_spc is None:
self.dataOut.flagNoData = True
return 0
<<<<<<< HEAD
self.getBasicHeader()
self.getFirstHeader()
self.dataOut.data_spc = self.data_spc
self.dataOut.data_cspc = self.data_cspc
self.dataOut.data_dc = self.data_dc
self.dataOut.flagNoData = False
self.dataOut.realtime = self.online
return self.dataOut.data_spc
class SpectraWriter(JRODataWriter, Operation):
"""
Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
de los datos siempre se realiza por bloques.
"""
ext = ".pdata"
optchar = "P"
shape_spc_Buffer = None
shape_cspc_Buffer = None
shape_dc_Buffer = None
data_spc = None
data_cspc = None
data_dc = None
# dataOut = None
def __init__(self, **kwargs):
"""
Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
Affected:
=======
self.getBasicHeader()
self.getFirstHeader()
self.dataOut.data_spc = self.data_spc
self.dataOut.data_cspc = self.data_cspc
self.dataOut.data_dc = self.data_dc
self.dataOut.flagNoData = False
self.dataOut.realtime = self.online
return self.dataOut.data_spc
class SpectraWriter(JRODataWriter, Operation):
"""
Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
de los datos siempre se realiza por bloques.
"""
ext = ".pdata"
optchar = "P"
shape_spc_Buffer = None
shape_cspc_Buffer = None
shape_dc_Buffer = None
data_spc = None
data_cspc = None
data_dc = None
# dataOut = None
def __init__(self):
"""
Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
Affected:
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
self.dataOut
self.basicHeaderObj
self.systemHeaderObj
self.radarControllerHeaderObj
self.processingHeaderObj
Return: None
"""
<<<<<<< HEAD
Operation.__init__(self, **kwargs)
self.isConfig = False
self.nTotalBlocks = 0
self.data_spc = None
self.data_cspc = None
=======
Operation.__init__(self)
self.isConfig = False
self.nTotalBlocks = 0
self.data_spc = None
self.data_cspc = None
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
self.data_dc = None
self.fp = None
self.flagIsNewFile = 1
<<<<<<< HEAD
self.nTotalBlocks = 0
self.flagIsNewBlock = 0
self.setFile = None
self.dtype = None
self.path = None
self.noMoreFiles = 0
self.filename = None
self.basicHeaderObj = BasicHeader(LOCALTIME)
self.systemHeaderObj = SystemHeader()
self.radarControllerHeaderObj = RadarControllerHeader()
self.processingHeaderObj = ProcessingHeader()
def hasAllDataInBuffer(self):
return 1
=======
self.nTotalBlocks = 0
self.flagIsNewBlock = 0
self.setFile = None
self.dtype = None
self.path = None
self.noMoreFiles = 0
self.filename = None
self.basicHeaderObj = BasicHeader(LOCALTIME)
self.systemHeaderObj = SystemHeader()
self.radarControllerHeaderObj = RadarControllerHeader()
self.processingHeaderObj = ProcessingHeader()
def hasAllDataInBuffer(self):
return 1
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
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.shape_spc_Buffer = (self.dataOut.nChannels,
self.processingHeaderObj.nHeights,
self.processingHeaderObj.profilesPerBlock)
self.shape_cspc_Buffer = (self.dataOut.nPairs,
self.processingHeaderObj.nHeights,
self.processingHeaderObj.profilesPerBlock)
<<<<<<< HEAD
self.shape_dc_Buffer = (self.dataOut.nChannels,
self.processingHeaderObj.nHeights)
def writeBlock(self):
"""
Escribe el buffer en el file designado
=======
self.shape_dc_Buffer = (self.dataOut.nChannels,
self.processingHeaderObj.nHeights)
def writeBlock(self):
"""
Escribe el buffer en el file designado
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
Affected:
self.data_spc
self.data_cspc
self.data_dc
self.flagIsNewFile
self.flagIsNewBlock
self.nTotalBlocks
<<<<<<< HEAD
self.nWriteBlocks
Return: None
"""
=======
self.nWriteBlocks
Return: None
"""
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
spc = numpy.transpose( self.data_spc, (0,2,1) )
if not( self.processingHeaderObj.shif_fft ):
spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
data = spc.reshape((-1))
data = data.astype(self.dtype[0])
data.tofile(self.fp)
if self.data_cspc is not None:
data = numpy.zeros( self.shape_cspc_Buffer, self.dtype )
cspc = numpy.transpose( self.data_cspc, (0,2,1) )
if not( self.processingHeaderObj.shif_fft ):
cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
data['real'] = cspc.real
data['imag'] = cspc.imag
data = data.reshape((-1))
data.tofile(self.fp)
<<<<<<< HEAD
=======
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
if self.data_dc is not None:
data = numpy.zeros( self.shape_dc_Buffer, self.dtype )
dc = self.data_dc
data['real'] = dc.real
data['imag'] = dc.imag
data = data.reshape((-1))
data.tofile(self.fp)
# self.data_spc.fill(0)
<<<<<<< HEAD
#
# if self.data_dc is not None:
# self.data_dc.fill(0)
#
# if self.data_cspc is not None:
# self.data_cspc.fill(0)
=======
#
# if self.data_dc is not None:
# self.data_dc.fill(0)
#
# if self.data_cspc is not None:
# self.data_cspc.fill(0)
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
self.flagIsNewFile = 0
self.flagIsNewBlock = 1
self.nTotalBlocks += 1
self.nWriteBlocks += 1
self.blockIndex += 1
<<<<<<< HEAD
# print "[Writing] Block = %d04" %self.blockIndex
def putData(self):
"""
Setea un bloque de datos y luego los escribe en un file
=======
# print "[Writing] Block = %d04" %self.blockIndex
def putData(self):
"""
Setea un bloque de datos y luego los escribe en un file
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
Affected:
self.data_spc
self.data_cspc
self.data_dc
<<<<<<< HEAD
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
"""
if self.dataOut.flagNoData:
return 0
self.flagIsNewBlock = 0
if self.dataOut.flagDiscontinuousBlock:
self.data_spc.fill(0)
if self.dataOut.data_cspc is not None:
self.data_cspc.fill(0)
if self.dataOut.data_dc is not None:
self.data_dc.fill(0)
self.setNextFile()
if self.flagIsNewFile == 0:
self.setBasicHeader()
self.data_spc = self.dataOut.data_spc.copy()
if self.dataOut.data_cspc is not None:
self.data_cspc = self.dataOut.data_cspc.copy()
if self.dataOut.data_dc is not None:
self.data_dc = self.dataOut.data_dc.copy()
=======
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
"""
if self.dataOut.flagNoData:
return 0
self.flagIsNewBlock = 0
if self.dataOut.flagDiscontinuousBlock:
self.data_spc.fill(0)
self.data_cspc.fill(0)
self.data_dc.fill(0)
self.setNextFile()
if self.flagIsNewFile == 0:
self.setBasicHeader()
self.data_spc = self.dataOut.data_spc.copy()
if self.dataOut.data_cspc is not None:
self.data_cspc = self.dataOut.data_cspc.copy()
if self.dataOut.data_dc is not None:
self.data_dc = self.dataOut.data_dc.copy()
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
# #self.processingHeaderObj.dataBlocksPerFile)
if self.hasAllDataInBuffer():
# self.setFirstHeader()
self.writeNextBlock()
<<<<<<< HEAD
return 1
=======
return 1
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
def __getBlockSize(self):
'''
Este metodos determina el cantidad de bytes para un bloque de datos de tipo Spectra
'''
<<<<<<< HEAD
dtype_width = self.getDtypeWidth()
pts2write = self.dataOut.nHeights * self.dataOut.nFFTPoints
pts2write_SelfSpectra = int(self.dataOut.nChannels * pts2write)
blocksize = (pts2write_SelfSpectra*dtype_width)
if self.dataOut.data_cspc is not None:
pts2write_CrossSpectra = int(self.dataOut.nPairs * pts2write)
blocksize += (pts2write_CrossSpectra*dtype_width*2)
if self.dataOut.data_dc is not None:
pts2write_DCchannels = int(self.dataOut.nChannels * self.dataOut.nHeights)
blocksize += (pts2write_DCchannels*dtype_width*2)
# blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO
return blocksize
def setFirstHeader(self):
"""
Obtiene una copia del First Header
=======
dtype_width = self.getDtypeWidth()
pts2write = self.dataOut.nHeights * self.dataOut.nFFTPoints
pts2write_SelfSpectra = int(self.dataOut.nChannels * pts2write)
blocksize = (pts2write_SelfSpectra*dtype_width)
if self.dataOut.data_cspc is not None:
pts2write_CrossSpectra = int(self.dataOut.nPairs * pts2write)
blocksize += (pts2write_CrossSpectra*dtype_width*2)
if self.dataOut.data_dc is not None:
pts2write_DCchannels = int(self.dataOut.nChannels * self.dataOut.nHeights)
blocksize += (pts2write_DCchannels*dtype_width*2)
# blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO
return blocksize
def setFirstHeader(self):
"""
Obtiene una copia del First Header
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
Affected:
self.systemHeaderObj
self.radarControllerHeaderObj
self.dtype
<<<<<<< HEAD
Return:
None
"""
self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
self.systemHeaderObj.nChannels = self.dataOut.nChannels
self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
=======
Return:
None
"""
self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
self.systemHeaderObj.nChannels = self.dataOut.nChannels
self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
self.processingHeaderObj.dtype = 1 # Spectra
self.processingHeaderObj.blockSize = self.__getBlockSize()
self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints
self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
self.processingHeaderObj.nCohInt = self.dataOut.nCohInt# Se requiere para determinar el valor de timeInterval
<<<<<<< HEAD
self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt
self.processingHeaderObj.totalSpectra = self.dataOut.nPairs + self.dataOut.nChannels
self.processingHeaderObj.shif_fft = self.dataOut.flagShiftFFT
=======
self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt
self.processingHeaderObj.totalSpectra = self.dataOut.nPairs + self.dataOut.nChannels
self.processingHeaderObj.shif_fft = self.dataOut.flagShiftFFT
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
if self.processingHeaderObj.totalSpectra > 0:
channelList = []
for channel in range(self.dataOut.nChannels):
channelList.append(channel)
channelList.append(channel)
<<<<<<< HEAD
=======
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
pairsList = []
if self.dataOut.nPairs > 0:
for pair in self.dataOut.pairsList:
pairsList.append(pair[0])
pairsList.append(pair[1])
<<<<<<< HEAD
spectraComb = channelList + pairsList
spectraComb = numpy.array(spectraComb, dtype="u1")
self.processingHeaderObj.spectraComb = spectraComb
=======
spectraComb = channelList + pairsList
spectraComb = numpy.array(spectraComb, dtype="u1")
self.processingHeaderObj.spectraComb = spectraComb
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
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
<<<<<<< HEAD
=======
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
if self.processingHeaderObj.nWindows != 0:
self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
self.processingHeaderObj.nHeights = self.dataOut.nHeights
self.processingHeaderObj.samplesWin = self.dataOut.nHeights
<<<<<<< HEAD
self.processingHeaderObj.processFlags = self.getProcessFlags()
=======
self.processingHeaderObj.processFlags = self.getProcessFlags()
>>>>>>> 08c4507d6c3c48f6c52326d5dedfa1972fb26356
self.setBasicHeader()