{ "nbformat": 4, "nbformat_minor": 0, "metadata": { "anaconda-cloud": {}, "kernelspec": { "name": "python3", "display_name": "Python 3" }, "colab": { "name": "2020-11-14 Pendulum probabilistic primer.ipynb", "provenance": [], "collapsed_sections": [] } }, "cells": [ { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true, "id": "3ZcBq90xg0T5" }, "source": [ "# Uncertainty quantification" ] }, { "cell_type": "markdown", "metadata": { "id": "0OQLfnuhHM9Q" }, "source": [ "This colab notebook is intended to provide an interactive example of uncertainty quantification using the example of a double pendulum (epistemic uncertainty) and rain drops (aleatory uncertainty).\n", "\n", "A double pendulum is well known for it's highly sensitive and \"chaotic\" behaviour. It is however described precisely by differential equations, and it is the extreme sensitivity that makes it appear so chaotic. \n", "\n", "The basis for the functions for the double pendulum is entirely from Jake VanderPlas, originally posted here: https://jakevdp.github.io/blog/2017/03/08/triple-pendulum-chaos/.\n", "\n", "The rain drop simulation is originally from https://matplotlib.org/3.3.2/gallery/animation/rain.html created by Nicolas P. Rougier. " ] }, { "cell_type": "markdown", "metadata": { "id": "kiasddMkrqAC" }, "source": [ "## Double Pendulum" ] }, { "cell_type": "markdown", "metadata": { "id": "JlLZQH9OI2w9" }, "source": [ "First let make our imports" ] }, { "cell_type": "code", "metadata": { "deletable": true, "editable": true, "id": "mOkt99fwg0UT", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "f69cda6a-16ed-479c-e979-6adabcf639e5" }, "source": [ "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", "from sympy import symbols\n", "from sympy.physics import mechanics\n", "\n", "from sympy import Dummy, lambdify\n", "from scipy.integrate import odeint\n", "\n", "from IPython.display import HTML\n", "\n", "from statsmodels.distributions.empirical_distribution import ECDF\n", "\n", "from matplotlib import collections\n", "from matplotlib import animation\n" ], "execution_count": 1, "outputs": [ { "output_type": "stream", "text": [ "/usr/local/lib/python3.6/dist-packages/statsmodels/tools/_testing.py:19: FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.\n", " import pandas.util.testing as tm\n" ], "name": "stderr" } ] }, { "cell_type": "code", "metadata": { "id": "ASgCIg1hlx0k" }, "source": [ "# set the random generator seed so you will get the same \"random\" results as me\n", "np.random.seed(42)" ], "execution_count": 2, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "_hw-MO7BI_WG" }, "source": [ "Then we can define a function for our pendulum (which is generalised to be 'n' sections. We'll only use n=2 for a double pendulum in this notebook however." ] }, { "cell_type": "code", "metadata": { "id": "HWF1BpQ2I6M1" }, "source": [ "def integrate_pendulum(n, times,\n", " initial_positions=135,\n", " initial_velocities=0,\n", " lengths=None, masses=1):\n", " \"\"\"Integrate a multi-pendulum with `n` sections\"\"\"\n", " #-------------------------------------------------\n", " # Step 1: construct the pendulum model\n", " \n", " # Generalized coordinates and velocities\n", " # (in this case, angular positions & velocities of each mass) \n", " q = mechanics.dynamicsymbols('q:{0}'.format(n))\n", " u = mechanics.dynamicsymbols('u:{0}'.format(n))\n", "\n", " # mass and length\n", " m = symbols('m:{0}'.format(n))\n", " l = symbols('l:{0}'.format(n))\n", "\n", " # gravity and time symbols\n", " g, t = symbols('g,t')\n", " \n", " #--------------------------------------------------\n", " # Step 2: build the model using Kane's Method\n", "\n", " # Create pivot point reference frame\n", " A = mechanics.ReferenceFrame('A')\n", " P = mechanics.Point('P')\n", " P.set_vel(A, 0)\n", "\n", " # lists to hold particles, forces, and kinetic ODEs\n", " # for each pendulum in the chain\n", " particles = []\n", " forces = []\n", " kinetic_odes = []\n", "\n", " for i in range(n):\n", " # Create a reference frame following the i^th mass\n", " Ai = A.orientnew('A' + str(i), 'Axis', [q[i], A.z])\n", " Ai.set_ang_vel(A, u[i] * A.z)\n", "\n", " # Create a point in this reference frame\n", " Pi = P.locatenew('P' + str(i), l[i] * Ai.x)\n", " Pi.v2pt_theory(P, A, Ai)\n", "\n", " # Create a new particle of mass m[i] at this point\n", " Pai = mechanics.Particle('Pa' + str(i), Pi, m[i])\n", " particles.append(Pai)\n", "\n", " # Set forces & compute kinematic ODE\n", " forces.append((Pi, m[i] * g * A.x))\n", " kinetic_odes.append(q[i].diff(t) - u[i])\n", "\n", " P = Pi\n", "\n", " # Generate equations of motion\n", " KM = mechanics.KanesMethod(A, q_ind=q, u_ind=u,\n", " kd_eqs=kinetic_odes)\n", " fr, fr_star = KM.kanes_equations(particles, forces)\n", " \n", " #-----------------------------------------------------\n", " # Step 3: numerically evaluate equations and integrate\n", "\n", " # initial positions and velocities – assumed to be given in degrees\n", " y0 = np.deg2rad(np.concatenate([np.broadcast_to(initial_positions, n),\n", " np.broadcast_to(initial_velocities, n)]))\n", " \n", " # lengths and masses\n", " if lengths is None:\n", " lengths = np.ones(n) / n\n", " lengths = np.broadcast_to(lengths, n)\n", " masses = np.broadcast_to(masses, n)\n", "\n", " # Fixed parameters: gravitational constant, lengths, and masses\n", " parameters = [g] + list(l) + list(m)\n", " parameter_vals = [9.81] + list(lengths) + list(masses)\n", "\n", " # define symbols for unknown parameters\n", " unknowns = [Dummy() for i in q + u]\n", " unknown_dict = dict(zip(q + u, unknowns))\n", " kds = KM.kindiffdict()\n", "\n", " # substitute unknown symbols for qdot terms\n", " mm_sym = KM.mass_matrix_full.subs(kds).subs(unknown_dict)\n", " fo_sym = KM.forcing_full.subs(kds).subs(unknown_dict)\n", "\n", " # create functions for numerical calculation \n", " mm_func = lambdify(unknowns + parameters, mm_sym)\n", " fo_func = lambdify(unknowns + parameters, fo_sym)\n", "\n", " # function which computes the derivatives of parameters\n", " def gradient(y, t, args):\n", " vals = np.concatenate((y, args))\n", " sol = np.linalg.solve(mm_func(*vals), fo_func(*vals))\n", " return np.array(sol).T[0]\n", "\n", " # ODE integration\n", " return odeint(gradient, y0, times, args=(parameter_vals,))" ], "execution_count": 3, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "nL1aC9waJNe_" }, "source": [ "We need a little helper function to convert from radial positions to x, y positions." ] }, { "cell_type": "code", "metadata": { "deletable": true, "editable": true, "id": "r0VW3cHpg0UZ" }, "source": [ "def get_xy_coords(p, lengths=None):\n", " \"\"\"Get (x, y) coordinates from generalized coordinates p\"\"\"\n", " p = np.atleast_2d(p)\n", " n = p.shape[1] // 2\n", " if lengths is None:\n", " lengths = np.ones(n) / n\n", " zeros = np.zeros(p.shape[0])[:, None]\n", " x = np.hstack([zeros, lengths * np.sin(p[:, :n])])\n", " y = np.hstack([zeros, -lengths * np.cos(p[:, :n])])\n", " return np.cumsum(x, 1), np.cumsum(y, 1)" ], "execution_count": 4, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "l-Ra1MH6JV1D" }, "source": [ "And now we can define a time list, t, in this case 10 seconds, and solve the pendulum equations of motion." ] }, { "cell_type": "code", "metadata": { "deletable": true, "editable": true, "id": "fXUrhniIg0Ue" }, "source": [ "t = np.linspace(0, 10, 1000)\n", "p = integrate_pendulum(n=2, times=t, initial_positions=135)\n" ], "execution_count": 5, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "q1z5ofOjJm6E" }, "source": [ "Since this notebook is interested in a double pendulum example, we can slice the solved pendulum results to obtain the angular velocity of the 2nd mass. This angular velocity will be our output variable of interest. " ] }, { "cell_type": "code", "metadata": { "id": "6Qz935KRPNOA", "colab": { "base_uri": "https://localhost:8080/", "height": 295 }, "outputId": "4d731572-a599-4678-d764-3a1bf71077f8" }, "source": [ "plt.plot(t,p[:, 3:4])\n", "plt.title(\"Angular velocity vs. time\")\n", "plt.xlabel(\"Max angular velocity, rad/s\")\n", "plt.ylabel(\"Time, s\")\n", "plt.show()" ], "execution_count": 6, "outputs": [ { "output_type": "display_data", "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "tags": [], "needs_background": "light" } } ] }, { "cell_type": "markdown", "metadata": { "id": "QH1v0P_0LUH3" }, "source": [ "We can find the maximum absolute value, to give us a single output parameter of interest." ] }, { "cell_type": "code", "metadata": { "id": "PgbWD5gcPoWX", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "1a114fdd-abf0-42ef-8c59-ef1f9c9c014b" }, "source": [ "print(f\"The maximum absolute angular velocity of the 2nd mass is {max(p[:, 3:4].max(),-p[:, 3:4].min()):.2f} rad/s\")" ], "execution_count": 7, "outputs": [ { "output_type": "stream", "text": [ "The maximum absolute angular velocity of the 2nd mass is 17.45 rad/s\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "id": "O0w0aRZACO0T", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "be9c6199-bec7-41e3-9c9a-24d1eb551a49" }, "source": [ "%%time\n", "\n", "# Monte Carlo\n", "\n", "NUM_RUNS=1000\n", "\n", "runs = []\n", "angles = []\n", "\n", "for i in range(NUM_RUNS):\n", " angle_i = np.random.normal(loc=135., scale=0.001)\n", " p = integrate_pendulum(n=2, times=t, initial_positions=angle_i)\n", " runs.append(max(p[:, 3:4].max(),-p[:, 3:4].min())) \n", " angles.append(angle_i)\n", "\n" ], "execution_count": 8, "outputs": [ { "output_type": "stream", "text": [ "CPU times: user 5min 48s, sys: 442 ms, total: 5min 49s\n", "Wall time: 5min 48s\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "id": "185RPXeKyFG7", "colab": { "base_uri": "https://localhost:8080/", "height": 295 }, "outputId": "42ad8057-5ece-4d79-e1fb-26c8eb07c74b" }, "source": [ "# plotting\n", "\n", "plt.hist(runs, 60, facecolor='blue', alpha=0.5)\n", "plt.vlines(17.45,0,70)\n", "plt.text(16.8, 72, 'exact value')\n", "plt.title(\"Histogram of angular velocity\")\n", "plt.xlabel(\"Max angular velocity, rad/s\")\n", "plt.ylabel(\"count\")\n", "plt.show()" ], "execution_count": 9, "outputs": [ { "output_type": "display_data", "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "tags": [], "needs_background": "light" } } ] }, { "cell_type": "code", "metadata": { "id": "pkm5AiBCzrHM", "colab": { "base_uri": "https://localhost:8080/", "height": 295 }, "outputId": "82f57f80-80bd-4d7c-a292-b6639e21fc9d" }, "source": [ "ecdf = ECDF(runs)\n", "x = np.linspace(min(runs), max(runs), 100)\n", "y = ecdf(x)\n", "plt.step(x, y)\n", "plt.title(\"Cumulative distribution function\")\n", "plt.xlabel(\"Max angular velocity, rad/s\")\n", "plt.ylabel(\"cumulative probability\")\n", "\n", "plt.axvline(np.interp(0.95,y,x))\n", "plt.axhline(0.95)\n", "plt.text(17, 0.9, '95% probability')\n", "plt.text(17, 0.83, f'{np.interp(0.95,y,x):.2f} rad/s')\n", "\n", "plt.show()" ], "execution_count": 10, "outputs": [ { "output_type": "display_data", "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "tags": [], "needs_background": "light" } } ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 295 }, "id": "8cKzqZHKnJ7k", "outputId": "0a63e247-747f-4394-d42b-fa3dcada10a0" }, "source": [ "plt.scatter(angles, runs)\n", "plt.title(\"Angular velocity vs. Initial Angle\")\n", "plt.ylabel(\"Max angular velocity, rad/s\")\n", "plt.xlabel(\"Initial Angle, deg\")\n", "plt.xlim(134.996,135.004)\n", "plt.show()" ], "execution_count": 11, "outputs": [ { "output_type": "display_data", "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "tags": [], "needs_background": "light" } } ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true, "id": "xpmzOnbkg0Uj" }, "source": [ "Now to check some animations:" ] }, { "cell_type": "code", "metadata": { "deletable": true, "editable": true, "id": "8jMeb11sg0Up" }, "source": [ "def animate_pendulum(n, times,\n", " initial_positions=135,\n", " initial_velocities=0,\n", " lengths=None, masses=1):\n", " \n", " p = integrate_pendulum(n, times,\n", " initial_positions=initial_positions,\n", " initial_velocities=initial_velocities,\n", " lengths=lengths, masses=masses)\n", " x, y = get_xy_coords(p)\n", " \n", " fig, ax = plt.subplots(figsize=(6, 6))\n", " fig.subplots_adjust(left=0, right=1, bottom=0, top=1)\n", " ax.axis('off')\n", " ax.set(xlim=(-1, 1), ylim=(-1, 1))\n", "\n", " line, = ax.plot([], [], 'o-', lw=2)\n", "\n", " def init():\n", " line.set_data([], [])\n", " return line,\n", "\n", " def animate(i):\n", " line.set_data(x[i], y[i])\n", " return line,\n", "\n", " anim = animation.FuncAnimation(fig, animate, frames=len(times),\n", " interval=1000 * times.max() / len(times),\n", " blit=True, init_func=init)\n", " plt.close(fig)\n", " return anim" ], "execution_count": 12, "outputs": [] }, { "cell_type": "code", "metadata": { "deletable": true, "editable": true, "id": "4cdT04fyg0U4" }, "source": [ "def animate_pendulum_multiple(n, times=t, n_pendulums=100, track_length=15):\n", " oversample = 3\n", " track_length *= oversample\n", " \n", " t = np.linspace(0, 10, oversample * 200)\n", " p = [integrate_pendulum(n, t, initial_positions=np.random.normal(loc=135., scale=0.001))\n", " for i in range(n_pendulums)]\n", " positions = np.array([get_xy_coords(pi) for pi in p])\n", " positions = positions.transpose(0, 2, 3, 1)\n", " # positions is a 4D array: (npendulums, len(t), n+1, xy)\n", " \n", " fig, ax = plt.subplots(figsize=(6, 6))\n", " fig.subplots_adjust(left=0, right=1, bottom=0, top=1)\n", " ax.axis('off')\n", " ax.set(xlim=(-1, 1), ylim=(-1, 1))\n", " \n", " track_segments = np.zeros((n_pendulums, 0, 2))\n", " tracks = collections.LineCollection(track_segments, cmap='jet')\n", " tracks.set_array(np.linspace(0, 1, n_pendulums))\n", " ax.add_collection(tracks)\n", " \n", " points, = plt.plot([], [], 'ok')\n", " \n", " pendulum_segments = np.zeros((n_pendulums, 0, 2))\n", " pendulums = collections.LineCollection(pendulum_segments, colors='black')\n", " ax.add_collection(pendulums)\n", "\n", " def init():\n", " pendulums.set_segments(np.zeros((n_pendulums, 0, 2)))\n", " tracks.set_segments(np.zeros((n_pendulums, 0, 2)))\n", " points.set_data([], [])\n", " return pendulums, tracks, points\n", "\n", " def animate(i):\n", " i = i * oversample\n", " pendulums.set_segments(positions[:, i])\n", " sl = slice(max(0, i - track_length), i)\n", " tracks.set_segments(positions[:, sl, -1])\n", " x, y = positions[:, i].reshape(-1, 2).T\n", " points.set_data(x, y)\n", " return pendulums, tracks, points\n", "\n", " interval = 1000 * oversample * t.max() / len(t)\n", " anim = animation.FuncAnimation(fig, animate, frames=len(t) // oversample,\n", " interval=interval,\n", " blit=True, init_func=init)\n", " plt.close(fig)\n", " return anim\n", " \n", "anim = animate_pendulum_multiple(2, times=t)\n" ], "execution_count": 13, "outputs": [] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 453 }, "id": "6NWS_7znqIi6", "outputId": "5974efc1-975d-4f44-ff3e-d5b98a5b37f5" }, "source": [ "HTML(anim.to_html5_video()) \n", "\n", "# or, if FFMPEG is not installed then comment the above line and uncomment the lines below:\n", "#plt.rcParams[\"animation.writer\"] = 'html'\n", "#anim.save('double_pendulum_multiple.html', extra_args=['-vcodec', 'libx264'])\n", "#HTML(filename=\"double_pendulum_multiple.html\")\n" ], "execution_count": 14, "outputs": [ { "output_type": "execute_result", "data": { "text/html": [ "