notebook/Scientific_Visualisation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6afcfbdf-21ea-4772-9b28-87b5f7721c43",
   "metadata": {},
   "source": [
    "## Exercise 1a): Matplotlib advanced features: inset plots\n",
    "\n",
    "This execise demonstrates adding inset plots to an axes.\n",
    "\n",
    "The main axes and inset axes are instatiated as separate objects which are plotted on the same Figure. Each axes requires individual setup.\n",
    "\n",
    "The main axes and inset axes are linked through `mark_inset`, which is a sub function of `mpl_tookits`.\n",
    "\n",
    "Try changing which section of the main plot the inset captures, and moving the position of the inset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "644d874f-d58d-4c6e-bbdf-156eb233aa89",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from mpl_toolkits.axes_grid1.inset_locator import mark_inset\n",
    "\n",
    "# Create a figure and main axes\n",
    "fig, main_ax = plt.subplots(figsize=(6, 4))\n",
    "\n",
    "# Add inset axes\n",
    "inset_ax = fig.add_axes([0.55, 0.55, 0.3, 0.3])\n",
    "\n",
    "# Data for main plot\n",
    "x_main = np.linspace(0, 10, 100)\n",
    "y_main = np.sin(x_main)\n",
    "\n",
    "# Data for inset plot (highlight a specific region of the main data)\n",
    "x_inset = np.linspace(2, 4, 50)\n",
    "y_inset = np.sin(x_inset)\n",
    "\n",
    "# Plot data on main axes\n",
    "main_ax.plot(x_main, y_main, label=\"Main Data\")\n",
    "main_ax.set_title(\"Main Plot\")\n",
    "main_ax.set_xlabel(\"X-axis\")\n",
    "main_ax.set_ylabel(\"Y-axis\")\n",
    "main_ax.legend()\n",
    "\n",
    "# Plot data on inset axes\n",
    "inset_ax.plot(x_inset, y_inset, color=\"red\", label=\"Inset Data\")\n",
    "inset_ax.set_title(\"Inset Plot\")\n",
    "inset_ax.legend()\n",
    "\n",
    "# Highlight the inset area on the main plot\n",
    "\n",
    "mark_inset(main_ax, inset_ax, loc1=2, loc2=4, fc=\"none\", ec=\"0.5\")\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8725323-75c4-477e-a082-a4677983225b",
   "metadata": {},
   "source": [
    "# Exercise 1b) Custom date time axes formats\n",
    "\n",
    "Its common to plot time series data using Matplotlib. This section explores the default date formatter and shows alternatives which may be more readable.\n",
    "\n",
    "This section also introduces `subplots` which are a common way of adding multiple axes to a `figure` in a structured fashion.\n",
    "\n",
    "`axs` is a structure containing all the subplots. This is looped over to update each subplot in a consistent way. This minimises the amount of repeated code.\n",
    "\n",
    "This exercise demonstataes how to manaually define x-axis data labels, and how display of time series data is improved with manual intervention. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ec22422-6e9f-4108-949e-fe9dbf60305f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.dates as mdates\n",
    "from matplotlib import cbook\n",
    "\n",
    "# Load a numpy record array from yahoo csv data with fields date, open, high,\n",
    "# low, close, volume, adj_close from the mpl-data/sample_data directory. The\n",
    "# record array stores the date as an np.datetime64 with a day unit ('D') in\n",
    "# the date column.\n",
    "data = cbook.get_sample_data(\"goog.npz\")[\"price_data\"]\n",
    "\n",
    "# note use of subplots\n",
    "fig, axs = plt.subplots(3, 1, figsize=(6.4, 7), layout=\"constrained\")\n",
    "\n",
    "# common to all three:\n",
    "for ax in axs:\n",
    "    ax.plot(\"date\", \"adj_close\", data=data)\n",
    "    # Major ticks every half year, minor ticks every month,\n",
    "    ax.xaxis.set_major_locator(mdates.MonthLocator(bymonth=(1, 7)))\n",
    "    ax.xaxis.set_minor_locator(mdates.MonthLocator())\n",
    "    ax.grid(True)\n",
    "    ax.set_ylabel(r\"Price [\\$]\")\n",
    "\n",
    "# define unique settings for each subplot:\n",
    "ax = axs[0]\n",
    "ax.set_title(\"DefaultFormatter\", loc=\"left\", y=0.85, x=0.02, fontsize=\"medium\")\n",
    "\n",
    "ax = axs[1]\n",
    "ax.set_title(\"ConciseFormatter\", loc=\"left\", y=0.85, x=0.02, fontsize=\"medium\")\n",
    "ax.xaxis.set_major_formatter(mdates.ConciseDateFormatter(ax.xaxis.get_major_locator()))\n",
    "\n",
    "ax = axs[2]\n",
    "ax.set_title(\"Manual DateFormatter\", loc=\"left\", y=0.85, x=0.02, fontsize=\"medium\")\n",
    "\n",
    "\n",
    "# Text in the x-axis will be displayed in 'YYYY-mm' format.\n",
    "ax.xaxis.set_major_formatter(mdates.DateFormatter(\"%Y-%b\"))\n",
    "\n",
    "\n",
    "# Rotates and right-aligns the x labels so they don't crowd each other.\n",
    "for label in ax.get_xticklabels(which=\"major\"):\n",
    "    label.set(rotation=30, horizontalalignment=\"right\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae063378-edc4-48f4-b6c4-e0c3842279c9",
   "metadata": {},
   "source": [
    "## Exercise 1c) Annotating plots\n",
    "\n",
    "It can be useful to highlight specific data areas or add commentry. Matplotlib supports a subset of `latex` which can be used to display mathematics or text.\n",
    "\n",
    "Try moving the annotations and modifying their content."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "474b4d13-1c1b-4873-b0ad-c358f87f94f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a figure\n",
    "fig, main_ax = plt.subplots(figsize=(6, 4))\n",
    "\n",
    "# Data for main plot\n",
    "x_main = np.linspace(0, 10, 100)\n",
    "y_main = np.sin(x_main)\n",
    "\n",
    "# Plot data on main axes\n",
    "main_ax.plot(x_main, y_main, label=\"Main Data\")\n",
    "main_ax.set_title(\"Main Plot\")\n",
    "main_ax.set_xlabel(\"X-axis\")\n",
    "main_ax.set_ylabel(\"Y-axis\")\n",
    "main_ax.legend()\n",
    "\n",
    "# Add the first annotation\n",
    "main_ax.annotate(\n",
    "    \"Peak\",\n",
    "    xy=(np.pi / 2, 1),\n",
    "    xytext=(4, 0.5),\n",
    "    arrowprops={\"facecolor\": \"black\", \"shrink\": 0.05},\n",
    ")\n",
    "\n",
    "# Add the second annotation\n",
    "main_ax.annotate(\n",
    "    \"y = Sin(x)\",\n",
    "    xy=(3 * np.pi / 2, -1),\n",
    "    xytext=(4, 0),\n",
    "    arrowprops={\"facecolor\": \"red\", \"shrink\": 0.05},\n",
    ")\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cca63bfd-b29e-4d56-ba93-7638778125e9",
   "metadata": {},
   "source": [
    "## Exercise 2a) Plotting NetCDF data\n",
    "\n",
    "NetCDF data needs to be processed before it can be plotted effectively in matplotlib.\n",
    "\n",
    "The first codebox simply displays the NetCDF data we are going to plot. Find the following:\n",
    "- source \n",
    "- temporal range\n",
    "- extents of longitude and latitude\n",
    "- variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8bd22fe8-aa47-4726-a5cc-12fd17a828b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import netCDF4 as nc\n",
    "\n",
    "# Open the NetCDF file\n",
    "file_path = \"../data/MERRA2_400.tavg1_2d_lnd_Nx.20240401.nc4\"\n",
    "dataset = nc.Dataset(file_path)\n",
    "\n",
    "# Print metadata\n",
    "print(dataset)\n",
    "\n",
    "# Close the dataset\n",
    "dataset.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34998fc5-c94b-4fb7-b63d-f43d491f7728",
   "metadata": {},
   "source": [
    "## Exercise 2b) Plot the netCDF data\n",
    "\n",
    "Try changing the colour scheme or changing the plot to focus on a smaller region of the earth\n",
    "\n",
    "For this exercise we will be using `dataset` as loaded above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50b5eb5b-d8a3-42a6-bbbc-ee45ffe7f974",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the netCDF file\n",
    "file_path = \"../data/MERRA2_400.tavg1_2d_lnd_Nx.20240401.nc4\"\n",
    "dataset = nc.Dataset(file_path)\n",
    "\n",
    "# Extract the variables\n",
    "lats = dataset.variables[\"lat\"][:]\n",
    "lons = dataset.variables[\"lon\"][:]\n",
    "temps = dataset.variables[\"TSURF\"][\n",
    "    0, :, :\n",
    "]  # Assuming the time dimension is the first dimension\n",
    "\n",
    "# Close the dataset\n",
    "dataset.close()\n",
    "\n",
    "# Create a figure\n",
    "fig, ax = plt.subplots(figsize=(12, 6))\n",
    "\n",
    "# Plot the temperature data\n",
    "c = ax.pcolormesh(lons, lats, temps, shading=\"auto\")\n",
    "fig.colorbar(c, ax=ax, label=\"Temperature\")\n",
    "\n",
    "# Set labels and title\n",
    "ax.set_xlabel(\"Longitude\")\n",
    "ax.set_ylabel(\"Latitude\")\n",
    "ax.set_title(\"Surface Temperature Distribution\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ff13435-bbde-4842-b143-15050baba354",
   "metadata": {},
   "source": [
    "## Excercise 3a) Cartopy coastlines\n",
    "\n",
    "Cartopy is a wrapper for Matplotlib. It extends Matplotlib functionality\n",
    "by adding additional features that can be invoked through the conventional\n",
    "Matplotlib interface.\n",
    "\n",
    "The trigger for activation of Cartopy features is the addition of the `projection = ccrs.X` argument in the creation of the plot object.\n",
    "\n",
    "Once the projection map is defined on the `axes`, coastlines can be added with the command `ax.coastlines()`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dab529aa-a768-4209-9809-6a7b7001d36b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import cartopy.crs as ccrs\n",
    "\n",
    "ax = plt.axes(projection=ccrs.PlateCarree())\n",
    "ax.coastlines()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f1ac205-6e7d-4b23-8d98-15ea24baddf1",
   "metadata": {},
   "source": [
    "## Exercise 3b) Cartopy features\n",
    "\n",
    "`stock_img` is an internal Matplotlib standard image.\n",
    "Currently, the only (and default) option is a downsampled version of the Natural Earth shaded relief raster.\n",
    "\n",
    "You may notice that we use a new command `ax.set_extent`. This is an extension of the conventional `matplotlib` command `ax.set_xlim`, and is better able to work with geomgraphic data such as latitude and longitude, and non cartesian axes. \n",
    "\n",
    "The cartopy `Feature` interface provides Cartopy resources that can be invoked in a consistent way.\n",
    "\n",
    "`cartopy.feature.BORDERS` &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Country boundaries\\\n",
    "`cartopy.feature.COASTLINE` &nbsp;&nbsp;Coastline, including major islands.\\\n",
    "`cartopy.feature.LAKES` &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Natural and artificial lakes.\\\n",
    "`cartopy.feature.LAND` &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Land polygons, including major islands.\\\n",
    "`cartopy.feature.OCEAN`&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Ocean polygons.\\\n",
    "`cartopy.feature.RIVERS`&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Single-line drainages, including lake centerlines.\\\n",
    "\n",
    "The `ax.add_feature` command takes Cartopy `Features` as arguments and adds them to the plot axes.\n",
    "\n",
    "This example uses the `Matplotlib` library `AnchoredText` within `offsetbox` to add further information to the plot. The `axes` attribute `add_artist` is used to directly add the `AnchoredText` to the plot. This is added last as it is layered on top of the prior features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c774cd48-6294-4ffd-a263-99cbfc47b32f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import cartopy.feature as cfeature\n",
    "from matplotlib.offsetbox import AnchoredText\n",
    "\n",
    "ax = plt.axes(projection=ccrs.PlateCarree())\n",
    "ax.set_extent([80, 170, -45, 30])\n",
    "\n",
    "# Put a background image on for nice sea rendering.\n",
    "ax.stock_img()\n",
    "\n",
    "# Create a feature for States/Admin 1 regions at 1:50m from Natural Earth\n",
    "states_provinces = cfeature.NaturalEarthFeature(\n",
    "    category=\"cultural\",\n",
    "    name=\"admin_1_states_provinces_lines\",\n",
    "    scale=\"50m\",\n",
    "    facecolor=\"none\",\n",
    ")\n",
    "\n",
    "SOURCE = \"Natural Earth\"\n",
    "LICENSE = \"public domain\"\n",
    "\n",
    "ax.add_feature(cfeature.LAND)\n",
    "ax.add_feature(cfeature.COASTLINE)\n",
    "ax.add_feature(states_provinces, edgecolor=\"gray\")\n",
    "\n",
    "# Add a text annotation for the license information to the\n",
    "# the bottom right corner.\n",
    "text = AnchoredText(\n",
    "    \"\\u00a9 {}; license: {}\" \"\".format(SOURCE, LICENSE),\n",
    "    loc=4,\n",
    "    prop={\"size\": 8},\n",
    "    frameon=True,\n",
    ")\n",
    "ax.add_artist(text)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba714ae5-076d-4dcc-a9dc-a4e33618d84e",
   "metadata": {},
   "source": [
    "## Exercise 4a) Cartopy projections\n",
    "\n",
    "`netCDF4` is a useful library for importing, parseinga nd saving netCDF files.\n",
    "\n",
    "`pcolormesh` is a matplotlib library for plotting pseudocolour data on non-regular rectanglar grids.\n",
    "\n",
    "Try:\n",
    "- rotating the plot\n",
    "- changing the projection (https://scitools.org.uk/cartopy/docs/v0.15/crs/projections.html)\n",
    "- changing the colourmap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cd928a1c-6bdc-4c52-90de-eb3548ecbdc0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Open the NetCDF file\n",
    "file_path = \"../data/MERRA2_400.tavg1_2d_lnd_Nx.20240401.nc4\"\n",
    "dataset = nc.Dataset(file_path)\n",
    "\n",
    "# Extract the variables\n",
    "lats = dataset.variables[\"lat\"][:]\n",
    "lons = dataset.variables[\"lon\"][:]\n",
    "temps = dataset.variables[\"TSURF\"][\n",
    "    0, :, :\n",
    "]  # Assuming the time dimension is the first dimension\n",
    "\n",
    "# Close the dataset\n",
    "dataset.close()\n",
    "\n",
    "# Create a figure\n",
    "fig, ax = plt.subplots(\n",
    "    figsize=(12, 6),\n",
    "    subplot_kw={\n",
    "        \"projection\": ccrs.Orthographic(central_longitude=0, central_latitude=50)\n",
    "    },\n",
    ")\n",
    "\n",
    "# Plot the temperature data\n",
    "c = ax.pcolormesh(\n",
    "    lons, lats, temps, shading=\"auto\", transform=ccrs.PlateCarree(), cmap=\"coolwarm\"\n",
    ")\n",
    "fig.colorbar(c, ax=ax, label=\"Temperature\")\n",
    "\n",
    "# Add features for better visualization\n",
    "ax.add_feature(cfeature.BORDERS, linestyle=\":\")\n",
    "ax.add_feature(cfeature.COASTLINE)\n",
    "\n",
    "# Set title\n",
    "ax.set_title(\"Surface Temperature Distribution\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "434d521b-66a7-426b-952d-da32d2b5aa0e",
   "metadata": {},
   "source": [
    "## Exercise 4b) Cartopy gridlines and ticks\n",
    "\n",
    "In this exercise we add both gridlines and specific labelled lcoations on the x-axis.\n",
    "\n",
    "The `matplotlib.ticker` library is used to define a custom set of x-axis labels at the correct longitude position.\n",
    "\n",
    "The `cartopy.mpl.ticker` library is used to format the latitude and longitudes correctly, so that these custom labels appear on the plot correctly.\n",
    "\n",
    "The y-axis labels are default from the `draw_labels = True` argument to `ax.gridlines`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d0c759f-e952-4ec7-b71b-f9b7454037d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import cartopy.crs as ccrs\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as mticker\n",
    "from cartopy.mpl.ticker import LatitudeFormatter, LatitudeLocator, LongitudeFormatter\n",
    "\n",
    "ax = plt.axes(projection=ccrs.Mercator())\n",
    "ax.coastlines()\n",
    "\n",
    "gl = ax.gridlines(\n",
    "    crs=ccrs.PlateCarree(),\n",
    "    draw_labels=True,\n",
    "    linewidth=2,\n",
    "    color=\"gray\",\n",
    "    alpha=0.5,\n",
    "    linestyle=\"--\",\n",
    ")\n",
    "gl.top_labels = False\n",
    "gl.left_labels = False\n",
    "gl.xlines = False\n",
    "gl.xlocator = mticker.FixedLocator([-180, -45, 0, 45, 180])\n",
    "gl.ylocator = LatitudeLocator()\n",
    "gl.xformatter = LongitudeFormatter()\n",
    "gl.yformatter = LatitudeFormatter()\n",
    "gl.xlabel_style = {\"size\": 15, \"color\": \"gray\"}\n",
    "gl.xlabel_style = {\"color\": \"red\", \"weight\": \"bold\"}\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0182960f",
   "metadata": {},
   "source": [
    "## Exercise 5) Visualising vector data as streamlines\n",
    "\n",
    "Up until now we have been displaying scalar temeprature data. However, different approaches can be used for vector data to communicate the magnitude and angle associated with the data.\n",
    "\n",
    "Many climate datasets will store wind velocity data as `u` annd `v` orthogonal components. These can be converted to a magnitude and direction, and then streamlines can be used to visualise these for a geographical area.\n",
    "\n",
    "`streamplot` is a `matplotlib` library that takes corordinate data and vector components and convertes these to streamlines. The vector magnitudes can be used to colour the steamlines.\n",
    "\n",
    "This code outputs a streamline plot in `Orthographic` projection. The display projection is set when we create the axes using the command `ax = plt.axes(projection=ccrs.Orthographic(central_longitude=0, central_latitude=50))`. This centres the plot on the (0, 50) co-ordinate which is roughly Cambridge.\n",
    "\n",
    "Later, when we compute the streamlines, we use the `transform=ccrs.PlateCarree()` argument. The data we use to calculate the streamlines is in basic lat/lon format, therefore computing on a rectangular grid is the simplest computational approach. The results are then mapped back to the orthographic projection.\n",
    "\n",
    "Try changing:\n",
    "- projection type\n",
    "- plot centre\n",
    "- streamline size and density\n",
    "- streamline colour\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e32f2fb7-253d-46ab-8b95-66d25513df42",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import cartopy.crs as ccrs\n",
    "import cartopy.feature as cfeature\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import xarray as xr\n",
    "from matplotlib import cm\n",
    "from matplotlib.colors import Normalize\n",
    "\n",
    "# Open the NetCDF file\n",
    "dataset = xr.load_dataset(\"../data/ERA5_vector_data.nc\", engine=\"netcdf4\")\n",
    "\n",
    "# Extract the variables\n",
    "u = dataset.variables[\"u10\"][0, :, :].values  # U-component of wind\n",
    "v = dataset.variables[\"v10\"][0, :, :].values  # V-component of wind\n",
    "lats = dataset.variables[\"latitude\"][:].values\n",
    "lons = dataset.variables[\"longitude\"][:].values\n",
    "\n",
    "# Close the dataset\n",
    "dataset.close()\n",
    "\n",
    "# Calculate the magnitude of the wind vectors\n",
    "magnitude = (u**2 + v**2) ** 0.5\n",
    "\n",
    "# Normalize the magnitude for coloring\n",
    "norm = Normalize(vmin=np.min(magnitude), vmax=np.max(magnitude))\n",
    "cmap = cm.viridis\n",
    "\n",
    "# Plotting\n",
    "fig = plt.figure(figsize=(10, 6))\n",
    "ax = plt.axes(projection=ccrs.Orthographic(central_longitude=0, central_latitude=50))\n",
    "\n",
    "# Create the streamlines with color mapping based on magnitude\n",
    "strm = ax.streamplot(\n",
    "    lons,\n",
    "    lats,\n",
    "    u,\n",
    "    v,\n",
    "    transform=ccrs.PlateCarree(),\n",
    "    color=magnitude,\n",
    "    linewidth=1,\n",
    "    cmap=cmap,\n",
    "    norm=norm,\n",
    "    density=1.5,\n",
    ")\n",
    "\n",
    "# Add color to the land and sea\n",
    "land = cfeature.NaturalEarthFeature(\n",
    "    \"physical\", \"land\", \"110m\", edgecolor=\"face\", facecolor=cfeature.COLORS[\"land\"]\n",
    ")\n",
    "ax.add_feature(land)\n",
    "\n",
    "sea = cfeature.NaturalEarthFeature(\n",
    "    \"physical\", \"ocean\", \"110m\", edgecolor=\"face\", facecolor=cfeature.COLORS[\"water\"]\n",
    ")\n",
    "ax.add_feature(sea)\n",
    "\n",
    "# Add coastlines\n",
    "ax.coastlines(color=\"r\", linewidth=1)\n",
    "\n",
    "# Add a color bar with adjusted size\n",
    "sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)\n",
    "sm.set_array(magnitude)\n",
    "plt.colorbar(\n",
    "    sm, ax=ax, orientation=\"horizontal\", label=\"Wind Speed (m/s)\", shrink=0.5, pad=0.1\n",
    ")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0a14216",
   "metadata": {},
   "source": [
    "## Exercise 6) Visualising data as animations\n",
    "\n",
    "Previously we have been only plotting steady state data. Not we will look at plotting timeseries data as animations.\n",
    "\n",
    "`matplotlib.animation` contains a set of methods used for computing animations:\n",
    "\n",
    "- `matplotlib.animation.animation`&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;base class for Animations.\n",
    "- `matplotlib.animation.FuncAnimation`&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;subclass that creates an animation by repeatedly calling a function `func`\n",
    "- `matplotlib.animation.ArtistAnimation`&nbsp;&nbsp;&nbsp; subclass that cerates an animation by using a fixed set of artist objects\n",
    "\n",
    "In this case we use `matplotlib.animation.FuncAnimation` to call a function which updates each frame with timeseries data.\n",
    "\n",
    "We convert the animation object to html for plotting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85db9e9b-8ab8-44c1-9a5c-b705d4bb54e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython import display\n",
    "from matplotlib import animation\n",
    "from matplotlib.colors import Normalize\n",
    "\n",
    "# Open the NetCDF file\n",
    "dataset = xr.load_dataset(\"../data/ERA5_vector_data.nc\", engine=\"netcdf4\")\n",
    "\n",
    "# Define the latitude and longitude bounds for the UK and Ireland\n",
    "lat_bounds = [49, 61]\n",
    "lon_bounds = [-12, 4]\n",
    "\n",
    "# Extract latitude and longitude arrays\n",
    "lats = dataset.variables[\"latitude\"][:].values\n",
    "lons = dataset.variables[\"longitude\"][:].values\n",
    "\n",
    "# Convert longitudes from [0, 360] to [-180, 180]\n",
    "lons = np.where(lons > 180, lons - 360, lons)\n",
    "\n",
    "# Find the indices that correspond to the desired lat/lon bounds\n",
    "lat_indices = np.where((lats >= lat_bounds[0]) & (lats <= lat_bounds[1]))[0]\n",
    "lon_indices = np.where((lons >= lon_bounds[0]) & (lons <= lon_bounds[1]))[0]\n",
    "\n",
    "# Slice the data to include only these bounds\n",
    "u = dataset.variables[\"u10\"][:, lat_indices, :][:, :, lon_indices].values\n",
    "v = dataset.variables[\"v10\"][:, lat_indices, :][:, :, lon_indices].values\n",
    "lats = lats[lat_indices]\n",
    "lons = lons[lon_indices]\n",
    "\n",
    "# Set up the plot\n",
    "fig = plt.figure(figsize=(10, 6))\n",
    "ax = plt.axes(projection=ccrs.PlateCarree())\n",
    "ax.set_extent([-12, 4, 49, 61], crs=ccrs.PlateCarree())  # Focus on UK and Ireland\n",
    "\n",
    "# Add color to the land and sea\n",
    "land = cfeature.NaturalEarthFeature(\n",
    "    \"physical\", \"land\", \"110m\", edgecolor=\"face\", facecolor=cfeature.COLORS[\"land\"]\n",
    ")\n",
    "ax.add_feature(land)\n",
    "\n",
    "sea = cfeature.NaturalEarthFeature(\n",
    "    \"physical\", \"ocean\", \"110m\", edgecolor=\"face\", facecolor=cfeature.COLORS[\"water\"]\n",
    ")\n",
    "ax.add_feature(sea)\n",
    "\n",
    "# Add coastlines\n",
    "ax.coastlines(color=\"r\", linewidth=1)\n",
    "\n",
    "# Normalize the magnitude for coloring\n",
    "norm = Normalize(vmin=np.min(u**2 + v**2), vmax=np.max(u**2 + v**2))\n",
    "cmap = cm.viridis\n",
    "\n",
    "\n",
    "# Function to update the streamline plot\n",
    "def update(frame):\n",
    "    \"\"\"Update with a new plot for each frame of the animation.\"\"\"\n",
    "    ax.clear()  # Clear the previous streamlines\n",
    "    ax.set_extent([-12, 4, 49, 61], crs=ccrs.PlateCarree())  # Reset the extent\n",
    "    ax.add_feature(land)\n",
    "    ax.add_feature(sea)\n",
    "    ax.coastlines(color=\"r\", linewidth=1)\n",
    "\n",
    "    magnitude = (u[frame, :, :] ** 2 + v[frame, :, :] ** 2) ** 0.5\n",
    "    strm = ax.streamplot(\n",
    "        lons,\n",
    "        lats,\n",
    "        u[frame, :, :],\n",
    "        v[frame, :, :],\n",
    "        transform=ccrs.PlateCarree(),\n",
    "        color=magnitude,\n",
    "        linewidth=2,\n",
    "        cmap=cmap,\n",
    "        norm=norm,\n",
    "    )\n",
    "    return strm\n",
    "\n",
    "\n",
    "# Create animation\n",
    "ani = animation.FuncAnimation(\n",
    "    fig, update, frames=len(dataset.variables[\"time\"]), blit=False, interval=1000\n",
    ")\n",
    "\n",
    "# Close the dataset\n",
    "dataset.close()\n",
    "\n",
    "# Assign the animation to a variable to prevent it from being deleted\n",
    "anim = ani\n",
    "\n",
    "# converting to an html5 video\n",
    "video = anim.to_html5_video()\n",
    "\n",
    "# embedding for the video\n",
    "html = display.HTML(video)\n",
    "\n",
    "# draw the animation\n",
    "display.display(html)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f39f968-80d2-4f6a-a46d-95f36d9ce8d1",
   "metadata": {},
   "source": [
    "## Exercise 7) Organising Plotting Code\n",
    "\n",
    "Plotting data is often done in a race to produce output and see results.\\\n",
    "However, it should be treated with as much respect as any other code. Doing so can save time and tears later.\n",
    "\n",
    "Repeated code is a bad 'code smell'. Look to place repeated code into subroutines where parameters can be changed in one place only.\n",
    "\n",
    "Useful 'tricks' here include:\n",
    "\n",
    "- `np.ravel()` allows us to iterate over grids of matlotlib subplots by flattening the subplots array.\n",
    "- `**kwargs` allows us to pass arbitrary keyword arguments through wrapper functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee52bf5b-be54-4403-b5b2-927315e71841",
   "metadata": {},
   "source": [
    "### Not so good:\n",
    "\n",
    "Consider the code below.\\\n",
    "Suppose you wish to change the colormap, or add axis labels to the plots, how easy will this be with the following?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d1c99e2-0764-4bd2-b498-85c78ee241d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the netCDF file\n",
    "file_path = \"../data/MERRA2_400.tavg1_2d_lnd_Nx.20240401.nc4\"\n",
    "dataset = nc.Dataset(file_path)\n",
    "\n",
    "# Extract the variables\n",
    "lats = dataset.variables[\"lat\"][:]\n",
    "lons = dataset.variables[\"lon\"][:]\n",
    "temps = dataset.variables[\"TSURF\"][\n",
    "    0, :, :\n",
    "]  # Assuming the time dimension is the first dimension\n",
    "\n",
    "# Close the dataset\n",
    "dataset.close()\n",
    "\n",
    "# Create a figure\n",
    "fig, ax = plt.subplots(\n",
    "    2, 2, figsize=(12, 6), subplot_kw={\"projection\": ccrs.PlateCarree()}\n",
    ")\n",
    "\n",
    "# Plot the temperature data\n",
    "c = ax[0][0].pcolormesh(\n",
    "    lons,\n",
    "    lats,\n",
    "    temps,\n",
    "    shading=\"auto\",\n",
    "    transform=ccrs.PlateCarree(),\n",
    "    cmap=\"viridis\",\n",
    ")\n",
    "ax[0][0].coastlines()\n",
    "ax[0][0].set_xticks(np.arange(-180, 181, 20), crs=ccrs.PlateCarree())\n",
    "ax[0][0].set_yticks([-66.5, -23.5, 0, 23.5, 66.5], crs=ccrs.PlateCarree())\n",
    "ax[0][0].set_extent(\n",
    "    [-30, 40, 30, 80], crs=ccrs.PlateCarree()\n",
    ")  # Note use extent after setting ticks!\n",
    "plt.colorbar(c, ax=ax[0][0], label=\"Temperature\")\n",
    "\n",
    "c = ax[0][1].pcolormesh(\n",
    "    lons, lats, temps, shading=\"auto\", transform=ccrs.PlateCarree(), cmap=\"viridis\"\n",
    ")\n",
    "ax[0][1].coastlines()\n",
    "ax[0][1].set_xticks(np.arange(-180, 181, 20), crs=ccrs.PlateCarree())\n",
    "ax[0][1].set_yticks([-66.5, -23.5, 0, 23.5, 66.5], crs=ccrs.PlateCarree())\n",
    "ax[0][1].set_extent(\n",
    "    [-160, -50, 20, 80], crs=ccrs.PlateCarree()\n",
    ")  # Note use extent after setting ticks!\n",
    "plt.colorbar(c, ax=ax[0][1], label=\"Temperature\")\n",
    "\n",
    "c = ax[1][0].pcolormesh(\n",
    "    lons, lats, temps, shading=\"auto\", transform=ccrs.PlateCarree(), cmap=\"viridis\"\n",
    ")\n",
    "ax[1][0].coastlines()\n",
    "ax[1][0].set_xticks(np.arange(-180, 181, 20), crs=ccrs.PlateCarree())\n",
    "ax[1][0].set_yticks([-66.5, -23.5, 0, 23.5, 66.5], crs=ccrs.PlateCarree())\n",
    "ax[1][0].set_extent(\n",
    "    [110, 180, -50, 0], crs=ccrs.PlateCarree()\n",
    ")  # Note use extent after setting ticks!\n",
    "plt.colorbar(c, ax=ax[1][0], label=\"Temperature\")\n",
    "\n",
    "c = ax[1][1].pcolormesh(\n",
    "    lons, lats, temps, shading=\"auto\", transform=ccrs.PlateCarree(), cmap=\"viridis\"\n",
    ")\n",
    "ax[1][1].coastlines()\n",
    "ax[1][1].set_xticks(np.arange(-180, 181, 20), crs=ccrs.PlateCarree())\n",
    "ax[1][1].set_yticks([-66.5, -23.5, 0, 23.5, 66.5], crs=ccrs.PlateCarree())\n",
    "ax[1][1].set_extent(\n",
    "    [-20, 50, -40, 40], crs=ccrs.PlateCarree()\n",
    ")  # Note use extent after setting ticks!\n",
    "plt.colorbar(c, ax=ax[1][1], label=\"Temperature\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c125572e-d365-4012-b85a-adf0e67d58f3",
   "metadata": {},
   "source": [
    "### Better:\n",
    "\n",
    "By taking the repeated code and placing it in a function call we can change all plots from a single place, fine-tuning with the `**kwargs` functionalities.\\\n",
    "Note also the use of `ax.ravel()` to loop over subplots.\n",
    "\n",
    "Try changing some of the \"global\" settings and see how they are reflected across all plots.\n",
    "Think about how this would have been done in the above version of the code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0ff86fb-aca0-4902-8748-4b79eeae2d84",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the netCDF file\n",
    "file_path = \"../data/MERRA2_400.tavg1_2d_lnd_Nx.20240401.nc4\"\n",
    "dataset = nc.Dataset(file_path)\n",
    "\n",
    "# Extract the variables\n",
    "lats = dataset.variables[\"lat\"][:]\n",
    "lons = dataset.variables[\"lon\"][:]\n",
    "temps = dataset.variables[\"TSURF\"][\n",
    "    0, :, :\n",
    "]  # Assuming the time dimension is the first dimension\n",
    "\n",
    "# Close the dataset\n",
    "dataset.close()\n",
    "\n",
    "\n",
    "def plot_section(axis, lons, lats, temps, extent=None, **kwargs):\n",
    "    \"\"\"Plot temperature data on a subplot with specified extent.\"\"\"\n",
    "    c = axis.pcolormesh(\n",
    "        lons, lats, temps, shading=\"auto\", transform=ccrs.PlateCarree(), **kwargs\n",
    "    )\n",
    "    axis.coastlines()\n",
    "    axis.set_xticks(np.arange(-180, 181, 20), crs=ccrs.PlateCarree())\n",
    "    axis.set_yticks([-66.5, -23.5, 0, 23.5, 66.5], crs=ccrs.PlateCarree())\n",
    "    if extent is not None:\n",
    "        axis.set_extent(\n",
    "            extent, crs=ccrs.PlateCarree()\n",
    "        )  # Note use extent after setting ticks!\n",
    "    plt.colorbar(c, ax=axis, label=\"Temperature\")\n",
    "\n",
    "\n",
    "# Create a figure\n",
    "fig, ax = plt.subplots(\n",
    "    2, 2, figsize=(12, 6), subplot_kw={\"projection\": ccrs.PlateCarree()}\n",
    ")\n",
    "\n",
    "extents = [\n",
    "    [-30, 40, 30, 80],\n",
    "    [-160, -50, 20, 80],\n",
    "    [110, 180, -50, 0],\n",
    "    [-20, 50, -40, 40],\n",
    "]\n",
    "\n",
    "# Plot the temperature data\n",
    "for i, axis in enumerate(ax.ravel()):\n",
    "    plot_section(\n",
    "        axis, lons, lats, temps, extent=extents[i], cmap=\"viridis\", vmin=230, vmax=330\n",
    "    )\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2af958b5-dbfe-4e56-8f69-8029417aed21",
   "metadata": {},
   "source": [
    "## Exercise 8) Colormaps\n",
    "\n",
    "### 8) a) Types of colormaps\n",
    "\n",
    "The following function converts a colormap to show how it will appear when rendered greyscale.\\\n",
    "Whilst this is less important today, it is still a useful consideration, and can help illustrate how images might appear to those without perfect vision.\n",
    "\n",
    "The plot in the following cell shows the surface temperature from our dataset plotted with different colormaps.\n",
    "\n",
    "Consult the different colormaps available at https://matplotlib.org/stable/users/explain/colors/colormaps.html and try different options."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91b5c97a-f0af-429f-824e-702ba35eb976",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adapted from https://jakevdp.github.io/blog/2014/10/16/how-bad-is-your-colormap/\n",
    "\n",
    "import matplotlib.colors as mpc\n",
    "\n",
    "\n",
    "def grayify_cmap(cmap):\n",
    "    \"\"\"Return a grayscale version of a colormap.\"\"\"\n",
    "    cmap = plt.get_cmap(cmap)\n",
    "    colors = cmap(np.arange(cmap.N))\n",
    "\n",
    "    # convert RGBA to perceived greyscale luminance\n",
    "    # cf. http://alienryderflex.com/hsp.html\n",
    "    RGB_weight = [0.299, 0.587, 0.114]\n",
    "    luminance = np.sqrt(np.dot(colors[:, :3] ** 2, RGB_weight))\n",
    "    colors[:, :3] = luminance[:, np.newaxis]\n",
    "\n",
    "    return mpc.LinearSegmentedColormap.from_list(\n",
    "        cmap.name + \"_grayscale\", colors, cmap.N\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86679f4e-0995-4834-9cce-d4d0b553696f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the netCDF file\n",
    "file_path = \"../data/MERRA2_400.tavg1_2d_lnd_Nx.20240401.nc4\"\n",
    "dataset = nc.Dataset(file_path)\n",
    "\n",
    "# Extract the variables\n",
    "lats = dataset.variables[\"lat\"][:]\n",
    "lons = dataset.variables[\"lon\"][:]\n",
    "temps = dataset.variables[\"TSURF\"][\n",
    "    0, :, :\n",
    "]  # Assuming the time dimension is the first dimension\n",
    "\n",
    "# Close the dataset\n",
    "dataset.close()\n",
    "\n",
    "# Create a figure\n",
    "fig, ax = plt.subplots(2, 3, figsize=(12, 6), sharex=\"col\", sharey=\"row\")\n",
    "\n",
    "cmaps = [\"jet\", \"viridis\", \"bwr\"]\n",
    "\n",
    "for i in range(3):\n",
    "    # Plot the temperature data\n",
    "    c1 = ax[0][i].pcolormesh(\n",
    "        lons, lats, temps, shading=\"auto\", cmap=cmaps[i], vmin=240, vmax=320\n",
    "    )\n",
    "    plt.colorbar(c1, ax=ax[0][i], label=\"Temperature\")\n",
    "\n",
    "    c2 = ax[1][i].pcolormesh(\n",
    "        lons,\n",
    "        lats,\n",
    "        temps,\n",
    "        shading=\"auto\",\n",
    "        cmap=grayify_cmap(cmaps[i]),\n",
    "        vmin=240,\n",
    "        vmax=320,\n",
    "    )\n",
    "    plt.colorbar(c2, ax=ax[1][i], label=\"Temperature\")\n",
    "\n",
    "    ax[0][i].set_title(cmaps[i])\n",
    "\n",
    "# Set labels\n",
    "for i in range(3):\n",
    "    ax[-1][i].set_xlabel(\"Longitude\")\n",
    "for i in range(2):\n",
    "    ax[i][0].set_ylabel(\"Latitude\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fa9a3bc-db3a-4cf6-ae8b-27ca2f5914a8",
   "metadata": {},
   "source": [
    "## 8) b) cmocean package\n",
    "\n",
    "The code below will output the different options for cmocean colormaps.\n",
    "These can then be accessed by passing a string to the plotting `cmap` argument with the cmocean library and colormap name connected with a `.`\n",
    "\n",
    "You can see the cmocean maps at https://matplotlib.org/cmocean/\n",
    "You can also explore the native matplotlib options at https://matplotlib.org/stable/users/explain/colors/colormaps.html\n",
    "\n",
    "Print the available colormaps below, then return to the above exercise and explore some of the options."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "79f21f96-3535-45bc-9497-d2e71a69e8b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "import cmocean as cmo\n",
    "\n",
    "print(cmo.cm.cmapnames)\n",
    "\n",
    "cmaps = [\"cmo.thermal\", \"cmo.ice\", \"cmo.algae\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bab2118-ddfc-4d6a-8e40-7e0972604c75",
   "metadata": {},
   "source": [
    "## 8) c) Custom Colormaps (optional)\n",
    "\n",
    "Setting up a colormap\n",
    "RGB colormap generator: https://jdherman.github.io/colormap/ \\\n",
    "Use the plaintext and RGB options, and copy this to the file \"`my_colormap.cmap`\"\n",
    "\n",
    "We will read this in and convert it to a Matplotlib colormap in the `my_cmap` object.\n",
    "Once this has been done you can use this in plots (try it above) by setting `cmap=my_cmap`.\n",
    "\n",
    "Generate your custom colormaps and see how this affects the display of the data.\n",
    "Share your best/wackiest images on slack."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32203ad9-be02-4ab8-95dd-87236e44fcd0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load colormap array in from file and cast to a Matplotlib colormap\n",
    "cmap_array = np.loadtxt(\"my_colormap.cmap\", delimiter=\" \")\n",
    "my_cmap = mpc.ListedColormap(cmap_array / 255.0)\n",
    "\n",
    "# Plot the colormap to visualise\n",
    "gradient = np.linspace(0, 1, 256)\n",
    "gradient = np.vstack((gradient, gradient))\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(8, 0.5))\n",
    "ax.imshow(gradient, aspect=\"auto\", cmap=my_cmap)\n",
    "ax.get_yaxis().set_visible(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be3d6e0f-ea25-44a9-acc5-c026e2325e17",
   "metadata": {},
   "source": [
    "## 8) d) Adjusting the scale on a colormap (optional)\n",
    "\n",
    "Matplotlib norms documentation is available at: https://matplotlib.org/stable/users/explain/colors/colormapnorms.html\n",
    "\n",
    "Here are a few snippets from the slides to get you started:\n",
    "\n",
    "```python\n",
    "my_norm = mpc.Normalize(vmin=273, vmax=300, clip=True)\n",
    "my_norm = mpc.CenteredNorm(vcenter=286.5, halfrange=13.55)\n",
    "my_norm = mpc.LogNorm(vmin=273, vmax=300)\n",
    "my_norm = mpc.TwoSlopeNorm(vcenter=290, vmin=273, vmax=300)\n",
    "my_norm = mpc.PowerNorm(2, vmin=273, vmax=300)\n",
    "```\n",
    "\n",
    "Adjust the normalisation schemes used in the cell below to examine the effects of different norms on the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c0921ed-a515-4fb4-afd5-c0cecf842632",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the netCDF file\n",
    "file_path = \"../data/MERRA2_400.tavg1_2d_lnd_Nx.20240401.nc4\"\n",
    "dataset = nc.Dataset(file_path)\n",
    "\n",
    "# Extract the variables\n",
    "lats = dataset.variables[\"lat\"][:]\n",
    "lons = dataset.variables[\"lon\"][:]\n",
    "temps = dataset.variables[\"TSURF\"][\n",
    "    0, :, :\n",
    "]  # Assuming the time dimension is the first dimension\n",
    "\n",
    "# Close the dataset\n",
    "dataset.close()\n",
    "\n",
    "# Create a figure\n",
    "fig, axs = plt.subplots(1, 3, figsize=(12, 3), sharex=\"col\", sharey=\"row\")\n",
    "\n",
    "my_norms = [\n",
    "    mpc.Normalize(vmin=240, vmax=320),\n",
    "    mpc.Normalize(vmin=240, vmax=320, clip=True),\n",
    "    mpc.CenteredNorm(vcenter=280, halfrange=40),\n",
    "]\n",
    "\n",
    "for i, ax in enumerate(axs):\n",
    "    # Plot the temperature data\n",
    "    im = ax.pcolormesh(\n",
    "        lons, lats, temps, shading=\"auto\", cmap=\"cmo.thermal\", norm=my_norms[i]\n",
    "    )\n",
    "    plt.colorbar(im, ax=ax, label=\"Temperature\")\n",
    "    ax.set_xlabel(\"Longitude\")\n",
    "\n",
    "axs[0].set_ylabel(\"Latitude\")\n",
    "\n",
    "plt.show()"
   ]
  }
 ],
 "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
}