ewgeo 0.0.1__tar.gz

ewgeo-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Nicholas A O'Donoughue
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ewgeo-0.0.1/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: ewgeo
+Version: 0.0.1
+Summary: Python code companion to Emitter Detection and Geolocation for Electronic Warfare (Artech House, 2019) and Practical Geolocation for Electronic Warfare Using MATLAB (Artech House, 2022)
+Author-email: Nicholas O'Donoughue <nodonoug@rand.org>
+License-Expression: MIT
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: seaborn
+Dynamic: license-file
+
+# Python Companion to Emitter Detection and Geolocation for Electronic Warfare
+
+<img src="graphics/cover_emitterDet.png" height=200 /><img src="graphics/cover_practicalGeo.png" height=200 />
+
+This repository is a port of the [MATLAB software companion](https://github.com/nodonoughue/emitter-detection-book/) to *Emitter Detection and Geolocation for Electronic Warfare,* by Nicholas A. O'Donoughue, Artech House, 2019.
+
+This repository contains the Python code, released under the MIT License, and when it is complete, it will generate all the figures and implements all the algorithms and many of the performance calculations within the texts *Emitter Detection and Geolocation for Electronic Warfare,* by Nicholas A. O'Donoughue, Artech House, 2019 and *Practical Geolocation for Electronic Warfare using MATLAB,* by Nicholas A. O'Donoughue, Artech House, 2022.
+
+The textbooks can be purchased from Artech House directly at the following links: **[Emitter Detection and Geolocation for Electronic Warfare](https://us.artechhouse.com/Emitter-Detection-and-Geolocation-for-Electronic-Warfare-P2291.aspx)**, and **[Practical Geolocation for Electronic Warfare using MATLAB](https://us.artechhouse.com/Practical-Geolocation-for-Electronic-Warfare-Using-MATLAB-P2292.aspx)** Both are also available from Amazon.
+
+## Installation
+
+### PyPI Install (recommended)
+Use pip to install the package from the PyPI repository
+```
+pip install ewgeo
+```
+
+All the tools will be installed and available by importing the `ewgeo` package.
+```
+import ewgeo
+```
+
+### Local Install
+After cloning or downloading the git repository, you can install it locally in any virtual environment.
+
+If the path to your downloaded copy of the repository is `<PATH_TO_EWGEO>`, then issue the following commands in a terminal window.
+```
+cd <PATH_TO_EWGEO>
+python3 -m venv .venv
+source .venv/bin/activate
+python3 -m pip install -e .
+```
+
+This repository has been tested with Python 3.12 and 3.13. We recommend using a 
+virtual environment for package/dependency handling (the virtual environment 
+does not need to be named `.venv`, however).
+
+### Dependencies
+
+This repository is dependent on the following packages, and was written with Python 3.12.
++ matplotlib
++ numpy
++ scipy
++ seaborn
+
+## Figures
+The **make_figures/** folder contains the code to generate all the figures in the textbook. The subfolder **make_figures/practical_geo** generates figures for the second textbook.
+
+To generate all figures, run the file **make_figures.py**. To run figures for an individual chapter, use a command such as the following:
+```python
+import make_figures
+chap1_figs = make_figures.chapter1.make_all_figures()
+```
+
+## Examples
+The **examples/** folder contains the code to execute each of the examples in the textbook. The subfolder **examples/practical_geo** has examples from the second textbook.
+
+## Utilities
+A number of utilities are provided in this repository, under the following modules:
+
++ **ewgeo.aoa** Code to execute angle-of-arrival estimation, as discussed in Chapter 7
++ **ewgeo.array** Code to execute array-based angle-of-arrival estimation, as discussed in Chapter 8
++ **ewgeo.atm** Code to model atmospheric loss, as discussed in Appendix Carlo
++ **ewgeo.detector** Code to model detection performance, as discussed in Chapter 3-4
++ **ewgeo.fdoa** Code to execute Frequency Difference of Arrival (FDOA) geolocation processing, as discussed in Chapter 12.
++ **ewgeo.hybrid** Code to execute hybrid geolocation processing, as discussed in Chapter 13.
++ **ewgeo.noise** Code to model noise power, as discussed in Appendix D.
++ **ewgeo.prop** Code to model propagation losses, as discussed in Appendix B.
++ **ewgeo.tdoa** Code to execute Time Difference of Arrival (TDOA) geolocation processing, as discussed in Chapter 11.
++ **ewgeo.triang** Code to model triangulation from multiple AOA measurements, as discussed in Chapter 10.
++ **ewgeo.utils** Generic utilities, including numerical solvers used in geolocation algorithms.
+
+## Feedback
+Please submit any suggestions, bugs, or comments as issues in this git repository.

ewgeo-0.0.1/README.md

@@ -0,0 +1,75 @@
+# Python Companion to Emitter Detection and Geolocation for Electronic Warfare
+
+<img src="graphics/cover_emitterDet.png" height=200 /><img src="graphics/cover_practicalGeo.png" height=200 />
+
+This repository is a port of the [MATLAB software companion](https://github.com/nodonoughue/emitter-detection-book/) to *Emitter Detection and Geolocation for Electronic Warfare,* by Nicholas A. O'Donoughue, Artech House, 2019.
+
+This repository contains the Python code, released under the MIT License, and when it is complete, it will generate all the figures and implements all the algorithms and many of the performance calculations within the texts *Emitter Detection and Geolocation for Electronic Warfare,* by Nicholas A. O'Donoughue, Artech House, 2019 and *Practical Geolocation for Electronic Warfare using MATLAB,* by Nicholas A. O'Donoughue, Artech House, 2022.
+
+The textbooks can be purchased from Artech House directly at the following links: **[Emitter Detection and Geolocation for Electronic Warfare](https://us.artechhouse.com/Emitter-Detection-and-Geolocation-for-Electronic-Warfare-P2291.aspx)**, and **[Practical Geolocation for Electronic Warfare using MATLAB](https://us.artechhouse.com/Practical-Geolocation-for-Electronic-Warfare-Using-MATLAB-P2292.aspx)** Both are also available from Amazon.
+
+## Installation
+
+### PyPI Install (recommended)
+Use pip to install the package from the PyPI repository
+```
+pip install ewgeo
+```
+
+All the tools will be installed and available by importing the `ewgeo` package.
+```
+import ewgeo
+```
+
+### Local Install
+After cloning or downloading the git repository, you can install it locally in any virtual environment.
+
+If the path to your downloaded copy of the repository is `<PATH_TO_EWGEO>`, then issue the following commands in a terminal window.
+```
+cd <PATH_TO_EWGEO>
+python3 -m venv .venv
+source .venv/bin/activate
+python3 -m pip install -e .
+```
+
+This repository has been tested with Python 3.12 and 3.13. We recommend using a 
+virtual environment for package/dependency handling (the virtual environment 
+does not need to be named `.venv`, however).
+
+### Dependencies
+
+This repository is dependent on the following packages, and was written with Python 3.12.
++ matplotlib
++ numpy
++ scipy
++ seaborn
+
+## Figures
+The **make_figures/** folder contains the code to generate all the figures in the textbook. The subfolder **make_figures/practical_geo** generates figures for the second textbook.
+
+To generate all figures, run the file **make_figures.py**. To run figures for an individual chapter, use a command such as the following:
+```python
+import make_figures
+chap1_figs = make_figures.chapter1.make_all_figures()
+```
+
+## Examples
+The **examples/** folder contains the code to execute each of the examples in the textbook. The subfolder **examples/practical_geo** has examples from the second textbook.
+
+## Utilities
+A number of utilities are provided in this repository, under the following modules:
+
++ **ewgeo.aoa** Code to execute angle-of-arrival estimation, as discussed in Chapter 7
++ **ewgeo.array** Code to execute array-based angle-of-arrival estimation, as discussed in Chapter 8
++ **ewgeo.atm** Code to model atmospheric loss, as discussed in Appendix Carlo
++ **ewgeo.detector** Code to model detection performance, as discussed in Chapter 3-4
++ **ewgeo.fdoa** Code to execute Frequency Difference of Arrival (FDOA) geolocation processing, as discussed in Chapter 12.
++ **ewgeo.hybrid** Code to execute hybrid geolocation processing, as discussed in Chapter 13.
++ **ewgeo.noise** Code to model noise power, as discussed in Appendix D.
++ **ewgeo.prop** Code to model propagation losses, as discussed in Appendix B.
++ **ewgeo.tdoa** Code to execute Time Difference of Arrival (TDOA) geolocation processing, as discussed in Chapter 11.
++ **ewgeo.triang** Code to model triangulation from multiple AOA measurements, as discussed in Chapter 10.
++ **ewgeo.utils** Generic utilities, including numerical solvers used in geolocation algorithms.
+
+## Feedback
+Please submit any suggestions, bugs, or comments as issues in this git repository.

ewgeo-0.0.1/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ewgeo"
+version = "0.0.1"
+authors = [
+  { name="Nicholas O'Donoughue", email="nodonoug@rand.org" },
+]
+description = "Python code companion to Emitter Detection and Geolocation for Electronic Warfare (Artech House, 2019) and Practical Geolocation for Electronic Warfare Using MATLAB (Artech House, 2022)"
+readme = "README.md"
+requires-python = ">= 3.12"
+dependencies = [
+  "matplotlib",
+  "numpy",
+  "scipy",
+  "seaborn",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

ewgeo-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ewgeo-0.0.1/src/ewgeo/aoa/__init__.py

@@ -0,0 +1,5 @@
+from .aoa import *
+from . import directional
+from . import doppler
+from . import interferometer
+from . import watson_watt

ewgeo-0.0.1/src/ewgeo/aoa/aoa.py

@@ -0,0 +1,56 @@
+import numpy as np
+
+from ewgeo.utils import sinc_derivative
+
+
+def make_gain_functions(aperture_type, d_lam, psi_0):
+    """
+    Generate function handles for the gain pattern (g) and gradient (g_dot),
+    given the specified aperture type, aperture size, and mechanical steering
+    angle.
+
+    Ported from MATLAB Code
+
+    Nicholas O'Donoughue
+    9 January 2021
+
+    :param aperture_type: String indicating the type of aperture requested.  Supports 'omni', 'adcock', 'rectangular'
+    :param d_lam: Aperture length, in units of wavelength (d/lambda)
+    :param psi_0: Mechanical steering angle (in radians) of the array [default=0]
+    :return g: Function handle to the antenna pattern g(psi), for psi in radians
+    :return g_dot: Function handle to the gradient of the antenna pattern, g_dot(psi), for psi in radians.
+    """
+
+    #  type = 'adcock' or 'Rectangular'
+    # params
+    #   d_lam = baseline (in wavelengths)
+    #   psi_0 = central angle
+
+    # Define all the possible functions
+    def g_omni(psi):
+        return np.ones_like(psi)
+
+    def g_dot_omni(psi):
+        return np.zeros_like(psi)
+
+    def g_adcock(psi):
+        return 2*np.sin(np.pi * d_lam * np.cos(psi-psi_0))
+
+    def g_dot_adcock(psi):
+        return -2*np.pi*d_lam*np.sin(psi-psi_0)*np.cos(np.pi*d_lam*np.cos(psi-psi_0))
+
+    def g_rect(psi):
+        # In the text, the function is sinc((psi-psi_0)*d/2*lam), but the sinc function is defined sin(x)/x
+        # In numpy, the sinc function is sin(pi*x)/(pi*x), thus we should divide the argument to numpy.sinc by pi
+        return np.abs(np.sinc((psi-psi_0)*d_lam/np.pi))  # sinc includes implicit pi
+
+    def g_dot_rect(psi):
+        return sinc_derivative((psi - psi_0) * d_lam) * d_lam
+
+    switcher = {'omni': (g_omni, g_dot_omni),
+                'adcock': (g_adcock, g_dot_adcock),
+                'rectangular': (g_rect, g_dot_rect)}
+
+    result = switcher.get(aperture_type.lower())
+
+    return result[0], result[1]

ewgeo-0.0.1/src/ewgeo/aoa/directional.py

@@ -0,0 +1,255 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+from . import make_gain_functions
+from ewgeo.utils.unit_conversions import db_to_lin
+
+
+def crlb(snr, num_samples, g, g_dot, psi_samples, psi_true):
+    """
+    Computes the CRLB for a directional antenna with amplitude measurements taken at a series of angles.  Supports M
+    measurements from each of N different angles.
+
+    If there are multiple true angles of arrival provided (psi_true), then the CRLB is computed independently for each
+    one.
+    
+    Ported from MATLAB Code.
+    
+    Nicholas O'Donoughue
+    14 January 2021
+    
+    :param snr: Signal-to-Noise ratio [dB]
+    :param num_samples: Number of samples for each antenna position
+    :param g: Function handle to g(psi)
+    :param g_dot: Function handle to g_dot(psi)
+    :param psi_samples: The sampled steering angles (radians)
+    :param psi_true: The true angle of arrival (radians)
+    :return crlb: Lower bound on the Mean Squared Error of an unbiased estimation of psi (radians)
+    """
+    
+    # Convert SNR from dB to linear units
+    snr_lin = db_to_lin(snr)
+    
+    # Evaluate the antenna pattern and antenna gradient at each of the steering angles sampled.
+    g_vec = np.array([g(psi-psi_true) for psi in psi_samples])
+    g_dot_vec = np.array([g_dot(psi-psi_true) for psi in psi_samples])
+    
+    # Pre-compute steering vector inner products
+    g_g = np.sum(g_vec * g_vec, axis=0)
+    g_dot_g = np.sum(g_vec * g_dot_vec, axis=0)
+    g_dot_g_dot = np.sum(g_dot_vec * g_dot_vec, axis=0)
+    
+    # Compute CRLB for each true angle theta
+    jacobian = 2 * num_samples * snr_lin * (g_dot_g_dot - g_dot_g ** 2 / g_g)  # Eq 7.25
+    return 1./jacobian  # 1 x num_angles
+
+
+def compute_df(s, psi_samples, g, psi_res=0.1, min_psi=-np.pi, max_psi=np.pi):
+    """
+    Computes an estimate of the angle of arrival psi (in radians) for a set of amplitude measurements s, taken at
+    various steering angles psi_samples
+
+    Ported from MATLAB Code.
+
+    Nicholas O'Donoughue
+    14 January 2021
+
+    :param s: Set of num_samples measurements taken at each of num_steering steering angles.
+    :param psi_samples: Steering angles at which measurements were taken [radians]
+    :param g: Function handle to gain equation, g(psi)
+    :param psi_res: Desired resolution for output estimate [default = .1]
+    :param min_psi: Lower bound on valid region for psi [default = -pi]
+    :param max_psi: Upper bound on valid region for psi [default = pi]
+    :return: Estimated angle of arrival [radians]
+    """
+
+    # Initialize the outer loop to .1 radians
+    this_psi_res = .1
+    psi = 0.  # Initialize output
+
+    # Ensure at least one loop
+    psi_res = min(psi_res, this_psi_res)
+
+    while this_psi_res >= psi_res:
+        psi_vec = np.arange(start=min_psi, stop=max_psi + this_psi_res, step=this_psi_res)  # Set up search vector
+
+        # Find the difference between each possible AoA (psi_vec) and the measurement steering angles
+        psi_diff = psi_samples[:, np.newaxis] - psi_vec[np.newaxis, :]
+
+        # Compute the expected gain pattern for each candidate AoA value
+        g_vec = g(psi_diff)
+    
+        # Find the candidate AoA value that minimizes the MSE between the
+        # expected and received gain patterns.
+        sse = np.sum(np.absolute(s[:, :, np.newaxis]-g_vec[:, np.newaxis, :])**2, axis=(0, 1))
+        idx_opt = np.argmin(sse)
+        psi = psi_vec[idx_opt]
+        
+        # Set up the bounds and resolution for the next iteration
+        this_psi_res /= 10
+        idx_min = max(0, idx_opt-4)
+        idx_max = min(len(psi_vec)-1, idx_opt+4)
+        min_psi = psi_vec[idx_min]
+        max_psi = psi_vec[idx_max]
+
+    return psi
+
+
+def run_example(mc_params=None):
+    """
+    Example evaluation of an Adcock and Rectangular-aperture DF receiver
+
+    Ported from MATLAB code.
+
+    Nicholas O'Donoughue
+    14 January 2021
+
+    :param mc_params: Optional struct to control Monte Carlo trial size
+    :return: None
+    """
+
+    # ================================ Adcock Test Script ================================
+    # Create the antenna pattern generating function
+    # --- NOTE --- g,g_dot take radian inputs (psi, not theta)
+    d_lam = .25
+    [g, g_dot] = make_gain_functions(aperture_type='adcock', d_lam=d_lam, psi_0=0.)
+        
+    # Generate the angular samples and true gain values
+    th_true = 5.                    # degrees
+    psi_true = np.deg2rad(th_true)  # radians
+    psi_res = .001  # desired resolution from multi-stage search directional_df() for details.
+
+    num_angles = 10                        # Number of angular samples
+    th = np.linspace(start=-180., stop=180., num=num_angles, endpoint=False)  # evenly spaced across unit circle
+    psi = np.deg2rad(th)
+    x = g(psi-psi_true)  # Actual gain values
+    
+    # Set up the parameter sweep
+    num_samples_vec = np.array([1, 10, 100])         # Number of temporal samples at each antenna test point
+    snr_db_vec = np.arange(start=-20, step=2, stop=20+2)  # signal-to-noise ratio
+    num_monte_carlo = 1000              # number of monte carlo trials at each parameter setting
+    if mc_params is not None:
+        num_monte_carlo = max(int(num_monte_carlo/mc_params['monte_carlo_decimation']),mc_params['min_num_monte_carlo'])
+
+    # Set up output variables
+    out_shp = [np.size(num_samples_vec), np.size(snr_db_vec)]
+    rmse_psi = np.zeros(shape=out_shp)
+    crlb_psi = np.zeros(shape=out_shp)
+    
+    # Loop over parameters
+    print('Executing Adcock Monte Carlo sweep...')
+    for idx_num_samples, num_samples in enumerate(num_samples_vec.tolist()):
+        this_num_monte_carlo = num_monte_carlo / num_samples
+        print('\tnum_samples={}'.format(num_samples))
+    
+        # Generate Monte Carlo Noise with unit power
+        noise_base = [np.random.normal(size=(num_angles, num_samples)) for _ in np.arange(this_num_monte_carlo)]
+        
+        # Loop over SNR levels
+        for idx_snr, snr_db in enumerate(snr_db_vec.tolist()):
+            print('.')
+            
+            # Compute noise power, scale base noise
+            noise_amp = db_to_lin(-snr_db/2)
+            
+            # Generate noisy measurement
+            y = [x+noise_amp*this_noise for this_noise in noise_base]
+            
+            # Estimate angle of arrival for each Monte Carlo trial
+            psi_est = np.array([compute_df(this_y, psi, g, psi_res, min(psi), max(psi)) for this_y in y])
+
+            # Compute RMS Error
+            rmse_psi[idx_num_samples, idx_snr] = np.sqrt(np.mean((psi_est - psi_true) ** 2))
+
+            # Compute CRLB for RMS Error
+            crlb_psi[idx_num_samples, idx_snr] = crlb(snr_db, num_samples, g, g_dot, psi, psi_true)
+
+        print('done.')
+
+    _, _ = plt.subplots()
+
+    for idx_num_samples, this_num_samples in enumerate(num_samples_vec):
+        crlb_label = 'CRLB, M={}'.format(this_num_samples)
+        mc_label = 'Simulation Result, M={}'.format(this_num_samples)
+
+        # Plot the MC and CRLB results for this number of samples
+        handle1 = plt.semilogy(snr_db_vec, np.rad2deg(np.sqrt(crlb_psi[idx_num_samples, :])), label=crlb_label)
+        plt.semilogy(snr_db_vec, np.rad2deg(rmse_psi[idx_num_samples, :]), color=handle1[0].get_color(),
+                     style='--', label=mc_label)
+
+    plt.xlabel(r'$\xi$ [dB]')
+    plt.ylabel('RMSE [deg]')
+    plt.title('Adcock DF Performance')
+    plt.legend(loc='lower left')
+    
+    # ============================= Reflector/Array Test Script =============================
+    # Create the antenna pattern generating function
+    aperture_size_wavelengths = 5
+    [g, g_dot] = make_gain_functions(aperture_type='rectangular', d_lam=aperture_size_wavelengths, psi_0=0.)
+        
+    # Generate the angular samples and true gain values
+    th_true = 5.
+    psi_true = np.deg2rad(th_true)
+    num_angles = 36  # number of samples
+    th = np.linspace(start=-180, stop=180, num=num_angles, endpoint=False)  # evenly spaced across unit circle
+    psi = np.deg2rad(th)
+    x = g(psi - psi_true)  # Actual gain values
+    psi_res = .001  # desired resolution from multi-stage search, see directional_df for details.
+
+    # Set up the parameter sweep
+    num_samples_vec = np.array([1, 10, 100])  # Number of temporal samples at each antenna test point
+    snr_db_vec = np.arange(start=-20, step=2, stop=20 + 2)  # signal-to-noise ratio
+    num_monte_carlo = 1000  # number of monte carlo trials at each parameter setting
+    if mc_params is not None:
+        num_monte_carlo = max(int(num_monte_carlo/mc_params['monte_carlo_decimation']),mc_params['min_num_monte_carlo'])
+
+    # Set up output variables
+    out_shp = [np.size(num_samples_vec), np.size(snr_db_vec)]
+    rmse_psi = np.zeros(shape=out_shp)
+    crlb_psi = np.zeros(shape=out_shp)
+
+    # Loop over parameters
+    print('Executing Adcock Monte Carlo sweep...')
+    for idx_num_samples, num_samples in enumerate(num_samples_vec.tolist()):
+        this_num_monte_carlo = num_monte_carlo / num_samples
+        print('\tnum_samples={}'.format(num_samples))
+
+        # Generate Monte Carlo Noise with unit power
+        noise_base = [np.random.normal(size=(num_angles, num_samples)) for _ in np.arange(this_num_monte_carlo)]
+
+        # Loop over SNR levels
+        for idx_snr, snr_db in enumerate(snr_db_vec.tolist()):
+            print('.')
+
+            # Compute noise power, scale base noise
+            noise_amp = db_to_lin(-snr_db/2)
+
+            # Generate noisy measurement
+            y = [x + noise_amp * this_noise for this_noise in noise_base]
+
+            # Estimate angle of arrival for each Monte Carlo trial
+            psi_est = np.array([compute_df(this_y, psi, g, psi_res, min(psi), max(psi)) for this_y in y])
+
+            # Compute RMS Error
+            rmse_psi[idx_num_samples, idx_snr] = np.sqrt(np.mean((psi_est - psi_true) ** 2))
+
+            # Compute CRLB for RMS Error
+            crlb_psi[idx_num_samples, idx_snr] = crlb(snr_db, num_samples, g, g_dot, psi, psi_true)
+
+        print('done.')
+
+    _, _ = plt.subplots()
+
+    for idx_num_samples, this_num_samples in enumerate(num_samples_vec):
+        crlb_label = 'CRLB, M={}'.format(this_num_samples)
+        mc_label = 'Simulation Result, M={}'.format(this_num_samples)
+
+        # Plot the MC and CRLB results for this number of samples
+        handle1 = plt.semilogy(snr_db_vec, np.rad2deg(np.sqrt(crlb_psi[idx_num_samples, :])), label=crlb_label)
+        plt.semilogy(snr_db_vec, np.rad2deg(rmse_psi[idx_num_samples, :]), color=handle1[0].get_color(),
+                     style='--', label=mc_label)
+
+    plt.xlabel(r'$\xi$ [dB]')
+    plt.ylabel('RMSE [deg]')
+    plt.title('Rectangular Array DF Performance')
+    plt.legend(loc='lower left')