{ "cells": [ { "cell_type": "markdown", "id": "51c31adb", "metadata": {}, "source": [ "### Exercise 1 - Simulation\n", "\n", "\n", "In this exercise, we will get to know the software tool CasADi.\n", "\n", "We consider a simple inverted pendulum. \n", "The system dynamics are given via the ODE:\n", "\\begin{align}\n", "\\dot{\\theta} =& \\omega \\\\\n", "\\dot{\\omega} =& \\sin(\\theta) + \\tau,\n", "\\end{align}\n", "where $\\theta$ is the angle describing the orientation of the pendulum, $\\omega$ is its angular velocity and $\\tau$ is the input torque. \n", "\n" ] }, { "cell_type": "markdown", "id": "ec4afa84", "metadata": {}, "source": [] }, { "cell_type": "code", "execution_count": 1, "id": "e062f8ba", "metadata": {}, "outputs": [], "source": [ "from casadi import *\n", "\n", "theta = SX.sym('theta', 1, 1)\n", "omega = SX.sym('omega')" ] }, { "cell_type": "code", "execution_count": 2, "id": "644d4ea2", "metadata": {}, "outputs": [], "source": [ "expr = theta**2 + omega**2" ] }, { "cell_type": "code", "execution_count": 3, "id": "ca394e7e", "metadata": {}, "outputs": [], "source": [ "J = jacobian(expr, theta)" ] }, { "cell_type": "code", "execution_count": 4, "id": "228f9685", "metadata": {}, "outputs": [], "source": [ "J_fun = Function('J_F', [theta, omega], [J])" ] }, { "cell_type": "code", "execution_count": 5, "id": "fd3b5d6b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "SX(@1=sin(theta), (@1+@1))" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "J_fun(sin(theta), omega)" ] }, { "cell_type": "markdown", "id": "88661cfd", "metadata": {}, "source": [ "### 1.1 Intro to CasADi \n", "Check out the CasADi [documentation](https://web.casadi.org/docs/). Make sure you understand the difference between a CasADi expression and a CasADi functionCasADi. Check out the CasADi [documentation](https://web.casadi.org/docs/). Make sure you understand the difference between a CasADi expression and a CasADi function.\n", "\n", "Define the continuous time model in terms of CasADi SX expressions." ] }, { "cell_type": "code", "execution_count": 6, "id": "e19c85e8", "metadata": {}, "outputs": [], "source": [ "from casadi import *\n", "import numpy as np\n", "\n", "# continuous model dynamics \n", "\n", "n_s = 2 # number of states\n", "n_a = 1 # number of actions\n", "\n", "theta = SX.sym('theta')\n", "omega = SX.sym('omega')\n", "\n", "tau = SX.sym('tau')\n", "\n", "theta_dot = omega\n", "omega_dot = sin(theta) + tau\n", "\n", "s = vertcat(theta, omega)\n", "s_dot = vertcat(theta_dot, omega_dot)" ] }, { "cell_type": "code", "execution_count": 7, "id": "ef1db596", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "SX([omega, (sin(theta)+tau)])" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "s_dot" ] }, { "cell_type": "markdown", "id": "ad71a90b", "metadata": {}, "source": [ "### 1.2 Differentation\n", "\n", "Use the CasADi function jacobian to obtain two CasADi functions that compute the Jacobian of the continuous time dynamics with respect to states and actions respectively.\n", "\n", "Use these functions to evaluate the Jacobians at the steady state $(0, 0)$.\n", "\n", "What is the return type of the casadi function? How can you cast it to a numpy array? \n", "\n", "What is its sparsity pattern of the Jacobians? " ] }, { "cell_type": "code", "execution_count": 8, "id": "5e670eef", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Jacobian w.r.t. s at the steady state\n", "\n", "[[00, 1], \n", " [1, 00]]\n", "Jacobian w.r.t. a at the steady state\n", "[00, 1]\n" ] } ], "source": [ "# jacobian functions \n", "J_s_expr = jacobian(s_dot, s)\n", "J_a_expr = jacobian(s_dot, tau)\n", "\n", "J_s = Function('jac_states', [s, tau], [J_s_expr])\n", "J_a = Function('jac_actions', [s, tau], [J_a_expr])\n", "\n", "# evaluate at steady state\n", "s_steady = np.zeros((n_s, 1))\n", "a_steady = np.zeros((n_a, 1))\n", " \n", "print('Jacobian w.r.t. s at the steady state')\n", "print(J_s(s_steady, a_steady))\n", "\n", "print('Jacobian w.r.t. a at the steady state')\n", "print(J_a(s_steady, a_steady)) \n", "# return type is DM, use .full() to get a numpy array" ] }, { "cell_type": "code", "execution_count": 9, "id": "7f70818b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[0.],\n", " [1.]])" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "J_a(s_steady, a_steady).full()" ] }, { "cell_type": "code", "execution_count": 10, "id": "b9e610b6", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "sparsity pattern of the Jacobian w.r.t. s at the steady state\n", ".*\n", "*.\n" ] } ], "source": [ "# sparsity \n", "sparsity_J_s = J_s(s_steady, a_steady).sparsity()\n", "\n", "print('sparsity pattern of the Jacobian w.r.t. s at the steady state')\n", "sparsity_J_s.spy()" ] }, { "cell_type": "markdown", "id": "f7cd82ad", "metadata": {}, "source": [ "### 1.3 From continuos-time to discrete-time\n", "\n", "We would like to build the discrete time dynamic system from the continuous time ODE using one RK4 step. " ] }, { "cell_type": "code", "execution_count": 11, "id": "10488e2d", "metadata": {}, "outputs": [], "source": [ "def integrate_RK4(s_expr, a_expr, sdot_expr, dt, N_steps=1):\n", " '''RK4 integrator.\n", " \n", " s_expr, a_expr: casadi expression that have been used to define the dynamics sdot_expr\n", " sdot_expr: casadi expr defining the rhs of the ode\n", " dt: integration interval\n", " N_steps: number of integration steps per integration interval, default:1\n", " '''\n", "\n", " h = dt/N_steps\n", "\n", " s_end = s_expr\n", "\n", " sdot_fun = Function('sdot', [s_expr, a_expr], [sdot_expr])\n", "\n", " for _ in range(N_steps):\n", "\n", " v_1 = sdot_fun(s_end, a_expr)\n", " v_2 = sdot_fun(s_end + 0.5 * h * v_1, a_expr) \n", " v_3 = sdot_fun(s_end + 0.5 * h * v_2, a_expr)\n", " v_4 = sdot_fun(s_end + v_3 * h, a_expr)\n", "\n", " s_end = s_end + (1/6) * (v_1 + 2 * v_2 + 2 * v_3 + v_4) * h\n", " \n", " F_expr = s_end\n", "\n", " return F_expr" ] }, { "cell_type": "markdown", "id": "dd95d6c9", "metadata": {}, "source": [ "We can now use this RK4 integrator to obtain a discrete time system describin the dynamics of the inverted pendulum dynamics." ] }, { "cell_type": "code", "execution_count": 12, "id": "3ffd67da", "metadata": {}, "outputs": [], "source": [ "dt = 0.1 \n", "N_steps = 5\n", "\n", "F_discrete = Function('F_discrete', [s, tau], [integrate_RK4(s, tau, s_dot, dt, N_steps)])\n", "# s^+ = F_discrete(s, a)\n", "# a = tau" ] }, { "cell_type": "code", "execution_count": 13, "id": "37716885", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Function(F_discrete:(i0[2],i1)->(o0[2]) SXFunction)" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "F_discrete" ] }, { "cell_type": "markdown", "id": "05fbbb15", "metadata": {}, "source": [ "### 1.4 Simulation\n", "\n", "Complete the following template to simulate the system forward in time starting from the initial state $s_0=(\\pi/2, 0)$ with constant input $a_k=0$, $k=0, \\ldots, 200$.\n", "What do you observe?\n" ] }, { "cell_type": "code", "execution_count": 14, "id": "8cc354d8", "metadata": {}, "outputs": [], "source": [ "N = 200\n", "\n", "# state and (constant) action trajectories\n", "s_traj = np.zeros((n_s, N+1))\n", "a_traj = 0.001*np.ones((n_a, N))\n", "\n", "# initial state\n", "s0 = np.array([np.pi/2, 0.])\n", "\n", "s_traj[:, 0] = s0\n", "\n", "# forward simulation\n", "for n in range(N):\n", " s0 = s_traj[:, n]\n", " a0 = a_traj[:, n]\n", " s_traj[:, [n+1]] = F_discrete(s0, a0).full()" ] }, { "cell_type": "code", "execution_count": 15, "id": "e8896e48", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "