Rocket.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "import casadi as ca\n",
    "from casadi import CodeGenerator\n",
    "import sys\n",
    "import numpy as np\n",
    "from IPython.display import Image\n",
    "import scipy.integrate\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from casadi.tools.graph import dotgraph\n",
    "\n",
    "sys.path.insert(0, '../python/pyecca/')\n",
    "from pyecca.lie import so3\n",
    "from pyecca.util import rk4\n",
    "\n",
    "def draw_expr(expr):\n",
    "    return Image(dotgraph(expr).create_png())\n",
    "\n",
    "def draw_graph(expr):\n",
    "    return Image(dotgraph(expr).create_png())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$v = \\dfrac{^e d}{dt} r$, where r is a position vector"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\dfrac{^ed}{dt} (mv) = F$ Newton's 2nd law. Derivative of linear momentum w.r.t. the inertial frame is equal to the force applied on a rigid body.\n",
    "\n",
    "$^e\\dfrac{d}{dt} (J ^e\\omega^b) = M$ Newton's 2nd law (angular version). Derivative of the angular momentum w.r.t. the inertial frame is equal to the moment applied on the rigid body."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\dot{m} v  + m \\dfrac{^ed}{dt} (v) = F$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\dot{m} v_e  + m \\dfrac{^ed}{dt} (v_e) = F_e$\n",
    "\n",
    "Simplifies to\n",
    "\n",
    "$\\dot{m} v_e  + m a_e = F_e$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Body frame:\n",
    "\n",
    "$\\dot{m} v_b  + m \\dfrac{^ed}{dt} (v_b) = F_b$\n",
    "\n",
    "$\\dot{m} v_b  + m \\left( \\dfrac{^b d}{dt} (v_b) + ^e\\omega^b \\times v_b \\right) = F_b$\n",
    "\n",
    "$\\dot{m} v_b  + m \\left( \\dot{v}_b + ^e\\omega^b \\times v_b \\right) = F_b$\n",
    "\n",
    "In the state vector, $\\vec{x}$ we would have:\n",
    "\n",
    "$v_b$: linear velocity, $^e\\omega^b_b$: angular velocity, $m$: mass, $r$: position vector, and orientation, not clear which one we want."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Choices for Orientation (3 Rotational degrees of freedom)\n",
    "\n",
    "* Euler angles\n",
    "    * Advantages:\n",
    "        * 3 angles\n",
    "    * Disadvantages:\n",
    "        * Gimbal lock/ singularity\n",
    "* Direction Cosine Matrix\n",
    "    * Advantages:\n",
    "        * No singularity.\n",
    "        * Can just use matrix multiplication to rotate vectors.\n",
    "    * Disadvantages:\n",
    "        * 9 parameters\n",
    "* Quaternions\n",
    "    * Advantages:\n",
    "        * No singularity.\n",
    "    * Disadvantages:\n",
    "        * 4 parameters, because there is a constraint of unit magnitude, so we have one extra parameter.\n",
    "* Modified Rodrigues Parameters\n",
    "    * Advantages:\n",
    "        * Singularity, but can be avoided using the shadow parameter. 3 parameters and a shadow set. (3.5 parameters, because the last keeps track of if you are using the shadow set)\n",
    "    * Disadvantages:\n",
    "        * Has extra binary switch. Have to make sure switch doesn't impact control system.\n",
    "\n",
    "These are all part of the SO(3) group in mathematics that describe 3D rotations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rocket_equations(jit=True):\n",
    "    x = ca.SX.sym('x', 14)\n",
    "    u = ca.SX.sym('u', 4)\n",
    "    p = ca.SX.sym('p', 15)\n",
    "\n",
    "    # State: x\n",
    "    omega_b = x[0:3]  # inertial angular velocity expressed in body frame\n",
    "    r_nb = x[3:7]  # modified rodrigues parameters\n",
    "    v_b = x[7:10]  # inertial velocity expressed in body components\n",
    "    p_n = x[10:13]  # positon in nav frame\n",
    "    m_fuel = x[13]  # mass\n",
    "    \n",
    "    # Input: u\n",
    "    m_dot = ca.if_else(m_fuel > 0, u[0], 0)\n",
    "    aileron = u[1]\n",
    "    elevator = u[2]\n",
    "    rudder = u[3]\n",
    "    \n",
    "    # Parameters: p\n",
    "    g = p[0]  # gravity\n",
    "    Jx = p[1]  # moment of inertia\n",
    "    Jy = p[2]\n",
    "    Jz = p[3]\n",
    "    Jxz = p[4]\n",
    "    ve = p[5]\n",
    "    l_fin = p[6]\n",
    "    CL_alpha = p[7]\n",
    "    CL0 = p[8]\n",
    "    CD0 = p[9]\n",
    "    K = p[10]\n",
    "   \n",
    "    s_fin = p[11]\n",
    "    rho = p[12]\n",
    "    m_empty = p[13]\n",
    "    l_motor = p[14]\n",
    "    m = m_empty + m_fuel\n",
    "  #frame conversions  \n",
    "    C_NED_ENU = np.array([\n",
    "      [0, 1, 0],\n",
    "      [1, 0, 0],\n",
    "      [0, 0, -1]\n",
    "    ])\n",
    "\n",
    "    C_TRF_FRD = np.array([\n",
    "      [0, 0, -1],\n",
    "      [0, 1, 0],\n",
    "      [1, 0, 0]\n",
    "    ])\n",
    "    \n",
    "    C_ENU_TRF = so3.Dcm.from_quat(r_nb)\n",
    "    C_FRD_ENU = ca.mtimes(C_TRF_FRD.T, C_ENU_TRF.T)\n",
    "   \n",
    "    r_NED_FRD = so3.Mrp.from_dcm(\n",
    "        ca.mtimes([C_NED_ENU, C_ENU_TRF, C_TRF_FRD]))\n",
    "  \n",
    "    omega_FRD = ca.mtimes(C_FRD_ENU, omega_b)\n",
    "    pos_NED = ca.mtimes(C_NED_ENU, p_n)\n",
    "    vel_FRD = ca.mtimes(C_FRD_ENU, v_b)\n",
    "    \n",
    "    #omega_FRD = omega_FRD.expand()\n",
    "    #pos_NED = pos_NED.expand()\n",
    "    #vel_FRD = vel_FRD.expand()\n",
    "    \n",
    "    \n",
    "    # Calculations\n",
    "    J_b = ca.SX.zeros(3, 3)\n",
    "    J_b[0, 0] = Jx + m_fuel*l_motor**2\n",
    "    J_b[1, 1] = Jy + m_fuel*l_motor**2\n",
    "    J_b[2, 2] = Jz\n",
    "    J_b[0, 2] = J_b[2, 0] = Jxz\n",
    "    C_nb = so3.Dcm.from_mrp(r_NED_FRD)\n",
    "    g_n = ca.vertcat(0, 0, g)\n",
    "    v_n = ca.mtimes(C_nb, vel_FRD)\n",
    "    \n",
    "    # aerodynamics\n",
    "    VT = ca.norm_2(vel_FRD)\n",
    "    q = 0.5*rho*VT**2\n",
    "    fins = {\n",
    "        'top': {\n",
    "            'fwd': [1, 0, 0],\n",
    "            'up': [0, 1, 0],\n",
    "            'mix': aileron + rudder,\n",
    "        },\n",
    "        'left': {\n",
    "            'fwd': [1, 0, 0],\n",
    "            'up': [0, 0, -1],\n",
    "            'mix': aileron + elevator,\n",
    "        },\n",
    "        'down': {\n",
    "            'fwd': [1, 0, 0],\n",
    "            'up': [0, -1, 0],\n",
    "            'mix': aileron - rudder,\n",
    "        },\n",
    "        'right': {\n",
    "            'fwd': [1, 0, 0],\n",
    "            'up': [0, 0, 1],\n",
    "            'mix': aileron - elevator,\n",
    "        },\n",
    "    }\n",
    "    vel_tol = 1e-3\n",
    "    FA_b = ca.SX.zeros(3)\n",
    "    MA_b = ca.SX.zeros(3) \n",
    "    for key, data in fins.items():\n",
    "        fwd = data['fwd']\n",
    "        up = data['up']\n",
    "        mix = data['mix']\n",
    "        U = ca.dot(fwd, vel_FRD)\n",
    "        W = ca.dot(up, vel_FRD)\n",
    "        alpha = ca.if_else(\n",
    "            ca.logic_and(ca.fabs(W) > vel_tol, ca.fabs(U) > vel_tol),\n",
    "            -ca.atan(W/U), 0)\n",
    "        rel_wind_dir = ca.if_else(ca.fabs(VT) > vel_tol, v_b/VT, -ca.DM(fwd))\n",
    "        perp_wind_dir = ca.cross(ca.cross(fwd, up), rel_wind_dir)\n",
    "        perp_wind_dir = perp_wind_dir/ca.norm_2(perp_wind_dir)\n",
    "        CL = CL0 + CL_alpha*(alpha + mix)\n",
    "        CD = CD0 + K*(CL - CL0)**2\n",
    "        L = CL*q*s_fin\n",
    "        D = CD*q*s_fin\n",
    "        FA_b += L*perp_wind_dir - D*rel_wind_dir\n",
    "        MA_b += ca.cross(ca.vertcat(-l_fin, 0, 0), FA_b)\n",
    "        \n",
    "        \n",
    "\n",
    "    # propulsion\n",
    "    FP_b = ca.vertcat(0, 0, -m_dot*ve)\n",
    "    MP_b = ca.vertcat(0, 0, 0)\n",
    "    \n",
    "    \n",
    "    FA_b = ca.mtimes(C_TRF_FRD, FA_b)\n",
    "    MA_b = ca.mtimes(C_TRF_FRD, MA_b)\n",
    "    FP_b = ca.mtimes(C_TRF_FRD, FP_b)\n",
    "    MP_b = ca.mtimes(C_TRF_FRD, MP_b)\n",
    "\n",
    "    # force and momental total\n",
    "    F_b = FA_b + FP_b + ca.mtimes(C_nb.T, g_n)\n",
    "    M_b = MA_b + MP_b\n",
    "    \n",
    "    # function generations\n",
    "    rocket_aero_forces = ca.Function(\n",
    "        'rocket_aero_forces', [x, u, p], [FA_b], ['x', 'u', 'p'], ['FA_b'])\n",
    "    rocket_aero_moment = ca.Function(\n",
    "        'rocket_aero_moment', [x, u, p], [MA_b], ['x', 'u', 'p'], ['MA_b'])\n",
    "    rocket_prop_forces = ca.Function(\n",
    "        'rocket_prop_forces', [x, u, p], [FP_b], ['x', 'u', 'p'], ['FP_b'])\n",
    "    rocket_prop_moment = ca.Function(\n",
    "        'rocket_prop_moment', [x, u, p], [MP_b], ['x', 'u', 'p'], ['MP_b']) \n",
    "\n",
    "    \n",
    "    # c code generations\n",
    "    gen_with_main = CodeGenerator(\n",
    "    'rocket_aero_forces.c',\n",
    "    {'main': False, 'mex': False, 'with_header': True, 'with_mem': True})\n",
    "    gen_with_main.add(rocket_aero_forces)\n",
    "    gen_with_main.generate()\n",
    "    \n",
    "    gen_with_main = CodeGenerator(\n",
    "    'rocket_aero_moment.c',\n",
    "    {'main': False, 'mex': False, 'with_header': True, 'with_mem': True})\n",
    "    gen_with_main.add(rocket_aero_moment)\n",
    "    gen_with_main.generate()\n",
    "    \n",
    "    gen_with_main = CodeGenerator(\n",
    "    'rocket_prop_forces.c',\n",
    "    {'main': False, 'mex': False, 'with_header': True, 'with_mem': True})\n",
    "    gen_with_main.add(rocket_prop_forces)\n",
    "    gen_with_main.generate()\n",
    "    \n",
    "    gen_with_main = CodeGenerator(\n",
    "    'rocket_prop_moment.c',\n",
    "    {'main': False, 'mex': False, 'with_header': True, 'with_mem': True})\n",
    "    gen_with_main.add(rocket_prop_moment)\n",
    "    gen_with_main.generate()\n",
    "    \n",
    "    # right hand side\n",
    "    rhs = ca.Function('rhs', [x, u, p], [ca.vertcat(\n",
    "        ca.mtimes(ca.inv(J_b), M_b - ca.cross(omega_b, ca.mtimes(J_b, omega_b))),\n",
    "        so3.Mrp.kinematics(r_nb, omega_b),\n",
    "        F_b/m - m_dot*v_b/m - ca.cross(omega_b, v_b),\n",
    "        ca.mtimes(C_nb, v_b), -m_dot)], ['x', 'u', 'p'], ['rhs'], {'jit': jit})\n",
    "\n",
    "    # prediction\n",
    "    t0 = ca.SX.sym('t0')\n",
    "    h = ca.SX.sym('h')\n",
    "    x0 = ca.SX.sym('x', 14)\n",
    "    x1 = rk4(lambda t, x: rhs(x, u, p), t0, x0, h)\n",
    "    x1[3:7] = so3.Mrp.shadow_if_necessary(x1[3:7])\n",
    "    predict = ca.Function('predict', [x0, u, p, t0, h], [x1], {'jit': jit})\n",
    "\n",
    "    # initialize\n",
    "    pitch_deg = ca.SX.sym('pitch_deg')\n",
    "    omega0_b = ca.vertcat(0, 0, 0)\n",
    "    r0_nb = so3.Mrp.from_euler(ca.vertcat(0, pitch_deg*ca.pi/180, 0))\n",
    "    v0_b = ca.vertcat(0, 0, 0)\n",
    "    p0_n = ca.vertcat(0, 0, 0)\n",
    "    m0_fuel = 0.8\n",
    "    # x: omega_b, r_nb, v_b, p_n, m_fuel\n",
    "    x0 = ca.vertcat(omega0_b, r0_nb, v0_b, p0_n, m0_fuel)\n",
    "    #     g, Jx, Jy, Jz, Jxz, ve, l_fin, CL_alpha, CL0, CD0, K, s, rho, m_emptpy, l_motor\n",
    "    p0 = [9.8, 1, 1, 1, 0.1, 350, 1.0, 2*np.pi, 0, 0.01, 0.01, 0.05, 1.225, 0.2, 1.0]\n",
    "    initialize = ca.Function('initialize', [pitch_deg], [x0, p0])\n",
    "\n",
    "    return {\n",
    "        'rhs': rhs,\n",
    "        'predict': predict,\n",
    "        'initialize': initialize,\n",
    "        'x': x,\n",
    "        'u': u,\n",
    "        'p': p,\n",
    "        \n",
    "    }\n",
    "    return rhs, x, u, p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "rocket_equations()\n",
    "!g++ my_code.c -o my_code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def analyze_data(data):\n",
    "    plt.figure(figsize=(10, 17))\n",
    "    plt.subplot(321)\n",
    "    plt.title('fuel')\n",
    "    plt.plot(data['t'], data['x'][:, 13])\n",
    "    plt.xlabel('t, sec')\n",
    "    plt.ylabel('mass, kg')\n",
    "    plt.grid()\n",
    "\n",
    "    plt.subplot(322)\n",
    "    plt.title('velocity')\n",
    "    plt.plot(data['t'], data['x'][:, 7], label='v_X')\n",
    "    plt.plot(data['t'], data['x'][:, 8], label='v_Y')\n",
    "    plt.plot(data['t'], data['x'][:, 9], label='v_Z')\n",
    "    plt.xlabel('t, sec')\n",
    "    plt.ylabel('m/s')\n",
    "    plt.grid()\n",
    "    plt.legend()\n",
    "    \n",
    "    plt.subplot(323)\n",
    "    euler = np.array(\n",
    "        [np.array(ca.DM(so3.Euler.from_mrp(x))).reshape(-1) for x in data['x'][:, 3:7]])\n",
    "    plt.plot(data['t'], np.rad2deg(euler[:, 0]), label='roll')\n",
    "    plt.plot(data['t'], np.rad2deg(euler[:, 1]), label='pitch')\n",
    "    plt.plot(data['t'], np.rad2deg(euler[:, 2]), label='yaw')\n",
    "    plt.legend()\n",
    "    plt.grid()\n",
    "    plt.xlabel('t, sec')\n",
    "    plt.ylabel('deg')\n",
    "    plt.title('euler')\n",
    "    \n",
    "    plt.subplot(324)\n",
    "    plt.title('angular velocity')\n",
    "    plt.plot(data['t'], data['x'][:, 0], label='x')\n",
    "    plt.plot(data['t'], data['x'][:, 1], label='y')\n",
    "    plt.plot(data['t'], data['x'][:, 2], label='z')\n",
    "    plt.xlabel('t, sec')\n",
    "    plt.ylabel('rad/s')\n",
    "    plt.grid()\n",
    "    plt.legend()\n",
    "    \n",
    "    plt.subplot(325)\n",
    "    plt.title('trajectory [side]')\n",
    "    plt.plot(data['x'][:, 10], -data['x'][:, 12])\n",
    "    plt.xlabel('North, m')\n",
    "    plt.ylabel('Altitude, m')\n",
    "    plt.axis('equal')\n",
    "    plt.grid()\n",
    "    \n",
    "    plt.subplot(326)\n",
    "    plt.title('trajectory [top]')\n",
    "    plt.plot(data['x'][:, 11], data['x'][:, 10])\n",
    "    plt.xlabel('East, m')\n",
    "    plt.ylabel('North, m')\n",
    "    plt.axis('equal')\n",
    "    plt.grid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simulate(rocket, x0, u0, p0, dt=0.01, t0=0, tf=10):\n",
    "    \"\"\"\n",
    "    An integrator using a fixed step runge-kutta approach.\n",
    "    \"\"\"\n",
    "    x = x0\n",
    "    data = {\n",
    "        't': [],\n",
    "        'x': []\n",
    "    }\n",
    "    for t in np.arange(t0, tf, dt):\n",
    "        data['x'].append(np.array(x).reshape(-1))\n",
    "        data['t'].append(t)\n",
    "        x = rocket['predict'](x, u0, p0, t, dt)\n",
    "   \n",
    "    for k in data.keys():\n",
    "        data[k] = np.array(data[k])\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 2.21 s, sys: 80.1 ms, total: 2.29 s\n",
      "Wall time: 2.28 s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x1224 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%time\n",
    "rocket = rocket_equations()\n",
    "x0, p0 = rocket['initialize'](10)\n",
    "# m_dot, aileron, elevator, rudder\n",
    "u0 = [0.5, 0, 0, 0]\n",
    "data = simulate(rocket, x0, u0, p0, tf=10)\n",
    "analyze_data(data)\n",
    "plt.savefig('rocket.png')"
   ]
  },
  {
   "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
}