{
"nbformat": 4,
"nbformat_minor": 0,
"metadata": {
"colab": {
"provenance": [],
"toc_visible": true,
"name": "FMCW-Radar-103_AoA.ipynb"
},
"kernelspec": {
"name": "python3",
"display_name": "Python 3"
},
"language_info": {
"name": "python"
}
},
"cells": [
{
"cell_type": "markdown",
"source": [
"# FMCW Radar 103 - AoA\n",
"\n",
"> In FMCW MIMO (multiple TX, multiple RX antennas) radar, the Angle of Arrival is computed from the phase difference measured at each antenna.\n",
"\n",
"Status:\n",
"* Minimum Reproducible Example for 1 target multiple angles, 2 RX antennas and calculation of the Angle of Arrival\n",
"* Shows how to compute Bartlet and Capon with code\n",
"* Back-up code also looks at using FFT and cross-correlation (not yet finished)\n",
"\n",
"Results:\n",
"* shows that Barlett ,for 6 elements, is limited to 8.5 degrees and CAPON goes done to 2.5 degrees all other parameters equivalent.\n",
"* compares code to existing pyargus library (similar results).\n",
"\n",
"Next:\n",
"* instead of implicit compute of Rxx from steering vector (Eq 7.21 below) , compute its estimates with ADC samples (Eq RXX_1) and add this into radar signal chain\n",
"\n",
"History:\n",
"* 2023-01-02: Added 2D FFT AoA, CAPON and Bartlet
(\n",
" see code cell for warning about same range bin)
\n",
"* 2022-12-16: Moved 2 RX antennas MRE to fore-front.\n",
"* 2022-12-14: added MRE for single target 2 antennas\n",
"* 2022-10-28: adding investigations with Pyargus on resolution as function elements in ULA with Capon vs Bartlet\n",
"* 2022-10-22: fixed Bartlett and Capon code to allow for any number of RX elements"
],
"metadata": {
"id": "iNt83nhEmGgf"
}
},
{
"cell_type": "markdown",
"source": [
"Next:\n",
"\n",
"* click to access other workbooks:\n",
" * [FMCW 101 - Range and Speed](https://colab.research.google.com/gist/matt-chv/bdd8b835c5cb7e739bb8b68d00257690/fmcw-radar-101.ipynb): Measure distance and speed for FMCW radar.\n",
" * [FMCW 102 - CFAR](https://colab.research.google.com/gist/matt-chv/33e98a23d4b9d90dd27c1bf7f0a54781/fmcw-radar-102-cfar.ipynb) : CFAR or how to detect objects of interest from range FFT.\n",
" * [FMCW 103 - AoA](https://colab.research.google.com/gist/matt-chv/d81f7e2166009a623a36781a0773ae47/fmcw-radar-103-aoa.ipynb) : angle of arrival (CAPON vs Bartlett)\n",
" * [FMCW 104 - increased resolution vs FFT bin](https://colab.research.google.com/gist/matt-chv/0b25dbc4673f2d7d63804cc6241643b9/fmcw-radar-104-1-fft-freq-estimation.ipynb)increase accuracy option compared to standard FFT.\n",
" * Also available on github as gist for forking:\n",
" * [fmcw 101](https://gist.github.com/matt-chv/bdd8b835c5cb7e739bb8b68d00257690)\n",
" * [fmcw 102](https://gist.github.com/matt-chv/33e98a23d4b9d90dd27c1bf7f0a54781)\n",
" * ...\n",
"\n",
"Related ressources:"
],
"metadata": {
"id": "aAJENwbvsZx3"
}
},
{
"cell_type": "markdown",
"source": [
"## AoA Maths"
],
"metadata": {
"id": "8VzKg_OnsrwX"
}
},
{
"cell_type": "markdown",
"source": [
"## Minimum Reproductible Examples"
],
"metadata": {
"id": "z3_nV_1Mst5T"
}
},
{
"cell_type": "markdown",
"source": [
"## Phase based AoA estimate"
],
"metadata": {
"id": "FUAB_Om3s4eO"
}
},
{
"cell_type": "code",
"source": [
"from numpy import abs ,angle, arange, arcsin, cos, pi, sqrt, tan\n",
"from scipy.fft import fft\n",
"\n",
"def y_IF(f0_min, slope, T, antenna_tx, antenna_rx, target, v=3e8):\n",
" \"\"\" This function implements the mathematical IF defined in latex as\n",
" y_{IF} = cos(2 \\pi [f_0\\delta + s * \\delta * t - s* \\delta^2])\n",
" into following python code\n",
" y_IF = cos (2*pi*(f_0 * delta + slope * delta * T + slope * delta**2))\n",
" Parameters:\n",
" -----------\n",
" f0_min: float\n",
" the frequency at the begining of the chirp\n",
" slope: float\n",
" the slope with which the chirp frequency inceases over time\n",
" T: ndarray\n",
" the 1D vector containing time values\n",
" antenna_tx: tuple of floats\n",
" x, y, z coordinates\n",
" antenna_rx: tuple of floats\n",
" x, y, z coordinates\n",
" target: tuple of floats\n",
" x, y, z coordinates\n",
" v: float\n",
" speed of light in considered medium\n",
" Returns:\n",
" --------\n",
" YIF: ndarray\n",
" vector containing the IF values\n",
" \"\"\"\n",
" tx_x, tx_y, tx_z = antenna_tx\n",
" rx_x, rx_y, rx_z = antenna_rx\n",
" t_x, t_y, t_z = target\n",
" distance = sqrt((tx_x-t_x)**2 + (tx_y-t_y)**2 + (tx_z-t_z)**2)\n",
" distance += sqrt((rx_x-t_x)**2 + (rx_y-t_y)**2 + (rx_z-t_z)**2)\n",
" # delta = sqrt((A.x-target.x)**2+(A.y-target.y)**2+(A.z-target.z)**2)/3e8\n",
" delta = distance/v\n",
" YIF = cos(2 *pi *(f0_min * delta + slope * delta * T + slope * delta**2))\n",
" return YIF\n",
"\n",
"f0_min = 60e9\n",
"c = 3e8\n",
"# lambda ~5mm at 60GHz\n",
"lambda0_max = 3e8/f0_min\n",
"n_rx = 2\n",
"Distance = 10\n",
"k = 200e12\n",
"n_samples = 512\n",
"f_if = 2*k*Distance/c\n",
"fs = 50e6\n",
"ts = 1/fs\n",
"\n",
"antenna_tx = (-lambda0_max/2,0,0)\n",
"T = arange(0, n_samples*ts+ts, ts)\n",
"\n",
"for theta in [-180/3, -180/6, -180/10, 0, 180/10, 180/6, 180/3]:\n",
" target = (4*sin(theta/180*pi), 4*cos(theta/180*pi),0)\n",
"\n",
" Antennas_RXs = [(i*lambda0_max/2,0,0) for i in range(n_rx)]\n",
"\n",
" phases = []\n",
" i_peaks = []\n",
" for antenna_rx in Antennas_RXs:\n",
" tx_x, tx_y, tx_z = antenna_tx\n",
" rx_x, rx_y, rx_z = antenna_rx\n",
" t_x, t_y, t_z = target\n",
" distance = sqrt((tx_x-t_x)**2 + (tx_y-t_y)**2 + (tx_z-t_z)**2)\n",
" distance += sqrt((rx_x-t_x)**2 + (rx_y-t_y)**2 + (rx_z-t_z)**2)\n",
" f_if = 2*k*Distance/c\n",
" assert f_if < 1/ts/2\n",
" YIF = y_IF(f0_min, k,T, antenna_tx, antenna_rx, target)\n",
" FT = fft(YIF)\n",
" MAG = abs(FT)[0:int(n_samples/2)]\n",
" ANG = angle(FT)[0:int(n_samples/2)]\n",
"\n",
" # now find the peak\n",
" amplitude_peak = sorted(MAG, reverse = True)[0]\n",
" i_peak = list(MAG).index(amplitude_peak)\n",
" if not i_peaks:\n",
" i_peaks.append(i_peak)\n",
" else:\n",
" try:\n",
" assert i_peak in i_peaks\n",
" except:\n",
" # exit now as we don't have the logic to track across range bins\n",
" print(\"bin range change\")\n",
" break\n",
" phases.append(ANG[0:int(n_samples/2)][i_peak])\n",
" f_peak = i_peak * 1/ts / n_samples\n",
" d2 = f_peak*c/2/k\n",
" dfixed = 0\n",
"\n",
" delta_phase = (phases[0]-phases[1]) #/len(phases)\n",
" if delta_phase/pi>1:\n",
" theta_calc = arcsin(delta_phase/pi -2)*180/pi\n",
" print(f\"theta: {theta:.2g}, calculated_p: {theta_calc:.2g}\")\n",
" elif delta_phase/pi<-1:\n",
" theta_calc = arcsin(delta_phase/pi % +2)*180/pi\n",
" print(f\"theta: {theta:.2g}, calculated_m: {theta_calc:.2g}\")\n",
" else:\n",
" theta_calc = arcsin(delta_phase/pi)*180/pi\n",
" print(f\"theta: {theta:.2g}, calculated: {theta_calc:.2g}\")"
],
"metadata": {
"id": "PWNqe1oErEqc",
"outputId": "947c3df3-9f0f-473e-95cd-e55b8d117b40",
"colab": {
"base_uri": "https://localhost:8080/"
}
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"theta: -60, calculated: -62\n",
"theta: -30, calculated: -31\n",
"theta: -18, calculated: -18\n",
"theta: 0, calculated: -0.018\n",
"theta: 18, calculated: 18\n",
"theta: 30, calculated: 31\n",
"theta: 60, calculated: 62\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"## FFT based AoA"
],
"metadata": {
"id": "lFyDfSeKs_xS"
}
},
{
"cell_type": "code",
"source": [
"# single target FFT AoA MRE\n",
"from numpy import abs ,angle, arange, arcsin, cos, pi, sqrt, tan, zeros\n",
"from scipy.fft import fft, fft2\n",
"import matplotlib.pyplot as plt\n",
"\n",
"def y_IF(f0_min, slope, T, antenna_tx, antenna_rx, target, v=3e8):\n",
" \"\"\" This function implements the mathematical IF defined in latex as\n",
" y_{IF} = cos(2 \\pi [f_0\\delta + s * \\delta * t - s* \\delta^2])\n",
" into following python code\n",
" y_IF = cos (2*pi*(f_0 * delta + slope * delta * T + slope * delta**2))\n",
" Parameters:\n",
" -----------\n",
" f0_min: float\n",
" the frequency at the begining of the chirp\n",
" slope: float\n",
" the slope with which the chirp frequency inceases over time\n",
" T: ndarray\n",
" the 1D vector containing time values\n",
" antenna_tx: tuple of floats\n",
" x, y, z coordinates\n",
" antenna_rx: tuple of floats\n",
" x, y, z coordinates\n",
" target: tuple of floats\n",
" x, y, z coordinates\n",
" v: float\n",
" speed of light in considered medium\n",
" Returns:\n",
" --------\n",
" YIF: ndarray\n",
" vector containing the IF values\n",
" \"\"\"\n",
" tx_x, tx_y, tx_z = antenna_tx\n",
" rx_x, rx_y, rx_z = antenna_rx\n",
" t_x, t_y, t_z = target\n",
" distance = sqrt((tx_x-t_x)**2 + (tx_y-t_y)**2 + (tx_z-t_z)**2)\n",
" distance += sqrt((rx_x-t_x)**2 + (rx_y-t_y)**2 + (rx_z-t_z)**2)\n",
" # delta = sqrt((A.x-target.x)**2+(A.y-target.y)**2+(A.z-target.z)**2)/3e8\n",
" delta = distance/v\n",
" YIF = cos(2 *pi *(f0_min * delta + slope * delta * T + slope * delta**2))\n",
" return YIF\n",
"\n",
"f0_min = 60e9\n",
"c = 3e8\n",
"# lambda ~5mm at 60GHz\n",
"lambda0_max = 3e8/f0_min\n",
"n_rx = 32\n",
"Distance = 10\n",
"k = 200e12\n",
"n_samples = 512\n",
"f_if = 2*k*Distance/c\n",
"fs = 50e6\n",
"ts = 1/fs\n",
"\n",
"antenna_tx = (-lambda0_max/2,0,0)\n",
"T = arange(0, n_samples*ts, ts)\n",
"\n",
"#for theta in [-180/3, -180/6, -180/10, 0, 180/10, 180/6, 180/3]:\n",
"theta = -180/6\n",
"target = (4*tan(theta/180*pi),4,0)\n",
"\n",
"Antennas_RXs = [(i*lambda0_max/2,0,0) for i in range(n_rx)]\n",
"\n",
"phases = []\n",
"i_peaks = []\n",
"cube2D = zeros((n_rx, n_samples))\n",
"for i, antenna_rx_i in enumerate(Antennas_RXs):\n",
" tx_x, tx_y, tx_z = antenna_tx\n",
" rx_x, rx_y, rx_z = antenna_rx_i\n",
" t_x, t_y, t_z = target\n",
" distance = sqrt((tx_x-t_x)**2 + (tx_y-t_y)**2 + (tx_z-t_z)**2)\n",
" distance += sqrt((rx_x-t_x)**2 + (rx_y-t_y)**2 + (rx_z-t_z)**2)\n",
" f_if = 2*k*Distance/c\n",
" assert f_if < 1/ts/2\n",
" YIFi = y_IF(f0_min, k, T, antenna_tx, antenna_rx_i, target)\n",
" cube2D[i, :] = YIFi\n",
"\n",
"Z_fft2 = abs(fft2(cube2D))\n",
"Data_fft2 = Z_fft2[0:n_rx//2,0:n_samples//2]\n",
"\n",
"# change scale for 2D plot to display range and velocity values\n",
"# https://stackoverflow.com/a/53746824\n",
"# range formula\n",
"ranges = arange(0, fs*c/2/k, fs*c/2/k/n_samples)\n",
"no_labels = 10 # how many labels to see on axis x\n",
"step_x = int(n_samples / (no_labels - 1)) # step between consecutive labels\n",
"x_positions = arange(0, n_samples, step_x) # pixel count at label position\n",
"x_labels = ranges[::step_x] # labels you want to see\n",
"plt.xticks(x_positions, x_labels)\n",
"\n",
"# angle of arrival\n",
"# angles = arange(-90, 90, 1)\n",
"# no_labels_y = 5 # how many labels to see on axis y\n",
"# step_y = int(n_chirps / (no_labels_y - 1)) # step between consecutive labels\n",
"# y_positions = arange(0, n_chirps, step_y) # pixel count at label position\n",
"# y_labels = speeds[::step_y] # labels you want to see\n",
"# plt.yticks(y_positions, y_labels)\n",
"\n",
"# adding aspect=10 to have a more readable image\n",
"# since we have ~512 samples\n",
"# and only ~16 antennas\n",
"plt.imshow(Data_fft2, interpolation='nearest', aspect=10)\n",
"\n",
"# plt.rcParams[\"figure.figsize\"] = (10,100)\n",
"plt.xlabel(\"Range (m)\")\n",
"plt.ylabel(\"AoA\")\n",
"plt.title('AoA-Range 2D FFT')\n"
],
"metadata": {
"id": "qCMP9W4XtJEo",
"outputId": "df18228e-50d9-4e7d-f49c-6f7a76fe2630",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 444
}
},
"execution_count": null,
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"Text(0.5, 1.0, 'AoA-Range 2D FFT')"
]
},
"metadata": {},
"execution_count": 44
},
{
"output_type": "display_data",
"data": {
"text/plain": [
""
],
"image/png": "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\n"
},
"metadata": {
"needs_background": "light"
}
}
]
},
{
"cell_type": "code",
"source": [
"# 3 targets FFT AoA MRE\n",
"from numpy import abs ,angle, arange, arcsin, cos, pi, sin, sqrt, tan, zeros\n",
"from scipy.fft import fft, fft2\n",
"import matplotlib.pyplot as plt\n",
"\n",
"def y_IF(f0_min, slope, T, antenna_tx, antenna_rx, target, v=3e8):\n",
" \"\"\" This function implements the mathematical IF defined in latex as\n",
" y_{IF} = cos(2 \\pi [f_0\\delta + s * \\delta * t - s* \\delta^2])\n",
" into following python code\n",
" y_IF = cos (2*pi*(f_0 * delta + slope * delta * T + slope * delta**2))\n",
" Parameters:\n",
" -----------\n",
" f0_min: float\n",
" the frequency at the begining of the chirp\n",
" slope: float\n",
" the slope with which the chirp frequency inceases over time\n",
" T: ndarray\n",
" the 1D vector containing time values\n",
" antenna_tx: tuple of floats\n",
" x, y, z coordinates\n",
" antenna_rx: tuple of floats\n",
" x, y, z coordinates\n",
" target: tuple of floats\n",
" x, y, z coordinates\n",
" v: float\n",
" speed of light in considered medium\n",
" Returns:\n",
" --------\n",
" YIF: ndarray\n",
" vector containing the IF values\n",
" \"\"\"\n",
" tx_x, tx_y, tx_z = antenna_tx\n",
" rx_x, rx_y, rx_z = antenna_rx\n",
" t_x, t_y, t_z = target\n",
" distance = sqrt((tx_x-t_x)**2 + (tx_y-t_y)**2 + (tx_z-t_z)**2)\n",
" distance += sqrt((rx_x-t_x)**2 + (rx_y-t_y)**2 + (rx_z-t_z)**2)\n",
" # delta = sqrt((A.x-target.x)**2+(A.y-target.y)**2+(A.z-target.z)**2)/3e8\n",
" delta = distance/v\n",
" YIF = cos(2 *pi *(f0_min * delta + slope * delta * T + slope * delta**2))\n",
" return YIF\n",
"\n",
"f0_min = 60e9\n",
"c = 3e8\n",
"# lambda ~5mm at 60GHz\n",
"lambda0_max = 3e8/f0_min\n",
"n_rx = 32\n",
"k = 200e12\n",
"n_samples = 512\n",
"fs = 50e6\n",
"ts = 1/fs\n",
"\n",
"antenna_tx = (-lambda0_max/2,0,0)\n",
"T = arange(0, n_samples*ts, ts)\n",
"\n",
"Antennas_RXs = [(i*lambda0_max/2,0,0) for i in range(n_rx)]\n",
"\n",
"phases = []\n",
"i_peaks = []\n",
"cube2D = zeros((n_rx, n_samples))\n",
"\n",
"d0, theta0 = 4, 0\n",
"target0 = (d0*sin(theta0/180*pi),d0*cos(theta0/180*pi),0)\n",
"t_x, t_y, t_z = target0\n",
"\n",
"d1, theta1 = 4, 180/3\n",
"target1 = (d1*sin(theta1/180*pi),d1*cos(theta1/180*pi),0)\n",
"t_x, t_y, t_z = target1\n",
"\n",
"d2, theta2 = 12, 180/3\n",
"target2 = (d2*sin(theta2/180*pi),d2*cos(theta2/180*pi),0)\n",
"\n",
"for i, antenna_rx_i in enumerate(Antennas_RXs):\n",
" tx_x, tx_y, tx_z = antenna_tx\n",
" rx_x, rx_y, rx_z = antenna_rx_i\n",
"\n",
" distance = sqrt((tx_x-t_x)**2 + (tx_y-t_y)**2 + (tx_z-t_z)**2)\n",
" distance += sqrt((rx_x-t_x)**2 + (rx_y-t_y)**2 + (rx_z-t_z)**2)\n",
" f_if = 2*k*distance/c\n",
" assert f_if < 1/ts/2\n",
" YIFi0 = y_IF(f0_min, k, T, antenna_tx, antenna_rx_i, target0)\n",
" YIFi1 = y_IF(f0_min, k, T, antenna_tx, antenna_rx_i, target1)\n",
" YIFi2 = y_IF(f0_min, k, T, antenna_tx, antenna_rx_i, target2)\n",
"\n",
" YIFi = YIFi0 + YIFi1 + YIFi2\n",
"\n",
" cube2D[i, :] = YIFi\n",
"\n",
"Z_fft2 = abs(fft2(cube2D))\n",
"Data_fft2 = Z_fft2[0:n_rx,0:n_samples//2]\n",
"\n",
"# change scale for 2D plot to display range and velocity values\n",
"# https://stackoverflow.com/a/53746824\n",
"# range formula\n",
"ranges = arange(0, fs*c/2/k, fs*c/2/k/n_samples)\n",
"# convert to int for ease of dispaly on x_axis\n",
"ranges = ranges.astype(int)\n",
"no_labels = 10 # how many labels to see on axis x\n",
"step_x = int(n_samples / (no_labels - 1)) # step between consecutive labels\n",
"x_positions = arange(0, n_samples, step_x) # pixel count at label position\n",
"x_labels = ranges[::step_x] # labels you want to see\n",
"plt.xticks(x_positions, x_labels)\n",
"\n",
"# angle of arrival labels\n",
"# non linear as we have arcsin to convert phase delta to AoA\n",
"phases = arange(0, 1, 1/n_rx)\n",
"angles = arcsin(phases)*100\n",
"angles = angles.astype(int)\n",
"n_angles = len(angles)\n",
"no_labels_y = 10 # how many labels to see on axis y\n",
"step_y = int(n_rx / (no_labels_y - 1)) # step between consecutive labels\n",
"y_positions = arange(0, n_rx, step_y) # pixel count at label position\n",
"y_labels = angles[::step_y] # labels you want to see\n",
"plt.yticks(y_positions, y_labels)\n",
"\n",
"# adding aspect=10 to have a more readable image\n",
"# since we have ~512 samples\n",
"# and only ~16 antennas\n",
"plt.imshow(Data_fft2, interpolation='nearest', aspect=10)\n",
"\n",
"# plt.rcParams[\"figure.figsize\"] = (10,100)\n",
"plt.xlabel(\"Range (m)\")\n",
"plt.ylabel(\"AoA in degrees\")\n",
"plt.title('AoA-Range 2D FFT')"
],
"metadata": {
"id": "nNU-z_IQdupA",
"outputId": "43f773a8-f369-4211-bbaf-cfcfb4bd6c8d",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 312
}
},
"execution_count": null,
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"Text(0.5, 1.0, 'AoA-Range 2D FFT')"
]
},
"metadata": {},
"execution_count": 4
},
{
"output_type": "display_data",
"data": {
"text/plain": [
""
],
"image/png": "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\n"
},
"metadata": {
"needs_background": "light"
}
}
]
},
{
"cell_type": "markdown",
"source": [
"## Bartlet based AoA\n",
"\n",
"* Eq RXX_1\n",
"\n",
"$$ R_{xx} \\approx \\frac{1}{N} \\cdot \\displaystyle\\sum_{k=0}^{n} X(t) \\cdot X^H(t) $$\n",
"[source Eq 14.](https://www.mdpi.com/2411-5134/4/3/43/pdf)\n",
"Where X(t) is\n",
"$$ X(t) =\n",
"\\begin{pmatrix}\n",
" x_1(t_1) & x_1(t_2) & \\cdots & x_1(t_n) \\\\\n",
" x_2(t_1) & x_2(t_2) & \\cdots & x_2(t_n) \\\\\n",
"\\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
" x_M(t_1) & x_M(t_2) & \\cdots & x_M(t_n)\n",
"\\end{pmatrix} $$\n",
"\n",
"and 7.22:\n",
"\n",
"* PB(θ) = /aH(θ) * Rxx * /a(θ)\n",
"\n",
"
\n",
"\n",
"
\n",
"\n",
"The non-correlation constraint for the correlation matrix, implies that the targets _cannot_ be in the same range bin !!\n"
],
"metadata": {
"id": "tHccDScatCcT"
}
},
{
"cell_type": "code",
"source": [
"from numpy import arange, array, cos, column_stack, exp, identity, matrix, random, pi, sin, sqrt, zeros\n",
"import matplotlib.pyplot as plt\n",
"\n",
"n_rx = 6\n",
"# M = n_rx\n",
"f0_min = 60e9\n",
"c = 3e8\n",
"# lambda ~5mm at 60GHz\n",
"lambda0_max = 3e8/f0_min\n",
"k = 200e12\n",
"n_samples = 512\n",
"fs = 50e6\n",
"ts = 1/fs\n",
"\n",
"def a(theta, M=n_rx):\n",
" # a_theta is the steering vector - defined by the sensing array\n",
" theta=theta/180*pi\n",
" return array([exp(n*1j*pi*sin(theta)) for n in range(M)])\n",
"\n",
"def R_est(Xs):\n",
" n = Xs.shape[1]\n",
" X = matrix(Xs)\n",
" Rxx = X*X.H\n",
" Rxx = Rxx/n\n",
" return Rxx\n",
"\n",
"def Rxx_expl(thetas,M=6,s2_n=0.1):\n",
" \"\"\"\n",
" A: MxD matrix of steering vectors\n",
" M: number of elements in array\n",
" D: number of targets\n",
" assumed: D"
],
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEYCAYAAABMVQ1yAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO2debgU1bW333UYlVEEkVHQIApGRUDjFZUoihAVZ8UJY9TkCzhl0BjNlTjEKclNHBNnxYAakVxncEIjIgjKRREHFAigIMgMh3l9f6xqT3Hs6fTp7qrus97nqae6a9fetbp69692r7332qKqOI7jOKVPRdQGOI7jOPnBBd1xHKdMcEF3HMcpE1zQHcdxygQXdMdxnDLBBd1xHKdMcEF3HMcpE1zQHcdxygQX9AIhIvNEZEDUdiRDRGaJSP8c8j0sIjcUwKSCIyLdRWSGiKwRkUuitsdJTinXsThQJwU9ENtKEVkrIitE5HkR6VTL8nIS72zyVrN3SVDpm+ZmLahqT1WdmGv+EuUK4HVVbaaqt+ejQBHpJSKTRGS9iEwVkc7B8Xki0iUf10hyzUYi8oCIzA8eTjNEZFAovZWIjBORdcE5Z2ZR5q9E5CsRWSkir4vIDhnOnygiG4L6uFZEPqmWXmMbnPxQJwU94DhVbQq0A5YAd9S0ABGpn3erUpOw9wCgD3BNTQsosr1ZUyS7dgNm1TRTKttEpCPwAnALsDPwBTl8JzlQH1gAHA60CK75ZOgBchewCWgLnAXcIyI9UxUmInsBNwBHA62B3wPbsrBjhKo2Dbbu1dJqZEMxiGvdzzd1WdABUNUNwFNAj8QxEfmNiHwetIA+EpETQ2nzRORKEZkJrBORMUBn4NmgtXJF9WuISHsRGSsiS0VkbuIvv4iMypQ3ib2LgBeBfdKVncbe+uF/BSKyd9DiWhm4Yo4P5e0lIu8F9+EJoHG1stPlPUBE3g/y/lNEngj/lU5hV6b7/msRmRm0/B4QkbYi8mJw/isislOyeyYirwE/BO4M7vOeGWz/jm1Jiv0TcJ+qPqOqlcDjQN8U179SRBYFdn4iIkcmOy8bVHWdqo5U1Xmquk1VnwPmAr1FpAlwMvA7VV2rqm8BzwDnpClyC7AVmK+qW1R1oqpuzNW+mtqQRR1LWb9zrGPpykuXlrfvsKCoap3bgHnAgOD1jsAjwKOh9FOB9tgD73RgHdAulHcG0AnYoXp51a8RlDEd+G+gIbA71pobmCpvBns7YS3N6zOVncleoAEwB/htkP8IYA3QPXg/H7g8OO8UYDNwQ1BGNnkvDc47CWux3ZDBrkz3/R2s1dcB+Bp4D+iFicBrwLVp7uFE4IJMtqeyrVpZzYENQOfQsZOAyUnO7Y61qNsH77sAewSvnwNWptiey7Iutw1s2Su4F+urpf8KeDZN/ubYA2EC0DjLa04ElgLLgElA/1Ba1jZkUcdS1u9c6liG8tKlpfwO47ZFbkAkH9q+6LXBD2cz8CXw/TTnzwCGhPKen6S8VIJ+EPCfamlXAQ+lypvB3vnA3UEFTVt2JnuBQ4HFQEUobQwwEjgsuC8SSns79GPLlHdRtbxvJfmxnZ/hc1e/72eF0sYC94TeXwz8K01ZE6kS9JS2Z2MbcCLWqg0LcCXweJJzv4c9fAYADfJcjxsArwB/D3+uaudcCExMU8ZLQZ25K3jdODj+GHBxijwHAc2ARsAw7GG4R01tyKKOpazfudSxDOWlSyvYd5jvrU74lVJwgqq+IiL1gCHAGyLSQ1UXi8i5wC+wJzFAU8y/mGBBDa6zG9BeRFaGjtUD/p2LveEDIpJt2ansbQ8sUNWwz3Q+1gJuDyzSoGaH0nLNm8yG7Y5lcd+XhF5XJnmfbUdxOtvT2ZugC/CMqoZdQi9ggrgdqjpHRC7DHnQ9RWQ88AtV/TJLW5MiIhXAKKxVOiI4vBZrcYdpjglusjK6A/2A47AH1GPAv0TkJOBg4KZk+VR1SujtIyIyFBiM9UPVxIZMdSxd/c6ljqUrL2Vaob7DQuA+dNWtqvo0VqH7BSJ5H/Yj2VlVWwIfAhLOVr2YNJdYAMxV1ZahrZmqDs4ibyYylZ3Jvi+BToE4JOiMtXy+AjqIiFRLyzVvslFE39qV5X3PF+ls/45tSWgErE+8EZGuWEf1M8lOVtXRqtoPEw3FOlIJ/P9rU2wvprp4cF8fwNwtJ6vq5iDpU6C+iHQLnb4fqTuD62OiJcHDbRj2O3gfmK2q2XYiK1XfU01syFTH0tXvGtexDOWl/S2l+g7jRp0XdDGGADsBs4Em2Be2NEj/MUEHZBqWYD63ZEwF1gSdKjuISD0R2UdE+maRNxOZys7EFEyYrhCRBmJj04/DOvgmYx1mlwRpJwEH1iDvVmBE0BE1pFreZORy33Mlne3Z8C5weNCJ1gkYDVytqsurnyg2/v0IEWmE+borCUaRqOogrRopUn0bVL2sEPcAe2MjnyoTB1V1HfA0cJ2INBGRQ7B/n6NSlPMx8Blwt4i0wFw4LwN7AmuriWXi87QUkYEi0jj4bs/C3B8v5WBDpjqWrn7nUsfSlZcyLd13GDfqsqA/KyJrgdXAjcAwVZ2lqh9hIxgmY2L7fazjJx03AdeIjZj4VThBVbcCxwL7Y51Py4D7sSFnafNmIouyM+XfhAnZoCDv3cC5qvpxkHYScB6wHOukfLqGeX+C+ZfPxjoAU46eyPG+50Q627Ms4jXs83yK+W1Hqep9Kc5tBNwcXGcxsAvmm82J4J/MT7HvfHGoRX9WcMrPsf6Vr7F+gf+XqqUdqj8tgc+xfyj9gN7Y8NhkE3waBMcTnaIXY+7AT0PnZGVDFnUsZf3OsY6lKy/dbymv32Ehke1dUI5TGERkCvA3VX0oaluc8sTrWN1uoTsFREQOF5Fdg7/Dw4B9SdJp6Di54nXsu9TlUS5OYekOPIn5xr8ATlHVr6I1ySkzvI5Vw10ujuM4ZYK7XBzHccqEyFwurVu31i5dukR1ecdxnJJk+vTpy1S1TbK0yAS9S5cuTJs2LarLO47jlCQiMj9VmrtcHMdxygQXdMdxnDLBBd1x4oYqPPUUnHwy9O4NY8bYsVJnxQoYORJ++EPYe2844QS47z7YmHP4dacaLuiOEzduvx1OPRXeeQc2bIAzzzRx3xbL8CHZ8eST0LUr/P739pn22gv+7//gootg//3hrbeitrAscEF3nDjxyivwy19a63XBApg5E66/HsaNgztqvEpiPLj7bjjjDOjZ00R88mT7PF98AS++CJWVcMQR9q/EqRWRTSzq06eP+igXxwmxcSPssQe0bGmi16yZHVeF44+HCRNg2jT4/vejtbMmjB0Lp5xi9j/+OOyQZP3pVatg8GD7RzJ6NJx+evHtLCFEZLqq9kmW5i10x4kLjz4KixbBX/5SJeYAIvDgg9C0KVx9dXT21ZTPP4fzz4cDD4R//jO5mAO0aGEPq0MOgWHD7KHl5IQLuuPEgS1b4JZboG9fODLJ+sNt2sAll8Czz8KHHxbfvpqybRucdRbUqwdPPAENG6Y/v0kTa83vuiuceCJ8/XVx7CwzXNAdJw489ZS1aH/7W2uRJ2PECNhxR7jttuLalguPPAJTpsBf/wrZzghv08Z8619/DT/7WXmM7CkyLuiOEwcefBB23918zanYeWe48ELzMy9cWDzbasrq1XDVVXDwwXD22TXL26tXVSfwmDGFsa+McUF3nKj5+mt49VUYOhQqMvwkL77Y3DOPPVYc23LhlltgyRIbfpnq30Y6fvlLexiMGAFLl+bfvjLGBd1xouapp8znfMYZmc/dYw/rPBw1Kp4uiZUr4c47bWRLn6QDMTJTrx7cfz+sWVNancAxwAXdcaJmzBgbo71Plmtin3MOfPQRvPdeYe3KhTvvNJfLb39bu3J69LBO4Pvvh3ffzY9tdQAXdMeJkoULbZZkNq3zBKedZqNGRo0qnF25sG6dDbkcPNh84bXl2mthl13g8svj+W8khrigO06UvPCC7U86Kfs8O+0Exx5rE3W2bi2MXbnw2GPwzTfWIZoPmje32C+TJtmMUicjLuiOEyXjx0OnThasqiaceqp1PE6ZUhi7aooq3HWXxWU55JD8lXv++Tb65+qrSzuWTZFwQXecqNiyxUa3DBxY89EggwZBgwbwr38VxraaMmkSfPABDB+e28iWVDRsaAG9ZszwWC9Z4ILuOFExZYrFMRk4sOZ5W7SwgFbjxsXDv3zXXWbT0KH5L3voUOsw/t3v7CHopMQF3XGiYvx4G3eebKp/NpxwAsyZA7Nn59eumrJyJTz9NJx7rk3hzzf16sENN8Cnn1q8GyclLuiOExXjx8NBB1knZy4MGWL7cePyZ1MuPP00bNpkwykLxfHHW5CvkSN9QYw0uKA7ThSsXm1RBQcMyL2Mdu1M5J5/Pn925cLo0TbhKdeJRNkgYq30BQu8lZ4GF3THiYK337ZRG4cdVrtyEnHEly3Lj1015auv4PXXbVWlfHaGJmPAAItGecst7ktPgQu640TBv/8N9etbzJLaMHiwdYpOmJAfu2rKk0/ag6kQnaHVEbEZqJ9/btd1voMLuuNEwZtvwgEH1L4TsXdvCzubmKBUbMaMsbHnNR1HnyvHH29hAW66ycelJ8EF3XGKzYYNMHVq7d0tYKNkjjnGOliLPWv0889t6OWZZxbvmhUVNhP1ww/hueeKd90SwQXdcYrN1Kk2KuTQQ/NT3uDB5kMv9tJtjz9u+2KvAXrGGdC1K9x4YzzG4McIF3THKTZvvmn7fv3yU97RR1vLtZhuF1Ub3XLoodC5c/GuC9b3cOWV9mB87bXiXjvmuKA7TrF5+23zA7dqlZ/yWrWyztViCvoHH1gI32J0hiZj2DAbtvmHP0Rz/Zjigu44xUTVWpY/+EF+yx082FwuS5bkt9xUjB5tLeVTTy3O9arTuLGtbPTaazZs0wFc0B2nuHzxhYWYPfDA/JY7eLDtX3opv+UmY9s2858fdRS0bl3466Xipz+1fyfeSv8WF3THKSZTp9r+oIPyW+5++5kLohhul8mTYf784o5uSUbTpnDppfDsszBzZrS2xAQXdMcpJlOmwA47ZL/cXLaIWCt9/PjCz6IcM8ZcHolYMlEyYoQJu7fSARd0xykuU6faZKD69fNf9uDBFo538uT8l51gyxabpXn88dCsWeGuky2tWlkM9ieftGiMdRwXdMcpFps22cLO+fafJxgwwB4UhXS7vPoqLF0a3eiWZFx+OTRqBDffHLUlkeOC7jjFYuZMC/2ab/95gubNbVx4IQV99GhbyGLQoMJdo6a0bQsXXWSLZs+fH7U1keKC7jjFolAdomEGDbIHx8KF+S+7stJir598srWI48Svf239CLfeGrUlkeKC7jjFYsoU2GWXws6sTAxffPHF/Jf9/POwZk30o1uS0bEjnHcePPCAhfSto7igO06xmDrVWueFjBveo4c9MArhdhk9GnbdFfr3z3/Z+eDKK2HzZvjTn6K2JDJc0B2nGKxcCR9/XLgO0QSJ4YuvvJLfpdpWrrSHxOmn2xqfcWSPPayz9m9/i27Bj4hxQXecYpCIhFhI/3mCwYNh7Vp46638lTlunD0g4jS6JRm//S2sWwd//WvUlkSCC7rjFIMpU2zft2/hr3XEEdCwYX796GPGwO67F/4fRm3p0QNOOgnuuMPG5NcxXNAdpxhMnQrdu0PLloW/VpMm5ufOlx998WIbfz50aOHXDc0HV19tYv6Xv0RtSdGpkaCLSCcReV1EPhKRWSJyaXC8lYi8LCKfBfudCmOu45QgqtZCL2brdvBgmD0b5s6tfVlPPFG8dUPzwQEHWCv9T3+yQGh1iJq20LcAv1TVHsAPgOEi0gP4DfCqqnYDXg3eO44DsGCBhbUthv88QWL44jPP1L6shx+2cAU9e9a+rGJx3XXWj1DHxqXXSNBV9StVfS94vQaYDXQAhgCPBKc9ApyQTyMdp6RJ+M+L2ULv1g323dda17VhxgzbzjsvL2YVjZ494eyzzZdeh8al5+xDF5EuQC9gCtBWVRN3bTHQNkWei0RkmohMW7p0aa6XdpzSYupUm1m5337Fve4ZZ1igrnnzci/jkUesg7VU3C1hRo60cek33hi1JUUjJ0EXkabAWOAyVV0dTlNVBZKu3Kqq96pqH1Xt06ZNm1wu7Tilx5Qp0KuXCWMxSSze/OSTueXftAkee8wiK+68c/7sKha77w4XXAD33lu7h1oJUWNBF5EGmJj/Q1WfDg4vEZF2QXo74Ov8meg4JcyWLTB9ejTD/RLDDB9/PLf8Y8faBJ3zz8+vXcXkmmtsItS110ZtSVGo6SgXAR4AZqvqn0NJzwDDgtfDgP/Nj3mOU+LMmgXr1xe3QzTM0KHw/vu2qHNNueMO+N73YODA/NtVLDp0sFWNHn0U3n03amsKTk1b6IcA5wBHiMiMYBsM3AwcJSKfAQOC947jRNEhGuacc8x/f889Ncs3fbr530eMgIoSn65y9dUWYvfSS20IaRlT01Eub6mqqOq+qrp/sL2gqt+o6pGq2k1VB6jq8kIZ7DglxdSptqrOHntEc/2dd7bO0VGjYPXqzOcnuP12m6BUaqNbktGsGdx0kz2gxoyJ2pqCUuKPXseJOYkJRVHOsPz5z21M9qhR2Z0/Zw784x/wk5/YYhblwLBhNpb+iiss1kuZ4oLuOIVizRrzoUflP0/Qty/06WNT4Tdvznz+yJE2IueqqwpuWtGoqLCAXYsWlfVkIxd0xykU06ebzzbqgFYiJtJz5tgQvnTMmmVxzy+5xGKflxOHHGKdxLfeaveiDHFBd5xCkVhyLmpBBwsF0L8//P73qX3pW7bAT39qa5NecUVRzSsat91m/z4uvNDi05QZLuiOUyimTLGx4K1bR22JtdJvuw2WLoXLL08+2uOmm2DSJLj7buvILUc6dLCgXRMnwn33RW1N3nFBd5xCkVhyLi706WND+B58EP74x+3T/vEPa72feWY81wzNJz/5CRx5pC0svWBB1NbklfpRG+A4ZcmXX8LChfESdLAohHPmmEvl7bdtWv9bb5nIH364tc7LHRFrne+zj7mYnn++NOK8Z4G30B2nEMTJfx6mosLC4V57Lbz+uk3rf+wxGD4cJkwon2GKmejaFW6+2VZ1euihqK3JGy7ojlMI3n7bOt969Yraku/SuLGNevnPf+Cjj2yM+p13Fj94WNQMHw4//KHNhs0lNEIMcUF3nEIwaZJNZGncOGpLUtO8Oey9NzRoELUl0VBRYUM0W7SAU0+1eQMljgu64+SbDRtg2jQb9+zEm113tXAAn31mQxlLPNaLC7rj5Jv33rNY4i7opUH//nDDDba6U4l3CrugO06+mTTJ9v/1X9Ha4WTPlVfCj34El10Gr74atTU544LuOPlm0iRb03OXXaK2xMmWigobi7/XXnDyyRYCoQRxQXecfKJqI1zc3VJ6tGhhY9J33BGOPhq++CJqi2qMC7rj5JNPPrHp9S7opUnnzjYef8MGGDCg5GaSuqA7Tj55/XXb9+8fqRlOLdhnH3jpJfjmGzj0UPj886gtyhoXdMfJJ6+/Dh07RrdCkZMf+vaF116zSVf9+tnIpRLABd1x8sW2bSboRxxRNrFB6jS9e8Mbb9jEq8MOg2eeidqijLigO06+mDULli2z6eROedCzp4VB3ntvGDLEolVu3Rq1VSlxQXecfPHaa7Z3QS8v2rWDf/8bLrgA/vAHa63HdMUjF3THyRevvWYLWuy2W9SWOPmmcWMLufvYYxbQbL/9LFrjpk1RW7YdLuiOkw82bTJBHzAgakucQnLWWRaZ8eijbRHtHj0sHHE2i28XARd0x8kHb75pIyKOPTZqS5xC07EjjBsHL7xgESt//GPo3t1a8GvXRmqaC7rj5IPnnrO/5UceGbUlTrEYNAimT4dnn4Wdd4aLLoK2ba0V/8ILkbhjRCMKF9mnTx+dNm1aJNd2nLyiarFbune3qeNO3UPVlvL7xz/gySdhxQp7wPfta7OG+/a1vpVOnaBNm1oNaxWR6araJ1la6a0pevfdcOONFneheXNo2dKWk+rZ0/xZ++1nT0vHKRaffmqzCX/5y6gtcaJCxGaVHnoo3H47jB9vcxImTbIFubdsqTq3USNbIeqCC/JuRukJ+h57wDHHwOrVti1fbuNEV660dBFb9mvAADjqKFv4tq6uyOIUh8SEkx/9KFo7nHjQsCEcd5xtAJWVNjJmwYKqbZ99CnLp8nC5qMLixTax45134OWXYfJk63lu0wbOOAPOPtv+9vgMPiffHHAA1KsH774btSVOHSCdy6U8OkVFbPD/gAFwzTU2XXf5cuuJ7t8f7r0XDjoIvv99e71+fdQWO+XCrFnw/vtwzjlRW+I4ZSLoyWjaFE44wTooliyxIUUNG8JPf2rDjn7zGzvuOLVh1ChrnZ9xRtSWOE4ZC3qYFi2sA2L6dJvCe+SRcNtt1pl6+eXw5ZdRW+iUItu22aiGgQN9dSInFtQNQU8gYqEw//lP+PhjOP10uOMOm6598cWwcGHUFjqlxPjxVmfc3eLEhLol6GG6dYOHHrIhZ+ecA3/7m42g+fnPXdid7LjlFujQAU46KWpLHAeoy4KeYPfdzb8+Zw6cd5693mMPGDECFi2K2jonrkyebJ3vv/yl9c04Tgwoj2GL+WTePAuR+dBD1tl10UXWgdq+fdSWVbFtm3XoLlgAq1bZ+ocNGlhfQfv2Nhutwp/VgMWu/uwzmD3bRjftsAPsuaet7l6/FtMwhgyx/pj//Mc64B2nSKQbtuiCnoq5c21G6sMPm1heeCFcdpm16IvNsmXw6qs2znnaNOvcTRcEqFkzGxvdpw/8139ZZLi6JDqq1np+5BH417+qJp2Fad3aRkENHw7771+z8p9/3oJwXX+9DZN1nCLigl4bvvjChP3RR61lPGSIjYzp169wk5RUbWzz889bkJ8pU+xYo0YmPn372goqnTrBTjtZzIhNm6y1vnAh/N//mfDPmAEbN1q+I480ATvhBJtsVWhUYelSs2ftWnvftKn5nNu2Lcy927IFxo61EUzTp9s/liFDbMGJffaxUBFr1tisvRdftBme69bZKJXrr7f7momVK62sli3tGo0a5f9zOE4a0gk6qhrJ1rt3by0pFi5Uveoq1VatVEG1e3fV669XnTs3P+UvX6761FOq55+v2q6dXQNU+/ZVHTlSdcoU1U2balbmpk2qr7+uetllql27Wnn16qkOGKB6772qS5fmx3ZV1c2bVd99V/W221R/9CPVFi2qPkP1rWlTs+G661TfeEN1w4baXXvdOtU776z6jHvuaZ+vsjJ9vhUrVG+6SbV1a8t34omqH36Y+vzKStVjj1WtqFCdOrV2NjtOjgDTNIWuegu9pqxfD6NH24SSN9+0Y336WCuwf39ruTdvnr4MVfO9zphhre9XXrHW3rZt1qocOBAGD7aYNW3b5sduVQvM/89/whNPmF+5Xj1ruZ92mrXcaxLUbMsWWwn9jTdg4kTzJ69ZY2l77mkxdPbZx/5FNG9uLfI1a8zvP3u2RaabOdPOb9LE3ELHHmufe9dds7Nh8WKb+XvHHeaW+sEP4Mor4fjja9aHsGYN/OUvFkRpzRoLE3HttdY5nmDRIhg2zFxfd91lo6EcJwKK4nIRkWOAvwL1gPtV9eZ055esoIeZP9/E/cUXLYZMYtWStm2hSxcLl9mypXW+rVoF33xj22efVfl169UzIRowwLaDDip8MDFVc8s8+aRtn39ugrv//nDwwRYioWtXmyzTqJF9ruXLbYjnBx/Y9v77VQK+114m4P37275du+zsWL7cHgQvvWTupQUL7HifPhZY7cAD7eHQvr3dw9WrzQX2zjswYYKJ67ZtFgTpiissTGltXDnffAO33moPiMpKux977WXf3csv2zkPPADnnpv7NRynlhRc0EWkHvApcBSwEHgXGKqqH6XKUxaCHmb9ehOad96xDtW5c23EzNq1JogtW0KrVrZ17Wpisd9+Jp5Rdlgm/PXPPmut7WnTqoQ6Gc2aWcu7Vy8T78MOy75FncmODz6whSKee846gMMhR6uz555wyik2h2CvvWp//TBffmkdquPHW8u8cWN7wIwYEU2nuOOEKIagHwyMVNWBwfurAFT1plR5yk7Qy4WEO2jBAuvU3LzZWsc77WQPot12K07EyspK+xcxdy589ZW1xJs0sevvv3+8hpE6ThEpxgIXHYAFofcLgYOSGHIRcBFA586d83RpJ6+ImGhGvXL9DjuYK+oHP4jWDscpIYo6+0RV71XVPqrap00xhs45juPUIfIl6IuATqH3HYNjjuM4TpHIlw+9PtYpeiQm5O8CZ6rqrDR5lgLza33xwtIaWBa1EVlQKnZC6dhaKnZC6dhaKnZCvG3dTVWTujjy4kNX1S0iMgIYjw1bfDCdmAd5Yu9zEZFpqTof4kSp2AmlY2up2AmlY2up2AmlZWuYvC0SraovAC/kqzzHcRynZnhIPsdxnDLBBT0990ZtQJaUip1QOraWip1QOraWip1QWrZ+S2SxXJziIyKzgOGqOjGHvA8DC1W1pOLFikh34AlgD+BqVb09YpOcFJRqHYsTdbqFLiJnisg0EVkrIl+JyIsi0i9qu8KIyDwRqQxsXCIiD4tITrECVLVnLmJe4lwBvK6qzfIp5iLSS0Qmich6EZkqIp2D4/NEpEu+rhO6XiMReUBE5ovIGhGZISKDqp3TSkTGici64LwzM5T5q6DerxSR10VkhyzsmCgiG4L6uFZEPsn1+k7+qbOCLiK/AP4C/AFoC3QG7gaGRGlXCo5T1abAAUAfoEYtmGBYaewokl27AWlHXKUilX0i0hEbAHALsDPwBTX8TnKgPjYb+3CgRXC9J6s9PO4CNmH1+SzgHhHpmawwEdkLuAE4Ghui93tgW5a2jFDVpsHWPZfrF4u41v2CkSqubjlv2A9iLXBqmnN+A3wOrAE+Ak4Mpc0DrgqOrwAeAhqH0vcGJgIrMTE5vlreXwEzgVWYO6BxGjvmAQNC728DngtetwfGAkuBucAl1fJdGVxnIyYI35aVzsYgvRfwXvD5nwAeB27IMu8BwPtB3n8G+W9IY1fKex3K89FXb2YAABr+SURBVOsgzzrgAUw0XgzyvALslOTevQZsBTYE3/eeWdj+HfuSlPsEcF3o/QnA+6H8XYLXV2LzMtYAnwBH5rkezwRODl43wcR0z1D6KODmFHm/F9zL5jW85kTggiTHa3T9LOpYyrqdYx3LVF6631JBv8e81omoDYjkQ8MxwJZkP9bQOacGX3IFcHpQ+duFKsyH2OzYVsCkUGVqAMwBfgs0BI4IKkL3UN6pQdmtgNnAz9LYMY8qEe6EidD1gV3Tgf8OrrM71lIcGMo3I8izQ7isLGxsiE36ujw49xRgM9aiyzbvpcG5J2E/9BvS2JXyXofyvIOJeAfga0wIegGNMeG+NsX9m0ggQJlsT2VftfKaYw+IzqFjJwGTq53XHWtRtw/edwH2CF4/hz1Qkm3PZVmH2wZ27BW87wWsr3bOr4BnU+RvjgnXBNI0KFLcz6XYpJtJQP8cr5+ujmWq2zWqY1mUlzI93fcYxy1yAyL50PZ3cHEN88wAhoQqzM9CaYOBz4PXhwKLgYpQ+hgsGmUi79mhtFuBv6W57jysdbkyqMR3B5X0IOA/1c69CngolO/8JGUNyMLGw4AvCTrNg2NvBz+2bPIuqpb3rWo/tvNTfd7q9zqU56zQ+7HAPaH3FwP/SlHWRKoEPa3t2dgHnIi1+sMiXAk8Xu2872EPngFAgzzX3wbYv5K/h44dWr1OAxcCE1OU8VJQX+4KXjcOjj8GXJzm2gcBzYBGwDDsgbhHDtdPV8cy1e0a1bEsykuZXsjvsRBb3fIvVfEN0FpE6qtq0qDbInIu8AvsiQzQFPM1JghHl5yPtTAJ9gtUdVu19A6h94tDr9eH8qbiBFV9pZp9uwHtRSS8AnI94N8pbAyTycb2wCINanYoPde81e3Y7n0W9xpgSeh1ZZL32XQUZ/PdJLM3TBfgGVU9MXFARF7ARPFbVHWOiFwGjAR6ish44Beq+mUWdqZERCowV8YmYEQoaS3W6g7THBPc6mV0B/oBx2EPp8eAf4nIScDBQMqw16o6JfT2EREZijVo3sr2+gHp6limul3TOpapvJTphfoeC0Vd7RSdjPnWTkiWGIjlfdgPZmdVbYm5WMKBwMPByDpjrQ2CfafghxdOz3ewsgXAXFVtGdqaqerg0DmaIm8mG78COohsF/i8cy3yhu/VdnZlea/zRbbfTar7BtYyXZ94IyJdsY7qZ6qfqKqjVbUfJhiKdaISjKZam2J7MdWFg3ua6D84WVU3h5I/BeqLSLfQsf1I3iFcHxMsCR5uwzBhfx+YrRnCdlT/mNh3VZPrQ/o6lqlu16iOZVFe2vRU32McqZOCrqqrMH/ZXSJygojsKCINRGSQiNyKdfAo5itERH4M7FOtmOEi0lFEWgFXY50yAFOwH/wVQZn9sZbQ43n+GFOBNSJypYjsICL1RGQfEcli6fqMNk7G+hguCdJPAg6sQd6twAgRqS8iQ0J5k5HNvc4X+fhu3gUOF5H2ItIJGI2Nb18ePklEuovIESLSCPN1VxKMIlHVQVo1SqT6Nqj6BUPcg3XqHqeqleEEVV0HPA1cJyJNROQQbMTWqCTlfAx8BtwtIi0wF87LWKfx2mpCGf5MLUVkoIg0Dr7bszD3x0s1vD6kr2OZ6nZN61im8lKmp/se40idFHQAVf0T9jf/GkxMFmCtxH+pLZ33J6ziLAG+j3UAhRmNdSh9gY3QuCEodxMmEoOwjqO7gXNV9eM8278VOBbYH+vcWgbcj43gyZQ3rY1B+knAecByrKPy6Rrm/QnmXz4b6wTcmMKWbO51XsjTd/Ma9nk+xdwMo1T1viTnNQJuDq6zGNgF88vmRPBP5qfY97041KI/K3Taz7H+la+xvoH/l6y1Hao7LbG6uwhzwfTGRo/ckMKMBkFaolP0Yswd+GlNrh/YkK6Opa3bOdSxTOWlS8/r91hofKZoDojIPKyj7ZVM5zogIlOwjt+HorbFKU+8jhl1toXuFA4ROVxEdg3+Dg8D9qVap6Hj1AavY8mpq6NcnMLSHXgS849/AZyiql9Fa5JTZngdS4K7XBzHccqEjC4XEXlQRL4WkQ9TpIuI3C4ic0RkpogckH8zHcdxnExk43J5GLgTeDRF+iCgW7AdhA2tOihToa1bt9YuXbpkZaTjOI5jTJ8+fZnmuqaoqr4p6cOBDgEeDWZtvROMVW2XyZ/VpUsXpk2blunyjuM4TggRmZ8qLR+jXDqw/TTbhXx3KnXCkIvE4o9PW7p0aR4u7TiO4yQo6rBFVb1XVfuoap82bZL+Y3Acp4xZtgwWL858npMb+Ri2uIjt4yh0JP9xSxzHKQOGD4clS2DixKgtKU/y0UJ/Bjg3GO3yA2CVjwd1HCcZixfDIm/uFYyMLXQRGQP0x8LNLgSuxWI6oKp/w5biGowtHLAe+HGhjHUcp7RZvx5WrYraivIlm1EuQzOkKzA8bxY5jlO2uKAXFo/l4jhO0Vi/HjZtgg0borakPHFBdxynaKwPlgbxVnphcEF3HKdorFtnexf0wuCC7jgxZcECuPFGKJf4eareQi80LuiOE1PGjYNrroEvY7kccc3ZuLHq4bR6dbS2lCsu6I4TUxIdh2vWRGtHvli/vuq1t9ALgwu648SUchP0hP8cXNALhQu648SUchN0b6EXHhd0x4kpG4M17F3QnWxxQXecmOItdKemuKA7TkzxFrpTU1zQHSemlFsL3TtFC48LuuPElHIT9EQLfaedXNALhQu648SUhMulXCbhJAS9fXsX9ELhgu44MaVcW+jt2rmgFwoXdMeJKeXWKZrwobdrVz7/OuKGC7rjxJRybKGLQNu23kIvFC7ojhNTyq2Fvn497LgjtGgBlZWweXPUFpUfLuiOE1PKsYWeEHTwVnohcEF3nJhSjoLepIkLeiFxQXecmFJuLpd167yFXmhc0B0nppRjC90FvbC4oDtOTEm00DdtqnpdyrigFx4XdMeJIarWQm/Z0t6XQyvdBb3wuKA7TgzZtMn2rVvbvhwEfd066xRt3tzeu6DnHxd0x4khCRdLmza2LwdB9xZ64XFBd5wYkugQLUdBb9AAGjcuj88UN1zQHSeGJFro5eRySQg6QLNm5fGZ4oYLuuPEkHJroau6oBcDF3THiSHl1kLfuBG2bbNOUXBBLxQu6I4TQ8qthZ6Ihe4t9MLigu44McQF3ckFF3THiSEJl0uzZtCoUemLnwt6cXBBd5wYkmihN2pk4lfqK/wkVityH3phcUF3nBiSaKE3blwe4uct9OLggu44MSTRQi9nQV+71oYzOvnDBd1xYkh1l0s5CrpqlSvGyQ9ZCbqIHCMin4jIHBH5TZL080RkqYjMCLYL8m+q49Qd6oLLBUr/c8WNjIIuIvWAu4BBQA9gqIj0SHLqE6q6f7Ddn2c7HadOUW4t9GSdolD6nytuZNNCPxCYo6pfqOom4HFgSGHNcpy6Tbm10BP2N21qexf0wpCNoHcAFoTeLwyOVedkEZkpIk+JSKe8WOc4dZREC71hw/IQ9BUrQKQqdK4LemHIV6fos0AXVd0XeBl4JNlJInKRiEwTkWlLly7N06Udp/zYuNHEvKLCFoQo9REhK1aYmFcEiuOCXhiyEfRFQLjF3TE49i2q+o2qJlY9vB/onawgVb1XVfuoap82iTnNjuN8hw0bzN0C5TEiZOXKquX0wAW9UGQj6O8C3USkq4g0BM4AngmfICLtQm+PB2bnz0THqXts2GAdolAlfqU8W3TFCthpp6r3LuiFoX6mE1R1i4iMAMYD9YAHVXWWiFwHTFPVZ4BLROR4YAuwHDivgDY7TtmzceP2LXQobfFzQS8OGQUdQFVfAF6oduy/Q6+vAq7Kr2mOU3dJ1kIvZfFbuRL23rvqfWL4Yil/pjjiM0UdJ4aUYws97EOvqLAhjKX8meKIC7rjxJDqnaJQ2uJX3eUC5TEcM264oDtODNm4sXxcLhs22OaCXnhc0B0nhpRTC33lStuHXS7ggl4IXNAdJ4aUU6foihW29xZ64XFBd5wYEu4UbdLEps2XqvglWugu6IXHBd1xYkjY5VLqI0LStdBLebJUHHFBd5wYEu4UhdJuzSYE3X3ohccF3XFiSLiFDqXdmnWXS/FwQXecGBLuFIXSFr90LpcNG2DLluLbVK64oDtODAl3ikLpC3qTJtCgwfbHS330ThxxQXecmLFtG2zaVF4t9Or+c3BBLwQu6I4TMzZtsn25tNBXrvyuuwVc0AuBC7rjxIzE8nPlIujJ4rgAJNa4WbKkuPaUMy7ojhMzEgtEh10uzZuXtqAnc7l07Wr7uXOLa08544LuODEjsdTcDjtUHWvWzIR+8+ZobKoNqVwunTpBvXou6PnEBd1xYsaXX9q+ffuqY6Xsb07lcqlfHzp2hHnzim5S2eKC7jgxY+FC23fsWHWsVAV961abEJVM0MHcLt5Czx8u6I4TMxKC3qFD1bFSXSh61SrbJ/Ohgwt6vnFBd5yYsWiRBeNq3rzqWKm20P/zH9u3a5c8vWtX+OorqKwsnk3ljAu648SMhQvN3SJSdaxUBX3WLNv37Jk8PTHSZf784thT7rigO07MSAh6mFIW9Pr1oVu35Ok+dDG/uKA7TswoJ0H/8EPYc09o2DB5ugt6fnFBd5wYsWWL+ZTLRdBnzUrtbgHYdVebQOVDF/ODC7rjxIglS2yoX3VBT3SQfvNN8W3KlfXrreW9zz6pz6mogC5dvIWeL1zQHSdGJBuDDuay6NYNZs4svk25Mns2qKZvoYMPXcwnLuiOEyNSCTpA794wfXpx7akNH35o+0yCvtde8NFHPnQxH7igO06MyCToCxbA0qXFtSlXZs2yfxbf+1768wYONDGfOLEoZpU1LuiOEyMWLrSwua1afTetd2/bl0orfdYs6N7dhi2mo39/W9Ho2WeLYlZZ44LuODEi2aSiBAccYPtSEPR16+Df/4YDD8x8buPGcNRR8Nxz5nN3cscF3XFiRLIx6AlatDD3RSkI+tixNsTy3HOzO/+448ydVEqdvnHEBd1xYsLq1TBtWvphfqXSMfrgg/bwOfTQ7M4fPNj248YVzqa6gAu648SEsWNt+bmzzkp9Tu/eFvDq66+LZ1dN+fxzeOMN+PGPk7uOkrHrribq//M/viRdbXBBd5yY8Nhj1qo96KDU5wwYYPu77y6OTblw8802YShbd0uCP//ZRrv85jeFsasu4ILuODFg4UJ4/XU4++z0rdpeveCUU+CPf4TFi4tnX7Y88QTcfz/86lep+wJS0b07/OIX8PDD8PTTBTGv7HFBd5wY8Oc/2wiPdO6WBH/4g60ves018RoV8uabcOGFcPDBcMMNuZXxu9/ZP5TTToNRo/JrX13ABd1xIubee813fNFFmSfhgIUAuPRSeOABGD7cAnpFydq1JuBHHGG+8McfhwYNciurSRN4+WU47DBz2ZxwgoUQcLJEVTNuwDHAJ8Ac4DdJ0hsBTwTpU4Aumcrs3bu3Ok5dZtky1UsuUa2oUB08WHXz5uzzbt2qeuWVqqC6996qDzygunx54WytzoYNqm+8oXr55aqtWpkdp52mumpV/sq/+WbVJk2s7EMOUf3jH1WnT1etrMzPNUoVYJqm0FXRDP/ZRKQe8ClwFLAQeBcYqqofhc75ObCvqv5MRM4ATlTV09OV26dPH502bVouzyDHKTk2bbKwuPPmwYwZ8OqrMGECbN5sboo//tGWnaspY8fCddfZ+O2KCth/f/NFd+tmrf1ddrEFmnfayVq/DRrYdPwGDWyrqLAW/tattt+yxUbarFq1/bZsmdk+d66NYvnwQ7O9YUMbnXLFFeZqyTdLlsAjj8Cjj1atflRRYZ+tRw/o3BnatrXPmdi3bAk77mift0kTszHb0TalgIhMV9U+SdOyEPSDgZGqOjB4fxWAqt4UOmd8cM5kEakPLAbaaJrCcxX0CROsEie+IJHvvo5jWqEp1nUS32hd3qdL27jRZkmuXVu1LVtmwwzDv4bddoMhQ0zM0407zwZVePttGD8eJk+Gzz6zoY359q83bGiREbt2hf32M1/3kUduv/ZpIVm0CN56y4R91iwL6LVoUeYY8fXqmbDvuKN9hvr17WFWv/72r5MdC/+O020VFdmfK2J9JYcfntt9SCfoGaIsANABWBB6vxCoPrDq23NUdYuIrAJ2BpbV3Nz0zJkD//u/9rr6jyvZ+0KmObkRfuiV+r76sUaNrKXdtKm1FDt0sJZrx472ulMn2Hff1Ism54IIHHKIbQk2bLAW9TffwIoVsHKlPVw2b95+27ZteyGrV89Er0WL7bdWrcw/XhFhr1uHDnB6kv/9lZUWsGzJEntwrl5tD9Xq2/r1VZ97y5aqffXXlZVVx8IakGnbti37c/v1K8w9ykbQ84aIXARcBNC5c+ecyvj5z22LC9k8CIplQ6GvUVsBdIpH48YWlrYusMMO5nrJUVLKimwEfRHQKfS+Y3As2TkLA5dLC+A7a6uo6r3AvWAul1wMjhsuWo7jxIVs/kC9C3QTka4i0hA4A3im2jnPAMOC16cAr6XznzuO4zj5J2MLPfCJjwDGA/WAB1V1lohchw2feQZ4ABglInOA5ZjoO47jOEUk4yiXgl1YZCkwP5KLZ09rCtCxWwBKxU4oHVtLxU4oHVtLxU6It627qWqbZAmRCXopICLTUg0PihOlYieUjq2lYieUjq2lYieUlq1hfOq/4zhOmeCC7jiOUya4oKfn3qgNyJJSsRNKx9ZSsRNKx9ZSsRNKy9ZvcR+64zhOmeAtdMdxnDLBBd1xHKdMcEGvhog8ISIzgm2eiMwIjncRkcpQ2t9iYOtIEVkUsmlwKO0qEZkjIp+IyMCI7bxNRD4WkZkiMk5EWgbHY3dPAUTkmOC+zRGR2KxwKSKdROR1EflIRGaJyKXB8ZT1IEqC388HgU3TgmOtRORlEfks2O8UsY3dQ/dthoisFpHL4npPM+E+9DSIyJ+AVap6nYh0AZ5T1VoGO80fIjISWKuqf6x2vAcwBjgQaA+8AuypqluLbqTZczQWDmKLiNwCoKpXxvSeZoz/HxUi0g5op6rviUgzYDpwAnAaSepB1IjIPKCPqi4LHbsVWK6qNwcPy51U9cqobAwTfPeLsGiyPyaG9zQT3kJPgYgI9kMZE7UtOTAEeFxVN6rqXGwlqQOjMkZVJ6hqYqG0d7AAb3HlQGCOqn6hqpuAx7H7GTmq+pWqvhe8XgPMxkJXlxJDgEeC149gD6S4cCTwuarGfQZ7SlzQU3MosERVPwsd6yoi74vIGyJyaFSGVWNE4Mp4MPT3NVkM+7j88M8HXgy9j9s9jfO9+5bg300vbMlHSF4PokaBCSIyPQidDdBWVb8KXi8G2kZjWlLOYPsGXBzvaVrqpKCLyCsi8mGSLdwSG8r2X+5XQGdV7QX8AhgtIgVfqyWDrfcAewD7B/b9qdD25Ghn4pyrgS3AP4JDkdzTUkdEmgJjgctUdTUxqgfV6KeqBwCDgOEiclg4MYjIGgufr1gk2eOBfwaH4npP01LUBS7igqoOSJcuFtP9JKB3KM9GYGPwerqIfA7sCRR0YdRMtiYQkfuA54K32cSwzytZ3NPzgGOBIxOhlaO6pxko+r2rCSLSABPzf6jq0wCquiSUHq4HkaKqi4L91yIyDnNnLRGRdqr6VdAn8HWkRlYxCHgvcS/jek8zUSdb6FkwAPhYVRcmDohIm6DTBBHZHegGfBGRfQmbwguZnQh8GLx+BjhDRBqJSFfM1qnFti+BiBwDXAEcr6rrQ8djd0/JLv5/JAT9Og8As1X1z6HjqepBZIhIk6DjFhFpAhyN2RVeO2EY8L/RWPgdtvtHHsd7mg11soWeBdV9aQCHAdeJyGZgG/AzVV1edMu251YR2R/72zoP+ClAEK/+SeAjzMUxPKoRLgF3Ao2Al02TeEdVf0YM72mq+P9R2hTiEOAc4AMJhtMCvwWGJqsHEdMWGBd83/WB0ar6koi8CzwpIj/BwmefFqGNwLcPnKPY/r4l/W3FHR+26DiOUya4y8VxHKdMcEF3HMcpE1zQHcdxygQXdMdxnDLBBd1xHKdMcEF3YoGInCAiKiJ71SDPX4KIeEnrsYj0EZHba2HTeSJyZ675HafYuKA7cWEo8Fawz0gg4idicVcOT3aOqk5T1UvyZmGOiOG/NafgeCVzIieITdIP+Ak2qStxvLGIPCQWU/t9EflhKFt/YBYWcyPpQ0BE+ovIc8HrkUGQpYki8oWIJBV6EfmxiHwqIlOxiTyJ421EZKyIvBtsh4SOvywWn/x+EZkvIq3FYr1/IiKPYrMMO4nIr4O8M0Xk96GyzxaRqWJxt/8uIvWC7eEgHs4HInJ5TjfXqVO4oDtxYAjwkqp+CnwjIokYOsOxGE7fx0T7ERFpHKQlpmqPA34UxDjJxF7AQCymyLXV8wTTvX+PCXk/oEco+a/A/6hqX+Bk4P7g+LVYrPeewFNA51CebsDdQVr34P2BWMCn3iJymIjsDZwOHKKq+wNbgbOCczqo6j7B538oi8/n1HF86r8TB4ZiggkWf3wotnhDP+AOAFX9WETmA3uKyMfAYOAXqrpGRKZgQp0pgNLziYBgIvI1Nj19YSj9IGCiqi4FW70KCxYGFt+nRzCVHaB56J/FiYGNL4nIilB581X1neD10cH2fvC+KSbw+2JB4N4Nyt4BC1j1LLC7iNwBPA9MyPDZHMcF3YkWEWkFHAF8X0QUi5+iIvLrNNkGAi2xmCYAOwKVZBb0jaHXW6lZ/a8AfqCqG6rZny7PuvCpwE2q+vdq+S8GHlHVq6pnFpH9sM/6Myzmyfk1sNepg7jLxYmaU4BRqrqbqnZR1U7AXGyBkX9j7gdEZE/MnfEJ1oK/IDi/C9AVOEpEdqylLVOAw0Vk58Adc2oobQJwceJNELgJYBJBgCmxpfZSLYQwHjg/aNUjIh1EZBfgVeCU4HVizc3dRKQ1UKGqY4FrgANq+dmcOoALuhM1QzE/eJixwfG7gQoR+QB4AjgPa8Efg7khAFDVddgImeNqY0iwks5IYDIm1LNDyZcAfYIOzY+wVjOYz/1oEfkQewAsBtYkKXsCMBqYHHyep4BmwVql12Ar+8wEXgbaYaskTQyiKj4GfKcF7zjV8WiLjlMLRKQRsDUIu3swcE/Quek4Rcd96I5TOzpj8b0rgE3AhRHb49RhvIXuOI5TJrgP3XEcp0xwQXccxykTXNAdx3HKBBd0x3GcMsEF3XEcp0z4/wCv1p4vYFYrAAAAAElFTkSuQmCC\n"
},
"metadata": {
"needs_background": "light"
}
}
]
},
{
"cell_type": "markdown",
"source": [
"## Capon based AoA"
],
"metadata": {
"id": "VIE2vdXxtFWb"
}
},
{
"cell_type": "code",
"source": [
"plt.figure()\n",
"plt.plot(theta, PC, 'r')\n",
"plt.ylabel('Amplitude')\n",
"plt.show()"
],
"metadata": {
"id": "cJMFZq9wtNqN",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 265
},
"outputId": "50108ea4-d5da-4592-d9e5-2b05dec871a3"
},
"execution_count": null,
"outputs": [
{
"output_type": "display_data",
"data": {
"text/plain": [
""
],
"image/png": "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\n"
},
"metadata": {
"needs_background": "light"
}
}
]
},
{
"cell_type": "markdown",
"source": [
"## Back-up"
],
"metadata": {
"id": "MQ2QDmzPtO-j"
}
},
{
"cell_type": "markdown",
"source": [
"### imports"
],
"metadata": {
"id": "Gwkr1SB46Mfr"
}
},
{
"cell_type": "code",
"source": [
"#imports\n",
"from numpy import abs,angle,arange,array, linspace,matrix, pi,sin,cos, exp\n",
"from numpy import column_stack, identity\n",
"#import scipy.fftpack\n",
"from scipy.fftpack import fft, fftshift, fftfreq\n",
"import matplotlib.pyplot as plt\n",
"\n",
"print(\"imports done\")"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "i2XrRr9eFsuA",
"outputId": "6a0108c3-d3db-41ef-eef3-72ec41c79e17"
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"imports done\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"### defines"
],
"metadata": {
"id": "_KCndjBf4kjM"
}
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "A9Cj7f-QmDhl"
},
"outputs": [],
"source": [
"# defines\n",
"\n",
"def fmcw_fft(signal,time,Fs,plot_fft=True,plot_abs_nphase=True,minf=0,maxf=1,Npeaks=1):\n",
" \"\"\"main function for fmcw FFT related math\n",
" Parameters:\n",
" -----------\n",
" signal: numpy ndarray\n",
" the signal whose FFT we are interested int\n",
" time: numpy ndarray\n",
" time stamps at which we sampled the signal\n",
" Fs: float\n",
" sampling frequency\n",
" plot_fft: bool\n",
" if we show FFT or not\n",
" plot_abs_n_phase: bool\n",
" if we look at magnitude or phase\n",
" minf: float\n",
" zoom inside FFT (between 0 and 1.0)\n",
" maxf: float\n",
" zoom inside FFT (between 0 and 1.0)\n",
" Returns:\n",
" --------\n",
" None if plot_fft==True\n",
" freq or phase for which magnitude is max for FFT\n",
" \"\"\"\n",
" N2 = int(len(signal)/2)\n",
" FFT = fft(signal) #/len(signal) #normalise amplitude\n",
" FFT = FFT[range(int(len(signal)/2))]\n",
" tpCount = len(signal)\n",
" values = arange(int(tpCount/2))\n",
" timePeriod = tpCount/Fs\n",
" frequencies = linspace(0.0, Fs/(2), N2) #values/timePeriod\n",
"\n",
" magnitude = abs(FFT)\n",
" phase = angle(FFT)\n",
"\n",
" #peak = max(list(magnitude))\n",
" #fpeak = list(magnitude).index(peak)\n",
" sorted_magnitude = sorted(magnitude,reverse = True)\n",
" sorted_magnitude = sorted_magnitude[:Npeaks]\n",
" fpeaks = [list(magnitude).index(peak) for peak in sorted_magnitude]\n",
"\n",
"\n",
" if plot_fft:\n",
" #either we plot the fft or we return the peak position\n",
"\n",
" if plot_abs_nphase:\n",
" #either we plot amplitude or phase\n",
" #added provision for zooming on certain section of the FFT\n",
" plt.plot(frequencies[int(len(frequencies)*minf):int(len(frequencies)*maxf)],\n",
" magnitude[int(len(frequencies)*minf):int(len(frequencies)*maxf)])\n",
" plt.title('FFT')\n",
" plt.xlabel('Freq (Hz)')\n",
" plt.ylabel('X(t)')\n",
" else:\n",
" plt.plot(frequencies[int(len(frequencies)*minf):int(len(frequencies)*maxf)],\n",
" phase[int(len(frequencies)*minf):int(len(frequencies)*maxf)])\n",
" plt.title('FFT (phase)')\n",
" plt.xlabel('Freq (Hz)')\n",
" plt.ylabel('phase')\n",
" else:\n",
" if plot_abs_nphase:\n",
" return [frequencies[fpeak] for fpeak in fpeaks]\n",
" #return frequencies[fpeak]\n",
" else:\n",
" #return phase[fpeak]\n",
" return [phase[fpeak] for fpeak in fpeaks]"
]
},
{
"cell_type": "code",
"source": [
"start = 0\n",
"\n",
"#R0: distance between radar and target in meters (m)\n",
"Distance=10\n",
"R0 = Distance\n",
"# c: speed of light\n",
"c=3e8\n",
"# Chirp_Slope: chirp ramp 10 MHz/us = 10e12\n",
"Chirp_Slope=10e12\n",
"S = Chirp_Slope\n",
"# target object speed in m/s\n",
"v=1\n",
"#60GHz = 0.005 m\n",
"#should be lambda at end of chirp, keeping 5mm to simplify\n",
"fmin = 60e9 #60GHz\n",
"lambda_max=0.005\n",
"tof = 2*Distance/c\n",
"# frequency of IF signal\n",
"f_if = 2*Chirp_Slope*Distance/c\n",
"N=1024\n",
"step = 1/f_if/4096\n",
"stop = 5/f_if\n",
"\n",
"stop = 5/f_if\n",
"step = stop/N\n",
"\n",
"\n",
"N=2048\n",
"t = None\n",
"y0, y1 = None, None\n",
"Y1, Y1 = None, None\n",
"#R0=33\n",
"f_if0 = f_if\n",
"Ts = 1/f_if0/512\n",
"Fs = 1/Ts\n",
"N=1024\n",
"delta_2_chirps=1.2e-6\n",
"\n",
"def fmcw_if(t,delta_T=1e-6,vt=0,dt=10,show_phase = False):\n",
" \"\"\" generates the IF signal and returns key values for debug\n",
" Parameters:\n",
" t: numpy array\n",
" vt: float\n",
" dt: float\n",
" show_phase: Bool\n",
" Returns:\n",
" y_t: numpy array (if show_phase == False)\n",
" phase: float (if show_phase == True\n",
" \"\"\"\n",
" phase_count = 2*(dt+vt*delta_T)*fmin/c\n",
" phase = 2*pi*phase_count\n",
" freq_if = Chirp_Slope*2*(dt+vt*delta_T)/c\n",
" y_t = sin(2*pi*freq_if*t+phase)\n",
" if show_phase:\n",
" return phase\n",
" else:\n",
" return y_t\n",
"\n",
"for Distance in [10,20]:\n",
" for v in [0.1e3, 0.5e3, 0.2e3]:\n",
"\n",
" # ensure no phase ambiguity\n",
" assert v*4*pi*delta_2_chirps/lambda_max d = f0* c/ 2/s\n",
" R0_est = f0*c/2/S\n",
" print(f\"Estimated Distance: {R0_est:.2g} real distance was {Distance:.2g}\")\n",
"\n",
" #get the phase at target frequency bin for first chirp\n",
" ph0 = fmcw_fft(y0,t,1/Ts,plot_fft=False,plot_abs_nphase=False)\n",
" ph0=ph0[0]\n",
" #get the phase at target frequency bin for second chirp\n",
" ph1 = fmcw_fft(y1,t,1/Ts,plot_fft=False,plot_abs_nphase=False)\n",
" ph1=ph1[0]\n",
"\n",
" v_est = lambda_max*(ph1-ph0)/(4*pi*delta_2_chirps)\n",
" print(f\"Estimated speed: {v_est:.2g} real speed was {v:.2g}\")\n"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "e6N288JXmUji",
"outputId": "2569e445-973a-418a-d6c1-6d776971bfae"
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Estimated Distance: 10 real distance was 10\n",
"Estimated speed: 1e+02 real speed was 1e+02\n",
"Estimated Distance: 10 real distance was 10\n",
"Estimated speed: 5e+02 real speed was 5e+02\n",
"Estimated Distance: 10 real distance was 10\n",
"Estimated speed: 2e+02 real speed was 2e+02\n",
"Estimated Distance: 20 real distance was 20\n",
"Estimated speed: 1e+02 real speed was 1e+02\n",
"Estimated Distance: 20 real distance was 20\n",
"Estimated speed: 5e+02 real speed was 5e+02\n",
"Estimated Distance: 20 real distance was 20\n",
"Estimated speed: 2e+02 real speed was 2e+02\n"
]
}
]
},
{
"cell_type": "code",
"source": [
"\n",
"from numpy import sqrt, arccos, arctan, sign, mean, unwrap\n",
"\n",
"def fmcw_if_target(t,rx_antenna,tx_antenna,target,delta_T=1e-6,): #vt=0,dt=10,show_phase = False):\n",
" \"\"\" generates the IF signal and returns key values for debug\n",
" Parameters:\n",
" t: numpy array\n",
" rx_antenna: t-uple of float\n",
" target: t-uple of float\n",
" delta_T: float\n",
" time offset between current chirp and first chirp of frame\n",
" Returns:\n",
" y_t: numpy array (if show_phase == False)\n",
" phase: float (if show_phase == True\n",
" \"\"\"\n",
" dt = distance(target,tx_antenna,rx_antenna)\n",
" vt = 0\n",
"\n",
" phase_count = 2*(dt+vt*delta_T)*fmin/c\n",
" phase = 2*pi*phase_count\n",
" freq_if = Chirp_Slope*2*(dt+vt*delta_T)/c\n",
" y_t = sin(2*pi*freq_if*t+phase)\n",
" return y_t\n",
"\n",
"def distance(target,tx,rx):\n",
" xt,yt,zt = target\n",
" xrx,yrx,zrx = rx\n",
" xtx,ytx,ztx = tx\n",
" d = sqrt((xt-xrx)**2+(yt-yrx)**2+(zt-zrx)**2+\\\n",
" (xt-xtx)**2+(yt-ytx)**2+(zt-ztx)**2)\n",
" return d\n",
"\n",
"def _unwrap(X0,debug=False):\n",
"\n",
" X1 = [X0[0]]\n",
" for x in X0[1:]:\n",
"\n",
" if abs(X1[-1]-x)>250:\n",
" x1 = x+sign(X1[-1])*sign(x)*360\n",
" elif abs(X1[-1]-x)>90:\n",
" #if we cross 0 only add 180\n",
" if sign(X1[-1])==sign(x):\n",
" x1 = x+sign(X1[-1])*sign(x)*180\n",
" else:\n",
" x1 = x+sign(X1[-1])*180\n",
"\n",
" else:\n",
" x1=x\n",
" if debug:\n",
" print(92,x,x1,abs(X1[-1]-x))\n",
" X1.append(x1)\n",
" return X1"
],
"metadata": {
"id": "pP-M0lpFpAj3"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"tx_antenna = [(0,0,0)]\n",
"NRX = 500\n",
"d=lambda_max/2\n",
"X_rx = [(n-NRX/2)* d for n in range(1,NRX)]\n",
"rx_antennas = [(x,0,0) for x in X_rx]\n",
"Z0=0.9*R0\n",
"X_step = 10\n",
"offset = 3\n",
"NTargets = 3\n",
"targets = [(offset+(n-int(NTargets/2))*X_step,0,Z0) for n in range(NTargets)]\n",
"targets = [(0,0,Z0),(2,0,Z0),(10,0,Z0)]\n",
"\n",
"phases = []\n",
"aoa = []\n",
"#targets=[targets[1]]\n",
"#rx_antennas = [rx_antennas[0]]\n",
"\n",
"#fmcw_if_new = fmcw_if_target\n",
"print(\"AoA 1\",arctan(1)*180/pi)\n",
"for i,target in enumerate(targets):\n",
" x,y,z = target\n",
" print(f\"AoA target_{i}\",arctan(x/z)*180/pi)\n",
"for rx in rx_antennas:\n",
" y=0\n",
" for i,target in enumerate(targets):\n",
"\n",
" # ensure no phase ambiguity\n",
" assert v*4*pi*delta_2_chirps/lambda_max d = f0* c/ 2/s\n",
" R0_est = f0*c/2/S\n",
" #print(f\"Estimated Distance: {R0_est:.3g} real distance was {Distance:.3g}\")\n",
" #get the phase at target frequency bin for first chirp\n",
" ph0 = fmcw_fft(y,t,1/Ts,plot_fft=False,plot_abs_nphase=False)\n",
" ph0=ph0[0]\n",
" aoa.append(ph0*180/pi)\n",
"\n",
"\n",
"\n",
"\n",
"P=0\n",
"if P==0:\n",
" myd = False\n",
"else:\n",
" myd=True\n",
"#_unwrap\n",
"#aoa = _unwrap(aoa[P:-1],debug=myd)\n",
"#print(len(aoa))\n",
"aoa = list(unwrap(aoa))\n",
"#print(\"a8\",len(aoa))\n",
"X = [180*(n-NRX/2)/2/NRX for n in range(1,NRX)]\n",
"#X=X[P:-1]\n",
"#X = [180*(n-NRX/2)/2/NRX for n in range(1,P+1)]\n",
"\n",
"maoa = mean(aoa)\n",
"#print(maoa)\n",
"aoa=[x-maoa for x in aoa]\n",
"if False:\n",
" f, ax1 = plt.subplots(num=1, clear=True)\n",
" ax1.plot(X,aoa,'xb')\n",
"else:\n",
" fmcw_fft(aoa,X_rx,d,plot_fft=True,plot_abs_nphase=True,maxf=0.1)\n",
"\n",
"#f.title('phase array')\n",
"#ax1.xlabel('X')\n",
"#ax1.ylabel('Y')\n",
"#phases.append(aoa)\n",
"#aoa=[]\n",
"\n",
"#peak = min(aoa)\n",
"#fpeak = aoa.index(peak)\n",
"#print(peak,fpeak)\n",
"\n",
"# plt.plot(range(len(phases)),phases,'xb')\n",
"# plt.title('phase array')\n",
"# plt.xlabel('X')\n",
"# plt.ylabel('Y')\n",
"print(116,2*pi/NRX/d)\n",
"print(12/.00002)"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 399
},
"id": "DuaOoKdMnUY2",
"outputId": "738e1cb9-d400-40a1-fa08-0dc0b33e506d"
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"AoA 1 45.0\n",
"AoA target_0 0.0\n",
"AoA target_1 12.528807709151511\n",
"AoA target_2 48.012787504183336\n",
"116 5.026548245743669\n",
"600000.0\n"
]
},
{
"output_type": "display_data",
"data": {
"text/plain": [
""
],
"image/png": "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\n"
},
"metadata": {
"needs_background": "light"
}
}
]
},
{
"cell_type": "code",
"source": [
"N=512\n",
"TM=pi/2*10\n",
"t = linspace(0.0, TM, N)\n",
"y=sin(t)\n",
"#plt.plot(t,y)\n",
"f0 = fmcw_fft(y,t,TM/N,plot_fft=True,plot_abs_nphase=True,maxf=0.3)"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 295
},
"id": "1cD-zsu11mb3",
"outputId": "2f9fdabf-1e98-42c6-d8d8-9851e969d8a2"
},
"execution_count": null,
"outputs": [
{
"output_type": "display_data",
"data": {
"text/plain": [
""
],
"image/png": "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\n"
},
"metadata": {
"needs_background": "light"
}
}
]
},
{
"cell_type": "markdown",
"source": [
"## BARTLET in python\n",
"\n",
"From\n",
"Smart Antennas\n",
"for Wireless\n",
"Communications\n",
"With MATLAB\n",
"\n",
"Frank B. Gross, PhD\n",
"Senior Systems Engineer\n",
"Argon ST\n",
"Fairfax, Virginia"
],
"metadata": {
"id": "8MqU9b3MDdDp"
}
},
{
"cell_type": "markdown",
"source": [
"Example 7.5\n",
"Use MATLAB to plot the pseudo-spectrum using the Bartlett\n",
"estimate for an M = 6 element array. With element spacing d = λ/2, uncorrelated,\n",
"equal amplitude sources, (s1, s2), and σ2\n",
"n = .1, and the two different\n",
"pairs of arrival angles given by ±10◦ and ±5◦, assume ergodicity.\n"
],
"metadata": {
"id": "HnmZcHChDnle"
}
},
{
"cell_type": "markdown",
"source": [
"### Solution\n",
"Solution From the information given we can find the following:\n",
"* /s = [1 1]\n",
"\n",
"* a¯(θ) = [1 e jπ sin θ · · · e j5π sin θ ]T\n",
"* A = [/a(θ1) /a(θ2)]\n",
"* Rss = [[1 0] [0 1]]\n",
"\n",
"Note: Rss = [[1 0] [01]] is the DxD (with D number of sources) source correlation matrix - assumption is that all signals are not correlated.\n",
"\n",
"Applying Eq. (7.21) we can find \u0003Rxx for both sets of angles. Substituting Rxx\n",
"into Eq. (7.22) and usingMATLAB,we can plot the pseudospectrum as shown\n",
"in Figs. 7.2a and b.\n",
"\n",
"Where 7.21 is:\n",
"\n",
"* Rxx = A * Rss * AH + Rnn\n",
"\n",
"or implicitly\n",
"\n",
"* Eq RXX_1\n",
"\n",
"$$ R_{xx} \\approx \\frac{1}{N} \\cdot \\displaystyle\\sum_{k=0}^{n} X(t) \\cdot X^H(t) $$\n",
"[source Eq 14.](https://www.mdpi.com/2411-5134/4/3/43/pdf)\n",
"Where X(t) is\n",
"$$ X(t) =\n",
"\\begin{pmatrix}\n",
" x_1(t_1) & x_1(t_2) & \\cdots & x_1(t_n) \\\\\n",
" x_2(t_1) & x_2(t_2) & \\cdots & x_2(t_n) \\\\\n",
"\\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
" x_M(t_1) & x_M(t_2) & \\cdots & x_M(t_n)\n",
"\\end{pmatrix} $$\n",
"\n",
"and 7.22:\n",
"\n",
"* PB(θ) = /aH(θ) * Rxx * /a(θ)"
],
"metadata": {
"id": "u7KLVZieDth2"
}
},
{
"cell_type": "code",
"source": [
"\n",
"def a(theta, M=6):\n",
" # a_theta is the steering vector - defined by the sensing array\n",
" theta=theta/180*pi\n",
" return array([exp(n*1j*pi*sin(theta)) for n in range(M)])\n",
"\n",
"def Rxx_expl(thetas,M=6,s2_n=0.1):\n",
" \"\"\"\n",
" A: MxD matrix of steering vectors\n",
" M: number of elements in array\n",
" D: number of targets\n",
" assumed: D"
],
"image/png": "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\n"
},
"metadata": {
"needs_background": "light"
}
}
]
},
{
"cell_type": "markdown",
"source": [
"### pyargus: bartlett and capon\n",
"\n",
"pyargus seems to be a python library dedicated to this topic, below shows basic code."
],
"metadata": {
"id": "mA7RN_Wsb6Ml"
}
},
{
"cell_type": "code",
"source": [
"d = 0.5 # Inter element spacing [lambda]\n",
"M = 5 # number of antenna elements in the antenna system (ULA)\n",
"N = 2**12 # sample size used for the simulation\n",
"N = 2**12 #MCV\n",
"theta1 = -9 # incident angle of the test signal [deg]\n",
"theta2 = -theta1 # incident angle of the test signal [deg]\n",
"\n",
"# Array response vectors of the test signal\n",
"a = np.exp(np.arange(0,M,1)*1j*2*np.pi*d*np.cos(np.deg2rad(theta1)))\n",
"\n",
"# Array response vectors of the test signal\n",
"a_1 = np.exp(np.arange(0,M,1)*1j*2*np.pi*d*np.cos(np.deg2rad(theta1)))\n",
"a_2 = np.exp(np.arange(0,M,1)*1j*2*np.pi*d*np.cos(np.deg2rad(theta2)))\n",
"\n",
"# Generate multichannel test signal\n",
"# Notes seems to require some noise , if sigma is too low less reliable outcome?!?\n",
"soi1 = np.random.normal(0,1,N) # Signal of Interest\n",
"soi_outer = np.outer( soi1, a_1)\n",
"soi_matrix= soi_outer.T\n",
"\n",
"# Generate multichannel uncorrelated noise\n",
"noise = np.random.normal(0,np.sqrt(10**-1),(M,N))\n",
"\n",
"# Create received signal array\n",
"rec_signal = soi_matrix + noise\n",
"\n",
"R = corr_matrix_estimate(rec_signal.T, imp=\"mem_eff\")\n",
"\n",
"array_alignment = np.arange(0, M, 1)* d\n",
"incident_angles= np.arange(-30,30,1)\n",
"ula_scanning_vectors = gen_ula_scanning_vectors(array_alignment, incident_angles)\n",
"#print(ula_scanning_vectors)\n",
"\n",
"Bartlett = DOA_Bartlett(R,ula_scanning_vectors)\n",
"\n",
"# Get matplotlib axes object\n",
"\n",
"\n",
"DOA_plot(Bartlett, incident_angles, log_scale_min = -50)\n",
"\n",
"# Mark nominal incident angles\n",
"axes = plt.axes()\n",
"axes.axvline(linestyle = '--',linewidth = 2,color = 'black',x = theta1)\n",
"axes.axvline(linestyle = '--',linewidth = 2,color = 'black',x = theta2)"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 235
},
"id": "yg6MV5Nqb5Rr",
"outputId": "87cb2518-6a8a-4903-bfae-3df60cd04171"
},
"execution_count": null,
"outputs": [
{
"output_type": "error",
"ename": "NameError",
"evalue": "ignored",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0;31m# Array response vectors of the test signal\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mM\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;36m1j\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpi\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdeg2rad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtheta1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0;31m# Array response vectors of the test signal\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
"\u001b[0;31mNameError\u001b[0m: name 'np' is not defined"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"## Back-up and research code"
],
"metadata": {
"id": "KGV3Q-TB4-pn"
}
},
{
"cell_type": "markdown",
"source": [
"## PYARGUS\n",
"\n",
"| N | Bartlett resolution | CAPON resolution |\n",
"|---|---|---|\n",
"|2 | N/A | N/A |\n",
"|3 | 20 | 12 |\n",
"|4 | 13 | 7 |\n",
"|8 | 7 | 3 |\n",
"|12 | 4.2 | 1.7|\n",
"\n",
"\n",
"https://github.com/petotamas/pyArgus/blob/master/docs/nb_direction_of_arrival_estimaton.ipynb"
],
"metadata": {
"id": "u-7hiMt3-o8z"
}
},
{
"cell_type": "code",
"source": [
"!pip install pyargus\n",
"from pyargus.directionEstimation import *\n",
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"np.set_printoptions(precision=1)\n",
"\n",
"%matplotlib inline"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "ckE47UbL-rKe",
"outputId": "3fca19e6-3432-4a7f-8474-92cbcc16dcd7"
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
"Requirement already satisfied: pyargus in /usr/local/lib/python3.7/dist-packages (1.1.post1)\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"### 4 elements"
],
"metadata": {
"id": "s4rXrkGbvO3M"
}
},
{
"cell_type": "code",
"source": [
"d = 0.5 # Inter element spacing [lambda]\n",
"M = 10 # number of antenna elements in the antenna system (ULA)\n",
"M = 4 # temp value\n",
"N = 2**12 # sample size used for the simulation\n",
"N = 2**12 #MCV\n",
"theta1 = 50 # incident angle of the test signal [deg]\n",
"theta2 = 80 # incident angle of the test signal [deg]\n",
"# MCV temp\n",
"theta1, theta2 = 50, 68\n",
"\n",
"# Array response vectors of the test signal\n",
"a = np.exp(np.arange(0,M,1)*1j*2*np.pi*d*np.cos(np.deg2rad(theta1)))\n",
"\n",
"a_90 = np.exp(np.arange(0,M,1)*1j*2*np.pi*d*np.cos(np.deg2rad(90)))\n",
"a_0 = np.exp(np.arange(0,M,1)*1j*2*np.pi*d*np.cos(np.deg2rad(0)))\n",
"a_60 = np.exp(np.arange(0,M,1)*1j*2*np.pi*d*np.cos(np.deg2rad(60)))\n",
"\n",
"# To display only the first fractional digit\n",
"np.set_printoptions(precision=1)\n",
"\n",
"print(\"Signal is received from the front: a=\",a_90)\n",
"print(\"Signal is received from the side: a=\",a_0)\n",
"print(\"Signal is received on 60 deg: a=\",a_60)\n",
"\n",
"# Array response vectors of the test signal\n",
"a_1 = np.exp(np.arange(0,M,1)*1j*2*np.pi*d*np.cos(np.deg2rad(theta1)))\n",
"a_2 = np.exp(np.arange(0,M,1)*1j*2*np.pi*d*np.cos(np.deg2rad(theta2)))\n",
"print(f\"Signal is received on {theta2} deg: a=\",a_2)\n",
"\n",
"# Generate multichannel test signal\n",
"# Notes seems to require some noise , if sigma is too low less reliable outcome?!?\n",
"soi1 = np.random.normal(0,1,N) # Signal of Interest\n",
"correlated = False\n",
"if correlated:\n",
" soi2 = soi1 #CAPON will faill here\n",
"else:\n",
" print(\"not correlated\")\n",
" soi2 = np.random.normal(0,1,N)\n",
"#print(30,soi1)\n",
"soi_outer = np.outer( soi1, a_1)\n",
"soi_outer+= np.outer( soi2, a_2)\n",
"soi_matrix= soi_outer.T\n",
"\n",
"#soi_matrix = ( np.outer( soi, a_1) + np.outer( soi, a_2)).T\n",
"\n",
"# Generate multichannel uncorrelated noise\n",
"noise = np.random.normal(0,np.sqrt(10**-1),(M,N))\n",
"\n",
"# Create received signal array\n",
"rec_signal = soi_matrix + noise\n",
"\n",
"R = corr_matrix_estimate(rec_signal.T, imp=\"mem_eff\")\n",
"\n",
"array_alignment = np.arange(0, M, 1)* d\n",
"incident_angles= np.arange(0,181,1)\n",
"ula_scanning_vectors = gen_ula_scanning_vectors(array_alignment, incident_angles)\n",
"#print(ula_scanning_vectors)\n",
"\n",
"Bartlett = DOA_Bartlett(R,ula_scanning_vectors)\n",
"Capon = DOA_Capon(R, ula_scanning_vectors)\n",
"\n",
"# Get matplotlib axes object\n",
"\n",
"\n",
"# DOA_plot(Bartlett, incident_angles, log_scale_min = -50)\n",
"\n",
"DOA_plot(Capon, incident_angles, log_scale_min = -50)\n",
"# Mark nominal incident angles\n",
"axes = plt.axes()\n",
"axes.axvline(linestyle = '--',linewidth = 2,color = 'black',x = theta1)\n",
"axes.axvline(linestyle = '--',linewidth = 2,color = 'black',x = theta2)"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 473
},
"id": "pO0X3zwI-yoR",
"outputId": "d9c72dad-8b09-488f-ae1d-b684b3d22833"
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Signal is received from the front: a= [1.+0.0e+00j 1.+1.9e-16j 1.+3.8e-16j 1.+5.8e-16j]\n",
"Signal is received from the side: a= [ 1.+0.0e+00j -1.+1.2e-16j 1.-2.4e-16j -1.+3.7e-16j]\n",
"Signal is received on 60 deg: a= [ 1.0e+00+0.0e+00j -3.8e-16+1.0e+00j -1.0e+00-7.7e-16j 7.0e-16-1.0e+00j]\n",
"Signal is received on 68 deg: a= [ 1. +0.j 0.4+0.9j -0.7+0.7j -0.9-0.4j]\n",
"not correlated\n",
"Minimum alias angle 0.00 \n",
"Maximum alias angle 0.00 \n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:69: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n"
]
},
{
"output_type": "execute_result",
"data": {
"text/plain": [
""
]
},
"metadata": {},
"execution_count": 3
},
{
"output_type": "display_data",
"data": {
"text/plain": [
""
],
"image/png": "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\n"
},
"metadata": {
"needs_background": "light"
}
}
]
},
{
"cell_type": "markdown",
"source": [
"### 2 elements\n",
" does not seem to work ???"
],
"metadata": {
"id": "1rvhM76pwJ-b"
}
},
{
"cell_type": "code",
"source": [
"M = 2 # number of antenna elements in the antenna system (ULA)\n",
"delta_theta = 35\n",
"theta1, theta2 = 90+delta_theta, 90-delta_theta\n",
"\n",
"# Array response vectors of the test signal\n",
"a_1 = np.exp(np.arange(0,M,1)*1j*2*np.pi*d*np.cos(np.deg2rad(theta1)))\n",
"a_2 = np.exp(np.arange(0,M,1)*1j*2*np.pi*d*np.cos(np.deg2rad(theta2)))\n",
"\n",
"# Generate multichannel test signal\n",
"# Notes seems to require some noise , if sigma is too low less reliable outcome?!?\n",
"soi2 = np.random.normal(0,1,N)\n",
"soi_outer = np.outer( soi1, a_1)\n",
"soi_outer+= np.outer( soi2, a_2)\n",
"soi_matrix= soi_outer.T\n",
"\n",
"# Generate multichannel uncorrelated noise\n",
"noise = np.random.normal(0,np.sqrt(10**-1),(M,N))\n",
"\n",
"# Create received signal array\n",
"rec_signal = soi_matrix + noise\n",
"\n",
"R = corr_matrix_estimate(rec_signal.T, imp=\"mem_eff\")\n",
"\n",
"array_alignment = np.arange(0, M, 1)* d\n",
"incident_angles= np.arange(0,181,1)\n",
"ula_scanning_vectors = gen_ula_scanning_vectors(array_alignment, incident_angles)\n",
"\n",
"Bartlett = DOA_Bartlett(R,ula_scanning_vectors)\n",
"Capon = DOA_Capon(R, ula_scanning_vectors)\n",
"\n",
"DOA_plot(Bartlett, incident_angles, log_scale_min = -50)\n",
"\n",
"# DOA_plot(Capon, incident_angles, log_scale_min = -50)\n",
"# Mark nominal incident angles\n",
"axes = plt.axes()\n",
"axes.axvline(linestyle = '--',linewidth = 2,color = 'black',x = theta1)\n",
"axes.axvline(linestyle = '--',linewidth = 2,color = 'black',x = theta2)"
],
"metadata": {
"id": "DmIfBv4rx6gH",
"outputId": "6dfc6239-eb23-42f5-b1cf-ad3e457f6bb7",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 386
}
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Minimum alias angle 0.00 \n",
"Maximum alias angle 0.00 \n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:35: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n"
]
},
{
"output_type": "execute_result",
"data": {
"text/plain": [
""
]
},
"metadata": {},
"execution_count": 37
},
{
"output_type": "display_data",
"data": {
"text/plain": [
""
],
"image/png": "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\n"
},
"metadata": {
"needs_background": "light"
}
}
]
},
{
"cell_type": "markdown",
"source": [
"### 3 elements\n",
"\n",
"* BARTLET down to +/- 20 degree\n",
"* CAPON down to +/- 12 degree"
],
"metadata": {
"id": "Wc7HZDX-xOqn"
}
},
{
"cell_type": "code",
"source": [
"M = 3 # number of antenna elements in the antenna system (ULA)\n",
"delta_theta = 20\n",
"theta1, theta2 = 90+delta_theta, 90-delta_theta\n",
"\n",
"# Array response vectors of the test signal\n",
"a_1 = np.exp(np.arange(0,M,1)*1j*2*np.pi*d*np.cos(np.deg2rad(theta1)))\n",
"a_2 = np.exp(np.arange(0,M,1)*1j*2*np.pi*d*np.cos(np.deg2rad(theta2)))\n",
"\n",
"# Generate multichannel test signal\n",
"# Notes seems to require some noise , if sigma is too low less reliable outcome?!?\n",
"soi2 = np.random.normal(0,1,N)\n",
"soi_outer = np.outer( soi1, a_1)\n",
"soi_outer+= np.outer( soi2, a_2)\n",
"soi_matrix= soi_outer.T\n",
"\n",
"# Generate multichannel uncorrelated noise\n",
"noise = np.random.normal(0,np.sqrt(10**-1),(M,N))\n",
"\n",
"# Create received signal array\n",
"rec_signal = soi_matrix + noise\n",
"\n",
"R = corr_matrix_estimate(rec_signal.T, imp=\"mem_eff\")\n",
"\n",
"array_alignment = np.arange(0, M, 1)* d\n",
"incident_angles= np.arange(0,181,1)\n",
"ula_scanning_vectors = gen_ula_scanning_vectors(array_alignment, incident_angles)\n",
"\n",
"Bartlett = DOA_Bartlett(R,ula_scanning_vectors)\n",
"Capon = DOA_Capon(R, ula_scanning_vectors)\n",
"\n",
"DOA_plot(Bartlett, incident_angles, log_scale_min = -50)\n",
"\n",
"# DOA_plot(Capon, incident_angles, log_scale_min = -50)\n",
"# Mark nominal incident angles\n",
"axes = plt.axes()\n",
"axes.axvline(linestyle = '--',linewidth = 2,color = 'black',x = theta1)\n",
"axes.axvline(linestyle = '--',linewidth = 2,color = 'black',x = theta2)"
],
"metadata": {
"id": "s7Nu9P6Cv0rD",
"outputId": "9f50ad2e-7f71-408a-af24-28e0f82fbb59",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 386
}
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Minimum alias angle 0.00 \n",
"Maximum alias angle 0.00 \n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:35: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n"
]
},
{
"output_type": "execute_result",
"data": {
"text/plain": [
""
]
},
"metadata": {},
"execution_count": 31
},
{
"output_type": "display_data",
"data": {
"text/plain": [
""
],
"image/png": "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\n"
},
"metadata": {
"needs_background": "light"
}
}
]
},
{
"cell_type": "markdown",
"source": [
"### 4 elements\n",
"\n",
"Bartlett +/- 13 degrees\n",
"\n",
"Capon +/- 7 degrees"
],
"metadata": {
"id": "vQ_0FTEzyWYh"
}
},
{
"cell_type": "code",
"source": [
"M = 4 # number of antenna elements in the antenna system (ULA)\n",
"delta_theta = 7\n",
"theta1, theta2 = 90+delta_theta, 90-delta_theta\n",
"\n",
"# Array response vectors of the test signal\n",
"a_1 = np.exp(np.arange(0,M,1)*1j*2*np.pi*d*np.cos(np.deg2rad(theta1)))\n",
"a_2 = np.exp(np.arange(0,M,1)*1j*2*np.pi*d*np.cos(np.deg2rad(theta2)))\n",
"\n",
"# Generate multichannel test signal\n",
"# Notes seems to require some noise , if sigma is too low less reliable outcome?!?\n",
"soi2 = np.random.normal(0,1,N)\n",
"soi_outer = np.outer( soi1, a_1)\n",
"soi_outer+= np.outer( soi2, a_2)\n",
"soi_matrix= soi_outer.T\n",
"\n",
"# Generate multichannel uncorrelated noise\n",
"noise = np.random.normal(0,np.sqrt(10**-1),(M,N))\n",
"\n",
"# Create received signal array\n",
"rec_signal = soi_matrix + noise\n",
"\n",
"R = corr_matrix_estimate(rec_signal.T, imp=\"mem_eff\")\n",
"\n",
"array_alignment = np.arange(0, M, 1)* d\n",
"incident_angles= np.arange(0,181,1)\n",
"ula_scanning_vectors = gen_ula_scanning_vectors(array_alignment, incident_angles)\n",
"\n",
"Bartlett = DOA_Bartlett(R,ula_scanning_vectors)\n",
"Capon = DOA_Capon(R, ula_scanning_vectors)\n",
"\n",
"# DOA_plot(Bartlett, incident_angles, log_scale_min = -50)\n",
"\n",
"DOA_plot(Capon, incident_angles, log_scale_min = -50)\n",
"# Mark nominal incident angles\n",
"axes = plt.axes()\n",
"axes.axvline(linestyle = '--',linewidth = 2,color = 'black',x = theta1)\n",
"axes.axvline(linestyle = '--',linewidth = 2,color = 'black',x = theta2)"
],
"metadata": {
"id": "rF7OM0f6yYSH",
"outputId": "f5df7085-1378-4c18-9bdb-c00028ccfac4",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 386
}
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Minimum alias angle 0.00 \n",
"Maximum alias angle 0.00 \n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:35: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n"
]
},
{
"output_type": "execute_result",
"data": {
"text/plain": [
""
]
},
"metadata": {},
"execution_count": 45
},
{
"output_type": "display_data",
"data": {
"text/plain": [
""
],
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAEYCAYAAAByXKB5AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dd3xb9bn48c/j7XglzrCznUUGYSQ2YbWQlFGg0LRQRieUQuivk94O4Nf2ltt1b/e9XZSE9ldooeFCywq0KaEJlDKSOIvsPZydOPFK7NjW8/vjHCWKIsmyLOlI8vN+vfSydMb3PDqS9ZzzPd/z/YqqYowxxnRXltcBGGOMSU+WQIwxxsTEEogxxpiYWAIxxhgTE0sgxhhjYmIJxBhjTEwsgaQ4EblDRDTg0SIi20XkGRG5RUQkaPkqd7k7PIjzzjDTVUSqkhlPtESkUkSeF5F6N857o1jno+6yy+Mci4rIg/EsM6DspH4vRGS6iDwoIllB0736fla58YwOMW+7iPw+mfFkihyvAzBRuxmoA/KBEcD7gD8Bs0TkBlU97i63F7gY2JLk+O7A+T79Lmj6i248e5McT7T+HbgcJ/69wPYo1rnd/Xu+iJyjqu/EKZaLcT7jTDAd+BbwXcAXMN2r72eVG8/rwNageR8EGpMcT0awBJI+Vqjq5oDXfxCRp4CngB8CnwdQ1Tbgra4KE5F8d9mEUtWDwMFEb6cHJgIrVfWZaBYWkaHAFcBfgWtxkslXolgv7P72z1PVLj+3dBft9zOZVDWuZ5K9iqraI4UfOEfGCowNM/8ZoBXo476ucpe/I2CZ3+Mc2V4MvAEcB/7HnTcQ+A2wG2gD1gOzQmxnFPAHYJ+73NaAMha52wx8LAqKvyqgrFycI9PtwAn373eB3IBl/O/jHuDbOEeuR4EXgGFR7DcBvgRscLexF/glUBpUfvCjqoty73eXuwDnaHYvkB20zHR3mRuBOTgJ9GjAvnoduAFY7u7LL7nzFHjQfX6z+/rcEDG8hJP0/K8/B7wJ1Lv76C3gfUHrnPG9iPAezwOeB46435V/Ae8OWuYC4GXgsLvMVuDX7rwHQ+3bKL6fNZz6fm7wvwfg39zvSCPwHDAwKJaI7z/g8wh+THfnbwd+H1TmNGAB0Ay0AK8A04KW8cc9BfgncAzYBHza69+NZD3sGkj6ewmnWqumi+XKgLk41V7XAk+ISCnOj9l1OP/078P5gX5IRD7vX1FERgGLgctwqnyuAf4DGOAu8hmcH8NVOEnqYndaOI/i/BA/BlyP8494nzs92APAWOBO4Itu2X/s4r0CfA/4Kc6P3A04Z2l3AC+69fL+qpRVbuz+uLuqarsdWKeqS9z4K4Grwyz7C5xE9nF3235nAT93578X58cp2AtAA/CxwIkiUuFu77GAyVXAIzhJ51ZgKTBPRK7p4r2cQUSm4vyIlwN3AzfhJIkFIlLtLlMMzAc63fd1LU6S99doPAL81n3+Lk7t20hK3ff0CE6V0gHgzyLyE2AG8FngXvf5r4LWrSLy+1/mrg/whYB4loXZB+cCrwL93Pf3CTe+V0XkvBBxP4HznZwJLMH5/5nRxfvNDF5nMHtEftD1Gch73fm3uq+rCH2Ep8DMoHW/iXP2Mi5o+hzgEJDjvn4M50hsSIQ4FwGvR4i/yn09mYAj7YDlvkHAEXfA+1gUtNxX3OmRYinHObL/fdD0j7nrvj9g2uvB24hQ7jR3/Qfc131xjpbnBi033V3umTD7yQecH2LeafvF/RzqgKyAafcCHcDgMDFm4fyQ/x14LmD6Gd+LMOu/AqwD8gKmZbvTnnVf1xDm7ChgnQfdZXKCpkf6fl4WMO1cd9oGAs7wcA4K2gk664vi/fs/kytDrLM98LsCPI1zJtM3YFopzhnOX0LEPSNgWj5Owp0dzXcq3R92BpL+/K2wuuoVsx2YFzTtGuBtYJuI5PgfOEeX/YFJ7nJXA/NUdU8c4r3M/Rt8FuF/fXnQ9JeCXvsvWI+IsI2LgLwQ25iL8+MbvI1o3Y7z4/9HAFU9ilOlMlNEykIsH+66ynZVXRHF9h4DhgLvCZj2ceAVVT15piQi1SIyT0T247y/duAqYHwU2zhJRApx9s1TgC/g+yA41Tn+z24Tzg/swyLyMREZ3p3thNGiqq8FvF7v/l2gqp1B03OAwQFxx+X9B7gM5/t+1D9BVRtxqvWCvzvHVHVhwHJtwEYifz8zhiWQ9Of/5+2q6uVg0D8iwCCcf5b2oMdT7vz+AX/j1Tqo3P0bHO++oPl+9UGv/ReiC7q7DVXtwDk6DN5Gl0QkD7gNp669SUT6ikhfnCRRANwSYrVwn0m0LdJexzk6/rgbw0RgKgHVV+6P9ys47+nzwCU41yf+RuR9FEo5ztnGNznzO/E5oJ+IZKlqA05V0h7g18BOEVktIjd1c3uBjga+UNUT7tMjQcv5pxdA3N+/XzmhP6N9ONVagYLjA+c7Guu204q1wkp/78OphqrtYrlQZyiHceqavxhmnQ3u30M4R8Lx4E8IlZzelLMyaH68trHGP9E9mu4f4zZuwPlhuZTQPxq341Q5BQp3VtjV2aKzkKqKyB+Be0Xk/+AkkmZOP7O5Buf61i2qejLJi0ifaLYR5CjOGdavOP0aS2BMPvfvCuAmd5/W4Fyr+l8ROU9VV8ew7VjF8/371XPq+xioktCffa9lCSSNuUd878dpDXUshiL+hnPUtlNVD0RY7u/AjSIyOLDqJEgbUBLFNv3VFLfhXOj2+6j7d1EUZXTlLZwj1ds4/QL1rTjf+Vi2cTtOa5yZOBePg+fdISJjVDXe9zf8Aef60I04++gvQZ+1/4ey3T9BRM7CSXTdOmtU1RYR+SdOK6xl/mTRxTodwFsi8k2c7+JEYDWnzhQLgabuxNFN0b7/wHi68ipwnYiUqGqTW2YJzkHEop4GnEksgaSP80VkAE7d/gic1ks347QyeiDGMn+G86P6TxH5Gc4ZRxEwAafZ5kx3uW/htNR6Q0S+D2zGOSO5RlX9rYTWAp8RkVtxziyaVHUDQVR1tYj8CXjQPXp9A6dFzDeBP2kcbspT1Xq39c4DItKCcx1lIk5T4ddxbm6MmogMwmlp9EdVPaPFlIjs41RrnW/1LPrTqepGEXkb+C+cfR58ZrAAp97/Mfc9D8ZpIbeT2Kqo/w0nyc8Xkd/iVOUMwKk6y1bV+0XkemAW8CywDec78wWcRPGmW85a9++XReSvQKeqLo0hnq5E+/43usvdKSL1OAllgz9BBPkOzv/XKyLyA5wzxvtwktW3E/Ae0pfXV/HtEfnBqVZM/sdxYAdONcbNgAQtX0WYdvZhyu+Hk0i24Ry1H8Bp035v0HJjcJoAH8KpMtsC/DRgfiXOD3UTXd8HkofzY74D58hxB+HvA7krKI7pBLThj7DfQt0H8ivc+0ACluuyFRZOyycl6F6IoGX+5e5DIXKLn0WEaK3mzjujdZo7/bPuvNNaZAXMvwXn4nIrTpXdbe5nvj3S9yLCe5mI0+DgAM4PbR3OBeTr3PnjgSfd99uKc5/LS8CFAWVku/v7AE61mHb3++ku990w/w9ju/P+3eXuwblfpSPwO0To+0AuJMr7QMJ8xhG/U5nyEPcNG2OMMd1irbCMMcbExBKIMcaYmFgCMcYYExNLIMYYY2LSq5rxDhgwQKuqqmJat/FoE6V9o7nNwVstLS0UFRV5HUZU0iXWWOKsrXXu66yuro57POHKTpf9CekTaybF2drQRkFZfkzl19bWHlLVgWfM8LoZWDIf1dXVGqtnH38x5nWTaeHChV6HELV0iTWWODnVhXnchSs7XfanavrEmklxPv+Nt2MuH1iqIX5TrQrLGGNMTCyBGGOMiYklEGOMMTGxBGKMMSYmvaoVljHJognsIiiRZRvTHSl7BiIi14jIBhHZLCL3h5ifLyJPuvPfFpGq5EdpjDG9V0omEBHx9+R5Lc6wqh8WkUlBi30KOKKqY3F6k/1BcqM0xpjeLVWrsKYBm1V1K4CIzMUZyGdtwDIzgQfd508DvxQRUTu/NynAf5Of/6a/7mhp62Dxtnre2d1AR6eP4eV9mHn+UPJysnpctjHxlJLduYvIh3AGK7rLff1xnLEGPhewzGp3mTr39RZ3mUNBZc3CGfyGioqK6rlz58YUU0N9I2XlpTGtm0zNzc0UFxd7HUZU0iXWWOKcMWMGAAsXLjxteuMJZW+zj04Fn4JPFZ/C8Q7Y1eRj45FOtjU48wP1LxA+dU4+k/pnhy07XfYnpE+smRRnw55jlA2JbaTfGTNm1KpqTfD0VD0DiRtVnQ3MBqipqdHp06fHVM5zT7xErOsm06JFi9IiTkifWHsSp3+9xdvq+ffnVrN+X/jRXXOzhUlDyrjn/P5cMmYANVX9yM/J4tWNB/n2vLU8vPoE8z5/8RllxyPOZEuXWDMpzhe+uZjpH5kW1+2magLZDQwPeD3MnRZqmTp3aNQy4HBywjMmerNf28J//XU9w8v78LVrxnP2kDLyc7LIzhKyRMjOEgpzsxk1oOhkNVWg6eMHMWpAEdf/4nU+98QyD96BMaGlagJZAowTkVE4ieI24CNByzwP3I4zBvOHgH/Y9Q+Tat7YfIjvv7SeaydX8qObz6M4P7Z/uZH9i/jhTefyfx63BGJSR0q2wlLVDuBzwHxgHfC/qrpGRL4tIu93F/st0F9ENgP/BpzR1NcYr3316VWMGlDET285P+bk4XfN5EomVKZ+j9Cm90jVMxBU9SXgpaBp/x7wvBW4OdlxGdMdexuO89SnL6YwL7vHZYkIt19Sxfw4xGVMPKRsAjEmnd35qbt4bsVu3nt2JdUjy+NW7gfOH0r51GupLCuIW5nGxColq7CMSXfXf/ZbFF/5WT520ci4lluYl80XH/wxJy6+i+a2jriWbUx3WQIxJgH++NZORg8o4pIx/eNe9lWTKmjvVP61+VDXCxuTQJZAjImzTfubeOPtJVzatwERiXv5WYe3kn14G4s2HIx72cZ0h10DMSbOXl63n32P3st3H4Xv3BX/luUXXejcDLZo9AJUNSFJypho2BmIMXGWrDODvQ2tbNzfnJRtGROKJRBj4qixtZ3aHUeStr2FGw4kbVvGBLMEYkwcvb7pEJ2+5HSIcFZFMW9usd57jHcsgRgTR4s2HKCkIDmXFqeO6MeKXUfxJSlhGRPMEogxcaKqvLbxEO8eNyAp25syoi8Nx9vZdrglKdszJpglEGPiZPfR4+xrbOXCUfG/9yOUqSP6AbAsiddcjAlkzXiNiZNlO48Czg/70qVLE7Ydf9ljBhZTkp/D8l1HublmeBdrGRN/lkCMiZNlO45QkJvFhMEl5A6rTth2/EPaApw/oi/L3cRlTLJZFZYxcbJ85xHOHdaX3Ozk/VtNGdGPDfsarV8s4wlLIMbEQWt7J2v2NJ68LjFr1ixmzZqVkG0Flj1lRF98Cqvq7CzEJJ8lEGPi4J3dDXT4lKkj+gIwZ84c5syZk5BtBZZ97tAyANbuaUzItoyJxBKIMXHgbwk1dWS/pG63f3E+g0ryLYEYT1gCMSYOVtU1MLy8kAHF+Unf9qQhpazdawnEJJ8lEGPiYM2eBiYPKfNk2xMHl7L5QDPtdke6STJLIMb0UHNbB9sPH2PS4FJPtj9pcCkdPmVPs8+T7ZveyxKIMT20zq0+OnuoNwlkopu4djVZAjHJlXI3EorIj4AbgBPAFuCTqnpGG0UR2Q40AZ1Ah6rWJDNOY/z8F7AnDT5VhTV16tSEbS+47FEDiijIzWJnoyUQk1wpl0CAl4EHVLVDRH4APADcF2bZGapqA0MbT63Z00B5UR4VpacuoNfW1iZse8FlZ2cJ4ytL2dVkF9JNcqVcFZaq/l1V/bfVvgUM8zIeY7qydm8jZw8p9XRo2UmDS9nZ5EPVLqSb5JFU/sKJyAvAk6r6xxDztgFHAAUeVtXZYcqYBcwCqKioqJ47d25MsTTUN1JW7k0dd3c0NzdTXFzsdRhRSZdYI8XZ4VM+/fIxrqrK5dbxeUmO7JQFO9r547oT/Pf0QvoWpNxx4Rky4bNPJdHE2bDnGGVD+sRU/owZM2pDXiZQ1aQ/gAXA6hCPmQHLfB14BjfJhShjqPt3ELASuKyr7VZXV2usnn38xZjXTaaFCxd6HULU0iXWSHGu3dOgI++bp88urzttOs6BTULiCVX2vzYd1JH3zdPXNx1MyDbjLRM++1QSTZzPf+PtmMsHlmqI31RProGo6pWR5ovIHcD1wBVu8KHK2O3+PSAizwDTgNfiHKoxEflbYHnVhNdvbIVz9LlpfxOXjk3OgFbGpNy5rohcA3wNeL+qHguzTJGIlPifA1fjnMEYk1Qb9jeRl51F1YAiT+MYWJxPUS5sOtDsaRymd0m5BAL8EigBXhaRFSLyGwARGSIiL7nLVACvi8hKYDHwoqr+zZtwTW+2cV8TowcWJbUL91BEhCFFWZZATFKlXDNeVR0bZvoe4Dr3+VbgvGTGZUwoG/c3U1OV3A4UwxlSnMU7lkBMEqXiGYgxaaGptZ3dR49zVkWJ16EATgKpbznB4eY2r0MxvYQlEGNitHG/c7Q/PkUSyNBi5z4Uq8YyyZJyVVjGpItN+5sAGF95ZgJ5+OGHE7bdcGUPKXaOBzcdaOai0f0Ttn1j/CyBGBOjDfub6JOXzdC+hWfMS9RwtpHK7pcvFOfnsNlNbMYkmlVhGROjjfubGFdRQlaWd12YBBIRxg4qtioskzSWQIyJ0YZ9zYyvCN19xOzZs5k9O2TvOj0WqexxlkBMElkCMSYG9S0nONTcFrYF1j333MM999yTkG1HKntcRTEHm9o4euxEQrZtTCBLIMbEYLN7lD92UGp1tDdukJPQNttZiEkCSyDGxGDTAedC9bgUacLr509o/ibGxiSSJRBjYrBpfzNFedkMKSvwOpTTDO1bSGFu9skEZ0wiWQIxJgZbDjYzZlCxp4NIhZKV5bTEsioskwyWQIyJwab9zSl3/cNv3KBiNlkVlkkCSyDGdFNjazv7GltPXrBONWMritnX2Epja7vXoZgMZwnEmG7yVw+Ni3AGoqdGzoy7rsq2llgmWSyBGNNNqdqE18+f2DZbNZZJMEsgxnTT5gPN5OVkMby8j9ehhDS8vA95OVlsPmgJxCSWJRBjumnT/ibGDCwmO0IfWNXV1VRXVydk+12VnZ0ljB5QdLK3YGMSxXrjNaabNh1oZsqIyKMQLlu2LGHbj6bscRUlrNh1JGExGAN2BmJMtxw70cHuo8cjXkBPBWMHFlN35DjHT3R6HYrJYJZAjOmGrQdbUI3cAisVjKsoRtW54dGYREm5BCIiD4rIbhFZ4T6uC7PcNSKyQUQ2i8j9yY7T9E6n+sBK7QTibyFmTXlNIqXqNZCfqeqPw80UkWzgV8BVQB2wRESeV9W1yQrQ9E6b9jeTkyWM7F/kdSgRVfUvIjtLLIGYhEq5M5AoTQM2q+pWVT0BzAVmehyT6QU2H2imakARudmp/a+Tl5PFyP59rFNFk1CpegbyORH5BLAU+LKqBjcnGQrsCnhdB1wYqiARmQXMAqioqGDRokWxRVTQEfu6SdTc3JwWcUL6xBoY56rtxxhWktVl3O973/sAEvL+wpUdvD/7ZbWyavuxlNzH6fjZp7Jo4vRNTMB3wd8tQjIfwAJgdYjHTKACyMY5O/oe8LsQ638IeCTg9ceBX3a13erqao3Vs4+/GPO6ybRw4UKvQ4hausTqj7O1vUNH3T9Pfzx/vbcBhRG8P3/4t3U6+oEXta2905uAIki3zz7VRRPn8994O+bygaUa4jfVkzMQVb0ymuVEZA4wL8Ss3cDwgNfD3GnGJMy2Qy34NHW7MAk2blAJnT5lx+GWlBv4ymSGlKvIFZHBAS8/iHNmEmwJME5ERolIHnAb8Hwy4jO9V3f6wKqtraW2tjYhcURbtj/OTXYh3SRIKl4D+aGInA8osB24B0BEhuBUW12nqh0i8jlgPk511+9UdY1XAZveYeP+ZrIExgzsOoHU1NQAJKRH3mjLHjOwGBFrymsSJ2wCEZFojujrVfWO+IUDqvrxMNP3ANcFvH4JeCme2zYmkk37mxjZv4iC3GyvQ4lKYV42Q/sW2hmISZhIZyATgbsizBecezGM6RU27m9Km+sffja8rUmkSAnk66r6aqSVReQ/4hyPMSmpraOT7YePcc3kSq9D6ZZxg4p5Y8thOn0asfdgY2IR9iK6qv5vVytHs4wxmWD7oWN0+pSz0qw109hBxZzo8FF35JjXoZgMFDaBiMgAEfmWiHxBRIpF5CERWS0iz4nI2GQGaYzXNrpja6TqOOjhjHXj3WSjE5oEiNSM9wkgHxgHLAa24tzANw94JPGhGZM6Nu1vIktg9MDU7gMr2MlOFa1XXpMAka6BVKjq/xURAXao6o/c6etF5LNJiM2YlLFxf3O3WmAtXbo0YbF0p+yywlwGleTbGYhJiEgJpBNAVVVEDgXN8yUuJGNSz6YDTd0aAyRRw9nGUvbYQcV2BmISIlICGe3eCyIBz3Ffj0p4ZMakiHafsv3wca6dPLjrhVPQuEHF/HnZblQVp0LBmPiIlEACu0cPHpsj7FgdxmSafS1Kp0+7NYjUrFmzAJg9e3bc4+lu2WMHFdPc1sG+xlYGlxXGPR7Te4VNIF3dA2JMb7G72amx7U4LrDlz5gCJSSDdLTuwJZYlEBNPkboyeQenP6qQVPXchERkTIrZ3exLyxZYfoHD21521kCPozGZJFIV1vXuX3+Lqz+4fz9GhMRiTKbZ0+yjKo36wAo2oDiPvn1yrU8sE3eRqrB2AIjIVao6JWDWfSKyDLg/0cEZkwp2N/s4ryq9+sAKJCKMHVjMFksgJs6iGQ9EROTSgBeXRLmeMWmvraOTA8c07e5ADzauotjGRzdxF814IJ8CficiZe7ro8CdiQvJmNSx9aAzCmF3WmClojEDizlyrJ3DzW30L873OhyTIbpMIKpaC5znTyCq2pDwqIxJEf4+sLrbieLUqVMTEU7MZfuHtN10oNkSiImbSK2wrlfVk+ORh0ocwcsYk2k2H2h27qTtZgusRA1nG2vZgcPbXjS6f7xDMr1UpDOQH4nIbpw7z8P5Pk7nisZkpI37m6joI+TnpGcLLL8hZQWU5OewcZ9dBzHxEymB7Ad+2sX6m+IYizEpZ8O+JoaWpH+bERFhfGUJGyyBmDiK1Ix3ehLjMCbltLR1sKP+GFPG5HZ7XX+fU6rxv2Uq1rInDC7huRV7rE8sEzfpf2hlTIJs2N+EKgzPgDMQgAmVpTS1drCnodXrUEyGiKYZb1KJyJPAePdlX+Coqp4fYrntQBNOt/MdqlqTtCBNr7BubyOQOQlk4mCnJdb6vY0M7Wt9YpmeS7kEoqq3+p+LyE+ASM2GZ6hq8FglxsTF+r1NFOfnMKAwM6p7/E2R1+9r4oqJFR5HYzJBl4dWItJHRL4pInPc1+NE5Pqu1uspdyTEW4A/JXpbxoSybm8jEypLMuZ6QUlBLsP6FZ48szKmp6SrC3FulVIt8AlVnSwifYA3QlUrxTUwkcuAn4armhKRbcARnI4dH1bVkH1bi8gsYBZARUVF9dy5c2OKp6G+kbLy0pjWTabm5maKi9PjrulUjtWnymcWHOOSoTncOKK923HOmDEDgIULF8Y9tnBlR7M//2dZK/tbfHz/3X3iHld3pPJnHyiT4mzYc4yyIbF97jNmzKgN+VusqhEfwFL37/KAaSu7Wq+LMhcAq0M8ZgYs8xDw5QhlDHX/DgJWApd1td3q6mqN1bOPvxjzusm0cOFCr0OIWirHuvNwi468b54+/taOmOLEObCJf2ARyo4mzh/PX6+j7p+nx090JCCy6KXyZx8ok+J8/htvx1y+Pw8EP6K5BnJCRArdLy0iMgZo634OOy1pXRlpvojkADcCYQd/VtXd7t8DIvIMMA14rSdxGeO31q3mmTC4hMat3V//4YcfjnNE8Sl7QmUpPnXusJ88tKzrFYyJIJoE8i3gb8BwEXkcuBS4I5FBAVcC61W1LtRMESkCslS1yX1+NfDtBMdkepH1e5sQgQmVJSyOIYH4h51NhJ6UPWHwqQvplkBMT0XTmeLL7vgfF+F0a/JFTXzLp9sIunguIkOAR1T1OqACeMa9uJkDPKGqf0twTKYXWbe3kar+RfTJS7mGij1S1b+I/Jws1tuFdBMHkTpTDO7yc6/7d4SIjFDVZYkKSlXvCDFtD3Cd+3wrcF6itm/Mun2NTBoce6MJ/3jliTgT6UnZ2VlOlybrrUsTEweRDq9+4v4tAGpwLlQLcC6wFLg4saEZ442Wtg52HD7GTVOHxVzGPffcAyQmgfS07AmVJfxj/YF4hmR6qbD3gajqDFWdgXPmMVVVa1S1GpgC7E5WgMYkm//ofGIPzkBS2YTKUg41n+BgU4/awhgTVV9Y41X1Hf8LVV0NTExcSMZ4a/0+twVWZXoPYxvOqQvpdh3E9Ew0CWSViDwiItPdxxxgVaIDM8Yr6/Y2UlKQw7B+mdlf1IRK58xq/V67DmJ6JpomJp8E/g/wRff1azg3+RmTkdbtbWJiZWnGdGESrLwoj4rSfNbZGYjpoWia8bYCP3MfxmQ0n0/ZsK+JG6cO9TqUhJpQWco6OwMxPdRlAnH7nDqjwyxVHZ2QiIzxUN2R4zS3dWTsBXS/s4eU8q/XttLa3klBbnoP12u8E00VVmAHWgXAzUB5YsIxxlurdh8F4Jwe3qWtCRiJMJ5lnzusjA73bOu84X3jEJXpjbq8iK6qhwMeu1X1v4H3JSE2Y5LunboG8rKzTo6dkan83Zis2h1puB1jIoumCivwjvQsnDOSzOrfwRjXyrqjTBxcQl5OZoxCGM7QvoWUF+XxTt1RYKTX4Zg0FU0i+EnA8w5gG85AT8ZkFJ9PWb27kQ9O6fkF9OpqpyPp2traHpeViLJFhHOGlrGqzs5ATOyiSSCfcvueOklERiUoHmM8s+1wC81tHZwzrOe91C5blrCu4uJW9jlDy3h98yG7kG5iFs15+tNRTjMmra2qcy6gnxuHBJIOzhlWRqdPT459Ykx3ReqNdwJwNlAmIjcGzCrFaY1lTEZZVddAYW42Ywem/hCm8eBPlHDUtWQAACAASURBVO/UNTB1RD+PozHpKFIV1njgeqAvcEPA9Cbg7kQGZYwXVtU1cPaQUnKyM/sCul9laQEDivPtOoiJWdgEoqrPAc+JyMWq+mYSYzIm6To6fazZ08CHp43wOpSkcS6kl7LamvKaGEWqwvqaqv4Q+IiIfDh4vqp+IaGRGZNEmw8209ru47xhveumunOG9eXVjZs4dqIj40ZfNIkX6Ruzzv27NBmBGOOlVbuco/B4tMACuPvuxNXyxrPsc4eW4VNYu6eRmirrYMJ0T6QqrBfcv48mLxxjvLFq91FK8nMY1b8oLuX5h51NhHiW7U+Yq+oaLIGYbotUhfUCITpR9FPV9yckImM8sKqugclDy8jKyswu3MOpKC1gUEm+XQcxMYlUhfXjRG5YRG4GHsQZ3XCaqi4NmPcA8CmgE/iCqs4Psf4oYC7QH6gFPq6qJxIZs8lMbR2drNvbyJ2Xxu/+WP9d4v67xuMp3mWfO6zM+sQyMYlUhfWq/7mI5AETcM5INsTph3o1cCPwcOBEEZkE3IZzD8oQYIGInKWqnUHr/wD4marOFZHf4CQcG+jKdNvGfc20dyrnxvECek2N04l1InrljXfZ5wztyyvrD9Dc1kFxvl1IN9HrssG7iLwP2AL8HPglsFlEru3phlV1napuCDFrJjBXVdtUdRuwGZgWFJMA7+HUHfGPAh/oaUymd1rZy+5AD3busDJUnRsKjemOaO6Y+gkwQ1Wnq+rlwAwSOzrhUGBXwOs6d1qg/sBRVe2IsIwxUVmx6yj9+uRm7BjoXfGPB7J81xGPIzHpJprz1SZV3RzweivO3ehdEpEFQGWIWV93b1RMOBGZBcwCqKioYNGiRbEVVNAR+7pJ1NzcnBZxQurE+vq6Y4wsyuLVV18NOb8ncSby/QWX3ZM4K/sILy/bzCTqeh5YFFLls+9KJsXpm3gs/u9FVSM+cK4rvATcAdwOzAN+jXP94sau1o+i/EVATcDrB4AHAl7PBy4OWkeAQ0CO+/piYH5X26qurtZYPfv4izGvm0wLFy70OoSopUKsh5vbdOR98/RXCzeFXSaWOHGuF/Ygsu6X3ZP9+W9PrtAp3/67+ny+HkQWvVT47KORSXE+/423Yy4fWKohflOjqcIqAPYDlwPTgYNAIU7/WNfHnLnCex64TUTy3ZZW44DFgQu4b2gh8CF30u1AUs5oTGZZvtOptqnu5Z0JTh3Zl/qWE+w4fMzrUEwa6bIKS1U/mYgNi8gHgV8AA4EXRWSFqr5XVdeIyP8Ca3EGsPqsui2wROQl4C5V3QPcB8wVke8Cy4HfJiJOk9lqdxwhJ0vi2gIrHVWPdBLosp1HqBoQn5spTeaLZkjbUcDngarA5bWHNxKq6jPAM2HmfQ/4Xojp1wU830pQ6yxjuqt2xxHOHlJKYV58B1RaujRxPQAlouxxg0oozs9h2c4j3Dh1WNzLN5kpmovoz+Ic3b8A+BIbjjHJ097pY2Xd0YT0wJuIGwgTWXZ2lnD+8L7U7jga97JN5oomgbSq6s8THokxSbZubyOt7T4bTMlVPbIfv/jHJhpb2yktyPU6HJMGormI/j8i8i0RuVhEpvofCY/MmARbvK0egGmj4t+J4KxZs5g1a1bcy01k2dNGleNTp1rPmGhEcwZyDvBxnDu//VVY6r42Jm29va2eqv59qCiN/wjNc+bMARLTK2+iyp4yoi85WcKSbfXMGD8ormWbzBRNArkZGK3WUaHJID6fsmR7PVdPqvA6lJTRJy+HyUPLTp6ZGdOVaKqwVuOMi25Mxth0oJmjx9qZNqq/16GklAtHlbOqroHW9uC+S405UzQJpC+wXkTmi8jz/keiAzMmkRZvOww4P5jmlAuqyjnR6WPlLmuNZboWTRXWtxIehTFJ9va2egaXFfTaDhTDuaCqHBGngcGFo+3szETW5RmIqr4a+MAZ5OmWxIdmTGKoKou31bs/lr1rBMKulPXJZUJlKW+5Z2jGRBLV6DEiMgX4CM4F9W3AnxMZlDGJtOVgMwea2rhkTOKOsKdOTVxL90SWDXDJmP788a0dtLZ3UpAb3zv0TWaJNCb6WcCH3cch4ElAVHVGkmIzJiH+tdk5ur507ICEbcM/7Gy6lQ1OAvnt69tYvvMoFycwyZr0F6kKaz3OvR7Xq+q7VPUXONVXxqS1f20+xLB+hQwv7+N1KClp2qhysrOEN7cc8joUk+IiJZAbgb3AQhGZIyJX4IzDYUza6vQpb209zKVjEnf2ke5KCnI5Z2gZb2yx6yAmsrAJRFWfVdXbgAk4Y2/cCwwSkYdE5OpkBWhMPK3Z00BjaweXjE1s1YyIJOwCfSLL9rtkTH9W7DpKS1tH1wubXiuaVlgtqvqEqt4ADMMZe+O+hEdmTAL4r39Y3X5kl4wZQIdP7a50E1E0NxKepKpHVHW2ql6RqICMSaTXNx9kfEUJg0ri3/9VJqmp6kd+ThavbTrodSgmhXUrgRiTzlraOliy7QiXjx/odSgpryA3mwtH9+fVjZZATHiWQEyv8dbWw5zo9HH5WZZAonH5WQPZerCFuiM2TroJzRKI6TVe3XiQwtxsaqpsAKloXH6W01LttY3WnNeEZgnE9BqvbjzIxWP6k59jd1dHY8zAYoaUFfDqxgNeh2JSVFRdmRiT7rYfamHH4WPceemopGzv4YcfTsuyA4kIl48fyLyVe2nv9JGbbceb5nSefCNE5GYRWSMiPhGpCZh+lYjUisg77t+Qox6KyIMisltEVriP65IXvUlH/1jvHEUn6/pHOg5pG8r08YNoautgiTXnNSF4dUixGudO99eCph8CblDVc4DbgT9EKONnqnq++3gpQXGaDPHK+v2MHVRM1YAir0NJK+8eN4C8nCwWrLNqLHMmTxKIqq5T1Q0hpi9X1T3uyzVAoYjkJzc6k2kaW9t5e2s9V05M3vC1s2fPTsh46IkuO1ifvBwuGdOfV9bvR1WTsk2TPsTLL4WILAK+oqpLQ8z7EPBpVb0yxLwHgTuARmAp8GVVPRJmG7OAWQAVFRXVc+fOjSnWhvpGyspLY1o3mZqbmykuLvY6jKgkK9a393bw0Mo2vn5hAeP6df8CeixxzpjhdFq9cOHCbm8v1rITtT//sbOdx9ae4PvvKmRIcXyOOdPle5pJcTbsOUbZkNg6EJ0xY0atqtacMUNVE/IAFuBUVQU/ZgYsswioCbHu2cAWYEyYsiuAbJwzqO8Bv4smpurqao3Vs4+/GPO6ybRw4UKvQ4hasmL9wp+W6ZRv/107On0xrR9LnIA6/17xF67sRO3P3UeO6cj75ulDizbHrcx0+Z5mUpzPf+PtmMsHlmqI39SEtcLSEGcO0RCRYcAzwCdUdUuYsvcHLD8HmBdTkCbjtXf6WLThIFdOrCA7yzqTjsWQvoVMGlzK39fs49OXj/E6HJNCUqpdnoj0BV4E7lfVf0VYbnDAyw/inNkYc4Y3txym4Xg710yu9DqUtHbt5EqW7TzKvoZWr0MxKcSrZrwfFJE64GLgRRGZ7876HDAW+PeAJrqD3HUeCWjy+0O3qe8qYAbwpWS/B5Me/rp6L0V52bx7nI3/0RPXnuMk4Plr9nkciUklntxIqKrP4FRTBU//LvDdMOvcFfD844mLzmSKjk4f89fs54qJFTa2dw+NHVTCuEHF/HX1Xm6/pMrrcEyKSKkqLGPiafG2eupbTnDdOVZ9FQ/XTq5k8bZ6DjW3eR2KSRGWQEzGevGdvRTmZnP5WYOSvm091WIwrcqO5NpzBuNT+Ntqq8YyDksgJiO1d/r46+p9XDFxEIV5Vn0VDxMqSxg7qJjnV+7pemHTK1gCMRnpn5sOUt9ygg+cP9TrUDKGiDDzvCEs3lbP7qPHvQ7HpABLICYjPbt8D3375HKZR4NHVVdXU11dnXZld2Wmm5BfsLMQg3XnbjJQS1sHL6/dz41Th5KX480x0rJly9Ky7K6M6N+HKSP68tyKPXZTobEzEJN55q/Zx/H2Tj4wxaqvEuED5w9l3d5G1u5p9DoU4zFLICbjPLlkFyP796FmpA1dmwjvP28IedlZPFW7y+tQjMcsgZiMsv1QC29vq+eWmuGIWN9XidCvKI+rzq7gmeW7aevo9Doc4yFLICaj/O/SXWQJ3DR1mNehZLRba4Zz9Fg7C9baQFO9mSUQkzE6On38eVkd08cPorKswOtwMtqlYwcwpKyAuUt2eh2K8ZC1wjIZY8G6/exvbOM7M4d7HQp33313WpYdrews4dYLRvCzBRvZdqiFUTZUcK9kCcRkjEff2MHQvoVckcSha8NJ5JCzyRrOtisfnjacX/xjE398awffvH6S1+EYD1gVlskIG/c38ebWw3zsopE2cFSSDCot4JrJlTy1dBfHT9jF9N7IEojJCI++sZ28nCxuvcD76iuA2tpaamtr067s7vrExVU0tnbwzPLdXodiPGBVWCbtHW5u48/L6ph53hDKi/K8DgeAmhpn7LNE9JqbyLK764KqfkweWsojr2/ltguGk2Vnf72KnYGYtPfYmztobfcx67LRXofS64gIsy4bw9aDLSxYt9/rcEySWQIxae34iU4ee3M7V04cxLiKEq/D6ZWum1zJsH6FzH5tq9ehmCSzBGLS2pNLdnLkWDv3WMd+nsnJzuKud41i6Y4jvL31sNfhmCSyBGLSVmt7J79etIVpVeXW75XHbps2goEl+fzPK5u8DsUkkSUQk7aeeHsnB5ra+NJVZ1m/Vx4ryM3m05eP4Y0th+0spBfxJIGIyM0iskZEfCJSEzC9SkSOi8gK9/GbMOuXi8jLIrLJ/WuHn73M8ROdPPTqFi4aXc7FY/p7HY4BPnqhcxbyk5c3pkQLMZN4Xp2BrAZuBF4LMW+Lqp7vPj4dZv37gVdUdRzwivva9CK/fX0rB5va+PLV470OJaSlS5eydOnStCu7Jwpys/ncjLEs3lbPP9ZbJ4u9gSf3gajqOqAn1Q4zgenu80eBRcB9PY3LpIeDTW08tGgL7z27gguqyr0OJ6REDjnr1XC20fjIhSP4/Rvb+c+/rufyswaSk2215JlMvDzVFJFFwFdUdan7ugpYA2wEGoFvqOo/Q6x3VFX7us8FOOJ/HWLZWcAsgIqKiuq5c+fGFGtDfSNl5aUxrZtMzc3NFBcXex1GVGKN9fdr2vhnXQffe1chlUWJ/4FKl32aKnHW7u/gF8vb+MSkPN4zIjfkMqkSa1cyKc6GPccoG9InpvJnzJhRq6o1Z8xQ1YQ8gAU4VVXBj5kByywCagJe5wP93efVwC6gNETZR4NeH4kmpurqao3Vs4+/GPO6ybRw4UKvQ4haLLGu3HVEq+6fpw8+vzr+AYURS5x333233n333fEPJkLZqfLZ+3w+vfXhN/TcB+froabWkMukSqxdyaQ4n//G2zGXDyzVEL+pCTt8U9UrVXVyiMdzEdZpU9XD7vNaYAtwVohF94vIYAD3r1W49gKdPuXrz6xmQHE+X7oq1NcidcyZM4c5c+akXdnxICJ8Z+ZkWto6+K+/rvc6HJNAKVVBKSIDRSTbfT4aGAeEur31eeB29/ntQNikZDLHo29s553dDXzz+kmUFoSuGjGpYVxFCXe9ezRP1dbxxpZDXodjEsSrZrwfFJE64GLgRRGZ7866DFglIiuAp4FPq2q9u84jAU1+/wu4SkQ2AVe6r00G23qwmR/OX8/08QO54dzBXodjovDFK8ZR1b8PX3t6Fc1tHV6HYxLAkwSiqs+o6jBVzVfVClV9rzv9z6p6tjpNeKeq6gsB69yl7sV2VT2sqleo6ji3qqzei/dhkqOj08eXn1pJfk42P7jpXLtpME0U5mXz45vPY/fR43zvxbVeh2MSIKWqsIwJ5b8XbGL5zqN8e+bZVJTaWOfppKaqnFmXjeZPi3fxwso9Xodj4swSiElpCzcc4JcLN3NLzTBmnj/U63BMDL5y9XimjujLA395h60Hm70Ox8SRJRCTsrYcbObeuSuYUFnCt2dO9jqcbpk6dSpTp05Nu7ITITc7i19+ZCq52cLdjy2l4Xi71yGZOLEEYlJSfcsJ7vz9EnKyhDmfqKEgN9vrkLqltwxpG60hfQt56GPV7Kw/xmcer6XDZ31lZQJLICblNLW288nfL2FvQyuzP1HD8PLY7p41qeWi0f35zxvP5V+bDzN7VRudlkTSno2JHoVnltcxd5fyxtOrEAGnEZCQ5T4XBBHIclsH+aednC+C4P4V55Q+P8d95GaffF6Qm01JQQ5lhbmUFuRS1ieXkvycXtXqqLmtg0/+vyWs2d3AQx+rptrG+cgoH6oeRn1LG99/aT1ffXolP7zp3F7TX5aq0tbho6m1g+a2DppbO2hqa3det3bQ1uGjvdN5nOj00d6hdPhOf+7veUpRt0xQYM+eNubXvwMB00/Nd16M0fg3pbYEEoUtB1rY0Aw7Nh7Ep87H4XxAik/d7mDcaT73E3Veu/PRkx+0qtLeGf2RV5ZAaWEu/frkUVGaz+CyQirLChhcVsDgskJGDejD8PI+5OekVxVPKIea2/jk/1vC2r2N/Py2KVw1qcLrkGLmT/qagL7mEll2Msy6bAzrN23hL8t209zawc8/PCXtqihDaWxtZ+fhY+ysP8aOw8fY13CcA01tHGxq42BzGwca2zje3tmtMrPcA8687Cyys08diAL4DytF4MSJTvKO7HcPXk9Nd5ZzDlwrND8u7zOQJZAofOW94xl3eAszP3JFXMpTVU50+mjr8NHW7qOto5O2Dh/HT3TS1NpBw/F2Go+30xDwqD92gv0NrSzeVs+BptbTklCWwPDyPowaUER+axuHSuo4e0gpYwcVk5smR3fr9zVyzx9q2d/YypxPVPOeCembPEzX3j8mj3MnjOM/5q3lw3Pe4jcfq06bJtoNx9vZsK+JDfsaWbevifV7G9l2qIUjx05vHFBakMOg0gIGFudz3rC+DCrJp19RHqUFORQX5FCSn0txQQ7F+TmUFORQmJtNbnYWOdlCbnYWudlZZGdFV/uwaNEipk+fHnGZF765ONa3HJYlEA+ICPk52c5ZQwz/Mz6fcrjlBLuPHmfboWa2HWxhy6EWth1sYfP+DubvWAlAXk4W4ytKmDy0lCnD+1Fd1Y/RA4pSqkpMVXm6to5vPrea0oJcnrj7IqaOsGqr3uCOS0dRUVrAl59ayft+/jo/veU8LjtroNdhncanyto9jdTuqKd2xxFqdx5hV/3xk/NLC3KYUFnKNZMHM7J/H0aW92FE/z6MKO9DSS/obscSSBrKyhIGluQzsCSf84ef3ov9PxYuZMTZNazZ0+g+GnjpnX38afEuAPr1yaV6ZD+mjuxHzchyzh1W5ln1weHjPu5+bCkL1h3gwlHl/OIjUxhUkh5HoSY+rj1nMGMGFfOZx5fxid8t5sPTRvC1946nX1GeJ/E0tbazYtdRlm4/wrKdR1iy9Rit850RJQaW5FMzsh8fnjaCiZWlTBhcQmVpQUodkCWbJZAMkyXC2EEljB1UcvLGO59P2XqomdodR1i63TmKWrDO6cA4N1uYPLSMmpH9qB5ZTk1VPwYUx7+uNFB9ywl++/pWZv/zOFlZbXzjfRP55KWjoj5dN5nlrIoS5n3+Xfz05Y088s+tvPTOXj4zfQwfvWgkxfmJ+4lSVeqOHHf+L3bUU7vjKBv2NeJT5/rBhMpSLhmSw/svmUz1yH4M61fYq5NFKJZAeoGsrFNJ5dYLRgDOj/iyHUdYuuMItTvqefTNHcz55zYARg0oonpkP2pG9qOmqh+jBxST1cMfd1Vl+a6jPF1bx1+W1dHa7uOiwdn85PbLGdq3sMfv0aS3gtxs/u91E7lp6jC+99I6/vOv6/n1oi18qHoYN00dxsTBJT3+8W5qbeedugZW1B1l5a6jLN95lANNbQAU5+cwZURfrn7POGqq+nH+8L6UFOQ61xamWA8I4VgC6aXKi/K4clIFV7otndo6Olm9u4Gl252k8sq6/TxdWwdAUV42EweXMnFwKWdVljC8XyEjyvswtF9h2NZfzW0dbD/U4tYfH+HVjQfZ19hKQW4WN5w7hFmXjWb3ulpLHuY04ytLeOzOaSzfeYQ5/9zKY29u57evb2NYv0LePW4gU4b3ZcygIgaXFTKoJP+MJsAnOnwcbnFaPu04fIzNB5rZfLCZDfua2HKw+WTz1lEDirhkTH+q3TPv8ZUldgYcA0sgBoD8nGyqR5ZTPbKce3DOGLYeaqF2+xHW7Glg3d4mnlm++4xuuQtysyjOz6EoP4dOn3LsRCfNbR2c6PCdXKa0IIdLxw7gPRMGcc3kypMXF3evS+Y7TK6HH344LctOFVNG9OPXH62mvuUEf1u9j3+s38+8VXv40+KdJ5fJzhJKC079hHX4lKbW07+fIjC8Xx/Oqijm/ecN4bzhfTlvWBl9+3hzjSXTWAIxIYkIYwYWM2ZgMTAccK6lHGhqY9eRY+w8fIw9R4/T1ObcFNXS1kG2CH3ysynKz6FvYR5V/ftwVmUJo/oX9bgKLN3MmjUrLctONeVFeXzkwhF85MIR+HzKtsMt7Kx3vnt7j7bScLz95P0OWSKUF+UxoDifAcV5J5u2Z8I9JqnKEoiJWlaWUFlWQGVZARdUlXsdjullsrICD2pMKkiPu8yMSTOzZ89m9uzZaVe2Md1hZyDGJMA999wDJKa6KZFlG9MddgZijDEmJpZAjDHGxMSTBCIiN4vIGhHxiUhNwPSPisiKgIdPRM4Psf6DIrI7YLnrkvsOjDHGeHUNZDVwI3Bag3ZVfRx4HEBEzgGeVdUVYcr4mar+OKFRGmOMCcuTBKKq64Cuuib4MDA3KQEZY4zpNvFyUBoRWQR8RVWXhpi3BZipqqtDzHsQuANoBJYCX1bVI2G2MQuYBVBRUVE9d25sOamhvpGy8tKY1k2m5uZmiovTo518usQaS5wzZswAYOHChXGPJ1zZ6bI/IX1izaQ4G/Yco2xIbMNDz5gxo1ZVa4KnJyyBiMgCoDLErK+r6nPuMosIkUBE5ELgEVU9J0zZFcAhnEH+vgMMVtU7o4jpILCjO+8jwAB3m6kuXeKE9InV4oy/dInV4nSMVNUzBmtJWBWWql7Zg9VvA/4Uoez9/uciMgeYF2VMMY9WIyJLQ2XgVJMucUL6xGpxxl+6xGpxRpZyzXhFJAu4hQjXP0RkcMDLD+JclDfGGJNEXjXj/aCI1AEXAy+KyPyA2ZcBu1R1a9A6jwQ0+f2hiLwjIquAGcCXkhK4McaYk7xqhfUM8EyYeYuAi0JMvyvg+ccTFlx46dL5ULrECekTq8UZf+kSq8UZgaetsIwxxqSvlLsGYowxJj1YAjHGGBMTSyBREJFrRGSDiGwWkfu9jsdPRIaLyEIRWev2LfZFd3rK9RUmItvdhg8rRGSpO61cRF4WkU3u334exzg+qC+2RhG5N1X2p4j8TkQOiMjqgGkh96E4fu5+Z1eJyFSP4/yRiKx3Y3lGRPq606tE5HjAvv2Nx3GG/axF5AF3f24QkfcmK84IsT4ZEOd2EVnhTk/ePlVVe0R4ANnAFmA0kAesBCZ5HZcb22Bgqvu8BNgITAIexLlB0/MYA2LdDgwImvZD4H73+f3AD7yOM+hz3weMTJX9idNCcSqwuqt9CFwH/BUQnEYpb3sc59VAjvv8BwFxVgUulwL7M+Rn7f5frQTygVHub0K2l7EGzf8J8O/J3qd2BtK1acBmVd2qqidw7k+Z6XFMAKjqXlVd5j5vAtYBQ72NqltmAo+6zx8FPuBhLMGuALaoaqw9F8Sdqr4G1AdNDrcPZwKPqeMtoG/Q/VNJjVNV/66qHe7Lt4BhyYglkjD7M5yZwFxVbVPVbcBmnN+GpIgUqzidCt5ChJuvE8USSNeGArsCXteRgj/SIlIFTAHedid9zq0u+J3XVUMuBf4uIrVu/2QAFaq6132+D6jwJrSQgntDSLX96RduH6by9/ZOnLMjv1EislxEXhWRd3sVVIBQn3Uq7893A/tVdVPAtKTsU0sgGUBEioE/A/eqaiPwEDAGOB/Yi3N667V3qepU4FrgsyJyWeBMdc69U6JNuYjkAe8HnnInpeL+PEMq7cNwROTrQAfusA04+3OEqk4B/g14QkS87LU0LT7rIB/m9IOdpO1TSyBd2w0MD3g9zJ2WEkQkFyd5PK6qfwGnrzBV7VRVHzCHJJ5qh6Oqu92/B3BuIp0G7PdXq7h/D3gX4WmuBZap2+daKu7PAOH2Ycp9b0XkDuB64KNussOtEjrsPq/FubZwllcxRvisU25/AohIDs7YSk/6pyVzn1oC6doSYJyIjHKPTG8Dnvc4JuBk3edvgXWq+tOA6SnVV5iIFIlIif85zgXV1Tj78XZ3sduB57yJ8AynHdGl2v4MEm4fPg98wm2NdRHQEFDVlXQicg3wNeD9qnosYPpAEcl2n48GxgFbQ5eSeBE+6+eB20QkX0RG4cS5ONnxhXAlsF5V6/wTkrpPk9WKIJ0fOC1aNuJk8q97HU9AXO/CqbJYBaxwH9cBfwDecac/j9PdvZdxjsZpwbISWOPfh0B/4BVgE7AAKE+BfVoEHAbKAqalxP7ESWp7gXacOvhPhduHOK2vfuV+Z98BajyOczPONQT/9/Q37rI3ud+JFcAy4AaP4wz7WQNfd/fnBuBarz97d/rvgU8HLZu0fWpdmRhjjImJVWEZY4yJiSUQY4wxMbEEYowxJiaWQIwxxsTEEogxxpiYWAIxaU9EmmNcr0ZEfh5m3nYRGRBjuR8QkUmxrNvN7fxeRD7UzeW3icinw8yPaT+66/5IRPaJyFdiLcOkH0+GtDUmFajqUmBpAor+ADAPWJuAsnvqq6r6dLwLVdWvikhLvMs1qc3OQEzGEJHpIrJIRJ52x5543L1bHxG5QETeEJGVIrJYRErc5ee58/uLyN/FGVflEZwb8fzlfsxdZ4WIPBxwl2+ziHzPLfMtEakQkUtwOg9ITwAAAyFJREFU+tH6kbv8mKAYbxCRt92O7haISIU7/UG3875FIrJVRL4QsM43xRmD4nUR+VOoo3wRqXY7zqsVkfkSRc+7bu8Kb4ozTst3g+Z9VUSWuJ0K/kd3YjG9hyUQk2mmAPfijN8wGrjU7YLmSeCLqnoeTvcPx4PW+xbwuqqejdNX1wgAEZkI3ApcqqrnA53AR911ioC33DJfA+5W1Tdw7mD+qqqer6pbgrbzOnCROh3dzcXp3sNvAvBenP6XviUiuSJyAc6dxefh9NFVE/yG3f7QfgF8SFWrgd8B34tiX/0P8JCqnoNzl7O/vKtxur+YhtOpYLWIXBZNLKZ3sSosk2kWq9svkDgjtFUBDcBeVV0CoE6PxbgnJ36X4XRKh6q+KCJH3OlXANXAEnf5Qk51WHgCp6oKoBa4Kor4hgFPumcIecC2gHkvqmob0CYiB3C6Zr8UeE5VW4FWEXkhRJnjgcnAy26M2QQkhAguxUkI4HTh8QP3+dXuY7n7uhgnoZREEYvpRSyBmEzTFvC8k55/xwV4VFUfCDGvXU/1BRTttn4B/FRVnxeR6Tgj4PnFGrsAa1T14iiXDxSqLyMB/lNVHz5tosi9MZRvMphVYZneYAMw2K2Cwb3+Efzj/BrwEXf+tYB/IKFXgA+JyCB3XrmIjOxie004R+uhlHGqG/DbwywT6F/ADSJSIM64L9eHWGYDMFBELnZjzBWRs6Ms+zb3+UcDps8H7nS3h4gMdd9/NLGYXsQSiMl46gxFfCvwCxFZCbwMFAQt9h/AZSKyBqcqa6e77lrgGzijKa5y1+3qAvVc4KvuhfIxQfMeBJ4SkVrgUBSxL8G5prIKZxS/d3Cq5ILf34eAH7jvbwVwSVdlA1/EGdzrHQJG11PVvwNPAG+6854GSqKJxfQu1huvMSlORIpVtVlE+uCcKc1S1WUxlPN7YF5PmvFGikVEHgSaVfXHsZZv0oudgRiT+ma7DQKWAX+OJXm4GoDvhLuRsCexiMiPgI8Bdi9IL2JnIMYYY2JiZyDGGGNiYgnEGGNMTCyBGGOMiYklEGOMMTGxBGKMMSYm/x/l2b1GCSNXbgAAAABJRU5ErkJggg==\n"
},
"metadata": {
"needs_background": "light"
}
}
]
},
{
"cell_type": "markdown",
"source": [
"### 8 elements\n",
"\n",
"* Bartlett +/- 7\n",
"* Capon +/- 3"
],
"metadata": {
"id": "ZbdTj-Jeyvuy"
}
},
{
"cell_type": "code",
"source": [
"d = 0.5 # Inter element spacing [lambda]\n",
"N = 2**12\n",
"\n",
"M = 8 # number of antenna elements in the antenna system (ULA)\n",
"delta_theta = 3\n",
"theta1, theta2 = 90+delta_theta, 90-delta_theta\n",
"\n",
"# Array response vectors of the test signal\n",
"a_1 = np.exp(np.arange(0,M,1)*1j*2*np.pi*d*np.cos(np.deg2rad(theta1)))\n",
"a_2 = np.exp(np.arange(0,M,1)*1j*2*np.pi*d*np.cos(np.deg2rad(theta2)))\n",
"\n",
"# Generate multichannel test signal\n",
"soi1 = np.random.normal(0,1,N) # Signal of Interest\n",
"# Notes seems to require some noise , if sigma is too low less reliable outcome?!?\n",
"soi2 = np.random.normal(0,1,N)\n",
"soi_outer = np.outer( soi1, a_1)\n",
"soi_outer+= np.outer( soi2, a_2)\n",
"soi_matrix= soi_outer.T\n",
"\n",
"# Generate multichannel uncorrelated noise\n",
"noise = np.random.normal(0,np.sqrt(10**-1),(M,N))\n",
"\n",
"# Create received signal array\n",
"rec_signal = soi_matrix + noise\n",
"\n",
"R = corr_matrix_estimate(rec_signal.T, imp=\"mem_eff\")\n",
"\n",
"array_alignment = np.arange(0, M, 1)* d\n",
"incident_angles=None\n",
"incident_angles2= np.arange(70,110.01,0.01)\n",
"ula_scanning_vectors = gen_ula_scanning_vectors(array_alignment, incident_angles2)\n",
"\n",
"Bartlett = DOA_Bartlett(R,ula_scanning_vectors)\n",
"Capon = DOA_Capon(R, ula_scanning_vectors)\n",
"\n",
"# DOA_plot(Bartlett, incident_angles, log_scale_min = -50)\n",
"# DOA_plot(Capon, incident_angles2, log_scale_min = -50, alias_highlight=True)\n",
"fig = plt.figure()\n",
"axes = fig.add_subplot(111)\n",
"axes.plot(incident_angles2,Capon)\n",
"axes.set_title('Direction of Arrival estimation ',fontsize = 16)\n",
"axes.set_xlabel('Incident angle [deg]')\n",
"axes.set_ylabel('Amplitude [dB]')\n",
"# Mark nominal incident angles\n",
"axes = plt.axes()\n",
"axes.axvline(linestyle = '--',linewidth = 2,color = 'black',x = theta1)\n",
"axes.axvline(linestyle = '--',linewidth = 2,color = 'black',x = theta2)"
],
"metadata": {
"id": "MqkEDiUtyyth",
"outputId": "f332d129-df43-4aff-a18f-c78177e06517",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 386
}
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stderr",
"text": [
"/usr/local/lib/python3.7/dist-packages/matplotlib/cbook/__init__.py:1317: ComplexWarning: Casting complex values to real discards the imaginary part\n",
" return np.asarray(x, float)\n",
"/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:45: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n"
]
},
{
"output_type": "execute_result",
"data": {
"text/plain": [
""
]
},
"metadata": {},
"execution_count": 19
},
{
"output_type": "display_data",
"data": {
"text/plain": [
""
],
"image/png": "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\n"
},
"metadata": {
"needs_background": "light"
}
}
]
},
{
"cell_type": "markdown",
"source": [
"### 12 elements\n",
"\n",
"* Bartlett: 4.2\n",
"* Capon: 1.7"
],
"metadata": {
"id": "RwBcto0zOCoN"
}
},
{
"cell_type": "code",
"source": [
"d = 0.5 # Inter element spacing [lambda]\n",
"N = 2**12\n",
"\n",
"M = 12 # number of antenna elements in the antenna system (ULA)\n",
"delta_theta = 1.7\n",
"theta1, theta2 = 90+delta_theta, 90-delta_theta\n",
"\n",
"# Array response vectors of the test signal\n",
"a_1 = np.exp(np.arange(0,M,1)*1j*2*np.pi*d*np.cos(np.deg2rad(theta1)))\n",
"a_2 = np.exp(np.arange(0,M,1)*1j*2*np.pi*d*np.cos(np.deg2rad(theta2)))\n",
"\n",
"# Generate multichannel test signal\n",
"soi1 = np.random.normal(0,1,N) # Signal of Interest\n",
"# Notes seems to require some noise , if sigma is too low less reliable outcome?!?\n",
"soi2 = np.random.normal(0,1,N)\n",
"soi_outer = np.outer( soi1, a_1)\n",
"soi_outer+= np.outer( soi2, a_2)\n",
"soi_matrix= soi_outer.T\n",
"\n",
"# Generate multichannel uncorrelated noise\n",
"noise = np.random.normal(0,np.sqrt(10**-1),(M,N))\n",
"\n",
"# Create received signal array\n",
"rec_signal = soi_matrix + noise\n",
"\n",
"R = corr_matrix_estimate(rec_signal.T, imp=\"mem_eff\")\n",
"\n",
"array_alignment = np.arange(0, M, 1)* d\n",
"incident_angles=None\n",
"incident_angles2= np.arange(70,110.01,0.01)\n",
"ula_scanning_vectors = gen_ula_scanning_vectors(array_alignment, incident_angles2)\n",
"\n",
"Bartlett = DOA_Bartlett(R,ula_scanning_vectors)\n",
"Capon = DOA_Capon(R, ula_scanning_vectors)\n",
"\n",
"# DOA_plot(Bartlett, incident_angles, log_scale_min = -50)\n",
"# DOA_plot(Capon, incident_angles2, log_scale_min = -50, alias_highlight=True)\n",
"fig = plt.figure()\n",
"axes = fig.add_subplot(111)\n",
"axes.plot(incident_angles2,Capon)\n",
"axes.set_title('Direction of Arrival estimation ',fontsize = 16)\n",
"axes.set_xlabel('Incident angle [deg]')\n",
"axes.set_ylabel('Amplitude [dB]')\n",
"# Mark nominal incident angles\n",
"axes = plt.axes()\n",
"axes.axvline(linestyle = '--',linewidth = 2,color = 'black',x = theta1)\n",
"axes.axvline(linestyle = '--',linewidth = 2,color = 'black',x = theta2)"
],
"metadata": {
"id": "YA0zr6BTOHo0",
"outputId": "bfa3a6ab-abe7-4869-e1b5-c0e3ce5c6d8d",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 386
}
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stderr",
"text": [
"/usr/local/lib/python3.7/dist-packages/matplotlib/cbook/__init__.py:1317: ComplexWarning: Casting complex values to real discards the imaginary part\n",
" return np.asarray(x, float)\n",
"/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:45: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n"
]
},
{
"output_type": "execute_result",
"data": {
"text/plain": [
""
]
},
"metadata": {},
"execution_count": 31
},
{
"output_type": "display_data",
"data": {
"text/plain": [
""
],
"image/png": "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\n"
},
"metadata": {
"needs_background": "light"
}
}
]
},
{
"cell_type": "markdown",
"source": [
"## angle of arrival with FFT\n",
"\n",
"the phase increase as a function of distance between antennas and angle of arrival\n",
"\n",
"$$ \\omega = 2 \\cdot \\pi \\cdot \\lambda \\cdot d \\cdot sin(\\theta)$$\n",
"\n",
"Where:\n",
"* $ \\lambda $ is the wavelength\n",
"* $ \\theta $ is the angle of arrival (AoA)\n",
"* d is the distance between antennas\n",
"\n",
"The AoA can be computed by looking for peaks in the FFT of the range FFT phase.\n",
"\n",
"Similarly to temporal FFT, physical FFT defines:\n",
"\n",
"* angular range bin, physical range bin is $ \\frac{1}{d \\cdot \\frac{N}{2}} \\iff $ angular range bin is $ \\frac{2 \\cdot \\lambda *pi}{d \\cdot N} = \\frac{4*pi}{N}$\n",
"* angular resolution\n",
"\n"
],
"metadata": {
"id": "CAD4Ew1mXs_G"
}
},
{
"cell_type": "code",
"source": [
"\"\"\"X=arange(0,100,1e-2)\n",
"Y=sin(2*pi*10*X)\n",
"FA = fmcw_fft(Y,X,1/1e-2,plot_fft=False)\n",
"FAt = fmcw_fft(Y,X,1/1e-2,plot_fft=True)\n",
"print(FA)\"\"\"\n",
"\n",
"lambda1 = 0.05\n",
"d = lambda1 /2\n",
"Nrx = 20\n",
"X = arange(0.0, d*Nrx, d)\n",
"theta1=20\n",
"theta2 = 45\n",
"F1 = 1/lambda1*sin(theta1*pi/180)\n",
"F2 = 1/lambda1*sin(theta2*pi/180)\n",
"\n",
"#ensure that there is at least one full period\n",
"assert F1*X[-1]>1\n",
"assert F2*X[-1]>1\n",
"#Y = sin(2*pi*F1*X)\n",
"Y = sin(2*pi*F1*X)+sin(2*pi*F2*X)\n",
"Fest=fmcw_fft(Y,X,1/d,plot_fft=False,Npeaks=2)\n",
"theta_est = [f1*lambda1*180/pi for f1 in Fest]\n",
"print(\"tetha est\",theta_est)\n",
"F0=fmcw_fft(Y,X,d,plot_fft=True)\n"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 312
},
"id": "3c3ELYtgXwc7",
"outputId": "094c3737-0012-4e26-a183-4e964c62a548"
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"tetha est [44.5633840657307, 19.098593171027442]\n"
]
},
{
"output_type": "display_data",
"data": {
"text/plain": [
""
],
"image/png": "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\n"
},
"metadata": {
"needs_background": "light"
}
}
]
},
{
"cell_type": "markdown",
"source": [
"## angle of arrival with cross-correlation\n",
"\n",
"background maths:\n",
"* https://www.eecs.umich.edu/courses/eecs206/archive/spring02/lab.dir/Lab3/lab3_v3_0_release.pdf\n",
"\n",
"> p7/14 gives refresher of correlation of different sine waves to find frequencies\n",
"\n",
"https://www.comm.utoronto.ca/~rsadve/Notes/DOA.pdf\n",
"\n",
"> Fig 1. for different methods for spectral estimation and DoA\n",
"\n",
"> Pcorr(φ) is a non-adaptive estimate of the spectrum of the incoming data. The M largest peaks of\n",
"this plot are the estimated directions of arrival.\n",
"In the case of our linear, equispaced array, the steering vector s(φ) is equivalent to Fourier\n",
"coefficients, i.e., the correlation in Eqn. (33) is equivalent to a DFT of the data vector x. We will\n",
"see that this technique is optimal (in the maximum likelihood sense) in the single user situation.\n",
"\n",
"> ibid `p6/25`"
],
"metadata": {
"id": "k5XcKdjo6HU5"
}
},
{
"cell_type": "code",
"source": [
"corr = []\n",
"angles = range(-90,91,1)\n",
"for theta in angles:\n",
" fc = 1/lambda1*sin(theta*pi/180)\n",
" yc = sin(2*pi*fc*X)\n",
" xcor = [yc[i]*Y[i] for i in range(len(X))]\n",
" corr.append(sum(xcor))\n",
"f, ax1 = plt.subplots(num=1, clear=True)\n",
"ax1.plot(angles,corr,'-r')\n",
"\n",
"top4 = sorted(corr,reverse=True)[:4]\n",
"angle4 = [angles[list(corr).index(peak)] for peak in top4]\n",
"print(angle4)\n",
"print(theta1,theta2)"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 300
},
"id": "0CXvNb3o6Knj",
"outputId": "2bdf321c-f85f-498a-8590-e7220f31a88f"
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"[45, 20, 44, 21]\n",
"20 45\n"
]
},
{
"output_type": "display_data",
"data": {
"text/plain": [
""
],
"image/png": "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\n"
},
"metadata": {
"needs_background": "light"
}
}
]
},
{
"cell_type": "markdown",
"source": [
"## DFT"
],
"metadata": {
"id": "TlZmNnysg56j"
}
},
{
"cell_type": "code",
"source": [
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"\n",
"plt.style.use('seaborn-poster')\n",
"%matplotlib inline\n",
"\n",
"\n",
"def DFT(x):\n",
" \"\"\"\n",
" Function to calculate the\n",
" discrete Fourier Transform\n",
" of a 1D real-valued signal x\n",
" \"\"\"\n",
"\n",
" N = len(x)\n",
" n = np.arange(N)\n",
" k = n.reshape((N, 1))\n",
" e = np.exp(-2j * np.pi * k * n / N)\n",
"\n",
" X = np.dot(e, x)\n",
"\n",
" return X"
],
"metadata": {
"id": "grolGk4qhDWE"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"\n",
"\n",
"# sampling rate\n",
"sr = 100\n",
"# sampling interval\n",
"ts = 1.0/sr\n",
"t = np.arange(0,1,ts)\n",
"\n",
"freq = 1.\n",
"x = 3*np.sin(2*np.pi*freq*t)\n",
"\n",
"freq = 4\n",
"x += np.sin(2*np.pi*freq*t)\n",
"\n",
"freq = 7\n",
"x += 0.5* np.sin(2*np.pi*freq*t)\n",
"\n",
"plt.figure(figsize = (8, 6))\n",
"plt.plot(t, x, 'r')\n",
"plt.ylabel('Amplitude')\n",
"\n",
"plt.show()"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 387
},
"id": "S0VuFOOKhFJc",
"outputId": "2883b3d1-63e5-4019-c602-b2b70ad12738"
},
"execution_count": null,
"outputs": [
{
"output_type": "display_data",
"data": {
"text/plain": [
""
],
"image/png": "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\n"
},
"metadata": {
"needs_background": "light"
}
}
]
},
{
"cell_type": "code",
"source": [
"freqs = [1,4,7]\n",
"x = np.sin(2*np.pi*freqs[0]*t)\n",
"for f in [1,4,7]:\n",
" x+=np.sin(2*np.pi*f*t)\n",
"\n",
"X = DFT(x)\n",
"\n",
"# calculate the frequency\n",
"N = len(X)\n",
"n = np.arange(N)\n",
"T = N/sr\n",
"freq = n/T\n",
"\n",
"plt.figure(figsize = (12, 6))\n",
"#plt.figure(figsize = (8, 6))\n",
"plt.subplot(221)\n",
"\n",
"plt.plot(t, x, 'r')\n",
"plt.ylabel('Amplitude')\n",
"\n",
"plt.subplot(222)\n",
"\n",
"plt.stem(freq, abs(X), 'b', \\\n",
" markerfmt=\" \", basefmt=\"-b\")\n",
"plt.xlabel('Freq (Hz)')\n",
"plt.ylabel('DFT Amplitude |X(freq)|')\n",
"\n",
"n_oneside = N//2\n",
"# get the one side frequency\n",
"f_oneside = freq[:n_oneside]\n",
"\n",
"# normalize the amplitude\n",
"X_oneside =X[:n_oneside]/n_oneside\n",
"\n",
"\n",
"plt.subplot(223)\n",
"plt.stem(f_oneside, abs(X_oneside), 'b', \\\n",
" markerfmt=\" \", basefmt=\"-b\")\n",
"plt.xlabel('Freq (Hz)')\n",
"plt.ylabel('DFT Amplitude |X(freq)|')\n",
"\n",
"plt.subplot(224)\n",
"plt.stem(f_oneside, abs(X_oneside), 'b', \\\n",
" markerfmt=\" \", basefmt=\"-b\")\n",
"plt.xlabel('Freq (Hz)')\n",
"plt.xlim(0, 10)\n",
"plt.tight_layout()\n",
"#plt.show()\n",
"\n",
"plt.show()"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 523
},
"id": "GhL6JGXxhMXb",
"outputId": "44d78950-8460-4a14-8894-e9a999a58ac2"
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stderr",
"text": [
"/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:23: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n",
"/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:36: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n",
"/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:41: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n"
]
},
{
"output_type": "display_data",
"data": {
"text/plain": [
""
],
"image/png": "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\n"
},
"metadata": {
"needs_background": "light"
}
}
]
},
{
"cell_type": "markdown",
"source": [
"## AoA - MRE (old #2)\n",
"\n",
"Below computes AoA for one target with 2 antennas, only looking at the phase difference"
],
"metadata": {
"id": "xECwQNYPrmD7"
}
},
{
"cell_type": "code",
"source": [
"from numpy import abs ,angle, arange, arcsin, cos, pi, sqrt, tan\n",
"from scipy.fft import fft\n",
"\n",
"class Object(object):\n",
" def __init__(self, x, y, z):\n",
" self.x = x\n",
" self.y = y\n",
" self.z = z\n",
" def dist(self, obj2):\n",
" sx = self.x\n",
" sy = self.y\n",
" sz = self.z\n",
" ox = obj2.x\n",
" oy = obj2.y\n",
" oz = obj2.z\n",
" distance = sqrt((sx-ox)**2+(sy-oy)**2+(sz-oz)**2)\n",
" return distance\n",
" def __str__(self):\n",
" return f\"x: {self.x}, Y: {self.y}, z: {self.z}\"\n",
"\n",
"def y_IF(f0_min,slope,T, antenna_tx, antenna_rx, target):\n",
" \"\"\" y_{IF} = cos(2 \\pi [-f_0\\delta -2 * K * \\delta * t + K* \\delta^2])\n",
" delta: delta t = distance (m)/c\n",
" A: (x,y,z)\n",
" T: (x,y,z)\n",
" \"\"\"\n",
" c = 3e8\n",
" distance = antenna_tx.dist(target) + antenna_rx.dist(target)\n",
" # delta = sqrt((A.x-target.x)**2+(A.y-target.y)**2+(A.z-target.z)**2)/3e8\n",
" delta = distance/c\n",
" # /!!!!!!\\ most equations have 2 * delta as delta is the one way time of flight\n",
" # here we have computed the 2 way round time of flight ence the lack of 2x\n",
" # see text books ahve\n",
" # YIF = cos(2 *pi *(2 * f0_min * delta + 2 * slope * delta * T + slope * delta**2))\n",
" # but we only have :\n",
" YIF = cos(2 *pi *(f0_min * delta + 2 * slope * delta * T + slope * delta**2))\n",
" return YIF\n",
"f0_min = 60e9\n",
"c = 3e8\n",
"# lambda ~5mm at 60GHz\n",
"lambda0_max = 3e8/f0_min\n",
"n_rx = 2\n",
"Distance = 10\n",
"k = 200e12\n",
"n_samples = 512\n",
"f_if = 2*k*Distance/c\n",
"fs = 50e6\n",
"ts = 1/fs\n",
"\n",
"antenna_tx = Object(-lambda0_max/2,0,0)\n",
"T = arange(0, n_samples*ts+ts, ts)\n",
"\n",
"for theta in [-180/3, -180/6, -180/10, 0, 180/10, 180/6, 180/3]:\n",
" Target = Object(4*tan(theta/180*pi),4,0)\n",
"\n",
" Antennas_RXs = [Object(i*lambda0_max/2,0,0) for i in range(n_rx)]\n",
"\n",
" phases = []\n",
" i_peaks = []\n",
" for target_i in [Target]:\n",
" for antenna_rx in Antennas_RXs:\n",
" Distance = antenna_rx.dist(target_i) + antenna_tx.dist(target_i)\n",
" f_if = 2*k*Distance/c\n",
" assert f_if < 1/ts/2\n",
" YIF = y_IF(f0_min, k,T, antenna_tx, antenna_rx, target_i)\n",
" FT = fft(YIF)\n",
" MAG = abs(FT)[0:int(n_samples/2)]\n",
" ANG = angle(FT)[0:int(n_samples/2)]\n",
"\n",
" # now find the peak\n",
" amplitude_peak = sorted(MAG, reverse = True)[0]\n",
" i_peak = list(MAG).index(amplitude_peak)\n",
" if not i_peaks:\n",
" i_peaks.append(i_peak)\n",
" else:\n",
" try:\n",
" assert i_peak in i_peaks\n",
" except:\n",
" # exit now as we don't have the logic to track across range bins\n",
" print(\"bin range change\")\n",
" break\n",
" phases.append(ANG[0:int(n_samples/2)][i_peak])\n",
" f_peak = i_peak * 1/ts / n_samples\n",
" d2 = f_peak*c/2/k\n",
" dfixed = 0\n",
"\n",
" delta_phase = (phases[0]-phases[1]) #/len(phases)\n",
" # need to verify / proof below formula still seems buggy\n",
" # idea is that phase goes inside frequency range bin and needs to be computed\n",
" # as such\n",
" # print(\"G***\", 90+arcsin(delta_phase*1/ts*c/pi/ n_samples/1/k/lambda0_max)*180/pi)\n",
" if delta_phase/pi>1:\n",
" theta_calc = arcsin(delta_phase/pi -2)*180/pi\n",
" print(f\"theta: {theta:.2g}, calculated_p: {theta_calc:.2g}\")\n",
" elif delta_phase/pi<-1:\n",
" theta_calc = arcsin(delta_phase/pi % +2)*180/pi\n",
" print(f\"theta: {theta:.2g}, calculated_m: {theta_calc:.2g}\")\n",
" else:\n",
" theta_calc = arcsin(delta_phase/pi)*180/pi\n",
" print(f\"theta: {theta:.2g}, calculated: {theta_calc:.2g}\")"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "mWbST4hKruiN",
"outputId": "f5cfc1c6-a206-498b-fbee-c37782ff8ff0"
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"theta: -60, calculated_p: -64\n",
"theta: -30, calculated: -31\n",
"theta: -18, calculated_p: -19\n",
"theta: 0, calculated: -0.019\n",
"theta: 18, calculated: 19\n",
"theta: 30, calculated: 31\n",
"theta: 60, calculated: 64\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"## AoA trial #2"
],
"metadata": {
"id": "IRvNvZwRhqJ3"
}
},
{
"cell_type": "code",
"source": [
"#imports\n",
"from numpy import abs ,angle, arange, array, linspace, matrix, pi, sin, cos, exp\n",
"from numpy import sqrt, arcsin, arccos, arctan, dot, tan\n",
"from numpy import column_stack, identity\n",
"#import scipy.fftpack\n",
"from scipy.fftpack import fft, fftshift, fftfreq\n",
"import matplotlib.pyplot as plt\n",
"\n",
"class Object(object):\n",
" def __init__(self, x, y, z):\n",
" self.x = x\n",
" self.y = y\n",
" self.z = z\n",
" def dist(self, obj2):\n",
" sx = self.x\n",
" sy = self.y\n",
" sz = self.z\n",
" ox = obj2.x\n",
" oy = obj2.y\n",
" oz = obj2.z\n",
" distance = sqrt((sx-ox)**2+(sy-oy)**2+(sz-oz)**2)\n",
" return distance\n",
" def __str__(self):\n",
" return f\"x: {self.x}, Y: {self.y}, z: {self.z}\"\n",
"\n",
"def y_IF(lambda0_max,slope,T, antenna_tx, antenna_rx, target):\n",
" \"\"\" y_{IF} = cos(2 \\pi [-f_0\\delta -2 * K * \\delta * t + K* \\delta^2])\n",
" delta: delta t = distance (m)/c\n",
" A: (x,y,z)\n",
" T: (x,y,z)\n",
" \"\"\"\n",
" distance = antenna_RX.dist(target_i) + antenna_TX.dist(target_i)\n",
" # delta = sqrt((A.x-target.x)**2+(A.y-target.y)**2+(A.z-target.z)**2)/3e8\n",
" delta = distance/c\n",
" f_0 = c/lambda0_max\n",
" YIF = cos(2 *pi *(-f_0 *delta - 2 * slope * delta * T + slope * delta**2))\n",
" return YIF\n",
"\n",
"f0_min = 60e9\n",
"c = 3e8\n",
"# lambda ~5mm at 60GHz\n",
"lambda0_max = 3e8/f0_min\n",
"n_rx = 16\n",
"Distance = 10\n",
"k = 200e12\n",
"n_samples = 512\n",
"f_if = 2*k*Distance/c\n",
"fs = 50e6\n",
"ts = 1/fs\n",
"\n",
"for Target_Angle in [-180/3, -180/6, -180/10, 0, 180/10, 180/6, 180/3]:\n",
" print(\"Target Angle Objective\", Target_Angle)\n",
" Target = Object(4*tan(Target_Angle/180*pi),4,0)\n",
" if abs(Target.x)>0:\n",
" alpha = arctan(Target.y/Target.x)\n",
" else:\n",
" alpha = 0\n",
" # theta = pi/2-alpha\n",
" theta = None\n",
" antenna_TX = Object(-lambda0_max/2,0,0)\n",
" Antennas_RX = [Object(i*lambda0_max/2,0,0) for i in range(n_rx)]\n",
" # ts = 1/f_if/n_samples\n",
" # T = linspace(0.0, n_samples*ts+ts, n_samples)\n",
" T = arange(0, n_samples*ts+ts, ts)\n",
" phases = []\n",
" Distances = []\n",
" i_peaks = []\n",
" for target_i in [Target]:\n",
" for antenna_RX in Antennas_RX[:8]:\n",
" Distance = antenna_RX.dist(target_i) + antenna_TX.dist(target_i)\n",
" Distances.append(Distance)\n",
" f_if = 2*k*Distance/c\n",
" assert f_if < 1/ts/2\n",
" YIF = y_IF(lambda0_max,k,T, antenna_TX, antenna_RX, target_i)\n",
" FT = fft(YIF)\n",
" MAG = abs(FT)[0:int(n_samples/2)]\n",
" ANG = angle(FT)[0:int(n_samples/2)]\n",
"\n",
" # now find the peak\n",
" amplitude_peak = sorted(MAG, reverse = True)[0]\n",
" i_peak = list(MAG).index(amplitude_peak)\n",
" if not i_peaks:\n",
" i_peaks.append(i_peak)\n",
" else:\n",
" try:\n",
" assert i_peak in i_peaks\n",
" except:\n",
" # exit now as we don't have the logic to track across range bins\n",
" print(\"bin range change\")\n",
" break\n",
" phases.append(ANG[0:int(n_samples/2)][i_peak])\n",
" f_peak = i_peak * 1/ts / n_samples\n",
" d2 = f_peak*c/2/k\n",
" dfixed = 0\n",
"\n",
" delta_d = Distances[1]-Distances[0]\n",
" delta_phase = (phases[0]-phases[1]) #/len(phases)\n",
" # need to verify / proof below formula still seems buggy\n",
" # idea is that phase goes inside frequency range bin and needs to be computed\n",
" # as such\n",
" # print(\"G***\", 90+arcsin(delta_phase*1/ts*c/pi/ n_samples/1/k/lambda0_max)*180/pi)\n",
" print(\"delta_phase\",delta_phase/pi)\n",
" if abs(delta_phase/pi)>1:\n",
" print(\"ipeaks\",i_peaks)\n",
" print(\"test ?\",arcsin(delta_phase/pi %1)*180/pi)\n",
" else:\n",
" theta_calc = arcsin(delta_phase/pi)*180/pi\n",
" print(\"theta calc\", theta_calc)\n"
],
"metadata": {
"id": "dH-PZQwohzo7",
"outputId": "3fa2c891-9b1f-4cf8-c360-9d9c216c99b9",
"colab": {
"base_uri": "https://localhost:8080/"
}
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Target Angle Objective -60.0\n",
"delta_phase -0.8954859449632953\n",
"theta calc -63.57091626643821\n",
"Target Angle Objective -30.0\n",
"delta_phase 1.4814397586646584\n",
"ipeaks [126]\n",
"test ? 28.779477208424485\n",
"Target Angle Objective -18.0\n",
"delta_phase -0.3195709654583408\n",
"theta calc -18.636980685491228\n",
"Target Angle Objective 0\n",
"delta_phase -0.00032144728634370725\n",
"theta calc -0.018417573160603964\n",
"Target Angle Objective 18.0\n",
"delta_phase 0.31940018563514966\n",
"theta calc 18.626654540903953\n",
"Target Angle Objective 30.0\n",
"delta_phase 0.5153379636703278\n",
"theta calc 31.020047623162547\n",
"Target Angle Objective 60.0\n",
"delta_phase -1.1048598118773927\n",
"ipeaks [219]\n",
"test ? 63.52644220014059\n"
]
}
]
},
{
"cell_type": "code",
"source": [
"tx = Object(-lambda0_max/2,0,0)\n",
"rx0 = Object(0,0,0)\n",
"rx1 = Object(-lambda0_max/2,0,0)\n",
"angle = 30\n",
"angle = 0\n",
"D0 = 10\n",
"for angle in [0, 30]:\n",
" theta = angle/180*pi\n",
" target = Object(D0*tan(theta),D0,0)\n",
" print(target)\n",
" d1 = tx.dist(target)+rx0.dist(target)\n",
" d2 = tx.dist(target)+rx1.dist(target)\n",
" print(d2-d1,\"///\", lambda0_max/2*sin(theta),\"@@\",rx0.dist(target)-rx1.dist(target))"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "Qq4PIEmky4eU",
"outputId": "6ca6516d-62c0-4db4-eb9c-e0250a49ebd3"
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"x: 0.0, Y: 10, z: 0\n",
"3.1249999565829967e-07 /// 0.0 @@ -3.1249999565829967e-07\n",
"x: 5.773502691896257, Y: 10, z: 0\n",
"0.001250202952732593 /// 0.0012499999999999998 @@ -0.001250202952732593\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"### Non linear FFT x-axis"
],
"metadata": {
"id": "TSGzom-pt2dV"
}
},
{
"cell_type": "code",
"source": [
"from numpy import arange, cos, sin, pi\n",
"from scipy.fft import fft\n",
"import matplotlib.pyplot as plt\n",
"\n",
"f0=500\n",
"f1 =4096\n",
"N = 32\n",
"ts = 1/f0/N\n",
"fs = 1/ts\n",
"assert fs> 2* f0\n",
"print(fs, f0)\n",
"T = arange(0, N*ts, ts)\n",
"y = cos(2*pi*f1*T)\n",
"DFT = fft(y)\n",
"F = arange(0, fs, fs/N)\n",
"fig, (ax1, ax2) = plt.subplots(2, sharex=True)\n",
"\n",
"ax1.title.set_text(r\"default FFT\")\n",
"ax1.tick_params(axis='x', which='minor', bottom=False)\n",
"plt.xticks(F)\n",
"ax1.plot(F, DFT, 'r')"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 525
},
"id": "LwaPd1lJt1-E",
"outputId": "4c645321-99b6-4a64-af54-be7d80902b64"
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"16000.0 500\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"/usr/local/lib/python3.10/dist-packages/matplotlib/cbook/__init__.py:1335: ComplexWarning: Casting complex values to real discards the imaginary part\n",
" return np.asarray(x, float)\n"
]
},
{
"output_type": "execute_result",
"data": {
"text/plain": [
"[]"
]
},
"metadata": {},
"execution_count": 16
},
{
"output_type": "display_data",
"data": {
"text/plain": [
""
],
"image/png": "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\n"
},
"metadata": {}
}
]
}
]
}
![](\"https://upload.wikimedia.org/wikipedia/commons/1/15/Ambox_warning_pn.svg\")
see code cell for warning about same range bin)