From f3b88c6eddb85c089e19c247f3aa4c817350d88e Mon Sep 17 00:00:00 2001
From: Alexander <alexanderjchapa@gmail.com>
Date: Fri, 20 Sep 2019 20:14:05 -0400
Subject: [PATCH] HW#3

---
 homework/AlexanderChapaHW3.ipynb   | 677 +++++++++++++++++++++++++
 homework/AlexanderJChapa-F16.ipynb | 470 +++++++++++++++++
 lectures/4-Casadi-Transport.ipynb  |   4 +-
 lectures/AJC-MSD.ipynb             | 181 +++++++
 lectures/AlexanderChapaHW3.ipynb   | 677 +++++++++++++++++++++++++
 lectures/Homework3.ipynb           | 780 +++++++++++++++++++++++++++++
 lectures/ROCKET.ipynb              |  43 ++
 lectures/gen.c                     | 114 +++++
 python/casadi_f16                  |   2 +-
 9 files changed, 2945 insertions(+), 3 deletions(-)
 create mode 100644 homework/AlexanderChapaHW3.ipynb
 create mode 100644 homework/AlexanderJChapa-F16.ipynb
 create mode 100644 lectures/AJC-MSD.ipynb
 create mode 100644 lectures/AlexanderChapaHW3.ipynb
 create mode 100644 lectures/Homework3.ipynb
 create mode 100644 lectures/ROCKET.ipynb
 create mode 100644 lectures/gen.c

diff --git a/homework/AlexanderChapaHW3.ipynb b/homework/AlexanderChapaHW3.ipynb
new file mode 100644
index 00000000..3ab14991
--- /dev/null
+++ b/homework/AlexanderChapaHW3.ipynb
@@ -0,0 +1,677 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import casadi as ca\n",
+    "import numpy as np\n",
+    "import control\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from casadi.tools.graph import dotgraph\n",
+    "from IPython.display import Image\n",
+    "\n",
+    "def draw_graph(expr):\n",
+    "    return Image(dotgraph(expr).create_png())\n",
+    "\n",
+    "# make matrix printing prettier\n",
+    "np.set_printoptions(precision=3, suppress=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This notebook will walk through trimming and control design for a transport aircxraft using casadi."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def rhs(x, u):\n",
+    "    s = 2170\n",
+    "    cbar = 17.5\n",
+    "    mass = 5.0e3\n",
+    "    iyy = 4.1e6\n",
+    "    tstat = 6.0e4\n",
+    "    dtdv = -38.0\n",
+    "    ze = 2.0\n",
+    "    cdcls = 0.042\n",
+    "    cla = 0.085\n",
+    "    cma = -0.022\n",
+    "    cmde = -0.016\n",
+    "    cmq = -16.0\n",
+    "    cmadot = -6.0\n",
+    "    cladot = 0.0\n",
+    "    rtod = 57.29578\n",
+    "    gd = 32.17\n",
+    "    \n",
+    "    thtl = u[0]\n",
+    "    elev_deg = u[1]\n",
+    "    xcg = u[2]\n",
+    "    land = u[3]\n",
+    "    \n",
+    "    vt = x[0]  # velocity, ft/s\n",
+    "    alpha = x[1]\n",
+    "    alpha_deg = rtod*alpha  # angle of attack, deg\n",
+    "    theta = x[2]  # pitch angle, rad\n",
+    "    q = x[3]  # pitch rate, rad/s\n",
+    "    h = x[4]  # altitude, ft\n",
+    "    pos = x[5]  # horizontal position from origin, ft (not used in dynamics)\n",
+    "    \n",
+    "    r0 = 2.377e-3\n",
+    "    tfac = 1.0 - 0.703e-5*h\n",
+    "    temperature = ca.if_else(h > 35000, 390.0, 519.0*tfac)\n",
+    "    rho = r0*(tfac**4.14)\n",
+    "    mach = vt/ca.sqrt(1.4*1716.3*temperature)\n",
+    "    qbar = 0.5*rho*vt**2\n",
+    "    \n",
+    "    qs = qbar*s\n",
+    "    salp = ca.sin(alpha)\n",
+    "    calp = ca.cos(alpha)\n",
+    "    gam = theta - alpha\n",
+    "    sgam = ca.sin(gam)\n",
+    "    cgam = ca.cos(gam)\n",
+    "    \n",
+    "    aero_p = ca.if_else(\n",
+    "        land,\n",
+    "        (1.0, 0.08, -0.20, 0.02, -0.05),\n",
+    "        (0.2, 0.016, 0.05, 0.0, 0.0))\n",
+    "    cl0 = aero_p[0]\n",
+    "    cd0 = aero_p[1]\n",
+    "    cm0 = aero_p[2]\n",
+    "    dcdg = aero_p[3]\n",
+    "    dcmg = aero_p[4]\n",
+    "    \n",
+    "    thr = (tstat + vt*dtdv)*ca.fmax(thtl, 0)\n",
+    "    cl = cl0 + cla*alpha_deg\n",
+    "    cm = dcmg + cm0 + cma*alpha_deg + cmde*elev_deg + cl*(xcg - 0.25)\n",
+    "    cd = dcdg + cd0 + cdcls*cl**2\n",
+    "    \n",
+    "    x_dot = ca.SX.zeros(6)\n",
+    "    x_dot[0] = (thr*calp - qs*cd)/mass - gd*sgam\n",
+    "    x_dot[1] = (-thr*salp - qs*cl + mass*(vt*q + gd*cgam))/(mass*vt + qs*cladot)\n",
+    "    x_dot[2] = q\n",
+    "    d = 0.5*cbar*(cmq*q + cmadot*x_dot[1])/vt\n",
+    "    x_dot[3] = (qs*cbar*(cm + d) + thr*ze)/iyy\n",
+    "    x_dot[4] = vt*sgam\n",
+    "    x_dot[5] = vt*cgam\n",
+    "    return x_dot"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def constrain(s, vt, h, q, gamma):\n",
+    "    \n",
+    "    # s is our design vector:\n",
+    "    # s = [thtl, elev_deg, alpha]\n",
+    "    thtl = s[0]\n",
+    "    elev_deg = s[1]\n",
+    "    alpha = s[2]\n",
+    "    \n",
+    "    pos = 0  # we don't care what horiz. position we are at\n",
+    "    xcg = 0.25  # we assume xcg at 1/4 chord\n",
+    "    land = 0  # we assume we do not have flaps/gear deployed\n",
+    "    theta = alpha + gamma\n",
+    "    \n",
+    "    # vt, alpha, theta, q, h, pos\n",
+    "    x = ca.vertcat(vt, alpha, theta, q, h, pos)\n",
+    "    \n",
+    "    # thtl, elev_deg, xcg, land\n",
+    "    u = ca.vertcat(thtl, elev_deg, xcg, land)\n",
+    "    return x, u\n",
+    "\n",
+    "def trim_cost(x, u):\n",
+    "    x_dot = rhs(x, u)\n",
+    "    return x_dot[0]**2 + 100*x_dot[1]**2 + 10*x_dot[3]**2\n",
+    "\n",
+    "def objective(s, vt, h, q, gamma):\n",
+    "    x, u = constrain(s, vt, h, q, gamma)\n",
+    "    return trim_cost(x, u)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def trim(vt, h, q, gamma):\n",
+    "    s = ca.SX.sym('s', 3)\n",
+    "    nlp = {'x': s, 'f': objective(s, vt=vt, h=h, q=q, gamma=gamma)}\n",
+    "    S = ca.nlpsol('S', 'ipopt', nlp, {\n",
+    "        'print_time': 0,\n",
+    "        'ipopt': {\n",
+    "            'sb': 'yes',\n",
+    "            'print_level': 0,\n",
+    "            }\n",
+    "        })\n",
+    "    # s = [thtl, elev_deg, alpha]\n",
+    "    s0 = [0.293, 2.46, np.deg2rad(0.58)]\n",
+    "    res = S(x0=s0, lbg=0, ubg=0, lbx=[0, -60, -np.deg2rad(5)], ubx=[1, 60, np.deg2rad(18)])\n",
+    "    \n",
+    "    trim_cost = res['f']\n",
+    "    trim_tol = 100\n",
+    "    if trim_cost > trim_tol:\n",
+    "        raise ValueError('Trim failed to converge', trim_cost)\n",
+    "    assert np.abs(float(res['f'])) < trim_tol\n",
+    "    s_opt = res['x']\n",
+    "    print(s_opt)\n",
+    "    x0, u0 = constrain(s_opt, vt, h, q, gamma)\n",
+    "    return {\n",
+    "        'x0': np.array(x0).reshape(-1),\n",
+    "        'u0': np.array(u0).reshape(-1),\n",
+    "        's': np.array(s_opt).reshape(-1)\n",
+    "    }\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.292673, 2.4607, 0.0101196]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'x0': array([500.  ,   0.01,   0.01,   0.  ,   0.  ,   0.  ]),\n",
+       " 'u0': array([0.293, 2.461, 0.25 , 0.   ]),\n",
+       " 's': array([0.293, 2.461, 0.01 ])}"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "trim(500, 0, 0, 0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.0753603, -27.9939, 0.314159]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'x0': array([100.   ,   0.314,   0.314,   0.   ,   0.   ,   0.   ]),\n",
+       " 'u0': array([  0.075, -27.994,   0.25 ,   0.   ]),\n",
+       " 's': array([  0.075, -27.994,   0.314])}"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "trim(100, 0, 0, 0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.250133, -19.8854, 0.304934]\n",
+      "[0.241141, -18.6539, 0.288171]\n",
+      "[0.23299, -17.5014, 0.272547]\n",
+      "[0.225603, -16.422, 0.257969]\n",
+      "[0.218911, -15.4101, 0.24435]\n",
+      "[0.212855, -14.4608, 0.231612]\n",
+      "[0.207382, -13.5694, 0.219686]\n",
+      "[0.202444, -12.7315, 0.208505]\n",
+      "[0.198002, -11.9433, 0.198012]\n",
+      "[0.194017, -11.2011, 0.188153]\n",
+      "[0.190456, -10.5015, 0.17888]\n",
+      "[0.187292, -9.84159, 0.170149]\n",
+      "[0.184496, -9.21842, 0.161919]\n",
+      "[0.182045, -8.62946, 0.154154]\n",
+      "[0.179919, -8.07233, 0.146821]\n",
+      "[0.178097, -7.54487, 0.139887]\n",
+      "[0.176563, -7.04505, 0.133327]\n",
+      "[0.1753, -6.57103, 0.127112]\n",
+      "[0.174295, -6.12111, 0.121221]\n",
+      "[0.173535, -5.69373, 0.115632]\n",
+      "[0.173008, -5.28743, 0.110324]\n",
+      "[0.172702, -4.90089, 0.105279]\n",
+      "[0.17261, -4.53285, 0.10048]\n",
+      "[0.172721, -4.18219, 0.0959123]\n",
+      "[0.173028, -3.84785, 0.0915606]\n",
+      "[0.173523, -3.52883, 0.087412]\n",
+      "[0.174199, -3.22425, 0.083454]\n",
+      "[0.175051, -2.93324, 0.0796752]\n",
+      "[0.176074, -2.65502, 0.0760652]\n",
+      "[0.177261, -2.38887, 0.0726141]\n",
+      "[0.178608, -2.13411, 0.0693127]\n",
+      "[0.180111, -1.8901, 0.0661526]\n",
+      "[0.181766, -1.65625, 0.0631259]\n",
+      "[0.18357, -1.43201, 0.0602252]\n",
+      "[0.185519, -1.21687, 0.0574437]\n",
+      "[0.187611, -1.01035, 0.0547749]\n",
+      "[0.189842, -0.811989, 0.052213]\n",
+      "[0.192211, -0.621375, 0.0497522]\n",
+      "[0.194715, -0.43811, 0.0473874]\n",
+      "[0.197353, -0.261825, 0.0451136]\n",
+      "[0.200122, -0.0921724, 0.0429263]\n",
+      "[0.203021, 0.0711747, 0.0408212]\n",
+      "[0.206048, 0.228523, 0.0387941]\n",
+      "[0.209203, 0.38016, 0.0368413]\n",
+      "[0.212485, 0.526357, 0.0349593]\n",
+      "[0.215892, 0.667371, 0.0331446]\n",
+      "[0.219423, 0.803441, 0.0313941]\n",
+      "[0.223079, 0.934796, 0.0297048]\n",
+      "[0.226858, 1.06165, 0.0280739]\n",
+      "[0.23076, 1.1842, 0.0264988]\n",
+      "[0.234785, 1.30265, 0.0249768]\n",
+      "[0.238933, 1.41717, 0.0235058]\n",
+      "[0.243202, 1.52793, 0.0220834]\n",
+      "[0.247595, 1.6351, 0.0207075]\n",
+      "[0.25211, 1.73882, 0.0193761]\n",
+      "[0.256747, 1.83925, 0.0180874]\n",
+      "[0.261507, 1.93653, 0.0168394]\n",
+      "[0.266391, 2.03077, 0.0156306]\n",
+      "[0.271398, 2.12211, 0.0144593]\n",
+      "[0.276529, 2.21066, 0.013324]\n",
+      "[0.281785, 2.29654, 0.0122232]\n",
+      "[0.287166, 2.37985, 0.0111555]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def power_required_curve():\n",
+    "    throttle = []\n",
+    "    vt_list = np.arange(190, 500, 5)\n",
+    "    for vt in vt_list:\n",
+    "        res = trim(vt=vt, h=0, q=0, gamma=0)\n",
+    "        throttle.append(res['s'][0])\n",
+    "    plt.plot(vt_list, 100*np.array(throttle))\n",
+    "    plt.grid()\n",
+    "    plt.ylabel(r'throttle, %')\n",
+    "    plt.xlabel('VT, ft/s')\n",
+    "    plt.title('power required curve')\n",
+    "    \n",
+    "power_required_curve()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def linearize(trim):\n",
+    "    x0 = trim['x0']\n",
+    "    u0 = trim['u0']\n",
+    "    x = ca.SX.sym('x', 6)\n",
+    "    u = ca.SX.sym('u', 4)\n",
+    "    y = x\n",
+    "    A = ca.jacobian(rhs(x, u), x)\n",
+    "    B = ca.jacobian(rhs(x, u), u)\n",
+    "    C = ca.jacobian(y, x)\n",
+    "    D = ca.jacobian(y, u)\n",
+    "    f_ss = ca.Function('ss', [x, u], [A, B, C, D])\n",
+    "    return control.ss(*f_ss(x0, u0))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def pitch_rate_control_design(vt, H, xlim, ylim, tf=3):\n",
+    "    trim_state = trim(vt=vt, h=0, q=0, gamma=0)\n",
+    "    print(trim_state)\n",
+    "    sys = linearize(trim_state)\n",
+    "    G = control.minreal(control.tf(sys[3, 1]), 1e-2)\n",
+    "    control.rlocus(G*H, kvect=np.linspace(0, 1, 1000), xlim=xlim, ylim=ylim);\n",
+    "    Go = G*H\n",
+    "    Gc = control.feedback(Go)\n",
+    "    plt.plot([0, -3], [0, 3*np.arccos(0.707)], '--')\n",
+    "    #plt.axis('equal')\n",
+    "    plt.grid()\n",
+    "    \n",
+    "    plt.figure()\n",
+    "    control.bode(Go, margins=True, dB=True, Hz=True, omega_limits=[1e-2, 1e2], omega_num=1000);\n",
+    "    plt.grid()\n",
+    "\n",
+    "    plt.figure()\n",
+    "    t = np.linspace(0, tf, 1000)\n",
+    "    r = np.array(t > 0.1, dtype=float)\n",
+    "    t, y, x = control.forced_response(Gc, T=t, U=r)\n",
+    "    _, u, _ = control.forced_response((1/G)*Gc, T=t, U=r)\n",
+    "\n",
+    "    u_norm = np.abs(u)\n",
+    "    max_u_norm = np.max(u_norm)\n",
+    "    print('u_norm max', max_u_norm)\n",
+    "    \n",
+    "    t,y=control.step_response(Gc, T=np.linspace(0, 10, 1000))\n",
+    "    plt.plot(t,y , label='me')\n",
+    "\n",
+    "    plt.plot(t, y, label='x')\n",
+    "    plt.plot(t, r, label='r')\n",
+    "    plt.plot(t, u_norm/max_u_norm, label='u normalized')\n",
+    "    plt.gca().set_ylim(0, 1.5)\n",
+    "    plt.grid()\n",
+    "    plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.292673, 2.4607, 0.0101196]\n",
+      "{'x0': array([500.  ,   0.01,   0.01,   0.  ,   0.  ,   0.  ]), 'u0': array([0.293, 2.461, 0.25 , 0.   ]), 's': array([0.293, 2.461, 0.01 ])}\n",
+      "1 states have been removed from the model\n",
+      "u_norm max 1205.0227541640938\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "s = control.tf([1, 0], [0, 1])\n",
+    "# this is a PID controller with an extra pole at the origin\n",
+    "pitch_rate_control_design(500, -1300*((s + 3 + 5j)*(s + 3 - 5j)/s**2), [-8, 2], [-4, 4])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'Gc' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-30-aaf597c96489>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcontrol\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep_response\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mGc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mT\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinspace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1000\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'Gc' is not defined"
+     ]
+    }
+   ],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.0753603, -27.9939, 0.314159]\n",
+      "{'x0': array([100.   ,   0.314,   0.314,   0.   ,   0.   ,   0.   ]), 'u0': array([  0.075, -27.994,   0.25 ,   0.   ]), 's': array([  0.075, -27.994,   0.314])}\n",
+      "1 states have been removed from the model\n",
+      "u_norm max 1995.4278451991186\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pitch_rate_control_design(100, -2000*((s + 1 )*(s + 1 )/s**2), [-3, 1], [-2, 2])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def lqr_design(out_num, in_num, tf=3, R=1e-5, y_max=1.5):\n",
+    "    trim_500 = trim(vt=500, h=0, q=0, gamma=0)\n",
+    "    # input: thtl, elev, xcg, land\n",
+    "    # state: vt, alpha, theta, q, h, pos\n",
+    "    sys = control.minreal(linearize(trim_500)[out_num, in_num], 1e-3)\n",
+    "    assert np.linalg.matrix_rank(control.ctrb(sys.A, sys.B)) == sys.A.shape[0]\n",
+    "    assert np.linalg.matrix_rank(control.obsv(sys.A, sys.C)) == sys.A.shape[0]\n",
+    "\n",
+    "    Q = sys.C.T.dot(sys.C)\n",
+    "    K, S, E = control.lqr(sys, Q, R)\n",
+    "    sys_c = control.ss( sys.A - sys.B*K, sys.B, sys.C, sys.D)\n",
+    "    final_value = float(sys_c.horner(0))\n",
+    "    N = 1.0/final_value\n",
+    "    sys_c = control.ss( sys.A - sys.B*K, sys.B*N, sys.C, sys.D)\n",
+    "\n",
+    "    t = np.linspace(0, tf, 1000)\n",
+    "    r = np.array(t > 0.1, dtype=float)\n",
+    "    t, y, x = control.forced_response(sys_c, T=np.linspace(0, tf, 1000), U=r)\n",
+    "    u_norm = np.linalg.norm(K.dot(x), axis=0)\n",
+    "    max_u_norm = np.max(u_norm)\n",
+    "    print('u_norm max', max_u_norm)\n",
+    "\n",
+    "    plt.plot(t, r, 'r--', label='r')\n",
+    "    plt.plot(t, y, 'b-', label='y')\n",
+    "    plt.plot(t, u_norm/max_u_norm, 'g-', label='u normalized')\n",
+    "    plt.gca().set_ylim(-0.1, y_max)\n",
+    "    plt.grid()\n",
+    "    plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.292673, 2.4607, 0.0101196]\n",
+      "1 states have been removed from the model\n",
+      "u_norm max 324.04247010257035\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "lqr_design(2, 1, tf=10, R=1e-5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here we see that the LQR is not able to design a reasonable pitch rate controller."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.292673, 2.4607, 0.0101196]\n",
+      "1 states have been removed from the model\n",
+      "u_norm max 61120.83319605678\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD4CAYAAAD8Zh1EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3de3SU9b3v8fc3k4SEW0DQcBUiRpEooAa8UDVo9xatq5Yej4o9rbW6WOxatXV3V9tu616n6+xttWfvtraWjYr2YotHsZZaL7WXqaJVQVGKXCMgRO7hlguBZPI9f8wkTu6TMMnkmfm81pqVeeb3zDPfX+aZT3555rmYuyMiIsGXleoCREQkORToIiJpQoEuIpImFOgiImlCgS4ikiayU/XCI0eO9IkTJ/bouTU1NQwaNIjt22HfPjj77OTW1h819TmTqM+ZQX3unrfffnufu5/YbqO7p+R27rnnek/95S9/cXf3O+5wLyjo8WICpanPmUR9zgzqc/cAK72DXNUmFxGRNKFAFxFJEwp0EZE0kbIvRUWkf6mvr6eiooK6uro+fd2CggLWrVvXp6+Zaon0OS8vj3HjxpGTk5PwchXoIgJARUUFQ4YMYeLEiZhZn71uVVUVQ4YM6bPX6w+66rO7U1lZSUVFBUVFRQkvV5tcRASAuro6RowY0adhLu0zM0aMGNHt/5YU6CLSTGHef/TkvVCgi4ikCQW6iEia6DLQzWyxme0xszVdzDfDzCJmdk3yyhORTOXuNDY2prqMQElkhP44MKezGcwsBHwPeCkJNYlIhtq6dStnnHEGX/7ylznnnHPYvn17qksKlC53W3T3V8xsYhez3QYsBWYkoSYR6Q/Kyto+du218OUvQ20tXHll2/YvfjF627cPrmn1z3o4nNDLbtiwgccee4yHHnqomwXLce+HbmZjgbnApXQR6GY2H5gPUFhYSDjBN7i16upqwuEwFRWn0tAwinB4eY+WEyRNfc4k6nPfKigooKqqqnk6PxJpM09DXR31VVVQW9tue31dHQ1VVVh1NXmt2o/ELTteJBJpft3q6mpOPvlkSkpKWtSSbuL73Jm6urrurQ8dnbUr/gZMBNZ00PYUcH7s/uPANYksU2db7B6dkS4zpLLPa9euTcnrHj58uPn+li1bvKSkJCV19KX4PnemvfeETs62mIwjRUuBJbF9JkcCV5pZg7s/m4Rli4hIgo470N29+bhUM3sceE5hLiLS97oMdDP7NVAGjDSzCuBeIAfA3Rf2anUiklEmTpzImjWd7iEtnUhkL5d5iS7M3b94XNWIiEiP6UhREZE0oUAXEUkTCnQRkTShQBcRSRMKdBGRNBHoQI8enCoiIhDwQAfQBVZERKICH+gikh7uuecefvjDHzZPf/vb3+ZHP/pRCisKnmScy0VE0sxXvwrvvpvcZU6fDj/4QcftN998M5/97Ge54447aGxsZMmSJbz11lvJLSLNKdBFpF+YOHEiI0aMYNWqVezevZuzzz6bESNGpLqsQFGgi0gbnY2ke9Mtt9zC448/zq5du/jSl76UmiICTNvQRaTfmDt3Li+++CIrVqzg8ssvT3U5gaMRuoj0G7m5ucyePZthw4YRCoVSXU7gKNBFpN9obGzkjTfe4Kmnnkp1KYGkTS4i0i+sXbuWU089lcsuu4zi4uJUlxNIGqGLSL8wZcoUNm/enOoyAk0jdBGRNKFAFxFJE10GupktNrM9Ztbuhf7M7HNmtjp2e93MpiW/TBER6UoiI/THgTmdtG8BLnH3qcB3gUVJqEtERLqpy0B391eA/Z20v+7uB2KTbwDjklSbiEi/Ew6HueqqqwBYtmwZ991333Evs6ysjJUrVx73cpK9l8vNwAsdNZrZfGA+QGFhIeFwuEcvUl1dTTgcpqLiVBoaCgmHX+vRcoKkqc+ZRH3uWwUFBVRVVfX560YikT573UgkctwHLNXW1tLQ0EBVVRWzZ89m9uzZ3a6/dZ8jkQg1NTVtllNXV9e99cHdu7wBE4E1XcwzG1gHjEhkmeeee6731F/+8hd3d7/9dvdhw3q8mEBp6nMmUZ/71tq1a1PyuocPH3Z39y1btnhJSUnz4w888IDfe++9bea/8cYb/bbbbvMLLrjAi4qK/KmnnnJ398bGRv/617/uJSUlfuaZZ/qSJUvcPfo7LSsr83nz5vkZZ5zhW7Zs8dNPP91vvvlmLykp8RtuuMFffvllv/DCC/3UU0/1N998093d33zzTb/gggt8+vTpfsEFF/j69eubl/epT33K3d0fe+wxv/XWW93dfdq0ac23vLw8D4fDXl1d7TfddJOXlpb69OnT/dlnn3V39927d/t1113nZ511ll977bU+c+ZMX7FiRZu+tveeACu9g1xNygjdzKYCjwBXuHtlMpYpIqnz1Re/yru7knv+3OmjpvODOck569fOnTtZvnw569ev59Of/jTXXHMNzzzzDO+++y7vvfce+/btY8aMGVx88cUAvPXWW6xZs4aioiK2bt1KeXk5Tz31FIsWLWLGjBn86le/Yvny5Sxbtox///d/59lnn2Xy5Mm88sorZGdn88c//pFvfetbLF26tMOa3o2db/h3v/sd999/PxdeeCH33nsvl156KYsXL+bgwYPMnDmTT37ykzz66KMMHDiQ1atXs3r1as4555yk/F6OO9DN7GTgGeDz7r7x+EsSEencZz7zGbKyspgyZQq7d+8GYPny5cybN49QKERhYSGXXHIJK1asYOjQocycOZOioqLm5xcVFXHWWWcBUFJSwmWXXYaZcdZZZ7F161YADh06xI033simTZswM+rr67usa9OmTfzLv/wLf/7zn8nJyeEPf/gDy5Yt4/vf/z4Q3YSybds2XnvtNe68804Apk6dytSpU5Pye+ky0M3s10AZMNLMKoB7gRwAd18IfAcYATxk0evBNbh7aVKqE5GUSNZIujuys7NpbGxsnq6rq+tw3gEDBjTf99jFhZt+tmfQoEEdPj8rK6t5Oisri4aGBiB6BaXZs2fzm9/8hq1bt1JWVtZp/TU1NVx77bU8/PDDjBkzprmmpUuXcvrpp7eZ33rh+pmJ7OUyz91Hu3uOu49z90fdfWEszHH3W9x9uLtPj90U5iLSbYWFhezZs4fKykqOHj3Kc889163nX3zxxTz55JNEIhH27t3LK6+8wsyZM3tcz6FDhxg7diwAjz/+eJfz33TTTdx0001cdNFFzY9dfvnlPPjgg81/bFatWgXArFmzeOKJJwBYs2YNq1ev7nGd8XSkqIj0Czk5OXznO9/hvPPO46qrrmLy5Mndev7cuXOZOnUq06ZN49JLL+X+++9n1KhRPa7nG9/4Bt/85jeZNWsWkUik03k//PBDnn76aRYvXsz06dOZPn06K1eu5J577qG+vp6pU6dy5plncs899wDRy+1VV1czdepU7r///uP6w9NCR9+W9vZNe7l0j/b4yAyZvJdLJkm0z93dy0UjdBGRNBHoQO/kOxARkYwT6EAXkeRyjZL6jZ68F4EP9F7Y80ckI+Xl5VFZWalQ7wfcncrKSvLy8rr1PF2xSEQAGDduHBUVFezdu7dPX7eurq7bwRV0ifQ5Ly+PceO6d65DBbqIANHdBuOPpuwr4XCYs88+u89fN5V6q8+B3+QiIiJRCnQRkTShQBcRSRMKdBGRNKFAFxFJEwp0EZE0oUAXEUkTCnQRkTShQBcRSRMKdBGRNNFloJvZYjPbY2ZrOmg3M/uRmZWb2WozS87lq0VEpFsSGaE/DszppP0KoDh2mw/89PjLEhGR7ury5Fzu/oqZTexklquBn8cujfSGmQ0zs9HuvjNJNXYs0gBHG+C/fgozZsAnPgFHjsDChc2z7Gms4oWG9Rw7dSIzZl3LtLyJ2GOPtV3W7NkwfTrs2we/+EXb9ssvhylTYMcOePLJtu1XXQXFxbB1K/zmN23bP/tZmDABNm6E3/++bft118GYMfD++/CHP7RpzjnllOidVasgHG77/JtvhqFD4a234LXX2rYvWAD5+bB8OaxY0bb99tshFII//xnee69lWygUbQd48UVYt65le14e/NM/Re//7ndQXt6yfejQaH0AS5fCtm0t20eMgC98IXp/yRLYGV11xpWXR/s7ejRcf320/ec/h8rKls+fMCH6+wV45BGoqmrZXlwcfX8AfvpTaH01+SlTou8vwA9/CHFXngei68Xs2dDQAA8+SBsdrHvNZs2CmTPh0CFYvLhte9y6N+6pp6J9jpfidY/Pfx5Gjuy9dW/q1OjPfrTuNeuNdW/UqOhye0EyzrY4FtgeN10Re6xNoJvZfKKjeAoLCwm3t3IkoLq6mnA4zL73hkLtRLjzTj684Qa2NDSQc+gQs+68E4A/FcFnr4PDecAaYM1/cPqAifzbE1u59n3Iijvt86bbb+ejuXMZtHkzM2LPj7furrvYPWcOQ9es4Zx22tccPsy+Sy5h+FtvMe2uu9q0v9fQwIEZMzjxr3+l5N/+rU37O7m5HC4pYdQLLzD5/vvbtDf8+MeEw2HGPvMMxe2Eyt9Gj+boqFGc/Mtfcsqjj7ZpX37KKTQUFFD08MNM+NWv2rT/9cwz8Zwcih98kLHPPtuirTEnh1diH7rJ//VfjGr1oa8fOpTXzjgDgJIHHuDEV19t0X5k1CjenDQJgKn33ccJK1e2aK8uKmLlyScDcPZ3v0vB2rUAnBprP1RSwqrYxX5n3Hsvg7ZubfH8/aWlrD7hBADO/9d/JW/37hbtey++mPcHDwZg1t13k3P4cIv2nXPmsGHAAAAu/vrXyWpoaNFeMXcu5WbYsWNc0s573966F2/zLbewrbaWvJ07Ob+d9hbr3kMPtWlP9bq3YtgwaoqKem3dq3nmGcLhcL9a95r0xrp3+IwzqL7//h7nX2cskZPZx0boz7n7me20/R74D3dfHpv+E/ANd3+7s2WWlpb6yla/3ESFw2HKysq4/dNb+eXvhrL/j6uio6C8vOjoqqqK3TV7OP1npYwfMo6fXf4Qw4cU8lJFmAfffJC1+9Zy7knTeeCi/83s8RdHF5qXBwMGQCQC1dVtXzQ/H3Jzo6O0mpq27QMHQk4O1NdDbW332wcNguxsOHYsOtJr3eeVKym77DI4erTtCBNgyBDIyoq2HT3a/fahQ6NXCzlyJFpDawUF0Z+1tdE+xDOLPh+iv5tWgdhle1ZWtD6I/u5jV1h/9dVXueiii6KjtNiHgqqqtiPo7Ozo7w/g8OG21ybsqj0nJ/r+QHQU3VpubvT9d48+v7UBA1qse91uj1v3Xn3hhWif46V43WPw4Oh70EvrXviddyibPbtfrXvNemPdC4Win+eysrZ9TYCZve3upe21JWOEXgGMj5seB+xIwnITEPvlDRkS/VBA9A0qKOD/vH4PtQ1HWDrvN5w24jQAFoyazPxz5/PE6if49p+/zaVLP82VxVdy32X3cVbBWdHnh0Ifr0Dtyc7uvD0n5/jac3Ojt9ZCoejPAQOit47k5X38u+hJe35+9NaRpuDrSNPK29P2pg8PEBk8uO3vqunD15GmD29P2zt7b8w6b4+tez1uD4Xa73OTVK17TXpr3Wu67Fg/Wvfa1dvrXhIkY7fFZcAXYnu7nA8c6pPt5xBd+UKhNm9UbX0tP3/v51xbcm1zmDfJsiw+P+3zbLxtI9/75Pd4bdtrTFs4jS/99ktUHK7ok7JFRHpDIrst/hr4G3C6mVWY2c1mtsDMFsRmeR7YDJQDDwNf7rVqWxszFoYWQElJi4df/uBlDh09xBenf7HDp+Zl5/GNWd9g8x2bufOCO3ni709Q/GAxd718F3tq9vRy4SIiyddloLv7PHcf7e457j7O3R9194XuvjDW7u5+q7tPcvez3L1nG8aT6KUPXmJQziAunnBxl/OekH8C3//H77PhKxu4Zso1PPD6A0z4wQRu/f2tbDmwpQ+qFRFJjmAfKfrRR3D4ELT6Zjq8NcwlEy8hN9TJ9sBWJg6byC/m/oJ1t67jc2d9joffeZjiB4uZ++RcXtj0ApHGSNcLERFJoWAH+tGj0W+l476Zrzpaxfp965k5ZmaPFnn6yNN55NOPsOWOLfzzBf/Ma9te48pfXcmkH03iu3/9LpsqNyWrehGRpAp0oDfvIdT0LTnw3u73cJxzx5x7XMseO3Qs3/uH77H9a9tZ8j+WMOmESXwn/B1O+/FpnPPf53Df8vvYsG8Diez2KSLSFwId6ACGtwj0d3e9C8A5o5NzSpkB2QO47szr+NMX/sS2r27jP//xPxmQPYBv/umbTP7JZE750SkseG4Bz65/loN1B5PymiIiPZGM/dD7lY2VGxmSO4TRg5N/aO34gvF87YKv8bULvsaHBz/khfIXeLH8RZ74+xP899v/jWFMOXEKs8bP4sLxF3LeuPMoPqGYUFYo6bWIiLQW7EDPy4sebBF3QMCm/ZsoHlGMxY3ae8OEYRNYULqABaULOBY5xuvbX+fVD1/l9YrXefL9J1n0ziIA8rPzKTmphGmF05haOJUzRp7BpBMmcXLByWRnBfvXLyL9S7ATZcwYGAoUf3z028bKjcwYM6NPy8gN5VI2sYyyiWUANHoj6/auY8WOFazevZrVu1fz2w2/5dFVH5/nIjsrmwkFE5h0wiQmDZ/E2CFjGT1kNGOGjGH04NGMHjKakQNHkmWB3yomMe5OxCM0eiON3oi74zjuHp3GqW6o5mDdwQ7bW993vNvzxjOiA5+mAVBfTJsZWZbVfDtw7ACVtZXN06GsUIv2kEWne3uQlg6CHeit1Efq+fDgh8w7c15K68iyLEpOKqHkpI8PeHJ3dlXvYkPlBj7Y/wEfHIjd9n/Aio9WcKDuQJvlZGdlMzxvOMPzhxM6FmLCRxOi03nDGZY3jMG5gxmYM5D8nHwG5gxsc8vLziM7K7vLW8hCLT4s8V/0Oi2/9G3dFmmMEPFI88+GxoY2j0UaY4+3eqyrtvf2vsfuNbvbLLf1a8Q/v1v3e2u5HdxvHaYdaueEhWnvb4nNFh/w7f0B6Kwtvj2UFUr4s5HIfN1dVk11DWWUJf3XGOxA37YNDg6B9bth8mR2Vu8k4hEmFExIdWVtmBmjh0RH3k0j+XhH6o+wq3oXO6t3srNqJzuqdrCrehf7j+znQN0BPtjxAZW1lWyq3MSBugPNo7i0t7brWdrT9AFq+uB2db/pw9be/bzsvC7n6c5ym8LFzDCsxf0PPviA04pPax7Jtm6Pv9800u3JvPDxH+emP9p9Nd30X0PTfyrrNqzj1FNPpdEbW/wH0+iNRBpbTce1d9bW3E77y2r6I9vQ2NDiVltf2+axplvTH+cO2z3xY1VuGH8Dt3BLN9boxAQ70Ovro2c/i52h7aPDHwHRXQ6DJj8nn6LhRRQNL2q3vekMk03cnaORoxypP0JtfW2b25GGIxypP9LuStverbWmf5WBNv/qxrc1BVV7QZZIW3zYtf656u1VnH/e+QkHb9P9IG+mCh8LU3Z+WarL6FPh6jBl55Wluozj1rRJLZHP29p3ejhS6UKwA73V5oCPqmKBPiR4gd5dZkZedh552XkMzx+e6nJ6xaHBh5hy4pRUlyGSEDMj27IT2tlhV+6uXqkhuEMZ+DjPYyPIII/QRUSOV7ADvUlToFd9xIDQAEbkj0hxQSIifS/YgT4odiWW2Innd1TtYMyQMdq9SUQyUrC3oY8eA0OACdErgeyr3ceJg05MbU0iIikS7BF6K/tq9zFy4MhUlyEikhLBDvQtm+HAfti4EYC9tXsV6CKSsYId6PUN0XPoxq7Uva92HyPzFegikpkSCnQzm2NmG8ys3Mzubqe9wMx+Z2bvmdn7ZnZT8kvttMDmA2o0QheRTJXIRaJDwE+AK4ApwDwza320x63AWnefBpQB/9fMEr/+WxJU1lYCKNBFJGMlMkKfCZS7+2Z3PwYsAa5uNY8DQyy6v+BgYD/Q9njy3mLG3tq9ANrLRUQyViK7LY4FtsdNVwDntZrnx8AyYAfRHQmvc2975igzmw/MBygsLCQcDvegZKiuriYcDrO3bjiencPrf/87fwt9CMDW9VsJ7+rZcvuzpj5nEvU5M6jPyZNIoLd3lE7rC2leDrwLXApMAl42s1fd/XCLJ7kvAhYBlJaWevzJprqj6URVS6eCrYELr7mGnWuXwmqYff5spo2a1qPl9metT86VCdTnzKA+J08im1wqgPFx0+OIjsTj3QQ841HlwBZgcnJKTMyho4cAKMgr6GJOEZH0lEigrwCKzawo9kXn9UQ3r8TbBlwGYGaFwOnA5mQW2q5Nm2D/figv51BdLNAHKNBFJDN1ucnF3RvM7CvAS0AIWOzu75vZglj7QuC7wONm9neim2jucvd9vVh3VGMEcHBvHqEPHTC0119WRKQ/SuhcLu7+PPB8q8cWxt3fAfxjckvrBjMO1R1icO5gQlmhlJUhIpJKgT5SNO7ylhw6ekibW0QkowU60JuZRQNdX4iKSAYLdqAXDMMGDIAhQzhUpxG6iGS2YJ8PfdSo6HGpJw3m0NFDOuxfRDJasEfocQ4fPawRuohktGCP0Netg8oTYUsV1ceqGZw7ONUViYikTHqM0M2oPlbNoJxBqa5ERCRl0iLQHag5VsOgXAW6iGSugAd6dEf0Y43HiHhEm1xEJKMFPNCjqhuOAGiTi4hktGAH+gkjIC+fmrxoN7TJRUQyWbD3cikshEFQkx/thja5iEgmC3agRyLgRs3RKkCbXEQkswV7k8uG9bB/P9U7o5ef0yYXEclkwQ702NkWa+prAY3QRSSzBTvQY2oi0b1ctA1dRDJZegR6Q2yErk0uIpLB0iLQq7XJRUQk4IF+4omQP5DaUATQCF1EMltCgW5mc8xsg5mVm9ndHcxTZmbvmtn7ZvbX5JbZgZNOgoEDORKKfjual53XJy8rItIfdbkfupmFgJ8A/wBUACvMbJm7r42bZxjwEDDH3beZ2Um9VXAL9fXQGKKuvpbcUC5ZFux/OEREjkciCTgTKHf3ze5+DFgCXN1qnhuAZ9x9G4C770lumR3YsB4O7OfI4QPkZ+f3yUuKiPRXiRwpOhbYHjddAZzXap7TgBwzCwNDgB+6+89bL8jM5gPzAQoLCwmHwz0oGaqrqwmHwxw8EAJGs3XHh2Q1ZvV4eUHQ1OdMoj5nBvU5eRIJdGvnMW9nOecClwH5wN/M7A1339jiSe6LgEUApaWlXlZW1u2CAcLhMGVlZTw97O8AFIwcRkFjAT1dXhA09TmTqM+ZQX1OnkQCvQIYHzc9DtjRzjz73L0GqDGzV4BpwEZ6VfTvSl3kqL4QFZGMl8g29BVAsZkVmVkucD2wrNU8vwUuMrNsMxtIdJPMuuSW2rG6yFFtQxeRjNflCN3dG8zsK8BLQAhY7O7vm9mCWPtCd19nZi8Cq4FG4BF3X9ObhQN44WgYOIgjfkwjdBHJeAmdPtfdnweeb/XYwlbTDwAPJK+0BJx4IjYQ6rxegS4iGS/YO24frYNIA0fqj5Cfo00uIpLZgh3oGzbCgQPUHa3RCF1EMl6wAz3mSEOdvhQVkYyXFoFeF6nTCF1EMl7AAz26H7pG6CIigQ/0KB1YJCKS4G6L/dbYcfjgfI40aC8XEZFgj9BHjICBIUDnQhcRCfYIvbYWJ3r5OQW6iGS6YAf6xo1Qkwso0EVEgr3JBfDQMQByQ7kprkREJLUCH+go0EVEgKAHujueHQ30AaEBKS5GRCS1gh3ooBG6iEhMsAN94gR8SA4AA7I1QheRzBbsQB9+AsR2btEIXUQyXbADvaqK6GVMFegiIsEO9PJNUHcQ0JeiIiIJBbqZzTGzDWZWbmZ3dzLfDDOLmNk1ySuxEw6efRTQCF1EpMtAN7MQ8BPgCmAKMM/MpnQw3/eIXky6jziE6gEFuohIIiP0mUC5u29292PAEuDqdua7DVgK7ElifZ3zj48U1V4uIpLpEjmXy1hge9x0BXBe/AxmNhaYC1wKzOhoQWY2H5gPUFhYSDgc7ma5UdXV1YTDYQ4fdsiLBvrbb71NRV5Fj5YXBE19ziTqc2ZQn5MnkUC3dh7zVtM/AO5y94hZe7PHnuS+CFgEUFpa6mVlZQmW2VI4HKasrIynzj6Ib1sDQNknyigcXNij5QVBU58zifqcGdTn5Ekk0CuA8XHT44AdreYpBZbEwnwkcKWZNbj7s0mpsgNeMAwGRABtQxcRSSTQVwDFZlYEfARcD9wQP4O7FzXdN7PHged6O8wBOHQQ9+j50BXoIpLpugx0d28ws68Q3XslBCx29/fNbEGsfWEv19ix8g8g7zCgL0VFRBK6wIW7Pw883+qxdoPc3b94/GUlyiF0DMMIWajvXlZEpB8K9pGigIfqyQ3l0tmXsSIimSDYge5A6Jg2t4iIEPRABzz7mL4QFREh6BeJPv00qDOdmEtEhKAH+pCheKReI3QREYK+yaWyEjiiQBcRIeiBvnkz3lirQBcRIeiBHjt9bk4oJ9WFiIikXMADHTyrgZwsBbqISLAD3dEIXUQkJtiBDpAVITsr2DvriIgkQ7ADvaQEz3VtchERIej7oQ8aBNagTS4iIgR9hL5nD84xjdBFRAh6oG/ZAnZUI3QREYIe6ABZDfpSVESENAh0z6rXJhcREYIe6O4Q0oFFIiKQYKCb2Rwz22Bm5WZ2dzvtnzOz1bHb62Y2Lfmlts+zdGCRiAgkEOhmFgJ+AlwBTAHmmdmUVrNtAS5x96nAd4FFyS60XdOmQXZEI3QRERIboc8Eyt19s7sfA5YAV8fP4O6vu/uB2OQbwLjkltmB/HzI0n7oIiKQ2IFFY4HtcdMVwHmdzH8z8EJ7DWY2H5gPUFhYSDgcTqzKVqqrqwmHw+xbfQJeVs+Oih09XlZQNPU5k6jPmUF9Tp5EAt3aeczbndFsNtFA/0R77e6+iNjmmNLSUi8rK0usylbC4TBlZWU8WfM3CNUzaeIkerqsoGjqcyZRnzOD+pw8iQR6BTA+bnocsKP1TGY2FXgEuMLdK5NTXufcHbIi2uQiIkJi29BXAMVmVmRmucD1wLL4GczsZOAZ4PPuvjH5Zbav0RoA9KWoiAgJjNDdvcHMvgK8BISAxe7+vpktiLUvBL4DjAAeMjOABncv7bCIiJUAAAX4SURBVL2yoxqzYoGuEbqISGJnW3T354HnWz22MO7+LcAtyS2ta40WAdCh/yIiBPxI0cazo7vDa5OLiEjQAz03Wr42uYiIBD3Qd24FNEIXEYGgB/qu6PFOGqGLiAQ80F1fioqINAt0oDfvtqhNLiIiAQ90tB+6iEiTQAd6RCN0EZFmgQ70xrNOAzRCFxGBgAe6x6rXl6IiIgEP9Mbd2wBtchERgaAH+v7dgDa5iIhAwAM9knUMgLzsvBRXIiKSeoEO9IbQUUCBLiICAQ90jdBFRD6mQBcRSROBDvSG4nEA5Gfnp7gSEZHUC3SgR6wO0AhdRAQSDHQzm2NmG8ys3MzubqfdzOxHsfbVZnZO8kttK3LgIwByQ7l98XIiIv1al4FuZiHgJ8AVwBRgnplNaTXbFUBx7DYf+GmS62xXQ20l1OcRuzC1iEhGS2SEPhMod/fN7n4MWAJc3Wqeq4Gfe9QbwDAzG53kWgF4+tXV3Pazh5n5hevZOGw11jCgN15GRCRwEjkJylhge9x0BXBeAvOMBXbGz2Rm84mO4CksLCQcDnezXHj6r++yZuxvmqdHVEzr0XKCprq6OiP6GU99zgzqc/IkEujtbc/wHsyDuy8CFgGUlpZ6WVlZAi/fUllZGQvC0+nJc4MsHA6rzxlAfc4MvdXnRDa5VADj46bHATt6MI+IiPSiRAJ9BVBsZkVmlgtcDyxrNc8y4AuxvV3OBw65+87WCxIRkd7T5SYXd28ws68ALwEhYLG7v29mC2LtC4HngSuBcqAWuKn3ShYRkfYkdGUId3+eaGjHP7Yw7r4Dtya3NBER6Y5AHykqIiIfU6CLiKQJBbqISJpQoIuIpAkFuohImlCgi4ikCQW6iEiaUKCLiKQJix4TlIIXNtsLfNjDp48E9iWxnCBQnzOD+pwZjqfPE9z9xPYaUhbox8PMVrp7aarr6Evqc2ZQnzNDb/VZm1xERNKEAl1EJE0ENdAXpbqAFFCfM4P6nBl6pc+B3IYuIiJtBXWELiIirSjQRUTSROAC3czmmNkGMys3s7tTXU9vM7PxZvYXM1tnZu+b2R2prqkvmFnIzFaZ2XOprqWvmNkwM3vazNbH3u8LUl1TbzKzr8XW6TVm9mszy0t1Tb3BzBab2R4zWxP32Alm9rKZbYr9HJ6M1wpUoJtZCPgJcAUwBZhnZlNSW1WvawD+2d3PAM4Hbs2APgPcAaxLdRF97IfAi+4+GZhGGvffzMYCtwOl7n4m0ctbXp/aqnrN48CcVo/dDfzJ3YuBP8Wmj1ugAh2YCZS7+2Z3PwYsAa5OcU29yt13uvs7sftVRD/kY1NbVe8ys3HAp4BHUl1LXzGzocDFwKMA7n7M3Q+mtqpelw3km1k2MBDYkeJ6eoW7vwLsb/Xw1cDPYvd/BnwmGa8VtEAfC2yPm64gzcMtnplNBM4G3kxtJb3uB8A3gMZUF9KHTgH2Ao/FNjU9YmaDUl1Ub3H3j4DvA9uAncAhd/9DaqvqU4XuvhOigzbgpGQsNGiBbu08lhH7XZrZYGAp8FV3P5zqenqLmV0F7HH3t1NdSx/LBs4BfuruZwM1JOnf8P4ots34aqAIGAMMMrP/ldqqgi9ogV4BjI+bHkea/psWz8xyiIb5E+7+TKrr6WWzgE+b2Vaim9QuNbNfprakPlEBVLh7039fTxMN+HT1SWCLu+9193rgGeDCFNfUl3ab2WiA2M89yVho0AJ9BVBsZkVmlkv0S5RlKa6pV5mZEd2uus7d/zPV9fQ2d/+mu49z94lE398/u3vaj9zcfRew3cxOjz10GbA2hSX1tm3A+WY2MLaOX0YafwncjmXAjbH7NwK/TcZCs5OxkL7i7g1m9hXgJaLfii929/dTXFZvmwV8Hvi7mb0be+xb7v58CmuS3nEb8ERssLIZuCnF9fQad3/TzJ4G3iG6J9cq0vQUAGb2a6AMGGlmFcC9wH3A/zOzm4n+cfufSXktHfovIpIegrbJRUREOqBAFxFJEwp0EZE0oUAXEUkTCnQRkTShQBcRSRMKdBGRNPH/AfyX335OGbyxAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "lqr_design(3, 1, tf=10, R=1e-5, y_max=1.5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here we see the LQR is doing a poor job of designing a pitch rate controller. This is likely because none of the\n",
+    "states provide derivative of the pitch rate signal to prevent overshoot."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "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.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/homework/AlexanderJChapa-F16.ipynb b/homework/AlexanderJChapa-F16.ipynb
new file mode 100644
index 00000000..d7eee0e3
--- /dev/null
+++ b/homework/AlexanderJChapa-F16.ipynb
@@ -0,0 +1,470 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline\n",
+    "\n",
+    "import sys\n",
+    "sys.path.insert(0, '../python/casadi_f16')\n",
+    "import f16\n",
+    "import control\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import scipy.linalg\n",
+    "\n",
+    "from analysis import loop_analysis, rlocus, bode\n",
+    "\n",
+    "plt.rcParams['figure.figsize'] = (10, 10)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Pitch-Rate CAS Design\n",
+    "\n",
+    "* Example 4.5-1\n",
+    "* pg. 310"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "p = f16.Parameters()\n",
+    "x0, u0 = f16.trim(x=f16.State(VT=550), p=p, phi_dot=0, theta_dot=0, psi_dot=0.0, gam=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Control(thtl=DM(0.166459), ail_cmd_deg=DM(0), elv_cmd_deg=DM(-0.807378), rdr_cmd_deg=DM(0))"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def f_control(t, x):\n",
+    "    Kalpha = 0.2\n",
+    "    return f16.Control(\n",
+    "        thtl=u0.thtl,\n",
+    "        ail_cmd_deg=u0.ail_cmd_deg,\n",
+    "        elv_cmd_deg=u0.elv_cmd_deg + 1*np.sin(2*np.pi*2*t),\n",
+    "        rdr_cmd_deg=u0.rdr_cmd_deg)\n",
+    "\n",
+    "f_control(0, x0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'angle of attack')"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "res = f16.simulate(x0, f_control, p, 0, 10, 0.01)\n",
+    "plt.plot(res['t'], np.rad2deg(res['x'][:, f16.State().name_to_index('alpha')]))\n",
+    "plt.xlabel('t ,sec')\n",
+    "plt.ylabel(r'$\\alpha$, deg')\n",
+    "plt.grid()\n",
+    "plt.title('angle of attack')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'trajectory')"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "res = f16.simulate(x0, f_control, p, 0, 20, 0.01)\n",
+    "\n",
+    "plt.plot(res['x'][:, f16.State().name_to_index('p_E')], res['x'][:, f16.State().name_to_index('p_N')])\n",
+    "plt.axis('equal');\n",
+    "plt.xlabel('East, ft')\n",
+    "plt.ylabel('North, ft')\n",
+    "plt.grid()\n",
+    "plt.title('trajectory')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def f_control(t, x):\n",
+    "    print(x)\n",
+    "    return f16.Control(\n",
+    "        thtl=u0.thtl,\n",
+    "        ail_cmd_deg=u0.ail_cmd_deg,\n",
+    "        elv_cmd_deg=u0.elv_cmd_deg + 1*np.sin(2*np.pi*2*t),\n",
+    "        rdr_cmd_deg=u0.rdr_cmd_deg)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def select(n, i):\n",
+    "    D = np.zeros((1, n))\n",
+    "    D[0, i] = 1\n",
+    "    return control.ss([], [], [], D)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "A = [[-1.11607665e+00  9.06007222e-01 -2.35158696e-03  0.00000000e+00]\n",
+       " [ 9.85813115e-01 -1.17939983e+00 -2.10904761e-01  0.00000000e+00]\n",
+       " [ 0.00000000e+00  0.00000000e+00 -2.02020000e+01  2.31497868e+03]\n",
+       " [ 1.00000000e+00  0.00000000e+00  0.00000000e+00 -1.00000000e+01]]\n",
+       "\n",
+       "B = [[    0.        ]\n",
+       " [    0.        ]\n",
+       " [-1157.48933772]\n",
+       " [    0.        ]]\n",
+       "\n",
+       "C = [[1. 0. 0. 0.]\n",
+       " [0. 1. 0. 0.]]\n",
+       "\n",
+       "D = [[0.]\n",
+       " [0.]]"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ss = f16.linearize(x0, u0, p)\n",
+    "s = control.tf([1, 0], [0, 1])\n",
+    "G = -(180/np.pi)*ss.sub_system(x=['alpha', 'Q', 'elv_deg'],\n",
+    "                  u=['elv_cmd_deg'], y=['alpha', 'Q']).to_control()\n",
+    "sys3 = control.feedback(G, 0.2*10/(s+10)*select(2, 0))\n",
+    "sys3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3 states have been removed from the model\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[-21, 0, -8, 8]"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEWCAYAAAB8LwAVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3deXhU5fn/8fedBQIJBAgQQSKLCgIhAkEFRSGg1hVKK4oKglYpdam1Vtv+7KbVb61ara1U6gouBUQUFKmiEqCoIKsBwiJC2JdAWBJC9vv3x0wwhJlkMtuZhPt1XXMxmbM8n5wznDtne46oKsYYY0x1UU4HMMYYE5msQBhjjPHICoQxxhiPrEAYY4zxyAqEMcYYj6xAGGOM8cgKhKkXRGSciCwO9riRRkQGi8hOp3MYA1YgjAkrEckRkcudzmGML6xAGFMHIhLjdAZjwsUKhIkYIvIbEflORPJFJFtERtQwrorIz0Vki4gcEJGnRSSq2jjPiMghEdkqIldX+fx2EVnvbmeLiPy0hnbGicgXIvKciOQBfxKRKBH5nYhsE5H9IvKGiCRWmWaYiKwTkcMiskBEurs/fxM4C/hQRApE5GEflkl39zwOu+c5rMqwJiLyN3eOIyKy2P3ZKYepqu65iMiFIrJcRI6KyD4Reba2HOb0ZAXCRJLvgEuBROBR4C0RaVfD+COAfkBfYDhwR5VhFwEbgdbAU8CrIiLuYfuB64DmwO3AcyLSt4Z2LgK2AG2BJ4Bx7lcG0AVIAF4AEJGuwFTgF0AbYC6ugtBIVccA24HrVTVBVZ+qaWGISCzwITDP3fZ9wNsi0s09yjNAOnAx0Ap4GKioaZ5uzwPPq2pz4GzgHR+mMachKxAmYqjqDFXdraoVqjod+Ba4sIZJ/qqqeaq6Hfg7cHOVYdtU9WVVLQemAO2AZHc7H6nqd+qyENcG+NIa2tmtqv9U1TJVPQ7cCjyrqltUtQD4LTDKffjpJuAjVf1UVUtxbcSb4NqI11V/XMXnSVUtUdX5wBzgZvfe0h3A/aq6S1XLVfVLVS32Yb6lwDki0lpVC1R1iR/ZzGnACoSJGCJym4isdh9OOQyk4toD8GZHlffbgPZVft5b+UZVC91vE9ztXC0iS0Qkz93ONXVoB3c726q1HYOrAJ00TFUr3NOfWcP8vWkP7HDPo2pbZ7rzxuHa66qrnwBdgQ0iskxErvNjHuY0YAXCRAQR6Qi8DNwLJKlqC2AtIDVMllLl/VnAbh/aaQzMxPWXfbK7nbm1tFO9y+PdQMdqbZcB+6oPcx/WSgF2eZlXTXYDKdXOrZzlntcBoAjXIaLqjgFNq2SIxnW4yxVA9VtVvRnXYau/Au+KSHwdcpnThBUIEynicW08c8F1IhnXHkRNHhKRliKSAtwPTPehnUZAY3c7Ze6T11fWMetU4AER6SwiCcD/AdNVtQzX8fxrRWSo+xzCg0Ax8KV72n24zlv4Yimujf3DIhIrIoOB64Fp7r2K14BnRaS9iESLyAB3AdwExInIte4Mv3P/zgCIyGgRaeOex2H3x+V1XAbmNGAFwkQEVc0G/gZ8hWsj2gv4opbJZgMrgNXAR8CrPrSTD/wc14b8EHAL8EEd474GvAksArbi+kv+Pvf8NwKjgX/i+iv/elwnpUvc0/4F+J37MNqvaslaAgwDrnbP61/Abaq6wT3Kr4A1wDIgD9feQJSqHgHuBl7BtbdxDKh6VdNVwDoRKcB1wnqUqhbVcRmY04DYA4NMfSQiCpyrqpudzmJMQ2V7EMYYYzxytECIyAPum3/WishUEYlzMo8xxpjvOVYgRORMXMeC+6lqKhANjHIqj6lfVFXs8JIxoeX0IaYYoIn7BqOm+HCZojHGmPBwrOMxVd0lIs/g6nrgODBPVedVH09ExgPjAZo0aZKekpJSfRSfVVRUEBXldE30zvL5L5KzgeULlOULzKZNmw6oapvax6xGVR15AS2B+bhu4IkFZgGja5omPT1dA5GZmRnQ9KFm+fwXydlULV+gLF9ggOXqx3bayZJ3ObBVVXPV1WfNe/jXX40xxpgQcLJAbAf6i0hTd3cEQ4H1DuYxxhhThWMFQlWXAu8CK3HdDRoFvORUHmOMMSdz9OlYqvpH4I9OZjDmdFZaWsrOnTtJTExk/frI3YG3fL6Ji4ujQ4cOxMbGBmV+9vhEY05jO3fupFmzZiQlJdG8eXOn43iVn59Ps2bNnI7hVSTkU1UOHjzIzp076dy5c1DmGbnXZRljQq6oqIikpCS+f9ieqa9EhKSkJIqKgtfvohUIY05ztRaHiRNh/37vw/fvd41jHBfsQm8Fwhjj3cSJcO+9kJHhuUjs3+8adu+9ViQaICsQxhjvRo6EHj0gO/vUIlFZHLKzXeOMHBmWSIMHD2b58uVhaet0ZwXCGONd27aQmXlqkaheHDIzXeOaBsUKhDGmZtWLRGqq6xWk4pCTk8N5553H2LFjSUtL44YbbqCwsJDPP/+cPn360KtXL+6++26Ki4tPmXbevHkMGDCAvn37MnLkSAoKCgL5TU01ViCMMbWrLBJt2kBuruvVpk3Q9hw2btzI+PHjycrKonnz5jz77LOMGzeO6dOns2bNGsrKynjxxRdPmubAgQM8/vjjfPbZZ6xcuZJ+/frx7LPPBpzFfM8KhDHGcSkpKVxyySUAjB49ms8//5zOnTvTtWtXAG655RYWLVp00jRLliwhOzubSy65hN69ezNlyhS2bdsW9uwNmd0oZ4ypXeU5h8o9B3C9z8gIyl6EP5dnqipXXHEFU6dODaht453tQRhjalb9hPTata6Xt6ub/LB9+3a++uorAKZOncrll19OTk4Omze7Hho4bdo0Bg0adNI0/fv354svvjgxTmFhIZs2bQoohzmZFQhjjHferlbydnWTn7p3786UKVNIS0sjLy+PBx54gNdff52RI0fSq1cvoqKimDBhwknTtGnThsmTJ3PzzTeTlpZG//792bBhQ6C/sanCDjEZY7ybMcP71UqVRaKygMyYAffc41czUVFRTJo06aTPhg4dyqpVqwBXX0eNGzcGYMGCBSfGGTJkCMuWLfOrTVM7KxDGGO8qN/gjR3o+z1BZJAIoDiZyWYEwxtSstg1/27YBFYdOnTqxdu1av6c3oWPnIIwxxnhkBcIYY4xHdojJGOO77dvhgw/g8GFo0QKGD4eUFKdTmRBxtECISAvgFSAVUOAOVf3KyUzGGA/27nV16f3++1BR8f3n998PI0bACy/AGWc4l8+EhNN7EM8DH6vqDSLSCGjqcB5jTHV798Ill8CWLRAb6yoI3brBxo0wezbMnAmrVsGXX0JystNpTRA5ViBEpDlwGTAOQFVLgBKn8hhjvLj3Xldx6NvXVRA6dPh+2M6drsNMK1e6rmR6992wRCovLyc6OjosbZ3OnDxJ3QXIBV4XkVUi8oqIxDuYxxhT3fbtrsNKsbGnFgdw/TxrFsTEuMbbsaNOs580aRK9e/emd+/edO7cmYyMDK9deHfq1InHHnuMgQMHMmPGDFavXk3//v1JS0tjxIgRHDp0KFi/tXETVXWmYZF+wBLgElVdKiLPA0dV9ffVxhsPjAdITk5OnzZtmt9tFhQUkJCQEEDq0LJ8/ovkbBC5+RITEznnnHO8/kUe++9/E/fQQ5QOH07Rm296nU/cmDHEzp5N0TPPUDp+fJ1zlJaWct111zFu3DimTJnCzJkziY+P57nnnqO4uJiHHnqI888/nzvvvJNf/OIXAAwYMICnn36agQMH8vjjj5Ofn89f//rXOrcdDJG0R7N582aOHDly0mcZGRkrVLVfXefl5DmIncBOVV3q/vld4DfVR1LVl4CXAPr166eDBw/2u8EFCxYQyPShZvn8F8nZIHLzrV+/nmbNmpGfn0+zZs1OHaGoCIDYnj2J9TS8Uo8eMHs2ccePE1fTeF7cfffdXHHFFbRv356NGzdy1VVXAVBSUsKAAQOIjo5GRLjtttto1qwZR44c4ejRo1x99dUAjB8/npEjR3r+HcLA6/JzQFxcHH369AnKvBwrEKq6V0R2iEg3Vd0IDAWyncpjjPGgRQvXvxs31jxeZS+qLVvWuYnJkyezbds2XnjhBT766COPXXjn5+cDEB9vR6HDyekb5e4D3haRLKA38H8O5zHGVDVsGERFue592LnT8zg7drjOT0RFucavgxUrVvDMM8/w1ltvERUV5XMX3omJibRs2ZL//e9/ALz55pundAduAufoZa6quhqo83ExY0yYnHWW67LWmTNdVyvNmnXyjXE7dsAPfwhlZfDjH9f5prkXXniBvLw8MjIyAOjXr9+JLrwrn0H9+OOP065du1OmnTJlChMmTKCwsJAuXbrw+uuv+/97Go+cvg/CGBPpXnjBdZ/DypXQpYurUHTt6jqsNHu2qzh06QITJ9Z51t426tW78M7PzycnJ+ekz3r37s2SJUvq3KbxnRUIY0zNzjgDvvji+zupZ878flhUlGvPYeJEu0muAbICYYyp3RlnuG6C27HDdT7i0CHXCelhw6wvpgbMCoQxxncpKfZgoNOI01cxNTz5e+Hrl51OYYwxAbMCEWwrJsPcX8G3nzqdxJjAidTtZRoUKxDBNvABaHMefPBzKDpS+/jGGBOhrEAEW0xjGP4vKNgL837ndBpjgkO15leQ/elPf+KZZ54J+nwrDR48mOXLl/v8uVMWLFjAdddd51j7ViBCoUM6DLgXVr4B3813Oo0xxvjFCkSoZPw/SDoHPrgfSo45ncaYiPXGG2+QlpbG+eefz5gxY04Zvnr1aoYMGXJKt97/+Mc/6NGjB2lpaYwaNQqAY8eOcccdd3DBBRfQp08fZs+eDcDx48cZNWoUaWlp3HTTTRw/frzWXFOnTqVXr16kpqby61//utbPExISePDBB+nbty9Dhw4lNzf3lHmOGzeOCRMmcOmll9K1a1fmzJkDQFFREbfffju9evWiT58+ZGZmnjKtt98tlKxAhEpsExj2TziyHRY60wWxMZFu3bp1PPHEE8yfP59vvvmG559//pRxbrvtNh577DGysrLo1asXjz76KABPPvkkq1atIisri0mTJgHwxBNPMGTIEJYtW0ZmZiYPPfQQx44d48UXX6Rp06ZkZWXxyCOPsGLFihpz7d69m1//+tfMnz+f1atXs2zZMmbNmuX1c3BtwPv27cvKlSsZNGjQiZzV5eTksHDhQj766CMmTJhAUVERE913oa9Zs4apU6cyduxYitw96Vby9ruFkhWIUOp4MfQZDV9NhH3rnE5jTMSZP38+N9xwA61btwagVatWJw0/cuQIhw8fZuDAgQCMHTuWRYsWAZCWlsatt97KW2+9RUyM65auefPm8eSTT9K7d28GDx5MUVER27dvZ9GiRYwePfrEdGlpaTXmWrZsGYMHD6ZNmzbExMRw6623smjRIq+fA0RFRXHTTTcBMHr0aBYvXuxx3jfeeCNRUVGce+65dOnShQ0bNrB48eITe0/nnXceHTt2PKWTQm+/WyjZjXKhdsWfYcNc+PAXcMcnrq4JjDEAqCri5+WxH330EYsWLeKDDz7gz3/+M+vWrUNVmTlzJt26dTtl/Lq04+1BanV5wJq39qp/LiI+zbem3y1UbGsVak1bwZWPw86vYdUbTqcxJqIMHTqUd955h4MHDwKQl5d30vDKbr2//PJL4PtuvSsqKtixYwcZGRk89dRTHD58mIKCAn7wgx/wz3/+88QGd9WqVQBcdtllvP322wCsXbuWrKysGnNddNFFLFy4kAMHDlBeXs7UqVMZNGiQ188BKioqeNf9TO7//Oc/J/Z6qpsxYwYVFRV89913bNmyhW7dup2Ub9OmTWzfvv2UQuDtdwsl24MIh963wOr/wKd/hG7XQkIbpxMZExF69uzJI488wqBBg4iOjqZPnz5Mnjz5pHGmTJnCXXfdxUMPPXSiW+/y8nJGjx7NkSNHUFUeeOABWrRowe9//3t+8YtfkJaWhqrSqVMn5syZw89+9jNuv/120tLS6N27NxdeeGGNudq1a8df/vIXMjIyUFWuueYahg8fDuDx8/z8fOLj41m3bh3p6ekkJiYyffp0j/Pu1q0bgwYNYt++fUyaNIm4uDjuvvtuJkyYQK9evYiJiWHy5Mk0btz4pOm8/W4hpar15pWenq6ByMzMDGj6gOzfoPpoK9XZ93odxdF8PojkfJGcTTVy82VnZ6uq6tGjRz2PUPsdECe/QsRrvghx9OhRjY+Pr3W8sWPH6owZM0KapXKdVgUsVz+2uXaIKVzadIMLfwor34Q93zidxhhjamUFIpwGPew6J/Hxb0Ny96kxQVfXfYjTWEFBQa3jTJ48mRtuuCEMaYLDCkQ4NWkBGY/Ati8gO/Q3uRjjCz3NN+wNSbDXpeMFQkSiRWSViIT4bEuE6DsW2vaET38PpUW1j29MCMXFxXHw4EErEg2AqnLw4EHi4uJO+vxIsf+dhkbCVUz3A+uB5k4HCYvoGLjqL/DGMFj6oqv3V2Mc0qFDB3bu3Mnhw4dP2bBEkqKiIsvng7i4ODp06HDSZ5O+meT3/BwtECLSAbgWeAL4pZNZwqrLIDj3Slj8d0i/3XXoyRgHxMbG0rlzZxYsWECfPn2cjuOV5fNPzpEcpm2Y5vf04uSupYi8C/wFaAb8SlVP6ddWRMYD4wGSk5PTp03z/5ctKCggISHB7+mDKSF/C/1WPMC2s0aytYurC4BIyudJJOeL5Gxg+QJl+fzz0v6X+LboW5aPXb5CVfvVeQb+XBsbjBdwHfAv9/vBwJzapqnX90F48s441cfbqebvU9UIzFdNJOeL5Gyqli9Qlq/uluxeoqmTU/XlrJfr5X0QlwDDRCQHmAYMEZG3HMwTfkN+B2VF8L+/OZ3EGNOAVGgFTy97mvbx7RnT49Qu1H3lWIFQ1d+qagdV7QSMAuar6min8jgi6WxXb6/LX4PDO5xOY4xpID7e+jEbD23k531/TuPoxrVP4IXjl7me9gY97LrB6Mt/OJ3EGNMAlFaUMnH1RM5teS5Xd746oHlFRIFQ1QXq4QT1aSGxA5w/Cla+QWzJYafTGGPquQ82f8D2/O3c1/s+oiSwTXxEFIjT3sAHoLyElB12d7Uxxn/F5cW8+M2LpLVOY3DK4IDnZwUiEiSdDT1H0H73XCjMq318Y4zxYMbGGewr3Md9fe/z+0FMVVmBiBQDf0lMeRF8/bLTSYwx9dDxsuO8vOZlLjzjQvq36x+UeVqBiBRnpHKwVT9Y9jKUFTudxhhTz7z37XvkFeVxd++7gzZPKxARZGeH6+FYLqx9z+koxph6pLS8lNfXvk7ftn1JT04P2nytQESQQy3Ph9bdYOmk075vfWOM7+ZsmcO+wn3clXZXUOdrBSKSiMBFP4U9q2HH106nMcbUA+UV5by69lW6t+rOJe0vCeq8rUBEmvNHQVyiqytwY4ypxafbP2Xb0W3clXZXUK5cqsoKRKRpFA99xsD6D+HYAafTGGMi3Jvr3qRj844MPWto0OdtBSIS9RkNFWXwjf9dmxtjGr6s3CyyDmRxy3m3BHzXtCdWICJR2+5wZj9Y9aadrDbGePXW+rdIiE1g+DnDQzJ/KxCRqs9oyN0Au1Y6ncQYE4H2HdvHpzmf8sNzfkh8bHxI2rACEalSfwQxTWDVG04nMcZEoHc2vUO5lnNL91tC1oYViEgVlwjdr4d1s6C81Ok0xpgIUlZRxvvfvs+lHS4lpVlKyNqxAhHJeo6AosOwZaHTSYwxEeSLXV+QezyXH53zo5C2YwUikp09BBo3h3XvO53EGBNB3vv2PVrFteKylMtC2o4ViEgWGwfdroENH0JZidNpjDER4MDxAyzauYhhZw8jNio2pG1ZgYh0PUdA0RHYaoeZjDEw57s5lGkZI84ZEfK2HCsQIpIiIpkisl5E1onI/U5liWhnZ0BsPGz8r9NJjDERYO7WufRM6kmXFl1C3paTexBlwIOq2h3oD9wjIj0czBOZYhpDl0Gw+VO7ac6Y09z2o9tZn7eeqzpdFZb2HCsQqrpHVVe63+cD64EzncoT0c69Ag5vhwObnE5ijKmj0tJSli5dSkVFRcDzmrdtHgBXdroy4Hn5QjQC/ioVkU7AIiBVVY9WGzYeGA+QnJycPm2a//0TFRQUkJCQ4H/QEPOWr3FRLgOW3Mnms+9gZ0pobqn3RSQvv0jOBpYvUPU53969e9mwYQNt27alR4/ADpI8uftJYiWWB9s9WKfpMjIyVqhqvzo3qKqOvoAEYAXwo9rGTU9P10BkZmYGNH2o1ZjvhYtUpwwLWxZPInn5RXI2VcsXqPqeb8mSJbp27dqA2th+ZLumTk7VKWun1HlaYLn6sX129ComEYkFZgJvq6o9Z7MmnS9zPUTI7qo2pt656KKL6NmzJwBr1qxh7969dZ7Hol2LABicMjiY0Wrk5FVMArwKrFfVZ53KUW90vBhKC2HPN04nMcb4qaysjPnz5/Paa6+xaVPdziku3rWYjs07clbzs0KU7lRO7kFcAowBhojIavfrGgfzRLaOF7v+3falszmMMX6LiYnh9ttvJykpialTp7JkyRKfpjtedpxle5dx6ZmXhjjhyZy8immxqoqqpqlqb/drrlN5Il5CW2h1thUIY+q55s2bc/vtt9O1a1c+/vhj5s6dW3k+1qtle5dRXF58+hQI44ezBsCOpXY/hDH1XKNGjbjpppsYMGAAcXFxtT5Levne5cRExdA3uW+YErrEhLU1E5j2vWH1W3B0FyR2cDqNMSYAUVFR/OAHPzix97Br1y7i4+Np0aLFKeOu2L+C1KRU4mLiwpsxrK2ZwJyR5vp3T5azOYwxQSMilJeXM3PmTF5++WV27dp10vDjZcfJPpgd9r0HsAJRvyT3BAT2WoEwpiGJjo5m1KhRxMbG8vrrr5OdnX1i2NoDaymrKCM9OT3suaxA1CeNEyDpHNuDMKYBatu2LXfeeSdnnHEG77zzDosXL0ZV+SbXdWn7+W3OD3smKxD1TXJP2J9d+3jGmHonISGBsWPH0rNnT3bu3ImqsjFvI2cmnEli48Sw57GT1PVN0tmwYY7rjuro0D4sxBgTfrGxsfz4xz+mvLycqKgotu7bSrfEbo5ksT2I+qbV2VBRBkd2OJ3EGBNMIideUdHRxDZqhIpw5actOefDcvJatTppnHCwAlHftHI/JOTgFmdzGGNCToAr582jsGlTXr7zTralpIS1fSsQ9U1lgcizAmFMg6R64jXnuw+5/rHmXPmzm2nSoQNv3HUXWampYYtiBaK+SWgL0Y1cN8sZYxq0PQV7AOjWoRt33nknHTp0YPHAgZRHhWfT7dNJahFp5eHjfFW1vqfDTQTi20LBfqeTGGNCbPex3bSKa0XT2KYQC2PGjOH4ffcRXVFBSUkJIkJsbOguVvG1DK0EcoFNwLfu91tFZKWIhP/ujdNdQlso2Od0CmNMiO0u2E27+HYnfo6JiaHZsWMoMGvWLN544w2OHTsWsvZ9LRAfA9eoamtVTQKuBt4B7gb+FapwxouEZDhmexDGNHS7C3bTPqH9KZ8L0KNHD3bv3s0rr7xCbm5uSNr3tUD0U9VPKn9Q1XnAZaq6BGgckmTGu/jWUBCaL4QxJnLkFeWRFJfkcVhqairjxo2jpKSEV199lS1bgn/hiq8FIk9Efi0iHd2vh4FDIhINVAQ9lT+qXh/s5TU4IyOs1xCHTONmUBK63UpTBz5870767gHs3w8TJzqb2wTfxImudetNHde7qnKs9BjNGjXzOk5KSgp33nknzUpLee/ddykpKfE4XqyfN0X7WiBuAToAs4DZwFnuz6KBG/1p2AQgtimUHrPnQtRH+/dDRgbce68ViQak/fvvu9ZpRobnIuHHej9edpxyLSehUUKN47X8z3/4yRNPcOvs2TQ6fBhVpaKiyt/t+/fTDfy6FdunAqGqB1T1PlXt437y272qmquqJaq62Z+GQ6pHD9i37/vrifftc33WUDRqCloBZcVOJzGVPH3Xqn4PK2VkQHa2a9jIkc5kNUGXO3iwa51mZ59aJCqLg6/r3b3X2bRRPGvGreWOXj+p+Q7qkSOJO/ts2n35JWRksHDuXN6t3Jtwt90Y/HqQhE8FQkTaiMjTIjJXROZXvvxpsNp8rxKRjSKyWUR+E+j8gFNXUpWVc6xjx6A04bjYpq5/SwudzWFO1bYtZGZ631hUbiQyM13jmgahtGVLz+u9enEIxXqv9p1r9PLLZGdnM+WVV8i/6irIzqYYivyZta+HmN4GNgCdgUeBHGCZPw1Wcp+/mIjriqgewM0iEvif+VVXUmqq6+VeOaufey7g2UeEOPcTp6aPgY0fQ0VknAYybtWLRNU7X604NFye1nuV7U9t610rKsg+sI6nv36KodOH0GtyKgPe7s/mvG9Purv6xMtL2xfPns2ouXPZv2sXr1x2Gfv692cjbPTnV/L1xEWSqr4qIver6kJgoYgs9KfBKi4ENqvqFgARmQYMBwLry9q9oCpSU4lyX/qV36wlf77772zJKecS92g/e2tFQM2EQm5uEdN3es91ZosmjL24EympP4LCA7BkEky9CZLOhbbdQ56vZ24u7Hs15O34w/Fs08ec+tn9PeCh76DqJYhWHBq2yg11auqJ9Z7foglPP34pBdlP1rh123x4M1uPbCUmKoaBZw7koS4PMbjD4BOPGdWyMgoWLyb/k3lUeLn3IWrAxSRv3cp5y5Zx+44dTL31ViYPG0bpkiVl/vw6vhaIyjum94jItcBuXCetA3EmULVL0p3ARdVHEpHxwHiA5ORkFixY4HFmg93/LliwgNhDh+hXUnri+tuyigrW7cglr2nzE+Nn5UTejWYVFRXsOeY5lwLzjimvfbGVi86I5pouPTmr9/O0yf2C9rs/IXbb6pDna1xRwbHCyOziw6ls8e5/j3la/gVlNC0vo+pR4y+++MJ1OCLCFBQUeP2/FQnqU77YQ4e4oLSURu5h5RVlbNi7gcPHG3mdHqBZdDNGtRpF76a9iY+KhxxYkrOE6N27afLVV8Qt/Zroo0epiI+nIrG5x3lEl5TQtsxVC9rv3cvY6dNZ9Nhj/v9iqlrrC7gOSARSgUxgBTDMl2lrmFOjPS0AABS3SURBVOdI4JUqP48B/lnTNOnp6epV5Y7Xvn2qPXq43rdp43qBao8euvi9974fLwJlZmbWOHz34UJ9fM467fH7/+rZv/1IDx0rDk8wt9ryOcmxbN6+T9W/h5Xj9ejhGhZhInndqtajfDVsf+q63suOHtWtN43S7G7naXbPVN1+zz169LPPtKLYy//7GtqOhdXqx3bapz0IVZ3jfnsEyPC/HJ1kJ1C179oOuPZMAlP9hFCVz3o/8EDAs3dSu8QmPHJtD9q3aMKjH2ZTYVe5RiZPJyaTk13DKk9g2qGmhsfTeofvP6vjei/ds4fjq1fT4qabaPPz+4hJ8nzDnC9th/QyVxHpLCLPish7IvJB5cufBqtYBpzrnncjYBQQ6DxPPSFU5eRN/LZtAc8+EhwvLQegSWy0w0nMKWq7asXb1U2mXos9dMjzeq/tqraqqt1cGdetG903bqDdY48S07r1qTdgVvL2navStr+Xufp6DmIW8CrwIUG6c1pVy0TkXuATXDfcvaaq64Ixb7Kzv/+LrQEqKilHBOJirbf2iOHp+nRP38PMzO//M8+YAffcE558JqTaLFjg/Y+Cyg11qNb7jBm1tl2cnOzXZa6+FogiVf2HPw3URFXnAnODPd+GrrCknCax0Uh97zLkdFS5sbDi0KDsHjGCrl27um6C83QIqS7r3X0Jq1ZUsKFnKkkTfkrb++//fnj1//eV86uhbX8vc/X1T9DnReSPIjJARPpWvvxpMGQ8XSdc7bUgM9PzNcT1zLGScpo2ssNLEcGH791J3z1w/Se24tDw3HNPzecX6rjeJSqKqIQEKvILAm67FEJ6mWsvXFcZDeH7Q0zq/tmEWd6xYpLirRNdYxq66JYtKc/Lc6x9XwvECKCLqnruKtCEVW5+MW2aWYEwpqGLbdeO0t2BX9zpL18PMX0DtAhlEOO73IJiWifUfNONMab+iz3zTEcLhK97EMnABhFZBpzoQlRVh4UklfFKVTmQX2J7EMacBmLbt6ds/34qSkqIahT+Pwp9LRB/DGkK47Mjx0s5XlpOcnO/Lms2xtQjse1djxst27OHRg70Ru3rndSBdsxngiTnoKuL705J8bWMaYyp7xp16gRA8ZYtkVcgRGSxqg4UkXxcVy2dGISr/xnPPUaZkMk54OrFsVPrpg4nMcaERJX7HJoC3QGGOHPBaI0FQlUHuv/1/lBUE1Y5B48hAh1aWoEwxoSW9dVQz2w7WEj7xCbEWT9MxjQsXm6y3HHPPXx39TU1PzAoRKxA1DMb9uZzdtuaH2JujGk44rp2oyQnh4rC8D9i2ApEPVJcVs63+/Lp2d5O/RhzumhyfhpUVHA8KyvsbVuBqEe+3VdAWYVagTDmNNKkTx8QoXBF+B+TbAWiHlm3+wgAPdsnOpzEGBMu0c2b07hbN45bgTA1WbvrKPGNounYyq5gMuZ00rRvXwpXf4OW+dUpq9+sQNQjy7cdovdZLYiKsudAGHM6aXrhBWhhYdjPQ1iBqCeOHC9lw96jXNiphufSGmMapPgBAyA6moJFi8LarhWIemLFtjxU4YLOLZ2OYowJs+jERJr06X16FAgReVpENohIloi8LyLWlXgtvt56iNhooU+KFQhjTkcJlw2iOHs9pfv2h61Np/YgPgVSVTUN2AT81qEc9cZXWw7S68xEmtijRo05LSUMugyAgkXh6zvVkQKhqvNUtfJ0/BKggxM56ouDBcVk7TzMoK41PO/WGNOgNe7aldiUFPI//iRsbYqGqU8PrwFEPgSmq+pbXoaPB8YDJCcnp0+bNs3vtgoKCkhIiNxuKrzl+3J3GS9lFfOHAXF0SXRuDyKSl18kZwPLFyjL55Lw/iyafvopuU/9Fa1DexkZGStUtV+dG1TVkLyAz4C1Hl7Dq4zzCPA+7kJV2ys9PV0DkZmZGdD0oeYt38+nrtS+j83T8vKK8AaqJpKXXyRnU7V8gbJ8LsfXrdPsbudp3rTpdZoOWK5+bMd9faKcP4Xn8pqGi8hY4DpgqPsXMB6UVygLN+UypFtbu//BmNNc4+7dadSxI0c//i8tb7ox5O05dRXTVcCvgWGqGv4uCuuR5Tl5HC4sJeM8O/9gzOlORGh2zdUULv2a0r17Q96eU1cxvQA0Az4VkdUiMsmhHBHvozV7iIuNYogVCGMM0GLECKio4MisWSFvK2SHmGqiquc40W59U16hzF2zl4xubYlv7MiqMsZEmEZnnUXTCy/k8Mz3SBo/HokK3d/5did1BPt6ax4HCoq5Nq2d01GMMRGkxQ0/pnTHDgq/XhbSdqxARLCP1uy2w0vGmFM0u/JKopo14/DMmSFtxwpEhCoqLefDb/Zwefdkmjayw0vGmO9FxcWReP315H/8MWUHD4aunZDN2QTks/X7OHK8lBv7pTgdxRgTgVqOHo2WlnJo+vSQtWEFIkK9s3wn7RPjuOSc1k5HMcZEoMZdOhN/6aUcmjoVLSkJSRtWICLQrsPH+d+3udzQL4VouznOGONFqzGjKc89wNFP5oVk/lYgItC7y3eiCiPTrQ9DY4x38QMH0qhTJ/LefJNQdEhhBSLClJZXMPXr7Vx6bmtS7NnTxpgaSFQUrcbeRlFWFoXLgn/JqxWICPPx2r3sPVrEuIs7OR3FGFMPJI4YQXTr1hyc9O+gz9sKRISZ/GUOHZOaktHN7n0wxtQuKi6OpHFjOfbllxxfsya48w7q3ExAth4pZ8W2Q9w2oJP13GqM8VmLUTcT1bw5B/4d3L0IKxAR5NNtZcQ3imZkPzs5bYzxXXRCPK1Gj6bgs88p/vbboM3XCkSE2HmokKV7yhjZL4XmcbFOxzHG1DMtx4xGmjblwIsvBm2eViAixMuLtgAw/rIuDicxxtRHMS1b0mrMGI7O/S9FGzYEZZ5WICJAbn4x05bt4OL2MbRv0cTpOMaYeirpjtuJat6c3L8/H5T5WYGIAK8u3kppeQXXdrFDS8YY/0UnJpL0k59QsGABhatWBTw/KxAOO1JYyltLtnFtWnvOiLfVYYwJTKsxo4lOSiL3ub8HfHe1bZEc9tL/vqOguIx7Ms52OooxpgGIatqU1j/9KYVff82xL78MbF5ByuQXEfmViKiInJZdlu7PL+K1xTlcf357zjujudNxjDENRItRNxHTvh37n/kbWl7u93wcKxAikgJcAWx3KoPT/pX5HSXlFfzyiq5ORzHGNCBRjRrR9pcPUrx+PUdmzfZ/PkHMVFfPAQ8Dwe+CsB7YkVfI20u3cWO/FDq3jnc6jjGmgWl+7TU0Of989v/9Ob/nIaHoIrbWRkWGAUNV9X4RyQH6qeoBL+OOB8YDJCcnp0+bNs3vdgsKCkhISPB7+mB6OauYpXvLeOqyJrSKc9XpSMrnSSTni+RsYPkCZfn8E7tlC62eepoeGzesUNV+dZ6BqobkBXwGrPXwGg4sBRLd4+UArX2ZZ3p6ugYiMzMzoOmDJXv3Ee38mzn6+Jx1J30eKfm8ieR8kZxN1fIFyvL5b+cDv1RgufqxHQ/ZISZVvVxVU6u/gC1AZ+Ab995DB2CliJwRqiyRRFV57MNsmjeJ5Z6Mc5yOY4xp4No++Eu/p40JYg6fqOoa4ERf1rUdYmpoPlm3j6+2HOSx4T1p0bSR03GMMQ1c7Jln+j2t3QcRRsVl5fzf3PV0TU7glgvPcjqOMcbUKOx7ENWpaienM4TL61/ksD2vkDd/ciEx0VabjTGRzbZSYbL/aBEvzN/M0PPacum5bZyOY4wxtbICESaPzcmmpLyC313Xw+koxhjjEysQYbBwUy5zsvZwz+Bz7KY4Y0y9YQUixIpKy/n9rLV0aR3PhMH2MCBjTP3h+Enqhm5i5ma25xXynzsvonFMtNNxjDHGZ7YHEUKb9+czaeF3jOhzJhefc1p2WGuMqcesQIRIeYXym5lraBIbzSPXdnc6jjHG1JkViBCZ8mUOy7cd4g/X96R1QmOn4xhjTJ1ZgQiBbQeP8dQnGxjcrQ0/7uv/be7GGOMkKxBBVlGhPPxuFrFRUfzlR70QEacjGWOMX6xABNnbS7exdGsej1zbnXaJTZyOY4wxfrMCEWTnp7Rg7ICO3HRBitNRjDEmIHYfRJCldWhBWocWTscwxpiA2R6EMcYYj6xAGGOM8cgKhDHGGI+sQBhjjPHICoQxxhiPHCsQInKfiGwUkXUi8pRTOYwxxnjmyGWuIpIBDAfSVLVYRNo6kcMYY4x3Tu1B/Ax4UlWLAVR1v0M5jDHGeOFUgegKXCoiS0VkoYhc4FAOY4wxXoiqhmbGIp8BZ3gY9AjwBDAfuB+4AJgOdFEPYURkPDAeIDk5OX3atGl+ZyooKCAhIcHv6UPN8vkvkrOB5QuU5QtMRkbGClXtV+cJVTXsL+BjYHCVn78D2tQ2XXp6ugYiMzMzoOlDzfL5L5KzqVq+QFm+wADL1Y9ttVOHmGYBQwBEpCvQCDjgUBZjjDEeONVZ32vAayKyFigBxrqrnDHGmAjhSIFQ1RJgtBNtG2OM8Y3dSW2MMcYjKxDGGGM8sgJhjDHGIysQxhhjPLICYYwxxiMrEMYYYzyyAmGMMcYjKxDGGGM8sgJhjDHGIysQxhhjPLICYYwxxiMrEMYYYzyyAmGMMcYjKxDGGGM8sgJhjDHGIysQxhhjPLICYYwxxiMrEMYYYzyyAmGMMcYjRwqEiPQWkSUislpElovIhU7kMMYY451TexBPAY+qam/gD+6fjTHGRBCnCoQCzd3vE4HdDuUwxhjjhahq+BsV6Q58AgiuInWxqm7zMu54YLz7x27AxgCabg0cCGD6ULN8/ovkbGD5AmX5AtNNVZvVdaKQFQgR+Qw4w8OgR4ChwEJVnSkiNwLjVfXykAQ5OdNyVe0X6nb8Zfn8F8nZwPIFyvIFxt98MaEIA1DTBl9E3gDud/84A3glVDmMMcb4x6lzELuBQe73Q4BvHcphjDHGi5DtQdTiLuB5EYkBivj+HEOovRSmdvxl+fwXydnA8gXK8gXGr3yOnKQ2xhgT+exOamOMMR5ZgTDGGONRgysQIvK0iGwQkSwReV9EWlQZ9lsR2SwiG0XkB16mbyUin4rIt+5/WwYx20gRWSciFSLSr8rnt7q7Hal8VYhIbw/T/0lEdlUZ75pgZaslXycROV6l3Ulepg/Zsqsl3xUiskJE1rj/HeJlekeWn3uYo989D21Nr7IcckRktZfxctzLdbWILA9VHg/t+rSuROQq9zLdLCK/CWM+r9uZauOFbfnVtizE5R/u4Vki0rfWmapqg3oBVwIx7vd/Bf7qft8D+AZoDHQGvgOiPUz/FPAb9/vfVE4fpGzdcd3stwDo52WcXsAWL8P+BPwqhMvOYz6gE7DWh+lDtuxqydcHaO9+nwrsirDl5/h3r5bcfwP+4GVYDtA6HDnquq6AaPey7AI0ci/jHmHK53E749Ty82VZANcA/8V1g3J/YGlt821wexCqOk9Vy9w/LgE6uN8PB6aparGqbgU2A546CRwOTHG/nwL8MIjZ1qtqbXeC3wxMDVabdeFjvpqEbNmB93yqukpVK7trWQfEiUjjYLbtixqWn+PfPW9ERIAbceg7F6ALgc2qukVVS4BpuJZhyNWwnXGKL8tiOPCGuiwBWohIu5pm2uAKRDV34KqYAGcCO6oM2+n+rLpkVd0D4P63bUgTnuomav7Peq979/C1UB6C8KCziKwSkYUicqmXcZxedgA/BlaparGX4U4sv0j+7l0K7FNVb/ciKTDPfeguXJejV6ptXfm6XEOt6namunAtP1+WRZ2Xl1P3QQREaujGQ1Vnu8d5BCgD3q6czMP4Qb/G15dsNUx7EVCoqmu9jPIi8Gdcuf+M69DAHWHItwc4S1UPikg6MEtEeqrq0bq0HcJ8ldP2xLW7f6WXUZxafmH57p3SqG9Za9tjvURVd4tIW+BTEdmgqotCnQ/f1lVIl6uf25nqQrb8qsf18Fn1ZVHn5VUvC4TW0m+TiIwFrgOGqvvgG65qmVJltA547kV2n4i0U9U97t2v/cHMVotR1PCfVVX3Vb4XkZeBOXVtwJ987r/Gi93vV4jId0BXoPpJt4CWnb/5AESkA/A+cJuqfudl3o4sP8L03avOh/8nMcCPgPQa5rHb/e9+EXkf16GMoGzgfF2WNawrX5erX/zczlSfR8iWXzW+LIs6L68Gd4hJRK4Cfg0MU9XCKoM+AEaJSGMR6QycC3ztYRYfAGPd78cCNf7VGiwiEgWMxHXs0Ns4VY8XjgC87WkElYi0EZFo9/suuJbdFg+jOrXsWgAfAb9V1S9qGM+R5UfkfvcuBzao6k5PA0UkXkSaVb7HtWcWru+cL+tqGXCuiHQWkUa4/sD6IEz5vG1nqo4TzuXny7L4ALjNfTVTf+BI5SFNr0J9dj3cL1wnAHcAq92vSVWGPYLrTP9G4Ooqn7+C+6oTIAn4HFf/UJ8DrYKYbQSuKl4M7AM+qTJsMLDEwzRVs70JrAGy3Cu7XZCXncd8uI7rr8N1ZcRK4PpwL7ta8v0OOFZlna8G2kbK8ouE756XvJOBCdU+aw/Mdb/v4l7n37jX/yOhzFMth8d1VTWf++drgE3uZRvOfB63M04uP0/LAphQuY5xHWKa6B6+Bi9XUlZ9WVcbxhhjPGpwh5iMMcYEhxUIY4wxHlmBMMYY45EVCGOMMR5ZgTDGGOORFQhjwkBEJovIDU7nMKYurEAYU0fuG43s/45p8OxLbowPxPVMjPUi8i9cNwuOEZGvRGSliMwQkQT3eH8QkWUislZEXnL3lmpMvWQFwhjfdQPeAK4AfgJcrqp9cfVJ9Uv3OC+o6gWqmgo0wdVXjzH1Ur3srM8Yh2xT1SUich2uhwB94d5BaAR85R4nQ0QeBpoCrXB1sfChE2GNCZQVCGN8d8z9rwCfqurNVQeKSBzwL1x93OwQkT8BceGNaEzw2CEmY+puCXCJiJwDICJNRaQr3xeDA+5zEnbVkqnXbA/CmDpS1VwRGQdMrfJo09+p6ib3swvW4HoW8TKHIhoTFNabqzHGGI/sEJMxxhiPrEAYY4zxyAqEMcYYj6xAGGOM8cgKhDHGGI+sQBhjjPHICoQxxhiP/j89DRjSK5BtRwAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from analysis import rlocus\n",
+    "H = (10/(s+10))*select(2, 0)\n",
+    "plt.figure()\n",
+    "kalpha = 0.1\n",
+    "rlocus('alpha', control.minreal(H*G), kvect=np.linspace(0, 10, 1000), k=kalpha);\n",
+    "plt.plot([0, -2], [0, 2], '--')\n",
+    "plt.axis([-21, 0, -8, 8])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7f5919c28748>]"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure()\n",
+    "sys3 = control.feedback(G, kalpha*(10/(s+10))*select(2, 0))\n",
+    "rlocus('p', (s+3)/s*sys3[1, 0], kvect=np.linspace(0, 1, 1000), k=.6)\n",
+    "plt.plot([0, -10], [0, 10*np.cos(0.707)], '--')\n",
+    "#plt.axis([-20, 0, -5, 5])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$$\\frac{s + 3}{s}$$"
+      ],
+      "text/plain": [
+       "\n",
+       "s + 3\n",
+       "-----\n",
+       "  s"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "H_PI = 1 + 3*(1/s) + 0*s\n",
+    "H_PI"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$$\\frac{244.1 s^3 + 3449 s^2 + 1.09e+04 s + 8254}{s^5 + 32.5 s^4 + 271.8 s^3 + 479.2 s^2 + 309.9 s}$$"
+      ],
+      "text/plain": [
+       "\n",
+       "    244.1 s^3 + 3449 s^2 + 1.09e+04 s + 8254\n",
+       "------------------------------------------------\n",
+       "s^5 + 32.5 s^4 + 271.8 s^3 + 479.2 s^2 + 309.9 s"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "Go = H_PI*sys3[1,0]\n",
+    "Go"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Gc = control.feedback(Go,1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7f5917675828>]"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "t,y=control.step_response(Gc, T=np.linspace(0, 10, 1000))\n",
+    "plt.plot(t,y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "TypeError",
+     "evalue": "bode() got an unexpected keyword argument 'Hz'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-20-56a265ca8417>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mbode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'test'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0msys3\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0momega\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlogspace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmargins\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mHz\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;31mTypeError\u001b[0m: bode() got an unexpected keyword argument 'Hz'"
+     ]
+    }
+   ],
+   "source": [
+    "bode('test', (s+3)/s*sys3[1, 0], omega=np.logspace(-2, 4), margins=True, Hz=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "control.nyquist(Go);\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "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.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/lectures/4-Casadi-Transport.ipynb b/lectures/4-Casadi-Transport.ipynb
index 98b9480a..dc985e58 100644
--- a/lectures/4-Casadi-Transport.ipynb
+++ b/lectures/4-Casadi-Transport.ipynb
@@ -30,7 +30,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -284,7 +284,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/home/jgoppert/anaconda3/envs/aae497-f19/lib/python3.7/site-packages/control/xferfcn.py:896: ComplexWarning: Casting complex values to real discards the imaginary part\n",
+      "/home/alexander/anaconda3/envs/aae497-f19/lib/python3.7/site-packages/control/xferfcn.py:896: ComplexWarning: Casting complex values to real discards the imaginary part\n",
       "  num[i, j, np + 1 - len(numpoly):np + 1] = numpoly[::-1]\n"
      ]
     },
diff --git a/lectures/AJC-MSD.ipynb b/lectures/AJC-MSD.ipynb
new file mode 100644
index 00000000..659c3b32
--- /dev/null
+++ b/lectures/AJC-MSD.ipynb
@@ -0,0 +1,181 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import casadi as ca"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$m\\ddot{x} + c\\dot{x}+k x = u$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$\\vec{x} = \\begin{bmatrix} x \\\\ \\dot{x} \\end{bmatrix}$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$\\vec{u} = \\begin{bmatrix} u \\end{bmatrix}$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$\\vec{y} = \\begin{bmatrix} x \\end{bmatrix}$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$\\ddot{x} = (-c \\dot{x} - k x + u)/m$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$\\vec{\\dot{x}} = f(\\vec{x}) =  \\begin{bmatrix} \\dot{x} \\\\ (-c \\dot{x} - k x + u)/m \\end{bmatrix}$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$\\dot{\\vec{x}} = A  \\vec{x} + B \\vec{u}$\n",
+    "\n",
+    "$\\vec{y} = C \\vec{x} + D \\vec{u}$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "SX([x_1, ((u-((c*x_1)+(k*x_0)))/m)])"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "m = ca.SX.sym('m')\n",
+    "c = ca.SX.sym('c')\n",
+    "k = ca.SX.sym('k')\n",
+    "p = ca.vertcat(m, c, k)\n",
+    "\n",
+    "u = ca.SX.sym('u')\n",
+    "xv = ca.SX.sym('x',2)\n",
+    "x = xv[0]\n",
+    "xd = xv[1]\n",
+    "\n",
+    "xv_dot = ca.vertcat(xd, (-c*xd - k*x + u)/m)\n",
+    "xv_dot\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "f_rhs = ca.Function('rha', [xv, u, p], [xv_dot], ['x','u','p'], ['x_dot'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "DM([2, -7])"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "f_rhs([1,2], [0], [1,2,3])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ValueError",
+     "evalue": "could not broadcast input array from shape (2,1) into shape (2)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-15-927dc80cd2d6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mscipy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mintegrate\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mnumpy\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mscipy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mintegrate\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msolve_ivp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mf_rhs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt_span\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my0\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt_eval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0.1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;32m~/anaconda3/envs/aae497-f19/lib/python3.7/site-packages/scipy/integrate/_ivp/ivp.py\u001b[0m in \u001b[0;36msolve_ivp\u001b[0;34m(fun, t_span, y0, method, t_eval, dense_output, events, vectorized, **options)\u001b[0m\n\u001b[1;32m    500\u001b[0m     \u001b[0mstatus\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    501\u001b[0m     \u001b[0;32mwhile\u001b[0m \u001b[0mstatus\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 502\u001b[0;31m         \u001b[0mmessage\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msolver\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    503\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    504\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0msolver\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstatus\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'finished'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/anaconda3/envs/aae497-f19/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\u001b[0m in \u001b[0;36mstep\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    180\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    181\u001b[0m             \u001b[0mt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 182\u001b[0;31m             \u001b[0msuccess\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmessage\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_step_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    183\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    184\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0msuccess\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/anaconda3/envs/aae497-f19/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\u001b[0m in \u001b[0;36m_step_impl\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    141\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    142\u001b[0m             y_new, f_new, error = rk_step(self.fun, t, y, self.f, h, self.A,\n\u001b[0;32m--> 143\u001b[0;31m                                           self.B, self.C, self.E, self.K)\n\u001b[0m\u001b[1;32m    144\u001b[0m             \u001b[0mscale\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0matol\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmaximum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mabs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mabs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_new\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mrtol\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    145\u001b[0m             \u001b[0merror_norm\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0merror\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mscale\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/anaconda3/envs/aae497-f19/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\u001b[0m in \u001b[0;36mrk_step\u001b[0;34m(fun, t, y, f, h, A, B, C, E, K)\u001b[0m\n\u001b[1;32m     65\u001b[0m            \u001b[0mEquations\u001b[0m \u001b[0mI\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mNonstiff\u001b[0m \u001b[0mProblems\u001b[0m\u001b[0;31m\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSec\u001b[0m\u001b[0;34m.\u001b[0m \u001b[0mII\u001b[0m\u001b[0;36m.4\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     66\u001b[0m     \"\"\"\n\u001b[0;32m---> 67\u001b[0;31m     \u001b[0mK\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     68\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mC\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m         \u001b[0mdy\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mK\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0ms\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mh\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mValueError\u001b[0m: could not broadcast input array from shape (2,1) into shape (2)"
+     ]
+    }
+   ],
+   "source": [
+    "import scipy.integrate\n",
+    "import numpy as np\n",
+    "scipy.integrate.solve_ivp(\n",
+    "    fun=lambda t, x: np.array(f_rhs(x, 1.0, [1,2,3])), \n",
+    "    t_span=[0,1], y0=[0,0], t_eval = np.arange(0,1,0.1))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "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.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/lectures/AlexanderChapaHW3.ipynb b/lectures/AlexanderChapaHW3.ipynb
new file mode 100644
index 00000000..23efa001
--- /dev/null
+++ b/lectures/AlexanderChapaHW3.ipynb
@@ -0,0 +1,677 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import casadi as ca\n",
+    "import numpy as np\n",
+    "import control\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from casadi.tools.graph import dotgraph\n",
+    "from IPython.display import Image\n",
+    "\n",
+    "def draw_graph(expr):\n",
+    "    return Image(dotgraph(expr).create_png())\n",
+    "\n",
+    "# make matrix printing prettier\n",
+    "np.set_printoptions(precision=3, suppress=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This notebook will walk through trimming and control design for a transport aircxraft using casadi."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def rhs(x, u):\n",
+    "    s = 2170\n",
+    "    cbar = 17.5\n",
+    "    mass = 5.0e3\n",
+    "    iyy = 4.1e6\n",
+    "    tstat = 6.0e4\n",
+    "    dtdv = -38.0\n",
+    "    ze = 2.0\n",
+    "    cdcls = 0.042\n",
+    "    cla = 0.085\n",
+    "    cma = -0.022\n",
+    "    cmde = -0.016\n",
+    "    cmq = -16.0\n",
+    "    cmadot = -6.0\n",
+    "    cladot = 0.0\n",
+    "    rtod = 57.29578\n",
+    "    gd = 32.17\n",
+    "    \n",
+    "    thtl = u[0]\n",
+    "    elev_deg = u[1]\n",
+    "    xcg = u[2]\n",
+    "    land = u[3]\n",
+    "    \n",
+    "    vt = x[0]  # velocity, ft/s\n",
+    "    alpha = x[1]\n",
+    "    alpha_deg = rtod*alpha  # angle of attack, deg\n",
+    "    theta = x[2]  # pitch angle, rad\n",
+    "    q = x[3]  # pitch rate, rad/s\n",
+    "    h = x[4]  # altitude, ft\n",
+    "    pos = x[5]  # horizontal position from origin, ft (not used in dynamics)\n",
+    "    \n",
+    "    r0 = 2.377e-3\n",
+    "    tfac = 1.0 - 0.703e-5*h\n",
+    "    temperature = ca.if_else(h > 35000, 390.0, 519.0*tfac)\n",
+    "    rho = r0*(tfac**4.14)\n",
+    "    mach = vt/ca.sqrt(1.4*1716.3*temperature)\n",
+    "    qbar = 0.5*rho*vt**2\n",
+    "    \n",
+    "    qs = qbar*s\n",
+    "    salp = ca.sin(alpha)\n",
+    "    calp = ca.cos(alpha)\n",
+    "    gam = theta - alpha\n",
+    "    sgam = ca.sin(gam)\n",
+    "    cgam = ca.cos(gam)\n",
+    "    \n",
+    "    aero_p = ca.if_else(\n",
+    "        land,\n",
+    "        (1.0, 0.08, -0.20, 0.02, -0.05),\n",
+    "        (0.2, 0.016, 0.05, 0.0, 0.0))\n",
+    "    cl0 = aero_p[0]\n",
+    "    cd0 = aero_p[1]\n",
+    "    cm0 = aero_p[2]\n",
+    "    dcdg = aero_p[3]\n",
+    "    dcmg = aero_p[4]\n",
+    "    \n",
+    "    thr = (tstat + vt*dtdv)*ca.fmax(thtl, 0)\n",
+    "    cl = cl0 + cla*alpha_deg\n",
+    "    cm = dcmg + cm0 + cma*alpha_deg + cmde*elev_deg + cl*(xcg - 0.25)\n",
+    "    cd = dcdg + cd0 + cdcls*cl**2\n",
+    "    \n",
+    "    x_dot = ca.SX.zeros(6)\n",
+    "    x_dot[0] = (thr*calp - qs*cd)/mass - gd*sgam\n",
+    "    x_dot[1] = (-thr*salp - qs*cl + mass*(vt*q + gd*cgam))/(mass*vt + qs*cladot)\n",
+    "    x_dot[2] = q\n",
+    "    d = 0.5*cbar*(cmq*q + cmadot*x_dot[1])/vt\n",
+    "    x_dot[3] = (qs*cbar*(cm + d) + thr*ze)/iyy\n",
+    "    x_dot[4] = vt*sgam\n",
+    "    x_dot[5] = vt*cgam\n",
+    "    return x_dot"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def constrain(s, vt, h, q, gamma):\n",
+    "    \n",
+    "    # s is our design vector:\n",
+    "    # s = [thtl, elev_deg, alpha]\n",
+    "    thtl = s[0]\n",
+    "    elev_deg = s[1]\n",
+    "    alpha = s[2]\n",
+    "    \n",
+    "    pos = 0  # we don't care what horiz. position we are at\n",
+    "    xcg = 0.25  # we assume xcg at 1/4 chord\n",
+    "    land = 0  # we assume we do not have flaps/gear deployed\n",
+    "    theta = alpha + gamma\n",
+    "    \n",
+    "    # vt, alpha, theta, q, h, pos\n",
+    "    x = ca.vertcat(vt, alpha, theta, q, h, pos)\n",
+    "    \n",
+    "    # thtl, elev_deg, xcg, land\n",
+    "    u = ca.vertcat(thtl, elev_deg, xcg, land)\n",
+    "    return x, u\n",
+    "\n",
+    "def trim_cost(x, u):\n",
+    "    x_dot = rhs(x, u)\n",
+    "    return x_dot[0]**2 + 100*x_dot[1]**2 + 10*x_dot[3]**2\n",
+    "\n",
+    "def objective(s, vt, h, q, gamma):\n",
+    "    x, u = constrain(s, vt, h, q, gamma)\n",
+    "    return trim_cost(x, u)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def trim(vt, h, q, gamma):\n",
+    "    s = ca.SX.sym('s', 3)\n",
+    "    nlp = {'x': s, 'f': objective(s, vt=vt, h=h, q=q, gamma=gamma)}\n",
+    "    S = ca.nlpsol('S', 'ipopt', nlp, {\n",
+    "        'print_time': 0,\n",
+    "        'ipopt': {\n",
+    "            'sb': 'yes',\n",
+    "            'print_level': 0,\n",
+    "            }\n",
+    "        })\n",
+    "    # s = [thtl, elev_deg, alpha]\n",
+    "    s0 = [0.293, 2.46, np.deg2rad(0.58)]\n",
+    "    res = S(x0=s0, lbg=0, ubg=0, lbx=[0, -60, -np.deg2rad(5)], ubx=[1, 60, np.deg2rad(18)])\n",
+    "    \n",
+    "    trim_cost = res['f']\n",
+    "    trim_tol = 100\n",
+    "    if trim_cost > trim_tol:\n",
+    "        raise ValueError('Trim failed to converge', trim_cost)\n",
+    "    assert np.abs(float(res['f'])) < trim_tol\n",
+    "    s_opt = res['x']\n",
+    "    print(s_opt)\n",
+    "    x0, u0 = constrain(s_opt, vt, h, q, gamma)\n",
+    "    return {\n",
+    "        'x0': np.array(x0).reshape(-1),\n",
+    "        'u0': np.array(u0).reshape(-1),\n",
+    "        's': np.array(s_opt).reshape(-1)\n",
+    "    }\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.292673, 2.4607, 0.0101196]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'x0': array([500.  ,   0.01,   0.01,   0.  ,   0.  ,   0.  ]),\n",
+       " 'u0': array([0.293, 2.461, 0.25 , 0.   ]),\n",
+       " 's': array([0.293, 2.461, 0.01 ])}"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "trim(500, 0, 0, 0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.0753603, -27.9939, 0.314159]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'x0': array([100.   ,   0.314,   0.314,   0.   ,   0.   ,   0.   ]),\n",
+       " 'u0': array([  0.075, -27.994,   0.25 ,   0.   ]),\n",
+       " 's': array([  0.075, -27.994,   0.314])}"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "trim(100, 0, 0, 0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.250133, -19.8854, 0.304934]\n",
+      "[0.241141, -18.6539, 0.288171]\n",
+      "[0.23299, -17.5014, 0.272547]\n",
+      "[0.225603, -16.422, 0.257969]\n",
+      "[0.218911, -15.4101, 0.24435]\n",
+      "[0.212855, -14.4608, 0.231612]\n",
+      "[0.207382, -13.5694, 0.219686]\n",
+      "[0.202444, -12.7315, 0.208505]\n",
+      "[0.198002, -11.9433, 0.198012]\n",
+      "[0.194017, -11.2011, 0.188153]\n",
+      "[0.190456, -10.5015, 0.17888]\n",
+      "[0.187292, -9.84159, 0.170149]\n",
+      "[0.184496, -9.21842, 0.161919]\n",
+      "[0.182045, -8.62946, 0.154154]\n",
+      "[0.179919, -8.07233, 0.146821]\n",
+      "[0.178097, -7.54487, 0.139887]\n",
+      "[0.176563, -7.04505, 0.133327]\n",
+      "[0.1753, -6.57103, 0.127112]\n",
+      "[0.174295, -6.12111, 0.121221]\n",
+      "[0.173535, -5.69373, 0.115632]\n",
+      "[0.173008, -5.28743, 0.110324]\n",
+      "[0.172702, -4.90089, 0.105279]\n",
+      "[0.17261, -4.53285, 0.10048]\n",
+      "[0.172721, -4.18219, 0.0959123]\n",
+      "[0.173028, -3.84785, 0.0915606]\n",
+      "[0.173523, -3.52883, 0.087412]\n",
+      "[0.174199, -3.22425, 0.083454]\n",
+      "[0.175051, -2.93324, 0.0796752]\n",
+      "[0.176074, -2.65502, 0.0760652]\n",
+      "[0.177261, -2.38887, 0.0726141]\n",
+      "[0.178608, -2.13411, 0.0693127]\n",
+      "[0.180111, -1.8901, 0.0661526]\n",
+      "[0.181766, -1.65625, 0.0631259]\n",
+      "[0.18357, -1.43201, 0.0602252]\n",
+      "[0.185519, -1.21687, 0.0574437]\n",
+      "[0.187611, -1.01035, 0.0547749]\n",
+      "[0.189842, -0.811989, 0.052213]\n",
+      "[0.192211, -0.621375, 0.0497522]\n",
+      "[0.194715, -0.43811, 0.0473874]\n",
+      "[0.197353, -0.261825, 0.0451136]\n",
+      "[0.200122, -0.0921724, 0.0429263]\n",
+      "[0.203021, 0.0711747, 0.0408212]\n",
+      "[0.206048, 0.228523, 0.0387941]\n",
+      "[0.209203, 0.38016, 0.0368413]\n",
+      "[0.212485, 0.526357, 0.0349593]\n",
+      "[0.215892, 0.667371, 0.0331446]\n",
+      "[0.219423, 0.803441, 0.0313941]\n",
+      "[0.223079, 0.934796, 0.0297048]\n",
+      "[0.226858, 1.06165, 0.0280739]\n",
+      "[0.23076, 1.1842, 0.0264988]\n",
+      "[0.234785, 1.30265, 0.0249768]\n",
+      "[0.238933, 1.41717, 0.0235058]\n",
+      "[0.243202, 1.52793, 0.0220834]\n",
+      "[0.247595, 1.6351, 0.0207075]\n",
+      "[0.25211, 1.73882, 0.0193761]\n",
+      "[0.256747, 1.83925, 0.0180874]\n",
+      "[0.261507, 1.93653, 0.0168394]\n",
+      "[0.266391, 2.03077, 0.0156306]\n",
+      "[0.271398, 2.12211, 0.0144593]\n",
+      "[0.276529, 2.21066, 0.013324]\n",
+      "[0.281785, 2.29654, 0.0122232]\n",
+      "[0.287166, 2.37985, 0.0111555]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def power_required_curve():\n",
+    "    throttle = []\n",
+    "    vt_list = np.arange(190, 500, 5)\n",
+    "    for vt in vt_list:\n",
+    "        res = trim(vt=vt, h=0, q=0, gamma=0)\n",
+    "        throttle.append(res['s'][0])\n",
+    "    plt.plot(vt_list, 100*np.array(throttle))\n",
+    "    plt.grid()\n",
+    "    plt.ylabel(r'throttle, %')\n",
+    "    plt.xlabel('VT, ft/s')\n",
+    "    plt.title('power required curve')\n",
+    "    \n",
+    "power_required_curve()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def linearize(trim):\n",
+    "    x0 = trim['x0']\n",
+    "    u0 = trim['u0']\n",
+    "    x = ca.SX.sym('x', 6)\n",
+    "    u = ca.SX.sym('u', 4)\n",
+    "    y = x\n",
+    "    A = ca.jacobian(rhs(x, u), x)\n",
+    "    B = ca.jacobian(rhs(x, u), u)\n",
+    "    C = ca.jacobian(y, x)\n",
+    "    D = ca.jacobian(y, u)\n",
+    "    f_ss = ca.Function('ss', [x, u], [A, B, C, D])\n",
+    "    return control.ss(*f_ss(x0, u0))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def pitch_rate_control_design(vt, H, xlim, ylim, tf=100):\n",
+    "    trim_state = trim(vt=vt, h=0, q=0, gamma=0)\n",
+    "    print(trim_state)\n",
+    "    sys = linearize(trim_state)\n",
+    "    G = control.minreal(control.tf(sys[3, 1]), 1e-2)\n",
+    "    control.rlocus(G*H, kvect=np.linspace(0, 1, 1000), xlim=xlim, ylim=ylim);\n",
+    "    Go = G*H\n",
+    "    Gc = control.feedback(Go)\n",
+    "    plt.plot([0, -3], [0, 3*np.arccos(0.707)], '--')\n",
+    "    #plt.axis('equal')\n",
+    "    plt.grid()\n",
+    "    \n",
+    "    plt.figure()\n",
+    "    control.bode(Go, margins=True, dB=True, Hz=True, omega_limits=[1e-2, 1e2], omega_num=1000);\n",
+    "    plt.grid()\n",
+    "\n",
+    "    plt.figure()\n",
+    "    t = np.linspace(0, tf, 1000)\n",
+    "    r = np.array(t > 0.1, dtype=float)\n",
+    "    t, y, x = control.forced_response(Gc, T=t, U=r)\n",
+    "    _, u, _ = control.forced_response((1/G)*Gc, T=t, U=r)\n",
+    "\n",
+    "    u_norm = np.abs(u)\n",
+    "    max_u_norm = np.max(u_norm)\n",
+    "    print('u_norm max', max_u_norm)\n",
+    "    \n",
+    "    t,y=control.step_response(Gc, T=np.linspace(0, 10, 1000))\n",
+    "    plt.plot(t,y , label='me')\n",
+    "\n",
+    "    plt.plot(t, y, label='x')\n",
+    "    plt.plot(t, r, label='r')\n",
+    "    plt.plot(t, u_norm/max_u_norm, label='u normalized')\n",
+    "    plt.gca().set_ylim(0, 1.5)\n",
+    "    plt.grid()\n",
+    "    plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.292673, 2.4607, 0.0101196]\n",
+      "{'x0': array([500.  ,   0.01,   0.01,   0.  ,   0.  ,   0.  ]), 'u0': array([0.293, 2.461, 0.25 , 0.   ]), 's': array([0.293, 2.461, 0.01 ])}\n",
+      "1 states have been removed from the model\n",
+      "u_norm max 1762.7074129652137\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAEKCAYAAAASByJ7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3deXhTVf7H8fdJ971Ay9aWHctaiixCESmCCoqg4oCiOKKIiowyiuMyjsroKI6o4A+XUUBGEJEBZVFAQS3IvpZShUJLWcraAi0t3Zvz+yOhZW8KTW6Sfl/P00fuzUny4Vryzbnn3nOU1hohhBDCZHQAIYQQzkEKghBCCEAKghBCCCspCEIIIQApCEIIIaykIAghhACcoCAopTyUUtuUUt8bnUUIIWoywwsC8Ayw0+gQQghR0xlaEJRSkcAdwFQjcwghhABPg99/EvA3IOhyDZRSo4BRAL6+vp0aNWrkoGjOzWw2YzI5QwfPeHIsKsixqGDrsdDA/tNmQn0UoT7K/sEMsHv37iytdXhl7QwrCEqpAcBxrfUWpVT85dpprT8DPgOIjo7WKSkpDkro3BISEoiPjzc6hlOQY1FBjoXFwYMHWbduHUOGDLGpfa93f6Vtw2A+fqCTnZMZQym135Z2RvYQegADlVK3A75AsFJqltb6QQMzCSHcwPDhw8nOzra5ILSsG8TuY3l2TuX8DOtbaq1f0lpHaq2bAPcBv0gxEEJUh1deeYXhw4fb3L5ZeAAHTuZT0yf7NHoMQQghql3fvn3x9LT9461BiC/FpWZOnimmTqCPHZM5N6cYfdJaJ2itBxidQwjhHvbu3cvhw4dtbt8gxBeAIzmF9orkEpyiIAghRHV65JFH+Pe//21z+wYhfoAUBDllJIRwO+PHj2fbtm02t68d4A3Aqfxie0VyCVIQhBBup1evXlUaIA729QIgt7DUXpFcgpwyEkK4nZSUFA4cOGBz+0Bfy3fj0wUl9orkEqSHIIRwO48//jjZ2dk89NBDNrX3MCkCvD1qfA9BCoIQwu289dZbbN26tUrP8fXyoKi0zE6JXIMUBCGE24mLi6O4uGoDxEpZ5jWqyWQMQQjhdpKTk0lPT6/isxQ1/EZlKQhCCPczZswYJk+eXKXnKAU1vY8gp4yEEG7n3XffZcuWLUbHcDlSEIQQbqdLly6cOXOmSs8pKC7Dz6tmfyTKKSMhhNtJTEwkNTXV5vZmsyavqJQgXykIQgjhVsaOHcuUKVNsbp9XbLn/oKYXhJr9txdCuKVJkyaxefNmm9vnWW9IC/Sp2R+JNftvL4RwS7GxsWRnZ9vc/uwdyoE1vIcgp4yEEG5n06ZN7Nq1y+b2x3Mt016H1+DFcUAKghDCDT3//PN8+umnNrc/uw5Cw1A/e0VyCTW7fySEcEtTpkxh06ZNNrc/km0pCHWDa3YPwbCCoJTyBVYBPtYc87TWrxmVRwjhPtq1a0dWVpbN7Q9nFxAW6I2Pp4cdUzk/I08ZFQE3a607ALFAP6VUNwPzCCHcxNq1a0lOTra5fVpmHs3CAu2YyDUYVhC0RZ5108v6U7MnEhFCVIuXX36ZqVOn2tw+LTOP5nWlIBg6hqCU8gC2AC2Aj7TWG4zMI4RwD//5z3/YsMG2j5MTeUWcyi+heXiAnVM5P1WVdUftFkKpUOA74C9a6+QLHhsFjAIIDw/vNHfuXAMSOp+8vDwCA+UbDcixOJcciwq2HotdJ8uYsLGQZzv5EBPuntfZ9O7de4vWunNl7Zzib6+1zlZKJQD9gOQLHvsM+AwgOjpax8fHOzyfM0pISECOhYUciwpyLCxWrlxJamoqY8eOrbTt7lVpwC6G9e9JmNyHYAylVLi1Z4BSyg/oC9h+J4kQQlzGa6+9xowZM2xqu/1gDpG1/Gp8MQBjewgNgP9axxFMwFyt9fcG5hFCuInp06ezfv16m9omHswmtlGonRO5BsMKgtY6Ceho1PsLIdxXs2bNOHDgQKXtsvKKOJRdwMNxTewfygXI1BVCCLezYsUKm1ZM25h+EoDrG0sPAaQgCCHc0JtvvsnMmTMrbffbniyCfDzpECkFAZzkKiMhhKhOM2fOZN26dVdso7Vm1e5Mujevg6eHfDcG6SEIIdxQVFQUdevWvWKbfSfyOZRdQM+WYQ5K5fykIAgh3M6yZcvYuHHjFdus3pMJQM+W4Y6I5BKkIAgh3M6ECROYPXv2Fdus2HmcRrX9aVzH30GpnJ+MIQgh3M6cOXNYu3btZR8/eaaYNalZPNqzKUopByZzbtJDEEK4nfr161O7du3LPr4s+SilZs2dMQ0dmMr5SUEQQridxYsXX7GH8H3SYZqFBdC2YbADUzk/KQhCCLfz3nvvcbmZkY/nFrJ+7wkGxDSQ00UXkDEEIYTbmTdvHmvWrLnkY0t3HMWs4c4OcrroQtJDEEK4nbCwMEJCQi752LfbDtGqfhAt6wU5OJXzk4IgRDU6cPoAxWXFRseo8b799ltWrVp10f7fD+ew/WA2QzpHGZDK+UlBEKKalJhLeGLFEwxZPITE44lGx6nRPvzwQ7799tuL9s/ecAAfTxODr480IJXzk4IgRDXxMnnxYtcXyS/N56GlD/Hm+jfJK84zOlaNtHDhQt58883z9uUVlbJg2yHuiGlAiL+XQcmcmxQEIarRTZE3sWDQAh5o/QBzU+YyaOEgDuYeNDpWjRMSEnLRespzNx3kTHEZw7s1NiiV85OCIEQ18/fy54WuL/DV7V9xY8SNRARGAFBqLjU4Wc3xzTff8Msvv5Rvl5aZmbY6nc6Na9GxUS0Dkzk3KQhC2En78PaMjxuPSZnIKsjizu/uZP7u+WitjY7m9j755BMWLVpUvr3s96Mcyi5gZM9mBqZyflIQhHCA4rJiGgQ24PV1r/PIj4+wL2ef0ZHc2pIlS5gwYQJgWffg89/SaVzHn1va1DM4mXMzrCAopaKUUr8qpXYqpX5XSj1jVBYh7K1hYEOm3TqN8XHjSTmVwuBFg/ks6TPpLdiJv78/vr6+AKxOzWL7wWxG9myGh0nuTL4SI3sIpcBzWuvWQDfgKaVUGwPzCGFXSinuaXkPi+5aRHxUPHtO7ZGpE+xk1qxZLF++HK01k1bsoUGIL0M6y6WmlTFs6gqt9RHgiPXPuUqpnUAE8IdRmYRwhDC/MN6Lf4+SshIA0rLTmLd7Hn/p+Bf8vWRu/uowdepUsrOz6ffwWLbsP8Ubd7XDx9PD6FhOTzlDl1Up1QRYBbTTWp++4LFRwCiA8PDwTpebsKqmycvLu+iyuprK1Y/FytMrmX9qPqEeoQytM5S2fm2v+rVc/VhUl9LSUnJz8/g4xYcThZp3bvLDqwafLurdu/cWrXXnytoZXhCUUoHASuBfWuuLby08R3R0tE5JSXFMMCeXkJBAfHy80TGcgjsci8Tjiby+9nXSctLo36Q/L3R9gTp+dar8Ou5wLKrLlHkrmLi5iDfualfj7z1QStlUEAy9ykgp5QXMB76qrBgI4c5i68Yy9865jI4dzYoDK5i968rLP4ormz79C/5vzhIiQv1k7KAKjLzKSAHTgJ1a6/eNyiGEs/D28ObJDk8yb+A8RrYfCUByVjIHTh8wONn5Pl2Zxtq0rPP2rU3L4tOVaQYlutgHH3/O/o3LGXfbdTJ2UAVG9hB6AMOBm5VSidaf2w3MI4RTaBbSDD9PP7TWvLH+De5ZdA/TdkyjxFxidDQAYiJDGDN7W3lRWJuWxZjZ24iJvPR0045WXGqm1pB/0eXxfzOoQ4TRcVyKkVcZrQZq7iiPEJVQSvFh7w95e+PbTNo6iaXpSxkfN562YVc/6Fwd4pqH8X/3x/LYfzfTp1VdVqedYMqwjsQ1DzM011mzN+znwMl8nu3kg6kGDyRfDblTWQgnVi+gHpN6T+KD+A84WXiSYUuGse34NqNj0bVpHfy8PViUdIS7Yxs6TTHILSzhw19SqXtoNfvXLzU6jsuRJTSFcAF9G/ela4OuzNs9jw7hHQDIKsgizM+YD+JN+05SUqbxMCm+XL+fm1vXpUeLcEOynGvqb+mcPFNM/fR1JPyRa3QclyM9BCFcRLB3MI+0e6R8srxBCwbx4m8vcrLwpENznB0z+OTB63n9zjaUlGke+3LLRQPNjlZQXMZ/1+3jljb1WL86gffee8/QPK5ICoIQLijYO5hhrYfx474fGbRgEIvTFjtsXqSkjJzyMYMHuzXm5lZ1KSkz8/PO4w55/8uZvzWD7PwSHpMZTa+aFAQhXJC3hzdPxT7F/wb8j8bBjXl59cs8seIJSrT9r0R6olfz8jEDpRT/vjeGED8v1qRmYTYbc6Or2ayZviad9hEhdGlSi48//pgFCxYYksWVSUEQwoW1qNWCL/t/ycs3vEyDgAZ4KcvSkI6cgSAs0IfR8S3YdTSXzLwih73vuVbuzmRv5hlG9myKUorFixezbt06Q7K4MikIQrg4kzJxf6v7eT3udQBST6UyfOlwdp7Y6bAMkbX8ADh+2piCMG11OvWDfbm9fQMAli5dyjvvvGNIFlcmBUEIN5NVmEVGbgb3/3A/7295n4LSAru/Z3iQDwCZeYV2f68L7TxymtWpWTwU1xgvD/lIuxZy9IRwM90adGPhXQsZ1GIQXyR/weBFg1l/ZL1d3/NsQTCihzB9dTp+Xh4M69qofN/kyZOZN2+ew7O4OikIQrihEJ8QxseNZ/pt0zEpE+sO2/d8enkPIdexBSEzt4iFiYcZ3CmCUH/v8v0///wz27YZfwOfq5Eb04RwY13qd2HenfPKV2bbeGQjWQVZ9G/av1pXa/Px9CDEz8vhg8qz1u+nuMzMIz2anrd/0aJFJCQkODSLO5AeghBuztfTFx8Pyzf4ubvn8sJvLzD659Eczjtcre8THuTj8FNG/9t8kPjocJqFy6JA1UEKghA1yDs93+FvXf7GlmNbuGvhXcz6YxZl5rJqee26QT4O7yF4eChC/Lwu2j9x4kS++eYbh2ZxB1IQhKhBPEweDG8znAWDFtCpXife2fQOP+3/6Zpf9+DJfPYcz6uGhFUTEepHxqmLr6Jat24dv//+u8PzuDoZQxCiBmoY2JCP+3zM6kOr6RHRA7AsxtMitAW+nr5Veq3M3CKGT9tAUUkZ/7q7nT3iXlZkLX9+25N50f758+fLGMJVkB6CEDWUUoqekT0xKRN5xXk8vvxxBi8azMYjG21+jdOFJfx5+kaOni7kixFdaFU/2I6JLxZZy4/juUUUlVbPaa+aTgqCEIJA70Am9pqIWZt59KdHeW3ta+QU5VzxOQXFZYycsZk9x3P5z/DOdGpc20FpK0TW8kdrOJJ9/g1xEyZMYPZsWZe6qqQgCCEA6N6wO98O+pYRbUewMHUhgxYM4kTBiUu2LSkz89TsrWzaf5L3h8TS6zpj1kKICLVMmXHhOEJiYiKpqalGRHJpho4hKKWmAwOA41prx558FEJcxM/Tj2c7P0v/pv359eCv1PGrA0BBaQF+npYP3/ziUp6fl8Qvu47zr7vbcWeHhoblPTuH0qHs/PP2z5kzR8YQroLRPYQZQD+DMwghLtC6TmtGx44GYM+pPdw671a+3vU1SRmnGPB/q1my4wgv396KB25obGjOBiG+eJjUJa80ElVnaA9Ba71KKdXEyAxCiCvz9/Knde02vLXhLcwFswgou5+vRvZzinWUPT1M1A/2vaggvPHGG6SnpxMfH29MMBfl9JedKqVGAaMAwsPDpRtolZeXJ8fCSo5FBXsci+wiM4eS7qKgJIqABosprjeRRTuSKT7oHJ37QFXE7/uOkJCQXb5v1apVlJaWyu9FFSlHLqRxyQCWHsL3towhREdH65SUFLtncgUJCQny7cdKjkWF6j4Wv+w6xvP/S+JMcSn/GNCGfjGBTNw8kXr+9RjbaWy1vc+1eHZuIuvTTrD2pT7n7ZffiwpKqS1a686VtXP6HoIQwvEKS8qYsHQXM9buo1X9IObc342W9YIAeLvn25i1GYB1h9exfP9y/trprwR5BxmSNbKWP0dPH6KkzCzrIVwjOXpCiPPsPpbLXR+tYcbafTzSoykLnupRXgzOMinLR8euk7uYv2c+gxYM4uf9PxsRl8hQP8wajuZU3Ivw6quvMn36dEPyuDKbCoJSysMeb66U+hpYB0QrpTKUUo/a432EEJXTWjNz/X7u/L/VZOUV8cWILrx6Zxt8vS7/z39EuxF8dftX1PatzdiEsYz9dSzH8487MHXFpacHT1Zcenrw4EEyMy+e0kJcma2njFKVUvOAL7TWf1TXm2ut76+u1xJCXL2TZ4r527wkVuw8Rq/rwpn4pw7li95Upl1YO74e8DVf/v4ln2z/hISDCQyJHmLnxBVa1LNMfb3zaC5xLSxXPn3xxRcyoHwVbC0IMcB9wFSllAmYDszRWp+2WzIhhEOs33uCZ+Zs49SZEv4xoA0j4ppgMlVt8RwvkxePtn+Ufk370SDAstD9qoxVRAZG0iy0mT1il6sb5Ev9YF92ZGRX3lhckU2njLTWuVrrz7XWccDfgNeAI0qp/yqlWtg1oRDCbuZvyeDBqRsI8PHku6fiePTGplUuBueKCIzApEyUmkt5e8Pb3Lv4Xj7Z/gklZSXVmPpiMZEhJGVUzL300ksv8fnnn9v1Pd2RzWMISqmBSqnvgMnAe0AzYDGwxI75hBB28tGvqTz3v+3c0Kw2C57qQduGIdX22p4mT2bePpO+jfryceLH/Gnxn0g8nlhtr3+hmMgQ9mad4XShpfCcOHGCnJwrT84nLmbrVUZ7gEHAu1rrjlrr97XWx7TW84Bl9osnhKhuWmveX76bd39M4e6OEXzxcFeCfS9edexahfmF8e9e/+ajPh9xpvQMDy19iLTstGp/H4D2kaEAJFt7CZ999hnjxo2zy3u5s0oLgvUKoxla60e11msvfFxr/bRdkgkh7OLDn1P58Oc9DOkcyXt/6oC3p32vPr8p8iYWDFrAmze+SfPQ5gDsP72/Wt8jJsLSu0k6JL2Ca1Hpb4LWugzo7YAsQgg7m7vpIB+s2M3g6yOZcE/MNY0XVEWAVwADmw8EYG/2Xu5aeBfPJTxHVkFWtbx+rQBvomr7kWQdWB43bhyffPJJtbx2TWLrV4O1SqkpSqmeSqnrz/7YNZkQolqtTcvi5e920LNlGBMGt3dYMbhQVHAUozuMJuFgAgMXDGT+7vlUxxQ6MZGh5QPLBQUFFBUVXfNr1jS2XnYaZ/3vP8/Zp4GbqzeOEMIeTuQVMXZOIo3r+PPxA9cbOsWDl8mLx2Ie45bGtzB+3XheX/c6y/Yt49O+n+Jhuvp7YGMiQvgh6QgnzxTz0UcfyX0IV8GmgqC1llNGQrgorTXPz0siu6CEGSO6EmSHAeSr0SSkCdNum8Z3e77jVNGp8mJQZi67qsIQYx1YTsrIJj66brVmrSlsntxOKXUH0BbwPbtPa/3Pyz9DCOEMliYf5Zddx3l1QBvaNAw2Os55TMrE4OsGl2+vPbSW97a8x+vdX6d9ePsqvVa7CMvfbUdGDgs+eYuMjAyZ7bSKbL0P4VNgKPAXQAF/AoxdKkkIUanCkjL+9cNOWtUP4s9xTYyOY5PsomweWPIA72x8h/yS/MqfYBXk60Wz8AC2Z8iVRlfL1hOJcVrrh4BTWuvxQHcgyn6xhBDV4b9r93Eou4BX72yDh0GDyFURFxHHwkELGRI9hFk7Z3HXwrtYc2iNzc/vEBnKjkPZTJo0iTFjxtgxqXuytSCcXZ8uXynVECgBmtonkhCiOpjNltlLuzWr7RTLXdoq0DuQV7q9wpf9v8TP049DeYdsfm77iBCOnS7i2OnCyhuLi9g6hvC9UioUeBfYiuUKo6l2SyWEuGar9mSScaqAF/q1MjrKVelYtyP/u/N/eJosH1Pf7/2ekrIS7mpxF0pdurfTIcpyg9pjjz+JqeCUjCFUka1XGb1h/eN8pdT3gK/WWk7UCeGktNbMXLefOgHe3Na2vtFxrpq3h3f5n5elL2Nlxkp+SP+B17q9RlTwxWet2zQIwcOkOF2iqOdj2/TdokJVrjKKA5qcfY5SCq31l3bKJYS4SmazZvzi3/l513GeveU6u09N4Sgf3vwh83bP4/0t73P3ort5ssOTPNT2IbxMFZfR+nl70LJuIPVaPMGIZrYPSAsLW68ymglMBG4Eulh/Kl2wWQjhWKVmzV/nJvLfdfsZeWNTxvR2n9npTcrEkOghLBy0kB4NezBp66SLZlD9dGWaZW2EQznldz+vTcvi05X2mVTP3djaQ+gMtNHVcX+5EMIuCorL+HBbEUmZh3n+tmhGxze/7Ll2V1YvoB6Tb57Mjswd5fcqrDm0ho51OxITGcKHP+/h4KJJ/GuNJz6N2jNm9jamDOtocGrXYGtBSAbqA0eq882VUv2wrK/gAUzVWk+oztcXoqbIKShh5H83sSOzjLfubs+wGxpV/5skzYWf/wk5GRASCX1ehRjHLZV5obPFIDM/k7/88hfq+tfl+mPXMV1t4Ta/htTK3UzrmbG8GDWWz1aFuNSVVkaxtSCEAX8opTYC5TNGaa0HXu0bW6fV/gi4BcgANimlFlXnms1C1ATHcwt5aNpG0jLzeDLWx37FYPHTUGK9Aj3noGUbDC0KAOH+4Xx2y2eMTxjH4oBfKQvPZ0TfTgxXdajFHu468DZhbX2ArobmdAXKlrNASqlel9qvtV551W+sVHfgda31bdbtl6yv+fblnhMS0VzHjX6XJo0bYzab+e2332jatCmNGjWirKyM1atX06x5c6IiIykpKWHt2rW0aNGCiIgIioqKWL9+Pddddx0NGjSgsLCQDRs2EB0dTf369ckvKGDTxo20bt2aunXrcubMGTZv3kybNm0IDw8nNzeXrVu30q5dO+rUqUPO6dMkbttG+5gYateqRXZ2Ntu3b6dDhw6EhoZy8tQpdiQlEduxIyHBwZw4cYLk5GSuv/56goKCyMzM5I8//qBz584EBARw/Phxdu7cSZeuXfH38+Po0aOkpKRwww034Ovry5EjR9i9ezfdunXDx8eHw4cPs2fPHuLi4vDy8uJgRgZ709K48cYb8fDw4MCBA6Snp9OzZ09MJhP79u9n/7599Opl+V+Znp7OwYMZ3HRTTwDS0tI4cuQIN954IwB7UlPJPH6cuDjLvIa7d+/mxIkTdO/eHYCUlBSys7O54YYbANi5cye5ubl07Wr5R/f7739QUJBP586Woabk5GSKiovpdL1lktykpCTKysro2NHSld++fTsAHTp0AGDbtm14eHgQExMDwJatW/Hx9qZdu3YAbN68GT8/f9q2bUNmZibp6ekEBQXRunVrADZs2EBoaCjR0dEArFu3jjp16nDdddcBsHbtWsLr1qVlC8s59tWrV9OgQQOaN7fM179q1W9ERUXStKnldpuVK1fSuEkTp/zd27w3k6zcAl69uQFN/QoJCAjg+eefZ8qUKbRr1461a9fywj/GE/PgK5i9/K/qd6/Wic34mswADPdYTpyH9XtbSBTfNPwHn3zyCUuWLMHf359Zs2YxdepUli9fjpeXFzNmzGDGjBnlk819/vnnfPPNN6xYsQKAjz/+mMWLF7N06VIAJk+ezM8//8yiRYsAmDhxIuvWrWP+/PkATJgwgcTERObMmQPAG2+8QUpKCtM6JfK5Os1noaF4lPoyYF8n3vCcDcCxsmDqvXEQsEyNXVBQwEcffQTA2LFjAZg0aRIATz31FH5+fkycOBGAUaNGUadOHd5+2/LRNGLECKKiovjnPy0z9zz44INER0fzj3/8A4D77ruP2NhYXnzxRQAGDx5M9+7dyxfsGThwIH369OGZZ54BoH///tx5552MHj0agL59+zJ06FAee+wxAOLj43n44Yd5+OGHKSkp4ZZbbmHkyJE8+OCD5Ofnc/vtt/Pkk08ydOhQcnJyGDRoEE8//TT33HMPWVlZ3HvvvaxcuXKL1rrScV+bCoI9KKXuBfpprUdat4cDN2itx1zQbhQwCsC3XtNOHZ6cjIeHZeKroqJiPD09LNsaioortrWG4uJiPD098fAwXXbby9MT07nbXp6YTCa01hQXl1xi2wuTSaHNmuKSim2zWVNyiW1vLy/UudveXiilMJvNlJSUXmLbG6XAXGampLRiu6zMTOkVt8soLS3Dx9sbzt32sVy2d+F2aWkZZWXnb5vLyvA+d9tchrf32e1SzGbzBdsab2+vS26XlJSi9fnboPHyuty2ZenD87cVXl6el9wuLi5BKcu22WymtLQMk0nh6Vnx+PnbxZhMpgu2PfD0tPwuFRcVY/Ko2C4qKsbjgu3y3zUn+93zUppeQcfp1rI+ZWVlmEwmMjIyaNSoEb6+vpw5c4bPEs+wIy+ABgFX97sXXJhR/m/yWc//0c9jMwAaxYIOX5CZmUmLFi0wmUycPHmSrKwsWrZsiVKKEydOcOLEifJinJWVxcmTJ8u3MzMzyc7OpmXLlgAcP36c06dP08JarI8dO0ZeXl55sT569Cj5+fk0a9YMgCNHjlBYWMjD+/+KQvOsuofFuxMJTC5k292HrTlhZfxCADIyMjCbzTRqZOlJHTxoKRRRUZbLWA8cOIDJZCIyMhKA/fv34+npSUREBAD79u3D29ubhg0bApYvV76+vjRo0ACAvXv34u/vT/36lst909LSCAwMpF69egCkpqYSHBxM3bqWCfj27NlDaGgo4eHhgOXLV+3atQkLCyvfrlOnDnXq1EFrzZ49ewgLC6N27dqYzWZSU1MJDw+nVq1alJWVkZaWRt26dQkNDaW0tJS9e/fy+OOPX3tBUEqt1lrfqJTKtR7T8ocArbW+6pmylFJ/Am67oCB01Vr/5XLPiY6O1ikpKVf7lm4lISFBbrqxkmNR4VLHYl3aCe7/fD1P9GrOi/2v8ia1D9pZThNdKCQK/pp8da9Z3awZy7Ri4C9RNFNH+L+bLV80cn0aEPTSLoMDGkcpZVNBuOJlp1rrG63/DdJaB5/zE3QtxcAqg/PnQ4oEDl/jawohzlFYUsbfv9tBo9r+PNOn5dW/UJ9Xwcvv/H1efpb9zqLPq5TiSaqO4PceE7i5l+X0ZbH2ZFPzpwwO5xpsGlRWStW+xO5crXXJNbz3JqClUqopcDHpzysAABeOSURBVAi4Dxh2Da8nhLjAxwlp7M06w8xHu+LnffWLz5QPHDvRVUYXiRnC1JVpBGZuA6C9SucUQSxvNJYlZ26Q1bxsYOtVRluxfJs/heV0UShwRCl1HHhMa72lqm+stS5VSo0BfsRy2el0rfXvVX0dIcSl7TmWyycJqdzdMYKeLcOv/QVjhjhXAbiEmNsfY8QXmzj1w7s8UT+Sf376NRNmb2PKsGZGR3MJthaEZcB3WusfAZRStwL9gLnAx8ANV/PmWuslwJKrea4Q4sr+tWQnAT6evHJHa6OjOExSRg6RtfzwbtaCRnVKiWsexpRhHUnKyJH7EGxg6yQnnc8WAwCt9U/ATVrr9YDMICWEEyopMxPk60ktf+/KG7uJR3o05eDJAu5//K889NBDAMQ1D+OJXs0NTuYabC0IJ5VSLyilGlt//gacst5cZrZjPiHEVRrapREHTxbwW2qW0VEcZvexXIrLzMREhhgdxSXZWhCGYbkKaAGwEGhk3ecBOPdJRSFqqNva1qN2gDezN+w3OorDJFmXz/zstWfKbxwTtrN1PYQsLOspX0pq9cURQlQXH08PhnSO4rNVaew6eppW9a/1SnHnl5SRTai/F927Xk96errRcVyOrdNfhyul3lVKLVFK/XL2x97hhBDX5vGbmhHk68U/F//BlW5CdRdJGTm0jwjhpZdeYtgwuYq9qmw9ZfQVsAvLOsrjgX1Y7iMQQjixWgHePHvLdaxNO8HS5KNGx7GrwpIyUo7lyvjBNbC1INTRWk8DSrTWK7XWjwDd7JhLCFFNHrihEe0ignn5ux0cySkwOo7d/HHkNGVmTUxkKIMHD+bVV53oLmoXYWtBOHtH8hGl1B1KqY5YBpmFEE7O08PEh/d1pLjUzDNzEikpc88LA5MOZgMQExlC9+7dadu2rcGJXI+tBeFNpVQI8BwwDpgK/NVuqYQQ1apZeCD/ursdG9NP8o8FyW45npB0KIfwIB/qB/sybtw4hg4danQkl2PrVUbfW/+YA/S2XxwhhL3c3TGS1ON5fPRrGpG1/Bhz8zVMdueEdmTkEBMR4pbLhjqKrZPbNcVy2WmTc59zLSumCSEcb9yt0RzOLmTiT7vxMJl4Mt497uDNKyolNTOPATGWNQoGDhzIiRMnWLNmjcHJXIutcxktAKYBi5E7k4VwWUop3r03hlKz5p1luyguNfN0nxYu/63690M5aE35FUZ9+vRhz549BqdyPbYWhEKt9Yd2TSKEcAhPDxMfDOmAl0nxwYrdHD1dwBuD2uHpYeuQovM5e4dye2tBeOaZZ8qX7BS2s7UgTFZKvQb8BBSd3am13mqXVEIIu/L0MDHxTx1oEOrLR7+mcfBkAe8P7UDdIF+jo12VpEM5RIT6ERYoc21eC1sLQntgOHAzFaeMtHVbCOGCTCbF87e1onHtAP6xMJn+k35j4p860LtVXaOjVdmOjGzaR1TckNa/f39OnjzJhg0bDEzlemwtCHcDzbTWxfYMI4RwvCFdoohtFMrTX29jxIxNjOjRhBf6tcLX6xpWWHOgnPwS9p3IZ0iXihV577zzTnbv3m1gKtdk60nD7VhWSRNCuKHr6gWx4KkePBzXhC/W7OOuj9aw51iu0bFskmLN2aZBxeR9o0eP5q677jIqksuytSDUA3YppX5USi06+2PPYEIIx/L18uD1gW2Z/nBnMnOLGPB/q5m1fr/T38SWcSofgEa1/Q1O4vpsPWX0WnW+qVLqT8DrQGugq9Z6c3W+vhDi6t3cqh5Lx/bkubnbeWVBMqt2Z/LO4BhqBTjnymuHTlnmZ2oY6le+r2/fvpw6dYotW6q83HuNZuudyiur+X2TgXuA/1Tz6wohqkHdIF/+O6Ir09ek886yXfSbvIoPhsQS18L51iXOOFVAeJDPeWMeQ4cOJSUlxcBUrumKp4yUUrlKqdOX+MlVSp2+2jfVWu/UWsv/LSGcmMmkGNmzGd+N7kGAjycPTNvAO8t2Od3keBnZ+UTW8jtv32OPPcaAAQMMSuS6lJHnB5VSCcC4K50yUkqNAkYBhIeHd5o7d66D0jm3vLw8AgMDjY7hFORYVLDXsSgq1czeVczKjFKahph4IsaHegHOcSPbC6vyaRxsYnTs+fdQyO9Fhd69e2/RWneurJ3dCoJSagVQ/xIP/V1rvdDaJoFKCsK5oqOjtXQDLRISEoiPjzc6hlOQY1HB3sdi6Y4jvPjtDkrLzLw3JJZ+7S71T9xxzGZN9D+W8uiNzXixf6vy/fHx8WRnZ5OYmGhgOuehlLKpINg6qFxlWuu+9nptIYQx+rdvQIeoUEZ/tZW/fL2VqX/uQq/rwg3Lczy3iJIyfdEpo4cffphdu3YZlMp1OUefTwjhMhqG+vHlo11pWTeIJ2ZuYcv+k4ZlOXvJacQlCkK/fv2MiOTSDCkISqm7lVIZQHfgB6XUj0bkEEJcnWBfL/77SFfqBfsw4otN7Dxy1deYXJND2ZZLTqMuKAglJSWUlpYaEcmlGVIQtNbfaa0jtdY+Wut6WuvbjMghhLh64UE+zHz0Bvy9PXlo+kb2nzjj8AwZ1nsQIkLPvyntlltuYdy4cQ7P4+rklJEQ4qpF1fZn5qNdKSkzM3zaRo6fLnTo+2ecyqdOgDd+3ufPuzRy5EjuuOMOh2ZxB1IQhBDXpGW9IGaM6EpWXhHj5iU59L0zThVcNKAM8OCDD3LLLbc4NIs7kIIghLhmsVGhdGpci5yCEoe+76FTBRcNKAPk5+dTWOjY3oo7sNtlp0KImiUzt4jIWo6dYO50YQmKi5f/vP3228nOzpYrjapIeghCiGqRmVtE3WDHrlg2IKYhP/1x9KKxiyeffJKBAwc6NIs7kIIghLhmJWVmTuYXE+7gJSxH9GhCqVnz5br95+0fOnQoN98sCzpWlRQEIcQ1O5FXjNY4vIfQuE4AfVvX46sN+yksKSvfn5OTQ15enkOzuAMpCEKIa5aZWwTg8B4CwKM3NuVUfgnfbj1Uvm/QoEG88sorDs/i6qQgCCGu2fFcyzn8usG+lbSsfjc0rU27iGCmr0kvX93t6aef5p577nF4FlcnBUEIcc2Onbb2EIIc30NQSvHojU1JPZ7Hyt2ZANxzzz3cdNNNDs/i6qQgCCGuSUFxGVNX76V+sC/1DCgIAHe0b0jdIB+mrU4HICsri5ycHEOyuDIpCEKIa/LmD3+QnnWG94Z0wNPDmI8Ub08Tf45rwm97skg5msu9997La69V61LwNYIUBCFElXy6Mo21aVkALP/jGF9tOMAd7Ruw45Cx38iHdW2Er5eJaav38txzzzFkyBBD87giKQhCiCqJiQxhzOxt/LDjMC/MT6JJHX/WpGYRExliaK5aAd4M6RzFt1sPERN3M3FxcYbmcUVSEIQQVRLXPIwP74/lmTmJnC4o4VR+CR89cD1xzcOMjsaY3i3w8jDx+jdrOHnSuIV7XJUUBCFElXVrWocOkSGUmjV/7t7YKYoBWC57HdmzKV9PeI6XXx1vdByXIwVBCFFlG/edJD0rn6dvbsGsDQfKxxScwaibmhEZfz+BN9xbfl+CsI0UBCFElaxNy2LM7G1MGdaRZ2+NZsqwjoyZvc1pikKQrxd/f/x+ssKv57c9zpHJVRi1pvK7SqldSqkkpdR3SqlQI3IIIaouKSOHKcM6lp8mimsexpRhHUnKcJ7r/ns2VIQUZzFh6S7MZukl2MqoHsJyoJ3WOgbYDbxkUA4hRBU90av5RWMGcc3DeKJXc4MSXWzkiIfJXfY+fxw5zdLko0bHcRmGFASt9U9a61Lr5nog0ogcQgj39Morr/DkI8NpHh7A5J93Sy/BRsroQRel1GLgG631rMs8PgoYBRAeHt5p7ty5jozntPLy8ggMDDQ6hlOQY1FBjkWFvLw8kk/78mlSEaNjfehav+YuENm7d+8tWuvOlbWzW0FQSq0A6l/iob9rrRda2/wd6Azco20IEh0drVNSUqo3qItKSEggPj7e6BhOQY5FBTkWFnv37mX9+vUMve9+bv1gJR4mxbJnbsJkuni5zZpAKWVTQbBbydRa973S40qpPwMDgD62FAMhhLDVI488QnZ2NsOGDePpPi15Zk4iS5OPckdMA6OjOTWjrjLqB7wADNRa5xuRQQjhvsaPH8/DDz8MWNZdbhoWwKcr0+S+hEoYdZXRFCAIWK6USlRKfWpQDiGEG+rVqxexsbEAeJgs6yXsOJTDhnSZzuJKjLrKqIXWOkprHWv9ecKIHEII95SSksKBAwfKtwdfH0ktfy+m/rbXwFTOT+5UFkK4nccff5z333+/fNvP24Ph3RqzYudx0jLzDEzm3KQgCCHczltvvcXIkSPP2ze8exO8PBSz1u83KJXzk4IghHA7cXFxtGvX7rx94UE+3Na2PvO3ZFBYUmZQMucmBUEI4XaSk5NJT0+/aP8DNzTmdGEpPyQdMSCV85OCIIRwO2PGjGHy5MkX7e/WrDbNwgP4euOBSzxLSEEQQridd999lyeeuPjiRaUUg6+PZPP+UxzKLjAgmXOTgiCEcDtdunShVatWl3xsgPVu5R+SDjsykkuQgiCEcDuJiYmkpqZe8rHGdQKIiQzhexlHuIgUBCGE2xk7dixTpky57OMDYhqQlJHDvqwzDkzl/KQgCCHczqRJkxgzZsxlH78jpiEA38tpo/NIQRBCuJ3Y2FhatGhx2ccjQv3o1LiWnDa6gBQEIYTb2bRpE7t27bpim1va1GPX0VyOnS50UCrnJwVBCOF2nn/+eT799MqTKPdsaVkX+rc9WY6I5BJq7ppyQgi3NWXKFDZt2nTFNq3rBxMW6M3qPZnc20mWdQcpCEIIN9SuXTuysq78zd9kUvRoEcbq1CzMZl1jl9c8l5wyEkK4nbVr15KcnFxpu54tw8nKK2bX0VwHpHJ+UhCEEG7n5ZdfZurUqZW269asNgBb9stKaiCnjIQQbug///kPGzZsqLRdRKgfYYE+JB7MYXh3BwRzcob0EJRSbyilkqzrKf+klGpoRA4hhHuKjo6mUaNGlbZTShEbFcL2jGwHpHJ+Rp0yeldrHaO1jgW+B141KIcQwg2tXLmSxMREm9p2iAwlLTOP04Uldk7l/AwpCFrr0+dsBgDaiBxCCPf02muvMWPGDJvaxkSFojUkH8qxbygXYNgYglLqX8BDQA7Q26gcQgj3M336dNavX29T2+h6QQCkHc8jrnmYPWM5PaW1fb6cK6VWAPUv8dDftdYLz2n3EuCrtX7tMq8zChgFEB4e3mnu3Ln2iOty8vLyCAwMNDqGU5BjUUGORQVbj4XWmidX5NMjwpPhbXwckMzxevfuvUVr3bmydnYrCLZSSjUGftBat6usbXR0tE5JSXFAKueXkJBAfHy80TGcghyLCnIsLFasWMH27dt57rnnbGo/aMpqgny9mDXyBjsnM4ZSyqaCYNRVRi3P2RwIXHkWKiGEqII333yTmTNn2ty+eXggaZl5dkzkGowaQ5iglIoGzMB+4OLFT4UQ4irNnDmTdevW2dw+spYfx04XUlpmxtOj5t6va0hB0FoPNuJ9hRA1Q1RUFGlpaTa3rx/ih1nD8dwiGob62TGZc6u5pVAI4baWLVvGxo0bbW7fIMQXgCM5NXttBCkIQgi3M2HCBGbPnm1z+3rBloJwvIYvliNzGQkh3M6cOXNYu3atze2D/SwfhbmFpfaK5BKkhyCEcDv169endu3aNrcP8vECILdICoIQQriVxYsXV6mHEODjAUCe9BCEEMK9vPfee1RlVgNPDxP+3h7kFdXsCe5kDEEI4XbmzZvHmjVrqvQcf29P8orK7JTINUgPQQjhdsLCwggJCanSc5SCmj7xshQEIYTb+fbbb1m1alWVnmOZ1k3ZJY+rkIIghHA7H374Id9++20Vn6WtvYSaS8YQhBBuZ+HChfz2229Vfl4NrwfSQxBCuJ+QkJAqrwtRVGrGqwZPbAdSEIQQbuibb77hl19+sbm92azJKyol2LdmnzSRgiCEcDuffPIJixYtsrl9XnEpWkOQr5cdUzm/ml0OhRBuacmSJVW6yujsHEZB0kMQQgj34u/vj6+vr83tT50pBiDUv2b3EKQgCCHczqxZs1i+fLnN7Y9a10GoH1JzF8cBKQhCCDc0depUfvjhB5vbH8kpAKBhiO29CndUs0+YCSHc0vLly1m5cqXN7Y/kFOJpUtQJ9LFjKudnaA9BKTVOKaWVUmFG5hBCuBcvLy88PW3/vrv/RD4NQ/3wMNXsW9MMKwhKqSjgFuCAURmEEO5pxowZLFu2zOb2u4/lcl29qt3I5o6M7CF8APyNmj69oBCi2lWlIJSUmUnPOkPLekF2TuX8lNaO/zxWSg0E+mitn1FK7QM6a62zLtN2FDDKutkOSHZMSqcXBlzymNVAciwqyLGoIMeiQrTWutKKZ7eCoJRaAdS/xEN/B14GbtVa51RWEC54zc1a687Vm9Q1ybGoIMeighyLCnIsKth6LOx2lZHWuu+l9iul2gNNge3KMtdsJLBVKdVVa33UXnmEEEJcmcMvO9Va7wDqnt2uSg9BCCGE/bjajWmfGR3AicixqCDHooIciwpyLCrYdCwMGVQWQgjhfFythyCEEMJOpCAIIYQAXLAgKKVilVLrlVKJSqnNSqmuRmcyklLqL0qpFKXU70qpfxudx2gyHQoopd5VSu1SSiUppb5TSoUancmRlFL9rP8mUpVSLxqdxyhKqSil1K9KqZ3Wz4dnKnuOyxUE4N/AeK11LPCqdbtGUkr1BgYBMVrrtsBEgyMZSqZDKbccaKe1jgF2Ay8ZnMdhlFIewEdAf6ANcL9Sqo2xqQxTCjyntW4NdAOequxYuGJB0ECw9c8hwGEDsxjtSWCC1roIQGt93OA8RpPpUACt9U9a61Lr5nos9/rUFF2BVK31Xq11MTAHy5emGkdrfURrvdX651xgJxBxpee4YkEYC7yrlDqI5Rtxjfn2cwnXAT2VUhuUUiuVUl2MDmQU63Qoh7TW243O4mQeAZYaHcKBIoCD52xnUMmHYE2glGoCdAQ2XKmdU66HUMm0F32Av2qt5yulhgDTgEveFe0OKjkWnkAtLN3BLsBcpVQz7abXEtsyHYpjExnnSsdCa73Q2ubvWE4bfOXIbAa71PzVbvnvwVZKqUBgPjBWa336im1d7bNDKZUDhGqttbLMfZGjtQ6u7HnuSCm1DMspowTrdhrQTWudaWgwB7NOh/IzkG/dFYnlVGKNnQ5FKfVn4Aksk0jmV9beXSilugOva61vs26/BKC1ftvQYAZRSnkB3wM/aq3fr6y9K54yOgz0sv75ZmCPgVmMtgDLMUApdR3gTQ2c3VFrvUNrXVdr3URr3QTLaYLra3Ax6Ae8AAysScXAahPQUinVVCnlDdwHLDI4kyGsX5inATttKQbgpKeMKvEYMFkp5QkUUjE1dk00HZiulEoGioE/u+vpIlElUwAfYLl1Asn1WusnjI3kGFrrUqXUGOBHwAOYrrX+3eBYRukBDAd2KKUSrfte1lovudwTXO6UkRBCCPtwxVNGQggh7EAKghBCCEAKghBCCCspCEIIIQApCEIIIaykIAhxBUqpMuvMuslKqcXXMnOoUmpfTZ6FVTg/KQhCXFmB1jpWa90OOAk8ZXQgIexFCoIQtlvHOROlKaWeV0ptsq47MP6c/QuUUlusc9DX5BsnhYuRgiCEDazz7PfBOg2CUupWoCWW6ZZjgU5KqZuszR/RWncCOgNPK6XqGBBZiCqTgiDElflZb/s/AdTGsvgMWGZWvRXYBmwFWmEpEGApAtuxrEUQdc5+IZyaFAQhrqzAujpfYyyTB54dQ1DA29bxhVitdQut9TSlVDyW6di7a607YCkYvkYEF6KqpCAIYQOtdQ7wNDDOOqXwj8Aj1rnmUUpFKKXqYlnF75TWOl8p1QrLWhVCuARXnO1UCENorbdZTwXdp7WeqZRqDayzziiaBzwILAOeUEolASlYThsJ4RJktlMhhBCAnDISQghhJQVBCCEEIAVBCCGElRQEIYQQgBQEIYQQVlIQhBBCAFIQhBBCWP0/3Oqyql7VtzgAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "s = control.tf([1, 0], [0, 1])\n",
+    "# this is a PID controller with an extra pole at the origin\n",
+    "pitch_rate_control_design(500, -1300*((s + 3 + 5j)*(s + 3 - 5j)/s**2), [-8, 2], [-4, 4])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'Gc' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-30-aaf597c96489>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcontrol\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep_response\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mGc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mT\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinspace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1000\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'Gc' is not defined"
+     ]
+    }
+   ],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.0753603, -27.9939, 0.314159]\n",
+      "{'x0': array([100.   ,   0.314,   0.314,   0.   ,   0.   ,   0.   ]), 'u0': array([  0.075, -27.994,   0.25 ,   0.   ]), 's': array([  0.075, -27.994,   0.314])}\n",
+      "1 states have been removed from the model\n",
+      "u_norm max 8946.358858834441\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pitch_rate_control_design(100, -2000*((s + 1 )*(s + 1 )/s**2), [-3, 1], [-2, 2])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def lqr_design(out_num, in_num, tf=3, R=1e-5, y_max=1.5):\n",
+    "    trim_500 = trim(vt=500, h=0, q=0, gamma=0)\n",
+    "    # input: thtl, elev, xcg, land\n",
+    "    # state: vt, alpha, theta, q, h, pos\n",
+    "    sys = control.minreal(linearize(trim_500)[out_num, in_num], 1e-3)\n",
+    "    assert np.linalg.matrix_rank(control.ctrb(sys.A, sys.B)) == sys.A.shape[0]\n",
+    "    assert np.linalg.matrix_rank(control.obsv(sys.A, sys.C)) == sys.A.shape[0]\n",
+    "\n",
+    "    Q = sys.C.T.dot(sys.C)\n",
+    "    K, S, E = control.lqr(sys, Q, R)\n",
+    "    sys_c = control.ss( sys.A - sys.B*K, sys.B, sys.C, sys.D)\n",
+    "    final_value = float(sys_c.horner(0))\n",
+    "    N = 1.0/final_value\n",
+    "    sys_c = control.ss( sys.A - sys.B*K, sys.B*N, sys.C, sys.D)\n",
+    "\n",
+    "    t = np.linspace(0, tf, 1000)\n",
+    "    r = np.array(t > 0.1, dtype=float)\n",
+    "    t, y, x = control.forced_response(sys_c, T=np.linspace(0, tf, 1000), U=r)\n",
+    "    u_norm = np.linalg.norm(K.dot(x), axis=0)\n",
+    "    max_u_norm = np.max(u_norm)\n",
+    "    print('u_norm max', max_u_norm)\n",
+    "\n",
+    "    plt.plot(t, r, 'r--', label='r')\n",
+    "    plt.plot(t, y, 'b-', label='y')\n",
+    "    plt.plot(t, u_norm/max_u_norm, 'g-', label='u normalized')\n",
+    "    plt.gca().set_ylim(-0.1, y_max)\n",
+    "    plt.grid()\n",
+    "    plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.292673, 2.4607, 0.0101196]\n",
+      "1 states have been removed from the model\n",
+      "u_norm max 324.04247010257035\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "lqr_design(2, 1, tf=10, R=1e-5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here we see that the LQR is not able to design a reasonable pitch rate controller."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.292673, 2.4607, 0.0101196]\n",
+      "1 states have been removed from the model\n",
+      "u_norm max 61120.83319605678\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "lqr_design(3, 1, tf=10, R=1e-5, y_max=1.5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here we see the LQR is doing a poor job of designing a pitch rate controller. This is likely because none of the\n",
+    "states provide derivative of the pitch rate signal to prevent overshoot."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "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.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/lectures/Homework3.ipynb b/lectures/Homework3.ipynb
new file mode 100644
index 00000000..84af7e42
--- /dev/null
+++ b/lectures/Homework3.ipynb
@@ -0,0 +1,780 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import casadi as ca\n",
+    "import matplotlib.pyplot as plt\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$m \\ddot{x} + c \\dot{x} + k x + sin(x) = u$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$\\vec{x} = \\begin{bmatrix}\n",
+    "x \\\\\n",
+    "\\dot{x}\n",
+    "\\end{bmatrix}$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$\\vec{u} = \\begin{bmatrix} u\\end{bmatrix}$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$\\vec{y} = \\vec{g}(\\vec{x}) = \\begin{bmatrix} x\\end{bmatrix}$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$\\ddot{x} = (-c \\dot{x} - kx + u)/m$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$\\dot{\\vec{x}} = \\vec{f}(\\vec{x}) = \\begin{bmatrix}\n",
+    "\\dot{x} \\\\\n",
+    "(-c \\dot{x} - kx - sin(x) + u)/m\n",
+    "\\end{bmatrix}$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$\\dot{\\vec{x}} = A \\vec{x} + B \\vec{u}$\n",
+    "\n",
+    "$\\vec{y} = C \\vec{x} + D \\vec{u}$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$A = \\dfrac{\\partial \\vec{f}}{\\partial \\vec{x}}$\n",
+    "\n",
+    "$B = \\dfrac{\\partial \\vec{f}}{\\partial \\vec{u}}$\n",
+    "\n",
+    "$C = \\dfrac{\\partial \\vec{g}}{\\partial \\vec{x}}$\n",
+    "\n",
+    "$D = \\dfrac{\\partial \\vec{g}}{\\partial \\vec{u}}$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "SX([x_1, (((u-(((c*x_1)+(k*x_0))+sin(x_0)))+3)/m)])"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "m = ca.SX.sym('m')\n",
+    "c = ca.SX.sym('c')\n",
+    "k = ca.SX.sym('k')\n",
+    "p = ca.vertcat(m, c, k)\n",
+    "\n",
+    "u = ca.SX.sym('u')\n",
+    "xv = ca.SX.sym('x', 2)\n",
+    "x = xv[0]\n",
+    "xd = xv[1]\n",
+    "\n",
+    "y = x\n",
+    "\n",
+    "xv_dot = ca.vertcat(xd, (-c*xd - k*x - ca.sin(x) + u + 3)/m)\n",
+    "xv_dot"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Function(rhs:(x[2],u,p[3])->(x_dot[2]) SXFunction)"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "f_rhs = ca.Function('rhs', [xv, u, p], [xv_dot], ['x', 'u', 'p'], ['x_dot'], {'jit': True})\n",
+    "f_rhs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "DM([2, -4.84147])"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "f_rhs([1, 2], [0], [1, 2, 3])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import scipy.integrate\n",
+    "import numpy as np\n",
+    "tf = 10\n",
+    "res = scipy.integrate.solve_ivp(\n",
+    "    fun=lambda t, x: np.array(f_rhs(x, 0.0, [1, 2, 3])).reshape(-1),\n",
+    "    t_span=[0, tf],\n",
+    "    y0=[0, 0], t_eval=np.arange(0, tf, 0.1))\n",
+    "plt.plot(res['t'], res['y'][0, :]);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "SX(\n",
+       "[[00, 1], \n",
+       " [(-((k+cos(x_0))/m)), (-(c/m))]])"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "A = ca.jacobian(xv_dot, xv)\n",
+    "A"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "SX([00, (1./m)])"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "B = ca.jacobian(xv_dot, u)\n",
+    "B"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "SX([[1, 00]])"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "C = ca.jacobian(y, xv)\n",
+    "C"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "SX(00)"
+      ]
+     },
+     "execution_count": 35,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "D = ca.jacobian(y, u)\n",
+    "D"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Function(f_ss:(x[2],p[3])->(A[2x2,3nz],B[2x1,1nz],C[1x2,1nz],D[1x1,0nz]) SXFunction)"
+      ]
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "f_ss = ca.Function('f_ss', [xv, p], [A, B, C, D], ['x', 'p'], ['A', 'B', 'C', 'D'])\n",
+    "f_ss"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "A = [[ 0.  1.]\n",
+       " [-4. -2.]]\n",
+       "\n",
+       "B = [[0.]\n",
+       " [1.]]\n",
+       "\n",
+       "C = [[1. 0.]]\n",
+       "\n",
+       "D = [[0.]]"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import control\n",
+    "sys = control.ss(*f_ss([0, 0], [1, 2, 3]))\n",
+    "sys"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'rhs.c'"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "f_rhs.generate('rhs.c')\n",
+    "#!cat rhs.c"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "s = control.TransferFunction([1, 0], [0, 1])\n",
+    "H = (s + 2)\n",
+    "control.rlocus(H*sys);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$$\\frac{s + 2}{s^2 + 2 s + 4}$$"
+      ],
+      "text/plain": [
+       "\n",
+       "    s + 2\n",
+       "-------------\n",
+       "s^2 + 2 s + 4"
+      ]
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "H*sys"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Linear Time Invariant Systems (LTI)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* Transfer Functions: $G(s) = s/(s+1)$\n",
+    "* State-space: $\\dot{x} = Ax + Bu$, $y = Cx + Du$\n",
+    "* Impulse response function: $g(t)$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* $\\dot{x} = a_1 x + a_2 x + b u$, $y = c x + du$ Linear?  (Yes) Because A = A1 + A2\n",
+    "* $\\dot{x} = a_1 x + 3 + b u$, $y = c x + du$ Linear?  (No, not a linear system)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* What u would balance this equation at x=0?  -> u0 = -3/b (trim input)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For compensated dynamcis to be $G(s) = 1/(s+1)$,  u(x)=?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* LTI $\\implies$ zero in -> zero out"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$u(x) = (-a1 x - x - 3)/b$\n",
+    "\n",
+    "$\\dot{x} = -x$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Trimming the MSD"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "DM([0, 0])"
+      ]
+     },
+     "execution_count": 43,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "f_rhs([0, 0], [-3], [1, 2, 3])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$\\dot{x} = Ax + Bu$, $y = Cx + Du + 3$   (non-linear -> violates zero in zero out law)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Trimming an aircraft means, finding where the rhs = 0,  or $f(t, x) = 0$, in order to do this we want to minimize\n",
+    "$dot(f(t, x), f(t, x))$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def trim_function(xv_dot):\n",
+    "#    return xv_dot[0] + xv_dot[1] # BAD, will drive to -inf\n",
+    "    return xv_dot[0]**2 + xv_dot[1]**2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This design problems find the state at which a given input will drive the sytem to.\n",
+    "\n",
+    "* x is the design vector\n",
+    "* f is the objective function\n",
+    "* p is a list of constant parameters\n",
+    "* S is the solver itself"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "S:(x0[2],p[4],lbx[2],ubx[2],lbg[0],ubg[0],lam_x0[2],lam_g0[0])->(x[2],f,g[0],lam_x[2],lam_g[0],lam_p[4]) IpoptInterface\n"
+     ]
+    }
+   ],
+   "source": [
+    "nlp = {'x':xv, 'f':trim_function(xv_dot), 'p': ca.vertcat(p, u)}\n",
+    "S = ca.nlpsol('S', 'ipopt', nlp)\n",
+    "print(S)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "This is Ipopt version 3.12.3, running with linear solver mumps.\n",
+      "NOTE: Other linear solvers might be more efficient (see Ipopt documentation).\n",
+      "\n",
+      "Number of nonzeros in equality constraint Jacobian...:        0\n",
+      "Number of nonzeros in inequality constraint Jacobian.:        0\n",
+      "Number of nonzeros in Lagrangian Hessian.............:        3\n",
+      "\n",
+      "Total number of variables............................:        2\n",
+      "                     variables with only lower bounds:        0\n",
+      "                variables with lower and upper bounds:        0\n",
+      "                     variables with only upper bounds:        0\n",
+      "Total number of equality constraints.................:        0\n",
+      "Total number of inequality constraints...............:        0\n",
+      "        inequality constraints with only lower bounds:        0\n",
+      "   inequality constraints with lower and upper bounds:        0\n",
+      "        inequality constraints with only upper bounds:        0\n",
+      "\n",
+      "iter    objective    inf_pr   inf_du lg(mu)  ||d||  lg(rg) alpha_du alpha_pr  ls\n",
+      "   0  9.0000000e+00 0.00e+00 2.40e+01  -1.0 0.00e+00    -  0.00e+00 0.00e+00   0\n",
+      "   1  4.6732591e-03 0.00e+00 5.10e-01  -1.0 7.50e-01    -  1.00e+00 1.00e+00f  1\n",
+      "   2  3.1560062e-07 0.00e+00 2.50e-03  -1.7 1.80e-02    -  1.00e+00 1.00e+00f  1\n",
+      "   3  5.2554628e-15 0.00e+00 4.41e-07  -3.8 4.50e-04    -  1.00e+00 1.00e+00f  1\n",
+      "   4  1.5117267e-30 0.00e+00 6.61e-15  -8.6 4.18e-08    -  1.00e+00 1.00e+00f  1\n",
+      "\n",
+      "Number of Iterations....: 4\n",
+      "\n",
+      "                                   (scaled)                 (unscaled)\n",
+      "Objective...............:   1.5117267303341599e-30    1.5117267303341599e-30\n",
+      "Dual infeasibility......:   6.6063745872867690e-15    6.6063745872867690e-15\n",
+      "Constraint violation....:   0.0000000000000000e+00    0.0000000000000000e+00\n",
+      "Complementarity.........:   0.0000000000000000e+00    0.0000000000000000e+00\n",
+      "Overall NLP error.......:   6.6063745872867690e-15    6.6063745872867690e-15\n",
+      "\n",
+      "\n",
+      "Number of objective function evaluations             = 5\n",
+      "Number of objective gradient evaluations             = 5\n",
+      "Number of equality constraint evaluations            = 0\n",
+      "Number of inequality constraint evaluations          = 0\n",
+      "Number of equality constraint Jacobian evaluations   = 0\n",
+      "Number of inequality constraint Jacobian evaluations = 0\n",
+      "Number of Lagrangian Hessian evaluations             = 4\n",
+      "Total CPU secs in IPOPT (w/o function evaluations)   =      0.004\n",
+      "Total CPU secs in NLP function evaluations           =      0.000\n",
+      "\n",
+      "EXIT: Optimal Solution Found.\n",
+      "               t_proc [s]   t_wall [s]    n_eval\n",
+      "           S      0.00706       0.0153         1\n",
+      "       nlp_f        3e-05     2.79e-05         5\n",
+      "    nlp_grad        9e-06     6.35e-06         1\n",
+      "  nlp_grad_f      3.5e-05     3.23e-05         6\n",
+      "  nlp_hess_l        2e-05     1.94e-05         4\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'f': DM(1.51173e-30),\n",
+       " 'g': DM([]),\n",
+       " 'lam_g': DM([]),\n",
+       " 'lam_p': DM([1.57772e-30, 1.51029e-30, 1.36486e-15, -1.77636e-15]),\n",
+       " 'lam_x': DM([0, 0]),\n",
+       " 'x': DM([0.76835, 8.50215e-16])}"
+      ]
+     },
+     "execution_count": 58,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "S(x0=(0, 0), p=(1, 2, 3, 0))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "S:(x0,p[5],lbx,ubx,lbg[0],ubg[0],lam_x0,lam_g0[0])->(x,f,g[0],lam_x,lam_g[0],lam_p[5]) IpoptInterface\n"
+     ]
+    }
+   ],
+   "source": [
+    "nlp = {'x':u, 'f':trim_function(xv_dot), 'p': ca.vertcat(p, xv)}\n",
+    "S2 = ca.nlpsol('S', 'ipopt', nlp)\n",
+    "print(S2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "This is Ipopt version 3.12.3, running with linear solver mumps.\n",
+      "NOTE: Other linear solvers might be more efficient (see Ipopt documentation).\n",
+      "\n",
+      "Number of nonzeros in equality constraint Jacobian...:        0\n",
+      "Number of nonzeros in inequality constraint Jacobian.:        0\n",
+      "Number of nonzeros in Lagrangian Hessian.............:        1\n",
+      "\n",
+      "Total number of variables............................:        1\n",
+      "                     variables with only lower bounds:        0\n",
+      "                variables with lower and upper bounds:        0\n",
+      "                     variables with only upper bounds:        0\n",
+      "Total number of equality constraints.................:        0\n",
+      "Total number of inequality constraints...............:        0\n",
+      "        inequality constraints with only lower bounds:        0\n",
+      "   inequality constraints with lower and upper bounds:        0\n",
+      "        inequality constraints with only upper bounds:        0\n",
+      "\n",
+      "iter    objective    inf_pr   inf_du lg(mu)  ||d||  lg(rg) alpha_du alpha_pr  ls\n",
+      "   0  9.0000000e+00 0.00e+00 6.00e+00  -1.0 0.00e+00    -  0.00e+00 0.00e+00   0\n",
+      "   1  0.0000000e+00 0.00e+00 0.00e+00  -1.0 3.00e+00    -  1.00e+00 1.00e+00f  1\n",
+      "\n",
+      "Number of Iterations....: 1\n",
+      "\n",
+      "                                   (scaled)                 (unscaled)\n",
+      "Objective...............:   0.0000000000000000e+00    0.0000000000000000e+00\n",
+      "Dual infeasibility......:   0.0000000000000000e+00    0.0000000000000000e+00\n",
+      "Constraint violation....:   0.0000000000000000e+00    0.0000000000000000e+00\n",
+      "Complementarity.........:   0.0000000000000000e+00    0.0000000000000000e+00\n",
+      "Overall NLP error.......:   0.0000000000000000e+00    0.0000000000000000e+00\n",
+      "\n",
+      "\n",
+      "Number of objective function evaluations             = 2\n",
+      "Number of objective gradient evaluations             = 2\n",
+      "Number of equality constraint evaluations            = 0\n",
+      "Number of inequality constraint evaluations          = 0\n",
+      "Number of equality constraint Jacobian evaluations   = 0\n",
+      "Number of inequality constraint Jacobian evaluations = 0\n",
+      "Number of Lagrangian Hessian evaluations             = 1\n",
+      "Total CPU secs in IPOPT (w/o function evaluations)   =      0.002\n",
+      "Total CPU secs in NLP function evaluations           =      0.000\n",
+      "\n",
+      "EXIT: Optimal Solution Found.\n",
+      "               t_proc [s]   t_wall [s]    n_eval\n",
+      "           S      0.00292       0.0022         1\n",
+      "       nlp_f        8e-06        7e-06         2\n",
+      "    nlp_grad        6e-06     4.48e-06         1\n",
+      "  nlp_grad_f      8.9e-05      1.3e-05         3\n",
+      "  nlp_hess_l        3e-06     2.93e-06         1\n",
+      "we need a trim input of -3.000000\n"
+     ]
+    }
+   ],
+   "source": [
+    "res = S(x0=(0), p=(1, 2, 3, 0, 0))\n",
+    "print('we need a trim input of {:f}'.format(float(res['x'])))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "S=2170.0\n",
+    "BAR = 17.5\n",
+    "Tstat = 6.0E4\n",
+    "MASS=5.0E3 \n",
+    "IYY= 4.1E6\n",
+    "DTDV =-38.0\n",
+    "ZE= 2.0\n",
+    "CDCLS= .042\n",
+    "CLA = .085 \n",
+    "CMA=−.022\n",
+    "CMDE =-.016 \n",
+    "# per degree\n",
+    "CMQ =-16.0 \n",
+    "CMADOT= -6.0\n",
+    "CLADOT= 0.0\n",
+    "# per radian\n",
+    "RTOD = 57.29578 \n",
+    "GD=32.17\n",
+    "Thtl = ca.SX.sim('thtl')\n",
+    "Elev = ca.SX.sim('elev')\n",
+    "Xcg = ca.SX.sim('xcg')\n",
+    "Land = ca.SX.sim('land')\n",
+    "u = ca.vertcat(Throttle, Elev, Xcg, Land)\n",
+    "VT = ca.SX.sim('vt')\n",
+    "ALPHA = ca.SX.sim('alpha')     # A.O.A.\n",
+    "THETA= ca.SX.sim('theta')   # PITCH ATTITUDE\n",
+    "Q = ca.SX.sim('Q')    # PITCH RATE\n",
+    "H= ca.SX.sim('H');# ALTITUDE\n",
+    "x = \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "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.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/lectures/ROCKET.ipynb b/lectures/ROCKET.ipynb
new file mode 100644
index 00000000..934c7a4f
--- /dev/null
+++ b/lectures/ROCKET.ipynb
@@ -0,0 +1,43 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import casadi as ca\n",
+    "import numpy as np\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "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.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/lectures/gen.c b/lectures/gen.c
new file mode 100644
index 00000000..aeeabbf1
--- /dev/null
+++ b/lectures/gen.c
@@ -0,0 +1,114 @@
+/* This file was automatically generated by CasADi.
+   The CasADi copyright holders make no ownership claim of its contents. */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* How to prefix internal symbols */
+#ifdef CODEGEN_PREFIX
+  #define NAMESPACE_CONCAT(NS, ID) _NAMESPACE_CONCAT(NS, ID)
+  #define _NAMESPACE_CONCAT(NS, ID) NS ## ID
+  #define CASADI_PREFIX(ID) NAMESPACE_CONCAT(CODEGEN_PREFIX, ID)
+#else
+  #define CASADI_PREFIX(ID) gen_ ## ID
+#endif
+
+#include <math.h>
+
+#ifndef casadi_real
+#define casadi_real double
+#endif
+
+#ifndef casadi_int
+#define casadi_int long long int
+#endif
+
+/* Add prefix to internal symbols */
+#define casadi_f0 CASADI_PREFIX(f0)
+#define casadi_s0 CASADI_PREFIX(s0)
+#define casadi_sq CASADI_PREFIX(sq)
+
+/* Symbol visibility in DLLs */
+#ifndef CASADI_SYMBOL_EXPORT
+  #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+    #if defined(STATIC_LINKED)
+      #define CASADI_SYMBOL_EXPORT
+    #else
+      #define CASADI_SYMBOL_EXPORT __declspec(dllexport)
+    #endif
+  #elif defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+    #define CASADI_SYMBOL_EXPORT __attribute__ ((visibility ("default")))
+  #else
+    #define CASADI_SYMBOL_EXPORT
+  #endif
+#endif
+
+static const casadi_int casadi_s0[5] = {1, 1, 0, 1, 0};
+
+casadi_real casadi_sq(casadi_real x) { return x*x;}
+
+/* y:(x)->(y) */
+static int casadi_f0(const casadi_real** arg, casadi_real** res, casadi_int* iw, casadi_real* w, void* mem) {
+  casadi_real a0, a1;
+  a0=-2.;
+  a1=arg[0] ? arg[0][0] : 0;
+  a1=casadi_sq(a1);
+  a0=(a0*a1);
+  if (res[0]!=0) res[0][0]=a0;
+  return 0;
+}
+
+CASADI_SYMBOL_EXPORT int y(const casadi_real** arg, casadi_real** res, casadi_int* iw, casadi_real* w, void* mem){
+  return casadi_f0(arg, res, iw, w, mem);
+}
+
+CASADI_SYMBOL_EXPORT void y_incref(void) {
+}
+
+CASADI_SYMBOL_EXPORT void y_decref(void) {
+}
+
+CASADI_SYMBOL_EXPORT casadi_int y_n_in(void) { return 1;}
+
+CASADI_SYMBOL_EXPORT casadi_int y_n_out(void) { return 1;}
+
+CASADI_SYMBOL_EXPORT const char* y_name_in(casadi_int i){
+  switch (i) {
+    case 0: return "x";
+    default: return 0;
+  }
+}
+
+CASADI_SYMBOL_EXPORT const char* y_name_out(casadi_int i){
+  switch (i) {
+    case 0: return "y";
+    default: return 0;
+  }
+}
+
+CASADI_SYMBOL_EXPORT const casadi_int* y_sparsity_in(casadi_int i) {
+  switch (i) {
+    case 0: return casadi_s0;
+    default: return 0;
+  }
+}
+
+CASADI_SYMBOL_EXPORT const casadi_int* y_sparsity_out(casadi_int i) {
+  switch (i) {
+    case 0: return casadi_s0;
+    default: return 0;
+  }
+}
+
+CASADI_SYMBOL_EXPORT int y_work(casadi_int *sz_arg, casadi_int* sz_res, casadi_int *sz_iw, casadi_int *sz_w) {
+  if (sz_arg) *sz_arg = 1;
+  if (sz_res) *sz_res = 1;
+  if (sz_iw) *sz_iw = 0;
+  if (sz_w) *sz_w = 0;
+  return 0;
+}
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
diff --git a/python/casadi_f16 b/python/casadi_f16
index 898f6fd2..f79899ab 160000
--- a/python/casadi_f16
+++ b/python/casadi_f16
@@ -1 +1 @@
-Subproject commit 898f6fd2b032dbbb8a0cfeb52906c2587b557605
+Subproject commit f79899ab53f632ae4d561285ef1b7b7055770409