C1M4L4___Longitudinal_Vehicle_Model__M.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "In this notebook, you will implement the forward longitudinal vehicle model. The model accepts throttle inputs and steps through the longitudinal dynamic equations. Once implemented, you will be given a set of inputs that drives over a small road slope to test your model.\n",
    "\n",
    "The input to the model is a throttle percentage $x_\\theta \\in [0,1]$ which provides torque to the engine and subsequently accelerates the vehicle for forward motion. \n",
    "\n",
    "The dynamic equations consist of many stages to convert throttle inputs to wheel speed (engine -> torque converter -> transmission -> wheel). These stages are bundled together in a single inertia term $J_e$ which is used in the following combined engine dynamic equations.\n",
    "\n",
    "\\begin{align}\n",
    "    J_e \\dot{\\omega}_e &= T_e - (GR)(r_{eff} F_{load}) \\\\ m\\ddot{x} &= F_x - F_{load}\n",
    "\\end{align}\n",
    "\n",
    "Where $T_e$ is the engine torque, $GR$ is the gear ratio, $r_{eff}$ is the effective radius, $m$ is the vehicle mass, $x$ is the vehicle position, $F_x$ is the tire force, and $F_{load}$ is the total load force. \n",
    "\n",
    "The engine torque is computed from the throttle input and the engine angular velocity $\\omega_e$ using a simplified quadratic model. \n",
    "\n",
    "\\begin{align}\n",
    "    T_e = x_{\\theta}(a_0 + a_1 \\omega_e + a_2 \\omega_e^2)\n",
    "\\end{align}\n",
    "\n",
    "The load forces consist of aerodynamic drag $F_{aero}$, rolling friction $R_x$, and gravitational force $F_g$ from an incline at angle $\\alpha$. The aerodynamic drag is a quadratic model and the friction is a linear model.\n",
    "\n",
    "\\begin{align}\n",
    "    F_{load} &= F_{aero} + R_x + F_g \\\\\n",
    "    F_{aero} &= \\frac{1}{2} C_a \\rho A \\dot{x}^2 = c_a \\dot{x}^2\\\\\n",
    "    R_x &= N(\\hat{c}_{r,0} + \\hat{c}_{r,1}|\\dot{x}| + \\hat{c}_{r,2}\\dot{x}^2) \\approx c_{r,1} \\dot{x}\\\\\n",
    "    F_g &= mg\\sin{\\alpha}\n",
    "\\end{align}\n",
    "\n",
    "Note that the absolute value is ignored for friction since the model is used for only forward motion ($\\dot{x} \\ge 0$). \n",
    " \n",
    "The tire force is computed using the engine speed and wheel slip equations.\n",
    "\n",
    "\\begin{align}\n",
    "    \\omega_w &= (GR)\\omega_e \\\\\n",
    "    s &= \\frac{\\omega_w r_e - \\dot{x}}{\\dot{x}}\\\\\n",
    "    F_x &= \\left\\{\\begin{array}{lr}\n",
    "        cs, &  |s| < 1\\\\\n",
    "        F_{max}, & \\text{otherwise}\n",
    "        \\end{array}\\right\\} \n",
    "\\end{align}\n",
    "\n",
    "Where $\\omega_w$ is the wheel angular velocity and $s$ is the slip ratio. \n",
    "\n",
    "We setup the longitudinal model inside a Python class below. The vehicle begins with an initial velocity of 5 m/s and engine speed of 100 rad/s. All the relevant parameters are defined and like the bicycle model, a sampling time of 10ms is used for numerical integration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.image as mpimg\n",
    "\n",
    "class Vehicle():\n",
    "    def __init__(self):\n",
    " \n",
    "        # ==================================\n",
    "        #  Parameters\n",
    "        # ==================================\n",
    "    \n",
    "        #Throttle to engine torque\n",
    "        self.a_0 = 400\n",
    "        self.a_1 = 0.1\n",
    "        self.a_2 = -0.0002\n",
    "        \n",
    "        # Gear ratio, effective radius, mass + inertia\n",
    "        self.GR = 0.35\n",
    "        self.r_e = 0.3\n",
    "        self.J_e = 10\n",
    "        self.m = 2000\n",
    "        self.g = 9.81\n",
    "        \n",
    "        # Aerodynamic and friction coefficients\n",
    "        self.c_a = 1.36\n",
    "        self.c_r1 = 0.01\n",
    "        \n",
    "        # Tire force \n",
    "        self.c = 10000\n",
    "        self.F_max = 10000\n",
    "        \n",
    "        # State variables\n",
    "        self.x = 0\n",
    "        self.v = 5\n",
    "        self.a = 0\n",
    "        self.w_e = 100\n",
    "        self.w_e_dot = 0\n",
    "        \n",
    "        self.sample_time = 0.01\n",
    "        \n",
    "    def reset(self):\n",
    "        # reset state variables\n",
    "        self.x = 0\n",
    "        self.v = 5\n",
    "        self.a = 0\n",
    "        self.w_e = 100\n",
    "        self.w_e_dot = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implement the combined engine dynamic equations along with the force equations in the cell below. The function $\\textit{step}$ takes the throttle $x_\\theta$ and incline angle $\\alpha$ as inputs and performs numerical integration over one timestep to update the state variables. Hint: Integrate to find the current position, velocity, and engine speed first, then propagate those values into the set of equations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vehicle(Vehicle):\n",
    "    def step(self, throttle, alpha):\n",
    "        # ==================================\n",
    "        #  Implement vehicle model here\n",
    "        # ==================================\n",
    "        T_e = throttle * (self.a_0 + self.a_1*self.w_e + self.a_2*self.w_e**2)\n",
    "        F_areo = self.c_a * self.v**2\n",
    "        R_x = self.c_r1 * self.v\n",
    "        F_g = self.m * self.g * np.sin(alpha)\n",
    "        F_load = F_areo + R_x + F_g\n",
    "        #torque equation (angular acceleration)\n",
    "        self.w_e_dot = (T_e - self.GR*self.r_e*F_load) / self.J_e\n",
    "        \n",
    "        w_w = self.GR * self.w_e\n",
    "        s = (w_w*self.r_e - self.v) / self.v\n",
    "        if abs(s) < 1:\n",
    "            F_x = self.c * s\n",
    "        else:\n",
    "            F_x = self.F_max\n",
    "        #force equation (acceleration) \n",
    "        self.a = (F_x - F_load) / self.m\n",
    "            \n",
    "        #update equations\n",
    "        self.w_e += self.w_e_dot * self.sample_time\n",
    "        #since v = a*t\n",
    "        self.v += self.a * self.sample_time\n",
    "        #since x = v*t - (1/2)*a*t^2\n",
    "        self.x += (self.v * self.sample_time) - (0.5 * self.a * self.sample_time**2) \n",
    "        \n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the model, you can send constant throttle inputs to the vehicle in the cell below. You will observe that the velocity converges to a fixed value based on the throttle input due to the aerodynamic drag and tire force limit. A similar velocity profile can be seen by setting a negative incline angle $\\alpha$. In this case, gravity accelerates the vehicle to a terminal velocity where it is balanced by the drag force."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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": [
    "sample_time = 0.01\n",
    "time_end = 100\n",
    "model = Vehicle()\n",
    "\n",
    "t_data = np.arange(0,time_end,sample_time)\n",
    "v_data = np.zeros_like(t_data)\n",
    "\n",
    "# throttle percentage between 0 and 1\n",
    "throttle = 0.2\n",
    "\n",
    "# incline angle (in radians)\n",
    "alpha = 0\n",
    "\n",
    "for i in range(t_data.shape[0]):\n",
    "    v_data[i] = model.v\n",
    "    model.step(throttle, alpha)\n",
    "    \n",
    "plt.plot(t_data, v_data)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will now drive the vehicle over a slope as shown in the diagram below.\n",
    "\n",
    "![ramp](ramp.png)\n",
    "\n",
    "To climb the slope, a trapezoidal throttle input is provided for the next 20 seconds as shown in the figure below. \n",
    "\n",
    "![throttle](throttle.png)\n",
    "\n",
    "The vehicle begins at 20% throttle and gradually increases to 50% throttle. This is maintained for 10 seconds as the vehicle climbs the steeper slope. Afterwards, the vehicle reduces the throttle to 0.\n",
    "\n",
    "In the cell below, implement the ramp angle profile $\\alpha (x)$ and throttle profile $x_\\theta (t)$ and step them through the vehicle dynamics. The vehicle position $x(t)$ is saved in the array $\\textit{x_data}$. This will be used to grade your solution.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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": [
    "time_end = 20\n",
    "t_data = np.arange(0,time_end,sample_time)\n",
    "x_data = np.zeros_like(t_data)\n",
    "\n",
    "v_data = np.zeros_like(t_data)\n",
    "w_e_data = np.zeros_like(t_data)\n",
    "\n",
    "# reset the states\n",
    "model.reset()\n",
    "\n",
    "# ==================================\n",
    "#  Learner solution begins here\n",
    "# ==================================\n",
    "def angle(i, alpha, x):\n",
    "    if x < 60:\n",
    "        alpha[i] = np.arctan(3/60)\n",
    "    elif x < 150:\n",
    "        alpha[i] = np.arctan(9/90)\n",
    "    else:\n",
    "        alpha[i] = 0\n",
    "\n",
    "throttle = np.zeros_like(t_data)\n",
    "alpha = np.zeros_like(t_data)\n",
    "\n",
    "#throttle depends on time and alpha depends on distance travelled (model.x)\n",
    "for i in range(t_data.shape[0]):\n",
    "    if t_data[i] < 5:\n",
    "        throttle[i] = 0.2 + ((0.5 - 0.2)/5)*t_data[i]\n",
    "        angle(i, alpha, model.x)\n",
    "    elif t_data[i] < 15:\n",
    "        throttle[i] = 0.5\n",
    "        angle(i, alpha, model.x)\n",
    "    else:\n",
    "        throttle[i] = ((0 - 0.5)/(20 - 15))*(t_data[i] - 20)\n",
    "        angle(i, alpha, model.x)\n",
    "    \n",
    "    #call the step function and update x_data array\n",
    "    model.step(throttle[i], alpha[i])\n",
    "    x_data[i] = model.x\n",
    "    v_data[i] = model.v\n",
    "    w_e_data[i] = model.w_e\n",
    "    \n",
    "# ==================================\n",
    "#  Learner solution ends here\n",
    "# ==================================\n",
    "\n",
    "# Plot x vs t for visualization\n",
    "plt.plot(t_data, x_data)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have implemented the vehicle model and inputs correctly, you should see that the vehicle crosses the ramp at ~15s where the throttle input begins to decrease.\n",
    "\n",
    "The cell below will save the time and vehicle inputs as text file named $\\textit{xdata.txt}$. To locate the file, change the end of your web directory to $\\textit{/notebooks/Course_1_Module_4/xdata.txt}$\n",
    "\n",
    "Once you are there, you can download the file and submit to the Coursera grader to complete this assessment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = np.vstack([t_data, x_data]).T\n",
    "np.savetxt('xdata.txt', data, delimiter=', ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Congratulations! You have now completed the assessment! Feel free to test the vehicle model with different inputs in the cell below, and see what trajectories they form. In the next module, you will see the longitudinal model being used for speed control. See you there!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYYAAAD8CAYAAABzTgP2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAEO9JREFUeJzt3X+MZWV9x/H3pyv0B5KCsvxaWJfqxgSJIJ2sGloDBeyysaJG7fKHom2yasBo0j9ESaxt0sRYtY3FQlZLiolCbRQhdeVnbJCkCrNkgYUFWSnKuht20AhsMNLFb/+Ys8k8w72zw86cmbnM+5Xc3HOe57n3fk9O2A/3OefOk6pCkqQDfmexC5AkLS0GgySpYTBIkhoGgySpYTBIkhoGgySpYTBIkhoGgySpYTBIkhovW+wCDsUxxxxTa9asWewyJGmkbN269cmqWnmwcSMZDGvWrGF8fHyxy5CkkZLkp7MZ51SSJKlhMEiSGvMSDEmuTrI3yfYpba9IcmuSR7rno4e8dn2Sh5PsTHLZfNQjSTp08/WN4d+B9dPaLgNur6q1wO3dfiPJCuDLwAXAqcBFSU6dp5okSYdgXoKhqu4Afjmt+ULgmm77GuAdA166DthZVY9W1XPAdd3rJEmLpM9rDMdV1R6A7vnYAWNWAY9P2d/VtUmSFsliX3zOgLaBS8ol2ZRkPMn4xMREz2VJ0vLVZzA8keQEgO5574Axu4CTp+yfBOwe9GZVtbmqxqpqbOXKg/4+Q5J0iPoMhhuBi7vti4EbBoy5G1ib5JQkhwMbu9dJkhbJfN2uei3wP8Brk+xK8tfAZ4HzkzwCnN/tk+TEJFsAqmo/cClwM7AD+GZVPTAfNUmSDs28/EmMqrpoSNe5A8buBjZM2d8CbJmPOiRJc7fYF58lSUuMwSBJahgMkqSGwSBJahgMkqSGwSBJahgMkqSGwSBJahgMkqSGwSBJahgMkqSGwSBJahgMkqSGwSBJahgMkqSGwSBJavQaDElem2TblMfTST4+bczZSZ6aMubTfdYkSZrZvKzgNkxVPQycAZBkBfBz4PoBQ39QVW/rsxZJ0uws5FTSucBPquqnC/iZkqQXaSGDYSNw7ZC+Nye5N8n3krxuAWuSJE2zIMGQ5HDg7cB/Dui+B3hVVZ0O/AvwnSHvsSnJeJLxiYmJ/oqVpGVuob4xXADcU1VPTO+oqqeral+3vQU4LMkxA8ZtrqqxqhpbuXJl/xVL0jK1UMFwEUOmkZIcnyTd9rqupl8sUF2SpGl6vSsJIMkfAOcDH5rS9mGAqroKeDfwkST7gV8DG6uq+q5LkjRY78FQVc8Cr5zWdtWU7SuAK/quQ5I0O/7yWZLUMBgkSQ2DQZLUMBgkSQ2DQZLUMBgkSQ2DQZLUMBgkSQ2DQZLUMBgkSQ2DQZLUMBgkSQ2DQZLUMBgkSQ2DQZLUMBgkSQ2DQZLU6D0YkjyW5P4k25KMD+hPki8l2ZnkviRn9l2TJGm43pf27JxTVU8O6bsAWNs93ghc2T1LkhbBUphKuhD4Wk36IXBUkhMWuyhJWq4WIhgKuCXJ1iSbBvSvAh6fsr+ra2sk2ZRkPMn4xMRET6VKkhYiGM6qqjOZnDK6JMlbpvVnwGvqBQ1Vm6tqrKrGVq5c2UedkiQWIBiqanf3vBe4Hlg3bcgu4OQp+ycBu/uuS5I0WK/BkOSIJEce2AbeCmyfNuxG4P3d3UlvAp6qqj191iVJGq7vu5KOA65PcuCzvlFVNyX5MEBVXQVsATYAO4FngQ/2XJMkaQa9BkNVPQqcPqD9qinbBVzSZx2SpNlbCrerSpKWEINBktQwGCRJDYNBktQwGCRJDYNBktQwGCRJDYNBktQwGCRJDYNBktQwGCRJDYNBktQwGCRJDYNBktQwGCRJDYNBktToe2nPk5N8P8mOJA8k+diAMWcneSrJtu7x6T5rkiTNrO+lPfcDf1NV93RrP29NcmtVPTht3A+q6m091yJJmoVevzFU1Z6quqfbfgbYAazq8zMlSXOzYNcYkqwB3gD8aED3m5Pcm+R7SV63UDVJkl6o76kkAJK8HPgW8PGqenpa9z3Aq6pqX5INwHeAtQPeYxOwCWD16tU9VyxJy1fv3xiSHMZkKHy9qr49vb+qnq6qfd32FuCwJMcMGLe5qsaqamzlypV9ly1Jy1bfdyUF+DdgR1V9cciY47txJFnX1fSLPuuSJA3X91TSWcD7gPuTbOvaPgWsBqiqq4B3Ax9Jsh/4NbCxqqrnuiRJQ/QaDFV1J5CDjLkCuKLPOiRJs+cvnyVJDYNBktQwGCRJDYNBktQwGCRJDYNBktQwGCRJDYNBktQwGCRJDYNBktQwGCRJDYNBktQwGCRJDYNBktQwGCRJDYNBktRYiDWf1yd5OMnOJJcN6E+SL3X99yU5s++aJEnD9b3m8wrgy8AFwKnARUlOnTbsAmBt99gEXNlnTZKkmfX9jWEdsLOqHq2q54DrgAunjbkQ+FpN+iFwVJITeq5LkjREr2s+A6uAx6fs7wLeOIsxq4A9813MtXf9jDt+PDHfbytJC+aSc17Daav+sNfP6DsYMqCtDmEMSTYxOdXE6tWrD6mYJ5/5DT+Z2HdIr5WkpeDX//d875/RdzDsAk6esn8SsPsQxlBVm4HNAGNjYy8Ijtn46Llr+ei5aw/lpZK0bPR9jeFuYG2SU5IcDmwEbpw25kbg/d3dSW8CnqqqeZ9GkiTNTq/fGKpqf5JLgZuBFcDVVfVAkg93/VcBW4ANwE7gWeCDfdYkSZpZ31NJVNUWJv/xn9p21ZTtAi7puw5J0uz4y2dJUsNgkCQ1DAZJUsNgkCQ1DAZJUsNgkCQ1DAZJUsNgkCQ1DAZJUsNgkCQ1DAZJUsNgkCQ1DAZJUsNgkCQ1DAZJUsNgkCQ1DAZJUqO3FdyS/CPwF8BzwE+AD1bVrwaMewx4Bnge2F9VY33VJEk6uD6/MdwKnFZVrwd+DHxyhrHnVNUZhoIkLb7egqGqbqmq/d3uD4GT+vosSdL8WahrDH8FfG9IXwG3JNmaZNOwN0iyKcl4kvGJiYleipQkzfEaQ5LbgOMHdF1eVTd0Yy4H9gNfH/I2Z1XV7iTHArcmeaiq7pg+qKo2A5sBxsbGai51S5KGm1MwVNV5M/UnuRh4G3BuVQ38x7yqdnfPe5NcD6wDXhAMkqSF0dtUUpL1wCeAt1fVs0PGHJHkyAPbwFuB7X3VJEk6uD6vMVwBHMnk9NC2JFcBJDkxyZZuzHHAnUnuBe4CvltVN/VYkyTpIHr7HUNVvWZI+25gQ7f9KHB6XzVIkl48f/ksSWoYDJKkhsEgSWoYDJKkhsEgSWoYDJKkhsEgSWoYDJKkhsEgSWoYDJKkhsEgSWoYDJKkhsEgSWoYDJKkhsEgSWoYDJKkRp9Le34myc+71du2JdkwZNz6JA8n2Znksr7qkSTNTm8ruHX+qao+P6wzyQrgy8D5wC7g7iQ3VtWDPdclSRpisaeS1gE7q+rRqnoOuA64cJFrkqRlre9guDTJfUmuTnL0gP5VwONT9nd1bZKkRTKnYEhyW5LtAx4XAlcCrwbOAPYAXxj0FgPaashnbUoynmR8YmJiLmVLkmYwp2sMVXXebMYl+QrwXwO6dgEnT9k/Cdg95LM2A5sBxsbGBoaHJGnu+rwr6YQpu+8Etg8YdjewNskpSQ4HNgI39lWTJOng+rwr6XNJzmByaugx4EMASU4EvlpVG6pqf5JLgZuBFcDVVfVAjzVJkg6it2CoqvcNad8NbJiyvwXY0lcdkqQXZ7FvV5UkLTEGgySpYTBIkhoGgySpYTBIkhoGgySpYTBIkhoGgySpYTBIkhoGgySpYTBIkhoGgySpYTBIkhoGgySpYTBIkhoGgySpYTBIkhq9reCW5D+A13a7RwG/qqozBox7DHgGeB7YX1VjfdUkSTq4Ppf2/MsD20m+ADw1w/BzqurJvmqRJM1eb8FwQJIA7wX+rO/PkiTN3UJcY/hT4ImqemRIfwG3JNmaZNOwN0myKcl4kvGJiYleCpUkzfEbQ5LbgOMHdF1eVTd02xcB187wNmdV1e4kxwK3Jnmoqu6YPqiqNgObAcbGxmoudUuShptTMFTVeTP1J3kZ8C7gj2d4j93d894k1wPrgBcEgyRpYfQ9lXQe8FBV7RrUmeSIJEce2AbeCmzvuSZJ0gz6DoaNTJtGSnJiki3d7nHAnUnuBe4CvltVN/VckyRpBr3elVRVHxjQthvY0G0/CpzeZw2SpBfHXz5LkhoGgySpYTBIkhoGgySpYTBIkhoGgySpYTBIkhoGgySpYTBIkhoGgySpYTBIkhoGgySpYTBIkhoGgySpYTBIkhoGgySpMadgSPKeJA8k+W2SsWl9n0yyM8nDSf58yOtfkeTWJI90z0fPpR5J0tzN9RvDduBdwB1TG5OcyuSynq8D1gP/mmTFgNdfBtxeVWuB27t9SdIimlMwVNWOqnp4QNeFwHVV9Zuq+l9gJ7BuyLhruu1rgHfMpR5J0tz1dY1hFfD4lP1dXdt0x1XVHoDu+die6pEkzdLLDjYgyW3A8QO6Lq+qG4a9bEBbvZjCBtSxCdgEsHr16rm8lSRpBgcNhqo67xDedxdw8pT9k4DdA8Y9keSEqtqT5ARg7wx1bAY2A4yNjc0pZCRJw/U1lXQjsDHJ7yY5BVgL3DVk3MXd9sXAsG8gkqQFMtfbVd+ZZBfwZuC7SW4GqKoHgG8CDwI3AZdU1fPda7465dbWzwLnJ3kEOL/blyQtolSN3qzM2NhYjY+PL3YZkjRSkmytqrGDjfOXz5KkhsEgSWqM5FRSkgngp4f48mOAJ+exnMXksSw9L5XjAI9lqZrLsbyqqlYebNBIBsNcJBmfzRzbKPBYlp6XynGAx7JULcSxOJUkSWoYDJKkxnIMhs2LXcA88liWnpfKcYDHslT1fizL7hqDJGlmy/EbgyRpBssqGJKs71aU25lkpBcFSvJYkvuTbEsyMj8DT3J1kr1Jtk9pG8mV/IYcy2eS/Lw7L9uSbFjMGmcryclJvp9kR7cq48e69pE6NzMcx8idlyS/l+SuJPd2x/J3XXvv52TZTCV1K8j9mMm/ybQLuBu4qKoeXNTCDlGSx4Cxqhqpe7OTvAXYB3ytqk7r2j4H/LKqPtsF9tFV9YnFrHM2hhzLZ4B9VfX5xaztxer+uvEJVXVPkiOBrUwunPUBRujczHAc72XEzkuSAEdU1b4khwF3Ah9jctXMXs/JcvrGsA7YWVWPVtVzwHVMriCnBVRVdwC/nNY8kiv5DTmWkVRVe6rqnm77GWAHk4trjdS5meE4Rk5N2tftHtY9igU4J8spGGa7qtyoKOCWJFu7RYxG2UttJb9Lk9zXTTUt6amXQZKsAd4A/IgRPjfTjgNG8LwkWZFkG5Nr1dxaVQtyTpZTMMz7qnKL7KyqOhO4ALikm9bQ4rsSeDVwBrAH+MLilvPiJHk58C3g41X19GLXc6gGHMdInpeqer6qzmBysbN1SU5biM9dTsEw21XlRkJV7e6e9wLXMzlVNqqe6OaGD8wRD13Jb6mrqie6/5h/C3yFETov3Tz2t4CvV9W3u+aROzeDjmOUzwtAVf0K+G9gPQtwTpZTMNwNrE1ySpLDgY1MriA3cpIc0V1YI8kRwFuB7TO/akl7yazkd+A/2M47GZHz0l3o/DdgR1V9cUrXSJ2bYccxiuclycokR3Xbvw+cBzzEApyTZXNXEkB3i9o/AyuAq6vqHxa5pEOS5I+Y/JYAk+t2f2NUjiXJtcDZTP6FyCeAvwW+w+SKf6uBnwHvqaolf1F3yLGczeR0RQGPAR86MB+8lCX5E+AHwP3Ab7vmTzE5Pz8y52aG47iIETsvSV7P5MXlFUz+T/w3q+rvk7ySns/JsgoGSdLBLaepJEnSLBgMkqSGwSBJahgMkqSGwSBJahgMkqSGwSBJahgMkqTG/wPMAS7yV47s5wAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sample_time = 0.01\n",
    "time_end = 30\n",
    "model.reset()\n",
    "\n",
    "t_data = np.arange(0,time_end,sample_time)\n",
    "x_data = np.zeros_like(t_data)\n",
    "\n",
    "# ==================================\n",
    "#  Test various inputs here\n",
    "# ==================================\n",
    "for i in range(t_data.shape[0]):\n",
    "\n",
    "    model.step(0,0)\n",
    "    \n",
    "plt.axis('equal')\n",
    "plt.plot(t_data, x_data)\n",
    "plt.show()"
   ]
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}