Slinky - Part1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Matplotlib created a temporary config/cache directory at /tmp/matplotlib-wf_yy2r_ because the default path (/tmp/cache/matplotlib) is not a writable directory; it is highly recommended to set the MPLCONFIGDIR environment variable to a writable directory, in particular to speed up the import of Matplotlib and to better support multiprocessing.\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import numpy.linalg as la\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\">\n",
    "\n",
    "# Lesson 4: Linear Systems\n",
    "    \n",
    "**You learned about spring systems during lecture. We will now use this knowledge to understand how a Slinky changes its shape due to gravity!**\n",
    "        \n",
    "    \n",
    "![Figure](slinky1.jpg)\n",
    "    \n",
    "    \n",
    "Try taking a slinky and suspend it from one side. What happens to its shape?\n",
    "\n",
    "Today we will model the deformation (change of shape) of a slinky under the effects of gravitational forces. We will break down the slinky into many small springs, creating a mass-spring system as illustrated below:\n",
    "\n",
    "<img src=\"slinky_held2.png\" width=350>\n",
    "    \n",
    "\n",
    "where in the general case, $f_i$ is the applied force and $u_i$ is the corresponding displacement (movement) at mass $m_i$. For this example, the applied force $f_i$ correspond to the gravitational force.\n",
    "\n",
    "We want to determine the equilibrium condition of this system, such that the balance of the internal forces (resulting from the spring getting deformed) and external forces (applied forces at the masses) is equal to zero. To accomplish this we will follow Hooke's law, which states the spring force needed to deform a spring by an amount $\\Delta L$ is given as $−k \\Delta L$, where $k$ is the spring's stiffness. Consider the two springs below:\n",
    "    \n",
    "    \n",
    "<img src=\"two_springs.png\" width=300>\n",
    "\n",
    "\n",
    "The force that spring $k_i$ exerts on mass $m_i$ is given by $-k_i(u_i - u_{i-1})$. In a similar way, the force that spring $k_{i+1}$ exerts on mass $m_i$ is $k_{i+1}(u_{i+1} - u_{i})$. We can combine these two spring forces and the applied force at $m_i$ to obtain the following equation:\n",
    "    \n",
    "<img src=\"force_balance.png\" width=300>\n",
    "\n",
    "\n",
    "$$f_i - k_i(u_i - u_{i-1}) + k_{i+1}(u_{i+1} - u_{i}) = 0 $$\n",
    "    \n",
    "If we apply the equilibrium equation to all $N$ masses of the spring system, we get the following system of equations:\n",
    "\n",
    "$$\n",
    "\\begin{equation}\n",
    "f_1 - k_1(u_1 - u_{0}) + k_{2}(u_{2} - u_{1}) = 0 \\\\\n",
    "f_2 - k_2(u_2 - u_{1}) + k_{3}(u_{3} - u_{2}) = 0 \\\\\n",
    "f_3 - k_3(u_3 - u_{2}) + k_{4}(u_{4} - u_{3}) = 0 \\\\\n",
    "f_4 - k_4(u_4 - u_{3}) + k_{5}(u_{5} - u_{4}) = 0 \\\\\n",
    "f_5 - k_5(u_5 - u_{4})  = 0 \\\\\n",
    "\\end{equation}\n",
    "$$\n",
    "\n",
    "We can assume that $u_0 = 0$, indicating that one end of the slinky is held in place. The above equations can be re-written in matrix form:\n",
    "\n",
    "$$\n",
    "\\begin{eqnarray}\n",
    "\\begin{bmatrix}\n",
    "k_1+k_2 & -k_2 & 0 & 0 & 0 \\\\\n",
    " -k_2 & k_2+k_3 & -k_3 & 0 & 0 \\\\\n",
    " 0 & -k_3 & k_3+k_4 & -k_4 & 0 \\\\\n",
    " 0 & 0 & -k_4 & k_4 + k_5 & -k_5 \\\\\n",
    " 0 & 0 & 0 &  -k_5 & k_5 \\\\\n",
    "\\end{bmatrix} \n",
    "\\begin{bmatrix}\n",
    "u_1\\\\ u_2 \\\\ u_3 \\\\ u_4 \\\\ u_5\n",
    "\\end{bmatrix} = \n",
    "\\begin{bmatrix}\n",
    " f_1\\\\ f_2 \\\\ f_3 \\\\ f_4 \\\\ f_5\n",
    "\\end{bmatrix}\n",
    "\\end{eqnarray}\n",
    "$$\n",
    "\n",
    "which we can solve for the unknown displacements $u_i$ by solving\n",
    "\n",
    "$${\\bf K}{\\bf u} = {\\bf f}$$\n",
    "\n",
    "where we will denote ${\\bf K}$ the stiffness matrix, ${\\bf u}$ the displacement vector and ${\\bf f}$ the force vector.\n",
    "\n",
    "**We are done! We can now analyze the slinky model.**\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem definition - Input variables:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The overall slinky has mass $M$, length $L_s$ and stiffness $K_s$ (a parameter that depends on the material and the dimensions of the slinky). We will use the parameters below for the metal slinky:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "Ls = 10   # (cm)       Length of the slinky\n",
    "Ks = 700  # (N/cm)     Stiffness\n",
    "M  = 170  # (grams)    Total mass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our model assumes that the mass $M$ is split into a series of $(N+1)$ smaller equal masses $m = M/(N+1)$ which are connected by $N$ massless ideal springs. Hence, the slinky  is divided into smaller but stiffer springs, with $l = L_s/N$ and $k = K_s\\cdot N$ (in this example, all springs have the same stiffness, since the slinky is made of one material).\n",
    "\n",
    "In other words, we will **discretize** our model into $N$-many springs. We will start by using $N = 5$. You will later use a finer discretization by increasing the value of $N$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Number of springs\n",
    "N = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28.333333333333332"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = M/(N+1) # each individual mass\n",
    "k = Ks*N    # each individiual spring stiffness\n",
    "l = Ls/N    # each individual spring length\n",
    "m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the spring system above, all the springs will have the same spring stiffness $k$, since we are assuming the entire slinky is made of the same material. But in general, we could combine two slinkies of different materials. For that reason, we will define the array `k_array` which contains each individual spring stiffness:\n",
    "\n",
    "$$ \\textrm{k_array} = [k_1, k_2, k_3, ... , k_N ] $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3500. 3500. 3500. 3500. 3500.]\n"
     ]
    }
   ],
   "source": [
    "k_array = k*np.ones(N)\n",
    "print(k_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Obtaining the stiffness matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We would like to create the stiffness matrix in a programmatic way. That way, we can later add many more springs, or use different material without having to change our code. We will take advantage of the pattern of this matrix. Here is the stiffness matrix for the 5 spring system:\n",
    "\n",
    "$$\n",
    "\\begin{eqnarray}\n",
    "{\\bf K} = \\begin{bmatrix}\n",
    "k_1+k_2 & -k_2 & 0 & 0 & 0 \\\\\n",
    " -k_2 & k_2+k_3 & -k_3 & 0 & 0 \\\\\n",
    " 0 & -k_3 & k_3+k_4 & -k_4 & 0 \\\\\n",
    " 0 & 0 & -k_4 & k_4 + k_5 & -k_5 \\\\\n",
    " 0 & 0 & 0 &  -k_5 & k_5 \\\\\n",
    "\\end{bmatrix}\n",
    "\\end{eqnarray}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Can you see a pattern?**\n",
    "\n",
    "Note that each spring contributes to the stiffness matrix with the following sub-matrix:\n",
    "\n",
    "$$\n",
    "\\begin{eqnarray}\n",
    "\\begin{bmatrix}\n",
    "k_i & -k_i  \\\\\n",
    " -k_i & k_i\\\\\n",
    "\\end{bmatrix}\n",
    "\\end{eqnarray}\n",
    "$$\n",
    "with the exception of $k_1$.\n",
    "\n",
    "Once you can recognize the pattern, you will need to:\n",
    "\n",
    "1) add this sub-matrix in the correct location of the bigger stiffness matrix ${\\bf K}$\n",
    "\n",
    "2) adjust the first line of the stiffness matrix ${\\bf K}$, that follows a different pattern due to the boundary conditions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To help you with 1), you could use the following method to insert the sub-matrix `Asub` in the matrix `A` given the position of the entry `Asub[0,0]`. This is not a requirement, there are other ways to accomplish the same thing :-)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 1. 1. 0. 0.]\n",
      " [0. 1. 1. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]]\n",
      "[[0. 1. 1. 0. 0.]\n",
      " [1. 2. 1. 0. 0.]\n",
      " [1. 1. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "A = np.zeros((5,5))\n",
    "Asub = np.ones((2,2))\n",
    "\n",
    "# Use Python slicing\n",
    "# Insert by overriding a sub-matrix\n",
    "A[0:2,1:3] = Asub\n",
    "print(A)\n",
    "# Insert by adding a sub-matrix\n",
    "A[1:3, 0:2] += Asub\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'i' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-14-0adb74a4f6bf>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mK\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mAsub\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mk_array\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0mk_array\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mk_array\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mk_array\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;31m# Use Python slicing\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# Insert by overriding a sub-matrix\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'i' is not defined"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Check your answers!**  \n",
    "#### Create the stiffness matrix\n",
    "\n",
    "Define the function `get_stiffness` that takes the array `k_array` with each spring stiffness, and returns the stiffness matrix ${\\bf K}$.  You can refer back to the definition of the stiffness matrix above. Remember that you have to exclude the first $k_1$ in your loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "#grade (enter your code in this cell - DO NOT DELETE THIS LINE) \n",
    "def get_stiffness(k_array):\n",
    "    # k_array: 1d numpy array with all the stiffness spring values\n",
    "    # number of springs\n",
    "    N = len(k_array)\n",
    "    # create and return an N x N stiffness matrix\n",
    "    K = np.zeros((N,N))\n",
    "    for i in range (N-1):\n",
    "        #A = np.zeros((5,5)) \"K\"\n",
    "        Asub = np.array([[k_array[i], -k_array[i]],[-k_array[i], k_array[i]]])\n",
    "\n",
    "        # Use Python slicing\n",
    "        # Insert by overriding a sub-matrix\n",
    "\n",
    "        # Insert by adding a sub-matrix\n",
    "        K[i:i+2, i:i+2] += Asub\n",
    "    \n",
    "    K[0][0] += k_array[0]\n",
    "    \n",
    "    return K"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you can get the stiffness matrix `K` given `k_array`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 7000. -3500.     0.     0.     0.]\n",
      " [-3500.  7000. -3500.     0.     0.]\n",
      " [    0. -3500.  7000. -3500.     0.]\n",
      " [    0.     0. -3500.  7000. -3500.]\n",
      " [    0.     0.     0. -3500.  3500.]]\n"
     ]
    }
   ],
   "source": [
    "K = get_stiffness(k_array)\n",
    "print(K)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the slinky model, the applied forces correspond to the gravitational forces, as such we evaluate:\n",
    "\n",
    "$$f_i = m_i g$$\n",
    "\n",
    "**Check your answers!**  \n",
    "\n",
    "Recall that in this model, we assume that the mass of the slinky $M$ is distributed equally in smaller equal masses $m_i = m$. You need to create the right-hand side, the vector ${\\bf f}$ where each entry is given as $f_i = m_i g$. Define the function `get_force` that takes the scalar value of the mass $m$, the gravitational constant $g$, and the discretization count $N$, then returns the force vector ${\\bf f}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "g = 9.81*10**2 #cm/s^2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "#grade (enter your code in this cell - DO NOT DELETE THIS LINE) \n",
    "def get_force(m,g,N):\n",
    "    # modify the force vector below and return it\n",
    "    force = m*g*np.ones(N)\n",
    "    return force"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you can get the force vector `f` given `m`, `g`, and `N`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[27795. 27795. 27795. 27795. 27795.]\n"
     ]
    }
   ],
   "source": [
    "f = get_force(m,g,N)\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluate the displacement vector"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obtain the response of the mass-spring system by solving the linear system of equations\n",
    "\n",
    "$${\\bf K}{\\bf u} = {\\bf f}$$\n",
    "\n",
    "**Try this!**\n",
    "\n",
    "\n",
    "First, solve the system of equations above by taking the inverse of the stiffness matrix using the ${\\bf K}$ and ${\\bf f}$. You can use [`numpy.linalg.inv`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.inv.html).\n",
    "\n",
    "Store your results in the variable `u`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define u below\n",
    "u = f * np.linalg.inv(K)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Try this!**\n",
    "\n",
    "\n",
    "Solve the same system of linear equations using [`numpy.linalg.solve`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.solve.html).\n",
    "This function will take ${\\bf K}$ and ${\\bf f}$ and return ${\\bf u}$.  \n",
    "Store your results in the variable `u2`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define u2 below\n",
    "u2 = np.linalg.solve(K,f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`u` and `u2` are the same! We will soon talk more about how to \"break apart\" what is happening inside `solve`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vizualizing the deformation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"two_springs.png\" width=300>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will create a numpy array `coord` with the position of each mass (the point that connects each spring of length $l$).  The position of the first mass is $0$ and the position of the last mass is $L$. The 1d numpy array `coord` has length `N+1`. The position $0$ corresponds to the mass $m_0$, which is the location where the system is getting constrained (held in place)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.,  2.,  4.,  6.,  8., 10.])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coord = np.array([l*i for i in range(N+1)])\n",
    "coord"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall that the displacement $u$ obtained above corresponded to the movement of each mass. Check the shape of the array `coord` and the array `u`. What do you notice?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(6,) (5, 5)\n"
     ]
    }
   ],
   "source": [
    "print(coord.shape, u.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Try this!**\n",
    "\n",
    "\n",
    "Hmm... What do you think you need to do next?  How can you include the initial condition at the wall? Create a numpy array `utotal` with the displacement of all the masses, that has the same shape of `coord`.  \n",
    "Hint: you can use [`np.append(var, array)`](https://numpy.org/doc/stable/reference/generated/numpy.append.html) to add a single `var` at the beginning of `array`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define utotal below\n",
    "utotal = np.append()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, you can get the deformed position (coordinate) of the masses at the equilibrium (final) configuration using `coord` and `utotal`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def_coord = coord + utotal\n",
    "def_coord"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We provide a helper function to help you vizualize the final configuration of the slinky. You can use the code snippet below once you have created the arrays `coord` and `def_coord`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from helper_functions import draw_slinky\n",
    "plt.figure()\n",
    "plt.axis('equal')\n",
    "draw_slinky(-5, coord, 2)\n",
    "draw_slinky(5, def_coord, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should see in blue the original configuration of the slinky, and in orage the deformed configuration of the slinky!"
   ]
  },
  {
   "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.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}