|
|
#primer windprofiler
|
|
|
class WindProfiler(Operation):
|
|
|
|
|
|
__isConfig = False
|
|
|
|
|
|
__initime = None
|
|
|
__lastdatatime = None
|
|
|
__integrationtime = None
|
|
|
|
|
|
__buffer = None
|
|
|
|
|
|
__dataReady = False
|
|
|
|
|
|
__firstdata = None
|
|
|
|
|
|
n = None
|
|
|
|
|
|
def __init__(self):
|
|
|
Operation.__init__(self)
|
|
|
|
|
|
def __calculateCosDir(self, elev, azim):
|
|
|
zen = (90 - elev)*numpy.pi/180
|
|
|
azim = azim*numpy.pi/180
|
|
|
cosDirX = numpy.sqrt((1-numpy.cos(zen)**2)/((1+numpy.tan(azim)**2)))
|
|
|
cosDirY = numpy.sqrt(1-numpy.cos(zen)**2-cosDirX**2)
|
|
|
|
|
|
signX = numpy.sign(numpy.cos(azim))
|
|
|
signY = numpy.sign(numpy.sin(azim))
|
|
|
|
|
|
cosDirX = numpy.copysign(cosDirX, signX)
|
|
|
cosDirY = numpy.copysign(cosDirY, signY)
|
|
|
return cosDirX, cosDirY
|
|
|
|
|
|
def __calculateAngles(self, theta_x, theta_y, azimuth):
|
|
|
|
|
|
dir_cosw = numpy.sqrt(1-theta_x**2-theta_y**2)
|
|
|
zenith_arr = numpy.arccos(dir_cosw)
|
|
|
azimuth_arr = numpy.arctan2(theta_x,theta_y) + azimuth*math.pi/180
|
|
|
|
|
|
dir_cosu = numpy.sin(azimuth_arr)*numpy.sin(zenith_arr)
|
|
|
dir_cosv = numpy.cos(azimuth_arr)*numpy.sin(zenith_arr)
|
|
|
|
|
|
return azimuth_arr, zenith_arr, dir_cosu, dir_cosv, dir_cosw
|
|
|
|
|
|
def __calculateMatA(self, dir_cosu, dir_cosv, dir_cosw, horOnly):
|
|
|
|
|
|
if horOnly:
|
|
|
A = numpy.c_[dir_cosu,dir_cosv]
|
|
|
else:
|
|
|
A = numpy.c_[dir_cosu,dir_cosv,dir_cosw]
|
|
|
A = numpy.asmatrix(A)
|
|
|
A1 = numpy.linalg.inv(A.transpose()*A)*A.transpose()
|
|
|
|
|
|
return A1
|
|
|
|
|
|
def __correctValues(self, heiRang, phi, velRadial, SNR):
|
|
|
listPhi = phi.tolist()
|
|
|
maxid = listPhi.index(max(listPhi))
|
|
|
minid = listPhi.index(min(listPhi))
|
|
|
|
|
|
rango = list(range(len(phi)))
|
|
|
|
|
|
heiRang1 = heiRang*math.cos(phi[maxid])
|
|
|
heiRangAux = heiRang*math.cos(phi[minid])
|
|
|
indOut = (heiRang1 < heiRangAux[0]).nonzero()
|
|
|
heiRang1 = numpy.delete(heiRang1,indOut)
|
|
|
|
|
|
velRadial1 = numpy.zeros([len(phi),len(heiRang1)])
|
|
|
SNR1 = numpy.zeros([len(phi),len(heiRang1)])
|
|
|
|
|
|
for i in rango:
|
|
|
x = heiRang*math.cos(phi[i])
|
|
|
y1 = velRadial[i,:]
|
|
|
f1 = interpolate.interp1d(x,y1,kind = 'cubic')
|
|
|
|
|
|
x1 = heiRang1
|
|
|
y11 = f1(x1)
|
|
|
|
|
|
y2 = SNR[i,:]
|
|
|
f2 = interpolate.interp1d(x,y2,kind = 'cubic')
|
|
|
y21 = f2(x1)
|
|
|
|
|
|
velRadial1[i,:] = y11
|
|
|
SNR1[i,:] = y21
|
|
|
|
|
|
return heiRang1, velRadial1, SNR1
|
|
|
|
|
|
def __calculateVelUVW(self, A, velRadial):
|
|
|
|
|
|
#Operacion Matricial
|
|
|
velUVW = numpy.zeros((A.shape[0],velRadial.shape[1]))
|
|
|
velUVW[:,:] = numpy.dot(A,velRadial)
|
|
|
|
|
|
|
|
|
return velUVW
|
|
|
|
|
|
def techniqueDBS(self, kwargs):
|
|
|
"""
|
|
|
Function that implements Doppler Beam Swinging (DBS) technique.
|
|
|
|
|
|
Input: Radial velocities, Direction cosines (x and y) of the Beam, Antenna azimuth,
|
|
|
Direction correction (if necessary), Ranges and SNR
|
|
|
|
|
|
Output: Winds estimation (Zonal, Meridional and Vertical)
|
|
|
|
|
|
Parameters affected: Winds, height range, SNR
|
|
|
"""
|
|
|
velRadial0 = kwargs['velRadial']
|
|
|
heiRang = kwargs['heightList']
|
|
|
SNR0 = kwargs['SNR']
|
|
|
|
|
|
if 'dirCosx' in kwargs and 'dirCosy' in kwargs:
|
|
|
theta_x = numpy.array(kwargs['dirCosx'])
|
|
|
theta_y = numpy.array(kwargs['dirCosy'])
|
|
|
else:
|
|
|
elev = numpy.array(kwargs['elevation'])
|
|
|
azim = numpy.array(kwargs['azimuth'])
|
|
|
theta_x, theta_y = self.__calculateCosDir(elev, azim)
|
|
|
azimuth = kwargs['correctAzimuth']
|
|
|
if 'horizontalOnly' in kwargs:
|
|
|
horizontalOnly = kwargs['horizontalOnly']
|
|
|
else: horizontalOnly = False
|
|
|
if 'correctFactor' in kwargs:
|
|
|
correctFactor = kwargs['correctFactor']
|
|
|
else: correctFactor = 1
|
|
|
if 'channelList' in kwargs:
|
|
|
channelList = kwargs['channelList']
|
|
|
if len(channelList) == 2:
|
|
|
horizontalOnly = True
|
|
|
arrayChannel = numpy.array(channelList)
|
|
|
param = param[arrayChannel,:,:]
|
|
|
theta_x = theta_x[arrayChannel]
|
|
|
theta_y = theta_y[arrayChannel]
|
|
|
|
|
|
azimuth_arr, zenith_arr, dir_cosu, dir_cosv, dir_cosw = self.__calculateAngles(theta_x, theta_y, azimuth)
|
|
|
heiRang1, velRadial1, SNR1 = self.__correctValues(heiRang, zenith_arr, correctFactor*velRadial0, SNR0)
|
|
|
A = self.__calculateMatA(dir_cosu, dir_cosv, dir_cosw, horizontalOnly)
|
|
|
|
|
|
#Calculo de Componentes de la velocidad con DBS
|
|
|
winds = self.__calculateVelUVW(A,velRadial1)
|
|
|
|
|
|
return winds, heiRang1, SNR1
|
|
|
|
|
|
def __calculateDistance(self, posx, posy, pairs_ccf, azimuth = None):
|
|
|
|
|
|
nPairs = len(pairs_ccf)
|
|
|
posx = numpy.asarray(posx)
|
|
|
posy = numpy.asarray(posy)
|
|
|
|
|
|
#Rotacion Inversa para alinear con el azimuth
|
|
|
if azimuth!= None:
|
|
|
azimuth = azimuth*math.pi/180
|
|
|
posx1 = posx*math.cos(azimuth) + posy*math.sin(azimuth)
|
|
|
posy1 = -posx*math.sin(azimuth) + posy*math.cos(azimuth)
|
|
|
else:
|
|
|
posx1 = posx
|
|
|
posy1 = posy
|
|
|
|
|
|
#Calculo de Distancias
|
|
|
distx = numpy.zeros(nPairs)
|
|
|
disty = numpy.zeros(nPairs)
|
|
|
dist = numpy.zeros(nPairs)
|
|
|
ang = numpy.zeros(nPairs)
|
|
|
|
|
|
for i in range(nPairs):
|
|
|
distx[i] = posx1[pairs_ccf[i][1]] - posx1[pairs_ccf[i][0]]
|
|
|
disty[i] = posy1[pairs_ccf[i][1]] - posy1[pairs_ccf[i][0]]
|
|
|
dist[i] = numpy.sqrt(distx[i]**2 + disty[i]**2)
|
|
|
ang[i] = numpy.arctan2(disty[i],distx[i])
|
|
|
|
|
|
return distx, disty, dist, ang
|
|
|
#Calculo de Matrices
|
|
|
|
|
|
|
|
|
def __calculateVelVer(self, phase, lagTRange, _lambda):
|
|
|
|
|
|
Ts = lagTRange[1] - lagTRange[0]
|
|
|
velW = -_lambda*phase/(4*math.pi*Ts)
|
|
|
|
|
|
return velW
|
|
|
|
|
|
def __calculateVelHorDir(self, dist, tau1, tau2, ang):
|
|
|
nPairs = tau1.shape[0]
|
|
|
nHeights = tau1.shape[1]
|
|
|
vel = numpy.zeros((nPairs,3,nHeights))
|
|
|
dist1 = numpy.reshape(dist, (dist.size,1))
|
|
|
|
|
|
angCos = numpy.cos(ang)
|
|
|
angSin = numpy.sin(ang)
|
|
|
|
|
|
vel0 = dist1*tau1/(2*tau2**2)
|
|
|
vel[:,0,:] = (vel0*angCos).sum(axis = 1)
|
|
|
vel[:,1,:] = (vel0*angSin).sum(axis = 1)
|
|
|
|
|
|
ind = numpy.where(numpy.isinf(vel))
|
|
|
vel[ind] = numpy.nan
|
|
|
|
|
|
return vel
|
|
|
|
|
|
def techniqueSA(self, kwargs):
|
|
|
|
|
|
"""
|
|
|
Function that implements Spaced Antenna (SA) technique.
|
|
|
|
|
|
Input: Radial velocities, Direction cosines (x and y) of the Beam, Antenna azimuth,
|
|
|
Direction correction (if necessary), Ranges and SNR
|
|
|
|
|
|
Output: Winds estimation (Zonal, Meridional and Vertical)
|
|
|
|
|
|
Parameters affected: Winds
|
|
|
"""
|
|
|
position_x = kwargs['positionX']
|
|
|
position_y = kwargs['positionY']
|
|
|
azimuth = kwargs['azimuth']
|
|
|
|
|
|
if 'correctFactor' in kwargs:
|
|
|
correctFactor = kwargs['correctFactor']
|
|
|
else:
|
|
|
correctFactor = 1
|
|
|
|
|
|
groupList = kwargs['groupList']
|
|
|
pairs_ccf = groupList[1]
|
|
|
tau = kwargs['tau']
|
|
|
_lambda = kwargs['_lambda']
|
|
|
|
|
|
#Cross Correlation pairs obtained
|
|
|
|
|
|
indtau = tau.shape[0]/2
|
|
|
tau1 = tau[:indtau,:]
|
|
|
tau2 = tau[indtau:-1,:]
|
|
|
phase1 = tau[-1,:]
|
|
|
|
|
|
#---------------------------------------------------------------------
|
|
|
#Metodo Directo
|
|
|
distx, disty, dist, ang = self.__calculateDistance(position_x, position_y, pairs_ccf,azimuth)
|
|
|
winds = self.__calculateVelHorDir(dist, tau1, tau2, ang)
|
|
|
winds = stats.nanmean(winds, axis=0)
|
|
|
#---------------------------------------------------------------------
|
|
|
#Metodo General
|
|
|
|
|
|
#---------------------------------------------------------------------
|
|
|
winds[2,:] = self.__calculateVelVer(phase1, lagTRange, _lambda)
|
|
|
winds = correctFactor*winds
|
|
|
return winds
|
|
|
|
|
|
def __checkTime(self, currentTime, paramInterval, outputInterval):
|
|
|
|
|
|
dataTime = currentTime + paramInterval
|
|
|
deltaTime = dataTime - self.__initime
|
|
|
|
|
|
if deltaTime >= outputInterval or deltaTime < 0:
|
|
|
self.__dataReady = True
|
|
|
return
|
|
|
|
|
|
def techniqueMeteors(self, arrayMeteor, meteorThresh, heightMin, heightMax):
|
|
|
'''
|
|
|
Function that implements winds estimation technique with detected meteors.
|
|
|
|
|
|
Input: Detected meteors, Minimum meteor quantity to wind estimation
|
|
|
|
|
|
Output: Winds estimation (Zonal and Meridional)
|
|
|
|
|
|
Parameters affected: Winds
|
|
|
'''
|
|
|
#Settings
|
|
|
nInt = (heightMax - heightMin)/2
|
|
|
nInt = int(nInt)
|
|
|
winds = numpy.zeros((2,nInt))*numpy.nan
|
|
|
|
|
|
#Filter errors
|
|
|
error = numpy.where(arrayMeteor[:,-1] == 0)[0]
|
|
|
finalMeteor = arrayMeteor[error,:]
|
|
|
|
|
|
#Meteor Histogram
|
|
|
finalHeights = finalMeteor[:,2]
|
|
|
hist = numpy.histogram(finalHeights, bins = nInt, range = (heightMin,heightMax))
|
|
|
nMeteorsPerI = hist[0]
|
|
|
heightPerI = hist[1]
|
|
|
|
|
|
#Sort of meteors
|
|
|
indSort = finalHeights.argsort()
|
|
|
finalMeteor2 = finalMeteor[indSort,:]
|
|
|
|
|
|
# Calculating winds
|
|
|
ind1 = 0
|
|
|
ind2 = 0
|
|
|
|
|
|
for i in range(nInt):
|
|
|
nMet = nMeteorsPerI[i]
|
|
|
ind1 = ind2
|
|
|
ind2 = ind1 + nMet
|
|
|
|
|
|
meteorAux = finalMeteor2[ind1:ind2,:]
|
|
|
|
|
|
if meteorAux.shape[0] >= meteorThresh:
|
|
|
vel = meteorAux[:, 6]
|
|
|
zen = meteorAux[:, 4]*numpy.pi/180
|
|
|
azim = meteorAux[:, 3]*numpy.pi/180
|
|
|
|
|
|
n = numpy.cos(zen)
|
|
|
# m = (1 - n**2)/(1 - numpy.tan(azim)**2)
|
|
|
# l = m*numpy.tan(azim)
|
|
|
l = numpy.sin(zen)*numpy.sin(azim)
|
|
|
m = numpy.sin(zen)*numpy.cos(azim)
|
|
|
|
|
|
A = numpy.vstack((l, m)).transpose()
|
|
|
A1 = numpy.dot(numpy.linalg.inv( numpy.dot(A.transpose(),A) ),A.transpose())
|
|
|
windsAux = numpy.dot(A1, vel)
|
|
|
|
|
|
winds[0,i] = windsAux[0]
|
|
|
winds[1,i] = windsAux[1]
|
|
|
|
|
|
return winds, heightPerI[:-1]
|
|
|
|
|
|
def techniqueNSM_SA(self, **kwargs):
|
|
|
metArray = kwargs['metArray']
|
|
|
heightList = kwargs['heightList']
|
|
|
timeList = kwargs['timeList']
|
|
|
|
|
|
rx_location = kwargs['rx_location']
|
|
|
groupList = kwargs['groupList']
|
|
|
azimuth = kwargs['azimuth']
|
|
|
dfactor = kwargs['dfactor']
|
|
|
k = kwargs['k']
|
|
|
|
|
|
azimuth1, dist = self.__calculateAzimuth1(rx_location, groupList, azimuth)
|
|
|
d = dist*dfactor
|
|
|
#Phase calculation
|
|
|
metArray1 = self.__getPhaseSlope(metArray, heightList, timeList)
|
|
|
|
|
|
metArray1[:,-2] = metArray1[:,-2]*metArray1[:,2]*1000/(k*d[metArray1[:,1].astype(int)]) #angles into velocities
|
|
|
|
|
|
velEst = numpy.zeros((heightList.size,2))*numpy.nan
|
|
|
azimuth1 = azimuth1*numpy.pi/180
|
|
|
|
|
|
for i in range(heightList.size):
|
|
|
h = heightList[i]
|
|
|
indH = numpy.where((metArray1[:,2] == h)&(numpy.abs(metArray1[:,-2]) < 100))[0]
|
|
|
metHeight = metArray1[indH,:]
|
|
|
if metHeight.shape[0] >= 2:
|
|
|
velAux = numpy.asmatrix(metHeight[:,-2]).T #Radial Velocities
|
|
|
iazim = metHeight[:,1].astype(int)
|
|
|
azimAux = numpy.asmatrix(azimuth1[iazim]).T #Azimuths
|
|
|
A = numpy.hstack((numpy.cos(azimAux),numpy.sin(azimAux)))
|
|
|
A = numpy.asmatrix(A)
|
|
|
A1 = numpy.linalg.pinv(A.transpose()*A)*A.transpose()
|
|
|
velHor = numpy.dot(A1,velAux)
|
|
|
|
|
|
velEst[i,:] = numpy.squeeze(velHor)
|
|
|
return velEst
|
|
|
|
|
|
def __getPhaseSlope(self, metArray, heightList, timeList):
|
|
|
meteorList = []
|
|
|
#utctime sec1 height SNR velRad ph0 ph1 ph2 coh0 coh1 coh2
|
|
|
#Putting back together the meteor matrix
|
|
|
utctime = metArray[:,0]
|
|
|
uniqueTime = numpy.unique(utctime)
|
|
|
|
|
|
phaseDerThresh = 0.5
|
|
|
ippSeconds = timeList[1] - timeList[0]
|
|
|
sec = numpy.where(timeList>1)[0][0]
|
|
|
nPairs = metArray.shape[1] - 6
|
|
|
nHeights = len(heightList)
|
|
|
|
|
|
for t in uniqueTime:
|
|
|
metArray1 = metArray[utctime==t,:]
|
|
|
# phaseDerThresh = numpy.pi/4 #reducir Phase thresh
|
|
|
tmet = metArray1[:,1].astype(int)
|
|
|
hmet = metArray1[:,2].astype(int)
|
|
|
|
|
|
metPhase = numpy.zeros((nPairs, heightList.size, timeList.size - 1))
|
|
|
metPhase[:,:] = numpy.nan
|
|
|
metPhase[:,hmet,tmet] = metArray1[:,6:].T
|
|
|
|
|
|
#Delete short trails
|
|
|
metBool = ~numpy.isnan(metPhase[0,:,:])
|
|
|
heightVect = numpy.sum(metBool, axis = 1)
|
|
|
metBool[heightVect<sec,:] = False
|
|
|
metPhase[:,heightVect<sec,:] = numpy.nan
|
|
|
|
|
|
#Derivative
|
|
|
metDer = numpy.abs(metPhase[:,:,1:] - metPhase[:,:,:-1])
|
|
|
phDerAux = numpy.dstack((numpy.full((nPairs,nHeights,1), False, dtype=bool),metDer > phaseDerThresh))
|
|
|
metPhase[phDerAux] = numpy.nan
|
|
|
|
|
|
#--------------------------METEOR DETECTION -----------------------------------------
|
|
|
indMet = numpy.where(numpy.any(metBool,axis=1))[0]
|
|
|
|
|
|
for p in numpy.arange(nPairs):
|
|
|
phase = metPhase[p,:,:]
|
|
|
phDer = metDer[p,:,:]
|
|
|
|
|
|
for h in indMet:
|
|
|
height = heightList[h]
|
|
|
phase1 = phase[h,:] #82
|
|
|
phDer1 = phDer[h,:]
|
|
|
|
|
|
phase1[~numpy.isnan(phase1)] = numpy.unwrap(phase1[~numpy.isnan(phase1)]) #Unwrap
|
|
|
|
|
|
indValid = numpy.where(~numpy.isnan(phase1))[0]
|
|
|
initMet = indValid[0]
|
|
|
endMet = 0
|
|
|
|
|
|
for i in range(len(indValid)-1):
|
|
|
|
|
|
#Time difference
|
|
|
inow = indValid[i]
|
|
|
inext = indValid[i+1]
|
|
|
idiff = inext - inow
|
|
|
#Phase difference
|
|
|
phDiff = numpy.abs(phase1[inext] - phase1[inow])
|
|
|
|
|
|
if idiff>sec or phDiff>numpy.pi/4 or inext==indValid[-1]: #End of Meteor
|
|
|
sizeTrail = inow - initMet + 1
|
|
|
if sizeTrail>3*sec: #Too short meteors
|
|
|
x = numpy.arange(initMet,inow+1)*ippSeconds
|
|
|
y = phase1[initMet:inow+1]
|
|
|
ynnan = ~numpy.isnan(y)
|
|
|
x = x[ynnan]
|
|
|
y = y[ynnan]
|
|
|
slope, intercept, r_value, p_value, std_err = stats.linregress(x,y)
|
|
|
ylin = x*slope + intercept
|
|
|
rsq = r_value**2
|
|
|
if rsq > 0.5:
|
|
|
vel = slope#*height*1000/(k*d)
|
|
|
estAux = numpy.array([utctime,p,height, vel, rsq])
|
|
|
meteorList.append(estAux)
|
|
|
initMet = inext
|
|
|
metArray2 = numpy.array(meteorList)
|
|
|
|
|
|
return metArray2
|
|
|
|
|
|
def __calculateAzimuth1(self, rx_location, pairslist, azimuth0):
|
|
|
|
|
|
azimuth1 = numpy.zeros(len(pairslist))
|
|
|
dist = numpy.zeros(len(pairslist))
|
|
|
|
|
|
for i in range(len(rx_location)):
|
|
|
ch0 = pairslist[i][0]
|
|
|
ch1 = pairslist[i][1]
|
|
|
|
|
|
diffX = rx_location[ch0][0] - rx_location[ch1][0]
|
|
|
diffY = rx_location[ch0][1] - rx_location[ch1][1]
|
|
|
azimuth1[i] = numpy.arctan2(diffY,diffX)*180/numpy.pi
|
|
|
dist[i] = numpy.sqrt(diffX**2 + diffY**2)
|
|
|
|
|
|
azimuth1 -= azimuth0
|
|
|
return azimuth1, dist
|
|
|
|
|
|
def techniqueNSM_DBS(self, **kwargs):
|
|
|
metArray = kwargs['metArray']
|
|
|
heightList = kwargs['heightList']
|
|
|
timeList = kwargs['timeList']
|
|
|
azimuth = kwargs['azimuth']
|
|
|
theta_x = numpy.array(kwargs['theta_x'])
|
|
|
theta_y = numpy.array(kwargs['theta_y'])
|
|
|
|
|
|
utctime = metArray[:,0]
|
|
|
cmet = metArray[:,1].astype(int)
|
|
|
hmet = metArray[:,3].astype(int)
|
|
|
SNRmet = metArray[:,4]
|
|
|
vmet = metArray[:,5]
|
|
|
spcmet = metArray[:,6]
|
|
|
|
|
|
nChan = numpy.max(cmet) + 1
|
|
|
nHeights = len(heightList)
|
|
|
|
|
|
azimuth_arr, zenith_arr, dir_cosu, dir_cosv, dir_cosw = self.__calculateAngles(theta_x, theta_y, azimuth)
|
|
|
hmet = heightList[hmet]
|
|
|
h1met = hmet*numpy.cos(zenith_arr[cmet]) #Corrected heights
|
|
|
|
|
|
velEst = numpy.zeros((heightList.size,2))*numpy.nan
|
|
|
|
|
|
for i in range(nHeights - 1):
|
|
|
hmin = heightList[i]
|
|
|
hmax = heightList[i + 1]
|
|
|
|
|
|
thisH = (h1met>=hmin) & (h1met<hmax) & (cmet!=2) & (SNRmet>8) & (vmet<50) & (spcmet<10)
|
|
|
indthisH = numpy.where(thisH)
|
|
|
|
|
|
if numpy.size(indthisH) > 3:
|
|
|
|
|
|
vel_aux = vmet[thisH]
|
|
|
chan_aux = cmet[thisH]
|
|
|
cosu_aux = dir_cosu[chan_aux]
|
|
|
cosv_aux = dir_cosv[chan_aux]
|
|
|
cosw_aux = dir_cosw[chan_aux]
|
|
|
|
|
|
nch = numpy.size(numpy.unique(chan_aux))
|
|
|
if nch > 1:
|
|
|
A = self.__calculateMatA(cosu_aux, cosv_aux, cosw_aux, True)
|
|
|
velEst[i,:] = numpy.dot(A,vel_aux)
|
|
|
|
|
|
return velEst
|
|
|
|
|
|
def run(self, dataOut, technique, nHours=1, hmin=70, hmax=110, **kwargs):
|
|
|
|
|
|
param = dataOut.data_param
|
|
|
#if dataOut.abscissaList != None:
|
|
|
if numpy.any(dataOut.abscissaList):
|
|
|
absc = dataOut.abscissaList[:-1]
|
|
|
# noise = dataOut.noise
|
|
|
heightList = dataOut.heightList
|
|
|
SNR = dataOut.data_snr
|
|
|
|
|
|
if technique == 'DBS':
|
|
|
|
|
|
kwargs['velRadial'] = param[:,1,:] #Radial velocity
|
|
|
kwargs['heightList'] = heightList
|
|
|
kwargs['SNR'] = SNR
|
|
|
|
|
|
dataOut.data_output, dataOut.heightList, dataOut.data_snr = self.techniqueDBS(kwargs) #DBS Function
|
|
|
dataOut.utctimeInit = dataOut.utctime
|
|
|
dataOut.outputInterval = dataOut.paramInterval
|
|
|
|
|
|
elif technique == 'SA':
|
|
|
|
|
|
#Parameters
|
|
|
# position_x = kwargs['positionX']
|
|
|
# position_y = kwargs['positionY']
|
|
|
# azimuth = kwargs['azimuth']
|
|
|
#
|
|
|
# if kwargs.has_key('crosspairsList'):
|
|
|
# pairs = kwargs['crosspairsList']
|
|
|
# else:
|
|
|
# pairs = None
|
|
|
#
|
|
|
# if kwargs.has_key('correctFactor'):
|
|
|
# correctFactor = kwargs['correctFactor']
|
|
|
# else:
|
|
|
# correctFactor = 1
|
|
|
|
|
|
# tau = dataOut.data_param
|
|
|
# _lambda = dataOut.C/dataOut.frequency
|
|
|
# pairsList = dataOut.groupList
|
|
|
# nChannels = dataOut.nChannels
|
|
|
|
|
|
kwargs['groupList'] = dataOut.groupList
|
|
|
kwargs['tau'] = dataOut.data_param
|
|
|
kwargs['_lambda'] = dataOut.C/dataOut.frequency
|
|
|
# dataOut.data_output = self.techniqueSA(pairs, pairsList, nChannels, tau, azimuth, _lambda, position_x, position_y, absc, correctFactor)
|
|
|
dataOut.data_output = self.techniqueSA(kwargs)
|
|
|
dataOut.utctimeInit = dataOut.utctime
|
|
|
dataOut.outputInterval = dataOut.timeInterval
|
|
|
|
|
|
elif technique == 'Meteors':
|
|
|
dataOut.flagNoData = True
|
|
|
self.__dataReady = False
|
|
|
|
|
|
if 'nHours' in kwargs:
|
|
|
nHours = kwargs['nHours']
|
|
|
else:
|
|
|
nHours = 1
|
|
|
|
|
|
if 'meteorsPerBin' in kwargs:
|
|
|
meteorThresh = kwargs['meteorsPerBin']
|
|
|
else:
|
|
|
meteorThresh = 6
|
|
|
|
|
|
if 'hmin' in kwargs:
|
|
|
hmin = kwargs['hmin']
|
|
|
else: hmin = 70
|
|
|
if 'hmax' in kwargs:
|
|
|
hmax = kwargs['hmax']
|
|
|
else: hmax = 110
|
|
|
|
|
|
dataOut.outputInterval = nHours*3600
|
|
|
|
|
|
if self.__isConfig == False:
|
|
|
# self.__initime = dataOut.datatime.replace(minute = 0, second = 0, microsecond = 03)
|
|
|
#Get Initial LTC time
|
|
|
self.__initime = datetime.datetime.utcfromtimestamp(dataOut.utctime)
|
|
|
self.__initime = (self.__initime.replace(minute = 0, second = 0, microsecond = 0) - datetime.datetime(1970, 1, 1)).total_seconds()
|
|
|
|
|
|
self.__isConfig = True
|
|
|
|
|
|
if self.__buffer is None:
|
|
|
self.__buffer = dataOut.data_param
|
|
|
self.__firstdata = copy.copy(dataOut)
|
|
|
|
|
|
else:
|
|
|
self.__buffer = numpy.vstack((self.__buffer, dataOut.data_param))
|
|
|
|
|
|
self.__checkTime(dataOut.utctime, dataOut.paramInterval, dataOut.outputInterval) #Check if the buffer is ready
|
|
|
|
|
|
if self.__dataReady:
|
|
|
dataOut.utctimeInit = self.__initime
|
|
|
|
|
|
self.__initime += dataOut.outputInterval #to erase time offset
|
|
|
|
|
|
dataOut.data_output, dataOut.heightList = self.techniqueMeteors(self.__buffer, meteorThresh, hmin, hmax)
|
|
|
dataOut.flagNoData = False
|
|
|
self.__buffer = None
|
|
|
|
|
|
elif technique == 'Meteors1':
|
|
|
dataOut.flagNoData = True
|
|
|
self.__dataReady = False
|
|
|
|
|
|
if 'nMins' in kwargs:
|
|
|
nMins = kwargs['nMins']
|
|
|
else: nMins = 20
|
|
|
if 'rx_location' in kwargs:
|
|
|
rx_location = kwargs['rx_location']
|
|
|
else: rx_location = [(0,1),(1,1),(1,0)]
|
|
|
if 'azimuth' in kwargs:
|
|
|
azimuth = kwargs['azimuth']
|
|
|
else: azimuth = 51.06
|
|
|
if 'dfactor' in kwargs:
|
|
|
dfactor = kwargs['dfactor']
|
|
|
if 'mode' in kwargs:
|
|
|
mode = kwargs['mode']
|
|
|
if 'theta_x' in kwargs:
|
|
|
theta_x = kwargs['theta_x']
|
|
|
if 'theta_y' in kwargs:
|
|
|
theta_y = kwargs['theta_y']
|
|
|
else: mode = 'SA'
|
|
|
|
|
|
#Borrar luego esto
|
|
|
if dataOut.groupList is None:
|
|
|
dataOut.groupList = [(0,1),(0,2),(1,2)]
|
|
|
groupList = dataOut.groupList
|
|
|
C = 3e8
|
|
|
freq = 50e6
|
|
|
lamb = C/freq
|
|
|
k = 2*numpy.pi/lamb
|
|
|
|
|
|
timeList = dataOut.abscissaList
|
|
|
heightList = dataOut.heightList
|
|
|
|
|
|
if self.__isConfig == False:
|
|
|
dataOut.outputInterval = nMins*60
|
|
|
# self.__initime = dataOut.datatime.replace(minute = 0, second = 0, microsecond = 03)
|
|
|
#Get Initial LTC time
|
|
|
initime = datetime.datetime.utcfromtimestamp(dataOut.utctime)
|
|
|
minuteAux = initime.minute
|
|
|
minuteNew = int(numpy.floor(minuteAux/nMins)*nMins)
|
|
|
self.__initime = (initime.replace(minute = minuteNew, second = 0, microsecond = 0) - datetime.datetime(1970, 1, 1)).total_seconds()
|
|
|
|
|
|
self.__isConfig = True
|
|
|
|
|
|
if self.__buffer is None:
|
|
|
self.__buffer = dataOut.data_param
|
|
|
self.__firstdata = copy.copy(dataOut)
|
|
|
|
|
|
else:
|
|
|
self.__buffer = numpy.vstack((self.__buffer, dataOut.data_param))
|
|
|
|
|
|
self.__checkTime(dataOut.utctime, dataOut.paramInterval, dataOut.outputInterval) #Check if the buffer is ready
|
|
|
|
|
|
if self.__dataReady:
|
|
|
dataOut.utctimeInit = self.__initime
|
|
|
self.__initime += dataOut.outputInterval #to erase time offset
|
|
|
|
|
|
metArray = self.__buffer
|
|
|
if mode == 'SA':
|
|
|
dataOut.data_output = self.techniqueNSM_SA(rx_location=rx_location, groupList=groupList, azimuth=azimuth, dfactor=dfactor, k=k,metArray=metArray, heightList=heightList,timeList=timeList)
|
|
|
elif mode == 'DBS':
|
|
|
dataOut.data_output = self.techniqueNSM_DBS(metArray=metArray,heightList=heightList,timeList=timeList, azimuth=azimuth, theta_x=theta_x, theta_y=theta_y)
|
|
|
dataOut.data_output = dataOut.data_output.T
|
|
|
dataOut.flagNoData = False
|
|
|
self.__buffer = None
|
|
|
|
|
|
return
|
|
|
|
