DS_2023/S2_DS1_python_notebook_fr_teacher.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/lionelalexandre/4TPU271/blob/main/S2_TD1_python_notebook_en_teacher.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nv0Y9pmYeuWZ"
   },
   "source": [
    "# <span style=\"color:blue\"> <center>Teacher / DS : 4TPU271 & 4TPU279U $-$ Licence 1ère année $-$ printemps 2023</center></span>\n",
    "# <center>Méthodes Numériques pour les Sciences</center>\n",
    "# <hr style=\"border:1px solid black\"><center>DS1 : Introduction à la programmation Python </center><hr style=\"border:1px solid black\">\n",
    "</br>\n",
    "\n",
    "<span style=\"color:red\"> A la fin de l'épreuve, déposer ce fichier **notebook** complété ou un fichier **python** édité via Spyder, sur la page\n",
    "[Moodle](https://moodle1.u-bordeaux.fr/course/view.php?id=12271) consacrée à votre demi-groupe. </span>\n",
    "\n",
    "\n",
    "<span style=\"color:red\"> Renommer votre fichier suivant le protocole  </span>: \n",
    "- `DST_NomPrenom_S2.ipynb` pour un fichier *jupyter-notebook*\n",
    "\n",
    "ou \n",
    "\n",
    "- `DST_NomPrenom_S2.py` pour un fichier *python* pur\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>ATTENTION :</b> Abolir totalement l’emploi des espaces, lettres accentuées et autres symboles\n",
    "dans le nom du fichier !\n",
    "</div>\n",
    "\n",
    "**Les points suivants seront pris en compte pour l'évaluation :**\n",
    "- respect des consignes\n",
    "- mise en forme des figures (légendes, unités, titre etc...)\n",
    "- clarté des programmes et mise en page\n",
    "\n",
    "</br>\n",
    "<div style=\"text-align: right\"> Credits: R. Boisgard, L. Truflandier, Philippe Paillou, Julien Burgin, Sara Zein, Leo Delmarre, Simon Villain-Guillot, Louise Marinho </div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <hr style=\"border:1px solid black\"> Exercice 1 : potentiel de Morse et représentation graphique <hr style=\"border:1px solid black\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On souhaite étudier le potentiel de Morse de la molécule de Cl$_2$ décrivant la variation d'énergie potentielle en fonction de la distance $x$ entre les 2 atomes de Chlore. Son expression est donnée par :\n",
    "\n",
    "$$ V(x) = D_e \\left( 1 - e^{-\\beta (x-x_{e})}\\right)^2 - D_e$$\n",
    "\n",
    "On remarquera :\n",
    "- $\\lim_{x\\rightarrow\\infty}V(x) = 0 $.\n",
    "- $\\frac {d V(x)}{dx} = 0$ pour $x = x_e$ ; $x_e$ correspond à la distance d'équilibre des 2 atomes.\n",
    "- $V(x_e)=-D_e$ ; l'énergie potentielle est minimale en $x = x_e$ et vaut moins l'énergie de dissociation $D_e$.\n",
    "\n",
    "Pour Cl$_2$ on donne : $D_e = 2.514$ eV, $x_e=2.0$ Å et $\\beta=2.0$ Å$^{-1}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Représenter graphiquement le potentiel de Morse. Respecter les consignes suivantes pour le tracé :\n",
    "    - En utilisant la fonction `linspace`, représenter $V$ en fonction de $x$ pour $x\\in[1.4,5.0]$ avec 256 point de discrétisation.\n",
    "    - Légender les axes avec les unités.\n",
    "    - Faire apparaître un axe horizontal en pointillé noir correspondant au zéro d'énergie potentielle.\n",
    "    - Localiser $x_e$ par un cercle noir sur la courbe.\n",
    "    - Le domaine du tracé sera borné : suivant l'axe des absisses de 1.4 à 5.0, et de -2.7 à 2.7\n",
    "    suivant l'axe des ordonnées. Utiliser les fonctions `xlim` et `ylim` comme proposé ci-dessous."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Limites suivant x pour le tracé \n",
    "#plt.xlim( 1.4,5.0)\n",
    "\n",
    "# Limites suivant y pour le tracé \n",
    "#plt.ylim(-2.7,2.7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:red\">**solution :**</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import exp, linspace\n",
    "from scipy.constants import e, Avogadro\n",
    "\n",
    "# Rq: l'utilisation d'une fonction pour le potentiel de Morse n'est pas obligatoire\n",
    "def pot_morse(x,De,beta,xe):\n",
    "    return De*(1 - exp(-beta*(x-xe)))**2 - De\n",
    "\n",
    "De   = 2.514 # eV\n",
    "beta = 2.00  # Ang^-1\n",
    "xe   = 2.00  # Ang"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x = linspace(1.4,5,256)\n",
    "\n",
    "# Tracé du Potentiel de Morse \n",
    "V = pot_morse(x,De,beta,xe)\n",
    "plt.plot(x,V)\n",
    "\n",
    "# Tracé de l'asymptote horizontale\n",
    "De_plot = linspace(0,0,256)\n",
    "plt.plot(x,De_plot,color='black',linestyle=':')\n",
    "\n",
    "# Localisation de la distance d'équilibre\n",
    "plt.plot(xe,-De,marker='o',linestyle='',color='black',label='$x_e$')\n",
    "\n",
    "plt.xlabel('$x$ in Ang.')\n",
    "plt.ylabel('$V(x)$ in eV')\n",
    "\n",
    "plt.xlim( 1.4,5.0)\n",
    "plt.ylim(-2.7,2.7)\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour des faibles variations de $x$ au voisinage de $x_e$, on peut assimiler le potentiel de Morse comme\n",
    "l'énergie potentielle d'un oscillateur harmonique. Le développement au deuxième ordre de Taylor de $V(x)$ au voisinage the $x_e$ permet d'approximer $V(x)$ par :\n",
    "\n",
    "$$ V_\\text{harm}(x) = \\beta^2 D_e(x-x_e)^2 -D_e$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Reprendre le graphique précédent et ajouter le potentiel harmonique $V_\\text{harm}(x)$. Faire afficher la légende de chaque graphique. Ne pas oublier de borner la représentation comme dans la question précédente. Légender les courbes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:red\">**solution :**</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x = linspace(1.4,5,256)\n",
    "V = pot_morse(x,De,beta,xe)\n",
    "\n",
    "plt.plot(x,V,label='$V$')\n",
    "plt.xlabel('$x$ in Ang.')\n",
    "plt.ylabel('$V(x)$ in eV')\n",
    "\n",
    "V_harm = beta**2*De*(x - xe)**2 -De\n",
    "plt.plot(x,V_harm,label='$V_\\mathrm{harm}$')\n",
    "\n",
    "De_plot = linspace(0,0,256)\n",
    "plt.plot(x,De_plot,color='black',linestyle=':')\n",
    "plt.plot(xe,-De,marker='o',linestyle='',color='black',label='$x_e$')\n",
    "\n",
    "plt.xlim(1.4,5.0)\n",
    "plt.ylim(-2.7,2.7)\n",
    "plt.legend()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Représenter l'écart $V(x) - V_\\text{harm}(x)$ sur un nouveau graphique pour $x\\in[1.95,2.05]$. Légender les axes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:red\">**solution :**</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x = linspace(1.95,2.05,256)\n",
    "V = pot_morse(x,De,beta,xe)\n",
    "V_harm = beta**2*De*(x - xe)**2 - De\n",
    "\n",
    "plt.plot(x,V-V_harm)\n",
    "plt.xlabel('$x$ in Ang.')\n",
    "plt.ylabel('$V(x)-V_\\mathrm{harm}(x)$ in eV')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "O8OHxE2reuW6"
   },
   "source": [
    "<hr style=\"border:1px solid grey\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <hr style=\"border:1px solid black\"> Exercice 2 : résolution numérique des équations de la dynamique <hr style=\"border:1px solid black\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> On souhaite étudier le mouvement d'un des atomes de chlore soumis à la force dérivant du potentiel harmonique $V_\\text{harm}(x)$ tel que : $$\\vec{f}=-\\frac{dV_\\text{harm}}{dx}\\:\\vec{e}_x=-k(x-x_e)\\:\\vec{e}_x \\quad\\quad\\text{(1)}$$\n",
    "avec $k=2\\beta^2D_e$ la constante de force de la liaison Cl$-$Cl. Pour l'intégration numérique des équations du mouvement, on utilisera la méthode de Hooke-Newton décrite ci-dessous :\n",
    "$$\\begin{align}\n",
    "x(t_{i+1}) &= x(t_i) + h\\;v(t_i) \\quad\\quad\\quad\\quad\\ \\ \\text{(2)}\\\\   \n",
    "v(t_{i+1}) &= v(t_i)+\\frac{h}m f\\left(x(t_{i+1})\\right)\\quad\\quad\\text{(3)} \\\\ \n",
    "\\end{align}$$\n",
    "avec $m=35.5$ g/mol, la masse de l'atome Cl et $h$ le pas de temps en unité de temps réduite (utr ; 1 utr $\\simeq 10^{-14}$ s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. A partir des constantes $\\beta$ et $D_e$ données précédemment, calculer la valeur $k$ en eV$\\cdot$Å$^{-2}$ et N$\\cdot$m$^{-1}$.\n",
    "Pour les conversions, on utilisera les constantes physiques de la librarie `scipy.constants`. Par la suite on prendra $k=20.112$ eV$\\cdot$Å$^{-2}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:red\">**solution :**</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.constants import e\n",
    "\n",
    "De   = 2.514     # eV\n",
    "beta = 2.00      # Ang^-1\n",
    "\n",
    "k = 2*beta**2*De\n",
    "print(' k = %.3f eV.Ang^-2'%k)\n",
    "\n",
    "k = 2*beta**2*De * e * (1e+10)**2\n",
    "print(' k = %.1f N.m^-1'%k)\n",
    "\n",
    "k = 2*beta**2*De"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Utiliser l'algorithme de Hooke-Newton pour simuler le déplacement de l'atome de Cl autour de sa position d'équilibre. Le temps d'étude sera de $t_\\textrm{max}=4\\pi\\sqrt{m/k}=16.695$ utr, avec un pas de discrétisation $h=0.01$. On utilisera les conditions initiales :\n",
    "- $x(t_0)=2.02$ Å \n",
    "- $v(t_0)=0.0$\n",
    "\n",
    "On prendra une masse $m=35.5$ g/mol.\n",
    "\n",
    "***Pour vous guider reprendre les différentes étapes du TD4 données ci-dessous :***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> On commence par définir la force, cf. **équation (1)**, *via* une fonction `f`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    xe = 2.0\n",
    "    k  = 2*beta**2*De\n",
    "    return - k*(x - xe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> On initialise $m$ et on discrétise l'axe du temps :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import pi, arange, zeros, cos, sqrt\n",
    "\n",
    "m = 35.5\n",
    "\n",
    "tmin = 0.0\n",
    "tmax = 2*pi*sqrt(m/k)*2\n",
    "print('tmax = ', tmax)\n",
    "\n",
    "h    = 0.01\n",
    "t    = arange(tmin,tmax,h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> On initialise les tableaux pour $x$ et $v$ ainsi que les conditions initiales :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = zeros(len(t))\n",
    "v = zeros(len(t))\n",
    "\n",
    "x0 = 2.02\n",
    "v0 = 0.00"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> On applique la relation de récurrence de Hooke-Newton à $x$ et à $v$ :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[0] = x0\n",
    "v[0] = v0\n",
    "for i in range(len(t)-1):\n",
    "    x[i+1] = x[i] + h*v[i]\n",
    "    v[i+1] = v[i] + h*f(x[i+1])/m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Sauvegarder la position $x$ et la vitesse $v$ dans 2 tableaux `x_harm` et `v_harm` pour une utilisation ultérieure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_harm = x\n",
    "v_harm = v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Tracer des lois horaires $x(t)$ et $v(t)$ sur 2 figures différentes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pylab as plt\n",
    "\n",
    "plt.plot(t,x,marker='')\n",
    "plt.xlabel('$t$ (in utr)')\n",
    "plt.ylabel('$x(t)$ (in Ang)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(t,v,marker='')\n",
    "plt.xlabel('$t$ (in utr)')\n",
    "plt.ylabel('$v(t)$ (in Ang)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Tracer du portrait de phase $(x(t),v(t))$ et repérage des conditions initiales :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(x,v,marker='')\n",
    "plt.plot(x0,v0,marker='o')\n",
    "plt.xlabel('$x(t)$')\n",
    "plt.ylabel('$v(t)$')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Reprendre la résolution des équations de la dynamique pour une force dérivant du potentiel de Morse. L'expression est donnée ci-dessous :\n",
    "$$\\vec{f}=-\\frac{dV}{dx}\\:\\vec{e}_x=-2\\beta D_e\\left( e^{-\\beta (x-x_e)} - e^{-2\\beta (x-xe)} \\right) \\:\\vec{e}_x \\quad\\quad\\text{(4)}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> On commence par définir la force, cf. **équation (4)**, *via* une fonction `f`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import exp\n",
    "\n",
    "def f(x):\n",
    "    xe   =  2.0\n",
    "    beta =  2.0\n",
    "    De   = 2.514 \n",
    "    return - 2*beta*De*( exp(-beta*(x-xe)) - exp(-2*beta*(x-xe)) ) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> On initialise $m$ et on discrétise l'axe du temps :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import pi, arange, zeros, cos, sqrt\n",
    "\n",
    "m = 35.5\n",
    "\n",
    "tmin = 0.0\n",
    "tmax = 2*pi*sqrt(m/k)*2\n",
    "print('tmax = ', tmax)\n",
    "\n",
    "h    = 0.01\n",
    "t    = arange(tmin,tmax,h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> On initialise les tableaux pour $x$ et $v$ ainsi que les conditions initiales :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = zeros(len(t))\n",
    "v = zeros(len(t))\n",
    "\n",
    "x0 = 2.02\n",
    "v0 = 0.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> On applique la relation de récurrence de Hooke-Newton à $x$ et à $v$ :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[0] = x0\n",
    "v[0] = v0\n",
    "for i in range(len(t)-1):\n",
    "    x[i+1] = x[i] + h*v[i]\n",
    "    v[i+1] = v[i] + h*f(x[i+1])/m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Sauvegarder la position $x$ et la vitesse $v$ dans 2 tableaux `x_morse` et `v_morse`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_morse = x\n",
    "v_morse = v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Sur un même graphique tracer des lois horaires $v_\\text{harm}(t)$ et $v_\\text{morse}(t)$ ; sur un autre graphique tracer $x_\\text{harm}(t)$ et $x_\\text{morse}(t)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pylab as plt\n",
    "\n",
    "plt.plot(t,x_morse,marker='',label='Morse potential')\n",
    "plt.plot(t,x_harm,marker='', label='Harmonic potential')\n",
    "\n",
    "plt.xlabel('$t$ (in utr)')\n",
    "plt.ylabel('$x(t)$ (in Ang)')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(t,v_harm,marker='', label='Harmonic potential')\n",
    "plt.plot(t,v_morse,marker='',label='Morse potential')\n",
    "\n",
    "plt.xlabel('$t$ (in utr)')\n",
    "plt.ylabel('$v(t)$ (in Ang)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Tracer des portraits de phase $(x_\\text{morse}(t)v_\\text{morse}(t))$ et $(x_\\text{harm}(t)v_\\text{harm}(t))$ et repérer des conditions initiales :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(x_morse,v_morse,marker='',label='Morse')\n",
    "plt.plot(x_harm,v_harm,  marker='',label='Harmonic')\n",
    "\n",
    "plt.plot(x0,v0,marker='o',linestyle='',label='initial conditions')\n",
    "plt.xlabel('$x(t)$')\n",
    "plt.ylabel('$v(t)$')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Reprendre les questions 2. et 3. avec les conditions initiales :\n",
    "- $x(t_0)=2.2$ Å \n",
    "- $v(t_0)=0$ Å/utr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <hr style=\"border:1px solid black\"> Exercice bonus : double factoriel (pair) <hr style=\"border:1px solid black\">\n",
    "\n",
    "Pour un entier $n$ **pair**, le double factoriel, $n!!$, est donné par :\n",
    "\n",
    "$$\\sum^{\\frac{n}{2}}_{k=1}(2k)=2\\times4\\times\\cdots(n-4)(n-2)n$$\n",
    "\n",
    "Ecrire un programme permettant le calcul de $n!!$. Tester votre programme avec $n=12$ et comparer au résultat\n",
    "obtenu avec la fonction `factorial2()` de la librairie `scipy`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:red\">**solution :**</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.special import factorial2\n",
    "\n",
    "n = 20\n",
    "\n",
    "fact2 = 1\n",
    "for k in range(1,int(n/2)+1):\n",
    "    fact2 = fact2*2*k\n",
    "\n",
    "print(fact2)\n",
    "print(factorial2(n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Diaporama",
  "colab": {
   "include_colab_link": true,
   "provenance": []
  },
  "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}