jrodata.py
506 lines
| 11.8 KiB
| text/x-python
|
PythonLexer
|
r174 | ''' | ||
$Author: murco $ | ||||
$Id: JROData.py 173 2012-11-20 15:06:21Z murco $ | ||||
''' | ||||
import os, sys | ||||
import copy | ||||
import numpy | ||||
|
r178 | from jroheaderIO import SystemHeader, RadarControllerHeader | ||
|
r174 | |||
|
r199 | def hildebrand_sekhon(data, navg): | ||
""" | ||||
This method is for the objective determination of de noise level in Doppler spectra. This | ||||
implementation technique is based on the fact that the standard deviation of the spectral | ||||
densities is equal to the mean spectral density for white Gaussian noise | ||||
Inputs: | ||||
Data : heights | ||||
navg : numbers of averages | ||||
Return: | ||||
-1 : any error | ||||
anoise : noise's level | ||||
""" | ||||
|
r201 | dataflat = data.copy().reshape(-1) | ||
|
r199 | dataflat.sort() | ||
npts = dataflat.size #numbers of points of the data | ||||
if npts < 32: | ||||
print "error in noise - requires at least 32 points" | ||||
return -1.0 | ||||
dataflat2 = numpy.power(dataflat,2) | ||||
cs = numpy.cumsum(dataflat) | ||||
cs2 = numpy.cumsum(dataflat2) | ||||
# data sorted in ascending order | ||||
nmin = int((npts + 7.)/8) | ||||
for i in range(nmin, npts): | ||||
s = cs[i] | ||||
s2 = cs2[i] | ||||
p = s / float(i); | ||||
p2 = p**2; | ||||
q = s2 / float(i) - p2; | ||||
leftc = p2; | ||||
rightc = q * float(navg); | ||||
R2 = leftc/rightc | ||||
# Signal detect: R2 < 1 (R2 = leftc/rightc) | ||||
if R2 < 1: | ||||
npts_noise = i | ||||
break | ||||
anoise = numpy.average(dataflat[0:npts_noise]) | ||||
return anoise; | ||||
|
r201 | def sorting_bruce(data, navg): | ||
data = data.copy() | ||||
sortdata = numpy.sort(data) | ||||
lenOfData = len(data) | ||||
|
r199 | nums_min = lenOfData/10 | ||
if (lenOfData/10) > 0: | ||||
nums_min = lenOfData/10 | ||||
else: | ||||
nums_min = 0 | ||||
rtest = 1.0 + 1.0/navg | ||||
sum = 0. | ||||
sumq = 0. | ||||
j = 0 | ||||
cont = 1 | ||||
while((cont==1)and(j<lenOfData)): | ||||
sum += sortdata[j] | ||||
sumq += sortdata[j]**2 | ||||
j += 1 | ||||
if j > nums_min: | ||||
if ((sumq*j) <= (rtest*sum**2)): | ||||
lnoise = sum / j | ||||
else: | ||||
j = j - 1 | ||||
sum = sum - sordata[j] | ||||
sumq = sumq - sordata[j]**2 | ||||
cont = 0 | ||||
if j == nums_min: | ||||
lnoise = sum /j | ||||
return lnoise | ||||
|
r174 | class JROData: | ||
# m_BasicHeader = BasicHeader() | ||||
# m_ProcessingHeader = ProcessingHeader() | ||||
systemHeaderObj = SystemHeader() | ||||
radarControllerHeaderObj = RadarControllerHeader() | ||||
# data = None | ||||
type = None | ||||
dtype = None | ||||
|
r200 | # nChannels = None | ||
|
r174 | |||
|
r207 | # nHeights = None | ||
|
r174 | |||
nProfiles = None | ||||
heightList = None | ||||
channelList = None | ||||
flagNoData = True | ||||
flagTimeBlock = False | ||||
utctime = None | ||||
blocksize = None | ||||
nCode = None | ||||
nBaud = None | ||||
code = None | ||||
flagDecodeData = True #asumo q la data esta decodificada | ||||
flagDeflipData = True #asumo q la data esta sin flip | ||||
flagShiftFFT = False | ||||
ippSeconds = None | ||||
timeInterval = None | ||||
|
r199 | |||
nCohInt = None | ||||
noise = None | ||||
|
r201 | |||
#Speed of ligth | ||||
C = 3e8 | ||||
frequency = 49.92e6 | ||||
|
r174 | |||
def __init__(self): | ||||
raise ValueError, "This class has not been implemented" | ||||
def copy(self, inputObj=None): | ||||
if inputObj == None: | ||||
return copy.deepcopy(self) | ||||
for key in inputObj.__dict__.keys(): | ||||
self.__dict__[key] = inputObj.__dict__[key] | ||||
def deepcopy(self): | ||||
return copy.deepcopy(self) | ||||
|
r185 | def isEmpty(self): | ||
|
r189 | return self.flagNoData | ||
|
r185 | |||
|
r207 | def getNoise(self): | ||
raise ValueError, "Not implemented" | ||||
|
r200 | def getNChannels(self): | ||
return len(self.channelList) | ||||
def getChannelIndexList(self): | ||||
return range(self.nChannels) | ||||
|
r207 | def getNHeights(self): | ||
return len(self.heightList) | ||||
def getHeiRange(self, extrapoints=0): | ||||
heis = self.heightList | ||||
# deltah = self.heightList[1] - self.heightList[0] | ||||
# | ||||
# heis.append(self.heightList[-1]) | ||||
return heis | ||||
def getDatatime(self): | ||||
datatime = [] | ||||
datatime.append(self.utctime) | ||||
|
r220 | datatime.append(self.utctime + self.timeInterval) | ||
|
r207 | |||
datatime = numpy.array(datatime) | ||||
return datatime | ||||
def getFmax(self): | ||||
PRF = 1./(self.ippSeconds * self.nCohInt) | ||||
fmax = PRF/2. | ||||
return fmax | ||||
def getVmax(self): | ||||
_lambda = self.C/self.frequency | ||||
vmax = self.getFmax() * _lambda / 2. | ||||
return vmax | ||||
|
r200 | nChannels = property(getNChannels, "I'm the 'nChannel' property.") | ||
channelIndexList = property(getChannelIndexList, "I'm the 'channelIndexList' property.") | ||||
|
r207 | nHeights = property(getNHeights, "I'm the 'nHeights' property.") | ||
noise = property(getNoise, "I'm the 'nHeights' property.") | ||||
|
r174 | class Voltage(JROData): | ||
#data es un numpy array de 2 dmensiones (canales, alturas) | ||||
data = None | ||||
def __init__(self): | ||||
''' | ||||
Constructor | ||||
''' | ||||
self.radarControllerHeaderObj = RadarControllerHeader() | ||||
self.systemHeaderObj = SystemHeader() | ||||
self.type = "Voltage" | ||||
self.data = None | ||||
self.dtype = None | ||||
|
r200 | # self.nChannels = 0 | ||
|
r174 | |||
|
r207 | # self.nHeights = 0 | ||
|
r174 | |||
self.nProfiles = None | ||||
self.heightList = None | ||||
self.channelList = None | ||||
|
r200 | # self.channelIndexList = None | ||
|
r174 | |||
self.flagNoData = True | ||||
self.flagTimeBlock = False | ||||
self.utctime = None | ||||
self.nCohInt = None | ||||
self.blocksize = None | ||||
|
r199 | |||
def getNoisebyHildebrand(self): | ||||
""" | ||||
Determino el nivel de ruido usando el metodo Hildebrand-Sekhon | ||||
Return: | ||||
noiselevel | ||||
""" | ||||
|
r174 | |||
|
r199 | for channel in range(self.nChannels): | ||
daux = self.data_spc[channel,:,:] | ||||
self.noise[channel] = hildebrand_sekhon(daux, self.nCohInt) | ||||
return self.noise | ||||
def getNoise(self, type = 1): | ||||
self.noise = numpy.zeros(self.nChannels) | ||||
if type == 1: | ||||
noise = self.getNoisebyHildebrand() | ||||
return 10*numpy.log10(noise) | ||||
|
r174 | class Spectra(JROData): | ||
#data es un numpy array de 2 dmensiones (canales, perfiles, alturas) | ||||
data_spc = None | ||||
#data es un numpy array de 2 dmensiones (canales, pares, alturas) | ||||
data_cspc = None | ||||
#data es un numpy array de 2 dmensiones (canales, alturas) | ||||
data_dc = None | ||||
nFFTPoints = None | ||||
nPairs = None | ||||
pairsList = None | ||||
nIncohInt = None | ||||
wavelength = None #Necesario para cacular el rango de velocidad desde la frecuencia | ||||
nCohInt = None #se requiere para determinar el valor de timeInterval | ||||
def __init__(self): | ||||
''' | ||||
Constructor | ||||
''' | ||||
self.radarControllerHeaderObj = RadarControllerHeader() | ||||
self.systemHeaderObj = SystemHeader() | ||||
self.type = "Spectra" | ||||
# self.data = None | ||||
self.dtype = None | ||||
|
r200 | # self.nChannels = 0 | ||
|
r174 | |||
|
r207 | # self.nHeights = 0 | ||
|
r174 | |||
self.nProfiles = None | ||||
self.heightList = None | ||||
self.channelList = None | ||||
|
r200 | # self.channelIndexList = None | ||
|
r174 | |||
self.flagNoData = True | ||||
self.flagTimeBlock = False | ||||
self.utctime = None | ||||
|
r199 | self.nCohInt = None | ||
|
r174 | self.nIncohInt = None | ||
self.blocksize = None | ||||
self.nFFTPoints = None | ||||
self.wavelength = None | ||||
|
r199 | |||
def getNoisebyHildebrand(self): | ||||
""" | ||||
Determino el nivel de ruido usando el metodo Hildebrand-Sekhon | ||||
Return: | ||||
noiselevel | ||||
""" | ||||
for channel in range(self.nChannels): | ||||
daux = self.data_spc[channel,:,:] | ||||
self.noise[channel] = hildebrand_sekhon(daux, self.nIncohInt) | ||||
return self.noise | ||||
def getNoisebyWindow(self, heiIndexMin=0, heiIndexMax=-1, freqIndexMin=0, freqIndexMax=-1): | ||||
""" | ||||
Determina el ruido del canal utilizando la ventana indicada con las coordenadas: | ||||
(heiIndexMIn, freqIndexMin) hasta (heiIndexMax, freqIndexMAx) | ||||
Inputs: | ||||
heiIndexMin: Limite inferior del eje de alturas | ||||
heiIndexMax: Limite superior del eje de alturas | ||||
freqIndexMin: Limite inferior del eje de frecuencia | ||||
freqIndexMax: Limite supoerior del eje de frecuencia | ||||
""" | ||||
data = self.data_spc[:, heiIndexMin:heiIndexMax, freqIndexMin:freqIndexMax] | ||||
for channel in range(self.nChannels): | ||||
daux = data[channel,:,:] | ||||
self.noise[channel] = numpy.average(daux) | ||||
return self.noise | ||||
def getNoisebySort(self): | ||||
for channel in range(self.nChannels): | ||||
daux = self.data_spc[channel,:,:] | ||||
self.noise[channel] = sorting_bruce(daux, self.nIncohInt) | ||||
return self.noise | ||||
def getNoise(self, type = 1): | ||||
self.noise = numpy.zeros(self.nChannels) | ||||
if type == 1: | ||||
noise = self.getNoisebyHildebrand() | ||||
if type == 2: | ||||
noise = self.getNoisebySort() | ||||
if type == 3: | ||||
noise = self.getNoisebyWindow() | ||||
|
r174 | |||
|
r199 | return 10*numpy.log10(noise) | ||
|
r215 | |||
def getFreqRange(self, extrapoints=0): | ||||
delfreq = 2 * self.getFmax() / self.nFFTPoints | ||||
freqrange = deltafreqs*(numpy.arange(self.nFFTPoints+extrapoints)-self.nFFTPoints/2.) - deltafreq/2 | ||||
return freqrange | ||||
def getVelRange(self, extrapoints=0): | ||||
deltav = 2 * self.getVmax() / self.nFFTPoints | ||||
velrange = deltav*(numpy.arange(self.nFFTPoints+extrapoints)-self.nFFTPoints/2.) - deltav/2 | ||||
return velrange | ||||
def getNPairs(self): | ||||
return len(self.pairsList) | ||||
def getPairsIndexList(self): | ||||
return range(self.nPairs) | ||||
nPairs = property(getNPairs, "I'm the 'nPairs' property.") | ||||
pairsIndexList = property(getPairsIndexList, "I'm the 'pairsIndexList' property.") | ||||
|
r174 | |||
class SpectraHeis(JROData): | ||||
data_spc = None | ||||
data_cspc = None | ||||
data_dc = None | ||||
nFFTPoints = None | ||||
nPairs = None | ||||
pairsList = None | ||||
nIncohInt = None | ||||
def __init__(self): | ||||
self.radarControllerHeaderObj = RadarControllerHeader() | ||||
self.systemHeaderObj = SystemHeader() | ||||
self.type = "SpectraHeis" | ||||
self.dtype = None | ||||
|
r200 | # self.nChannels = 0 | ||
|
r174 | |||
|
r207 | # self.nHeights = 0 | ||
|
r174 | |||
self.nProfiles = None | ||||
self.heightList = None | ||||
self.channelList = None | ||||
|
r200 | # self.channelIndexList = None | ||
|
r174 | |||
self.flagNoData = True | ||||
self.flagTimeBlock = False | ||||
self.nPairs = 0 | ||||
self.utctime = None | ||||
self.blocksize = None | ||||