From 36928134efd4152bdd07ac91446795e2a4d45206 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 18 Mar 2025 17:37:57 +0100 Subject: [PATCH 001/113] Implements equality methods for impf and impfset --- climada/entity/impact_funcs/base.py | 24 +++++++++++++++---- .../entity/impact_funcs/impact_func_set.py | 17 +++++++++++++ 2 files changed, 36 insertions(+), 5 deletions(-) diff --git a/climada/entity/impact_funcs/base.py b/climada/entity/impact_funcs/base.py index 287391a79..321fd2cda 100644 --- a/climada/entity/impact_funcs/base.py +++ b/climada/entity/impact_funcs/base.py @@ -97,6 +97,20 @@ def __init__( self.mdd = mdd if mdd is not None else np.array([]) self.paa = paa if paa is not None else np.array([]) + def __eq__(self, value: object, /) -> bool: + if isinstance(value, ImpactFunc): + return ( + self.haz_type == value.haz_type + and self.id == value.id + and self.name == value.name + and self.intensity_unit == value.intensity_unit + and np.array_equal(self.intensity, value.intensity) + and np.array_equal(self.mdd, value.mdd) + and np.array_equal(self.paa, value.paa) + ) + else: + return False + def calc_mdr(self, inten: Union[float, np.ndarray]) -> np.ndarray: """Interpolate impact function to a given intensity. @@ -177,7 +191,7 @@ def from_step_impf( mdd: tuple[float, float] = (0, 1), paa: tuple[float, float] = (1, 1), impf_id: int = 1, - **kwargs + **kwargs, ): """Step function type impact function. @@ -218,7 +232,7 @@ def from_step_impf( intensity=intensity, mdd=mdd, paa=paa, - **kwargs + **kwargs, ) def set_step_impf(self, *args, **kwargs): @@ -238,7 +252,7 @@ def from_sigmoid_impf( x0: float, haz_type: str, impf_id: int = 1, - **kwargs + **kwargs, ): r"""Sigmoid type impact function hinging on three parameter. @@ -287,7 +301,7 @@ def from_sigmoid_impf( intensity=intensity, paa=paa, mdd=mdd, - **kwargs + **kwargs, ) def set_sigmoid_impf(self, *args, **kwargs): @@ -308,7 +322,7 @@ def from_poly_s_shape( exponent: float, haz_type: str, impf_id: int = 1, - **kwargs + **kwargs, ): r"""S-shape polynomial impact function hinging on four parameter. diff --git a/climada/entity/impact_funcs/impact_func_set.py b/climada/entity/impact_funcs/impact_func_set.py index e94ff8b82..0c332518c 100755 --- a/climada/entity/impact_funcs/impact_func_set.py +++ b/climada/entity/impact_funcs/impact_func_set.py @@ -109,6 +109,23 @@ def __init__(self, impact_funcs: Optional[Iterable[ImpactFunc]] = None): for impf in impact_funcs: self.append(impf) + def __eq__(self, value: object, /) -> bool: + if not isinstance(value, ImpactFuncSet): + return False + + if self._data.keys() != value._data.keys(): + return False + + for haz_type1, id_map1 in self._data.items(): + id_map2 = value._data[haz_type1] + if id_map1.keys() != id_map2.keys(): + return False + for fid, func1 in id_map1.items(): + if not func1 == id_map2[fid]: + return False + + return True + def clear(self): """Reinitialize attributes.""" self._data = dict() # {hazard_type : {id:ImpactFunc}} From 16068968e815e4fd0caf08eb2c1127edd6e585d5 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 18 Mar 2025 17:55:40 +0100 Subject: [PATCH 002/113] adds a few tests --- climada/entity/impact_funcs/test/test_base.py | 75 ++++++++++++++++++- 1 file changed, 73 insertions(+), 2 deletions(-) diff --git a/climada/entity/impact_funcs/test/test_base.py b/climada/entity/impact_funcs/test/test_base.py index b0652a1be..59fc5a676 100644 --- a/climada/entity/impact_funcs/test/test_base.py +++ b/climada/entity/impact_funcs/test/test_base.py @@ -26,6 +26,74 @@ from climada.entity.impact_funcs.base import ImpactFunc +class TestEquality(unittest.TestCase): + """Test equality method""" + + def setUp(self): + self.impf1 = ImpactFunc( + haz_type="TC", + id=1, + intensity=np.array([1, 2, 3]), + mdd=np.array([0.1, 0.2, 0.3]), + paa=np.array([0.4, 0.5, 0.6]), + intensity_unit="m/s", + name="Test Impact", + ) + self.impf2 = ImpactFunc( + haz_type="TC", + id=1, + intensity=np.array([1, 2, 3]), + mdd=np.array([0.1, 0.2, 0.3]), + paa=np.array([0.4, 0.5, 0.6]), + intensity_unit="m/s", + name="Test Impact", + ) + self.impf3 = ImpactFunc( + haz_type="FL", + id=2, + intensity=np.array([4, 5, 6]), + mdd=np.array([0.7, 0.8, 0.9]), + paa=np.array([0.1, 0.2, 0.3]), + intensity_unit="m", + name="Another Impact", + ) + + def test_reflexivity(self): + self.assertEqual(self.impf1, self.impf1) + + def test_symmetry(self): + self.assertEqual(self.impf1, self.impf2) + self.assertEqual(self.impf2, self.impf1) + + def test_transitivity(self): + impf4 = ImpactFunc( + haz_type="TC", + id=1, + intensity=np.array([1, 2, 3]), + mdd=np.array([0.1, 0.2, 0.3]), + paa=np.array([0.4, 0.5, 0.6]), + intensity_unit="m/s", + name="Test Impact", + ) + self.assertEqual(self.impf1, self.impf2) + self.assertEqual(self.impf2, impf4) + self.assertEqual(self.impf1, impf4) + + def test_consistency(self): + self.assertEqual(self.impf1, self.impf2) + self.assertEqual(self.impf1, self.impf2) + + def test_comparison_with_none(self): + self.assertNotEqual(self.impf1, None) + + def test_different_types(self): + self.assertNotEqual(self.impf1, "Not an ImpactFunc") + + def test_inequality(self): + self.assertNotEqual(self.impf1, self.impf3) + self.assertTrue(self.impf1 != self.impf3) + + class TestInterpolation(unittest.TestCase): """Impact function interpolation test""" @@ -139,5 +207,8 @@ def test_aux_vars(impf): # Execute Tests if __name__ == "__main__": - TESTS = unittest.TestLoader().loadTestsFromTestCase(TestInterpolation) - unittest.TextTestRunner(verbosity=2).run(TESTS) + equality_tests = unittest.TestLoader().loadTestsFromTestCase(TestEquality) + interpolation_tests = unittest.TestLoader().loadTestsFromTestCase(TestInterpolation) + unittest.TextTestRunner(verbosity=2).run( + unittest.TestSuite([equality_tests, interpolation_tests]) + ) From 37762285d9911e8d6a89023e2b9138263a206355 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 18 Mar 2025 18:02:38 +0100 Subject: [PATCH 003/113] updates changelog --- CHANGELOG.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 07d6e2869..b07f905d6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,6 +12,9 @@ Code freeze date: YYYY-MM-DD ### Added +- `climada.entity.impact_funcs.base.ImpactFunc.__eq__` method +- `climada.entity.impact_funcs.impact_func_set.ImpactFuncSet.__eq__` method + ### Changed - `Hazard.local_exceedance_intensity`, `Hazard.local_return_period` and `Impact.local_exceedance_impact`, `Impact.local_return_period`, using the `climada.util.interpolation` module: New default (no binning), binning on decimals, and faster implementation [#1012](https://github.com/CLIMADA-project/climada_python/pull/1012) ### Fixed From f6d9febc3985869a0e735ca9da3e7ac0fd621da1 Mon Sep 17 00:00:00 2001 From: Samuel Juhel <10011382+spjuhel@users.noreply.github.com> Date: Mon, 24 Mar 2025 14:03:56 +0100 Subject: [PATCH 004/113] Improves dict comparison Co-authored-by: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> --- .../entity/impact_funcs/impact_func_set.py | 19 ++++--------------- 1 file changed, 4 insertions(+), 15 deletions(-) diff --git a/climada/entity/impact_funcs/impact_func_set.py b/climada/entity/impact_funcs/impact_func_set.py index 0c332518c..358b7e69e 100755 --- a/climada/entity/impact_funcs/impact_func_set.py +++ b/climada/entity/impact_funcs/impact_func_set.py @@ -110,21 +110,10 @@ def __init__(self, impact_funcs: Optional[Iterable[ImpactFunc]] = None): self.append(impf) def __eq__(self, value: object, /) -> bool: - if not isinstance(value, ImpactFuncSet): - return False - - if self._data.keys() != value._data.keys(): - return False - - for haz_type1, id_map1 in self._data.items(): - id_map2 = value._data[haz_type1] - if id_map1.keys() != id_map2.keys(): - return False - for fid, func1 in id_map1.items(): - if not func1 == id_map2[fid]: - return False - - return True + if isinstance(value, ImpactFuncSet): + return self._data == value._data + + return False def clear(self): """Reinitialize attributes.""" From 222644d3cc1829ddd83194e548fcf360ff3be6f0 Mon Sep 17 00:00:00 2001 From: Samuel Juhel <10011382+spjuhel@users.noreply.github.com> Date: Mon, 24 Mar 2025 14:05:17 +0100 Subject: [PATCH 005/113] Applies suggestion from Lukas (1) Co-authored-by: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> --- climada/entity/impact_funcs/base.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/climada/entity/impact_funcs/base.py b/climada/entity/impact_funcs/base.py index 321fd2cda..c51540d57 100644 --- a/climada/entity/impact_funcs/base.py +++ b/climada/entity/impact_funcs/base.py @@ -108,8 +108,7 @@ def __eq__(self, value: object, /) -> bool: and np.array_equal(self.mdd, value.mdd) and np.array_equal(self.paa, value.paa) ) - else: - return False + return False def calc_mdr(self, inten: Union[float, np.ndarray]) -> np.ndarray: """Interpolate impact function to a given intensity. From 29ecee4a52f92b877e49ff19975bec5fa5af4de3 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Wed, 2 Apr 2025 14:33:09 +0200 Subject: [PATCH 006/113] init commit --- climada/trajectories/__init__.py | 18 + climada/trajectories/risk_trajectory.py | 626 ++++++++++++++++++++++++ climada/trajectories/riskperiod.py | 244 +++++++++ climada/trajectories/snapshot.py | 172 +++++++ climada/trajectories/timeseries.py | 138 ++++++ 5 files changed, 1198 insertions(+) create mode 100644 climada/trajectories/__init__.py create mode 100644 climada/trajectories/risk_trajectory.py create mode 100644 climada/trajectories/riskperiod.py create mode 100644 climada/trajectories/snapshot.py create mode 100644 climada/trajectories/timeseries.py diff --git a/climada/trajectories/__init__.py b/climada/trajectories/__init__.py new file mode 100644 index 000000000..bd6a81a78 --- /dev/null +++ b/climada/trajectories/__init__.py @@ -0,0 +1,18 @@ +""" +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 . + +--- +""" diff --git a/climada/trajectories/risk_trajectory.py b/climada/trajectories/risk_trajectory.py new file mode 100644 index 000000000..0b0f49866 --- /dev/null +++ b/climada/trajectories/risk_trajectory.py @@ -0,0 +1,626 @@ +""" +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 . + +--- + +""" + +import datetime +import logging + +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd + +from climada.engine.impact_calc import ImpactCalc +from climada.entity.disc_rates.base import DiscRates +from climada.trajectories.riskperiod import RiskPeriod +from climada.trajectories.snapshot import Snapshot, pairwise + +LOGGER = logging.getLogger(__name__) + + +class RiskTrajectory: + + _grouper = ["measure", "metric"] + + def __init__( + self, + snapshots_list: list[Snapshot], + risk_disc: DiscRates | None = None, + metrics: list[str] = ["aai", "eai", "rp"], + return_periods: list[int] = [100, 500, 1000], + compute_groups=False, + risk_transf_cover=None, + risk_transf_attach=None, + ): + "docstring" + self._metrics_up_to_date: bool = False + self.metrics = metrics + 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 = risk_disc + self.risk_transf_cover = risk_transf_cover + self.risk_transf_attach = risk_transf_attach + LOGGER.debug("Computing risk periods") + self.risk_periods = self._calc_risk_periods(snapshots_list) + self._update_risk_metrics(compute_groups=compute_groups) + + def _calc_risk_periods(self, snapshots): + return [ + RiskPeriod(start_snapshot, end_snapshot) + for start_snapshot, end_snapshot in pairwise(snapshots) + ] + + def _update_risk_metrics(self, compute_groups=False): + results_df = [] + for period in self.risk_periods: + results_df.append( + bayesian_mixer_opti( + period, + self.metrics, + self.return_periods, + compute_groups, + all_groups_name="All", + ) + ) + results_df = pd.concat(results_df, axis=0) + + # duplicate rows arise from overlapping end and start if there's more than two snapshots + results_df.drop_duplicates(inplace=True) + + # reorder the columns (but make sure not to remove possibly important ones in the future) + columns_to_front = ["date", "measure", "metric"] + if compute_groups: + columns_to_front = ["group"] + columns_to_front + self._annual_risk_metrics = results_df[ + columns_to_front + + [ + col + for col in results_df.columns + if col not in columns_to_front + ["group", "risk", "rp"] + ] + + ["risk"] + ] + self._metrics_up_to_date = True + + @staticmethod + def _get_risk_periods( + risk_periods, start_date: datetime.date, end_date: datetime.date + ): + return [ + period + for period in risk_periods + if (start_date >= period.start_date or end_date <= period.end_date) + ] + + def _calc_annual_risk_metrics(self, npv=True): + def npv_transform(group): + start_date = group.index.get_level_values("date").min() + end_date = group.index.get_level_values("date").max() + return calc_npv_cash_flows( + group.values, start_date, end_date, self.risk_disc + ) + + if self._metrics_up_to_date: + df = self._annual_risk_metrics + else: + self._update_risk_metrics() + df = self._annual_risk_metrics + + if npv: + df = df.set_index("date") + grouper = self._grouper + if "group" in df.columns: + grouper = ["group"] + grouper + + df["risk"] = df.groupby( + grouper, + dropna=False, + as_index=False, + group_keys=False, + )["risk"].transform(npv_transform) + df = df.reset_index() + + return df + + @classmethod + def _calc_periods_risk(cls, df: pd.DataFrame, time_unit="year", colname="risk"): + def identify_continuous_periods(group, time_unit): + # Calculate the difference between consecutive dates + if time_unit == "year": + group["date_diff"] = group["date"].dt.year.diff() + if time_unit == "month": + group["date_diff"] = group["date"].dt.month.diff() + if time_unit == "day": + group["date_diff"] = group["date"].dt.day.diff() + if time_unit == "hour": + group["date_diff"] = group["date"].dt.hour.diff() + # Identify breaks in continuity + group["period_id"] = (group["date_diff"] != 1).cumsum() + return group + + grouper = cls._grouper + if "group" in df.columns: + grouper = ["group"] + grouper + + df_sorted = df.sort_values(by=cls._grouper + ["date"]) + # Apply the function to identify continuous periods + df_periods = df_sorted.groupby(grouper, dropna=False, group_keys=False).apply( + identify_continuous_periods, time_unit + ) + + # Group by the identified periods and calculate start and end dates + df_periods = ( + df_periods.groupby(grouper + ["period_id"], dropna=False) + .agg( + start_date=pd.NamedAgg(column="date", aggfunc="min"), + end_date=pd.NamedAgg(column="date", aggfunc="max"), + total=pd.NamedAgg(column=colname, aggfunc="sum"), + ) + .reset_index() + ) + + df_periods["period"] = ( + df_periods["start_date"].astype(str) + + " to " + + df_periods["end_date"].astype(str) + ) + df_periods = df_periods.rename(columns={"total": f"{colname}"}) + df_periods = df_periods.drop(["period_id", "start_date", "end_date"], axis=1) + return df_periods[ + ["period"] + [col for col in df_periods.columns if col != "period"] + ] + + @property + def all_dates_risk_metrics(self): + return self._calc_risk_metrics(total=False, npv=True) + + @property + def total_risk_metrics(self): + return self._calc_risk_metrics(total=True, npv=True) + + def _calc_risk_metrics(self, total=False, npv=True): + df = self._calc_annual_risk_metrics(npv=npv) + if total: + return self._calc_periods_risk(df) + + return df + + def _calc_waterfall_plot_data(self, start_date=None, end_date=None): + 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 + considered_risk_periods = self._get_risk_periods( + self.risk_periods, start_date=start_date, end_date=end_date + ) + + risk_component = { + str(period.start_date) + + "-" + + str(period.end_date): self._calc_risk_component(period) + for period in considered_risk_periods + } + risk_component = pd.concat( + risk_component.values(), keys=risk_component.keys(), names=["Period"] + ).reset_index() + risk_component = risk_component.loc[ + (risk_component["date"].dt.date >= start_date) + & (risk_component["date"].dt.date <= end_date) + ] + risk_component["Base risk"] = risk_component["Base risk"].min() + risk_component[["Change in Exposure", "Change in Hazard (with Exposure)"]] = ( + risk_component[["Change in Exposure", "Change in Hazard (with Exposure)"]] + .replace(0, None) + .ffill() + .fillna(0.0) + ) + return risk_component + + def _calc_risk_component(self, period: RiskPeriod): + imp_mats_H0 = period.imp_mats_0 + imp_mats_H1 = period.imp_mats_1 + freq_H0 = period.snapshot0.hazard.frequency + freq_H1 = period.snapshot1.hazard.frequency + dately_eai_H0, dately_eai_H1 = calc_dately_eais( + imp_mats_H0, imp_mats_H1, freq_H0, freq_H1 + ) + dately_aai_H0, dately_aai_H1 = calc_dately_aais(dately_eai_H0, dately_eai_H1) + prop_H1 = np.linspace(0, 1, num=len(period.date_idx)) + prop_H0 = 1 - prop_H1 + dately_aai = prop_H0 * dately_aai_H0 + prop_H1 * dately_aai_H1 + + risk_dev_0 = dately_aai_H0 - dately_aai[0] + risk_cc_0 = dately_aai - (risk_dev_0 + dately_aai[0]) + df = pd.DataFrame( + { + "Base risk": dately_aai - (risk_dev_0 + risk_cc_0), + "Change in Exposure": risk_dev_0, + "Change in Hazard (with Exposure)": risk_cc_0, + }, + index=period.date_idx, + ) + return df.round(1) + + def plot_dately_waterfall(self, ax=None, start_date=None, end_date=None): + if ax is None: + _, ax = plt.subplots(figsize=(12, 6)) + 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_component = self._calc_waterfall_plot_data( + start_date=start_date, end_date=end_date + ) + risk_component.plot(ax=ax, kind="bar", x="date", stacked=True) + # Construct y-axis label and title based on parameters + value_label = "USD" + title_label = ( + f"Risk between {start_date} and {end_date} (Annual Average impact)" + ) + + ax.set_title(title_label) + ax.set_ylabel(value_label) + return ax + + def plot_waterfall(self, ax=None, start_date=None, end_date=None): + 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_component = self._calc_waterfall_plot_data( + start_date=start_date, end_date=end_date + ) + if ax is None: + _, ax = plt.subplots(figsize=(8, 5)) + + risk_component = risk_component.loc[ + (risk_component["date"].dt.date == end_date) + ].squeeze() + + labels = [ + f"Risk {start_date}", + f"Exposure {end_date}", + f"Hazard {end_date}¹", + f"Total Risk {end_date}", + ] + values = [ + risk_component["Base risk"], + risk_component["Change in Exposure"], + risk_component["Change in Hazard (with Exposure)"], + risk_component["Base risk"] + + risk_component["Change in Exposure"] + + risk_component["Change in Hazard (with Exposure)"], + ] + bottoms = [ + 0.0, + risk_component["Base risk"], + risk_component["Base risk"] + risk_component["Change in Exposure"], + 0.0, + ] + + ax.bar( + labels, + values, + bottom=bottoms, + edgecolor="black", + color=["tab:blue", "tab:orange", "tab:green", "tab:red"], + ) + for i in range(len(values)): + ax.text( + labels[i], + values[i] + bottoms[i], + f"{values[i]:.0e}", + ha="center", + va="bottom", + color="black", + ) + + # Construct y-axis label and title based on parameters + value_label = "USD" + title_label = f"Risk at {start_date} and {end_date} (Annual Average impact)" + + ax.set_title(title_label) + ax.set_ylabel(value_label) + # ax.tick_params(axis='x', labelrotation=90,) + ax.annotate( + """¹: The increase in risk due to hazard denotes the difference in risk with future exposure +and hazard compared to risk with future exposure and present hazard.""", + xy=(0.0, -0.15), + xycoords="axes fraction", + ha="left", + va="center", + fontsize=8, + ) + + return ax + + +def calc_npv_cash_flows(cash_flows, start_date, end_date=None, disc=None): + # If no discount rates are provided, return the cash flows as is + if not disc: + return cash_flows + + if not isinstance(cash_flows, pd.Series) or not isinstance( + cash_flows.index, pd.DatetimeIndex + ): + raise ValueError("cash_flows must be a pandas Series with a datetime index") + + # Determine the end date if not provided + if end_date is None: + end_date = cash_flows.index[-1] + + df = cash_flows.to_frame(name="cash_flow") + df["year"] = df.index.year + + # Merge with the discount rates based on the year + df = df.merge( + pd.DataFrame({"year": disc.years, "rate": disc.rates}), on="year", how="left" + ) + + # Calculate the discount factors + df["discount_factor"] = (1 / (1 + df["rate"])) ** ( + df.index - start_date + ).days / 365.25 + + # Apply the discount factors to the cash flows + df["npv_cash_flow"] = df["cash_flow"] * df["discount_factor"] + + return df["npv_cash_flow"] + + +def calc_dately_eais(imp_mats_0, imp_mats_1, frequency_0, frequency_1): + """ + Calculate dately expected annual impact (EAI) values for two scenarios. + + Parameters + ---------- + imp_mats_0 : list of np.ndarray + List of interpolated impact matrices for scenario 0. + imp_mats_1 : list of np.ndarray + List of interpolated impact matrices for scenario 1. + frequency_0 : np.ndarray + Frequency values associated with scenario 0. + frequency_1 : np.ndarray + Frequency values associated with scenario 1. + + Returns + ------- + tuple + Tuple containing: + - dately_eai_exp_0 : list of float + Dately expected annual impacts for scenario 0. + - dately_eai_exp_1 : list of float + Dately expected annual impacts for scenario 1. + """ + dately_eai_exp_0 = [ + ImpactCalc.eai_exp_from_mat(imp_mat, frequency_0) for imp_mat in imp_mats_0 + ] + dately_eai_exp_1 = [ + ImpactCalc.eai_exp_from_mat(imp_mat, frequency_1) for imp_mat in imp_mats_1 + ] + return dately_eai_exp_0, dately_eai_exp_1 + + +def calc_dately_aais(dately_eai_exp_0, dately_eai_exp_1): + """ + Calculate dately aggregate annual impact (AAI) values for two scenarios. + + Parameters + ---------- + dately_eai_exp_0 : list of float + Dately expected annual impacts for scenario 0. + dately_eai_exp_1 : list of float + Dately expected annual impacts for scenario 1. + + Returns + ------- + tuple + Tuple containing: + - dately_aai_0 : list of float + Aggregate annual impact values for scenario 0. + - dately_aai_1 : list of float + Aggregate annual impact values for scenario 1. + """ + dately_aai_0 = [ + ImpactCalc.aai_agg_from_eai_exp(eai_exp) for eai_exp in dately_eai_exp_0 + ] + dately_aai_1 = [ + ImpactCalc.aai_agg_from_eai_exp(eai_exp) for eai_exp in dately_eai_exp_1 + ] + return dately_aai_0, dately_aai_1 + + +def calc_freq_curve(imp_mat_intrpl, frequency, return_per=None): + """ + Calculate the frequency curve + + Parameters: + imp_mat_intrpl (np.array): The interpolated impact matrix + frequency (np.array): The frequency of the hazard + return_per (np.array): The return period + + Returns: + ifc_return_per (np.array): The impact exceeding frequency + ifc_impact (np.array): The impact exceeding the return period + """ + + # Calculate the at_event make the np.array + 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 ifc_impact + + +def calc_dately_rps(imp_mats_0, imp_mats_1, frequency_0, frequency_1, return_periods): + """ + Calculate dately return period impact values for two scenarios. + + Parameters + ---------- + imp_mats_0 : list of np.ndarray + List of interpolated impact matrices for scenario 0. + imp_mats_1 : list of np.ndarray + List of interpolated impact matrices for scenario 1. + frequency_0 : np.ndarray + Frequency values for scenario 0. + frequency_1 : np.ndarray + Frequency values for scenario 1. + return_periods : list of int + Return periods to calculate impact values for. + + Returns + ------- + tuple + Tuple containing: + - rp_0 : list of np.ndarray + Dately return period impact values for scenario 0. + - rp_1 : list of np.ndarray + Dately return period impact values for scenario 1. + """ + rp_0 = [ + calc_freq_curve(imp_mat, frequency_0, return_periods) for imp_mat in imp_mats_0 + ] + rp_1 = [ + calc_freq_curve(imp_mat, frequency_1, return_periods) for imp_mat in imp_mats_1 + ] + return rp_0, rp_1 + + +def get_eai_exp(eai_exp, group_map): + """ + Aggregate expected annual impact (EAI) by groups. + + Parameters + ---------- + eai_exp : np.ndarray + Array of EAI values. + group_map : dict + Mapping of group names to indices for aggregation. + + Returns + ------- + dict + Dictionary of EAI values aggregated by specified groups. + """ + eai_region_id = {} + for group_name, exp_indices in group_map.items(): + eai_region_id[group_name] = np.sum(eai_exp[:, exp_indices], axis=1) + return eai_region_id + + +def bayesian_mixer_opti( + risk_period, + metrics, + return_periods, + compute_groups=False, + all_groups_name: str | None = None, +): + """ + Perform Bayesian mixing of impacts across snapshots. + + Parameters + ---------- + start_snapshot : Snapshot + The starting snapshot. + end_snapshot : Snapshot + The ending snapshot. + metrics : list of str + Metrics to calculate (e.g., 'eai', 'aai', 'rp'). + return_periods : list of int + Return periods for calculating impact values. + groups : dict, optional + Mapping of group names to indices for aggregating EAI values by group. + all_groups_name : str, optional + Name for all-groups aggregation in the output. + risk_transf_cover : float, optional + Coverage level for risk transfer calculations. + risk_transf_attach : float, optional + Attachment point for risk transfer calculations. + calc_residual : bool, optional + Whether to calculate residual impacts after applying risk transfer. + + Returns + ------- + pd.DataFrame + DataFrame of calculated impact values by date, group, and metric. + """ + # 1. Interpolate in between dates + + all_groups_n = pd.NA if all_groups_name is None else all_groups_name + + prop_H0, prop_H1 = risk_period._prop_H0, risk_period._prop_H1 + frequency_0 = risk_period.snapshot0.hazard.frequency + frequency_1 = risk_period.snapshot1.hazard.frequency + imp_mats_0, imp_mats_1 = risk_period.get_interp() + dately_eai_exp_0, dately_eai_exp_1 = calc_dately_eais( + imp_mats_0, imp_mats_1, frequency_0, frequency_1 + ) + date_idx = risk_period.date_idx + res = [] + if "aai" in metrics: + dately_aai_0, dately_aai_1 = calc_dately_aais( + dately_eai_exp_0, dately_eai_exp_1 + ) + dately_aai = prop_H0 * dately_aai_0 + prop_H1 * dately_aai_1 + aai_df = pd.DataFrame(index=date_idx, columns=["risk"], data=dately_aai) + aai_df["group"] = all_groups_n + aai_df["metric"] = "aai" + aai_df.reset_index(inplace=True) + res.append(aai_df) + + if "rp" in metrics: + rp_0, rp_1 = calc_dately_rps( + imp_mats_0, imp_mats_1, frequency_0, frequency_1, return_periods + ) + dately_rp = np.multiply(prop_H0.reshape(-1, 1), rp_0) + np.multiply( + prop_H1.reshape(-1, 1), rp_1 + ) + rp_df = pd.DataFrame( + index=date_idx, columns=return_periods, data=dately_rp + ).melt(value_name="risk", var_name="rp", ignore_index=False) + rp_df.reset_index(inplace=True) + rp_df["group"] = all_groups_n + rp_df["metric"] = "rp_" + rp_df["rp"].astype(str) + res.append(rp_df) + + if compute_groups: + dately_eai = np.multiply( + prop_H0.reshape(-1, 1), dately_eai_exp_0 + ) + np.multiply(prop_H1.reshape(-1, 1), dately_eai_exp_1) + eai_group_df = pd.DataFrame( + data=dately_eai.T, + index=risk_period.snapshot1.exposure.gdf["group_id"], + columns=risk_period.date_idx, + ) + eai_group_df = eai_group_df.groupby(eai_group_df.index).sum() + eai_group_df = eai_group_df.melt( + ignore_index=False, value_name="risk" + ).reset_index(names="group") + eai_group_df["metric"] = "aai" + res.append(eai_group_df) + + ret = pd.concat(res, axis=0) + ret["measure"] = risk_period.measure_name + return ret diff --git a/climada/trajectories/riskperiod.py b/climada/trajectories/riskperiod.py new file mode 100644 index 000000000..607b67299 --- /dev/null +++ b/climada/trajectories/riskperiod.py @@ -0,0 +1,244 @@ +""" +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 and SnapshotsCollection classes. + +""" + +import copy +import logging + +import numpy as np +import pandas as pd +from scipy.sparse import lil_matrix + +from climada.engine.impact_calc import ImpactCalc +from climada.entity.impact_funcs.impact_func_set import ImpactFuncSet +from climada.entity.measures.base import Measure +from climada.trajectories.snapshot import Snapshot + +LOGGER = logging.getLogger(__name__) + + +class RiskPeriod: + + # TODO: make lazy / delayed interpolation and impacts + # TODO: make MeasureRiskPeriod child class (with effective start/end) + # TODO: special case where hazard and exposure don't change (no need to interpolate) ? + + def __init__( + self, + snapshot0: Snapshot, + snapshot1: Snapshot, + measure_name="no_measure", + time_freq="YS", + risk_transf_cover=None, + risk_transf_attach=None, + calc_residual=True, + ): + LOGGER.debug( + f"Initializing new RiskPeriod from {snapshot0.date} to {snapshot1.date}, with snapshot0: {id(snapshot0)}, snapshot1: {id(snapshot1)}" + ) + self.snapshot0 = snapshot0 + self.snapshot1 = snapshot1 + self.start_date = snapshot0.date + self.end_date = snapshot1.date + self.time_frequency = time_freq + self.date_idx = pd.date_range( + snapshot0.date, snapshot1.date, freq=time_freq, name="date" + ) + self.measure_name = measure_name + self.impfset = self._merge_impfset(snapshot0.impfset, snapshot1.impfset) + + self._prop_H1 = np.linspace(0, 1, num=len(self.date_idx)) + self._prop_H0 = 1 - self._prop_H1 + self._exp_y0 = snapshot0.exposure + self._exp_y1 = snapshot1.exposure + self._haz_y0 = snapshot0.hazard + self._haz_y1 = snapshot1.hazard + + # Compute impacts once + LOGGER.debug("Computing snapshots combination impacts") + imp_E0H0 = self._compute_impact(self._exp_y0, self._haz_y0) + imp_E1H0 = self._compute_impact(self._exp_y1, self._haz_y0) + imp_E0H1 = self._compute_impact(self._exp_y0, self._haz_y1) + imp_E1H1 = self._compute_impact(self._exp_y1, self._haz_y1) + + # Modify the impact matrices if risk transfer is provided + # TODO: See where this ends up + imp_E0H0.imp_mat = self.calc_residual_or_risk_transf_imp_mat( + imp_E0H0.imp_mat, risk_transf_attach, risk_transf_cover, calc_residual + ) + imp_E1H0.imp_mat = self.calc_residual_or_risk_transf_imp_mat( + imp_E1H0.imp_mat, risk_transf_attach, risk_transf_cover, calc_residual + ) + imp_E0H1.imp_mat = self.calc_residual_or_risk_transf_imp_mat( + imp_E0H1.imp_mat, risk_transf_attach, risk_transf_cover, calc_residual + ) + imp_E1H1.imp_mat = self.calc_residual_or_risk_transf_imp_mat( + imp_E1H1.imp_mat, risk_transf_attach, risk_transf_cover, calc_residual + ) + + LOGGER.debug("Interpolating impact matrices between E0H0 and E1H0") + time_points = len(self.date_idx) + self.imp_mats_0 = interpolate_imp_mat(imp_E0H0, imp_E1H0, time_points) + LOGGER.debug("Interpolating impact matrices between E0H1 and E1H1") + self.imp_mats_1 = interpolate_imp_mat(imp_E0H1, imp_E1H1, time_points) + LOGGER.debug("Done") + + self._initialized = True + + @staticmethod + def _merge_impfset(impfs1: ImpactFuncSet, impfs2: ImpactFuncSet): + if impfs1 == impfs2: + return impfs1 + else: + LOGGER.warning( + "Impact function sets differ. Will update the first one with the second." + ) + impfs1._data |= impfs2._data # Merges dictionaries (priority to impfs2) + return impfs1 + + def _compute_impact(self, exposure, hazard): + """Compute the impact once per unique exposure-hazard pair.""" + return ImpactCalc(exposure, self.impfset, hazard).impact() + + def get_interp(self): + return self.imp_mats_0, self.imp_mats_1 + + def apply_measure(self, measure: Measure): + # Apply measure on snapshot and return risk period instance + snapshot0 = self.snapshot0.apply_measure(measure) + snapshot1 = self.snapshot1.apply_measure(measure) + return RiskPeriod(snapshot0, snapshot1, measure_name=measure.name) + + @classmethod + def calc_residual_or_risk_transf_imp_mat( + cls, imp_mat, attachment=None, cover=None, calc_residual=True + ): + """ + Calculate either the residual or the risk transfer impact matrix. + + The impact matrix is adjusted based on the total impact for each event. + When calculating the residual impact, the result is the total impact minus + the risk layer. The risk layer is defined as the minimum of the cover and + the maximum of the difference between the total impact and the attachment. + If `calc_residual` is False, the function returns the risk layer matrix + instead of the residual. + + Parameters + ---------- + imp_mat : scipy.sparse.csr_matrix + The original impact matrix to be scaled. + attachment : float, optional + The attachment point for the risk layer. + cover : float, optional + The maximum coverage for the risk layer. + calc_residual : bool, default=True + Determines if the function calculates the residual (if True) or the + risk layer (if False). + + Returns + ------- + scipy.sparse.csr_matrix + The adjusted impact matrix, either residual or risk transfer. + + Example + ------- + >>> calc_residual_or_risk_transf_imp_mat(imp_mat, attachment=100, cover=500, calc_residual=True) + Residual impact matrix with applied risk layer adjustments. + """ + if attachment and cover: + # Make a copy of the impact matrix + imp_mat = copy.deepcopy(imp_mat) + # Calculate the total impact per event + total_at_event = imp_mat.sum(axis=1).A1 + # Risk layer at event + transfer_at_event = np.minimum( + np.maximum(total_at_event - attachment, 0), cover + ) + # Resiudal impact + residual_at_event = np.maximum(total_at_event - transfer_at_event, 0) + + # Calculate either the residual or transfer impact matrix + # Choose the denominator to rescale the impact values + if calc_residual: + # Rescale the impact values + numerator = residual_at_event + else: + # Rescale the impact values + numerator = transfer_at_event + + # Rescale the impact values + rescale_impact_values = np.divide( + numerator, + total_at_event, + out=np.zeros_like(numerator, dtype=float), + where=total_at_event != 0, + ) + + # The multiplication is broadcasted across the columns for each row + result_matrix = imp_mat.multiply(rescale_impact_values[:, np.newaxis]) + + return result_matrix + + else: + + return imp_mat + + +def interpolate_imp_mat(imp0, imp1, time_points): + """ + Interpolate between two impact matrices over a specified time range. + + Parameters + ---------- + imp0 : ImpactCalc + The impact calculation for the starting time. + imp1 : ImpactCalc + The impact calculation for the ending time. + time_points: + The number of points to interpolate. + + Returns + ------- + list of np.ndarray + List of interpolated impact matrices for each time points in the specified range. + """ + + def interpolate_sm(mat_start, mat_end, time, time_points): + """Perform linear interpolation between two matrices for a specified time point.""" + if time > time_points: + raise ValueError("time point must be within the range") + + ratio = time / (time_points - 1) + + # Convert the input matrices to a format that allows efficient modification of its elements + mat_start = lil_matrix(mat_start) + mat_end = lil_matrix(mat_end) + + # Perform the linear interpolation + mat_interpolated = mat_start + ratio * (mat_end - mat_start) + + return mat_interpolated + + LOGGER.debug(f"imp0: {imp0.imp_mat.data[0]}, imp1: {imp1.imp_mat.data[0]}") + return [ + interpolate_sm(imp0.imp_mat, imp1.imp_mat, time, time_points) + for time in range(time_points) + ] diff --git a/climada/trajectories/snapshot.py b/climada/trajectories/snapshot.py new file mode 100644 index 000000000..844693d47 --- /dev/null +++ b/climada/trajectories/snapshot.py @@ -0,0 +1,172 @@ +""" +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 and SnapshotsCollection classes. + +""" + +import copy +import datetime +import itertools +import logging +from dataclasses import InitVar, dataclass, field +from weakref import WeakValueDictionary + +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__) + + +# TODO: Improve and make it an __eq__ function within Hazard? +def hazard_data_equal(haz1: Hazard, haz2: Hazard) -> bool: + intensity_eq = ( + haz1.intensity != haz2.intensity + ).nnz == 0 # type:ignore (__neq__ type hint is bool) + freq_eq = (haz1.frequency == haz2.frequency).all() + frac_eq = ( + haz1.fraction != haz2.fraction + ).nnz == 0 # type:ignore (__neq__ type hint is bool) + return intensity_eq and freq_eq and frac_eq + + +class _SnapData: + """ + A snapshot of exposure, hazard, and impact function. + + Attributes + ---------- + exposure : Exposures + Exposure data for the snapshot. + hazard : Hazard + Hazard data for the snapshot. + impfset : ImpactFuncSet + Impact function set associated with the snapshot. + """ + + # Class-level cache + def __init__( + self, exposure: Exposures, hazard: Hazard, impfset: ImpactFuncSet + ) -> None: + self.exposure = copy.deepcopy(exposure) + self.hazard = copy.deepcopy(hazard) + self.impfset = copy.deepcopy(impfset) + + def __eq__(self, value, /) -> bool: + if not isinstance(value, _SnapData): + return False + if self is value: + return True + same_exposure = self.exposure.gdf.equals(value.exposure.gdf) + same_hazard = hazard_data_equal(self.hazard, value.hazard) + same_impfset = self.impfset == value.impfset + return same_exposure and same_hazard and same_impfset + + +class Snapshot: + """ + A snapshot of exposure, hazard, and impact function at a specific date. + + Attributes + ---------- + date : datetime + Date of the snapshot. + + Notes + ----- + + The object creates copies of the exposure hazard and impact function set. + """ + + def __init__( + self, + exposure: Exposures, + hazard: Hazard, + impfset: ImpactFuncSet, + date: int | datetime.date | str, + ) -> None: + self._data = _SnapData(exposure, hazard, impfset) + self.measure = None + self.date = self._convert_to_date(date) + + @property + def exposure(self) -> Exposures: + """Exposure data for the snapshot.""" + return self._data.exposure + + @property + def hazard(self) -> Hazard: + """Hazard data for the snapshot.""" + return self._data.hazard + + @property + def impfset(self) -> ImpactFuncSet: + """Impact function set data for the snapshot.""" + return self._data.impfset + + @staticmethod + def _convert_to_date(date_arg) -> datetime.date: + if isinstance(date_arg, int): + # Assume the integer represents a year + return datetime.date(date_arg, 1, 1) + elif 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: + raise ValueError("String must be in the format 'YYYY-MM-DD'") + elif isinstance(date_arg, datetime.date): + # Already a date object + return date_arg + else: + raise TypeError("date_arg must be an int, str, or datetime.date") + + def apply_measure(self, measure: Measure): + LOGGER.debug(f"Applying measure {measure.name} on snapshot {id(self)}") + exp_new, impfset_new, haz_new = measure.apply( + self.exposure, self.impfset, self.hazard + ) + snap = Snapshot(exp_new, haz_new, impfset_new, self.date) + snap.measure = measure + return snap + + +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)] + """ + a, b = itertools.tee(container) + next(b, None) + return zip(a, b) diff --git a/climada/trajectories/timeseries.py b/climada/trajectories/timeseries.py new file mode 100644 index 000000000..c81c885f4 --- /dev/null +++ b/climada/trajectories/timeseries.py @@ -0,0 +1,138 @@ +""" +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 . + +--- + +""" + +import copy +from datetime import datetime + +import numpy as np + +from climada.hazard.base import Hazard + + +def get_dates(haz: Hazard): + """ + Convert ordinal dates from a Hazard object to datetime objects. + + Parameters + ---------- + haz : Hazard + A Hazard instance with ordinal date values. + + Returns + ------- + list of datetime + List of datetime objects corresponding to the ordinal dates in `haz`. + + Example + ------- + >>> haz = Hazard(...) + >>> get_dates(haz) + [datetime(2020, 1, 1), datetime(2020, 1, 2), ...] + """ + return [datetime.fromordinal(date) for date in haz.date] + + +def get_years(haz: Hazard): + """ + Extract unique years from ordinal dates in a Hazard object. + + Parameters + ---------- + haz : Hazard + A Hazard instance containing ordinal date values. + + Returns + ------- + np.ndarray + Array of unique years as integers, derived from the ordinal dates in `haz`. + + Example + ------- + >>> haz = Hazard(...) + >>> get_years(haz) + array([2020, 2021, ...]) + """ + return np.unique(np.array([datetime.fromordinal(date).year for date in haz.date])) + + +def grow_exp(exp, exp_growth_rate, elapsed): + """ + Apply exponential growth to the exposure values over a specified period. + + Parameters + ---------- + exp : Exposures + The initial Exposures object with values to be grown. + exp_growth_rate : float + The annual growth rate to apply (in decimal form, e.g., 0.01 for 1%). + elapsed : int + Number of years over which to apply the growth. + + Returns + ------- + Exposures + A deep copy of the original Exposures object with grown exposure values. + + Example + ------- + >>> exp = Exposures(...) + >>> grow_exp(exp, 0.01, 5) + Exposures object with values grown by 5%. + """ + exp_grown = copy.deepcopy(exp) + # Exponential growth + exp_growth_rate = 0.01 + exp_grown.gdf.value = exp_grown.gdf.value * (1 + exp_growth_rate) ** elapsed + return exp_grown + + +class TBRTrajectories: + + # Compute impacts for trajectories with present exposure and future exposure and interpolate in between + # + + @classmethod + def create_hazard_yearly_set(cls, haz: Hazard): + haz_set = {} + years = get_years(haz) + for year in range(years.min(), years.max(), 1): + haz_set[year] = haz.select( + date=[f"{str(year)}-01-01", f"{str(year+1)}-01-01"] + ) + + return haz_set + + @classmethod + def create_exposure_set(cls, snapshot_years, exp1, exp2=None, growth=None): + exp_set = {} + year_0 = snapshot_years.min() + if exp2 is None: + if growth is None: + raise ValueError("Need to specify either final exposure or growth.") + else: + exp_set = { + year: grow_exp(exp1, growth, year - year_0) + for year in snapshot_years + } + else: + exp_set = { + year: np.interp(exp1, exp2, year - year_0) for year in snapshot_years + } + return exp_set From d7c0f23216ddf1f51721fff49baf60910c9039fc Mon Sep 17 00:00:00 2001 From: spjuhel Date: Wed, 2 Apr 2025 15:00:30 +0200 Subject: [PATCH 007/113] Pushes tutorial notebook --- doc/tutorial/climada_trajectories.ipynb | 896 ++++++++++++++++++++++++ 1 file changed, 896 insertions(+) create mode 100644 doc/tutorial/climada_trajectories.ipynb diff --git a/doc/tutorial/climada_trajectories.ipynb b/doc/tutorial/climada_trajectories.ipynb new file mode 100644 index 000000000..2785a3623 --- /dev/null +++ b/doc/tutorial/climada_trajectories.ipynb @@ -0,0 +1,896 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "af79f465-fbb3-43e1-80fa-40ac378b7b2b", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "id": "a50d00c0-a08d-4877-87ac-e6f0c2a4bc60", + "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.\n", + "\n", + "Currently it proposes to look at the evolution between defined points in time and in the future we plan to also allow use a timeseries-oriented approach.\n", + "\n", + "In this tutorial we present the current possibilities offered by the module." + ] + }, + { + "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. This object acts as a wrapper of the classic risk framework composed of Exposure, Hazard and Vulnerability. As such it is define for a specific year, and contains references to an `Exposures`, a `Hazard`, and an `ImpactFuncSet` object.\n", + "\n", + "Next we show how to instantiate such a `Snapshot`. Note however that they are of little use by themselves, and what you will really use are `SnapshotsCollection` which we present right after." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "0d52dfa2-5836-4693-ad5d-7f10ad21c695", + "metadata": {}, + "outputs": [], + "source": [ + "import datetime" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f4ff8ced-0050-436d-9efc-e3802fc70b37", + "metadata": {}, + "outputs": [], + "source": [ + "test = {0: \"A\"}" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "8c2e89cd-cb2a-4a0c-9460-9614470a6bb2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list(test.keys())[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dec203d1-943f-41d8-9542-009f288b937b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "ERROR 1: PROJ: proj_create_from_database: Open of /home/sjuhel/miniforge3/envs/cb_refactoring/share/proj failed\n", + "/home/sjuhel/miniforge3/envs/cb_refactoring/lib/python3.10/site-packages/dask/dataframe/_pyarrow_compat.py:15: FutureWarning: Minimal version of pyarrow will soon be increased to 14.0.1. You are using 12.0.1. Please consider upgrading.\n", + " warnings.warn(\n" + ] + } + ], + "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", + "\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", + "exp_present.assign_centroids(haz_present, distance=\"approx\")\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", + "snap = Snapshot(exp_present, haz_present, impf_set, 2018)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "aa0becca-d334-40b4-86c0-1959c750f6d5", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "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": [ + "snap.exposure.plot_raster()\n", + "snap.hazard.plot_intensity(0)\n", + "snap.impfset.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "8e8458c3-a3f9-4210-9de0-15293167f2f9", + "metadata": {}, + "source": [ + "As stated previously, it makes little sense to define a Snapshot alone, so your main entry point should rather be the `SnapshotsCollection`.\n", + "For this let us define a future point in time:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c516c861-c5c1-475b-82e2-c867c5c08ec9", + "metadata": {}, + "outputs": [], + "source": [ + "import copy\n", + "\n", + "future_year = 2040\n", + "\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", + "exp_future.assign_centroids(haz_future, distance=\"approx\")\n", + "impf_set = ImpactFuncSet(\n", + " [\n", + " ImpfTropCyclone.from_emanuel_usa(),\n", + " ImpfTropCyclone.from_emanuel_usa(impf_id=2, v_half=60.0),\n", + " ]\n", + ")\n", + "exp_future.gdf.rename(columns={\"impf_\": \"impf_TC\"}, inplace=True)\n", + "exp_future.gdf[\"impf_TC\"] = 2" + ] + }, + { + "cell_type": "markdown", + "id": "05009191-8a5f-4b38-a282-6c433924d4be", + "metadata": {}, + "source": [ + "Note how we use only one set of impact function `impf_set`, with one impact function for the present (id=1) and one for the future (id=2)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "3b909d67-9e89-4a50-905c-de616c9d5a0a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([,\n", + " ],\n", + " dtype=object)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "impf_set.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a9dd7b63-c577-4b60-87f8-bc2b8782c100", + "metadata": {}, + "outputs": [], + "source": [ + "snap2 = Snapshot(exp_future, haz_future, impf_set, 2040)" + ] + }, + { + "cell_type": "markdown", + "id": "8fa675df-c8ea-40fe-a1a1-73f2495c536c", + "metadata": {}, + "source": [ + "Now we can define a list of two snapshots, present and future:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "15ca9827-029c-4ca3-aa5e-377aca135f89", + "metadata": {}, + "outputs": [], + "source": [ + "snapcol = [snap, snap2]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9ee5e65f-ac42-4718-9ccb-951c92d7cc87", + "metadata": {}, + "outputs": [], + "source": [ + "from climada.trajectories.riskperiod import RiskPeriod" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "1c4c4782-e95b-4a75-ad49-623b8c91a1d0", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Impact function sets differ. Will update the first one with the second.\n" + ] + } + ], + "source": [ + "rp = RiskPeriod(snap, snap2)" + ] + }, + { + "cell_type": "markdown", + "id": "27ca72b1-b1fa-4cd2-8f74-a69dc6eb3c9c", + "metadata": {}, + "source": [ + "Based on a list of snapshots, you can then evaluate a risk trajectory using a `RiskTrajectory` object.\n", + "\n", + "This object will hold yearly risk metrics for all the years between the different snapshots in the given collection, in this example, from 2020 to 2040. This requires a bit of computation and memory, especially for large regions or extended range of time." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "ff177685-bf41-49c9-8b86-043855862d0d", + "metadata": {}, + "outputs": [], + "source": [ + "from climada.trajectories.risk_trajectory import RiskTrajectory\n", + "\n", + "risk_traj = RiskTrajectory(snapcol, compute_groups=True)" + ] + }, + { + "cell_type": "markdown", + "id": "68d9e0c7-8efd-44fb-8512-cd480e510c50", + "metadata": {}, + "source": [ + "From this object you can access different yearly risk metrics:\n", + "\n", + "* Annual Average Impact (aai)\n", + "* Estimated impact for different return periods (100, 500 and 1000 by default)\n", + "* (if `compute_groups` was set to True) Annual Average Impact per group_id from the exposure (when group is not NaN)" + ] + }, + { + "cell_type": "markdown", + "id": "00e0a09b-9dd6-4378-81a1-cda5290f9aa4", + "metadata": {}, + "source": [ + "You can also plot the \"components\" of the change in risk via a waterfall graph, both over the whole period:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "866db75c-5b21-4134-9f4e-f7213ad49f18", + "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", + " \n", + " \n", + "
periodgroupmeasuremetricrisk
02018-01-01 to 2040-01-010no_measureaai1.487445e+07
12018-01-01 to 2040-01-011no_measureaai9.945312e+09
22018-01-01 to 2040-01-01Allno_measureaai9.960186e+09
32018-01-01 to 2040-01-01Allno_measurerp_1003.288826e+11
42018-01-01 to 2040-01-01Allno_measurerp_10008.369369e+11
52018-01-01 to 2040-01-01Allno_measurerp_5008.369369e+11
\n", + "
" + ], + "text/plain": [ + " period group measure metric risk\n", + "0 2018-01-01 to 2040-01-01 0 no_measure aai 1.487445e+07\n", + "1 2018-01-01 to 2040-01-01 1 no_measure aai 9.945312e+09\n", + "2 2018-01-01 to 2040-01-01 All no_measure aai 9.960186e+09\n", + "3 2018-01-01 to 2040-01-01 All no_measure rp_100 3.288826e+11\n", + "4 2018-01-01 to 2040-01-01 All no_measure rp_1000 8.369369e+11\n", + "5 2018-01-01 to 2040-01-01 All no_measure rp_500 8.369369e+11" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "risk_traj.total_risk_metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "2c3f0d17-17ef-4f38-a01f-b4567a492eb1", + "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", + " \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", + "
dategroupmeasuremetricrisk
02018-01-01Allno_measureaai1.840432e+08
12019-01-01Allno_measureaai2.055335e+08
22020-01-01Allno_measureaai2.271876e+08
32021-01-01Allno_measureaai2.490056e+08
42022-01-01Allno_measureaai2.709873e+08
..................
1332038-01-011no_measureaai6.440116e+08
1342039-01-010no_measureaai1.003259e+06
1352039-01-011no_measureaai6.687412e+08
1362040-01-010no_measureaai1.040877e+06
1372040-01-011no_measureaai6.936344e+08
\n", + "

138 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " date group measure metric risk\n", + "0 2018-01-01 All no_measure aai 1.840432e+08\n", + "1 2019-01-01 All no_measure aai 2.055335e+08\n", + "2 2020-01-01 All no_measure aai 2.271876e+08\n", + "3 2021-01-01 All no_measure aai 2.490056e+08\n", + "4 2022-01-01 All no_measure aai 2.709873e+08\n", + ".. ... ... ... ... ...\n", + "133 2038-01-01 1 no_measure aai 6.440116e+08\n", + "134 2039-01-01 0 no_measure aai 1.003259e+06\n", + "135 2039-01-01 1 no_measure aai 6.687412e+08\n", + "136 2040-01-01 0 no_measure aai 1.040877e+06\n", + "137 2040-01-01 1 no_measure aai 6.936344e+08\n", + "\n", + "[138 rows x 5 columns]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "risk_traj.all_dates_risk_metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "08c226a4-944b-4301-acfa-602adde980a5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "risk_traj.plot_waterfall()" + ] + }, + { + "cell_type": "markdown", + "id": "7896af66-b0aa-4418-b22e-c64fd4d2cfe1", + "metadata": {}, + "source": [ + "And on a yearly basis:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "cf40380a-5814-4164-a592-7ab181776b5a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "risk_traj.plot_dately_waterfall()" + ] + }, + { + "cell_type": "markdown", + "id": "c629b746-512f-4d57-8ad8-487b57274c4f", + "metadata": {}, + "source": [ + "Note that we plot the change in risk due to exposure change only, and the additional change when considering change in hazard. As vulnerability is most often non-linear, this should be considered with caution." + ] + }, + { + "cell_type": "markdown", + "id": "7ef127ba-96e3-48bc-a1ea-a9df4cb0acd5", + "metadata": {}, + "source": [ + "### DiscRates" + ] + }, + { + "cell_type": "markdown", + "id": "0dba0218-55fe-423d-a520-61d3cb2a991c", + "metadata": {}, + "source": [ + "To correctly assess the future risk, you may want to apply a discount rate, in order to express future costs in net present value.\n", + "\n", + "This can easily be done using the `DiscRates` class:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "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)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "d86bedbb-6c0a-4f7d-a63e-5012510339d3", + "metadata": {}, + "outputs": [], + "source": [ + "discounted_risk_traj = RiskTrajectory(snapcol, risk_disc=discount_stern)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "1d436f15-020a-40e2-8db7-869b5e3a10a1", + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "Addition/subtraction of integers and integer-arrays with Timestamp is no longer supported. Instead of adding/subtracting `n`, use `n * obj.freq`", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[18], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mdiscounted_risk_traj\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mall_dates_risk_metrics\u001b[49m\n", + "File \u001b[0;32m~/Repos/climada_python/climada/trajectories/risk_trajectory.py:189\u001b[0m, in \u001b[0;36mRiskTrajectory.all_dates_risk_metrics\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 187\u001b[0m \u001b[38;5;129m@property\u001b[39m\n\u001b[1;32m 188\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mall_dates_risk_metrics\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m--> 189\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_calc_risk_metrics\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtotal\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnpv\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Repos/climada_python/climada/trajectories/risk_trajectory.py:196\u001b[0m, in \u001b[0;36mRiskTrajectory._calc_risk_metrics\u001b[0;34m(self, total, npv)\u001b[0m\n\u001b[1;32m 195\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21m_calc_risk_metrics\u001b[39m(\u001b[38;5;28mself\u001b[39m, total\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, npv\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m):\n\u001b[0;32m--> 196\u001b[0m df \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_calc_annual_risk_metrics\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnpv\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnpv\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 197\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m total:\n\u001b[1;32m 198\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_calc_periods_risk(df)\n", + "File \u001b[0;32m~/Repos/climada_python/climada/trajectories/risk_trajectory.py:134\u001b[0m, in \u001b[0;36mRiskTrajectory._calc_annual_risk_metrics\u001b[0;34m(self, npv)\u001b[0m\n\u001b[1;32m 126\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mgroup\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01min\u001b[39;00m df\u001b[38;5;241m.\u001b[39mcolumns:\n\u001b[1;32m 127\u001b[0m grouper \u001b[38;5;241m=\u001b[39m [\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mgroup\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m+\u001b[39m grouper\n\u001b[1;32m 129\u001b[0m df[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mrisk\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[43mdf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgroupby\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 130\u001b[0m \u001b[43m \u001b[49m\u001b[43mgrouper\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 131\u001b[0m \u001b[43m \u001b[49m\u001b[43mdropna\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 132\u001b[0m \u001b[43m \u001b[49m\u001b[43mas_index\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 133\u001b[0m \u001b[43m \u001b[49m\u001b[43mgroup_keys\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[0;32m--> 134\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mrisk\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtransform\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnpv_transform\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 135\u001b[0m df \u001b[38;5;241m=\u001b[39m df\u001b[38;5;241m.\u001b[39mreset_index()\n\u001b[1;32m 137\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m df\n", + "File \u001b[0;32m~/miniforge3/envs/cb_refactoring/lib/python3.10/site-packages/pandas/core/groupby/generic.py:516\u001b[0m, in \u001b[0;36mSeriesGroupBy.transform\u001b[0;34m(self, func, engine, engine_kwargs, *args, **kwargs)\u001b[0m\n\u001b[1;32m 513\u001b[0m \u001b[38;5;129m@Substitution\u001b[39m(klass\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mSeries\u001b[39m\u001b[38;5;124m\"\u001b[39m, example\u001b[38;5;241m=\u001b[39m__examples_series_doc)\n\u001b[1;32m 514\u001b[0m \u001b[38;5;129m@Appender\u001b[39m(_transform_template)\n\u001b[1;32m 515\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mtransform\u001b[39m(\u001b[38;5;28mself\u001b[39m, func, \u001b[38;5;241m*\u001b[39margs, engine\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, engine_kwargs\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m--> 516\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_transform\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 517\u001b[0m \u001b[43m \u001b[49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mengine\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mengine\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mengine_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mengine_kwargs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\n\u001b[1;32m 518\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniforge3/envs/cb_refactoring/lib/python3.10/site-packages/pandas/core/groupby/groupby.py:1950\u001b[0m, in \u001b[0;36mGroupBy._transform\u001b[0;34m(self, func, engine, engine_kwargs, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1947\u001b[0m warn_alias_replacement(\u001b[38;5;28mself\u001b[39m, orig_func, func)\n\u001b[1;32m 1949\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(func, \u001b[38;5;28mstr\u001b[39m):\n\u001b[0;32m-> 1950\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_transform_general\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mengine\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mengine_kwargs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1952\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m func \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m base\u001b[38;5;241m.\u001b[39mtransform_kernel_allowlist:\n\u001b[1;32m 1953\u001b[0m msg \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfunc\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m is not a valid function name for transform(name)\u001b[39m\u001b[38;5;124m\"\u001b[39m\n", + "File \u001b[0;32m~/miniforge3/envs/cb_refactoring/lib/python3.10/site-packages/pandas/core/groupby/generic.py:556\u001b[0m, in \u001b[0;36mSeriesGroupBy._transform_general\u001b[0;34m(self, func, engine, engine_kwargs, *args, **kwargs)\u001b[0m\n\u001b[1;32m 551\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m name, group \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgrouper\u001b[38;5;241m.\u001b[39mget_iterator(\n\u001b[1;32m 552\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_selected_obj, axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39maxis\n\u001b[1;32m 553\u001b[0m ):\n\u001b[1;32m 554\u001b[0m \u001b[38;5;66;03m# this setattr is needed for test_transform_lambda_with_datetimetz\u001b[39;00m\n\u001b[1;32m 555\u001b[0m \u001b[38;5;28mobject\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__setattr__\u001b[39m(group, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mname\u001b[39m\u001b[38;5;124m\"\u001b[39m, name)\n\u001b[0;32m--> 556\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgroup\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 558\u001b[0m results\u001b[38;5;241m.\u001b[39mappend(klass(res, index\u001b[38;5;241m=\u001b[39mgroup\u001b[38;5;241m.\u001b[39mindex))\n\u001b[1;32m 560\u001b[0m \u001b[38;5;66;03m# check for empty \"results\" to avoid concat ValueError\u001b[39;00m\n", + "File \u001b[0;32m~/Repos/climada_python/climada/trajectories/risk_trajectory.py:113\u001b[0m, in \u001b[0;36mRiskTrajectory._calc_annual_risk_metrics..npv_transform\u001b[0;34m(group)\u001b[0m\n\u001b[1;32m 111\u001b[0m start_date \u001b[38;5;241m=\u001b[39m group\u001b[38;5;241m.\u001b[39mindex\u001b[38;5;241m.\u001b[39mget_level_values(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdate\u001b[39m\u001b[38;5;124m\"\u001b[39m)\u001b[38;5;241m.\u001b[39mmin()\n\u001b[1;32m 112\u001b[0m end_date \u001b[38;5;241m=\u001b[39m group\u001b[38;5;241m.\u001b[39mindex\u001b[38;5;241m.\u001b[39mget_level_values(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdate\u001b[39m\u001b[38;5;124m\"\u001b[39m)\u001b[38;5;241m.\u001b[39mmax()\n\u001b[0;32m--> 113\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mcalc_npv_cash_flows\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 114\u001b[0m \u001b[43m \u001b[49m\u001b[43mgroup\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvalues\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstart_date\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mend_date\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrisk_disc\u001b[49m\n\u001b[1;32m 115\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Repos/climada_python/climada/trajectories/risk_trajectory.py:355\u001b[0m, in \u001b[0;36mcalc_npv_cash_flows\u001b[0;34m(cash_flows, start_date, end_date, disc)\u001b[0m\n\u001b[1;32m 352\u001b[0m end_date \u001b[38;5;241m=\u001b[39m end_date \u001b[38;5;129;01mor\u001b[39;00m (start_date \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mlen\u001b[39m(cash_flows) \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m 354\u001b[0m \u001b[38;5;66;03m# Generate an array of dates\u001b[39;00m\n\u001b[0;32m--> 355\u001b[0m dates \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marange(start_date, \u001b[43mend_date\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m)\n\u001b[1;32m 357\u001b[0m \u001b[38;5;66;03m# Find the intersection of dates and discount dates\u001b[39;00m\n\u001b[1;32m 358\u001b[0m disc_dates \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mintersect1d(dates, disc\u001b[38;5;241m.\u001b[39mdates)\n", + "File \u001b[0;32mtimestamps.pyx:466\u001b[0m, in \u001b[0;36mpandas._libs.tslibs.timestamps._Timestamp.__add__\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: Addition/subtraction of integers and integer-arrays with Timestamp is no longer supported. Instead of adding/subtracting `n`, use `n * obj.freq`" + ] + } + ], + "source": [ + "discounted_risk_traj.all_dates_risk_metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "id": "0f732fc0-21b6-456d-9d97-662aa1b8cf15", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 91, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "\n", + "sns.lineplot(\n", + " discouted_risk_traj.yearly_risk_metrics.loc[\n", + " discouted_risk_traj.yearly_risk_metrics[\"metric\"] == \"aai\"\n", + " ],\n", + " x=\"year\",\n", + " y=\"risk\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9c613f3a-8f6c-4eb2-ac1f-fdf8a4367418", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 90, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.lineplot(\n", + " risk_traj.yearly_risk_metrics.loc[\n", + " discouted_risk_traj.yearly_risk_metrics[\"metric\"] == \"aai\"\n", + " ],\n", + " x=\"year\",\n", + " y=\"risk\",\n", + " ax=g,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ebe17c88-a970-4e29-a74f-3e8126c7a0b8", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 31ef976164f11090c5500765c6432e162caa537d Mon Sep 17 00:00:00 2001 From: spjuhel Date: Wed, 2 Apr 2025 18:07:14 +0200 Subject: [PATCH 008/113] Working tutorial --- climada/trajectories/risk_trajectory.py | 283 ++++++++--- climada/trajectories/riskperiod.py | 68 ++- climada/trajectories/snapshot.py | 85 +--- doc/tutorial/climada_trajectories.ipynb | 619 ++++++++++++++---------- 4 files changed, 636 insertions(+), 419 deletions(-) diff --git a/climada/trajectories/risk_trajectory.py b/climada/trajectories/risk_trajectory.py index 0b0f49866..3322ee0a4 100644 --- a/climada/trajectories/risk_trajectory.py +++ b/climada/trajectories/risk_trajectory.py @@ -19,6 +19,7 @@ """ import datetime +import itertools import logging import matplotlib.pyplot as plt @@ -28,14 +29,35 @@ from climada.engine.impact_calc import ImpactCalc from climada.entity.disc_rates.base import DiscRates from climada.trajectories.riskperiod import RiskPeriod -from climada.trajectories.snapshot import Snapshot, pairwise +from climada.trajectories.snapshot import Snapshot LOGGER = logging.getLogger(__name__) class RiskTrajectory: + """Calculates risk trajectories over a series of snapshots. + + This class computes risk metrics over a series of snapshots, + optionally applying risk discounting and risk transfer adjustments. + + Attributes + ---------- + start_date : datetime + The start date of the risk trajectory. + end_date : datetime + The end date of the risk trajectory. + risk_disc : DiscRates | None + The discount rates for risk, default is None. + risk_transf_cover : optional + The risk transfer coverage, default is None. + risk_transf_attach : optional + The risk transfer attachment, default is None. + risk_periods : list + The computed RiskPeriod objects from the snapshots. + """ _grouper = ["measure", "metric"] + """Grouping class attribute""" def __init__( self, @@ -50,17 +72,79 @@ def __init__( "docstring" self._metrics_up_to_date: bool = False self.metrics = metrics - self.return_periods = return_periods + 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 = risk_disc - self.risk_transf_cover = risk_transf_cover - self.risk_transf_attach = risk_transf_attach + self._risk_transf_cover = risk_transf_cover + self._risk_transf_attach = risk_transf_attach LOGGER.debug("Computing risk periods") - self.risk_periods = self._calc_risk_periods(snapshots_list) + self._risk_periods = self._calc_risk_periods(snapshots_list) self._update_risk_metrics(compute_groups=compute_groups) + @property + def return_periods(self) -> list[int]: + """The return periods considered in the risk trajectory.""" + return self._return_periods + + @return_periods.setter + def return_periods(self, value: list[int]): + if not isinstance(value, list): + raise ValueError("Not a list") + if any(not isinstance(i, int) for i in value): + raise ValueError("List elements are not int") + self._return_periods = value + self._metrics_up_to_date = False + + @property + def risk_transf_cover(self): + """The risk transfer coverage.""" + return self._risk_transf_cover + + @risk_transf_cover.setter + def risk_transf_cover(self, value): + self._risk_transf_cover = value + self._metrics_up_to_date = False + + @property + def risk_transf_attach(self): + """The risk transfer attachment.""" + return self._risk_transf_attach + + @risk_transf_attach.setter + def risk_transf_attach(self, value): + self._risk_transf_attach = value + self._metrics_up_to_date = False + + @property + def risk_periods(self) -> list[RiskPeriod]: + """The computed risk periods from the snapshots.""" + return self._risk_periods + def _calc_risk_periods(self, snapshots): + 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)] + """ + a, b = itertools.tee(container) + next(b, None) + return zip(a, b) + return [ RiskPeriod(start_snapshot, end_snapshot) for start_snapshot, end_snapshot in pairwise(snapshots) @@ -68,9 +152,9 @@ def _calc_risk_periods(self, snapshots): def _update_risk_metrics(self, compute_groups=False): results_df = [] - for period in self.risk_periods: + for period in self._risk_periods: results_df.append( - bayesian_mixer_opti( + impact_mixer( period, self.metrics, self.return_periods, @@ -80,7 +164,7 @@ def _update_risk_metrics(self, compute_groups=False): ) results_df = pd.concat(results_df, axis=0) - # duplicate rows arise from overlapping end and start if there's more than two snapshots + # duplicate rows may arise from overlapping end and start if there's more than two snapshots results_df.drop_duplicates(inplace=True) # reorder the columns (but make sure not to remove possibly important ones in the future) @@ -108,13 +192,11 @@ def _get_risk_periods( if (start_date >= period.start_date or end_date <= period.end_date) ] - def _calc_annual_risk_metrics(self, npv=True): + def _calc_per_date_risk_metrics(self, npv=True): def npv_transform(group): start_date = group.index.get_level_values("date").min() end_date = group.index.get_level_values("date").max() - return calc_npv_cash_flows( - group.values, start_date, end_date, self.risk_disc - ) + return calc_npv_cash_flows(group, start_date, end_date, self.risk_disc) if self._metrics_up_to_date: df = self._annual_risk_metrics @@ -187,15 +269,17 @@ def identify_continuous_periods(group, time_unit): ] @property - def all_dates_risk_metrics(self): + def per_date_risk_metrics(self) -> pd.DataFrame | pd.Series: + """Returns a tidy dataframe of the risk metrics for all dates.""" return self._calc_risk_metrics(total=False, npv=True) @property def total_risk_metrics(self): + """Returns a tidy dataframe of the risk metrics with the total for each different period.""" return self._calc_risk_metrics(total=True, npv=True) def _calc_risk_metrics(self, total=False, npv=True): - df = self._calc_annual_risk_metrics(npv=npv) + df = self._calc_per_date_risk_metrics(npv=npv) if total: return self._calc_periods_risk(df) @@ -205,7 +289,7 @@ def _calc_waterfall_plot_data(self, start_date=None, end_date=None): 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 considered_risk_periods = self._get_risk_periods( - self.risk_periods, start_date=start_date, end_date=end_date + self._risk_periods, start_date=start_date, end_date=end_date ) risk_component = { @@ -231,23 +315,25 @@ def _calc_waterfall_plot_data(self, start_date=None, end_date=None): return risk_component def _calc_risk_component(self, period: RiskPeriod): - imp_mats_H0 = period.imp_mats_0 - imp_mats_H1 = period.imp_mats_1 + imp_mats_H0 = period._imp_mats_0 + imp_mats_H1 = period._imp_mats_1 freq_H0 = period.snapshot0.hazard.frequency freq_H1 = period.snapshot1.hazard.frequency - dately_eai_H0, dately_eai_H1 = calc_dately_eais( + per_date_eai_H0, per_date_eai_H1 = calc_per_date_eais( imp_mats_H0, imp_mats_H1, freq_H0, freq_H1 ) - dately_aai_H0, dately_aai_H1 = calc_dately_aais(dately_eai_H0, dately_eai_H1) + per_date_aai_H0, per_date_aai_H1 = calc_per_date_aais( + per_date_eai_H0, per_date_eai_H1 + ) prop_H1 = np.linspace(0, 1, num=len(period.date_idx)) prop_H0 = 1 - prop_H1 - dately_aai = prop_H0 * dately_aai_H0 + prop_H1 * dately_aai_H1 + per_date_aai = prop_H0 * per_date_aai_H0 + prop_H1 * per_date_aai_H1 - risk_dev_0 = dately_aai_H0 - dately_aai[0] - risk_cc_0 = dately_aai - (risk_dev_0 + dately_aai[0]) + risk_dev_0 = per_date_aai_H0 - per_date_aai[0] + risk_cc_0 = per_date_aai - (risk_dev_0 + per_date_aai[0]) df = pd.DataFrame( { - "Base risk": dately_aai - (risk_dev_0 + risk_cc_0), + "Base risk": per_date_aai - (risk_dev_0 + risk_cc_0), "Change in Exposure": risk_dev_0, "Change in Hazard (with Exposure)": risk_cc_0, }, @@ -255,7 +341,34 @@ def _calc_risk_component(self, period: RiskPeriod): ) return df.round(1) - def plot_dately_waterfall(self, ax=None, start_date=None, end_date=None): + def plot_per_date_waterfall(self, ax=None, start_date=None, end_date=None): + """Plot a waterfall chart of risk components over a specified date range. + + This method generates a stacked bar chart to visualize the + risk components between specified start and end dates, for each date in between. + If no dates are provided, it defaults to the start and end dates of the risk trajectory. + See the notes on how risk is attributed to each components. + + Parameters + ---------- + ax : matplotlib.axes.Axes, optional + The matplotlib axes on which to plot. If None, a new figure and axes are created. + start_date : datetime, optional + The start date for the waterfall plot. If None, defaults to the start date of the risk trajectory. + end_date : datetime, optional + The end date for the waterfall plot. If None, defaults to the end date of the risk trajectory. + + Returns + ------- + matplotlib.axes.Axes + The matplotlib axes with the plotted waterfall chart. + + Notes + ----- + The "risk components" are plotted such that the increase in risk due to the hazard component + really denotes the difference between the risk associated with both future exposure and hazard + compared to the risk associated with future exposure and present hazard. + """ if ax is None: _, ax = plt.subplots(figsize=(12, 6)) start_date = self.start_date if start_date is None else start_date @@ -275,6 +388,32 @@ def plot_dately_waterfall(self, ax=None, start_date=None, end_date=None): return ax def plot_waterfall(self, ax=None, start_date=None, end_date=None): + """Plot a waterfall chart of risk components between two dates. + + This method generates a waterfall plot to visualize the changes in risk components + between a specified start and end date. If no dates are provided, it defaults to + the start and end dates of the risk trajectory. + + Parameters + ---------- + ax : matplotlib.axes.Axes, optional + The matplotlib axes on which to plot. If None, a new figure and axes are created. + start_date : datetime, optional + The start date for the waterfall plot. If None, defaults to the start date of the risk trajectory. + end_date : datetime, optional + The end date for the waterfall plot. If None, defaults to the end date of the risk trajectory. + + Returns + ------- + matplotlib.axes.Axes + The matplotlib axes with the plotted waterfall chart. + + Notes + ----- + The "risk components" are plotted such that the increase in risk due to the hazard component + really denotes the difference between the risk associated with both future exposure and hazard + compared to the risk associated with future exposure and present hazard. + """ 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_component = self._calc_waterfall_plot_data( @@ -350,9 +489,7 @@ def calc_npv_cash_flows(cash_flows, start_date, end_date=None, disc=None): if not disc: return cash_flows - if not isinstance(cash_flows, pd.Series) or not isinstance( - cash_flows.index, pd.DatetimeIndex - ): + if not isinstance(cash_flows.index, pd.DatetimeIndex): raise ValueError("cash_flows must be a pandas Series with a datetime index") # Determine the end date if not provided @@ -363,14 +500,14 @@ def calc_npv_cash_flows(cash_flows, start_date, end_date=None, disc=None): df["year"] = df.index.year # Merge with the discount rates based on the year - df = df.merge( + tmp = df.merge( pd.DataFrame({"year": disc.years, "rate": disc.rates}), on="year", how="left" ) - - # Calculate the discount factors + tmp.index = df.index + df = tmp.copy() df["discount_factor"] = (1 / (1 + df["rate"])) ** ( - df.index - start_date - ).days / 365.25 + (df.index - start_date).days // 365 + ) # Apply the discount factors to the cash flows df["npv_cash_flow"] = df["cash_flow"] * df["discount_factor"] @@ -378,9 +515,9 @@ def calc_npv_cash_flows(cash_flows, start_date, end_date=None, disc=None): return df["npv_cash_flow"] -def calc_dately_eais(imp_mats_0, imp_mats_1, frequency_0, frequency_1): +def calc_per_date_eais(imp_mats_0, imp_mats_1, frequency_0, frequency_1): """ - Calculate dately expected annual impact (EAI) values for two scenarios. + Calculate per_date expected annual impact (EAI) values for two scenarios. Parameters ---------- @@ -397,47 +534,47 @@ def calc_dately_eais(imp_mats_0, imp_mats_1, frequency_0, frequency_1): ------- tuple Tuple containing: - - dately_eai_exp_0 : list of float - Dately expected annual impacts for scenario 0. - - dately_eai_exp_1 : list of float - Dately expected annual impacts for scenario 1. + - per_date_eai_exp_0 : list of float + Per_Date expected annual impacts for scenario 0. + - per_date_eai_exp_1 : list of float + Per_Date expected annual impacts for scenario 1. """ - dately_eai_exp_0 = [ + per_date_eai_exp_0 = [ ImpactCalc.eai_exp_from_mat(imp_mat, frequency_0) for imp_mat in imp_mats_0 ] - dately_eai_exp_1 = [ + per_date_eai_exp_1 = [ ImpactCalc.eai_exp_from_mat(imp_mat, frequency_1) for imp_mat in imp_mats_1 ] - return dately_eai_exp_0, dately_eai_exp_1 + return per_date_eai_exp_0, per_date_eai_exp_1 -def calc_dately_aais(dately_eai_exp_0, dately_eai_exp_1): +def calc_per_date_aais(per_date_eai_exp_0, per_date_eai_exp_1): """ - Calculate dately aggregate annual impact (AAI) values for two scenarios. + Calculate per_date aggregate annual impact (AAI) values for two scenarios. Parameters ---------- - dately_eai_exp_0 : list of float - Dately expected annual impacts for scenario 0. - dately_eai_exp_1 : list of float - Dately expected annual impacts for scenario 1. + per_date_eai_exp_0 : list of float + Per_Date expected annual impacts for scenario 0. + per_date_eai_exp_1 : list of float + Per_Date expected annual impacts for scenario 1. Returns ------- tuple Tuple containing: - - dately_aai_0 : list of float + - per_date_aai_0 : list of float Aggregate annual impact values for scenario 0. - - dately_aai_1 : list of float + - per_date_aai_1 : list of float Aggregate annual impact values for scenario 1. """ - dately_aai_0 = [ - ImpactCalc.aai_agg_from_eai_exp(eai_exp) for eai_exp in dately_eai_exp_0 + per_date_aai_0 = [ + ImpactCalc.aai_agg_from_eai_exp(eai_exp) for eai_exp in per_date_eai_exp_0 ] - dately_aai_1 = [ - ImpactCalc.aai_agg_from_eai_exp(eai_exp) for eai_exp in dately_eai_exp_1 + per_date_aai_1 = [ + ImpactCalc.aai_agg_from_eai_exp(eai_exp) for eai_exp in per_date_eai_exp_1 ] - return dately_aai_0, dately_aai_1 + return per_date_aai_0, per_date_aai_1 def calc_freq_curve(imp_mat_intrpl, frequency, return_per=None): @@ -473,9 +610,9 @@ def calc_freq_curve(imp_mat_intrpl, frequency, return_per=None): return ifc_impact -def calc_dately_rps(imp_mats_0, imp_mats_1, frequency_0, frequency_1, return_periods): +def calc_per_date_rps(imp_mats_0, imp_mats_1, frequency_0, frequency_1, return_periods): """ - Calculate dately return period impact values for two scenarios. + Calculate per_date return period impact values for two scenarios. Parameters ---------- @@ -495,9 +632,9 @@ def calc_dately_rps(imp_mats_0, imp_mats_1, frequency_0, frequency_1, return_per tuple Tuple containing: - rp_0 : list of np.ndarray - Dately return period impact values for scenario 0. + Per_Date return period impact values for scenario 0. - rp_1 : list of np.ndarray - Dately return period impact values for scenario 1. + Per_Date return period impact values for scenario 1. """ rp_0 = [ calc_freq_curve(imp_mat, frequency_0, return_periods) for imp_mat in imp_mats_0 @@ -530,7 +667,7 @@ def get_eai_exp(eai_exp, group_map): return eai_region_id -def bayesian_mixer_opti( +def impact_mixer( risk_period, metrics, return_periods, @@ -566,7 +703,9 @@ def bayesian_mixer_opti( pd.DataFrame DataFrame of calculated impact values by date, group, and metric. """ - # 1. Interpolate in between dates + + # Posterity comment: This was called bayesian_mixing in its initial version, + # although there is nothing really bayesian here, (but it did sound cool!) all_groups_n = pd.NA if all_groups_name is None else all_groups_name @@ -574,31 +713,31 @@ def bayesian_mixer_opti( frequency_0 = risk_period.snapshot0.hazard.frequency frequency_1 = risk_period.snapshot1.hazard.frequency imp_mats_0, imp_mats_1 = risk_period.get_interp() - dately_eai_exp_0, dately_eai_exp_1 = calc_dately_eais( + per_date_eai_exp_0, per_date_eai_exp_1 = calc_per_date_eais( imp_mats_0, imp_mats_1, frequency_0, frequency_1 ) date_idx = risk_period.date_idx res = [] if "aai" in metrics: - dately_aai_0, dately_aai_1 = calc_dately_aais( - dately_eai_exp_0, dately_eai_exp_1 + per_date_aai_0, per_date_aai_1 = calc_per_date_aais( + per_date_eai_exp_0, per_date_eai_exp_1 ) - dately_aai = prop_H0 * dately_aai_0 + prop_H1 * dately_aai_1 - aai_df = pd.DataFrame(index=date_idx, columns=["risk"], data=dately_aai) + per_date_aai = prop_H0 * per_date_aai_0 + prop_H1 * per_date_aai_1 + aai_df = pd.DataFrame(index=date_idx, columns=["risk"], data=per_date_aai) aai_df["group"] = all_groups_n aai_df["metric"] = "aai" aai_df.reset_index(inplace=True) res.append(aai_df) if "rp" in metrics: - rp_0, rp_1 = calc_dately_rps( + rp_0, rp_1 = calc_per_date_rps( imp_mats_0, imp_mats_1, frequency_0, frequency_1, return_periods ) - dately_rp = np.multiply(prop_H0.reshape(-1, 1), rp_0) + np.multiply( + per_date_rp = np.multiply(prop_H0.reshape(-1, 1), rp_0) + np.multiply( prop_H1.reshape(-1, 1), rp_1 ) rp_df = pd.DataFrame( - index=date_idx, columns=return_periods, data=dately_rp + index=date_idx, columns=return_periods, data=per_date_rp ).melt(value_name="risk", var_name="rp", ignore_index=False) rp_df.reset_index(inplace=True) rp_df["group"] = all_groups_n @@ -606,11 +745,11 @@ def bayesian_mixer_opti( res.append(rp_df) if compute_groups: - dately_eai = np.multiply( - prop_H0.reshape(-1, 1), dately_eai_exp_0 - ) + np.multiply(prop_H1.reshape(-1, 1), dately_eai_exp_1) + per_date_eai = np.multiply( + prop_H0.reshape(-1, 1), per_date_eai_exp_0 + ) + np.multiply(prop_H1.reshape(-1, 1), per_date_eai_exp_1) eai_group_df = pd.DataFrame( - data=dately_eai.T, + data=per_date_eai.T, index=risk_period.snapshot1.exposure.gdf["group_id"], columns=risk_period.date_idx, ) diff --git a/climada/trajectories/riskperiod.py b/climada/trajectories/riskperiod.py index 607b67299..69fc55f96 100644 --- a/climada/trajectories/riskperiod.py +++ b/climada/trajectories/riskperiod.py @@ -36,10 +36,36 @@ class RiskPeriod: + """Interpolated impacts between two snapshots. - # TODO: make lazy / delayed interpolation and impacts - # TODO: make MeasureRiskPeriod child class (with effective start/end) - # TODO: special case where hazard and exposure don't change (no need to interpolate) ? + This class calculates the interpolated impacts between two snapshots over a specified + time period. It supports risk transfer modifications and can compute residual impacts. + + Attributes + ---------- + snapshot0 : Snapshot + The snapshot starting the period. + snapshot1 : Snapshot + The snapshot ending the period. + start_date : datetime + The start date of the risk period. + end_date : datetime + The end date of the risk period. + time_frequency : str + The frequency of the time intervals (e.g., 'YS' for yearly). + See `pandas freq string documentation `_. + date_idx : pd.DatetimeIndex + The date range index between the start and end dates. + measure_name : str + The name of the measure applied to the period. "no_measure" if no measure is applied. + impfset : object + The impact function set for the period. If both snapshots do not share the same ImpactFuncSet object, + they are merged together. Note that if impact functions with the same hazard type and id differ, + the one from the ending Snapshot takes precedence. + """ + + # Future TODO: make lazy / delayed interpolation and impacts + # Future TODO: special case where hazard and exposure don't change (no need to interpolate) ? def __init__( self, @@ -65,8 +91,12 @@ def __init__( self.measure_name = measure_name self.impfset = self._merge_impfset(snapshot0.impfset, snapshot1.impfset) + # Posterity comment: The following attributes + # were refered as Victypliers in homage to Victor + # Watkinsson, the conceptual father of this module self._prop_H1 = np.linspace(0, 1, num=len(self.date_idx)) self._prop_H0 = 1 - self._prop_H1 + self._exp_y0 = snapshot0.exposure self._exp_y1 = snapshot1.exposure self._haz_y0 = snapshot0.hazard @@ -74,10 +104,10 @@ def __init__( # Compute impacts once LOGGER.debug("Computing snapshots combination impacts") - imp_E0H0 = self._compute_impact(self._exp_y0, self._haz_y0) - imp_E1H0 = self._compute_impact(self._exp_y1, self._haz_y0) - imp_E0H1 = self._compute_impact(self._exp_y0, self._haz_y1) - imp_E1H1 = self._compute_impact(self._exp_y1, self._haz_y1) + imp_E0H0 = ImpactCalc(self._exp_y0, self.impfset, self._haz_y0).impact() + imp_E1H0 = ImpactCalc(self._exp_y1, self.impfset, self._haz_y0).impact() + imp_E0H1 = ImpactCalc(self._exp_y0, self.impfset, self._haz_y1).impact() + imp_E1H1 = ImpactCalc(self._exp_y1, self.impfset, self._haz_y1).impact() # Modify the impact matrices if risk transfer is provided # TODO: See where this ends up @@ -96,13 +126,11 @@ def __init__( LOGGER.debug("Interpolating impact matrices between E0H0 and E1H0") time_points = len(self.date_idx) - self.imp_mats_0 = interpolate_imp_mat(imp_E0H0, imp_E1H0, time_points) + self._imp_mats_0 = interpolate_imp_mat(imp_E0H0, imp_E1H0, time_points) LOGGER.debug("Interpolating impact matrices between E0H1 and E1H1") - self.imp_mats_1 = interpolate_imp_mat(imp_E0H1, imp_E1H1, time_points) + self._imp_mats_1 = interpolate_imp_mat(imp_E0H1, imp_E1H1, time_points) LOGGER.debug("Done") - self._initialized = True - @staticmethod def _merge_impfset(impfs1: ImpactFuncSet, impfs2: ImpactFuncSet): if impfs1 == impfs2: @@ -114,15 +142,21 @@ def _merge_impfset(impfs1: ImpactFuncSet, impfs2: ImpactFuncSet): impfs1._data |= impfs2._data # Merges dictionaries (priority to impfs2) return impfs1 - def _compute_impact(self, exposure, hazard): - """Compute the impact once per unique exposure-hazard pair.""" - return ImpactCalc(exposure, self.impfset, hazard).impact() - def get_interp(self): - return self.imp_mats_0, self.imp_mats_1 + """Return two lists of interpolated impacts matrices with varying exposure, for starting and ending hazard. + + Returns + ------- + + _imp_mats_0 : np.ndarray + Interpolated impact matrices varying Exposure from starting snapshot to ending one, using Hazard from starting snapshot. + _imp_mats_1 : np.ndarray + Interpolated impact matrices varying Exposure from starting snapshot to ending one, using Hazard from ending snapshot. + """ + return self._imp_mats_0, self._imp_mats_1 def apply_measure(self, measure: Measure): - # Apply measure on snapshot and return risk period instance + """Applies measure to RiskPeriod, returns a new object""" snapshot0 = self.snapshot0.apply_measure(measure) snapshot1 = self.snapshot1.apply_measure(measure) return RiskPeriod(snapshot0, snapshot1, measure_name=measure.name) diff --git a/climada/trajectories/snapshot.py b/climada/trajectories/snapshot.py index 844693d47..3abedf3d8 100644 --- a/climada/trajectories/snapshot.py +++ b/climada/trajectories/snapshot.py @@ -24,8 +24,6 @@ import datetime import itertools import logging -from dataclasses import InitVar, dataclass, field -from weakref import WeakValueDictionary from climada.entity.exposures import Exposures from climada.entity.impact_funcs import ImpactFuncSet @@ -35,51 +33,6 @@ LOGGER = logging.getLogger(__name__) -# TODO: Improve and make it an __eq__ function within Hazard? -def hazard_data_equal(haz1: Hazard, haz2: Hazard) -> bool: - intensity_eq = ( - haz1.intensity != haz2.intensity - ).nnz == 0 # type:ignore (__neq__ type hint is bool) - freq_eq = (haz1.frequency == haz2.frequency).all() - frac_eq = ( - haz1.fraction != haz2.fraction - ).nnz == 0 # type:ignore (__neq__ type hint is bool) - return intensity_eq and freq_eq and frac_eq - - -class _SnapData: - """ - A snapshot of exposure, hazard, and impact function. - - Attributes - ---------- - exposure : Exposures - Exposure data for the snapshot. - hazard : Hazard - Hazard data for the snapshot. - impfset : ImpactFuncSet - Impact function set associated with the snapshot. - """ - - # Class-level cache - def __init__( - self, exposure: Exposures, hazard: Hazard, impfset: ImpactFuncSet - ) -> None: - self.exposure = copy.deepcopy(exposure) - self.hazard = copy.deepcopy(hazard) - self.impfset = copy.deepcopy(impfset) - - def __eq__(self, value, /) -> bool: - if not isinstance(value, _SnapData): - return False - if self is value: - return True - same_exposure = self.exposure.gdf.equals(value.exposure.gdf) - same_hazard = hazard_data_equal(self.hazard, value.hazard) - same_impfset = self.impfset == value.impfset - return same_exposure and same_hazard and same_impfset - - class Snapshot: """ A snapshot of exposure, hazard, and impact function at a specific date. @@ -88,11 +41,15 @@ class Snapshot: ---------- date : datetime Date of the snapshot. + measure: Measure | None + The possible measure applied to the snapshot. Notes ----- The object creates copies of the exposure hazard and impact function set. + + To create a snapshot with a measure use Snapshot.apply_measure(measure). """ def __init__( @@ -102,24 +59,26 @@ def __init__( impfset: ImpactFuncSet, date: int | datetime.date | str, ) -> None: - self._data = _SnapData(exposure, hazard, impfset) + self._exposure = copy.deepcopy(exposure) + self._hazard = copy.deepcopy(hazard) + self._impfset = copy.deepcopy(impfset) self.measure = None self.date = self._convert_to_date(date) @property def exposure(self) -> Exposures: """Exposure data for the snapshot.""" - return self._data.exposure + return self._exposure @property def hazard(self) -> Hazard: """Hazard data for the snapshot.""" - return self._data.hazard + return self._hazard @property def impfset(self) -> ImpactFuncSet: """Impact function set data for the snapshot.""" - return self._data.impfset + return self._impfset @staticmethod def _convert_to_date(date_arg) -> datetime.date: @@ -146,27 +105,3 @@ def apply_measure(self, measure: Measure): snap = Snapshot(exp_new, haz_new, impfset_new, self.date) snap.measure = measure return snap - - -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)] - """ - a, b = itertools.tee(container) - next(b, None) - return zip(a, b) diff --git a/doc/tutorial/climada_trajectories.ipynb b/doc/tutorial/climada_trajectories.ipynb index 2785a3623..1ed27c292 100644 --- a/doc/tutorial/climada_trajectories.ipynb +++ b/doc/tutorial/climada_trajectories.ipynb @@ -1,14 +1,28 @@ { "cells": [ { - "cell_type": "code", - "execution_count": 1, - "id": "af79f465-fbb3-43e1-80fa-40ac378b7b2b", + "cell_type": "markdown", + "id": "a5245bdb-fc31-4cb9-912f-560d23231622", "metadata": {}, - "outputs": [], "source": [ - "%load_ext autoreload\n", - "%autoreload 2" + "Currently, to run this tutorial, from within a climada_python git repo please run:\n", + "\n", + "```\n", + "mamba create -n climada_trajectory \"python==3.11.*\"\n", + "git fetch\n", + "git checkout feature/risk_trajectory\n", + "mamba env update -n climada_trajectory -f requirements/env_climada.yml\n", + "mamba activate climada_trajectory\n", + "python -m pip install -e ./\n", + "\n", + "```\n", + "\n", + "To be able to select that environment in jupyter you possibly might also need:\n", + "\n", + "```\n", + "mamba install ipykernel\n", + "python -m ipykernel install --user --name climada_trajectory\n", + "```" ] }, { @@ -46,53 +60,12 @@ "source": [ "We use `Snapshot` objects to define a point in time. This object acts as a wrapper of the classic risk framework composed of Exposure, Hazard and Vulnerability. As such it is define for a specific year, and contains references to an `Exposures`, a `Hazard`, and an `ImpactFuncSet` object.\n", "\n", - "Next we show how to instantiate such a `Snapshot`. Note however that they are of little use by themselves, and what you will really use are `SnapshotsCollection` which we present right after." + "Next we show how to instantiate such a `Snapshot`. Note however that they are of little use by themselves, and what you will really use are `RiskTrajectory` which we present right after." ] }, { "cell_type": "code", - "execution_count": 19, - "id": "0d52dfa2-5836-4693-ad5d-7f10ad21c695", - "metadata": {}, - "outputs": [], - "source": [ - "import datetime" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f4ff8ced-0050-436d-9efc-e3802fc70b37", - "metadata": {}, - "outputs": [], - "source": [ - "test = {0: \"A\"}" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "8c2e89cd-cb2a-4a0c-9460-9614470a6bb2", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "list(test.keys())[0]" - ] - }, - { - "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "dec203d1-943f-41d8-9542-009f288b937b", "metadata": {}, "outputs": [ @@ -193,8 +166,11 @@ "id": "8e8458c3-a3f9-4210-9de0-15293167f2f9", "metadata": {}, "source": [ - "As stated previously, it makes little sense to define a Snapshot alone, so your main entry point should rather be the `SnapshotsCollection`.\n", - "For this let us define a future point in time:" + "As stated previously, it makes little sense to define a Snapshot alone, so your main entry point should rather be the `RiskTrajectory`. \n", + "`RiskTrajectory` uses one or more `RiskPeriod` under the hood, these objects used to hold pairs of `Snapshot` and compute the impacts at each dates in between.\n", + "This allows you to create a trajectory or risk with any number of snapshots.\n", + "\n", + "So first, let us define a future point in time:" ] }, { @@ -240,7 +216,9 @@ "id": "05009191-8a5f-4b38-a282-6c433924d4be", "metadata": {}, "source": [ - "Note how we use only one set of impact function `impf_set`, with one impact function for the present (id=1) and one for the future (id=2)." + "The set of impact functions `impf_set` has to be common for the different snapshot, with one impact function for the present (id=1) and one for the future (id=2).\n", + "\n", + "Note that, the `RiskTrajectory` object will detect different `ImpactFunSet` objects and merge them together, while warning the user. In case of conflicting functions, this merge will retain the impact functions from the Snapshot with the latest date." ] }, { @@ -296,8 +274,8 @@ }, { "cell_type": "code", - "execution_count": 7, - "id": "15ca9827-029c-4ca3-aa5e-377aca135f89", + "execution_count": null, + "id": "4ffe490d-8488-4005-9442-deb642e19985", "metadata": {}, "outputs": [], "source": [ @@ -305,19 +283,23 @@ ] }, { - "cell_type": "code", - "execution_count": 8, - "id": "9ee5e65f-ac42-4718-9ccb-951c92d7cc87", + "cell_type": "markdown", + "id": "27ca72b1-b1fa-4cd2-8f74-a69dc6eb3c9c", "metadata": {}, - "outputs": [], "source": [ - "from climada.trajectories.riskperiod import RiskPeriod" + "Based on such a list of snapshots, you can then evaluate a risk trajectory using a `RiskTrajectory` object.\n", + "\n", + "This object will hold risk metrics for all the dates between the different snapshots in the given collection for a given time frequency (a year by default)\n", + "\n", + "In this example, from the snapshot in 2018 to the one in 2040. \n", + "\n", + "Note that this requires a bit of computation and memory, especially for large regions or extended range of time." ] }, { "cell_type": "code", - "execution_count": 9, - "id": "1c4c4782-e95b-4a75-ad49-623b8c91a1d0", + "execution_count": 45, + "id": "ff177685-bf41-49c9-8b86-043855862d0d", "metadata": {}, "outputs": [ { @@ -328,30 +310,10 @@ ] } ], - "source": [ - "rp = RiskPeriod(snap, snap2)" - ] - }, - { - "cell_type": "markdown", - "id": "27ca72b1-b1fa-4cd2-8f74-a69dc6eb3c9c", - "metadata": {}, - "source": [ - "Based on a list of snapshots, you can then evaluate a risk trajectory using a `RiskTrajectory` object.\n", - "\n", - "This object will hold yearly risk metrics for all the years between the different snapshots in the given collection, in this example, from 2020 to 2040. This requires a bit of computation and memory, especially for large regions or extended range of time." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "ff177685-bf41-49c9-8b86-043855862d0d", - "metadata": {}, - "outputs": [], "source": [ "from climada.trajectories.risk_trajectory import RiskTrajectory\n", "\n", - "risk_traj = RiskTrajectory(snapcol, compute_groups=True)" + "risk_traj = RiskTrajectory(snapcol)" ] }, { @@ -359,24 +321,17 @@ "id": "68d9e0c7-8efd-44fb-8512-cd480e510c50", "metadata": {}, "source": [ - "From this object you can access different yearly risk metrics:\n", + "From this object you can access different risk metrics:\n", "\n", - "* Annual Average Impact (aai)\n", + "* Average Annual Impact (aai)\n", "* Estimated impact for different return periods (100, 500 and 1000 by default)\n", - "* (if `compute_groups` was set to True) Annual Average Impact per group_id from the exposure (when group is not NaN)" - ] - }, - { - "cell_type": "markdown", - "id": "00e0a09b-9dd6-4378-81a1-cda5290f9aa4", - "metadata": {}, - "source": [ - "You can also plot the \"components\" of the change in risk via a waterfall graph, both over the whole period:" + "\n", + "Both as totals over the whole period:" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 15, "id": "866db75c-5b21-4134-9f4e-f7213ad49f18", "metadata": {}, "outputs": [ @@ -402,7 +357,6 @@ " \n", " \n", " period\n", - " group\n", " measure\n", " metric\n", " risk\n", @@ -412,47 +366,27 @@ " \n", " 0\n", " 2018-01-01 to 2040-01-01\n", - " 0\n", - " no_measure\n", - " aai\n", - " 1.487445e+07\n", - " \n", - " \n", - " 1\n", - " 2018-01-01 to 2040-01-01\n", - " 1\n", - " no_measure\n", - " aai\n", - " 9.945312e+09\n", - " \n", - " \n", - " 2\n", - " 2018-01-01 to 2040-01-01\n", - " All\n", " no_measure\n", " aai\n", " 9.960186e+09\n", " \n", " \n", - " 3\n", + " 1\n", " 2018-01-01 to 2040-01-01\n", - " All\n", " no_measure\n", " rp_100\n", " 3.288826e+11\n", " \n", " \n", - " 4\n", + " 2\n", " 2018-01-01 to 2040-01-01\n", - " All\n", " no_measure\n", " rp_1000\n", " 8.369369e+11\n", " \n", " \n", - " 5\n", + " 3\n", " 2018-01-01 to 2040-01-01\n", - " All\n", " no_measure\n", " rp_500\n", " 8.369369e+11\n", @@ -462,16 +396,14 @@ "" ], "text/plain": [ - " period group measure metric risk\n", - "0 2018-01-01 to 2040-01-01 0 no_measure aai 1.487445e+07\n", - "1 2018-01-01 to 2040-01-01 1 no_measure aai 9.945312e+09\n", - "2 2018-01-01 to 2040-01-01 All no_measure aai 9.960186e+09\n", - "3 2018-01-01 to 2040-01-01 All no_measure rp_100 3.288826e+11\n", - "4 2018-01-01 to 2040-01-01 All no_measure rp_1000 8.369369e+11\n", - "5 2018-01-01 to 2040-01-01 All no_measure rp_500 8.369369e+11" + " period measure metric risk\n", + "0 2018-01-01 to 2040-01-01 no_measure aai 9.960186e+09\n", + "1 2018-01-01 to 2040-01-01 no_measure rp_100 3.288826e+11\n", + "2 2018-01-01 to 2040-01-01 no_measure rp_1000 8.369369e+11\n", + "3 2018-01-01 to 2040-01-01 no_measure rp_500 8.369369e+11" ] }, - "execution_count": 11, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -480,10 +412,18 @@ "risk_traj.total_risk_metrics" ] }, + { + "cell_type": "markdown", + "id": "ff6d6915-805f-46a9-8552-c03c635fe2d5", + "metadata": {}, + "source": [ + "Or on a per-date basis:" + ] + }, { "cell_type": "code", - "execution_count": 12, - "id": "2c3f0d17-17ef-4f38-a01f-b4567a492eb1", + "execution_count": 18, + "id": "67efba39-11b6-40fc-b5dd-a8799ec00c12", "metadata": {}, "outputs": [ { @@ -508,7 +448,6 @@ " \n", " \n", " date\n", - " group\n", " measure\n", " metric\n", " risk\n", @@ -518,7 +457,6 @@ " \n", " 0\n", " 2018-01-01\n", - " All\n", " no_measure\n", " aai\n", " 1.840432e+08\n", @@ -526,7 +464,6 @@ " \n", " 1\n", " 2019-01-01\n", - " All\n", " no_measure\n", " aai\n", " 2.055335e+08\n", @@ -534,7 +471,6 @@ " \n", " 2\n", " 2020-01-01\n", - " All\n", " no_measure\n", " aai\n", " 2.271876e+08\n", @@ -542,7 +478,6 @@ " \n", " 3\n", " 2021-01-01\n", - " All\n", " no_measure\n", " aai\n", " 2.490056e+08\n", @@ -550,7 +485,6 @@ " \n", " 4\n", " 2022-01-01\n", - " All\n", " no_measure\n", " aai\n", " 2.709873e+08\n", @@ -561,82 +495,84 @@ " ...\n", " ...\n", " ...\n", - " ...\n", " \n", " \n", - " 133\n", - " 2038-01-01\n", - " 1\n", + " 87\n", + " 2036-01-01\n", " no_measure\n", - " aai\n", - " 6.440116e+08\n", + " rp_1000\n", + " 4.734810e+10\n", " \n", " \n", - " 134\n", - " 2039-01-01\n", - " 0\n", + " 88\n", + " 2037-01-01\n", " no_measure\n", - " aai\n", - " 1.003259e+06\n", + " rp_1000\n", + " 4.893501e+10\n", " \n", " \n", - " 135\n", - " 2039-01-01\n", - " 1\n", + " 89\n", + " 2038-01-01\n", " no_measure\n", - " aai\n", - " 6.687412e+08\n", + " rp_1000\n", + " 5.052490e+10\n", " \n", " \n", - " 136\n", - " 2040-01-01\n", - " 0\n", + " 90\n", + " 2039-01-01\n", " no_measure\n", - " aai\n", - " 1.040877e+06\n", + " rp_1000\n", + " 5.211776e+10\n", " \n", " \n", - " 137\n", + " 91\n", " 2040-01-01\n", - " 1\n", " no_measure\n", - " aai\n", - " 6.936344e+08\n", + " rp_1000\n", + " 5.371361e+10\n", " \n", " \n", "\n", - "

138 rows × 5 columns

\n", + "

92 rows × 4 columns

\n", "" ], "text/plain": [ - " date group measure metric risk\n", - "0 2018-01-01 All no_measure aai 1.840432e+08\n", - "1 2019-01-01 All no_measure aai 2.055335e+08\n", - "2 2020-01-01 All no_measure aai 2.271876e+08\n", - "3 2021-01-01 All no_measure aai 2.490056e+08\n", - "4 2022-01-01 All no_measure aai 2.709873e+08\n", - ".. ... ... ... ... ...\n", - "133 2038-01-01 1 no_measure aai 6.440116e+08\n", - "134 2039-01-01 0 no_measure aai 1.003259e+06\n", - "135 2039-01-01 1 no_measure aai 6.687412e+08\n", - "136 2040-01-01 0 no_measure aai 1.040877e+06\n", - "137 2040-01-01 1 no_measure aai 6.936344e+08\n", + " date measure metric risk\n", + "0 2018-01-01 no_measure aai 1.840432e+08\n", + "1 2019-01-01 no_measure aai 2.055335e+08\n", + "2 2020-01-01 no_measure aai 2.271876e+08\n", + "3 2021-01-01 no_measure aai 2.490056e+08\n", + "4 2022-01-01 no_measure aai 2.709873e+08\n", + ".. ... ... ... ...\n", + "87 2036-01-01 no_measure rp_1000 4.734810e+10\n", + "88 2037-01-01 no_measure rp_1000 4.893501e+10\n", + "89 2038-01-01 no_measure rp_1000 5.052490e+10\n", + "90 2039-01-01 no_measure rp_1000 5.211776e+10\n", + "91 2040-01-01 no_measure rp_1000 5.371361e+10\n", "\n", - "[138 rows x 5 columns]" + "[92 rows x 4 columns]" ] }, - "execution_count": 12, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "risk_traj.all_dates_risk_metrics" + "risk_traj.per_date_risk_metrics" + ] + }, + { + "cell_type": "markdown", + "id": "00e0a09b-9dd6-4378-81a1-cda5290f9aa4", + "metadata": {}, + "source": [ + "You can also plot the \"components\" of the change in risk via a waterfall graph, both over the whole period:" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 19, "id": "08c226a4-944b-4301-acfa-602adde980a5", "metadata": {}, "outputs": [ @@ -646,7 +582,7 @@ "" ] }, - "execution_count": 13, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" }, @@ -670,12 +606,12 @@ "id": "7896af66-b0aa-4418-b22e-c64fd4d2cfe1", "metadata": {}, "source": [ - "And on a yearly basis:" + "And as well on a per date basis:" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 20, "id": "cf40380a-5814-4164-a592-7ab181776b5a", "metadata": {}, "outputs": [ @@ -685,7 +621,7 @@ "" ] }, - "execution_count": 15, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" }, @@ -701,20 +637,168 @@ } ], "source": [ - "risk_traj.plot_dately_waterfall()" + "risk_traj.plot_per_date_waterfall()" + ] + }, + { + "cell_type": "markdown", + "id": "759c6736-8d34-4012-a5ac-7c1999eaf193", + "metadata": {}, + "source": [ + "Note that as warned in the first plot, we plot the change in risk due to exposure change only, and the additional change when considering change in hazard. As vulnerability is most often non-linear, this should be considered with caution." + ] + }, + { + "cell_type": "markdown", + "id": "a078921f-dca1-4850-83bf-16d39935d5b2", + "metadata": {}, + "source": [ + "### Grouping" + ] + }, + { + "cell_type": "markdown", + "id": "2283e6f9-0230-4865-a5db-ac33b5d9eccc", + "metadata": {}, + "source": [ + "If `compute_groups` is set to True, the object will also compute the Annual Average Impact per group_id from the exposure:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "4af17732-708b-48e0-938b-afb962a7d29d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Impact function sets differ. Will update the first one with the second.\n" + ] + } + ], + "source": [ + "grouped_risk_traj = RiskTrajectory(snapcol, compute_groups=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "ff4da4a5-a2bc-4697-b829-43c4b05776d2", + "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", + " \n", + " \n", + "
periodgroupmeasuremetricrisk
02018-01-01 to 2040-01-010no_measureaai1.487445e+07
12018-01-01 to 2040-01-011no_measureaai9.945312e+09
22018-01-01 to 2040-01-01Allno_measureaai9.960186e+09
32018-01-01 to 2040-01-01Allno_measurerp_1003.288826e+11
42018-01-01 to 2040-01-01Allno_measurerp_10008.369369e+11
52018-01-01 to 2040-01-01Allno_measurerp_5008.369369e+11
\n", + "
" + ], + "text/plain": [ + " period group measure metric risk\n", + "0 2018-01-01 to 2040-01-01 0 no_measure aai 1.487445e+07\n", + "1 2018-01-01 to 2040-01-01 1 no_measure aai 9.945312e+09\n", + "2 2018-01-01 to 2040-01-01 All no_measure aai 9.960186e+09\n", + "3 2018-01-01 to 2040-01-01 All no_measure rp_100 3.288826e+11\n", + "4 2018-01-01 to 2040-01-01 All no_measure rp_1000 8.369369e+11\n", + "5 2018-01-01 to 2040-01-01 All no_measure rp_500 8.369369e+11" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "grouped_risk_traj.total_risk_metrics" ] }, { "cell_type": "markdown", - "id": "c629b746-512f-4d57-8ad8-487b57274c4f", + "id": "e78f1b7a-8ebe-4f46-96d0-ace8815ee3b8", "metadata": {}, "source": [ - "Note that we plot the change in risk due to exposure change only, and the additional change when considering change in hazard. As vulnerability is most often non-linear, this should be considered with caution." + "From this, one could for instance evaluate how the risk for a specific type of asset, or a specific population, evolves in between two points in time." ] }, { "cell_type": "markdown", - "id": "7ef127ba-96e3-48bc-a1ea-a9df4cb0acd5", + "id": "501e455b-e7c6-4672-9191-d5fefe38d424", "metadata": {}, "source": [ "### DiscRates" @@ -725,14 +809,14 @@ "id": "0dba0218-55fe-423d-a520-61d3cb2a991c", "metadata": {}, "source": [ - "To correctly assess the future risk, you may want to apply a discount rate, in order to express future costs in net present value.\n", + "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 using the `DiscRates` class:" + "This can easily be done using the already existing `DiscRates` class:" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 23, "id": "651e31cb-5a55-4a22-a7c3-b5f79b3a20ef", "metadata": {}, "outputs": [], @@ -747,103 +831,124 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 24, "id": "d86bedbb-6c0a-4f7d-a63e-5012510339d3", "metadata": {}, - "outputs": [], - "source": [ - "discounted_risk_traj = RiskTrajectory(snapcol, risk_disc=discount_stern)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "1d436f15-020a-40e2-8db7-869b5e3a10a1", - "metadata": {}, "outputs": [ { - "ename": "TypeError", - "evalue": "Addition/subtraction of integers and integer-arrays with Timestamp is no longer supported. Instead of adding/subtracting `n`, use `n * obj.freq`", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[18], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mdiscounted_risk_traj\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mall_dates_risk_metrics\u001b[49m\n", - "File \u001b[0;32m~/Repos/climada_python/climada/trajectories/risk_trajectory.py:189\u001b[0m, in \u001b[0;36mRiskTrajectory.all_dates_risk_metrics\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 187\u001b[0m \u001b[38;5;129m@property\u001b[39m\n\u001b[1;32m 188\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mall_dates_risk_metrics\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m--> 189\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_calc_risk_metrics\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtotal\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnpv\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/Repos/climada_python/climada/trajectories/risk_trajectory.py:196\u001b[0m, in \u001b[0;36mRiskTrajectory._calc_risk_metrics\u001b[0;34m(self, total, npv)\u001b[0m\n\u001b[1;32m 195\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21m_calc_risk_metrics\u001b[39m(\u001b[38;5;28mself\u001b[39m, total\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, npv\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m):\n\u001b[0;32m--> 196\u001b[0m df \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_calc_annual_risk_metrics\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnpv\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnpv\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 197\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m total:\n\u001b[1;32m 198\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_calc_periods_risk(df)\n", - "File \u001b[0;32m~/Repos/climada_python/climada/trajectories/risk_trajectory.py:134\u001b[0m, in \u001b[0;36mRiskTrajectory._calc_annual_risk_metrics\u001b[0;34m(self, npv)\u001b[0m\n\u001b[1;32m 126\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mgroup\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01min\u001b[39;00m df\u001b[38;5;241m.\u001b[39mcolumns:\n\u001b[1;32m 127\u001b[0m grouper \u001b[38;5;241m=\u001b[39m [\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mgroup\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m+\u001b[39m grouper\n\u001b[1;32m 129\u001b[0m df[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mrisk\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[43mdf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgroupby\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 130\u001b[0m \u001b[43m \u001b[49m\u001b[43mgrouper\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 131\u001b[0m \u001b[43m \u001b[49m\u001b[43mdropna\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 132\u001b[0m \u001b[43m \u001b[49m\u001b[43mas_index\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 133\u001b[0m \u001b[43m \u001b[49m\u001b[43mgroup_keys\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[0;32m--> 134\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mrisk\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtransform\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnpv_transform\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 135\u001b[0m df \u001b[38;5;241m=\u001b[39m df\u001b[38;5;241m.\u001b[39mreset_index()\n\u001b[1;32m 137\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m df\n", - "File \u001b[0;32m~/miniforge3/envs/cb_refactoring/lib/python3.10/site-packages/pandas/core/groupby/generic.py:516\u001b[0m, in \u001b[0;36mSeriesGroupBy.transform\u001b[0;34m(self, func, engine, engine_kwargs, *args, **kwargs)\u001b[0m\n\u001b[1;32m 513\u001b[0m \u001b[38;5;129m@Substitution\u001b[39m(klass\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mSeries\u001b[39m\u001b[38;5;124m\"\u001b[39m, example\u001b[38;5;241m=\u001b[39m__examples_series_doc)\n\u001b[1;32m 514\u001b[0m \u001b[38;5;129m@Appender\u001b[39m(_transform_template)\n\u001b[1;32m 515\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mtransform\u001b[39m(\u001b[38;5;28mself\u001b[39m, func, \u001b[38;5;241m*\u001b[39margs, engine\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, engine_kwargs\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m--> 516\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_transform\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 517\u001b[0m \u001b[43m \u001b[49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mengine\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mengine\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mengine_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mengine_kwargs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\n\u001b[1;32m 518\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/miniforge3/envs/cb_refactoring/lib/python3.10/site-packages/pandas/core/groupby/groupby.py:1950\u001b[0m, in \u001b[0;36mGroupBy._transform\u001b[0;34m(self, func, engine, engine_kwargs, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1947\u001b[0m warn_alias_replacement(\u001b[38;5;28mself\u001b[39m, orig_func, func)\n\u001b[1;32m 1949\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(func, \u001b[38;5;28mstr\u001b[39m):\n\u001b[0;32m-> 1950\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_transform_general\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mengine\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mengine_kwargs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1952\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m func \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m base\u001b[38;5;241m.\u001b[39mtransform_kernel_allowlist:\n\u001b[1;32m 1953\u001b[0m msg \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfunc\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m is not a valid function name for transform(name)\u001b[39m\u001b[38;5;124m\"\u001b[39m\n", - "File \u001b[0;32m~/miniforge3/envs/cb_refactoring/lib/python3.10/site-packages/pandas/core/groupby/generic.py:556\u001b[0m, in \u001b[0;36mSeriesGroupBy._transform_general\u001b[0;34m(self, func, engine, engine_kwargs, *args, **kwargs)\u001b[0m\n\u001b[1;32m 551\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m name, group \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgrouper\u001b[38;5;241m.\u001b[39mget_iterator(\n\u001b[1;32m 552\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_selected_obj, axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39maxis\n\u001b[1;32m 553\u001b[0m ):\n\u001b[1;32m 554\u001b[0m \u001b[38;5;66;03m# this setattr is needed for test_transform_lambda_with_datetimetz\u001b[39;00m\n\u001b[1;32m 555\u001b[0m \u001b[38;5;28mobject\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__setattr__\u001b[39m(group, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mname\u001b[39m\u001b[38;5;124m\"\u001b[39m, name)\n\u001b[0;32m--> 556\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgroup\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 558\u001b[0m results\u001b[38;5;241m.\u001b[39mappend(klass(res, index\u001b[38;5;241m=\u001b[39mgroup\u001b[38;5;241m.\u001b[39mindex))\n\u001b[1;32m 560\u001b[0m \u001b[38;5;66;03m# check for empty \"results\" to avoid concat ValueError\u001b[39;00m\n", - "File \u001b[0;32m~/Repos/climada_python/climada/trajectories/risk_trajectory.py:113\u001b[0m, in \u001b[0;36mRiskTrajectory._calc_annual_risk_metrics..npv_transform\u001b[0;34m(group)\u001b[0m\n\u001b[1;32m 111\u001b[0m start_date \u001b[38;5;241m=\u001b[39m group\u001b[38;5;241m.\u001b[39mindex\u001b[38;5;241m.\u001b[39mget_level_values(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdate\u001b[39m\u001b[38;5;124m\"\u001b[39m)\u001b[38;5;241m.\u001b[39mmin()\n\u001b[1;32m 112\u001b[0m end_date \u001b[38;5;241m=\u001b[39m group\u001b[38;5;241m.\u001b[39mindex\u001b[38;5;241m.\u001b[39mget_level_values(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdate\u001b[39m\u001b[38;5;124m\"\u001b[39m)\u001b[38;5;241m.\u001b[39mmax()\n\u001b[0;32m--> 113\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mcalc_npv_cash_flows\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 114\u001b[0m \u001b[43m \u001b[49m\u001b[43mgroup\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvalues\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstart_date\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mend_date\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrisk_disc\u001b[49m\n\u001b[1;32m 115\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/Repos/climada_python/climada/trajectories/risk_trajectory.py:355\u001b[0m, in \u001b[0;36mcalc_npv_cash_flows\u001b[0;34m(cash_flows, start_date, end_date, disc)\u001b[0m\n\u001b[1;32m 352\u001b[0m end_date \u001b[38;5;241m=\u001b[39m end_date \u001b[38;5;129;01mor\u001b[39;00m (start_date \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mlen\u001b[39m(cash_flows) \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m 354\u001b[0m \u001b[38;5;66;03m# Generate an array of dates\u001b[39;00m\n\u001b[0;32m--> 355\u001b[0m dates \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marange(start_date, \u001b[43mend_date\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m)\n\u001b[1;32m 357\u001b[0m \u001b[38;5;66;03m# Find the intersection of dates and discount dates\u001b[39;00m\n\u001b[1;32m 358\u001b[0m disc_dates \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mintersect1d(dates, disc\u001b[38;5;241m.\u001b[39mdates)\n", - "File \u001b[0;32mtimestamps.pyx:466\u001b[0m, in \u001b[0;36mpandas._libs.tslibs.timestamps._Timestamp.__add__\u001b[0;34m()\u001b[0m\n", - "\u001b[0;31mTypeError\u001b[0m: Addition/subtraction of integers and integer-arrays with Timestamp is no longer supported. Instead of adding/subtracting `n`, use `n * obj.freq`" + "name": "stderr", + "output_type": "stream", + "text": [ + "Impact function sets differ. Will update the first one with the second.\n" ] } ], "source": [ - "discounted_risk_traj.all_dates_risk_metrics" + "discounted_risk_traj = RiskTrajectory(snapcol, risk_disc=discount_stern)" ] }, { "cell_type": "code", - "execution_count": 91, - "id": "0f732fc0-21b6-456d-9d97-662aa1b8cf15", + "execution_count": 38, + "id": "1d436f15-020a-40e2-8db7-869b5e3a10a1", "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", + "
periodmeasuremetricrisk
02018-01-01 to 2040-01-01no_measureaai8.303380e+09
12018-01-01 to 2040-01-01no_measurerp_1002.737759e+11
22018-01-01 to 2040-01-01no_measurerp_10007.023722e+11
32018-01-01 to 2040-01-01no_measurerp_5007.023722e+11
\n", + "
" + ], "text/plain": [ - "" + " period measure metric risk\n", + "0 2018-01-01 to 2040-01-01 no_measure aai 8.303380e+09\n", + "1 2018-01-01 to 2040-01-01 no_measure rp_100 2.737759e+11\n", + "2 2018-01-01 to 2040-01-01 no_measure rp_1000 7.023722e+11\n", + "3 2018-01-01 to 2040-01-01 no_measure rp_500 7.023722e+11" ] }, - "execution_count": 91, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ - "import seaborn as sns\n", - "\n", - "sns.lineplot(\n", - " discouted_risk_traj.yearly_risk_metrics.loc[\n", - " discouted_risk_traj.yearly_risk_metrics[\"metric\"] == \"aai\"\n", - " ],\n", - " x=\"year\",\n", - " y=\"risk\",\n", - ")" + "discounted_risk_traj.total_risk_metrics" ] }, { "cell_type": "code", - "execution_count": null, - "id": "9c613f3a-8f6c-4eb2-ac1f-fdf8a4367418", + "execution_count": 48, + "id": "0f732fc0-21b6-456d-9d97-662aa1b8cf15", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 90, + "execution_count": 48, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -853,23 +958,27 @@ } ], "source": [ + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "g = sns.lineplot(\n", + " discounted_risk_traj.per_date_risk_metrics.loc[\n", + " discounted_risk_traj.per_date_risk_metrics[\"metric\"] == \"aai\"\n", + " ],\n", + " x=\"date\",\n", + " y=\"risk\",\n", + " color=\"blue\",\n", + ")\n", "sns.lineplot(\n", - " risk_traj.yearly_risk_metrics.loc[\n", - " discouted_risk_traj.yearly_risk_metrics[\"metric\"] == \"aai\"\n", + " risk_traj.per_date_risk_metrics.loc[\n", + " risk_traj.per_date_risk_metrics[\"metric\"] == \"aai\"\n", " ],\n", - " x=\"year\",\n", + " x=\"date\",\n", " y=\"risk\",\n", " ax=g,\n", + " color=\"red\",\n", ")" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ebe17c88-a970-4e29-a74f-3e8126c7a0b8", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 10ca2433627d93e2fa1f942b9acfea60cc06615c Mon Sep 17 00:00:00 2001 From: spjuhel Date: Wed, 2 Apr 2025 19:26:16 +0200 Subject: [PATCH 009/113] fixes a typo from mass edit --- climada/trajectories/risk_trajectory.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/climada/trajectories/risk_trajectory.py b/climada/trajectories/risk_trajectory.py index 3322ee0a4..b52c8ee86 100644 --- a/climada/trajectories/risk_trajectory.py +++ b/climada/trajectories/risk_trajectory.py @@ -535,9 +535,9 @@ def calc_per_date_eais(imp_mats_0, imp_mats_1, frequency_0, frequency_1): tuple Tuple containing: - per_date_eai_exp_0 : list of float - Per_Date expected annual impacts for scenario 0. + per date expected annual impacts for scenario 0. - per_date_eai_exp_1 : list of float - Per_Date expected annual impacts for scenario 1. + per date expected annual impacts for scenario 1. """ per_date_eai_exp_0 = [ ImpactCalc.eai_exp_from_mat(imp_mat, frequency_0) for imp_mat in imp_mats_0 From 389787e9d66a8d7354d55a3459f5bbfd20cd2669 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 15 Apr 2025 18:42:22 +0200 Subject: [PATCH 010/113] Refactor to a more object-oriented design - Replaced RiskPeriod class by CalcRiskPeriod class to centralize shared computations and dynamic metric instantiation. - Improved efficiency by reusing shared computations across metrics. - Added InterpolationStrategy and ImpactCalcStrategy classes to abstract that part of the computation --- climada/trajectories/risk_trajectory.py | 576 ++++++++---------------- climada/trajectories/riskperiod.py | 567 ++++++++++++++++------- 2 files changed, 614 insertions(+), 529 deletions(-) diff --git a/climada/trajectories/risk_trajectory.py b/climada/trajectories/risk_trajectory.py index b52c8ee86..616143ae6 100644 --- a/climada/trajectories/risk_trajectory.py +++ b/climada/trajectories/risk_trajectory.py @@ -26,13 +26,20 @@ import numpy as np import pandas as pd -from climada.engine.impact_calc import ImpactCalc from climada.entity.disc_rates.base import DiscRates -from climada.trajectories.riskperiod import RiskPeriod +from climada.trajectories.riskperiod import ( + CalcRiskPeriod, + ImpactCalcComputation, + ImpactComputationStrategy, + InterpolationStrategy, + LinearInterpolation, +) from climada.trajectories.snapshot import Snapshot LOGGER = logging.getLogger(__name__) +POSSIBLE_METRICS = ["aai", "rp", "group", "components"] + class RiskTrajectory: """Calculates risk trajectories over a series of snapshots. @@ -62,39 +69,61 @@ class RiskTrajectory: def __init__( self, snapshots_list: list[Snapshot], + interval_freq: str = "YS", + all_groups_name: str = "All", risk_disc: DiscRates | None = None, - metrics: list[str] = ["aai", "eai", "rp"], - return_periods: list[int] = [100, 500, 1000], - compute_groups=False, risk_transf_cover=None, risk_transf_attach=None, + calc_residual: bool = True, + interpolation_strategy: InterpolationStrategy | None = None, + impact_computation_strategy: ImpactComputationStrategy | None = None, ): - "docstring" - self._metrics_up_to_date: bool = False - self.metrics = metrics - self._return_periods = return_periods + self._aai_metrics = None + self._return_periods_metrics = None + self._risk_components_metrics = None + self._aai_per_group_metrics = None + self._all_risk_metrics = None + self._metrics_up_to_date = False + self._risk_period_up_to_date: bool = False + self._snapshots = snapshots_list + self._all_groups_name = all_groups_name + self._default_rp = [50, 100, 500] self.start_date = min([snapshot.date for snapshot in snapshots_list]) self.end_date = max([snapshot.date for snapshot in snapshots_list]) + self._interval_freq = interval_freq self.risk_disc = risk_disc self._risk_transf_cover = risk_transf_cover self._risk_transf_attach = risk_transf_attach + self._calc_residual = calc_residual + self._interpolation_strategy = interpolation_strategy or LinearInterpolation() + self._impact_computation_strategy = ( + impact_computation_strategy or ImpactCalcComputation() + ) LOGGER.debug("Computing risk periods") - self._risk_periods = self._calc_risk_periods(snapshots_list) - self._update_risk_metrics(compute_groups=compute_groups) + self._risk_periods_calculators = self._calc_risk_periods(snapshots_list) + + def _reset_metrics(self): + self._aai_metrics = None + self._return_periods_metrics = None + self._risk_components_metrics = None + self._aai_per_group_metrics = None + self._all_risk_metrics = None + self._metrics_up_to_date = False @property - def return_periods(self) -> list[int]: - """The return periods considered in the risk trajectory.""" - return self._return_periods + def default_rp(self): + return self._default_rp - @return_periods.setter - def return_periods(self, value: list[int]): + @default_rp.setter + def default_rp(self, value): if not isinstance(value, list): - raise ValueError("Not a list") + ValueError("Return periods need to be a list of int.") if any(not isinstance(i, int) for i in value): - raise ValueError("List elements are not int") - self._return_periods = value + ValueError("Return periods need to be a list of int.") + self._return_periods_metrics = None + self._all_risk_metrics = None self._metrics_up_to_date = False + self._default_rp = value @property def risk_transf_cover(self): @@ -104,7 +133,8 @@ def risk_transf_cover(self): @risk_transf_cover.setter def risk_transf_cover(self, value): self._risk_transf_cover = value - self._metrics_up_to_date = False + self._risk_period_up_to_date = False + self._reset_metrics @property def risk_transf_attach(self): @@ -114,12 +144,17 @@ def risk_transf_attach(self): @risk_transf_attach.setter def risk_transf_attach(self, value): self._risk_transf_attach = value - self._metrics_up_to_date = False + self._risk_period_up_to_date = False + self._reset_metrics @property - def risk_periods(self) -> list[RiskPeriod]: + def risk_periods(self) -> list: """The computed risk periods from the snapshots.""" - return self._risk_periods + if not self._risk_period_up_to_date: + self._risk_periods_calculators = self._calc_risk_periods(self._snapshots) + self._risk_period_up_to_date = True + + return self._risk_periods_calculators def _calc_risk_periods(self, snapshots): def pairwise(container: list): @@ -145,42 +180,126 @@ def pairwise(container: list): next(b, None) return zip(a, b) + # impfset = self._merge_impfset(snapshots) return [ - RiskPeriod(start_snapshot, end_snapshot) + CalcRiskPeriod( + start_snapshot, + end_snapshot, + interval_freq=self._interval_freq, + interpolation_strategy=self._interpolation_strategy, + impact_computation_strategy=self._impact_computation_strategy, + risk_transf_cover=self.risk_transf_cover, + risk_transf_attach=self.risk_transf_attach, + calc_residual=self._calc_residual, + ) for start_snapshot, end_snapshot in pairwise(snapshots) ] - def _update_risk_metrics(self, compute_groups=False): - results_df = [] - for period in self._risk_periods: - results_df.append( - impact_mixer( - period, - self.metrics, - self.return_periods, - compute_groups, - all_groups_name="All", - ) - ) - results_df = pd.concat(results_df, axis=0) - - # duplicate rows may arise from overlapping end and start if there's more than two snapshots - results_df.drop_duplicates(inplace=True) - - # reorder the columns (but make sure not to remove possibly important ones in the future) - columns_to_front = ["date", "measure", "metric"] - if compute_groups: - columns_to_front = ["group"] + columns_to_front - self._annual_risk_metrics = results_df[ - columns_to_front - + [ - col - for col in results_df.columns - if col not in columns_to_front + ["group", "risk", "rp"] + @classmethod + def npv_transform(cls, df, risk_disc): + def _npv_group(group, disc): + start_date = group.index.get_level_values("date").min() + end_date = group.index.get_level_values("date").max() + return calc_npv_cash_flows(group, start_date, end_date, disc) + + df = df.set_index("date") + grouper = cls._grouper + if "group" in df.columns: + grouper = ["group"] + grouper + + df["risk"] = df.groupby( + grouper, + dropna=False, + as_index=False, + group_keys=False, + )["risk"].transform(_npv_group, risk_disc) + df = df.reset_index() + return df + + def _generic_metrics( + self, npv=True, metric_name=None, metric_meth=None, *args, **kwargs + ): + """Generic method to compute metrics based on the provided metric name and method.""" + if metric_name is None or metric_meth is None: + raise ValueError("Both metric_name and metric_meth must be provided.") + + # Construct the attribute name for storing the metric results + attr_name = f"_{metric_name}_metrics" + + if getattr(self, attr_name, None) is None: + tmp = [] + for calc_period in self.risk_periods: + # Call the specified method on the calc_period object + tmp.append(getattr(calc_period, metric_meth)(*args, **kwargs)) + + tmp = pd.concat(tmp) + tmp.drop_duplicates(inplace=True) + tmp["group"] = tmp["group"].fillna(self._all_groups_name) + columns_to_front = ["group", "date", "measure", "metric"] + tmp = tmp[ + columns_to_front + + [ + col + for col in tmp.columns + if col not in columns_to_front + ["group", "risk", "rp"] + ] + + ["risk"] ] - + ["risk"] - ] - self._metrics_up_to_date = True + if npv: + tmp = self.npv_transform(tmp, self.risk_disc) + + setattr(self, attr_name, tmp) + + return getattr(self, attr_name) + + def aai_metrics(self, npv=True): + return self._generic_metrics( + npv=npv, metric_name="aai", metric_meth="calc_aai_metric" + ) + + def return_periods_metrics(self, return_periods=None, npv=True): + return_periods = return_periods if return_periods else self.default_rp + return self._generic_metrics( + npv=npv, + metric_name="return_periods", + metric_meth="calc_return_periods_metric", + return_periods=return_periods, + ) + + def aai_per_group_metrics(self, npv=True): + return self._generic_metrics( + npv=npv, + metric_name="aai_per_group", + metric_meth="calc_aai_per_group_metric", + ) + + def risk_components_metrics(self, npv=True): + return self._generic_metrics( + npv=npv, + metric_name="risk_components", + metric_meth="calc_risk_components_metric", + ) + + def all_risk_metrics(self, return_periods=[50, 100, 500], npv=True): + if not self._metrics_up_to_date: + aai = self.aai_metrics + rp = self.return_periods_metrics(return_periods) + aai_per_group = self.aai_per_group_metrics + risk_components = self.risk_components_metrics + tmp = pd.concat([aai, rp, aai_per_group, risk_components]) + columns_to_front = ["group", "date", "measure", "metric"] + self._all_risk_metrics = tmp[ + columns_to_front + + [ + col + for col in tmp.columns + if col not in columns_to_front + ["group", "risk", "rp"] + ] + + ["risk"] + ] + self._metrics_up_to_date = True + + return self._all_risk_metrics @staticmethod def _get_risk_periods( @@ -192,36 +311,8 @@ def _get_risk_periods( if (start_date >= period.start_date or end_date <= period.end_date) ] - def _calc_per_date_risk_metrics(self, npv=True): - def npv_transform(group): - start_date = group.index.get_level_values("date").min() - end_date = group.index.get_level_values("date").max() - return calc_npv_cash_flows(group, start_date, end_date, self.risk_disc) - - if self._metrics_up_to_date: - df = self._annual_risk_metrics - else: - self._update_risk_metrics() - df = self._annual_risk_metrics - - if npv: - df = df.set_index("date") - grouper = self._grouper - if "group" in df.columns: - grouper = ["group"] + grouper - - df["risk"] = df.groupby( - grouper, - dropna=False, - as_index=False, - group_keys=False, - )["risk"].transform(npv_transform) - df = df.reset_index() - - return df - @classmethod - def _calc_periods_risk(cls, df: pd.DataFrame, time_unit="year", colname="risk"): + def _per_period_risk(cls, df: pd.DataFrame, time_unit="year", colname="risk"): def identify_continuous_periods(group, time_unit): # Calculate the difference between consecutive dates if time_unit == "year": @@ -271,75 +362,32 @@ def identify_continuous_periods(group, time_unit): @property def per_date_risk_metrics(self) -> pd.DataFrame | pd.Series: """Returns a tidy dataframe of the risk metrics for all dates.""" - return self._calc_risk_metrics(total=False, npv=True) + return self._prepare_risk_metrics(total=False, npv=True) @property def total_risk_metrics(self): """Returns a tidy dataframe of the risk metrics with the total for each different period.""" - return self._calc_risk_metrics(total=True, npv=True) + return self._prepare_risk_metrics(total=True, npv=True) - def _calc_risk_metrics(self, total=False, npv=True): - df = self._calc_per_date_risk_metrics(npv=npv) + def _prepare_risk_metrics(self, total=False, npv=True): + df = self.all_risk_metrics(npv=npv) if total: - return self._calc_periods_risk(df) + return self._per_period_risk(df) return df - def _calc_waterfall_plot_data(self, start_date=None, end_date=None): + def _calc_waterfall_plot_data(self, start_date=None, end_date=None, npv=True): 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 - considered_risk_periods = self._get_risk_periods( - self._risk_periods, start_date=start_date, end_date=end_date - ) - - risk_component = { - str(period.start_date) - + "-" - + str(period.end_date): self._calc_risk_component(period) - for period in considered_risk_periods - } - risk_component = pd.concat( - risk_component.values(), keys=risk_component.keys(), names=["Period"] - ).reset_index() - risk_component = risk_component.loc[ - (risk_component["date"].dt.date >= start_date) - & (risk_component["date"].dt.date <= end_date) + risk_components = self.risk_components_metrics(npv) + risk_components = risk_components.loc[ + (risk_components["date"].dt.date >= start_date) + & (risk_components["date"].dt.date <= end_date) ] - risk_component["Base risk"] = risk_component["Base risk"].min() - risk_component[["Change in Exposure", "Change in Hazard (with Exposure)"]] = ( - risk_component[["Change in Exposure", "Change in Hazard (with Exposure)"]] - .replace(0, None) - .ffill() - .fillna(0.0) - ) - return risk_component - - def _calc_risk_component(self, period: RiskPeriod): - imp_mats_H0 = period._imp_mats_0 - imp_mats_H1 = period._imp_mats_1 - freq_H0 = period.snapshot0.hazard.frequency - freq_H1 = period.snapshot1.hazard.frequency - per_date_eai_H0, per_date_eai_H1 = calc_per_date_eais( - imp_mats_H0, imp_mats_H1, freq_H0, freq_H1 - ) - per_date_aai_H0, per_date_aai_H1 = calc_per_date_aais( - per_date_eai_H0, per_date_eai_H1 - ) - prop_H1 = np.linspace(0, 1, num=len(period.date_idx)) - prop_H0 = 1 - prop_H1 - per_date_aai = prop_H0 * per_date_aai_H0 + prop_H1 * per_date_aai_H1 - - risk_dev_0 = per_date_aai_H0 - per_date_aai[0] - risk_cc_0 = per_date_aai - (risk_dev_0 + per_date_aai[0]) - df = pd.DataFrame( - { - "Base risk": per_date_aai - (risk_dev_0 + risk_cc_0), - "Change in Exposure": risk_dev_0, - "Change in Hazard (with Exposure)": risk_cc_0, - }, - index=period.date_idx, - ) - return df.round(1) + risk_components = risk_components.set_index(["date", "metric"])[ + "risk" + ].unstack() + return risk_components def plot_per_date_waterfall(self, ax=None, start_date=None, end_date=None): """Plot a waterfall chart of risk components over a specified date range. @@ -376,7 +424,7 @@ def plot_per_date_waterfall(self, ax=None, start_date=None, end_date=None): risk_component = self._calc_waterfall_plot_data( start_date=start_date, end_date=end_date ) - risk_component.plot(ax=ax, kind="bar", x="date", stacked=True) + risk_component.plot(ax=ax, kind="bar", stacked=True) # Construct y-axis label and title based on parameters value_label = "USD" title_label = ( @@ -423,7 +471,7 @@ def plot_waterfall(self, ax=None, start_date=None, end_date=None): _, ax = plt.subplots(figsize=(8, 5)) risk_component = risk_component.loc[ - (risk_component["date"].dt.date == end_date) + (risk_component.index.date == end_date) ].squeeze() labels = [ @@ -433,17 +481,17 @@ def plot_waterfall(self, ax=None, start_date=None, end_date=None): f"Total Risk {end_date}", ] values = [ - risk_component["Base risk"], - risk_component["Change in Exposure"], - risk_component["Change in Hazard (with Exposure)"], - risk_component["Base risk"] - + risk_component["Change in Exposure"] - + risk_component["Change in Hazard (with Exposure)"], + risk_component["base risk"], + risk_component["delta from exposure"], + risk_component["delta from hazard"], + risk_component["base risk"] + + risk_component["delta from exposure"] + + risk_component["delta from hazard"], ] bottoms = [ 0.0, - risk_component["Base risk"], - risk_component["Base risk"] + risk_component["Change in Exposure"], + risk_component["base risk"], + risk_component["base risk"] + risk_component["delta from exposure"], 0.0, ] @@ -515,136 +563,6 @@ def calc_npv_cash_flows(cash_flows, start_date, end_date=None, disc=None): return df["npv_cash_flow"] -def calc_per_date_eais(imp_mats_0, imp_mats_1, frequency_0, frequency_1): - """ - Calculate per_date expected annual impact (EAI) values for two scenarios. - - Parameters - ---------- - imp_mats_0 : list of np.ndarray - List of interpolated impact matrices for scenario 0. - imp_mats_1 : list of np.ndarray - List of interpolated impact matrices for scenario 1. - frequency_0 : np.ndarray - Frequency values associated with scenario 0. - frequency_1 : np.ndarray - Frequency values associated with scenario 1. - - Returns - ------- - tuple - Tuple containing: - - per_date_eai_exp_0 : list of float - per date expected annual impacts for scenario 0. - - per_date_eai_exp_1 : list of float - per date expected annual impacts for scenario 1. - """ - per_date_eai_exp_0 = [ - ImpactCalc.eai_exp_from_mat(imp_mat, frequency_0) for imp_mat in imp_mats_0 - ] - per_date_eai_exp_1 = [ - ImpactCalc.eai_exp_from_mat(imp_mat, frequency_1) for imp_mat in imp_mats_1 - ] - return per_date_eai_exp_0, per_date_eai_exp_1 - - -def calc_per_date_aais(per_date_eai_exp_0, per_date_eai_exp_1): - """ - Calculate per_date aggregate annual impact (AAI) values for two scenarios. - - Parameters - ---------- - per_date_eai_exp_0 : list of float - Per_Date expected annual impacts for scenario 0. - per_date_eai_exp_1 : list of float - Per_Date expected annual impacts for scenario 1. - - Returns - ------- - tuple - Tuple containing: - - per_date_aai_0 : list of float - Aggregate annual impact values for scenario 0. - - per_date_aai_1 : list of float - Aggregate annual impact values for scenario 1. - """ - per_date_aai_0 = [ - ImpactCalc.aai_agg_from_eai_exp(eai_exp) for eai_exp in per_date_eai_exp_0 - ] - per_date_aai_1 = [ - ImpactCalc.aai_agg_from_eai_exp(eai_exp) for eai_exp in per_date_eai_exp_1 - ] - return per_date_aai_0, per_date_aai_1 - - -def calc_freq_curve(imp_mat_intrpl, frequency, return_per=None): - """ - Calculate the frequency curve - - Parameters: - imp_mat_intrpl (np.array): The interpolated impact matrix - frequency (np.array): The frequency of the hazard - return_per (np.array): The return period - - Returns: - ifc_return_per (np.array): The impact exceeding frequency - ifc_impact (np.array): The impact exceeding the return period - """ - - # Calculate the at_event make the np.array - 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 ifc_impact - - -def calc_per_date_rps(imp_mats_0, imp_mats_1, frequency_0, frequency_1, return_periods): - """ - Calculate per_date return period impact values for two scenarios. - - Parameters - ---------- - imp_mats_0 : list of np.ndarray - List of interpolated impact matrices for scenario 0. - imp_mats_1 : list of np.ndarray - List of interpolated impact matrices for scenario 1. - frequency_0 : np.ndarray - Frequency values for scenario 0. - frequency_1 : np.ndarray - Frequency values for scenario 1. - return_periods : list of int - Return periods to calculate impact values for. - - Returns - ------- - tuple - Tuple containing: - - rp_0 : list of np.ndarray - Per_Date return period impact values for scenario 0. - - rp_1 : list of np.ndarray - Per_Date return period impact values for scenario 1. - """ - rp_0 = [ - calc_freq_curve(imp_mat, frequency_0, return_periods) for imp_mat in imp_mats_0 - ] - rp_1 = [ - calc_freq_curve(imp_mat, frequency_1, return_periods) for imp_mat in imp_mats_1 - ] - return rp_0, rp_1 - - def get_eai_exp(eai_exp, group_map): """ Aggregate expected annual impact (EAI) by groups. @@ -665,101 +583,3 @@ def get_eai_exp(eai_exp, group_map): for group_name, exp_indices in group_map.items(): eai_region_id[group_name] = np.sum(eai_exp[:, exp_indices], axis=1) return eai_region_id - - -def impact_mixer( - risk_period, - metrics, - return_periods, - compute_groups=False, - all_groups_name: str | None = None, -): - """ - Perform Bayesian mixing of impacts across snapshots. - - Parameters - ---------- - start_snapshot : Snapshot - The starting snapshot. - end_snapshot : Snapshot - The ending snapshot. - metrics : list of str - Metrics to calculate (e.g., 'eai', 'aai', 'rp'). - return_periods : list of int - Return periods for calculating impact values. - groups : dict, optional - Mapping of group names to indices for aggregating EAI values by group. - all_groups_name : str, optional - Name for all-groups aggregation in the output. - risk_transf_cover : float, optional - Coverage level for risk transfer calculations. - risk_transf_attach : float, optional - Attachment point for risk transfer calculations. - calc_residual : bool, optional - Whether to calculate residual impacts after applying risk transfer. - - Returns - ------- - pd.DataFrame - DataFrame of calculated impact values by date, group, and metric. - """ - - # Posterity comment: This was called bayesian_mixing in its initial version, - # although there is nothing really bayesian here, (but it did sound cool!) - - all_groups_n = pd.NA if all_groups_name is None else all_groups_name - - prop_H0, prop_H1 = risk_period._prop_H0, risk_period._prop_H1 - frequency_0 = risk_period.snapshot0.hazard.frequency - frequency_1 = risk_period.snapshot1.hazard.frequency - imp_mats_0, imp_mats_1 = risk_period.get_interp() - per_date_eai_exp_0, per_date_eai_exp_1 = calc_per_date_eais( - imp_mats_0, imp_mats_1, frequency_0, frequency_1 - ) - date_idx = risk_period.date_idx - res = [] - if "aai" in metrics: - per_date_aai_0, per_date_aai_1 = calc_per_date_aais( - per_date_eai_exp_0, per_date_eai_exp_1 - ) - per_date_aai = prop_H0 * per_date_aai_0 + prop_H1 * per_date_aai_1 - aai_df = pd.DataFrame(index=date_idx, columns=["risk"], data=per_date_aai) - aai_df["group"] = all_groups_n - aai_df["metric"] = "aai" - aai_df.reset_index(inplace=True) - res.append(aai_df) - - if "rp" in metrics: - rp_0, rp_1 = calc_per_date_rps( - imp_mats_0, imp_mats_1, frequency_0, frequency_1, return_periods - ) - per_date_rp = np.multiply(prop_H0.reshape(-1, 1), rp_0) + np.multiply( - prop_H1.reshape(-1, 1), rp_1 - ) - rp_df = pd.DataFrame( - index=date_idx, columns=return_periods, data=per_date_rp - ).melt(value_name="risk", var_name="rp", ignore_index=False) - rp_df.reset_index(inplace=True) - rp_df["group"] = all_groups_n - rp_df["metric"] = "rp_" + rp_df["rp"].astype(str) - res.append(rp_df) - - if compute_groups: - per_date_eai = np.multiply( - prop_H0.reshape(-1, 1), per_date_eai_exp_0 - ) + np.multiply(prop_H1.reshape(-1, 1), per_date_eai_exp_1) - eai_group_df = pd.DataFrame( - data=per_date_eai.T, - index=risk_period.snapshot1.exposure.gdf["group_id"], - columns=risk_period.date_idx, - ) - eai_group_df = eai_group_df.groupby(eai_group_df.index).sum() - eai_group_df = eai_group_df.melt( - ignore_index=False, value_name="risk" - ).reset_index(names="group") - eai_group_df["metric"] = "aai" - res.append(eai_group_df) - - ret = pd.concat(res, axis=0) - ret["measure"] = risk_period.measure_name - return ret diff --git a/climada/trajectories/riskperiod.py b/climada/trajectories/riskperiod.py index 69fc55f96..de27df24e 100644 --- a/climada/trajectories/riskperiod.py +++ b/climada/trajectories/riskperiod.py @@ -22,148 +22,156 @@ import copy import logging +from abc import ABC, abstractmethod import numpy as np import pandas as pd from scipy.sparse import lil_matrix from climada.engine.impact_calc import ImpactCalc -from climada.entity.impact_funcs.impact_func_set import ImpactFuncSet from climada.entity.measures.base import Measure from climada.trajectories.snapshot import Snapshot LOGGER = logging.getLogger(__name__) -class RiskPeriod: - """Interpolated impacts between two snapshots. - - This class calculates the interpolated impacts between two snapshots over a specified - time period. It supports risk transfer modifications and can compute residual impacts. - - Attributes - ---------- - snapshot0 : Snapshot - The snapshot starting the period. - snapshot1 : Snapshot - The snapshot ending the period. - start_date : datetime - The start date of the risk period. - end_date : datetime - The end date of the risk period. - time_frequency : str - The frequency of the time intervals (e.g., 'YS' for yearly). - See `pandas freq string documentation `_. - date_idx : pd.DatetimeIndex - The date range index between the start and end dates. - measure_name : str - The name of the measure applied to the period. "no_measure" if no measure is applied. - impfset : object - The impact function set for the period. If both snapshots do not share the same ImpactFuncSet object, - they are merged together. Note that if impact functions with the same hazard type and id differ, - the one from the ending Snapshot takes precedence. - """ - - # Future TODO: make lazy / delayed interpolation and impacts - # Future TODO: special case where hazard and exposure don't change (no need to interpolate) ? +def lazy_property(method): + attr_name = f"_{method.__name__}" - def __init__( - self, - snapshot0: Snapshot, - snapshot1: Snapshot, - measure_name="no_measure", - time_freq="YS", - risk_transf_cover=None, - risk_transf_attach=None, - calc_residual=True, - ): - LOGGER.debug( - f"Initializing new RiskPeriod from {snapshot0.date} to {snapshot1.date}, with snapshot0: {id(snapshot0)}, snapshot1: {id(snapshot1)}" - ) - self.snapshot0 = snapshot0 - self.snapshot1 = snapshot1 - self.start_date = snapshot0.date - self.end_date = snapshot1.date - self.time_frequency = time_freq - self.date_idx = pd.date_range( - snapshot0.date, snapshot1.date, freq=time_freq, name="date" - ) - self.measure_name = measure_name - self.impfset = self._merge_impfset(snapshot0.impfset, snapshot1.impfset) + @property + def _lazy(self): + if getattr(self, attr_name) is None: + setattr(self, attr_name, method(self)) + return getattr(self, attr_name) - # Posterity comment: The following attributes - # were refered as Victypliers in homage to Victor - # Watkinsson, the conceptual father of this module - self._prop_H1 = np.linspace(0, 1, num=len(self.date_idx)) - self._prop_H0 = 1 - self._prop_H1 + return _lazy - self._exp_y0 = snapshot0.exposure - self._exp_y1 = snapshot1.exposure - self._haz_y0 = snapshot0.hazard - self._haz_y1 = snapshot1.hazard - - # Compute impacts once - LOGGER.debug("Computing snapshots combination impacts") - imp_E0H0 = ImpactCalc(self._exp_y0, self.impfset, self._haz_y0).impact() - imp_E1H0 = ImpactCalc(self._exp_y1, self.impfset, self._haz_y0).impact() - imp_E0H1 = ImpactCalc(self._exp_y0, self.impfset, self._haz_y1).impact() - imp_E1H1 = ImpactCalc(self._exp_y1, self.impfset, self._haz_y1).impact() - - # Modify the impact matrices if risk transfer is provided - # TODO: See where this ends up - imp_E0H0.imp_mat = self.calc_residual_or_risk_transf_imp_mat( - imp_E0H0.imp_mat, risk_transf_attach, risk_transf_cover, calc_residual - ) - imp_E1H0.imp_mat = self.calc_residual_or_risk_transf_imp_mat( - imp_E1H0.imp_mat, risk_transf_attach, risk_transf_cover, calc_residual - ) - imp_E0H1.imp_mat = self.calc_residual_or_risk_transf_imp_mat( - imp_E0H1.imp_mat, risk_transf_attach, risk_transf_cover, calc_residual - ) - imp_E1H1.imp_mat = self.calc_residual_or_risk_transf_imp_mat( - imp_E1H1.imp_mat, risk_transf_attach, risk_transf_cover, calc_residual - ) - LOGGER.debug("Interpolating impact matrices between E0H0 and E1H0") - time_points = len(self.date_idx) - self._imp_mats_0 = interpolate_imp_mat(imp_E0H0, imp_E1H0, time_points) - LOGGER.debug("Interpolating impact matrices between E0H1 and E1H1") - self._imp_mats_1 = interpolate_imp_mat(imp_E0H1, imp_E1H1, time_points) - LOGGER.debug("Done") +class InterpolationStrategy(ABC): + """Interface for interpolation strategies.""" + + @abstractmethod + def interpolate(self, imp_E0, imp_E1, time_points: int) -> list: ... + + +class LinearInterpolation(InterpolationStrategy): + """Linear interpolation strategy.""" + + def interpolate(self, imp_E0, imp_E1, time_points: int): + try: + return self.interpolate_imp_mat(imp_E0, imp_E1, time_points) + except ValueError as e: + if str(e) == "inconsistent shape": + raise ValueError( + "Interpolation between impact matrices of different shapes" + ) @staticmethod - def _merge_impfset(impfs1: ImpactFuncSet, impfs2: ImpactFuncSet): - if impfs1 == impfs2: - return impfs1 - else: - LOGGER.warning( - "Impact function sets differ. Will update the first one with the second." - ) - impfs1._data |= impfs2._data # Merges dictionaries (priority to impfs2) - return impfs1 + def interpolate_imp_mat(imp0, imp1, time_points): + """Interpolate between two impact matrices over a specified time range. - def get_interp(self): - """Return two lists of interpolated impacts matrices with varying exposure, for starting and ending hazard. + Parameters + ---------- + imp0 : ImpactCalc + The impact calculation for the starting time. + imp1 : ImpactCalc + The impact calculation for the ending time. + time_points: + The number of points to interpolate. Returns ------- - - _imp_mats_0 : np.ndarray - Interpolated impact matrices varying Exposure from starting snapshot to ending one, using Hazard from starting snapshot. - _imp_mats_1 : np.ndarray - Interpolated impact matrices varying Exposure from starting snapshot to ending one, using Hazard from ending snapshot. + list of np.ndarray + List of interpolated impact matrices for each time points in the specified range. """ - return self._imp_mats_0, self._imp_mats_1 - def apply_measure(self, measure: Measure): - """Applies measure to RiskPeriod, returns a new object""" - snapshot0 = self.snapshot0.apply_measure(measure) - snapshot1 = self.snapshot1.apply_measure(measure) - return RiskPeriod(snapshot0, snapshot1, measure_name=measure.name) + def interpolate_sm(mat_start, mat_end, time, time_points): + """Perform linear interpolation between two matrices for a specified time point.""" + if time > time_points: + raise ValueError("time point must be within the range") - @classmethod - def calc_residual_or_risk_transf_imp_mat( - cls, imp_mat, attachment=None, cover=None, calc_residual=True + ratio = time / (time_points - 1) + + # Convert the input matrices to a format that allows efficient modification of its elements + mat_start = lil_matrix(mat_start) + mat_end = lil_matrix(mat_end) + + # Perform the linear interpolation + mat_interpolated = mat_start + ratio * (mat_end - mat_start) + + return mat_interpolated + + LOGGER.debug(f"imp0: {imp0.imp_mat.data[0]}, imp1: {imp1.imp_mat.data[0]}") + return [ + interpolate_sm(imp0.imp_mat, imp1.imp_mat, time, time_points) + for time in range(time_points) + ] + + +class ImpactComputationStrategy(ABC): + """Interface for impact computation strategies.""" + + @abstractmethod + def compute_impacts( + self, + snapshot0, + snapshot1, + risk_transf_attach: float | None, + risk_transf_cover: float | None, + calc_residual: bool, + ) -> tuple: + pass + + +class ImpactCalcComputation(ImpactComputationStrategy): + """Default impact computation strategy.""" + + def compute_impacts( + self, + snapshot0, + snapshot1, + risk_transf_attach: float | None, + risk_transf_cover: float | None, + calc_residual: bool = False, + ): + impacts = self._calculate_impacts_for_snapshots(snapshot0, snapshot1) + self._apply_risk_transfer( + impacts, risk_transf_attach, risk_transf_cover, calc_residual + ) + return impacts + + def _calculate_impacts_for_snapshots(self, snapshot0, snapshot1): + """Calculate impacts for the given snapshots and impact function set.""" + imp_E0H0 = ImpactCalc( + snapshot0.exposure, snapshot0.impfset, snapshot0.hazard + ).impact() + imp_E1H0 = ImpactCalc( + snapshot1.exposure, snapshot1.impfset, snapshot0.hazard + ).impact() + imp_E0H1 = ImpactCalc( + snapshot0.exposure, snapshot0.impfset, snapshot1.hazard + ).impact() + imp_E1H1 = ImpactCalc( + snapshot1.exposure, snapshot1.impfset, snapshot1.hazard + ).impact() + return imp_E0H0, imp_E1H0, imp_E0H1, imp_E1H1 + + def _apply_risk_transfer( + self, + impacts, + risk_transf_attach: float | None, + risk_transf_cover: float | None, + calc_residual: bool, + ): + """Apply risk transfer to the calculated impacts.""" + if risk_transf_attach is not None and risk_transf_cover is not None: + for imp in impacts: + imp.imp_mat = self.calculate_residual_or_risk_transfer_impact_matrix( + imp.imp_mat, risk_transf_attach, risk_transf_cover, calc_residual + ) + + def calculate_residual_or_risk_transfer_impact_matrix( + self, imp_mat, risk_transf_attach, risk_transf_cover, calc_residual ): """ Calculate either the residual or the risk transfer impact matrix. @@ -197,14 +205,14 @@ def calc_residual_or_risk_transf_imp_mat( >>> calc_residual_or_risk_transf_imp_mat(imp_mat, attachment=100, cover=500, calc_residual=True) Residual impact matrix with applied risk layer adjustments. """ - if attachment and cover: + if risk_transf_attach and risk_transf_cover: # Make a copy of the impact matrix imp_mat = copy.deepcopy(imp_mat) # Calculate the total impact per event total_at_event = imp_mat.sum(axis=1).A1 # Risk layer at event transfer_at_event = np.minimum( - np.maximum(total_at_event - attachment, 0), cover + np.maximum(total_at_event - risk_transf_attach, 0), risk_transf_cover ) # Resiudal impact residual_at_event = np.maximum(total_at_event - transfer_at_event, 0) @@ -236,43 +244,300 @@ def calc_residual_or_risk_transf_imp_mat( return imp_mat -def interpolate_imp_mat(imp0, imp1, time_points): - """ - Interpolate between two impact matrices over a specified time range. +class CalcRiskPeriod: + """Handles the computation of impacts for a risk period.""" - Parameters - ---------- - imp0 : ImpactCalc - The impact calculation for the starting time. - imp1 : ImpactCalc - The impact calculation for the ending time. - time_points: - The number of points to interpolate. + def __init__( + self, + snapshot0, + snapshot1, + interval_freq: str | None = "YS", + time_points: int | None = None, + interpolation_strategy: InterpolationStrategy | None = None, + impact_computation_strategy: ImpactComputationStrategy | None = None, + risk_transf_attach: float | None = None, + risk_transf_cover: float | None = None, + calc_residual: bool = False, + measure: Measure | None = None, + ): + self.snapshot0 = snapshot0 + self.snapshot1 = snapshot1 + self.date_idx = pd.date_range( + snapshot0.date, + snapshot1.date, + periods=time_points, + freq=interval_freq, + name="date", + ) + self.time_points = len(self.date_idx) + self.interval_freq = self.date_idx.inferred_freq + self.measure = measure + self._prop_H1 = np.linspace(0, 1, num=self.time_points) + self._prop_H0 = 1 - self._prop_H1 + self.interpolation_strategy = interpolation_strategy or LinearInterpolation() + self.impact_computation_strategy = ( + impact_computation_strategy or ImpactCalcComputation() + ) + self._E0H0, self._E1H0, self._E0H1, self._E1H1 = ( + self.impact_computation_strategy.compute_impacts( + snapshot0, + snapshot1, + risk_transf_attach, + risk_transf_cover, + calc_residual, + ) + ) + self._imp_mats_H0, self._imp_mats_H1 = None, None + self._imp_mats_E0, self._imp_mats_E1 = None, None + self._per_date_eai_H0, self._per_date_eai_H1 = None, None + self._per_date_aai_H0, self._per_date_aai_H1 = None, None + self._per_date_return_periods_H0, self._per_date_return_periods_H1 = None, None + self._group_id_E0 = self.snapshot0.exposure.gdf["group_id"].values + self._group_id_E1 = self.snapshot1.exposure.gdf["group_id"].values + + @lazy_property + def imp_mats_H0(self): + return self.interpolation_strategy.interpolate( + self._E0H0, self._E1H0, self.time_points + ) - Returns - ------- - list of np.ndarray - List of interpolated impact matrices for each time points in the specified range. - """ + @lazy_property + def imp_mats_H1(self): + return self.interpolation_strategy.interpolate( + self._E0H1, self._E1H1, self.time_points + ) - def interpolate_sm(mat_start, mat_end, time, time_points): - """Perform linear interpolation between two matrices for a specified time point.""" - if time > time_points: - raise ValueError("time point must be within the range") + @lazy_property + def imp_mats_E0(self): + return self.interpolation_strategy.interpolate( + self._E0H0, self._E0H1, self.time_points + ) - ratio = time / (time_points - 1) + @lazy_property + def imp_mats_E1(self): + return self.interpolation_strategy.interpolate( + self._E1H0, self._E1H1, self.time_points + ) + + @lazy_property + def per_date_eai_H0(self): + return self.calc_per_date_eais( + self.imp_mats_H0, self.snapshot0.hazard.frequency + ) + + @lazy_property + def per_date_eai_H1(self): + return self.calc_per_date_eais( + self.imp_mats_H1, self.snapshot1.hazard.frequency + ) + + @lazy_property + def per_date_aai_H0(self): + return self.calc_per_date_aais(self.per_date_eai_H0) + + @lazy_property + def per_date_aai_H1(self): + return self.calc_per_date_aais(self.per_date_eai_H1) + + def per_date_return_periods_H0(self, return_periods) -> np.ndarray: + return self.calc_per_date_rps( + self.imp_mats_H0, self.snapshot0.hazard.frequency, return_periods + ) + + def per_date_return_periods_H1(self, return_periods) -> np.ndarray: + return self.calc_per_date_rps( + self.imp_mats_H1, self.snapshot1.hazard.frequency, return_periods + ) + + @classmethod + def calc_per_date_eais(cls, imp_mats, frequency) -> np.ndarray: + """ + Calculate per_date expected annual impact (EAI) values for two scenarios. + + Parameters + ---------- + imp_mats_0 : list of np.ndarray + List of interpolated impact matrices for scenario 0. + imp_mats_1 : list of np.ndarray + List of interpolated impact matrices for scenario 1. + frequency_0 : np.ndarray + Frequency values associated with scenario 0. + frequency_1 : np.ndarray + Frequency values associated with scenario 1. + + Returns + ------- + tuple + Tuple containing: + - per_date_eai_exp_0 : list of float + per date expected annual impacts for scenario 0. + - per_date_eai_exp_1 : list of float + per date expected annual impacts for scenario 1. + """ + per_date_eai_exp = np.array( + [ImpactCalc.eai_exp_from_mat(imp_mat, frequency) for imp_mat in imp_mats] + ) + return per_date_eai_exp + + @staticmethod + def calc_per_date_aais(per_date_eai_exp) -> np.ndarray: + """ + Calculate per_date aggregate annual impact (AAI) values for two scenarios. + + Parameters + ---------- + per_date_eai_exp_0 : list of float + Per_Date expected annual impacts for scenario 0. + per_date_eai_exp_1 : list of float + Per_Date expected annual impacts for scenario 1. + + Returns + ------- + tuple + Tuple containing: + - per_date_aai_0 : list of float + Aggregate annual impact values for scenario 0. + - per_date_aai_1 : list of float + Aggregate annual impact values for scenario 1. + """ + per_date_aai = np.array( + [ImpactCalc.aai_agg_from_eai_exp(eai_exp) for eai_exp in per_date_eai_exp] + ) + return per_date_aai + + @classmethod + def calc_per_date_rps(cls, imp_mats, frequency, return_periods) -> np.ndarray: + """ + Calculate per_date return period impact values for two scenarios. + + Parameters + ---------- + imp_mats_0 : list of np.ndarray + List of interpolated impact matrices for scenario 0. + imp_mats_1 : list of np.ndarray + List of interpolated impact matrices for scenario 1. + frequency_0 : np.ndarray + Frequency values for scenario 0. + frequency_1 : np.ndarray + Frequency values for scenario 1. + return_periods : list of int + Return periods to calculate impact values for. - # Convert the input matrices to a format that allows efficient modification of its elements - mat_start = lil_matrix(mat_start) - mat_end = lil_matrix(mat_end) + Returns + ------- + tuple + Tuple containing: + - rp_0 : list of np.ndarray + Per_Date return period impact values for scenario 0. + - rp_1 : list of np.ndarray + Per_Date return period impact values for scenario 1. + """ + rp = np.array( + [ + cls.calc_freq_curve(imp_mat, frequency, return_periods) + for imp_mat in imp_mats + ] + ) + return rp - # Perform the linear interpolation - mat_interpolated = mat_start + ratio * (mat_end - mat_start) + @classmethod + def calc_freq_curve(cls, imp_mat_intrpl, frequency, return_per=None) -> np.ndarray: + """ + Calculate the frequency curve - return mat_interpolated + Parameters: + imp_mat_intrpl (np.array): The interpolated impact matrix + frequency (np.array): The frequency of the hazard + return_per (np.array): The return period - LOGGER.debug(f"imp0: {imp0.imp_mat.data[0]}, imp1: {imp1.imp_mat.data[0]}") - return [ - interpolate_sm(imp0.imp_mat, imp1.imp_mat, time, time_points) - for time in range(time_points) - ] + Returns: + ifc_return_per (np.array): The impact exceeding frequency + ifc_impact (np.array): The impact exceeding the return period + """ + + # Calculate the at_event make the np.array + 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 ifc_impact + + def calc_aai_metric(self): + per_date_aai_H0, per_date_aai_H1 = self.per_date_aai_H0, self.per_date_aai_H1 + per_date_aai = self._prop_H0 * per_date_aai_H0 + self._prop_H1 * per_date_aai_H1 + aai_df = pd.DataFrame(index=self.date_idx, columns=["risk"], data=per_date_aai) + aai_df["group"] = pd.NA + aai_df["metric"] = "aai" + aai_df["measure"] = self.measure.name if self.measure else "no_measure" + aai_df.reset_index(inplace=True) + return aai_df + + def calc_aai_per_group_metric(self): + aai_per_group_df = [] + for group in np.unique(np.concatenate(self._group_id_E0, self._group_id_E1)): + group_idx_E0 = np.where(self._group_id_E0 != group) + group_idx_E1 = np.where(self._group_id_E1 != group) + per_date_aai_H0, per_date_aai_H1 = ( + self.per_date_eai_H0[group_idx_E0].sum(), + self.per_date_eai_H1[group_idx_E1].sum(), + ) + per_date_aai = ( + self._prop_H0 * per_date_aai_H0 + self._prop_H1 * per_date_aai_H1 + ) + df = pd.DataFrame(index=self.date_idx, columns=["risk"], data=per_date_aai) + df["group"] = pd.NA + aai_per_group_df += df + + return pd.concat(aai_per_group_df) + + def calc_return_periods_metric(self, return_periods): + rp_0, rp_1 = self.per_date_return_periods_H0( + return_periods + ), self.per_date_return_periods_H1(return_periods) + per_date_rp = np.multiply(self._prop_H0.reshape(-1, 1), rp_0) + np.multiply( + self._prop_H1.reshape(-1, 1), rp_1 + ) + rp_df = pd.DataFrame( + index=self.date_idx, columns=return_periods, data=per_date_rp + ).melt(value_name="risk", var_name="rp", ignore_index=False) + rp_df.reset_index(inplace=True) + rp_df["group"] = pd.NA + rp_df["metric"] = "rp_" + rp_df["rp"].astype(str) + rp_df["measure"] = self.measure.name if self.measure else "no_measure" + return rp_df + + def calc_risk_components_metric(self): + per_date_aai_H0, per_date_aai_H1 = self.per_date_aai_H0, self.per_date_aai_H1 + per_date_aai = self._prop_H0 * per_date_aai_H0 + self._prop_H1 * per_date_aai_H1 + + risk_dev_0 = per_date_aai_H0 - per_date_aai[0] + risk_cc_0 = per_date_aai - (risk_dev_0 + per_date_aai[0]) + df = pd.DataFrame( + { + "base risk": per_date_aai - (risk_dev_0 + risk_cc_0), + "delta from exposure": risk_dev_0, + "delta from hazard": risk_cc_0, + }, + index=self.date_idx, + ) + df = df.melt( + value_vars=["base risk", "delta from exposure", "delta from hazard"], + var_name="metric", + value_name="risk", + ignore_index=False, + ) + df.reset_index(inplace=True) + df["group"] = pd.NA + df["measure"] = self.measure.name if self.measure else "no_measure" + return df From 4ea685d11f7e223aff80f6dcff7b3add795f64e7 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 15 Apr 2025 19:30:19 +0200 Subject: [PATCH 011/113] fixes some bugs --- climada/trajectories/risk_trajectory.py | 20 +-- climada/trajectories/riskperiod.py | 18 +- doc/tutorial/climada_trajectories.ipynb | 224 +++++++++++++++--------- 3 files changed, 156 insertions(+), 106 deletions(-) diff --git a/climada/trajectories/risk_trajectory.py b/climada/trajectories/risk_trajectory.py index 616143ae6..92fc7cb58 100644 --- a/climada/trajectories/risk_trajectory.py +++ b/climada/trajectories/risk_trajectory.py @@ -282,21 +282,13 @@ def risk_components_metrics(self, npv=True): def all_risk_metrics(self, return_periods=[50, 100, 500], npv=True): if not self._metrics_up_to_date: - aai = self.aai_metrics + aai = self.aai_metrics() rp = self.return_periods_metrics(return_periods) - aai_per_group = self.aai_per_group_metrics - risk_components = self.risk_components_metrics - tmp = pd.concat([aai, rp, aai_per_group, risk_components]) - columns_to_front = ["group", "date", "measure", "metric"] - self._all_risk_metrics = tmp[ - columns_to_front - + [ - col - for col in tmp.columns - if col not in columns_to_front + ["group", "risk", "rp"] - ] - + ["risk"] - ] + aai_per_group = self.aai_per_group_metrics() + risk_components = self.risk_components_metrics() + self._all_risk_metrics = pd.concat( + [aai, rp, aai_per_group, risk_components] + ) self._metrics_up_to_date = True return self._all_risk_metrics diff --git a/climada/trajectories/riskperiod.py b/climada/trajectories/riskperiod.py index de27df24e..24c80816a 100644 --- a/climada/trajectories/riskperiod.py +++ b/climada/trajectories/riskperiod.py @@ -485,21 +485,27 @@ def calc_aai_metric(self): def calc_aai_per_group_metric(self): aai_per_group_df = [] - for group in np.unique(np.concatenate(self._group_id_E0, self._group_id_E1)): + for group in np.unique(np.concatenate([self._group_id_E0, self._group_id_E1])): group_idx_E0 = np.where(self._group_id_E0 != group) group_idx_E1 = np.where(self._group_id_E1 != group) per_date_aai_H0, per_date_aai_H1 = ( - self.per_date_eai_H0[group_idx_E0].sum(), - self.per_date_eai_H1[group_idx_E1].sum(), + self.per_date_eai_H0[:, group_idx_E0].sum(), + self.per_date_eai_H1[:, group_idx_E1].sum(), ) per_date_aai = ( self._prop_H0 * per_date_aai_H0 + self._prop_H1 * per_date_aai_H1 ) df = pd.DataFrame(index=self.date_idx, columns=["risk"], data=per_date_aai) - df["group"] = pd.NA - aai_per_group_df += df + df["group"] = group + aai_per_group_df.append(df) - return pd.concat(aai_per_group_df) + aai_per_group_df = pd.concat(aai_per_group_df) + aai_per_group_df["metric"] = "aai" + aai_per_group_df["measure"] = ( + self.measure.name if self.measure else "no_measure" + ) + aai_per_group_df.reset_index(inplace=True) + return aai_per_group_df def calc_return_periods_metric(self, return_periods): rp_0, rp_1 = self.per_date_return_periods_H0( diff --git a/doc/tutorial/climada_trajectories.ipynb b/doc/tutorial/climada_trajectories.ipynb index 1ed27c292..12e2158d5 100644 --- a/doc/tutorial/climada_trajectories.ipynb +++ b/doc/tutorial/climada_trajectories.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "a5245bdb-fc31-4cb9-912f-560d23231622", + "id": "a147d925-bedb-45a1-a56e-589bd351a4e6", "metadata": {}, "source": [ "Currently, to run this tutorial, from within a climada_python git repo please run:\n", @@ -65,7 +65,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "id": "dec203d1-943f-41d8-9542-009f288b937b", "metadata": {}, "outputs": [ @@ -108,7 +108,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "aa0becca-d334-40b4-86c0-1959c750f6d5", "metadata": { "scrolled": true @@ -120,7 +120,7 @@ "" ] }, - "execution_count": 3, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" }, @@ -175,7 +175,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "c516c861-c5c1-475b-82e2-c867c5c08ec9", "metadata": {}, "outputs": [], @@ -203,47 +203,34 @@ "exp_future.assign_centroids(haz_future, distance=\"approx\")\n", "impf_set = ImpactFuncSet(\n", " [\n", - " ImpfTropCyclone.from_emanuel_usa(),\n", - " ImpfTropCyclone.from_emanuel_usa(impf_id=2, v_half=60.0),\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\"] = 2" - ] - }, - { - "cell_type": "markdown", - "id": "05009191-8a5f-4b38-a282-6c433924d4be", - "metadata": {}, - "source": [ - "The set of impact functions `impf_set` has to be common for the different snapshot, with one impact function for the present (id=1) and one for the future (id=2).\n", - "\n", - "Note that, the `RiskTrajectory` object will detect different `ImpactFunSet` objects and merge them together, while warning the user. In case of conflicting functions, this merge will retain the impact functions from the Snapshot with the latest date." + "exp_future.gdf[\"impf_TC\"] = 1" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "3b909d67-9e89-4a50-905c-de616c9d5a0a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([,\n", - " ],\n", - " dtype=object)" + "" ] }, - "execution_count": 5, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -256,7 +243,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "a9dd7b63-c577-4b60-87f8-bc2b8782c100", "metadata": {}, "outputs": [], @@ -274,7 +261,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "4ffe490d-8488-4005-9442-deb642e19985", "metadata": {}, "outputs": [], @@ -298,18 +285,10 @@ }, { "cell_type": "code", - "execution_count": 45, - "id": "ff177685-bf41-49c9-8b86-043855862d0d", + "execution_count": 7, + "id": "c644d470-7fd3-461e-97fd-d23d40f7abd9", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Impact function sets differ. Will update the first one with the second.\n" - ] - } - ], + "outputs": [], "source": [ "from climada.trajectories.risk_trajectory import RiskTrajectory\n", "\n", @@ -331,7 +310,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 8, "id": "866db75c-5b21-4134-9f4e-f7213ad49f18", "metadata": {}, "outputs": [ @@ -357,6 +336,7 @@ " \n", " \n", " period\n", + " group\n", " measure\n", " metric\n", " risk\n", @@ -366,27 +346,71 @@ " \n", " 0\n", " 2018-01-01 to 2040-01-01\n", + " 0\n", " no_measure\n", " aai\n", - " 9.960186e+09\n", + " 2.268384e+11\n", " \n", " \n", " 1\n", " 2018-01-01 to 2040-01-01\n", + " 1\n", " no_measure\n", - " rp_100\n", - " 3.288826e+11\n", + " aai\n", + " 3.391447e+08\n", " \n", " \n", " 2\n", " 2018-01-01 to 2040-01-01\n", + " All\n", " no_measure\n", - " rp_1000\n", - " 8.369369e+11\n", + " aai\n", + " 9.960186e+09\n", " \n", " \n", " 3\n", " 2018-01-01 to 2040-01-01\n", + " All\n", + " no_measure\n", + " base risk\n", + " 4.232995e+09\n", + " \n", + " \n", + " 4\n", + " 2018-01-01 to 2040-01-01\n", + " All\n", + " no_measure\n", + " delta from exposure\n", + " 5.186536e+09\n", + " \n", + " \n", + " 5\n", + " 2018-01-01 to 2040-01-01\n", + " All\n", + " no_measure\n", + " delta from hazard\n", + " 5.406561e+08\n", + " \n", + " \n", + " 6\n", + " 2018-01-01 to 2040-01-01\n", + " All\n", + " no_measure\n", + " rp_100\n", + " 3.288826e+11\n", + " \n", + " \n", + " 7\n", + " 2018-01-01 to 2040-01-01\n", + " All\n", + " no_measure\n", + " rp_50\n", + " 1.886460e+11\n", + " \n", + " \n", + " 8\n", + " 2018-01-01 to 2040-01-01\n", + " All\n", " no_measure\n", " rp_500\n", " 8.369369e+11\n", @@ -396,14 +420,30 @@ "" ], "text/plain": [ - " period measure metric risk\n", - "0 2018-01-01 to 2040-01-01 no_measure aai 9.960186e+09\n", - "1 2018-01-01 to 2040-01-01 no_measure rp_100 3.288826e+11\n", - "2 2018-01-01 to 2040-01-01 no_measure rp_1000 8.369369e+11\n", - "3 2018-01-01 to 2040-01-01 no_measure rp_500 8.369369e+11" + " period group measure metric \\\n", + "0 2018-01-01 to 2040-01-01 0 no_measure aai \n", + "1 2018-01-01 to 2040-01-01 1 no_measure aai \n", + "2 2018-01-01 to 2040-01-01 All no_measure aai \n", + "3 2018-01-01 to 2040-01-01 All no_measure base risk \n", + "4 2018-01-01 to 2040-01-01 All no_measure delta from exposure \n", + "5 2018-01-01 to 2040-01-01 All no_measure delta from hazard \n", + "6 2018-01-01 to 2040-01-01 All no_measure rp_100 \n", + "7 2018-01-01 to 2040-01-01 All no_measure rp_50 \n", + "8 2018-01-01 to 2040-01-01 All no_measure rp_500 \n", + "\n", + " risk \n", + "0 2.268384e+11 \n", + "1 3.391447e+08 \n", + "2 9.960186e+09 \n", + "3 4.232995e+09 \n", + "4 5.186536e+09 \n", + "5 5.406561e+08 \n", + "6 3.288826e+11 \n", + "7 1.886460e+11 \n", + "8 8.369369e+11 " ] }, - "execution_count": 15, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -422,7 +462,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 9, "id": "67efba39-11b6-40fc-b5dd-a8799ec00c12", "metadata": {}, "outputs": [ @@ -448,6 +488,7 @@ " \n", " \n", " date\n", + " group\n", " measure\n", " metric\n", " risk\n", @@ -457,6 +498,7 @@ " \n", " 0\n", " 2018-01-01\n", + " All\n", " no_measure\n", " aai\n", " 1.840432e+08\n", @@ -464,6 +506,7 @@ " \n", " 1\n", " 2019-01-01\n", + " All\n", " no_measure\n", " aai\n", " 2.055335e+08\n", @@ -471,6 +514,7 @@ " \n", " 2\n", " 2020-01-01\n", + " All\n", " no_measure\n", " aai\n", " 2.271876e+08\n", @@ -478,6 +522,7 @@ " \n", " 3\n", " 2021-01-01\n", + " All\n", " no_measure\n", " aai\n", " 2.490056e+08\n", @@ -485,6 +530,7 @@ " \n", " 4\n", " 2022-01-01\n", + " All\n", " no_measure\n", " aai\n", " 2.709873e+08\n", @@ -495,65 +541,71 @@ " ...\n", " ...\n", " ...\n", + " ...\n", " \n", " \n", - " 87\n", + " 64\n", " 2036-01-01\n", + " All\n", " no_measure\n", - " rp_1000\n", - " 4.734810e+10\n", + " delta from hazard\n", + " 4.288923e+07\n", " \n", " \n", - " 88\n", + " 65\n", " 2037-01-01\n", + " All\n", " no_measure\n", - " rp_1000\n", - " 4.893501e+10\n", + " delta from hazard\n", + " 4.682841e+07\n", " \n", " \n", - " 89\n", + " 66\n", " 2038-01-01\n", + " All\n", " no_measure\n", - " rp_1000\n", - " 5.052490e+10\n", + " delta from hazard\n", + " 5.093143e+07\n", " \n", " \n", - " 90\n", + " 67\n", " 2039-01-01\n", + " All\n", " no_measure\n", - " rp_1000\n", - " 5.211776e+10\n", + " delta from hazard\n", + " 5.519828e+07\n", " \n", " \n", - " 91\n", + " 68\n", " 2040-01-01\n", + " All\n", " no_measure\n", - " rp_1000\n", - " 5.371361e+10\n", + " delta from hazard\n", + " 5.962897e+07\n", " \n", " \n", "\n", - "

92 rows × 4 columns

\n", + "

207 rows × 5 columns

\n", "" ], "text/plain": [ - " date measure metric risk\n", - "0 2018-01-01 no_measure aai 1.840432e+08\n", - "1 2019-01-01 no_measure aai 2.055335e+08\n", - "2 2020-01-01 no_measure aai 2.271876e+08\n", - "3 2021-01-01 no_measure aai 2.490056e+08\n", - "4 2022-01-01 no_measure aai 2.709873e+08\n", - ".. ... ... ... ...\n", - "87 2036-01-01 no_measure rp_1000 4.734810e+10\n", - "88 2037-01-01 no_measure rp_1000 4.893501e+10\n", - "89 2038-01-01 no_measure rp_1000 5.052490e+10\n", - "90 2039-01-01 no_measure rp_1000 5.211776e+10\n", - "91 2040-01-01 no_measure rp_1000 5.371361e+10\n", + " date group measure metric risk\n", + "0 2018-01-01 All no_measure aai 1.840432e+08\n", + "1 2019-01-01 All no_measure aai 2.055335e+08\n", + "2 2020-01-01 All no_measure aai 2.271876e+08\n", + "3 2021-01-01 All no_measure aai 2.490056e+08\n", + "4 2022-01-01 All no_measure aai 2.709873e+08\n", + ".. ... ... ... ... ...\n", + "64 2036-01-01 All no_measure delta from hazard 4.288923e+07\n", + "65 2037-01-01 All no_measure delta from hazard 4.682841e+07\n", + "66 2038-01-01 All no_measure delta from hazard 5.093143e+07\n", + "67 2039-01-01 All no_measure delta from hazard 5.519828e+07\n", + "68 2040-01-01 All no_measure delta from hazard 5.962897e+07\n", "\n", - "[92 rows x 4 columns]" + "[207 rows x 5 columns]" ] }, - "execution_count": 18, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -572,7 +624,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 10, "id": "08c226a4-944b-4301-acfa-602adde980a5", "metadata": {}, "outputs": [ @@ -582,7 +634,7 @@ "" ] }, - "execution_count": 19, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, @@ -611,7 +663,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 11, "id": "cf40380a-5814-4164-a592-7ab181776b5a", "metadata": {}, "outputs": [ @@ -621,13 +673,13 @@ "" ] }, - "execution_count": 20, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From 0d6335b7a2fd91e3104753034350af2c8da7d6b5 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Wed, 16 Apr 2025 10:57:36 +0200 Subject: [PATCH 012/113] fixses some linter issues --- climada/trajectories/risk_trajectory.py | 16 +- climada/trajectories/riskperiod.py | 29 +-- climada/trajectories/snapshot.py | 1 - climada/trajectories/timeseries.py | 236 ++++++++++++------------ 4 files changed, 146 insertions(+), 136 deletions(-) diff --git a/climada/trajectories/risk_trajectory.py b/climada/trajectories/risk_trajectory.py index 92fc7cb58..3838c1c5c 100644 --- a/climada/trajectories/risk_trajectory.py +++ b/climada/trajectories/risk_trajectory.py @@ -156,7 +156,7 @@ def risk_periods(self) -> list: return self._risk_periods_calculators - def _calc_risk_periods(self, snapshots): + def _calc_risk_periods(self, snapshots: list[Snapshot]) -> list[CalcRiskPeriod]: def pairwise(container: list): """ Generate pairs of successive elements from an iterable. @@ -280,8 +280,10 @@ def risk_components_metrics(self, npv=True): metric_meth="calc_risk_components_metric", ) - def all_risk_metrics(self, return_periods=[50, 100, 500], npv=True): - if not self._metrics_up_to_date: + def all_risk_metrics( + self, return_periods=[50, 100, 500], npv=True + ) -> pd.DataFrame | pd.Series: + if not self._metrics_up_to_date or self._all_risk_metrics is None: aai = self.aai_metrics() rp = self.return_periods_metrics(return_periods) aai_per_group = self.aai_per_group_metrics() @@ -304,7 +306,9 @@ def _get_risk_periods( ] @classmethod - def _per_period_risk(cls, df: pd.DataFrame, time_unit="year", colname="risk"): + def _per_period_risk( + cls, df: pd.DataFrame, time_unit="year", colname="risk" + ) -> pd.DataFrame | pd.Series: def identify_continuous_periods(group, time_unit): # Calculate the difference between consecutive dates if time_unit == "year": @@ -357,11 +361,11 @@ def per_date_risk_metrics(self) -> pd.DataFrame | pd.Series: return self._prepare_risk_metrics(total=False, npv=True) @property - def total_risk_metrics(self): + def total_risk_metrics(self) -> pd.DataFrame | pd.Series: """Returns a tidy dataframe of the risk metrics with the total for each different period.""" return self._prepare_risk_metrics(total=True, npv=True) - def _prepare_risk_metrics(self, total=False, npv=True): + def _prepare_risk_metrics(self, total=False, npv=True) -> pd.DataFrame | pd.Series: df = self.all_risk_metrics(npv=npv) if total: return self._per_period_risk(df) diff --git a/climada/trajectories/riskperiod.py b/climada/trajectories/riskperiod.py index 24c80816a..d22096e84 100644 --- a/climada/trajectories/riskperiod.py +++ b/climada/trajectories/riskperiod.py @@ -28,6 +28,7 @@ import pandas as pd from scipy.sparse import lil_matrix +from climada.engine.impact import Impact from climada.engine.impact_calc import ImpactCalc from climada.entity.measures.base import Measure from climada.trajectories.snapshot import Snapshot @@ -65,6 +66,8 @@ def interpolate(self, imp_E0, imp_E1, time_points: int): raise ValueError( "Interpolation between impact matrices of different shapes" ) + else: + raise e @staticmethod def interpolate_imp_mat(imp0, imp1, time_points): @@ -114,8 +117,8 @@ class ImpactComputationStrategy(ABC): @abstractmethod def compute_impacts( self, - snapshot0, - snapshot1, + snapshot0: Snapshot, + snapshot1: Snapshot, risk_transf_attach: float | None, risk_transf_cover: float | None, calc_residual: bool, @@ -128,8 +131,8 @@ class ImpactCalcComputation(ImpactComputationStrategy): def compute_impacts( self, - snapshot0, - snapshot1, + snapshot0: Snapshot, + snapshot1: Snapshot, risk_transf_attach: float | None, risk_transf_cover: float | None, calc_residual: bool = False, @@ -140,7 +143,9 @@ def compute_impacts( ) return impacts - def _calculate_impacts_for_snapshots(self, snapshot0, snapshot1): + def _calculate_impacts_for_snapshots( + self, snapshot0: Snapshot, snapshot1: Snapshot + ): """Calculate impacts for the given snapshots and impact function set.""" imp_E0H0 = ImpactCalc( snapshot0.exposure, snapshot0.impfset, snapshot0.hazard @@ -158,7 +163,7 @@ def _calculate_impacts_for_snapshots(self, snapshot0, snapshot1): def _apply_risk_transfer( self, - impacts, + impacts: tuple[Impact, Impact, Impact, Impact], risk_transf_attach: float | None, risk_transf_cover: float | None, calc_residual: bool, @@ -249,8 +254,8 @@ class CalcRiskPeriod: def __init__( self, - snapshot0, - snapshot1, + snapshot0: Snapshot, + snapshot1: Snapshot, interval_freq: str | None = "YS", time_points: int | None = None, interpolation_strategy: InterpolationStrategy | None = None, @@ -266,11 +271,11 @@ def __init__( snapshot0.date, snapshot1.date, periods=time_points, - freq=interval_freq, + freq=interval_freq, # type: ignore name="date", ) self.time_points = len(self.date_idx) - self.interval_freq = self.date_idx.inferred_freq + self.interval_freq = pd.infer_freq(self.date_idx) self.measure = measure self._prop_H1 = np.linspace(0, 1, num=self.time_points) self._prop_H0 = 1 - self._prop_H1 @@ -485,7 +490,9 @@ def calc_aai_metric(self): def calc_aai_per_group_metric(self): aai_per_group_df = [] - for group in np.unique(np.concatenate([self._group_id_E0, self._group_id_E1])): + for group in np.unique( + np.concatenate(np.array([self._group_id_E0, self._group_id_E1]), axis=0) + ): group_idx_E0 = np.where(self._group_id_E0 != group) group_idx_E1 = np.where(self._group_id_E1 != group) per_date_aai_H0, per_date_aai_H1 = ( diff --git a/climada/trajectories/snapshot.py b/climada/trajectories/snapshot.py index 3abedf3d8..617cdb6aa 100644 --- a/climada/trajectories/snapshot.py +++ b/climada/trajectories/snapshot.py @@ -22,7 +22,6 @@ import copy import datetime -import itertools import logging from climada.entity.exposures import Exposures diff --git a/climada/trajectories/timeseries.py b/climada/trajectories/timeseries.py index c81c885f4..934c51d02 100644 --- a/climada/trajectories/timeseries.py +++ b/climada/trajectories/timeseries.py @@ -18,121 +18,121 @@ """ -import copy -from datetime import datetime - -import numpy as np - -from climada.hazard.base import Hazard - - -def get_dates(haz: Hazard): - """ - Convert ordinal dates from a Hazard object to datetime objects. - - Parameters - ---------- - haz : Hazard - A Hazard instance with ordinal date values. - - Returns - ------- - list of datetime - List of datetime objects corresponding to the ordinal dates in `haz`. - - Example - ------- - >>> haz = Hazard(...) - >>> get_dates(haz) - [datetime(2020, 1, 1), datetime(2020, 1, 2), ...] - """ - return [datetime.fromordinal(date) for date in haz.date] - - -def get_years(haz: Hazard): - """ - Extract unique years from ordinal dates in a Hazard object. - - Parameters - ---------- - haz : Hazard - A Hazard instance containing ordinal date values. - - Returns - ------- - np.ndarray - Array of unique years as integers, derived from the ordinal dates in `haz`. - - Example - ------- - >>> haz = Hazard(...) - >>> get_years(haz) - array([2020, 2021, ...]) - """ - return np.unique(np.array([datetime.fromordinal(date).year for date in haz.date])) - - -def grow_exp(exp, exp_growth_rate, elapsed): - """ - Apply exponential growth to the exposure values over a specified period. - - Parameters - ---------- - exp : Exposures - The initial Exposures object with values to be grown. - exp_growth_rate : float - The annual growth rate to apply (in decimal form, e.g., 0.01 for 1%). - elapsed : int - Number of years over which to apply the growth. - - Returns - ------- - Exposures - A deep copy of the original Exposures object with grown exposure values. - - Example - ------- - >>> exp = Exposures(...) - >>> grow_exp(exp, 0.01, 5) - Exposures object with values grown by 5%. - """ - exp_grown = copy.deepcopy(exp) - # Exponential growth - exp_growth_rate = 0.01 - exp_grown.gdf.value = exp_grown.gdf.value * (1 + exp_growth_rate) ** elapsed - return exp_grown - - -class TBRTrajectories: - - # Compute impacts for trajectories with present exposure and future exposure and interpolate in between - # - - @classmethod - def create_hazard_yearly_set(cls, haz: Hazard): - haz_set = {} - years = get_years(haz) - for year in range(years.min(), years.max(), 1): - haz_set[year] = haz.select( - date=[f"{str(year)}-01-01", f"{str(year+1)}-01-01"] - ) - - return haz_set - - @classmethod - def create_exposure_set(cls, snapshot_years, exp1, exp2=None, growth=None): - exp_set = {} - year_0 = snapshot_years.min() - if exp2 is None: - if growth is None: - raise ValueError("Need to specify either final exposure or growth.") - else: - exp_set = { - year: grow_exp(exp1, growth, year - year_0) - for year in snapshot_years - } - else: - exp_set = { - year: np.interp(exp1, exp2, year - year_0) for year in snapshot_years - } - return exp_set +# import copy +# from datetime import datetime + +# import numpy as np + +# from climada.hazard.base import Hazard + + +# def get_dates(haz: Hazard): +# """ +# Convert ordinal dates from a Hazard object to datetime objects. + +# Parameters +# ---------- +# haz : Hazard +# A Hazard instance with ordinal date values. + +# Returns +# ------- +# list of datetime +# List of datetime objects corresponding to the ordinal dates in `haz`. + +# Example +# ------- +# >>> haz = Hazard(...) +# >>> get_dates(haz) +# [datetime(2020, 1, 1), datetime(2020, 1, 2), ...] +# """ +# return [datetime.fromordinal(date) for date in haz.date] + + +# def get_years(haz: Hazard): +# """ +# Extract unique years from ordinal dates in a Hazard object. + +# Parameters +# ---------- +# haz : Hazard +# A Hazard instance containing ordinal date values. + +# Returns +# ------- +# np.ndarray +# Array of unique years as integers, derived from the ordinal dates in `haz`. + +# Example +# ------- +# >>> haz = Hazard(...) +# >>> get_years(haz) +# array([2020, 2021, ...]) +# """ +# return np.unique(np.array([datetime.fromordinal(date).year for date in haz.date])) + + +# def grow_exp(exp, exp_growth_rate, elapsed): +# """ +# Apply exponential growth to the exposure values over a specified period. + +# Parameters +# ---------- +# exp : Exposures +# The initial Exposures object with values to be grown. +# exp_growth_rate : float +# The annual growth rate to apply (in decimal form, e.g., 0.01 for 1%). +# elapsed : int +# Number of years over which to apply the growth. + +# Returns +# ------- +# Exposures +# A deep copy of the original Exposures object with grown exposure values. + +# Example +# ------- +# >>> exp = Exposures(...) +# >>> grow_exp(exp, 0.01, 5) +# Exposures object with values grown by 5%. +# """ +# exp_grown = copy.deepcopy(exp) +# # Exponential growth +# exp_growth_rate = 0.01 +# exp_grown.gdf.value = exp_grown.gdf.value * (1 + exp_growth_rate) ** elapsed +# return exp_grown + + +# class TBRTrajectories: + +# # Compute impacts for trajectories with present exposure and future exposure and interpolate in between +# # + +# @classmethod +# def create_hazard_yearly_set(cls, haz: Hazard): +# haz_set = {} +# years = get_years(haz) +# for year in range(years.min(), years.max(), 1): +# haz_set[year] = haz.select( +# date=[f"{str(year)}-01-01", f"{str(year+1)}-01-01"] +# ) + +# return haz_set + +# @classmethod +# def create_exposure_set(cls, snapshot_years, exp1, exp2=None, growth=None): +# exp_set = {} +# year_0 = snapshot_years.min() +# if exp2 is None: +# if growth is None: +# raise ValueError("Need to specify either final exposure or growth.") +# else: +# exp_set = { +# year: grow_exp(exp1, growth, year - year_0) +# for year in snapshot_years +# } +# else: +# exp_set = { +# year: np.interp(exp1, exp2, year - year_0) for year in snapshot_years +# } +# return exp_set From 31ea96d9a29854532dcedec67d083013b4359fe9 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 17 Apr 2025 09:31:04 +0200 Subject: [PATCH 013/113] feat(trajectory): interpolation and impactcalc files, eai_gdf metric --- climada/trajectories/impact_calc_strat.py | 168 ++++++++++++++++ climada/trajectories/interpolation.py | 133 ++++++++++++ climada/trajectories/risk_trajectory.py | 8 +- climada/trajectories/riskperiod.py | 233 +++------------------- 4 files changed, 330 insertions(+), 212 deletions(-) create mode 100644 climada/trajectories/impact_calc_strat.py create mode 100644 climada/trajectories/interpolation.py diff --git a/climada/trajectories/impact_calc_strat.py b/climada/trajectories/impact_calc_strat.py new file mode 100644 index 000000000..7620a7b37 --- /dev/null +++ b/climada/trajectories/impact_calc_strat.py @@ -0,0 +1,168 @@ +""" +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 and SnapshotsCollection classes. + +""" + +import copy +from abc import ABC, abstractmethod + +import numpy as np + +from climada.engine.impact import Impact +from climada.engine.impact_calc import ImpactCalc +from climada.trajectories.snapshot import Snapshot + + +class ImpactComputationStrategy(ABC): + """Interface for impact computation strategies.""" + + @abstractmethod + def compute_impacts( + self, + snapshot0: Snapshot, + snapshot1: Snapshot, + risk_transf_attach: float | None, + risk_transf_cover: float | None, + calc_residual: bool, + ) -> tuple: + pass + + +class ImpactCalcComputation(ImpactComputationStrategy): + """Default impact computation strategy.""" + + def compute_impacts( + self, + snapshot0: Snapshot, + snapshot1: Snapshot, + risk_transf_attach: float | None, + risk_transf_cover: float | None, + calc_residual: bool = False, + ): + impacts = self._calculate_impacts_for_snapshots(snapshot0, snapshot1) + self._apply_risk_transfer( + impacts, risk_transf_attach, risk_transf_cover, calc_residual + ) + return impacts + + def _calculate_impacts_for_snapshots( + self, snapshot0: Snapshot, snapshot1: Snapshot + ): + """Calculate impacts for the given snapshots and impact function set.""" + imp_E0H0 = ImpactCalc( + snapshot0.exposure, snapshot0.impfset, snapshot0.hazard + ).impact() + imp_E1H0 = ImpactCalc( + snapshot1.exposure, snapshot1.impfset, snapshot0.hazard + ).impact() + imp_E0H1 = ImpactCalc( + snapshot0.exposure, snapshot0.impfset, snapshot1.hazard + ).impact() + imp_E1H1 = ImpactCalc( + snapshot1.exposure, snapshot1.impfset, snapshot1.hazard + ).impact() + return imp_E0H0, imp_E1H0, imp_E0H1, imp_E1H1 + + def _apply_risk_transfer( + self, + impacts: tuple[Impact, Impact, Impact, Impact], + risk_transf_attach: float | None, + risk_transf_cover: float | None, + calc_residual: bool, + ): + """Apply risk transfer to the calculated impacts.""" + if risk_transf_attach is not None and risk_transf_cover is not None: + for imp in impacts: + imp.imp_mat = self.calculate_residual_or_risk_transfer_impact_matrix( + imp.imp_mat, risk_transf_attach, risk_transf_cover, calc_residual + ) + + def calculate_residual_or_risk_transfer_impact_matrix( + self, imp_mat, risk_transf_attach, risk_transf_cover, calc_residual + ): + """ + Calculate either the residual or the risk transfer impact matrix. + + The impact matrix is adjusted based on the total impact for each event. + When calculating the residual impact, the result is the total impact minus + the risk layer. The risk layer is defined as the minimum of the cover and + the maximum of the difference between the total impact and the attachment. + If `calc_residual` is False, the function returns the risk layer matrix + instead of the residual. + + Parameters + ---------- + imp_mat : scipy.sparse.csr_matrix + The original impact matrix to be scaled. + attachment : float, optional + The attachment point for the risk layer. + cover : float, optional + The maximum coverage for the risk layer. + calc_residual : bool, default=True + Determines if the function calculates the residual (if True) or the + risk layer (if False). + + Returns + ------- + scipy.sparse.csr_matrix + The adjusted impact matrix, either residual or risk transfer. + + Example + ------- + >>> calc_residual_or_risk_transf_imp_mat(imp_mat, attachment=100, cover=500, calc_residual=True) + Residual impact matrix with applied risk layer adjustments. + """ + if risk_transf_attach and risk_transf_cover: + # Make a copy of the impact matrix + imp_mat = copy.deepcopy(imp_mat) + # Calculate the total impact per event + total_at_event = imp_mat.sum(axis=1).A1 + # Risk layer at event + transfer_at_event = np.minimum( + np.maximum(total_at_event - risk_transf_attach, 0), risk_transf_cover + ) + # Resiudal impact + residual_at_event = np.maximum(total_at_event - transfer_at_event, 0) + + # Calculate either the residual or transfer impact matrix + # Choose the denominator to rescale the impact values + if calc_residual: + # Rescale the impact values + numerator = residual_at_event + else: + # Rescale the impact values + numerator = transfer_at_event + + # Rescale the impact values + rescale_impact_values = np.divide( + numerator, + total_at_event, + out=np.zeros_like(numerator, dtype=float), + where=total_at_event != 0, + ) + + # The multiplication is broadcasted across the columns for each row + result_matrix = imp_mat.multiply(rescale_impact_values[:, np.newaxis]) + + return result_matrix + + else: + + return imp_mat diff --git a/climada/trajectories/interpolation.py b/climada/trajectories/interpolation.py new file mode 100644 index 000000000..46d523d89 --- /dev/null +++ b/climada/trajectories/interpolation.py @@ -0,0 +1,133 @@ +import logging +from abc import ABC, abstractmethod + +import numpy as np +from scipy.sparse import lil_matrix + +LOGGER = logging.getLogger(__name__) + + +class InterpolationStrategy(ABC): + """Interface for interpolation strategies.""" + + @abstractmethod + def interpolate(self, imp_E0, imp_E1, time_points: int) -> list: ... + + +class LinearInterpolation(InterpolationStrategy): + """Linear interpolation strategy.""" + + def interpolate(self, imp_E0, imp_E1, time_points: int): + try: + return self.interpolate_imp_mat(imp_E0, imp_E1, time_points) + except ValueError as e: + if str(e) == "inconsistent shape": + raise ValueError( + "Interpolation between impact matrices of different shapes" + ) + else: + raise e + + @staticmethod + def interpolate_imp_mat(imp0, imp1, time_points): + """Interpolate between two impact matrices over a specified time range. + + Parameters + ---------- + imp0 : ImpactCalc + The impact calculation for the starting time. + imp1 : ImpactCalc + The impact calculation for the ending time. + time_points: + The number of points to interpolate. + + Returns + ------- + list of np.ndarray + List of interpolated impact matrices for each time points in the specified range. + """ + + def interpolate_sm(mat_start, mat_end, time, time_points): + """Perform linear interpolation between two matrices for a specified time point.""" + if time > time_points: + raise ValueError("time point must be within the range") + + ratio = time / (time_points - 1) + + # Convert the input matrices to a format that allows efficient modification of its elements + mat_start = lil_matrix(mat_start) + mat_end = lil_matrix(mat_end) + + # Perform the linear interpolation + mat_interpolated = mat_start + ratio * (mat_end - mat_start) + + return mat_interpolated + + LOGGER.debug(f"imp0: {imp0.imp_mat.data[0]}, imp1: {imp1.imp_mat.data[0]}") + return [ + interpolate_sm(imp0.imp_mat, imp1.imp_mat, time, time_points) + for time in range(time_points) + ] + + +class ExponentialInterpolation: + """Exponential interpolation strategy.""" + + def interpolate(self, imp_E0, imp_E1, time_points: int): + try: + return self.interpolate_imp_mat(imp_E0, imp_E1, time_points) + except ValueError as e: + if str(e) == "inconsistent shape": + raise ValueError( + "Interpolation between impact matrices of different shapes" + ) + else: + raise e + + @staticmethod + def interpolate_imp_mat(imp0, imp1, time_points): + """Interpolate between two impact matrices over a specified time range. + + Parameters + ---------- + imp0 : ImpactCalc + The impact calculation for the starting time. + imp1 : ImpactCalc + The impact calculation for the ending time. + time_points: + The number of points to interpolate. + + Returns + ------- + list of np.ndarray + List of interpolated impact matrices for each time points in the specified range. + """ + + def interpolate_sm(mat_start, mat_end, time, time_points): + """Perform exponential interpolation between two matrices for a specified time point.""" + if time > time_points: + raise ValueError("time point must be within the range") + + # Convert matrices to logarithmic domain + log_mat_start = np.log(mat_start.toarray() + np.finfo(float).eps) + log_mat_end = np.log(mat_end.toarray() + np.finfo(float).eps) + + # Perform linear interpolation in the logarithmic domain + ratio = time / (time_points - 1) + log_mat_interpolated = log_mat_start + ratio * (log_mat_end - log_mat_start) + + # Convert back to the original domain using the exponential function + mat_interpolated = np.exp(log_mat_interpolated) + + return lil_matrix(mat_interpolated) + + return [ + interpolate_sm(imp0.imp_mat, imp1.imp_mat, time, time_points) + for time in range(time_points) + ] + + +# Example usage +# Assuming imp0 and imp1 are instances of ImpactCalc with imp_mat attributes as sparse matrices +# interpolator = ExponentialInterpolation() +# interpolated_matrices = interpolator.interpolate(imp0, imp1, 100) diff --git a/climada/trajectories/risk_trajectory.py b/climada/trajectories/risk_trajectory.py index 3838c1c5c..11b28822e 100644 --- a/climada/trajectories/risk_trajectory.py +++ b/climada/trajectories/risk_trajectory.py @@ -78,12 +78,7 @@ def __init__( interpolation_strategy: InterpolationStrategy | None = None, impact_computation_strategy: ImpactComputationStrategy | None = None, ): - self._aai_metrics = None - self._return_periods_metrics = None - self._risk_components_metrics = None - self._aai_per_group_metrics = None - self._all_risk_metrics = None - self._metrics_up_to_date = False + self._reset_metrics() self._risk_period_up_to_date: bool = False self._snapshots = snapshots_list self._all_groups_name = all_groups_name @@ -103,6 +98,7 @@ def __init__( self._risk_periods_calculators = self._calc_risk_periods(snapshots_list) def _reset_metrics(self): + self._eai_metrics = None self._aai_metrics = None self._return_periods_metrics = None self._risk_components_metrics = None diff --git a/climada/trajectories/riskperiod.py b/climada/trajectories/riskperiod.py index d22096e84..0f1aca698 100644 --- a/climada/trajectories/riskperiod.py +++ b/climada/trajectories/riskperiod.py @@ -20,17 +20,21 @@ """ -import copy import logging -from abc import ABC, abstractmethod import numpy as np import pandas as pd -from scipy.sparse import lil_matrix -from climada.engine.impact import Impact from climada.engine.impact_calc import ImpactCalc from climada.entity.measures.base import Measure +from climada.trajectories.impact_calc_strat import ( + ImpactCalcComputation, + ImpactComputationStrategy, +) +from climada.trajectories.interpolation import ( + InterpolationStrategy, + LinearInterpolation, +) from climada.trajectories.snapshot import Snapshot LOGGER = logging.getLogger(__name__) @@ -48,207 +52,6 @@ def _lazy(self): return _lazy -class InterpolationStrategy(ABC): - """Interface for interpolation strategies.""" - - @abstractmethod - def interpolate(self, imp_E0, imp_E1, time_points: int) -> list: ... - - -class LinearInterpolation(InterpolationStrategy): - """Linear interpolation strategy.""" - - def interpolate(self, imp_E0, imp_E1, time_points: int): - try: - return self.interpolate_imp_mat(imp_E0, imp_E1, time_points) - except ValueError as e: - if str(e) == "inconsistent shape": - raise ValueError( - "Interpolation between impact matrices of different shapes" - ) - else: - raise e - - @staticmethod - def interpolate_imp_mat(imp0, imp1, time_points): - """Interpolate between two impact matrices over a specified time range. - - Parameters - ---------- - imp0 : ImpactCalc - The impact calculation for the starting time. - imp1 : ImpactCalc - The impact calculation for the ending time. - time_points: - The number of points to interpolate. - - Returns - ------- - list of np.ndarray - List of interpolated impact matrices for each time points in the specified range. - """ - - def interpolate_sm(mat_start, mat_end, time, time_points): - """Perform linear interpolation between two matrices for a specified time point.""" - if time > time_points: - raise ValueError("time point must be within the range") - - ratio = time / (time_points - 1) - - # Convert the input matrices to a format that allows efficient modification of its elements - mat_start = lil_matrix(mat_start) - mat_end = lil_matrix(mat_end) - - # Perform the linear interpolation - mat_interpolated = mat_start + ratio * (mat_end - mat_start) - - return mat_interpolated - - LOGGER.debug(f"imp0: {imp0.imp_mat.data[0]}, imp1: {imp1.imp_mat.data[0]}") - return [ - interpolate_sm(imp0.imp_mat, imp1.imp_mat, time, time_points) - for time in range(time_points) - ] - - -class ImpactComputationStrategy(ABC): - """Interface for impact computation strategies.""" - - @abstractmethod - def compute_impacts( - self, - snapshot0: Snapshot, - snapshot1: Snapshot, - risk_transf_attach: float | None, - risk_transf_cover: float | None, - calc_residual: bool, - ) -> tuple: - pass - - -class ImpactCalcComputation(ImpactComputationStrategy): - """Default impact computation strategy.""" - - def compute_impacts( - self, - snapshot0: Snapshot, - snapshot1: Snapshot, - risk_transf_attach: float | None, - risk_transf_cover: float | None, - calc_residual: bool = False, - ): - impacts = self._calculate_impacts_for_snapshots(snapshot0, snapshot1) - self._apply_risk_transfer( - impacts, risk_transf_attach, risk_transf_cover, calc_residual - ) - return impacts - - def _calculate_impacts_for_snapshots( - self, snapshot0: Snapshot, snapshot1: Snapshot - ): - """Calculate impacts for the given snapshots and impact function set.""" - imp_E0H0 = ImpactCalc( - snapshot0.exposure, snapshot0.impfset, snapshot0.hazard - ).impact() - imp_E1H0 = ImpactCalc( - snapshot1.exposure, snapshot1.impfset, snapshot0.hazard - ).impact() - imp_E0H1 = ImpactCalc( - snapshot0.exposure, snapshot0.impfset, snapshot1.hazard - ).impact() - imp_E1H1 = ImpactCalc( - snapshot1.exposure, snapshot1.impfset, snapshot1.hazard - ).impact() - return imp_E0H0, imp_E1H0, imp_E0H1, imp_E1H1 - - def _apply_risk_transfer( - self, - impacts: tuple[Impact, Impact, Impact, Impact], - risk_transf_attach: float | None, - risk_transf_cover: float | None, - calc_residual: bool, - ): - """Apply risk transfer to the calculated impacts.""" - if risk_transf_attach is not None and risk_transf_cover is not None: - for imp in impacts: - imp.imp_mat = self.calculate_residual_or_risk_transfer_impact_matrix( - imp.imp_mat, risk_transf_attach, risk_transf_cover, calc_residual - ) - - def calculate_residual_or_risk_transfer_impact_matrix( - self, imp_mat, risk_transf_attach, risk_transf_cover, calc_residual - ): - """ - Calculate either the residual or the risk transfer impact matrix. - - The impact matrix is adjusted based on the total impact for each event. - When calculating the residual impact, the result is the total impact minus - the risk layer. The risk layer is defined as the minimum of the cover and - the maximum of the difference between the total impact and the attachment. - If `calc_residual` is False, the function returns the risk layer matrix - instead of the residual. - - Parameters - ---------- - imp_mat : scipy.sparse.csr_matrix - The original impact matrix to be scaled. - attachment : float, optional - The attachment point for the risk layer. - cover : float, optional - The maximum coverage for the risk layer. - calc_residual : bool, default=True - Determines if the function calculates the residual (if True) or the - risk layer (if False). - - Returns - ------- - scipy.sparse.csr_matrix - The adjusted impact matrix, either residual or risk transfer. - - Example - ------- - >>> calc_residual_or_risk_transf_imp_mat(imp_mat, attachment=100, cover=500, calc_residual=True) - Residual impact matrix with applied risk layer adjustments. - """ - if risk_transf_attach and risk_transf_cover: - # Make a copy of the impact matrix - imp_mat = copy.deepcopy(imp_mat) - # Calculate the total impact per event - total_at_event = imp_mat.sum(axis=1).A1 - # Risk layer at event - transfer_at_event = np.minimum( - np.maximum(total_at_event - risk_transf_attach, 0), risk_transf_cover - ) - # Resiudal impact - residual_at_event = np.maximum(total_at_event - transfer_at_event, 0) - - # Calculate either the residual or transfer impact matrix - # Choose the denominator to rescale the impact values - if calc_residual: - # Rescale the impact values - numerator = residual_at_event - else: - # Rescale the impact values - numerator = transfer_at_event - - # Rescale the impact values - rescale_impact_values = np.divide( - numerator, - total_at_event, - out=np.zeros_like(numerator, dtype=float), - where=total_at_event != 0, - ) - - # The multiplication is broadcasted across the columns for each row - result_matrix = imp_mat.multiply(rescale_impact_values[:, np.newaxis]) - - return result_matrix - - else: - - return imp_mat - - class CalcRiskPeriod: """Handles the computation of impacts for a risk period.""" @@ -344,6 +147,10 @@ def per_date_aai_H0(self): def per_date_aai_H1(self): return self.calc_per_date_aais(self.per_date_eai_H1) + @lazy_property + def eai_gdf(self): + return self.calc_eai_gdf() + def per_date_return_periods_H0(self, return_periods) -> np.ndarray: return self.calc_per_date_rps( self.imp_mats_H0, self.snapshot0.hazard.frequency, return_periods @@ -357,7 +164,7 @@ def per_date_return_periods_H1(self, return_periods) -> np.ndarray: @classmethod def calc_per_date_eais(cls, imp_mats, frequency) -> np.ndarray: """ - Calculate per_date expected annual impact (EAI) values for two scenarios. + Calculate per_date expected average impact (EAI) values for two scenarios. Parameters ---------- @@ -478,6 +285,20 @@ def calc_freq_curve(cls, imp_mat_intrpl, frequency, return_per=None) -> np.ndarr return ifc_impact + def calc_eai_gdf(self): + per_date_eai_H0, per_date_eai_H1 = (self.per_date_eai_H0, self.per_date_eai_H1) + per_date_eai = np.multiply( + self._prop_H0.reshape(-1, 1), per_date_eai_H0 + ) + np.multiply(self._prop_H1.reshape(-1, 1), per_date_eai_H1) + df = pd.DataFrame(per_date_eai, index=self.date_idx) + df = df.reset_index().melt( + id_vars="date", var_name="coord_id", value_name="risk" + ) + eai_gdf = self.snapshot1.exposure.gdf + eai_gdf["coord_id"] = eai_gdf.index + eai_gdf = eai_gdf.merge(df, on="coord_id") + return eai_gdf + def calc_aai_metric(self): per_date_aai_H0, per_date_aai_H1 = self.per_date_aai_H0, self.per_date_aai_H1 per_date_aai = self._prop_H0 * per_date_aai_H0 + self._prop_H1 * per_date_aai_H1 From 3f13c2e1c7f07ce3ed32bf30074794302669ecc4 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 24 Apr 2025 13:43:23 +0200 Subject: [PATCH 014/113] impact func __eq__ --- climada/entity/impact_funcs/base.py | 23 +++++++++++++++---- .../entity/impact_funcs/impact_func_set.py | 6 +++++ 2 files changed, 24 insertions(+), 5 deletions(-) diff --git a/climada/entity/impact_funcs/base.py b/climada/entity/impact_funcs/base.py index 287391a79..c51540d57 100644 --- a/climada/entity/impact_funcs/base.py +++ b/climada/entity/impact_funcs/base.py @@ -97,6 +97,19 @@ def __init__( self.mdd = mdd if mdd is not None else np.array([]) self.paa = paa if paa is not None else np.array([]) + def __eq__(self, value: object, /) -> bool: + if isinstance(value, ImpactFunc): + return ( + self.haz_type == value.haz_type + and self.id == value.id + and self.name == value.name + and self.intensity_unit == value.intensity_unit + and np.array_equal(self.intensity, value.intensity) + and np.array_equal(self.mdd, value.mdd) + and np.array_equal(self.paa, value.paa) + ) + return False + def calc_mdr(self, inten: Union[float, np.ndarray]) -> np.ndarray: """Interpolate impact function to a given intensity. @@ -177,7 +190,7 @@ def from_step_impf( mdd: tuple[float, float] = (0, 1), paa: tuple[float, float] = (1, 1), impf_id: int = 1, - **kwargs + **kwargs, ): """Step function type impact function. @@ -218,7 +231,7 @@ def from_step_impf( intensity=intensity, mdd=mdd, paa=paa, - **kwargs + **kwargs, ) def set_step_impf(self, *args, **kwargs): @@ -238,7 +251,7 @@ def from_sigmoid_impf( x0: float, haz_type: str, impf_id: int = 1, - **kwargs + **kwargs, ): r"""Sigmoid type impact function hinging on three parameter. @@ -287,7 +300,7 @@ def from_sigmoid_impf( intensity=intensity, paa=paa, mdd=mdd, - **kwargs + **kwargs, ) def set_sigmoid_impf(self, *args, **kwargs): @@ -308,7 +321,7 @@ def from_poly_s_shape( exponent: float, haz_type: str, impf_id: int = 1, - **kwargs + **kwargs, ): r"""S-shape polynomial impact function hinging on four parameter. diff --git a/climada/entity/impact_funcs/impact_func_set.py b/climada/entity/impact_funcs/impact_func_set.py index e94ff8b82..030f73f2b 100755 --- a/climada/entity/impact_funcs/impact_func_set.py +++ b/climada/entity/impact_funcs/impact_func_set.py @@ -109,6 +109,12 @@ def __init__(self, impact_funcs: Optional[Iterable[ImpactFunc]] = None): for impf in impact_funcs: self.append(impf) + def __eq__(self, value: object, /) -> bool: + if isinstance(value, ImpactFuncSet): + return self._data == value._data + + return False + def clear(self): """Reinitialize attributes.""" self._data = dict() # {hazard_type : {id:ImpactFunc}} From 519c9af4e738d22323772b1f711adf4779ced673 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 24 Apr 2025 14:19:29 +0200 Subject: [PATCH 015/113] feat(test): adds test for ImpactFuncSet --- .../impact_funcs/test/test_imp_fun_set.py | 50 +++++++++++++++++++ 1 file changed, 50 insertions(+) diff --git a/climada/entity/impact_funcs/test/test_imp_fun_set.py b/climada/entity/impact_funcs/test/test_imp_fun_set.py index 3bc60559b..768b271cc 100644 --- a/climada/entity/impact_funcs/test/test_imp_fun_set.py +++ b/climada/entity/impact_funcs/test/test_imp_fun_set.py @@ -288,6 +288,55 @@ def test_remove_add_pass(self): self.assertEqual([1], imp_fun.get_ids("TC")) +class TestEquality(unittest.TestCase): + """Test equality method for ImpactFuncSet""" + + def setUp(self): + intensity = np.array([0, 20]) + paa = np.array([0, 1]) + mdd = np.array([0, 0.5]) + + fun_1 = ImpactFunc("TC", 3, intensity, mdd, paa) + fun_2 = ImpactFunc("TC", 3, intensity, mdd, paa) + fun_3 = ImpactFunc("TC", 4, intensity + 1, mdd, paa) + + self.impact_set1 = ImpactFuncSet([fun_1]) + self.impact_set2 = ImpactFuncSet([fun_2]) + self.impact_set3 = ImpactFuncSet([fun_3]) + self.impact_set4 = ImpactFuncSet([fun_1, fun_3]) + + def test_reflexivity(self): + self.assertEqual(self.impact_set1, self.impact_set1) + + def test_symmetry(self): + self.assertEqual(self.impact_set1, self.impact_set2) + self.assertEqual(self.impact_set2, self.impact_set1) + + def test_transitivity(self): + impact_set5 = ImpactFuncSet([self.impact_set1._data["TC"][3]]) + self.assertEqual(self.impact_set1, self.impact_set2) + self.assertEqual(self.impact_set2, impact_set5) + self.assertEqual(self.impact_set1, impact_set5) + + def test_consistency(self): + self.assertEqual(self.impact_set1, self.impact_set2) + self.assertEqual(self.impact_set1, self.impact_set2) + + def test_comparison_with_none(self): + self.assertNotEqual(self.impact_set1, None) + + def test_different_types(self): + self.assertNotEqual(self.impact_set1, "Not an ImpactFuncSet") + + def test_field_comparison(self): + self.assertNotEqual(self.impact_set1, self.impact_set3) + self.assertNotEqual(self.impact_set1, self.impact_set4) + + def test_inequality(self): + self.assertNotEqual(self.impact_set1, self.impact_set3) + self.assertTrue(self.impact_set1 != self.impact_set3) + + class TestChecker(unittest.TestCase): """Test loading funcions from the ImpactFuncSet class""" @@ -592,6 +641,7 @@ def test_write_read_pass(self): # Execute Tests if __name__ == "__main__": TESTS = unittest.TestLoader().loadTestsFromTestCase(TestContainer) + TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestEquality)) TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestChecker)) TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestExtend)) TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestReaderExcel)) From adfc7e20996739f41d30de720aae10489a1bcd3e Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 24 Apr 2025 14:22:15 +0200 Subject: [PATCH 016/113] fix(format): removes trailing whitespace --- climada/entity/impact_funcs/impact_func_set.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/climada/entity/impact_funcs/impact_func_set.py b/climada/entity/impact_funcs/impact_func_set.py index 358b7e69e..030f73f2b 100755 --- a/climada/entity/impact_funcs/impact_func_set.py +++ b/climada/entity/impact_funcs/impact_func_set.py @@ -112,7 +112,7 @@ def __init__(self, impact_funcs: Optional[Iterable[ImpactFunc]] = None): def __eq__(self, value: object, /) -> bool: if isinstance(value, ImpactFuncSet): return self._data == value._data - + return False def clear(self): From 9c358ca73dd1c81111da1e3f724798e493bdd252 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 24 Apr 2025 15:36:29 +0200 Subject: [PATCH 017/113] fix: npv arg not considered in .all_risk_metrics() --- climada/trajectories/risk_trajectory.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/climada/trajectories/risk_trajectory.py b/climada/trajectories/risk_trajectory.py index 11b28822e..ad47086be 100644 --- a/climada/trajectories/risk_trajectory.py +++ b/climada/trajectories/risk_trajectory.py @@ -280,10 +280,10 @@ def all_risk_metrics( self, return_periods=[50, 100, 500], npv=True ) -> pd.DataFrame | pd.Series: if not self._metrics_up_to_date or self._all_risk_metrics is None: - aai = self.aai_metrics() - rp = self.return_periods_metrics(return_periods) - aai_per_group = self.aai_per_group_metrics() - risk_components = self.risk_components_metrics() + aai = self.aai_metrics(npv) + rp = self.return_periods_metrics(return_periods, npv) + aai_per_group = self.aai_per_group_metrics(npv) + risk_components = self.risk_components_metrics(npv) self._all_risk_metrics = pd.concat( [aai, rp, aai_per_group, risk_components] ) From b7bf68b7e2a7f08e5ba8ed00dbc79e5de48628d4 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 24 Apr 2025 15:37:40 +0200 Subject: [PATCH 018/113] refactor: enforce kwargs in RiskTrajectory init --- climada/trajectories/risk_trajectory.py | 1 + 1 file changed, 1 insertion(+) diff --git a/climada/trajectories/risk_trajectory.py b/climada/trajectories/risk_trajectory.py index ad47086be..99f2b510c 100644 --- a/climada/trajectories/risk_trajectory.py +++ b/climada/trajectories/risk_trajectory.py @@ -69,6 +69,7 @@ class RiskTrajectory: def __init__( self, snapshots_list: list[Snapshot], + *, interval_freq: str = "YS", all_groups_name: str = "All", risk_disc: DiscRates | None = None, From b75ab91c8d1ba04a6be799450cce2c5cd6867fc6 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 24 Apr 2025 16:56:25 +0200 Subject: [PATCH 019/113] refactor: adds consistency between attribute --- climada/trajectories/riskperiod.py | 185 +++++++++++++++++++++++++---- 1 file changed, 163 insertions(+), 22 deletions(-) diff --git a/climada/trajectories/riskperiod.py b/climada/trajectories/riskperiod.py index 0f1aca698..f07fb181e 100644 --- a/climada/trajectories/riskperiod.py +++ b/climada/trajectories/riskperiod.py @@ -66,10 +66,9 @@ def __init__( risk_transf_attach: float | None = None, risk_transf_cover: float | None = None, calc_residual: bool = False, - measure: Measure | None = None, ): - self.snapshot0 = snapshot0 - self.snapshot1 = snapshot1 + self._snapshot0 = snapshot0 + self._snapshot1 = snapshot1 self.date_idx = pd.date_range( snapshot0.date, snapshot1.date, @@ -77,31 +76,153 @@ def __init__( freq=interval_freq, # type: ignore name="date", ) - self.time_points = len(self.date_idx) - self.interval_freq = pd.infer_freq(self.date_idx) - self.measure = measure - self._prop_H1 = np.linspace(0, 1, num=self.time_points) - self._prop_H0 = 1 - self._prop_H1 self.interpolation_strategy = interpolation_strategy or LinearInterpolation() self.impact_computation_strategy = ( impact_computation_strategy or ImpactCalcComputation() ) - self._E0H0, self._E1H0, self._E0H1, self._E1H1 = ( - self.impact_computation_strategy.compute_impacts( - snapshot0, - snapshot1, - risk_transf_attach, - risk_transf_cover, - calc_residual, - ) - ) + self.risk_transf_attach = risk_transf_attach + self.risk_transf_cover = risk_transf_cover + self.calc_residual = calc_residual + self.measure = None # Only possible to set with apply_measure to make sure snapshots are consistent + + self._group_id_E0 = self.snapshot0.exposure.gdf["group_id"].values + self._group_id_E1 = self.snapshot1.exposure.gdf["group_id"].values + + def _reset_impact_data(self): + self._impacts_arrays = None, None, None, None self._imp_mats_H0, self._imp_mats_H1 = None, None self._imp_mats_E0, self._imp_mats_E1 = None, None self._per_date_eai_H0, self._per_date_eai_H1 = None, None self._per_date_aai_H0, self._per_date_aai_H1 = None, None self._per_date_return_periods_H0, self._per_date_return_periods_H1 = None, None - self._group_id_E0 = self.snapshot0.exposure.gdf["group_id"].values - self._group_id_E1 = self.snapshot1.exposure.gdf["group_id"].values + + @property + def snapshot0(self): + return self._snapshot0 + + @property + def snapshot1(self): + return self._snapshot1 + + @property + def date_idx(self): + return self._date_idx + + @date_idx.setter + def date_idx(self, value, /): + if not isinstance(value, pd.DatetimeIndex): + raise ValueError("Not a DatetimeIndex") + + self._date_idx = value + self._time_points = len(self.date_idx) + self._interval_freq = pd.infer_freq(self.date_idx) + self._prop_H1 = np.linspace(0, 1, num=self.time_points) + self._prop_H0 = 1 - self._prop_H1 + self._reset_impact_data() + + @property + def time_points(self): + return self._time_points + + @time_points.setter + def time_points(self, value, /): + if not isinstance(value, int): + raise ValueError("Not an int") + + self.date_idx = pd.date_range( + self.snapshot0.date, self.snapshot1.date, periods=value, name="date" + ) + + @property + def interval_freq(self): + return self._interval_freq + + @interval_freq.setter + def interval_freq(self, value, /): + freq = pd.tseries.frequencies.to_offset(value) + self.date_idx = pd.date_range( + self.snapshot0.date, self.snapshot1.date, freq=freq, name="date" + ) + + @property + def interpolation_strategy(self): + return self._interpolation_strategy + + @interpolation_strategy.setter + def interpolation_strategy(self, value, /): + if not isinstance(value, InterpolationStrategy): + raise ValueError("Not an interpolation strategy") + + self._interpolation_strategy = value + self._reset_impact_data() + + @property + def impact_computation_strategy(self): + return self._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._impact_computation_strategy = value + self._reset_impact_data() + + @lazy_property + def impacts_arrays(self): + return self.impact_computation_strategy.compute_impacts( + self.snapshot0, + self.snapshot1, + self.risk_transf_attach, + self.risk_transf_cover, + self.calc_residual, + ) + + @property + def _E0H0(self): + return self.impacts_arrays[0] + + @property + def _E1H0(self): + return self.impacts_arrays[1] + + @property + def _E0H1(self): + return self.impacts_arrays[2] + + @property + def _E1H1(self): + return self.impacts_arrays[3] + + @property + def risk_transf_attach(self): + return self._risk_transfer_attach + + @risk_transf_attach.setter + def risk_transf_attach(self, value, /): + self._risk_transfer_attach = value + self._reset_impact_data() + + @property + def risk_transf_cover(self): + return self._risk_transfer_cover + + @risk_transf_cover.setter + def risk_transf_cover(self, value, /): + self._risk_transfer_cover = value + self._reset_impact_data() + + @property + def calc_residual(self): + return self._calc_residual + + @calc_residual.setter + def calc_residual(self, value, /): + if not isinstance(value, bool): + raise ValueError("Not a boolean") + + self._calc_residual = value + self._reset_impact_data() @lazy_property def imp_mats_H0(self): @@ -336,9 +457,10 @@ def calc_aai_per_group_metric(self): return aai_per_group_df def calc_return_periods_metric(self, return_periods): - rp_0, rp_1 = self.per_date_return_periods_H0( - return_periods - ), self.per_date_return_periods_H1(return_periods) + rp_0, rp_1 = ( + self.per_date_return_periods_H0(return_periods), + self.per_date_return_periods_H1(return_periods), + ) per_date_rp = np.multiply(self._prop_H0.reshape(-1, 1), rp_0) + np.multiply( self._prop_H1.reshape(-1, 1), rp_1 ) @@ -375,3 +497,22 @@ def calc_risk_components_metric(self): df["group"] = pd.NA df["measure"] = self.measure.name if self.measure else "no_measure" return df + + def apply_measure(self, measure: Measure): + snap0 = self.snapshot0.apply_measure(measure) + snap1 = self.snapshot1.apply_measure(measure) + + risk_period = CalcRiskPeriod( + snap0, + snap1, + self.interval_freq, + self.time_points, + self.interpolation_strategy, + self.impact_computation_strategy, + self.risk_transf_attach, + self.risk_transf_cover, + self.calc_residual, + ) + + risk_period.measure = measure + return risk_period From e12b2c4562f890eab94d57dd2ec8f30797ba63ea Mon Sep 17 00:00:00 2001 From: spjuhel Date: Fri, 25 Apr 2025 18:14:49 +0200 Subject: [PATCH 020/113] refactor(risktraj): lays better foundations for MeasureAppraiser --- climada/trajectories/risk_trajectory.py | 96 +++++++++++++++---------- climada/trajectories/riskperiod.py | 68 ++++++++++++++++-- 2 files changed, 120 insertions(+), 44 deletions(-) diff --git a/climada/trajectories/risk_trajectory.py b/climada/trajectories/risk_trajectory.py index 99f2b510c..3121fc33f 100644 --- a/climada/trajectories/risk_trajectory.py +++ b/climada/trajectories/risk_trajectory.py @@ -105,7 +105,6 @@ def _reset_metrics(self): self._risk_components_metrics = None self._aai_per_group_metrics = None self._all_risk_metrics = None - self._metrics_up_to_date = False @property def default_rp(self): @@ -249,48 +248,67 @@ def _generic_metrics( return getattr(self, attr_name) - def aai_metrics(self, npv=True): - return self._generic_metrics( - npv=npv, metric_name="aai", metric_meth="calc_aai_metric" + def _compute_metrics( + self, metric_name, metric_meth, total=False, npv=True, *args, **kwargs + ): + """Helper method to compute metrics and optionally return total risk.""" + df = self._generic_metrics( + npv=npv, metric_name=metric_name, metric_meth=metric_meth, *args, **kwargs ) + if total: + return self._per_period_risk(df) + return df - def return_periods_metrics(self, return_periods=None, npv=True): + def aai_metrics(self, total=False, npv=True, *args, **kwargs): + return self._compute_metrics( + total=total, + npv=npv, + metric_name="aai", + metric_meth="calc_aai_metric", + *args, + **kwargs, + ) + + def return_periods_metrics( + self, total=False, return_periods=None, npv=True, *args, **kwargs + ): return_periods = return_periods if return_periods else self.default_rp - return self._generic_metrics( + return self._compute_metrics( npv=npv, metric_name="return_periods", metric_meth="calc_return_periods_metric", return_periods=return_periods, + *args, + **kwargs, ) - def aai_per_group_metrics(self, npv=True): - return self._generic_metrics( + def aai_per_group_metrics(self, npv=True, *args, **kwargs): + return self._compute_metrics( npv=npv, metric_name="aai_per_group", metric_meth="calc_aai_per_group_metric", + *args, + **kwargs, ) - def risk_components_metrics(self, npv=True): - return self._generic_metrics( + def risk_components_metrics(self, npv=True, *args, **kwargs): + return self._compute_metrics( npv=npv, metric_name="risk_components", metric_meth="calc_risk_components_metric", + *args, + **kwargs, ) def all_risk_metrics( - self, return_periods=[50, 100, 500], npv=True + self, return_periods=[50, 100, 500], npv=True, *args, **kwargs ) -> pd.DataFrame | pd.Series: - if not self._metrics_up_to_date or self._all_risk_metrics is None: - aai = self.aai_metrics(npv) - rp = self.return_periods_metrics(return_periods, npv) - aai_per_group = self.aai_per_group_metrics(npv) - risk_components = self.risk_components_metrics(npv) - self._all_risk_metrics = pd.concat( - [aai, rp, aai_per_group, risk_components] - ) - self._metrics_up_to_date = True - return self._all_risk_metrics + aai = self.aai_metrics(npv, *args, **kwargs) + rp = self.return_periods_metrics(return_periods, npv, *args, **kwargs) + aai_per_group = self.aai_per_group_metrics(npv, *args, **kwargs) + risk_components = self.risk_components_metrics(npv, *args, **kwargs) + return pd.concat([aai, rp, aai_per_group, risk_components]) @staticmethod def _get_risk_periods( @@ -321,7 +339,7 @@ def identify_continuous_periods(group, time_unit): return group grouper = cls._grouper - if "group" in df.columns: + if "group" in df.columns and "group" not in grouper: grouper = ["group"] + grouper df_sorted = df.sort_values(by=cls._grouper + ["date"]) @@ -330,14 +348,20 @@ def identify_continuous_periods(group, time_unit): identify_continuous_periods, time_unit ) + if isinstance(colname, str): + colname = [colname] + + agg_dict = { + "start_date": pd.NamedAgg(column="date", aggfunc="min"), + "end_date": pd.NamedAgg(column="date", aggfunc="max"), + } + for col in colname: + agg_dict[col] = pd.NamedAgg(column=col, aggfunc="sum") # Group by the identified periods and calculate start and end dates + print(df_periods) df_periods = ( df_periods.groupby(grouper + ["period_id"], dropna=False) - .agg( - start_date=pd.NamedAgg(column="date", aggfunc="min"), - end_date=pd.NamedAgg(column="date", aggfunc="max"), - total=pd.NamedAgg(column=colname, aggfunc="sum"), - ) + .agg(**agg_dict) .reset_index() ) @@ -346,28 +370,22 @@ def identify_continuous_periods(group, time_unit): + " to " + df_periods["end_date"].astype(str) ) - df_periods = df_periods.rename(columns={"total": f"{colname}"}) + # df_periods = df_periods.rename(columns={"total": f"{colname}"}) df_periods = df_periods.drop(["period_id", "start_date", "end_date"], axis=1) return df_periods[ ["period"] + [col for col in df_periods.columns if col != "period"] ] @property - def per_date_risk_metrics(self) -> pd.DataFrame | pd.Series: + def per_date_risk_metrics(self, *args, **kwargs) -> pd.DataFrame | pd.Series: """Returns a tidy dataframe of the risk metrics for all dates.""" - return self._prepare_risk_metrics(total=False, npv=True) + return self.all_risk_metrics(*args, **kwargs) @property - def total_risk_metrics(self) -> pd.DataFrame | pd.Series: + def total_risk_metrics(self, *args, **kwargs) -> pd.DataFrame | pd.Series: """Returns a tidy dataframe of the risk metrics with the total for each different period.""" - return self._prepare_risk_metrics(total=True, npv=True) - - def _prepare_risk_metrics(self, total=False, npv=True) -> pd.DataFrame | pd.Series: - df = self.all_risk_metrics(npv=npv) - if total: - return self._per_period_risk(df) - - return df + df = self.all_risk_metrics(*args, **kwargs) + return self._per_period_risk(df) def _calc_waterfall_plot_data(self, start_date=None, end_date=None, npv=True): start_date = self.start_date if start_date is None else start_date diff --git a/climada/trajectories/riskperiod.py b/climada/trajectories/riskperiod.py index f07fb181e..b9237d164 100644 --- a/climada/trajectories/riskperiod.py +++ b/climada/trajectories/riskperiod.py @@ -46,6 +46,10 @@ def lazy_property(method): @property def _lazy(self): if getattr(self, attr_name) is None: + meas_n = self.measure.name if self.measure else "no_measure" + LOGGER.debug( + f"Computing {method.__name__} for {self._snapshot0.date}-{self._snapshot1.date} with {meas_n}." + ) setattr(self, attr_name, method(self)) return getattr(self, attr_name) @@ -67,13 +71,14 @@ def __init__( risk_transf_cover: float | None = None, calc_residual: bool = False, ): + LOGGER.info("Instantiating new CalcRiskPeriod.") self._snapshot0 = snapshot0 self._snapshot1 = snapshot1 - self.date_idx = pd.date_range( - snapshot0.date, - snapshot1.date, + self.date_idx = CalcRiskPeriod._set_date_idx( + date1=snapshot0.date, + date2=snapshot1.date, periods=time_points, - freq=interval_freq, # type: ignore + freq=interval_freq, name="date", ) self.interpolation_strategy = interpolation_strategy or LinearInterpolation() @@ -89,13 +94,66 @@ def __init__( self._group_id_E1 = self.snapshot1.exposure.gdf["group_id"].values def _reset_impact_data(self): - self._impacts_arrays = None, None, None, None + self._impacts_arrays = None self._imp_mats_H0, self._imp_mats_H1 = None, None self._imp_mats_E0, self._imp_mats_E1 = None, None self._per_date_eai_H0, self._per_date_eai_H1 = None, None self._per_date_aai_H0, self._per_date_aai_H1 = None, None self._per_date_return_periods_H0, self._per_date_return_periods_H1 = None, None + @staticmethod + def _set_date_idx( + date1: str | pd.Timestamp, + date2: str | pd.Timestamp, + periods: int | None = None, + freq: str | None = None, + name: str | None = None, + ) -> pd.DatetimeIndex: + """ + Generate a date range index based on the provided parameters. + + Parameters + ---------- + date1 : str or pd.Timestamp + The start date of the date range. + date2 : str or pd.Timestamp + The end date of the date range. + periods : int, optional + Number of date points to generate. If None, `freq` must be provided. + freq : str, optional + Frequency string for the date range. If None, `periods` must be provided. + name : str, optional + Name of the resulting date range index. + + Returns + ------- + pd.DatetimeIndex + A DatetimeIndex representing the date range. + + Raises + ------ + ValueError + If the number of periods and frequency given to date_range are inconsistent. + """ + if periods is not None and freq is not None: + points = None + else: + points = periods + + ret = pd.date_range( + date1, + date2, + periods=points, + freq=freq, # type: ignore + name=name, + ) + if periods is not None and len(ret) != periods: + raise ValueError( + "Number of periods and frequency given to date_range are inconsistant" + ) + + return ret + @property def snapshot0(self): return self._snapshot0 From 866619777f0501703c43212315e7c9eee81ae013 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Wed, 7 May 2025 17:34:03 +0200 Subject: [PATCH 021/113] minor additions, refactors and fixes --- climada/trajectories/risk_trajectory.py | 181 +++++++++++++----------- climada/trajectories/riskperiod.py | 13 +- 2 files changed, 108 insertions(+), 86 deletions(-) diff --git a/climada/trajectories/risk_trajectory.py b/climada/trajectories/risk_trajectory.py index 3121fc33f..3322bf7fe 100644 --- a/climada/trajectories/risk_trajectory.py +++ b/climada/trajectories/risk_trajectory.py @@ -38,7 +38,8 @@ LOGGER = logging.getLogger(__name__) -POSSIBLE_METRICS = ["aai", "rp", "group", "components"] +POSSIBLE_METRICS = ["eai", "aai", "return_periods", "risk_components", "aai_per_group"] +DEFAULT_RP = [50, 100, 500] class RiskTrajectory: @@ -83,7 +84,7 @@ def __init__( self._risk_period_up_to_date: bool = False self._snapshots = snapshots_list self._all_groups_name = all_groups_name - self._default_rp = [50, 100, 500] + self._default_rp = DEFAULT_RP self.start_date = min([snapshot.date for snapshot in snapshots_list]) self.end_date = max([snapshot.date for snapshot in snapshots_list]) self._interval_freq = interval_freq @@ -99,11 +100,9 @@ def __init__( self._risk_periods_calculators = self._calc_risk_periods(snapshots_list) def _reset_metrics(self): - self._eai_metrics = None - self._aai_metrics = None - self._return_periods_metrics = None - self._risk_components_metrics = None - self._aai_per_group_metrics = None + for metric in POSSIBLE_METRICS: + setattr(self, "_" + metric + "_metrics", None) + self._all_risk_metrics = None @property @@ -118,7 +117,6 @@ def default_rp(self, value): ValueError("Return periods need to be a list of int.") self._return_periods_metrics = None self._all_risk_metrics = None - self._metrics_up_to_date = False self._default_rp = value @property @@ -192,7 +190,7 @@ def pairwise(container: list): ] @classmethod - def npv_transform(cls, df, risk_disc): + def npv_transform(cls, df: pd.DataFrame, risk_disc) -> pd.DataFrame: def _npv_group(group, disc): start_date = group.index.get_level_values("date").min() end_date = group.index.get_level_values("date").max() @@ -213,12 +211,20 @@ def _npv_group(group, disc): return df def _generic_metrics( - self, npv=True, metric_name=None, metric_meth=None, *args, **kwargs + self, + npv: bool = True, + metric_name: str | None = None, + metric_meth: str | None = None, + **kwargs, ): """Generic method to compute metrics based on the provided metric name and method.""" 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 POSSIBLE_METRICS: + raise NotImplementedError( + f"{metric_name} not implemented ({POSSIBLE_METRICS})." + ) # Construct the attribute name for storing the metric results attr_name = f"_{metric_name}_metrics" @@ -226,7 +232,7 @@ def _generic_metrics( tmp = [] for calc_period in self.risk_periods: # Call the specified method on the calc_period object - tmp.append(getattr(calc_period, metric_meth)(*args, **kwargs)) + tmp.append(getattr(calc_period, metric_meth)(**kwargs)) tmp = pd.concat(tmp) tmp.drop_duplicates(inplace=True) @@ -241,88 +247,107 @@ def _generic_metrics( ] + ["risk"] ] - if npv: - tmp = self.npv_transform(tmp, self.risk_disc) - setattr(self, attr_name, tmp) + if npv: + return self.npv_transform(getattr(self, attr_name), self.risk_disc) + return getattr(self, attr_name) + def _compute_period_metrics( + self, metric_name: str, metric_meth: str, npv: bool = True, **kwargs + ): + """Helper method to compute total metrics per period.""" + df = self._generic_metrics( + npv=npv, metric_name=metric_name, metric_meth=metric_meth, **kwargs + ) + return self._per_period_risk(df) + def _compute_metrics( - self, metric_name, metric_meth, total=False, npv=True, *args, **kwargs + self, metric_name: str, metric_meth: str, npv: bool = True, **kwargs ): - """Helper method to compute metrics and optionally return total risk.""" + """Helper method to compute metrics.""" df = self._generic_metrics( - npv=npv, metric_name=metric_name, metric_meth=metric_meth, *args, **kwargs + npv=npv, metric_name=metric_name, metric_meth=metric_meth, **kwargs ) - if total: - return self._per_period_risk(df) return df - def aai_metrics(self, total=False, npv=True, *args, **kwargs): + def eai_metrics(self, npv: bool = True): + return self._compute_metrics( + npv=npv, + metric_name="eai", + metric_meth="calc_eai_gdf", + ) + + def aai_metrics(self, npv: bool = True): return self._compute_metrics( - total=total, npv=npv, metric_name="aai", metric_meth="calc_aai_metric", - *args, - **kwargs, ) - def return_periods_metrics( - self, total=False, return_periods=None, npv=True, *args, **kwargs - ): - return_periods = return_periods if return_periods else self.default_rp + def return_periods_metrics(self, return_periods, npv: bool = True): return self._compute_metrics( npv=npv, metric_name="return_periods", metric_meth="calc_return_periods_metric", return_periods=return_periods, - *args, - **kwargs, ) - def aai_per_group_metrics(self, npv=True, *args, **kwargs): + def aai_per_group_metrics(self, npv: bool = True): return self._compute_metrics( npv=npv, metric_name="aai_per_group", metric_meth="calc_aai_per_group_metric", - *args, - **kwargs, ) - def risk_components_metrics(self, npv=True, *args, **kwargs): + def risk_components_metrics(self, npv: bool = True): return self._compute_metrics( npv=npv, metric_name="risk_components", metric_meth="calc_risk_components_metric", - *args, - **kwargs, ) - def all_risk_metrics( - self, return_periods=[50, 100, 500], npv=True, *args, **kwargs + def per_date_risk_metrics( + self, + metrics: list[str] | None = None, + return_periods: list[int] | None = None, + npv: bool = True, ) -> pd.DataFrame | pd.Series: + metrics_df = [] + metrics = ( + ["aai", "return_periods", "aai_per_group"] if metrics is None else metrics + ) + return_periods = return_periods if return_periods else self.default_rp + if "aai" in metrics: + metrics_df.append(self.aai_metrics(npv)) + if "return_periods" in metrics: + metrics_df.append(self.return_periods_metrics(return_periods, npv)) + if "aai_per_group" in metrics: + metrics_df.append(self.aai_per_group_metrics(npv)) - aai = self.aai_metrics(npv, *args, **kwargs) - rp = self.return_periods_metrics(return_periods, npv, *args, **kwargs) - aai_per_group = self.aai_per_group_metrics(npv, *args, **kwargs) - risk_components = self.risk_components_metrics(npv, *args, **kwargs) - return pd.concat([aai, rp, aai_per_group, risk_components]) + return pd.concat(metrics_df) @staticmethod def _get_risk_periods( - risk_periods, start_date: datetime.date, end_date: datetime.date + risk_periods: list[CalcRiskPeriod], + start_date: datetime.date, + end_date: datetime.date, ): return [ period for period in risk_periods - if (start_date >= period.start_date or end_date <= period.end_date) + if ( + start_date >= period.snapshot0.date or end_date <= period.snapshot1.date + ) ] @classmethod def _per_period_risk( - cls, df: pd.DataFrame, time_unit="year", colname="risk" + cls, + df: pd.DataFrame, + time_unit: str = "year", + colname: str | list[str] = "risk", ) -> pd.DataFrame | pd.Series: def identify_continuous_periods(group, time_unit): # Calculate the difference between consecutive dates @@ -358,7 +383,6 @@ def identify_continuous_periods(group, time_unit): for col in colname: agg_dict[col] = pd.NamedAgg(column=col, aggfunc="sum") # Group by the identified periods and calculate start and end dates - print(df_periods) df_periods = ( df_periods.groupby(grouper + ["period_id"], dropna=False) .agg(**agg_dict) @@ -370,24 +394,24 @@ def identify_continuous_periods(group, time_unit): + " to " + df_periods["end_date"].astype(str) ) - # df_periods = df_periods.rename(columns={"total": f"{colname}"}) df_periods = df_periods.drop(["period_id", "start_date", "end_date"], axis=1) return df_periods[ ["period"] + [col for col in df_periods.columns if col != "period"] ] - @property - def per_date_risk_metrics(self, *args, **kwargs) -> pd.DataFrame | pd.Series: - """Returns a tidy dataframe of the risk metrics for all dates.""" - return self.all_risk_metrics(*args, **kwargs) - - @property - def total_risk_metrics(self, *args, **kwargs) -> pd.DataFrame | pd.Series: + def per_period_risk_metrics( + self, metrics: list[str] = ["aai", "return_periods", "aai_per_group"], **kwargs + ) -> pd.DataFrame | pd.Series: """Returns a tidy dataframe of the risk metrics with the total for each different period.""" - df = self.all_risk_metrics(*args, **kwargs) - return self._per_period_risk(df) + df = self.per_date_risk_metrics(metrics=metrics, **kwargs) + return self._per_period_risk(df, **kwargs) - def _calc_waterfall_plot_data(self, start_date=None, end_date=None, npv=True): + def _calc_waterfall_plot_data( + self, + start_date: datetime.date | None = None, + end_date: datetime.date | None = None, + npv: bool = True, + ): 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_components = self.risk_components_metrics(npv) @@ -400,7 +424,12 @@ def _calc_waterfall_plot_data(self, start_date=None, end_date=None, npv=True): ].unstack() return risk_components - def plot_per_date_waterfall(self, ax=None, start_date=None, end_date=None): + def plot_per_date_waterfall( + self, + ax=None, + start_date: datetime.date | None = None, + end_date: datetime.date | None = None, + ): """Plot a waterfall chart of risk components over a specified date range. This method generates a stacked bar chart to visualize the @@ -446,7 +475,12 @@ def plot_per_date_waterfall(self, ax=None, start_date=None, end_date=None): ax.set_ylabel(value_label) return ax - def plot_waterfall(self, ax=None, start_date=None, end_date=None): + def plot_waterfall( + self, + ax=None, + start_date: datetime.date | None = None, + end_date: datetime.date | None = None, + ): """Plot a waterfall chart of risk components between two dates. This method generates a waterfall plot to visualize the changes in risk components @@ -543,7 +577,12 @@ def plot_waterfall(self, ax=None, start_date=None, end_date=None): return ax -def calc_npv_cash_flows(cash_flows, start_date, end_date=None, disc=None): +def calc_npv_cash_flows( + cash_flows: pd.DataFrame, + start_date: datetime.date, + end_date: datetime.date | None = None, + disc: DiscRates | None = None, +): # If no discount rates are provided, return the cash flows as is if not disc: return cash_flows @@ -572,25 +611,3 @@ def calc_npv_cash_flows(cash_flows, start_date, end_date=None, disc=None): df["npv_cash_flow"] = df["cash_flow"] * df["discount_factor"] return df["npv_cash_flow"] - - -def get_eai_exp(eai_exp, group_map): - """ - Aggregate expected annual impact (EAI) by groups. - - Parameters - ---------- - eai_exp : np.ndarray - Array of EAI values. - group_map : dict - Mapping of group names to indices for aggregation. - - Returns - ------- - dict - Dictionary of EAI values aggregated by specified groups. - """ - eai_region_id = {} - for group_name, exp_indices in group_map.items(): - eai_region_id[group_name] = np.sum(eai_exp[:, exp_indices], axis=1) - return eai_region_id diff --git a/climada/trajectories/riskperiod.py b/climada/trajectories/riskperiod.py index b9237d164..4b64bbe92 100644 --- a/climada/trajectories/riskperiod.py +++ b/climada/trajectories/riskperiod.py @@ -476,6 +476,11 @@ def calc_eai_gdf(self): eai_gdf = self.snapshot1.exposure.gdf eai_gdf["coord_id"] = eai_gdf.index eai_gdf = eai_gdf.merge(df, on="coord_id") + eai_gdf = eai_gdf.rename( + columns={"group_id": "group", "value": "exposure_value"} + ) + eai_gdf["metric"] = "eai" + eai_gdf["measure"] = self.measure.name if self.measure else "no_measure" return eai_gdf def calc_aai_metric(self): @@ -493,11 +498,11 @@ def calc_aai_per_group_metric(self): for group in np.unique( np.concatenate(np.array([self._group_id_E0, self._group_id_E1]), axis=0) ): - group_idx_E0 = np.where(self._group_id_E0 != group) - group_idx_E1 = np.where(self._group_id_E1 != group) + group_idx_E0 = np.where(self._group_id_E0 == group)[0] + group_idx_E1 = np.where(self._group_id_E1 == group)[0] per_date_aai_H0, per_date_aai_H1 = ( - self.per_date_eai_H0[:, group_idx_E0].sum(), - self.per_date_eai_H1[:, group_idx_E1].sum(), + self.per_date_eai_H0[:, group_idx_E0].sum(axis=1), + self.per_date_eai_H1[:, group_idx_E1].sum(axis=1), ) per_date_aai = ( self._prop_H0 * per_date_aai_H0 + self._prop_H1 * per_date_aai_H1 From 9711379ae305d0234f1c8e282949a2ba71964d58 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Wed, 14 May 2025 18:41:20 +0200 Subject: [PATCH 022/113] format,doc: cleans up code, adds docstrings --- climada/trajectories/impact_calc_strat.py | 10 +- climada/trajectories/interpolation.py | 48 +- climada/trajectories/risk_trajectory.py | 1 - climada/trajectories/riskperiod.py | 55 +- climada/trajectories/snapshot.py | 17 +- doc/tutorial/climada_trajectories.ipynb | 601 ++++++---------------- 6 files changed, 247 insertions(+), 485 deletions(-) diff --git a/climada/trajectories/impact_calc_strat.py b/climada/trajectories/impact_calc_strat.py index 7620a7b37..23168caec 100644 --- a/climada/trajectories/impact_calc_strat.py +++ b/climada/trajectories/impact_calc_strat.py @@ -124,13 +124,9 @@ def calculate_residual_or_risk_transfer_impact_matrix( scipy.sparse.csr_matrix The adjusted impact matrix, either residual or risk transfer. - Example - ------- - >>> calc_residual_or_risk_transf_imp_mat(imp_mat, attachment=100, cover=500, calc_residual=True) - Residual impact matrix with applied risk layer adjustments. """ + if risk_transf_attach and risk_transf_cover: - # Make a copy of the impact matrix imp_mat = copy.deepcopy(imp_mat) # Calculate the total impact per event total_at_event = imp_mat.sum(axis=1).A1 @@ -138,19 +134,15 @@ def calculate_residual_or_risk_transfer_impact_matrix( transfer_at_event = np.minimum( np.maximum(total_at_event - risk_transf_attach, 0), risk_transf_cover ) - # Resiudal impact residual_at_event = np.maximum(total_at_event - transfer_at_event, 0) # Calculate either the residual or transfer impact matrix # Choose the denominator to rescale the impact values if calc_residual: - # Rescale the impact values numerator = residual_at_event else: - # Rescale the impact values numerator = transfer_at_event - # Rescale the impact values rescale_impact_values = np.divide( numerator, total_at_event, diff --git a/climada/trajectories/interpolation.py b/climada/trajectories/interpolation.py index 46d523d89..6f1469faf 100644 --- a/climada/trajectories/interpolation.py +++ b/climada/trajectories/interpolation.py @@ -1,8 +1,30 @@ +""" +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 logging from abc import ABC, abstractmethod import numpy as np -from scipy.sparse import lil_matrix +from scipy.sparse import csr_matrix, lil_matrix LOGGER = logging.getLogger(__name__) @@ -21,7 +43,7 @@ def interpolate(self, imp_E0, imp_E1, time_points: int): try: return self.interpolate_imp_mat(imp_E0, imp_E1, time_points) except ValueError as e: - if str(e) == "inconsistent shape": + if str(e) == "inconsistent shapes": raise ValueError( "Interpolation between impact matrices of different shapes" ) @@ -61,7 +83,7 @@ def interpolate_sm(mat_start, mat_end, time, time_points): # Perform the linear interpolation mat_interpolated = mat_start + ratio * (mat_end - mat_start) - return mat_interpolated + return csr_matrix(mat_interpolated) LOGGER.debug(f"imp0: {imp0.imp_mat.data[0]}, imp1: {imp1.imp_mat.data[0]}") return [ @@ -70,19 +92,11 @@ def interpolate_sm(mat_start, mat_end, time, time_points): ] -class ExponentialInterpolation: +class ExponentialInterpolation(InterpolationStrategy): """Exponential interpolation strategy.""" def interpolate(self, imp_E0, imp_E1, time_points: int): - try: - return self.interpolate_imp_mat(imp_E0, imp_E1, time_points) - except ValueError as e: - if str(e) == "inconsistent shape": - raise ValueError( - "Interpolation between impact matrices of different shapes" - ) - else: - raise e + return self.interpolate_imp_mat(imp_E0, imp_E1, time_points) @staticmethod def interpolate_imp_mat(imp0, imp1, time_points): @@ -119,15 +133,9 @@ def interpolate_sm(mat_start, mat_end, time, time_points): # Convert back to the original domain using the exponential function mat_interpolated = np.exp(log_mat_interpolated) - return lil_matrix(mat_interpolated) + return csr_matrix(mat_interpolated) return [ interpolate_sm(imp0.imp_mat, imp1.imp_mat, time, time_points) for time in range(time_points) ] - - -# Example usage -# Assuming imp0 and imp1 are instances of ImpactCalc with imp_mat attributes as sparse matrices -# interpolator = ExponentialInterpolation() -# interpolated_matrices = interpolator.interpolate(imp0, imp1, 100) diff --git a/climada/trajectories/risk_trajectory.py b/climada/trajectories/risk_trajectory.py index 3322bf7fe..a9f69af0f 100644 --- a/climada/trajectories/risk_trajectory.py +++ b/climada/trajectories/risk_trajectory.py @@ -23,7 +23,6 @@ import logging import matplotlib.pyplot as plt -import numpy as np import pandas as pd from climada.entity.disc_rates.base import DiscRates diff --git a/climada/trajectories/riskperiod.py b/climada/trajectories/riskperiod.py index 4b64bbe92..0ef8aa8ea 100644 --- a/climada/trajectories/riskperiod.py +++ b/climada/trajectories/riskperiod.py @@ -41,15 +41,19 @@ def lazy_property(method): + # This function is used as a decorator for properties + # that require "heavy" computation and are not always needed + # if the property is none, it uses the corresponding computation method + # and stores the result in the corresponding private attribute attr_name = f"_{method.__name__}" @property def _lazy(self): if getattr(self, attr_name) is None: - meas_n = self.measure.name if self.measure else "no_measure" - LOGGER.debug( - f"Computing {method.__name__} for {self._snapshot0.date}-{self._snapshot1.date} with {meas_n}." - ) + # meas_n = self.measure.name if self.measure else "no_measure" + # LOGGER.debug( + # f"Computing {method.__name__} for {self._snapshot0.date}-{self._snapshot1.date} with {meas_n}." + # ) setattr(self, attr_name, method(self)) return getattr(self, attr_name) @@ -57,13 +61,43 @@ def _lazy(self): class CalcRiskPeriod: - """Handles the computation of impacts for a risk period.""" + """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 DateTime index build on + `interval_freq` or `time_points`. + + Attributes + ---------- + + date_idx: pd.DateTimeIndex + 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 + risk_transf_attach: float, optional + The attachement of risk transfer to apply. Defaults to None. + risk_transf_cover: float, optional + The cover of risk transfer to apply. Defaults to None. + calc_residual: bool, optional + A boolean stating whether the residual (True) or transfered risk (False) is retained when doing + the risk transfer. Defaults to False. + measure: Measure, optional + The measure to apply to both snapshots. Defaults to None. + + Notes + ----- + + This class is intended for internal computation. Users should favor `RiskTrajectory` objects. + """ def __init__( self, snapshot0: Snapshot, snapshot1: Snapshot, - interval_freq: str | None = "YS", + interval_freq: str | None = "AS-JAN", time_points: int | None = None, interpolation_strategy: InterpolationStrategy | None = None, impact_computation_strategy: ImpactComputationStrategy | None = None, @@ -99,6 +133,7 @@ def _reset_impact_data(self): self._imp_mats_E0, self._imp_mats_E1 = None, None self._per_date_eai_H0, self._per_date_eai_H1 = None, None self._per_date_aai_H0, self._per_date_aai_H1 = None, None + self._eai_gdf = None self._per_date_return_periods_H0, self._per_date_return_periods_H1 = None, None @staticmethod @@ -146,12 +181,18 @@ def _set_date_idx( periods=points, freq=freq, # type: ignore name=name, + normalize=True, ) if periods is not None and len(ret) != periods: raise ValueError( "Number of periods and frequency given to date_range are inconsistant" ) + if pd.infer_freq(ret) != freq: + LOGGER.debug( + f"Given interval frequency ( {pd.infer_freq(ret)} ) and infered interval frequency differ ( {freq} )." + ) + return ret @property @@ -171,7 +212,7 @@ def date_idx(self, value, /): if not isinstance(value, pd.DatetimeIndex): raise ValueError("Not a DatetimeIndex") - self._date_idx = value + self._date_idx = value.normalize() self._time_points = len(self.date_idx) self._interval_freq = pd.infer_freq(self.date_idx) self._prop_H1 = np.linspace(0, 1, num=self.time_points) diff --git a/climada/trajectories/snapshot.py b/climada/trajectories/snapshot.py index 617cdb6aa..b3cdf4995 100644 --- a/climada/trajectories/snapshot.py +++ b/climada/trajectories/snapshot.py @@ -46,9 +46,10 @@ class Snapshot: Notes ----- - The object creates copies of the exposure hazard and impact function set. + The object creates deep copies of the exposure hazard and impact function set. - To create a snapshot with a measure use Snapshot.apply_measure(measure). + 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. """ def __init__( @@ -97,6 +98,18 @@ def _convert_to_date(date_arg) -> datetime.date: raise TypeError("date_arg must be an int, str, or datetime.date") def apply_measure(self, measure: Measure): + """Create a new snapshot from a measure + + This methods creates a new `Snapshot` object by applying a measure on + the current one. + + Parameters + ---------- + measure : Measure + The measure to be applied to the snapshot + + """ + LOGGER.debug(f"Applying measure {measure.name} on snapshot {id(self)}") exp_new, impfset_new, haz_new = measure.apply( self.exposure, self.impfset, self.hazard diff --git a/doc/tutorial/climada_trajectories.ipynb b/doc/tutorial/climada_trajectories.ipynb index 12e2158d5..875967880 100644 --- a/doc/tutorial/climada_trajectories.ipynb +++ b/doc/tutorial/climada_trajectories.ipynb @@ -77,6 +77,16 @@ "/home/sjuhel/miniforge3/envs/cb_refactoring/lib/python3.10/site-packages/dask/dataframe/_pyarrow_compat.py:15: FutureWarning: Minimal version of pyarrow will soon be increased to 14.0.1. You are using 12.0.1. Please consider upgrading.\n", " warnings.warn(\n" ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-05-13 16:49:57,986 - climada.entity.exposures.base - INFO - Reading /home/sjuhel/climada/data/exposures/litpop/LitPop_150arcsec_HTI/v3/LitPop_150arcsec_HTI.hdf5\n", + "2025-05-13 16:50:03,270 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020/v2/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020.hdf5\n", + "2025-05-13 16:50:03,306 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-13 16:50:03,308 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n" + ] } ], "source": [ @@ -114,6 +124,13 @@ "scrolled": true }, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-05-13 16:50:03,667 - climada.util.coordinates - INFO - Raster from resolution 0.04166665999999708 to 0.04166665999999708.\n" + ] + }, { "data": { "text/plain": [ @@ -178,7 +195,19 @@ "execution_count": 3, "id": "c516c861-c5c1-475b-82e2-c867c5c08ec9", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-05-13 16:50:25,814 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2040/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2040.hdf5\n", + "2025-05-13 16:50:25,851 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-13 16:50:25,852 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-13 16:50:25,852 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-13 16:50:25,854 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n" + ] + } + ], "source": [ "import copy\n", "\n", @@ -288,7 +317,15 @@ "execution_count": 7, "id": "c644d470-7fd3-461e-97fd-d23d40f7abd9", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-05-13 16:50:25,998 - climada.trajectories.riskperiod - INFO - Instantiating new CalcRiskPeriod.\n" + ] + } + ], "source": [ "from climada.trajectories.risk_trajectory import RiskTrajectory\n", "\n", @@ -310,162 +347,37 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "id": "866db75c-5b21-4134-9f4e-f7213ad49f18", "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", - " \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", - "
periodgroupmeasuremetricrisk
02018-01-01 to 2040-01-010no_measureaai2.268384e+11
12018-01-01 to 2040-01-011no_measureaai3.391447e+08
22018-01-01 to 2040-01-01Allno_measureaai9.960186e+09
32018-01-01 to 2040-01-01Allno_measurebase risk4.232995e+09
42018-01-01 to 2040-01-01Allno_measuredelta from exposure5.186536e+09
52018-01-01 to 2040-01-01Allno_measuredelta from hazard5.406561e+08
62018-01-01 to 2040-01-01Allno_measurerp_1003.288826e+11
72018-01-01 to 2040-01-01Allno_measurerp_501.886460e+11
82018-01-01 to 2040-01-01Allno_measurerp_5008.369369e+11
\n", - "
" - ], - "text/plain": [ - " period group measure metric \\\n", - "0 2018-01-01 to 2040-01-01 0 no_measure aai \n", - "1 2018-01-01 to 2040-01-01 1 no_measure aai \n", - "2 2018-01-01 to 2040-01-01 All no_measure aai \n", - "3 2018-01-01 to 2040-01-01 All no_measure base risk \n", - "4 2018-01-01 to 2040-01-01 All no_measure delta from exposure \n", - "5 2018-01-01 to 2040-01-01 All no_measure delta from hazard \n", - "6 2018-01-01 to 2040-01-01 All no_measure rp_100 \n", - "7 2018-01-01 to 2040-01-01 All no_measure rp_50 \n", - "8 2018-01-01 to 2040-01-01 All no_measure rp_500 \n", - "\n", - " risk \n", - "0 2.268384e+11 \n", - "1 3.391447e+08 \n", - "2 9.960186e+09 \n", - "3 4.232995e+09 \n", - "4 5.186536e+09 \n", - "5 5.406561e+08 \n", - "6 3.288826e+11 \n", - "7 1.886460e+11 \n", - "8 8.369369e+11 " - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "risk_traj.total_risk_metrics" - ] - }, - { - "cell_type": "markdown", - "id": "ff6d6915-805f-46a9-8552-c03c635fe2d5", - "metadata": {}, - "source": [ - "Or on a per-date basis:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "67efba39-11b6-40fc-b5dd-a8799ec00c12", - "metadata": {}, - "outputs": [ + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-05-13 16:50:39,073 - climada.trajectories.riskperiod - INFO - Instantiating new CalcRiskPeriod.\n", + "2025-05-13 16:50:39,077 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-13 16:50:39,078 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-13 16:50:39,078 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-13 16:50:39,080 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-13 16:50:39,086 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-05-13 16:50:39,097 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-13 16:50:39,098 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-13 16:50:39,098 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-13 16:50:39,101 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-13 16:50:39,106 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-05-13 16:50:39,118 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-13 16:50:39,119 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-13 16:50:39,120 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-13 16:50:39,121 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-13 16:50:39,127 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-05-13 16:50:39,139 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-13 16:50:39,140 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-13 16:50:39,141 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-13 16:50:39,142 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-13 16:50:39,146 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n" + ] + }, { "data": { "text/html": [ @@ -544,111 +456,119 @@ " ...\n", " \n", " \n", - " 64\n", + " 41\n", " 2036-01-01\n", - " All\n", + " 1\n", " no_measure\n", - " delta from hazard\n", - " 4.288923e+07\n", + " aai\n", + " 5.950431e+08\n", " \n", " \n", - " 65\n", + " 42\n", " 2037-01-01\n", - " All\n", + " 1\n", " no_measure\n", - " delta from hazard\n", - " 4.682841e+07\n", + " aai\n", + " 6.194455e+08\n", " \n", " \n", - " 66\n", + " 43\n", " 2038-01-01\n", - " All\n", + " 1\n", " no_measure\n", - " delta from hazard\n", - " 5.093143e+07\n", + " aai\n", + " 6.440116e+08\n", " \n", " \n", - " 67\n", + " 44\n", " 2039-01-01\n", - " All\n", + " 1\n", " no_measure\n", - " delta from hazard\n", - " 5.519828e+07\n", + " aai\n", + " 6.687412e+08\n", " \n", " \n", - " 68\n", + " 45\n", " 2040-01-01\n", - " All\n", + " 1\n", " no_measure\n", - " delta from hazard\n", - " 5.962897e+07\n", + " aai\n", + " 6.936344e+08\n", " \n", " \n", "\n", - "

207 rows × 5 columns

\n", + "

138 rows × 5 columns

\n", "" ], "text/plain": [ - " date group measure metric risk\n", - "0 2018-01-01 All no_measure aai 1.840432e+08\n", - "1 2019-01-01 All no_measure aai 2.055335e+08\n", - "2 2020-01-01 All no_measure aai 2.271876e+08\n", - "3 2021-01-01 All no_measure aai 2.490056e+08\n", - "4 2022-01-01 All no_measure aai 2.709873e+08\n", - ".. ... ... ... ... ...\n", - "64 2036-01-01 All no_measure delta from hazard 4.288923e+07\n", - "65 2037-01-01 All no_measure delta from hazard 4.682841e+07\n", - "66 2038-01-01 All no_measure delta from hazard 5.093143e+07\n", - "67 2039-01-01 All no_measure delta from hazard 5.519828e+07\n", - "68 2040-01-01 All no_measure delta from hazard 5.962897e+07\n", + " date group measure metric risk\n", + "0 2018-01-01 All no_measure aai 1.840432e+08\n", + "1 2019-01-01 All no_measure aai 2.055335e+08\n", + "2 2020-01-01 All no_measure aai 2.271876e+08\n", + "3 2021-01-01 All no_measure aai 2.490056e+08\n", + "4 2022-01-01 All no_measure aai 2.709873e+08\n", + ".. ... ... ... ... ...\n", + "41 2036-01-01 1 no_measure aai 5.950431e+08\n", + "42 2037-01-01 1 no_measure aai 6.194455e+08\n", + "43 2038-01-01 1 no_measure aai 6.440116e+08\n", + "44 2039-01-01 1 no_measure aai 6.687412e+08\n", + "45 2040-01-01 1 no_measure aai 6.936344e+08\n", "\n", - "[207 rows x 5 columns]" + "[138 rows x 5 columns]" ] }, - "execution_count": 9, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "risk_traj.per_date_risk_metrics" + "risk_traj.per_date_risk_metrics()" ] }, { "cell_type": "markdown", - "id": "00e0a09b-9dd6-4378-81a1-cda5290f9aa4", + "id": "ff6d6915-805f-46a9-8552-c03c635fe2d5", "metadata": {}, "source": [ - "You can also plot the \"components\" of the change in risk via a waterfall graph, both over the whole period:" + "Or on a per-date basis:" ] }, { "cell_type": "code", - "execution_count": 10, - "id": "08c226a4-944b-4301-acfa-602adde980a5", + "execution_count": 11, + "id": "67efba39-11b6-40fc-b5dd-a8799ec00c12", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + ">" ] }, - "execution_count": 10, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], + "source": [ + "risk_traj.per_date_risk_metrics" + ] + }, + { + "cell_type": "markdown", + "id": "00e0a09b-9dd6-4378-81a1-cda5290f9aa4", + "metadata": {}, + "source": [ + "You can also plot the \"components\" of the change in risk via a waterfall graph, both over the whole period:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "08c226a4-944b-4301-acfa-602adde980a5", + "metadata": {}, + "outputs": [], "source": [ "risk_traj.plot_waterfall()" ] @@ -663,31 +583,10 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "cf40380a-5814-4164-a592-7ab181776b5a", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "risk_traj.plot_per_date_waterfall()" ] @@ -718,124 +617,20 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "id": "4af17732-708b-48e0-938b-afb962a7d29d", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Impact function sets differ. Will update the first one with the second.\n" - ] - } - ], + "outputs": [], "source": [ "grouped_risk_traj = RiskTrajectory(snapcol, compute_groups=True)" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "id": "ff4da4a5-a2bc-4697-b829-43c4b05776d2", "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", - " \n", - " \n", - "
periodgroupmeasuremetricrisk
02018-01-01 to 2040-01-010no_measureaai1.487445e+07
12018-01-01 to 2040-01-011no_measureaai9.945312e+09
22018-01-01 to 2040-01-01Allno_measureaai9.960186e+09
32018-01-01 to 2040-01-01Allno_measurerp_1003.288826e+11
42018-01-01 to 2040-01-01Allno_measurerp_10008.369369e+11
52018-01-01 to 2040-01-01Allno_measurerp_5008.369369e+11
\n", - "
" - ], - "text/plain": [ - " period group measure metric risk\n", - "0 2018-01-01 to 2040-01-01 0 no_measure aai 1.487445e+07\n", - "1 2018-01-01 to 2040-01-01 1 no_measure aai 9.945312e+09\n", - "2 2018-01-01 to 2040-01-01 All no_measure aai 9.960186e+09\n", - "3 2018-01-01 to 2040-01-01 All no_measure rp_100 3.288826e+11\n", - "4 2018-01-01 to 2040-01-01 All no_measure rp_1000 8.369369e+11\n", - "5 2018-01-01 to 2040-01-01 All no_measure rp_500 8.369369e+11" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "grouped_risk_traj.total_risk_metrics" ] @@ -868,7 +663,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "id": "651e31cb-5a55-4a22-a7c3-b5f79b3a20ef", "metadata": {}, "outputs": [], @@ -883,132 +678,30 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "id": "d86bedbb-6c0a-4f7d-a63e-5012510339d3", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Impact function sets differ. Will update the first one with the second.\n" - ] - } - ], + "outputs": [], "source": [ "discounted_risk_traj = RiskTrajectory(snapcol, risk_disc=discount_stern)" ] }, { "cell_type": "code", - "execution_count": 38, + "execution_count": null, "id": "1d436f15-020a-40e2-8db7-869b5e3a10a1", "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", - "
periodmeasuremetricrisk
02018-01-01 to 2040-01-01no_measureaai8.303380e+09
12018-01-01 to 2040-01-01no_measurerp_1002.737759e+11
22018-01-01 to 2040-01-01no_measurerp_10007.023722e+11
32018-01-01 to 2040-01-01no_measurerp_5007.023722e+11
\n", - "
" - ], - "text/plain": [ - " period measure metric risk\n", - "0 2018-01-01 to 2040-01-01 no_measure aai 8.303380e+09\n", - "1 2018-01-01 to 2040-01-01 no_measure rp_100 2.737759e+11\n", - "2 2018-01-01 to 2040-01-01 no_measure rp_1000 7.023722e+11\n", - "3 2018-01-01 to 2040-01-01 no_measure rp_500 7.023722e+11" - ] - }, - "execution_count": 38, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "discounted_risk_traj.total_risk_metrics" ] }, { "cell_type": "code", - "execution_count": 48, + "execution_count": null, "id": "0f732fc0-21b6-456d-9d97-662aa1b8cf15", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 48, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", @@ -1031,6 +724,22 @@ " color=\"red\",\n", ")" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "98fc7fe1-b013-4356-ab13-007c7b74b77b", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ce42cd76-bf1e-4f16-b689-c398f7f05c8b", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 9aec92fa03dbbf052fd06bc52a33a18419c57d1b Mon Sep 17 00:00:00 2001 From: spjuhel Date: Wed, 14 May 2025 18:42:20 +0200 Subject: [PATCH 023/113] test: adds lots of unittests, and placeholders --- climada/test/test_trajectories.py | 2 + .../test/test_impact_calc_strat.py | 138 ++++ .../trajectories/test/test_interpolation.py | 120 ++++ .../trajectories/test/test_risk_trajectory.py | 21 + climada/trajectories/test/test_riskperiod.py | 658 ++++++++++++++++++ climada/trajectories/test/test_snapshot.py | 110 +++ 6 files changed, 1049 insertions(+) create mode 100644 climada/test/test_trajectories.py create mode 100644 climada/trajectories/test/test_impact_calc_strat.py create mode 100644 climada/trajectories/test/test_interpolation.py create mode 100644 climada/trajectories/test/test_risk_trajectory.py create mode 100644 climada/trajectories/test/test_riskperiod.py create mode 100644 climada/trajectories/test/test_snapshot.py diff --git a/climada/test/test_trajectories.py b/climada/test/test_trajectories.py new file mode 100644 index 000000000..926c31122 --- /dev/null +++ b/climada/test/test_trajectories.py @@ -0,0 +1,2 @@ +# 100% Coverage goal: +## Integration test for risk period with periods and freq defined 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 000000000..1da2e8ddd --- /dev/null +++ b/climada/trajectories/test/test_impact_calc_strat.py @@ -0,0 +1,138 @@ +""" +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 + +import numpy as np +from scipy.sparse import csr_matrix + +from climada.trajectories.impact_calc_strat import ( + Impact, + ImpactCalcComputation, + Snapshot, +) + + +class TestImpactCalcComputation(unittest.TestCase): + def setUp(self): + self.mock_snapshot0 = MagicMock(spec=Snapshot) + self.mock_snapshot1 = MagicMock(spec=Snapshot) + + self.impact_calc_computation = ImpactCalcComputation() + + @patch.object(ImpactCalcComputation, "_calculate_impacts_for_snapshots") + @patch.object(ImpactCalcComputation, "_apply_risk_transfer") + def test_compute_impacts( + self, mock_apply_risk_transfer, mock_calculate_impacts_for_snapshots + ): + mock_impacts = ( + MagicMock(spec=Impact), + MagicMock(spec=Impact), + MagicMock(spec=Impact), + MagicMock(spec=Impact), + ) + mock_calculate_impacts_for_snapshots.return_value = mock_impacts + + result = self.impact_calc_computation.compute_impacts( + self.mock_snapshot0, self.mock_snapshot1, 0.1, 0.9, False + ) + + self.assertEqual(result, mock_impacts) + mock_calculate_impacts_for_snapshots.assert_called_once_with( + self.mock_snapshot0, self.mock_snapshot1 + ) + mock_apply_risk_transfer.assert_called_once_with(mock_impacts, 0.1, 0.9, False) + + def test_calculate_impacts_for_snapshots(self): + mock_imp_E0H0 = MagicMock(spec=Impact) + mock_imp_E1H0 = MagicMock(spec=Impact) + mock_imp_E0H1 = MagicMock(spec=Impact) + mock_imp_E1H1 = 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, + mock_imp_E1H0, + mock_imp_E0H1, + mock_imp_E1H1, + ] + + result = self.impact_calc_computation._calculate_impacts_for_snapshots( + self.mock_snapshot0, self.mock_snapshot1 + ) + + self.assertEqual( + result, (mock_imp_E0H0, mock_imp_E1H0, mock_imp_E0H1, mock_imp_E1H1) + ) + + def test_apply_risk_transfer(self): + mock_imp_E0H0 = MagicMock(spec=Impact) + mock_imp_E0H0.imp_mat = MagicMock(spec=csr_matrix) + + mock_imp_E1H0 = MagicMock(spec=Impact) + mock_imp_E1H0.imp_mat = MagicMock(spec=csr_matrix) + + mock_imp_E0H1 = MagicMock(spec=Impact) + mock_imp_E0H1.imp_mat = MagicMock(spec=csr_matrix) + + mock_imp_E1H1 = MagicMock(spec=Impact) + mock_imp_E1H1.imp_mat = MagicMock(spec=csr_matrix) + + mock_impacts = (mock_imp_E0H0, mock_imp_E1H0, mock_imp_E0H1, mock_imp_E1H1) + + mock_imp_resi = MagicMock(spec=csr_matrix) + + with patch.object( + self.impact_calc_computation, + "calculate_residual_or_risk_transfer_impact_matrix", + ) as mock_calc_risk_transfer: + mock_calc_risk_transfer.return_value = mock_imp_resi + self.impact_calc_computation._apply_risk_transfer( + mock_impacts, 0.1, 0.9, False + ) + + self.assertIs(mock_impacts[0].imp_mat, mock_imp_resi) + self.assertIs(mock_impacts[1].imp_mat, mock_imp_resi) + self.assertIs(mock_impacts[2].imp_mat, mock_imp_resi) + self.assertIs(mock_impacts[3].imp_mat, mock_imp_resi) + + def test_calculate_residual_or_risk_transfer_impact_matrix(self): + imp_mat = MagicMock() + imp_mat.sum.return_value.A1 = np.array([100, 200, 300]) + imp_mat.multiply.return_value = "rescaled_matrix" + + result = self.impact_calc_computation.calculate_residual_or_risk_transfer_impact_matrix( + imp_mat, 0.1, 0.9, True + ) + self.assertEqual(result, "rescaled_matrix") + + result = self.impact_calc_computation.calculate_residual_or_risk_transfer_impact_matrix( + imp_mat, 0.1, 0.9, False + ) + self.assertEqual(result, "rescaled_matrix") + + +if __name__ == "__main__": + unittest.main() diff --git a/climada/trajectories/test/test_interpolation.py b/climada/trajectories/test/test_interpolation.py new file mode 100644 index 000000000..e88aace90 --- /dev/null +++ b/climada/trajectories/test/test_interpolation.py @@ -0,0 +1,120 @@ +""" +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 ( + ExponentialInterpolation, + LinearInterpolation, +) + + +class TestLinearInterpolation(unittest.TestCase): + def setUp(self): + # Create mock impact matrices for testing + self.imp0 = MagicMock() + self.imp1 = MagicMock() + self.imp0.imp_mat = csr_matrix(np.array([[1, 2], [3, 4]])) + self.imp1.imp_mat = csr_matrix(np.array([[5, 6], [7, 8]])) + self.time_points = 5 + + # Create an instance of LinearInterpolation + self.linear_interpolation = LinearInterpolation() + + def test_interpolate(self): + result = self.linear_interpolation.interpolate( + self.imp0, self.imp1, 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_interpolate_inconsistent_shape(self): + imp0 = MagicMock() + imp1 = MagicMock() + imp0.imp_mat = csr_matrix(np.array([[1, 2], [3, 4]])) + imp1.imp_mat = csr_matrix(np.array([[5, 6, 7], [8, 9, 10]])) # Different shape + + with self.assertRaises(ValueError): + self.linear_interpolation.interpolate(imp0, imp1, self.time_points) + + +class TestExponentialInterpolation(unittest.TestCase): + def setUp(self): + # Create mock impact matrices for testing + self.imp0 = MagicMock() + self.imp1 = MagicMock() + self.imp0.imp_mat = csr_matrix(np.array([[1, 2], [3, 4]])) + self.imp1.imp_mat = csr_matrix(np.array([[5, 6], [7, 8]])) + self.time_points = 5 + + # Create an instance of ExponentialInterpolation + self.exponential_interpolation = ExponentialInterpolation() + + def test_interpolate(self): + result = self.exponential_interpolation.interpolate( + self.imp0, self.imp1, 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_interpolate_inconsistent_shape(self): + imp0 = MagicMock() + imp1 = MagicMock() + imp0.imp_mat = csr_matrix(np.array([[1, 2], [3, 4]])) + imp1.imp_mat = csr_matrix(np.array([[5, 6, 7], [8, 9, 10]])) # Different shape + + with self.assertRaises(ValueError): + self.exponential_interpolation.interpolate(imp0, imp1, self.time_points) + + +if __name__ == "__main__": + unittest.main() diff --git a/climada/trajectories/test/test_risk_trajectory.py b/climada/trajectories/test/test_risk_trajectory.py new file mode 100644 index 000000000..d5b6cd66b --- /dev/null +++ b/climada/trajectories/test/test_risk_trajectory.py @@ -0,0 +1,21 @@ +""" +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 + +""" diff --git a/climada/trajectories/test/test_riskperiod.py b/climada/trajectories/test/test_riskperiod.py new file mode 100644 index 000000000..265ad389e --- /dev/null +++ b/climada/trajectories/test/test_riskperiod.py @@ -0,0 +1,658 @@ +""" +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 types +import unittest +from unittest.mock import MagicMock, patch + +import geopandas as gpd +import numpy as np +import pandas as pd +from scipy.sparse import csr_matrix +from shapely import Point + +# 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 + +# Import the CalcRiskPeriod class and other necessary classes/functions +from climada.trajectories.riskperiod import ( + CalcRiskPeriod, + ImpactCalcComputation, + ImpactComputationStrategy, + InterpolationStrategy, + LinearInterpolation, + Snapshot, +) +from climada.util.constants import EXP_DEMO_H5, HAZ_DEMO_H5 + + +class TestCalcRiskPeriod_TopLevel(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"] = ( + self.exposure_present.gdf["value"] > 500000 + ) * 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"] = ( + self.exposure_future.gdf["value"] > 500000 + ) * 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_snapshot0 = Snapshot( + self.exposure_present, + self.hazard_present, + self.impfset_present, + self.present_date, + ) + self.mock_snapshot1 = Snapshot( + self.exposure_future, + self.hazard_future, + self.impfset_future, + self.future_date, + ) + + # Create an instance of CalcRiskPeriod + self.calc_risk_period = CalcRiskPeriod( + self.mock_snapshot0, + self.mock_snapshot1, + interval_freq="AS-JAN", + interpolation_strategy=LinearInterpolation(), + impact_computation_strategy=ImpactCalcComputation(), + # These will have to be tested when implemented + # risk_transf_attach=0.1, + # risk_transf_cover=0.9, + # calc_residual=False + ) + + def test_init(self): + self.assertEqual(self.calc_risk_period.snapshot0, self.mock_snapshot0) + self.assertEqual(self.calc_risk_period.snapshot1, self.mock_snapshot1) + self.assertEqual(self.calc_risk_period.interval_freq, "AS-JAN") + self.assertEqual( + self.calc_risk_period.time_points, self.future_date - self.present_date + 1 + ) + self.assertIsInstance( + self.calc_risk_period.interpolation_strategy, LinearInterpolation + ) + self.assertIsInstance( + self.calc_risk_period.impact_computation_strategy, ImpactCalcComputation + ) + np.testing.assert_array_equal( + self.calc_risk_period._group_id_E0, + self.mock_snapshot0.exposure.gdf["group_id"].values, + ) + np.testing.assert_array_equal( + self.calc_risk_period._group_id_E1, + self.mock_snapshot1.exposure.gdf["group_id"].values, + ) + self.assertIsInstance(self.calc_risk_period.date_idx, pd.DatetimeIndex) + self.assertEqual( + len(self.calc_risk_period.date_idx), + self.future_date - self.present_date + 1, + ) + + def test_set_date_idx_wrong_type(self): + with self.assertRaises(ValueError): + self.calc_risk_period.date_idx = "A" + + def test_set_date_idx_periods(self): + new_date_idx = pd.date_range("2023-01-01", "2023-12-01", periods=24) + self.calc_risk_period.date_idx = new_date_idx + self.assertEqual(len(self.calc_risk_period.date_idx), 24) + + def test_set_date_idx_freq(self): + new_date_idx = pd.date_range("2023-01-01", "2023-12-01", freq="MS") + self.calc_risk_period.date_idx = new_date_idx + self.assertEqual(len(self.calc_risk_period.date_idx), 12) + pd.testing.assert_index_equal( + self.calc_risk_period.date_idx, + pd.date_range("2023-01-01", "2023-12-01", freq="MS", normalize=True), + ) + + def test_set_time_points(self): + self.calc_risk_period.time_points = 10 + self.assertEqual(self.calc_risk_period.time_points, 10) + self.assertEqual(len(self.calc_risk_period.date_idx), 10) + pd.testing.assert_index_equal( + self.calc_risk_period.date_idx, + pd.DatetimeIndex( + pd.DatetimeIndex( + [ + "2020-01-01", + "2020-07-22", + "2021-02-10", + "2021-09-01", + "2022-03-23", + "2022-10-12", + "2023-05-03", + "2023-11-22", + "2024-06-12", + "2025-01-01", + ], + name="date", + ) + ), + ) + + def test_set_time_points_wtype(self): + with self.assertRaises(ValueError): + self.calc_risk_period.time_points = "1" + + def test_set_interval_freq(self): + self.calc_risk_period.interval_freq = "MS" + self.assertEqual(self.calc_risk_period.interval_freq, "MS") + pd.testing.assert_index_equal( + self.calc_risk_period.date_idx, + pd.DatetimeIndex( + pd.DatetimeIndex( + [ + "2020-01-01", + "2020-02-01", + "2020-03-01", + "2020-04-01", + "2020-05-01", + "2020-06-01", + "2020-07-01", + "2020-08-01", + "2020-09-01", + "2020-10-01", + "2020-11-01", + "2020-12-01", + "2021-01-01", + "2021-02-01", + "2021-03-01", + "2021-04-01", + "2021-05-01", + "2021-06-01", + "2021-07-01", + "2021-08-01", + "2021-09-01", + "2021-10-01", + "2021-11-01", + "2021-12-01", + "2022-01-01", + "2022-02-01", + "2022-03-01", + "2022-04-01", + "2022-05-01", + "2022-06-01", + "2022-07-01", + "2022-08-01", + "2022-09-01", + "2022-10-01", + "2022-11-01", + "2022-12-01", + "2023-01-01", + "2023-02-01", + "2023-03-01", + "2023-04-01", + "2023-05-01", + "2023-06-01", + "2023-07-01", + "2023-08-01", + "2023-09-01", + "2023-10-01", + "2023-11-01", + "2023-12-01", + "2024-01-01", + "2024-02-01", + "2024-03-01", + "2024-04-01", + "2024-05-01", + "2024-06-01", + "2024-07-01", + "2024-08-01", + "2024-09-01", + "2024-10-01", + "2024-11-01", + "2024-12-01", + "2025-01-01", + ], + name="date", + ) + ), + ) + + def test_set_interpolation_strategy(self): + new_interpolation_strategy = MagicMock(spec=InterpolationStrategy) + self.calc_risk_period.interpolation_strategy = new_interpolation_strategy + self.assertEqual( + self.calc_risk_period.interpolation_strategy, new_interpolation_strategy + ) + + def test_set_interpolation_strategy_wtype(self): + with self.assertRaises(ValueError): + self.calc_risk_period.interpolation_strategy = "A" + + def test_set_impact_computation_strategy(self): + new_impact_computation_strategy = MagicMock(spec=ImpactComputationStrategy) + self.calc_risk_period.impact_computation_strategy = ( + new_impact_computation_strategy + ) + self.assertEqual( + self.calc_risk_period.impact_computation_strategy, + new_impact_computation_strategy, + ) + + def test_set_impact_computation_strategy_wtype(self): + with self.assertRaises(ValueError): + self.calc_risk_period.impact_computation_strategy = "A" + + def test_set_calc_residual_wtype(self): + with self.assertRaises(ValueError): + self.calc_risk_period.calc_residual = "A" + + # The computation are tested in the CalcImpactStrategy / InterpolationStrategy tests + # Here we just make sure that the calling works + @patch.object(CalcRiskPeriod, "impact_computation_strategy") + def test_impacts_arrays(self, mock_impact_compute): + mock_impact_compute.compute_impacts.return_value = 1 + self.assertEqual(self.calc_risk_period.impacts_arrays, 1) + mock_impact_compute.compute_impacts.assert_called_with( + self.calc_risk_period.snapshot0, + self.calc_risk_period.snapshot1, + self.calc_risk_period.risk_transf_attach, + self.calc_risk_period.risk_transf_cover, + self.calc_risk_period.calc_residual, + ) + + @patch.object(CalcRiskPeriod, "interpolation_strategy") + def test_imp_mats_H0(self, mock_interpolate): + mock_interpolate.interpolate.return_value = 1 + result = self.calc_risk_period.imp_mats_H0 + self.assertEqual(result, 1) + mock_interpolate.interpolate.assert_called_with( + self.calc_risk_period._E0H0, + self.calc_risk_period._E1H0, + self.calc_risk_period.time_points, + ) + + @patch.object(CalcRiskPeriod, "interpolation_strategy") + def test_imp_mats_H1(self, mock_interpolate): + mock_interpolate.interpolate.return_value = 1 + result = self.calc_risk_period.imp_mats_H1 + self.assertEqual(result, 1) + mock_interpolate.interpolate.assert_called_with( + self.calc_risk_period._E0H1, + self.calc_risk_period._E1H1, + self.calc_risk_period.time_points, + ) + + @patch.object(CalcRiskPeriod, "interpolation_strategy") + def test_imp_mats_E0(self, mock_interpolate): + mock_interpolate.interpolate.return_value = 1 + result = self.calc_risk_period.imp_mats_E0 + self.assertEqual(result, 1) + mock_interpolate.interpolate.assert_called_with( + self.calc_risk_period._E0H0, + self.calc_risk_period._E0H1, + self.calc_risk_period.time_points, + ) + + @patch.object(CalcRiskPeriod, "interpolation_strategy") + def test_imp_mats_E1(self, mock_interpolate): + mock_interpolate.interpolate.return_value = 1 + result = self.calc_risk_period.imp_mats_E1 + self.assertEqual(result, 1) + mock_interpolate.interpolate.assert_called_with( + self.calc_risk_period._E1H0, + self.calc_risk_period._E1H1, + self.calc_risk_period.time_points, + ) + + @patch.object(CalcRiskPeriod, "calc_per_date_eais", return_value=1) + def test_per_date_eai_H0(self, mock_calc_per_date_eais): + result = self.calc_risk_period.per_date_eai_H0 + self.assertEqual(result, 1) + mock_calc_per_date_eais.assert_called_with( + self.calc_risk_period.imp_mats_H0, + self.calc_risk_period.snapshot0.hazard.frequency, + ) + + @patch.object(CalcRiskPeriod, "calc_per_date_eais", return_value=1) + def test_per_date_eai_H1(self, mock_calc_per_date_eais): + result = self.calc_risk_period.per_date_eai_H1 + self.assertEqual(result, 1) + mock_calc_per_date_eais.assert_called_with( + self.calc_risk_period.imp_mats_H1, + self.calc_risk_period.snapshot1.hazard.frequency, + ) + + @patch.object(CalcRiskPeriod, "calc_per_date_aais", return_value=1) + def test_per_date_aai_H0(self, mock_calc_per_date_aais): + result = self.calc_risk_period.per_date_aai_H0 + self.assertEqual(result, 1) + mock_calc_per_date_aais.assert_called_with( + self.calc_risk_period.per_date_eai_H0 + ) + + @patch.object(CalcRiskPeriod, "calc_per_date_aais", return_value=1) + def test_per_date_aai_H1(self, mock_calc_per_date_aais): + result = self.calc_risk_period.per_date_aai_H1 + self.assertEqual(result, 1) + mock_calc_per_date_aais.assert_called_with( + self.calc_risk_period.per_date_eai_H1 + ) + + @patch.object(CalcRiskPeriod, "calc_per_date_rps", return_value=1) + def test_per_date_return_periods_H0(self, mock_calc_per_date_rps): + result = self.calc_risk_period.per_date_return_periods_H0([10, 50]) + self.assertEqual(result, 1) + mock_calc_per_date_rps.assert_called_with( + self.calc_risk_period.imp_mats_H0, + self.calc_risk_period.snapshot0.hazard.frequency, + [10, 50], + ) + + @patch.object(CalcRiskPeriod, "calc_per_date_rps", return_value=1) + def test_per_date_return_periods_H1(self, mock_calc_per_date_rps): + result = self.calc_risk_period.per_date_return_periods_H1([10, 50]) + self.assertEqual(result, 1) + mock_calc_per_date_rps.assert_called_with( + self.calc_risk_period.imp_mats_H1, + self.calc_risk_period.snapshot1.hazard.frequency, + [10, 50], + ) + + @patch.object(CalcRiskPeriod, "calc_eai_gdf", return_value=1) + def test_eai_gdf(self, mock_calc_eai_gdf): + result = self.calc_risk_period.eai_gdf + mock_calc_eai_gdf.assert_called_once() + self.assertEqual(result, 1) + + # Here we mock the impact calc method just to make sure it is rightfully called + def test_calc_per_date_eais(self): + results = self.calc_risk_period.calc_per_date_eais( + imp_mats=[ + csr_matrix( + [ + [1, 1, 1], + [2, 2, 2], + ] + ), + csr_matrix( + [ + [2, 0, 1], + [2, 0, 2], + ] + ), + ], + frequency=np.array([1, 1]), + ) + np.testing.assert_array_equal(results, np.array([[3, 3, 3], [4, 0, 3]])) + + def test_calc_per_date_aais(self): + results = self.calc_risk_period.calc_per_date_aais( + np.array([[3, 3, 3], [4, 0, 3]]) + ) + np.testing.assert_array_equal(results, np.array([9, 7])) + + def test_calc_freq_curve(self): + results = self.calc_risk_period.calc_freq_curve( + imp_mat_intrpl=csr_matrix( + [ + [0.1, 0, 0], + [1, 0, 0], + [10, 0, 0], + ] + ), + frequency=np.array([0.5, 0.05, 0.005]), + return_per=[10, 50, 100], + ) + np.testing.assert_array_equal(results, np.array([0.55045, 2.575, 5.05])) + + def test_calc_per_date_rps(self): + base_imp = csr_matrix( + [ + [0.1, 0, 0], + [1, 0, 0], + [10, 0, 0], + ] + ) + results = self.calc_risk_period.calc_per_date_rps( + [base_imp, base_imp * 2, base_imp * 4], + frequency=np.array([0.5, 0.05, 0.005]), + return_periods=[10, 50, 100], + ) + np.testing.assert_array_equal( + results, + np.array( + [[0.55045, 2.575, 5.05], [1.1009, 5.15, 10.1], [2.2018, 10.3, 20.2]] + ), + ) + + +class TestCalcRiskPeriod_LowLevel(unittest.TestCase): + def setUp(self): + # Create mock objects for testing + self.calc_risk_period = MagicMock(spec=CalcRiskPeriod) + + # Little trick to bind the mocked object method to the real one + self.calc_risk_period.calc_eai_gdf = types.MethodType( + CalcRiskPeriod.calc_eai_gdf, self.calc_risk_period + ) + self.calc_risk_period.calc_aai_metric = types.MethodType( + CalcRiskPeriod.calc_aai_metric, self.calc_risk_period + ) + self.calc_risk_period.calc_aai_per_group_metric = types.MethodType( + CalcRiskPeriod.calc_aai_per_group_metric, self.calc_risk_period + ) + self.calc_risk_period.calc_return_periods_metric = types.MethodType( + CalcRiskPeriod.calc_return_periods_metric, self.calc_risk_period + ) + self.calc_risk_period.calc_risk_components_metric = types.MethodType( + CalcRiskPeriod.calc_risk_components_metric, self.calc_risk_period + ) + self.calc_risk_period.apply_measure = types.MethodType( + CalcRiskPeriod.apply_measure, self.calc_risk_period + ) + + self.calc_risk_period.per_date_eai_H0 = np.array( + [[1, 0, 1], [1, 2, 0], [3, 3, 3]] + ) + self.calc_risk_period.per_date_eai_H1 = np.array( + [[2, 0, 2], [2, 4, 0], [12, 6, 6]] + ) + self.calc_risk_period.per_date_aai_H0 = np.array([2, 3, 9]) + self.calc_risk_period.per_date_aai_H1 = np.array([4, 6, 24]) + self.calc_risk_period._prop_H0 = np.array([1, 0.5, 0]) + self.calc_risk_period._prop_H1 = 1.0 - self.calc_risk_period._prop_H0 + self.calc_risk_period.date_idx = pd.DatetimeIndex( + ["2020-01-01", "2025-01-01", "2030-01-01"], name="date" + ) + self.calc_risk_period.snapshot1.exposure.gdf = gpd.GeoDataFrame( + { + "group_id": [1, 2, 2], + "geometry": [Point(0, 0), Point(1, 1), Point(2, 2)], + "value": [10, 10, 20], + } + ) + self.calc_risk_period._group_id_E0 = np.array([1, 1, 2]) + self.calc_risk_period._group_id_E1 = np.array([1, 2, 2]) + + self.calc_risk_period.per_date_return_periods_H0 = MagicMock( + return_value=np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) + ) + self.calc_risk_period.per_date_return_periods_H1 = MagicMock( + return_value=np.array([[10, 20, 30], [40, 50, 60], [70, 80, 90]]) + ) + self.calc_risk_period.measure = MagicMock(spec=Measure) + self.calc_risk_period.measure.name = "dummy_measure" + + def test_calc_eai_gdf(self): + result = self.calc_risk_period.calc_eai_gdf() + expected_columns = { + "group", + "geometry", + "coord_id", + "date", + "risk", + "metric", + "measure", + } + self.assertTrue(expected_columns.issubset(set(result.columns))) + self.assertTrue((result["metric"] == "eai").all()) + self.assertTrue((result["measure"] == "dummy_measure").all()) + + # Check calculated risk values by coord_id, date + expected_risk = np.array([1.0, 1.5, 12, 0, 3, 6, 1, 0, 6]) + actual_risk = result["risk"].values + np.testing.assert_array_almost_equal(expected_risk, actual_risk) + + def test_calc_aai_metric(self): + result = self.calc_risk_period.calc_aai_metric() + expected_columns = { + "group", + "date", + "risk", + "metric", + "measure", + } + self.assertTrue(expected_columns.issubset(set(result.columns))) + self.assertTrue((result["metric"] == "aai").all()) + self.assertTrue((result["measure"] == "dummy_measure").all()) + + # Check calculated risk values by coord_id, date + expected_risk = np.array([2, 4.5, 24]) + actual_risk = result["risk"].values + np.testing.assert_array_almost_equal(expected_risk, actual_risk) + + def test_calc_aai_per_group_metric(self): + result = self.calc_risk_period.calc_aai_per_group_metric() + expected_columns = { + "group", + "date", + "risk", + "metric", + "measure", + } + self.assertTrue(expected_columns.issubset(set(result.columns))) + self.assertTrue((result["metric"] == "aai").all()) + self.assertTrue((result["measure"] == "dummy_measure").all()) + # Check calculated risk values by coord_id, date + expected_risk = np.array([1.0, 2.5, 12.0, 1.0, 2.0, 12]) + actual_risk = result["risk"].values + np.testing.assert_array_almost_equal(expected_risk, actual_risk) + + def test_calc_return_periods_metric(self): + result = self.calc_risk_period.calc_return_periods_metric([10, 20, 30]) + expected_columns = { + "group", + "date", + "risk", + "metric", + "measure", + } + self.assertTrue(expected_columns.issubset(set(result.columns))) + self.assertTrue(all(result["metric"].unique() == ["rp_10", "rp_20", "rp_30"])) + self.assertTrue((result["measure"] == "dummy_measure").all()) + + # Check calculated risk values by rp, date + expected_risk = np.array([1.0, 22.0, 70.0, 2.0, 27.5, 80, 3, 33, 90]) + actual_risk = result["risk"].values + np.testing.assert_array_almost_equal(expected_risk, actual_risk) + + def test_calc_risk_components_metric(self): + result = self.calc_risk_period.calc_risk_components_metric() + expected_columns = { + "group", + "date", + "risk", + "metric", + "measure", + } + self.assertTrue(expected_columns.issubset(set(result.columns))) + self.assertTrue( + all( + result["metric"].unique() + == ["base risk", "delta from exposure", "delta from hazard"] + ) + ) + self.assertTrue((result["measure"] == "dummy_measure").all()) + + # Check calculated risk values by rp, date + expected_risk = np.array([2.0, 2.0, 2.0, 0.0, 1.0, 7.0, 0, 1.5, 15]) + actual_risk = result["risk"].values + np.testing.assert_array_almost_equal(expected_risk, actual_risk) + + @patch("climada.trajectories.riskperiod.CalcRiskPeriod") + def test_apply_measure(self, mock_CalcRiskPeriod): + mock_CalcRiskPeriod.return_value = MagicMock(spec=CalcRiskPeriod) + self.calc_risk_period.snapshot0.apply_measure.return_value = 2 + self.calc_risk_period.snapshot1.apply_measure.return_value = 3 + result = self.calc_risk_period.apply_measure(self.calc_risk_period.measure) + self.assertEqual(result.measure, self.calc_risk_period.measure) + mock_CalcRiskPeriod.assert_called_with( + 2, + 3, + self.calc_risk_period.interval_freq, + self.calc_risk_period.time_points, + self.calc_risk_period.interpolation_strategy, + self.calc_risk_period.impact_computation_strategy, + self.calc_risk_period.risk_transf_attach, + self.calc_risk_period.risk_transf_cover, + self.calc_risk_period.calc_residual, + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/climada/trajectories/test/test_snapshot.py b/climada/trajectories/test/test_snapshot.py new file mode 100644 index 000000000..792c5a280 --- /dev/null +++ b/climada/trajectories/test/test_snapshot.py @@ -0,0 +1,110 @@ +import copy +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 ImpactFuncSet +from climada.entity.impact_funcs.base import ImpactFunc +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( + self.mock_exposure, self.mock_hazard, self.mock_impfset, 2023 + ) + self.assertEqual(snapshot.date, datetime.date(2023, 1, 1)) + + def test_init_with_str_date(self): + snapshot = Snapshot( + self.mock_exposure, self.mock_hazard, self.mock_impfset, "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( + self.mock_exposure, self.mock_hazard, self.mock_impfset, date_obj + ) + self.assertEqual(snapshot.date, date_obj) + + def test_init_with_invalid_date(self): + with self.assertRaises(ValueError): + Snapshot( + self.mock_exposure, self.mock_hazard, self.mock_impfset, "invalid-date" + ) + + def test_init_with_invalid_type(self): + with self.assertRaises(TypeError): + Snapshot(self.mock_exposure, self.mock_hazard, self.mock_impfset, 2023.5) + + def test_properties(self): + snapshot = Snapshot( + self.mock_exposure, self.mock_hazard, self.mock_impfset, 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( + self.mock_exposure, self.mock_hazard, self.mock_impfset, 2023 + ) + new_snapshot = snapshot.apply_measure(self.mock_measure) + + self.assertIsNotNone(new_snapshot.measure) + self.assertEqual(new_snapshot.measure.name, "Test Measure") + 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__": + unittest.main() From 7387165345050d801edfff1bcc43a530d384fb0a Mon Sep 17 00:00:00 2001 From: spjuhel Date: Mon, 19 May 2025 14:05:23 +0200 Subject: [PATCH 024/113] feature(Traj): fixes metrics generic and removes storing values Could not work with npv on/off --- climada/trajectories/risk_trajectory.py | 59 ++++++++++++------------- 1 file changed, 29 insertions(+), 30 deletions(-) diff --git a/climada/trajectories/risk_trajectory.py b/climada/trajectories/risk_trajectory.py index a9f69af0f..4d7ad5ad1 100644 --- a/climada/trajectories/risk_trajectory.py +++ b/climada/trajectories/risk_trajectory.py @@ -173,6 +173,7 @@ def pairwise(container: list): next(b, None) return zip(a, b) + LOGGER.debug(f"{self.__class__.__name__}: Calc risk periods") # impfset = self._merge_impfset(snapshots) return [ CalcRiskPeriod( @@ -227,26 +228,25 @@ def _generic_metrics( # Construct the attribute name for storing the metric results attr_name = f"_{metric_name}_metrics" - if getattr(self, attr_name, None) is None: - tmp = [] - for calc_period in self.risk_periods: - # Call the specified method on the calc_period object - tmp.append(getattr(calc_period, metric_meth)(**kwargs)) - - tmp = pd.concat(tmp) - tmp.drop_duplicates(inplace=True) - tmp["group"] = tmp["group"].fillna(self._all_groups_name) - columns_to_front = ["group", "date", "measure", "metric"] - tmp = tmp[ - columns_to_front - + [ - col - for col in tmp.columns - if col not in columns_to_front + ["group", "risk", "rp"] - ] - + ["risk"] + tmp = [] + for calc_period in self.risk_periods: + # Call the specified method on the calc_period object + tmp.append(getattr(calc_period, metric_meth)(**kwargs)) + + tmp = pd.concat(tmp) + tmp.drop_duplicates(inplace=True) + tmp["group"] = tmp["group"].fillna(self._all_groups_name) + columns_to_front = ["group", "date", "measure", "metric"] + tmp = tmp[ + columns_to_front + + [ + col + for col in tmp.columns + if col not in columns_to_front + ["group", "risk", "rp"] ] - setattr(self, attr_name, tmp) + + ["risk"] + ] + setattr(self, attr_name, tmp) if npv: return self.npv_transform(getattr(self, attr_name), self.risk_disc) @@ -271,40 +271,39 @@ def _compute_metrics( ) return df - def eai_metrics(self, npv: bool = True): + def eai_metrics(self, npv: bool = True, **kwargs): return self._compute_metrics( - npv=npv, - metric_name="eai", - metric_meth="calc_eai_gdf", + npv=npv, metric_name="eai", metric_meth="calc_eai_gdf", **kwargs ) - def aai_metrics(self, npv: bool = True): + def aai_metrics(self, npv: bool = True, **kwargs): return self._compute_metrics( - npv=npv, - metric_name="aai", - metric_meth="calc_aai_metric", + npv=npv, metric_name="aai", metric_meth="calc_aai_metric", **kwargs ) - def return_periods_metrics(self, return_periods, npv: bool = True): + def return_periods_metrics(self, return_periods, npv: bool = True, **kwargs): return self._compute_metrics( npv=npv, metric_name="return_periods", metric_meth="calc_return_periods_metric", return_periods=return_periods, + **kwargs, ) - def aai_per_group_metrics(self, npv: bool = True): + def aai_per_group_metrics(self, npv: bool = True, **kwargs): return self._compute_metrics( npv=npv, metric_name="aai_per_group", metric_meth="calc_aai_per_group_metric", + **kwargs, ) - def risk_components_metrics(self, npv: bool = True): + def risk_components_metrics(self, npv: bool = True, **kwargs): return self._compute_metrics( npv=npv, metric_name="risk_components", metric_meth="calc_risk_components_metric", + **kwargs, ) def per_date_risk_metrics( From 20befdf87954c28388d15d2807df3db91b3fb74a Mon Sep 17 00:00:00 2001 From: spjuhel Date: Mon, 19 May 2025 14:06:33 +0200 Subject: [PATCH 025/113] updates tutorial --- doc/tutorial/climada_trajectories.ipynb | 645 ++++++++++++++++++------ 1 file changed, 494 insertions(+), 151 deletions(-) diff --git a/doc/tutorial/climada_trajectories.ipynb b/doc/tutorial/climada_trajectories.ipynb index 875967880..b1f0dacad 100644 --- a/doc/tutorial/climada_trajectories.ipynb +++ b/doc/tutorial/climada_trajectories.ipynb @@ -77,16 +77,6 @@ "/home/sjuhel/miniforge3/envs/cb_refactoring/lib/python3.10/site-packages/dask/dataframe/_pyarrow_compat.py:15: FutureWarning: Minimal version of pyarrow will soon be increased to 14.0.1. You are using 12.0.1. Please consider upgrading.\n", " warnings.warn(\n" ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2025-05-13 16:49:57,986 - climada.entity.exposures.base - INFO - Reading /home/sjuhel/climada/data/exposures/litpop/LitPop_150arcsec_HTI/v3/LitPop_150arcsec_HTI.hdf5\n", - "2025-05-13 16:50:03,270 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020/v2/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020.hdf5\n", - "2025-05-13 16:50:03,306 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", - "2025-05-13 16:50:03,308 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n" - ] } ], "source": [ @@ -124,13 +114,6 @@ "scrolled": true }, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2025-05-13 16:50:03,667 - climada.util.coordinates - INFO - Raster from resolution 0.04166665999999708 to 0.04166665999999708.\n" - ] - }, { "data": { "text/plain": [ @@ -195,19 +178,7 @@ "execution_count": 3, "id": "c516c861-c5c1-475b-82e2-c867c5c08ec9", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2025-05-13 16:50:25,814 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2040/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2040.hdf5\n", - "2025-05-13 16:50:25,851 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", - "2025-05-13 16:50:25,852 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", - "2025-05-13 16:50:25,852 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", - "2025-05-13 16:50:25,854 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n" - ] - } - ], + "outputs": [], "source": [ "import copy\n", "\n", @@ -317,15 +288,7 @@ "execution_count": 7, "id": "c644d470-7fd3-461e-97fd-d23d40f7abd9", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2025-05-13 16:50:25,998 - climada.trajectories.riskperiod - INFO - Instantiating new CalcRiskPeriod.\n" - ] - } - ], + "outputs": [], "source": [ "from climada.trajectories.risk_trajectory import RiskTrajectory\n", "\n", @@ -347,37 +310,124 @@ }, { "cell_type": "code", - "execution_count": 10, - "id": "866db75c-5b21-4134-9f4e-f7213ad49f18", + "execution_count": 12, + "id": "9c485dc4-c009-46fb-aa4a-603bc9dcf5b4", "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "2025-05-13 16:50:39,073 - climada.trajectories.riskperiod - INFO - Instantiating new CalcRiskPeriod.\n", - "2025-05-13 16:50:39,077 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", - "2025-05-13 16:50:39,078 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", - "2025-05-13 16:50:39,078 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", - "2025-05-13 16:50:39,080 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", - "2025-05-13 16:50:39,086 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", - "2025-05-13 16:50:39,097 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", - "2025-05-13 16:50:39,098 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", - "2025-05-13 16:50:39,098 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", - "2025-05-13 16:50:39,101 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", - "2025-05-13 16:50:39,106 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", - "2025-05-13 16:50:39,118 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", - "2025-05-13 16:50:39,119 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", - "2025-05-13 16:50:39,120 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", - "2025-05-13 16:50:39,121 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", - "2025-05-13 16:50:39,127 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", - "2025-05-13 16:50:39,139 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", - "2025-05-13 16:50:39,140 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", - "2025-05-13 16:50:39,141 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", - "2025-05-13 16:50:39,142 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", - "2025-05-13 16:50:39,146 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\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", + "
periodgroupmeasuremetricrisk
02018-01-01 to 2040-01-010no_measureaai1.487445e+07
12018-01-01 to 2040-01-011no_measureaai9.945312e+09
22018-01-01 to 2040-01-01Allno_measureaai9.960186e+09
32018-01-01 to 2040-01-01Allno_measurerp_1003.288826e+11
42018-01-01 to 2040-01-01Allno_measurerp_501.886460e+11
52018-01-01 to 2040-01-01Allno_measurerp_5008.369369e+11
\n", + "
" + ], + "text/plain": [ + " period group measure metric risk\n", + "0 2018-01-01 to 2040-01-01 0 no_measure aai 1.487445e+07\n", + "1 2018-01-01 to 2040-01-01 1 no_measure aai 9.945312e+09\n", + "2 2018-01-01 to 2040-01-01 All no_measure aai 9.960186e+09\n", + "3 2018-01-01 to 2040-01-01 All no_measure rp_100 3.288826e+11\n", + "4 2018-01-01 to 2040-01-01 All no_measure rp_50 1.886460e+11\n", + "5 2018-01-01 to 2040-01-01 All no_measure rp_500 8.369369e+11" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "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": 13, + "id": "6b73a589-9ee4-41e8-90e0-910bfe4dd8fc", + "metadata": {}, + "outputs": [ { "data": { "text/html": [ @@ -517,7 +567,7 @@ "[138 rows x 5 columns]" ] }, - "execution_count": 10, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -528,47 +578,39 @@ }, { "cell_type": "markdown", - "id": "ff6d6915-805f-46a9-8552-c03c635fe2d5", + "id": "00e0a09b-9dd6-4378-81a1-cda5290f9aa4", "metadata": {}, "source": [ - "Or on a per-date basis:" + "You can also plot the \"components\" of the change in risk via a waterfall graph, both over the whole period:" ] }, { "cell_type": "code", - "execution_count": 11, - "id": "67efba39-11b6-40fc-b5dd-a8799ec00c12", + "execution_count": 14, + "id": "08c226a4-944b-4301-acfa-602adde980a5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - ">" + "" ] }, - "execution_count": 11, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], - "source": [ - "risk_traj.per_date_risk_metrics" - ] - }, - { - "cell_type": "markdown", - "id": "00e0a09b-9dd6-4378-81a1-cda5290f9aa4", - "metadata": {}, - "source": [ - "You can also plot the \"components\" of the change in risk via a waterfall graph, both over the whole period:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "08c226a4-944b-4301-acfa-602adde980a5", - "metadata": {}, - "outputs": [], "source": [ "risk_traj.plot_waterfall()" ] @@ -583,10 +625,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "cf40380a-5814-4164-a592-7ab181776b5a", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "risk_traj.plot_per_date_waterfall()" ] @@ -607,40 +670,13 @@ "### Grouping" ] }, - { - "cell_type": "markdown", - "id": "2283e6f9-0230-4865-a5db-ac33b5d9eccc", - "metadata": {}, - "source": [ - "If `compute_groups` is set to True, the object will also compute the Annual Average Impact per group_id from the exposure:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4af17732-708b-48e0-938b-afb962a7d29d", - "metadata": {}, - "outputs": [], - "source": [ - "grouped_risk_traj = RiskTrajectory(snapcol, compute_groups=True)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ff4da4a5-a2bc-4697-b829-43c4b05776d2", - "metadata": {}, - "outputs": [], - "source": [ - "grouped_risk_traj.total_risk_metrics" - ] - }, { "cell_type": "markdown", "id": "e78f1b7a-8ebe-4f46-96d0-ace8815ee3b8", "metadata": {}, "source": [ - "From this, one could for instance evaluate how the risk for a specific type of asset, or a specific population, evolves in between two points in time." + "This can be used for instance to evaluate how the risk for a specific type of asset, or a specific population, evolves in between two points in time.\n", + "Group are defined from the exposure data. Metric for each group are indexed by their corresponding ID (from the exposure) in the group column of the dataframes." ] }, { @@ -663,7 +699,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "651e31cb-5a55-4a22-a7c3-b5f79b3a20ef", "metadata": {}, "outputs": [], @@ -678,7 +714,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "id": "d86bedbb-6c0a-4f7d-a63e-5012510339d3", "metadata": {}, "outputs": [], @@ -688,35 +724,358 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "1d436f15-020a-40e2-8db7-869b5e3a10a1", "metadata": {}, - "outputs": [], + "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", + " \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", + "
dategroupmeasuremetricrisk
02018-01-01Allno_measureaai1.840432e+08
12019-01-01Allno_measureaai2.026958e+08
22020-01-01Allno_measureaai2.209575e+08
32021-01-01Allno_measureaai2.388335e+08
42022-01-01Allno_measureaai2.563287e+08
..................
412036-01-011no_measureaai4.633031e+08
422037-01-011no_measureaai4.756440e+08
432038-01-011no_measureaai4.876796e+08
442039-01-011no_measureaai4.994144e+08
452040-01-011no_measureaai5.108526e+08
\n", + "

138 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " date group measure metric risk\n", + "0 2018-01-01 All no_measure aai 1.840432e+08\n", + "1 2019-01-01 All no_measure aai 2.026958e+08\n", + "2 2020-01-01 All no_measure aai 2.209575e+08\n", + "3 2021-01-01 All no_measure aai 2.388335e+08\n", + "4 2022-01-01 All no_measure aai 2.563287e+08\n", + ".. ... ... ... ... ...\n", + "41 2036-01-01 1 no_measure aai 4.633031e+08\n", + "42 2037-01-01 1 no_measure aai 4.756440e+08\n", + "43 2038-01-01 1 no_measure aai 4.876796e+08\n", + "44 2039-01-01 1 no_measure aai 4.994144e+08\n", + "45 2040-01-01 1 no_measure aai 5.108526e+08\n", + "\n", + "[138 rows x 5 columns]" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "discounted_risk_traj.total_risk_metrics" + "discounted_risk_traj.per_date_risk_metrics()" ] }, { "cell_type": "code", - "execution_count": null, - "id": "0f732fc0-21b6-456d-9d97-662aa1b8cf15", + "execution_count": 25, + "id": "80381f13-5eac-4ecf-a15d-7a73365bed29", "metadata": {}, - "outputs": [], + "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", + " \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", + "
dategroupmeasuremetricrisk
02018-01-01Allno_measureaai1.840432e+08
12019-01-01Allno_measureaai2.026958e+08
22020-01-01Allno_measureaai2.209575e+08
32021-01-01Allno_measureaai2.388335e+08
42022-01-01Allno_measureaai2.563287e+08
..................
412036-01-011no_measureaai4.633031e+08
422037-01-011no_measureaai4.756440e+08
432038-01-011no_measureaai4.876796e+08
442039-01-011no_measureaai4.994144e+08
452040-01-011no_measureaai5.108526e+08
\n", + "

69 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " date group measure metric risk\n", + "0 2018-01-01 All no_measure aai 1.840432e+08\n", + "1 2019-01-01 All no_measure aai 2.026958e+08\n", + "2 2020-01-01 All no_measure aai 2.209575e+08\n", + "3 2021-01-01 All no_measure aai 2.388335e+08\n", + "4 2022-01-01 All no_measure aai 2.563287e+08\n", + ".. ... ... ... ... ...\n", + "41 2036-01-01 1 no_measure aai 4.633031e+08\n", + "42 2037-01-01 1 no_measure aai 4.756440e+08\n", + "43 2038-01-01 1 no_measure aai 4.876796e+08\n", + "44 2039-01-01 1 no_measure aai 4.994144e+08\n", + "45 2040-01-01 1 no_measure aai 5.108526e+08\n", + "\n", + "[69 rows x 5 columns]" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "discounted_risk_traj.per_date_risk_metrics().loc[\n", + " discounted_risk_traj.per_date_risk_metrics()[\"metric\"] == \"aai\"\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "ee3b0217-fe14-44a9-98f5-e1fc7f45e613", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "\n", "g = sns.lineplot(\n", - " discounted_risk_traj.per_date_risk_metrics.loc[\n", - " discounted_risk_traj.per_date_risk_metrics[\"metric\"] == \"aai\"\n", + " discounted_risk_traj.per_date_risk_metrics().loc[\n", + " (discounted_risk_traj.per_date_risk_metrics()[\"metric\"] == \"aai\")\n", + " & (discounted_risk_traj.per_date_risk_metrics()[\"group\"] == \"All\")\n", " ],\n", " x=\"date\",\n", " y=\"risk\",\n", " color=\"blue\",\n", ")\n", "sns.lineplot(\n", - " risk_traj.per_date_risk_metrics.loc[\n", - " risk_traj.per_date_risk_metrics[\"metric\"] == \"aai\"\n", + " risk_traj.per_date_risk_metrics().loc[\n", + " (risk_traj.per_date_risk_metrics()[\"metric\"] == \"aai\")\n", + " & (risk_traj.per_date_risk_metrics()[\"group\"] == \"All\")\n", " ],\n", " x=\"date\",\n", " y=\"risk\",\n", @@ -724,22 +1083,6 @@ " color=\"red\",\n", ")" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "98fc7fe1-b013-4356-ab13-007c7b74b77b", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ce42cd76-bf1e-4f16-b689-c398f7f05c8b", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From e06a3e739d3a2e4d40397585b7b9116aea0273aa Mon Sep 17 00:00:00 2001 From: spjuhel Date: Wed, 21 May 2025 11:16:31 +0200 Subject: [PATCH 026/113] doc(risk_traj): adds some docstrings --- climada/trajectories/risk_trajectory.py | 156 ++++++++++++++++++++++-- 1 file changed, 145 insertions(+), 11 deletions(-) diff --git a/climada/trajectories/risk_trajectory.py b/climada/trajectories/risk_trajectory.py index 4d7ad5ad1..abef133b0 100644 --- a/climada/trajectories/risk_trajectory.py +++ b/climada/trajectories/risk_trajectory.py @@ -106,6 +106,13 @@ def _reset_metrics(self): @property def default_rp(self): + """The default return period values to use when computing risk period metrics. + + Notes + ----- + + Changing its value resets the corresponding metric. + """ return self._default_rp @default_rp.setter @@ -120,7 +127,14 @@ def default_rp(self, value): @property def risk_transf_cover(self): - """The risk transfer coverage.""" + """The risk transfer coverage. + + Notes + ----- + + Changing its value resets the risk metrics. + """ + return self._risk_transf_cover @risk_transf_cover.setter @@ -131,7 +145,14 @@ def risk_transf_cover(self, value): @property def risk_transf_attach(self): - """The risk transfer attachment.""" + """The risk transfer attachment. + + Notes + ----- + + Changing its value resets the risk metrics. + """ + return self._risk_transf_attach @risk_transf_attach.setter @@ -190,11 +211,27 @@ def pairwise(container: list): ] @classmethod - def npv_transform(cls, df: pd.DataFrame, risk_disc) -> pd.DataFrame: + def npv_transform(cls, df: pd.DataFrame, risk_disc: DiscRates) -> pd.DataFrame: + """Apply discount rate to a metric `DataFrame`. + + Parameters + ---------- + df : pd.DataFrame + The `DataFrame` of the metric to discount. + risk_disc : 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").min() - end_date = group.index.get_level_values("date").max() - return calc_npv_cash_flows(group, start_date, end_date, disc) + return calc_npv_cash_flows(group, start_date, disc) df = df.set_index("date") grouper = cls._grouper @@ -272,11 +309,39 @@ def _compute_metrics( return df def eai_metrics(self, npv: bool = True, **kwargs): + """Return the estimatated annual impacts at each exposure point for each date. + + This method computes and return a `GeoDataFrame` with eai metric + (for each exposure point) for each date. + + Parameters + ---------- + npv : bool + Whether to apply the (risk) discount rate if it is defined. + Defaults to `True`. + + Notes + ----- + + This computation may become quite expensive for big areas with high resolution. + + """ return self._compute_metrics( npv=npv, metric_name="eai", metric_meth="calc_eai_gdf", **kwargs ) def aai_metrics(self, npv: bool = True, **kwargs): + """Return the average annual impacts for each date. + + This method computes and return a `DataFrame` with aai metric for each date. + + Parameters + ---------- + npv : bool + Whether to apply the (risk) discount rate if it is defined. + Defaults to `True`. + """ + return self._compute_metrics( npv=npv, metric_name="aai", metric_meth="calc_aai_metric", **kwargs ) @@ -291,6 +356,18 @@ def return_periods_metrics(self, return_periods, npv: bool = True, **kwargs): ) def aai_per_group_metrics(self, npv: bool = True, **kwargs): + """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. + + Parameters + ---------- + npv : bool + Whether to apply the (risk) discount rate if it is defined. + Defaults to `True`. + """ + return self._compute_metrics( npv=npv, metric_name="aai_per_group", @@ -299,6 +376,24 @@ def aai_per_group_metrics(self, npv: bool = True, **kwargs): ) def risk_components_metrics(self, npv: bool = True, **kwargs): + """Return the "components" of change in future risk (Exposure and Hazard) + + This method returns the components of the change in risk at each date: + + - The base risk, i.e., the risk without change in hazard or exposure, compared to trajectory earliest date. + - The "delta from exposure", i.e., the additional risks that come with change in exposure + - The "delta from hazard", i.e., the additional risks that come with change in hazard + + Due to how computations are being done the "delta from exposure" corresponds to the change of risk due to change in exposure while hazard remains constant to "baseline hazard", while "delta from hazard" corresponds to the change of risk due to change in hazard, while exposure remains constant to **future** exposure. + + Parameters + ---------- + npv : bool + Whether to apply the (risk) discount rate if it is defined. + Defaults to `True`. + + """ + return self._compute_metrics( npv=npv, metric_name="risk_components", @@ -312,6 +407,30 @@ def per_date_risk_metrics( return_periods: list[int] | None = None, npv: bool = True, ) -> 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", "return_periods" and "aai_per_group"). + + Parameters + ---------- + metrics : list[str], optional + The list of metrics to return (defaults to + ["aai","return_periods","aai_per_group"]) + return_periods : list[int], optional + The return periods to consider for the return periods metric + (default to the value of the `.default_rp` attribute) + npv : bool + Whether to apply the (risk) discount rate if it was defined + when instantiating the trajectory. Defaults to `True`. + + Returns + ------- + pd.DataFrame | pd.Series + A tidy DataFrame with metrics value for all possible dates. + + """ + metrics_df = [] metrics = ( ["aai", "return_periods", "aai_per_group"] if metrics is None else metrics @@ -578,20 +697,35 @@ def plot_waterfall( def calc_npv_cash_flows( cash_flows: pd.DataFrame, start_date: datetime.date, - end_date: datetime.date | None = None, disc: DiscRates | None = None, ): - # If no discount rates are provided, return the cash flows as is + """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: return cash_flows if not isinstance(cash_flows.index, pd.DatetimeIndex): raise ValueError("cash_flows must be a pandas Series with a datetime index") - # Determine the end date if not provided - if end_date is None: - end_date = cash_flows.index[-1] - df = cash_flows.to_frame(name="cash_flow") df["year"] = df.index.year From 924bb35af9bba81f175b093e10eadfd824f666bd Mon Sep 17 00:00:00 2001 From: spjuhel Date: Wed, 21 May 2025 11:31:05 +0200 Subject: [PATCH 027/113] doc(module desc): improves top file desc --- climada/trajectories/risk_trajectory.py | 3 +++ climada/trajectories/riskperiod.py | 10 ++++++++-- climada/trajectories/snapshot.py | 5 ++++- 3 files changed, 15 insertions(+), 3 deletions(-) diff --git a/climada/trajectories/risk_trajectory.py b/climada/trajectories/risk_trajectory.py index abef133b0..3304939ef 100644 --- a/climada/trajectories/risk_trajectory.py +++ b/climada/trajectories/risk_trajectory.py @@ -16,6 +16,9 @@ --- +This file implements risk trajectory objects, to allow a better evaluation +of risk in between two points in time (snapshots). + """ import datetime diff --git a/climada/trajectories/riskperiod.py b/climada/trajectories/riskperiod.py index 0ef8aa8ea..853157758 100644 --- a/climada/trajectories/riskperiod.py +++ b/climada/trajectories/riskperiod.py @@ -16,7 +16,13 @@ --- -This modules implements the Snapshot and SnapshotsCollection classes. +This modules implements the CalcRiskPeriod class. + +CalcRiskPeriod 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. """ @@ -212,7 +218,7 @@ def date_idx(self, value, /): if not isinstance(value, pd.DatetimeIndex): raise ValueError("Not a DatetimeIndex") - self._date_idx = value.normalize() + self._date_idx = value.normalize() # Avoids weird hourly data self._time_points = len(self.date_idx) self._interval_freq = pd.infer_freq(self.date_idx) self._prop_H1 = np.linspace(0, 1, num=self.time_points) diff --git a/climada/trajectories/snapshot.py b/climada/trajectories/snapshot.py index b3cdf4995..02ca5839e 100644 --- a/climada/trajectories/snapshot.py +++ b/climada/trajectories/snapshot.py @@ -16,7 +16,10 @@ --- -This modules implements the Snapshot and SnapshotsCollection classes. +This modules implements the Snapshot class. + +Snapshot are used to store the a snapshot of Exposure, Hazard, Vulnerability +at a specific date. """ From 6595e13e8cb8704540681a114ee26a77ff7400d9 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Wed, 21 May 2025 16:56:33 +0200 Subject: [PATCH 028/113] fix(log) : Removes endless logs --- climada/trajectories/riskperiod.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/climada/trajectories/riskperiod.py b/climada/trajectories/riskperiod.py index 853157758..a63ba1011 100644 --- a/climada/trajectories/riskperiod.py +++ b/climada/trajectories/riskperiod.py @@ -45,6 +45,10 @@ LOGGER = logging.getLogger(__name__) +logging.getLogger("climada.util.coordinates").setLevel(logging.WARNING) +logging.getLogger("climada.entity.exposures.base").setLevel(logging.WARNING) +logging.getLogger("climada.engine.impact_calc").setLevel(logging.WARNING) + def lazy_property(method): # This function is used as a decorator for properties @@ -111,7 +115,7 @@ def __init__( risk_transf_cover: float | None = None, calc_residual: bool = False, ): - LOGGER.info("Instantiating new CalcRiskPeriod.") + LOGGER.debug("Instantiating new CalcRiskPeriod.") self._snapshot0 = snapshot0 self._snapshot1 = snapshot1 self.date_idx = CalcRiskPeriod._set_date_idx( From 94bd00eac203a2c133b62a9b64d1e1e1a7a04f58 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Wed, 21 May 2025 16:57:17 +0200 Subject: [PATCH 029/113] fix(risk_traj): Fixes problems with >2 snapshots --- climada/trajectories/risk_trajectory.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/climada/trajectories/risk_trajectory.py b/climada/trajectories/risk_trajectory.py index 3304939ef..493fd14a0 100644 --- a/climada/trajectories/risk_trajectory.py +++ b/climada/trajectories/risk_trajectory.py @@ -274,7 +274,11 @@ def _generic_metrics( tmp.append(getattr(calc_period, metric_meth)(**kwargs)) tmp = pd.concat(tmp) - tmp.drop_duplicates(inplace=True) + tmp = tmp.set_index(["date", "group", "measure", "metric"]) + tmp = tmp[ + ~tmp.index.duplicated(keep="last") + ] # We want to avoid overlap when more than 2 snapshots + tmp = tmp.reset_index() tmp["group"] = tmp["group"].fillna(self._all_groups_name) columns_to_front = ["group", "date", "measure", "metric"] tmp = tmp[ From 49215281c938502127a1d6ff5973ecf1192e7b00 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Wed, 21 May 2025 16:58:01 +0200 Subject: [PATCH 030/113] doc(notebook): adds disclaimers --- doc/tutorial/climada_trajectories.ipynb | 622 ++++++++++++++++++++++-- 1 file changed, 592 insertions(+), 30 deletions(-) diff --git a/doc/tutorial/climada_trajectories.ipynb b/doc/tutorial/climada_trajectories.ipynb index b1f0dacad..cfa258e50 100644 --- a/doc/tutorial/climada_trajectories.ipynb +++ b/doc/tutorial/climada_trajectories.ipynb @@ -27,7 +27,49 @@ }, { "cell_type": "markdown", - "id": "a50d00c0-a08d-4877-87ac-e6f0c2a4bc60", + "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": [ + "The purpose of this module is to improve the evaluation of risk in between two \"known\" points in time.\n", + "\n", + "It relies on interpolation (linear by default) of impacts and risk metrics in between the different points, \n", + "which may lead to incoherent results in cases where this simplification drifts too far from reality.\n", + "\n", + "As always users should carefully consider it the tool fits the purpose and if the limitations \n", + "remain acceptable, even more so when used to design DRR or CCA 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" @@ -77,6 +119,16 @@ "/home/sjuhel/miniforge3/envs/cb_refactoring/lib/python3.10/site-packages/dask/dataframe/_pyarrow_compat.py:15: FutureWarning: Minimal version of pyarrow will soon be increased to 14.0.1. You are using 12.0.1. Please consider upgrading.\n", " warnings.warn(\n" ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-05-21 16:01:03,369 - climada.entity.exposures.base - INFO - Reading /home/sjuhel/climada/data/exposures/litpop/LitPop_150arcsec_HTI/v3/LitPop_150arcsec_HTI.hdf5\n", + "2025-05-21 16:01:08,809 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020/v2/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020.hdf5\n", + "2025-05-21 16:01:08,836 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-21 16:01:08,838 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n" + ] } ], "source": [ @@ -108,19 +160,26 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "aa0becca-d334-40b4-86c0-1959c750f6d5", "metadata": { "scrolled": true }, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-05-21 15:55:57,839 - climada.util.coordinates - INFO - Raster from resolution 0.04166665999999708 to 0.04166665999999708.\n" + ] + }, { "data": { "text/plain": [ "" ] }, - "execution_count": 2, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" }, @@ -166,7 +225,8 @@ "id": "8e8458c3-a3f9-4210-9de0-15293167f2f9", "metadata": {}, "source": [ - "As stated previously, it makes little sense to define a Snapshot alone, so your main entry point should rather be the `RiskTrajectory`. \n", + "As stated previously, it makes little sense to define a Snapshot alone, so your main entry point should rather be the `RiskTrajectory` object.\n", + "\n", "`RiskTrajectory` uses one or more `RiskPeriod` under the hood, these objects used to hold pairs of `Snapshot` and compute the impacts at each dates in between.\n", "This allows you to create a trajectory or risk with any number of snapshots.\n", "\n", @@ -175,15 +235,26 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "c516c861-c5c1-475b-82e2-c867c5c08ec9", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-05-21 15:56:19,977 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2040/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2040.hdf5\n", + "2025-05-21 15:56:20,006 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-21 15:56:20,007 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-21 15:56:20,007 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-21 15:56:20,009 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n" + ] + } + ], "source": [ "import copy\n", "\n", "future_year = 2040\n", - "\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", @@ -212,7 +283,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "3b909d67-9e89-4a50-905c-de616c9d5a0a", "metadata": {}, "outputs": [ @@ -222,7 +293,7 @@ "" ] }, - "execution_count": 4, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, @@ -243,7 +314,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "a9dd7b63-c577-4b60-87f8-bc2b8782c100", "metadata": {}, "outputs": [], @@ -261,7 +332,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "4ffe490d-8488-4005-9442-deb642e19985", "metadata": {}, "outputs": [], @@ -285,10 +356,18 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "c644d470-7fd3-461e-97fd-d23d40f7abd9", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-05-21 15:56:20,163 - climada.trajectories.riskperiod - INFO - Instantiating new CalcRiskPeriod.\n" + ] + } + ], "source": [ "from climada.trajectories.risk_trajectory import RiskTrajectory\n", "\n", @@ -310,10 +389,37 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 9, "id": "9c485dc4-c009-46fb-aa4a-603bc9dcf5b4", "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-05-21 15:56:20,172 - climada.trajectories.riskperiod - INFO - Instantiating new CalcRiskPeriod.\n", + "2025-05-21 15:56:20,175 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-21 15:56:20,176 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-21 15:56:20,176 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-21 15:56:20,178 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-21 15:56:20,184 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-05-21 15:56:20,194 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-21 15:56:20,195 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-21 15:56:20,195 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-21 15:56:20,197 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-21 15:56:20,202 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-05-21 15:56:20,212 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-21 15:56:20,213 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-21 15:56:20,213 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-21 15:56:20,215 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-21 15:56:20,218 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-05-21 15:56:20,228 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-21 15:56:20,229 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-21 15:56:20,229 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-21 15:56:20,231 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-21 15:56:20,234 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n" + ] + }, { "data": { "text/html": [ @@ -405,7 +511,7 @@ "5 2018-01-01 to 2040-01-01 All no_measure rp_500 8.369369e+11" ] }, - "execution_count": 12, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -424,7 +530,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 10, "id": "6b73a589-9ee4-41e8-90e0-910bfe4dd8fc", "metadata": {}, "outputs": [ @@ -567,7 +673,7 @@ "[138 rows x 5 columns]" ] }, - "execution_count": 13, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -586,7 +692,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 11, "id": "08c226a4-944b-4301-acfa-602adde980a5", "metadata": {}, "outputs": [ @@ -596,7 +702,7 @@ "" ] }, - "execution_count": 14, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, @@ -625,7 +731,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 12, "id": "cf40380a-5814-4164-a592-7ab181776b5a", "metadata": {}, "outputs": [ @@ -635,7 +741,7 @@ "" ] }, - "execution_count": 15, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, @@ -699,7 +805,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 13, "id": "651e31cb-5a55-4a22-a7c3-b5f79b3a20ef", "metadata": {}, "outputs": [], @@ -714,20 +820,55 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 14, "id": "d86bedbb-6c0a-4f7d-a63e-5012510339d3", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-05-21 15:56:30,978 - climada.trajectories.riskperiod - INFO - Instantiating new CalcRiskPeriod.\n" + ] + } + ], "source": [ "discounted_risk_traj = RiskTrajectory(snapcol, risk_disc=discount_stern)" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 15, "id": "1d436f15-020a-40e2-8db7-869b5e3a10a1", "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-05-21 15:56:30,989 - climada.trajectories.riskperiod - INFO - Instantiating new CalcRiskPeriod.\n", + "2025-05-21 15:56:30,992 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-21 15:56:30,992 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-21 15:56:30,992 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-21 15:56:30,994 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-21 15:56:30,998 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-05-21 15:56:31,009 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-21 15:56:31,009 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-21 15:56:31,010 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-21 15:56:31,011 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-21 15:56:31,014 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-05-21 15:56:31,025 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-21 15:56:31,026 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-21 15:56:31,026 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-21 15:56:31,028 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-21 15:56:31,032 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-05-21 15:56:31,044 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-21 15:56:31,044 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-21 15:56:31,045 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-21 15:56:31,046 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-21 15:56:31,050 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n" + ] + }, { "data": { "text/html": [ @@ -867,7 +1008,7 @@ "[138 rows x 5 columns]" ] }, - "execution_count": 20, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -878,7 +1019,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 16, "id": "80381f13-5eac-4ecf-a15d-7a73365bed29", "metadata": {}, "outputs": [ @@ -1021,7 +1162,7 @@ "[69 rows x 5 columns]" ] }, - "execution_count": 25, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -1034,7 +1175,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 17, "id": "ee3b0217-fe14-44a9-98f5-e1fc7f45e613", "metadata": {}, "outputs": [ @@ -1044,7 +1185,7 @@ "" ] }, - "execution_count": 32, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" }, @@ -1083,6 +1224,427 @@ " color=\"red\",\n", ")" ] + }, + { + "cell_type": "markdown", + "id": "0152e9fa-55fa-4cf2-b187-59e6228af563", + "metadata": {}, + "source": [ + "# Advanced usage\n", + "\n", + "In this section we present some more advanced feature and usage of this module." + ] + }, + { + "cell_type": "markdown", + "id": "42c9daed-6488-488b-b01a-fd6dfc5d0274", + "metadata": {}, + "source": [ + "## Higher number of snapshots" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7de43e3c-df4f-4f24-b230-717f06c7e6e0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-05-21 16:01:50,165 - climada.entity.exposures.base - INFO - Reading /home/sjuhel/climada/data/exposures/litpop/LitPop_150arcsec_HTI/v3/LitPop_150arcsec_HTI.hdf5\n", + "2025-05-21 16:01:55,538 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020/v2/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020.hdf5\n", + "2025-05-21 16:01:55,569 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-21 16:01:55,571 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-21 16:02:00,968 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2040/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2040.hdf5\n", + "2025-05-21 16:02:01,000 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-21 16:02:01,001 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-21 16:02:01,001 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-21 16:02:01,003 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-21 16:02:06,396 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2060/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2060.hdf5\n", + "2025-05-21 16:02:06,426 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-21 16:02:06,427 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-21 16:02:06,427 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-21 16:02:06,429 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-21 16:02:11,716 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2080/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2080.hdf5\n", + "2025-05-21 16:02:11,742 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-21 16:02:11,742 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-21 16:02:11,743 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-21 16:02:11,744 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n" + ] + } + ], + "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.risk_trajectory import RiskTrajectory\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", + "exp_present.assign_centroids(haz_present, distance=\"approx\")\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 = [Snapshot(exp_present, haz_present, impf_set, 2018)]\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", + " exp_future.assign_centroids(haz_future, distance=\"approx\")\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", + " snapcol.append(Snapshot(exp_future, haz_future, impf_set, year))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c1b8425f-efdd-421a-a953-01e7baeeea04", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-05-21 16:02:48,338 - climada.trajectories.riskperiod - INFO - Instantiating new CalcRiskPeriod.\n", + "2025-05-21 16:02:48,340 - climada.trajectories.riskperiod - INFO - Instantiating new CalcRiskPeriod.\n", + "2025-05-21 16:02:48,341 - climada.trajectories.riskperiod - INFO - Instantiating new CalcRiskPeriod.\n" + ] + } + ], + "source": [ + "risk_traj = RiskTrajectory(snapcol)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "95af829e-3f18-450e-91e6-7611e4afa00d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-05-21 16:02:50,423 - climada.trajectories.riskperiod - INFO - Instantiating new CalcRiskPeriod.\n", + "2025-05-21 16:02:50,425 - climada.trajectories.riskperiod - INFO - Instantiating new CalcRiskPeriod.\n", + "2025-05-21 16:02:50,426 - climada.trajectories.riskperiod - INFO - Instantiating new CalcRiskPeriod.\n", + "2025-05-21 16:02:50,428 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-21 16:02:50,429 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-21 16:02:50,429 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-21 16:02:50,431 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-21 16:02:50,435 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-05-21 16:02:50,445 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-21 16:02:50,445 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-21 16:02:50,446 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-21 16:02:50,447 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-21 16:02:50,451 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-05-21 16:02:50,463 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-21 16:02:50,463 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-21 16:02:50,464 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-21 16:02:50,465 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-21 16:02:50,470 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-05-21 16:02:50,482 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-21 16:02:50,482 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-21 16:02:50,483 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-21 16:02:50,485 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-21 16:02:50,489 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-05-21 16:02:59,575 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-21 16:02:59,576 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-21 16:02:59,576 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-21 16:02:59,578 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-21 16:02:59,582 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-05-21 16:02:59,592 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-21 16:02:59,593 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-21 16:02:59,593 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-21 16:02:59,594 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-21 16:02:59,598 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-05-21 16:02:59,609 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-21 16:02:59,610 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-21 16:02:59,610 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-21 16:02:59,611 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-21 16:02:59,615 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-05-21 16:02:59,624 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-21 16:02:59,625 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-21 16:02:59,625 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-21 16:02:59,626 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-21 16:02:59,630 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-05-21 16:03:08,420 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-21 16:03:08,421 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-21 16:03:08,421 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-21 16:03:08,423 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-21 16:03:08,427 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-05-21 16:03:08,439 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-21 16:03:08,439 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-21 16:03:08,440 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-21 16:03:08,442 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-21 16:03:08,446 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-05-21 16:03:08,460 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-21 16:03:08,461 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-21 16:03:08,461 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-21 16:03:08,463 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-21 16:03:08,466 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-05-21 16:03:08,478 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-05-21 16:03:08,478 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-05-21 16:03:08,479 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-05-21 16:03:08,480 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-05-21 16:03:08,484 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\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", + "
dategroupmeasuremetricrisk
02018-01-01Allno_measureaai1.840432e+08
12019-01-01Allno_measureaai2.055335e+08
22020-01-01Allno_measureaai2.271876e+08
32021-01-01Allno_measureaai2.490056e+08
42022-01-01Allno_measureaai2.709873e+08
..................
582076-01-01Allno_measureaai1.641765e+09
592077-01-01Allno_measureaai1.677493e+09
602078-01-01Allno_measureaai1.713461e+09
612079-01-01Allno_measureaai1.749670e+09
622080-01-01Allno_measureaai1.786120e+09
\n", + "

63 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " date group measure metric risk\n", + "0 2018-01-01 All no_measure aai 1.840432e+08\n", + "1 2019-01-01 All no_measure aai 2.055335e+08\n", + "2 2020-01-01 All no_measure aai 2.271876e+08\n", + "3 2021-01-01 All no_measure aai 2.490056e+08\n", + "4 2022-01-01 All no_measure aai 2.709873e+08\n", + ".. ... ... ... ... ...\n", + "58 2076-01-01 All no_measure aai 1.641765e+09\n", + "59 2077-01-01 All no_measure aai 1.677493e+09\n", + "60 2078-01-01 All no_measure aai 1.713461e+09\n", + "61 2079-01-01 All no_measure aai 1.749670e+09\n", + "62 2080-01-01 All no_measure aai 1.786120e+09\n", + "\n", + "[63 rows x 5 columns]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "risk_traj.aai_metrics()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "22ff0a25-2242-47de-b2ce-61e8f4ccbb6b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "risk_traj.plot_per_date_waterfall()" + ] + }, + { + "cell_type": "markdown", + "id": "39059ec5-9125-4cfc-b8c6-e6327d8b98cc", + "metadata": {}, + "source": [ + "## Non-yearly date index" + ] + }, + { + "cell_type": "markdown", + "id": "6dcce31f-4270-47c5-b874-d4ae8c443c0d", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "id": "096c2393-eb2b-4926-9105-61daaee8cbbe", + "metadata": {}, + "source": [ + "## Non-linear interpolation" + ] + }, + { + "cell_type": "markdown", + "id": "2e47a20b-7034-49f6-b6cd-6c9a98772d7a", + "metadata": {}, + "source": [ + "## Spatial mapping" + ] + }, + { + "cell_type": "markdown", + "id": "16a4a91f-f336-4e7b-bece-5b71a2f61ed6", + "metadata": {}, + "source": [ + "## \"Big\" data" + ] } ], "metadata": { From 02244cb4672e7a74d41d4902ad4c30ff4af17581 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 22 May 2025 14:44:55 +0200 Subject: [PATCH 031/113] fix(CalcRiskPeriod): fixes problem with undefined group_id --- climada/trajectories/riskperiod.py | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/climada/trajectories/riskperiod.py b/climada/trajectories/riskperiod.py index a63ba1011..bba83420a 100644 --- a/climada/trajectories/riskperiod.py +++ b/climada/trajectories/riskperiod.py @@ -134,8 +134,16 @@ def __init__( self.calc_residual = calc_residual self.measure = None # Only possible to set with apply_measure to make sure snapshots are consistent - self._group_id_E0 = self.snapshot0.exposure.gdf["group_id"].values - self._group_id_E1 = self.snapshot1.exposure.gdf["group_id"].values + self._group_id_E0 = ( + self.snapshot0.exposure.gdf["group_id"].values + if "group_id" in self.snapshot0.exposure.gdf.columns + else np.array([]) + ) + self._group_id_E1 = ( + self.snapshot1.exposure.gdf["group_id"].values + if "group_id" in self.snapshot1.exposure.gdf.columns + else np.array([]) + ) def _reset_impact_data(self): self._impacts_arrays = None From b0a9f6d2977885394848fd3d61013fd4cb3700c1 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 22 May 2025 15:16:46 +0200 Subject: [PATCH 032/113] fix(calcriskperiod): further fix for no group defined --- climada/trajectories/riskperiod.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/climada/trajectories/riskperiod.py b/climada/trajectories/riskperiod.py index bba83420a..59cf45ae2 100644 --- a/climada/trajectories/riskperiod.py +++ b/climada/trajectories/riskperiod.py @@ -570,6 +570,9 @@ def calc_aai_per_group_metric(self): df["group"] = group aai_per_group_df.append(df) + # If no groups defined + if not aai_per_group_df: + return None aai_per_group_df = pd.concat(aai_per_group_df) aai_per_group_df["metric"] = "aai" aai_per_group_df["measure"] = ( From 06afe2fdff57143340bb3681cad6cf727310048a Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 22 May 2025 15:22:44 +0200 Subject: [PATCH 033/113] fix(groups): still fixing groups --- climada/trajectories/risk_trajectory.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/climada/trajectories/risk_trajectory.py b/climada/trajectories/risk_trajectory.py index 493fd14a0..0f70d3e4c 100644 --- a/climada/trajectories/risk_trajectory.py +++ b/climada/trajectories/risk_trajectory.py @@ -273,6 +273,9 @@ def _generic_metrics( # Call the specified method on the calc_period object tmp.append(getattr(calc_period, metric_meth)(**kwargs)) + # Notably for per_group_aai being None: + if not tmp: + return None tmp = pd.concat(tmp) tmp = tmp.set_index(["date", "group", "measure", "metric"]) tmp = tmp[ From eceeba070a126b89d01a557d26add323104bcb88 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 22 May 2025 15:35:25 +0200 Subject: [PATCH 034/113] fix(groups): final fix (on the correct branch) --- climada/trajectories/risk_trajectory.py | 49 ++++++++++++++----------- 1 file changed, 27 insertions(+), 22 deletions(-) diff --git a/climada/trajectories/risk_trajectory.py b/climada/trajectories/risk_trajectory.py index 0f70d3e4c..502e8a42e 100644 --- a/climada/trajectories/risk_trajectory.py +++ b/climada/trajectories/risk_trajectory.py @@ -274,31 +274,36 @@ def _generic_metrics( tmp.append(getattr(calc_period, metric_meth)(**kwargs)) # Notably for per_group_aai being None: - if not tmp: - return None - tmp = pd.concat(tmp) - tmp = tmp.set_index(["date", "group", "measure", "metric"]) - tmp = tmp[ - ~tmp.index.duplicated(keep="last") - ] # We want to avoid overlap when more than 2 snapshots - tmp = tmp.reset_index() - tmp["group"] = tmp["group"].fillna(self._all_groups_name) - columns_to_front = ["group", "date", "measure", "metric"] - tmp = tmp[ - columns_to_front - + [ - col - for col in tmp.columns - if col not in columns_to_front + ["group", "risk", "rp"] + try: + tmp = pd.concat(tmp) + except ValueError as e: + if str(e) == "All objects passed were None": + return None + else: + raise e + else: + tmp = tmp.set_index(["date", "group", "measure", "metric"]) + tmp = tmp[ + ~tmp.index.duplicated(keep="last") + ] # We want to avoid overlap when more than 2 snapshots + tmp = tmp.reset_index() + tmp["group"] = tmp["group"].fillna(self._all_groups_name) + columns_to_front = ["group", "date", "measure", "metric"] + tmp = tmp[ + columns_to_front + + [ + col + for col in tmp.columns + if col not in columns_to_front + ["group", "risk", "rp"] + ] + + ["risk"] ] - + ["risk"] - ] - setattr(self, attr_name, tmp) + setattr(self, attr_name, tmp) - if npv: - return self.npv_transform(getattr(self, attr_name), self.risk_disc) + if npv: + return self.npv_transform(getattr(self, attr_name), self.risk_disc) - return getattr(self, attr_name) + return getattr(self, attr_name) def _compute_period_metrics( self, metric_name: str, metric_meth: str, npv: bool = True, **kwargs From a7dd0f7390402585ed31cdad814e7f24e892424a Mon Sep 17 00:00:00 2001 From: Samuel Juhel <10011382+spjuhel@users.noreply.github.com> Date: Mon, 26 May 2025 11:30:54 +0200 Subject: [PATCH 035/113] Applies suggestion from Lucas (j/n) Batch-apply no work :sadface: Co-authored-by: luseverin <91593121+luseverin@users.noreply.github.com> --- doc/tutorial/climada_trajectories.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/tutorial/climada_trajectories.ipynb b/doc/tutorial/climada_trajectories.ipynb index cfa258e50..0b44216c7 100644 --- a/doc/tutorial/climada_trajectories.ipynb +++ b/doc/tutorial/climada_trajectories.ipynb @@ -51,7 +51,7 @@ "It relies on interpolation (linear by default) of impacts and risk metrics in between the different points, \n", "which may lead to incoherent results in cases where this simplification drifts too far from reality.\n", "\n", - "As always users should carefully consider it the tool fits the purpose and if the limitations \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 DRR or CCA measures." ] }, From 7989c716386000c858a6114d75c77b11631269d5 Mon Sep 17 00:00:00 2001 From: Samuel Juhel <10011382+spjuhel@users.noreply.github.com> Date: Mon, 26 May 2025 11:31:26 +0200 Subject: [PATCH 036/113] Applies suggestion from Lucas (j/n) Co-authored-by: luseverin <91593121+luseverin@users.noreply.github.com> --- doc/tutorial/climada_trajectories.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/tutorial/climada_trajectories.ipynb b/doc/tutorial/climada_trajectories.ipynb index 0b44216c7..72ad8de66 100644 --- a/doc/tutorial/climada_trajectories.ipynb +++ b/doc/tutorial/climada_trajectories.ipynb @@ -52,7 +52,7 @@ "which may lead to incoherent results in cases where this simplification drifts too far from reality.\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 DRR or CCA measures." + "remain acceptable, even more so when used to design Disaster Risk Reduction or Climate Change Adaptation measures." ] }, { From 399572ec74fc539f4f5ab5d7a59a344319fc3bab Mon Sep 17 00:00:00 2001 From: Samuel Juhel <10011382+spjuhel@users.noreply.github.com> Date: Mon, 26 May 2025 11:31:38 +0200 Subject: [PATCH 037/113] Applies suggestion from Lucas (j/n) Co-authored-by: luseverin <91593121+luseverin@users.noreply.github.com> --- doc/tutorial/climada_trajectories.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/tutorial/climada_trajectories.ipynb b/doc/tutorial/climada_trajectories.ipynb index 72ad8de66..6f014d28a 100644 --- a/doc/tutorial/climada_trajectories.ipynb +++ b/doc/tutorial/climada_trajectories.ipynb @@ -82,7 +82,7 @@ "source": [ "The fundamental idea behing the `trajectories` module is to enable a better assessment of the evolution of risk over time.\n", "\n", - "Currently it proposes to look at the evolution between defined points in time and in the future we plan to also allow use a timeseries-oriented approach.\n", + "Currently it proposes to look at the evolution between defined points in time and in the future we plan to also allow using a timeseries-oriented approach.\n", "\n", "In this tutorial we present the current possibilities offered by the module." ] From 3db32ca9441c1af112b9bc7d8c812875daa6412b Mon Sep 17 00:00:00 2001 From: Samuel Juhel <10011382+spjuhel@users.noreply.github.com> Date: Mon, 26 May 2025 11:31:50 +0200 Subject: [PATCH 038/113] Applies suggestion from Lucas (j/n) Co-authored-by: luseverin <91593121+luseverin@users.noreply.github.com> --- doc/tutorial/climada_trajectories.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/tutorial/climada_trajectories.ipynb b/doc/tutorial/climada_trajectories.ipynb index 6f014d28a..16fadc53c 100644 --- a/doc/tutorial/climada_trajectories.ipynb +++ b/doc/tutorial/climada_trajectories.ipynb @@ -100,7 +100,7 @@ "id": "274a342f-54c0-4590-9110-5e297010955e", "metadata": {}, "source": [ - "We use `Snapshot` objects to define a point in time. This object acts as a wrapper of the classic risk framework composed of Exposure, Hazard and Vulnerability. As such it is define for a specific year, and contains references to an `Exposures`, a `Hazard`, and an `ImpactFuncSet` object.\n", + "We use `Snapshot` objects to define a point in time. 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 year, and contains references to an `Exposures`, a `Hazard`, and an `ImpactFuncSet` object.\n", "\n", "Next we show how to instantiate such a `Snapshot`. Note however that they are of little use by themselves, and what you will really use are `RiskTrajectory` which we present right after." ] From d2b0f6b79f0ea65eedffe810e66f85481c8bbb9c Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 5 Jun 2025 16:44:09 +0200 Subject: [PATCH 039/113] refactor(impact strat): Clarifies/Simplified computation --- climada/trajectories/impact_calc_strat.py | 102 ++++++++++------------ 1 file changed, 45 insertions(+), 57 deletions(-) diff --git a/climada/trajectories/impact_calc_strat.py b/climada/trajectories/impact_calc_strat.py index 23168caec..ea283d1d4 100644 --- a/climada/trajectories/impact_calc_strat.py +++ b/climada/trajectories/impact_calc_strat.py @@ -38,10 +38,11 @@ def compute_impacts( self, snapshot0: Snapshot, snapshot1: Snapshot, + future: tuple[int, int, int], risk_transf_attach: float | None, risk_transf_cover: float | None, calc_residual: bool, - ) -> tuple: + ) -> Impact: pass @@ -52,47 +53,40 @@ def compute_impacts( self, snapshot0: Snapshot, snapshot1: Snapshot, + future: tuple[int, int, int], risk_transf_attach: float | None, risk_transf_cover: float | None, calc_residual: bool = False, ): - impacts = self._calculate_impacts_for_snapshots(snapshot0, snapshot1) + impact = self.compute_impacts_pre_transfer(snapshot0, snapshot1, future) self._apply_risk_transfer( - impacts, risk_transf_attach, risk_transf_cover, calc_residual + impact, risk_transf_attach, risk_transf_cover, calc_residual ) - return impacts + return impact - def _calculate_impacts_for_snapshots( - self, snapshot0: Snapshot, snapshot1: Snapshot - ): - """Calculate impacts for the given snapshots and impact function set.""" - imp_E0H0 = ImpactCalc( - snapshot0.exposure, snapshot0.impfset, snapshot0.hazard - ).impact() - imp_E1H0 = ImpactCalc( - snapshot1.exposure, snapshot1.impfset, snapshot0.hazard - ).impact() - imp_E0H1 = ImpactCalc( - snapshot0.exposure, snapshot0.impfset, snapshot1.hazard - ).impact() - imp_E1H1 = ImpactCalc( - snapshot1.exposure, snapshot1.impfset, snapshot1.hazard - ).impact() - return imp_E0H0, imp_E1H0, imp_E0H1, imp_E1H1 + def compute_impacts_pre_transfer( + self, + snapshot0: Snapshot, + snapshot1: Snapshot, + future: tuple[int, int, int], + ) -> Impact: + exp = snapshot1.exposure if future[0] else snapshot0.exposure + haz = snapshot1.hazard if future[1] else snapshot0.hazard + vul = snapshot1.impfset if future[2] else snapshot0.impfset + return ImpactCalc(exposures=exp, impfset=vul, hazard=haz).impact() def _apply_risk_transfer( self, - impacts: tuple[Impact, Impact, Impact, Impact], + impact: Impact, risk_transf_attach: float | None, risk_transf_cover: float | None, calc_residual: bool, ): """Apply risk transfer to the calculated impacts.""" if risk_transf_attach is not None and risk_transf_cover is not None: - for imp in impacts: - imp.imp_mat = self.calculate_residual_or_risk_transfer_impact_matrix( - imp.imp_mat, risk_transf_attach, risk_transf_cover, calc_residual - ) + impact.imp_mat = self.calculate_residual_or_risk_transfer_impact_matrix( + impact.imp_mat, risk_transf_attach, risk_transf_cover, calc_residual + ) def calculate_residual_or_risk_transfer_impact_matrix( self, imp_mat, risk_transf_attach, risk_transf_cover, calc_residual @@ -111,9 +105,9 @@ def calculate_residual_or_risk_transfer_impact_matrix( ---------- imp_mat : scipy.sparse.csr_matrix The original impact matrix to be scaled. - attachment : float, optional + attachment : float The attachment point for the risk layer. - cover : float, optional + cover : float The maximum coverage for the risk layer. calc_residual : bool, default=True Determines if the function calculates the residual (if True) or the @@ -125,36 +119,30 @@ def calculate_residual_or_risk_transfer_impact_matrix( The adjusted impact matrix, either residual or risk transfer. """ + imp_mat = copy.deepcopy(imp_mat) + # Calculate the total impact per event + total_at_event = imp_mat.sum(axis=1).A1 + # Risk layer at event + transfer_at_event = np.minimum( + np.maximum(total_at_event - risk_transf_attach, 0), risk_transf_cover + ) + residual_at_event = np.maximum(total_at_event - transfer_at_event, 0) - if risk_transf_attach and risk_transf_cover: - imp_mat = copy.deepcopy(imp_mat) - # Calculate the total impact per event - total_at_event = imp_mat.sum(axis=1).A1 - # Risk layer at event - transfer_at_event = np.minimum( - np.maximum(total_at_event - risk_transf_attach, 0), risk_transf_cover - ) - residual_at_event = np.maximum(total_at_event - transfer_at_event, 0) - - # Calculate either the residual or transfer impact matrix - # Choose the denominator to rescale the impact values - if calc_residual: - numerator = residual_at_event - else: - numerator = transfer_at_event - - rescale_impact_values = np.divide( - numerator, - total_at_event, - out=np.zeros_like(numerator, dtype=float), - where=total_at_event != 0, - ) - - # The multiplication is broadcasted across the columns for each row - result_matrix = imp_mat.multiply(rescale_impact_values[:, np.newaxis]) + # Calculate either the residual or transfer impact matrix + # Choose the denominator to rescale the impact values + if calc_residual: + numerator = residual_at_event + else: + numerator = transfer_at_event - return result_matrix + rescale_impact_values = np.divide( + numerator, + total_at_event, + out=np.zeros_like(numerator, dtype=float), + where=total_at_event != 0, + ) - else: + # The multiplication is broadcasted across the columns for each row + result_matrix = imp_mat.multiply(rescale_impact_values[:, np.newaxis]) - return imp_mat + return result_matrix From 3f0dfc64edf4fd58c22283dec625de55e170c331 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 5 Jun 2025 16:45:33 +0200 Subject: [PATCH 040/113] feat(interpolation): Vastly improves interpolation of metrics --- climada/trajectories/interpolation.py | 220 ++++++++------ climada/trajectories/risk_trajectory.py | 73 +++-- climada/trajectories/riskperiod.py | 372 ++++++++++++++++++------ 3 files changed, 454 insertions(+), 211 deletions(-) diff --git a/climada/trajectories/interpolation.py b/climada/trajectories/interpolation.py index 6f1469faf..f3ed64410 100644 --- a/climada/trajectories/interpolation.py +++ b/climada/trajectories/interpolation.py @@ -21,121 +21,149 @@ """ import logging -from abc import ABC, abstractmethod +from abc import ABC +from typing import Callable import numpy as np -from scipy.sparse import csr_matrix, lil_matrix LOGGER = logging.getLogger(__name__) -class InterpolationStrategy(ABC): - """Interface for interpolation strategies.""" - - @abstractmethod - def interpolate(self, imp_E0, imp_E1, time_points: int) -> list: ... - - -class LinearInterpolation(InterpolationStrategy): - """Linear interpolation strategy.""" - - def interpolate(self, imp_E0, imp_E1, time_points: int): +def linear_interp_imp_mat(mat_start, mat_end, interpolation_range) -> list: + """Linearly interpolates between two impact matrices over an interpolation range. + + Returns a list of `interpolation_range` matrices linearly interpolated between + `mat_start` and `mat_end`. + """ + res = [] + for point in range(interpolation_range): + ratio = point / (interpolation_range - 1) + mat_interpolated = mat_start + ratio * (mat_end - mat_start) + res.append(mat_interpolated) + return res + + +def exponential_interp_imp_mat(mat_start, mat_end, interpolation_range, rate) -> list: + """Exponentially interpolates between two impact matrices over an interpolation range with a growth rate `rate`. + + Returns a list of `interpolation_range` matrices exponentially (with growth rate `rate`) interpolated between + `mat_start` and `mat_end`. + """ + # Convert matrices to logarithmic domain + mat_start = mat_start.copy() + mat_end = mat_end.copy() + mat_start.data = np.log(mat_start.data + np.finfo(float).eps) / np.log(rate) + mat_end.data = np.log(mat_end.data + np.finfo(float).eps) / np.log(rate) + + # Perform linear interpolation in the logarithmic domain + res = [] + for point in range(interpolation_range): + ratio = point / (interpolation_range - 1) + mat_interpolated = mat_start * (1 - ratio) + ratio * mat_end + mat_interpolated.data = np.exp(mat_interpolated.data * np.log(rate)) + res.append(mat_interpolated) + return res + + +def linear_interp_arrays(arr_start, arr_end, interpolation_range): + """Perform linear interpolation between two arrays (of a scalar metric) over an interpolation range.""" + 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, arr_end, interpolation_range, rate): + """Perform exponential interpolation between two arrays (of a scalar metric) over an interpolation range with a growth rate `rate`.""" + 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.exp( + ( + np.multiply(np.log(arr_start) / np.log(rate), prop0) + + np.multiply(np.log(arr_end) / np.log(rate), prop1) + ) + * np.log(rate) + ) + + +def logarithmic_interp_arrays(arr_start, arr_end, interpolation_range): + """Perform logarithmic (natural logarithm) interpolation between two arrays (of a scalar metric) over an interpolation range.""" + prop1 = np.logspace(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) + + +class InterpolationStrategyBase(ABC): + exposure_interp: Callable + hazard_interp: Callable + vulnerability_interp: Callable + + def interp_exposure_dim( + self, imp_E0, imp_E1, interpolation_range: int, **kwargs + ) -> list: + """Interpolates along the exposure change between two impact matrices. + + Returns a list of `interpolation_range` matrices linearly interpolated between + `mat_start` and `mat_end`. + """ try: - return self.interpolate_imp_mat(imp_E0, imp_E1, time_points) - except ValueError as e: - if str(e) == "inconsistent shapes": + res = self.exposure_interp(imp_E0, imp_E1, interpolation_range, **kwargs) + except ValueError as err: + if str(err) == "inconsistent shapes": raise ValueError( - "Interpolation between impact matrices of different shapes" + "Tried to interpolate impact matrices of different shape. A possible reason could be Exposures of different shapes." ) - else: - raise e - - @staticmethod - def interpolate_imp_mat(imp0, imp1, time_points): - """Interpolate between two impact matrices over a specified time range. - - Parameters - ---------- - imp0 : ImpactCalc - The impact calculation for the starting time. - imp1 : ImpactCalc - The impact calculation for the ending time. - time_points: - The number of points to interpolate. - - Returns - ------- - list of np.ndarray - List of interpolated impact matrices for each time points in the specified range. - """ - def interpolate_sm(mat_start, mat_end, time, time_points): - """Perform linear interpolation between two matrices for a specified time point.""" - if time > time_points: - raise ValueError("time point must be within the range") + raise err - ratio = time / (time_points - 1) + return res - # Convert the input matrices to a format that allows efficient modification of its elements - mat_start = lil_matrix(mat_start) - mat_end = lil_matrix(mat_end) + def interp_hazard_dim( + self, metric_0, metric_1, interpolation_range: int, **kwargs + ) -> np.ndarray: + return self.hazard_interp(metric_0, metric_1, interpolation_range, **kwargs) - # Perform the linear interpolation - mat_interpolated = mat_start + ratio * (mat_end - mat_start) + def interp_vulnerability_dim( + self, metric_0, metric_1, interpolation_range: int, **kwargs + ) -> np.ndarray: + return self.vulnerability_interp( + metric_0, metric_1, interpolation_range, **kwargs + ) - return csr_matrix(mat_interpolated) - - LOGGER.debug(f"imp0: {imp0.imp_mat.data[0]}, imp1: {imp1.imp_mat.data[0]}") - return [ - interpolate_sm(imp0.imp_mat, imp1.imp_mat, time, time_points) - for time in range(time_points) - ] +class InterpolationStrategy(InterpolationStrategyBase): + """Interface for interpolation strategies.""" -class ExponentialInterpolation(InterpolationStrategy): - """Exponential interpolation strategy.""" + def __init__(self, exposure_interp, hazard_interp, vulnerability_interp) -> None: + super().__init__() + self.exposure_interp = exposure_interp + self.hazard_interp = hazard_interp + self.vulnerability_interp = vulnerability_interp - def interpolate(self, imp_E0, imp_E1, time_points: int): - return self.interpolate_imp_mat(imp_E0, imp_E1, time_points) - - @staticmethod - def interpolate_imp_mat(imp0, imp1, time_points): - """Interpolate between two impact matrices over a specified time range. - - Parameters - ---------- - imp0 : ImpactCalc - The impact calculation for the starting time. - imp1 : ImpactCalc - The impact calculation for the ending time. - time_points: - The number of points to interpolate. - - Returns - ------- - list of np.ndarray - List of interpolated impact matrices for each time points in the specified range. - """ - def interpolate_sm(mat_start, mat_end, time, time_points): - """Perform exponential interpolation between two matrices for a specified time point.""" - if time > time_points: - raise ValueError("time point must be within the range") - - # Convert matrices to logarithmic domain - log_mat_start = np.log(mat_start.toarray() + np.finfo(float).eps) - log_mat_end = np.log(mat_end.toarray() + np.finfo(float).eps) +class AllLinearStrategy(InterpolationStrategyBase): + """Linear interpolation strategy.""" - # Perform linear interpolation in the logarithmic domain - ratio = time / (time_points - 1) - log_mat_interpolated = log_mat_start + ratio * (log_mat_end - log_mat_start) + 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 - # Convert back to the original domain using the exponential function - mat_interpolated = np.exp(log_mat_interpolated) - return csr_matrix(mat_interpolated) +class ExponentialExposureInterpolation(InterpolationStrategyBase): + """Exponential interpolation strategy.""" - return [ - interpolate_sm(imp0.imp_mat, imp1.imp_mat, time, time_points) - for time in range(time_points) - ] + 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/risk_trajectory.py b/climada/trajectories/risk_trajectory.py index 502e8a42e..53409af65 100644 --- a/climada/trajectories/risk_trajectory.py +++ b/climada/trajectories/risk_trajectory.py @@ -29,12 +29,12 @@ import pandas as pd from climada.entity.disc_rates.base import DiscRates +from climada.trajectories.interpolation import InterpolationStrategyBase from climada.trajectories.riskperiod import ( + AllLinearStrategy, CalcRiskPeriod, ImpactCalcComputation, ImpactComputationStrategy, - InterpolationStrategy, - LinearInterpolation, ) from climada.trajectories.snapshot import Snapshot @@ -79,7 +79,7 @@ def __init__( risk_transf_cover=None, risk_transf_attach=None, calc_residual: bool = True, - interpolation_strategy: InterpolationStrategy | None = None, + interpolation_strategy: InterpolationStrategyBase | None = None, impact_computation_strategy: ImpactComputationStrategy | None = None, ): self._reset_metrics() @@ -94,7 +94,7 @@ def __init__( self._risk_transf_cover = risk_transf_cover self._risk_transf_attach = risk_transf_attach self._calc_residual = calc_residual - self._interpolation_strategy = interpolation_strategy or LinearInterpolation() + self._interpolation_strategy = interpolation_strategy or AllLinearStrategy() self._impact_computation_strategy = ( impact_computation_strategy or ImpactCalcComputation() ) @@ -283,6 +283,9 @@ def _generic_metrics( raise e else: tmp = tmp.set_index(["date", "group", "measure", "metric"]) + if "coord_id" in tmp.columns: + tmp = tmp.set_index(["coord_id"], append=True) + tmp = tmp[ ~tmp.index.duplicated(keep="last") ] # We want to avoid overlap when more than 2 snapshots @@ -596,6 +599,15 @@ def plot_per_date_waterfall( risk_component = self._calc_waterfall_plot_data( start_date=start_date, end_date=end_date ) + risk_component = risk_component[ + [ + "base risk", + "exposure contribution", + "hazard contribution", + "vulnerability contribution", + "interaction contribution", + ] + ] risk_component.plot(ax=ax, kind="bar", stacked=True) # Construct y-axis label and title based on parameters value_label = "USD" @@ -654,21 +666,30 @@ def plot_waterfall( labels = [ f"Risk {start_date}", f"Exposure {end_date}", - f"Hazard {end_date}¹", + f"Hazard {end_date}", + f"Vulnerability {end_date}", + f"Interaction {end_date}", f"Total Risk {end_date}", ] values = [ risk_component["base risk"], - risk_component["delta from exposure"], - risk_component["delta from hazard"], - risk_component["base risk"] - + risk_component["delta from exposure"] - + risk_component["delta from hazard"], + risk_component["exposure contribution"], + risk_component["hazard contribution"], + risk_component["vulnerability contribution"], + risk_component["interaction contribution"], + risk_component.sum(), ] bottoms = [ 0.0, risk_component["base risk"], - risk_component["base risk"] + risk_component["delta from exposure"], + risk_component["base risk"] + risk_component["exposure contribution"], + risk_component["base risk"] + + risk_component["exposure contribution"] + + risk_component["hazard contribution"], + risk_component["base risk"] + + risk_component["exposure contribution"] + + risk_component["hazard contribution"] + + risk_component["vulnerability contribution"], 0.0, ] @@ -677,7 +698,14 @@ def plot_waterfall( values, bottom=bottoms, edgecolor="black", - color=["tab:blue", "tab:orange", "tab:green", "tab:red"], + color=[ + "tab:cyan", + "tab:orange", + "tab:green", + "tab:red", + "tab:purple", + "tab:blue", + ], ) for i in range(len(values)): ax.text( @@ -695,16 +723,19 @@ def plot_waterfall( ax.set_title(title_label) ax.set_ylabel(value_label) - # ax.tick_params(axis='x', labelrotation=90,) - ax.annotate( - """¹: The increase in risk due to hazard denotes the difference in risk with future exposure -and hazard compared to risk with future exposure and present hazard.""", - xy=(0.0, -0.15), - xycoords="axes fraction", - ha="left", - va="center", - fontsize=8, + ax.tick_params( + axis="x", + labelrotation=90, ) + # ax.annotate( + # """¹: The increase in risk due to hazard denotes the difference in risk with future exposure + # and hazard compared to risk with future exposure and present hazard.""", + # xy=(0.0, -0.15), + # xycoords="axes fraction", + # ha="left", + # va="center", + # fontsize=8, + # ) return ax diff --git a/climada/trajectories/riskperiod.py b/climada/trajectories/riskperiod.py index 59cf45ae2..19877c278 100644 --- a/climada/trajectories/riskperiod.py +++ b/climada/trajectories/riskperiod.py @@ -26,6 +26,7 @@ """ +import itertools import logging import numpy as np @@ -38,8 +39,9 @@ ImpactComputationStrategy, ) from climada.trajectories.interpolation import ( - InterpolationStrategy, - LinearInterpolation, + AllLinearStrategy, + InterpolationStrategyBase, + linear_interp_arrays, ) from climada.trajectories.snapshot import Snapshot @@ -109,7 +111,7 @@ def __init__( snapshot1: Snapshot, interval_freq: str | None = "AS-JAN", time_points: int | None = None, - interpolation_strategy: InterpolationStrategy | None = None, + interpolation_strategy: InterpolationStrategyBase | None = None, impact_computation_strategy: ImpactComputationStrategy | None = None, risk_transf_attach: float | None = None, risk_transf_cover: float | None = None, @@ -125,7 +127,7 @@ def __init__( freq=interval_freq, name="date", ) - self.interpolation_strategy = interpolation_strategy or LinearInterpolation() + self.interpolation_strategy = interpolation_strategy or AllLinearStrategy() self.impact_computation_strategy = ( impact_computation_strategy or ImpactCalcComputation() ) @@ -146,12 +148,17 @@ def __init__( ) def _reset_impact_data(self): - self._impacts_arrays = None - self._imp_mats_H0, self._imp_mats_H1 = None, None - self._imp_mats_E0, self._imp_mats_E1 = None, None - self._per_date_eai_H0, self._per_date_eai_H1 = None, None - self._per_date_aai_H0, self._per_date_aai_H1 = None, None + for fut in list(itertools.product([0, 1], repeat=3)): + setattr(self, f"_E{fut[0]}H{fut[1]}V{fut[2]}", None) + + for fut in list(itertools.product([0, 1], repeat=2)): + setattr(self, f"_imp_mats_H{fut[0]}V{fut[1]}", None) + setattr(self, f"_per_date_eai_H{fut[0]}V{fut[1]}", None) + setattr(self, f"_per_date_aai_H{fut[0]}V{fut[1]}", None) + self._eai_gdf = None + self._per_date_eai = None + self._per_date_aai = None self._per_date_return_periods_H0, self._per_date_return_periods_H1 = None, None @staticmethod @@ -233,8 +240,6 @@ def date_idx(self, value, /): self._date_idx = value.normalize() # Avoids weird hourly data self._time_points = len(self.date_idx) self._interval_freq = pd.infer_freq(self.date_idx) - self._prop_H1 = np.linspace(0, 1, num=self.time_points) - self._prop_H0 = 1 - self._prop_H1 self._reset_impact_data() @property @@ -267,7 +272,7 @@ def interpolation_strategy(self): @interpolation_strategy.setter def interpolation_strategy(self, value, /): - if not isinstance(value, InterpolationStrategy): + if not isinstance(value, InterpolationStrategyBase): raise ValueError("Not an interpolation strategy") self._interpolation_strategy = value @@ -285,31 +290,99 @@ def impact_computation_strategy(self, value, /): self._impact_computation_strategy = value self._reset_impact_data() + ##### Impact objects cube ##### + @lazy_property - def impacts_arrays(self): + def E0H0V0(self): return self.impact_computation_strategy.compute_impacts( self.snapshot0, self.snapshot1, + (0, 0, 0), self.risk_transf_attach, self.risk_transf_cover, self.calc_residual, ) - @property - def _E0H0(self): - return self.impacts_arrays[0] + @lazy_property + def E1H0V0(self): + return self.impact_computation_strategy.compute_impacts( + self.snapshot0, + self.snapshot1, + (1, 0, 0), + self.risk_transf_attach, + self.risk_transf_cover, + self.calc_residual, + ) - @property - def _E1H0(self): - return self.impacts_arrays[1] + @lazy_property + def E0H1V0(self): + return self.impact_computation_strategy.compute_impacts( + self.snapshot0, + self.snapshot1, + (0, 1, 0), + self.risk_transf_attach, + self.risk_transf_cover, + self.calc_residual, + ) - @property - def _E0H1(self): - return self.impacts_arrays[2] + @lazy_property + def E1H1V0(self): + return self.impact_computation_strategy.compute_impacts( + self.snapshot0, + self.snapshot1, + (1, 1, 0), + self.risk_transf_attach, + self.risk_transf_cover, + self.calc_residual, + ) - @property - def _E1H1(self): - return self.impacts_arrays[3] + @lazy_property + def E0H0V1(self): + return self.impact_computation_strategy.compute_impacts( + self.snapshot0, + self.snapshot1, + (0, 0, 1), + self.risk_transf_attach, + self.risk_transf_cover, + self.calc_residual, + ) + + @lazy_property + def E1H0V1(self): + return self.impact_computation_strategy.compute_impacts( + self.snapshot0, + self.snapshot1, + (1, 0, 1), + self.risk_transf_attach, + self.risk_transf_cover, + self.calc_residual, + ) + + @lazy_property + def E0H1V1(self): + return self.impact_computation_strategy.compute_impacts( + self.snapshot0, + self.snapshot1, + (0, 1, 1), + self.risk_transf_attach, + self.risk_transf_cover, + self.calc_residual, + ) + + @lazy_property + def E1H1V1(self): + return self.impact_computation_strategy.compute_impacts( + self.snapshot0, + self.snapshot1, + (1, 1, 1), + self.risk_transf_attach, + self.risk_transf_cover, + self.calc_residual, + ) + + ############################### + + ######## Risk transfer ######## @property def risk_transf_attach(self): @@ -341,64 +414,126 @@ def calc_residual(self, value, /): self._calc_residual = value self._reset_impact_data() + ############################### + + ### Impact Matrices arrays #### + @lazy_property - def imp_mats_H0(self): - return self.interpolation_strategy.interpolate( - self._E0H0, self._E1H0, self.time_points + def imp_mats_H0V0(self): + return self.interpolation_strategy.interp_exposure_dim( + self.E0H0V0.imp_mat, self.E1H0V0.imp_mat, self.time_points ) @lazy_property - def imp_mats_H1(self): - return self.interpolation_strategy.interpolate( - self._E0H1, self._E1H1, self.time_points + def imp_mats_H1V0(self): + return self.interpolation_strategy.interp_exposure_dim( + self.E0H1V0.imp_mat, self.E1H1V0.imp_mat, self.time_points ) @lazy_property - def imp_mats_E0(self): - return self.interpolation_strategy.interpolate( - self._E0H0, self._E0H1, self.time_points + def imp_mats_H0V1(self): + return self.interpolation_strategy.interp_exposure_dim( + self.E0H0V1.imp_mat, self.E1H0V1.imp_mat, self.time_points ) @lazy_property - def imp_mats_E1(self): - return self.interpolation_strategy.interpolate( - self._E1H0, self._E1H1, self.time_points + def imp_mats_H1V1(self): + return self.interpolation_strategy.interp_exposure_dim( + self.E0H1V1.imp_mat, self.E1H1V1.imp_mat, self.time_points ) + ############################### + + ########## Base EAI ########### + @lazy_property - def per_date_eai_H0(self): + def per_date_eai_H0V0(self): return self.calc_per_date_eais( - self.imp_mats_H0, self.snapshot0.hazard.frequency + self.imp_mats_H0V0, self.snapshot0.hazard.frequency ) @lazy_property - def per_date_eai_H1(self): + def per_date_eai_H1V0(self): return self.calc_per_date_eais( - self.imp_mats_H1, self.snapshot1.hazard.frequency + self.imp_mats_H1V0, self.snapshot1.hazard.frequency ) @lazy_property - def per_date_aai_H0(self): - return self.calc_per_date_aais(self.per_date_eai_H0) + def per_date_eai_H0V1(self): + return self.calc_per_date_eais( + self.imp_mats_H0V1, self.snapshot0.hazard.frequency + ) @lazy_property - def per_date_aai_H1(self): - return self.calc_per_date_aais(self.per_date_eai_H1) + def per_date_eai_H1V1(self): + return self.calc_per_date_eais( + self.imp_mats_H1V1, self.snapshot1.hazard.frequency + ) + + ################################## + + ######### Specific AAIs ########## @lazy_property - def eai_gdf(self): - return self.calc_eai_gdf() + def per_date_aai_H0V0(self): + return self.calc_per_date_aais(self.per_date_eai_H0V0) + + @lazy_property + def per_date_aai_H1V0(self): + return self.calc_per_date_aais(self.per_date_eai_H1V0) + + @lazy_property + def per_date_aai_H0V1(self): + return self.calc_per_date_aais(self.per_date_eai_H0V1) + + @lazy_property + def per_date_aai_H1V1(self): + return self.calc_per_date_aais(self.per_date_eai_H1V1) - def per_date_return_periods_H0(self, return_periods) -> np.ndarray: + ################################# + + ######### Specific RPs ######### + + def per_date_return_periods_H0V0(self, return_periods) -> np.ndarray: return self.calc_per_date_rps( - self.imp_mats_H0, self.snapshot0.hazard.frequency, return_periods + self.imp_mats_H0V0, self.snapshot0.hazard.frequency, return_periods ) - def per_date_return_periods_H1(self, return_periods) -> np.ndarray: + def per_date_return_periods_H1V0(self, return_periods) -> np.ndarray: return self.calc_per_date_rps( - self.imp_mats_H1, self.snapshot1.hazard.frequency, return_periods + self.imp_mats_H1V0, self.snapshot1.hazard.frequency, return_periods ) + def per_date_return_periods_H0V1(self, return_periods) -> np.ndarray: + return self.calc_per_date_rps( + self.imp_mats_H0V1, self.snapshot0.hazard.frequency, return_periods + ) + + def per_date_return_periods_H1V1(self, return_periods) -> np.ndarray: + return self.calc_per_date_rps( + self.imp_mats_H1V1, self.snapshot1.hazard.frequency, return_periods + ) + + ################################## + + ### Fully interpolated metrics ### + + @lazy_property + def per_date_aai(self): + return self.calc_per_date_aais(self.per_date_eai) + + @lazy_property + def per_date_eai(self): + return self.calc_eai() + + @lazy_property + def eai_gdf(self): + return self.calc_eai_gdf() + + #################################### + + ### Metrics from impact matrices ### + @classmethod def calc_per_date_eais(cls, imp_mats, frequency) -> np.ndarray: """ @@ -523,16 +658,34 @@ def calc_freq_curve(cls, imp_mat_intrpl, frequency, return_per=None) -> np.ndarr return ifc_impact + #################################### + + ##### Interpolation of metrics ##### + + def calc_eai(self): + per_date_eai_H0V0, per_date_eai_H1V0, per_date_eai_H0V1, per_date_eai_H1V1 = ( + self.per_date_eai_H0V0, + self.per_date_eai_H1V0, + self.per_date_eai_H0V1, + self.per_date_eai_H1V1, + ) + per_date_eai_V0 = self.interpolation_strategy.interp_hazard_dim( + per_date_eai_H0V0, per_date_eai_H1V0, self.time_points + ) + per_date_eai_V1 = self.interpolation_strategy.interp_hazard_dim( + per_date_eai_H0V1, per_date_eai_H1V1, self.time_points + ) + per_date_eai = self.interpolation_strategy.interp_vulnerability_dim( + per_date_eai_V0, per_date_eai_V1, self.time_points + ) + return per_date_eai + def calc_eai_gdf(self): - per_date_eai_H0, per_date_eai_H1 = (self.per_date_eai_H0, self.per_date_eai_H1) - per_date_eai = np.multiply( - self._prop_H0.reshape(-1, 1), per_date_eai_H0 - ) + np.multiply(self._prop_H1.reshape(-1, 1), per_date_eai_H1) - df = pd.DataFrame(per_date_eai, index=self.date_idx) + df = pd.DataFrame(self.per_date_eai, index=self.date_idx) df = df.reset_index().melt( id_vars="date", var_name="coord_id", value_name="risk" ) - eai_gdf = self.snapshot1.exposure.gdf + eai_gdf = self.snapshot0.exposure.gdf eai_gdf["coord_id"] = eai_gdf.index eai_gdf = eai_gdf.merge(df, on="coord_id") eai_gdf = eai_gdf.rename( @@ -543,9 +696,9 @@ def calc_eai_gdf(self): return eai_gdf def calc_aai_metric(self): - per_date_aai_H0, per_date_aai_H1 = self.per_date_aai_H0, self.per_date_aai_H1 - per_date_aai = self._prop_H0 * per_date_aai_H0 + self._prop_H1 * per_date_aai_H1 - aai_df = pd.DataFrame(index=self.date_idx, columns=["risk"], data=per_date_aai) + aai_df = pd.DataFrame( + index=self.date_idx, columns=["risk"], data=self.per_date_aai + ) aai_df["group"] = pd.NA aai_df["metric"] = "aai" aai_df["measure"] = self.measure.name if self.measure else "no_measure" @@ -553,41 +706,53 @@ def calc_aai_metric(self): return aai_df def calc_aai_per_group_metric(self): - aai_per_group_df = [] - for group in np.unique( - np.concatenate(np.array([self._group_id_E0, self._group_id_E1]), axis=0) - ): - group_idx_E0 = np.where(self._group_id_E0 == group)[0] - group_idx_E1 = np.where(self._group_id_E1 == group)[0] - per_date_aai_H0, per_date_aai_H1 = ( - self.per_date_eai_H0[:, group_idx_E0].sum(axis=1), - self.per_date_eai_H1[:, group_idx_E1].sum(axis=1), + 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 pd.DataFrame() + + eai_pres_groups = self.eai_gdf[["date", "coord_id", "group", "risk"]].copy() + aai_per_group_df = eai_pres_groups.groupby(["date", "group"], as_index=False)[ + "risk" + ].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 = self.eai_gdf.copy() + eai_fut_groups.index = self._group_id_E1 + aai_fut_groups = ( + eai_fut_groups.groupby(["date", "group"], as_index=False)["risk"] + .sum() + .values() ) - per_date_aai = ( - self._prop_H0 * per_date_aai_H0 + self._prop_H1 * per_date_aai_H1 + aai_per_group_df["risk"] = linear_interp_arrays( + aai_per_group_df["risk"], aai_fut_groups, self.time_points ) - df = pd.DataFrame(index=self.date_idx, columns=["risk"], data=per_date_aai) - df["group"] = group - aai_per_group_df.append(df) - - # If no groups defined - if not aai_per_group_df: - return None - aai_per_group_df = pd.concat(aai_per_group_df) + aai_per_group_df["metric"] = "aai" aai_per_group_df["measure"] = ( self.measure.name if self.measure else "no_measure" ) - aai_per_group_df.reset_index(inplace=True) return aai_per_group_df def calc_return_periods_metric(self, return_periods): - rp_0, rp_1 = ( - self.per_date_return_periods_H0(return_periods), - self.per_date_return_periods_H1(return_periods), + # maybe wrong, to be reworked by concatenating imp_mats first + 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_hazard_dim( + per_date_rp_H0V0, per_date_rp_H1V0, self.time_points ) - per_date_rp = np.multiply(self._prop_H0.reshape(-1, 1), rp_0) + np.multiply( - self._prop_H1.reshape(-1, 1), rp_1 + per_date_rp_V1 = self.interpolation_strategy.interp_hazard_dim( + per_date_rp_H0V1, per_date_rp_H1V1, self.time_points + ) + per_date_rp = self.interpolation_strategy.interp_vulnerability_dim( + per_date_rp_V0, per_date_rp_V1, self.time_points ) rp_df = pd.DataFrame( index=self.date_idx, columns=return_periods, data=per_date_rp @@ -599,21 +764,40 @@ def calc_return_periods_metric(self, return_periods): return rp_df def calc_risk_components_metric(self): - per_date_aai_H0, per_date_aai_H1 = self.per_date_aai_H0, self.per_date_aai_H1 - per_date_aai = self._prop_H0 * per_date_aai_H0 + self._prop_H1 * per_date_aai_H1 - - risk_dev_0 = per_date_aai_H0 - per_date_aai[0] - risk_cc_0 = per_date_aai - (risk_dev_0 + per_date_aai[0]) + per_date_aai_V0 = self.interpolation_strategy.interp_vulnerability_dim( + self.per_date_aai_H0V0, self.per_date_aai_H1V0, self.time_points + ) + per_date_aai_H0 = self.interpolation_strategy.interp_vulnerability_dim( + self.per_date_aai_H0V0, self.per_date_aai_H0V1, self.time_points + ) df = pd.DataFrame( { - "base risk": per_date_aai - (risk_dev_0 + risk_cc_0), - "delta from exposure": risk_dev_0, - "delta from hazard": risk_cc_0, + "total risk": self.per_date_aai, + "base risk": self.per_date_aai[0], + "exposure contribution": self.per_date_aai_H0V0 - self.per_date_aai[0], + "hazard contribution": per_date_aai_V0 + - (self.per_date_aai_H0V0 - self.per_date_aai[0]) + - self.per_date_aai[0], + "vulnerability contribution": per_date_aai_H0 + - self.per_date_aai[0] + - (self.per_date_aai_H0V0 - self.per_date_aai[0]), }, index=self.date_idx, ) + df["interaction contribution"] = df["total risk"] - ( + df["base risk"] + + df["exposure contribution"] + + df["hazard contribution"] + + df["vulnerability contribution"] + ) df = df.melt( - value_vars=["base risk", "delta from exposure", "delta from hazard"], + value_vars=[ + "base risk", + "exposure contribution", + "hazard contribution", + "vulnerability contribution", + "interaction contribution", + ], var_name="metric", value_name="risk", ignore_index=False, From d24a5b8a4460f0de7675132538d8a0b67b3de6a2 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 5 Jun 2025 16:46:26 +0200 Subject: [PATCH 041/113] test(naming): updates names --- climada/trajectories/test/test_interpolation.py | 8 ++++---- climada/trajectories/test/test_riskperiod.py | 6 +++--- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/climada/trajectories/test/test_interpolation.py b/climada/trajectories/test/test_interpolation.py index e88aace90..15e1a439c 100644 --- a/climada/trajectories/test/test_interpolation.py +++ b/climada/trajectories/test/test_interpolation.py @@ -27,8 +27,8 @@ from scipy.sparse import csr_matrix from climada.trajectories.interpolation import ( - ExponentialInterpolation, - LinearInterpolation, + AllLinearInterpolation, + ExponentialExposureInterpolation, ) @@ -42,7 +42,7 @@ def setUp(self): self.time_points = 5 # Create an instance of LinearInterpolation - self.linear_interpolation = LinearInterpolation() + self.linear_interpolation = AllLinearInterpolation() def test_interpolate(self): result = self.linear_interpolation.interpolate( @@ -84,7 +84,7 @@ def setUp(self): self.time_points = 5 # Create an instance of ExponentialInterpolation - self.exponential_interpolation = ExponentialInterpolation() + self.exponential_interpolation = ExponentialExposureInterpolation() def test_interpolate(self): result = self.exponential_interpolation.interpolate( diff --git a/climada/trajectories/test/test_riskperiod.py b/climada/trajectories/test/test_riskperiod.py index 265ad389e..35f673ca0 100644 --- a/climada/trajectories/test/test_riskperiod.py +++ b/climada/trajectories/test/test_riskperiod.py @@ -39,11 +39,11 @@ # Import the CalcRiskPeriod class and other necessary classes/functions from climada.trajectories.riskperiod import ( + AllLinearInterpolation, CalcRiskPeriod, ImpactCalcComputation, ImpactComputationStrategy, InterpolationStrategy, - LinearInterpolation, Snapshot, ) from climada.util.constants import EXP_DEMO_H5, HAZ_DEMO_H5 @@ -115,7 +115,7 @@ def setUp(self): self.mock_snapshot0, self.mock_snapshot1, interval_freq="AS-JAN", - interpolation_strategy=LinearInterpolation(), + interpolation_strategy=AllLinearInterpolation(), impact_computation_strategy=ImpactCalcComputation(), # These will have to be tested when implemented # risk_transf_attach=0.1, @@ -131,7 +131,7 @@ def test_init(self): self.calc_risk_period.time_points, self.future_date - self.present_date + 1 ) self.assertIsInstance( - self.calc_risk_period.interpolation_strategy, LinearInterpolation + self.calc_risk_period.interpolation_strategy, AllLinearInterpolation ) self.assertIsInstance( self.calc_risk_period.impact_computation_strategy, ImpactCalcComputation From 304a641cf0ae91cfcd9bc7987f22a1a5542bd4bb Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 5 Jun 2025 16:55:12 +0200 Subject: [PATCH 042/113] Squashed commit of the following: commit f312a58c4d6e22212ebd5c0733e773a8811d74b6 Merge: 2995735f 2ed84e58 Author: Samuel Juhel <10011382+spjuhel@users.noreply.github.com> Date: Wed Jun 4 15:36:52 2025 +0200 Merge pull request #977 from CLIMADA-project/feature/documentation-restructuring Restructuring of the documentation commit 2ed84e58245dba50a06dbd34281e30c465efc163 Author: spjuhel Date: Mon Jun 2 16:37:15 2025 +0200 doc(rst,changelog): fixes trailing, updates changelog commit 8797d60894f3af73fc965c87154e070f5028f1c3 Author: spjuhel Date: Mon Jun 2 16:32:03 2025 +0200 doc(rst): better margin commit 7d466a1933ebc53eb9c425d0e3c4d2e94527324a Merge: fccc4a03 2995735f Author: spjuhel Date: Mon Jun 2 16:29:06 2025 +0200 Merge remote-tracking branch 'origin/develop' into feature/documentation-restructuring commit fccc4a03facddfc723ffc15d02a775adfd6df1b4 Author: spjuhel Date: Mon Jun 2 16:15:45 2025 +0200 doc(notebooks and rst files): Applies changes from review, fixes some url commit f8611bbdc1fe2333fedd848273c1ac24327fa650 Author: spjuhel Date: Mon Jun 2 16:10:56 2025 +0200 doc(docstring): Fixes too short header specifier commit 15aeeabebd5815d7d07d3db9d021318ae5255221 Author: spjuhel Date: Mon Jun 2 16:09:53 2025 +0200 doc(changelog): Fixes right arrow and minor bugs, typos. commit 9b1f7aca12b3cb5a6bd6f9c4fb1c41a5cd347839 Author: Samuel Juhel <10011382+spjuhel@users.noreply.github.com> Date: Mon Jun 2 10:07:40 2025 +0200 Apply suggestions from code review Co-authored-by: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> commit 2995735f490e5657bedc51d13c898685b3685156 Author: Emanuel Schmid <51439563+emanuel-schmid@users.noreply.github.com> Date: Wed May 28 11:56:09 2025 +0200 Update URLs for WISC data (#944) * storm_europe: wisc.climate.copernicus.eu has moved to cds.climate.copernicus.eu * storm europe: update links * Add data links and improve docs of StormEurope --------- Co-authored-by: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> commit 3d34cd9b8da5a40ecd89225deca2e1b1d8b54577 Author: Samuel Juhel <10011382+spjuhel@users.noreply.github.com> Date: Wed May 28 11:45:47 2025 +0200 Implement equality methods for impf and impfset (#1027) * Implement equality methods for impf and impfset * Update tests --------- Co-authored-by: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> commit ac13a72a6075e67e8355f568529128e51ea7d180 Author: spjuhel Date: Mon May 19 15:24:16 2025 +0200 Addresses env setup for develop/review commit d7cae4f2779857f48545c1dbb2cd11f7e4c42d4d Author: spjuhel Date: Mon May 19 14:37:14 2025 +0200 improves Developer Guide index commit af793bc2212af90193c2aabd0eebd229736bbf26 Author: Valentin Gebhart <60438839+ValentinGebhart@users.noreply.github.com> Date: Fri May 16 17:40:51 2025 +0200 Add option in raster plot to crop around centroids (#1047) * add option to crop raster plots around centroids * update docstrings * change name of keyword parameter * change keyword name and improve docstring descriptions * updated changelog * change default value of mask parameter and update changelog commit 1a6df8ef81b221840935109b0a9419668b6a8d45 Author: Emanuel Schmid <51439563+emanuel-schmid@users.noreply.github.com> Date: Fri May 16 12:59:44 2025 +0200 Avoid pickling shapely object in Exposures.write_hdf5 (#1051) * refactor Exposures.write_hdf5 and .from_hdf5: use wkb instead of pickle for geometry serialization * refactor Exposures.write_hdf5 * change of plan: just pickle geometries in wkb format * Update climada/entity/exposures/base.py Co-authored-by: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> * abandon shapely pickling * simplify wkb columns collection * simplify wkb conversion * cosmetics --------- Co-authored-by: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> commit 51b66fa60ff35e57522eab21efd62fd3d75c8754 Author: Emanuel Schmid <51439563+emanuel-schmid@users.noreply.github.com> Date: Fri May 9 14:53:33 2025 +0200 Remove geopandas.datasets (#1052) Use cartopy.io.shapereader for loading natural earth data instead of geopandas commit a5a3fefdfbd20c68573e7a9925ac14ea64c0241a Author: emanuel-schmid Date: Tue Apr 29 13:01:13 2025 +0200 fix test_data_api commit d8b8e9a2200641d3ad2ba0e7374868f112af22ed Author: Emanuel Schmid <51439563+emanuel-schmid@users.noreply.github.com> Date: Thu Apr 24 15:16:06 2025 +0200 Raise ValueError in download_world_bank_indicator (#1050) * Fix worldbank fallback by raising a ValueError instead of a RuntimeError commit 4d2d690dd4f1d0e0b8f4d3829a235e347bf46088 Author: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> Date: Wed Apr 16 09:41:20 2025 +0200 Remove pandas-datareader (#1033) * Remove pandas-datareader Use JSON/pandas solution for downloading World Bank indicator data. * Add function `download_world_bank_indicator`. * Add unit test. * Update requirements. * Update CHANGELOG.md * Remove stray print and fix comments * Switch to compatible Petals target branch for testing REVERT THIS! * Fix linter warnings - Add timeout parameter to requests call - Remove unused import * #168 is merged Co-authored-by: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> * Apply suggestions from code review Use single list instead of nested lists Co-authored-by: Emanuel Schmid <51439563+emanuel-schmid@users.noreply.github.com> * Update reading WB data * Fall back to parsing dates if conversion to ints fails. * Throw a ValueError if no data is available. --------- Co-authored-by: emanuel-schmid Co-authored-by: Emanuel Schmid <51439563+emanuel-schmid@users.noreply.github.com> commit a2d2297a64ade90716996ca04ef2fbd789dbbde3 Author: emanuel-schmid Date: Mon Apr 7 16:21:48 2025 +0200 remove shapely 2.0 pin commit 6dc20ab2db66c7d1425a762b8fa746c717f3fa59 Merge: eda7e40c 2c34d49a Author: Samuel Juhel <10011382+spjuhel@users.noreply.github.com> Date: Mon Apr 7 14:44:24 2025 +0200 Merge pull request #1026 from CLIMADA-project/feature/improve_ee_import Better handling of optional dependency import for earth-engine commit 2c34d49a642f288025fb2ea538e24c6f3f65939b Author: emanuel-schmid Date: Mon Apr 7 10:57:51 2025 +0200 pylint commit 3db15c5fed86f0448c5a36944561e09acd172cf5 Author: emanuel-schmid Date: Mon Apr 7 10:35:04 2025 +0200 fix obvious errors commit 176db2dd6f8859b50a99cf8d7c6fc441154453c1 Merge: f2c27a7d eda7e40c Author: emanuel-schmid Date: Mon Apr 7 10:08:30 2025 +0200 Merge branch 'develop' into feature/improve_ee_import commit eda7e40cde45a7473e80f840fc5afaae31f5c5bd Author: Emanuel Schmid <51439563+emanuel-schmid@users.noreply.github.com> Date: Fri Apr 4 16:12:38 2025 +0200 Explicit arguments in TropCyclone.apply_climate_scenario_knu (#991) * trop_cyclone.apply_climate_scenario_knu: make yearly_steps argument explicit * changelog * readthedocs: explicit configuration file commit 004651bdb14cc55615020bf9b8a0e6a44b854030 Merge: 3cfbe05a 08ec51bb Author: emanuel-schmid Date: Fri Apr 4 12:45:23 2025 +0200 Merge branch 'main' into develop # Conflicts: # CHANGELOG.md # climada/_version.py # setup.py commit 08ec51bb958436cd18e77cf8f4178bc05a295d78 Author: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> Date: Fri Apr 4 12:06:06 2025 +0200 Update GitHub infrastructure (#1036) * Increase fetch depth to avoid missing the commit The target commit might not be the latest of the target branch. * Add CODEOWNERS file * dependencies: pin shapley version down to 2.0 --------- Co-authored-by: emanuel-schmid commit 3cfbe05afee5ab3eccc1cbfd05578944ba2028bc Merge: 5aeebeae cc9b33af Author: Valentin Gebhart <60438839+ValentinGebhart@users.noreply.github.com> Date: Thu Apr 3 18:20:05 2025 +0200 Merge pull request #1038 from CLIMADA-project/hotfix/plot_NaN_on_grid Hotfix: plot NaNs in geo_im_from_array commit cc9b33afe75ab3b50ad275a24f82651333efd801 Author: Valentin Gebhart Date: Thu Apr 3 17:45:09 2025 +0200 update changelog commit 01eb0bd79f23698dcf1bc3640143e3eaf8d91b5e Author: Valentin Gebhart Date: Thu Apr 3 17:34:59 2025 +0200 changed docstring and small optimization commit 94bc45d357cefd13fc9c358e1bf6ce0d0e9da760 Author: Valentin Gebhart Date: Thu Apr 3 12:09:45 2025 +0200 added edgecolor commit 3ddc5d95362d3b5de7c5253afec22f24fa48e831 Author: Valentin Gebhart Date: Thu Apr 3 12:03:35 2025 +0200 adapted NaN plot handling and include legend commit 5aeebeae46e61fdf6218913e067f62625851b949 Author: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> Date: Wed Apr 2 10:18:31 2025 +0200 Add links to new CLIMADA webpage to docs (#1021) commit ead106c439ed12a798cb2ac4b36bb3d0db13127d Author: Valentin Gebhart Date: Mon Mar 31 17:24:48 2025 +0200 added section to local exceedance tutorial commit 868066867ba11fa02d47b3fb998fd85ca9fc07b8 Merge: 95052b2d 25e4332a Author: luseverin <91593121+luseverin@users.noreply.github.com> Date: Mon Mar 24 14:37:55 2025 +0100 Merge pull request #1029 from CLIMADA-project/feature/update_euler_guide_petals Add instructions to install climada petals on Euler commit 25e4332aef9a7169ed3c702fd54456a938de027c Author: luseverin Date: Mon Mar 24 13:54:05 2025 +0100 Update changelog commit 31cb34a570742a602df0a28be4ae32451ffe87ff Author: luseverin <91593121+luseverin@users.noreply.github.com> Date: Mon Mar 24 11:23:58 2025 +0000 Specify how to work with a specific branch if needed commit 5b00f365e9e62704b489e182dcdcb3642d2327bc Author: luseverin <91593121+luseverin@users.noreply.github.com> Date: Mon Mar 24 12:11:00 2025 +0100 Correct few typos and rephrase Co-authored-by: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> commit 3b45cf930d4214e11e0e890973a86147448c23a3 Author: luseverin Date: Fri Mar 21 19:17:15 2025 +0100 Add instructions to install climada petals on Euler commit 95052b2d653cadc3382124f4c52c4681bb4a9ed3 Author: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> Date: Wed Mar 19 10:34:15 2025 +0100 Upgrade to Python 3.12 (#870) * Upgrade to Python 3.12 * Increment supported Python versions in setup.py. * Update GitHub workflow testing matrix. * Upgrade eccodes and cfgrib versions * Add prominent information on Python versions --------- Co-authored-by: emanuel-schmid commit a8a3c78c8ee3ba638df798a80e3780d3903d63e8 Author: emanuel-schmid Date: Wed Mar 19 10:07:25 2025 +0100 fix broken plot test commit 5517c89a5a0b02ebd6b51573b0f67d5df3caeac1 Author: Nicolas Colombi Date: Wed Mar 19 09:11:33 2025 +0100 Revert "change logo with QR code, the logo was ugly on the page" This reverts commit 57526731db2f02e4e0f5d6813729db01d93be9b4. commit 004a31f81eabf401785679f7e7530a4318b8745c Author: Nicolas Colombi Date: Wed Mar 19 08:49:49 2025 +0100 fix indent last dropdown getting started commit 8062f0eff75d977e9c8d9e44987c17488e77a9c7 Merge: 57526731 88e305ee Author: Nicolas Colombi Date: Wed Mar 19 08:46:04 2025 +0100 Merge branch 'feature/documentation-restructuring' of https://github.com/CLIMADA-project/climada_python into feature/documentation-restructuring commit 57526731db2f02e4e0f5d6813729db01d93be9b4 Author: Nicolas Colombi Date: Wed Mar 19 08:45:25 2025 +0100 change logo with QR code commit 88e305ee367970cd4f88fb461975e1ac720f4a2e Author: spjuhel Date: Wed Mar 19 08:35:07 2025 +0100 Tidying up after develop merged commit 9dcc2a378e974bdf22beb178d77d50279d50b135 Author: Nicolas Colombi Date: Wed Mar 19 08:24:14 2025 +0100 add links and images to getting started commit 898240d8440e32043123ab610dc590ae5549788e Merge: 6282eb7c ba6457c5 Author: spjuhel Date: Tue Mar 18 18:28:47 2025 +0100 Merge branch 'develop' into feature/documentation-restructuring commit 6282eb7c3c07ee08e4ea3eaaa3bf8ad60b5f53c1 Author: spjuhel Date: Tue Mar 18 14:00:15 2025 +0100 Improves How to navigate page commit 2ef5bd73e7d263241d9f5ae20d27c79bc4e79909 Author: spjuhel Date: Tue Mar 18 14:00:01 2025 +0100 This file is not used anymore commit fdcb21519ccbb5cb4bc254832fe122a1c6b1efa9 Author: spjuhel Date: Tue Mar 18 13:59:41 2025 +0100 Avoids section navigation in Changelog commit a66697760e89fb13d9967bed0c4240fa36496f57 Author: spjuhel Date: Tue Mar 18 13:58:27 2025 +0100 Final touch on urls commit 9a0ea1f6311f2e88ce8a19a43713a31df2e3b9b9 Merge: 2d81ae19 f2c27a7d Author: spjuhel Date: Tue Mar 18 12:01:39 2025 +0100 Merge branch 'feature/improve_ee_import' into feature/documentation-restructuring commit f2c27a7dcc3b76f86aeb6b5928fea64356e03366 Author: spjuhel Date: Tue Mar 18 11:57:23 2025 +0100 implements improvement commit 2d81ae19be487e6779e01ca2745b8561693005fa Author: spjuhel Date: Tue Mar 18 11:42:20 2025 +0100 Removes some errors messages from documentation build (see details) Several attributes of Centroids became properties and were doctringed twice, I removed the attribute docstring and improved the properties ones. commit fb7cd37028f3638381c3189f04e926844d2291b0 Author: spjuhel Date: Tue Mar 18 11:41:35 2025 +0100 Adds some near final touch commit f4d851d5f49c58743b6b442f47829cee85982ebe Merge: 99625557 7b1a6bb8 Author: spjuhel Date: Tue Mar 18 10:21:38 2025 +0100 Merge branch 'develop' into feature/documentation-restructuring commit 99625557c68af19c6fbdca3a7d8788fcd8e6794a Author: spjuhel Date: Tue Mar 18 10:08:32 2025 +0100 backtracking .md file hack commit 410223260ed46c87ed1449f5fbcff4b77b28b10f Author: spjuhel Date: Mon Mar 17 17:50:35 2025 +0100 url fixing WIP commit 400eb739b8a7ec1bc9bc8d3c5aff31c54df636dc Author: spjuhel Date: Mon Mar 17 10:47:14 2025 +0100 wip on urls commit b4421676b9914c2db78efcbd0ac2d508329aacd5 Author: Samuel Juhel <10011382+spjuhel@users.noreply.github.com> Date: Mon Mar 17 09:22:27 2025 +0100 Update urls in install.rst commit 304afb4dc02bf4ca19c1ec08bff0ed4513ee33ab Author: climada Date: Thu Mar 13 16:07:52 2025 +0000 'Automated update v6.0.1' commit bbf53a84bbf9436481e22005b1b9c000b76590d7 Merge: 3314b0ba 7459ab8c Author: emanuel-schmid Date: Thu Mar 13 16:40:23 2025 +0100 Merge branch 'develop' commit 3314b0baea9de0c69d2845793ffb3fe79aa884de Merge: a0f6d7d8 edfce31f Author: emanuel-schmid Date: Thu Mar 13 11:30:00 2025 +0100 Merge branch 'develop' # Conflicts: # climada/_version.py # setup.py commit e0d4e7e813104f604fe4c1a72c86d570c03118d0 Author: Valentin Gebhart Date: Tue Mar 11 16:44:31 2025 +0100 readd the navigation in getting started commit 97b108b2a988364da805fc1c5ebd379b9d3c8eec Author: Nicolas Colombi Date: Mon Mar 10 13:08:53 2025 +0100 getting started commit 68d2f3d739cb9616758c31ca8a7e207c4272c860 Author: Samuel Juhel <10011382+spjuhel@users.noreply.github.com> Date: Wed Mar 5 16:43:57 2025 +0100 Updates index.rst install title commit 2302e91f33f34fa45dc10456c85758ded6bf50bc Author: Samuel Juhel <10011382+spjuhel@users.noreply.github.com> Date: Wed Mar 5 16:38:36 2025 +0100 Updates impact.rst with landing content commit 754417f1a9ffd09146d85111381a94bdf08b8a76 Author: Samuel Juhel <10011382+spjuhel@users.noreply.github.com> Date: Wed Mar 5 16:26:53 2025 +0100 Updates exposures.rst with some landing content commit c95b7df87ea424ee97d72b3dcd475309a7d5aabb Author: Samuel Juhel <10011382+spjuhel@users.noreply.github.com> Date: Wed Mar 5 16:19:50 2025 +0100 Updates hazard.rst with some landing content commit 7c850a53b561f89526a814e7aea95923734e695b Author: Samuel Juhel <10011382+spjuhel@users.noreply.github.com> Date: Wed Mar 5 16:17:25 2025 +0100 Updates User Guide landing page commit 029b81dcc10071e54f714ba7acfd714667485a19 Author: Samuel Juhel <10011382+spjuhel@users.noreply.github.com> Date: Wed Mar 5 15:12:37 2025 +0100 Adds link to new website in top bar commit a0f6d7d8d060026e5323ea00f525d9b1d3fc7f4b Author: climada Date: Mon Mar 3 14:11:00 2025 +0000 'Automated update v6.0.0' commit 18d3f6a30f6ba209f27b1eabad603371d0a07a9a Merge: f2dd9b8a 51d1e829 Author: emanuel-schmid Date: Mon Mar 3 14:32:56 2025 +0100 Merge branch 'develop' commit f2dd9b8a8c89e54b398f3fdbe67115015d94488c Author: Emanuel Schmid <51439563+emanuel-schmid@users.noreply.github.com> Date: Mon Mar 3 14:24:50 2025 +0100 Fix Author List on Zenodo (#1011) * add .zenodo.json file * fix affiliation * update affiliation B.G. commit 8bb10110a93ea877e6b1116252456ab3b1f9f51d Merge: 5fba3aba 0c462e88 Author: emanuel-schmid Date: Mon Mar 3 11:37:15 2025 +0100 Merge branch 'develop' commit 5fba3aba88a263c31e5a8401db83be39eb5ee511 Merge: e4a3cfd2 d0a67525 Author: emanuel-schmid Date: Mon Mar 3 11:33:19 2025 +0100 Merge branch 'develop' into 'main' (towards release 6.0) commit 993ec4af5ba1c3559f8b04e58cbc3e65bd580006 Author: Samuel Juhel <10011382+spjuhel@users.noreply.github.com> Date: Mon Feb 24 09:33:47 2025 +0100 Update website link Co-authored-by: Emanuel Schmid <51439563+emanuel-schmid@users.noreply.github.com> commit eec248778e729f4e7627e917281df1c5e32724e7 Author: Valentin Gebhart Date: Fri Feb 7 18:15:33 2025 +0100 fixed compiling headers issues commit c0681bd6115f3f2648218be770bebbfb58da33c6 Author: Valentin Gebhart Date: Fri Feb 7 16:58:56 2025 +0100 fixed white space commit ca6b749075ba69ea589ed2bbd178c0fe71d6bf7d Author: Valentin Gebhart Date: Fri Feb 7 16:42:23 2025 +0100 updated conda installation instructions for different OS commit ef1c45264e86d0877bf67d8970d28d3da41f5e74 Author: spjuhel Date: Tue Feb 4 13:46:39 2025 +0100 forgot moving 10min climada notebook file commit c7f76c651dbfc466678b655dc960149c94328281 Author: spjuhel Date: Tue Feb 4 13:43:15 2025 +0100 Title level fixing and 10min to clim back in userguide commit f93460910dc4c469da615443c15d6539de2226e8 Author: spjuhel Date: Tue Feb 4 13:48:41 2025 +0100 Reworks getting-started section commit e958b7c17ee4084099183438550ce80a19b21c1e Author: spjuhel Date: Tue Feb 4 13:40:33 2025 +0100 More linkref fixing commit e534253c8063560bd0aac7012b779099b698d624 Author: spjuhel Date: Tue Feb 4 13:37:50 2025 +0100 Restructures development guide with subsections - Fixes links in development guide - Minor renaming commit 17e1a96f7485f980344167a2399630b218642894 Author: Valentin Gebhart Date: Tue Feb 4 09:23:22 2025 +0100 fixed typos commit f584983559d979c57e90ba4b86c38fdb1826d892 Merge: 1125d36b ac2c997d Author: Valentin Gebhart Date: Mon Feb 3 21:51:23 2025 +0100 Merge branch 'feature/documentation-restructuring' of github.com:CLIMADA-project/climada_python into feature/documentation-restructuring commit 1125d36b9cda9f5d9512dd971804b364f7d0c8ce Author: Valentin Gebhart Date: Mon Feb 3 21:51:20 2025 +0100 add some warnings and info to mamba installation commit ac2c997decbb2cd0e0597f9ab53c44117eff345b Author: spjuhel Date: Mon Feb 3 14:42:26 2025 +0100 moves pages around commit 26c10633dec72390705bf929ca64e0d8e3a63241 Author: spjuhel Date: Mon Feb 3 14:16:23 2025 +0100 fixes ``sphinx.configuration`` key is missing see https://about.readthedocs.com/blog/2024/12/deprecate-config-files-without-sphinx-or-mkdocs-config/ commit 225a734f73b7c27e9cbf2165bfc91577412a5370 Author: Valentin Gebhart Date: Mon Feb 3 11:25:58 2025 +0100 add data flow and workflow to dev intro commit ac6b5405c276404c81a3d2ea83cf6bcd1caff441 Author: Valentin Gebhart Date: Mon Feb 3 10:51:57 2025 +0100 split climada dev and git intro commit bae24b56757327b5364fbbd572f3453a5bbe6a29 Author: Valentin Gebhart Date: Tue Jan 21 15:52:06 2025 +0100 first version of 10min CLIMADA intro commit 62dfd2942fcecfd4d5d9f12824e0304d4adb59e6 Author: Valentin Gebhart Date: Mon Jan 6 16:18:01 2025 +0100 added draft for 10min intro commit 2dce78dab134f13c65eb59d770827f5364eacbb6 Author: spjuhel Date: Wed Dec 4 19:18:28 2024 +0100 changes conda to mamba commit 567a492e51d05a742db0f93cc93e8ce32071f256 Author: spjuhel Date: Wed Dec 4 19:02:44 2024 +0100 renames folder to match new naming commit efef7610ee58d8bc810187da0664278f914af3bf Author: spjuhel Date: Wed Dec 4 19:02:07 2024 +0100 creates the new toctrees to start seeing content commit 80c0694f7f591425aecc290bd7bb055669f40f28 Author: spjuhel Date: Wed Dec 4 18:58:51 2024 +0100 improves navbar header rendering commit 8b5227c39ac657baac6c394e23518c7839b25699 Author: spjuhel Date: Wed Dec 4 18:58:06 2024 +0100 fixes docstrings indentations errors commit 1d05166158f53c5ee6c16c1041715b76859a25bd Author: spjuhel Date: Fri Nov 15 09:02:01 2024 +0100 adds sphinx-design dependency commit de6d4bdc96debed9876a8141caaf5efa227ef88c Author: spjuhel Date: Fri Nov 15 08:42:23 2024 +0100 Revert "Revert "Merge branch 'feature/documentation-restructuring' into develop"" This reverts commit b8cc3c4da3ee3beb9028a5ffaeed6392c048e742. commit e4a3cfd231fd6ef91c102f9956bf3acfd08b6880 Author: climada Date: Fri Jul 19 07:57:49 2024 +0000 'Automated update v5.0.0' commit 54cc800d851e02536776f346ae233cc26792d26c Merge: 8f89ce10 70ddc93e Author: emanuel-schmid Date: Thu Jul 18 18:20:02 2024 +0200 Merge branch 'develop' commit 8f89ce10c3eaa14811c8c35247cda58de9c5516b Author: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> Date: Fri Jun 21 13:55:32 2024 +0200 Fix links in pull request template (#901) --- .github/CODEOWNERS | 7 + .github/workflows/ci.yml | 2 +- .github/workflows/pull-request.yml | 2 +- .readthedocs.yml | 3 + CHANGELOG.md | 189 +++-- CONTRIBUTING.md | 9 +- README.md | 4 +- climada/engine/impact.py | 13 +- climada/engine/unsequa/calc_base.py | 4 +- climada/engine/unsequa/calc_cost_benefit.py | 3 +- climada/engine/unsequa/unc_output.py | 12 +- climada/entity/exposures/base.py | 18 +- climada/entity/exposures/test/test_base.py | 52 +- .../impact_funcs/test/test_imp_fun_set.py | 3 +- climada/hazard/centroids/centr.py | 38 +- climada/hazard/plot.py | 55 +- climada/hazard/storm_europe.py | 17 +- climada/hazard/tc_tracks.py | 2 +- climada/hazard/test/test_tc_tracks.py | 15 +- climada/hazard/trop_cyclone/trop_cyclone.py | 9 +- climada/test/test_litpop_integr.py | 4 +- climada/test/test_plot.py | 4 +- climada/util/earth_engine.py | 295 +++---- climada/util/finance.py | 88 +- climada/util/plot.py | 45 +- climada/util/test/test_finance.py | 29 + doc/_static/css/custom.css | 39 + doc/{ => api}/climada/climada.engine.rst | 0 .../climada/climada.engine.unsequa.rst | 0 .../climada/climada.entity.disc_rates.rst | 0 .../climada.entity.exposures.litpop.rst | 0 .../climada/climada.entity.exposures.rst | 0 .../climada/climada.entity.impact_funcs.rst | 0 .../climada/climada.entity.measures.rst | 0 doc/{ => api}/climada/climada.entity.rst | 0 .../climada/climada.hazard.centroids.rst | 0 doc/{ => api}/climada/climada.hazard.rst | 0 .../climada/climada.hazard.trop_cyclone.rst | 0 doc/{ => api}/climada/climada.rst | 0 .../climada/climada.util.calibrate.rst | 0 doc/{ => api}/climada/climada.util.rst | 0 doc/api/index.rst | 12 + doc/conf.py | 26 +- .../Guide_CLIMADA_Development.ipynb} | 769 ++++-------------- .../Guide_CLIMADA_Tutorial.ipynb | 0 .../Guide_CLIMADA_conventions.ipynb | 8 +- .../Guide_Configuration.ipynb | 6 +- doc/{guide => development}/Guide_Euler.ipynb | 27 +- .../Guide_Exception_Logging.ipynb | 0 doc/development/Guide_Git_Development.ipynb | 303 +++++++ .../Guide_Py_Performance.ipynb | 0 .../Guide_PythonDos-n-Donts.ipynb | 0 doc/{guide => development}/Guide_Review.ipynb | 45 +- .../Guide_Testing.ipynb | 14 +- ...ontinuous_integration_GitHub_actions.ipynb | 0 doc/development/coding-in-python.rst | 10 + .../img/CLIMADA_logo_QR.png | Bin .../img/FileSystem-1.png | Bin .../img/FileSystem-2.png | Bin .../img/LoggerLevels.png | Bin doc/{guide => development}/img/WhenToLog.png | Bin doc/{guide => development}/img/docstring1.png | Bin doc/{guide => development}/img/docstring2.png | Bin doc/{guide => development}/img/docstring3.png | Bin doc/{guide => development}/img/docstring4.png | Bin doc/{guide => development}/img/docstring5.png | Bin doc/{guide => development}/img/dr_who.jpg | Bin doc/{guide => development}/img/flow_1.png | Bin doc/{guide => development}/img/flow_2.png | Bin doc/{guide => development}/img/flow_3.png | Bin doc/{guide => development}/img/flow_4.png | Bin doc/{guide => development}/img/fstrings.png | Bin .../img/git_github_logos.jpg | Bin doc/{guide => development}/img/git_gui.png | Bin doc/{guide => development}/img/pylint.png | Bin doc/{guide => development}/img/xkcd_git.png | Bin .../img/zen_of_python.png | Bin doc/development/index.rst | 30 + doc/development/write-documentation.rst | 9 + .../0_intro_python.ipynb | 0 .../Guide_Introduction.ipynb | 8 +- doc/getting-started/Guide_get_started.ipynb | 132 +++ doc/getting-started/index.rst | 112 +++ doc/{guide => getting-started}/install.rst | 182 ++++- doc/guide/Guide_get_started.ipynb | 135 --- doc/index.rst | 185 +++-- doc/misc/CONTRIBUTING.rst | 5 - doc/misc/README.rst | 5 - doc/misc/citation.rst | 14 +- doc/tutorial/impact.rst | 14 - doc/user-guide/0_10min_climada.ipynb | 452 ++++++++++ .../1_main_climada.ipynb | 86 +- .../climada_engine_CostBenefit.ipynb | 0 .../climada_engine_Forecast.ipynb | 0 .../climada_engine_Impact.ipynb | 12 +- .../climada_engine_impact_data.ipynb | 17 +- .../climada_engine_unsequa.ipynb | 4 +- .../climada_engine_unsequa_helper.ipynb | 0 .../climada_entity_DiscRates.ipynb | 0 .../climada_entity_Exposures.ipynb | 13 +- .../climada_entity_Exposures_osm.ipynb | 0 ...mada_entity_Exposures_polygons_lines.ipynb | 0 .../climada_entity_ImpactFuncSet.ipynb | 26 +- .../climada_entity_LitPop.ipynb | 10 +- .../climada_entity_MeasureSet.ipynb | 0 .../climada_hazard_Hazard.ipynb | 18 +- .../climada_hazard_StormEurope.ipynb | 18 +- .../climada_hazard_TropCyclone.ipynb | 13 +- .../climada_trajectories.ipynb | 0 .../climada_util_api_client.ipynb | 6 +- .../climada_util_calibrate.ipynb | 15 +- .../climada_util_earth_engine.ipynb | 8 +- ...climada_util_local_exceedance_values.ipynb | 191 ++++- .../climada_util_yearsets.ipynb | 0 doc/{tutorial => user-guide}/exposures.rst | 4 + doc/{tutorial => user-guide}/hazard.rst | 3 + .../img/UncertaintySensitivity.jpg | Bin doc/user-guide/img/cost-benefit.png | Bin 0 -> 18708 bytes doc/user-guide/img/exposure.png | Bin 0 -> 172053 bytes doc/user-guide/img/impact-function.png | Bin 0 -> 85965 bytes doc/user-guide/img/risk_framework.png | Bin 0 -> 480216 bytes doc/user-guide/img/sensitivity.png | Bin 0 -> 144886 bytes doc/user-guide/img/tc-tracks.png | Bin 0 -> 68747 bytes doc/user-guide/impact.rst | 22 + doc/user-guide/index.rst | 28 + doc/{tutorial => user-guide}/unsequa.rst | 0 requirements/env_climada.yml | 1 - script/jenkins/test_data_api.py | 10 +- setup.py | 4 +- 129 files changed, 2540 insertions(+), 1433 deletions(-) create mode 100644 .github/CODEOWNERS create mode 100644 doc/_static/css/custom.css rename doc/{ => api}/climada/climada.engine.rst (100%) rename doc/{ => api}/climada/climada.engine.unsequa.rst (100%) rename doc/{ => api}/climada/climada.entity.disc_rates.rst (100%) rename doc/{ => api}/climada/climada.entity.exposures.litpop.rst (100%) rename doc/{ => api}/climada/climada.entity.exposures.rst (100%) rename doc/{ => api}/climada/climada.entity.impact_funcs.rst (100%) rename doc/{ => api}/climada/climada.entity.measures.rst (100%) rename doc/{ => api}/climada/climada.entity.rst (100%) rename doc/{ => api}/climada/climada.hazard.centroids.rst (100%) rename doc/{ => api}/climada/climada.hazard.rst (100%) rename doc/{ => api}/climada/climada.hazard.trop_cyclone.rst (100%) rename doc/{ => api}/climada/climada.rst (100%) rename doc/{ => api}/climada/climada.util.calibrate.rst (100%) rename doc/{ => api}/climada/climada.util.rst (100%) create mode 100644 doc/api/index.rst rename doc/{guide/Guide_Git_Development.ipynb => development/Guide_CLIMADA_Development.ipynb} (60%) rename doc/{guide => development}/Guide_CLIMADA_Tutorial.ipynb (100%) rename doc/{guide => development}/Guide_CLIMADA_conventions.ipynb (98%) rename doc/{guide => development}/Guide_Configuration.ipynb (98%) rename doc/{guide => development}/Guide_Euler.ipynb (93%) rename doc/{guide => development}/Guide_Exception_Logging.ipynb (100%) create mode 100644 doc/development/Guide_Git_Development.ipynb rename doc/{guide => development}/Guide_Py_Performance.ipynb (100%) rename doc/{guide => development}/Guide_PythonDos-n-Donts.ipynb (100%) rename doc/{guide => development}/Guide_Review.ipynb (78%) rename doc/{guide => development}/Guide_Testing.ipynb (97%) rename doc/{guide => development}/Guide_continuous_integration_GitHub_actions.ipynb (100%) create mode 100644 doc/development/coding-in-python.rst rename doc/{guide => development}/img/CLIMADA_logo_QR.png (100%) rename doc/{guide => development}/img/FileSystem-1.png (100%) rename doc/{guide => development}/img/FileSystem-2.png (100%) rename doc/{guide => development}/img/LoggerLevels.png (100%) rename doc/{guide => development}/img/WhenToLog.png (100%) rename doc/{guide => development}/img/docstring1.png (100%) rename doc/{guide => development}/img/docstring2.png (100%) rename doc/{guide => development}/img/docstring3.png (100%) rename doc/{guide => development}/img/docstring4.png (100%) rename doc/{guide => development}/img/docstring5.png (100%) rename doc/{guide => development}/img/dr_who.jpg (100%) rename doc/{guide => development}/img/flow_1.png (100%) rename doc/{guide => development}/img/flow_2.png (100%) rename doc/{guide => development}/img/flow_3.png (100%) rename doc/{guide => development}/img/flow_4.png (100%) rename doc/{guide => development}/img/fstrings.png (100%) rename doc/{guide => development}/img/git_github_logos.jpg (100%) rename doc/{guide => development}/img/git_gui.png (100%) rename doc/{guide => development}/img/pylint.png (100%) rename doc/{guide => development}/img/xkcd_git.png (100%) rename doc/{guide => development}/img/zen_of_python.png (100%) create mode 100644 doc/development/index.rst create mode 100644 doc/development/write-documentation.rst rename doc/{tutorial => getting-started}/0_intro_python.ipynb (100%) rename doc/{guide => getting-started}/Guide_Introduction.ipynb (95%) create mode 100644 doc/getting-started/Guide_get_started.ipynb create mode 100644 doc/getting-started/index.rst rename doc/{guide => getting-started}/install.rst (76%) delete mode 100644 doc/guide/Guide_get_started.ipynb delete mode 100644 doc/misc/CONTRIBUTING.rst delete mode 100644 doc/misc/README.rst delete mode 100644 doc/tutorial/impact.rst create mode 100644 doc/user-guide/0_10min_climada.ipynb rename doc/{tutorial => user-guide}/1_main_climada.ipynb (99%) rename doc/{tutorial => user-guide}/climada_engine_CostBenefit.ipynb (100%) rename doc/{tutorial => user-guide}/climada_engine_Forecast.ipynb (100%) rename doc/{tutorial => user-guide}/climada_engine_Impact.ipynb (99%) rename doc/{tutorial => user-guide}/climada_engine_impact_data.ipynb (99%) rename doc/{tutorial => user-guide}/climada_engine_unsequa.ipynb (99%) rename doc/{tutorial => user-guide}/climada_engine_unsequa_helper.ipynb (100%) rename doc/{tutorial => user-guide}/climada_entity_DiscRates.ipynb (100%) rename doc/{tutorial => user-guide}/climada_entity_Exposures.ipynb (99%) rename doc/{tutorial => user-guide}/climada_entity_Exposures_osm.ipynb (100%) rename doc/{tutorial => user-guide}/climada_entity_Exposures_polygons_lines.ipynb (100%) rename doc/{tutorial => user-guide}/climada_entity_ImpactFuncSet.ipynb (99%) rename doc/{tutorial => user-guide}/climada_entity_LitPop.ipynb (99%) rename doc/{tutorial => user-guide}/climada_entity_MeasureSet.ipynb (100%) rename doc/{tutorial => user-guide}/climada_hazard_Hazard.ipynb (99%) rename doc/{tutorial => user-guide}/climada_hazard_StormEurope.ipynb (99%) rename doc/{tutorial => user-guide}/climada_hazard_TropCyclone.ipynb (99%) rename doc/{tutorial => user-guide}/climada_trajectories.ipynb (100%) rename doc/{tutorial => user-guide}/climada_util_api_client.ipynb (99%) rename doc/{tutorial => user-guide}/climada_util_calibrate.ipynb (99%) rename doc/{tutorial => user-guide}/climada_util_earth_engine.ipynb (99%) rename doc/{tutorial => user-guide}/climada_util_local_exceedance_values.ipynb (93%) rename doc/{tutorial => user-guide}/climada_util_yearsets.ipynb (100%) rename doc/{tutorial => user-guide}/exposures.rst (52%) rename doc/{tutorial => user-guide}/hazard.rst (62%) rename doc/{tutorial => user-guide}/img/UncertaintySensitivity.jpg (100%) create mode 100644 doc/user-guide/img/cost-benefit.png create mode 100644 doc/user-guide/img/exposure.png create mode 100644 doc/user-guide/img/impact-function.png create mode 100644 doc/user-guide/img/risk_framework.png create mode 100644 doc/user-guide/img/sensitivity.png create mode 100644 doc/user-guide/img/tc-tracks.png create mode 100644 doc/user-guide/impact.rst create mode 100644 doc/user-guide/index.rst rename doc/{tutorial => user-guide}/unsequa.rst (100%) diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS new file mode 100644 index 000000000..d33b10330 --- /dev/null +++ b/.github/CODEOWNERS @@ -0,0 +1,7 @@ +# This is a comment. +# Each line is a file pattern followed by one or more owners. + +# These owners will be the default owners for everything in +# the repo. Unless a later match takes precedence, they will +# be requested for review when someone opens a pull request. +* @emanuel-schmid @chahank @peanutfun diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index fa19e7581..bb2efb924 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -22,7 +22,7 @@ jobs: # Do not abort other tests if only a single one fails fail-fast: false matrix: - python-version: ["3.10", "3.11"] + python-version: ["3.10", "3.11", "3.12"] steps: - diff --git a/.github/workflows/pull-request.yml b/.github/workflows/pull-request.yml index b95037993..de26bc70f 100644 --- a/.github/workflows/pull-request.yml +++ b/.github/workflows/pull-request.yml @@ -16,7 +16,7 @@ jobs: ref: ${{ github.event.pull_request.head.sha }} - name: Checkout target commit - run: git -c protocol.version=2 fetch --no-tags --prune --no-recurse-submodules --depth=1 origin ${{ github.event.pull_request.base.ref }} + run: git -c protocol.version=2 fetch --no-tags --prune --no-recurse-submodules --depth=50 origin ${{ github.event.pull_request.base.ref }} - name: Set up Python 3.11 uses: actions/setup-python@v5 diff --git a/.readthedocs.yml b/.readthedocs.yml index 5ee23a7ae..0682f9864 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -25,3 +25,6 @@ python: formats: - pdf + +sphinx: + configuration: doc/conf.py diff --git a/CHANGELOG.md b/CHANGELOG.md index b07f905d6..80b534820 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,18 +10,36 @@ Code freeze date: YYYY-MM-DD ### Dependency Changes +Removed: + +- `pandas-datareader` + ### Added +- Added optional parameter to `geo_im_from_array`, `plot_from_gdf`, `plot_rp_imp`, `plot_rp_intensity`, +`plot_intensity`, `plot_fraction`, `_event_plot` to mask plotting when regions are too far from data points [#1047](https://github.com/CLIMADA-project/climada_python/pull/1047). To recreate previous plots (no masking), the parameter can be set to None. +- Added instructions to install Climada petals on Euler cluster in `doc.guide.Guide_Euler.ipynb` [#1029](https://github.com/CLIMADA-project/climada_python/pull/1029) + +- `ImpactFunc` and `ImpactFuncSet` now support equality comparisons via `==` [#1027](https://github.com/CLIMADA-project/climada_python/pull/1027) - `climada.entity.impact_funcs.base.ImpactFunc.__eq__` method - `climada.entity.impact_funcs.impact_func_set.ImpactFuncSet.__eq__` method ### Changed + - `Hazard.local_exceedance_intensity`, `Hazard.local_return_period` and `Impact.local_exceedance_impact`, `Impact.local_return_period`, using the `climada.util.interpolation` module: New default (no binning), binning on decimals, and faster implementation [#1012](https://github.com/CLIMADA-project/climada_python/pull/1012) +- World Bank indicator data is now downloaded directly from their API via the function `download_world_bank_indicator`, instead of relying on the `pandas-datareader` package [#1033](https://github.com/CLIMADA-project/climada_python/pull/1033) +- `Exposures.write_hdf5` pickles geometry data in WKB format, which is faster and more sustainable. [#1051](https://github.com/CLIMADA-project/climada_python/pull/1051) +- The online documentation has been completely overhauled, now uses PyData theme: [#977](https://github.com/CLIMADA-project/climada_python/pull/977) + ### Fixed +- NaN plotting issues in `geo_im_from_array`[#1038](https://github.com/CLIMADA-project/climada_python/pull/1038) +- Broken ECMWF links in pydoc of `climada.hazard.storm_europe` relocated. [#944](https://github.com/CLIMADA-project/climada_python/pull/944) + ### Deprecated ### Removed + - `climada.util.interpolation.round_to_sig_digits` [#1012](https://github.com/CLIMADA-project/climada_python/pull/1012) ## 6.0.1 @@ -45,27 +63,27 @@ Added: Updated: -- `cartopy` >=0.23 → >=0.24 -- `cfgrib` >=0.9.9,<0.9.10 → >=0.9 -- `dask` >=2024.2,<2024.3 → >=2025.2 -- `eccodes` >=2.27,<2.28 → >=2.40 -- `gdal` >=3.6 → >=3.10 -- `geopandas` >=0.14 → >=0.14,<1.0 -- `h5py` >=3.8 → >=3.12 -- `haversine` >=2.8 → >=2.9 -- `matplotlib-base` >=3.9 → >=3.10 -- `netcdf4` >=1.6 → >=1.7 -- `numba` >=0.60 → >=0.61 -- `pillow` =9.4 → =11.1 -- `pyproj` >=3.5 → >=3.7 -- `pytables` >=3.7 → >=3.10 -- `python` =3.9 → =3.11 -- `rasterio` >=1.3 → >=1.4 -- `scikit-learn` >=1.5 → >=1.6 -- `scipy` >=1.13 → >=1.14,<1.15 -- `tqdm` >=4.66 → >=4.67 -- `xarray` >=2024.6 → >=2025.1 -- `xlsxwriter` >=3.1 → >=3.2 +- `cartopy` >=0.23 → >=0.24 +- `cfgrib` >=0.9.9,<0.9.10 → >=0.9 +- `dask` >=2024.2,<2024.3 → >=2025.2 +- `eccodes` >=2.27,<2.28 → >=2.40 +- `gdal` >=3.6 → >=3.10 +- `geopandas` >=0.14 → >=0.14,<1.0 +- `h5py` >=3.8 → >=3.12 +- `haversine` >=2.8 → >=2.9 +- `matplotlib-base` >=3.9 → >=3.10 +- `netcdf4` >=1.6 → >=1.7 +- `numba` >=0.60 → >=0.61 +- `pillow` =9.4 → =11.1 +- `pyproj` >=3.5 → >=3.7 +- `pytables` >=3.7 → >=3.10 +- `python` =3.9 → =3.11 +- `rasterio` >=1.3 → >=1.4 +- `scikit-learn` >=1.5 → >=1.6 +- `scipy` >=1.13 → >=1.14,<1.15 +- `tqdm` >=4.66 → >=4.67 +- `xarray` >=2024.6 → >=2025.1 +- `xlsxwriter` >=3.1 → >=3.2 Removed: @@ -76,7 +94,7 @@ Removed: - `climada.hazard.tc_tracks.TCTracks.subset_years` function [#1023](https://github.com/CLIMADA-project/climada_python/pull/1023) - `climada.hazard.tc_tracks.TCTracks.from_FAST` function, add Australia basin (AU) [#993](https://github.com/CLIMADA-project/climada_python/pull/993) - Add `osm-flex` package to CLIMADA core [#981](https://github.com/CLIMADA-project/climada_python/pull/981) -- `doc.tutorial.climada_entity_Exposures_osm.ipynb` tutorial explaining how to use `osm-flex`with CLIMADA +- `doc.tutorial.climada_entity_Exposures_osm.ipynb` tutorial explaining how to use `osm-flex` with CLIMADA - `climada.util.coordinates.bounding_box_global` function [#980](https://github.com/CLIMADA-project/climada_python/pull/980) - `climada.util.coordinates.bounding_box_from_countries` function [#980](https://github.com/CLIMADA-project/climada_python/pull/980) - `climada.util.coordinates.bounding_box_from_cardinal_bounds` function [#980](https://github.com/CLIMADA-project/climada_python/pull/980) @@ -108,8 +126,8 @@ Removed: - the _geometry_ column of the inherent `GeoDataFrame` is set up at initialization - latitude and longitude column are no longer present there (the according arrays can be retrieved as properties of the Exposures object: `exp.latitude` instead of `exp.gdf.latitude.values`). - `Exposures.gdf` has been renamed to `Exposures.data` (it still works though, as it is a property now pointing to the latter) -- the `check` method does not add a default "IMPF_" column to the GeoDataFrame anymore -- Updated IBTrACS version from v4.0 to v4.1 ([#976](https://github.com/CLIMADA-project/climada_python/pull/976) +- the `check` method does not add a default `'IMPF_'` column to the GeoDataFrame anymore +- Updated IBTrACS version from v4.0 to v4.1 [#976](https://github.com/CLIMADA-project/climada_python/pull/976) - Fix xarray future warning in TCTracks for .dims to .sizes - Fix hazard.concatenate type test for pathos pools @@ -143,20 +161,20 @@ Added: Updated: -- `bottleneck` >=1.3 → >=1.4 -- `cartopy` >=0.22 → >=0.23 -- `contextily` >=1.5 → >=1.6 -- `dask` >=2024.1,<2024.3 → >=2024.2,<2024.3 -- `matplotlib-base` >=3.8 → >=3.9 -- `numba` >=0.59 → >=0.60 -- `numexpr` >=2.9 → >=2.10 -- `pint` >=0.23 → >=0.24 -- `pycountry` >=22.3 → >=24.6 -- `requests` >=2.31 → >=2.32 -- `salib` >=1.4 → >=1.5 -- `scikit-learn` >=1.4 → >=1.5 -- `scipy` >=1.12 → >=1.13 -- `xarray` >=2024.2 → >=2024.6 +- `bottleneck` >=1.3 → >=1.4 +- `cartopy` >=0.22 → >=0.23 +- `contextily` >=1.5 → >=1.6 +- `dask` >=2024.1,<2024.3 → >=2024.2,<2024.3 +- `matplotlib-base` >=3.8 → >=3.9 +- `numba` >=0.59 → >=0.60 +- `numexpr` >=2.9 → >=2.10 +- `pint` >=0.23 → >=0.24 +- `pycountry` >=22.3 → >=24.6 +- `requests` >=2.31 → >=2.32 +- `salib` >=1.4 → >=1.5 +- `scikit-learn` >=1.4 → >=1.5 +- `scipy` >=1.12 → >=1.13 +- `xarray` >=2024.2 → >=2024.6 ### Added @@ -191,6 +209,7 @@ CLIMADA tutorials. [#872](https://github.com/CLIMADA-project/climada_python/pull - `Impact.from_hdf5` now calls `str` on `event_name` data that is not strings, and issue a warning then [#894](https://github.com/CLIMADA-project/climada_python/pull/894) - `Impact.write_hdf5` now throws an error if `event_name` is does not contain strings exclusively [#894](https://github.com/CLIMADA-project/climada_python/pull/894) - Split `climada.hazard.trop_cyclone` module into smaller submodules without affecting module usage [#911](https://github.com/CLIMADA-project/climada_python/pull/911) +- `yearly_steps` parameter of `TropCyclone.apply_climate_scenario_knu` has been made explicit [#991](https://github.com/CLIMADA-project/climada_python/pull/991) ### Fixed @@ -261,17 +280,17 @@ Added: Updated: -- `contextily` >=1.3 → >=1.5 -- `dask` >=2023 → >=2024 -- `numba` >=0.57 → >=0.59 -- `pandas` >=2.1 → >=2.1,<2.2 -- `pint` >=0.22 → >=0.23 -- `scikit-learn` >=1.3 → >=1.4 -- `scipy` >=1.11 → >=1.12 -- `sparse` >=0.14 → >=0.15 -- `xarray` >=2023.8 → >=2024.1 -- `overpy` =0.6 → =0.7 -- `peewee` =3.16.3 → =3.17.1 +- `contextily` >=1.3 → >=1.5 +- `dask` >=2023 → >=2024 +- `numba` >=0.57 → >=0.59 +- `pandas` >=2.1 → >=2.1,<2.2 +- `pint` >=0.22 → >=0.23 +- `scikit-learn` >=1.3 → >=1.4 +- `scipy` >=1.11 → >=1.12 +- `sparse` >=0.14 → >=0.15 +- `xarray` >=2023.8 → >=2024.1 +- `overpy` =0.6 → =0.7 +- `peewee` =3.16.3 → =3.17.1 Removed: @@ -280,7 +299,7 @@ Removed: ### Added - Convenience method `api_client.Client.get_dataset_file`, combining `get_dataset_info` and `download_dataset`, returning a single file objet. [#821](https://github.com/CLIMADA-project/climada_python/pull/821) -- Read and Write methods to and from csv files for the `DiscRates` class. [#818](ttps://github.com/CLIMADA-project/climada_python/pull/818) +- Read and Write methods to and from csv files for the `DiscRates` class. [#818](https://github.com/CLIMADA-project/climada_python/pull/818) - Add `CalcDeltaClimate` to unsequa module to allow uncertainty and sensitivity analysis of impact change calculations [#844](https://github.com/CLIMADA-project/climada_python/pull/844) - Add function `safe_divide` in util which handles division by zero and NaN values in the numerator or denominator [#844](https://github.com/CLIMADA-project/climada_python/pull/844) - Add reset_frequency option for the impact.select() function. [#847](https://github.com/CLIMADA-project/climada_python/pull/847) @@ -314,13 +333,13 @@ Release date: 2023-09-27 Added: -- `matplotlib-base` None → >=3.8 +- `matplotlib-base` None → >=3.8 Changed: -- `geopandas` >=0.13 → >=0.14 -- `pandas` >=1.5,<2.0 → >=2.1 -- `salib` >=1.3.0 → >=1.4.7 +- `geopandas` >=0.13 → >=0.14 +- `pandas` >=1.5,<2.0 → >=2.1 +- `salib` >=1.3.0 → >=1.4.7 Removed: @@ -349,37 +368,37 @@ Added: Changed: -- `cartopy` >=0.20.0,<0.20.3 → >=0.21 -- `cfgrib` >=0.9.7,<0.9.10 → =0.9.9 -- `contextily` >=1.0 → >=1.3 -- `dask` >=2.25 → >=2023 -- `eccodes` [auto] → =2.27 -- `gdal` !=3.4.1 → >=3.6 -- `geopandas` >=0.8 → >=0.13 -- `h5py` >=2.10 → >=3.8 -- `haversine` >=2.3 → >=2.8 -- `matplotlib` >=3.2,< 3.6 → >=3.7 -- `netcdf4` >=1.5 → >=1.6 -- `numba` >=0.51,!=0.55.0 → >=0.57 -- `openpyxl` >=3.0 → >=3.1 -- `pandas-datareader` >=0.9 → >=0.10 -- `pathos` >=0.2 → >=0.3 -- `pint` >=0.15 → >=0.22 -- `proj` !=9.0.0 → >=9.1 -- `pycountry` >=20.7 → >=22.3 -- `pytables` >=3.6 → >=3.7 -- `rasterio` >=1.2.7,<1.3 → >=1.3 -- `requests` >=2.24 → >=2.31 -- `salib` >=1.3.0 → >=1.4 -- `scikit-learn` >=1.0 → >=1.2 -- `scipy` >=1.6 → >=1.10 -- `sparse` >=0.13 → >=0.14 -- `statsmodels` >=0.11 → >=0.14 -- `tabulate` >=0.8 → >=0.9 -- `tqdm` >=4.48 → >=4.65 -- `xarray` >=0.13 → >=2023.5 -- `xlrd` >=1.2 → >=2.0 -- `xlsxwriter` >=1.3 → >=3.1 +- `cartopy` >=0.20.0,<0.20.3 → >=0.21 +- `cfgrib` >=0.9.7,<0.9.10 → =0.9.9 +- `contextily` >=1.0 → >=1.3 +- `dask` >=2.25 → >=2023 +- `eccodes` [auto] → =2.27 +- `gdal` !=3.4.1 → >=3.6 +- `geopandas` >=0.8 → >=0.13 +- `h5py` >=2.10 → >=3.8 +- `haversine` >=2.3 → >=2.8 +- `matplotlib` >=3.2,< 3.6 → >=3.7 +- `netcdf4` >=1.5 → >=1.6 +- `numba` >=0.51,!=0.55.0 → >=0.57 +- `openpyxl` >=3.0 → >=3.1 +- `pandas-datareader` >=0.9 → >=0.10 +- `pathos` >=0.2 → >=0.3 +- `pint` >=0.15 → >=0.22 +- `proj` !=9.0.0 → >=9.1 +- `pycountry` >=20.7 → >=22.3 +- `pytables` >=3.6 → >=3.7 +- `rasterio` >=1.2.7,<1.3 → >=1.3 +- `requests` >=2.24 → >=2.31 +- `salib` >=1.3.0 → >=1.4 +- `scikit-learn` >=1.0 → >=1.2 +- `scipy` >=1.6 → >=1.10 +- `sparse` >=0.13 → >=0.14 +- `statsmodels` >=0.11 → >=0.14 +- `tabulate` >=0.8 → >=0.9 +- `tqdm` >=4.48 → >=4.65 +- `xarray` >=0.13 → >=2023.5 +- `xlrd` >=1.2 → >=2.0 +- `xlsxwriter` >=1.3 → >=3.1 Removed: diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index f21b73e95..2ee11385f 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -12,11 +12,11 @@ For orientation, these are some categories of possible contributions we can thin * **New Modules and Utility Functions:** Did you create a function or an entire module you find useful for your work? Maybe you are not the only one! Feel free to simply raise a pull request for functions that improve, e.g., plotting or data handling. As an entire module has to be carefully integrated into the framework, it might help if you talk to us first so we can design the module and plan the next steps. You can do that by raising an issue or starting a [discussion](https://github.com/CLIMADA-project/climada_python/discussions) on GitHub. A good place to start a personal discussion is our monthly CLIMADA developers call. -Please contact the [lead developers](https://wcr.ethz.ch/research/climada.html) if you want to join. +Please contact the [lead developers](https://climada.ethz.ch/team/) if you want to join. ## Why Should You Contribute? -* You will be listed as author of the CLIMADA repository in the [AUTHORS](AUTHORS.md) file. +* You will be listed as author of the CLIMADA repository in the [AUTHORS][authors] file. * You will improve the quality of the CLIMADA software for you and for everybody else using it. * You will gain insights into scientific software development. @@ -40,7 +40,7 @@ To contribute follow these steps: ```bash pylint ``` -6. Add your name to the [AUTHORS](AUTHORS.md) file. +6. Add your name to the [AUTHORS][authors] file. 7. Push your updates to the remote repository: ```bash @@ -83,4 +83,5 @@ It also contains a checklist for both pull request authors and reviewers to guid [docs]: https://climada-python.readthedocs.io/en/latest/ [devguide]: https://climada-python.readthedocs.io/en/latest/#developer-guide -[testing]: https://climada-python.readthedocs.io/en/latest/guide/Guide_Testing.html +[testing]: https://climada-python.readthedocs.io/en/latest/development/Guide_Testing.html +[authors]: https://github.com/CLIMADA-project/climada_python/blob/main/AUTHORS.md diff --git a/README.md b/README.md index d51e9f83c..6c09a6f67 100644 --- a/README.md +++ b/README.md @@ -16,9 +16,9 @@ CLIMADA is divided into two parts (two repositories): 1. the core [climada_python](https://github.com/CLIMADA-project/climada_python) contains all the modules necessary for the probabilistic impact, the averted damage, uncertainty and forecast calculations. Data for hazard, exposures and impact functions can be obtained from the [data API](https://github.com/CLIMADA-project/climada_python/blob/main/doc/tutorial/climada_util_api_client.ipynb). [Litpop](https://github.com/CLIMADA-project/climada_python/blob/main/doc/tutorial/climada_entity_LitPop.ipynb) is included as demo Exposures module, and [Tropical cyclones](https://github.com/CLIMADA-project/climada_python/blob/main/doc/tutorial/climada_hazard_TropCyclone.ipynb) is included as a demo Hazard module. 2. the petals [climada_petals](https://github.com/CLIMADA-project/climada_petals) contains all the modules for generating data (e.g., TC_Surge, WildFire, OpenStreeMap, ...). Most development is done here. The petals builds-upon the core and does not work as a stand-alone. -It is recommend for new users to begin with the core (1) and the [tutorials](https://github.com/CLIMADA-project/climada_python/tree/main/doc/tutorial) therein. +For new users, we recommend to begin with the core (1) and the [tutorials](https://github.com/CLIMADA-project/climada_python/tree/main/doc/tutorial) therein. -This is the Python (3.9+) version of CLIMADA - please see [here](https://github.com/davidnbresch/climada) for backward compatibility with the MATLAB version. +This is the Python version of CLIMADA - please see [here](https://github.com/davidnbresch/climada) for backward compatibility with the MATLAB version. ## Getting started diff --git a/climada/engine/impact.py b/climada/engine/impact.py index f0b22767e..da95f44bf 100644 --- a/climada/engine/impact.py +++ b/climada/engine/impact.py @@ -1178,6 +1178,7 @@ def plot_rp_imp( return_periods=(25, 50, 100, 250), log10_scale=True, axis=None, + mask_distance=0.01, kwargs_local_exceedance_impact=None, **kwargs, ): @@ -1194,6 +1195,11 @@ def plot_rp_imp( plot impact as log10(impact). Default: True smooth : bool, optional smooth plot to plot.RESOLUTIONxplot.RESOLUTION. Default: True + mask_distance: float, optional + Only regions are plotted that are closer to any of the data points than this distance, + relative to overall plot size. For instance, to only plot values + at the centroids, use mask_distance=0.01. If None, the plot is not masked. + Default is 0.01. kwargs_local_exceedance_impact: dict Dictionary of keyword arguments for the method impact.local_exceedance_impact. kwargs : dict, optional @@ -1242,7 +1248,12 @@ def plot_rp_imp( ) axis = u_plot.plot_from_gdf( - impacts_stats, title, column_labels, axis=axis, **kwargs + impacts_stats, + title, + column_labels, + axis=axis, + mask_distance=mask_distance, + **kwargs, ) return axis, impacts_stats_vals diff --git a/climada/engine/unsequa/calc_base.py b/climada/engine/unsequa/calc_base.py index 0c7b6d725..901661f6e 100644 --- a/climada/engine/unsequa/calc_base.py +++ b/climada/engine/unsequa/calc_base.py @@ -223,7 +223,7 @@ def make_sample(self, N, sampling_method="saltelli", sampling_kwargs=None): The 'ff' sampling method does not require a value for the N parameter. The inputed N value is hence ignored in the sampling process in the case of this method. - The 'ff' sampling method requires a number of uncerainty parameters to be + The 'ff' sampling method requires a number of uncertainty parameters to be a power of 2. The users can generate dummy variables to achieve this requirement. Please refer to https://salib.readthedocs.io/en/latest/api.html for more details. @@ -231,7 +231,7 @@ def make_sample(self, N, sampling_method="saltelli", sampling_kwargs=None): See Also -------- SALib.sample: sampling methods from SALib SALib.sample - https://salib.readthedocs.io/en/latest/api.html + https://salib.readthedocs.io/en/latest/api.html """ diff --git a/climada/engine/unsequa/calc_cost_benefit.py b/climada/engine/unsequa/calc_cost_benefit.py index 8d574b2c3..05fffbc9b 100644 --- a/climada/engine/unsequa/calc_cost_benefit.py +++ b/climada/engine/unsequa/calc_cost_benefit.py @@ -53,8 +53,7 @@ class CalcCostBenefit(Calc): - """ - Cost Benefit uncertainty analysis class + """Cost Benefit uncertainty analysis class This is the base class to perform uncertainty analysis on the outputs of climada.engine.costbenefit.CostBenefit(). diff --git a/climada/engine/unsequa/unc_output.py b/climada/engine/unsequa/unc_output.py index d9c68fe69..80a385395 100644 --- a/climada/engine/unsequa/unc_output.py +++ b/climada/engine/unsequa/unc_output.py @@ -84,20 +84,9 @@ class UncOutput: samples_df : pandas.DataFrame Values of the sampled uncertainty parameters. It has n_samples rows and one column per uncertainty parameter. - sampling_method : str - Name of the sampling method from SAlib. - https://salib.readthedocs.io/en/latest/api.html# - n_samples : int - Effective number of samples (number of rows of samples_df) - param_labels : list - Name of all the uncertainty parameters distr_dict : dict Comon flattened dictionary of all the distr_dict of all input variables. It represents the distribution of all the uncertainty parameters. - problem_sa : dict - The description of the uncertainty variables and their - distribution as used in SALib. - https://salib.readthedocs.io/en/latest/basics.html. """ _metadata = [ @@ -192,6 +181,7 @@ def check_salib(self, sensitivity_method): def sampling_method(self): """ Returns the sampling method used to generate self.samples_df + See: https://salib.readthedocs.io/en/latest/api.html# Returns ------- diff --git a/climada/entity/exposures/base.py b/climada/entity/exposures/base.py index f437d2d46..1021dc7ab 100644 --- a/climada/entity/exposures/base.py +++ b/climada/entity/exposures/base.py @@ -29,6 +29,7 @@ import cartopy.crs as ccrs import contextily as ctx +import geopandas as gpd import matplotlib.pyplot as plt import numpy as np import pandas as pd @@ -1131,10 +1132,8 @@ def write_hdf5(self, file_name): """ LOGGER.info("Writing %s", file_name) store = pd.HDFStore(file_name, mode="w") - pandas_df = pd.DataFrame(self.gdf) - for col in pandas_df.columns: - if str(pandas_df[col].dtype) == "geometry": - pandas_df[col] = np.asarray(self.gdf[col]) + geocols = self.data.columns[self.data.dtypes == "geometry"].to_list() + pandas_df = self.data.to_wkb() # Avoid pandas PerformanceWarning when writing HDF5 data with warnings.catch_warnings(): @@ -1146,6 +1145,7 @@ def write_hdf5(self, file_name): for var in type(self)._metadata: var_meta[var] = getattr(self, var) var_meta["crs"] = self.crs + var_meta["wkb_columns"] = geocols store.get_storer("exposures").attrs.metadata = var_meta store.close() @@ -1184,7 +1184,15 @@ def from_hdf5(cls, file_name): crs = metadata.get("crs", metadata.get("_crs")) if crs is None and metadata.get("meta"): crs = metadata["meta"].get("crs") - exp = cls(store["exposures"], crs=crs) + data = pd.DataFrame(store["exposures"]) + + wkb_columns = ( + metadata.pop("wkb_columns") if "wkb_columns" in metadata else [] + ) + for col in wkb_columns: + data[col] = gpd.GeoSeries.from_wkb(data[col]) + + exp = cls(data, crs=crs) for key, val in metadata.items(): if key in type(exp)._metadata: # pylint: disable=protected-access setattr(exp, key, val) diff --git a/climada/entity/exposures/test/test_base.py b/climada/entity/exposures/test/test_base.py index 66e921cd4..77e1e50ec 100644 --- a/climada/entity/exposures/test/test_base.py +++ b/climada/entity/exposures/test/test_base.py @@ -378,11 +378,14 @@ def test_read_template_pass(self): def test_io_hdf5_pass(self): """write and read hdf5""" - exp_df = Exposures(pd.read_excel(ENT_TEMPLATE_XLS), crs="epsg:32632") - exp_df.check() + exp = Exposures(pd.read_excel(ENT_TEMPLATE_XLS), crs="epsg:32632") + # set metadata - exp_df.ref_year = 2020 - exp_df.value_unit = "XSD" + exp.ref_year = 2020 + exp.value_unit = "XSD" + + # add another geometry column + exp.data["geocol2"] = exp.data.geometry.copy(deep=True) file_name = DATA_DIR.joinpath("test_hdf5_exp.h5") @@ -392,46 +395,51 @@ def test_io_hdf5_pass(self): with warnings.catch_warnings(): warnings.simplefilter("error", category=pd.errors.PerformanceWarning) - exp_df.write_hdf5(file_name) + exp.write_hdf5(file_name=file_name) exp_read = Exposures.from_hdf5(file_name) - self.assertEqual(exp_df.ref_year, exp_read.ref_year) - self.assertEqual(exp_df.value_unit, exp_read.value_unit) - self.assertEqual(exp_df.description, exp_read.description) - np.testing.assert_array_equal(exp_df.latitude, exp_read.latitude) - np.testing.assert_array_equal(exp_df.longitude, exp_read.longitude) - np.testing.assert_array_equal(exp_df.value, exp_read.value) + self.assertEqual(exp.ref_year, exp_read.ref_year) + self.assertEqual(exp.value_unit, exp_read.value_unit) + self.assertEqual(exp.description, exp_read.description) + np.testing.assert_array_equal(exp.latitude, exp_read.latitude) + np.testing.assert_array_equal(exp.longitude, exp_read.longitude) + np.testing.assert_array_equal(exp.value, exp_read.value) np.testing.assert_array_equal( - exp_df.data["deductible"].values, exp_read.data["deductible"].values + exp.data["deductible"].values, exp_read.data["deductible"].values ) np.testing.assert_array_equal( - exp_df.data["cover"].values, exp_read.data["cover"].values + exp.data["cover"].values, exp_read.data["cover"].values ) np.testing.assert_array_equal( - exp_df.data["region_id"].values, exp_read.data["region_id"].values + exp.data["region_id"].values, exp_read.data["region_id"].values ) np.testing.assert_array_equal( - exp_df.data["category_id"].values, exp_read.data["category_id"].values + exp.data["category_id"].values, exp_read.data["category_id"].values ) np.testing.assert_array_equal( - exp_df.data["impf_TC"].values, exp_read.data["impf_TC"].values + exp.data["impf_TC"].values, exp_read.data["impf_TC"].values ) np.testing.assert_array_equal( - exp_df.data["centr_TC"].values, exp_read.data["centr_TC"].values + exp.data["centr_TC"].values, exp_read.data["centr_TC"].values ) np.testing.assert_array_equal( - exp_df.data["impf_FL"].values, exp_read.data["impf_FL"].values + exp.data["impf_FL"].values, exp_read.data["impf_FL"].values ) np.testing.assert_array_equal( - exp_df.data["centr_FL"].values, exp_read.data["centr_FL"].values + exp.data["centr_FL"].values, exp_read.data["centr_FL"].values ) self.assertTrue( - u_coord.equal_crs(exp_df.crs, exp_read.crs), - f"{exp_df.crs} and {exp_read.crs} are different", + u_coord.equal_crs(exp.crs, exp_read.crs), + f"{exp.crs} and {exp_read.crs} are different", + ) + self.assertTrue(u_coord.equal_crs(exp.data.crs, exp_read.data.crs)) + + self.assertTrue(exp_read.data["geocol2"].dtype == "geometry") + np.testing.assert_array_equal( + exp.data["geocol2"].geometry, exp_read.data["geocol2"].values ) - self.assertTrue(u_coord.equal_crs(exp_df.gdf.crs, exp_read.gdf.crs)) class TestAddSea(unittest.TestCase): diff --git a/climada/entity/impact_funcs/test/test_imp_fun_set.py b/climada/entity/impact_funcs/test/test_imp_fun_set.py index 768b271cc..fdedf133c 100644 --- a/climada/entity/impact_funcs/test/test_imp_fun_set.py +++ b/climada/entity/impact_funcs/test/test_imp_fun_set.py @@ -20,6 +20,7 @@ """ import unittest +from copy import deepcopy import numpy as np @@ -297,7 +298,7 @@ def setUp(self): mdd = np.array([0, 0.5]) fun_1 = ImpactFunc("TC", 3, intensity, mdd, paa) - fun_2 = ImpactFunc("TC", 3, intensity, mdd, paa) + fun_2 = ImpactFunc("TC", 3, deepcopy(intensity), deepcopy(mdd), deepcopy(paa)) fun_3 = ImpactFunc("TC", 4, intensity + 1, mdd, paa) self.impact_set1 = ImpactFuncSet([fun_1]) diff --git a/climada/hazard/centroids/centr.py b/climada/hazard/centroids/centr.py index c4044f7dd..e5e5a45bf 100644 --- a/climada/hazard/centroids/centr.py +++ b/climada/hazard/centroids/centr.py @@ -23,7 +23,7 @@ import logging import warnings from pathlib import Path -from typing import Any, Literal, Union +from typing import Any, Literal, Optional, Union import cartopy import cartopy.crs as ccrs @@ -52,21 +52,7 @@ class Centroids: - """Contains vector centroids as a GeoDataFrame - - Attributes - ---------- - lat : np.array - Latitudinal coordinates in the specified CRS (can be any unit). - lon : np.array - Longitudinal coordinates in the specified CRS (can be any unit). - crs : pyproj.CRS - Coordinate reference system. Default: EPSG:4326 (WGS84) - region_id : np.array, optional - Numeric country (or region) codes. Default: None - on_land : np.array, optional - Boolean array indicating on land (True) or off shore (False). Default: None - """ + """Contains vector centroids as a GeoDataFrame""" def __init__( self, @@ -116,13 +102,13 @@ def __init__( self.set_on_land(source=on_land, overwrite=True) @property - def lat(self): - """Return latitudes""" + def lat(self) -> np.array: + """Latitudinal coordinates in the specified CRS (can be any unit).""" return self.gdf.geometry.y.values @property - def lon(self): - """Return longitudes""" + def lon(self) -> np.array: + """Longitudinal coordinates in the specified CRS (can be any unit).""" return self.gdf.geometry.x.values @property @@ -131,8 +117,8 @@ def geometry(self): return self.gdf["geometry"] @property - def on_land(self): - """Get the on_land property""" + def on_land(self) -> Optional[np.array]: + """Boolean array indicating on land (True) or off shore (False). Default: None""" if "on_land" not in self.gdf: return None if self.gdf["on_land"].isna().all(): @@ -140,8 +126,8 @@ def on_land(self): return self.gdf["on_land"].values @property - def region_id(self): - """Get the assigned region_id""" + def region_id(self) -> Optional[np.array]: + """Numeric country (or region) codes. Default: None""" if "region_id" not in self.gdf: return None if self.gdf["region_id"].isna().all(): @@ -149,8 +135,8 @@ def region_id(self): return self.gdf["region_id"].values @property - def crs(self): - """Get the crs""" + def crs(self) -> CRS: + """Coordinate reference system. Default: EPSG:4326 (WGS84)""" return self.gdf.crs @property diff --git a/climada/hazard/plot.py b/climada/hazard/plot.py index e3a9ac78f..2925b1d27 100644 --- a/climada/hazard/plot.py +++ b/climada/hazard/plot.py @@ -23,7 +23,6 @@ import matplotlib.pyplot as plt import numpy as np -from deprecation import deprecated import climada.util.plot as u_plot @@ -41,6 +40,7 @@ def plot_rp_intensity( self, return_periods=(25, 50, 100, 250), axis=None, + mask_distance=0.01, kwargs_local_exceedance_intensity=None, **kwargs, ): @@ -57,6 +57,11 @@ def plot_rp_intensity( axis to use kwargs_local_exceedance_intensity: dict Dictionary of keyword arguments for the method hazard.local_exceedance_intensity. + mask_distance: float, optional + Only regions are plotted that are closer to any of the data points than this distance, + relative to overall plot size. For instance, to only plot values + at the centroids, use mask_distance=0.01. If None, the plot is not masked. + Default is 0.01. kwargs: optional arguments for pcolormesh matplotlib function used in event plots @@ -77,8 +82,8 @@ def plot_rp_intensity( util.plot.plot_from_gdf(gdf, title, labels) instead. """ LOGGER.info( - "Some errors in the previous calculation of local exceedance intensities have been corrected," - " see Hazard.local_exceedance_intensity. To reproduce data with the " + "Some errors in the previous calculation of local exceedance intensities have been " + "corrected, see Hazard.local_exceedance_intensity. To reproduce data with the " "previous calculation, use CLIMADA v5.0.0 or less." ) @@ -90,7 +95,12 @@ def plot_rp_intensity( ) axis = u_plot.plot_from_gdf( - inten_stats, title, column_labels, axis=axis, **kwargs + inten_stats, + title, + column_labels, + axis=axis, + mask_distance=mask_distance, + **kwargs, ) return axis, inten_stats.values[:, 1:].T.astype(float) @@ -101,6 +111,7 @@ def plot_intensity( smooth=True, axis=None, adapt_fontsize=True, + mask_distance=0.01, **kwargs, ): """Plot intensity values for a selected event or centroid. @@ -124,6 +135,11 @@ def plot_intensity( in module `climada.util.plot`) axis: matplotlib.axes._subplots.AxesSubplot, optional axis to use + mask_distance: float, optional + Only regions are plotted that are closer to any of the data points than this distance, + relative to overall plot size. For instance, to only plot values + at the centroids, use mask_distance=0.01. If None, the plot is not masked. + Default is 0.01. kwargs: optional arguments for pcolormesh matplotlib function used in event plots or for plot function used in centroids plots @@ -149,6 +165,7 @@ def plot_intensity( crs_epsg, axis, adapt_fontsize=adapt_fontsize, + mask_distance=mask_distance, **kwargs, ) if centr is not None: @@ -158,7 +175,15 @@ def plot_intensity( raise ValueError("Provide one event id or one centroid id.") - def plot_fraction(self, event=None, centr=None, smooth=True, axis=None, **kwargs): + def plot_fraction( + self, + event=None, + centr=None, + smooth=True, + axis=None, + mask_distance=0.01, + **kwargs, + ): """Plot fraction values for a selected event or centroid. Parameters @@ -180,6 +205,11 @@ def plot_fraction(self, event=None, centr=None, smooth=True, axis=None, **kwargs in module `climada.util.plot`) axis: matplotlib.axes._subplots.AxesSubplot, optional axis to use + mask_distance: float, optional + Relative distance (with respect to maximal map extent in longitude or latitude) to data + points above which plot should not display values. For instance, to only plot values + at the centroids, use mask_distance=0.01. If None, the plot is not masked. + Default is None. kwargs: optional arguments for pcolormesh matplotlib function used in event plots or for plot function used in centroids plots @@ -197,7 +227,13 @@ def plot_fraction(self, event=None, centr=None, smooth=True, axis=None, **kwargs if isinstance(event, str): event = self.get_event_id(event) return self._event_plot( - event, self.fraction, col_label, smooth, axis, **kwargs + event, + self.fraction, + col_label, + smooth, + axis, + mask_distance=mask_distance, + **kwargs, ) if centr is not None: if isinstance(centr, tuple): @@ -216,6 +252,7 @@ def _event_plot( axis=None, figsize=(9, 13), adapt_fontsize=True, + mask_distance=0.01, **kwargs, ): """Plot an event of the input matrix. @@ -237,6 +274,11 @@ def _event_plot( axis to use figsize: tuple, optional figure size for plt.subplots + mask_distance: float, optional + Only regions are plotted that are closer to any of the data points than this distance, + relative to overall plot size. For instance, to only plot values + at the centroids, use mask_distance=0.01. If None, the plot is not masked. + Default is None. kwargs: optional arguments for pcolormesh matplotlib function @@ -284,6 +326,7 @@ def _event_plot( figsize=figsize, proj=crs_espg, adapt_fontsize=adapt_fontsize, + mask_distance=mask_distance, **kwargs, ) diff --git a/climada/hazard/storm_europe.py b/climada/hazard/storm_europe.py index e42509898..25f8999d4 100644 --- a/climada/hazard/storm_europe.py +++ b/climada/hazard/storm_europe.py @@ -60,11 +60,16 @@ class StormEurope(Hazard): """A hazard set containing european winter storm events. Historic storm - events can be downloaded at http://wisc.climate.copernicus.eu/ and read - with `from_footprints`. Weather forecasts can be automatically downloaded from - https://opendata.dwd.de/ and read with from_icon_grib(). Weather forecast - from the COSMO-Consortium http://www.cosmo-model.org/ can be read with - from_cosmoe_file(). + events can be downloaded at https://cds.climate.copernicus.eu/ and read + with :meth:`from_footprints`. Weather forecasts can be automatically downloaded from + https://opendata.dwd.de/ and read with :meth:`from_icon_grib`. Weather forecast + from the COSMO-Consortium https://www.cosmo-model.org/ can be read with + :meth:`from_cosmoe_file`. + + Direct links to CDS data: + + * Winter windstorm indicators (1979 to 2021): https://doi.org/10.24381/cds.9b4ea013 + * Synthetic windstorm events (1986 to 2011): https://doi.org/10.24381/cds.ce973f02 Attributes ---------- @@ -696,7 +701,7 @@ def calc_ssi( ssi = sum_i(area_cell_i * intensity_cell_i^3) 'wisc_gust', according to the WISC Tier 1 definition found at - https://wisc.climate.copernicus.eu/wisc/#/help/products#tier1_section + https://confluence.ecmwf.int/display/CKB/Synthetic+Windstorm+Events+for+Europe+from+1986+to+2011%3A+Product+User+Guide ssi = sum(area_on_land) * mean(intensity)^3 In both definitions, only raster cells that are above the threshold are diff --git a/climada/hazard/tc_tracks.py b/climada/hazard/tc_tracks.py index 2a7441e70..43ea51b58 100644 --- a/climada/hazard/tc_tracks.py +++ b/climada/hazard/tc_tracks.py @@ -330,7 +330,7 @@ def subset_year( """Subset TCTracks between start and end dates, both included. Parameters: - ---------- + ----------- start_date: tuple First date to include in the selection (YYYY, MM, DD). Each element can either be an integer or `False`. If an element is `False`, it is ignored during the filter. diff --git a/climada/hazard/test/test_tc_tracks.py b/climada/hazard/test/test_tc_tracks.py index f1943c7f3..7388a8284 100644 --- a/climada/hazard/test/test_tc_tracks.py +++ b/climada/hazard/test/test_tc_tracks.py @@ -27,7 +27,8 @@ import numpy as np import pandas as pd import xarray as xr -from shapely.geometry import LineString, MultiLineString, Point +from cartopy.io import shapereader +from shapely.geometry import LineString, MultiLineString import climada.hazard.tc_tracks as tc import climada.util.coordinates as u_coord @@ -1278,8 +1279,16 @@ def test_tracks_in_exp_pass(self): storms = {"in": "2000233N12316", "out": "2000160N21267"} tc_track = tc.TCTracks.from_ibtracs_netcdf(storm_id=list(storms.values())) - # Define exposure from geopandas - world = gpd.read_file(gpd.datasets.get_path("naturalearth_lowres")) + # Define exposure from shapefile.natural_earth + shape_file = shapereader.Reader( + shapereader.natural_earth( + resolution="110m", category="cultural", name="admin_0_countries" + ) + ) + world = gpd.GeoDataFrame( + data=[cntry.attributes for cntry in shape_file.records()], + geometry=[cntry.geometry for cntry in shape_file.records()], + ).rename(columns=lambda col: col.lower()) exp_world = Exposures(world) exp = Exposures(exp_world.gdf[exp_world.gdf["name"] == "Cuba"]) diff --git a/climada/hazard/trop_cyclone/trop_cyclone.py b/climada/hazard/trop_cyclone/trop_cyclone.py index 73cb8764f..853046020 100644 --- a/climada/hazard/trop_cyclone/trop_cyclone.py +++ b/climada/hazard/trop_cyclone/trop_cyclone.py @@ -391,7 +391,7 @@ def apply_climate_scenario_knu( percentile: str = "50", scenario: str = "4.5", target_year: int = 2050, - **kwargs, + yearly_steps: int = 5, ): """ From current TC hazard instance, return new hazard set with future events @@ -437,6 +437,9 @@ def apply_climate_scenario_knu( target_year : int future year to be simulated, between 2000 and 2100. Default: 2050. + yearly_steps : int + yearly resolution at which projections are provided. Default is 5 years. + Returns ------- haz_cc : climada.hazard.TropCyclone @@ -465,11 +468,11 @@ def apply_climate_scenario_knu( for basin in np.unique(tc_cc.basin): scale_year_rcp_05, scale_year_rcp_45 = [ get_knutson_scaling_factor( - percentile=percentile, variable=variable, + percentile=percentile, basin=basin, baseline=(np.min(years), np.max(years)), - **kwargs, + yearly_steps=yearly_steps, ).loc[target_year, scenario] for variable in ["cat05", "cat45"] ] diff --git a/climada/test/test_litpop_integr.py b/climada/test/test_litpop_integr.py index 2c2ddba88..ae1b5588e 100644 --- a/climada/test/test_litpop_integr.py +++ b/climada/test/test_litpop_integr.py @@ -53,7 +53,9 @@ def test_netherlands150_pass(self): self.assertEqual(ent.gdf.shape[0], 2829) def test_BLM150_pass(self): - """Test from_countries for BLM at 150 arcsec, 2 data points""" + """Test from_countries for BLM at 150 arcsec, 2 data points + The world bank doesn't provide data for Saint Barthélemy, fall back to natearth + """ ent = lp.LitPop.from_countries("BLM", res_arcsec=150, reference_year=2016) self.assertEqual(ent.gdf.shape[0], 2) diff --git a/climada/test/test_plot.py b/climada/test/test_plot.py index 04131741f..89adaf0e5 100644 --- a/climada/test/test_plot.py +++ b/climada/test/test_plot.py @@ -112,8 +112,8 @@ def test_hazard_rp_intensity(self): """ "Plot exceedance intensity maps for different return periods""" hazard = Hazard.from_hdf5(HAZ_TEST_TC) (axis1, axis2), _ = hazard.plot_rp_intensity([25, 50]) - self.assertEqual("Return period: 25 years", axis1.get_title()) - self.assertEqual("Return period: 50 years", axis2.get_title()) + self.assertEqual("Return Period: 25 years", axis1.get_title()) + self.assertEqual("Return Period: 50 years", axis2.get_title()) def test_exposures_value_pass(self): """Plot exposures values.""" diff --git a/climada/util/earth_engine.py b/climada/util/earth_engine.py index 2a35755e5..92fa96cad 100644 --- a/climada/util/earth_engine.py +++ b/climada/util/earth_engine.py @@ -26,148 +26,159 @@ # That's why `earthengine-api` is not in the CLIMADA requirements. # See tutorial: climada_util_earth_engine.ipynb # pylint: disable=import-error -import ee - LOGGER = logging.getLogger(__name__) -ee.Initialize() - - -def obtain_image_landsat_composite(landsat_collection, time_range, area): - """Selection of Landsat cloud-free composites in the Earth Engine library - See also: https://developers.google.com/earth-engine/landsat - - Parameters - ---------- - collection : - name of the collection - time_range : ['YYYY-MT-DY','YYYY-MT-DY'] - must be inside the available data - area : ee.geometry.Geometry - area of interest - - Returns - ------- - image_composite : ee.image.Image - """ - collection = ee.ImageCollection(landsat_collection) - - # Filter by time range and location - collection_time = collection.filterDate(time_range[0], time_range[1]) - image_area = collection_time.filterBounds(area) - image_composite = ee.Algorithms.Landsat.simpleComposite(image_area, 75, 3) - return image_composite - - -def obtain_image_median(collection, time_range, area): - """Selection of median from a collection of images in the Earth Engine library - See also: https://developers.google.com/earth-engine/reducers_image_collection - - Parameters - ---------- - collection : - name of the collection - time_range : ['YYYY-MT-DY','YYYY-MT-DY'] - must be inside the available data - area : ee.geometry.Geometry - area of interest - - Returns - ------- - image_median : ee.image.Image - """ - collection = ee.ImageCollection(collection) - - # Filter by time range and location - collection_time = collection.filterDate(time_range[0], time_range[1]) - image_area = collection_time.filterBounds(area) - image_median = image_area.median() - return image_median - - -def obtain_image_sentinel(sentinel_collection, time_range, area): - """Selection of median, cloud-free image from a collection of images in the Sentinel 2 dataset - See also: https://developers.google.com/earth-engine/datasets/catalog/COPERNICUS_S2 - - Parameters - ---------- - collection : - name of the collection - time_range : ['YYYY-MT-DY','YYYY-MT-DY'] - must be inside the available data - area : ee.geometry.Geometry - area of interest - - Returns - ------- - sentinel_median : ee.image.Image - """ - - # First, method to remove cloud from the image - def maskclouds(image): - band_qa = image.select("QA60") - cloud_mask = ee.Number(2).pow(10).int() - cirrus_mask = ee.Number(2).pow(11).int() - mask = band_qa.bitwiseAnd(cloud_mask).eq(0) and ( - band_qa.bitwiseAnd(cirrus_mask).eq(0) - ) - return image.updateMask(mask).divide(10000) - - sentinel_filtered = ( - ee.ImageCollection(sentinel_collection) - .filterBounds(area) - .filterDate(time_range[0], time_range[1]) - .filter(ee.Filter.lt("CLOUDY_PIXEL_PERCENTAGE", 20)) - .map(maskclouds) + +try: + import ee + + LOGGER.info("Google Earth Engine API successfully imported.") + EE_AVAILABLE = True +except ImportError: + LOGGER.error( + "Google Earth Engine API not found. Please install it using 'pip install earthengine-api'." + ) + EE_AVAILABLE = False + +if not EE_AVAILABLE: + LOGGER.error( + "Google Earth Engine API not found. Skipping the init of `earth_engine.py`." ) +else: + ee.Initialize() + + def obtain_image_landsat_composite(landsat_collection, time_range, area): + """Selection of Landsat cloud-free composites in the Earth Engine library + See also: https://developers.google.com/earth-engine/landsat + + Parameters + ---------- + collection : + name of the collection + time_range : ['YYYY-MT-DY','YYYY-MT-DY'] + must be inside the available data + area : ee.geometry.Geometry + area of interest + + Returns + ------- + image_composite : ee.image.Image + """ + collection = ee.ImageCollection(landsat_collection) + + # Filter by time range and location + collection_time = collection.filterDate(time_range[0], time_range[1]) + image_area = collection_time.filterBounds(area) + image_composite = ee.Algorithms.Landsat.simpleComposite(image_area, 75, 3) + return image_composite + + def obtain_image_median(collection, time_range, area): + """Selection of median from a collection of images in the Earth Engine library + See also: https://developers.google.com/earth-engine/reducers_image_collection + + Parameters + ---------- + collection : + name of the collection + time_range : ['YYYY-MT-DY','YYYY-MT-DY'] + must be inside the available data + area : ee.geometry.Geometry + area of interest + + Returns + ------- + image_median : ee.image.Image + """ + collection = ee.ImageCollection(collection) + + # Filter by time range and location + collection_time = collection.filterDate(time_range[0], time_range[1]) + image_area = collection_time.filterBounds(area) + image_median = image_area.median() + return image_median + + def obtain_image_sentinel(sentinel_collection, time_range, area): + """Selection of median, cloud-free image from a collection of images in the Sentinel 2 + dataset. + See also: https://developers.google.com/earth-engine/datasets/catalog/COPERNICUS_S2 + + Parameters + ---------- + collection : + name of the collection + time_range : ['YYYY-MT-DY','YYYY-MT-DY'] + must be inside the available data + area : ee.geometry.Geometry + area of interest + + Returns + ------- + sentinel_median : ee.image.Image + """ + + # First, method to remove cloud from the image + def maskclouds(image): + band_qa = image.select("QA60") + cloud_mask = ee.Number(2).pow(10).int() + cirrus_mask = ee.Number(2).pow(11).int() + mask = band_qa.bitwiseAnd(cloud_mask).eq(0) and ( + band_qa.bitwiseAnd(cirrus_mask).eq(0) + ) + return image.updateMask(mask).divide(10000) + + sentinel_filtered = ( + ee.ImageCollection(sentinel_collection) + .filterBounds(area) + .filterDate(time_range[0], time_range[1]) + .filter(ee.Filter.lt("CLOUDY_PIXEL_PERCENTAGE", 20)) + .map(maskclouds) + ) + + sentinel_median = sentinel_filtered.median() + return sentinel_median + + def get_region(geom): + """Get the region of a given geometry, needed for exporting tasks. + + Parameters + ---------- + geom : ee.Geometry, ee.Feature, ee.Image + region of interest + + Returns + ------- + region : list + """ + if isinstance(geom, ee.Geometry): + return geom.getInfo()["coordinates"] + if isinstance(geom, (ee.Feature, ee.Image)): + return geom.geometry().getInfo()["coordinates"] + raise ValueError( + "parameter must be one of `ee.Geometry`, `ee.Feature`, `ee.Image`" + ) + + def get_url(name, image, scale, region): + """It will open and download automatically a zip folder containing Geotiff data of 'image'. + If additional parameters are needed, see also: + https://github.com/google/earthengine-api/blob/master/python/ee/image.py + + Parameters + ---------- + name : str + name of the created folder + image : ee.image.Image + image to export + scale : int + resolution of export in meters (e.g: 30 for Landsat) + region : list + region of interest + + Returns + ------- + path : str + """ + path = image.getDownloadURL( + {"name": (name), "scale": scale, "region": (region)} + ) - sentinel_median = sentinel_filtered.median() - return sentinel_median - - -def get_region(geom): - """Get the region of a given geometry, needed for exporting tasks. - - Parameters - ---------- - geom : ee.Geometry, ee.Feature, ee.Image - region of interest - - Returns - ------- - region : list - """ - if isinstance(geom, ee.Geometry): - region = geom.getInfo()["coordinates"] - elif isinstance(geom, ee.Feature, ee.Image): - region = geom.geometry().getInfo()["coordinates"] - elif isinstance(geom, list): - condition = all([isinstance(item) == list for item in geom]) - if condition: - region = geom - return region - - -def get_url(name, image, scale, region): - """It will open and download automatically a zip folder containing Geotiff data of 'image'. - If additional parameters are needed, see also: - https://github.com/google/earthengine-api/blob/master/python/ee/image.py - - Parameters - ---------- - name : str - name of the created folder - image : ee.image.Image - image to export - scale : int - resolution of export in meters (e.g: 30 for Landsat) - region : list - region of interest - - Returns - ------- - path : str - """ - path = image.getDownloadURL({"name": (name), "scale": scale, "region": (region)}) - - webbrowser.open_new_tab(path) - return path + webbrowser.open_new_tab(path) + return path diff --git a/climada/util/finance.py b/climada/util/finance.py index 94059c6f6..7ae54fcc4 100644 --- a/climada/util/finance.py +++ b/climada/util/finance.py @@ -21,9 +21,9 @@ __all__ = ["net_present_value", "income_group", "gdp"] +import json import logging import shutil -import warnings import zipfile from pathlib import Path @@ -31,7 +31,6 @@ import pandas as pd import requests from cartopy.io import shapereader -from pandas_datareader import wb from climada.util.constants import SYSTEM_DIR from climada.util.files_handler import download_file @@ -181,6 +180,77 @@ def gdp(cntry_iso, ref_year, shp_file=None, per_capita=False): return close_year, close_val +def download_world_bank_indicator( + country_code: str, indicator: str, parse_dates: bool = False +): + """Download indicator data from the World Bank API for all years or dates on record + + Parameters + ---------- + country_code : str + The country code in ISO alpha 3 + indicator : str + The ID of the indicator in the World Bank API + parse_dates : bool, optional + Whether the dates of the indicator data should be parsed as datetime objects. + If ``False`` (default), this will first try to parse them as ``int`` (this only + works for yearly data), and then parse as datetime objects if that fails. + + Returns + ------- + pd.Series + A series with the values of the indicator for all dates (years) on record + """ + # Download data from API + raw_data = [] + pages = np.inf + page = 1 + while page <= pages: + response = requests.get( + f"https://api.worldbank.org/v2/countries/{country_code}/indicators/" + f"{indicator}?format=json&page={page}", + timeout=30, + ) + json_data = json.loads(response.text) + + # Check if we received an error message + try: + if json_data[0]["message"][0]["id"] == "120": + raise ValueError( + "Error requesting data from the World Bank API. Did you use the " + "correct country code and indicator ID?" + ) + # If no, we should be fine + except KeyError: + pass + + # Check if there is no data available + pages = json_data[0]["pages"] + if pages == 0: + raise ValueError( + f"No data available for country {country_code}, indicator {indicator}" + ) + + # Update the data + page = page + 1 + raw_data.extend(json_data[1]) + + # Create dataframe + data = pd.DataFrame.from_records(raw_data) + + # Maybe parse dates + if parse_dates: + data["date"] = pd.DatetimeIndex(data["date"]) + else: + try: + data["date"] = data["date"].astype("int") + except TypeError: + data["date"] = pd.DatetimeIndex(data["date"]) + + # Only return indicator data (with a proper name) + return data.set_index("date")["value"].rename(data["indicator"].iloc[0]["value"]) + + def world_bank(cntry_iso, ref_year, info_ind): """Get country's GDP from World Bank's data at a given year, or closest year value. If no data, get the natural earth's approximation. @@ -204,18 +274,14 @@ def world_bank(cntry_iso, ref_year, info_ind): IOError, KeyError, IndexError """ if info_ind != "INC_GRP": - with warnings.catch_warnings(): - warnings.simplefilter("ignore") - cntry_gdp = wb.download( - indicator=info_ind, country=cntry_iso, start=1960, end=2030 - ) - years = np.array( - [int(year) for year in cntry_gdp.index.get_level_values("year")] + cntry_gdp = download_world_bank_indicator( + indicator=info_ind, country_code=cntry_iso, parse_dates=False ) + years = cntry_gdp.index sort_years = np.abs(years - ref_year).argsort() close_val = cntry_gdp.iloc[sort_years].dropna() - close_year = int(close_val.iloc[0].name[1]) - close_val = float(close_val.iloc[0].values) + close_year = close_val.index[0] + close_val = float(close_val.iloc[0]) else: # income group level fn_ig = SYSTEM_DIR.joinpath("OGHIST.xls") dfr_wb = pd.DataFrame() diff --git a/climada/util/plot.py b/climada/util/plot.py index 92c97ad36..b201b3fdd 100644 --- a/climada/util/plot.py +++ b/climada/util/plot.py @@ -37,6 +37,7 @@ import cartopy.crs as ccrs import geopandas as gpd import matplotlib as mpl +import matplotlib.patches as mpatches import matplotlib.pyplot as plt import numpy as np import requests @@ -46,6 +47,7 @@ from mpl_toolkits.axes_grid1 import make_axes_locatable from rasterio.crs import CRS from scipy.interpolate import griddata +from scipy.spatial import cKDTree from shapely.geometry import box import climada.util.coordinates as u_coord @@ -336,6 +338,7 @@ def geo_im_from_array( axes=None, figsize=(9, 13), adapt_fontsize=True, + mask_distance=0.01, **kwargs, ): """Image(s) plot defined in array(s) over input coordinates. @@ -367,6 +370,11 @@ def geo_im_from_array( adapt_fontsize : bool, optional If set to true, the size of the fonts will be adapted to the size of the figure. Otherwise the default matplotlib font size is used. Default is True. + mask_distance: float, optional + Only regions are plotted that are closer to any of the data points than this distance, + relative to overall plot size. For instance, to only plot values + at the centroids, use mask_distance=0.01. If None, the plot is not masked. + Default is 0.01. **kwargs arbitrary keyword arguments for pcolormesh matplotlib function @@ -374,6 +382,11 @@ def geo_im_from_array( ------- cartopy.mpl.geoaxes.GeoAxesSubplot + Notes + ----- + Data points with NaN or inf are plotted in gray. White regions correspond to + regions outside the convex hull of the given coordinates. + Raises ------ ValueError @@ -420,8 +433,7 @@ def geo_im_from_array( # prepare colormap cmap = plt.get_cmap(kwargs.pop("cmap", CMAP_RASTER)) - cmap.set_bad("gainsboro") # For NaNs and infs - cmap.set_under("white", alpha=0) # For values below vmin + cmap.set_under("white") # For values below vmin # Generate each subplot for array_im, axis, tit, name in zip( @@ -443,6 +455,17 @@ def geo_im_from_array( (grid_x, grid_y), fill_value=min_value, ) + # Compute distance of each grid point to the nearest known point + if mask_distance is not None: + tree = cKDTree(np.array((coord[:, 1], coord[:, 0])).T) + distances, _ = tree.query( + np.c_[grid_x.ravel(), grid_y.ravel()], + p=2, # for plotting squares and not sphere around centroids use p=np.inf + ) + threshold = ( + max(extent[1] - extent[0], extent[3] - extent[2]) * mask_distance + ) + grid_im[(distances.reshape(grid_im.shape) > threshold)] = min_value else: grid_x = coord[:, 1].reshape((width, height)).transpose() grid_y = coord[:, 0].reshape((width, height)).transpose() @@ -470,6 +493,17 @@ def geo_im_from_array( cmap=cmap, **kwargs, ) + # handle NaNs in griddata + color_nan = "gainsboro" + if np.isnan(grid_im).any(): + no_data_patch = mpatches.Patch( + facecolor=color_nan, edgecolor="black", label="NaN" + ) + axis.legend( + handles=[no_data_patch] + axis.get_legend_handles_labels()[0], + loc="lower right", + ) + axis.set_facecolor(color_nan) cbar = plt.colorbar(img, cax=cbax, orientation="vertical") cbar.set_label(name) axis.set_title("\n".join(wrap(tit))) @@ -1070,6 +1104,7 @@ def plot_from_gdf( axis=None, figsize=(9, 13), adapt_fontsize=True, + mask_distance=0.01, **kwargs, ): """Plot several subplots from different columns of a GeoDataFrame, e.g., for @@ -1092,6 +1127,11 @@ def plot_from_gdf( adapt_fontsize: bool, optional If set to true, the size of the fonts will be adapted to the size of the figure. Otherwise the default matplotlib font size is used. Default is True. + mask_distance: float, optional + Relative distance (with respect to maximal map extent in longitude or latitude) to data + points above which plot should not display values. For instance, to only plot values + at the centroids, use mask_distance=0.01. If None, the plot is not masked. + Default is 0.01. kwargs: optional Arguments for pcolormesh matplotlib function used in event plots. @@ -1152,6 +1192,7 @@ def plot_from_gdf( axes=axis, figsize=figsize, adapt_fontsize=adapt_fontsize, + mask_distance=mask_distance, **kwargs, ) diff --git a/climada/util/test/test_finance.py b/climada/util/test/test_finance.py index 70dec420e..0676c7a09 100644 --- a/climada/util/test/test_finance.py +++ b/climada/util/test/test_finance.py @@ -26,6 +26,7 @@ from climada.util.finance import ( _gdp_twn, + download_world_bank_indicator, gdp, income_group, nat_earth_adm0, @@ -137,6 +138,34 @@ def test_wb_esp_1950_pass(self): self.assertEqual(wb_year, ref_year) self.assertAlmostEqual(wb_val, ref_val) + def test_download_wb_data(self): + """Test downloading data via the API""" + # Unfortunate reference test + data = download_world_bank_indicator("ESP", "NY.GDP.MKTP.CD") + self.assertAlmostEqual(data[1960], 12424514013.7604) + self.assertEqual(data.name, "GDP (current US$)") + + # Check parsing dates + data = download_world_bank_indicator("ESP", "NY.GDP.MKTP.CD", parse_dates=True) + self.assertEqual(data.index[-1], np.datetime64("1960-01-01")) + + # Check errors raised + with self.assertRaisesRegex( + ValueError, + "Did you use the correct country code", + ): + download_world_bank_indicator("Spain", "NY.GDP.MKTP.CD") + with self.assertRaisesRegex( + ValueError, + "Did you use the correct country code", + ): + download_world_bank_indicator("ESP", "BogusIndicator") + with self.assertRaisesRegex( + ValueError, + "No data available for country AIA, indicator NY.GDP.MKTP.CD", + ): + download_world_bank_indicator("AIA", "NY.GDP.MKTP.CD") + class TestWealth2GDP(unittest.TestCase): """Test Wealth to GDP factor extraction""" diff --git a/doc/_static/css/custom.css b/doc/_static/css/custom.css new file mode 100644 index 000000000..18c791182 --- /dev/null +++ b/doc/_static/css/custom.css @@ -0,0 +1,39 @@ +:root { + + .navbar-brand { + height: 7rem; + max-height: 7rem; + } + +} + +.bd-main .bd-content .bd-article-container { + max-width: 100%; /* default is 60em */ +} + +.bd-page-width { + max-width: 100rem; +} + + +html { + --pst-font-size-base: 16px; + --pst-header-height: 7rem; +} + +.hero { + display: flex; + align-items: center; + justify-content: center; + text-align: center; /* Center-align text */ + background: linear-gradient(to right, #f39c12, #1abc9c, #bdc3c7); /* Orange, teal, gray gradient */ + color: white; /* Ensure text stands out */ + padding: 10px; + border-radius: 10px; /* Soft rounded corners */ + margin: 10px auto; /* Center the hero section horizontally */ + max-width: 980px; /* Restrict width to ensure readability */ + font-size: 1.1em; /* Slightly smaller text size */ + line-height: 1.8; /* Better line spacing for readability */ + box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1); /* Subtle shadow for depth */ + overflow-wrap: break-word; /* Ensure text doesn't overflow borders */ +} diff --git a/doc/climada/climada.engine.rst b/doc/api/climada/climada.engine.rst similarity index 100% rename from doc/climada/climada.engine.rst rename to doc/api/climada/climada.engine.rst diff --git a/doc/climada/climada.engine.unsequa.rst b/doc/api/climada/climada.engine.unsequa.rst similarity index 100% rename from doc/climada/climada.engine.unsequa.rst rename to doc/api/climada/climada.engine.unsequa.rst diff --git a/doc/climada/climada.entity.disc_rates.rst b/doc/api/climada/climada.entity.disc_rates.rst similarity index 100% rename from doc/climada/climada.entity.disc_rates.rst rename to doc/api/climada/climada.entity.disc_rates.rst diff --git a/doc/climada/climada.entity.exposures.litpop.rst b/doc/api/climada/climada.entity.exposures.litpop.rst similarity index 100% rename from doc/climada/climada.entity.exposures.litpop.rst rename to doc/api/climada/climada.entity.exposures.litpop.rst diff --git a/doc/climada/climada.entity.exposures.rst b/doc/api/climada/climada.entity.exposures.rst similarity index 100% rename from doc/climada/climada.entity.exposures.rst rename to doc/api/climada/climada.entity.exposures.rst diff --git a/doc/climada/climada.entity.impact_funcs.rst b/doc/api/climada/climada.entity.impact_funcs.rst similarity index 100% rename from doc/climada/climada.entity.impact_funcs.rst rename to doc/api/climada/climada.entity.impact_funcs.rst diff --git a/doc/climada/climada.entity.measures.rst b/doc/api/climada/climada.entity.measures.rst similarity index 100% rename from doc/climada/climada.entity.measures.rst rename to doc/api/climada/climada.entity.measures.rst diff --git a/doc/climada/climada.entity.rst b/doc/api/climada/climada.entity.rst similarity index 100% rename from doc/climada/climada.entity.rst rename to doc/api/climada/climada.entity.rst diff --git a/doc/climada/climada.hazard.centroids.rst b/doc/api/climada/climada.hazard.centroids.rst similarity index 100% rename from doc/climada/climada.hazard.centroids.rst rename to doc/api/climada/climada.hazard.centroids.rst diff --git a/doc/climada/climada.hazard.rst b/doc/api/climada/climada.hazard.rst similarity index 100% rename from doc/climada/climada.hazard.rst rename to doc/api/climada/climada.hazard.rst diff --git a/doc/climada/climada.hazard.trop_cyclone.rst b/doc/api/climada/climada.hazard.trop_cyclone.rst similarity index 100% rename from doc/climada/climada.hazard.trop_cyclone.rst rename to doc/api/climada/climada.hazard.trop_cyclone.rst diff --git a/doc/climada/climada.rst b/doc/api/climada/climada.rst similarity index 100% rename from doc/climada/climada.rst rename to doc/api/climada/climada.rst diff --git a/doc/climada/climada.util.calibrate.rst b/doc/api/climada/climada.util.calibrate.rst similarity index 100% rename from doc/climada/climada.util.calibrate.rst rename to doc/api/climada/climada.util.calibrate.rst diff --git a/doc/climada/climada.util.rst b/doc/api/climada/climada.util.rst similarity index 100% rename from doc/climada/climada.util.rst rename to doc/api/climada/climada.util.rst diff --git a/doc/api/index.rst b/doc/api/index.rst new file mode 100644 index 000000000..eabfe4a5e --- /dev/null +++ b/doc/api/index.rst @@ -0,0 +1,12 @@ +============== +API Reference +============== + +The API reference contains the whole specification of the code, that is, every modules, +classes (and their attributes), and functions that are available (and documented). + +.. toctree:: + :caption: API Reference + :hidden: + + Modules diff --git a/doc/conf.py b/doc/conf.py index 9656a27a2..82e0abfa9 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -40,6 +40,7 @@ "sphinx.ext.viewcode", "sphinx.ext.napoleon", "sphinx.ext.ifconfig", + "sphinx_design", "sphinx_mdinclude", "myst_nb", "sphinx_markdown_tables", @@ -124,12 +125,30 @@ # The theme to use for HTML and HTML Help pages. Major themes that come with # Sphinx are currently 'default' and 'sphinxdoc'. -html_theme = "sphinx_book_theme" +html_theme = "pydata_sphinx_theme" # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. -# html_theme_options = {} +html_theme_options = { + "header_links_before_dropdown": 6, + "navbar_align": "left", + # "icon_links": [ + # { + # # Label for this link + # "name": "GitHub", + # # URL where the link will redirect + # "url": "https://github.com/CLIMADA-project", # required + # # Icon class (if "type": "fontawesome"), or path to local image (if "type": "local") + # "icon": "fa-brands fa-square-github", + # # The type of image to be used (see below for details) + # "type": "fontawesome", + # } + # ], +} + +# Avoid section navigation sidebar in changelog page +html_sidebars = {"misc/CHANGELOG": []} # Add any paths that contain custom themes here, relative to this directory. # html_theme_path = [] @@ -155,6 +174,9 @@ # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ["_static"] +html_css_files = [ + "css/custom.css", +] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. # html_last_updated_fmt = '%b %d, %Y' diff --git a/doc/guide/Guide_Git_Development.ipynb b/doc/development/Guide_CLIMADA_Development.ipynb similarity index 60% rename from doc/guide/Guide_Git_Development.ipynb rename to doc/development/Guide_CLIMADA_Development.ipynb index 08eb92c0c..18ff93640 100644 --- a/doc/guide/Guide_Git_Development.ipynb +++ b/doc/development/Guide_CLIMADA_Development.ipynb @@ -2,288 +2,145 @@ "cells": [ { "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "fragment" - } - }, - "source": [ - "# Development and Git and CLIMADA" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## Git and GitHub\n", - "\n", - "- Git's not that scary\n", - " - 95% of your work on Git will be done with the same handful of commands (the other 5% will always be done with careful Googling)\n", - " - Almost everything in Git can be undone by design (but use `rebase`, `--force` and `--hard` with care!)\n", - " - Your favourite IDE (Spyder, PyCharm, ...) will have a GUI for working with Git, or you can download a standalone one.\n", - "- The [Git Book](https://git-scm.com/book/en/v2) is a great introduction to how Git works and to using it on the command line.\n", - "- Consider using a GUI program such as “git desktop” or “Gitkraken” to have a visual git interface, in particular at the beginning. Your python IDE is also likely to have a visual git interface. \n", - "- Feel free to ask for help" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, + "metadata": {}, "source": [ - "![](img/git_gui.png)" + "# CLIMADA Development\n", + "\n", + "This is a guide about how to contribute to the development of CLIMADA. We first explain some general guidelines about when and how one can contribute to CLIMADA, and then describe the steps in detail. We assume that you are familiar with Git, Github and their commands. If you are not familiar with these, you can refer to our instructions for [Development with Git](Guide_Git_Development.ipynb). " ] }, { "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, + "metadata": {}, "source": [ - "### What we assume you know\n", + "## Is CLIMADA the right place for your contribution? \n", "\n", - "We're assuming you're all familiar with the basics of Git.\n", + "When developing for CLIMADA, it is important to distinguish between core content and particular applications. Core content is meant to be included into the [climada_python](https://github.com/CLIMADA-project/climada_python) repository and will be subject to a code review. Any new addition should first be discussed with one of the [repository admins](https://github.com/CLIMADA-project/climada_python/wiki/Developer-Board). The purpose of this discussion is to see\n", "\n", - "- What (and why) is version control\n", - "- How to clone a repository\n", - "- How to make a commit and push it to GitHub\n", - "- What a branch is, and how to make one\n", - "- How to merge two branches\n", - "- The basics of the GitHub website\n", + "- How does the planned module fit into CLIMADA?\n", + "- What is an optimal architecture for the new module?\n", + "- What parts might already exist in other parts of the code?\n", "\n", - "If you're not feeling great about this, we recommend\n", - "- sending me a message so we can arrange an introduction with CLIMADA\n", - "- exploring the [Git Book](https://git-scm.com/book/en/v2)" + "Applications made with CLIMADA, such as an [ECA study](https://eca-network.org/) can be stored in the [paper repository](https://github.com/CLIMADA-project/climada_papers) once they have been published. For other types of work, consider making a separate repository that imports CLIMADA as an external package." ] }, { "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, + "metadata": {}, "source": [ - "### Terms we'll be using today\n", + "## Planning a new feature\n", "\n", - "These are terms that will come up a lot, so let's make sure we know them\n", + "Here we're talking about large features such as new modules, new data sources, or big methodological changes. Any extension to CLIMADA that might affect other developers' work, modify the CLIMADA core, or need a big code review.\n", "\n", - "- local versus remote\n", - " - Our **remote** repository is hosted on GitHub. This is the central location where all updates to CLIMADA that we want to share end up. If you're updating CLIMADA for the community, your code will end up here too.\n", - " - Your **local** repository is the copy you have on the machine you're working on, and where you do your work.\n", - " - Git calls the (first, default) remote the `origin`\n", - " - (It's possible to set more than one remote repository, e.g. you might set one up on a network-restricted computing cluster)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "source": [ - "- push, pull and pull request\n", - " - You **push** your work when you send it from your local machine to the remote repository\n", - " - You **pull** from the remote repository to update the code on your local machine\n", - " - A **pull request** is a standardised review process on GitHub. Usually it ends with one branch merging into another" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "source": [ - "- Conflict resolution\n", - " - Sometimes two people have made changes to the same bit of code. Usually this comes up when you're trying to merge branches. The changes have to be manually compared and the code edited to make sure the 'correct' version of the code is kept. " - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## Gitflow " - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "Gitflow is a particular way of using git to organise projects that have\n", - "- multiple developers\n", - "- working on different features\n", - "- with a release cycle\n", - "\n", - "It means that\n", - "- there's always a stable version of the code available to the public\n", - "- the chances of two developers' code conflicting are reduced\n", - "- the process of adding and reviewing features and fixes is more standardised for everyone\n", - "\n", - "Gitflow is a _convention_, so you don't need any additional software.\n", - "- ... but if you want you can get some: a popular extension to the git command line tool allows you to issue more intuitive commands for a Gitflow workflow.\n", - "- Mac/Linux users can install git-flow from their package manager, and it's included with Git for Windows " - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "### Gitflow works on the `develop` branch instead of `main`" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "![](img/flow_1.png)\n", + "Smaller feature branches don't need such formalities. Use your judgment, and if in doubt, let people know.\n", "\n", - "- The critical difference between Gitflow and 'standard' git is that almost all of your work takes place on the `develop` branch, instead of the `main` (formerly `master`) branch.\n", - "- The `main` branch is reserved for planned, stable product releases, and it's what the general public download when they install CLIMADA. The developers almost never interact with it." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "### Gitflow is a feature-based workflow" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "![](img/flow_2.png)\n", + "### Talk to the group\n", + " - Before starting coding a module, do not forget to coordinate with one of the repo admins (Emanuel, Chahan or Lukas)\n", + " - This is the chance to work out the Big Picture stuff that is better when it's planned with the group - possible intersections with other projects, possible conflicts, changes to the CLIMADA core, additional dependencies\n", + " - Also talk with others from the core development team ([see the GitHub wiki](https://github.com/CLIMADA-project/climada_python/wiki/Developer-Board)).\n", + " - Bring it to a developers meeting - people may be able to help/advise and are always interested in hearing about new projects. You can also find reviewers!\n", + " - Also, keep talking! Your plans _will_ change :)\n", "\n", - "- This is common to many workflows: when you want to add something new to the model you start a new branch, work on it locally, and then merge it back into `develop` **with a pull request** (which we'll cover later)." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "source": [ - "- By convention we name all CLIMADA feature branches `feature/*` (e.g. `feature/meteorite`).\n", - "- Features can be anything, from entire hazard modules to a smarter way to do one line of a calculation. Most of the work you'll do on CLIMADA will be a features of one size or another.\n", - "- We'll talk more about developing CLIMADA features later!" + "### Formulate the feature's data flow and workflow\n", + "\n", + "To optimize implementation and usefulness of the new feature, first conceptualize its data flow and workflow. It makes sense to discuss these with a CLIMADA core developer before starting to work on the feature's implementation.\n", + "- **Data flow**: Outline of how data moves through the system — where it is created or input, how it is processed, and if and where it is stored. This helps to improve the computational efficiency and to identify potential bottlenecks. \n", + "- **Workflow**: Plan about where and how the user and other CLIMADA components can interact with the new feature. This ensures that the new feature couples seamlessly to the existing code base of CLIMADA and that the new feaute is easily and clearly accessible to users.\n", + "\n", + "### Planning the work\n", + "\n", + "- Does the project go in its own repository and import CLIMADA, or does it extend the main CLIMADA repository. The way this is done is slowly changing, so definitely discuss it with the group.\n", + "- Find a few people who will help to review your code.\n", + " - Ask in a developers' meeting, on Slack (for WCR developers) or message people on the development team ([see the GitHub wiki](https://github.com/CLIMADA-project/climada_python/wiki/Developer-Board)).\n", + " - Let them know roughly how much code will be in the reviews, and when you'll be creating pull requests.\n", + "- How can the work split into manageable chunks?\n", + " - A series of smaller pull requests is far more manageable than one big one (and takes off some of the pre-release pressure)\n", + " - Reviewing and spotting issues/improvements/generalisations early is always a good thing.\n", + " - It encourages modularisation of the code: smaller self-contained updates, with documentation and tests.\n", + "- Will there be any changes to the CLIMADA core? These should be planned carefully\n", + "- Will you need any new dependencies? Are you sure?" ] }, { "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, + "metadata": {}, "source": [ - "### Gitflow enables a regular release cycle" + "## Installing CLIMADA for development\n", + "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "![](img/flow_3.png)\n", + "To develop (or review a pull request), you need to setup a proper climada development environment. This is relatively easy but requires rigor, so please read all the instructions below and make sure to follow them (we also recommend to read everything once first, and then follow them from the start). \n", "\n", - "- A release is usually more complex than merging `develop` into `main`." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "source": [ - "- So for this a `release-*` branch is created from `develop`. We'll all be notified repeatedly when the deadline is to submit (and then to review) pull requests so that you can be included in a release.\n", - "- The core developer team (mostly Emanuel) will then make sure tests, bugfixes, documentation and compatibility requirements are met, merging any fixes back into `develop`.\n", - "- On release day, the release branch is merged into `main`, the commit is tagged as a release and the release notes are published on the GitHub at " - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "### Everything else is hotfixes" + "First, follow the [Advanced instructions](../getting-started/install.rst#install-advanced). Note that if you want to work on a specific branch instead of `develop`, if you work on a feature for instance), you need to checkout that specific branc instead of `develop` after cloning:\n", + "\n", + "```\n", + "git clone https://github.com/CLIMADA-project/climada_python.git\n", + "cd climada_python\n", + "git checkout \n", + "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "![](img/flow_4.png)\n", + "### Note on dependencies\n", "\n", - "- The other type of branch you'll create is a hotfix." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "source": [ - "- Hotfixes are generally small changes to code that do one thing, fixing typos, small bugs, or updating docstrings. They're done in much the same way as features, and are usually merged with a pull request.\n", - "- The difference between features and hotfixes is fuzzy and you don't need to worry about getting it right.\n", - "- Hotfixes will occasionally be used to fix bugs on the `main` branch, in which case they will merge into both `main` and `develop`.\n", - "- Some hotfixes are so simple - e.g. fixing a typo or a docstring - that they don't need a pull request. Use your judgement, but as a rule, if you change what the code does, or how, you should be merging with a pull request." + "Climada dependencies are handled with the `requirements/env_climada.yml` file.\n", + "When you run `mamba env update -n -f requirements/env_climada.yml`, the content of that file is used to install the dependencies, thus, if you are working on a branch that changes the dependencies, make sure to be on that branch **before** running the command." ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "## Installing CLIMADA for development\n", + "## Working on feature branches\n", + "\n", + "When developing a big new feature, consider creating a feature branch and merging smaller branches into that feature branch with pull requests, keeping the whole process separate from `develop` until it's completed. This makes step-by-step code review nice and easy, and makes the final merge more easily tracked in the history.\n", + "\n", + "e.g. developing the big `feature/meteorite` module you might write `feature/meteorite-hazard` and merge it in, then `feature/meteorite-impact`, then `feature/meteorite-stochastic-events` etc... before finally merging `feature/meteorite` into `develop`. Each of these could be a reviewable pull request.\n", + "\n", + "### Make a new **branch**\n", + "\n", + "For new features in Git flow:\n", + "\n", + " git flow feature start feature_name\n", + " \n", + "Which is equivalent to (in vanilla git):\n", "\n", - "See [Installation](install.rst) for instructions on how to install CLIMADA for developers. You might need to install additional environments contained in ``climada_python/requirements`` when using specific functionalities. Also see [Apps for working with CLIMADA](../guide/Guide_get_started.ipynb#apps-for-working-with-climada) for an overview of which tools are useful for CLIMADA developers. " + " git checkout -b feature/feature_name\n", + "\n", + "Or work on an existing branch:\n", + "\n", + " git checkout -b branch_name\n", + "\n", + "get the latest data from the remote repository and update your branch\n", + " \n", + " git pull\n", + "\n", + "Once you have set up everything (including pre-commit hooks) you will be able to:\n", + "\n", + "see your locally modified files\n", + "\n", + " git status\n", + "\n", + "add changes you want to include in the commit\n", + "\n", + " git add climada/modified_file.py climada/test/test_modified_file.py\n", + "\n", + "commit the changes\n", + "\n", + " git commit -m \"new functionality of .. implemented\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "(guide-pre-commit-hooks)=\n", "### Pre-Commit Hooks\n", "\n", "Climada developer dependencies include pre-commit hooks to help ensure code linting and formatting.\n", @@ -295,7 +152,7 @@ "- the correct sorting of imports using ``isort``\n", "- the correct formatting of the code using ``black``\n", "\n", - "If you have installed the pre-commit hooks (see [Install developer dependencies](install.rst#install-developer-dependencies-optional)), they will be run each time you attempt to create a new commit, and the usual git flow can slightly change:\n", + "If you have installed the pre-commit hooks (see [Install developer dependencies](../getting-started/install.rst#install-developer-dependencies-optional)), they will be run each time you attempt to create a new commit, and the usual git flow can slightly change:\n", "\n", "If any check fails, you will be warned and these hooks **will apply** corrections (such as formatting the code with black if it is not).\n", "As files are modified, you are required to stage them again (hooks cannot stage their modification, only you can) and commit again.\n", @@ -372,150 +229,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Does it belong in CLIMADA? " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "When developing for CLIMADA, it is important to distinguish between core content and particular applications. Core content is meant to be included into the [climada_python](https://github.com/CLIMADA-project/climada_python) repository and will be subject to a code review. Any new addition should first be discussed with one of the [repository admins](https://github.com/CLIMADA-project/climada_python/wiki/Developer-Board). The purpose of this discussion is to see\n", - "\n", - "- How does the planned module fit into CLIMADA?\n", - "- What is an optimal architecture for the new module?\n", - "- What parts might already exist in other parts of the code?\n", - "\n", - "Applications made with CLIMADA, such as an [ECA study](https://eca-network.org/) can be stored in the [paper repository](https://github.com/CLIMADA-project/climada_papers) once they have been published. For other types of work, consider making a separate repository that imports CLIMADA as an external package." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## Features and branches" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "### Planning a new feature\n", - "\n", - "Here we're talking about large features such as new modules, new data sources, or big methodological changes. Any extension to CLIMADA that might affect other developers' work, modify the CLIMADA core, or need a big code review.\n", - "\n", - "Smaller feature branches don't need such formalities. Use your judgment, and if in doubt, let people know.\n", - "\n", - "### Talk to the group\n", - " - Before starting coding a module, do not forget to coordinate with one of the repo admins (Emanuel, Chahan or Lukas)\n", - " - This is the chance to work out the Big Picture stuff that is better when it's planned with the group - possible intersections with other projects, possible conflicts, changes to the CLIMADA core, additional dependencies\n", - " - Also talk with others from the core development team ([see the GitHub wiki](https://github.com/CLIMADA-project/climada_python/wiki/Developer-Board)).\n", - " - Bring it to a developers meeting - people may be able to help/advise and are always interested in hearing about new projects. You can also find reviewers!\n", - " - Also, keep talking! Your plans _will_ change :)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "### Planning the work\n", + "### Make unit and integration tests on your code, preferably during development\n", "\n", - "- Does the project go in its own repository and import CLIMADA, or does it extend the main CLIMADA repository?\n", - " - The way this is done is slowly changing, so definitely discuss it with the group.\n", - " - Chahan will discuss this later!\n", - "- Find a few people who will help to review your code.\n", - " - Ask in a developers' meeting, on Slack (for WCR developers) or message people on the development team ([see the GitHub wiki](https://github.com/CLIMADA-project/climada_python/wiki/Developer-Board)).\n", - " - Let them know roughly how much code will be in the reviews, and when you'll be creating pull requests.\n", - "- How can the work split into manageable chunks?\n", - " - A series of smaller pull requests is far more manageable than one big one (and takes off some of the pre-release pressure)\n", - " - Reviewing and spotting issues/improvements/generalisations early is always a good thing.\n", - " - It encourages modularisation of the code: smaller self-contained updates, with documentation and tests.\n", - "- Will there be any changes to the CLIMADA core?\n", - " - These should be planned carefully\n", - "- Will you need any new dependencies? Are you sure?\n", - " - Chahan will discuss this later!" + "Writing new code requires writing new tests: Please read our [Guide on unit and integration tests](Guide_Testing.ipynb)" ] }, { "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, + "metadata": {}, "source": [ - "### Working on feature branches\n", + "## Pull requests\n", "\n", - "When developing a big new feature, consider creating a feature branch and merging smaller branches into that feature branch with pull requests, keeping the whole process separate from `develop` until it's completed. This makes step-by-step code review nice and easy, and makes the final merge more easily tracked in the history.\n", - "\n", - "e.g. developing the big `feature/meteorite` module you might write `feature/meteorite-hazard` and merge it in, then `feature/meteorite-impact`, then `feature/meteorite-stochastic-events` etc... before finally merging `feature/meteorite` into `develop`. Each of these could be a reviewable pull request.\n", - "\n", - "### Make a new **branch**\n", - "\n", - "For new features in Git flow:\n", - "\n", - " git flow feature start feature_name\n", - " \n", - "Which is equivalent to (in vanilla git):\n", - "\n", - " git checkout -b feature/feature_name\n", - "\n", - "Or work on an existing branch:\n", - "\n", - " git checkout -b branch_name\n", - "\n", - "### Follow the [python do's and don't](https://github.com/CLIMADA-project/climada_python/blob/main/doc/guide/Guide_PythonDos-n-Donts.ipynb) and [performance](https://github.com/CLIMADA-project/climada_python/blob/main/doc/guide/Guide_Py_Performance.ipynb) guides. Write small readable methods, classes and functions.\n", - "\n", - "get the latest data from the remote repository and update your branch\n", - " \n", - " git pull\n", - "\n", - "see your locally modified files\n", - "\n", - " git status\n", - "\n", - "add changes you want to include in the commit\n", - "\n", - " git add climada/modified_file.py climada/test/test_modified_file.py\n", - "\n", - "commit the changes\n", - "\n", - " git commit -m \"new functionality of .. implemented\"\n", - " \n", - "### Make unit and integration tests on your code, preferably during development\n", - "see [Guide on unit and integration tests](../guide/Guide_Testing.ipynb)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## Pull requests" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ "We want every line of code that goes into the CLIMADA repository to be reviewed!\n", "\n", "Code review:\n", @@ -523,17 +247,8 @@ "- lets you draw on the experience of the rest of the team\n", "- makes sure that more than one person knows how your code works\n", "- helps to unify and standardise CLIMADA's code, so new users find it easier to read and navigate\n", - "- creates an archived description and discussion of the changes you've made" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ + "- creates an archived description and discussion of the changes you've made\n", + "\n", "### When to make a pull request\n", "\n", "- When you've finished writing a big new class or method (and its tests)\n", @@ -543,17 +258,8 @@ "\n", "Not all pull requests have to be into `develop` - you can make a pull request into any active branch that suits you.\n", "\n", - "Pull requests need to be made latest two weeks before a release, see [releases](https://github.com/CLIMADA-project/climada_python/releases)." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ + "Pull requests need to be made latest two weeks before a release, see [releases](https://github.com/CLIMADA-project/climada_python/releases).\n", + "\n", "### Step by step pull request!\n", "\n", "Let's suppose you've developed a cool new module on the `feature/meteorite` branch and you're ready to merge it into `develop`.\n", @@ -566,17 +272,8 @@ "- Updated dependencies (if need be)\n", "- Added your name to the AUTHORS file\n", "- Added an entry to the ``CHANGELOG.md`` file. See for information on how this shoud look like.\n", - "- (Advanced, optional) interactively rebase/squash recent commits that _aren't yet on GitHub_.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ + "- (Advanced, optional) interactively rebase/squash recent commits that _aren't yet on GitHub_.\n", + "\n", "### Steps\n", "\n", "1) Make sure the `develop` branch is up to date on your own machine\n", @@ -600,17 +297,8 @@ " ```\n", "\n", "4) Perform a static code analysis using pylint with CLIMADA's configuration `.pylintrc` (in the climada root directory). Jenkins executes it after every push.\\\n", - " To do it locally, your IDE probably provides a tool, or you can run `make lint` and see the output in `pylint.log`." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ + " To do it locally, your IDE probably provides a tool, or you can run `make lint` and see the output in `pylint.log`.\n", + "\n", "5) Push to GitHub.\n", " If you're pushing this branch for the first time, use\n", " ```\n", @@ -621,17 +309,8 @@ " git push\n", " ```\n", "\n", - "6) Check all the tests pass on the WCR Jenkins server (). See Emanuel's presentation for how to do this! You should regularly be pushing your code and checking this!" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ + "6) Check all the tests pass on the WCR Jenkins server (). See Emanuel's presentation for how to do this! You should regularly be pushing your code and checking this!\n", + "\n", "7) Create the pull request!\n", "\n", " - On the CLIMADA GitHub page, navigate to your feature branch (there's a drop-down menu above the file structure, pointing by default to `main`).\n", @@ -642,13 +321,7 @@ " - Assign reviewers in the page's right hand sidebar. Tag anyone who might be interested in reading the code. You should already have found one or two people who are happy to read the whole request and\n", " sign it off (they could also be added to 'Assignees').\n", " - Create the pull request.\n", - " - Contact the reviewers to let them know the request is live. GitHub's settings mean that they may not be alerted automatically. Maybe also let people know on the WCR Slack!" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ + " - Contact the reviewers to let them know the request is live. GitHub's settings mean that they may not be alerted automatically. Maybe also let people know on the WCR Slack!\n", "\n", "8) Talk with your reviewers\n", "\n", @@ -656,17 +329,8 @@ " - Take comments and suggestions on board, but you don't need to agree with everything and you don't need to implement everything.\n", " - If you feel someone is asking for too many changes, prioritise, especially if you don't have time for complex rewrites.\n", " - If the suggested changes and or features don't block functionality and you don't have time to fix them, they can be moved to Issues.\n", - " - Chase people up if they're slow. People are slow." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ + " - Chase people up if they're slow. People are slow.\n", + "\n", "\n", "9) Once you implement the requested changes, respond to the comments with the corresponding commit implementing each requested change.\n", "\n", @@ -679,41 +343,21 @@ " \n", "12) Update the `develop` branch on your local machine.\n", "\n", - "Also see the [**Reviewer Guide**](../guide/Guide_Review.ipynb) and [**Reviewer Checklist**](../guide/Guide_Review.ipynb#reviewer-checklist)!" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## General tips and tricks" + "Also see the [**Reviewer Guide**](Guide_Review.ipynb) and [**Reviewer Checklist**](Guide_Review.ipynb#reviewer-checklist)!" ] }, { "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, + "metadata": {}, "source": [ + "## General tips and tricks\n", + "\n", + "Follow the [python do's and don't](Guide_PythonDos-n-Donts) and [performance](Guide_Py_Performance.ipynb) guides. Write small readable methods, classes and functions.\n", + "\n", "### Ask for help with Git\n", "\n", - "- Git isn't intuitive, and rewinding or resetting is always work. If you're not certain what you're doing, or if you think you've messed up, send someone a message." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ + "- Git isn't intuitive, and rewinding or resetting is always work. If you're not certain what you're doing, or if you think you've messed up, send someone a message. See also our instructions for [Development with Git](Guide_Git_Development.ipynb).\n", + "\n", "### Don't push or commit to develop or main\n", "\n", "- Almost all new additions to CLIMADA should be merged into the `develop` branch with a pull request.\n", @@ -723,17 +367,8 @@ "\n", "So if you find yourself on the `main` or `develop` branches typing `git merge ...` or `git push` stop and think again - you should probably be making a pull request.\n", "\n", - "This can be difficult to undo, so contact someone on the team if you're unsure!" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ + "This can be difficult to undo, so contact someone on the team if you're unsure!\n", + "\n", "### Commit more often than you think, and use informative commit messages\n", "\n", "- Committing often makes mistakes less scary to undo\n", @@ -741,13 +376,8 @@ "git reset --hard HEAD\n", "```\n", "- Detailed commit messages make writing pull requests really easy\n", - "- Yes it's boring, but _trust me_, everyone (usually your future self) will love you when they're rooting through the git history to try and understand why something was changed" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ + "- Yes it's boring, but _trust me_, everyone (usually your future self) will love you when they're rooting through the git history to try and understand why something was changed\n", + "\n", "### Commit message syntax guidelines\n", "\n", "Basic syntax guidelines taken from here (on 17.06.2020)\n", @@ -763,17 +393,8 @@ " do it directly with the git command)\n", "- Put the name of the function/class/module/file that was edited\n", "- When fixing an issue, add the reference gh-ISSUENUMBER to the commit message \n", - " e.g. “fixes gh-40.” or “Closes gh-40.” For more infos see here ." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ + " e.g. “fixes gh-40.” or “Closes gh-40.” For more infos see here .\n", + "\n", "### What not to commit\n", "\n", "There are a lot of things that don't belong in the Git repository: \n", @@ -790,43 +411,16 @@ "To avoid committing changes of unrelated metadata, open Jupyter Notebooks in a text editor instead of your browser renderer. When committing changes, make sure that you indeed only commit things you *did* change, and revert any changes to metadata that are not related to your code updates.\n", "\n", "Several code editors use plugins to render Jupyter Notebooks. Here we collect the instructions to inspect Jupyter Notebooks as plain text when using them:\n", - "- **VSCode**: Open the Jupyter Notebook. Then open the internal command prompt (`Ctrl` + `Shift` + `P` or `Cmd` + `Shift` + `P` on macOS) and type/select 'View: Reopen Editor with Text Editor'" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ + "- **VSCode**: Open the Jupyter Notebook. Then open the internal command prompt (`Ctrl` + `Shift` + `P` or `Cmd` + `Shift` + `P` on macOS) and type/select 'View: Reopen Editor with Text Editor'\n", + "\n", "### Log ideas and bugs as GitHub Issues\n", "\n", "If there's a change you might want to see in the code - something that generalises, something that's not quite right, or a cool new feature - it can be set up as a GitHub Issue. Issues are pages for conversations about changes to the codebase and for logging bugs, and act as a 'backlog' for the CLIMADA project.\n", "\n", - "For a bug, or a question about functionality, make a minimal working example, state which version of CLIMADA you are using, and post it with the Issue." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "### How not to mess up the timeline" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "source": [ + "For a bug, or a question about functionality, make a minimal working example, state which version of CLIMADA you are using, and post it with the Issue.\n", + "\n", + "### How not to mess up the timeline\n", + "\n", "Git builds the repository through incremental edits. This means it's great at keeping track of its history. But there are a few commands that _edit_ this history, and if histories get out of sync on different copies of the repository you're going to have a bad time.\n", "\n", "- Don't rebase any commits that already exist remotely!\n", @@ -834,17 +428,8 @@ "- Otherwise, you're unlikely to do anything irreversible\n", "- You can do what you like with commits that only exist on your machine.\n", "\n", - "That said, doing an interactive rebase to tidy up your commit history _before_ you push it to GitHub is a nice friendly gesture :)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ + "That said, doing an interactive rebase to tidy up your commit history _before_ you push it to GitHub is a nice friendly gesture :)\n", + "\n", "### Do not fast forward merges \n", "\n", "(This shouldn't be relevant - all your merges into `develop` should be through pull requests, which doesn't fast forward. But:)\n", @@ -852,17 +437,8 @@ "Don't fast forward your merges unless your branch is a single commit. Use\n", "`git merge --no-ff ...`\n", "\n", - "The exceptions is when you're merging `develop` into your feature branch." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ + "The exceptions is when you're merging `develop` into your feature branch.\n", + "\n", "### Merge the remote develop branch into your feature branch every now and again\n", "\n", "- This way you'll find conflicts early\n", @@ -871,96 +447,39 @@ "git pull\n", "git checkout feature/myfeature\n", "git merge develop\n", - "```" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ + "```\n", + "\n", "### Create frequent pull requests\n", "\n", "I said this already:\n", "- It structures your workflow\n", "- It's easier for reviewers\n", "- If you're going to break something for other people you all know sooner\n", - "- It saves work for the rest of the team right before a release" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ + "- It saves work for the rest of the team right before a release\n", + "\n", "### Whenever you do something with CLIMADA, make a new local branch \n", "\n", - "You never know when a quick experiment will become something you want to save for later." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ + "You never know when a quick experiment will become something you want to save for later.\n", + "\n", "### But do not do everything in the CLIMADA repository\n", "\n", "- If you're running CLIMADA rather than developing it, create a new folder, initialise a new repository with `git init` and store your scripts and data there\n", - "- If you're writing an extension to CLIMADA that doesn't change the model core, create a new folder, initialise a new repository with `git init` and import CLIMADA. You can always add it to the model later if you need to." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "### Questions" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ + "- If you're writing an extension to CLIMADA that doesn't change the model core, create a new folder, initialise a new repository with `git init` and import CLIMADA. You can always add it to the model later if you need to.\n", + "\n", + "### Questions\n", + "\n", "![Git and Github logos](img/xkcd_git.png)\\\n", "" ] } ], "metadata": { - "celltoolbar": "Slideshow", "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" + "display_name": "", + "name": "" }, "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.10.13" - }, - "vscode": { - "interpreter": { - "hash": "fe76ddefd4ac3b756bca82b2809865e7c67c346a46477cb9eec4ead581742ab6" - } + "name": "python" } }, "nbformat": 4, diff --git a/doc/guide/Guide_CLIMADA_Tutorial.ipynb b/doc/development/Guide_CLIMADA_Tutorial.ipynb similarity index 100% rename from doc/guide/Guide_CLIMADA_Tutorial.ipynb rename to doc/development/Guide_CLIMADA_Tutorial.ipynb diff --git a/doc/guide/Guide_CLIMADA_conventions.ipynb b/doc/development/Guide_CLIMADA_conventions.ipynb similarity index 98% rename from doc/guide/Guide_CLIMADA_conventions.ipynb rename to doc/development/Guide_CLIMADA_conventions.ipynb index 6b4e4c290..9ce5b3285 100644 --- a/doc/guide/Guide_CLIMADA_conventions.ipynb +++ b/doc/development/Guide_CLIMADA_conventions.ipynb @@ -49,7 +49,7 @@ " - Contact a [repository admin](https://github.com/CLIMADA-project/climada_python/wiki/Developer-Board) to get permission\n", " - Open an [issue](https://github.com/CLIMADA-project/climada_python/issues)\n", " \n", - "Hence, first try to solve your problem with the standard library and function/methods already implemented in CLIMADA (see in particular the [utility functions](#Utility-functions)) then use the packages included in CLIMADA, and if this is not enough, propose the addition of a new package. Do not hesitate to propose new packages if this is needed for your work!" + "Hence, first try to solve your problem with the standard library and function/methods already implemented in CLIMADA then use the packages included in CLIMADA, and if this is not enough, propose the addition of a new package. Do not hesitate to propose new packages if this is needed for your work!" ] }, { @@ -132,8 +132,8 @@ "\n", "Note that most text editors usually take care of 1. and 2. by default.\n", "\n", - "Please note that pull requests will not be merged if these checks fail. The easiest way to ensure this, is to use [pre-commit hooks](guide-pre-commit-hooks), which will allow you to both run the checks and apply fixes when creating a new commit.\n", - "Following the [advanced installation instructions](install.rst#advanced-instructions) will set up these hooks for you." + "Please note that pull requests will not be merged if these checks fail. The easiest way to ensure this, is to use [pre-commit hooks](Guide_CLIMADA_Development.ipynb#pre-commit-hooks), which will allow you to both run the checks and apply fixes when creating a new commit.\n", + "Following the [advanced installation instructions](../getting-started/install.rst#advanced-instructions) will set up these hooks for you." ] }, { @@ -505,7 +505,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.19" + "version": "3.12.6" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/doc/guide/Guide_Configuration.ipynb b/doc/development/Guide_Configuration.ipynb similarity index 98% rename from doc/guide/Guide_Configuration.ipynb rename to doc/development/Guide_Configuration.ipynb index 69056eba6..ad8ccb36f 100644 --- a/doc/guide/Guide_Configuration.ipynb +++ b/doc/development/Guide_Configuration.ipynb @@ -439,7 +439,7 @@ "source": [ "### Test Configuration \n", "\n", - "The configuration values for unit and integration tests are not part of the [default configuration](#Default-Configuration), since they are irrelevant for the regular CLIMADA user and only aimed for developers.\\\n", + "The configuration values for unit and integration tests are not part of the [default configuration](#default-configuration), since they are irrelevant for the regular CLIMADA user and only aimed for developers.\\\n", "The default test configuration is defined in the `climada.conf` file of the installation directory.\n", "This file contains paths to files that are read during tests. If they are part of the GitHub repository, their path i.g. starts with the `climada` folder within the installation directory:\n", "```json\n", @@ -509,7 +509,7 @@ ], "metadata": { "kernelspec": { - "display_name": "climada_env", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -523,7 +523,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13 | packaged by conda-forge | (default, Mar 25 2022, 06:05:47) \n[Clang 12.0.1 ]" + "version": "3.12.6" }, "vscode": { "interpreter": { diff --git a/doc/guide/Guide_Euler.ipynb b/doc/development/Guide_Euler.ipynb similarity index 93% rename from doc/guide/Guide_Euler.ipynb rename to doc/development/Guide_Euler.ipynb index ccfc8a445..1798f11b1 100644 --- a/doc/guide/Guide_Euler.ipynb +++ b/doc/development/Guide_Euler.ipynb @@ -72,12 +72,13 @@ "\n", "(The last two lines may seem odd but they are working around a conficting dependency version situation.)\n", "\n", - "You need to execute this every time you login to Euler before Climada can be used. \n", + "You need to execute this every time you login to Euler before Climada can be used.\n", "To safe yourself from doing it manually, append these lines to the ~/.bashrc script, which is automatically executed upon logging in to Euler." ] }, { "cell_type": "markdown", + "id": "4dad7c27", "metadata": {}, "source": [ "\n", @@ -121,7 +122,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### 4. Install climada\n", + "### 4. Install Climada\n", "\n", "There are two options. Either install from the downloaded repository (option A), or use a particular released version (option B).\n", "\n", @@ -132,6 +133,7 @@ "cd climada_python\n", "pip install -e .\n", "```\n", + "If you need to work with a specific branch of Climada, you can do so by checking out to the target branch `your_branch` by running `git checkout your_branch` after having cloned the Climada repository and before running `pip install -e .`.\n", "\n", "#### option B\n", "\n", @@ -144,12 +146,13 @@ }, { "cell_type": "markdown", + "id": "479e0ac2", "metadata": {}, "source": [ "\n", "### 5. Adjust the Climada configuration\n", "\n", - "Edit a configuration file according to your needs (see [Guide_Configuration](../guide/Guide_Configuration.ipynb)).\n", + "Edit a configuration file according to your needs (see [Configuration](../development/Guide_Configuration.ipynb)).\n", "Create a climada.conf file e.g., in /cluster/home/$USER/.config with the following content:\n", "\n", "```json\n", @@ -186,10 +189,26 @@ "\n", "Look for the \"`OK`\" in the hereby created `slurm-[XXXXXXX].out` file\n", "\n", - "Please see the docs at https://slurm.schedmd.com/ on how to use the `slurm` batch system \n", + "Please see the docs at https://slurm.schedmd.com/ on how to use the `slurm` batch system\n", "and the Wiki https://scicomp.ethz.ch/wiki/Transition_from_LSF_to_Slurm for a mapping of `lsf` commands to their `slurm` equivalents." ] }, + { + "cell_type": "markdown", + "id": "e5c90bff", + "metadata": {}, + "source": [ + "### 7. Optional: Install Climada Petals\n", + "\n", + "To install Climada Petals, repeat the steps described in step 4A, but replacing the climada_python with the climada_petals repository:\n", + "```bash\n", + "cd /cluster/project/climate/$USER # or wherever you plan to download the repository\n", + "git clone https://github.com/CLIMADA-project/climada_petals.git # unless this has been done before\n", + "cd climada_petals\n", + "pip install -e .\n", + "```" + ] + }, { "cell_type": "markdown", "metadata": {}, diff --git a/doc/guide/Guide_Exception_Logging.ipynb b/doc/development/Guide_Exception_Logging.ipynb similarity index 100% rename from doc/guide/Guide_Exception_Logging.ipynb rename to doc/development/Guide_Exception_Logging.ipynb diff --git a/doc/development/Guide_Git_Development.ipynb b/doc/development/Guide_Git_Development.ipynb new file mode 100644 index 000000000..b71d408fe --- /dev/null +++ b/doc/development/Guide_Git_Development.ipynb @@ -0,0 +1,303 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "# Development with Git\n", + "\n", + " Here we provide a detailed instruction to the use of Git and GitHub and their workflows, which are essential to the code development of CLIMADA. \n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Git and GitHub\n", + "\n", + "- Git's not that scary\n", + " - 95% of your work on Git will be done with the same handful of commands (the other 5% will always be done with careful Googling)\n", + " - Almost everything in Git can be undone by design (but use `rebase`, `--force` and `--hard` with care!)\n", + " - Your favourite IDE (Spyder, PyCharm, ...) will have a GUI for working with Git, or you can download a standalone one.\n", + "- The [Git Book](https://git-scm.com/book/en/v2) is a great introduction to how Git works and to using it on the command line.\n", + "- Consider using a GUI program such as “git desktop” or “Gitkraken” to have a visual git interface, in particular at the beginning. Your python IDE is also likely to have a visual git interface. \n", + "- Feel free to ask for help" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "![](img/git_gui.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### What we assume you know\n", + "\n", + "We're assuming you're all familiar with the basics of Git.\n", + "\n", + "- What (and why) is version control\n", + "- How to clone a repository\n", + "- How to make a commit and push it to GitHub\n", + "- What a branch is, and how to make one\n", + "- How to merge two branches\n", + "- The basics of the GitHub website\n", + "\n", + "If you're not feeling great about this, we recommend\n", + "- sending me a message so we can arrange an introduction with CLIMADA\n", + "- exploring the [Git Book](https://git-scm.com/book/en/v2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Terms we'll be using today\n", + "\n", + "These are terms that will come up a lot, so let's make sure we know them\n", + "\n", + "- local versus remote\n", + " - Our **remote** repository is hosted on GitHub. This is the central location where all updates to CLIMADA that we want to share end up. If you're updating CLIMADA for the community, your code will end up here too.\n", + " - Your **local** repository is the copy you have on the machine you're working on, and where you do your work.\n", + " - Git calls the (first, default) remote the `origin`\n", + " - (It's possible to set more than one remote repository, e.g. you might set one up on a network-restricted computing cluster)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "- push, pull and pull request\n", + " - You **push** your work when you send it from your local machine to the remote repository\n", + " - You **pull** from the remote repository to update the code on your local machine\n", + " - A **pull request** is a standardised review process on GitHub. Usually it ends with one branch merging into another" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "- Conflict resolution\n", + " - Sometimes two people have made changes to the same bit of code. Usually this comes up when you're trying to merge branches. The changes have to be manually compared and the code edited to make sure the 'correct' version of the code is kept. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Gitflow " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Gitflow is a particular way of using git to organise projects that have\n", + "- multiple developers\n", + "- working on different features\n", + "- with a release cycle\n", + "\n", + "It means that\n", + "- there's always a stable version of the code available to the public\n", + "- the chances of two developers' code conflicting are reduced\n", + "- the process of adding and reviewing features and fixes is more standardised for everyone\n", + "\n", + "Gitflow is a _convention_, so you don't need any additional software.\n", + "- ... but if you want you can get some: a popular extension to the git command line tool allows you to issue more intuitive commands for a Gitflow workflow.\n", + "- Mac/Linux users can install git-flow from their package manager, and it's included with Git for Windows " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Gitflow works on the `develop` branch instead of `main`" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "![](img/flow_1.png)\n", + "\n", + "- The critical difference between Gitflow and 'standard' git is that almost all of your work takes place on the `develop` branch, instead of the `main` (formerly `master`) branch.\n", + "- The `main` branch is reserved for planned, stable product releases, and it's what the general public download when they install CLIMADA. The developers almost never interact with it." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Gitflow is a feature-based workflow" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/flow_2.png)\n", + "\n", + "- This is common to many workflows: when you want to add something new to the model you start a new branch, work on it locally, and then merge it back into `develop` **with a pull request** (which we'll cover later)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "- By convention we name all CLIMADA feature branches `feature/*` (e.g. `feature/meteorite`).\n", + "- Features can be anything, from entire hazard modules to a smarter way to do one line of a calculation. Most of the work you'll do on CLIMADA will be a features of one size or another.\n", + "- We'll talk more about developing CLIMADA features later!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Gitflow enables a regular release cycle" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/flow_3.png)\n", + "\n", + "- A release is usually more complex than merging `develop` into `main`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "- So for this a `release-*` branch is created from `develop`. We'll all be notified repeatedly when the deadline is to submit (and then to review) pull requests so that you can be included in a release.\n", + "- The core developer team (mostly Emanuel) will then make sure tests, bugfixes, documentation and compatibility requirements are met, merging any fixes back into `develop`.\n", + "- On release day, the release branch is merged into `main`, the commit is tagged as a release and the release notes are published on the GitHub at " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Everything else is hotfixes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/flow_4.png)\n", + "\n", + "- The other type of branch you'll create is a hotfix." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "- Hotfixes are generally small changes to code that do one thing, fixing typos, small bugs, or updating docstrings. They're done in much the same way as features, and are usually merged with a pull request.\n", + "- The difference between features and hotfixes is fuzzy and you don't need to worry about getting it right.\n", + "- Hotfixes will occasionally be used to fix bugs on the `main` branch, in which case they will merge into both `main` and `develop`.\n", + "- Some hotfixes are so simple - e.g. fixing a typo or a docstring - that they don't need a pull request. Use your judgement, but as a rule, if you change what the code does, or how, you should be merging with a pull request." + ] + } + ], + "metadata": { + "celltoolbar": "Slideshow", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + }, + "vscode": { + "interpreter": { + "hash": "fe76ddefd4ac3b756bca82b2809865e7c67c346a46477cb9eec4ead581742ab6" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/doc/guide/Guide_Py_Performance.ipynb b/doc/development/Guide_Py_Performance.ipynb similarity index 100% rename from doc/guide/Guide_Py_Performance.ipynb rename to doc/development/Guide_Py_Performance.ipynb diff --git a/doc/guide/Guide_PythonDos-n-Donts.ipynb b/doc/development/Guide_PythonDos-n-Donts.ipynb similarity index 100% rename from doc/guide/Guide_PythonDos-n-Donts.ipynb rename to doc/development/Guide_PythonDos-n-Donts.ipynb diff --git a/doc/guide/Guide_Review.ipynb b/doc/development/Guide_Review.ipynb similarity index 78% rename from doc/guide/Guide_Review.ipynb rename to doc/development/Guide_Review.ipynb index f996598b4..55bb3bfb7 100644 --- a/doc/guide/Guide_Review.ipynb +++ b/doc/development/Guide_Review.ipynb @@ -39,9 +39,9 @@ "At least one reviewer needs to\n", "- Review all the changes in the pull request. Read what it's supposed to do, check it does that, and make sure the logic is sound.\n", "- Check that the code follows the CLIMADA style guidelines \n", - "- [CLIMADA coding conventions](../guide/Guide_CLIMADA_conventions.ipynb) \n", - "- [Python Dos and Don't](../guide/Guide_PythonDos-n-Donts.ipynb) \n", - " - [Python performance tips and best practice for CLIMADA developers](../guide/Guide_Py_Performance.ipynb) \n", + "- [CLIMADA coding conventions](../development/Guide_CLIMADA_conventions.ipynb) \n", + "- [Python Dos and Don't](../development/Guide_PythonDos-n-Donts.ipynb) \n", + "- [Python performance tips and best practice for CLIMADA developers](../development/Guide_Py_Performance.ipynb) \n", "- If the code is implementing an algorithm it should be referenced in the documentation. Check it's implemented correctly.\n", "- Try to think of edge cases and ways the code could break. See if there's appropriate error handling in cases where the function might behave unexpectedly.\n", "- (Optional) suggest easy ways to speed up the code, and more elegant ways to achieve the same goal.\n", @@ -52,6 +52,32 @@ "- If you decide to help the author with changes, you can either push them to the same branch, or create a new branch and make a pull request with the changes back into the branch you're reviewing. This lets the author review it and merge." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup the environment" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order to make your review, you will have to have climada installed from source (see [here](../getting-started/install.rst#install-advanced)), and switch to the branch you are reviewing (see [here](../getting-started/install.rst#change-branch))\n", + "\n", + "Creating a new python environment is often not necessary (*e.g.*, for minor feature branch that do not change the dependencies you can probably use a generic `develop` environment where you installed climada in editable mode), but can help in some cases (for instance changes in dependencies), to do so:\n", + "\n", + "Here is a generic set of instructions which should always work, assuming you already cloned the climada repository, and are at the root of that folder:\n", + "\n", + "```\n", + "git fetch && git checkout \n", + "mamba create -n # restrict python version here with \"python==3.x.*\"\n", + "mamba env update -n -f requirements/env_climada.yml\n", + "mamba activate \n", + "pip install -e ./\n", + "```\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -123,13 +149,24 @@ " obviously inefficient (computation time-wise and memory-wise) parts in\n", " the code?" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { + "kernelspec": { + "display_name": "", + "name": "" + }, "language_info": { "name": "python" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/doc/guide/Guide_Testing.ipynb b/doc/development/Guide_Testing.ipynb similarity index 97% rename from doc/guide/Guide_Testing.ipynb rename to doc/development/Guide_Testing.ipynb index 319d8ada5..12f59efb3 100644 --- a/doc/guide/Guide_Testing.ipynb +++ b/doc/development/Guide_Testing.ipynb @@ -47,13 +47,13 @@ " `python -m unittest climada.x.test_y.TestY.test_z`\\\n", " _Interactively:_ \\\n", " `climada.x.test_y.TestY().test_z()`\n", - "- __Right after implementation.__ In case the coverage analysis shows that there are missing tests, see [Test Coverage](#CICover).\n", - "- __Later, when a bug was encountered.__ Whenever a bug gets fixed, also the tests need to be adapted or amended. " + "- __Right after implementation.__ In case the coverage analysis shows that there are missing tests, see [Test Coverage](#test-coverage).\n", + "- __Later, when a bug was encountered.__ Whenever a bug gets fixed, also the tests need to be adapted or amended." ] }, { - "attachments": {}, "cell_type": "markdown", + "id": "5819e8c6", "metadata": {}, "source": [ "### Basic Test Procedure\n", @@ -287,7 +287,7 @@ "## Testing CLIMADA\n", "\n", "Executing the entire test suite requires you to install the additional requirements for testing.\n", - "See the [installation instructions](install.rst) for [developer dependencies](install-dev) for further information.\n", + "See the [installation instructions for developer dependencies](../getting-started/install.rst#advanced-instructions) for further information.\n", "\n", "In general, you execute tests with\n", "```\n", @@ -323,7 +323,7 @@ "```\n", "make integ_test\n", "```\n", - "It lasts about 15 minutes and runs extensive integration tests, during which also data from external resources is read. An open internet connection is required for a successful test run. \n", + "It lasts about 15 minutes and runs extensive integration tests, during which also data from external resources is read. An open internet connection is required for a successful test run.\n", "\n", "### Coverage\n", "\n", @@ -334,7 +334,7 @@ ], "metadata": { "kernelspec": { - "display_name": "climada_py38", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -348,7 +348,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.15" + "version": "3.12.6" }, "vscode": { "interpreter": { diff --git a/doc/guide/Guide_continuous_integration_GitHub_actions.ipynb b/doc/development/Guide_continuous_integration_GitHub_actions.ipynb similarity index 100% rename from doc/guide/Guide_continuous_integration_GitHub_actions.ipynb rename to doc/development/Guide_continuous_integration_GitHub_actions.ipynb diff --git a/doc/development/coding-in-python.rst b/doc/development/coding-in-python.rst new file mode 100644 index 000000000..39912c73e --- /dev/null +++ b/doc/development/coding-in-python.rst @@ -0,0 +1,10 @@ +################ +Coding in python +################ + +.. toctree:: + :maxdepth: 1 + + Guide_PythonDos-n-Donts + Guide_Exception_Logging + Performance and Best Practices diff --git a/doc/guide/img/CLIMADA_logo_QR.png b/doc/development/img/CLIMADA_logo_QR.png similarity index 100% rename from doc/guide/img/CLIMADA_logo_QR.png rename to doc/development/img/CLIMADA_logo_QR.png diff --git a/doc/guide/img/FileSystem-1.png b/doc/development/img/FileSystem-1.png similarity index 100% rename from doc/guide/img/FileSystem-1.png rename to doc/development/img/FileSystem-1.png diff --git a/doc/guide/img/FileSystem-2.png b/doc/development/img/FileSystem-2.png similarity index 100% rename from doc/guide/img/FileSystem-2.png rename to doc/development/img/FileSystem-2.png diff --git a/doc/guide/img/LoggerLevels.png b/doc/development/img/LoggerLevels.png similarity index 100% rename from doc/guide/img/LoggerLevels.png rename to doc/development/img/LoggerLevels.png diff --git a/doc/guide/img/WhenToLog.png b/doc/development/img/WhenToLog.png similarity index 100% rename from doc/guide/img/WhenToLog.png rename to doc/development/img/WhenToLog.png diff --git a/doc/guide/img/docstring1.png b/doc/development/img/docstring1.png similarity index 100% rename from doc/guide/img/docstring1.png rename to doc/development/img/docstring1.png diff --git a/doc/guide/img/docstring2.png b/doc/development/img/docstring2.png similarity index 100% rename from doc/guide/img/docstring2.png rename to doc/development/img/docstring2.png diff --git a/doc/guide/img/docstring3.png b/doc/development/img/docstring3.png similarity index 100% rename from doc/guide/img/docstring3.png rename to doc/development/img/docstring3.png diff --git a/doc/guide/img/docstring4.png b/doc/development/img/docstring4.png similarity index 100% rename from doc/guide/img/docstring4.png rename to doc/development/img/docstring4.png diff --git a/doc/guide/img/docstring5.png b/doc/development/img/docstring5.png similarity index 100% rename from doc/guide/img/docstring5.png rename to doc/development/img/docstring5.png diff --git a/doc/guide/img/dr_who.jpg b/doc/development/img/dr_who.jpg similarity index 100% rename from doc/guide/img/dr_who.jpg rename to doc/development/img/dr_who.jpg diff --git a/doc/guide/img/flow_1.png b/doc/development/img/flow_1.png similarity index 100% rename from doc/guide/img/flow_1.png rename to doc/development/img/flow_1.png diff --git a/doc/guide/img/flow_2.png b/doc/development/img/flow_2.png similarity index 100% rename from doc/guide/img/flow_2.png rename to doc/development/img/flow_2.png diff --git a/doc/guide/img/flow_3.png b/doc/development/img/flow_3.png similarity index 100% rename from doc/guide/img/flow_3.png rename to doc/development/img/flow_3.png diff --git a/doc/guide/img/flow_4.png b/doc/development/img/flow_4.png similarity index 100% rename from doc/guide/img/flow_4.png rename to doc/development/img/flow_4.png diff --git a/doc/guide/img/fstrings.png b/doc/development/img/fstrings.png similarity index 100% rename from doc/guide/img/fstrings.png rename to doc/development/img/fstrings.png diff --git a/doc/guide/img/git_github_logos.jpg b/doc/development/img/git_github_logos.jpg similarity index 100% rename from doc/guide/img/git_github_logos.jpg rename to doc/development/img/git_github_logos.jpg diff --git a/doc/guide/img/git_gui.png b/doc/development/img/git_gui.png similarity index 100% rename from doc/guide/img/git_gui.png rename to doc/development/img/git_gui.png diff --git a/doc/guide/img/pylint.png b/doc/development/img/pylint.png similarity index 100% rename from doc/guide/img/pylint.png rename to doc/development/img/pylint.png diff --git a/doc/guide/img/xkcd_git.png b/doc/development/img/xkcd_git.png similarity index 100% rename from doc/guide/img/xkcd_git.png rename to doc/development/img/xkcd_git.png diff --git a/doc/guide/img/zen_of_python.png b/doc/development/img/zen_of_python.png similarity index 100% rename from doc/guide/img/zen_of_python.png rename to doc/development/img/zen_of_python.png diff --git a/doc/development/index.rst b/doc/development/index.rst new file mode 100644 index 000000000..a5e5f90c6 --- /dev/null +++ b/doc/development/index.rst @@ -0,0 +1,30 @@ +*************** +Developer Guide +*************** + +This developer guide regroups all information intended for contributors. + +Very minimal instruction for contributing can be found below. + +If you are interested in contributing to CLIMADA, we recommand you to start with the +:doc:`Overview ` part of this guide. + +.. include:: ../../CONTRIBUTING.md + :parser: myst_parser.sphinx_ + :start-line: 3 + +.. toctree:: + :maxdepth: 2 + :hidden: + + Overview + Development with Git + Guide_continuous_integration_GitHub_actions + Coding in python + CLIMADA Coding Conventions + CLIMADA Configuration convention + Documenting your code + Writing tests for your code + Guide_Review + Guide_Euler + Authors <../misc/AUTHORS> diff --git a/doc/development/write-documentation.rst b/doc/development/write-documentation.rst new file mode 100644 index 000000000..cfa4baa32 --- /dev/null +++ b/doc/development/write-documentation.rst @@ -0,0 +1,9 @@ +########################### +Documentation writing +########################### + +.. toctree:: + :maxdepth: 1 + + Guide_CLIMADA_Tutorial + Building the Documentation <../README> diff --git a/doc/tutorial/0_intro_python.ipynb b/doc/getting-started/0_intro_python.ipynb similarity index 100% rename from doc/tutorial/0_intro_python.ipynb rename to doc/getting-started/0_intro_python.ipynb diff --git a/doc/guide/Guide_Introduction.ipynb b/doc/getting-started/Guide_Introduction.ipynb similarity index 95% rename from doc/guide/Guide_Introduction.ipynb rename to doc/getting-started/Guide_Introduction.ipynb index 3f3a9ff13..aae2fa54d 100644 --- a/doc/guide/Guide_Introduction.ipynb +++ b/doc/getting-started/Guide_Introduction.ipynb @@ -9,7 +9,7 @@ "# Introduction\n", "\n", "CLIMADA implements a fully probabilistic risk assessment model.\n", - "According to the IPCC [[1]](#1), natural risks emerge through the\n", + "According to the IPCC [[1](#references)], natural risks emerge through the\n", "interplay of climate and weather-related hazards, the exposure of goods\n", "or people to this hazard, and the specific vulnerability of exposed\n", "people, infrastructure and environment. \n", @@ -53,7 +53,7 @@ "

\n", "\n", "## References\n", - "[1] \n", + "[IPCC] \n", "IPCC: Climate Change 2014: Impacts, Adaptation and Vulnerability.\n", " Part A: Global and Sectoral Aspects. Contribution of Working Group\n", " II to the Fifth Assessment Report of the Intergovernmental Panel on\n", @@ -70,7 +70,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -84,7 +84,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.12.6" } }, "nbformat": 4, diff --git a/doc/getting-started/Guide_get_started.ipynb b/doc/getting-started/Guide_get_started.ipynb new file mode 100644 index 000000000..c4171d500 --- /dev/null +++ b/doc/getting-started/Guide_get_started.ipynb @@ -0,0 +1,132 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "trying-bronze", + "metadata": {}, + "source": [ + "# How to navigate this documentation" + ] + }, + { + "cell_type": "markdown", + "id": "multiple-radical", + "metadata": {}, + "source": [ + "This page is a short summary of the different sections and guides here, to help you find the information that you need to get started.\n", + "\n", + "Each top section has its own landing page, presenting the essential elements in brief, and often several subsections, which go more into details." + ] + }, + { + "cell_type": "markdown", + "id": "68085d04-e4ee-45c8-8dbb-41e35bd072a1", + "metadata": {}, + "source": [ + "## Getting started\n", + "\n", + "The [Getting started](../getting-started/index.rst) section, where you are currently, presents the very basics of climada.\n", + "\n", + "For instance, to start learning about CLIMADA, you can have a look at the [introduction](../getting-started/Guide_Introduction.ipynb). \n", + "\n", + "You can also have a look at the paper [repository](https://github.com/CLIMADA-project/climada_papers) to get an overview of research projects conducted with CLIMADA." + ] + }, + { + "cell_type": "markdown", + "id": "future-distinction", + "metadata": {}, + "source": [ + "### Programming in Python\n", + "\n", + "It is best to have some basic knowledge of Python programming before starting with CLIMADA. But if you need a quick introduction or reminder, have a look at the short [Python Tutorial](../getting-started/0_intro_python.ipynb). Also have a look at the python [Python Dos and Don't](../development/Guide_PythonDos-n-Donts.ipynb) guide and at the [Python Performance Guide](../development/Guide_Py_Performance.ipynb) for best practice tips." + ] + }, + { + "cell_type": "markdown", + "id": "touched-penetration", + "metadata": {}, + "source": [ + "## Tutorials\n", + "A good way to start using CLIMADA is to have a look at the tutorials in the [User Guide](../user-guide/index.rst). The [10 minute climada](../user-guide/0_10min_climada.ipynb) tutorial will give you a quick introduction to CLIMADA, with a brief example on how to calculate you first impacts, as well as your first appraisal of adaptation options, while the [Overview](../user-guide/1_main_climada.ipynb) will present the whole structure of CLIMADA more in depth. You can then look at the specific tutorials for each module (for example if you are interested in a specific hazard, like [Tropical Cyclones](../user-guide/climada_hazard_TropCyclone.ipynb), or in learning to [estimate the value of asset exposure](../user-guide/climada_entity_LitPop.ipynb),...). " + ] + }, + { + "cell_type": "markdown", + "id": "cd831a52-ea5f-48ee-bf6b-4a6c1a1cdf15", + "metadata": {}, + "source": [ + "## Contributing\n", + "\n", + "If you would like to participate in the development of CLIMADA, carefully read the [Developer Guide](../development/index.rst). \n", + "Here you will find how to set up an environment to develop new features for CLIMADA, the workflow and rules to follow to make sure you can implement a valuable contribution!" + ] + }, + { + "cell_type": "markdown", + "id": "dc0f6303-e02b-429f-acc3-dd1b23d49be3", + "metadata": {}, + "source": [ + "## API Reference\n", + "\n", + "The [API reference](../api/index.rst) presents the documentation of the internal modules, classes, methods and function of CLIMADA." + ] + }, + { + "cell_type": "markdown", + "id": "6a25d260-336f-439a-8859-00b9b4c1251d", + "metadata": {}, + "source": [ + "## Changelog\n", + "\n", + "In the Changelog section, you can have a look at all the changes made between the different versions of CLIMADA" + ] + }, + { + "cell_type": "markdown", + "id": "efa8c4fc-706b-40e1-9567-c58dc9f59e0c", + "metadata": {}, + "source": [ + "## External links\n", + "\n", + "The top bar of this website also link to the documentation of [Climada Petals](https://climada-petals.readthedocs.io/en/stable/), the webpage of the [Weather and Climate Risk group](https://wcr.ethz.ch/) at ETH, and the official [CLIMADA website](https://climada.ethz.ch/)." + ] + }, + { + "cell_type": "markdown", + "id": "connected-anthony", + "metadata": {}, + "source": [ + "## Other Questions\n", + "\n", + "If you cannot find you answer in the other guides provided here, you can open an [issue](https://github.com/CLIMADA-project/climada_python/issues) for somebody to help you." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.6" + }, + "vscode": { + "interpreter": { + "hash": "fe76ddefd4ac3b756bca82b2809865e7c67c346a46477cb9eec4ead581742ab6" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/doc/getting-started/index.rst b/doc/getting-started/index.rst new file mode 100644 index 000000000..9356080de --- /dev/null +++ b/doc/getting-started/index.rst @@ -0,0 +1,112 @@ +=================== +Getting started +=================== + +Quick Installation +-------------------- + +The simple CLIMADA installation only requires the `mamba` (or `conda`) python environment manager (look :ref:`here `). + +If you are already working with mamba or conda, you can install CLIMADA by executing the following line in the terminal: + + mamba create -n climada_env -c conda-forge climada + +Each time you will want to work with CLIMADA, simply activate the environment:: + + mamba activate climada_env + +You are good to go! + +.. seealso:: + + You don't have mamba or conda installed, or you are looking for advanced installation instructions? Look up our :doc:`detailed instructions ` on CLIMADA installation. + +CLIMADA in a Nutshell +--------------------- + +.. dropdown:: How does CLIMADA compute impacts ? + :color: primary + + CLIMADA follows the IPCC risk framework to compute impacts by combining hazard intensity, exposure, and vulnerability. + It models hazards intensity (e.g., tropical cyclones, floods) using + historical event sets or stochastic simulations, overlaying them with spatial exposure data + (e.g., population, infrastructure), and applies vulnerability functions that estimate damage + given the hazard intensity. By aggregating these results, CLIMADA calculates expected + impacts, such as economic losses or affected populations. See the dedicated :doc:`impact tutorial ` + for more information. + + .. image:: /user-guide/img/risk_framework.png + :width: 400 + :alt: Alternative text + :align: center + +.. dropdown:: How do you create a Hazard ? + :color: primary + + From a risk perspective, the interesting aspect of a natural hazard is its location and intensity. For such, + CLIMADA allows you to load your own :doc:`hazard ` data or to directly define it in the platform. As an example, + users can easily load historical tropical cyclone tracks (IBTracks) and apply stochastic methods to generate + a larger ensemble of tracks from the historical ones, from which they can easily compute the maximal windspeed, + the hazard intensity. + + .. image:: /user-guide/img/tc-tracks.png + :width: 500 + :alt: Alternative text + :align: center + +.. dropdown:: How do we define an exposure ? + :color: primary + + Exposure is defined as the entity that could potentially be damaged by a hazard: it can be people, infrastructures, + assests, ecosystems or more. A CLIMADA user is given the option to load its own exposure data into the platform, + or to use CLIMADA to define it. One common way of defining assets' exposure is through :doc:`LitPop `. LitPop dissagrate a + financial index, as the country GDP for instance, to a much finer resolution proportionally to population + density and nighlight intensity. + + .. image:: /user-guide/img/exposure.png + :width: 500 + :align: center + +.. dropdown:: How do we model vulnerability ? + :color: primary + + Vulnerability curves, also known as impact functions, tie the link between hazard intensity and damage. + CLIMADA offers built-in sigmoidal or step-wise vulnerability curves, and allows you to calibrate your own + impact functions with damage and hazard data through the :doc:`calibration module `. + + + .. image:: /user-guide/img/impact-function.png + :width: 400 + :align: center + +.. dropdown:: Do you want to quantify uncertainties ? + :color: primary + + CLIMADA provides a dedicated module :doc:`unsequa ` for conducting uncertainty and sensitivity analyses. + This module allows you to define a range of input parameters and evaluate their influence on the output, + helping you quantify the sensitivity of the modeling chain as well as the uncertainties in your results. + + .. image:: /user-guide/img/sensitivity.png + :width: 500 + :align: center + +.. dropdown:: Compare adaptation measures and assess their cost-effectiveness + :color: primary + + Is there an adaptation measure that will decrease the impact? Does the cost needed to implement such + measure outweight the gains? All these questions can be asnwered using the :doc:`cost-benefit ` and + :doc:`adaptation module `. + With this module, users can define and compare adaptation measures to establish their cost-effectiveness. + + .. image:: /user-guide/img/cost-benefit.png + :width: 400 + :align: center + +.. toctree:: + :maxdepth: 1 + :hidden: + + Navigate this documentation + Introduction + Installation instructions + Python introduction <0_intro_python> diff --git a/doc/guide/install.rst b/doc/getting-started/install.rst similarity index 76% rename from doc/guide/install.rst rename to doc/getting-started/install.rst index d573b25f0..6af45a15b 100644 --- a/doc/guide/install.rst +++ b/doc/getting-started/install.rst @@ -8,33 +8,66 @@ The following sections will guide you through the installation of CLIMADA and it CLIMADA has a complicated set of dependencies that cannot be installed with ``pip`` alone. Please follow the installation instructions carefully! - We recommend to use `Conda`_ for creating a suitable software environment to execute CLIMADA. + We recommend to use a ``conda``-based python environment manager such as `Mamba`_ or `Conda`_ for creating a suitable software environment to execute CLIMADA. -All following instructions should work on any operating system (OS) that is supported by `Conda`_, including in particular: **Windows**, **macOS**, and **Linux**. +All following instructions should work on any operating system (OS) that is supported by ``conda``, including in particular: **Windows**, **macOS**, and **Linux**. .. hint:: If you need help with the vocabulary used on this page, refer to the :ref:`Glossary `. -------------- -Prerequisites -------------- +.. _install-manager: -* Make sure you are using the **latest version** of your OS. Install any outstanding **updates**. -* Free up at least 10 GB of **free storage space** on your machine. - Conda and the CLIMADA dependencies will require around 5 GB of free space, and you will need at least that much additional space for storing the input and output data of CLIMADA. -* Ensure a **stable internet connection** for the installation procedure. - All dependencies will be downloaded from the internet. - Do **not** use a metered, mobile connection! -* Install the `Conda`_ environment management system. - We highly recommend you use `Miniforge`_, which includes the potent `Mamba`_ package manager. - Download the installer suitable for your system and follow the respective installation instructions. - We do **not** recommend using the ``conda`` command anymore, rather use ``mamba`` (see :ref:`conda-instead-of-mamba`). +--------------------------- +Install environment manager +--------------------------- -.. note:: When mentioning the terms "terminal" or "command line" in the following, we are referring to the "Terminal" apps on macOS or Linux and the "Miniforge Prompt" on Windows. +If you haven't already installed an environment management system like `Mamba`_ or `Conda`_, you have to do so now. +We recommend to use ``mamba`` (see :ref:`conda-instead-of-mamba`) which is available in the installer Miniforge (see below). + +macOS and Linux +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +* Open the "Terminal" app, copy-paste the two commands below, and hit enter: + + .. code-block:: shell + + curl -L -O "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh" + bash Miniforge3-$(uname)-$(uname -m).sh + +* Accept the license terms. +* You can confirm the default location. +* Answer 'yes' when asked if if you wish to update your shell profile to automatically initialize conda. **Do not just hit ENTER but first type 'yes'** +* If at some point you encounter ``command not found: mamba``, open a new terminal window. +* If you encounter ``Run 'mamba init' to be able to run mamba activate/deactivate ...``, please run ``mamba init zsh`` or ``mamba init``. + +Windows +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +* Download the Windows installer at the Install section from `Miniforge`_. +* Execute the installer. This will install Mamba and provide the "Miniforge Prompt" program as a command line replacement. + +.. _python-versions: + +.. admonition:: Python Versions + + CLIMADA is primarily tested against a **supported** Python version, but is allowed to run with others. + If you follow the installation instructions exactly, you will create an environment with the supported version. + Depending on your setup, you are free to choose another allowed version, but we recommend the supported one. + + .. list-table:: + :width: 60% + + * - **Supported Version** + - ``3.11`` + * - Allowed Versions + - ``3.10``, ``3.11``, ``3.12`` .. _install-choice: +--------------------------------------- Decide on Your Entry Level! -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +--------------------------------------- + +.. hint:: When mentioning the terms "terminal" or "command line" in the following, we are referring to the "Terminal" apps on macOS or Linux and the "Miniforge Prompt" on Windows. Depening on your level of expertise, we provide two different approaches: @@ -51,14 +84,14 @@ Notes on the CLIMADA Petals Package CLIMADA is divided into two packages, CLIMADA Core (`climada_python `_) and CLIMADA Petals (`climada_petals `_). The Core contains all the modules necessary for probabilistic impact, averted damage, uncertainty and forecast calculations. -Data for hazard, exposures and impact functions can be obtained from the :doc:`CLIMADA Data API `. +Data for hazard, exposures and impact functions can be obtained from the :doc:`CLIMADA Data API `. Hazard and Exposures subclasses are included as demonstrators only. .. attention:: CLIMADA Petals is **not** a standalone module and requires CLIMADA Core to be installed! CLIMADA Petals contains all the modules for generating data (e.g., ``TC_Surge``, ``WildFire``, ``OpenStreeMap``, ...). New modules are developed and tested here. -Some data created with modules from Petals is available to download from the :doc:`Data API `. +Some data created with modules from Petals is available to download from the :doc:`Data API `. This works with just CLIMADA Core installed. CLIMADA Petals can be used to generate additional data of this type, or to have a look at the tutorials for all data types available from the API. @@ -108,15 +141,15 @@ These instructions will install the most recent stable version of CLIMADA withou .. _install-advanced: ---------------------- -Advanced Instructions ---------------------- +--------------------------------------------- +Advanced Instructions: Installing from source +--------------------------------------------- -For advanced Python users or developers of CLIMADA, we recommed cloning the CLIMADA repository and installing the package from source. +For advanced Python users or developers of CLIMADA, cloning the CLIMADA repository and installing the package from source. .. warning:: - If you followed the :ref:`install-simple` before, make sure you **either** remove the environment with + If you followed the :ref:`install-simple` before, make sure you **either** remove the environment with: .. code-block:: shell @@ -168,18 +201,7 @@ For advanced Python users or developers of CLIMADA, we recommed cloning the CLIM Use the wildcard ``.*`` at the end to allow a downgrade of the bugfix version of Python. This increases compatibility when installing the requirements in the next step. - .. note:: - - CLIMADA can be installed for different Python versions. - If you want to use a different version, replace the version specification in the command above with another allowed version. - - .. list-table:: - :width: 60% - - * - **Supported Version** - - ``3.11`` - * - Allowed Versions - - ``3.10``, ``3.11`` + .. note:: You may choose any of the :ref:`allowed Python versions ` from the list above. #. Use the default environment specs in ``env_climada.yml`` to install all dependencies. Then activate the environment: @@ -201,6 +223,8 @@ For advanced Python users or developers of CLIMADA, we recommed cloning the CLIM The ``-e`` (for "editable") option further instructs ``pip`` to link to the source files instead of copying them during installation. This means that any changes to the source files will have immediate effects in your environment, and re-installing the module is never required. + Further note that this works only for the source files not for the dependencies. If you change the latter, you will need to update the environment with step 6. ! + #. Verify that everything is installed correctly by executing a single test: .. code-block:: shell @@ -211,7 +235,25 @@ For advanced Python users or developers of CLIMADA, we recommed cloning the CLIM If this test passes, great! You are good to go. -.. _install-dev: +.. _change-branch: + +How to switch branch +^^^^^^^^^^^^^^^^^^^^^^ + +Advanced users, or reviewers, may also want to check the feature of a specific branch other than develop. +To do so, **assuming you did install CLIMADA in editable mode (`pip install` with the `-e` flag)**, you just have to: + +``` +git fetch +git checkout +git pull +``` + +This will work most of the time, except if the target branch defines new dependencies that you don't have already in your environment (as they will not get installed this way), in that case you can install these dependencies yourself, or create a new environment with the *new* requirements from the branch. + +If you did not install CLIMADA in editable mode, you can also reinstall CLIMADA from its folder after switching the branch (`pip install [-e] ./`). + +.. _devdeps: Install Developer Dependencies (Optional) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -250,7 +292,7 @@ With the ``climada_env`` activated, execute pre-commit install -Please refer to the :ref:`guide on pre-commit hooks ` for information on how to use this tool. +Please refer to the `guide on pre-commit hooks <../development/Guide_CLIMADA_Development.html#pre-commit-hooks>`_ for information on how to use this tool. For executing the pre-defined test scripts in exactly the same way as they are executed by the automated CI pipeline, you will need ``make`` to be installed. On macOS and on Linux it is pre-installed. On Windows, it can easily be installed with Conda: @@ -259,7 +301,7 @@ On macOS and on Linux it is pre-installed. On Windows, it can easily be installe mamba install -n climada_env make -Instructions for running the test scripts can be found in the :doc:`Testing Guide `. +Instructions for running the test scripts can be found in the `Testing Guide <../development/Guide_Testing.html>`_. Install CLIMADA Petals (Optional) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -293,6 +335,10 @@ To install CLIMADA Petals, we assume you have already installed CLIMADA Core wit python -m pip install -e ./ +--------------------------------------- +Code Editors +--------------------------------------- + JupyterLab ^^^^^^^^^^ @@ -356,7 +402,7 @@ Test Explorer Setup After you set up a workspace, you might want to configure the test explorer for easily running the CLIMADA test suite within VSCode. -.. note:: Please install the additional :ref:`test dependencies ` before proceeding. +.. note:: Please install the additional :ref:`test dependencies ` before proceeding. #. In the left sidebar, select the "Testing" symbol, and click on *Configure Python Tests*. @@ -420,6 +466,56 @@ Therefore, we recommend installing Spyder in a *separate* environment, and then #. Set the Python interpreter used by Spyder to the one of ``climada_env``. Select *Preferences* > *Python Interpreter* > *Use the following interpreter* and paste the iterpreter path you copied from the ``climada_env``. +--------------------------------------- +Apps for working with CLIMADA +--------------------------------------- + +To work with CLIMADA, you will need an application that supports Jupyter Notebooks. +There are plugins available for nearly every code editor or IDE, but if you are unsure about which to choose, we recommend `JupyterLab `_, `Visual Studio Code `_ or `Spyder `_. +It is easy to get confused by all the different softwares and their uses so here is an overview of which tools we use for what: + +.. list-table:: + :header-rows: 1 + :widths: auto + + * - Use + - Tools + - Description + - Useful for + * - Distribution / manage virtual environment & packages + - **Recommended:** + Mamba + **Alternatives:** + Anaconda + - - Install climada, manage & use the climada virtual environment, install packages + - Anaconda includes Anaconda Navigator, which is a desktop GUI and can be used to launch applications like Jupyter Notebook, Spyder, etc. + - Climada Users + & Developers + * - IDE (Integrated Development Environment) + - **Recommended:** + VSCode + **Alternatives:** + Spyder, JupyterLab, PyCharm, & many more + - - Write and run code + - Useful for Developers: + - VSCode also has a GUI to commit changes to Git (similar to GitHub Desktop, but in the same place as your code) + - VSCode test explorer shows results for individual tests & any classes and files containing those tests (folders display a failure or pass icon) + - Climada Users + & Developers + * - Git GUI (Graphical User Interface) + - GitHub Desktop, GitKraken + - - Provides an interface which keeps track of the branch you’re working on, changes you made, etc. + - Allows you to commit changes, push to GitHub, etc. without having to use the command line + - The code itself is not written using these applications but with your IDE of choice (see above) + - Climada Developers + * - Continuous integration (CI) server + - Jenkins + - - Automatically checks code changes in GitHub repositories, e.g., when you create a pull request for the develop branch + - Performs static code analysis using pylint + - You don't need to do any installations yourself; this runs automatically when you push new code to GitHub + - See `Continuous Integration and GitHub Actions <../development/Guide_continuous_integration_GitHub_actions.ipynb>`_ + - Climada Developers + ---- FAQs ---- @@ -536,12 +632,12 @@ the level set to ``WARNING``. If you prefer another logging configuration, e.g., for using Climada embedded in another application, you can opt out of the default pre-configuration by setting the config value for -``logging.climada_style`` to ``false`` in the :doc:`configuration file ` +``logging.climada_style`` to ``false`` in the :doc:`configuration file <../development/Guide_Configuration>` ``climada.conf``. Changing the logging level can be done in multiple ways: -* Adjust the :doc:`configuration file ` ``climada.conf`` by setting a the value of the ``global.log_level`` property. +* Adjust the :doc:`configuration file <../development/Guide_Configuration>` ``climada.conf`` by setting a the value of the ``global.log_level`` property. This only has an effect if the ``logging.climada_style`` is set to ``true`` though. * Set a global logging level in your Python script: @@ -640,6 +736,6 @@ IDE .. _Conda: https://docs.conda.io/en/latest/ -.. _Mamba: https://mamba.readthedocs.io/en/latest/ +.. _Mamba: https://mamba.readthedocs.io/en/latest/installation/mamba-installation.html .. _Miniforge: https://github.com/conda-forge/miniforge .. _CLIMADA Petals: https://climada-petals.readthedocs.io/en/latest/ diff --git a/doc/guide/Guide_get_started.ipynb b/doc/guide/Guide_get_started.ipynb deleted file mode 100644 index 6fa55047b..000000000 --- a/doc/guide/Guide_get_started.ipynb +++ /dev/null @@ -1,135 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "trying-bronze", - "metadata": {}, - "source": [ - "# Getting started with CLIMADA" - ] - }, - { - "cell_type": "markdown", - "id": "multiple-radical", - "metadata": {}, - "source": [ - "This is a short summary of the guides to help you find the information that you need to get started.\n", - "To learn more about CLIMADA, have a look at the [introduction](../guide/Guide_Introduction.ipynb). You can also have a look at the paper [repository](https://github.com/CLIMADA-project/climada_papers) to get an overview of research projects." - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "israeli-street", - "metadata": {}, - "source": [ - "## Installation\n", - "The first step to getting started is installing CLIMADA. To do so you will need:\n", - "1. To get the lastest release from the git repository [CLIMADA releases](https://github.com/climada-project/climada_python/releases) or clone the project with git if you are interested in contributing to the development.\n", - "2. To build a conda environment with the dependencies needed by CLIMADA. \n", - "\n", - "For details see the [Installation Instructions](install.rst).\n", - "\n", - "If you need to run a model on a computational cluster, have a look at [this guide](Guide_Euler.ipynb) to install CLIMADA and run your jobs." - ] - }, - { - "cell_type": "markdown", - "id": "future-distinction", - "metadata": {}, - "source": [ - "## Programming in Python\n", - "It is best to have some basic knowledge of Python programming before starting with CLIMADA. But if you need a quick introduction or reminder, have a look at the short [Python Tutorial](../tutorial/0_intro_python.ipynb). Also have a look at the python [Python Dos and Don't](../guide/Guide_PythonDos-n-Donts.ipynb) guide and at the [Python Performance Guide](../guide/Guide_Py_Performance.ipynb) for best practice tips." - ] - }, - { - "cell_type": "markdown", - "id": "c6ae7939", - "metadata": {}, - "source": [ - "## Apps for working with CLIMADA\n", - "\n", - "To work with CLIMADA, you will need an application that supports Jupyter Notebooks.\n", - "There are plugins available for nearly every code editor or IDE, but if you are unsure about which to choose, we recommend [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/), [Visual Studio Code](https://code.visualstudio.com/) or [Spyder](https://www.spyder-ide.org/).\n", - "It is easy to get confused by all the different softwares and their uses so here is an overview of which tools we use for what:" - ] - }, - { - "cell_type": "markdown", - "id": "25ab3b98", - "metadata": {}, - "source": [ - "| Use | Tools | Description | Useful for |\n", - "|:----------------------------------|:---------------------|:------------|:-----------|\n", - "| Distribution /
manage virtual environment
& packages | Recommended:
Mamba
Alternatives:
Anaconda|
  • Install climada, manage & use the climada virtual environment, install packages
  • Anaconda includes Anaconda navigator, which is a desktop GUI and can be used to launch applications like Jupyter Notebook, Spyder etc.
    • | Climada Users
    & Developers|\n", - "| IDE
    (Integrated Development Environment)|Recommended:
    VSCode
    Alternatives:
    Spyder
    JupyterLab
    PyCharm
    & many more|
  • Write and run code
    • Useful for Developers:
  • VSCode also has a GUI to commit changes to Git (similar to GitHub Desktop, but in the same place as your code)
  • VSCode test explorer shows results for individual tests & any classes and files containing those tests (folders display a failure or pass icon)
    • |Climada Users
    & Developers|\n", - "| Git GUI
    (Graphical User Interface)|GitHub Desktop
    Gitkraken|
  • Provides an interface which keeps track of the branch you’re working on, changes you made etc.
  • Allows you to commit changes, push to GitHub etc. without having to use command line
  • The code itself is not written using these applications but with your IDE of choice(see above)
    • |Climada Developers|\n", - "| Continuous integration
    (CI) server|Jenkins|
  • Automatically checks code changes in GitHub repositories, e.g. when you create a pull request for the develop branch
  • Performs static code analysis using pylint
  • you don't need to do any installations yourself, this runs automatically when you push new code to GitHub
  • see [Continuous Integration and GitHub Actions](../guide/Guide_continuous_integration_GitHub_actions.ipynb)
    • |Climada Developers|" - ] - }, - { - "cell_type": "markdown", - "id": "touched-penetration", - "metadata": {}, - "source": [ - "## Tutorials\n", - "A good way to start using CLIMADA is to have a look at the [Tutorials](https://github.com/CLIMADA-project/climada_python/tree/main/doc/tutorial). The [Main Tutorial](../tutorial/1_main_climada.ipynb) will introduce you the structure of CLIMADA and how to calculate you first impacts, as well as your first appraisal of adaptation options. You can then look at the specific tutorials for each module (for example if you are interested in a specific hazard, like [Tropical Cyclones](../tutorial/climada_hazard_TropCyclone.ipynb), or in learning to [estimate the value of asset exposure](../tutorial/climada_entity_LitPop.ipynb),...). " - ] - }, - { - "cell_type": "markdown", - "id": "0cc77b19", - "metadata": {}, - "source": [ - "## Documentation\n", - "\n", - "You can find the documentation of CLIMADA on Read the Docs [online](https://climada-python.readthedocs.io/en/stable/index.html#). Note that the documentation has several versions: 'latest', 'stable' and explicit version numbers, such as 'v3.1.1', in the url path. 'latest' is created from the 'develop' branch and has the latest changes of the developers, 'stable' from the latest release. For more details about documentation versions, please have a look at [here](https://readthedocs.org/projects/climada-python/versions/)." - ] - }, - { - "cell_type": "markdown", - "id": "growing-religious", - "metadata": {}, - "source": [ - "## Contributing\n", - "If you would like to participate in the development of CLIMADA, carefully read the [Git and Development Guide](../guide/Guide_Git_Development.ipynb). Before making a new feature, discuss with one of the repository admins (Now Chahan, Emmanuel and David). Every new feature or enhancement should be done on a separate branch, which will be merged in the develop branch after being reviewed (see [Checklist](../guide/Guide_Review.ipynb)). Finally, the develop branch is merged in the main branch in each CLIMADA release. Each new feature should come with a tutorial and with [Unit and Integration Tests](../guide/Guide_Testing.ipynb). " - ] - }, - { - "cell_type": "markdown", - "id": "connected-anthony", - "metadata": {}, - "source": [ - "## Other Questions\n", - "\n", - "If you cannot find you answer in the other guides provided here, you can open an [issue](https://github.com/CLIMADA-project/climada_python/issues) for somebody to help you." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "climada_env", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.15 | packaged by conda-forge | (default, Nov 22 2022, 08:49:06) \n[Clang 14.0.6 ]" - }, - "vscode": { - "interpreter": { - "hash": "fe76ddefd4ac3b756bca82b2809865e7c67c346a46477cb9eec4ead581742ab6" - } - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/doc/index.rst b/doc/index.rst index f2434e97d..b3600deda 100644 --- a/doc/index.rst +++ b/doc/index.rst @@ -1,27 +1,112 @@ +:html_theme.sidebar_secondary.remove: true + =================== Welcome to CLIMADA! =================== -.. image:: guide/img/CLIMADA_logo_QR.png - :align: center - :alt: CLIMADA Logo +.. card:: CLIMADA (CLIMate ADAptation) + :text-align: center + :width: 75% + :margin: 2 2 auto auto + + CLIMADA is a free and open-source software framework for climate risk assessment and + adaptation option appraisal. + Designed by a large scientific community, it + helps researchers, policymakers, and businesses analyse the impacts of + natural hazards and explore adaptation strategies. + + +CLIMADA is primarily developed and maintained by the `Weather and Climate Risks +Group `_ at `ETH Zürich `_. + +If you use CLIMADA for your own scientific work, please reference the +appropriate publications according to the :doc:`misc/citation`. + +This is the documentation of the CLIMADA core module which contains all +functionalities necessary for performing climate risk analysis and appraisal of +adaptation options. Modules for generating different types of hazards and other +specialized applications can be found in the `CLIMADA Petals +`_ module. + +**Useful links:** `WCR Group `_ | `CLIMADA Petals `_ | `CLIMADA website `_ | `Mailing list `_ + +.. grid:: 1 2 2 2 + :margin: 5 + :gutter: 0 2 3 4 + :padding: 0 0 2 2 + :class-container: sd-text-center + + .. grid-item-card:: Getting Started + :shadow: md + :width: 75% + + Getting started with CLIMADA: How to install? + What are the basic concepts and functionalities? + + +++ + + .. button-ref:: getting-started/index + :ref-type: doc + :click-parent: + :color: secondary + :expand: + -CLIMADA stands for CLIMate ADAptation and is a probabilistic natural catastrophe impact model, that also calculates averted damage (benefit) thanks to adaptation measures of any kind (from grey to green infrastructure, behavioural, etc.). + .. grid-item-card:: User Guide + :shadow: md + :width: 75% -CLIMADA is primarily developed and maintained by the `Weather and Climate Risks Group `_ at `ETH Zürich `_. + Want to go more in depth? Check out the User guide. It contains detailed + tutorials on the different concepts, modules and possible usage of CLIMADA. -If you use CLIMADA for your own scientific work, please reference the appropriate publications according to the :doc:`misc/citation`. + +++ -This is the documentation of the CLIMADA core module which contains all functionalities necessary for performing climate risk analysis and appraisal of adaptation options. Modules for generating different types of hazards and other specialized applications can be found in the `CLIMADA Petals `_ module. + .. button-ref:: user-guide/index + :ref-type: doc + :click-parent: + :color: secondary + :expand: -Jump right in: + To the user guide! -* :doc:`README ` -* :doc:`Getting Started ` -* :doc:`Installation ` -* :doc:`Overview ` -* `GitHub Repository `_ -* :doc:`Module Reference ` + + + .. grid-item-card:: Implementation API reference + :shadow: md + :width: 75% + + The reference guide contains a detailed description of + the CLIMADA API. The API reference describes each module, class, + methods and functions. + + +++ + + .. button-ref:: api/index + :ref-type: doc + :click-parent: + :color: secondary + :expand: + + To the reference guide! + + .. grid-item-card:: Developer guide + :shadow: md + :width: 75% + + Saw a typo in the documentation? Want to improve + existing functionalities? Want to extend them? + The contributing guidelines will guide you through + the process of improving CLIMADA. + + +++ + + .. button-ref:: development/index + :ref-type: doc + :click-parent: + :color: secondary + :expand: + + To the development guide! .. ifconfig:: readthedocs @@ -31,6 +116,8 @@ Jump right in: Use the drop-down menu on the bottom left to switch versions. ``stable`` refers to the most recent release, whereas ``latest`` refers to the latest development version. +**Date**: |today| **Version**: |version| + .. admonition:: Copyright Notice Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in :doc:`AUTHORS.md `. @@ -47,74 +134,12 @@ Jump right in: with CLIMADA. If not, see https://www.gnu.org/licenses/. -.. toctree:: - :hidden: - - GitHub Repositories - CLIMADA Petals - Weather and Climate Risks Group - - .. toctree:: :maxdepth: 1 - :caption: User Guide - :hidden: - - guide/Guide_Introduction - Getting Started - guide/install - Running CLIMADA on Euler - - -.. toctree:: - :caption: API Reference - :hidden: - - Python Modules - - -.. toctree:: - :maxdepth: 2 - :caption: Tutorials - :hidden: - - Overview - Python Introduction - Hazard - Exposures - Impact - Uncertainty Quantification - tutorial/climada_engine_Forecast - tutorial/climada_util_calibrate - Google Earth Engine - tutorial/climada_util_api_client - Local exceedance frequency and return period - - -.. toctree:: - :maxdepth: 1 - :caption: Developer Guide - :hidden: - - Development with Git - guide/Guide_CLIMADA_Tutorial - guide/Guide_Configuration - guide/Guide_Testing - guide/Guide_continuous_integration_GitHub_actions - guide/Guide_Review - guide/Guide_PythonDos-n-Donts - guide/Guide_Exception_Logging - Performance and Best Practices - CLIMADA Coding Conventions - Building the Documentation - - -.. toctree:: - :caption: Miscellaneous :hidden: - README + Getting started + User Guide + Developer Guide + API Reference Changelog - List of Authors - Contribution Guide - misc/citation diff --git a/doc/misc/CONTRIBUTING.rst b/doc/misc/CONTRIBUTING.rst deleted file mode 100644 index c8174bf1b..000000000 --- a/doc/misc/CONTRIBUTING.rst +++ /dev/null @@ -1,5 +0,0 @@ -CLIMADA Contribution Guide -========================== - -.. mdinclude:: ../../CONTRIBUTING.md - :start-line: 1 diff --git a/doc/misc/README.rst b/doc/misc/README.rst deleted file mode 100644 index 543ca2cfc..000000000 --- a/doc/misc/README.rst +++ /dev/null @@ -1,5 +0,0 @@ -CLIMADA -======= - -.. mdinclude:: ../../README.md - :start-line: 5 diff --git a/doc/misc/citation.rst b/doc/misc/citation.rst index 91570dbe4..9f4610db7 100644 --- a/doc/misc/citation.rst +++ b/doc/misc/citation.rst @@ -19,19 +19,19 @@ If you use specific tools and modules of CLIMADA, please cite the appropriate pu - Publication to cite * - *Any* - The `Zenodo archive `_ of the CLIMADA version you are using - * - :doc:`Impact calculations ` + * - :doc:`Impact calculations ` - Aznar-Siguan, G. and Bresch, D. N. (2019): CLIMADA v1: A global weather and climate risk assessment platform, Geosci. Model Dev., 12, 3085–3097, https://doi.org/10.5194/gmd-14-351-2021 - * - :doc:`Cost-benefit analysis ` + * - :doc:`Cost-benefit analysis ` - Bresch, D. N. and Aznar-Siguan, G. (2021): CLIMADA v1.4.1: Towards a globally consistent adaptation options appraisal tool, Geosci. Model Dev., 14, 351–363, https://doi.org/10.5194/gmd-14-351-2021 - * - :doc:`Uncertainty and sensitivity analysis ` + * - :doc:`Uncertainty and sensitivity analysis ` - Kropf, C. M. et al. (2022): Uncertainty and sensitivity analysis for probabilistic weather and climate-risk modelling: an implementation in CLIMADA v.3.1.0. Geosci. Model Dev. 15, 7177–7201, https://doi.org/10.5194/gmd-15-7177-2022 - * - :doc:`Lines and polygons exposures ` *or* `Open Street Map exposures `_ + * - :doc:`Lines and polygons exposures ` *or* `Open Street Map exposures `_ - Mühlhofer, E., et al. (2024): OpenStreetMap for Multi-Faceted Climate Risk Assessments : Environ. Res. Commun. 6 015005, https://doi.org/10.1088/2515-7620/ad15ab - * - :doc:`LitPop exposures ` + * - :doc:`LitPop exposures ` - Eberenz, S., et al. (2020): Asset exposure data for global physical risk assessment. Earth System Science Data 12, 817–833, https://doi.org/10.3929/ethz-b-000409595 - * - :doc:`Impact function calibration ` + * - :doc:`Impact function calibration ` - Riedel, L., et al. (2024): A Module for Calibrating Impact Functions in the Climate Risk Modeling Platform CLIMADA. Journal of Open Source Software, 9(99), 6755, https://doi.org/10.21105/joss.06755 - * - `GloFAS River Flood Module `_ + * - `GloFAS River Flood Module `_ - Riedel, L. et al. (2024): Fluvial flood inundation and socio-economic impact model based on open data, Geosci. Model Dev., 17, 5291–5308, https://doi.org/10.5194/gmd-17-5291-2024 Please find the code to reprocduce selected CLIMADA-related scientific publications in our `repository of scientific publications `_. diff --git a/doc/tutorial/impact.rst b/doc/tutorial/impact.rst deleted file mode 100644 index 259cb0c9b..000000000 --- a/doc/tutorial/impact.rst +++ /dev/null @@ -1,14 +0,0 @@ -================ -Impact Tutorials -================ - -.. toctree:: - :maxdepth: 1 - - Impact Calculation - climada_entity_ImpactFuncSet - climada_entity_MeasureSet - Discount Rates - climada_engine_impact_data - Cost Benefit Calculation - Probabilistic Yearly Impacts diff --git a/doc/user-guide/0_10min_climada.ipynb b/doc/user-guide/0_10min_climada.ipynb new file mode 100644 index 000000000..1e575c19e --- /dev/null +++ b/doc/user-guide/0_10min_climada.ipynb @@ -0,0 +1,452 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 10 minutes CLIMADA\n", + "\n", + "This is a brief introduction to CLIMADA that showcases CLIMADA's key building block, the impact calculation. For more details and features of the impact calculation, please check out the more detailed [CLIMADA Overview](../user-guide/1_main_climada.ipynb).\n", + "\n", + "## Key ingredients in a CLIMADA impact calculation\n", + "\n", + "For CLIMADA's impact calculation, we have to specify the following ingredients:\n", + "- **Hazard**: The hazard object entails event-based and spatially-resolved information of the intensity of a natural hazard. It contains a probabilistic event set, meaning that is a set of several events, each of which is associated to a frequency corresponding to the estimated probability of the occurence of the event.\n", + "- **Exposure**: The exposure information provides the location and the number and/or value of objects (e.g., humans, buildings, ecosystems) that are exposed to the hazard.\n", + "- **Vulnerability**: The impact or vunerability function models the average impact that is expected for a given exposure value and given hazard intensity.\n", + "\n", + "## Exemplary impact calculation\n", + "\n", + "We exemplify the impact calculation and its key ingredients with an analysis of the risk of tropical cyclones on several assets in Florida.\n", + "\n", + "\n", + "### Hazard objects\n", + "\n", + "First, we read a demo hazard file that includes information about several tropical cyclone events. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from climada.hazard import Hazard\n", + "from climada.util import HAZ_DEMO_H5\n", + "\n", + "haz = Hazard.from_hdf5(HAZ_DEMO_H5)\n", + "\n", + "# to hide the warnings\n", + "import warnings\n", + "\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can infer some information from the Hazard object. The central piece of the hazard object is a sparse matrix at `haz.intensity` that contains the hazard intensity values for each event (axis 0) and each location (axis 1). " + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The hazard object contains 216 events. \n", + "The maximal intensity contained in the Hazard object is 72.75 m/s. \n", + "The first event was observed in a time series of 185 years, \n", + "which is why CLIMADA estimates an annual probability of 0.0054 for the occurence of this event.\n" + ] + } + ], + "source": [ + "print(\n", + " f\"The hazard object contains {haz.intensity.shape[0]} events. \\n\"\n", + " f\"The maximal intensity contained in the Hazard object is {haz.intensity.max():.2f} {haz.units}. \\n\"\n", + " f\"The first event was observed in a time series of {int(1/haz.frequency[0])} {haz.frequency_unit[2:]}s, \\n\"\n", + " f\"which is why CLIMADA estimates an annual probability of {haz.frequency[0]:.4f} for the occurence of this event.\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The probabilistic event set and its single events can be plotted. For instance, below we plot maximal intensity per grid point over the whole event set." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
    " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "haz.plot_intensity(0, figsize=(6, 6));" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exposure objects\n", + "Now, we read a demo expopure file containing the location and value of a number of exposed assets in Florida." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-01-21 15:38:13,269 - climada.entity.exposures.base - INFO - Reading /Users/vgebhart/climada/demo/data/exp_demo_today.h5\n" + ] + } + ], + "source": [ + "from climada.entity import Exposures\n", + "from climada.util.constants import EXP_DEMO_H5\n", + "\n", + "exp = Exposures.from_hdf5(EXP_DEMO_H5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can print some basic information about the exposure object. The central information of the exposure object is contained in a geopandas.GeoDataFrame at `exp.gdf`." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "In the exposure object, a total amount of USD 657.05B is distributed among 50 points.\n" + ] + } + ], + "source": [ + "print(\n", + " f\"In the exposure object, a total amount of {exp.value_unit} {exp.gdf.value.sum() / 1_000_000_000:.2f}B\"\n", + " f\" is distributed among {exp.gdf.shape[0]} points.\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can plot the different exposure points on a map." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-01-21 15:39:38,249 - climada.entity.exposures.base - INFO - Setting latitude and longitude attributes.\n", + "2025-01-21 15:39:38,498 - climada.entity.exposures.base - INFO - Setting latitude and longitude attributes.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
    " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "exp.plot_basemap(figsize=(6, 6));" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Impact Functions\n", + "\n", + "To model the impact to the exposure that is caused by the hazard, CLIMADA makes use of an impact function. This function relates both percentage of assets affected (PAA, red line below) and the mean damage degree (MDD, blue line below), to the hazard intensity. The multiplication of PAA and MDD result in the mean damage ratio (MDR, black dashed line below), that relates the hazard intensity to corresponding relative impact values. Finally, a multiplication with the exposure values results in the total impact.\n", + "\n", + "Below, we read and plot a standard impact function for tropical cyclones." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
    " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from climada.entity import ImpactFuncSet, ImpfTropCyclone\n", + "\n", + "impf_tc = ImpfTropCyclone.from_emanuel_usa()\n", + "impf_set = ImpactFuncSet([impf_tc])\n", + "impf_set.plot();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Impact calculation \n", + "\n", + "Having defined hazard, exposure, and impact function, we can finally perform the impact calcuation. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-01-21 15:43:22,682 - climada.entity.exposures.base - INFO - Matching 50 exposures with 2500 centroids.\n", + "2025-01-21 15:43:22,683 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-01-21 15:43:22,686 - climada.engine.impact_calc - INFO - Calculating impact for 250 assets (>0) and 216 events.\n", + "2025-01-21 15:43:22,687 - climada.engine.impact_calc - INFO - cover and/or deductible columns detected, going to calculate insured impact\n" + ] + } + ], + "source": [ + "from climada.engine import ImpactCalc\n", + "\n", + "imp = ImpactCalc(exp, impf_set, haz).impact(save_mat=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Impact object contains the results of the impact calculation (including event- and location-wise impact information when `save_mat=True`)." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The total expected annual impact over all exposure points is USD 288.90 M. \n", + "The largest estimated single-event impact is USD 20.96 B. \n", + "The largest expected annual impact for a single location is USD 9.58 M. \n", + "\n" + ] + } + ], + "source": [ + "print(\n", + " f\"The total expected annual impact over all exposure points is {imp.unit} {imp.aai_agg / 1_000_000:.2f} M. \\n\"\n", + " f\"The largest estimated single-event impact is {imp.unit} {max(imp.at_event) / 1_000_000_000:.2f} B. \\n\"\n", + " f\"The largest expected annual impact for a single location is {imp.unit} {max(imp.eai_exp) / 1_000_000:.2f} M. \\n\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Several visualizations of impact objects are available. For instance, we can plot the expected annual impact per location on a map." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-01-21 15:44:16,514 - climada.util.coordinates - INFO - Setting geometry points.\n", + "2025-01-21 15:44:16,518 - climada.entity.exposures.base - INFO - Setting latitude and longitude attributes.\n", + "2025-01-21 15:44:16,771 - climada.entity.exposures.base - INFO - Setting latitude and longitude attributes.\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
    " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "imp.plot_basemap_eai_exposure(figsize=(6, 6))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Further CLIMADA features\n", + "\n", + "CLIMADA offers several additional features and modules that complement its basic impact and risk calculation, among which are\n", + "- uncertainty and sensitivity analysis\n", + "- adaptation option appraisal and cost benefit analysis\n", + "- several tools for providing hazard objects such as tropical cyclones, floods, or winter storms; and exposure objects such as Litpop, or open street maps\n", + "- impact function calibration methods\n", + "\n", + "We end this introduction with a simple adaptation measure analysis. \n", + "\n", + "### Adaptation measure analysis\n", + "\n", + "Consider a simple adaptation measure that results in a 10% decrease in the percentage of affected assets (PAA) decreases and a 20% decrease in the mean damage degree (MDD). We apply this measure and recompute the impact." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-01-21 15:49:48,642 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-01-21 15:49:48,643 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-01-21 15:49:48,643 - climada.entity.exposures.base - INFO - Matching 50 exposures with 2500 centroids.\n", + "2025-01-21 15:49:48,645 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-01-21 15:49:48,648 - climada.engine.impact_calc - INFO - Calculating impact for 250 assets (>0) and 216 events.\n", + "2025-01-21 15:49:48,648 - climada.engine.impact_calc - INFO - cover and/or deductible columns detected, going to calculate insured impact\n" + ] + } + ], + "source": [ + "from climada.entity.measures import Measure\n", + "\n", + "meas = Measure(haz_type=\"TC\", paa_impact=(0.9, 0), mdd_impact=(0.8, 0))\n", + "\n", + "new_exp, new_impfs, new_haz = meas.apply(exp, impf_set, haz)\n", + "new_imp = ImpactCalc(new_exp, new_impfs, new_haz).impact()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To analyze the effect of the adaptation measure, we can, for instance, plot the impact exceedance frequency curves that describe, according to the given data, how frequent different impacts thresholds are expected to be exceeded." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
    " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = imp.calc_freq_curve().plot(label=\"Without measure\")\n", + "new_imp.calc_freq_curve().plot(axis=ax, label=\"With measure\")\n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "hide_input": false, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.6" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/doc/tutorial/1_main_climada.ipynb b/doc/user-guide/1_main_climada.ipynb similarity index 99% rename from doc/tutorial/1_main_climada.ipynb rename to doc/user-guide/1_main_climada.ipynb index 7a9b45ab8..ee18d9e06 100644 --- a/doc/tutorial/1_main_climada.ipynb +++ b/doc/user-guide/1_main_climada.ipynb @@ -22,7 +22,7 @@ "\n", "The model core is designed to give as much flexibility as possible when describing the elements of risk, meaning that CLIMADA isn't limited to particular hazards, exposure types or impacts. We love to see the model applied to new problems and contexts.\n", "\n", - "CLIMADA provides classes, methods and data for exposure, hazard and impact functions (also called vulnerability functions), plus a financial model and a framework to analyse adaptation measures. Additional classes and data for common uses, such as economic exposures or tropical storms and tutorials for every class are available: see the [CLIMADA features](#CLIMADA-features) section below.\n", + "CLIMADA provides classes, methods and data for exposure, hazard and impact functions (also called vulnerability functions), plus a financial model and a framework to analyse adaptation measures. Additional classes and data for common uses, such as economic exposures or tropical storms and tutorials for every class are available: see the [CLIMADA features](#climada-features) section below.\n", "\n", "\n", "### This tutorial\n", @@ -31,9 +31,9 @@ "\n", "### Resources beyond this tutorial\n", "\n", - "- [Installation guide](../guide/install.rst) - go here if you've not installed the model yet\n", + "- [Installation guide](../getting-started/install.rst) - go here if you've not installed the model yet\n", "- [CLIMADA Read the Docs home page](https://climada-python.readthedocs.io) - for all other documentation\n", - "- [List of CLIMADA's features and associated tutorials](#CLIMADA-features)\n", + "- [List of CLIMADA's features and associated tutorials](#climada-features)\n", "- [CLIMADA GitHub develop branch documentation](https://github.com/CLIMADA-project/climada_python/tree/develop/doc) for the very latest versions of code and documentation\n", "- [CLIMADA paper GitHub repository](https://github.com/CLIMADA-project/climada_papers) - for publications using CLIMADA\n" ] @@ -57,7 +57,7 @@ "CLIMADA's `Impact` object is used to analyse events and event sets, whether this is the impact of a single wildfire, or the global economic risk from tropical cyclones in 2100.\n", "\n", "CLIMADA is divided into two parts (two repositories): \n", - "1. the core [climada_python](https://github.com/CLIMADA-project/climada_python) contains all the modules necessary for the probabilistic impact, the averted damage, uncertainty and forecast calculations. Data for hazard, exposures and impact functions can be obtained from the [data API](https://github.com/CLIMADA-project/climada_python/blob/main/doc/tutorial/climada_util_api_client.ipynb). [Litpop](https://github.com/CLIMADA-project/climada_python/blob/main/doc/tutorial/climada_entity_LitPop.ipynb) is included as demo Exposures module, and [Tropical cyclones](https://github.com/CLIMADA-project/climada_python/blob/main/doc/tutorial/climada_hazard_TropCyclone.ipynb) is included as a demo Hazard module. \n", + "1. the core [climada_python](https://github.com/CLIMADA-project/climada_python) contains all the modules necessary for the probabilistic impact, the averted damage, uncertainty and forecast calculations. Data for hazard, exposures and impact functions can be obtained from the [data API](/user-guide/climada_util_api_client.ipynb). [Litpop](/user-guide/climada_entity_LitPop.ipynb) is included as demo Exposures module, and [Tropical cyclones](/user-guide/climada_hazard_TropCyclone.ipynb) is included as a demo Hazard module. \n", "2. the petals [climada_petals](https://github.com/CLIMADA-project/climada_petals) contains all the modules for generating data (e.g., TC_Surge, WildFire, OpenStreeMap, ...). Most development is done here. The petals builds-upon the core and does not work as a stand-alone.\n", "\n", "### CLIMADA classes\n", @@ -65,32 +65,32 @@ "This is a full directory of tutorials for CLIMADA's classes to use as a reference. You don't need to read all this to do this tutorial, but it may be useful to refer back to.\n", "\n", "Core (climada_python):\n", - "- [**Hazard**](../tutorial/climada_hazard_Hazard.ipynb): a class that stores sets of geographic hazard footprints, (e.g. for wind speed, water depth and fraction, drought index), and metadata including event frequency. Several predefined extensions to create particular hazards from particular datasets and models are included with CLIMADA:\n", - " - [Tropical cyclone wind](../tutorial/climada_hazard_TropCyclone.ipynb): global hazard sets for tropical cyclone events, constructing statistical wind fields from storm tracks. Subclasses include methods and data to calculate historical wind footprints, create forecast enembles from ECMWF tracks, and create climatological event sets for different climate scenarios.\n", - " - [European windstorms](../tutorial/climada_hazard_StormEurope.ipynb): includes methods to read and plot footprints from the Copernicus WISC dataset and for DWD and ICON forecasts. \n", + "- [**Hazard**](../user-guide/climada_hazard_Hazard.ipynb): a class that stores sets of geographic hazard footprints, (e.g. for wind speed, water depth and fraction, drought index), and metadata including event frequency. Several predefined extensions to create particular hazards from particular datasets and models are included with CLIMADA:\n", + " - [Tropical cyclone wind](../user-guide/climada_hazard_TropCyclone.ipynb): global hazard sets for tropical cyclone events, constructing statistical wind fields from storm tracks. Subclasses include methods and data to calculate historical wind footprints, create forecast enembles from ECMWF tracks, and create climatological event sets for different climate scenarios.\n", + " - [European windstorms](../user-guide/climada_hazard_StormEurope.ipynb): includes methods to read and plot footprints from the Copernicus WISC dataset and for DWD and ICON forecasts. \n", "\n", "- [**Entity**](#Entity): this is a container that groups CLIMADA's socio-economic models. It's is where the Exposures and Impact Functions are stored, which can then be combined with a hazard for a risk analysis (using the Engine's Impact class). It is also where Discount Rates and Measure Sets are stored, which are used in adaptation cost-benefit analyses (using the Engine's CostBenefit class):\n", - " - [Exposures](../tutorial/climada_entity_Exposures.ipynb): geolocated exposures. Each exposure is associated with a value (which can be a dollar value, population, crop yield, etc), information to associate it with impact functions for the relevant hazard(s) (in the Entity's ImpactFuncSet), a geometry, and other optional properties such as deductables and cover. Exposures can be loaded from a file, specified by the user, or created from regional economic models accessible within CLIMADA, for example: \n", - " - [LitPop](../tutorial/climada_entity_LitPop.ipynb): regional economic model using nightlight and population maps together with several economic indicators \n", - " - [Polygons_lines](../tutorial/climada_entity_Exposures_polygons_lines.ipynb): use CLIMADA Impf you have your exposure in the form of shapes/polygons or in the form of lines.\n", - " - [ImpactFuncSet](../tutorial/climada_entity_ImpactFuncSet.ipynb): functions to describe the impacts that hazards have on exposures, expressed in terms of e.g. the % dollar value of a building lost as a function of water depth, or the mortality rate for over-70s as a function of temperature. CLIMADA provides some common impact functions, or they can be user-specified. The following is an incomplete list:\n", + " - [Exposures](../user-guide/climada_entity_Exposures.ipynb): geolocated exposures. Each exposure is associated with a value (which can be a dollar value, population, crop yield, etc), information to associate it with impact functions for the relevant hazard(s) (in the Entity's ImpactFuncSet), a geometry, and other optional properties such as deductables and cover. Exposures can be loaded from a file, specified by the user, or created from regional economic models accessible within CLIMADA, for example: \n", + " - [LitPop](../user-guide/climada_entity_LitPop.ipynb): regional economic model using nightlight and population maps together with several economic indicators \n", + " - [Polygons_lines](../user-guide/climada_entity_Exposures_polygons_lines.ipynb): use CLIMADA Impf you have your exposure in the form of shapes/polygons or in the form of lines.\n", + " - [ImpactFuncSet](../user-guide/climada_entity_ImpactFuncSet.ipynb): functions to describe the impacts that hazards have on exposures, expressed in terms of e.g. the % dollar value of a building lost as a function of water depth, or the mortality rate for over-70s as a function of temperature. CLIMADA provides some common impact functions, or they can be user-specified. The following is an incomplete list:\n", " - ImpactFunc: a basic adjustable impact function, specified by the user\n", " - IFTropCyclone: impact functions for tropical cyclone winds\n", " - IFRiverFlood: impact functions for river floods\n", " - IFStormEurope: impact functions for European windstorms \n", - " - [DiscRates](../tutorial/climada_entity_DiscRates.ipynb): discount rates per year\n", - " - [MeasureSet](../tutorial/climada_entity_MeasureSet.ipynb): a collection of Measure objects that together describe any adaptation measures being modelled. Adaptation measures are described by their cost, and how they modify exposure, hazard, and impact functions (and have have a method to do these things). Measures also include risk transfer options.\n", + " - [DiscRates](../user-guide/climada_entity_DiscRates.ipynb): discount rates per year\n", + " - [MeasureSet](../user-guide/climada_entity_MeasureSet.ipynb): a collection of Measure objects that together describe any adaptation measures being modelled. Adaptation measures are described by their cost, and how they modify exposure, hazard, and impact functions (and have have a method to do these things). Measures also include risk transfer options.\n", " \n", - "- [**Engine**](../tutorial/climada_engine_Impact.ipynb): the CLIMADA Engine contains the Impact and CostBenefit classes, which are where the main model calculations are done, combining Hazard and Entity objects.\n", - " - [Impact](../tutorial/climada_engine_Impact.ipynb): a class that stores CLIMADA's modelled impacts and the methods to calculate them from Exposure, Impact Function and Hazard classes. The calculations include average annual impact, expected annual impact by exposure item, total impact by event, and (optionally) the impact of each event on each exposure point. Includes statistical and plotting routines for common analysis products.\n", - " - [Impact_data](../tutorial/climada_engine_impact_data.ipynb): The core functionality of the module is to read disaster impact data as downloaded from the International Disaster Database EM-DAT (www.emdat.be) and produce a CLIMADA Impact()-instance from it. The purpose is to make impact data easily available for comparison with simulated impact inside CLIMADA, e.g. for calibration purposes.\n", - " - [CostBenefit](#Adaptation-options-appraisal): a class to appraise adaptation options. It uses an Entity's MeasureSet to calculate new Impacts based on their adjustments to hazard, exposure, and impact functions, and returns statistics and plotting routines to express cost-benefit comparisons.\n", - " - [Unsequa](../tutorial/climada_engine_unsequa.ipynb): a module for uncertainty and sensitivity analysis.\n", - " - [Unsequa_helper](../tutorial/climada_engine_unsequa_helper.ipynb): The InputVar class provides a few helper methods to generate generic uncertainty input variables for exposures, impact function sets, hazards, and entities (including measures cost and disc rates). This tutorial complements the general tutorial on the uncertainty and sensitivity analysis module unsequa.\n", - " - [Forecast](../tutorial/climada_engine_Forecast.ipynb): This class deals with weather forecasts and uses CLIMADA ImpactCalc.impact() to forecast impacts of weather events on society. It mainly does one thing: It contains all plotting and other functionality that are specific for weather forecasts, impact forecasts and warnings.\n", + "- [**Engine**](../user-guide/climada_engine_Impact.ipynb): the CLIMADA Engine contains the Impact and CostBenefit classes, which are where the main model calculations are done, combining Hazard and Entity objects.\n", + " - [Impact](../user-guide/climada_engine_Impact.ipynb): a class that stores CLIMADA's modelled impacts and the methods to calculate them from Exposure, Impact Function and Hazard classes. The calculations include average annual impact, expected annual impact by exposure item, total impact by event, and (optionally) the impact of each event on each exposure point. Includes statistical and plotting routines for common analysis products.\n", + " - [Impact_data](../user-guide/climada_engine_impact_data.ipynb): The core functionality of the module is to read disaster impact data as downloaded from the International Disaster Database EM-DAT (www.emdat.be) and produce a CLIMADA Impact()-instance from it. The purpose is to make impact data easily available for comparison with simulated impact inside CLIMADA, e.g. for calibration purposes.\n", + " - [CostBenefit](../user-guide/climada_engine_CostBenefit.ipynb): a class to appraise adaptation options. It uses an Entity's MeasureSet to calculate new Impacts based on their adjustments to hazard, exposure, and impact functions, and returns statistics and plotting routines to express cost-benefit comparisons.\n", + " - [Unsequa](../user-guide/climada_engine_unsequa.ipynb): a module for uncertainty and sensitivity analysis.\n", + " - [Unsequa_helper](../user-guide/climada_engine_unsequa_helper.ipynb): The InputVar class provides a few helper methods to generate generic uncertainty input variables for exposures, impact function sets, hazards, and entities (including measures cost and disc rates). This tutorial complements the general tutorial on the uncertainty and sensitivity analysis module unsequa.\n", + " - [Forecast](../user-guide/climada_engine_Forecast.ipynb): This class deals with weather forecasts and uses CLIMADA ImpactCalc.impact() to forecast impacts of weather events on society. It mainly does one thing: It contains all plotting and other functionality that are specific for weather forecasts, impact forecasts and warnings.\n", "\n", "climada_petals:\n", - "- [**Hazard**](../tutorial/climada_hazard_Hazard.ipynb):\n", + "- [**Hazard**](../user-guide/climada_hazard_Hazard.ipynb):\n", " - [Storm surge](https://climada-petals.readthedocs.io/en/stable/tutorial/climada_hazard_TCSurgeBathtub.html): Tropical cyclone surge from linear wind-surge relationship and a bathtub model.\n", " - [River flooding](https://climada-petals.readthedocs.io/en/stable/tutorial/climada_hazard_RiverFlood.html): global water depth hazard for flood, including methods to work with ISIMIP simulations.\n", " - [Crop modelling](https://climada-petals.readthedocs.io/en/stable/tutorial/climada_hazard_entity_Crop.html): combines ISIMIP crop simulations and UN Food and Agrigultre Organization data. The module uses crop production as exposure, with hydrometeorological 'hazard' increasing or decreasing production.\n", @@ -101,12 +101,12 @@ " - Drought (global): tutorial under development\n", "\n", "- [**Entity**](#Entity): \n", - " - [Exposures](../tutorial/climada_entity_Exposures.ipynb):\n", - " - [BlackMarble](https://climada-petals.readthedocs.io/en/stable/tutorial/climada_entity_BlackMarble.html): regional economic model from nightlight intensities and economic indicators (GDP, income group). Largely succeeded by LitPop.\n", - " - [OpenStreetMap](https://climada-petals.readthedocs.io/en/stable/tutorial/climada_exposures_openstreetmap.html): CLIMADA provides some ways to make use of the entire OpenStreetMap data world and to use those data within the risk modelling chain of CLIMADA as exposures.\n", + " - [Exposures](../user-guide/climada_entity_Exposures.ipynb):\n", + " - [BlackMarble](https://climada-petals.readthedocs.io/en/stable/user-guide/climada_entity_BlackMarble.html): regional economic model from nightlight intensities and economic indicators (GDP, income group). Largely succeeded by LitPop.\n", + " - [OpenStreetMap](https://climada-petals.readthedocs.io/en/stable/user-guide/climada_exposures_openstreetmap.html): CLIMADA provides some ways to make use of the entire OpenStreetMap data world and to use those data within the risk modelling chain of CLIMADA as exposures.\n", "\n", - "- [**Engine**](../tutorial/climada_engine_Impact.ipynb):\n", - " - [SupplyChain](https://climada-petals.readthedocs.io/en/stable/tutorial/climada_engine_SupplyChain.html): This class allows assessing indirect impacts via Input-Ouput modeling.\n", + "- [**Engine**](../user-guide/climada_engine_Impact.ipynb):\n", + " - [SupplyChain](https://climada-petals.readthedocs.io/en/stable/user-guide/climada_engine_SupplyChain.html): This class allows assessing indirect impacts via Input-Ouput modeling.\n", "\n", "This list will be updated periodically along with new CLIMADA releases. To see the latest, development version of all tutorials, see the [tutorials page on the CLIMADA GitHub](https://github.com/CLIMADA-project/climada_python/tree/develop/doc/tutorial)." ] @@ -128,16 +128,16 @@ "\n", "Hazards are characterized by their frequency of occurrence and the geographical distribution of their intensity. The `Hazard` class collects events of the same hazard type (e.g. tropical cyclone, flood, drought, ...) with intensity values over the same geographic centroids. They might be historical events or synthetic.\n", "\n", - "See the [Hazard tutorial](climada_hazard_Hazard.ipynb) to learn about the Hazard class in more detail, and the [CLIMADA features](#CLIMADA-features) section of this document to explore tutorials for different hazards, including\n", - "[tropical cyclones](climada_hazard_TropCyclone.ipynb), as used here.\n", + "See the [Hazard tutorial](climada_hazard_Hazard.ipynb) to learn about the Hazard class in more detail, and the [CLIMADA features](#climada-features) section of this document to explore tutorials for different hazards, including\n", + "[tropical cyclones](../user-guide/climada_hazard_TropCyclone.ipynb), as used here.\n", "\n", - "Tropical cyclones in CLIMADA and the `TropCyclone` class work like any hazard, storing each event's wind speeds at the geographic centroids specified for the class. Pre-calculated hazards can be loaded from files (see the [full Hazard tutorial](climada_hazard_Hazard.ipynb), but they can also be modelled from a storm track using the `TCTracks` class, based on a storm's parameters at each time step. This is how we'll construct the hazards for our example.\n", + "Tropical cyclones in CLIMADA and the `TropCyclone` class work like any hazard, storing each event's wind speeds at the geographic centroids specified for the class. Pre-calculated hazards can be loaded from files (see the [full Hazard tutorial](../user-guide/climada_hazard_Hazard.ipynb), but they can also be modelled from a storm track using the `TCTracks` class, based on a storm's parameters at each time step. This is how we'll construct the hazards for our example.\n", "\n", "So before we create the hazard, we will create our storm tracks and define the geographic centroids for the locations we want to calculate hazard at.\n", "\n", "### Storm tracks\n", "\n", - "Storm tracks are created and stored in a separate class, `TCTracks`. We use its method `from_ibtracs_netcdf` to create the tracks from the [IBTRaCS](https://www.ncdc.noaa.gov/ibtracs/) storm tracks archive. In the next block we will download the full dataset, which might take a little time. However, to plot the whole dataset takes too long (see the second block), so we choose a shorter time range here to show the function. See the [full TropCyclone tutorial](climada_hazard_TropCyclone.ipynb) for more detail and troubleshooting." + "Storm tracks are created and stored in a separate class, `TCTracks`. We use its method `from_ibtracs_netcdf` to create the tracks from the [IBTRaCS](https://www.ncdc.noaa.gov/ibtracs/) storm tracks archive. In the next block we will download the full dataset, which might take a little time. However, to plot the whole dataset takes too long (see the second block), so we choose a shorter time range here to show the function. See the [full TropCyclone tutorial](../user-guide/climada_hazard_TropCyclone.ipynb) for more detail and troubleshooting." ] }, { @@ -257,7 +257,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now, irresponsibly for a risk analysis, we're only going to use these historical events: they're enough to demonstrate CLIMADA in action. A proper risk analysis would expand it to include enough events for a statistically robust climatology. See the [full TropCyclone tutorial](climada_hazard_TropCyclone.ipynb) for CLIMADA's stochastic event generation." + "Now, irresponsibly for a risk analysis, we're only going to use these historical events: they're enough to demonstrate CLIMADA in action. A proper risk analysis would expand it to include enough events for a statistically robust climatology. See the [full TropCyclone tutorial](../user-guide/climada_hazard_TropCyclone.ipynb) for CLIMADA's stochastic event generation." ] }, { @@ -444,9 +444,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "See the [TropCyclone tutorial](climada_hazard_TropCyclone.ipynb) for full details of the TropCyclone hazard class.\n", + "See the [TropCyclone tutorial](../user-guide/climada_hazard_TropCyclone.ipynb) for full details of the TropCyclone hazard class.\n", "\n", - "We can also recalculate event sets to reflect the effects of climate change. The `apply_climate_scenario_knu` method applies changes in intensity and frequency projected due to climate change, as described in 'Global projections of intense tropical cyclone activity for the late twenty-first century from dynamical downscaling of CMIP5/RCP4.5 scenarios' (Knutson _et al._ 2015). See the [tutorial](climada_hazard_TropCyclone.ipynb) for details.\n", + "We can also recalculate event sets to reflect the effects of climate change. The `apply_climate_scenario_knu` method applies changes in intensity and frequency projected due to climate change, as described in 'Global projections of intense tropical cyclone activity for the late twenty-first century from dynamical downscaling of CMIP5/RCP4.5 scenarios' (Knutson _et al._ 2015). See the [tutorial](../user-guide/climada_hazard_TropCyclone.ipynb) for details.\n", "\n", ">**Exercise:** Extend this notebook's analysis to examine the effects of climate change in Puerto Rico. You'll need to extend the historical event set with stochastic tracks to create a robust statistical storm climatology - the `TCTracks` class has the functionality to do this. Then you can apply the `apply_climate_scenario_knu` method to the generated hazard object to create a second hazard climatology representing storm activity under climate change. See how the results change using the different hazard sets.\n", "\n", @@ -474,7 +474,7 @@ "\n", "The `Entity`'s `exposures` attribute contains geolocalized values of anything exposed to the hazard, whether monetary values of assets or number of human lives, for example. It is of type `Exposures`. \n", "\n", - "See the [Exposures tutorial](climada_entity_Exposures.ipynb) for more detail on the structure of the class, and how to create and import exposures. The [LitPop tutorial](climada_entity_LitPop.ipynb) explains how CLIMADA models economic exposures using night-time light and economic data, and is what we'll use here. To combine your exposure with OpenStreetMap's data see the [OSM tutorial](https://github.com/CLIMADA-project/climada_petals/blob/main/doc/tutorial/climada_exposures_openstreetmap.ipynb).\n", + "See the [Exposures tutorial](../user-guide/climada_entity_Exposures.ipynb) for more detail on the structure of the class, and how to create and import exposures. The [LitPop tutorial](../user-guide/climada_entity_LitPop.ipynb) explains how CLIMADA models economic exposures using night-time light and economic data, and is what we'll use here. To combine your exposure with OpenStreetMap's data see the [OSM tutorial](https://github.com/CLIMADA-project/climada_petals/blob/main/doc/tutorial/climada_exposures_openstreetmap.ipynb).\n", "\n", "LitPop is a module that allows CLIMADA to estimate exposed populations and economic assets at any point on the planet without additional information, and in a globally consistent way. Before we try it out with the next code block, we'll need to download a data set and put it into the right folder:\n", "1. Go to the [download page](https://beta.sedac.ciesin.columbia.edu/data/set/gpw-v4-population-count-rev11/data-download) on Socioeconomic Data and Applications Center (sedac).\n", @@ -578,7 +578,7 @@ "\n", "Impact functions are stored as the Entity's `impact_funcs` attribute, in an instance of the `ImpactFuncSet` class which groups one or more `ImpactFunc` objects. They can be specified manually, read from a file, or you can use CLIMADA's pre-defined impact functions. We'll use a pre-defined function for tropical storm wind damage stored in the `IFTropCyclone` class. \n", "\n", - "See the [Impact Functions tutorial](climada_entity_ImpactFuncSet.ipynb) for a full guide to the class, including how data are stored and reading and writing to files.\n", + "See the [Impact Functions tutorial](../user-guide/climada_entity_ImpactFuncSet.ipynb) for a full guide to the class, including how data are stored and reading and writing to files.\n", "\n", "We initialise an Impact Function with the `IFTropCyclone` class, and use its `from_emanuel_usa` method to load the Emanuel (2011) impact function. (The class also contains regional impact functions for the full globe, but we'll won't use these for now.) The class's `plot` method visualises the function, which we can see is expressed just through the Mean Degree of Damage, with all assets affected." ] @@ -679,7 +679,7 @@ "\n", "They are stored as `Measure` objects within a `MeasureSet` container class (similarly to `ImpactFuncSet` containing several `ImpactFunc`s), and are assigned to the `measures` attribute of the Entity.\n", "\n", - "See the [Adaptation Measures tutorial](climada_entity_MeasureSet.ipynb) on how to create, read and write measures. CLIMADA doesn't yet have pre-defined adaptation measures, mostly because they are hard to standardise.\n", + "See the [Adaptation Measures tutorial](../user-guide/climada_entity_MeasureSet.ipynb) on how to create, read and write measures. CLIMADA doesn't yet have pre-defined adaptation measures, mostly because they are hard to standardise.\n", "\n", "The best way to understand an adaptation measure is by an example. Here's a possible measure for the creation of coastal mangroves (ignore the exact numbers, they are just for illustration):" ] @@ -889,7 +889,7 @@ "\n", "The `disc_rates` attribute is of type `DiscRates`. This class contains the discount rates for the following years and computes the net present value for given values.\n", "\n", - "See the [Discount Rates tutorial](climada_entity_DiscRates.ipynb) for more details about creating, reading and writing the `DiscRates` class, and how it is used in calculations.\n", + "See the [Discount Rates tutorial](../user-guide/climada_entity_DiscRates.ipynb) for more details about creating, reading and writing the `DiscRates` class, and how it is used in calculations.\n", "\n", "Here we will implement a simple, flat 2% discount rate." ] @@ -979,7 +979,7 @@ "metadata": {}, "source": [ "Note: the configurable parameter `CONFIG.maz_matrix_size` controls the maximum matrix size contained in a chunk. You can decrease its value if you are having memory issues when using the `Impact`'s `calc` method. A high value will make the computation fast, but increase the memory use.\n", - "(See the [config guide](../guide/Guide_Configuration.ipynb) on how to set configuration values.)\n", + "(See the [config guide](../development/Guide_Configuration.ipynb) on how to set configuration values.)\n", "\n", "CLIMADA calculates impacts by providing exposures, impact functions and hazard to an `Impact` object's `calc` method:" ] @@ -1115,7 +1115,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "`Impact` also has `write_csv()` and `write_excel()` methods to save the impact variables, and `write_sparse_csr()` to save the impact matrix (impact per event and exposure). Use the [Impact tutorial](climada_engine_Impact.ipynb) to get more information about these functions and the class in general." + "`Impact` also has `write_csv()` and `write_excel()` methods to save the impact variables, and `write_sparse_csr()` to save the impact matrix (impact per event and exposure). Use the [Impact tutorial](../user-guide/climada_engine_Impact.ipynb) to get more information about these functions and the class in general." ] }, { @@ -1226,16 +1226,16 @@ "source": [ "## What next?\n", "\n", - "Thanks for following this tutorial! Take time to work on the exercises it suggested, or design your own risk analysis for your own topic. More detailed tutorials for individual classes were listed in the [Features](#CLIMADA-features) section.\n", + "Thanks for following this tutorial! Take time to work on the exercises it suggested, or design your own risk analysis for your own topic. More detailed tutorials for individual classes were listed in the [Features](#climada-features) section.\n", "\n", - "Also, explore the full CLIMADA documentation and additional resources [described at the start of this document](#Resources-beyond-this-tutorial) to learn more about CLIMADA, its structure, its existing applications and how you can contribute.\n" + "Also, explore the full CLIMADA documentation and additional resources [described at the start of this document](#resources-beyond-this-tutorial) to learn more about CLIMADA, its structure, its existing applications and how you can contribute.\n" ] } ], "metadata": { "hide_input": false, "kernelspec": { - "display_name": "climada_env", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -1249,7 +1249,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.15" + "version": "3.12.6" }, "vscode": { "interpreter": { diff --git a/doc/tutorial/climada_engine_CostBenefit.ipynb b/doc/user-guide/climada_engine_CostBenefit.ipynb similarity index 100% rename from doc/tutorial/climada_engine_CostBenefit.ipynb rename to doc/user-guide/climada_engine_CostBenefit.ipynb diff --git a/doc/tutorial/climada_engine_Forecast.ipynb b/doc/user-guide/climada_engine_Forecast.ipynb similarity index 100% rename from doc/tutorial/climada_engine_Forecast.ipynb rename to doc/user-guide/climada_engine_Forecast.ipynb diff --git a/doc/tutorial/climada_engine_Impact.ipynb b/doc/user-guide/climada_engine_Impact.ipynb similarity index 99% rename from doc/tutorial/climada_engine_Impact.ipynb rename to doc/user-guide/climada_engine_Impact.ipynb index a342a43b3..150d76e0d 100644 --- a/doc/tutorial/climada_engine_Impact.ipynb +++ b/doc/user-guide/climada_engine_Impact.ipynb @@ -11,7 +11,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Goal of this tutorial" + "## Goal of this tutorial" ] }, { @@ -30,7 +30,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### What is an Impact?" + "## What is an Impact?" ] }, { @@ -44,7 +44,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Impact class data structure" + "## Impact class data structure" ] }, { @@ -97,7 +97,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### How do I compute an impact in CLIMADA?" + "### How do I compute an impact in CLIMADA?" ] }, { @@ -141,7 +141,7 @@ "By default it is set to 1e9 in the [default config file](https://github.com/CLIMADA-project/climada_python/blob/main/climada/conf/climada.conf).\n", "A high value makes the computation fast at the cost of increased memory consumption.\n", "You can decrease its value if you are having memory issues with the `ImpactCalc.impact()` method.\n", - "(See the [config guide](../guide/Guide_Configuration.ipynb) on how to set configuration values)." + "(See the [config guide](../development/Guide_Configuration.ipynb) on how to set configuration values)." ] }, { @@ -2039,7 +2039,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13" + "version": "3.12.6" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/doc/tutorial/climada_engine_impact_data.ipynb b/doc/user-guide/climada_engine_impact_data.ipynb similarity index 99% rename from doc/tutorial/climada_engine_impact_data.ipynb rename to doc/user-guide/climada_engine_impact_data.ipynb index 40ead3d80..6f6972f3b 100644 --- a/doc/tutorial/climada_engine_impact_data.ipynb +++ b/doc/user-guide/climada_engine_impact_data.ipynb @@ -62,6 +62,7 @@ "metadata": {}, "source": [ "### clean_emdat_df()\n", + "\n", "read CSV from EM-DAT into a DataFrame and clean up.\n", "\n", "Use the parameters countries, hazard, and year_range to filter. These parameters are the same for most functions shown here." @@ -184,11 +185,11 @@ "### emdat_to_impact()\n", "function to load EM-DAT impact data and return impact set with impact per event\n", "\n", - "##### Parameters:\n", + "#### Parameters:\n", "- emdat_file_csv (str): Full path to EMDAT-file (CSV)\n", "- hazard_type_climada (str): Hazard type abbreviation used in CLIMADA, e.g. 'TC'\n", "\n", - "##### Optional parameters:\n", + "#### Optional parameters:\n", "\n", "- hazard_type_emdat (list or str): List of Disaster (sub-)type according EMDAT terminology or CLIMADA hazard type abbreviations. e.g. ['Wildfire', 'Forest fire'] or ['BF']\n", "- year_range (list with 2 integers): start and end year e.g. [1980, 2017]\n", @@ -196,7 +197,7 @@ "- reference_year (int): reference year of exposures for normalization. Impact is scaled proportional to GDP to the value of the reference year. No scaling for reference_year=0 (default)\n", "- imp_str (str): Column name of impact metric in EMDAT CSV, e.g. 'Total Affected'; default = \"Total Damages\"\n", "\n", - "##### Returns:\n", + "#### Returns:\n", "- impact_instance (instance of climada.engine.Impact):\n", " Impact() instance (same format as output from CLIMADA impact computations).\n", " Values are scaled with GDP to reference_year if reference_year not equal 0.\n", @@ -322,10 +323,10 @@ "\n", "function to load EM-DAT impact data and return DataFrame with impact summed per year and country\n", "\n", - "##### Parameters:\n", + "#### Parameters:\n", "- emdat_file_csv (str): Full path to EMDAT-file (CSV)\n", "\n", - "##### Optional parameters:\n", + "#### Optional parameters:\n", "\n", "- hazard (list or str): List of Disaster (sub-)type according EMDAT terminology or CLIMADA hazard type abbreviations. e.g. ['Wildfire', 'Forest fire'] or ['BF']\n", "- year_range (list with 2 integers): start and end year e.g. [1980, 2017]\n", @@ -334,7 +335,7 @@ "- imp_str (str): Column name of impact metric in EMDAT CSV, e.g. 'Total Affected'; default = \"Total Damages\"\n", "- version (int): given EM-DAT data format version (i.e. year of download), changes naming of columns/variables (default: 2020)\n", "\n", - "##### Returns:\n", + "#### Returns:\n", "- pandas.DataFrame with impact per year and country" ] }, @@ -430,9 +431,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.12" + "version": "3.12.6" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/doc/tutorial/climada_engine_unsequa.ipynb b/doc/user-guide/climada_engine_unsequa.ipynb similarity index 99% rename from doc/tutorial/climada_engine_unsequa.ipynb rename to doc/user-guide/climada_engine_unsequa.ipynb index a7f6fabd6..d1f60722f 100644 --- a/doc/tutorial/climada_engine_unsequa.ipynb +++ b/doc/user-guide/climada_engine_unsequa.ipynb @@ -3085,7 +3085,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "For examples of how to use non-defaults please see the [impact example](###Compute-uncertainty-and-sensitivity-using-default-methods )" + "For examples of how to use non-defaults please see the [impact example](#compute-uncertainty-and-sensitivity-using-default-methods)" ] }, { @@ -5778,7 +5778,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.18" + "version": "3.12.6" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/doc/tutorial/climada_engine_unsequa_helper.ipynb b/doc/user-guide/climada_engine_unsequa_helper.ipynb similarity index 100% rename from doc/tutorial/climada_engine_unsequa_helper.ipynb rename to doc/user-guide/climada_engine_unsequa_helper.ipynb diff --git a/doc/tutorial/climada_entity_DiscRates.ipynb b/doc/user-guide/climada_entity_DiscRates.ipynb similarity index 100% rename from doc/tutorial/climada_entity_DiscRates.ipynb rename to doc/user-guide/climada_entity_DiscRates.ipynb diff --git a/doc/tutorial/climada_entity_Exposures.ipynb b/doc/user-guide/climada_entity_Exposures.ipynb similarity index 99% rename from doc/tutorial/climada_entity_Exposures.ipynb rename to doc/user-guide/climada_entity_Exposures.ipynb index a57079ef2..aa1b39fd3 100644 --- a/doc/tutorial/climada_entity_Exposures.ipynb +++ b/doc/user-guide/climada_entity_Exposures.ipynb @@ -12,21 +12,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### What is an exposure?\n", + "## What is an exposure?\n", "\n", "Exposure describes the set of assets, people, livelihoods, infrastructures, etc. within an area of interest in terms of their geographic location, their value etc.; in brief - everything potentially exposed to hazards. \n", "\n", - "\n", - "\n", - "### What options does CLIMADA offer for me to create an exposure?\n", + "## What options does CLIMADA offer for me to create an exposure?\n", "\n", "CLIMADA has an `Exposures` class for this purpuse. An `Exposures` instance can be filled with your own data, or loaded from available default sources implemented through some Exposures-type classes from CLIMADA.
    \n", "If you have your own data, they can be provided in the formats of a `pandas.DataFrame`, a `geopandas.GeoDataFrame` or simply an `Excel` file. \n", "If you didn't collect your own data, exposures can be generated on the fly using CLIMADA's [LitPop](climada_entity_LitPop.ipynb), [BlackMarble](https://climada-petals.readthedocs.io/en/stable/tutorial/climada_entity_BlackMarble.html) or [OpenStreetMap](https://climada-petals.readthedocs.io/en/stable/tutorial/climada_exposures_openstreetmap.html) modules. See the respective tutorials to learn what exactly they contain and how to use them.\n", "\n", - "\n", - "\n", - "### What does an exposure look like in CLIMADA?\n", + "## What does an exposure look like in CLIMADA?\n", "\n", "An exposure is represented in the class `Exposures`, which contains a [geopandas](https://geopandas.readthedocs.io/en/latest/gallery/cartopy_convert.html) [GeoDataFrame](https://geopandas.readthedocs.io/en/latest/docs/user_guide/data_structures.html#geodataframe) that is accessible through the `Exposures.data` attribute.\n", "A \"geometry\" column is initialized in the `GeoDataFrame` of the `Exposures` object, other columns are optional at first but some have to be present or make a difference when it comes to do calculations.\n", @@ -1689,7 +1685,6 @@ }, { "cell_type": "markdown", - "id": "5d078d09", "metadata": {}, "source": [ "Optionally use climada's save option to save it in pickle format. This allows fast to quickly restore the object in its current state and take up your work right were you left it the next time.\n", @@ -1727,7 +1722,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.12.6" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/doc/tutorial/climada_entity_Exposures_osm.ipynb b/doc/user-guide/climada_entity_Exposures_osm.ipynb similarity index 100% rename from doc/tutorial/climada_entity_Exposures_osm.ipynb rename to doc/user-guide/climada_entity_Exposures_osm.ipynb diff --git a/doc/tutorial/climada_entity_Exposures_polygons_lines.ipynb b/doc/user-guide/climada_entity_Exposures_polygons_lines.ipynb similarity index 100% rename from doc/tutorial/climada_entity_Exposures_polygons_lines.ipynb rename to doc/user-guide/climada_entity_Exposures_polygons_lines.ipynb diff --git a/doc/tutorial/climada_entity_ImpactFuncSet.ipynb b/doc/user-guide/climada_entity_ImpactFuncSet.ipynb similarity index 99% rename from doc/tutorial/climada_entity_ImpactFuncSet.ipynb rename to doc/user-guide/climada_entity_ImpactFuncSet.ipynb index 6df482925..fd349487c 100644 --- a/doc/tutorial/climada_entity_ImpactFuncSet.ipynb +++ b/doc/user-guide/climada_entity_ImpactFuncSet.ipynb @@ -11,7 +11,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### What is an impact function?\n", + "## What is an impact function?\n", "\n", "An impact function relates the percentage of damage in the exposure to the hazard intensity, also commonly referred to as a \"vulnerability curve\" in the modelling community. Every hazard and exposure types are characterized by an impact function." ] @@ -20,7 +20,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### What is the difference between `ImpactFunc` and `ImpactFuncSet`?\n", + "## What is the difference between `ImpactFunc` and `ImpactFuncSet`?\n", "\n", "An `ImpactFunc` is a class for a single impact function. E.g. a function that relates the percentage of damage of a reinforced concrete building (exposure) to the wind speed of a tropical cyclone (hazard intensity). \n", "\n", @@ -31,7 +31,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### What does an `ImpactFunc` look like in CLIMADA?\n", + "### What does an `ImpactFunc` look like in CLIMADA?\n", "\n", "The `ImpactFunc` class requires users to define the following attributes.\n", "\n", @@ -52,7 +52,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### What does an `ImpactFuncSet` look like in CLIMADA?\n", + "### What does an `ImpactFuncSet` look like in CLIMADA?\n", "\n", "The `ImpactFuncSet` class contains all the `ImpactFunc` classes. Users are not required to define any attributes in `ImpactFuncSet`. \n", "\n", @@ -77,7 +77,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Generate a dummy impact function from scratch.\n", + "### Generate a dummy impact function from scratch.\n", "\n", "Here we generate an impact function with random dummy data for illustrative reasons. Assuming this impact function is a function that relates building damage to tropical cyclone (TC) wind, with an arbitrary id 3." ] @@ -187,7 +187,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Loading CLIMADA in-built impact function for tropical cyclones\n", + "### Loading CLIMADA in-built impact function for tropical cyclones\n", "\n", "`ImpfTropCyclone` is a derivated class of `ImpactFunc`. This in-built impact function estimates the insured property damages by tropical cyclone wind in USA, following the reference paper [Emanuel (2011)](https://doi.org/10.1175/WCAS-D-11-00007.1).
    \n", "\n", @@ -289,7 +289,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Plotting all the impact functions in an `ImpactFuncSet`\n", + "### Plotting all the impact functions in an `ImpactFuncSet`\n", "\n", "The method `plot()` in `ImpactFuncSet` also uses the the [matplotlib's axes plot function](https://matplotlib.org/3.3.2/api/_as_gen/matplotlib.axes.Axes.plot.html) to visualise the impact functions, returning a figure with all the subplots of impact functions. Users may modify these plots." ] @@ -321,7 +321,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Retrieving an impact function from the `ImpactFuncSet`\n", + "### Retrieving an impact function from the `ImpactFuncSet`\n", "User may want to retrive a particular impact function from `ImpactFuncSet`. Using the method `get_func(haz_type, id)`, it returns an `ImpactFunc` class of the desired impact function. Below is an example of extracting the TC impact function with id 1, and using `plot()` to visualise the function." ] }, @@ -354,7 +354,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Removing an impact function from the `ImpactFuncSet`\n", + "### Removing an impact function from the `ImpactFuncSet`\n", "\n", "If there is an unwanted impact function from the `ImpactFuncSet`, we may remove it using the method `remove_func(haz_type, id)` to remove it from the set. \n", "\n", @@ -423,7 +423,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Reading impact functions from an Excel file\n", + "### Reading impact functions from an Excel file\n", "\n", "Impact functions defined in an excel file following the template provided in sheet `impact_functions` of `climada_python/climada/data/system/entity_template.xlsx` can be ingested directly using the method `from_excel()`." ] @@ -471,7 +471,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Write impact functions\n", + "### Write impact functions\n", "\n", "Users may write the impact functions in Excel format using `write_excel()` method." ] @@ -570,7 +570,7 @@ "metadata": { "hide_input": false, "kernelspec": { - "display_name": "climada_env", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -584,7 +584,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13" + "version": "3.12.6" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/doc/tutorial/climada_entity_LitPop.ipynb b/doc/user-guide/climada_entity_LitPop.ipynb similarity index 99% rename from doc/tutorial/climada_entity_LitPop.ipynb rename to doc/user-guide/climada_entity_LitPop.ipynb index b41728bf2..613d3b3e2 100644 --- a/doc/tutorial/climada_entity_LitPop.ipynb +++ b/doc/user-guide/climada_entity_LitPop.ipynb @@ -29,7 +29,7 @@ "\n", "*Note*: All required data except for the population data from Gridded Population of the World (GPW) is downloaded automatically when an `LitPop.set_*` method is called.\n", "\n", - "**Warning**: Processing the data for the first time can take up huge amounts of RAM (>10 GB), depending on country or region size. Consider using the [wrapper function](climada_util_api_client.ipynb#The-wrapper-functions-client.get_litpop()) of the [data API](climada_util_api_client.ipynb) to download readily computed LitPop exposure data for default values ($n = m = 1$) on demand.\n", + "**Warning**: Processing the data for the first time can take up huge amounts of RAM (>10 GB), depending on country or region size. Consider using the [wrapper function](climada_util_api_client.ipynb#the-wrapper-functions-client-get-litpop) of the [data API](climada_util_api_client.ipynb) to download readily computed LitPop exposure data for default values ($n = m = 1$) on demand.\n", "\n", "#### Nightlight intensity\n", "Black Marble annual composite of the VIIRS day-night band (Grayscale) at 15 arcsec resolution is downloaded from the NASA Earth Observatory: https://earthobservatory.nasa.gov/Features/NightLights (available for 2012 and 2016 at 15 arcsec resolution (~500m)).\n", @@ -50,7 +50,7 @@ "\n", "### Downloading existing LitPop asset exposure data\n", "\n", - "The easiest way to download existing data is using the [wrapper function](climada_util_api_client.ipynb#The-wrapper-functions-client.get_litpop()) of the [data API](climada_util_api_client.ipynb).\n", + "The easiest way to download existing data is using the [wrapper function](climada_util_api_client.ipynb#the-wrapper-functions-client-get-litpop) of the [data API](climada_util_api_client.ipynb).\n", "\n", "Readily computed LitPop asset exposure data based on $Lit^1Pop^1$ for 224 countries, distributing produced capital / non-financial wealth of 2014 at a resolution of 30 arcsec can also be downloaded from the ETH Research Repository: https://doi.org/10.3929/ethz-b-000331316.\n", "The dataset contains gridded data for more than 200 countries as CSV files." @@ -62,7 +62,7 @@ "source": [ "## Attributes\n", "\n", - "The `LitPop` class inherits from [`Exposures`](climada_entity_Exposures.ipynb#Exposures-class).\n", + "The `LitPop` class inherits from [`Exposures`](climada_entity_Exposures.ipynb).\n", "It adds the following attributes:\n", "\n", " exponents : Defining powers (m, n) with which nightlights and population go into Lit**m * Pop**n.\n", @@ -830,7 +830,7 @@ "metadata": { "hide_input": false, "kernelspec": { - "display_name": "climada_env", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -844,7 +844,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.18" + "version": "3.12.6" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/doc/tutorial/climada_entity_MeasureSet.ipynb b/doc/user-guide/climada_entity_MeasureSet.ipynb similarity index 100% rename from doc/tutorial/climada_entity_MeasureSet.ipynb rename to doc/user-guide/climada_entity_MeasureSet.ipynb diff --git a/doc/tutorial/climada_hazard_Hazard.ipynb b/doc/user-guide/climada_hazard_Hazard.ipynb similarity index 99% rename from doc/tutorial/climada_hazard_Hazard.ipynb rename to doc/user-guide/climada_hazard_Hazard.ipynb index aebd85792..412346d04 100644 --- a/doc/tutorial/climada_hazard_Hazard.ipynb +++ b/doc/user-guide/climada_hazard_Hazard.ipynb @@ -6,17 +6,13 @@ "source": [ "# Hazard class\n", "\n", - "#### What is a hazard?\n", + "## What is a hazard?\n", "A hazard describes weather events such as storms, floods, droughts, or heat waves both in terms of probability of occurrence as well as physical intensity.\n", "\n", - "
    \n", - "\n", - "#### How are hazards embedded in the CLIMADA architecture?\n", + "## How are hazards embedded in the CLIMADA architecture?\n", "Hazards are defined by the base class `Hazard` which gathers the required attributes that enable the impact computation (such as centroids, frequency per event, and intensity per event and centroid) and common methods such as readers and visualization functions. Each hazard class collects historical data or model simulations and transforms them, if necessary, in order to construct a coherent event database. Stochastic events can be generated taking into account the frequency and main intensity characteristics (such as local water depth for floods or gust speed for storms) of historical events, producing an ensemble of probabilistic events for each historical event. CLIMADA provides therefore an event-based probabilistic approach which does not depend on a hypothesis of a priori general probability distribution choices. Note that one can also reduce the probabilistic approach to a deterministic approach (e.g., story-line or forecasting) by defining the frequency to be 1. The source of the historical data (e.g. inventories or satellite images) or model simulations (e.g. synthetic tropical cyclone tracks) and the methodologies used to compute the hazard attributes and its stochastic events depend on each hazard type and are defined in its corresponding Hazard-derived class (e.g. `TropCylcone` for tropical cyclones, explained in the tutorial [TropCyclone](climada_hazard_TropCyclone.ipynb)). This procedure provides a solid and homogeneous methodology to compute impacts worldwide. In the case where the risk analysis comprises a specific region where good quality data or models describing the hazard intensity and frequency are available, these can be directly ingested by the platform through the reader functions, skipping the hazard modelling part (in total or partially), and allowing us to easily and seamlessly combine CLIMADA with external sources. Hence the impact model can be used for a wide variety of applications, e.g. deterministically to assess the impact of a single (past or future) event or to quantify risk based on a (large) set of probabilistic events. Note that since the `Hazard` class is not an abstract class, any hazard that is not defined in CLIMADA can still be used by providing the `Hazard` attributes.\n", "\n", - "
    \n", - "\n", - "#### What do hazards look like in CLIMADA?\n", + "## What do hazards look like in CLIMADA?\n", "\n", "A `Hazard` contains events of some hazard type defined at `centroids`. There are certain variables in a `Hazard` instance that _are needed_ to compute the impact, while others are _descriptive_ and can therefore be set with default values. The full list of looks like this:\n", "\n", @@ -779,9 +775,7 @@ { "cell_type": "code", "execution_count": 13, - "metadata": { - "scrolled": false - }, + "metadata": {}, "outputs": [ { "data": { @@ -1009,7 +1003,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.8.13 ('climada_env')", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -1023,7 +1017,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.18" + "version": "3.12.6" } }, "nbformat": 4, diff --git a/doc/tutorial/climada_hazard_StormEurope.ipynb b/doc/user-guide/climada_hazard_StormEurope.ipynb similarity index 99% rename from doc/tutorial/climada_hazard_StormEurope.ipynb rename to doc/user-guide/climada_hazard_StormEurope.ipynb index 7772d6057..1d13396fb 100644 --- a/doc/tutorial/climada_hazard_StormEurope.ipynb +++ b/doc/user-guide/climada_hazard_StormEurope.ipynb @@ -31,7 +31,7 @@ "source": [ "## Reading Data\n", "\n", - "StormEurope was written under the presumption that you'd start out with [WISC](https://wisc.climate.copernicus.eu/wisc/#/help/products#footprint_section) storm footprint data in netCDF format. This notebook works with a demo dataset. If you would like to work with the real data: (1) Please follow the link and download the file C3S_WISC_FOOTPRINT_NETCDF_0100.tgz from the Copernicus Windstorm Information Service, (2) unzip it (3) uncomment the last two lines in the following codeblock and (4) adjust the variable \"WISC_files\".\n", + "StormEurope was written under the presumption that you'd start out with [WISC](https://confluence.ecmwf.int/display/CKB/Synthetic+Windstorm+Events+for+Europe+from+1986+to+2011%3A+Product+User+Guide) storm footprint data in netCDF format. This notebook works with a demo dataset. If you would like to work with the real data: (1) Please follow the link and download the file C3S_WISC_FOOTPRINT_NETCDF_0100.tgz from the Copernicus Windstorm Information Service, (2) unzip it (3) uncomment the last two lines in the following codeblock and (4) adjust the variable \"WISC_files\".\n", "\n", "We first construct an instance and then point the reader at a directory containing compatible `.nc` files. Since there are other files in there, we must be explicit and use a globbing pattern; supplying incompatible files will make the reader fail.\n", "\n", @@ -42,17 +42,7 @@ "cell_type": "code", "execution_count": 2, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "$CLIMADA_SRC/climada/hazard/centroids/centr.py:822: UserWarning: Geometry is in a geographic CRS. Results from 'buffer' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " xy_pixels = self.geometry.buffer(res / 2).envelope\n" - ] - } - ], + "outputs": [], "source": [ "from climada.hazard import StormEurope\n", "from climada.util.constants import WS_DEMO_NC\n", @@ -85,10 +75,10 @@ "\u001b[0;31mFile:\u001b[0m ~/code/climada_python/climada/hazard/storm_europe.py\n", "\u001b[0;31mDocstring:\u001b[0m \n", "A hazard set containing european winter storm events. Historic storm\n", - "events can be downloaded at http://wisc.climate.copernicus.eu/ and read\n", + "events can be downloaded at https://cds.climate.copernicus.eu/ and read\n", "with `from_footprints`. Weather forecasts can be automatically downloaded from\n", "https://opendata.dwd.de/ and read with from_icon_grib(). Weather forecast\n", - "from the COSMO-Consortium http://www.cosmo-model.org/ can be read with\n", + "from the COSMO-Consortium https://www.cosmo-model.org/ can be read with\n", "from_cosmoe_file().\n", "\n", "Attributes\n", diff --git a/doc/tutorial/climada_hazard_TropCyclone.ipynb b/doc/user-guide/climada_hazard_TropCyclone.ipynb similarity index 99% rename from doc/tutorial/climada_hazard_TropCyclone.ipynb rename to doc/user-guide/climada_hazard_TropCyclone.ipynb index 28d80d1ac..c58cc4a30 100644 --- a/doc/tutorial/climada_hazard_TropCyclone.ipynb +++ b/doc/user-guide/climada_hazard_TropCyclone.ipynb @@ -13,7 +13,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### What do tropical cyclones look like in CLIMADA?\n", + "## What do tropical cyclones look like in CLIMADA?\n", "\n", "`TCTracks` reads and handles historical tropical cyclone tracks of the [IBTrACS](https://www.ncdc.noaa.gov/ibtracs/) repository or synthetic tropical cyclone tracks simulated using fully statistical or coupled statistical-dynamical modeling approaches. It also generates synthetic tracks from the historical ones using Wiener processes.\n", "\n", @@ -2183,7 +2183,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### REFERENCES:\n", + "## REFERENCES:\n", "\n", "- Bloemendaal, N., Haigh, I. D., de Moel, H., Muis, S., Haarsma, R. J., & Aerts, J. C. J. H. (2020). Generation of a global synthetic tropical cyclone hazard dataset using STORM. Scientific Data, 7(1). https://doi.org/10.1038/s41597-020-0381-2\n", "\n", @@ -2195,6 +2195,13 @@ "\n", "- Lee, C. Y., Tippett, M. K., Sobel, A. H., & Camargo, S. J. (2018). An environmentally forced tropical cyclone hazard model. Journal of Advances in Modeling Earth Systems, 10(1), 223–241. https://doi.org/10.1002/2017MS001186" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -2213,7 +2220,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.12" + "version": "3.12.6" }, "toc": { "base_numbering": 1, diff --git a/doc/tutorial/climada_trajectories.ipynb b/doc/user-guide/climada_trajectories.ipynb similarity index 100% rename from doc/tutorial/climada_trajectories.ipynb rename to doc/user-guide/climada_trajectories.ipynb diff --git a/doc/tutorial/climada_util_api_client.ipynb b/doc/user-guide/climada_util_api_client.ipynb similarity index 99% rename from doc/tutorial/climada_util_api_client.ipynb rename to doc/user-guide/climada_util_api_client.ipynb index 215f8b6d0..29d6bf0a0 100644 --- a/doc/tutorial/climada_util_api_client.ipynb +++ b/doc/user-guide/climada_util_api_client.ipynb @@ -620,9 +620,7 @@ { "cell_type": "code", "execution_count": 18, - "metadata": { - "scrolled": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -1331,7 +1329,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13" + "version": "3.12.6" } }, "nbformat": 4, diff --git a/doc/tutorial/climada_util_calibrate.ipynb b/doc/user-guide/climada_util_calibrate.ipynb similarity index 99% rename from doc/tutorial/climada_util_calibrate.ipynb rename to doc/user-guide/climada_util_calibrate.ipynb index 0efefc5a2..bd08946ff 100644 --- a/doc/tutorial/climada_util_calibrate.ipynb +++ b/doc/user-guide/climada_util_calibrate.ipynb @@ -7,17 +7,17 @@ "source": [ "# Impact Function Calibration\n", "\n", - "CLIMADA provides the [`climada.util.calibrate`](../climada/climada.util.calibrate) module for calibrating impact functions based on impact data.\n", + "CLIMADA provides the [`climada.util.calibrate`](../api/climada/climada.util.calibrate) module for calibrating impact functions based on impact data.\n", "This tutorial will guide through the usage of this module by calibrating an impact function for tropical cyclones (TCs).\n", "\n", - "For further information on the classes available from the module, see its [documentation](../climada/climada.util.calibrate).\n", + "For further information on the classes available from the module, see its [documentation](../api/climada/climada.util.calibrate).\n", "\n", "## Overview\n", "\n", "The basic idea of the calibration is to find a set of parameters for an impact function that minimizes the deviation between the calculated impact and some impact data.\n", "For setting up a calibration task, users have to supply the following information:\n", "\n", - "* Hazard and Exposure (as usual, see [the tutorial](../tutorial/1_main_climada.ipynb#tutorial-an-example-risk-assessment))\n", + "* Hazard and Exposure (as usual, see [the tutorial](../user-guide/1_main_climada.ipynb#tutorial-an-example-risk-assessment))\n", "* The impact data to calibrate the model to\n", "* An impact function definition depending on the calibrated parameters\n", "* Bounds and constraints of the calibrated parameters (depending on the calibration algorithm)\n", @@ -4049,7 +4049,7 @@ ], "metadata": { "kernelspec": { - "display_name": "climada_env_3.9", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -4063,10 +4063,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.18" - }, - "orig_nbformat": 4 + "version": "3.12.6" + } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/doc/tutorial/climada_util_earth_engine.ipynb b/doc/user-guide/climada_util_earth_engine.ipynb similarity index 99% rename from doc/tutorial/climada_util_earth_engine.ipynb rename to doc/user-guide/climada_util_earth_engine.ipynb index 10811ce4d..bf773ef7d 100644 --- a/doc/tutorial/climada_util_earth_engine.ipynb +++ b/doc/user-guide/climada_util_earth_engine.ipynb @@ -88,10 +88,10 @@ "metadata": {}, "source": [ "If you have a collection, specification of the time range and area of interest. Then, use methods of the series **obtain_image_type(collection,time_range,area)** depending the type of product needed.\n", - "#### Time range\n", + "### Time range\n", "It depends on the image acquisition period of the targeted satellite and type of images desired (without clouds, from a specific period...) \n", "\n", - "#### Area\n", + "### Area\n", "GEE needs a special format for defining an area of interest. It has to be a GeoJSON Polygon and the coordinates should be first defined in a list and then converted using ee.Geometry. It is possible to use data obtained via Exposure layer. Some examples are given below." ] }, @@ -558,9 +558,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.12" + "version": "3.12.6" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/doc/tutorial/climada_util_local_exceedance_values.ipynb b/doc/user-guide/climada_util_local_exceedance_values.ipynb similarity index 93% rename from doc/tutorial/climada_util_local_exceedance_values.ipynb rename to doc/user-guide/climada_util_local_exceedance_values.ipynb index c8a4d156f..72c9b62e5 100644 --- a/doc/tutorial/climada_util_local_exceedance_values.ipynb +++ b/doc/user-guide/climada_util_local_exceedance_values.ipynb @@ -340,7 +340,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2025-03-14 16:42:11,754 - climada.hazard.io - INFO - Reading /Users/vgebhart/climada/data/hazard/template/HAZ_DEMO_FL_15/v1/HAZ_DEMO_FL_15.h5\n" + "2025-03-31 17:21:06,957 - climada.hazard.io - INFO - Reading /Users/vgebhart/climada/data/hazard/template/HAZ_DEMO_FL_15/v1/HAZ_DEMO_FL_15.h5\n" ] } ], @@ -508,7 +508,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2025-03-14 16:42:35,716 - climada.hazard.io - INFO - Reading /Users/vgebhart/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020/v2/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020.hdf5\n" + "2025-03-31 17:21:31,356 - climada.hazard.io - INFO - Reading /Users/vgebhart/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020/v2/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020.hdf5\n" ] } ], @@ -546,12 +546,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "2025-03-14 16:42:37,253 - climada.entity.exposures.base - INFO - Reading /Users/vgebhart/climada/data/exposures/litpop/LitPop_150arcsec_HTI/v3/LitPop_150arcsec_HTI.hdf5\n", - "2025-03-14 16:42:37,282 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n", - "2025-03-14 16:42:37,283 - climada.entity.exposures.base - INFO - category_id not set.\n", - "2025-03-14 16:42:37,283 - climada.entity.exposures.base - INFO - cover not set.\n", - "2025-03-14 16:42:37,284 - climada.entity.exposures.base - INFO - deductible not set.\n", - "2025-03-14 16:42:37,284 - climada.entity.exposures.base - INFO - centr_ not set.\n" + "2025-03-31 17:21:32,751 - climada.entity.exposures.base - INFO - Reading /Users/vgebhart/climada/data/exposures/litpop/LitPop_150arcsec_HTI/v3/LitPop_150arcsec_HTI.hdf5\n", + "2025-03-31 17:21:32,768 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n", + "2025-03-31 17:21:32,769 - climada.entity.exposures.base - INFO - category_id not set.\n", + "2025-03-31 17:21:32,769 - climada.entity.exposures.base - INFO - cover not set.\n", + "2025-03-31 17:21:32,769 - climada.entity.exposures.base - INFO - deductible not set.\n", + "2025-03-31 17:21:32,770 - climada.entity.exposures.base - INFO - centr_ not set.\n" ] } ], @@ -584,10 +584,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "2025-03-14 16:42:37,339 - climada.entity.exposures.base - INFO - No specific impact function column found for hazard TC. Using the anonymous 'impf_' column.\n", - "2025-03-14 16:42:37,340 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", - "2025-03-14 16:42:37,342 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", - "2025-03-14 16:42:37,346 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n" + "2025-03-31 17:21:32,824 - climada.entity.exposures.base - INFO - No specific impact function column found for hazard TC. Using the anonymous 'impf_' column.\n", + "2025-03-31 17:21:32,825 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-03-31 17:21:32,827 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-03-31 17:21:32,830 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n" ] } ], @@ -606,7 +606,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2025-03-14 16:42:37,379 - climada.engine.impact - INFO - Computing exceedance impact map for return periods: [10, 50, 100, 200]\n" + "2025-03-31 17:21:32,861 - climada.engine.impact - INFO - Computing exceedance impact map for return periods: [10, 50, 100, 200]\n" ] } ], @@ -651,7 +651,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2025-03-14 16:43:03,117 - climada.engine.impact - INFO - Computing return period map for impacts: [1000, 10000, 100000, 1000000]\n" + "2025-03-31 17:21:58,100 - climada.engine.impact - INFO - Computing return period map for impacts: [1000, 10000, 100000, 1000000]\n" ] } ], @@ -683,6 +683,169 @@ "# plot local return periods of impacts\n", "plot_from_gdf(local_return_periods, title, column_label, smooth=False);" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## When to use binning in calculating local exceedance frequencies or local return periods\n", + "\n", + "When using `method='extrapolate'`, local exceedance frequencies or local return periods are extrapolated beyond the observed data range. The used extrapolation technique is the one of `scipy.interpolate.interp1d`: the two extremal interpolations at the lower and upper limits of the data are simply extended beyond the data range.\n", + "\n", + "In specific cases (see below for an example), this can lead to undesired behaviour. For this reason, the user can pass in an additional integer parameter `bin_decimals` to bin the intensities (and sum up the corresponding frequencies) according to `bin_decimals` decimal places. \n", + "\n", + "As can be seen in the following example, this binning can lead to a different and more stable extrapolation (which might be desriable in particular for the `local_return_period` method), and to a smoother interpolation. Note that, due to binning, the data range of observed return periods for `method='interpolate'` may be reduced.\n", + "\n", + "As an example, we consider a hazard object that contains one centroid and five intensities, all of which occur with a frequency of 1/10years. Importantly, the two maximal intensities are very similar, which strongly affects the extrapolation behaviour." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "hazard_binning = Hazard(\n", + " intensity=sparse.csr_matrix([[80.0], [80.02], [70.0], [70.0], [60.0]]),\n", + " frequency=np.array([0.1, 0.1, 0.1, 0.1, 0.1]),\n", + " frequency_unit=\"1/year\",\n", + " units=\"m/s\",\n", + " centroids=Centroids(lat=np.array([1]), lon=np.array([2])),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "test_return_periods = np.arange(1, 12, 0.1)\n", + "interpolated = hazard_binning.local_exceedance_intensity(\n", + " return_periods=test_return_periods\n", + ")[0]\n", + "extrapolated = hazard_binning.local_exceedance_intensity(\n", + " return_periods=test_return_periods, method=\"extrapolate\"\n", + ")[0]\n", + "interpolated_binned = hazard_binning.local_exceedance_intensity(\n", + " return_periods=test_return_periods, bin_decimals=1\n", + ")[0]\n", + "extrapolated_binned = hazard_binning.local_exceedance_intensity(\n", + " return_periods=test_return_periods, method=\"extrapolate\", bin_decimals=1\n", + ")[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAyUAAAIhCAYAAABQchU9AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAz/NJREFUeJzs3XdYFFfbBvB76R0ElC6golhQsWFJxIYx9hA1alQw+sZoGhprjIpRQTEhJhpLYkGjRmONJRY0SiyIKHaNFbuICtJE2p7vD8J+roDswi4L7P27rr10z56ZeWZmdx7OzJkzEiGEABERERERkYboaDoAIiIiIiLSbmyUEBERERGRRrFRQkREREREGsVGCRERERERaRQbJUREREREpFFslBARERERkUaxUUJERERERBrFRgkREREREWkUGyVERERERKRRbJSQ0kJCQrB9+/ZC5REREZBIJDh16pTaY+jQoQM6dOig9uW8vszAwEAAQGBgYKHlSyQSBAcHl2reixcvRkRERJniK0+HDx+GRCLB4cOHlZ728uXLCA4Oxu3bt0u9/ILv2quxlGV+RKQ5zClF5xRVevjwIYKDg3H27Fm1LUPVAgMD4ebmVqpp169fjwULFpRp+eW5fyhfmRolWVlZqoqDKpHiEoi2i46OxsiRI0s1bWVrlJTF5cuXMXPmTDYiqFjMLdqFOUX9Hj58iJkzZ1aqRklZqKJRQuVPqUbJvn37EBgYiNq1a0NfXx8mJiYwNzeHr68v5syZg4cPH6orTqIKr3Xr1nB2dtZ0GDJCCGRmZmo6DKISMbcQVSwvXrzQdAikhRRqlGzfvh316tVDQEAAdHR0MGHCBGzduhX79u3DihUr4OvriwMHDqBWrVr45JNP8OTJE3XHTa8JDg6GRCLB+fPn0b9/f1haWsLa2hrjxo1Dbm4url69im7dusHc3Bxubm4ICwsrNI/U1FSMHz8e7u7uMDAwgJOTE4KCgpCRkSGrI5FIkJGRgdWrV0MikUAikRS6pJmWlobRo0fD1tYWNjY28Pf3L/RHhVQqRVhYGDw9PWFoaIgaNWpg2LBhuH//vlw9IQTCwsLg6uoKIyMjNGvWDHv27FHdhlOh17tvFXQ9OHTo0Bu3h5ubGy5duoSoqCjZNn31krUi+6Vg+Z999hmWLl2K+vXrw9DQEKtXr8bt27chkUgQFhaGOXPmoGbNmjAyMkKLFi1w8ODBQutx9OhRdO7cGebm5jAxMUHbtm2xe/fuEtf/1KlTGDhwINzc3GBsbAw3NzcMGjQId+7ckdsm/fv3BwB07NhRtr6vXiU6cOAAOnfuDAsLC5iYmKBdu3ZFxkmVH3NLxcWconnZ2dmYPXu2bJ2qV6+O4cOHy/0O5s6dCx0dHezcuVNu2sDAQJiYmODChQs4fPgwWrZsCQAYPny4bDsX5KvAwECYmZnhwoUL6Nq1K8zNzdG5c2cAQGRkJPr06QNnZ2cYGRmhTp06GDVqFJ4+fSq3vILvy5kzZ+Dv7w8LCwtYWlpiyJAhhX63iu6rovz8889o3749atSoAVNTU3h5eSEsLAw5OTmyOh06dMDu3btx584d2boWdPdVdLuShggFtGzZUuzYsUPk5eW9sd79+/fFhAkTxHfffafIbEmFZsyYIQCIevXqiVmzZonIyEgxceJEAUB89tlnwtPTU/z0008iMjJSDB8+XAAQW7ZskU2fkZEhmjZtKmxtbUV4eLg4cOCA+PHHH4WlpaXo1KmTkEqlQgghoqOjhbGxsejevbuIjo4W0dHR4tKlS0IIIVatWiUAiFq1aonPP/9c7Nu3TyxfvlxUq1ZNdOzYUS7ejz/+WBbb3r17xdKlS0X16tWFi4uLePLkSaH1GjFihNizZ4/45ZdfhJOTk7C3txe+vr4lbpfc3FyRk5NT4quk77YiAIgZM2bI3iu6PeLi4kStWrWEt7e3bJvGxcUJIRTfLwXLd3JyEo0bNxbr168Xf//9t7h48aKIj48XAISLi4t46623xJYtW8SmTZtEy5Ythb6+vjh+/LhsHocPHxb6+vqiefPmYuPGjWL79u2ia9euQiKRiA0bNsjqHTp0SAAQhw4dkpVt2rRJTJ8+XWzbtk1ERUWJDRs2CF9fX1G9enXZPk1MTBQhISECgPj5559l65uYmCiEEOK3334TEolE9O3bV2zdulXs3LlT9OzZU+jq6ooDBw6UeR9RxcLcUnExpxStvHJKXl6e6NatmzA1NRUzZ84UkZGRYvny5cLJyUk0aNBAvHjxQgghhFQqFd27dxfVqlUTt2/fFkIIsXLlSgFALF++XAghREpKimxbfvPNN7LtfO/ePSGEEAEBAUJfX1+4ubmJ0NBQcfDgQbFv3z4hhBBLliwRoaGhYseOHSIqKkqsXr1aNGnSRNSrV09kZ2cX2q6urq5iwoQJYt++fSI8PFyYmpoKb29vubqK7quAgADh6uoqt13Gjh0rlixZIvbu3Sv+/vtv8cMPPwhbW1sxfPhwWZ1Lly6Jdu3aCXt7e9m6RkdHK7VdSTMUapRQxVdwQPj+++/lyps2bSoAiK1bt8rKcnJyRPXq1YW/v7+sLDQ0VOjo6IjY2Fi56Tdv3iwAiL/++ktWZmpqKgICAgrFUHDQGzNmjFx5WFiYACAePXokhBDiypUrRdaLiYkRAMTXX38thBAiOTlZGBkZiffee0+u3rFjxwQAhRKIr6+vAFDiq6j1UVZxjZKStocQQjRs2LDI9VFmvwAQlpaWIikpSa5uQaPE0dFRZGZmyspTU1OFtbW16NKli6ysdevWokaNGiItLU1WlpubKxo1aiScnZ1lf0gU1Sh5XW5urkhPTxempqbixx9/lJVv2rSpyGkzMjKEtbW16NWrl1x5Xl6eaNKkiWjVqlWxyyIi1WJOKVp55ZTff/+9UENPCCFiY2MFALF48WJZ2dOnT4Wzs7No1aqViIuLEyYmJmLIkCFFTrdq1apCywoICBAAxMqVK98Yk1QqFTk5OeLOnTsCgPjzzz9lnxV8X8aOHSs3zbp16wQAsXbtWiGE4vuqIK7XGyWvysvLEzk5OWLNmjVCV1dXLvf16NGjyGmV2a5U/so8+lZeXh7Onj2L5OTkss6KVKBnz55y7+vXrw+JRIJ3331XVqanp4c6derIdavZtWsXGjVqhKZNmyI3N1f2euedd5QeZal3795y7xs3bgwAsuUdOnQIAGSjWhRo1aoV6tevL+uqEx0djZcvX+LDDz+Uq9e2bVu4uroqFMuyZcsQGxtb4qu0o2YpoqTt8SbK7pdOnTqhWrVqRc7L398fRkZGsvfm5ubo1asX/vnnH+Tl5SEjIwMxMTHo168fzMzMZPV0dXUxdOhQ3L9/H1evXi021vT0dEyaNAl16tSBnp4e9PT0YGZmhoyMDFy5cqXEdT1+/DiSkpIQEBAgt65SqRTdunVDbGxsoS5rVHUxt1QMzCnyyiun7Nq1C1ZWVujVq5fc9mvatCns7e3ltp+NjQ02btyIuLg4tG3bFjVr1sTSpUuVXub7779fqCwxMRGffPIJXFxcoKenB319fdm2Kuq4/vq2HTBgAPT09GT7SNF9VZwzZ86gd+/esLGxga6uLvT19TFs2DDk5eXh2rVrJa6jMtuVyp+eshMEBQXBy8sLI0aMQF5eHnx9fXH8+HGYmJhg165dHDJNw6ytreXeGxgYwMTERO6P0YLy1NRU2fvHjx/jxo0b0NfXL3K+r/cffRMbGxu594aGhgAgu+n62bNnAAAHB4dC0zo6OsoSTUE9e3v7QvWKKitKnTp1IIQosZ6OjvpGxy5pe7yJsvulqG1aoLjtmJ2djfT0dKSlpUEIUex+Af5/nxRl8ODBOHjwIKZNm4aWLVvCwsICEokE3bt3V3hdAaBfv37F1klKSoKpqWmJ86LKh7mlYmJOkVdeOeXx48d4/vw5DAwMivz89e3n4+ODhg0b4ty5cxg9erTSx0kTExNYWFjIlUmlUnTt2hUPHz7EtGnT4OXlBVNTU0ilUrRu3brI4/rr21FPTw82Njayba/ovirK3bt38fbbb6NevXr48ccf4ebmBiMjI5w8eRKffvqpwnlGme1K5UvpRsnmzZsxZMgQAMDOnTsRHx+Pf//9F2vWrMHUqVNx7NgxlQdJ6mdrawtjY2OsXLmy2M9VpSDBPHr0qNBoVQ8fPpQtq6BeQkJCoXkkJCQoNH55586dERUVVWK9gICACjkkr7L75dWb+V5X3HY0MDCAmZkZ9PT0oKOjg0ePHhWqV3BTaXHfg5SUFOzatQszZszA5MmTZeVZWVlISkoqNqai1mXhwoVo3bp1kXXs7OwUmhdVPswtVQtzStlySsFN/Xv37i3yc3Nzc7n3M2bMwIULF9C8eXNMnz4dPXv2RK1atRReXlG54+LFizh37hwiIiIQEBAgK79x40ax80lISICTk5PsfW5uLp49eybb9oruq6Js374dGRkZ2Lp1q9yVLWWGOVZ2u1L5UrpR8vTpU1lL+K+//kL//v1Rt25djBgxAj/99JPKA6Ty0bNnT4SEhMDGxgbu7u5vrGtoaFimoWY7deoEAFi7dq1sRBAAiI2NxZUrVzB16lQA+UPsGhkZYd26dXKXlY8fP447d+4olECWLVuGtLS0EuupMkGWRnHbVJn9UpKtW7di/vz5sjOcaWlp2LlzJ95++23o6urC1NQUPj4+2Lp1K7777jsYGxsDyD9btnbtWjg7O6Nu3bpFzlsikUAIITuDWWD58uXIy8srtK5A4StF7dq1g5WVFS5fvozPPvusTOtKlQ9zS9XCnFK2nNKzZ09s2LABeXl58PHxeWPdyMhIhIaG4ptvvkFQUBCaNm2KDz74AMeOHZNdEVDmCn2BgobK68f1ZcuWFTvNunXr0Lx5c9n7P/74A7m5ubIrnYruK0XjEULg119/LVT3TTlV0e1K5U/pRomdnR0uX74MBwcH7N27F4sXLwaQP6a1rq6uygOk8hEUFIQtW7agffv2GDt2LBo3bgypVIq7d+9i//79+Oqrr2Q/YC8vLxw+fBg7d+6Eg4MDzM3NUa9ePYWXVa9ePXz88cdYuHAhdHR08O677+L27duYNm0aXFxcMHbsWABAtWrVMH78eMyePRsjR45E//79ce/ePQQHByt8qV2ZuDTJy8sLGzZswMaNG1GrVi0YGRnBy8tLqf1SEl1dXfj5+WHcuHGQSqWYN28eUlNTMXPmTFmd0NBQ+Pn5oWPHjhg/fjwMDAywePFiXLx4Eb///nuxV2IsLCzQvn17zJ8/H7a2tnBzc0NUVBRWrFgBKysrubqNGjUCAPzyyy8wNzeHkZER3N3dYWNjg4ULFyIgIABJSUno168fatSogSdPnuDcuXN48uQJlixZUroNTBUec0vVwpxSNgMHDsS6devQvXt3fPnll2jVqhX09fVx//59HDp0CH369MF7772HR48eYciQIfD19cWMGTOgo6ODjRs3on379pg4caLsAYK1a9eGsbEx1q1bh/r168PMzAyOjo6yrrlF8fT0RO3atTF58mQIIWBtbY2dO3ciMjKy2Gm2bt0KPT09+Pn54dKlS5g2bRqaNGmCAQMGAFB8XxXFz88PBgYGGDRoECZOnIiXL19iyZIlRd535uXlha1bt2LJkiVo3rw5dHR00KJFC4W3K2mIsnfGz5gxQ1haWgpPT09Rs2ZN8fLlSyGEECtWrBCtW7dW4T34pIyCkS9eHU5PiPzRK0xNTQvV9/X1FQ0bNpQrS09PF998842oV6+eMDAwEJaWlsLLy0uMHTtWJCQkyOqdPXtWtGvXTpiYmMiNWFIwUsrro60UNVJTXl6emDdvnqhbt67Q19cXtra2YsiQIbIhCgtIpVIRGhoqXFxchIGBgWjcuLHYuXOn8PX1VWiklPKEYkbfUmR73L59W3Tt2lWYm5vLhlUsoOh+ASA+/fTTQnEVjL41b948MXPmTOHs7CwMDAyEt7e3bNjHVx05ckR06tRJmJqaCmNjY9G6dWuxc+fOEtfh/v374v333xfVqlUT5ubmolu3buLixYvC1dW10Eg0CxYsEO7u7kJXV7fQiDBRUVGiR48ewtraWujr6wsnJyfRo0cPsWnTpiK2OlUVzC0VC3OK5uXk5IjvvvtONGnSRBgZGQkzMzPh6ekpRo0aJa5fvy5yc3OFr6+vsLOzkxvNUQgh5s+fLwCIbdu2ycp+//134enpKfT19eXyVXH7VAghLl++LPz8/IS5ubmoVq2a6N+/v7h7926hfFfwfTl9+rTo1auXMDMzE+bm5mLQoEHi8ePHcvNUdF8VNfrWzp07ZdvDyclJTJgwQezZs6fQ9yEpKUn069dPWFlZCYlEIl79c7ek7UqaIxFCgTu2XrN582bcu3cP/fv3l/UJXL16NaysrNCnT58yNJGISNVu374Nd3d3zJ8/H+PHj9d0OETFYm4hqpyCg4Mxc+ZMPHnyROPdoanyUrj71uDBg9G3b19069atyNFxXr0JioiISBHMLUREBAAKj1lXr149zJs3DzVq1EDXrl3x888/4969e+qMjYiIqjjmFiIiAgClu2/dv38fO3bswJ9//omoqCg0aNAAvXv3Rp8+feDt7a2uOImIqApjbiEi0m5KP93H2dkZY8aMwb59+/DkyRNMnjwZ169fR+fOneHq6orPPvsMly5dUmhe//zzD3r16gVHR0dIJBJs375d7nMhBIKDg+Ho6AhjY2N06NCh0LyzsrLw+eefw9bWFqampujduzfu37+v7GoREZEGMbcQEWm3Mj1y1NzcHAMGDMC6devw5MkTrFy5Erq6uoiOjlZo+oyMDDRp0gSLFi0q8vOwsDCEh4dj0aJFiI2Nhb29Pfz8/OTGCA8KCsK2bduwYcMGHD16FOnp6ejZs2ehZyMQEVHlwNxCRKSFNDn016vw2tB1UqlU2Nvbi7lz58rKXr58KSwtLcXSpUuFEEI8f/5c6Ovriw0bNsjqPHjwQOjo6Ii9e/eWW+xERFQxMbcQEVUOSj888dmzZ5g+fToOHTqExMRESKVSuc+TkpJU0liKj49HQkICunbtKiszNDSEr68vjh8/jlGjRuH06dPIycmRq+Po6IhGjRrh+PHjeOedd4qcd1ZWFrKysmTvpVIpkpKSYGNjU+zD4YiI1E0IgbS0NDg6OkJHp0wXsisd5hYiItWrTHlF6UbJkCFDcPPmTYwYMQJ2dnZqO9AmJCQAyH/K76vs7Oxw584dWR0DAwNUq1atUJ2C6YsSGhoq9xRrIqKK5N69e7LndGgL5hYiIvWpDHlF6UbJ0aNHcfToUTRp0kQd8RTyemISQpSYrEqqM2XKFIwbN072PiUlBTVr1sS9e/dgYWFRtoCJiEopNTUVLi4uMDc313Qo5Y65hYhI9SpTXlG6UeLp6YnMzEx1xCLH3t4eQP4ZKwcHB1l5YmKi7AyXvb09srOzkZycLHdGKzExEW3bti123oaGhjA0NCxUbmFhwcRBRBqnjV19mFuIiNSnMuQVpTuXLV68GFOnTkVUVBSePXuG1NRUuZequLu7w97eHpGRkbKy7OxsREVFyZJC8+bNoa+vL1fn0aNHuHjx4hsTBxERVSzMLURE2k3pKyVWVlZISUlBp06d5MoLLmsrM1xieno6bty4IXsfHx+Ps2fPwtraGjVr1kRQUBBCQkLg4eEBDw8PhISEwMTEBIMHDwYAWFpaYsSIEfjqq69gY2MDa2trjB8/Hl5eXujSpYuyq0ZERBrC3EJEpN2UbpR8+OGHMDAwwPr168t8M+KpU6fQsWNH2fuCvrgBAQGIiIjAxIkTkZmZiTFjxiA5ORk+Pj7Yv3+/XL+4H374AXp6ehgwYAAyMzPRuXNnREREQFdXt9RxERFR+WJuISLSbhIhhFBmAhMTE5w5cwb16tVTV0zlLjU1FZaWlkhJSWG/XyLSGG0+FjG3EBGpXmU6Dil9T0mLFi1w7949dcRCRERairmFiEi7Kd196/PPP8eXX36JCRMmwMvLC/r6+nKfN27cWGXBERGRdmBuISLSbkp33yrqaZASiaRUNyNWFJXp0hYRVV3afCxibiEiUr3KdBxS+kpJfHy8OuIgIiItxtxCRKTdlG6UuLq6qiMOIiLSYswtRETaTaEb3aOjoxWeYUZGBi5dulTqgIiISDswtxARUQGFGiXDhg2Dn58f/vjjD6SnpxdZ5/Lly/j6669Rp04dxMXFqTRIIiKqephbiIiogELdty5fvoxly5Zh+vTp+PDDD1G3bl04OjrCyMgIycnJ+Pfff5GRkQF/f39ERkaiUaNG6o6biIgqOeYWIiIqoPToW3FxcThy5Ahu376NzMxM2NrawtvbGx07doS1tbW64lSryjQyARFVXdp8LGJuISJSvcp0HFL6RvdmzZqhWbNm6oiFiIi0FHMLEZF2U/qJ7kRERERERKrERgkREREREWkUGyVERERERKRRbJQQEREREZFGKd0oiY+PV0ccRESkxZhbiIi0m9KNkjp16qBjx45Yu3YtXr58qY6YiIhIyzC3EBFpN6UbJefOnYO3tze++uor2NvbY9SoUTh58qQ6YiMiIi3B3EJEpN2UbpQ0atQI4eHhePDgAVatWoWEhAS89dZbaNiwIcLDw/HkyRN1xElERFUYcwsRkXYr9Y3uenp6eO+99/DHH39g3rx5uHnzJsaPHw9nZ2cMGzYMjx49UmWcRESkBZhbiIi0U6kbJadOncKYMWPg4OCA8PBwjB8/Hjdv3sTff/+NBw8eoE+fPqqMk4iItABzCxGRdtJTdoLw8HCsWrUKV69eRffu3bFmzRp0794dOjr57Rt3d3csW7YMnp6eKg+WiIiqJuYWIiLtpvSVkiVLlmDw4MG4e/cutm/fjp49e8qSRoGaNWtixYoVKgkwLS0NQUFBcHV1hbGxMdq2bYvY2FjZ50IIBAcHw9HREcbGxujQoQMuXbqkkmUTEVH5YG4hItJuSjdKIiMjMWnSJNjb28uVCyFw9+5dAICBgQECAgJUEuDIkSMRGRmJ3377DRcuXEDXrl3RpUsXPHjwAAAQFhaG8PBwLFq0CLGxsbC3t4efnx/S0tJUsnwiIlI/5hYiIu0mEUIIZSbQ1dXFo0ePUKNGDbnyZ8+eoUaNGsjLy1NZcJmZmTA3N8eff/6JHj16yMqbNm2Knj17YtasWXB0dERQUBAmTZoEAMjKyoKdnR3mzZuHUaNGKbSc1NRUWFpaIiUlBRYWFiqLn4hIGdp8LGJuISJSvcp0HFL6SklxbZj09HQYGRmVOaBX5ebmIi8vr9B8jY2NcfToUcTHxyMhIQFdu3aVfWZoaAhfX18cP3682PlmZWUhNTVV7kVERJrD3EJEpN0UvtF93LhxAACJRILp06fDxMRE9lleXh5iYmLQtGlTlQZnbm6ONm3aYNasWahfvz7s7Ozw+++/IyYmBh4eHkhISAAA2NnZyU1nZ2eHO3fuFDvf0NBQzJw5U6WxEhGR8phbiIgIUKJRcubMGQD5Z7MuXLgAAwMD2WcGBgZo0qQJxo8fr/IAf/vtN3z00UdwcnKCrq4umjVrhsGDByMuLk5WRyKRyE0jhChU9qopU6bIEiGQf2nLxcVF5bETEdGbMbcQERGgRKPk0KFDAIDhw4fjxx9/LLd+abVr10ZUVBQyMjKQmpoKBwcHfPDBB3B3d5fdEJmQkAAHBwfZNImJiYXOcL3K0NAQhoaGao+diIjejLmFiIiAUtxTsmrVKo3cKGNqagoHBwckJydj37596NOnjyx5REZGyuplZ2cjKioKbdu2LfcYiYiodJhbiIi0m0JXSvz9/REREQELCwv4+/u/se7WrVtVEliBffv2QQiBevXq4caNG5gwYQLq1auH4cOHQyKRICgoCCEhIfDw8ICHhwdCQkJgYmKCwYMHqzQOIiJSLeYWIiIqoFCjxNLSUtaP1tLSUq0BvS4lJQVTpkzB/fv3YW1tjffffx9z5syBvr4+AGDixInIzMzEmDFjkJycDB8fH+zfvx/m5ublGicRESmHuYWIiAoo/ZySqqgyjeFMRFUXj0VVC/cnEWlaZToOKX1PSWZmJl68eCF7f+fOHSxYsAD79+9XaWBERKQ9mFuIiLSb0o2SPn36YM2aNQCA58+fo1WrVvj+++/Rp08fLFmyROUBEhFR1cfcQkSk3ZRulMTFxeHtt98GAGzevBn29va4c+cO1qxZg59++knlARIRUdXH3EJEpN2UbpS8ePFCdqPf/v374e/vDx0dHbRu3fqNT7olIiIqDnMLEZF2U7pRUqdOHWzfvh337t3Dvn370LVrVwD5D5Wq6DfQEBFRxcTcQkSk3ZRulEyfPh3jx4+Hm5sbfHx80KZNGwD5Z7a8vb1VHiAREVV9zC1ERNqtVEMCJyQk4NGjR2jSpAl0dPLbNSdPnoSFhQU8PT1VHqS6Vabh0oio6tL2YxFzCxGRalWm45BCD098nb29Pezt7eXKWrVqpZKAiIhIOzG3EBFpL6UbJRkZGZg7dy4OHjyIxMRESKVSuc9v3bqlsuCIiEg7MLcQEWk3pRslI0eORFRUFIYOHQoHBwdIJBJ1xEVERFqEuYWISLsp3SjZs2cPdu/ejXbt2qkjHiIi0kLMLURE2k3p0beqVasGa2trdcRCRERairmFiEi7Kd0omTVrFqZPn44XL16oIx4iItJCzC1ERNpN6e5b33//PW7evAk7Ozu4ublBX19f7vO4uDiVBUdERNqBuYWISLsp3Sjp27evGsIgIiJtxtxCRKTdlGqU5ObmAgA++ugjuLi4qCUgIiLSLswtRESk1D0lenp6+O6775CXl6eueIiISMswtxARkdI3unfu3BmHDx9WQyhERKStmFuIiLSb0veUvPvuu5gyZQouXryI5s2bw9TUVO7z3r17qyw4IiLSDswtRETaTSKEEMpMoKNT/MUViURSKS+/p6amwtLSEikpKbCwsNB0OESkpbT5WMTcQkSkepXpOKT0lRKpVKqOOIiISIsxtxARaTel7yl51cuXL1UVR5Fyc3PxzTffwN3dHcbGxqhVqxa+/fZbueQlhEBwcDAcHR1hbGyMDh064NKlS2qNi4iI1Ie5hYhI+yjdKMnLy8OsWbPg5OQEMzMz3Lp1CwAwbdo0rFixQqXBzZs3D0uXLsWiRYtw5coVhIWFYf78+Vi4cKGsTlhYGMLDw7Fo0SLExsbC3t4efn5+SEtLU2kspHkxMTH47bffEBMTo+lQqALg96FqYW4hTeBxhF7H74TmKN19a86cOVi9ejXCwsLwv//9T1bu5eWFH374ASNGjFBZcNHR0ejTpw969OgBAHBzc8Pvv/+OU6dOAcg/k7VgwQJMnToV/v7+AIDVq1fDzs4O69evx6hRo1QWC2nWpEmTELZkCWBoCAAYMWIExo8fL1enqNujirthqqRbqYr6tDTTqGp6dS9bHfNS5mY1JW9tw6aFC/F9WJjs/cSJEzFv3jyl5kEVC3MLlbdJkyYhLCwMsAKgV3ReAYrLLUWUlXicLvrz0k6nyPRlmVYV06tjXiXNpyzz/Pnnn7F27VpZ+ZAhQ/Dpp5+qbP7KUDYvFrUsU31T1DatXar5aILSN7rXqVMHy5YtQ+fOnWFubo5z586hVq1a+Pfff9GmTRskJyerLLi5c+di6dKl2L9/P+rWrYtz586ha9euWLBgAQYNGoRbt26hdu3aiIuLg7e3t2y6Pn36wMrKCqtXry5yvllZWcjKypK9T01NhYuLS6W4CUgb7fnnH3RfuBBo1EjToVBFMX8+kJEhV3TixAn4+PhoKCDVqEw3JKoacwuVp5iYGLR+tzXQC0AtTUdDpB7NHJrh0MBDlSavKH2l5MGDB6hTp06hcqlUipycHJUEVWDSpElISUmBp6cndHV1kZeXhzlz5mDQoEEAgISEBACAnZ2d3HR2dna4c+dOsfMNDQ3FzJkzVRorqZ4QAmvPn8foqKj8BokQwCt9zU1NTWH435WTApIS5imRFK5RXtNUpumVmVd5zzM9PR1PijiXcu3atUrfKNFmzC1UXvKkefjx5I/AGAD6APIAZOd/VlReAQBJCUe4ovNE+UxTmaZXdD6lmacy8y1qnunp6Xjy5Emh8hrVa8DM3KxU8yxxGjVthwI1LWsqPY0mKd0oadiwIY4cOQJXV1e58k2bNsmdUVKFjRs3Yu3atVi/fj0aNmyIs2fPIigoCI6OjggICJDVe32nCiHeuKOnTJmCcePGyd4XnM2iiuNuSgpG7dqFvTdu5Bc8egTs2JH/738OVoEz46S8mJgYtP7mm0LldevW1UA0pCrMLVQeLiZexIgdI3Ay6WR+gyQewE4ASfmfHzxxkHlFS8XExKB169aFynec2FGpvxOpqamaDkFhSjdKZsyYgaFDh+LBgweQSqXYunUrrl69ijVr1mDXrl0qDW7ChAmYPHkyBg4cCCC/b/GdO3cQGhqKgIAA2NvbA8g/q+Xg4CCbLjExsdAZrlcZGhoWeSaENE8qBH45fRoTIiORnp0NQ11dzPD1xbNdu/D9Kw2SSZMmVeqDBJWej48PJk6cmN8X/D/8PlR+zC2kTjl5OZh7dC5m/TMLOdIcWBpaonVqa+xbvU9Wh8cR7cbconlKN0p69eqFjRs3IiQkBBKJBNOnT0ezZs2wc+dO+Pn5qTS4Fy9eFHqglq6urmzYRnd3d9jb2yMyMlJ2Ji07OxtRUVG86bUSik9OxogdO3Do9m0AQFsXF6zo3RuetrbA22+jv78/rl27hrp16/IgoeXmzZsHf34fqhTmFlKXswlnMfzP4TibcBYA0KtuLyzpsQROFk6I6RPD4wjJMLdoltI3upenwMBAHDhwAMuWLUPDhg1x5swZfPzxx/joo49kiWHevHkIDQ3FqlWr4OHhgZCQEBw+fBhXr16Fubm5QsvR5ptLKwKpEFh66hQmRkYiIycHxnp6CO3cGZ+1agXdNzzlmaiq4bGofDC3aIecvByEHAnB7COzkSvNhbWxNRa+uxCDGg1Sqi8/UWVWmY5DSl8pqVWrFmJjY2FjYyNX/vz5czRr1kw2trwqLFy4ENOmTcOYMWOQmJgIR0dHjBo1CtOnT5fVmThxIjIzMzFmzBgkJyfDx8cH+/fvVzhpkGbdfv4cI3bswN/x8QCA9q6uWNG7N+pYW2s4MiIqT8wtpErnH59HwPYA2dWR9zzfw5IeS2BnVnz3OyLSLKWvlOjo6CAhIQE1atSQK3/8+DFq1qwpNxxiZVGZWpFVhRACK86cwdh9+5CenQ1jPT3M69IFn7ZqBR2ewSItpc3HIuYWUoVcaS7CjoUh+HAwcqQ5sDa2xs/df8YHDT/g1RHSSpXpOKTwlZIdO3bI/r9v3z5YWlrK3ufl5eHgwYNwc3NTaXBUNT1KS8P/du7E7uvXAQDtXFwQ0bcvr44QaSHmFlKVa8+uIWB7AE7cPwEA6F2vN5b1XAZ7M3sNR0ZEilC4UdK3b18A+UMkvjpkIgDo6+vDzc0N33//vUqDo6pn06VL+GT3biRlZsJQVxdzOnVCUOvWvHeESEsxt1BZCSGwOHYxJkROQGZuJiwNLfHTuz9haOOhvDpCVIko3Ch5dVSS2NhY2Nraqi0oqnqev3yJz/fswdrz5wEAzRwcsKZvXzR8rasGEWkX5hYqi4dpD/HRnx9h3838oX271OqClb1XwsWSz4chqmyUvtE9/r8bkokUdfj2bQzbtg33UlOhI5Hg67fewjRfXxjo6mo6NCKqIJhbSFmbL2/GqF2jkJSZBCM9I4R1CcOnrT6FjoRX3okqI6UbJQBw8OBBHDx4EImJibKzXAVWrlypksCo8svOy8O0v//G/OPHIQDUrlYNv733HtrwCcdEVATmFlJEWlYavtj7BSLORgAAmjs0x1r/tfC09dRsYERUJko3SmbOnIlvv/0WLVq0gIODA/trUpGuPn2KwVu3Iu6/p7CP9PbGD926wczAQMOREVFFxNxCioi5H4PBWwfjVvIt6Eh0MOWtKZjuOx0GuswtRJWd0o2SpUuXIiIiAkOHDlVHPFTJFQz1++XevXiRkwNrY2Ms79UL79Wvr+nQiKgCY26hN8mT5mHu0bmYcXgG8kQealrWxNr31uJt17c1HRoRqYjSjZLs7Gy0bdtWHbFQJZecmYmPd+3C5suXAQCd3d2x5r334MiHjRFRCZhbqDj3U+9j6LahOHz7MABgYKOBWNJjCayMrDQaFxGpltJ3g40cORLr169XRyxUiR2/dw9Nly3D5suXoaejg3ldumD/0KFskBCRQphbqCg7ru5Ak6VNcPj2YZjqmyKiTwTW+69ng4SoClL6SsnLly/xyy+/4MCBA2jcuDH09fXlPg8PD1dZcFTxSYXAvKNHMe3QIeQJgdrVquH3999HSycnTYdGRJUIcwu9Kis3CxMjJ+Knkz8BAJo5NMOG9zfAw8ZDw5ERkboo3Sg5f/48mjZtCgC4ePGi3Ge8MVG7JGZkYMjWrYi8dQsAMKhRIyzt2RMWhoYajoyIKhvmFipwM+kmBmwegLhHcQCAsa3HYm6XubyZnaiKU7pRcujQIXXEQZXM4du3MXjLFjxKT4exnh4Wde+O4U2b8o8HIioV5hYCgE2XNmHkzpFIzUqFjbENIvpGoGfdnpoOi4jKQameU0LaSyoEQo8cwfTDhyEVAg2qV8cf/frxyexERFRqWblZGL9/PBbFLgIAtHNphw39NsDZwlnDkRFReVGoUeLv74+IiAhYWFjA39//jXW3bt2qksCo4nn24gWGbtuGPTduAAACmjTBz927w5TPHiGiUmBuIQC48/wO+m/qj9iHsQCASe0mYXan2dDT4XlTIm2i0C/e0tJS1i3H0tJSrQFRxXTywQP0++MP3EtNhZGeHhZ3747h3t6aDouIKjHmFtpzfQ8+3Pohkl8mo5pRNfz23m/oUbeHpsMiIg2QCCGEpoPQtNTUVFhaWiIlJQUWFhaaDqdCEUJg2enT+HLvXmTn5aGOtTU29++PJvb2mg6NqMrhsahq4f4sXp40D99GfYtZ/8yCgEBLx5bY1H8TXK1cNR0aUZVSmY5DvDZKxcrMycHo3bux+tw5AMB7np5Y1acPLI2MNBwZERFVVkmZSfhw64fYe2MvAGB0i9H44Z0fYKjHkRuJtBkbJVSk28+fw3/jRpxJSICORIK5nTtjfNu2HF2LiIhK7WzCWfhv9Ef883gY6xljWc9lGNpkqKbDIqIKgI0SKuTArVv4YPNmJGVmwtbEBBv79UMnd3dNh0VERJXY+gvrMXLHSGTmZsLdyh3bPtiGJvZNNB0WEVUQbJSQjBACP5w4gQmRkZAKgRaOjtgyYABq8gZUIiIqpVxpLiYfmIzvo78HAHSr0w3r/NfB2thaw5ERUUVSpkbJy5cvYcT7C6qEzJwcfLxrF9aePw8gf7jfpT17wkiP7VYiKl/MLVVHUmYSBm4eiMhbkQCAr9/6Gt92/Ba6OroajoyIKhodZSeQSqWYNWsWnJycYGZmhlu3bgEApk2bhhUrVqg8QDc3N0gkkkKvTz/9FED+2f3g4GA4OjrC2NgYHTp0wKVLl1QeR1X2IDUV7SMisPb8eehKJPipWzes6tOHDRIiKjflmVuYV8rH5SeX0erXVoi8FQkTfRP80e8PzOk8hw0SIiqS0o2S2bNnIyIiAmFhYTB45aF5Xl5eWL58uUqDA4DY2Fg8evRI9oqMzD/b0r9/fwBAWFgYwsPDsWjRIsTGxsLe3h5+fn5IS0tTeSyaEhMTg99++w0xMTEqn++UX35Bk8WLcerhQ1gbGyNy6FB87uPDG9qJqFyVZ25hXlFvXlmzZg1C/gxB6+WtcTP5JlwtXRE9Ihr9G/ZX6bKIqIoRSqpdu7Y4cOCAEEIIMzMzcfPmTSGEEFeuXBFWVlbKzk5pX375pahdu7aQSqVCKpUKe3t7MXfuXNnnL1++FJaWlmLp0qUKzzMlJUUAECkpKeoIuUwmTpwooK8vYGwsYGwsPp84UTx78aLMr+GTJgkMHCgQHCwQHCxsp08XN5OSNL26RFqtIh+L1E2TuUUdeUWIirs/J06cKAAIGEDAGOLziZ+LZy+elfn1+cTPBZwhEAiB4PxX+1XtRWJ6oqZXmUhrVdTjUFGU7p/z4MED1KlTp1C5VCpFTk5OWdtIb5SdnY21a9di3LhxkEgkuHXrFhISEtC1a1dZHUNDQ/j6+uL48eMYNWpUkfPJyspCVlaW7H1qaqpa4y6tmJgYhO3eDUyZAujkX9RaCGBhWFjZZ25sDHh6AlIpcPo0nkZG4kn37qjl41P2eRMRKUlTuUVVeQWoHLklJiYGYWFhQBsA7+SXLcRCLAxbWPaZmwAY+d//cwBEA3Nmz0F10+plnzcRVXlKd99q2LAhjhw5Uqh806ZN8Pb2VklQxdm+fTueP3+OwMBAAEBCQgIAwM7OTq6enZ2d7LOihIaGwtLSUvZycXFRW8xlcfXqVaB9e1mDRKWEAK5eBZYsAXbvBrKzce3aNdUvh4hIAZrKLarKK0DlyC3Xrl3LH+LmLTUtIA/AOeSfQfsbiL8Rr6YFEVFVo/SVkhkzZmDo0KF48OABpFIptm7diqtXr2LNmjXYtWuXOmKUWbFiBd599104OjrKlb9+/4MQ4o33REyZMgXjxo2TvU9NTa2QySOjenXAzg7IzgZ++AH47wzc0aNH4VOGKxoxMTF4q127/IbJK+rWrVumeImISktTuUVVeQWoHLmlbt26QEMApgCeI7/xIFSUV956C8jvGCa/PCIiBSh9Cr5Xr17YuHEj/vrrL0gkEkyfPh1XrlzBzp074efnp44YAQB37tzBgQMHMHLkSFmZvb09ABQ6e5WYmFjoLNerDA0NYWFhIfeqiA4W3FR5/jyQmQlIpZg0YQLatWkDPR2dUr/atWmDiRMmyC1r0qRJZUpIRERloYncosq8AlSO3NKqVSvY9f5vPU4ByAMmTZiEdm3aQU9Hr9Svdm3aYeL4iXINEuYVIlJGqcZ8feedd/DOO++oOpY3WrVqFWrUqIEePXrIytzd3WFvb4/IyEjZ5f3s7GxERUVh3rx55Rqfqt1LScH2f/8FAKz98ktIBwxA3bp1VXaAnzdvHvz9/XHt2jWVzpeIqLTKO7doW14BgJgHMXis+xgGOgb4YcQPaP5dc+YVIqoQlG6UxMbGQiqVFjrYxMTEQFdXFy1atFBZcAWkUilWrVqFgIAA6L3y7AyJRIKgoCCEhITAw8MDHh4eCAkJgYmJCQYPHqzyOMrTstOnkScEOri54cMuXdSyDB8fHyYNIqoQyju3aGNeAYBFJxcBAAY3HowxfcaofP7MK0RUWkp33/r0009x7969QuUPHjyQPXhK1Q4cOIC7d+/io48+KvTZxIkTERQUhDFjxqBFixZ48OAB9u/fD3Nzc7XEUh6ycnPxy+nTAIDPWrbUcDREROpX3rlF2/IKADxOf4w/Lv0BAPis5WcajoaISJ5EiNfudi6BmZkZzp8/j1q1asmVx8fHo3HjxpXy4VKpqamwtLRESkpKhegDvPb8eQzdtg1O5ua4HRQEPXWMvkVEFU5FOxaVJ+YW9Zv9z2xMOzQNPk4+ODHyhKbDIaJyUNGOQ2+i9F+7hoaGePz4caHyR48eyV0Cp9L7OTYWAPBJixZskBCRVmBuUa9caS6WnV4GAPisFa+SEFHFo/RfvH5+fpgyZQpSUlJkZc+fP8fXX3+t1tG3tEXco0c4cf8+9HV08L9mzTQdDhFRuWBuUa8dV3fgfup9VDepjv4N+ms6HCKiQpQ+/fT999+jffv2cHV1lY1McvbsWdjZ2eG3335TeYDa5ueTJwEA/Ro0gJ2ZmYajISIqH8wt6vVz7M8AgJHNRsJQz1DD0RARFaZ0o8TJyQnnz5/HunXrcO7cORgbG2P48OEYNGgQ9PX11RGj1kjOzMT6ixcBAJ/yBnci0iLMLepz5ckV/B3/N3QkOvikxSeaDoeIqEil6qhramqKjz/+WNWxaL1VZ8/iZW4umtjZoW0FewowEZG6Mbeox5JTSwAAver2Qk3LmhqOhoioaKVqlFy7dg2HDx9GYmIipFKp3GfTp09XSWDaRioElpw6BSD/KolEItFwRERE5Yu5RfXSs9Ox+txqAMCnLdUzbD8RkSoo3Sj59ddfMXr0aNja2sLe3l7uj2eJRMLEUUoHbt3CjaQkWBoaYrCXl6bDISIqV8wt6rH+wnqkZqXCw9oDnWt11nQ4RETFUrpRMnv2bMyZMweTJk1SRzxaq+AqSUCTJjA1MNBwNERE5Yu5RfWEELKuW6NbjIaOhEPME1HFpfQRKjk5Gf37czhBVbqXkoIdV68CyH82CRGRtmFuUb0T90/gbMJZGOkZIaBpgKbDISJ6I6UbJf3798f+/fvVEYvW+jUuDlIh0NHNDfWrV9d0OERE5Y65RfUKrpIMajQI1sbWGo6GiOjNlO6+VadOHUybNg0nTpyAl5dXoaEav/jiC5UFpw2y8/Lwa1wcAGA0r5IQkZZiblGtpy+eYuOljQDyu24REVV0EiGEUGYCd3f34mcmkeDWrVtlDqq8paamwtLSEikpKbCwsCjXZW+6dAkDNm+GvZkZ7gYFQV9Xt1yXT0QVhyaPRZrG3KJa84/Nx8QDE9HCsQVi/xdbrssmooqjMuUVpa+UxMfHqyMOrbX09GkAwEhvbzZIiEhrMbeojlRIsez0MgDAJ835sEQiqhw4FIcGXX36FH/Hx0NHIsH/mjfXdDhERFQFHLx1EDeTb8LS0BIDGw3UdDhERAop1cMT79+/jx07duDu3bvIzs6W+yw8PFwlgWmDZf9dJenh4YGalpYajoaISLOYW1Sj4Ab3YU2GwdTAVMPREBEpRulGycGDB9G7d2+4u7vj6tWraNSoEW7fvg0hBJo1a6aOGKukzJwcRJw9C4DDABMRMbeoxoPUB9hxdQcAYFTzURqOhohIcUp335oyZQq++uorXLx4EUZGRtiyZQvu3bsHX19fjjGvhE2XLyP55Uu4Wlrindq1NR0OEZFGMbeoxoozK5An8vB2zbfRsEZDTYdDRKQwpRslV65cQUBA/kOY9PT0kJmZCTMzM3z77beYN2+eygOsqpb+9wT3j5s3h64Ob+0hIu3G3FJ2udJc/Br3KwDgkxa8wZ2IKhel/xo2NTVFVlYWAMDR0RE3b96Uffb06VPVRVaFXXj8GNH370NPRwcfeXtrOhwiIo1jbim7Pdf34H7qfdgY2+D9+u9rOhwiIqUofU9J69atcezYMTRo0AA9evTAV199hQsXLmDr1q1o3bq1OmKscgpucO/r6Ql7MzMNR0NEpHnMLWVXMAzw8KbDYahnqOFoiIiUo3SjJDw8HOnp6QCA4OBgpKenY+PGjahTpw5++OEHlQdY1bzIycFv588DAEZxGGAiIgDMLWV1N+Uu9tzYAwD4X/P/aTgaIiLlKd19q1atWmjcuDEAwMTEBIsXL8b58+exdetWuLq6qjzABw8eYMiQIbCxsYGJiQmaNm2K0/9daQAAIQSCg4Ph6OgIY2NjdOjQAZcuXVJ5HKqy8eJFpGZloVa1auj0hicYExFpE+aWslkRtwJSIUVHt46oa1NX0+EQESmtQt9hnZycjHbt2kFfXx979uzB5cuX8f3338PKykpWJywsDOHh4Vi0aBFiY2Nhb28PPz8/pKWlaS7wYsTExGDOvn0AgI+bNYOORKLhiIiItE9Vyy3Hoo9h4bGFAICPm3+s4WiIiEpHoe5b1apVg0TBP6CTkpLKFNCr5s2bBxcXF6xatUpW5ubmJvu/EAILFizA1KlT4e/vDwBYvXo17OzssH79eowaVXHGaJ80aRLCVq8GRo8G8vJwb+dO4K23NB0WEZHGMLeU3aRJkxD2ZxgwCEAGEPtbLAbO41PciajykQghREmVVq9eLfv/s2fPMHv2bLzzzjto06YNACA6Ohr79u3DtGnTMHbsWJUF16BBA7zzzju4f/8+oqKi4OTkhDFjxuB//8vvL3vr1i3Url0bcXFx8H5lFKs+ffrAyspKLu5XZWVlyUZ5AYDU1FS4uLggJSUFFhYWKou/QExMTP6Nmt27A61aAZcuAZs24cSJE/Dx8VH58oiockpNTYWlpaXajkUVDXNL2chyy2AAdQEcAxAJ5hYikqlMeUWhKyUFY8cDwPvvv49vv/0Wn332mazsiy++wKJFi3DgwAGVJo5bt25hyZIlGDduHL7++mucPHkSX3zxBQwNDTFs2DAkJCQAAOzs7OSms7Ozw507d4qdb2hoKGbOnKmyOEty7dq1/P84Oub/+1+/5WvXrjFxEJHWYm4pm2vXrgEWAOr8VxD3/+XMLURU2Sh9T8m+ffvQrVu3QuXvvPMODhw4oJKgCkilUjRr1gwhISHw9vbGqFGj8L///Q9LliyRq/f65X8hxBu7BEyZMgUpKSmy171791Qa9+vq1v3vpsPly4GVK4H4ePlyIiItx9yivLp16wLeyM/ktwE8e6WciKiSUbpRYmNjg23bthUq3759O2xsbFQSVAEHBwc0aNBArqx+/fq4e/cuAMDe3h4AZGe1CiQmJhY6w/UqQ0NDWFhYyL3UycfHBxMnTsx/c/cuIAQmTZrEM1lERP9hblFei5YtYOH73zL+GziMuYWIKiuln1Myc+ZMjBgxAocPH5b1+z1x4gT27t2L5cuXqzS4du3a4erVq3Jl165dkw0P6e7uDnt7e0RGRsr6/WZnZyMqKgrz5s1TaSxlNW/ePPj7++PatWuoW7cukwYR0SuYW5QXeSsSqTqpsNC3QPhX4Wjk2Yi5hYgqLaUbJYGBgahfvz5++uknbN26FUIINGjQAMeOHVP5wXDs2LFo27YtQkJCMGDAAJw8eRK//PILfvnlFwD5l9aDgoIQEhICDw8PeHh4ICQkBCYmJhg8eLBKY1EFHx8fJgwioiIwtyjv17hfAQCB3oEY8e4IDUdDRFQ2Co2+pUm7du3ClClTcP36dbi7u2PcuHGyEVKA/D6+M2fOxLJly5CcnAwfHx/8/PPPaNSokcLLqEwjExBR1cVjUfmp7LnlcfpjOP/gjFxpLi6MvoBGNRSPi4i0R2XKK6VqlNy8eROrVq3CrVu3sGDBAtSoUQN79+6Fi4sLGjZsqI441aoy7TAiqrq0/VjE3KK4eUfnYfLByWjt3BrRI6JVOm8iqjoqU15R+kb3qKgoeHl5ISYmBlu2bEF6ejoA4Pz585gxY4bKAyQioqqPuUVxQgisOLMCADDSe6SGoyEiUg2lGyWTJ0/G7NmzERkZCQMDA1l5x44dER3NszVERKQ85hbFHbl7BNeTrsPMwAwfNPpA0+EQEamE0o2SCxcu4L333itUXr16dTx79kwlQRERkXZhblFcwVWSDxp+ADMDMw1HQ0SkGko3SqysrPDo0aNC5WfOnIGTk5NKgiIiIu3C3KKYlJcp2HRpEwBghDdH3CKiqkPpRsngwYMxadIkJCQkQCKRQCqV4tixYxg/fjyGDRumjhiJiKiKY25RzIaLG5CZm4kG1RugtXNrTYdDRKQySjdK5syZg5o1a8LJyQnp6elo0KAB2rdvj7Zt2+Kbb75RR4xERFTFMbcoZvmZ/AdJjvAeAYlEouFoiIhUp9TPKbl58ybOnDkDqVQKb29veHh4qDq2clOZhksjoqqLxyLmljc5//g8mixtAn0dfTwY9wDVTaurIEoiqsoqU15R+onuBVxcXJCbm4vatWtDT6/UsyEiIpJhbineqjOrAAC96/Vmg4SIqhylu2+9ePECI0aMgImJCRo2bIi7d+8CAL744gvMnTtX5QESEVHVx9zyZtl52Vh7YS0AYHjT4RqOhohI9ZRulEyZMgXnzp3D4cOHYWRkJCvv0qULNm7cqNLgiIhIOzC3vNmua7vw9MVTOJg54J0672g6HCIilVP62vj27duxceNGtG7dWu4muwYNGuDmzZsqDY6IiLQDc8ubrTyzEgAQ0CQAejrs1kZEVY/SV0qePHmCGjVqFCrPyMjgSCBERFQqzC3Fe5j2EHtu7AEADPdm1y0iqpqUbpS0bNkSu3fvlr0vSBa//vor2rRpo7rIiIhIazC3FO+3c79BKqRo59IOdW3qajocIiK1UPoacGhoKLp164bLly8jNzcXP/74Iy5duoTo6GhERUWpI0YiIqrimFuKJoTAqrP5o27xBnciqsqUvlLStm1bHDt2DC9evEDt2rWxf/9+2NnZITo6Gs2bN1dHjEREVMUxtxQt5kEMrj67ChN9EwxoOEDT4RARqU2p7pbz8vLC6tWrVR0LERFpMeaWwiLORgAA3q//PswNzTUbDBGRGil9peSvv/7Cvn37CpXv27cPe/bsUUlQRESkXZhbCsvMycSGixsAAIFNAzUbDBGRmindKJk8eTLy8vIKlQshMHnyZJUERURE2oW5pbAdV3cgJSsFNS1rooNbB02HQ0SkVko3Sq5fv44GDRoUKvf09MSNGzdUEhQREWkX5pbCIs5FAMh/NomOROl0TURUqSh9lLO0tMStW7cKld+4cQOmpqYqCYqIiLQLc4u8B6kPsP/mfgDAsCbDNBwNEZH6Kd0o6d27N4KCguSesHvjxg189dVX6N27t0qDIyIi7cDcIm/dhXWyZ5PUsa6j6XCIiNRO6UbJ/PnzYWpqCk9PT7i7u8Pd3R3169eHjY0NvvvuO5UGFxwcDIlEIveyt7eXfS6EQHBwMBwdHWFsbIwOHTrg0qVLKo2BiIjUj7nl/wkhsPpc/ihkvMGdiLSF0kMCW1pa4vjx44iMjMS5c+dgbGyMxo0bo3379uqIDw0bNsSBAwdk73V1dWX/DwsLQ3h4OCIiIlC3bl3Mnj0bfn5+uHr1KszNOXQiEVFlwdzy/84knMHlJ5dhqGuI/g36q315REQVgdKNksePH8POzg5du3ZF165d5T47f/48GjdurLLgAEBPT0/uDFYBIQQWLFiAqVOnwt/fHwCwevVq2NnZYf369Rg1apRK4yAiIvVhbvl/a86tAQD09ewLSyNLtS+PiKgiULr7lpeXF3bs2FGo/LvvvoOPj49KgnrV9evX4ejoCHd3dwwcOFB2I2R8fDwSEhLkkpehoSF8fX1x/PjxN84zKysLqampci8iItIc5pZ8OXk5WH9hPQDe4E5E2kXpRsmkSZPwwQcf4JNPPkFmZiYePHiATp06Yf78+di4caNKg/Px8cGaNWuwb98+/Prrr0hISEDbtm3x7NkzJCQkAADs7OzkprGzs5N9VpzQ0FBYWlrKXi4uLiqNm4iIlMPckm/fzX148uIJapjWQNfaXUuegIioilC6UfLVV1/hxIkTOHbsGBo3bozGjRvD2NgY58+fV/kIKe+++y7ef/99eHl5oUuXLti9ezeA/EvpBSQSidw0QohCZa+bMmUKUlJSZK979+6pNG4iIlIOc0u+gq5bH3p9CD0dpXtYExFVWqV6GlOtWrXQsGFD3L59G6mpqRgwYEChs0rqYGpqCi8vL1y/fl3WF/j1M1eJiYklxmJoaAgLCwu5FxERaZa255bnL59jx9X8LmzsukVE2kbpRknBWawbN27g/PnzWLJkCT7//HMMGDAAycnJ6ohRJisrC1euXIGDgwPc3d1hb2+PyMhI2efZ2dmIiopC27Zt1RoHERGpFnMLsPnyZmTlZaFh9YZoYtdErcsiIqpolG6UdOrUCR988AGio6NRv359jBw5EmfOnMH9+/fh5eWl0uDGjx+PqKgoxMfHIyYmBv369UNqaioCAgIgkUgQFBSEkJAQbNu2DRcvXkRgYCBMTEwwePBglcZBRETqxdwCrD2/FgAwtPHQEruKERFVNUp3WN2/fz98fX3lymrXro2jR49izpw5KgsMAO7fv49Bgwbh6dOnqF69Olq3bo0TJ07A1dUVADBx4kRkZmZizJgxSE5Oho+PD/bv389nlBARVTLanlvuPL+DqDtRAIDBXjyxRkTaRyKEEKWZ8MaNG7h58ybat28PY2NjhW4CrKhSU1NhaWmJlJQU3l9CRBrDY5H25pbQI6H4+u+v0cGtAw4FHCqnCImoqqtMeUXp7lvPnj1D586dUbduXXTv3h2PHj0CAIwcORLjx49XeYBERFT1aXNuEULgt/O/AQCGeA3RcDRERJqhdKNk7Nix0NfXx927d2FiYiIr/+CDD7Bnzx6VBkdERNpBm3PL2YSzuPL0Cgx1DfF+g/c1HQ4RkUaU6p6Sffv2wdnZWa7cw8MDd+7cUVlgRESkPbQ5txTc4N6rXi9YGVlpNhgiIg1R+kpJRkaG3FmsAk+fPoWhoaFKgiIiIu2irbklT5qHDZc2AMh/YCIRkbZSulHSvn17rFmzRvZeIpFAKpVi/vz56Nixo0qDIyIi7aCtuSXqThQepj2ElZEV3q3zrqbDISLSGKW7b82fPx8dOnTAqVOnkJ2djYkTJ+LSpUtISkrCsWPH1BEjERFVcdqaW9ZfWA8A6N+gPwz1qu4VISKikih9paRBgwY4f/48WrVqBT8/P2RkZMDf3x9nzpxB7dq11REjERFVcdqYW7Jys7D58mYAfDYJEZHSV0oAwN7eHjNnzlR1LEREpMW0LbfsubEHKVkpcDJ3wts139Z0OEREGqX0lRIiIiIqu4KuWwMbDYSujq6GoyEi0iw2SoiIiMpZalYqdl7bCYBdt4iIADZKiIiIyt2f//6Jl7kvUc+mHrztvTUdDhGRxrFRQkREVM4Knk0yqNEgSCQSDUdDRKR5bJQQERGVo2cvnmH/zf0AgA8afaDhaIiIKgaFRt/y9vZW+ExOXFxcmQIiIiLtoK25ZeuVrciV5qKpfVN42npqOhwiogpBoUZJ37591RwGERFpG23NLQVdtwY2HKjhSIiIKg6JEEJoOghNS01NhaWlJVJSUmBhYaHpcIhIS/FYVLUUtT8fpT2CU7gTBATiv4yHm5WbZoMkoiqtMuUV3lNCRERUTjZf3gwBgdbOrdkgISJ6hdJPdM/Ly8MPP/yAP/74A3fv3kV2drbc50lJSSoLjoiItIO25BZ23SIiKprSV0pmzpyJ8PBwDBgwACkpKRg3bhz8/f2ho6OD4OBgNYRIRERVnTbklrspd3H83nFIIEH/hv01HQ4RUYWidKNk3bp1+PXXXzF+/Hjo6elh0KBBWL58OaZPn44TJ06oI0YiIqritCG3bL68GQDwtuvbcDR31HA0REQVi9KNkoSEBHh5eQEAzMzMkJKSAgDo2bMndu/erdroiIhIK2hDbtl0eRMAYECDARqOhIio4lG6UeLs7IxHjx4BAOrUqYP9+/MfABUbGwtDQ0PVRvea0NBQSCQSBAUFycqEEAgODoajoyOMjY3RoUMHXLp0Sa1xEBGRalX13HLn+R2cuH8CEkjwfoP3VRA1EVHVonSj5L333sPBgwcBAF9++SWmTZsGDw8PDBs2DB999JHKAywQGxuLX375BY0bN5YrDwsLQ3h4OBYtWoTY2FjY29vDz88PaWlpaouFiIhUq6rnloKuW+1d28PezL7McRMRVTVKj741d+5c2f/79esHFxcXHDt2DHXq1EHv3r1VGlyB9PR0fPjhh/j1118xe/ZsWbkQAgsWLMDUqVPh7+8PAFi9ejXs7Oywfv16jBo1Si3xEBGRalX13CLrutWQXbeIiIqidKPkdT4+PvDx8VFFLMX69NNP0aNHD3Tp0kUuccTHxyMhIQFdu3aVlRkaGsLX1xfHjx8vNnFkZWUhKytL9r6g73Jqaqqa1oCIqGQFxyA+07Zq5ZbL9y4j5mYMAMDPyY+5hojKTWXKK0o3SkJDQ2FnZ1focvrKlSvx5MkTTJo0SWXBAcCGDRsQFxeH2NjYQp8lJCQAAOzs7OTK7ezscOfOnWLnGRoaipkzZxYqd3FxKWO0RERl9+zZM1haWmo6jHJVlXNLm0ZtZP+vO7duaUMmIiq1ypBXlG6ULFu2DOvXry9U3rBhQwwcOFCliePevXv48ssvsX//fhgZGRVbTyKRyL0XQhQqe9WUKVMwbtw42XupVIqkpCTY2Ni8cbqySk1NhYuLC+7duwcLCwu1Lac8cZ0qB65T5ZCSkoKaNWvC2tpa06GUO+aW0quKvwWuU+XAdar4KlNeUbpRkpCQAAcHh0Ll1atXl42coiqnT59GYmIimjdvLivLy8vDP//8g0WLFuHq1atFxpSYmFjoDNerDA0NC43mYmVlpdLY38TCwqJKfNFfxXWqHLhOlYOOjtJjkFR6zC1lVxV/C1ynyoHrVPFVhryidIQFNx++7tixY3B0VO3DoDp37owLFy7g7NmzsleLFi3w4Ycf4uzZs6hVqxbs7e0RGRkpmyY7OxtRUVFo27atSmMhIiL1YW4hItJuSl8pGTlyJIKCgpCTk4NOnToBAA4ePIiJEyfiq6++Umlw5ubmaNSokVyZqakpbGxsZOVBQUEICQmBh4cHPDw8EBISAhMTEwwePFilsRARkfowtxARaTelGyUTJ05EUlISxowZg+zsbACAkZERJk2ahClTpqg8QEXiyczMxJgxY5CcnAwfHx/s378f5ubm5R5LSQwNDTFjxgy1PwisPHGdKgeuU+VQFddJUcwtpVcVvzdcp8qB61TxVab1kYhSjhGWnp6OK1euwNjYGB4eHpViZYmIqGJjbiEi0k6lfk6JmZkZHBwcIJFImDSIiEglmFuIiLST0je6S6VSfPvtt7C0tISrqytq1qwJKysrzJo1C1KpVB0xEhFRFcfcQkSk3ZS+UjJ16lSsWLECc+fORbt27SCEwLFjxxAcHIyXL19izpw56oiTiIiqMOYWIiLtpvQ9JY6Ojli6dCl69+4tV/7nn39izJgxePDggUoDJCKiqo+5hYhIuyndfSspKQmenp6Fyj09PZGUlKSSoIiISLswtxARaTelGyVNmjTBokWLCpUvWrQITZo0UUlQVU1oaChatmwJc3Nz1KhRA3379pU9MbgqCA0NhUQiQVBQkKZDKbMHDx5gyJAhsLGxgYmJCZo2bYrTp09rOqxSyc3NxTfffAN3d3cYGxujVq1a+PbbbytV//x//vkHvXr1gqOjIyQSCbZv3y73uRACwcHBcHR0hLGxMTp06IBLly5pJlgFvWmdcnJyMGnSJHh5ecHU1BSOjo4YNmwYHj58qLmAywlzi/KYWyqHqpRXAOaWiqoq5BalGyVhYWFYuXIlGjRogBEjRmDkyJFo0KABIiIiMH/+fHXEWOlFRUXh008/xYkTJxAZGYnc3Fx07doVGRkZmg6tzGJjY/HLL7+gcePGmg6lzJKTk9GuXTvo6+tjz549uHz5Mr7//ntYWVlpOrRSmTdvHpYuXYpFixbhypUrCAsLw/z587Fw4UJNh6awjIyMYv9YBfKPR+Hh4Vi0aBFiY2Nhb28PPz8/pKWllXOkinvTOr148QJxcXGYNm0a4uLisHXrVly7dq1Ql6aqiLlFecwtFV9VyysAc0tFVSVyiyiFBw8eiK+//lr4+/uL9957T0ydOlU8ePCgNLPSSomJiQKAiIqK0nQoZZKWliY8PDxEZGSk8PX1FV9++aWmQyqTSZMmibfeekvTYahMjx49xEcffSRX5u/vL4YMGaKhiMoGgNi2bZvsvVQqFfb29mLu3LmyspcvXwpLS0uxdOlSDUSovNfXqSgnT54UAMSdO3fKJygNYm4pG+aWiqeq5RUhmFsqg8qaW5S+UgLk35A4Z84cbNmyBVu3bsXs2bORl5eHjz76SFVtpSotJSUFAGBtba3hSMrm008/RY8ePdClSxdNh6ISO3bsQIsWLdC/f3/UqFED3t7e+PXXXzUdVqm99dZbOHjwIK5duwYAOHfuHI4ePYru3btrODLViI+PR0JCArp27SorMzQ0hK+vL44fP67ByFQrJSUFEomkUp9ZVRRzS9kwt1Q8VS2vAMwtVUVFzC2lapQUJSkpCatXr1bV7KosIQTGjRuHt956C40aNdJ0OKW2YcMGxMXFITQ0VNOhqMytW7ewZMkSeHh4YN++ffjkk0/wxRdfYM2aNZoOrVQmTZqEQYMGwdPTE/r6+vD29kZQUBAGDRqk6dBUIiEhAQBgZ2cnV25nZyf7rLJ7+fIlJk+ejMGDB8PCwkLT4WgEc4timFsqpqqWVwDmlqqgouaWUj/RnUrns88+w/nz53H06FFNh1Jq9+7dw5dffon9+/fDyMhI0+GojFQqRYsWLRASEgIA8Pb2xqVLl7BkyRIMGzZMw9Epb+PGjVi7di3Wr1+Phg0b4uzZswgKCoKjoyMCAgI0HZ7KSCQSufdCiEJllVFOTg4GDhwIqVSKxYsXazocquCYWyqmqpZXAOaWyq4i5xY2SsrR559/jh07duCff/6Bs7OzpsMptdOnTyMxMRHNmzeXleXl5eGff/7BokWLkJWVBV1dXQ1GWDoODg5o0KCBXFn9+vWxZcsWDUVUNhMmTMDkyZMxcOBAAICXlxfu3LmD0NDQKpE47O3tAeSf1XJwcJCVJyYmFjrDVdnk5ORgwIABiI+Px99//12hzmRRxcPcUnFVtbwCMLdUZhU9t6is+xYVTwiBzz77DFu3bsXff/8Nd3d3TYdUJp07d8aFCxdw9uxZ2atFixb48MMPcfbs2UqXNAq0a9eu0HCa165dg6urq4YiKpsXL15AR0f+J66rq1uphm18E3d3d9jb2yMyMlJWlp2djaioKLRt21aDkZVNQdK4fv06Dhw4ABsbG02HRBUUc0vFV9XyCsDcUllVhtyi8JUSf3//N37+/PnzssZSZX366adYv349/vzzT5ibm8v6JFpaWsLY2FjD0SnP3Ny8UJ9lU1NT2NjYVOq+zGPHjkXbtm0REhKCAQMG4OTJk/jll1/wyy+/aDq0UunVqxfmzJmDmjVromHDhjhz5gzCw8Mr1U3D6enpuHHjhux9fHw8zp49C2tra9SsWRNBQUEICQmBh4cHPDw8EBISAhMTEwwePFiDUb/Zm9bJ0dER/fr1Q1xcHHbt2oW8vDzZ8cLa2hoGBgaaClttmFtKj7ml4qtqeQVgbqmoqkJukQghhCIVhw8frtAMV61aVaaAqqLi+iCuWrUKgYGB5RuMmnTo0AFNmzbFggULNB1KmezatQtTpkzB9evX4e7ujnHjxuF///ufpsMqlbS0NEybNg3btm1DYmIiHB0dMWjQIEyfPr3CHIBKcvjwYXTs2LFQeUBAACIiIiCEwMyZM7Fs2TIkJyfDx8cHP//8c4X+A+ZN6xQcHFzs2e5Dhw6hQ4cOao6u/DG3lB5zS+VQlfIKwNxSUVWF3KJwo4SIiIiIiEgdeE8JERERERFpFBslRERERESkUWyUEBERERGRRrFRQkREREREGsVGCRERERERaRQbJUREREREpFFslBARERERkUaxUUKkIrdv34ZEIsHZs2fLNJ8OHTogKCioxHrt27fH+vXry7Ss8tCvXz+Eh4drOgwiokqJuaVozC1VDxslpJDAwEBIJBJIJBLo6emhZs2aGD16NJKTkxWeh6oOrBWVi4sLHj16VC5PfN21axcSEhIwcOBAtS+rrKZPn445c+YgNTVV06EQUQXD3FIy5paiMbdUPWyUkMK6deuGR48e4fbt21i+fDl27tyJMWPGaCSW7OxsjSy3ONnZ2dDV1YW9vT309PTUvryffvoJw4cPh46OZn/CiuyHxo0bw83NDevWrSuHiIiosmFuKR5zS/GYW6oeNkpIYYaGhrC3t4ezszO6du2KDz74APv375ers2rVKtSvXx9GRkbw9PTE4sWLZZ+5u7sDALy9vSGRSNChQwcARV9S7tu3LwIDA2Xv3dzcMHv2bAQGBsLS0hL/+9//EBERASsrK+zbtw/169eHmZmZLLkV5/Dhw5BIJNi9ezeaNGkCIyMj+Pj44MKFC3L1jh8/jvbt28PY2BguLi744osvkJGR8cZ4ijpbFxUVhVatWsHQ0BAODg6YPHkycnNzZZ9nZGRg2LBhMDMzg4ODA77//vs37gMAePr0KQ4cOIDevXvLyj766CP07NlTrl5ubi7s7e2xcuVKAIAQAmFhYahVqxaMjY3RpEkTbN68WVY/Ly8PI0aMgLu7O4yNjVGvXj38+OOPcvMMDAxE3759ERoaCkdHR9StWxcAsHjxYnh4eMDIyAh2dnbo16+f3HS9e/fG77//XuK6EZH2YW5hbmFuIQCAIFJAQECA6NOnj+z9zZs3RYMGDYSdnZ2s7JdffhEODg5iy5Yt4tatW2LLli3C2tpaRERECCGEOHnypAAgDhw4IB49eiSePXsmhBDC19dXfPnll3LL69OnjwgICJC9d3V1FRYWFmL+/Pni+vXr4vr162LVqlVCX19fdOnSRcTGxorTp0+L+vXri8GDBxe7HocOHRIARP369cX+/fvF+fPnRc+ePYWbm5vIzs4WQghx/vx5YWZmJn744Qdx7do1cezYMeHt7S0CAwPfGE98fLwAIM6cOSOEEOL+/fvCxMREjBkzRly5ckVs27ZN2NraihkzZsjmM3r0aOHs7CwXi5mZWaHt8apt27YJU1NTkZeXJys7duyY0NXVFQ8fPpSV/fnnn8LU1FSkpaUJIYT4+uuvhaenp9i7d6+4efOmWLVqlTA0NBSHDx8WQgiRnZ0tpk+fLk6ePClu3bol1q5dK0xMTMTGjRtl8wwICBBmZmZi6NCh4uLFi+LChQsiNjZW6OrqivXr14vbt2+LuLg48eOPP8rF/NdffwlDQ0Px8uXLYteLiLQPcwtzixDMLZSPjRJSSEBAgNDV1RWmpqbCyMhIABAARHh4uKyOi4uLWL9+vdx0s2bNEm3atBFCiEIH1gKKJo6+ffvK1Vm1apUAIG7cuCEr+/nnn+WS2esKEseGDRtkZc+ePRPGxsayA+TQoUPFxx9/LDfdkSNHhI6OjsjMzCw2ntfX7+uvvxb16tUTUqlULj4zMzORl5cn0tLShIGBQZGxvClx/PDDD6JWrVqFyhs0aCDmzZsne9+3b19ZsktPTxdGRkbi+PHjctOMGDFCDBo0qNhljRkzRrz//vuy9wEBAcLOzk5kZWXJyrZs2SIsLCxEampqsfM5d+6cACBu375dbB0i0j7MLcwtQjC3UD71d1CkKqNjx45YsmQJXrx4geXLl+PatWv4/PPPAQBPnjzBvXv3MGLECPzvf/+TTZObmwtLS0uVLL9FixaFykxMTFC7dm3ZewcHByQmJpY4rzZt2sj+b21tjXr16uHKlSsAgNOnT+PGjRty/VSFEJBKpYiPj0f9+vWLjedVV65cQZs2bSCRSGRl7dq1Q3p6Ou7fv4/k5GRkZ2cXGcubZGZmwsjIqFD5yJEj8csvv2DixIlITEzE7t27cfDgQQDA5cuX8fLlS/j5+clNk52dDW9vb9n7pUuXYvny5bhz5w4yMzORnZ2Npk2byk3j5eUFAwMD2Xs/Pz+4urqiVq1a6NatG7p164b33nsPJiYmsjrGxsYAgBcvXrxx3YhI+zC3MLcAzC0EsFFCCjM1NUWdOnUA5N8M17FjR8ycOROzZs2CVCoFAPz666/w8fGRm05XV/eN89XR0YEQQq4sJyenyOW/Tl9fX+69RCIpNC9FFRzgpVIpRo0ahS+++KJQnZo1a74xnlcJIeSSRkFZWeO0tbUtcmSaYcOGYfLkyYiOjkZ0dDTc3Nzw9ttvA4Bs/+zevRtOTk5y0xkaGgIA/vjjD4wdOxbff/892rRpA3Nzc8yfPx8xMTFy9V9fb3Nzc8TFxeHw4cPYv38/pk+fjuDgYMTGxsLKygoAkJSUBACoXr16qdaZiKou5hbmFoC5hdgooTKYMWMG3n33XYwePRqOjo5wcnLCrVu38OGHHxZZv+AMSF5enlx59erV5W4gzMvLw8WLF9GxY0e1xX7ixAlZEkhOTsa1a9fg6ekJAGjWrBkuXbokS5Kl1aBBA2zZskUugRw/fhzm5uZwcnJCtWrVoK+vX2Qsvr6+xc7X29sbCQkJSE5ORrVq1WTlNjY26Nu3L1atWoXo6GgMHz5cLhZDQ0PcvXu32HkfOXIEbdu2lRv15ubNmwqtq56eHrp06YIuXbpgxowZsLKywt9//w1/f38AwMWLF+Hs7AxbW1uF5kdE2ou55c2YW5hbqio2SqjUOnTogIYNGyIkJASLFi1CcHAwvvjiC1hYWODdd99FVlYWTp06heTkZIwbNw41atSAsbEx9u7dC2dnZxgZGcHS0hKdOnXCuHHjsHv3btSuXRs//PADnj9/rtbYv/32W9jY2MDOzg5Tp06Fra0t+vbtCwCYNGkSWrdujU8//RT/+9//YGpqiitXriAyMhILFy5UeBljxozBggUL8Pnnn+Ozzz7D1atXMWPGDIwbNw46OjowMzPDiBEjMGHCBLlYShqK0dvbG9WrV8exY8cKjYoycuRI9OzZE3l5eQgICJCVm5ubY/z48Rg7diykUineeustpKam4vjx4zAzM0NAQADq1KmDNWvWYN++fXB3d8dvv/2G2NhY2cg2xdm1axdu3bqF9u3bo1q1avjrr78glUrlugocOXIEXbt2VXjbEZH2Ym55M+YW5pYqSxM3slDl8/oIKQXWrVsnDAwMxN27d2XvmzZtKgwMDES1atVE+/btxdatW2X1f/31V+Hi4iJ0dHSEr6+vECJ/ZI7Ro0cLa2trUaNGDREaGlrkzYg//PCD3LJXrVolLC0t5cq2bdsm3vS1LrgZcefOnaJhw4bCwMBAtGzZUpw9e1au3smTJ4Wfn58wMzMTpqamonHjxmLOnDlvjKeomy0PHz4sWrZsKQwMDIS9vb2YNGmSyMnJkX2elpYmhgwZIkxMTISdnZ0ICwsr8ubM102ePFkMHDiwULlUKhWurq6ie/fuRX72448/inr16gl9fX1RvXp18c4774ioqCghhBAvX74UgYGBwtLSUlhZWYnRo0eLyZMniyZNmsjmUdT34MiRI8LX11dUq1ZNGBsbi8aNG8uNqpKZmSksLCxEdHT0G9eJiLQPcwtzixDMLZRPIkQpOx8SVUKHDx9Gx44dkZycLOuTWhk9fvwYDRs2xOnTp+Hq6iorf/HiBRwdHbFy5UrZ5W1N+/nnn/Hnn38Weu4AEVFVwdxS/phbqh4+PJGoErKzs8OKFStw9+5dAPk3Gz58+BDTpk2DpaWl3MOvNE1fX1+prglERKQZzC2kSbynhKiS6tOnj+z/d+/ehbu7O5ydnREREQE9vYrz0/744481HQIRESmIuYU0hd23iIiIiIhIo9h9i4iIiIiINIqNEiIiIiIi0ig2SoiIiIiISKPYKCEiIiIiIo1io4SIiIiIiDSKjRIiIiIiItIoNkqIiIiIiEij2CghIiIiIiKNYqOEiIiIiIg0io0SIiIiIiLSKDZKiIiIiIhIo9goISIiIiIijWKjhIiIiIiINKpMjZKsrCxVxaExISEh2L59e6HyiIgISCQSnDp1Su0xdOjQAR06dFD7cl5fZmBgIAAgMDCw0PIlEgmCg4NLNe/FixcjIiKiTPGVp8OHD0MikeDw4cNKT3v58mUEBwfj9u3bpV5+wXft1VhKM7/bt29DIpHgu+++U3iZZYm7NNzc3GTfu8o4/zcJDAyEm5ubRpb9JkePHsXIkSPRvHlzGBoaamS/K6sy5xbmlKJziio9fPgQwcHBOHv2rNqWoWplOT6sX78eCxYsKNPyVbV/goODIZFI8PTpU4WWWd7fw7Lk84ow/5KU5W8zdVqwYAH8/f3h7u4OiURS6v2uVKNk3759CAwMRO3ataGvrw8TExOYm5vD19cXc+bMwcOHD0sVhCYVl0C0XXR0NEaOHFmqaStbo6QsLl++jJkzZ1b4P/Je16NHD0RHR8PBwUHToajUtm3bMG3aNE2HUaEcPHgQBw4cQM2aNdG2bVtNh1OkqpRbmFPU7+HDh5g5c2alapSUhSoaJZqwePFiLF68WNNhqFSzZs0QHR2NZs2aaTqUCmXp0qW4c+cOOnXqhOrVq5d6PnqKVNq+fTsmTZqElJQUdO/eHRMmTICTkxOMjY2RlJSEixcv4sCBA5g1axYCAwMxa9asMgVFmte6dWtNhyBHCIGXL1/C2NhY06FUCdWrV6+Sv1Fvb29Nh1DhTJs2DTNmzAAAfPfddxo7w1cU5hYqDy9evICJiYmmw9A6DRo00HQIKmdhYVHh/j6qCC5fvgwdnfzrHI0aNSr1fBS6UhISEoLvvvsODx8+xMqVK/HJJ5+gV69e6NKlCwYMGIBvv/0Whw4dws2bN2FhYYE1a9aUOiDg/y8Pnj9/Hv3794elpSWsra0xbtw45Obm4urVq+jWrRvMzc3h5uaGsLCwQvNITU3F+PHj4e7uDgMDAzg5OSEoKAgZGRmyOhKJBBkZGVi9ejUkEkmRl5zS0tIwevRo2NrawsbGBv7+/oXO2kmlUoSFhcHT0xOGhoaoUaMGhg0bhvv378vVE0IgLCwMrq6uMDIyQrNmzbBnz54ybSt1ef0SYUHXg0OHDr1xe7i5ueHSpUuIioqSbdNXL1krsl8Klv/ZZ59h6dKlqF+/PgwNDbF69WpZF6WwsDDMmTMHNWvWhJGREVq0aIGDBw8WWo+jR4+ic+fOMDc3h4mJCdq2bYvdu3eXuP6nTp3CwIED4ebmBmNjY7i5uWHQoEG4c+eO3Dbp378/AKBjx46y9X31KtGBAwfQuXNnWFhYwMTEBO3atSsyTlWSSqUlbpuium916NABjRo1QmxsLN5++22YmJigVq1amDt3LqRSqVIx5OTkYOLEibC3t4eJiQneeustnDx5ssi6CQkJGDVqFJydnWFgYAB3d3fMnDkTubm5cvWysrLw7bffon79+jAyMoKNjQ06duyI48ePy+q83n2r4FL7+vXrMWnSJDg4OMDMzAy9evXC48ePkZaWho8//hi2trawtbXF8OHDkZ6eLrfcn3/+Ge3bt0eNGjVgamoKLy8vhIWFIScnp8TtsGnTJvj4+MDS0lK2PT/66CMltmTZFSSKiqi8cgtziuZlZ2dj9uzZsnWqXr06hg8fjidPnsjqzJ07Fzo6Oti5c6fctIGBgTAxMcGFCxdw+PBhtGzZEgAwfPhw2XYuyFeBgYEwMzPDhQsX0LVrV5ibm6Nz584AgMjISPTp0wfOzs4wMjJCnTp1MGrUqEJdkQq+L2fOnIG/vz8sLCxgaWmJIUOGyMULKL6viqLIsaVDhw7YvXs37ty5I1vXgu6+im5Xdbh3716J2+b17luvdjEODw+Hu7s7zMzM0KZNG5w4cULpGP79919069YNJiYmsLW1xSeffIK0tLQi6yqai//9918MGjQIdnZ2MDQ0RM2aNTFs2DBZl9Kium8VfOf+/fdfvPPOOzA1NYWDgwPmzp0LADhx4gTeeustmJqaom7duli9erXcMp88eYIxY8agQYMGMDMzQ40aNdCpUyccOXKkxG3w4sUL2XHJyMgI1tbWaNGiBX7//XdFN6NKqCzPiApoxowZAoCoV6+emDVrloiMjBQTJ04UAMRnn30mPD09xU8//SQiIyPF8OHDBQCxZcsW2fQZGRmiadOmwtbWVoSHh4sDBw6IH3/8UVhaWopOnToJqVQqhBAiOjpaGBsbi+7du4vo6GgRHR0tLl26JIQQYtWqVQKAqFWrlvj888/Fvn37xPLly0W1atVEx44d5eL9+OOPZbHt3btXLF26VFSvXl24uLiIJ0+eFFqvESNGiD179ohffvlFODk5CXt7e+Hr61vidsnNzRU5OTklvvLy8sq8DwCIGTNmyN4ruj3i4uJErVq1hLe3t2ybxsXFCSEU3y8Fy3dychKNGzcW69evF3///be4ePGiiI+PFwCEi4uLeOutt8SWLVvEpk2bRMuWLYW+vr44fvy4bB6HDx8W+vr6onnz5mLjxo1i+/btomvXrkIikYgNGzbI6h06dEgAEIcOHZKVbdq0SUyfPl1s27ZNREVFiQ0bNghfX19RvXp12T5NTEwUISEhAoD4+eefZeubmJgohBDit99+ExKJRPTt21ds3bpV7Ny5U/Ts2VPo6uqKAwcOlHkfvU6ZbVOwP+Pj42Vlvr6+wsbGRnh4eIilS5eKyMhIMWbMGAFArF69WqlYAgIChEQiERMmTBD79+8X4eHhwsnJSVhYWIiAgABZvUePHgkXFxfh6uoqli1bJg4cOCBmzZolDA0NRWBgoKxeTk6O6Nixo9DT0xPjx48Xf/31l9ixY4f4+uuvxe+//y6r5+rqKjf/gn3r6uoqAgMDZb9PMzMz0bFjR+Hn5yfGjx8v9u/fL+bNmyd0dXXF559/LrcuY8eOFUuWLBF79+4Vf//9t/jhhx+Era2tGD58eKF1dnV1lb0/fvy4kEgkYuDAgeKvv/4Sf//9t1i1apUYOnRoidtPXb/1+fPnF9rv2oA5pWjllVPy8vJEt27dhKmpqZg5c6aIjIwUy5cvF05OTqJBgwbixYsXQgghpFKp6N69u6hWrZq4ffu2EEKIlStXCgBi+fLlQgghUlJSZNvym2++kW3ne/fuCSHyf4f6+vrCzc1NhIaGioMHD4p9+/YJIYRYsmSJCA0NFTt27BBRUVFi9erVokmTJqJevXoiOzu70HZ1dXUVEyZMEPv27RPh4eHC1NRUeHt7y9VVdF+9fnwQQrFjy6VLl0S7du2Evb29bF2jo6OV2q6qpMy28fX1lfseFuQoNzc30a1bN7F9+3axfft24eXlJapVqyaeP3+ucBwJCQmiRo0awsnJSaxatUr89ddf4sMPPxQ1a9YslM8VzcVnz54VZmZmws3NTSxdulQcPHhQrF27VgwYMECkpqYKIYr+eyEgIEAYGBiI+vXrix9//FHuODJlyhRRt25dsWLFCrFv3z7Rs2dPAUCcOnVKNv2///4rRo8eLTZs2CAOHz4sdu3aJUaMGCF0dHTkliNE4b/NRo0aJUxMTER4eLg4dOiQ2LVrl5g7d65YuHBhidtQkd9+Tk6O3N9mimjYsKFCx5+ilLlRkpubK86cOSOSkpLKOiuZgi/9999/L1fetGlTAUBs3bpVVpaTkyOqV68u/P39ZWWhoaFCR0dHxMbGyk2/efNmAUD89ddfsjJTU1O5P2IKFBz0xowZI1ceFhYmAIhHjx4JIYS4cuVKkfViYmIEAPH1118LIYRITk4WRkZG4r333pOrd+zYMQFAoR3o6+srAJT4Kmp9lFVco6Sk7SFE8V9IZfYLAGFpaVnoe1VwUHN0dBSZmZmy8tTUVGFtbS26dOkiK2vdurWoUaOGSEtLk5Xl5uaKRo0aCWdnZ9kPraiDzOtyc3NFenq6MDU1FT/++KOsfNOmTUVOm5GRIaytrUWvXr3kyvPy8kSTJk1Eq1atil1WaSmzbYprlAAQMTExcvNt0KCBeOeddxSOo+A3MXbsWLnydevWFfp+jho1SpiZmYk7d+7I1f3uu+8EANkfdGvWrBEAxK+//vrGZRfXKHl9PwQFBQkA4osvvpAr79u3r7C2ti52/nl5eSInJ0esWbNG6Orqyn0/X/+jo2AdlEm0BdT1W69MjRJV5hbmlKKVV075/fffCzX0hBAiNjZWABCLFy+WlT19+lQ4OzuLVq1aibi4OGFiYiKGDBlS5HSrVq0qtKyAgAABQKxcufKNMUmlUpGTkyPu3LkjAIg///xT9lnB96W4Y9jatWuFEIrvq4K4Xm+UvOpNx5YePXoUOa0y21VVFN02QhTfKPHy8hK5ubmy8pMnTwoAcieYSjJp0iQhkUjE2bNn5cr9/PzkcrIyubhTp07CyspKdmKxKMU1Sl7fDwXHEQCyE7NCCPHs2TOhq6srxo0bV+wyCk4WdO7cudDv+/W/zRo1aiT69u1b7LyKU7AvFHm96W+jopSlUaL09ZagoCCsWLECAJCXlwdfX180a9YMLi4uKu+r3LNnT7n39evXh0Qiwbvvvisr09PTQ506deS61ezatQuNGjVC06ZNkZubK3u98847So+a0Lt3b7n3jRs3BgDZ8g4dOgQAhUb8adWqFerXry+7PBgdHY2XL1/iww8/lKvXtm1buLq6KhTLsmXLEBsbW+JLnSMzlLQ93kTZ/dKpUydUq1atyHn5+/vDyMhI9t7c3By9evXCP//8g7y8PGRkZCAmJgb9+vWDmZmZrJ6uri6GDh2K+/fv4+rVq8XGmp6ejkmTJqFOnTrQ09ODnp4ezMzMkJGRgStXrpS4rsePH0dSUhICAgLk1lUqlaJbt26IjY0t1GVNVUraNm9ib2+PVq1ayZU1btxYof1boOA38fp3fcCAAdDTk7+NbdeuXejYsSMcHR3ltlPBbzwqKgoAsGfPHhgZGZW661NRxxIg/4b/18uTkpLkunCdOXMGvXv3ho2NDXR1daGvr49hw4YhLy8P165dK3aZBV1MBgwYgD/++AMPHjxQON6K8Fsvb+WRW5hT5JXX92zXrl2wsrJCr1695LZf06ZNYW9vL7f9bGxssHHjRsTFxaFt27aoWbMmli5dqvQy33///UJliYmJ+OSTT+Di4gI9PT3o6+vLtlVRx/XijmEF+0jRfVWc0h5bCiizXVWtpG3zJj169ICurq7svTJ/RxQ4dOgQGjZsiCZNmsiVDx48WO69orn4xYsXiIqKwoABA0p135pEIkH37t1l7wuOIw4ODnL3OlpbW6NGjRqF1nXp0qVo1qwZjIyMZN/NgwcPlvj3RqtWrbBnzx5MnjwZhw8fRmZmpkLxOjo6KvTbj42NRfPmzZXYEmWj0I3ur9q8eTOGDBkCANi5cyfi4+Px77//Ys2aNZg6dSqOHTumsuCsra3l3hsYGMDExETuD66C8tTUVNn7x48f48aNG9DX1y9yvooMZVfAxsZG7r2hoSEAyHb8s2fPAKDIUYwcHR1lX7yCevb29oXqFVVWlDp16kAIUWI9dfYhL2l7vImy++VNI0MVtx2zs7ORnp6OtLQ0CCGK3S/A/++TogwePBgHDx7EtGnT0LJlS1hYWMgOOoquKwD069ev2DpJSUkwNTUtcV7KKmnbWFpaFjvt6/sXyN/Hih7ogOK/63p6eoXm//jxY+zcubPE78STJ0/g6OhY6u92UceSN5W/fPkSZmZmuHv3Lt5++23Uq1cPP/74I9zc3GBkZISTJ0/i008/feN2ad++PbZv346ffvpJ1ie5YcOGmDp1KgYNGvTGeCvCb728lUduYU6RV17fs8ePH+P58+ey39frXt9+Pj4+aNiwIc6dO4fRo0crfZw0MTGBhYWFXJlUKkXXrl3x8OFDTJs2DV5eXjA1NYVUKkXr1q2L/C0Xdwwr2PaK7quilOXYUkDZ7apKJW2bNynL3xEFnj17Bnd39xLjUjQX6+joIC8vD87OzgrH8KrijiOvH3MKyl++fCl7Hx4ejq+++gqffPIJZs2aBVtbW+jq6mLatGklNkp++uknODs7Y+PGjZg3bx6MjIzwzjvvYP78+fDw8Ch2OgMDAzRt2lShdXu1AaluSjdKnj59Ktvpf/31F/r374+6detixIgR+Omnn1QeYGnY2trC2NgYK1euLPZzVSn4cT169KjQl/nhw4eyZRXUS0hIKDSPhIQEhcYv79y5s+zM8ZsEBARUyCF5ld0vr97M97ritqOBgQHMzMygp6cHHR0dPHr0qFC9gptKi/sepKSkYNeuXZgxYwYmT54sK8/KykJSUlKxMRW1LgsXLix2pA47OzuF5qWskraNur36XXdycpKV5+bmFkpYtra2aNy4MebMmVPkvAoakNWrV8fRo0chlUrL9Q/x7du3IyMjA1u3bpU7+6zoUKR9+vRBnz59kJWVhRMnTiA0NBSDBw+Gm5sb2rRpU+x0lf23XhoVObcwp5Tte1ZwU//evXuL/Nzc3Fzu/YwZM3DhwgU0b94c06dPR8+ePVGrVi2Fl1dU7rh48SLOnTuHiIgIBAQEyMpv3LhR7HyKO4YVbHtF91VRynpsAZTfrqpU0rZRNxsbm2K/+69SNBfn5eVBV1dXoQEKVG3t2rXo0KEDlixZIlde3E37rzI1NcXMmTMxc+ZMPH78WHbVpFevXvj333+Lne727dtFNuqKcujQoXJ73ozSjRI7OztcvnwZDg4O2Lt3r2wM6hcvXpRra+pNevbsiZCQENjY2JS40ZU9C/y6Tp06Acj/UhV01wCA2NhYXLlyBVOnTgWQP8SukZER1q1bJ3dZ+fjx47hz545CCWTZsmUKfUlVmSBLo7htqsx+KcnWrVsxf/582ZmJtLQ07Ny5E2+//TZ0dXVhamoKHx8fbN26Fd99951sKGGpVIq1a9fC2dkZdevWLXLeEokEQgjZ2ZsCy5cvL9T9qbgzPO3atYOVlRUuX76Mzz77rEzrqqySto26FRy81q1bJ3fZ948//ig0olbPnj3x119/oXbt2sV21QOAd999F7///jsiIiLKdfSqgj9uXv0uCCHw66+/KjUfQ0ND+Pr6wsrKCvv27cOZM2fe2CipLL91VarIuYU5pWzfs549e2LDhg3Iy8uDj4/PG+tGRkYiNDQU33zzDYKCgtC0aVN88MEHOHbsmOyKQGnOrBf1Wwbyt0FxijuGFRzjFN1XisZT3LHlTTlV0e2qaiVtG3Xr2LEjwsLCcO7cObkuXOvXr5erp0wu9vX1xaZNmzBnzpxyPbZKJJJC38vz588jOjoaLi4uCs/Hzs4OgYGBOHfuHBYsWPDGobALum8pol69egrHUFZKN0qGDx+OAQMGwMHBARKJBH5+fgCAmJgYeHp6qjzA0ggKCsKWLVvQvn17jB07Fo0bN4ZUKsXdu3exf/9+fPXVV7IfsJeXFw4fPoydO3fCwcEB5ubmSu2AevXq4eOPP8bChQuho6ODd999F7dv38a0adPg4uKCsWPHAgCqVauG8ePHY/bs2Rg5ciT69++Pe/fuITg4WOFL7eX5xSgLLy8vbNiwARs3bkStWrVgZGQELy8vpfZLSXR1deHn54dx48ZBKpVi3rx5SE1NxcyZM2V1QkND4efnh44dO2L8+PEwMDDA4sWLcfHiRfz+++/FXomxsLBA+/btMX/+fNja2sLNzQ1RUVFYsWIFrKys5OoWjMf9yy+/wNzcHEZGRnB3d4eNjQ0WLlyIgIAAJCUloV+/fqhRowaePHmCc+fO4cmTJ4XOihTn8OHD6NixI2bMmKFQ325Fto061a9fH0OGDMGCBQugr6+PLl264OLFi/juu+8Kdan49ttvERkZibZt2+KLL75AvXr18PLlS9y+fRt//fUXli5dCmdnZwwaNAirVq3CJ598gqtXr6Jjx46QSqWIiYlB/fr1MXDgQLWsi5+fHwwMDDBo0CBMnDgRL1++xJIlS5CcnFzitNOnT8f9+/fRuXNnODs74/nz5/jxxx+hr68PX1/fN06ryt/6kydPZGfDL1y4ACD/Hp2CZ9WUFEt5qci5hTmlbAYOHIh169ahe/fu+PLLL9GqVSvo6+vj/v37OHToEPr06YP33nsPjx49wpAhQ+Dr64sZM2ZAR0cHGzduRPv27TFx4kTZAwRr164NY2NjrFu3DvXr14eZmRkcHR1lV1aL4unpidq1a2Py5MkQQsDa2ho7d+5EZGRksdNs3boVenp68PPzw6VLlzBt2jQ0adIEAwYMAKD4viqKMscWLy8vbN26FUuWLEHz5s2ho6ODFi1aKLxdFREYGIjVq1cjPj5eoQZtSdtG3YKCgrBy5Ur06NEDs2fPhp2dHdatW1fo6oCZmZnCuTg8PBxvvfUWfHx8MHnyZNSpUwePHz/Gjh07sGzZMrVdeerZsydmzZqFGTNmwNfXF1evXsW3334Ld3f3QifyXufj44OePXuicePGqFatGq5cuYLffvsNbdq0eeOzeQwMDNCiRQuVrcOpU6dkjxhITU2FEAKbN28GkH9/paL3uZVq9K1NmzaJ8PBw2RB8QggREREhtm/fXqq77V9XMLrDq8PpCZE/woGpqWmh+r6+vqJhw4ZyZenp6eKbb74R9erVEwYGBsLS0lJ4eXmJsWPHioSEBFm9s2fPinbt2gkTExO5EUsKRkp5fbSVokZeyMvLE/PmzRN169YV+vr6wtbWVgwZMkRu+wiRP9pHaGiocHFxEQYGBqJx48Zi586dhUaoqAhQzOhbimyP27dvi65duwpzc3OB/4YOLKDofgEgPv3000JxFYwYMW/ePDFz5kzh7OwsDAwMhLe3t2zYx1cdOXJEdOrUSZiamgpjY2PRunVrsXPnzhLX4f79++L9998X1apVE+bm5qJbt27i4sWLhUZ3EkKIBQsWCHd3d6Grq1toRJioqCjRo0cPYW1tLfT19YWTk5Po0aOH2LRpUxFbvWg7d+4UAMTSpUvfWE+ZbVPc6Fuv/46EKHnUmKJkZWWJr776StSoUUMYGRmJ1q1bi+jo6CK335MnT8QXX3wh3N3dhb6+vrC2thbNmzcXU6dOFenp6bJ6mZmZYvr06cLDw0MYGBgIGxsb0alTJ7mhjosbfev17V3c97moY8/OnTtFkyZNhJGRkXBychITJkwQe/bsKXIElle3065du8S7774rnJychIGBgahRo4bo3r27OHLkiFLbsqwKtkFRr4p23FFXbmFO0bycnBzx3XffyX5LZmZmwtPTU4waNUpcv35d5ObmCl9fX2FnZyc3mqMQ/z9q3LZt22Rlv//+u/D09BT6+vpy+aq4fSqEEJcvXxZ+fn7C3NxcVKtWTfTv31/cvXu3UL4r+L6cPn1a9OrVS5iZmQlzc3MxaNAg8fjxY7l5KrqvijqOKnpsSUpKEv369RNWVlZCIpGIV/90K2m7Kur9998XxsbGIjk5+Y31lNk2xY2+NX/+/ELzfX0fKKJgfxoZGQlra2sxYsQI8eeffxY5YpSiufjy5cuif//+wsbGRhgYGIiaNWuKwMBA8fLlSyFE8aNvKXocESI/T/Xo0UP2PisrS4wfP144OTkJIyMj0axZM7F9+/YivzOvb6fJkyeLFi1aiGrVqglDQ0NRq1YtMXbsWPH06VMFt6JqFIxAVtSrqFHyiiMRQoG73JB/42/fvn3RrVu3Qmc7icpLQT/I+fPnY/z48ZoOp1xMnDgRv//+O65fv17oRjqiyo65hSqa4OBgzJw5E0+ePKlSXSTfxN7eHkOHDsX8+fM1HQppMYXvGK1Xrx7mzZuHGjVqoGvXrvj5559x7949dcZGRMi/yWzatGlskFCVxNxCpFmXLl3CixcvMGnSJE2HQlpO4UbJjBkzcPr0ady4cQN9+/bFjh074OHhgWbNmiE4OBhnzpxRZ5xEWis2NhYff/yxpsMAkP/8iFfHen/9VdJzUIhex9xCpFkNGzZEampqhbgqJIR4Y47Jzc1VaBhrqpyUHlvT2dkZY8aMwb59+/DkyRNMnjwZ169fR+fOneHq6orPPvsMly5dUmhe//zzD3r16gVHR0dIJBJs375d7nMhBIKDg+Ho6AhjY2N06NCh0LyzsrLw+eefw9bWFqampujdu7dGhnSj8uHm5gYhhNZ03apoateuDX19/WJfnTt31nSIVEkxt1BFERwcDCFEhfgjXdtERUW9Mcfo6+tj9erVmg6T1EThe0pKkpeXh8OHD2PHjh3w8vLCyJEjS5xmz549OHbsGJo1a4b3338f27ZtQ9++fWWfz5s3D3PmzEFERATq1q2L2bNn459//sHVq1dloyCMHj0aO3fuREREBGxsbPDVV18hKSkJp0+f1vgwkkRVzYULF5CVlVXs58qONERUEuYWIu2RlpaGq1evvrFOwQiXVAWp+g780sJrI2tIpVJhb28v5s6dKyt7+fKlsLS0lI1C9Pz5c6Gvry82bNggq/PgwQOho6Mj9u7dW26xExFRxcTcQkRUOSj9nJJnz55h+vTpOHToEBITEyGVSuU+V/SJ1yWJj49HQkICunbtKisreADZ8ePHMWrUKJw+fRo5OTlydRwdHdGoUSMcP34c77zzTpHzzsrKkjvbK5VKkZSUBBsbmzc+RZyISJ2EEEhLS4Ojo2O5Prm+ImBuISJSvcqUV5RulAwZMgQ3b97EiBEjYGdnp7YDbUJCAoD8J1S+ys7ODnfu3JHVMTAwKPQkaDs7O9n0RQkNDS23B8kRESnr3r17cHZ21nQY5Yq5hYhIfSpDXlG6UXL06FEcPXoUTZo0UUc8hbyemIQQJSarkupMmTIF48aNk71PSUlBzZo1ce/ePY6TT0Qak5qaChcXF7U9ObgiY24hIlK9ypRXlG6UeHp6IjMzUx2xyLG3tweQf8bKwcFBVp6YmCg7w2Vvb4/s7GwkJyfLndFKTExE27Zti523oaEhDA0NC5VbWFgwcRCRxmljVx/mFiIi9akMeUXpzmWLFy/G1KlTERUVhWfPniE1NVXupSru7u6wt7dHZGSkrCw7OxtRUVGypNC8eXPo6+vL1Xn06BEuXrz4xsRBREQVC3MLEZF2U/pKiZWVFVJSUtCpUye58oLL2so8PC09PR03btyQvY+Pj8fZs2dhbW2NmjVrIigoCCEhIfDw8ICHhwdCQkJgYmKCwYMHAwAsLS0xYsQIfPXVV7CxsYG1tTXGjx8PLy8vdOnSRdlVIyIiDWFuISLSbko3Sj788EMYGBhg/fr1Zb4Z8dSpU+jYsaPsfUFf3ICAAERERGDixInIzMzEmDFjkJycDB8fH+zfv1+uX9wPP/wAPT09DBgwAJmZmejcuTMiIiI4jjwRUSXC3EJEpN2UfniiiYkJzpw5U6UekJaamgpLS0ukpKSw3y8RaYw2H4uYW4iIVK8yHYeUvqekRYsWuHfvnjpiISIiLcXcQkSk3ZTuvvX555/jyy+/xIQJE+Dl5QV9fX25zxs3bqyy4IiISDswtxARaTelu28V9TRIiURSqpsRK4rKdGmLiKoubT4WMbcQEaleZToOKX2lJD4+Xh1xEBGRFmNuISLSbko3SlxdXdURBxERaTHmFiIi7abQje7R0dEKzzAjIwOXLl0qdUBERKQdmFuIiKiAQo2SYcOGwc/PD3/88QfS09OLrHP58mV8/fXXqFOnDuLi4lQaJBERVT3MLUREVECh7luXL1/GsmXLMH36dHz44YeoW7cuHB0dYWRkhOTkZPz777/IyMiAv78/IiMj0ahRI3XHTURElRxzCxERFVB69K24uDgcOXIEt2/fRmZmJmxtbeHt7Y2OHTvC2tpaXXGqVWUamYCIqi5tPhYxtxARqV5lOg4pfaN7s2bN0KxZM3XEQkREWoq5hYhIBYQAMh8Bz88BkABmbTUdkcKUbpQQEREREZGGSfOAtKtA8ln5V9aT/M9tWgNt9mkuPiWxUUJEREREVJHlvgCeX/iv4XEm//X8ApCXWbiuRAew8ASsKtd9eGyUEBERERFVFNnP8xsfSXH/NUDigNR/ASEtXFfPFLBqDFTz/u/VBLBsBOgZ53+emlqekZcJGyVERERERJrw8ml+oyMp7v//Tb9ZdF2jGoBVU8Da+/8bIeZ18q+MVAFKN0ri4+Ph7u6ujliIiEhLMbcQUZX3MhFIOv3KKw54cbfouqau/zU8mv3XCGkGGDsAEkn5xlyOlG6U1KlTB+3bt8eIESPQr18/GBkZqSMuIiLSIswtRFSlvHzyX8Pj1P//++J+0XXN6gDWzf97/dcAMaycQ6GXhdLPKbl48SJWrlyJdevWISsrCx988AFGjBiBVq1aqStGtatMYzgTUdWlzcci5hYiqrSyn+c3PJ7F/tcIOQVk3CmiogSwqJff+KjW7P8bIfrqOz5UpuOQ0o2SArm5udi5cyciIiKwZ88eeHh4YMSIERg6dCiqV6+u6jjVqjLtMCKqungsYm4hogou90X+zefPTgLPTgFJsUDa9aLrmtcFrFvkNz5sWuR3x9I3L9dwK9NxqNSNkgJZWVlYvHgxpkyZguzsbOjr6+ODDz7AvHnz4ODgoKo41aoy7TAiqrp4LPp/zC1EpHHSXCDl8n8NkP9eKRcBkVe4rlmt/xogLQCblvkNEAPL8o/5NZXpOFTq0bdOnTqFlStXYsOGDTA1NcX48eMxYsQIPHz4ENOnT0efPn1w8uRJVcZKRERVHHMLEWmEEPk3nT87CTyNyf836TSQ96JwXWMHwLplfuPDumX+VRBDm/KPuYpRulESHh6OVatW4erVq+jevTvWrFmD7t27Q0cnfzgyd3d3LFu2DJ6enioPloiIqibmFiIqVzlp+fd+PD2R/3oWA7x8XLiennl+48OmJWDjk/+viXP5x6sFlB7YeMmSJRg8eDDu3r2L7du3o2fPnrKkUaBmzZpYsWKFSgJMS0tDUFAQXF1dYWxsjLZt2yI2Nlb2uRACwcHBcHR0hLGxMTp06IBLly6pZNlERFQ+mFuISG2EFEi5AtxcBZwcBfzVBNhsBRzsBJz7GniwI79BItHL73ZV5xOg9SqgxyWg/3Og80Gg6VzA5T02SNRI6SslkZGRqFmzZqFkIYTAvXv3ULNmTRgYGCAgIEAlAY4cORIXL17Eb7/9BkdHR6xduxZdunTB5cuX4eTkhLCwMISHhyMiIgJ169bF7Nmz4efnh6tXr8LcvHxvJiIiotJhbiEilclOyb/y8TT6v1cMkPO8cD2TmoCtD2DTOv/fas3+/0noVO6UvtFdV1cXjx49Qo0aNeTKnz17hho1aiAvr4ibf0opMzMT5ubm+PPPP9GjRw9ZedOmTdGzZ0/MmjULjo6OCAoKwqRJkwDk3xxpZ2eHefPmYdSoUQotpzLdBEREVZc2H4uYW4ioVITIH/3q6fH8BsiT40DKJQCv/Xmra/z/XbBs2+T/a+KokZDLU2U6Dil9paS4Nkx6errKH3aVm5uLvLy8QvM1NjbG0aNHER8fj4SEBHTt2lX2maGhIXx9fXH8+PFiE0dWVhaysrJk71NTU1UaNxERKYe5hYgUkvcyfyjep8eBJ8fy/816WrieqXt+46N62/x/rbwAHf3yj5cUpnCjZNy4cQAAiUSC6dOnw8TERPZZXl4eYmJi0LRpU5UGZ25ujjZt2mDWrFmoX78+7Ozs8PvvvyMmJgYeHh5ISEgAANjZ2clNZ2dnhzt3inpoTb7Q0FDMnDlTpbESEZHymFuI6I1ePv2vAXI0vxGSdAqQZsvX0THMHwHLtl1+A8S2DWBsV/T8qMJSuFFy5swZAPlnsy5cuAADAwPZZwYGBmjSpAnGjx+v8gB/++03fPTRR3BycoKuri6aNWuGwYMHIy4uTlZHIpHITSOEKFT2qilTpsgSIZB/NsvFxUXlsRMR0ZsxtxCRjBBARjyQeBR4ciS/IZL6b+F6RnZA9Xb5jZDq7fJvTtc1KFyPKhWFGyWHDh0CAAwfPhw//vhjufVLq127NqKiopCRkYHU1FQ4ODjggw8+gLu7O+zt7QEACQkJcg/TSkxMLHSG61WGhoYwNDRUe+xE9H/t3Xd4U2X/x/F3KKW0pS1D6IACBcooy7rK8GEow4lYfRRwgIADXIhKQR6WMosiKioPqAyVR1TAhUoBpSpbEUHkR9lLagVKyygtNPfvj0CgFLCBpGmSz+u6ejW5z0nyiWC+fHPucx+Ri1NtEfFhxmo7/yPjB8j40daI5PxZeL/QBlD5elsDUrkllKsNF/mCQDyTw+eUTJs2zRU5/lFwcDDBwcFkZmayYMECkpOT7cVj4cKFxMfHA5CXl0dqairjxo1zS04REXGcaouID7CehMxfTzUhP9iakLzMgvuU8ocKV0OVf505GlL2CvfklWJVpKYkMTGR6dOnExoaSmJi4kX3nTt3rlOCnbZgwQKMMdSrV48tW7bw/PPPU69ePR566CEsFgv9+vVj9OjRxMbGEhsby+jRowkKCqJbt25OzSEiIs6l2iLi5awnbCelZyyBjFTbOSEnjxTcp3TwqRPS/wVVWkGl66B00HmfTrxbkZqSsLAw+zzasLAwlwY6V1ZWFoMGDWLPnj1UrFiRu+66i1GjRuHvb1tBYcCAAeTk5NC3b18yMzNJSEggJSVF68iLiJRwqi0iXubsJuSvJbZzQvKPFdzHP8zWgIS3tv2ueJVWxRLgEq5T4o08aQ1nEfFe+izyLvrzFK9nPQkHf4G/vrc1In//BCePFtwnoBJUbgVVWtsakbDGUMrPLXF9kSd9Djl8TklOTg7GGPuyjTt37mTevHnExcUVWNNdRESkqFRbRDyAscKhdZD+3alGJBVOHi64T0AlWwNSpe2pJqQhWEq5J694FIebkjvuuIPExEQee+wxDh06xHXXXUeZMmXYv38/EyZMoE+fPq7IKSIiXky1RaQEMgaObIX0xfDXYlsjcu6FCv3L25qPKm0hvC2Ub6QmRC6Jw39r1qxZw7/+9S8APv30UyIiIti5cyczZ87k9ddfd3pAERHxfqotIiXE8QzY8T9Y0Qs+rwlfxsLqx2DXJ7aGpHQwRN4E8ePhpp/hrv3Q6jOo/zRUaKKGRC6Zw0dKjh07Zj/RLyUlhcTEREqVKkWzZs0ueqVbERGRC1FtEXGTkzm2c0HSU2DfQjj0W8Htpfxtq2OF3wgRN0LFa3WhQnEJh5uSOnXq8Nlnn3HnnXeyYMECnnnmGcB2UamSfgKNiIiUTKotIsXEGDi0/lQTkmK7Xog1t+A+5ZtARHuIaGe7XkjpYPdkFZ/icFMydOhQunXrxjPPPMONN95I8+bNAds3W6cvMiUiIuII1RYRFzr+N6QvhH0LbI3I8fSC2wOrQmR7WyMSfiMEhrsnp/i0S1oSOD09nX379tG0aVNKlbLNHVy1ahWhoaHUr1/f6SFdzZOWSxMR7+Xrn0WqLSJOYs2HAyth37fw57dw8GfgrH/u+QVBeBuI6GBrRkIbwKlrBol38aTPIYePlABEREQQERFRYOy6665zSiAREfFNqi0ilyHnr1NNyDe2qVl5mQW3l28CkR1tJ6lXbgl+Ae7JKXIBDjclR48eZezYsSxevJiMjAysVmuB7du2bXNaOBER8Q2qLSIOMlbb1dP/nA9/fn3qaMhZ/MtDZAdbExLZEYKi3BJTpKgcbkp69+5NamoqDzzwAJGRkVh0uE9ERC6TaotIEZzItp0Tsvcr2PeNbfnes1W4CqJutv1USoBSlzQhRsQtHP7b+s033zB//nxatmzpijwiIuKDVFtELuDINtjzJez9Ev7+AawnzmwrHWI7GhJ1K0TdBIGR7sspcpkcbkoqVKhAxYoVXZFFRER8lGqLyCnGCgdWwZ4vYO8XkLWh4PaQulD1NlsjUvl6XTNEvIbDTclLL73E0KFDmTFjBkFBQa7IJCIiPka1RXxa/nFIXwR7PrcdETn+15ltFj+o/C+oerutGQmt676cIi7kcFPyyiuvsHXrVsLDw6lZsyb+/v4Ftq9Zs8Zp4URExDeotojPyTsEe+fDnnm2VbNOHj2zzT8Uom6Bqp1s07LKVHBbTJHi4nBT0rlzZxfEEBERX6baIj4hJ912NGT3XPjrOzAnz2wLrArV7oBqnaFKa03LEp/jUFNy8qTtf56ePXsSHR3tkkAiIuJbVFvEqx3dZWtCds+Bv5dS4CKGYXG2JqTanVDxal3AUHyaw1d0DwkJYf369dSsWdNFkYqfJ13tUkS8ly9/Fqm2iFc5sgN2fwq7PrGdtH62StfZmpDoRJ0fIi7nSZ9DDk/fuvHGG1myZAk9evRwQRwREfFFqi3i8Y7ssDUhuz6Bg6vP2mCxrZJV/W5bMxKso4Ei5+NwU3LzzTczaNAgfv/9d66++mqCg4MLbO/UqZPTwomIiG9QbRGPdGwP7PwYds0ueETEUsp2Xkj03bYjIoER7sso4iEcnr5VqlSpCz+ZxUJ+fv5lhypunnRoS0S8ly9/Fqm2iMc4/rftaMjOj+DvH8/aYLE1IjXugWqJEBjutogip3nS55DDR0qsVqsrcoiIiA9TbZES7cRh2PMZ7JgF6QvBnNUkV74eqt9rm56lIyIil+zCX00VwfHjx52V47xOnjzJf/7zH2JiYggMDKRWrVq8+OKLBYqXMYbhw4cTFRVFYGAgbdq0YcOGDRd5VhERKclUW6REsJ6AvV/BT11gbjgsf9B2PRGTb1spK/5luGMXtP8R6j2hhkTkMjnclOTn5/PSSy9RtWpVypUrx7Zt2wAYMmQI7777rlPDjRs3jsmTJzNp0iQ2btxIcnIy48eP54033rDvk5yczIQJE5g0aRKrV68mIiKC9u3bc/jwYadmEfdbuXIl77//PitXrnR3FBFxMtUWcYdCdcUY2L8SVj8B8yIh9Xbb+SL5ORBSFxoPh9s2wU0/Q4NnddK6iDMZB40YMcLUqlXLfPDBByYwMNBs3brVGGPM7NmzTbNmzRx9uou69dZbTc+ePQuMJSYmmvvvv98YY4zVajURERFm7Nix9u3Hjx83YWFhZvLkyUV+naysLAOYrKws5wQXpxswYIDBtri7AcyAAQPcHUnE6Xz5s0i1RYrb2XWl+hWYb1++3pgv6hrzIWd+5oQb83M/Yw78bIzV6u7IIg7zpM8hh4+UzJw5kylTpnDffffh5+dnH2/SpAn/93//54w+ye76669n8eLFpKWlAfDbb7/x008/ccsttwCwfft20tPT6dChg/0xAQEBtG7dmmXLll3weXNzc8nOzi7wIyXXypUrSU5OLjCWnJysIyYiXkS1RYrTypUrmfRaMvdfD4sGwc7XoGPkT3A4DfyCoOZ90OZb6LwHrn5VFzYUKQYOn+i+d+9e6tSpU2jcarVy4sQJp4Q6LSkpiaysLOrXr4+fnx/5+fmMGjWKrl27ApCeng5AeHjBFS7Cw8PZuXPnBZ93zJgxjBgxwqlZxQXWrYP33qPKqlXn3ZyWlkZCQkIxhxIRV1BtkWJhDOxfTsXNL7DvTQgNPLPpuw0Q0OBhWv77FfAPcV9GER/lcFPSsGFDfvzxR2rUqFFg/JNPPiE+Pt5pwQBmz57NBx98wKxZs2jYsCFr166lX79+REVF0b17d/t+lnO+vTDGFBo726BBg+jfv7/9fnZ2NtHRmhdaImRlwf/+B+++Cz//DEBNi4VqwJ5zdq1bV1fCFfEWqi3iUjl/wfaZsO09yP4/YksBgbAlHWb8CDN/gl37YcWKXmpIRNzE4aZk2LBhPPDAA+zduxer1crcuXPZtGkTM2fO5KuvvnJquOeff56BAwfSpUsXABo3bszOnTsZM2YM3bt3JyLCttJFeno6kZGR9sdlZGQU+obrbAEBAQQEBDg1q1wGY2DpUpg6FT75BHJybOP+/nDHHVh69uS+775j3Msv2x+SlJSkoyQiXkS1RZzOmg/pKbD1HdjzBZiTtnG/IKhxD5NTcukz7H/23VVXRNzL4abk9ttvZ/bs2YwePRqLxcLQoUO56qqr+PLLL2nfvr1Twx07dqzQBbX8/PzsyzbGxMQQERHBwoUL7d+k5eXlkZqayrhx45yaRVzg4EGYOROmTIGNG8+MN2wIvXrB/fdD5coAjL35Zu68+27S0tKoW7euCoeIl1FtEac59idsfdfWjBzbdWa8UjOo3Qtq3Av+ITzWDOI7Pq26IlJCONyUAHTs2JGOHTs6O0sht99+O6NGjaJ69eo0bNiQX3/9lQkTJtCzZ0/Admi9X79+jB49mtjYWGJjYxk9ejRBQUF069bN5fnkEhgDy5fD5Mnw8ceQm2sbDwqCrl2hd29ISDjvCYUJCQkqGiJeTLVFLpmxwr6FsOW/sPeLMxc3LFMBYh6E2r2hfKNCD1NdESk5HG5KatWqxerVq6lUqVKB8UOHDnHVVVfZ15Z3hjfeeIMhQ4bQt29fMjIyiIqK4tFHH2Xo0KH2fQYMGEBOTg59+/YlMzOThIQEUlJSCAnRnNAS5cgRmDUL3noLfvvtzPiVV8Ijj8B990FoqNviiYh7qbbIJck9aDtPZPNkOLL1zHjlf0GdR2xXWfcr6758IlJkFmOMceQBpUqVIj09nSpVqhQY/+uvv6hevTq5p7/59iDZ2dmEhYWRlZVFqP5h7FxpabZGZNo0OL08Ztmy0KUL9OkD116rZRZFTvHlzyLVFnHIwTWQNgl2/g/yj9vG/EMhpjvEPgZhce7NJ1JCeNLnUJGPlHzxxRf22wsWLCAsLMx+Pz8/n8WLF1OzZk2nhhMPZbXCN9/AG2/AggVnxuvUsTUiPXpAxYpuiyciJYdqixSZ9QTsmgNpr8P+5WfGK8RDbF+o2RVKB7svn4hcliI3JZ07dwZsc23PXjIRwN/fn5o1a/LKK684NZx4mMOHYfp0WzOyebNtzGKBW2+FJ56A9u2hlMPX6xQRL6baIv/o+N+wZQpsfgty/rSNlfKH6Luh7pNwRTMdcRfxAkVuSs5elWT16tVcccUVLgslHmbnTlsjMnXqmSlaYWG2FbQefxxq1XJvPhEpsVRb5IKy/oD/mwg73j8zRatshG16Vp1HITDCrfFExLkcPtF9+/btrsghnujnn+Hll+HTTyH/1Eon9erBU0/Bgw9CuXLuzSciHkO1RQDbCo1/fQcbX4F935wZr3g11OsH1e8BvzJuiycirnNJSwIvXryYxYsXk5GRYf+W67T33nvPKcGkhDp9vsj48ZCaemb8xhuhf3+46SZN0RKRS6La4sOsJ2HXx7BxPGSuPTVogWqdoX5/qNxSU7REvJzDTcmIESN48cUXueaaa4iMjMSiDwnfcOIE/O9/kJwMGzbYxkqXtl1b5NlnoWlT9+YTEY+m2uKjTh6zXejw/16BozttY35BULun7chISG23xhOR4uNwUzJ58mSmT5/OAw884Io8UtIcOwbvvmubprXr1JVxQ0Lg0Ufh6aehWjX35hMRr6Da4mPyMiHtTdj0GuTut40FVLaduF63LwRUuvjjRcTrONyU5OXl0aJFC1dkkZIkO9t2fZEJE+Dvv21j4eHQrx889hiUL+/OdCLiZVRbfMTxDPi/V20NycnDtrHgGIh7HmJ6QOlAt8YTEfdxePJ/7969mTVrliuySElw6BCMGAE1asCgQbaGpGZNW4OyfTsMHKiGREScTrXFy+Xsg1+egc9rwh9jbQ1J+cbQ4kO4PQ1i+6ghEfFxDh8pOX78OFOmTGHRokU0adIEf3//AtsnTJjgtHBSjDIz4dVX4bXXzizrW68eDB5sO2+k9CWtiSAiUiSqLV7q2J+2JmTLFLDm2sYqXguN/gNVbwOLFkYRERuH/6W5bt06rrzySgB+//33Att0YqIHysqyNSOvvnqmGWnUCIYMgbvuAj8/9+YTEZ+g2uJlctJtzcjmyWeakStaQKMhENlRK2mJSCEONyXff/+9K3JIcTt6FF5/3ba0b2ambaxxYxg2DO68U8v6ikixUm3xErkH4I9xkDYJ8nNsY5Wvh8bDIfwGNSMickGak+NrcnNhyhQYORIyMmxjDRrYziO56y41IyIi4rgTh20nsG98+cwJ7JWaQZMXIaKdmhER+UdFakoSExOZPn06oaGhJCYmXnTfuXPnOiWYOFl+Pnz4IQwdCjtPrQVfu7atGenSRdO0RKTYqbZ4gfxc2xStDaMg99RKjRWuhCYjIeoWNSMiUmRFakrCwsLsc3rDwsJcGkiczBhYsACSkmDdOttYVJRtmtZDD8E5J5OKiBQX1RYPZqyw8yP47T9wdLttLCQWmo6C6Lt0AruIOMxijDHuDuFu2dnZhIWFkZWVRWhoqLvjOM9vv8Fzz8GiRbb7YWG2ZX6ffBKCgtybTUQK8drPIh/ltX+eGT/Ammfh4M+2+4GRtnNGaj0EpfRFl0hJ4kmfQzqnxBvt2wf/+Q9Mm2Y7UlKmDDzxBLzwAlTSVXJFROQSZG+GtQNgz2e2+6VDIC4J6veD0sHuTCYiXkBNiTc5fty2tO/o0XDkiG3s3nthzBiIiXFvNhER8Ux5WbBhJGx6DawnwOIHdR6xHR0pW8Xd6UTES6gp8QbGwOefQ//+tquuAyQk2BqU5s3dm01ERDyTscK26bB24JmT2CNvgqtegbA4t0YTEe+jpsTTbdoETz0FKSm2+1Wrwtix0K2blvcVEZFLc2A1rH4cDq623Q+tB1e9ClE3uzeXiHity2pKjh8/TtmyZZ2VRRxx7BiMGmW7+OGJE7bzRp57znbeSLDm9oqI51JtcaPcg/DbINgyFTC280YaD4d6T+okdhFxKYe/Srdarbz00ktUrVqVcuXKsW3bNgCGDBnCu+++6/SAch5ffw1xcbZzR06cgJtvhg0bbE2KGhIR8UCqLW5mDGybCV/Vgy1TAAM174fb06BBfzUkIuJyDjclI0eOZPr06SQnJ1OmTBn7eOPGjXnnnXecGg6gZs2aWCyWQj+PP/44AMYYhg8fTlRUFIGBgbRp04YNGzY4PYc7rVy5kvfff5818+fDPffArbfaLoBYvTrMmwfz50OdOu6OKSJyyYqztqiunKkrK1euhOw0+O5GWNEdcvdDWENolwot3ofACHdHFRFfYRxUu3Zts2jRImOMMeXKlTNbt241xhizceNGU758eUef7h9lZGSYffv22X8WLlxoAPP9998bY4wZO3asCQkJMXPmzDHr16839957r4mMjDTZ2dlFfo2srCwDmKysLKfnv1wDBgwwgOkNJtP2XZYxfn7GPPecMUeOuDueiDhRSf4scrXirC3FUVeMKbl/nqfrSmk/zKBOmLz3/Yz5EGM+CjRmw1hj8vPcHVFEnKSkfg6dj8PnlOzdu5c65/lW3mq1cuLEictqkM6ncuXKBe6PHTuW2rVr07p1a4wxTJw4kcGDB5OYmAjAjBkzCA8PZ9asWTz66KPnfc7c3Fxyc3Pt97Ozs52e2xlWrlzJe8nJfAe0PTW2CgicNo3GDzzgxmQiIs5VnLXFFXUFPKO2rFy5kuTkZGqHw6dPw5U1API5FNiM8u0/hHK13B1RRHyUw9O3GjZsyI8//lho/JNPPiE+Pt4poS4kLy+PDz74gJ49e2KxWNi+fTvp6el06NDBvk9AQACtW7dm2bJlF3yeMWPGEBYWZv+Jjo52ae5LlZaWxlhsDclR4BmgObDWnaFERFzAXbXFWXUFPKO2pKWlAfDfnraGZP9huP8t+PJIHzUkIuJWDh8pGTZsGA888AB79+7FarUyd+5cNm3axMyZM/nqq69ckdHus88+49ChQ/To0QOA9PR0AMLDwwvsFx4ezs6dOy/4PIMGDaJ///72+9nZ2SWyeMSFh3N6JfhbgB9O3a5bt66bEomIuIa7aouz6gp4Rm2pW7cuDarCjY0g3woJQ2FbBjz5Sj13RxMRH+fwkZLbb7+d2bNn8/XXX2OxWBg6dCgbN27kyy+/pH379q7IaPfuu+9y8803ExUVVWDcYrEUuG+MKTR2toCAAEJDQwv8lERX//YbgcAazjQkSUlJJCQkuDGViIjzuau2OKuugGfUloSEBN4ZYDvy9PkvtoZEdUVESoJLuk5Jx44d6dixo7OzXNTOnTtZtGgRc+fOtY9FRNhWBUlPTycyMtI+npGRUehbLo+Tnw9vvQVA+cGDmVmvHnXr1lXhEBGvVdy1xefqCkBeFi0i0uAkhFw1kBUrOquuiEiJ4PCRktWrV9uWEDzHypUr+fnnn50S6nymTZtGlSpVuPXWW+1jMTExREREsHDhQvtYXl4eqamptGjRwmVZisX8+bBjB1SsSK3Bg3nggQdUOETEa7mjtvhcXQHYPgNOHoWwONrfP1p1RURKDIebkscff5zdu3cXGt+7d699jXdns1qtTJs2je7du1O69JmDOxaLhX79+jF69GjmzZvH77//To8ePQgKCqJbt24uyVJs3njD9rt3bwgMdG8WEREXK+7a4pN1xVghbZLtdt0n4B+mo4mIFCeHp2/98ccfXHXVVYXG4+Pj+eOPP5wS6lyLFi1i165d9OzZs9C2AQMGkJOTQ9++fcnMzCQhIYGUlBRCQkJckqVY/N//waJFtoLRp4+704iIuFxx1xafqysA+xbC4c3gHwo1tay8iJQsDjclAQEB/PXXX9SqVXDpwH379hX4tsmZOnTogDHmvNssFgvDhw9n+PDhLnlttzh1Lgm33QY1a7o1iohIcSju2uJzdQVg85u23zHdwb+ce7OIiJzD4elb7du3Z9CgQWRlZdnHDh06xAsvvODy1bd8wpEjMGOG7fYTT7g3i4hIMVFtcbEjO2DvqaWV67pmqrWIyOVw+OunV155hVatWlGjRg37Ba3Wrl1LeHg477//vtMD+pwPP4TsbKhTB9q1c3caEZFiodriYlv+CxgIvxFCdU0SESl5HG5Kqlatyrp16/jwww/57bffCAwM5KGHHqJr1674+/u7IqPvMAbePHV4vW9fKOXwgSwREY+k2uJC+cdh6zu22zpKIiIl1CVN1A0ODuaRRx5xdhb56SdYv9622tapqwuLiPgK1RYX2fUJ5O6HoGioeru704iInNclNSVpaWksWbKEjIwMrFZrgW1Dhw51SjCfdPoE9/vugwoV3JtFRKSYqba4SNqp2lLnUSjlmgVpREQul8OfTlOnTqVPnz5cccUVREREYDlrnXOLxaLCcanS02HOHNttF13vRUSkpFJtcZGDa+DACijlD7V7uzuNiMgFOdyUjBw5klGjRpGUlOSKPL7r3XfhxAlo3hyuvNLdaUREipVqi4tsftv2O/puCAx3bxYRkYtw+EzqzMxM/v3vf7sii+/Kz4f//td2WxdLFBEfpNriAnmHYMcs2+1Y1RYRKdkcbkr+/e9/k5KS4oosvmv+fNi9GypVAhVlEfFBqi0usH0m5B+DsEZQ+Xp3pxERuSiHp2/VqVOHIUOGsGLFCho3blxoqcannnrKaeF8xtunDq/36gVly7o3i4iIG6i2OJkxZ6Zu1e0LZ52jIyJSElmMMcaRB8TExFz4ySwWtm3bdtmhilt2djZhYWFkZWURGhpavC++davtQokWC2zZArVqFe/ri0iJ4dbPIjdTbXGyv76HxTdA6XJw55/gH1K8ry8iJYIn1RWHj5Rs377dFTl815Qptt8dO6ohERGfpdriZJsn237XvF8NiYh4BF0y3J1yc+G992y3dYK7iIg4Q85fsHuu7XbsY+7NIiJSRJd0FaU9e/bwxRdfsGvXLvLy8gpsmzBhglOC+YS5c2H/fqhWDW65xd1pRETcSrXFSba9B+YkXNEcKjR1dxoRkSJxuClZvHgxnTp1IiYmhk2bNtGoUSN27NiBMYarrrrKFRm91+kT3B9+GErrKrsi4rtUW5zEmg9bTi0xX0dHSUTEczg8fWvQoEE8++yz/P7775QtW5Y5c+awe/duWrdurTXmHbFhA/z4I/j52VbdEhHxYaotTrJvARzdCWUqQHX9dxMRz+FwU7Jx40a6d+8OQOnSpcnJyaFcuXK8+OKLjBs3zukBvdbpiyV26gRVq7o3i4iIm6m2OMmWUye4x/SA0oFujSIi4giHm5Lg4GByc3MBiIqKYuvWrfZt+/fvd14yb3bsGMycabv9mA6vi4iotjjB0d3w53zb7dhH3ZtFRMRBDp/I0KxZM5YuXUpcXBy33norzz77LOvXr2fu3Lk0a9bMFRm9z8cfQ1aWbQngdu3cnUZExO1UW5xg67tgrFClDYTWc3caERGHONyUTJgwgSNHjgAwfPhwjhw5wuzZs6lTpw6vvvqq0wN6pdNTtx5+GEppVWYREdWWy2Q9CVvfsd2uo6MkIuJ5HL6iuzcq1qtdrlsHTZvaVtvaswfCw137eiLiMTzpyrvyz4r1z3PPl/BDJwi4AjrvAb8A176eiHgET6orJf5r+r1793L//fdTqVIlgoKCuPLKK/nll1/s240xDB8+nKioKAIDA2nTpg0bNmxwY+J/cPoK7p07qyEREXETr6stp5cBrtVDDYmIeKQiTd+qUKECFoulSE948ODBywp0tszMTFq2bEnbtm355ptvqFKlClu3bqV8+fL2fZKTk5kwYQLTp0+nbt26jBw5kvbt27Np0yZCQkKclsUZVqem0vS99ygD8KgOr4uIb1NtcY5ff/qcpnu/ppQFqP2wu+OIiFySIjUlEydOtN8+cOAAI0eOpGPHjjRv3hyA5cuXs2DBAoYMGeLUcOPGjSM6Oppp06bZx2rWrGm/bYxh4sSJDB48mMTERABmzJhBeHg4s2bN4tES9A//pKQkMpKTmQZsBaampDBWJ7mLiA9Tbbl8SUlJBG1NJj4RvtsAC357V0soi4hHcvickrvuuou2bdvyxBNPFBifNGkSixYt4rPPPnNauLi4ODp27MiePXtITU2latWq9O3bl4cftn0TtG3bNmrXrs2aNWuIj4+3P+6OO+6gfPnyzJgx47zPm5uba196Emzz7aKjo102327lypU0a9aMZUBzIAlIBlasWEFCQoLTX09EPJMnzf11NtUWx61cuZKWLZqx4zWoVhG6ToKPlqu2iMgZnlRXHD6nZMGCBdx0002Fxjt27MiiRYucEuq0bdu28fbbbxMbG8uCBQt47LHHeOqpp5h56hof6enpAISfc25GeHi4fdv5jBkzhrCwMPtPdHS0U3OfKy0tDYDXgUXA9HPGRUR8nWqL49LS0ripqa0h2X8Y5q4+My4i4mkcbkoqVarEvHnzCo1/9tlnVKpUySmhTrNarVx11VWMHj2a+Ph4Hn30UR5++GHefvvtAvudOyfZGHPRecqDBg0iKyvL/rN7926n5j5X3bp1AfgIaA9knDMuIuLrVFscV7duXR5ua7s980fIO3lmXETE0zh8nZIRI0bQq1cvlixZYp/3u2LFCr799lveeecdp4aLjIwkLi6uwFiDBg2YM2cOABEREYDtW63IyEj7PhkZGYW+4TpbQEAAAQHFtzpJQkICAwYMIDk52T6WlJSkw+siIqeotjguoXE0+VssgGHq97Yx1RYR8VQONyU9evSgQYMGvP7668ydOxdjDHFxcSxdutTpH4QtW7Zk06ZNBcbS0tKoUaMGADExMURERLBw4UL7vN+8vDxSU1NL3Il+48aNIzExkbS0NOrWrauiISJyFtWWS7BtGn4Ww+GyTXhh7HOqLSLi2UwJtmrVKlO6dGkzatQos3nzZvPhhx+aoKAg88EHH9j3GTt2rAkLCzNz584169evN127djWRkZEmOzu7yK+TlZVlAJOVleWKtyEiUiT6LCoeXlFbrPnGfBZjzIcYs3W6859fRLyCJ9UVh4+UAGzdupVp06axbds2Jk6cSJUqVfj222+Jjo6mYcOGTmuYrr32WubNm8egQYN48cUXiYmJYeLEidx33332fQYMGEBOTg59+/YlMzOThIQEUlJSStw68iIicnGqLQ5IXwxHt4N/GFT/t7vTiIhcNoeXBE5NTeXmm2+mZcuW/PDDD2zcuJFatWqRnJzMqlWr+PTTT12V1WU8abk0EfFevvxZpNrioJ/uhV0fQ2xfuPZN5z63iHgNT6orDq++NXDgQEaOHMnChQspU6aMfbxt27YsX77cqeFERMQ3qLY4IPcA7PnMdrt2b7dGERFxFoebkvXr13PnnXcWGq9cuTIHDhxwSigREfEtqi0O2P4BWPOgQjxUjP/n/UVEPIDDTUn58uXZt29fofFff/2VqlWrOiWUiIj4FtWWIjIGtp5aIllHSUTEizjclHTr1o2kpCTS09OxWCxYrVaWLl3Kc889x4MPPuiKjCIi4uVUW4rowGrI+h38ykLNbu5OIyLiNA43JaNGjaJ69epUrVqVI0eOEBcXR6tWrWjRogX/+c9/XJFRRES8nGpLEW171/Y7+i4oU96tUUREnMnh1bdO27p1K7/++itWq5X4+HhiY2Odna3YeNLKBCLivfRZpNpyUSePwtxIOHkYbvwewttc/nOKiFfzpLpySdcpAYiOjubkyZPUrl2b0qUv+WlERETsVFsuYtccW0NSrhZUae3uNCIiTuXw9K1jx47Rq1cvgoKCaNiwIbt27QLgqaeeYuzYsU4PKCIi3k+1pQi2vWf7XasnWCzuzSIi4mQONyWDBg3it99+Y8mSJZQtW9Y+3q5dO2bPnu3UcCIi4htUW/7B4a2QkQpYIEYn/ouI93H42Phnn33G7NmzadasGZazvqmJi4tj69atTg0nIiK+QbXlH2ybbvsd2QGCo90aRUTEFRw+UvL3339TpUqVQuNHjx4tUEhERESKSrXlIqz5sH267Xath9waRUTEVRxuSq699lrmz59vv3+6WEydOpXmzZs7L5mIiPgM1ZaL+GsxHNsDZSpAtTvcnUZExCUcnr41ZswYbrrpJv744w9OnjzJa6+9xoYNG1i+fDmpqamuyCgiIl5OteUitp46wb3mfbaLJoqIeCGHj5S0aNGCpUuXcuzYMWrXrk1KSgrh4eEsX76cq6++2hUZRUTEy6m2XEBeJuz5zHa7Vg93JhERcalLWgS+cePGzJgxw9lZRETEh6m2nMfO2WDNhfKNocJV7k4jIuIyDh8p+frrr1mwYEGh8QULFvDNN984JZSIiPgW1ZYLOL3qVkwPXZtERLyaw03JwIEDyc/PLzRujGHgwIFOCSUiIr5FteU8sv4PDqwEi5/tfBIRES/mcFOyefNm4uLiCo3Xr1+fLVu2OCWUiIj4FtWW89h+aipb1C0QGO7eLCIiLuZwUxIWFsa2bdsKjW/ZsoXg4GCnhBIREd+i2nIOaz5sn2m7rRPcRcQHONyUdOrUiX79+hW4wu6WLVt49tln6dSpk1PDiYiIb1BtOUf6Isj5E8pUhKhb3Z1GRMTlHG5Kxo8fT3BwMPXr1ycmJoaYmBgaNGhApUqVePnll12RUUREvJxqyzlOHyWp0RX8AtybRUSkGFzS9K1ly5Yxf/58+vbty7PPPsvixYv57rvvKF++vFPDDR8+HIvFUuAnIiLCvt0Yw/Dhw4mKiiIwMJA2bdqwYcMGp2YQERHXU205y4ls2DPPdrtW9+J7XRERN3L4OiV//fUX4eHhdOjQgQ4dOhTYtm7dOpo0aeK0cAANGzZk0aJF9vt+fn7228nJyUyYMIHp06dTt25dRo4cSfv27dm0aRMhISFOzSEiIq6j2nKWXXMgPwdC60PFa1z/eiIiJYDDR0oaN27MF198UWj85ZdfJiEhwSmhzla6dGkiIiLsP5UrVwZs32RNnDiRwYMHk5iYSKNGjZgxYwbHjh1j1qxZTs8hIiKuo9pyltNTt2Ie1LVJRMRnONyUJCUlce+99/LYY4+Rk5PD3r17ueGGGxg/fjyzZ892esDNmzcTFRVFTEwMXbp0sa/Osn37dtLT0wt8oxYQEEDr1q1ZtmzZRZ8zNzeX7OzsAj8iIuI+qi2nHN0JGUsAi65NIiI+xeGm5Nlnn2XFihUsXbqUJk2a0KRJEwIDA1m3bp3TV0hJSEhg5syZLFiwgKlTp5Kenk6LFi04cOAA6enpAISHF1y7PTw83L7tQsaMGUNYWJj9Jzo62qm5RUTEMaotp2z/4NQLtoXg6o4/XkTEQznclADUqlWLhg0bsmPHDrKzs7nnnnsKfYA7w80338xdd91F48aNadeuHfPnzwdgxowZ9n0s5xzaNsYUGjvXoEGDyMrKsv/s3r3b6dlFRMQxPl9bjCk4dUtExIc43JSc/hZry5YtrFu3jrfffpsnn3ySe+65h8zMTFdktAsODqZx48Zs3rzZvlLKud9cZWRk/GMRCwgIIDQ0tMCPiIi4j2oLcGA1HE4Dv0CITnTssSIiHs7hpuSGG27g3nvvZfny5TRo0IDevXvz66+/smfPHho3buyKjHa5ubls3LiRyMhIYmJiiIiIYOHChfbteXl5pKam0qJFC5fmEBER51JtAXacmrpV7U7w1wqSIuJbHF4SOCUlhdatWxcYq127Nj/99BOjRo1yWjCA5557jttvv53q1auTkZHByJEjyc7Opnv37lgsFvr168fo0aOJjY0lNjaW0aNHExQURLdu3ZyaQ0REXMvna4v1BOz8yHY75n7XvY6ISAnlcFNyumhs2bKFrVu30qpVKwIDA7FYLAwZMsSp4fbs2UPXrl3Zv38/lStXplmzZqxYsYIaNWoAMGDAAHJycujbty+ZmZkkJCSQkpKia5SIiHgYn68t+1Ig928IqAwR7V33OiIiJZTFGGMcecCBAwe45557+P7777FYLGzevJlatWrRq1cvKlSowMsvv+yqrC6TnZ1NWFgYWVlZOr9ERNzGlz+LfL62LO1qO1JS9ym45rXiCSgiXs+T6orD55Q888wz+Pv7s2vXLoKCguzj9957L998841Tw4mIiG/w6dpyIhv2fGa7ralbIuKjLumckgULFlCtWrUC47GxsezcudNpwURExHf4dG3ZPQ/yj0NIXah4jbvTiIi4hcNHSo4ePVrgW6zT9u/fT0BAgFNCiYiIb/Hp2rLjQ9vvmvfDP1wLRUTEWznclLRq1YqZM2fa71ssFqxWK+PHj6dt27ZODSciIr7BZ2tLTjr8tdh2u6ZWjhQR3+Xw9K3x48fTpk0bfv75Z/Ly8hgwYAAbNmzg4MGDLF261BUZRUTEy/lsbdk5G4wVKjWDkNruTiMi4jYOHymJi4tj3bp1XHfddbRv356jR4+SmJjIr7/+Su3a+kAVERHH+Wxt2TnL9ltHSUTExzm8JLA38qTl0kTEe+mzyLv845/n4S3wZSxYSkHnPyEwvPhDiohX86S64vCREhEREXGCHf+z/Q5vp4ZERHyemhIREZHiZgzsPL3qlqZuiYioKRERESlumWshexOUCoDoO92dRkTE7dSUiIiIFLedH9l+V70N/Ev2PG8RkeKgpkRERKQ4GXOmKanR1b1ZRERKiCJdpyQ+Ph5LEa8yu2bNmssKJCIivsFna8v+FXBsF5QuB1G3uDuNiEiJUKSmpHPnzi6OISIivsZna8vpoyTVOkPpQLdGEREpKYrUlAwbNszVOURExMf4ZG2x5sOuj223a3RxbxYRkRJE55SIiIgUl79/gOPpUKYCRLR3dxoRkRKjSEdKzpafn8+rr77Kxx9/zK5du8jLyyuw/eDBg04LJyIivsFnasvpqVvRd4FfGfdmEREpQRw+UjJixAgmTJjAPffcQ1ZWFv379ycxMZFSpUoxfPhwF0QUERFv5xO1xXoCds+x3dbULRGRAhxuSj788EOmTp3Kc889R+nSpenatSvvvPMOQ4cOZcWKFa7IKCIiXs4nakv6d5B7AMpWgSqt3Z1GRKREcbgpSU9Pp3HjxgCUK1eOrKwsAG677Tbmz5/v3HQiIuITfKK27P7E9jv6Lijl8OxpERGv5nBTUq1aNfbt2wdAnTp1SElJAWD16tUEBAQ4N52IiPgEr68t1hOwe67tdvV73JtFRKQEcrgpufPOO1m8eDEATz/9NEOGDCE2NpYHH3yQnj17Oj3g2caMGYPFYqFfv372MWMMw4cPJyoqisDAQNq0acOGDRtcmkNERJzL62tL+mLIy4Sy4VD5X5cfWkTEyzh8/Hjs2LH223fffTfR0dEsXbqUOnXq0KlTJ6eGO9vq1auZMmUKTZo0KTCenJzMhAkTmD59OnXr1mXkyJG0b9+eTZs2ERIS4rI8IiLiPF5fW3adPXXLzwnJRUS8y2VfpyQhIYH+/fu7tGgcOXKE++67j6lTp1KhQgX7uDGGiRMnMnjwYBITE2nUqBEzZszg2LFjzJo1y2V5RETEtbyqtuTnwZ55ttuauiUicl4OHykZM2YM4eHhhQ6nv/fee/z9998kJSU5Ldxpjz/+OLfeeivt2rVj5MiR9vHt27eTnp5Ohw4d7GMBAQG0bt2aZcuW8eijj573+XJzc8nNzbXfP31CZXZ2ttOzi4gU1enPIGOMm5MUP6+uLdu+gUOZULYyBDQB1RoRKSaeVFccbkr++9//nvebooYNG9KlSxenF46PPvqINWvWsHr16kLb0tPTAQgPDy8wHh4ezs6dOy/4nGPGjGHEiBGFxqOjoy8zrYjI5Ttw4ABhYWHujlGsvLq2XPPgqVt/AxUvObOIyKXyhLricFOSnp5OZGRkofHKlSvbV05xlt27d/P000+TkpJC2bJlL7ifxWIpcN8YU2jsbIMGDaJ///72+1arlYMHD1KpUqWLPu5yZWdnEx0dze7duwkNDXXZ6xQnvSfPoPfkGbKysqhevToVK/reP1xVWy6dN/6/oPfkGfSeSj5PqisONyWnTz6MiYkpML506VKioqKcFgzgl19+ISMjg6uvvto+lp+fzw8//MCkSZPYtGkTULiYZWRkFPqG62wBAQGFlpgsX768U7NfTGhoqFf8RT+b3pNn0HvyDKVKXfbpfh5HteXyeeP/C3pPnkHvqeTzhLricFPSu3dv+vXrx4kTJ7jhhhsAWLx4MQMGDODZZ591argbb7yR9evXFxh76KGHqF+/PklJSdSqVYuIiAgWLlxIfHw8AHl5eaSmpjJu3DinZhEREddRbRER8W0ONyUDBgzg4MGD9O3bl7y8PADKli1LUlISgwYNcmq4kJAQGjVqVGAsODiYSpUq2cf79evH6NGjiY2NJTY2ltGjRxMUFES3bt2cmkVERFxHtUVExLc53JRYLBbGjRvHkCFD2LhxI4GBgcTGxrrtirsDBgwgJyeHvn37kpmZSUJCAikpKSXyGiUBAQEMGzbMO65OfIrek2fQe/IM3vieikq15dJ5498bvSfPoPdU8nnS+7GYy1gjbM+ePVgsFqpWrerMTCIi4sNUW0REfI/DZ71YrVZefPFFwsLCqFGjBtWrV6d8+fK89NJLWK1WV2QUEREvp9oiIuLbHJ6+NXjwYN59913Gjh1Ly5YtMcawdOlShg8fzvHjxxk1apQrcoqIiBdTbRER8W0OT9+Kiopi8uTJdOrUqcD4559/Tt++fdm7d69TA4qIiPdTbRER8W0OT986ePAg9evXLzRev359Dh486JRQIiLiW1RbRER8m8NNSdOmTZk0aVKh8UmTJtG0aVOnhPI2Y8aM4dprryUkJIQqVarQuXNn+8W5vMGYMWOwWCz069fP3VEu2969e7n//vupVKkSQUFBXHnllfzyyy/ujnVJTp48yX/+8x9iYmIIDAykVq1avPjiix41P/+HH37g9ttvJyoqCovFwmeffVZguzGG4cOHExUVRWBgIG3atGHDhg3uCVtEF3tPJ06cICkpicaNGxMcHExUVBQPPvggf/75p/sCFxPVFseptngGb6oroNpSUnlDbXG4KUlOTua9994jLi6OXr160bt3b+Li4pg+fTrjx493RUaPl5qayuOPP86KFStYuHAhJ0+epEOHDhw9etTd0S7b6tWrmTJlCk2aNHF3lMuWmZlJy5Yt8ff355tvvuGPP/7glVdeKdYrMjvTuHHjmDx5MpMmTWLjxo0kJyczfvx43njjDXdHK7KjR49e8B+rYPs8mjBhApMmTWL16tVERETQvn17Dh8+XMxJi+5i7+nYsWOsWbOGIUOGsGbNGubOnUtaWlqhKU3eSLXFcaotJZ+31RVQbSmpvKK2mEuwd+9e88ILL5jExERz5513msGDB5u9e/deylP5pIyMDAOY1NRUd0e5LIcPHzaxsbFm4cKFpnXr1ubpp592d6TLkpSUZK6//np3x3CaW2+91fTs2bPAWGJiorn//vvdlOjyAGbevHn2+1ar1URERJixY8fax44fP27CwsLM5MmT3ZDQcee+p/NZtWqVAczOnTuLJ5QbqbZcHtWWksfb6ooxqi2ewFNri8NHSsB2QuKoUaOYM2cOc+fOZeTIkeTn59OzZ09n9UpeLSsrC4CKFSu6Ocnlefzxx7n11ltp166du6M4xRdffME111zDv//9b6pUqUJ8fDxTp051d6xLdv3117N48WLS0tIA+O233/jpp5+45ZZb3JzMObZv3056ejodOnSwjwUEBNC6dWuWLVvmxmTOlZWVhcVi8ehvVotKteXyqLaUPN5WV0C1xVuUxNpySU3J+Rw8eJAZM2Y46+m8ljGG/v37c/3119OoUSN3x7lkH330EWvWrGHMmDHujuI027Zt4+233yY2NpYFCxbw2GOP8dRTTzFz5kx3R7skSUlJdO3alfr16+Pv7098fDz9+vWja9eu7o7mFOnp6QCEh4cXGA8PD7dv83THjx9n4MCBdOvWjdDQUHfHcQvVlqJRbSmZvK2ugGqLNyiptcXh65TI5XniiSdYt24dP/30k7ujXLLdu3fz9NNPk5KSQtmyZd0dx2msVivXXHMNo0ePBiA+Pp4NGzbw9ttv8+CDD7o5neNmz57NBx98wKxZs2jYsCFr166lX79+REVF0b17d3fHcxqLxVLgvjGm0JgnOnHiBF26dMFqtfLWW2+5O46UcKotJZO31RVQbfF0Jbm2qCkpRk8++SRffPEFP/zwA9WqVXN3nEv2yy+/kJGRwdVXX20fy8/P54cffmDSpEnk5ubi5+fnxoSXJjIykri4uAJjDRo0YM6cOW5KdHmef/55Bg4cSJcuXQBo3LgxO3fuZMyYMV5ROCIiIgDbt1qRkZH28YyMjELfcHmaEydOcM8997B9+3a+++67EvVNlpQ8qi0ll7fVFVBt8WQlvbY4bfqWXJgxhieeeIK5c+fy3XffERMT4+5Il+XGG29k/fr1rF271v5zzTXXcN9997F27VqPKxqntWzZstBymmlpadSoUcNNiS7PsWPHKFWq4P/ifn5+HrVs48XExMQQERHBwoUL7WN5eXmkpqbSokULNya7PKeLxubNm1m0aBGVKlVydyQpoVRbSj5vqyug2uKpPKG2FPlISWJi4kW3Hzp06HKzeK3HH3+cWbNm8fnnnxMSEmKfkxgWFkZgYKCb0zkuJCSk0Jzl4OBgKlWq5NFzmZ955hlatGjB6NGjueeee1i1ahVTpkxhypQp7o52SW6//XZGjRpF9erVadiwIb/++isTJkzwqJOGjxw5wpYtW+z3t2/fztq1a6lYsSLVq1enX79+jB49mtjYWGJjYxk9ejRBQUF069bNjakv7mLvKSoqirvvvps1a9bw1VdfkZ+fb/+8qFixImXKlHFXbJdRbbl0qi0ln7fVFVBtKam8obZYjDGmKDs+9NBDRXrCadOmXVYgb3ShOYjTpk2jR48exRvGRdq0acOVV17JxIkT3R3lsnz11VcMGjSIzZs3ExMTQ//+/Xn44YfdHeuSHD58mCFDhjBv3jwyMjKIioqia9euDB06tMR8AP2TJUuW0LZt20Lj3bt3Z/r06RhjGDFiBP/973/JzMwkISGBN998s0T/A+Zi72n48OEX/Lb7+++/p02bNi5OV/xUWy6daotn8Ka6AqotJZU31JYiNyUiIiIiIiKuoHNKRERERETErdSUiIiIiIiIW6kpERERERERt1JTIiIiIiIibqWmRERERERE3EpNiYiIiIiIuJWaEhERERERcSs1JSIiIiIi4lZqSkScZMeOHVgsFtauXXtZz9OmTRv69ev3j/u1atWKWbNmXdZrFYe7776bCRMmuDuGiIhHUm05P9UW76OmRIqkR48eWCwWLBYLpUuXpnr16vTp04fMzMwiP4ezPlhLqujoaPbt20ejRo1c/lpfffUV6enpdOnSxeWvdbmGDh3KqFGjyM7OdncUESlhVFv+mWrL+am2eB81JVJkN910E/v27WPHjh288847fPnll/Tt29ctWfLy8tzyuheSl5eHn58fERERlC5d2uWv9/rrr/PQQw9RqpR7/xcuyp9DkyZNqFmzJh9++GExJBIRT6PacmGqLRem2uJ91JRIkQUEBBAREUG1atXo0KED9957LykpKQX2mTZtGg0aNKBs2bLUr1+ft956y74tJiYGgPj4eCwWC23atAHOf0i5c+fO9OjRw36/Zs2ajBw5kh49ehAWFsbDDz/M9OnTKV++PAsWLKBBgwaUK1fOXtwuZMmSJVgsFubPn0/Tpk0pW7YsCQkJrF+/vsB+y5Yto1WrVgQGBhIdHc1TTz3F0aNHL5rnfN/Wpaamct111xEQEEBkZCQDBw7k5MmT9u1Hjx7lwQcfpFy5ckRGRvLKK69c9M8AYP/+/SxatIhOnTrZx3r27Mltt91WYL+TJ08SERHBe++9B4AxhuTkZGrVqkVgYCBNmzbl008/te+fn59Pr169iImJITAwkHr16vHaa68VeM4ePXrQuXNnxowZQ1RUFHXr1gXgrbfeIjY2lrJlyxIeHs7dd99d4HGdOnXif//73z++NxHxPaotqi2qLQKAESmC7t27mzvuuMN+f+vWrSYuLs6Eh4fbx6ZMmWIiIyPNnDlzzLZt28ycOXNMxYoVzfTp040xxqxatcoAZtGiRWbfvn3mwIEDxhhjWrdubZ5++ukCr3fHHXeY7t272+/XqFHDhIaGmvHjx5vNmzebzZs3m2nTphl/f3/Trl07s3r1avPLL7+YBg0amG7dul3wfXz//fcGMA0aNDApKSlm3bp15rbbbjM1a9Y0eXl5xhhj1q1bZ8qVK2deffVVk5aWZpYuXWri4+NNjx49Lppn+/btBjC//vqrMcaYPXv2mKCgINO3b1+zceNGM2/ePHPFFVeYYcOG2Z+nT58+plq1agWylCtXrtB/j7PNmzfPBAcHm/z8fPvY0qVLjZ+fn/nzzz/tY59//rkJDg42hw8fNsYY88ILL5j69eubb7/91mzdutVMmzbNBAQEmCVLlhhjjMnLyzNDhw41q1atMtu2bTMffPCBCQoKMrNnz7Y/Z/fu3U25cuXMAw88YH7//Xezfv16s3r1auPn52dmzZplduzYYdasWWNee+21Apm//vprExAQYI4fP37B9yUivke1RbXFGNUWsVFTIkXSvXt34+fnZ4KDg03ZsmUNYAAzYcIE+z7R0dFm1qxZBR730ksvmebNmxtjTKEP1tOKWjg6d+5cYJ9p06YZwGzZssU+9uabbxYoZuc6XTg++ugj+9iBAwdMYGCg/QPygQceMI888kiBx/3444+mVKlSJicn54J5zn1/L7zwgqlXr56xWq0F8pUrV87k5+ebw4cPmzJlypw3y8UKx6uvvmpq1apVaDwuLs6MGzfOfr9z5872YnfkyBFTtmxZs2zZsgKP6dWrl+natesFX6tv377mrrvust/v3r27CQ8PN7m5ufaxOXPmmNDQUJOdnX3B5/ntt98MYHbs2HHBfUTE96i2qLYYo9oiNq6foCheo23btrz99tscO3aMd955h7S0NJ588kkA/v77b3bv3k2vXr14+OGH7Y85efIkYWFhTnn9a665ptBYUFAQtWvXtt+PjIwkIyPjH5+refPm9tsVK1akXr16bNy4EYBffvmFLVu2FJinaozBarWyfft2GjRocME8Z9u4cSPNmzfHYrHYx1q2bMmRI0fYs2cPmZmZ5OXlnTfLxeTk5FC2bNlC471792bKlCkMGDCAjIwM5s+fz+LFiwH4448/OH78OO3bty/wmLy8POLj4+33J0+ezDvvvMPOnTvJyckhLy+PK6+8ssBjGjduTJkyZez327dvT40aNahVqxY33XQTN910E3feeSdBQUH2fQIDAwE4duzYRd+biPge1RbVFlBtEVBTIkUWHBxMnTp1ANvJcG3btmXEiBG89NJLWK1WAKZOnUpCQkKBx/n5+V30eUuVKoUxpsDYiRMnzvv65/L39y9w32KxFHquojr9AW+1Wnn00Ud56qmnCu1TvXr1i+Y5mzGmQNE4PXa5Oa+44orzrkzz4IMPMnDgQJYvX87y5cupWbMm//rXvwDsfz7z58+natWqBR4XEBAAwMcff8wzzzzDK6+8QvPmzQkJCWH8+PGsXLmywP7nvu+QkBDWrFnDkiVLSElJYejQoQwfPpzVq1dTvnx5AA4ePAhA5cqVL+k9i4j3Um1RbQHVFlFTIpdh2LBh3HzzzfTp04eoqCiqVq3Ktm3buO+++867/+lvQPLz8wuMV65cucAJhPn5+fz++++0bdvWZdlXrFhhLwKZmZmkpaVRv359AK666io2bNhgL5KXKi4ujjlz5hQoIMuWLSMkJISqVatSoUIF/P39z5uldevWF3ze+Ph40tPTyczMpEKFCvbxSpUq0blzZ6ZNm8by5ct56KGHCmQJCAhg165dF3zuH3/8kRYtWhRY9Wbr1q1Feq+lS5emXbt2tGvXjmHDhlG+fHm+++47EhMTAfj999+pVq0aV1xxRZGeT0R8l2rLxam2qLZ4KzUlcsnatGlDw4YNGT16NJMmTWL48OE89dRThIaGcvPNN5Obm8vPP/9MZmYm/fv3p0qVKgQGBvLtt99SrVo1ypYtS1hYGDfccAP9+/dn/vz51K5dm1dffZVDhw65NPuLL75IpUqVCA8PZ/DgwVxxxRV07twZgKSkJJo1a8bjjz/Oww8/THBwMBs3bmThwoW88cYbRX6Nvn37MnHiRJ588kmeeOIJNm3axLBhw+jfvz+lSpWiXLly9OrVi+eff75Aln9aijE+Pp7KlSuzdOnSQqui9O7dm9tuu438/Hy6d+9uHw8JCeG5557jmWeewWq1cv3115Odnc2yZcsoV64c3bt3p06dOsycOZMFCxYQExPD+++/z+rVq+0r21zIV199xbZt22jVqhUVKlTg66+/xmq1Fpgq8OOPP9KhQ4ci/7cTEd+l2nJxqi2qLV7LHSeyiOc5d4WU0z788ENTpkwZs2vXLvv9K6+80pQpU8ZUqFDBtGrVysydO9e+/9SpU010dLQpVaqUad26tTHGtjJHnz59TMWKFU2VKlXMmDFjznsy4quvvlrgtadNm2bCwsIKjM2bN89c7K/16ZMRv/zyS9OwYUNTpkwZc+2115q1a9cW2G/VqlWmffv2ply5ciY4ONg0adLEjBo16qJ5zney5ZIlS8y1115rypQpYyIiIkxSUpI5ceKEffvhw4fN/fffb4KCgkx4eLhJTk4+78mZ5xo4cKDp0qVLoXGr1Wpq1KhhbrnllvNue+2110y9evWMv7+/qVy5sunYsaNJTU01xhhz/Phx06NHDxMWFmbKly9v+vTpYwYOHGiaNm1qf47z/T348ccfTevWrU2FChVMYGCgadKkSYFVVXJyckxoaKhZvnz5Rd+TiPge1RbVFmNUW8TGYswlTj4U8UBLliyhbdu2ZGZm2uekeqK//vqLhg0b8ssvv1CjRg37+LFjx4iKiuK9996zH952tzfffJPPP/+80HUHRES8hWpL8VNt8T66eKKIBwoPD+fdd99l165dgO1kwz///JMhQ4YQFhZW4OJX7ubv7+/Q1AQREXEP1RZxJ51TIuKh7rjjDvvtXbt2ERMTQ7Vq1Zg+fTqlS5ec/7UfeeQRd0cQEZEiUm0Rd9H0LRERERERcStN3xIREREREbdSUyIiIiIiIm6lpkRERERERNxKTYmIiIiIiLiVmhIREREREXErNSUiIiIiIuJWakpERERERMSt1JSIiIiIiIhb/T838V/vPdrLUwAAAABJRU5ErkJggg==", + "text/plain": [ + "
    " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot different extrapolation methods at at centroid\n", + "import matplotlib.pyplot as plt\n", + "\n", + "fig, axes = plt.subplots(2, 2, figsize=(9, 6))\n", + "plt.subplots_adjust(wspace=0.4, hspace=0.4)\n", + "\n", + "for axis, local_exceedance_intensity, color, title in zip(\n", + " axes.flatten(),\n", + " [interpolated, extrapolated, interpolated_binned, extrapolated_binned],\n", + " [\"teal\", \"g\", \"r\", \"orange\"],\n", + " [\n", + " '\"interpolate\"',\n", + " '\"extrapolate\"',\n", + " '\"interpolate\", bin_decimals = 1',\n", + " '\"extrapolate\", bin_decimals = 1',\n", + " ],\n", + "):\n", + " axis.plot(\n", + " test_return_periods,\n", + " local_exceedance_intensity.values[0, 1:],\n", + " color=color,\n", + " )\n", + " axis.set_ylabel(\"Local exceedance internsity (m/s)\")\n", + " axis.set_xlabel(\"Return period (years)\")\n", + " if title in ['\"interpolate\"', '\"extrapolate\"']:\n", + " cum_freq = np.arange(5, 0, -1) * hazard_binning.frequency[0]\n", + " intensities = np.sort(hazard_binning.intensity[:, 0].toarray())[::-1]\n", + " else:\n", + " cum_freq = np.array([5, 4, 2]) * hazard_binning.frequency[0]\n", + " intensities = np.sort(\n", + " np.unique(np.round(hazard_binning.intensity[:, 0], decimals=1).toarray())\n", + " )\n", + " axis.scatter(\n", + " 1 / cum_freq,\n", + " intensities,\n", + " s=10,\n", + " color=\"k\",\n", + " )\n", + " axis.set_title(f\"method = {title}\")\n", + " axis.set_xlim([1, 12])\n", + " axis.set_ylim([40, 100])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Given the hazard distribution in the hazard object (black points), the user might prefer flat extrapolation behaviour to large return periods, in which case the default `bin_decimals=None` is the correct choice. \n", + "\n", + "However, in the inverse problem of computing a return period for a given hazard intensity, not binning the values can lead to an unbounded extrapolation, and binning the values might be a good choice." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Local return periods [years] without binning:\n", + "\n", + "| | geometry | 55.0 | 75.0 | 85.0 |\n", + "|---:|:------------|--------:|--------:|------------:|\n", + "| 0 | POINT (2 1) | 1.76331 | 4.11019 | 5.09816e+73 |\n", + "\n", + "\n", + "Local return periods [years] with binning to bin_decimals=1:\n", + "\n", + "| | geometry | 55.0 | 75.0 | 85.0 |\n", + "|---:|:------------|--------:|--------:|--------:|\n", + "| 0 | POINT (2 1) | 1.76331 | 3.57665 | 6.84921 |\n" + ] + } + ], + "source": [ + "test_hazard_intensities = [55.0, 75.0, 85.0]\n", + "print(\"Local return periods [years] without binning:\\n\")\n", + "print(\n", + " hazard_binning.local_return_period(\n", + " threshold_intensities=test_hazard_intensities,\n", + " method=\"extrapolate\",\n", + " )[0].to_markdown()\n", + ")\n", + "print(\"\\n\\nLocal return periods [years] with binning to bin_decimals=1:\\n\")\n", + "print(\n", + " hazard_binning.local_return_period(\n", + " threshold_intensities=test_hazard_intensities,\n", + " method=\"extrapolate\",\n", + " bin_decimals=1,\n", + " )[0].to_markdown()\n", + ")" + ] } ], "metadata": { diff --git a/doc/tutorial/climada_util_yearsets.ipynb b/doc/user-guide/climada_util_yearsets.ipynb similarity index 100% rename from doc/tutorial/climada_util_yearsets.ipynb rename to doc/user-guide/climada_util_yearsets.ipynb diff --git a/doc/tutorial/exposures.rst b/doc/user-guide/exposures.rst similarity index 52% rename from doc/tutorial/exposures.rst rename to doc/user-guide/exposures.rst index c5a278fc7..846846e67 100644 --- a/doc/tutorial/exposures.rst +++ b/doc/user-guide/exposures.rst @@ -2,6 +2,10 @@ Exposures Tutorials =================== +These guides present the `Exposures` class, as the main object to handle exposure data, +as well as the `LitPop` subclass which allows to estimate exposure using nightlight intensity and +population count data. We also show how to handle polygons or lines with CLIMADA. + .. toctree:: :maxdepth: 1 diff --git a/doc/tutorial/hazard.rst b/doc/user-guide/hazard.rst similarity index 62% rename from doc/tutorial/hazard.rst rename to doc/user-guide/hazard.rst index 248dacd82..dbf38bbc0 100644 --- a/doc/tutorial/hazard.rst +++ b/doc/user-guide/hazard.rst @@ -2,6 +2,9 @@ Hazard Tutorials ================ +These guides present the `Hazard` class as well as subclasses +that handle tropical cyclones and winter storms more specifically. + .. toctree:: :maxdepth: 1 diff --git a/doc/tutorial/img/UncertaintySensitivity.jpg b/doc/user-guide/img/UncertaintySensitivity.jpg similarity index 100% rename from doc/tutorial/img/UncertaintySensitivity.jpg rename to doc/user-guide/img/UncertaintySensitivity.jpg diff --git a/doc/user-guide/img/cost-benefit.png b/doc/user-guide/img/cost-benefit.png new file mode 100644 index 0000000000000000000000000000000000000000..6e10294106c826ccfb712320250021b6260f4dc2 GIT binary patch literal 18708 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 DjD5Fl literal 0 HcmV?d00001 diff --git a/doc/user-guide/img/exposure.png b/doc/user-guide/img/exposure.png new file mode 100644 index 0000000000000000000000000000000000000000..ae87af65c1060bf09fdb2fea02a9ebbcf2d5e147 GIT binary patch literal 172053 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�~mBa1O2gdC(NP-*qO=LS20OE%ya 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�`X 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�|T&P?!D+i&8l@G7KSc}fsG^7 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 z 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≷GbCi7@?BxB@-!L8 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