jroIO_spectra.py
678 lines
| 20.2 KiB
| text/x-python
|
PythonLexer
|
r487 | ''' | |
|
r568 | Created on Jul 2, 2014 | |
|
r487 | ||
|
r568 | @author: roj-idl71 | |
''' | |||
|
r487 | import numpy | |
|
r1167 | from schainpy.model.io.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 Spectra | |||
|
r487 | ||
class SpectraReader(JRODataReader, ProcessingUnit): | |||
r889 | """ | ||
|
r487 | Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura | |
r889 | de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones) | ||
|
r487 | 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) | |||
r889 | Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader, | ||
|
r487 | 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". | |||
r889 | |||
Example: | |||
|
r487 | dpath = "/home/myuser/data" | |
r889 | |||
|
r487 | startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0) | |
r889 | |||
|
r487 | endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0) | |
r889 | |||
|
r487 | readerObj = SpectraReader() | |
r889 | |||
|
r487 | readerObj.setup(dpath, startTime, endTime) | |
r889 | |||
|
r487 | while(True): | |
r889 | |||
|
r487 | readerObj.getData() | |
r889 | |||
|
r487 | print readerObj.data_spc | |
r889 | |||
|
r487 | print readerObj.data_cspc | |
r889 | |||
|
r487 | print readerObj.data_dc | |
r889 | |||
|
r487 | if readerObj.flagNoMoreFiles: | |
break | |||
r889 | |||
|
r487 | """ | |
pts2read_SelfSpectra = 0 | |||
r889 | |||
|
r487 | pts2read_CrossSpectra = 0 | |
r889 | |||
|
r487 | pts2read_DCchannels = 0 | |
r889 | |||
|
r487 | ext = ".pdata" | |
r889 | |||
|
r487 | optchar = "P" | |
r889 | |||
|
r487 | dataOut = None | |
r889 | |||
|
r487 | nRdChannels = None | |
r889 | |||
|
r487 | nRdPairs = None | |
r889 | |||
|
r487 | rdPairList = [] | |
r889 | |||
def __init__(self, **kwargs): | |||
""" | |||
|
r487 | Inicializador de la clase SpectraReader para la lectura de datos de espectros. | |
r889 | Inputs: | ||
|
r487 | 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. | |||
r889 | |||
Affected: | |||
|
r487 | self.dataOut | |
Return : None | |||
""" | |||
r889 | |||
|
r487 | #Eliminar de la base la herencia | |
r889 | ProcessingUnit.__init__(self, **kwargs) | ||
|
r487 | # self.isConfig = False | |
r889 | |||
|
r487 | self.pts2read_SelfSpectra = 0 | |
r889 | |||
|
r487 | self.pts2read_CrossSpectra = 0 | |
r889 | |||
|
r487 | self.pts2read_DCchannels = 0 | |
r889 | |||
|
r487 | self.datablock = None | |
r889 | |||
|
r487 | self.utc = None | |
r889 | |||
|
r487 | self.ext = ".pdata" | |
r889 | |||
|
r487 | self.optchar = "P" | |
r889 | |||
|
r487 | self.basicHeaderObj = BasicHeader(LOCALTIME) | |
r889 | |||
|
r487 | self.systemHeaderObj = SystemHeader() | |
r889 | |||
|
r487 | self.radarControllerHeaderObj = RadarControllerHeader() | |
r889 | |||
|
r487 | self.processingHeaderObj = ProcessingHeader() | |
r889 | |||
|
r487 | self.online = 0 | |
r889 | |||
|
r487 | self.fp = None | |
r889 | |||
|
r487 | self.idFile = None | |
r889 | |||
|
r487 | self.dtype = None | |
r889 | |||
|
r487 | self.fileSizeByHeader = None | |
r889 | |||
|
r487 | self.filenameList = [] | |
r889 | |||
|
r487 | self.filename = None | |
r889 | |||
|
r487 | self.fileSize = None | |
r889 | |||
|
r487 | self.firstHeaderSize = 0 | |
r889 | |||
|
r487 | self.basicHeaderSize = 24 | |
r889 | |||
|
r487 | self.pathList = [] | |
self.lastUTTime = 0 | |||
r889 | |||
|
r487 | self.maxTimeStep = 30 | |
r889 | |||
|
r487 | self.flagNoMoreFiles = 0 | |
r889 | |||
|
r487 | self.set = 0 | |
r889 | |||
|
r487 | self.path = None | |
self.delay = 60 #seconds | |||
r889 | |||
|
r487 | self.nTries = 3 #quantity tries | |
r889 | |||
|
r487 | self.nFiles = 3 #number of files for searching | |
r889 | |||
|
r487 | self.nReadBlocks = 0 | |
r889 | |||
|
r487 | self.flagIsNewFile = 1 | |
r889 | |||
|
r487 | self.__isFirstTimeOnline = 1 | |
r889 | |||
|
r487 | # self.ippSeconds = 0 | |
r889 | |||
self.flagDiscontinuousBlock = 0 | |||
|
r487 | self.flagIsNewBlock = 0 | |
r889 | |||
|
r487 | self.nTotalBlocks = 0 | |
r889 | |||
|
r487 | self.blocksize = 0 | |
r889 | |||
|
r487 | self.dataOut = self.createObjByDefault() | |
r889 | |||
|
r487 | self.profileIndex = 1 #Always | |
def createObjByDefault(self): | |||
r889 | |||
|
r487 | dataObj = Spectra() | |
r889 | |||
|
r487 | return dataObj | |
r889 | |||
|
r487 | def __hasNotDataInBuffer(self): | |
return 1 | |||
def getBlockDimension(self): | |||
""" | |||
Obtiene la cantidad de puntos a leer por cada bloque de datos | |||
r889 | |||
|
r487 | 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 = [] | |||
r889 | |||
|
r487 | for i in range(0, self.processingHeaderObj.totalSpectra*2, 2): | |
if self.processingHeaderObj.spectraComb[i] == self.processingHeaderObj.spectraComb[i+1]: | |||
r889 | self.nRdChannels = self.nRdChannels + 1 #par de canales iguales | ||
|
r487 | 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 | |||
self.pts2read_SelfSpectra = int(self.nRdChannels * pts2read) | |||
self.blocksize = self.pts2read_SelfSpectra | |||
r889 | |||
|
r487 | if self.processingHeaderObj.flag_cspc: | |
self.pts2read_CrossSpectra = int(self.nRdPairs * pts2read) | |||
self.blocksize += self.pts2read_CrossSpectra | |||
r889 | |||
|
r487 | if self.processingHeaderObj.flag_dc: | |
self.pts2read_DCchannels = int(self.systemHeaderObj.nChannels * self.processingHeaderObj.nHeights) | |||
self.blocksize += self.pts2read_DCchannels | |||
r889 | |||
|
r487 | # self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels | |
r889 | |||
|
r487 | 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 | |||
r889 | |||
|
r487 | Return: None | |
r889 | |||
|
r487 | Variables afectadas: | |
r889 | |||
|
r487 | self.flagIsNewFile | |
self.flagIsNewBlock | |||
self.nTotalBlocks | |||
self.data_spc | |||
self.data_cspc | |||
self.data_dc | |||
r889 | Exceptions: | ||
|
r487 | Si un bloque leido no es un bloque valido | |
""" | |||
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 | |||
r889 | |||
|
r487 | 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 | |||
r889 | |||
|
r487 | 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 | |||
r889 | |||
|
r1170 | if not self.processingHeaderObj.shif_fft: | |
|
r487 | #desplaza a la derecha en el eje 2 determinadas posiciones | |
shift = int(self.processingHeaderObj.profilesPerBlock/2) | |||
spc = numpy.roll( spc, shift , axis=2 ) | |||
r889 | |||
|
r487 | if self.processingHeaderObj.flag_cspc: | |
#desplaza a la derecha en el eje 2 determinadas posiciones | |||
cspc = numpy.roll( cspc, shift, axis=2 ) | |||
r889 | |||
|
r616 | #Dimensions : nChannels, nProfiles, nSamples | |
|
r487 | spc = numpy.transpose( spc, (0,2,1) ) | |
self.data_spc = spc | |||
r889 | |||
if self.processingHeaderObj.flag_cspc: | |||
|
r487 | cspc = numpy.transpose( cspc, (0,2,1) ) | |
self.data_cspc = cspc['real'] + cspc['imag']*1j | |||
else: | |||
self.data_cspc = None | |||
r889 | |||
|
r487 | 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 | |||
r889 | |||
|
r487 | def getFirstHeader(self): | |
r889 | |||
|
r616 | self.getBasicHeader() | |
r889 | |||
|
r487 | self.dataOut.systemHeaderObj = self.systemHeaderObj.copy() | |
r889 | |||
|
r487 | self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy() | |
r889 | |||
|
r487 | # self.dataOut.ippSeconds = self.ippSeconds | |
r889 | |||
|
r527 | # self.dataOut.timeInterval = self.radarControllerHeaderObj.ippSeconds * self.processingHeaderObj.nCohInt * self.processingHeaderObj.nIncohInt * self.processingHeaderObj.profilesPerBlock | |
|
r487 | ||
self.dataOut.dtype = self.dtype | |||
r889 | |||
|
r487 | # self.dataOut.nPairs = self.nPairs | |
r889 | |||
|
r487 | self.dataOut.pairsList = self.rdPairList | |
r889 | |||
|
r487 | self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock | |
r889 | |||
|
r487 | self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock | |
r889 | |||
|
r487 | self.dataOut.nCohInt = self.processingHeaderObj.nCohInt | |
r889 | |||
|
r487 | self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt | |
r889 | |||
|
r487 | xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight | |
r889 | self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight) | ||
|
r1167 | self.dataOut.channelList = list(range(self.systemHeaderObj.nChannels)) | |
r889 | |||
|
r624 | self.dataOut.flagShiftFFT = True #Data is always shifted | |
r889 | |||
|
r624 | self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode #asumo q la data no esta decodificada | |
r889 | |||
self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip #asumo q la data esta sin flip | |||
|
r487 | def getData(self): | |
""" | |||
First method to execute before "RUN" is called. | |||
r889 | |||
|
r487 | 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" | |||
r889 | |||
|
r487 | Return: | |
0 : Si no hay mas archivos disponibles | |||
1 : Si hizo una buena copia del buffer | |||
r889 | |||
|
r487 | Affected: | |
self.dataOut | |||
r889 | |||
|
r568 | self.flagDiscontinuousBlock | |
|
r487 | self.flagIsNewBlock | |
""" | |||
if self.flagNoMoreFiles: | |||
self.dataOut.flagNoData = True | |||
|
r1167 | print('Process finished') | |
|
r487 | return 0 | |
r889 | |||
|
r568 | self.flagDiscontinuousBlock = 0 | |
|
r487 | self.flagIsNewBlock = 0 | |
r889 | |||
if self.__hasNotDataInBuffer(): | |||
|
r487 | ||
if not( self.readNextBlock() ): | |||
self.dataOut.flagNoData = True | |||
return 0 | |||
r889 | |||
|
r487 | #data es un numpy array de 3 dmensiones (perfiles, alturas y canales) | |
|
r624 | if self.data_spc is None: | |
|
r487 | self.dataOut.flagNoData = True | |
return 0 | |||
r889 | |||
|
r487 | self.getBasicHeader() | |
r889 | |||
|
r487 | self.getFirstHeader() | |
self.dataOut.data_spc = self.data_spc | |||
r889 | |||
|
r487 | self.dataOut.data_cspc = self.data_cspc | |
r889 | |||
|
r487 | self.dataOut.data_dc = self.data_dc | |
r889 | |||
|
r487 | self.dataOut.flagNoData = False | |
r889 | |||
|
r487 | self.dataOut.realtime = self.online | |
r889 | |||
|
r487 | return self.dataOut.data_spc | |
class SpectraWriter(JRODataWriter, Operation): | |||
r889 | |||
""" | |||
|
r487 | Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura | |
r889 | de los datos siempre se realiza por bloques. | ||
|
r487 | """ | |
r889 | |||
|
r487 | ext = ".pdata" | |
r889 | |||
|
r487 | optchar = "P" | |
r889 | |||
|
r487 | shape_spc_Buffer = None | |
r889 | |||
|
r487 | shape_cspc_Buffer = None | |
r889 | |||
|
r487 | shape_dc_Buffer = None | |
r889 | |||
|
r487 | data_spc = None | |
r889 | |||
|
r487 | data_cspc = None | |
r889 | |||
|
r487 | data_dc = None | |
r889 | |||
|
r487 | # dataOut = None | |
r889 | |||
|
r897 | def __init__(self, **kwargs): | |
r889 | """ | ||
|
r487 | Inicializador de la clase SpectraWriter para la escritura de datos de espectros. | |
r889 | |||
Affected: | |||
|
r487 | self.dataOut | |
self.basicHeaderObj | |||
self.systemHeaderObj | |||
self.radarControllerHeaderObj | |||
self.processingHeaderObj | |||
Return: None | |||
""" | |||
r889 | |||
|
r897 | Operation.__init__(self, **kwargs) | |
r889 | |||
|
r487 | self.isConfig = False | |
r889 | |||
|
r487 | self.nTotalBlocks = 0 | |
r889 | |||
|
r487 | self.data_spc = None | |
r889 | |||
|
r487 | self.data_cspc = None | |
r889 | |||
|
r487 | self.data_dc = None | |
self.fp = None | |||
self.flagIsNewFile = 1 | |||
r889 | |||
self.nTotalBlocks = 0 | |||
|
r487 | self.flagIsNewBlock = 0 | |
self.setFile = None | |||
r889 | |||
|
r487 | self.dtype = None | |
r889 | |||
|
r487 | self.path = None | |
r889 | |||
|
r487 | self.noMoreFiles = 0 | |
r889 | |||
|
r487 | self.filename = None | |
r889 | |||
|
r487 | self.basicHeaderObj = BasicHeader(LOCALTIME) | |
r889 | |||
|
r487 | self.systemHeaderObj = SystemHeader() | |
r889 | |||
|
r487 | self.radarControllerHeaderObj = RadarControllerHeader() | |
r889 | |||
|
r487 | self.processingHeaderObj = ProcessingHeader() | |
r889 | |||
|
r487 | def hasAllDataInBuffer(self): | |
return 1 | |||
r889 | |||
|
r487 | 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) | |||
r889 | |||
|
r487 | self.shape_dc_Buffer = (self.dataOut.nChannels, | |
self.processingHeaderObj.nHeights) | |||
r889 | |||
|
r487 | def writeBlock(self): | |
""" | |||
Escribe el buffer en el file designado | |||
r889 | |||
|
r487 | Affected: | |
self.data_spc | |||
self.data_cspc | |||
self.data_dc | |||
self.flagIsNewFile | |||
self.flagIsNewBlock | |||
self.nTotalBlocks | |||
r889 | self.nWriteBlocks | ||
|
r487 | Return: None | |
""" | |||
r889 | |||
|
r487 | spc = numpy.transpose( self.data_spc, (0,2,1) ) | |
|
r1170 | if not self.processingHeaderObj.shif_fft: | |
|
r487 | 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) | |||
|
r612 | if self.data_cspc is not None: | |
|
r487 | data = numpy.zeros( self.shape_cspc_Buffer, self.dtype ) | |
cspc = numpy.transpose( self.data_cspc, (0,2,1) ) | |||
|
r1170 | if not self.processingHeaderObj.shif_fft: | |
|
r487 | 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) | |||
r889 | |||
|
r612 | if self.data_dc is not None: | |
|
r487 | 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) | |||
|
r781 | # self.data_spc.fill(0) | |
r889 | # | ||
|
r781 | # if self.data_dc is not None: | |
# self.data_dc.fill(0) | |||
r889 | # | ||
|
r781 | # if self.data_cspc is not None: | |
# self.data_cspc.fill(0) | |||
r889 | |||
|
r487 | self.flagIsNewFile = 0 | |
self.flagIsNewBlock = 1 | |||
self.nTotalBlocks += 1 | |||
self.nWriteBlocks += 1 | |||
self.blockIndex += 1 | |||
r889 | |||
|
r584 | # print "[Writing] Block = %d04" %self.blockIndex | |
r889 | |||
|
r487 | def putData(self): | |
""" | |||
r889 | Setea un bloque de datos y luego los escribe en un file | ||
|
r487 | Affected: | |
self.data_spc | |||
self.data_cspc | |||
self.data_dc | |||
r889 | 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 | |
""" | |||
r889 | |||
|
r487 | if self.dataOut.flagNoData: | |
return 0 | |||
r889 | |||
|
r487 | self.flagIsNewBlock = 0 | |
r889 | |||
|
r568 | if self.dataOut.flagDiscontinuousBlock: | |
|
r487 | self.data_spc.fill(0) | |
|
r860 | 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) | |||
|
r487 | self.setNextFile() | |
r889 | |||
|
r487 | if self.flagIsNewFile == 0: | |
self.setBasicHeader() | |||
r889 | |||
|
r487 | self.data_spc = self.dataOut.data_spc.copy() | |
r889 | |||
|
r612 | if self.dataOut.data_cspc is not None: | |
|
r487 | self.data_cspc = self.dataOut.data_cspc.copy() | |
r889 | |||
|
r781 | if self.dataOut.data_dc is not None: | |
self.data_dc = self.dataOut.data_dc.copy() | |||
r889 | |||
|
r487 | # #self.processingHeaderObj.dataBlocksPerFile) | |
if self.hasAllDataInBuffer(): | |||
# self.setFirstHeader() | |||
self.writeNextBlock() | |||
r889 | |||
|
r487 | return 1 | |
r889 | |||
|
r487 | def __getBlockSize(self): | |
''' | |||
Este metodos determina el cantidad de bytes para un bloque de datos de tipo Spectra | |||
''' | |||
r889 | |||
|
r616 | dtype_width = self.getDtypeWidth() | |
r889 | |||
|
r487 | pts2write = self.dataOut.nHeights * self.dataOut.nFFTPoints | |
r889 | |||
|
r487 | pts2write_SelfSpectra = int(self.dataOut.nChannels * pts2write) | |
|
r616 | blocksize = (pts2write_SelfSpectra*dtype_width) | |
r889 | |||
|
r612 | if self.dataOut.data_cspc is not None: | |
|
r487 | pts2write_CrossSpectra = int(self.dataOut.nPairs * pts2write) | |
|
r616 | blocksize += (pts2write_CrossSpectra*dtype_width*2) | |
r889 | |||
|
r612 | if self.dataOut.data_dc is not None: | |
|
r487 | pts2write_DCchannels = int(self.dataOut.nChannels * self.dataOut.nHeights) | |
|
r616 | blocksize += (pts2write_DCchannels*dtype_width*2) | |
r889 | |||
|
r616 | # blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO | |
|
r487 | ||
return blocksize | |||
r889 | |||
|
r487 | def setFirstHeader(self): | |
r889 | |||
|
r487 | """ | |
Obtiene una copia del First Header | |||
r889 | |||
|
r487 | Affected: | |
self.systemHeaderObj | |||
self.radarControllerHeaderObj | |||
self.dtype | |||
r889 | Return: | ||
|
r487 | None | |
""" | |||
r889 | |||
|
r487 | self.systemHeaderObj = self.dataOut.systemHeaderObj.copy() | |
self.systemHeaderObj.nChannels = self.dataOut.nChannels | |||
self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy() | |||
r889 | |||
|
r487 | 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 | |||
r889 | self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt | ||
|
r487 | self.processingHeaderObj.totalSpectra = self.dataOut.nPairs + self.dataOut.nChannels | |
self.processingHeaderObj.shif_fft = self.dataOut.flagShiftFFT | |||
r889 | |||
|
r487 | if self.processingHeaderObj.totalSpectra > 0: | |
channelList = [] | |||
for channel in range(self.dataOut.nChannels): | |||
channelList.append(channel) | |||
channelList.append(channel) | |||
r889 | |||
|
r487 | pairsList = [] | |
if self.dataOut.nPairs > 0: | |||
for pair in self.dataOut.pairsList: | |||
pairsList.append(pair[0]) | |||
pairsList.append(pair[1]) | |||
r889 | |||
|
r487 | spectraComb = channelList + pairsList | |
|
r624 | spectraComb = numpy.array(spectraComb, dtype="u1") | |
|
r487 | self.processingHeaderObj.spectraComb = spectraComb | |
r889 | |||
|
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 | |||
r889 | |||
|
r487 | 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 | |||
r889 | |||
|
r624 | self.processingHeaderObj.processFlags = self.getProcessFlags() | |
r889 | |||
|
r1167 | self.setBasicHeader() |