|
|
'''
|
|
|
|
|
|
$Author$
|
|
|
$Id$
|
|
|
'''
|
|
|
|
|
|
import os
|
|
|
import sys
|
|
|
import numpy
|
|
|
import datetime
|
|
|
import time
|
|
|
|
|
|
path = os.path.split(os.getcwd())[0]
|
|
|
sys.path.append(path)
|
|
|
|
|
|
from Data.JROData import Voltage
|
|
|
from IO.VoltageIO import VoltageWriter
|
|
|
#from Graphics.schainPlotTypes import ScopeFigure, RTIFigure
|
|
|
|
|
|
class VoltageProcessor:
|
|
|
|
|
|
dataInObj = None
|
|
|
dataOutObj = None
|
|
|
integratorObjIndex = None
|
|
|
writerObjIndex = None
|
|
|
integratorObjList = None
|
|
|
writerObjList = None
|
|
|
|
|
|
def __init__(self):
|
|
|
self.integratorObjIndex = None
|
|
|
self.writerObjIndex = None
|
|
|
self.plotObjIndex = None
|
|
|
self.integratorObjList = []
|
|
|
self.writerObjList = []
|
|
|
self.plotObjList = []
|
|
|
|
|
|
def setup(self,dataInObj=None,dataOutObj=None):
|
|
|
self.dataInObj = dataInObj
|
|
|
|
|
|
if self.dataOutObj == None:
|
|
|
dataOutObj = Voltage()
|
|
|
|
|
|
self.dataOutObj = dataOutObj
|
|
|
|
|
|
return self.dataOutObj
|
|
|
|
|
|
def init(self):
|
|
|
self.integratorObjIndex = 0
|
|
|
self.writerObjIndex = 0
|
|
|
self.plotObjIndex = 0
|
|
|
|
|
|
if not(self.dataInObj.flagNoData):
|
|
|
self.dataOutObj.copy(self.dataInObj)
|
|
|
# No necesita copiar en cada init() los atributos de dataInObj
|
|
|
# la copia deberia hacerse por cada nuevo bloque de datos
|
|
|
|
|
|
def addRti(self, idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile):
|
|
|
rtiObj = RTIFigure(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
|
|
|
self.plotObjList.append(rtiObj)
|
|
|
|
|
|
def plotRti(self, idfigure=None,
|
|
|
starttime=None,
|
|
|
endtime=None,
|
|
|
rangemin=None,
|
|
|
rangemax=None,
|
|
|
minvalue=None,
|
|
|
maxvalue=None,
|
|
|
wintitle='',
|
|
|
driver='plplot',
|
|
|
colormap='br_greeen',
|
|
|
colorbar=True,
|
|
|
showprofile=False,
|
|
|
xrangestep=None,
|
|
|
save=False,
|
|
|
gpath=None,
|
|
|
ratio=1,
|
|
|
channelList=None):
|
|
|
|
|
|
if self.dataOutObj.flagNoData:
|
|
|
return 0
|
|
|
|
|
|
if channelList == None:
|
|
|
channelList = self.dataOutObj.channelList
|
|
|
|
|
|
nframes = len(channelList)
|
|
|
|
|
|
if len(self.plotObjList) <= self.plotObjIndex:
|
|
|
self.addRti(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
|
|
|
|
|
|
data = self.dataOutObj.data[channelList,:] * numpy.conjugate(self.dataOutObj.data[channelList,:])
|
|
|
data = 10*numpy.log10(data.real)
|
|
|
|
|
|
currenttime = self.dataOutObj.utctime - time.timezone
|
|
|
|
|
|
range = self.dataOutObj.heightList
|
|
|
|
|
|
thisdatetime = datetime.datetime.fromtimestamp(self.dataOutObj.utctime)
|
|
|
dateTime = "%s"%(thisdatetime.strftime("%d-%b-%Y %H:%M:%S"))
|
|
|
date = "%s"%(thisdatetime.strftime("%d-%b-%Y"))
|
|
|
|
|
|
figuretitle = "RTI Plot Radar Data" #+ date
|
|
|
|
|
|
plotObj = self.plotObjList[self.plotObjIndex]
|
|
|
|
|
|
cleardata = False
|
|
|
|
|
|
deltax = self.dataOutObj.timeInterval
|
|
|
|
|
|
plotObj.plotPcolor(data=data,
|
|
|
x=currenttime,
|
|
|
y=range,
|
|
|
channelList=channelList,
|
|
|
xmin=starttime,
|
|
|
xmax=endtime,
|
|
|
ymin=rangemin,
|
|
|
ymax=rangemax,
|
|
|
minvalue=minvalue,
|
|
|
maxvalue=maxvalue,
|
|
|
figuretitle=figuretitle,
|
|
|
xrangestep=xrangestep,
|
|
|
deltax=deltax,
|
|
|
save=save,
|
|
|
gpath=gpath,
|
|
|
ratio=ratio,
|
|
|
cleardata=cleardata
|
|
|
)
|
|
|
|
|
|
|
|
|
self.plotObjIndex += 1
|
|
|
|
|
|
def addScope(self, idfigure, nframes, wintitle, driver):
|
|
|
if idfigure==None:
|
|
|
idfigure = self.plotObjIndex
|
|
|
|
|
|
scopeObj = ScopeFigure(idfigure, nframes, wintitle, driver)
|
|
|
self.plotObjList.append(scopeObj)
|
|
|
|
|
|
def plotScope(self,
|
|
|
idfigure=None,
|
|
|
minvalue=None,
|
|
|
maxvalue=None,
|
|
|
xmin=None,
|
|
|
xmax=None,
|
|
|
wintitle='',
|
|
|
driver='plplot',
|
|
|
save=False,
|
|
|
gpath=None,
|
|
|
ratio=1,
|
|
|
type="power"):
|
|
|
|
|
|
if self.dataOutObj.flagNoData:
|
|
|
return 0
|
|
|
|
|
|
nframes = len(self.dataOutObj.channelList)
|
|
|
|
|
|
if len(self.plotObjList) <= self.plotObjIndex:
|
|
|
self.addScope(idfigure, nframes, wintitle, driver)
|
|
|
|
|
|
|
|
|
if type=="power":
|
|
|
data1D = self.dataOutObj.data * numpy.conjugate(self.dataOutObj.data)
|
|
|
data1D = data1D.real
|
|
|
|
|
|
if type =="iq":
|
|
|
data1D = self.dataOutObj.data
|
|
|
|
|
|
thisDatetime = datetime.datetime.fromtimestamp(self.dataOutObj.utctime)
|
|
|
|
|
|
dateTime = "%s"%(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
|
|
|
date = "%s"%(thisDatetime.strftime("%d-%b-%Y"))
|
|
|
|
|
|
figuretitle = "Scope Plot Radar Data: " + date
|
|
|
|
|
|
plotObj = self.plotObjList[self.plotObjIndex]
|
|
|
|
|
|
plotObj.plot1DArray(data1D=data1D,
|
|
|
x=self.dataOutObj.heightList,
|
|
|
channelList=self.dataOutObj.channelList,
|
|
|
xmin=xmin,
|
|
|
xmax=xmax,
|
|
|
minvalue=minvalue,
|
|
|
maxvalue=maxvalue,
|
|
|
figuretitle=figuretitle,
|
|
|
save=save,
|
|
|
gpath=gpath,
|
|
|
ratio=ratio)
|
|
|
|
|
|
|
|
|
self.plotObjIndex += 1
|
|
|
|
|
|
|
|
|
def addIntegrator(self, *args):
|
|
|
objCohInt = CoherentIntegrator(*args)
|
|
|
self.integratorObjList.append(objCohInt)
|
|
|
|
|
|
def addWriter(self, *args):
|
|
|
writerObj = VoltageWriter(self.dataOutObj)
|
|
|
writerObj.setup(*args)
|
|
|
self.writerObjList.append(writerObj)
|
|
|
|
|
|
def writeData(self, wrpath, blocksPerFile, profilesPerBlock):
|
|
|
|
|
|
if self.dataOutObj.flagNoData:
|
|
|
return 0
|
|
|
|
|
|
if len(self.writerObjList) <= self.writerObjIndex:
|
|
|
self.addWriter(wrpath, blocksPerFile, profilesPerBlock)
|
|
|
|
|
|
self.writerObjList[self.writerObjIndex].putData()
|
|
|
|
|
|
self.writerObjIndex += 1
|
|
|
|
|
|
def integrator(self, nCohInt=None, timeInterval=None, overlapping=False):
|
|
|
|
|
|
if self.dataOutObj.flagNoData:
|
|
|
return 0
|
|
|
|
|
|
if len(self.integratorObjList) <= self.integratorObjIndex:
|
|
|
self.addIntegrator(nCohInt, timeInterval, overlapping)
|
|
|
|
|
|
myCohIntObj = self.integratorObjList[self.integratorObjIndex]
|
|
|
myCohIntObj.exe(data = self.dataOutObj.data, datatime=self.dataOutObj.utctime)
|
|
|
|
|
|
# self.dataOutObj.timeInterval *= nCohInt
|
|
|
self.dataOutObj.flagNoData = True
|
|
|
|
|
|
if myCohIntObj.isReady:
|
|
|
self.dataOutObj.data = myCohIntObj.data
|
|
|
self.dataOutObj.timeInterval *= myCohIntObj.nCohInt
|
|
|
self.dataOutObj.nCohInt = myCohIntObj.nCohInt * self.dataInObj.nCohInt
|
|
|
self.dataOutObj.utctime = myCohIntObj.firstdatatime
|
|
|
self.dataOutObj.flagNoData = False
|
|
|
|
|
|
def selectChannels(self, channelList):
|
|
|
|
|
|
self.selectChannelsByIndex(channelList)
|
|
|
|
|
|
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.dataOutObj.data
|
|
|
self.dataOutObj.channelIndexList
|
|
|
self.dataOutObj.nChannels
|
|
|
self.dataOutObj.m_ProcessingHeader.totalSpectra
|
|
|
self.dataOutObj.systemHeaderObj.numChannels
|
|
|
self.dataOutObj.m_ProcessingHeader.blockSize
|
|
|
|
|
|
Return:
|
|
|
None
|
|
|
"""
|
|
|
if self.dataOutObj.flagNoData:
|
|
|
return 0
|
|
|
|
|
|
for channel in channelIndexList:
|
|
|
if channel not in self.dataOutObj.channelIndexList:
|
|
|
raise ValueError, "The value %d in channelIndexList is not valid" %channel
|
|
|
|
|
|
nChannels = len(channelIndexList)
|
|
|
|
|
|
data = self.dataOutObj.data[channelIndexList,:]
|
|
|
|
|
|
self.dataOutObj.data = data
|
|
|
self.dataOutObj.channelIndexList = channelIndexList
|
|
|
self.dataOutObj.channelList = [self.dataOutObj.channelList[i] for i in channelIndexList]
|
|
|
self.dataOutObj.nChannels = nChannels
|
|
|
|
|
|
return 1
|
|
|
|
|
|
class CoherentIntegrator:
|
|
|
|
|
|
|
|
|
__profIndex = 0
|
|
|
__withOverapping = False
|
|
|
|
|
|
__isByTime = False
|
|
|
__initime = None
|
|
|
__integrationtime = None
|
|
|
|
|
|
__buffer = None
|
|
|
|
|
|
isReady = False
|
|
|
nCohInt = None
|
|
|
firstdatatime = None
|
|
|
|
|
|
def __init__(self, nCohInt=None, timeInterval=None, overlapping=False):
|
|
|
|
|
|
"""
|
|
|
Set the parameters of the integration class.
|
|
|
|
|
|
Inputs:
|
|
|
|
|
|
nCohInt : Number of coherent integrations
|
|
|
timeInterval : Time of integration. If nCohInt is selected this parameter does not work
|
|
|
overlapping :
|
|
|
|
|
|
"""
|
|
|
|
|
|
self.__buffer = None
|
|
|
self.isReady = False
|
|
|
|
|
|
if nCohInt == None and timeInterval == None:
|
|
|
raise ValueError, "nCohInt or timeInterval should be specified ..."
|
|
|
|
|
|
if nCohInt != None:
|
|
|
self.nCohInt = nCohInt
|
|
|
self.__isByTime = False
|
|
|
else:
|
|
|
self.__integrationtime = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
|
|
|
self.__isByTime = True
|
|
|
|
|
|
if overlapping:
|
|
|
self.__withOverapping = True
|
|
|
self.__buffer = None
|
|
|
else:
|
|
|
self.__withOverapping = False
|
|
|
self.__buffer = 0
|
|
|
|
|
|
self.__profIndex = 0
|
|
|
firstdatatime = None
|
|
|
|
|
|
def putData(self, data):
|
|
|
|
|
|
"""
|
|
|
Add a profile to the __buffer and increase in one the __profileIndex
|
|
|
|
|
|
"""
|
|
|
if not self.__withOverapping:
|
|
|
self.__buffer += data
|
|
|
self.__profIndex += 1
|
|
|
return
|
|
|
|
|
|
#Overlapping data
|
|
|
nChannels, nHeis = data.shape
|
|
|
data = numpy.reshape(data, (1, nChannels, nHeis))
|
|
|
|
|
|
if self.__buffer == None:
|
|
|
self.__buffer = data
|
|
|
self.__profIndex += 1
|
|
|
return
|
|
|
|
|
|
if self.__profIndex < self.nCohInt:
|
|
|
self.__buffer = numpy.vstack((self.__buffer, data))
|
|
|
self.__profIndex += 1
|
|
|
return
|
|
|
|
|
|
self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
|
|
|
self.__buffer[self.nCohInt-1] = data
|
|
|
#self.__profIndex = self.nCohInt
|
|
|
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
|
|
|
nCohInt = self.__profIndex
|
|
|
|
|
|
self.__buffer = 0
|
|
|
self.__profIndex = 0
|
|
|
|
|
|
return data, nCohInt
|
|
|
|
|
|
#Overlapping data
|
|
|
data = numpy.sum(self.__buffer, axis=0)
|
|
|
nCohInt = self.__profIndex
|
|
|
|
|
|
return data, nCohInt
|
|
|
|
|
|
def byProfiles(self, data):
|
|
|
|
|
|
self.isReady = False
|
|
|
avg_data = None
|
|
|
|
|
|
self.putData(data)
|
|
|
|
|
|
if self.__profIndex == self.nCohInt:
|
|
|
avg_data, nCohInt = self.pushData()
|
|
|
self.isReady = True
|
|
|
|
|
|
return avg_data
|
|
|
|
|
|
def byTime(self, data, datatime):
|
|
|
|
|
|
self.isReady = False
|
|
|
avg_data = None
|
|
|
|
|
|
if self.__initime == None:
|
|
|
self.__initime = datatime
|
|
|
|
|
|
self.putData(data)
|
|
|
|
|
|
if (datatime - self.__initime) >= self.__integrationtime:
|
|
|
avg_data, nCohInt = self.pushData()
|
|
|
self.nCohInt = nCohInt
|
|
|
self.isReady = True
|
|
|
|
|
|
return avg_data
|
|
|
|
|
|
def exe(self, data, datatime=None):
|
|
|
|
|
|
|
|
|
if self.firstdatatime == None or self.isReady:
|
|
|
self.firstdatatime = datatime
|
|
|
|
|
|
if not self.__isByTime:
|
|
|
avg_data = self.byProfiles(data)
|
|
|
else:
|
|
|
avg_data = self.byTime(data, datatime)
|
|
|
|
|
|
self.data = avg_data
|
|
|
|
|
|
|
|
|
|
|
|
return avg_data
|
|
|
|
|
|
|
|
|
|
