01_Single_Particle.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "# First Hands-On Session\n",
    "---\n",
    "- Introducing simple tracking libraries\n",
    "- Tracking of a few particles along a beamline\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### First, Let's import standard packages and settings..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import custom tracking functions and useful libraries\n",
    "from pprint import pprint\n",
    "\n",
    "from tracking_library import *\n",
    "\n",
    "# Set up plotting\n",
    "params = {\n",
    "    \"legend.fontsize\": \"x-large\",\n",
    "    \"figure.figsize\": (15, 5),\n",
    "    \"axes.labelsize\": \"x-large\",\n",
    "    \"axes.titlesize\": \"x-large\",\n",
    "    \"xtick.labelsize\": \"x-large\",\n",
    "    \"ytick.labelsize\": \"x-large\",\n",
    "}\n",
    "plt.rcParams.update(params)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## The Physics Basics\n",
    "\n",
    "From [Wolfgan's lecture](https://indico.cern.ch/event/1356988/contributions/5713241/), you learnt about **matrices** and particle trajectories:\n",
    "\n",
    "<p align=\"center\">\n",
    "<img src=./_img_exercises/upload_0c59b4d203ab8bd7b31827ad332baca1.png width=\"60%\">\n",
    "</p>\n",
    "\n",
    "Those matrices are the **building blocks** for our  course. Please, keep them in mind."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "#### Note about variables\n",
    "\n",
    "- In this course, we will concentrate mainly on the **horizontal** (or vertical) dynamics. \n",
    "- The motion of **charged particles** with respect to the \"center\" of a beamline resamples the motion of **optical rays** in optical systems.\n",
    "- If we were to be more formal, charged particles are best described by **Hamiltonian dynamics** using **canonical coordinates**. \n",
    "    - Typical **canonical coordinates** are the horizontal (or vertical) position $x$, and the corresponding horizontal momentum $p_x$ divided by the reference momentum $p_0$, i.e. $PX=p_x/p_0$.\n",
    "    - If we assume that particle trajectories have **small offsets and angles** (say less than a few mm and mrad) with respect to the \"axis\" of long (say a few m-long) beamline under study, then:\n",
    "    \\begin{equation}\n",
    "       PX = \\frac{p_x}{p_0} \\approx \\frac{p_x}{p_s} = \\tan(x') \\approx x'\n",
    "    \\end{equation}\n",
    "    where $p_s$ is the projected momentum along the beamline direction (i.e. coordinate $s$), and $x'$ is the angle of the particle with respect to the $s$.\n",
    "    - Therefore, we assume here that using $(x, x')$ as **position-angle phase-space coordinates** is a **valid approximation**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "#### Note about units\n",
    "\n",
    "- We will use units derived from the \"Système International\" (SI), e.g. lengths in metres and angles in radians. \n",
    "- However, our approximation is valid assuming small transverse positions and angles!\n",
    "    - From [Wolfgan's lecture](https://indico.cern.ch/event/1356988/contributions/5713241/) the dynamics we are studying is linear:\n",
    "\n",
    "        \\begin{equation}\n",
    "        \\vec{x_s} = M \\cdot \\vec{x_0}\n",
    "        \\end{equation}\n",
    "        \n",
    "    - So we can multiply by $1000$ on both side and obtain:\n",
    "    \n",
    "        \\begin{align}\n",
    "        \\vec{x_s} (\\text{in mm,mrad})\n",
    "          &= 1000 \\cdot \\vec{x_s} (\\text{in m,rad}) \\\\\n",
    "          &= 1000 \\cdot M \\cdot \\vec{x_0} (\\text{in m,rad}) \\\\\n",
    "          &=  M \\cdot (1000 \\cdot \\vec{x_0} (\\text{in m,rad})) \\\\\n",
    "          & = M \\cdot \\vec{x_0} (\\text{in mm,mrad})\n",
    "        \\end{align}\n",
    "    \n",
    "- We will therefore assume that **all matrices** will have units in **(m, rad)**, while all **particle coordinates** in **(mm, mrad)**.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### First Guided Exercise\n",
    "\n",
    "Let's build the transfer matrix of a beam line made of a (thin) focusing quadrupole with focal length $f = 2$ m installed in between two drifts of length $L = f = 2$ m.\n",
    "\n",
    "Afterwards, let's transport *one* or *several* particle that starts with an initial offset (e.g. $x_0$ = 0.4 mm), but no initial angle (i.e. $x_0'$ = 0 mrad) through such a system.\n",
    "\n",
    "**Hint**: Recall from [Wolfgan's lecture](https://indico.cern.ch/event/1356988/contributions/5713241/):\n",
    "\n",
    "<p align=\"center\">\n",
    "<img src=./_img_exercises/upload_938d56be287cccab0bd618456f94efc1.png width=\"60%\">\n",
    "</p>\n",
    "\n",
    "**What do we need ?**\n",
    "- Some matrices representing the different elements ...\n",
    "- Some column array representing the coordinates of the given particle ...\n",
    "- Apply some multiplications ...\n",
    "\n",
    "**NOTE: You can implement everything yourself, but for the time being we suggest you using the simple libraries we provide...**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Let's start defining a Drift"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import a custom-made function to create a simple representation of\n",
    "# a Drift of length L : D(L)\n",
    "from tracking_library import D\n",
    "\n",
    "# create a drift of length L=2m\n",
    "L = 2\n",
    "drift = D(L)\n",
    "\n",
    "# Let's look inside to see what was created\n",
    "print('Let\\'s see what this \"drift\" is:')\n",
    "print(drift)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Note:** It is an `array` (with a single element) of `dictionaries` which include a `matrix` and a `length` keys\n",
    "\n",
    "- **What is this `matrix`?!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(drift[0][\"matrix\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Hint:** Recall that a `drift` is represented by a matrix with ones on the diagonal and the length of the drift on the upper right corner:\n",
    "\n",
    "\\begin{equation}\n",
    "D=\\left[\n",
    "\\begin{array}{c}\n",
    "1\\quad L\\\\\n",
    "0\\quad 1\n",
    "\\end{array}\n",
    "\\right]\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Let's continue defining a Quadrupole"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Repeat for a (thin) Quadrupole with focal length f : Q(f)\n",
    "from tracking_library import Q\n",
    "\n",
    "# create a quadrupole of focal length f=L=2m\n",
    "f = 2\n",
    "quadrupole = Q(f)\n",
    "print(quadrupole)\n",
    "print(quadrupole[0][\"matrix\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** Recall that a `thin quadrupole` is represented by a matrix with ones on the diagonal and $-1/f$ on the bottom left corner:\n",
    "\n",
    "\\begin{equation}\n",
    "D=\\left[\n",
    "\\begin{array}{c}\n",
    "1\\quad 0\\\\\n",
    "-1/f\\quad 1\n",
    "\\end{array}\n",
    "\\right]\n",
    "\\end{equation}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Let's now define a particles\n",
    "\n",
    "A single particle is described by a column vector containing its phase-space coordinates ($x$, $x'$):\n",
    "\\begin{equation}\n",
    "\\vec{x} = X = \\left(\n",
    "\\begin{array}{c}\n",
    "x \\\\\n",
    "x'\n",
    "\\end{array}\n",
    "\\right).\n",
    "\\end{equation}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# in Python\n",
    "x = 0.4  # initial position\n",
    "xp = 0.0  # initial angle\n",
    "X_0 = np.array([[x], [xp]])\n",
    "print(f\"Initial particle coordinates:\\n {X_0}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Let's now *track* the particle along our *beamline*\n",
    "\n",
    "Remember that the *final* coordinates of a particle, $\\vec{x_s}$, are given as:\n",
    "\n",
    "\\begin{equation}\n",
    "\\vec{x_s} = M_n \\cdot ... \\cdot M_2 \\cdot M_1 \\cdot \\vec{x_0}\n",
    "\\end{equation}\n",
    "\n",
    "where $\\vec{x_0}$ are the initial coordinates, $M_1$ is the first element/matrix encountered by the particle, followed by $M_2$ ... $M_n$...\n",
    "\n",
    "- First, we **define a beamline** as a sequence of elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's define a beam line as a sequence of elements, e.g.\n",
    "beamline = drift + quadrupole + drift\n",
    "pprint(beamline)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** the `+` operation between `lists` in python results in a `list` containing all elements of the original lists in the provided order, in this case first our quadrupole and then the drift.\n",
    "\n",
    "- Then, import a **custom-made function** that tracks given particle coordinates along a given beamline\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import a custom-made function\n",
    "from tracking_library import transportParticles\n",
    "\n",
    "# track/transport particle coordinates along beamline elements:\n",
    "tracked_data = transportParticles(X_0, beamline)\n",
    "\n",
    "# this returns a dictionary with interesting `keys`\n",
    "print(tracked_data.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The most useful output, for now, is the `x` (or `x'`=`xp`) coordinate of the tracked particle(s) for each longitudinal position `s` along the beamline, which we can easily plot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's make a simple plot\n",
    "plt.plot(tracked_data[\"s\"], tracked_data[\"x\"], \".-\")\n",
    "plt.xlabel(\"s [m]\")\n",
    "plt.ylabel(\"x [mm]\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also repeat this for many particles: the phase-space coordinates of several, say $N$, particles can be conveniently collected in a $2 \\times N$ matrix:\n",
    "\\begin{equation}\n",
    "X = \\left[ \n",
    "    \\left(\n",
    "    \\begin{array}{c}\n",
    "    x \\\\\n",
    "    x'\n",
    "    \\end{array}\n",
    "    \\right)_1\n",
    "    \\left(\n",
    "    \\begin{array}{c}\n",
    "    x \\\\\n",
    "    x'\n",
    "    \\end{array}\n",
    "    \\right)_2\n",
    "    \\left(\n",
    "    \\begin{array}{c}\n",
    "    x \\\\\n",
    "    x'\n",
    "    \\end{array}\n",
    "    \\right)_3\n",
    "    \\cdots\n",
    "    \\left(\n",
    "    \\begin{array}{c}\n",
    "    x \\\\\n",
    "    x'\n",
    "    \\end{array}\n",
    "    \\right)_N\n",
    "\\right]\n",
    "\\end{equation}\n",
    "\n",
    "This is very convenient, as we can then transport all particles through the very same matrix multiplication: \n",
    "\\begin{equation}\n",
    "X_s = M_n \\cdot ... \\cdot M_2 \\cdot M_1 \\cdot X_0\n",
    "\\end{equation}\n",
    "where $X_0$ are the initial coordinates, and $X_s$ the final ones. \n",
    "\n",
    "- **Example:** let's describe $N=5$ particles all with initial angle $x'_0=0$, but different initial $x_0$, e.g. [-2,-1,0,1,2] mm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's define all initial conditions in a matrix:\n",
    "X_0 = np.array([[-2, -1, 0, 1, 2], [0, 0, 0, 0, 0]])\n",
    "print(X_0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Note:** the first `row` contains all `x` coordinates for all particles, while the second `row` contains all `x'` coordinates.\n",
    "\n",
    "- As before, we can use our tools to track all particles along the given beamline:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tracked_data = transportParticles(X_0, beamline)\n",
    "plt.plot(tracked_data[\"s\"], tracked_data[\"x\"], \".-\")\n",
    "plt.xlabel(\"s [m]\")\n",
    "plt.ylabel(\"x [mm]\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also plot all final `x` coordinates as a function of the initial ones...\n",
    "\n",
    "**Python Hint:** Mind that `tracked_data['x']` is **NxM** `numpy` array, where **N** are the number of elements along the beamline + 1 (the initial condition), and **M** are the number of particles being tracked.\n",
    "E.g. \n",
    "\n",
    "**Question:** What is the final position ($x_1$)? Why?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mind that tracked_data['x'][0,:] are the initial (0) `x` coordinate of all particles (:)\n",
    "# and tracked_data['x'][-1,:] are the final (-1) `x` coordinate of all particles (:)\n",
    "plt.plot(tracked_data[\"x\"][0, :], tracked_data[\"x\"][-1, :], \"o-\")\n",
    "plt.xlabel(\"Initial x_0 [mm]\")\n",
    "plt.ylabel(\"Final x_1 [mm]\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2\n",
    "Now is your turn! Try to modify the beamline description: what happens if you modify your beam line such that $f \\ne L$?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SOLUTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3\n",
    "\n",
    "Let's consider again the beamline from [First Guided Exercise](#first-guided-exercise), i.e. a quadrupole in between drifts such that $f=L=2.5$ in this case, however, model the drifts as a series of $L/10$ long drifts.\n",
    "\n",
    "1. Track all particles along the newly defined beamline, note that this allows to have \"more points\" along $s$ to see the trajectory of your particles.\n",
    "2. Verify once more that parallel rays (e.g. $x_0$ = [-2,-1,0,1,2] mm) cross the axis after a distance $L=f$ after the quadrupole, plotting the final $x$ as a function of the initial one for all particles. **Anything strange to observe?**\n",
    "\n",
    "**Python hint**: given our beamline element modelling as a list, you can repeat a single element *N* times, simply by multiplying it by *N*, e.g. to model 5 equal drifts of 3 m each one can simply do `5*D(3)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SOLUTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### From a list of elements - or beamline - to an equivalent single element\n",
    "---\n",
    "\n",
    "A beam line (or a whole ring) is modelled by a series of matrices. Independently of the initial particle coordinates, we can compute a single matrix ($M_{eq.}$) that represents the whole beam line (or ring): \n",
    "\n",
    "\\begin{equation}\n",
    "X_s = M_n \\cdot ... \\cdot M_2 \\cdot M_1 \\cdot X_0 = M_{eq.} \\cdot X_0\n",
    "\\end{equation}\n",
    "\n",
    "Given our choice of beamline structure, i.e. a `list` of **elements**, each modeled by a `dictionary` with some properties, another help function is provided in the `tracking_library` toolbox that does exaly that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import the getEquivalentElement function\n",
    "from tracking_library import getEquivalentElement\n",
    "\n",
    "# Beamline definition, e.g. two drifts of 1.3 and 0.6 m:\n",
    "beamline = D(1.3) + D(0.6)\n",
    "\n",
    "# Compute equivalent element, or \"one-turn-matrix\"\n",
    "equivalent_element = getEquivalentElement(beamline)\n",
    "print(equivalent_element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** Indeed, this corresponds to the matrix of a drift of lenght L=1.3+0.6=1.9 m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 4\n",
    "\n",
    "Compute the equivalent matrix of a beamline made of two consecutive thin quadrupoles with **different focal length ($f_1 = 1$ and $f_2 = 2$)**. \n",
    "\n",
    "- What does the final matrix resamble to?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SOLUTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 5\n",
    "Let's consider again a beamline from previous exercise, i.e. a quadrupole installed in between drifts such that $L=f$ (e.g. L=1.5 m), and modelling the drift as a series of 10 consecutive drifts.\n",
    "\n",
    "Verify once more that parallel rays (e.g. $x_0$ = [-2,-1,0,1,2] mm) cross the axis after a distance $L=f$, comparing the results from simple tracking with `transportParticles` over the whole beamline elements AND over the equivalent matrix obtained **using `getEquivalentElement` function**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SOLUTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 6\n",
    "Recall that the **imaging equation** for a lens is $1/b+1/g=1/f,$ which corresponds to a system of one focusing lens with focal length $f,$ sandwiched between drift spaces with lengths $b$ and $g$.\n",
    "\n",
    "1. Write a beamline description that corresponds to this system, with, for example, $b=3$ m and $g=2$ m.\n",
    "2. Prove that the particles starting with a random angle $x'_0$ and zero position $x$ are focused back to the end of such a system.\n",
    "   \n",
    "   **Hint:** you can create a random ensample of particles with such properties as\n",
    "   \n",
    "   `X = np.array([np.zeros(n_particles),np.random.randn(n_particles)])`\n",
    "\n",
    "   where `n_particles` is the numbers of particles you want to generate.\n",
    "\n",
    "4. (Optional) Try to change the position of the quadrupole, i.e. $b$, while keeping fixed the total length of the imaging system (i.e. $b+g=5$ m). Plot both position and angle trajectory for one particle with $x=0$ and $x'_0=1$ mrad for different values of $b$, and show that, with an approriate change of $f$, this particle is always focused back to $x=0$ at the end of system, but what happens to the angle?\n",
    "\n",
    "   **Hint:** for this exercise it is useful to make a small animation with the `interactive` package. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SOLUTION 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SOLUTION 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SOLUTION 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 7\n",
    "\n",
    "Your time to explore...\n",
    "1. Build a more complex beamline made of several (be reasonable) quadrupoles with different focal lengths (possibly, alternating positive and negative *f*) and drifts (possibly, split them in many short drifts). \n",
    "2. Track a bunch of *N* particles (be reasonable on *N*...) with initial random coordinates (say, 2 mm, 3 mrad rms), and plot all their *x* trajectory along *s*\n",
    "\n",
    "**Note:** Try to keep the particles oscillation amplitude \"small\" varying the strength/focal length of your quadrupoles.\n",
    "\n",
    "**Python hint:** Remember that you can repeat one element *but also a full portion of beamline* simply with the * operation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SOLUTION 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SOLUTION 2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Well done ! Now you have the basic ingredients !\n",
    "\n",
    "- Now you understand how to transport an ensamble of particles or its **covariance** matrix along a beamline... But how to design a \"nice\" beamline?\n",
    "\n",
    "=> **Continue your learning with the following [notebook](./02_Multi_Particles.ipynb)**...\n",
    "\n",
    "**Note:** If you have time and wish to, consider also looking at the optional exercises.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.12.5"
  },
  "vscode": {
   "interpreter": {
    "hash": "fbec5cc8bb1f13e0584b60d171916a07df7bc30ce2ee62338372c9d5be648ecd"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}