# Least Squares based Position Estimator for DoA

The $$\text{5G}^\text{th}$$ generation of wireless networks are equipped with increased number of antennas and radio frequency RF chains at the transmitter and receiver. This allows the 5G systems to estimate the angles with improved resolution. In release-15, 3GPP defined standards to enable methods for estimating UE location based on angle of departure and angle of arrival measurements for 5G-NR systems. The nomenclature of the methods is detailed below.

Table 39 Table-1: Angle od Departure and Arrival based Positioning in 5G Networks

Generation

Method

Measurement

Optimization methods

5G

DL-AoD

Beam-ID and RSRP

5G

UL-AoA

AOA, RToA, Beam-ID, and RSRP

Its not possible to find a close form estimator for 2D-DoAs. Hence, DoA based positioning methods rely on iterative optimization methods. One such optimization method is Gradient Descent (GD) which has low complexity iteration in comparison to Newton Raphson (NR) method but needs more iterations to converge to local/global optima. The comparison between the two methods is shown below:

where N denotes the number of measurements used for positioning and $$N_\text{iterations}$$ denotes the number of iterations used by iterative methods. The implementation of both these methods provided in 5G Toolkit is inspired by [3gppDoA].

Code example

# shape of refLocations: Nref x 3
# shape of xoA: Nref x 2
posEstimator     = LeastSquareDoA()
positionEstimate, error = posEstimator(refLocations, xoA)


class toolkit5G.Positioning.LeastSquareDoA[source]

This modules uses least squares optimization framework to estimate the node location using direction of arrival (DoA) measurements.

Parameters:

None

Input:
• refLocations (($$\text{N}_\text{ref}$$, 3), np.number) – Reference locations with respect to whom ToAs are estimated.

• xoA (($$\text{N}_\text{ref}$$,k), np.number) – Direction of arrival estimates with respect to $$\text{N}_\text{ref}$$ reference locations where xoA[0] and xoA[1] denotes the azimuth and elevation angles of arrival respectively. * If k is 1, It assume that xoA contains all Azimuth angle of arrival. * If k is 2, It assume that xoA[:,0] contains all Azimuth angle of arrival and xoA[:,1] stores all the elevation angle of arrival.

Note

$$\text{N}_\text{ref}$$ should be higher than 2.

Important

If k = 1, then only 2D location can be estimated.

Output:
• (N, 3), np.number – Position estimate. If the height of all the transmitter is same, then N=2 else N=1.

• For equiheight transmitters, there exist two estimates of the height of the UE.

• One above the transmitter and other below it.

• This phenomenon results in 2 estimate of the position of the UE.

• However, both these estimates have the same (x, y) co-ordinate.

• np.number – Uncertainty in Position Estimates. The lower the value better the position estimates.

Raises:
• ValueError – [Error-LeastSquareDoA]: ‘xoA’ must be an array of numbers!

• ValueError – [Error-LeastSquareDoA]: ‘xoA’ must have 2 dimension!

• ValueError – [Error-LeastSquareDoA]: ‘xoA’ must have shape (Nref, 2) or (Nref, 1) with Nref>2!

• ValueError – [Error-LeastSquareDoA]: ‘refLocations’ must be an array of numbers!

• ValueError – [Error-LeastSquareDoA]: ‘refLocations’ must have 2 dimension!

• ValueError – [Error-LeastSquareDoA]: ‘refLocations’ must have shape (Nref, 3) with refLocations.shape[0] == xoA.shape[0]!

# Gradient Descent based Position Estimator for DoA

Code example

# shape of refLocations: Nref x 3
# shape of xoA: Nref x 2
numEpoches    = 1
tolerance     = 10**-5
numIterations = 10000
stepsize      = 1

posEstimator  = GradientDescentDoA(numEpochs = numEpoches, numIterationPerEpoch = numIterations,
stepsize = stepsize, tolerance = tolerance, isd = 100)
positionEstimate, error = posEstimator(refLocations, xoA)


The input output interface for usage of Gradient Descent algorithm is provided below.

class toolkit5G.Positioning.GradientDescentDoA(numIterationPerEpoch=10000, numEpochs=10, tolerance=1e-06, stepsize=0.1, isd=100)[source]

This modules uses direction of arrival measurements $$\{(\phi_i, \theta_i)\}_{i=0}^{i=\text{N}_\text{ref}-1}$$ to estimate the position of a node based on gradient descent optimization method.

Parameters:
• numIterationPerEpoch (int) – Number of iteration for gradient descent optimizations. Default value is 10000.

• numEpochs (int) – Number of epoches used in gradient descent optimizations. Default value is 10.

• tolerance (float) – Error tolerance values. The optimization stops when the optimization error reduces below tolerance value. Default value is 0.000001.

• stepsize (float) – Optimization step size. The Gradient Descent algorithms iterates using this step-size to converge towards the global solutions. Default value is 0.1.

• isd (float) – Defines the intersite distance (m). Its equal to :math:2 times  cell-size. Default value is 100.

Input:
• refPosition (($$\text{N}_\text{ref}$$, 3), np.number) – Reference locations with respect to whom ToAs are estimated.

• xoA (($$\text{N}_\text{ref}$$,2), np.number) – direction of arrival estimates of the target node with respect to $$\text{N}_\text{ref}$$ reference nodes. xoA[:,0] stores the azimuth angle ($$\phi$$) and xoA[:,1] stores elevation angle ($$\theta$$).

Output:

(3,), np.number – returns the position estimate based on DoA estimates and reference Tx locations.

Note

The large value of numIterationPerEpoch improves the optimization performance but increases the complexity of the method.

Note

The large value of numEpochs helps reduce the odds of getting stuck in the local optima but increases the complexity of the method.

Note

The lower value of tolerance improves the optimization performance but increases the complexity of the method. The method iterative longer to reduces the optimization error below the tolerance limit.

Note

The selection of step-size mu plays crucial role in performance of the method. Small step-size results in good performance but requires large number of iteration numIterationPerEpoch to converge. Large step-size improves the convergence rate but are suceptible to local minimas.

Raises:
• ValueError – [Error-GradientDescentDoA]: ‘refPosition’ and ‘measurements’ must be an numpy array!

• ValueError – [Error-GradientDescentDoA]: ‘refPosition’ must be an 2D numpy array!

• ValueError – [Error-GradientDescentDoA]: ‘refPosition’ must be an numpy array of size (nRefnode x 3). refPosition.shape[1] is not equal to 3!

• ValueError – [Error-GradientDescentDoA]: ‘refPosition’ must be an numpy array of size (nRefnode x 3). refPosition.shape[0] should be more than 3 for trilateration!

• ValueError – [Error-GradientDescentDoA]: ‘number of refPositions’ must be consistent with number of measurements! refPosition.shape[0] should be equal to tdoa.size+1

• ValueError – [Error-GradientDescentDoA]: ‘numIterationPerEpoch’ should be a scalar integer!

• ValueError – [Error-GradientDescentDoA]: ‘numEpochs’ should be a scalar integer!

• ValueError – [Error-GradientDescentDoA]: ‘tolerance’ should be a scalar number!

• ValueError – [Error-GradientDescentDoA]: ‘stepsize’ should be a scalar number!

• ValueError – [Error-GradientDescentDoA]: ‘isd’ should be a scalar number!

• ValueError – [Error-GradientDescentDoA]: ‘refPosition’ and ‘measurements’ must be an numpy array!

References:
[3gppDoA]
1. Wang, Z. Shi, Y. Yu, S. Huang and L. Chen, “Enabling Angle-based Positioning to 3GPP NR Systems,” 2019 16th Workshop on Positioning, Navigation and Communications (WPNC), Bremen, Germany, 2019, pp. 1-7, doi: 10.1109/WPNC47567.2019.8970182.