|
|
import numpy
|
|
|
|
|
|
from jroproc_base import ProcessingUnit, Operation
|
|
|
from model.data.jrodata import Voltage
|
|
|
|
|
|
class VoltageProc(ProcessingUnit):
|
|
|
|
|
|
|
|
|
def __init__(self):
|
|
|
|
|
|
ProcessingUnit.__init__(self)
|
|
|
|
|
|
# self.objectDict = {}
|
|
|
self.dataOut = Voltage()
|
|
|
self.flip = 1
|
|
|
|
|
|
def run(self):
|
|
|
self.dataOut.copy(self.dataIn)
|
|
|
|
|
|
# def __updateObjFromAmisrInput(self):
|
|
|
#
|
|
|
# self.dataOut.timeZone = self.dataIn.timeZone
|
|
|
# self.dataOut.dstFlag = self.dataIn.dstFlag
|
|
|
# self.dataOut.errorCount = self.dataIn.errorCount
|
|
|
# self.dataOut.useLocalTime = self.dataIn.useLocalTime
|
|
|
#
|
|
|
# self.dataOut.flagNoData = self.dataIn.flagNoData
|
|
|
# self.dataOut.data = self.dataIn.data
|
|
|
# self.dataOut.utctime = self.dataIn.utctime
|
|
|
# self.dataOut.channelList = self.dataIn.channelList
|
|
|
# self.dataOut.timeInterval = self.dataIn.timeInterval
|
|
|
# self.dataOut.heightList = self.dataIn.heightList
|
|
|
# self.dataOut.nProfiles = self.dataIn.nProfiles
|
|
|
#
|
|
|
# self.dataOut.nCohInt = self.dataIn.nCohInt
|
|
|
# self.dataOut.ippSeconds = self.dataIn.ippSeconds
|
|
|
# self.dataOut.frequency = self.dataIn.frequency
|
|
|
#
|
|
|
# pass#
|
|
|
#
|
|
|
# def init(self):
|
|
|
#
|
|
|
#
|
|
|
# if self.dataIn.type == 'AMISR':
|
|
|
# self.__updateObjFromAmisrInput()
|
|
|
#
|
|
|
# if self.dataIn.type == 'Voltage':
|
|
|
# self.dataOut.copy(self.dataIn)
|
|
|
# # No necesita copiar en cada init() los atributos de dataIn
|
|
|
# # la copia deberia hacerse por cada nuevo bloque de datos
|
|
|
|
|
|
def selectChannels(self, channelList):
|
|
|
|
|
|
channelIndexList = []
|
|
|
|
|
|
for channel in channelList:
|
|
|
index = self.dataOut.channelList.index(channel)
|
|
|
channelIndexList.append(index)
|
|
|
|
|
|
self.selectChannelsByIndex(channelIndexList)
|
|
|
|
|
|
def selectChannelsByIndex(self, channelIndexList):
|
|
|
"""
|
|
|
Selecciona un bloque de datos en base a canales segun el channelIndexList
|
|
|
|
|
|
Input:
|
|
|
channelIndexList : lista sencilla de canales a seleccionar por ej. [2,3,7]
|
|
|
|
|
|
Affected:
|
|
|
self.dataOut.data
|
|
|
self.dataOut.channelIndexList
|
|
|
self.dataOut.nChannels
|
|
|
self.dataOut.m_ProcessingHeader.totalSpectra
|
|
|
self.dataOut.systemHeaderObj.numChannels
|
|
|
self.dataOut.m_ProcessingHeader.blockSize
|
|
|
|
|
|
Return:
|
|
|
None
|
|
|
"""
|
|
|
|
|
|
for channelIndex in channelIndexList:
|
|
|
if channelIndex not in self.dataOut.channelIndexList:
|
|
|
print channelIndexList
|
|
|
raise ValueError, "The value %d in channelIndexList is not valid" %channelIndex
|
|
|
|
|
|
# nChannels = len(channelIndexList)
|
|
|
|
|
|
data = self.dataOut.data[channelIndexList,:]
|
|
|
|
|
|
self.dataOut.data = data
|
|
|
self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
|
|
|
# self.dataOut.nChannels = nChannels
|
|
|
|
|
|
return 1
|
|
|
|
|
|
def selectHeights(self, minHei=None, maxHei=None):
|
|
|
"""
|
|
|
Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
|
|
|
minHei <= height <= maxHei
|
|
|
|
|
|
Input:
|
|
|
minHei : valor minimo de altura a considerar
|
|
|
maxHei : valor maximo de altura a considerar
|
|
|
|
|
|
Affected:
|
|
|
Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
|
|
|
|
|
|
Return:
|
|
|
1 si el metodo se ejecuto con exito caso contrario devuelve 0
|
|
|
"""
|
|
|
|
|
|
if minHei == None:
|
|
|
minHei = self.dataOut.heightList[0]
|
|
|
|
|
|
if maxHei == None:
|
|
|
maxHei = self.dataOut.heightList[-1]
|
|
|
|
|
|
if (minHei < self.dataOut.heightList[0]) or (minHei > maxHei):
|
|
|
raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
|
|
|
|
|
|
|
|
|
if (maxHei > self.dataOut.heightList[-1]):
|
|
|
maxHei = self.dataOut.heightList[-1]
|
|
|
# raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
|
|
|
|
|
|
minIndex = 0
|
|
|
maxIndex = 0
|
|
|
heights = self.dataOut.heightList
|
|
|
|
|
|
inda = numpy.where(heights >= minHei)
|
|
|
indb = numpy.where(heights <= maxHei)
|
|
|
|
|
|
try:
|
|
|
minIndex = inda[0][0]
|
|
|
except:
|
|
|
minIndex = 0
|
|
|
|
|
|
try:
|
|
|
maxIndex = indb[0][-1]
|
|
|
except:
|
|
|
maxIndex = len(heights)
|
|
|
|
|
|
self.selectHeightsByIndex(minIndex, maxIndex)
|
|
|
|
|
|
return 1
|
|
|
|
|
|
|
|
|
def selectHeightsByIndex(self, minIndex, maxIndex):
|
|
|
"""
|
|
|
Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
|
|
|
minIndex <= index <= maxIndex
|
|
|
|
|
|
Input:
|
|
|
minIndex : valor de indice minimo de altura a considerar
|
|
|
maxIndex : valor de indice maximo de altura a considerar
|
|
|
|
|
|
Affected:
|
|
|
self.dataOut.data
|
|
|
self.dataOut.heightList
|
|
|
|
|
|
Return:
|
|
|
1 si el metodo se ejecuto con exito caso contrario devuelve 0
|
|
|
"""
|
|
|
|
|
|
if (minIndex < 0) or (minIndex > maxIndex):
|
|
|
raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
|
|
|
|
|
|
if (maxIndex >= self.dataOut.nHeights):
|
|
|
maxIndex = self.dataOut.nHeights-1
|
|
|
# raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
|
|
|
|
|
|
# nHeights = maxIndex - minIndex + 1
|
|
|
|
|
|
#voltage
|
|
|
data = self.dataOut.data[:,minIndex:maxIndex+1]
|
|
|
|
|
|
# firstHeight = self.dataOut.heightList[minIndex]
|
|
|
|
|
|
self.dataOut.data = data
|
|
|
self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex+1]
|
|
|
|
|
|
return 1
|
|
|
|
|
|
|
|
|
def filterByHeights(self, window):
|
|
|
deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
|
|
|
|
|
|
if window == None:
|
|
|
window = (self.dataOut.radarControllerHeaderObj.txA/self.dataOut.radarControllerHeaderObj.nBaud) / deltaHeight
|
|
|
|
|
|
newdelta = deltaHeight * window
|
|
|
r = self.dataOut.data.shape[1] % window
|
|
|
buffer = self.dataOut.data[:,0:self.dataOut.data.shape[1]-r]
|
|
|
buffer = buffer.reshape(self.dataOut.data.shape[0],self.dataOut.data.shape[1]/window,window)
|
|
|
buffer = numpy.sum(buffer,2)
|
|
|
self.dataOut.data = buffer
|
|
|
self.dataOut.heightList = numpy.arange(self.dataOut.heightList[0],newdelta*(self.dataOut.nHeights-r)/window,newdelta)
|
|
|
self.dataOut.windowOfFilter = window
|
|
|
|
|
|
def deFlip(self):
|
|
|
self.dataOut.data *= self.flip
|
|
|
self.flip *= -1.
|
|
|
|
|
|
def setRadarFrequency(self, frequency=None):
|
|
|
if frequency != None:
|
|
|
self.dataOut.frequency = frequency
|
|
|
|
|
|
return 1
|
|
|
|
|
|
class CohInt(Operation):
|
|
|
|
|
|
isConfig = False
|
|
|
|
|
|
__profIndex = 0
|
|
|
__withOverapping = False
|
|
|
|
|
|
__byTime = False
|
|
|
__initime = None
|
|
|
__lastdatatime = None
|
|
|
__integrationtime = None
|
|
|
|
|
|
__buffer = None
|
|
|
|
|
|
__dataReady = False
|
|
|
|
|
|
n = None
|
|
|
|
|
|
|
|
|
def __init__(self):
|
|
|
|
|
|
Operation.__init__(self)
|
|
|
|
|
|
# self.isConfig = False
|
|
|
|
|
|
def setup(self, n=None, timeInterval=None, overlapping=False):
|
|
|
"""
|
|
|
Set the parameters of the integration class.
|
|
|
|
|
|
Inputs:
|
|
|
|
|
|
n : Number of coherent integrations
|
|
|
timeInterval : Time of integration. If the parameter "n" is selected this one does not work
|
|
|
overlapping :
|
|
|
|
|
|
"""
|
|
|
|
|
|
self.__initime = None
|
|
|
self.__lastdatatime = 0
|
|
|
self.__buffer = None
|
|
|
self.__dataReady = False
|
|
|
|
|
|
|
|
|
if n == None and timeInterval == None:
|
|
|
raise ValueError, "n or timeInterval should be specified ..."
|
|
|
|
|
|
if n != None:
|
|
|
self.n = n
|
|
|
self.__byTime = False
|
|
|
else:
|
|
|
self.__integrationtime = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
|
|
|
self.n = 9999
|
|
|
self.__byTime = True
|
|
|
|
|
|
if overlapping:
|
|
|
self.__withOverapping = True
|
|
|
self.__buffer = None
|
|
|
else:
|
|
|
self.__withOverapping = False
|
|
|
self.__buffer = 0
|
|
|
|
|
|
self.__profIndex = 0
|
|
|
|
|
|
def putData(self, data):
|
|
|
|
|
|
"""
|
|
|
Add a profile to the __buffer and increase in one the __profileIndex
|
|
|
|
|
|
"""
|
|
|
|
|
|
if not self.__withOverapping:
|
|
|
self.__buffer += data.copy()
|
|
|
self.__profIndex += 1
|
|
|
return
|
|
|
|
|
|
#Overlapping data
|
|
|
nChannels, nHeis = data.shape
|
|
|
data = numpy.reshape(data, (1, nChannels, nHeis))
|
|
|
|
|
|
#If the buffer is empty then it takes the data value
|
|
|
if self.__buffer == None:
|
|
|
self.__buffer = data
|
|
|
self.__profIndex += 1
|
|
|
return
|
|
|
|
|
|
#If the buffer length is lower than n then stakcing the data value
|
|
|
if self.__profIndex < self.n:
|
|
|
self.__buffer = numpy.vstack((self.__buffer, data))
|
|
|
self.__profIndex += 1
|
|
|
return
|
|
|
|
|
|
#If the buffer length is equal to n then replacing the last buffer value with the data value
|
|
|
self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
|
|
|
self.__buffer[self.n-1] = data
|
|
|
self.__profIndex = self.n
|
|
|
return
|
|
|
|
|
|
|
|
|
def pushData(self):
|
|
|
"""
|
|
|
Return the sum of the last profiles and the profiles used in the sum.
|
|
|
|
|
|
Affected:
|
|
|
|
|
|
self.__profileIndex
|
|
|
|
|
|
"""
|
|
|
|
|
|
if not self.__withOverapping:
|
|
|
data = self.__buffer
|
|
|
n = self.__profIndex
|
|
|
|
|
|
self.__buffer = 0
|
|
|
self.__profIndex = 0
|
|
|
|
|
|
return data, n
|
|
|
|
|
|
#Integration with Overlapping
|
|
|
data = numpy.sum(self.__buffer, axis=0)
|
|
|
n = self.__profIndex
|
|
|
|
|
|
return data, n
|
|
|
|
|
|
def byProfiles(self, data):
|
|
|
|
|
|
self.__dataReady = False
|
|
|
avgdata = None
|
|
|
# n = None
|
|
|
|
|
|
self.putData(data)
|
|
|
|
|
|
if self.__profIndex == self.n:
|
|
|
|
|
|
avgdata, n = self.pushData()
|
|
|
self.__dataReady = True
|
|
|
|
|
|
return avgdata
|
|
|
|
|
|
def byTime(self, data, datatime):
|
|
|
|
|
|
self.__dataReady = False
|
|
|
avgdata = None
|
|
|
n = None
|
|
|
|
|
|
self.putData(data)
|
|
|
|
|
|
if (datatime - self.__initime) >= self.__integrationtime:
|
|
|
avgdata, n = self.pushData()
|
|
|
self.n = n
|
|
|
self.__dataReady = True
|
|
|
|
|
|
return avgdata
|
|
|
|
|
|
def integrate(self, data, datatime=None):
|
|
|
|
|
|
if self.__initime == None:
|
|
|
self.__initime = datatime
|
|
|
|
|
|
if self.__byTime:
|
|
|
avgdata = self.byTime(data, datatime)
|
|
|
else:
|
|
|
avgdata = self.byProfiles(data)
|
|
|
|
|
|
|
|
|
self.__lastdatatime = datatime
|
|
|
|
|
|
if avgdata == None:
|
|
|
return None, None
|
|
|
|
|
|
avgdatatime = self.__initime
|
|
|
|
|
|
deltatime = datatime -self.__lastdatatime
|
|
|
|
|
|
if not self.__withOverapping:
|
|
|
self.__initime = datatime
|
|
|
else:
|
|
|
self.__initime += deltatime
|
|
|
|
|
|
return avgdata, avgdatatime
|
|
|
|
|
|
def run(self, dataOut, **kwargs):
|
|
|
|
|
|
if not self.isConfig:
|
|
|
self.setup(**kwargs)
|
|
|
self.isConfig = True
|
|
|
|
|
|
avgdata, avgdatatime = self.integrate(dataOut.data, dataOut.utctime)
|
|
|
|
|
|
# dataOut.timeInterval *= n
|
|
|
dataOut.flagNoData = True
|
|
|
|
|
|
if self.__dataReady:
|
|
|
dataOut.data = avgdata
|
|
|
dataOut.nCohInt *= self.n
|
|
|
dataOut.utctime = avgdatatime
|
|
|
dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt
|
|
|
dataOut.flagNoData = False
|
|
|
|
|
|
class Decoder(Operation):
|
|
|
|
|
|
isConfig = False
|
|
|
__profIndex = 0
|
|
|
|
|
|
code = None
|
|
|
|
|
|
nCode = None
|
|
|
nBaud = None
|
|
|
|
|
|
def __init__(self):
|
|
|
|
|
|
Operation.__init__(self)
|
|
|
# self.isConfig = False
|
|
|
|
|
|
def setup(self, code, shape):
|
|
|
|
|
|
self.__profIndex = 0
|
|
|
|
|
|
self.code = code
|
|
|
|
|
|
self.nCode = len(code)
|
|
|
self.nBaud = len(code[0])
|
|
|
|
|
|
self.__nChannels, self.__nHeis = shape
|
|
|
|
|
|
__codeBuffer = numpy.zeros((self.nCode, self.__nHeis), dtype=numpy.complex)
|
|
|
|
|
|
__codeBuffer[:,0:self.nBaud] = self.code
|
|
|
|
|
|
self.fft_code = numpy.conj(numpy.fft.fft(__codeBuffer, axis=1))
|
|
|
|
|
|
self.ndatadec = self.__nHeis - self.nBaud + 1
|
|
|
|
|
|
self.datadecTime = numpy.zeros((self.__nChannels, self.ndatadec), dtype=numpy.complex)
|
|
|
|
|
|
def convolutionInFreq(self, data):
|
|
|
|
|
|
fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
|
|
|
|
|
|
fft_data = numpy.fft.fft(data, axis=1)
|
|
|
|
|
|
conv = fft_data*fft_code
|
|
|
|
|
|
data = numpy.fft.ifft(conv,axis=1)
|
|
|
|
|
|
datadec = data[:,:-self.nBaud+1]
|
|
|
|
|
|
return datadec
|
|
|
|
|
|
def convolutionInFreqOpt(self, data):
|
|
|
|
|
|
fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
|
|
|
|
|
|
data = cfunctions.decoder(fft_code, data)
|
|
|
|
|
|
datadec = data[:,:-self.nBaud+1]
|
|
|
|
|
|
return datadec
|
|
|
|
|
|
def convolutionInTime(self, data):
|
|
|
|
|
|
code = self.code[self.__profIndex]
|
|
|
|
|
|
for i in range(self.__nChannels):
|
|
|
self.datadecTime[i,:] = numpy.correlate(data[i,:], code, mode='valid')
|
|
|
|
|
|
return self.datadecTime
|
|
|
|
|
|
def run(self, dataOut, code=None, nCode=None, nBaud=None, mode = 0):
|
|
|
|
|
|
if code == None:
|
|
|
code = dataOut.code
|
|
|
else:
|
|
|
code = numpy.array(code).reshape(nCode,nBaud)
|
|
|
dataOut.code = code
|
|
|
dataOut.nCode = nCode
|
|
|
dataOut.nBaud = nBaud
|
|
|
dataOut.radarControllerHeaderObj.code = code
|
|
|
dataOut.radarControllerHeaderObj.nCode = nCode
|
|
|
dataOut.radarControllerHeaderObj.nBaud = nBaud
|
|
|
|
|
|
|
|
|
if not self.isConfig:
|
|
|
|
|
|
self.setup(code, dataOut.data.shape)
|
|
|
self.isConfig = True
|
|
|
|
|
|
if mode == 0:
|
|
|
datadec = self.convolutionInTime(dataOut.data)
|
|
|
|
|
|
if mode == 1:
|
|
|
datadec = self.convolutionInFreq(dataOut.data)
|
|
|
|
|
|
if mode == 2:
|
|
|
datadec = self.convolutionInFreqOpt(dataOut.data)
|
|
|
|
|
|
dataOut.data = datadec
|
|
|
|
|
|
dataOut.heightList = dataOut.heightList[0:self.ndatadec]
|
|
|
|
|
|
dataOut.flagDecodeData = True #asumo q la data no esta decodificada
|
|
|
|
|
|
if self.__profIndex == self.nCode-1:
|
|
|
self.__profIndex = 0
|
|
|
return 1
|
|
|
|
|
|
self.__profIndex += 1
|
|
|
|
|
|
return 1
|
|
|
# dataOut.flagDeflipData = True #asumo q la data no esta sin flip
|
|
|
|
