diff --git a/climada/conf/climada.conf b/climada/conf/climada.conf
index 5fd35b1c42..d0573ff7a6 100644
--- a/climada/conf/climada.conf
+++ b/climada/conf/climada.conf
@@ -69,5 +69,6 @@
"cache_dir": "{local_data.system}/.apicache",
"supported_hazard_types": ["river_flood", "tropical_cyclone", "storm_europe", "relative_cropyield", "wildfire", "earthquake", "flood", "hail", "aqueduct_coastal_flood"],
"supported_exposures_types": ["litpop", "crop_production", "ssp_population", "crops"]
- }
+ },
+ "trajectory_caching": true
}
diff --git a/climada/test/conftest.py b/climada/test/conftest.py
new file mode 100644
index 0000000000..28214dfcaf
--- /dev/null
+++ b/climada/test/conftest.py
@@ -0,0 +1,312 @@
+"""
+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 `_.
+ name : str, optional
+ Name of the resulting period range index.
+
+ Returns
+ -------
+ pd.PeriodIndex
+ A PeriodIndex representing the date range.
+
+ Raises
+ ------
+ ValueError
+ If the number of periods and frequency given to period_range are inconsistent.
+ """
+ ret = pd.period_range(
+ date1,
+ date2,
+ freq=freq, # type: ignore
+ name=name,
+ )
+ return ret
+
+ @property
+ def snapshot_start(self) -> Snapshot:
+ """The `Snapshot` at the start of the risk period."""
+ return self._snapshot_start
+
+ @property
+ def snapshot_end(self) -> Snapshot:
+ """The `Snapshot` at the end of the risk period."""
+ return self._snapshot_end
+
+ @property
+ def date_idx(self) -> pd.PeriodIndex:
+ """The pandas PeriodIndex representing the time dimension of the risk period."""
+ return self._date_idx
+
+ @date_idx.setter
+ def date_idx(self, value, /):
+ if not isinstance(value, pd.PeriodIndex):
+ raise ValueError("Not a PeriodIndex")
+
+ self._date_idx = value # Avoids weird hourly data
+ self._time_resolution = self.date_idx.freq
+ self._reset_impact_data()
+
+ @property
+ def time_points(self) -> int:
+ """The numbers of different time points (periods) in the risk period."""
+ return len(self.date_idx)
+
+ @property
+ def time_resolution(self) -> str:
+ """The time resolution of the risk periods, expressed as
+ a pandas period frequency string.
+
+ """
+ return self._time_resolution # type: ignore
+
+ @time_resolution.setter
+ def time_resolution(self, value, /):
+ self.date_idx = pd.period_range(
+ self.snapshot_start.date,
+ self.snapshot_end.date,
+ freq=value,
+ name=DEFAULT_PERIOD_INDEX_NAME,
+ )
+
+ @property
+ def interpolation_strategy(self) -> InterpolationStrategyBase:
+ """The approach used to interpolate impact matrices in between the two snapshots."""
+ return self._interpolation_strategy
+
+ @interpolation_strategy.setter
+ def interpolation_strategy(self, value, /):
+ if not isinstance(value, InterpolationStrategyBase):
+ raise ValueError("Not an interpolation strategy")
+
+ self._interpolation_strategy = value
+ self._reset_impact_data()
+
+ @property
+ def impact_computation_strategy(self) -> ImpactComputationStrategy:
+ """The method used to calculate the impact from the (Haz,Exp,Vul) of the two snapshots."""
+ return self._impact_computation_strategy
+
+ @impact_computation_strategy.setter
+ def impact_computation_strategy(self, value, /):
+ if not isinstance(value, ImpactComputationStrategy):
+ raise ValueError("Not an impact computation strategy")
+
+ self._impact_computation_strategy = value
+ self._reset_impact_data()
+
+ def apply_measure(self, measure: Measure) -> "CalcRiskMetricsPeriod":
+ """Creates a new `CalcRiskMetricsPeriod` object with a measure.
+
+ The given measure is applied to both snapshot of the risk period.
+
+ Parameters
+ ----------
+ measure : Measure
+ The measure to apply.
+
+ Returns
+ -------
+
+ CalcRiskPeriod
+ The risk period with given measure applied.
+
+ """
+ snap0 = self.snapshot_start.apply_measure(measure)
+ snap1 = self.snapshot_end.apply_measure(measure)
+
+ risk_period = CalcRiskMetricsPeriod(
+ snap0,
+ snap1,
+ time_resolution=self.time_resolution,
+ interpolation_strategy=self.interpolation_strategy,
+ impact_computation_strategy=self.impact_computation_strategy,
+ )
+
+ risk_period.measure = measure
+ return risk_period
+
+ ###################################################
+ ##### Impact objects cube / Risk Cube corners #####
+
+ @lazy_property
+ def E0H0V0(self) -> Impact:
+ """Impact object corresponding to starting exposure,
+ starting hazard and starting vulnerability.
+
+ """
+ return self.impact_computation_strategy.compute_impacts(
+ self.snapshot_start.exposure,
+ self.snapshot_start.hazard,
+ self.snapshot_start.impfset,
+ )
+
+ @lazy_property
+ def E1H0V0(self) -> Impact:
+ """Impact object corresponding to future exposure,
+ starting hazard and starting vulnerability.
+
+ """
+ return self.impact_computation_strategy.compute_impacts(
+ self.snapshot_end.exposure,
+ self.snapshot_start.hazard,
+ self.snapshot_start.impfset,
+ )
+
+ @lazy_property
+ def E0H1V0(self) -> Impact:
+ """Impact object corresponding to starting exposure,
+ future hazard and starting vulnerability.
+
+ """
+ return self.impact_computation_strategy.compute_impacts(
+ self.snapshot_start.exposure,
+ self.snapshot_end.hazard,
+ self.snapshot_start.impfset,
+ )
+
+ @lazy_property
+ def E1H1V0(self) -> Impact:
+ """Impact object corresponding to future exposure,
+ future hazard and starting vulnerability.
+
+ """
+ return self.impact_computation_strategy.compute_impacts(
+ self.snapshot_end.exposure,
+ self.snapshot_end.hazard,
+ self.snapshot_start.impfset,
+ )
+
+ @lazy_property
+ def E0H0V1(self) -> Impact:
+ """Impact object corresponding to starting exposure,
+ starting hazard and future vulnerability.
+
+ """
+ return self.impact_computation_strategy.compute_impacts(
+ self.snapshot_start.exposure,
+ self.snapshot_start.hazard,
+ self.snapshot_end.impfset,
+ )
+
+ @lazy_property
+ def E1H0V1(self) -> Impact:
+ """Impact object corresponding to future exposure,
+ starting hazard and future vulnerability.
+
+ """
+ return self.impact_computation_strategy.compute_impacts(
+ self.snapshot_end.exposure,
+ self.snapshot_start.hazard,
+ self.snapshot_end.impfset,
+ )
+
+ @lazy_property
+ def E0H1V1(self) -> Impact:
+ """Impact object corresponding to starting exposure,
+ future hazard and future vulnerability.
+
+ """
+ return self.impact_computation_strategy.compute_impacts(
+ self.snapshot_start.exposure,
+ self.snapshot_end.hazard,
+ self.snapshot_end.impfset,
+ )
+
+ @lazy_property
+ def E1H1V1(self) -> Impact:
+ """Impact object corresponding to future exposure,
+ future hazard and future vulnerability.
+
+ """
+ return self.impact_computation_strategy.compute_impacts(
+ self.snapshot_end.exposure,
+ self.snapshot_end.hazard,
+ self.snapshot_end.impfset,
+ )
+
+ ###############################
+
+ #################################################
+ ### Impact Matrices arrays / Risk Cube edges ####
+
+ def _interp_mats(self, start_attr, end_attr) -> list:
+ """Helper to reduce repetition in impact matrix interpolation."""
+ start = getattr(self, start_attr).imp_mat
+ end = getattr(self, end_attr).imp_mat
+ return self.interpolation_strategy.interp_over_exposure_dim(
+ start, end, self.time_points
+ )
+
+ def _imp_mats(self, invariant: str) -> list:
+ """List of `time_points` impact matrices with changing
+ exposure, and invariant hazard and vulnerability.
+
+ """
+ if re.match(r"H[01]V[01]", invariant):
+ return self._interp_mats(f"E0{invariant}", f"E1{invariant}")
+
+ if re.match(r"E[01]H[01]V[01]", invariant):
+ return [getattr(self, invariant).imp_mat] * self.time_points
+
+ raise ValueError(
+ f"Unrecognised invariant format ({invariant}), should be H[01]V[01] | E[01]H[01]V[01]"
+ )
+
+ ###############################
+
+ ###############################
+ ########## Core EAI ###########
+
+ def _per_date_eais_interp(self, invariant: str) -> np.ndarray:
+ """Expected annual impacts for changing exposure, and fixed
+ hazard and vulnerability.
+
+ """
+ return calc_per_date_eais(
+ self._imp_mats(invariant=invariant),
+ (
+ self.snapshot_start.hazard.frequency
+ if "H0" in invariant
+ else self.snapshot_end.hazard.frequency
+ ),
+ )
+
+ ##############################
+ ######### Core AAIs ##########
+
+ # Not required for final AAIs computation (we use final EAIs instead),
+ # but could be useful in the future?
+
+ def _per_date_aais_interp(self, invariant: str) -> np.ndarray:
+ """Average periodic impacts for specified invariant."""
+ return calc_per_date_aais(self._per_date_eais_interp(invariant=invariant))
+
+ #############################
+ ######### Core RPs #########
+
+ def _per_date_return_periods(
+ self, invariant: str, return_periods: list[int]
+ ) -> np.ndarray:
+ return calc_per_date_rps(
+ self._imp_mats(invariant=invariant),
+ (
+ self.snapshot_start.hazard.frequency
+ if "H0" in invariant
+ else self.snapshot_end.hazard.frequency
+ ),
+ self.date_idx.freqstr[0],
+ return_periods,
+ )
+
+ ##################################
+ ##### Interpolation of metrics ###
+
+ # Actual results
+
+ def _calc_eai(self) -> np.ndarray:
+ """Compute the EAIs at each date of the risk period (including changes in exposure, hazard and vulnerability)."""
+ per_date_eai_H0V0, per_date_eai_H1V0, per_date_eai_H0V1, per_date_eai_H1V1 = (
+ self._per_date_eais_interp("H0V0"),
+ self._per_date_eais_interp("H1V0"),
+ self._per_date_eais_interp("H0V1"),
+ self._per_date_eais_interp("H1V1"),
+ )
+ per_date_eai_V0 = self.interpolation_strategy.interp_over_hazard_dim(
+ per_date_eai_H0V0, per_date_eai_H1V0
+ )
+ per_date_eai_V1 = self.interpolation_strategy.interp_over_hazard_dim(
+ per_date_eai_H0V1, per_date_eai_H1V1
+ )
+ per_date_eai = self.interpolation_strategy.interp_over_vulnerability_dim(
+ per_date_eai_V0, per_date_eai_V1
+ )
+ return per_date_eai
+
+ ### Fully interpolated metrics ###
+
+ @lazy_property
+ def per_date_eai(self) -> np.ndarray:
+ """Expected annual impacts per date with changing
+ exposure, changing hazard and changing vulnerability.
+
+ """
+ return self._calc_eai()
+
+ @lazy_property
+ def per_date_aai(self) -> np.ndarray:
+ """Average annual impacts per date with changing
+ exposure, changing hazard and changing vulnerability.
+
+ """
+ return calc_per_date_aais(self.per_date_eai)
+
+ ####################################
+ ######## Tidying results ###########
+
+ def calc_eai_gdf(self) -> pd.DataFrame:
+ """Convenience function returning a DataFrame from `per_date_eai`.
+
+ This dataframe can easily be merged with one of the snapshot exposure geodataframe.
+
+ Notes
+ -----
+
+ The DataFrame from the starting snapshot is used as a basis
+ (notably for `value` and `group_id`).
+
+ """
+ metric_df = pd.DataFrame(self.per_date_eai, index=self.date_idx)
+ metric_df = metric_df.reset_index().melt(
+ id_vars=DEFAULT_PERIOD_INDEX_NAME,
+ var_name=COORD_ID_COL_NAME,
+ value_name=RISK_COL_NAME,
+ )
+ if GROUP_ID_COL_NAME in self.snapshot_start.exposure.gdf:
+ eai_gdf = self.snapshot_start.exposure.gdf[[GROUP_ID_COL_NAME]]
+ eai_gdf[COORD_ID_COL_NAME] = eai_gdf.index
+ eai_gdf = eai_gdf.merge(metric_df, on=COORD_ID_COL_NAME)
+ eai_gdf = eai_gdf.rename(columns={GROUP_ID_COL_NAME: GROUP_COL_NAME})
+ else:
+ eai_gdf = metric_df
+ eai_gdf[GROUP_COL_NAME] = pd.NA
+
+ eai_gdf[GROUP_COL_NAME] = pd.Categorical(
+ eai_gdf[GROUP_COL_NAME], categories=self._groups_id
+ )
+ eai_gdf[METRIC_COL_NAME] = EAI_METRIC_NAME
+ eai_gdf[MEASURE_COL_NAME] = (
+ self.measure.name if self.measure else NO_MEASURE_VALUE
+ )
+ eai_gdf[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit
+ return eai_gdf
+
+ def calc_aai_metric(self) -> pd.DataFrame:
+ """Compute a DataFrame of the AAI at each dates of the risk period
+ (including changes in exposure, hazard and vulnerability).
+
+ """
+ aai_df = pd.DataFrame(
+ index=self.date_idx, columns=[RISK_COL_NAME], data=self.per_date_aai
+ )
+ aai_df[GROUP_COL_NAME] = pd.Categorical(
+ [pd.NA] * len(aai_df), categories=self._groups_id
+ )
+ aai_df[METRIC_COL_NAME] = AAI_METRIC_NAME
+ aai_df[MEASURE_COL_NAME] = (
+ self.measure.name if self.measure else NO_MEASURE_VALUE
+ )
+ aai_df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit
+ aai_df.reset_index(inplace=True)
+ return aai_df
+
+ def calc_aai_per_group_metric(self) -> pd.DataFrame | None:
+ """Compute a DataFrame of the AAI distinguised per group id in the exposures,
+ at each dates of the risk period (including changes in exposure, hazard and vulnerability).
+
+ Notes
+ -----
+
+ If group ids changes between starting and ending snapshots of the risk period,
+ the AAIs are linearly interpolated (with a warning for transparency).
+
+ """
+ if len(self._group_id_E0) < 1 or len(self._group_id_E1) < 1:
+ LOGGER.warning(
+ "No group id defined in at least one of the Exposures object. Per group aai will be empty."
+ )
+ return None
+
+ eai_gdf = self.calc_eai_gdf()
+ eai_pres_groups = eai_gdf[
+ [
+ DEFAULT_PERIOD_INDEX_NAME,
+ COORD_ID_COL_NAME,
+ GROUP_COL_NAME,
+ RISK_COL_NAME,
+ ]
+ ].copy()
+ aai_per_group_df = eai_pres_groups.groupby(
+ [DEFAULT_PERIOD_INDEX_NAME, GROUP_COL_NAME], as_index=False, observed=True
+ ).agg({RISK_COL_NAME: "sum"})
+ if not np.array_equal(self._group_id_E0, self._group_id_E1):
+ LOGGER.warning(
+ "Group id are changing between present and future snapshot."
+ " Per group AAI will be linearly interpolated."
+ )
+ eai_fut_groups = eai_gdf.copy()
+ eai_fut_groups[GROUP_COL_NAME] = pd.Categorical(
+ np.tile(self._group_id_E1, len(self.date_idx)),
+ categories=self._groups_id,
+ )
+ aai_fut_groups = eai_fut_groups.groupby(
+ [DEFAULT_PERIOD_INDEX_NAME, GROUP_COL_NAME],
+ as_index=False,
+ observed=False,
+ ).agg({RISK_COL_NAME: "sum"})
+ aai_per_group_df[RISK_COL_NAME] = linear_interp_arrays(
+ aai_per_group_df[RISK_COL_NAME].to_numpy(),
+ aai_fut_groups[RISK_COL_NAME].to_numpy(),
+ )
+
+ aai_per_group_df[METRIC_COL_NAME] = AAI_METRIC_NAME
+ aai_per_group_df[MEASURE_COL_NAME] = (
+ self.measure.name if self.measure else NO_MEASURE_VALUE
+ )
+ aai_per_group_df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit
+ return aai_per_group_df
+
+ def calc_return_periods_metric(self, return_periods: list[int]) -> pd.DataFrame:
+ """Compute a DataFrame of the estimated impacts for a list of return
+ periods, at each dates of the risk period (including changes in exposure,
+ hazard and vulnerability).
+
+ Parameters
+ ----------
+
+ return_periods : list of int
+ The return periods to estimate impacts for.
+
+ """
+
+ # currently mathematicaly wrong, but approximatively correct, to be reworked when concatenating the impact matrices for the interpolation
+ per_date_rp_H0V0, per_date_rp_H1V0, per_date_rp_H0V1, per_date_rp_H1V1 = (
+ self._per_date_return_periods("H0V0", return_periods),
+ self._per_date_return_periods("H1V0", return_periods),
+ self._per_date_return_periods("H0V1", return_periods),
+ self._per_date_return_periods("H1V1", return_periods),
+ )
+ per_date_rp_V0 = self.interpolation_strategy.interp_over_hazard_dim(
+ per_date_rp_H0V0, per_date_rp_H1V0
+ )
+ per_date_rp_V1 = self.interpolation_strategy.interp_over_hazard_dim(
+ per_date_rp_H0V1, per_date_rp_H1V1
+ )
+ per_date_rp = self.interpolation_strategy.interp_over_vulnerability_dim(
+ per_date_rp_V0, per_date_rp_V1
+ )
+ rp_df = pd.DataFrame(
+ index=self.date_idx, columns=return_periods, data=per_date_rp
+ ).melt(value_name=RISK_COL_NAME, var_name="rp", ignore_index=False)
+ rp_df.reset_index(inplace=True)
+ rp_df[GROUP_COL_NAME] = pd.Categorical(
+ [pd.NA] * len(rp_df), categories=self._groups_id
+ )
+ rp_df[METRIC_COL_NAME] = RP_VALUE_PREFIX + "_" + rp_df["rp"].astype(str)
+ rp_df = rp_df.drop("rp", axis=1)
+ rp_df[MEASURE_COL_NAME] = (
+ self.measure.name if self.measure else NO_MEASURE_VALUE
+ )
+ rp_df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit
+ return rp_df
+
+ def calc_risk_contributions_metric(self) -> pd.DataFrame:
+ """Compute a DataFrame of the individual contributions of risk (impact),
+ at each dates of the risk period (including changes in exposure,
+ hazard and vulnerability).
+
+ """
+ aai_changes_hazard_only = self.interpolation_strategy.interp_over_hazard_dim(
+ self._per_date_aais_interp("E0H0V0"), self._per_date_aais_interp("E0H1V0")
+ )
+ aai_changes_vulnerability_only = (
+ self.interpolation_strategy.interp_over_vulnerability_dim(
+ self._per_date_aais_interp("E0H0V0"),
+ self._per_date_aais_interp("E0H0V1"),
+ )
+ )
+ metric_df = pd.DataFrame(
+ {
+ CONTRIBUTION_TOTAL_RISK_NAME: self.per_date_aai,
+ CONTRIBUTION_BASE_RISK_NAME: self.per_date_aai[0],
+ CONTRIBUTION_EXPOSURE_NAME: self._per_date_aais_interp("H0V0")
+ - self.per_date_aai[0],
+ CONTRIBUTION_HAZARD_NAME: aai_changes_hazard_only
+ - self.per_date_aai[0],
+ CONTRIBUTION_VULNERABILITY_NAME: aai_changes_vulnerability_only
+ - self.per_date_aai[0],
+ },
+ index=self.date_idx,
+ )
+ metric_df[CONTRIBUTION_INTERACTION_TERM_NAME] = metric_df[
+ CONTRIBUTION_TOTAL_RISK_NAME
+ ] - (
+ metric_df[CONTRIBUTION_BASE_RISK_NAME]
+ + metric_df[CONTRIBUTION_EXPOSURE_NAME]
+ + metric_df[CONTRIBUTION_HAZARD_NAME]
+ + metric_df[CONTRIBUTION_VULNERABILITY_NAME]
+ )
+ metric_df = metric_df.melt(
+ value_vars=[
+ CONTRIBUTION_BASE_RISK_NAME,
+ CONTRIBUTION_EXPOSURE_NAME,
+ CONTRIBUTION_HAZARD_NAME,
+ CONTRIBUTION_VULNERABILITY_NAME,
+ CONTRIBUTION_INTERACTION_TERM_NAME,
+ ],
+ var_name=METRIC_COL_NAME,
+ value_name=RISK_COL_NAME,
+ ignore_index=False,
+ )
+ metric_df.reset_index(inplace=True)
+ metric_df[GROUP_COL_NAME] = pd.Categorical(
+ [pd.NA] * len(metric_df), categories=self._groups_id
+ )
+ metric_df[MEASURE_COL_NAME] = (
+ self.measure.name if self.measure else NO_MEASURE_VALUE
+ )
+ metric_df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit
+ return metric_df
+
+
+####################################
+### Metrics from impact matrices ###
+
+
+def calc_per_date_eais(imp_mats: list[csr_matrix], frequency: np.ndarray) -> np.ndarray:
+ """Calculate expected average impact (EAI) values from a list of impact matrices
+ corresponding to impacts at different dates (with possible changes along
+ exposure, hazard and vulnerability).
+
+ Parameters
+ ----------
+ imp_mats : list of np.ndarray
+ List of impact matrices.
+ frequency : np.ndarray
+ Hazard frequency values.
+
+ Returns
+ -------
+ np.ndarray
+ 2D array of EAI (1D) for each dates.
+
+ """
+ return np.array(
+ [ImpactCalc.eai_exp_from_mat(imp_mat, frequency) for imp_mat in imp_mats]
+ )
+
+
+def calc_per_date_aais(per_date_eai_exp: np.ndarray) -> np.ndarray:
+ """Calculate per_date aggregate annual impact (AAI) values
+ resulting from a list arrays corresponding to EAI at different
+ dates (with possible changes along exposure, hazard and vulnerability).
+
+ Parameters
+ ----------
+ per_date_eai_exp: np.ndarray
+ EAIs arrays.
+
+ Returns
+ -------
+ np.ndarray
+ 1D array of AAI (0D) for each dates.
+ """
+ return np.array(
+ [ImpactCalc.aai_agg_from_eai_exp(eai_exp) for eai_exp in per_date_eai_exp]
+ )
+
+
+def calc_per_date_rps(
+ imp_mats: list[csr_matrix],
+ frequency: np.ndarray,
+ frequency_unit: str,
+ return_periods: list[int],
+) -> np.ndarray:
+ """Calculate per date return period impact values from a
+ list of impact matrices corresponding to impacts at different
+ dates (with possible changes along exposure, hazard and vulnerability).
+
+ Parameters
+ ----------
+ imp_mats: list of scipy.crs_matrix
+ List of impact matrices.
+ frequency: np.ndarray
+ Frequency values.
+ return_periods : list of int
+ Return periods to calculate impact values for.
+
+ Returns
+ -------
+ np.ndarray
+ 2D array of impacts per return periods (1D) for each dates.
+
+ """
+ return np.array(
+ [
+ calc_freq_curve(imp_mat, frequency, frequency_unit, return_periods).impact
+ for imp_mat in imp_mats
+ ]
+ )
+
+
+def calc_freq_curve(
+ imp_mat_intrpl, frequency, frequency_unit, return_per=None
+) -> ImpactFreqCurve:
+ """Calculate the estimated impacts for given return periods.
+
+ Parameters
+ ----------
+
+ imp_mat_intrpl: scipy.csr_matrix
+ An impact matrix.
+ frequency: np.ndarray
+ The frequency of the hazard.
+ return_per: np.ndarray
+ The return periods to compute impacts for.
+
+ Returns
+ -------
+ np.ndarray
+ The estimated impacts for the different return periods.
+
+ """
+
+ at_event = np.sum(imp_mat_intrpl, axis=1).A1
+
+ # Sort descendingly the impacts per events
+ sort_idxs = np.argsort(at_event)[::-1]
+ # Calculate exceedence frequency
+ exceed_freq = np.cumsum(frequency[sort_idxs])
+ # Set return period and impact exceeding frequency
+ ifc_return_per = 1 / exceed_freq[::-1]
+ ifc_impact = at_event[sort_idxs][::-1]
+
+ if return_per is not None:
+ interp_imp = np.interp(return_per, ifc_return_per, ifc_impact)
+ ifc_return_per = return_per
+ ifc_impact = interp_imp
+
+ return ImpactFreqCurve(
+ return_per=ifc_return_per,
+ impact=ifc_impact,
+ frequency_unit=frequency_unit,
+ label="Exceedance frequency curve",
+ )
diff --git a/climada/trajectories/constants.py b/climada/trajectories/constants.py
new file mode 100644
index 0000000000..969e585531
--- /dev/null
+++ b/climada/trajectories/constants.py
@@ -0,0 +1,55 @@
+"""
+This file is part of CLIMADA.
+
+Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS.
+
+CLIMADA is free software: you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free
+Software Foundation, version 3.
+
+CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with CLIMADA. If not, see `_
+
+ Notes
+ -----
+
+ Changing its value resets the corresponding metric.
+ """
+ return self._risk_metrics_calculators[0].time_resolution
+
+ @time_resolution.setter
+ def time_resolution(self, value, /):
+ if not isinstance(value, str):
+ raise ValueError(
+ "time_resolution should be a valid pandas Period"
+ ' frequency string (e.g., `"Y"`, `"M"`, `"D"`).'
+ )
+ self._reset_metrics()
+ for rmcalc in self._risk_metrics_calculators:
+ rmcalc.time_resolution = value
+
+ @staticmethod
+ def _reset_risk_metrics_calculators(
+ snapshots: list[Snapshot],
+ time_resolution,
+ interpolation_strategy,
+ impact_computation_strategy,
+ ) -> list[CalcRiskMetricsPeriod]:
+ """Initialize or reset the internal risk metrics calculators.
+
+ Notes
+ -----
+
+ This methods sorts the snapshots per date.
+ """
+
+ def pairwise(container: list):
+ """
+ Generate pairs of successive elements from an iterable.
+
+ Parameters
+ ----------
+ iterable : iterable
+ An iterable sequence from which successive pairs of elements are generated.
+
+ Returns
+ -------
+ zip
+ A zip object containing tuples of successive pairs from the input iterable.
+
+ Example
+ -------
+ >>> list(pairwise([1, 2, 3, 4]))
+ [(1, 2), (2, 3), (3, 4)]
+ """
+ first, second = itertools.tee(container)
+ next(second, None)
+ return zip(first, second)
+
+ return [
+ CalcRiskMetricsPeriod(
+ start_snapshot,
+ end_snapshot,
+ time_resolution=time_resolution,
+ interpolation_strategy=interpolation_strategy,
+ impact_computation_strategy=impact_computation_strategy,
+ )
+ for start_snapshot, end_snapshot in pairwise(
+ sorted(snapshots, key=lambda snap: snap.date)
+ )
+ ]
+
+ def _generic_metrics(
+ self,
+ /,
+ metric_name: str | None = None,
+ metric_meth: str | None = None,
+ **kwargs,
+ ) -> pd.DataFrame:
+ """Generic method to compute metrics based on the provided metric name and method.
+
+ This method calls the appropriate method from the calculator to return
+ the results for the given metric, in a tidy formatted dataframe.
+
+ It first checks whether the requested metric is a valid one.
+ Then looks for a possible cached value and otherwised asks the
+ calculators (`self._risk_metric_calculators`) to run the computations.
+ The results are then regrouped in a nice and tidy DataFrame.
+ If a `risk_disc_rates` was set, values are converted to net present values.
+ Results are then cached within `self.__metrics` and returned.
+
+ Parameters
+ ----------
+ metric_name : str, optional
+ The name of the metric to return results for.
+ metric_meth : str, optional
+ The name of the specific method of the calculator to call.
+
+ Returns
+ -------
+ pd.DataFrame
+ A tidy formatted dataframe of the risk metric computed for the
+ different snapshots.
+
+ Raises
+ ------
+ NotImplementedError
+ If the requested metric is not part of `POSSIBLE_METRICS`.
+ ValueError
+ If either of the arguments are not provided.
+
+ """
+
+ if metric_name is None or metric_meth is None:
+ raise ValueError("Both metric_name and metric_meth must be provided.")
+
+ if metric_name not in self.POSSIBLE_METRICS:
+ raise NotImplementedError(
+ f"{metric_name} not implemented ({self.POSSIBLE_METRICS})."
+ )
+
+ attr_name = f"_{metric_name}_metrics"
+
+ if getattr(self, attr_name) is not None:
+ LOGGER.debug("Returning cached %s, ", attr_name)
+ return getattr(self, attr_name)
+
+ LOGGER.debug("Computing %s", attr_name)
+ with log_level(level="WARNING", name_prefix="climada"):
+ tmp = [
+ getattr(calc_period, metric_meth)(**kwargs)
+ for calc_period in self._risk_metrics_calculators
+ ]
+
+ try:
+ tmp = pd.concat(tmp)
+ except ValueError as exc:
+ if str(exc) == "All objects passed were None":
+ return pd.DataFrame()
+ raise exc
+
+ if len(tmp) == 0:
+ return pd.DataFrame()
+
+ tmp = self._metric_post_treatment(tmp, metric_name)
+
+ if CONFIG.trajectory_caching.bool():
+ LOGGER.debug("All computing done, caching value.")
+ setattr(self, attr_name, tmp)
+ return getattr(self, attr_name)
+
+ return tmp
+
+ def _metric_post_treatment(
+ self, metric_df: pd.DataFrame, metric_name: str
+ ) -> pd.DataFrame:
+ # Notably for per_group_aai being None:
+ metric_df = self._avoid_duplicates(metric_df)
+ metric_df = self._handle_group_categories(metric_df)
+ if metric_name == CONTRIBUTIONS_METRIC_NAME and len(self._snapshots) > 2:
+ # If there is more than one Snapshot, we need to update the
+ # contributions from previous periods for continuity
+ # and to set the base risk from the first period
+ # This is not elegant, but we need the concatenated metrics from each period,
+ # so we can't do it in the calculators, and we need
+ # to do it before caching in the private attribute
+ metric_df = self._risk_contributions_post_treatment(metric_df)
+
+ if self._risk_disc_rates:
+ LOGGER.debug("Found risk discount rate. Computing NPV.")
+ metric_df = self.npv_transform(metric_df, self._risk_disc_rates)
+
+ metric_df = reorder_dataframe_columns(metric_df, DEFAULT_DF_COLUMN_PRIORITY)
+ return metric_df
+
+ def _avoid_duplicates(self, metric_df: pd.DataFrame) -> pd.DataFrame:
+ metric_df = metric_df.set_index(INDEXING_COLUMNS)
+ if COORD_ID_COL_NAME in metric_df.columns:
+ metric_df = metric_df.set_index([COORD_ID_COL_NAME], append=True)
+
+ # When more than 2 snapshots, there are duplicated rows, we need to remove them.
+ metric_df = metric_df[~metric_df.index.duplicated(keep="first")]
+ metric_df = metric_df.reset_index()
+ return metric_df
+
+ def _handle_group_categories(self, metric_df: pd.DataFrame) -> pd.DataFrame:
+ if self._all_groups_name not in metric_df[GROUP_COL_NAME].cat.categories:
+ metric_df[GROUP_COL_NAME] = metric_df[GROUP_COL_NAME].cat.add_categories(
+ [self._all_groups_name]
+ )
+ metric_df[GROUP_COL_NAME] = metric_df[GROUP_COL_NAME].fillna(
+ self._all_groups_name
+ )
+
+ return metric_df
+
+ def _compute_period_metrics(
+ self, metric_name: str, metric_meth: str, **kwargs
+ ) -> pd.DataFrame:
+ """Helper method to compute total metrics per period
+ (i.e. whole ranges between pairs of consecutive snapshots).
+
+ """
+ metric_df = self._generic_metrics(
+ metric_name=metric_name, metric_meth=metric_meth, **kwargs
+ )
+ return self._date_to_period_agg(metric_df, grouper=self._grouper)
+
+ def eai_metrics(self, **kwargs) -> pd.DataFrame:
+ """Return the estimated annual impacts at each exposure point for each date.
+
+ This method computes and return a `DataFrame` with eai metric
+ (for each exposure point) for each date.
+
+ Notes
+ -----
+
+ This computation may become quite expensive for big areas with high resolution.
+
+ """
+ df = self._compute_metrics(
+ metric_name=EAI_METRIC_NAME, metric_meth="calc_eai_gdf", **kwargs
+ )
+ return df
+
+ def aai_metrics(self, **kwargs) -> pd.DataFrame:
+ """Return the average annual impacts for each date.
+
+ This method computes and return a `DataFrame` with aai metric for each date.
+
+ """
+
+ return self._compute_metrics(
+ metric_name=AAI_METRIC_NAME, metric_meth="calc_aai_metric", **kwargs
+ )
+
+ def return_periods_metrics(self, **kwargs) -> pd.DataFrame:
+ """Return the estimated impacts for different return periods.
+
+ Return periods to estimate impacts for are defined by `self.return_periods`.
+
+ """
+
+ return self._compute_metrics(
+ metric_name=RETURN_PERIOD_METRIC_NAME,
+ metric_meth="calc_return_periods_metric",
+ return_periods=self.return_periods,
+ **kwargs,
+ )
+
+ def aai_per_group_metrics(self, **kwargs) -> pd.DataFrame:
+ """Return the average annual impacts for each exposure group ID.
+
+ This method computes and return a `DataFrame` with aai metric for each
+ of the exposure group defined by a group id, for each date.
+
+ """
+
+ return self._compute_metrics(
+ metric_name=AAI_PER_GROUP_METRIC_NAME,
+ metric_meth="calc_aai_per_group_metric",
+ **kwargs,
+ )
+
+ def risk_contributions_metrics(self, **kwargs) -> pd.DataFrame:
+ """Return the "contributions" of change in future risk (Exposure and Hazard)
+
+ This method returns the contributions of the change in risk at each date:
+
+ - The 'base risk', i.e., the risk without change in hazard or exposure,
+ compared to trajectory's earliest date.
+ - The 'exposure contribution', i.e., the additional risks due to change
+ in exposure (only)
+ - The 'hazard contribution', i.e., the additional risks due to change
+ in hazard (only)
+ - The 'vulnerability contribution', i.e., the additional risks due to
+ change in vulnerability (only)
+ - The 'interaction contribution', i.e., the additional risks due to the
+ interaction term
+
+
+ """
+
+ return self._compute_metrics(
+ metric_name=CONTRIBUTIONS_METRIC_NAME,
+ metric_meth="calc_risk_contributions_metric",
+ **kwargs,
+ )
+
+ def _risk_contributions_post_treatment(self, df: pd.DataFrame) -> pd.DataFrame:
+ """Post treat the risk contributions metrics.
+
+ When more than two snapshots are provided, the total risk of the previous pair
+ (period) becomes the base risk for the subsequent one.
+ This method straightens this by resetting the base risk to the risk from
+ the first snapshot of the list and correcting the different contributions
+ by cumulating the contributions from the previous periods.
+
+ """
+
+ df.set_index(INDEXING_COLUMNS, inplace=True)
+ start_dates = [snap.date for snap in self._snapshots[:-1]]
+ end_dates = [snap.date for snap in self._snapshots[1:]]
+ periods_dates = list(zip(start_dates, end_dates))
+ df.loc[pd.IndexSlice[:, :, :, CONTRIBUTION_BASE_RISK_NAME]] = df.loc[
+ pd.IndexSlice[
+ pd.to_datetime(self.start_date).to_period(self.time_resolution),
+ :,
+ :,
+ CONTRIBUTION_BASE_RISK_NAME,
+ ] # type: ignore
+ ].values
+ for p2 in periods_dates[1:]:
+ for metric in [
+ CONTRIBUTION_EXPOSURE_NAME,
+ CONTRIBUTION_HAZARD_NAME,
+ CONTRIBUTION_VULNERABILITY_NAME,
+ CONTRIBUTION_INTERACTION_TERM_NAME,
+ ]:
+ mask_last_previous = (
+ df.index.get_level_values(0)
+ == pd.to_datetime(p2[0]).to_period(self.time_resolution)
+ ) & (df.index.get_level_values(3) == metric)
+ mask_to_update = (
+ (
+ df.index.get_level_values(0)
+ > pd.to_datetime(p2[0]).to_period(self.time_resolution)
+ )
+ & (
+ df.index.get_level_values(0)
+ <= pd.to_datetime(p2[1]).to_period(self.time_resolution)
+ )
+ & (df.index.get_level_values(3) == metric)
+ )
+
+ df.loc[mask_to_update, RISK_COL_NAME] += df.loc[
+ mask_last_previous, RISK_COL_NAME
+ ].iloc[0]
+
+ return df.reset_index()
+
+ def per_date_risk_metrics(
+ self,
+ metrics: Iterable[str] | None = None,
+ ) -> pd.DataFrame:
+ """Returns a DataFrame of risk metrics for each dates
+
+ This methods collects (and if needed computes) the `metrics`
+ (Defaulting to AAI_METRIC_NAME, RETURN_PERIOD_METRIC_NAME and AAI_PER_GROUP_METRIC_NAME).
+
+ Parameters
+ ----------
+ metrics : list[str], optional
+ The list of metrics to return (defaults to
+ [AAI_METRIC_NAME,RETURN_PERIOD_METRIC_NAME,AAI_PER_GROUP_METRIC_NAME])
+ return_periods : list[int], optional
+ The return periods to consider for the return periods metric
+ (default to the value of the `.default_rp` attribute)
+
+ Returns
+ -------
+ pd.DataFrame | pd.Series
+ A tidy DataFrame with metrics value for all possible dates.
+
+ """
+
+ metrics = self._DEFAULT_ALL_METRICS if metrics is None else metrics
+ return pd.concat(
+ [getattr(self, f"{metric}_metrics")() for metric in metrics],
+ ignore_index=True,
+ )
+
+ @staticmethod
+ def _get_risk_periods(
+ risk_periods: list[CalcRiskMetricsPeriod],
+ start_date: datetime.date,
+ end_date: datetime.date,
+ strict: bool = True,
+ ):
+ """Returns risk periods from the given list that are within `start_date` and `end_date`.
+
+ Either using a strict inclusion (period is stricly within start and end) or extending
+ to overlap inclusion, i.e., start or end is within the period.
+
+ Parameters
+ ----------
+ risk_periods : list[CalcRiskPeriod]
+ The list of risk periods to look through
+ start_date : datetime.date
+ end_date : datetime.date
+ strict: bool, default True
+ If true, only returns periods stricly within start and end dates. Else,
+ additionaly returns periods that have an overlap within start and end.
+ """
+ if strict:
+ return [
+ period
+ for period in risk_periods
+ if (
+ start_date <= period.snapshot_start.date
+ and end_date >= period.snapshot_end.date
+ )
+ ]
+
+ return [
+ period
+ for period in risk_periods
+ if not (
+ start_date >= period.snapshot_end.date
+ or end_date <= period.snapshot_start.date
+ )
+ ]
+
+ @staticmethod
+ def _identify_continuous_periods(group, time_unit):
+ """Calculate the difference between consecutive dates."""
+
+ if time_unit == "year":
+ group["date_diff"] = group[DATE_COL_NAME].dt.year.diff()
+ if time_unit == "month":
+ group["date_diff"] = group[DATE_COL_NAME].dt.month.diff()
+ if time_unit == "day":
+ group["date_diff"] = group[DATE_COL_NAME].dt.day.diff()
+ if time_unit == "hour":
+ group["date_diff"] = group[DATE_COL_NAME].dt.hour.diff()
+ # Identify breaks in continuity
+ group["period_id"] = (group["date_diff"] != 1).cumsum()
+ return group
+
+ @classmethod
+ def _date_to_period_agg(
+ cls,
+ metric_df: pd.DataFrame,
+ grouper: list[str],
+ time_unit: str = "year",
+ colname: str | list[str] = RISK_COL_NAME,
+ ) -> pd.DataFrame:
+ """Group per date risk metric to periods."""
+
+ df_sorted = metric_df.sort_values(by=grouper + [DATE_COL_NAME])
+
+ if GROUP_COL_NAME in metric_df.columns and GROUP_COL_NAME not in grouper:
+ grouper = [GROUP_COL_NAME] + grouper
+
+ # Apply the function to identify continuous periods
+ df_periods = df_sorted.groupby(
+ grouper, dropna=False, group_keys=False, observed=True
+ )[df_sorted.columns].apply(cls._identify_continuous_periods, time_unit)
+
+ if isinstance(colname, str):
+ colname = [colname]
+ agg_dict = {
+ "start_date": pd.NamedAgg(column=DATE_COL_NAME, aggfunc="min"),
+ "end_date": pd.NamedAgg(column=DATE_COL_NAME, aggfunc="max"),
+ }
+ df_periods_dates = (
+ df_periods.groupby(grouper + ["period_id"], dropna=False, observed=True)
+ .agg(func=None, **agg_dict) # type: ignore
+ .reset_index()
+ )
+
+ df_periods_dates[PERIOD_COL_NAME] = (
+ df_periods_dates["start_date"].astype(str)
+ + " to "
+ + df_periods_dates["end_date"].astype(str)
+ )
+ df_periods = (
+ df_periods.groupby(grouper + ["period_id"], dropna=False, observed=True)[
+ colname
+ ]
+ .apply("mean")
+ .reset_index()
+ )
+ df_periods = pd.merge(
+ df_periods_dates[grouper + [PERIOD_COL_NAME, "period_id"]],
+ df_periods,
+ on=grouper + ["period_id"],
+ )
+ df_periods = df_periods.drop(["period_id"], axis=1)
+ return df_periods[
+ [PERIOD_COL_NAME]
+ + [col for col in df_periods.columns if col != PERIOD_COL_NAME]
+ ]
+
+ def per_period_risk_metrics(
+ self,
+ metrics: Iterable[str] = (
+ AAI_METRIC_NAME,
+ RETURN_PERIOD_METRIC_NAME,
+ AAI_PER_GROUP_METRIC_NAME,
+ ),
+ **kwargs,
+ ) -> pd.DataFrame:
+ """Return a tidy dataframe of the risk metrics with the total
+ for each different period (pair of snapshots).
+
+ """
+
+ metric_df = self.per_date_risk_metrics(metrics=metrics, **kwargs)
+ return self._date_to_period_agg(
+ metric_df, grouper=self._grouper + [UNIT_COL_NAME], **kwargs
+ )
+
+ def _calc_waterfall_plot_data(
+ self,
+ start_date: datetime.date | None = None,
+ end_date: datetime.date | None = None,
+ ):
+ """Compute the required data for the waterfall plot between `start_date` and `end_date`."""
+ start_date = self.start_date if start_date is None else start_date
+ end_date = self.end_date if end_date is None else end_date
+ risk_contributions = self.risk_contributions_metrics()
+ risk_contributions = risk_contributions.loc[
+ (risk_contributions[DATE_COL_NAME] >= str(start_date))
+ & (risk_contributions[DATE_COL_NAME] <= str(end_date))
+ ]
+ risk_contributions = risk_contributions.set_index(
+ [DATE_COL_NAME, METRIC_COL_NAME]
+ )[RISK_COL_NAME].unstack()
+ return risk_contributions
+
+ # Acceptable given it is a plotting function
+ # pylint: disable=too-many-locals
+ def plot_time_waterfall(
+ self,
+ ax=None,
+ figsize=(12, 6),
+ ):
+ """Plot a waterfall chart of risk contributions over a specified date range.
+
+ This method generates a stacked bar chart to visualize the
+ risk contributions.
+
+ Parameters
+ ----------
+ ax : matplotlib.axes.Axes, optional
+ The matplotlib axes on which to plot. If None, a new figure and axes are created.
+
+ Returns
+ -------
+ matplotlib.axes.Axes
+ The matplotlib axes with the plotted waterfall chart.
+
+ """
+ if ax is None:
+ fig, ax = plt.subplots(figsize=figsize)
+ else:
+ fig = ax.figure # get parent figure from the axis
+
+ risk_contribution = self._calc_waterfall_plot_data(
+ start_date=self.start_date, end_date=self.end_date
+ )
+ risk_contribution = risk_contribution[
+ [
+ CONTRIBUTION_EXPOSURE_NAME,
+ CONTRIBUTION_HAZARD_NAME,
+ CONTRIBUTION_VULNERABILITY_NAME,
+ CONTRIBUTION_INTERACTION_TERM_NAME,
+ ]
+ ]
+ positive_contrib = (
+ risk_contribution[risk_contribution > 0].dropna(how="all", axis=1).fillna(0)
+ ) # + base_risk.iloc[0]
+ negative_contrib = (
+ risk_contribution[risk_contribution < 0].dropna(how="all", axis=1).fillna(0)
+ ) # + base_risk.iloc[0]
+
+ color_index = {
+ CONTRIBUTION_EXPOSURE_NAME: 1,
+ CONTRIBUTION_HAZARD_NAME: 2,
+ CONTRIBUTION_VULNERABILITY_NAME: 3,
+ CONTRIBUTION_INTERACTION_TERM_NAME: 4,
+ }
+ csequence = mpl.color_sequences["tab10"]
+ ax.stackplot(
+ positive_contrib.index.to_timestamp(), # type: ignore
+ [positive_contrib[col] for col in positive_contrib.columns],
+ labels=positive_contrib.columns,
+ colors=[csequence[color_index[col]] for col in positive_contrib.columns],
+ )
+ if not negative_contrib.empty:
+ ax.stackplot(
+ negative_contrib.index.to_timestamp(), # type: ignore
+ [negative_contrib[col] for col in negative_contrib.columns],
+ labels=negative_contrib.columns,
+ colors=[
+ csequence[color_index[col]] for col in negative_contrib.columns
+ ],
+ )
+ handles, labels = plt.gca().get_legend_handles_labels()
+ newLabels, newHandles = [], []
+ for handle, label in zip(handles, labels):
+ if label not in newLabels:
+ newLabels.append(label)
+ newHandles.append(handle)
+
+ ax.legend(newHandles, newLabels)
+ value_label = "Deviation from base risk"
+ title_label = f"Contributions to change in risk between {self.start_date} and {self.end_date} (Average)"
+
+ locator = mdates.AutoDateLocator()
+ formatter = mdates.ConciseDateFormatter(locator)
+
+ ax.axhline(y=0, linestyle="--", color="black", linewidth=2)
+ ax.xaxis.set_major_locator(locator)
+ ax.xaxis.set_major_formatter(formatter)
+ ax.yaxis.set_major_formatter(mticker.EngFormatter())
+ ax.set_title(title_label)
+ ax.set_ylabel(value_label)
+ ax.set_ylim(top=1.1 * ax.get_ylim()[1])
+ return fig, ax
+
+ def plot_waterfall(
+ self,
+ ax=None,
+ ):
+ """Plot a waterfall chart of risk contributions between two dates.
+
+ This method generates a waterfall plot to visualize the changes in risk contributions.
+
+ Parameters
+ ----------
+ ax : matplotlib.axes.Axes, optional
+ The matplotlib axes on which to plot. If None, a new figure and axes are created.
+
+ Returns
+ -------
+ matplotlib.axes.Axes
+ The matplotlib axes with the plotted waterfall chart.
+
+ """
+ start_date_p = pd.to_datetime(self.start_date).to_period(self.time_resolution)
+ end_date_p = pd.to_datetime(self.end_date).to_period(self.time_resolution)
+ risk_contribution = self._calc_waterfall_plot_data(
+ start_date=self.start_date, end_date=self.end_date
+ )
+ if ax is None:
+ _, ax = plt.subplots(figsize=(8, 5))
+
+ risk_contribution = risk_contribution.loc[
+ (risk_contribution.index == str(self.end_date))
+ ].squeeze()
+ risk_contribution = cast(pd.Series, risk_contribution)
+
+ labels = [
+ f"Risk {start_date_p}",
+ f"Exposure contribution {end_date_p}",
+ f"Hazard contribution {end_date_p}",
+ f"Vulnerability contribution {end_date_p}",
+ f"Interaction contribution {end_date_p}",
+ f"Total Risk {end_date_p}",
+ ]
+ values = [
+ risk_contribution[CONTRIBUTION_BASE_RISK_NAME],
+ risk_contribution[CONTRIBUTION_EXPOSURE_NAME],
+ risk_contribution[CONTRIBUTION_HAZARD_NAME],
+ risk_contribution[CONTRIBUTION_VULNERABILITY_NAME],
+ risk_contribution[CONTRIBUTION_INTERACTION_TERM_NAME],
+ risk_contribution.sum(),
+ ]
+ bottoms = [
+ 0.0,
+ risk_contribution[CONTRIBUTION_BASE_RISK_NAME],
+ risk_contribution[CONTRIBUTION_BASE_RISK_NAME]
+ + risk_contribution[CONTRIBUTION_EXPOSURE_NAME],
+ risk_contribution[CONTRIBUTION_BASE_RISK_NAME]
+ + risk_contribution[CONTRIBUTION_EXPOSURE_NAME]
+ + risk_contribution[CONTRIBUTION_HAZARD_NAME],
+ risk_contribution[CONTRIBUTION_BASE_RISK_NAME]
+ + risk_contribution[CONTRIBUTION_EXPOSURE_NAME]
+ + risk_contribution[CONTRIBUTION_HAZARD_NAME]
+ + risk_contribution[CONTRIBUTION_VULNERABILITY_NAME],
+ 0.0,
+ ]
+
+ ax.bar(
+ labels,
+ values,
+ bottom=bottoms,
+ edgecolor="black",
+ color=[
+ "tab:cyan",
+ "tab:orange",
+ "tab:green",
+ "tab:red",
+ "tab:purple",
+ "tab:blue",
+ ],
+ )
+ for i, val in enumerate(values):
+ ax.text(
+ labels[i], # type: ignore
+ val + bottoms[i],
+ f"{val:.0e}",
+ ha="center",
+ va="bottom",
+ color="black",
+ )
+
+ # Construct y-axis label and title based on parameters
+ value_label = "USD"
+ title_label = f"Evolution of the contributions of risk between {start_date_p} and {end_date_p} (Average impact)"
+ ax.yaxis.set_major_formatter(mticker.EngFormatter())
+ ax.set_title(title_label)
+ ax.set_ylabel(value_label)
+ ax.set_ylim(0.0, 1.1 * ax.get_ylim()[1])
+ ax.tick_params(
+ axis="x",
+ labelrotation=90,
+ )
+
+ return ax
diff --git a/climada/trajectories/interpolation.py b/climada/trajectories/interpolation.py
new file mode 100644
index 0000000000..c07c53883c
--- /dev/null
+++ b/climada/trajectories/interpolation.py
@@ -0,0 +1,435 @@
+"""
+This file is part of CLIMADA.
+
+Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS.
+
+CLIMADA is free software: you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free
+Software Foundation, version 3.
+
+CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with CLIMADA. If not, see _metrics` and returned.
+
+ Parameters
+ ----------
+ metric_name : str, optional
+ The name of the metric to return results for.
+ metric_meth : str, optional
+ The name of the specific method of the calculator to call.
+
+ Returns
+ -------
+ pd.DataFrame
+ A tidy formatted dataframe of the risk metric computed for the
+ different snapshots.
+
+ Raises
+ ------
+ NotImplementedError
+ If the requested metric is not part of `POSSIBLE_METRICS`.
+ ValueError
+ If either of the arguments are not provided.
+
+ """
+ if metric_name is None or metric_meth is None:
+ raise ValueError("Both metric_name and metric_meth must be provided.")
+
+ if metric_name not in self.POSSIBLE_METRICS:
+ raise NotImplementedError(
+ f"{metric_name} not implemented ({self.POSSIBLE_METRICS})."
+ )
+
+ # Construct the attribute name for storing the metric results
+ attr_name = f"_{metric_name}_metrics"
+
+ if getattr(self, attr_name) is not None:
+ LOGGER.debug("Returning cached %s", attr_name)
+ return getattr(self, attr_name)
+
+ with log_level(level="WARNING", name_prefix="climada"):
+ tmp = getattr(self._risk_metrics_calculators, metric_meth)(**kwargs)
+ if tmp is None:
+ return tmp
+
+ tmp = tmp.set_index(
+ [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME]
+ )
+ if COORD_ID_COL_NAME in tmp.columns:
+ tmp = tmp.set_index([COORD_ID_COL_NAME], append=True)
+
+ # When more than 2 snapshots, there might be duplicated rows, we need to remove them.
+ # Should not be the case in static trajectory, but in any case we really don't want
+ # duplicated rows, which would mess up some dataframe manipulation down the road.
+ tmp = tmp[~tmp.index.duplicated(keep="first")]
+ tmp = tmp.reset_index()
+ if self._all_groups_name not in tmp[GROUP_COL_NAME].cat.categories:
+ tmp[GROUP_COL_NAME] = tmp[GROUP_COL_NAME].cat.add_categories(
+ [self._all_groups_name]
+ )
+ tmp[GROUP_COL_NAME] = tmp[GROUP_COL_NAME].fillna(self._all_groups_name)
+
+ if self._risk_disc_rates:
+ tmp = self.npv_transform(tmp, self._risk_disc_rates)
+
+ tmp = reorder_dataframe_columns(tmp, DEFAULT_DF_COLUMN_PRIORITY)
+
+ setattr(self, attr_name, tmp)
+ return getattr(self, attr_name)
+
+ def eai_metrics(self, **kwargs) -> pd.DataFrame:
+ """Return the estimated annual impacts at each exposure point for each date.
+
+ This method computes and return a `DataFrame` with eai metric
+ (for each exposure point) for each date.
+
+ Notes
+ -----
+
+ This computation may become quite expensive for big areas with high resolution.
+
+ """
+ metric_df = self._compute_metrics(
+ metric_name=EAI_METRIC_NAME, metric_meth="calc_eai_gdf", **kwargs
+ )
+ return metric_df
+
+ def aai_metrics(self, **kwargs) -> pd.DataFrame:
+ """Return the average annual impacts for each date.
+
+ This method computes and return a `DataFrame` with aai metric for each date.
+
+ """
+
+ return self._compute_metrics(
+ metric_name=AAI_METRIC_NAME, metric_meth="calc_aai_metric", **kwargs
+ )
+
+ def return_periods_metrics(self, **kwargs) -> pd.DataFrame:
+ """Return the estimated impacts for different return periods.
+
+ Return periods to estimate impacts for are defined by `self.return_periods`.
+
+ """
+ return self._compute_metrics(
+ metric_name=RETURN_PERIOD_METRIC_NAME,
+ metric_meth="calc_return_periods_metric",
+ return_periods=self.return_periods,
+ **kwargs,
+ )
+
+ def aai_per_group_metrics(self, **kwargs) -> pd.DataFrame:
+ """Return the average annual impacts for each exposure group ID.
+
+ This method computes and return a `DataFrame` with aai metric for each
+ of the exposure group defined by a group id, for each date.
+
+ """
+
+ return self._compute_metrics(
+ metric_name=AAI_PER_GROUP_METRIC_NAME,
+ metric_meth="calc_aai_per_group_metric",
+ **kwargs,
+ )
+
+ def per_date_risk_metrics(
+ self,
+ metrics: list[str] | None = None,
+ ) -> pd.DataFrame | pd.Series:
+ """Returns a DataFrame of risk metrics for each dates.
+
+ This methods collects (and if needed computes) the `metrics`
+ (Defaulting to AAI_METRIC_NAME, RETURN_PERIOD_METRIC_NAME and AAI_PER_GROUP_METRIC_NAME).
+
+ Parameters
+ ----------
+ metrics : list[str], optional
+ The list of metrics to return (defaults to
+ [AAI_METRIC_NAME,RETURN_PERIOD_METRIC_NAME,AAI_PER_GROUP_METRIC_NAME])
+
+ Returns
+ -------
+ pd.DataFrame | pd.Series
+ A tidy DataFrame with metric values for all possible dates.
+
+ """
+
+ metrics = (
+ [AAI_METRIC_NAME, RETURN_PERIOD_METRIC_NAME, AAI_PER_GROUP_METRIC_NAME]
+ if metrics is None
+ else metrics
+ )
+ return pd.concat(
+ [getattr(self, f"{metric}_metrics")() for metric in metrics],
+ ignore_index=True,
+ )
diff --git a/climada/trajectories/test/test_calc_risk_metrics.py b/climada/trajectories/test/test_calc_risk_metrics.py
new file mode 100644
index 0000000000..d024e2c1c5
--- /dev/null
+++ b/climada/trajectories/test/test_calc_risk_metrics.py
@@ -0,0 +1,346 @@
+"""
+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 "
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "snap1.exposure.plot_raster()\n",
+ "snap1.hazard.plot_intensity(0)\n",
+ "snap1.impfset.plot()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d2e6daae-6345-41ac-a560-71040942db39",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "source": [
+ "## Evaluating risk from multiple snapshots using trajectories"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8e8458c3-a3f9-4210-9de0-15293167f2f9",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "source": [
+ "Trajectories facilitate the evaluation of risk of multiple snapshot. The module implements two kinds of trajectories:\n",
+ "\n",
+ "- `StaticRiskTrajectory`: which estimate the risk at each snaphot only, and regroups the results nicely.\n",
+ "- `InterpolatedRiskTrajectory`: which also includes the evolution of risk in between the snapshots using interpolation.\n",
+ "\n",
+ "So first, let us define `Snapshot` for a future point in time. We will increase the value of the exposure following a certain growth rate, and use future tropical\n",
+ "cyclone data for the hazard, we will also change the vulnerability to be slightly lower in the future:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "c516c861-c5c1-475b-82e2-c867c5c08ec9",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2026-02-11 11:52:25,184 - 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"
+ ]
+ }
+ ],
+ "source": [
+ "import copy\n",
+ "\n",
+ "future_year = 2040\n",
+ "exp_future = copy.deepcopy(exp_present)\n",
+ "exp_future.ref_year = future_year\n",
+ "n_years = exp_future.ref_year - exp_present.ref_year + 1\n",
+ "growth_rate = 1.02\n",
+ "growth = growth_rate**n_years\n",
+ "exp_future.gdf[\"value\"] = exp_future.gdf[\"value\"] * growth\n",
+ "\n",
+ "haz_future = client.get_hazard(\n",
+ " \"tropical_cyclone\",\n",
+ " properties={\n",
+ " \"country_name\": \"Haiti\",\n",
+ " \"climate_scenario\": \"rcp60\",\n",
+ " \"ref_year\": str(future_year),\n",
+ " \"nb_synth_tracks\": \"10\",\n",
+ " },\n",
+ ")\n",
+ "\n",
+ "impf_set = ImpactFuncSet(\n",
+ " [\n",
+ " ImpfTropCyclone.from_emanuel_usa(v_half=78.0),\n",
+ " ]\n",
+ ")\n",
+ "exp_future.gdf.rename(columns={\"impf_\": \"impf_TC\"}, inplace=True)\n",
+ "exp_future.gdf[\"impf_TC\"] = 1\n",
+ "snap2 = Snapshot.from_triplet(\n",
+ " exposure=exp_future, hazard=haz_future, impfset=impf_set, date=str(future_year)\n",
+ ")\n",
+ "\n",
+ "# Now we can define a list of two snapshots, present and future:\n",
+ "snapcol = [snap1, snap2]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "27ca72b1-b1fa-4cd2-8f74-a69dc6eb3c9c",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "source": [
+ "Based on such a list of snapshots, we can then evaluate a risk trajectory using a `StaticRiskTrajectory` or a `InterpolatedRiskTrajectory` object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "e782ab8b",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "from climada.trajectories import StaticRiskTrajectory, InterpolatedRiskTrajectory\n",
+ "\n",
+ "static_risk_traj = StaticRiskTrajectory(snapcol)\n",
+ "interpolated_risk_traj = InterpolatedRiskTrajectory(snapcol)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "483767e7-9089-4b5e-a307-514ac302e773",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": [
+ "remove-input"
+ ]
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n"
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "%%html\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2d7e8653-4ef9-40f5-8f8a-ef0e8b3b8a8c",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "source": [
+ "### Tidy format\n",
+ "\n",
+ "We use the \"tidy\" format to output most of the results.\n",
+ "\n",
+ "A **tidy data** format is a standardized way to structure datasets, making them easier to analyze and visualize. It's based on three main principles:\n",
+ "\n",
+ "1. **Each variable forms a column.**\n",
+ "2. **Each observation forms a row.**\n",
+ "3. **Each type of observational unit forms a table.**\n",
+ "\n",
+ "Example:\n",
+ "\n",
+ "| group | date | metric | risk |\n",
+ "| :---: | :---: | :---: | :---: |\n",
+ "| All | 2018-01-01 | aai | $1.840432 \\times 10^{8}$ |\n",
+ "| All | 2040-01-01 | aai | $6.946753 \\times 10^{8}$ |\n",
+ "| All | 2018-01-01 | rp\\_20 | $1.420589 \\times 10^{8}$ |\n",
+ "\n",
+ "In this example, every descriptive quality (variable) of the risk evaluation is placed in its own column:\n",
+ "\n",
+ "* **`group`**: The exposure subgroup for the risk evalution point.\n",
+ "* **`date`**: The date for the risk evalution point.\n",
+ "* **`metric`**: The specific risk measure (e.g., 'aai', 'rp\\_20', 'rp\\_100').\n",
+ "* **`unit`**: The unit of the risk evaluation.\n",
+ "* **`risk`**: The actual value being measured.\n",
+ "\n",
+ "Each row represents a single, complete observation. For example, the very first row is a measurement of the **'aai' metric** for **group 'All'** on **'2018-01-01'**, with the resulting **risk** value of **$1.840432 \\times 10^{8}$ USD**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ca8951cc-4a0a-4f3d-9c21-96dd6a835810",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "source": [
+ "### Static and Interpolated trajectories"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dc76cb91",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "source": [
+ "`StaticRiskTrajectory` will compute and hold risk metrics for all the given snapshots without interpolation:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "14453563",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2026-02-11 11:52:25,317 - climada.trajectories.calc_risk_metrics - WARNING - No group id defined in the Exposures object. Per group aai will be empty.\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " date \n",
+ " group \n",
+ " measure \n",
+ " metric \n",
+ " unit \n",
+ " risk \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " 2018-01-01 \n",
+ " All \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.840432e+08 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " 2040-01-01 \n",
+ " All \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 2.749295e+08 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " 2018-01-01 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_20 \n",
+ " USD \n",
+ " 1.420589e+08 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " 2040-01-01 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_20 \n",
+ " USD \n",
+ " 2.357976e+08 \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " 2018-01-01 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_50 \n",
+ " USD \n",
+ " 3.059112e+09 \n",
+ " \n",
+ " \n",
+ " 5 \n",
+ " 2040-01-01 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_50 \n",
+ " USD \n",
+ " 4.580720e+09 \n",
+ " \n",
+ " \n",
+ " 6 \n",
+ " 2018-01-01 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_100 \n",
+ " USD \n",
+ " 5.719050e+09 \n",
+ " \n",
+ " \n",
+ " 7 \n",
+ " 2040-01-01 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_100 \n",
+ " USD \n",
+ " 8.477125e+09 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " period \n",
+ " group \n",
+ " measure \n",
+ " metric \n",
+ " unit \n",
+ " risk \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " 2018 to 2040 \n",
+ " All \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 2.309016e+08 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " 2018 to 2040 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_100 \n",
+ " USD \n",
+ " 7.148372e+09 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " 2018 to 2040 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_20 \n",
+ " USD \n",
+ " 1.896739e+08 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " 2018 to 2040 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_50 \n",
+ " USD \n",
+ " 3.847129e+09 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " date \n",
+ " group \n",
+ " measure \n",
+ " metric \n",
+ " unit \n",
+ " risk \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " 2018 \n",
+ " All \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.840432e+08 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " 2019 \n",
+ " All \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.885312e+08 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " 2020 \n",
+ " All \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.929908e+08 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " 2021 \n",
+ " All \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.974211e+08 \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " 2022 \n",
+ " All \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 2.018214e+08 \n",
+ " \n",
+ " \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " \n",
+ " \n",
+ " 87 \n",
+ " 2036 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_100 \n",
+ " USD \n",
+ " 8.025179e+09 \n",
+ " \n",
+ " \n",
+ " 88 \n",
+ " 2037 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_100 \n",
+ " USD \n",
+ " 8.140512e+09 \n",
+ " \n",
+ " \n",
+ " 89 \n",
+ " 2038 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_100 \n",
+ " USD \n",
+ " 8.254300e+09 \n",
+ " \n",
+ " \n",
+ " 90 \n",
+ " 2039 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_100 \n",
+ " USD \n",
+ " 8.366514e+09 \n",
+ " \n",
+ " \n",
+ " 91 \n",
+ " 2040 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_100 \n",
+ " USD \n",
+ " 8.477125e+09 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
92 rows × 6 columns
\n",
+ "
"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "interpolated_risk_traj.plot_waterfall()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7896af66-b0aa-4418-b22e-c64fd4d2cfe1",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "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": 10,
+ "id": "6a15775f-af9e-4940-b18d-eb16bd0c8c85",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(,\n",
+ " )"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "interpolated_risk_traj.plot_time_waterfall()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "501e455b-e7c6-4672-9191-d5fefe38d424",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "source": [
+ "### DiscRates"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0dba0218-55fe-423d-a520-61d3cb2a991c",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "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.\n",
+ "\n",
+ "The discount rate is applied by assuming the year of the date of the first Snapshot is the baseline (no discounting).\n",
+ "\n",
+ "Note that when interpolating on a sub-yearly basis, the discount rate remains on a yearly basis: All dates "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "651e31cb-5a55-4a22-a7c3-b5f79b3a20ef",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "from climada.entity import DiscRates\n",
+ "import numpy as np\n",
+ "\n",
+ "year_range = np.arange(exp_present.ref_year, exp_future.ref_year + 1)\n",
+ "annual_discount_stern = np.ones(n_years) * 0.014\n",
+ "discount_stern = DiscRates(year_range, annual_discount_stern)\n",
+ "discounted_risk_traj = InterpolatedRiskTrajectory(\n",
+ " snapcol, risk_disc_rates=discount_stern\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d86bedbb-6c0a-4f7d-a63e-5012510339d3",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "source": [
+ "You can easily notice the difference with the previously defined trajectory without discount rate."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "ee3b0217-fe14-44a9-98f5-e1fc7f45e613",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "ax = interpolated_risk_traj.aai_metrics().plot(\n",
+ " x=\"date\", y=\"risk\", label=\"No discount rate\"\n",
+ ")\n",
+ "discounted_risk_traj.aai_metrics().plot(\n",
+ " x=\"date\", y=\"risk\", label=\"Stern discount rate\", ax=ax\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0152e9fa-55fa-4cf2-b187-59e6228af563",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "source": [
+ "# Advanced usage\n",
+ "\n",
+ "In this section we present some more advanced features and use of this module."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dbf4b23d-d502-4c06-8e0d-eb832af8ebe4",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "source": [
+ "## Exposure sub groups"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "86a58a22-63a5-42a9-9afb-cf8962156e36",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "source": [
+ "It is often useful to look at sub-groups of your exposure (social groups of different social vulnerability, buildings of different type, etc.)\n",
+ "\n",
+ "The `trajectory` module facilitate looking at risk specifically for sub-groups of exposure points. In order to do so, you need to set a column \"group_id\" in the `GeoDataFrame` of your exposure.\n",
+ "\n",
+ "Here we create dummy groups for exposure points above and below the mean exposure value:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "566f0c34-b19b-403a-a905-92c51093c182",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "exp_present.gdf[\"group_id\"] = (\n",
+ " exp_present.gdf[\"value\"] > exp_present.gdf[\"value\"].mean()\n",
+ ") * 1\n",
+ "exp_future.gdf[\"group_id\"] = (\n",
+ " exp_future.gdf[\"value\"] > exp_future.gdf[\"value\"].mean()\n",
+ ") * 1\n",
+ "\n",
+ "snap1 = Snapshot.from_triplet(\n",
+ " exposure=exp_present, hazard=haz_present, impfset=impf_set, date=\"2018\"\n",
+ ")\n",
+ "snap2 = Snapshot.from_triplet(\n",
+ " exposure=exp_future, hazard=haz_future, impfset=impf_set, date=\"2040\"\n",
+ ")\n",
+ "static_risk_traj = StaticRiskTrajectory([snap1, snap2])\n",
+ "interpolated_risk_traj = InterpolatedRiskTrajectory([snap1, snap2])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e0123f8f-ec7f-47ac-9f60-0f59808b9670",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "source": [
+ "You can now access the `aii_per_group` metric, which will give you the average impact (for the frequency unit of you hazard) restricted to the exposure points of the corresponding group."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "id": "344a84d7-275c-426d-80d1-5375696f5cc3",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " date \n",
+ " group \n",
+ " measure \n",
+ " metric \n",
+ " unit \n",
+ " risk \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " 2018-01-01 \n",
+ " 0 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 6.094866e+06 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " 2018-01-01 \n",
+ " 1 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.508360e+08 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " 2040-01-01 \n",
+ " 0 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.063804e+07 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " 2040-01-01 \n",
+ " 1 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 2.642915e+08 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " date \n",
+ " group \n",
+ " measure \n",
+ " metric \n",
+ " unit \n",
+ " risk \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " 2018 \n",
+ " 0 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 6.094866e+06 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " 2018 \n",
+ " 1 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.508360e+08 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " 2019 \n",
+ " 0 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 6.285071e+06 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " 2019 \n",
+ " 1 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.555734e+08 \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " 2020 \n",
+ " 0 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 6.476829e+06 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
"
+ ]
+ },
+ "execution_count": 18,
+ "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": 19,
+ "id": "16faf81c-8760-4c02-a575-ae033bcb637d",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(,\n",
+ " )"
+ ]
+ },
+ "execution_count": 19,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "risk_traj.plot_time_waterfall()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fed22016-ab8f-4761-892a-c893d18357b7",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "source": [
+ "## Non-default return periods"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fcaed625-82a8-4cc4-82de-e36b67601dcb",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "source": [
+ "You can easily change the default return periods computed, either at initialisation time, or via the property `return_periods`.\n",
+ "Note that estimates of impacts for specific return periods are highly dependant on the data you provided.\n",
+ "\n",
+ "**We cannot check if the event set you provide is fit for computing impacts for a specific return period.** "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "id": "0ade93f9-c43a-4e8a-8225-9343bbbb3615",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " date \n",
+ " group \n",
+ " measure \n",
+ " metric \n",
+ " unit \n",
+ " risk \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " 2018 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_10 \n",
+ " USD \n",
+ " 1.225210e+07 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " 2019 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_10 \n",
+ " USD \n",
+ " 1.277500e+07 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " 2020 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_10 \n",
+ " USD \n",
+ " 1.330821e+07 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " 2021 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_10 \n",
+ " USD \n",
+ " 1.385172e+07 \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " 2022 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_10 \n",
+ " USD \n",
+ " 1.440553e+07 \n",
+ " \n",
+ " \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " \n",
+ " \n",
+ " 87 \n",
+ " 2036 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_30 \n",
+ " USD \n",
+ " 8.662373e+08 \n",
+ " \n",
+ " \n",
+ " 88 \n",
+ " 2037 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_30 \n",
+ " USD \n",
+ " 8.894772e+08 \n",
+ " \n",
+ " \n",
+ " 89 \n",
+ " 2038 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_30 \n",
+ " USD \n",
+ " 9.129904e+08 \n",
+ " \n",
+ " \n",
+ " 90 \n",
+ " 2039 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_30 \n",
+ " USD \n",
+ " 9.367770e+08 \n",
+ " \n",
+ " \n",
+ " 91 \n",
+ " 2040 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_30 \n",
+ " USD \n",
+ " 9.608368e+08 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
92 rows × 6 columns
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " date \n",
+ " group \n",
+ " measure \n",
+ " metric \n",
+ " unit \n",
+ " risk \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " 2018 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_150 \n",
+ " USD \n",
+ " 8.436864e+09 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " 2019 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_150 \n",
+ " USD \n",
+ " 8.697801e+09 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " 2020 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_150 \n",
+ " USD \n",
+ " 8.960766e+09 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " 2021 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_150 \n",
+ " USD \n",
+ " 9.225760e+09 \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " 2022 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_150 \n",
+ " USD \n",
+ " 9.492784e+09 \n",
+ " \n",
+ " \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " \n",
+ " \n",
+ " 64 \n",
+ " 2036 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_500 \n",
+ " USD \n",
+ " 2.643662e+10 \n",
+ " \n",
+ " \n",
+ " 65 \n",
+ " 2037 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_500 \n",
+ " USD \n",
+ " 2.698681e+10 \n",
+ " \n",
+ " \n",
+ " 66 \n",
+ " 2038 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_500 \n",
+ " USD \n",
+ " 2.753977e+10 \n",
+ " \n",
+ " \n",
+ " 67 \n",
+ " 2039 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_500 \n",
+ " USD \n",
+ " 2.809551e+10 \n",
+ " \n",
+ " \n",
+ " 68 \n",
+ " 2040 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_500 \n",
+ " USD \n",
+ " 2.865402e+10 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
69 rows × 6 columns
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " date \n",
+ " group \n",
+ " measure \n",
+ " metric \n",
+ " unit \n",
+ " risk \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " 2018 \n",
+ " All \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.569309e+08 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " 2023 \n",
+ " All \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.845465e+08 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " 2028 \n",
+ " All \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 2.134182e+08 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " 2033 \n",
+ " All \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 2.435459e+08 \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " 2038 \n",
+ " All \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 2.749295e+08 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " date \n",
+ " group \n",
+ " measure \n",
+ " metric \n",
+ " unit \n",
+ " risk \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " 2018-01 \n",
+ " All \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.569309e+08 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " 2018-02 \n",
+ " All \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.573399e+08 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " 2018-03 \n",
+ " All \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.577492e+08 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " 2018-04 \n",
+ " All \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.581589e+08 \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " 2018-05 \n",
+ " All \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.585688e+08 \n",
+ " \n",
+ " \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " \n",
+ " \n",
+ " 1585 \n",
+ " 2039-11 \n",
+ " 1 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 2.633593e+08 \n",
+ " \n",
+ " \n",
+ " 1586 \n",
+ " 2039-12 \n",
+ " 0 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.061942e+07 \n",
+ " \n",
+ " \n",
+ " 1587 \n",
+ " 2039-12 \n",
+ " 1 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 2.638252e+08 \n",
+ " \n",
+ " \n",
+ " 1588 \n",
+ " 2040-01 \n",
+ " 0 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.063804e+07 \n",
+ " \n",
+ " \n",
+ " 1589 \n",
+ " 2040-01 \n",
+ " 1 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 2.642915e+08 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
1590 rows × 6 columns
\n",
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "from climada.trajectories import StaticRiskTrajectory, InterpolatedRiskTrajectory\n",
+ "from climada.trajectories import ExponentialExposureStrategy\n",
+ "import seaborn as sns\n",
+ "\n",
+ "future_year = 2100\n",
+ "exp_future = copy.deepcopy(exp_present)\n",
+ "exp_future.ref_year = future_year\n",
+ "n_years = exp_future.ref_year - exp_present.ref_year + 1\n",
+ "growth_rate = 1.04\n",
+ "growth = growth_rate**n_years\n",
+ "exp_future.gdf[\"value\"] = exp_future.gdf[\"value\"] * growth\n",
+ "\n",
+ "haz_future = client.get_hazard(\n",
+ " \"tropical_cyclone\",\n",
+ " properties={\n",
+ " \"country_name\": \"Haiti\",\n",
+ " \"climate_scenario\": \"rcp60\",\n",
+ " \"ref_year\": \"2080\",\n",
+ " \"nb_synth_tracks\": \"10\",\n",
+ " },\n",
+ ")\n",
+ "impf_set = ImpactFuncSet(\n",
+ " [\n",
+ " ImpfTropCyclone.from_emanuel_usa(v_half=60.0),\n",
+ " ]\n",
+ ")\n",
+ "exp_future.gdf.rename(columns={\"impf_\": \"impf_TC\"}, inplace=True)\n",
+ "exp_future.gdf[\"impf_TC\"] = 1\n",
+ "\n",
+ "snap2 = Snapshot.from_triplet(\n",
+ " exposure=exp_future, hazard=haz_future, impfset=impf_set, date=\"2100\"\n",
+ ")\n",
+ "snapcol = [snap1, snap2]\n",
+ "\n",
+ "exp_interp = ExponentialExposureStrategy()\n",
+ "risk_traj = InterpolatedRiskTrajectory(snapcol)\n",
+ "risk_traj_exp = InterpolatedRiskTrajectory(snapcol, interpolation_strategy=exp_interp)\n",
+ "ax = risk_traj.aai_metrics().plot(\n",
+ " x=\"date\", y=\"risk\", label=\"Linear interpolation for exposure\"\n",
+ ")\n",
+ "risk_traj_exp.aai_metrics().plot(\n",
+ " x=\"date\", y=\"risk\", label=\"Exponential interpolation for exposure\", ax=ax\n",
+ ")\n",
+ "\n",
+ "ax.set_title(\n",
+ " \"Comparison of average annual impact estimate for different interpolation approaches\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4a5991b8-659e-4b0a-81cc-bc0d085ff1e7",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "source": [
+ "## Spatial mapping"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d47bcc7e-defe-4058-b7a3-4dafd4374f35",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "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": 24,
+ "id": "431d26f1-c19f-4654-814b-20e8a243848e",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " date \n",
+ " group \n",
+ " measure \n",
+ " metric \n",
+ " unit \n",
+ " coord_id \n",
+ " risk \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " 2018 \n",
+ " 0 \n",
+ " no_measure \n",
+ " eai \n",
+ " USD \n",
+ " 0 \n",
+ " 2993.678321 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " 2019 \n",
+ " 0 \n",
+ " no_measure \n",
+ " eai \n",
+ " USD \n",
+ " 0 \n",
+ " 3994.537003 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " 2020 \n",
+ " 0 \n",
+ " no_measure \n",
+ " eai \n",
+ " USD \n",
+ " 0 \n",
+ " 5038.235198 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " 2021 \n",
+ " 0 \n",
+ " no_measure \n",
+ " eai \n",
+ " USD \n",
+ " 0 \n",
+ " 6125.062545 \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " 2022 \n",
+ " 0 \n",
+ " no_measure \n",
+ " eai \n",
+ " USD \n",
+ " 0 \n",
+ " 7255.308683 \n",
+ " \n",
+ " \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " \n",
+ " \n",
+ " 110302 \n",
+ " 2096 \n",
+ " 0 \n",
+ " no_measure \n",
+ " eai \n",
+ " USD \n",
+ " 1328 \n",
+ " 99978.314476 \n",
+ " \n",
+ " \n",
+ " 110303 \n",
+ " 2097 \n",
+ " 0 \n",
+ " no_measure \n",
+ " eai \n",
+ " USD \n",
+ " 1328 \n",
+ " 102320.813007 \n",
+ " \n",
+ " \n",
+ " 110304 \n",
+ " 2098 \n",
+ " 0 \n",
+ " no_measure \n",
+ " eai \n",
+ " USD \n",
+ " 1328 \n",
+ " 104694.867359 \n",
+ " \n",
+ " \n",
+ " 110305 \n",
+ " 2099 \n",
+ " 0 \n",
+ " no_measure \n",
+ " eai \n",
+ " USD \n",
+ " 1328 \n",
+ " 107100.640151 \n",
+ " \n",
+ " \n",
+ " 110306 \n",
+ " 2100 \n",
+ " 0 \n",
+ " no_measure \n",
+ " eai \n",
+ " USD \n",
+ " 1328 \n",
+ " 109538.294005 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
110307 rows × 7 columns
\n",
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "gdf = snap1.exposure.gdf\n",
+ "gdf[\"coord_id\"] = gdf.index\n",
+ "gdf = gdf.merge(df, on=\"coord_id\")\n",
+ "\n",
+ "fig, axs = plt.subplots(1, 3, figsize=(24, 5))\n",
+ "\n",
+ "gdf.loc[gdf[\"date\"] == \"2018-01-01\"].plot(\n",
+ " column=\"risk\",\n",
+ " legend=True,\n",
+ " vmin=gdf[\"risk\"].min(),\n",
+ " vmax=gdf[\"risk\"].max(),\n",
+ " ax=axs[0],\n",
+ ")\n",
+ "gdf.loc[gdf[\"date\"] == \"2050-01-01\"].plot(\n",
+ " column=\"risk\",\n",
+ " legend=True,\n",
+ " vmin=gdf[\"risk\"].min(),\n",
+ " vmax=gdf[\"risk\"].max(),\n",
+ " ax=axs[1],\n",
+ ")\n",
+ "gdf.loc[gdf[\"date\"] == \"2100-01-01\"].plot(\n",
+ " column=\"risk\",\n",
+ " legend=True,\n",
+ " vmin=gdf[\"risk\"].min(),\n",
+ " vmax=gdf[\"risk\"].max(),\n",
+ " ax=axs[2],\n",
+ ")\n",
+ "\n",
+ "axs[0].set_title(\"Average Annual Risk in 2018\")\n",
+ "axs[1].set_title(\"Average Annual Risk in 2050\")\n",
+ "axs[2].set_title(\"Average Annual Risk in 2100\")\n",
+ "\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "98159b83-677e-4c23-a926-d03da8c80f3b",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "source": [
+ "## Custom Impact Computation strategy"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "825b9b95-3343-4250-8e1c-e89120359482",
+ "metadata": {},
+ "source": [
+ "By default, trajectory objects use `ImpactCalc().impact()` to compute the `Impact` object and the resulting metric, but you can customize this behaviour via the `impact_computation_strategy` argument.\n",
+ "\n",
+ "The value has to be a class derived from `ImpactComputationStrategy`, and should at the very least implement a `compute_impacts()` method, taking `Exposures`, `Hazard` and `ImpactFuncSet` arguments and returning an `Impact` object.\n",
+ "\n",
+ "For instance, if you don't want the matching of the exposure and hazard centroids to be done internally you can do the following:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "id": "f3b8d931-e4e5-40bf-b702-31183c6c7ec3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from climada.trajectories.impact_calc_strat import ImpactComputationStrategy\n",
+ "\n",
+ "\n",
+ "class ImpactCalcNoAssign(ImpactComputationStrategy):\n",
+ " def compute_impacts(\n",
+ " self,\n",
+ " exp,\n",
+ " haz,\n",
+ " vul,\n",
+ " ):\n",
+ " return ImpactCalc(exposures=exp, impfset=vul, hazard=haz).impact(\n",
+ " assign_centroids=False\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "998fa84d-12e7-4e18-aa96-41ca4bac3ed7",
+ "metadata": {},
+ "source": [
+ "Note that you now have to assign the centroids before running the computations or else they will fail:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "id": "8d8d3b88-2c17-471e-acc3-afd8391a469d",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2026-02-11 11:53:04,676 - climada.entity.exposures.base - INFO - Reading /home/sjuhel/climada/data/exposures/litpop/LitPop_150arcsec_HTI/v3/LitPop_150arcsec_HTI.hdf5\n",
+ "2026-02-11 11:53:04,694 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n",
+ "2026-02-11 11:53:04,696 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n",
+ "2026-02-11 11:53:04,699 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n",
+ "2026-02-11 11:53:04,701 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n"
+ ]
+ }
+ ],
+ "source": [
+ "exp_present = client.get_litpop(country=\"Haiti\")\n",
+ "exp_present.gdf.rename(columns={\"impf_\": \"impf_TC\"}, inplace=True)\n",
+ "exp_present.gdf[\"impf_TC\"] = 1\n",
+ "\n",
+ "\n",
+ "exp_future = copy.deepcopy(exp_present)\n",
+ "exp_future.gdf[\"value\"] = exp_future.gdf[\"value\"] * growth\n",
+ "\n",
+ "exp_present.assign_centroids(haz_present)\n",
+ "exp_future.assign_centroids(haz_future)\n",
+ "\n",
+ "snap1 = Snapshot.from_triplet(\n",
+ " exposure=exp_present, hazard=haz_present, impfset=impf_set, date=\"2018\"\n",
+ ")\n",
+ "snap2 = Snapshot.from_triplet(\n",
+ " exposure=exp_future, hazard=haz_future, impfset=impf_set, date=\"2040\"\n",
+ ")\n",
+ "\n",
+ "impact_calc_no_assign = ImpactCalcNoAssign()\n",
+ "\n",
+ "static_risk_traj = StaticRiskTrajectory(\n",
+ " [snap1, snap2], impact_computation_strategy=impact_calc_no_assign\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "id": "a94d99b5-2c7b-418e-88e9-a9dff39ab21e",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2026-02-11 11:53:04,757 - climada.trajectories.calc_risk_metrics - WARNING - No group id defined in the Exposures object. Per group aai will be empty.\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " date \n",
+ " group \n",
+ " measure \n",
+ " metric \n",
+ " unit \n",
+ " risk \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " 2018-01-01 \n",
+ " All \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 4.027184e+08 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " 2040-01-01 \n",
+ " All \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.330047e+10 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " 2018-01-01 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_20 \n",
+ " USD \n",
+ " 4.096584e+08 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " 2040-01-01 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_20 \n",
+ " USD \n",
+ " 2.003911e+10 \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " 2018-01-01 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_50 \n",
+ " USD \n",
+ " 7.738183e+09 \n",
+ " \n",
+ " \n",
+ " 5 \n",
+ " 2040-01-01 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_50 \n",
+ " USD \n",
+ " 2.719459e+11 \n",
+ " \n",
+ " \n",
+ " 6 \n",
+ " 2018-01-01 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_100 \n",
+ " USD \n",
+ " 1.351303e+10 \n",
+ " \n",
+ " \n",
+ " 7 \n",
+ " 2040-01-01 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_100 \n",
+ " USD \n",
+ " 4.438845e+11 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
+ Risk trajectories
Using EM-DAT data
Cost Benefit Calculation
Probabilistic Yearly Impacts