From c118b6cb8f7eadb93fbc58fc76e436f4aa7f3472 Mon Sep 17 00:00:00 2001 From: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> Date: Tue, 5 Mar 2024 20:14:17 +0100 Subject: [PATCH] Add module for computing river flood footprints from GloFAS river discharge data (#64) * Add util functions for downloading GloFAS data Use cdsapi to download GloFAS data from Copernicus Data Store. So far, the actual download is not tested. * Add util functions for downloading data. * Add unit tests for request handling. * Add 'cdsapi' to requirements * Allow `date_to=None` to download only a single file * [draft] Add class for processing GloFAS river flood * Working on glofas flood stuff [revise!] * Add tests for dantro operations * Update operations to fix issues found when writing the tests. * Add unit test case for dantro operations. * Tweak CDS GloFAS downloader. * Add dantro to requirements * Update GloFAS river flood pipeline * Add option to set countries instead of lat/lon limits when downloading GloFAS data. * Return pandas Series of Hazards with multi index. * Use discharge dataset for lat/lon slicing of all other datasets. * Add unit tests. * Make CDS Downloader support skipping downloads Downloads will be skipped if the target file exists with the same request dict. * Place the request as YAML file next to the target file for request comparison. * Add option to control using the "cached" results or always downloading the data. * Update unit tests. * Explicitly list ruamel.yaml as requirement (already required by dantro). * Fix an issue where ruamel.yaml could not dump numbers * Add 'max_from_isel' operation NOTE: Commented code would be an alternative to define the select dimension based on values instead of indices. * Add operation * Add test case for operation * Handle NaNs in flood depth interpolation * Update unit tests accordingly. * Add core dimension checks to flood depth unit tests. * Add routines for computing default files for GloFAS flood module * Add operations and config for computing the GEV fits and merging flood maps, which are both used for computing a flood footprint. * Update affected operations and configs. * Remove GloFASRiverFlood class in favor of two functions. * Update tests * Overhaul GloFAS flood pipeline * Move respective files into their own subdirectory. * Adapt configuration files to latest dantro version. * Add 'transform_ops.py' containing only dantro transformations. * Expose user functions via dedicated __init__.py * Add option to run tasks in parallel * Rename 'test_glofas_rf.py' to 'rest_rf_glofas.py' * Rename 'rf_glofas_util.yml' to 'setup.yml' and expose dantro_transform function * Add rioxarray as dependency Used for reading GeoTIFF with xarray. * Update test_rf_glofas.py imports to new module structure * Rework user experience of rf_glofas module and write full documentation * Fix formatting in glofas_rf docs * Fix type hints and data manager container type * Add operation for including FLOPROS database * Add tutorial for GloFAS river flood module * WIP: Add bootstrap resampling to return period computation * Fix glofas_rf unit tests, formatting, and docstrings * Fix return period sampling and update tests * Add tests for 'save_file' and 'finalize' * Fix return period resampling Actually do the resampling instead of resampling once and copying the new value. Update tests accordingly. * Add module docstrings and fix linter warnings in rf_glofas * Improve docstrings and try to please linter * Add links to ETH research collection datasets * Update env_docs.yml * Fix env_docs.yml * Fix order in doc toctree * Upgrade matplotlib in doc environment * Revert "Upgrade matplotlib in doc environment" This reverts commit 94c210f55f71f6d6e35e1d5f76131f7c15834652. * Mock dantro when building docs * Comply to latest climada_python/develop * readthedocs: add glofas to tutorials section of the navigation bar * jenkinsfile: install new dependencies on the fly * fix error in jenkins file * Add xesmf regrid operation * Add 'xesmf' to requirements * Fix bug in test file * Add new requirements to Jenkinsfile * Mock modules when building docs to make the automated build succeed * Fix typos in linter instructions * Only use pip to install missing dependencies * Fix pip install in Jenkinsfile * conda-env: install xesmf * Try 'pip install --upgrade' in Jenkinsfile * Do not upgrade to matplotlib 3.6 in Jenkinsfile * Fix an issue where the GeoDataFrame loader is not available * Fix an issue where infinite return periods would lead to NaN flood depths * rf_glofas: try to circumvent "ImportError: The ESMFMKFILE environment variable is not available." * rf_glofas: try to circumvent "ImportError: The ESMFMKFILE environment variable is not available.", bis * Apply suggestions from code review Co-authored-by: Thomas Vogt <57705593+tovogt@users.noreply.github.com> * Improve performance of inundation computation * Vectorize computations of return period and inundation. * Define maximum return period to avoid inf. * Return Hazard instead of RiverFlood instances. * Working on new version without dantro * Make parallelization of 'setup_gumbel_fit' external * Fix bug in calling 'download_glofas_discharge' * Make sure netcdf4 engine is used to store data * Various changes * Improve file opening and closing with custom context manager. * Set new default data directory. * Add option to download reanalysis. * Improve compute algorithm and add docstrings * Do not store everything, avoid zlib * Update transform operations tests * Remove unused 'finalize' function * Remove dantro pipeline config files * Remove dantro-related functions and classes * Rework tutorial, docstrings, improve usability * Rework tutorial, docstrings, improve usability * Remove pipeline config files for tutorial * Add 'xesmf' to conda environment specs * Update requirement handling in Jenkinsfile * RiverFlood.__init__: re-merge from dev * RiverFlood.__init__: re-merge from dev * Add ruamel.yaml to requirements * Move CDS downloader into rf_glofas folder Adapt imports, tests, docs * Update docs and docstrings * Fix logger for river_flood_computation.py * Fix name for _RiverFloodCachePaths * Fix linter issues * Add tests for RiverFloodInundation * Add cdsapi as dependency * env_docs: include additional dependencies * Add rioxarray to requirements * Apply suggestions for test_preprocess Co-authored-by: Thomas Vogt <57705593+tovogt@users.noreply.github.com> * Update climada_petals/hazard/rf_glofas/test/test_river_flood_computation.py Co-authored-by: Thomas Vogt <57705593+tovogt@users.noreply.github.com> * Apply suggestions for cds_glofas_downloader.py Co-authored-by: Thomas Vogt <57705593+tovogt@users.noreply.github.com> * Revert changes to river_flood.py * Remove import mocking in doc/conf.py * Update climada_petals/hazard/rf_glofas/test/test_rf_glofas.py Co-authored-by: Thomas Vogt <57705593+tovogt@users.noreply.github.com> * Make sure tests operate on floats * Avoid division by zero in return period computation Co-authored-by: Thomas Vogt <57705593+tovogt@users.noreply.github.com> * Improve testing of return_period_resample * Rename test_rf_glofas.py to test_transform_ops.py * Add tests for rf_glofas.py * Fix a bug where unit tests were not executed if called directly * Clean up temporary directories explicitly * Update climada_petals/hazard/rf_glofas/setup.py Co-authored-by: Thomas Vogt <57705593+tovogt@users.noreply.github.com> * Update climada_petals/hazard/rf_glofas/transform_ops.py Co-authored-by: Thomas Vogt <57705593+tovogt@users.noreply.github.com> * Only use dimensions with time information for events * Render docs with 'myst_nb' * Add myst-nb parser to doc requirements * Mock xesmf in sphinx build Installing xesmf would require to reload the environment, which does not happen online. * Avoid squeezing of 'time' dimension when opening discharge data * Use hashed download paths for CDS data This avoids overwriting data downloaded for the same day (forecast) or year (reanalysis/historical). * Update tutorial * Apply suggestions from code review Co-authored-by: Thomas Vogt <57705593+tovogt@users.noreply.github.com> * update glofas tutorial after code review * update glofas tutorial to make selection in multiindex more stable * fix pylint * Update docstrings --------- Co-authored-by: Lukas Riedel Co-authored-by: emanuel-schmid Co-authored-by: Thomas Vogt <57705593+tovogt@users.noreply.github.com> Co-authored-by: Thomas Roosli --- climada_petals/hazard/rf_glofas/__init__.py | 25 + .../hazard/rf_glofas/cds_glofas_downloader.py | 291 ++ climada_petals/hazard/rf_glofas/rf_glofas.py | 165 + .../rf_glofas/river_flood_computation.py | 665 ++++ climada_petals/hazard/rf_glofas/setup.py | 238 ++ .../test/test_cds_glofas_downloader.py | 219 ++ .../hazard/rf_glofas/test/test_rf_glofas.py | 184 + .../test/test_river_flood_computation.py | 389 ++ .../rf_glofas/test/test_transform_ops.py | 660 ++++ .../hazard/rf_glofas/transform_ops.py | 813 +++++ .../climada_petals.hazard.rf_glofas.rst | 47 + doc/climada_petals/climada_petals.hazard.rst | 1 + doc/climada_petals/climada_petals.util.rst | 1 - doc/conf.py | 41 +- doc/glofas_rf.rst | 294 ++ doc/index.rst | 7 + doc/tutorial/climada_hazard_glofas_rf.ipynb | 3234 +++++++++++++++++ doc/tutorial/hazard.rst | 1 + requirements/env_climada.yml | 5 + requirements/env_docs.yml | 11 +- script/jenkins/branches/Jenkinsfile | 7 +- setup.py | 4 + 22 files changed, 7285 insertions(+), 17 deletions(-) create mode 100644 climada_petals/hazard/rf_glofas/__init__.py create mode 100644 climada_petals/hazard/rf_glofas/cds_glofas_downloader.py create mode 100644 climada_petals/hazard/rf_glofas/rf_glofas.py create mode 100644 climada_petals/hazard/rf_glofas/river_flood_computation.py create mode 100644 climada_petals/hazard/rf_glofas/setup.py create mode 100644 climada_petals/hazard/rf_glofas/test/test_cds_glofas_downloader.py create mode 100644 climada_petals/hazard/rf_glofas/test/test_rf_glofas.py create mode 100644 climada_petals/hazard/rf_glofas/test/test_river_flood_computation.py create mode 100644 climada_petals/hazard/rf_glofas/test/test_transform_ops.py create mode 100644 climada_petals/hazard/rf_glofas/transform_ops.py create mode 100644 doc/climada_petals/climada_petals.hazard.rf_glofas.rst create mode 100644 doc/glofas_rf.rst create mode 100644 doc/tutorial/climada_hazard_glofas_rf.ipynb diff --git a/climada_petals/hazard/rf_glofas/__init__.py b/climada_petals/hazard/rf_glofas/__init__.py new file mode 100644 index 000000000..251df8a17 --- /dev/null +++ b/climada_petals/hazard/rf_glofas/__init__.py @@ -0,0 +1,25 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +Export functions of the GloFAS River Flood Module +""" + +from .setup import setup_all +from .river_flood_computation import RiverFloodInundation +from .rf_glofas import hazard_series_from_dataset +from .transform_ops import save_file diff --git a/climada_petals/hazard/rf_glofas/cds_glofas_downloader.py b/climada_petals/hazard/rf_glofas/cds_glofas_downloader.py new file mode 100644 index 000000000..9f1330c49 --- /dev/null +++ b/climada_petals/hazard/rf_glofas/cds_glofas_downloader.py @@ -0,0 +1,291 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +Functions for downloading GloFAS river discharge data from the Copernicus Climate Data +Store (CDS). +""" + +from pathlib import Path +import multiprocessing as mp +from copy import deepcopy +from typing import Iterable, Mapping, Any, Optional, List, Union +from itertools import repeat +from datetime import date, datetime +import logging +import hashlib + +from cdsapi import Client +from ruamel.yaml import YAML +from ruamel.yaml.compat import StringIO +import pandas as pd +import numpy as np + +from climada.util.constants import SYSTEM_DIR + +LOGGER = logging.getLogger(__name__) + +CDS_DOWNLOAD_DIR = Path(SYSTEM_DIR, "cds-download") + +DEFAULT_REQUESTS = { + "historical": { + "variable": "river_discharge_in_the_last_24_hours", + "product_type": "consolidated", + "system_version": "version_3_1", + "hydrological_model": "lisflood", + "format": "grib", + "hyear": "1979", + "hmonth": [ + "january", + "february", + "march", + "april", + "may", + "june", + "july", + "august", + "september", + "october", + "november", + "december", + ], + "hday": [f"{day:02}" for day in range(1, 32)], + }, + "forecast": { + "variable": "river_discharge_in_the_last_24_hours", + "product_type": "ensemble_perturbed_forecasts", + "system_version": "version_3_1", + "hydrological_model": "lisflood", + "format": "grib", + "year": "2022", + "month": "08", + "day": "01", + "leadtime_hour": (np.arange(1, 31) * 24).astype(str).tolist(), + }, +} +"""Default request keyword arguments to be updated by the user requests""" + + +def request_to_md5(request: Mapping[Any, Any]) -> str: + """Hash a string with the MD5 algorithm""" + yaml = YAML() + stream = StringIO() + yaml.dump(request, stream) + return hashlib.md5(stream.getvalue().encode("utf-8")).hexdigest() + + +def cleanup_download_dir( + download_dir: Union[Path, str] = CDS_DOWNLOAD_DIR, dry_run: bool = False +): + """Delete the contents of the download directory""" + for filename in Path(download_dir).glob("*"): + LOGGER.debug("Removing file: %s", filename) + if not dry_run: + filename.unlink() + if dry_run: + LOGGER.debug("Dry run. No files removed") + + +def glofas_request_single( + product: str, + request: Mapping[str, Any], + outpath: Union[Path, str], + use_cache: bool = True, + client_kw: Optional[Mapping[str, Any]] = None, +) -> Path: + """Perform a single request for data from the Copernicus data store + + This will skip the download if a file was found at the target location with the same + request. The request will be stored as YAML file alongside the target file and used + for comparison. This behavior can be adjusted with the ``use_cache`` parameter. + + Parameters + ---------- + product : str + The string identifier of the product in the Copernicus data store + request : dict + The download request as dictionary + outpath : str or Path + The file path to store the download into (including extension) + use_cache : bool (optional) + Skip downloading if the target file exists and the accompanying request file + contains the same request + client_kw : dict (optional) + Dictionary with keyword arguments for the ``cdsapi.Client`` used for downloading + """ + # Define output file + outpath = Path(outpath) + request_hash = request_to_md5(request) + outfile = outpath / ( + datetime.today().strftime("%y%m%d-%H%M%S") + f"-{request_hash}" + ) + extension = ".grib" if request["format"] == "grib" else ".nc" + outfile = outfile.with_suffix(extension) + + # Check if request was issued before + if use_cache: + for filename in outpath.glob(f"*{extension}"): + if request_hash == filename.stem.split("-")[-1]: + LOGGER.info( + "Skipping request for file '%s' because it already exists", outfile + ) + return filename.resolve() + + # Set up client and retrieve data + LOGGER.info("Downloading file: %s", outfile) + client_kw_default = dict(quiet=False, debug=False) + if client_kw is not None: + client_kw_default.update(client_kw) + client = Client(**client_kw_default) + client.retrieve(product, request, outfile) + + # Dump request + yaml = YAML() + yaml.dump(request, outfile.with_suffix(".yml")) + + # Return file path + return outfile.resolve() + + +def glofas_request_multiple( + product: str, + requests: Iterable[Mapping[str, str]], + outdir: Union[Path, str], + num_proc: int, + use_cache: bool, + client_kw: Optional[Mapping[str, Any]] = None, +) -> List[Path]: + """Execute multiple requests to the Copernicus data store in parallel""" + with mp.Pool(num_proc) as pool: + return pool.starmap( + glofas_request_single, + zip( + repeat(product), + requests, + repeat(outdir), + repeat(use_cache), + repeat(client_kw), + ), + ) + + +def glofas_request( + product: str, + date_from: str, + date_to: Optional[str], + output_dir: Union[Path, str], + num_proc: int = 1, + use_cache: bool = True, + request_kw: Optional[Mapping[str, str]] = None, + client_kw: Optional[Mapping[str, Any]] = None, +) -> List[Path]: + """Request download of GloFAS data products from the Copernicus Data Store (CDS) + + Uses the Copernicus Data Store API (cdsapi) Python module. The interpretation of the + ``date`` parameters and the grouping of the downloaded data depends on the type of + ``product`` requested. + + Available ``products``: + + - ``historical``: Historical reanalysis discharge data. ``date_from`` and ``date_to`` + are interpreted as integer years. Data for each year is placed into a single file. + - ``forecast``: Forecast discharge data. ``date_from`` and ``date_to`` are + interpreted as ISO date format strings. Data for each day is placed into a single + file. + + Notes + ----- + Downloading data from the CDS requires authentication via a user key which is granted + to each user upon registration. Do the following **before calling this function**: + + - Create an account at the Copernicus Data Store website: + https://cds.climate.copernicus.eu/ + - Follow the instructions to install the CDS API key: + https://cds.climate.copernicus.eu/api-how-to#install-the-cds-api-key + + Parameters + ---------- + product : str + The indentifier for the CMS product to download. See below for available options. + date_from : str + First date to download data for. Interpretation varies based on ``product``. + date_to : str or None + Last date to download data for. Interpretation varies based on ``product``. If + ``None``, or the same date as ``date_from``, only download data for ``date_from`` + output_dir : Path + Output directory for the downloaded data + num_proc : int + Number of processes used for parallel requests + use_cache : bool (optional) + Skip downloading if the target file exists and the accompanying request file + contains the same request + request_kw : dict(str: str) + Dictionary to update the default request for the given product + client_kw : dict (optional) + Dictionary with keyword arguments for the ``cdsapi.Client`` used for downloading + + Returns + ------- + list of Path + Paths of the downloaded files + """ + # Check if product exists + try: + default_request = deepcopy(DEFAULT_REQUESTS[product]) + except KeyError as err: + raise NotImplementedError( + f"product = {product}. Choose from {list(DEFAULT_REQUESTS.keys())}" + ) from err + + # Update with request_kw + if request_kw is not None: + default_request.update(**request_kw) + + if product == "historical": + # Interpret dates as years only + year_from = int(date_from) + year_to = int(date_to) if date_to is not None else year_from + + # List up all requests + requests = [ + {"hyear": str(year)} for year in list(range(year_from, year_to + 1)) + ] + + elif product == "forecast": + # Download single date if 'date_to' is 'None' + date_from: date = date.fromisoformat(date_from) + date_to: date = ( + date.fromisoformat(date_to) if date_to is not None else date_from + ) + + # List up all requests + dates = pd.date_range(date_from, date_to, freq="D", inclusive="both").date + requests = [ + {"year": str(d.year), "month": f"{d.month:02d}", "day": f"{d.day:02d}"} + for d in dates + ] + + else: + NotImplementedError("Unknown product: %s" % product) + + requests = [{**default_request, **req} for req in requests] + glofas_product = f"cems-glofas-{product}" + + # Execute request + return glofas_request_multiple( + glofas_product, requests, output_dir, num_proc, use_cache, client_kw + ) diff --git a/climada_petals/hazard/rf_glofas/rf_glofas.py b/climada_petals/hazard/rf_glofas/rf_glofas.py new file mode 100644 index 000000000..303d143b3 --- /dev/null +++ b/climada_petals/hazard/rf_glofas/rf_glofas.py @@ -0,0 +1,165 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +User Interface for GloFAS River Flood Module +""" + +import logging +from contextlib import contextmanager +from typing import Union + +import xarray as xr +import pandas as pd +from dask.distributed import Client + +from climada.util.constants import SYSTEM_DIR +from climada.hazard import Hazard + +LOGGER = logging.getLogger(__name__) + +DEFAULT_DATA_DIR = SYSTEM_DIR / "river-flood-computation" + + +@contextmanager +def dask_client(n_workers, threads_per_worker, memory_limit, *args, **kwargs): + """Create a context with a ``dask.distributed.Client``. + + This is a lightweight wrapper and intended to expose only the most important + parameters to end users. + + Parameters + ---------- + n_workers : int + Number of parallel processes to launch. + threads_per_worker : int + Compute threads launched by each worker. + memory_limit : str + Memory limit for each process. Example: 4 GB can be expressed as ``4000M`` or + ``4G``. + args, kwargs + Additional (keyword) arguments passed to the ``dask.distributed.Client`` + constructor. + + Example + ------- + >>> with dask_client(n_workers=2, threads_per_worker=2, memory_limit="4G"): + ... xr.open_dataset("data.nc", chunks="auto").median() + """ + # Yield the client with the arguments, and close it afterwards + LOGGER.info("Creating dask.distributed.Client") + client = Client( + *args, + n_workers=n_workers, + threads_per_worker=threads_per_worker, + memory_limit=memory_limit, + **kwargs, + ) + try: + yield client + finally: + LOGGER.info("Closing dask.distributed.Client") + client.close() + + +def hazard_series_from_dataset( + data: xr.Dataset, intensity: str, event_dim: str +) -> Union[pd.Series, Hazard]: + """Create a series of Hazard objects from a multi-dimensional dataset + + The input flood data is usually multi-dimensional. For example, you might have + downloaded ensemble data over an extended period of time. Therefore, this function + returns a ``pandas.Series``. Each entry of the series is a ``Hazard`` object whose + events have the same coordinates in this multi-dimensional space except the one + given by ``event_dim``. For example, if your data space has the dimensions ``time``, + ``lead_time`` and ``number``, and you choose ``event_dim="number"``, then the index + of the series will be a ``MultiIndex`` from ``time`` and ``lead_time``, and a single + hazard object will contain all events along the ``number`` axis for a given + MultiIndex. + + Parameters + ---------- + data : xarray.Dataset + Data to load a hazard series from. + intensity : str + Name of the dataset variable to read as hazard intensity. + event_dim : str + Name of the dimension to be used as event dimension in the hazards. All other + dimension names except the dimensions for longitude and latitude will make up the + hierarchy of the ``MultiIndex`` of the resulting series. + + Returns + ------- + pandas.Series + Series of ``Hazard`` objects with events along ``event_dim`` and with + a ``MultiIndex`` of the remaining dimensions. + + Tip + --- + This function must transpose the underlying data in the dataset to convenietly build + ``Hazard`` objects. To ensure that this is an efficient operation, avoid plugging + the return value of + :py:meth:`~climada_petals.hazard.rf_glofas.river_flood_computation.RiverFloodInundation.compute` + directly into this function, especially for **large data**. Instead, save the data + first using :py:func:`~climada_petals.hazard.rf_glofas.transform_ops.save_file`, + then re-open the data with xarray and call this function on it. + + Examples + -------- + + Execute the default pipeline and retrieve the Hazard series + + >>> import xarray as xr + >>> dset = xr.open_dataset("flood.nc") + >>> sorted(list(dset.dims.keys())) + ["date", "latitude", "longitude", "number", "sample"] + + >>> from climada_petals.hazard.rf_glofas import hazard_series_from_dataset + >>> with xr.open_dataset("flood.nc") as dset: + >>> hazard_series_from_dataset(dset, "flood_depth_flopros", "number") + date sample + 2022-08-10 0 Hazard: + """Create hazard from a GloFASRiverFlood hazard dataset""" + return Hazard.from_xarray_raster( + dataset, + hazard_type="RF", + intensity=intensity, + intensity_unit="m", + coordinate_vars=dict(event=event_dim), + data_vars=dict(date="time"), + rechunk=True, + ) + + # Iterate over all dimensions that are not lon, lat, or 'event_dim' + iter_dims = list(set(data.dims) - {"longitude", "latitude", event_dim}) + if iter_dims: + index = pd.MultiIndex.from_product( + [data[dim].values for dim in iter_dims], names=iter_dims + ) + hazards = [ + create_hazard(data.sel(dict(zip(iter_dims, idx)))) + for idx in index.to_flat_index() + ] + return pd.Series(hazards, index=index) + + return create_hazard(data) diff --git a/climada_petals/hazard/rf_glofas/river_flood_computation.py b/climada_petals/hazard/rf_glofas/river_flood_computation.py new file mode 100644 index 000000000..40ef150ae --- /dev/null +++ b/climada_petals/hazard/rf_glofas/river_flood_computation.py @@ -0,0 +1,665 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +Top-level computation class for river flood inundation +""" +from pathlib import Path +from tempfile import TemporaryDirectory +import logging +from typing import Iterable, Union, Optional, Mapping, Any, Callable, List +from contextlib import contextmanager +from datetime import datetime +from collections import namedtuple + +import xarray as xr +import geopandas as gpd +import numpy as np +import pandas as pd + +from .rf_glofas import DEFAULT_DATA_DIR, dask_client +from .transform_ops import ( + download_glofas_discharge, + return_period, + return_period_resample, + regrid, + apply_flopros, + flood_depth, + save_file, +) + +LOGGER = logging.getLogger(__name__) + + +@contextmanager +def _maybe_open_dataarray( + arr: Optional[xr.DataArray], + filename: Union[str, Path], + **open_dataarray_kwargs, +): + """Create a context for opening an xarray file or yielding the input array + + This will open the file with ``xr.open_dataarray`` + + Parameters + ---------- + arr : xr.DataArray or None + The input array. If this is *not* ``None`` it is simply returned. + filename : Path or str + The file to open as data array if ``arr`` is ``None``. + open_dataarray_kwargs + Keyword arguments passed to ``xr.open_dataarray``. + + Returns + ------- + xr.DataArray + Either ``arr`` or the array at ``filename``. If a file was opened, it will be + closed when this context manager closes. + """ + if arr is None: + LOGGER.debug("Opening file: %s", filename) + arr = xr.open_dataarray(filename, **open_dataarray_kwargs) + try: + yield arr + finally: + LOGGER.debug("Closing file: %s", filename) + arr.close() + + else: + yield arr + + +_RiverFloodCachePaths = namedtuple( + "RiverFloodCachePaths", + [ + "discharge", + "return_period", + "return_period_regrid", + "return_period_regrid_protect", + ], +) + + +class RiverFloodCachePaths(_RiverFloodCachePaths): + """Container for storing paths to caches for :py:class:`RiverFloodInundation` + + Depending on the state of the corresponding :py:class:`RiverFloodInundation` + instance, files might be present or not. Please check this explicitly before + accessing them. + + Attributes + ---------- + discharge : pathlib.Path + Path to the discharge data cache. + return_period : pathlib.Path + Path to the return period data cache. + return_period_regrid : pathlib.Path + Path to the regridded return period data cache. + return_period_regrid_protect : pathlib.Path + Path to the regridded return period data cache, where the return period was + restricted by the protection limits. + """ + + @classmethod + def from_dir(cls, cache_dir: Path): + """Set default paths from a cache directory""" + return cls( + discharge=cache_dir / "discharge.nc", + return_period=cache_dir / "return-period.nc", + return_period_regrid=cache_dir / "return-period-regrid.nc", + return_period_regrid_protect=cache_dir / "return-period-regrid-protect.nc", + ) + + +class RiverFloodInundation: + """Class for computing river flood inundations + + Attributes + ---------- + store_intermediates : bool + If intermediate results are stored in the respective :py:attr:`cache_paths` + cache_paths : RiverFloodCachePaths + Paths pointing to potential intermediate results stored in a cache directory. + flood_maps : xarray.DataArray + Flood inundation on lat/lon grid for specific return periods. + gumbel_fits : xarray.Dataset + Gumbel parameters resulting from extreme value analysis of historical discharge + data. + flopros : geopandas.GeoDataFrame + Spatially explicit information on flood protection levels. + regridder : xesmf.Regridder + Storage for re-using the XESMF regridder in case the computation is repeated + on the same grid. This reduces the runtime of subsequent computations. + """ + + def __init__( + self, + store_intermediates: bool = True, + data_dir: Union[Path, str] = DEFAULT_DATA_DIR, + cache_dir: Union[Path, str] = DEFAULT_DATA_DIR / ".cache", + ): + """Initialize the instance + + Parameters + ---------- + store_intermediates : bool, optional + Whether the data of each computation step should be stored in the cache + directory. This is recommended especially for larger data. Only set this + to ``False`` if the data operated on is very small (e.g., for a small + country or region). Defaults to ``True``. + data_dir : Path or str, optional + The directory where flood maps, Gumbel distribution parameters and the + FLOPROS database are located. Defaults to + ``/data/river-flood-computation``, where ```` is the + Climada data directory indicated by ``local_data : system`` in the + ``climada.conf``. This directory must exist. + cache_dir : Path or str, optional + The top-level cache directory where computation caches of this instance will + be placed. Defaults to ``/data/river-flood-computation/.cache`` + (see above for configuration). This directory (and all its parents) will be + created. + """ + self._tempdir = None + data_dir = Path(data_dir) + if not data_dir.is_dir(): + raise FileNotFoundError(f"'data_dir' does not exist: {data_dir}") + + self.store_intermediates = store_intermediates + self.flood_maps = xr.open_dataarray( + data_dir / "flood-maps.nc", + chunks=dict(return_period=-1, latitude="auto", longitude="auto"), + ) + self.gumbel_fits = xr.open_dataset(data_dir / "gumbel-fit.nc", chunks="auto") + self.flopros = gpd.read_file(data_dir / "FLOPROS_shp_V1/FLOPROS_shp_V1.shp") + self.regridder = None + self._create_tempdir(cache_dir=cache_dir) + + def __del__(self): + """Upon deletion, make sure the temporary directory is cleaned up""" + # NOTE: Deletion might also happen when __init__ did not succeed/conclude! + if self._tempdir is not None: + self._tempdir.cleanup() + + def _create_tempdir(self, cache_dir: Union[Path, str]): + """Create a temporary directory inside the top-level cache dir + + Parameters + ---------- + cache_dir : Path or str + The directory where caches are placed. Each cache is a temporary + subdirectory of ``cache_dir``. If the path does not exist, it will be + created, including all parent directories. + """ + # Create cache directory + cache_dir = Path(cache_dir) + cache_dir.mkdir(parents=True, exist_ok=True) + + # Create temporary directory for cache + self._tempdir = TemporaryDirectory( + dir=cache_dir, prefix=datetime.today().strftime("%y%m%d-%H%M%S-") + ) + + # Define cache paths + self.cache_paths = RiverFloodCachePaths.from_dir(Path(self._tempdir.name)) + + def clear_cache(self): + """Clear the cache of this instance + + This will delete the temporary cache directory and create a new one by calling + :py:meth:`_create_tempdir`. + """ + cache_dir = Path(self._tempdir.name).parent + self._tempdir.cleanup() + self._create_tempdir(cache_dir=cache_dir) + + def compute( + self, + discharge: Optional[xr.DataArray] = None, + apply_protection: Union[bool, str] = "both", + resample_kws: Optional[Mapping[str, Any]] = None, + regrid_kws: Optional[Mapping[str, Any]] = None, + ): + """Compute river flood inundation from downloaded river discharge + + After downloading discharge data, this will execute the pipeline for computing + river flood inundaton. This pipeline has the following steps: + + - Compute the equivalent return period, either with :py:meth:`return_period`, or + :py:meth:`return_period_resample`. + - Regrid the return period data onto the grid of the flood hazard maps with + :py:meth:`regrid`. + - *Optional*: Apply the protection layer with :py:meth:`apply_protection`. + - Compute the flood depth by interpolating flood hazard maps with + :py:meth:`flood_depth`. + + Resampling, regridding, and the application of protection information are + controlled via the parameters of this method. + + Parameters + ---------- + discharge : xr.DataArray or None (optional) + The discharge data to compute flood depths for. If ``None``, the cached + discharge will be used. Defaults to ``None``. + apply_protection : bool or "both" (optional) + If the stored protection layer should be considered when computing the flood + depth. If ``"both"``, this method will return a dataset with two flood depth + arrays. Defaults to ``both``. + resample_kws : Mapping (str, Any) or None (optional) + Keyword arguments for :py:meth:`return_period_resample`. If ``None``, + this method will call :py:meth:`return_period`. Otherwise, it will call + :py:meth:`return_period_resample` and pass this parameter as keyword + arguments. Defaults to ``None``. + regrid_kws : Mapping (str, Any) or None (optional) + Keyword arguments for :py:meth:`regrid`. Defaults to ``None``. + + Returns + ------- + xr.Dataset + Dataset containing the flood data with the same dimensions as the input + discharge data. Depending on the choice of ``apply_protection``, this will + contain one or two DataArrays. + + Raises + ------ + RuntimeError + If ``discharge`` is ``None``, but no discharge data is cached. + """ + if discharge is None and not self.cache_paths.discharge.is_file(): + raise RuntimeError( + "No discharge data. Please download a discharge with this object " + "first or supply the data as argument to this function" + ) + + # Compute return period + if resample_kws is None: + self.return_period(discharge=discharge) + else: + self.return_period_resample(discharge=discharge, **resample_kws) + + # Regrid + regrid_kws = regrid_kws if regrid_kws is not None else {} + self.regrid(**regrid_kws) + + # Compute flood depth + ds_flood = xr.Dataset() + if not apply_protection or apply_protection == "both": + ds_flood["flood_depth"] = self.flood_depth() + + # Compute flood depth with protection + self.apply_protection() + ds_flood["flood_depth_flopros"] = self.flood_depth() + + # Return data + return ds_flood + + def download_forecast( + self, + countries: Union[str, List[str]], + forecast_date: Union[str, np.datetime64, datetime, pd.Timestamp], + lead_time_days: int = 10, + preprocess: Optional[Callable] = None, + **download_glofas_discharge_kwargs, + ) -> xr.DataArray: + """Download GloFAS discharge ensemble forecasts + + If :py:attr:`store_intermediates` is true, the returned data is also stored in + :py:attr:`cache_paths`. + + Parameters + ---------- + countries : str or list of str + Names or codes of countries to download data for. The downloaded data will + be a lat/lon grid covering all specified countries. + forecast_date + The date at which the forecast was issued. Can be defined any way that is + compatible with ``pandas.Timestamp``, see + https://pandas.pydata.org/docs/reference/api/pandas.Timestamp.html + lead_time_days : int, optional + How many days of lead time to include in the downloaded forecast. Maximum + is 30. Defaults to 10, in which case the 10 days following the + ``forecast_date`` are included in the download. + preprocess + Callable for preprocessing data while loading it. See + https://docs.xarray.dev/en/stable/generated/xarray.open_mfdataset.html + download_glofas_discharge_kwargs + Additional arguments to + :py:func:`climada_petals.hazard.rf_glofas.transform_ops.download_glofas_discharge` + + Returns + ------- + forecast : xr.DataArray + Downloaded forecast as DataArray after preprocessing + + See Also + -------- + :py:func:`climada_petals.hazard.rf_glofas.transform_ops.download_glofas_discharge` + """ + leadtime_hour = list( + map(str, (np.arange(1, lead_time_days + 1, dtype=np.int_) * 24).flat) + ) + forecast = download_glofas_discharge( + product="forecast", + date_from=pd.Timestamp(forecast_date).date().isoformat(), + date_to=None, + countries=countries, + preprocess=preprocess, + leadtime_hour=leadtime_hour, + **download_glofas_discharge_kwargs, + ) + if self.store_intermediates: + save_file(forecast, self.cache_paths.discharge, zlib=False) + return forecast + + def download_reanalysis( + self, + countries: Union[str, Iterable[str]], + year: int, + preprocess: Optional[Callable] = None, + **download_glofas_discharge_kwargs, + ): + """Download GloFAS discharge historical data + + If :py:attr:`store_intermediates` is true, the returned data is also stored in + :py:attr:`cache_paths`. + + Parameters + ---------- + countries : str or list of str + Names or codes of countries to download data for. The downloaded data will + be a lat/lon grid covering all specified countries. + year : int + The year to download data for. + preprocess + Callable for preprocessing data while loading it. See + https://docs.xarray.dev/en/stable/generated/xarray.open_mfdataset.html + download_glofas_discharge_kwargs + Additional arguments to + :py:func:`climada_petals.hazard.rf_glofas.transform_ops.download_glofas_discharge` + + Returns + ------- + reanalysis : xr.DataArray + Downloaded forecast as DataArray after preprocessing + + See Also + -------- + :py:func:`climada_petals.hazard.rf_glofas.transform_ops.download_glofas_discharge` + """ + reanalysis = download_glofas_discharge( + product="historical", + date_from=str(year), + date_to=None, + countries=countries, + preprocess=preprocess, + **download_glofas_discharge_kwargs, + ) + if self.store_intermediates: + save_file(reanalysis, self.cache_paths.discharge, zlib=False) + return reanalysis + + def return_period( + self, + discharge: Optional[xr.DataArray] = None, + ) -> xr.DataArray: + """Compute the return period for a given discharge + + If no discharge data is given as parameter, the discharge cache will be + accessed. + + If :py:attr:`store_intermediates` is true, the returned data is also stored in + :py:attr:`cache_paths`. + + Parameters + ---------- + discharge : xr.DataArray, optional + The discharge data to operate on. Defaults to ``None``, which indicates that + data should be loaded from the cache + + Returns + ------- + r_period : xr.DataArray + Return period for each location of the input discharge. + + See Also + -------- + :py:func:`climada_petals.hazard.rf_glofas.transform_ops.return_period` + """ + with _maybe_open_dataarray( + discharge, self.cache_paths.discharge, chunks="auto" + ) as discharge: + r_period = return_period( + discharge, self.gumbel_fits["loc"], self.gumbel_fits["scale"] + ) + + if self.store_intermediates: + save_file(r_period, self.cache_paths.return_period) + return r_period + + def return_period_resample( + self, + num_bootstrap_samples: int, + discharge: Optional[xr.DataArray] = None, + fit_method: str = "MM", + num_workers: int = 1, + memory_per_worker: str = "2G", + ): + """Compute the return period for a given discharge using bootstrap sampling. + + For each input discharge value, this creates an ensemble of return periods by + employing bootstrap sampling. The ensemble size is controlled with + ``num_bootstrap_samples``. + + If :py:attr:`store_intermediates` is true, the returned data is also stored in + :py:attr:`cache_paths`. + + Parameters + ---------- + num_bootstrap_samples : int + Number of bootstrap samples to compute for each discharge value. + discharge : xr.DataArray, optional + The discharge data to operate on. Defaults to ``None``, which indicates that + data should be loaded from the cache. + fit_method : str, optional + Method for fitting data to bootstrapped samples. + + * ``"MM"``: Method of Moments + * ``"MLE"``: Maximum Likelihood Estimation + + num_workers : int, optional + Number of parallel processes to use when computing the samples. + memory_per_worker : str, optional + Memory to allocate for each process. + + Returns + ------- + r_period : xr.DataArray + Return period samples for each location of the input discharge. + + See Also + -------- + :py:func:`climada_petals.hazard.rf_glofas.transform_ops.return_period_resample` + """ + # Use smaller chunks so function does not suffocate + with _maybe_open_dataarray( + discharge, + self.cache_paths.discharge, + chunks=dict(longitude=50, latitude=50), + ) as discharge_data: + kwargs = dict( + discharge=discharge_data, + gev_loc=self.gumbel_fits["loc"], + gev_scale=self.gumbel_fits["scale"], + gev_samples=self.gumbel_fits["samples"], + bootstrap_samples=num_bootstrap_samples, + fit_method=fit_method, + ) + + def work(): + r_period = return_period_resample(**kwargs) + if self.store_intermediates: + save_file(r_period, self.cache_paths.return_period, zlib=False) + return r_period + + if num_workers > 1: + with dask_client(num_workers, 1, memory_per_worker): + return work() + else: + return work() + + def regrid( + self, + r_period: Optional[xr.DataArray] = None, + method: str = "bilinear", + reuse_regridder: bool = False, + ): + """Regrid the return period data onto the flood hazard map grid. + + This computes the regridding matrix for the given coordinates and then performs + the actual regridding. The matrix is stored in :py:attr:`regridder`. If + another regridding is performed on the same grid (but possibly different data), + the regridder can be reused to save time. To control that, set + ``reuse_regridder=True``. + + If :py:attr:`store_intermediates` is true, the returned data is also stored in + :py:attr:`cache_paths`. + + Parameters + ---------- + r_period : xr.DataArray, optional + The return period data to regrid. Defaults to ``None``, which indicates that + data should be loaded from the cache. + method : str, optional + Interpolation method of the return period data. Defaults to ``"bilinear"``. + See https://xesmf.readthedocs.io/en/stable/notebooks/Compare_algorithms.html + reuse_regridder : bool, optional + Reuse the regridder stored if one is stored. Defaults to ``False``, which + means that a new regridder is always built when calling this function. + If ``True``, and no regridder is stored, it will be built nonetheless. + + Returns + ------- + return_period_regrid : xr.DataArray + The regridded return period data. + + See Also + -------- + :py:func:`climada_petals.hazard.rf_glofas.transform_ops.regrid` + """ + # NOTE: Chunks must be small because resulting array is huge! + with _maybe_open_dataarray( + r_period, + self.cache_paths.return_period, + chunks=dict(longitude=-1, latitude=-1, time=1, sample=1, number=1, step=1), + ) as return_period_data: + if not reuse_regridder: + self.regridder = None + return_period_regrid, self.regridder = regrid( + return_period_data, + self.flood_maps, + method=method, + regridder=self.regridder, + return_regridder=True, + ) + + if self.store_intermediates: + save_file( + return_period_regrid, + self.cache_paths.return_period_regrid, + zlib=False, + ) + return return_period_regrid + + def apply_protection(self, return_period_regrid: Optional[xr.DataArray] = None): + """Limit the return period data by applying FLOPROS protection levels. + + This sets each return period value where the local FLOPROS protection level is + not exceeded to NaN and returns the result. Protection levels are read from + :py:attr:`flopros`. + + If :py:attr:`store_intermediates` is true, the returned data is also stored in + :py:attr:`cache_paths`. + + Parameters + ---------- + return_period_regrid : xr.DataArray, optional + The return period data to regrid. Defaults to ``None``, which indicates that + data should be loaded from the cache. + + Returns + ------- + return_period_regrid_protect : xr.DataArray + The regridded return period where each value that does not reach the + protection limit is set to NaN. + + See Also + -------- + :py:func:`climada_petals.hazard.rf_glofas.transform_ops.apply_flopros` + """ + with _maybe_open_dataarray( + return_period_regrid, self.cache_paths.return_period_regrid, chunks="auto" + ) as return_period_regrid_data: + return_period_regrid_protect = apply_flopros( + self.flopros, return_period_regrid_data + ) + + if self.store_intermediates: + save_file( + return_period_regrid_protect, + self.cache_paths.return_period_regrid_protect, + zlib=False, + ) + return return_period_regrid_protect + + def flood_depth(self, return_period_regrid: Optional[xr.DataArray] = None): + """Compute the flood depth from regridded return period data. + + Interpolate the flood hazard maps stored in :py:attr`flood_maps` in the return + period dimension at every location to compute the flood footprint. + + Note + ---- + Even if :py:attr:`store_intermediates` is true, the returned data is **not** + stored automatically! Use + :py:func:`climada_petals.hazard.rf_glofas.transform_ops.save_file` to store + the data yourself. + + Parameters + ---------- + return_period_regrid : xr.DataArray, optional + The regridded return period data to use for computing the flood footprint. + Defaults to ``None`` which indicates that data should be loaded from the + cache. If :py:attr:`RiverFloodCachePaths.return_period_regrid_protect` + exists, that data is used. Otherwise, the "unprotected" data + :py:attr:`RiverFloodCachePaths.return_period_regrid` is loaded. + + Returns + ------- + inundation : xr.DataArray + The flood inundation at every location of the flood hazard maps grid. + """ + file_path = self.cache_paths.return_period_regrid + if ( + return_period_regrid is None + and self.cache_paths.return_period_regrid_protect.is_file() + ): + file_path = self.cache_paths.return_period_regrid_protect + + with _maybe_open_dataarray( + return_period_regrid, file_path, chunks="auto" + ) as return_period_regrid_data: + inundation = flood_depth(return_period_regrid_data, self.flood_maps) + return inundation diff --git a/climada_petals/hazard/rf_glofas/setup.py b/climada_petals/hazard/rf_glofas/setup.py new file mode 100644 index 000000000..e64362417 --- /dev/null +++ b/climada_petals/hazard/rf_glofas/setup.py @@ -0,0 +1,238 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +Module preparing data for the river flood inundation model +""" +from typing import Union +from pathlib import Path +from tempfile import TemporaryFile, TemporaryDirectory +from urllib.parse import urlparse +from zipfile import ZipFile +import logging +import shutil + +import xarray as xr +import requests + +from .transform_ops import ( + merge_flood_maps, + download_glofas_discharge, + fit_gumbel_r, + save_file, +) +from .rf_glofas import DEFAULT_DATA_DIR + +LOGGER = logging.getLogger(__name__) + +JRC_FLOOD_HAZARD_MAPS = [ + "https://cidportal.jrc.ec.europa.eu/ftp/jrc-opendata/FLOODS/GlobalMaps/floodMapGL_rp10y.zip", + "https://cidportal.jrc.ec.europa.eu/ftp/jrc-opendata/FLOODS/GlobalMaps/floodMapGL_rp20y.zip", + "https://cidportal.jrc.ec.europa.eu/ftp/jrc-opendata/FLOODS/GlobalMaps/floodMapGL_rp50y.zip", + "https://cidportal.jrc.ec.europa.eu/ftp/jrc-opendata/FLOODS/GlobalMaps/floodMapGL_rp100y.zip", + "https://cidportal.jrc.ec.europa.eu/ftp/jrc-opendata/FLOODS/GlobalMaps/floodMapGL_rp200y.zip", + "https://cidportal.jrc.ec.europa.eu/ftp/jrc-opendata/FLOODS/GlobalMaps/floodMapGL_rp500y.zip", +] + +FLOPROS_DATA = \ + "https://nhess.copernicus.org/articles/16/1049/2016/nhess-16-1049-2016-supplement.zip" + +GUMBEL_FIT_DATA = \ + "https://www.research-collection.ethz.ch/bitstream/handle/20.500.11850/641667/gumbel-fit.nc" + + +def download_flopros_database(output_dir: Union[str, Path] = DEFAULT_DATA_DIR): + """Download the FLOPROS database and place it into the output directory. + + Download the supplementary material of `P. Scussolini et al.: "FLOPROS: an evolving + global database of flood protection standards" + `_, extract the zipfile, and retrieve + the shapefile within. Discard the temporary data afterwards. + """ + LOGGER.debug("Downloading FLOPROS database") + + # Download the file + response = requests.get(FLOPROS_DATA, stream=True) + with TemporaryFile(suffix=".zip") as file: + for chunk in response.iter_content(chunk_size=10 * 1024): + file.write(chunk) + + # Unzip the folder + with TemporaryDirectory() as tmpdir: + with ZipFile(file) as zipfile: + zipfile.extractall(tmpdir) + + shutil.copytree( + Path(tmpdir) / "Scussolini_etal_Suppl_info/FLOPROS_shp_V1", + Path(output_dir) / "FLOPROS_shp_V1", + dirs_exist_ok=True, + ) + + +def download_flood_hazard_maps(output_dir: Union[str, Path]): + """Download the JRC flood hazard maps and unzip them + + This stores the downloaded zip files as temporary files which are discarded after + unzipping. + """ + LOGGER.debug("Downloading flood hazard maps") + for url in JRC_FLOOD_HAZARD_MAPS: + # Set output path for the archive + file_name = Path(urlparse(url).path).stem + output_path = Path(output_dir) / file_name + output_path.mkdir(exist_ok=True) + + # Download the file (streaming, because they are around 45 MB) + response = requests.get(url, stream=True) + with TemporaryFile(suffix=".zip") as file: + for chunk in response.iter_content(chunk_size=10 * 1024): + file.write(chunk) + + # Unzip the file + with ZipFile(file) as zipfile: + zipfile.extractall(output_path) + + +def setup_flood_hazard_maps(flood_maps_dir: Path, output_dir=DEFAULT_DATA_DIR): + """Download the flood hazard maps and merge them into a single NetCDF file + + Maps will be downloaded into ``flood_maps_dir`` if it does not exist. Then, the + single maps are re-written as NetCDF files, if these do not exist. Finally, all maps + are merged into a single dataset and written to the ``output_dir``. Because NetCDF + files are more flexibly read and written, this procedure is more efficient that + directly merging the GeoTIFF files into a single dataset. + + Parameters + ---------- + flood_maps_dir : Path + Storage directory of the flood maps as GeoTIFF files. Will be created if it does + not exist, in which case the files are automatically downloaded. + output_dir : Path + Directory to store the flood maps dataset. + """ + # Download flood maps if directory does not exist + if not flood_maps_dir.is_dir(): + LOGGER.debug( + "No flood maps found. Downloading GeoTIFF files to %s", flood_maps_dir + ) + flood_maps_dir.mkdir() + download_flood_hazard_maps(flood_maps_dir) + + # Find flood maps + flood_maps_paths = list(Path(flood_maps_dir).glob("**/floodMapGL_rp*y.tif")) + flood_maps_paths_nc = [path.with_suffix(".nc") for path in flood_maps_paths] + + # Rewrite GeoTIFFs as NetCDFs + LOGGER.debug("Rewriting flood hazard maps to NetCDF files") + for path, path_nc in zip(flood_maps_paths, flood_maps_paths_nc): + if not path_nc.is_file(): + # This uses rioxarray to open a GeoTIFF as an xarray DataArray: + with xr.open_dataarray(path, engine="rasterio", chunks="auto") as d_arr: + save_file(d_arr, path_nc, zlib=True) + + # Load NetCDFs and merge + LOGGER.debug("Merging flood hazard maps into single dataset") + flood_maps = { + str(path): xr.open_dataset(path, engine="netcdf4", chunks="auto")["band_data"] + for path in flood_maps_paths_nc + } + da_flood_maps = merge_flood_maps(flood_maps) + save_file(da_flood_maps, output_dir / "flood-maps.nc", zlib=True) + + +def setup_gumbel_fit( + output_dir=DEFAULT_DATA_DIR, num_downloads: int = 1, parallel: bool = False +): + """Download historical discharge data and compute the Gumbel distribution fits. + + Data is downloaded from the Copernicus Climate Data Store (CDS). + + Parameters + ---------- + output_dir + The directory to place the resulting file + num_downloads : int + Number of parallel downloads from the CDS. Defaults to 1. + parallel : bool + Whether to preprocess data in parallel. Defaults to ``False``. + """ + # Download discharge and preprocess + LOGGER.debug("Downloading historical discharge data") + discharge = download_glofas_discharge( + "historical", + "1979", + "2015", + num_proc=num_downloads, + preprocess=lambda x: x.groupby("time.year").max(), + open_mfdataset_kw=dict( + concat_dim="year", + chunks=dict(time=-1, longitude="auto", latitude="auto"), + parallel=parallel, + ), + ) + discharge_file = output_dir / "discharge.nc" + discharge.to_netcdf(discharge_file, engine="netcdf4") + discharge.close() + + # Fit Gumbel + LOGGER.debug("Fitting Gumbel distributions to historical discharge data") + with xr.open_dataarray( + discharge_file, chunks=dict(time=-1, longitude=50, latitude=50) + ) as discharge: + fit = fit_gumbel_r(discharge, min_samples=10) + fit.to_netcdf(output_dir / "gumbel-fit.nc", engine="netcdf4") + + +def download_gumbel_fit(output_dir=DEFAULT_DATA_DIR): + """Download the pre-computed Gumbel parameters from the ETH research collection. + + Download dataset of https://doi.org/10.3929/ethz-b-000641667 + """ + LOGGER.debug("Downloading Gumbel fit parameters") + response = requests.get(GUMBEL_FIT_DATA, stream=True) + with open(output_dir / "gumbel-fit.nc", "wb") as file: + for chunk in response.iter_content(chunk_size=10 * 1024): + file.write(chunk) + + +def setup_all( + output_dir: Union[str, Path] = DEFAULT_DATA_DIR, +): + """Set up the data for river flood computations. + + This performs two tasks: + + #. Downloading the JRC river flood hazard maps and merging them into a single NetCDF + dataset. + #. Downloading the FLOPROS flood protection database. + #. Downloading the Gumbel distribution parameters fitted to GloFAS river discharge + reanalysis data from 1979 to 2015. + + Parameters + ---------- + output_dir : Path or str, optional + The directory to store the datasets into. + """ + # Make sure the path exists + output_dir = Path(output_dir) + output_dir.mkdir(exist_ok=True) + + setup_flood_hazard_maps( + flood_maps_dir=DEFAULT_DATA_DIR / "flood-maps", output_dir=output_dir + ) + download_flopros_database(output_dir) + download_gumbel_fit(output_dir) diff --git a/climada_petals/hazard/rf_glofas/test/test_cds_glofas_downloader.py b/climada_petals/hazard/rf_glofas/test/test_cds_glofas_downloader.py new file mode 100644 index 000000000..29ccdbe5f --- /dev/null +++ b/climada_petals/hazard/rf_glofas/test/test_cds_glofas_downloader.py @@ -0,0 +1,219 @@ +import tempfile +import unittest +import unittest.mock as mock +from copy import deepcopy +from pathlib import Path +from datetime import date + +import cdsapi +from ruamel.yaml import YAML + +from climada_petals.hazard.rf_glofas.cds_glofas_downloader import ( + glofas_request, + glofas_request_single, + request_to_md5, + cleanup_download_dir, + DEFAULT_REQUESTS, +) + + +class TestGloFASRequest(unittest.TestCase): + """Test requests to the CDS API""" + + def setUp(self): + """Create temporary directory in case we download data""" + self.tempdir = tempfile.TemporaryDirectory() + + def tearDown(self): + """Clean up the temporary directory""" + self.tempdir.cleanup() + + def test_cleanup_download_dir(self): + """Check if deleting download directory contents works""" + _, filename = tempfile.mkstemp(dir=self.tempdir.name) + cleanup_download_dir(self.tempdir.name, dry_run=True) + self.assertTrue(Path(filename).is_file()) + cleanup_download_dir(self.tempdir.name, dry_run=False) + self.assertFalse(Path(filename).is_file()) + + @mock.patch( + "climada_petals.hazard.rf_glofas.cds_glofas_downloader.Client", autospec=True + ) + def test_request_single(self, client_mock): + """Test execution of a single request without actually downloading stuff""" + product = "product" + request = deepcopy(DEFAULT_REQUESTS["forecast"]) + outdir = Path(self.tempdir.name) + client_obj_mock = mock.create_autospec(cdsapi.Client) + client_mock.return_value = client_obj_mock + + # Call once + glofas_request_single(product, request, outdir, use_cache=True) + client_mock.assert_called_once_with(quiet=False, debug=False) + call_args = client_obj_mock.retrieve.call_args.args + self.assertEqual(call_args[0], product) + self.assertEqual(call_args[1], request) + request_hash = request_to_md5(request) + self.assertIn(request_hash, call_args[2].stem) + self.assertIn(date.today().strftime("%y%m%d"), call_args[2].stem) + + # Check if request was correctly dumped + outfile_yml = next(outdir.glob(f"*-{request_hash}.yml")) + yaml = YAML() + self.assertEqual(yaml.load(outfile_yml), request) + + # Call again to check caching, client should not have been called again + with tempfile.NamedTemporaryFile(dir=outdir, suffix=f"-{request_hash}.grib"): + client_mock.reset_mock() + client_obj_mock.reset_mock() + glofas_request_single(product, request, outdir, use_cache=True) + client_mock.assert_not_called() + client_obj_mock.retrieve.assert_not_called() + + # ...but it should when cache is not used + # Also check client_kw here! + glofas_request_single( + product, + request, + outdir, + use_cache=False, + client_kw=dict(verify=True, debug=True), + ) + client_mock.assert_called_once_with(quiet=False, debug=True, verify=True) + call_args = client_obj_mock.retrieve.call_args.args + self.assertEqual(call_args[0], product) + self.assertEqual(call_args[1], request) + self.assertIn(request_hash, call_args[2].stem) + + # Different request should also induce new download + client_mock.reset_mock() + client_obj_mock.reset_mock() + new_request = deepcopy(request) + new_request["leadtime_hour"][2] = "xx" + glofas_request_single(product, new_request, outdir, use_cache=True) + client_mock.assert_called_once_with(quiet=False, debug=False) + call_args = client_obj_mock.retrieve.call_args.args + self.assertEqual(call_args[0], product) + self.assertEqual(call_args[1], new_request) + self.assertIn(request_to_md5(new_request), call_args[2].stem) + + @mock.patch( + "climada_petals.hazard.rf_glofas.cds_glofas_downloader.glofas_request_multiple", + autospec=True, + ) + def test_forecast_single(self, mock_req): + """Test request for a single forecast day""" + glofas_request("forecast", "2022-01-01", None, self.tempdir.name) + request = deepcopy(DEFAULT_REQUESTS["forecast"]) + request["month"] = "01" + request["day"] = "01" + mock_req.assert_called_once_with( + "cems-glofas-forecast", + [request], + self.tempdir.name, + 1, + True, + None, + ) + + @mock.patch( + "climada_petals.hazard.rf_glofas.cds_glofas_downloader.Client", autospec=True + ) + def test_forecast_filetype(self, client_mock): + """Test correct filetype suffix""" + client_obj_mock = mock.create_autospec(cdsapi.Client) + client_mock.return_value = client_obj_mock + + # Use default grib + request = deepcopy(DEFAULT_REQUESTS["forecast"]) + request["format"] = "grib" + glofas_request_single( + "forecast", + request, + self.tempdir.name, + use_cache=False, + ) + call_args = client_obj_mock.retrieve.call_args.args + self.assertEqual(call_args[2].suffix, ".grib") + + # Use nonsense (should be .nc then) + request["format"] = "foo" + glofas_request_single( + "forecast", + request, + self.tempdir.name, + use_cache=False, + ) + call_args = client_obj_mock.retrieve.call_args.args + self.assertEqual(call_args[2].suffix, ".nc") + + def test_forecast_wrong_date(self): + """Test correct error for wrong date specification""" + with self.assertRaises(ValueError): + glofas_request("forecast", "2022-01-01", "2022-01111", self.tempdir.name) + + @mock.patch( + "climada_petals.hazard.rf_glofas.cds_glofas_downloader.glofas_request_multiple", + autospec=True, + ) + def test_forecast_iter(self, mock_req): + """Test request for multiple forecast days""" + glofas_request("forecast", "2022-12-31", "2023-01-01", self.tempdir.name) + requests = mock_req.call_args.args[1] + self.assertEqual(requests[0]["year"], "2022") + self.assertEqual(requests[1]["year"], "2023") + self.assertEqual(requests[0]["month"], "12") + self.assertEqual(requests[1]["month"], "01") + self.assertEqual(requests[0]["day"], "31") + self.assertEqual(requests[1]["day"], "01") + self.assertEqual(mock_req.call_args.args[2], self.tempdir.name) + + @mock.patch( + "climada_petals.hazard.rf_glofas.cds_glofas_downloader.glofas_request_multiple", + autospec=True, + ) + def test_historical_single(self, mock_req): + """Test request for single historical year""" + glofas_request("historical", "2019", None, self.tempdir.name) + request = deepcopy(DEFAULT_REQUESTS["historical"]) + request["hyear"] = "2019" + mock_req.assert_called_once_with( + "cems-glofas-historical", + [request], + self.tempdir.name, + 1, + True, + None, + ) + + @mock.patch( + "climada_petals.hazard.rf_glofas.cds_glofas_downloader.glofas_request_multiple", + autospec=True, + ) + def test_historical_iter(self, mock_req): + """Test request for multiple historical years""" + glofas_request("historical", "2019", "2021", self.tempdir.name) + requests = mock_req.call_args.args[1] + self.assertEqual(requests[0]["hyear"], "2019") + self.assertEqual(requests[1]["hyear"], "2020") + self.assertEqual(requests[2]["hyear"], "2021") + self.assertEqual( + mock_req.call_args.args[2], + self.tempdir.name + ) + + def test_historical_wrong_date(self): + """Test correct error for wrong date specification""" + with self.assertRaises(ValueError): + glofas_request("historical", "2022", "2022-01-01", self.tempdir.name) + + def test_wrong_product(self): + """Test handling of unknown product""" + with self.assertRaises(NotImplementedError): + glofas_request("abc", "2022", "2022", self.tempdir.name) + + +# Execute Tests +if __name__ == "__main__": + TESTS = unittest.TestLoader().loadTestsFromTestCase(TestGloFASRequest) + unittest.TextTestRunner(verbosity=2).run(TESTS) diff --git a/climada_petals/hazard/rf_glofas/test/test_rf_glofas.py b/climada_petals/hazard/rf_glofas/test/test_rf_glofas.py new file mode 100644 index 000000000..e2cf6328e --- /dev/null +++ b/climada_petals/hazard/rf_glofas/test/test_rf_glofas.py @@ -0,0 +1,184 @@ +import unittest +from unittest.mock import patch, MagicMock + +import pandas as pd +import xarray as xr +import numpy as np +import numpy.testing as npt +from dask.distributed import Client + +from climada.hazard import Hazard +from climada_petals.hazard.rf_glofas import hazard_series_from_dataset +from climada_petals.hazard.rf_glofas.rf_glofas import dask_client + + +class TestDaskClient(unittest.TestCase): + """Test the custom dask client context manager""" + + def test_dask_client(self): + """Check if context manager behaves as expected""" + client = MagicMock(spec=Client) + with patch( + "climada_petals.hazard.rf_glofas.rf_glofas.Client", return_value=client + ) as pt: + # Call the manager + with dask_client(2, 3, "1G", "foo", foo="bar") as cm: + self.assertIs(cm, client) + pt.assert_called_once_with( + "foo", + n_workers=2, + threads_per_worker=3, + memory_limit="1G", + foo="bar", + ) + + client.close.assert_called_once_with() + + +class TestHazardSeriesFromDataset(unittest.TestCase): + """Test case for contents of the `rf_glofas` submodule""" + + def test_single_hazard(self): + """Test hazard_series_from_dataset resulting in single hazard""" + ds = xr.Dataset( + data_vars=dict( + intensity=(["time", "latitude", "longitude"], np.zeros((4, 2, 3))) + ), + coords=dict( + time=( + "time", + np.array( + [np.datetime64(f"2000-01-{i:02d}") for i in range(1, 5)] + ).astype("datetime64[ns]"), + ), + latitude=("latitude", np.arange(2)), + longitude=("longitude", np.arange(3)), + ), + ) + + # Use time as event + haz = hazard_series_from_dataset(ds, "intensity", "time") + self.assertIsInstance(haz, Hazard) + + # Check hazard + num_events = ds.sizes["time"] + self.assertEqual(haz.size, num_events) + num_centroids = ds.sizes["latitude"] * ds.sizes["longitude"] + self.assertEqual(haz.centroids.size, num_centroids) + self.assertTupleEqual(haz.intensity.shape, (num_events, num_centroids)) + + # Check data + npt.assert_array_equal( + haz.date, [pd.to_datetime(x).toordinal() for x in ds["time"].values] + ) + + def _check_series(self, series, length, num_events, num_centroids): + """Check the value within a hazard series""" + self.assertEqual(series.size, length) + npt.assert_array_equal([haz.size for haz in series], [num_events] * length) + npt.assert_array_equal( + [haz.centroids.size for haz in series], + [num_centroids] * length, + ) + npt.assert_array_equal( + [haz.intensity.shape for haz in series], + [(num_events, num_centroids)] * length, + ) + + def test_single_dim(self): + """Test hazard_series_from_dataset resulting in single level series""" + ds = xr.Dataset( + data_vars=dict( + intensity=( + ["number", "time", "latitude", "longitude"], + np.zeros((5, 4, 2, 3)), + ) + ), + coords=dict( + number=("number", np.arange(5)), + time=( + "time", + np.array( + [np.datetime64(f"2000-01-{i:02d}") for i in range(1, 5)] + ).astype("datetime64[ns]"), + ), + latitude=("latitude", np.arange(2)), + longitude=("longitude", np.arange(3)), + ), + ) + + # Use time as event + haz_series = hazard_series_from_dataset(ds, "intensity", "time") + self.assertIsInstance(haz_series, pd.Series) + + # Check index + index = haz_series.index + self.assertEqual(index.nlevels, 1) + self.assertSetEqual(set(index.names), {"number"}) + npt.assert_array_equal(index.get_level_values("number"), ds["number"].values) + + # Check series + self._check_series( + haz_series, + length=ds.sizes["number"], + num_events=ds.sizes["time"], + num_centroids=ds.sizes["latitude"] * ds.sizes["longitude"], + ) + + def test_multi_dims(self): + """Test hazard_series_from_dataset resulting in multiindex series""" + ds = xr.Dataset( + data_vars=dict( + intensity=( + ["another_number", "number", "time", "latitude", "longitude"], + np.zeros((6, 5, 4, 2, 3)), + ) + ), + coords=dict( + another_number=("another_number", np.arange(6)), + number=("number", np.arange(5)), + time=( + "time", + np.array( + [np.datetime64(f"2000-01-{i:02d}") for i in range(1, 5)] + ).astype("datetime64[ns]"), + ), + latitude=("latitude", np.arange(2)), + longitude=("longitude", np.arange(3)), + ), + ) + + # Use time as event + haz_series = hazard_series_from_dataset(ds, "intensity", "time") + self.assertIsInstance(haz_series, pd.Series) + + # Check index + index = haz_series.index + self.assertEqual(index.nlevels, 2) + self.assertSetEqual( + set(index.names), {"number", "another_number"} + ) # NOTE: Order not defined + npt.assert_array_equal( + index.get_level_values("number").unique(), ds["number"].values + ) + npt.assert_array_equal( + index.get_level_values("another_number").unique(), + ds["another_number"].values, + ) + + # Check series + self._check_series( + haz_series, + length=ds.sizes["number"] * ds.sizes["another_number"], + num_events=ds.sizes["time"], + num_centroids=ds.sizes["latitude"] * ds.sizes["longitude"], + ) + + +# Execute Tests +if __name__ == "__main__": + TESTS = unittest.TestLoader().loadTestsFromTestCase(TestDaskClient) + TESTS.addTests( + unittest.TestLoader().loadTestsFromTestCase(TestHazardSeriesFromDataset) + ) + unittest.TextTestRunner(verbosity=2).run(TESTS) diff --git a/climada_petals/hazard/rf_glofas/test/test_river_flood_computation.py b/climada_petals/hazard/rf_glofas/test/test_river_flood_computation.py new file mode 100644 index 000000000..3ba06c4e3 --- /dev/null +++ b/climada_petals/hazard/rf_glofas/test/test_river_flood_computation.py @@ -0,0 +1,389 @@ +import unittest +from unittest.mock import patch, MagicMock, DEFAULT +from tempfile import TemporaryDirectory +from pathlib import Path + +import xarray as xr +import xarray.testing as xrt +import geopandas as gpd +import pandas.testing as pdt + +from climada.util.constants import DEF_CRS +from climada_petals.hazard.rf_glofas.river_flood_computation import ( + _maybe_open_dataarray, + RiverFloodInundation, +) + + +class TestMaybeOpenDataArray(unittest.TestCase): + """Check the maybe_open_dataarray context manager""" + + def setUp(self): + """Create the input array""" + self.tempdir = TemporaryDirectory() + self.arr_1 = xr.DataArray(data=[0], coords={"dim": [0]}) + self.arr_2 = xr.DataArray(data=[1], coords={"dim": [1]}) + self.filename = Path(self.tempdir.name) / "file.nc" + self.arr_2.to_netcdf(self.filename) + + def tearDown(self): + """Clean up temporary directory""" + self.tempdir.cleanup() + + @patch("climada_petals.hazard.rf_glofas.river_flood_computation.xr.open_dataarray") + def test_with_arr(self, open_dataarray_mock): + """Check behavior if array is given""" + with _maybe_open_dataarray(self.arr_1, self.filename) as da: + xrt.assert_identical(self.arr_1, da) + open_dataarray_mock.assert_not_called() + + def test_without_arr(self): + """Check if file is correctly opened with no array input""" + with _maybe_open_dataarray(None, self.filename) as da: + xrt.assert_identical(self.arr_2, da) + + @patch("climada_petals.hazard.rf_glofas.river_flood_computation.xr.open_dataarray") + def test_file_is_closed(self, open_dataarray_mock): + """Check if the dataset is correctly close after release""" + arr = MagicMock(xr.DataArray) + open_dataarray_mock.return_value = arr + + with _maybe_open_dataarray(None, self.filename) as da: + open_dataarray_mock.assert_called_once_with(self.filename) + da.close.assert_not_called() + + da.close.assert_called_once() + + @patch("climada_petals.hazard.rf_glofas.river_flood_computation.xr.open_dataarray") + def test_kwargs(self, open_dataarray_mock): + """Check if kwargs are passed correctly""" + kwargs = {"chunks": "auto", "foo": "bar"} + with _maybe_open_dataarray(None, self.filename, **kwargs) as _: + open_dataarray_mock.assert_called_once_with(self.filename, **kwargs) + + +@patch.multiple( + "climada_petals.hazard.rf_glofas.river_flood_computation", + download_glofas_discharge=DEFAULT, + return_period=DEFAULT, + return_period_resample=DEFAULT, + regrid=DEFAULT, + apply_flopros=DEFAULT, + flood_depth=DEFAULT, +) +class TestRiverFloodInundation(unittest.TestCase): + """Check the RiverFloodInundation class""" + + @classmethod + def setUpClass(cls): + """Create fake data""" + cls.tempdir = TemporaryDirectory() + cls.temppath = Path(cls.tempdir.name) + + cls.flood_maps = xr.DataArray( + [[[0]]], + coords={"return_period": [0], "longitude": [0], "latitude": [0]}, + name="flood_maps", + ) + cls.flood_maps.to_netcdf(cls.temppath / "flood-maps.nc") + + arr = xr.DataArray([[0]], coords={"longitude": [0], "latitude": [0]}) + cls.gumbel_fits = xr.Dataset({"loc": arr, "scale": arr, "samples": arr}) + cls.gumbel_fits.to_netcdf(cls.temppath / "gumbel-fit.nc") + + cls.flopros = gpd.GeoDataFrame( + data={"data": [0]}, geometry=gpd.points_from_xy([0], [0], crs=DEF_CRS) + ) + Path(cls.temppath / "FLOPROS_shp_V1").mkdir() + cls.flopros.to_file(cls.temppath / "FLOPROS_shp_V1/FLOPROS_shp_V1.shp") + + @classmethod + def tearDownClass(cls): + """Clean up the temporary directory""" + cls.tempdir.cleanup() + + def setUp(self): + """Initialize the class instance""" + self.cache_dir = self.temppath / "cache" + self.rf = RiverFloodInundation(data_dir=self.temppath, cache_dir=self.cache_dir) + + def test_init(self, **_): + """Test object initialization""" + # Load files + xrt.assert_identical(self.rf.flood_maps, self.flood_maps) + xrt.assert_identical(self.rf.gumbel_fits, self.gumbel_fits) + pdt.assert_frame_equal(self.rf.flopros, self.flopros) + + # Create cache dir + self.assertTrue(self.cache_dir.is_dir()) + self.assertTrue(Path(self.rf._tempdir.name).is_dir()) + for path in self.rf.cache_paths._asdict().values(): + self.assertIn(self.temppath, path.parents) + + # Check that data_dir must exist + with self.assertRaises(FileNotFoundError) as cm: + RiverFloodInundation(data_dir="some_dir") + self.assertIn("'data_dir' does not exist", str(cm.exception)) + + def test_clear_cache(self, **_): + """Check if cache directory is correctly removed""" + self.assertTrue(self.cache_dir.is_dir()) + first_cache = Path(self.rf._tempdir.name) + self.assertTrue(first_cache.is_dir()) + + # Create new cache dir + self.rf.clear_cache() + second_cache = Path(self.rf._tempdir.name) + self.assertFalse(first_cache.is_dir()) + self.assertTrue(second_cache.is_dir()) + for path in self.rf.cache_paths._asdict().values(): + self.assertIn(second_cache, path.parents) + + def _assert_store_intermediates( + self, rf, func_name, arr_compare, cache_name, *args, **kwargs + ): + """Check if store_intermediates behaves correctly""" + func = getattr(rf, func_name) + filename = getattr(rf.cache_paths, cache_name) + filename.unlink(missing_ok=True) + + rf.store_intermediates = False + result = func(*args, **kwargs) + xrt.assert_identical(result, arr_compare) + self.assertFalse(filename.is_file()) + + rf.store_intermediates = True + result = func(*args, **kwargs) + xrt.assert_identical(result, arr_compare) + self.assertTrue(filename.is_file()) + with xr.open_dataarray(filename) as arr: + xrt.assert_identical(arr, arr_compare) + + def test_download_forecast(self, download_glofas_discharge: MagicMock, **_): + """Check if download_forecast passes parameters correctly""" + download_glofas_discharge.return_value = self.flood_maps + + preprocess = lambda x: x + self._assert_store_intermediates( + self.rf, + "download_forecast", + self.flood_maps, + "discharge", + "ABC", + "2000-01-01", + lead_time_days=2, + preprocess=preprocess, + foo="bar", + ) + download_glofas_discharge.assert_called_with( + product="forecast", + date_from="2000-01-01", + date_to=None, + countries="ABC", + preprocess=preprocess, + leadtime_hour=["24", "48"], + foo="bar", + ) + + def test_download_reanalysis(self, download_glofas_discharge: MagicMock, **_): + """Check if download_reanalysis passes parameters correctly""" + download_glofas_discharge.return_value = self.flood_maps + preprocess = lambda x: x + self._assert_store_intermediates( + self.rf, + "download_reanalysis", + self.flood_maps, + "discharge", + "ABC", + 2000, + preprocess=preprocess, + foo="bar", + ) + download_glofas_discharge.assert_called_with( + product="historical", + date_from="2000", + date_to=None, + countries="ABC", + preprocess=preprocess, + foo="bar", + ) + + def test_return_period(self, return_period, **_): + """Check if return_period passes parameters correctly""" + return_period.return_value = self.flood_maps + self._assert_store_intermediates( + self.rf, + "return_period", + self.flood_maps, + "return_period", + self.flood_maps, + ) + return_period.assert_called_with( + self.flood_maps, self.gumbel_fits["loc"], self.gumbel_fits["scale"] + ) + + @patch("climada_petals.hazard.rf_glofas.river_flood_computation.dask_client") + def test_return_period_resample(self, dask_client, return_period_resample, **_): + """Check if return_period_resample passes parameters correctly""" + return_period_resample.return_value = self.flood_maps + self._assert_store_intermediates( + self.rf, + "return_period_resample", + self.flood_maps, + "return_period", + 10, + self.flood_maps, + ) + expected_kwargs = dict( + discharge=self.flood_maps, + gev_loc=self.gumbel_fits["loc"], + gev_scale=self.gumbel_fits["scale"], + gev_samples=self.gumbel_fits["samples"], + bootstrap_samples=10, + fit_method="MM", + ) + return_period_resample.assert_called_with(**expected_kwargs) + dask_client.assert_not_called() + + # Parallel + self._assert_store_intermediates( + self.rf, + "return_period_resample", + self.flood_maps, + "return_period", + 10, + self.flood_maps, + num_workers=4, + ) + return_period_resample.assert_called_with(**expected_kwargs) + dask_client.assert_any_call(4, 1, "2G") + + def test_regrid(self, regrid, **_): + """Check if regrid passes parameters correctly""" + regrid.return_value = self.flood_maps, "regridder" + self._assert_store_intermediates( + self.rf, + "regrid", + self.flood_maps, + "return_period_regrid", + self.flood_maps, + reuse_regridder=False, + ) + regrid.assert_called_with( + self.flood_maps, + self.flood_maps, + method="bilinear", + regridder=None, + return_regridder=True, + ) + self.assertIsNotNone(self.rf.regridder) + + self._assert_store_intermediates( + self.rf, + "regrid", + self.flood_maps, + "return_period_regrid", + self.flood_maps, + reuse_regridder=True, + ) + regrid.assert_called_with( + self.flood_maps, + self.flood_maps, + method="bilinear", + regridder="regridder", # Reused + return_regridder=True, + ) + + def test_apply_protection(self, apply_flopros, **_): + """Check if apply_protection passes parameters correctly""" + apply_flopros.return_value = self.flood_maps + self._assert_store_intermediates( + self.rf, + "apply_protection", + self.flood_maps, + "return_period_regrid_protect", + self.flood_maps, + ) + + # Clumsy check because the dataframe does not support equal comparison + call_args = apply_flopros.call_args.args + pdt.assert_frame_equal(call_args[0], self.flopros) + xrt.assert_identical(call_args[1], self.flood_maps) + + def test_flood_depth(self, flood_depth, **_): + """Check if flood_depth passes parameters correctly""" + flood_depth.return_value = self.flood_maps + + # Default, use argument + self.rf.flood_depth(self.flood_maps) + flood_depth.assert_called_with( + self.flood_maps, + self.flood_maps, + ) + + # Store regrid + self.flood_maps.to_netcdf(self.rf.cache_paths.return_period_regrid) + self.rf.flood_depth(None) + flood_depth.assert_called_with( + self.flood_maps, + self.flood_maps, + ) + self.rf.cache_paths.return_period_regrid.unlink() + + # Store regrid protect + self.flood_maps.to_netcdf(self.rf.cache_paths.return_period_regrid_protect) + self.rf.flood_depth(None) + flood_depth.assert_called_with( + self.flood_maps, + self.flood_maps, + ) + + def test_compute_default( + self, return_period, return_period_resample, regrid, flood_depth, **_ + ): + """Test compute algorithm with defaults""" + return_period.return_value = self.flood_maps + return_period_resample.return_value = self.flood_maps + regrid.return_value = self.flood_maps, "regridder" + flood_depth.return_value = self.flood_maps + + # No data + with self.assertRaises(RuntimeError) as cm: + self.rf.compute(None) + self.assertIn("No discharge data", str(cm.exception)) + + # Default + ds_result = self.rf.compute(self.flood_maps) + return_period.assert_called_once() + return_period_resample.assert_not_called() + regrid.assert_called_once() + self.assertEqual(flood_depth.call_count, 2) + xrt.assert_equal(ds_result["flood_depth"], self.flood_maps) + xrt.assert_equal(ds_result["flood_depth_flopros"], self.flood_maps) + + # Reset mocks + for mock in (return_period, return_period_resample, regrid, flood_depth): + mock.reset_mock() + + # More arguments + ds_result = self.rf.compute( + self.flood_maps, + apply_protection=True, + resample_kws=dict(num_bootstrap_samples=10), + regrid_kws=dict(reuse_regridder=True), + ) + return_period.assert_not_called() + return_period_resample.assert_called_once() + regrid.assert_called_once() + flood_depth.assert_called_once() + self.assertNotIn("flood_depth", ds_result.data_vars.keys()) + xrt.assert_equal(ds_result["flood_depth_flopros"], self.flood_maps) + + +# Execute Tests +if __name__ == "__main__": + TESTS = unittest.TestLoader().loadTestsFromTestCase(TestMaybeOpenDataArray) + TESTS.addTests( + unittest.TestLoader().loadTestsFromTestCase(TestRiverFloodInundation) + ) + unittest.TextTestRunner(verbosity=2).run(TESTS) diff --git a/climada_petals/hazard/rf_glofas/test/test_transform_ops.py b/climada_petals/hazard/rf_glofas/test/test_transform_ops.py new file mode 100644 index 000000000..83e8d0f5b --- /dev/null +++ b/climada_petals/hazard/rf_glofas/test/test_transform_ops.py @@ -0,0 +1,660 @@ +import tempfile +import unittest +from unittest.mock import patch, MagicMock, DEFAULT +from pathlib import Path + +import numpy as np +import numpy.testing as npt +from numpy.random import default_rng + +import xarray as xr +import xarray.testing as xrt +import geopandas as gpd +from shapely.geometry import Polygon + +from climada_petals.hazard.rf_glofas.transform_ops import ( + download_glofas_discharge, + return_period, + return_period_resample, + interpolate_space, + regrid, + flood_depth, + reindex, + sel_lon_lat_slice, + max_from_isel, + apply_flopros, + fit_gumbel_r, + save_file, +) + + +def cdf_mock(dis, loc, scale): + """A mock for the gumbel_r.cdf method. Return zeros if inputs are the same, else ones""" + if np.array_equal(dis, loc) and np.array_equal(loc, scale): + return np.zeros_like(dis) + + return np.ones_like(dis) + + +def fit_mock(series, method): + """A mock for gumbel_r.fit method. Returns min and max of the series""" + return np.amin(series), np.amax(series) + + +def create_data_array(x, y, values, name): + return xr.DataArray( + data=values, + dims=["longitude", "latitude"], + coords=dict(longitude=x, latitude=y), + ).rename(name) + + +class TestGlofasDownloadOps(unittest.TestCase): + """Test case for 'download_glofas_discharge' operation""" + + def setUp(self): + """Create temporary directory in case we download data""" + self.tempdir = tempfile.TemporaryDirectory() + + # Store some dummy data + xr.DataArray( + data=[0, 1, 2], dims=["x"], coords=dict(x=[0, 1, 2], time=0) + ).rename("dis24").to_netcdf(self.tempdir.name + "/file-1.nc") + xr.DataArray( + data=[10, 11, 12], dims=["x"], coords=dict(x=[0, 1, 2], time=1) + ).rename("dis24").to_netcdf(self.tempdir.name + "/file-2.nc") + + # Mock the 'glofas_request' function + # NOTE: Need to patch the object where it is imported and used + self.patch_glofas_request = patch( + "climada_petals.hazard.rf_glofas.transform_ops.glofas_request", + autospec=True, + ) + self.glofas_request_mock = self.patch_glofas_request.start() + self.glofas_request_mock.return_value = [ + Path(self.tempdir.name, f"file-{num}.nc") for num in range(1, 3) + ] + + def tearDown(self): + """Clean up the temporary directory""" + self.tempdir.cleanup() + self.patch_glofas_request.stop() + + def test_basic(self): + """Basic case for 'download_glofas_discharge' operation""" + out_dir = Path(self.tempdir.name, "bla") + ds = download_glofas_discharge( + "forecast", + "2022-01-01", + None, + 42, + out_dir, + some_kwarg="foo", + ) + + # Check directory + self.assertTrue(out_dir.exists()) + + # Check call + self.glofas_request_mock.assert_called_once_with( + product="forecast", + date_from="2022-01-01", + date_to=None, + num_proc=42, + output_dir=out_dir, + request_kw=dict(some_kwarg="foo"), + ) + + # Check return value + npt.assert_array_equal(ds["time"].data, [0, 1]) + npt.assert_array_equal(ds["x"].data, [0, 1, 2]) + npt.assert_array_equal(ds.data, [[0, 1, 2], [10, 11, 12]]) + + @patch( + "climada_petals.hazard.rf_glofas.transform_ops.get_country_geometries", + autospec=True, + ) + def test_countries_area(self, get_country_geometries_mock): + """Check behavior of 'countries' and 'area' kwargs""" + get_country_geometries_mock.return_value = gpd.GeoDataFrame( + dict(geometry=[Polygon([(0, 0), (1, 0), (1, 1), (0, 1)])]) + ) + + # Default: countries=None + download_glofas_discharge( + "forecast", + "2022-01-01", + None, + 42, + self.tempdir.name, + ) + get_country_geometries_mock.assert_not_called() + + # Assert that 'area' was not passed + self.assertEqual(self.glofas_request_mock.call_args.kwargs["request_kw"], {}) + + # Set only countries + download_glofas_discharge( + "forecast", "2022-01-01", None, 42, self.tempdir.name, "Switzerland" + ) + get_country_geometries_mock.assert_called_once_with("CHE", extent=None) + npt.assert_array_equal( + self.glofas_request_mock.call_args.kwargs["request_kw"]["area"], + [1.0, 0.0, 0.0, 1.0], + ) + + # Set both countries and area + download_glofas_discharge( + "forecast", + "2022-01-01", + None, + 42, + self.tempdir.name, + countries=["Switzerland", "DEU"], + area=[0, 1, 2, 3], + ) + + # Check country code translation and area order + get_country_geometries_mock.assert_called_with( + ["CHE", "DEU"], extent=[1, 3, 2, 0] + ) + self.assertEqual(self.glofas_request_mock.call_count, 3) + npt.assert_array_equal( + self.glofas_request_mock.call_args.kwargs["request_kw"]["area"], + [1.0, 0.0, 0.0, 1.0], + ) + + def test_preprocess(self): + """Test the capabilities of the preprocessing""" + # Simple addition + ds = download_glofas_discharge( + "forecast", "2022-01-01", None, 1, preprocess=lambda x: x + 1 + ) + npt.assert_array_equal(ds["time"].data, [0, 1]) + npt.assert_array_equal(ds["x"].data, [0, 1, 2]) + npt.assert_array_equal(ds.data, [[1, 2, 3], [11, 12, 13]]) + + # Maximum new concat dim + ds = download_glofas_discharge( + "forecast", + "2022-01-01", + None, + 1, + preprocess=lambda x: x.max(dim="x").rename(time="year"), + open_mfdataset_kw=dict(concat_dim="year"), + ) + self.assertIn("year", ds.dims) + self.assertNotIn("time", ds.dims) + self.assertNotIn("x", ds.dims) + npt.assert_array_equal(ds["year"].data, [0, 1]) + npt.assert_array_equal(ds.data, [2, 12]) + + +class TestTransformOps(unittest.TestCase): + """Test case for other dantro operations""" + + def setUp(self): + """Set up a random number generator""" + self.rng = default_rng(1) + + @patch("climada_petals.hazard.rf_glofas.transform_ops.gumbel_r.fit", new=fit_mock) + def test_fit_gumbel_r(self): + """Test the 'fit_gumbel_r' operation""" + # Dummy data + input_data = xr.DataArray( + data=[[0, 1, 2], [np.nan, 2, 3], [np.nan, np.nan, 1]], + coords=dict(x=[1, 2, 3], year=[2000, 2001, 2002]), + ) + + # Check result + # NOTE: The mock will return min for 'loc' and max for 'scale' + res = fit_gumbel_r(input_data) + npt.assert_array_equal(res["loc"].values, [0, 2, np.nan]) + npt.assert_array_equal(res["scale"].values, [2, 3, np.nan]) + npt.assert_array_equal(res["samples"].values, [3, 2, 0]) + + def test_max_from_isel(self): + """Test the 'max_from_isel' operation""" + # NOTE: Use timedelta to check support for this data type + # (we typically compute a maximum over multiple time steps) + da = xr.DataArray( + data=[[0], [1], [2], [3]], + coords=dict( + step=np.arange(np.timedelta64(4, "D")).astype("timedelta64[ns]"), x=[0] + ), + ) + + # Test how it's regularly called + res = max_from_isel(da, "step", [slice(0, 2), [0, 3, 2]]) + npt.assert_array_equal(res["x"].values, [0]) + npt.assert_array_equal(res["select"].values, list(range(2))) + # NOTE: slicing with .isel is NOT inclusive (as opposed to .sel)! + npt.assert_array_equal(res.values, [[1], [3]]) + + # Check errors + with self.assertRaises(TypeError) as cm: + max_from_isel(da, "step", [1]) + self.assertIn( + "This function only works with iterables or slices as selection", + str(cm.exception), + ) + + # @patch.object(gumbel_r, "cdf", new=cdf_mock) + @patch("climada_petals.hazard.rf_glofas.transform_ops.gumbel_r.cdf", new=cdf_mock) + def test_return_period(self): + """Test 'return_period' operation""" + x = np.arange(10) + # Distort the coordinates to test the reindexing + x_var = x + self.rng.uniform(low=-1e-7, high=1e-7, size=x.shape) + x_var_big = x + self.rng.uniform(low=-1e-2, high=1e-2, size=x.shape) + y = np.arange(20, 10, -1) + values = np.outer(x, y) + + def return_arg(target, *args, **kwargs): + """A dummy that returns the first argument""" + return target + + # Wrong x coordinates should cause an error + discharge = create_data_array(x_var_big, y, values, "discharge") + loc = create_data_array(x, y, values, "loc") + self.assertFalse(discharge.equals(loc)) + with self.assertRaises(ValueError) as cm: + return_period(discharge, loc, loc) + self.assertIn( + "Reindexing 'loc' to 'discharge' exceeds tolerance!", str(cm.exception) + ) + + # Small deviations should cause an error if reindexing does not work + discharge = create_data_array(x_var, y, values, "discharge") + self.assertFalse(discharge.equals(loc)) + + # Mock a DataArray + da_mock = MagicMock(spec_set=xr.DataArray) + da_mock.reindex_like.return_value = loc # Return without reindexing + da_mock.count.return_value = 0 # Mock the count + + # Patch the reindexing + with patch( + "climada_petals.hazard.rf_glofas.transform_ops.reindex", new=return_arg + ): + with self.assertRaises(ValueError) as cm: + return_period(discharge, da_mock, loc) + self.assertIn("cannot align objects", str(cm.exception)) + self.assertIn("longitude", str(cm.exception)) + + # Call the function again, slicing and reindexing should work as expected + x_loc = np.arange(11) + y_loc = np.arange(25, 5, -1) + values_loc = np.outer(x_loc, y_loc) + loc = create_data_array(x_loc, y_loc, values_loc, "loc") + result = return_period(discharge, loc, loc) + self.assertEqual(result.name, "Return Period") + + # "-1" would be a sign that indexing does not work + self.assertFalse((result == -1).any()) + + # NOTE: This checks if slicing works through 'cdf_mock' + # NOTE: Needs 'allclose' because of float32 dtype + npt.assert_allclose(result.values, np.ones_like(result.values)) + npt.assert_allclose(result["longitude"].values, x, atol=1e-8) + npt.assert_allclose(result["latitude"].values, y, atol=1e-8) + + def test_return_period_resample(self): + """Test 'return_period_resample' operation""" + # Make more than 2 dims to check handling of 'core_dims' + x = np.arange(10) + y = np.arange(20, 10, -1) + z = np.linspace(0, 5, 11) + + values = (x[:, None, None] * y[None, :, None] * z[None, None, :]).astype("float") + discharge = xr.DataArray(values, coords=dict(longitude=x, latitude=y, time=z)) + gev = xr.DataArray( + np.outer(x, y).astype("float"), coords=dict(longitude=x, latitude=y) + ) + + # Test special values + samples = gev.copy().astype("int") + samples[0, 1] = 0 + gev[1, 0] = np.inf + gev[1, 1] = np.nan + discharge[0, 0, 1] = np.nan + + # Check result + max_return_period = 10 + result = return_period_resample( + discharge, gev, gev, samples, 5, max_return_period=max_return_period + ) + self.assertIn("sample", result.dims) + self.assertEqual(result.sizes["sample"], 5) + + # Check if new dimension is ordered last + self.assertListEqual( + list(result.sizes.keys()), list(discharge.sizes.keys()) + ["sample"] + ) + + # Results should be NaN if there are no samples or non-finite value + npt.assert_array_equal(result.values[0, 1, :], np.full((11, 5), np.nan)) + npt.assert_array_equal(result.values[1, 0, :], np.full((11, 5), np.nan)) + npt.assert_array_equal(result.values[1, 1, :], np.full((11, 5), np.nan)) + + # Result should be NaN if discharge is NaN + npt.assert_array_equal(result.values[0, 0, 1], [np.nan] * 5) + mask_nan = np.isnan((result.values)) + self.assertTrue(np.any(~mask_nan)) + self.assertTrue(np.all(result.values[~mask_nan] <= max_return_period)) + self.assertTrue(np.all(result.values[~mask_nan] >= 1)) + + # Checks calls to 'fit' and 'rvs' + with patch.multiple( + "climada_petals.hazard.rf_glofas.transform_ops.gumbel_r", + fit=DEFAULT, + rvs=DEFAULT, + ) as mocks: + mocks["fit"].return_value = (1, 1) + bootstrap_samples = 2 + return_period_resample(discharge, gev, gev, samples, bootstrap_samples) + + # Test number of calls + expected_calls = np.count_nonzero( + np.isfinite(gev.values) & (samples.values > 0) + ) + self.assertEqual( + len(mocks["fit"].call_args_list), expected_calls * bootstrap_samples + ) + + # Test that kwargs align + kwargs = np.array( + [ + ( + call_args.kwargs["loc"], + call_args.kwargs["scale"], + call_args.kwargs["size"], + ) + for call_args in mocks["rvs"].call_args_list + ] + ) + loc, scale, size = np.vsplit(kwargs.T, 3) + npt.assert_array_equal(loc, size) + npt.assert_array_equal(scale, size) + + def test_interpolate_space(self): + """Test 'interpolate_space' and 'regrid' operations""" + + def _assert_result(da_result, da_expected_values, **kwargs): + """Check if result is as expected""" + npt.assert_array_equal( + da_result["longitude"], da_expected_values["longitude"] + ) + npt.assert_array_equal( + da_result["latitude"], da_expected_values["latitude"] + ) + # Interpolation causes some noise, so "allclose" is enough here + xrt.assert_allclose(da_result, da_expected_values, **kwargs) + + x = np.arange(4.0) + y = np.flip(x) + x_diff = x * 0.9 + y_diff = y * 0.8 + xx, yy = np.meshgrid(x, y, indexing="xy") + values = xx + yy + + da_values = xr.DataArray( + data=values, + dims=["latitude", "longitude"], + coords=dict(longitude=x, latitude=y), + ) + da_coords = xr.DataArray( + data=values, + dims=["latitude", "longitude"], + coords=dict(longitude=x_diff, latitude=y_diff), + ) + + xx_diff, yy_diff = np.meshgrid(x_diff, y_diff, indexing="xy") + expected_values = xx_diff + yy_diff + da_expected = xr.DataArray( + data=expected_values, + dims=["latitude", "longitude"], + coords=dict(longitude=x_diff, latitude=y_diff), + ) + + # 'interpolate_space' + da_result = interpolate_space(da_values, da_coords) + _assert_result(da_result, da_expected) + + # 'regrid' + da_values[2:, 2:] = np.nan + da_expected[2:, 2:] = [[2, 5], [1, 1]] # Nearest neighbor extrapolation + + da_result = regrid(da_values, da_coords) + _assert_result( + da_result, + xr.DataArray( + data=expected_values, + dims=["latitude", "longitude"], + coords=dict(longitude=x_diff, latitude=y_diff), + ), + rtol=2e5, + ) # Regridding has lower accuracy + + def test_apply_flopros(self): + """Test 'apply_flopros' operation""" + # Create dummy data + return_period = create_data_array( + [0, 1, 2], [10, 11], [[1, 2], [1.5, 3], [1.5, 1.5]], "return_period" + ) + polygons = [ + Polygon([(0, 0), (1.5, 0), (1.5, 10.5), (0, 10.5)]), + Polygon([(1.5, 0), (3, 0), (3, 12), (0, 12), (0, 10.5), (1.5, 10.5)]), + ] + flopros_data = gpd.GeoDataFrame( + {"MerL_Riv": [1, 2]}, geometry=polygons, crs="EPSG:4326" + ) + + # Call the function + res = apply_flopros(flopros_data, return_period) + npt.assert_array_equal( + res.values, [[np.nan, np.nan], [1.5, 3], [np.nan, np.nan]] + ) + + def test_flood_depth(self): + """Test 'flood_depth' operation""" + # Create dummy datasets + ones = np.ones((4, 3), dtype="float") + da_flood_maps = xr.DataArray( + data=[ones, ones * 10, ones * 100], + dims=["return_period", "longitude", "latitude"], + coords=dict( + return_period=[1, 10, 100], + longitude=np.arange(4), + latitude=np.arange(3), + ), + ) + + x = np.arange(4) + y = np.arange(3) + core_dim_1 = np.arange(3) + core_dim_2 = np.arange(2) + shape = (x.size, y.size, core_dim_1.size, core_dim_2.size) + values = np.array( + list(range(x.size * y.size * core_dim_1.size * core_dim_2.size)), + dtype="float", + ) + values = values.reshape(shape) + self.rng.uniform(-0.1, 0.1, size=shape) + values.flat[0] = 101 # Above max + values.flat[1] = 0.1 # Below min + da_return_period = xr.DataArray( + data=values, + dims=["longitude", "latitude", "core_dim_1", "core_dim_2"], + coords=dict( + longitude=x, latitude=y, core_dim_1=core_dim_1, core_dim_2=core_dim_2 + ), + ).astype(np.float32) + + da_result = flood_depth(da_return_period, da_flood_maps) + self.assertEqual(da_result.name, "Flood Depth") + # NOTE: Single point precision, so reduce the decimal accuracy + xrt.assert_allclose(da_result, da_return_period.clip(1, 100)) + + # Check NaN shortcut + da_flood_maps = xr.DataArray( + data=[np.full_like(ones, np.nan)] * 3, + dims=["return_period", "longitude", "latitude"], + coords=dict( + return_period=[1, 10, 100], + longitude=np.arange(4), + latitude=np.arange(3), + ), + ) + da_result = flood_depth(da_return_period, da_flood_maps) + self.assertTrue(da_result.isnull().all()) + + # Check NaN sanitizer + da_flood_maps = xr.DataArray( + data=[np.full_like(ones, np.nan), ones * 9, ones * 99], + dims=["return_period", "longitude", "latitude"], + coords=dict( + return_period=[1, 10, 100], + longitude=np.arange(4), + latitude=np.arange(3), + ), + ) + da_return_period[...] = 1 + self.rng.uniform(-0.1, 0.1, size=shape) + da_result = flood_depth(da_return_period, da_flood_maps) + xrt.assert_allclose(da_result, (da_return_period - 1).clip(min=0)) + + # Check that DataArrays have to be aligned + x_diff = x + self.rng.uniform(-1e-3, 1e-3, size=x.shape) + y_diff = y + self.rng.uniform(-1e-3, 1e-3, size=y.shape) + da_return_period = xr.DataArray( + data=values, + dims=["longitude", "latitude", "core_dim_1", "core_dim_2"], + coords=dict( + longitude=x_diff, + latitude=y_diff, + core_dim_1=core_dim_1, + core_dim_2=core_dim_2, + ), + ) + with self.assertRaises(ValueError) as cm: + flood_depth(da_return_period, da_flood_maps) + self.assertIn("cannot align objects", str(cm.exception)) + + def test_reindex(self): + """Test the custom reindex function""" + # Define target + x = np.arange(10) + y = np.arange(10, 20) + xx, yy = np.meshgrid(x, y, indexing="xy") + values = xx + yy + target = xr.DataArray( + values.astype("float"), dims=["y", "x"], coords=dict(x=x, y=y) + ) + + # Define source + x_diff = x + self.rng.uniform(-0.1, 0.1, size=x.shape) + y_diff = y + self.rng.uniform(-0.1, 0.1, size=y.shape) + source = xr.DataArray( + np.zeros_like(values), dims=["y", "x"], coords=dict(x=x_diff, y=y_diff) + ) + + # Default values + res = reindex(target, source) + npt.assert_array_equal(res["x"], x_diff) + npt.assert_array_equal(res["y"], y_diff) + npt.assert_array_equal(res.values, values) + + # Add tolerance, we should have some NaNs then + res = reindex(target, source, tolerance=1e-3) + self.assertTrue(res.isnull().any()) + + # Change fill value + res = reindex(target, source, tolerance=1e-2, fill_value=-10) + self.assertTrue((res == -10).any()) + + # Check raise error + with self.assertRaises(ValueError) as cm: + reindex(target, source, tolerance=1e-3, assert_no_fill_value=True) + self.assertIn("exceeds tolerance", str(cm.exception)) + with self.assertRaises(ValueError) as cm: + reindex(target, source, fill_value=11, assert_no_fill_value=True) + self.assertIn("does already contain reindex fill value", str(cm.exception)) + + def test_sel_lon_lat_slice(self): + """Test selection of lon/lat slices""" + x = np.arange(10) + target = create_data_array(x, x, np.zeros((10, 10)), "target") + x_new = np.linspace(0, 6.5, 10) + source = create_data_array(x_new, x_new, np.zeros((10, 10)), "source") + + res = sel_lon_lat_slice(target, source) + self.assertEqual(res["latitude"][0], 0) + self.assertEqual(res["latitude"][-1], 6) + self.assertEqual(res["longitude"][0], 0) + self.assertEqual(res["longitude"][-1], 6) + + # Flip coordinates + target = create_data_array(x, np.flip(x), np.zeros((10, 10)), "target") + source = create_data_array(x_new, np.flip(x_new), np.zeros((10, 10)), "source") + res = sel_lon_lat_slice(target, source) + self.assertEqual(res["latitude"][0], 6) + self.assertEqual(res["latitude"][-1], 0) + self.assertEqual(res["longitude"][0], 0) + self.assertEqual(res["longitude"][-1], 6) + + def test_save_file(self): + """Test the file saving wrapper for the dantro pipeline""" + # Mock the dataset + ds = MagicMock(xr.Dataset) + ds.data_vars = ["foo", "bar"] + + # Call the function + outpath = Path(tempfile.gettempdir()) / "outpath" + encoding = dict(bar=dict(dtype="float64", some_setting=True)) + encoding_defaults = dict(zlib=True, other_setting=False) + + # Assert calls + save_file(ds, outpath, encoding, **encoding_defaults) + ds.to_netcdf.assert_called_once_with( + outpath.with_suffix(".nc"), + encoding=dict( + foo=dict(dtype="float32", zlib=True, complevel=4, other_setting=False), + bar=dict( + dtype="float64", + zlib=True, + complevel=4, + other_setting=False, + some_setting=True, + ), + ), + engine="netcdf4", + ) + ds.to_netcdf.reset_mock() + + # Any suffix will be forwarded + outpath = outpath.with_suffix(".suffix") + defaults = dict(dtype="float32", zlib=False, complevel=4) + save_file(ds, outpath) + ds.to_netcdf.assert_called_once_with( + outpath, encoding=dict(foo=defaults, bar=defaults), engine="netcdf4" + ) + + # KeyError for data_vars that do not exist + with self.assertRaises(KeyError) as cm: + save_file(ds, outpath, dict(baz=dict(stuff=True))) + self.assertIn("baz", str(cm.exception)) + ds.to_netcdf.reset_mock() + + # DataArray must be promoted + da = MagicMock(xr.DataArray) + da.to_dataset.return_value = ds + save_file(da, outpath) + da.to_dataset.assert_called_once_with() + ds.to_netcdf.assert_called_once_with( + outpath, encoding=dict(foo=defaults, bar=defaults), engine="netcdf4" + ) + + +if __name__ == "__main__": + TESTS = unittest.TestLoader().loadTestsFromTestCase(TestGlofasDownloadOps) + TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestTransformOps)) + unittest.TextTestRunner(verbosity=2).run(TESTS) diff --git a/climada_petals/hazard/rf_glofas/transform_ops.py b/climada_petals/hazard/rf_glofas/transform_ops.py new file mode 100644 index 000000000..46671fc4b --- /dev/null +++ b/climada_petals/hazard/rf_glofas/transform_ops.py @@ -0,0 +1,813 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +Transformations for dantro data pipeline +""" + +import logging +import re +from pathlib import Path +from typing import Optional, Union, List, Mapping, Any, Iterable, Tuple, Callable +from collections import deque +from copy import deepcopy + +import xarray as xr +import numpy as np +import pandas as pd +import geopandas as gpd +from scipy.stats import gumbel_r +import xesmf as xe +from numba import guvectorize + +from climada.util.coordinates import get_country_geometries, country_to_iso +from .cds_glofas_downloader import glofas_request, CDS_DOWNLOAD_DIR + +LOGGER = logging.getLogger(__name__) + + +def sel_lon_lat_slice(target: xr.DataArray, source: xr.DataArray) -> xr.DataArray: + """Select a lon/lat slice from 'target' using coordinates of 'source'""" + return target.sel({c: slice(*source[c][[0, -1]]) for c in ["longitude", "latitude"]}) + + +def rp_comp( + sample: np.ndarray, + loc: np.ndarray, + scale: np.ndarray, + max_rp: Optional[float] = np.inf, +): + """Compute the return period from a right-handed Gumbel distribution + + All parameters can be arrays, in which case numpy broadcasting rules apply. + + The return period of a sample :math:`x` from an extreme value distribution is + defined as :math:`(1 - \\mathrm{cdf}(x))^{-1}`, where :math:`\\mathrm{cdf}` is the + cumulative distribution function of said distribution. + + Parameters + ---------- + sample : array + Samples for which to compute the return period + loc : array + Loc parameter of the Gumbel distribution + scale : array + Scale parameter of the distribution + max_rp : float, optional + The maximum value of return periods. This avoids returning infinite values. + Defaults to ``np.inf`` (no maximum). + + Returns + ------- + np.ndarray + The return period(s) for the input parameters + """ + cdf = gumbel_r.cdf(sample, loc=loc, scale=scale) + rp_from_cdf = np.where(cdf >= 1.0, np.inf, 1.0 / np.fmax(1.0 - cdf, np.spacing(1))) + return np.fmin(rp_from_cdf, max_rp) + + +def reindex( + target: xr.DataArray, + source: xr.DataArray, + tolerance: Optional[float] = None, + fill_value: float = np.nan, + assert_no_fill_value: bool = False, +) -> xr.DataArray: + """Reindex target to source with nearest neighbor lookup + + Parameters + ---------- + target : xr.DataArray + Array to be reindexed. + source : xr.DataArray + Array whose coordinates are used for reindexing. + tolerance : float (optional) + Maximum distance between coordinates. If it is superseded, the ``fill_value`` is + inserted instead of the nearest neighbor value. Defaults to NaN + fill_value : float (optional) + The fill value to use if coordinates are changed by a distance of more than + ``tolerance``. + assert_no_fill_value : bool (optional) + Throw an error if fill values are found in the data after reindexing. This will + also throw an error if the fill value is present in the ``target`` before + reindexing (because the check afterwards would else not make sense) + + Returns + ------- + target : xr.DataArray + Target reindexed like 'source' with nearest neighbor lookup for the data. + + Raises + ------ + ValueError + If tolerance is exceeded when reindexing, in case ``assert_no_fill_value`` is + ``True``. + ValueError + If ``target`` already contains the ``fill_value`` before reindexing, in case + ``assert_no_fill_value`` is ``True``. + """ + + def has_fill_value(arr): + return arr.isin(fill_value).any() or ( + np.isnan(fill_value) and arr.isnull().any() + ) + + # Check for fill values before + if assert_no_fill_value and has_fill_value(target): + raise ValueError( + f"Array '{target.name}' does already contain reindex fill value" + ) + + # Reindex operation + target = target.reindex_like( + source, method="nearest", tolerance=tolerance, copy=False, fill_value=fill_value + ) + + # Check for fill values after + if assert_no_fill_value and has_fill_value(target): + raise ValueError( + f"Reindexing '{target.name}' to '{source.name}' exceeds tolerance! " + "Try interpolating the datasets or increasing the tolerance" + ) + + return target + + +def merge_flood_maps(flood_maps: Mapping[str, xr.DataArray]) -> xr.DataArray: + """Merge the flood maps GeoTIFFs into one NetCDF file + + Adds a "zero" flood map (all zeros) + + Parameters + ---------- + flood_maps : dict(str, xarray.DataArray) + The mapping of GeoTIFF file paths to respective DataArray. Each flood map is + identified through the folder containing it. The folders are expected to follow + the naming scheme ``floodMapGL_rpXXXy``, where ``XXX`` indicates the return + period of the respective map. + """ + expr = re.compile(r"floodMapGL_rp(\d+)y") + years = [int(expr.search(name).group(1)) for name in flood_maps] + idx = np.argsort(years) + darrs = list(flood_maps.values()) + darrs = [ + darrs[i].drop_vars("spatial_ref", errors="ignore").squeeze("band", drop=True) + for i in idx + ] + + # Add zero flood map + # NOTE: Return period of 1 is the minimal value + da_null_flood = xr.full_like(darrs[0], np.nan) + darrs.insert(0, da_null_flood) + + # Concatenate and rename + years = np.insert(np.array(years)[idx], 0, 1) + da_flood_maps = xr.concat(darrs, pd.Index(years, name="return_period")) + da_flood_maps = da_flood_maps.rename(x="longitude", y="latitude") + return da_flood_maps.rename("flood_depth") + + +def fit_gumbel_r( + input_data: xr.DataArray, + time_dim: str = "year", + fit_method: str = "MM", + min_samples: int = 2, +): + """Fit a right-handed Gumbel distribution to the data + + Parameters + ---------- + input_data : xr.DataArray + The input time series to compute the distributions for. It must contain the + dimension specified as ``time_dim``. + time_dim : str + The dimension indicating time. Defaults to ``year``. + fit_method : str + The method used for computing the distribution. Either ``MLE`` (Maximum + Likelihood Estimation) or ``MM`` (Method of Moments). + min_samples : int + The number of finite samples along the time dimension required for a + successful fit. If there are fewer samples, the fit result will be NaN. + + Returns + ------- + xr.Dataset + A dataset on the same grid as the input data with variables + + * ``loc``: The loc parameter of the fitted distribution (mode) + * ``scale``: The scale parameter of the fitted distribution + * ``samples``: The number of samples used to fit the distribution at this + coordinate + """ + + def fit(time_series): + # Count finite samples + samples = np.isfinite(time_series) + samples_count = np.count_nonzero(samples) + if samples_count < min_samples: + return np.nan, np.nan, 0 + + # Mask array + return (*gumbel_r.fit(time_series[samples], method=fit_method), samples_count) + + # Apply fitting + loc, scale, samples = xr.apply_ufunc( + fit, + input_data, + input_core_dims=[[time_dim]], + output_core_dims=[[], [], []], + exclude_dims={time_dim}, + vectorize=True, + dask="parallelized", + output_dtypes=[np.float64, np.float64, np.int32], + dask_gufunc_kwargs=dict(allow_rechunk=True), + ) + + return xr.Dataset(dict(loc=loc, scale=scale, samples=samples)) + + +def download_glofas_discharge( + product: str, + date_from: str, + date_to: Optional[str], + num_proc: int = 1, + download_path: Union[str, Path] = CDS_DOWNLOAD_DIR, + countries: Optional[Union[List[str], str]] = None, + preprocess: Optional[Callable] = None, + open_mfdataset_kw: Optional[Mapping[str, Any]] = None, + **request_kwargs, +) -> xr.DataArray: + """Download the GloFAS data and return the resulting dataset + + Several parameters are passed directly to + :py:func:`climada_petals.hazard.rf_glofas.cds_glofas_downloader.glofas_request`. See + this functions documentation for further information. + + Parameters + ---------- + product : str + The string identifier of the product to download. See + :py:func:`climada_petals.hazard.rf_glofas.cds_glofas_downloader.glofas_request` + for supported products. + date_from : str + Earliest date to download. Specification depends on the ``product`` chosen. + date_to : str or None + Latest date to download. If ``None``, only download the ``date_from``. + Specification depends on the ``product`` chosen. + num_proc : int + Number of parallel processes to use for downloading. Defaults to 1. + download_path : str or pathlib.Path + Directory to store the downloaded data. The directory (and all required parent + directories!) will be created if it does not yet exist. Defaults to + ``~/climada/data/glofas-discharge/``. + countries : str or list of str, optional + Countries to download data for. Uses the maximum extension of all countries for + selecting the latitude/longitude range of data to download. + preprocess : str, optional + String expression for preprocessing the data before merging it into one dataset. + Must be valid Python code. The downloaded data is passed as variable ``x``. + open_mfdataset_kw : dict, optional + Optional keyword arguments for the ``xarray.open_mfdataset`` function. + request_kwargs: + Keyword arguments for the Copernicus data store request. + """ + # Create the download path if it does not yet exist + LOGGER.debug("Preparing download directory: %s", download_path) + download_path = Path(download_path) # Make sure it is a Path + download_path.mkdir(parents=True, exist_ok=True) + + # Determine area from 'countries' + if countries is not None: + LOGGER.debug("Choosing lat/lon bounds from countries %s", countries) + # Fetch area and reorder appropriately + # NOTE: 'area': north, west, south, east + # 'extent': lon min (west), lon max (east), lat min (south), lat max (north) + area = request_kwargs.get("area") + if area is not None: + LOGGER.debug("Subsetting country geometries with 'area'") + area = [area[1], area[3], area[2], area[0]] + + # Fetch geometries and bounds of requested countries + iso = country_to_iso(countries) + geo = get_country_geometries(iso, extent=area) + + # NOTE: 'bounds': minx (west), miny (south), maxx (east), maxy (north) + # NOTE: Explicitly cast to float to ensure that YAML parser can dump the data + bounds = deque(map(float, geo.total_bounds.flat)) + bounds.rotate(1) + + # Insert into kwargs + request_kwargs["area"] = list(bounds) + + # Request the data + files = glofas_request( + product=product, + date_from=date_from, + date_to=date_to, + num_proc=num_proc, + output_dir=download_path, + request_kw=request_kwargs, + ) + + # Set arguments for 'open_mfdataset' + open_kwargs = dict( + chunks={}, combine="nested", concat_dim="time", preprocess=preprocess + ) + if open_mfdataset_kw is not None: + open_kwargs.update(open_mfdataset_kw) + + # Squeeze all dimensions except time + arr = xr.open_mfdataset(files, **open_kwargs)["dis24"] + dims = {dim for dim, size in arr.sizes.items() if size == 1} - {"time"} + return arr.squeeze(dim=dims) + +def max_from_isel( + array: xr.DataArray, dim: str, selections: List[Union[Iterable, slice]] +) -> xr.DataArray: + """Compute the maximum over several selections of an array dimension""" + if not all(isinstance(sel, (Iterable, slice)) for sel in selections): + raise TypeError( + "This function only works with iterables or slices as selection" + ) + + data = [array.isel({dim: sel}) for sel in selections] + return xr.concat( + [da.max(dim=dim, skipna=True) for da in data], + dim=pd.Index(list(range(len(selections))), name="select") + # dim=xr.concat([da[dim].max() for da in data], dim=dim) + ) + + +def return_period( + discharge: xr.DataArray, + gev_loc: xr.DataArray, + gev_scale: xr.DataArray, + max_return_period: float = 1e4, +) -> xr.DataArray: + """Compute the return period for a discharge from a Gumbel EV distribution fit + + Coordinates of the three datasets must match up to a tolerance of 1e-3 degrees. If + they do not, an error is thrown. + + Parameters + ---------- + discharge : xr.DataArray + The discharge values to compute the return period for + gev_loc : xr.DataArray + The loc parameters for the Gumbel EV distribution + gev_scale : xr.DataArray + The scale parameters for the Gumbel EV distribution + + Returns + ------- + xr.DataArray + The equivalent return periods for the input discharge and Gumbel EV istributions + + See Also + -------- + :py:func:`climada_petals.hazard.rf_glofas.transform_ops.rp` + :py:func:`climada_petals.hazard.rf_glofas.transform_ops.return_period_resample` + """ + reindex_kwargs = dict(tolerance=1e-3, fill_value=-1, assert_no_fill_value=True) + gev_loc = reindex(gev_loc, discharge, **reindex_kwargs) + gev_scale = reindex(gev_scale, discharge, **reindex_kwargs) + + # Apply and return + return xr.apply_ufunc( + rp_comp, + discharge, + gev_loc, + gev_scale, + max_return_period, + dask="parallelized", + output_dtypes=[np.float32], + ).rename("Return Period") + + +def return_period_resample( + discharge: xr.DataArray, + gev_loc: xr.DataArray, + gev_scale: xr.DataArray, + gev_samples: xr.DataArray, + bootstrap_samples: int, + max_return_period: float = 1e4, + fit_method: str = "MLE", +) -> xr.DataArray: + """Compute resampled return periods for a discharge from a Gumbel EV distribution fit + + This function uses bootstrap resampling to incorporate the uncertainty in the EV + distribution fit. Bootstrap resampling takes the fitted distribution, draws N samples + from it (where N is the number of samples originally used to fit the distribution), + and fits a new distribution onto these samples. This "bootstrapped" distribution is + then used to compute the return period. Repeating this process yields an ensemble of + distributions that captures the uncertainty in the original distribution fit. + + Coordinates of the three datasets must match up to a tolerance of 1e-3 degrees. If + they do not, an error is thrown. + + Parameters + ---------- + discharge : xr.DataArray + The discharge values to compute the return period for + gev_loc : xr.DataArray + The loc parameters for the Gumbel EV distribution + gev_scale : xr.DataArray + The scale parameters for the Gumbel EV distribution + gev_samples : xr.DataArray + The samples used to fit the Gumbel EV distribution at every point + bootstrap_samples : int + The number of bootstrap samples to compute. Increasing this will improve the + representation of uncertainty, but strongly increase computational costs later + on. + fit_method : str + Method for fitting the Gumbel EV during resampling. Available methods are the + Method of Moments ``MM`` or the Maximum Likelihood Estimation ``MLE`` (default). + + Returns + ------- + xr.DataArray + The equivalent return periods for the input discharge and Gumbel EV + distributions. The data array will have an additional dimension ``sample``, + representing the bootstrap samples for every point. + + See Also + -------- + :py:func:`climada_petals.hazard.rf_glofas.transform_ops.rp` + :py:func:`climada_petals.hazard.rf_glofas.transform_ops.return_period` + """ + reindex_kwargs = dict(tolerance=1e-3, fill_value=-1, assert_no_fill_value=True) + gev_loc = reindex(gev_loc, discharge, **reindex_kwargs) + gev_scale = reindex(gev_scale, discharge, **reindex_kwargs) + gev_samples = reindex(gev_samples, discharge, **reindex_kwargs).astype("int32") + + # All but 'longitude' and 'latitude' are core dimensions for this operation + core_dims = list(discharge.dims) + core_dims.remove("longitude") + core_dims.remove("latitude") + + # Define input array layout + # NOTE: This depends on the actual core dimensions put in, so we have to do this + # programmatically. + # num_core_dims = len(core_dims) + # arr_str_in = "[" + ", ".join([":" for _ in range(num_core_dims)]) + "]" + # dims_str_in = "(" + ", ".join([f"c_{i}" for i in range(num_core_dims)]) + ")" + # arr_str_out = arr_str_in[:-1] + ", :]" + # dims_str_out = dims_str_in[:-1] + ", samples)" + # print(arr_str_in, dims_str_in) + # print(arr_str_out, dims_str_out) + + # Dummy array + # dummy = xr.DataArray( + # np.empty((bootstrap_samples)), + # coords=dict(samples=list(range(bootstrap_samples))), + # ) + + # Define the vectorized function + # @guvectorize( + # ( + # f"(float32{arr_str_in}, float64, float64, int32," + # f"float64,float64[:], float32{arr_str_out})" + # ), + # f"{dims_str_in}, (), (), (), (), (samples) -> {dims_str_out}", + # # nopython=True, + # ) + def rp_sampling( + dis: np.ndarray, + loc: float, + scale: float, + samples: int, + max_rp: float, + ): + """Compute multiple return periods using bootstrap sampling + + This function does not support broadcasting on the ``loc`` and ``scale`` + parameters. + """ + # Return NaNs if we have no reliable samples + finite_input = all((np.isfinite(x) for x in (loc, scale, samples))) + if samples < 1 or not finite_input: + return np.full((bootstrap_samples,) + dis.shape, np.nan) + + # Resample by drawing samples and re-fitting + def resample_params(): + return gumbel_r.fit( + gumbel_r.rvs(loc=loc, scale=scale, size=samples), + method=fit_method, + ) + + # Resample the distribution and compute return periods from these resamples + return np.array( + [ + rp_comp(dis, *resample_params(), max_rp) + for _ in range(bootstrap_samples) + ], + dtype=np.float32, + ) + + # Apply and return + # NOTE: 'rp_sampling' requires scalar 'loc' and 'scale' parameters, so we + # define all but 'longitude' and 'latitude' dimensions as core dimensions + # core_dims = set(discharge.dims) - {"longitude", "latitude"} + return ( + xr.apply_ufunc( + rp_sampling, + discharge, + gev_loc, + gev_scale, + gev_samples, + max_return_period, + input_core_dims=[list(core_dims), [], [], [], []], + output_core_dims=[["sample"] + list(core_dims)], + vectorize=True, + dask="parallelized", + output_dtypes=[np.float32], + dask_gufunc_kwargs=dict( + output_sizes=dict(sample=bootstrap_samples), allow_rechunk=True + ), + ) + .rename("Return Period") + .assign_coords(sample=np.arange(bootstrap_samples)) + .transpose(..., "sample") + ) + + +def interpolate_space( + return_period: xr.DataArray, + flood_maps: xr.DataArray, + method: str = "linear", +) -> xr.DataArray: + """Interpolate the return period in space onto the flood maps grid""" + # Select lon/lat for flood maps + flood_maps = sel_lon_lat_slice(flood_maps, return_period) + + # Interpolate the return period + return return_period.interp( + coords=dict(longitude=flood_maps["longitude"], latitude=flood_maps["latitude"]), + method=method, + kwargs=dict(fill_value=None), # Extrapolate + ) + + +def regrid( + return_period: xr.DataArray, + flood_maps: xr.DataArray, + method: str = "bilinear", + regridder: Optional[xe.Regridder] = None, + return_regridder: bool = False, +) -> Union[xr.DataArray, Tuple[xr.DataArray, xe.Regridder]]: + """Regrid the return period onto the flood maps grid""" + # Select lon/lat for flood maps + flood_maps = sel_lon_lat_slice(flood_maps, return_period) + + # Mask return period so NaNs are not propagated + rp = return_period.to_dataset(name="data") + dims_to_remove = set(rp.sizes.keys()) - {"longitude", "latitude"} + dims_to_remove = {dim: 0 for dim in dims_to_remove} + rp["mask"] = xr.where(rp["data"].isel(dims_to_remove).isnull(), 0, 1) + + # NOTE: Masking here would omit all return periods outside flood plains + # (This might be desirable at some point?) + flood = flood_maps.to_dataset(name="data") + # flood["mask"] = xr.where(flood["data"].isel(return_period=-1).isnull(), 0, 1) + + # Perform regridding + if regridder is None: + regridder = xe.Regridder( + rp, + flood, + method=method, + extrap_method="nearest_s2d", + # unmapped_to_nan=False, + ) + + return_period_regridded = regridder(return_period).rename(return_period.name) + if return_regridder: + return return_period_regridded, regridder + + return return_period_regridded + + +def apply_flopros( + flopros_data: gpd.GeoDataFrame, + return_period: Union[xr.DataArray, xr.Dataset], + layer: str = "MerL_Riv", +) -> Union[xr.DataArray, xr.Dataset]: + """Restrict the given return periods using FLOPROS data + + The FLOPROS database describes the regional protection to river flooding based on a + return period. Users can choose from different database layers. For each coordinate + in ``return_period``, the value from the respective FLOPROS database layer is + selected. Any ``return_period`` lower than or equal to the FLOPROS protection value + is discarded and set to ``NaN``. + + Parameters + ---------- + flopros_data : PassthroughContainer + The FLOPROS data bundled into a dantro.containers.PassthroughContainer + return_period : xr.DataArray or xr.Dataset + The return periods to be restricted by the FLOPROS data + layer : str + The FLOPROS database layer to evaluate + + Returns + ------- + xr.DataArray or xr.Dataset + The ``return_period`` data with all values below the local FLOPROS protection + threshold set to ``NaN``. + """ + # Make GeoDataframe from existing geometry + latitude = return_period["latitude"].values + longitude = return_period["longitude"].values + lon, lat = np.meshgrid(longitude, latitude, indexing="ij") + df_geometry = gpd.GeoDataFrame( + geometry=gpd.points_from_xy(lon.flat, lat.flat), crs="EPSG:4326" + ) + + # Merge the DataFrames, setting the FLOPROS value for each point + df_merged = df_geometry.sjoin(flopros_data, how="left", predicate="within") + + # Available layers + # layers = [ + # "DL_Min_Co", + # "DL_Max_Co", + # "PL_Min_Co", + # "PL_Max_Co", + # "MerL_Riv", + # "DL_Min_Riv", + # "DL_Max_Riv", + # "PL_Min_Riv", + # "PL_Max_Riv", + # "ModL_Riv", + # ] + + def data_array_from_layer(col_name): + """Create a xr.DataArray from a GeoDataFrame column""" + return xr.DataArray( + data=df_merged[col_name] + .to_numpy(dtype=np.float32) + .reshape((longitude.size, latitude.size)), + dims=["longitude", "latitude"], + coords=dict(longitude=longitude, latitude=latitude), + ) + + # Apply the FLOPROS protection + flopros = data_array_from_layer(layer) + return return_period.where(return_period > flopros) + + +def flood_depth( + return_period: Union[xr.Dataset, xr.DataArray], flood_maps: xr.DataArray +) -> Union[xr.Dataset, xr.DataArray]: + """Compute the flood depth from a return period and flood maps. + + At each lat/lon coordinate, take the return period(s) and use them to interpolate + the flood maps at this position in the return period dimension. Take the interpolated + values and return them as flood hazard footprints. Works with arbitrarily high + dimensions in the ``return_period`` array. Interpolation is linear. + + Parameters + ---------- + return_period : xr.DataArray or xr.Dataset + The return periods for which to compute the flood depth. If this is a dataset, + the function will compute the flood depth for each variable. + flood_maps : xr.DataArray + Maps that indicate flood depth at latitude/longitude/return period coordinates. + + Returns + ------- + xr.DataArray or xr.Dataset + The flood depths for the given return periods. + """ + # Select lon/lat for flood maps + flood_maps = sel_lon_lat_slice(flood_maps, return_period) + + # Clip infinite return periods + return_period = return_period.clip( + min=1, max=flood_maps["return_period"].max(), keep_attrs=True + ) + + # All but 'longitude' and 'latitude' are core dimensions for this operation + core_dims = list(return_period.dims) + core_dims.remove("longitude") + core_dims.remove("latitude") + + # Define input array layout + # NOTE: This depends on the actual core dimensions put in, so we have to do this + # programmatically. + num_core_dims = len(core_dims) + arr_str = "[" + ", ".join([":" for _ in range(num_core_dims)]) + "]" + core_dims_str = "(" + ", ".join([f"c_{i}" for i in range(num_core_dims)]) + ")" + + # Define the vectorized function + @guvectorize( + f"(float32{arr_str}, float64[:], int64[:], float32{arr_str})", + f"{core_dims_str}, (j), (j) -> {core_dims_str}", + nopython=True, + ) + def interpolate(return_period, hazard, return_periods, out_depth): + """Linearly interpolate the hazard to a given return period + + Args: + return_period (float): The return period to evaluate the hazard at + hazard (np.array): The hazard at given return periods (dependent var) + return_periods (np.array): The given return periods (independent var) + + Returns: + float: The hazard at the requested return period. + + The hazard cannot become negative. Values beyond the given return periods + range are extrapolated. + """ + # Shortcut for only NaNs + # NOTE: After rebuilding the hazard maps, the "1:" can be removed + if np.all(np.isnan(hazard[1:])): + out_depth[:] = np.full_like(return_period, np.nan) + return + + # Make NaNs to zeros + # NOTE: NaNs should be grouped at lower end of 'return_periods', so this should + # be sane. + # hazard = np.nan_to_num(hazard) + hazard = np.where(np.isnan(hazard), 0.0, hazard) + + # Use extrapolation and have 0.0 as minimum value + out_depth[:] = np.interp(return_period, return_periods, hazard) + out_depth[:] = np.maximum(out_depth, 0.0) + + # Perform operation + out = xr.apply_ufunc( + interpolate, + return_period, + flood_maps, + flood_maps["return_period"], + input_core_dims=[core_dims, ["return_period"], ["return_period"]], + output_core_dims=[core_dims], + dask="parallelized", + output_dtypes=[np.float32], + dask_gufunc_kwargs=dict(allow_rechunk=True), + ) + if isinstance(out, xr.DataArray): + out = out.rename("Flood Depth") + return out + + +def save_file( + data: Union[xr.Dataset, xr.DataArray], + output_path: Union[Path, str], + encoding: Optional[Mapping[str, Any]] = None, + engine: Optional[str] = "netcdf4", + **encoding_defaults, +): + """Save xarray data as a file with default compression + + Calls ``data.to_netcdf``. + See https://docs.xarray.dev/en/stable/generated/xarray.Dataset.to_netcdf.html + for the documentation of the underlying method. + + Parameters + ---------- + data : xr.Dataset or xr.Dataarray + The data to be stored in the file + output_path : pathlib.Path or str + The file path to store the data into. If it does not contain a suffix, ``.nc`` + is automatically appended. The enclosing folder must already exist. + encoding : dict (optional) + Encoding settings for every data variable. Will update the default settings. + engine : str (optional) + The engine used for writing the file. Defaults to ``"netcdf4"``. + encoding_defaults + Encoding settings shared by all data variables. This will update the default + encoding settings, which are ``dict(dtype="float32", zlib=False, complevel=4)``. + """ + # Promote to Dataset for accessing the data_vars + if isinstance(data, xr.DataArray): + data = data.to_dataset() + + # Store encoding + default_encoding = dict(dtype="float32", zlib=False, complevel=4) + default_encoding.update(**encoding_defaults) + enc = {var: deepcopy(default_encoding) for var in data.data_vars} + if encoding is not None: + for key, settings in encoding.items(): + enc[key].update(settings) + + # Sanitize output path and write file + output_path = Path(output_path) + if not output_path.suffix: + output_path = output_path.with_suffix(".nc") + data.to_netcdf(output_path, encoding=enc, engine=engine) diff --git a/doc/climada_petals/climada_petals.hazard.rf_glofas.rst b/doc/climada_petals/climada_petals.hazard.rf_glofas.rst new file mode 100644 index 000000000..1c73542b2 --- /dev/null +++ b/doc/climada_petals/climada_petals.hazard.rf_glofas.rst @@ -0,0 +1,47 @@ +=================================================== +River Flood from GloFAS River Discharge Data Module +=================================================== + +----------- +Main Module +----------- + +.. automodule:: climada_petals.hazard.rf_glofas.river_flood_computation + :members: + :undoc-members: + :show-inheritance: + +------------------------- +Transformation Operations +------------------------- + +.. automodule:: climada_petals.hazard.rf_glofas.transform_ops + :members: + :undoc-members: + :show-inheritance: + +---------------- +Helper Functions +---------------- + +These are the functions exposed by the module. + +.. automodule:: climada_petals.hazard.rf_glofas.rf_glofas + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: climada_petals.hazard.rf_glofas.setup + :members: + :undoc-members: + :show-inheritance: + +--------------------- +CDS Glofas Downloader +--------------------- + +.. autofunction:: climada_petals.hazard.rf_glofas.cds_glofas_downloader.glofas_request + +The default configuration for each product will be updated with the ``request_kw`` from :py:func:`climada_petals.hazard.rf_glofas.cds_glofas_downloader.glofas_request`: + +.. autodata:: climada_petals.hazard.rf_glofas.cds_glofas_downloader.DEFAULT_REQUESTS diff --git a/doc/climada_petals/climada_petals.hazard.rst b/doc/climada_petals/climada_petals.hazard.rst index 873d02a68..1101e676a 100644 --- a/doc/climada_petals/climada_petals.hazard.rst +++ b/doc/climada_petals/climada_petals.hazard.rst @@ -4,6 +4,7 @@ climada\_petals\.hazard package .. toctree:: climada_petals.hazard.emulator + climada_petals.hazard.rf_glofas climada\_petals\.hazard\.drought module --------------------------------------- diff --git a/doc/climada_petals/climada_petals.util.rst b/doc/climada_petals/climada_petals.util.rst index 8cc9d8e2e..5b09f16ca 100644 --- a/doc/climada_petals/climada_petals.util.rst +++ b/doc/climada_petals/climada_petals.util.rst @@ -16,4 +16,3 @@ climada\_petals\.util\.constants module :members: :undoc-members: :show-inheritance: - diff --git a/doc/conf.py b/doc/conf.py index 863cf595b..fa23f356e 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -38,13 +38,10 @@ 'sphinx.ext.viewcode', 'sphinx.ext.napoleon', 'sphinx.ext.ifconfig', - 'nbsphinx', - 'myst_parser', + 'myst_nb', 'sphinx_markdown_tables', 'readthedocs_ext.readthedocs',] -nbsphinx_allow_errors = True - # read the docs version used for links if 'dev' in __version__: read_docs_url = 'en/latest/' @@ -54,12 +51,6 @@ # Add any paths that contain templates here, relative to this directory. templates_path = [] -# The suffix of source filenames. -source_suffix = { - ".rst": "restructuredtext", - ".md": "markdown", -} - # The encoding of source files. #source_encoding = 'utf-8' @@ -233,7 +224,28 @@ # If false, no module index is generated. #latex_use_modindex = True -# ----------------------------------------------------------------------------- +# --- MYST Parser settings ---- + +# Jupyter Notebooks will not be executed when creating the docs +nb_execution_mode = "off" + +# Extensions, see https://myst-parser.readthedocs.io/en/latest/configuration.html#list-of-syntax-extensions +myst_enable_extensions = [ + "amsmath", + "colon_fence", + "deflist", + "dollarmath", + "html_image", +] + +# URI schemes that are converted to external links +myst_url_schemes = ("http", "https", "mailto") + +# Generate heading anchors for linking to them, up to heading level 4 +myst_heading_anchors = 4 + +# --- + # show __init__ documentation def skip(app, what, name, obj, skip, options): if (name == "__init__"): @@ -247,6 +259,13 @@ def remove_module_docstring(app, what, name, obj, options, lines): autodoc_member_order = "bysource" +# Mock imports that do not work in the readthedocs environment +autodoc_mock_imports = [ + # Does not work because it would require a reload of the environment after + # installation (which is not done by readthedocs.org) + "xesmf" +] + def setup(app): app.connect("autodoc-skip-member", skip) app.connect("autodoc-process-docstring", remove_module_docstring) diff --git a/doc/glofas_rf.rst b/doc/glofas_rf.rst new file mode 100644 index 000000000..c37e850b6 --- /dev/null +++ b/doc/glofas_rf.rst @@ -0,0 +1,294 @@ +============================================== +River Flood Hazards from GloFAS Discharge Data +============================================== + +This tutorial will guide you through the GloFAS River Flood module of CLIMADA Petals. +It's purpose is to download river discharge data from the Global Flood Awareness System (GloFAS) and compute flood depths from it. +The data is stored by the `Copernicus Data Store (CDS) `_ and will be automatically downloaded in the process. + +-------- +Overview +-------- + +Instead of employing a computationally expensive hydrological model to compute inundation depths, this module uses a simplified statistical approach to compute flooded areas. +As an input, the approach uses river discharge data and river flood hazard maps. +These hazard maps contain flood footprints for specific return periods. +The idea is to compute equivalent return periods for the discharge data at every pixel and then use the flood hazard maps to compute a flood hazard. +For computing these return periods, we require an extreme value distribution at every point. +In practice, we fit such distributions from the historical discharge data. + +Depending on your area and time series of interest the computational cost and the amount of data produced can be immense. +For a larger country, however, a single flood inundation footprint can be computed within few minutes on a decently modern machine. + +------------ +Preparations +------------ + +We need to prepare three things: The flood hazard maps, the extreme value distributions, and access to the CDS API. + +Copernicus Data Store API Access + +1. Register at the `Copernicus Data Store (CDS) `_ and log in. +2. Check out the `CDS API HowTo `_. + In the section "Install the CDS API key", copy the content of the black box on the right. +3. Create a file called ``.cdsapirc`` in your home directory and paste the contents of the black box into it. + + If you are unsure where to put the file and you are working on a Linux or macOS system, open a terminal and execute + + .. code-block:: shell + + cd $HOME + touch .cdsapirc + + Now the file is created and can be opened with your favorite text editor. + +Use Prepared Datasets +^^^^^^^^^^^^^^^^^^^^^ + +The Gumbel distribution fit parameter data has been uploaded to the `ETH Research Collection `_ for your convenience: `Gumbel distribution fit parameters for historical GloFAS river discharge data (1979–2015) `_ + +This dataset and the global flood hazard maps will be automatically downloaded when executing + +.. code-block:: python + + from climada_petals.hazard.rf_glofas import setup_all + + setup_all() + +Alternatively, you can download the data yourself or specify custom paths to datasets on +your machine. + +After this step, you should have the following files in your ``/data/river-flood-computation``: + +* ``gumbel-fit.nc``: A NetCDF file containing ``loc``, ``scale`` and ``samples`` variables with dimensions ``latitude`` and ``longitude`` on a grid matching the input discharge data (here: GloFAS). +* ``flood-maps.nc``: A NetCDF file giving the ``flood_depth`` with dimensions ``latitude``, ``longitude``, and ``return_period``. The grid is allowed to differ from that of the discharge and the Gumbel fit parameters and is expected to have a higher resolution. +* ``FLOPROS_shp_V1/FLOPROS_shp_V1.shp``: A shapefile containing flood protection standards for the entire world, encoded as return period against which the local measures are protecting against. + +.. _compute: + +--------------------------- +Computing a Flood Footprint +--------------------------- + +With the required data in place and access to the Copernicus Data Store, we can proceed to compute a flood footprint. +In the end, we want to arrive at a ``Hazard`` object we can use for computations in CLIMADA. + +The overall procedure is as follows: + +1. Instantiate an object of :py:class:`~climada_petals.hazard.rf_glofas.river_flood_computation.RiverFloodInundation`. +2. Use it to download discharge data (either ensemble forecasts or historical reanalysis) from the CDS. +3. Compute flood inundation footprints from the downloaded data with :py:meth:`~climada_petals.hazard.rf_glofas.river_flood_computation.RiverFloodInundation.compute`. +4. Create a series of hazard objects (or a single object) from the data using :py:func:`~climada_petals.hazard.rf_glofas.rf_glofas.hazard_series_from_dataset`. + +.. code-block:: python + + from climada_petals.hazard.rf_glofas import ( + RiverFloodInundation, + hazard_series_from_dataset, + ) + + forecast_date = "2023-08-01" + rf = RiverFloodInundation() + rf.download_forecast( + countries="Switzerland", + forecast_date=forecast_date, + lead_time_days=5, + preprocess=lambda x: x.max(dim="step"), + ) + ds_flood = rf.compute() + hazard = hazard_series_from_dataset(ds_flood, "flood_depth", "number") + +Step-By-Step Instructions +^^^^^^^^^^^^^^^^^^^^^^^^^ + +The :py:meth:`~climada_petals.hazard.rf_glofas.river_flood_computation.RiverFloodInundation.compute` method is a shortcut for the steps of the flood model algorithm that compute flood depth from the discharge input. + +The single steps are as follows: + +#. Computing the return period from the input discharge with :py:meth:`~climada_petals.hazard.rf_glofas.river_flood_computation.RiverFloodInundation.return_period`. + To that end, the fitted Gumbel distributions are used and a return period is computed by :math:`r(q) = (1 - \text{cdf}(q))^{-1}`, where :math:`\text{cdf}` is the cumulative distribution function of the fitted Gumbel distribution and :math:`q` is the input discharge. + + .. code-block:: python + + discharge = rf.download_forecast( + countries="Switzerland", + forecast_date=forecast_date, + lead_time_days=5, + preprocess=lambda x: x.max(dim="step"), + ) + return_period = rf.return_period(discharge) + + Alternatively, bootstrap sampling can be employed to represent the statistical uncertainty in the return period computation with :py:meth:`~climada_petals.hazard.rf_glofas.river_flood_computation.RiverFloodInundation.return_period_resample`. + In bootstrap sampling, we draw random samples from the fitted Gumbel distribution and fit a new distribution from them. + This process can be repeated an arbitrary number of times. + The resulting distribution quantifies the uncertainty in the original fit. + The first argument to the method is the number of samples to draw while bootstrapping (i.e., how many samples the resulting distribution should have). + + .. code-block:: python + + return_period = rf.return_period_resample(10, discharge) + +#. Regridding the return period onto the higher resolution grid of the flood hazard maps with :py:meth:`~climada_petals.hazard.rf_glofas.river_flood_computation.RiverFloodInundation.regrid`: + + .. code-block:: python + + return_period_regrid = rf.regrid(return_period) + +#. *Optional:* Applying the protection level with :py:meth:`~climada_petals.hazard.rf_glofas.river_flood_computation.RiverFloodInundation.apply_protection`: + + .. code-block:: python + + return_period_regrid_protect = rf.apply_protection(return_period_regrid) + +#. Computing the flood depth from the regridded return period by interpolating between flood hazard maps for various return periods with :py:meth:`~climada_petals.hazard.rf_glofas.river_flood_computation.RiverFloodInundation.flood_depth` + + .. code-block:: python + + flood_depth = rf.flood_depth(return_period_regrid) + flood_depth_protect = rf.flood_depth(return_period_regrid_protect) + + If :py:meth:`~climada_petals.hazard.rf_glofas.river_flood_computation.RiverFloodInundation.compute` was executed with ``apply_protection="both"`` (default), it will merge the data arrays for flood depth without protection applied and with protection applied, respectively, into a single dataset and return it. + +Passing Keyword-Arguments to ``compute`` +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +If you want to pass custom arguments to the methods called by :py:meth:`~climada_petals.hazard.rf_glofas.river_flood_computation.RiverFloodInundation.compute` without calling each method individually, you can do so via the ``resample_kws`` and ``regrid_kws`` arguments. + +If you add ``resample_kws``, :py:meth:`~climada_petals.hazard.rf_glofas.river_flood_computation.RiverFloodInundation.compute` will call :py:meth:`~climada_petals.hazard.rf_glofas.river_flood_computation.RiverFloodInundation.return_period_resample` instead of :py:meth:`~climada_petals.hazard.rf_glofas.river_flood_computation.RiverFloodInundation.return_period` and pass the mapping as keyword arguments. + +Likewise, ``regrid_kws`` will be passed as keyword arguments to :py:meth:`~climada_petals.hazard.rf_glofas.river_flood_computation.RiverFloodInundation.regrid`. + +.. code-block:: python + + ds_flood = rf.compute( + resample_kws=dict(num_bootstrap_samples=20, num_workers=4), + regrid_kws=dict(reuse_regridder=True) + ) + +Creating Hazards from the Data +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +With the computation successful, we now want to create `Hazard `_ objects. +The resulting data is usually multi-dimensional, which is why we typically create multiple Hazard objects from it. +Two obvious dimensions are the spatial ones, longitude and latitude. +Ignoring these (as they must persist into the ``Hazard`` object), we can decide on one more dimension to merge into a single hazard. + +If we use an ensemble forecast like in the above example, and decide *not* to compute the maximum in time, the dataset has four coodinates: ``latitude``, ``longitude``, ``step``, and ``number``, with the latter two indicating the lead time step and the ensemble member, respectively. +Employing bootstrap sampling would add another dimension ``sample``. +To create hazard objects, we would have to decide which of these dimensions should encode the "event" dimension in the ``Hazard``. +For each combination of the remaining dimension coordinates, a new Hazard object would then be created. + +The task of splitting and concatenating along particular dimensions of the dataset and creating Hazard objects is performed by :py:func:`climada_petals.hazard.rf_glofas.rf_glofas.hazard_series_from_dataset`. +We put in the data as file path or xarray ``Dataset`` and receive a `pandas.Series `_ with the hazard objects as values and the remaining dimension coordinates as `MultiIndex `_. +The dimension name which is to be considered the event dimension in a ``Hazard`` instance must be specified as the ``event_dim`` argument. + +.. tip:: + + If the dataset is three-dimensional, :py:func:`climada_petals.hazard.rf_glofas.rf_glofas.hazard_series_from_dataset` will return a single Hazard object instead of a ``pandas.Series``. + +.. code-block:: python + + discharge = rf.download_forecast( + countries="Switzerland", + forecast_date="2023-08-01", + lead_time_days=5, + ) + + # Compute flood for maximum over lead time + ds_flood = rf.compute(discharge.max(dim="step")) + + # Single hazard return (no remaining dimensions) + hazard = hazard_series_from_dataset(ds_flood, "flood_depth", "number") + + # Compute flood for each lead time day *and* bootstrap sample + ds_flood_multidim = rf.compute(discharge, resample_kws=dict(num_bootstrap_samples=20)) + + # Series with MultiIndex: step, member + # Each hazard with 20 events (samples) + hazard_series = hazard_series_from_dataset(ds_flood, "flood_depth", "sample") + + +Storing Data +^^^^^^^^^^^^ + +Use :py:func:`climada_petals.hazard.rf_glofas.transform_ops.save_file` to store xarray Datasets or DataArrays conveniently. + +.. tip:: + + Storing your result is important for two reasons: + + #. Computing flood footprints for larger areas or multiple events can take a lot of time. + #. Loading flood footprints into ``Hazard`` objects requires transpositions that do not commute well with the lazy computations and evaluations by xarray. + Storing the data and re-loading it before plugging it into :py:func:`~climada_petals.hazard.rf_glofas.rf_glofas.hazard_series_from_dataset` will likely increase performance. + +By default, data is stored without compression and encoded in 32-bit floats. +This maintains a reasonable accuracy while reducing file size by half even though no compression is applied. +Compression will drastically reduce the storage space needed for the data. +However, it also creates a heavy burden on the CPU and especially multiprocessing and multithreading tasks suffer heavily. +If storage space permits, it is therefore recommended to store the data without compression. + +.. warning:: Saving results of computations **with** compression is **not** recommended, because performance might be impeded **a lot**! + +To enable compression, add ``zlib=True`` as argument to :py:func:`~climada_petals.hazard.rf_glofas.transform_ops.save_file`. +The default compression level is ``complevel=4``. +The compression level may range from 1 to 9. + +Because storing without compression does not compromise multiprocessing performance, it might be feasible to first write *without* compression after computing the result, and then to re-write *with* compression separately to save storage space. +The reason for this is that xarray uses dask to perform computations lazily. +Only when data is required, dask will compute it according to the transformations applied on the data. +This does not commute well with compression. + +The following code will likely run much faster than directly writing ``ds_flood`` with compression, especially when the data is large. +However, it requires the space to once store the entire dataset without compression. + +.. code-block:: python + + from pathlib import Path + import xarray as xr + from climada_petals.hazard.rf_glofas import save_file + + rf.download_forecast( + countries="Switzerland", + forecast_date="2023-08-01", + lead_time_days=5, + ) + ds_flood = rf.compute() + + # Save without compression (default) + outpath = Path("out.nc") + save_file(ds_flood, outpath) + ds_flood.close() # Release data + + # Re-open, and save with compression into "out-comp.nc" + with xr.open_dataset(outpath, chunks="auto") as ds: + save_file(ds, outpath.with_stem(outpath.stem + "-comp"), zlib=True) + + # Delete initial file + outpath.unlink() + +Storing Intermediate Data +^^^^^^^^^^^^^^^^^^^^^^^^^ + +By default, :py:class:`~climada_petals.hazard.rf_glofas.river_flood_computation.RiverFloodInundation` stores the result of each computation step in a cache directory and reloads it for the next step. +The reason for this is similar to the issue with compression: +To perform our computations, the data has to be transposed often. +Multiple transpositions of a dataset in memory are costly, but storing data and reopening it transposed is fast. +Especially for larger data that do not fit into memory at once, :py:attr:`~climada_petals.hazard.rf_glofas.river_flood_computation.RiverFloodInundation.store_intermediates` should therefore be set to ``True`` (default). + +The intermediate data is stored in a cache directory which is deleted after the :py:class:`~climada_petals.hazard.rf_glofas.river_flood_computation.RiverFloodInundation` instance is closed or deleted. +While it exists, the cached data can be accessed via the :py:attr:`~climada_petals.hazard.rf_glofas.river_flood_computation.RiverFloodInundation.cache_paths` after the computation: + +.. code-block:: python + + import xarray as xr + + rf.download_forecast( + countries="Switzerland", + forecast_date="2023-08-01", + lead_time_days=5, + ) + ds_flood = rf.compute() + + # Plot regridded return period + with xr.open_dataarray(rf.cache_paths.return_period_regrid, chunks="auto") as da_rp: + da_rp.isel(step=0).max(dim="member").plot() diff --git a/doc/index.rst b/doc/index.rst index dcfd5f6ae..fca1b9b40 100644 --- a/doc/index.rst +++ b/doc/index.rst @@ -57,6 +57,13 @@ Jump right in: Weather and Climate Risks Group +.. toctree:: + :caption: Documentation + :maxdepth: 1 + + glofas_rf + + .. toctree:: :caption: API Reference :hidden: diff --git a/doc/tutorial/climada_hazard_glofas_rf.ipynb b/doc/tutorial/climada_hazard_glofas_rf.ipynb new file mode 100644 index 000000000..4882aa485 --- /dev/null +++ b/doc/tutorial/climada_hazard_glofas_rf.ipynb @@ -0,0 +1,3234 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# River Flood based on GloFAS Discharge Data\n", + "\n", + "This tutorial will guide through the process of computing flood foodprints from GloFAS river discharge data and using these footprints in CLIMADA impact calculations.\n", + "\n", + "Executing this tutorial requires access to the Copernicus Data Store (CDS) and the input data for the flood footprint pipeline.\n", + "Please have a look at the documentation of the [GloFAS River Flood module](../glofas_rf.rst) and follow the instructions in its \"Preparation\" section before continuing.\n", + "\n", + "The first step is setting up the \"static\" data required for the river flood model.\n", + "The {py:func}`~climada_petals.hazard.rf_glofas.setup.setup_all` function will download the flood hazard maps, the FLOPROS flood protection database, and the pre-computed Gumbel distribution fit parameters.\n", + "This might take a while." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/roo/miniforge3/envs/climada_flood/lib/python3.9/site-packages/dask/dataframe/_pyarrow_compat.py:17: FutureWarning: Minimal version of pyarrow will soon be increased to 14.0.1. You are using 12.0.1. Please consider upgrading.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-02-29 14:54:26,872 - climada_petals.hazard.rf_glofas.setup - DEBUG - Rewriting flood hazard maps to NetCDF files\n", + "2024-02-29 14:54:26,873 - climada_petals.hazard.rf_glofas.setup - DEBUG - Merging flood hazard maps into single dataset\n", + "2024-02-29 14:58:21,780 - climada_petals.hazard.rf_glofas.setup - DEBUG - Downloading FLOPROS database\n", + "2024-02-29 14:58:22,371 - climada_petals.hazard.rf_glofas.setup - DEBUG - Downloading Gumbel fit parameters\n" + ] + } + ], + "source": [ + "from climada.util import log_level\n", + "from climada_petals.hazard.rf_glofas import setup_all\n", + "\n", + "with log_level(\"DEBUG\", \"climada_petals\"):\n", + " setup_all()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/roo/miniforge3/envs/climada_flood/lib/python3.9/site-packages/xarray/core/dataset.py:282: UserWarning: The specified chunks separate the stored chunks along dimension \"latitude\" starting at index 1377. This could degrade performance. Instead, consider rechunking after loading.\n", + " warnings.warn(\n", + "/home/roo/miniforge3/envs/climada_flood/lib/python3.9/site-packages/xarray/core/dataset.py:282: UserWarning: The specified chunks separate the stored chunks along dimension \"longitude\" starting at index 3480. This could degrade performance. Instead, consider rechunking after loading.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-02-29 14:58:26,019 - climada_petals.hazard.rf_glofas.cds_glofas_downloader - INFO - Skipping request for file '/home/roo/climada/data/cds-download/240229-145826-83e84eba8992a4a4d5f8af0a923e2458.grib' because it already exists\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/roo/miniforge3/envs/climada_flood/lib/python3.9/site-packages/dask/array/routines.py:325: PerformanceWarning: Increasing number of chunks by factor of 50\n", + " intermediate = blockwise(\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:              (number: 50, time: 1, longitude: 1356, latitude: 1128)\n",
+       "Coordinates:\n",
+       "  * number               (number) int64 1 2 3 4 5 6 7 8 ... 44 45 46 47 48 49 50\n",
+       "  * time                 (time) datetime64[ns] 2021-07-10\n",
+       "    surface              float64 ...\n",
+       "    step                 timedelta64[ns] ...\n",
+       "  * longitude            (longitude) float64 5.854 5.863 5.871 ... 17.14 17.15\n",
+       "  * latitude             (latitude) float64 55.15 55.14 55.13 ... 45.76 45.75\n",
+       "Data variables:\n",
+       "    flood_depth          (latitude, longitude, time, number) float32 dask.array<chunksize=(762, 162, 1, 50), meta=np.ndarray>\n",
+       "    flood_depth_flopros  (latitude, longitude, time, number) float32 dask.array<chunksize=(762, 162, 1, 50), meta=np.ndarray>
" + ], + "text/plain": [ + "\n", + "Dimensions: (number: 50, time: 1, longitude: 1356, latitude: 1128)\n", + "Coordinates:\n", + " * number (number) int64 1 2 3 4 5 6 7 8 ... 44 45 46 47 48 49 50\n", + " * time (time) datetime64[ns] 2021-07-10\n", + " surface float64 ...\n", + " step timedelta64[ns] ...\n", + " * longitude (longitude) float64 5.854 5.863 5.871 ... 17.14 17.15\n", + " * latitude (latitude) float64 55.15 55.14 55.13 ... 45.76 45.75\n", + "Data variables:\n", + " flood_depth (latitude, longitude, time, number) float32 dask.array\n", + " flood_depth_flopros (latitude, longitude, time, number) float32 dask.array" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from climada_petals.hazard.rf_glofas import RiverFloodInundation\n", + "\n", + "countries = [\"Germany\", \"Switzerland\", \"Austria\"]\n", + "\n", + "rf = RiverFloodInundation()\n", + "rf.download_forecast(\n", + " countries=countries,\n", + " forecast_date=\"2021-07-10\",\n", + " preprocess=lambda x: x.max(dim=\"step\"),\n", + " system_version=\"operational\", # Version mislabeled\n", + ")\n", + "\n", + "ds_flood = rf.compute()\n", + "ds_flood\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The returned dataset contains two variables, `flood_depth` and `flood_depth_flopros` which indicate the flood footprints without and with FLOPROS protection levels considered, respectively.\n", + "Notice that intermediate data is stored in a cache directory by default, but the returned flood data is not.\n", + "You can use {py:func}`~climada_petals.hazard.rf_glofas.transform_ops.save_file` to store it.\n", + "The cache directory will be deleted as soon as the {py:class}`~climada_petals.hazard.rf_glofas.river_flood_computation.RiverFloodInundation` object is." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from climada_petals.hazard.rf_glofas import save_file\n", + "\n", + "save_file(ds_flood, \"flood-2021-07-10.nc\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To use the data within CLIMADA we will have to \"translate\" it into a Hazard object.\n", + "We provide a helper function for that: {py:func}`climada_petals.hazard.rf_glofas.rf_glofas.hazard_series_from_dataset`.\n", + "Here we have to specify the variable to be read as hazard intensity (we choose the one *without* FLOPROS protection levels) and the dimension of the dataset that indicates the \"event\" dimension of the Hazard object.\n", + "If the dataset contained more dimensions than `event_dim`, `latitude` and `longitude`, the function `hazard_series_from_dataset` would return a pandas Series of Hazard objects indexed with these additional dimensions.\n", + "We will see this later.\n", + "\n", + "Notice that storing data and reading it from a file might in some cases be faster than loading the data directly into a Hazard object, because the latter requires some potentially costly transpositions of the underlying data structures.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-02-29 14:59:26,406 - climada.hazard.base - WARNING - Failed to read values of 'number' as dates. Hazard.event_name will be empty strings\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_41108/360336388.py:3: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " hazard = hazard_series_from_dataset(\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from climada_petals.hazard.rf_glofas import hazard_series_from_dataset\n", + "\n", + "hazard = hazard_series_from_dataset(\n", + " ds_flood, intensity=\"flood_depth\", event_dim=\"number\"\n", + ")[0]\n", + "hazard.plot_intensity(event=0)\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exposure and Vulnerability\n", + "\n", + "When looking at flood warnings and protection we typically want to determine how many people might be affected from floods or lose their homes.\n", + "We therefore use data on population distribution as exposure.\n", + "To that end, we create a `LitPop` exposure with the `pop` mode for the countries of interest.\n", + "\n", + "Being affected by a flood can be considered a binary classification (yes/no), therefore we use a simple step function with a relatively low threshold of 0.2 m.\n", + "\n", + "Notice that we set the impact function identifier to `\"RF\"` because this is the hazard type identifier of `RiverFlood`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-02-29 14:59:53,885 - climada.entity.exposures.litpop.litpop - INFO - \n", + " LitPop: Init Exposure for country: DEU (276)...\n", + "\n", + "2024-02-29 14:59:53,935 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n", + "2024-02-29 14:59:53,936 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n", + "2024-02-29 14:59:53,956 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n", + "2024-02-29 14:59:53,957 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n", + "2024-02-29 14:59:53,982 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n", + "2024-02-29 14:59:53,983 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n", + "2024-02-29 14:59:54,006 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n", + "2024-02-29 14:59:54,007 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n", + "2024-02-29 14:59:54,031 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n", + "2024-02-29 14:59:54,032 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n", + "2024-02-29 14:59:54,058 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n", + "2024-02-29 14:59:54,059 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n", + "2024-02-29 14:59:54,084 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n", + "2024-02-29 14:59:54,085 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n", + "2024-02-29 14:59:54,104 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n", + "2024-02-29 14:59:54,105 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n", + "2024-02-29 14:59:54,134 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n", + "2024-02-29 14:59:54,135 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n", + "2024-02-29 14:59:54,151 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n", + "2024-02-29 14:59:54,151 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n", + "2024-02-29 14:59:54,185 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n", + "2024-02-29 14:59:54,186 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n", + "2024-02-29 14:59:56,052 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n", + "2024-02-29 14:59:56,053 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n", + "2024-02-29 14:59:56,119 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n", + "2024-02-29 14:59:56,120 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n", + "2024-02-29 14:59:56,194 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n", + "2024-02-29 14:59:56,195 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n", + "2024-02-29 14:59:56,257 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n", + "2024-02-29 14:59:56,258 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n", + "2024-02-29 14:59:56,339 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n", + "2024-02-29 14:59:56,340 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n", + "2024-02-29 14:59:56,411 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n", + "2024-02-29 14:59:56,412 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n", + "2024-02-29 14:59:56,478 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n", + "2024-02-29 14:59:56,479 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n", + "2024-02-29 14:59:56,541 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n", + "2024-02-29 14:59:56,542 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n", + "2024-02-29 14:59:56,614 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n", + "2024-02-29 14:59:56,615 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n", + "2024-02-29 14:59:56,685 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n", + "2024-02-29 14:59:56,687 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n", + "2024-02-29 14:59:58,417 - climada.entity.exposures.litpop.litpop - INFO - \n", + " LitPop: Init Exposure for country: CHE (756)...\n", + "\n", + "2024-02-29 15:00:00,409 - climada.entity.exposures.litpop.litpop - INFO - \n", + " LitPop: Init Exposure for country: AUT (40)...\n", + "\n", + "2024-02-29 15:00:01,222 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n", + "2024-02-29 15:00:01,223 - climada.entity.exposures.base - INFO - category_id not set.\n", + "2024-02-29 15:00:01,224 - climada.entity.exposures.base - INFO - cover not set.\n", + "2024-02-29 15:00:01,224 - climada.entity.exposures.base - INFO - deductible not set.\n", + "2024-02-29 15:00:01,225 - climada.entity.exposures.base - INFO - centr_ not set.\n" + ] + } + ], + "source": [ + "from climada.entity import LitPop\n", + "from climada.entity import ImpactFunc, ImpactFuncSet\n", + "\n", + "# Create a population exposure\n", + "exposure = LitPop.from_population([\"Germany\", \"Switzerland\", \"Austria\"])\n", + "exposure.gdf[\"impf_RF\"] = 1\n", + "\n", + "# Create a impact function for being affected by flooding\n", + "impf_affected = ImpactFunc.from_step_impf(\n", + " intensity=(0.0, 0.2, 100.0), impf_id=1, haz_type=\"RF\"\n", + ")\n", + "impf_set_affected = ImpactFuncSet([impf_affected])\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Impact Calculation\n", + "\n", + "We simply plug everything together and calculate the impact.\n", + "Afterwards, we plot the average impact for 14 July 2021.\n", + "\n", + "The averaging function takes the `frequency` parameter of the hazard into account.\n", + "By default, all hazard events have a frequency of 1.\n", + "This may result in unexpected values for average impacts.\n", + "We therefore divide the frequency by the number of events before plotting." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-02-29 15:00:01,268 - climada.entity.exposures.base - INFO - Matching 876313 exposures with 1529568 centroids.\n", + "2024-02-29 15:00:01,281 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2024-02-29 15:00:03,547 - climada.engine.impact_calc - INFO - Calculating impact for 2606616 assets (>0) and 50 events.\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "from climada.engine import ImpactCalc\n", + "\n", + "hazard.frequency = hazard.frequency / hazard.size\n", + "impact = ImpactCalc(exposure, impf_set_affected, hazard).impact()\n", + "impact.plot_hexbin_eai_exposure(gridsize=100, lw=0)\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## FLOPROS Database Protection Standards\n", + "\n", + "So far, we ignored any protection standards, likely overestimating the impact of events.\n", + "The FLOPROS database provides information on river flood protection standards.\n", + "It is a supplement to the publication by [P. Scussolini et al.: \"FLOPROS: an evolving global database of flood protection standards\"](https://dx.doi.org/10.5194/nhess-16-1049-2016)\n", + "It was automatically loaded when you called `setup_all()`.\n", + "\n", + "Let's compare the hazard and corresponding impacts when considering the FLOPROS protection standards!" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-02-29 15:00:09,411 - climada.hazard.base - WARNING - Failed to read values of 'number' as dates. Hazard.event_name will be empty strings\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_41108/1832447213.py:1: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " hazard_flopros = hazard_series_from_dataset(\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hazard_flopros = hazard_series_from_dataset(\n", + " ds_flood, intensity=\"flood_depth_flopros\", event_dim=\"number\"\n", + ")[0]\n", + "hazard_flopros.plot_intensity(event=0)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-02-29 15:00:37,496 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for RF\n", + "2024-02-29 15:00:37,497 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for RF\n", + "2024-02-29 15:00:37,498 - climada.entity.exposures.base - INFO - Matching 876313 exposures with 1529568 centroids.\n", + "2024-02-29 15:00:37,514 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2024-02-29 15:00:39,504 - climada.engine.impact_calc - INFO - Calculating impact for 2606616 assets (>0) and 50 events.\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hazard_flopros.frequency = hazard_flopros.frequency / hazard_flopros.size\n", + "impact_flopros = ImpactCalc(exposure, impf_set_affected, hazard_flopros).impact()\n", + "impact_flopros.plot_hexbin_eai_exposure(gridsize=100, lw=0)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.02, 0.5, 'Affected Population')" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkcAAAGsCAYAAADXKAMrAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABKpElEQVR4nO3de1xUZf4H8M/ADMMdAgRFLiKmRHhJwPsFMikSy9SytVw1rQzWQlJ/Ypuma1Galy6Al0xzt93MW+16S9RRvGQhpqlIKqJi3AKUEQaG2/n94TI7I6gzzAwzMJ/368UL5znPPPOF8cCH5zznHJEgCAKIiIiICABgZeoCiIiIiMwJwxERERGRGoYjIiIiIjUMR0RERERqGI6IiIiI1DAcEREREalhOCIiIiJSw3BEREREpIbhiIiIiEgNwxERERGRGoYjPaSnp2P06NHw9vaGSCTCd999p/MYgiDg448/Rvfu3SGVSuHr64sPPvjA8MUSERGRVsSmLqAtq6ysRO/evTF16lSMGzeuRWO89dZb2LdvHz7++GP07NkT5eXlKCkpMXClREREpC0RbzxrGCKRCDt27MCYMWNUbTU1NfjrX/+Kr7/+Grdu3UJISAg++ugjREREAAAuXLiAXr164dy5c+jRo4dpCiciIiINPKxmRFOnTsWxY8fwzTff4Ndff8Xzzz+Pp556CpcuXQIA/Oc//0HXrl2xc+dOBAQEoEuXLpg+fTrKyspMXDkREZHlYjgykpycHPzrX//Cli1bMHToUAQGBmL27NkYMmQINmzYAAC4cuUKrl27hi1btmDTpk3YuHEjMjMzMX78eBNXT0REZLm45shITp06BUEQ0L17d412pVIJd3d3AEBDQwOUSiU2bdqk6rd+/XqEhobit99+46E2IiIiE2A4MpKGhgZYW1sjMzMT1tbWGtscHR0BAJ06dYJYLNYIUI888ggA4Pr16wxHREREJsBwZCSPPfYY6uvrUVxcjKFDhzbbZ/Dgwairq0NOTg4CAwMBABcvXgQA+Pv7t1qtRERE9D88W00PFRUVuHz5MoA7YWjFihWIjIyEm5sb/Pz88PLLL+PYsWNYvnw5HnvsMZSUlODgwYPo2bMnnn76aTQ0NCA8PByOjo5YtWoVGhoaEBcXB2dnZ+zbt8/EXx0REZFlYjjSw6FDhxAZGdmkffLkydi4cSNqa2uxZMkSbNq0Cb///jvc3d0xcOBALFq0CD179gQA5OfnY+bMmdi3bx8cHBwQHR2N5cuXw83NrbW/HCIiIgLDEREREZEGnspPREREpIbhiIiIiEgNz1bTUUNDA/Lz8+Hk5ASRSGTqcoiIiEgLgiDg9u3b8Pb2hpXV/eeGGI50lJ+fD19fX1OXQURERC2Ql5cHHx+f+/ZhONKRk5MTgDvfXGdnZxNXQ8amUCggk8kQGRkJe3t7U5dDRAbE/duyyOVy+Pr6qn6P3w/DkY4aD6U5OzszHFkAsVgMe3t7ODs784cnUTvD/dsyabMkhguyiYiIiNQwHBERERGpYTgiIiIiUsM1R2SxFAoFsrOz79vn1u1KHD+bAydXN7g6OTxwzKCgIK5dICJq4xiOyGJlZ2cjNDRUq75LtRwzMzMTffv2bXlRRERkcgxHZLGCgoKQmZl53z5ZeaWYsyMLy54LRrCvu1ZjEhFR28ZwRBbL3t7+gbM8DS5FkP5Yg6CQXugb6NVKlRERkSlxQTYRERGRGoYjIiIiIjUMR0RERERqGI6IiIiI1DAcEREREalhOCIiIiJSw3BEREREpIbhiIiIiEgNwxERERGRGoYjIiIiIjUMR0RERERqGI6IiIiI1DAcEREREalhOCIiIiJSY9HhKCkpCSKRCPHx8aYuhYiIiMyExYajjIwMrF27Fr169TJ1KURERGRGLDIcVVRU4KWXXsK6devw0EMPmbocIiIiMiNiUxdgCnFxcRg1ahSeeOIJLFmy5L59lUollEql6rFcLgcA1NbWora21qh1kunV1derPvP9Jmpf6urqVJ+5f7d/urzHFheOvvnmG5w6dQoZGRla9U9KSsKiRYuatO/btw/29vaGLo/MTF4FAIhxMiMDRRdMXQ0RGYNMJjN1CdQKFAqF1n0tKhzl5eXhrbfewr59+2Bra6vVcxITE5GQkKB6LJfL4evri6ioKDg7OxurVDITmbl/AGd/QVh4OEIDOpi6HCIyoKqqKshkMkRGRsLOzs7U5ZCRNR750YZFhaPMzEwUFxcjNDRU1VZfX4/09HR8/vnnUCqVsLa21niOVCqFVCptMpZEIoFEIjF6zWRa4v/+fxBbW/P9JmpnGg+ziMVi7t8WQJf32KLC0YgRI3D27FmNtqlTpyIoKAj/93//1yQYERERkeWxqHDk5OSEkJAQjTYHBwe4u7s3aSciIiLLZJGn8hMRERHdi0XNHDXn0KFDpi6BiIiIzAhnjoiIiIjUMBwRERERqWE4IiIiIlLDcERERESkhuGIiIiISA3DEREREZEahiMiIiIiNQxHRERERGoYjoiIiIjUMBwRERERqWE4IiIiIlLDcERERESkhuGIiIiISA3DEREREZEahiMiIiIiNQxHRERERGoYjoiIiIjUMBwRERERqWE4IiIiIlIjNnUBRMaSW1KJSmWdXmNcKalUfba1Lde7JgepGAEeDnqPQ0RExsNwRO1SbkklIj8+ZLDx5u64YLCxZLMjGJCIiMwYwxG1S40zRqsm9EE3T8cWj1NeUYm9RzLw1NBwuDjqF2guF1cgfvNpvWeziIjIuCwuHKWmpiI1NRVXr14FADz66KNYsGABoqOjTVsYGUU3T0eEdHZp8fMVCglKOgCP+brC3t7egJUREZG5srgF2T4+Pvjwww9x8uRJnDx5Eo8//jieffZZnD9/3tSlERERkRmwuJmj0aNHazx+//33kZqaihMnTuDRRx81UVVERERkLiwuHKmrr6/Hli1bUFlZiYEDBzbbR6lUQqlUqh7L5XIAQG1tLWpra1ulTtJdXV2d6rM+75OhxjH0WESkP+6TlkWX99giw9HZs2cxcOBAVFdXw9HRETt27EBwcHCzfZOSkrBo0aIm7fv27eMaFDOWVwEAYhw9ehTXWr4eW0Umk+k9hqFrIiLDMMT+TeZPoVBo3VckCIJgxFrMUk1NDa5fv45bt25h27Zt+OKLL3D48OFmA1JzM0e+vr4oKSmBs7Nza5ZNOjifL8eY1BP47o0BeNS75e9TVVUVZDIZIiMjYWdnZxY1EZFhGHL/JvMnl8vh4eGB8vLyB/7+tsiZIxsbG3Tr1g0AEBYWhoyMDHzyySdYs2ZNk75SqRRSqbRJu0QigUQiMXqt1DJisVj1WZ/3qXEaVt9xDFkTERmGIfdvMn+6vMcWd7ZacwRB0JgdIiIiIstlcTNH8+fPR3R0NHx9fXH79m188803OHToEPbu3Wvq0oiIiMgMWFw4KioqwqRJk1BQUAAXFxf06tULe/fuxciRI01dGhEREZkBiwtH69evN3UJREREZMa45oiIiIhIDcMRERERkRqLO6xGlkMkliNX/husbFt+xcXq6mrk1+Uj+2Y2bKts9aonV14BkViu1xhERGR8DEfUbklcf8L8nz8wyFgp+1MMMo7EdQSApw0yFhERGQfDEbVbtbf6Y/moiQj01G/m6KcTP6H/gP6wtdVv5iinuAJvfp2j1xhERGR8DEfUbgl1zghw7oFgd5cWj6FQKJAnzkPQQ0F630uvobocQt0feo1BRETGxwXZRERERGoYjoiIiIjUMBwRERERqWE4IiIiIlLDcERERESkhuGIiIiISA3DEREREZEahiMiIiIiNQxHRERERGoYjoiIiIjUMBwRERERqWE4IiIiIlLDG89Su1RVWw8AOPd7uV7jlFdU4uQfgEfeLbg41uo11uXiCr2eT0RErYPhiNqlnP8GkXnbzxpgNDH+fvkXA4xzh4OUux0RkTnjT2lql6Ie7QgACPR0hJ3EusXjZN0oxdwdF7D0uUcQ7OOud10OUjECPBz0HoeIiIyH4YjaJTcHG7zYz0/vcaqrqwEAXT0cENLZRe/xiIjI/FncguykpCSEh4fDyckJnp6eGDNmDH777TdTl0VERERmwuLC0eHDhxEXF4cTJ04gLS0NdXV1iIqKQmVlpalLIyIiIjNgcYfV9u7dq/F4w4YN8PT0RGZmJoYNG2aiqoiIiMhcWFw4ult5+Z1Tvd3c3JrdrlQqoVQqVY/lcjkAoLa2FrW1+p3aTeavrr5e9ZnvN1H7UldXp/rM/bv90+U9tuhwJAgCEhISMGTIEISEhDTbJykpCYsWLWrSvm/fPtjb2xu7RDKxvAoAEONkRgaKLpi6GiIyBplMZuoSqBUoFAqt+4oEQRCMWItZi4uLw65du3D06FH4+Pg026e5mSNfX1+UlJTA2dm5tUolE8nM/QMvfvkLvnnlMYQGdDB1OURkQFVVVZDJZIiMjISdnZ2pyyEjk8vl8PDwQHl5+QN/f1vszNHMmTPx73//G+np6fcMRgAglUohlUqbtEskEkgkEmOWSGZAbG2t+sz3m6h9aTzMIhaLuX9bAF3eY4sLR4IgYObMmdixYwcOHTqEgIAAU5dEREREZsTiwlFcXBz++c9/4vvvv4eTkxMKCwsBAC4uLpxWJSIiIsu7zlFqairKy8sRERGBTp06qT42b95s6tKIiIjIDFjczJEFrz8nIiIiLVjczBERERHR/TAcEREREalhOCIiIotTX1+P9PR01Uf9f6+GTwS0cM3RP/7xD/zzn//EtWvXUFVVpbFNJBIhJyfHIMUREREZ2vbt2/H222/j6tWrAIAVK1agS5cuWL58OcaOHWva4sgs6ByOPvroIyQmJiI4OBi9e/du9gKJRERE5mj79u0YP348YmJisGHDBhQWFqJjx45YsWIFxo8fj61btzIgke63DwkMDMTTTz+Nzz77zFg1mTW5XA4XFxetLj9Obd/JnCKMX3cSW18NQ1igl6nLISI91NfXo1u3bujZsye+++47VFdXIy0tDSNHjoStrS3GjBmDc+fO4dKlS7D+79Xxqf3Q5fe3zmuOCgsL8dxzz7W4OCIiIlM4cuQIrl69ivnz58PKSvPXn5WVFRITE5Gbm4sjR46YqEIyFzqHo9DQUK4pIiKiNqegoAAAEBIS0uz2xvbGfmS5dF5ztGLFCrz88svo27cvQkNDjVETUatQKBTIzs6+b5/svFIoCy8j+5wNrMrdHzhmUFAQ7O3tDVUiERlQp06dAADnzp3DgAEDmmw/d+6cRj+yXDqvOerZsycKCwtRVlaGjh07wt1d8xeGSCTCmTNnDFqkOeGao/bj1KlTBg/4mZmZ6Nu3r0HHJCLD4Jojy6bL72+dZ47c3d3h4eHR4uKIzEVQUBAyMzPv2+fW7Ur8cCQDTw4Nh6uTg1ZjEpF5sra2xvLlyzF+/HiMGTMGs2bNQlVVFX766SesXLkSO3fuxNatWxmMSPeZI0vHmSPLolAoVH9Z8nAZUfuwfft2JCQk4Nq1a6o2Xueo/TPq2WpERERtnUgkMnUJZMZaFI7Kysrw7rvvYtCgQejRowcGDx6MhQsX4ubNm4auj4iIyGAaLwLZs2dPyGQy/Otf/4JMJkPPnj0xfvx4bN++3dQlkhnQ+bDa77//jsGDB+P69et45JFH4O3tjfz8fFy4cAH+/v44duwYvL29jVWvyfGwmmXhYTWi9oMLsi2bUQ+rzZ8/X7WA7fz580hLS8P58+fx008/oaqqCvPnz29x4URERMaifhFIQRA0bjwrCAIvAkkqOoejvXv3YsmSJQgPD9doDw8Px+LFi7Fnzx6DFUdERGQojRd3zMnJQbdu3RAdHY0VK1YgOjoa3bp1w5UrVzT6keXSORyVl5ejS5cuzW4LCAhAeXm5vjUREREZXOPFHV9++eVm1xy9/PLLGv3IcukcjgICArBr165mt+3ZswcBAQF6F0VERGRogwYNglgshpeXF7Zv345+/frBzs4O/fr1w/bt2+Hl5QWxWIxBgwaZulQyMZ0vAjl16lTMmzcPDQ0NmDx5Mjp16oSCggL84x//wGeffYYPP/zQGHUSERHp5fjx46irq0NxcTGee+45PP7447hy5QquXLmCgwcPori4GIIg4Pjx44iIiDB1uWRCOoejOXPmICcnB59//jmSk5NV7YIg4LXXXsPs2bMNWiAREZEhNK4levPNN5GcnIydO3eqtonFYrz55pv45JNPuOaIdA9HIpEIa9asQUJCAmQyGUpLS+Hu7o7HH38c3bt3N0aNREREemtcS/Tpp59i1KhRGDFiBHJychAYGIgDBw7g008/1ehHlsvibh+Snp6OZcuWITMzEwUFBdixYwfGjBmj9fN5nSPLwuscEbUfNTU1cHBwgLu7O27cuIGamhrV/m1jYwMfHx+UlpaisrISNjY2pi6XDMyoN55t6yorK9G7d29MnToV48aNM3U5RETUShrXHBUVFTW75qioqEjVj2uOLJtW4cja2ho//vgj+vXrBysrq/vek0YkEqGurs5gBRpadHQ0oqOjTV0GERG1ssa1RG+99Vaza47eeustrjkiAFqGowULFsDHx0f1b0u6YZ9SqYRSqVQ9lsvlAIDa2lrU1taaqixqJY1Bv66uju83URvXoUMHAHfWHNna2mr8IS+RSFRrjjp06MD9vR3S5T3VKhwtXLhQ9e/33ntP54LasqSkJCxatKhJ+759+7gGxYLIZDJTl0BEeqqpqYFIJIIgCAgODsYLL7wAPz8/XL9+Hd9++y0yMzMhEolw8+ZN7N6929TlkoEpFAqt++q85mjx4sWYPn16szeXLSgowLp167BgwQJdhzVbiYmJSEhIUD2Wy+Xw9fVFVFQUF2RbgKqqKshkMkRGRsLOzs7U5RCRHmQyGRrPQerYsSP69u2LkpIS9O3bF+np6QDuXJbGxcUFkZGRpiyVjKDxyI82dA5HixYtwlNPPdVsOMrPz8eiRYvaVTiSSqWQSqVN2iUSCSQSiQkqotbUOA0rFov5fhO1cY03lH3vvfewceNGjBw5UrUtICAACxcuxKJFi3DkyBFERUWZqkwyEl1+hut8+5D7nflfUVHBXyBERGTWhg4disuXL2PPnj1ISEjAnj17cOnSJQwZMsTUpZGZ0Grm6Ndff8Xp06dVj3fv3o3s7GyNPlVVVfj6668RGBho0AINraKiApcvX1Y9zs3NxenTp+Hm5gY/Pz8TVkZERMYUERGBJUuWYOHChTh8+DCGDRsGpVKJYcOGQSQSqdaX8jR+0ioc7dixQ/WfRiQSYfHixc32s7Ozw4YNGwxXnRGcPHlS41hy43qiyZMnY+PGjSaqioiIjC0iIgIdOnTA0aNH8eyzzyIhIQFVVVX46aefsGLFChw9ehSenp4MR6RdOHrttdcQExMDQRDQr18/bNiwASEhIRp9pFIpAgMDzX7RakRExH0PDRIRUftkbW2N1atXY9y4cThw4IDGdY4azz5OTU2FtbW1qUokM6FVOOrUqZPqXjMymQyhoaFwdHQ0amFERESGNnbsWGzbtg3x8fHIy8tTtXt4eGDlypUYO3asCasjc6Hzguzhw4czGBERUZt14sSJJlfBzs/Px4kTJ0xUEZmbFt1b7dKlS1izZg0uXLiAqqoqjW0ikQgHDhwwSHFERESGNHfuXCxbtgxeXl5YsGAB7O3toVAosHjxYixbtgwAsHTpUhNXSaYmEnRcgHPu3DkMGDAAnTt3xuXLl9GrVy+UlJTg999/h6+vLwIDA3Hw4EFj1WtyutzVl9o+hUKhums3r4hO1LbV1NTAwcEB7u7uuHHjBmpqalT7t42NDXx8fFBaWorKykrY2NiYulwyMF1+f+t8WG3+/Pl48skncf78eQiCgPXr1yMvLw//+c9/UF1djSVLlrS4cCIiImNJSUlBXV0dlixZArFY88CJWCzG4sWLUVdXh5SUFBNVSOZC53B06tQpTJ48GVZWd57a0NAAABg1ahRmz56NxMREw1ZIRERkADk5OQCAmJiYZrc3tjf2I8ulczi6efMm3NzcYGVlBYlEgps3b6q2hYWF4dSpUwYtkIiIyBAaL1Ksfgq/usZ2c7+YMRmfzuGoc+fOKCkpAQB069ZNdbM+4M6VtHkmGxERmaPY2FiIxWL89a9/RV1dnca2uro6LFiwAGKxGLGxsSaqkMyFzuFoyJAhOH78OADgpZdewocffojp06cjNjYWiYmJGD16tMGLJCIi0peNjQ1mzZqFoqIi+Pj44Msvv0RZWRm+/PJL+Pj4oKioCLNmzeJibNL9VP533nkH+fn5AID/+7//Q2FhIb7++muIRCK88MIL+Pjjjw1eJBERkSE0nqa/cuVKzJw5U9UuFosxZ84cnsZPAFpwKr+l46n8loWn8hO1TzU1NVi1ahUOHz6M4cOHIz4+njNG7Zwuv79bdBFIIiIic6ZQKJCdnX3fPmH9B6K0Royw/uE4d+7cA8cMCgriH0kWQqtwtGnTJp0G/fOf/9yiYoiIiAwhOzsboaGhWvXV9kBaZmYm+vbt2/KiqM3QKhxNmTJF6wFFIhHDERERmVRQUBAyMzPv2ycrrxRzdmRh2XPBCPZ112pMsgxahaPc3Fxj10FERGQw9vb2D5zlaXApgvTHGgSF9ELfQK9WqozaAq3Ckb+/v7HrICIiIjILOl/niIiIiKg90/lstccff/y+20UiEQ4cONDigoiIiB4kt6QSlcq6B3e8jysllarPtrbletfkIBUjwMNB73HI9HQORw0NDRCJRBptJSUl+O233+Dp6Ynu3bsbrDgiIqK75ZZUIvLjQwYbb+6OCwYbSzY7ggGpHdA5HB06dKjZ9osXL+LZZ5/FwoUL9a2JiIjonhpnjFZN6INuni2/n2d5RSX2HsnAU0PD4eKoX6C5XFyB+M2n9Z7NIvNgsItAdu/eHXPmzMHcuXPx008/GWpYIiKiZnXzdERIZ5cWP1+hkKCkA/CYrysv7kgaDLogu0uXLlpdZZSIiIjIXBk0HG3btg3e3t6GHNIoUlJSEBAQAFtbW4SGhuLIkSOmLomIiIjMhM6H1V555ZUmbUqlEr/++iuysrLM/o7GmzdvRnx8PFJSUjB48GCsWbMG0dHRyMrKgp+fn6nLIyIiIhPTORwdPHiwydlqtra26NKlCxITEzFx4kSDFWcMK1aswLRp0zB9+nQAwKpVq/DDDz8gNTUVSUlJJq6OiIiITE3ncHT16lUjlNE6ampqkJmZiXnz5mm0R0VF4fjx480+R6lUQqlUqh7L5XIAQG1tLWpra41XLJmFuro61We+30Tm4XaVEiKxHD9czMDlm82fZVatrEbBjev3Hae2tg5XcnLwW20JJJIH/zrs5OMHW6lts9vyblZBJJbzZ4UZ0+V9MdjZam1BSUkJ6uvr4eWleQ8dLy8vFBYWNvucpKQkLFq0qEn7vn37eHaDBZHJZKYugYj+68ciESSuP2Hj9QPA/fPPg3UEjlVq2ffW/TdLXEcg40d7XLPTsyYyCoVCoXXfFoUjuVyO5ORkyGQylJaWwt3dHZGRkXjjjTfg6urakiFb1d2HBQVBaNLWKDExEQkJCarHcrkcvr6+iIqKgrOzs1HrJNOrqqqCTCZDZGQk7Oz4E4/IHAyorEHA2c5wcRoPW7F1s310mTnqGhio98wRAHRy6oC+3rwXqblqPPKjDZ3DUW5uLiIjI3H9+nX4+/ujY8eOuHTpEvbv34/Vq1dDJpOha9euug7bKjw8PGBtbd1klqi4uLjJbFIjqVQKqVTapF0ikUAikRilTjIfjdOwYrGY7zeRmfByleD1oaEP7viALgqFAmlpaRg5ciSPBFgAXX6G63wq/1tvvYXq6mocO3YMubm5+PHHH5Gbm4ujR49CqVQiPj5e1yFbjY2NDUJDQ5GWlqbRnpaWhkGDBpmoKiIiIjInLTpb7ZNPPsHAgQM12gcNGoQlS5aYdTgCgISEBEyaNAlhYWEYOHAg1q5di+vXr2PGjBmmLo2IiIjMgM7hSCqVwtfXt9ltfn5+zR6CMicTJkxAaWkpFi9ejIKCAoSEhGD37t3w9+dxYiIiImrBYbVnn30WW7ZsaXbbli1bEBMTo3dRxhYbG4urV69CqVQiMzMTw4YNM3VJREREZCZ0njmaOHEipk2bhueffx4TJ05Ex44dUVhYiK+//honT57E+vXrcerUKVX/vn37GrRgUxMEAYBuq96p7VIoFFAoFJDL5aprHhFR+8D927I0/t5u/D1+PyJBm15qrKz+N9mkfvp74zCNbY2nx9fX1+syvNm7cePGPQ8rEhERkXnLy8uDj4/PffvoPHO0YcOGFhfUHnh7eyMvLw9OTk73vDYStR+///47goODkZWVhc6dO5u6HCIyIO7flkUQBNy+fRve3t4P7KtzOJo8eXKLimovrKysHpg4qf1onIZ1cnLiRT+J2hnu35bHxcVFq3563T7k4sWLKC0thYeHBx5++GF9hiIiIiIyCzqfrQbcOSvN398fjzzyCIYMGYKgoCD4+/tj69athq6PiIiIqFXpHI52796NF198ES4uLvjwww+xadMmJCUlwcXFBS+++CL27NljjDqJTMLZ2RnDhw/nlDtRO8T9m+5F57PVBg8eDGdnZ+zatUvjzDVBEBAdHY3bt2/j2LFjBi+UiIiIqDXoPHN0+vRpxMbGagQj4M4p/LGxsThz5ozBiiMiIiJqbTqHI2tra9TU1DS7rba2tkloIiIiImpLdD6sNmLECFRUVODQoUOws7NTtSuVSkRERMDR0bHJXe+JiIiI2gqdw9HRo0cxYsQIuLm54fnnn0fHjh1RUFCA7du3o7S0FAcPHsSgQYOMVS8RERGRUekcjgDg8OHDmDdvHn7++WcIggArKyv0798fSUlJvIkrERERtWktCkeNFAoFbt68iYceegj29vaGrIuIiIjIJLRePb1mzRr06NEDtra28PX1RWJiImxsbNC5c2cGIyIiImo3tApHf//73/HGG2+gqKgIvXv3Rm1tLZYuXYo5c+YYuz4iIiKiVqXVYbUBAwbAysoKe/bsgYuLC+rq6jB9+nRs3boVt27dglis1y3aiIiIiMyGVuHIyckJX331FcaOHatqu3r1Krp27YoLFy6gR48eRi2SiIiIqLVodVitsrISPj4+Gm2+vr4A7izKJiIiImovtF6QLRKJjFkHERERkVnQ6rCalZUVhgwZAldXV1WbIAjYtWsXhg4dChcXl/8NKBLh+++/N0qxRERERMamVTjq0qWL1jNHIpEIV65c0bswIiIiIlPQ6yKQRERERO2N1muOiIiIiCwBwxERERGRGoYjIiIiIjUMR0RERERqGI6IiIiI1DAcEREREalhOCIiIiJSI9am0+OPP671gCKRCAcOHGhxQURERESmpFU4amho0LhC9m+//YbCwkL4+/ujY8eOKCwsxLVr19CpUyf06NHDaMUSERERGZtW4ejQoUOqf+/duxevvvoqjh07hoEDB6rajx8/jgkTJmD27NkGL5KIiIioteh8+5CwsDC88cYbmDZtWpNtX3zxBZKTk/HLL78YrEBz09DQgPz8fDg5OWl9vzkiIiIyLUEQcPv2bXh7e8PK6v5LrrWaOVJ3/vx5+Pr6NrvNz88P2dnZug7ZpuTn59/z6yciIiLzlpeXBx8fn/v20TkceXl5Ydu2bYiKimqybcuWLfDy8tJ1yDYhOTkZycnJqKurA3Dnm+vs7GziqsjYFAoFZDIZIiMjYW9vb+pyiMiAuH9bFrlcDl9fXzg5OT2wr87hKDY2FvPmzUNZWRkmTpyoWpD99ddfY8eOHUhKSmpR0eYuLi4OcXFxkMvlcHFxgbOzM8ORBRCLxbC3t4ezszN/eBK1M9y/LZM2S2J0Dkdz586FQqHA0qVLsX37dgB3juPZ2trinXfewdy5c3WvlIiIiMhM6ByOAOC9997DrFmzcPz4cZSVlcHd3R0DBgyAq6urgcsjIiIial0tCkcA4OLigujoaEPWYtYa1xzV19ebuhQyEIVC8cATCG7drsTxszlwcnWDq5PDA8cMCgri9DwRURvXonD0xx9/YMWKFTh06BBKS0uxY8cOPProo1izZg369euHxx57zNB1mtzda46o7cvOzkZoaKhWfZdqOWZmZib69u3b8qKIiMjkdA5Hubm5GDx4MMrLy9G7d2/k5ORAqVQCAH799VecOHECGzZsMHihRIYWFBSEzMzM+/bJyivFnB1ZWPZcMIJ93bUak4iI2rYWLch2dXXFyZMn4enpCRsbG9W2IUOGYOHChQYtkMhY7O3tHzjL0+BSBOmPNQgK6YW+ge3zMhVERKRJ53B04MABpKamwtvbu8n6m06dOiE/P99gxZkTrjkiIiKyDPe/fnYzqqur4ebm1uy2ysrKB16Su62Ki4tDVlYWMjIyTF0KERERGZHOSaZHjx7Yv39/s9vS09MREhKid1FEREREpqLzYbVXX30VCQkJ8Pb2xksvvQQAqKmpwdatW5GSkoLPP//c4EUStURuSSUqlXV6jXGlpFL12da2XO+aHKRiBHg8+JIARERkOiJBEARdn/Taa6/hiy++gJWVFRoaGmBlZQVBEPDqq69i9erVxqjTbDSeyl9eXs7bh5ix3JJKRH58yNRlNEs2O4IBicgMKBQKpKWlYeTIkbw+mQXQ5fd3i65ztHbtWrzyyivYtWsXioqK4OHhgZiYGAwaNKhFBbcFXJDdtjTOGK2a0AfdPB1bPE55RSX2HsnAU0PD4eKoX6C5XFyB+M2n9Z7NIiIi49I5HF2/fh2dOnXCgAEDMGDAAI1tdXV1yM/Ph5+fn8EKNBe8CGTbIxLLYW37O6xsWx6O7FAN74fyYedYCCtbW73qsbatgEgs12sMIiIyPp3DUUBAAH788Uf069evybYzZ86gX79+nF0hsyBx/Qnzf/7AIGOl7E8xyDgS1xEAnjbIWEREZBw6h6P7LVGqr6+HSCTSqyAiQ6m91R/LR01EoB6H1aqrq/HTiZ/Qf0B/2Oo5c5RTXIE3v87RawwiIjK+Fq05ai4AKZVK7NmzBx4eHnoXRWQIQp0zApx7INi95YdBFQoF8sR5CHpI/xvKNlSXQ6j7Q68xiIjI+LQKR4sWLcLixYsB3AlGd681Ujd9+nTDVEakh6raO4d2z/2u3+n35RWVOPkH4JF3Cy6OtXqNdbm4Qq/nExFR69AqHPXr1w+xsbEQBAEpKSkYP348vLw07zMllUrRs2dPTJw40SiFEuki579BZN72swYYTYy/X/7FAOPc4SBt0YQtERG1Eq1+SkdHRyM6OhrAnVuELFiwAAEBAUYtjEgfUY92BAAEejrCTmLd4nGybpRi7o4LWPrcIwj2cde7Ll4EkojI/On8J+yGDRuMUYfZ43WO2hY3Bxu82E//S0pUV1cDALp6OCCkMy/hQNRe1NfXIz09Henp6ZBKpRg5ciSsrVv+hxS1LzrfW+2jjz7CzJkzm902c+ZMfPzxx3oXZY5441kiovZh+/bt6NatG6Kjo7FixQpER0ejW7du2L59u6lLIzOhczj66quv7nlz2d69e+Orr77SuygiIiJj2L59O8aPH4+ePXtCJpPhX//6F2QyGXr27Inx48czIBGAFoSja9euoXv37s1u69atG65evapvTURERAZXX1+Pt99+GzExMdi2bRuqq6uRkZGB6upqbNu2DTExMZg9ezaXT5Dua44kEgmKi4ub3VZUVMSLQFKboVAokJ2dfd8+2XmlUBZeRvY5G1iVP3hBdlCQ/tdDIiLjOHLkCK5evYrXX38d3bt3V/0xv2LFCnTp0gWvvfYa/vOf/+DIkSOIiIgwaa1kWjqHo7CwMKxbtw4TJkxosm3dunUICwszSGFExpadnY3Q0FCt+k7S8mhxZmYm+vbtq0dVRGQsBQUFAID58+dj1KhRePPNN3HlyhV07doVBw8exDvvvKPRjyyXzuFo9uzZGDVqFCIiIhAbG4vOnTvjxo0bWL16NdLT07F7925j1ElkcEFBQcjMzLxvn1u3K/HDkQw8OTQcrk4PPgU/KCjIUOURkYF5enoCuLOfnj17Fjt37lRt8/f3R48ePZCdna3qR5ZL53D01FNPYe3atXj77bfx4osvQiQSQRAEuLi4YN26dXjyySeNUSeRwdnb2z9wlkehUOD2rTIMCA/l4TKiduLChQsYNWoU4uPjkZOTg8DAQOzfvx+7du0ydWlkJlp0qd5p06bhxRdfxLFjx1BSUoIOHTpg0KBBcHBoGxe3y83NxSuvvIKioiJYW1vjxIkTbaZ2IiJqmcLCQtW/Dx48qBGG7Ozsmu1HlqnF9zFwcHBAVFSUIWtpNVOmTMGSJUswdOhQlJWVQSqVmrokIiIysj/+uPeNn9VPJrpfP7IMOp/KD9z5j5OYmIiBAweie/fuOH/+PABgzZo1+OUXw92DyhjOnz8PiUSCoUOHAgDc3NwgFvNeV0RE7Z27+50zTp2dndGhQweNbR4eHnB2dtboR5ZL53CUm5uL3r1749NPP4VIJEJOTg6USiUA4Ndff8Wnn35q8CLVpaenY/To0fD29oZIJMJ3333XpE9KSgoCAgJga2uL0NBQHDlyRLXt0qVLcHR0xDPPPIO+ffvigw8+MGq9RERkHkpLSwEAcrkcN27c0Nh248YNyOVyjX5kuXSeMpk7dy5cXV1x8uRJeHp6wsbGRrVtyJAhWLhwoUELvFtlZSV69+6NqVOnYty4cU22b968GfHx8UhJScHgwYOxZs0aREdHIysrC35+fqitrcWRI0dw+vRpeHp64qmnnkJ4eDhGjhzZ7OsplUpV+AOg2nlqa2tRW1trnC+SzEZdXZ3qM99vorbNxeV/90eUSqWoqqpq9rGLiwv393ZIl/dU53B04MABpKamwtvbu8lVRDt16oT8/Hxdh9RJdHQ0oqOj77l9xYoVmDZtGqZPnw4AWLVqFX744QekpqYiKSkJPj4+CA8Ph6+vLwDg6aefxunTp+8ZjpKSkrBo0aIm7fv27ePZSxZEJpOZugQi0lN6errq38HBwejbty+kUimUSiVOnTqlurRHeno63NzcTFUmGYlCodC6r87hqLq6+p7/aSorK2Fl1aJlTAZRU1ODzMxMzJs3T6M9KioKx48fBwCEh4ejqKgIN2/ehIuLC9LT0/H666/fc8zExEQkJCSoHsvlcvj6+iIqKkp1fJrar6qqKshkMkRGRmqczUJEbc+PP/4IAOjevTtKSkqwbt061bYuXbrg4YcfxqVLl+Dl5YWnn37aVGWSkTQe+dGGzuGoR48e2L9/f7MzLenp6fe8KW1rKCkpQX19Pby8vDTavby8VKdmisVifPDBBxg2bBgEQUBUVBRiYmLuOaZUKoVUKkVycjKSk5NVs2USiQQSicR4XwyZhcZpWLFYzPebqI1r3IcvXryImJgYvPXWWxpXyG68KCR/vrdPurynOoejV199FQkJCfD29sZLL70E4M6MzdatW5GSkoLPP/9c1yEN7u77uwmCoNH2oENzzYmLi0NcXBzkcrnGcWsiImobIiIisGTJEjzyyCNNrpDdpUsXBAUFITs7m/dVI93DUWxsLE6fPo1Zs2bh7bffBnBnIbYgCHj11VcxefJkgxepLQ8PD1hbWze5gFdxcXGT2SQiIrIsERER6NChAy5cuIDo6Gj06dNHNXNUU1ODPXv2wNPTk+GIWnYRyLVr1+KVV17Brl27UFRUBA8PD8TExGDQoEGGrk8nNjY2CA0NRVpaGp577jlVe1paGp599lm9xr77sBoREbUt1tbWWL16NcaNG4c9e/ao2s+ePav6d2pqKqytrU1RHpkRrcJR37598fe//x2PPvooNm3ahFGjRmHAgAEYMGCAsetroqKiApcvX1Y9zs3NxenTp+Hm5gY/Pz8kJCRg0qRJCAsLw8CBA7F27Vpcv34dM2bM0Ot1eViNiKjtO3HiBADAysoKDQ0NqvbGxydOnMDYsWNNVR6ZCZEgCMKDOonFYhw7dgz9+/eHtbU1fvzxR/Tr16816mvi0KFDiIyMbNI+efJkbNy4EcCdi0AuXboUBQUFCAkJwcqVKzFs2DC9Xld95ujixYsoLy/n2WoWQKFQIC0tDSNHjuSlG4jauJqaGjg4OMDd3R3Xrl2DTCZT7d+RkZHw9/dHaWkpKisrNa7hR+1D4+SGNr+/tTrv3tPTE6dOnQLQdHFza4uIiIAgCE0+GoMRcGdd1NWrV6FUKpGZmal3MALuzBxlZWUhIyND77GIiKj1paSkoK6uDkuWLIFUKsWwYcNUH1KpFIsXL0ZdXR1SUlJMXSqZmFbh6JlnnkFcXBwcHR0hEokQGRkJZ2fnZj94yImIiMxRTk4OANzz8i2N7Y39yHJptebos88+wyOPPIJz587hyy+/VK34tyRckE1E1LYFBgYCAHbu3Km6i4K6xlP7G/uR5dJqzZE6KysrnDhxwmRrjkxNl2OW1PZxzRFR+6G+5ujGjRuoqalR7d82Njbw8fHhmqN2zOBrjtzc3FRrjhYuXAgfHx/9qyQiImpFNjY2mDVrFoqKiuDj44Mvv/wSZWVl+PLLL+Hj44OioiLMmjWLwYi0O6x2+/Zt1NTUAAAWL16M6OhoeHt7G7UwIiIiQ1u6dCkAYOXKlZg5c6aqXSwWY86cOartZNm0Ckfe3t7Ys2cPunXrBkEQIJfLUVZWds/+7fFuxlxzRETUPixduhRLlizBqlWrcPjwYQwfPhzx8fGcMSIVrdYc/fWvf8UHH3yg9Sn87TlAcM2RZeGaI6L2i/u3ZdHl97dWM0dLlixBv379cPbsWbz77ruYNm0a1x0REZHZUigUyM7Ovm+fW7crcfxsDpxc3eDq5PDAMYOCghiiLITW91Z75pln8Mwzz+CLL77AX/7yF/Tu3bvZfn/88YfBiiMiImqJ7OxshIaGatVX21VGmZmZ6Nu3b8uLojZD5xvP5ubmNmkTBAF79uzB+vXrsWvXLlRXVxukOHPCNUdERG1HUFAQMjMz79snK68Uc3ZkYdlzwQj2dddqTLIMOocjdTk5Ofjyyy/x1VdfoaCgADY2Nu32hn288SwRUdthb2//wFmeBpciSH+sQVBIL/QN9Gqlyqgt0DkcVVdXY8uWLVi/fj2OHDmiutdaQkIC5s2bB3f3B6dvIiIiInOl1UUgASAjIwMzZsxAx44dMWXKFJw6dQpTpkzBzp07IQgCRo8ezWBEREREbZ5WM0e9evXC+fPnAQADBw7EK6+8ggkTJsDBwQHl5eVGLZCIiIioNWkVjs6dOweRSIRRo0bhww8/RHBwsLHrIiIiIjIJrQ6rrVq1Cr169cLOnTvRs2dPDBw4EF988QVu375t7PrMRnJyMoKDgxEeHm7qUoiIiMiItApHb775Jn755Rf8/PPPeO2115CdnY3XXnsNnTp1wmuvvQaRSKT11bPbqri4OGRlZSEjI8PUpRAREZERab0gGwDCwsKQmpqKgoICfPXVVwgLC8PWrVshCAKmTZuG5cuXo7S01Fi1EhERERldi65zZGtri0mTJmHSpEnIycnB+vXrsWnTJsyZMwfvvvsuFAqFoeskIiJSyS2pRKWyTq8xrpRUqj7b2up/cpGDVIwAjwffhoTMn1Y3ntVGQ0MDdu/ejS+//BLbt283xJBmiTeetSy8MSWR+cktqUTkx4dMXUazZLMjGJDMlMFvPKsNKysrxMTEICYmxlBDEhERNdE4Y7RqQh9083Rs8TjlFZXYeyQDTw0Nh4ujfoHmcnEF4jef1ns2i8yDwcIRERFRa+rm6YiQzi2/nZNCIUFJB+AxX1fODJMGnRZkWzKeyk9ERGQZGI60xFP5iYiILAPDEREREZEahiMiIiIiNQxHRERERGoYjoiIiIjUMBwRERERqWE4IiIiIlJjkeFILBajT58+6NOnD6ZPn27qcoiIiMiMWOQVsl1dXXH69GlTl0FERERmyCJnjoiIiIjupc2Fo/T0dIwePRre3t4QiUT47rvvmvRJSUlBQEAAbG1tERoaiiNHjmhsl8vlCA0NxZAhQ3D48OFWqpyIiIjagjYXjiorK9G7d298/vnnzW7fvHkz4uPj8c477+CXX37B0KFDER0djevXr6v6XL16FZmZmVi9ejX+/Oc/Qy6Xt1b5REREZOba3Jqj6OhoREdH33P7ihUrMG3aNNVC61WrVuGHH35AamoqkpKSAADe3t4AgJCQEAQHB+PixYsICwtrdjylUgmlUql63BikamtrUVtba5CvicxXXV2d6jPfbyLzYKj90pD7N39WmD9d3pc2F47up6amBpmZmZg3b55Ge1RUFI4fPw4AuHnzJuzt7SGVSnHjxg1kZWWha9eu9xwzKSkJixYtatK+b98+2NvbG/YLILMlk8lMXQIR/VdeBQCIcfToUVxz1H88Q+zfhq6JDE+hUGjdt12Fo5KSEtTX18PLy0uj3cvLC4WFhQCACxcu4PXXX4eVlRVEIhE++eQTuLm53XPMxMREJCQkqB7L5XL4+voiKioKzs7OxvlCyGxUVVVBJpMhMjISdnZ2pi6HiACcz5fj47MnMGTIEDzq3fKfw4bcvw1VExmPLkto2lU4aiQSiTQeC4Kgahs0aBDOnj2r9VhSqRRSqRTJyclITk5GfX09AEAikUAikRiuaDJLjdOwYrGY7zeRmRCLxarP+uyXhty/DVUTGY8u70ubW5B9Px4eHrC2tlbNEjUqLi5uMpukq7i4OGRlZSEjI0OvcYiIiMi8tatwZGNjg9DQUKSlpWm0p6WlYdCgQXqNnZycjODgYISHh+s1DhEREZm3NndYraKiApcvX1Y9zs3NxenTp+Hm5gY/Pz8kJCRg0qRJCAsLw8CBA7F27Vpcv34dM2bM0Ot14+LiEBcXB7lcDhcXF32/DCIiIjJTbS4cnTx5EpGRkarHjYulJ0+ejI0bN2LChAkoLS3F4sWLUVBQgJCQEOzevRv+/v6mKpmIiIjakDYXjiIiIiAIwn37xMbGIjY21qCve/eCbCIiImqf2tWaI2PigmwiIiLLwHBEREREpIbhSEs8W42IiMgyMBxpiYfViIiILAPDEREREZEahiMt8bAaERGRZWA40hIPqxEREVkGhiMiIiIiNQxHRERERGoYjrTENUdERESWgeFIS1xzREREZBkYjoiIiIjUMBwRERERqWE4IiIiIlLDcERERESkhuFISzxbjYiIyDIwHGmJZ6sRERFZBoYjIiIiIjUMR0RERERqGI6IiIiI1DAcEREREalhOCIiIiJSw3BEREREpIbhSEu8zhEREZFlYDjSEq9zREREZBkYjoiIiIjUMBwRERERqWE4IiIiIlLDcERERESkhuGIiIiISI3FhiOFQgF/f3/Mnj3b1KUQERGRGRGbugBTef/999G/f39Tl0FERC0gEsuRK/8NVraOLR6juroa+XX5yL6ZDdsqW73qyZVXQCSW6zUGmQ+LDEeXLl1CdnY2Ro8ejXPnzpm6HCIi0pHE9SfM//kDg4yVsj/FIONIXEcAeNogY5FptblwlJ6ejmXLliEzMxMFBQXYsWMHxowZo9EnJSUFy5YtQ0FBAR599FGsWrUKQ4cOVW2fPXs2li1bhuPHj7dy9UREZAi1t/pj+aiJCPTUb+bopxM/of+A/rC11W/mKKe4Am9+naPXGGQ+2lw4qqysRO/evTF16lSMGzeuyfbNmzcjPj4eKSkpGDx4MNasWYPo6GhkZWXBz88P33//Pbp3747u3bszHBERtVFCnTMCnHsg2N2lxWMoFArkifMQ9FAQ7O3t9aqnobocQt0feo1B5qPNhaPo6GhER0ffc/uKFSswbdo0TJ8+HQCwatUq/PDDD0hNTUVSUhJOnDiBb775Blu2bEFFRQVqa2vh7OyMBQsWNDueUqmEUqlUPZbL7xxTrq2tRW1trQG/MjJHdXV1qs98v4nMg6H2S0Pu3/xZYf50eV/aXDi6n5qaGmRmZmLevHka7VFRUapZoqSkJCQlJQEANm7ciHPnzt0zGDX2X7RoUZP2ffv26f2XBrUdMpnM1CUQ0X/lVQCAGEePHsW1lh9VUzHE/m3omsjwFAqF1n3bVTgqKSlBfX09vLy8NNq9vLxQWFjYojETExORkJCgeiyXy+Hr64uoqCg4OzvrVS+Zv6qqKshkMkRGRsLOzs7U5RARgPP5cnx89gSGDBmCR71b/nPYkPu3oWoi42k88qONdhWOGolEIo3HgiA0aQOAKVOmPHAsqVQKqVSK5ORkJCcno76+HgAgkUggkUgMUi+Zr8ZpWLFYzPebyEyIxWLVZ332S0Pu34aqiYxHl/elXV0E0sPDA9bW1k1miYqLi5vMJukqLi4OWVlZyMjI0GscIiIiMm/tKhzZ2NggNDQUaWlpGu1paWkYNGiQXmMnJycjODgY4eHheo1DRERE5q3NHVarqKjA5cuXVY9zc3Nx+vRpuLm5wc/PDwkJCZg0aRLCwsIwcOBArF27FtevX8eMGTP0et24uDjExcVBLpfDxaXlp44SERGReWtz4ejkyZOIjIxUPW5cLD158mRs3LgREyZMQGlpKRYvXoyCggKEhIRg9+7d8Pf3N1XJRERE1Ia0uXAUEREBQRDu2yc2NhaxsbEGfd27F2QTERFR+9Su1hwZExdkExERWQaGIyIiIiI1DEda4tlqREREloHhSEs8rEZERGQZGI6IiIiI1DAcaYmH1YiIiCwDw5GWeFiNiIjIMjAcEREREalhOCIiIiJSw3BEREREpIbhSEtckE1ERGQZGI60xAXZREREloHhiIiIiEgNwxERERGRGoYjIiIiIjUMR1rigmwiIiLLwHCkJS7IJiIisgwMR0RERERqGI6IiIiI1DAcEREREalhOCIiIiJSw3BEREREpIbhiIiIiEgNw5GWeJ0jIiIiy8BwpCVe54iIiMgyMBwRERERqWE4IiIiIlLDcERERESkhuGIiIiISA3DEREREZEahiMiIiIiNRYXjm7fvo3w8HD06dMHPXv2xLp160xdEhEREZkRsakLaG329vY4fPgw7O3toVAoEBISgrFjx8Ld3d3UpREREZEZsLiZI2tra9jb2wMAqqurUV9fD0EQTFwVERERmYs2F47S09MxevRoeHt7QyQS4bvvvmvSJyUlBQEBAbC1tUVoaCiOHDmisf3WrVvo3bs3fHx8MHfuXHh4eLRS9URERGTu2txhtcrKSvTu3RtTp07FuHHjmmzfvHkz4uPjkZKSgsGDB2PNmjWIjo5GVlYW/Pz8AACurq44c+YMioqKMHbsWIwfPx5eXl7Nvp5SqYRSqVQ9Li8vBwCUlZWhtrbWCF8hmZOqqiooFAqUlZWhqqrK1OUQEYBbN2+jQanArZs3UWpb1+JxDLl/G6omMp7bt28DgHZHi4Q2DICwY8cOjbZ+/foJM2bM0GgLCgoS5s2b1+wYM2bMEL799tt7vsbChQsFAPzgBz/4wQ9+8KMdfOTl5T0wX7S5maP7qampQWZmJubNm6fRHhUVhePHjwMAioqKYGdnB2dnZ8jlcqSnp+ONN96455iJiYlISEhQPW5oaEBZWRnc3d0hEomM84WQ2fj9998RHByMrKwsdO7c2dTlEJEBcf+2LIIg4Pbt2/D29n5g33YVjkpKSlBfX9/kEJmXlxcKCwsBADdu3MC0adMgCAIEQcBf/vIX9OrV655jSqVSSKVSjTZXV1eD107mSS6XAwCcnJzg7Oxs4mqIyJC4f1seFxcXrfq1q3DU6O4ZHUEQVG2hoaE4ffq0CaoiIiKitqDNna12Px4eHrC2tlbNEjUqLi6+54JrIiIiInXtKhzZ2NggNDQUaWlpGu1paWkYNGiQiaqitszZ2RnDhw/nlDtRO8T9m+6lzR1Wq6iowOXLl1WPc3Nzcfr0abi5ucHPzw8JCQmYNGkSwsLCMHDgQKxduxbXr1/HjBkzTFg1tVXOzs44dOiQqcsgIiPg/k33IvrvKfFtxqFDhxAZGdmkffLkydi4cSOAOxeBXLp0KQoKChASEoKVK1di2LBhrVwpERERtUVtLhwRERERGVO7WnNEREREpC+GIyIzcfToUYhEImzevNnUpRARWTSGI2o13bp1g0gkwlNPPaXRnpiYqPfVxqdPnw6RSKT6sLa2hq+vL9LT0/Uad9WqVRCJRLh27Zpe49ytW7du6NSpk0Zbv379cObMGTz77LMGfS2itqDx58PdHwcOHGh2f1FXVlaG4cOHw8bGBiKRCFZWVvDx8cH333+v0S8iIkJjbLFYjB49euDChQuqPne/vp2dHaZPn97kNWtqajBmzBjY2dmp+nbo0AGpqalN+j355JOQSqWq2hwdHfHKK6/o+R0jY2I4ola3b98+5ObmGmXsM2fO4JdffsGyZctQVFSEqKgo1NTUNOnX0NCA6upqo9TQUjY2NujVqxdsbW1NXQqRSXh4eODMmTMaH0OHDr3vc+RyObp06YJjx44hLi4OR48exfr169HQ0IAxY8bgiy++0OgvlUpx5swZZGRkYP78+bh06VKTE3amTZuGM2fO4MCBAxg6dCjWr1+P999/X7W9oaEBXbt2xb///W+88MILOHz4MDZv3gwPDw/ExsYiMTFR1XfEiBFIS0tDXFwcDh8+jG+++Qbjx49HaWmpAb5jZDQPvPsakYEEBgYKnp6ego2NjRAeHq5qnzdvnnD3f8XZs2cLUqlUACBYW1sLMTEx9x172rRpTcZ44403BADC7t27hZUrVwoAhCVLlgj29vYCAGH58uVCeXm50KtXL0EkEgkABCcnJ2Hjxo2CIAjCkSNHmtywMDAwUBAEQaivrxeio6MFsVgsABBsbW2FhIQEjdf/7rvvhA4dOqie6+zsLBw4cEAYPnx4k3FXrlyper1vvvlGNcaqVasEBwcHAYBgZWUl9O/fX6iqqlJtd3FxEXr16iWEh4cLIpFIsLKyEoYPH679m0JkJgIDA4WOHTvqvO2pp54SAAibN2/WaK+trRXs7e0FqVQq1NfXC4IgCMOHDxdsbW01+j3xxBMCAKG0tFQQhDs3NL/7RuUikUgIDQ1VPX7zzTcFAMJf//rXJvV4e3sLIpFIKCoqEgRBEGxtbYWIiIj7felkhjhzRK3KysoK8fHxyMjIQEZGRrN9/vGPf+Djjz/G4MGDsXfvXkyZMgU7d+5sdmr7fhwdHQFAY4ZoyZIlePfdd3HgwAGMHj0aw4YNw7lz5/Dee+/h+++/h6enJ6ZOnYqcnBz069cPc+bMAQDs3bsXZ86cwcGDBwEAQ4cOxYEDB/Dee+9BJpPhpZdewooVK/DJJ58AAE6ePInnnnsOEokEX331Ffbu3Ytx48ZBqVTim2++ga+vr8Zfyc19bSdPnkR8fDwCAgKwa9cuzJ07Fz///HOTw5K//vorHBwc8MMPP2DatGk4fPgwPvzwQ52+V0Rt1aFDh+Du7o4XXnhBo10sFmPKlClQKpXYsmXLPZ9vb28PAM3OJNfU1GDWrFkQBAFi8f8uC/jtt99CIpHgb3/7W5PnLFiwAIIgYOXKlQAABwcH/PLLLxqH7qgNMHU6I8uh/tefo6Oj8PDDDwuC0HTmyN/fX3Bzc9N4bnh4uCCVSu859t0zRz///LPg6OgoWFtbC7dv31bNHCUmJqr6FBUVCQCE2NhYVVtlZaVgZWUlPP3004IgCKrnXb16tcnz1qxZo1FD9+7dBX9/f0EQBGHgwIGCWCwWKisrH/i9aHT3zNGgQYMEGxsb1V+9giAIEyZMEAAItbW1giDcmTlydnbWGMfBwUHo37//Pb9XROYoMDCwyYxq586dVdvuNXMEQOjTp0+z2/75z38KAIT4+HhBEJrOHO3atUuQSCSCg4ODxnh3f4hEImH//v2qPjY2Nves58qVKwIAITo6WhAEQfj+++8FGxsb1QzzI488IixatEiH7wyZAmeOyCQ++OADXLp0Cf/+97+bbCsuLkavXr002p544gkolcpm1w+pa1wY2a9fP9TX12P9+vWqGSQAGDt2rOrfjYu1J06cqGqzt7eHl5cXLl26dM/X2LNnDwDg9ddf11i4efHiRZSUlAAALl++DD8/P9VfpS2Rm5sLPz8/WFn9bzdtrF991s3Pz0/jeU5OTigrK2vx6xKZipubG/bv36/62Llzp17jNTQ0ANC8GXl1dbVqnx01ahQcHByaLNz+05/+hP3792P58uWqBdkjRozQ6bUbX/OZZ55BZWUlNm7ciCeffBK3bt3CwoUL0aNHD72+NjKuNnf7EGofZs6cib/97W94/fXXMWXKlCbb7z57TdDyWqX79++HtbU1goOD4enp2WR7hw4dVP9u/MGpHj60ea26ujoAd85kCwkJ0djWGMQkEolW9T7Ivb4P6jWrT/c3avzaiNoSGxsbnUOIra0trl+/3uy248ePAwD69++v8Rq7d++GRCJBnz59mr2vmr+/P0aMGIERI0agd+/eeOKJJxATE4NnnnkGwJ0Qd68F1fv27QMAjT/wxGIxJk+ejMmTJwMA3njjDaxevRrp6em8e4OZ4swRmUxqaioKCwtx4MABjXZPT0+cOXNGo+3AgQOQSqWwsbG575gjRoxAREREs8HobhEREQDurHFqpFAoUFxcjO7duwMA7OzsAEBjxio6OhoAcOHCBdUP0MaPxh/C3bt3x/Xr16FQKJp9bYlE8sAAExAQgGvXrmn027FjBwAgNDT0gV8fkSUYNmwYysrK8O2332q019XVYePGjZBKpXj++edV7VZWVhgxYgSGDRum1Q1nR4wYgcDAQLz++uuqtvHjx6O2thbvvvtuk/6LFy+GSCTCrFmz7jnmkCFDAIBnrJkxzhyRyYwbNw5du3ZtsjD7/fffx8svv4wRI0Zg7ty52Lp1KzIyMjBt2jSDvr6npyf69OmD1atXo1OnTujVqxcSEhIgCAI+++wzAP8LIUuXLkVCQgIeeugheHt7Y/DgwVi7di3q6+vxpz/9CUVFRdixYwdcXFywbt06rF27Fj169MDDDz+MpKQkdOrUCdu2bcOzzz6L6Oho+Pr64tKlS9izZw+6du0KX1/fJvV98sknCA8PR58+ffDhhx/i6NGj+PbbbzF8+PBmZ4uI2rPq6uomF0j18/PD5s2b4ePjg4kTJ+LEiRN4/vnncfHiRSQmJkKhUGDdunVNZod19dFHH2H8+PHYtGkT/vznP+OTTz7Btm3b8P777yMvLw/Tp09HYWEh3n33XeTn52PevHmqP9B8fHwQFhaG0aNHIygoCBkZGXj33XchkUhUf2iRGTLtkieyJM0tqjx69Khq0aO6u0/lHzVq1H3Hbu5UfnXNLawWBEG4efPmPU/lb/T4448LVlZWTU7lHzt2rGqhpUgkEtzd3YVPP/1U9bwtW7YI7u7uGqfyy2QyQRAEISsrS3BzczPIqfx3L0bt2LGjqk6ituJBp/KjmYXSjf/P//jjD2HIkCGCRCJR7Y+dO3cWtm/frjFOc6fy3w3NnMovCILg5uYmdOjQQfW4qqpKiImJUf2cAiC4u7sLycnJGs+bNGmS4OrqqvoZY21tLXTr1k04evSoVt8XMg3eeJaIiIhIDdccEREREalhOCIiIiJSw3BEREREpIbhiIiIiEgNwxERERGRGoYjIiIiIjUMR0RERERqGI6IiIiI1DAcEREREalhOCIiIiJSw3BEREREpIbhiIiIiEjN/wP8KSwq/W8FKAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "df_impact = pd.DataFrame.from_dict(\n", + " data={\"No Protection\": impact.at_event, \"FLOPROS\": impact_flopros.at_event}\n", + ")\n", + "\n", + "fig, axes = plt.subplots(2, 1, sharex=True)\n", + "\n", + "for ax in axes:\n", + " df_impact.boxplot(ax=ax)\n", + "\n", + "axes[1].set_yscale(\"log\")\n", + "axes[1].set_ylim(bottom=1e3)\n", + "fig.supylabel(\"Affected Population\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Multidimensional Data\n", + "\n", + "We computed the risk of population being affected by 0.2 m of river flooding from the forecast issued on 2021-07-10 over the next 10 days.\n", + "We reduced the dimensionality of the data by simply taking the maximum discharge over the lead time of 10 days before computing the flood footprint.\n", + "We can get a clearer picture of flood timings by defining sub-selection of the lead time and computing footprints for each of these.\n", + "This is easy to do because we receive the downloaded discharge as xarray DataArray and can manipulate it however we like before putting it into the computation pipeline.\n", + "However, increasing the amount of flood footprints to compute will also increase the computational cost." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-02-29 15:00:44,793 - climada_petals.hazard.rf_glofas.cds_glofas_downloader - INFO - Skipping request for file '/home/roo/climada/data/cds-download/240229-150044-83e84eba8992a4a4d5f8af0a923e2458.grib' because it already exists\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'dis24' (time: 1, number: 50, step: 10, latitude: 95,\n",
+       "                           longitude: 114)>\n",
+       "dask.array<broadcast_to, shape=(1, 50, 10, 95, 114), dtype=float32, chunksize=(1, 50, 10, 95, 114), chunktype=numpy.ndarray>\n",
+       "Coordinates:\n",
+       "  * number      (number) int64 1 2 3 4 5 6 7 8 9 ... 42 43 44 45 46 47 48 49 50\n",
+       "  * time        (time) datetime64[ns] 2021-07-10\n",
+       "  * step        (step) timedelta64[ns] 1 days 2 days 3 days ... 9 days 10 days\n",
+       "    surface     float64 ...\n",
+       "  * latitude    (latitude) float64 55.15 55.05 54.95 54.85 ... 45.95 45.85 45.75\n",
+       "  * longitude   (longitude) float64 5.85 5.95 6.05 6.15 ... 16.95 17.05 17.15\n",
+       "    valid_time  (step) datetime64[ns] dask.array<chunksize=(10,), meta=np.ndarray>\n",
+       "Attributes: (12/30)\n",
+       "    GRIB_paramId:                             240024\n",
+       "    GRIB_dataType:                            pf\n",
+       "    GRIB_numberOfPoints:                      10830\n",
+       "    GRIB_typeOfLevel:                         surface\n",
+       "    GRIB_stepUnits:                           1\n",
+       "    GRIB_stepType:                            avg\n",
+       "    ...                                       ...\n",
+       "    GRIB_shortName:                           dis24\n",
+       "    GRIB_totalNumber:                         51\n",
+       "    GRIB_units:                               m**3 s**-1\n",
+       "    long_name:                                Mean discharge in the last 24 h...\n",
+       "    units:                                    m**3 s**-1\n",
+       "    standard_name:                            unknown
" + ], + "text/plain": [ + "\n", + "dask.array\n", + "Coordinates:\n", + " * number (number) int64 1 2 3 4 5 6 7 8 9 ... 42 43 44 45 46 47 48 49 50\n", + " * time (time) datetime64[ns] 2021-07-10\n", + " * step (step) timedelta64[ns] 1 days 2 days 3 days ... 9 days 10 days\n", + " surface float64 ...\n", + " * latitude (latitude) float64 55.15 55.05 54.95 54.85 ... 45.95 45.85 45.75\n", + " * longitude (longitude) float64 5.85 5.95 6.05 6.15 ... 16.95 17.05 17.15\n", + " valid_time (step) datetime64[ns] dask.array\n", + "Attributes: (12/30)\n", + " GRIB_paramId: 240024\n", + " GRIB_dataType: pf\n", + " GRIB_numberOfPoints: 10830\n", + " GRIB_typeOfLevel: surface\n", + " GRIB_stepUnits: 1\n", + " GRIB_stepType: avg\n", + " ... ...\n", + " GRIB_shortName: dis24\n", + " GRIB_totalNumber: 51\n", + " GRIB_units: m**3 s**-1\n", + " long_name: Mean discharge in the last 24 h...\n", + " units: m**3 s**-1\n", + " standard_name: unknown" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "discharge = rf.download_forecast(\n", + " countries=countries,\n", + " forecast_date=\"2021-07-10\",\n", + " system_version=\"operational\", # Version mislabeled\n", + ")\n", + "discharge\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'dis24' (Time Frame: 3, time: 1, number: 50, latitude: 95,\n",
+       "                           longitude: 114)>\n",
+       "dask.array<concatenate, shape=(3, 1, 50, 95, 114), dtype=float32, chunksize=(1, 1, 50, 95, 114), chunktype=numpy.ndarray>\n",
+       "Coordinates:\n",
+       "  * number      (number) int64 1 2 3 4 5 6 7 8 9 ... 42 43 44 45 46 47 48 49 50\n",
+       "  * time        (time) datetime64[ns] 2021-07-10\n",
+       "    surface     float64 ...\n",
+       "  * latitude    (latitude) float64 55.15 55.05 54.95 54.85 ... 45.95 45.85 45.75\n",
+       "  * longitude   (longitude) float64 5.85 5.95 6.05 6.15 ... 16.95 17.05 17.15\n",
+       "  * Time Frame  (Time Frame) object '1-2 Days' '3-5 Days' '6-10 Days'
" + ], + "text/plain": [ + "\n", + "dask.array\n", + "Coordinates:\n", + " * number (number) int64 1 2 3 4 5 6 7 8 9 ... 42 43 44 45 46 47 48 49 50\n", + " * time (time) datetime64[ns] 2021-07-10\n", + " surface float64 ...\n", + " * latitude (latitude) float64 55.15 55.05 54.95 54.85 ... 45.95 45.85 45.75\n", + " * longitude (longitude) float64 5.85 5.95 6.05 6.15 ... 16.95 17.05 17.15\n", + " * Time Frame (Time Frame) object '1-2 Days' '3-5 Days' '6-10 Days'" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import xarray as xr\n", + "\n", + "discharge_tf = xr.concat(\n", + " [\n", + " discharge.isel(step=slice(0, 2)).max(dim=\"step\"),\n", + " discharge.isel(step=slice(2, 5)).max(dim=\"step\"),\n", + " discharge.isel(step=slice(5, 10)).max(dim=\"step\"),\n", + " ],\n", + " dim=pd.Index([\"1-2 Days\", \"3-5 Days\", \"6-10 Days\"], name=\"Time Frame\"),\n", + ")\n", + "discharge_tf\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we have to clear the cached files to make sure the `RiverFloodInundation` object is not operating on the last computed results.\n", + "Then, we call `compute` again, this time with a custom data array inserted as discharge.\n", + "As additional arguments we add `reuse_regridder=True` to the parameters of `regrid`, which will instruct the object to save time by reusing the regridding matrix.\n", + "This is possible because all computations in this tutorial operate on the same grid." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/roo/miniforge3/envs/climada_flood/lib/python3.9/site-packages/dask/array/routines.py:325: PerformanceWarning: Increasing number of chunks by factor of 50\n", + " intermediate = blockwise(\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:              (number: 50, time: 1, Time Frame: 3, longitude: 1356,\n",
+       "                          latitude: 1128)\n",
+       "Coordinates:\n",
+       "  * number               (number) int64 1 2 3 4 5 6 7 8 ... 44 45 46 47 48 49 50\n",
+       "  * time                 (time) datetime64[ns] 2021-07-10\n",
+       "    surface              float64 ...\n",
+       "  * Time Frame           (Time Frame) <U9 '1-2 Days' '3-5 Days' '6-10 Days'\n",
+       "    step                 timedelta64[ns] ...\n",
+       "  * longitude            (longitude) float64 5.854 5.863 5.871 ... 17.14 17.15\n",
+       "  * latitude             (latitude) float64 55.15 55.14 55.13 ... 45.76 45.75\n",
+       "Data variables:\n",
+       "    flood_depth          (latitude, longitude, Time Frame, time, number) float32 dask.array<chunksize=(762, 162, 3, 1, 50), meta=np.ndarray>\n",
+       "    flood_depth_flopros  (latitude, longitude, Time Frame, time, number) float32 dask.array<chunksize=(762, 162, 3, 1, 50), meta=np.ndarray>
" + ], + "text/plain": [ + "\n", + "Dimensions: (number: 50, time: 1, Time Frame: 3, longitude: 1356,\n", + " latitude: 1128)\n", + "Coordinates:\n", + " * number (number) int64 1 2 3 4 5 6 7 8 ... 44 45 46 47 48 49 50\n", + " * time (time) datetime64[ns] 2021-07-10\n", + " surface float64 ...\n", + " * Time Frame (Time Frame) \n", + " flood_depth_flopros (latitude, longitude, Time Frame, time, number) float32 dask.array" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rf.clear_cache()\n", + "ds_flood_tf = rf.compute(discharge=discharge_tf, regrid_kws=dict(reuse_regridder=True))\n", + "save_file(ds_flood_tf, \"flood-2021-07-10-tf.nc\")\n", + "ds_flood_tf\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "ds_flood_tf.close()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since the dataset contains more dimensions than `latitude`, `longitude`, and the dimension specified as `event_dim` (here: `number`), the function `hazard_series_from_dataset` will return a pandas Series of Hazard objects, with the remaining dimensions as (possibly multidimensional) index." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-02-29 15:01:35,407 - climada.hazard.base - WARNING - Failed to read values of 'number' as dates. Hazard.event_name will be empty strings\n", + "2024-02-29 15:01:37,239 - climada.hazard.base - WARNING - Failed to read values of 'number' as dates. Hazard.event_name will be empty strings\n", + "2024-02-29 15:01:38,239 - climada.hazard.base - WARNING - Failed to read values of 'number' as dates. Hazard.event_name will be empty strings\n", + "2024-02-29 15:01:39,994 - climada.hazard.base - WARNING - Failed to read values of 'number' as dates. Hazard.event_name will be empty strings\n", + "2024-02-29 15:01:40,862 - climada.hazard.base - WARNING - Failed to read values of 'number' as dates. Hazard.event_name will be empty strings\n", + "2024-02-29 15:01:41,792 - climada.hazard.base - WARNING - Failed to read values of 'number' as dates. Hazard.event_name will be empty strings\n" + ] + }, + { + "data": { + "text/plain": [ + "time Time Frame\n", + "2021-07-10 1-2 Days 0) and 50 events.\n", + "2024-02-29 15:01:41,991 - climada.engine.impact_calc - INFO - Calculating impact for 2606616 assets (>0) and 50 events.\n", + "2024-02-29 15:01:42,161 - climada.engine.impact_calc - INFO - Calculating impact for 2606616 assets (>0) and 50 events.\n", + "2024-02-29 15:01:42,339 - climada.engine.impact_calc - INFO - Calculating impact for 2606616 assets (>0) and 50 events.\n", + "2024-02-29 15:01:42,434 - climada.engine.impact_calc - INFO - Calculating impact for 2606616 assets (>0) and 50 events.\n", + "2024-02-29 15:01:42,541 - climada.engine.impact_calc - INFO - Calculating impact for 2606616 assets (>0) and 50 events.\n" + ] + } + ], + "source": [ + "impact_series = pd.Series(\n", + " [\n", + " ImpactCalc(exposure, impf_set_affected, haz).impact(assign_centroids=False)\n", + " for _, haz in hazard_series.items()\n", + " ],\n", + " index=hazard_series.index,\n", + ")\n", + "impact_series_flopros = pd.Series(\n", + " [\n", + " ImpactCalc(exposure, impf_set_affected, haz).impact(assign_centroids=False)\n", + " for _, haz in hazard_series_flopros.items()\n", + " ],\n", + " index=hazard_series_flopros.index,\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Affected Population')" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_impacts = pd.concat(\n", + " [\n", + " pd.DataFrame.from_records(\n", + " {str_idx: imp.at_event for idx, imp in impact_series.items() for str_idx in idx if isinstance(str_idx, str)}\n", + " | {\"Protection\": \"No Protection\"}\n", + " ),\n", + " pd.DataFrame.from_records(\n", + " {str_idx: imp.at_event for idx, imp in impact_series_flopros.items() for str_idx in idx if isinstance(str_idx, str)}\n", + " | {\"Protection\": \"FLOPROS\"}\n", + " ),\n", + " ]\n", + ")\n", + "axes = df_impacts.boxplot(\n", + " column=[\"1-2 Days\", \"3-5 Days\", \"6-10 Days\"],\n", + " by=\"Protection\",\n", + " figsize=(9, 4.8),\n", + " layout=(1, 3),\n", + ")\n", + "axes[0].set_ylabel(\"Affected Population\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(100.0, 6561677.47926394)" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "axes = df_impacts.boxplot(\n", + " column=[\"1-2 Days\", \"3-5 Days\", \"6-10 Days\"],\n", + " by=\"Protection\",\n", + " figsize=(9, 4.8),\n", + " layout=(1, 3),\n", + ")\n", + "axes[0].set_ylabel(\"Affected Population\")\n", + "axes[0].set_yscale(\"log\")\n", + "axes[0].set_ylim(bottom=1e2)\n" + ] + } + ], + "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.9.18" + }, + "vscode": { + "interpreter": { + "hash": "24dfe080b6cf704a96271fca78d332670fc2f2ed0496af9ace9fdf9307202526" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/doc/tutorial/hazard.rst b/doc/tutorial/hazard.rst index b77a54710..310d7f343 100644 --- a/doc/tutorial/hazard.rst +++ b/doc/tutorial/hazard.rst @@ -12,3 +12,4 @@ Hazard Tutorials TC Rain TC Surge (Bathtub Model) Wildfire + climada_hazard_glofas_rf diff --git a/requirements/env_climada.yml b/requirements/env_climada.yml index d5bad7552..13342ccf4 100644 --- a/requirements/env_climada.yml +++ b/requirements/env_climada.yml @@ -3,6 +3,11 @@ channels: - conda-forge - nodefaults dependencies: + - cdsapi>=0.6 + - ruamel.yaml>=0.18 + - xesmf>=0.8 + - pymrio>=0.5 + - rioxarray>=0.13 - overpy>=0.7 - pymrio>=0.5 - scikit-image>=0.22 diff --git a/requirements/env_docs.yml b/requirements/env_docs.yml index 2aaf406a2..9c5f4d0bc 100644 --- a/requirements/env_docs.yml +++ b/requirements/env_docs.yml @@ -4,7 +4,11 @@ channels: - defaults dependencies: - climada - - scikit-image=0.21 + - cdsapi>=0.6 + - ruamel.yaml>=0.18 + - scikit-image>=0.21 + - xesmf>=0.8 + - pymrio>=0.5 - ipython - ipykernel - mccabe>=0.6 @@ -16,9 +20,8 @@ dependencies: - coverage>=4.5 - descartes - markdown - - myst-parser - - nbformat - - nbsphinx + - myst-parser + - myst-nb - pylint - readthedocs-sphinx-ext>=2.1 - sphinx-markdown-tables diff --git a/script/jenkins/branches/Jenkinsfile b/script/jenkins/branches/Jenkinsfile index 5303137bb..a1e468070 100644 --- a/script/jenkins/branches/Jenkinsfile +++ b/script/jenkins/branches/Jenkinsfile @@ -22,7 +22,12 @@ pipeline { steps { sh '''#!/bin/bash export PATH=$PATH:$CONDAPATH - source activate petals_env + source activate + + # first install xemsf, then activate environment, so .../envs/.../etc/conda/activate.d/esmpy.sh is executed + # otherwise the environment varibalbe ESMFMKFILE is not initialized + mamba install -n petals_env -c conda-forge -y xesmf ruamel.yaml cdsapi + conda activate petals_env rm -rf tests_xml/ rm -rf coverage/ make unit_test''' diff --git a/setup.py b/setup.py index c9b98b7e1..61a1fc341 100644 --- a/setup.py +++ b/setup.py @@ -38,8 +38,12 @@ install_requires=[ 'climada>=4.1', + 'cdsapi', + 'ruamel.yaml', 'scikit-image', + 'xesmf', "pymrio", + 'rioxarray', 'osm-flex>=1.1.1', ],