Rigid_Body_Rotation_Euler_Eqn.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ddca6dae",
   "metadata": {},
   "source": [
    "## Example 1. Rigid Body Rotation: Euler's Equations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d9dd329",
   "metadata": {},
   "source": [
    "This notebook solves the Euler equations by different RK methods and their relaxation versions:\n",
    "\\begin{align}\n",
    "    \\dot{u}_{1}=(\\alpha - \\beta)u_2u_3 \\\\\n",
    "    \\dot{u}_{2}=(1-\\alpha)u_3u_1 \\\\\n",
    "    \\dot{u}_{3}=(\\beta-1)u_1u_2\\;,\n",
    "\\end{align}\n",
    "with $\\left(u_1(0),u_2(0),u_3(0)\\right)^T = (0,1,1)^T$, $\\alpha = 1 + \\frac{1}{\\sqrt{1.51}}$, and $\\beta = 1 - \\frac{0.51}{\\sqrt{1.51}}$. The exact solution is\n",
    "    \\begin{align}\n",
    "        \\left(u_1(t),u_2(t),u_3(t)\\right)^T = \\left(\\sqrt{1.51} \\  \\textrm{sn}(t,0.51),\\textrm{cn}(t,0.51),\\textrm{dn}(t,0.51)\\right)^T \\;,\n",
    "    \\end{align}\n",
    "    where $\\textrm{sn},\\ \\textrm{cn},\\ \\text{and}, \\ \\textrm{dn}$ are the elliptic Jacobi functions. This problem has two quadratic conserved quantities:\n",
    "\\begin{align}\n",
    "    & G_1(u_{1},u_{2},u_{3}) = u_{1}^{2}+ u_{2}^{2}+u_{3}^{2}\\\\\n",
    "    & G_2(u_{1},u_{2},u_{3}) = u_{1}^{2}+ \\beta u_{2}^{2}+\\alpha u_{3}^{2} \\;.\n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5225cb73",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Required libraries \n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.optimize import fsolve\n",
    "from nodepy import rk\n",
    "from IPython.display import clear_output\n",
    "from RKSchemes import ssp22, heun33, ssp33, rk44, fehlberg45, dp75"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87e6cbdd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Required functions for Euler's equation\n",
    "def EulerEqs_f(u):\n",
    "    u1 = u[0]; u2 = u[1]; u3 = u[2];\n",
    "    alpha = 1 + 1/np.sqrt(1.51); beta = 1 - 0.51/np.sqrt(1.51)\n",
    "    du1 = (alpha - beta)*u2*u3\n",
    "    du2 = (1 - alpha)*u3*u1\n",
    "    du3 = (beta - 1)*u1*u2\n",
    "    return np.array([du1, du2, du3])\n",
    "\n",
    "def G_1(u):\n",
    "    u1 = u[0]; u2 = u[1]; u3 = u[2];\n",
    "    return u1*u1 + u2*u2 + u3*u3\n",
    "\n",
    "def G_2(u):\n",
    "    u1 = u[0]; u2 = u[1]; u3 = u[2];\n",
    "    alpha = 1 + 1/np.sqrt(1.51); beta = 1 - 0.51/np.sqrt(1.51)\n",
    "    return u1*u1 + beta*u2*u2 + alpha*u3*u3\n",
    "\n",
    "def rgam(gammas,u,inc1,inc2,E1_old,E2_old):\n",
    "    gamma1, gamma2 = gammas\n",
    "    uprop = u + gamma1*inc1 + gamma2*inc2  \n",
    "    E1 = G_1(uprop)\n",
    "    E2 = G_2(uprop)\n",
    "    return np.array([E1-E1_old,E2-E2_old])\n",
    "\n",
    "from scipy import special\n",
    "def EulerEqs_ExactSol(t):\n",
    "    sn, cn, dn, ph = special.ellipj(t, 0.51) \n",
    "    u1 = np.sqrt(1.51)*sn\n",
    "    u2 = cn\n",
    "    u3 = dn\n",
    "    return np.array([u1, u2, u3])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61524358",
   "metadata": {},
   "source": [
    "### Baseline RK methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6db4a42",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute solution with baseline RK methods\n",
    "def compute_sol_without_relaxation(Mthdname,rkm, dt, f, T, u0,t0): \n",
    "    tt = np.zeros(1) \n",
    "    t = t0; tt[0] = t\n",
    "    uu = np.zeros((1,np.size(u0))) \n",
    "    uu[0,:] = u0.copy()\n",
    "    \n",
    "    s = len(rkm)\n",
    "    y = np.zeros((s,len(u0))) \n",
    "    F = np.zeros((s,len(u0))) \n",
    "    steps = 0\n",
    "    \n",
    "    while t < T and not np.isclose(t, T):\n",
    "        clear_output(wait=True)\n",
    "        if t + dt > T:\n",
    "            dt = T - t\n",
    "        for i in range(s):\n",
    "            y[i,:] = uu[-1].copy()\n",
    "            for j in range(i):\n",
    "                y[i,:] += dt*rkm.A[i,j]*F[j,:]\n",
    "            F[i,:] = f(y[i,:])\n",
    "        inc = dt*sum([rkm.b[i]*F[i] for i in range(s)])    \n",
    "        unew = uu[-1]+inc; t+= dt\n",
    "        tt = np.append(tt, t)\n",
    "        steps +=1\n",
    "        uu = np.append(uu, np.reshape(unew.copy(), (1,len(unew))), axis=0)  \n",
    "        print(\"Method = Baseline %s: Step number = %d (time = %1.2f)\"%(Mthdname,steps,tt[-1]))\n",
    "    return tt, uu"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "217f68c8",
   "metadata": {},
   "source": [
    "### Relaxation RK methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad67f742",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Computing solution with multiple relaxation methods\n",
    "def compute_sol_multi_relaxation(Mthdname,rkm, dt, f, T, u0, t0):\n",
    "    tt = np.zeros(1) \n",
    "    t = t0; tt[0] = t\n",
    "    uu = np.zeros((1,np.size(u0))) \n",
    "    uu[0,:] = u0.copy()\n",
    "    \n",
    "    s = len(rkm)\n",
    "    y = np.zeros((s,len(u0))) \n",
    "    F = np.zeros((s,len(u0))) \n",
    "    \n",
    "    G1 = np.array([]); G2 = np.array([])\n",
    "    no_inv = 2; gammas0 = np.zeros(no_inv)\n",
    "    \n",
    "    errs = 0; steps = 0\n",
    "    \n",
    "    while t < T and not np.isclose(t, T):\n",
    "        clear_output(wait=True)\n",
    "        if t + dt > T:\n",
    "            dt = T - t\n",
    "        for i in range(s):\n",
    "            y[i,:] = uu[-1].copy()\n",
    "            for j in range(i):\n",
    "                y[i,:] += dt*rkm.A[i,j]*F[j,:]\n",
    "            F[i,:] = f(y[i,:])\n",
    "            \n",
    "        inc1 = dt*sum([rkm.b[i]*F[i] for i in range(s)])\n",
    "        inc2 = dt*sum([rkm.bhat[i]*F[i] for i in range(s)])\n",
    "        \n",
    "        wr_unew = uu[-1] + inc1; E1_old = G_1(uu[-1]); E2_old = G_2(uu[-1])\n",
    "        \n",
    "        gammas, info, ier, mesg = fsolve(rgam,gammas0,args=(wr_unew,inc1,inc2,E1_old,E2_old),full_output=True)\n",
    "        gamma1, gamma2 = gammas\n",
    "        \n",
    "        unew =  wr_unew + gamma1*inc1 + gamma2*inc2; t+=(1+gamma1+gamma2)*dt\n",
    "        tt = np.append(tt, t)\n",
    "        steps += 1\n",
    "        uu = np.append(uu, np.reshape(unew.copy(), (1,len(unew))), axis=0) \n",
    "        G1 = np.append(G1, gamma1); G2 = np.append(G2, gamma2)\n",
    "        print(\"Method = Relaxation %s: At step number = %d (time = %1.2f), integer flag = %d and γ1+γ2 = %f \\n\"%(Mthdname,steps,tt[-1],ier,gamma1+gamma2))\n",
    "\n",
    "    return tt, uu, G1, G2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "645a7714",
   "metadata": {},
   "source": [
    "### Compute solution by all methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a90f682",
   "metadata": {},
   "outputs": [],
   "source": [
    "%time\n",
    "eqn = 'EE'\n",
    "methods = [heun33,fehlberg45,dp75]\n",
    "method_labels = [\"Heun(3,3)\", \"Fehlberg(6,4)\", \"DP5(7,5)\"]\n",
    "method_names = [\"Heuns3p3\", \"Fehlbergs6p4\", \"DP5s7p5\"]\n",
    "\n",
    "# Inputs to solve the system of ODEs\n",
    "DT = [0.04, .1, .1];  f = EulerEqs_f; T = 1000; \n",
    "\n",
    "# Initial condition\n",
    "t0 = 0; u0 = np.array([0.0, 1.0, 1.0])\n",
    "b_tt = []; b_uu = []; r_tt = []; r_uu = []  # empty list to store data by all the methods\n",
    "    \n",
    "for idx in range(len(methods)):\n",
    "    print(idx)\n",
    "    rkm = methods[idx]; dt = DT[idx]\n",
    "    tt, uu, G1, G2 = compute_sol_multi_relaxation(method_labels[idx], rkm, dt, f, T, u0, t0)\n",
    "    r_tt.append(tt); r_uu.append(uu)\n",
    "    \n",
    "for idx in range(len(methods)):\n",
    "    rkm = methods[idx]; dt = DT[idx]\n",
    "    tt, uu = compute_sol_without_relaxation(method_labels[idx], rkm, dt , f, T, u0, t0)\n",
    "    b_tt.append(tt); b_uu.append(uu)\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e22bd12",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "path = '%s'%('Figures')\n",
    "\n",
    "import os\n",
    "if not os.path.exists(path):\n",
    "   os.makedirs(path)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cdddee65",
   "metadata": {},
   "source": [
    "### Compute and plot changes in invariants by different methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bda66710",
   "metadata": {},
   "outputs": [],
   "source": [
    "b_G_1 = []; b_G_2 = []; r_G_1 = []; r_G_2 = []\n",
    "for i in range(len(methods)):\n",
    "    b_g_1 = [G_1(u) for u in b_uu[i]] - G_1(b_uu[i][0])\n",
    "    b_g_2 = [G_2(u) for u in b_uu[i]] - G_2(b_uu[i][0])\n",
    "    r_g_1 = [G_1(u) for u in r_uu[i]] - G_1(r_uu[i][0])\n",
    "    r_g_2 = [G_2(u) for u in r_uu[i]] - G_2(r_uu[i][0])\n",
    "    b_G_1.append(b_g_1); b_G_2.append(b_g_2)\n",
    "    r_G_1.append(r_g_1); r_G_2.append(r_g_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54b09e19",
   "metadata": {},
   "outputs": [],
   "source": [
    "methods = [heun33,fehlberg45,dp75]\n",
    "method_labels = [\"Heun(3,3)\", \"Fehlberg(6,4)\", \"DP5(7,5)\"]\n",
    "method_names = [\"Heuns3p3\", \"Fehlbergs6p4\", \"DP5s7p5\"]\n",
    "\n",
    "font = {#'family' : 'normal',\n",
    "'weight' : 'normal',\n",
    "'size'   : 14}\n",
    "plt.rc('font', **font) \n",
    "plt.figure(figsize=(15, 4))\n",
    "for i in range(len(methods)):\n",
    "    plt.subplot(1,len(methods),i+1)\n",
    "    plt.plot(b_tt[i],b_G_1[i],':r',label=\"Baseline: $G_1(u_1(t),u_2(t),u_3(t))-G_1(u_1(0),u_2(0),u_3(0))$\")\n",
    "    plt.plot(r_tt[i],r_G_1[i],'-r',label=\"Relaxation: $G_1(u_1(t),u_2(t),u_3(t))-G_1(u_1(0),u_2(0),u_3(0))$\")\n",
    "    plt.plot(b_tt[i],b_G_2[i],':b',label=\"Baseline: $G_2(u_1(t),u_2(t),u_3(t))-G_2(u_1(0),u_2(0),u_3(0))$\")\n",
    "    plt.plot(r_tt[i],r_G_2[i],'-b',label=\"Relaxation: $G_2(u_1(t),u_2(t),u_3(t))-G_2(u_1(0),u_2(0),u_3(0))$\")\n",
    "    plt.title(\"%s with $\\Delta t$ = %.2f\"%(method_labels[i],DT[i]))\n",
    "    plt.xlabel(\"$t$\");\n",
    "    #plt.ylabel(\"$\\eta(u(t)) - \\eta(u^0)$\")\n",
    "    plt.yscale(\"symlog\", linthresh=1.e-14)\n",
    "    plt.yticks([-1.e-6, -1.e-10, -1.e-14, 1.e-14, 1.e-10, 1.e-6])\n",
    "    \n",
    "\n",
    "plt.tight_layout()\n",
    "ax = plt.gca()\n",
    "handles, labels = ax.get_legend_handles_labels()\n",
    "plt.figlegend(handles, labels, loc='upper center', ncol=2, bbox_to_anchor=(0.5, 1.2))\n",
    "#plt.show()\n",
    "plt.savefig(\"./Figures/Rigid_Body_2_Inv_Error_Time.pdf\", bbox_inches=\"tight\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b709a73",
   "metadata": {},
   "source": [
    "### Compute and plot solution errors by different methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "20271dc9",
   "metadata": {},
   "outputs": [],
   "source": [
    "b_ERR = []; r_ERR = []\n",
    "for i in range(len(methods)):\n",
    "    # maximum norm\n",
    "    b_err = [np.max(np.abs(b_uu[i][j] - EulerEqs_ExactSol(b_tt[i][j]))) for j in np.arange(len(b_tt[i]))]\n",
    "    r_err = [np.max(np.abs(r_uu[i][j] - EulerEqs_ExactSol(r_tt[i][j]))) for j in np.arange(len(r_tt[i]))]\n",
    "    b_ERR.append(b_err); r_ERR.append(r_err)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b4c4be96",
   "metadata": {},
   "outputs": [],
   "source": [
    "methods = [heun33,fehlberg45,dp75]\n",
    "method_labels = [\"Heun(3,3)\", \"Fehlberg(6,4)\", \"DP5(7,5)\"]\n",
    "method_names = [\"Heuns3p3\", \"Fehlbergs6p4\", \"DP5s7p5\"]\n",
    "\n",
    "lgd_box_pos = [[0.4,0.2,0.5, 0.5],[0.4,0.1,0.5, 0.5],[0.4,0.5,0.5, 0.5]]\n",
    "sl1_cons_mult = [5e-7,5e-8,3e-9]; sl1_p = [1,1,1]\n",
    "sl2_cons_mult = [8*1e-8,9*1e-10,3*1e-11]; sl2_p = [2,2,2]\n",
    "y_scale_line = [1e-10,1e-8,1e-7]\n",
    "\n",
    "font = {#'family' : 'normal',\n",
    "'weight' : 'normal',\n",
    "'size'   : 14}\n",
    "plt.rc('font', **font)\n",
    "shift = 1\n",
    "plt.figure(figsize=(15, 4))\n",
    "\n",
    "for i in range(len(methods)):\n",
    "    plt.subplot(1,len(methods),i+1)\n",
    "    plt.plot(b_tt[i]+shift,b_ERR[i],':',color='orangered',label=\"Baseline\")\n",
    "    plt.plot(r_tt[i]+shift,r_ERR[i],'-g',label=\"Relaxation\")\n",
    "    sl_t = np.linspace(10,T,1000)\n",
    "\n",
    "    plt.plot(sl_t,sl1_cons_mult[i]*sl_t**sl1_p[i],'--',color='0.5',label=\"$\\mathcal{O}(t^{%d})$\"%(sl1_p[i]))\n",
    "    plt.plot(sl_t,sl2_cons_mult[i]*sl_t**sl2_p[i],'-',color='0.5',label=\"$\\mathcal{O}(t^{%d})$\"%(sl2_p[i]))\n",
    "     \n",
    "    plt.xscale(\"log\"); plt.yscale(\"log\")\n",
    "    plt.xlabel('t'); plt.ylabel('Error in q')\n",
    "    plt.title(\"%s with $\\Delta t$ = %.2f\"%(method_labels[i],DT[i]))\n",
    "    plt.tight_layout()\n",
    "    \n",
    "ax = plt.gca()\n",
    "handles, labels = ax.get_legend_handles_labels()\n",
    "plt.figlegend(handles, labels, loc='upper center', ncol=6, bbox_to_anchor=(0.5, 1.1))\n",
    "#plt.show()\n",
    "plt.savefig(\"./Figures/Rigid_Body_Sol_Err_Time.pdf\", bbox_inches=\"tight\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65a074d3",
   "metadata": {},
   "source": [
    "### Compute errors and plot error convergence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56ac1eab",
   "metadata": {},
   "outputs": [],
   "source": [
    "methods = [ssp22,heun33,rk44,dp75]\n",
    "method_names = [\"ssps2p2\",\"heuns3p3\", \"rks4p4\", \"DP5s7p5\"]\n",
    "dts = 1/2**np.linspace(3,8,10)\n",
    "dts = dts[0:]\n",
    "f = EulerEqs_f; tf = 5\n",
    "# Initial condition\n",
    "t0 = 0; u0 = np.array([0.0, 1.0, 1.0])\n",
    "b_errs = np.zeros((len(methods),len(dts))); r_errs = np.zeros((len(methods),len(dts)))\n",
    "\n",
    "for idx in range(len(methods)):\n",
    "    rkm = methods[idx]\n",
    "    for dt_idx in range(len(dts)):\n",
    "        dt = dts[dt_idx]\n",
    "        b_T, b_U = compute_sol_without_relaxation(method_names[idx], rkm, dt, f, tf, u0, t0)\n",
    "        r_T, r_U, G1, G2 = compute_sol_multi_relaxation(method_names[idx], rkm, dt, f, tf, u0, t0)\n",
    "        \n",
    "        b_error = np.max(np.abs(b_U[-1]-EulerEqs_ExactSol(b_T[-1]))); \n",
    "        r_error = np.max(np.abs(r_U[-1]-EulerEqs_ExactSol(r_T[-1]))); \n",
    "        b_errs[idx][dt_idx]=b_error; r_errs[idx][dt_idx]=r_error; "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10e073e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plotting routine\n",
    "from itertools import cycle\n",
    "lines = [\":\",\"--\",\"-.\",\"-\"]\n",
    "colors = [\"red\", \"blue\", \"green\" ,\"darkviolet\"]\n",
    "method_labels = [\"SSPRK(2,2)\",\"Heun(3,3)\", \"RK(4,4)\", \"DP(7,5)\"]\n",
    "\n",
    "# Font size \n",
    "font = {'family' : 'normal',\n",
    "        'weight' : 'normal',\n",
    "        'size'   : 12}\n",
    "plt.rc('font', **font) \n",
    "\n",
    "fig = plt.figure(1)\n",
    "for idx in range(len(methods)):\n",
    "    plt.plot(dts,b_errs[idx],color = colors[idx],linestyle=lines[idx],label = method_labels[idx])\n",
    "    \n",
    "plt.plot(dts, 1.5e-0*dts**2, \"-.\", color=\"gray\")\n",
    "plt.annotate(r\"$\\mathcal{O}(t^2)$\", (2.0e-2, 1.0e-3), color=\"gray\")\n",
    "plt.plot(dts, .5e-0*dts**3, \"-P\", color=\"gray\")\n",
    "plt.annotate(r\"$\\mathcal{O}(t^3)$\", (2.0e-2, 1.2e-5), color=\"gray\")\n",
    "plt.plot(dts, 1e-1*dts**4, \"--s\", color=\"gray\")\n",
    "plt.annotate(r\"$\\mathcal{O}(t^4)$\", (2.0e-2, 8.0e-8), color=\"gray\")\n",
    "plt.plot(dts[:8], .5e-2*dts[:8]**5, \":o\", color=\"gray\")\n",
    "plt.annotate(r\"$\\mathcal{O}(t^5)$\", (2.0e-2, 1.0e-10), color=\"gray\")\n",
    "plt.xscale(\"log\"); plt.yscale(\"log\"); plt.xlabel(\"$\\Delta t$\"); plt.ylabel('Error')\n",
    "fig.tight_layout()\n",
    "plt.savefig('./Figures/%s_Baseline_Mthds_ErrorConv_tf%d.pdf'%(eqn,tf),format='pdf', bbox_inches=\"tight\")\n",
    "\n",
    "fig = plt.figure(2)\n",
    "for idx in range(len(methods)):\n",
    "    plt.plot(dts,r_errs[idx],color = colors[idx],linestyle=lines[idx],label = method_labels[idx])\n",
    "\n",
    "plt.plot(dts, 1.5e-0*dts**2, \"-.\", color=\"gray\")\n",
    "plt.annotate(r\"$\\mathcal{O}(t^2)$\", (2.0e-2, 2.0e-3), color=\"gray\")\n",
    "plt.plot(dts, 2.0e-1*dts**3, \"-P\", color=\"gray\")\n",
    "plt.annotate(r\"$\\mathcal{O}(t^3)$\", (2.0e-2, 1.0e-5), color=\"gray\")\n",
    "plt.plot(dts, 1.5e-1*dts**4, \"--s\", color=\"gray\")\n",
    "plt.annotate(r\"$\\mathcal{O}(t^4)$\", (2.0e-2, 8.0e-8), color=\"gray\")\n",
    "plt.plot(dts[:8], 1e-2*dts[:8]**5, \":o\", color=\"gray\")\n",
    "plt.annotate(r\"$\\mathcal{O}(t^5)$\", (2.0e-2, 1.0e-10), color=\"gray\")\n",
    "plt.xscale(\"log\"); plt.yscale(\"log\"); plt.xlabel(\"$\\Delta t$\"); plt.ylabel('Error')\n",
    "fig.tight_layout()\n",
    "plt.savefig('./Figures/%s_Relaxation_Mthds_ErrorConv_tf%d.pdf'%(eqn,tf),format='pdf', bbox_inches=\"tight\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3fa2ad5e",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}