diff --git a/datasets/met-office/met-office-icechunk.ipynb b/datasets/met-office/met-office-icechunk.ipynb new file mode 100644 index 0000000..edc6e31 --- /dev/null +++ b/datasets/met-office/met-office-icechunk.ipynb @@ -0,0 +1,5734 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3ac0585d-4182-49cf-981d-023aa041c9e9", + "metadata": {}, + "source": [ + "## Loading Met Office Deterministic Forecast data into Icechunk\n", + "\n", + "The Met Office Deterministic collections have data for each variable and forecast time step stored in a separate NetCDF file. This makes querying the data somewhat cumbersome because you need to write a STAC search query then write the right incantation to load the assets of interest into an xarray Dataset or DataArray. This is a perfect application for a virtual representation of the collection in Icechunk that can simply be 'opened' by xarray and queried using the `sel` and `isel` methods." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "e2bd4455-b9ca-4e5a-9d67-fe8da13b7793", + "metadata": {}, + "outputs": [], + "source": [ + "import logging\n", + "from datetime import datetime, timedelta, UTC\n", + "from collections import defaultdict\n", + "from itertools import batched, groupby\n", + "from typing import Any\n", + "from urllib.parse import urlparse\n", + "\n", + "import icechunk as ic\n", + "import pystac_client\n", + "import xarray as xr\n", + "from dask.distributed import Client, LocalCluster\n", + "from icechunk.credentials import AzureRefreshableCredential\n", + "from obstore.auth.planetary_computer import PlanetaryComputerCredentialProvider\n", + "from obstore.store import AzureStore\n", + "from obspec_utils.readers import BufferedStoreReader\n", + "from obspec_utils.registry import ObjectStoreRegistry\n", + "from obspec_utils.wrappers import CachingReadableStore, SplittingReadableStore\n", + "from pystac import Collection, Item, ItemCollection\n", + "from tqdm import tqdm\n", + "from virtualizarr import open_virtual_dataset, open_virtual_mfdataset\n", + "from virtualizarr.parsers import HDFParser\n", + "\n", + "\n", + "STACType = dict[str, Any] | Item | ItemCollection | Collection" + ] + }, + { + "cell_type": "markdown", + "id": "534a6541-235a-478a-a9f3-eeed49cb3d02", + "metadata": {}, + "source": [ + "The Met Office STAC items have `https` asset hrefs which work fine in isolation but for the simplest integration with obspec-utils and icechunk we need to convert them to `abfs://` hrefs.\n", + "\n", + "See https://github.com/developmentseed/obspec-utils/issues/79 for a discussion on improving the handling of Azure Blob https links in obspec-utils.\n", + "\n", + "The following functions can be used to apply this modification to the asset hrefs as they are processed by pystac-client." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6ee39406-955c-4aaa-b4b4-70efe0a3e7bb", + "metadata": {}, + "outputs": [], + "source": [ + "def https_blob_to_abfs(url: str) -> tuple[str, str, str]:\n", + " \"\"\"Convert an Azure Blob HTTPS URL to an ABFS URL.\"\"\"\n", + " parsed = urlparse(url)\n", + " if parsed.scheme != \"https\" or not parsed.netloc.endswith(\".blob.core.windows.net\"):\n", + " raise ValueError(f\"Expected an Azure Blob HTTPS URL, got {url!r}\")\n", + "\n", + " account_name = parsed.netloc.split(\".\")[0]\n", + " container, blob_path = parsed.path.lstrip(\"/\").split(\"/\", 1)\n", + " return f\"abfs://{container}/{blob_path}\", account_name, container\n", + "\n", + "\n", + "def _rewrite_asset_dict_in_place(asset: dict[str, Any]) -> None:\n", + " href = asset.get(\"href\")\n", + " if not isinstance(href, str):\n", + " return\n", + "\n", + " parsed = urlparse(href)\n", + " if parsed.scheme != \"https\" or not parsed.netloc.endswith(\".blob.core.windows.net\"):\n", + " return\n", + "\n", + " abfs_href, _, _ = https_blob_to_abfs(href)\n", + " alternate = asset.setdefault(\"alternate\", {})\n", + " if isinstance(alternate, dict):\n", + " alternate.setdefault(\"https\", {\"href\": href})\n", + " asset[\"href\"] = abfs_href\n", + "\n", + "\n", + "def _rewrite_item_dict_in_place(item: dict[str, Any]) -> None:\n", + " assets = item.get(\"assets\")\n", + " if not isinstance(assets, dict):\n", + " return\n", + "\n", + " for asset in assets.values():\n", + " if isinstance(asset, dict):\n", + " _rewrite_asset_dict_in_place(asset)\n", + "\n", + "\n", + "def _rewrite_item_in_place(item: Item) -> None:\n", + " for asset in item.assets.values():\n", + " href = asset.href\n", + " parsed = urlparse(href)\n", + " if parsed.scheme != \"https\" or not parsed.netloc.endswith(\".blob.core.windows.net\"):\n", + " continue\n", + "\n", + " abfs_href, _, _ = https_blob_to_abfs(href)\n", + " alternate = asset.extra_fields.setdefault(\"alternate\", {})\n", + " if isinstance(alternate, dict):\n", + " alternate.setdefault(\"https\", {\"href\": href})\n", + " asset.href = abfs_href\n", + "\n", + "\n", + "def replace_https_with_abfs(obj: STACType) -> None:\n", + " \"\"\"Rewrite Azure Blob asset hrefs to ABFS in place for pystac-client.\"\"\"\n", + " if isinstance(obj, ItemCollection):\n", + " for item in obj.items:\n", + " _rewrite_item_in_place(item)\n", + " return\n", + "\n", + " if isinstance(obj, Item):\n", + " _rewrite_item_in_place(obj)\n", + " return\n", + "\n", + " if not isinstance(obj, dict):\n", + " return\n", + "\n", + " if obj.get(\"type\") == \"FeatureCollection\":\n", + " for feature in obj.get(\"features\", []):\n", + " if isinstance(feature, dict):\n", + " _rewrite_item_dict_in_place(feature)\n", + " return\n", + "\n", + " if obj.get(\"type\") == \"Feature\":\n", + " _rewrite_item_dict_in_place(obj)" + ] + }, + { + "cell_type": "markdown", + "id": "a7a1a231-1f89-4722-9fb4-705ae2003723", + "metadata": {}, + "source": [ + "Start by running a STAC search for a few days of historical Met Office zero-hour forecast (analysis) records from the UK Deterministic Near Surface collection. Each item contains a few dozen assets and each asset references a single NetCDF file with a single data variable. See the [comprehensive Met Office tutorial notebook](./met-office-forecast-data.ipynb) for a more complete description of the dataset's structure." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2f47a606-852c-4a8b-ba6b-8ea3c6ccebec", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "found 120 items\n", + "assets for 2026-06-01T00:00:00+00:00: ['landsea_mask', 'rainfall_rate', 'snowfall_rate', 'hail_fall_rate', 'wind_gust_at_10m', 'wind_speed_at_10m', 'precipitation_rate', 'height_of_orography', 'pressure_at_surface', 'wind_direction_at_10m', 'temperature_at_surface', 'pressure_at_mean_sea_level', 'visibility_at_screen_level', 'snow_depth_water_equivalent', 'temperature_at_screen_level', 'fog_fraction_at_screen_level', 'sensible_heat_flux_at_surface', 'relative_humidity_at_screen_level', 'radiation_flux_in_uv_downward_at_surface', 'temperature_of_dew_point_at_screen_level', 'radiation_flux_in_longwave_downward_at_surface', 'radiation_flux_in_shortwave_total_downward_at_surface', 'radiation_flux_in_shortwave_direct_downward_at_surface', 'radiation_flux_in_shortwave_diffuse_downward_at_surface']\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "
\n", + "
\n", + " <Asset href=abfs://deterministic/uk/near-surface/20260601T0000Z/20260601T0000Z-PT0000H00M-temperature_at_surface.nc>\n", + "
\n", + "\n", + "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "catalog = pystac_client.Client.open(\n", + " \"https://planetarycomputer.microsoft.com/api/stac/v1/\",\n", + " modifier=replace_https_with_abfs,\n", + ")\n", + "\n", + "search = catalog.search(\n", + " collections=\"met-office-uk-deterministic-near-surface\",\n", + " datetime=[datetime(2026, 6, 1, tzinfo=UTC), datetime(2026, 6, 6, tzinfo=UTC) - timedelta(seconds=1)],\n", + " filter_lang=\"cql2-json\",\n", + " filter={\n", + " \"op\": \"=\",\n", + " \"args\": [\n", + " {\"property\": \"forecast:horizon\"},\n", + " \"PT0000H00M\",\n", + " ],\n", + " },\n", + " sortby=\"datetime\",\n", + " limit=100,\n", + ")\n", + "\n", + "items = search.item_collection()\n", + "\n", + "print(f\"found {len(items)} items\")\n", + "\n", + "sample_item = items[0]\n", + "print(\n", + " f\"assets for {sample_item.datetime.isoformat()}:\",\n", + " list(sample_item.assets.keys()),\n", + ")\n", + "\n", + "sample_asset = sample_item.assets[\"temperature_at_surface\"]\n", + "sample_asset" + ] + }, + { + "cell_type": "markdown", + "id": "7beca6eb-0deb-4ad5-84a7-1ab40cf66cf4", + "metadata": {}, + "source": [ + "Now use a sample asset to configure object storage access for reading the raw data. \n", + "\n", + "The `PlanetaryComputerCredentialProvider` from obstore can be used to automatically generate SAS tokens for individual asset read operations." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e6aa8953-f859-400c-9eb8-48939534d0c0", + "metadata": {}, + "outputs": [], + "source": [ + "sample_asset_https_href = sample_asset.extra_fields[\"alternate\"][\"https\"][\"href\"]\n", + "_, account_name, container_name = https_blob_to_abfs(sample_asset_https_href)\n", + "\n", + "pc_credential_provider = PlanetaryComputerCredentialProvider(\n", + " f\"abfs://{container_name}\",\n", + " account_name=account_name,\n", + ")\n", + "\n", + "base_store = AzureStore(\n", + " container_name=container_name,\n", + " account_name=account_name,\n", + " credential_provider=pc_credential_provider,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "f957484f-ed20-4a21-ae8a-6b138288af0f", + "metadata": {}, + "source": [ + "Set up the object storage registry for virtualizarr. This configuration is based on a [virtualizarr GOES demo script](https://github.com/zarr-developers/VirtualiZarr/blob/b693e0d5d958338a9fd34a7a0c4cb5ad0369d4a6/examples/V2/goes_with_caching_stores.py)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "3c4cfdd8-802d-4068-b27a-ef3219895309", + "metadata": {}, + "outputs": [], + "source": [ + "splitting_store = SplittingReadableStore(base_store)\n", + "caching_store = CachingReadableStore(splitting_store, max_size=512 * 1024 * 1024)\n", + "\n", + "parser = HDFParser(\n", + " reader_factory=BufferedStoreReader\n", + ")\n", + "\n", + "registry = ObjectStoreRegistry({f\"abfs://{container_name}\": caching_store})" + ] + }, + { + "cell_type": "markdown", + "id": "2f9d8c45-f216-4339-88ee-e594032bf870", + "metadata": {}, + "source": [ + "Now open the assets for a single item as a virtual dataset. Each asset contains one data variable (and several other non-data variables)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d48aa8e7-11d6-4b68-be03-3a835d58fbe8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 658 ms, sys: 254 ms, total: 912 ms\n", + "Wall time: 12.9 s\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 97MB\n",
+       "Dimensions:                                              (time: 1,\n",
+       "                                                          projection_y_coordinate: 970,\n",
+       "                                                          projection_x_coordinate: 1042,\n",
+       "                                                          bnds: 2)\n",
+       "Coordinates:\n",
+       "  * time                                                 (time) datetime64[ns] 8B ...\n",
+       "    projection_y_coordinate                              (projection_y_coordinate) float32 4kB ManifestArray<shape=(970,), dtype=float...\n",
+       "    projection_x_coordinate                              (projection_x_coordinate) float32 4kB ManifestArray<shape=(1042,), dtype=float3...\n",
+       "    forecast_period                                      int32 4B ManifestArr...\n",
+       "    forecast_reference_time                              int64 8B ManifestArr...\n",
+       "    height                                               float32 4B ManifestA...\n",
+       "Dimensions without coordinates: bnds\n",
+       "Data variables: (12/27)\n",
+       "    land_binary_mask                                     (time, projection_y_coordinate, projection_x_coordinate) int32 4MB ManifestArray<shape=(1,...\n",
+       "    lambert_azimuthal_equal_area                         (time) int32 4B Mani...\n",
+       "    projection_y_coordinate_bnds                         (time, projection_y_coordinate, bnds) float32 8kB ManifestArray<shape=(1, 970, 2), dtyp...\n",
+       "    projection_x_coordinate_bnds                         (time, projection_x_coordinate, bnds) float32 8kB ManifestArray<shape=(1, 1042, 2), dtype...\n",
+       "    rainfall_rate                                        (time, projection_y_coordinate, projection_x_coordinate) float32 4MB ManifestArray<shape=(1,...\n",
+       "    lwe_snowfall_rate                                    (time, projection_y_coordinate, projection_x_coordinate) float32 4MB ManifestArray<shape=(1,...\n",
+       "    ...                                                   ...\n",
+       "    surface_downwelling_ultraviolet_flux_in_air          (time, projection_y_coordinate, projection_x_coordinate) float32 4MB ManifestArray<shape=(1,...\n",
+       "    dew_point_temperature                                (time, projection_y_coordinate, projection_x_coordinate) float32 4MB ManifestArray<shape=(1,...\n",
+       "    surface_downwelling_longwave_flux_in_air             (time, projection_y_coordinate, projection_x_coordinate) float32 4MB ManifestArray<shape=(1,...\n",
+       "    surface_downwelling_shortwave_flux_in_air            (time, projection_y_coordinate, projection_x_coordinate) float32 4MB ManifestArray<shape=(1,...\n",
+       "    surface_direct_downwelling_shortwave_flux_in_air     (time, projection_y_coordinate, projection_x_coordinate) float32 4MB ManifestArray<shape=(1,...\n",
+       "    surface_diffusive_downwelling_shortwave_flux_in_air  (time, projection_y_coordinate, projection_x_coordinate) float32 4MB ManifestArray<shape=(1,...\n",
+       "Attributes:\n",
+       "    history:                      2026-06-01T01:17:02Z: StaGE Decoupler\n",
+       "    institution:                  Met Office\n",
+       "    mosg__forecast_run_duration:  PT54H\n",
+       "    mosg__grid_domain:            uk_extended\n",
+       "    mosg__grid_type:              standard\n",
+       "    mosg__grid_version:           1.7.0\n",
+       "    mosg__model_configuration:    uk_det\n",
+       "    source:                       Met Office Unified Model\n",
+       "    title:                        UKV Model Forecast on UK 2 km Standard Grid\n",
+       "    um_version:                   13.8\n",
+       "    Conventions:                  CF-1.7, UKMO-1.0
" + ], + "text/plain": [ + " Size: 97MB\n", + "Dimensions: (time: 1,\n", + " projection_y_coordinate: 970,\n", + " projection_x_coordinate: 1042,\n", + " bnds: 2)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 8B ...\n", + " projection_y_coordinate (projection_y_coordinate) float32 4kB ManifestArray 0 else None)" + ] + }, + { + "cell_type": "markdown", + "id": "85a1879b-61bf-426a-bd32-7b55ee2797a5", + "metadata": {}, + "source": [ + "You can open a connection to the virtual array with several days worth of forecast hour zero with xarray! " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "a55f9274-c20d-482b-9c1c-fa1ee5b40093", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 12GB\n",
+       "Dimensions:                                              (time: 120,\n",
+       "                                                          projection_y_coordinate: 970,\n",
+       "                                                          projection_x_coordinate: 1042,\n",
+       "                                                          bnds: 2)\n",
+       "Coordinates:\n",
+       "  * time                                                 (time) datetime64[ns] 960B ...\n",
+       "  * projection_y_coordinate                              (projection_y_coordinate) float32 4kB ...\n",
+       "  * projection_x_coordinate                              (projection_x_coordinate) float32 4kB ...\n",
+       "    height                                               float32 4B ...\n",
+       "    forecast_period                                      int32 4B ...\n",
+       "    forecast_reference_time                              datetime64[ns] 8B ...\n",
+       "Dimensions without coordinates: bnds\n",
+       "Data variables: (12/27)\n",
+       "    air_temperature                                      (time, projection_y_coordinate, projection_x_coordinate) float32 485MB dask.array<chunksize=(1, 128, 128), meta=np.ndarray>\n",
+       "    fog_area_fraction                                    (time, projection_y_coordinate, projection_x_coordinate) float32 485MB dask.array<chunksize=(1, 128, 128), meta=np.ndarray>\n",
+       "    lwe_precipitation_rate                               (time, projection_y_coordinate, projection_x_coordinate) float32 485MB dask.array<chunksize=(1, 128, 128), meta=np.ndarray>\n",
+       "    lwe_graupel_and_hail_fall_rate                       (time, projection_y_coordinate, projection_x_coordinate) float32 485MB dask.array<chunksize=(1, 128, 128), meta=np.ndarray>\n",
+       "    dew_point_temperature                                (time, projection_y_coordinate, projection_x_coordinate) float32 485MB dask.array<chunksize=(1, 128, 128), meta=np.ndarray>\n",
+       "    air_pressure_at_sea_level                            (time, projection_y_coordinate, projection_x_coordinate) float32 485MB dask.array<chunksize=(1, 128, 128), meta=np.ndarray>\n",
+       "    ...                                                   ...\n",
+       "    surface_diffusive_downwelling_shortwave_flux_in_air  (time, projection_y_coordinate, projection_x_coordinate) float32 485MB dask.array<chunksize=(1, 128, 128), meta=np.ndarray>\n",
+       "    surface_downwelling_longwave_flux_in_air             (time, projection_y_coordinate, projection_x_coordinate) float32 485MB dask.array<chunksize=(1, 128, 128), meta=np.ndarray>\n",
+       "    surface_downwelling_ultraviolet_flux_in_air          (time, projection_y_coordinate, projection_x_coordinate) float32 485MB dask.array<chunksize=(1, 128, 128), meta=np.ndarray>\n",
+       "    surface_temperature                                  (time, projection_y_coordinate, projection_x_coordinate) float32 485MB dask.array<chunksize=(1, 128, 128), meta=np.ndarray>\n",
+       "    wind_speed_of_gust                                   (time, projection_y_coordinate, projection_x_coordinate) float32 485MB dask.array<chunksize=(1, 128, 128), meta=np.ndarray>\n",
+       "    wind_speed                                           (time, projection_y_coordinate, projection_x_coordinate) float32 485MB dask.array<chunksize=(1, 128, 128), meta=np.ndarray>\n",
+       "Attributes:\n",
+       "    history:                      2026-06-05T21:05:50Z: StaGE Decoupler\n",
+       "    institution:                  Met Office\n",
+       "    mosg__forecast_run_duration:  PT12H\n",
+       "    mosg__grid_domain:            uk_extended\n",
+       "    mosg__grid_type:              standard\n",
+       "    mosg__grid_version:           1.7.0\n",
+       "    mosg__model_configuration:    uk_det\n",
+       "    source:                       Met Office Unified Model\n",
+       "    title:                        UKV Model Forecast on UK 2 km Standard Grid\n",
+       "    um_version:                   13.8\n",
+       "    Conventions:                  CF-1.7, UKMO-1.0
" + ], + "text/plain": [ + " Size: 12GB\n", + "Dimensions: (time: 120,\n", + " projection_y_coordinate: 970,\n", + " projection_x_coordinate: 1042,\n", + " bnds: 2)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 960B ...\n", + " * projection_y_coordinate (projection_y_coordinate) float32 4kB ...\n", + " * projection_x_coordinate (projection_x_coordinate) float32 4kB ...\n", + " height float32 4B ...\n", + " forecast_period int32 4B ...\n", + " forecast_reference_time datetime64[ns] 8B ...\n", + "Dimensions without coordinates: bnds\n", + "Data variables: (12/27)\n", + " air_temperature (time, projection_y_coordinate, projection_x_coordinate) float32 485MB dask.array\n", + " fog_area_fraction (time, projection_y_coordinate, projection_x_coordinate) float32 485MB dask.array\n", + " lwe_precipitation_rate (time, projection_y_coordinate, projection_x_coordinate) float32 485MB dask.array\n", + " lwe_graupel_and_hail_fall_rate (time, projection_y_coordinate, projection_x_coordinate) float32 485MB dask.array\n", + " dew_point_temperature (time, projection_y_coordinate, projection_x_coordinate) float32 485MB dask.array\n", + " air_pressure_at_sea_level (time, projection_y_coordinate, projection_x_coordinate) float32 485MB dask.array\n", + " ... ...\n", + " surface_diffusive_downwelling_shortwave_flux_in_air (time, projection_y_coordinate, projection_x_coordinate) float32 485MB dask.array\n", + " surface_downwelling_longwave_flux_in_air (time, projection_y_coordinate, projection_x_coordinate) float32 485MB dask.array\n", + " surface_downwelling_ultraviolet_flux_in_air (time, projection_y_coordinate, projection_x_coordinate) float32 485MB dask.array\n", + " surface_temperature (time, projection_y_coordinate, projection_x_coordinate) float32 485MB dask.array\n", + " wind_speed_of_gust (time, projection_y_coordinate, projection_x_coordinate) float32 485MB dask.array\n", + " wind_speed (time, projection_y_coordinate, projection_x_coordinate) float32 485MB dask.array\n", + "Attributes:\n", + " history: 2026-06-05T21:05:50Z: StaGE Decoupler\n", + " institution: Met Office\n", + " mosg__forecast_run_duration: PT12H\n", + " mosg__grid_domain: uk_extended\n", + " mosg__grid_type: standard\n", + " mosg__grid_version: 1.7.0\n", + " mosg__model_configuration: uk_det\n", + " source: Met Office Unified Model\n", + " title: UKV Model Forecast on UK 2 km Standard Grid\n", + " um_version: 13.8\n", + " Conventions: CF-1.7, UKMO-1.0" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "session = repo.readonly_session(\"main\")\n", + "\n", + "ds = xr.open_zarr(session.store, zarr_format=3, consolidated=False)\n", + "ds" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "f449ca97-6b78-433d-9e6e-c6f88f5b414d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ds[\"air_temperature\"].isel(projection_x_coordinate=100, projection_y_coordinate=100).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "c3393999-f1a0-44f5-a9cd-b0e10e1afee9", + "metadata": {}, + "outputs": [], + "source": [ + "! rm -r /tmp/metoffice-deterministic-uk-local/" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7d816beb-08aa-4ce4-80ae-8ce7683c4a52", + "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.13.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}