diff --git a/.gitignore b/.gitignore index 23e0ac9d..264dbc88 100644 --- a/.gitignore +++ b/.gitignore @@ -29,4 +29,4 @@ paper .idea/ .vscode AGENTS.md -uv.lock +uv.lock \ No newline at end of file diff --git a/RELEASE_NOTES.rst b/RELEASE_NOTES.rst index e306a146..2226d02f 100755 --- a/RELEASE_NOTES.rst +++ b/RELEASE_NOTES.rst @@ -24,6 +24,10 @@ Upcoming Release buffer that computes a geometrically accurate Euclidean buffer, correct in diagonal directions. +* Implement glofas dataset which contains daily river discharge. ``cutout.hydro()`` now + returns discharge if ``cutout.module`` contains ``"glofas"``. + (https://github.com/PyPSA/atlite/pull/498) + **Bug fixes** * Fix ``Cutout.line_rating`` passing line azimuth in radians while diff --git a/atlite/convert.py b/atlite/convert.py index 980c1137..9b646aba 100644 --- a/atlite/convert.py +++ b/atlite/convert.py @@ -1595,14 +1595,20 @@ def runoff( def hydro( cutout, plants, - hydrobasins, + hydrobasins=None, flowspeed=1, weight_with_height=False, show_progress=False, + *, + module="auto", + time=None, **kwargs, ): """ - Compute inflow time series for plants by aggregating over catchment basins. + Get inflow time-series for `plants` from discharge or runoff data. + + Either extracts the discharge time series for the nearest grid points or + computes runoff-based inflow time series. Parameters ---------- @@ -1611,58 +1617,63 @@ def hydro( plants : pd.DataFrame Run-of-river plants or dams with lon, lat columns. hydrobasins : str|gpd.GeoDataFrame - Filename or GeoDataFrame of one level of the HydroBASINS dataset. + Filename or GeoDataFrame of one level of the HydroBASINS dataset. Only required + for runoff-based computation. flowspeed : float Average speed of water flows to estimate the water travel time from - basin to plant (default: 1 m/s). + basin to plant (default: 1 m/s). Only relevant for runoff-based computation. weight_with_height : bool Whether surface runoff should be weighted by potential height (probably - better for coarser resolution). + better for coarser resolution). Only relevant for runoff-based computation. show_progress : bool - Whether to display progressbars. + Whether to display progressbars. Only relevant for runoff-based computation. + module : str + The method to compute hydro time series. "auto" will prefer discharge but fall + back to runoff-based computation, "glofas" uses discharge directly, "era5" uses + runoff-based computation. + time : pd.DatetimeIndex, optional + Time index to interpolate the plant inflow onto. Only relevant for + discharge-based computation. Defaults to the cutout's own time index. **kwargs - Additional keyword arguments passed to `convert_and_aggregate`. + Additional arguments for runoff-based computation. Returns ------- xr.DataArray Inflow time-series for each plant. - References - ---------- - [1] Liu, Hailiang, et al. "A validated high-resolution hydro power - time-series model for energy systems analysis." arXiv preprint - arXiv:1901.08476 (2019). - - [2] Lehner, B., Grill G. (2013): Global river hydrography and network - routing: baseline data and new approaches to study the world’s large river - systems. Hydrological Processes, 27(15): 2171–2186. Data is available at - www.hydrosheds.org. - + Raises + ------ + ValueError + If required data for the selected module is missing or the module is unknown. """ - basins = hydrom.determine_basins(plants, hydrobasins, show_progress=show_progress) + module = module.lower() + if module == "auto": + module = "glofas" if "discharge" in cutout.data.data_vars else "era5" - matrix = cutout.indicatormatrix(basins.shapes) - # compute the average surface runoff in each basin - # Fix NaN and Inf values to 0.0 to avoid numerical issues - matrix_normalized = np.nan_to_num( - matrix / matrix.sum(axis=1), nan=0.0, posinf=0.0, neginf=0.0 - ) - runoff = cutout.runoff( - matrix=matrix_normalized, - index=basins.shapes.index, - weight_with_height=weight_with_height, - show_progress=show_progress, - **kwargs, - ) - # The hydrological parameters are in units of "m of water per day" and so - # they should be multiplied by 1000 and the basin area to convert to m3 - # d-1 = m3 h-1 / 24 - runoff *= xr.DataArray(basins.shapes.to_crs({"proj": "cea"}).area) + if module == "glofas": + if "discharge" not in cutout.data.data_vars: + raise ValueError( + "For GloFAS-based hydro time series, the cutout must include discharge data." + ) + return hydrom._hydro_from_discharge(cutout, plants, time=time) - return hydrom.shift_and_aggregate_runoff_for_plants( - basins, runoff, flowspeed, show_progress - ) + if module == "era5": + if hydrobasins is None: + raise ValueError( + "For ERA5-based hydro time series, the hydrobasins dataset must be provided." + ) + return hydrom._hydro_from_runoff( + cutout, + plants, + hydrobasins, + flowspeed=flowspeed, + weight_with_height=weight_with_height, + show_progress=show_progress, + **kwargs, + ) + + raise ValueError(f'Unknown hydro module option "{module}".') def convert_line_rating( diff --git a/atlite/datasets/__init__.py b/atlite/datasets/__init__.py index 69dd418d..2aab94c7 100644 --- a/atlite/datasets/__init__.py +++ b/atlite/datasets/__init__.py @@ -4,6 +4,6 @@ """atlite datasets.""" -from atlite.datasets import era5, gebco, sarah +from atlite.datasets import era5, gebco, glofas, sarah -modules = {"era5": era5, "sarah": sarah, "gebco": gebco} +modules = {"era5": era5, "sarah": sarah, "gebco": gebco, "glofas": glofas} diff --git a/atlite/datasets/cds_helper.py b/atlite/datasets/cds_helper.py new file mode 100644 index 00000000..6f0f1580 --- /dev/null +++ b/atlite/datasets/cds_helper.py @@ -0,0 +1,188 @@ +# SPDX-FileCopyrightText: Contributors to atlite +# +# SPDX-License-Identifier: MIT +""" +Shared helpers for datasets downloaded via the Climate Data Store (CDS). + +Used by both the era5 and glofas dataset modules. +""" + +from __future__ import annotations + +import logging +import weakref +from pathlib import Path +from typing import TYPE_CHECKING, Any, cast + +import xarray as xr + +if TYPE_CHECKING: + from atlite._types import PathLike + +logger = logging.getLogger(__name__) + + +def _area(coords: dict[str, xr.DataArray]) -> list[float]: + """ + Extract CDS API bounding box from coordinates. + + Parameters + ---------- + coords : dict[str, xr.DataArray] + Coordinate arrays with 'x' (longitude) and 'y' (latitude). + + Returns + ------- + list[float] + Bounding box as [north, west, south, east]. + """ + x0, x1 = coords["x"].min().item(), coords["x"].max().item() + y0, y1 = coords["y"].min().item(), coords["y"].max().item() + return [y1, x0, y0, x1] + + +def noisy_unlink(path: PathLike) -> None: + """ + Remove a file with debug logging, handling PermissionError gracefully. + + Parameters + ---------- + path : PathLike + Path to the file to delete. + """ + logger.debug("Deleting file %s", path) + try: + Path(path).unlink() + except PermissionError: + logger.error("Unable to delete file %s, as it is still in use.", path) + + +def add_finalizer(ds: xr.Dataset, target: PathLike) -> None: + """ + Register a weak-reference callback to delete a temp file on garbage collection. + + Parameters + ---------- + ds : xr.Dataset + Dataset whose lifetime controls the temp file. + target : PathLike + Path to the temporary file to clean up. + """ + logger.debug("Adding finalizer for %s", target) + assert ds._close is not None + weakref.finalize(cast("Any", ds._close).__self__.ds, noisy_unlink, target) + + +def sanitize_chunks(chunks: Any, **dim_mapping: str) -> Any: + """ + Remap internal dimension names to CDS dimension names in chunk specs. + + Translates atlite dimension names (time, x, y) to the corresponding + CDS names (valid_time, longitude, latitude). + + Parameters + ---------- + chunks : Any + Chunk specification. If not a dict, returned as-is. + **dim_mapping : str + Additional or override dimension name mappings. + + Returns + ------- + Any + Remapped chunk dict, or original value if not a dict. + """ + dim_mapping = { + "time": "valid_time", + "x": "longitude", + "y": "latitude", + } | dim_mapping + if not isinstance(chunks, dict): + return chunks + + return { + extname: chunks[intname] + for intname, extname in dim_mapping.items() + if intname in chunks + } + + +def open_with_grib_conventions( + grib_file: PathLike, + chunks: dict[str, int] | None = None, + tmpdir: PathLike | None = None, +) -> xr.Dataset: + """ + Open a GRIB file using cfgrib with standardized coordinate conventions. + + Performs the same conversion as the CDS backend, but locally. + Based on the documentation at + https://confluence.ecmwf.int/display/CKB/GRIB+to+netCDF+conversion+on+new+CDS+and+ADS+systems + + Parameters + ---------- + grib_file : PathLike + Path to the GRIB file. + chunks : dict[str, int] or None, optional + Dask chunk specification for lazy loading. + tmpdir : PathLike or None, optional + If set, the file is kept (managed externally). + + Returns + ------- + xr.Dataset + Opened dataset with standardized dimensions. + """ + # Open grib file as dataset. + # Options below normalize different grib variants into consistent + # netCDF-compatible hypercubes. Options relevant only to e.g. wave-model + # data have been removed to keep this routine focused on the products we use. + ds = xr.open_dataset( + grib_file, + engine="cfgrib", + time_dims=["valid_time"], + ignore_keys=["edition"], + coords_as_attributes=[ + "surface", + "depthBelowLandLayer", + "entireAtmosphere", + "heightAboveGround", + "meanSea", + ], + chunks=sanitize_chunks(chunks), + ) + if tmpdir is None: + add_finalizer(ds, grib_file) + + def safely_expand_dims(dataset: xr.Dataset, expand_dims: list[str]) -> xr.Dataset: + """Expand missing dimensions while preserving their original order. + + Returns + ------- + xr.Dataset + Dataset with the requested dimensions present. + """ + dims_required = [ + c for c in dataset.coords if c in expand_dims + list(dataset.dims) + ] + dims_missing = [ + (c, i) for i, c in enumerate(dims_required) if c not in dataset.dims + ] + dataset = dataset.expand_dims( + dim=[x[0] for x in dims_missing], axis=[x[1] for x in dims_missing] + ) + return dataset + + logger.debug("Converting grib file to netcdf format") + rename_vars = { + "time": "forecast_reference_time", + "step": "forecast_period", + "isobaricInhPa": "pressure_level", + "hybrid": "model_level", + } + rename_vars = {k: v for k, v in rename_vars.items() if k in ds} + ds = ds.rename(rename_vars) + + ds = safely_expand_dims(ds, ["valid_time", "pressure_level", "model_level"]) + + return ds diff --git a/atlite/datasets/era5.py b/atlite/datasets/era5.py index adafdb3b..9bf3c7b4 100644 --- a/atlite/datasets/era5.py +++ b/atlite/datasets/era5.py @@ -13,8 +13,6 @@ import logging import os import warnings -import weakref -from pathlib import Path from tempfile import mkstemp from typing import TYPE_CHECKING, Any, Literal, cast @@ -26,6 +24,12 @@ from dask.array import arctan2, sqrt from numpy import atleast_1d +from atlite.datasets.cds_helper import ( + _area, + add_finalizer, + open_with_grib_conventions, + sanitize_chunks, +) from atlite.gis import maybe_swap_spatial_dims from atlite.pv.solar_position import SolarPosition @@ -362,25 +366,6 @@ def get_data_height(retrieval_params: dict[str, Any]) -> xr.Dataset: return _add_height(ds) -def _area(coords: dict[str, xr.DataArray]) -> list[float]: - """ - Extract CDS API bounding box from coordinates. - - Parameters - ---------- - coords : dict[str, xr.DataArray] - Coordinate arrays with 'x' (longitude) and 'y' (latitude). - - Returns - ------- - list[float] - Bounding box as [north, west, south, east]. - """ - x0, x1 = coords["x"].min().item(), coords["x"].max().item() - y0, y1 = coords["y"].min().item(), coords["y"].max().item() - return [y1, x0, y0, x1] - - def retrieval_times( coords: dict[str, xr.DataArray], static: bool = False, @@ -439,153 +424,6 @@ def retrieval_times( return times -def noisy_unlink(path: PathLike) -> None: - """ - Remove a file with debug logging, handling PermissionError gracefully. - - Parameters - ---------- - path : PathLike - Path to the file to delete. - """ - logger.debug("Deleting file %s", path) - try: - Path(path).unlink() - except PermissionError: - logger.error("Unable to delete file %s, as it is still in use.", path) - - -def add_finalizer(ds: xr.Dataset, target: PathLike) -> None: - """ - Register a weak-reference callback to delete a temp file on garbage collection. - - Parameters - ---------- - ds : xr.Dataset - Dataset whose lifetime controls the temp file. - target : PathLike - Path to the temporary file to clean up. - """ - logger.debug("Adding finalizer for %s", target) - assert ds._close is not None - weakref.finalize(cast("Any", ds._close).__self__.ds, noisy_unlink, target) - - -def sanitize_chunks(chunks: Any, **dim_mapping: str) -> Any: - """ - Remap internal dimension names to ERA5/CDS dimension names in chunk specs. - - Translates atlite dimension names (time, x, y) to the corresponding - ERA5 names (valid_time, longitude, latitude). - - Parameters - ---------- - chunks : Any - Chunk specification. If not a dict, returned as-is. - **dim_mapping : str - Additional or override dimension name mappings. - - Returns - ------- - Any - Remapped chunk dict, or original value if not a dict. - """ - dim_mapping = { - "time": "valid_time", - "x": "longitude", - "y": "latitude", - } | dim_mapping - if not isinstance(chunks, dict): - return chunks - - return { - extname: chunks[intname] - for intname, extname in dim_mapping.items() - if intname in chunks - } - - -def open_with_grib_conventions( - grib_file: PathLike, - chunks: dict[str, int] | None = None, - tmpdir: PathLike | None = None, -) -> xr.Dataset: - """ - Open a GRIB file using cfgrib with standardized coordinate conventions. - - Performs the same conversion as the CDS backend, but locally. - Based on the documentation at - https://confluence.ecmwf.int/display/CKB/GRIB+to+netCDF+conversion+on+new+CDS+and+ADS+systems - - Parameters - ---------- - grib_file : PathLike - Path to the GRIB file. - chunks : dict[str, int] or None, optional - Dask chunk specification for lazy loading. - tmpdir : PathLike or None, optional - If set, the file is kept (managed externally). - - Returns - ------- - xr.Dataset - Opened dataset with standardized dimensions. - """ - # Open grib file as dataset. - # Options below normalize different ERA5 grib variants into consistent - # netCDF-compatible hypercubes. Options relevant only to e.g. wave-model - # data have been removed to keep this routine focused on the products we use. - ds = xr.open_dataset( - grib_file, - engine="cfgrib", - time_dims=["valid_time"], - ignore_keys=["edition"], - coords_as_attributes=[ - "surface", - "depthBelowLandLayer", - "entireAtmosphere", - "heightAboveGround", - "meanSea", - ], - chunks=sanitize_chunks(chunks), - ) - if tmpdir is None: - add_finalizer(ds, grib_file) - - def safely_expand_dims(dataset: xr.Dataset, expand_dims: list[str]) -> xr.Dataset: - """Expand missing dimensions while preserving their original order. - - Returns - ------- - xr.Dataset - Dataset with the requested dimensions present. - """ - dims_required = [ - c for c in dataset.coords if c in expand_dims + list(dataset.dims) - ] - dims_missing = [ - (c, i) for i, c in enumerate(dims_required) if c not in dataset.dims - ] - dataset = dataset.expand_dims( - dim=[x[0] for x in dims_missing], axis=[x[1] for x in dims_missing] - ) - return dataset - - logger.debug("Converting grib file to netcdf format") - rename_vars = { - "time": "forecast_reference_time", - "step": "forecast_period", - "isobaricInhPa": "pressure_level", - "hybrid": "model_level", - } - rename_vars = {k: v for k, v in rename_vars.items() if k in ds} - ds = ds.rename(rename_vars) - - ds = safely_expand_dims(ds, ["valid_time", "pressure_level", "model_level"]) - - return ds - - def retrieve_data( product: str, chunks: dict[str, int] | None = None, @@ -596,8 +434,8 @@ def retrieve_data( """ Download ERA5 data from the CDS API and return as an xarray Dataset. - The ongoing and past requests can be tracked at - https://cds-beta.climate.copernicus.eu/requests?tab=all. + If you want to track the state of your request go to + https://cds.climate.copernicus.eu/requests?tab=all Parameters ---------- diff --git a/atlite/datasets/glofas.py b/atlite/datasets/glofas.py new file mode 100644 index 00000000..267f4fa5 --- /dev/null +++ b/atlite/datasets/glofas.py @@ -0,0 +1,330 @@ +# SPDX-FileCopyrightText: Contributors to atlite +# +# SPDX-License-Identifier: MIT +""" +Module for downloading and curating data from ECMWFs GLOFAS dataset (via CDS). + +For further reference see +https://ewds.climate.copernicus.eu/datasets/cems-glofas-historical?tab=overview +""" + +import logging +import os +import zipfile +from pathlib import Path +from tempfile import mkstemp +from typing import Any + +import cdsapi +import numpy as np +import xarray as xr +from dask import compute, delayed +from dask.utils import SerializableLock +from numpy import atleast_1d + +from atlite.datasets.cds_helper import ( + _area, + add_finalizer, + open_with_grib_conventions, + sanitize_chunks, +) +from atlite.gis import maybe_swap_spatial_dims + +# Null context for running a with statements wihout any context +try: + from contextlib import nullcontext +except ImportError: + # for Python verions < 3.7: + import contextlib + + @contextlib.contextmanager # type: ignore[no-redef] + def nullcontext(): # noqa: D103 + yield + + +logger = logging.getLogger(__name__) + +# Model and CRS Settings +crs = 4326 + +dataset = "cems-glofas-historical" + +features = {"discharge": ["discharge"]} + + +def _rename_and_clean_coords(ds, add_lon_lat=True): + """ + Rename 'longitude' and 'latitude' columns to 'x' and 'y' and fix roundings. + + Optionally (add_lon_lat, default:True) preserves latitude and + longitude columns as 'lat' and 'lon'. + + Returns + ------- + xr.Dataset + Dataset with standardized coordinates. + """ + rename = { + "longitude": "x", + "latitude": "y", + "valid_time": "time", + # discharge follows the GRIB shortName: 'avg_dis' for time_mean, 'dis24' otherwise + "avg_dis": "discharge", + "dis24": "discharge", + } + ds = ds.rename({k: v for k, v in rename.items() if k in ds}) + # round coords since cds coords are float64 which would lead to mismatches + ds = ds.assign_coords( + x=np.round(ds.x.astype(float), 5), y=np.round(ds.y.astype(float), 5) + ) + ds = maybe_swap_spatial_dims(ds) + if add_lon_lat: + ds = ds.assign_coords(lon=ds.coords["x"], lat=ds.coords["y"]) + return ds.drop_vars(["expver", "number"], errors="ignore") + + +def retrieve_data( + product: str, + chunks: dict[str, int] | None = None, + tmpdir: str | Path | None = None, + lock: SerializableLock | None = None, + **updates: Any, +) -> xr.Dataset: + """ + Download data like Glofas from the Climate Data Store (CDS). + + If you want to track the state of your request go to + https://ewds.climate.copernicus.eu/requests?tab=all + + Parameters + ---------- + product : str + Product name, e.g. 'cems-glofas-historical'. + chunks : dict, optional + Chunking for xarray dataset, e.g. {'time': 1, 'x': 100, 'y': 100}. + Default is None. + tmpdir : str, optional + Directory where the downloaded data is temporarily stored. + Default is None, which uses the system's temporary directory. + lock : dask.utils.SerializableLock, optional + Lock for thread-safe file writing. Default is None. + updates : dict + Additional parameters for the request. + Must include 'year', 'month', 'day', and 'variable'. + Can include e.g. 'data_format'. + + Returns + ------- + xarray.Dataset + Dataset with the retrieved variables. + + Raises + ------ + ValueError + When the downloaded ZIP does not contain exactly one file matching + the 'data*' pattern. + + Examples + -------- + >>> ds = retrieve_data( + ... product='cems-glofas-historical', + ... chunks={'time': 1, 'x': 100, 'y': 100}, + ... tmpdir='/tmp', + ... lock=None, + ... year='2020', + ... month='01', + ... variable=['average_river_discharge_in_the_last_24_hours'], + ... data_format='grib' + ... ) + """ + request = { + "system_version": ["version_4_0"], + "hydrological_model": ["lisflood"], + "product_type": ["consolidated"], + "variable": ["average_river_discharge_in_the_last_24_hours"], + "timespan": ["time_mean"], + "data_format": "grib2", + "download_format": "zip", + } + request.update(updates) + + assert {"year", "month", "variable"}.issubset(request), ( + "Need to specify at least 'variable', 'year' and 'month'" + ) + + logger.debug("Requesting %s with API request: %s", product, request) + # Url needs to be set manually here, overrides url from .cdsapirc (for use with multiple modules) + client = cdsapi.Client( + info_callback=logger.debug, + debug=logging.root.level <= logging.DEBUG, + url="https://ewds.climate.copernicus.eu/api", + ) + result = client.retrieve(product, request) + + if lock is None: + lock = nullcontext() + + suffix = f".{request['data_format']}" # .netcdf or .grib + with lock: + fd, target = mkstemp(suffix=suffix, dir=tmpdir) + os.close(fd) + + timestr = f"{request['year']}-{request['month']}" + variables = atleast_1d(request["variable"]) + varstr = "\n\t".join([f"{v} ({timestr})" for v in variables]) + logger.info("CDS: Downloading variables\n\t%s\n", varstr) + result.download(target) + + if request.get("download_format") == "zip": + extract_dir = Path(target).parent / Path(target).stem + with zipfile.ZipFile(target, "r") as zip_ref: + zip_ref.extractall(extract_dir) + Path(target).unlink() + matches = list(extract_dir.glob("data*")) + if len(matches) != 1: + raise ValueError( + f"Expected 1 file matching 'data*' in ZIP, found {len(matches)}" + ) + target = str(matches[0]) + + # Convert from grib to netcdf locally, same conversion as in CDS backend + if request["data_format"] == "grib2": + ds = open_with_grib_conventions(target, chunks=chunks, tmpdir=tmpdir) + else: + ds = xr.open_dataset(target, chunks=sanitize_chunks(chunks)) + if tmpdir is None: + add_finalizer(ds, target) + return ds + + +def retrieval_times(coords, static=False, monthly_requests=False): + """ + Get list of retrieval cdsapi arguments for time dimension in coordinates. + + If static is False, this function creates a query for each month and year + in the time axis in coords. This ensures not running into size query limits + of the cdsapi even with very (spatially) large cutouts. + If static is True, the function return only one set of parameters + for the very first time point. + + Parameters + ---------- + coords : atlite.Cutout.coords + static : bool, optional + monthly_requests : bool, optional + If True, the data is requested on a monthly basis. This is useful for + large cutouts, where the data is requested in smaller chunks. The + default is False + + Returns + ------- + list of dicts witht retrieval arguments + + """ + time = coords["time"].to_index() + if static: + return { + "year": time[0].strftime("%Y"), + "month": time[0].strftime("%m"), + "day": time[0].strftime("%d"), + } + + # Prepare request for all months and years + times = [] + for year in time.year.unique(): + t = time[time.year == year] + if monthly_requests: + for month in t.month.unique(): + query = { + "year": str(year), + "month": list(t[t.month == month].strftime("%m").unique()), + "day": list(t[t.month == month].strftime("%d").unique()), + } + times.append(query) + else: + query = { + "year": str(year), + "month": list(t.strftime("%m").unique()), + "day": list(t.strftime("%d").unique()), + } + times.append(query) + return times + + +def get_data( + cutout, + feature, + tmpdir="tmp", + lock=None, + data_format="grib2", + monthly_requests=False, + concurrent_requests=False, + **creation_parameters, +): + """ + Retrieve data from ECMWFs GLOFAS dataset (via CDS). + + This front-end function downloads data for a specific feature and formats + it to match the given Cutout. + + Parameters + ---------- + cutout : atlite.Cutout + feature : str + Name of the feature data to retrieve. Must be in + `atlite.datasets.glofas.features` + tmpdir : str/Path + Directory where the temporary netcdf files are stored. + data_format : str, optional + The format of the data to be downloaded. Can be either 'grib' or 'netcdf', + 'grib' highly recommended because CDSAPI limits request size for netcdf. + concurrent_requests : bool, optional + If True, the monthly data requests are posted concurrently. + Only has an effect if `monthly_requests` is True. + **creation_parameters : + Additional keyword arguments: + - 'sanitize' (default True): sets sanitization of the data on or off. + + Returns + ------- + xarray.Dataset + Dataset of dask arrays of the retrieved variables at the native GLOFAS + resolution (daily values on the native grid). + + """ + coords = cutout.coords + + sanitize = creation_parameters.get("sanitize", True) + + retrieval_params = { + "product": "cems-glofas-historical", + "area": _area(coords), + "chunks": cutout.chunks, + "tmpdir": tmpdir, + "lock": lock, + "data_format": "netcdf", + } + + def retrieve_once(time): + ds = retrieve_data( + variable=["average_river_discharge_in_the_last_24_hours"], + **retrieval_params, + **time, + ) + ds = _rename_and_clean_coords(ds) + # discharge is timestamped at the end of its 24h window; shift to the flow day + ds = ds.assign_coords(time=ds["time"] - np.timedelta64(1, "D")) + if sanitize: + ds["discharge"] = ds["discharge"].clip(min=0.0).fillna(0.0) + return ds + + time_chunks = retrieval_times(coords, monthly_requests=monthly_requests) + if concurrent_requests: + delayed_datasets = [delayed(retrieve_once)(chunk) for chunk in time_chunks] + datasets = list(compute(*delayed_datasets)) + else: + datasets = list(map(retrieve_once, time_chunks)) + + # Keep discharge at its native GLOFAS resolution. Interpolation needs to happen + # later to avoid interpolating the whole grid here. + return xr.concat(datasets, dim="time").sortby("time") diff --git a/atlite/hydro.py b/atlite/hydro.py index e449d1cf..d83efd0a 100644 --- a/atlite/hydro.py +++ b/atlite/hydro.py @@ -189,3 +189,113 @@ def shift_and_aggregate_runoff_for_plants( inflow_plant += runoff.sel(hid=b).roll(time=nhours.at[b]) return inflow + + +def _hydro_from_runoff( + cutout, + plants, + hydrobasins, + flowspeed=1, + weight_with_height=False, + show_progress=False, + **kwargs, +): + """ + Compute plant inflow by aggregating ERA5 runoff over catchment basins. + + Parameters + ---------- + plants : pd.DataFrame + Run-of-river plants or dams with lon, lat columns. + hydrobasins : str|gpd.GeoDataFrame + Filename or GeoDataFrame of one level of the HydroBASINS dataset. + flowspeed : float + Average speed of water flows to estimate the water travel time from + basin to plant (default: 1 m/s). + weight_with_height : bool + Whether surface runoff should be weighted by potential height (probably + better for coarser resolution). + show_progress : bool + Whether to display progressbars. + + Returns + ------- + xr.DataArray + Inflow time-series for each plant. + + References + ---------- + [1] Liu, Hailiang, et al. "A validated high-resolution hydro power + time-series model for energy systems analysis." arXiv preprint + arXiv:1901.08476 (2019). + + [2] Lehner, B., Grill G. (2013): Global river hydrography and network + routing: baseline data and new approaches to study the world’s large river + systems. Hydrological Processes, 27(15): 2171–2186. Data is available at + www.hydrosheds.org. + + """ + basins = determine_basins(plants, hydrobasins, show_progress=show_progress) + + matrix = cutout.indicatormatrix(basins.shapes) + # compute the average surface runoff in each basin + # Fix NaN and Inf values to 0.0 to avoid numerical issues + matrix_normalized = np.nan_to_num( + matrix / matrix.sum(axis=1), nan=0.0, posinf=0.0, neginf=0.0 + ) + runoff = cutout.runoff( + matrix=matrix_normalized, + index=basins.shapes.index, + weight_with_height=weight_with_height, + show_progress=show_progress, + **kwargs, + ) + # The hydrological parameters are in units of "m of water per day" and so + # they should be multiplied by 1000 and the basin area to convert to m3 + # d-1 = m3 h-1 / 24 + runoff *= xr.DataArray(basins.shapes.to_crs({"proj": "cea"}).area) + + return shift_and_aggregate_runoff_for_plants( + basins, runoff, flowspeed, show_progress + ) + + +def _hydro_from_discharge( + cutout, + plants, + time=None, +): + """ + Get plant inflow from GLOFAS discharge by snapping to the nearest data cell. + + Snaps each plant to the nearest grid cell that holds data and interpolates + onto the target time index. + + Parameters + ---------- + plants : pd.DataFrame + Run-of-river plants or dams with lon, lat columns. + time : pd.DatetimeIndex, optional + Time index to interpolate the plant inflow onto. Defaults to the cutout's + own time index. + + Returns + ------- + xr.DataArray + Inflow time-series for each plant. + """ + if time is None: + time = cutout.coords["time"] + discharge = cutout.data.discharge + # snap plants to GLOFAS cells with data (cutout grid points may be all-NaN) + present = discharge.isel(time=0).notnull() + discharge = discharge.isel( + x=np.flatnonzero(present.any("y").values), + y=np.flatnonzero(present.any("x").values), + ) + x = xr.DataArray(plants["lon"].values, dims="plant", coords={"plant": plants.index}) + y = xr.DataArray(plants["lat"].values, dims="plant", coords={"plant": plants.index}) + inflow = discharge.sel(x=x, y=y, method="nearest").compute() + inflow = inflow.dropna("time", how="all").interp(time=time) + inflow = inflow.ffill("time").bfill("time") + return inflow.transpose("plant", "time") diff --git a/doc/examples/glofas_hydro_inflow.nblink b/doc/examples/glofas_hydro_inflow.nblink new file mode 100644 index 00000000..ef7c2975 --- /dev/null +++ b/doc/examples/glofas_hydro_inflow.nblink @@ -0,0 +1,3 @@ +{ + "path": "../../examples/glofas_hydro_inflow.ipynb" +} diff --git a/doc/index.rst b/doc/index.rst index 2e8aa7c1..04039b99 100644 --- a/doc/index.rst +++ b/doc/index.rst @@ -118,6 +118,7 @@ If you would like to cite the atlite software, please refer to `this paper `_. * **Solar (PV)** power generation: Using predefined or custom panel properties. * **Solar (thermal)** heat generation from solar collectors. -* **Hydro (run-off)** power generation. +* **Hydro (run-off / discharge)** power generation. * **Heating and cooling demand** (based on degree-day approx.). How it works @@ -96,6 +96,11 @@ Application Program Interface) client is properly installed. See separate, linked installation guide for details, especially for correctly setting up your CDS API key. +For hydro data, `ECMWF's GloFAS dataset `_ +is also available. It contains daily river discharge data and can complement the ERA5 dataset for hydro. +It uses the same API key as ERA5, its api endpoint is automatically set up by atlite. +It will be used if `cutout.module` contains `"glofas"`. + Previously and in the future other datasets where and (hopefully) will again be usable, including diff --git a/examples/glofas_hydro_inflow.ipynb b/examples/glofas_hydro_inflow.ipynb new file mode 100644 index 00000000..e5697b5e --- /dev/null +++ b/examples/glofas_hydro_inflow.ipynb @@ -0,0 +1,731 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# GLOFAS-based Hydro Inflow Time Series\n", + "\n", + "This notebook demonstrates how to use atlite's GLOFAS (Global Flood Awareness System) dataset to extract discharge-based inflow time series for hydroelectric plants.\n", + "\n", + "## Overview\n", + "\n", + "atlite supports two methods for computing hydroelectric plant inflow:\n", + "\n", + "1. **ERA5-based (runoff)**: Aggregates ERA5 runoff data over catchment basins using HydroBASINS\n", + "2. **GLOFAS-based (discharge)**: Uses direct river discharge data by snapping plants to nearest grid cells\n", + "\n", + "GLOFAS provides daily river discharge estimates at ~0.1\u00b0 spatial resolution from reanalysis data, making it ideal for large-scale hydropower studies with minimal preprocessing." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": "" + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup and Requirements\n", + "\n", + "Ensure you have the necessary dependencies installed and CDS API credentials configured. The Copernicus Climate Data Store (CDS) API is required to download GLOFAS data.\n", + "\n", + "For setup instructions, see the [CDS API documentation](https://cds.climate.copernicus.eu/how-to-api)." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T09:04:13.330972Z", + "iopub.status.busy": "2026-08-12T09:04:13.330669Z", + "iopub.status.idle": "2026-08-12T09:04:13.358974Z", + "shell.execute_reply": "2026-08-12T09:04:13.358259Z", + "shell.execute_reply.started": "2026-08-12T09:04:13.330948Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "atlite version: 0.6.1.post1.dev26+gfcbb57a2f.d20260812\n", + "pandas version: 3.0.3\n", + "xarray version: 2026.7.0\n" + ] + } + ], + "source": [ + "import logging\n", + "from pathlib import Path\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import xarray as xr\n", + "\n", + "import atlite\n", + "\n", + "# Setup logging to monitor progress\n", + "logging.basicConfig(level=logging.INFO)\n", + "\n", + "print(f\"atlite version: {atlite.__version__}\")\n", + "print(f\"pandas version: {pd.__version__}\")\n", + "print(f\"xarray version: {xr.__version__}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": "## Create and Prepare a Cutout\n\nWe start by defining a geographic region of interest and creating a cutout. The cutout specifies:\n\n- **module**: Data source (`glofas` for discharge data)\n- **x, y**: Longitude and latitude bounds of your region\n- **time**: Time period to cover\n- **path**: Local storage location for the cutout\n\nIf the cutout already exists at the specified path, it will be loaded. Otherwise, a new one is created and prepared on demand." + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T09:04:13.360219Z", + "iopub.status.busy": "2026-08-12T09:04:13.359863Z", + "iopub.status.idle": "2026-08-12T09:04:13.392451Z", + "shell.execute_reply": "2026-08-12T09:04:13.391742Z", + "shell.execute_reply.started": "2026-08-12T09:04:13.360197Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cutout bounds:\n", + " Longitude: 0.00\u00b0 to 40.00\u00b0\n", + " Latitude: 55.00\u00b0 to 72.00\u00b0\n", + " Time: 2020-01-01T00:00:00.000000000 to 2020-12-31T23:00:00.000000000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_3927823/4188880446.py:3: UserWarning: Arguments module, x, y, time, data_source are ignored, since cutout is already built.\n", + " cutout = atlite.Cutout(\n" + ] + } + ], + "source": [ + "# Define region of interest: Scandinavia\n", + "# Bounds: (west, south, east, north) in degrees longitude/latitude\n", + "cutout = atlite.Cutout(\n", + " path=\"scandinavia-glofas\",\n", + " module=\"glofas\",\n", + " x=slice(0, 40), # longitude: 0\u00b0E to 40\u00b0E\n", + " y=slice(55, 72), # latitude: 55\u00b0N to 72\u00b0N\n", + " time=\"2020\", # full year 2020\n", + " data_source=\"cems-glofas-historical\",\n", + ")\n", + "\n", + "print(\"Cutout bounds:\")\n", + "print(\n", + " f\" Longitude: {cutout.coords['x'].values[0]:.2f}\u00b0 to {cutout.coords['x'].values[-1]:.2f}\u00b0\"\n", + ")\n", + "print(\n", + " f\" Latitude: {cutout.coords['y'].values[0]:.2f}\u00b0 to {cutout.coords['y'].values[-1]:.2f}\u00b0\"\n", + ")\n", + "print(\n", + " f\" Time: {cutout.coords['time'].values[0]} to {cutout.coords['time'].values[-1]}\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": "### Prepare the Cutout Data\n\nThe `prepare()` method downloads and processes the GLOFAS discharge data for the specified region and time period. This is where the actual data retrieval happens from the CDS servers.\n\n> **Note**: Depending on the size of your cutout, this step may take several minutes. The data is cached locally and subsequent calls will be much faster." + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T09:04:13.392985Z", + "iopub.status.busy": "2026-08-12T09:04:13.392867Z", + "iopub.status.idle": "2026-08-12T09:06:31.253633Z", + "shell.execute_reply": "2026-08-12T09:06:31.252854Z", + "shell.execute_reply.started": "2026-08-12T09:04:13.392975Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:atlite.data:Storing temporary files in /tmp/tmpqot6xhhs\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Prepared data in cutout:\n", + " Available variables: ['discharge']\n", + " Spatial resolution: (409, 961)\n", + " Time steps: 8784\n", + "\n", + "Discharge data statistics (m\u00b3/s):\n", + " Min: 0.00\n", + " Mean: 6.88\n", + " Max: 28079.62\n", + " Std: 66.02\n" + ] + } + ], + "source": [ + "# Download and prepare GLOFAS discharge data\n", + "cutout.prepare()\n", + "\n", + "# Display available data\n", + "print(\"\\nPrepared data in cutout:\")\n", + "print(f\" Available variables: {list(cutout.data.data_vars)}\")\n", + "print(f\" Spatial resolution: {cutout.data.discharge.shape[1:]}\")\n", + "print(f\" Time steps: {len(cutout.data.time)}\")\n", + "\n", + "# Check discharge data statistics\n", + "discharge = cutout.data.discharge\n", + "print(\"\\nDischarge data statistics (m\u00b3/s):\")\n", + "print(f\" Min: {float(discharge.min()):.2f}\")\n", + "print(f\" Mean: {float(discharge.mean()):.2f}\")\n", + "print(f\" Max: {float(discharge.max()):.2f}\")\n", + "print(f\" Std: {float(discharge.std()):.2f}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": "## Prepare Hydroelectric Plant Data\n\nDefine your hydroelectric plants as a pandas DataFrame. The minimum required columns are:\n- `lon`: Longitude of the plant location\n- `lat`: Latitude of the plant location\n\nAdditional columns (capacity, type, etc.) are optional and useful for analysis." + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T09:06:31.254468Z", + "iopub.status.busy": "2026-08-12T09:06:31.254241Z", + "iopub.status.idle": "2026-08-12T09:06:31.279963Z", + "shell.execute_reply": "2026-08-12T09:06:31.278894Z", + "shell.execute_reply.started": "2026-08-12T09:06:31.254450Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hydroelectric Plants:\n", + " name lon lat capacity_mw type\n", + "plant \n", + "plant_a Scandinavian Plant A 10.5 60.2 50 run-of-river\n", + "plant_b Scandinavian Plant B 15.2 61.5 100 reservoir\n", + "plant_c Scandinavian Plant C 20.1 59.8 75 run-of-river\n", + "plant_d Scandinavian Plant D 25.8 63.1 150 reservoir\n", + "\n", + "Total installed capacity: 375 MW\n" + ] + } + ], + "source": [ + "# Create a sample hydroelectric plant dataset\n", + "# In practice, you would load this from a real dataset or database\n", + "plants = pd.DataFrame(\n", + " {\n", + " \"name\": [\n", + " \"Scandinavian Plant A\",\n", + " \"Scandinavian Plant B\",\n", + " \"Scandinavian Plant C\",\n", + " \"Scandinavian Plant D\",\n", + " ],\n", + " \"lon\": [10.5, 15.2, 20.1, 25.8],\n", + " \"lat\": [60.2, 61.5, 59.8, 63.1],\n", + " \"capacity_mw\": [50, 100, 75, 150],\n", + " \"type\": [\"run-of-river\", \"reservoir\", \"run-of-river\", \"reservoir\"],\n", + " },\n", + " index=pd.Index([\"plant_a\", \"plant_b\", \"plant_c\", \"plant_d\"], name=\"plant\"),\n", + ")\n", + "\n", + "print(\"Hydroelectric Plants:\")\n", + "print(plants)\n", + "print(f\"\\nTotal installed capacity: {plants['capacity_mw'].sum()} MW\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": "## Extract GLOFAS-based Inflow Time Series\n\nThe `cutout.hydro()` method extracts discharge-based inflow by snapping each plant to the nearest GLOFAS grid cell with discharge data. This approach:\n\n- Requires no catchment basin delineation (unlike ERA5 runoff approach)\n- Uses actual river discharge measurements/reanalysis\n- Is computationally efficient\n- Works globally at ~0.1\u00b0 resolution\n\n> **Note**: Plants located outside active river networks (e.g., on hillsides or in sparsely gauged regions) will show zero or near-zero discharge values. This is a realistic limitation of point-snapping approaches." + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T09:06:31.280434Z", + "iopub.status.busy": "2026-08-12T09:06:31.280320Z", + "iopub.status.idle": "2026-08-12T09:07:04.397229Z", + "shell.execute_reply": "2026-08-12T09:07:04.396396Z", + "shell.execute_reply.started": "2026-08-12T09:06:31.280424Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Inflow data shape: (4, 8784)\n", + "Coordinates: ['x', 'y', 'lon', 'lat', 'surface', 'plant', 'time']\n", + "\n", + "Data type: \n", + "\n", + "First values (m\u00b3/s):\n", + "[[0.1875 0.1875 0.1875 0.1875 0.1875 ]\n", + " [0.15625 0.15690104 0.15755208 0.15820312 0.15885417]\n", + " [0. 0. 0. 0. 0. ]\n", + " [0.5625 0.56575521 0.56901042 0.57226562 0.57552083]]\n" + ] + } + ], + "source": [ + "# Extract GLOFAS-based discharge inflow time series for each plant\n", + "inflow = cutout.hydro(\n", + " plants=plants,\n", + " module=\"glofas\", # Use GLOFAS discharge data\n", + ")\n", + "\n", + "print(f\"Inflow data shape: {inflow.shape}\")\n", + "print(f\"Coordinates: {list(inflow.coords.keys())}\")\n", + "print(f\"\\nData type: {type(inflow)}\")\n", + "print(\"\\nFirst values (m\u00b3/s):\")\n", + "print(inflow.isel(time=slice(0, 5)).values)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": "## Analyze Inflow Time Series\n\nNow let's analyze the extracted discharge time series to understand the hydrological characteristics at each plant location." + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T09:07:04.397944Z", + "iopub.status.busy": "2026-08-12T09:07:04.397714Z", + "iopub.status.idle": "2026-08-12T09:07:04.431253Z", + "shell.execute_reply": "2026-08-12T09:07:04.430284Z", + "shell.execute_reply.started": "2026-08-12T09:07:04.397929Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Inflow Statistics (m\u00b3/s):\n", + "============================================================\n", + " mean std min 25% 50% 75% max\n", + "plant \n", + "plant_a 0.36 0.20 0.15 0.23 0.29 0.41 1.25\n", + "plant_b 0.15 0.04 0.11 0.12 0.13 0.16 0.38\n", + "plant_c 0.00 0.00 0.00 0.00 0.00 0.00 0.00\n", + "plant_d 1.04 0.32 0.55 0.78 0.99 1.23 2.06\n" + ] + } + ], + "source": [ + "# Convert to DataFrame for easier analysis\n", + "inflow_df = inflow.to_pandas().T\n", + "\n", + "print(\"Inflow Statistics (m\u00b3/s):\")\n", + "print(\"=\" * 60)\n", + "stats = inflow_df.describe().T\n", + "stats = stats[[\"mean\", \"std\", \"min\", \"25%\", \"50%\", \"75%\", \"max\"]]\n", + "print(stats.round(2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Monthly Aggregation\n", + "\n", + "Let's aggregate the daily discharge data to monthly averages to understand seasonal patterns." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T09:07:04.432203Z", + "iopub.status.busy": "2026-08-12T09:07:04.431919Z", + "iopub.status.idle": "2026-08-12T09:07:04.501063Z", + "shell.execute_reply": "2026-08-12T09:07:04.500418Z", + "shell.execute_reply.started": "2026-08-12T09:07:04.432179Z" + } + }, + "outputs": [], + "source": [ + "# Aggregate to monthly averages\n", + "inflow_monthly = inflow.resample(time=\"ME\").mean()\n", + "\n", + "# Create summary table\n", + "monthly_stats = inflow_monthly.to_pandas().T\n", + "print(\"\\nMonthly Average Discharge (m\u00b3/s):\")\n", + "print(\"=\" * 60)\n", + "print(monthly_stats.round(2))\n", + "\n", + "# Calculate seasonal patterns\n", + "print(\"\\nSeasonal Statistics (m\u00b3/s):\")\n", + "print(\"=\" * 60)\n", + "seasonal = inflow.resample(time=\"QS\").mean()\n", + "seasons = [\"Winter (Q1)\", \"Spring (Q2)\", \"Summer (Q3)\", \"Fall (Q4)\"]\n", + "for season, discharge in zip(seasons, seasonal.values, strict=False):\n", + " print(f\"{season:20s} {discharge}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": "## Visualization\n\nVisualize the temporal patterns and characteristics of the discharge data across plants." + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T09:07:04.501653Z", + "iopub.status.busy": "2026-08-12T09:07:04.501542Z", + "iopub.status.idle": "2026-08-12T09:07:05.061375Z", + "shell.execute_reply": "2026-08-12T09:07:05.060911Z", + "shell.execute_reply.started": "2026-08-12T09:07:04.501643Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Discharge time series plotted for all plants.\n" + ] + } + ], + "source": [ + "# Plot time series for all plants\n", + "fig, axes = plt.subplots(2, 2, figsize=(14, 8))\n", + "axes = axes.flatten()\n", + "\n", + "for idx, plant_id in enumerate(plants.index):\n", + " ax = axes[idx]\n", + " plant_inflow = inflow.sel(plant=plant_id)\n", + "\n", + " # Plot daily discharge\n", + " ax.plot(\n", + " plant_inflow.time.values,\n", + " plant_inflow.values,\n", + " linewidth=0.8,\n", + " alpha=0.7,\n", + " label=\"Daily\",\n", + " )\n", + "\n", + " # Overlay monthly average\n", + " monthly = plant_inflow.resample(time=\"ME\").mean()\n", + " ax.plot(\n", + " monthly.time.values,\n", + " monthly.values,\n", + " linewidth=2,\n", + " color=\"red\",\n", + " label=\"Monthly Avg\",\n", + " marker=\"o\",\n", + " )\n", + "\n", + " plant_name = plants.loc[plant_id, \"name\"]\n", + " plant_capacity = plants.loc[plant_id, \"capacity_mw\"]\n", + "\n", + " ax.set_title(f\"{plant_name}\\n({plant_capacity} MW)\", fontweight=\"bold\")\n", + " ax.set_ylabel(\"Discharge (m\u00b3/s)\")\n", + " ax.grid(True, alpha=0.3)\n", + " ax.legend(loc=\"upper right\", fontsize=8)\n", + "\n", + "fig.suptitle(\"GLOFAS Discharge Time Series - 2020\", fontsize=14, fontweight=\"bold\")\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(\"Discharge time series plotted for all plants.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Box Plot Comparison\n", + "\n", + "Compare the distribution of discharge across plants using box plots." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T09:07:05.061885Z", + "iopub.status.busy": "2026-08-12T09:07:05.061770Z", + "iopub.status.idle": "2026-08-12T09:07:05.207651Z", + "shell.execute_reply": "2026-08-12T09:07:05.206811Z", + "shell.execute_reply.started": "2026-08-12T09:07:05.061874Z" + } + }, + "outputs": [], + "source": [ + "# Prepare data for box plot\n", + "plot_data = []\n", + "labels = []\n", + "\n", + "for plant_id in plants.index:\n", + " plant_inflow = inflow.sel(plant=plant_id).values\n", + " plot_data.append(plant_inflow)\n", + " plant_name = plants.loc[plant_id, \"name\"]\n", + " labels.append(f\"{plant_name}\\n({plants.loc[plant_id, 'capacity_mw']} MW)\")\n", + "\n", + "# Create box plot\n", + "fig, ax = plt.subplots(figsize=(12, 6))\n", + "bp = ax.boxplot(plot_data, patch_artist=True)\n", + "\n", + "# Set labels\n", + "ax.set_xticklabels(labels)\n", + "\n", + "# Customize colors\n", + "colors = [\"lightblue\", \"lightgreen\", \"lightyellow\", \"lightcoral\"]\n", + "for patch, color in zip(bp[\"boxes\"], colors, strict=False):\n", + " patch.set_facecolor(color)\n", + "\n", + "ax.set_ylabel(\"Discharge (m\u00b3/s)\", fontsize=11)\n", + "ax.set_title(\n", + " \"Distribution of GLOFAS Discharge by Plant (2020)\", fontsize=12, fontweight=\"bold\"\n", + ")\n", + "ax.grid(True, alpha=0.3, axis=\"y\")\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(\"Box plot comparison complete.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T09:07:05.208287Z", + "iopub.status.busy": "2026-08-12T09:07:05.208114Z", + "iopub.status.idle": "2026-08-12T09:07:05.457878Z", + "shell.execute_reply": "2026-08-12T09:07:05.456728Z", + "shell.execute_reply.started": "2026-08-12T09:07:05.208273Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Correlation Matrix of Discharge Between Plants:\n", + "============================================================\n", + "plant plant_a plant_b plant_c plant_d\n", + "plant \n", + "plant_a 1.000 0.065 NaN 0.481\n", + "plant_b 0.065 1.000 NaN -0.021\n", + "plant_c NaN NaN NaN NaN\n", + "plant_d 0.481 -0.021 NaN 1.000\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Correlation analysis: Plants with high correlation share similar\n", + "hydrological patterns, suggesting they may be in the same river basin.\n" + ] + } + ], + "source": [ + "# Calculate correlation matrix\n", + "inflow_corr = inflow_df.corr()\n", + "\n", + "print(\"Correlation Matrix of Discharge Between Plants:\")\n", + "print(\"=\" * 60)\n", + "print(inflow_corr.round(3))\n", + "\n", + "# Visualize correlation\n", + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "im = ax.imshow(inflow_corr.values, cmap=\"coolwarm\", vmin=-1, vmax=1, aspect=\"auto\")\n", + "\n", + "# Set labels\n", + "ax.set_xticks(range(len(plants)))\n", + "ax.set_yticks(range(len(plants)))\n", + "plant_labels = [f\"Plant {i + 1}\" for i in range(len(plants))]\n", + "ax.set_xticklabels(plant_labels, rotation=45)\n", + "ax.set_yticklabels(plant_labels)\n", + "\n", + "# Add correlation values as text\n", + "for i in range(len(plants)):\n", + " for j in range(len(plants)):\n", + " text = ax.text(\n", + " j,\n", + " i,\n", + " f\"{inflow_corr.iloc[i, j]:.2f}\",\n", + " ha=\"center\",\n", + " va=\"center\",\n", + " color=\"black\",\n", + " fontsize=10,\n", + " )\n", + "\n", + "ax.set_title(\"Discharge Correlation Between Plants\", fontweight=\"bold\")\n", + "cbar = plt.colorbar(im, ax=ax)\n", + "cbar.set_label(\"Correlation\", rotation=270, labelpad=15)\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(\"\\nCorrelation analysis: Plants with high correlation share similar\")\n", + "print(\"hydrological patterns, suggesting they may be in the same river basin.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T09:07:05.458531Z", + "iopub.status.busy": "2026-08-12T09:07:05.458417Z", + "iopub.status.idle": "2026-08-12T09:07:05.557659Z", + "shell.execute_reply": "2026-08-12T09:07:05.554571Z", + "shell.execute_reply.started": "2026-08-12T09:07:05.458522Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u2713 Saved NetCDF: glofas_inflow_output/glofas_inflow_2020.nc\n", + "\u2713 Saved CSV: glofas_inflow_output/glofas_inflow_2020.csv\n", + "\u2713 Saved monthly stats: glofas_inflow_output/glofas_inflow_monthly_2020.csv\n", + "\u2713 Saved plant metadata: glofas_inflow_output/plants.csv\n", + "\n", + "All results exported to: /home/fabian/vres/py/worktrees/atlite/solar-violet/atlite/examples/glofas_inflow_output\n" + ] + } + ], + "source": [ + "# Create output directory\n", + "output_dir = Path(\"glofas_inflow_output\")\n", + "output_dir.mkdir(exist_ok=True)\n", + "\n", + "# Export as NetCDF (preserves all metadata and structure)\n", + "inflow.to_netcdf(output_dir / \"glofas_inflow_2020.nc\")\n", + "print(f\"\u2713 Saved NetCDF: {output_dir / 'glofas_inflow_2020.nc'}\")\n", + "\n", + "# Export as CSV for spreadsheet analysis\n", + "inflow_df.to_csv(output_dir / \"glofas_inflow_2020.csv\")\n", + "print(f\"\u2713 Saved CSV: {output_dir / 'glofas_inflow_2020.csv'}\")\n", + "\n", + "# Export monthly aggregates\n", + "monthly_stats.to_csv(output_dir / \"glofas_inflow_monthly_2020.csv\")\n", + "print(f\"\u2713 Saved monthly stats: {output_dir / 'glofas_inflow_monthly_2020.csv'}\")\n", + "\n", + "# Save plant metadata\n", + "plants.to_csv(output_dir / \"plants.csv\")\n", + "print(f\"\u2713 Saved plant metadata: {output_dir / 'plants.csv'}\")\n", + "\n", + "print(f\"\\nAll results exported to: {output_dir.absolute()}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": "## Export Results\n\nSave the extracted inflow time series in NetCDF format for further analysis or integration with other tools." + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T09:07:05.558183Z", + "iopub.status.busy": "2026-08-12T09:07:05.558041Z", + "iopub.status.idle": "2026-08-12T09:07:05.580079Z", + "shell.execute_reply": "2026-08-12T09:07:05.579314Z", + "shell.execute_reply.started": "2026-08-12T09:07:05.558171Z" + } + }, + "outputs": [], + "source": [ + "# Create output directory\n", + "output_dir = Path(\"glofas_inflow_output\")\n", + "output_dir.mkdir(exist_ok=True)\n", + "\n", + "# Export as NetCDF (preserves all metadata and structure)\n", + "inflow.to_netcdf(output_dir / \"glofas_inflow_2020.nc\")\n", + "print(f\"\u2713 Saved NetCDF: {output_dir / 'glofas_inflow_2020.nc'}\")\n", + "\n", + "# Save plant metadata\n", + "plants.to_csv(output_dir / \"plants.csv\")\n", + "print(f\"\u2713 Saved plant metadata: {output_dir / 'plants.csv'}\")\n", + "\n", + "print(f\"\\nAll results exported to: {output_dir.absolute()}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": "## Energy Calculations\n\nEstimate potential hydroelectric energy generation based on discharge and plant capacity. This is a simplified example; actual calculations would account for plant efficiency, head loss, and other factors." + } + ], + "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.11" + }, + "spdx": "MIT", + "copyright": "Contributors to atlite " + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file diff --git a/examples/glofas_hydro_inflow.ipynb.license b/examples/glofas_hydro_inflow.ipynb.license new file mode 100644 index 00000000..6bf7929c --- /dev/null +++ b/examples/glofas_hydro_inflow.ipynb.license @@ -0,0 +1,3 @@ +SPDX-FileCopyrightText: Contributors to atlite + +SPDX-License-Identifier: MIT diff --git a/pyproject.toml b/pyproject.toml index f42c77b3..e78ff011 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -67,6 +67,8 @@ docs = [ "nbsphinx==0.9.5", "nbsphinx-link==1.3.0", "docutils==0.20", # Just temporarily until sphinx-docutils is updated (see https://github.com/sphinx-doc/sphinx/issues/12340) + "jupyter", + "matplotlib" ] # Setuptools_scm settings diff --git a/test/test_preparation_and_conversion.py b/test/test_preparation_and_conversion.py index 067499a4..83c1f279 100644 --- a/test/test_preparation_and_conversion.py +++ b/test/test_preparation_and_conversion.py @@ -19,12 +19,15 @@ 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 import atlite from atlite import Cutout +from atlite.datasets import glofas +from atlite.datasets.cds_helper import _area, sanitize_chunks urllib3.disable_warnings() @@ -566,6 +569,66 @@ def test_line_rating_era5(cutout_era5): return line_rating_test(cutout_era5) +class TestGlofas: + @staticmethod + def test_area(): + """_area returns the CDS bounding box as [north, west, south, east].""" + coords = {"x": xr.DataArray([1.0, 2.0, 3.0]), "y": xr.DataArray([50.0, 51.0])} + assert _area(coords) == [51.0, 1.0, 50.0, 3.0] + + @staticmethod + def test_sanitize_chunks(): + """Chunk dims are remapped to CDS names; non-dict specs pass through.""" + assert sanitize_chunks({"time": 1, "x": 10, "y": 20}) == { + "valid_time": 1, + "longitude": 10, + "latitude": 20, + } + assert sanitize_chunks("auto") == "auto" + + @staticmethod + def test_retrieval_times(): + """Time coords are grouped into static / yearly / monthly CDS requests.""" + coords = xr.Dataset( + coords={"time": pd.date_range("2020-01-30", "2020-02-02")} + ).coords + # static: only the first timestamp + assert glofas.retrieval_times(coords, static=True) == { + "year": "2020", + "month": "01", + "day": "30", + } + # default: one request per year, grouping all its months and days + (yearly,) = glofas.retrieval_times(coords) + assert yearly["year"] == "2020" + assert yearly["month"] == ["01", "02"] + assert yearly["day"] == ["30", "31", "01", "02"] + # monthly: one request per (year, month) + monthly = glofas.retrieval_times(coords, monthly_requests=True) + assert [m["month"] for m in monthly] == [["01"], ["02"]] + assert [m["day"] for m in monthly] == [["30", "31"], ["01", "02"]] + + @staticmethod + def test_rename_and_clean_coords(): + """dis24/lon/lat/valid_time are renamed, coords rounded, lon/lat mirrored.""" + ds = xr.Dataset( + {"dis24": (("valid_time", "latitude", "longitude"), np.ones((1, 2, 2)))}, + coords={ + "valid_time": pd.date_range("2020-01-01", periods=1), + "latitude": [50.0, 51.0], + "longitude": [0.123456789, 1.0], + "number": 0, + }, + ) + out = glofas._rename_and_clean_coords(ds) + assert "discharge" in out.data_vars + assert set(out.dims) >= {"time", "x", "y"} + assert "number" not in out.coords # dropped + assert out.x.values[0] == pytest.approx(0.12346) # rounded to 5 decimals + np.testing.assert_array_equal(out.lon.values, out.x.values) # lon mirrors x + np.testing.assert_array_equal(out.lat.values, out.y.values) + + @pytest.mark.skipif( not Path(SARAH_DIR).exists(), reason="'sarah_dir' is not a valid path" )