Spark_Physics/ATLAS_Higgs_opendata/H_ZZ_4l_analysis_basic_experiment_data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c97f8c4d",
   "metadata": {},
   "source": [
    "# Higgs Boson Analysis with ATLAS Open Data\n",
    "This is an example analysis of the Higgs boson detection via the decay channel H &rarr; ZZ* &rarr; 4l  \n",
    "From the decay products measured at the ATLAS experiment and provided as open data, you will be able to produce a histogram, and from there you can infer the invariant mass of the Higgs boson.  \n",
    "Code: it is based on the original work at [ATLAS outreach notebooks](https://github.com/atlas-outreach-data-tools/notebooks-collection-opendata/tree/master/13-TeV-examples/uproot_python)  \n",
    "Data: from the 13TeV [ATLAS opendata](http://opendata.atlas.cern/release/2020/documentation/datasets/files.html)  \n",
    "Physics: See ATLAS paper on the [discovery of the Higgs boson](https://www.sciencedirect.com/science/article/pii/S037026931200857X) (mostly Section 4 and 4.1) \n",
    "\n",
    "See also: https://github.com/LucaCanali/Miscellaneous/tree/master/Spark_Physics\n",
    "\n",
    "Author and contact: Luca.Canali@cern.ch  \n",
    "March, 2022"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22d54a3d",
   "metadata": {},
   "source": [
    "## H &rarr; ZZ* &rarr; 4l analsys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "38800879",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run this if you need to install Apache Spark (PySpark)\n",
    "\n",
    "# !pip install pyspark\n",
    "\n",
    "# Install sparkhistogram\n",
    "# Note: if you cannot install the package, create the computeHistogram\n",
    "# function as detailed at the end of this notebook.\n",
    "\n",
    "!pip install sparkhistogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a6d1374",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run this to download the dataset \n",
    "# It is a small file (200 KB), this exercise is meant mostly to show the Spark API\n",
    "# See further details at https://github.com/LucaCanali/Miscellaneous/tree/master/Spark_Physics\n",
    "\n",
    "!wget https://sparkdltrigger.web.cern.ch/sparkdltrigger/ATLAS_Higgs_opendata/Data_4lep.parquet\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "bee0e073",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Setting default log level to \"WARN\".\n",
      "To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).\n",
      "24/05/07 22:53:29 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable\n"
     ]
    }
   ],
   "source": [
    "# Start the Spark Session\n",
    "# This uses local mode for simplicity\n",
    "\n",
    "# the use of findspark is optional\n",
    "# import findspark\n",
    "# findspark.init(\"/home/luca/Spark/spark-3.5.1-bin-hadoop3\")\n",
    "\n",
    "from pyspark.sql import SparkSession\n",
    "spark = (SparkSession.builder\n",
    "         .appName(\"H_ZZ_4Lep\")\n",
    "         .master(\"local[*]\")\n",
    "         .getOrCreate()\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ab108ade",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root\n",
      " |-- runNumber: integer (nullable = true)\n",
      " |-- eventNumber: integer (nullable = true)\n",
      " |-- channelNumber: integer (nullable = true)\n",
      " |-- mcWeight: float (nullable = true)\n",
      " |-- scaleFactor_PILEUP: float (nullable = true)\n",
      " |-- scaleFactor_ELE: float (nullable = true)\n",
      " |-- scaleFactor_MUON: float (nullable = true)\n",
      " |-- scaleFactor_PHOTON: float (nullable = true)\n",
      " |-- scaleFactor_TAU: float (nullable = true)\n",
      " |-- scaleFactor_BTAG: float (nullable = true)\n",
      " |-- scaleFactor_LepTRIGGER: float (nullable = true)\n",
      " |-- scaleFactor_PhotonTRIGGER: float (nullable = true)\n",
      " |-- trigE: boolean (nullable = true)\n",
      " |-- trigM: boolean (nullable = true)\n",
      " |-- trigP: boolean (nullable = true)\n",
      " |-- lep_n: long (nullable = true)\n",
      " |-- lep_truthMatched: array (nullable = true)\n",
      " |    |-- element: boolean (containsNull = true)\n",
      " |-- lep_trigMatched: array (nullable = true)\n",
      " |    |-- element: boolean (containsNull = true)\n",
      " |-- lep_pt: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- lep_eta: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- lep_phi: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- lep_E: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- lep_z0: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- lep_charge: array (nullable = true)\n",
      " |    |-- element: integer (containsNull = true)\n",
      " |-- lep_type: array (nullable = true)\n",
      " |    |-- element: long (containsNull = true)\n",
      " |-- lep_isTightID: array (nullable = true)\n",
      " |    |-- element: boolean (containsNull = true)\n",
      " |-- lep_ptcone30: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- lep_etcone20: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- lep_trackd0pvunbiased: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- lep_tracksigd0pvunbiased: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- met_et: float (nullable = true)\n",
      " |-- met_phi: float (nullable = true)\n",
      " |-- jet_n: long (nullable = true)\n",
      " |-- jet_pt: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- jet_eta: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- jet_phi: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- jet_E: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- jet_jvt: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- jet_trueflav: array (nullable = true)\n",
      " |    |-- element: integer (containsNull = true)\n",
      " |-- jet_truthMatched: array (nullable = true)\n",
      " |    |-- element: boolean (containsNull = true)\n",
      " |-- jet_MV2c10: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- photon_n: long (nullable = true)\n",
      " |-- photon_truthMatched: array (nullable = true)\n",
      " |    |-- element: boolean (containsNull = true)\n",
      " |-- photon_trigMatched: array (nullable = true)\n",
      " |    |-- element: boolean (containsNull = true)\n",
      " |-- photon_pt: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- photon_eta: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- photon_phi: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- photon_E: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- photon_isTightID: array (nullable = true)\n",
      " |    |-- element: boolean (containsNull = true)\n",
      " |-- photon_ptcone30: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- photon_etcone20: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- photon_convType: array (nullable = true)\n",
      " |    |-- element: integer (containsNull = true)\n",
      " |-- tau_n: long (nullable = true)\n",
      " |-- tau_pt: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- tau_eta: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- tau_phi: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- tau_E: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- tau_isTightID: array (nullable = true)\n",
      " |    |-- element: boolean (containsNull = true)\n",
      " |-- tau_truthMatched: array (nullable = true)\n",
      " |    |-- element: boolean (containsNull = true)\n",
      " |-- tau_trigMatched: array (nullable = true)\n",
      " |    |-- element: boolean (containsNull = true)\n",
      " |-- tau_nTracks: array (nullable = true)\n",
      " |    |-- element: integer (containsNull = true)\n",
      " |-- tau_BDTid: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- ditau_m: float (nullable = true)\n",
      " |-- lep_pt_syst: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- met_et_syst: float (nullable = true)\n",
      " |-- jet_pt_syst: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- photon_pt_syst: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- tau_pt_syst: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- XSection: float (nullable = true)\n",
      " |-- SumWeights: float (nullable = true)\n",
      " |-- largeRjet_n: long (nullable = true)\n",
      " |-- largeRjet_pt: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- largeRjet_eta: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- largeRjet_phi: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- largeRjet_E: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- largeRjet_m: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- largeRjet_truthMatched: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- largeRjet_D2: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- largeRjet_tau32: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- largeRjet_pt_syst: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- tau_charge: array (nullable = true)\n",
      " |    |-- element: integer (containsNull = true)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Read data with the candidate events\n",
    "df_events = spark.read.parquet(\"Data_4lep.parquet\")\n",
    "\n",
    "df_events.printSchema()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6790882f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of events: 832\n"
     ]
    }
   ],
   "source": [
    "# Count the number of events before cuts (filter)\n",
    "print(f\"Number of events: {df_events.count()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c369ad6",
   "metadata": {},
   "source": [
    "### Apply basic cuts\n",
    "More details on the cuts (filters applied to the event data) in the reference ATLAS paper on the [discovery of the Higgs boson](https://www.sciencedirect.com/science/article/pii/S037026931200857X) (mostly Section 4 and 4.1) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e481cb25",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of events after applying cuts: 507\n"
     ]
    }
   ],
   "source": [
    "# Apply filters to the input data\n",
    "# only events with 4 leptons in the input data\n",
    "\n",
    "# cut on lepton charge\n",
    "# paper: \"selecting two pairs of isolated leptons, each of which is comprised of two leptons with the same flavour and opposite charge\"\n",
    "df_events = df_events.filter(\"lep_charge[0] + lep_charge[1] + lep_charge[2] + lep_charge[3] == 0\")\n",
    "\n",
    "# cut on lepton type\n",
    "# paper: \"selecting two pairs of isolated leptons, each of which is comprised of two leptons with the same flavour and opposite charge\"\n",
    "df_events = df_events.filter(\"lep_type[0] + lep_type[1] + lep_type[2] + lep_type[3] in (44, 48, 52)\")\n",
    "\n",
    "print(f\"Number of events after applying cuts: {df_events.count()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71d0e2de",
   "metadata": {},
   "source": [
    "### Compute the invariant mass\n",
    "This computes the 4-vectors sum for the 4-lepton system\n",
    "using formulas from special relativity.  \n",
    "See also http://edu.itp.phys.ethz.ch/hs10/ppp1/2010_11_02.pdf\n",
    "and https://en.wikipedia.org/wiki/Invariant_mass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1834fc32",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------------------+-------------------+-------------------+---------+\n",
      "|                 Px|                 Py|                 Pz|        E|\n",
      "+-------------------+-------------------+-------------------+---------+\n",
      "| -5549.313396878235|-170444.05334022344|-15746.091731533503|309954.88|\n",
      "|  42207.49382671446| 130573.00201274469| -47275.43779472515|294242.06|\n",
      "|-1688.5786930973281| 12019.559647988772|-184350.58119043778|255493.97|\n",
      "|-24986.255307382246| -16563.56023125274|  586515.1288275808| 655824.6|\n",
      "| -25158.89812267374|-26052.317345542066|  649866.7138738859| 689542.3|\n",
      "+-------------------+-------------------+-------------------+---------+\n",
      "only showing top 5 rows\n",
      "\n",
      "+------------------+\n",
      "|       invmass_GeV|\n",
      "+------------------+\n",
      "| 258.3449524588402|\n",
      "| 255.9543720735489|\n",
      "| 176.4786439391845|\n",
      "| 291.9028801340375|\n",
      "|227.66237283516355|\n",
      "+------------------+\n",
      "only showing top 5 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# This computes the 4-vectors sum for the 4-lepton system\n",
    "\n",
    "df_4lep = df_events.selectExpr(\n",
    "\"lep_pt[0] * cos(lep_phi[0]) + lep_pt[1] * cos(lep_phi[1]) + lep_pt[2] * cos(lep_phi[2]) + lep_pt[3] * cos(lep_phi[3]) as Px\",\n",
    "\"lep_pt[0] * sin(lep_phi[0]) + lep_pt[1] * sin(lep_phi[1]) + lep_pt[2] * sin(lep_phi[2]) + lep_pt[3] * sin(lep_phi[3]) as Py\",\n",
    "\"lep_pt[0] * sinh(lep_eta[0]) + lep_pt[1] * sinh(lep_eta[1]) + lep_pt[2] * sinh(lep_eta[2]) + lep_pt[3] * sinh(lep_eta[3]) as Pz\",\n",
    "\"lep_E[0] + lep_E[1] + lep_E[2] + lep_E[3] as E\"    \n",
    ")\n",
    "\n",
    "df_4lep.show(5)\n",
    "\n",
    "df_4lep_invmass = df_4lep.selectExpr(\"sqrt(E * E - ( Px * Px + Py * Py + Pz * Pz))/1e3 as invmass_GeV\")\n",
    "\n",
    "df_4lep_invmass.show(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "bf45e904",
   "metadata": {},
   "outputs": [],
   "source": [
    "# This defines the DataFrame transformation to compute the histogram of invariant mass\n",
    "# The result is a histogram with (energy) bin values and event counts foreach bin\n",
    "\n",
    "# Requires sparkhistogram\n",
    "# See https://github.com/LucaCanali/Miscellaneous/blob/master/Spark_Notes/Spark_DataFrame_Histograms.md \n",
    "from sparkhistogram import computeHistogram\n",
    "\n",
    "# histogram parameters\n",
    "min_val = 80\n",
    "max_val = 250\n",
    "num_bins = (max_val - min_val) / 5.0\n",
    "\n",
    "# use the helper function computeHistogram in the package sparkhistogram\n",
    "histogram_data = computeHistogram(df_4lep_invmass, \"invmass_GeV\", min_val, max_val, num_bins) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "703b649a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 339 ms, sys: 55.2 ms, total: 394 ms\n",
      "Wall time: 1.83 s\n"
     ]
    }
   ],
   "source": [
    "# The action toPandas() here triggers the computation.\n",
    "# Histogram data is fetched into the driver as a Pandas Dataframe.\n",
    "\n",
    "%time histogram_data_pandas=histogram_data.toPandas()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "158e0813",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Computes statistical error on the data (histogram)\n",
    "histogram_data_stat_errors = np.sqrt(histogram_data_pandas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "927ff9c0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1400x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# This plots the data histogram with error bars\n",
    "import matplotlib.pyplot as plt \n",
    "plt.style.use('seaborn-v0_8-darkgrid')\n",
    "\n",
    "plt.rcParams.update({'font.size': 20, 'figure.figsize': [14,10]})\n",
    "\n",
    "f, ax = plt.subplots()\n",
    "\n",
    "x = histogram_data_pandas[\"value\"]\n",
    "y = histogram_data_pandas[\"count\"]\n",
    "err = histogram_data_stat_errors[\"count\"]\n",
    "\n",
    "# scatter plot\n",
    "ax.plot(x, y, marker='o', color='red', linewidth=0)\n",
    "#ax.errorbar(x, y, err, fmt = 'ro')\n",
    "# histogram with error bars\n",
    "ax.bar(x, y, width = 5.0, yerr = err, capsize = 5, linewidth = 0.2, ecolor='blue', fill=False)\n",
    "\n",
    "ax.set_xlim(min_val-2, max_val)\n",
    "\n",
    "ax.set_xlabel('$m_{4lep}$ (GeV)')\n",
    "ax.set_ylabel('Number of Events / bucket_size = 5 GeV')\n",
    "ax.set_title(\"Distribution of the 4-Lepton Invariant Mass\")\n",
    "\n",
    "# Label for the Z ang Higgs spectrum peaks\n",
    "txt_opts = {'horizontalalignment': 'left',\n",
    "            'verticalalignment': 'center',\n",
    "            'transform': ax.transAxes}\n",
    "\n",
    "plt.text(0.10, 0.86, \"Z boson, mass = 91 GeV\", **txt_opts)\n",
    "plt.text(0.27, 0.55, \"Higgs boson, mass = 125 GeV\", **txt_opts)\n",
    "\n",
    "# Add energy and luminosity\n",
    "plt.text(0.60, 0.92, \"ATLAS open data, for education\", **txt_opts)\n",
    "plt.text(0.60, 0.87, '$\\sqrt{s}$=13 TeV,$\\int$L dt = 10 fb$^{-1}$', **txt_opts)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b27dc159",
   "metadata": {},
   "outputs": [],
   "source": [
    "spark.stop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fee18bd0",
   "metadata": {},
   "source": [
    "## Note on sparkhistogram\n",
    "\n",
    "Use this to define the computeHistogram function if you cannot pip install sparkhistogram\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c4dab31",
   "metadata": {},
   "outputs": [],
   "source": [
    "def computeHistogram(df: \"DataFrame\", value_col: str, min_val: float, max_val: float, bins: int) -> \"DataFrame\":\n",
    "    \"\"\" This is a dataframe function to compute the count/frequecy histogram of a column\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        df: the dataframe with the data to compute\n",
    "        value_col: column name on which to compute the histogram\n",
    "        min: minimum value in the histogram\n",
    "        max: maximum value in the histogram\n",
    "        bins: number of histogram buckets to compute\n",
    "        \n",
    "        Output DataFrame\n",
    "        ----------------\n",
    "        bucket: the bucket number, range from 1 to bins (included)\n",
    "        value: midpoint value of the given bucket\n",
    "        count: number of values in the bucket        \n",
    "    \"\"\"\n",
    "    # Compute the step size for the histogram\n",
    "    step = (max_val - min_val) / bins\n",
    "\n",
    "    # Get the Spark Session handle\n",
    "    spark = SparkSession.getActiveSession()\n",
    "\n",
    "    # df_buckets is the range of {bins} buckets as requested by the user\n",
    "    # It will be used to fill in for missing buckets, i.e. buckets with no corresponding values\n",
    "    df_buckets = spark.range(bins).selectExpr(\"id + 1 as bucket\")\n",
    "\n",
    "    # Group user data into buckets and count their population count\n",
    "    df_grouped = (df\n",
    "                   .selectExpr(f\"width_bucket({value_col}, {min_val}, {max_val}, {bins}) as bucket\")\n",
    "                   .groupBy(\"bucket\")\n",
    "                   .count()\n",
    "                 )\n",
    "\n",
    "    # join df_buckets with the grouped data to fill in missing buckets\n",
    "    df_hist = (df_buckets # note this will be typically broadcasted, the order of the join is important\n",
    "               .join(df_grouped, \"bucket\", \"left_outer\") # add missing buckets and remove buckets out of range\n",
    "               .selectExpr(\"bucket\", f\"{min_val} + (bucket - 0.5) * {step} as value\",  # use center value of the buckets\n",
    "                           \"nvl(count, 0) as count\") # buckets with no values will have a count of 0\n",
    "               .orderBy(\"bucket\")\n",
    "              )\n",
    "\n",
    "    return df_hist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba7086f8-db28-4355-8288-43b0b593daec",
   "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}