propNav.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6fddabd4-e944-4c30-a63a-6d61b439939a",
   "metadata": {
    "id": "6fddabd4-e944-4c30-a63a-6d61b439939a"
   },
   "source": [
    "# propNav\n",
    "---------"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e38f5a33-a94a-4b65-b856-4883fab334da",
   "metadata": {
    "id": "e38f5a33-a94a-4b65-b856-4883fab334da"
   },
   "source": [
    "## 3-DOF Kinematic Ideal Proportional Navigation Guidance Missile Flyout Model\n",
    "\n",
    "To best utilize this notebook, keep all code cells collapsed except that which is immediately below the \"Processing Control Options - ...\" markdown cell. Edit contents of that code cell to specify:\n",
    "\n",
    "+ Processing output flags (PRINT_DATA, PLOT_DATA, SHOW_ANIM, SAVE_ANIM, PRINT_TXYZ) and plot figure flags (PLOT_FIGS)\n",
    "+ Missile type (SAM or AAM)\n",
    "+ Proportional navigation guidance type (True, Pure, ZEM, ATPN, APPN or AZEM) and navigation constant (Nm)\n",
    "+ Target turning or weave acceleration (Nt)\n",
    "+ Target initial position and velocity (Pt0, Vt0)\n",
    "+ Missile initial position (Pm0), velocity magnitude (magVm), and launch lead or heading error angles (maz, mel)\n",
    "+ Target rotation direction vector or weave rate (UWt, Wt)\n",
    "+ Integration step size and stop time (T_STEP, T_STOP)\n",
    "\n",
    "then select \"Run Selected Cell and All Below\" for Jupyter \"Run\" or \"Run after\" for Google Colab \"Runtime\" menu options. Processing output text and figures will be presented in output cells following the main routine code cell immediately below the \"Processing Main Routine ...\" markdown cell."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "041a3969-d608-4d64-aa71-f1951b728bb8",
   "metadata": {
    "id": "041a3969-d608-4d64-aa71-f1951b728bb8"
   },
   "source": [
    "### File Header Comment Block"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99187dc6-371c-4bd7-85ed-a8967ae67d25",
   "metadata": {
    "executionInfo": {
     "elapsed": 147,
     "status": "ok",
     "timestamp": 1710972456315,
     "user": {
      "displayName": "Gary Deschaines",
      "userId": "00818646848844190559"
     },
     "user_tz": 300
    },
    "id": "99187dc6-371c-4bd7-85ed-a8967ae67d25",
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "# File: propNav.ipynb\n",
    "# Auth: Gary E. Deschaines\n",
    "# Date: 16 Mar 2024\n",
    "# Prog: Proportional navigation guidance missile flyout model\n",
    "# Desc: Application of selectable proportional navigation guidance laws\n",
    "#       (True, Pure, ZEM, or Augmented PN) for missile engagement\n",
    "#       of a target. 3-DOF point mass kinematic model for missile and\n",
    "#       target. Ideal missile seeker and control: no sensor range or\n",
    "#       field-of-view (FOV) limits, no measurement errors, no lag with\n",
    "#       100% effective, but bounded commanded acceleration, and perfect\n",
    "#       command response.\n",
    "#\n",
    "# Note: Refactored from a Mathcad 3-DOF kinematic ideal proportional\n",
    "#       navigation guidance missile flyout model developed in 1997.\n",
    "#       The inertial (fixed) reference frame Cartesian (+X, +Y, +Z)\n",
    "#       coordinate system in the Mathcad model correlates with (East,\n",
    "#       North, Up), while translational/rotational missile and target\n",
    "#       body frame (+x, +y, +z) axes follow the (forward, right, down)\n",
    "#       convention. Care must be taken in transforming displacement\n",
    "#       and directional vectors between these coordinate frames, and\n",
    "#       describing rotational directions. Specifically, since missile\n",
    "#       and target body frame +x axes are aligned with their respective\n",
    "#       inertial velocity vectors, positive azimuth rotation is negative\n",
    "#       body yaw, while positive elevation rotation is positive body\n",
    "#       pitch. Thus, positive accelerations normal to body frame +x\n",
    "#       axis are those resulting from positive yaw or pitch rates\n",
    "#       crossed with the body frame inertial velocity vector. The +/-\n",
    "#       missile line-of-sigt (LOS) rates and normal accelerations will\n",
    "#       be evident in associated profile plots.\n",
    "#\n",
    "# Refs:\n",
    "#\n",
    "#  [1] Paul Zarchan and A. Richard Seebass (Editor-in-Chief),\n",
    "#      \"Tactical and Strategic Missile Guidance (Progress in\n",
    "#      Astronautics and Aeronautics, Vol 124)\", American\n",
    "#      Institute of Aeronautics and Astronautics, Washington,\n",
    "#      D.C., 1990.\n",
    "#\n",
    "#  [2] Donald T. Greenwood, \"Principles of Dynamics\", Prentice-Hall,\n",
    "#      Inc. of Englewood Clifts, New Jersey, 1965.\n",
    "#\n",
    "#  [3] Neil F. Palumbo, Ross A. Blauwkamp, and Justin M. Lloyd,\n",
    "#      \"Basic Principles of Homing Guidance\", rev 2018, Johns\n",
    "#      Hopkins APL Technical Digest, VOL 29, No 1, 2010. Web\n",
    "#      available at secwww.jhuapl.edu/techdigest:\n",
    "#      https://secwww.jhuapl.edu/techdigest/Content/techdigest/pdf/V29-N01/29-01-Palumbo_Principles_Rev2018.pdf\n",
    "#\n",
    "#  [4] Ben Dickinson, \"Missile Guidance Fundamentals Tutorial\",\n",
    "#      last updated Oct. 15, 2023. Web available at www.youtube.com:\n",
    "#      https://www.youtube.com/playlist?list=PLcmbTy9X3gXt02z1wNy4KF5ui0tKxdQm7\n",
    "#\n",
    "#  [5] Ben Dickinson, \"Guidance from Optimal Control\",\n",
    "#      last updated Apr. 2, 2023. Web available at www.youtube.com:\n",
    "#      https://www.youtube.com/playlist?list=PLcmbTy9X3gXsh-o1W60E7rEA35igNj__q\n",
    "#\n",
    "#  [6] Farham A. Faruqi, \"Integrated Navigation, Guidance, and\n",
    "#      Control of Missile Systems: 3-D Dynamic Model\", Weapon\n",
    "#      Systems Division DSTO, DSTO-TR-2805, Feb., 2013. Web\n",
    "#      available at www.dst.defence.gov.au:\n",
    "#      https://www.dst.defence.gov.au/publication/integrated-navigation-guidance-and-control-missile-systems-3-d-dynamic-model\n",
    "#\n",
    "#  [7] David Hosier, \"Avoiding Gimbal Lock in a Trajectory Simulation\",\n",
    "#      U.S. Army Armament Research, Development and Engineering Center\n",
    "#      ARDEC, METC, Technical Report ARMET-TR-17051, Picatinny Arsenal, New\n",
    "#      Jersey, July 2018. Web Available at discover.dtic.mil:\n",
    "#      https://apps.dtic.mil/sti/pdfs/AD1055301.pdf\n",
    "#\n",
    "#  [8] Neil F. Palumbo, Ross A. Blauwkamp, and Justin M. Lloyd,\n",
    "#      \"Modern Homing Missile Guidance Theory and Techniques\", rev 2018, Johns\n",
    "#      Hopkins APL Technical Digest, VOL 29, No 1, 2010. Web\n",
    "#      available at secwww.jhuapl.edu/techdigest:\n",
    "#      https://secwww.jhuapl.edu/techdigest/Content/techdigest/pdf/V29-N01/29-01-Palumbo_Homing.pdf\n",
    "#\n",
    "#  [9] Ben Dickinson, \"Time to Go Estimation - Guidance Fundamentals II - Section 1.1\",\n",
    "#      last updated Jan. 6, 2024. Web available at www.youtube.com:\n",
    "#      https://youtu.be/sbcPfnm30vA?si=nngS_KMwzqJyxMv3\n",
    "#\n",
    "# Disclaimer:\n",
    "#\n",
    "# See DISCLAIMER\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d8feb87-2bbd-4740-9f91-a5ddf6411603",
   "metadata": {
    "id": "7d8feb87-2bbd-4740-9f91-a5ddf6411603"
   },
   "source": [
    "### Module Imports\n",
    "\n",
    "**NOTE:**\n",
    "\n",
    "1. If this notebook is on Google Drive and run with Google Colaboratory, then set *RUN_WITH_COLAB* to *True* in the following code cell.\n",
    "2. In the following code cell, specify appropriate *Backend* value to display engagement animation and results plots on desktop or inline. The interactive engagement animation can only be displayed on the desktop, and only inline is available with Google Colaboratory.\n",
    "3. A saved engagement animation video may be displayed inline if the moviepy module editor can be imported.\n",
    "4. The Module Imports code cell must be run at least once before all following code cells."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ba8c892-e642-4417-9337-5735d28f1196",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 801,
     "status": "ok",
     "timestamp": 1710972457301,
     "user": {
      "displayName": "Gary Deschaines",
      "userId": "00818646848844190559"
     },
     "user_tz": 300
    },
    "id": "6ba8c892-e642-4417-9337-5735d28f1196",
    "jupyter": {
     "source_hidden": true
    },
    "outputId": "07cf8023-bf31-408c-850a-87b67a82d704"
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "RUN_WITH_SPYDER = False\n",
    "RUN_WITH_COLAB  = False\n",
    "\n",
    "if RUN_WITH_COLAB:\n",
    "    from google.colab import widgets\n",
    "    from google.colab import drive\n",
    "    try:\n",
    "        drive.mount('/content/drive')\n",
    "        # The following statements assumes propNav.ipynb and RK4_Solver.py\n",
    "        # are both in the specified Google Drive folder.\n",
    "        Google_Drive_Folder = '/content/drive/MyDrive/Colab Notebooks/propNav'\n",
    "        if Google_Drive_Folder not in sys.path:\n",
    "            sys.path.insert(0, Google_Drive_Folder)\n",
    "    except:\n",
    "        pass\n",
    "\n",
    "import time\n",
    "\n",
    "from math import ceil, floor, cos, sin, acos, asin, atan, atan2, pi, sqrt\n",
    "from io import StringIO\n",
    "#from locale import format_string\n",
    "import warnings\n",
    "warnings.simplefilter(action='ignore', category=FutureWarning)\n",
    "\n",
    "try:\n",
    "    import numpy             as np\n",
    "    import numpy.linalg      as la\n",
    "    import matplotlib        as mpl\n",
    "    import matplotlib.pyplot as plt\n",
    "    import matplotlib.animation as animation\n",
    "    from mpl_toolkits.mplot3d.art3d import Line3D\n",
    "except ImportError:\n",
    "    print(\"* Error: NumPy and Matplotlib packages required.\")\n",
    "    sys.exit()\n",
    "\n",
    "try:\n",
    "    from RK4_Solver import RK4_Solver\n",
    "except ImportError:\n",
    "    print(\"* Error: RK4_Solver class required.\")\n",
    "    sys.exit()\n",
    "\n",
    "#Backend = 'Qt5Agg'  # to display rendering in desktop window.\n",
    "Backend = 'nbAgg'   # to display rendering animation inline.\n",
    "plt.close('all')\n",
    "mpl.use(Backend)\n",
    "\n",
    "if Backend == 'nbAgg':\n",
    "    if RUN_WITH_COLAB:\n",
    "        %matplotlib inline\n",
    "    else:\n",
    "        if RUN_WITH_SPYDER:\n",
    "            # CAUTION: Embedded 'jshtml' engagement animation in saves of this\n",
    "            #          notebook with output may be upwards of 50 Mb in size.\n",
    "            from matplotlib import rc  # Needed to set Matplotlib animation._repr_html_()\n",
    "            rc('animation',\n",
    "                html='jshtml',    # Matplotlib animation will be HTML wrapped JavaScript\n",
    "                embed_limit=150)  # Embedded animation size will be limited to 150 Mb\n",
    "        try:\n",
    "            %matplotlib ipympl\n",
    "        except:\n",
    "            print(\"No ipympl\")\n",
    "            try:\n",
    "                %matplotlib notebook\n",
    "            except:\n",
    "                print(\"No notebook\")\n",
    "                %matplotlib inline\n",
    "        try:\n",
    "           out = widgets.Output(layout={'border': '1px solid black'})\n",
    "        except:\n",
    "            try:\n",
    "                import ipywidgets as widgets\n",
    "            except:\n",
    "                try:\n",
    "                    %pip install -q ipywidgets\n",
    "                    import ipywidgets as widgets\n",
    "                except:\n",
    "                    print(\"No ipywidgets\")\n",
    "                    widgets = None\n",
    "        finally:\n",
    "            out = None\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1cd46fb-37f7-4c94-a783-e1953a0c714a",
   "metadata": {},
   "source": [
    "### File/Module Scope Constants and Globals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a54f9e5-6bc1-45c3-bf0c-be845f163285",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "RPD = atan(1.0)/45.0  # radians per degree\n",
    "DPR = 1.0/RPD         # degrees per radian\n",
    "g   = 9.80665         # gravitational acceleration at sea-level (meters/s/s)\n",
    "\n",
    "# Unit vectors for inertial Cartesian frame X,Y,Z axes.\n",
    "\n",
    "global Uxi, Uyi, Uzi\n",
    "\n",
    "Uxi = np.array([1.0, 0.0, 0.0])\n",
    "Uyi = np.array([0.0, 1.0, 0.0])\n",
    "Uzi = np.array([0.0, 0.0, 1.0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4dfa85a0-2143-4bcd-9bcb-1ce40269d7e7",
   "metadata": {
    "id": "4dfa85a0-2143-4bcd-9bcb-1ce40269d7e7"
   },
   "source": [
    "### Processing Control Options - Output Flags, PN Guidance Type,  Missile/Target Engagement Options and Initial State "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "996af7c2-c454-44c7-b11a-79fe4f701482",
   "metadata": {
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1710972457301,
     "user": {
      "displayName": "Gary Deschaines",
      "userId": "00818646848844190559"
     },
     "user_tz": 300
    },
    "id": "996af7c2-c454-44c7-b11a-79fe4f701482"
   },
   "outputs": [],
   "source": [
    "# Set processing output control flags.\n",
    "\n",
    "PRINT_DATA = False  # Controls printing of collected data (for debugging)\n",
    "PLOT_DATA  = True   # Controls plotting of collected data\n",
    "SHOW_ANIM  = False  # Controls showing interactive 3D engagement animation\n",
    "SAVE_ANIM  = True   # Controls saving/showing 3D engagement animation\n",
    "PRINT_TXYZ = True   # Controls printing TXYZ.OUT file\n",
    "\n",
    "PLOT_FIGS = { 1:True,  # Closing distance at tStop\n",
    "              2:True,  # XY plan view of intercept geometry at tStop\n",
    "              3:True,  # XZ profile view of intercept geometry at tStop\n",
    "              4:True,  # XY plan view of missile/target engagement\n",
    "              5:True,  # XZ profile view of missile/target engagement\n",
    "              6:True,  # Msl/Tgt velocity magnitude vs time of flight\n",
    "              7:True,  # Msl/Tgt acceleration vs time of flight\n",
    "              8:True,  # Line-of-Sight rate vs time of flight\n",
    "              9:True,  # Closing velocity vs time of flight\n",
    "             10:True,  # Zero Effort Miss distance vs time of flight\n",
    "             11:True,  # Target offset sines wrt missile +x axis\n",
    "             12:True,  # Rotational energy vs time of flight plots\n",
    "             13:True,  # 3D missile/target engagement trajectories plot\n",
    "            }\n",
    "\n",
    "\"\"\"\n",
    "# Plot only selected figures.\n",
    "for ifig in PLOT_FIGS.keys():\n",
    "    PLOT_FIGS[ifig] = False\n",
    "\n",
    "PLOT_FIGS[4] = True\n",
    "PLOT_FIGS[5] = True\n",
    "PLOT_FIGS[6] = True\n",
    "PLOT_FIGS[7] = True\n",
    "PLOT_FIGS[8] = True\n",
    "PLOT_FIGS[9] = True\n",
    "PLOT_FIGS[10] = True\n",
    "PLOT_FIGS[12] = True\n",
    "\"\"\"\n",
    "\n",
    "# Set missile type and acceleration maximum.\n",
    "\n",
    "SAM = 1  # For engagements described in Caveats section of propNav README.\n",
    "AAM = 2  # For engagements presented in Section 3, Modules 3 & 4, Section 4,\n",
    "         # Module 4 of ref [4], and Section 2, Module 3 of ref [5].\n",
    "MSL = SAM\n",
    "\n",
    "global Ammax\n",
    "\n",
    "Gmmax = {SAM:8, AAM:30}  # maximum missile acceleration (g's)\n",
    "Ammax = Gmmax[MSL]*g     # maximum missile acceleration (meters/s/s)\n",
    "\n",
    "# Set minimum miss distance (meters).\n",
    "\n",
    "global MinMissDist\n",
    "\n",
    "if MSL == SAM:\n",
    "    MinMissDist = 3.0\n",
    "else:\n",
    "    MinMissDist = 6.0\n",
    "\n",
    "# Proportional Navigation law (method) selection.\n",
    "\n",
    "PN_TRUE = 1  # With guidance command preservation (GCP1) per ref [3]\n",
    "PN_PURE = 2\n",
    "PN_ZEM  = 3  # Zero Effort Miss per Section 3, Module 4 of ref [4]\n",
    "PN_ATPN = 4  # Augmented True Proportional Navigation per ref [6]\n",
    "PN_APPN = 5  # Augmented Pure Proportional Navigation per ref [6]\n",
    "PN_AZEM = 6  # Augmented Zero Effort Miss per Section 2, Module 2 of ref [5]\n",
    "PN_LAWS = {PN_TRUE:'True', PN_PURE:'Pure', PN_ZEM:'ZEM',\n",
    "           PN_ATPN:'ATPN', PN_APPN:'APPN', PN_AZEM:'AZEM'}\n",
    "PNAV = PN_APPN\n",
    "\n",
    "global Nm, Nt, Wt\n",
    "\n",
    "Nm = 4    # proportional navigation constant\n",
    "Nt = 5.0  # target turning acceleration (g's)\n",
    "Wt = 0.0  # target weave rate (rad/sec)\n",
    "\n",
    "# Define target and missile initial states.\n",
    "\n",
    "if MSL == SAM:\n",
    "    Pt0   = np.array([ 2000.0,    0.0,  500.0])  # 0.0k offset and\n",
    "    Vt0   = np.array([    0.0,  200.0,    0.0])  # crossing\n",
    "    Pt0   = np.array([ 2000.0,  500.0,  500.0])  # 0.5k offset and\n",
    "    Vt0   = np.array([ -200.0,    0.0,    0.0])  # inbound\n",
    "    Pm0   = np.array([    0.0,    0.0,    2.0])\n",
    "    magVm = 450.0\n",
    "else:\n",
    "    if Wt > 0.0:\n",
    "        # For Section 5, Module 2 of ref [4].\n",
    "        Pt0   = np.array([12192.0,   6096.0, 3048.0])\n",
    "        Vt0   = np.array([ -304.8, -Nt*g/Wt,    0.0])\n",
    "        Pm0   = np.array([    0.0,   6096.0, 3048.0])\n",
    "        magVm = 914.4\n",
    "    elif ((int(Nt) == 3) and (int(Nm) >= 2)) and \\\n",
    "         ((PNAV == PN_TRUE) or (PNAV == PN_ATPN) or \\\n",
    "          (PNAV == PN_APPN) or (PNAV == PN_AZEM)):\n",
    "        # for Section 2, Module 3 of ref [5].\n",
    "        Pt0   = np.array([ 9144.0, 6096.0, 3048.0])\n",
    "        Vt0   = np.array([ -304.8,    0.0,    0.0])\n",
    "        Pm0   = np.array([    0.0, 6096.0, 3048.0])\n",
    "        magVm = 457.2\n",
    "    else:\n",
    "        # For Section 3, Modules 3 & 4, Section 4, Module 4 of ref [4],\n",
    "        # and Section 1.1 of ref [9].\n",
    "        Pt0   = np.array([12192.0, 6096.0, 3048.0])\n",
    "        Vt0   = np.array([ -304.8,    0.0,    0.0])\n",
    "        Pm0   = np.array([    0.0, 6096.0, 3048.0])\n",
    "        magVm = 914.4\n",
    "\n",
    "# Verify missile is faster than target.\n",
    "\n",
    "magVt = la.norm(Vt0)\n",
    "if magVm <= magVt:\n",
    "    print(\"Error:  magVm= %8.2f <= magVt= %8.2f;\\n        %s\" % \\\n",
    "          (magVm, magVt, \"Missile must be faster than target.\"))\n",
    "    sys.exit()\n",
    "\n",
    "# Missile lead azimuth and elevation angles in degrees.\n",
    "# Set to None for calculation of lead angles based on\n",
    "# estimation of time-to-intercept of a non-maneuvering\n",
    "# target with constant velocity and heading.\n",
    "\n",
    "if MSL == SAM:\n",
    "    # Point missile at target's current position.\n",
    "    maz = atan2((Pt0[1]-Pm0[1]),(Pt0[0]-Pm0[0]))*DPR\n",
    "    mel = atan((Pt0[2]-Pm0[2])/sqrt((Pt0[0]-Pm0[0])**2 + (Pt0[1]-Pm0[1])**2))*DPR\n",
    "    # Add lead angles.\n",
    "    #maz +=  4.0\n",
    "    #mel +=  2.0\n",
    "    #maz = 10.0\n",
    "    #mel = 12.0\n",
    "    maz = None\n",
    "    mel = None\n",
    "else:\n",
    "    maz = 0.0\n",
    "    mel = 0.0\n",
    "\n",
    "# Define target turning/climbing rotation axis unit vector.\n",
    "\n",
    "global UWt\n",
    "\n",
    "if MSL == SAM:\n",
    "    UWt = Uzi  # for level leftward turn in XY plane\n",
    "    #UWt = -Uzi  # for level rightward turn in XY plane\n",
    "    UWt = np.array([-0.2418, -0.2418, -0.9397])  # shallow diving leftward turn\n",
    "    #UWt = np.array([-0.2418, -0.2418,  0.9397])  # shallow diving rightward turn\n",
    "    #UWt = np.array([-0.5657,  0.5657, -0.6000])  # steep climbing leftward turn\n",
    "    #UWt = np.array([-0.5657,  0.5657,  0.6000])  # steep climbing rightward turn\n",
    "else:\n",
    "    if Wt > 0.0:\n",
    "        UWt = -Uxi  # for weave maneuver\n",
    "    else:\n",
    "        UWt = Uyi  # for climbing turn in XZ plane\n",
    "        #UWt = -Uyi  # for diving turn in XZ plane\n",
    "        #UWt = np.array([0.5657, 0.6000, 0.5657])  # steep rightward climbing turn\n",
    "        #UWt = np.array([0.0000, 0.2500, 0.9682])  # shallow rightward climbing turn\n",
    "        #UWt = np.array([0.5657,-0.6000,-0.5657])  # steep leftward diving turn\n",
    "        #UWt = np.array([0.0000,-0.2500,-0.9682])  # shallow leftward diving turn\n",
    "\n",
    "UWt = UWt/la.norm(UWt)\n",
    "\n",
    "# Set integration time step size and simulation stop time (sec).\n",
    "\n",
    "T_STEP = 0.005\n",
    "if MSL == SAM:\n",
    "    T_STOP = 8.0\n",
    "else:\n",
    "    if Wt > 0.0:\n",
    "        # For Section 5, Module 2 of ref [4].\n",
    "        T_STOP = 11.0\n",
    "    elif ((int(Nt) == 3) and (int(Nm) >= 2)) and \\\n",
    "         ((PNAV == PN_TRUE) or (PNAV == PN_ATPN) or \\\n",
    "          (PNAV == PN_APPN) or (PNAV == PN_AZEM)):\n",
    "        # For Section 2, Module 3 of ref [5].\n",
    "        T_STOP = 15.5\n",
    "    elif (int(Nt) == 6) and \\\n",
    "        ((PNAV == PN_ATPN) or (PNAV == PN_APPN) or (PNAV == PN_AZEM)):\n",
    "        # For Section 1.1 of ref [9].\n",
    "        T_STOP = 13.5\n",
    "    else:\n",
    "        # For Section 3, Modules 3 & 4, Section 4, Module 4 of ref [4].\n",
    "        T_STOP = 13.0\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ac41851-6413-4665-b9c9-60d8b2e0c05c",
   "metadata": {
    "id": "7ac41851-6413-4665-b9c9-60d8b2e0c05c"
   },
   "source": [
    "### Procedures for 3-DOF Kinematic Relative Position, Orientation and Motion in 3D Cartesian Frames"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e50cf1c6-5d54-48c5-9c81-ba68932a487b",
   "metadata": {
    "executionInfo": {
     "elapsed": 3,
     "status": "ok",
     "timestamp": 1710972457301,
     "user": {
      "displayName": "Gary Deschaines",
      "userId": "00818646848844190559"
     },
     "user_tz": 300
    },
    "id": "e50cf1c6-5d54-48c5-9c81-ba68932a487b",
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "def Uvec(V):\n",
    "    \"\"\"\n",
    "    Returns unit direction vector of given vector V.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    V : float 3-vector\n",
    "        Vector.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    U : float 3-vector\n",
    "        Unit direction vector of V.\n",
    "\n",
    "    \"\"\"\n",
    "    magV = la.norm(V)\n",
    "    if magV > 0.0: U = V / magV\n",
    "    else:          U = np.array([0.0, 0.0, 0.0])\n",
    "    return U\n",
    "\n",
    "def Prel(Pt, Pm):\n",
    "    return Pt - Pm\n",
    "\n",
    "def Vrel(Vt, Vm):\n",
    "    return Vt - Vm\n",
    "\n",
    "def Mrot(psi, tht, phi):\n",
    "    \"\"\"\n",
    "    Euler angle (yaw,pitch,roll) rotation transformation matrix\n",
    "    for inertial frame Cartesian coordinates (Xi,Yi,Zi) to body\n",
    "    frame coordinates (xb,yb,zb) derived from equation (7-166)\n",
    "    on pg 335 of ref [2] (same as that presented in Figure 3 on\n",
    "    pg 6 of ref [6]). In the derivation below, consider the\n",
    "    xyz inertial frame depicted in Figure 3 on pg 6 of ref [6]\n",
    "    rotated 180 deg counter-clockwise about the +yi axis so the\n",
    "    +zi axis points toward top of the page, then the following\n",
    "    relationships exist between azimuth, elevation and bank\n",
    "    angles in propNav inertial frame and psi, theta, phi in\n",
    "    the figure:\n",
    "\n",
    "      psi = azimuth\n",
    "      theta = -elevation\n",
    "      phi = bank angle\n",
    "\n",
    "    Note:  Yaw, pitch and roll are expected to be in radians,\n",
    "           NOT degrees!\n",
    "\n",
    "    Use as:  [xb, yb, zb] = Numpy.matmul(Mbi, [Xi, Yi, Zi])\n",
    "    \"\"\"\n",
    "    cpsi = cos(psi)\n",
    "    spsi = sin(psi)\n",
    "    ctht = cos(-tht)\n",
    "    stht = sin(-tht)\n",
    "    cphi = cos(phi)\n",
    "    sphi = sin(phi)\n",
    "\n",
    "    M = np.zeros([3,3])\n",
    "\n",
    "    M[0,0] =  cpsi*ctht\n",
    "    M[0,1] =  spsi*ctht\n",
    "    M[0,2] = -stht\n",
    "    M[1,0] = -spsi*cphi + cpsi*stht*sphi\n",
    "    M[1,1] =  cpsi*cphi + spsi*stht*sphi\n",
    "    M[1,2] =  ctht*sphi\n",
    "    M[2,0] =  spsi*sphi + cpsi*stht*cphi\n",
    "    M[2,1] = -cpsi*sphi + spsi*stht*cphi\n",
    "    M[2,2] =  ctht*cphi\n",
    "\n",
    "    # Account for +yb = -Yi and +zb = -Zi\n",
    "    Mbi = np.matmul(np.array([[1.0,  0.0,  0.0],\n",
    "                              [0.0, -1.0,  0.0],\n",
    "                              [0.0,  0.0, -1.0]]), M)\n",
    "    return Mbi\n",
    "\n",
    "def leadAngle(Pt, Vt, Pm, magVm):\n",
    "    #\n",
    "    # Assuming constant velocity magnitudes and\n",
    "    # headings, at some future intercept point the\n",
    "    # triangle formed by missile velocity magVm and\n",
    "    # target velocity magVt toward that point from\n",
    "    # their current positions Pm and Pt, and the\n",
    "    # LOS distance between current positions (i.e.,\n",
    "    # Rlos = Pt - Pm) must satisfy the following\n",
    "    # relationship:\n",
    "    #\n",
    "    #   Vm*sin(alpha) = Vt*sin(beta)\n",
    "    #\n",
    "    # where alpha (lead angle) is the angle between\n",
    "    # Vm and Rlos, and beta is the angle between Vt\n",
    "    # and Rlos. Using definition of inner product:\n",
    "    #\n",
    "    #   cos(beta) = <Vt, Rlos> / |Vt||Rlos|\n",
    "    #\n",
    "    # a value for beta can determined, and then the\n",
    "    # above relationship solved for alpha.\n",
    "    #\n",
    "    magVt = la.norm(Vt)\n",
    "    Ptm   = Prel(Pt, Pm)\n",
    "    cosb  = np.dot(Vt, Ptm)/(magVt*la.norm(Ptm))\n",
    "    alpha = asin((magVt/magVm)*sin(acos(cosb)))\n",
    "    return alpha  # Note: alpha in radians.\n",
    "\n",
    "def az_el_of_V(V):\n",
    "    # Note: DPR is global.\n",
    "    U  = Uvec(V)\n",
    "    az = atan2(U[1], U[0])*DPR\n",
    "    el = atan2(U[2], la.norm([U[0], U[1]]))*DPR\n",
    "    return az, el  # Note: az and el in degrees.\n",
    "\n",
    "def setVm(vmag, az, el):\n",
    "    # Note: az and el in radians.\n",
    "    vx = vmag*cos(el)*cos(az)\n",
    "    vy = vmag*cos(el)*sin(az)\n",
    "    vz = vmag*sin(el)\n",
    "    Vm = np.array([vx, vy, vz])\n",
    "    return Vm\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aaba3689-a3c5-41a1-8ee6-65e208d42667",
   "metadata": {
    "id": "aaba3689-a3c5-41a1-8ee6-65e208d42667"
   },
   "source": [
    "### Procedures for 3-DOF Kinematic Proportional Navigation Guidance Laws of Ideal Missile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c4bd8207-0855-4d26-b56f-ef0a85980828",
   "metadata": {
    "executionInfo": {
     "elapsed": 3,
     "status": "ok",
     "timestamp": 1710972457301,
     "user": {
      "displayName": "Gary Deschaines",
      "userId": "00818646848844190559"
     },
     "user_tz": 300
    },
    "id": "c4bd8207-0855-4d26-b56f-ef0a85980828",
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "def Vclose(Vt, Vm, Ulos, collision=False):\n",
    "    # Note: Closing velocity is defined as -d(Rlos)/dt.\n",
    "    if collision == True:\n",
    "        # Calculate collision closing velocity (see calcVcTgo).\n",
    "        vt = la.norm(Vt)\n",
    "        vm = la.norm(Vm)\n",
    "        betat = acos(np.dot(Vt, Ulos)/vt)\n",
    "        betam = asin((vt/vm)*sin(betat))\n",
    "        Vc = (vm*cos(betam) - vt*cos(betat))*Ulos\n",
    "    else:\n",
    "        # Calculate standard closing velocity which assumes\n",
    "        # Vt, Vm and Ulos are all within the same plane.\n",
    "        Vc = -np.dot(Vrel(Vt,Vm), Ulos)*Ulos\n",
    "    return Vc\n",
    "\n",
    "def timeToGo(Rlos, Vt, Vm):\n",
    "    # Note: Uses collision closing velocity (see calcVcTgo).\n",
    "    vcc = la.norm(Vclose(Vt, Vm, Uvec(Rlos), True))\n",
    "    tgo = la.norm(Rlos)/vcc\n",
    "    return tgo\n",
    "\n",
    "def calcVcTgo(Pt, Vt, Pm, Vm):\n",
    "    #\n",
    "    # Calculates Vc as collision course relative (closing)\n",
    "    # velocity of missile wrt target, and Tgo as time-to-go\n",
    "    # (to intercept) using equations presented on pgs 25-26\n",
    "    # in sections C.1.1, C.1.2 and C.1.3 of ref [6].\n",
    "    #\n",
    "    # NOTE: Following two expressions assume elt != +/-90\n",
    "    #       and ||[Prel[0], Prel[1]]|| > zero.\n",
    "    azt, elt   = az_el_of_V(Vt)\n",
    "    aztm, eltm = az_el_of_V(Prel(Pt,Pm))\n",
    "\n",
    "    thtt  = elt*RPD\n",
    "    psit  = -azt*RPD\n",
    "    thttm = eltm*RPD\n",
    "    psitm = -aztm*RPD\n",
    "\n",
    "    # Unit vector (evt) along target body, and unit Rlos (estm) vector;\n",
    "    # equations (A2.1) and (A2.2).\n",
    "    evt  = np.array([cos(thtt)*cos(psit), cos(thtt)*sin(psit), -sin(thtt)])\n",
    "    estm = np.array([cos(thttm)*cos(psitm), cos(thttm)*sin(psitm), -sin(thttm)])\n",
    "\n",
    "    # Angle between target velocity vector Vt and the Rlos vector measured\n",
    "    # in Vt X Rlos X Vm plane; equations (A2.3) and (A2.4).\n",
    "    Betatm = acos(np.dot(evt, estm))\n",
    "\n",
    "    # Angle between missile collision course velocity vector and the\n",
    "    # RLos vector measured in Vt X Rlos X Vm plane; equation (A2.6).\n",
    "    Betaccmt = asin((la.norm(Vt)/la.norm(Vm))*sin(Betatm))\n",
    "\n",
    "    # Collision course closing velocity of missile wrt target along\n",
    "    # Rmt; equation (A2.7).\n",
    "    VCccmt = la.norm(Vm)*cos(Betaccmt) - la.norm(Vt)*cos(Betatm)\n",
    "\n",
    "    # Target/missile range-to-go; equation (A2.8).\n",
    "    Rmt = la.norm(Prel(Pm, Pt))\n",
    "\n",
    "    # Time-to-go; equation (A2.9).\n",
    "    Tgo = Rmt/VCccmt\n",
    "\n",
    "    return VCccmt, Tgo\n",
    "\n",
    "def ZEMn(Rlos, Vtm, tgo):\n",
    "    # Zero Effort Miss normal to line-of-sight (LOS) vector Rlos\n",
    "    # towards a non-maneuvering target at time-to-go tgo.\n",
    "    # See derivation of equation (22) on pg 48 in ref [8] and\n",
    "    # discussion of ZEM in Section 4, Module 3 ref [4].\n",
    "    Ulos = Uvec(Rlos)\n",
    "    ZEM  = Rlos + Vtm*tgo\n",
    "    ZEMr = np.dot(ZEM, Ulos)*Ulos\n",
    "    ZEMn = ZEM - ZEMr\n",
    "    \"\"\"\n",
    "    try:\n",
    "        azd, eld = az_el_of_V(Rlos)\n",
    "        Mli   = Mrot(azd*RPD, eld*RPD, 0.0)\n",
    "        ZEMl  = np.matmul(Mli, ZEM)\n",
    "        ZEMln = np.array([0.0, ZEMl[1], ZEMl[2]])\n",
    "        ZEMi  = np.matmul(Mli.transpose(), ZEMln)\n",
    "        np.testing.assert_almost_equal(la.norm(ZEMn - ZEMi), 0.0, 6)\n",
    "    except:\n",
    "        print(\"ZEMn:  (%10.3f, %10.3f, %10.3f)\" %\\\n",
    "              (ZEMn[0], ZEMn[1], ZEMn[2]))\n",
    "        print(\"ZEMi:  (%10.3f, %10.3f, %10.3f)\" %\\\n",
    "              (ZEMi[0], ZEMi[1], ZEMi[2]))\n",
    "        sys.exit()\n",
    "    \"\"\"\n",
    "    return ZEMn\n",
    "\n",
    "def AZEMn(Rlos, Vtm, At, tgo):\n",
    "    # Augmented Zero Effort Miss normal to line-of-sight (LOS) vector\n",
    "    # Rlos towards an accelerating target at time-to-go tgo.\n",
    "    # See derivation of equation (27) on pg 51 in ref [8] and\n",
    "    # discussion of APN in Section 2, Module 2 of ref [5].\n",
    "    Ulos  = Uvec(Rlos)\n",
    "    ZEMA  = Rlos + Vtm*tgo + (At/2.0)*tgo**2\n",
    "    ZEMAr = np.dot(ZEMA, Ulos)*Ulos\n",
    "    ZEMAn = ZEMA - ZEMAr\n",
    "    return ZEMAn\n",
    "\n",
    "def Wlos(Vt, Vm, Rlos, Ulos):\n",
    "    # Calculates line-of-sight (LOS) rotation rate Ws in the direction\n",
    "    # of Ulos x (Ws x Ulos) perpendicular to the instantaneous rotation\n",
    "    # plane of LOS (IRPL), and represents angular velocity of Rlos (i.e.,\n",
    "    # Vrel = W x Rlos) without the component in the direction of Ulos.\n",
    "    # \n",
    "    # This could be derived from the slew rate(s) of a missile's seeker\n",
    "    # as it follows the target, or as rate of change in target angular\n",
    "    # offset within the sensor FOV for a fixed seeker. Naturally, the\n",
    "    # contribution of seeker orientation, missile attitude angles and\n",
    "    # rotation rates to Ws would need to be accounted for (see ref [3]).\n",
    "    #\n",
    "    # Note: Following expressions for calculating Wlos\n",
    "    #\n",
    "    Vnrm = Vrel(Vt, Vm) - Vclose(Vt, Vm, Ulos)\n",
    "    Wlos = np.cross(-Vnrm, Ulos)/la.norm(Rlos)\n",
    "    #\n",
    "    # is equivalent to:\n",
    "    #\n",
    "    #   Wlos = np.cross(Rlos, Vtm)/np.dot(Rlos, Rlos)\n",
    "    \"\"\"\n",
    "    Wlos2 = np.cross(Rlos, Vrel(Vt,Vm))/np.dot(Rlos, Rlos)\n",
    "    try:\n",
    "        np.testing.assert_almost_equal(Wlos2, Wlos, 6)\n",
    "    except:\n",
    "        print(\"Wlos:   (%8.3f, %8.3f, %8.3f)\" % (Wlos[0], Wlos[1], Wlos[2]))\n",
    "        print(\"Wlos2:  (%8.3f, %8.3f, %8.3f)\" % (Wlos2[0], Wlos2[1], Wlos2[2]))\n",
    "    \"\"\"\n",
    "    #\n",
    "    # which can be reduced to:\n",
    "    #\n",
    "    #   Wlos = np.array([Rlos[1]*Vtm[2] - Rlos[2]*Vtm[1],\n",
    "    #                    Rlos[2]*Vtm[0] - Rlos[0]*Vtm[2],\n",
    "    #                    Rlos[0]*Vtm[1] - Rlos[1]*Vtm[0]\n",
    "    #                   ])/np.dot(Rlos, Rlos)\n",
    "    #\n",
    "    # as shown in derivation of equation (2.18) in ref [6].\n",
    "    return Wlos\n",
    "\n",
    "def applyGCP(Ac, Ulos, Vm):\n",
    "    \"\"\"\n",
    "    Apply guidance command preservation per eq (45) on pg 38 of ref [3].\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    \n",
    "    Ac : float 3-vector\n",
    "        Commanded missile guidance acceleration (inertial).\n",
    "    Ulos : float 3-vector\n",
    "        Unit vector along LOS from missile to target (inertial).\n",
    "    Vm : float 3-vector\n",
    "        Velocity (inertial) of missile.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    Acmd : float 3-Vector\n",
    "        Acceleration commanded.\n",
    "    \n",
    "    \"\"\"\n",
    "    UVm = Uvec(Vm)\n",
    "    Am  = Ac - np.dot(Ac, UVm)*UVm\n",
    "    dot_Ulos_UVm = np.dot(Ulos, UVm)\n",
    "    if abs(dot_Ulos_UVm) > 0.0:\n",
    "        Agcp = ((Am[0] - np.dot(Ac, UVm))/dot_Ulos_UVm)*Ulos + Ac\n",
    "        Acmd = Agcp - np.dot(Agcp, UVm)*UVm  # no thrust control\n",
    "        \"\"\"\n",
    "        try:\n",
    "            np.testing.assert_almost_equal(np.dot(Agcp, UVm), Am[0], 6)\n",
    "            np.testing.assert_almost_equal(np.dot(Agcp, Uvec(Ac)), la.norm(Ac), 6)\n",
    "        except:\n",
    "            print(\"\\nAc:    (%8.3f, %8.3f, %8.3f)\" % (Ac[0], Ac[1], Ac[2]))\n",
    "            print(\"Agcp:  (%8.3f, %8.3f, %8.3f)\" % (Agcp[0], Agcp[1], Agcp[2]))\n",
    "            print(\"Acmd:  (%8.3f, %8.3f, %8.3f)\" % (Acmd[0], Acmd[1], Acmd[2]))\n",
    "            print(\"||Ac||, ||Agcp||, ||Acmd||:  %8.3f  %8.3f  %8.3f\" % \\\n",
    "                  (la.norm(Ac), la.norm(Agcp), la.norm(Acmd)))\n",
    "        \"\"\"\n",
    "    else:\n",
    "        # Missile body x-axis (uVM) perpendicular to LOS (Ulos).\n",
    "        Acmd = Ac - np.dot(Ac, UVm)*UVm\n",
    "    return Acmd\n",
    "\n",
    "def Amslc(Rlos, Vt, At, Vm, N):\n",
    "    \"\"\"\n",
    "    This routine is the application of selected proportional\n",
    "    navigation method - True, Pure, ZEM, ATPN, APPN or AZEM.\n",
    "    \n",
    "    Globals\n",
    "    -------\n",
    "    PNAV : integer constant\n",
    "        Proportional Navigation law selected identifier\n",
    "    RPD : float constant\n",
    "        Radians per degree\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    Rlos : float 3-vector\n",
    "        Range along LOS from missile to target.\n",
    "    Vt : float 3-vector\n",
    "        Velocity (inertial) of target.\n",
    "    At : float 3-vector\n",
    "        Acceleration (inertial) of target.\n",
    "    Vm : float 3-vector\n",
    "        Velocity (inertial) of missile.\n",
    "    N : float\n",
    "        Proportional navigation constant (or gain).\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    Acmd : float 3-Vector\n",
    "        Acceleration commanded.\n",
    "    \n",
    "    \"\"\"\n",
    "    Ulos = Uvec(Rlos)\n",
    "    Vtm  = Vrel(Vt, Vm)\n",
    "    if PNAV == PN_APPN or PNAV == PN_ATPN:\n",
    "        # Create inertial to missile body rotation matrix\n",
    "        maz, mel = az_el_of_V(Vm)\n",
    "        Mbi = Mrot(maz*RPD, mel*RPD, 0.0)\n",
    "        \"\"\"\n",
    "        try:\n",
    "            np.testing.assert_almost_equal(la.norm(np.matmul(Mbi, Mbi.transpose())),\n",
    "                                           sqrt(3.0), 6)\n",
    "        except:\n",
    "             print('Msl:\\n', np.matmul(Mbi, Mbi.transpose()))\n",
    "             print(la.norm(np.matmul(Mbi, Mbi.transpose())))\n",
    "             sys.exit()\n",
    "        try:\n",
    "            Atb = np.matmul(Mbi, At)\n",
    "            Atx = np.matmul(Mbi.transpose(), Atb)\n",
    "            np.testing.assert_almost_equal(la.norm(At - Atx), 0.0, 6)\n",
    "        except:\n",
    "            print(\"At orig:  (%8.3f, %8.3f, %8.3f)\" % (At[0], At[1], At[2]))\n",
    "            print(\"At xfrm:  (%8.3f, %8.3f, %8.3f)\" % (Atx[0], Atx[1], Atx[2]))\n",
    "            sys.exit()\n",
    "        \"\"\"\n",
    "        # See derivation of equation (3.8) in ref [6].\n",
    "        #\n",
    "        Ws  = Wlos(Vt, Vm, Rlos, Ulos)\n",
    "        ##UWs = Uvec(Ws)  # Used to calculate Ats below\n",
    "        ##UVm = Uvec(Vm)  # Used in the assert statements below.\n",
    "        # Vector Atn is the rejection of At with vector Ulos and is normal\n",
    "        # to Ulos, and represents the components of target acceleration At\n",
    "        # which can contribute to change in line-of-sight (LOS) rotation\n",
    "        # rate Ws (i.e., d(Ws)/dt).\n",
    "        Atn = At - np.dot(At, Ulos)*Ulos\n",
    "        # Vector Ats is the rejection of Atn with vector UWs and is in the\n",
    "        # plane containing both vector UWs x Ulos and vector Ulos; thus\n",
    "        # omitting the component of Atn which could change the direction\n",
    "        # of Ws. Not applied; using Atn instead of Ats for APPN and ATPN\n",
    "        # below.\n",
    "        ##Ats  = Atn - np.dot(Atn, UWs)*UWs\n",
    "        if PNAV == PN_APPN:\n",
    "            # 3.1.1 Version 1 (PN-1) Pure PN equations (3.2)-(3.4).\n",
    "            Atsb = np.matmul(Mbi, Atn)\n",
    "            Atsb[0] = 0.0\n",
    "            Atsi = np.matmul(Mbi.transpose(), Atsb)\n",
    "            # Vector Ac normal to UVm.\n",
    "            Ac = N*np.cross(Ws, Vm) + (N/2)*Atsi  # eqs (3.2) & (3.8) inertial\n",
    "            \"\"\"\n",
    "            PN_1b = np.matmul(Mbi, Ac)\n",
    "            # Eq. (3.4) not required since Ac dot Vm is zero by definition.\n",
    "            # PN_1b[0] = 0.0  # eq. (3.4)\n",
    "            np.testing.assert_almost_equal(np.dot(Ac,UVm), 0.0, 6)\n",
    "            np.testing.assert_almost_equal(PN_1b[0], 0.0, 6)\n",
    "            \"\"\"\n",
    "            Acmd = Ac\n",
    "        else: # PNAV == PN_ATPN\n",
    "            # 3.1.2 Version 2 (PN-2) True PN equations (3.5)-(3.7).\n",
    "            Vc = la.norm(Vclose(Vt, Vm, Ulos))\n",
    "            # Vector Ac is normal to Ulos.\n",
    "            Ac = N*Vc*np.cross(Ws, Ulos) + (N/2)*Atn  # eqs (3.5) & (3.8) inertial.\n",
    "            Agcp = applyGCP(Ac, Ulos, Vm)\n",
    "            \"\"\"\n",
    "            PN_2b = np.matmul(Mbi, Agcp)\n",
    "            # Eq. (3.7) not required since Agcp dot Vm is zero by definition.\n",
    "            # PN_2b[0] = 0.0  # eq. (3.7)\n",
    "            np.testing.assert_almost_equal(np.dot(Agcp,UVm), 0.0, 6)\n",
    "            np.testing.assert_almost_equal(PN_2b[0], 0.0, 6)\n",
    "            \"\"\"\n",
    "            Acmd = Agcp\n",
    "    elif PNAV == PN_AZEM:\n",
    "        # See derivation of equation (27) on pg 51 in ref [8].\n",
    "        # NOTE: Time-to-go calculated here assumes non-accelerating target.\n",
    "        tgo  = timeToGo(Rlos, Vt, Vm)\n",
    "        Ac   = N*AZEMn(Rlos, Vtm, At, tgo)/(tgo**2)\n",
    "        Acmd = applyGCP(Ac, Ulos, Vm)\n",
    "    elif PNAV == PN_ZEM:\n",
    "        # See derivation of equation (22) on pg 48 in ref [8].\n",
    "        # NOTE: Time-to-go calculated here assumes non-accelerating target.\n",
    "        tgo  = timeToGo(Rlos, Vt, Vm)\n",
    "        Ac   = N*ZEMn(Rlos, Vtm, tgo)/(tgo**2)\n",
    "        Acmd = applyGCP(Ac, Ulos, Vm)\n",
    "    elif PNAV == PN_PURE:\n",
    "        Acmd = N*np.cross(Wlos(Vt, Vm, Rlos, Ulos), Vm)\n",
    "    else: # PNAV == PN_TRUE\n",
    "        Vc   = la.norm(Vclose(Vt, Vm, Ulos))\n",
    "        Ac   = N*Vc*np.cross(Wlos(Vt, Vm, Rlos, Ulos), Ulos)\n",
    "        Acmd = applyGCP(Ac, Ulos, Vm)\n",
    "    return Acmd\n",
    "\n",
    "def Amsla(Amcmd, Ammax):\n",
    "    \"\"\"\n",
    "    Applies Ammax bound to given commanded missile acceleration.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    Amcmd : float 3-vector\n",
    "        Missile inertial linear acceleration commanded.\n",
    "    Ammax : float constant\n",
    "        Maximum missile linear acceleration.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    float 3-Vector\n",
    "        Missile inertial acceleration achieved (actual).\n",
    "    \n",
    "    \"\"\"\n",
    "    if la.norm(Amcmd) > Ammax:\n",
    "        return np.dot(Ammax, Uvec(Amcmd))\n",
    "    return Amcmd\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98cfc666-da96-4ab2-ba96-06dfa669cb0a",
   "metadata": {
    "id": "98cfc666-da96-4ab2-ba96-06dfa669cb0a"
   },
   "source": [
    "### Procedures for 3-DOF Kinematic Equations of Motion of Fixed-Wing Target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72d3336e-a53f-4e13-a13b-bdfc2f3c77bb",
   "metadata": {
    "executionInfo": {
     "elapsed": 2,
     "status": "ok",
     "timestamp": 1710972457301,
     "user": {
      "displayName": "Gary Deschaines",
      "userId": "00818646848844190559"
     },
     "user_tz": 300
    },
    "id": "72d3336e-a53f-4e13-a13b-bdfc2f3c77bb",
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "def Atgt(t, UWt, Pt, Vt, n, TgtTheta):\n",
    "    \"\"\"\n",
    "    This routine calculates target inertial linear acceleration\n",
    "    and pitch rate for given inertial angular velocity direction\n",
    "    unit vector, inertial linear velocity, turning g's, and pitch\n",
    "    angle.\n",
    "    \n",
    "    Globals\n",
    "    -------\n",
    "    g : float (read only)\n",
    "        gravitional acceleration magnitude (meters/sec/sec)\n",
    "    DPR: float (read only)\n",
    "        degrees per radian\n",
    "    RPD: float (read only)\n",
    "        radians per degree\n",
    "    MSL: integer (read only)\n",
    "        Missile type code\n",
    "    Wt: float (read only)\n",
    "        Target weave angular velocity in UWt direction (rad/sec)\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    t : float\n",
    "        Time (sec)\n",
    "    UWt : float 3-vector\n",
    "        Target angular velocity direction unit vector (i.e.,\n",
    "        direction frame rotation axis points in inertial space).\n",
    "    Pt : float 3-vector\n",
    "        Target inertial position.\n",
    "    Vt : float 3-vector\n",
    "        Target inertial velocity.\n",
    "    n : float\n",
    "        Target turning acceleration (normal to UWt) magnitude\n",
    "        in g's.\n",
    "    TgtTheta : float\n",
    "        Target pitch angle in radians.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    At : float 3-vector\n",
    "        Target inertial acceleration.\n",
    "    TgtThetaDot : float\n",
    "        Target pitch angle rotation rate in radians/sec.\n",
    "    \n",
    "    \"\"\"\n",
    "    global Wt\n",
    "    \n",
    "    if n != 0.0:\n",
    "        if MSL == AAM and Wt > 0.0:\n",
    "            # Weave maneuver\n",
    "            At = np.array([0.0, n*g*sin(Wt*t), n*g*cos(Wt*t)])\n",
    "            return At, 0.0\n",
    "        magVt = la.norm(Vt)\n",
    "        # Calculate target az and el in degrees.\n",
    "        taz, tel = az_el_of_V(Vt)\n",
    "        # Set target body frame rotation axis.\n",
    "        if abs(np.dot(UWt,Uyi)) < 0.0001:\n",
    "            UWtb = -UWt  # +yawing about -zb axis\n",
    "        else:\n",
    "            UWtb = UWt   # +pitching about +yb axis\n",
    "        # Compute inertial to body transformation matrix\n",
    "        if (abs(UWtb[1]) > 0.9999 and TgtTheta*DPR > 85.0) or \\\n",
    "           (abs(UWtb[1]) < 0.9999 and (tel > 85.0 and TgtTheta*DPR > 85.0)):\n",
    "            # Approaching gimbal lock; form direction cosine matrix\n",
    "            # using position pointing vector as derived in eqs (25)\n",
    "            # thru (30) on pg 5 of ref [7].\n",
    "            i = Uvec(Vt)\n",
    "            r = np.array([20000.0, Pt[1], 20000.0]) - Pt\n",
    "            j = Uvec(np.cross(r, i))\n",
    "            k = Uvec(np.cross(i, j))\n",
    "            Mbi = np.zeros([3,3])\n",
    "            Mbi[0,0] = i[0]\n",
    "            Mbi[0,1] = i[1]\n",
    "            Mbi[0,2] = i[2]\n",
    "            Mbi[1,0] = j[0]\n",
    "            Mbi[1,1] = j[1]\n",
    "            Mbi[1,2] = j[2]\n",
    "            Mbi[2,0] = k[0]\n",
    "            Mbi[2,1] = k[1]\n",
    "            Mbi[2,2] = k[2]\n",
    "            UWtb = np.matmul(Mbi, UWt)\n",
    "            # Calculate lift g's loss due to pitch angle.\n",
    "            loss = cos(TgtTheta)\n",
    "        else:\n",
    "            # Use ENU coordinate transformation matrix.\n",
    "            Mbi = Mrot(taz*RPD, tel*RPD, 0.0)\n",
    "            # Calculate lift g's loss due to pitch angle.\n",
    "            theta = pitchAngle(Vt)\n",
    "            loss  = cos(theta)\n",
    "        \"\"\"\n",
    "        try:\n",
    "            np.testing.assert_almost_equal(la.norm(np.matmul(Mbi, Mbi.transpose())),\n",
    "                                           sqrt(3.0), 6)\n",
    "        except:\n",
    "            print('Tgt:\\n', np.matmul(Mbi, Mbi.transpose()))\n",
    "            print(la.norm(np.matmul(Mbi, Mbi.transpose())))\n",
    "            sys.exit()\n",
    "        \"\"\"\n",
    "        # Rotate inertial Vt into target body frame.\n",
    "        Vtb = np.matmul(Mbi, Vt)\n",
    "        # Calculate aircraft body rotational rate (rad/sec).\n",
    "        OmegaDot    = (n*g)/magVt                  # total rate\n",
    "        ## NOTE: Set loss to zero for constant target rotation rate as modeled\n",
    "        ##       in AAM engagement cases presented in refs [4], [5] and [9].\n",
    "        loss = 0.0\n",
    "        TgtThetaDot = (((n-loss)*g)/magVt)*UWt[1]  # pitch rate\n",
    "        # Calculate inertial acceleration in target body frame.\n",
    "        Atb = np.cross(OmegaDot*UWtb, Vtb.flatten())\n",
    "        # Rotate inertial acceleration into inertial space frame.\n",
    "        At = np.matmul(Mbi.transpose(), Atb)\n",
    "    else:\n",
    "        TgtThetaDot = 0.0\n",
    "        At = np.array([0.0, 0.0, 0.0])\n",
    "    return At, TgtThetaDot\n",
    "\n",
    "def pitchAngle(Vt):\n",
    "    # Note: The following expression returns values in the\n",
    "    #       range [-90.0, 90.0], and does not account for\n",
    "    #       instances where the target has pitched past\n",
    "    #       +/-90 degrees.\n",
    "    theta = atan2(Vt[2], la.norm([Vt[0], Vt[1]]))\n",
    "    return theta  # Note: theta in radians.\n",
    "\n",
    "def bankAngle(At, Vt):\n",
    "    # Note: RPD and g are global.\n",
    "    UVt = Uvec(Vt)\n",
    "    # Calculate turning acceleration normal to Vt.\n",
    "    Atn = At - np.dot(At, UVt)*UVt\n",
    "    # Calculate target az and el in degrees.\n",
    "    taz, tel = az_el_of_V(Vt)\n",
    "    # Rotate inertial Atn into target body frame.\n",
    "    Mbi = Mrot(taz*RPD, tel*RPD, 0.0)\n",
    "    Atb = np.matmul(Mbi, Atn)\n",
    "    # Only use Y component of turning acceleration normal.\n",
    "    phi = atan(Atb[1]/g)\n",
    "    return phi  # Note: phi in radians.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3686f94-fb74-4028-aea9-7f77904d5078",
   "metadata": {
    "id": "e3686f94-fb74-4028-aea9-7f77904d5078"
   },
   "source": [
    "### Differential Equations of Motion State Integration Data Structures and Procedures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c36d9297-4175-46f6-91df-03244987ca73",
   "metadata": {
    "executionInfo": {
     "elapsed": 270,
     "status": "ok",
     "timestamp": 1710972457569,
     "user": {
      "displayName": "Gary Deschaines",
      "userId": "00818646848844190559"
     },
     "user_tz": 300
    },
    "id": "c36d9297-4175-46f6-91df-03244987ca73",
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "# Initial values for state variables array.\n",
    "\n",
    "nSvar = 14               # number of state variables\n",
    "S     = np.zeros(nSvar)  # state variables\n",
    "dS    = np.zeros(nSvar)  # state derivatives\n",
    "\n",
    "def setS(S, Vt, Pt, Vm, Pm, TgtTheta):\n",
    "    # Note: S[0] is t (time).\n",
    "    S[1]  = Vt[0]\n",
    "    S[2]  = Vt[1]\n",
    "    S[3]  = Vt[2]\n",
    "    S[4]  = Pt[0]\n",
    "    S[5]  = Pt[1]\n",
    "    S[6]  = Pt[2]\n",
    "    S[7]  = Vm[0]\n",
    "    S[8]  = Vm[1]\n",
    "    S[9]  = Vm[2]\n",
    "    S[10] = Pm[0]\n",
    "    S[11] = Pm[1]\n",
    "    S[12] = Pm[2]\n",
    "    S[13] = TgtTheta\n",
    "    return S\n",
    "\n",
    "def getVtOfS(S):\n",
    "    return np.array([S[1], S[2], S[3]])\n",
    "def getPtOfS(S):\n",
    "    return np.array([S[4], S[5], S[6]])\n",
    "def getVmOfS(S):\n",
    "    return np.array([S[7], S[8], S[9]])\n",
    "def getPmOfS(S):\n",
    "    return np.array([S[10], S[11], S[12]])\n",
    "\n",
    "def getS(S):\n",
    "    Vt = getVtOfS(S)\n",
    "    Pt = getPtOfS(S)\n",
    "    Vm = getVmOfS(S)\n",
    "    Pm = getPmOfS(S)\n",
    "    TgtTheta = S[13]\n",
    "    return Vt, Pt, Vm, Pm, TgtTheta\n",
    "\n",
    "def setSdot(Sdot, At, Vt, Am, Vm, TgtThetaDot):\n",
    "    # Note: Sdot[0] is dt (1.0).\n",
    "    Sdot[1]  = At[0]\n",
    "    Sdot[2]  = At[1]\n",
    "    Sdot[3]  = At[2]\n",
    "    Sdot[4]  = Vt[0]\n",
    "    Sdot[5]  = Vt[1]\n",
    "    Sdot[6]  = Vt[2]\n",
    "    Sdot[7]  = Am[0]\n",
    "    Sdot[8]  = Am[1]\n",
    "    Sdot[9]  = Am[2]\n",
    "    Sdot[10] = Vm[0]\n",
    "    Sdot[11] = Vm[1]\n",
    "    Sdot[12] = Vm[2]\n",
    "    Sdot[13] = TgtThetaDot\n",
    "    return Sdot\n",
    "\n",
    "def getAtOfSdot(Sdot):\n",
    "    return np.array([Sdot[1], Sdot[2], Sdot[3]])\n",
    "def getVtOfSdot(Sdot):\n",
    "    return np.array([Sdot[4], Sdot[5], Sdot[6]])\n",
    "def getAmOfSdot(Sdot):\n",
    "    return np.array([Sdot[7], Sdot[8], Sdot[9]])\n",
    "def getVmOfSdot(Sdot):\n",
    "    return np.array([Sdot[10], Sdot[11], Sdot[12]])\n",
    "\n",
    "def getSdot(Sdot):\n",
    "    At = getAtOfSdot(Sdot)\n",
    "    Vt = getVtOfSdot(Sdot)\n",
    "    Am = getAmOfSdot(Sdot)\n",
    "    Vm = getVmOfSdot(Sdot)\n",
    "    TgtThetaDot = Sdot[13]\n",
    "    return At, Vt, Am, Vm, TgtThetaDot\n",
    "\n",
    "def dotS2(dS, At, Vt, Amcmd, Vm, TgtThetaDot):\n",
    "    global Ammax\n",
    "    dS = setSdot(dS, At, Vt, Amsla(Amcmd, Ammax), Vm, TgtThetaDot)\n",
    "    return dS\n",
    "\n",
    "def dotS1(dS, t, Pt, Ptm, Vt, Vm, TgtTheta):\n",
    "    global UWt, Nt, Nm\n",
    "    At, TgtThetaDot = Atgt(t, UWt, Pt, Vt, Nt, TgtTheta)\n",
    "    dS = dotS2(dS, At, Vt, Amslc(Ptm, Vt, At, Vm, Nm), Vm, TgtThetaDot)\n",
    "    return dS\n",
    "\n",
    "def dotS(n, S):\n",
    "    \"\"\"\n",
    "    State derivatives function.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    n : integer\n",
    "        Number of state variables (i.e., length of state vector S).\n",
    "    S : float n-vector\n",
    "        State variable vector.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    dS : float n-Vector\n",
    "         Computed derivatives of state vector variables (i.e., dS/dt).\n",
    "\n",
    "    \"\"\"\n",
    "    dS    = np.zeros(n)\n",
    "    dS[0] = 1.0  # d(t)/dt\n",
    "\n",
    "    Vt, Pt, Vm, Pm, TgtTheta = getS(S)\n",
    "\n",
    "    dS = dotS1(dS, S[0], Pt, Prel(Pt,Pm), Vt, Vm, TgtTheta)\n",
    "\n",
    "    return dS\n",
    "\n",
    "def Stop(S):\n",
    "    Vt, Pt, Vm, Pm, _ = getS(S)\n",
    "    if (S[0] >= T_STOP) or (np.dot(Vrel(Vm,Vt), Uvec(Prel(Pt,Pm))) < 0.0):\n",
    "        return True\n",
    "    return False\n",
    "\n",
    "def Dclose(S):\n",
    "    Vt, Pt, Vm, Pm, _ = getS(S)\n",
    "    dtm = la.norm(Prel(Pt, Pm))\n",
    "    return dtm\n",
    "\n",
    "DT_FINAL = T_STEP/50.0\n",
    "def delT(S):\n",
    "    # This routine is called to reduce integration step size\n",
    "    # at engagement endgame to refine time of intercept.\n",
    "    global MinMissDist\n",
    "\n",
    "    if Dclose(S) < 100.0:\n",
    "        if Dclose(S) < 10.0:\n",
    "            if Dclose(S) < MinMissDist:\n",
    "                h = DT_FINAL  # final reduction\n",
    "            else:\n",
    "                h = T_STEP/20.0\n",
    "        else:\n",
    "            h = T_STEP/10.0\n",
    "    else:\n",
    "        h = T_STEP/2.0  # first reduction\n",
    "    return h\n",
    "\n",
    "# Differential equations of motion constants.\n",
    "\n",
    "tStep = T_STEP  # simulation and integration time step (sec)\n",
    "tStop = T_STOP  # simulation and integration stop time (sec)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd62c4dd-e993-4ea2-bb08-4c87bbda148b",
   "metadata": {
    "id": "bd62c4dd-e993-4ea2-bb08-4c87bbda148b"
   },
   "source": [
    "### Data Collection Constants, Storage Arrays and Procedures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a277e0a8-1406-4722-8695-fbb6fedfbbc0",
   "metadata": {
    "executionInfo": {
     "elapsed": 1,
     "status": "ok",
     "timestamp": 1710972457569,
     "user": {
      "displayName": "Gary Deschaines",
      "userId": "00818646848844190559"
     },
     "user_tz": 300
    },
    "id": "a277e0a8-1406-4722-8695-fbb6fedfbbc0",
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "# Animation display and data sampling constants.\n",
    "\n",
    "FPS    = 100\n",
    "F_TIME = 1.0/FPS\n",
    "N_STEP = int(floor((F_TIME + 0.5*T_STEP)/T_STEP))\n",
    "N_TIME = N_STEP*T_STEP\n",
    "\n",
    "# Create simulation data collection arrays for plotting.\n",
    "\n",
    "nSamples   = int(ceil(T_STOP/N_TIME)) + 1\n",
    "nSamplesp1 = nSamples + 1  # add 1 for possible overflow.\n",
    "\n",
    "if SHOW_ANIM or SAVE_ANIM or PLOT_DATA or PRINT_TXYZ:\n",
    "    Time  = np.zeros(nSamplesp1)  # simulation time\n",
    "    Ptx   = np.zeros(nSamplesp1)  # target position x\n",
    "    Pty   = np.zeros(nSamplesp1)  # target position y\n",
    "    Ptz   = np.zeros(nSamplesp1)  # target position z\n",
    "    Vtx   = np.zeros(nSamplesp1)  # target velocity x\n",
    "    Vty   = np.zeros(nSamplesp1)  # target velocity y\n",
    "    Vtz   = np.zeros(nSamplesp1)  # target velocity z\n",
    "    Atx   = np.zeros(nSamplesp1)  # target acceleration x\n",
    "    Aty   = np.zeros(nSamplesp1)  # target acceleration y\n",
    "    Atz   = np.zeros(nSamplesp1)  # target acceleration z\n",
    "    Pmx   = np.zeros(nSamplesp1)  # missile position x\n",
    "    Pmy   = np.zeros(nSamplesp1)  # missile position y\n",
    "    Pmz   = np.zeros(nSamplesp1)  # missile position z\n",
    "    Vmx   = np.zeros(nSamplesp1)  # missile velocity x\n",
    "    Vmy   = np.zeros(nSamplesp1)  # missile velocity y\n",
    "    Vmz   = np.zeros(nSamplesp1)  # missile velocity z\n",
    "    Amx   = np.zeros(nSamplesp1)  # missile acceleration x\n",
    "    Amy   = np.zeros(nSamplesp1)  # missile acceleration y\n",
    "    Amz   = np.zeros(nSamplesp1)  # missile acceleration z\n",
    "    Wrx   = np.zeros(nSamplesp1)  # Angular rate of Rtm x\n",
    "    Wry   = np.zeros(nSamplesp1)  # Angular rate of Rtm y\n",
    "    Wrz   = np.zeros(nSamplesp1)  # Anguler rate of Rtm z\n",
    "    Dcls  = np.zeros(nSamplesp1)  # Closest approach distance\n",
    "    LOSd  = np.zeros(nSamplesp1)  # LOS rate in (deg/sec)\n",
    "    T2go  = np.zeros(nSamplesp1)  # Time to go (sec)\n",
    "    VELc  = np.zeros(nSamplesp1)  # Closing velocity (meters/sec)\n",
    "    Atg   = np.zeros(nSamplesp1)  # Target acceleration in g's\n",
    "    Acmg  = np.zeros(nSamplesp1)  # Missile acceleration in g's\n",
    "    Velt  = np.zeros(nSamplesp1)  # Target velocity magnitude\n",
    "    Velm  = np.zeros(nSamplesp1)  # Missile velocity magnitude\n",
    "    ZEMd  = np.zeros(nSamplesp1)  # Zero Effort Miss distance\n",
    "    Thoff = np.zeros(nSamplesp1)  # Target horiz. offset angle sines\n",
    "    Tvoff = np.zeros(nSamplesp1)  # Target vert. offset angle sines\n",
    "    THTtd = np.zeros(nSamplesp1)  # Target pitch (theta) angle (deg)\n",
    "\n",
    "def collectData(i, t, S):\n",
    "\n",
    "    global LastPorY, LastWsgn, LastAsgn\n",
    "\n",
    "    # Get current target and missile states.\n",
    "    Vt, Pt, Vm, Pm, TgtTheta = getS(S)\n",
    "\n",
    "    # Get current missile azimuth and elevation.\n",
    "    maz, mel = az_el_of_V(Vm)\n",
    "\n",
    "    # Get current target offset horiz and vert angles in\n",
    "    # missile body frame.\n",
    "\n",
    "    Mbi  = Mrot(maz*RPD, mel*RPD, 0.0)\n",
    "    Rlos = Prel(Pt, Pm)\n",
    "    Rtmb = np.matmul(Mbi, Rlos)\n",
    "    horiz, vert = az_el_of_V(Rtmb)\n",
    "\n",
    "    # Get current target and missile state derivatives.\n",
    "    dS = dotS(nSvar, S)\n",
    "    dVt, dPt, dVm, dPm, TgtThetaDot = getSdot(dS)\n",
    "\n",
    "    # Calculate current time-to-go, LOS rate, closing velocity,\n",
    "    # closing distance, missile acceleration in g's, and ZEM.\n",
    "\n",
    "    Ulos  = Uvec(Rlos)\n",
    "    tgo   = timeToGo(Rlos, Vt, Vm)\n",
    "    Wlosi = Wlos(Vt, Vm, Rlos, Ulos)\n",
    "    Wlosb = np.matmul(Mbi, Wlosi)\n",
    "    Amb   = np.matmul(Mbi,dVm)\n",
    "    if abs(Wlosb[2]) >= abs(Wlosb[1]):\n",
    "        # predominantly yaw maneuver\n",
    "        Uzb  = np.matmul(Mbi,  Uzi)  # positive yaw axis\n",
    "        Uyb  = np.matmul(Mbi,  Uyi)  # positive accel axis\n",
    "        wsgn = np.sign(np.dot(Wlosb, Uzb))\n",
    "        asgn = np.sign(np.dot(Amb,   Uyb))\n",
    "        PorY = 'Y'\n",
    "    else:\n",
    "        # predominantly pitch maneuver\n",
    "        Uyb  = np.matmul(Mbi, -Uyi)  # positive pitch axis\n",
    "        Uzb  = np.matmul(Mbi,  Uzi)  # positive accel axis\n",
    "        wsgn = np.sign(np.dot(Wlosb, Uyb))\n",
    "        asgn = np.sign(np.dot(Amb,   Uzb))\n",
    "        PorY = 'P'\n",
    "    losr = wsgn*la.norm(Wlosb)\n",
    "    vcls = la.norm(Vclose(Vt, Vm, Ulos, True))\n",
    "    dcls = Dclose(S)\n",
    "    acmg = asgn*la.norm(dVm)/g\n",
    "    if PNAV == PN_ATPN or PNAV == PN_APPN or PNAV == PN_AZEM:\n",
    "        zemd = la.norm(AZEMn(Rlos, Vrel(Vt,Vm), dVt, tgo))\n",
    "    else:\n",
    "        zemd = la.norm(ZEMn(Rlos, Vrel(Vt,Vm), tgo))\n",
    "\n",
    "    \"\"\"\n",
    "    # Verify vcls and tgo with that returned by calcVcTgo().\n",
    "    Vc, Tgo = calcVcTgo(Pt, Vt, Pm, Vm)\n",
    "    np.testing.assert_almost_equal(vcls, Vc, 3)\n",
    "    np.testing.assert_almost_equal(tgo, Tgo, 4)\n",
    "    \"\"\"\n",
    "\n",
    "    # Display current missile and target states and\n",
    "    # intercept status; collect data for plotting\n",
    "    # or printing.\n",
    "\n",
    "    if i == 0 or PRINT_DATA:\n",
    "\n",
    "        print(\"\\nt:  %9.5f\" % t)\n",
    "        print(\"Target position:   [%9.2f, %9.2f, %9.2f]\" %\n",
    "              (Pt[0], Pt[1], Pt[2]))\n",
    "        print(\"Target velocity:   [%9.3f, %9.3f, %9.3f]\" %\n",
    "              (Vt[0], Vt[1], Vt[2]))\n",
    "        print(\"Missile position:  [%9.2f, %9.2f, %9.2f]\" %\n",
    "              (Pm[0], Pm[1], Pm[2]))\n",
    "        print(\"Missile velocity:  [%9.3f, %9.3f, %9.3f]\" %\n",
    "              (Vm[0], Vm[1], Vm[2]))\n",
    "        print(\"Target velocity magnitude:   %9.3f\" % (la.norm(Vt)))\n",
    "        print(\"Missile velocity magnitude:  %9.3f\" % (la.norm(Vm)))\n",
    "        print(\"Missile inertial (az, el):    (%8.3f, %8.3f) degrees\" %\n",
    "               (maz, mel))\n",
    "        print(\"Target offset (horiz, vert):  (%8.3f, %8.3f) degrees\" %\n",
    "               (horiz, vert))\n",
    "        print(\"time to go:  %9.5f sec\" % tgo)\n",
    "        print(\"LOS rate:    %9.4f deg/sec\" % (losr*DPR))\n",
    "        print(\"closing velocity:  %9.4f meters/sec\" % vcls)\n",
    "        print(\"closing distance:  %9.4f meters\" % dcls)\n",
    "        print(\"missile accel.:    %9.4f g's\" % acmg)\n",
    "        print(\"ZEM distance:      %9.4f meters\" % zemd)\n",
    "\n",
    "    if (PorY != LastPorY) \\\n",
    "        or ((PorY == LastPorY) and ((wsgn != LastWsgn) or (asgn != LastAsgn))):\n",
    "        print(\"\\nt=%9.5f  %s  sgn_Wlos= %4.1f  sgn_Am= %4.1f\" % (t, PorY, wsgn, asgn))\n",
    "        if PorY != LastPorY : LastPorY = PorY\n",
    "        if wsgn != LastWsgn : LastWsgn = wsgn\n",
    "        if asgn != LastAsgn : LastAsgn = asgn\n",
    "\n",
    "    if SHOW_ANIM or SAVE_ANIM or PLOT_DATA or PRINT_TXYZ:\n",
    "\n",
    "        Time[i]  = t\n",
    "        Ptx[i]   = Pt[0]\n",
    "        Pty[i]   = Pt[1]\n",
    "        Ptz[i]   = Pt[2]\n",
    "        Vtx[i]   = Vt[0]\n",
    "        Vty[i]   = Vt[1]\n",
    "        Vtz[i]   = Vt[2]\n",
    "        Atx[i]   = dVt[0]\n",
    "        Aty[i]   = dVt[1]\n",
    "        Atz[i]   = dVt[2]\n",
    "        Pmx[i]   = Pm[0]\n",
    "        Pmy[i]   = Pm[1]\n",
    "        Pmz[i]   = Pm[2]\n",
    "        Vmx[i]   = Vm[0]\n",
    "        Vmy[i]   = Vm[1]\n",
    "        Vmz[i]   = Vm[2]\n",
    "        Amx[i]   = dVm[0]\n",
    "        Amy[i]   = dVm[1]\n",
    "        Amz[i]   = dVm[2]\n",
    "        Wrx[i]   = Wlosi[0]\n",
    "        Wry[i]   = Wlosi[1]\n",
    "        Wrz[i]   = Wlosi[2]\n",
    "        Dcls[i]  = dcls\n",
    "        LOSd[i]  = losr*DPR\n",
    "        T2go[i]  = tgo\n",
    "        VELc[i]  = vcls\n",
    "        Atg[i]   = la.norm(dVt)/g\n",
    "        Acmg[i]  = acmg\n",
    "        Velt[i]  = la.norm(Vt)\n",
    "        Velm[i]  = la.norm(Vm)\n",
    "        ZEMd[i]  = zemd\n",
    "        Thoff[i] = sin(horiz*RPD)\n",
    "        Tvoff[i] = sin(vert*RPD)\n",
    "        THTtd[i] = TgtTheta*DPR\n",
    "\n",
    "    return\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a76c1e63-44bc-4f75-8838-3895cb95fc5d",
   "metadata": {
    "id": "a76c1e63-44bc-4f75-8838-3895cb95fc5d"
   },
   "source": [
    "### 3D Engagement Animation Callback and Plotting Procedures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36c80dde-80e1-4f2e-a7a7-ba595446a0d8",
   "metadata": {
    "executionInfo": {
     "elapsed": 1,
     "status": "ok",
     "timestamp": 1710972457569,
     "user": {
      "displayName": "Gary Deschaines",
      "userId": "00818646848844190559"
     },
     "user_tz": 300
    },
    "id": "36c80dde-80e1-4f2e-a7a7-ba595446a0d8",
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "def onPress(event):\n",
    "    global nincr, iloop, istop, paused, quitflag, doneflag\n",
    "    \"\"\"\n",
    "    Keyboard key press handler.\n",
    "    \"\"\"\n",
    "    if event.key == 'up':\n",
    "        nincr += 1\n",
    "        nincr = min(1, nincr)\n",
    "    elif event.key == 'down':\n",
    "        nincr -= 1\n",
    "        nincr = max(-1, nincr)\n",
    "    elif event.key == 'right':\n",
    "        nincr = 0\n",
    "        iloop += 1\n",
    "        iloop = min(iloop, istop)\n",
    "    elif event.key == 'left':\n",
    "        nincr = 0\n",
    "        iloop -= 1\n",
    "        iloop = max(iloop, 0)\n",
    "    elif event.key == ' ':\n",
    "        paused = not paused\n",
    "    elif event.key == 'x':\n",
    "        # Exits loop and permits restart.\n",
    "        quitflag = True\n",
    "        doneflag = False\n",
    "    elif event.key == 'escape':\n",
    "        # Exits loop and closes figure.\n",
    "        quitflag = True\n",
    "        doneflag = True\n",
    "\n",
    "def blit3D(fig, ax, backend):\n",
    "    \"\"\"\n",
    "    Background blitting function for 3D engagement animation.\n",
    "    \"\"\"\n",
    "    if backend[0:2] == 'WX':\n",
    "        fig.canvas.update()\n",
    "    elif backend[0:2] == 'TK':\n",
    "        fig.canvas.blit(ax.bbox)\n",
    "    elif backend[0:2] == 'NB':\n",
    "        fig.canvas.blit(ax.bbox)\n",
    "    elif backend == 'MODULE://IPYMPL.BACKEND_NBAGG':\n",
    "        fig.canvas.blit(ax.bbox)\n",
    "    else:  # QT or GTK\n",
    "        fig.canvas.update()\n",
    "    fig.canvas.flush_events()\n",
    "\n",
    "def init3D():\n",
    "    \"\"\"\n",
    "    Initialization function for 3D engagement animation.\n",
    "    \"\"\"\n",
    "    global ax3D\n",
    "    global linePt, linePttrk, linePtxy, linePtxz\n",
    "    global LinePm, linePmtrk, linePmxy, linePmxz\n",
    "    global linePtv, linePmv, linePma, linePwr, linePx\n",
    "    global linePttgoxy, linePttgoxz, linePmtgoxy, linePmtgoxz\n",
    "    global time_text\n",
    "\n",
    "    linePt.set_data_3d(np.array([]), np.array([]), np.array([]))\n",
    "    linePttrk.set_data_3d(np.array([]), np.array([]), np.array([]))\n",
    "    linePtxy.set_data_3d(np.array([]), np.array([]), np.array([]))\n",
    "    linePtxz.set_data_3d(np.array([]), np.array([]), np.array([]))\n",
    "    linePm.set_data_3d(np.array([]), np.array([]), np.array([]))\n",
    "    linePmtrk.set_data_3d(np.array([]), np.array([]), np.array([]))\n",
    "    linePmxy.set_data_3d(np.array([]), np.array([]), np.array([]))\n",
    "    linePmxz.set_data_3d(np.array([]), np.array([]), np.array([]))\n",
    "    linePtv.set_data_3d(np.array([]), np.array([]), np.array([]))\n",
    "    linePmv.set_data_3d(np.array([]), np.array([]), np.array([]))\n",
    "    linePma.set_data_3d(np.array([]), np.array([]), np.array([]))\n",
    "    linePwr.set_data_3d(np.array([]), np.array([]), np.array([]))\n",
    "    linePx.set_data_3d(np.array([]), np.array([]), np.array([]))\n",
    "    linePttgoxy.set_data_3d(np.array([]), np.array([]), np.array([]))\n",
    "    linePttgoxz.set_data_3d(np.array([]), np.array([]), np.array([]))\n",
    "    linePmtgoxy.set_data_3d(np.array([]), np.array([]), np.array([]))\n",
    "    linePmtgoxz.set_data_3d(np.array([]), np.array([]), np.array([]))\n",
    "\n",
    "    ax3D.legend((linePt.get_label(),\n",
    "                 linePm.get_label(),\n",
    "                 linePma.get_label(),\n",
    "                 linePwr.get_label()), loc='upper right')\n",
    "\n",
    "    time_text.set_text('')\n",
    "\n",
    "    # Return artists in drawing order.\n",
    "    return linePttgoxy, linePmtgoxy, linePttgoxz, linePmtgoxz, \\\n",
    "           linePtxy, linePtxz, linePmxy, linePmxz, linePttrk, linePmtrk, \\\n",
    "           linePtv, linePt, linePwr, linePmv, linePma, linePm, linePx, time_text\n",
    "\n",
    "def anim3D(n):\n",
    "    \"\"\"\n",
    "    Animation function for 3D engagement animation.\n",
    "    \"\"\"\n",
    "    global fig3D, ax3D\n",
    "    global INTERCEPT, istop\n",
    "    global Ptx, Pty, PTz, Vtx, Vty, Vtz\n",
    "    global Pmx, Pmy, Pmz, Vmx, Vmy, Vmz, Amx, Amy, Amz, Amcg\n",
    "    global Wrx, Wry, Wrz, LOSd, T2go\n",
    "    global Qsfac, ymax, zmin\n",
    "    global linePt, linePttrk, linePtxy, linePtxz\n",
    "    global LinePm, linePmtrk, linePmxz, linePmxz\n",
    "    global linePtv, linePmv, linePma, linePwr, linePx\n",
    "    global linePttgoxy, linePttgoxz, linePmtgoxy, linePmtgoxz\n",
    "    global time_text\n",
    "\n",
    "    np1 = n + 1\n",
    "\n",
    "    linePt.set_data_3d(Ptx[n:np1], Pty[n:np1], Ptz[n:np1])\n",
    "    linePttrk.set_data_3d(Ptx[0:np1], Pty[0:np1], Ptz[0:np1])\n",
    "    linePtxy.set_data_3d(Ptx[0:np1], Pty[0:np1], np.ones(np1)*zmin)\n",
    "    linePtxz.set_data_3d(Ptx[0:np1], np.ones(np1)*ymax, Ptz[0:np1])\n",
    "\n",
    "    QVt = np.array([Vtx[n], Vty[n], Vtz[n]])*T2go[n]\n",
    "    linePttgoxy.set_data_3d(np.array([Ptx[n], Ptx[n]+QVt[0]], dtype=object),\n",
    "                            np.array([Pty[n], Pty[n]+QVt[1]], dtype=object),\n",
    "                            np.array([zmin,   zmin         ], dtype=object))\n",
    "    linePttgoxz.set_data_3d(np.array([Ptx[n], Ptx[n]+QVt[0]], dtype=object),\n",
    "                            np.array([ymax,   ymax         ], dtype=object),\n",
    "                            np.array([Ptz[n], Ptz[n]+QVt[2]], dtype=object))\n",
    "\n",
    "    linePm.set_data_3d(Pmx[n:np1], Pmy[n:np1], Pmz[n:np1])\n",
    "    linePmtrk.set_data_3d(Pmx[0:np1], Pmy[0:np1], Pmz[0:np1])\n",
    "    linePmxy.set_data_3d(Pmx[0:np1], Pmy[0:np1], np.ones(np1)*zmin)\n",
    "    linePmxz.set_data_3d(Pmx[0:np1], np.ones(np1)*ymax, Pmz[0:np1])\n",
    "\n",
    "    QVm = np.array([Vmx[n], Vmy[n], Vmz[n]])*T2go[n]\n",
    "    linePmtgoxy.set_data_3d(np.array([Pmx[n], Pmx[n]+QVm[0]], dtype=object),\n",
    "                            np.array([Pmy[n], Pmy[n]+QVm[1]], dtype=object),\n",
    "                            np.array([zmin,   zmin         ], dtype=object))\n",
    "    linePmtgoxz.set_data_3d(np.array([Pmx[n], Pmx[n]+QVm[0]], dtype=object),\n",
    "                            np.array([ymax,   ymax         ], dtype=object),\n",
    "                            np.array([Pmz[n], Pmz[n]+QVm[2]], dtype=object))\n",
    "\n",
    "    QVt = Uvec(np.array([Vtx[n], Vty[n], Vtz[n]]))*Qsfac\n",
    "    linePtv.set_data_3d(np.array([Ptx[n], Ptx[n]+QVt[0]], dtype=object),\n",
    "                        np.array([Pty[n], Pty[n]+QVt[1]], dtype=object),\n",
    "                        np.array([Ptz[n], Ptz[n]+QVt[2]], dtype=object))\n",
    "    QVm = Uvec(np.array([Vmx[n], Vmy[n], Vmz[n]]))*Qsfac\n",
    "    linePmv.set_data_3d(np.array([Pmx[n], Pmx[n]+QVm[0]], dtype=object),\n",
    "                        np.array([Pmy[n], Pmy[n]+QVm[1]], dtype=object),\n",
    "                        np.array([Pmz[n], Pmz[n]+QVm[2]], dtype=object))\n",
    "\n",
    "    QAm = Uvec(np.array([Amx[n], Amy[n], Amz[n]]))*abs(Acmg[n])*Qsfac/Gmmax[MSL]\n",
    "    if MSL == AAM: QAm *= 2.5  # enlarge to be visible\n",
    "    linePma.set_data_3d(np.array([Pmx[n], Pmx[n]+QAm[0]], dtype=object),\n",
    "                        np.array([Pmy[n], Pmy[n]+QAm[1]], dtype=object),\n",
    "                        np.array([Pmz[n], Pmz[n]+QAm[2]], dtype=object))\n",
    "    QWr = Uvec(np.array([Wrx[n], Wry[n], Wrz[n]]))*min(abs(LOSd[n]),6.0)*Qsfac/6.0\n",
    "    if MSL == AAM: QWr *= 2.5  # enlarge to be visible\n",
    "    linePwr.set_data_3d(np.array([Pmx[n], Pmx[n]+QWr[0]], dtype=object),\n",
    "                        np.array([Pmy[n], Pmy[n]+QWr[1]], dtype=object),\n",
    "                        np.array([Pmz[n], Pmz[n]+QWr[2]], dtype=object))\n",
    "\n",
    "    if n == istop:\n",
    "        if INTERCEPT:\n",
    "            linePx.set_data_3d(Pmx[n:np1],\n",
    "                               Pmy[n:np1],\n",
    "                               Pmz[n:np1])\n",
    "            linePx.set(color='m', ls=' ', lw=1.0,\n",
    "                       marker='x' ,mew=3.0, mec='m', mfc='m',\n",
    "                       label='Actual Intercept')\n",
    "        else:\n",
    "            linePx.set_data_3d(np.array([Pmx[n],Ptx[n]]),\n",
    "                               np.array([Pmy[n],Pty[n]]),\n",
    "                               np.array([Pmz[n],Ptz[n]]))\n",
    "            linePx.set(color='c', ls=' ', lw=1.0,\n",
    "                       marker='o', mew=3.0, mec='c', mfc='c',\n",
    "                       label='Missed Intercept')\n",
    "        ax3D.legend((linePt.get_label(),\n",
    "                     linePm.get_label(),\n",
    "                     linePma.get_label(),\n",
    "                     linePwr.get_label(),\n",
    "                     linePx.get_label()), loc='upper right')\n",
    "        ##fig3D.canvas.draw()\n",
    "        if SHOW_ANIM:\n",
    "            fig3D.canvas.draw()\n",
    "    else:\n",
    "        linePx.set_data_3d(np.array([]), np.array([]), np.array([]))\n",
    "\n",
    "    time_text.set_text('Time = %.4f' % Time[n])\n",
    "\n",
    "    # Return artists in drawing order.\n",
    "    return linePttgoxy, linePmtgoxy, linePttgoxz, linePmtgoxz, \\\n",
    "           linePtxy, linePtxz, linePmxy, linePmxz, linePttrk, linePmtrk, \\\n",
    "           linePtv, linePt, linePwr, linePmv, linePma, linePm, linePx, time_text\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b9c96f2-4907-4bcb-9a8a-5d416e205858",
   "metadata": {
    "id": "0b9c96f2-4907-4bcb-9a8a-5d416e205858"
   },
   "source": [
    "### Processing Main Routine to Run Missile/Target Engagement Case and Display Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65fd8ce5-faf5-412a-80bd-781915142fb6",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 1178,
     "status": "ok",
     "timestamp": 1710972458746,
     "user": {
      "displayName": "Gary Deschaines",
      "userId": "00818646848844190559"
     },
     "user_tz": 300
    },
    "id": "65fd8ce5-faf5-412a-80bd-781915142fb6",
    "jupyter": {
     "source_hidden": true
    },
    "outputId": "9d94a2e5-f43a-40fc-b6e5-0aaf62b897ad"
   },
   "outputs": [],
   "source": [
    "if __name__ == \"__main__\":\n",
    "\n",
    "    # Globals for saving last predominant missile rotation, Pitch\n",
    "    # or Yaw, and last LOS rate and missile acceleration signs to\n",
    "    # explain sign changes in LOS rate and missile acceleration\n",
    "    # profile plots.\n",
    "\n",
    "    global LastPorY  # pitch or yaw:  'P' or 'Y'\n",
    "    global LastWsgn  # LOS rate sign: -1.0 or 1.0\n",
    "    global LastAsgn  # missile acceleration sign: -1.0 or 1.0\n",
    "\n",
    "    LastPorY = None\n",
    "    LastWsgn = None\n",
    "    LastAsgn = None\n",
    "\n",
    "    # Estimate time-to-intercept and target position\n",
    "    # at intercept using Law of Cosines:\n",
    "    #\n",
    "    #   C**2 = A**2 + B**2 - 2*A*B*cos(alpha)\n",
    "    #\n",
    "    # where:\n",
    "    #\n",
    "    #   A     = |Pt0 - Pm0|\n",
    "    #   B     = |Vm0|*tint\n",
    "    #   C     = |Vt0|*tint\n",
    "    #   alpha = leadAngle\n",
    "    #\n",
    "    # Then solve the quadratic equation for tint.\n",
    "\n",
    "    magVt = la.norm(Vt0)\n",
    "    dtm   = la.norm(Prel(Pt0,Pm0))\n",
    "    alpha = leadAngle(Pt0, Vt0, Pm0, magVm)\n",
    "\n",
    "    c2 = magVm**2 - magVt**2\n",
    "    c1 = -2*magVm*dtm*cos(alpha)\n",
    "    c0 = dtm**2\n",
    "    p  = np.poly1d([c2,c1,c0])\n",
    "\n",
    "    tint  = np.amin(np.abs(p.roots))\n",
    "    EstPt = Pt0 + Vt0*tint\n",
    "\n",
    "    if tint > tStop:\n",
    "        print(\"Error:  estimated time-to-intercept=%8.4f > T_STOP=%8.4f\" %\n",
    "              (tint, tStop))\n",
    "        sys.exit()\n",
    "\n",
    "    # Calculate azimuth and elevation of estimated target position\n",
    "    # with respect to missile initial position at time of intercept.\n",
    "\n",
    "    if maz is None:\n",
    "        maz = atan((EstPt[1]-Pm0[1])/la.norm([EstPt[0]-Pm0[0]]))*DPR\n",
    "    if mel is None:\n",
    "        mel = atan((EstPt[2]-Pm0[2])/la.norm([EstPt[0]-Pm0[0], EstPt[1]-Pm0[1]]))*DPR\n",
    "\n",
    "    Vm0 = setVm(magVm, maz*RPD, mel*RPD)\n",
    "\n",
    "    print(\"Applying %s proportional navigation guidance law.\" % (PN_LAWS[PNAV]))\n",
    "\n",
    "    if PRINT_DATA:\n",
    "        print(\"Target initial position:  [%9.2f, %9.2f, %9.2f]\" %\n",
    "              (Pt0[0], Pt0[1], Pt0[2]))\n",
    "        print(\"Target initial velocity:  [%9.3f, %9.3f, %9.3f]\" %\n",
    "              (Vt0[0], Vt0[1], Vt0[2]))\n",
    "        print(\"Missile initial position: [%9.2f, %9.2f, %9.2f]\" %\n",
    "              (Pm0[0], Pm0[1], Pm0[2]))\n",
    "        print(\"Target velocity magnitude:    %9.3f\" % magVt)\n",
    "        print(\"Missile velocity magnitude:   %9.3f\" % magVm)\n",
    "        print(\"Estimated time-to-intercept:  %9.5f\" % tint)\n",
    "        print(\"Estimated target position:  [%9.2f, %9.2f, %9.2f]\" %\n",
    "              (EstPt[0], EstPt[1], EstPt[2]))\n",
    "        print(\"Missile (az, el) lead angles:  (%8.3f, %8.3f) degrees\" %\n",
    "              (maz, mel))\n",
    "        print(\"Missile initial velocity:   [%9.3f, %9.3f, %9.3f]\" %\n",
    "              (Vm0[0], Vm0[1], Vm0[2]))\n",
    "\n",
    "    # Initialize 3D plot for engagement animation.\n",
    "\n",
    "    Writer = None\n",
    "    if SAVE_ANIM:\n",
    "        try:\n",
    "            Writer = animation.writers['ffmpeg']\n",
    "        except KeyError:\n",
    "            try:\n",
    "                Writer = animation.writers['avconv']\n",
    "            except KeyError:\n",
    "                print(\"Cannot save animation, no animation writers available!\")\n",
    "                print(\"Try installing ffmpeg or avconv.\")\n",
    "                SAVE_ANIM = False\n",
    "\n",
    "    if SHOW_ANIM or SAVE_ANIM:\n",
    "        if RUN_WITH_COLAB or (Backend == 'nbAgg'):\n",
    "            with plt.ioff():\n",
    "                fig3D = plt.figure(14, figsize=(6,6), dpi=100)\n",
    "        else:\n",
    "            fig3D = plt.figure(14, figsize=(6,6), dpi=100)           \n",
    "        ax3D  = fig3D.add_subplot(111, projection='3d',\n",
    "                                  autoscale_on=False, animated=False)\n",
    "        # Instantiate artist for each line/point to be drawn on 3D plot.\n",
    "        linePt = Line3D([], [], [], color='r', ls=' ', lw=1.0,\n",
    "                        marker='s', mew=1.0, mec='r', mfc='w',\n",
    "                        label='Target', animated=False)  # target in 3D space\n",
    "        linePm = Line3D([], [], [], color='b', ls=' ', lw=1.0,\n",
    "                        marker='x', mew=0.5, mec='b', mfc='w',\n",
    "                        label='Missile', animated=False)  # missile in 3D space\n",
    "        linePx = Line3D([], [], [], color='k', ls=' ', lw=1.0,\n",
    "                        marker=' ', mew=1.0, mec='k', mfc='k',\n",
    "                        label='', animated=False)  # intercept in 3D space\n",
    "        linePtv = Line3D([], [], [], color='r', ls='-', lw=1.0,\n",
    "                         marker=' ', mew=0.5, mec='r', mfc='r',\n",
    "                         label='', animated=False)  # tgt vel in 3D space\n",
    "        linePmv = Line3D([], [], [], color='b', ls='-', lw=1.0,\n",
    "                         marker=' ', mew=0.5, mec='b', mfc='b',\n",
    "                         label='', animated=False)  # msl vel in 3D space\n",
    "        linePma = Line3D([], [], [], color='m', ls='-', lw=1.0,\n",
    "                         marker=' ', mew=0.5, mec='m', mfc='m',\n",
    "                         label='Command Accel', animated=False)  # msl acc in 3D space\n",
    "        linePwr = Line3D([], [], [], color='g', ls='-', lw=1.0,\n",
    "                         marker=' ', mew=0.5, mec='g', mfc='g',\n",
    "                         label='Rlos Ang Vel', animated=False)  # Rlos ang vel in 3D space\n",
    "        linePttrk = Line3D([], [], [], color='r', ls='-', lw=1.0,\n",
    "                           marker=' ', mew=0.5, mec='r', mfc=None,\n",
    "                           label='', animated=False)  # target track in 3D space\n",
    "        linePtxy = Line3D([], [], [], color='r', ls=':', lw=0.5,\n",
    "                           marker=' ', mew=0.5, mec='r', mfc=None,\n",
    "                           label='', animated=False)  # target track in XY plane\n",
    "        linePtxz = Line3D([], [], [], color='r', ls=':', lw=0.5,\n",
    "                           marker=' ', mew=0.5, mec='r', mfc=None,\n",
    "                           label='', animated=False)  # target track in XZ plane\n",
    "        linePmtrk = Line3D([], [], [], color='b', ls='-', lw=1.0,\n",
    "                           marker=' ', mew=0.5, mec='b', mfc=None,\n",
    "                           label='', animated=False)  # missile track in 3D space\n",
    "        linePmxy = Line3D([], [], [], color='b', ls=':', lw=0.5,\n",
    "                           marker=' ', mew=0.5, mec='b', mfc=None,\n",
    "                           label='', animated=False)  # missile track in XY plane\n",
    "        linePmxz = Line3D([], [], [], color='b', ls=':', lw=0.5,\n",
    "                           marker=' ', mew=0.5, mec='b', mfc=None,\n",
    "                           label='', animated=False)  # missile track in XZ plane\n",
    "        linePttgoxy = Line3D([], [], [], color='k', ls=':', lw=1.0,\n",
    "                              marker='s', mew=0.5, mec='r', mfc='w',\n",
    "                              label='', animated=False)  # Estimated tgt Tgo loc in XY plane\n",
    "        linePttgoxz = Line3D([], [], [], color='k', ls=':', lw=1.0,\n",
    "                              marker='s', mew=0.5, mec='r', mfc='w',\n",
    "                              label='', animated=False)  # Estimated tgt Tgo loc in XZ plane\n",
    "        linePmtgoxy = Line3D([], [], [], color='k', ls=':', lw=1.0,\n",
    "                              marker='x', mew=0.5, mec='b', mfc=None,\n",
    "                              label='', animated=False)  # Estimated msl Tgo loc in XY plane\n",
    "        linePmtgoxz = Line3D([], [], [], color='k', ls=':', lw=1.0,\n",
    "                              marker='x', mew=0.5, mec='b', mfc=None,\n",
    "                              label='', animated=False)  # Estimated msl Tgo loc in XZ plane\n",
    "        # Set 3D plot title and axes labels.\n",
    "        text = \"3D Animation of missile/target engagement ({0}, N={1}, At={2})\"\\\n",
    "                .format(PN_LAWS[PNAV], int(Nm), int(Nt))\n",
    "        ax3D.set_title(text)\n",
    "        ax3D.set_xlabel('X (meters)')\n",
    "        ax3D.set_ylabel('Y (meters)')\n",
    "        ax3D.set_zlabel('Z (meters)')\n",
    "        # Set/get 3D plot axes data limits; enable drawing grid lines.\n",
    "        if MSL == SAM:\n",
    "            ax3D.set_xlim3d([Pm0[0],  Pt0[0]+500.0])\n",
    "            ax3D.set_ylim3d([Pm0[1],  Pm0[1]+(Pt0[0]+500-Pm0[0])])\n",
    "            ax3D.set_zlim3d([0.0,    (Pt0[0]+500-Pm0[0])/2])\n",
    "        else:\n",
    "            ax3D.set_xlim3d([floor(Pm0[0]/500.0)*500.0,\n",
    "                             ceil(Pt0[0]/500.0)*500.0])\n",
    "            ax3D.set_ylim3d([floor(Pm0[1]/500.0)*500.0 -\n",
    "                             (ceil(Pt0[0]/500.0)*500.0 -\n",
    "                              floor(Pm0[0]/500.0)*500.0)/2,\n",
    "                             floor(Pm0[1]/500.0)*500.0 +\n",
    "                             (ceil(Pt0[0]/500.0)*500.0 -\n",
    "                              floor(Pm0[0]/500.0)*500.0)/2])\n",
    "            ax3D.set_zlim3d([floor(Pm0[2]/500.0)*500.0 -\n",
    "                             (ceil(Pt0[0]/500.0)*500.0 -\n",
    "                              floor(Pm0[0]/500.0)*500.0)/2,\n",
    "                             floor(Pm0[2]/500.0)*500.0 +\n",
    "                             (ceil(Pt0[0]/500.0)*500.0 -\n",
    "                              floor(Pm0[0]/500.0)*500.0)/2])\n",
    "            ax3D.set_aspect('equal')\n",
    "        (xmin, xmax) = ax3D.get_xlim()\n",
    "        (ymin, ymax) = ax3D.get_ylim()\n",
    "        (zmin, zmax) = ax3D.get_zlim()\n",
    "        ax3D.grid()\n",
    "        # Set scale factor for drawing \"quiver\" vectors (i.e., Vt, Vm, Am, Wr).\n",
    "        Qsfac = abs(xmax-xmin)/15.0\n",
    "        # Instantiate artist for frame time to be drawn on 3D plot.\n",
    "        time_text = ax3D.text3D(xmin-500.0, ymax+100.0, zmax+(zmax-zmin)/4.0, '')\n",
    "        # Add line artists to 3D plot and set legend location.\n",
    "        ax3D.add_line(linePt)\n",
    "        ax3D.add_line(linePm)\n",
    "        ax3D.add_line(linePma)\n",
    "        ax3D.add_line(linePwr)\n",
    "        ax3D.add_line(linePx)\n",
    "        ax3D.add_line(linePtv)\n",
    "        ax3D.add_line(linePmv)\n",
    "        ax3D.add_line(linePttrk)\n",
    "        ax3D.add_line(linePtxy)\n",
    "        ax3D.add_line(linePtxz)\n",
    "        ax3D.add_line(linePmtrk)\n",
    "        ax3D.add_line(linePmxy)\n",
    "        ax3D.add_line(linePmxz)\n",
    "        ax3D.add_line(linePttgoxy)\n",
    "        ax3D.add_line(linePttgoxz)\n",
    "        ax3D.add_line(linePmtgoxy)\n",
    "        ax3D.add_line(linePmtgoxz)\n",
    "        ax3D.legend(loc='upper right')\n",
    "        # Set 3D plot viewing orientation, then draw everything.\n",
    "        ax3D.view_init(elev=20.0, azim=220.0)\n",
    "        ##fig3D.canvas.draw()\n",
    "        if SHOW_ANIM:\n",
    "            fig3D.canvas.draw()\n",
    "            # Note: The mouse is disabled to prevent the user from\n",
    "            #       changing 3D projection perspective and scaling\n",
    "            #       by 3D rotation, panning or zooming. However, it\n",
    "            #       would be advantageous for the user not to be so\n",
    "            #       restricted.\n",
    "            ax3D.disable_mouse_rotation()\n",
    "            bckgrnd = fig3D.canvas.copy_from_bbox(fig3D.bbox)\n",
    "            backend = mpl.get_backend().upper()\n",
    "            plt.show(block=False)\n",
    "\n",
    "    # Initialize state vector.\n",
    "\n",
    "    S = setS(S, Vt0, Pt0, Vm0, Pm0, pitchAngle(Vt0))\n",
    "\n",
    "    # Instantiate Runge-Kutta 4th order ode solver, initialize\n",
    "    # using current state with state time set to zero.\n",
    "\n",
    "    rk4 = RK4_Solver(tStep, nSvar)\n",
    "\n",
    "    S[0] = 0.0\n",
    "    rk4.init(S)\n",
    "\n",
    "    ## Loop until termination event or simulation stop condition reached.\n",
    "\n",
    "    t     = S[0]\n",
    "    i     = 0\n",
    "    istop = None  # used within onPress and anim3D procedures\n",
    "\n",
    "    while (not Stop(S)) and (i < nSamples):\n",
    "\n",
    "        if i == 0 or PRINT_DATA or SHOW_ANIM or SAVE_ANIM or PLOT_DATA or PRINT_TXYZ:\n",
    "            collectData(i, t, S)\n",
    "\n",
    "        if SHOW_ANIM:\n",
    "            fig3D.canvas.restore_region(bckgrnd)\n",
    "            for a in (anim3D(i)):\n",
    "                ax3D.draw_artist(a)\n",
    "            blit3D(fig3D, ax3D, backend)\n",
    "\n",
    "        # Perform RK4 integration for animation frame.\n",
    "        for n in range(0, N_STEP):\n",
    "            if not Stop(S):\n",
    "                S = rk4.step(S, dotS)\n",
    "\n",
    "        # Update simulation time and data samples index.\n",
    "        t = S[0]\n",
    "        i = i + 1\n",
    "\n",
    "    ## Exited simulation loop.\n",
    "\n",
    "    # Using states and derivatives prior to\n",
    "    # stop time, reduce step size and integrate\n",
    "    # till final stop condition.\n",
    "\n",
    "    num_trys = 0  # account for non-covergent intercepts\n",
    "    max_trys = 4\n",
    "\n",
    "    while (tStep > DT_FINAL) and (num_trys < max_trys):\n",
    "\n",
    "        print(\"\\nt=%9.5f  tStep=%9.5f  num_trys=%d  Dclose=%f\" %\n",
    "              (S[0], tStep, num_trys, Dclose(S)))\n",
    "\n",
    "        S = rk4.get_Sprev()\n",
    "\n",
    "        last_tStep = tStep\n",
    "        tStep      = delT(S)\n",
    "\n",
    "        rk4 = RK4_Solver(tStep, nSvar)\n",
    "\n",
    "        rk4.init(S)\n",
    "\n",
    "        while (not Stop(S)):\n",
    "            S = rk4.step(S, dotS)\n",
    "\n",
    "        if tStep == last_tStep:\n",
    "            num_trys = num_trys + 1\n",
    "\n",
    "    S = rk4.get_Sprev()\n",
    "    t = S[0]\n",
    "\n",
    "    if num_trys == max_trys:\n",
    "        if t < tStop-tStep:\n",
    "            print(\"\\n*** Non-convergent Intercept ***\")\n",
    "        else:\n",
    "            print(\"\\n*** Insufficient Simulation Time ***\")\n",
    "        INTERCEPT = False\n",
    "    else:\n",
    "        INTERCEPT = True\n",
    "\n",
    "    # Display last missile and target states and\n",
    "    # intercept status; collect data for plotting\n",
    "    # or printing.\n",
    "\n",
    "    PRINT_DATA = True\n",
    "\n",
    "    collectData(i, t, S)\n",
    "\n",
    "    istop = i\n",
    "    iend  = istop + 1\n",
    "\n",
    "    if (num_trys == max_trys) or (Dclose(S) > MinMissDist):\n",
    "        INTERCEPT = False\n",
    "        print(\"\\n*** Missile missed target.\")\n",
    "    else:\n",
    "        INTERCEPT = True\n",
    "        print(\"\\n*** Missile intercepted target.\")\n",
    "\n",
    "    if SHOW_ANIM or SAVE_ANIM or PLOT_DATA or PRINT_TXYZ:\n",
    "\n",
    "        # Ensure Time data array contains nSamples of simulation time steps\n",
    "        # in order to prevent plotted lines from wrapping back to time 0.0\n",
    "        # if the simulation loop was terminated before all nSamples of data\n",
    "        # were collected. Note: This may no longer be necessary.\n",
    "\n",
    "        while i < nSamples:\n",
    "            Time[i] = t\n",
    "            t = t + N_TIME\n",
    "            i = i + 1\n",
    "\n",
    "    if SHOW_ANIM:\n",
    "\n",
    "        # Display location of actual or missed intercept, then\n",
    "        # enter interactive replay loop.\n",
    "\n",
    "        fig3D.canvas.restore_region(bckgrnd)\n",
    "        for a in (anim3D(istop)):\n",
    "            ax3D.draw_artist(a)\n",
    "        blit3D(fig3D, ax3D, backend)\n",
    "        fig3D.canvas.draw()\n",
    "\n",
    "        nincr    = 0\n",
    "        paused   = True\n",
    "        quitflag = False\n",
    "        doneflag = False\n",
    "\n",
    "        # Connect Figure 14 key press handler.\n",
    "        cidkey = fig3D.canvas.mpl_connect('key_press_event', onPress)\n",
    "\n",
    "        print(\"\\nThe 3D engagement animation may be replayed forward and backward\")\n",
    "        print(\"in time. To reset the animation, press Space bar to unpause, then\")\n",
    "        print(\"press Up Arrow key to play forward in time. If the animation is\")\n",
    "        print(\"exited, press Up Arrow key to restart forward in time, or press\")\n",
    "        print(\"Esc key to exit Figure 14 and continue on with program processing.\")\n",
    "        print(\"During animation the following key presses are recognized:\\n\")\n",
    "\n",
    "        print(\"Press Up Arrow key twice to play animation forward in time.\")\n",
    "        print(\"Press Down Arrow key twice to play animation backward in time.\")\n",
    "        print(\"Press Right Arrow key to step animation one frame forward in time.\")\n",
    "        print(\"Press Left Arrow key to step animation one frame backward in time.\")\n",
    "        print(\"Press Space bar to toggle pause/unpause.\")\n",
    "        print(\"Press X key to exit animation (press Up Arrow key start replay).\")\n",
    "        print(\"Press Esc key to exit Figure 14.\")\n",
    "        print(\"Press Q key to close Figure 14.\")\n",
    "        \n",
    "        # Interactive replay loop.\n",
    "        while not doneflag:\n",
    "            if paused:\n",
    "                fig3D.canvas.flush_events()\n",
    "                continue\n",
    "            quitflag = False\n",
    "            nincr    = 0\n",
    "            iloop    = 0\n",
    "            init3D()\n",
    "            while not quitflag:\n",
    "                if doneflag or (iloop > istop) or (iloop < 0):\n",
    "                    quitflag = True\n",
    "                    break\n",
    "                if quitflag:\n",
    "                    break\n",
    "                if paused:\n",
    "                    fig3D.canvas.flush_events()\n",
    "                    continue\n",
    "                fig3D.canvas.restore_region(bckgrnd)\n",
    "                for a in (anim3D(iloop)):\n",
    "                    ax3D.draw_artist(a)\n",
    "                blit3D(fig3D, ax3D, backend)\n",
    "                iloop += nincr\n",
    "                iloop = min(max(0,iloop),istop)\n",
    "\n",
    "        # Disconnect Figure 14 key press handler.\n",
    "        fig3D.canvas.mpl_disconnect(cidkey)\n",
    "\n",
    "        # Enable 3D rotation, panning and zooming of final Figure\n",
    "        # 14 image displayed.\n",
    "        ax3D.mouse_init()\n",
    "\n",
    "        if not (PLOT_DATA or SAVE_ANIM):\n",
    "            if PRINT_TXYZ:\n",
    "                print(\"\\nClose Figure 14 to continue program.\")\n",
    "            else:\n",
    "                print(\"\\nClose Figure 14 to terminate program.\")\n",
    "            plt.show(block=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "jMcPITCwkN0V",
   "metadata": {
    "id": "jMcPITCwkN0V"
   },
   "source": [
    "### Save Animated Engagement Plot Figure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1uXJouk9kGuP",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 34707,
     "status": "ok",
     "timestamp": 1710972493447,
     "user": {
      "displayName": "Gary Deschaines",
      "userId": "00818646848844190559"
     },
     "user_tz": 300
    },
    "id": "1uXJouk9kGuP",
    "jupyter": {
     "source_hidden": true
    },
    "outputId": "9728b4f5-fad7-4205-fdfe-59369d448633"
   },
   "outputs": [],
   "source": [
    "    if SAVE_ANIM:\n",
    "\n",
    "        # Create and show the 3D engagement animation.\n",
    "        nframes   = iend\n",
    "        tdel      = 1.0/FPS\n",
    "        tdel_msec = 1000.0*tdel\n",
    "        try:\n",
    "            tmsec0 = 1000.0*time.clock()\n",
    "        except:\n",
    "            tmsec0 = 1000.0*time.process_time()\n",
    "        anim3D(0)\n",
    "        try:\n",
    "            tmsec1 = 1000.0*time.clock()\n",
    "        except:\n",
    "            tmsec1 = 1000.0*time.process_time()\n",
    "        tstep = tmsec1 - tmsec0\n",
    "        #interval  = max(ceil(tmsec1-tmsec0),1.0) # allows faster than real-time\n",
    "        interval  = tdel_msec - tstep   # approximates real-time\n",
    "        anim = animation.FuncAnimation(fig3D, anim3D, init_func=init3D,\n",
    "                                        frames=nframes, blit=True,\n",
    "                                        cache_frame_data=True,\n",
    "                                        interval=interval, repeat=False)\n",
    "\n",
    "        print(\"\\nCreating animation video; presentation will begin shortly...\")\n",
    "        writer = Writer(fps=FPS, codec='h264',\n",
    "                        metadata=dict(artist='propNav'),\n",
    "                        bitrate=-1)\n",
    "        sbuff = StringIO()\n",
    "        sbuff.write(\"%1d%1d%1d%1d\" % (int(MSL), int(PNAV), int(Nm), int(Nt)))\n",
    "        icase = sbuff.getvalue()\n",
    "        sbuff.close()\n",
    "\n",
    "        anim_filename = None\n",
    "        if RUN_WITH_COLAB:\n",
    "            gdf_path = Google_Drive_Folder\n",
    "            anim_filename = \"{0}/img/propNav_{1}.mp4\".format(gdf_path, icase)\n",
    "        else:\n",
    "            anim_filename = './img/propNav_' + icase + '.mp4'\n",
    "\n",
    "        anim.save(anim_filename, writer=writer)\n",
    "        print(\"Animation saved in file %s\" % anim_filename)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "Lplx8bPFrGpn",
   "metadata": {
    "id": "Lplx8bPFrGpn"
   },
   "source": [
    "### Display Figure 14 - Engagement Animation 3D Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8D2Q5GLLra70",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 573
    },
    "executionInfo": {
     "elapsed": 441,
     "status": "ok",
     "timestamp": 1710972493886,
     "user": {
      "displayName": "Gary Deschaines",
      "userId": "00818646848844190559"
     },
     "user_tz": 300
    },
    "id": "8D2Q5GLLra70",
    "jupyter": {
     "source_hidden": true
    },
    "outputId": "314e5669-f72e-439c-fe6c-bd04338e64d7"
   },
   "outputs": [],
   "source": [
    "        if Backend == 'nbAgg':\n",
    "            if RUN_WITH_COLAB:\n",
    "                print(\"\\nCreating Figure 14 - Engagement Animation; final frame will be displayed shortly...\\n\")\n",
    "                plt.show()\n",
    "            else:\n",
    "                print(\"\\nCreating Figure 14 - Engagement Animation.\\n\")\n",
    "                plt.show()\n",
    "        else:\n",
    "            if PLOT_DATA or PRINT_TXYZ:\n",
    "                print(\"\\nAfter animation stops, close Figure 14 to continue program.\")\n",
    "            else:\n",
    "                print(\"\\nAfter animation stops, close Figure 14 to terminate program.\")\n",
    "            plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52948db7-a157-4391-a8c5-969b02de1a9f",
   "metadata": {},
   "source": [
    "### Extract Arrays of Target and Missile Vectors from Collected Data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f602fd5d-aa31-4476-b502-a0f4b4a4fda7",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "    if (PLOT_DATA and PLOT_FIGS[12]) or PRINT_TXYZ:\n",
    "        \n",
    "        # Extract arrays of target and missile position, velocity\n",
    "        # and acceleration vectors from arrays of collected data.\n",
    "        \n",
    "        Pte = np.array([[Ptx[0:iend]],\n",
    "                        [Pty[0:iend]],\n",
    "                        [Ptz[0:iend]]]).reshape([1,3,iend])\n",
    "        Vte = np.array([[Vtx[0:iend]],\n",
    "                        [Vty[0:iend]],\n",
    "                        [Vtz[0:iend]]]).reshape([1,3,iend])\n",
    "        Ate = np.array([[Atx[0:iend]],\n",
    "                        [Aty[0:iend]],\n",
    "                        [Atz[0:iend]]]).reshape([1,3,iend])\n",
    "        Pme = np.array([[Pmx[0:iend]],\n",
    "                        [Pmy[0:iend]],\n",
    "                        [Pmz[0:iend]]]).reshape([1,3,iend])\n",
    "        Vme = np.array([[Vmx[0:iend]],\n",
    "                        [Vmy[0:iend]],\n",
    "                        [Vmz[0:iend]]]).reshape([1,3,iend])\n",
    "        Ame = np.array([[Amx[0:iend]],\n",
    "                        [Amy[0:iend]],\n",
    "                        [Amz[0:iend]]]).reshape([1,3,iend])\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "JY_PjKOJiqmO",
   "metadata": {
    "id": "JY_PjKOJiqmO"
   },
   "source": [
    "### Create and Display Engagement Data Plot Figures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bgXgw1_Ghtt4",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 376,
     "resources": {
      "http://localhost:8080/nbextensions/google.colab/tabbar.css": {
       "data": "Lmdvb2ctdGFie3Bvc2l0aW9uOnJlbGF0aXZlO3BhZGRpbmc6NHB4IDhweDtjb2xvcjojMDBjO3RleHQtZGVjb3JhdGlvbjp1bmRlcmxpbmU7Y3Vyc29yOmRlZmF1bHR9Lmdvb2ctdGFiLWJhci10b3AgLmdvb2ctdGFie21hcmdpbjoxcHggNHB4IDAgMDtib3JkZXItYm90dG9tOjA7ZmxvYXQ6bGVmdH0uZ29vZy10YWItYmFyLXRvcDphZnRlciwuZ29vZy10YWItYmFyLWJvdHRvbTphZnRlcntjb250ZW50OiIgIjtkaXNwbGF5OmJsb2NrO2hlaWdodDowO2NsZWFyOmJvdGg7dmlzaWJpbGl0eTpoaWRkZW59Lmdvb2ctdGFiLWJhci1ib3R0b20gLmdvb2ctdGFie21hcmdpbjowIDRweCAxcHggMDtib3JkZXItdG9wOjA7ZmxvYXQ6bGVmdH0uZ29vZy10YWItYmFyLXN0YXJ0IC5nb29nLXRhYnttYXJnaW46MCAwIDRweCAxcHg7Ym9yZGVyLXJpZ2h0OjB9Lmdvb2ctdGFiLWJhci1lbmQgLmdvb2ctdGFie21hcmdpbjowIDFweCA0cHggMDtib3JkZXItbGVmdDowfS5nb29nLXRhYi1ob3ZlcntiYWNrZ3JvdW5kOiNlZWV9Lmdvb2ctdGFiLWRpc2FibGVke2NvbG9yOiM2NjZ9Lmdvb2ctdGFiLXNlbGVjdGVke2NvbG9yOiMwMDA7YmFja2dyb3VuZDojZmZmO3RleHQtZGVjb3JhdGlvbjpub25lO2ZvbnQtd2VpZ2h0OmJvbGQ7Ym9yZGVyOjFweCBzb2xpZCAjNmI5MGRhfS5nb29nLXRhYi1iYXItdG9we3BhZGRpbmctdG9wOjVweCFpbXBvcnRhbnQ7cGFkZGluZy1sZWZ0OjVweCFpbXBvcnRhbnQ7Ym9yZGVyLWJvdHRvbToxcHggc29saWQgIzZiOTBkYSFpbXBvcnRhbnR9Lmdvb2ctdGFiLWJhci10b3AgLmdvb2ctdGFiLXNlbGVjdGVke3RvcDoxcHg7bWFyZ2luLXRvcDowO3BhZGRpbmctYm90dG9tOjVweH0uZ29vZy10YWItYmFyLWJvdHRvbSAuZ29vZy10YWItc2VsZWN0ZWR7dG9wOi0xcHg7bWFyZ2luLWJvdHRvbTowO3BhZGRpbmctdG9wOjVweH0uZ29vZy10YWItYmFyLXN0YXJ0IC5nb29nLXRhYi1zZWxlY3RlZHtsZWZ0OjFweDttYXJnaW4tbGVmdDowO3BhZGRpbmctcmlnaHQ6OXB4fS5nb29nLXRhYi1iYXItZW5kIC5nb29nLXRhYi1zZWxlY3RlZHtsZWZ0Oi0xcHg7bWFyZ2luLXJpZ2h0OjA7cGFkZGluZy1sZWZ0OjlweH0uZ29vZy10YWItYmFye21hcmdpbjowO2JvcmRlcjowO3BhZGRpbmc6MDtsaXN0LXN0eWxlOm5vbmU7Y3Vyc29yOmRlZmF1bHQ7b3V0bGluZTpub25lO2JhY2tncm91bmQ6I2ViZWZmOX0uZ29vZy10YWItYmFyLWNsZWFye2NsZWFyOmJvdGg7aGVpZ2h0OjA7b3ZlcmZsb3c6aGlkZGVufS5nb29nLXRhYi1iYXItc3RhcnR7ZmxvYXQ6bGVmdH0uZ29vZy10YWItYmFyLWVuZHtmbG9hdDpyaWdodH0qIGh0bWwgLmdvb2ctdGFiLWJhci1zdGFydHttYXJnaW4tcmlnaHQ6LTNweH0qIGh0bWwgLmdvb2ctdGFiLWJhci1lbmR7bWFyZ2luLWxlZnQ6LTNweH0=",
       "headers": [
        [
         "content-type",
         "text/css"
        ]
       ],
       "ok": true,
       "status": 200,
       "status_text": ""
      },
      "http://localhost:8080/nbextensions/google.colab/tabbar_main.min.js": {
       "data": "// clang-format off
(function(){var h,aa=function(a){var b=0;return function(){return b<a.length?{done:!1,value:a[b++]}:{done:!0}}},ba=function(a){var b="undefined"!=typeof Symbol&&Symbol.iterator&&a[Symbol.iterator];return b?b.call(a):{next:aa(a)}},l=this||self,ca=function(){},da=function(a){a.Ba=void 0;a.R=function(){return a.Ba?a.Ba:a.Ba=new a}},ea=function(a){var b=typeof a;if("object"==b)if(a){if(a instanceof Array)return"array";if(a instanceof Object)return b;var c=Object.prototype.toString.call(a);if("[object Window]"==c)return"object";
if("[object Array]"==c||"number"==typeof a.length&&"undefined"!=typeof a.splice&&"undefined"!=typeof a.propertyIsEnumerable&&!a.propertyIsEnumerable("splice"))return"array";if("[object Function]"==c||"undefined"!=typeof a.call&&"undefined"!=typeof a.propertyIsEnumerable&&!a.propertyIsEnumerable("call"))return"function"}else return"null";else if("function"==b&&"undefined"==typeof a.call)return"object";return b},fa=function(a){return"array"==ea(a)},ha=function(a){var b=ea(a);return"array"==b||"object"==
b&&"number"==typeof a.length},ia=function(a){return"function"==ea(a)},m=function(a){var b=typeof a;return"object"==b&&null!=a||"function"==b},ja="closure_uid_"+(1E9*Math.random()>>>0),ka=0,la=function(a,b){var c=Array.prototype.slice.call(arguments,1);return function(){var d=c.slice();d.push.apply(d,arguments);return a.apply(this,d)}},n=function(a,b){function c(){}c.prototype=b.prototype;a.i=b.prototype;a.prototype=new c;a.prototype.constructor=a};var ma,na={eb:"activedescendant",jb:"atomic",kb:"autocomplete",mb:"busy",pb:"checked",qb:"colindex",vb:"controls",xb:"describedby",Ab:"disabled",Cb:"dropeffect",Db:"expanded",Eb:"flowto",Gb:"grabbed",Kb:"haspopup",Mb:"hidden",Ob:"invalid",Pb:"label",Qb:"labelledby",Rb:"level",Wb:"live",kc:"multiline",lc:"multiselectable",pc:"orientation",qc:"owns",rc:"posinset",tc:"pressed",xc:"readonly",zc:"relevant",Ac:"required",Ec:"rowindex",Hc:"selected",Jc:"setsize",Lc:"sort",Zc:"valuemax",$c:"valuemin",ad:"valuenow",
bd:"valuetext"};var oa=function(a,b,c){for(var d in a)b.call(c,a[d],d,a)},pa=function(a,b){for(var c in a)if(a[c]==b)return!0;return!1},qa=function(a,b,c){if(null!==a&&b in a)throw Error('The object already contains the key "'+b+'"');a[b]=c},sa=function(a){var b={},c;for(c in a)b[a[c]]=c;return b},ta="constructor hasOwnProperty isPrototypeOf propertyIsEnumerable toLocaleString toString valueOf".split(" "),ua=function(a,b){for(var c,d,e=1;e<arguments.length;e++){d=arguments[e];for(c in d)a[c]=d[c];for(var f=0;f<ta.length;f++)c=
ta[f],Object.prototype.hasOwnProperty.call(d,c)&&(a[c]=d[c])}};var va={fb:"alert",gb:"alertdialog",hb:"application",ib:"article",lb:"banner",nb:"button",ob:"checkbox",rb:"columnheader",sb:"combobox",tb:"complementary",ub:"contentinfo",wb:"definition",yb:"dialog",zb:"directory",Bb:"document",Fb:"form",Hb:"grid",Ib:"gridcell",Jb:"group",Lb:"heading",Nb:"img",Sb:"link",Tb:"list",Ub:"listbox",Vb:"listitem",Xb:"log",Yb:"main",Zb:"marquee",$b:"math",ac:"menu",bc:"menubar",cc:"menuitem",dc:"menuitemcheckbox",ec:"menuitemradio",mc:"navigation",nc:"note",oc:"option",
sc:"presentation",uc:"progressbar",vc:"radio",wc:"radiogroup",yc:"region",Bc:"row",Cc:"rowgroup",Dc:"rowheader",Fc:"scrollbar",Gc:"search",Ic:"separator",Kc:"slider",Mc:"spinbutton",Nc:"status",Oc:"tab",Pc:"tablist",Qc:"tabpanel",Rc:"textbox",Sc:"textinfo",Tc:"timer",Uc:"toolbar",Vc:"tooltip",Wc:"tree",Xc:"treegrid",Yc:"treeitem"};var wa=function(a){if(Error.captureStackTrace)Error.captureStackTrace(this,wa);else{var b=Error().stack;b&&(this.stack=b)}a&&(this.message=String(a))};n(wa,Error);wa.prototype.name="CustomError";var xa;var ya=function(a,b){a=a.split("%s");for(var c="",d=a.length-1,e=0;e<d;e++)c+=a[e]+(e<b.length?b[e]:"%s");wa.call(this,c+a[d])};n(ya,wa);ya.prototype.name="AssertionError";
var za=function(a,b,c,d){var e="Assertion failed";if(c){e+=": "+c;var f=d}else a&&(e+=": "+a,f=b);throw new ya(""+e,f||[]);},q=function(a,b,c){a||za("",null,b,Array.prototype.slice.call(arguments,2));return a},Aa=function(a,b,c){m(a)&&1==a.nodeType||za("Expected Element but got %s: %s.",[ea(a),a],b,Array.prototype.slice.call(arguments,2))},Ca=function(a,b,c,d){a instanceof b||za("Expected instanceof %s but got %s.",[Ba(b),Ba(a)],c,Array.prototype.slice.call(arguments,3))},Ba=function(a){return a instanceof
Function?a.displayName||a.name||"unknown type name":a instanceof Object?a.constructor.displayName||a.constructor.name||Object.prototype.toString.call(a):null===a?"null":typeof a};var Da=Array.prototype.indexOf?function(a,b){q(null!=a.length);return Array.prototype.indexOf.call(a,b,void 0)}:function(a,b){if("string"===typeof a)return"string"!==typeof b||1!=b.length?-1:a.indexOf(b,0);for(var c=0;c<a.length;c++)if(c in a&&a[c]===b)return c;return-1},r=Array.prototype.forEach?function(a,b,c){q(null!=a.length);Array.prototype.forEach.call(a,b,c)}:function(a,b,c){for(var d=a.length,e="string"===typeof a?a.split(""):a,f=0;f<d;f++)f in e&&b.call(c,e[f],f,a)},Ea=Array.prototype.filter?
function(a,b){q(null!=a.length);return Array.prototype.filter.call(a,b,void 0)}:function(a,b){for(var c=a.length,d=[],e=0,f="string"===typeof a?a.split(""):a,g=0;g<c;g++)if(g in f){var k=f[g];b.call(void 0,k,g,a)&&(d[e++]=k)}return d},Fa=Array.prototype.every?function(a,b){q(null!=a.length);return Array.prototype.every.call(a,b,void 0)}:function(a,b){for(var c=a.length,d="string"===typeof a?a.split(""):a,e=0;e<c;e++)if(e in d&&!b.call(void 0,d[e],e,a))return!1;return!0},Ga=function(a,b){return 0<=
Da(a,b)},Ha=function(a,b){b=Da(a,b);var c;if(c=0<=b)q(null!=a.length),Array.prototype.splice.call(a,b,1);return c},Ia=function(a){return Array.prototype.concat.apply([],arguments)},Ja=function(a){var b=a.length;if(0<b){for(var c=Array(b),d=0;d<b;d++)c[d]=a[d];return c}return[]},La=function(a,b,c,d){q(null!=a.length);Array.prototype.splice.apply(a,Ka(arguments,1))},Ka=function(a,b,c){q(null!=a.length);return 2>=arguments.length?Array.prototype.slice.call(a,b):Array.prototype.slice.call(a,b,c)};var Ma=String.prototype.trim?function(a){return a.trim()}:function(a){return/^[\s\xa0]*([\s\S]*?)[\s\xa0]*$/.exec(a)[1]},Na=/&/g,Oa=/</g,Pa=/>/g,Qa=/"/g,Ra=/'/g,Sa=/\x00/g,Ta=/[\x00&<>"']/,t=function(a,b){return-1!=a.indexOf(b)},Ua=function(a,b){return a<b?-1:a>b?1:0};var u;a:{var Va=l.navigator;if(Va){var Wa=Va.userAgent;if(Wa){u=Wa;break a}}u=""};/*

 Copyright The Closure Library Authors.
 SPDX-License-Identifier: Apache-2.0
*/
var Xa=function(a){Ta.test(a)&&(-1!=a.indexOf("&")&&(a=a.replace(Na,"&amp;")),-1!=a.indexOf("<")&&(a=a.replace(Oa,"&lt;")),-1!=a.indexOf(">")&&(a=a.replace(Pa,"&gt;")),-1!=a.indexOf('"')&&(a=a.replace(Qa,"&quot;")),-1!=a.indexOf("'")&&(a=a.replace(Ra,"&#39;")),-1!=a.indexOf("\x00")&&(a=a.replace(Sa,"&#0;")));return a};var Ya=function(a){Ya[" "](a);return a};Ya[" "]=ca;var $a=function(a,b){var c=Za;return Object.prototype.hasOwnProperty.call(c,a)?c[a]:c[a]=b(a)};var ab=t(u,"Opera"),v=t(u,"Trident")||t(u,"MSIE"),bb=t(u,"Edge"),x=t(u,"Gecko")&&!(t(u.toLowerCase(),"webkit")&&!t(u,"Edge"))&&!(t(u,"Trident")||t(u,"MSIE"))&&!t(u,"Edge"),y=t(u.toLowerCase(),"webkit")&&!t(u,"Edge"),z=t(u,"Macintosh"),cb=function(){var a=l.document;return a?a.documentMode:void 0},db;
a:{var eb="",fb=function(){var a=u;if(x)return/rv:([^\);]+)(\)|;)/.exec(a);if(bb)return/Edge\/([\d\.]+)/.exec(a);if(v)return/\b(?:MSIE|rv)[: ]([^\);]+)(\)|;)/.exec(a);if(y)return/WebKit\/(\S+)/.exec(a);if(ab)return/(?:Version)[ \/]?(\S+)/.exec(a)}();fb&&(eb=fb?fb[1]:"");if(v){var gb=cb();if(null!=gb&&gb>parseFloat(eb)){db=String(gb);break a}}db=eb}
var hb=db,Za={},A=function(a){return $a(a,function(){for(var b=0,c=Ma(String(hb)).split("."),d=Ma(String(a)).split("."),e=Math.max(c.length,d.length),f=0;0==b&&f<e;f++){var g=c[f]||"",k=d[f]||"";do{g=/(\d*)(\D*)(.*)/.exec(g)||["","","",""];k=/(\d*)(\D*)(.*)/.exec(k)||["","","",""];if(0==g[0].length&&0==k[0].length)break;b=Ua(0==g[1].length?0:parseInt(g[1],10),0==k[1].length?0:parseInt(k[1],10))||Ua(0==g[2].length,0==k[2].length)||Ua(g[2],k[2]);g=g[3];k=k[3]}while(0==b)}return 0<=b})},ib;
ib=l.document&&v?cb():void 0;var jb=!v||9<=Number(ib);var lb=function(a,b){oa(b,function(c,d){c&&"object"==typeof c&&c.dd&&(c=c.cd());"style"==d?a.style.cssText=c:"class"==d?a.className=c:"for"==d?a.htmlFor=c:kb.hasOwnProperty(d)?a.setAttribute(kb[d],c):0==d.lastIndexOf("aria-",0)||0==d.lastIndexOf("data-",0)?a.setAttribute(d,c):a[d]=c})},kb={cellpadding:"cellPadding",cellspacing:"cellSpacing",colspan:"colSpan",frameborder:"frameBorder",height:"height",maxlength:"maxLength",nonce:"nonce",role:"role",rowspan:"rowSpan",type:"type",usemap:"useMap",valign:"vAlign",
width:"width"},mb=function(a,b,c){function d(k){k&&b.appendChild("string"===typeof k?a.createTextNode(k):k)}for(var e=2;e<c.length;e++){var f=c[e];if(!ha(f)||m(f)&&0<f.nodeType)d(f);else{a:{if(f&&"number"==typeof f.length){if(m(f)){var g="function"==typeof f.item||"string"==typeof f.item;break a}if(ia(f)){g="function"==typeof f.item;break a}}g=!1}r(g?Ja(f):f,d)}}},nb=function(a,b){b=String(b);"application/xhtml+xml"===a.contentType&&(b=b.toLowerCase());return a.createElement(b)},ob=function(a){a&&
a.parentNode&&a.parentNode.removeChild(a)},pb=function(a,b){if(!a||!b)return!1;if(a.contains&&1==b.nodeType)return a==b||a.contains(b);if("undefined"!=typeof a.compareDocumentPosition)return a==b||!!(a.compareDocumentPosition(b)&16);for(;b&&a!=b;)b=b.parentNode;return b==a},qb=function(a){q(a,"Node cannot be null or undefined.");return 9==a.nodeType?a:a.ownerDocument||a.document},rb=function(a,b){b?a.tabIndex=0:(a.tabIndex=-1,a.removeAttribute("tabIndex"))},sb=function(a){return v&&!A("9")?(a=a.getAttributeNode("tabindex"),
null!=a&&a.specified):a.hasAttribute("tabindex")},tb=function(a){a=a.tabIndex;return"number"===typeof a&&0<=a&&32768>a},ub=function(a){this.a=a||l.document||document};ub.prototype.f=function(a){return"string"===typeof a?this.a.getElementById(a):a};
ub.prototype.b=function(a,b,c){var d=this.a,e=arguments,f=String(e[0]),g=e[1];if(!jb&&g&&(g.name||g.type)){f=["<",f];g.name&&f.push(' name="',Xa(g.name),'"');if(g.type){f.push(' type="',Xa(g.type),'"');var k={};ua(k,g);delete k.type;g=k}f.push(">");f=f.join("")}f=nb(d,f);g&&("string"===typeof g?f.className=g:fa(g)?f.className=g.join(" "):lb(f,g));2<e.length&&mb(d,f,e);return f};var vb=function(a,b){b?(q(pa(va,b),"No such ARIA role "+b),a.setAttribute("role",b)):a.removeAttribute("role")},xb=function(a,b,c){fa(c)&&(c=c.join(" "));var d=wb(b);""===c||void 0==c?(ma||(ma={atomic:!1,autocomplete:"none",dropeffect:"none",haspopup:!1,live:"off",multiline:!1,multiselectable:!1,orientation:"vertical",readonly:!1,relevant:"additions text",required:!1,sort:"none",busy:!1,disabled:!1,hidden:!1,invalid:"false"}),c=ma,b in c?a.setAttribute(d,c[b]):a.removeAttribute(d)):a.setAttribute(d,
c)},wb=function(a){q(a,"ARIA attribute cannot be empty.");q(pa(na,a),"No such ARIA attribute "+a);return"aria-"+a};var yb=Object.freeze||function(a){return a};var C=function(){this.U=this.U;this.J=this.J};C.prototype.U=!1;C.prototype.N=function(){this.U||(this.U=!0,this.u())};var zb=function(a,b){a.U?b():(a.J||(a.J=[]),a.J.push(b))};C.prototype.u=function(){if(this.J)for(;this.J.length;)this.J.shift()()};var Ab=function(a){a&&"function"==typeof a.N&&a.N()};var Bb=function(a){return"string"==typeof a.className?a.className:a.getAttribute&&a.getAttribute("class")||""},D=function(a){return a.classList?a.classList:Bb(a).match(/\S+/g)||[]},Cb=function(a,b){"string"==typeof a.className?a.className=b:a.setAttribute&&a.setAttribute("class",b)},Db=function(a,b){return a.classList?a.classList.contains(b):Ga(D(a),b)},Eb=function(a,b){if(a.classList)a.classList.add(b);else if(!Db(a,b)){var c=Bb(a);Cb(a,c+(0<c.length?" "+b:b))}},Fb=function(a,b){if(a.classList)r(b,
function(e){Eb(a,e)});else{var c={};r(D(a),function(e){c[e]=!0});r(b,function(e){c[e]=!0});b="";for(var d in c)b+=0<b.length?" "+d:d;Cb(a,b)}},Gb=function(a,b){a.classList?a.classList.remove(b):Db(a,b)&&Cb(a,Ea(D(a),function(c){return c!=b}).join(" "))},Hb=function(a,b){a.classList?r(b,function(c){Gb(a,c)}):Cb(a,Ea(D(a),function(c){return!Ga(b,c)}).join(" "))};var Ib=!v||9<=Number(ib),Jb=!v||9<=Number(ib),Kb=v&&!A("9"),Lb=function(){if(!l.addEventListener||!Object.defineProperty)return!1;var a=!1,b=Object.defineProperty({},"passive",{get:function(){a=!0}});try{l.addEventListener("test",ca,b),l.removeEventListener("test",ca,b)}catch(c){}return a}();var E=function(a,b){this.type=a;this.a=this.target=b;this.h=!1;this.Ka=!0};E.prototype.j=function(){this.h=!0};E.prototype.g=function(){this.Ka=!1};var F={L:"mousedown",M:"mouseup",aa:"mousecancel",hc:"mousemove",jc:"mouseover",ic:"mouseout",fc:"mouseenter",gc:"mouseleave"};var G=function(a,b){E.call(this,a?a.type:"");this.relatedTarget=this.a=this.target=null;this.button=this.screenY=this.screenX=this.clientY=this.clientX=0;this.key="";this.c=0;this.A=this.metaKey=this.shiftKey=this.altKey=this.ctrlKey=!1;this.pointerId=0;this.pointerType="";this.b=null;if(a){var c=this.type=a.type,d=a.changedTouches&&a.changedTouches.length?a.changedTouches[0]:null;this.target=a.target||a.srcElement;this.a=b;if(b=a.relatedTarget){if(x){a:{try{Ya(b.nodeName);var e=!0;break a}catch(f){}e=
!1}e||(b=null)}}else"mouseover"==c?b=a.fromElement:"mouseout"==c&&(b=a.toElement);this.relatedTarget=b;d?(this.clientX=void 0!==d.clientX?d.clientX:d.pageX,this.clientY=void 0!==d.clientY?d.clientY:d.pageY,this.screenX=d.screenX||0,this.screenY=d.screenY||0):(this.clientX=void 0!==a.clientX?a.clientX:a.pageX,this.clientY=void 0!==a.clientY?a.clientY:a.pageY,this.screenX=a.screenX||0,this.screenY=a.screenY||0);this.button=a.button;this.c=a.keyCode||0;this.key=a.key||"";this.ctrlKey=a.ctrlKey;this.altKey=
a.altKey;this.shiftKey=a.shiftKey;this.metaKey=a.metaKey;this.A=z?a.metaKey:a.ctrlKey;this.pointerId=a.pointerId||0;this.pointerType="string"===typeof a.pointerType?a.pointerType:Mb[a.pointerType]||"";this.b=a;a.defaultPrevented&&this.g()}};n(G,E);var Nb=yb([1,4,2]),Mb=yb({2:"touch",3:"pen",4:"mouse"}),Ob=function(a){return Ib?0==a.b.button:"click"==a.type?!0:!!(a.b.button&Nb[0])};G.prototype.j=function(){G.i.j.call(this);this.b.stopPropagation?this.b.stopPropagation():this.b.cancelBubble=!0};
G.prototype.g=function(){G.i.g.call(this);var a=this.b;if(a.preventDefault)a.preventDefault();else if(a.returnValue=!1,Kb)try{if(a.ctrlKey||112<=a.keyCode&&123>=a.keyCode)a.keyCode=-1}catch(b){}};var Pb="closure_listenable_"+(1E6*Math.random()|0),Qb=function(a){return!(!a||!a[Pb])},Rb=0;var Sb=function(a,b,c,d,e){this.listener=a;this.a=null;this.src=b;this.type=c;this.capture=!!d;this.ma=e;this.key=++Rb;this.X=this.ha=!1},Tb=function(a){a.X=!0;a.listener=null;a.a=null;a.src=null;a.ma=null};var Ub=function(a){this.src=a;this.a={};this.b=0};Ub.prototype.add=function(a,b,c,d,e){var f=a.toString();a=this.a[f];a||(a=this.a[f]=[],this.b++);var g=Vb(a,b,d,e);-1<g?(b=a[g],c||(b.ha=!1)):(b=new Sb(b,this.src,f,!!d,e),b.ha=c,a.push(b));return b};
var Wb=function(a,b){var c=b.type;c in a.a&&Ha(a.a[c],b)&&(Tb(b),0==a.a[c].length&&(delete a.a[c],a.b--))},Xb=function(a,b,c,d,e){a=a.a[b.toString()];b=-1;a&&(b=Vb(a,c,d,e));return-1<b?a[b]:null},Vb=function(a,b,c,d){for(var e=0;e<a.length;++e){var f=a[e];if(!f.X&&f.listener==b&&f.capture==!!c&&f.ma==d)return e}return-1};var Yb="closure_lm_"+(1E6*Math.random()|0),Zb={},$b=0,bc=function(a,b,c,d,e){if(d&&d.once)return ac(a,b,c,d,e);if(fa(b)){for(var f=0;f<b.length;f++)bc(a,b[f],c,d,e);return null}c=cc(c);return Qb(a)?dc(a,b,c,m(d)?!!d.capture:!!d,e):ec(a,b,c,!1,d,e)},ec=function(a,b,c,d,e,f){if(!b)throw Error("Invalid event type");var g=m(e)?!!e.capture:!!e,k=fc(a);k||(a[Yb]=k=new Ub(a));c=k.add(b,c,d,g,f);if(c.a)return c;d=gc();c.a=d;d.src=a;d.listener=c;if(a.addEventListener)Lb||(e=g),void 0===e&&(e=!1),a.addEventListener(b.toString(),
d,e);else if(a.attachEvent)a.attachEvent(hc(b.toString()),d);else if(a.addListener&&a.removeListener)q("change"===b,"MediaQueryList only has a change event"),a.addListener(d);else throw Error("addEventListener and attachEvent are unavailable.");$b++;return c},gc=function(){var a=ic,b=Jb?function(c){return a.call(b.src,b.listener,c)}:function(c){c=a.call(b.src,b.listener,c);if(!c)return c};return b},ac=function(a,b,c,d,e){if(fa(b)){for(var f=0;f<b.length;f++)ac(a,b[f],c,d,e);return null}c=cc(c);return Qb(a)?
a.h.add(String(b),c,!0,m(d)?!!d.capture:!!d,e):ec(a,b,c,!0,d,e)},jc=function(a,b,c,d,e){if(fa(b))for(var f=0;f<b.length;f++)jc(a,b[f],c,d,e);else d=m(d)?!!d.capture:!!d,c=cc(c),Qb(a)?(a=a.h,b=String(b).toString(),b in a.a&&(f=a.a[b],c=Vb(f,c,d,e),-1<c&&(Tb(f[c]),q(null!=f.length),Array.prototype.splice.call(f,c,1),0==f.length&&(delete a.a[b],a.b--)))):a&&(a=fc(a))&&(c=Xb(a,b,c,d,e))&&kc(c)},kc=function(a){if("number"!==typeof a&&a&&!a.X){var b=a.src;if(Qb(b))Wb(b.h,a);else{var c=a.type,d=a.a;b.removeEventListener?
b.removeEventListener(c,d,a.capture):b.detachEvent?b.detachEvent(hc(c),d):b.addListener&&b.removeListener&&b.removeListener(d);$b--;(c=fc(b))?(Wb(c,a),0==c.b&&(c.src=null,b[Yb]=null)):Tb(a)}}},hc=function(a){return a in Zb?Zb[a]:Zb[a]="on"+a},mc=function(a,b,c,d){var e=!0;if(a=fc(a))if(b=a.a[b.toString()])for(b=b.concat(),a=0;a<b.length;a++){var f=b[a];f&&f.capture==c&&!f.X&&(f=lc(f,d),e=e&&!1!==f)}return e},lc=function(a,b){var c=a.listener,d=a.ma||a.src;a.ha&&kc(a);return c.call(d,b)},ic=function(a,
b){if(a.X)return!0;if(!Jb){if(!b)a:{b=["window","event"];for(var c=l,d=0;d<b.length;d++)if(c=c[b[d]],null==c){b=null;break a}b=c}d=b;b=new G(d,this);c=!0;if(!(0>d.keyCode||void 0!=d.returnValue)){a:{var e=!1;if(0==d.keyCode)try{d.keyCode=-1;break a}catch(g){e=!0}if(e||void 0==d.returnValue)d.returnValue=!0}d=[];for(e=b.a;e;e=e.parentNode)d.push(e);a=a.type;for(e=d.length-1;!b.h&&0<=e;e--){b.a=d[e];var f=mc(d[e],a,!0,b);c=c&&f}for(e=0;!b.h&&e<d.length;e++)b.a=d[e],f=mc(d[e],a,!1,b),c=c&&f}return c}return lc(a,
new G(b,this))},fc=function(a){a=a[Yb];return a instanceof Ub?a:null},nc="__closure_events_fn_"+(1E9*Math.random()>>>0),cc=function(a){q(a,"Listener can not be null.");if(ia(a))return a;q(a.handleEvent,"An object listener must have handleEvent method.");a[nc]||(a[nc]=function(b){return a.handleEvent(b)});return a[nc]};var oc=function(a){C.call(this);this.b=a;this.a={}};n(oc,C);
var pc=[],H=function(a,b,c,d){fa(c)||(c&&(pc[0]=c.toString()),c=pc);for(var e=0;e<c.length;e++){var f=bc(b,c[e],d||a.handleEvent,!1,a.b||a);if(!f)break;a.a[f.key]=f}return a},qc=function(a,b,c,d,e,f){if(fa(c))for(var g=0;g<c.length;g++)qc(a,b,c[g],d,e,f);else d=d||a.handleEvent,e=m(e)?!!e.capture:!!e,f=f||a.b||a,d=cc(d),e=!!e,c=Qb(b)?Xb(b.h,String(c),d,e,f):b?(b=fc(b))?Xb(b,c,d,e,f):null:null,c&&(kc(c),delete a.a[c.key]);return a},rc=function(a){oa(a.a,function(b,c){this.a.hasOwnProperty(c)&&kc(b)},
a);a.a={}};oc.prototype.u=function(){oc.i.u.call(this);rc(this)};oc.prototype.handleEvent=function(){throw Error("EventHandler.handleEvent not implemented");};var I=function(){C.call(this);this.h=new Ub(this);this.Ma=this;this.pa=null};n(I,C);I.prototype[Pb]=!0;I.prototype.ra=function(a){this.pa=a};I.prototype.removeEventListener=function(a,b,c,d){jc(this,a,b,c,d)};
var uc=function(a,b){sc(a);var c=a.pa;if(c){var d=[];for(var e=1;c;c=c.pa)d.push(c),q(1E3>++e,"infinite loop")}a=a.Ma;c=b.type||b;"string"===typeof b?b=new E(b,a):b instanceof E?b.target=b.target||a:(e=b,b=new E(c,a),ua(b,e));e=!0;if(d)for(var f=d.length-1;!b.h&&0<=f;f--){var g=b.a=d[f];e=tc(g,c,!0,b)&&e}b.h||(g=b.a=a,e=tc(g,c,!0,b)&&e,b.h||(e=tc(g,c,!1,b)&&e));if(d)for(f=0;!b.h&&f<d.length;f++)g=b.a=d[f],e=tc(g,c,!1,b)&&e;return e};
I.prototype.u=function(){I.i.u.call(this);if(this.h){var a=this.h,b=0,c;for(c in a.a){for(var d=a.a[c],e=0;e<d.length;e++)++b,Tb(d[e]);delete a.a[c];a.b--}}this.pa=null};var dc=function(a,b,c,d,e){sc(a);return a.h.add(String(b),c,!1,d,e)},tc=function(a,b,c,d){b=a.h.a[String(b)];if(!b)return!0;b=b.concat();for(var e=!0,f=0;f<b.length;++f){var g=b[f];if(g&&!g.X&&g.capture==c){var k=g.listener,p=g.ma||g.src;g.ha&&Wb(a.h,g);e=!1!==k.call(p,d)&&e}}return e&&0!=d.Ka},sc=function(a){q(a.h,"Event target is not initialized. Did you call the superclass (goog.events.EventTarget) constructor?")};var xc=function(a,b,c,d,e,f){if(y&&!A("525"))return!0;if(z&&e)return vc(a);if(e&&!d)return!1;if(!x){"number"===typeof b&&(b=wc(b));var g=17==b||18==b||z&&91==b;if((!c||z)&&g||z&&16==b&&(d||f))return!1}if((y||bb)&&d&&c)switch(a){case 220:case 219:case 221:case 192:case 186:case 189:case 187:case 188:case 190:case 191:case 192:case 222:return!1}if(v&&d&&b==a)return!1;switch(a){case 13:return x?f||e?!1:!(c&&d):!0;case 27:return!(y||bb||x)}return x&&(d||e||f)?!1:vc(a)},vc=function(a){if(48<=a&&57>=a||
96<=a&&106>=a||65<=a&&90>=a||(y||bb)&&0==a)return!0;switch(a){case 32:case 43:case 63:case 64:case 107:case 109:case 110:case 111:case 186:case 59:case 189:case 187:case 61:case 188:case 190:case 191:case 192:case 222:case 219:case 220:case 221:case 163:case 58:return!0;case 173:return x;default:return!1}},wc=function(a){if(x)a=yc(a);else if(z&&y)switch(a){case 93:a=91}return a},yc=function(a){switch(a){case 61:return 187;case 59:return 186;case 173:return 189;case 224:return 91;case 0:return 224;
default:return a}};var J=function(a,b){I.call(this);a&&zc(this,a,b)};n(J,I);h=J.prototype;h.S=null;h.na=null;h.Ca=null;h.oa=null;h.w=-1;h.F=-1;h.ua=!1;
var Ac={3:13,12:144,63232:38,63233:40,63234:37,63235:39,63236:112,63237:113,63238:114,63239:115,63240:116,63241:117,63242:118,63243:119,63244:120,63245:121,63246:122,63247:123,63248:44,63272:46,63273:36,63275:35,63276:33,63277:34,63289:144,63302:45},Bc={Up:38,Down:40,Left:37,Right:39,Enter:13,F1:112,F2:113,F3:114,F4:115,F5:116,F6:117,F7:118,F8:119,F9:120,F10:121,F11:122,F12:123,"U+007F":46,Home:36,End:35,PageUp:33,PageDown:34,Insert:45},Cc=!y||A("525"),Dc=z&&x;
J.prototype.a=function(a){if(y||bb)if(17==this.w&&!a.ctrlKey||18==this.w&&!a.altKey||z&&91==this.w&&!a.metaKey)this.F=this.w=-1;-1==this.w&&(a.ctrlKey&&17!=a.c?this.w=17:a.altKey&&18!=a.c?this.w=18:a.metaKey&&91!=a.c&&(this.w=91));Cc&&!xc(a.c,this.w,a.shiftKey,a.ctrlKey,a.altKey,a.metaKey)?this.handleEvent(a):(this.F=wc(a.c),Dc&&(this.ua=a.altKey))};J.prototype.b=function(a){this.F=this.w=-1;this.ua=a.altKey};
J.prototype.handleEvent=function(a){var b=a.b,c=b.altKey;if(v&&"keypress"==a.type){var d=this.F;var e=13!=d&&27!=d?b.keyCode:0}else(y||bb)&&"keypress"==a.type?(d=this.F,e=0<=b.charCode&&63232>b.charCode&&vc(d)?b.charCode:0):ab&&!y?(d=this.F,e=vc(d)?b.keyCode:0):("keypress"==a.type?(Dc&&(c=this.ua),b.keyCode==b.charCode?32>b.keyCode?(d=b.keyCode,e=0):(d=this.F,e=b.charCode):(d=b.keyCode||this.F,e=b.charCode||0)):(d=b.keyCode||this.F,e=b.charCode||0),z&&63==e&&224==d&&(d=191));var f=d=wc(d);d?63232<=
d&&d in Ac?f=Ac[d]:25==d&&a.shiftKey&&(f=9):b.keyIdentifier&&b.keyIdentifier in Bc&&(f=Bc[b.keyIdentifier]);x&&Cc&&"keypress"==a.type&&!xc(f,this.w,a.shiftKey,a.ctrlKey,c,a.metaKey)||(a=f==this.w,this.w=f,b=new Ec(f,e,a,b),b.altKey=c,uc(this,b))};J.prototype.f=function(){return this.S};
var zc=function(a,b,c){a.oa&&Fc(a);a.S=b;a.na=bc(a.S,"keypress",a,c);a.Ca=bc(a.S,"keydown",a.a,c,a);a.oa=bc(a.S,"keyup",a.b,c,a)},Fc=function(a){a.na&&(kc(a.na),kc(a.Ca),kc(a.oa),a.na=null,a.Ca=null,a.oa=null);a.S=null;a.w=-1;a.F=-1};J.prototype.u=function(){J.i.u.call(this);Fc(this)};var Ec=function(a,b,c,d){G.call(this,d);this.type="key";this.c=a;this.repeat=c};n(Ec,G);var Gc=x?"MozUserSelect":y||bb?"WebkitUserSelect":null,Hc=function(a,b){b=b?null:a.getElementsByTagName("*");if(Gc){var c="none";a.style&&(a.style[Gc]=c);if(b){a=0;for(var d;d=b[a];a++)d.style&&(d.style[Gc]=c)}}else if(v||ab)if(c="on",a.setAttribute("unselectable",c),b)for(a=0;d=b[a];a++)d.setAttribute("unselectable",c)};var Ic=function(){};da(Ic);Ic.prototype.a=0;var K=function(a){I.call(this);this.j=a||xa||(xa=new ub);this.qa=Jc;this.Y=null;this.m=!1;this.a=null;this.A=void 0;this.g=this.c=this.b=null;this.Ga=!1};n(K,I);K.prototype.Oa=Ic.R();
var Jc=null,Kc=function(a,b){switch(a){case 1:return b?"disable":"enable";case 2:return b?"highlight":"unhighlight";case 4:return b?"activate":"deactivate";case 8:return b?"select":"unselect";case 16:return b?"check":"uncheck";case 32:return b?"focus":"blur";case 64:return b?"open":"close"}throw Error("Invalid component state");},Lc=function(a){return a.Y||(a.Y=":"+(a.Oa.a++).toString(36))},Mc=function(a,b){if(a.b&&a.b.g){var c=a.b.g,d=a.Y;d in c&&delete c[d];qa(a.b.g,b,a)}a.Y=b};K.prototype.f=function(){return this.a};
var Nc=function(a){a=a.a;q(a,"Can not call getElementStrict before rendering/decorating.");return a},Oc=function(a){a.A||(a.A=new oc(a));return q(a.A)};K.prototype.ra=function(a){if(this.b&&this.b!=a)throw Error("Method not supported");K.i.ra.call(this,a)};K.prototype.ia=function(){this.a=nb(this.j.a,"DIV")};
var Pc=function(a,b){if(a.m)throw Error("Component already rendered");if(b&&a.xa(b)){a.Ga=!0;var c=qb(b);a.j&&a.j.a==c||(a.j=b?new ub(qb(b)):xa||(xa=new ub));a.va(b);a.D()}else throw Error("Invalid element to decorate");};h=K.prototype;h.xa=function(){return!0};h.va=function(a){this.a=a};h.D=function(){this.m=!0;Qc(this,function(a){!a.m&&a.f()&&a.D()})};h.P=function(){Qc(this,function(a){a.m&&a.P()});this.A&&rc(this.A);this.m=!1};
h.u=function(){this.m&&this.P();this.A&&(this.A.N(),delete this.A);Qc(this,function(a){a.N()});!this.Ga&&this.a&&ob(this.a);this.b=this.a=this.g=this.c=null;K.i.u.call(this)};h.sa=function(a,b){this.ta(a,Rc(this),b)};
h.ta=function(a,b,c){q(!!a,"Provided element must not be null.");if(a.m&&(c||!this.m))throw Error("Component already rendered");if(0>b||b>Rc(this))throw Error("Child component index out of bounds");this.g&&this.c||(this.g={},this.c=[]);if(a.b==this){var d=Lc(a);this.g[d]=a;Ha(this.c,a)}else qa(this.g,Lc(a),a);if(a==this)throw Error("Unable to set parent component");if(d=this&&a.b&&a.Y){var e=a.b;d=a.Y;e.g&&d?(e=e.g,d=(null!==e&&d in e?e[d]:void 0)||null):d=null}if(d&&a.b!=this)throw Error("Unable to set parent component");
a.b=this;K.i.ra.call(a,this);La(this.c,b,0,a);if(a.m&&this.m&&a.b==this)c=this.ja(),b=c.childNodes[b]||null,b!=a.f()&&c.insertBefore(a.f(),b);else if(c){this.a||this.ia();c=L(this,b+1);b=this.ja();c=c?c.a:null;if(a.m)throw Error("Component already rendered");a.a||a.ia();b?b.insertBefore(a.a,c||null):a.j.a.body.appendChild(a.a);a.b&&!a.b.m||a.D()}else this.m&&!a.m&&a.a&&a.a.parentNode&&1==a.a.parentNode.nodeType&&a.D()};h.ja=function(){return this.a};
var Sc=function(a){if(null==a.qa){var b=a.m?a.a:a.j.a.body;a:{var c=qb(b);if(c.defaultView&&c.defaultView.getComputedStyle&&(c=c.defaultView.getComputedStyle(b,null))){c=c.direction||c.getPropertyValue("direction")||"";break a}c=""}a.qa="rtl"==(c||(b.currentStyle?b.currentStyle.direction:null)||b.style&&b.style.direction)}return a.qa},Rc=function(a){return a.c?a.c.length:0},L=function(a,b){return a.c?a.c[b]||null:null},Qc=function(a,b,c){a.c&&r(a.c,b,c)},Tc=function(a,b){return a.c&&b?Da(a.c,b):-1};var Vc=function(a,b){if(!a)throw Error("Invalid class name "+a);if(!ia(b))throw Error("Invalid decorator function "+b);Uc[a]=b},Wc={},Uc={};var Xc=function(a){this.h=a};da(Xc);var Yc=function(a,b){a&&(a.tabIndex=b?0:-1)},$c=function(a,b,c){c.id&&Mc(b,c.id);var d=a.b(),e=!1,f=D(c);f&&r(f,function(g){g==d?e=!0:g&&this.g(b,g,d)},a);e||Eb(c,d);Zc(b,c);return c};Xc.prototype.g=function(a,b,c){b==c+"-disabled"?a.Z(!1):b==c+"-horizontal"?ad(a,"horizontal"):b==c+"-vertical"&&ad(a,"vertical")};
var Zc=function(a,b){if(b)for(var c=b.firstChild,d;c&&c.parentNode==b;){d=c.nextSibling;if(1==c.nodeType){a:{var e=c;q(e);e=D(e);for(var f=0,g=e.length;f<g;f++){var k=e[f];if(k=k in Uc?Uc[k]():null){e=k;break a}}e=null}e&&(e.a=c,a.isEnabled()||e.Z(!1),a.sa(e),Pc(e,c))}else c.nodeValue&&""!=Ma(c.nodeValue)||b.removeChild(c);c=d}},bd=function(a,b){b=b.f();q(b,"The container DOM element cannot be null.");Hc(b,x);v&&(b.hideFocus=!0);(a=a.h)&&vb(b,a)};Xc.prototype.b=function(){return"goog-container"};
Xc.prototype.c=function(a){var b=this.b(),c=[b,"horizontal"==a.H?b+"-horizontal":b+"-vertical"];a.isEnabled()||c.push(b+"-disabled");return c};var M=function(){},cd;da(M);var dd={button:"pressed",checkbox:"checked",menuitem:"selected",menuitemcheckbox:"checked",menuitemradio:"checked",radio:"checked",tab:"selected",treeitem:"selected"};M.prototype.h=function(){};M.prototype.c=function(a){return a.j.b("DIV",ed(this,a).join(" "),a.ba)};var gd=function(a,b,c){if(a=a.f?a.f():a){var d=[b];v&&!A("7")&&(d=fd(D(a),b),d.push(b));(c?Fb:Hb)(a,d)}};
M.prototype.g=function(a,b){b.id&&Mc(a,b.id);b&&b.firstChild?hd(a,b.firstChild.nextSibling?Ja(b.childNodes):b.firstChild):a.ba=null;var c=0,d=this.a(),e=this.a(),f=!1,g=!1,k=!1,p=Ja(D(b));r(p,function(B){f||B!=d?g||B!=e?c|=id(this,B):g=!0:(f=!0,e==d&&(g=!0));1==id(this,B)&&(Aa(b),sb(b)&&tb(b)&&rb(b,!1))},this);a.o=c;f||(p.push(d),e==d&&(g=!0));g||p.push(e);(a=a.wa)&&p.push.apply(p,a);if(v&&!A("7")){var w=fd(p);0<w.length&&(p.push.apply(p,w),k=!0)}f&&g&&!a&&!k||Cb(b,p.join(" "));return b};
var jd=function(a,b){if(a=a.h()){q(b,"The element passed as a first parameter cannot be null.");var c=b.getAttribute("role")||null;a!=c&&vb(b,a)}},kd=function(a,b){var c;if(a.v&32&&(c=a.f())){if(!b&&a.o&32){try{c.blur()}catch(d){}a.o&32&&a.Fa(null)}(sb(c)&&tb(c))!=b&&rb(c,b)}},ld=function(a,b,c){cd||(cd={1:"disabled",8:"selected",16:"checked",64:"expanded"});q(a,"The element passed as a first parameter cannot be null.");b=cd[b];var d=a.getAttribute("role")||null;d&&(d=dd[d]||b,b="checked"==b||"selected"==
b?d:b);b&&xb(a,b,c)};M.prototype.a=function(){return"goog-control"};
var ed=function(a,b){var c=a.a(),d=[c],e=a.a();e!=c&&d.push(e);c=b.o;for(e=[];c;){var f=c&-c;e.push(md(a,f));c&=~f}d.push.apply(d,e);(a=b.wa)&&d.push.apply(d,a);v&&!A("7")&&d.push.apply(d,fd(d));return d},fd=function(a,b){var c=[];b&&(a=Ia(a,[b]));r([],function(d){!Fa(d,la(Ga,a))||b&&!Ga(d,b)||c.push(d.join("_"))});return c},md=function(a,b){a.b||nd(a);return a.b[b]},id=function(a,b){a.j||(a.b||nd(a),a.j=sa(a.b));a=parseInt(a.j[b],10);return isNaN(a)?0:a},nd=function(a){var b=a.a(),c=!t(b.replace(/\xa0|\s/g,
" ")," ");q(c,"ControlRenderer has an invalid css class: '"+b+"'");a.b={1:b+"-disabled",2:b+"-hover",4:b+"-active",8:b+"-selected",16:b+"-checked",32:b+"-focused",64:b+"-open"}};var N=function(a,b,c){K.call(this,c);if(!b){b=this.constructor;for(var d;b;){d=b[ja]||(b[ja]=++ka);if(d=Wc[d])break;b=b.i?b.i.constructor:null}b=d?ia(d.R)?d.R():new d:null}this.B=b;this.ba=void 0!==a?a:null};n(N,K);h=N.prototype;h.ba=null;h.o=0;h.v=39;h.K=0;h.Ia=!0;h.wa=null;h.ya=!0;h.ia=function(){var a=this.B.c(this);this.a=a;jd(this.B,a);Hc(a,!v&&!ab);this.isVisible()||(a.style.display="none",a&&xb(a,"hidden",!0))};h.ja=function(){return this.f()};h.xa=function(){return!0};
h.va=function(a){this.a=a=this.B.g(this,a);jd(this.B,a);Hc(a,!v&&!ab);this.Ia="none"!=a.style.display};
h.D=function(){N.i.D.call(this);var a=Nc(this);q(this);q(a);this.isVisible()||xb(a,"hidden",!this.isVisible());this.isEnabled()||ld(a,1,!this.isEnabled());this.v&8&&ld(a,8,!!(this.o&8));this.v&16&&ld(a,16,!!(this.o&16));this.v&64&&ld(a,64,!!(this.o&64));a=this.B;Sc(this)&&gd(this.f(),a.a()+"-rtl",!0);this.isEnabled()&&kd(this,this.isVisible());if(this.v&-2&&(this.ya&&od(this,!0),this.v&32&&(a=this.f()))){var b=this.W||(this.W=new J);zc(b,a);H(H(H(Oc(this),b,"key",this.fa),a,"focus",this.Na),a,"blur",
this.Fa)}};var od=function(a,b){var c=Oc(a),d=a.f();b?(H(H(H(H(c,d,F.L,a.ka),d,[F.M,F.aa],a.la),d,"mouseover",a.Aa),d,"mouseout",a.za),a.ea!=ca&&H(c,d,"contextmenu",a.ea),v&&(A(9)||H(c,d,"dblclick",a.Ja),a.ga||(a.ga=new pd(a),zb(a,la(Ab,a.ga))))):(qc(qc(qc(qc(c,d,F.L,a.ka),d,[F.M,F.aa],a.la),d,"mouseover",a.Aa),d,"mouseout",a.za),a.ea!=ca&&qc(c,d,"contextmenu",a.ea),v&&(A(9)||qc(c,d,"dblclick",a.Ja),Ab(a.ga),a.ga=null))};
N.prototype.P=function(){N.i.P.call(this);this.W&&Fc(this.W);this.isVisible()&&this.isEnabled()&&kd(this,!1)};N.prototype.u=function(){N.i.u.call(this);this.W&&(this.W.N(),delete this.W);delete this.B;this.ga=this.wa=this.ba=null};var hd=function(a,b){a.ba=b};N.prototype.isVisible=function(){return this.Ia};N.prototype.isEnabled=function(){return!(this.o&1)};
N.prototype.Z=function(a){var b=this.b;b&&"function"==typeof b.isEnabled&&!b.isEnabled()||!O(this,1,!a)||(a||(qd(this,!1),P(this,!1)),this.isVisible()&&kd(this,a),Q(this,1,!a,!0))};
var P=function(a,b){O(a,2,b)&&Q(a,2,b)},qd=function(a,b){O(a,4,b)&&Q(a,4,b)},rd=function(a,b){O(a,8,b)&&Q(a,8,b)},sd=function(a,b){O(a,64,b)&&Q(a,64,b)},Q=function(a,b,c,d){if(!d&&1==b)a.Z(!c);else if(a.v&b&&c!=!!(a.o&b)){var e=a.B;if(d=a.f())(e=md(e,b))&&gd(a,e,c),ld(d,b,c);a.o=c?a.o|b:a.o&~b}},td=function(a,b,c){if(a.m&&a.o&b&&!c)throw Error("Component already rendered");!c&&a.o&b&&Q(a,b,!1);a.v=c?a.v|b:a.v&~b},R=function(a,b){return!!(255&b)&&!!(a.v&b)},O=function(a,b,c){return!!(a.v&b)&&!!(a.o&
b)!=c&&(!(a.K&b)||uc(a,Kc(b,c)))&&!a.U};h=N.prototype;h.Aa=function(a){(!a.relatedTarget||!pb(this.f(),a.relatedTarget))&&uc(this,"enter")&&this.isEnabled()&&R(this,2)&&P(this,!0)};h.za=function(a){a.relatedTarget&&pb(this.f(),a.relatedTarget)||!uc(this,"leave")||(R(this,4)&&qd(this,!1),R(this,2)&&P(this,!1))};h.ea=ca;
h.ka=function(a){if(this.isEnabled()&&(R(this,2)&&P(this,!0),Ob(a)&&!(y&&z&&a.ctrlKey))){R(this,4)&&qd(this,!0);var b;if(b=this.B){var c;b=this.v&32&&(c=this.f())?sb(c)&&tb(c):!1}b&&this.f().focus()}!Ob(a)||y&&z&&a.ctrlKey||a.g()};h.la=function(a){this.isEnabled()&&(R(this,2)&&P(this,!0),this.o&4&&ud(this,a)&&R(this,4)&&qd(this,!1))};h.Ja=function(a){this.isEnabled()&&ud(this,a)};
var ud=function(a,b){if(R(a,16)){var c=!(a.o&16);O(a,16,c)&&Q(a,16,c)}R(a,8)&&rd(a,!0);R(a,64)&&sd(a,!(a.o&64));c=new E("action",a);b&&(c.altKey=b.altKey,c.ctrlKey=b.ctrlKey,c.metaKey=b.metaKey,c.shiftKey=b.shiftKey,c.A=b.A);return uc(a,c)};N.prototype.Na=function(){R(this,32)&&O(this,32,!0)&&Q(this,32,!0)};N.prototype.Fa=function(){R(this,4)&&qd(this,!1);R(this,32)&&O(this,32,!1)&&Q(this,32,!1)};
N.prototype.fa=function(a){return this.isVisible()&&this.isEnabled()&&13==a.c&&ud(this,a)?(a.g(),a.j(),!0):!1};if(!ia(N))throw Error("Invalid component class "+N);if(!ia(M))throw Error("Invalid renderer class "+M);var vd=N[ja]||(N[ja]=++ka);Wc[vd]=M;Vc("goog-control",function(){return new N(null)});var pd=function(a){C.call(this);this.b=a;this.a=!1;this.c=new oc(this);zb(this,la(Ab,this.c));a=Nc(this.b);H(H(H(this.c,a,F.L,this.h),a,F.M,this.j),a,"click",this.g)};n(pd,C);var wd=!v||9<=Number(ib);
pd.prototype.h=function(){this.a=!1};pd.prototype.j=function(){this.a=!0};var xd=function(a,b){if(!wd)return a.button=0,a.type=b,a;var c=document.createEvent("MouseEvents");c.initMouseEvent(b,a.bubbles,a.cancelable,a.view||null,a.detail,a.screenX,a.screenY,a.clientX,a.clientY,a.ctrlKey,a.altKey,a.shiftKey,a.metaKey,0,a.relatedTarget||null);return c};
pd.prototype.g=function(a){if(this.a)this.a=!1;else{var b=a.b,c=b.button,d=b.type,e=xd(b,"mousedown");this.b.ka(new G(e,a.a));e=xd(b,"mouseup");this.b.la(new G(e,a.a));wd||(b.button=c,b.type=d)}};pd.prototype.u=function(){this.b=null;pd.i.u.call(this)};var S=function(a,b,c){K.call(this,c);this.da=b||Xc.R();this.H=a||"vertical"};n(S,K);h=S.prototype;h.Da=null;h.ca=null;h.da=null;h.H=null;h.T=!0;h.O=!0;h.l=-1;h.s=null;h.V=!1;h.I=null;var yd=function(a){return a.Da||a.f()};h=S.prototype;h.ia=function(){this.a=this.j.b("DIV",this.da.c(this).join(" "))};h.ja=function(){return this.f()};h.xa=function(a){return"DIV"==a.tagName};h.va=function(a){this.a=$c(this.da,this,a);"none"==a.style.display&&(this.T=!1)};
h.D=function(){S.i.D.call(this);Qc(this,function(b){b.m&&zd(this,b)},this);var a=this.f();bd(this.da,this);Ad(this,this.T);H(H(H(H(H(H(H(H(Oc(this),this,"enter",this.Wa),this,"highlight",this.Xa),this,"unhighlight",this.cb),this,"open",this.Ya),this,"close",this.Ua),a,F.L,this.Sa),qb(a),[F.M,F.aa],this.Va),a,[F.L,F.M,F.aa,"mouseover","mouseout","contextmenu"],this.Ta);Bd(this)};var Bd=function(a){var b=Oc(a),c=yd(a);H(H(H(b,c,"focus",a.Ha),c,"blur",a.Qa),a.ca||(a.ca=new J(yd(a))),"key",a.Ra)};h=S.prototype;
h.P=function(){Cd(this,-1);this.s&&sd(this.s,!1);this.V=!1;S.i.P.call(this)};h.u=function(){S.i.u.call(this);this.ca&&(this.ca.N(),this.ca=null);this.da=this.s=this.I=this.Da=null};h.Wa=function(){return!0};
h.Xa=function(a){var b=Tc(this,a.target);if(-1<b&&b!=this.l){var c=L(this,this.l);c&&P(c,!1);this.l=b;c=L(this,this.l);this.V&&qd(c,!0);this.s&&c!=this.s&&(c.v&64?sd(c,!0):sd(this.s,!1))}b=this.f();q(b,"The DOM element for the container cannot be null.");null!=a.target.f()&&xb(b,"activedescendant",a.target.f().id)};h.cb=function(a){a.target==L(this,this.l)&&(this.l=-1);a=this.f();q(a,"The DOM element for the container cannot be null.");a.removeAttribute(wb("activedescendant"))};
h.Ya=function(a){(a=a.target)&&a!=this.s&&a.b==this&&(this.s&&sd(this.s,!1),this.s=a)};h.Ua=function(a){a.target==this.s&&(this.s=null);var b=this.f(),c=a.target.f();b&&a.target.o&2&&c&&(a="",c&&(a=c.id,q(a,"The active element should have an id.")),xb(b,"activedescendant",a))};h.Sa=function(a){this.O&&(this.V=!0);var b=yd(this);b&&sb(b)&&tb(b)?b.focus():a.g()};h.Va=function(){this.V=!1};
h.Ta=function(a){a:{var b=a.target;if(this.I)for(var c=this.f();b&&b!==c;){var d=b.id;if(d in this.I){b=this.I[d];break a}b=b.parentNode}b=null}if(b)switch(a.type){case F.L:b.ka(a);break;case F.M:case F.aa:b.la(a);break;case "mouseover":b.Aa(a);break;case "mouseout":b.za(a);break;case "contextmenu":b.ea(a)}};h.Ha=function(){};h.Qa=function(){Cd(this,-1);this.V=!1;this.s&&sd(this.s,!1)};
h.Ra=function(a){return this.isEnabled()&&this.isVisible()&&(0!=Rc(this)||this.Da)&&Dd(this,a)?(a.g(),a.j(),!0):!1};
var Dd=function(a,b){var c=L(a,a.l);if(c&&"function"==typeof c.fa&&c.fa(b)||a.s&&a.s!=c&&"function"==typeof a.s.fa&&a.s.fa(b))return!0;if(b.shiftKey||b.ctrlKey||b.metaKey||b.altKey)return!1;switch(b.c){case 27:yd(a).blur();break;case 36:Ed(a);break;case 35:Fd(a);break;case 38:if("vertical"==a.H)Gd(a);else return!1;break;case 37:if("horizontal"==a.H)Sc(a)?Hd(a):Gd(a);else return!1;break;case 40:if("vertical"==a.H)Hd(a);else return!1;break;case 39:if("horizontal"==a.H)Sc(a)?Gd(a):Hd(a);else return!1;
break;default:return!1}return!0},zd=function(a,b){var c=b.f();c=c.id||(c.id=Lc(b));a.I||(a.I={});a.I[c]=b};S.prototype.sa=function(a,b){Ca(a,N,"The child of a container must be a control");S.i.sa.call(this,a,b)};S.prototype.ta=function(a,b,c){Ca(a,N);a.K|=2;a.K|=64;td(a,32,!1);a.m&&0!=a.ya&&od(a,!1);a.ya=!1;var d=a.b==this?Tc(this,a):-1;S.i.ta.call(this,a,b,c);a.m&&this.m&&zd(this,a);a=d;-1==a&&(a=Rc(this));a==this.l?this.l=Math.min(Rc(this)-1,b):a>this.l&&b<=this.l?this.l++:a<this.l&&b>this.l&&this.l--};
var ad=function(a,b){if(a.f())throw Error("Component already rendered");a.H=b};S.prototype.isVisible=function(){return this.T};var Ad=function(a,b){a.T=b;var c=a.f();c&&(c.style.display=b?"":"none",Yc(yd(a),a.O&&a.T))};S.prototype.isEnabled=function(){return this.O};S.prototype.Z=function(a){this.O!=a&&uc(this,a?"enable":"disable")&&(a?(this.O=!0,Qc(this,function(b){b.La?delete b.La:b.Z(!0)})):(Qc(this,function(b){b.isEnabled()?b.Z(!1):b.La=!0}),this.V=this.O=!1),Yc(yd(this),a&&this.T))};
var Cd=function(a,b){(b=L(a,b))?P(b,!0):-1<a.l&&P(L(a,a.l),!1)},Ed=function(a){Id(a,function(b,c){return(b+1)%c},Rc(a)-1)},Fd=function(a){Id(a,function(b,c){b--;return 0>b?c-1:b},0)},Hd=function(a){Id(a,function(b,c){return(b+1)%c},a.l)},Gd=function(a){Id(a,function(b,c){b--;return 0>b?c-1:b},a.l)},Id=function(a,b,c){c=0>c?Tc(a,a.s):c;var d=Rc(a);c=b.call(a,c,d);for(var e=0;e<=d;){var f=L(a,c),g;if(g=f)g=f.isVisible()&&f.isEnabled()&&!!(f.v&2);if(g){a.Ea(c);break}e++;c=b.call(a,c,d)}};
S.prototype.Ea=function(a){Cd(this,a)};var T=function(){};n(T,M);da(T);T.prototype.a=function(){return"goog-tab"};T.prototype.h=function(){return"tab"};T.prototype.c=function(a){var b=T.i.c.call(this,a);(a=a.Pa)&&b&&(b.title=a||"");return b};T.prototype.g=function(a,b){b=T.i.g.call(this,a,b);var c=b.title||"";c&&(a.Pa=c);a.o&8&&(c=a.b)&&ia(c.G)&&(Q(a,8,!1),c.G(a));return b};var Jd=function(a,b,c){N.call(this,a,b||T.R(),c);td(this,8,!0);this.K|=9};n(Jd,N);Vc("goog-tab",function(){return new Jd(null)});var U=function(){this.h="tablist"};n(U,Xc);da(U);U.prototype.b=function(){return"goog-tab-bar"};U.prototype.g=function(a,b,c){this.j||(this.a||Kd(this),this.j=sa(this.a));var d=this.j[b];d?(ad(a,Ld(d)),a.B=d):U.i.g.call(this,a,b,c)};U.prototype.c=function(a){var b=U.i.c.call(this,a);this.a||Kd(this);b.push(this.a[a.B]);return b};var Kd=function(a){var b=a.b();a.a={top:b+"-top",bottom:b+"-bottom",start:b+"-start",end:b+"-end"}};var V=function(a,b,c){a=a||"top";ad(this,Ld(a));this.B=a;S.call(this,this.H,b||U.R(),c);Md(this)};n(V,S);h=V.prototype;h.C=null;h.D=function(){V.i.D.call(this);Md(this)};h.u=function(){V.i.u.call(this);this.C=null};h.Ea=function(a){V.i.Ea.call(this,a);this.G(L(this,a))};h.G=function(a){a?rd(a,!0):this.C&&rd(this.C,!1)};
var Nd=function(a,b){if(b&&b==a.C){for(var c=Tc(a,b),d=c-1;b=L(a,d);d--){var e=b;if(e.isVisible()&&e.isEnabled()){a.G(b);return}}for(c+=1;b=L(a,c);c++)if(d=b,d.isVisible()&&d.isEnabled()){a.G(b);return}a.G(null)}};h=V.prototype;h.ab=function(a){this.C&&this.C!=a.target&&rd(this.C,!1);this.C=a.target};h.bb=function(a){a.target==this.C&&(this.C=null)};h.Za=function(a){Nd(this,a.target)};h.$a=function(a){Nd(this,a.target)};h.Ha=function(){L(this,this.l)||Cd(this,Tc(this,this.C||L(this,0)))};
var Md=function(a){H(H(H(H(Oc(a),a,"select",a.ab),a,"unselect",a.bb),a,"disable",a.Za),a,"hide",a.$a)},Ld=function(a){return"start"==a||"end"==a?"vertical":"horizontal"};Vc("goog-tab-bar",function(){return new V});function Od(a){var b={top:"bottom",bottom:"top",start:"right",end:"left"}[a.location],c=a.elementId,d=document.createElement("style");d.textContent="\n    fieldset {\n      padding: 10px;\n      border: 1px solid #369;\n    }\n\n    #"+c+" .goog-tab-content {\n      min-height: 3em;\n      margin: 0;\n      border: "+a.border+" solid "+a.borderColor+";\n      border-top: 0;\n      height: "+a.contentHeight+";\n      padding: 4px 8px;\n      margin-right: 4px;\n      background: var(--colab-primary-surface-color);\n      overflow: auto;\n    }\n\n    #"+
c+" .goog-tab-bar-"+a.location+" .goog-tab-selected {\n      background-color: var(--colab-primary-surface-color);\n      border: 1px solid "+a.borderColor+";\n      border-"+b+": 0px;\n    }\n\n    #"+c+" .goog-tab-bar-"+a.location+" {\n      padding-"+a.location+": 5px !important;\n      border-"+b+": 1px solid "+a.borderColor+" !important;\n      background: var(--colab-primary-surface-color);\n    }\n\n    #"+c+" .goog-tab-bar {\n       margin: 0;\n       border: 0;\n       padding: 0;\n       list-style: none;\n       cursor: default;\n       outline: none;\n       background: var(--colab-primary-surface-color);\n       margin-right: 4px;\n      }\n\n     #"+
c+" .goog-tab {\n       position: relative;\n       padding: 4px 8px;\n       color: var(--colab-primary-text-color);\n       text-decoration: initial;\n       cursor: default;\n      }\n\n      #"+c+" .goog-tab-hover {\n        background-color: var(--colab-highlighted-surface-color);\n      }\n      ";return d}
var Pd=function(a){var b=a.elementId,c=a.tabNames,d=a.selectedIndex;"contentBorder"in a||(a.contentBorder="0px");"contentHeight"in a||(a.contentHeight="initial");"borderColor"in a||(a.borderColor="var(--colab-border-color)");a.location||(a.location="top");var e=document.querySelector("#"+b),f=document.createElement("div");f.classList.add("goog-tab-bar");var g=a.location;f.classList.add("goog-tab-bar-"+g);for(var k=[],p=ba(c),w=p.next();!w.done;w=p.next()){w=w.value;var B=document.createElement("div");
B.classList.add("goog-tab");B.textContent=w;f.appendChild(B);k.push(B)}"bottom"!=g&&e.appendChild(f);p=null;if("top"==g||"bottom"==g)p=document.createElement("div"),p.classList.add("goog-tab-bar-clear");"top"==g&&p&&e.appendChild(p);B=document.createElement("div");B.classList.add("goog-tab-content");var ra=[];c=ba(c);for(w=c.next();!w.done;w=c.next())w=document.createElement("div"),w.id=e.id+"_content_"+ra.length,w.style.display="none",B.appendChild(w),ra.push(w);e.appendChild(B);"bottom"==g&&(p&&
e.appendChild(p),e.appendChild(f));var X=new V(g);Pc(X,f);var Y=-1;dc(X,"select",function(Z){Z=k.indexOf(Z.target.f());Z!=Y&&(0<=Y&&Y<ra.length&&(ra[Y].style.display="none",Y=-1),0<=Z&&Z<ra.length&&(Y=Z,ra[Y].style.display="inline",window.dispatchEvent(new Event("resize")),google.colab.output.resizeIframeToContent()),X.G(L(X,Y)))});X.G(L(X,d));window[b]={setSelectedTabIndex:function(Z){X.G(L(X,Z))}};document.head.appendChild(Od(a))},Qd=["colab_lib","createTabBar"],W=l;
Qd[0]in W||"undefined"==typeof W.execScript||W.execScript("var "+Qd[0]);for(var Rd;Qd.length&&(Rd=Qd.shift());)Qd.length||void 0===Pd?W[Rd]&&W[Rd]!==Object.prototype[Rd]?W=W[Rd]:W=W[Rd]={}:W[Rd]=Pd;}).call(this);
// clang-format on
",
       "headers": [
        [
         "content-type",
         "application/javascript"
        ]
       ],
       "ok": true,
       "status": 200,
       "status_text": ""
      }
     }
    },
    "executionInfo": {
     "elapsed": 3871,
     "status": "ok",
     "timestamp": 1710972497744,
     "user": {
      "displayName": "Gary Deschaines",
      "userId": "00818646848844190559"
     },
     "user_tz": 300
    },
    "id": "bgXgw1_Ghtt4",
    "jupyter": {
     "source_hidden": true
    },
    "outputId": "cc7c467e-8cfb-4833-aea0-51be7a1f1f63"
   },
   "outputs": [],
   "source": [
    "    if PLOT_DATA:\n",
    "\n",
    "        # Create and show the plot figures.\n",
    "        figures = []\n",
    "        if RUN_WITH_COLAB:\n",
    "            print(\"\\n\")\n",
    "\n",
    "        # Create tab widget to display inline plot\n",
    "        # figures for Matplotlib NbAgg backend.\n",
    "        if (Backend == 'nbAgg') and (widgets is not None):\n",
    "            fig_tabs = []\n",
    "            for ifig in PLOT_FIGS.keys():\n",
    "                if PLOT_FIGS[ifig]:\n",
    "                    fig_tabs.append(\"Fig-\" + str(ifig))\n",
    "\n",
    "            if len(fig_tabs) > 0:\n",
    "                if RUN_WITH_COLAB:\n",
    "                    TABS = widgets.TabBar(fig_tabs)\n",
    "                else:\n",
    "                    children = []\n",
    "                    tab_child = {}\n",
    "                    for ichild in range(len(fig_tabs)):\n",
    "                        tab_child[fig_tabs[ichild]] = ichild\n",
    "                        children.append(widgets.Output(layout={'border': '1px solid black'}))\n",
    "                    TABS = widgets.Tab()\n",
    "                    TABS.children = children\n",
    "                    TABS.titles = [fig_tabs[i] for i in range(len(children))]\n",
    "                    TABS.selection_index = 0\n",
    "            else:\n",
    "                TABS = None\n",
    "        else:\n",
    "            TABS = None\n",
    "\n",
    "        if TABS is not None:\n",
    "            if not PRINT_TXYZ:\n",
    "                print(\"\\n\")\n",
    "\n",
    "        if PLOT_FIGS[1]:\n",
    "\n",
    "            def plotFig01(figures):\n",
    "                ## Figure 1 - Closing distance at tStop.\n",
    "                figures.append(plt.figure(1, figsize=(6,3), dpi=80))\n",
    "                text = \"Closing distance ({0}, N={1}, At={2})\"\\\n",
    "                     .format(PN_LAWS[PNAV], int(Nm), int(Nt))\n",
    "                plt.title(text)\n",
    "                plt.xlabel('Time (sec)')\n",
    "                plt.ylabel('Distance (meters)')\n",
    "                plt.xlim([Time[istop-3], Time[istop]])\n",
    "                plt.ylim([-1.0, Dcls[istop-3]])\n",
    "                plt.grid()\n",
    "                plt.plot(Time[istop-3:iend], Dcls[istop-3:iend], 'o:k')\n",
    "                plt.plot(np.array([Time[istop-3], Time[istop]]),\n",
    "                         np.array([MinMissDist, MinMissDist]), '-c')\n",
    "                if INTERCEPT:\n",
    "                    plt.plot(Time[istop], Dcls[istop], 'X:m')\n",
    "                    plt.legend(['Distance','MinMissDist','Intercept'])\n",
    "                else:\n",
    "                    plt.plot(Time[istop], Dcls[istop], 'o:c')\n",
    "                    plt.legend(['Distance','MinMissDist','Missed'])\n",
    "                return figures\n",
    "\n",
    "            if TABS is None:\n",
    "                figures = plotFig01(figures)\n",
    "            elif RUN_WITH_COLAB:\n",
    "                with TABS.output_to(\"Fig-1\", select=SAVE_ANIM):\n",
    "                    figures = plotFig01(figures)\n",
    "                    plt.show(block=False)\n",
    "            else:\n",
    "                with TABS.children[tab_child['Fig-1']]:\n",
    "                    figures = plotFig01(figures)\n",
    "                    plt.show(block=False)\n",
    "\n",
    "        if PLOT_FIGS[2]:\n",
    "\n",
    "            def plotFig02(figures):\n",
    "                ## Figure 2 - XY plan view of intercept geometry at tStop.\n",
    "                figures.append(plt.figure(2, figsize=(6,6), dpi=80))\n",
    "                text = \"XY plan view of intercept ({0}, N={1}, At={2})\"\\\n",
    "                    .format(PN_LAWS[PNAV], int(Nm), int(Nt))\n",
    "                plt.title(text)\n",
    "                plt.xlabel('X (meters)')\n",
    "                plt.ylabel('y (meters)')\n",
    "                if MSL == SAM:\n",
    "                    plt.xlim([(Pmx[istop]+Ptx[istop])/2-max(10.0, Dcls[istop]),\n",
    "                              (Pmx[istop]+Ptx[istop])/2+max(10.0, Dcls[istop])/2.0])\n",
    "                    plt.ylim([(Pmy[istop]+Pty[istop])/2-max(10.0, Dcls[istop]),\n",
    "                              (Pmy[istop]+Pty[istop])/2+max(10.0, Dcls[istop])/2.0])\n",
    "                else:\n",
    "                    plt.xlim([(Pmx[istop]+Ptx[istop])/2-max(20.0, Dcls[istop]),\n",
    "                              (Pmx[istop]+Ptx[istop])/2+max(20.0, Dcls[istop])/2.0])\n",
    "                    plt.ylim([(Pmy[istop]+Pty[istop])/2-max(20.0, Dcls[istop]),\n",
    "                              (Pmy[istop]+Pty[istop])/2+max(20.0, Dcls[istop])/2.0])\n",
    "                plt.grid()\n",
    "                plt.plot(Ptx[istop-3:iend], Pty[istop-3:iend], 's:r',\n",
    "                         Pmx[istop-3:iend], Pmy[istop-3:iend], 'x:b',\n",
    "                         np.array([Pmx[istop-3],Ptx[istop-3]]),\n",
    "                         np.array([Pmy[istop-3],Pty[istop-3]]), '.:k',\n",
    "                         np.array([Pmx[istop-2],Ptx[istop-2]]),\n",
    "                         np.array([Pmy[istop-2],Pty[istop-2]]), '.:k',\n",
    "                         np.array([Pmx[istop-1],Ptx[istop-1]]),\n",
    "                         np.array([Pmy[istop-1],Pty[istop-1]]), '.:k')\n",
    "                if INTERCEPT:\n",
    "                    plt.plot(np.array([Pmx[istop],Ptx[istop]]),\n",
    "                             np.array([Pmy[istop],Pty[istop]]), '.:m')\n",
    "                    plt.legend(('Target','Missile','LOS',' ',' ','Intercept'), loc='upper left')\n",
    "                else:\n",
    "                    plt.plot(np.array([Pmx[istop],Ptx[istop]]),\n",
    "                             np.array([Pmy[istop],Pty[istop]]), '.:c')\n",
    "                    plt.legend(('Target','Missile','LOS',' ', ' ','Missed'), loc='upper left')\n",
    "                return figures\n",
    "\n",
    "            if TABS is None:\n",
    "                figures = plotFig02(figures)\n",
    "            elif RUN_WITH_COLAB:\n",
    "                with TABS.output_to(\"Fig-2\", select=False):\n",
    "                    figures = plotFig02(figures)\n",
    "                    plt.show(block=False)\n",
    "            else:\n",
    "                with TABS.children[tab_child['Fig-2']]:\n",
    "                    figures = plotFig02(figures)\n",
    "                    plt.show(block=False)\n",
    "\n",
    "        if PLOT_FIGS[3]:\n",
    "\n",
    "            def plotFig03(figures):\n",
    "                ## Figure 3 - XZ profile view of intercept geometry at tStop.\n",
    "                figures.append(plt.figure(3, figsize=(6,3), dpi=80))\n",
    "                text = \"XZ profile view of intercept ({0}, N={1}, At={2})\"\\\n",
    "                    .format(PN_LAWS[PNAV], int(Nm), int(Nt))\n",
    "                plt.title(text)\n",
    "                plt.xlabel('X (meters)')\n",
    "                plt.ylabel('Z (meters)')\n",
    "                if MSL == SAM:\n",
    "                    plt.xlim([(Pmx[istop]+Ptx[istop])/2-max(10.0, Dcls[istop]),\n",
    "                              (Pmx[istop]+Ptx[istop])/2+max(10.0, Dcls[istop])/2.0])\n",
    "                    plt.ylim([(Pmz[istop]+Ptz[istop])/2-max(10.0, Dcls[istop])/2.0,\n",
    "                              (Pmz[istop]+Ptz[istop])/2+max(10.0, Dcls[istop])/4.0])\n",
    "                else:\n",
    "                    plt.xlim([(Pmx[istop]+Ptx[istop])/2-max(20.0, Dcls[istop]),\n",
    "                              (Pmx[istop]+Ptx[istop])/2+max(20.0, Dcls[istop])/2.0])\n",
    "                    plt.ylim([(Pmz[istop]+Ptz[istop])/2-max(20.0, Dcls[istop])/2.0,\n",
    "                              (Pmz[istop]+Ptz[istop])/2+max(20.0, Dcls[istop])/4.0])\n",
    "                plt.grid()\n",
    "                plt.plot(Ptx[istop-3:iend], Ptz[istop-3:iend], 's:r',\n",
    "                         Pmx[istop-3:iend], Pmz[istop-3:iend], 'x:b',\n",
    "                         np.array([Pmx[istop-3],Ptx[istop-3]]),\n",
    "                         np.array([Pmz[istop-3],Ptz[istop-3]]), '.:k',\n",
    "                         np.array([Pmx[istop-2],Ptx[istop-2]]),\n",
    "                         np.array([Pmz[istop-2],Ptz[istop-2]]), '.:k',\n",
    "                         np.array([Pmx[istop-1],Ptx[istop-1]]),\n",
    "                         np.array([Pmz[istop-1],Ptz[istop-1]]), '.:k')\n",
    "                if INTERCEPT:\n",
    "                    plt.plot(np.array([Pmx[istop],Ptx[istop]]),\n",
    "                             np.array([Pmz[istop],Ptz[istop]]), '.:m')\n",
    "                    plt.legend(('Target','Missile','LOS',' ',' ','Intercept'), loc='upper left')\n",
    "                else:\n",
    "                    plt.plot(np.array([Pmx[istop],Ptx[istop]]),\n",
    "                             np.array([Pmz[istop],Ptz[istop]]), '.:c')\n",
    "                    plt.legend(('Target','Missile','LOS',' ',' ','Missed'), loc='upper left')\n",
    "                return figures\n",
    "\n",
    "            if TABS is None:\n",
    "                figures = plotFig03(figures)\n",
    "            elif RUN_WITH_COLAB:\n",
    "                with TABS.output_to(\"Fig-3\", select=False):\n",
    "                    figures = plotFig03(figures)\n",
    "                    plt.show(block=False)\n",
    "            else:\n",
    "                with TABS.children[tab_child['Fig-3']]:\n",
    "                    figures = plotFig03(figures)\n",
    "                    plt.show(block=False)\n",
    "\n",
    "        if PLOT_FIGS[4]:\n",
    "\n",
    "            def plotFig04(figures):\n",
    "                ## Figure 4 - XY plan view of missile/target engagement.\n",
    "                figures.append(plt.figure(4, figsize=(6,6), dpi=80))\n",
    "                text = \"XY plan view of missile/target engagement ({0}, N={1}, At={2})\"\\\n",
    "                    .format(PN_LAWS[PNAV], int(Nm), int(Nt))\n",
    "                plt.title(text)\n",
    "                plt.xlabel('X (meters)')\n",
    "                plt.ylabel('Y (meters)')\n",
    "                plt.xlim([Pm0[0], Pt0[0]+500.0])\n",
    "                if MSL == SAM:\n",
    "                    plt.ylim([Pm0[1], Pm0[1]+(Pt0[0]+500-Pm0[0])])\n",
    "                else:\n",
    "                    plt.ylim([Pm0[1]-Pm0[1]/2.0, Pm0[1]+Pm0[1]/2])\n",
    "                plt.grid()\n",
    "                plt.plot(Ptx[0:iend], Pty[0:iend], '-r',\n",
    "                         Pmx[0:iend], Pmy[0:iend], '-b')\n",
    "                if INTERCEPT:\n",
    "                    plt.plot(Pmx[istop:iend], Pmy[istop:iend], 'xm')\n",
    "                    plt.legend(('Target','Missile','Intercept'), loc='upper left')\n",
    "                else:\n",
    "                    plt.plot(np.array([Pmx[istop],Ptx[istop]]),\n",
    "                             np.array([Pmy[istop],Pty[istop]]), 'oc')\n",
    "                    plt.legend(('Target','Missile','Missed'), loc='upper left')\n",
    "                return figures\n",
    "\n",
    "            if TABS is None:\n",
    "                figures = plotFig04(figures)\n",
    "            elif RUN_WITH_COLAB:\n",
    "                with TABS.output_to(\"Fig-4\", select=False):\n",
    "                    figures = plotFig04(figures)\n",
    "                    plt.show(block=False)\n",
    "            else:\n",
    "                with TABS.children[tab_child['Fig-4']]:\n",
    "                    figures = plotFig04(figures)\n",
    "                    plt.show(block=False)\n",
    "\n",
    "        if PLOT_FIGS[5]:\n",
    "\n",
    "            def plotFig05(figures):\n",
    "                ## Figure 5 - XZ profile view of missile/target engagement.\n",
    "                figures.append(plt.figure(5, figsize=(6,3), dpi=80))\n",
    "                text = \"XZ profile view of missile/target engagement ({0}, N={1}, At={2})\"\\\n",
    "                    .format(PN_LAWS[PNAV], int(Nm), int(Nt))\n",
    "                plt.title(text)\n",
    "                plt.xlabel('X (meters)')\n",
    "                plt.ylabel('Z (meters)')\n",
    "                plt.xlim([Pm0[0], Pt0[0]+500.0])\n",
    "                if MSL == SAM:\n",
    "                    plt.ylim([0.0, (Pt0[0]+500-Pm0[0])/2])\n",
    "                else:\n",
    "                    plt.ylim([floor(min(Pmz[0:istop])/1000.0)*1000.0 - 1000.0,\n",
    "                              floor(min(Pmz[0:istop])/1000.0)*1000.0 +\n",
    "                              (Pt0[0]-Pm0[0])/2 - 1000.0])\n",
    "                plt.grid()\n",
    "                plt.plot(Ptx[0:iend], Ptz[0:iend], '-r',\n",
    "                         Pmx[0:iend], Pmz[0:iend], '-b')\n",
    "                if INTERCEPT:\n",
    "                    plt.plot(Pmx[istop:iend], Pmz[istop:iend], 'xm')\n",
    "                    plt.legend(('Target','Missile','Intercept'), loc='upper left')\n",
    "                else:\n",
    "                    plt.plot(np.array([Pmx[istop],Ptx[istop]]),\n",
    "                             np.array([Pmz[istop],Ptz[istop]]), 'oc')\n",
    "                    plt.legend(('Target','Missile','Missed'), loc='upper left')\n",
    "                return figures\n",
    "\n",
    "            if TABS is None:\n",
    "                figures = plotFig05(figures)\n",
    "            elif RUN_WITH_COLAB:\n",
    "                with TABS.output_to(\"Fig-5\", select=False):\n",
    "                    figures = plotFig05(figures)\n",
    "                    plt.show(block=False)\n",
    "            else:\n",
    "                with TABS.children[tab_child['Fig-5']]:\n",
    "                    figures = plotFig05(figures)\n",
    "                    plt.show(block=False)\n",
    "\n",
    "        if PLOT_FIGS[6]:\n",
    "\n",
    "            def plotFig06(figures):\n",
    "                ## Figure 6 - Msl/Tgt velocity magnitude vs time of flight\n",
    "                ##            up to point just before flight termination.\n",
    "                ##                Note: This is a constant velocity missile.\n",
    "                figures.append(plt.figure(6, figsize=(6,3), dpi=80))\n",
    "                text = \"Msl/Tgt velocity magnitude profiles ({0}, N={1}, At={2})\"\\\n",
    "                    .format(PN_LAWS[PNAV], int(Nm), int(Nt))\n",
    "                plt.title(text)\n",
    "                plt.xlabel('Time (sec)')\n",
    "                plt.ylabel('Velocity (meters/sec)')\n",
    "                plt.xlim([0.0, T_STOP])\n",
    "                plt.ylim([Velt[0]-10, ceil(max(Velm[0:istop]))+10])\n",
    "                plt.grid()\n",
    "                plt.plot(Time[0:istop], Velm[0:istop], '-b')\n",
    "                plt.plot(Time[0:istop], Velt[0:istop], '-r')\n",
    "                plt.legend(('Missile','Target'), loc='center right')\n",
    "                return figures\n",
    "\n",
    "            if TABS is None:\n",
    "                figures = plotFig06(figures)\n",
    "            elif RUN_WITH_COLAB:\n",
    "                with TABS.output_to(\"Fig-6\", select=False):\n",
    "                    figures = plotFig06(figures)\n",
    "                    plt.show(block=False)\n",
    "            else:\n",
    "                with TABS.children[tab_child['Fig-6']]:\n",
    "                    figures = plotFig06(figures)\n",
    "                    plt.show(block=False)\n",
    "\n",
    "        if PLOT_FIGS[7]:\n",
    "\n",
    "            def plotFig07(figures):\n",
    "                ## Figure 7 - Msl/Tgt acceleration vs time of flight up\n",
    "                ##            to point just before flight termination.\n",
    "                figures.append(plt.figure(7, figsize=(6,3), dpi=80))\n",
    "                text = \"Msl/Tgt acceleration profiles ({0}, N={1}, At={2})\"\\\n",
    "                    .format(PN_LAWS[PNAV], int(Nm), int(Nt))\n",
    "                plt.title(text)\n",
    "                plt.xlabel('Time (sec)')\n",
    "                plt.ylabel('Acceleration (g)')\n",
    "                plt.xlim([0.0, T_STOP])\n",
    "                plt.ylim([floor((min([min(Acmg[0:istop]),min(Atg[0:istop])])-Gmmax[MSL]/2)*10.0)/10.0,\n",
    "                          ceil((max([max(Acmg[0:istop]),max(Atg[0:istop])])+Gmmax[MSL]/2)*10.0)/10.0])\n",
    "                plt.grid()\n",
    "                plt.plot(Time[0:istop], Acmg[0:istop], ',-b')\n",
    "                plt.plot(Time[0:istop], Atg[0:istop], ',-r')\n",
    "                plt.legend(('Missile','Target'), loc='lower right')\n",
    "                return figures\n",
    "\n",
    "            if TABS is None:\n",
    "                figures = plotFig07(figures)\n",
    "            elif RUN_WITH_COLAB:\n",
    "                with TABS.output_to(\"Fig-7\", select=False):\n",
    "                    figures = plotFig07(figures)\n",
    "                    plt.show(block=False)\n",
    "            else:\n",
    "                with TABS.children[tab_child['Fig-7']]:\n",
    "                    figures = plotFig07(figures)\n",
    "                    plt.show(block=False)\n",
    "\n",
    "        if PLOT_FIGS[8]:\n",
    "\n",
    "            def plotFig08(figures):\n",
    "                ## Figure 8 - Line-of-Sight rate vs time of flight up\n",
    "                ##            to point just before flight termination.\n",
    "                figures.append(plt.figure(8, figsize=(6,3), dpi=80))\n",
    "                text = \"LOS rate profile ({0}, N={1}, At={2})\"\\\n",
    "                    .format(PN_LAWS[PNAV], int(Nm), int(Nt))\n",
    "                plt.title(text)\n",
    "                plt.xlabel('Time (sec)')\n",
    "                plt.ylabel('LOS rate (deg/sec)')\n",
    "                plt.xlim([0.0, T_STOP])\n",
    "                plt.ylim([max([floor(min(LOSd[0:istop]))-0.2,-6]),\n",
    "                          min([ ceil(max(LOSd[0:istop]))+0.2, 6])])\n",
    "                plt.grid()\n",
    "                plt.plot(Time[0:istop], LOSd[0:istop], '-k')\n",
    "                return figures\n",
    "\n",
    "            if TABS is None:\n",
    "                figures = plotFig08(figures)\n",
    "            elif RUN_WITH_COLAB:\n",
    "                with TABS.output_to(\"Fig-8\", select=False):\n",
    "                    figures = plotFig08(figures)\n",
    "                    plt.show(block=False)\n",
    "            else:\n",
    "                with TABS.children[tab_child['Fig-8']]:\n",
    "                    figures = plotFig08(figures)\n",
    "                    plt.show(block=False)\n",
    "\n",
    "        if PLOT_FIGS[9]:\n",
    "\n",
    "            def plotFig09(figures):\n",
    "                ## Figure 9 - Closing velocity vs time of flight up\n",
    "                ##            to point just before flight termination.\n",
    "                figures.append(plt.figure(9, figsize=(6,3), dpi=80))\n",
    "                text = \"Closing velocity profile ({0}, N={1}, At={2})\"\\\n",
    "                    .format(PN_LAWS[PNAV], int(Nm), int(Nt))\n",
    "                plt.title(text)\n",
    "                plt.xlabel('Time (sec)')\n",
    "                plt.ylabel('Velocity (meters/sec)')\n",
    "                plt.xlim([0.0, T_STOP])\n",
    "                plt.ylim([floor(min(VELc[0:istop]))-10.0,\n",
    "                          ceil(max(VELc[0:istop]))+10.0])\n",
    "                plt.grid()\n",
    "                plt.plot(Time[0:istop], VELc[0:istop], '-k')\n",
    "                return figures\n",
    "\n",
    "            if TABS is None:\n",
    "                figures = plotFig09(figures)\n",
    "            elif RUN_WITH_COLAB:\n",
    "                with TABS.output_to(\"Fig-9\", select=False):\n",
    "                    figures = plotFig09(figures)\n",
    "                    plt.show(block=False)\n",
    "            else:\n",
    "                with TABS.children[tab_child['Fig-9']]:\n",
    "                    figures = plotFig09(figures)\n",
    "                    plt.show(block=False)\n",
    "\n",
    "        if PLOT_FIGS[10]:\n",
    "\n",
    "            def plotFig10(figures):\n",
    "                ## Figure 10 - Zero Effort Miss distance vs time of flight\n",
    "                ##             up to point just before flight termination.\n",
    "                figures.append(plt.figure(10, figsize=(6,3), dpi=80))\n",
    "                text = \"Zero Effort Miss distance profile ({0}, N={1}, At={2})\"\\\n",
    "                    .format(PN_LAWS[PNAV], int(Nm), int(Nt))\n",
    "                plt.title(text)\n",
    "                plt.xlabel('Time (sec)')\n",
    "                plt.ylabel('Distance (meters)')\n",
    "                plt.xlim([0.0, T_STOP])\n",
    "                plt.ylim([0.0, ceil(max(ZEMd[0:istop]))+10.0])\n",
    "                plt.grid()\n",
    "                plt.plot(Time[0:istop], ZEMd[0:istop], '-k')\n",
    "                return figures\n",
    "\n",
    "            if TABS is None:\n",
    "                figures = plotFig10(figures)\n",
    "            elif RUN_WITH_COLAB:\n",
    "                with TABS.output_to(\"Fig-10\", select=False):\n",
    "                    figures = plotFig10(figures)\n",
    "                    plt.show(block=False)\n",
    "            else:\n",
    "                with TABS.children[tab_child['Fig-10']]:\n",
    "                    figures = plotFig10(figures)\n",
    "                    plt.show(block=False)\n",
    "\n",
    "        if PLOT_FIGS[11]:\n",
    "\n",
    "            def plotFig11(figures):\n",
    "                ## Figure 11 - Target offset sines wrt missile +x axis.\n",
    "                figures.append(plt.figure(11, figsize=(6,6), dpi=80))\n",
    "                text = \"Target offset sines wrt missile +x axis ({0}, N={1}, At={2})\"\\\n",
    "                    .format(PN_LAWS[PNAV], int(Nm), int(Nt))\n",
    "                plt.title(text)\n",
    "                plt.xlabel('Horizontal Offset (Sine)')\n",
    "                plt.ylabel('Vertical Offset (Sine)')\n",
    "                plt.xlim([-0.5,  0.5])  # +/- 30 degrees\n",
    "                plt.ylim([ 0.5, -0.5])  # +/- 30 degrees\n",
    "                plt.grid()\n",
    "                plt.plot(Thoff[0:1], Tvoff[0:1], 'o:r')\n",
    "                plt.plot(Thoff[1:iend], Tvoff[1:iend], ',:r')\n",
    "                if INTERCEPT:\n",
    "                    plt.plot(Thoff[istop:iend], Tvoff[istop:iend], 'xm')\n",
    "                    plt.legend(('Target at To','Target Path','Intercept'), loc='upper left')\n",
    "                else:\n",
    "                    plt.plot(Thoff[istop:iend], Tvoff[istop:iend], 'oc')\n",
    "                    plt.legend(('Target at To','Target Path','Missed'), loc='upper left')\n",
    "                return figures\n",
    "\n",
    "            if TABS is None:\n",
    "                figures = plotFig11(figures)\n",
    "            elif RUN_WITH_COLAB:\n",
    "                with TABS.output_to(\"Fig-11\", select=False):\n",
    "                    figures = plotFig11(figures)\n",
    "                    plt.show(block=False)\n",
    "            else:\n",
    "                with TABS.children[tab_child['Fig-11']]:\n",
    "                    figures = plotFig11(figures)\n",
    "                    plt.show(block=False)\n",
    "\n",
    "        if PLOT_FIGS[12]:\n",
    "\n",
    "            def plotFig12(figures):\n",
    "                ## Figure 12 - Rotational energy vs time of flight plots.\n",
    "                figures.append(plt.figure(12, figsize=(6,6), dpi=80))\n",
    "                text = \"Rotational Energy vs ToF ({0}, N={1}, At={2})\"\\\n",
    "                    .format(PN_LAWS[PNAV], int(Nm), int(Nt))\n",
    "                figures[-1].suptitle(text)\n",
    "                try:\n",
    "                    figures[-1].set_tight_layout(True)\n",
    "                except:\n",
    "                    figures[-1].set_layout_engine('tight')\n",
    "                \n",
    "                # Calculate missile body angular velocity using equation (4.6)\n",
    "                # on pg 13 of ref [6].\n",
    "                Wmen = np.cross(Vme[0,:,0:istop], Ame[0,:,0:istop], axis=0)\n",
    "                Wmed = np.einsum('ij,ij->j', Vme[0,:,0:istop], Vme[0,:,0:istop])\n",
    "                Wme  = Wmen[:,0:istop] / Wmed[0:istop,]  # rad/sec\n",
    "            \n",
    "                # Calculate and plot missile rotational energy.\n",
    "                Er = 0.5*np.einsum('ij,ij->j', Wme[:,0:istop], Wme[:,0:istop])\n",
    "                ax1 = figures[-1].add_subplot(211)\n",
    "                ax1.set_title(None)\n",
    "                ax1.set_xlabel('Time-of-Flight (sec)')\n",
    "                ax1.set_ylabel('Rotational Energy (Joules/I)')\n",
    "                ax1.set_xlim([0.0, ceil(Time[istop]*10.0)/10.0])\n",
    "                ax1.set_ylim([0.0, ceil(max(Er[0:istop])*1000.0)/1000.0])\n",
    "                ax1.grid()\n",
    "                ax1.plot(Time[0:istop], Er[0:istop], '-r')\n",
    "            \n",
    "                # Calculate and plot missile total rotational energy.\n",
    "                TotEr = np.cumsum(Er)\n",
    "                ax2 = figures[-1].add_subplot(212)\n",
    "                ax2.set_title(\" \")\n",
    "                ax2.set_xlabel('Time-of-Flight (sec)')\n",
    "                ax2.set_ylabel('Total Rotational Energy (Joules/I)')\n",
    "                ax2.set_xlim([0.0, ceil(Time[istop]*10.0)/10.0])\n",
    "                ax2.set_ylim([0.0, ceil(max(TotEr[0:istop])*100.0)/100.0])\n",
    "                ax2.grid()\n",
    "                ax2.plot(Time[0:istop], TotEr[0:istop], '-r')\n",
    "                return figures\n",
    "            \n",
    "            if TABS is None:\n",
    "                figures = plotFig12(figures)\n",
    "            elif RUN_WITH_COLAB:\n",
    "                with TABS.output_to(\"Fig-12\", select=False):\n",
    "                    figures = plotFig12(figures)\n",
    "                    plt.show(block=False)\n",
    "            else:\n",
    "                with TABS.children[tab_child['Fig-12']]:\n",
    "                    figures = plotFig12(figures)\n",
    "                    plt.show(block=False)     \n",
    "                \n",
    "        if PLOT_FIGS[13]:\n",
    "\n",
    "            def plotFig13(figures):\n",
    "                ## Figure 13- 3D missile/target engagement trajectories plot.\n",
    "                figures.append(plt.figure(13, figsize=(8,8), dpi=80))\n",
    "                ax = figures[-1].add_subplot(projection='3d')\n",
    "                text = \"3D Plot of missile/target engagement ({0}, N={1}, At={2})\"\\\n",
    "                   .format(PN_LAWS[PNAV], int(Nm), int(Nt))\n",
    "                ax.set_title(text)\n",
    "                ax.set_xlabel('X (meters)')\n",
    "                ax.set_ylabel('Y (meters)')\n",
    "                ax.set_zlabel('Z (meters)')\n",
    "                if MSL == SAM:\n",
    "                    ax.set_xlim3d([Pm0[0],  Pt0[0]+500.0])\n",
    "                    ax.set_ylim3d([Pm0[1],  Pm0[1]+(Pt0[0]+500-Pm0[0])])\n",
    "                    ax.set_zlim3d([0.0,    (Pt0[0]+500-Pm0[0])/2])\n",
    "                else:\n",
    "                    ax.set_xlim3d([floor(Pmx[0]/500.0)*500.0,\n",
    "                                   ceil(Ptx[0]/500.0)*500.0])\n",
    "                    ax.set_ylim3d([floor(Pmy[0]/500.0)*500.0 -\n",
    "                                   (ceil(Ptx[0]/500.0)*500.0 -\n",
    "                                    floor(Pmx[0]/500.0)*500.0)/2,\n",
    "                                   floor(Pmy[0]/500.0)*500.0 +\n",
    "                                    (ceil(Ptx[0]/500.0)*500.0 -\n",
    "                                     floor(Pmx[0]/500.0)*500.0)/2])\n",
    "                    ax.set_zlim3d([floor(Pmz[0]/500.0)*500.0 -\n",
    "                                   (ceil(Ptx[0]/500.0)*500.0 -\n",
    "                                    floor(Pmx[0]/500.0)*500.0)/2,\n",
    "                                   floor(Pmz[0]/500.0)*500.0 +\n",
    "                                   (ceil(Ptx[0]/500.0)*500.0 -\n",
    "                                    floor(Pmx[0]/500.0)*500.0)/2])\n",
    "                    ax.set_aspect('equal')\n",
    "                ax.grid()\n",
    "                # target in 3D space\n",
    "                line1 = Line3D(Ptx[0:iend], Pty[0:iend], Ptz[0:iend],\n",
    "                               color='r', ls='-', lw=2.0,\n",
    "                               marker=' ', mew=2.0, mec='r', mfc='r',\n",
    "                               label='Target Flight Path')\n",
    "                # missile in 3D space\n",
    "                line2 = Line3D(Pmx[0:iend], Pmy[0:iend], Pmz[0:iend],\n",
    "                               color='b', ls='-', lw=2.0,\n",
    "                               marker=' ', mew=2.0, mec='b', mfc='b',\n",
    "                               label='Missile Trajectory')\n",
    "                # estimated intercept trajectory in 3D space\n",
    "                line3 = Line3D(np.array([Pm0[0],EstPt[0]]),\n",
    "                               np.array([Pm0[1],EstPt[1]]),\n",
    "                               np.array([Pm0[2],EstPt[2]]),\n",
    "                               color='g', ls=':', lw=2.0,\n",
    "                               marker=' ', mew=1.0, mec='g', mfc='g',\n",
    "                               label='Estimated Trajectory')\n",
    "                # estimated intercept point in 3D space\n",
    "                line4 = Line3D(np.array([EstPt[0],EstPt[0]]),\n",
    "                               np.array([EstPt[1],EstPt[1]]),\n",
    "                               np.array([EstPt[2],EstPt[2]]),\n",
    "                               color='g', ls=' ', lw=1.0,\n",
    "                               marker='X', mew=1.0, mec='g', mfc='g',\n",
    "                               label='Estimated Intercept')\n",
    "                if INTERCEPT:\n",
    "                    # intercept point in 3D space\n",
    "                    line5 = Line3D(Pmx[istop:iend], Pmy[istop:iend], Pmz[istop:iend],\n",
    "                                   color='m', ls=' ', lw=1.0,\n",
    "                                   marker='X', mew=1.0, mec='m', mfc='m',\n",
    "                                   label='Actual Intercept')\n",
    "                else:\n",
    "                    # missed target and missile points in 3D space\n",
    "                    line5 = Line3D(np.array([Pmx[istop],Ptx[istop]]),\n",
    "                                   np.array([Pmy[istop],Pty[istop]]),\n",
    "                                   np.array([Pmz[istop],Ptz[istop]]),\n",
    "                                   color='c', ls=' ', lw=1.0,\n",
    "                                   marker='o', mew=1.0, mec='c', mfc='c',\n",
    "                                   label='Missed Intercept')\n",
    "                ax.add_line(line1)\n",
    "                ax.add_line(line2)\n",
    "                ax.add_line(line3)\n",
    "                ax.add_line(line4)\n",
    "                ax.add_line(line5)\n",
    "\n",
    "                (xmin, xmax) = ax.get_xlim()\n",
    "                (ymin, ymax) = ax.get_ylim()\n",
    "                (zmin, zmax) = ax.get_zlim()\n",
    "                time_text = ax.text3D(xmin-500.0, ymax+100.0, zmax+(zmax-zmin)/4.0,\n",
    "                                      'Time = %.4f' % Time[istop])\n",
    "\n",
    "                ax.legend(loc='upper right')\n",
    "                ax.view_init(elev=20.0, azim=220.0)\n",
    "                return figures\n",
    "\n",
    "            if TABS is None:\n",
    "                figures = plotFig13(figures)\n",
    "            elif RUN_WITH_COLAB:\n",
    "                with TABS.output_to(\"Fig-13\", select=(not SAVE_ANIM)):\n",
    "                    figures = plotFig13(figures)\n",
    "                    plt.show(block=False)\n",
    "            else:\n",
    "                with TABS.children[tab_child['Fig-13']]:\n",
    "                    figures = plotFig13(figures)\n",
    "                    plt.show(block=False)\n",
    "\n",
    "        def move_fig(fig):\n",
    "            \"\"\"\n",
    "            Moves given figure plot window based on figure's number.\n",
    "            \"\"\"\n",
    "            fign = fig.number\n",
    "            x, y = 60*(fign+1), 40*(fign+1)\n",
    "            backend = mpl.get_backend().upper()\n",
    "            if backend[0:2] == 'WX':\n",
    "                fig.canvas.manager.window.SetPosition((x,y))\n",
    "            elif backend[0:2] == 'TK':\n",
    "                fig.canvas.manager.window.wm_geometry(\"+%d+%d\" % (x,y))\n",
    "            else:  # QT or GTK\n",
    "                fig.canvas.manager.window.move(x,y)\n",
    "\n",
    "        try:\n",
    "            if not RUN_WITH_COLAB:\n",
    "                if TABS is None:\n",
    "                    for fig in figures:\n",
    "                        move_fig(fig)\n",
    "                    # Block to keep plots displayed when not running interactively.\n",
    "                    plt.show(block=True)\n",
    "                    plt.close('all')\n",
    "                else:\n",
    "                    # Figures will be displayed in tabs within the output cell\n",
    "                    # for the code cell immediatelly following the output cell\n",
    "                    # diplaying the printed results from this code cell.\n",
    "                    display(TABS)\n",
    "        except AttributeError:\n",
    "            # Possibly running \"inline\".\n",
    "            plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "V0vzRk9Jihka",
   "metadata": {
    "id": "V0vzRk9Jihka"
   },
   "source": [
    "### Print TXYZ.OUT Trajectory File"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "yB_7x0ldhvFu",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 9,
     "status": "ok",
     "timestamp": 1710972497744,
     "user": {
      "displayName": "Gary Deschaines",
      "userId": "00818646848844190559"
     },
     "user_tz": 300
    },
    "id": "yB_7x0ldhvFu",
    "jupyter": {
     "source_hidden": true
    },
    "outputId": "15892832-50ea-43a6-edce-a1aa50cc6831"
   },
   "outputs": [],
   "source": [
    "    if PRINT_TXYZ:\n",
    "\n",
    "        # Set constant missile spin rate. This is purely a\n",
    "        # cosmetic effect to provide rendering realism for\n",
    "        # spin stabilized/controlled missiles. Spin is not\n",
    "        # considered in kinematic equations of motion.\n",
    "\n",
    "        twopi = 2.0*pi\n",
    "        fspin = 16.0\n",
    "        pspin = 1.0/fspin\n",
    "        wspin = fspin*twopi\n",
    "\n",
    "        # Calculate missile and target yaw (PSI), pitch (THT) and\n",
    "        # roll (PHI) angles.\n",
    "        #\n",
    "        # Note: Vectorized atan2 expression from pitchAngle()\n",
    "        #       routine used for calculating THTm and THTt.\n",
    "        #       These equations do not account for instances\n",
    "        #       where the missile or target have pitched past\n",
    "        #       +/- 90 degrees.\n",
    "\n",
    "        UVm   = Uvec(Vme[:,0:iend])\n",
    "        PSImd = np.arctan2(-UVm[0,1,0:iend], UVm[0,0,0:iend],)*DPR\n",
    "        THTmd = np.arctan2(UVm[0,2,0:iend],\n",
    "                           la.norm([UVm[0,0,0:iend],\n",
    "                                    UVm[0,1,0:iend]], axis=0))*DPR\n",
    "        PHIm  = wspin*Time[0:iend]\n",
    "        PHImd = np.fmod(PHIm[0:iend], twopi)*DPR\n",
    "\n",
    "        UVt   = Uvec(Vte[:,0:iend])\n",
    "        PSItd = np.arctan2(-UVt[0,1,0:iend], UVt[0,0,0:iend])*DPR\n",
    "        \"\"\"\n",
    "        THTtd  = np.arctan2(UVt[0,2,0:iend],\n",
    "                            la.norm([UVt[0,0,0:iend],\n",
    "                                     UVt[0,1,0:iend]], axis=0))*DPR\n",
    "        \"\"\"\n",
    "        for i in range(0, iend):\n",
    "            if ( abs(THTtd[i]) > 90.0):\n",
    "                # Account for looping maneuver.\n",
    "                PSItd[i] = np.fmod(PSItd[i] + 180.0, 360.0)\n",
    "\n",
    "        PHIt = np.zeros([iend])\n",
    "        for i in range(0, iend):\n",
    "            PHIt[i] = bankAngle(Ate[0,:,i],Vte[0,:,i])\n",
    "        PHItd = np.fmod(PHIt[0:iend], twopi)*DPR\n",
    "\n",
    "        # Assemble run case identifier appended to \"./out/TXYZ.OUT.\"\n",
    "\n",
    "        sbuff = StringIO()\n",
    "        sbuff.write(\"%1d%1d%1d%1d\" % (int(MSL), int(PNAV), int(Nm), int(Nt)))\n",
    "        icase = sbuff.getvalue()\n",
    "        sbuff.close()\n",
    "\n",
    "        # TXYZ output file record formats.\n",
    "\n",
    "        fmt1 = \" %9.4f %9d %10.2f %10.2f %10.2f %10.2f %10.2f %10.2f\"\n",
    "        fmt2 = \" %9d %9d %10.3f %10.3f %10.3f %10.3f %10.3f %10.3f\"\n",
    "\n",
    "        # Open TXYZ output file and write trajectory data.\n",
    "\n",
    "        if RUN_WITH_COLAB:\n",
    "            gdf_path  = Google_Drive_Folder\n",
    "            txyz_path = \"{0}/out/TXYZ.OUT.{1}\".format(gdf_path, icase)\n",
    "        else:\n",
    "            txyz_path = \"./out/TXYZ.OUT.{0}\".format(icase)\n",
    "\n",
    "        try:\n",
    "\n",
    "            f = open(txyz_path, \"w\")\n",
    "\n",
    "            for i in range(0, iend):\n",
    "                print(fmt1 % \\\n",
    "                      (Time[i], 0, Pme[0,0,i], -Pme[0,1,i], -Pme[0,2,i],\n",
    "                                   Pte[0,0,i], -Pte[0,1,i], -Pte[0,2,i]),\n",
    "                      file=f)\n",
    "                print(fmt2 % \\\n",
    "                      (-9999, -9999, PHImd[i], THTmd[i], PSImd[i],\n",
    "                                     PHItd[i], THTtd[i], PSItd[i]),\n",
    "                      file=f)\n",
    "\n",
    "            # Append padded time record for rendering and display of\n",
    "            # last frame by threeD program. Time of istop frame plus\n",
    "            # 2*F_TIME, but with missile and target states of istop\n",
    "            # frame.\n",
    "\n",
    "            print(fmt1 % \\\n",
    "                  (Time[istop]+2*F_TIME, -1, Pme[0,0,istop], -Pme[0,1,istop], -Pme[0,2,istop],\n",
    "                                             Pte[0,0,istop], -Pte[0,1,istop], -Pte[0,2,istop]),\n",
    "                  file=f)\n",
    "            print(fmt2 % \\\n",
    "                  (-9999, -9999, PHImd[istop], THTmd[istop], PSImd[istop],\n",
    "                                 PHItd[istop], THTtd[istop], PSItd[istop]),\n",
    "                  file=f)\n",
    "\n",
    "            print(\"\\nTXYZ.OUT trajectory data written to:  %s\" % txyz_path)\n",
    "\n",
    "            f.close()\n",
    "\n",
    "        except:\n",
    "\n",
    "            print(\"\\nError:  TXYZ.OUT trajectory data could not be written.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6f227aa-094a-4314-b80a-195ec1980881",
   "metadata": {
    "id": "a6f227aa-094a-4314-b80a-195ec1980881"
   },
   "source": [
    "### Display Saved Engagement Animation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f878a27a-9a8b-455d-9821-a861b1f29852",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 621
    },
    "executionInfo": {
     "elapsed": 731,
     "status": "ok",
     "timestamp": 1710972498468,
     "user": {
      "displayName": "Gary Deschaines",
      "userId": "00818646848844190559"
     },
     "user_tz": 300
    },
    "id": "f878a27a-9a8b-455d-9821-a861b1f29852",
    "jupyter": {
     "source_hidden": true
    },
    "outputId": "b5302278-cadf-4e20-daee-88c53b254b3e"
   },
   "outputs": [],
   "source": [
    "    if SAVE_ANIM and anim_filename is not None:\n",
    "        if RUN_WITH_SPYDER:\n",
    "            display(anim)\n",
    "        else:\n",
    "            from moviepy import editor\n",
    "            display(editor.ipython_display(anim_filename))"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [
    "041a3969-d608-4d64-aa71-f1951b728bb8",
    "7d8feb87-2bbd-4740-9f91-a5ddf6411603",
    "7ac41851-6413-4665-b9c9-60d8b2e0c05c",
    "aaba3689-a3c5-41a1-8ee6-65e208d42667",
    "98cfc666-da96-4ab2-ba96-06dfa669cb0a",
    "e3686f94-fb74-4028-aea9-7f77904d5078",
    "bd62c4dd-e993-4ea2-bb08-4c87bbda148b",
    "a76c1e63-44bc-4f75-8838-3895cb95fc5d"
   ],
   "provenance": [
    {
     "file_id": "1nl3vJxiAUQCU9309B4mNA-9ZCWPbOm6Z",
     "timestamp": 1710807152782
    },
    {
     "file_id": "1Jv-PmoQpVU2LiwY7n97PjP7sz4nF8aFg",
     "timestamp": 1710705851530
    }
   ]
  },
  "kernelspec": {
   "display_name": "Python 3 (Spyder)",
   "language": "python3",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}