quadrotor_model.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quadrotor Model\n",
    "\n",
    "Multirotors are underactuated aerial robots that consist of multiple motor/propeller combinations. A quadrotor has four motor/propellor combinations, as shown in the below figure."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Figure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Coordinate Frames\n",
    "\n",
    "Coordinate frames are rigid, orthonormal bases of $\\mathbb{R}^3$. There are two main coordinate frames of interest: the inertial frame $\\mathcal{F}^i$ and the body frame $\\mathcal{F}^b$. The inertial frame $\\mathcal{F}^i$ is an orthonormal basis of $\\mathbb{R}^3$ that is earth-fixed with an origin defined as the ''home'' position. The body frame $\\mathcal{F}^b$ represents the quadrotor and we assume that its origin is the center of mass of the quadrotor. \n",
    "\n",
    "Intermediate frames exist that help us account for the roll, pitch, and yaw rotations of the quadrotor. The first intermediate frame is the vehicle frame $\\mathcal{F}^v$, which is at the position of the unrolled, unpitched, unyawed quadrotor. The vehicle frame leads to the vehicle-1 frame $\\mathcal{F}^{v1}$ by yawing about the $\\mathbf{k}^v$ axis, resulting in the unrolled, unpitched frame. Pitching about the new $\\mathbf{j}^{v1}$ axis results in the unrolled vehicle-2 frame $\\mathcal{F}^{v2}$, and rolling about the new $\\mathbf{i}^{v2}$ axis results in the properly oriented body frame $\\mathcal{F}^b$.\n",
    "\n",
    "Additional frames may be the camera frame, the gimbal frame, or other sensor or measurement frames.\n",
    "\n",
    "Note that in this work, we use the aerospace standard of passive, right-handed rotations and we will use 3-2-1 ($\\psi$-$\\theta$-$\\phi$) Euler angles for yaw, pitch, roll, respectively.\n",
    "\n",
    "Python code that builds proper rotation matrices in $\\mathbb{R}^{3\\times3}$ is given below. These rotation matrices can be used to rotate from the vehicle (or inertial) frame to the body frame through all the intermediate frames."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def Rot_v_to_v1(psi):\n",
    "    R = np.array([\n",
    "        [ np.cos(psi), np.sin(psi), 0],\n",
    "        [-np.sin(psi), np.cos(psi), 0],\n",
    "        [     0,           0    ,   1]\n",
    "    ])\n",
    "    return R\n",
    "\n",
    "def Rot_v1_to_v2(theta):\n",
    "    R = np.array([\n",
    "        [np.cos(theta), 0, -np.sin(theta)],\n",
    "        [      0      , 1,        0      ],\n",
    "        [np.sin(theta), 0,  np.cos(theta)]\n",
    "    ])\n",
    "    return R\n",
    "\n",
    "def Rot_v2_to_b(phi):\n",
    "    R = np.array([\n",
    "        [1,       0,           0     ],\n",
    "        [0,  np.cos(phi), np.sin(phi)],\n",
    "        [0, -np.sin(phi), np.cos(phi)]\n",
    "    ])\n",
    "    return R\n",
    "\n",
    "def Rot_v_to_b(phi, theta, psi):\n",
    "    return Rot_v2_to_b(phi).dot(Rot_v1_to_v2(theta).dot(Rot_v_to_v1(psi)))\n",
    "\n",
    "def Rot_i_to_b(phi, theta, psi):\n",
    "    return Rot_v_to_b(phi, theta, psi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configuration Space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The quadrotor equations of motion consist of $6$ degrees of freedom (DOF) and $12$ ordinary differential equations ($6$ are kinematic and $6$ are dynamic). The quadrotor is modelled as a freely-rotating rigid body evolving in $\\mathcal{M} = \\mathbb{R}^3 \\times \\text{SO}(3) = \\text{SE}(3)$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that $\\text{SO}(3)$ is a matrix Lie group that describes the orientation of rigid body in 3D space and is not isomorphic to $\\mathbb{R}^3$. However, because Lie groups are smooth (i.e., differentiable) manifolds, there is an atlas of charts (i.e., homemorphisms) that allow the manifold to be locally described as a Euclidean space. A popular set of local parameterizations are the intuitive Euler angles, of which there are twelve. We will use the intrinsic 3-2-1 ($\\psi$-$\\theta$-$\\phi$) Euler angle representation as is common in aerospace with first a yaw rotation about $\\mathbf{k}$, a pitch rotation about $\\mathbf{j}$, and then a roll rotation about $\\mathbf{i}$. Additionally, we assume that the roll, pitch, and yaw of the quadrotor are small -- a logical assumption for the smooth trajectories of typical maneuvers. More precisely, we have that\n",
    "$$\n",
    "\\phi \\in [0, 2\\pi) \\subset \\mathbb{R} \\\\\n",
    "\\theta \\in (-\\pi/2, \\pi/2) \\subset \\mathbb{R} \\\\\n",
    "\\psi \\in [0, 2\\pi) \\subset \\mathbb{R}.\n",
    "$$\n",
    "Thus, the state of the quadrotor is given by $\\mathbf{x} = \\begin{bmatrix} x & y & z & \\phi & \\theta & \\psi \\end{bmatrix}^\\top \\in \\mathbb{R}^6$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Equations of Motion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Kinematics\n",
    "\n",
    "Kinematics describe the motion of an object without consideration of what caused that motion. Using kinematics, we can relate position to velocity and orientation to angular velocity. Notice that these equations are irrespective of intertial properties such mass and size."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Translational\n",
    "\n",
    "$$\n",
    "\\dot{\\mathbf{r}}^i = R_b^i \\mathbf{v}^b\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Rotational\n",
    "\n",
    "When determining the rotational kinematic equation of a rigid body, we are asking how the angular velocities relate to the current orientation. A rate gyro is used to measure the angular velocity about each of the body-frame axes of the rigid body. These gyro measurements are given by $\\mathbf{\\omega}^b = p\\mathbf{i}^b + q\\mathbf{j}^b + r\\mathbf{k}^b = \\begin{bmatrix} p & q & r\\end{bmatrix}^\\top$.\n",
    "\n",
    "Difficulty relating $\\mathbf{\\omega}$ with the orientation expressed with Euler angles arises because each Euler angle is defined in a different frame. Therefore, the derivatives of each Euler angle must be transformed into the proper frame as follows:\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "\\mathbf{\\omega} =\n",
    "  \\begin{bmatrix} p \\\\ q \\\\ r \\end{bmatrix} &= \n",
    "  \\begin{bmatrix} \\dot{\\phi} \\\\ 0 \\\\ 0 \\end{bmatrix} +\n",
    "  R_{v2}^b(\\phi) \\begin{bmatrix} 0 \\\\ \\dot{\\theta} \\\\ 0 \\end{bmatrix} +\n",
    "  R_{v2}^b(\\phi) R_{v1}^{v2}(\\theta) \\begin{bmatrix} 0 \\\\ 0 \\\\ \\dot{\\psi} \\end{bmatrix} \\\\\n",
    "&=\n",
    "  \\begin{bmatrix} \\dot{\\phi} \\\\ 0 \\\\ 0 \\end{bmatrix} +\n",
    "  \\begin{bmatrix}\n",
    "    1 & 0 & 0 \\\\\n",
    "    0 & \\cos\\phi & \\sin\\phi \\\\\n",
    "    0 & -\\sin\\phi & \\cos\\phi\n",
    "  \\end{bmatrix}\n",
    "  \\begin{bmatrix} 0 \\\\ \\dot{\\theta} \\\\ 0 \\end{bmatrix} +\n",
    "  \\begin{bmatrix}\n",
    "    1 & 0 & 0 \\\\\n",
    "    0 & \\cos\\phi & \\sin\\phi \\\\\n",
    "    0 & -\\sin\\phi & \\cos\\phi\n",
    "  \\end{bmatrix}\n",
    "  \\begin{bmatrix}\n",
    "    \\cos\\theta & 0 & -\\sin\\theta \\\\\n",
    "    0 & 1 & 0 \\\\\n",
    "    \\sin\\theta & 0 & \\cos\\theta\n",
    "  \\end{bmatrix}\n",
    "  \\begin{bmatrix} 0 \\\\ 0 \\\\ \\dot{\\psi} \\end{bmatrix} \\\\\n",
    "&=\n",
    "\\underbrace{\n",
    "  \\begin{bmatrix}\n",
    "    1 & 0 & -\\sin\\theta \\\\\n",
    "    0 & \\cos\\phi & \\sin\\phi\\cos\\theta \\\\\n",
    "    0 & -\\sin\\phi & \\cos\\phi\\cos\\theta\n",
    "  \\end{bmatrix}\n",
    "}_{\\Gamma^{-1}}\n",
    "  \\begin{bmatrix} \\dot\\phi \\\\ \\dot\\theta \\\\ \\dot\\psi \\end{bmatrix}.\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "Note that $\\det\\Gamma^{-1} = cos\\theta$. Thus, for $\\theta \\in (-\\pi/2, \\pi/2)$ the matrix $\\Gamma^{-1}$ is invertible, and we can write the rotational kinematic equation using Euler angles as\n",
    "\n",
    "$$\n",
    "\\mathbf{\\dot\\Phi} =\n",
    "\\begin{bmatrix} \\dot\\phi \\\\ \\dot\\theta \\\\ \\dot\\psi \\end{bmatrix} =\n",
    "\\begin{bmatrix}\n",
    "  1 & \\sin\\phi\\tan\\theta & \\cos\\phi\\tan\\theta \\\\\n",
    "  0 & \\cos\\phi & -\\sin\\phi \\\\\n",
    "  0 & \\sin\\phi\\sec\\theta & \\cos\\phi\\sec\\theta\n",
    "\\end{bmatrix}\n",
    "\\begin{bmatrix} p \\\\ q \\\\ r \\end{bmatrix} =\n",
    "\\Gamma(\\phi,\\theta) \\mathbf{\\omega}.\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dynamics\n",
    "\n",
    "Dynamics describe the motion of objects in relation to forces and torques, which cause motion. This is often how we use a controller to interact with a physical system. This is because we can control actuators which cause a force or torque on the system."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Translational\n",
    "\n",
    "It is easiest to express Newton's second law in the body frame. However, Newton's laws only hold in inertial frames. Therefore, we use the equation of Coriolis to express the derivative of an inertial frame quantity to the derivative in the body frame, which gives us\n",
    "\n",
    "$$\n",
    "\\mathbf{F}_g - \\mathbf{T} = m\\dot{\\mathbf{v}}^b + \\mathbf{\\omega} \\times \\mathbf{v}^b,\n",
    "$$\n",
    "\n",
    "where $\\mathbf{F}_g = mg \\begin{bmatrix} -\\sin\\theta & \\cos\\theta\\sin\\phi & \\cos\\theta\\cos\\phi \\end{bmatrix}^\\top$ and $\\mathbf{T} = \\begin{bmatrix} 0 & 0 & f \\end{bmatrix}^\\top$. This can be rearranged into\n",
    "\n",
    "$$\n",
    "\\dot{\\mathbf{v}}^b = \\frac{1}{m}[\\mathbf{F}_g - \\mathbf{T} - \\mathbf{\\omega} \\times \\mathbf{v}^b].\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Translational (inertial)\n",
    "\n",
    "Alternatively, we can express the translational dynamics in the inertial frame, which can be advantageous if we are trying to command inertial positions or velocities.\n",
    "\n",
    "$$\n",
    "m\\ddot{\\mathbf{r}}^i = mg\\mathbf{k}^i - R_b^i \\begin{bmatrix} 0 \\\\ 0 \\\\ u_1 \\end{bmatrix}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Translational (inertial) with Drag\n",
    "\n",
    "We make the model more realistic by adding drag, see [3]. It is ideal to have a higher fidelity plant model than the control/estimation models---this will certainly be true in real life.\n",
    "\n",
    "$$\n",
    "m\\ddot{\\mathbf{r}}^i = mg\\mathbf{k}^i -\n",
    "R_b^i \\begin{bmatrix} 0 \\\\ 0 \\\\ u_1 \\end{bmatrix} -\n",
    "\\begin{bmatrix} \\mu \\\\ \\mu \\\\ 0 \\end{bmatrix} \\dot{\\mathbf{r}}^i\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Rotational\n",
    "\n",
    "Following Netwton's second law for rotational motion ($M = I\\dot\\omega$), we get\n",
    "\n",
    "$$\n",
    "I\\mathbf{\\dot\\omega} = -\\omega \\times I\\omega + M.\n",
    "$$\n",
    "\n",
    "We assume that the quadrotor is symmetric about its axes so that\n",
    "$$\n",
    "I=\n",
    "\\begin{bmatrix}\n",
    "    I_x &  0  &  0  \\\\\n",
    "     0  & I_y &  0  \\\\\n",
    "     0  &  0  & I_z \\\\\n",
    "\\end{bmatrix}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Forces and Moments\n",
    "\n",
    "Given that we have a dynamic model of a quadrotor, we must determine the forces and moments that are used to drive the 6 DOF dynamic model we have derived.\n",
    "\n",
    "$$\n",
    "\\begin{bmatrix} u_1 \\\\ u_2 \\\\ u_3 \\\\ u_4 \\end{bmatrix} =\n",
    "\\begin{bmatrix}\n",
    "    1 & 1 & 1 & 1 \\\\\n",
    "    0 & -\\ell & 0 & \\ell \\\\\n",
    "    \\ell & 0 & -\\ell & 0 \\\\\n",
    "    -c_T & c_T & -c_T & c_T \\\\\n",
    "\\end{bmatrix}\n",
    "\\begin{bmatrix} T_1 \\\\ T_2 \\\\ T_3 \\\\ T_4 \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "The thrust $T_i$ produced by each motor/propellor combination is related to the propellor's angular velocity by\n",
    "$$\n",
    "T_i = k\\Omega_i^2.\n",
    "$$\n",
    "\n",
    "Using these expressions, we can find the actual motor commands.\n",
    "\n",
    "Note: Given that the thrust is such that it is always overcoming gravity, a positive $m_\\phi$ yields a positive motion along $\\mathbf{j}^b$. A positive $m_\\theta$ yields a negative motion along $\\mathbf{i}^b$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "np.set_printoptions(formatter={'float': '{: 0.3f}'.format})\n",
    "\n",
    "class Quadrotor(object):\n",
    "    \"\"\"Quadrotor\n",
    "        \n",
    "    This class models the physical quadrotor vehicle evolving in SE(3).\n",
    "    \"\"\"\n",
    "    def __init__(self, r=None, Phi=None, v=None, omega=None):\n",
    "        \n",
    "        # internal quadrotor state\n",
    "        self.r = r if r is not None else np.zeros((3,1))\n",
    "        self.Phi = Phi if Phi is not None else np.zeros((3,1))\n",
    "        self.v = v if v is not None else np.zeros((3,1))\n",
    "        self.omega = omega if omega is not None else np.zeros((3,1))\n",
    "        \n",
    "        # phyiscal true parameters\n",
    "        self.g = 9.81\n",
    "        self.mass = 3.81\n",
    "        Jxx = 0.060224; Jyy = 0.122198; Jzz = 0.132166\n",
    "        self.I = np.array([[Jxx,0,0],\n",
    "                           [0,Jyy,0],\n",
    "                           [0,0,Jzz]])\n",
    "        \n",
    "        self.Mu = np.diag(np.array([0.85,0.85,0.85])) # drag\n",
    "#         self.Mu = np.diag(np.array([0,0,0])) # drag\n",
    "        \n",
    "        # max control actuation\n",
    "        self.Tmax = 40\n",
    "        self.Mmax = 2\n",
    "        \n",
    "        # convenience\n",
    "        self.Niters = 0\n",
    "        \n",
    "    def __str__(self):\n",
    "        s  = \"Quadrotor state after {} iters:\\n\".format(self.Niters)\n",
    "        s += \"\\tr:     {}.T\\n\".format(self.r.T)\n",
    "        s += \"\\tPhi:   {}.T\\n\".format(self.Phi.T)\n",
    "        s += \"\\tv:     {}.T\\n\".format(self.v.T)\n",
    "        s += \"\\tomega: {}.T\\n\".format(self.omega.T)\n",
    "        return s\n",
    "    \n",
    "    @staticmethod\n",
    "    def clamp(v, limit):\n",
    "        v = np.copy(v)\n",
    "        v[np.abs(v) > limit] = np.sign(v[np.abs(v) > limit])*limit\n",
    "        return v\n",
    "\n",
    "    @staticmethod\n",
    "    def Gamma(phi, theta):\n",
    "        return np.array([\n",
    "            [1, np.sin(phi)*np.tan(theta), np.cos(phi)*np.tan(theta)],\n",
    "            [0,         np.cos(phi)      ,        -np.sin(phi)      ],\n",
    "            [0, np.sin(phi)/np.cos(theta), np.cos(phi)/np.cos(theta)]\n",
    "        ])\n",
    "        \n",
    "    def Fg(self, phi, theta):\n",
    "        return self.mass*self.g*np.array([[      -np.sin(theta)     ],\n",
    "                                          [np.cos(theta)*np.sin(phi)],\n",
    "                                          [np.cos(theta)*np.cos(phi)]])\n",
    "    \n",
    "    def update(self, u, dt):\n",
    "        # We've been through another iteration\n",
    "        self.Niters += 1\n",
    "        \n",
    "        # Extract Euler angles for convenience\n",
    "        ph = self.Phi.flatten()[0]\n",
    "        th = self.Phi.flatten()[1]\n",
    "        ps = self.Phi.flatten()[2]\n",
    "        \n",
    "        #\n",
    "        # Forces and Moments\n",
    "        #\n",
    "        \n",
    "        u = np.array(u).flatten()\n",
    "        T = np.array([[0, 0, u[0]]]).T\n",
    "        M = np.array([[u[1], u[2], u[3]]]).T\n",
    "        \n",
    "        #\n",
    "        # Saturate control effort\n",
    "        #\n",
    "        \n",
    "        T = self.clamp(T, self.Tmax)\n",
    "        M = self.clamp(M, self.Mmax)\n",
    "        \n",
    "        #\n",
    "        # Kinematics\n",
    "        #\n",
    "        \n",
    "        # Translational\n",
    "#         f = lambda r: Rot_i_to_b(ph,th,ps).T.dot(self.v) # body velocities\n",
    "        f = lambda r: self.v # inertial velocities\n",
    "        self.r = rk4(f, self.r, dt)\n",
    "        \n",
    "        # Rotational\n",
    "        f = lambda Phi: self.Gamma(Phi[0], Phi[1]).dot(self.omega)\n",
    "        self.Phi = rk4(f, self.Phi, dt)\n",
    "        \n",
    "        #\n",
    "        # Dynamics\n",
    "        #\n",
    "        \n",
    "        # Translational\n",
    "#         f = lambda v: (1/self.mass)*(self.Fg(ph,th) - T - np.cross(self.omega, v, axis=0)) # body\n",
    "        f = lambda v: (1/self.mass)*(self.Fg(0,0) - Rot_i_to_b(ph,th,ps).T.dot(T) - self.Mu.dot(v)) # inertial\n",
    "        self.v = rk4(f, self.v, dt)\n",
    "        \n",
    "        # Rotational\n",
    "        f = lambda omega: np.linalg.inv(self.I).dot((-np.cross(omega, self.I.dot(omega), axis=0) + M))\n",
    "        self.omega = rk4(f, self.omega, dt)\n",
    "        \n",
    "        # update control input\n",
    "        u = np.hstack((T[2], M.flatten()))\n",
    "        return u"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "%run utils.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quadrotor state after 150 iters:\n",
      "\tr:     [[ 0.000  0.000  0.000]].T\n",
      "\tPhi:   [[ 0.000  0.000  0.000]].T\n",
      "\tv:     [[ 0.000  0.000  0.000]].T\n",
      "\tomega: [[ 0.000  0.000  0.000]].T\n",
      "\n"
     ]
    }
   ],
   "source": [
    "quad = Quadrotor()\n",
    "\n",
    "# feed-forward thrust\n",
    "z_ff = quad.mass*quad.g\n",
    "\n",
    "Ts = 0.01\n",
    "Tf = 1.5\n",
    "N = int(Tf/Ts)\n",
    "for i in range(N):\n",
    "    m1 = 10 if Ts*i < 1 else 0\n",
    "    quad.update([z_ff, 0.0, 0.0, 0.0], Ts)\n",
    "print(quad)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References\n",
    "\n",
    "[1] R. W. Beard and T. W. McLain, Small Unmanned Aircraft. Princeton, New Jersey: Princeton University Press, 2012.\n",
    "\n",
    "[2] R. W. Beard and T. W. Mclain, “Introduction to Feedback Control using Design Studies,” 2016.\n",
    "\n",
    "[3] R. C. Leishman, J. C. MacDonald, R. W. Beard, and T. W. McLain, “Quadrotors and accelerometers: State estimation with an improved dynamic model,” IEEE Control Syst., vol. 34, no. 1, pp. 28–41, 2014."
   ]
  }
 ],
 "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.5.2"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}