notebooks/RAiDER_tutorial/RAiDER_Python_access.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "16b09d12-6b7b-47f6-9fe2-667b4cc6bef7",
   "metadata": {},
   "source": [
    "# RAiDER in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19f549d1-113d-4ba9-9b6d-2d2798bdc50f",
   "metadata": {},
   "source": [
    "RAiDER can be called and used from with Python. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3541909b-938b-4ba3-aec0-f3ada8105ba2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# at the most basic level, can \"import RAiDER\"\n",
    "import RAiDER\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6df74f54-2e1b-4a49-986b-4bd870fef003",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set up a custom logging location\n",
    "log_dir = './logs/'\n",
    "if not os.path.exists(log_dir):\n",
    "    os.mkdir(log_dir)\n",
    "import RAiDER.cli.conf as conf\n",
    "conf.LOGGER_PATH = log_dir\n",
    "from RAiDER.logger import logger"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef938bda-a8d6-4ee7-be43-d709f48c2a16",
   "metadata": {},
   "outputs": [],
   "source": [
    "# we'll need some other basic libraries\n",
    "import datetime\n",
    "import pyproj\n",
    "import xarray\n",
    "import matplotlib\n",
    "\n",
    "matplotlib.use('qtagg')\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e17e11c-2d91-4beb-b7f3-ccf147b0eed3",
   "metadata": {},
   "source": [
    "## Downloading weather model data\n",
    "RAiDER provides access to multiple weather models through a consistent API. \n",
    "RAiDER will process the weather model data to a regular 3D cube and write the data to a NETCDF file that will be used later by the `tropo_delay` function to calculate delays at specified query points. \n",
    "\n",
    "In order to download weather model data, we need to instantiate a weather model object of the appropriate class. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2735b4fe-adfb-4eb6-aa48-5fa69a318ae2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can print out the list of models currently implemented in RAiDER\n",
    "# Note that some of these models require licenses etc. \n",
    "from RAiDER.models.allowed import ALLOWED_MODELS\n",
    "print(ALLOWED_MODELS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e848770-949d-42e3-a069-66c418d1c7ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The HRRR model from NOAA can be accessed for free\n",
    "from RAiDER.models.hrrr import HRRR, HRRRAK"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9478ab04-8874-466b-b94c-3ce29ec2bacc",
   "metadata": {},
   "source": [
    "To access weather model data, we need only to specify a datetime and a bounding box in South-North-West-East format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77bb87f4-d0ed-4b03-83b3-ac1878f209fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# First define datetime, and AOI\n",
    "date_time = datetime.datetime(2018,11,13, 23, 0, 0)\n",
    "\n",
    "# bounding box is given in SNWE format\n",
    "ll_bounds = [36.8, 36.85, -76.15, -76.05]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07736371-a842-4ace-aa65-63192ffffc35",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(date_time)\n",
    "print(ll_bounds)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de72eb94-3127-42ca-9feb-33b493143ff7",
   "metadata": {},
   "source": [
    "`prepareWeatherModel` is the function for accessing weather model data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22ba28bc-3595-44e3-882a-c6020b3c0262",
   "metadata": {},
   "outputs": [],
   "source": [
    "from RAiDER.processWM import prepareWeatherModel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36f8a46f-1114-42ff-85e4-fb411afd734e",
   "metadata": {},
   "outputs": [],
   "source": [
    "help(prepareWeatherModel)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "836e7e34-6605-4980-bd41-1ab5cc88a321",
   "metadata": {},
   "source": [
    "Instantiate the weather model and then pass it to `prepareWeatherModel`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db9e463e-d984-4026-85dc-fdfe4db3a28a",
   "metadata": {},
   "outputs": [],
   "source": [
    "weather_model = HRRR()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "779937c2-5aef-423e-a4f1-eebddd157fc7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# For the first example, we'll do a zenith calculation at the weather model grid nodes\n",
    "prepareWeatherModel(weather_model, date_time, ll_bounds=ll_bounds, makePlots=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c29558d9-597c-493e-ac8d-289909ed69bc",
   "metadata": {},
   "source": [
    "You can look at the PDF files generated to see slices of the weather model variables at different heights. \n",
    "\n",
    "We can also load the weather model using xarray:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e65706db-0e88-4e66-9797-1806ef7504e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can get the name of the weather model file by passing the write directory to the 'out_file' method\n",
    "weather_model_file = weather_model.out_file('weather_files')\n",
    "ds = xarray.load_dataset(weather_model_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e713881-39ba-45da-99c5-cfc62d88ab13",
   "metadata": {},
   "outputs": [],
   "source": [
    "ds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "827939c9-5a5e-472f-b9ec-a0c4adedda55",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Plot a slice of the total delay at 500 m height\n",
    "plt.close('all')\n",
    "(ds['wet_total'] + ds['hydro_total']).interp(z=500).plot()\n",
    "plt.savefig('total_delay.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e1f4579-b998-47bc-a9a1-ad7b665f9e4a",
   "metadata": {},
   "source": [
    "\"wet_total\" and \"hydro_total\" are the zenith delays (ZTD) at the weather model grid nodes. \n",
    "\n",
    "We can now run the delay calculation using various input query points"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40f9d33f-4ff7-4475-9cf0-ceca370306fb",
   "metadata": {},
   "source": [
    "### Compare to HRRR-AK"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1b47e59-a920-4582-9ab5-7811b77fa468",
   "metadata": {},
   "source": [
    "We can compare to using HRRR in Alaska. RAiDER can tell when you want to process data in Alaska versus the Continental US (CONUS), and will automatically switch to the HRRR-AK model for a bounding box within the extent of that model. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c3d0f9c-f385-4fef-838b-3ce2506e7264",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# bounding box for south-central AK\n",
    "date_time = datetime.datetime(2018,11,1, 0, 0, 0)\n",
    "ll_bounds_ak = [60.5, 61.5, -151, -149]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24406742-3381-4d69-a725-1f624858f06a",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# instantiate a new weather model\n",
    "weather_model_ak = HRRRAK()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6e364b9-7d8f-4219-80e6-d03eb34e7228",
   "metadata": {},
   "outputs": [],
   "source": [
    "prepareWeatherModel(weather_model_ak, date_time, ll_bounds=ll_bounds_ak, makePlots=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50d0d76a-6873-4c61-b286-98b1fa5961ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "weather_model_file_ak = weather_model_ak.out_file('weather_files')\n",
    "ds_ak = xarray.load_dataset(weather_model_file_ak)\n",
    "ds_ak"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f49b2c93-628b-4c92-b20c-1cce76f09667",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Plot a slice of the total delay at 500 m height\n",
    "plt.close('all')\n",
    "(ds_ak['wet_total'] + ds_ak['hydro_total']).interp(z=500).plot()\n",
    "plt.savefig('total_delay_ak.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "789718df-eced-496a-8d97-5d22be02fa8e",
   "metadata": {},
   "source": [
    "## Delay calculation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec0cba6e-0226-4922-9e33-8066b414bf11",
   "metadata": {},
   "source": [
    "The pre-processed weather model already has zenith delays calculated at the grid nodes, but if we want the delays at specific query points we need to use the `tropo_delay` function in RAiDER. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "866591cf-3324-4554-a024-9ab47407aee6",
   "metadata": {},
   "outputs": [],
   "source": [
    "from RAiDER.delay import tropo_delay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac6aaa3e-0c82-47c1-b528-27f3af7588a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "help(tropo_delay)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "494448fa-f790-4b3d-9a52-c9edb6201856",
   "metadata": {},
   "source": [
    "We will need a few more objects for this delay calculation depending on the type of delays desired. \n",
    "The `weather_model_file` is the file path to the NETCDF file generated from `prepareWeatherModel`. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52e07cb7-a6a6-440b-9b7a-0e29800e66a7",
   "metadata": {},
   "source": [
    "## AOI objects\n",
    "The AOI object is one of several types depending on what is requested. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ba60383-b2ae-4ff6-9e8c-765946c2e9db",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. basic data types and input parameters\n",
    "ll_bounds = [36.8, 36.85, -76.15, -76.05]\n",
    "from RAiDER.llreader import BoundingBox, StationFile  # also available: RasterRDR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73c75db7-39f2-43b6-bfb6-955a8216df47",
   "metadata": {},
   "outputs": [],
   "source": [
    "aoi = BoundingBox(ll_bounds)\n",
    "print(aoi.bounds())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e75e593a-c376-4d15-b0f8-a6f8c7e7580d",
   "metadata": {},
   "source": [
    "We can do much more with the AOI objects than just define a bounding box. \n",
    "For example, we can load lat/lon files or files containing GNSS station lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "876266ac-2191-4eac-bc80-437e98fe0fbc",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_aoi = StationFile('data/sample_gnss_list.csv')\n",
    "print(test_aoi)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82bf309e-a4fe-4759-b14c-086acfec3332",
   "metadata": {},
   "source": [
    "Several methods become available upon creation of the object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "20c7e21a-0708-46c5-8a8c-3016598ad5e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_aoi.bounds()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ba13295-6852-4280-aa13-801381d629d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_aoi.projection()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "698cb800-0d7e-4f75-b3fe-d878b094b9b6",
   "metadata": {},
   "source": [
    "We can use the `readLL` and `readZ` methods to access the lat/lon and elevation values. If no elevation values are available from the data, a DEM will be downloaded on the fly. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c1e911a-b2f9-4839-8fe6-125baa06f3df",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_aoi.readLL()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "09329625-9009-4f36-93a2-c60c072b0dc0",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_aoi.readZ()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b98b2fcf-ba5f-4235-9399-f6e6bf9515f8",
   "metadata": {},
   "source": [
    "## The LOS object"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "763ddc94-0825-4c8d-a4d8-900fde1bafb8",
   "metadata": {},
   "source": [
    "The LOS object defines the type of delay to calculate; can be zenith delays (ZTD), slant delays (STD) projected from the zenith delays, and slant delays (STD) integrated along the ray path. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9698323f",
   "metadata": {},
   "outputs": [],
   "source": [
    "date_time = datetime.datetime(2018, 11, 13, 0, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f37a8137-7a01-4e65-8ee2-7e4ecc1bc0c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# \"Conventional\" refers to slant delays by projection\n",
    "from RAiDER.losreader import Zenith, Conventional, Raytracing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f7540ea-376e-4fd9-bcf3-7603f1ee9341",
   "metadata": {},
   "outputs": [],
   "source": [
    "los = Zenith()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de8fcd5c-2c97-45b2-bbb7-f24cfd8b7f24",
   "metadata": {},
   "outputs": [],
   "source": [
    "los.is_Zenith()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9367f488-6c46-4a5e-8f86-93033778ff16",
   "metadata": {},
   "source": [
    "If using the `Conventional` or `Raytracing` objects, an orbit file or look vector files should be supplied"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a5ddc06-c94f-45ac-9e4f-f2a1f183b741",
   "metadata": {},
   "outputs": [],
   "source": [
    "los_ray = Raytracing('data/S1A_OPER_AUX_POEORB_OPOD_20181203T120749_V20181112T225942_20181114T005942.EOF', time=date_time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e457c2d3-6a59-4c1c-a49d-18a9f07a63f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "los_ray.is_Zenith()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c15cbc48-468e-4871-b3be-5f5b7ebb05e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "los_ray.ray_trace()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c5f6f61-66b3-4341-b4a8-4d036b8d63d5",
   "metadata": {},
   "source": [
    "### ZTD calculation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0cdc91a-038f-4351-8f27-afddcd459f8a",
   "metadata": {},
   "source": [
    "Delay calculation in this case will be for a uniform cube at fixed height levels and horizontal spacing. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63a6cce1-6ff9-4340-8618-9714565be00a",
   "metadata": {},
   "source": [
    "We need to setup some objects with the appropriate parameters, including the area of interest (AOI) and line-of-sight (LOS) objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f7d9d61",
   "metadata": {},
   "outputs": [],
   "source": [
    "weather_model = HRRR()\n",
    "prepareWeatherModel(weather_model, date_time, ll_bounds=ll_bounds, makePlots=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03f4e955-ec5d-4618-8e32-42e7dd26dfb8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set parameters\n",
    "aoi.add_buffer(weather_model.getLLRes())\n",
    "aoi.set_output_xygrid(4326)\n",
    "los = Zenith()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "90a10154-8d58-4ab1-93d4-95548e6c53a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# add a buffer determined by latitude for ray tracing\n",
    "if los.ray_trace():\n",
    "    wm_bounds = aoi.calc_buffer_ray(\n",
    "        los.getSensorDirection(),\n",
    "        lookDir=los.getLookDirection(),\n",
    "        incAngle=30\n",
    "    )\n",
    "else:\n",
    "    wm_bounds = aoi.bounds()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "786b7a07-29fb-45f4-8e0d-2694b87797a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "weather_model.set_latlon_bounds(wm_bounds, output_spacing=aoi.get_output_spacing())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d61d5c53-f90d-4e90-833e-d31403888615",
   "metadata": {},
   "outputs": [],
   "source": [
    "# calculate ZTD\n",
    "ds, _ = tropo_delay(\n",
    "    date_time,\n",
    "    weather_model.out_file('weather_files'),\n",
    "    aoi,\n",
    "    los,\n",
    "    height_levels=[0, 100, 500, 1000]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa5c36bb-ab93-4a1f-8421-b42b34e83c7c",
   "metadata": {},
   "source": [
    "Because we asked for a cube, the delays are returned as a single xarray Dataset. In other cases e.g. for rasters, wet and hydrostatic delays will be returned as two ndarrays. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1af58ca4-9b91-4ca0-84a4-54babd07951a",
   "metadata": {},
   "source": [
    "We can look at the output of the delay calculation in the Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d5b21d4-27f0-43dd-89c7-e6b97dee6bbb",
   "metadata": {},
   "outputs": [],
   "source": [
    "ds"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e74a7749-f6c7-4b7c-8fae-33b16bed4dd2",
   "metadata": {},
   "source": [
    "We can look at the output shape etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8634777-162b-41e2-a629-6374059812e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(ds['wet'].shape)\n",
    "print(ds['wet'].values.mean())\n",
    "print(ds['wet'].attrs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b477e0eb-6d94-4a47-a80a-6daf6cc21e24",
   "metadata": {},
   "source": [
    "Projection information is maintained in the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c0ac577-3d6f-4c6c-876f-1e3a9609f0c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(ds.crs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72ffceb4-5c38-41b1-8233-6d10a764eebb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot a slice of the total delay at 500 m height\n",
    "plt.close('all')\n",
    "(ds['wet'] + ds['hydro']).interp(z=500).plot()\n",
    "plt.savefig('ZTD_delays.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e3eb806-edf6-4024-a07a-39a3fd18fb9f",
   "metadata": {},
   "source": [
    "### Raytracing calculation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a7e805d-7a2a-4a79-a067-56c501f2d267",
   "metadata": {},
   "outputs": [],
   "source": [
    "ds, _ = tropo_delay(\n",
    "    date_time,\n",
    "    weather_model.out_file('weather_files'),\n",
    "    aoi,\n",
    "    los_ray,\n",
    "    height_levels=[0, 100, 500, 1000]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bae19e15-d53e-4b2a-ac62-82d0e79c0160",
   "metadata": {},
   "outputs": [],
   "source": [
    "ds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "431aaf45-a3a9-4028-a837-86c48370451a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Look at the output\n",
    "print(ds['wet'].shape)\n",
    "print(ds['hydro'].shape)\n",
    "print(ds['wet'].values.mean())\n",
    "print(ds['hydro'].values.mean())\n",
    "print(ds['wet'].attrs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28592ff0-bc07-4a1b-aec1-584b4fe1a418",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot a slice of the total delay at 500 m height\n",
    "plt.close('all')\n",
    "(ds['wet'] + ds['hydro']).interp(z=500).plot()\n",
    "plt.savefig('Raytracing_delays.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d34eb0e",
   "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.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}