diff --git a/RELEASE_NOTES.rst b/RELEASE_NOTES.rst old mode 100755 new mode 100644 index 1583d28c..7ba561c3 --- a/RELEASE_NOTES.rst +++ b/RELEASE_NOTES.rst @@ -24,6 +24,12 @@ Upcoming Release * Fix backwards compatibility of ``aggregate_matrix``. +**Features** + +* Add an Earth Data Hub (EDH) source for ERA5 as a new dataset ``atlite/datasets/era5_edh.py``. + EDH provides data without a processing queue. + + `v0.6.0 `__ (15th April 2026) ======================================================================================= diff --git a/atlite/datasets/__init__.py b/atlite/datasets/__init__.py index 045c59d8..edb2f008 100644 --- a/atlite/datasets/__init__.py +++ b/atlite/datasets/__init__.py @@ -6,6 +6,11 @@ atlite datasets. """ -from atlite.datasets import era5, gebco, sarah +from atlite.datasets import era5, era5_edh, gebco, sarah -modules = {"era5": era5, "sarah": sarah, "gebco": gebco} +modules = { + "era5": era5, + "era5-edh": era5_edh, + "sarah": sarah, + "gebco": gebco, +} diff --git a/atlite/datasets/era5_edh.py b/atlite/datasets/era5_edh.py new file mode 100644 index 00000000..2b1302b6 --- /dev/null +++ b/atlite/datasets/era5_edh.py @@ -0,0 +1,523 @@ +# SPDX-FileCopyrightText: Contributors to atlite +# +# SPDX-License-Identifier: MIT +""" +Download ERA5 data from the Earth Data Hub (EDH). + +EDH stores a mirror of ERA5 in a Zarr format. Dataset parameters: + +- URL: https://data.earthdatahub.destine.eu/era5/reanalysis-era5-single-levels-v0.zarr +- Auth: .netrc in the user's home directory. +- Time coordinate: ``valid_time``, hourly, from 1940-01-01 to the present. +- Latitude: descending from 90.0 to -90.0 in 0.25 degree steps, 721 points. +- Longitude: ascending from 0.0 to 359.75 in 0.25 degree steps, 1440 points. +- Native chunks: ``valid_time=4320, latitude=64, longitude=64``. +""" + +from __future__ import annotations + +import asyncio +import logging +import warnings +from collections.abc import Callable +from pathlib import Path +from typing import TYPE_CHECKING + +import numpy as np +import pandas as pd +import xarray as xr +import zarr +from dask.utils import SerializableLock +from fsspec.implementations.http import HTTPFileSystem + +from atlite.datasets.era5 import ( + _add_height, + sanitize_influx, + sanitize_runoff, + sanitize_wind, +) +from atlite.pv.solar_position import SolarPosition + +if TYPE_CHECKING: + from atlite.cutout import Cutout + + +Handler = Callable[["Cutout"], xr.Dataset] +Sanitizer = Callable[[xr.Dataset], xr.Dataset] + + +logger = logging.getLogger(__name__) + +crs = 4326 + +features: dict[str, list[str]] = { + "height": ["height"], + "wind": ["wnd100m", "wnd_shear_exp", "wnd_azimuth", "roughness"], + "influx": [ + "influx_toa", + "influx_direct", + "influx_diffuse", + "albedo", + "solar_altitude", + "solar_azimuth", + ], + "temperature": ["temperature", "soil temperature", "dewpoint temperature"], + "runoff": ["runoff"], +} + +static_features: set[str] = {"height"} + + +# Per-feature raw variables to pull from the EDH zarr. +_FEATURE_VARS: dict[str, list[str]] = { + "wind": ["u10", "v10", "u100", "v100", "fsr"], + "influx": ["ssrd", "ssr", "fdir", "tisr"], + "temperature": ["t2m", "d2m", "stl4"], + "runoff": ["ro"], + "height": ["z"], +} + + +_EDH_URL = ( + "https://data.earthdatahub.destine.eu/era5/reanalysis-era5-single-levels-v0.zarr" +) + + +class _RetryingHTTPFileSystem(HTTPFileSystem): + """ + ``HTTPFileSystem`` that retries transient transport errors on chunk reads. + + The EDH dataset is accessed via Zarr over HTTPS using an ``fsspec`` filesystem. + The default HTTPFileSystem in Zarr doesn't implement retries. On large downloads + this can crash a whole cutout. This class patches the default filesystem to + retry on errors caused by transient connection issues. + """ + + _retry_attempts = 8 + _retry_statuses = {408, 425, 429, 500, 502, 503, 504} + + async def _cat_file(self, url, start=None, end=None, **kwargs): # type: ignore[no-untyped-def] + import aiohttp + + transient = ( + aiohttp.ClientPayloadError, + aiohttp.ClientConnectionError, + aiohttp.ClientResponseError, + TimeoutError, + ) + for attempt in range(self._retry_attempts): + try: + return await super()._cat_file(url, start=start, end=end, **kwargs) + except transient as exc: + if ( + isinstance(exc, aiohttp.ClientResponseError) + and exc.status not in self._retry_statuses + ): + raise + if attempt == self._retry_attempts - 1: + raise + delay = min(2**attempt, 30) + logger.warning( + f"EDH chunk fetch failed ({exc!r}); retry " + f"{attempt + 1}/{self._retry_attempts - 1} in {delay}s" + ) + await asyncio.sleep(delay) + + +def _open_edh() -> xr.Dataset: + """ + Open the ERA5 dataset hosted on Earth Data Hub. + + Returns + ------- + xarray.Dataset + Dataset object, dask-backed with the store's native + ``(4320, 64, 64)`` chunks. + """ + # trust_env: lets aiohttp pick up the EDH credentials from ~/.netrc. + # Use a patched HTTPFileSystem to allow for retries. + fs = _RetryingHTTPFileSystem(asynchronous=True, client_kwargs={"trust_env": True}) + store = zarr.storage.FsspecStore(fs, read_only=True, path=_EDH_URL) + ds = xr.open_dataset(store, chunks={}, engine="zarr") + # get rid of unnecessary coordinates + for coord in ("number", "surface"): + if coord in ds.coords: + ds = ds.reset_coords(coord, drop=True) + return ds + + +def _subset_spatial(ds: xr.Dataset, cutout: Cutout) -> xr.Dataset: + """ + Select the cutout's bounding box and convert from atlite coordinates to + EDH coordinates. + + atlite coordinate system: + - x: -180:180 + - y: -90:90 + + EDH coordinate system: + - x: 0:360 + - y: 90:-90 + + Parameters + ---------- + ds : xarray.Dataset + Dataset on the EDH grid with descending ``latitude`` coordinates and + ascending ``longitude`` coordinates in the half-open interval + ``[0, 360)``. + cutout : atlite.Cutout + Cutout defining the target bbox via its ``x``/``y`` coords. + + Returns + ------- + xarray.Dataset + Subset with ``latitude`` (descending) and ``longitude`` + rewrapped to -180..180 ascending. + """ + x = cutout.coords["x"].values + y = cutout.coords["y"].values + + x_lo = float(x.min()) % 360 + x_hi = float(x.max()) % 360 + if x_lo <= x_hi: + sub = ds.sel(longitude=slice(x_lo, x_hi)) + else: + # bbox straddles the 0/360 seam — fetch the two halves and concat. + east = ds.sel(longitude=slice(x_lo, 360.0)) + west = ds.sel(longitude=slice(0.0, x_hi)) + sub = xr.concat([east, west], dim="longitude") + + sub = sub.sel(latitude=slice(float(y.max()), float(y.min()))) + new_lon = ((sub.longitude + 180) % 360) - 180 + # Rewrapping can leave longitude non-monotonic (wide seam-straddling + # bboxes); sort so downstream slicing and grid logic stay correct. + return sub.assign_coords(longitude=new_lon).sortby("longitude") + + +def _subset_temporal(ds: xr.Dataset, cutout: Cutout) -> xr.Dataset: + """ + Select the cutout's time slice. + + Parameters + ---------- + ds : xarray.Dataset + Dataset with a ``valid_time`` coordinate. + cutout : atlite.Cutout + Cutout defining the target time range. + + Returns + ------- + xarray.Dataset + Subset with the time axis renamed to ``time``. + """ + t = cutout.coords["time"].values + sub = ds.sel(valid_time=slice(t[0], t[-1])) + return sub.rename({"valid_time": "time"}) + + +def _rename_and_clean_coords(ds: xr.Dataset, cutout: Cutout) -> xr.Dataset: + """ + Rename ``latitude``/``longitude`` to atlite's ``y``/``x`` and apply the + cutout's dask chunking. + + Parameters + ---------- + ds : xarray.Dataset + Dataset with ``latitude`` and ``longitude`` coords, already subset to + the cutout's bbox and time range. + cutout : atlite.Cutout + Cutout whose ``chunks`` (set via ``Cutout(..., chunks=...)``) control + the dask block size of the returned data, mirroring how the ``era5`` + (CDS) module threads ``cutout.chunks`` into its readers. + + Returns + ------- + xarray.Dataset + Dataset with ``y``, ``x`` (rounded to 5 decimals, both ascending) and + ``lat``/``lon`` aliases, rechunked to ``cutout.chunks``. + + Notes + ----- + The rechunk runs here, on the already-subset array, not on the raw store. + ``ds`` now spans only the cutout (a few native time chunks), so the + rechunk graph is small. Rechunking the full 1940..today store instead + would build a multi-million-task graph and exhaust memory. + """ + ds = ds.rename({"latitude": "y", "longitude": "x"}) + # EDH stores latitude descending; atlite expects ascending. + ds = ds.isel(y=slice(None, None, -1)) + ds = ds.assign_coords( + x=np.round(ds.x.astype(float), 5), + y=np.round(ds.y.astype(float), 5), + ) + ds = ds.assign_coords(lon=ds.coords["x"], lat=ds.coords["y"]) + chunks = {k: v for k, v in (cutout.chunks or {}).items() if k in ds.dims} + if chunks: + # unify_chunks reconciles the 1-D index coordinates -- which .chunk() + # turns into single-chunk dask arrays -- with data variables whose + # spatial dims may be multi-chunk, e.g. after the 0/360 seam concat + # in _subset_spatial. + ds = ds.chunk(chunks).unify_chunks() + return ds + + +def _load_feature(cutout: Cutout, feature: str, static: bool = False) -> xr.Dataset: + """ + Open the EDH store, pull the feature's raw variables and subset them to + the cutout's bbox (and time range, unless ``static``). + + Parameters + ---------- + cutout : atlite.Cutout + Cutout defining the target grid and time range. + feature : str + Feature name; key into ``_FEATURE_VARS``. + static : bool, optional + If True, collapse the time axis to its first step and skip the + temporal subset (for time-invariant features such as ``height``). + + Returns + ------- + xarray.Dataset + Raw feature variables on atlite's ``y``/``x`` grid, rechunked to + ``cutout.chunks``. + """ + ds = _open_edh()[_FEATURE_VARS[feature]] + if static: + ds = ds.isel(valid_time=0, drop=True) + ds = _subset_spatial(ds, cutout) + if not static: + ds = _subset_temporal(ds, cutout) + return _rename_and_clean_coords(ds, cutout) + + +def get_data_wind(cutout: Cutout) -> xr.Dataset: + """ + Retrieve and prepare wind variables. + + Parameters + ---------- + cutout : atlite.Cutout + Cutout defining the target grid and time range. + + Returns + ------- + xarray.Dataset + Dataset containing ``wnd100m``, ``wnd_shear_exp``, ``wnd_azimuth`` and + ``roughness``. + """ + ds = _load_feature(cutout, "wind") + + for h in (10, 100): + ds[f"wnd{h}m"] = np.sqrt(ds[f"u{h}"] ** 2 + ds[f"v{h}"] ** 2).assign_attrs( + units="m s**-1", long_name=f"{h} metre wind speed" + ) + # Dividing by the float64 scalar np.log(0.1) promotes the result to + # float64; cast back to float32 -- the shear exponent needs no more. + ds["wnd_shear_exp"] = ( + (np.log(ds["wnd10m"] / ds["wnd100m"]) / np.log(10 / 100)) + .astype(np.float32) + .assign_attrs(units="", long_name="wind shear exponent") + ) + + # span the whole circle: 0 is north, π/2 east, π south, 3π/2 west. The + # `+ 2π` float64 scalar promotes the result; cast back to float32. + azimuth = np.arctan2(ds["u100"], ds["v100"]) + ds["wnd_azimuth"] = azimuth.where(azimuth >= 0, azimuth + 2 * np.pi).astype( + np.float32 + ) + + ds = ds.drop_vars(["u100", "v100", "u10", "v10", "wnd10m"]) + ds = ds.rename({"fsr": "roughness"}) + ds["roughness"] = ds["roughness"].assign_attrs( + units="m", long_name="Forecast surface roughness" + ) + return ds + + +def get_data_influx(cutout: Cutout) -> xr.Dataset: + """ + Retrieve and prepare solar influx variables. + + Parameters + ---------- + cutout : atlite.Cutout + Cutout defining the target grid and time range. + + Returns + ------- + xarray.Dataset + Dataset containing ``influx_toa``, ``influx_direct``, ``influx_diffuse``, + ``albedo``, ``solar_altitude`` and ``solar_azimuth``. + """ + ds = _load_feature(cutout, "influx") + + ds = ds.rename({"fdir": "influx_direct", "tisr": "influx_toa"}) + ds["albedo"] = ( + ((ds["ssrd"] - ds["ssr"]) / ds["ssrd"].where(ds["ssrd"] != 0)) + .fillna(0.0) + .assign_attrs(units="(0 - 1)", long_name="Albedo") + ) + ds["influx_diffuse"] = (ds["ssrd"] - ds["influx_direct"]).assign_attrs( + units="J m**-2", long_name="Surface diffuse solar radiation downwards" + ) + ds = ds.drop_vars(["ssrd", "ssr"]) + + for a in ("influx_direct", "influx_diffuse", "influx_toa"): + ds[a] = ds[a] / 3600.0 + ds[a].attrs["units"] = "W m**-2" + + # ERA5 radiation is the mean over the previous hour; centre solar position + # on the interval midpoint (see PyPSA/atlite#158). + with warnings.catch_warnings(): + warnings.simplefilter("ignore", DeprecationWarning) + sp = SolarPosition(ds, time_shift=pd.to_timedelta("-30 minutes")) + sp = sp.rename({v: f"solar_{v}" for v in sp.data_vars}) + # SolarPosition computes in float64; float32 is ample for stored solar + # geometry (~1e-6 rad) and halves these variables on disk. + sp = sp.astype(np.float32) + + return xr.merge([ds, sp]) + + +def get_data_temperature(cutout: Cutout) -> xr.Dataset: + """ + Retrieve and prepare temperature variables. + + Parameters + ---------- + cutout : atlite.Cutout + Cutout defining the target grid and time range. + + Returns + ------- + xarray.Dataset + Dataset containing ``temperature``, ``soil temperature`` and + ``dewpoint temperature``. + """ + ds = _load_feature(cutout, "temperature") + ds = ds.rename( + { + "t2m": "temperature", + "stl4": "soil temperature", + "d2m": "dewpoint temperature", + } + ) + for name in ("temperature", "soil temperature", "dewpoint temperature"): + ds[name].attrs["units"] = "K" + return ds + + +def get_data_runoff(cutout: Cutout) -> xr.Dataset: + """ + Retrieve and prepare runoff. + + Parameters + ---------- + cutout : atlite.Cutout + Cutout defining the target grid and time range. + + Returns + ------- + xarray.Dataset + Dataset containing ``runoff``. + """ + ds = _load_feature(cutout, "runoff") + ds = ds.rename({"ro": "runoff"}) + ds["runoff"].attrs["units"] = "m" + return ds + + +def get_data_height(cutout: Cutout) -> xr.Dataset: + """ + Retrieve and prepare surface height. + + Parameters + ---------- + cutout : atlite.Cutout + Cutout defining the target grid. + + Returns + ------- + xarray.Dataset + Dataset containing ``height``. + """ + ds = _load_feature(cutout, "height", static=True) + ds = _add_height(ds) + ds["height"].attrs["units"] = "m**2 s**-2" + return ds + + +_HANDLERS: dict[str, Handler] = { + "wind": get_data_wind, + "influx": get_data_influx, + "temperature": get_data_temperature, + "runoff": get_data_runoff, + "height": get_data_height, +} + +_SANITIZERS: dict[str, Sanitizer] = { + "wind": sanitize_wind, + "influx": sanitize_influx, + "runoff": sanitize_runoff, +} + + +def get_data( + cutout: Cutout, + feature: str, + tmpdir: str | Path | None = None, + lock: SerializableLock | None = None, + **creation_parameters: object, +) -> xr.Dataset: + """ + Retrieve ERA5 feature data from Earth Data Hub. + + Parameters + ---------- + cutout : atlite.Cutout + Cutout defining the target grid and time range. + feature : str + Feature name to retrieve. Must be one of ``features``. + tmpdir : str or pathlib.Path, optional + Unused; accepted for interface compatibility with + :func:`atlite.datasets.era5.get_data`. + lock : dask.utils.SerializableLock, optional + Unused; accepted for interface compatibility with + :func:`atlite.datasets.era5.get_data`. + **creation_parameters + Additional creation parameters. ``sanitize`` controls whether the + standard atlite sanitizers are applied (default True). + + Returns + ------- + xarray.Dataset + Prepared dataset for the requested feature. + + Raises + ------ + ValueError + If the cutout grid is not the native 0.25°×0.25°. + NotImplementedError + If ``feature`` is not yet implemented. + """ + native_res = 0.25 + if not (np.isclose(cutout.dx, native_res) and np.isclose(cutout.dy, native_res)): + raise ValueError( + "era5-edh only supports the native 0.25°×0.25° grid. " + "For other resolutions, use module='era5' (CDS)." + ) + if feature not in _HANDLERS: + raise NotImplementedError(f"Feature {feature!r} not supported by era5_edh") + + logger.info(f"Requesting data for feature {feature}...") + ds = _HANDLERS[feature](cutout) + + sanitize = creation_parameters.get("sanitize", True) + if sanitize and feature in _SANITIZERS: + ds = _SANITIZERS[feature](ds) + + if feature not in static_features: + ds = ds.sel(time=cutout.coords["time"]) + + return ds diff --git a/doc/examples/comparing_era5_sources_cds_vs_edh.nblink b/doc/examples/comparing_era5_sources_cds_vs_edh.nblink new file mode 100644 index 00000000..d803c332 --- /dev/null +++ b/doc/examples/comparing_era5_sources_cds_vs_edh.nblink @@ -0,0 +1,3 @@ +{ + "path": "../../examples/comparing_era5_sources_cds_vs_edh.ipynb" +} diff --git a/doc/index.rst b/doc/index.rst index 2e8aa7c1..f157a678 100644 --- a/doc/index.rst +++ b/doc/index.rst @@ -109,6 +109,7 @@ If you would like to cite the atlite software, please refer to `this paper `_ + +Climate data store (fallback) +------------------------------- + +1. Create an acocount at https://cds.climate.copernicus.eu/ +2. Go to https://cds.climate.copernicus.eu/how-to-api +3. Copy the text inside the code callout in the "Setup the CDS Api key" section +4. Save it in a file called ``.cdsapirc`` in your home folder. (No instructions for Windows users) + Computational resources ======================= diff --git a/doc/introduction.rst b/doc/introduction.rst index 11047f67..c82ce44b 100644 --- a/doc/introduction.rst +++ b/doc/introduction.rst @@ -88,15 +88,24 @@ Datasets The standard data source we currently employ is ECMWF's ERA5 dataset (reanalysis weather data in a ca. 30 km x 30 km and hourly resolution). This dataset is easily available at no additional costs and requires only -minimal setup from the user in comparison to other datasets. -It is downloaded automatically on-demand after the -`ECMWF ADS API `_ -(European Centre for Medium-Range Weather Forecasts Climate Data Store -Application Program Interface) client is properly installed. See separate, -linked installation guide for details, especially for correctly setting up -your CDS API key. - -Previously and in the future other datasets where and (hopefully) will +minimal setup from the user in comparison to other datasets. See :doc:`installation instructions ` to learn +how to set it up. + +We offer two methods for accessing ERA5. + +- Earth Data Hub hosts `a mirror `_ + of ERA5 which allows for immediate downloads. + It is the most convenient source for most users unless you need + to download the data at an unusual resolution. See `this example `_ + to learn how to use the EDH mirror and understand where it may not be the best choice. + +- ECMWF ADS API (European Centre for Medium-Range Weather Forecasts + Climate Data Store) is the original source for ERA5. Unfortunately, CDS + downloads may spend hours in a processing queue on the server, so we only recommend using the CDS source if you really need to. See + `this example `_ + to learn how to create an ERA5 cutout. + +Previously and in the future other datasets were and (hopefully) will again be usable, including * the *NCEP Climate Forecast System* dataset diff --git a/examples/comparing_era5_sources_cds_vs_edh.ipynb b/examples/comparing_era5_sources_cds_vs_edh.ipynb new file mode 100644 index 00000000..71fca17e --- /dev/null +++ b/examples/comparing_era5_sources_cds_vs_edh.ipynb @@ -0,0 +1,334 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "50b93f0d", + "metadata": {}, + "source": [ + "# Comparing ERA5 sources - CDS vs EDH" + ] + }, + { + "cell_type": "markdown", + "id": "37a413aa-4327-4bed-bc87-a6ef13163fae", + "metadata": {}, + "source": [ + "`atlite` offers two sources for the ERA5 dataset - CDS and EDH. ERA5 is natively hosted on the Copernicus Data Store, which offers many convenient options for server-side processing of the raw ERA5 data. However, it can only serve 400 simultaneous requests, so you often have to wait for hours in order to download data, which can be annoying and difficult to debug. \n", + "\n", + "The Earth Data Hub hosts a mirror of ERA5. They do not have a queue (although they still require authentication, see [installation instructions](https://atlite.readthedocs.io/en/master/installation.html)). However, they offer limited server-side processing, which means you need to download a bit more data, and do more processing on device. Some of the CDS server-side processing is difficult to mimic locally, especially interpolation to grids other than the default 0.25x0.25 deg grid, so, for a small subset of users, CDS is the best source. \n", + "\n", + "This table summarises the differences between the two datasets:\n", + "\n", + "| | CDS | EDH |\n", + "|----------------------|----------------------|---------------|\n", + "| atlite API | same | same |\n", + "| authentication/setup | API + accept license | API + accept license |\n", + "| download queue | 5min-8hrs | none |\n", + "| download size | 1x | ~1.5x |\n", + "| data storage grid | parameter-dependent | 0.25 deg. grid |\n", + "| results at 0.25 deg. grid | reference | within 1.5% (worst-case) |\n", + "\n", + "\n", + "> **So which source should I use?** For workflows that already used CDS, and when you require data at resolution that is not a multiple of the default 0.25/0.25 deg. grid, use CDS. For everything else, EDH is more convenient.\n", + "\n", + "In this example we will demonstrate how to use the EDH mirror of the ERA5 dataset within `atlite` and the minimal numerical differences between them. For a more detailed explanation on how to build cutouts, follow [this notebook](https://atlite.readthedocs.io/en/master/examples/create_cutout.html).\n", + "\n", + "We start with the setup:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "e1af6df1-27f5-4d80-bdcf-a20a040d3a6e", + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "from pathlib import Path\n", + "\n", + "import numpy as np\n", + "import xarray as xr\n", + "\n", + "import atlite\n", + "\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "markdown", + "id": "69550ec1-cfef-4c30-a6b6-58d3411cd833", + "metadata": {}, + "source": [ + "Let's download cutouts from both sources:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "788126e3-90d3-48b3-85a9-5c1cb8991750", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + " x = -4.00 ⟷ 1.50, dx = 0.25\n", + " y = 56.00 ⟷ 62.00, dy = 0.25\n", + " time = 2013-01-01 ⟷ 2013-01-01, dt = h\n", + " module = era5\n", + " prepared_features = ['height', 'wind', 'influx', 'temperature', 'runoff']" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "TIME = \"2013-01-01\"\n", + "BOUNDS = (-4, 56, 1.5, 62)\n", + "CACHE = Path(\".cache\")\n", + "CACHE.mkdir(exist_ok=True)\n", + "\n", + "cutout_CDS = atlite.Cutout(\n", + " path=CACHE / \"era5-cds-native.nc\",\n", + " module=\"era5\",\n", + " bounds=BOUNDS,\n", + " time=TIME,\n", + ")\n", + "cutout_CDS.prepare()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a6da6210-2e47-4796-84e9-1c36dbfa2f5b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + " x = -4.00 ⟷ 1.50, dx = 0.25\n", + " y = 56.00 ⟷ 62.00, dy = 0.25\n", + " time = 2013-01-01 ⟷ 2013-01-01, dt = h\n", + " module = era5-edh\n", + " prepared_features = ['height', 'wind', 'influx', 'temperature', 'runoff']" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cutout_EDH = atlite.Cutout(\n", + " path=CACHE / \"era5-edh-native.nc\",\n", + " module=\"era5-edh\",\n", + " bounds=BOUNDS,\n", + " time=TIME,\n", + ")\n", + "cutout_EDH.prepare(tmpdir=CACHE)" + ] + }, + { + "cell_type": "markdown", + "id": "8fa9a5e3-e944-41e7-aa30-2120ec0b0672", + "metadata": {}, + "source": [ + "As you can see, the API for both datasets is identical. The only change needed is replacing `module=\"era5\"` with `module=\"era5-edh\"`. EDH provides the same atlite-facing functionality, except that it only works at 0.25x0.25 deg resolution. Now let's investigate if the datasets provide the same data:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "650f7f9a-aaf5-423e-aac8-81c5516a33a4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Both cutouts have the same features: True\n", + "Data in both sources matches within tolerance (1.5%)\n" + ] + } + ], + "source": [ + "common_vars = set(cutout_CDS.data.data_vars) & set(cutout_EDH.data.data_vars)\n", + "\n", + "print(\n", + " \"Both cutouts have the same features:\",\n", + " common_vars == set(cutout_CDS.data.data_vars),\n", + ")\n", + "\n", + "rtol = 1.5e-2\n", + "try:\n", + " xr.testing.assert_allclose(\n", + " cutout_CDS.data[common_vars], cutout_EDH.data[common_vars], rtol=rtol\n", + " )\n", + " print(f\"Data in both sources matches within tolerance ({rtol * 100}%)\")\n", + "except Exception:\n", + " print(\"Data in both features is NOT identical\")" + ] + }, + { + "cell_type": "markdown", + "id": "dfdad175-9929-418d-8a2a-58e010098946", + "metadata": {}, + "source": [ + "The two datasets match well enough for atlite use (within 1.5%). The source of error is lossy compression on the EDH side. They use a [bitround](https://numcodecs.readthedocs.io/en/latest/filter/bitround.html) filter, which only stores 10 bits of each variable. The result is worst for height and temperature variables, as you can see below:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b5449977-8680-4b8b-971f-b19aad56fee8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wnd_azimuth 4.093647e-04\n", + "wnd_shear_exp 3.905668e-04\n", + "height 1.690674e-01\n", + "albedo 8.535162e-04\n", + "dewpoint temperature 1.250000e-01\n", + "solar_azimuth 2.384101e-07\n", + "temperature 1.250000e-01\n", + "influx_direct 3.556061e-02\n", + "roughness 2.440810e-04\n", + "soil temperature 1.248779e-01\n", + "influx_diffuse 1.066666e-01\n", + "wnd100m 7.616043e-03\n", + "runoff 0.000000e+00\n", + "influx_toa 7.113647e-02\n", + "solar_altitude 2.980201e-08\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "diff = abs(cutout_CDS.data[common_vars] - cutout_EDH.data[common_vars])\n", + "max_diff = diff.max().compute()\n", + "print(max_diff.to_pandas())" + ] + }, + { + "cell_type": "markdown", + "id": "5db72288-01a8-4788-b7f5-2b38fb87233c", + "metadata": {}, + "source": [ + "We can also plot relative differences on a graph:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a2393a4e-2d72-491b-902c-62dfe83e86bb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "WORST_DIFF_VARS = [\n", + " \"height\",\n", + " \"temperature\",\n", + " \"soil temperature\",\n", + "]\n", + "\n", + "\n", + "def scaled_max_abs_diff(reference, candidate):\n", + " diff = np.abs(candidate - reference)\n", + " scale = float(np.maximum(np.abs(reference), np.abs(candidate)).max(skipna=True))\n", + " reduce_dims = [dim for dim in diff.dims if dim not in {\"x\", \"y\"}]\n", + " diff_map = diff.max(dim=reduce_dims, skipna=True) if reduce_dims else diff\n", + " return 100 * diff_map.fillna(0) / scale\n", + "\n", + "\n", + "diff_maps = [\n", + " scaled_max_abs_diff(\n", + " cutout_CDS.data[var],\n", + " cutout_EDH.data[var],\n", + " ).assign_coords(variable=var)\n", + " for var in WORST_DIFF_VARS\n", + "]\n", + "\n", + "relative_max_diff = xr.concat(diff_maps, dim=\"variable\").rename(\n", + " \"scaled max absolute difference [%]\"\n", + ")\n", + "\n", + "grid = relative_max_diff.plot.pcolormesh(\n", + " x=\"x\",\n", + " y=\"y\",\n", + " col=\"variable\",\n", + " col_wrap=3,\n", + " cmap=\"magma\",\n", + " robust=True,\n", + " cbar_kwargs={\"label\": \"scaled max absolute difference [%]\"},\n", + ")\n", + "\n", + "for ax in grid.axs.flat:\n", + " ax.set_aspect(\"equal\", adjustable=\"box\")\n", + " ax.set_xlabel(\"longitude\")\n", + " ax.set_ylabel(\"latitude\")" + ] + }, + { + "attachments": { + "3e57f600-f351-4edf-a09d-b8704391441d.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "6976eb51-c590-4eab-af21-3c2dec35aa5e", + "metadata": {}, + "source": [ + "Once we actually calculate the renewable potentials, all the quantisations average out, resulting in a smaller relative difference. Over larger time and space the differences are negligible. Here is the 99-percentile difference in pv and wind capacity factors between CDS and EDH over Europe in 2013:\n", + "\n", + "![output.png](attachment:3e57f600-f351-4edf-a09d-b8704391441d.png)\n", + "\n", + "Hopefully that quells any doubts you may have had about using EDH data. And you learned a bit about compression as well!" + ] + }, + { + "cell_type": "markdown", + "id": "d70b3929-7ecf-48b9-b57c-f16401030aed", + "metadata": {}, + "source": [ + "> **The conclusion once again:** For workflows that already used CDS, and when you require data at resolution that is not a multiple of 0.25/0.25 deg. grid, use CDS. For everything else, EDH is more convenient. And the change from one to another is a single line of code." + ] + } + ], + "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 +} diff --git a/examples/comparing_era5_sources_cds_vs_edh.ipynb.license b/examples/comparing_era5_sources_cds_vs_edh.ipynb.license new file mode 100644 index 00000000..6bf7929c --- /dev/null +++ b/examples/comparing_era5_sources_cds_vs_edh.ipynb.license @@ -0,0 +1,3 @@ +SPDX-FileCopyrightText: Contributors to atlite + +SPDX-License-Identifier: MIT diff --git a/examples/create_cutout.ipynb b/examples/create_cutout.ipynb index 88209eb4..ed2b5262 100644 --- a/examples/create_cutout.ipynb +++ b/examples/create_cutout.ipynb @@ -12,12 +12,11 @@ "metadata": {}, "source": [ "In this example we download ERA5 data on-demand for a cutout we want to create.\n", - "(Atlite does also work with other datasources, but ERA5 is the easiest one to get started.)\n", + "(`atlite` does also work with other datasources, but ERA5 is the easiest one to get started.)\n", "\n", - "This only works if you have in before\n", + "Before you get started, make sure that you've followed the [installation instructions](https://atlite.readthedocs.io/en/latest/installation.html) to set up access to a dataset source.\n", "\n", - "* Installed the Copernicus Climate Data Store `cdsapi` package\n", - "* Registered and setup your CDS API key as described [on their website here](https://cds.climate.copernicus.eu/how-to-api)" + "> **Note** In this tutorial we use the CDS source for ERA5. All the operations below work just as well with the EDH source. EDH is much faster for most users. To use it, simply replace `module=\"era5\"` with `module='era5-edh` when calling `atlite.Cutout()`" ] }, { @@ -29,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -48,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -70,13 +69,14 @@ "The `cutout` is created in the directory and file specified by the relative `path`\n", "If a cutout at the given location already exists, then this command will simply load the cutout again.\n", "If the cutout does not yet exist, it will specify the new to-be-created cutout.\n", - "> **Note** `ERA5`, Before the data can be downloaded it has to be processed by CDS servers, this might take a while depending on the ammout of data requested. \n", + "\n", + "> **Note** if using the `era5` module, data has to be processed by CDS servers, before it can be downloaded. This might take a while depending on the ammount of data requested. \n", "You can check the status of your request [here](https://cds.climate.copernicus.eu/cdsapp#!/yourrequests)." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -90,7 +90,7 @@ "source": [ "cutout = atlite.Cutout(\n", " path=\"western-europe-2011-01.nc\",\n", - " module=\"era5\",\n", + " module=\"era5\", # or \"era5-edh\"\n", " x=slice(-13.6913, 1.7712),\n", " y=slice(49.9096, 60.8479),\n", " time=\"2011-01\",\n", @@ -103,7 +103,7 @@ "source": [ "For creating the cutout, you need to specify\n", "\n", - "* The dataset to create the cutout with (`era5`)\n", + "* The dataset to create the cutout with (`era5` or `era5-edh`)\n", "* The time period it covers\n", "* The longitude `x` and latitude `y` it stretches\n", "\n", @@ -142,7 +142,7 @@ "\n", "No matter which dataset you use, this is where all the work actually happens.\n", "This can be fast or take some or a lot of time and resources, among others depending on\n", - "your computer ressources and (for downloading e.g. ERA5 data) your internet connection." + "your computer resources and (for downloading e.g. ERA5 data) your internet connection." ] }, { @@ -1508,7 +1508,7 @@ "lastKernelId": null }, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -1522,7 +1522,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.12.3" } }, "nbformat": 4, diff --git a/pyproject.toml b/pyproject.toml index d7d3c952..23f05586 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -49,6 +49,9 @@ dependencies = [ "cdsapi>=0.7.4", "cfgrib>=0.9.15.0", "h5netcdf>=1.6.1", + "zarr>=2.18.3", + "eccodeslib>=2.46.2.19", + "aiohttp>=3.13.5", ] [project.urls] diff --git a/test/conftest.py b/test/conftest.py index 9dfb99a6..11a2a10c 100644 --- a/test/conftest.py +++ b/test/conftest.py @@ -19,6 +19,16 @@ CDS_API_CONFIGURED = bool(os.environ.get("CDSAPI_URL")) +def _edh_reachable() -> bool: + try: + import socket + + socket.create_connection(("data.earthdatahub.destine.eu", 443), timeout=10) + return True + except Exception: + return False + + def pytest_addoption(parser): parser.addoption( "--cache-path", @@ -184,6 +194,44 @@ def cutout_sarah_weird_resolution(cutouts_path): return cutout +def _prepare_era5_edh_cutout(path, prepare_kwargs=None, **kwargs): + cutout = Cutout(path=path, module="era5-edh", bounds=BOUNDS, **kwargs) + if not path.exists() and not _edh_reachable(): + pytest.skip("EDH not reachable and no cached cutout available") + cutout.prepare(tmpdir=str(path.parent), **(prepare_kwargs or {})) + return cutout + + +@pytest.fixture(scope="session") +def cutout_era5_edh(cutouts_path): + return _prepare_era5_edh_cutout(cutouts_path / "cutout_era5-edh.nc", time=TIME) + + +@pytest.fixture(scope="session") +def cutout_era5_edh_3h_sampling(cutouts_path): + time = [ + f"{TIME} 00:00", + f"{TIME} 03:00", + f"{TIME} 06:00", + f"{TIME} 09:00", + f"{TIME} 12:00", + f"{TIME} 15:00", + f"{TIME} 18:00", + f"{TIME} 21:00", + ] + return _prepare_era5_edh_cutout( + cutouts_path / "cutout_era5-edh_3h_sampling.nc", time=time + ) + + +@pytest.fixture(scope="session") +def cutout_era5_edh_2days_crossing_months(cutouts_path): + return _prepare_era5_edh_cutout( + cutouts_path / "cutout_era5-edh_2days_crossing_months.nc", + time=slice("2013-02-28", "2013-03-01"), + ) + + @pytest.fixture(scope="session") def cutout_gebco(cutouts_path): tmp_path = cutouts_path / "cutout_gebco.nc" diff --git a/test/test_preparation_and_conversion.py b/test/test_preparation_and_conversion.py index 1ed9bdf1..73c0d40e 100644 --- a/test/test_preparation_and_conversion.py +++ b/test/test_preparation_and_conversion.py @@ -18,6 +18,7 @@ import pandas as pd import pytest import urllib3 +import xarray as xr from dateutil.relativedelta import relativedelta from shapely.geometry import LineString as Line from shapely.geometry import Point @@ -651,3 +652,143 @@ def test_all_non_na_gebco(cutout_gebco): Every cells should have data. """ assert np.isfinite(cutout_gebco.data).all() + + +class TestERA5EDH: + """ + we assume that era5.py cutouts are correct, and only test whether era5_edh.py cutouts + have the same structure and contain the same numerical values + """ + + # Per-variable absolute tolerances measured against CDS across all three + # EDH fixtures (1-day, 3h-sampled, and 2-day crossing months). Set just + # above the observed worst-case abs diff so any regression bigger than the + # GRIB-pack precision floor is caught. ``rtol`` is held at 0 — these are + # pure atol bounds. + TOLERANCES: dict[str, float] = { + "albedo": 1e-3, + "dewpoint temperature": 0.13, + "height": 0.2, + "influx_diffuse": 0.3, + "influx_direct": 0.15, + "influx_toa": 0.3, + "roughness": 3e-4, + "runoff": 1e-7, + "soil temperature": 0.13, + "solar_altitude": 1e-5, + "solar_azimuth": 1e-5, + "temperature": 0.13, + "wnd100m": 0.01, + "wnd_azimuth": 5e-4, + "wnd_shear_exp": 4e-4, + } + + @staticmethod + def _assert_compatible_cutouts(reference, candidate): + ref = reference.data + cand = candidate.data + + assert set(cand.data_vars) == set(ref.data_vars) + assert set(cand.coords) == set(ref.coords) + assert dict(cand.sizes) == dict(ref.sizes) + assert set(candidate.prepared_features) == set(reference.prepared_features) + assert set(cand.attrs["prepared_features"]) == set( + ref.attrs["prepared_features"] + ) + + for attr in ("dx", "dy"): + if attr in cand.attrs or attr in ref.attrs: + assert cand.attrs.get(attr) == ref.attrs.get(attr) + + for coord in sorted(ref.coords): + xr.testing.assert_equal(cand.coords[coord], ref.coords[coord]) + + for var in sorted(ref.data_vars): + assert cand[var].dims == ref[var].dims + assert cand[var].attrs["feature"] == ref[var].attrs["feature"] + assert cand[var].attrs["module"] == cand.attrs["module"] + assert ref[var].attrs["module"] == ref.attrs["module"] + + cand_units = {var: cand[var].attrs.get("units") for var in sorted(cand)} + ref_units = {var: ref[var].attrs.get("units") for var in sorted(ref)} + assert cand_units == ref_units + + @staticmethod + def _assert_allclose(reference, candidate, variables, *, atol, rtol=0): + """ + Assert per-variable closeness. + """ + for var in variables: + v_atol = atol[var] if isinstance(atol, dict) else atol + if var == "wnd_azimuth": + # wind_azimuth is an angle, so it wraps around zero. we must + # take the modulo to get an accurate numerical difference + diff = abs( + (candidate[var] - reference[var] + np.pi) % (2 * np.pi) - np.pi + ) + xr.testing.assert_allclose( + diff, + xr.zeros_like(diff), + atol=v_atol, + rtol=rtol, + ) + else: + xr.testing.assert_allclose( + candidate[var], + reference[var], + atol=v_atol, + rtol=rtol, + ) + + @staticmethod + def test_all_features_identical(cutout_era5, cutout_era5_edh): + """ + At native 0.25° resolution era5_edh should match era5 across every feature + within the per-variable tolerances. + """ + TestERA5EDH._assert_compatible_cutouts(cutout_era5, cutout_era5_edh) + common = sorted(cutout_era5.data.data_vars) + TestERA5EDH._assert_allclose( + cutout_era5.data, + cutout_era5_edh.data, + common, + atol=TestERA5EDH.TOLERANCES, + ) + + @staticmethod + def test_all_features_3h_sampling_identical( + cutout_era5_3h_sampling, cutout_era5_edh_3h_sampling + ): + """ + era5_edh should preserve coarser hourly sampling and match ERA5 values. + """ + assert pd.infer_freq(cutout_era5_edh_3h_sampling.data.time) == "3h" + TestERA5EDH._assert_compatible_cutouts( + cutout_era5_3h_sampling, cutout_era5_edh_3h_sampling + ) + common = sorted(cutout_era5_3h_sampling.data.data_vars) + TestERA5EDH._assert_allclose( + cutout_era5_3h_sampling.data, + cutout_era5_edh_3h_sampling.data, + common, + atol=TestERA5EDH.TOLERANCES, + ) + + @staticmethod + def test_all_features_2days_crossing_months_identical( + cutout_era5_2days_crossing_months, cutout_era5_edh_2days_crossing_months + ): + """ + era5_edh should match ERA5 across month boundaries. + """ + TestERA5EDH._assert_compatible_cutouts( + cutout_era5_2days_crossing_months, + cutout_era5_edh_2days_crossing_months, + ) + common = sorted(cutout_era5_2days_crossing_months.data.data_vars) + TestERA5EDH._assert_allclose( + cutout_era5_2days_crossing_months.data, + cutout_era5_edh_2days_crossing_months.data, + common, + atol=TestERA5EDH.TOLERANCES, + )