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/__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/impact_calc_strat.py b/climada/trajectories/impact_calc_strat.py new file mode 100644 index 000000000..c712d71ff --- /dev/null +++ b/climada/trajectories/impact_calc_strat.py @@ -0,0 +1,267 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +This modules implements the impact computation strategy objects for trajectories. + +""" + +import copy +from abc import ABC, abstractmethod +from typing import Any, Optional, Union + +import numpy as np +from scipy import sparse + +from climada.engine.impact import Impact +from climada.engine.impact_calc import ImpactCalc +from climada.entity.exposures.base import Exposures +from climada.entity.impact_funcs.impact_func_set import ImpactFuncSet +from climada.hazard.base import Hazard + + +class ImpactComputationStrategy(ABC): + """ + Interface for impact computation strategies. + + This abstract class defines the contract for all concrete strategies + responsible for calculating and optionally modifying the total impact + based on a set of inputs (exposure, hazard, vulnerability). + """ + + @abstractmethod + def compute_impacts( + self, + exp: Exposures, + haz: Hazard, + vul: ImpactFuncSet, + risk_transf_attach: Optional[float] = None, + risk_transf_cover: Optional[float] = None, + calc_residual: bool = True, + ) -> Impact: + """ + Calculates the total impact, including optional risk transfer application. + + Parameters + ---------- + exp : Exposures + The exposure data. + haz : Hazard + The hazard data (e.g., event intensity). + vul : ImpactFuncSet + The set of vulnerability functions. + risk_transf_attach : float, optional + The attachment point (deductible) for the global risk transfer mechanism. + If None, default to 0. + risk_transf_cover : float, optional + The cover limit for the risk transfer mechanism. If None, the cover + is assumed to be infinite (only the attachment applies). + calc_residual : bool, default=True + If True, the function returns the residual impact (after risk transfer). + If False, it returns the transferred impact (the part covered by the + risk transfer). + + Returns + ------- + Impact + An object containing the computed total impact matrix and metrics. + + See Also + -------- + ImpactCalcComputation : The default implementation of this interface. + """ + pass + + +class ImpactCalcComputation(ImpactComputationStrategy): + """ + Default impact computation strategy. + + This strategy first calculates the raw impact using the standard + :class:`ImpactCalc` logic and then applies a global risk transfer mechanism. + """ + + def compute_impacts( + self, + exp: Exposures, + haz: Hazard, + vul: ImpactFuncSet, + risk_transf_attach: Optional[float] = None, + risk_transf_cover: Optional[float] = None, + calc_residual: bool = False, + ) -> Impact: + """ + Calculates the impact and applies the risk transfer mechanism. + + This overrides the abstract method to implement the default strategy. + + Parameters + ---------- + exp : Exposures + The exposure data. + haz : Hazard + The hazard data. + vul : ImpactFuncSet + The set of vulnerability functions. + risk_transf_attach : float, optional + The attachment point (deductible) for the risk transfer mechanism. + risk_transf_cover : float, optional + The cover limit for the risk transfer mechanism. + calc_residual : bool, default=False + If True, returns the residual impact. If False, returns the transferred impact. + + Returns + ------- + Impact + The final impact object (either residual or transferred). + """ + impact = self.compute_impacts_pre_transfer(exp, haz, vul) + self._apply_risk_transfer( + impact, risk_transf_attach, risk_transf_cover, calc_residual + ) + return impact + + def compute_impacts_pre_transfer( + self, + exp: Exposures, + haz: Hazard, + vul: ImpactFuncSet, + ) -> Impact: + """ + Calculates the raw impact matrix before any risk transfer is applied. + + Parameters + ---------- + exp : Exposures + The exposure data. + haz : Hazard + The hazard data. + vul : ImpactFuncSet + The set of vulnerability functions. + + Returns + ------- + Impact + An Impact object containing the raw, pre-transfer impact matrix. + """ + return ImpactCalc(exposures=exp, impfset=vul, hazard=haz).impact() + + def _apply_risk_transfer( + self, + impact: Impact, + risk_transf_attach: Optional[float], + risk_transf_cover: Optional[float], + calc_residual: bool, + ) -> None: + """ + Applies risk transfer logic and modifies the Impact object in-place. + + Parameters + ---------- + impact : Impact + The Impact object whose impact matrix will be modified. + risk_transf_attach : float, optional + The attachment point. + risk_transf_cover : float, optional + The cover limit. + calc_residual : bool + Determines whether to set the matrix to the residual or transferred impact. + """ + if risk_transf_attach is not None or risk_transf_cover is not None: + # Assuming impact.imp_mat is a sparse matrix, which is a common pattern + 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: Union[ + sparse.csr_matrix, Any + ], # Use Any if sparse.csr_matrix is too restrictive + attachement: Optional[float], + cover: Optional[float], + calc_residual: bool, + ) -> Union[sparse.csr_matrix, Any]: + """ + Calculates either the residual or the risk transfer impact matrix + based on a global risk transfer mechanism. + + This function modifies the original impact matrix values proportionally + based on the total event impact relative to the attachment and cover. + + Parameters + ---------- + imp_mat : scipy.sparse.csr_matrix or object with .data + The original impact matrix (events x exposure points). + attachement : float, optional + The attachment point (deductible). + cover : float, optional + The cover limit. + calc_residual : bool + If True, the function returns the residual impact matrix. + If False, it returns the transferred risk impact matrix. + + Returns + ------- + scipy.sparse.csr_matrix or object with .data + The adjusted impact matrix (residual or transferred). + + Notes + ----- + The calculation is performed event-wise: + + 1. **Total Impact**: Calculate the total impact for each event + (sum of impacts across all exposure points). + 2. **Transferred Risk per Event**: Defined as: + $$\min(\max(0, \text{Total Impact} - \text{attachement}), \text{cover})$$ + 3. **Residual Risk per Event**: + $$\text{Total Impact} - \text{Transferred Risk per Event}$$ + 4. **Adjustment**: The original impact per exposure point is scaled + by the ratio of (Residual Risk / Total Impact) or + (Transferred Risk / Total Impact) for that event. + This ensures the risk transfer is shared proportionally among all + impacted exposure points. + """ + 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 + attachement = 0 if attachement is None else attachement + cover = np.inf if cover is None else cover + transfer_at_event = np.minimum( + np.maximum(total_at_event - attachement, 0), 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]) + + return result_matrix diff --git a/climada/trajectories/interpolated_trajectory.py b/climada/trajectories/interpolated_trajectory.py new file mode 100644 index 000000000..7834dd103 --- /dev/null +++ b/climada/trajectories/interpolated_trajectory.py @@ -0,0 +1,757 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +This file implements interpolated risk trajectory objects, to allow a better evaluation +of risk in between points in time (snapshots). + +""" + +import datetime +import itertools +import logging + +import matplotlib.dates as mdates +import matplotlib.pyplot as plt +import matplotlib.ticker as mticker +import pandas as pd +from pandas.tseries.frequencies import to_offset + +from climada.entity.disc_rates.base import DiscRates +from climada.trajectories.impact_calc_strat import ImpactCalcComputation +from climada.trajectories.interpolation import InterpolationStrategyBase +from climada.trajectories.riskperiod import ( + AllLinearStrategy, + CalcRiskMetricsPeriod, + ImpactComputationStrategy, +) +from climada.trajectories.snapshot import Snapshot +from climada.trajectories.trajectory import DEFAULT_RP, RiskTrajectory +from climada.util import log_level + +LOGGER = logging.getLogger(__name__) + + +class InterpolatedRiskTrajectory(RiskTrajectory): + """Calculates risk trajectories over a series of snapshots. + + This class computes risk metrics over a series of snapshots, + optionally applying risk discounting. + + """ + + _grouper = ["measure", "metric"] + """Results dataframe grouper""" + + POSSIBLE_METRICS = [ + "eai", + "aai", + "return_periods", + "risk_contributions", + "aai_per_group", + ] + + def __init__( + self, + snapshots_list: list[Snapshot], + *, + return_periods: list[int] = DEFAULT_RP, + time_resolution: str = "Y", + all_groups_name: str = "All", + risk_disc_rates: DiscRates | None = None, + interpolation_strategy: InterpolationStrategyBase | None = None, + impact_computation_strategy: ImpactComputationStrategy | None = None, + ): + super().__init__( + snapshots_list, + return_periods=return_periods, + all_groups_name=all_groups_name, + risk_disc_rates=risk_disc_rates, + ) + self._risk_metrics_up_to_date: bool = False + self.start_date = min([snapshot.date for snapshot in snapshots_list]) + self.end_date = max([snapshot.date for snapshot in snapshots_list]) + self._risk_metrics_calculators = self._reset_risk_metrics_calculators( + self._snapshots, + time_resolution, + interpolation_strategy or AllLinearStrategy(), + impact_computation_strategy or ImpactCalcComputation(), + ) + + @property + def interpolation_strategy(self) -> InterpolationStrategyBase: + """The approach used to interpolate impact matrices in between the two snapshots.""" + return self._risk_metrics_calculators[0].interpolation_strategy + + @interpolation_strategy.setter + def interpolation_strategy(self, value, /): + if not isinstance(value, InterpolationStrategyBase): + raise ValueError("Not an interpolation strategy") + + self._reset_metrics() + for rmcalc in self._risk_metrics_calculators: + rmcalc.interpolation_strategy = value + + @property + def impact_computation_strategy(self) -> ImpactComputationStrategy: + """The method used to calculate the impact from the (Haz,Exp,Vul) of the two snapshots.""" + return self._risk_metrics_calculators[0].impact_computation_strategy + + @impact_computation_strategy.setter + def impact_computation_strategy(self, value, /): + if not isinstance(value, ImpactComputationStrategy): + raise ValueError("Not an interpolation strategy") + + self._reset_metrics() + for rmcalc in self._risk_metrics_calculators: + rmcalc.impact_computation_strategy = value + + @property + def time_resolution(self) -> str: + """The return period values to use when computing risk period metrics. + + Notes + ----- + + Changing its value resets the corresponding metric. + """ + return self._risk_metrics_calculators[0].time_resolution + + @time_resolution.setter + def time_resolution(self, value, /): + if not isinstance(value, str): + raise ValueError( + 'time_resolution should be a valid pandas Period frequency string (e.g., `"Y"`, `"M"`, `"D"`).' + ) + self._reset_metrics() + for rmcalc in self._risk_metrics_calculators: + rmcalc.time_resolution = value + + @staticmethod + def _reset_risk_metrics_calculators( + snapshots: list[Snapshot], + time_resolution, + interpolation_strategy, + impact_computation_strategy, + ) -> list[CalcRiskMetricsPeriod]: + """Creates the `CalcRiskPeriod` objects corresponding to a given list of 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 [ + CalcRiskMetricsPeriod( + start_snapshot, + end_snapshot, + time_resolution=time_resolution, + interpolation_strategy=interpolation_strategy, + impact_computation_strategy=impact_computation_strategy, + ) + for start_snapshot, end_snapshot in pairwise( + sorted(snapshots, key=lambda snap: snap.date) + ) + ] + + def _generic_metrics( + self, + metric_name: str | None = None, + metric_meth: str | None = None, + **kwargs, + ) -> pd.DataFrame: + """Generic method to compute metrics based on the provided metric name and method.""" + if metric_name is None or metric_meth is None: + raise ValueError("Both metric_name and metric_meth must be provided.") + + if metric_name not in self.POSSIBLE_METRICS: + raise NotImplementedError( + f"{metric_name} not implemented ({self.POSSIBLE_METRICS})." + ) + + # Construct the attribute name for storing the metric results + attr_name = f"_{metric_name}_metrics" + + if getattr(self, attr_name) is not None: + LOGGER.debug(f"Returning cached {attr_name}") + return getattr(self, attr_name) + + LOGGER.debug(f"Computing {attr_name}") + with log_level(level="WARNING", name_prefix="climada"): + tmp = [ + getattr(calc_period, metric_meth)(**kwargs) + for calc_period in self._risk_metrics_calculators + ] + + # Notably for per_group_aai being None: + try: + tmp = pd.concat(tmp) + if len(tmp) == 0: + return pd.DataFrame() + except ValueError as e: + if str(e) == "All objects passed were None": + return pd.DataFrame() + else: + 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) + + # When more than 2 snapshots, there are duplicated rows, we need to remove them. + tmp = tmp[~tmp.index.duplicated(keep="first")] + tmp = tmp.reset_index() + tmp["group"] = tmp["group"].cat.add_categories([self._all_groups_name]) + 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"] + ] + + if metric_name == "risk_contributions" and len(self._snapshots) > 2: + # If there is more than one Snapshot, we need to update the + # contributions from previous periods for continuity + # and to set the base risk from the first period + # This is not elegant, but we need the concatenated metrics from each period, + # so we can't do it in the calculators, and we need + # to do it before caching in the private attribute + tmp = self._risk_contributions_post_treatment(tmp) + + setattr(self, attr_name, tmp) + + if self._risk_disc_rates: + return self.npv_transform( + getattr(self, attr_name), self._risk_disc_rates + ) + + return getattr(self, attr_name) + + def _compute_period_metrics( + self, metric_name: str, metric_meth: str, **kwargs + ) -> pd.DataFrame: + """Helper method to compute total metrics per period (i.e. whole ranges between pairs of consecutive snapshots).""" + df = self._generic_metrics( + metric_name=metric_name, metric_meth=metric_meth, **kwargs + ) + return self._date_to_period_agg(df, grouper=self._grouper) + + def eai_metrics(self, **kwargs) -> pd.DataFrame: + """Return the estimated annual impacts at each exposure point for each date. + + This method computes and return a `DataFrame` with eai metric + (for each exposure point) for each date. + + + Notes + ----- + + This computation may become quite expensive for big areas with high resolution. + + """ + df = self._compute_metrics( + metric_name="eai", metric_meth="calc_eai_gdf", **kwargs + ) + return df + + def aai_metrics(self, **kwargs) -> pd.DataFrame: + """Return the average annual impacts for each date. + + This method computes and return a `DataFrame` with aai metric for each date. + + """ + + return self._compute_metrics( + metric_name="aai", metric_meth="calc_aai_metric", **kwargs + ) + + def return_periods_metrics(self, **kwargs) -> pd.DataFrame: + return self._compute_metrics( + metric_name="return_periods", + metric_meth="calc_return_periods_metric", + return_periods=self.return_periods, + **kwargs, + ) + + def aai_per_group_metrics(self, **kwargs) -> pd.DataFrame: + """Return the average annual impacts for each exposure group ID. + + This method computes and return a `DataFrame` with aai metric for each + of the exposure group defined by a group id, for each date. + + """ + + return self._compute_metrics( + metric_name="aai_per_group", + metric_meth="calc_aai_per_group_metric", + **kwargs, + ) + + def risk_contributions_metrics(self, **kwargs) -> pd.DataFrame: + """Return the "contributions" of change in future risk (Exposure and Hazard) + + This method returns the contributions of the change in risk at each date: + + - The 'base risk', i.e., the risk without change in hazard or exposure, compared to trajectory's earliest date. + - The 'exposure contribution', i.e., the additional risks due to change in exposure (only) + - The 'hazard contribution', i.e., the additional risks due to change in hazard (only) + - The 'vulnerability contribution', i.e., the additional risks due to change in vulnerability (only) + - The 'interaction contribution', i.e., the additional risks due to the interaction term + + + """ + + return self._compute_metrics( + metric_name="risk_contributions", + metric_meth="calc_risk_contributions_metric", + **kwargs, + ) + + def _risk_contributions_post_treatment(self, df) -> pd.DataFrame: + df.set_index(["group", "date", "measure", "metric"], inplace=True) + start_dates = [snap.date for snap in self._snapshots[:-1]] + end_dates = [ + snap.date - to_offset(self.time_resolution) for snap in self._snapshots[1:] + ] + periods_dates = list(zip(start_dates, end_dates)) + df.loc[pd.IndexSlice[:, :, :, "base risk"]] = df.loc[ + pd.IndexSlice[ + :, + pd.to_datetime(self.start_date).to_period(self.time_resolution), + :, + "base risk", + ] + ].values + for p2 in periods_dates[1:]: + for metric in [ + "exposure contribution", + "hazard contribution", + "vulnerability contribution", + "interaction contribution", + ]: + mask_last_previous = ( + df.index.get_level_values(1) + == pd.to_datetime(p2[0]).to_period(self.time_resolution) + ) & (df.index.get_level_values(3) == metric) + mask_to_update = ( + ( + df.index.get_level_values(1) + > pd.to_datetime(p2[0]).to_period(self.time_resolution) + ) + & ( + df.index.get_level_values(1) + <= pd.to_datetime(p2[1]).to_period(self.time_resolution) + ) + & (df.index.get_level_values(3) == metric) + ) + + df.loc[mask_to_update, "risk"] += df.loc[ + mask_last_previous, "risk" + ].iloc[0] + + return df.reset_index() + + def per_date_risk_metrics( + self, + metrics: list[str] | None = None, + ) -> pd.DataFrame | pd.Series: + """Returns a DataFrame of risk metrics for each dates + + This methods collects (and if needed computes) the `metrics` + (Defaulting to "aai", "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 + ) + if "aai" in metrics: + metrics_df.append(self.aai_metrics()) + if "return_periods" in metrics: + metrics_df.append(self.return_periods_metrics()) + if "aai_per_group" in metrics: + metrics_df.append(self.aai_per_group_metrics()) + + return pd.concat(metrics_df) + + @staticmethod + def _get_risk_periods( + risk_periods: list[CalcRiskMetricsPeriod], + start_date: datetime.date, + end_date: datetime.date, + strict: bool = True, + ): + """Returns risk periods from the given list that are within `start_date` and `end_date`. + + Parameters + ---------- + risk_periods : list[CalcRiskPeriod] + The list of risk periods to look through + start_date : datetime.date + end_date : datetime.date + strict: bool, default True + If true, only returns periods stricly within start and end dates. Else, + returns periods that have an overlap within start and end. + """ + if strict: + return [ + period + for period in risk_periods + if ( + start_date <= period.snapshot_start.date + and end_date >= period.snapshot_end.date + ) + ] + else: + return [ + period + for period in risk_periods + if not ( + start_date >= period.snapshot_end.date + or end_date <= period.snapshot_start.date + ) + ] + + @staticmethod + def _identify_continuous_periods(group, time_unit): + # Calculate the difference between consecutive dates + if time_unit == "year": + group["date_diff"] = group["date"].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 + + @classmethod + def _date_to_period_agg( + cls, + df: pd.DataFrame, + grouper: list[str], + time_unit: str = "year", + colname: str | list[str] = "risk", + ) -> pd.DataFrame: + """Groups per date risk metric to periods.""" + + ## I'm thinking this does not work with RPs... As you can't just sum impacts + ## Not sure what to do with it. -> Fixed I take the avg RP impact of the period + def conditional_agg(group): + try: + if "rp" in group.name[2]: + return group.mean() + else: + return group.sum() + except IndexError: + return group.sum() + + df_sorted = df.sort_values(by=grouper + ["date"]) + + if "group" in df.columns and "group" not in grouper: + grouper = ["group"] + grouper + + # Apply the function to identify continuous periods + df_periods = df_sorted.groupby( + grouper, dropna=False, group_keys=False, observed=True + ).apply(cls._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"), + } + + df_periods_dates = ( + df_periods.groupby(grouper + ["period_id"], dropna=False, observed=True) + .agg(**agg_dict) + .reset_index() + ) + + df_periods_dates["period"] = ( + df_periods_dates["start_date"].astype(str) + + " to " + + df_periods_dates["end_date"].astype(str) + ) + + df_periods = ( + df_periods.groupby(grouper + ["period_id"], dropna=False, observed=True)[ + colname + ] + .apply(conditional_agg) + .reset_index() + ) + df_periods = pd.merge( + df_periods_dates[grouper + ["period"]], df_periods, on=grouper + ) + df_periods = df_periods.drop(["period_id"], axis=1) + return df_periods[ + ["period"] + [col for col in df_periods.columns if col != "period"] + ] + + def per_period_risk_metrics( + self, metrics: list[str] = ["aai", "return_periods", "aai_per_group"], **kwargs + ) -> pd.DataFrame: + """Returns a tidy dataframe of the risk metrics with the total for each different period.""" + df = self.per_date_risk_metrics(metrics=metrics, **kwargs) + return self._date_to_period_agg(df, grouper=self._grouper, **kwargs) + + def _calc_waterfall_plot_data( + self, + start_date: datetime.date | None = None, + end_date: datetime.date | None = None, + ): + """Compute the required data for the waterfall plot between `start_date` and `end_date`.""" + start_date = self.start_date if start_date is None else start_date + end_date = self.end_date if end_date is None else end_date + risk_contributions = self.risk_contributions_metrics() + risk_contributions = risk_contributions.loc[ + (risk_contributions["date"] >= str(start_date)) + & (risk_contributions["date"] <= str(end_date)) + ] + risk_contributions = risk_contributions.set_index(["date", "metric"])[ + "risk" + ].unstack() + return risk_contributions + + def plot_time_waterfall( + self, + ax=None, + start_date: datetime.date | None = None, + end_date: datetime.date | None = None, + figsize=(12, 6), + ): + """Plot a waterfall chart of risk contributions over a specified date range. + + This method generates a stacked bar chart to visualize the + risk contributions 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 contributions. + + 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. + + """ + if ax is None: + fig, ax = plt.subplots(figsize=figsize) + else: + fig = ax.figure # get parent figure from the axis + 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_contribution = self._calc_waterfall_plot_data( + start_date=start_date, end_date=end_date + ) + risk_contribution = risk_contribution[ + [ + "base risk", + "exposure contribution", + "hazard contribution", + "vulnerability contribution", + "interaction contribution", + ] + ] + risk_contribution["base risk"] = risk_contribution.iloc[0]["base risk"] + # risk_contribution.plot(x="date", ax=ax, kind="bar", stacked=True) + ax.stackplot( + risk_contribution.index.to_timestamp(), + [risk_contribution[col] for col in risk_contribution.columns], + labels=risk_contribution.columns, + ) + ax.legend() + # bottom = [0] * len(risk_contribution) + # for col in risk_contribution.columns: + # bottom = [b + v for b, v in zip(bottom, risk_contribution[col])] + # Construct y-axis label and title based on parameters + value_label = "USD" + title_label = f"Risk between {start_date} and {end_date} (Average impact)" + + locator = mdates.AutoDateLocator() + formatter = mdates.ConciseDateFormatter(locator) + + ax.xaxis.set_major_locator(locator) + ax.xaxis.set_major_formatter(formatter) + ax.yaxis.set_major_formatter(mticker.EngFormatter()) + ax.set_title(title_label) + ax.set_ylabel(value_label) + ax.set_ylim(0.0, 1.1 * ax.get_ylim()[1]) + return fig, ax + + def plot_waterfall( + self, + ax=None, + start_date: datetime.date | None = None, + end_date: datetime.date | None = None, + ): + """Plot a waterfall chart of risk contributions between two dates. + + This method generates a waterfall plot to visualize the changes in risk contributions + 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. + + """ + 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 + start_date_p = pd.to_datetime(start_date).to_period(self.time_resolution) + end_date_p = pd.to_datetime(end_date).to_period(self.time_resolution) + risk_contribution = self._calc_waterfall_plot_data( + start_date=start_date, end_date=end_date + ) + if ax is None: + _, ax = plt.subplots(figsize=(8, 5)) + + risk_contribution = risk_contribution.loc[ + (risk_contribution.index == str(end_date)) + ].squeeze() + + labels = [ + f"Risk {start_date_p}", + f"Exposure contribution {end_date_p}", + f"Hazard contribution {end_date_p}", + f"Vulnerability contribution {end_date_p}", + f"Interaction contribution {end_date_p}", + f"Total Risk {end_date_p}", + ] + values = [ + risk_contribution["base risk"], + risk_contribution["exposure contribution"], + risk_contribution["hazard contribution"], + risk_contribution["vulnerability contribution"], + risk_contribution["interaction contribution"], + risk_contribution.sum(), + ] + bottoms = [ + 0.0, + risk_contribution["base risk"], + risk_contribution["base risk"] + risk_contribution["exposure contribution"], + risk_contribution["base risk"] + + risk_contribution["exposure contribution"] + + risk_contribution["hazard contribution"], + risk_contribution["base risk"] + + risk_contribution["exposure contribution"] + + risk_contribution["hazard contribution"] + + risk_contribution["vulnerability contribution"], + 0.0, + ] + + ax.bar( + labels, + values, + bottom=bottoms, + edgecolor="black", + color=[ + "tab:cyan", + "tab:orange", + "tab:green", + "tab:red", + "tab:purple", + "tab:blue", + ], + ) + for i 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"Evolution of the contributions of risk between {start_date_p} and {end_date_p} (Average impact)" + ax.yaxis.set_major_formatter(mticker.EngFormatter()) + ax.set_title(title_label) + ax.set_ylabel(value_label) + ax.set_ylim(0.0, 1.1 * ax.get_ylim()[1]) + ax.tick_params( + axis="x", + labelrotation=90, + ) + + return ax diff --git a/climada/trajectories/interpolation.py b/climada/trajectories/interpolation.py new file mode 100644 index 000000000..c1ff23624 --- /dev/null +++ b/climada/trajectories/interpolation.py @@ -0,0 +1,468 @@ +""" +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 +from typing import Any, Callable, Dict, List, Optional + +import numpy as np +from scipy import sparse + +LOGGER = logging.getLogger(__name__) + +# Define a type alias for the expected signature of the metric interpolation functions +# (e.g., linear_interp_arrays) +MetricInterpFunc = Callable[ + [np.ndarray, np.ndarray, Optional[Dict[str, Any]]], np.ndarray +] + +# Define a type alias for the expected signature of the matrix interpolation function +# (e.g., linear_interp_imp_mat) +MatrixInterpFunc = Callable[ + [sparse.csr_matrix, sparse.csr_matrix, int, Optional[Dict[str, Any]]], + List[sparse.csr_matrix], +] + + +def linear_interp_imp_mat( + mat_start: sparse.csr_matrix, + mat_end: sparse.csr_matrix, + number_of_interpolation_points: int, +) -> List[sparse.csr_matrix]: + """ + Linearly interpolates between two sparse impact matrices. + + Creates a sequence of matrices representing a linear transition from a starting + matrix to an ending matrix. The interpolation includes both the start and end + points. + + Parameters + ---------- + mat_start : scipy.sparse.csr_matrix + The starting impact matrix. Must have a shape compatible with `mat_end` + for arithmetic operations. + mat_end : scipy.sparse.csr_matrix + The ending impact matrix. Must have a shape compatible with `mat_start` + for arithmetic operations. + number_of_interpolation_points : int + The total number of matrices to return, including the start and end points. + Must be $\ge 2$. + + Returns + ------- + list of scipy.sparse.csr_matrix + A list of matrices, where the first element is `mat_start` and the last + element is `mat_end`. The total length of the list is + `number_of_interpolation_points`. + + Notes + ----- + The formula used for interpolation at proportion $p$ is: + $$M_p = M_{start} \cdot (1 - p) + M_{end} \cdot p$$ + The proportions $p$ range from 0 to 1, inclusive. + """ + return [ + mat_start + prop * (mat_end - mat_start) + for prop in np.linspace(0, 1, number_of_interpolation_points) + ] + + +# Assuming the matrix object type is complex and not easily type-hinted beyond 'Any' +# If a specific custom type exists (e.g., 'ImpactMatrix'), that should be used instead of 'Any'. + + +def exponential_interp_imp_mat( + mat_start: Any, mat_end: Any, number_of_interpolation_points: int, rate: float +) -> List[Any]: + """ + Exponentially interpolates between two "impact matrices" using a specified rate. + + This function performs interpolation in a logarithmic space, effectively + achieving an exponential-like transition between `mat_start` and `mat_end`. + It is designed for objects that wrap NumPy arrays and expose them via a + `.data` attribute. + + Parameters + ---------- + mat_start : object + The starting matrix object. Must have a `.data` attribute that is a + NumPy array of positive values. + mat_end : object + The ending matrix object. Must have a `.data` attribute that is a + NumPy array of positive values and have a compatible shape with `mat_start`. + number_of_interpolation_points : int + The total number of matrix objects to return, including the start and + end points. Must be $\ge 2$. + rate : float + The base rate used for the exponential scaling. Must be positive ($> 0$). + It determines the scaling factor used in the logarithmic conversion. + + Returns + ------- + list of object + A list of interpolated matrix objects. The first element corresponds to + `mat_start` and the last to `mat_end` (after the conversion/reversion). + The list length is `number_of_interpolation_points`. + + Raises + ------ + ValueError + If `rate` is less than or equal to zero. + + Notes + ----- + The interpolation is achieved by: + + 1. Mapping the matrix data to a transformed logarithmic space: + $$M'_{i} = \frac{\ln(M_{i})}{\ln(\text{rate})}$$ + (where $\ln$ is the natural logarithm, and $\epsilon$ is added to $M_{i}$ + to prevent $\ln(0)$). + 2. Performing standard linear interpolation on the transformed matrices + $M'_{start}$ and $M'_{end}$ to get $M'_{interp}$: + $$M'_{interp} = M'_{start} \cdot (1 - \text{ratio}) + M'_{end} \cdot \text{ratio}$$ + 3. Mapping the result back to the original domain: + $$M_{interp} = \exp(M'_{interp} \cdot \ln(\text{rate}))$$ + + This process assumes the values in the original matrices are growth/impact + factors that should be compounded. + """ + # ... function body remains the same ... + # Convert matrices to logarithmic domain + if rate <= 0: + raise ValueError("Rate for exponential interpolation must be positive") + + mat_start = mat_start.copy() + mat_end = mat_end.copy() + log_rate = np.log(rate) + mat_start.data = np.log(mat_start.data + np.finfo(float).eps) / log_rate + mat_end.data = np.log(mat_end.data + np.finfo(float).eps) / log_rate + + # Perform linear interpolation in the logarithmic domain + res = [] + num_points = number_of_interpolation_points + for point in range(num_points): + ratio = point / (num_points - 1) + mat_interpolated = mat_start * (1 - ratio) + ratio * mat_end + mat_interpolated.data = np.exp(mat_interpolated.data * log_rate) + res.append(mat_interpolated) + return res + + +def linear_interp_arrays(arr_start: np.ndarray, arr_end: np.ndarray) -> np.ndarray: + """ + Performs linear interpolation between two NumPy arrays over their first dimension. + + This function interpolates each metric (column) linearly across the time steps + (rows), including both the start and end states. + + Parameters + ---------- + arr_start : numpy.ndarray + The starting array of metrics. The first dimension (rows) is assumed to + represent the interpolation steps (e.g., dates/time points). + arr_end : numpy.ndarray + The ending array of metrics. Must have the exact same shape as `arr_start`. + + Returns + ------- + numpy.ndarray + An array with the same shape as `arr_start` and `arr_end`. The values + in the first dimension transition linearly from those in `arr_start` + to those in `arr_end`. + + Raises + ------ + ValueError + If `arr_start` and `arr_end` do not have the same shape. + + Notes + ----- + The interpolation is performed element-wise along the first dimension + (axis 0). For each row $i$ and proportion $p_i$, the result $R_i$ is calculated as: + + $$R_i = arr\_start_i \cdot (1 - p_i) + arr\_end_i \cdot p_i$$ + + where $p_i$ is generated by $\text{np.linspace}(0, 1, n)$ and $n$ is the + size of the first dimension ($\text{arr\_start.shape}[0]$). + """ + if arr_start.shape != arr_end.shape: + raise ValueError( + f"Cannot interpolate arrays of different shapes: {arr_start.shape} and {arr_end.shape}." + ) + interpolation_range = arr_start.shape[0] + prop1 = np.linspace(0, 1, interpolation_range) + prop0 = 1 - prop1 + if arr_start.ndim > 1: + prop0, prop1 = prop0.reshape(-1, 1), prop1.reshape(-1, 1) + + return np.multiply(arr_start, prop0) + np.multiply(arr_end, prop1) + + +def exponential_interp_arrays( + arr_start: np.ndarray, arr_end: np.ndarray, rate: float +) -> np.ndarray: + """ + Performs exponential interpolation between two NumPy arrays over their first dimension. + + This function achieves an exponential-like transition by performing linear + interpolation in the logarithmic space, suitable for metrics that represent + growth factors. + + Parameters + ---------- + arr_start : numpy.ndarray + The starting array of metrics. Values must be positive. + arr_end : numpy.ndarray + The ending array of metrics. Must have the exact same shape as `arr_start`. + rate : float + The base rate used for the exponential scaling. Must be positive ($> 0$). + It defines the base for the logarithmic transformation. + + Returns + ------- + numpy.ndarray + An array with the same shape as `arr_start` and `arr_end`. The values + in the first dimension transition exponentially from those in `arr_start` + to those in `arr_end`. + + Raises + ------ + ValueError + If `arr_start` and `arr_end` do not have the same shape, or if `rate` is + less than or equal to zero. + + Notes + ----- + The interpolation is performed by transforming the arrays to a logarithmic + domain, linearly interpolating, and then transforming back. + + The formula for the interpolated result $R$ at proportion $\text{prop}$ is: + $$ + R = \exp \left( \left( + \frac{\ln(A_{start})}{\ln(\text{rate})} \cdot (1 - \text{prop}) + + \frac{\ln(A_{end})}{\ln(\text{rate})} \cdot \text{prop} + \right) \cdot \ln(\text{rate}) \right) + $$ + where $A_{start}$ and $A_{end}$ are the input arrays (with $\epsilon$ added + to prevent $\ln(0)$) and $\text{prop}$ ranges from 0 to 1. + """ + + if rate <= 0: + raise ValueError("Rate for exponential interpolation must be positive") + + if arr_start.shape != arr_end.shape: + raise ValueError( + f"Cannot interpolate arrays of different shapes: {arr_start.shape} and {arr_end.shape}." + ) + interpolation_range = arr_start.shape[0] + + prop1 = np.linspace(0, 1, interpolation_range) + prop0 = 1 - prop1 + if arr_start.ndim > 1: + prop0, prop1 = prop0.reshape(-1, 1), prop1.reshape(-1, 1) + + # Perform log transformation, linear interpolation, and exponential back-transformation + log_rate = np.log(rate) + log_arr_start = np.log(arr_start + np.finfo(float).eps) / log_rate + log_arr_end = np.log(arr_end + np.finfo(float).eps) / log_rate + + interpolated_log_arr = np.multiply(log_arr_start, prop0) + np.multiply( + log_arr_end, prop1 + ) + + return np.exp(interpolated_log_arr * log_rate) + + +class InterpolationStrategyBase(ABC): + """ + Base abstract class for defining a set of interpolation strategies. + + This class serves as a blueprint for implementing specific interpolation + methods (e.g., 'Linear', 'Exponential') across different impact dimensions: + Exposure (matrices), Hazard, and Vulnerability (arrays/metrics). + + Attributes + ---------- + exposure_interp : MatrixInterpFunc + The function used to interpolate sparse impact matrices over the + exposure dimension. + Signature: (mat_start, mat_end, num_points, **kwargs) -> list[sparse.csr_matrix]. + hazard_interp : MetricInterpFunc + The function used to interpolate NumPy arrays of metrics over the + hazard dimension. + Signature: (arr_start, arr_end, **kwargs) -> np.ndarray. + vulnerability_interp : MetricInterpFunc + The function used to interpolate NumPy arrays of metrics over the + vulnerability dimension. + Signature: (arr_start, arr_end, **kwargs) -> np.ndarray. + """ + + exposure_interp: MatrixInterpFunc + hazard_interp: MetricInterpFunc + vulnerability_interp: MetricInterpFunc + + def interp_over_exposure_dim( + self, + imp_E0: sparse.csr_matrix, + imp_E1: sparse.csr_matrix, + interpolation_range: int, + **kwargs: Optional[Dict[str, Any]], + ) -> List[sparse.csr_matrix]: + """ + Interpolates between two impact matrices using the defined exposure strategy. + + This method calls the function assigned to :attr:`exposure_interp` to generate + a sequence of matrices. + + Parameters + ---------- + imp_E0 : scipy.sparse.csr_matrix + A sparse matrix of the impacts at the start of the range. + imp_E1 : scipy.sparse.csr_matrix + A sparse matrix of the impacts at the end of the range. + interpolation_range : int + The total number of time points to interpolate, including the start and end. + **kwargs : Optional[ Dict[str, Any]] + Keyword arguments (e.g., 'rate' for exponential interpolation) to pass + to the underlying :attr:`exposure_interp` function. + + Returns + ------- + list of scipy.sparse.csr_matrix + A list of ``interpolation_range`` interpolated impact matrices. + + Raises + ------ + ValueError + If the underlying interpolation function raises a ``ValueError`` + indicating incompatible matrix shapes. + """ + try: + # Note: Assuming the Callable takes the exact positional arguments + res = self.exposure_interp(imp_E0, imp_E1, interpolation_range, **kwargs) + except ValueError as err: + # Specific error handling for clarity + if str(err) == "inconsistent shapes": + raise ValueError( + "Tried to interpolate impact matrices of different shape. " + "A possible reason could be Exposures of different shapes." + ) from err # Use 'from err' to chain the exception + + raise err + + return res + + def interp_over_hazard_dim( + self, + metric_0: np.ndarray, + metric_1: np.ndarray, + **kwargs: Optional[Dict[str, Any]], + ) -> np.ndarray: + """ + Interpolates between two metric arrays using the defined hazard strategy. + + This method calls the function assigned to :attr:`hazard_interp`. + + Parameters + ---------- + metric_0 : numpy.ndarray + The starting array of metrics. + metric_1 : numpy.ndarray + The ending array of metrics. Must have the same shape as ``metric_0``. + **kwargs : Optional[ Dict[str, Any]] + Keyword arguments to pass to the underlying :attr:`hazard_interp` function. + + Returns + ------- + numpy.ndarray + The resulting interpolated array. + """ + # Note: Assuming the Callable takes the exact positional arguments + return self.hazard_interp(metric_0, metric_1, **kwargs) + + def interp_over_vulnerability_dim( + self, + metric_0: np.ndarray, + metric_1: np.ndarray, + **kwargs: Optional[Dict[str, Any]], + ) -> np.ndarray: + """ + Interpolates between two metric arrays using the defined vulnerability strategy. + + This method calls the function assigned to :attr:`vulnerability_interp`. + + Parameters + ---------- + metric_0 : numpy.ndarray + The starting array of metrics. + metric_1 : numpy.ndarray + The ending array of metrics. Must have the same shape as ``metric_0``. + **kwargs : Optional[ Dict[str, Any]] + Keyword arguments to pass to the underlying :attr:`vulnerability_interp` function. + + Returns + ------- + numpy.ndarray + The resulting interpolated array. + """ + # Note: Assuming the Callable takes the exact positional arguments + return self.vulnerability_interp(metric_0, metric_1, **kwargs) + + +class InterpolationStrategy(InterpolationStrategyBase): + """Interface for interpolation strategies.""" + + def __init__( + self, + exposure_interp: Callable, + hazard_interp: Callable, + vulnerability_interp: Callable, + ) -> None: + super().__init__() + self.exposure_interp = exposure_interp + self.hazard_interp = hazard_interp + self.vulnerability_interp = vulnerability_interp + + +class AllLinearStrategy(InterpolationStrategyBase): + """Linear interpolation strategy.""" + + def __init__(self) -> None: + super().__init__() + self.exposure_interp = linear_interp_imp_mat + self.hazard_interp = linear_interp_arrays + self.vulnerability_interp = linear_interp_arrays + + +class ExponentialExposureStrategy(InterpolationStrategyBase): + """Exponential interpolation strategy.""" + + def __init__(self, rate) -> None: + super().__init__() + self.rate = rate + self.exposure_interp = ( + lambda mat_start, mat_end, points: exponential_interp_imp_mat( + mat_start, mat_end, points, self.rate + ) + ) + self.hazard_interp = linear_interp_arrays + self.vulnerability_interp = linear_interp_arrays diff --git a/climada/trajectories/riskperiod.py b/climada/trajectories/riskperiod.py new file mode 100644 index 000000000..e331b1b34 --- /dev/null +++ b/climada/trajectories/riskperiod.py @@ -0,0 +1,1011 @@ +""" +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 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. + +""" + +import itertools +import logging +from abc import ABC + +import geopandas as gpd +import numpy as np +import pandas as pd +from scipy.sparse import csr_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 ( + AllLinearStrategy, + InterpolationStrategy, + InterpolationStrategyBase, + linear_interp_arrays, +) +from climada.trajectories.snapshot import Snapshot +from climada.util import log_level + +LOGGER = logging.getLogger(__name__) + + +def lazy_property(method): + # This function is used as a decorator for properties + # that require "heavy" computation and are not always needed. + # When requested, if a property is none, it uses the corresponding + # computation method and caches the result in the corresponding + # private attribute + attr_name = f"_{method.__name__}" + + @property + def _lazy(self): + if getattr(self, attr_name) is None: + # 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) + + return _lazy + + +class CalcRiskMetricsPoints: + + def __init__( + self, + snapshots: list[Snapshot], + impact_computation_strategy: ImpactComputationStrategy, + ) -> None: + self._reset_impact_data() + self.snapshots = snapshots + self.impact_computation_strategy = impact_computation_strategy + self._date_idx = pd.DatetimeIndex( + [snap.date for snap in self.snapshots], name="date" + ) + self.measure = None + self._groups_id = np.unique( + np.concatenate( + [ + snap.exposure.gdf["group_id"] + for snap in self.snapshots + if "group_id" in snap.exposure.gdf.columns + ] + ) + ) + + def _reset_impact_data(self): + """Util method that resets computed data, for instance when changing the time resolution.""" + self._impacts = None + self._eai_gdf = None + self._per_date_eai = None + self._per_date_aai = None + + @lazy_property + def impacts(self) -> list[Impact]: + return [ + self.impact_computation_strategy.compute_impacts( + snap.exposure, snap.hazard, snap.impfset + ) + for snap in self.snapshots + ] + + @lazy_property + def per_date_eai(self) -> np.ndarray: + """Expected annual impacts per date with changing exposure, changing hazard and changing vulnerability""" + return np.array([imp.eai_exp for imp in self.impacts]) + + @lazy_property + def per_date_aai(self) -> np.ndarray: + """Average annual impacts per date with changing exposure, changing hazard and changing vulnerability""" + return np.array([imp.aai_agg for imp in self.impacts]) + + @lazy_property + def eai_gdf(self) -> pd.DataFrame: + """Convenience function returning a GeoDataFrame (with both datetime and coordinates) from `per_date_eai`. + + Notes + ----- + + The GeoDataFrame from the starting snapshot is used as a basis (notably for `value` and `group_id`). + """ + return self.calc_eai_gdf() + + def calc_eai_gdf(self) -> pd.DataFrame: + """Merges the per date EAIs of the risk period with the GeoDataframe of the exposure of the starting snapshot.""" + 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 = pd.concat( + [ + snap.exposure.gdf.reset_index(names=["coord_id"]).assign( + date=pd.to_datetime(snap.date) + )[["date", "coord_id", "group_id"]] + for snap in self.snapshots + ] + ) + eai_gdf = eai_gdf.merge(df, on=["date", "coord_id"]) + eai_gdf = eai_gdf.rename(columns={"group_id": "group"}) + eai_gdf["group"] = pd.Categorical(eai_gdf["group"], categories=self._groups_id) + eai_gdf["metric"] = "eai" + eai_gdf["measure"] = self.measure.name if self.measure else "no_measure" + eai_gdf["unit"] = self.snapshots[0].exposure.value_unit + return eai_gdf + + def calc_aai_metric(self) -> pd.DataFrame: + """Compute a DataFrame of the AAI at each dates of the risk period (including changes in exposure, hazard and vulnerability).""" + aai_df = pd.DataFrame( + index=self._date_idx, columns=["risk"], data=self.per_date_aai + ) + aai_df["group"] = pd.Categorical( + [pd.NA] * len(aai_df), categories=self._groups_id + ) + aai_df["metric"] = "aai" + aai_df["measure"] = self.measure.name if self.measure else "no_measure" + aai_df["unit"] = self.snapshots[0].exposure.value_unit + aai_df.reset_index(inplace=True) + return aai_df + + def calc_aai_per_group_metric(self) -> pd.DataFrame: + """Compute a DataFrame of the AAI distinguised per group id in the exposures, at each dates of the risk period (including changes in exposure, hazard and vulnerability). + + Notes + ----- + + If group id changes between starting and ending snapshots of the risk period, the AAIs are linearly interpolated (with a warning for transparency). + """ + + 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, observed=True + )["risk"].sum() + aai_per_group_df["metric"] = "aai" + aai_per_group_df["measure"] = ( + self.measure.name if self.measure else "no_measure" + ) + aai_per_group_df["unit"] = self.snapshots[0].exposure.value_unit + return aai_per_group_df + + def calc_return_periods_metric(self, return_periods: list[int]) -> pd.DataFrame: + """Compute a DataFrame of the estimated impacts for a list of return periods, at each dates of the risk period (including changes in exposure, hazard and vulnerability). + + Parameters + ---------- + + return_periods : list of int + The return periods to estimate impacts for. + """ + + # currently mathematicaly wrong, but approximatively correct, to be reworked when concatenating the impact matrices for the interpolation + per_date_rp = np.array( + [ + imp.calc_freq_curve(return_per=return_periods).impact + for imp in self.impacts + ] + ) + rp_df = pd.DataFrame( + index=self._date_idx, columns=return_periods, data=per_date_rp + ).melt(value_name="risk", var_name="rp", ignore_index=False) + rp_df.reset_index(inplace=True) + rp_df["group"] = pd.Categorical( + [pd.NA] * len(rp_df), categories=self._groups_id + ) + rp_df["metric"] = "rp_" + rp_df["rp"].astype(str) + rp_df["measure"] = self.measure.name if self.measure else "no_measure" + rp_df["unit"] = self.snapshots[0].exposure.value_unit + return rp_df + + def apply_measure(self, measure: Measure) -> "CalcRiskMetricsPoints": + """Creates a new `CalcRiskPeriod` object with a measure. + + The given measure is applied to both snapshot of the risk period. + + Parameters + ---------- + measure : Measure + The measure to apply. + + Returns + ------- + + CalcRiskPeriod + The risk period with given measure applied. + + """ + snapshots = [snap.apply(measure) for snap in self.snapshots] + risk_period = CalcRiskMetricsPoints( + snapshots, + self.impact_computation_strategy, + ) + + risk_period.measure = measure + return risk_period + + +class CalcRiskMetricsPeriod: + """Handles the computation of impacts for a risk period. + + This object handles the interpolations and computations of risk metrics in + between two given snapshots, along a DateTimeIndex build from either a + `time_resolution` (which must be a valid "freq" string to build a DateTimeIndex) + and defaults to "Y" (start of the year) or `time_points` integer argument, in which case + the DateTimeIndex will have that many periods. + + Note that most attribute like members are properties with their own docstring. + + Attributes + ---------- + + date_idx: pd.PeriodIndex + The date index for the different interpolated points between the two snapshots + interpolation_strategy: InterpolationStrategy, optional + The approach used to interpolate impact matrices in between the two snapshots, linear by default. + impact_computation_strategy: ImpactComputationStrategy, optional + The method used to calculate the impact from the (Haz,Exp,Vul) of the two snapshots. + Defaults to ImpactCalc + measure: Measure, optional + The measure to apply to both snapshots. Defaults to None. + + Notes + ----- + + This class is intended for internal computation. Users should favor `RiskTrajectory` objects. + """ + + def __init__( + self, + snapshot0: Snapshot, + snapshot1: Snapshot, + time_resolution: str, + interpolation_strategy: InterpolationStrategyBase, + impact_computation_strategy: ImpactComputationStrategy, + ): + """Initialize a new `CalcRiskPeriod` + + This initializes and instantiate a new CalcRiskPeriod object. No heavy + computation is done at that point. + + Parameters + ---------- + snapshot0 : Snapshot + The `Snapshot` at the start of the risk period. + snapshot1 : Snapshot + The `Snapshot` at the end of the risk period. + time_resolution : str, optional + One of pandas date offset strings or corresponding objects. See :func:`pandas.period_range`. + time_points : int, optional + Number of periods to generate for the PeriodIndex. + interpolation_strategy: InterpolationStrategy, optional + The approach used to interpolate impact matrices in between the two snapshots, linear by default. + impact_computation_strategy: ImpactComputationStrategy, optional + The method used to calculate the impact from the (Haz,Exp,Vul) of the two snapshots. + Defaults to ImpactCalc + + Notes + ----- + + If both `time_points` and `freq` are given, a consistency check between the two is made. + + """ + + LOGGER.debug("Instantiating new CalcRiskPeriod.") + self._snapshot0 = snapshot0 + self._snapshot1 = snapshot1 + self.date_idx = self._set_date_idx( + date1=snapshot0.date, + date2=snapshot1.date, + freq=time_resolution, + name="date", + ) + self.interpolation_strategy = interpolation_strategy + self.impact_computation_strategy = impact_computation_strategy + self.measure = None # Only possible to set with apply_measure to make sure snapshots are consistent + + self._group_id_E0 = ( + self.snapshot_start.exposure.gdf["group_id"].values + if "group_id" in self.snapshot_start.exposure.gdf.columns + else np.array([]) + ) + self._group_id_E1 = ( + self.snapshot_end.exposure.gdf["group_id"].values + if "group_id" in self.snapshot_end.exposure.gdf.columns + else np.array([]) + ) + self._groups_id = np.unique( + np.concatenate([self._group_id_E0, self._group_id_E1]) + ) + + def _reset_impact_data(self): + """Util method that resets computed data, for instance when changing the time resolution.""" + for fut in list(itertools.product([0, 1], repeat=3)): + setattr(self, f"_E{fut[0]}H{fut[1]}V{fut[2]}", None) + + 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 + def _set_date_idx( + date1: str | pd.Timestamp, + date2: str | pd.Timestamp, + freq: str | None = None, + name: str | None = None, + ) -> pd.PeriodIndex: + """Generate a date range index based on the provided parameters. + + Parameters + ---------- + date1 : str or pd.Timestamp + 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.PeriodIndex + A PeriodIndex representing the date range. + + Raises + ------ + ValueError + If the number of periods and frequency given to period_range are inconsistent. + """ + ret = pd.period_range( + date1, + date2, + freq=freq, # type: ignore + name=name, + ) + return ret + + @property + def snapshot_start(self) -> Snapshot: + """The `Snapshot` at the start of the risk period.""" + return self._snapshot0 + + @property + def snapshot_end(self) -> Snapshot: + """The `Snapshot` at the end of the risk period.""" + return self._snapshot1 + + @property + def date_idx(self) -> pd.PeriodIndex: + """The pandas PeriodIndex representing the time dimension of the risk period.""" + return self._date_idx + + @date_idx.setter + def date_idx(self, value, /): + if not isinstance(value, pd.PeriodIndex): + raise ValueError("Not a PeriodIndex") + + self._date_idx = value # Avoids weird hourly data + self._time_points = len(self.date_idx) + self._time_resolution = self.date_idx.freq + self._reset_impact_data() + + @property + def time_points(self) -> int: + """The numbers of different time points (dates) in the risk period.""" + return self._time_points + + @property + def time_resolution(self) -> str: + """The time resolution of the risk periods, expressed as a pandas interval frequency string.""" + return self._time_resolution + + @time_resolution.setter + def time_resolution(self, value, /): + freq = pd.tseries.frequencies.to_offset(value) + self.date_idx = pd.period_range( + self.snapshot_start.date, self.snapshot_end.date, freq=freq, name="date" + ) + + @property + def interpolation_strategy(self) -> InterpolationStrategyBase: + """The approach used to interpolate impact matrices in between the two snapshots.""" + return self._interpolation_strategy + + @interpolation_strategy.setter + def interpolation_strategy(self, value, /): + if not isinstance(value, InterpolationStrategyBase): + raise ValueError("Not an interpolation strategy") + + self._interpolation_strategy = value + self._reset_impact_data() + + @property + def impact_computation_strategy(self) -> ImpactComputationStrategy: + """The method used to calculate the impact from the (Haz,Exp,Vul) of the two snapshots.""" + return self._impact_computation_strategy + + @impact_computation_strategy.setter + def impact_computation_strategy(self, value, /): + if not isinstance(value, ImpactComputationStrategy): + raise ValueError("Not an impact computation strategy") + + self._impact_computation_strategy = value + self._reset_impact_data() + + ##### Impact objects cube / Risk Cube ##### + + @lazy_property + def E0H0V0(self) -> Impact: + """Impact object corresponding to starting exposure, starting hazard and starting vulnerability.""" + return self.impact_computation_strategy.compute_impacts( + self.snapshot_start.exposure, + self.snapshot_start.hazard, + self.snapshot_start.impfset, + ) + + @lazy_property + def E1H0V0(self) -> Impact: + """Impact object corresponding to future exposure, starting hazard and starting vulnerability.""" + return self.impact_computation_strategy.compute_impacts( + self.snapshot_end.exposure, + self.snapshot_start.hazard, + self.snapshot_start.impfset, + ) + + @lazy_property + def E0H1V0(self) -> Impact: + """Impact object corresponding to starting exposure, future hazard and starting vulnerability.""" + return self.impact_computation_strategy.compute_impacts( + self.snapshot_start.exposure, + self.snapshot_end.hazard, + self.snapshot_start.impfset, + ) + + @lazy_property + def E1H1V0(self) -> Impact: + """Impact object corresponding to future exposure, future hazard and starting vulnerability.""" + return self.impact_computation_strategy.compute_impacts( + self.snapshot_end.exposure, + self.snapshot_end.hazard, + self.snapshot_start.impfset, + ) + + @lazy_property + def E0H0V1(self) -> Impact: + """Impact object corresponding to starting exposure, starting hazard and future vulnerability.""" + return self.impact_computation_strategy.compute_impacts( + self.snapshot_start.exposure, + self.snapshot_start.hazard, + self.snapshot_end.impfset, + ) + + @lazy_property + def E1H0V1(self) -> Impact: + """Impact object corresponding to future exposure, starting hazard and future vulnerability.""" + return self.impact_computation_strategy.compute_impacts( + self.snapshot_end.exposure, + self.snapshot_start.hazard, + self.snapshot_end.impfset, + ) + + @lazy_property + def E0H1V1(self) -> Impact: + """Impact object corresponding to starting exposure, future hazard and future vulnerability.""" + return self.impact_computation_strategy.compute_impacts( + self.snapshot_start.exposure, + self.snapshot_end.hazard, + self.snapshot_end.impfset, + ) + + @lazy_property + def E1H1V1(self) -> Impact: + """Impact object corresponding to future exposure, future hazard and future vulnerability.""" + return self.impact_computation_strategy.compute_impacts( + self.snapshot_end.exposure, + self.snapshot_end.hazard, + self.snapshot_end.impfset, + ) + + ############################### + + ### Impact Matrices arrays #### + + @property + def imp_mats_H0V0(self) -> list: + """List of `time_points` impact matrices with changing exposure, starting hazard and starting vulnerability.""" + return self.interpolation_strategy.interp_over_exposure_dim( + self.E0H0V0.imp_mat, self.E1H0V0.imp_mat, self.time_points + ) + + @property + def imp_mats_H1V0(self) -> list: + """List of `time_points` impact matrices with changing exposure, future hazard and starting vulnerability.""" + return self.interpolation_strategy.interp_over_exposure_dim( + self.E0H1V0.imp_mat, self.E1H1V0.imp_mat, self.time_points + ) + + @property + def imp_mats_H0V1(self) -> list: + """List of `time_points` impact matrices with changing exposure, starting hazard and future vulnerability.""" + return self.interpolation_strategy.interp_over_exposure_dim( + self.E0H0V1.imp_mat, self.E1H0V1.imp_mat, self.time_points + ) + + @property + def imp_mats_H1V1(self) -> list: + """List of `time_points` impact matrices with changing exposure, future hazard and future vulnerability.""" + return self.interpolation_strategy.interp_over_exposure_dim( + self.E0H1V1.imp_mat, self.E1H1V1.imp_mat, self.time_points + ) + + ############################### + + ########## Base EAI ########### + + @property + def per_date_eai_H0V0(self) -> np.ndarray: + """Expected annual impacts for changing exposure, starting hazard and starting vulnerability.""" + return calc_per_date_eais( + self.imp_mats_H0V0, self.snapshot_start.hazard.frequency + ) + + @property + def per_date_eai_H1V0(self) -> np.ndarray: + """Expected annual impacts for changing exposure, future hazard and starting vulnerability.""" + return calc_per_date_eais( + self.imp_mats_H1V0, self.snapshot_end.hazard.frequency + ) + + @property + def per_date_eai_H0V1(self) -> np.ndarray: + """Expected annual impacts for changing exposure, starting hazard and future vulnerability.""" + return calc_per_date_eais( + self.imp_mats_H0V1, self.snapshot_start.hazard.frequency + ) + + @property + def per_date_eai_H1V1(self) -> np.ndarray: + """Expected annual impacts for changing exposure, future hazard and future vulnerability.""" + return calc_per_date_eais( + self.imp_mats_H1V1, self.snapshot_end.hazard.frequency + ) + + ################################## + + ######### Specific AAIs ########## + + @property + def per_date_aai_H0V0(self) -> np.ndarray: + """Average annual impacts for changing exposure, starting hazard and starting vulnerability.""" + return calc_per_date_aais(self.per_date_eai_H0V0) + + @property + def per_date_aai_H1V0(self) -> np.ndarray: + """Average annual impacts for changing exposure, future hazard and starting vulnerability.""" + return calc_per_date_aais(self.per_date_eai_H1V0) + + @property + def per_date_aai_H0V1(self) -> np.ndarray: + """Average annual impacts for changing exposure, starting hazard and future vulnerability.""" + return calc_per_date_aais(self.per_date_eai_H0V1) + + @property + def per_date_aai_H1V1(self) -> np.ndarray: + """Average annual impacts for changing exposure, future hazard and future vulnerability.""" + return calc_per_date_aais(self.per_date_eai_H1V1) + + ################################# + + ######### Specific RPs ######### + + def per_date_return_periods_H0V0(self, return_periods: list[int]) -> np.ndarray: + """Estimated impacts per dates for given return periods, with changing exposure, starting hazard and starting vulnerability.""" + return calc_per_date_rps( + self.imp_mats_H0V0, self.snapshot_start.hazard.frequency, return_periods + ) + + def per_date_return_periods_H1V0(self, return_periods: list[int]) -> np.ndarray: + """Estimated impacts per dates for given return periods, with changing exposure, future hazard and starting vulnerability.""" + return calc_per_date_rps( + self.imp_mats_H1V0, self.snapshot_end.hazard.frequency, return_periods + ) + + def per_date_return_periods_H0V1(self, return_periods: list[int]) -> np.ndarray: + """Estimated impacts per dates for given return periods, with changing exposure, starting hazard and future vulnerability.""" + return calc_per_date_rps( + self.imp_mats_H0V1, self.snapshot_start.hazard.frequency, return_periods + ) + + def per_date_return_periods_H1V1(self, return_periods: list[int]) -> np.ndarray: + """Estimated impacts per dates for given return periods, with changing exposure, future hazard and future vulnerability.""" + return calc_per_date_rps( + self.imp_mats_H1V1, self.snapshot_end.hazard.frequency, return_periods + ) + + ################################## + + ### Fully interpolated metrics ### + + @lazy_property + def per_date_eai(self) -> np.ndarray: + """Expected annual impacts per date with changing exposure, changing hazard and changing vulnerability""" + return self.calc_eai() + + @lazy_property + def per_date_aai(self) -> np.ndarray: + """Average annual impacts per date with changing exposure, changing hazard and changing vulnerability""" + return calc_per_date_aais(self.per_date_eai) + + @lazy_property + def eai_gdf(self) -> gpd.GeoDataFrame: + """Convenience function returning a GeoDataFrame (with both datetime and coordinates) from `per_date_eai`. + + Notes + ----- + + The GeoDataFrame from the starting snapshot is used as a basis (notably for `value` and `group_id`). + """ + return self.calc_eai_gdf() + + #################################### + + ### Metrics from impact matrices ### + + # These methods might go in a utils file instead, to be reused + # for a no interpolation case (and maybe the timeseries?) + + #################################### + + ##### Interpolation of metrics ##### + + def calc_eai(self) -> np.ndarray: + """Compute the EAIs at each date of the risk period (including changes in exposure, hazard and vulnerability).""" + per_date_eai_H0V0, per_date_eai_H1V0, per_date_eai_H0V1, per_date_eai_H1V1 = ( + self.per_date_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_over_hazard_dim( + per_date_eai_H0V0, per_date_eai_H1V0 + ) + per_date_eai_V1 = self.interpolation_strategy.interp_over_hazard_dim( + per_date_eai_H0V1, per_date_eai_H1V1 + ) + per_date_eai = self.interpolation_strategy.interp_over_vulnerability_dim( + per_date_eai_V0, per_date_eai_V1 + ) + return per_date_eai + + def calc_eai_gdf(self) -> gpd.GeoDataFrame: + """Merges the per date EAIs of the risk period with the GeoDataframe of the exposure of the starting snapshot.""" + 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" + ) + if "group_id" in self.snapshot_start.exposure.gdf: + eai_gdf = self.snapshot_start.exposure.gdf[["group_id"]] + 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"}) + else: + eai_gdf = df + eai_gdf["group"] = pd.NA + + eai_gdf["group"] = pd.Categorical(eai_gdf["group"], categories=self._groups_id) + eai_gdf["metric"] = "eai" + eai_gdf["measure"] = self.measure.name if self.measure else "no_measure" + eai_gdf["unit"] = self.snapshot_start.exposure.value_unit + return eai_gdf + + def calc_aai_metric(self) -> pd.DataFrame: + """Compute a DataFrame of the AAI at each dates of the risk period (including changes in exposure, hazard and vulnerability).""" + aai_df = pd.DataFrame( + index=self.date_idx, columns=["risk"], data=self.per_date_aai + ) + aai_df["group"] = pd.Categorical( + [pd.NA] * len(aai_df), categories=self._groups_id + ) + aai_df["metric"] = "aai" + aai_df["measure"] = self.measure.name if self.measure else "no_measure" + aai_df["unit"] = self.snapshot_start.exposure.value_unit + aai_df.reset_index(inplace=True) + return aai_df + + def calc_aai_per_group_metric(self) -> pd.DataFrame: + """Compute a DataFrame of the AAI distinguised per group id in the exposures, at each dates of the risk period (including changes in exposure, hazard and vulnerability). + + Notes + ----- + + If group id changes between starting and ending snapshots of the risk period, the AAIs are linearly interpolated (with a warning for transparency). + """ + if len(self._group_id_E0) < 1 or len(self._group_id_E1) < 1: + LOGGER.warning( + "No group id defined in at least one of the Exposures object. Per group aai will be empty." + ) + return 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, observed=True + )["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["group"] = pd.Categorical( + np.tile(self._group_id_E1, len(self.date_idx)), + categories=self._groups_id, + ) + aai_fut_groups = eai_fut_groups.groupby(["date", "group"], as_index=False)[ + "risk" + ].sum() + aai_per_group_df["risk"] = linear_interp_arrays( + aai_per_group_df["risk"].values, aai_fut_groups["risk"].values + ) + + aai_per_group_df["metric"] = "aai" + aai_per_group_df["measure"] = ( + self.measure.name if self.measure else "no_measure" + ) + aai_per_group_df["unit"] = self.snapshot_start.exposure.value_unit + return aai_per_group_df + + def calc_return_periods_metric(self, return_periods: list[int]) -> pd.DataFrame: + """Compute a DataFrame of the estimated impacts for a list of return periods, at each dates of the risk period (including changes in exposure, hazard and vulnerability). + + Parameters + ---------- + + return_periods : list of int + The return periods to estimate impacts for. + """ + + # currently mathematicaly wrong, but approximatively correct, to be reworked when concatenating the impact matrices for the interpolation + per_date_rp_H0V0, per_date_rp_H1V0, per_date_rp_H0V1, per_date_rp_H1V1 = ( + self.per_date_return_periods_H0V0(return_periods), + self.per_date_return_periods_H1V0(return_periods), + self.per_date_return_periods_H0V1(return_periods), + self.per_date_return_periods_H1V1(return_periods), + ) + per_date_rp_V0 = self.interpolation_strategy.interp_over_hazard_dim( + per_date_rp_H0V0, per_date_rp_H1V0 + ) + per_date_rp_V1 = self.interpolation_strategy.interp_over_hazard_dim( + per_date_rp_H0V1, per_date_rp_H1V1 + ) + per_date_rp = self.interpolation_strategy.interp_over_vulnerability_dim( + per_date_rp_V0, per_date_rp_V1 + ) + rp_df = pd.DataFrame( + index=self.date_idx, columns=return_periods, data=per_date_rp + ).melt(value_name="risk", var_name="rp", ignore_index=False) + rp_df.reset_index(inplace=True) + rp_df["group"] = pd.Categorical( + [pd.NA] * len(rp_df), categories=self._groups_id + ) + rp_df["metric"] = "rp_" + rp_df["rp"].astype(str) + rp_df["measure"] = self.measure.name if self.measure else "no_measure" + rp_df["unit"] = self.snapshot_start.exposure.value_unit + return rp_df + + def calc_risk_contributions_metric(self) -> pd.DataFrame: + """Compute a DataFrame of the individual contributions of risk (impact), at each dates of the risk period (including changes in exposure, hazard and vulnerability).""" + per_date_aai_V0 = self.interpolation_strategy.interp_over_hazard_dim( + self.per_date_aai_H0V0, self.per_date_aai_H1V0 + ) + per_date_aai_H0 = self.interpolation_strategy.interp_over_vulnerability_dim( + self.per_date_aai_H0V0, self.per_date_aai_H0V1 + ) + df = pd.DataFrame( + { + "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", + "exposure contribution", + "hazard contribution", + "vulnerability contribution", + "interaction contribution", + ], + var_name="metric", + value_name="risk", + ignore_index=False, + ) + df.reset_index(inplace=True) + df["group"] = pd.Categorical([pd.NA] * len(df), categories=self._groups_id) + df["measure"] = self.measure.name if self.measure else "no_measure" + df["unit"] = self.snapshot_start.exposure.value_unit + return df + + def apply_measure(self, measure: Measure) -> "CalcRiskMetricsPeriod": + """Creates a new `CalcRiskPeriod` object with a measure. + + The given measure is applied to both snapshot of the risk period. + + Parameters + ---------- + measure : Measure + The measure to apply. + + Returns + ------- + + CalcRiskPeriod + The risk period with given measure applied. + + """ + snap0 = self.snapshot_start.apply_measure(measure) + snap1 = self.snapshot_end.apply_measure(measure) + + risk_period = CalcRiskMetricsPeriod( + snap0, + snap1, + self.time_resolution, + self.interpolation_strategy, + self.impact_computation_strategy, + ) + + risk_period.measure = measure + return risk_period + + +def calc_per_date_eais(imp_mats: list[csr_matrix], frequency: np.ndarray) -> np.ndarray: + """ + Calculate expected average impact (EAI) values from a list of impact matrices corresponding + to impacts at different dates (with possible changes along exposure, hazard and vulnerability). + + Parameters + ---------- + imp_mats : list of np.ndarray + List of impact matrices. + frequency : np.ndarray + Hazard frequency values. + + Returns + ------- + np.ndarray + 2D array of EAI (1D) for each dates. + """ + 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 + + +def calc_per_date_aais(per_date_eai_exp: np.ndarray) -> np.ndarray: + """ + Calculate per_date aggregate annual impact (AAI) values resulting from a list arrays corresponding + to EAI at different dates (with possible changes along exposure, hazard and vulnerability). + + Parameters + ---------- + per_date_eai_exp: np.ndarray + EAIs arrays. + + Returns + ------- + np.ndarray + 1D array of AAI (0D) for each dates. + """ + 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 + + +def calc_per_date_rps( + imp_mats: list[csr_matrix], + frequency: np.ndarray, + return_periods: list[int], +) -> np.ndarray: + """ + Calculate per date return period impact values from a list of impact matrices corresponding + to impacts at different dates (with possible changes along exposure, hazard and vulnerability). + + Parameters + ---------- + imp_mats: list of scipy.crs_matrix + List of impact matrices. + frequency: np.ndarray + Frequency values. + return_periods : list of int + Return periods to calculate impact values for. + + Returns + ------- + np.ndarray + 2D array of impacts per return periods (1D) for each dates. + """ + rp = np.array( + [calc_freq_curve(imp_mat, frequency, return_periods) for imp_mat in imp_mats] + ) + return rp + + +def calc_freq_curve(imp_mat_intrpl, frequency, return_per=None) -> np.ndarray: + """ + Calculate the estimated impacts for given return periods. + + Parameters + ---------- + + imp_mat_intrpl: scipy.csr_matrix + An impact matrix. + frequency: np.ndarray + The frequency of the hazard. + return_per: np.ndarray + The return periods to compute impacts for. + + Returns + ------- + np.ndarray + The estimated impacts for the different return periods. + """ + + at_event = np.sum(imp_mat_intrpl, axis=1).A1 + + # Sort descendingly the impacts per events + sort_idxs = np.argsort(at_event)[::-1] + # Calculate exceedence frequency + exceed_freq = np.cumsum(frequency[sort_idxs]) + # Set return period and impact exceeding frequency + ifc_return_per = 1 / exceed_freq[::-1] + ifc_impact = at_event[sort_idxs][::-1] + + if return_per is not None: + interp_imp = np.interp(return_per, ifc_return_per, ifc_impact) + ifc_return_per = return_per + ifc_impact = interp_imp + + return ifc_impact diff --git a/climada/trajectories/snapshot.py b/climada/trajectories/snapshot.py new file mode 100644 index 000000000..b506a4551 --- /dev/null +++ b/climada/trajectories/snapshot.py @@ -0,0 +1,147 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +This modules implements the Snapshot class. + +Snapshot are used to store the a snapshot of Exposure, Hazard, Vulnerability +at a specific date. + +""" + +import copy +import datetime +import logging + +from climada.entity.exposures import Exposures +from climada.entity.impact_funcs import ImpactFuncSet +from climada.entity.measures.base import Measure +from climada.hazard import Hazard + +LOGGER = logging.getLogger(__name__) + + +class Snapshot: + """ + A snapshot of exposure, hazard, and impact function at a specific date. + + Parameters + ---------- + exposure : Exposures + hazard : Hazard + impfset : ImpactFuncSet + date : int | datetime.date | str + The date of the Snapshot, it can be an integer representing a year, + a datetime object or a string representation of a datetime object + with format YYYY-MM-DD. + + Attributes + ---------- + date : datetime + Date of the snapshot. + measure: Measure | None + The possible measure applied to the snapshot. + + Notes + ----- + + The object creates deep copies of the exposure hazard and impact function set. + + 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__( + self, + *, + exposure: Exposures, + hazard: Hazard, + impfset: ImpactFuncSet, + date: int | datetime.date | str, + ) -> None: + 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._exposure + + @property + def hazard(self) -> Hazard: + """Hazard data for the snapshot.""" + return self._hazard + + @property + def impfset(self) -> ImpactFuncSet: + """Impact function set data for the snapshot.""" + return self._impfset + + @property + def measure(self) -> Measure | None: + """Impact function set data for the snapshot.""" + return self._measure + + @property + def date(self) -> datetime.date: + """Impact function set data for the snapshot.""" + return self._date + + @staticmethod + def _convert_to_date(date_arg) -> datetime.date: + """Convert date argument of type int or str to a datetime.date object.""" + if isinstance(date_arg, int): + # Assume the integer represents a year + return datetime.date(date_arg, 1, 1) + 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) -> "Snapshot": + """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. + + Returns + ------- + The Snapshot with the measure applied. + + """ + + LOGGER.debug(f"Applying measure {measure.name} on snapshot {id(self)}") + snap = Snapshot( + *measure.apply(self.exposure, self.impfset, self.hazard), self.date + ) + snap._measure = measure + return snap diff --git a/climada/trajectories/static_trajectory.py b/climada/trajectories/static_trajectory.py new file mode 100644 index 000000000..01dcc4a99 --- /dev/null +++ b/climada/trajectories/static_trajectory.py @@ -0,0 +1,242 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +This file implements \"static\" risk trajectory objects, for an easier evaluation +of risk at multiple points in time (snapshots). + +""" + +import logging + +import pandas as pd + +from climada.entity.disc_rates.base import DiscRates +from climada.trajectories.impact_calc_strat import ImpactCalcComputation +from climada.trajectories.riskperiod import ( + CalcRiskMetricsPoints, + ImpactComputationStrategy, +) +from climada.trajectories.snapshot import Snapshot +from climada.trajectories.trajectory import DEFAULT_RP, RiskTrajectory +from climada.util import log_level + +LOGGER = logging.getLogger(__name__) + + +class StaticRiskTrajectory(RiskTrajectory): + """Calculates risk trajectories over a series of snapshots. + + This class computes risk metrics over a series of snapshots, + optionally applying risk discounting. + + """ + + POSSIBLE_METRICS = [ + "eai", + "aai", + "return_periods", + "aai_per_group", + ] + + def __init__( + self, + snapshots_list: list[Snapshot], + *, + return_periods: list[int] = DEFAULT_RP, + all_groups_name: str = "All", + risk_disc_rates: DiscRates | None = None, + impact_computation_strategy: ImpactComputationStrategy | None = None, + ): + super().__init__( + snapshots_list, + return_periods=return_periods, + all_groups_name=all_groups_name, + risk_disc_rates=risk_disc_rates, + ) + self._risk_metrics_calculators = CalcRiskMetricsPoints( + self._snapshots, + impact_computation_strategy=impact_computation_strategy + or ImpactCalcComputation(), + ) + + @property + def impact_computation_strategy(self) -> ImpactComputationStrategy: + """The method used to calculate the impact from the (Haz,Exp,Vul) of the two snapshots.""" + return self._risk_metrics_calculators.impact_computation_strategy + + @impact_computation_strategy.setter + def impact_computation_strategy(self, value, /): + if not isinstance(value, ImpactComputationStrategy): + raise ValueError("Not an interpolation strategy") + + self._reset_metrics() + self._risk_metrics_calculators.impact_computation_strategy = value + + def _generic_metrics( + self, + metric_name: str | None = None, + metric_meth: str | None = None, + **kwargs, + ) -> pd.DataFrame: + """Generic method to compute metrics based on the provided metric name and method.""" + if metric_name is None or metric_meth is None: + raise ValueError("Both metric_name and metric_meth must be provided.") + + if metric_name not in self.POSSIBLE_METRICS: + raise NotImplementedError( + f"{metric_name} not implemented ({self.POSSIBLE_METRICS})." + ) + + # Construct the attribute name for storing the metric results + attr_name = f"_{metric_name}_metrics" + + with log_level(level="WARNING", name_prefix="climada"): + tmp = getattr(self._risk_metrics_calculators, metric_meth)(**kwargs) + + tmp = tmp.set_index(["date", "group", "measure", "metric"]) + if "coord_id" in tmp.columns: + tmp = tmp.set_index(["coord_id"], append=True) + + # When more than 2 snapshots, there are duplicated rows, we need to remove them. + tmp = tmp[~tmp.index.duplicated(keep="first")] + tmp = tmp.reset_index() + tmp["group"] = tmp["group"].cat.add_categories([self._all_groups_name]) + 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"] + ] + setattr(self, attr_name, tmp) + + if self._risk_disc_rates: + return self.npv_transform(getattr(self, attr_name), self._risk_disc_rates) + + return getattr(self, attr_name) + + def eai_metrics(self, **kwargs) -> pd.DataFrame: + """Return the estimated annual impacts at each exposure point for each date. + + This method computes and return a `DataFrame` with eai metric + (for each exposure point) for each date. + + 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. + + """ + df = self._compute_metrics( + metric_name="eai", metric_meth="calc_eai_gdf", **kwargs + ) + return df + + def aai_metrics(self, **kwargs) -> pd.DataFrame: + """Return the average annual impacts for each date. + + This method computes and return a `DataFrame` with aai metric for each date. + + Parameters + ---------- + npv : bool + Whether to apply the (risk) discount rate if it is defined. + Defaults to `True`. + """ + + return self._compute_metrics( + metric_name="aai", metric_meth="calc_aai_metric", **kwargs + ) + + def return_periods_metrics(self, **kwargs) -> pd.DataFrame: + return self._compute_metrics( + metric_name="return_periods", + metric_meth="calc_return_periods_metric", + return_periods=self.return_periods, + **kwargs, + ) + + def aai_per_group_metrics(self, **kwargs) -> pd.DataFrame: + """Return the average annual impacts for each exposure group ID. + + This method computes and return a `DataFrame` with aai metric for each + of the exposure group defined by a group id, for each date. + + Parameters + ---------- + npv : bool + Whether to apply the (risk) discount rate if it is defined. + Defaults to `True`. + """ + + return self._compute_metrics( + metric_name="aai_per_group", + metric_meth="calc_aai_per_group_metric", + **kwargs, + ) + + def per_date_risk_metrics( + self, + metrics: list[str] | None = None, + ) -> pd.DataFrame | pd.Series: + """Returns a DataFrame of risk metrics for each dates + + This methods collects (and if needed computes) the `metrics` + (Defaulting to "aai", "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 + ) + if "aai" in metrics: + metrics_df.append(self.aai_metrics()) + if "return_periods" in metrics: + metrics_df.append(self.return_periods_metrics()) + if "aai_per_group" in metrics: + metrics_df.append(self.aai_per_group_metrics()) + + return pd.concat(metrics_df) 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..050464969 --- /dev/null +++ b/climada/trajectories/test/test_impact_calc_strat.py @@ -0,0 +1,113 @@ +""" +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, "compute_impacts_pre_transfer") + @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, 0, 0), 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, (0, 0, 0) + ) + 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) + + with patch( + "climada.trajectories.impact_calc_strat.ImpactCalc" + ) as mock_impact_calc: + mock_impact_calc.return_value.impact.side_effect = [mock_imp_E0H0] + + result = self.impact_calc_computation.compute_impacts_pre_transfer( + self.mock_snapshot0, self.mock_snapshot1, (0, 0, 0) + ) + + self.assertEqual(result, mock_imp_E0H0) + + def test_apply_risk_transfer(self): + mock_imp_E0H0 = MagicMock(spec=Impact) + mock_imp_E0H0.imp_mat = MagicMock(spec=csr_matrix) + 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_imp_E0H0, 0.1, 0.9, False + ) + + self.assertIs(mock_imp_E0H0.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..1d0520e1e --- /dev/null +++ b/climada/trajectories/test/test_interpolation.py @@ -0,0 +1,365 @@ +""" +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 math +import unittest +from unittest.mock import MagicMock + +import numpy as np +from scipy.sparse import csr_matrix + +from climada.trajectories.interpolation import ( + AllLinearStrategy, + ExponentialExposureStrategy, + InterpolationStrategy, + exponential_interp_arrays, + exponential_interp_imp_mat, + linear_interp_arrays, + linear_interp_imp_mat, +) + + +class TestInterpolationFuncs(unittest.TestCase): + def setUp(self): + # Create mock impact matrices for testing + self.imp_mat0 = csr_matrix(np.array([[1, 2], [3, 4]])) + self.imp_mat1 = csr_matrix(np.array([[5, 6], [7, 8]])) + self.imp_mat2 = csr_matrix(np.array([[5, 6, 7], [8, 9, 10]])) # Different shape + self.time_points = 5 + self.interpolation_range_5 = 5 + self.interpolation_range_1 = 1 + self.interpolation_range_2 = 2 + self.rtol = 1e-5 + self.atol = 1e-8 + + def test_linear_interp_arrays(self): + arr_start = np.array([10, 100]) + arr_end = np.array([20, 200]) + expected = np.array([10.0, 200.0]) + result = linear_interp_arrays(arr_start, arr_end) + np.testing.assert_allclose(result, expected, rtol=self.rtol, atol=self.atol) + + def test_linear_interp_arrays2D(self): + arr_start = np.array([[10, 100], [10, 100]]) + arr_end = np.array([[20, 200], [20, 200]]) + expected = np.array([[10.0, 100.0], [20, 200]]) + result = linear_interp_arrays(arr_start, arr_end) + np.testing.assert_allclose(result, expected, rtol=self.rtol, atol=self.atol) + + def test_linear_interp_arrays_shape(self): + arr_start = np.array([10, 100, 5]) + arr_end = np.array([20, 200]) + with self.assertRaises(ValueError): + linear_interp_arrays(arr_start, arr_end) + + def test_linear_interp_arrays_start_equals_end(self): + arr_start = np.array([5, 5]) + arr_end = np.array([5, 5]) + expected = np.array([5.0, 5.0]) + result = linear_interp_arrays(arr_start, arr_end) + np.testing.assert_allclose(result, expected, rtol=self.rtol, atol=self.atol) + + def test_exponential_interp_arrays_1d(self): + arr_start = np.array([1, 10, 100]) + arr_end = np.array([2, 20, 200]) + rate = 10 + expected = np.array([1.0, 14.142136, 200.0]) + result = exponential_interp_arrays(arr_start, arr_end, rate) + np.testing.assert_allclose(result, expected, rtol=self.rtol, atol=self.atol) + + def test_exponential_interp_arrays_shape(self): + arr_start = np.array([10, 100, 5]) + arr_end = np.array([20, 200]) + rate = 10 + with self.assertRaises(ValueError): + exponential_interp_arrays(arr_start, arr_end, rate) + + def test_exponential_interp_arrays_2d(self): + arr_start = np.array( + [ + [1, 10, 100], # date 1 metric a,b,c + [1, 10, 100], # date 2 metric a,b,c + [1, 10, 100], + ] + ) # date 3 metric a,b,c + arr_end = np.array([[2, 20, 200], [2, 20, 200], [2, 20, 200]]) + rate = 10 + expected = np.array( + [[1.0, 10.0, 100.0], [1.4142136, 14.142136, 141.42136], [2, 20, 200]] + ) + result = exponential_interp_arrays(arr_start, arr_end, rate) + np.testing.assert_allclose(result, expected, rtol=self.rtol, atol=self.atol) + + def test_exponential_interp_arrays_start_equals_end(self): + arr_start = np.array([5, 5]) + arr_end = np.array([5, 5]) + rate = 2 + expected = np.array([5.0, 5.0]) + result = exponential_interp_arrays(arr_start, arr_end, rate) + np.testing.assert_allclose(result, expected, rtol=self.rtol, atol=self.atol) + + def test_exponential_interp_arrays_invalid_rate(self): + arr_start = np.array([10, 100]) + arr_end = np.array([20, 200]) + # Test rate <= 0 + with self.assertRaises(ValueError) as cm: + exponential_interp_arrays(arr_start, arr_end, 0) + self.assertIn( + "Rate for exponential interpolation must be positive", str(cm.exception) + ) + + with self.assertRaises(ValueError) as cm: + exponential_interp_arrays(arr_start, arr_end, -2) + self.assertIn( + "Rate for exponential interpolation must be positive", str(cm.exception) + ) + + def test_linear_impmat_interpolate(self): + result = linear_interp_imp_mat(self.imp_mat0, self.imp_mat1, self.time_points) + self.assertEqual(len(result), self.time_points) + for mat in result: + self.assertIsInstance(mat, csr_matrix) + + dense = np.array([r.todense() for r in result]) + expected = np.array( + [ + [[1.0, 2.0], [3.0, 4.0]], + [[2.0, 3.0], [4.0, 5.0]], + [[3.0, 4.0], [5.0, 6.0]], + [[4.0, 5.0], [6.0, 7.0]], + [[5.0, 6.0], [7.0, 8.0]], + ] + ) + np.testing.assert_array_equal(dense, expected) + + def test_linear_impmat_interpolate_inconsistent_shape(self): + with self.assertRaises(ValueError): + linear_interp_imp_mat(self.imp_mat0, self.imp_mat2, self.time_points) + + def test_exp_impmat_interpolate(self): + result = exponential_interp_imp_mat( + self.imp_mat0, self.imp_mat1, self.time_points, 1.1 + ) + self.assertEqual(len(result), self.time_points) + for mat in result: + self.assertIsInstance(mat, csr_matrix) + + dense = np.array([r.todense() for r in result]) + expected = np.array( + [ + [[1.0, 2.0], [3.0, 4.0]], + [[1.49534878, 2.63214803], [3.70779275, 4.75682846]], + [[2.23606798, 3.46410162], [4.58257569, 5.65685425]], + [[3.34370152, 4.55901411], [5.66374698, 6.72717132]], + [[5.0, 6.0], [7.0, 8.0]], + ] + ) + np.testing.assert_array_almost_equal(dense, expected) + + def test_exp_impmat_interpolate_inconsistent_shape(self): + with self.assertRaises(ValueError): + exponential_interp_imp_mat( + self.imp_mat0, self.imp_mat2, self.time_points, 1.1 + ) + + +class TestInterpolationStrategies(unittest.TestCase): + + def setUp(self): + self.interpolation_range = 3 + self.dummy_metric_0 = np.array([10, 20]) + self.dummy_metric_1 = np.array([100, 200]) + self.dummy_matrix_0 = np.array([[1, 2], [3, 4]]) + self.dummy_matrix_1 = np.array([[10, 20], [30, 40]]) + + def test_InterpolationStrategy_init(self): + mock_exposure = lambda a, b, r: a + b + mock_hazard = lambda a, b, r: a * b + mock_vulnerability = lambda a, b, r: a / b + + strategy = InterpolationStrategy(mock_exposure, mock_hazard, mock_vulnerability) + self.assertEqual(strategy.exposure_interp, mock_exposure) + self.assertEqual(strategy.hazard_interp, mock_hazard) + self.assertEqual(strategy.vulnerability_interp, mock_vulnerability) + + def test_InterpolationStrategy_interp_exposure_dim(self): + mock_exposure = MagicMock(return_value=["mock_result"]) + strategy = InterpolationStrategy( + mock_exposure, linear_interp_arrays, linear_interp_arrays + ) + + result = strategy.interp_over_exposure_dim( + self.dummy_matrix_0, self.dummy_matrix_1, self.interpolation_range + ) + mock_exposure.assert_called_once_with( + self.dummy_matrix_0, self.dummy_matrix_1, self.interpolation_range + ) + self.assertEqual(result, ["mock_result"]) + + def test_InterpolationStrategy_interp_exposure_dim_inconsistent_shapes(self): + mock_exposure = MagicMock(side_effect=ValueError("inconsistent shapes")) + strategy = InterpolationStrategy( + mock_exposure, linear_interp_arrays, linear_interp_arrays + ) + + with self.assertRaisesRegex( + ValueError, "Tried to interpolate impact matrices of different shape" + ): + strategy.interp_over_exposure_dim( + self.dummy_matrix_0, np.array([[1]]), self.interpolation_range + ) + mock_exposure.assert_called_once() # Ensure it was called + + def test_InterpolationStrategy_interp_hazard_dim(self): + mock_hazard = MagicMock(return_value=np.array([1, 2, 3])) + strategy = InterpolationStrategy( + linear_interp_imp_mat, mock_hazard, linear_interp_arrays + ) + + result = strategy.interp_over_hazard_dim( + self.dummy_metric_0, self.dummy_metric_1 + ) + mock_hazard.assert_called_once_with(self.dummy_metric_0, self.dummy_metric_1) + np.testing.assert_array_equal(result, np.array([1, 2, 3])) + + def test_InterpolationStrategy_interp_vulnerability_dim(self): + mock_vulnerability = MagicMock(return_value=np.array([4, 5, 6])) + strategy = InterpolationStrategy( + linear_interp_imp_mat, linear_interp_arrays, mock_vulnerability + ) + + result = strategy.interp_over_vulnerability_dim( + self.dummy_metric_0, self.dummy_metric_1 + ) + mock_vulnerability.assert_called_once_with( + self.dummy_metric_0, self.dummy_metric_1 + ) + np.testing.assert_array_equal(result, np.array([4, 5, 6])) + + +class TestConcreteInterpolationStrategies(unittest.TestCase): + + def setUp(self): + self.interpolation_range = 3 + self.dummy_metric_0 = np.array([10, 20, 30]) + self.dummy_metric_1 = np.array([100, 200, 300]) + self.dummy_matrix_0 = csr_matrix([[1, 2], [3, 4]]) + self.dummy_matrix_1 = csr_matrix([[10, 20], [30, 40]]) + self.dummy_matrix_0_1_lin = csr_matrix([[5.5, 11], [16.5, 22]]) + self.dummy_matrix_0_1_exp = csr_matrix( + [[3.162278, 6.324555], [9.486833, 12.649111]] + ) + self.rtol = 1e-5 + self.atol = 1e-8 + + def test_AllLinearStrategy_init_and_methods(self): + strategy = AllLinearStrategy() + self.assertEqual(strategy.exposure_interp, linear_interp_imp_mat) + self.assertEqual(strategy.hazard_interp, linear_interp_arrays) + self.assertEqual(strategy.vulnerability_interp, linear_interp_arrays) + + # Test hazard interpolation + expected_hazard_interp = linear_interp_arrays( + self.dummy_metric_0, self.dummy_metric_1 + ) + result_hazard = strategy.interp_over_hazard_dim( + self.dummy_metric_0, self.dummy_metric_1 + ) + np.testing.assert_allclose( + result_hazard, expected_hazard_interp, rtol=self.rtol, atol=self.atol + ) + + # Test vulnerability interpolation + expected_vulnerability_interp = linear_interp_arrays( + self.dummy_metric_0, self.dummy_metric_1 + ) + result_vulnerability = strategy.interp_over_vulnerability_dim( + self.dummy_metric_0, self.dummy_metric_1 + ) + np.testing.assert_allclose( + result_vulnerability, + expected_vulnerability_interp, + rtol=self.rtol, + atol=self.atol, + ) + + # Test exposure interpolation (using mock for linear_interp_imp_mat) + result_exposure = strategy.interp_over_exposure_dim( + self.dummy_matrix_0, self.dummy_matrix_1, self.interpolation_range + ) + # Verify the structure/first/last elements of the mock output + self.assertEqual(len(result_exposure), self.interpolation_range) + np.testing.assert_allclose(result_exposure[0].data, self.dummy_matrix_0.data) + np.testing.assert_allclose( + result_exposure[1].data, self.dummy_matrix_0_1_lin.data + ) + np.testing.assert_allclose(result_exposure[2].data, self.dummy_matrix_1.data) + + def test_ExponentialExposureInterpolation_init_and_methods(self): + strategy = ExponentialExposureStrategy() + self.assertEqual(strategy.exposure_interp, exponential_interp_imp_mat) + self.assertEqual(strategy.hazard_interp, linear_interp_arrays) + self.assertEqual(strategy.vulnerability_interp, linear_interp_arrays) + + # Test hazard interpolation (should be linear) + expected_hazard_interp = linear_interp_arrays( + self.dummy_metric_0, self.dummy_metric_1 + ) + result_hazard = strategy.interp_over_hazard_dim( + self.dummy_metric_0, self.dummy_metric_1 + ) + np.testing.assert_allclose( + result_hazard, expected_hazard_interp, rtol=self.rtol, atol=self.atol + ) + + # Test vulnerability interpolation (should be linear) + expected_vulnerability_interp = linear_interp_arrays( + self.dummy_metric_0, self.dummy_metric_1 + ) + result_vulnerability = strategy.interp_over_vulnerability_dim( + self.dummy_metric_0, self.dummy_metric_1 + ) + np.testing.assert_allclose( + result_vulnerability, + expected_vulnerability_interp, + rtol=self.rtol, + atol=self.atol, + ) + + # Test exposure interpolation (using mock for exponential_interp_imp_mat) + result_exposure = strategy.interp_over_exposure_dim( + self.dummy_matrix_0, self.dummy_matrix_1, self.interpolation_range, rate=1.1 + ) + # Verify the structure/first/last elements of the mock output + self.assertEqual(len(result_exposure), self.interpolation_range) + np.testing.assert_allclose(result_exposure[0].data, self.dummy_matrix_0.data) + np.testing.assert_allclose( + result_exposure[1].data, + self.dummy_matrix_0_1_exp.data, + rtol=self.rtol, + atol=self.atol, + ) + np.testing.assert_allclose(result_exposure[-1].data, self.dummy_matrix_1.data) + + +if __name__ == "__main__": + 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..4f77e1681 --- /dev/null +++ b/climada/trajectories/test/test_risk_trajectory.py @@ -0,0 +1,1076 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +unit tests for risk_trajectory + +""" + +import datetime +import unittest +from itertools import product +from unittest.mock import Mock, PropertyMock, call, patch + +import numpy as np # For potential NaN/NA comparisons +import pandas as pd + +from climada.entity.disc_rates.base import DiscRates + +# Assuming your RiskTrajectory class is in a file named 'climada.trajectories.risk_trajectory' +# and the auxiliary classes are in 'climada.trajectories.riskperiod' etc. +# Adjust imports based on your actual file structure. +from climada.trajectories.risk_trajectory import ( + calc_npv_cash_flows, # standalone function +) +from climada.trajectories.risk_trajectory import ( + DEFAULT_RP, + POSSIBLE_METRICS, + InterpolatedRiskTrajectory, +) +from climada.trajectories.riskperiod import ( # ImpactComputationStrategy, # If needed to mock its base class directly + AllLinearStrategy, + ImpactCalcComputation, +) +from climada.trajectories.snapshot import Snapshot + + +class TestRiskTrajectory(unittest.TestCase): + def setUp(self): + # Common setup for all tests + self.mock_snapshot1 = Mock(spec=Snapshot) + self.mock_snapshot1.date = datetime.date(2023, 1, 1) + + self.mock_snapshot2 = Mock(spec=Snapshot) + self.mock_snapshot2.date = datetime.date(2024, 1, 1) + + self.mock_snapshot3 = Mock(spec=Snapshot) + self.mock_snapshot3.date = datetime.date(2025, 1, 1) + + self.snapshots_list = [ + self.mock_snapshot1, + self.mock_snapshot2, + self.mock_snapshot3, + ] + + # Mock interpolation strategy and impact computation strategy + self.mock_interpolation_strategy = Mock(spec=AllLinearStrategy) + self.mock_impact_computation_strategy = Mock(spec=ImpactCalcComputation) + + # Mock DiscRates if needed for NPV tests + self.mock_disc_rates = Mock(spec=DiscRates) + self.mock_disc_rates.years = [2023, 2024, 2025] + self.mock_disc_rates.rates = [0.01, 0.02, 0.03] # Example rates + + # --- Test Initialization and Properties --- + # These tests focus on the __init__ method and property getters/setters. + + ## Test `__init__` method + def test_init_basic(self): + # Test basic initialization with defaults + rt = InterpolatedRiskTrajectory( + self.snapshots_list, + interpolation_strategy=self.mock_interpolation_strategy, + impact_computation_strategy=self.mock_impact_computation_strategy, + ) + self.assertEqual(rt.start_date, self.mock_snapshot1.date) + self.assertEqual(rt.end_date, self.mock_snapshot3.date) + self.assertIsNone(rt._risk_disc_rates) + self.assertEqual(rt._interpolation_strategy, self.mock_interpolation_strategy) + self.assertEqual( + rt._impact_computation_strategy, self.mock_impact_computation_strategy + ) + self.assertFalse(rt._risk_period_up_to_date) + # Check that metrics are reset (initially None) + for metric in POSSIBLE_METRICS: + self.assertIsNone(getattr(rt, "_" + metric + "_metrics")) + self.assertIsNone(rt._all_risk_metrics) + + def test_init_with_custom_params(self): + # Test initialization with custom parameters + mock_disc = Mock(spec=DiscRates) + rt = InterpolatedRiskTrajectory( + self.snapshots_list, + time_resolution="MS", + all_groups_name="CustomAll", + risk_disc_rates=mock_disc, + interpolation_strategy=Mock(), + impact_computation_strategy=Mock(), + ) + self.assertEqual(rt._time_resolution, "MS") + self.assertEqual(rt._all_groups_name, "CustomAll") + self.assertEqual(rt._risk_disc_rates, mock_disc) + + ## Test Properties (`@property` and `@setter`) + def test_default_rp_getter_setter(self): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + self.assertEqual(rt.default_rp, DEFAULT_RP) + rt.default_rp = [10, 20] + self.assertEqual(rt.default_rp, [10, 20]) + # Check that setting resets metrics + rt._return_periods_metrics = "some_data" # Simulate old data + rt._all_risk_metrics = "some_data" + rt.default_rp = [10, 20, 30] + self.assertIsNone(rt._return_periods_metrics) + self.assertIsNone(rt._all_risk_metrics) + + def test_default_rp_setter_validation(self): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + with self.assertRaises(ValueError): + rt.default_rp = "not a list" + with self.assertRaises(ValueError): + rt.default_rp = [10, "not an int"] + + # --- Test Core Risk Period Calculation (`risk_periods` property and `_calc_risk_periods`) --- + # This is critical as many other methods depend on it. + + @patch("climada.trajectories.risk_trajectory.CalcRiskPeriod", autospec=True) + def test_risk_periods_lazy_computation(self, MockCalcRiskPeriod): + # Test that _calc_risk_periods is called only once, lazily + rt = InterpolatedRiskTrajectory( + self.snapshots_list, + interpolation_strategy=self.mock_interpolation_strategy, + impact_computation_strategy=self.mock_impact_computation_strategy, + ) + self.assertFalse(rt._risk_period_up_to_date) + self.assertIsNone(rt._risk_periods_calculators) + + # First access should trigger calculation + risk_periods = rt._risk_periods + MockCalcRiskPeriod.assert_has_calls( + [ + call( + self.mock_snapshot1, + self.mock_snapshot2, + time_resolution="Y", + interpolation_strategy=self.mock_interpolation_strategy, + impact_computation_strategy=self.mock_impact_computation_strategy, + ), + call( + self.mock_snapshot2, + self.mock_snapshot3, + time_resolution="Y", + interpolation_strategy=self.mock_interpolation_strategy, + impact_computation_strategy=self.mock_impact_computation_strategy, + ), + ] + ) + self.assertEqual(MockCalcRiskPeriod.call_count, 2) + self.assertTrue(rt._risk_period_up_to_date) + self.assertIsInstance(risk_periods, list) + self.assertEqual(len(risk_periods), 2) # N-1 periods for N snapshots + + # Second access should not trigger recalculation + rt._risk_periods + self.assertEqual(MockCalcRiskPeriod.call_count, 2) # Still 2 calls + + @patch("climada.trajectories.risk_trajectory.CalcRiskPeriod", autospec=True) + def test_calc_risk_periods_sorting(self, MockCalcRiskPeriod): + # Test that snapshots are sorted by date before pairing + unsorted_snapshots = [ + self.mock_snapshot3, + self.mock_snapshot1, + self.mock_snapshot2, + ] + rt = InterpolatedRiskTrajectory(unsorted_snapshots) + # Access the property to trigger calculation + _ = rt._risk_periods + MockCalcRiskPeriod.assert_has_calls( + [ + call( + self.mock_snapshot1, + self.mock_snapshot2, + **MockCalcRiskPeriod.call_args[1], + ), + call( + self.mock_snapshot2, + self.mock_snapshot3, + **MockCalcRiskPeriod.call_args[1], + ), + ] + ) + self.assertEqual(MockCalcRiskPeriod.call_count, 2) + + # --- Test Generic Metric Computation (`_generic_metrics`) --- + # This is a core internal method and deserves thorough testing. + + @patch.object(InterpolatedRiskTrajectory, "risk_periods", new_callable=PropertyMock) + @patch.object(InterpolatedRiskTrajectory, "npv_transform", new_callable=Mock) + def test_generic_metrics_basic_flow(self, mock_npv_transform, mock_risk_periods): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + rt._all_groups_name = "All" # Ensure default + rt._risk_disc_rates = self.mock_disc_rates # For NPV transform check + + # Mock CalcRiskPeriod instances returned by risk_periods property + mock_calc_period1 = Mock() + mock_calc_period2 = Mock() + mock_risk_periods.return_value = [mock_calc_period1, mock_calc_period2] + + # Mock the metric method on CalcRiskPeriod instances + dates1 = [pd.Timestamp("2023-01-01"), pd.Timestamp("2024-01-01")] + dates2 = [pd.Timestamp("2025-01-01"), pd.Timestamp("2026-01-01")] + groups = ["GroupA", "GroupB", pd.NA] + measures = ["MEAS1", "MEAS2"] + metrics = ["aai"] + df1 = pd.DataFrame( + product(dates1, groups, measures, metrics), + columns=["date", "group", "measure", "metric"], + ) + df1["risk"] = np.arange(12) * 100 + df1["group"] = df1["group"].astype("category") + df2 = pd.DataFrame( + product(dates2, groups, measures, metrics), + columns=["date", "group", "measure", "metric"], + ) + df2["risk"] = np.arange(12) * 100 + 1200 + df2["group"] = df2["group"].astype("category") + mock_calc_period1.calc_aai_metric.return_value = df1 + mock_calc_period2.calc_aai_metric.return_value = df2 + + # Mock npv_transform return value + mock_npv_transform.return_value = "discounted_df" + + result = rt._generic_metrics( + npv=True, metric_name="aai", metric_meth="calc_aai_metric" + ) + + # Assertions + mock_risk_periods.assert_called_once() # Ensure risk_periods was accessed + mock_calc_period1.calc_aai_metric.assert_called_once() + mock_calc_period2.calc_aai_metric.assert_called_once() + + # Check concatenated DataFrame before NPV + # We need to manually recreate the expected intermediate DataFrame before NPV for assertion + df3 = pd.DataFrame( + product(dates1 + dates2, groups, measures, metrics), + columns=["date", "group", "measure", "metric"], + ) + df3["risk"] = np.arange(24) * 100 + df3["group"] = df3["group"].astype("category") + df3["group"] = df3["group"].cat.add_categories(["All"]) + df3["group"] = df3["group"].fillna("All") + expected_pre_npv_df = df3 + expected_pre_npv_df = expected_pre_npv_df[ + ["group", "date", "measure", "metric", "risk"] + ] + # npv_transform should be called with the correctly formatted (concatenated and ordered) DataFrame + # and the risk_disc_rates attribute + mock_npv_transform.assert_called_once() + pd.testing.assert_frame_equal( + mock_npv_transform.call_args[0][0].reset_index(drop=True), + expected_pre_npv_df.reset_index(drop=True), + ) + self.assertEqual(mock_npv_transform.call_args[0][1], self.mock_disc_rates) + + self.assertEqual(result, "discounted_df") # Final result is from NPV transform + + # Check internal storage + stored_df = getattr(rt, "_aai_metrics") + # Assert that the stored DF is the one *before* NPV transformation + pd.testing.assert_frame_equal( + stored_df.reset_index(drop=True), expected_pre_npv_df.reset_index(drop=True) + ) + + @patch.object(InterpolatedRiskTrajectory, "risk_periods", new_callable=PropertyMock) + @patch.object(InterpolatedRiskTrajectory, "npv_transform", new_callable=Mock) + def test_generic_metrics_no_npv(self, mock_npv_transform, mock_risk_periods): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + # Mock CalcRiskPeriod instances + mock_calc_period1 = Mock() + mock_risk_periods.return_value = [mock_calc_period1] + dates1 = [pd.Timestamp("2023-01-01"), pd.Timestamp("2024-01-01")] + groups = ["GroupA", "GroupB", pd.NA] + measures = ["MEAS1", "MEAS2"] + metrics = ["aai"] + df1 = pd.DataFrame( + product(groups, dates1, measures, metrics), + columns=["group", "date", "measure", "metric"], + ) + df1["risk"] = np.arange(12) * 100 + df1["group"] = df1["group"].astype("category") + mock_calc_period1.calc_aai_metric.return_value = df1 + + result = rt._generic_metrics( + npv=False, metric_name="aai", metric_meth="calc_aai_metric" + ) + + # Assertions + mock_npv_transform.assert_not_called() + expected_df = df1.copy() + expected_df["group"] = expected_df["group"].cat.add_categories(["All"]) + expected_df["group"] = expected_df["group"].fillna("All") + pd.testing.assert_frame_equal(result, expected_df) + pd.testing.assert_frame_equal(getattr(rt, "_aai_metrics"), expected_df) + + @patch.object(InterpolatedRiskTrajectory, "risk_periods", new_callable=PropertyMock) + def test_generic_metrics_not_implemented_error(self, mock_risk_periods): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + with self.assertRaises(NotImplementedError): + rt._generic_metrics(metric_name="non_existent", metric_meth="some_method") + + @patch.object(InterpolatedRiskTrajectory, "risk_periods", new_callable=PropertyMock) + def test_generic_metrics_value_error_no_name_or_method(self, mock_risk_periods): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + with self.assertRaises(ValueError): + rt._generic_metrics(metric_name=None, metric_meth="some_method") + with self.assertRaises(ValueError): + rt._generic_metrics(metric_name="aai", metric_meth=None) + + @patch.object(InterpolatedRiskTrajectory, "risk_periods", new_callable=PropertyMock) + @patch.object(InterpolatedRiskTrajectory, "npv_transform", new_callable=Mock) + def test_generic_metrics_empty_concat_returns_None( + self, mock_npv_transform, mock_risk_periods + ): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + # Mock CalcRiskPeriod instances return None, mimicking `calc_aai_per_group_metric` possibly + mock_calc_period1 = Mock() + mock_calc_period2 = Mock() + mock_risk_periods.return_value = [mock_calc_period1, mock_calc_period2] + mock_calc_period1.calc_aai_per_group_metric.return_value = None + mock_calc_period2.calc_aai_per_group_metric.return_value = None + + result = rt._generic_metrics( + npv=False, + metric_name="aai_per_group", + metric_meth="calc_aai_per_group_metric", + ) + self.assertIsNone(result) + self.assertIsNone(getattr(rt, "_aai_per_group_metrics")) # Should also be None + + @patch.object(InterpolatedRiskTrajectory, "risk_periods", new_callable=PropertyMock) + @patch.object(InterpolatedRiskTrajectory, "npv_transform", new_callable=Mock) + def test_generic_metrics_coord_id_handling( + self, mock_npv_transform, mock_risk_periods + ): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + mock_calc_period = Mock() + mock_risk_periods.return_value = [mock_calc_period] + mock_calc_period.calc_eai_gdf.return_value = pd.DataFrame( + { + "date": [pd.Timestamp("2023-01-01"), pd.Timestamp("2023-01-01")], + "group": pd.Categorical([pd.NA, pd.NA]), + "measure": ["MEAS1", "MEAS1"], + "metric": ["eai", "eai"], + "coord_id": [1, 2], + "risk": [10.0, 20.0], + } + ) + + result = rt._generic_metrics( + npv=False, metric_name="eai", metric_meth="calc_eai_gdf" + ) + + expected_df = pd.DataFrame( + { + "group": pd.Categorical(["All", "All"]), + "date": [pd.Timestamp("2023-01-01"), pd.Timestamp("2023-01-01")], + "measure": ["MEAS1", "MEAS1"], + "metric": ["eai", "eai"], + "risk": [10.0, 20.0], + "coord_id": [ + 1, + 2, + ], # This column should remain and be placed at the end before risk if not in front_columns + } + ) + # The internal logic reorders columns, ensure it matches + cols_order = ["group", "date", "measure", "metric", "coord_id", "risk"] + pd.testing.assert_frame_equal(result[cols_order], expected_df[cols_order]) + + # --- Test Specific Metric Methods (e.g., `eai_metrics`, `aai_metrics`) --- + # These are mostly thin wrappers around _compute_metrics/_generic_metrics. + # Focus on ensuring they call _compute_metrics with the correct arguments. + + @patch.object(InterpolatedRiskTrajectory, "_compute_metrics") + def test_eai_metrics(self, mock_compute_metrics): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + rt.eai_metrics(npv=True, some_arg="test") + mock_compute_metrics.assert_called_once_with( + npv=True, metric_name="eai", metric_meth="calc_eai_gdf", some_arg="test" + ) + + @patch.object(InterpolatedRiskTrajectory, "_compute_metrics") + def test_aai_metrics(self, mock_compute_metrics): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + rt.aai_metrics(npv=False, other_arg=123) + mock_compute_metrics.assert_called_once_with( + npv=False, metric_name="aai", metric_meth="calc_aai_metric", other_arg=123 + ) + + @patch.object(InterpolatedRiskTrajectory, "_compute_metrics") + def test_return_periods_metrics(self, mock_compute_metrics): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + test_rps = [10, 20] + rt.return_periods_metrics(test_rps, npv=True, rp_arg="xyz") + mock_compute_metrics.assert_called_once_with( + npv=True, + metric_name="return_periods", + metric_meth="calc_return_periods_metric", + return_periods=test_rps, + rp_arg="xyz", + ) + + @patch.object(InterpolatedRiskTrajectory, "_compute_metrics") + def test_aai_per_group_metrics(self, mock_compute_metrics): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + rt.aai_per_group_metrics(npv=False) + mock_compute_metrics.assert_called_once_with( + npv=False, + metric_name="aai_per_group", + metric_meth="calc_aai_per_group_metric", + ) + + @patch.object(InterpolatedRiskTrajectory, "_compute_metrics") + def test_risk_components_metrics(self, mock_compute_metrics): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + rt.risk_components_metrics(npv=True) + mock_compute_metrics.assert_called_once_with( + npv=True, + metric_name="risk_components", + metric_meth="calc_risk_components_metric", + ) + + # --- Test NPV Transformation (`npv_transform` and `calc_npv_cash_flows`) --- + + ## Test `calc_npv_cash_flows` (standalone function) + def test_calc_npv_cash_flows_no_disc(self): + cash_flows = pd.Series( + [100, 200, 300], + index=pd.to_datetime(["2023-01-01", "2024-01-01", "2025-01-01"]), + ) + start_date = datetime.date(2023, 1, 1) + result = calc_npv_cash_flows(cash_flows, start_date, disc=None) + # If no disc, it should return the original cash_flows Series + pd.testing.assert_series_equal(result, cash_flows) + + def test_calc_npv_cash_flows_with_disc(self): + cash_flows = pd.Series( + [100, 200, 300], + index=pd.to_datetime(["2023-01-01", "2024-01-01", "2025-01-01"]), + ) + start_date = datetime.date(2023, 1, 1) + # Using the mock_disc_rates from setUp + # year 2023: (2023-01-01 - 2023-01-01) days // 365 = 0, factor = (1/(1+0.01))^0 = 1 + # year 2024: (2024-01-01 - 2023-01-01) days // 365 = 1, factor = (1/(1+0.02))^1 = 0.98039215... + # year 2025: (2025-01-01 - 2023-01-01) days // 365 = 2, factor = (1/(1+0.03))^2 = 0.9425959... + expected_cash_flows = pd.Series( + [ + 100 * (1 / (1 + 0.01)) ** 0, + 200 * (1 / (1 + 0.02)) ** 1, + 300 * (1 / (1 + 0.03)) ** 2, + ], + index=pd.to_datetime(["2023-01-01", "2024-01-01", "2025-01-01"]), + name="npv_cash_flow", + ) + + result = calc_npv_cash_flows(cash_flows, start_date, disc=self.mock_disc_rates) + pd.testing.assert_series_equal( + result, expected_cash_flows, check_dtype=False, rtol=1e-6 + ) + + def test_calc_npv_cash_flows_invalid_index(self): + cash_flows = pd.Series([100, 200, 300]) # No datetime index + start_date = datetime.date(2023, 1, 1) + with self.assertRaises( + ValueError, msg="cash_flows must be a pandas Series with a datetime index" + ): + calc_npv_cash_flows(cash_flows, start_date, disc=self.mock_disc_rates) + + ## Test `npv_transform` (class method) + def test_npv_transform_no_group_col(self): + df_input = pd.DataFrame( + { + "date": pd.to_datetime(["2023-01-01", "2024-01-01"] * 2), + "measure": ["m1", "m1", "m2", "m2"], + "metric": ["aai", "aai", "aai", "aai"], + "risk": [100.0, 200.0, 80.0, 180.0], + } + ) + # Mock the internal calc_npv_cash_flows + with patch( + "climada.trajectories.risk_trajectory.calc_npv_cash_flows" + ) as mock_calc_npv: + # For each group, it will be called + mock_calc_npv.side_effect = [ + pd.Series( + [100.0 * (1 / (1 + 0.01)) ** 0, 200.0 * (1 / (1 + 0.02)) ** 1], + index=[pd.Timestamp("2023-01-01"), pd.Timestamp("2024-01-01")], + ), + pd.Series( + [80.0 * (1 / (1 + 0.01)) ** 0, 180.0 * (1 / (1 + 0.02)) ** 1], + index=[pd.Timestamp("2023-01-01"), pd.Timestamp("2024-01-01")], + ), + ] + result_df = InterpolatedRiskTrajectory._npv_transform( + df_input.copy(), self.mock_disc_rates + ) + # Assertions for mock calls + # Grouping by 'measure', 'metric' (default _grouper) + pd.testing.assert_series_equal( + mock_calc_npv.mock_calls[0].args[0], + pd.Series( + [100.0, 200.0], + index=pd.Index( + [ + pd.Timestamp("2023-01-01"), + pd.Timestamp("2024-01-01"), + ], + name="date", + ), + name=("m1", "aai"), + ), + ) + assert mock_calc_npv.mock_calls[0].args[1] == pd.Timestamp("2023-01-01") + assert mock_calc_npv.mock_calls[0].args[2] == self.mock_disc_rates + pd.testing.assert_series_equal( + mock_calc_npv.mock_calls[1].args[0], + pd.Series( + [80.0, 180.0], + index=pd.Index( + [ + pd.Timestamp("2023-01-01"), + pd.Timestamp("2024-01-01"), + ], + name="date", + ), + name=("m2", "aai"), + ), + ) + assert mock_calc_npv.mock_calls[1].args[1] == pd.Timestamp("2023-01-01") + assert mock_calc_npv.mock_calls[1].args[2] == self.mock_disc_rates + + expected_df = pd.DataFrame( + { + "date": pd.to_datetime(["2023-01-01", "2024-01-01"] * 2), + "measure": ["m1", "m1", "m2", "m2"], + "metric": ["aai", "aai", "aai", "aai"], + "risk": [ + 100.0 * (1 / (1 + 0.01)) ** 0, + 200.0 * (1 / (1 + 0.02)) ** 1, + 80.0 * (1 / (1 + 0.01)) ** 0, + 180.0 * (1 / (1 + 0.02)) ** 1, + ], + } + ) + pd.testing.assert_frame_equal( + result_df.sort_values("date").reset_index(drop=True), + expected_df.sort_values("date").reset_index(drop=True), + rtol=1e-6, + ) + + def test_npv_transform_with_group_col(self): + df_input = pd.DataFrame( + { + "date": pd.to_datetime(["2023-01-01", "2024-01-01", "2023-01-01"]), + "group": ["G1", "G1", "G2"], + "measure": ["m1", "m1", "m1"], + "metric": ["aai", "aai", "aai"], + "risk": [100.0, 200.0, 150.0], + } + ) + with patch( + "climada.trajectories.risk_trajectory.calc_npv_cash_flows" + ) as mock_calc_npv: + mock_calc_npv.side_effect = [ + # First group G1, m1, aai + pd.Series( + [100.0 * (1 / (1 + 0.01)) ** 0, 200.0 * (1 / (1 + 0.02)) ** 1], + index=[pd.Timestamp("2023-01-01"), pd.Timestamp("2024-01-01")], + ), + # Second group G2, m1, aai + pd.Series( + [150.0 * (1 / (1 + 0.01)) ** 0], index=[pd.Timestamp("2023-01-01")] + ), + ] + result_df = InterpolatedRiskTrajectory._npv_transform( + df_input.copy(), self.mock_disc_rates + ) + + expected_df = pd.DataFrame( + { + "date": pd.to_datetime(["2023-01-01", "2024-01-01", "2023-01-01"]), + "group": ["G1", "G1", "G2"], + "measure": ["m1", "m1", "m1"], + "metric": ["aai", "aai", "aai"], + "risk": [ + 100.0 * (1 / (1 + 0.01)) ** 0, + 200.0 * (1 / (1 + 0.02)) ** 1, + 150.0 * (1 / (1 + 0.01)) ** 0, + ], + } + ) + pd.testing.assert_frame_equal( + result_df.sort_values(["group", "date"]).reset_index(drop=True), + expected_df.sort_values(["group", "date"]).reset_index(drop=True), + rtol=1e-6, + ) + + # --- Test Per Period Risk Aggregation (`_per_period_risk`) --- + def test_per_period_risk_basic(self): + df_input = pd.DataFrame( + { + "date": pd.to_datetime( + ["2023-01-01", "2024-01-01", "2025-01-01", "2023-01-01"] + ), + "group": ["All", "All", "All", "GroupB"], + "measure": ["m1", "m1", "m1", "m1"], + "metric": ["aai", "aai", "aai", "aai"], + "risk": [100.0, 200.0, 300.0, 50.0], + } + ) + result_df = InterpolatedRiskTrajectory._date_to_period_agg(df_input) + + expected_df = pd.DataFrame( + { + "period": ["2023-01-01 to 2025-01-01", "2023-01-01 to 2023-01-01"], + "group": ["All", "GroupB"], + "measure": ["m1", "m1"], + "metric": ["aai", "aai"], + "risk": [600.0, 50.0], # 100+200+300 for 'All', 50 for 'GroupB' + } + ) + # Sorting for comparison consistency + pd.testing.assert_frame_equal( + result_df.sort_values(["group", "period"]).reset_index(drop=True), + expected_df.sort_values(["group", "period"]).reset_index(drop=True), + ) + + def test_per_period_risk_multiple_risk_cols(self): + df_input = pd.DataFrame( + { + "date": pd.to_datetime(["2023-01-01", "2024-01-01"]), + "group": ["All", "All"], + "measure": ["m1", "m1"], + "metric": ["risk_components", "risk_components"], + "base risk": [10.0, 20.0], + "exposure contribution": [5.0, 8.0], + } + ) + result_df = InterpolatedRiskTrajectory._date_to_period_agg( + df_input, col_agg_dict=["base risk", "exposure contribution"] + ) + + expected_df = pd.DataFrame( + { + "period": ["2023-01-01 to 2024-01-01"], + "group": ["All"], + "measure": ["m1"], + "metric": ["risk_components"], + "base risk": [30.0], + "exposure contribution": [13.0], + } + ) + pd.testing.assert_frame_equal(result_df, expected_df) + + def test_per_period_risk_non_yearly_intervals(self): + df_input = pd.DataFrame( + { + "date": pd.to_datetime(["2023-01-01", "2023-02-01", "2023-03-01"]), + "group": ["All", "All", "All"], + "measure": ["m1", "m1", "m1"], + "metric": ["aai", "aai", "aai"], + "risk": [10.0, 20.0, 30.0], + } + ) + # Test with 'month' time_unit + result_df_month = InterpolatedRiskTrajectory._date_to_period_agg( + df_input, time_unit="month" + ) + expected_df_month = pd.DataFrame( + { + "period": ["2023-01-01 to 2023-03-01"], + "group": ["All"], + "measure": ["m1"], + "metric": ["aai"], + "risk": [60.0], + } + ) + pd.testing.assert_frame_equal(result_df_month, expected_df_month) + + # Introduce a gap for 'month' time_unit + df_gap = pd.DataFrame( + { + "date": pd.to_datetime( + ["2023-01-01", "2023-02-01", "2023-04-01"] + ), # Gap in March + "group": ["All", "All", "All"], + "measure": ["m1", "m1", "m1"], + "metric": ["aai", "aai", "aai"], + "risk": [10.0, 20.0, 40.0], + } + ) + result_df_gap = InterpolatedRiskTrajectory._date_to_period_agg( + df_gap, time_unit="month" + ) + expected_df_gap = pd.DataFrame( + { + "period": ["2023-01-01 to 2023-02-01", "2023-04-01 to 2023-04-01"], + "group": ["All", "All"], + "measure": ["m1", "m1"], + "metric": ["aai", "aai"], + "risk": [30.0, 40.0], + } + ) + pd.testing.assert_frame_equal( + result_df_gap.sort_values("period").reset_index(drop=True), + expected_df_gap.sort_values("period").reset_index(drop=True), + ) + + # --- Test Combined Metrics (`per_date_risk_metrics`, `per_period_risk_metrics`) --- + + @patch.object(InterpolatedRiskTrajectory, "aai_metrics") + @patch.object(InterpolatedRiskTrajectory, "return_periods_metrics") + @patch.object(InterpolatedRiskTrajectory, "aai_per_group_metrics") + def test_per_date_risk_metrics_defaults( + self, mock_aai_per_group, mock_return_periods, mock_aai + ): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + # Set up mock return values for each method + mock_aai.return_value = pd.DataFrame({"metric": ["aai"], "risk": [100]}) + mock_return_periods.return_value = pd.DataFrame( + {"metric": ["rp"], "risk": [50]} + ) + mock_aai_per_group.return_value = pd.DataFrame( + {"metric": ["aai_grp"], "risk": [10]} + ) + + result = rt.per_date_risk_metrics(npv=False) + + # Assert calls with default arguments + mock_aai.assert_called_once_with(False) + mock_return_periods.assert_called_once_with(rt.default_rp, False) + mock_aai_per_group.assert_called_once_with(False) + + # Assert concatenation + expected_df = pd.concat( + [ + mock_aai.return_value, + mock_return_periods.return_value, + mock_aai_per_group.return_value, + ] + ) + pd.testing.assert_frame_equal( + result.reset_index(drop=True), expected_df.reset_index(drop=True) + ) + + @patch.object(InterpolatedRiskTrajectory, "aai_metrics") + @patch.object(InterpolatedRiskTrajectory, "return_periods_metrics") + @patch.object(InterpolatedRiskTrajectory, "aai_per_group_metrics") + def test_per_date_risk_metrics_custom_metrics_and_rps( + self, mock_aai_per_group, mock_return_periods, mock_aai + ): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + mock_aai.return_value = pd.DataFrame({"metric": ["aai"], "risk": [100]}) + mock_return_periods.return_value = pd.DataFrame( + {"metric": ["rp"], "risk": [50]} + ) + + custom_metrics = ["aai", "return_periods"] + custom_rps = [1, 2] + result = rt.per_date_risk_metrics( + metrics=custom_metrics, return_periods=custom_rps, npv=True + ) + + mock_aai.assert_called_once_with(True) + mock_return_periods.assert_called_once_with(custom_rps, True) + mock_aai_per_group.assert_not_called() # Not in custom_metrics + + expected_df = pd.concat( + [mock_aai.return_value, mock_return_periods.return_value] + ) + pd.testing.assert_frame_equal( + result.reset_index(drop=True), expected_df.reset_index(drop=True) + ) + + @patch.object(InterpolatedRiskTrajectory, "per_date_risk_metrics") + @patch.object(InterpolatedRiskTrajectory, "_per_period_risk") + def test_per_period_risk_metrics( + self, mock_per_period_risk, mock_per_date_risk_metrics + ): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + mock_date_df = pd.DataFrame({"metric": ["aai"], "risk": [100]}) + mock_per_date_risk_metrics.return_value = mock_date_df + mock_per_period_risk.return_value = pd.DataFrame( + {"period": ["P1"], "risk": [200]} + ) + + test_metrics = ["aai"] + result = rt.per_period_risk_metrics(metrics=test_metrics, time_unit="month") + + mock_per_date_risk_metrics.assert_called_once_with( + metrics=test_metrics, time_unit="month" + ) + mock_per_period_risk.assert_called_once_with(mock_date_df, time_unit="month") + pd.testing.assert_frame_equal(result, mock_per_period_risk.return_value) + + # --- Test Plotting Related Methods --- + # These methods primarily generate data for plotting or call plotting functions. + # The actual plotting logic (matplotlib.pyplot calls) should be mocked. + + @patch.object(InterpolatedRiskTrajectory, "risk_components_metrics") + def test_calc_waterfall_plot_data(self, mock_risk_components_metrics): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + rt.start_date = datetime.date(2023, 1, 1) + rt.end_date = datetime.date(2025, 1, 1) + + # Mock the return of risk_components_metrics + mock_risk_components_metrics.return_value = pd.DataFrame( + { + "date": pd.to_datetime( + ["2023-01-01"] * 5 + + ["2024-01-01"] * 5 + + ["2025-01-01"] * 5 + + ["2026-01-01"] * 5 + ), + "metric": [ + "base risk", + "exposure contribution", + "hazard contribution", + "vulnerability contribution", + "interaction contribution", + ] + * 4, + "risk": np.arange(20) + * 1.0, # Dummy data for different components and dates + } + ) # .pivot_table(index="date", columns="metric", values="risk") + # Flattened for simplicity, in reality it's more structured + + result = rt._calc_waterfall_plot_data( + start_date=datetime.date(2024, 1, 1), + end_date=datetime.date(2025, 1, 1), + npv=False, + ) + + mock_risk_components_metrics.assert_called_once_with(False) + + # Expected output should be filtered by date and unstacked + expected_df = pd.DataFrame( + { + "date": pd.to_datetime(["2024-01-01"] * 5 + ["2025-01-01"] * 5), + "metric": [ + "base risk", + "exposure contribution", + "hazard contribution", + "vulnerability contribution", + "interaction contribution", + ] + * 2, + "risk": np.array([5.0, 6, 7, 8, 9, 10, 11, 12, 13, 14]), + } + ).pivot_table(index="date", columns="metric", values="risk") + pd.testing.assert_frame_equal( + result.sort_index(axis=1), expected_df.sort_index(axis=1) + ) # Sort columns for stable comparison + + @patch("matplotlib.pyplot.subplots") + @patch("matplotlib.dates.AutoDateLocator") + @patch("matplotlib.dates.ConciseDateFormatter") + @patch.object(InterpolatedRiskTrajectory, "_calc_waterfall_plot_data") + def test_plot_per_date_waterfall( + self, mock_calc_data, mock_formatter, mock_locator, mock_subplots + ): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + rt.start_date = datetime.date(2023, 1, 1) + rt.end_date = datetime.date(2023, 1, 2) + + # Mock matplotlib objects + mock_ax = Mock() + mock_fig = Mock() + mock_subplots.return_value = (mock_fig, mock_ax) + mock_ax.get_ylim.return_value = (0, 100) # For ylim scaling + + # Mock data returned by _calc_waterfall_plot_data + mock_df_data = pd.DataFrame( + { + "base risk": [10, 12], + "exposure contribution": [2, 3], + "hazard contribution": [5, 6], + "vulnerability contribution": [1, 2], + "interaction contribution": [0.5, 0.7], + }, + index=pd.to_datetime(["2023-01-01", "2023-01-02"]), + ) + mock_calc_data.return_value = mock_df_data + + # Call the method + fig, ax = rt.plot_per_date_waterfall( + start_date=datetime.date(2023, 1, 1), + end_date=datetime.date(2023, 1, 2), + npv=True, + ) + + # Assertions + mock_calc_data.assert_called_once_with( + start_date=datetime.date(2023, 1, 1), + end_date=datetime.date(2023, 1, 2), + npv=True, + ) + mock_ax.stackplot.assert_called_once() + self.assertEqual( + mock_ax.stackplot.call_args[0][0].tolist(), mock_df_data.index.tolist() + ) # Check x-axis data + self.assertEqual( + mock_ax.stackplot.call_args[0][1][0].tolist(), + mock_df_data["base risk"].tolist(), + ) # Check first stacked data + mock_ax.set_title.assert_called_once_with( + "Risk between 2023-01-01 and 2023-01-02 (Average impact)" + ) + mock_ax.set_ylabel.assert_called_once_with("USD") + mock_ax.set_ylim.assert_called_once() # Check ylim was set + mock_ax.xaxis.set_major_locator.assert_called_once() + mock_ax.xaxis.set_major_formatter.assert_called_once() + self.assertEqual(fig, mock_fig) + self.assertEqual(ax, mock_ax) + + @patch("matplotlib.pyplot.subplots") + @patch.object(InterpolatedRiskTrajectory, "_calc_waterfall_plot_data") + def test_plot_waterfall(self, mock_calc_data, mock_subplots): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + rt.start_date = datetime.date(2023, 1, 1) + rt.end_date = datetime.date(2024, 1, 1) + + mock_ax = Mock() + mock_fig = Mock() + mock_subplots.return_value = (mock_fig, mock_ax) + mock_ax.get_ylim.return_value = (0, 100) + + # Mock _calc_waterfall_plot_data to return a DataFrame for two dates, + # where the second date (end_date) is relevant for plot_waterfall + mock_data = pd.DataFrame( + { + "date": pd.to_datetime(["2023-01-01"] * 5 + ["2024-01-01"] * 5), + "metric": [ + "base risk", + "exposure contribution", + "hazard contribution", + "vulnerability contribution", + "interaction contribution", + ] + * 2, + "risk": [ + 10, + 2, + 5, + 1, + 0.5, + 15, + 3, + 7, + 2, + 1, + ], # values for 2023-01-01 and 2024-01-01 + } + ).pivot_table(index="date", columns="metric", values="risk") + mock_calc_data.return_value = mock_data + + # Call the method + ax = rt.plot_waterfall( + start_date=datetime.date(2023, 1, 1), + end_date=datetime.date(2024, 1, 1), + npv=True, + ) + + # Assertions + mock_calc_data.assert_called_once_with( + start_date=datetime.date(2023, 1, 1), + end_date=datetime.date(2024, 1, 1), + npv=True, + ) + mock_ax.bar.assert_called_once() + # Verify the bar arguments are correct for the end_date data + end_date_data = mock_data.loc[pd.Timestamp("2024-01-01")] + expected_values = [ + end_date_data["base risk"], + end_date_data["exposure contribution"], + end_date_data["hazard contribution"], + end_date_data["vulnerability contribution"], + end_date_data["interaction contribution"], + end_date_data.sum(), + ] + # Compare values passed to bar + np.testing.assert_allclose(mock_ax.bar.call_args[0][1], expected_values) + + mock_ax.set_title.assert_called_once_with( + "Risk at 2023-01-01 and 2024-01-01 (Average impact)" + ) + mock_ax.set_ylabel.assert_called_once_with("USD") + mock_ax.set_ylim.assert_called_once() + mock_ax.tick_params.assert_called_once_with(axis="x", labelrotation=90) + self.assertEqual(ax, mock_ax) + + # --- Test Private Helper Methods (`_reset_metrics`, `_get_risk_periods`) --- + + def test_reset_metrics(self): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + # Set some metrics to non-None values + rt._eai_metrics = "dummy_eai" + rt._aai_metrics = "dummy_aai" + rt._all_risk_metrics = "dummy_all" + + rt._reset_metrics() + + for metric in POSSIBLE_METRICS: + self.assertIsNone(getattr(rt, "_" + metric + "_metrics")) + self.assertIsNone(rt._all_risk_metrics) + + def test_get_risk_periods(self): + # Create dummy CalcRiskPeriod mocks with specific dates + mock_rp1 = Mock() + mock_rp1.snapshot_start.date = datetime.date(2020, 1, 1) + mock_rp1.snapshot_end.date = datetime.date(2021, 1, 1) + + mock_rp2 = Mock() + mock_rp2.snapshot_start.date = datetime.date(2021, 1, 1) + mock_rp2.snapshot_end.date = datetime.date(2022, 1, 1) + + mock_rp3 = Mock() + mock_rp3.snapshot_start.date = datetime.date(2022, 1, 1) + mock_rp3.snapshot_end.date = datetime.date(2023, 1, 1) + + all_risk_periods = [mock_rp1, mock_rp2, mock_rp3] + + # Test case 1: Full range, all periods included + result = InterpolatedRiskTrajectory._get_risk_periods( + all_risk_periods, datetime.date(2020, 1, 1), datetime.date(2023, 1, 1) + ) + self.assertEqual(len(result), 3) + self.assertListEqual(result, all_risk_periods) + + # Test case 2: Subset range + result = InterpolatedRiskTrajectory._get_risk_periods( + all_risk_periods, datetime.date(2021, 6, 1), datetime.date(2022, 6, 1) + ) + result = InterpolatedRiskTrajectory._get_risk_periods( + all_risk_periods, datetime.date(2021, 6, 1), datetime.date(2022, 6, 1) + ) + self.assertEqual(len(result), 3) + self.assertListEqual(result, all_risk_periods) + + # Test case 3: Dates completely outside the periods + result = InterpolatedRiskTrajectory._get_risk_periods( + all_risk_periods, datetime.date(2025, 1, 1), datetime.date(2026, 1, 1) + ) + # rp1: (2025 >= 2020) OR (2026 <= 2021) -> T OR F -> T + # rp2: (2025 >= 2021) OR (2026 <= 2022) -> T OR F -> T + # rp3: (2025 >= 2022) OR (2026 <= 2023) -> T OR F -> T + self.assertEqual(len(result), 3) + self.assertListEqual(result, all_risk_periods) + + +if __name__ == "__main__": + unittest.main(argv=["first-arg-is-ignored"], exit=False) diff --git a/climada/trajectories/test/test_riskperiod.py b/climada/trajectories/test/test_riskperiod.py new file mode 100644 index 000000000..83dfdb67d --- /dev/null +++ b/climada/trajectories/test/test_riskperiod.py @@ -0,0 +1,858 @@ +""" +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, call, patch + +import geopandas as gpd +import numpy as np +import pandas as pd +from numpy.testing import assert_array_almost_equal +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 ( + AllLinearStrategy, + CalcRiskMetricPeriod, + ImpactCalcComputation, + ImpactComputationStrategy, + InterpolationStrategyBase, + 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_snapshot_start = Snapshot( + self.exposure_present, + self.hazard_present, + self.impfset_present, + self.present_date, + ) + self.mock_snapshot_end = Snapshot( + self.exposure_future, + self.hazard_future, + self.impfset_future, + self.future_date, + ) + + # Create an instance of CalcRiskPeriod + self.calc_risk_period = CalcRiskMetricPeriod( + self.mock_snapshot_start, + self.mock_snapshot_end, + time_resolution="Y", + interpolation_strategy=AllLinearStrategy(), + 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.snapshot_start, self.mock_snapshot_start) + self.assertEqual(self.calc_risk_period.snapshot_end, self.mock_snapshot_end) + self.assertEqual(self.calc_risk_period.time_resolution, "Y") + self.assertEqual( + self.calc_risk_period.time_points, self.future_date - self.present_date + 1 + ) + self.assertIsInstance( + self.calc_risk_period.interpolation_strategy, AllLinearStrategy + ) + self.assertIsInstance( + self.calc_risk_period.impact_computation_strategy, ImpactCalcComputation + ) + np.testing.assert_array_equal( + self.calc_risk_period._group_id_E0, + self.mock_snapshot_start.exposure.gdf["group_id"].values, + ) + np.testing.assert_array_equal( + self.calc_risk_period._group_id_E1, + self.mock_snapshot_end.exposure.gdf["group_id"].values, + ) + self.assertIsInstance(self.calc_risk_period.date_idx, pd.PeriodIndex) + 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.PeriodIndex( + pd.PeriodIndex( + [ + "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_time_resolution(self): + self.calc_risk_period.time_resolution = "MS" + self.assertEqual(self.calc_risk_period.time_resolution, "MS") + pd.testing.assert_index_equal( + self.calc_risk_period.date_idx, + pd.PeriodIndex( + pd.PeriodIndex( + [ + "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=InterpolationStrategyBase) + 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" + + # The computation are tested in the CalcImpactStrategy / InterpolationStrategyBase tests + # Here we just make sure that the calling works + @patch.object(CalcRiskMetricPeriod, "impact_computation_strategy") + def test_impacts_arrays(self, mock_impact_compute): + mock_impact_compute.compute_impacts.side_effect = [1, 2, 3, 4, 5, 6, 7, 8] + self.assertEqual(self.calc_risk_period.E0H0V0, 1) + self.assertEqual(self.calc_risk_period.E1H0V0, 2) + self.assertEqual(self.calc_risk_period.E0H1V0, 3) + self.assertEqual(self.calc_risk_period.E1H1V0, 4) + self.assertEqual(self.calc_risk_period.E0H0V1, 5) + self.assertEqual(self.calc_risk_period.E1H0V1, 6) + self.assertEqual(self.calc_risk_period.E0H1V1, 7) + self.assertEqual(self.calc_risk_period.E1H1V1, 8) + mock_impact_compute.compute_impacts.assert_has_calls( + [ + call( + self.calc_risk_period.snapshot_start, + self.calc_risk_period.snapshot_end, + fut, + ) + for fut in [ + (0, 0, 0), + (1, 0, 0), + (0, 1, 0), + (1, 1, 0), + (0, 0, 1), + (1, 0, 1), + (0, 1, 1), + (1, 1, 1), + ] + ] + ) + + @patch.object(CalcRiskMetricPeriod, "interpolation_strategy") + def test_imp_mats_H0V0(self, mock_interpolate): + mock_interpolate.interp_over_exposure_dim.return_value = 1 + result = self.calc_risk_period.imp_mats_H0V0 + self.assertEqual(result, 1) + mock_interpolate.interp_over_exposure_dim.assert_called_with( + self.calc_risk_period.E0H0V0.imp_mat, + self.calc_risk_period.E1H0V0.imp_mat, + self.calc_risk_period.time_points, + ) + + @patch.object(CalcRiskMetricPeriod, "interpolation_strategy") + def test_imp_mats_H1V0(self, mock_interpolate): + mock_interpolate.interp_over_exposure_dim.return_value = 1 + result = self.calc_risk_period.imp_mats_H1V0 + self.assertEqual(result, 1) + mock_interpolate.interp_over_exposure_dim.assert_called_with( + self.calc_risk_period.E0H1V0.imp_mat, + self.calc_risk_period.E1H1V0.imp_mat, + self.calc_risk_period.time_points, + ) + + @patch.object(CalcRiskMetricPeriod, "interpolation_strategy") + def test_imp_mats_H0V1(self, mock_interpolate): + mock_interpolate.interp_over_exposure_dim.return_value = 1 + result = self.calc_risk_period.imp_mats_H0V1 + self.assertEqual(result, 1) + mock_interpolate.interp_over_exposure_dim.assert_called_with( + self.calc_risk_period.E0H0V1.imp_mat, + self.calc_risk_period.E1H0V1.imp_mat, + self.calc_risk_period.time_points, + ) + + @patch.object(CalcRiskMetricPeriod, "interpolation_strategy") + def test_imp_mats_H1V1(self, mock_interpolate): + mock_interpolate.interp_over_exposure_dim.return_value = 1 + result = self.calc_risk_period.imp_mats_H1V1 + self.assertEqual(result, 1) + mock_interpolate.interp_over_exposure_dim.assert_called_with( + self.calc_risk_period.E0H1V1.imp_mat, + self.calc_risk_period.E1H1V1.imp_mat, + self.calc_risk_period.time_points, + ) + + @patch.object(CalcRiskMetricPeriod, "calc_per_date_eais", return_value=1) + def test_per_date_eai_H0V0(self, mock_calc_per_date_eais): + result = self.calc_risk_period.per_date_eai_H0V0 + self.assertEqual(result, 1) + mock_calc_per_date_eais.assert_called_with( + self.calc_risk_period.imp_mats_H0V0, + self.calc_risk_period.snapshot_start.hazard.frequency, + ) + + @patch.object(CalcRiskMetricPeriod, "calc_per_date_eais", return_value=1) + def test_per_date_eai_H1V0(self, mock_calc_per_date_eais): + result = self.calc_risk_period.per_date_eai_H1V0 + self.assertEqual(result, 1) + mock_calc_per_date_eais.assert_called_with( + self.calc_risk_period.imp_mats_H1V0, + self.calc_risk_period.snapshot_end.hazard.frequency, + ) + + @patch.object(CalcRiskMetricPeriod, "calc_per_date_aais", return_value=1) + def test_per_date_aai_H0V0(self, mock_calc_per_date_aais): + result = self.calc_risk_period.per_date_aai_H0V0 + self.assertEqual(result, 1) + mock_calc_per_date_aais.assert_called_with( + self.calc_risk_period.per_date_eai_H0V0 + ) + + @patch.object(CalcRiskMetricPeriod, "calc_per_date_aais", return_value=1) + def test_per_date_aai_H1V0(self, mock_calc_per_date_aais): + result = self.calc_risk_period.per_date_aai_H1V0 + self.assertEqual(result, 1) + mock_calc_per_date_aais.assert_called_with( + self.calc_risk_period.per_date_eai_H1V0 + ) + + @patch.object(CalcRiskMetricPeriod, "calc_per_date_rps", return_value=1) + def test_per_date_return_periods_H0V0(self, mock_calc_per_date_rps): + result = self.calc_risk_period.per_date_return_periods_H0V0([10, 50]) + self.assertEqual(result, 1) + mock_calc_per_date_rps.assert_called_with( + self.calc_risk_period.imp_mats_H0V0, + self.calc_risk_period.snapshot_start.hazard.frequency, + [10, 50], + ) + + @patch.object(CalcRiskMetricPeriod, "calc_per_date_rps", return_value=1) + def test_per_date_return_periods_H1V0(self, mock_calc_per_date_rps): + result = self.calc_risk_period.per_date_return_periods_H1V0([10, 50]) + self.assertEqual(result, 1) + mock_calc_per_date_rps.assert_called_with( + self.calc_risk_period.imp_mats_H1V0, + self.calc_risk_period.snapshot_end.hazard.frequency, + [10, 50], + ) + + @patch.object(CalcRiskMetricPeriod, "calc_per_date_eais", return_value=1) + def test_per_date_eai_H0V1(self, mock_calc_per_date_eais): + result = self.calc_risk_period.per_date_eai_H0V1 + self.assertEqual(result, 1) + mock_calc_per_date_eais.assert_called_with( + self.calc_risk_period.imp_mats_H0V1, + self.calc_risk_period.snapshot_start.hazard.frequency, + ) + + @patch.object(CalcRiskMetricPeriod, "calc_per_date_eais", return_value=1) + def test_per_date_eai_H1V1(self, mock_calc_per_date_eais): + result = self.calc_risk_period.per_date_eai_H1V1 + self.assertEqual(result, 1) + mock_calc_per_date_eais.assert_called_with( + self.calc_risk_period.imp_mats_H1V1, + self.calc_risk_period.snapshot_end.hazard.frequency, + ) + + @patch.object(CalcRiskMetricPeriod, "calc_per_date_aais", return_value=1) + def test_per_date_aai_H0V1(self, mock_calc_per_date_aais): + result = self.calc_risk_period.per_date_aai_H0V1 + self.assertEqual(result, 1) + mock_calc_per_date_aais.assert_called_with( + self.calc_risk_period.per_date_eai_H0V1 + ) + + @patch.object(CalcRiskMetricPeriod, "calc_per_date_aais", return_value=1) + def test_per_date_aai_H1V1(self, mock_calc_per_date_aais): + result = self.calc_risk_period.per_date_aai_H1V1 + self.assertEqual(result, 1) + mock_calc_per_date_aais.assert_called_with( + self.calc_risk_period.per_date_eai_H1V1 + ) + + @patch.object(CalcRiskMetricPeriod, "calc_per_date_rps", return_value=1) + def test_per_date_return_periods_H0V1(self, mock_calc_per_date_rps): + result = self.calc_risk_period.per_date_return_periods_H0V1([10, 50]) + self.assertEqual(result, 1) + mock_calc_per_date_rps.assert_called_with( + self.calc_risk_period.imp_mats_H0V1, + self.calc_risk_period.snapshot_start.hazard.frequency, + [10, 50], + ) + + @patch.object(CalcRiskMetricPeriod, "calc_per_date_rps", return_value=1) + def test_per_date_return_periods_H1V1(self, mock_calc_per_date_rps): + result = self.calc_risk_period.per_date_return_periods_H1V1([10, 50]) + self.assertEqual(result, 1) + mock_calc_per_date_rps.assert_called_with( + self.calc_risk_period.imp_mats_H1V1, + self.calc_risk_period.snapshot_end.hazard.frequency, + [10, 50], + ) + + @patch.object(CalcRiskMetricPeriod, "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=CalcRiskMetricPeriod) + + # Little trick to bind the mocked object method to the real one + self.calc_risk_period.calc_eai = types.MethodType( + CalcRiskMetricPeriod.calc_eai, self.calc_risk_period + ) + + self.calc_risk_period.calc_eai_gdf = types.MethodType( + CalcRiskMetricPeriod.calc_eai_gdf, self.calc_risk_period + ) + self.calc_risk_period.calc_aai_metric = types.MethodType( + CalcRiskMetricPeriod.calc_aai_metric, self.calc_risk_period + ) + + self.calc_risk_period.calc_aai_per_group_metric = types.MethodType( + CalcRiskMetricPeriod.calc_aai_per_group_metric, self.calc_risk_period + ) + self.calc_risk_period.calc_return_periods_metric = types.MethodType( + CalcRiskMetricPeriod.calc_return_periods_metric, self.calc_risk_period + ) + self.calc_risk_period.calc_risk_components_metric = types.MethodType( + CalcRiskMetricPeriod.calc_risk_components_metric, self.calc_risk_period + ) + self.calc_risk_period.apply_measure = types.MethodType( + CalcRiskMetricPeriod.apply_measure, self.calc_risk_period + ) + + self.calc_risk_period.per_date_eai_H0V0 = np.array( + [[1, 0, 1], [1, 2, 0], [3, 3, 3]] + ) + self.calc_risk_period.per_date_eai_H1V0 = np.array( + [[2, 0, 2], [2, 4, 0], [12, 6, 6]] + ) + self.calc_risk_period.per_date_aai_H0V0 = np.array([2, 3, 9]) + self.calc_risk_period.per_date_aai_H1V0 = np.array([4, 6, 24]) + + self.calc_risk_period.per_date_eai_H0V1 = np.array( + [[1, 0, 1], [1, 2, 0], [3, 3, 3]] + ) + self.calc_risk_period.per_date_eai_H1V1 = np.array( + [[2, 0, 2], [2, 4, 0], [12, 6, 6]] + ) + self.calc_risk_period.per_date_aai_H0V1 = np.array([2, 3, 9]) + self.calc_risk_period.per_date_aai_H1V1 = np.array([4, 6, 24]) + + self.calc_risk_period.date_idx = pd.PeriodIndex( + ["2020-01-01", "2025-01-01", "2030-01-01"], name="date" + ) + self.calc_risk_period.snapshot_start.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.snapshot_end.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.measure = MagicMock(spec=Measure) + self.calc_risk_period.measure.name = "dummy_measure" + + def test_calc_eai(self): + # Mock the return values of interp_over_hazard_dim + self.calc_risk_period.interpolation_strategy.interp_over_hazard_dim.side_effect = [ + "V0_interpolated_data", # First call (for per_date_eai_V0) + "V1_interpolated_data", # Second call (for per_date_eai_V1) + ] + # Mock the return value of interp_over_vulnerability_dim + self.calc_risk_period.interpolation_strategy.interp_over_vulnerability_dim.return_value = ( + "final_eai_result" + ) + + result = self.calc_risk_period.calc_eai() + + # Assert that interp_over_hazard_dim was called with the correct arguments + self.calc_risk_period.interpolation_strategy.interp_over_hazard_dim.assert_has_calls( + [ + call( + self.calc_risk_period.per_date_eai_H0V0, + self.calc_risk_period.per_date_eai_H1V0, + ), + call( + self.calc_risk_period.per_date_eai_H0V1, + self.calc_risk_period.per_date_eai_H1V1, + ), + ] + ) + + # Assert that interp_over_vulnerability_dim was called with the results of interp_over_hazard_dim + self.calc_risk_period.interpolation_strategy.interp_over_vulnerability_dim.assert_called_once_with( + "V0_interpolated_data", "V1_interpolated_data" + ) + + # Assert the final returned value + self.assertEqual(result, "final_eai_result") + + def test_calc_eai_gdf(self): + self.calc_risk_period._groups_id = np.array([0]) + expected_risk = np.array([[1.0, 1.5, 12], [0, 3, 6], [1, 0, 6]]) + self.calc_risk_period.per_date_eai = expected_risk + result = self.calc_risk_period.calc_eai_gdf() + expected_columns = { + "group", + "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 + actual_risk = result["risk"].values + np.testing.assert_array_almost_equal(expected_risk.T.flatten(), actual_risk) + + def test_calc_aai_metric(self): + expected_aai = np.array([2, 4.5, 24]) + self.calc_risk_period.per_date_aai = expected_aai + self.calc_risk_period._groups_id = np.array([0]) + 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 + actual_risk = result["risk"].values + np.testing.assert_array_almost_equal(expected_aai, actual_risk) + + def test_calc_aai_per_group_metric(self): + self.calc_risk_period._group_id_E0 = np.array([1, 1, 2]) + self.calc_risk_period._group_id_E1 = np.array([2, 2, 2]) + self.calc_risk_period._groups_id = np.array([1, 2]) + self.calc_risk_period.eai_gdf = pd.DataFrame( + { + "date": pd.PeriodIndex( + ["2020-01-01"] * 3 + ["2025-01-01"] * 3 + ["2030-01-01"] * 3, + name="date", + ), + "coord_id": [0, 1, 2, 0, 1, 2, 0, 1, 2], + "group": [1, 1, 2, 1, 1, 2, 1, 1, 2], + "risk": [2, 3, 4, 5, 6, 7, 8, 9, 10], + "metric": ["eai", "eai", "eai"] * 3, + "measure": ["dummy_measure", "dummy_measure", "dummy_measure"] * 3, + } + ) + self.calc_risk_period.eai_gdf["group"] = self.calc_risk_period.eai_gdf[ + "group" + ].astype("category") + 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([5, 5, 6.6, 13.6, 3.4, 27]) + actual_risk = result["risk"].values + np.testing.assert_array_almost_equal(expected_risk, actual_risk) + + def test_calc_return_periods_metric(self): + self.calc_risk_period._groups_id = np.array([0]) + self.calc_risk_period.per_date_return_periods_H0V0.return_value = "H0V0" + self.calc_risk_period.per_date_return_periods_H1V0.return_value = "H1V0" + self.calc_risk_period.per_date_return_periods_H0V1.return_value = "H0V1" + self.calc_risk_period.per_date_return_periods_H1V1.return_value = "H1V1" + # Mock the return values of interp_over_hazard_dim + self.calc_risk_period.interpolation_strategy.interp_over_hazard_dim.side_effect = [ + "V0_interpolated_data", # First call (for per_date_rp_V0) + "V1_interpolated_data", # Second call (for per_date_rp_V1) + ] + # Mock the return value of interp_over_vulnerability_dim + self.calc_risk_period.interpolation_strategy.interp_over_vulnerability_dim.return_value = np.array( + [[1, 2, 3], [4, 5, 6], [7, 8, 9]] + ) + + result = self.calc_risk_period.calc_return_periods_metric([10, 20, 30]) + + # Assert that interp_over_hazard_dim was called with the correct arguments + self.calc_risk_period.interpolation_strategy.interp_over_hazard_dim.assert_has_calls( + [call("H0V0", "H1V0"), call("H0V1", "H1V1")] + ) + + # Assert that interp_over_vulnerability_dim was called with the results of interp_over_hazard_dim + self.calc_risk_period.interpolation_strategy.interp_over_vulnerability_dim.assert_called_once_with( + "V0_interpolated_data", "V1_interpolated_data" + ) + + # Assert the final returned value + + 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 + np.testing.assert_array_almost_equal( + result["risk"].values, np.array([1, 4, 7, 2, 5, 8, 3, 6, 9]) + ) + + def test_calc_risk_components_metric(self): + self.calc_risk_period._groups_id = np.array([0]) + self.calc_risk_period.per_date_aai_H0V0 = np.array([0, 0, 0]) + self.calc_risk_period.per_date_aai_H1V0 = np.array([1, 1, 1]) + self.calc_risk_period.per_date_aai_H0V1 = np.array([2, 2, 2]) + self.calc_risk_period.per_date_aai_H1V1 = np.array([3, 3, 3]) + self.calc_risk_period.per_date_aai = np.array([0, 6 / 4, 3]) + + # Mock the return values of interp_over_hazard_dim + self.calc_risk_period.interpolation_strategy.interp_over_hazard_dim.return_value = np.array( + [0, 0.5, 1] + ) + + # Mock the return value of interp_over_vulnerability_dim + self.calc_risk_period.interpolation_strategy.interp_over_vulnerability_dim.return_value = np.array( + [0, 1, 2] + ) + + result = self.calc_risk_period.calc_risk_components_metric() + + # Assert that interp_over_hazard_dim was called with the correct arguments + self.calc_risk_period.interpolation_strategy.interp_over_hazard_dim.assert_called_once_with( + self.calc_risk_period.per_date_aai_H0V0, + self.calc_risk_period.per_date_aai_H1V0, + ) + + # Assert that interp_over_vulnerability_dim was called with the results of interp_over_hazard_dim + self.calc_risk_period.interpolation_strategy.interp_over_vulnerability_dim.assert_called_once_with( + self.calc_risk_period.per_date_aai_H0V0, + self.calc_risk_period.per_date_aai_H0V1, + ) + + # Assert the final returned value + expected_columns = { + "group", + "date", + "risk", + "metric", + "measure", + } + self.assertTrue(expected_columns.issubset(set(result.columns))) + self.assertTrue( + all( + result["metric"].unique() + == [ + "base risk", + "exposure contribution", + "hazard contribution", + "vulnerability contribution", + "interaction contribution", + ] + ) + ) + self.assertTrue((result["measure"] == "dummy_measure").all()) + + # Check calculated risk values by rp, date + np.testing.assert_array_almost_equal( + result["risk"].values, + np.array([0, 0, 0, 0, 0, 0, 0, 0.5, 1.0, 0, 1, 2, 0, 0, 0]), + ) + + @patch("climada.trajectories.riskperiod.CalcRiskPeriod") + def test_apply_measure(self, mock_CalcRiskPeriod): + mock_CalcRiskPeriod.return_value = MagicMock(spec=CalcRiskMetricPeriod) + self.calc_risk_period.snapshot_start.apply_measure.return_value = 2 + self.calc_risk_period.snapshot_end.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.time_resolution, + self.calc_risk_period.time_points, + self.calc_risk_period.interpolation_strategy, + self.calc_risk_period.impact_computation_strategy, + ) + + +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() diff --git a/climada/trajectories/trajectory.py b/climada/trajectories/trajectory.py new file mode 100644 index 000000000..d37f72640 --- /dev/null +++ b/climada/trajectories/trajectory.py @@ -0,0 +1,214 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +This file implements abstract trajectory objects, to factorise the code common to +interpolated and static trajectories. + +""" + +import datetime +import logging +from abc import ABC + +import pandas as pd + +from climada.entity.disc_rates.base import DiscRates +from climada.trajectories.snapshot import Snapshot + +LOGGER = logging.getLogger(__name__) + +DEFAULT_RP = [20, 50, 100] + + +class RiskTrajectory(ABC): + _grouper = ["measure", "metric"] + """Results dataframe grouper""" + + POSSIBLE_METRICS = [] + + def __init__( + self, + snapshots_list: list[Snapshot], + *, + return_periods: list[int], + all_groups_name: str = "All", + risk_disc_rates: DiscRates | None = None, + ): + self._reset_metrics() + self._snapshots = snapshots_list + self._all_groups_name = all_groups_name + self._return_periods = return_periods + self.start_date = min([snapshot.date for snapshot in snapshots_list]) + self.end_date = max([snapshot.date for snapshot in snapshots_list]) + self._risk_disc_rates = risk_disc_rates + + def _reset_metrics(self): + for metric in self.POSSIBLE_METRICS: + setattr(self, "_" + metric + "_metrics", None) + + def _generic_metrics(self, metric_name: str, **kwargs) -> pd.DataFrame: ... + + def _compute_metrics( + self, metric_name: str, metric_meth: str, **kwargs + ) -> pd.DataFrame: + """Helper method to compute metrics. + + Notes + ----- + + This method exists for the sake of the children option appraisal classes, for which + `_generic_metrics` can have an additional keyword argument and call and extend on its + parent method, while this method can stay the same. + """ + df = self._generic_metrics( + metric_name=metric_name, metric_meth=metric_meth, **kwargs + ) + return df + + @property + def return_periods(self) -> list[int]: + """The return period values to use when computing risk period metrics. + + Notes + ----- + + Changing its value resets the corresponding metric. + """ + return self._return_periods + + @return_periods.setter + def return_periods(self, value, /): + if not isinstance(value, list): + raise ValueError("Return periods need to be a list of int.") + if any(not isinstance(i, int) for i in value): + raise ValueError("Return periods need to be a list of int.") + self._return_periods_metrics = None + self._return_periods = value + + @property + def risk_disc_rates(self) -> DiscRates | None: + """The discount rate applied to compute net present values. + None means no discount rate. + + Notes + ----- + + Changing its value resets the metrics. + """ + return self._risk_disc_rates + + @risk_disc_rates.setter + def risk_disc_rates(self, value, /): + if not isinstance(value, DiscRates): + raise ValueError("Risk discount needs to be a `DiscRates` object.") + + self._reset_metrics() + self._risk_disc_rates = value + + @classmethod + def npv_transform( + cls, df: pd.DataFrame, risk_disc_rates: DiscRates + ) -> pd.DataFrame: + """Apply discount rate to a metric `DataFrame`. + + Parameters + ---------- + df : pd.DataFrame + The `DataFrame` of the metric to discount. + risk_disc_rates : DiscRate + The discount rate to apply. + + Returns + ------- + pd.DataFrame + The discounted risk metric. + + + """ + + def _npv_group(group, disc): + start_date = group.index.get_level_values("date").min() + return cls._calc_npv_cash_flows(group, start_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, + observed=True, + )["risk"].transform(_npv_group, risk_disc_rates) + df = df.reset_index() + return df + + @staticmethod + def _calc_npv_cash_flows( + cash_flows: pd.DataFrame, + start_date: datetime.date, + disc_rates: DiscRates | None = None, + ): + """Apply discount rate to cash flows. + + If it is defined, applies a discount rate `disc` to a given cash flow + `cash_flows` assuming present year corresponds to `start_date`. + + Parameters + ---------- + cash_flows : pd.DataFrame + The cash flow to apply the discount rate to. + start_date : datetime.date + The date representing the present. + end_date : datetime.date, optional + disc : DiscRates, optional + The discount rate to apply. + + Returns + ------- + + A dataframe (copy) of `cash_flows` where values are discounted according to `disc` + """ + + if not disc_rates: + return cash_flows + + if not isinstance(cash_flows.index, pd.PeriodIndex): + raise ValueError("cash_flows must be a pandas Series with a datetime index") + + df = cash_flows.to_frame(name="cash_flow") + df["year"] = df.index.year + + # Merge with the discount rates based on the year + tmp = df.merge( + pd.DataFrame({"year": disc_rates.years, "rate": disc_rates.rates}), + on="year", + how="left", + ) + tmp.index = df.index + df = tmp.copy() + df["discount_factor"] = (1 / (1 + df["rate"])) ** ( + (df.index.year - start_date.year) + ) + + # Apply the discount factors to the cash flows + df["npv_cash_flow"] = df["cash_flow"] * df["discount_factor"] + + return df["npv_cash_flow"] diff --git a/doc/user-guide/climada_trajectories.ipynb b/doc/user-guide/climada_trajectories.ipynb new file mode 100644 index 000000000..b30c71217 --- /dev/null +++ b/doc/user-guide/climada_trajectories.ipynb @@ -0,0 +1,1962 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "96920214-a14b-4094-9949-36a1175b1df8", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "id": "56a07dee-25a8-4bb5-a01c-933ee955f067", + "metadata": {}, + "source": [ + "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", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "856ac388-9edb-497e-a2ff-a325f2a22562", + "metadata": {}, + "source": [ + "# Important disclaimers" + ] + }, + { + "cell_type": "markdown", + "id": "f7d4fdab-8662-4848-bb87-9b6045447957", + "metadata": {}, + "source": [ + "## Interpolation of risk can be... risky" + ] + }, + { + "cell_type": "markdown", + "id": "8f9531a7-9a1a-400f-8c82-3a51fdc6671a", + "metadata": {}, + "source": [ + "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 if the tool fits the purpose and if the limitations \n", + "remain acceptable, even more so when used to design Disaster Risk Reduction or Climate Change Adaptation measures." + ] + }, + { + "cell_type": "markdown", + "id": "c588329e-f5a5-4945-aad1-900b7bb675e3", + "metadata": {}, + "source": [ + "## Memory and computation requirements\n", + "\n", + "This module adds a new dimension (time) to the risk, as such, it **multiplies** the memory and computation requirement along that dimension (although we avoid running a full-fledge impact computation for each \"interpolated\" point, we still have to define an impact matrix for each of those). \n", + "\n", + "This can of course (very) quickly increase the memory and computation requirements for bigger data. We encourage you to first try on small examples before running big computations.\n" + ] + }, + { + "cell_type": "markdown", + "id": "b53b1da2-7be1-4507-96bb-2efd8dd3e910", + "metadata": {}, + "source": [ + "# Using the `trajectories` module" + ] + }, + { + "cell_type": "markdown", + "id": "4e0f3261-f443-4cc6-b85b-c6a3d90b73e3", + "metadata": {}, + "source": [ + "The fundamental idea behing the `trajectories` module is to enable a better assessment of the evolution of risk over time.\n", + "\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." + ] + }, + { + "cell_type": "markdown", + "id": "6396ab9f-7b09-49a7-81a5-a45e7a99a4ff", + "metadata": {}, + "source": [ + "## `Snapshot`: A snapshot of risk at a specific year" + ] + }, + { + "cell_type": "markdown", + "id": "274a342f-54c0-4590-9110-5e297010955e", + "metadata": {}, + "source": [ + "We use `Snapshot` objects to define a point in time for risk. This object acts as a wrapper of the classic risk framework composed of Exposure, Hazard and Vulnerability. As such it is defined for a specific date (usually a year), and contains 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 users will really use are `RiskTrajectory` which we present right after." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "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" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-09-12 14:44:39,261 - climada.entity.exposures.base - INFO - Reading /home/sjuhel/climada/data/exposures/litpop/LitPop_150arcsec_HTI/v3/LitPop_150arcsec_HTI.hdf5\n", + "2025-09-12 14:44:44,907 - 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-09-12 14:44:44,935 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-09-12 14:44:44,937 - 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", + "\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", + "\n", + "# Trajectories allow to look at the risk faced by specifics groups of coordinates based on the \"group_id\" column of the exposure\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": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-09-12 14:44:45,284 - climada.util.coordinates - INFO - Raster from resolution 0.04166665999999708 to 0.04166665999999708.\n" + ] + }, + { + "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 `RiskTrajectory` object.\n", + "\n", + "`RiskTrajectory` uses one or more `CalcRiskPeriod` under the hood that handles the computation to estimate the different risk metrics at every date between pairs of consecutive `Snapshot`.\n", + "\n", + "In the following we focus on a trajectory between only two snapshot, but as you can learn in the lasts part of this guide you can actually create a trajectory of risk with any number of snapshots.\n", + "\n", + "So first, let us define `Snapshot` for a future point in time. We will increase the value of the exposure following a certain growth rate, and use future tropical cyclone data." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c516c861-c5c1-475b-82e2-c867c5c08ec9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-09-12 14:45:06,403 - 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-09-12 14:45:06,427 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-09-12 14:45:06,427 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-09-12 14:45:06,427 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-09-12 14:45:06,429 - 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", + "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(v_half=60.0),\n", + " ]\n", + ")\n", + "exp_future.gdf.rename(columns={\"impf_\": \"impf_TC\"}, inplace=True)\n", + "exp_future.gdf[\"impf_TC\"] = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "3b909d67-9e89-4a50-905c-de616c9d5a0a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 84, + "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": 86, + "id": "4ffe490d-8488-4005-9442-deb642e19985", + "metadata": {}, + "outputs": [], + "source": [ + "snapcol = [snap, snap2]" + ] + }, + { + "cell_type": "markdown", + "id": "27ca72b1-b1fa-4cd2-8f74-a69dc6eb3c9c", + "metadata": {}, + "source": [ + "Based on such a list of snapshots, we can then evaluate a risk trajectory using a `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 resolution (one year by default).\n", + "\n", + "In this example, from the snapshot in 2018 to the one in 2040. \n", + "\n", + "Note that this can require a bit of computation and memory, especially for large regions or extended range of time.\n", + "The computations are only run when needed, not during instantiation, and are cached once computed." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "c644d470-7fd3-461e-97fd-d23d40f7abd9", + "metadata": {}, + "outputs": [], + "source": [ + "from climada.trajectories.risk_trajectory import RiskTrajectory\n", + "\n", + "risk_traj = RiskTrajectory(snapcol)" + ] + }, + { + "cell_type": "markdown", + "id": "68d9e0c7-8efd-44fb-8512-cd480e510c50", + "metadata": {}, + "source": [ + "From this object you can access different risk metrics:\n", + "\n", + "* Average Annual Impact (aai) both for all exposure points (group == \"All\") and specific groups of exposure points (defined by a \"group_id\" in the exposure).\n", + "* Estimated impact for different return periods (100, 500 and 1000 by default) **-> Pretty sure this is plain wrong as it sums up the values of each year**\n", + "\n", + "Both as totals over the whole period:" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "9c485dc4-c009-46fb-aa4a-603bc9dcf5b4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-09-12 11:48:45,353 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-09-12 11:48:45,353 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-09-12 11:48:45,354 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-09-12 11:48:45,355 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-09-12 11:48:45,359 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-09-12 11:48:45,369 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-09-12 11:48:45,370 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-09-12 11:48:45,370 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-09-12 11:48:45,372 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-09-12 11:48:45,376 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-09-12 11:48:45,428 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-09-12 11:48:45,429 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-09-12 11:48:45,429 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-09-12 11:48:45,431 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-09-12 11:48:45,435 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-09-12 11:48:45,445 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-09-12 11:48:45,446 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-09-12 11:48:45,446 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-09-12 11:48:45,448 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-09-12 11:48:45,451 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-09-12 11:48:45,495 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-09-12 11:48:45,495 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-09-12 11:48:45,496 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-09-12 11:48:45,498 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-09-12 11:48:45,501 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-09-12 11:48:45,511 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-09-12 11:48:45,512 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-09-12 11:48:45,512 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-09-12 11:48:45,514 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-09-12 11:48:45,517 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-09-12 11:48:45,559 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-09-12 11:48:45,560 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-09-12 11:48:45,560 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-09-12 11:48:45,563 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-09-12 11:48:45,568 - climada.engine.impact_calc - INFO - Calculating impact for 3987 assets (>0) and 43560 events.\n", + "2025-09-12 11:48:45,584 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-09-12 11:48:45,584 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-09-12 11:48:45,585 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-09-12 11:48:45,587 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-09-12 11:48:45,591 - 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.414905e+07
12018-01-01 to 2040-01-011no_measureaai9.465607e+09
22018-01-01 to 2040-01-01Allno_measureaai9.479757e+09
32018-01-01 to 2040-01-01Allno_measurerp_1003.117856e+11
42018-01-01 to 2040-01-01Allno_measurerp_501.782113e+11
52018-01-01 to 2040-01-01Allno_measurerp_5008.083646e+11
\n", + "
" + ], + "text/plain": [ + " period group measure metric risk\n", + "0 2018-01-01 to 2040-01-01 0 no_measure aai 1.414905e+07\n", + "1 2018-01-01 to 2040-01-01 1 no_measure aai 9.465607e+09\n", + "2 2018-01-01 to 2040-01-01 All no_measure aai 9.479757e+09\n", + "3 2018-01-01 to 2040-01-01 All no_measure rp_100 3.117856e+11\n", + "4 2018-01-01 to 2040-01-01 All no_measure rp_50 1.782113e+11\n", + "5 2018-01-01 to 2040-01-01 All no_measure rp_500 8.083646e+11" + ] + }, + "execution_count": 88, + "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": 89, + "id": "6b73a589-9ee4-41e8-90e0-910bfe4dd8fc", + "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", + "
groupdatemeasuremetricrisk
0All2018-01-01no_measureaai1.840432e+08
1All2019-01-01no_measureaai2.000396e+08
2All2020-01-01no_measureaai2.166844e+08
3All2021-01-01no_measureaai2.339834e+08
4All2022-01-01no_measureaai2.519424e+08
..................
4112038-01-01no_measureaai6.328297e+08
4202039-01-01no_measureaai9.943382e+05
4312039-01-01no_measureaai6.628505e+08
4402040-01-01no_measureaai1.040877e+06
4512040-01-01no_measureaai6.936344e+08
\n", + "

138 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " group date measure metric risk\n", + "0 All 2018-01-01 no_measure aai 1.840432e+08\n", + "1 All 2019-01-01 no_measure aai 2.000396e+08\n", + "2 All 2020-01-01 no_measure aai 2.166844e+08\n", + "3 All 2021-01-01 no_measure aai 2.339834e+08\n", + "4 All 2022-01-01 no_measure aai 2.519424e+08\n", + ".. ... ... ... ... ...\n", + "41 1 2038-01-01 no_measure aai 6.328297e+08\n", + "42 0 2039-01-01 no_measure aai 9.943382e+05\n", + "43 1 2039-01-01 no_measure aai 6.628505e+08\n", + "44 0 2040-01-01 no_measure aai 1.040877e+06\n", + "45 1 2040-01-01 no_measure aai 6.936344e+08\n", + "\n", + "[138 rows x 5 columns]" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], + "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:\n", + "\n", + " - The 'base risk', i.e., the risk without change in hazard or exposure, compared to trajectory's earliest date.\n", + " - The 'exposure contribution', i.e., the additional risks due to change in exposure (only)\n", + " - The 'hazard contribution', i.e., the additional risks due to change in hazard (only)\n", + " - The 'vulnerability contribution', i.e., the additional risks due to change in vulnerability (only)\n", + " - The 'interaction contribution', i.e., the additional risks due to the interaction term" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "id": "08c226a4-944b-4301-acfa-602adde980a5", + "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": [ + "risk_traj.plot_waterfall()" + ] + }, + { + "cell_type": "markdown", + "id": "7896af66-b0aa-4418-b22e-c64fd4d2cfe1", + "metadata": {}, + "source": [ + "And as well on a per date basis (keep in mind this is an interpolation, thus should be interpreted with caution):" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "id": "cf40380a-5814-4164-a592-7ab181776b5a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(
,\n", + " )" + ] + }, + "execution_count": 91, + "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": "501e455b-e7c6-4672-9191-d5fefe38d424", + "metadata": {}, + "source": [ + "### DiscRates" + ] + }, + { + "cell_type": "markdown", + "id": "0dba0218-55fe-423d-a520-61d3cb2a991c", + "metadata": {}, + "source": [ + "To correctly assess the future risk, you may also want to apply a discount rate, in order to express future costs in net present value.\n", + "\n", + "This can easily be done providing an instance of the already existing `DiscRates` class when instantiating the trajectory:" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "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": 43, + "id": "d86bedbb-6c0a-4f7d-a63e-5012510339d3", + "metadata": {}, + "outputs": [], + "source": [ + "discounted_risk_traj = RiskTrajectory(snapcol, risk_disc=discount_stern)" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "9b2f8e5f-c582-4971-a61c-ddd0d40448e4", + "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_measureaai1.972777e+08
22020-01-01Allno_measureaai2.107423e+08
32021-01-01Allno_measureaai2.244250e+08
42022-01-01Allno_measureaai2.383140e+08
..................
412038-01-011no_measureaai4.792120e+08
422039-01-010no_measureaai7.425694e+05
432039-01-011no_measureaai4.950152e+08
442040-01-010no_measureaai7.665923e+05
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 1.972777e+08\n", + "2 2020-01-01 All no_measure aai 2.107423e+08\n", + "3 2021-01-01 All no_measure aai 2.244250e+08\n", + "4 2022-01-01 All no_measure aai 2.383140e+08\n", + ".. ... ... ... ... ...\n", + "41 2038-01-01 1 no_measure aai 4.792120e+08\n", + "42 2039-01-01 0 no_measure aai 7.425694e+05\n", + "43 2039-01-01 1 no_measure aai 4.950152e+08\n", + "44 2040-01-01 0 no_measure aai 7.665923e+05\n", + "45 2040-01-01 1 no_measure aai 5.108526e+08\n", + "\n", + "[138 rows x 5 columns]" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "discounted_risk_traj.per_date_risk_metrics()" + ] + }, + { + "cell_type": "markdown", + "id": "da070e7d-6d12-4e47-b3dc-d5916e48b0a1", + "metadata": {}, + "source": [ + "To ease comparison, you can ask for metrics without NPV by asking explicitly:" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "426fef0d-2284-40fb-8ce2-09860de1e8a1", + "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", + "
groupdatemeasuremetricrisk
0All2018-01-01no_measureaai1.840432e+08
1All2019-01-01no_measureaai2.000396e+08
2All2020-01-01no_measureaai2.166844e+08
3All2021-01-01no_measureaai2.339834e+08
4All2022-01-01no_measureaai2.519424e+08
..................
4112038-01-01no_measureaai6.328297e+08
4202039-01-01no_measureaai9.943382e+05
4312039-01-01no_measureaai6.628505e+08
4402040-01-01no_measureaai1.040877e+06
4512040-01-01no_measureaai6.936344e+08
\n", + "

138 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " group date measure metric risk\n", + "0 All 2018-01-01 no_measure aai 1.840432e+08\n", + "1 All 2019-01-01 no_measure aai 2.000396e+08\n", + "2 All 2020-01-01 no_measure aai 2.166844e+08\n", + "3 All 2021-01-01 no_measure aai 2.339834e+08\n", + "4 All 2022-01-01 no_measure aai 2.519424e+08\n", + ".. ... ... ... ... ...\n", + "41 1 2038-01-01 no_measure aai 6.328297e+08\n", + "42 0 2039-01-01 no_measure aai 9.943382e+05\n", + "43 1 2039-01-01 no_measure aai 6.628505e+08\n", + "44 0 2040-01-01 no_measure aai 1.040877e+06\n", + "45 1 2040-01-01 no_measure aai 6.936344e+08\n", + "\n", + "[138 rows x 5 columns]" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "discounted_risk_traj.per_date_risk_metrics(npv=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "ee3b0217-fe14-44a9-98f5-e1fc7f45e613", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 55, + "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()[\"group\"] == \"All\")\n", + " ],\n", + " x=\"date\",\n", + " y=\"risk\",\n", + " color=\"blue\",\n", + " label=\"Discounted risk\",\n", + ")\n", + "sns.lineplot(\n", + " discounted_risk_traj.per_date_risk_metrics(npv=False).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", + " ax=g,\n", + " color=\"red\",\n", + " label=\"Not discounted risk\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "0152e9fa-55fa-4cf2-b187-59e6228af563", + "metadata": {}, + "source": [ + "# Advanced usage\n", + "\n", + "In this section we present some more advanced features and use of this module." + ] + }, + { + "cell_type": "markdown", + "id": "42c9daed-6488-488b-b01a-fd6dfc5d0274", + "metadata": {}, + "source": [ + "## Higher number of snapshots" + ] + }, + { + "cell_type": "markdown", + "id": "6db14802-fa35-4e33-91ef-7dddd4d43da7", + "metadata": {}, + "source": [ + "You can seemlessly use more than two snapshots to define a risk trajectory.\n", + "The interpolation will be done between each pair of consecutive snapshots, \n", + "and all results will be collected together." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d93eb82b-65d2-48fe-a195-6cb12f23bf47", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-09-12 13:35:07,107 - climada.entity.exposures.base - INFO - Reading /home/sjuhel/climada/data/exposures/litpop/LitPop_150arcsec_HTI/v3/LitPop_150arcsec_HTI.hdf5\n", + "2025-09-12 13:35:12,504 - 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-09-12 13:35:12,531 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-09-12 13:35:12,533 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-09-12 13:35:18,244 - 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-09-12 13:35:18,270 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-09-12 13:35:18,270 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-09-12 13:35:18,271 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-09-12 13:35:18,272 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-09-12 13:35:23,712 - 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-09-12 13:35:23,739 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-09-12 13:35:23,740 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-09-12 13:35:23,740 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-09-12 13:35:23,742 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2025-09-12 13:35:29,263 - 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-09-12 13:35:29,291 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2025-09-12 13:35:29,292 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-09-12 13:35:29,292 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-09-12 13:35:29,293 - 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": 101, + "id": "0ceb1362-a880-4deb-8477-fd160ce4292b", + "metadata": {}, + "outputs": [], + "source": [ + "risk_traj = RiskTrajectory(snapcol)" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "id": "1c5aeb4b-6320-479d-82a6-9b2c3901868e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 106, + "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": "code", + "execution_count": 107, + "id": "16faf81c-8760-4c02-a575-ae033bcb637d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(
,\n", + " )" + ] + }, + "execution_count": 107, + "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": "4f8f83d6-a45d-4d3b-b25d-d3294e6e1955", + "metadata": {}, + "source": [ + "You can use any valid pandas [frequency string](https://pandas.pydata.org/docs/user_guide/timeseries.html#timeseries-offset-aliases) for the time resolution,\n", + "for instance \"5YS\" for every five years. This reduces the resolution of the interpolation, which can reduce the required computations at the cost of \"precision\".\n", + "Conversely you can also increase the time resolution to a monthly base for instance\n", + "\n", + "Keep in mind that risk metrics are still computed the same way so you would still get \"Average Annual Impacts\"\n", + "values for every months and not average monthly ones !" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "id": "128fac77-e077-4241-a003-a60c4afcad74", + "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", + "
groupdatemeasuremetricrisk
0All2018-01-01no_measureaai1.840432e+08
1All2023-01-01no_measureaai2.801311e+08
2All2028-01-01no_measureaai3.966228e+08
3All2033-01-01no_measureaai5.344827e+08
4All2038-01-01no_measureaai6.946753e+08
\n", + "
" + ], + "text/plain": [ + " group date measure metric risk\n", + "0 All 2018-01-01 no_measure aai 1.840432e+08\n", + "1 All 2023-01-01 no_measure aai 2.801311e+08\n", + "2 All 2028-01-01 no_measure aai 3.966228e+08\n", + "3 All 2033-01-01 no_measure aai 5.344827e+08\n", + "4 All 2038-01-01 no_measure aai 6.946753e+08" + ] + }, + "execution_count": 126, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "snapcol = [snap, snap2]\n", + "risk_traj = RiskTrajectory(snapcol, time_resolution=\"5YS\")\n", + "risk_traj.per_date_risk_metrics().head()" + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "id": "c1e66906-63e3-4a29-8a0b-0e706e6a2a09", + "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", + "
groupdatemeasuremetricrisk
0All2018-01-01no_measureaai1.840432e+08
1All2018-02-01no_measureaai1.853516e+08
2All2018-03-01no_measureaai1.866645e+08
3All2018-04-01no_measureaai1.879819e+08
4All2018-05-01no_measureaai1.893037e+08
\n", + "
" + ], + "text/plain": [ + " group date measure metric risk\n", + "0 All 2018-01-01 no_measure aai 1.840432e+08\n", + "1 All 2018-02-01 no_measure aai 1.853516e+08\n", + "2 All 2018-03-01 no_measure aai 1.866645e+08\n", + "3 All 2018-04-01 no_measure aai 1.879819e+08\n", + "4 All 2018-05-01 no_measure aai 1.893037e+08" + ] + }, + "execution_count": 129, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "snapcol = [snap, snap2]\n", + "\n", + "# Here we use \"1MS\" to get a monthly basis\n", + "risk_traj = RiskTrajectory(snapcol, time_resolution=\"1MS\")\n", + "\n", + "# We would have to divide results by 12 to get \"average monthly impacts\"\n", + "risk_traj.per_date_risk_metrics().head()" + ] + }, + { + "cell_type": "markdown", + "id": "f5d6b725-41ee-495b-bc72-5806db4cfdba", + "metadata": {}, + "source": [ + "## Non-linear interpolation" + ] + }, + { + "cell_type": "markdown", + "id": "a8065729-5d0b-4250-8324-2ce82cb0d644", + "metadata": {}, + "source": [ + "The module allows you to define your own interpolation strategy. Thus you can decide how to interpolate along each dimension of risk (Exposure, Hazard and Vulnerability).\n", + "This is done via `InterpolationStrategy` objects, which simply require three functions stating how to interpolate along each dimensions.\n", + "\n", + "For convenience the module provides an `AllLinearStrategy` (risk is linearly interpolated along all dimensions) and a `ExponentialExposureStrategy` (risk uses exponential interpolation along exposure, and linear for the two other dimensions)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "4168946a-b3a0-46ad-950d-e8f2af48a1a2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from climada.trajectories.interpolation import ExponentialExposureStrategy\n", + "import seaborn as sns\n", + "\n", + "exp_interp = ExponentialExposureStrategy(rate=1.02)\n", + "\n", + "snapcol = [snap, snap2]\n", + "risk_traj = RiskTrajectory(snapcol)\n", + "risk_traj_exp = RiskTrajectory(snapcol, interpolation_strategy=exp_interp)\n", + "\n", + "sns.lineplot(\n", + " risk_traj.aai_metrics(),\n", + " x=\"date\",\n", + " y=\"risk\",\n", + " label=\"Linear interpolation for exposure\",\n", + ")\n", + "sns.lineplot(\n", + " risk_traj_exp.aai_metrics(),\n", + " x=\"date\",\n", + " y=\"risk\",\n", + " label=\"Exponential interpolation for exposure\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "4a5991b8-659e-4b0a-81cc-bc0d085ff1e7", + "metadata": {}, + "source": [ + "## Spatial mapping" + ] + }, + { + "cell_type": "markdown", + "id": "d47bcc7e-defe-4058-b7a3-4dafd4374f35", + "metadata": {}, + "source": [ + "You can access a DataFrame with the estimated annual impacts at each coordinates through \"eai_metrics\" which can easily be merged to the exposure GeoDataFrame:" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "431d26f1-c19f-4654-814b-20e8a243848e", + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
groupdatemeasuremetriccoord_idrisk
012018-01-01no_measureeai03515.056865
112019-01-01no_measureeai03822.351335
212020-01-01no_measureeai04142.027736
312021-01-01no_measureeai04474.189828
412022-01-01no_measureeai04818.941374
.....................
3056212036-01-01no_measureeai13284587.481962
3056312037-01-01no_measureeai13284827.783722
3056412038-01-01no_measureeai13285074.773534
3056512039-01-01no_measureeai13285328.510069
3056612040-01-01no_measureeai13285589.052003
\n", + "

30567 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " group date measure metric coord_id risk\n", + "0 1 2018-01-01 no_measure eai 0 3515.056865\n", + "1 1 2019-01-01 no_measure eai 0 3822.351335\n", + "2 1 2020-01-01 no_measure eai 0 4142.027736\n", + "3 1 2021-01-01 no_measure eai 0 4474.189828\n", + "4 1 2022-01-01 no_measure eai 0 4818.941374\n", + "... ... ... ... ... ... ...\n", + "30562 1 2036-01-01 no_measure eai 1328 4587.481962\n", + "30563 1 2037-01-01 no_measure eai 1328 4827.783722\n", + "30564 1 2038-01-01 no_measure eai 1328 5074.773534\n", + "30565 1 2039-01-01 no_measure eai 1328 5328.510069\n", + "30566 1 2040-01-01 no_measure eai 1328 5589.052003\n", + "\n", + "[30567 rows x 6 columns]" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = risk_traj.eai_metrics()\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "61abb90f-42f8-446c-aa27-8a5b5eaa3729", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "gdf = snap.exposure.gdf\n", + "gdf[\"coord_id\"] = gdf.index\n", + "gdf = gdf.merge(df, on=\"coord_id\")\n", + "\n", + "fig, axs = plt.subplots(1, 3, figsize=(20, 4))\n", + "\n", + "gdf.loc[gdf[\"date\"] == \"2018-01-01\"].plot(\n", + " column=\"risk\",\n", + " legend=True,\n", + " vmin=gdf[\"risk\"].min(),\n", + " vmax=gdf[\"risk\"].max(),\n", + " ax=axs[0],\n", + ")\n", + "gdf.loc[gdf[\"date\"] == \"2030-01-01\"].plot(\n", + " column=\"risk\",\n", + " legend=True,\n", + " vmin=gdf[\"risk\"].min(),\n", + " vmax=gdf[\"risk\"].max(),\n", + " ax=axs[1],\n", + ")\n", + "gdf.loc[gdf[\"date\"] == \"2040-01-01\"].plot(\n", + " column=\"risk\",\n", + " legend=True,\n", + " vmin=gdf[\"risk\"].min(),\n", + " vmax=gdf[\"risk\"].max(),\n", + " ax=axs[2],\n", + ")\n", + "\n", + "axs[0].set_title(\"Average Annual Risk in 2018\")\n", + "axs[1].set_title(\"Average Annual Risk in 2030\")\n", + "axs[2].set_title(\"Average Annual Risk in 2040\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2f53801f-7a31-4d77-b7b7-51bc8fd2bb05", + "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 +}