diff --git a/climada/conf/climada.conf b/climada/conf/climada.conf index 5fd35b1c42..d0573ff7a6 100644 --- a/climada/conf/climada.conf +++ b/climada/conf/climada.conf @@ -69,5 +69,6 @@ "cache_dir": "{local_data.system}/.apicache", "supported_hazard_types": ["river_flood", "tropical_cyclone", "storm_europe", "relative_cropyield", "wildfire", "earthquake", "flood", "hail", "aqueduct_coastal_flood"], "supported_exposures_types": ["litpop", "crop_production", "ssp_population", "crops"] - } + }, + "trajectory_caching": true } diff --git a/climada/test/conftest.py b/climada/test/conftest.py new file mode 100644 index 0000000000..5d43854a92 --- /dev/null +++ b/climada/test/conftest.py @@ -0,0 +1,307 @@ +""" +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 . +--- + +A set of reusable fixtures for testing purpose. + +The objective of this file is to provide minimalistic, understandable and consistent +default objects for unit and integration testing. + +Values are chosen such that: + - Exposure value of the first points is 0. (First location should always have 0 impacts) + - Category / Group id of all points is 1, except for third point, valued at 2000 (Impacts on that category are always a share of 2000) + - Hazard centroids are the exposure centroids shifted by `HAZARD_JITTER` on both lon and lat. + - There are 4 events, with frequencies == 0.03, 0.01, 0.006, 0.004, 0, + such that impacts for RP250, 100 and 50 and 20 are at_event, + (freq sorted cumulate to 1/250, 1/100, 1/50 and 1/20). + - Hazard intensity is: + * Event 1: zero everywhere (always no impact) + * Event 2: max intensity at first centroid (also always no impact (first centroid is 0)) + * Event 3: half max intensity at second centroid (impact == half second centroid) + * Event 4: quarter max intensity everywhere (impact == 1/4 total value) + * Event 5: max intensity everywhere (but zero frequency) + With max intensity set at 100 + - Impact function is the "identity function", x intensity is x% damages + - Impact values should be round. + +""" + +import geopandas as gpd +import numpy as np +import pytest +from scipy.sparse import csr_matrix +from shapely.geometry import Point + +from climada.entity import Exposures, ImpactFunc, ImpactFuncSet +from climada.hazard import Centroids, Hazard + +# --------------------------------------------------------------------------- +# Coordinate system and metadata +# --------------------------------------------------------------------------- +CRS_WGS84 = "EPSG:4326" + +# --------------------------------------------------------------------------- +# Exposure attributes +# --------------------------------------------------------------------------- +EXP_DESC = "Test exposure dataset" +EXPOSURE_REF_YEAR = 2020 +EXPOSURE_VALUE_UNIT = "USD" +VALUES = np.array([0, 1000, 2000, 3000, 4000, 5000]) +CATEGORIES = np.array([1, 1, 2, 1, 1, 3]) + +# Exposure coordinates +EXP_LONS = np.array([4, 4.25, 4.5, 4, 4.25, 4.5]) +EXP_LATS = np.array([45, 45, 45, 45.25, 45.25, 45.25]) + +# --------------------------------------------------------------------------- +# Hazard definition +# --------------------------------------------------------------------------- +HAZARD_TYPE = "TEST_HAZARD_TYPE" +HAZARD_UNIT = "TEST_HAZARD_UNIT" + +# Hazard centroid positions +HAZ_JITTER = 0.1 # To test centroid matching +HAZ_LONS = EXP_LONS + HAZ_JITTER +HAZ_LATS = EXP_LATS + HAZ_JITTER + +# Hazard events +EVENT_IDS = np.array([1, 2, 3, 4, 5]) +EVENT_NAMES = ["ev1", "ev2", "ev3", "ev4", "ev5"] +DATES = np.array([1, 2, 3, 4, 5]) + +# Frequency are choosen so that they cumulate nicely +# to correspond to 250, 100, 50, and 20y return periods (for impacts) +FREQUENCY = np.array([0.03, 0.01, 0.006, 0.004, 0.0]) +FREQUENCY_UNIT = "1/year" + +# Hazard maximum intensity +# 100 to match 0 to 100% idea +# also in line with linear 1:1 impact function +# for easy mental calculus +HAZARD_MAX_INTENSITY = 100 + +# --------------------------------------------------------------------------- +# Impact function +# --------------------------------------------------------------------------- +IMPF_ID = 1 +IMPF_NAME = "IMPF_1" + +# Sanity checks +for const in [VALUES, CATEGORIES, EXP_LONS, EXP_LATS]: + assert len(const) == len( + VALUES + ), "VALUES, REGIONS, CATEGORIES, EXP_LONS, EXP_LATS should all have the same lengths." + +for const in [EVENT_IDS, EVENT_NAMES, DATES, FREQUENCY]: + assert len(const) == len( + EVENT_IDS + ), "EVENT_IDS, EVENT_NAMES, DATES, FREQUENCY should all have the same lengths." + + +@pytest.fixture(scope="session") +def exposure_values(): + return VALUES.copy() + + +@pytest.fixture(scope="session") +def categories(): + return CATEGORIES.copy() + + +@pytest.fixture(scope="session") +def exposure_geometry(): + return [Point(lon, lat) for lon, lat in zip(EXP_LONS, EXP_LATS)] + + +@pytest.fixture(scope="session") +def exposures_factory( + exposure_values, + exposure_geometry, +): + def _make_exposures( + value_factor=1.0, + ref_year=EXPOSURE_REF_YEAR, + hazard_type=HAZARD_TYPE, + group_id=None, + ): + gdf = gpd.GeoDataFrame( + { + "value": exposure_values * value_factor, + f"impf_{hazard_type}": IMPF_ID, + "geometry": exposure_geometry, + }, + crs=CRS_WGS84, + ) + if group_id is not None: + gdf["group_id"] = group_id + + return Exposures( + data=gdf, + description=EXP_DESC, + ref_year=ref_year, + value_unit=EXPOSURE_VALUE_UNIT, + ) + + return _make_exposures + + +@pytest.fixture(scope="session") +def exposures(exposures_factory): + return exposures_factory() + + +@pytest.fixture(scope="session") +def hazard_frequency_factory(): + base = FREQUENCY + + def _make_frequency(scale=1.0): + return base * scale + + return _make_frequency + + +@pytest.fixture(scope="session") +def hazard_frequency(): + return hazard_frequency_factory() + + +@pytest.fixture(scope="session") +def hazard_intensity_factory(): + """ + Intensity matrix designed for analytical expectations: + - Event 1: zero + - Event 2: max intensity at first centroid + - Event 3: half max intensity at second centroid + - Event 4: quarter max intensity everywhere + """ + base = csr_matrix( + [ + [0, 0, 0, 0, 0, 0], + [HAZARD_MAX_INTENSITY, 0, 0, 0, 0, 0], + [0, HAZARD_MAX_INTENSITY / 2, 0, 0, 0, 0], + [ + HAZARD_MAX_INTENSITY / 4, + HAZARD_MAX_INTENSITY / 4, + HAZARD_MAX_INTENSITY / 4, + HAZARD_MAX_INTENSITY / 4, + HAZARD_MAX_INTENSITY / 4, + HAZARD_MAX_INTENSITY / 4, + ], + [ + HAZARD_MAX_INTENSITY, + HAZARD_MAX_INTENSITY, + HAZARD_MAX_INTENSITY, + HAZARD_MAX_INTENSITY, + HAZARD_MAX_INTENSITY, + HAZARD_MAX_INTENSITY, + ], + ] + ) + + def _make_intensity(scale=1.0): + return base * scale + + return _make_intensity + + +@pytest.fixture(scope="session") +def hazard_intensity_matrix(hazard_intensity_factory): + return hazard_intensity_factory() + + +@pytest.fixture(scope="session") +def centroids(): + return Centroids(lat=HAZ_LATS, lon=HAZ_LONS, crs=CRS_WGS84) + + +@pytest.fixture(scope="session") +def hazard_factory( + hazard_intensity_factory, + hazard_frequency_factory, + centroids, +): + def _make_hazard( + intensity_scale=1.0, + frequency_scale=1.0, + hazard_type=HAZARD_TYPE, + hazard_unit=HAZARD_UNIT, + ): + return Hazard( + haz_type=hazard_type, + units=hazard_unit, + centroids=centroids, + event_id=EVENT_IDS, + event_name=EVENT_NAMES, + date=DATES, + frequency=hazard_frequency_factory(scale=frequency_scale), + frequency_unit=FREQUENCY_UNIT, + intensity=hazard_intensity_factory(scale=intensity_scale), + ) + + return _make_hazard + + +@pytest.fixture(scope="session") +def hazard(hazard_factory): + return hazard_factory() + + +@pytest.fixture(scope="session") +def impf_factory(): + def _make_impf( + paa_scale=1.0, + max_intensity=HAZARD_MAX_INTENSITY, + hazard_type=HAZARD_TYPE, + hazard_unit=HAZARD_UNIT, + impf_id=IMPF_ID, + ): + return ImpactFunc( + haz_type=hazard_type, + intensity_unit=hazard_unit, + name=IMPF_NAME, + intensity=np.array([0, max_intensity / 2, max_intensity]), + mdd=np.array([0, 0.5, 1]), + paa=np.array([1, 1, 1]) * paa_scale, + id=impf_id, + ) + + return _make_impf + + +@pytest.fixture(scope="session") +def linear_impact_function(impf_factory): + return impf_factory() + + +@pytest.fixture(scope="session") +def impfset_factory(impf_factory): + def _make_impfset( + paa_scale=1.0, + max_intensity=HAZARD_MAX_INTENSITY, + hazard_type=HAZARD_TYPE, + hazard_unit=HAZARD_UNIT, + impf_id=IMPF_ID, + ): + return ImpactFuncSet( + [impf_factory(paa_scale, max_intensity, hazard_type, hazard_unit, impf_id)] + ) + + return _make_impfset + + +@pytest.fixture(scope="session") +def impfset(impfset_factory): + return impfset_factory() diff --git a/climada/test/test_trajectories.py b/climada/test/test_trajectories.py new file mode 100644 index 0000000000..6cbb5c6e29 --- /dev/null +++ b/climada/test/test_trajectories.py @@ -0,0 +1,828 @@ +""" +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 . +--- + +Test trajectories. + +""" + +import copy +from itertools import groupby +from unittest import TestCase + +import geopandas as gpd +import numpy as np +import pandas as pd +import pytest + +from climada.engine.impact_calc import ImpactCalc +from climada.entity.disc_rates.base import DiscRates +from climada.entity.exposures.base import Exposures +from climada.entity.impact_funcs.base import ImpactFunc +from climada.entity.impact_funcs.impact_func_set import ImpactFuncSet +from climada.hazard.base import Hazard +from climada.test.conftest import ( + CATEGORIES, + DATES, + EVENT_IDS, + EVENT_NAMES, + EXPOSURE_REF_YEAR, + FREQUENCY, + FREQUENCY_UNIT, + HAZARD_MAX_INTENSITY, + HAZARD_TYPE, + HAZARD_UNIT, + IMPF_ID, + IMPF_NAME, +) +from climada.trajectories import InterpolatedRiskTrajectory, StaticRiskTrajectory +from climada.trajectories.constants import ( + AAI_METRIC_NAME, + AAI_PER_GROUP_METRIC_NAME, + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + COORD_ID_COL_NAME, + DATE_COL_NAME, + EAI_METRIC_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + NO_MEASURE_VALUE, + PERIOD_COL_NAME, + RETURN_PERIOD_METRIC_NAME, + RISK_COL_NAME, + RP_VALUE_PREFIX, + UNIT_COL_NAME, +) +from climada.trajectories.snapshot import Snapshot +from climada.trajectories.trajectory import DEFAULT_RP + +EXPOSURE_FUTURE_YEAR = 2040 + +from climada.trajectories.snapshot import Snapshot + + +@pytest.fixture(scope="session") +def snapshot_factory( + exposures_factory, + hazard_factory, + impfset_factory, +): + """ + Factory for Snapshot objects. + + Allows controlled construction of baseline / future / counterfactual + scenarios by scaling exposure values, hazard intensity, and impact function. + """ + + def _make_snapshot( + *, + date=EXPOSURE_REF_YEAR, + exposure_value_factor=1.0, + hazard_intensity_factor=1.0, + hazard_frequency_factor=1.0, + paa_scale=1.0, + group_id=None, + ): + exposures = exposures_factory( + value_factor=exposure_value_factor, ref_year=date, group_id=group_id + ) + + hazard = hazard_factory( + intensity_scale=hazard_intensity_factor, + frequency_scale=hazard_frequency_factor, + ) + + impfset = impfset_factory( + paa_scale=paa_scale, + ) + + return Snapshot( + exposure=exposures, + hazard=hazard, + impfset=impfset, + date=date, + ) + + return _make_snapshot + + +@pytest.fixture(scope="session") +def snapshot_base(snapshot_factory): + return snapshot_factory() + + +@pytest.fixture(scope="session") +def snapshot_future(snapshot_factory): + return snapshot_factory( + date=2040, + exposure_value_factor=2.0, + hazard_intensity_factor=2.0, + ) + + +def expected_static_metrics_from_snapshots(snapshots): + rows = [] + group_p = False + for snap in snapshots: + imp = ImpactCalc(**snap.impact_calc_data).impact() + curve = imp.calc_freq_curve(DEFAULT_RP) + + rows.append( + [ + pd.Timestamp(str(snap.date)), + "All", + NO_MEASURE_VALUE, + "aai", + "USD", + imp.aai_agg, + ] + ) + + rows.extend( + [ + [ + pd.Timestamp(str(snap.date)), + "All", + NO_MEASURE_VALUE, + f"rp_{rp}", + "USD", + val, + ] + for rp, val in zip(curve.return_per, curve.impact) + ] + ) + if "group_id" in snap.exposure.gdf.columns: + group_p = True + aai_per_group = [ + [ + pd.Timestamp(str(snap.date)), + group, + NO_MEASURE_VALUE, + "aai", + "USD", + val, + ] + for group, val in zip(snap.exposure.gdf["group_id"], imp.eai_exp) + ] + group_df = pd.DataFrame( + aai_per_group, + columns=[ + DATE_COL_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + UNIT_COL_NAME, + RISK_COL_NAME, + ], + ) + + res = pd.DataFrame( + rows, + columns=[ + DATE_COL_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + UNIT_COL_NAME, + RISK_COL_NAME, + ], + ) + if group_p: + res = pd.concat([res, group_df]) + + return res.set_index( + [ + DATE_COL_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + UNIT_COL_NAME, + ] + ).sort_index() + + +def test_static_trajectory(snapshot_factory): + present_date = 2020 + future_date = 2040 + + hazard_intensity_factor = 2.0 + exposure_value_factor = 10.0 + + snapshot_base = snapshot_factory( + date=present_date, + ) + + snapshot_fut = snapshot_factory( + date=future_date, + hazard_intensity_factor=hazard_intensity_factor, + exposure_value_factor=exposure_value_factor, + ) + + expected_static_metrics = expected_static_metrics_from_snapshots( + [snapshot_base, snapshot_fut] + ) + static_traj = StaticRiskTrajectory([snapshot_base, snapshot_fut]) + result = ( + static_traj.per_date_risk_metrics() + .set_index( + [ + DATE_COL_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + UNIT_COL_NAME, + ] + ) + .sort_index() + ) + + # --- Assertion ---------------------------------------------------------- + pd.testing.assert_frame_equal( + result, + expected_static_metrics, + check_index_type=False, + check_categorical=False, + check_like=False, + ) + + +def test_static_trajectory_one_snap(snapshot_factory): + present_date = 2020 + + snapshot_base = snapshot_factory( + date=present_date, + ) + + expected_static_metrics = expected_static_metrics_from_snapshots([snapshot_base]) + static_traj = StaticRiskTrajectory([snapshot_base]) + result = ( + static_traj.per_date_risk_metrics() + .set_index( + [ + DATE_COL_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + UNIT_COL_NAME, + ] + ) + .sort_index() + ) + + # --- Assertion ---------------------------------------------------------- + pd.testing.assert_frame_equal( + result, + expected_static_metrics, + check_index_type=False, + check_categorical=False, + check_like=False, + ) + + +def test_static_trajectory_with_group(snapshot_factory): + present_date = 2020 + future_date = 2040 + + hazard_intensity_factor = 2.0 + exposure_value_factor = 10.0 + + snapshot_base = snapshot_factory(date=present_date, group_id=CATEGORIES) + + snapshot_fut = snapshot_factory( + date=future_date, + hazard_intensity_factor=hazard_intensity_factor, + exposure_value_factor=exposure_value_factor, + group_id=CATEGORIES, + ) + + expected_static_metrics = expected_static_metrics_from_snapshots( + [snapshot_base, snapshot_fut] + ) + static_traj = StaticRiskTrajectory([snapshot_base, snapshot_fut]) + result = ( + static_traj.per_date_risk_metrics() + .set_index( + [ + DATE_COL_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + UNIT_COL_NAME, + ] + ) + .sort_index() + ) + + # --- Assertion ---------------------------------------------------------- + pd.testing.assert_frame_equal( + result, + expected_static_metrics, + check_index_type=False, + check_categorical=False, + check_like=False, + ) + + +class TestStaticTrajectory: + + def test_static_trajectory_with_group(self): + exp0 = reusable_minimal_exposures(group_id=CATEGORIES) + exp1 = reusable_minimal_exposures( + group_id=CATEGORIES, increase_value_factor=self.EXP_INCREASE_VALUE_FACTOR + ) + snap0 = Snapshot( + exposure=exp0, + hazard=reusable_minimal_hazard(), + impfset=reusable_minimal_impfset(), + date=self.PRESENT_DATE, + ) + snap1 = Snapshot( + exposure=exp1, + hazard=reusable_minimal_hazard( + intensity_factor=self.HAZ_INCREASE_INTENSITY_FACTOR + ), + impfset=reusable_minimal_impfset(), + date=self.FUTURE_DATE, + ) + + expected_static_metrics = pd.concat( + [ + self.expected_static_metrics, + pd.DataFrame.from_dict( + # fmt: off + { + "index": [8, 9, 10, 11], + "columns": [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME, UNIT_COL_NAME, RISK_COL_NAME,], + "data": [ + [pd.Timestamp(str(self.PRESENT_DATE)), 1, NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", self.expected_base_imp.eai_exp[CATEGORIES == 1].sum(),], + [pd.Timestamp(str(self.PRESENT_DATE)), 2, NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", self.expected_base_imp.eai_exp[CATEGORIES == 2].sum(),], + [pd.Timestamp(str(self.FUTURE_DATE)), 1, NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", self.expected_future_imp.eai_exp[CATEGORIES == 1].sum(),], + [pd.Timestamp(str(self.FUTURE_DATE)), 2, NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", self.expected_future_imp.eai_exp[CATEGORIES == 2].sum(),], + ], + "index_names": [None], + "column_names": [None], + }, + # fmt: on + orient="tight", + ), + ] + ) + + static_traj = StaticRiskTrajectory([snap0, snap1]) + pd.testing.assert_frame_equal( + static_traj.per_date_risk_metrics(), + expected_static_metrics, + check_dtype=False, + check_categorical=False, + ) + + def test_static_trajectory_change_rp(self): + static_traj = StaticRiskTrajectory( + [self.base_snapshot, self.future_snapshot], return_periods=[10, 60, 1000] + ) + expected = pd.DataFrame.from_dict( + # fmt: off + { + "index": [0, 1, 2, 3, 4, 5, 6, 7], + "columns": [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME, UNIT_COL_NAME, RISK_COL_NAME,], + "data": [ + [pd.Timestamp(str(self.PRESENT_DATE)),"All", NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", self.expected_base_imp.aai_agg,], + [pd.Timestamp(str(self.FUTURE_DATE)), "All", NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", self.expected_future_imp.aai_agg,], + [pd.Timestamp(str(self.PRESENT_DATE)),"All", NO_MEASURE_VALUE, "rp_10", "USD", 0.0,], + [pd.Timestamp(str(self.FUTURE_DATE)), "All", NO_MEASURE_VALUE, "rp_10", "USD", 0.0,], + [pd.Timestamp(str(self.PRESENT_DATE)),"All", NO_MEASURE_VALUE, "rp_60", "USD", 700.0,], + [pd.Timestamp(str(self.FUTURE_DATE)), "All", NO_MEASURE_VALUE, "rp_60", "USD", 14000.0,], + [pd.Timestamp(str(self.PRESENT_DATE)),"All", NO_MEASURE_VALUE, "rp_1000", "USD", 1500.0,], + [pd.Timestamp(str(self.FUTURE_DATE)), "All", NO_MEASURE_VALUE, "rp_1000", "USD", 30000.0,], + ], + "index_names": [None], + "column_names": [None], + }, + # fmt: on + orient="tight", + ) + pd.testing.assert_frame_equal( + static_traj.per_date_risk_metrics(), + expected, + check_dtype=False, + check_categorical=False, + ) + + # Also check change to other return period + static_traj.return_periods = DEFAULT_RP + pd.testing.assert_frame_equal( + static_traj.per_date_risk_metrics(), + self.expected_static_metrics, + check_dtype=False, + check_categorical=False, + ) + + def test_static_trajectory_risk_disc_rate(self): + risk_disc_rate = DiscRates( + years=np.array(range(self.PRESENT_DATE, 2041)), rates=np.ones(21) * 0.01 + ) + static_traj = StaticRiskTrajectory( + [self.base_snapshot, self.future_snapshot], risk_disc_rates=risk_disc_rate + ) + expected = pd.DataFrame.from_dict( + # fmt: off + { + "index": [0, 1, 2, 3, 4, 5, 6, 7], + "columns": [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME, UNIT_COL_NAME, RISK_COL_NAME,], + "data": [ + [pd.Timestamp(str(self.PRESENT_DATE)),"All", NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", self.expected_base_imp.aai_agg,], + [pd.Timestamp(str(self.FUTURE_DATE)), "All", NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", self.expected_future_imp.aai_agg * ((1 / (1 + 0.01)) ** 20),], + [pd.Timestamp(str(self.PRESENT_DATE)),"All", NO_MEASURE_VALUE, f"rp_{DEFAULT_RP[0]}", "USD", self.expected_base_return_period_impacts[DEFAULT_RP[0]],], + [pd.Timestamp(str(self.FUTURE_DATE)), "All", NO_MEASURE_VALUE, f"rp_{DEFAULT_RP[0]}", "USD", self.expected_future_return_period_impacts[DEFAULT_RP[0]] * ((1 / (1 + 0.01)) ** 20),], + [pd.Timestamp(str(self.PRESENT_DATE)),"All", NO_MEASURE_VALUE, f"rp_{DEFAULT_RP[1]}", "USD", self.expected_base_return_period_impacts[DEFAULT_RP[1]],], + [pd.Timestamp(str(self.FUTURE_DATE)), "All", NO_MEASURE_VALUE, f"rp_{DEFAULT_RP[1]}", "USD", self.expected_future_return_period_impacts[DEFAULT_RP[1]] * ((1 / (1 + 0.01)) ** 20),], + [pd.Timestamp(str(self.PRESENT_DATE)),"All", NO_MEASURE_VALUE, f"rp_{DEFAULT_RP[2]}", "USD", self.expected_base_return_period_impacts[DEFAULT_RP[2]],], + [pd.Timestamp(str(self.FUTURE_DATE)), "All", NO_MEASURE_VALUE, f"rp_{DEFAULT_RP[2]}", "USD", self.expected_future_return_period_impacts[DEFAULT_RP[2]] * ((1 / (1 + 0.01)) ** 20),], + ], + "index_names": [None], + "column_names": [None], + }, + # fmt: on + orient="tight", + ) + pd.testing.assert_frame_equal( + static_traj.per_date_risk_metrics(), + expected, + check_dtype=False, + check_categorical=False, + ) + + # Also check change to other return period + static_traj.risk_disc_rates = None + pd.testing.assert_frame_equal( + static_traj.per_date_risk_metrics(), + self.expected_static_metrics, + check_dtype=False, + check_categorical=False, + ) + + +class TestInterpolatedTrajectory(TestCase): + PRESENT_DATE = 2020 + HAZ_INCREASE_INTENSITY_FACTOR = 2 + EXP_INCREASE_VALUE_FACTOR = 6 + FUTURE_DATE = 2022 + + def setUp(self) -> None: + self.base_snapshot = reusable_snapshot(date=self.PRESENT_DATE) + self.future_snapshot = reusable_snapshot( + hazard_intensity_increase_factor=self.HAZ_INCREASE_INTENSITY_FACTOR, + exposure_value_increase_factor=self.EXP_INCREASE_VALUE_FACTOR, + date=self.FUTURE_DATE, + ) + + self.expected_base_imp = ImpactCalc( + **self.base_snapshot.impact_calc_data + ).impact() + self.expected_future_imp = ImpactCalc( + **self.future_snapshot.impact_calc_data + ).impact() + # self.group_vector = self.base_snapshot.exposure.gdf[GROUP_ID_COL_NAME] + self.expected_base_return_period_impacts = { + rp: imp + for rp, imp in zip( + self.expected_base_imp.calc_freq_curve(DEFAULT_RP).return_per, + self.expected_base_imp.calc_freq_curve(DEFAULT_RP).impact, + ) + } + self.expected_future_return_period_impacts = { + rp: imp + for rp, imp in zip( + self.expected_future_imp.calc_freq_curve(DEFAULT_RP).return_per, + self.expected_future_imp.calc_freq_curve(DEFAULT_RP).impact, + ) + } + + # fmt: off + self.expected_interp_metrics = pd.DataFrame.from_dict( + {'index': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + 'columns': [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME, UNIT_COL_NAME, RISK_COL_NAME], + 'data': [[ pd.Period(2020), 'All',NO_MEASURE_VALUE, 'aai', 'USD', 20.0], + [ pd.Period(2021), 'All',NO_MEASURE_VALUE, 'aai', 'USD', 105.0], # This should indeed not be 240+20 / 2 (because we interpolate each contributor separately) + [ pd.Period(2022), 'All',NO_MEASURE_VALUE, 'aai', 'USD', 240.0], + [ pd.Period(2020), 'All',NO_MEASURE_VALUE, 'rp_20', 'USD', 0.0], + [ pd.Period(2021), 'All',NO_MEASURE_VALUE, 'rp_20', 'USD', 0.0], + [ pd.Period(2022), 'All',NO_MEASURE_VALUE, 'rp_20', 'USD', 0.0], + [ pd.Period(2020), 'All',NO_MEASURE_VALUE, 'rp_50', 'USD', 500.0], + [ pd.Period(2021), 'All',NO_MEASURE_VALUE, 'rp_50', 'USD', 2625.0], + [ pd.Period(2022), 'All',NO_MEASURE_VALUE, 'rp_50', 'USD', 6000.0], + [ pd.Period(2020), 'All',NO_MEASURE_VALUE, 'rp_100', 'USD', 1500.0], + [ pd.Period(2021), 'All',NO_MEASURE_VALUE, 'rp_100', 'USD', 7875.0], + [ pd.Period(2022), 'All',NO_MEASURE_VALUE, 'rp_100', 'USD', 18000.0]], + 'index_names': [None], + 'column_names': [None]}, + orient="tight" + ) + + self.expected_period_metrics = pd.DataFrame.from_dict( + {'index': [0, 1, 2, 3], + 'columns': [PERIOD_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME, UNIT_COL_NAME, RISK_COL_NAME], + 'data': [[f"{self.PRESENT_DATE} to {self.FUTURE_DATE}", 'All', NO_MEASURE_VALUE, 'aai', 'USD', 365.0/3], + [f"{self.PRESENT_DATE} to {self.FUTURE_DATE}", 'All', NO_MEASURE_VALUE, 'rp_100', 'USD', 27375/3], + [f"{self.PRESENT_DATE} to {self.FUTURE_DATE}", 'All', NO_MEASURE_VALUE, 'rp_20', 'USD', 0.0], + [f"{self.PRESENT_DATE} to {self.FUTURE_DATE}", 'All', NO_MEASURE_VALUE, 'rp_50', 'USD', 9125.0/3]], + 'index_names': [None], + 'column_names': [None]}, + orient="tight" + ) + # fmt: on + + def test_interp_trajectory(self): + interp_traj = InterpolatedRiskTrajectory( + [self.base_snapshot, self.future_snapshot] + ) + pd.testing.assert_frame_equal( + interp_traj.per_date_risk_metrics(), + self.expected_interp_metrics, + check_dtype=False, + check_categorical=False, + ) + pd.testing.assert_frame_equal( + interp_traj.per_period_risk_metrics(), + self.expected_period_metrics, + check_dtype=False, + check_categorical=False, + ) + + def test_interp_trajectory_with_group(self): + exp0 = reusable_minimal_exposures(group_id=CATEGORIES) + exp1 = reusable_minimal_exposures( + group_id=CATEGORIES, increase_value_factor=self.EXP_INCREASE_VALUE_FACTOR + ) + snap0 = Snapshot( + exposure=exp0, + hazard=reusable_minimal_hazard(), + impfset=reusable_minimal_impfset(), + date=self.PRESENT_DATE, + ) + snap1 = Snapshot( + exposure=exp1, + hazard=reusable_minimal_hazard( + intensity_factor=self.HAZ_INCREASE_INTENSITY_FACTOR + ), + impfset=reusable_minimal_impfset(), + date=self.FUTURE_DATE, + ) + + expected_interp_metrics = pd.concat( + [ + self.expected_interp_metrics, + # fmt: off + pd.DataFrame.from_dict( + { + "index": [0, 1, 2, 3, 4, 5], + "columns": [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME, UNIT_COL_NAME, RISK_COL_NAME,], + "data": [ + [pd.Period("2020"), 1, NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", 15.0,], + [pd.Period("2020"), 2, NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", 5.0,], + [pd.Period("2021"), 1, NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", 78.75,], + [pd.Period("2021"), 2, NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", 26.25,], + [pd.Period("2022"), 1, NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", 180.0,], + [pd.Period("2022"), 2, NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", 60.0,], + ], + "index_names": [None], + "column_names": [None], + }, + orient="tight", + ), + # fmt: on + ], + ignore_index=True, + ) + + interp_traj = InterpolatedRiskTrajectory([snap0, snap1]) + pd.testing.assert_frame_equal( + interp_traj.per_date_risk_metrics(), + expected_interp_metrics, + check_dtype=False, + check_categorical=False, + ) + + def test_interp_trajectory_change_rp(self): + interp_traj = InterpolatedRiskTrajectory( + [self.base_snapshot, self.future_snapshot], return_periods=[10, 60, 1000] + ) + expected = pd.DataFrame.from_dict( + # fmt: off + { + "index": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + "columns": [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME, UNIT_COL_NAME, RISK_COL_NAME,], + "data": [ + [pd.Period(2020), "All", NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", 20.0,], + [pd.Period(2021), "All", NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", 105.0,], + [pd.Period(2022), "All", NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", 240.0,], + [pd.Period(2020), "All", NO_MEASURE_VALUE, "rp_10", "USD", 0.0], + [pd.Period(2021), "All", NO_MEASURE_VALUE, "rp_10", "USD", 0.0], + [pd.Period(2022), "All", NO_MEASURE_VALUE, "rp_10", "USD", 0.0], + [pd.Period(2020), "All", NO_MEASURE_VALUE, "rp_60", "USD", 700.0], + [pd.Period(2021), "All", NO_MEASURE_VALUE, "rp_60", "USD", 3675.0], + [pd.Period(2022), "All", NO_MEASURE_VALUE, "rp_60", "USD", 8400.0], + [pd.Period(2020), "All", NO_MEASURE_VALUE, "rp_1000", "USD", 1500.0,], + [pd.Period(2021), "All", NO_MEASURE_VALUE, "rp_1000", "USD", 7875.0,], + [pd.Period(2022), "All", NO_MEASURE_VALUE, "rp_1000", "USD", 18000.0,], + ], + "index_names": [None], + "column_names": [None], + }, + # fmt: on + orient="tight", + ) + pd.testing.assert_frame_equal( + interp_traj.per_date_risk_metrics(), + expected, + check_dtype=False, + check_categorical=False, + ) + + # Also check change to other return period + interp_traj.return_periods = DEFAULT_RP + pd.testing.assert_frame_equal( + interp_traj.per_date_risk_metrics(), + self.expected_interp_metrics, + check_dtype=False, + check_categorical=False, + ) + + def test_interp_trajectory_risk_disc_rate(self): + risk_disc_rate = DiscRates( + years=np.array(range(2020, 2023)), rates=np.ones(3) * 0.05 + ) # Easy check for year 2021 -> 105.0 * 1/(1+0.05) == 100. + interp_traj = InterpolatedRiskTrajectory( + [self.base_snapshot, self.future_snapshot], risk_disc_rates=risk_disc_rate + ) + expected = pd.DataFrame.from_dict( + # fmt: off + { + "index": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + "columns": [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME, UNIT_COL_NAME, RISK_COL_NAME,], + "data": [ + [pd.Period(2020), "All", NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", 20.0,], + [pd.Period(2021), "All", NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", 100.0,], + [pd.Period(2022), "All", NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", 217.68707482993196,], + [pd.Period(2020), "All", NO_MEASURE_VALUE, "rp_20", "USD", 0.0], + [pd.Period(2021), "All", NO_MEASURE_VALUE, "rp_20", "USD", 0.0], + [pd.Period(2022), "All", NO_MEASURE_VALUE, "rp_20", "USD", 0.0], + [pd.Period(2020), "All", NO_MEASURE_VALUE, "rp_50", "USD", 500.0], + [pd.Period(2021), "All", NO_MEASURE_VALUE, "rp_50", "USD", 2500.0], + [pd.Period(2022), "All", NO_MEASURE_VALUE, "rp_50", "USD", 5442.176870748299,], + [pd.Period(2020), "All", NO_MEASURE_VALUE, "rp_100", "USD", 1500.0], + [pd.Period(2021), "All", NO_MEASURE_VALUE, "rp_100", "USD", 7500.0], + [pd.Period(2022), "All", NO_MEASURE_VALUE, "rp_100", "USD", 16326.530612244896,], + ], + "index_names": [None], + "column_names": [None], + }, + # fmt: on + orient="tight", + ) + pd.testing.assert_frame_equal( + interp_traj.per_date_risk_metrics(), + expected, + check_dtype=False, + check_categorical=False, + ) + + # Also check change to other return period + interp_traj.risk_disc_rates = None + pd.testing.assert_frame_equal( + interp_traj.per_date_risk_metrics(), + self.expected_interp_metrics, + check_dtype=False, + check_categorical=False, + ) + + def test_interp_trajectory_risk_contributions(self): + interp_traj = InterpolatedRiskTrajectory( + [self.base_snapshot, self.future_snapshot] + ) + expected = pd.DataFrame.from_dict( + # fmt: off + {'index': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], + 'columns': [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME, UNIT_COL_NAME, RISK_COL_NAME,], + 'data': [ + [pd.Period(str(2020)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_BASE_RISK_NAME, 'USD', 20.0], + [pd.Period(str(2021)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_BASE_RISK_NAME, 'USD', 20.0], + [pd.Period(str(2022)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_BASE_RISK_NAME, 'USD', 20.0], + [pd.Period(str(2020)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_EXPOSURE_NAME, 'USD', 0.0], + [pd.Period(str(2021)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_EXPOSURE_NAME, 'USD', 50.0], + [pd.Period(str(2022)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_EXPOSURE_NAME, 'USD', 100.0], + [pd.Period(str(2020)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_HAZARD_NAME, 'USD', 0.0], + [pd.Period(str(2021)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_HAZARD_NAME, 'USD', 10.0], + [pd.Period(str(2022)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_HAZARD_NAME, 'USD', 20.0], + [pd.Period(str(2020)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_VULNERABILITY_NAME, 'USD', 0.0], + [pd.Period(str(2021)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_VULNERABILITY_NAME, 'USD', 0.0], + [pd.Period(str(2022)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_VULNERABILITY_NAME, 'USD', 0.0], + [pd.Period(str(2020)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_INTERACTION_TERM_NAME, 'USD', 0.0], + [pd.Period(str(2021)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_INTERACTION_TERM_NAME, 'USD', 25.0], + [pd.Period(str(2022)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_INTERACTION_TERM_NAME, 'USD', 100.0]], + 'index_names': [None], + 'column_names': [None]}, + # fmt: on + orient="tight", + ) + pd.testing.assert_frame_equal( + interp_traj.risk_contributions_metrics(), + expected, + check_dtype=False, + check_categorical=False, + ) + + # With changing vulnerability + hazard = reusable_minimal_hazard() + impfset1 = ImpactFuncSet( + [ + ImpactFunc( + haz_type=hazard.haz_type, + intensity_unit=hazard.units, + name="linear", + intensity=np.array([0, 100 / 2, 100]), + mdd=np.array([0, 0.5, 1]), + paa=np.array([1, 1, 1]), + id=1, + ), + ] + ) + impfset2 = ImpactFuncSet( + [ + ImpactFunc( + haz_type=hazard.haz_type, + intensity_unit=hazard.units, + name="linear-half-paa", + intensity=np.array([0, 100 / 2, 100]), + mdd=np.array([0, 0.5, 1]), + paa=np.array([0.5, 0.5, 0.5]), + id=1, + ) + ] + ) + base_snapshot = Snapshot( + exposure=reusable_minimal_exposures(), + hazard=hazard, + impfset=impfset1, + date=2020, + ) + future_snapshot = Snapshot( + exposure=reusable_minimal_exposures( + increase_value_factor=self.EXP_INCREASE_VALUE_FACTOR, + ), + hazard=reusable_minimal_hazard( + intensity_factor=self.HAZ_INCREASE_INTENSITY_FACTOR + ), + impfset=impfset2, + date=2022, + ) + + interp_traj = InterpolatedRiskTrajectory([base_snapshot, future_snapshot]) + expected = pd.DataFrame.from_dict( + # fmt: off + {'index': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], + 'columns': [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME, UNIT_COL_NAME, RISK_COL_NAME,], + 'data': [ + [pd.Period(str(2020)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_BASE_RISK_NAME, 'USD', 20.0], + [pd.Period(str(2021)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_BASE_RISK_NAME, 'USD', 20.0], + [pd.Period(str(2022)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_BASE_RISK_NAME, 'USD', 20.0], + [pd.Period(str(2020)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_EXPOSURE_NAME, 'USD', 0.0], + [pd.Period(str(2021)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_EXPOSURE_NAME, 'USD', 50.0], + [pd.Period(str(2022)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_EXPOSURE_NAME, 'USD', 100.0], + [pd.Period(str(2020)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_HAZARD_NAME, 'USD', 0.0], + [pd.Period(str(2021)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_HAZARD_NAME, 'USD', 10.0], + [pd.Period(str(2022)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_HAZARD_NAME, 'USD', 20.0], + [pd.Period(str(2020)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_VULNERABILITY_NAME, 'USD', 0.0], + [pd.Period(str(2021)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_VULNERABILITY_NAME, 'USD', -5.0], + [pd.Period(str(2022)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_VULNERABILITY_NAME, 'USD', -10.0], + [pd.Period(str(2020)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_INTERACTION_TERM_NAME, 'USD', 0.0], + [pd.Period(str(2021)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_INTERACTION_TERM_NAME, 'USD', 3.75], + [pd.Period(str(2022)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_INTERACTION_TERM_NAME, 'USD', -10.0]], + 'index_names': [None], + 'column_names': [None]}, + # fmt: on + orient="tight", + ) + pd.testing.assert_frame_equal( + interp_traj.risk_contributions_metrics(), + expected, + check_dtype=False, + check_categorical=False, + ) diff --git a/climada/trajectories/__init__.py b/climada/trajectories/__init__.py new file mode 100644 index 0000000000..2cfaa41d7d --- /dev/null +++ b/climada/trajectories/__init__.py @@ -0,0 +1,35 @@ +""" +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 . + +--- + +This module implements risk trajectory objects which enable computation and +possibly interpolation of risk metric over multiple dates. + +""" + +from .interpolated_trajectory import InterpolatedRiskTrajectory +from .interpolation import AllLinearStrategy, ExponentialExposureStrategy +from .snapshot import Snapshot +from .static_trajectory import StaticRiskTrajectory + +__all__ = [ + "AllLinearStrategy", + "ExponentialExposureStrategy", + "Snapshot", + "StaticRiskTrajectory", + "InterpolatedRiskTrajectory", +] diff --git a/climada/trajectories/calc_risk_metrics.py b/climada/trajectories/calc_risk_metrics.py new file mode 100644 index 0000000000..ed618bf62e --- /dev/null +++ b/climada/trajectories/calc_risk_metrics.py @@ -0,0 +1,1176 @@ +""" +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 . + +--- + +This modules implements the CalcRiskMetrics classes. + +CalcRiskMetrics are used to compute risk metrics (and intermediate requirements) +in between two snapshots. + +As these computations are not always required and can become "heavy", a so called "lazy" +approach is used: computation is only done when required, and then stored. + +""" + +import datetime +import itertools +import logging +import re + +import numpy as np +import pandas as pd +from scipy.sparse import csr_matrix + +from climada.engine.impact import Impact, ImpactFreqCurve +from climada.engine.impact_calc import ImpactCalc +from climada.entity.measures.base import Measure +from climada.trajectories.constants import ( + AAI_METRIC_NAME, + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + CONTRIBUTION_TOTAL_RISK_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + COORD_ID_COL_NAME, + DATE_COL_NAME, + DEFAULT_PERIOD_INDEX_NAME, + EAI_METRIC_NAME, + GROUP_COL_NAME, + GROUP_ID_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + NO_MEASURE_VALUE, + RISK_COL_NAME, + RP_VALUE_PREFIX, + UNIT_COL_NAME, +) +from climada.trajectories.impact_calc_strat import ImpactComputationStrategy +from climada.trajectories.interpolation import ( + InterpolationStrategyBase, + linear_interp_arrays, +) +from climada.trajectories.snapshot import Snapshot +from climada.util.config import CONFIG + +LOGGER = logging.getLogger(__name__) + +__all__ = [ + "CalcRiskMetricsPoints", + "CalcRiskMetricsPeriod", + "calc_per_date_aais", + "calc_per_date_eais", + "calc_per_date_rps", + "calc_freq_curve", +] + + +def lazy_property(method): + """ + Decorator that converts a method into a cached, lazy-evaluated property. + + This decorator is intended for properties that require heavy computation. + The result is calculated only when first accessed and then stored in a + corresponding private attribute (e.g., a method named `impact` will + cache its result in `_impact`). + + Parameters + ---------- + method : callable + The method to be converted into a lazy property. + + Returns + ------- + property + A property object that handles the caching logic and attribute access. + + Notes + ----- + The caching behavior can be globally toggled via the + `_CACHE_SETTINGS["ENABLE_LAZY_CACHE"]` flag. If disabled, the + method will be re-evaluated on every access. + + """ + attr_name = f"_{method.__name__}" + + @property + def _lazy(self): + if not CONFIG.trajectory_caching.bool(): + return method(self) + + if getattr(self, attr_name) is None: + setattr(self, attr_name, method(self)) + + return getattr(self, attr_name) + + return _lazy + + +class CalcRiskMetricsPoints: + """This class handles the computation of impacts for a list of `Snapshot`. + + Note that most attribute like members are properties with their own docstring. + + Attributes + ---------- + + impact_computation_strategy: ImpactComputationStrategy, optional + The method used to calculate the impact from the (Haz,Exp,Vul) of the snapshots. + Defaults to ImpactCalc + measure: Measure, optional + The measure applied to snapshots. Defaults to None. + + Notes + ----- + + This class is intended for internal computation. + """ + + def __init__( + self, + snapshots: list[Snapshot], + impact_computation_strategy: ImpactComputationStrategy, + ) -> None: + """Initialize a new `CalcRiskMetricsPoints` + + This initializes and instantiate a new `CalcRiskMetricsPoints` object. + No computation is done at initialisation and only done "just in time". + + Parameters + ---------- + snapshots : List[Snapshot] + The `Snapshot` list to compute risk for. + impact_computation_strategy: ImpactComputationStrategy, optional + The method used to calculate the impact from the (Haz,Exp,Vul) of the two snapshots. + Defaults to ImpactCalc + + """ + + self._reset_impact_data() + self.snapshots = snapshots + self.impact_computation_strategy = impact_computation_strategy + self._date_idx = pd.DatetimeIndex( + [snap.date for snap in self.snapshots], name=DATE_COL_NAME + ) + self.measure = None + try: + self._group_id = np.unique( + np.concatenate( + [ + snap.exposure.gdf[GROUP_ID_COL_NAME] + for snap in self.snapshots + if GROUP_ID_COL_NAME in snap.exposure.gdf.columns + ] + ) + ) + except ValueError as exc: + error_message = str(exc).lower() + if "need at least one array to concatenate" in error_message: + self._group_id = np.array([]) + + def _reset_impact_data(self): + """Util method that resets computed data, for instance when + changing the computation strategy. + + """ + self._impacts = None + self._eai_gdf = None + self._per_date_eai = None + self._per_date_aai = None + + @property + def impact_computation_strategy(self) -> ImpactComputationStrategy: + """The method used to calculate the impact from the (Haz,Exp,Vul) + of the snapshots. + + """ + return self._impact_computation_strategy + + @impact_computation_strategy.setter + def impact_computation_strategy(self, value, /): + if not isinstance(value, ImpactComputationStrategy): + raise ValueError("Not an impact computation strategy") + + self._impact_computation_strategy = value + self._reset_impact_data() + + @lazy_property + def impacts(self) -> list[Impact]: + """Return Impact object for the different snapshots.""" + + return [ + self.impact_computation_strategy.compute_impacts( + snap.exposure, snap.hazard, snap.impfset + ) + for snap in self.snapshots + ] + + @lazy_property + def per_date_eai(self) -> np.ndarray: + """Expected annual impacts per snapshot.""" + + return np.array([imp.eai_exp for imp in self.impacts]) + + @lazy_property + def per_date_aai(self) -> np.ndarray: + """Average annual impacts per snapshot.""" + + return np.array([imp.aai_agg for imp in self.impacts]) + + def calc_eai_gdf(self) -> pd.DataFrame: + """Convenience function returning a DataFrame + from `per_date_eai`. + + This can easily be merged with the GeoDataFrame of + the exposure object of one of the `Snapshot`. + + Notes + ----- + + The DataFrame from the first snapshot of the list is used + as a basis (notably for `value` and `group_id`). + + """ + + metric_df = pd.DataFrame(self.per_date_eai, index=self._date_idx) + metric_df = metric_df.reset_index().melt( + id_vars=DATE_COL_NAME, var_name=COORD_ID_COL_NAME, value_name=RISK_COL_NAME + ) + eai_gdf = pd.concat( + [ + snap.exposure.gdf.reset_index(names=[COORD_ID_COL_NAME]).assign( + date=pd.to_datetime(snap.date) + ) + for snap in self.snapshots + ] + ) + if GROUP_ID_COL_NAME in eai_gdf.columns: + eai_gdf = eai_gdf[[DATE_COL_NAME, COORD_ID_COL_NAME, GROUP_ID_COL_NAME]] + else: + eai_gdf[[GROUP_ID_COL_NAME]] = pd.NA + eai_gdf = eai_gdf[[DATE_COL_NAME, COORD_ID_COL_NAME, GROUP_ID_COL_NAME]] + + eai_gdf = eai_gdf.merge(metric_df, on=[DATE_COL_NAME, COORD_ID_COL_NAME]) + eai_gdf = eai_gdf.rename(columns={GROUP_ID_COL_NAME: GROUP_COL_NAME}) + eai_gdf[GROUP_COL_NAME] = pd.Categorical( + eai_gdf[GROUP_COL_NAME], categories=self._group_id + ) + eai_gdf[METRIC_COL_NAME] = EAI_METRIC_NAME + eai_gdf[MEASURE_COL_NAME] = ( + self.measure.name if self.measure else NO_MEASURE_VALUE + ) + eai_gdf[UNIT_COL_NAME] = self.snapshots[0].exposure.value_unit + return eai_gdf + + def calc_aai_metric(self) -> pd.DataFrame: + """Compute a DataFrame of the AAI for each snapshot.""" + + aai_df = pd.DataFrame( + index=self._date_idx, columns=[RISK_COL_NAME], data=self.per_date_aai + ) + aai_df[GROUP_COL_NAME] = pd.Categorical( + [pd.NA] * len(aai_df), categories=self._group_id + ) + aai_df[METRIC_COL_NAME] = AAI_METRIC_NAME + aai_df[MEASURE_COL_NAME] = ( + self.measure.name if self.measure else NO_MEASURE_VALUE + ) + aai_df[UNIT_COL_NAME] = self.snapshots[0].exposure.value_unit + aai_df.reset_index(inplace=True) + return aai_df + + def calc_aai_per_group_metric(self) -> pd.DataFrame | None: + """Compute a DataFrame of the AAI distinguised per group id + in the exposures, for each snapshot. + + """ + + if len(self._group_id) < 1: + LOGGER.warning( + "No group id defined in the Exposures object. Per group aai will be empty." + ) + return None + + eai_pres_groups = self.calc_eai_gdf()[ + [DATE_COL_NAME, COORD_ID_COL_NAME, GROUP_COL_NAME, RISK_COL_NAME] + ].copy() + aai_per_group_df = eai_pres_groups.groupby( + [DATE_COL_NAME, GROUP_COL_NAME], as_index=False, observed=True + )[RISK_COL_NAME].sum() + aai_per_group_df[METRIC_COL_NAME] = AAI_METRIC_NAME + aai_per_group_df[MEASURE_COL_NAME] = ( + self.measure.name if self.measure else NO_MEASURE_VALUE + ) + aai_per_group_df[UNIT_COL_NAME] = self.snapshots[0].exposure.value_unit + return aai_per_group_df + + def calc_return_periods_metric(self, return_periods: list[int]) -> pd.DataFrame: + """Compute a DataFrame of the estimated impacts for a list + of return periods, for each snapshot. + + Parameters + ---------- + + return_periods : list of int + The return periods to estimate impacts for. + """ + + per_date_rp = np.array( + [ + imp.calc_freq_curve(return_per=return_periods).impact + for imp in self.impacts + ] + ) + rp_df = pd.DataFrame( + index=self._date_idx, columns=return_periods, data=per_date_rp + ).melt(value_name=RISK_COL_NAME, var_name="rp", ignore_index=False) + rp_df.reset_index(inplace=True) + rp_df[GROUP_COL_NAME] = pd.Categorical( + [pd.NA] * len(rp_df), categories=self._group_id + ) + rp_df[METRIC_COL_NAME] = RP_VALUE_PREFIX + "_" + rp_df["rp"].astype(str) + rp_df = rp_df.drop("rp", axis=1) + rp_df[MEASURE_COL_NAME] = ( + self.measure.name if self.measure else NO_MEASURE_VALUE + ) + rp_df[UNIT_COL_NAME] = self.snapshots[0].exposure.value_unit + return rp_df + + def apply_measure(self, measure: Measure) -> "CalcRiskMetricsPoints": + """Creates a new `CalcRiskMetricsPoints` object with a measure. + + The given measure is applied to both snapshot of the risk period. + + Parameters + ---------- + measure : Measure + The measure to apply. + + Returns + ------- + + CalcRiskPeriod + The risk period with given measure applied. + + """ + snapshots = [snap.apply_measure(measure) for snap in self.snapshots] + risk_period = CalcRiskMetricsPoints( + snapshots, + self.impact_computation_strategy, + ) + + risk_period.measure = measure + return risk_period + + +class CalcRiskMetricsPeriod: + """This class handles the computation of impacts for a risk period. + + This object handles the interpolations and computations of risk metrics in + between two given snapshots, along a DateTimeIndex build from either a + `time_resolution` (which must be a valid "freq" string to build a DateTimeIndex) + and defaults to "Y" (start of the year) or `time_points` integer argument, in which case + the DateTimeIndex will have that many periods. + + Note that most attribute like members are properties with their own docstring. + + Attributes + ---------- + + date_idx: pd.PeriodIndex + The date index for the different interpolated points between the two snapshots + interpolation_strategy: InterpolationStrategy, optional + The approach used to interpolate impact matrices in between the two snapshots, + linear by default. + impact_computation_strategy: ImpactComputationStrategy, optional + The method used to calculate the impact from the (Haz,Exp,Vul) of the two snapshots. + Defaults to ImpactCalc + measure: Measure, optional + The measure to apply to both snapshots. Defaults to None. + + Notes + ----- + + This class is intended for internal computation. + """ + + def __init__( + self, + snapshot_start: Snapshot, + snapshot_end: Snapshot, + *, + time_resolution: str, + interpolation_strategy: InterpolationStrategyBase, + impact_computation_strategy: ImpactComputationStrategy, + ): + """Initialize a new `CalcRiskMetricsPeriod` + + This initializes and instantiate a new `CalcRiskMetricsPeriod` object. + No computation is done at initialisation and only done "just in time". + + Parameters + ---------- + snapshot0 : Snapshot + The `Snapshot` at the start of the risk period. + snapshot1 : Snapshot + The `Snapshot` at the end of the risk period. + time_resolution : str, optional + One of pandas date offset strings or corresponding objects. + See :func:`pandas.period_range`. + time_points : int, optional + Number of periods to generate for the PeriodIndex. + interpolation_strategy: InterpolationStrategy, optional + The approach used to interpolate impact matrices in + between the two snapshots, linear by default. + impact_computation_strategy: ImpactComputationStrategy, optional + The method used to calculate the impact from the (Haz,Exp,Vul) + of the two snapshots. + Defaults to ImpactCalc + + """ + + LOGGER.debug("Instantiating new CalcRiskPeriod.") + self._snapshot_start = snapshot_start + self._snapshot_end = snapshot_end + self.date_idx = self._set_date_idx( + date1=snapshot_start.date, + date2=snapshot_end.date, + freq=time_resolution, + name=DEFAULT_PERIOD_INDEX_NAME, + ) + self.interpolation_strategy = interpolation_strategy + self.impact_computation_strategy = impact_computation_strategy + self.measure = None # Only possible to set with apply_measure() + + self._group_id_E0 = ( + np.array(self.snapshot_start.exposure.gdf[GROUP_ID_COL_NAME].values) + if GROUP_ID_COL_NAME in self.snapshot_start.exposure.gdf.columns + else np.array([]) + ) + self._group_id_E1 = ( + np.array(self.snapshot_end.exposure.gdf[GROUP_ID_COL_NAME].values) + if GROUP_ID_COL_NAME in self.snapshot_end.exposure.gdf.columns + else np.array([]) + ) + self._groups_id = np.unique( + np.concatenate([self._group_id_E0, self._group_id_E1]) + ) + + def _reset_impact_data(self): + """Util method that resets computed data, for instance when changing the time resolution.""" + for fut in list(itertools.product([0, 1], repeat=3)): + setattr(self, f"_E{fut[0]}H{fut[1]}V{fut[2]}", None) + + self._per_date_eai = None + self._per_date_aai = None + + @staticmethod + def _set_date_idx( + date1: str | pd.Timestamp | datetime.date, + date2: str | pd.Timestamp | datetime.date, + freq: str | None = None, + name: str | None = None, + ) -> pd.PeriodIndex: + """Generate a date range index based on the provided parameters. + + Parameters + ---------- + date1 : str or pd.Timestamp or datetime.date + The start date of the period range. + date2 : str or pd.Timestamp or datetime.date + The end date of the period range. + freq : str, optional + Frequency string for the period range. + See `here `_. + name : str, optional + Name of the resulting period range index. + + Returns + ------- + pd.PeriodIndex + A PeriodIndex representing the date range. + + Raises + ------ + ValueError + If the number of periods and frequency given to period_range are inconsistent. + """ + ret = pd.period_range( + date1, + date2, + freq=freq, # type: ignore + name=name, + ) + return ret + + @property + def snapshot_start(self) -> Snapshot: + """The `Snapshot` at the start of the risk period.""" + return self._snapshot_start + + @property + def snapshot_end(self) -> Snapshot: + """The `Snapshot` at the end of the risk period.""" + return self._snapshot_end + + @property + def date_idx(self) -> pd.PeriodIndex: + """The pandas PeriodIndex representing the time dimension of the risk period.""" + return self._date_idx + + @date_idx.setter + def date_idx(self, value, /): + if not isinstance(value, pd.PeriodIndex): + raise ValueError("Not a PeriodIndex") + + self._date_idx = value # Avoids weird hourly data + self._time_resolution = self.date_idx.freq + self._reset_impact_data() + + @property + def time_points(self) -> int: + """The numbers of different time points (periods) in the risk period.""" + return len(self.date_idx) + + @property + def time_resolution(self) -> str: + """The time resolution of the risk periods, expressed as + a pandas period frequency string. + + """ + return self._time_resolution # type: ignore + + @time_resolution.setter + def time_resolution(self, value, /): + self.date_idx = pd.period_range( + self.snapshot_start.date, + self.snapshot_end.date, + freq=value, + name=DEFAULT_PERIOD_INDEX_NAME, + ) + + @property + def interpolation_strategy(self) -> InterpolationStrategyBase: + """The approach used to interpolate impact matrices in between the two snapshots.""" + return self._interpolation_strategy + + @interpolation_strategy.setter + def interpolation_strategy(self, value, /): + if not isinstance(value, InterpolationStrategyBase): + raise ValueError("Not an interpolation strategy") + + self._interpolation_strategy = value + self._reset_impact_data() + + @property + def impact_computation_strategy(self) -> ImpactComputationStrategy: + """The method used to calculate the impact from the (Haz,Exp,Vul) of the two snapshots.""" + return self._impact_computation_strategy + + @impact_computation_strategy.setter + def impact_computation_strategy(self, value, /): + if not isinstance(value, ImpactComputationStrategy): + raise ValueError("Not an impact computation strategy") + + self._impact_computation_strategy = value + self._reset_impact_data() + + def apply_measure(self, measure: Measure) -> "CalcRiskMetricsPeriod": + """Creates a new `CalcRiskMetricsPeriod` object with a measure. + + The given measure is applied to both snapshot of the risk period. + + Parameters + ---------- + measure : Measure + The measure to apply. + + Returns + ------- + + CalcRiskPeriod + The risk period with given measure applied. + + """ + snap0 = self.snapshot_start.apply_measure(measure) + snap1 = self.snapshot_end.apply_measure(measure) + + risk_period = CalcRiskMetricsPeriod( + snap0, + snap1, + time_resolution=self.time_resolution, + interpolation_strategy=self.interpolation_strategy, + impact_computation_strategy=self.impact_computation_strategy, + ) + + risk_period.measure = measure + return risk_period + + ################################################### + ##### Impact objects cube / Risk Cube corners ##### + + @lazy_property + def E0H0V0(self) -> Impact: + """Impact object corresponding to starting exposure, + starting hazard and starting vulnerability. + + """ + return self.impact_computation_strategy.compute_impacts( + self.snapshot_start.exposure, + self.snapshot_start.hazard, + self.snapshot_start.impfset, + ) + + @lazy_property + def E1H0V0(self) -> Impact: + """Impact object corresponding to future exposure, + starting hazard and starting vulnerability. + + """ + return self.impact_computation_strategy.compute_impacts( + self.snapshot_end.exposure, + self.snapshot_start.hazard, + self.snapshot_start.impfset, + ) + + @lazy_property + def E0H1V0(self) -> Impact: + """Impact object corresponding to starting exposure, + future hazard and starting vulnerability. + + """ + return self.impact_computation_strategy.compute_impacts( + self.snapshot_start.exposure, + self.snapshot_end.hazard, + self.snapshot_start.impfset, + ) + + @lazy_property + def E1H1V0(self) -> Impact: + """Impact object corresponding to future exposure, + future hazard and starting vulnerability. + + """ + return self.impact_computation_strategy.compute_impacts( + self.snapshot_end.exposure, + self.snapshot_end.hazard, + self.snapshot_start.impfset, + ) + + @lazy_property + def E0H0V1(self) -> Impact: + """Impact object corresponding to starting exposure, + starting hazard and future vulnerability. + + """ + return self.impact_computation_strategy.compute_impacts( + self.snapshot_start.exposure, + self.snapshot_start.hazard, + self.snapshot_end.impfset, + ) + + @lazy_property + def E1H0V1(self) -> Impact: + """Impact object corresponding to future exposure, + starting hazard and future vulnerability. + + """ + return self.impact_computation_strategy.compute_impacts( + self.snapshot_end.exposure, + self.snapshot_start.hazard, + self.snapshot_end.impfset, + ) + + @lazy_property + def E0H1V1(self) -> Impact: + """Impact object corresponding to starting exposure, + future hazard and future vulnerability. + + """ + return self.impact_computation_strategy.compute_impacts( + self.snapshot_start.exposure, + self.snapshot_end.hazard, + self.snapshot_end.impfset, + ) + + @lazy_property + def E1H1V1(self) -> Impact: + """Impact object corresponding to future exposure, + future hazard and future vulnerability. + + """ + return self.impact_computation_strategy.compute_impacts( + self.snapshot_end.exposure, + self.snapshot_end.hazard, + self.snapshot_end.impfset, + ) + + ############################### + + ################################################# + ### Impact Matrices arrays / Risk Cube edges #### + + def _interp_mats(self, start_attr, end_attr) -> list: + """Helper to reduce repetition in impact matrix interpolation.""" + start = getattr(self, start_attr).imp_mat + end = getattr(self, end_attr).imp_mat + return self.interpolation_strategy.interp_over_exposure_dim( + start, end, self.time_points + ) + + def _imp_mats(self, invariant: str) -> list: + """List of `time_points` impact matrices with changing + exposure, and invariant hazard and vulnerability. + + """ + if re.match(r"H[01]V[01]", invariant): + return self._interp_mats(f"E0{invariant}", f"E1{invariant}") + + if re.match(r"E[01]H[01]V[01]", invariant): + return [getattr(self, invariant).imp_mat] * self.time_points + + raise ValueError( + f"Unrecognised invariant format ({invariant}), should be H[01]V[01] | E[01]H[01]V[01]" + ) + + ############################### + + ############################### + ########## Core EAI ########### + + def _per_date_eais_interp(self, invariant: str) -> np.ndarray: + """Expected annual impacts for changing exposure, and fixed + hazard and vulnerability. + + """ + return calc_per_date_eais( + self._imp_mats(invariant=invariant), + ( + self.snapshot_start.hazard.frequency + if "H0" in invariant + else self.snapshot_end.hazard.frequency + ), + ) + + ############################## + ######### Core AAIs ########## + + # Not required for final AAIs computation (we use final EAIs instead), + # but could be useful in the future? + + def _per_date_aais_interp(self, invariant: str) -> np.ndarray: + """Average periodic impacts for specified invariant.""" + return calc_per_date_aais(self._per_date_eais_interp(invariant=invariant)) + + ############################# + ######### Core RPs ######### + + def _per_date_return_periods( + self, invariant: str, return_periods: list[int] + ) -> np.ndarray: + return calc_per_date_rps( + self._imp_mats(invariant=invariant), + ( + self.snapshot_start.hazard.frequency + if "H0" in invariant + else self.snapshot_end.hazard.frequency + ), + self.date_idx.freqstr[0], + return_periods, + ) + + ################################## + ##### Interpolation of metrics ### + + # Actual results + + def _calc_eai(self) -> np.ndarray: + """Compute the EAIs at each date of the risk period (including changes in exposure, hazard and vulnerability).""" + per_date_eai_H0V0, per_date_eai_H1V0, per_date_eai_H0V1, per_date_eai_H1V1 = ( + self._per_date_eais_interp("H0V0"), + self._per_date_eais_interp("H1V0"), + self._per_date_eais_interp("H0V1"), + self._per_date_eais_interp("H1V1"), + ) + per_date_eai_V0 = self.interpolation_strategy.interp_over_hazard_dim( + per_date_eai_H0V0, per_date_eai_H1V0 + ) + per_date_eai_V1 = self.interpolation_strategy.interp_over_hazard_dim( + per_date_eai_H0V1, per_date_eai_H1V1 + ) + per_date_eai = self.interpolation_strategy.interp_over_vulnerability_dim( + per_date_eai_V0, per_date_eai_V1 + ) + return per_date_eai + + ### Fully interpolated metrics ### + + @lazy_property + def per_date_eai(self) -> np.ndarray: + """Expected annual impacts per date with changing + exposure, changing hazard and changing vulnerability. + + """ + return self._calc_eai() + + @lazy_property + def per_date_aai(self) -> np.ndarray: + """Average annual impacts per date with changing + exposure, changing hazard and changing vulnerability. + + """ + return calc_per_date_aais(self.per_date_eai) + + #################################### + ######## Tidying results ########### + + def calc_eai_gdf(self) -> pd.DataFrame: + """Convenience function returning a DataFrame from `per_date_eai`. + + This dataframe can easily be merged with one of the snapshot exposure geodataframe. + + Notes + ----- + + The DataFrame from the starting snapshot is used as a basis + (notably for `value` and `group_id`). + + """ + metric_df = pd.DataFrame(self.per_date_eai, index=self.date_idx) + metric_df = metric_df.reset_index().melt( + id_vars=DEFAULT_PERIOD_INDEX_NAME, + var_name=COORD_ID_COL_NAME, + value_name=RISK_COL_NAME, + ) + if GROUP_ID_COL_NAME in self.snapshot_start.exposure.gdf: + eai_gdf = self.snapshot_start.exposure.gdf[[GROUP_ID_COL_NAME]] + eai_gdf[COORD_ID_COL_NAME] = eai_gdf.index + eai_gdf = eai_gdf.merge(metric_df, on=COORD_ID_COL_NAME) + eai_gdf = eai_gdf.rename(columns={GROUP_ID_COL_NAME: GROUP_COL_NAME}) + else: + eai_gdf = metric_df + eai_gdf[GROUP_COL_NAME] = pd.NA + + eai_gdf[GROUP_COL_NAME] = pd.Categorical( + eai_gdf[GROUP_COL_NAME], categories=self._groups_id + ) + eai_gdf[METRIC_COL_NAME] = EAI_METRIC_NAME + eai_gdf[MEASURE_COL_NAME] = ( + self.measure.name if self.measure else NO_MEASURE_VALUE + ) + eai_gdf[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit + return eai_gdf + + def calc_aai_metric(self) -> pd.DataFrame: + """Compute a DataFrame of the AAI at each dates of the risk period + (including changes in exposure, hazard and vulnerability). + + """ + aai_df = pd.DataFrame( + index=self.date_idx, columns=[RISK_COL_NAME], data=self.per_date_aai + ) + aai_df[GROUP_COL_NAME] = pd.Categorical( + [pd.NA] * len(aai_df), categories=self._groups_id + ) + aai_df[METRIC_COL_NAME] = AAI_METRIC_NAME + aai_df[MEASURE_COL_NAME] = ( + self.measure.name if self.measure else NO_MEASURE_VALUE + ) + aai_df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit + aai_df.reset_index(inplace=True) + return aai_df + + def calc_aai_per_group_metric(self) -> pd.DataFrame | None: + """Compute a DataFrame of the AAI distinguised per group id in the exposures, + at each dates of the risk period (including changes in exposure, hazard and vulnerability). + + Notes + ----- + + If group ids changes between starting and ending snapshots of the risk period, + the AAIs are linearly interpolated (with a warning for transparency). + + """ + if len(self._group_id_E0) < 1 or len(self._group_id_E1) < 1: + LOGGER.warning( + "No group id defined in at least one of the Exposures object. Per group aai will be empty." + ) + return None + + eai_gdf = self.calc_eai_gdf() + eai_pres_groups = eai_gdf[ + [ + DEFAULT_PERIOD_INDEX_NAME, + COORD_ID_COL_NAME, + GROUP_COL_NAME, + RISK_COL_NAME, + ] + ].copy() + aai_per_group_df = eai_pres_groups.groupby( + [DEFAULT_PERIOD_INDEX_NAME, GROUP_COL_NAME], as_index=False, observed=True + )[RISK_COL_NAME].sum() + if not np.array_equal(self._group_id_E0, self._group_id_E1): + LOGGER.warning( + "Group id are changing between present and future snapshot." + " Per group AAI will be linearly interpolated." + ) + eai_fut_groups = eai_gdf.copy() + eai_fut_groups[GROUP_COL_NAME] = pd.Categorical( + np.tile(self._group_id_E1, len(self.date_idx)), + categories=self._groups_id, + ) + aai_fut_groups = eai_fut_groups.groupby( + [DEFAULT_PERIOD_INDEX_NAME, GROUP_COL_NAME], as_index=False + )[RISK_COL_NAME].sum() + aai_per_group_df[RISK_COL_NAME] = linear_interp_arrays( + aai_per_group_df[RISK_COL_NAME].values, + aai_fut_groups[RISK_COL_NAME].values, + ) + + aai_per_group_df[METRIC_COL_NAME] = AAI_METRIC_NAME + aai_per_group_df[MEASURE_COL_NAME] = ( + self.measure.name if self.measure else NO_MEASURE_VALUE + ) + aai_per_group_df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit + return aai_per_group_df + + def calc_return_periods_metric(self, return_periods: list[int]) -> pd.DataFrame: + """Compute a DataFrame of the estimated impacts for a list of return + periods, at each dates of the risk period (including changes in exposure, + hazard and vulnerability). + + Parameters + ---------- + + return_periods : list of int + The return periods to estimate impacts for. + + """ + + # currently mathematicaly wrong, but approximatively correct, to be reworked when concatenating the impact matrices for the interpolation + per_date_rp_H0V0, per_date_rp_H1V0, per_date_rp_H0V1, per_date_rp_H1V1 = ( + self._per_date_return_periods("H0V0", return_periods), + self._per_date_return_periods("H1V0", return_periods), + self._per_date_return_periods("H0V1", return_periods), + self._per_date_return_periods("H1V1", return_periods), + ) + per_date_rp_V0 = self.interpolation_strategy.interp_over_hazard_dim( + per_date_rp_H0V0, per_date_rp_H1V0 + ) + per_date_rp_V1 = self.interpolation_strategy.interp_over_hazard_dim( + per_date_rp_H0V1, per_date_rp_H1V1 + ) + per_date_rp = self.interpolation_strategy.interp_over_vulnerability_dim( + per_date_rp_V0, per_date_rp_V1 + ) + rp_df = pd.DataFrame( + index=self.date_idx, columns=return_periods, data=per_date_rp + ).melt(value_name=RISK_COL_NAME, var_name="rp", ignore_index=False) + rp_df.reset_index(inplace=True) + rp_df[GROUP_COL_NAME] = pd.Categorical( + [pd.NA] * len(rp_df), categories=self._groups_id + ) + rp_df[METRIC_COL_NAME] = RP_VALUE_PREFIX + "_" + rp_df["rp"].astype(str) + rp_df = rp_df.drop("rp", axis=1) + rp_df[MEASURE_COL_NAME] = ( + self.measure.name if self.measure else NO_MEASURE_VALUE + ) + rp_df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit + return rp_df + + def calc_risk_contributions_metric(self) -> pd.DataFrame: + """Compute a DataFrame of the individual contributions of risk (impact), + at each dates of the risk period (including changes in exposure, + hazard and vulnerability). + + """ + aai_changes_hazard_only = self.interpolation_strategy.interp_over_hazard_dim( + self._per_date_aais_interp("E0H0V0"), self._per_date_aais_interp("E0H1V0") + ) + aai_changes_vulnerability_only = ( + self.interpolation_strategy.interp_over_vulnerability_dim( + self._per_date_aais_interp("E0H0V0"), + self._per_date_aais_interp("E0H0V1"), + ) + ) + metric_df = pd.DataFrame( + { + CONTRIBUTION_TOTAL_RISK_NAME: self.per_date_aai, + CONTRIBUTION_BASE_RISK_NAME: self.per_date_aai[0], + CONTRIBUTION_EXPOSURE_NAME: self._per_date_aais_interp("H0V0") + - self.per_date_aai[0], + CONTRIBUTION_HAZARD_NAME: aai_changes_hazard_only + - self.per_date_aai[0], + CONTRIBUTION_VULNERABILITY_NAME: aai_changes_vulnerability_only + - self.per_date_aai[0], + }, + index=self.date_idx, + ) + metric_df[CONTRIBUTION_INTERACTION_TERM_NAME] = metric_df[ + CONTRIBUTION_TOTAL_RISK_NAME + ] - ( + metric_df[CONTRIBUTION_BASE_RISK_NAME] + + metric_df[CONTRIBUTION_EXPOSURE_NAME] + + metric_df[CONTRIBUTION_HAZARD_NAME] + + metric_df[CONTRIBUTION_VULNERABILITY_NAME] + ) + metric_df = metric_df.melt( + value_vars=[ + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + ], + var_name=METRIC_COL_NAME, + value_name=RISK_COL_NAME, + ignore_index=False, + ) + metric_df.reset_index(inplace=True) + metric_df[GROUP_COL_NAME] = pd.Categorical( + [pd.NA] * len(metric_df), categories=self._groups_id + ) + metric_df[MEASURE_COL_NAME] = ( + self.measure.name if self.measure else NO_MEASURE_VALUE + ) + metric_df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit + return metric_df + + +#################################### +### Metrics from impact matrices ### + + +def calc_per_date_eais(imp_mats: list[csr_matrix], frequency: np.ndarray) -> np.ndarray: + """Calculate expected average impact (EAI) values from a list of impact matrices + corresponding to impacts at different dates (with possible changes along + exposure, hazard and vulnerability). + + Parameters + ---------- + imp_mats : list of np.ndarray + List of impact matrices. + frequency : np.ndarray + Hazard frequency values. + + Returns + ------- + np.ndarray + 2D array of EAI (1D) for each dates. + + """ + return np.array( + [ImpactCalc.eai_exp_from_mat(imp_mat, frequency) for imp_mat in imp_mats] + ) + + +def calc_per_date_aais(per_date_eai_exp: np.ndarray) -> np.ndarray: + """Calculate per_date aggregate annual impact (AAI) values + resulting from a list arrays corresponding to EAI at different + dates (with possible changes along exposure, hazard and vulnerability). + + Parameters + ---------- + per_date_eai_exp: np.ndarray + EAIs arrays. + + Returns + ------- + np.ndarray + 1D array of AAI (0D) for each dates. + """ + return np.array( + [ImpactCalc.aai_agg_from_eai_exp(eai_exp) for eai_exp in per_date_eai_exp] + ) + + +def calc_per_date_rps( + imp_mats: list[csr_matrix], + frequency: np.ndarray, + frequency_unit: str, + return_periods: list[int], +) -> np.ndarray: + """Calculate per date return period impact values from a + list of impact matrices corresponding to impacts at different + dates (with possible changes along exposure, hazard and vulnerability). + + Parameters + ---------- + imp_mats: list of scipy.crs_matrix + List of impact matrices. + frequency: np.ndarray + Frequency values. + return_periods : list of int + Return periods to calculate impact values for. + + Returns + ------- + np.ndarray + 2D array of impacts per return periods (1D) for each dates. + + """ + return np.array( + [ + calc_freq_curve(imp_mat, frequency, frequency_unit, return_periods).impact + for imp_mat in imp_mats + ] + ) + + +def calc_freq_curve( + imp_mat_intrpl, frequency, frequency_unit, return_per=None +) -> ImpactFreqCurve: + """Calculate the estimated impacts for given return periods. + + Parameters + ---------- + + imp_mat_intrpl: scipy.csr_matrix + An impact matrix. + frequency: np.ndarray + The frequency of the hazard. + return_per: np.ndarray + The return periods to compute impacts for. + + Returns + ------- + np.ndarray + The estimated impacts for the different return periods. + + """ + + at_event = np.sum(imp_mat_intrpl, axis=1).A1 + + # Sort descendingly the impacts per events + sort_idxs = np.argsort(at_event)[::-1] + # Calculate exceedence frequency + exceed_freq = np.cumsum(frequency[sort_idxs]) + # Set return period and impact exceeding frequency + ifc_return_per = 1 / exceed_freq[::-1] + ifc_impact = at_event[sort_idxs][::-1] + + if return_per is not None: + interp_imp = np.interp(return_per, ifc_return_per, ifc_impact) + ifc_return_per = return_per + ifc_impact = interp_imp + + return ImpactFreqCurve( + return_per=ifc_return_per, + impact=ifc_impact, + frequency_unit=frequency_unit, + label="Exceedance frequency curve", + ) diff --git a/climada/trajectories/constants.py b/climada/trajectories/constants.py new file mode 100644 index 0000000000..969e585531 --- /dev/null +++ b/climada/trajectories/constants.py @@ -0,0 +1,55 @@ +""" +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 . + +--- + +Define constants for trajectories module. +""" + +DEFAULT_TIME_RESOLUTION = "Y" +DATE_COL_NAME = "date" +PERIOD_COL_NAME = "period" +GROUP_COL_NAME = "group" +GROUP_ID_COL_NAME = "group_id" +MEASURE_COL_NAME = "measure" +NO_MEASURE_VALUE = "no_measure" +METRIC_COL_NAME = "metric" +UNIT_COL_NAME = "unit" +RISK_COL_NAME = "risk" +COORD_ID_COL_NAME = "coord_id" + +DEFAULT_PERIOD_INDEX_NAME = "date" + +DEFAULT_RP = (20, 50, 100) +"""Default return periods to use when computing return period impact estimates.""" + +DEFAULT_ALLGROUP_NAME = "All" +"""Default string to use to define the exposure subgroup containing all exposure points.""" + +EAI_METRIC_NAME = "eai" +AAI_METRIC_NAME = "aai" +AAI_PER_GROUP_METRIC_NAME = "aai_per_group" +CONTRIBUTIONS_METRIC_NAME = "risk_contributions" +RETURN_PERIOD_METRIC_NAME = "return_periods" +RP_VALUE_PREFIX = "rp" + + +CONTRIBUTION_BASE_RISK_NAME = "base risk" +CONTRIBUTION_TOTAL_RISK_NAME = "total risk" +CONTRIBUTION_EXPOSURE_NAME = "exposure contribution" +CONTRIBUTION_HAZARD_NAME = "hazard contribution" +CONTRIBUTION_VULNERABILITY_NAME = "vulnerability contribution" +CONTRIBUTION_INTERACTION_TERM_NAME = "interaction contribution" diff --git a/climada/trajectories/impact_calc_strat.py b/climada/trajectories/impact_calc_strat.py new file mode 100644 index 0000000000..75cf08f545 --- /dev/null +++ b/climada/trajectories/impact_calc_strat.py @@ -0,0 +1,140 @@ +""" +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 . + +--- + +This modules implements the impact computation strategy objects for risk +trajectories. + +""" + +from abc import ABC, abstractmethod + +from climada.engine.impact import Impact +from climada.engine.impact_calc import ImpactCalc +from climada.entity.exposures.base import Exposures +from climada.entity.impact_funcs.impact_func_set import ImpactFuncSet +from climada.hazard.base import Hazard + +__all__ = ["ImpactCalcComputation"] + + +# The following is acceptable. +# We design a pattern, and currently it requires only to +# define the compute_impacts method. +# pylint: disable=too-few-public-methods +class ImpactComputationStrategy(ABC): + """ + Interface for impact computation strategies. + + This abstract class defines the contract for all concrete strategies + responsible for calculating and optionally modifying with a risk transfer, + the impact computation, based on a set of inputs (exposure, hazard, vulnerability). + + It revolves around a `compute_impacts()` method that takes as arguments + the three dimensions of risk (exposure, hazard, vulnerability) and return an + Impact object. + """ + + @abstractmethod + def compute_impacts( + self, + exp: Exposures, + haz: Hazard, + vul: ImpactFuncSet, + ) -> Impact: + """ + Calculates the total impact, including optional risk transfer application. + + Parameters + ---------- + exp : Exposures + The exposure data. + haz : Hazard + The hazard data (e.g., event intensity). + vul : ImpactFuncSet + The set of vulnerability functions. + + Returns + ------- + Impact + An object containing the computed total impact matrix and metrics. + + See Also + -------- + ImpactCalcComputation : The default implementation of this interface. + """ + + +class ImpactCalcComputation(ImpactComputationStrategy): + r""" + Default impact computation strategy using the core engine of climada. + + This strategy first calculates the raw impact using the standard + :class:`ImpactCalc` logic. + + """ + + def compute_impacts( + self, + exp: Exposures, + haz: Hazard, + vul: ImpactFuncSet, + ) -> Impact: + """ + Calculates the impact and applies the "global" risk transfer mechanism. + + Parameters + ---------- + exp : Exposures + The exposure data. + haz : Hazard + The hazard data. + vul : ImpactFuncSet + The set of vulnerability functions. + + Returns + ------- + Impact + The final impact object. + """ + impact = self.compute_impacts_pre_transfer(exp, haz, vul) + return impact + + def compute_impacts_pre_transfer( + self, + exp: Exposures, + haz: Hazard, + vul: ImpactFuncSet, + ) -> Impact: + """ + Calculates the raw impact matrix before any risk transfer is applied. + + Parameters + ---------- + exp : Exposures + The exposure data. + haz : Hazard + The hazard data. + vul : ImpactFuncSet + The set of vulnerability functions. + + Returns + ------- + Impact + An Impact object containing the raw, pre-transfer impact matrix. + """ + return ImpactCalc(exposures=exp, impfset=vul, hazard=haz).impact() diff --git a/climada/trajectories/interpolated_trajectory.py b/climada/trajectories/interpolated_trajectory.py new file mode 100644 index 0000000000..22c73cfa01 --- /dev/null +++ b/climada/trajectories/interpolated_trajectory.py @@ -0,0 +1,926 @@ +""" +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 . + +--- + +This file implements interpolated risk trajectory objects, to allow a better evaluation +of risk in between points in time (snapshots). + +""" + +import datetime +import itertools +import logging +from typing import Iterable, cast + +import matplotlib as mpl +import matplotlib.dates as mdates +import matplotlib.pyplot as plt +import matplotlib.ticker as mticker +import pandas as pd + +from climada.entity.disc_rates.base import DiscRates +from climada.trajectories.calc_risk_metrics import CalcRiskMetricsPeriod +from climada.trajectories.constants import ( + AAI_METRIC_NAME, + AAI_PER_GROUP_METRIC_NAME, + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTIONS_METRIC_NAME, + COORD_ID_COL_NAME, + DATE_COL_NAME, + DEFAULT_TIME_RESOLUTION, + EAI_METRIC_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + PERIOD_COL_NAME, + RETURN_PERIOD_METRIC_NAME, + RISK_COL_NAME, + UNIT_COL_NAME, +) +from climada.trajectories.impact_calc_strat import ( + ImpactCalcComputation, + ImpactComputationStrategy, +) +from climada.trajectories.interpolation import ( + AllLinearStrategy, + InterpolationStrategyBase, +) +from climada.trajectories.snapshot import Snapshot +from climada.trajectories.trajectory import ( + DEFAULT_ALLGROUP_NAME, + DEFAULT_DF_COLUMN_PRIORITY, + DEFAULT_RP, + INDEXING_COLUMNS, + RiskTrajectory, +) +from climada.util import log_level +from climada.util.config import CONFIG +from climada.util.dataframe_handling import reorder_dataframe_columns + +LOGGER = logging.getLogger(__name__) + +__all__ = ["InterpolatedRiskTrajectory"] + + +class InterpolatedRiskTrajectory(RiskTrajectory): + """This class implements interpolated risk trajectories, objects that + regroup impacts computations for multiple dates, and interpolate risk + metrics in between. + + This class computes risk metrics over a series of snapshots, + optionally applying risk discounting. It interpolate risk + between each pair of snapshots and provides dataframes of risk metric on a + given time resolution. + + """ + + _grouper = [MEASURE_COL_NAME, METRIC_COL_NAME] + """Results dataframe grouper""" + + POSSIBLE_METRICS = [ + EAI_METRIC_NAME, + AAI_METRIC_NAME, + RETURN_PERIOD_METRIC_NAME, + CONTRIBUTIONS_METRIC_NAME, + AAI_PER_GROUP_METRIC_NAME, + ] + """Class variable listing the risk metrics that can be computed. + + Currently: + + - eai, expected impact (per exposure point within a period of 1/frequency + unit of the hazard object) + - aai, average annual impact (aggregated eai over the whole exposure) + - aai_per_group, average annual impact per exposure subgroup (defined from + the exposure geodataframe) + - return_periods, estimated impacts aggregated over the whole exposure for + different return periods + - risk_contributions, estimated contribution part of, respectively exposure, + hazard, vulnerability and their interaction to the change in risk over the + considered period + + """ + + _DEFAULT_ALL_METRICS = [ + AAI_METRIC_NAME, + RETURN_PERIOD_METRIC_NAME, + AAI_PER_GROUP_METRIC_NAME, + ] + + def __init__( + self, + snapshots_list: Iterable[Snapshot], + *, + return_periods: Iterable[int] = DEFAULT_RP, + time_resolution: str = DEFAULT_TIME_RESOLUTION, + risk_disc_rates: DiscRates | None = None, + interpolation_strategy: InterpolationStrategyBase | None = None, + impact_computation_strategy: ImpactComputationStrategy | None = None, + ): + """Initialize a new `StaticRiskTrajectory`. + + Parameters + ---------- + snapshot_list : list[Snapshot] + The list of `Snapshot` object to compute risk from. + return_periods: list[int], optional + The return periods to use when computing the `return_periods_metric`. + Defaults to `DEFAULT_RP` ([20, 50, 100]). + time_resolution: str, optional + The time resolution to use for interpolation. + It must be a valid pandas string used to define periods, + e.g., "Y" for years, "M" for months, "3M" for trimester, etc. + Defaults to `DEFAULT_TIME_RESOLUTION` ("Y"). + all_groups_name: str, optional + The string to use to define all exposure points subgroup. + Defaults to `DEFAULT_ALLGROUP_NAME` ("All"). + risk_disc_rates: DiscRates, optional + The discount rate to apply to future risk. Defaults to None. + interpolation_strategy: InterpolationStrategyBase, optional + The interpolation strategy to use when interpolating. + Defaults to :class:`AllLinearStrategy` + impact_computation_strategy: ImpactComputationStrategy, optional + The method used to calculate the impact from the (Haz,Exp,Vul) + of the two snapshots. Defaults to :class:`ImpactCalcComputation`. + + """ + super().__init__( + snapshots_list, + return_periods=return_periods, + all_groups_name=DEFAULT_ALLGROUP_NAME, + risk_disc_rates=risk_disc_rates, + ) + self._risk_metrics_up_to_date: bool = False + self.start_date = min((snapshot.date for snapshot in snapshots_list)) + self.end_date = max((snapshot.date for snapshot in snapshots_list)) + self._risk_metrics_calculators = self._reset_risk_metrics_calculators( + self._snapshots, + time_resolution, + interpolation_strategy or AllLinearStrategy(), + impact_computation_strategy or ImpactCalcComputation(), + ) + + @property + def interpolation_strategy(self) -> InterpolationStrategyBase: + """The approach used to interpolate impact matrices in between the two snapshots.""" + return self._risk_metrics_calculators[0].interpolation_strategy + + @interpolation_strategy.setter + def interpolation_strategy(self, value, /): + if not isinstance(value, InterpolationStrategyBase): + raise ValueError("Not an interpolation strategy") + + self._reset_metrics() + for rmcalc in self._risk_metrics_calculators: + rmcalc.interpolation_strategy = value + + @property + def impact_computation_strategy(self) -> ImpactComputationStrategy: + """The method used to calculate the impact from the (Haz,Exp,Vul) triplets.""" + return self._risk_metrics_calculators[0].impact_computation_strategy + + @impact_computation_strategy.setter + def impact_computation_strategy(self, value, /): + if not isinstance(value, ImpactComputationStrategy): + raise ValueError("Not an interpolation strategy") + + self._reset_metrics() + for rmcalc in self._risk_metrics_calculators: + rmcalc.impact_computation_strategy = value + + @property + def time_resolution(self) -> str: + """The time resolution to use when interpolating. + + It must be a valid pandas string used to define periods, + e.g., "Y" for years, "M" for months, "3M" for trimester, etc. + + See `here `_ + + Notes + ----- + + Changing its value resets the corresponding metric. + """ + return self._risk_metrics_calculators[0].time_resolution + + @time_resolution.setter + def time_resolution(self, value, /): + if not isinstance(value, str): + raise ValueError( + "time_resolution should be a valid pandas Period" + ' frequency string (e.g., `"Y"`, `"M"`, `"D"`).' + ) + self._reset_metrics() + for rmcalc in self._risk_metrics_calculators: + rmcalc.time_resolution = value + + @staticmethod + def _reset_risk_metrics_calculators( + snapshots: list[Snapshot], + time_resolution, + interpolation_strategy, + impact_computation_strategy, + ) -> list[CalcRiskMetricsPeriod]: + """Initialize or reset the internal risk metrics calculators. + + Notes + ----- + + This methods sorts the snapshots per date. + """ + + def pairwise(container: list): + """ + Generate pairs of successive elements from an iterable. + + Parameters + ---------- + iterable : iterable + An iterable sequence from which successive pairs of elements are generated. + + Returns + ------- + zip + A zip object containing tuples of successive pairs from the input iterable. + + Example + ------- + >>> list(pairwise([1, 2, 3, 4])) + [(1, 2), (2, 3), (3, 4)] + """ + first, second = itertools.tee(container) + next(second, None) + return zip(first, second) + + return [ + CalcRiskMetricsPeriod( + start_snapshot, + end_snapshot, + time_resolution=time_resolution, + interpolation_strategy=interpolation_strategy, + impact_computation_strategy=impact_computation_strategy, + ) + for start_snapshot, end_snapshot in pairwise( + sorted(snapshots, key=lambda snap: snap.date) + ) + ] + + def _generic_metrics( + self, + /, + metric_name: str | None = None, + metric_meth: str | None = None, + **kwargs, + ) -> pd.DataFrame: + """Generic method to compute metrics based on the provided metric name and method. + + This method calls the appropriate method from the calculator to return + the results for the given metric, in a tidy formatted dataframe. + + It first checks whether the requested metric is a valid one. + Then looks for a possible cached value and otherwised asks the + calculators (`self._risk_metric_calculators`) to run the computations. + The results are then regrouped in a nice and tidy DataFrame. + If a `risk_disc_rates` was set, values are converted to net present values. + Results are then cached within `self.__metrics` and returned. + + Parameters + ---------- + metric_name : str, optional + The name of the metric to return results for. + metric_meth : str, optional + The name of the specific method of the calculator to call. + + Returns + ------- + pd.DataFrame + A tidy formatted dataframe of the risk metric computed for the + different snapshots. + + Raises + ------ + NotImplementedError + If the requested metric is not part of `POSSIBLE_METRICS`. + ValueError + If either of the arguments are not provided. + + """ + + if metric_name is None or metric_meth is None: + raise ValueError("Both metric_name and metric_meth must be provided.") + + if metric_name not in self.POSSIBLE_METRICS: + raise NotImplementedError( + f"{metric_name} not implemented ({self.POSSIBLE_METRICS})." + ) + + attr_name = f"_{metric_name}_metrics" + + if getattr(self, attr_name) is not None: + LOGGER.debug("Returning cached %s, ", attr_name) + return getattr(self, attr_name) + + LOGGER.debug("Computing %s", attr_name) + with log_level(level="WARNING", name_prefix="climada"): + tmp = [ + getattr(calc_period, metric_meth)(**kwargs) + for calc_period in self._risk_metrics_calculators + ] + + try: + tmp = pd.concat(tmp) + except ValueError as exc: + if str(exc) == "All objects passed were None": + return pd.DataFrame() + raise exc + + if len(tmp) == 0: + return pd.DataFrame() + + tmp = self._metric_post_treatment(tmp, metric_name) + + if CONFIG.trajectory_caching.bool(): + LOGGER.debug("All computing done, caching value.") + setattr(self, attr_name, tmp) + return getattr(self, attr_name) + + return tmp + + def _metric_post_treatment( + self, metric_df: pd.DataFrame, metric_name: str + ) -> pd.DataFrame: + # Notably for per_group_aai being None: + metric_df = self._avoid_duplicates(metric_df) + metric_df = self._handle_group_categories(metric_df) + if metric_name == CONTRIBUTIONS_METRIC_NAME and len(self._snapshots) > 2: + # If there is more than one Snapshot, we need to update the + # contributions from previous periods for continuity + # and to set the base risk from the first period + # This is not elegant, but we need the concatenated metrics from each period, + # so we can't do it in the calculators, and we need + # to do it before caching in the private attribute + metric_df = self._risk_contributions_post_treatment(metric_df) + + if self._risk_disc_rates: + LOGGER.debug("Found risk discount rate. Computing NPV.") + metric_df = self.npv_transform(metric_df, self._risk_disc_rates) + + metric_df = reorder_dataframe_columns(metric_df, DEFAULT_DF_COLUMN_PRIORITY) + return metric_df + + def _avoid_duplicates(self, metric_df: pd.DataFrame) -> pd.DataFrame: + metric_df = metric_df.set_index(INDEXING_COLUMNS) + if COORD_ID_COL_NAME in metric_df.columns: + metric_df = metric_df.set_index([COORD_ID_COL_NAME], append=True) + + # When more than 2 snapshots, there are duplicated rows, we need to remove them. + metric_df = metric_df[~metric_df.index.duplicated(keep="first")] + metric_df = metric_df.reset_index() + return metric_df + + def _handle_group_categories(self, metric_df: pd.DataFrame) -> pd.DataFrame: + if self._all_groups_name not in metric_df[GROUP_COL_NAME].cat.categories: + metric_df[GROUP_COL_NAME] = metric_df[GROUP_COL_NAME].cat.add_categories( + [self._all_groups_name] + ) + metric_df[GROUP_COL_NAME] = metric_df[GROUP_COL_NAME].fillna( + self._all_groups_name + ) + + return metric_df + + def _compute_period_metrics( + self, metric_name: str, metric_meth: str, **kwargs + ) -> pd.DataFrame: + """Helper method to compute total metrics per period + (i.e. whole ranges between pairs of consecutive snapshots). + + """ + metric_df = self._generic_metrics( + metric_name=metric_name, metric_meth=metric_meth, **kwargs + ) + return self._date_to_period_agg(metric_df, grouper=self._grouper) + + def eai_metrics(self, **kwargs) -> pd.DataFrame: + """Return the estimated annual impacts at each exposure point for each date. + + This method computes and return a `DataFrame` with eai metric + (for each exposure point) for each date. + + Notes + ----- + + This computation may become quite expensive for big areas with high resolution. + + """ + df = self._compute_metrics( + metric_name=EAI_METRIC_NAME, metric_meth="calc_eai_gdf", **kwargs + ) + return df + + def aai_metrics(self, **kwargs) -> pd.DataFrame: + """Return the average annual impacts for each date. + + This method computes and return a `DataFrame` with aai metric for each date. + + """ + + return self._compute_metrics( + metric_name=AAI_METRIC_NAME, metric_meth="calc_aai_metric", **kwargs + ) + + def return_periods_metrics(self, **kwargs) -> pd.DataFrame: + """Return the estimated impacts for different return periods. + + Return periods to estimate impacts for are defined by `self.return_periods`. + + """ + + return self._compute_metrics( + metric_name=RETURN_PERIOD_METRIC_NAME, + metric_meth="calc_return_periods_metric", + return_periods=self.return_periods, + **kwargs, + ) + + def aai_per_group_metrics(self, **kwargs) -> pd.DataFrame: + """Return the average annual impacts for each exposure group ID. + + This method computes and return a `DataFrame` with aai metric for each + of the exposure group defined by a group id, for each date. + + """ + + return self._compute_metrics( + metric_name=AAI_PER_GROUP_METRIC_NAME, + metric_meth="calc_aai_per_group_metric", + **kwargs, + ) + + def risk_contributions_metrics(self, **kwargs) -> pd.DataFrame: + """Return the "contributions" of change in future risk (Exposure and Hazard) + + This method returns the contributions of the change in risk at each date: + + - The 'base risk', i.e., the risk without change in hazard or exposure, + compared to trajectory's earliest date. + - The 'exposure contribution', i.e., the additional risks due to change + in exposure (only) + - The 'hazard contribution', i.e., the additional risks due to change + in hazard (only) + - The 'vulnerability contribution', i.e., the additional risks due to + change in vulnerability (only) + - The 'interaction contribution', i.e., the additional risks due to the + interaction term + + + """ + + return self._compute_metrics( + metric_name=CONTRIBUTIONS_METRIC_NAME, + metric_meth="calc_risk_contributions_metric", + **kwargs, + ) + + def _risk_contributions_post_treatment(self, df) -> pd.DataFrame: + """Post treat the risk contributions metrics. + + When more than two snapshots are provided, the total risk of the previous pair + (period) becomes the base risk for the subsequent one. + This method straightens this by resetting the base risk to the risk from + the first snapshot of the list and correcting the different contributions + by cumulating the contributions from the previous periods. + + """ + + df.set_index(INDEXING_COLUMNS, inplace=True) + start_dates = [snap.date for snap in self._snapshots[:-1]] + end_dates = [snap.date for snap in self._snapshots[1:]] + periods_dates = list(zip(start_dates, end_dates)) + df.loc[pd.IndexSlice[:, :, :, CONTRIBUTION_BASE_RISK_NAME]] = df.loc[ + pd.IndexSlice[ + pd.to_datetime(self.start_date).to_period(self.time_resolution), + :, + :, + CONTRIBUTION_BASE_RISK_NAME, + ] # type: ignore + ].values + for p2 in periods_dates[1:]: + for metric in [ + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + ]: + mask_last_previous = ( + df.index.get_level_values(0) + == pd.to_datetime(p2[0]).to_period(self.time_resolution) + ) & (df.index.get_level_values(3) == metric) + mask_to_update = ( + ( + df.index.get_level_values(0) + > pd.to_datetime(p2[0]).to_period(self.time_resolution) + ) + & ( + df.index.get_level_values(0) + <= pd.to_datetime(p2[1]).to_period(self.time_resolution) + ) + & (df.index.get_level_values(3) == metric) + ) + + df.loc[mask_to_update, RISK_COL_NAME] += df.loc[ + mask_last_previous, RISK_COL_NAME + ].iloc[0] + + return df.reset_index() + + def per_date_risk_metrics( + self, + metrics: list[str] | None = None, + ) -> pd.DataFrame: + """Returns a DataFrame of risk metrics for each dates + + This methods collects (and if needed computes) the `metrics` + (Defaulting to AAI_METRIC_NAME, RETURN_PERIOD_METRIC_NAME and AAI_PER_GROUP_METRIC_NAME). + + Parameters + ---------- + metrics : list[str], optional + The list of metrics to return (defaults to + [AAI_METRIC_NAME,RETURN_PERIOD_METRIC_NAME,AAI_PER_GROUP_METRIC_NAME]) + return_periods : list[int], optional + The return periods to consider for the return periods metric + (default to the value of the `.default_rp` attribute) + + Returns + ------- + pd.DataFrame | pd.Series + A tidy DataFrame with metrics value for all possible dates. + + """ + + metrics = self._DEFAULT_ALL_METRICS if metrics is None else metrics + return pd.concat( + [getattr(self, f"{metric}_metrics")() for metric in metrics], + ignore_index=True, + ) + + @staticmethod + def _get_risk_periods( + risk_periods: list[CalcRiskMetricsPeriod], + start_date: datetime.date, + end_date: datetime.date, + strict: bool = True, + ): + """Returns risk periods from the given list that are within `start_date` and `end_date`. + + Either using a strict inclusion (period is stricly within start and end) or extending + to overlap inclusion, i.e., start or end is within the period. + + Parameters + ---------- + risk_periods : list[CalcRiskPeriod] + The list of risk periods to look through + start_date : datetime.date + end_date : datetime.date + strict: bool, default True + If true, only returns periods stricly within start and end dates. Else, + additionaly returns periods that have an overlap within start and end. + """ + if strict: + return [ + period + for period in risk_periods + if ( + start_date <= period.snapshot_start.date + and end_date >= period.snapshot_end.date + ) + ] + + return [ + period + for period in risk_periods + if not ( + start_date >= period.snapshot_end.date + or end_date <= period.snapshot_start.date + ) + ] + + @staticmethod + def _identify_continuous_periods(group, time_unit): + """Calculate the difference between consecutive dates.""" + + if time_unit == "year": + group["date_diff"] = group[DATE_COL_NAME].dt.year.diff() + if time_unit == "month": + group["date_diff"] = group[DATE_COL_NAME].dt.month.diff() + if time_unit == "day": + group["date_diff"] = group[DATE_COL_NAME].dt.day.diff() + if time_unit == "hour": + group["date_diff"] = group[DATE_COL_NAME].dt.hour.diff() + # Identify breaks in continuity + group["period_id"] = (group["date_diff"] != 1).cumsum() + return group + + @classmethod + def _date_to_period_agg( + cls, + metric_df: pd.DataFrame, + grouper: list[str], + time_unit: str = "year", + colname: str | list[str] = RISK_COL_NAME, + ) -> pd.DataFrame: + """Group per date risk metric to periods.""" + + df_sorted = metric_df.sort_values(by=grouper + [DATE_COL_NAME]) + + if GROUP_COL_NAME in metric_df.columns and GROUP_COL_NAME not in grouper: + grouper = [GROUP_COL_NAME] + grouper + + # Apply the function to identify continuous periods + df_periods = df_sorted.groupby( + grouper, dropna=False, group_keys=False, observed=True + )[df_sorted.columns].apply(cls._identify_continuous_periods, time_unit) + + if isinstance(colname, str): + colname = [colname] + agg_dict = { + "start_date": pd.NamedAgg(column=DATE_COL_NAME, aggfunc="min"), + "end_date": pd.NamedAgg(column=DATE_COL_NAME, aggfunc="max"), + } + df_periods_dates = ( + df_periods.groupby(grouper + ["period_id"], dropna=False, observed=True) + .agg(func=None, **agg_dict) # type: ignore + .reset_index() + ) + + df_periods_dates[PERIOD_COL_NAME] = ( + df_periods_dates["start_date"].astype(str) + + " to " + + df_periods_dates["end_date"].astype(str) + ) + df_periods = ( + df_periods.groupby(grouper + ["period_id"], dropna=False, observed=True)[ + colname + ] + .apply("mean") + .reset_index() + ) + df_periods = pd.merge( + df_periods_dates[grouper + [PERIOD_COL_NAME, "period_id"]], + df_periods, + on=grouper + ["period_id"], + ) + df_periods = df_periods.drop(["period_id"], axis=1) + return df_periods[ + [PERIOD_COL_NAME] + + [col for col in df_periods.columns if col != PERIOD_COL_NAME] + ] + + def per_period_risk_metrics( + self, + metrics: Iterable[str] = ( + AAI_METRIC_NAME, + RETURN_PERIOD_METRIC_NAME, + AAI_PER_GROUP_METRIC_NAME, + ), + **kwargs, + ) -> pd.DataFrame: + """Return a tidy dataframe of the risk metrics with the total + for each different period (pair of snapshots). + + """ + + metric_df = self.per_date_risk_metrics(metrics=metrics, **kwargs) + return self._date_to_period_agg( + metric_df, grouper=self._grouper + [UNIT_COL_NAME], **kwargs + ) + + def _calc_waterfall_plot_data( + self, + start_date: datetime.date | None = None, + end_date: datetime.date | None = None, + ): + """Compute the required data for the waterfall plot between `start_date` and `end_date`.""" + start_date = self.start_date if start_date is None else start_date + end_date = self.end_date if end_date is None else end_date + risk_contributions = self.risk_contributions_metrics() + risk_contributions = risk_contributions.loc[ + (risk_contributions[DATE_COL_NAME] >= str(start_date)) + & (risk_contributions[DATE_COL_NAME] <= str(end_date)) + ] + risk_contributions = risk_contributions.set_index( + [DATE_COL_NAME, METRIC_COL_NAME] + )[RISK_COL_NAME].unstack() + return risk_contributions + + # Acceptable given it is a plotting function + # pylint: disable=too-many-locals + def plot_time_waterfall( + self, + ax=None, + figsize=(12, 6), + ): + """Plot a waterfall chart of risk contributions over a specified date range. + + This method generates a stacked bar chart to visualize the + risk contributions. + + Parameters + ---------- + ax : matplotlib.axes.Axes, optional + The matplotlib axes on which to plot. If None, a new figure and axes are created. + + Returns + ------- + matplotlib.axes.Axes + The matplotlib axes with the plotted waterfall chart. + + """ + if ax is None: + fig, ax = plt.subplots(figsize=figsize) + else: + fig = ax.figure # get parent figure from the axis + + risk_contribution = self._calc_waterfall_plot_data( + start_date=self.start_date, end_date=self.end_date + ) + risk_contribution = risk_contribution[ + [ + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + ] + ] + positive_contrib = ( + risk_contribution[risk_contribution > 0].dropna(how="all", axis=1).fillna(0) + ) # + base_risk.iloc[0] + negative_contrib = ( + risk_contribution[risk_contribution < 0].dropna(how="all", axis=1).fillna(0) + ) # + base_risk.iloc[0] + + color_index = { + CONTRIBUTION_EXPOSURE_NAME: 1, + CONTRIBUTION_HAZARD_NAME: 2, + CONTRIBUTION_VULNERABILITY_NAME: 3, + CONTRIBUTION_INTERACTION_TERM_NAME: 4, + } + csequence = mpl.color_sequences["tab10"] + ax.stackplot( + positive_contrib.index.to_timestamp(), # type: ignore + [positive_contrib[col] for col in positive_contrib.columns], + labels=positive_contrib.columns, + colors=[csequence[color_index[col]] for col in positive_contrib.columns], + ) + if not negative_contrib.empty: + ax.stackplot( + negative_contrib.index.to_timestamp(), # type: ignore + [negative_contrib[col] for col in negative_contrib.columns], + labels=negative_contrib.columns, + colors=[ + csequence[color_index[col]] for col in negative_contrib.columns + ], + ) + handles, labels = plt.gca().get_legend_handles_labels() + newLabels, newHandles = [], [] + for handle, label in zip(handles, labels): + if label not in newLabels: + newLabels.append(label) + newHandles.append(handle) + + ax.legend(newHandles, newLabels) + value_label = "Deviation from base risk" + title_label = f"Contributions to change in risk between {self.start_date} and {self.end_date} (Average)" + + locator = mdates.AutoDateLocator() + formatter = mdates.ConciseDateFormatter(locator) + + ax.axhline(y=0, linestyle="--", color="black", linewidth=2) + ax.xaxis.set_major_locator(locator) + ax.xaxis.set_major_formatter(formatter) + ax.yaxis.set_major_formatter(mticker.EngFormatter()) + ax.set_title(title_label) + ax.set_ylabel(value_label) + ax.set_ylim(top=1.1 * ax.get_ylim()[1]) + return fig, ax + + def plot_waterfall( + self, + ax=None, + ): + """Plot a waterfall chart of risk contributions between two dates. + + This method generates a waterfall plot to visualize the changes in risk contributions. + + Parameters + ---------- + ax : matplotlib.axes.Axes, optional + The matplotlib axes on which to plot. If None, a new figure and axes are created. + + Returns + ------- + matplotlib.axes.Axes + The matplotlib axes with the plotted waterfall chart. + + """ + start_date_p = pd.to_datetime(self.start_date).to_period(self.time_resolution) + end_date_p = pd.to_datetime(self.end_date).to_period(self.time_resolution) + risk_contribution = self._calc_waterfall_plot_data( + start_date=self.start_date, end_date=self.end_date + ) + if ax is None: + _, ax = plt.subplots(figsize=(8, 5)) + + risk_contribution = risk_contribution.loc[ + (risk_contribution.index == str(self.end_date)) + ].squeeze() + risk_contribution = cast(pd.Series, risk_contribution) + + labels = [ + f"Risk {start_date_p}", + f"Exposure contribution {end_date_p}", + f"Hazard contribution {end_date_p}", + f"Vulnerability contribution {end_date_p}", + f"Interaction contribution {end_date_p}", + f"Total Risk {end_date_p}", + ] + values = [ + risk_contribution[CONTRIBUTION_BASE_RISK_NAME], + risk_contribution[CONTRIBUTION_EXPOSURE_NAME], + risk_contribution[CONTRIBUTION_HAZARD_NAME], + risk_contribution[CONTRIBUTION_VULNERABILITY_NAME], + risk_contribution[CONTRIBUTION_INTERACTION_TERM_NAME], + risk_contribution.sum(), + ] + bottoms = [ + 0.0, + risk_contribution[CONTRIBUTION_BASE_RISK_NAME], + risk_contribution[CONTRIBUTION_BASE_RISK_NAME] + + risk_contribution[CONTRIBUTION_EXPOSURE_NAME], + risk_contribution[CONTRIBUTION_BASE_RISK_NAME] + + risk_contribution[CONTRIBUTION_EXPOSURE_NAME] + + risk_contribution[CONTRIBUTION_HAZARD_NAME], + risk_contribution[CONTRIBUTION_BASE_RISK_NAME] + + risk_contribution[CONTRIBUTION_EXPOSURE_NAME] + + risk_contribution[CONTRIBUTION_HAZARD_NAME] + + risk_contribution[CONTRIBUTION_VULNERABILITY_NAME], + 0.0, + ] + + ax.bar( + labels, + values, + bottom=bottoms, + edgecolor="black", + color=[ + "tab:cyan", + "tab:orange", + "tab:green", + "tab:red", + "tab:purple", + "tab:blue", + ], + ) + for i, val in enumerate(values): + ax.text( + labels[i], # type: ignore + val + bottoms[i], + f"{val:.0e}", + ha="center", + va="bottom", + color="black", + ) + + # Construct y-axis label and title based on parameters + value_label = "USD" + title_label = f"Evolution of the contributions of risk between {start_date_p} and {end_date_p} (Average impact)" + ax.yaxis.set_major_formatter(mticker.EngFormatter()) + ax.set_title(title_label) + ax.set_ylabel(value_label) + ax.set_ylim(0.0, 1.1 * ax.get_ylim()[1]) + ax.tick_params( + axis="x", + labelrotation=90, + ) + + return ax diff --git a/climada/trajectories/interpolation.py b/climada/trajectories/interpolation.py new file mode 100644 index 0000000000..c07c53883c --- /dev/null +++ b/climada/trajectories/interpolation.py @@ -0,0 +1,435 @@ +""" +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 . + +--- + +This modules implements different sparce matrices and numpy arrays +interpolation approaches. + +""" + +import logging +from abc import ABC +from collections.abc import Callable +from typing import Any, Dict, List, Optional + +import numpy as np +from scipy import sparse + +LOGGER = logging.getLogger(__name__) + +__all__ = [ + "AllLinearStrategy", + "ExponentialExposureStrategy", + "linear_interp_arrays", + "linear_interp_imp_mat", + "exponential_interp_arrays", + "exponential_interp_imp_mat", +] + + +def linear_interp_imp_mat( + mat_start: sparse.csr_matrix, + mat_end: sparse.csr_matrix, + number_of_interpolation_points: int, +) -> List[sparse.csr_matrix]: + r""" + Linearly interpolates between two sparse impact matrices. + + Creates a sequence of matrices representing a linear transition from a starting + matrix to an ending matrix. The interpolation includes both the start and end + points. + + Parameters + ---------- + mat_start : scipy.sparse.csr_matrix + The starting impact matrix. Must have a shape compatible with `mat_end` + for arithmetic operations. + mat_end : scipy.sparse.csr_matrix + The ending impact matrix. Must have a shape compatible with `mat_start` + for arithmetic operations. + number_of_interpolation_points : int + The total number of matrices to return, including the start and end points. + Must be $\ge 2$. + + Returns + ------- + list of scipy.sparse.csr_matrix + A list of matrices, where the first element is `mat_start` and the last + element is `mat_end`. The total length of the list is + `number_of_interpolation_points`. + + Notes + ----- + The formula used for interpolation at proportion $p$ is: + $$M_p = M_{start} \cdot (1 - p) + M_{end} \cdot p$$ + The proportions $p$ range from 0 to 1, inclusive. + """ + + return [ + mat_start + prop * (mat_end - mat_start) + for prop in np.linspace(0, 1, number_of_interpolation_points) + ] + + +def exponential_interp_imp_mat( + mat_start: sparse.csr_matrix, + mat_end: sparse.csr_matrix, + number_of_interpolation_points: int, +) -> List[sparse.csr_matrix]: + r""" + Exponentially interpolates between two "impact matrices". + + This function performs interpolation in a logarithmic space, effectively + achieving an exponential-like transition between `mat_start` and `mat_end`. + It is designed for objects that wrap NumPy arrays and expose them via a + `.data` attribute. + + Parameters + ---------- + mat_start : object + The starting matrix object. Must have a `.data` attribute that is a + NumPy array of positive values. + mat_end : object + The ending matrix object. Must have a `.data` attribute that is a + NumPy array of positive values and have a compatible shape with `mat_start`. + number_of_interpolation_points : int + The total number of matrix objects to return, including the start and + end points. Must be $\ge 2$. + + Returns + ------- + list of object + A list of interpolated matrix objects. The first element corresponds to + `mat_start` and the last to `mat_end` (after the conversion/reversion). + The list length is `number_of_interpolation_points`. + + Notes + ----- + The interpolation is achieved by: + + 1. Mapping the matrix data to a transformed logarithmic space: + $$M'_{i} = \ln(M_{i})}$$ + (where $\ln$ is the natural logarithm, and $\epsilon$ is added to $M_{i}$ + to prevent $\ln(0)$). + 2. Performing standard linear interpolation on the transformed matrices + $M'_{start}$ and $M'_{end}$ to get $M'_{interp}$: + $$M'_{interp} = M'_{start} \cdot (1 - \text{ratio}) + M'_{end} \cdot \text{ratio}$$ + 3. Mapping the result back to the original domain: + $$M_{interp} = \exp(M'_{interp}$$ + """ + + mat_start = mat_start.copy() + mat_end = mat_end.copy() + mat_start.data = np.log(mat_start.data + np.finfo(float).eps) + mat_end.data = np.log(mat_end.data + np.finfo(float).eps) + + # Perform linear interpolation in the logarithmic domain + res = [] + num_points = number_of_interpolation_points + for point in range(num_points): + ratio = point / (num_points - 1) + mat_interpolated = mat_start * (1 - ratio) + ratio * mat_end + mat_interpolated.data = np.exp(mat_interpolated.data) + res.append(mat_interpolated) + return res + + +def linear_interp_arrays(arr_start: np.ndarray, arr_end: np.ndarray) -> np.ndarray: + r""" + Performs linear interpolation between two NumPy arrays over their first dimension. + + This function interpolates each metric (column) linearly across the time steps + (rows), including both the start and end states. + + Parameters + ---------- + arr_start : numpy.ndarray + The starting array of metrics. The first dimension (rows) is assumed to + represent the interpolation steps (e.g., dates/time points). + arr_end : numpy.ndarray + The ending array of metrics. Must have the exact same shape as `arr_start`. + + Returns + ------- + numpy.ndarray + An array with the same shape as `arr_start` and `arr_end`. The values + in the first dimension transition linearly from those in `arr_start` + to those in `arr_end`. + + Raises + ------ + ValueError + If `arr_start` and `arr_end` do not have the same shape. + + Notes + ----- + The interpolation is performed element-wise along the first dimension + (axis 0). For each row $i$ and proportion $p_i$, the result $R_i$ is calculated as: + + $$R_i = arr\_start_i \cdot (1 - p_i) + arr\_end_i \cdot p_i$$ + + where $p_i$ is generated by $\text{np.linspace}(0, 1, n)$ and $n$ is the + size of the first dimension ($\text{arr\_start.shape}[0]$). + """ + if arr_start.shape != arr_end.shape: + raise ValueError( + f"Cannot interpolate arrays of different shapes: {arr_start.shape} and {arr_end.shape}." + ) + interpolation_range = arr_start.shape[0] + prop1 = np.linspace(0, 1, interpolation_range) + prop0 = 1 - prop1 + if arr_start.ndim > 1: + prop0, prop1 = prop0.reshape(-1, 1), prop1.reshape(-1, 1) + + return np.multiply(arr_start, prop0) + np.multiply(arr_end, prop1) + + +def exponential_interp_arrays(arr_start: np.ndarray, arr_end: np.ndarray) -> np.ndarray: + r""" + Performs exponential interpolation between two NumPy arrays over their first dimension. + + This function achieves an exponential-like transition by performing linear + interpolation in the logarithmic space, suitable to interpolate over a dimension which has + a growth factor. + + Parameters + ---------- + arr_start : numpy.ndarray + The starting array of metrics. Values must be positive. + arr_end : numpy.ndarray + The ending array of metrics. Must have the exact same shape as `arr_start`. + + Returns + ------- + numpy.ndarray + An array with the same shape as `arr_start` and `arr_end`. The values + in the first dimension transition exponentially from those in `arr_start` + to those in `arr_end`. + + Raises + ------ + ValueError + If `arr_start` and `arr_end` do not have the same shape. + + Notes + ----- + The interpolation is performed by transforming the arrays to a logarithmic + domain, linearly interpolating, and then transforming back. + + The formula for the interpolated result $R$ at proportion $\text{prop}$ is: + $$ + R = \exp \left( + \ln(A_{start}) \cdot (1 - \text{prop}) + + \ln(A_{end}) \cdot \text{prop} + \right) + $$ + where $A_{start}$ and $A_{end}$ are the input arrays (with $\epsilon$ added + to prevent $\ln(0)$) and $\text{prop}$ ranges from 0 to 1. + """ + if arr_start.shape != arr_end.shape: + raise ValueError( + f"Cannot interpolate arrays of different shapes: {arr_start.shape} and {arr_end.shape}." + ) + interpolation_range = arr_start.shape[0] + + prop1 = np.linspace(0, 1, interpolation_range) + prop0 = 1 - prop1 + if arr_start.ndim > 1: + prop0, prop1 = prop0.reshape(-1, 1), prop1.reshape(-1, 1) + + # Perform log transformation, linear interpolation, and exponential back-transformation + log_arr_start = np.log(arr_start + np.finfo(float).eps) + log_arr_end = np.log(arr_end + np.finfo(float).eps) + + interpolated_log_arr = np.multiply(log_arr_start, prop0) + np.multiply( + log_arr_end, prop1 + ) + + return np.exp(interpolated_log_arr) + + +class InterpolationStrategyBase(ABC): + r""" + Base abstract class for defining a set of interpolation strategies. + + This class serves as a blueprint for implementing specific interpolation + methods (e.g., 'Linear', 'Exponential') across different impact dimensions: + Exposure (matrices), Hazard, and Vulnerability (arrays/metrics). + + Attributes + ---------- + exposure_interp : Callable + The function used to interpolate sparse impact matrices over the + exposure dimension. + Signature: (mat_start, mat_end, num_points, **kwargs) -> list[sparse.csr_matrix]. + hazard_interp : Callable + The function used to interpolate NumPy arrays of metrics over the + hazard dimension. + Signature: (arr_start, arr_end, **kwargs) -> np.ndarray. + vulnerability_interp : Callable + The function used to interpolate NumPy arrays of metrics over the + vulnerability dimension. + Signature: (arr_start, arr_end, **kwargs) -> np.ndarray. + """ + + exposure_interp: Callable + hazard_interp: Callable + vulnerability_interp: Callable + + def interp_over_exposure_dim( + self, + imp_E0: sparse.csr_matrix, + imp_E1: sparse.csr_matrix, + interpolation_range: int, + /, + **kwargs: Optional[Dict[str, Any]], + ) -> List[sparse.csr_matrix]: + """ + Interpolates between two impact matrices using the defined exposure strategy. + + This method calls the function assigned to :attr:`exposure_interp` to generate + a sequence of matrices. + + Parameters + ---------- + imp_E0 : scipy.sparse.csr_matrix + A sparse matrix of the impacts at the start of the range. + imp_E1 : scipy.sparse.csr_matrix + A sparse matrix of the impacts at the end of the range. + interpolation_range : int + The total number of time points to interpolate, including the start and end. + **kwargs : Optional[Dict[str, Any]] + Keyword arguments to pass to the underlying :attr:`exposure_interp` function. + + Returns + ------- + list of scipy.sparse.csr_matrix + A list of ``interpolation_range`` interpolated impact matrices. + + Raises + ------ + ValueError + If the underlying interpolation function raises a ``ValueError`` + indicating incompatible matrix shapes. + """ + try: + res = self.exposure_interp(imp_E0, imp_E1, interpolation_range, **kwargs) + except ValueError as err: + if str(err) == "inconsistent shapes": + raise ValueError( + "Tried to interpolate impact matrices of different shapes. " + "A possible reason could be Exposures of different shapes." + ) from err + + raise err + + return res + + def interp_over_hazard_dim( + self, + metric_0: np.ndarray, + metric_1: np.ndarray, + /, + **kwargs: Optional[Dict[str, Any]], + ) -> np.ndarray: + """ + Interpolates between two metric arrays using the defined hazard strategy. + + This method calls the function assigned to :attr:`hazard_interp`. + + Parameters + ---------- + metric_0 : numpy.ndarray + The starting array of metrics. + metric_1 : numpy.ndarray + The ending array of metrics. Must have the same shape as ``metric_0``. + **kwargs : Optional [Dict[str, Any]] + Keyword arguments to pass to the underlying :attr:`hazard_interp` function. + + Returns + ------- + numpy.ndarray + The resulting interpolated array. + """ + return self.hazard_interp(metric_0, metric_1, **kwargs) + + def interp_over_vulnerability_dim( + self, + metric_0: np.ndarray, + metric_1: np.ndarray, + /, + **kwargs: Optional[Dict[str, Any]], + ) -> np.ndarray: + """ + Interpolates between two metric arrays using the defined vulnerability strategy. + + This method calls the function assigned to :attr:`vulnerability_interp`. + + Parameters + ---------- + metric_0 : numpy.ndarray + The starting array of metrics. + metric_1 : numpy.ndarray + The ending array of metrics. Must have the same shape as ``metric_0``. + **kwargs : Optional[Dict[str, Any]] + Keyword arguments to pass to the underlying :attr:`vulnerability_interp` function. + + Returns + ------- + numpy.ndarray + The resulting interpolated array. + """ + # Note: Assuming the Callable takes the exact positional arguments + return self.vulnerability_interp(metric_0, metric_1, **kwargs) + + +class InterpolationStrategy(InterpolationStrategyBase): + r"""Interface for interpolation strategies. + + This is the class to use to define your own custom interpolation strategy. + """ + + def __init__( + self, + exposure_interp: Callable, + hazard_interp: Callable, + vulnerability_interp: Callable, + ) -> None: + super().__init__() + self.exposure_interp = exposure_interp + self.hazard_interp = hazard_interp + self.vulnerability_interp = vulnerability_interp + + +class AllLinearStrategy(InterpolationStrategyBase): + r"""Linear interpolation strategy over all dimensions.""" + + def __init__(self) -> None: + super().__init__() + self.exposure_interp = linear_interp_imp_mat + self.hazard_interp = linear_interp_arrays + self.vulnerability_interp = linear_interp_arrays + + +class ExponentialExposureStrategy(InterpolationStrategyBase): + r"""Exponential interpolation strategy for exposure and linear for Hazard and Vulnerability.""" + + def __init__(self) -> None: + super().__init__() + self.exposure_interp = exponential_interp_imp_mat + self.hazard_interp = linear_interp_arrays + self.vulnerability_interp = linear_interp_arrays diff --git a/climada/trajectories/snapshot.py b/climada/trajectories/snapshot.py new file mode 100644 index 0000000000..8d9a74ef6f --- /dev/null +++ b/climada/trajectories/snapshot.py @@ -0,0 +1,221 @@ +""" +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 . + +--- + +This modules implements the Snapshot class. + +Snapshot are used to store a snapshot of Exposure, Hazard and Vulnerability +at a specific date. + +""" + +import copy +import datetime +import logging + +from climada.entity.exposures import Exposures +from climada.entity.impact_funcs import ImpactFuncSet +from climada.entity.measures.base import Measure +from climada.hazard import Hazard + +LOGGER = logging.getLogger(__name__) + +__all__ = ["Snapshot"] + + +class Snapshot: + """ + A snapshot of exposure, hazard, and impact function at a specific date. + + Parameters + ---------- + exposure : Exposures + hazard : Hazard + impfset : ImpactFuncSet + date : int | datetime.date | str + The date of the Snapshot, it can be an integer representing a year, + a datetime object or a string representation of a datetime object + with format "YYYY-MM-DD". + ref_only : bool, default False + Should the `Snapshot` contain deep copies of the Exposures, Hazard and Impfset (False) + or references only (True). + + Attributes + ---------- + date : datetime + Date of the snapshot. + measure: Measure | None + The possible measure applied to the snapshot. + + Notes + ----- + + The object creates deep copies of the exposure hazard and impact function set. + + Also note that exposure, hazard and impfset are read-only properties. + Consider snapshot as immutable objects. + + To create a snapshot with a measure, create a snapshot `snap` without + the measure and call `snap.apply_measure(measure)`, which returns a new Snapshot object + with the measure applied to its risk dimensions. + """ + + def __init__( + self, + *, + exposure: Exposures, + hazard: Hazard, + impfset: ImpactFuncSet, + measure: Measure | None, + date: int | datetime.date | str, + ref_only: bool = False, + ) -> None: + self._exposure = exposure if ref_only else copy.deepcopy(exposure) + self._hazard = hazard if ref_only else copy.deepcopy(hazard) + self._impfset = impfset if ref_only else copy.deepcopy(impfset) + self._measure = measure if ref_only else copy.deepcopy(impfset) + self._date = self._convert_to_date(date) + + @classmethod + def from_triplet( + cls, + *, + exposure: Exposures, + hazard: Hazard, + impfset: ImpactFuncSet, + date: int | datetime.date | str, + ref_only: bool = False, + ) -> "Snapshot": + """Create a Snapshot from exposure, hazard and impact functions set + + This method is the main point of entry for the creation of Snapshot. It + creates a new Snapshot object for the given date with copies of the + hazard, exposure and impact function set given in argument (or + references if ref_only is True) + + Parameters + ---------- + exposure : Exposures + hazard : Hazard + impfset : ImpactFuncSet + date : int | datetime.date | str + ref_only : bool + If true, uses references to the exposure, hazard and impact + function objects. Note that modifying the original objects after + computations using the Snapshot might lead to inconsistencies in + results. + + Returns + ------- + Snapshot + + Notes + ----- + + To create a Snapshot with a measure, first create the Snapshot without + the measure using this method, and use `apply_measure(measure)` afterward. + + """ + return cls( + exposure=exposure, + hazard=hazard, + impfset=impfset, + measure=None, + date=date, + ref_only=ref_only, + ) + + @property + def exposure(self) -> Exposures: + """Exposure data for the snapshot.""" + return self._exposure + + @property + def hazard(self) -> Hazard: + """Hazard data for the snapshot.""" + return self._hazard + + @property + def impfset(self) -> ImpactFuncSet: + """Impact function set data for the snapshot.""" + return self._impfset + + @property + def measure(self) -> Measure | None: + """(Adaptation) Measure data for the snapshot.""" + return self._measure + + @property + def date(self) -> datetime.date: + """Date of the snapshot.""" + return self._date + + @property + def impact_calc_data(self) -> dict: + """Convenience function for ImpactCalc class.""" + return { + "exposures": self.exposure, + "hazard": self.hazard, + "impfset": self.impfset, + } + + @staticmethod + def _convert_to_date(date_arg) -> datetime.date: + """Convert date argument of type int or str to a datetime.date object.""" + if isinstance(date_arg, int): + # Assume the integer represents a year + return datetime.date(date_arg, 1, 1) + if isinstance(date_arg, str): + # Try to parse the string as a date + try: + return datetime.datetime.strptime(date_arg, "%Y-%m-%d").date() + except ValueError as exc: + raise ValueError("String must be in the format 'YYYY-MM-DD'") from exc + if isinstance(date_arg, datetime.date): + # Already a date object + return date_arg + + raise TypeError("date_arg must be an int, str, or datetime.date") + + def apply_measure(self, measure: Measure, ref_only: bool = False) -> "Snapshot": + """Create a new snapshot by applying a Measure object. + + This method creates a new `Snapshot` object by applying a measure on + the current one. + + Parameters + ---------- + measure : Measure + The measure to be applied to the snapshot. + + Returns + ------- + The Snapshot with the measure applied. + + """ + + LOGGER.debug("Applying measure %s on snapshot %s", measure.name, id(self)) + exp, impfset, haz = measure.apply(self.exposure, self.impfset, self.hazard) + snap = Snapshot( + exposure=exp, + hazard=haz, + impfset=impfset, + date=self.date, + measure=measure, + ref_only=ref_only, + ) + return snap diff --git a/climada/trajectories/static_trajectory.py b/climada/trajectories/static_trajectory.py new file mode 100644 index 0000000000..42a9e8b84a --- /dev/null +++ b/climada/trajectories/static_trajectory.py @@ -0,0 +1,320 @@ +""" +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 . + +--- + +This file implements \"static\" risk trajectory objects, for an easier evaluation +of risk at multiple points in time (snapshots). + +""" + +import logging +from typing import Iterable + +import pandas as pd + +from climada.entity.disc_rates.base import DiscRates +from climada.trajectories.calc_risk_metrics import CalcRiskMetricsPoints +from climada.trajectories.constants import ( + AAI_METRIC_NAME, + AAI_PER_GROUP_METRIC_NAME, + COORD_ID_COL_NAME, + DATE_COL_NAME, + EAI_METRIC_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + RETURN_PERIOD_METRIC_NAME, +) +from climada.trajectories.impact_calc_strat import ( + ImpactCalcComputation, + ImpactComputationStrategy, +) +from climada.trajectories.snapshot import Snapshot +from climada.trajectories.trajectory import ( + DEFAULT_ALLGROUP_NAME, + DEFAULT_DF_COLUMN_PRIORITY, + DEFAULT_RP, + RiskTrajectory, +) +from climada.util import log_level +from climada.util.dataframe_handling import reorder_dataframe_columns + +LOGGER = logging.getLogger(__name__) + +__all__ = ["StaticRiskTrajectory"] + + +class StaticRiskTrajectory(RiskTrajectory): + """This class implements static risk trajectories, objects that + regroup impacts computations for multiple dates. + + This class computes risk metrics over a series of snapshots, + optionally applying risk discounting. It does not interpolate risk + between the snapshot and only provides results for each snapshot. + + """ + + POSSIBLE_METRICS = [ + EAI_METRIC_NAME, + AAI_METRIC_NAME, + RETURN_PERIOD_METRIC_NAME, + AAI_PER_GROUP_METRIC_NAME, + ] + """Class variable listing the risk metrics that can be computed. + + Currently: + + - eai, expected impact (per exposure point within a period of 1/frequency + unit of the hazard object) + - aai, average annual impact (aggregated eai over the whole exposure) + - aai_per_group, average annual impact per exposure subgroup (defined from + the exposure geodataframe) + - return_periods, estimated impacts aggregated over the whole exposure for + different return periods + + """ + + _DEFAULT_ALL_METRICS = [ + AAI_METRIC_NAME, + RETURN_PERIOD_METRIC_NAME, + AAI_PER_GROUP_METRIC_NAME, + ] + + def __init__( + self, + snapshots_list: Iterable[Snapshot], + *, + return_periods: Iterable[int] = DEFAULT_RP, + all_groups_name: str = DEFAULT_ALLGROUP_NAME, + risk_disc_rates: DiscRates | None = None, + impact_computation_strategy: ImpactComputationStrategy | None = None, + ): + """Initialize a new `StaticRiskTrajectory`. + + Parameters + ---------- + snapshots_list : list[Snapshot] + The list of `Snapshot` object to compute risk from. + return_periods: list[int], optional + The return periods to use when computing the `return_periods_metric`. + Defaults to `DEFAULT_RP` ([20, 50, 100]). + all_groups_name: str, optional + The string that should be used to define "all exposure points" subgroup. + Defaults to `DEFAULT_ALLGROUP_NAME` ("All"). + risk_disc_rates: DiscRates, optional + The discount rate to apply to future risk. Defaults to None. + impact_computation_strategy: ImpactComputationStrategy, optional + The method used to calculate the impact from the (Haz,Exp,Vul) + of the two snapshots. Defaults to :class:`ImpactCalcComputation`. + + """ + super().__init__( + snapshots_list, + return_periods=return_periods, + all_groups_name=all_groups_name, + risk_disc_rates=risk_disc_rates, + ) + self._risk_metrics_calculators = CalcRiskMetricsPoints( + self._snapshots, + impact_computation_strategy=impact_computation_strategy + or ImpactCalcComputation(), + ) + + @property + def impact_computation_strategy(self) -> ImpactComputationStrategy: + """The approach or strategy used to calculate the impact from the snapshots.""" + return self._risk_metrics_calculators.impact_computation_strategy + + @impact_computation_strategy.setter + def impact_computation_strategy(self, value, /): + if not isinstance(value, ImpactComputationStrategy): + raise ValueError("Not an interpolation strategy") + + self._reset_metrics() + self._risk_metrics_calculators.impact_computation_strategy = value + + def _generic_metrics( + self, + /, + metric_name: str | None = None, + metric_meth: str | None = None, + **kwargs, + ) -> pd.DataFrame: + """Generic method to compute metrics based on the provided metric name and method. + + This method calls the appropriate method from the calculator to return + the results for the given metric, in a tidy formatted dataframe. + + It first checks whether the requested metric is a valid one. + Then looks for a possible cached value and otherwised asks the + calculators (`self._risk_metric_calculators`) to run the computation. + The results are then regrouped in a nice and tidy DataFrame. + If a `risk_disc_rates` was set, values are converted to net present values. + Results are then cached within `self.__metrics` and returned. + + Parameters + ---------- + metric_name : str, optional + The name of the metric to return results for. + metric_meth : str, optional + The name of the specific method of the calculator to call. + + Returns + ------- + pd.DataFrame + A tidy formatted dataframe of the risk metric computed for the + different snapshots. + + Raises + ------ + NotImplementedError + If the requested metric is not part of `POSSIBLE_METRICS`. + ValueError + If either of the arguments are not provided. + + """ + if metric_name is None or metric_meth is None: + raise ValueError("Both metric_name and metric_meth must be provided.") + + if metric_name not in self.POSSIBLE_METRICS: + raise NotImplementedError( + f"{metric_name} not implemented ({self.POSSIBLE_METRICS})." + ) + + # Construct the attribute name for storing the metric results + attr_name = f"_{metric_name}_metrics" + + if getattr(self, attr_name) is not None: + LOGGER.debug("Returning cached %s", attr_name) + return getattr(self, attr_name) + + with log_level(level="WARNING", name_prefix="climada"): + tmp = getattr(self._risk_metrics_calculators, metric_meth)(**kwargs) + if tmp is None: + return tmp + + tmp = tmp.set_index( + [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME] + ) + if COORD_ID_COL_NAME in tmp.columns: + tmp = tmp.set_index([COORD_ID_COL_NAME], append=True) + + # When more than 2 snapshots, there might be duplicated rows, we need to remove them. + # Should not be the case in static trajectory, but in any case we really don't want + # duplicated rows, which would mess up some dataframe manipulation down the road. + tmp = tmp[~tmp.index.duplicated(keep="first")] + tmp = tmp.reset_index() + if self._all_groups_name not in tmp[GROUP_COL_NAME].cat.categories: + tmp[GROUP_COL_NAME] = tmp[GROUP_COL_NAME].cat.add_categories( + [self._all_groups_name] + ) + tmp[GROUP_COL_NAME] = tmp[GROUP_COL_NAME].fillna(self._all_groups_name) + + if self._risk_disc_rates: + tmp = self.npv_transform(tmp, self._risk_disc_rates) + + tmp = reorder_dataframe_columns(tmp, DEFAULT_DF_COLUMN_PRIORITY) + + setattr(self, attr_name, tmp) + return getattr(self, attr_name) + + def eai_metrics(self, **kwargs) -> pd.DataFrame: + """Return the estimated annual impacts at each exposure point for each date. + + This method computes and return a `DataFrame` with eai metric + (for each exposure point) for each date. + + Notes + ----- + + This computation may become quite expensive for big areas with high resolution. + + """ + metric_df = self._compute_metrics( + metric_name=EAI_METRIC_NAME, metric_meth="calc_eai_gdf", **kwargs + ) + return metric_df + + def aai_metrics(self, **kwargs) -> pd.DataFrame: + """Return the average annual impacts for each date. + + This method computes and return a `DataFrame` with aai metric for each date. + + """ + + return self._compute_metrics( + metric_name=AAI_METRIC_NAME, metric_meth="calc_aai_metric", **kwargs + ) + + def return_periods_metrics(self, **kwargs) -> pd.DataFrame: + """Return the estimated impacts for different return periods. + + Return periods to estimate impacts for are defined by `self.return_periods`. + + """ + return self._compute_metrics( + metric_name=RETURN_PERIOD_METRIC_NAME, + metric_meth="calc_return_periods_metric", + return_periods=self.return_periods, + **kwargs, + ) + + def aai_per_group_metrics(self, **kwargs) -> pd.DataFrame: + """Return the average annual impacts for each exposure group ID. + + This method computes and return a `DataFrame` with aai metric for each + of the exposure group defined by a group id, for each date. + + """ + + return self._compute_metrics( + metric_name=AAI_PER_GROUP_METRIC_NAME, + metric_meth="calc_aai_per_group_metric", + **kwargs, + ) + + def per_date_risk_metrics( + self, + metrics: list[str] | None = None, + ) -> pd.DataFrame | pd.Series: + """Returns a DataFrame of risk metrics for each dates. + + This methods collects (and if needed computes) the `metrics` + (Defaulting to AAI_METRIC_NAME, RETURN_PERIOD_METRIC_NAME and AAI_PER_GROUP_METRIC_NAME). + + Parameters + ---------- + metrics : list[str], optional + The list of metrics to return (defaults to + [AAI_METRIC_NAME,RETURN_PERIOD_METRIC_NAME,AAI_PER_GROUP_METRIC_NAME]) + + Returns + ------- + pd.DataFrame | pd.Series + A tidy DataFrame with metric values for all possible dates. + + """ + + metrics = ( + [AAI_METRIC_NAME, RETURN_PERIOD_METRIC_NAME, AAI_PER_GROUP_METRIC_NAME] + if metrics is None + else metrics + ) + return pd.concat( + [getattr(self, f"{metric}_metrics")() for metric in metrics], + ignore_index=True, + ) diff --git a/climada/trajectories/test/test_calc_risk_metrics.py b/climada/trajectories/test/test_calc_risk_metrics.py new file mode 100644 index 0000000000..7485f3cd3f --- /dev/null +++ b/climada/trajectories/test/test_calc_risk_metrics.py @@ -0,0 +1,448 @@ +""" +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 . + +--- + +This modules implements different sparce matrices interpolation approaches. + +""" + +import unittest +from unittest.mock import MagicMock, call, patch + +import numpy as np +import pandas as pd + +# Assuming these are the necessary imports from climada +from climada.entity.exposures import Exposures +from climada.entity.impact_funcs import ImpactFuncSet +from climada.entity.impact_funcs.trop_cyclone import ImpfTropCyclone +from climada.entity.measures.base import Measure +from climada.hazard import Hazard +from climada.trajectories.calc_risk_metrics import CalcRiskMetricsPoints +from climada.trajectories.constants import ( + AAI_METRIC_NAME, + COORD_ID_COL_NAME, + DATE_COL_NAME, + EAI_METRIC_NAME, + GROUP_COL_NAME, + GROUP_ID_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + NO_MEASURE_VALUE, + RISK_COL_NAME, + UNIT_COL_NAME, +) + +# Import the CalcRiskPeriod class and other necessary classes/functions +from climada.trajectories.impact_calc_strat import ( + ImpactCalcComputation, + ImpactComputationStrategy, +) +from climada.trajectories.snapshot import Snapshot +from climada.util.constants import EXP_DEMO_H5, HAZ_DEMO_H5 + + +class TestCalcRiskMetricsPoints(unittest.TestCase): + def setUp(self): + # Create mock objects for testing + self.present_date = 2020 + self.future_date = 2025 + self.exposure_present = Exposures.from_hdf5(EXP_DEMO_H5) + self.exposure_present.gdf.rename(columns={"impf_": "impf_TC"}, inplace=True) + self.exposure_present.gdf["impf_TC"] = 1 + self.exposure_present.gdf[GROUP_ID_COL_NAME] = ( + self.exposure_present.gdf["value"] + > self.exposure_present.gdf["value"].mean() + ) * 1 + self.hazard_present = Hazard.from_hdf5(HAZ_DEMO_H5) + self.exposure_present.assign_centroids(self.hazard_present, distance="approx") + self.impfset_present = ImpactFuncSet([ImpfTropCyclone.from_emanuel_usa()]) + + self.exposure_future = Exposures.from_hdf5(EXP_DEMO_H5) + n_years = self.future_date - self.present_date + 1 + growth_rate = 1.02 + growth = growth_rate**n_years + self.exposure_future.gdf["value"] = self.exposure_future.gdf["value"] * growth + self.exposure_future.gdf.rename(columns={"impf_": "impf_TC"}, inplace=True) + self.exposure_future.gdf["impf_TC"] = 1 + self.exposure_future.gdf[GROUP_ID_COL_NAME] = ( + self.exposure_future.gdf["value"] > self.exposure_future.gdf["value"].mean() + ) * 1 + self.hazard_future = Hazard.from_hdf5(HAZ_DEMO_H5) + self.hazard_future.intensity *= 1.1 + self.exposure_future.assign_centroids(self.hazard_future, distance="approx") + self.impfset_future = ImpactFuncSet( + [ + ImpfTropCyclone.from_emanuel_usa(impf_id=1, v_half=60.0), + ] + ) + + self.measure = MagicMock(spec=Measure) + self.measure.name = "Test Measure" + + # Setup mock return values for measure.apply + self.measure_exposure = MagicMock(spec=Exposures) + self.measure_hazard = MagicMock(spec=Hazard) + self.measure_impfset = MagicMock(spec=ImpactFuncSet) + self.measure.apply.return_value = ( + self.measure_exposure, + self.measure_impfset, + self.measure_hazard, + ) + + # Create mock snapshots + self.mock_snapshot_start = Snapshot( + exposure=self.exposure_present, + hazard=self.hazard_present, + impfset=self.impfset_present, + date=self.present_date, + ) + self.mock_snapshot_end = Snapshot( + exposure=self.exposure_future, + hazard=self.hazard_future, + impfset=self.impfset_future, + date=self.future_date, + ) + + # Create an instance of CalcRiskPeriod + self.calc_risk_metrics_points = CalcRiskMetricsPoints( + [self.mock_snapshot_start, self.mock_snapshot_end], + impact_computation_strategy=ImpactCalcComputation(), + ) + + self.expected_eai = np.array( + [ + [ + 8702904.63375606, + 7870925.19290905, + 1805021.12653289, + 3827196.02428828, + 5815346.97427834, + 7870925.19290905, + 7871847.53906951, + 7870925.19290905, + 7886487.76136572, + 7870925.19290905, + 7876058.84500811, + 3858228.67061225, + 8401461.85304853, + 9210350.19520265, + 1806363.23553602, + 6922250.59852326, + 6711006.70101515, + 6886568.00391817, + 6703749.80009753, + 6704689.17531993, + 6703401.93516038, + 6818839.81873556, + 6716262.5286998, + 6703369.87656195, + 6703952.06070945, + 5678897.05935781, + 4984034.77073219, + 6708908.84462217, + 6702586.9472999, + 4961843.43826371, + 5139913.92380089, + 5255310.96072403, + 4981705.85074492, + 4926529.74583162, + 4973726.6063121, + 4926015.68274236, + 4937618.79350358, + 4926144.19851468, + 4926015.68274236, + 9575288.06765627, + 5100904.22956578, + 3501325.10900064, + 5093920.89144773, + 3505527.05928994, + 4002552.92232482, + 3512012.80001039, + 3514993.26161994, + 3562009.79687436, + 3869298.39771648, + 3509317.94922485, + ], + [ + 46651387.10647343, + 42191612.28496882, + 14767621.68800634, + 24849532.38841432, + 32260334.11128166, + 42191612.28496882, + 42196556.46505447, + 42191612.28496882, + 42275034.47974126, + 42191612.28496882, + 42219130.91253302, + 24227735.90988531, + 45035521.54835925, + 49371517.94999501, + 14778602.03484606, + 39909758.65668079, + 38691846.52720026, + 39834520.43061425, + 38650007.36519716, + 38655423.2682883, + 38648001.77388126, + 39313550.93419428, + 38722148.63941796, + 38647816.9422419, + 38651173.48481285, + 33700748.42359267, + 30195870.8789255, + 38679751.48077733, + 38643303.01755095, + 30061424.26274527, + 31140267.73715352, + 31839402.91317674, + 30181761.07222111, + 29847475.57538872, + 30133418.66577969, + 29844361.11423809, + 29914658.78479145, + 29845139.72952577, + 29844361.11423809, + 58012067.61585025, + 30903926.75151934, + 23061159.87895984, + 33550647.3781805, + 23088835.64296583, + 26362451.35547444, + 23131553.38525813, + 23151183.92499699, + 23460854.06493051, + 24271571.95828693, + 23113803.99527559, + ], + ] + ) + + self.expected_aai = np.array([2.88895461e08, 1.69310367e09]) + self.expected_aai_per_group = np.array( + [2.33513758e08, 5.53817034e07, 1.37114041e09, 3.21963264e08] + ) + self.expected_return_period_metric = np.array( + [ + 0.00000000e00, + 0.00000000e00, + 7.10925472e09, + 4.53975437e10, + 1.36547014e10, + 7.69981714e10, + ] + ) + + def test_reset_impact_data(self): + self.calc_risk_metrics_points._impacts = "A" # type:ignore + self.calc_risk_metrics_points._eai_gdf = "B" # type:ignore + self.calc_risk_metrics_points._per_date_eai = "C" # type:ignore + self.calc_risk_metrics_points._per_date_aai = "D" # type:ignore + self.calc_risk_metrics_points._reset_impact_data() + self.assertIsNone(self.calc_risk_metrics_points._impacts) + self.assertIsNone(self.calc_risk_metrics_points._eai_gdf) + self.assertIsNone(self.calc_risk_metrics_points._per_date_aai) + self.assertIsNone(self.calc_risk_metrics_points._per_date_eai) + + def test_set_impact_computation_strategy(self): + new_impact_computation_strategy = MagicMock(spec=ImpactComputationStrategy) + self.calc_risk_metrics_points.impact_computation_strategy = ( + new_impact_computation_strategy + ) + self.assertEqual( + self.calc_risk_metrics_points.impact_computation_strategy, + new_impact_computation_strategy, + ) + + def test_set_impact_computation_strategy_wtype(self): + with self.assertRaises(ValueError): + self.calc_risk_metrics_points.impact_computation_strategy = "A" + + @patch.object(CalcRiskMetricsPoints, "impact_computation_strategy") + def test_impacts_arrays(self, mock_impact_compute): + mock_impact_compute.compute_impacts.side_effect = ["A", "B"] + results = self.calc_risk_metrics_points.impacts + mock_impact_compute.compute_impacts.assert_has_calls( + [ + call( + self.mock_snapshot_start.exposure, + self.mock_snapshot_start.hazard, + self.mock_snapshot_start.impfset, + ), + call( + self.mock_snapshot_end.exposure, + self.mock_snapshot_end.hazard, + self.mock_snapshot_end.impfset, + ), + ] + ) + self.assertEqual(results, ["A", "B"]) + + def test_per_date_eai(self): + np.testing.assert_allclose( + self.calc_risk_metrics_points.per_date_eai, self.expected_eai + ) + + def test_per_date_aai(self): + np.testing.assert_allclose( + self.calc_risk_metrics_points.per_date_aai, + self.expected_aai, + ) + + def test_eai_gdf(self): + result_gdf = self.calc_risk_metrics_points.calc_eai_gdf() + self.assertIsInstance(result_gdf, pd.DataFrame) + self.assertEqual( + result_gdf.shape[0], + len(self.mock_snapshot_start.exposure.gdf) + + len(self.mock_snapshot_end.exposure.gdf), + ) + expected_columns = [ + DATE_COL_NAME, + COORD_ID_COL_NAME, + GROUP_COL_NAME, + RISK_COL_NAME, + METRIC_COL_NAME, + MEASURE_COL_NAME, + UNIT_COL_NAME, + ] + self.assertTrue( + all(col in list(result_gdf.columns) for col in expected_columns) + ) + np.testing.assert_allclose( + np.array(result_gdf[RISK_COL_NAME].values), self.expected_eai.flatten() + ) + # Check constants and column transformations + self.assertEqual(result_gdf[METRIC_COL_NAME].unique(), EAI_METRIC_NAME) + self.assertEqual(result_gdf[MEASURE_COL_NAME].iloc[0], NO_MEASURE_VALUE) + self.assertEqual( + result_gdf[UNIT_COL_NAME].iloc[0], + self.mock_snapshot_start.exposure.value_unit, + ) + self.assertEqual(result_gdf[GROUP_COL_NAME].dtype.name, "category") + self.assertListEqual( + list(result_gdf[GROUP_COL_NAME].cat.categories), + list(self.calc_risk_metrics_points._group_id), + ) + + def test_calc_aai_metric(self): + result_df = self.calc_risk_metrics_points.calc_aai_metric() + self.assertIsInstance(result_df, pd.DataFrame) + self.assertEqual( + result_df.shape[0], len(self.calc_risk_metrics_points.snapshots) + ) + expected_columns = [ + DATE_COL_NAME, + GROUP_COL_NAME, + RISK_COL_NAME, + METRIC_COL_NAME, + MEASURE_COL_NAME, + UNIT_COL_NAME, + ] + self.assertTrue(all(col in result_df.columns for col in expected_columns)) + np.testing.assert_allclose( + np.array(result_df[RISK_COL_NAME].values), self.expected_aai + ) + # Check constants and column transformations + self.assertEqual(result_df[METRIC_COL_NAME].unique(), AAI_METRIC_NAME) + self.assertEqual(result_df[MEASURE_COL_NAME].iloc[0], NO_MEASURE_VALUE) + self.assertEqual( + result_df[UNIT_COL_NAME].iloc[0], + self.mock_snapshot_start.exposure.value_unit, + ) + self.assertEqual(result_df[GROUP_COL_NAME].dtype.name, "category") + + def test_calc_aai_per_group_metric(self): + result_df = self.calc_risk_metrics_points.calc_aai_per_group_metric() + self.assertIsInstance(result_df, pd.DataFrame) + self.assertEqual( + result_df.shape[0], + len(self.calc_risk_metrics_points.snapshots) + * len(self.calc_risk_metrics_points._group_id), + ) + expected_columns = [ + DATE_COL_NAME, + GROUP_COL_NAME, + RISK_COL_NAME, + METRIC_COL_NAME, + MEASURE_COL_NAME, + UNIT_COL_NAME, + ] + self.assertTrue(all(col in result_df.columns for col in expected_columns)) + np.testing.assert_allclose( + np.array(result_df[RISK_COL_NAME].values), self.expected_aai_per_group + ) + # Check constants and column transformations + self.assertEqual(result_df[METRIC_COL_NAME].unique(), AAI_METRIC_NAME) + self.assertEqual(result_df[MEASURE_COL_NAME].iloc[0], NO_MEASURE_VALUE) + self.assertEqual( + result_df[UNIT_COL_NAME].iloc[0], + self.mock_snapshot_start.exposure.value_unit, + ) + self.assertEqual(result_df[GROUP_COL_NAME].dtype.name, "category") + self.assertListEqual(list(result_df[GROUP_COL_NAME].unique()), [0, 1]) + + def test_calc_return_periods_metric(self): + result_df = self.calc_risk_metrics_points.calc_return_periods_metric( + [20, 50, 100] + ) + self.assertIsInstance(result_df, pd.DataFrame) + self.assertEqual( + result_df.shape[0], len(self.calc_risk_metrics_points.snapshots) * 3 + ) + expected_columns = [ + DATE_COL_NAME, + GROUP_COL_NAME, + RISK_COL_NAME, + METRIC_COL_NAME, + MEASURE_COL_NAME, + UNIT_COL_NAME, + ] + self.assertTrue(all(col in result_df.columns for col in expected_columns)) + np.testing.assert_allclose( + np.array(result_df[RISK_COL_NAME].values), + self.expected_return_period_metric, + ) + # Check constants and column transformations + self.assertListEqual( + list(result_df[METRIC_COL_NAME].unique()), ["rp_20", "rp_50", "rp_100"] + ) + self.assertEqual(result_df[MEASURE_COL_NAME].iloc[0], NO_MEASURE_VALUE) + self.assertEqual( + result_df[UNIT_COL_NAME].iloc[0], + self.mock_snapshot_start.exposure.value_unit, + ) + self.assertEqual(result_df[GROUP_COL_NAME].dtype.name, "category") + + @patch.object(Snapshot, "apply_measure") + @patch("climada.trajectories.calc_risk_metrics.CalcRiskMetricsPoints") + def test_apply_measure(self, mock_CalcRiskMetricPoints, mock_snap_apply_measure): + mock_CalcRiskMetricPoints.return_value = MagicMock(spec=CalcRiskMetricsPoints) + mock_snap_apply_measure.return_value = 42 + result = self.calc_risk_metrics_points.apply_measure(self.measure) + mock_snap_apply_measure.assert_called_with(self.measure) + mock_CalcRiskMetricPoints.assert_called_with( + [42, 42], + self.calc_risk_metrics_points.impact_computation_strategy, + ) + self.assertEqual(result.measure, self.measure) + + +if __name__ == "__main__": + TESTS = unittest.TestLoader().loadTestsFromTestCase(TestCalcRiskMetricsPoints) + unittest.TextTestRunner(verbosity=2).run(TESTS) diff --git a/climada/trajectories/test/test_impact_calc_strat.py b/climada/trajectories/test/test_impact_calc_strat.py new file mode 100644 index 0000000000..a828ec51e6 --- /dev/null +++ b/climada/trajectories/test/test_impact_calc_strat.py @@ -0,0 +1,84 @@ +""" +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 . + +--- + +Tests for impact_calc_strat + +""" + +import unittest +from unittest.mock import MagicMock, patch + +from climada.engine import Impact +from climada.entity import ImpactFuncSet +from climada.entity.exposures import Exposures +from climada.hazard import Hazard +from climada.trajectories import Snapshot +from climada.trajectories.impact_calc_strat import ImpactCalcComputation + + +class TestImpactCalcComputation(unittest.TestCase): + def setUp(self): + self.mock_snapshot0 = MagicMock(spec=Snapshot) + self.mock_snapshot0.exposure = MagicMock(spec=Exposures) + self.mock_snapshot0.hazard = MagicMock(spec=Hazard) + self.mock_snapshot0.impfset = MagicMock(spec=ImpactFuncSet) + self.mock_snapshot1 = MagicMock(spec=Snapshot) + self.mock_snapshot1.exposure = MagicMock(spec=Exposures) + self.mock_snapshot1.hazard = MagicMock(spec=Hazard) + self.mock_snapshot1.impfset = MagicMock(spec=ImpactFuncSet) + + self.impact_calc_computation = ImpactCalcComputation() + + @patch.object(ImpactCalcComputation, "compute_impacts_pre_transfer") + def test_compute_impacts(self, mock_calculate_impacts_for_snapshots): + mock_impacts = MagicMock(spec=Impact) + mock_calculate_impacts_for_snapshots.return_value = mock_impacts + + result = self.impact_calc_computation.compute_impacts( + exp=self.mock_snapshot0.exposure, + haz=self.mock_snapshot0.hazard, + vul=self.mock_snapshot0.impfset, + ) + + self.assertEqual(result, mock_impacts) + mock_calculate_impacts_for_snapshots.assert_called_once_with( + self.mock_snapshot0.exposure, + self.mock_snapshot0.hazard, + self.mock_snapshot0.impfset, + ) + + def test_calculate_impacts_for_snapshots(self): + mock_imp_E0H0 = MagicMock(spec=Impact) + + with patch( + "climada.trajectories.impact_calc_strat.ImpactCalc" + ) as mock_impact_calc: + mock_impact_calc.return_value.impact.side_effect = [mock_imp_E0H0] + + result = self.impact_calc_computation.compute_impacts_pre_transfer( + exp=self.mock_snapshot0.exposure, + haz=self.mock_snapshot0.hazard, + vul=self.mock_snapshot0.impfset, + ) + + self.assertEqual(result, mock_imp_E0H0) + + +if __name__ == "__main__": + TESTS = unittest.TestLoader().loadTestsFromTestCase(TestImpactCalcComputation) + unittest.TextTestRunner(verbosity=2).run(TESTS) diff --git a/climada/trajectories/test/test_interpolated_risk_trajectory.py b/climada/trajectories/test/test_interpolated_risk_trajectory.py new file mode 100644 index 0000000000..e09738260d --- /dev/null +++ b/climada/trajectories/test/test_interpolated_risk_trajectory.py @@ -0,0 +1,1416 @@ +""" +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 . + +--- + +unit tests for interpolated_risk_trajectory + +""" + +import datetime +import unittest +from itertools import product +from unittest.mock import MagicMock, Mock, call, patch + +import numpy as np # For potential NaN/NA comparisons +import pandas as pd + +from climada.entity.disc_rates.base import DiscRates +from climada.trajectories.calc_risk_metrics import ( # ImpactComputationStrategy, # If needed to mock its base class directly + CalcRiskMetricsPeriod, +) +from climada.trajectories.constants import ( + AAI_METRIC_NAME, + AAI_PER_GROUP_METRIC_NAME, + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + CONTRIBUTION_TOTAL_RISK_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTIONS_METRIC_NAME, + COORD_ID_COL_NAME, + DATE_COL_NAME, + EAI_METRIC_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + PERIOD_COL_NAME, + RETURN_PERIOD_METRIC_NAME, + RISK_COL_NAME, + UNIT_COL_NAME, +) +from climada.trajectories.impact_calc_strat import ImpactCalcComputation +from climada.trajectories.interpolated_trajectory import ( + INDEXING_COLUMNS, + InterpolatedRiskTrajectory, +) +from climada.trajectories.interpolation import ( + AllLinearStrategy, + ExponentialExposureStrategy, +) +from climada.trajectories.snapshot import Snapshot + + +class TestInterpolatedRiskTrajectory(unittest.TestCase): + def setUp(self): + # Common setup for all tests + self.dates1 = [ + pd.Period("2023-01-01", freq="Y"), + pd.Period("2024-01-01", freq="Y"), + ] + self.dates2 = [ + pd.Period("2025-01-01", freq="Y"), + pd.Period("2026-01-01", freq="Y"), + ] + self.groups = ["GroupA", "GroupB", pd.NA] + self.measures = ["MEAS1", "MEAS2"] + self.metrics = [AAI_METRIC_NAME] + self.aai_dates1 = pd.DataFrame( + product(self.dates1, self.groups, self.measures, self.metrics), + columns=INDEXING_COLUMNS, + ) + self.aai_dates1[RISK_COL_NAME] = np.arange(12) * 100 + self.aai_dates1[GROUP_COL_NAME] = self.aai_dates1[GROUP_COL_NAME].astype( + "category" + ) + + self.aai_dates2 = pd.DataFrame( + product(self.dates2, self.groups, self.measures, self.metrics), + columns=INDEXING_COLUMNS, + ) + self.aai_dates2[RISK_COL_NAME] = np.arange(12) * 100 + 1200 + self.aai_dates2[GROUP_COL_NAME] = self.aai_dates2[GROUP_COL_NAME].astype( + "category" + ) + + self.aai_alldates = pd.DataFrame( + product( + self.dates1 + self.dates2, self.groups, self.measures, self.metrics + ), + columns=INDEXING_COLUMNS, + ) + self.aai_alldates[RISK_COL_NAME] = np.arange(24) * 100 + self.aai_alldates[GROUP_COL_NAME] = self.aai_alldates[GROUP_COL_NAME].astype( + "category" + ) + self.aai_alldates[GROUP_COL_NAME] = self.aai_alldates[ + GROUP_COL_NAME + ].cat.add_categories(["All"]) + self.aai_alldates[GROUP_COL_NAME] = self.aai_alldates[GROUP_COL_NAME].fillna( + "All" + ) + self.expected_pre_npv_aai = self.aai_alldates + self.expected_pre_npv_aai = self.expected_pre_npv_aai[ + [ + DATE_COL_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + RISK_COL_NAME, + ] + ] + + self.expected_npv_aai = pd.DataFrame( + product( + self.dates1 + self.dates2, self.groups, self.measures, self.metrics + ), + columns=INDEXING_COLUMNS, + ) + self.expected_npv_aai[RISK_COL_NAME] = np.arange(24) * 90 + self.expected_npv_aai[GROUP_COL_NAME] = self.expected_npv_aai[ + GROUP_COL_NAME + ].astype("category") + self.expected_npv_aai[GROUP_COL_NAME] = self.expected_npv_aai[ + GROUP_COL_NAME + ].cat.add_categories(["All"]) + self.expected_npv_aai[GROUP_COL_NAME] = self.expected_npv_aai[ + GROUP_COL_NAME + ].fillna("All") + expected_npv_df = self.expected_npv_aai + expected_npv_df = expected_npv_df[ + [ + GROUP_COL_NAME, + DATE_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + RISK_COL_NAME, + ] + ] + self.mock_snapshot1 = MagicMock(spec=Snapshot) + self.mock_snapshot1.date = datetime.date(2023, 1, 1) + + self.mock_snapshot2 = MagicMock(spec=Snapshot) + self.mock_snapshot2.date = datetime.date(2024, 1, 1) + + self.mock_snapshot3 = MagicMock(spec=Snapshot) + self.mock_snapshot3.date = datetime.date(2025, 1, 1) + + self.snapshots_list: list[Snapshot] = [ + self.mock_snapshot1, + self.mock_snapshot2, + self.mock_snapshot3, + ] + # self.snapshots_list = cast(list[Snapshot], self.snapshots_list) + + # Mock interpolation strategy and impact computation strategy + self.mock_interpolation_strategy = MagicMock(spec=AllLinearStrategy) + self.mock_impact_computation_strategy = MagicMock(spec=ImpactCalcComputation) + + # Mock DiscRates if needed for NPV tests + self.mock_disc_rates = MagicMock(spec=DiscRates) + self.mock_disc_rates.years = [2023, 2024, 2025] + self.mock_disc_rates.rates = [0.01, 0.02, 0.03] # Example rates + + self.mock_risk_period_calc1 = MagicMock(spec=CalcRiskMetricsPeriod) + self.mock_risk_period_calc2 = MagicMock(spec=CalcRiskMetricsPeriod) + # Mock npv_transform return value + self.mock_risk_period_calc1.calc_aai_metric.return_value = self.aai_dates1 + self.mock_risk_period_calc2.calc_aai_metric.return_value = self.aai_dates2 + self.mock_risk_metric_calculators = [ + self.mock_risk_period_calc1, + self.mock_risk_period_calc2, + ] + + self.mock_interpolated_risk_traj = MagicMock(spec=InterpolatedRiskTrajectory) + self.mock_interpolated_risk_traj._risk_metrics_calcultators = ( + self.mock_risk_metric_calculators + ) + self.mock_interpolated_risk_traj._risk_disc_rates = ( + self.mock_disc_rates + ) # For NPV transform check + + # --- Test Initialization and Properties --- + # These tests focus on the __init__ method and property getters/setters. + + ## Test `__init__` method + @patch.object( + InterpolatedRiskTrajectory, "_reset_risk_metrics_calculators", return_value=1 + ) + def test_init_basic(self, mock_reset_metrics_calculators): + # Test basic initialization with defaults + rt = InterpolatedRiskTrajectory( + self.snapshots_list, + interpolation_strategy=self.mock_interpolation_strategy, + impact_computation_strategy=self.mock_impact_computation_strategy, + ) + self.assertEqual(rt.start_date, self.mock_snapshot1.date) + self.assertEqual(rt.end_date, self.mock_snapshot3.date) + self.assertIsNone(rt._risk_disc_rates) + mock_reset_metrics_calculators.assert_called_once_with( + self.snapshots_list, + "Y", + self.mock_interpolation_strategy, + self.mock_impact_computation_strategy, + ) + self.assertEqual(rt._risk_metrics_calculators, 1) + # Check that metrics are reset (initially None) + for metric in InterpolatedRiskTrajectory.POSSIBLE_METRICS: + self.assertIsNone(getattr(rt, "_" + metric + "_metrics")) + + @patch.object( + InterpolatedRiskTrajectory, "_reset_risk_metrics_calculators", return_value=1 + ) + def test_init_with_custom_params(self, _): + # Test initialization with custom parameters + mock_disc = Mock(spec=DiscRates) + rt = InterpolatedRiskTrajectory( + self.snapshots_list, + time_resolution="MS", + all_groups_name="CustomAll", + risk_disc_rates=mock_disc, + interpolation_strategy=Mock(), + impact_computation_strategy=Mock(), + ) + self.assertEqual(rt._all_groups_name, "CustomAll") + self.assertEqual(rt._risk_disc_rates, mock_disc) + + @patch.object(InterpolatedRiskTrajectory, "_reset_risk_metrics_calculators") + @patch.object(InterpolatedRiskTrajectory, "_reset_metrics", new_callable=Mock) + @patch( + "climada.trajectories.interpolated_trajectory.CalcRiskMetricsPeriod", + autospec=True, + ) + def test_set_impact_computation_strategy( + self, + mock_calc_risk_metrics, + mock_reset_metrics, + mock_reset_risk_metrics_calculators, + ): + mock_reset_risk_metrics_calculators.return_value = ( + self.mock_risk_metric_calculators + ) + rt = InterpolatedRiskTrajectory( + self.snapshots_list, + interpolation_strategy=self.mock_interpolation_strategy, + impact_computation_strategy=self.mock_impact_computation_strategy, + ) + mock_reset_metrics.assert_called_once() # Called during init + with self.assertRaises(ValueError): + rt.impact_computation_strategy = "A" + + # There is only one possibility at the moment so we just check against a new object + new_impact_calc = ImpactCalcComputation() + rt.impact_computation_strategy = new_impact_calc + self.assertEqual(rt.impact_computation_strategy, new_impact_calc) + mock_reset_metrics.assert_has_calls([call(), call()]) + for rp in self.mock_risk_metric_calculators: + self.assertEqual(rp.impact_computation_strategy, new_impact_calc) + + @patch.object(InterpolatedRiskTrajectory, "_reset_risk_metrics_calculators") + @patch.object(InterpolatedRiskTrajectory, "_reset_metrics", new_callable=Mock) + @patch( + "climada.trajectories.interpolated_trajectory.CalcRiskMetricsPeriod", + autospec=True, + ) + def test_set_interpolation_strategy( + self, + mock_calc_risk_metrics, + mock_reset_metrics, + mock_reset_risk_metrics_calculators, + ): + mock_reset_risk_metrics_calculators.return_value = ( + self.mock_risk_metric_calculators + ) + rt = InterpolatedRiskTrajectory( + self.snapshots_list, + interpolation_strategy=self.mock_interpolation_strategy, + impact_computation_strategy=self.mock_impact_computation_strategy, + ) + mock_reset_metrics.assert_called_once() # Called during init + with self.assertRaises(ValueError): + rt.interpolation_strategy = "A" + + # There is only one possibility at the moment so we just check against a new object + new_interp = ExponentialExposureStrategy() + rt.interpolation_strategy = new_interp + self.assertEqual(rt.interpolation_strategy, new_interp) + mock_reset_metrics.assert_has_calls([call(), call()]) + for rp in self.mock_risk_metric_calculators: + self.assertEqual(rp.interpolation_strategy, new_interp) + + @patch( + "climada.trajectories.interpolated_trajectory.CalcRiskMetricsPeriod", + autospec=True, + ) + def test_risk_periods_lazy_computation(self, MockCalcRiskPeriod): + # Test that _calc_risk_periods is called only once, lazily + rt = InterpolatedRiskTrajectory( + self.snapshots_list, + interpolation_strategy=self.mock_interpolation_strategy, + impact_computation_strategy=self.mock_impact_computation_strategy, + ) + + # First access should trigger calculation + risk_periods = rt._risk_metrics_calculators + MockCalcRiskPeriod.assert_has_calls( + [ + call( + self.mock_snapshot1, + self.mock_snapshot2, + time_resolution="Y", + interpolation_strategy=self.mock_interpolation_strategy, + impact_computation_strategy=self.mock_impact_computation_strategy, + ), + call( + self.mock_snapshot2, + self.mock_snapshot3, + time_resolution="Y", + interpolation_strategy=self.mock_interpolation_strategy, + impact_computation_strategy=self.mock_impact_computation_strategy, + ), + ] + ) + self.assertEqual(MockCalcRiskPeriod.call_count, 2) + self.assertIsInstance(risk_periods, list) + self.assertEqual(len(risk_periods), 2) # N-1 periods for N snapshots + + @patch( + "climada.trajectories.interpolated_trajectory.CalcRiskMetricsPeriod", + autospec=True, + ) + def test_calc_risk_periods_sorting(self, MockCalcRiskPeriod): + # Test that snapshots are sorted by date before pairing + unsorted_snapshots: list[Snapshot] = [ + self.mock_snapshot3, + self.mock_snapshot1, + self.mock_snapshot2, + ] + _ = InterpolatedRiskTrajectory(unsorted_snapshots) + # Access the property to trigger calculation + MockCalcRiskPeriod.assert_has_calls( + [ + call( + self.mock_snapshot1, + self.mock_snapshot2, + **MockCalcRiskPeriod.call_args[1], + ), + call( + self.mock_snapshot2, + self.mock_snapshot3, + **MockCalcRiskPeriod.call_args[1], + ), + ] + ) + self.assertEqual(MockCalcRiskPeriod.call_count, 2) + + @patch.object(InterpolatedRiskTrajectory, "_reset_metrics", new_callable=Mock) + @patch( + "climada.trajectories.interpolated_trajectory.CalcRiskMetricsPeriod", + autospec=True, + ) + def test_set_time_resolution( + self, mock_calc_risk_metrics_points, mock_reset_metrics + ): + rt = InterpolatedRiskTrajectory( + self.snapshots_list, + impact_computation_strategy=self.mock_impact_computation_strategy, + ) + mock_reset_metrics.assert_called_once() # Called during init + with self.assertRaises(ValueError): + rt.time_resolution = 75 + + # There is only one possibility at the moment so we just check against a new object + rt.time_resolution = "5M" + self.assertEqual(rt.time_resolution, "5M") + mock_reset_metrics.assert_has_calls([call(), call()]) + + # --- Test Generic Metric Computation (`_generic_metrics`) --- + # This is a core internal method and deserves thorough testing. + + @patch.object( + InterpolatedRiskTrajectory, "_reset_risk_metrics_calculators", new_callable=Mock + ) + @patch.object(InterpolatedRiskTrajectory, "npv_transform", new_callable=Mock) + def test_generic_metrics_basic_flow( + self, mock_npv_transform, mock_risk_metrics_calculators + ): + mock_risk_metrics_calculators.return_value = self.mock_risk_metric_calculators + mock_npv_transform.return_value = self.expected_npv_aai + rt = InterpolatedRiskTrajectory(self.snapshots_list) + rt._risk_disc_rates = self.mock_disc_rates + result = rt._generic_metrics( + metric_name=AAI_METRIC_NAME, metric_meth="calc_aai_metric" + ) + # Assertions + self.mock_risk_period_calc1.calc_aai_metric.assert_called_once() + self.mock_risk_period_calc2.calc_aai_metric.assert_called_once() + + # Check concatenated DataFrame before NPV + # We need to manually recreate the expected intermediate DataFrame before NPV for assertion + # npv_transform should be called with the correctly formatted (concatenated and ordered) DataFrame + # and the risk_disc_rates attribute + mock_npv_transform.assert_called_once() + pd.testing.assert_frame_equal( + mock_npv_transform.call_args[0][0].reset_index(drop=True), + self.expected_pre_npv_aai.reset_index(drop=True), + ) + self.assertEqual(mock_npv_transform.call_args[0][1], self.mock_disc_rates) + + pd.testing.assert_frame_equal( + result, self.expected_npv_aai + ) # Final result is from NPV transform + + # Check internal storage + stored_df = getattr(rt, "_aai_metrics") + # Assert that the stored DF is the one *before* NPV transformation + pd.testing.assert_frame_equal( + stored_df.reset_index(drop=True), + self.expected_npv_aai.reset_index(drop=True), + ) + + result2 = rt._generic_metrics( + metric_name=AAI_METRIC_NAME, metric_meth="calc_aai_metric" + ) + # Check no new calls + self.mock_risk_period_calc1.calc_aai_metric.assert_called_once() + self.mock_risk_period_calc2.calc_aai_metric.assert_called_once() + pd.testing.assert_frame_equal( + result2, + self.expected_npv_aai.reset_index(drop=True), + ) + + @patch.object( + InterpolatedRiskTrajectory, "_reset_risk_metrics_calculators", new_callable=Mock + ) + def test_generic_metrics_not_implemented_error( + self, mock_reset_risk_metrics_calculators + ): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + with self.assertRaises(NotImplementedError): + rt._generic_metrics(metric_name="non_existent", metric_meth="some_method") + + @patch.object( + InterpolatedRiskTrajectory, "_reset_risk_metrics_calculators", new_callable=Mock + ) + def test_generic_metrics_value_error_no_name_or_method( + self, mock_reset_risk_metrics_calculators + ): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + with self.assertRaises(ValueError): + rt._generic_metrics(metric_name=None, metric_meth="some_method") + with self.assertRaises(ValueError): + rt._generic_metrics(metric_name=AAI_METRIC_NAME, metric_meth=None) + + @patch.object( + InterpolatedRiskTrajectory, "_reset_risk_metrics_calculators", new_callable=Mock + ) + # @patch.object(InterpolatedRiskTrajectory, "npv_transform", new_callable=Mock) + def test_generic_metrics_None_concat_returns_empty( + self, mock_reset_risk_metrics_calculators + ): + self.mock_risk_period_calc1.calc_aai_per_group_metric.return_value = None + self.mock_risk_period_calc2.calc_aai_per_group_metric.return_value = None + mock_reset_risk_metrics_calculators.return_value = ( + self.mock_risk_metric_calculators + ) + rt = InterpolatedRiskTrajectory(self.snapshots_list) + # rt = self.mock_interpolated_risk_traj + # Mock CalcRiskPeriod instances return None, mimicking `calc_aai_per_group_metric` possibly + + result = rt._generic_metrics( + metric_name=AAI_PER_GROUP_METRIC_NAME, + metric_meth="calc_aai_per_group_metric", + ) + pd.testing.assert_frame_equal(result, pd.DataFrame()) + + @patch.object( + InterpolatedRiskTrajectory, "_reset_risk_metrics_calculators", new_callable=Mock + ) + # @patch.object(InterpolatedRiskTrajectory, "npv_transform", new_callable=Mock) + def test_generic_metrics_empty_df_concat_returns_empty( + self, mock_reset_risk_metrics_calculators + ): + self.mock_risk_period_calc1.calc_aai_per_group_metric.return_value = ( + pd.DataFrame() + ) + self.mock_risk_period_calc2.calc_aai_per_group_metric.return_value = ( + pd.DataFrame() + ) + mock_reset_risk_metrics_calculators.return_value = ( + self.mock_risk_metric_calculators + ) + rt = InterpolatedRiskTrajectory(self.snapshots_list) + # rt = self.mock_interpolated_risk_traj + # Mock CalcRiskPeriod instances return None, mimicking `calc_aai_per_group_metric` possibly + + result = rt._generic_metrics( + metric_name=AAI_PER_GROUP_METRIC_NAME, + metric_meth="calc_aai_per_group_metric", + ) + pd.testing.assert_frame_equal(result, pd.DataFrame()) + + @patch.object( + InterpolatedRiskTrajectory, "_reset_risk_metrics_calculators", new_callable=Mock + ) + @patch.object( + InterpolatedRiskTrajectory, + "_risk_contributions_post_treatment", + new_callable=Mock, + ) + def test_generic_metrics_risk_contribution_treatment( + self, + mock_risk_contributions_post_treatment, + mock_reset_risk_metrics_calculators, + ): + mock_risk_contributions_post_treatment.return_value = pd.DataFrame([42]) + self.mock_risk_period_calc1.calc_risk_contributions_metric.return_value = ( + self.aai_dates1 + ) + self.mock_risk_period_calc2.calc_risk_contributions_metric.return_value = ( + self.aai_dates2 + ) + mock_reset_risk_metrics_calculators.return_value = ( + self.mock_risk_metric_calculators + ) + rt = InterpolatedRiskTrajectory(self.snapshots_list) + # rt = self.mock_interpolated_risk_traj + # Mock CalcRiskPeriod instances return None, mimicking `calc_aai_per_group_metric` possibly + result = rt._generic_metrics( + metric_name=CONTRIBUTIONS_METRIC_NAME, + metric_meth="calc_risk_contributions_metric", + ) + mock_risk_contributions_post_treatment.assert_called_once() + pd.testing.assert_frame_equal(result, pd.DataFrame([42])) + + @patch.object( + InterpolatedRiskTrajectory, "_reset_risk_metrics_calculators", new_callable=Mock + ) + @patch.object(InterpolatedRiskTrajectory, "npv_transform", new_callable=Mock) + def test_generic_metrics_coord_id_handling( + self, mock_npv_transform, mock_risk_metric_calc + ): + mock_risk_metric_calc.return_value = self.mock_risk_metric_calculators + self.mock_risk_period_calc1.calc_eai_gdf.return_value = pd.DataFrame( + { + DATE_COL_NAME: [pd.Timestamp("2023-01-01"), pd.Timestamp("2023-01-01")], + GROUP_COL_NAME: pd.Categorical([pd.NA, pd.NA]), + MEASURE_COL_NAME: ["MEAS1", "MEAS1"], + METRIC_COL_NAME: [EAI_METRIC_NAME, EAI_METRIC_NAME], + COORD_ID_COL_NAME: [1, 2], + RISK_COL_NAME: [10.0, 20.0], + } + ) + self.mock_risk_period_calc2.calc_eai_gdf.return_value = pd.DataFrame() + rt = InterpolatedRiskTrajectory(self.snapshots_list) + result = rt._generic_metrics( + metric_name=EAI_METRIC_NAME, metric_meth="calc_eai_gdf" + ) + + expected_df = pd.DataFrame( + { + GROUP_COL_NAME: pd.Categorical(["All", "All"]), + DATE_COL_NAME: [pd.Timestamp("2023-01-01"), pd.Timestamp("2023-01-01")], + MEASURE_COL_NAME: ["MEAS1", "MEAS1"], + METRIC_COL_NAME: [EAI_METRIC_NAME, EAI_METRIC_NAME], + RISK_COL_NAME: [10.0, 20.0], + COORD_ID_COL_NAME: [ + 1, + 2, + ], # This column should remain and be placed at the end before risk if not in front_columns + } + ) + # The internal logic reorders columns, ensure it matches + cols_order = [ + DATE_COL_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + COORD_ID_COL_NAME, + RISK_COL_NAME, + ] + pd.testing.assert_frame_equal(result[cols_order], expected_df[cols_order]) + + # --- Test Specific Metric Methods (e.g., `eai_metrics`, `aai_metrics`) --- + # These are mostly thin wrappers around _compute_metrics/_generic_metrics. + # Focus on ensuring they call _compute_metrics with the correct arguments. + + @patch.object(InterpolatedRiskTrajectory, "_compute_metrics") + def test_eai_metrics(self, mock_compute_metrics): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + rt.eai_metrics(npv=True, some_arg="test") + mock_compute_metrics.assert_called_once_with( + npv=True, + metric_name=EAI_METRIC_NAME, + metric_meth="calc_eai_gdf", + some_arg="test", + ) + + @patch.object(InterpolatedRiskTrajectory, "_compute_metrics") + def test_aai_metrics(self, mock_compute_metrics): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + rt.aai_metrics(other_arg=123) + mock_compute_metrics.assert_called_once_with( + metric_name=AAI_METRIC_NAME, metric_meth="calc_aai_metric", other_arg=123 + ) + + @patch.object(InterpolatedRiskTrajectory, "_compute_metrics") + def test_return_periods_metrics(self, mock_compute_metrics): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + rt.return_periods_metrics(npv=True, rp_arg="xyz") + mock_compute_metrics.assert_called_once_with( + npv=True, + metric_name=RETURN_PERIOD_METRIC_NAME, + metric_meth="calc_return_periods_metric", + return_periods=rt.return_periods, + rp_arg="xyz", + ) + + @patch.object(InterpolatedRiskTrajectory, "_compute_metrics") + def test_aai_per_group_metrics(self, mock_compute_metrics): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + rt.aai_per_group_metrics() + mock_compute_metrics.assert_called_once_with( + metric_name=AAI_PER_GROUP_METRIC_NAME, + metric_meth="calc_aai_per_group_metric", + ) + + @patch.object(InterpolatedRiskTrajectory, "_compute_metrics") + def test_risk_components_metrics(self, mock_compute_metrics): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + rt.risk_contributions_metrics() + mock_compute_metrics.assert_called_once_with( + metric_name=CONTRIBUTIONS_METRIC_NAME, + metric_meth="calc_risk_contributions_metric", + ) + + ## Test `npv_transform` (class method) + def test_npv_transform_no_group_col(self): + df_input = pd.DataFrame( + { + DATE_COL_NAME: pd.to_datetime(["2023-01-01", "2024-01-01"] * 2), + MEASURE_COL_NAME: ["m1", "m1", "m2", "m2"], + METRIC_COL_NAME: [ + AAI_METRIC_NAME, + AAI_METRIC_NAME, + AAI_METRIC_NAME, + AAI_METRIC_NAME, + ], + RISK_COL_NAME: [100.0, 200.0, 80.0, 180.0], + } + ) + # Mock the internal calc_npv_cash_flows + with patch( + "climada.trajectories.trajectory.RiskTrajectory._calc_npv_cash_flows" + ) as mock_calc_npv: + # For each group, it will be called + mock_calc_npv.side_effect = [ + pd.Series( + [100.0 * (1 / (1 + 0.01)) ** 0, 200.0 * (1 / (1 + 0.02)) ** 1], + index=[pd.Timestamp("2023-01-01"), pd.Timestamp("2024-01-01")], + ), + pd.Series( + [80.0 * (1 / (1 + 0.01)) ** 0, 180.0 * (1 / (1 + 0.02)) ** 1], + index=[pd.Timestamp("2023-01-01"), pd.Timestamp("2024-01-01")], + ), + ] + result_df = InterpolatedRiskTrajectory.npv_transform( + df_input.copy(), self.mock_disc_rates + ) + # Assertions for mock calls + # Grouping by 'measure', 'metric' (default _grouper) + pd.testing.assert_series_equal( + mock_calc_npv.mock_calls[0].args[0], + pd.Series( + [100.0, 200.0], + index=pd.Index( + [ + pd.Timestamp("2023-01-01"), + pd.Timestamp("2024-01-01"), + ], + name=DATE_COL_NAME, + ), + name=("m1", AAI_METRIC_NAME), + ), + ) + assert mock_calc_npv.mock_calls[0].args[1] == pd.Timestamp("2023-01-01") + assert mock_calc_npv.mock_calls[0].args[2] == self.mock_disc_rates + pd.testing.assert_series_equal( + mock_calc_npv.mock_calls[1].args[0], + pd.Series( + [80.0, 180.0], + index=pd.Index( + [ + pd.Timestamp("2023-01-01"), + pd.Timestamp("2024-01-01"), + ], + name=DATE_COL_NAME, + ), + name=("m2", AAI_METRIC_NAME), + ), + ) + assert mock_calc_npv.mock_calls[1].args[1] == pd.Timestamp("2023-01-01") + assert mock_calc_npv.mock_calls[1].args[2] == self.mock_disc_rates + + expected_df = pd.DataFrame( + { + DATE_COL_NAME: pd.to_datetime(["2023-01-01", "2024-01-01"] * 2), + MEASURE_COL_NAME: ["m1", "m1", "m2", "m2"], + METRIC_COL_NAME: [ + AAI_METRIC_NAME, + AAI_METRIC_NAME, + AAI_METRIC_NAME, + AAI_METRIC_NAME, + ], + RISK_COL_NAME: [ + 100.0 * (1 / (1 + 0.01)) ** 0, + 200.0 * (1 / (1 + 0.02)) ** 1, + 80.0 * (1 / (1 + 0.01)) ** 0, + 180.0 * (1 / (1 + 0.02)) ** 1, + ], + } + ) + pd.testing.assert_frame_equal( + result_df.sort_values(DATE_COL_NAME).reset_index(drop=True), + expected_df.sort_values(DATE_COL_NAME).reset_index(drop=True), + rtol=1e-6, + ) + + def test_npv_transform_with_group_col(self): + df_input = pd.DataFrame( + { + DATE_COL_NAME: pd.to_datetime( + ["2023-01-01", "2024-01-01", "2023-01-01"] + ), + GROUP_COL_NAME: ["G1", "G1", "G2"], + MEASURE_COL_NAME: ["m1", "m1", "m1"], + METRIC_COL_NAME: [AAI_METRIC_NAME, AAI_METRIC_NAME, AAI_METRIC_NAME], + RISK_COL_NAME: [100.0, 200.0, 150.0], + } + ) + with patch( + "climada.trajectories.trajectory.RiskTrajectory._calc_npv_cash_flows" + ) as mock_calc_npv: + mock_calc_npv.side_effect = [ + # First group G1, m1, aai + pd.Series( + [100.0 * (1 / (1 + 0.01)) ** 0, 200.0 * (1 / (1 + 0.02)) ** 1], + index=[pd.Timestamp("2023-01-01"), pd.Timestamp("2024-01-01")], + ), + # Second group G2, m1, aai + pd.Series( + [150.0 * (1 / (1 + 0.01)) ** 0], index=[pd.Timestamp("2023-01-01")] + ), + ] + result_df = InterpolatedRiskTrajectory.npv_transform( + df_input.copy(), self.mock_disc_rates + ) + + expected_df = pd.DataFrame( + { + DATE_COL_NAME: pd.to_datetime( + ["2023-01-01", "2024-01-01", "2023-01-01"] + ), + GROUP_COL_NAME: ["G1", "G1", "G2"], + MEASURE_COL_NAME: ["m1", "m1", "m1"], + METRIC_COL_NAME: [ + AAI_METRIC_NAME, + AAI_METRIC_NAME, + AAI_METRIC_NAME, + ], + RISK_COL_NAME: [ + 100.0 * (1 / (1 + 0.01)) ** 0, + 200.0 * (1 / (1 + 0.02)) ** 1, + 150.0 * (1 / (1 + 0.01)) ** 0, + ], + } + ) + pd.testing.assert_frame_equal( + result_df.sort_values([GROUP_COL_NAME, DATE_COL_NAME]).reset_index( + drop=True + ), + expected_df.sort_values([GROUP_COL_NAME, DATE_COL_NAME]).reset_index( + drop=True + ), + rtol=1e-6, + ) + + @patch.object(InterpolatedRiskTrajectory, "_generic_metrics") + @patch.object(InterpolatedRiskTrajectory, "_date_to_period_agg") + def test_compute_period_metrics(self, mock_date_to_period, mock_generic_metrics): + mock_date_to_period.return_value = 42 + mock_generic_metrics.return_value = 46 + rt = InterpolatedRiskTrajectory(self.snapshots_list) + result = rt._compute_period_metrics("name", "method", other_args=5) + mock_generic_metrics.assert_called_once_with( + metric_name="name", metric_meth="method", other_args=5 + ) + mock_date_to_period.assert_called_once_with(46, grouper=rt._grouper) + self.assertEqual(result, 42) + + def test_risk_contributions_post_treatment(self): + # Create a sample DataFrame + data = { + GROUP_COL_NAME: ["All"] * 15, + DATE_COL_NAME: [ + pd.Period("2023-01-01", freq="Y"), + pd.Period("2024-01-02", freq="Y"), + pd.Period("2025-01-02", freq="Y"), + ] + * 5, + MEASURE_COL_NAME: ["measure1"] * 15, + METRIC_COL_NAME: [ + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + ], + RISK_COL_NAME: [100, 100, 195, 0, 50, 100, 0, 10, 20, 0, 5, 10, 0, 30, 60], + } + df = pd.DataFrame(data) + + # Call the method + rt = InterpolatedRiskTrajectory(self.snapshots_list) + result_df = rt._risk_contributions_post_treatment(df) + + # Expected output + expected_data = { + DATE_COL_NAME: [ + pd.Period("2023-01-01", freq="Y"), + pd.Period("2024-01-02", freq="Y"), + pd.Period("2025-01-02", freq="Y"), + ] + * 5, + GROUP_COL_NAME: ["All"] * 15, + MEASURE_COL_NAME: ["measure1"] * 15, + METRIC_COL_NAME: [ + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + ], + RISK_COL_NAME: [100, 100, 100, 0, 50, 150, 0, 10, 30, 0, 5, 15, 0, 30, 90], + } + expected_df = pd.DataFrame(expected_data) + + # Assert the result + pd.testing.assert_frame_equal( + result_df.reset_index(drop=True), expected_df.reset_index(drop=True) + ) + + # --- Test Per Period Risk Aggregation (`_per_period_risk`) --- + def test_per_period_risk_basic(self): + df_input = pd.DataFrame( + { + DATE_COL_NAME: pd.to_datetime( + ["2023-01-01", "2024-01-01", "2025-01-01", "2023-01-01"] + ), + GROUP_COL_NAME: ["All", "All", "All", "GroupB"], + MEASURE_COL_NAME: ["m1", "m1", "m1", "m1"], + METRIC_COL_NAME: [ + AAI_METRIC_NAME, + AAI_METRIC_NAME, + AAI_METRIC_NAME, + AAI_METRIC_NAME, + ], + RISK_COL_NAME: [100.0, 200.0, 300.0, 50.0], + } + ) + result_df = InterpolatedRiskTrajectory._date_to_period_agg( + df_input, grouper=InterpolatedRiskTrajectory._grouper + ) + + expected_df = pd.DataFrame( + { + PERIOD_COL_NAME: [ + "2023-01-01 to 2025-01-01", + "2023-01-01 to 2023-01-01", + ], + GROUP_COL_NAME: ["All", "GroupB"], + MEASURE_COL_NAME: ["m1", "m1"], + METRIC_COL_NAME: [AAI_METRIC_NAME, AAI_METRIC_NAME], + RISK_COL_NAME: [200.0, 50.0], # 100+200+300 for 'All', 50 for 'GroupB' + } + ) + # Sorting for comparison consistency + pd.testing.assert_frame_equal( + result_df.sort_values([GROUP_COL_NAME, PERIOD_COL_NAME]).reset_index( + drop=True + ), + expected_df.sort_values([GROUP_COL_NAME, PERIOD_COL_NAME]).reset_index( + drop=True + ), + ) + + def test_per_period_risk_multiple_risk_cols(self): + df_input = pd.DataFrame( + { + DATE_COL_NAME: pd.to_datetime(["2023-01-01", "2024-01-01"]), + GROUP_COL_NAME: ["All", "All"], + MEASURE_COL_NAME: ["m1", "m1"], + METRIC_COL_NAME: ["risk_components", "risk_components"], + CONTRIBUTION_BASE_RISK_NAME: [10.0, 20.0], + CONTRIBUTION_EXPOSURE_NAME: [5.0, 8.0], + } + ) + result_df = InterpolatedRiskTrajectory._date_to_period_agg( + df_input, + grouper=InterpolatedRiskTrajectory._grouper, + colname=[CONTRIBUTION_BASE_RISK_NAME, CONTRIBUTION_EXPOSURE_NAME], + ) + + expected_df = pd.DataFrame( + { + PERIOD_COL_NAME: ["2023-01-01 to 2024-01-01"], + GROUP_COL_NAME: ["All"], + MEASURE_COL_NAME: ["m1"], + METRIC_COL_NAME: ["risk_components"], + CONTRIBUTION_BASE_RISK_NAME: [15.0], + CONTRIBUTION_EXPOSURE_NAME: [6.5], + } + ) + pd.testing.assert_frame_equal(result_df, expected_df) + + def test_per_period_risk_non_yearly_intervals(self): + df_input = pd.DataFrame( + { + DATE_COL_NAME: pd.to_datetime( + ["2023-01-01", "2023-02-01", "2023-03-01"] + ), + GROUP_COL_NAME: ["All", "All", "All"], + MEASURE_COL_NAME: ["m1", "m1", "m1"], + METRIC_COL_NAME: [AAI_METRIC_NAME, AAI_METRIC_NAME, AAI_METRIC_NAME], + RISK_COL_NAME: [10.0, 20.0, 30.0], + } + ) + # Test with 'month' time_unit + result_df_month = InterpolatedRiskTrajectory._date_to_period_agg( + df_input, grouper=InterpolatedRiskTrajectory._grouper, time_unit="month" + ) + expected_df_month = pd.DataFrame( + { + PERIOD_COL_NAME: ["2023-01-01 to 2023-03-01"], + GROUP_COL_NAME: ["All"], + MEASURE_COL_NAME: ["m1"], + METRIC_COL_NAME: [AAI_METRIC_NAME], + RISK_COL_NAME: [20.0], + } + ) + pd.testing.assert_frame_equal(result_df_month, expected_df_month) + + # Introduce a gap for 'month' time_unit + df_gap = pd.DataFrame( + { + DATE_COL_NAME: pd.to_datetime( + ["2023-01-01", "2023-02-01", "2023-04-01"] + ), # Gap in March + GROUP_COL_NAME: ["All", "All", "All"], + MEASURE_COL_NAME: ["m1", "m1", "m1"], + METRIC_COL_NAME: [AAI_METRIC_NAME, AAI_METRIC_NAME, AAI_METRIC_NAME], + RISK_COL_NAME: [10.0, 20.0, 40.0], + } + ) + result_df_gap = InterpolatedRiskTrajectory._date_to_period_agg( + df_gap, grouper=InterpolatedRiskTrajectory._grouper, time_unit="month" + ) + expected_df_gap = pd.DataFrame( + { + PERIOD_COL_NAME: [ + "2023-01-01 to 2023-02-01", + "2023-04-01 to 2023-04-01", + ], + GROUP_COL_NAME: ["All", "All"], + MEASURE_COL_NAME: ["m1", "m1"], + METRIC_COL_NAME: [AAI_METRIC_NAME, AAI_METRIC_NAME], + RISK_COL_NAME: [15.0, 40.0], + } + ) + pd.testing.assert_frame_equal( + result_df_gap.sort_values(PERIOD_COL_NAME).reset_index(drop=True), + expected_df_gap.sort_values(PERIOD_COL_NAME).reset_index(drop=True), + ) + + # --- Test Combined Metrics (`per_date_risk_metrics`, `per_period_risk_metrics`) --- + + @patch.object(InterpolatedRiskTrajectory, "aai_metrics") + @patch.object(InterpolatedRiskTrajectory, "return_periods_metrics") + @patch.object(InterpolatedRiskTrajectory, "aai_per_group_metrics") + def test_per_date_risk_metrics_defaults( + self, mock_aai_per_group, mock_return_periods, mock_aai + ): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + # Set up mock return values for each method + mock_aai.return_value = pd.DataFrame( + {METRIC_COL_NAME: [AAI_METRIC_NAME], RISK_COL_NAME: [100]} + ) + mock_return_periods.return_value = pd.DataFrame( + {METRIC_COL_NAME: ["rp"], RISK_COL_NAME: [50]} + ) + mock_aai_per_group.return_value = pd.DataFrame( + {METRIC_COL_NAME: ["aai_grp"], RISK_COL_NAME: [10]} + ) + + result = rt.per_date_risk_metrics() + + # Assert calls with default arguments + mock_aai.assert_called_once_with() + mock_return_periods.assert_called_once_with() + mock_aai_per_group.assert_called_once_with() + + # Assert concatenation + expected_df = pd.concat( + [ + mock_aai.return_value, + mock_return_periods.return_value, + mock_aai_per_group.return_value, + ] + ) + pd.testing.assert_frame_equal( + result.reset_index(drop=True), expected_df.reset_index(drop=True) + ) + + @patch.object(InterpolatedRiskTrajectory, "aai_metrics") + @patch.object(InterpolatedRiskTrajectory, "return_periods_metrics") + @patch.object(InterpolatedRiskTrajectory, "aai_per_group_metrics") + def test_per_date_risk_metrics_custom_metrics_and_rps( + self, mock_aai_per_group, mock_return_periods, mock_aai + ): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + mock_aai.return_value = pd.DataFrame( + {METRIC_COL_NAME: [AAI_METRIC_NAME], RISK_COL_NAME: [100]} + ) + mock_return_periods.return_value = pd.DataFrame( + {METRIC_COL_NAME: ["rp"], RISK_COL_NAME: [50]} + ) + + custom_metrics = [AAI_METRIC_NAME, RETURN_PERIOD_METRIC_NAME] + result = rt.per_date_risk_metrics(metrics=custom_metrics) + + mock_aai.assert_called_once_with() + mock_return_periods.assert_called_once_with() + mock_aai_per_group.assert_not_called() # Not in custom_metrics + + expected_df = pd.concat( + [mock_aai.return_value, mock_return_periods.return_value] + ) + pd.testing.assert_frame_equal( + result.reset_index(drop=True), expected_df.reset_index(drop=True) + ) + + @patch.object(InterpolatedRiskTrajectory, "per_date_risk_metrics") + @patch.object(InterpolatedRiskTrajectory, "_date_to_period_agg") + def test_per_period_risk_metrics( + self, mock_per_period_risk, mock_per_date_risk_metrics + ): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + mock_date_df = pd.DataFrame( + {METRIC_COL_NAME: [AAI_METRIC_NAME], RISK_COL_NAME: [100]} + ) + mock_per_date_risk_metrics.return_value = mock_date_df + mock_per_period_risk.return_value = pd.DataFrame( + {PERIOD_COL_NAME: ["P1"], RISK_COL_NAME: [200]} + ) + + test_metrics = [AAI_METRIC_NAME] + result = rt.per_period_risk_metrics(metrics=test_metrics, time_unit="month") + + mock_per_date_risk_metrics.assert_called_once_with( + metrics=test_metrics, time_unit="month" + ) + mock_per_period_risk.assert_called_once_with( + mock_date_df, grouper=rt._grouper + [UNIT_COL_NAME], time_unit="month" + ) + pd.testing.assert_frame_equal(result, mock_per_period_risk.return_value) + + # --- Test Plotting Related Methods --- + # These methods primarily generate data for plotting or call plotting functions. + # The actual plotting logic (matplotlib.pyplot calls) should be mocked. + + @patch.object(InterpolatedRiskTrajectory, "risk_contributions_metrics") + def test_calc_waterfall_plot_data(self, mock_risk_contributions_metrics): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + rt.start_date = datetime.date(2023, 1, 1) + rt.end_date = datetime.date(2025, 1, 1) + + # Mock the return of risk_components_metrics + mock_risk_contributions_metrics.return_value = pd.DataFrame( + { + DATE_COL_NAME: pd.to_datetime( + ["2023-01-01"] * 5 + + ["2024-01-01"] * 5 + + ["2025-01-01"] * 5 + + ["2026-01-01"] * 5 + ), + METRIC_COL_NAME: [ + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + ] + * 4, + RISK_COL_NAME: np.arange(20) + * 1.0, # Dummy data for different components and dates + } + ) # .pivot_table(index=DATE_COL_NAME, columns=METRIC_COL_NAME, values=RISK_COL_NAME) + # Flattened for simplicity, in reality it's more structured + + result = rt._calc_waterfall_plot_data( + start_date=datetime.date(2024, 1, 1), + end_date=datetime.date(2025, 1, 1), + ) + + mock_risk_contributions_metrics.assert_called_once_with() + + # Expected output should be filtered by date and unstacked + expected_df = pd.DataFrame( + { + DATE_COL_NAME: pd.to_datetime(["2024-01-01"] * 5 + ["2025-01-01"] * 5), + METRIC_COL_NAME: [ + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + ] + * 2, + RISK_COL_NAME: np.array([5.0, 6, 7, 8, 9, 10, 11, 12, 13, 14]), + } + ).pivot_table( + index=DATE_COL_NAME, columns=METRIC_COL_NAME, values=RISK_COL_NAME + ) + pd.testing.assert_frame_equal( + result.sort_index(axis=1), expected_df.sort_index(axis=1) + ) # Sort columns for stable comparison + + @patch("matplotlib.pyplot.subplots") + @patch("matplotlib.dates.AutoDateLocator") + @patch("matplotlib.dates.ConciseDateFormatter") + @patch.object(InterpolatedRiskTrajectory, "_calc_waterfall_plot_data") + def test_plot_per_date_waterfall( + self, mock_calc_data, mock_formatter, mock_locator, mock_subplots + ): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + rt.start_date = datetime.date(2023, 1, 1) + rt.end_date = datetime.date(2023, 1, 2) + + # Mock matplotlib objects + mock_ax = Mock() + mock_fig = Mock() + mock_subplots.return_value = (mock_fig, mock_ax) + mock_ax.get_ylim.return_value = (0, 100) # For ylim scaling + + # Mock data returned by _calc_waterfall_plot_data + mock_df_data = pd.DataFrame( + { + CONTRIBUTION_BASE_RISK_NAME: [10, 10], + CONTRIBUTION_EXPOSURE_NAME: [2, 3], + CONTRIBUTION_HAZARD_NAME: [5, 6], + CONTRIBUTION_VULNERABILITY_NAME: [1, 2], + CONTRIBUTION_INTERACTION_TERM_NAME: [0.5, 0.7], + }, + index=pd.period_range(start="2023-01-01", end="2023-01-02", freq="D"), + ) + mock_calc_data.return_value = mock_df_data + + # Call the method + fig, ax = rt.plot_time_waterfall() + + # Assertions + mock_calc_data.assert_called_once_with( + start_date=datetime.date(2023, 1, 1), + end_date=datetime.date(2023, 1, 2), + ) + mock_ax.stackplot.assert_called_once() + self.assertEqual( + mock_ax.stackplot.call_args[0][0].tolist(), + mock_df_data.index.to_timestamp().tolist(), # type: ignore + ) # Check x-axis data + self.assertEqual( + mock_ax.stackplot.call_args[0][1][0].tolist(), + mock_df_data[CONTRIBUTION_BASE_RISK_NAME].tolist(), + ) # Check first stacked data + mock_ax.set_title.assert_called_once_with( + "Risk between 2023-01-01 and 2023-01-02 (Average impact)" + ) + mock_ax.set_ylabel.assert_called_once_with("USD") + mock_ax.set_ylim.assert_called_once() # Check ylim was set + mock_ax.xaxis.set_major_locator.assert_called_once() + mock_ax.xaxis.set_major_formatter.assert_called_once() + self.assertEqual(fig, mock_fig) + self.assertEqual(ax, mock_ax) + + @patch("matplotlib.pyplot.subplots") + @patch.object(InterpolatedRiskTrajectory, "_calc_waterfall_plot_data") + def test_plot_waterfall(self, mock_calc_data, mock_subplots): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + rt.start_date = datetime.date(2023, 1, 1) + rt.end_date = datetime.date(2024, 1, 1) + + mock_ax = Mock() + mock_fig = Mock() + mock_subplots.return_value = (mock_fig, mock_ax) + mock_ax.get_ylim.return_value = (0, 100) + + # Mock _calc_waterfall_plot_data to return a DataFrame for two dates, + # where the second date (end_date) is relevant for plot_waterfall + start_date = "2023-01-01" + end_date = "2024-01-01" + mock_data = pd.DataFrame( + { + DATE_COL_NAME: pd.to_datetime([start_date] * 5 + [end_date] * 5), + METRIC_COL_NAME: [ + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + ] + * 2, + RISK_COL_NAME: [ + 10, + 2, + 5, + 1, + 0.5, + 15, + 3, + 7, + 2, + 1, + ], # values for 2023-01-01 and 2024-01-01 + } + ).pivot_table( + index=DATE_COL_NAME, columns=METRIC_COL_NAME, values=RISK_COL_NAME + ) + mock_calc_data.return_value = mock_data + # Call the method + ax = rt.plot_waterfall() + + # Assertions + mock_calc_data.assert_called_once_with( + start_date=datetime.date.fromisoformat(start_date), + end_date=datetime.date.fromisoformat(end_date), + ) + mock_ax.bar.assert_called_once() + # Verify the bar arguments are correct for the end_date data + end_date_data = mock_data.loc[pd.Timestamp(end_date)] + expected_values = [ + end_date_data[CONTRIBUTION_BASE_RISK_NAME], + end_date_data[CONTRIBUTION_EXPOSURE_NAME], + end_date_data[CONTRIBUTION_HAZARD_NAME], + end_date_data[CONTRIBUTION_VULNERABILITY_NAME], + end_date_data[CONTRIBUTION_INTERACTION_TERM_NAME], + end_date_data.sum(), + ] + # Compare values passed to bar + np.testing.assert_allclose(mock_ax.bar.call_args[0][1], expected_values) + start_date_p = pd.to_datetime(start_date).to_period(rt.time_resolution) + end_date_p = pd.to_datetime(end_date).to_period(rt.time_resolution) + mock_ax.set_title.assert_called_once_with( + f"Evolution of the contributions of risk between {start_date_p} and {end_date_p} (Average impact)" + ) + mock_ax.set_ylabel.assert_called_once_with("USD") + mock_ax.set_ylim.assert_called_once() + mock_ax.tick_params.assert_called_once_with(axis="x", labelrotation=90) + self.assertEqual(ax, mock_ax) + + # --- Test Private Helper Methods (`_reset_metrics`, `_get_risk_periods`) --- + + def test_reset_metrics(self): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + # Set some metrics to non-None values + rt._eai_metrics = "dummy_eai" # type:ignore + rt._aai_metrics = "dummy_aai" # type:ignore + rt._reset_metrics() + + for metric in rt.POSSIBLE_METRICS: + self.assertIsNone(getattr(rt, "_" + metric + "_metrics")) + + def test_get_risk_periods(self): + # Create dummy CalcRiskPeriod mocks with specific dates + mock_rp1 = Mock() + mock_rp1.snapshot_start.date = datetime.date(2020, 1, 1) + mock_rp1.snapshot_end.date = datetime.date(2021, 1, 1) + + mock_rp2 = Mock() + mock_rp2.snapshot_start.date = datetime.date(2021, 1, 1) + mock_rp2.snapshot_end.date = datetime.date(2022, 1, 1) + + mock_rp3 = Mock() + mock_rp3.snapshot_start.date = datetime.date(2022, 1, 1) + mock_rp3.snapshot_end.date = datetime.date(2023, 1, 1) + + all_risk_periods: list[CalcRiskMetricsPeriod] = [mock_rp1, mock_rp2, mock_rp3] + + # Strict case + + # Test case 1: Full range, all periods included + result = InterpolatedRiskTrajectory._get_risk_periods( + all_risk_periods, datetime.date(2020, 1, 1), datetime.date(2023, 1, 1) + ) + self.assertEqual(len(result), 3) + self.assertListEqual(result, all_risk_periods) + + # Test case 1b: More than full range, all periods included + result = InterpolatedRiskTrajectory._get_risk_periods( + all_risk_periods, datetime.date(2018, 1, 1), datetime.date(2024, 1, 1) + ) + self.assertEqual(len(result), 3) + self.assertListEqual(result, all_risk_periods) + + # Test case 2: Range including some period + result = InterpolatedRiskTrajectory._get_risk_periods( + all_risk_periods, datetime.date(2021, 1, 1), datetime.date(2023, 1, 1) + ) + self.assertEqual(len(result), 2) + self.assertListEqual(result, all_risk_periods[1:]) + + # Test case 2: Range including no period + result = InterpolatedRiskTrajectory._get_risk_periods( + all_risk_periods, datetime.date(2021, 6, 1), datetime.date(2022, 6, 1) + ) + self.assertEqual(len(result), 0) + self.assertListEqual(result, []) + + # Overlap case + + # Test case 1: Full range, all periods included (should still work) + result = InterpolatedRiskTrajectory._get_risk_periods( + all_risk_periods, + datetime.date(2020, 1, 1), + datetime.date(2023, 1, 1), + strict=False, + ) + self.assertEqual(len(result), 3) + self.assertListEqual(result, all_risk_periods) + + # Test case 1b: More than full range, all periods included + result = InterpolatedRiskTrajectory._get_risk_periods( + all_risk_periods, + datetime.date(2018, 1, 1), + datetime.date(2024, 1, 1), + strict=False, + ) + self.assertEqual(len(result), 3) + self.assertListEqual(result, all_risk_periods) + + # Test case 2: Range including some period + result = InterpolatedRiskTrajectory._get_risk_periods( + all_risk_periods, + datetime.date(2021, 1, 1), + datetime.date(2023, 1, 1), + strict=False, + ) + self.assertEqual(len(result), 2) + self.assertListEqual(result, all_risk_periods[1:]) + + # Test case 2: Range including no period but overlap + result = InterpolatedRiskTrajectory._get_risk_periods( + all_risk_periods, + datetime.date(2021, 6, 1), + datetime.date(2022, 6, 1), + strict=False, + ) + self.assertEqual(len(result), 2) + self.assertListEqual(result, all_risk_periods[1:]) + + # Test case 2: Range including no period at all + result = InterpolatedRiskTrajectory._get_risk_periods( + all_risk_periods, + datetime.date(2024, 6, 1), + datetime.date(2026, 6, 1), + strict=False, + ) + self.assertEqual(len(result), 0) + self.assertListEqual(result, []) + + +if __name__ == "__main__": + TESTS = unittest.TestLoader().loadTestsFromTestCase(TestInterpolatedRiskTrajectory) + unittest.TextTestRunner(verbosity=2).run(TESTS) diff --git a/climada/trajectories/test/test_interpolation.py b/climada/trajectories/test/test_interpolation.py new file mode 100644 index 0000000000..693c9b9c33 --- /dev/null +++ b/climada/trajectories/test/test_interpolation.py @@ -0,0 +1,352 @@ +""" +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 . + +--- + +Tests for interpolation + +""" + +import unittest +from unittest.mock import MagicMock + +import numpy as np +from scipy.sparse import csr_matrix + +from climada.trajectories.interpolation import ( + AllLinearStrategy, + ExponentialExposureStrategy, + InterpolationStrategy, + exponential_interp_arrays, + exponential_interp_imp_mat, + linear_interp_arrays, + linear_interp_imp_mat, +) + + +class TestInterpolationFuncs(unittest.TestCase): + def setUp(self): + # Create mock impact matrices for testing + self.imp_mat0 = csr_matrix(np.array([[1, 2], [3, 4]])) + self.imp_mat1 = csr_matrix(np.array([[5, 6], [7, 8]])) + self.imp_mat2 = csr_matrix(np.array([[5, 6, 7], [8, 9, 10]])) # Different shape + self.time_points = 5 + self.interpolation_range_5 = 5 + self.interpolation_range_1 = 1 + self.interpolation_range_2 = 2 + self.rtol = 1e-5 + self.atol = 1e-8 + + def test_linear_interp_arrays(self): + arr_start = np.array([10, 100]) + arr_end = np.array([20, 200]) + expected = np.array([10.0, 200.0]) + result = linear_interp_arrays(arr_start, arr_end) + np.testing.assert_allclose(result, expected, rtol=self.rtol, atol=self.atol) + + def test_linear_interp_arrays2D(self): + arr_start = np.array([[10, 100], [10, 100]]) + arr_end = np.array([[20, 200], [20, 200]]) + expected = np.array([[10.0, 100.0], [20, 200]]) + result = linear_interp_arrays(arr_start, arr_end) + np.testing.assert_allclose(result, expected, rtol=self.rtol, atol=self.atol) + + def test_linear_interp_arrays_shape(self): + arr_start = np.array([10, 100, 5]) + arr_end = np.array([20, 200]) + with self.assertRaises(ValueError): + linear_interp_arrays(arr_start, arr_end) + + def test_linear_interp_arrays_start_equals_end(self): + arr_start = np.array([5, 5]) + arr_end = np.array([5, 5]) + expected = np.array([5.0, 5.0]) + result = linear_interp_arrays(arr_start, arr_end) + np.testing.assert_allclose(result, expected, rtol=self.rtol, atol=self.atol) + + def test_exponential_interp_arrays_1d(self): + arr_start = np.array([1, 10, 100]) + arr_end = np.array([2, 20, 200]) + expected = np.array([1.0, 14.142136, 200.0]) + result = exponential_interp_arrays(arr_start, arr_end) + np.testing.assert_allclose(result, expected, rtol=self.rtol, atol=self.atol) + + def test_exponential_interp_arrays_shape(self): + arr_start = np.array([10, 100, 5]) + arr_end = np.array([20, 200]) + with self.assertRaises(ValueError): + exponential_interp_arrays(arr_start, arr_end) + + def test_exponential_interp_arrays_2d(self): + arr_start = np.array( + [ + [1, 10, 100], # date 1 metric a,b,c + [1, 10, 100], # date 2 metric a,b,c + [1, 10, 100], + ] + ) # date 3 metric a,b,c + arr_end = np.array([[2, 20, 200], [2, 20, 200], [2, 20, 200]]) + expected = np.array( + [[1.0, 10.0, 100.0], [1.4142136, 14.142136, 141.42136], [2, 20, 200]] + ) + result = exponential_interp_arrays(arr_start, arr_end) + np.testing.assert_allclose(result, expected, rtol=self.rtol, atol=self.atol) + + def test_exponential_interp_arrays_start_equals_end(self): + arr_start = np.array([5, 5]) + arr_end = np.array([5, 5]) + expected = np.array([5.0, 5.0]) + result = exponential_interp_arrays(arr_start, arr_end) + np.testing.assert_allclose(result, expected, rtol=self.rtol, atol=self.atol) + + def test_linear_impmat_interpolate(self): + result = linear_interp_imp_mat(self.imp_mat0, self.imp_mat1, self.time_points) + self.assertEqual(len(result), self.time_points) + for mat in result: + self.assertIsInstance(mat, csr_matrix) + + dense = np.array([r.todense() for r in result]) + expected = np.array( + [ + [[1.0, 2.0], [3.0, 4.0]], + [[2.0, 3.0], [4.0, 5.0]], + [[3.0, 4.0], [5.0, 6.0]], + [[4.0, 5.0], [6.0, 7.0]], + [[5.0, 6.0], [7.0, 8.0]], + ] + ) + np.testing.assert_array_equal(dense, expected) + + def test_linear_impmat_interpolate_inconsistent_shape(self): + with self.assertRaises(ValueError): + linear_interp_imp_mat(self.imp_mat0, self.imp_mat2, self.time_points) + + def test_exp_impmat_interpolate(self): + result = exponential_interp_imp_mat( + self.imp_mat0, self.imp_mat1, self.time_points + ) + self.assertEqual(len(result), self.time_points) + for mat in result: + self.assertIsInstance(mat, csr_matrix) + + dense = np.array([r.todense() for r in result]) + expected = np.array( + [ + [[1.0, 2.0], [3.0, 4.0]], + [[1.49534878, 2.63214803], [3.70779275, 4.75682846]], + [[2.23606798, 3.46410162], [4.58257569, 5.65685425]], + [[3.34370152, 4.55901411], [5.66374698, 6.72717132]], + [[5.0, 6.0], [7.0, 8.0]], + ] + ) + np.testing.assert_array_almost_equal(dense, expected) + + def test_exp_impmat_interpolate_inconsistent_shape(self): + with self.assertRaises(ValueError): + exponential_interp_imp_mat(self.imp_mat0, self.imp_mat2, self.time_points) + + +class TestInterpolationStrategies(unittest.TestCase): + + def setUp(self): + self.interpolation_range = 3 + self.dummy_metric_0 = np.array([10, 20]) + self.dummy_metric_1 = np.array([100, 200]) + self.dummy_matrix_0 = csr_matrix(np.array([[1, 2], [3, 4]])) + self.dummy_matrix_1 = csr_matrix(np.array([[10, 20], [30, 40]])) + + def test_InterpolationStrategy_init(self): + def mock_exposure(a, b, r): + return a + b + + def mock_hazard(a, b, r): + return a * b + + def mock_vulnerability(a, b, r): + return a / b + + strategy = InterpolationStrategy(mock_exposure, mock_hazard, mock_vulnerability) + self.assertEqual(strategy.exposure_interp, mock_exposure) + self.assertEqual(strategy.hazard_interp, mock_hazard) + self.assertEqual(strategy.vulnerability_interp, mock_vulnerability) + + def test_InterpolationStrategy_interp_exposure_dim(self): + mock_exposure = MagicMock(return_value=["mock_result"]) + strategy = InterpolationStrategy( + mock_exposure, linear_interp_arrays, linear_interp_arrays + ) + + result = strategy.interp_over_exposure_dim( + self.dummy_matrix_0, self.dummy_matrix_1, self.interpolation_range + ) + mock_exposure.assert_called_once_with( + self.dummy_matrix_0, self.dummy_matrix_1, self.interpolation_range + ) + self.assertEqual(result, ["mock_result"]) + + def test_InterpolationStrategy_interp_exposure_dim_inconsistent_shapes(self): + mock_exposure = MagicMock(side_effect=ValueError("inconsistent shapes")) + strategy = InterpolationStrategy( + mock_exposure, linear_interp_arrays, linear_interp_arrays + ) + + with self.assertRaisesRegex( + ValueError, "Tried to interpolate impact matrices of different shape" + ): + strategy.interp_over_exposure_dim( + self.dummy_matrix_0, + csr_matrix(np.array([[1]])), + self.interpolation_range, + ) + mock_exposure.assert_called_once() # Ensure it was called + + def test_InterpolationStrategy_interp_hazard_dim(self): + mock_hazard = MagicMock(return_value=np.array([1, 2, 3])) + strategy = InterpolationStrategy( + linear_interp_imp_mat, mock_hazard, linear_interp_arrays + ) + + result = strategy.interp_over_hazard_dim( + self.dummy_metric_0, self.dummy_metric_1 + ) + mock_hazard.assert_called_once_with(self.dummy_metric_0, self.dummy_metric_1) + np.testing.assert_array_equal(result, np.array([1, 2, 3])) + + def test_InterpolationStrategy_interp_vulnerability_dim(self): + mock_vulnerability = MagicMock(return_value=np.array([4, 5, 6])) + strategy = InterpolationStrategy( + linear_interp_imp_mat, linear_interp_arrays, mock_vulnerability + ) + + result = strategy.interp_over_vulnerability_dim( + self.dummy_metric_0, self.dummy_metric_1 + ) + mock_vulnerability.assert_called_once_with( + self.dummy_metric_0, self.dummy_metric_1 + ) + np.testing.assert_array_equal(result, np.array([4, 5, 6])) + + +class TestConcreteInterpolationStrategies(unittest.TestCase): + + def setUp(self): + self.interpolation_range = 3 + self.dummy_metric_0 = np.array([10, 20, 30]) + self.dummy_metric_1 = np.array([100, 200, 300]) + self.dummy_matrix_0 = csr_matrix([[1, 2], [3, 4]]) + self.dummy_matrix_1 = csr_matrix([[10, 20], [30, 40]]) + self.dummy_matrix_0_1_lin = csr_matrix([[5.5, 11], [16.5, 22]]) + self.dummy_matrix_0_1_exp = csr_matrix( + [[3.162278, 6.324555], [9.486833, 12.649111]] + ) + self.rtol = 1e-5 + self.atol = 1e-8 + + def test_AllLinearStrategy_init_and_methods(self): + strategy = AllLinearStrategy() + self.assertEqual(strategy.exposure_interp, linear_interp_imp_mat) + self.assertEqual(strategy.hazard_interp, linear_interp_arrays) + self.assertEqual(strategy.vulnerability_interp, linear_interp_arrays) + + # Test hazard interpolation + expected_hazard_interp = linear_interp_arrays( + self.dummy_metric_0, self.dummy_metric_1 + ) + result_hazard = strategy.interp_over_hazard_dim( + self.dummy_metric_0, self.dummy_metric_1 + ) + np.testing.assert_allclose( + result_hazard, expected_hazard_interp, rtol=self.rtol, atol=self.atol + ) + + # Test vulnerability interpolation + expected_vulnerability_interp = linear_interp_arrays( + self.dummy_metric_0, self.dummy_metric_1 + ) + result_vulnerability = strategy.interp_over_vulnerability_dim( + self.dummy_metric_0, self.dummy_metric_1 + ) + np.testing.assert_allclose( + result_vulnerability, + expected_vulnerability_interp, + rtol=self.rtol, + atol=self.atol, + ) + + # Test exposure interpolation (using mock for linear_interp_imp_mat) + result_exposure = strategy.interp_over_exposure_dim( + self.dummy_matrix_0, self.dummy_matrix_1, self.interpolation_range + ) + # Verify the structure/first/last elements of the mock output + self.assertEqual(len(result_exposure), self.interpolation_range) + np.testing.assert_allclose(result_exposure[0].data, self.dummy_matrix_0.data) + np.testing.assert_allclose( + result_exposure[1].data, self.dummy_matrix_0_1_lin.data + ) + np.testing.assert_allclose(result_exposure[2].data, self.dummy_matrix_1.data) + + def test_ExponentialExposureInterpolation_init_and_methods(self): + strategy = ExponentialExposureStrategy() + # Test hazard interpolation (should be linear) + expected_hazard_interp = linear_interp_arrays( + self.dummy_metric_0, self.dummy_metric_1 + ) + result_hazard = strategy.interp_over_hazard_dim( + self.dummy_metric_0, self.dummy_metric_1 + ) + np.testing.assert_allclose( + result_hazard, expected_hazard_interp, rtol=self.rtol, atol=self.atol + ) + + # Test vulnerability interpolation (should be linear) + expected_vulnerability_interp = linear_interp_arrays( + self.dummy_metric_0, self.dummy_metric_1 + ) + result_vulnerability = strategy.interp_over_vulnerability_dim( + self.dummy_metric_0, self.dummy_metric_1 + ) + np.testing.assert_allclose( + result_vulnerability, + expected_vulnerability_interp, + rtol=self.rtol, + atol=self.atol, + ) + + # Test exposure interpolation (using mock for exponential_interp_imp_mat) + result_exposure = strategy.interp_over_exposure_dim( + self.dummy_matrix_0, self.dummy_matrix_1, self.interpolation_range + ) + # Verify the structure/first/last elements of the mock output + self.assertEqual(len(result_exposure), self.interpolation_range) + np.testing.assert_allclose(result_exposure[0].data, self.dummy_matrix_0.data) + np.testing.assert_allclose( + result_exposure[1].data, + self.dummy_matrix_0_1_exp.data, + rtol=self.rtol, + atol=self.atol, + ) + np.testing.assert_allclose(result_exposure[-1].data, self.dummy_matrix_1.data) + + +if __name__ == "__main__": + TESTS = unittest.TestLoader().loadTestsFromTestCase( + TestConcreteInterpolationStrategies + ) + TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestInterpolationFuncs)) + TESTS.addTests( + unittest.TestLoader().loadTestsFromTestCase(TestInterpolationStrategies) + ) + unittest.TextTestRunner(verbosity=2).run(TESTS) diff --git a/climada/trajectories/test/test_snapshot.py b/climada/trajectories/test/test_snapshot.py new file mode 100644 index 0000000000..4e3b465d8e --- /dev/null +++ b/climada/trajectories/test/test_snapshot.py @@ -0,0 +1,132 @@ +import datetime +import unittest +from unittest.mock import MagicMock + +import numpy as np +import pandas as pd + +from climada.entity.exposures import Exposures +from climada.entity.impact_funcs import ImpactFunc, ImpactFuncSet +from climada.entity.measures.base import Measure +from climada.hazard import Hazard +from climada.trajectories.snapshot import Snapshot +from climada.util.constants import EXP_DEMO_H5, HAZ_DEMO_H5 + + +class TestSnapshot(unittest.TestCase): + + def setUp(self): + # Create mock objects for testing + self.mock_exposure = Exposures.from_hdf5(EXP_DEMO_H5) + self.mock_hazard = Hazard.from_hdf5(HAZ_DEMO_H5) + self.mock_impfset = ImpactFuncSet( + [ + ImpactFunc( + "TC", + 3, + intensity=np.array([0, 20]), + mdd=np.array([0, 0.5]), + paa=np.array([0, 1]), + ) + ] + ) + self.mock_measure = MagicMock(spec=Measure) + self.mock_measure.name = "Test Measure" + + # Setup mock return values for measure.apply + self.mock_modified_exposure = MagicMock(spec=Exposures) + self.mock_modified_hazard = MagicMock(spec=Hazard) + self.mock_modified_impfset = MagicMock(spec=ImpactFuncSet) + self.mock_measure.apply.return_value = ( + self.mock_modified_exposure, + self.mock_modified_impfset, + self.mock_modified_hazard, + ) + + def test_init_with_int_date(self): + snapshot = Snapshot( + exposure=self.mock_exposure, + hazard=self.mock_hazard, + impfset=self.mock_impfset, + date=2023, + ) + self.assertEqual(snapshot.date, datetime.date(2023, 1, 1)) + + def test_init_with_str_date(self): + snapshot = Snapshot( + exposure=self.mock_exposure, + hazard=self.mock_hazard, + impfset=self.mock_impfset, + date="2023-01-01", + ) + self.assertEqual(snapshot.date, datetime.date(2023, 1, 1)) + + def test_init_with_date_object(self): + date_obj = datetime.date(2023, 1, 1) + snapshot = Snapshot( + exposure=self.mock_exposure, + hazard=self.mock_hazard, + impfset=self.mock_impfset, + date=date_obj, + ) + self.assertEqual(snapshot.date, date_obj) + + def test_init_with_invalid_date(self): + with self.assertRaises(ValueError): + Snapshot( + exposure=self.mock_exposure, + hazard=self.mock_hazard, + impfset=self.mock_impfset, + date="invalid-date", + ) + + def test_init_with_invalid_type(self): + with self.assertRaises(TypeError): + Snapshot( + exposure=self.mock_exposure, + hazard=self.mock_hazard, + impfset=self.mock_impfset, + date=2023.5, # type: ignore + ) + + def test_properties(self): + snapshot = Snapshot( + exposure=self.mock_exposure, + hazard=self.mock_hazard, + impfset=self.mock_impfset, + date=2023, + ) + + # We want a new reference + self.assertIsNot(snapshot.exposure, self.mock_exposure) + self.assertIsNot(snapshot.hazard, self.mock_hazard) + self.assertIsNot(snapshot.impfset, self.mock_impfset) + + # But we want equality + pd.testing.assert_frame_equal(snapshot.exposure.gdf, self.mock_exposure.gdf) + + self.assertEqual(snapshot.hazard.haz_type, self.mock_hazard.haz_type) + self.assertEqual(snapshot.hazard.intensity.nnz, self.mock_hazard.intensity.nnz) + self.assertEqual(snapshot.hazard.size, self.mock_hazard.size) + + self.assertEqual(snapshot.impfset, self.mock_impfset) + + def test_apply_measure(self): + snapshot = Snapshot( + exposure=self.mock_exposure, + hazard=self.mock_hazard, + impfset=self.mock_impfset, + date=2023, + ) + new_snapshot = snapshot.apply_measure(self.mock_measure) + + self.assertIsNotNone(new_snapshot.measure) + self.assertEqual(new_snapshot.measure.name, "Test Measure") # type: ignore + self.assertEqual(new_snapshot.exposure, self.mock_modified_exposure) + self.assertEqual(new_snapshot.hazard, self.mock_modified_hazard) + self.assertEqual(new_snapshot.impfset, self.mock_modified_impfset) + + +if __name__ == "__main__": + TESTS = unittest.TestLoader().loadTestsFromTestCase(TestSnapshot) + unittest.TextTestRunner(verbosity=2).run(TESTS) diff --git a/climada/trajectories/test/test_static_risk_trajectory.py b/climada/trajectories/test/test_static_risk_trajectory.py new file mode 100644 index 0000000000..7576c957f9 --- /dev/null +++ b/climada/trajectories/test/test_static_risk_trajectory.py @@ -0,0 +1,379 @@ +""" +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 . + +--- + +unit tests for static_risk_trajectory + +""" + +import datetime +import types +import unittest +from itertools import product +from unittest.mock import MagicMock, Mock, call, patch + +import numpy as np # For potential NaN/NA comparisons +import pandas as pd + +from climada.entity.disc_rates.base import DiscRates +from climada.trajectories.calc_risk_metrics import ( # ImpactComputationStrategy, # If needed to mock its base class directly + CalcRiskMetricsPoints, +) +from climada.trajectories.constants import ( + AAI_METRIC_NAME, + AAI_PER_GROUP_METRIC_NAME, + DATE_COL_NAME, + EAI_METRIC_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + RETURN_PERIOD_METRIC_NAME, + RISK_COL_NAME, +) +from climada.trajectories.impact_calc_strat import ImpactCalcComputation +from climada.trajectories.snapshot import Snapshot +from climada.trajectories.static_trajectory import ( + DEFAULT_ALLGROUP_NAME, + DEFAULT_RP, + StaticRiskTrajectory, +) + + +class TestStaticRiskTrajectory(unittest.TestCase): + def setUp(self) -> None: + self.dates1 = [pd.Timestamp("2023-01-01"), pd.Timestamp("2024-01-01")] + self.dates2 = [pd.Timestamp("2026-01-01")] + self.groups = ["GroupA", "GroupB", pd.NA] + self.measures = ["MEAS1", "MEAS2"] + self.metrics = [AAI_METRIC_NAME] + self.aai_dates1 = pd.DataFrame( + product(self.groups, self.dates1, self.measures, self.metrics), + columns=[GROUP_COL_NAME, DATE_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME], + ) + self.aai_dates1[RISK_COL_NAME] = np.arange(12) * 100 + self.aai_dates1[GROUP_COL_NAME] = self.aai_dates1[GROUP_COL_NAME].astype( + "category" + ) + + self.aai_dates2 = pd.DataFrame( + product(self.groups, self.dates2, self.measures, self.metrics), + columns=[GROUP_COL_NAME, DATE_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME], + ) + self.aai_dates2[RISK_COL_NAME] = np.arange(6) * 100 + 1200 + self.aai_dates2[GROUP_COL_NAME] = self.aai_dates2[GROUP_COL_NAME].astype( + "category" + ) + + self.aai_alldates = pd.DataFrame( + product( + self.groups, self.dates1 + self.dates2, self.measures, self.metrics + ), + columns=[GROUP_COL_NAME, DATE_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME], + ) + self.aai_alldates[RISK_COL_NAME] = np.arange(18) * 100 + self.aai_alldates[GROUP_COL_NAME] = self.aai_alldates[GROUP_COL_NAME].astype( + "category" + ) + self.aai_alldates[GROUP_COL_NAME] = self.aai_alldates[ + GROUP_COL_NAME + ].cat.add_categories([DEFAULT_ALLGROUP_NAME]) + self.aai_alldates[GROUP_COL_NAME] = self.aai_alldates[GROUP_COL_NAME].fillna( + DEFAULT_ALLGROUP_NAME + ) + self.expected_pre_npv_aai = self.aai_alldates + self.expected_pre_npv_aai = self.expected_pre_npv_aai[ + [ + DATE_COL_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + RISK_COL_NAME, + ] + ] + + self.expected_npv_aai = pd.DataFrame( + product( + self.dates1 + self.dates2, self.groups, self.measures, self.metrics + ), + columns=[DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME], + ) + self.expected_npv_aai[RISK_COL_NAME] = np.arange(18) * 90 + self.expected_npv_aai[GROUP_COL_NAME] = self.expected_npv_aai[ + GROUP_COL_NAME + ].astype("category") + self.expected_npv_aai[GROUP_COL_NAME] = self.expected_npv_aai[ + GROUP_COL_NAME + ].cat.add_categories(["All"]) + self.expected_npv_aai[GROUP_COL_NAME] = self.expected_npv_aai[ + GROUP_COL_NAME + ].fillna(DEFAULT_ALLGROUP_NAME) + expected_npv_df = self.expected_npv_aai + expected_npv_df = expected_npv_df[ + [ + DATE_COL_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + RISK_COL_NAME, + ] + ] + + self.mock_snapshot1 = MagicMock(spec=Snapshot) + self.mock_snapshot1.date = datetime.date(2023, 1, 1) + + self.mock_snapshot2 = MagicMock(spec=Snapshot) + self.mock_snapshot2.date = datetime.date(2024, 1, 1) + + self.mock_snapshot3 = MagicMock(spec=Snapshot) + self.mock_snapshot3.date = datetime.date(2026, 1, 1) + + self.snapshots_list: list[Snapshot] = [ + self.mock_snapshot1, + self.mock_snapshot2, + self.mock_snapshot3, + ] + + self.risk_disc_rates = MagicMock(spec=DiscRates) + self.risk_disc_rates.years = [2023, 2024, 2025, 2026] + self.risk_disc_rates.rates = [0.01, 0.02, 0.03, 0.04] # Example rates + + self.mock_impact_computation_strategy = MagicMock(spec=ImpactCalcComputation) + + self.custom_all_groups_name = "custom" + self.custom_return_periods = [10, 20] + + self.mock_static_traj = MagicMock(spec=StaticRiskTrajectory) + self.mock_static_traj._all_groups_name = DEFAULT_ALLGROUP_NAME + self.mock_static_traj._risk_disc_rates = None + self.mock_static_traj._risk_metrics_calculators = MagicMock( + spec=CalcRiskMetricsPoints + ) + + @patch( + "climada.trajectories.static_trajectory.CalcRiskMetricsPoints", + autospec=True, + ) + def test_init_basic(self, MockCalcRiskPoints): + mock_calculator = MagicMock(spec=CalcRiskMetricsPoints) + mock_calculator.impact_computation_strategy = ( + self.mock_impact_computation_strategy + ) + MockCalcRiskPoints.return_value = mock_calculator + rt = StaticRiskTrajectory( + self.snapshots_list, + impact_computation_strategy=self.mock_impact_computation_strategy, + ) + MockCalcRiskPoints.assert_has_calls( + [ + call( + self.snapshots_list, + impact_computation_strategy=self.mock_impact_computation_strategy, + ), + ] + ) + self.assertEqual(rt.start_date, self.mock_snapshot1.date) + self.assertEqual(rt.end_date, self.mock_snapshot3.date) + self.assertIsNone(rt._risk_disc_rates) + self.assertEqual(rt._all_groups_name, DEFAULT_ALLGROUP_NAME) + self.assertEqual(rt._return_periods, DEFAULT_RP) + self.assertEqual( + rt.impact_computation_strategy, self.mock_impact_computation_strategy + ) + # Check that metrics are reset (initially None) + for metric in StaticRiskTrajectory.POSSIBLE_METRICS: + self.assertIsNone(getattr(rt, "_" + metric + "_metrics")) + + @patch( + "climada.trajectories.static_trajectory.CalcRiskMetricsPoints", + autospec=True, + ) + def test_init_args(self, mock_calc_risk_metrics_points): + rt = StaticRiskTrajectory( + self.snapshots_list, + return_periods=self.custom_return_periods, + all_groups_name=self.custom_all_groups_name, + risk_disc_rates=self.risk_disc_rates, + impact_computation_strategy=self.mock_impact_computation_strategy, + ) + self.assertEqual(rt.start_date, self.mock_snapshot1.date) + self.assertEqual(rt.end_date, self.mock_snapshot3.date) + self.assertEqual(rt._risk_disc_rates, self.risk_disc_rates) + self.assertEqual(rt._all_groups_name, self.custom_all_groups_name) + self.assertEqual(rt._return_periods, self.custom_return_periods) + self.assertEqual(rt.return_periods, self.custom_return_periods) + # Check that metrics are reset (initially None) + for metric in StaticRiskTrajectory.POSSIBLE_METRICS: + self.assertIsNone(getattr(rt, "_" + metric + "_metrics")) + self.assertIsInstance(rt._risk_metrics_calculators, CalcRiskMetricsPoints) + mock_calc_risk_metrics_points.assert_called_with( + self.snapshots_list, + impact_computation_strategy=self.mock_impact_computation_strategy, + ) + + @patch.object(StaticRiskTrajectory, "_reset_metrics", new_callable=Mock) + @patch( + "climada.trajectories.static_trajectory.CalcRiskMetricsPoints", + autospec=True, + ) + def test_set_impact_computation_strategy( + self, mock_calc_risk_metrics_points, mock_reset_metrics + ): + rt = StaticRiskTrajectory( + self.snapshots_list, + impact_computation_strategy=self.mock_impact_computation_strategy, + ) + mock_reset_metrics.assert_called_once() # Called during init + with self.assertRaises(ValueError): + rt.impact_computation_strategy = "A" + + # There is only one possibility at the moment so we just check against a new object + new_impact_calc = ImpactCalcComputation() + rt.impact_computation_strategy = new_impact_calc + self.assertEqual(rt.impact_computation_strategy, new_impact_calc) + mock_reset_metrics.assert_has_calls([call(), call()]) + + def test_generic_metrics(self): + self.mock_static_traj.POSSIBLE_METRICS = StaticRiskTrajectory.POSSIBLE_METRICS + self.mock_static_traj._generic_metrics = types.MethodType( + StaticRiskTrajectory._generic_metrics, self.mock_static_traj + ) + self.mock_static_traj._risk_disc_rates = self.risk_disc_rates + self.mock_static_traj._aai_metrics = None + with self.assertRaises(ValueError): + self.mock_static_traj._generic_metrics(None, "dummy_meth") + + with self.assertRaises(NotImplementedError): + self.mock_static_traj._generic_metrics("dummy_name", "dummy_meth") + + self.mock_static_traj._risk_metrics_calculators.calc_aai_metric.return_value = ( + self.aai_alldates + ) + self.mock_static_traj.npv_transform.return_value = self.expected_npv_aai + result = self.mock_static_traj._generic_metrics( + AAI_METRIC_NAME, "calc_aai_metric" + ) + + self.mock_static_traj._risk_metrics_calculators.calc_aai_metric.assert_called_once_with() + self.mock_static_traj.npv_transform.assert_called_once() + pd.testing.assert_frame_equal( + self.mock_static_traj.npv_transform.call_args[0][0].reset_index(drop=True), + self.expected_pre_npv_aai.reset_index(drop=True), + ) + self.assertEqual( + self.mock_static_traj.npv_transform.call_args[0][1], self.risk_disc_rates + ) + pd.testing.assert_frame_equal( + result, self.expected_npv_aai + ) # Final result is from NPV transform + + # Check internal storage + stored_df = getattr(self.mock_static_traj, "_aai_metrics") + # Assert that the stored DF is the one *before* NPV transformation + pd.testing.assert_frame_equal( + stored_df.reset_index(drop=True), + self.expected_npv_aai.reset_index(drop=True), + ) + + result2 = self.mock_static_traj._generic_metrics( + AAI_METRIC_NAME, "calc_aai_metric" + ) + # Check no new call + self.mock_static_traj._risk_metrics_calculators.calc_aai_metric.assert_called_once_with() + pd.testing.assert_frame_equal( + result2, + self.expected_npv_aai.reset_index(drop=True), + ) + + def test_eai_metrics(self): + self.mock_static_traj.eai_metrics = types.MethodType( + StaticRiskTrajectory.eai_metrics, self.mock_static_traj + ) + self.mock_static_traj.eai_metrics(some_arg="test") + self.mock_static_traj._compute_metrics.assert_called_once_with( + metric_name=EAI_METRIC_NAME, metric_meth="calc_eai_gdf", some_arg="test" + ) + + def test_aai_metrics(self): + self.mock_static_traj.aai_metrics = types.MethodType( + StaticRiskTrajectory.aai_metrics, self.mock_static_traj + ) + self.mock_static_traj.aai_metrics(some_arg="test") + self.mock_static_traj._compute_metrics.assert_called_once_with( + metric_name=AAI_METRIC_NAME, metric_meth="calc_aai_metric", some_arg="test" + ) + + def test_return_periods_metrics(self): + self.mock_static_traj.return_periods = [1, 2] + self.mock_static_traj.return_periods_metrics = types.MethodType( + StaticRiskTrajectory.return_periods_metrics, self.mock_static_traj + ) + self.mock_static_traj.return_periods_metrics(some_arg="test") + self.mock_static_traj._compute_metrics.assert_called_once_with( + metric_name=RETURN_PERIOD_METRIC_NAME, + metric_meth="calc_return_periods_metric", + return_periods=[1, 2], + some_arg="test", + ) + + def test_aai_per_group_metrics(self): + self.mock_static_traj.aai_per_group_metrics = types.MethodType( + StaticRiskTrajectory.aai_per_group_metrics, self.mock_static_traj + ) + self.mock_static_traj.aai_per_group_metrics(some_arg="test") + self.mock_static_traj._compute_metrics.assert_called_once_with( + metric_name=AAI_PER_GROUP_METRIC_NAME, + metric_meth="calc_aai_per_group_metric", + some_arg="test", + ) + + def test_per_date_risk_metrics_defaults(self): + self.mock_static_traj.per_date_risk_metrics = types.MethodType( + StaticRiskTrajectory.per_date_risk_metrics, self.mock_static_traj + ) + # Set up mock return values for each method + self.mock_static_traj.aai_metrics.return_value = pd.DataFrame( + {METRIC_COL_NAME: [AAI_METRIC_NAME], RISK_COL_NAME: [100]} + ) + self.mock_static_traj.return_periods_metrics.return_value = pd.DataFrame( + {METRIC_COL_NAME: ["rp"], RISK_COL_NAME: [50]} + ) + self.mock_static_traj.aai_per_group_metrics.return_value = pd.DataFrame( + {METRIC_COL_NAME: ["aai_grp"], RISK_COL_NAME: [10]} + ) + result = self.mock_static_traj.per_date_risk_metrics() + + # Assert calls with default arguments + self.mock_static_traj.aai_metrics.assert_called_once_with() + self.mock_static_traj.return_periods_metrics.assert_called_once_with() + self.mock_static_traj.aai_per_group_metrics.assert_called_once_with() + + # Assert concatenation + expected_df = pd.concat( + [ + self.mock_static_traj.aai_metrics.return_value, + self.mock_static_traj.return_periods_metrics.return_value, + self.mock_static_traj.aai_per_group_metrics.return_value, + ] + ) + pd.testing.assert_frame_equal( + result.reset_index(drop=True), expected_df.reset_index(drop=True) + ) + + +if __name__ == "__main__": + TESTS = unittest.TestLoader().loadTestsFromTestCase(TestStaticRiskTrajectory) + unittest.TextTestRunner(verbosity=2).run(TESTS) diff --git a/climada/trajectories/test/test_trajectory.py b/climada/trajectories/test/test_trajectory.py new file mode 100644 index 0000000000..c39d6c9aac --- /dev/null +++ b/climada/trajectories/test/test_trajectory.py @@ -0,0 +1,326 @@ +""" +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 . + +--- + +unit tests for risk_trajectory + +""" + +import datetime +import unittest +from unittest.mock import MagicMock, Mock, call, patch + +import pandas as pd + +from climada.entity.disc_rates.base import DiscRates +from climada.trajectories.constants import AAI_METRIC_NAME +from climada.trajectories.snapshot import Snapshot +from climada.trajectories.trajectory import ( + DEFAULT_ALLGROUP_NAME, + DEFAULT_RP, + RiskTrajectory, +) + + +class TestRiskTrajectory(unittest.TestCase): + def setUp(self) -> None: + self.mock_snapshot1 = MagicMock(spec=Snapshot) + self.mock_snapshot1.date = datetime.date(2023, 1, 1) + + self.mock_snapshot2 = MagicMock(spec=Snapshot) + self.mock_snapshot2.date = datetime.date(2024, 1, 1) + + self.mock_snapshot3 = MagicMock(spec=Snapshot) + self.mock_snapshot3.date = datetime.date(2025, 1, 1) + + self.risk_disc_rates = MagicMock(spec=DiscRates) + self.risk_disc_rates.years = [2023, 2024, 2025] + self.risk_disc_rates.rates = [0.01, 0.02, 0.03] # Example rates + + self.snapshots_list: list[Snapshot] = [ + self.mock_snapshot1, + self.mock_snapshot2, + self.mock_snapshot3, + ] + + self.custom_all_groups_name = "custom" + self.custom_return_periods = [10, 20] + + def test_init_basic(self): + rt = RiskTrajectory(self.snapshots_list) + self.assertEqual(rt.start_date, self.mock_snapshot1.date) + self.assertEqual(rt.end_date, self.mock_snapshot3.date) + self.assertIsNone(rt._risk_disc_rates) + self.assertEqual(rt._all_groups_name, DEFAULT_ALLGROUP_NAME) + self.assertEqual(rt._return_periods, DEFAULT_RP) + # Check that metrics are reset (initially None) + for metric in RiskTrajectory.POSSIBLE_METRICS: + self.assertIsNone(getattr(rt, "_" + metric + "_metrics")) + + def test_init_args(self): + rt = RiskTrajectory( + self.snapshots_list, + return_periods=self.custom_return_periods, + all_groups_name=self.custom_all_groups_name, + risk_disc_rates=self.risk_disc_rates, + ) + self.assertEqual(rt.start_date, self.mock_snapshot1.date) + self.assertEqual(rt.end_date, self.mock_snapshot3.date) + self.assertEqual(rt._risk_disc_rates, self.risk_disc_rates) + self.assertEqual(rt._all_groups_name, self.custom_all_groups_name) + self.assertEqual(rt._return_periods, self.custom_return_periods) + self.assertEqual(rt.return_periods, self.custom_return_periods) + # Check that metrics are reset (initially None) + for metric in RiskTrajectory.POSSIBLE_METRICS: + self.assertIsNone(getattr(rt, "_" + metric + "_metrics")) + + @patch.object(RiskTrajectory, "_generic_metrics", new_callable=Mock) + def test_compute_metrics(self, mock_generic_metrics): + mock_generic_metrics.return_value = "42" + rt = RiskTrajectory(self.snapshots_list) + result = rt._compute_metrics( + metric_name="dummy_name", + metric_meth="dummy_meth", + dummy_kwarg1="A", + dummy_kwarg2=12, + ) + mock_generic_metrics.assert_called_once_with( + metric_name="dummy_name", + metric_meth="dummy_meth", + dummy_kwarg1="A", + dummy_kwarg2=12, + ) + self.assertEqual(result, "42") + + def test_set_return_periods(self): + rt = RiskTrajectory(self.snapshots_list) + with self.assertRaises(ValueError): + rt.return_periods = "A" + with self.assertRaises(ValueError): + rt.return_periods = ["A"] + + rt.return_periods = [1, 2] + self.assertEqual(rt._return_periods, [1, 2]) + self.assertEqual(rt.return_periods, [1, 2]) + + @patch.object(RiskTrajectory, "_reset_metrics", new_callable=Mock) + def test_set_disc_rates(self, mock_reset_metrics): + rt = RiskTrajectory(self.snapshots_list) + mock_reset_metrics.assert_called_once() # Called during init + with self.assertRaises(ValueError): + rt.risk_disc_rates = "A" + + rt.risk_disc_rates = self.risk_disc_rates + mock_reset_metrics.assert_has_calls([call(), call()]) + self.assertEqual(rt._risk_disc_rates, self.risk_disc_rates) + self.assertEqual(rt.risk_disc_rates, self.risk_disc_rates) + + def test_npv_transform_no_group_col(self): + df_input = pd.DataFrame( + { + "date": pd.to_datetime(["2023-01-01", "2024-01-01"] * 2), + "measure": ["m1", "m1", "m2", "m2"], + "metric": [ + AAI_METRIC_NAME, + AAI_METRIC_NAME, + AAI_METRIC_NAME, + AAI_METRIC_NAME, + ], + "risk": [100.0, 200.0, 80.0, 180.0], + } + ) + # Mock the internal calc_npv_cash_flows + with patch( + "climada.trajectories.trajectory.RiskTrajectory._calc_npv_cash_flows" + ) as mock_calc_npv: + # For each group, it will be called + mock_calc_npv.side_effect = [ + pd.Series( + [100.0 * (1 / (1 + 0.01)) ** 0, 200.0 * (1 / (1 + 0.02)) ** 1], + index=[pd.Timestamp("2023-01-01"), pd.Timestamp("2024-01-01")], + ), + pd.Series( + [80.0 * (1 / (1 + 0.01)) ** 0, 180.0 * (1 / (1 + 0.02)) ** 1], + index=[pd.Timestamp("2023-01-01"), pd.Timestamp("2024-01-01")], + ), + ] + result_df = RiskTrajectory.npv_transform( + df_input.copy(), self.risk_disc_rates + ) + # Assertions for mock calls + # Grouping by 'measure', 'metric' (default _grouper) + pd.testing.assert_series_equal( + mock_calc_npv.mock_calls[0].args[0], + pd.Series( + [100.0, 200.0], + index=pd.Index( + [ + pd.Timestamp("2023-01-01"), + pd.Timestamp("2024-01-01"), + ], + name="date", + ), + name=("m1", AAI_METRIC_NAME), + ), + ) + assert mock_calc_npv.mock_calls[0].args[1] == pd.Timestamp("2023-01-01") + assert mock_calc_npv.mock_calls[0].args[2] == self.risk_disc_rates + pd.testing.assert_series_equal( + mock_calc_npv.mock_calls[1].args[0], + pd.Series( + [80.0, 180.0], + index=pd.Index( + [ + pd.Timestamp("2023-01-01"), + pd.Timestamp("2024-01-01"), + ], + name="date", + ), + name=("m2", AAI_METRIC_NAME), + ), + ) + assert mock_calc_npv.mock_calls[1].args[1] == pd.Timestamp("2023-01-01") + assert mock_calc_npv.mock_calls[1].args[2] == self.risk_disc_rates + + expected_df = pd.DataFrame( + { + "date": pd.to_datetime(["2023-01-01", "2024-01-01"] * 2), + "measure": ["m1", "m1", "m2", "m2"], + "metric": [ + AAI_METRIC_NAME, + AAI_METRIC_NAME, + AAI_METRIC_NAME, + AAI_METRIC_NAME, + ], + "risk": [ + 100.0 * (1 / (1 + 0.01)) ** 0, + 200.0 * (1 / (1 + 0.02)) ** 1, + 80.0 * (1 / (1 + 0.01)) ** 0, + 180.0 * (1 / (1 + 0.02)) ** 1, + ], + } + ) + pd.testing.assert_frame_equal( + result_df.sort_values("date").reset_index(drop=True), + expected_df.sort_values("date").reset_index(drop=True), + rtol=1e-6, + ) + + def test_npv_transform_with_group_col(self): + df_input = pd.DataFrame( + { + "date": pd.to_datetime(["2023-01-01", "2024-01-01", "2023-01-01"]), + "group": ["G1", "G1", "G2"], + "measure": ["m1", "m1", "m1"], + "metric": [AAI_METRIC_NAME, AAI_METRIC_NAME, AAI_METRIC_NAME], + "risk": [100.0, 200.0, 150.0], + } + ) + with patch( + "climada.trajectories.trajectory.RiskTrajectory._calc_npv_cash_flows" + ) as mock_calc_npv: + mock_calc_npv.side_effect = [ + # First group G1, m1, aai + pd.Series( + [100.0 * (1 / (1 + 0.01)) ** 0, 200.0 * (1 / (1 + 0.02)) ** 1], + index=[pd.Timestamp("2023-01-01"), pd.Timestamp("2024-01-01")], + ), + # Second group G2, m1, aai + pd.Series( + [150.0 * (1 / (1 + 0.01)) ** 0], index=[pd.Timestamp("2023-01-01")] + ), + ] + result_df = RiskTrajectory.npv_transform( + df_input.copy(), self.risk_disc_rates + ) + + expected_df = pd.DataFrame( + { + "date": pd.to_datetime(["2023-01-01", "2024-01-01", "2023-01-01"]), + "group": ["G1", "G1", "G2"], + "measure": ["m1", "m1", "m1"], + "metric": [AAI_METRIC_NAME, AAI_METRIC_NAME, AAI_METRIC_NAME], + "risk": [ + 100.0 * (1 / (1 + 0.01)) ** 0, + 200.0 * (1 / (1 + 0.02)) ** 1, + 150.0 * (1 / (1 + 0.01)) ** 0, + ], + } + ) + pd.testing.assert_frame_equal( + result_df.sort_values(["group", "date"]).reset_index(drop=True), + expected_df.sort_values(["group", "date"]).reset_index(drop=True), + rtol=1e-6, + ) + + # --- Test NPV Transformation (`npv_transform` and `calc_npv_cash_flows`) --- + + ## Test `calc_npv_cash_flows` (standalone function) + def test_calc_npv_cash_flows_no_disc(self): + cash_flows = pd.Series( + [100, 200, 300], + index=pd.to_datetime(["2023-01-01", "2024-01-01", "2025-01-01"]), + ) + start_date = datetime.date(2023, 1, 1) + result = RiskTrajectory._calc_npv_cash_flows( + cash_flows, start_date, disc_rates=None + ) + # If no disc, it should return the original cash_flows Series + pd.testing.assert_series_equal(result, cash_flows) + + def test_calc_npv_cash_flows_with_disc(self): + cash_flows = pd.Series( + [100, 200, 300], + index=pd.period_range(start="2023-01-01", end="2025-01-01", freq="Y"), + ) + start_date = datetime.date(2023, 1, 1) + # Using the risk_disc_rates from SetUp + + # year 2023: (2023-01-01 - 2023-01-01) days // 365 = 0, factor = (1/(1+0.01))^0 = 1 + # year 2024: (2024-01-01 - 2023-01-01) days // 365 = 1, factor = (1/(1+0.02))^1 = 0.98039215... + # year 2025: (2025-01-01 - 2023-01-01) days // 365 = 2, factor = (1/(1+0.03))^2 = 0.9425959... + expected_cash_flows = pd.Series( + [ + 100 * (1 / (1 + 0.01)) ** 0, + 200 * (1 / (1 + 0.02)) ** 1, + 300 * (1 / (1 + 0.03)) ** 2, + ], + index=pd.period_range(start="2023-01-01", end="2025-01-01", freq="Y"), + name="npv_cash_flow", + ) + + result = RiskTrajectory._calc_npv_cash_flows( + cash_flows, start_date, disc_rates=self.risk_disc_rates + ) + pd.testing.assert_series_equal( + result, expected_cash_flows, check_dtype=False, rtol=1e-6 + ) + + def test_calc_npv_cash_flows_invalid_index(self): + cash_flows = pd.Series([100, 200, 300]) # No datetime index + start_date = datetime.date(2023, 1, 1) + with self.assertRaises( + ValueError, msg="cash_flows must be a pandas Series with a datetime index" + ): + RiskTrajectory._calc_npv_cash_flows( + cash_flows, start_date, disc_rates=self.risk_disc_rates + ) + + +if __name__ == "__main__": + TESTS = unittest.TestLoader().loadTestsFromTestCase(TestRiskTrajectory) + unittest.TextTestRunner(verbosity=2).run(TESTS) diff --git a/climada/trajectories/trajectory.py b/climada/trajectories/trajectory.py new file mode 100644 index 0000000000..75c30b9aa1 --- /dev/null +++ b/climada/trajectories/trajectory.py @@ -0,0 +1,274 @@ +""" +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 . + +--- + +This file implements abstract trajectory objects, to factorise the code common to +interpolated and static trajectories. + +""" + +import datetime +import logging +from abc import ABC, abstractmethod +from typing import Iterable + +import pandas as pd + +from climada.entity.disc_rates.base import DiscRates +from climada.trajectories.constants import ( + DATE_COL_NAME, + DEFAULT_ALLGROUP_NAME, + DEFAULT_RP, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + PERIOD_COL_NAME, + RISK_COL_NAME, + UNIT_COL_NAME, +) +from climada.trajectories.snapshot import Snapshot + +LOGGER = logging.getLogger(__name__) + +__all__ = ["RiskTrajectory"] + +DEFAULT_DF_COLUMN_PRIORITY = [ + DATE_COL_NAME, + PERIOD_COL_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + UNIT_COL_NAME, +] +INDEXING_COLUMNS = [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME] + + +class RiskTrajectory(ABC): + """Base abstract class for risk trajectory objects. + + See concrete implementation :class:`StaticRiskTrajectory` and + :class:`InterpolatedRiskTrajectory` for more details. + + """ + + _grouper = [MEASURE_COL_NAME, METRIC_COL_NAME] + """Results dataframe grouper used in most `groupby()` calls.""" + + POSSIBLE_METRICS = [] + """Class variable listing the risk metrics that can be computed.""" + + def __init__( + self, + snapshots_list: Iterable[Snapshot], + *, + return_periods: Iterable[int] = DEFAULT_RP, + all_groups_name: str = DEFAULT_ALLGROUP_NAME, + risk_disc_rates: DiscRates | None = None, + ): + self._reset_metrics() + self._snapshots = sorted(snapshots_list, key=lambda snap: snap.date) + self._all_groups_name = all_groups_name + self._return_periods = return_periods + self.start_date = min((snapshot.date for snapshot in snapshots_list)) + self.end_date = max((snapshot.date for snapshot in snapshots_list)) + self._risk_disc_rates = risk_disc_rates + + def _reset_metrics(self) -> None: + """Resets the computed metrics to None. + + This method is called to inititialize the `POSSIBLE_METRICS` to `None` during + the initialisation. + + It is also called when properties that would change the results of + computed metrics (for instance changing the time resolution in + :class:`InterpolatedRiskMetrics`) + + """ + for metric in self.POSSIBLE_METRICS: + setattr(self, "_" + metric + "_metrics", None) + + @abstractmethod + def _generic_metrics( + self, /, metric_name: str, metric_meth: str, **kwargs + ) -> pd.DataFrame: + """Main method to return the results of a specific metric. + + This method should call the `_generic_metrics()` of its parent and + define the part of the computation and treatment that + is specific to a child class of :class:`RiskTrajectory`. + + See also + -------- + + - :method:`_compute_metrics` + + """ + raise NotImplementedError( + f"'_generic_metrics' must be implemented by subclasses of {self.__class__.__name__}" + ) + + def _compute_metrics( + self, /, metric_name: str, metric_meth: str, **kwargs + ) -> pd.DataFrame: + """Helper method to compute metrics. + + Notes + ----- + + This method exists for the sake of the children classes for option appraisal, for which + `_generic_metrics` can have a different signature and extend on its + parent method. This method can stay the same (same signature) for all classes. + """ + return self._generic_metrics( + metric_name=metric_name, metric_meth=metric_meth, **kwargs + ) + + @property + def return_periods(self) -> Iterable[int]: + """The return period values to use when computing risk period metrics. + + Notes + ----- + + Changing its value resets the corresponding metric. + """ + return self._return_periods + + @return_periods.setter + def return_periods(self, value, /): + if not isinstance(value, list): + raise ValueError("Return periods need to be a list of int.") + if any(not isinstance(i, int) for i in value): + raise ValueError("Return periods need to be a list of int.") + self._return_periods_metrics = None + self._return_periods = value + + @property + def risk_disc_rates(self) -> DiscRates | None: + """The discount rate applied to compute net present values. + None means no discount rate. + + Notes + ----- + + Changing its value resets all the metrics. + """ + return self._risk_disc_rates + + @risk_disc_rates.setter + def risk_disc_rates(self, value, /): + if value is not None and not isinstance(value, (DiscRates)): + raise ValueError("Risk discount needs to be a `DiscRates` object.") + + self._reset_metrics() + self._risk_disc_rates = value + + @classmethod + def npv_transform( + cls, metric_df: pd.DataFrame, risk_disc_rates: DiscRates + ) -> pd.DataFrame: + """Apply provided discount rate to the provided metric `DataFrame`. + + Parameters + ---------- + metric_df : pd.DataFrame + The `DataFrame` of the metric to discount. + risk_disc_rates : DiscRate + The discount rate to apply. + + Returns + ------- + pd.DataFrame + The discounted risk metric. + + """ + + def _npv_group(group, disc): + start_date = group.index.get_level_values(DATE_COL_NAME).min() + return cls._calc_npv_cash_flows(group, start_date, disc) + + metric_df = metric_df.set_index(DATE_COL_NAME) + grouper = cls._grouper + if GROUP_COL_NAME in metric_df.columns: + grouper = [GROUP_COL_NAME] + grouper + + metric_df[RISK_COL_NAME] = metric_df.groupby( + grouper, + dropna=False, + as_index=False, + group_keys=False, + observed=True, + )[RISK_COL_NAME].transform(_npv_group, risk_disc_rates) + metric_df = metric_df.reset_index() + return metric_df + + @staticmethod + def _calc_npv_cash_flows( + cash_flows: pd.DataFrame, + start_date: datetime.date, + disc_rates: DiscRates | None = None, + ): + """Apply discount rate to cash flows. + + If it is defined, applies a discount rate `disc` to a given cash flow + `cash_flows` assuming present year corresponds to `start_date`. + + Parameters + ---------- + cash_flows : pd.DataFrame + The cash flow to apply the discount rate to. + start_date : datetime.date + The date representing the present. + end_date : datetime.date, optional + disc : DiscRates, optional + The discount rate to apply. + + Returns + ------- + + A dataframe (copy) of `cash_flows` where values are discounted according to `disc`. + + """ + + if not disc_rates: + return cash_flows + + if not isinstance(cash_flows.index, (pd.PeriodIndex, pd.DatetimeIndex)): + raise ValueError( + "cash_flows must be a pandas Series with a PeriodIndex or DatetimeIndex" + ) + + metric_df = cash_flows.to_frame(name="cash_flow") # type: ignore + metric_df["year"] = metric_df.index.year + + # Merge with the discount rates based on the year + tmp = metric_df.merge( + pd.DataFrame({"year": disc_rates.years, "rate": disc_rates.rates}), + on="year", + how="left", + ) + tmp.index = metric_df.index + metric_df = tmp.copy() + metric_df["discount_factor"] = (1 / (1 + metric_df["rate"])) ** ( + metric_df.index.year - start_date.year + ) + + # Apply the discount factors to the cash flows + metric_df["npv_cash_flow"] = ( + metric_df["cash_flow"] * metric_df["discount_factor"] + ) + return metric_df["npv_cash_flow"] diff --git a/climada/util/dataframe_handling.py b/climada/util/dataframe_handling.py new file mode 100644 index 0000000000..b5ac6bef97 --- /dev/null +++ b/climada/util/dataframe_handling.py @@ -0,0 +1,63 @@ +""" +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 . + +--- + +Define functions to handle with coordinates +""" + +import pandas as pd + + +def reorder_dataframe_columns( + df: pd.DataFrame, priority_order: list[str], keep_remaining: bool = True +) -> pd.DataFrame | pd.Series: + """ + Applies a column priority list to a DataFrame to reorder its columns. + + This function is robust to cases where: + 1. Columns in 'priority_order' are not in the DataFrame (they are ignored). + 2. Columns in the DataFrame are not in 'priority_order'. + + Parameters + ---------- + df: pd.DataFrame + The input DataFrame. + priority_order: list[str] + A list of strings defining the desired column + order. Columns listed first have higher priority. + keep_remaining: bool + If True, any columns in the DataFrame but NOT in + 'priority_order' will be appended to the end in their + original relative order. If False, these columns + are dropped. + + Returns: + pd.DataFrame: The DataFrame with columns reordered according to the priority list. + """ + + present_priority_columns = [col for col in priority_order if col in df.columns] + + new_column_order = present_priority_columns + + if keep_remaining: + remaining_columns = [ + col for col in df.columns if col not in present_priority_columns + ] + + new_column_order.extend(remaining_columns) + + return df[new_column_order] diff --git a/doc/api/climada/climada.rst b/doc/api/climada/climada.rst index 557532912f..2e8d053946 100644 --- a/doc/api/climada/climada.rst +++ b/doc/api/climada/climada.rst @@ -7,4 +7,5 @@ Software documentation per package climada.engine climada.entity climada.hazard + climada.trajectories climada.util diff --git a/doc/api/climada/climada.trajectories.impact_calc_strat.rst b/doc/api/climada/climada.trajectories.impact_calc_strat.rst new file mode 100644 index 0000000000..1bf211b4c0 --- /dev/null +++ b/doc/api/climada/climada.trajectories.impact_calc_strat.rst @@ -0,0 +1,7 @@ +climada\.trajectories\.impact_calc_strat module +---------------------------------------- + +.. automodule:: climada.trajectories.impact_calc_strat + :members: + :undoc-members: + :show-inheritance: diff --git a/doc/api/climada/climada.trajectories.interpolation.rst b/doc/api/climada/climada.trajectories.interpolation.rst new file mode 100644 index 0000000000..98e1ec7b32 --- /dev/null +++ b/doc/api/climada/climada.trajectories.interpolation.rst @@ -0,0 +1,7 @@ +climada\.trajectories\.interpolation module +---------------------------------------- + +.. automodule:: climada.trajectories.interpolation + :members: + :undoc-members: + :show-inheritance: diff --git a/doc/api/climada/climada.trajectories.rst b/doc/api/climada/climada.trajectories.rst new file mode 100644 index 0000000000..3766a7ed0d --- /dev/null +++ b/doc/api/climada/climada.trajectories.rst @@ -0,0 +1,10 @@ + +climada\.trajectories module +============================ + +.. toctree:: + + climada.trajectories.snapshot + climada.trajectories.trajectories + climada.trajectories.interpolation + climada.trajectories.impact_calc_strat diff --git a/doc/api/climada/climada.trajectories.snapshot.rst b/doc/api/climada/climada.trajectories.snapshot.rst new file mode 100644 index 0000000000..ba0faf57ac --- /dev/null +++ b/doc/api/climada/climada.trajectories.snapshot.rst @@ -0,0 +1,7 @@ +climada\.trajectories\.snapshot module +---------------------------------------- + +.. automodule:: climada.trajectories.snapshot + :members: + :undoc-members: + :show-inheritance: diff --git a/doc/api/climada/climada.trajectories.trajectories.rst b/doc/api/climada/climada.trajectories.trajectories.rst new file mode 100644 index 0000000000..35583b89d8 --- /dev/null +++ b/doc/api/climada/climada.trajectories.trajectories.rst @@ -0,0 +1,23 @@ +climada\.trajectories\.static_trajectory module +---------------------------------------- + +.. automodule:: climada.trajectories.static_trajectory + :members: + :undoc-members: + :show-inheritance: + +climada\.trajectories\.static_trajectory module +---------------------------------------- + +.. automodule:: climada.trajectories.interpolated_trajectory + :members: + :undoc-members: + :show-inheritance: + +climada\.trajectories\.trajectory module +---------------------------------------- + +.. automodule:: climada.trajectories.trajectory + :members: + :undoc-members: + :show-inheritance: diff --git a/doc/user-guide/climada_trajectories.ipynb b/doc/user-guide/climada_trajectories.ipynb new file mode 100644 index 0000000000..f222cd7c93 --- /dev/null +++ b/doc/user-guide/climada_trajectories.ipynb @@ -0,0 +1,1732 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "856ac388-9edb-497e-a2ff-a325f2a22562", + "metadata": {}, + "source": [ + "# Important disclaimers" + ] + }, + { + "cell_type": "markdown", + "id": "f7d4fdab-8662-4848-bb87-9b6045447957", + "metadata": {}, + "source": [ + "## Interpolation of risk can be... risky" + ] + }, + { + "cell_type": "markdown", + "id": "8f9531a7-9a1a-400f-8c82-3a51fdc6671a", + "metadata": {}, + "source": [ + "One purpose of this module is to improve the evaluation of risk in between two \"known\" points in time.\n", + "\n", + "This part relies on interpolation (linear by default) of impacts and risk metrics in between the different specified points, \n", + "which may lead to incoherent results in cases where this simplification drifts too far from reality.\n", + "\n", + "For instance if you are using different historical events as you points in time, a static comparison of the different risk\n", + "estimates may be interesting, but interpolating in between makes very little sense.\n", + "\n", + "As always users should carefully consider if the tool fits the purpose and if the limitations \n", + "remain acceptable, even more so when used to design Disaster Risk Reduction or Climate Change Adaptation measures." + ] + }, + { + "cell_type": "markdown", + "id": "c588329e-f5a5-4945-aad1-900b7bb675e3", + "metadata": {}, + "source": [ + "## Memory and computation requirements\n", + "\n", + "This module adds a new dimension (time) to the risk, as such, it **multiplies** the memory and computation requirement along that dimension (although we avoid running a full-fledge impact computation for each \"interpolated\" point, we still have to define an impact matrix for each of those). \n", + "\n", + "This can of course (very) quickly increase the memory and computation requirements for bigger data. We encourage you to first try on small examples before running big computations.\n" + ] + }, + { + "cell_type": "markdown", + "id": "b53b1da2-7be1-4507-96bb-2efd8dd3e910", + "metadata": {}, + "source": [ + "# Using the `trajectories` module" + ] + }, + { + "cell_type": "markdown", + "id": "4e0f3261-f443-4cc6-b85b-c6a3d90b73e3", + "metadata": {}, + "source": [ + "The fundamental idea behing the `trajectories` module is to enable a better assessment of the evolution of risk over time, both by facilitating point by point comparison, and the \"evolution\" or risk.\n", + "\n", + "This module aims at facilitating answering questions such as:\n", + "\n", + "- How does future hazards (probabilistic event set), exposure and vulnerability change impacts with respect to present?\n", + "- How would the impacts compare if a past event were to happen again with present / future exposure?\n", + "- How will risk evolve in the future under different assumptions on the evolution of hazard, exposure, vulnerability and discount rate?\n", + "- *etc*.\n", + "\n", + "To achieve this, this module introduces two concepts:\n", + "\n", + "- Snapshots of risk, a fixed representation of risk (via its three components Exposure, Hazard and Vulnerability) for a given date. This concept is intended to be generic, as such the given date can be something else than a year, a month or a day for instance, but keep in mind that we will not check that the data you provide makes sense for it!\n", + "- Trajectories of risk, a collection of snapshots,for which risk metrics can be computed and regrouped to ease their evaluation." + ] + }, + { + "cell_type": "markdown", + "id": "6396ab9f-7b09-49a7-81a5-a45e7a99a4ff", + "metadata": {}, + "source": [ + "## `Snapshot`: A snapshot of risk at a specific year" + ] + }, + { + "cell_type": "markdown", + "id": "274a342f-54c0-4590-9110-5e297010955e", + "metadata": {}, + "source": [ + "We use `Snapshot` objects to define a point in time for risk. This object acts as a wrapper of the classic risk framework composed of Exposure, Hazard and Vulnerability. As such it is defined for a specific date (usually a year), and contains an `Exposures`, a `Hazard`, and an `ImpactFuncSet` object.\n", + "\n", + "Instantiating such a `Snapshot` is done simply with:\n", + "\n", + "```python\n", + "snap = Snapshot(\n", + " exposure=your_exposure,\n", + " hazard=your_hazard,\n", + " impfset=your_impfset,\n", + " date=your_date\n", + " )\n", + "```\n", + "\n", + "Note that to avoid any ambiguity, you need to write explicitly `exposure=your_exposure`.\n", + "\n", + "Think of `Snapshot` as a representation of risk at, or around, a specific date. Your hazard should be a probabilistic set of events that are representative for the designated date.\n", + "\n", + "To be consistent with the intuitive idea of a snapshot, by default `Snapshot` objects make a \"deep copy\" of the risk triplet and are immutable.\n", + "This means that they do not change once created (notably even if you change one of the component, e.g. the Hazard object, outside of the `Snapshot`).\n", + "If you want a `Snapshot` with a different `Hazard`, you need to create a new one.\n", + "\n", + "In that spirit, you cannot directly instantiate a Snapshot with an adaptation measure. To include adaptation, you need to first create the snapshot without adaptation, and then use `apply_measure()`, which\n", + "will return a new `Snapshot`, with the changed (Exposure, Hazard, ImpactFuncSet) according to the given measure.\n", + "\n", + "Below is an concrete example of how to create a Snapshot using data from the data API for tropical cyclones in Haiti:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dec203d1-943f-41d8-9542-009f288b937b", + "metadata": {}, + "outputs": [], + "source": [ + "from climada.util.api_client import Client\n", + "from climada.entity import ImpactFuncSet, ImpfTropCyclone\n", + "from climada.trajectories.snapshot import Snapshot\n", + "\n", + "client = Client()\n", + "\n", + "exp_present = client.get_litpop(country=\"Haiti\")\n", + "\n", + "haz_present = client.get_hazard(\n", + " \"tropical_cyclone\",\n", + " properties={\n", + " \"country_name\": \"Haiti\",\n", + " \"climate_scenario\": \"historical\",\n", + " \"nb_synth_tracks\": \"10\",\n", + " },\n", + ")\n", + "\n", + "impf_set = ImpactFuncSet([ImpfTropCyclone.from_emanuel_usa()])\n", + "exp_present.gdf.rename(columns={\"impf_\": \"impf_TC\"}, inplace=True)\n", + "exp_present.gdf[\"impf_TC\"] = 1\n", + "\n", + "snap1 = Snapshot(exposure=exp_present, hazard=haz_present, impfset=impf_set, date=2018)" + ] + }, + { + "cell_type": "markdown", + "id": "044e2b4f-506a-492f-9627-471f46ad7c3a", + "metadata": {}, + "source": [ + "All risk dimensions are freely accessible from the snapshot:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aa0becca-d334-40b4-86c0-1959c750f6d5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "snap1.exposure.plot_raster()\n", + "snap1.hazard.plot_intensity(0)\n", + "snap1.impfset.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "d2e6daae-6345-41ac-a560-71040942db39", + "metadata": {}, + "source": [ + "## Evaluating risk from multiple snapshots using trajectories" + ] + }, + { + "cell_type": "markdown", + "id": "8e8458c3-a3f9-4210-9de0-15293167f2f9", + "metadata": {}, + "source": [ + "Trajectories facilitate the evaluation of risk of multiple snapshot. The module implements two kinds of trajectories:\n", + "\n", + "- `StaticRiskTrajectory`: which estimate the risk at each snaphot only, and regroups the results nicely.\n", + "- `InterpolatedRiskTrajectory`: which also includes the evolution of risk in between the snapshots using interpolation.\n", + "\n", + "So first, let us define `Snapshot` for a future point in time. We will increase the value of the exposure following a certain growth rate, and use future tropical\n", + "cyclone data for the hazard, we will also change the vulnerability to be slightly lower in the future:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c516c861-c5c1-475b-82e2-c867c5c08ec9", + "metadata": {}, + "outputs": [], + "source": [ + "import copy\n", + "\n", + "future_year = 2040\n", + "exp_future = copy.deepcopy(exp_present)\n", + "exp_future.ref_year = future_year\n", + "n_years = exp_future.ref_year - exp_present.ref_year + 1\n", + "growth_rate = 1.02\n", + "growth = growth_rate**n_years\n", + "exp_future.gdf[\"value\"] = exp_future.gdf[\"value\"] * growth\n", + "\n", + "haz_future = client.get_hazard(\n", + " \"tropical_cyclone\",\n", + " properties={\n", + " \"country_name\": \"Haiti\",\n", + " \"climate_scenario\": \"rcp60\",\n", + " \"ref_year\": str(future_year),\n", + " \"nb_synth_tracks\": \"10\",\n", + " },\n", + ")\n", + "\n", + "impf_set = ImpactFuncSet(\n", + " [\n", + " ImpfTropCyclone.from_emanuel_usa(v_half=78.0),\n", + " ]\n", + ")\n", + "exp_future.gdf.rename(columns={\"impf_\": \"impf_TC\"}, inplace=True)\n", + "exp_future.gdf[\"impf_TC\"] = 1\n", + "snap2 = Snapshot(exposure=exp_future, hazard=haz_future, impfset=impf_set, date=2040)\n", + "\n", + "# Now we can define a list of two snapshots, present and future:\n", + "snapcol = [snap1, snap2]" + ] + }, + { + "cell_type": "markdown", + "id": "27ca72b1-b1fa-4cd2-8f74-a69dc6eb3c9c", + "metadata": {}, + "source": [ + "Based on such a list of snapshots, we can then evaluate a risk trajectory using a `StaticRiskTrajectory` or a `InterpolatedRiskTrajectory` object." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e782ab8b", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "from climada.trajectories import StaticRiskTrajectory, InterpolatedRiskTrajectory\n", + "\n", + "static_risk_traj = StaticRiskTrajectory(snapcol)\n", + "interpolated_risk_traj = InterpolatedRiskTrajectory(snapcol)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "483767e7-9089-4b5e-a307-514ac302e773", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "remove-input" + ] + }, + "outputs": [], + "source": [ + "%%html\n", + "" + ] + }, + { + "cell_type": "markdown", + "id": "2d7e8653-4ef9-40f5-8f8a-ef0e8b3b8a8c", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "### Tidy format\n", + "\n", + "We use the \"tidy\" format to output most of the results.\n", + "\n", + "A **tidy data** format is a standardized way to structure datasets, making them easier to analyze and visualize. It's based on three main principles:\n", + "\n", + "1. **Each variable forms a column.**\n", + "2. **Each observation forms a row.**\n", + "3. **Each type of observational unit forms a table.**\n", + "\n", + "Example:\n", + "\n", + "| group | date | metric | risk |\n", + "| :---: | :---: | :---: | :---: |\n", + "| All | 2018-01-01 | aai | $1.840432 \\times 10^{8}$ |\n", + "| All | 2040-01-01 | aai | $6.946753 \\times 10^{8}$ |\n", + "| All | 2018-01-01 | rp\\_20 | $1.420589 \\times 10^{8}$ |\n", + "\n", + "In this example, every descriptive quality (variable) of the risk evaluation is placed in its own column:\n", + "\n", + "* **`group`**: The exposure subgroup for the risk evalution point.\n", + "* **`date`**: The date for the risk evalution point.\n", + "* **`metric`**: The specific risk measure (e.g., 'aai', 'rp\\_20', 'rp\\_100').\n", + "* **`unit`**: The unit of the risk evaluation.\n", + "* **`risk`**: The actual value being measured.\n", + "\n", + "Each row represents a single, complete observation. For example, the very first row is a measurement of the **'aai' metric** for **group 'All'** on **'2018-01-01'**, with the resulting **risk** value of **$1.840432 \\times 10^{8}$ USD**." + ] + }, + { + "cell_type": "markdown", + "id": "ca8951cc-4a0a-4f3d-9c21-96dd6a835810", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "### Static and Interpolated trajectories" + ] + }, + { + "cell_type": "markdown", + "id": "dc76cb91", + "metadata": {}, + "source": [ + "`StaticRiskTrajectory` will compute and hold risk metrics for all the given snapshots without interpolation:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "14453563", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No group id defined in the Exposures object. Per group aai will be empty.\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
dategroupmeasuremetricunitrisk
02018-01-01Allno_measureaaiUSD1.840432e+08
12040-01-01Allno_measureaaiUSD2.749295e+08
22018-01-01Allno_measurerp_20USD1.420589e+08
32040-01-01Allno_measurerp_20USD2.357976e+08
42018-01-01Allno_measurerp_50USD3.059112e+09
52040-01-01Allno_measurerp_50USD4.580720e+09
62018-01-01Allno_measurerp_100USD5.719050e+09
72040-01-01Allno_measurerp_100USD8.477125e+09
\n", + "
" + ], + "text/plain": [ + " date group measure metric unit risk\n", + "0 2018-01-01 All no_measure aai USD 1.840432e+08\n", + "1 2040-01-01 All no_measure aai USD 2.749295e+08\n", + "2 2018-01-01 All no_measure rp_20 USD 1.420589e+08\n", + "3 2040-01-01 All no_measure rp_20 USD 2.357976e+08\n", + "4 2018-01-01 All no_measure rp_50 USD 3.059112e+09\n", + "5 2040-01-01 All no_measure rp_50 USD 4.580720e+09\n", + "6 2018-01-01 All no_measure rp_100 USD 5.719050e+09\n", + "7 2040-01-01 All no_measure rp_100 USD 8.477125e+09" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "static_risk_traj.per_date_risk_metrics()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "cd169d1b-741c-471c-b402-391096e20613", + "metadata": {}, + "source": [ + " The `InterpolatedRiskTrajectory` object goes further and computes the metrics for all the dates between the different snapshots in the given collection for a given time resolution (one year by default). In this example, from the snapshot in 2018 to the one in 2040. \n", + "\n", + "Note that this can require a bit of computation and memory, especially for large regions or extended range of time with high time resolution.\n", + "Also note, that most computations are only run and stored when needed, not at instantiation.\n", + "\n", + "From this object you can access different risk metrics:\n", + "\n", + "* Average Annual Impact (aai) both for all exposure points (group == \"All\") and specific groups of exposure points (defined by a \"group_id\" in the exposure).\n", + "* Estimated impact for different return periods (20, 50 and 100 by default)\n", + "\n", + "Both as average over the whole period:" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "9c485dc4-c009-46fb-aa4a-603bc9dcf5b4", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No group id defined in at least one of the Exposures object. Per group aai will be empty.\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
periodgroupmeasuremetricunitrisk
02018 to 2040Allno_measureaaiUSD2.309016e+08
12018 to 2040Allno_measurerp_100USD7.148372e+09
22018 to 2040Allno_measurerp_20USD1.896739e+08
32018 to 2040Allno_measurerp_50USD3.847129e+09
\n", + "
" + ], + "text/plain": [ + " period group measure metric unit risk\n", + "0 2018 to 2040 All no_measure aai USD 2.309016e+08\n", + "1 2018 to 2040 All no_measure rp_100 USD 7.148372e+09\n", + "2 2018 to 2040 All no_measure rp_20 USD 1.896739e+08\n", + "3 2018 to 2040 All no_measure rp_50 USD 3.847129e+09" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "interpolated_risk_traj.per_period_risk_metrics()" + ] + }, + { + "cell_type": "markdown", + "id": "af53286d-ee62-44a5-907b-84103302663d", + "metadata": {}, + "source": [ + "Or on a per-date basis:" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "6b73a589-9ee4-41e8-90e0-910bfe4dd8fc", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No group id defined in at least one of the Exposures object. Per group aai will be empty.\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
dategroupmeasuremetricunitrisk
02018Allno_measureaaiUSD1.840432e+08
12019Allno_measureaaiUSD1.885312e+08
22020Allno_measureaaiUSD1.929908e+08
32021Allno_measureaaiUSD1.974211e+08
42022Allno_measureaaiUSD2.018214e+08
.....................
872036Allno_measurerp_100USD8.025179e+09
882037Allno_measurerp_100USD8.140512e+09
892038Allno_measurerp_100USD8.254300e+09
902039Allno_measurerp_100USD8.366514e+09
912040Allno_measurerp_100USD8.477125e+09
\n", + "

92 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " date group measure metric unit risk\n", + "0 2018 All no_measure aai USD 1.840432e+08\n", + "1 2019 All no_measure aai USD 1.885312e+08\n", + "2 2020 All no_measure aai USD 1.929908e+08\n", + "3 2021 All no_measure aai USD 1.974211e+08\n", + "4 2022 All no_measure aai USD 2.018214e+08\n", + ".. ... ... ... ... ... ...\n", + "87 2036 All no_measure rp_100 USD 8.025179e+09\n", + "88 2037 All no_measure rp_100 USD 8.140512e+09\n", + "89 2038 All no_measure rp_100 USD 8.254300e+09\n", + "90 2039 All no_measure rp_100 USD 8.366514e+09\n", + "91 2040 All no_measure rp_100 USD 8.477125e+09\n", + "\n", + "[92 rows x 6 columns]" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "interpolated_risk_traj.per_date_risk_metrics()" + ] + }, + { + "cell_type": "markdown", + "id": "00e0a09b-9dd6-4378-81a1-cda5290f9aa4", + "metadata": {}, + "source": [ + "You can also plot the \"contribution\" or \"components\" of the change in risk (Average ) via a waterfall graph:\n", + "\n", + " - The 'base risk', i.e., the risk without change in hazard or exposure, compared to trajectory's earliest date.\n", + " - The 'exposure contribution', i.e., the additional risks due to change in exposure (only)\n", + " - The 'hazard contribution', i.e., the additional risks due to change in hazard (only)\n", + " - The 'vulnerability contribution', i.e., the additional risks due to change in vulnerability (only)\n", + " - The 'interaction contribution', i.e., the additional risks due to the interaction term (between exposure, hazard and vulnerability)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "08c226a4-944b-4301-acfa-602adde980a5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "interpolated_risk_traj.plot_waterfall()" + ] + }, + { + "cell_type": "markdown", + "id": "7896af66-b0aa-4418-b22e-c64fd4d2cfe1", + "metadata": {}, + "source": [ + "And as well on a per date basis (keep in mind this is an interpolation, thus should be interpreted with caution):" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "6a15775f-af9e-4940-b18d-eb16bd0c8c85", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(
,\n", + " )" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "interpolated_risk_traj.plot_time_waterfall()" + ] + }, + { + "cell_type": "markdown", + "id": "501e455b-e7c6-4672-9191-d5fefe38d424", + "metadata": {}, + "source": [ + "### DiscRates" + ] + }, + { + "cell_type": "markdown", + "id": "0dba0218-55fe-423d-a520-61d3cb2a991c", + "metadata": {}, + "source": [ + "To correctly assess the future risk, you may also want to apply a discount rate, in order to express future costs in net present value.\n", + "\n", + "This can easily be done providing an instance of the already existing `DiscRates` class when instantiating the trajectory." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "651e31cb-5a55-4a22-a7c3-b5f79b3a20ef", + "metadata": {}, + "outputs": [], + "source": [ + "from climada.entity import DiscRates\n", + "import numpy as np\n", + "\n", + "year_range = np.arange(exp_present.ref_year, exp_future.ref_year + 1)\n", + "annual_discount_stern = np.ones(n_years) * 0.014\n", + "discount_stern = DiscRates(year_range, annual_discount_stern)\n", + "discounted_risk_traj = InterpolatedRiskTrajectory(\n", + " snapcol, risk_disc_rates=discount_stern\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "d86bedbb-6c0a-4f7d-a63e-5012510339d3", + "metadata": {}, + "source": [ + "You can easily notice the difference with the previously defined trajectory without discount rate." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "ee3b0217-fe14-44a9-98f5-e1fc7f45e613", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = interpolated_risk_traj.aai_metrics().plot(\n", + " x=\"date\", y=\"risk\", label=\"No discount rate\"\n", + ")\n", + "discounted_risk_traj.aai_metrics().plot(\n", + " x=\"date\", y=\"risk\", label=\"Stern discount rate\", ax=ax\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "0152e9fa-55fa-4cf2-b187-59e6228af563", + "metadata": {}, + "source": [ + "# Advanced usage\n", + "\n", + "In this section we present some more advanced features and use of this module." + ] + }, + { + "cell_type": "markdown", + "id": "dbf4b23d-d502-4c06-8e0d-eb832af8ebe4", + "metadata": {}, + "source": [ + "## Exposure sub groups" + ] + }, + { + "cell_type": "markdown", + "id": "86a58a22-63a5-42a9-9afb-cf8962156e36", + "metadata": {}, + "source": [ + "It is often useful to look at sub-groups of your exposure (social groups of different social vulnerability, buildings of different type, etc.)\n", + "\n", + "The `trajectory` module facilitate looking at risk specifically for sub-groups of exposure points. In order to do so, you need to set a column \"group_id\" in the `GeoDataFrame` of your exposure.\n", + "\n", + "Here we create dummy groups for exposure points above and below the mean exposure value:" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "566f0c34-b19b-403a-a905-92c51093c182", + "metadata": {}, + "outputs": [], + "source": [ + "exp_present.gdf[\"group_id\"] = (\n", + " exp_present.gdf[\"value\"] > exp_present.gdf[\"value\"].mean()\n", + ") * 1\n", + "exp_future.gdf[\"group_id\"] = (\n", + " exp_future.gdf[\"value\"] > exp_future.gdf[\"value\"].mean()\n", + ") * 1\n", + "\n", + "snap1 = Snapshot(exposure=exp_present, hazard=haz_present, impfset=impf_set, date=2018)\n", + "snap2 = Snapshot(exposure=exp_future, hazard=haz_future, impfset=impf_set, date=2040)\n", + "static_risk_traj = StaticRiskTrajectory([snap1, snap2])\n", + "interpolated_risk_traj = InterpolatedRiskTrajectory([snap1, snap2])" + ] + }, + { + "cell_type": "markdown", + "id": "e0123f8f-ec7f-47ac-9f60-0f59808b9670", + "metadata": {}, + "source": [ + "You can now access the `aii_per_group` metric, which will give you the average impact (for the frequency unit of you hazard) restricted to the exposure points of the corresponding group." + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "344a84d7-275c-426d-80d1-5375696f5cc3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
dategroupmeasuremetricunitrisk
02018-01-010no_measureaaiUSD6.094866e+06
12018-01-011no_measureaaiUSD1.508360e+08
22040-01-010no_measureaaiUSD1.063804e+07
32040-01-011no_measureaaiUSD2.642915e+08
\n", + "
" + ], + "text/plain": [ + " date group measure metric unit risk\n", + "0 2018-01-01 0 no_measure aai USD 6.094866e+06\n", + "1 2018-01-01 1 no_measure aai USD 1.508360e+08\n", + "2 2040-01-01 0 no_measure aai USD 1.063804e+07\n", + "3 2040-01-01 1 no_measure aai USD 2.642915e+08" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "static_risk_traj.aai_per_group_metrics()" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "43cff641-6288-48d6-81bb-40d9755c24d1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
dategroupmeasuremetricunitrisk
020180no_measureaaiUSD6.094866e+06
120181no_measureaaiUSD1.508360e+08
220190no_measureaaiUSD6.285071e+06
320191no_measureaaiUSD1.555734e+08
420200no_measureaaiUSD6.476829e+06
\n", + "
" + ], + "text/plain": [ + " date group measure metric unit risk\n", + "0 2018 0 no_measure aai USD 6.094866e+06\n", + "1 2018 1 no_measure aai USD 1.508360e+08\n", + "2 2019 0 no_measure aai USD 6.285071e+06\n", + "3 2019 1 no_measure aai USD 1.555734e+08\n", + "4 2020 0 no_measure aai USD 6.476829e+06" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "interpolated_risk_traj.aai_per_group_metrics().head()" + ] + }, + { + "cell_type": "markdown", + "id": "4fcc943d-e5c6-4667-8ec6-8f7d2f0b3ce4", + "metadata": {}, + "source": [ + "## Results caching" + ] + }, + { + "cell_type": "markdown", + "id": "b3f326db-458b-4238-a30b-fcc9215f8f36", + "metadata": {}, + "source": [ + "Trajectory objects regroup a large number of computations, especially for the interpolated ones. The module makes use of both a caching process to avoid recomputing the same metric over and over, and a \"lazy\" flow, which means computations are run only when needed.\n", + "\n", + "As such, the first time you call any metric can take a bit of time, but the subsequent ones should be much faster.\n", + "\n", + "Modifying attributes that would change the results (e.g. the time resolution or the impact computation strategy), will reset the cache.\n", + "\n", + "However this caching process can also get memory expensive. So you can deactivate it by setting \"trajectory_caching\" to false in CLIMADA's configuration (see __[Configuration](../development/Guide_Configuration.ipynb)__)." + ] + }, + { + "cell_type": "markdown", + "id": "42c9daed-6488-488b-b01a-fd6dfc5d0274", + "metadata": {}, + "source": [ + "## Higher number of snapshots" + ] + }, + { + "cell_type": "markdown", + "id": "6db14802-fa35-4e33-91ef-7dddd4d43da7", + "metadata": {}, + "source": [ + "You can of course use the module to evaluate more that two snapshots. With the `StaticRiskTrajectory` you will get a collection of results for each snapshot.\n", + "\n", + "For the `InterpolatedRiskTrajectory` the interpolation will be done between each pair of consecutive snapshots and all results will be collected together, this is usefull if you want to explore a trajectory for which you have clear \"intermediate points\", for instance if you are evaluating the risk in an area for which you know some specific development projects will start at a certain date.\n", + "\n", + "Below is an example featuring three snapshots:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d93eb82b-65d2-48fe-a195-6cb12f23bf47", + "metadata": {}, + "outputs": [], + "source": [ + "from climada.engine.impact_calc import ImpactCalc\n", + "from climada.util.api_client import Client\n", + "from climada.entity import ImpactFuncSet, ImpfTropCyclone\n", + "from climada.trajectories.snapshot import Snapshot\n", + "from climada.trajectories import InterpolatedRiskTrajectory\n", + "import copy\n", + "\n", + "client = Client()\n", + "\n", + "\n", + "future_years = [2040, 2060, 2080]\n", + "\n", + "exp_present = client.get_litpop(country=\"Haiti\")\n", + "haz_present = client.get_hazard(\n", + " \"tropical_cyclone\",\n", + " properties={\n", + " \"country_name\": \"Haiti\",\n", + " \"climate_scenario\": \"historical\",\n", + " \"nb_synth_tracks\": \"10\",\n", + " },\n", + ")\n", + "\n", + "impf_set = ImpactFuncSet([ImpfTropCyclone.from_emanuel_usa()])\n", + "exp_present.gdf.rename(columns={\"impf_\": \"impf_TC\"}, inplace=True)\n", + "exp_present.gdf[\"impf_TC\"] = 1\n", + "exp_present.gdf[\"group_id\"] = (exp_present.gdf[\"value\"] > 500000) * 1\n", + "\n", + "snapcol = [\n", + " Snapshot(exposure=exp_present, hazard=haz_present, impfset=impf_set, date=2018)\n", + "]\n", + "\n", + "for year in future_years:\n", + " exp_future = copy.deepcopy(exp_present)\n", + " exp_future.ref_year = year\n", + " n_years = exp_future.ref_year - exp_present.ref_year + 1\n", + " growth_rate = 1.02\n", + " growth = growth_rate**n_years\n", + " exp_future.gdf[\"value\"] = exp_future.gdf[\"value\"] * growth\n", + "\n", + " haz_future = client.get_hazard(\n", + " \"tropical_cyclone\",\n", + " properties={\n", + " \"country_name\": \"Haiti\",\n", + " \"climate_scenario\": \"rcp60\",\n", + " \"ref_year\": str(year),\n", + " \"nb_synth_tracks\": \"10\",\n", + " },\n", + " )\n", + " impf_set = ImpactFuncSet(\n", + " [\n", + " ImpfTropCyclone.from_emanuel_usa(v_half=78.0),\n", + " ]\n", + " )\n", + " exp_future.gdf.rename(columns={\"impf_\": \"impf_TC\"}, inplace=True)\n", + " exp_future.gdf[\"impf_TC\"] = 1\n", + " snapcol.append(\n", + " Snapshot(exposure=exp_future, hazard=haz_future, impfset=impf_set, date=year)\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b85d5b95-4316-481a-9eed-86977647b791", + "metadata": {}, + "outputs": [], + "source": [ + "risk_traj = InterpolatedRiskTrajectory(snapcol)" + ] + }, + { + "cell_type": "markdown", + "id": "537a9dd8-96e9-4ef4-a137-358990c658d2", + "metadata": {}, + "source": [ + "The \"static\" waterfall plot shows the evolution of risk between the earliest and latest snapshot." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1c5aeb4b-6320-479d-82a6-9b2c3901868e", + "metadata": {}, + "outputs": [], + "source": [ + "risk_traj.plot_waterfall()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "16faf81c-8760-4c02-a575-ae033bcb637d", + "metadata": {}, + "outputs": [], + "source": [ + "risk_traj.plot_time_waterfall()" + ] + }, + { + "cell_type": "markdown", + "id": "fed22016-ab8f-4761-892a-c893d18357b7", + "metadata": {}, + "source": [ + "## Non-default return periods" + ] + }, + { + "cell_type": "markdown", + "id": "fcaed625-82a8-4cc4-82de-e36b67601dcb", + "metadata": {}, + "source": [ + "You can easily change the default return periods computed, either at initialisation time, or via the property `return_periods`.\n", + "Note that estimates of impacts for specific return periods are highly dependant on the data you provided.\n", + "\n", + "**We cannot check if the event set you provide is fit for computing impacts for a specific return period.** " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0ade93f9-c43a-4e8a-8225-9343bbbb3615", + "metadata": {}, + "outputs": [], + "source": [ + "snapcol = [snap1, snap2]\n", + "risk_traj = InterpolatedRiskTrajectory(snapcol, return_periods=[10, 15, 20, 30])\n", + "display(risk_traj.return_periods_metrics())\n", + "\n", + "risk_traj.return_periods = [150, 250, 500]\n", + "display(risk_traj.return_periods_metrics())" + ] + }, + { + "cell_type": "markdown", + "id": "39059ec5-9125-4cfc-b8c6-e6327d8b98cc", + "metadata": {}, + "source": [ + "## Non-yearly date index" + ] + }, + { + "cell_type": "markdown", + "id": "4f8f83d6-a45d-4d3b-b25d-d3294e6e1955", + "metadata": {}, + "source": [ + "You can use any valid pandas [frequency string for periods](https://pandas.pydata.org/docs/user_guide/timeseries.html#period-aliases) for the time resolution,\n", + "for instance \"5Y\" for every five years. This reduces the resolution of the interpolation, which can reduce the required computations at the cost of \"precision\".\n", + "Conversely you can also increase the time resolution to a monthly base for instance.\n", + "\n", + "Same as for the return periods, you can change that at initialisation or afterward via the property.\n", + "\n", + "Keep in mind that risk metrics are still computed the same way, so if you initialy had hazards with annual frequency values, you would still have \"Average Annual Impacts\" values for every months and not average monthly ones!\n", + "\n", + "Also note that `InterpolatedRiskTrajectory` uses `PeriodIndex` for the time dimension. These indexes are defined with the dates of the first and last snapshot, and the given time resolution.\n", + "\n", + "This means that an `InterpolatedRiskTrajectory` for a 2020 `Snapshot` and 2040 `Snapshot` with a yearly time resolution will include all years from 2020 to 2040 included (11 years in total).\n", + "\n", + "However, a trajectory with the same snapshots with a monthly resolution will have January 2040 as a last period if you only provided year 2040 for the last date. If you want to include the whole 2040 year, you need to explicitly give the date \"2040-12-31\" to the last snapshot." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "128fac77-e077-4241-a003-a60c4afcad74", + "metadata": {}, + "outputs": [], + "source": [ + "snapcol = [snap1, snap2]\n", + "risk_traj = InterpolatedRiskTrajectory(snapcol, time_resolution=\"5Y\")\n", + "risk_traj.per_date_risk_metrics().head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c1e66906-63e3-4a29-8a0b-0e706e6a2a09", + "metadata": {}, + "outputs": [], + "source": [ + "# snapcol = [snap, snap2]\n", + "\n", + "# Here we use \"1MS\" to get a monthly basis\n", + "risk_traj.time_resolution = \"1M\"\n", + "\n", + "# We would have to divide results by 12 to get \"average monthly impacts\"\n", + "risk_traj.per_date_risk_metrics()" + ] + }, + { + "cell_type": "markdown", + "id": "f5d6b725-41ee-495b-bc72-5806db4cfdba", + "metadata": {}, + "source": [ + "## Non-linear interpolation" + ] + }, + { + "cell_type": "markdown", + "id": "a8065729-5d0b-4250-8324-2ce82cb0d644", + "metadata": {}, + "source": [ + "The module allows you to define your own interpolation strategy. Thus you can decide how to interpolate along each dimension of risk (Exposure, Hazard and Vulnerability).\n", + "This is done via `InterpolationStrategy` objects, which simply require three functions stating how to interpolate along each dimensions.\n", + "\n", + "For convenience the module provides an `AllLinearStrategy` (the risk is linearly interpolated along all dimensions) and a `ExponentialExposureStrategy` (uses exponential interpolation along exposure, and linear for the two other dimensions).\n", + "\n", + "This can prove helpfull if you are interpolating between two distant dates with an exponential growth factor for the exposure value. On the example below, we show the difference in risk estimates using an the two different interpolation strategies for the exposure dimension:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c97e768e-bd4c-47d7-bace-96645f8b3bc4", + "metadata": {}, + "outputs": [], + "source": [ + "from climada.trajectories import StaticRiskTrajectory, InterpolatedRiskTrajectory\n", + "from climada.trajectories import ExponentialExposureStrategy\n", + "import seaborn as sns\n", + "\n", + "future_year = 2100\n", + "exp_future = copy.deepcopy(exp_present)\n", + "exp_future.ref_year = future_year\n", + "n_years = exp_future.ref_year - exp_present.ref_year + 1\n", + "growth_rate = 1.04\n", + "growth = growth_rate**n_years\n", + "exp_future.gdf[\"value\"] = exp_future.gdf[\"value\"] * growth\n", + "\n", + "haz_future = client.get_hazard(\n", + " \"tropical_cyclone\",\n", + " properties={\n", + " \"country_name\": \"Haiti\",\n", + " \"climate_scenario\": \"rcp60\",\n", + " \"ref_year\": \"2080\",\n", + " \"nb_synth_tracks\": \"10\",\n", + " },\n", + ")\n", + "impf_set = ImpactFuncSet(\n", + " [\n", + " ImpfTropCyclone.from_emanuel_usa(v_half=60.0),\n", + " ]\n", + ")\n", + "exp_future.gdf.rename(columns={\"impf_\": \"impf_TC\"}, inplace=True)\n", + "exp_future.gdf[\"impf_TC\"] = 1\n", + "\n", + "snap2 = Snapshot(exposure=exp_future, hazard=haz_future, impfset=impf_set, date=2100)\n", + "snapcol = [snap1, snap2]\n", + "\n", + "exp_interp = ExponentialExposureStrategy()\n", + "risk_traj = InterpolatedRiskTrajectory(snapcol)\n", + "risk_traj_exp = InterpolatedRiskTrajectory(snapcol, interpolation_strategy=exp_interp)\n", + "ax = risk_traj.aai_metrics().plot(\n", + " x=\"date\", y=\"risk\", label=\"Linear interpolation for exposure\"\n", + ")\n", + "risk_traj_exp.aai_metrics().plot(\n", + " x=\"date\", y=\"risk\", label=\"Exponential interpolation for exposure\", ax=ax\n", + ")\n", + "\n", + "ax.set_title(\n", + " \"Comparison of average annual impact estimate for different interpolation approaches\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "4a5991b8-659e-4b0a-81cc-bc0d085ff1e7", + "metadata": {}, + "source": [ + "## Spatial mapping" + ] + }, + { + "cell_type": "markdown", + "id": "d47bcc7e-defe-4058-b7a3-4dafd4374f35", + "metadata": {}, + "source": [ + "You can access a DataFrame with the estimated annual impacts at each coordinates through \"eai_metrics\" which can easily be merged to the exposure GeoDataFrame:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "431d26f1-c19f-4654-814b-20e8a243848e", + "metadata": {}, + "outputs": [], + "source": [ + "df = risk_traj.eai_metrics()\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "61abb90f-42f8-446c-aa27-8a5b5eaa3729", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "gdf = snap1.exposure.gdf\n", + "gdf[\"coord_id\"] = gdf.index\n", + "gdf = gdf.merge(df, on=\"coord_id\")\n", + "\n", + "fig, axs = plt.subplots(1, 3, figsize=(24, 5))\n", + "\n", + "gdf.loc[gdf[\"date\"] == \"2018-01-01\"].plot(\n", + " column=\"risk\",\n", + " legend=True,\n", + " vmin=gdf[\"risk\"].min(),\n", + " vmax=gdf[\"risk\"].max(),\n", + " ax=axs[0],\n", + ")\n", + "gdf.loc[gdf[\"date\"] == \"2050-01-01\"].plot(\n", + " column=\"risk\",\n", + " legend=True,\n", + " vmin=gdf[\"risk\"].min(),\n", + " vmax=gdf[\"risk\"].max(),\n", + " ax=axs[1],\n", + ")\n", + "gdf.loc[gdf[\"date\"] == \"2100-01-01\"].plot(\n", + " column=\"risk\",\n", + " legend=True,\n", + " vmin=gdf[\"risk\"].min(),\n", + " vmax=gdf[\"risk\"].max(),\n", + " ax=axs[2],\n", + ")\n", + "\n", + "axs[0].set_title(\"Average Annual Risk in 2018\")\n", + "axs[1].set_title(\"Average Annual Risk in 2050\")\n", + "axs[2].set_title(\"Average Annual Risk in 2100\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "98159b83-677e-4c23-a926-d03da8c80f3b", + "metadata": {}, + "source": [ + "## Custom Impact Computation strategy" + ] + }, + { + "cell_type": "markdown", + "id": "825b9b95-3343-4250-8e1c-e89120359482", + "metadata": {}, + "source": [ + "By default, trajectory objects use `ImpactCalc().impact()` to compute the `Impact` object and the resulting metric, but you can customize this behaviour via the `impact_computation_strategy` argument.\n", + "\n", + "The value has to be a class derived from `ImpactComputationStrategy`, and should at the very least implement a `compute_impacts()` method, taking `Exposures`, `Hazard` and `ImpactFuncSet` arguments and returning an `Impact` object.\n", + "\n", + "For instance, if you don't want the matching of the exposure and hazard centroids to be done internally you can do the following:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f3b8d931-e4e5-40bf-b702-31183c6c7ec3", + "metadata": {}, + "outputs": [], + "source": [ + "from climada.trajectories.impact_calc_strat import ImpactComputationStrategy\n", + "\n", + "\n", + "class ImpactCalcNoAssign(ImpactComputationStrategy):\n", + " def compute_impacts(\n", + " self,\n", + " exp,\n", + " haz,\n", + " vul,\n", + " ):\n", + " return ImpactCalc(exposures=exp, impfset=vul, hazard=haz).impact(\n", + " assign_centroids=False\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "998fa84d-12e7-4e18-aa96-41ca4bac3ed7", + "metadata": {}, + "source": [ + "Note that you now have to assign the centroids before running the computations or else they will fail:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8d8d3b88-2c17-471e-acc3-afd8391a469d", + "metadata": {}, + "outputs": [], + "source": [ + "exp_present = client.get_litpop(country=\"Haiti\")\n", + "exp_present.gdf.rename(columns={\"impf_\": \"impf_TC\"}, inplace=True)\n", + "exp_present.gdf[\"impf_TC\"] = 1\n", + "\n", + "\n", + "exp_future = copy.deepcopy(exp_present)\n", + "exp_future.gdf[\"value\"] = exp_future.gdf[\"value\"] * growth\n", + "\n", + "exp_present.assign_centroids(haz_present)\n", + "exp_future.assign_centroids(haz_future)\n", + "\n", + "snap1 = Snapshot(exposure=exp_present, hazard=haz_present, impfset=impf_set, date=2018)\n", + "snap2 = Snapshot(exposure=exp_future, hazard=haz_future, impfset=impf_set, date=2040)\n", + "\n", + "impact_calc_no_assign = ImpactCalcNoAssign()\n", + "\n", + "static_risk_traj = StaticRiskTrajectory(\n", + " [snap1, snap2], impact_computation_strategy=impact_calc_no_assign\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a94d99b5-2c7b-418e-88e9-a9dff39ab21e", + "metadata": {}, + "outputs": [], + "source": [ + "static_risk_traj.per_date_risk_metrics()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "cb_refactoring", + "language": "python", + "name": "cb_refactoring" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/doc/user-guide/impact.rst b/doc/user-guide/impact.rst index 9046118297..df7e459407 100644 --- a/doc/user-guide/impact.rst +++ b/doc/user-guide/impact.rst @@ -17,6 +17,7 @@ Additionally you can find a guide on how to populate impact data from EM-DAT dat climada_entity_ImpactFuncSet climada_entity_MeasureSet Discount Rates + Risk trajectories Using EM-DAT data Cost Benefit Calculation Probabilistic Yearly Impacts