|
|
'''
|
|
|
Created on Feb 7, 2012
|
|
|
|
|
|
@author $Author$
|
|
|
@version $Id$
|
|
|
'''
|
|
|
|
|
|
import os, sys
|
|
|
import numpy
|
|
|
|
|
|
path = os.path.split(os.getcwd())[0]
|
|
|
sys.path.append(path)
|
|
|
|
|
|
from Model.Voltage import Voltage
|
|
|
from IO.VoltageIO import VoltageWriter
|
|
|
from Graphics.VoltagePlot import Osciloscope
|
|
|
|
|
|
class VoltageProcessor:
|
|
|
'''
|
|
|
classdocs
|
|
|
'''
|
|
|
|
|
|
def __init__(self, voltageInObj, voltageOutObj=None):
|
|
|
'''
|
|
|
Constructor
|
|
|
'''
|
|
|
|
|
|
self.voltageInObj = voltageInObj
|
|
|
|
|
|
if voltageOutObj == None:
|
|
|
self.voltageOutObj = Voltage()
|
|
|
else:
|
|
|
self.voltageOutObj = voltageOutObj
|
|
|
|
|
|
self.integratorIndex = None
|
|
|
self.decoderIndex = None
|
|
|
self.writerIndex = None
|
|
|
self.plotterIndex = None
|
|
|
|
|
|
self.integratorList = []
|
|
|
self.decoderList = []
|
|
|
self.writerList = []
|
|
|
self.plotterList = []
|
|
|
|
|
|
def init(self):
|
|
|
self.integratorIndex = 0
|
|
|
self.decoderIndex = 0
|
|
|
self.writerIndex = 0
|
|
|
self.plotterIndex = 0
|
|
|
self.voltageOutObj.copy(self.voltageInObj)
|
|
|
|
|
|
def addWriter(self,wrpath):
|
|
|
objWriter = VoltageWriter(self.voltageOutObj)
|
|
|
objWriter.setup(wrpath)
|
|
|
self.writerList.append(objWriter)
|
|
|
|
|
|
def addPlotter(self):
|
|
|
|
|
|
plotObj = Osciloscope(self.voltageOutObj,self.plotterIndex)
|
|
|
self.plotterList.append(plotObj)
|
|
|
|
|
|
def addIntegrator(self,N):
|
|
|
|
|
|
objCohInt = CoherentIntegrator(N)
|
|
|
self.integratorList.append(objCohInt)
|
|
|
|
|
|
def addDecoder(self,code,ncode,nbaud):
|
|
|
|
|
|
objDecoder = Decoder(code,ncode,nbaud)
|
|
|
self.decoderList.append(objDecoder)
|
|
|
|
|
|
def writeData(self,wrpath):
|
|
|
if self.voltageOutObj.flagNoData:
|
|
|
return 0
|
|
|
|
|
|
if len(self.writerList) <= self.writerIndex:
|
|
|
self.addWriter(wrpath)
|
|
|
|
|
|
self.writerList[self.writerIndex].putData()
|
|
|
|
|
|
# myWrObj = self.writerList[self.writerIndex]
|
|
|
# myWrObj.putData()
|
|
|
|
|
|
self.writerIndex += 1
|
|
|
|
|
|
def plotData(self,idProfile, type, xmin=None, xmax=None, ymin=None, ymax=None, winTitle=''):
|
|
|
if self.voltageOutObj.flagNoData:
|
|
|
return 0
|
|
|
|
|
|
if len(self.plotterList) <= self.plotterIndex:
|
|
|
self.addPlotter()
|
|
|
|
|
|
self.plotterList[self.plotterIndex].plotData(type=type, xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,winTitle=winTitle)
|
|
|
|
|
|
self.plotterIndex += 1
|
|
|
|
|
|
def integrator(self, N):
|
|
|
if self.voltageOutObj.flagNoData:
|
|
|
return 0
|
|
|
|
|
|
if len(self.integratorList) <= self.integratorIndex:
|
|
|
self.addIntegrator(N)
|
|
|
|
|
|
myCohIntObj = self.integratorList[self.integratorIndex]
|
|
|
myCohIntObj.exe(self.voltageOutObj.data)
|
|
|
|
|
|
if myCohIntObj.flag:
|
|
|
self.voltageOutObj.data = myCohIntObj.data
|
|
|
self.voltageOutObj.m_ProcessingHeader.coherentInt *= N
|
|
|
self.voltageOutObj.flagNoData = False
|
|
|
|
|
|
else:
|
|
|
self.voltageOutObj.flagNoData = True
|
|
|
|
|
|
self.integratorIndex += 1
|
|
|
|
|
|
def decoder(self,code=None,type = 0):
|
|
|
if self.voltageOutObj.flagNoData:
|
|
|
return 0
|
|
|
if code == None:
|
|
|
code = self.voltageOutObj.m_RadarControllerHeader.code
|
|
|
ncode, nbaud = code.shape
|
|
|
|
|
|
if len(self.decoderList) <= self.decoderIndex:
|
|
|
self.addDecoder(code,ncode,nbaud)
|
|
|
|
|
|
myDecodObj = self.decoderList[self.decoderIndex]
|
|
|
myDecodObj.exe(data=self.voltageOutObj.data,type=type)
|
|
|
|
|
|
if myDecodObj.flag:
|
|
|
self.voltageOutObj.data = myDecodObj.data
|
|
|
self.voltageOutObj.flagNoData = False
|
|
|
else:
|
|
|
self.voltageOutObj.flagNoData = True
|
|
|
|
|
|
self.decoderIndex += 1
|
|
|
|
|
|
def removeDC(self):
|
|
|
pass
|
|
|
|
|
|
def removeSignalInt(self):
|
|
|
pass
|
|
|
|
|
|
def selChannel(self):
|
|
|
pass
|
|
|
|
|
|
def selRange(self):
|
|
|
pass
|
|
|
|
|
|
def selProfiles(self):
|
|
|
pass
|
|
|
|
|
|
|
|
|
class Decoder:
|
|
|
def __init__(self,code, ncode, nbaud):
|
|
|
self.buffer = None
|
|
|
self.profCounter = 1
|
|
|
self.nCode = ncode
|
|
|
self.nBaud = nbaud
|
|
|
self.codeIndex = 0
|
|
|
self.code = code #this is a List
|
|
|
self.fft_code = None
|
|
|
self.flag = False
|
|
|
self.setCodeFft = False
|
|
|
|
|
|
def exe(self, data, ndata=None, type = 0):
|
|
|
if ndata == None: ndata = data.shape[1]
|
|
|
|
|
|
if type == 0:
|
|
|
self.convolutionInFreq(data,ndata)
|
|
|
|
|
|
if type == 1:
|
|
|
self.convolutionInTime(data, ndata)
|
|
|
|
|
|
def convolutionInFreq(self,data,ndata):
|
|
|
|
|
|
newcode = numpy.zeros(ndata)
|
|
|
newcode[0:self.nBaud] = self.code[self.codeIndex]
|
|
|
|
|
|
self.codeIndex += 1
|
|
|
|
|
|
fft_data = numpy.fft.fft(data, axis=1)
|
|
|
fft_code = numpy.conj(numpy.fft.fft(newcode))
|
|
|
fft_code = fft_code.reshape(1,len(fft_code))
|
|
|
|
|
|
conv = fft_data.copy()
|
|
|
conv.fill(0)
|
|
|
|
|
|
conv = fft_data*fft_code # This other way to calculate multiplication between bidimensional arrays
|
|
|
# for i in range(ndata):
|
|
|
# conv[i,:] = fft_data[i,:]*fft_code[i]
|
|
|
|
|
|
self.data = numpy.fft.ifft(conv,axis=1)
|
|
|
self.flag = True
|
|
|
|
|
|
if self.profCounter == self.nCode:
|
|
|
self.profCounter = 0
|
|
|
self.codeIndex = 0
|
|
|
|
|
|
self.profCounter += 1
|
|
|
|
|
|
def convolutionInTime(self, data, ndata):
|
|
|
|
|
|
nchannel = data.shape[1]
|
|
|
newcode = self.code[self.codeIndex]
|
|
|
self.codeIndex += 1
|
|
|
conv = data.copy()
|
|
|
for i in range(nchannel):
|
|
|
conv[i,:] = numpy.correlate(data[i,:], newcode, 'same')
|
|
|
|
|
|
self.data = conv
|
|
|
self.flag = True
|
|
|
|
|
|
if self.profCounter == self.nCode:
|
|
|
self.profCounter = 0
|
|
|
self.codeIndex = 0
|
|
|
|
|
|
self.profCounter += 1
|
|
|
|
|
|
|
|
|
class CoherentIntegrator:
|
|
|
def __init__(self, N):
|
|
|
self.profCounter = 1
|
|
|
self.data = None
|
|
|
self.buffer = None
|
|
|
self.flag = False
|
|
|
self.nCohInt = N
|
|
|
|
|
|
def exe(self,data):
|
|
|
|
|
|
if self.buffer == None:
|
|
|
self.buffer = data
|
|
|
else:
|
|
|
self.buffer = self.buffer + data
|
|
|
|
|
|
if self.profCounter == self.nCohInt:
|
|
|
self.data = self.buffer
|
|
|
self.buffer = None
|
|
|
self.profCounter = 0
|
|
|
self.flag = True
|
|
|
else:
|
|
|
self.flag = False
|
|
|
|
|
|
self.profCounter += 1
|
|
|
|
|
|
|
|
|
|
