diff --git a/climada_petals/data/cat_bonds/IBRD_bonds.xlsx b/climada_petals/data/cat_bonds/IBRD_bonds.xlsx
new file mode 100755
index 000000000..64488b972
Binary files /dev/null and b/climada_petals/data/cat_bonds/IBRD_bonds.xlsx differ
diff --git a/climada_petals/engine/cat_bonds/__init__.py b/climada_petals/engine/cat_bonds/__init__.py
new file mode 100644
index 000000000..f703c791c
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/__init__.py
@@ -0,0 +1,22 @@
+"""
+This file is part of CLIMADA.
+
+Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS.
+
+CLIMADA is free software: you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free
+Software Foundation, version 3.
+
+CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with CLIMADA. If not, see .
+
+---
+"""
+
+import logging
+
+LOGGER = logging.getLogger(__name__)
diff --git a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
new file mode 100644
index 000000000..9e707d11e
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
@@ -0,0 +1,582 @@
+import pandas as pd
+import numpy as np
+import logging
+
+from .utils_cat_bonds import multi_level_es, allocate_single_payout
+from .pooling_functions import process_maximum_principal_pools, process_n_pools
+
+LOGGER = logging.getLogger(__name__)
+
+class MultiCountryBond:
+
+ def __init__(self, country_dictionary, term, number_of_terms):
+ self.country_dictionary = country_dictionary
+ self.term = term
+ self.simulated_years = number_of_terms * term
+ self._prepare_data()
+
+
+
+ def _prepare_data(self):
+ self.pay_vs_dam_dic = {}
+ self.principal_dic_cty = {}
+ self.countries = list(self.country_dictionary.keys())
+ min_year_list = []
+ for cty, bond_sim_class in self.country_dictionary.items():
+ self.pay_vs_dam_dic[cty] = bond_sim_class.subarea_calc.pay_vs_dam
+ self.principal_dic_cty[cty] = bond_sim_class.subarea_calc.principal
+ min_year_list.append(bond_sim_class.subarea_calc.pay_vs_dam['year'].min())
+
+ min_year = min(min_year_list)
+
+ self.min_year = min_year
+
+
+
+ @classmethod
+ def simulate_bond_pool_n(cls, country_dictionary, term, number_of_terms, principal, number_pools, n_opt_rep=100):
+ """
+ Class method to optimize pool allocation using a fixed number of pools, create instances of MultiCountryBondSimulation per pool, and run the loss simulation.
+
+ Parameters
+ ----------
+ country_dictionary : dict
+ Dictionary mapping country codes to their bond simulation instances.
+ term : int
+ Term of the bond in years.
+ number_of_terms : int
+ Number of terms to simulate.
+ principal : float
+ Total principal value of the bond.
+ number_pools : int
+ Number of pools to create.
+ n_opt_rep : int, optional
+ Number of optimization repetitions (default is 100).
+
+ Returns
+ -------
+ mlt_bond_simulation_dic : dict
+ Dictionary mapping pool identifiers to their MultiCountryBondSimulation instances.
+ pool_allocation : dataframe
+ Dataframe mapping country codes to their assigned pool.
+ algorithm_result : object
+ Result object from the pooling optimization algorithm.
+ """
+
+ LOGGER.info(f"Starting pooling optimization for {number_pools} pools and {len(country_dictionary)} countries.")
+ countries_list = list(country_dictionary.keys())
+ cls_bond_simulation = [country_dictionary[cty] for cty in countries_list]
+ pool_allocation, algorithm_result = process_n_pools(number_pools, countries_list, cls_bond_simulation, n_opt_rep=n_opt_rep)
+ pool_dict = {}
+ for cty in countries_list:
+ if pool_dict.get(pool_allocation[cty][0]) is None:
+ pool_dict[pool_allocation[cty][0]] = []
+ pool_dict[pool_allocation[cty][0]].append(cty)
+ LOGGER.info("Completed pooling optimization.")
+
+ mlt_bond_simulation_dic = {}
+ for key, countries in pool_dict.items():
+ print(key, countries)
+ LOGGER.info(f"Pool {key}: Countries {pool_dict[key]}")
+ pool_country_dictionary = {cty: country_dictionary[cty] for cty in countries}
+ mlt_bond_simulation_dic[key] = cls(pool_country_dictionary, term, number_of_terms)
+ mlt_bond_simulation_dic[key].init_loss_simulation(principal)
+ LOGGER.info(f"Completed loss simulation for pool {key}.")
+
+ return mlt_bond_simulation_dic, pool_allocation, algorithm_result
+
+ @classmethod
+ def simulate_bond_max_principal_pool(cls, country_dictionary, term, number_of_terms, principal, maximum_principal, n_opt_rep=100):
+ """
+ Class method to optimize pool allocation using a maximum principal, create instances of MultiCountryBondSimulation per pool, and run the loss simulation.
+
+ Parameters
+ ----------
+ country_dictionary : dict
+ Dictionary mapping country codes to their bond simulation instances.
+ term : int
+ Term of the bond in years.
+ number_of_terms : int
+ Number of terms to simulate.
+ principal : float
+ Total principal value of the bond.
+ maximum_principal : float
+ Maximum principal allowed per pool.
+ n_opt_rep : int, optional
+ Number of optimization repetitions (default is 100).
+
+ Returns
+ -------
+ mlt_bond_simulation_dic : dict
+ Dictionary mapping pool identifiers to their MultiCountryBondSimulation instances.
+ pool_allocation : dataframe
+ Dataframe mapping country codes to their assigned pool.
+ algorithm_result : object
+ Result object from the pooling optimization algorithm.
+ """
+
+ LOGGER.info(f"Starting pooling optimization for pools with a maximum principal of {maximum_principal} and {len(country_dictionary)} countries.")
+ countries_list = list(country_dictionary.keys())
+ cls_bond_simulation = [country_dictionary[cty] for cty in countries_list]
+ pool_allocation, algorithm_result = process_maximum_principal_pools(maximum_principal, countries_list, cls_bond_simulation, n_opt_rep=n_opt_rep)
+ pool_dict = {}
+ for cty in countries_list:
+ if pool_dict.get(pool_allocation[cty][0]) is None:
+ pool_dict[pool_allocation[cty][0]] = []
+ pool_dict[pool_allocation[cty][0]].append(cty)
+ LOGGER.info("Completed pooling optimization.")
+
+ mlt_bond_simulation_dic = {}
+ for key, countries in pool_dict.items():
+ LOGGER.info(f"Pool {key}: Countries {pool_dict[key]}")
+ pool_country_dictionary = {cty: country_dictionary[cty] for cty in countries}
+ mlt_bond_simulation_dic[key] = cls(pool_country_dictionary, term, number_of_terms)
+ mlt_bond_simulation_dic[key].init_loss_simulation(principal)
+ LOGGER.info(f"Completed loss simulation for pool {key}.")
+
+ return mlt_bond_simulation_dic, pool_allocation, algorithm_result
+
+
+
+ '''Simulate one term of bond to derive losses'''
+ def _init_bond_loss(self, events_per_year, principal):
+ '''
+ Simulates the expected losses and payouts for a multi-country catastrophe bond over its term.
+ This function iterates over each year (term) and processes event data for each country, calculating
+ payouts and damages based on the provided nominal values and per-country nominal allocations. It tracks
+ losses, damages, and payouts for each country and for the bond as a whole, and computes several summary
+ statistics.
+
+ Parameters
+ ----------
+ self: mlt_bond_simulation
+ A class instance Dictionary mapping country codes to their allocated nominal values.
+ principal : float
+ The total principal value of the catastrophe bond.
+ events_per_year : list of pandas.DataFrame
+ List of DataFrames, one per year of the bond's term, each containing event data with columns:
+ 'month', 'country_code', 'pay', and 'damage'.
+
+ Returns
+ -------
+ rel_ann_bond_losses : list of floats
+ List of relative annual losses (as a fraction of the total principal) for each year of the bond's term.
+ rel_ann_cty_losses : dict
+ Dictionary mapping country codes to arrays of relative annual losses for each year.
+ rel_bond_monthly_losses : pandas.DataFrame
+ DataFrame containing, for each year, the array of event payouts ('losses') and corresponding months ('months'),
+ both normalized by the total principal.
+ coverage_tot : dict
+ Dictionary with total payout and total damage over the bond's term: {'payout': ..., 'damage': ...}.
+ coverage_cty : dict
+ Dictionary mapping country codes to their cumulative payout and damage over the bond's term:
+ {country_code: {'payout': ..., 'damage': ...}, ...}.
+
+ Notes
+ -----
+ - The function assumes that the term (number of years) is inferred from the length of `events_per_year`.
+ - Payouts are capped by the remaining principal value for the bond and by the per-country princpal allocation.
+ - All losses and payouts are normalized by the total principal value before being returned.
+ '''
+ ann_loss = np.zeros(self.term)
+ loss_month_data = []
+ cur_nominal = principal
+ cur_nom_cty = self.principal_dic_cty.copy()
+ sum_damages = 0.0
+ rel_ann_cty_losses = {country: np.zeros(self.term) for country in self.countries}
+ coverage_cty = {}
+ for code in self.countries:
+ coverage_cty[code] = {'payout': 0, 'damage': 0}
+
+ for k in range(self.term):
+
+ if not events_per_year[k].empty:
+ events = events_per_year[k].sort_values(by='month')
+ months = events['month'].to_numpy()
+ countries = events['country_code'].to_numpy()
+ pay = events['pay'].to_numpy()
+ damages = events['damage'].to_numpy()
+ sum_damages += np.sum(damages)
+
+ sum_payouts = np.zeros(len(events))
+ for payout, country, damage, idx in zip(pay, countries, damages, range(len(events))):
+
+ if payout == 0 or cur_nominal == 0 or cur_nom_cty[int(country)] == 0:
+ event_payout = 0
+ else:
+ event_payout = payout
+ cur_nom_cty[int(country)] -= event_payout
+ if cur_nom_cty[int(country)] < 0:
+ event_payout += cur_nom_cty[int(country)]
+ cur_nom_cty[int(country)] = 0
+ cur_nominal -= event_payout
+ if cur_nominal < 0:
+ event_payout += cur_nominal
+ cur_nominal = 0
+
+ sum_payouts[idx] = event_payout
+ coverage_cty[country]['payout'] += event_payout
+ coverage_cty[country]['damage'] += damage
+ rel_ann_cty_losses[country][k] += event_payout / principal
+
+ else:
+ sum_payouts = 0
+ months = []
+
+ ann_loss[k] = np.sum(sum_payouts)
+ loss_month_data.append((sum_payouts, months))
+
+ rel_bond_monthly_losses = pd.DataFrame(loss_month_data, columns=['losses', 'months'])
+
+ rel_ann_bond_losses = list(np.array(ann_loss) / principal)
+ rel_bond_monthly_losses['losses'] = rel_bond_monthly_losses['losses'].values / principal
+ coverage_tot = {'payout': np.sum(ann_loss), 'damage': sum_damages}
+
+ return rel_ann_bond_losses, rel_ann_cty_losses, rel_bond_monthly_losses, coverage_tot, coverage_cty
+
+
+ '''Loop over all terms of bond to derive losses'''
+ def init_loss_simulation(self, principal, confidence_levels=[0.95, 0.99]):
+ """
+ Simulates expected loss and attachment probability for a multi-country catastrophe bond over simulation period.
+ This function aggregates event data for multiple countries over a specified simulation period, computes annual and total losses,
+ calculates risk metrics (Value-at-Risk and Expected Shortfall) at given confidence levels, and evaluates coverage and expected loss
+ shares for each country. It also computes the probability that the bond is triggered (attachment probability) and can print summary statistics.
+
+ Parameters
+ ----------
+ self: mlt_bond_simulation
+ A class instance containing a list of countrie codes and a list of subarea_calc classes with principal values, and pay_vs_dam tables.
+ principal : float
+ The total principal value of the catastrophe bond.
+ confidence_levels : list, optional
+ List of confidence levels (floats between 0 and 1) for risk metrics calculation (default is [0.95, 0.99]).
+
+ Returns
+ -------
+ df_loss_month : pandas.DataFrame
+ DataFrame containing monthly relative losses for the entire bond.
+ loss_metrics : dict
+ Dictionary containing expected annual loss, annual attachment probability, payout, damage, and risk metrics (VaR and ES) at specified confidence levels for annual losses.
+ tot_coverage_cty : dict
+ Dictionary mapping each country code to its total payout, damage, coverage ratio, annual expected loss, and share of annual expected loss.
+
+ Notes
+ -----
+ - The function relies on the helper functions `init_bond_loss` and `multi_level_es` for loss simulation and risk metric calculation.
+ - The function expects event data to be structured such that each country's DataFrame contains a 'year' and 'month' column for filtering events.
+
+ """
+
+ annual_losses = []
+ total_losses = []
+ list_loss_month = []
+ ann_cty_losses = {cty: [] for cty in self.countries}
+ coverage = {'payout': 0, 'damage': 0}
+ self.tot_coverage_cty = {}
+ for cty in self.countries:
+ self.tot_coverage_cty[cty] = {'payout': 0.0, 'damage': 0.0, 'coverage': 0.0, 'EL': 0, 'share_EL': 0}
+
+ for i in range(self.simulated_years-self.term):
+ events_per_year = []
+ for j in range(self.term):
+ events_per_cty = []
+ for cty in self.countries:
+ events = self.pay_vs_dam_dic[int(cty)][self.pay_vs_dam_dic[int(cty)]['year'] == (self.min_year+i)+j].copy()
+ events['country_code'] = cty
+ events_per_cty.append(events)
+ year_events_df = pd.concat(events_per_cty, ignore_index=True) if events_per_cty else pd.DataFrame()
+ events_per_year.append(year_events_df)
+
+ rel_ann_bond_losses, rel_ann_cty_losses, rel_bond_monthly_losses, coverage_tot, coverage_cty = self._init_bond_loss(events_per_year, principal)
+
+ list_loss_month.append(rel_bond_monthly_losses)
+ annual_losses.extend(rel_ann_bond_losses)
+ coverage['payout'] += coverage_tot['payout']
+ coverage['damage'] += coverage_tot['damage']
+
+ for key in coverage_cty.keys():
+ self.tot_coverage_cty[key]['payout'] += coverage_cty[key]['payout']
+ self.tot_coverage_cty[key]['damage'] += coverage_cty[key]['damage']
+
+ for key in rel_ann_cty_losses:
+ ann_cty_losses[key].extend(rel_ann_cty_losses[key])
+
+ self.df_loss_month = pd.concat(list_loss_month, ignore_index=True)
+
+ att_prob_ann = sum(1 for x in annual_losses if x > 0) / len(annual_losses)
+ exp_loss_ann = np.mean(annual_losses)
+
+ annual_losses = pd.Series(annual_losses)
+ total_losses = pd.Series(total_losses)
+
+ var_list, es_list = multi_level_es(annual_losses, confidence_levels)
+
+ for key in self.tot_coverage_cty.keys():
+ self.tot_coverage_cty[key]['coverage'] = self.tot_coverage_cty[key]['payout'] / self.tot_coverage_cty[key]['damage']
+ self.tot_coverage_cty[key]['EL'] = np.mean(ann_cty_losses[key])
+ self.tot_coverage_cty[key]['share_EL'] = self.tot_coverage_cty[key]['EL'] / exp_loss_ann
+
+
+
+ self.loss_metrics = {'EL_ann': exp_loss_ann,
+ 'AP_ann': att_prob_ann,
+ 'Payout': coverage['payout'],
+ 'Damage': coverage['damage']}
+
+ for cl, var, es in zip(confidence_levels, var_list, es_list):
+ self.loss_metrics[f'VaR_{int(cl*100)}_ann'] = var
+ self.loss_metrics[f'ES_{int(cl*100)}_ann'] = es
+
+ LOGGER.info(f'Expected Loss = {exp_loss_ann}')
+ LOGGER.info(f'Attachment Probability = {att_prob_ann}')
+
+
+ '''reduced function to derive returns of the bond -> was used to save time during calculation'''
+ def init_return_simulation(self, premium, rf=0.0):
+ """
+ Simulates the net cash flows (NCF) and premium allocations for a multi-country catastrophe bond structure over the simiulation period.
+ This function calculates the premium payments, net cash flows, and premium allocations for the whole bond and all countries,
+ considering monthly losses and country exposure shares. It accounts for loss events, premium payments,
+ and risk-free rates, and distributes premiums according to country exposure shares represented by the country's Expected Marginal Loss.
+
+ Parameters
+ ----------
+ self: mlt_bond_simulation
+ Class instance of mlt_bond_simulation containing monthly loss data, country exposure shares, and the term of the bond.
+ premium : float
+ The annual premium rate for the bond.
+ rf : float, optional
+ Risk-free rate to be added to the premium (default is 0.0).
+
+ Returns
+ -------
+ ncf : pandas.DataFrame
+ DataFrame containing net cash flows for the bond.
+ prem_cty_df : pandas.DataFrame
+ DataFrame containing premium allocations for each country (based on their exposure share) and total premiums.
+
+ Notes
+ -----
+ - The function resets the nominal value at the end of each term.
+ - Premiums and cash flows are calculated monthly, accounting for loss events and remaining nominal.
+ """
+
+ premiums_tot = []
+ ncf_tot = []
+ cur_nominal = 1
+ for i in range(len(self.df_loss_month)):
+ losses = self.df_loss_month['losses'].iloc[i]
+ months = self.df_loss_month['months'].iloc[i]
+ if np.sum(losses) == 0:
+ premiums_tot.append(cur_nominal * premium)
+ ncf_tmp = cur_nominal * (premium + rf)
+ ncf_tot.append(ncf_tmp)
+ else:
+ ncf_tot_tmp = []
+ premiums_tot_tmp = []
+ premiums_tot_tmp.append(cur_nominal * premium / 12 * months[0])
+ prem_pre_tmp = cur_nominal * (premium + rf) / 12 * months[0]
+ ncf_tot_tmp.append(prem_pre_tmp)
+ for j in range(len(losses)):
+ loss = losses[j]
+ month = months[j]
+ cur_nominal -= loss
+ if cur_nominal < 0:
+ loss += cur_nominal
+ cur_nominal = 0
+ if j + 1 < len(losses):
+ nex_month = months[j+1]
+ premiums_tot_tmp.append(cur_nominal * premium / 12 * (nex_month - month))
+ prem_tmp = ((cur_nominal * (premium + rf)) / 12 * (nex_month - month))
+ ncf_tot_tmp.append(prem_tmp - loss)
+ else:
+ premiums_tot_tmp.append(cur_nominal * premium / 12 * (12 - month))
+ prem_tmp = ((cur_nominal * (premium + rf)) / 12 * (12- month))
+ ncf_tot_tmp.append(prem_tmp - loss)
+ ncf_tot.append(np.sum(ncf_tot_tmp))
+ premiums_tot.append(np.sum(premiums_tot_tmp))
+ if (i + 1) % self.term == 0:
+ cur_nominal = 1
+ prem_cty_dic = {country: [] for country in self.tot_coverage_cty}
+ for country in prem_cty_dic:
+ prem_cty_dic[country] = np.array(premiums_tot) * self.tot_coverage_cty[country]['share_EL']
+ prem_cty_dic['Total'] = premiums_tot
+
+ self.ncf = pd.DataFrame(ncf_tot, columns=['Total'])
+ self.prem_cty_df = pd.DataFrame(prem_cty_dic)
+
+
+
+ '''reduced function to derive returns of the bond -> was used to save time during calculation'''
+ def init_return_simulation_tranches(self, premiums, tranches, rf=0.0):
+ """
+ Simulates the net cash flows (NCF) and premium allocations for a multi-country catastrophe bond structure over the simiulation period.
+ This function calculates the premium payments, net cash flows, and premium allocations for each tranche and country,
+ considering monthly losses, tranche structures, and country exposure shares. It accounts for loss events, premium payments,
+ and risk-free rates, and distributes premiums according to country exposure shares represented by the country's Expected Marginal Loss.
+
+ Parameters
+ ----------
+ self: mlt_bond_simulation
+ Class instance of mlt_bond_simulation containing monthly loss data, country exposure shares, tranche structures, and the term of the bond.
+ premiums : float
+ List of annual premium rates for each tranche.
+ tranches : list
+ List of share of principal values for each tranche.
+ rf : float, optional
+ Risk-free rate to be added to the premium (default is 0.0).
+
+ Returns
+ -------
+ ncf : pandas.DataFrame
+ DataFrame containing net cash flows for each tranche and the total across all tranches for each period.
+ prem_cty_df : pandas.DataFrame
+ DataFrame containing premium allocations for each country (based on their exposure share), total premiums (if bond is priced as one), and alternative total premiums (if each tranche is priced seperately).
+
+ Notes
+ -----
+ - The function resets the nominal value at the end of each term.
+ - Premiums and cash flows are calculated monthly, accounting for loss events and remaining nominal.
+ - Alternative premium calculation is provided for country-level allocation.
+ - Losses are allocated to tranches in reverse order (from highest to lowest risk).
+ """
+
+ ncf = {str(tranche): [] for tranche in tranches}
+ premiums_tot = []
+ cur_nominal_tranches = tranches.copy()
+ for i in range(len(self.df_loss_month)):
+ losses = self.df_loss_month['losses'].iloc[i]
+ months = self.df_loss_month['months'].iloc[i]
+ if np.sum(losses) == 0:
+ prem_it_alt = 0
+ for k, tranche in enumerate(tranches):
+ ncf[str(tranche)].append(cur_nominal_tranches[k] * (premiums[k] + rf))
+ prem_it_alt += cur_nominal_tranches[k] * premiums[k]
+ premiums_tot.append(prem_it_alt)
+ else:
+ ncf_tmp = {str(tranche): [] for tranche in tranches}
+ prem_it_alt = 0
+ premiums_tot_tmp = []
+ for k, tranche in enumerate(tranches):
+ ncf_tmp[str(tranche)].append(cur_nominal_tranches[k] * (premiums[k] + rf) / 12 * months[0])
+ prem_it_alt += cur_nominal_tranches[k] * premiums[k] / 12 * months[0]
+ premiums_tot_tmp.append(prem_it_alt)
+ losses_per_tranche = np.zeros(len(tranches)) # accumulate over all events in this period
+ for j in range(len(losses)):
+ loss = losses[j]
+ month = months[j]
+ cur_nominal_tranches, payout_per_tranche = allocate_single_payout(loss, cur_nominal_tranches)
+ losses_per_tranche += payout_per_tranche
+ if j + 1 < len(losses):
+ nex_month = months[j+1]
+ prem_it_alt = 0
+ for k, tranche in enumerate(tranches):
+ ncf_tmp[str(tranche)].append(((cur_nominal_tranches[k] * (premiums[k] + rf)) / 12 * (nex_month - month)))
+ prem_it_alt += cur_nominal_tranches[k] * premiums[k] / 12 * (nex_month - month)
+ premiums_tot_tmp.append(prem_it_alt)
+ else:
+ prem_it_alt = 0
+ for k, tranche in enumerate(tranches):
+ ncf_tmp[str(tranche)].append(((cur_nominal_tranches[k] * (premiums[k] + rf)) / 12 * (12- month)))
+ prem_it_alt += cur_nominal_tranches[k] * premiums[k] / 12 * (12- month)
+ premiums_tot_tmp.append(prem_it_alt)
+ premiums_tot.append(np.sum(premiums_tot_tmp))
+ for idx, tranche in enumerate(tranches):
+ ncf[str(tranche)].append(np.sum(ncf_tmp[str(tranche)]) - losses_per_tranche[idx])
+ if (i + 1) % self.term == 0:
+ cur_nominal_tranches = tranches.copy()
+
+ prem_cty_dic = {country: [] for country in self.tot_coverage_cty}
+ for country in prem_cty_dic:
+ prem_cty_dic[country] = np.array(premiums_tot) * self.tot_coverage_cty[country]['share_EL']
+ prem_cty_dic['Total'] = premiums_tot
+
+ self.ncf_tranches = pd.DataFrame(ncf)
+ self.ncf_tranches['Total'] = self.ncf_tranches.sum(axis=1)
+ self.prem_cty_df_tranches = pd.DataFrame(prem_cty_dic)
+
+
+ '''Calculates required nominal for multi-country bonds -> derives maximal loss over simulation period'''
+ def init_required_principal(self):
+ """
+ Calculates the required nominal value for a multi-country catastrophe bond based on simulated event losses.
+ This function simulates event losses over a specified term for multiple countries, aggregates the losses,
+ and determines the maximum total loss across all simulation periods. The required nominal value is the
+ maximum loss observed, which can be used to set the bond's principal.
+ Parameters:
+ self: MultiCountryBondSimulation
+ An instance of the MultiCountryBondSimulation class containing country data and simulation parameters.
+ Returns:
+ float: The required nominal value for the catastrophe bond, equal to the maximum simulated total loss.
+ """
+
+ total_losses = []
+
+ for i in range(self.simulated_years-self.term):
+ events_per_year = []
+ for j in range(self.term):
+ events_per_cty = [self.pay_vs_dam_dic[int(cty)].loc[self.pay_vs_dam_dic[int(cty)]['year'] == (self.min_year + i) + j].assign(country_code=cty) for cty in self.countries]
+
+ year_events_df = pd.concat(events_per_cty, ignore_index=True) if events_per_cty else pd.DataFrame()
+ events_per_year.append(year_events_df)
+
+ tot_loss = self._init_equ_nom_sim(events_per_year, self.principal_dic_cty)
+
+ total_losses.append(tot_loss)
+
+ self.requ_principal = np.max(total_losses)
+
+
+ '''derives losses for one term of bond'''
+ def _init_equ_nom_sim(self, events_per_year, nominal_dic_cty):
+ """
+ Simulates total losses for a multi-country catastrophe bond over a specified term.
+ For each year in the bond's term, the function processes a list of event dataframes, each containing
+ payout amounts and country codes. It calculates the payouts for each event, ensuring that payouts do not
+ exceed the remaining nominal value for each country. The annual losses are accumulated, and the total loss
+ over the term is returned.
+
+ Parameters
+ ----------
+ events_per_year : list of pandas.DataFrame
+ A list where each element corresponds to a year and contains a DataFrame of events with columns
+ 'pay' (payout amount) and 'country_code' (identifier for the country).
+ nominal_dic_cty : dict
+ Dictionary mapping country codes to their initial nominal values for the bond.
+
+ Returns
+ -------
+ tot_loss : float
+ The total loss over the bond's term, accounting for country-specific nominal limits.
+ """
+
+ ann_loss = np.zeros(self.term)
+ cur_nom_cty = nominal_dic_cty.copy()
+
+ for k in range(self.term):
+ if not events_per_year[k].empty:
+ events = events_per_year[k]
+ payouts = events['pay'].to_numpy()
+ cties = events['country_code'].to_numpy()
+
+ sum_payouts = np.zeros(len(events))
+
+ for idx, (payout, cty) in enumerate(zip(payouts, cties)):
+ if payout == 0 or cur_nom_cty[cty] == 0:
+ event_payout = 0
+ else:
+ event_payout = payout
+ cur_nom_cty[cty] -= event_payout
+ if cur_nom_cty[cty] < 0:
+ event_payout += cur_nom_cty[cty]
+ cur_nom_cty[cty] = 0
+ sum_payouts[idx] = event_payout
+
+ ann_loss[k] = np.sum(sum_payouts)
+ else:
+ ann_loss[k] = 0
+
+ tot_loss = np.sum(ann_loss)
+ return tot_loss
+
\ No newline at end of file
diff --git a/climada_petals/engine/cat_bonds/pooling_functions.py b/climada_petals/engine/cat_bonds/pooling_functions.py
new file mode 100644
index 000000000..227d6ee48
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/pooling_functions.py
@@ -0,0 +1,292 @@
+import numpy as np
+from math import comb
+from pymoo.core.problem import ElementwiseProblem
+from pymoo.core.variable import Integer
+import pandas as pd
+from pymoo.operators.sampling.rnd import IntegerRandomSampling
+from pymoo.operators.mutation.pm import PolynomialMutation
+from pymoo.operators.crossover.hux import HalfUniformCrossover
+from pymoo.algorithms.soo.nonconvex.ga import GA
+from pymoo.optimize import minimize
+from pymoo.operators.repair.rounding import RoundingRepair
+
+def process_n_pools(number_pools, countries, cls_bond_simulations, n_opt_rep=100):
+ """
+ Runs risk concentration minimization for a given number of pools using a genetic algorithm,
+ processes the optimization results, and generates convergence plots.
+
+ Parameters
+ ----------
+ n : int
+ Number of pools to optimize.
+ cls_bond_simulations : list
+ List of SingleCountryBondSimulation instances for each country, containing the principals and
+ monthly losses.
+ n_opt_rep : int, optional
+ Number of optimization repetitions for seed analysis (default is 100).
+
+ Returns
+ -------
+ country_allocation : pandas.DataFrame
+ DataFrame containing a optimal country allocation for the minimum concentration solution.
+ algorithm_result: pymoo.core.result.Result
+ Result object from the optimization containing details of the optimization process.
+ """
+
+ annual_losses_dic_cty = {}
+ principal_sng = []
+ for idx, cty in enumerate(countries):
+ annual_losses_dic_cty[cty] = cls_bond_simulations[idx].df_loss_month['losses'].apply(lambda x: sum(x) if len(x) > 0 else 0)
+ principal_sng.append(cls_bond_simulations[idx].subarea_calc.principal)
+ df_losses = pd.DataFrame(annual_losses_dic_cty)
+
+ opt_rep = range(0,n_opt_rep,1)
+
+ ### CALCULATE ALPHA FOR RISK CONCENTRATION OPTIMIZATION ###
+ RT = len(df_losses[countries[0]])
+ alpha = 1-1/RT
+
+ bools = df_losses >= np.quantile(df_losses, alpha, axis=0)
+
+ risk_concentration = 1.0
+ # Loop through repetitions for seed analysis
+ for index in opt_rep:
+ # Define Problem and Algorithm (same as inside the loop)
+ problem = PoolOptimizationFixedNumber(principal_sng, df_losses, bools, alpha, number_pools, calc_pool_conc)
+ algorithm = GA(
+ pop_size=2000,
+ sampling=IntegerRandomSampling(),
+ crossover=HalfUniformCrossover(),
+ mutation=PolynomialMutation(repair=RoundingRepair()),
+ eliminate_duplicates=True,
+ )
+
+ # Solve the problem
+ res_reg = minimize(problem, algorithm, verbose=False, save_history=True)
+
+ # Process results (same code as inside the loop)
+ x = res_reg.X
+ risk_concentration_new = res_reg.F
+ if risk_concentration_new is not None and risk_concentration is not None and risk_concentration_new < risk_concentration:
+ algorithm_result = res_reg
+ risk_concentration = risk_concentration_new
+ sorted_unique = sorted(set(x))
+ rank_dict = {value: rank + 1 for rank, value in enumerate(sorted_unique)}
+ x = [rank_dict[value] for value in x]
+
+ # Add to dump dataframe
+ country_allocation = pd.DataFrame(columns=[countries, 'min_conc'])
+ country_allocation = pd.DataFrame([x], columns=countries)
+ country_allocation['min_conc'] = pd.DataFrame([res_reg.F], columns=['min_conc'])
+
+ return country_allocation, algorithm_result
+
+
+def process_maximum_principal_pools(maximum_principal, countries, cls_bond_simulations, n_opt_rep=100):
+ """
+ Runs risk concentration minimization for pools with a maximum principal constraint using a genetic algorithm,
+ processes the optimization results, and generates convergence plots.
+
+ Parameters
+ ----------
+ maximum_principal : float
+ Maximum principal allowed per pool.
+ cls_bond_simulations : list
+ List of SingleCountryBondSimulation instances for each country, containing the principals and
+ monthly losses.
+ n_opt_rep : int, optional
+ Number of optimization repetitions for seed analysis (default is 100).
+
+ Returns
+ -------
+ country_allocation : pandas.DataFrame
+ DataFrame containing a optimal country allocation for the minimum concentration solution.
+ algorithm_result: pymoo.core.result.Result
+ Result object from the optimization containing details of the optimization process.
+ """
+
+ annual_losses_dic_cty = {}
+ principal_sng = []
+ for idx, cty in enumerate(countries):
+ annual_losses_dic_cty[cty] = cls_bond_simulations[idx].df_loss_month['losses'].apply(lambda x: sum(x) if len(x) > 0 else 0)
+ principal_sng.append(cls_bond_simulations[idx].subarea_calc.principal)
+ df_losses = pd.DataFrame(annual_losses_dic_cty)
+
+ opt_rep = range(0,n_opt_rep,1)
+
+ ### CALCULATE ALPHA FOR RISK CONCENTRATION OPTIMIZATION ###
+ RT = len(df_losses[countries[0]])
+ alpha = 1-1/RT
+
+ bools = df_losses >= np.quantile(df_losses, alpha, axis=0)
+
+ risk_concentration = 1.0
+ # Loop through repetitions for seed analysis
+ for index in opt_rep:
+ # Define Problem and Algorithm (same as inside the loop)
+ problem = PoolOptimizationMaximumPrincipal(principal_sng, maximum_principal, df_losses, bools, alpha, len(countries), calc_pool_conc)
+ algorithm = GA(
+ pop_size=2000,
+ sampling=IntegerRandomSampling(),
+ crossover=HalfUniformCrossover(),
+ mutation=PolynomialMutation(repair=RoundingRepair()),
+ eliminate_duplicates=True,
+ )
+
+ # Solve the problem
+ res_reg = minimize(problem, algorithm, verbose=False, save_history=True)
+
+ # Process results (same code as inside the loop)
+ x = res_reg.X
+ risk_concentration_new = res_reg.F
+ if risk_concentration_new is not None and risk_concentration is not None and risk_concentration_new < risk_concentration:
+ algorithm_result = res_reg
+ risk_concentration = risk_concentration_new
+ sorted_unique = sorted(set(x))
+ rank_dict = {value: rank + 1 for rank, value in enumerate(sorted_unique)}
+ x = [rank_dict[value] for value in x]
+
+ # Add to dump dataframe
+ country_allocation = pd.DataFrame(columns=[countries, 'min_conc'])
+ country_allocation = pd.DataFrame([x], columns=countries)
+ country_allocation['min_conc'] = pd.DataFrame([res_reg.F], columns=['min_conc'])
+
+ return country_allocation, algorithm_result
+
+
+
+
+
+def calc_pool_conc(x, data_arr, bools, alpha):
+ """Calculate diversification of a given pool. Used to
+ find the best pool.
+
+ x : bool
+ Countries to consider in the pool
+ data_arr : np.array
+ Numpy array with annual damages for all countries
+ bools : np.array
+ Numpy array with the same shape as data, indicating when
+ annual damages are higher/lower than the country VaR
+ alpha : float
+ Point at which to calculate VaR and ES
+ """
+
+ dam = data_arr[:,x]
+ cntry_bools = bools[:,x]
+ tot_damage = dam.sum(1)
+
+ VAR_tot = np.quantile(tot_damage[~np.isnan(tot_damage)], alpha)
+ bool_tot = tot_damage >= VAR_tot
+
+ ES_cntry = []
+ MES = []
+
+ for cntry_pos in range(dam.shape[1]):
+ dummy_dam = dam[:,cntry_pos][cntry_bools[:,cntry_pos]]
+
+ ES_cntry.append(np.nanmean(dummy_dam))
+ MES.append(np.nanmean(dam[:,cntry_pos][bool_tot]))
+
+ ES_cntry = np.array(ES_cntry)
+ MES = np.array(MES)
+
+ # if no countries are picked
+ if x.sum() == 0:
+ POOL_CONC = 1.
+ else:
+ ES_tot = np.nansum(MES)
+ POOL_CONC = ES_tot / np.nansum(ES_cntry)
+
+ return np.round(POOL_CONC, 2)
+
+'''Pool optimization problem using fixed number of pools'''
+class PoolOptimizationFixedNumber(ElementwiseProblem):
+ def __init__(self, nominals, data, bools, alpha, N, fun, **kwargs):
+ self.data_arr = data
+ self.bools = bools
+ self.alpha = alpha
+ self.N = N
+ self.fun = fun
+ self.nominals = np.array(nominals)
+ self.n_countries = len(nominals)
+ super().__init__(
+ n_var=self.data_arr.shape[1],
+ n_obj=1,
+ n_constr = 1,
+ xl=0,
+ xu=self.N - 1,
+ type_var=int,
+ vars=[Integer((0, self.n_countries - 1)) for _ in range(self.n_countries)],
+ **kwargs
+ )
+
+ def _evaluate(self, x, out, *args, **kwargs):
+ pools = {i: [] for i in np.unique(x)}
+ for i, pool_id in enumerate(x):
+ if len(np.where(x == i)[0]) > 0:
+ pool_mask = np.where(x == i)[0]
+ pools[i].append(pool_mask)
+
+ total_concentration = 0
+ for pool_key, pool_countries in pools.items():
+ pool1_col = self.data_arr.columns[pool_countries[0]]
+ pool1_data = self.data_arr[pool1_col].values
+ pool1_bools = self.bools[pool1_col].values
+ conc = self.fun(np.arange(0, len(pool_countries[0])), pool1_data, pool1_bools, self.alpha)
+ total_concentration += conc
+ constraints = 0
+ if len(pools) != self.N:
+ constraints += 1
+
+ out["F"] = total_concentration/len(pools)
+ out["G"] = constraints
+
+def pop_num(n, k):
+ combinations = comb(n + k - 1, k)
+ return combinations
+
+'''Pool optimization problem using maximum nominal constraint'''
+class PoolOptimizationMaximumPrincipal(ElementwiseProblem):
+ def __init__(self, nominals, max_nominal, data, bools, alpha, N, fun, **kwargs):
+ self.data_arr = data
+ self.bools = bools
+ self.alpha = alpha
+ self.N = N
+ self.fun = fun
+ self.nominals = np.array(nominals)
+ self.n_countries = len(nominals)
+ self.max_nominal = max_nominal
+ super().__init__(
+ n_var=self.data_arr.shape[1],
+ n_obj=1,
+ n_constr = 1,
+ xl=0,
+ xu=self.N - 1,
+ type_var=int,
+ vars=[Integer((0, self.n_countries - 1)) for _ in range(self.n_countries)],
+ **kwargs
+ )
+
+ def _evaluate(self, x, out, *args, **kwargs):
+ pools = {i: [] for i in np.unique(x)}
+ for i, pool_id in enumerate(x):
+ if len(np.where(x == i)[0]) > 0:
+ pool_mask = np.where(x == i)[0]
+ pools[i].append(pool_mask)
+
+ total_concentration = 0
+ for pool_key, pool_countries in pools.items():
+ pool1_col = self.data_arr.columns[pool_countries[0]]
+ pool1_data = self.data_arr[pool1_col].values
+ pool1_bools = self.bools[pool1_col].values
+ conc = self.fun(np.arange(0, len(pool_countries[0])), pool1_data, pool1_bools, self.alpha) * np.sum(self.nominals[pool_countries[0]])
+ total_concentration += conc
+ constraints = 0
+ for members in pools.values():
+ pool_nominal_diff = np.sum(self.nominals[members[0]]) - self.max_nominal
+ if pool_nominal_diff > 0:
+ constraints += pool_nominal_diff
+
+ out["F"] = total_concentration / np.sum(self.nominals)
+ out["G"] = constraints
diff --git a/climada_petals/engine/cat_bonds/premium_class.py b/climada_petals/engine/cat_bonds/premium_class.py
new file mode 100644
index 000000000..a863e5ee6
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/premium_class.py
@@ -0,0 +1,170 @@
+import pandas as pd
+import numpy as np
+from pathlib import Path
+from scipy.optimize import curve_fit, minimize
+
+import logging
+
+# path to data folder
+DATA_DIR = (Path(__file__).parent.parent.parent).joinpath('data/cat_bonds')
+
+# setup logger
+LOGGER = logging.getLogger(__name__)
+
+# regression coefficients for chatoro premium calculation (extracted from Chatoro et al., 2022)
+b_0 = -0.5907
+b_1 = 1.3986
+b_2 = 2.2520
+b_3 = 0.0377
+b_4 = 0.4613
+b_5 = -0.0239
+b_6 = -2.6742
+b_7 = 0.7057
+
+class PremiumCalculations:
+
+ def __init__(self, bond_simulation_class):
+ self.bond_simulation_class = bond_simulation_class
+
+ ### CHATORO-PRICING ###
+ def calc_chatoro_premium(self, peak_multi, investment_graded, hybrid_trigger, GCIndex=None, BBSpread=None):
+ '''Linear regression formula to calculate the premium based on the regression model presented in Chatoro et al., 2022'''
+
+ if GCIndex is None:
+ GCIndex = 180 #Guy Carpenter Global Property Catastrophe Rate on Line Index (January, 2025)
+ LOGGER.info(f'Using default GCIndex value of {GCIndex}')
+ else:
+ pass
+ if BBSpread is None:
+ BBSpread = 1.6 #ICE BofA BB US High Yield Index Option-Adjusted Spread (January, 2025)
+ LOGGER.info(f'Using default BBSpread value of {BBSpread}')
+ else:
+ pass
+
+ self.chatoro_prem_rate = (b_0 + b_1 * self.bond_simulation_class.loss_metrics['EL_ann'] * 100 + b_2 * peak_multi +
+ b_3 * GCIndex + b_4 * BBSpread + b_5 * self.bond_simulation_class.term * 12 +
+ b_6 * investment_graded + b_7 * hybrid_trigger) / 100
+ LOGGER.info(f'Calculated Chatoro premium rate: {self.chatoro_prem_rate}')
+
+
+
+ ### IBRD-PRICING ###
+ def monoExp(self, x, a, k, b):
+ '''Exponential function to fit the risk multiple curve'''
+ return a * np.exp(-k * x) + b
+
+ def calc_ibrd_premium(self, peril=None, year=None):
+ """
+ Fits a monotonic exponential curve to catastrophe bond data for bonds issued by the World Bank to estimate premium parameters.
+ This function loads IBRD bond data from an Excel file, optionally filters the data by peril type or issuing year,
+ and fits a monotonic exponential function to the relationship between expected loss and risk multiple.
+ The fitted parameters are returned. Optionally, the function can generate and save a plot of the fit.
+
+ Parameters
+ ----------
+ peril : str, optional
+ Peril type to filter the bonds (e.g., 'Earthquake', 'Flood'). If None, no filtering by peril is applied.
+ year : list or int, optional
+ Issuing year(s) to filter the bonds. If None, no filtering by year is applied.
+
+ Returns
+ -------
+ ibrd_prem_rate : float
+ The estimated premium rate based on the fitted curve and the bond's expected annual loss.
+ """
+ ibrd_bonds = pd.read_excel(DATA_DIR.joinpath('IBRD_bonds.xlsx'))
+ if peril is not None:
+ flt_ibrd_bonds = ibrd_bonds[ibrd_bonds['Peril'] == peril]
+ flt_ibrd_bonds = flt_ibrd_bonds.reset_index(drop=True)
+
+ elif year is not None:
+ flt_ibrd_bonds = ibrd_bonds[ibrd_bonds['Issuing date'].isin(year)]
+ flt_ibrd_bonds = flt_ibrd_bonds.reset_index(drop=True)
+
+ else:
+ flt_ibrd_bonds = ibrd_bonds.copy()
+ #perform the fit
+ params_prem_ibrd, cv = curve_fit(self.monoExp, flt_ibrd_bonds['Expected Loss'], flt_ibrd_bonds['Risk Multiple'])
+
+ a, k, b = params_prem_ibrd
+ LOGGER.info(f'Fitted IBRD premium parameters: a={a}, k={k}, b={b}')
+ self.ibrd_prem_rate = self.monoExp(self.bond_simulation_class.loss_metrics['EL_ann']*100, a, k, b) * self.bond_simulation_class.loss_metrics['EL_ann']
+ LOGGER.info(f"Calculated IBRD premium rate: {self.ibrd_prem_rate}")
+
+
+
+ ### BENCHMARK SHARPE RATIO PREMIUMS ###
+ '''Benchmark pricing function for single country bonds -> goes through all losses and determines required premium to achieve a certain target Sharpe ratio'''
+ def find_sharpe(self, premium, monthly_losses, target_sharpe):
+ """
+ Calculates the squared difference between the Sharpe ratio of a cat bond cash flow and a target Sharpe ratio.
+ The function simulates the annual cash flows of a catastrophe bond investment, adjusting for losses and premium payments.
+ It computes the average return and standard deviation of the net cash flows, then calculates the Sharpe ratio and returns
+ the squared difference from the target Sharpe ratio.
+
+ Parameters
+ ----------
+ premium (float): The annual premium rate paid to the investor.
+ monthly_losses (pd.DataFrame): DataFrame containing monthly loss events per year, with columns 'losses' (list of loss amounts per event)
+ and 'months' (list of months when each event occurs).
+ target_sharpe (float): The target Sharpe ratio to compare against.
+
+ Returns
+ -------
+ float: The squared difference between the calculated Sharpe ratio and the target Sharpe ratio.
+ """
+
+ ncf = []
+ cur_nominal = 1
+ for i in range(len(monthly_losses)):
+ losses = monthly_losses['losses'].iloc[i]
+ months = monthly_losses['months'].iloc[i]
+ if np.sum(losses) == 0:
+ ncf.append(cur_nominal * premium)
+ else:
+ ncf_pre_event = (cur_nominal * premium) / 12 * (months[0])
+ ncf_post_event = []
+ for j in range(len(losses)):
+ loss = losses[j]
+ month = months[j]
+ cur_nominal -= loss
+ if cur_nominal < 0:
+ loss += cur_nominal
+ cur_nominal = 0
+ if j + 1 < len(losses):
+ nex_month = months[j+1]
+ ncf_post_event.append(((cur_nominal * premium) / 12 * (nex_month - month)) - loss)
+ else:
+ ncf_post_event.append(((cur_nominal * premium) / 12 * (12- month)) - loss)
+ ncf.append(ncf_pre_event + np.sum(ncf_post_event))
+ if (i + 1) % self.bond_simulation_class.term == 0:
+ cur_nominal = 1
+
+ avg_ret = np.mean(ncf)
+ sigma = np.std(ncf)
+ return (avg_ret / sigma - target_sharpe)**2
+
+
+ '''Benchmark pricing function for single country bonds -> wrapper function to call the optimization'''
+ def calc_benchmark_premium(self, target_sharpe):
+ """
+ Calculates the initial premium required to achieve a target Sharpe ratio for a given set of annual losses.
+ This function uses numerical optimization to find the premium value that results in the desired Sharpe ratio,
+ given the annual losses and the risk-free rate.
+
+ Parameters
+ ----------
+ self: float
+ An instance of the premium_calculation class containing a dataframw with monthly losses.
+ target_sharpe: float
+ Desired Sharpe ratio to be achieved.
+
+ Returns
+ -------
+ float: The optimal premium value that achieves the target Sharpe ratio.
+ """
+
+ result = minimize(lambda p: self.find_sharpe(p, self.bond_simulation_class.df_loss_month, target_sharpe),
+ x0=[0.05])
+ self.benchmark_prem_rate = result.x[0]
+
diff --git a/climada_petals/engine/cat_bonds/sng_bond_simulation.py b/climada_petals/engine/cat_bonds/sng_bond_simulation.py
new file mode 100644
index 000000000..d1edde833
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/sng_bond_simulation.py
@@ -0,0 +1,222 @@
+import pandas as pd
+import numpy as np
+import logging
+from .utils_cat_bonds import multi_level_es
+
+LOGGER = logging.getLogger(__name__)
+
+class SingleCountryBondSimulation:
+
+ def __init__(self, subarea_calc, term, number_of_terms):
+ self.term = term
+ self.number_of_terms = number_of_terms
+ self.subarea_calc = subarea_calc
+
+ '''Simulate one term of bond to derive losses'''
+ def init_bond_loss(self, events_per_year):
+ """
+ Calculates the expected losses for a catastrophe bond over its term.
+ This function simulates the bond's loss experience given a sequence of event data per year,
+ tracking payouts, damages, remaining princpal value, and the timing of losses. It returns the relative
+ losses per year, the total payouts and damages per term, and a DataFrame detailing losses and their corresponding months.
+
+ Parameters
+ ----------
+ self : bond_simulation
+ An instance of the bond_simulation class containing a payout vs damage table, bond term, and the principal.
+ events_per_year : list of pandas.DataFrame
+ A list where each element is a DataFrame representing events in a year. Each DataFrame must
+ contain at least 'month' and 'pay' columns, where 'pay' is the payout for each event.
+ Returns
+ -------
+ rel_annual_losses : numpy.ndarray
+ Array of relative payouts/losses per year (losses divided by principal).
+ rel_monthly_loss : pandas.DataFrame
+ DataFrame with columns 'losses' and 'months', detailing the losses and their corresponding
+ months for each year.
+ summed_payouts : float
+ The total summed payouts over the bond's term.
+ summed_damages : float
+ The total summed damages over the bond's term.
+ """
+
+ principal0 = self.subarea_calc.principal
+ principal = principal0
+
+ # Use Python lists only for month-level output (tiny)
+ df_monthly = pd.DataFrame(columns=[
+ "losses", "months"], dtype=object
+ )
+
+
+ annual_losses = pd.Series(0.0, index=range(self.term))
+
+ summed_damages = 0.0
+
+ for year, ev in enumerate(events_per_year):
+
+ # Extract arrays
+ months = ev["month"].to_numpy()
+ pays = ev["pay"].to_numpy()
+ damages = ev["damage"].to_numpy()
+
+ summed_damages += damages.sum()
+ # Running cumulative payout to detect exhaustion
+ cum = np.cumsum(pays)
+
+ # Identify first index where principal is exceeded
+ exhaust_idx = np.searchsorted(cum, principal, side="right")
+ if exhaust_idx == len(pays):
+ # principal never exhausted → no capping needed
+ payouts = pays.copy()
+ principal -= payouts.sum()
+ else:
+ # principal exhausted at this index
+ payouts = np.zeros_like(pays, dtype=float)
+ # All payouts before exhaustion are exact
+ if exhaust_idx > 0:
+ payouts[:exhaust_idx] = pays[:exhaust_idx]
+
+ # Payout at exhaustion month: whatever principal remains
+ prev_cum = cum[exhaust_idx-1] if exhaust_idx > 0 else 0
+ payouts[exhaust_idx] = principal - prev_cum
+
+ # After that → principal is 0, so payouts remain 0
+ principal = 0.0
+ # Store relative losses and months as arrays for consistent indexing
+ df_monthly.loc[year, "losses"] = list(payouts / principal0)
+ df_monthly.loc[year, "months"] = list(months)
+
+
+ # Sum for annual loss
+ annual_losses[year] = payouts.sum()
+
+ rel_annual_losses = annual_losses / principal0
+ summed_payouts = annual_losses.sum()
+
+ return rel_annual_losses, df_monthly, summed_payouts, summed_damages
+
+ def init_loss_simulation(self, confidence_levels=[0.95, 0.99]):
+ """
+ Simulate losses, payouts, damages, and risk metrics for a catastrophe bond.
+
+ Returns
+ -------
+ df_loss_month : pd.DataFrame
+ Monthly loss data for all simulations.
+ loss_metrics : dict
+ Expected loss, attachment probability, total payouts/damages,
+ VaR and ES metrics for given confidence levels.
+ """
+
+ pay_vs_dam = self.subarea_calc.pay_vs_dam
+ min_year = pay_vs_dam['year'].min()
+
+ annual_losses = []
+ list_loss_month = []
+ total_payouts = 0
+ total_damages = 0
+ # Iterate directly over year-starts
+ for start_year in range(min_year, min_year + self.number_of_terms):
+ # Collect events for the full term (vectorized selection)
+ events_per_year = [
+ pay_vs_dam[pay_vs_dam['year'] == (start_year + offset)].groupby(['month', 'year']).sum().reset_index().sort_values(by=['year','month'])
+ for offset in range(self.term)
+ ]
+
+ ann_losses_term, monthly_losses, summed_payouts, summed_damages = (
+ self.init_bond_loss(events_per_year)
+ )
+
+ annual_losses.extend(ann_losses_term)
+ list_loss_month.append(monthly_losses)
+ total_payouts += summed_payouts
+ total_damages += summed_damages
+
+ # Combine monthly losses
+ LOGGER.info(list_loss_month)
+ self.df_loss_month = pd.concat(list_loss_month, ignore_index=True)
+
+ annual_losses = pd.Series(annual_losses)
+ exp_loss_ann = annual_losses.mean()
+ att_prob = (annual_losses > 0).mean()
+
+ # Save metrics
+ self.loss_metrics = {
+ 'EL_ann': exp_loss_ann,
+ 'AP_ann': att_prob,
+ 'Tot_payout': total_payouts,
+ 'Tot_damages': total_damages,
+ }
+
+ var_list, es_list = multi_level_es(annual_losses, confidence_levels)
+
+ for cl, var, es in zip(confidence_levels, var_list, es_list):
+ self.loss_metrics[f'VaR_{int(cl*100)}_ann'] = var
+ self.loss_metrics[f'ES_{int(cl*100)}_ann'] = es
+
+ LOGGER.info(f'Expected Loss = {exp_loss_ann}')
+ LOGGER.info(f'Attachment Probability = {att_prob}')
+
+
+
+ '''Simulate over all terms of bond to derive returns'''
+ def init_return_simulation(self, premium):
+ """
+ Simulates the performance of a catastrophe bond over the simulation period, premiums and returns.
+ This function models the bond's payouts, premiums, and returns over a series of simulated years.
+ It aggregates annual and total returns and computes Sharpe ratios.
+
+ Parameters
+ ----------
+ self: bond_simulation
+ An instance of the bond_simulation class containing monthly loss data, premium rate, and term.
+ Returns
+ -------
+ return_metrics (pd.DataFrame): DataFrame containing annual premiums, annual returns, total returns, and total premiums for the bond.
+ """
+
+ premiums_tot = []
+ ncf_tot = []
+ cur_nominal = 1
+ for i in range(len(self.df_loss_month)):
+ losses = self.df_loss_month['losses'].iloc[i]
+ months = self.df_loss_month['months'].iloc[i]
+ if np.sum(losses) == 0:
+ prem_tmp = cur_nominal * premium
+ premiums_tot.append(prem_tmp)
+ ncf_tot.append(prem_tmp)
+ else:
+ ncf_tot_tmp = []
+ premiums_tot_tmp = []
+ prem_tmp = cur_nominal * premium / 12 * months[0]
+ premiums_tot_tmp.append(prem_tmp)
+ ncf_tot_tmp.append(prem_tmp)
+ for j in range(len(losses)):
+ loss = losses[j]
+ month = months[j]
+ cur_nominal -= loss
+ if cur_nominal < 0:
+ loss += cur_nominal
+ cur_nominal = 0
+ else:
+ pass
+ if j + 1 < len(losses):
+ next_month = months[j+1]
+ prem_tmp = ((cur_nominal * premium) / 12 * (next_month - month))
+ premiums_tot_tmp.append(prem_tmp)
+ ncf_tot_tmp.append(prem_tmp - loss)
+ else:
+ prem_tmp = ((cur_nominal * premium) / 12 * (12- month))
+ premiums_tot_tmp.append(prem_tmp)
+ ncf_tot_tmp.append(prem_tmp - loss)
+ ncf_tot.append(np.sum(ncf_tot_tmp))
+ premiums_tot.append(np.sum(premiums_tot_tmp))
+ if (i + 1) % self.term == 0:
+ cur_nominal = 1
+
+ sharpe_ratio = (np.mean(ncf_tot) / np.std(ncf_tot)) if np.std(ncf_tot) != 0 else np.nan
+
+ self.return_metrics = {'annual_premiums': np.array(premiums_tot), 'annual_returns': np.array(ncf_tot),
+ 'total_returns': np.sum(np.array(ncf_tot)) * self.subarea_calc.principal , 'total_premiums': np.sum(np.array(premiums_tot)) * self.subarea_calc.principal,
+ 'sharpe_ratio': sharpe_ratio}
diff --git a/climada_petals/engine/cat_bonds/subarea_calculations.py b/climada_petals/engine/cat_bonds/subarea_calculations.py
new file mode 100644
index 000000000..6bd8c30d1
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/subarea_calculations.py
@@ -0,0 +1,436 @@
+import pandas as pd
+import numpy as np
+from scipy.optimize import minimize
+import logging
+
+# import climada modules
+from climada.engine import ImpactCalc
+
+# set logging basics
+LOGGER = logging.getLogger(__name__)
+
+
+
+class SubareaCalculations:
+ def __init__(self, subareas, index_stat, intitial_guess=None):
+ '''
+ Attributes
+ ----------
+ self.exposure : climada.Exposure
+ Exposure object containing geospatial exposure data (with a GeoDataFrame attribute `gdf`).
+ self.hazard : climada.Hazard
+ Hazard object containing hazard events.
+ self.vulnerability : climada.Vulnerability
+ Vulnerability object containing vulnerability functions.
+ self.subareas : geopandas.GeoDataFrame
+ GeoDataFrame of CAT bond subareas for spatial aggregation of impacts.
+ self.exhaustion_point: float
+ The exhaustion_point value (maximum possible payout) of the CAT bond. If it is a string with 'Exp', it is treated as a
+ share of total exposure. If it is a string with 'RP', it is treated as a return period. If it is a float,
+ it is treated as a monetary value.
+ self.attachment: float
+ The attachment value (minimum possible payout) of the CAT bond. If it is a string with 'Exp', it is treated as a
+ share of total exposure. If it is a string with 'RP', it is treated as a return period. If it is a float,
+ it is treated as a monetary value.
+ self.index_stat: str or float
+ The statistic to calculate. Can either be a number to calculate percentile or the string 'mean' to calculate the average.
+ self.initial_guess: tuple, optional
+ A tuple containing the initial guess for the minimum and maximum trigger thresholds used in the payout function optimization.
+ Will be calculated as the 30th and 60th percentiles of the hazard intensity data if not provided.
+ '''
+
+ self.subareas = subareas
+ self.index_stat = index_stat
+ if intitial_guess is not None:
+ self.initial_guess = intitial_guess
+ else:
+ self.initial_guess = (np.percentile(subareas.hazard.intensity.data, 30), np.percentile(subareas.hazard.intensity.data, 60))
+
+ def _calc_impact(self):
+ """
+ Initializes and calculates impact based on exposure, hazard, vulnerability and optional subareas.
+ This function performs the following steps:
+ 1. Calculates impact using the provided exposure, vulnerability and hazard datasets.
+ 2. If subareas are provided, aggregates impact per subarea using spatial joins.
+
+ Parameters
+ ----------
+ self: class instance
+ Instance of the Subarea_Calculations class.
+
+ Returns
+ -------
+ imp : climada.ImpactCalc
+ Impact calculation object containing results and methods.
+ imp_subareas_evt : pandas.DataFrame
+ DataFrame of aggregated impacts per subarea and event.
+ """
+
+ # perform impact calcualtion
+ imp = ImpactCalc(self.subareas.exposure, self.subareas.vulnerability, self.subareas.hazard).impact(
+ save_mat=True
+ )
+
+ # Perform a spatial join to associate each exposure point with calculated impact with a subarea
+ exp_to_admin = self.subareas.exposure.gdf.sjoin(self.subareas.subareas_gdf, how="left", predicate="within")
+ if exp_to_admin['subarea_letter'].isnull().any():
+ LOGGER.warning("Some exposure points were not assigned to any subarea. Subareas may be to small.")
+ # group each exposure point according to subarea letter
+ agg_exp = exp_to_admin.subarea_letter.to_list()
+ imp_subareas_evt = imp.impact_at_reg(agg_exp)
+
+ return imp, imp_subareas_evt
+
+ def _calc_attachment_principal(self, impact, attachment_point, exhaustion_point, attachment_point_method=None, exhaustion_point_method=None):
+ """
+ Initializes and calculates the attachment point and principal value for a CAT bond.
+ The function determines the attachment point/principal amount based on either a protection return period
+ using the provided climada ImpactCalc object, or as a share of the total exposure value using the toal exposure.
+ If the principal is already a monetary values, it is used directly.
+
+ Parameters
+ ----------
+ self: class instance
+ Instance of the Subarea_Calculations class.
+ impact : climada.ImpactCalc
+ Impact calculation object containing results and methods.
+ attachment_point : float
+ The attachment point value for the CAT bond. Can be expressed as a monetary value, a share of total exposure, or a return period.
+ exhaustion_point : float
+ The exhaustion point value for the CAT bond. Can be expressed as a monetary value, a share of total exposure, or a return period.
+ attachment_point_method : str, optional
+ Method to interpret the attachment point. Options are 'Exposure_Share' or 'Return_Period'. If None, the attachment_point is treated as a monetary value.
+ exhaustion_point_method : str, optional
+ Method to interpret the exhaustion point. Options are 'Exposure_Share' or 'Return_Period'. If None, the exhaustion_point is treated as a monetary value.
+
+ Returns
+ ----------
+ attachment: float
+ The calculated attachment point value for the CAT bond.
+ principal: float
+ The calculated principal value for the CAT bond.
+ """
+
+ tot_exp = self.subareas.exposure.gdf["value"].sum()
+
+ if attachment_point_method is None:
+ attachment = attachment_point
+ elif attachment_point_method == "Exposure_Share":
+ attachment = tot_exp * attachment_point
+ elif attachment_point_method == "Return_Period":
+ attachment = impact.calc_freq_curve(attachment_point).impact
+ else:
+ raise ValueError(
+ "Invalid attachment point method. Choose 'Exposure_Share' or 'Return_Period'."
+ )
+
+ if exhaustion_point_method is None:
+ principal = exhaustion_point
+ elif exhaustion_point_method == "Exposure_Share":
+ principal = tot_exp * exhaustion_point
+ elif exhaustion_point_method == "Return_Period":
+ principal = impact.calc_freq_curve(exhaustion_point).impact
+ else:
+ raise ValueError(
+ "Invalid exhaustion point method. Choose 'Exposure_Share' or 'Return_Period'."
+ )
+
+ LOGGER.info(
+ f"The attachment point and the principal of the CAT bond is: {round(attachment, 3)} and {round(principal, 3)} [USD], respectively."
+ )
+
+ return principal, attachment
+
+ def _calc_parametric_index(self):
+ """
+ Calculates a specified statistic (mean, percentiles) for each events parametrix incex for each subarea.
+
+ Parameters
+ ----------
+ self: class instance
+ Instance of the Subarea_Calculations class.
+
+ Returns
+ -------
+ int_sub_dict: dict
+ A dictionary containing a pandas.DataFrame with the calculated statistics per subarea with labels as columns and year and month for each event.
+ The key to the dataframe is the hazard type (e.g., 'TC' for tropical cyclones).
+ """
+
+ hazard = self.subareas.hazard.centroids.gdf
+ hazard = hazard.to_crs(self.subareas.subareas_gdf.crs)
+ centrs_to_sub = hazard.sjoin(self.subareas.subareas_gdf, how="left", predicate="intersects")
+ agg_exp = centrs_to_sub.groupby("subarea_letter").apply(lambda x: x.index.tolist())
+
+ int_sub = {
+ letter: [np.nan] * len(self.subareas.hazard.event_id) for letter in agg_exp.keys()
+ }
+
+ int_sub["year"] = [0 for _ in range(len(self.subareas.hazard.event_id))]
+ int_sub["month"] = [0 for _ in range(len(self.subareas.hazard.event_id))]
+
+ # Iterate over each event
+ for i in range(len(self.subareas.hazard.event_id)):
+ date = pd.to_datetime(self.subareas.hazard.get_event_date()[i])
+ int_sub["year"][i] = date.year
+ int_sub["month"][i] = date.month
+ # For each subarea, calculate the desired statistic
+ for letter, line_numbers in agg_exp.items():
+ selected_values = self.subareas.hazard.intensity[i, line_numbers]
+ if self.index_stat == "mean":
+ int_sub[letter][i] = selected_values.mean()
+ elif isinstance(self.index_stat, (int, float)):
+ dense_array = selected_values.toarray()
+ flattened_array = dense_array.flatten()
+ int_sub[letter][i] = np.percentile(flattened_array, self.index_stat)
+ else:
+ raise ValueError(
+ "Invalid statistic choice. Choose number for percentile or 'mean'"
+ )
+ int_sub = pd.DataFrame.from_dict(int_sub)
+
+ int_sub_dict = {}
+ int_sub_dict[self.subareas.hazard.haz_type] = int_sub
+
+ return int_sub_dict
+
+ def _objective_fct(self, params, haz_int, damages, principal):
+ """
+ Defines the objective function used to minimize basis risk by adjusting minimum and maximum trigger thresholds in the payout function.
+ This function computes the squared difference between actual damages and payouts,
+ given a set of parameters and hazard intensity data. It determines the maximum payout
+ based on the principal value and observed damages, then calculates payouts using
+ a payout initialization function.
+
+ Parameters
+ ----------
+ self: class instance
+ Instance of the Subarea_Calculations class.
+ params: tuple
+ A tuple containing the minimum and maximum trigger values.
+ haz_int: dict
+ Hazard intensity data.
+ damages: array-like
+ Observed damages for each subarea and hazard event.
+ principal: float
+ The principal value (maximum possible payout).
+
+ Returns
+ -------
+ basis_risk: float
+ The calculated basis risk as the sum of squared differences between damages and payouts.
+ """
+
+ min_trig, max_trig = params
+ max_dam = np.max(damages)
+ if max_dam < principal:
+ max_pay = max_dam
+ else:
+ max_pay = principal
+ payouts = calc_payout(min_trig, max_trig, haz_int, max_pay)
+ arr_damages = np.array(damages)
+ basis_risk = np.sum((arr_damages - payouts) ** 2)
+ return basis_risk
+
+ # funtion to minimze basis risk by adjusting minimum and maximum parametric index thresholds used in the payout funciton
+ def _calibrate_payout_fcts(self, haz_int, principal, attachment, imp_subarea_evt):
+ """
+ Initializes and performs the optimization of the payout function which is based on a paramteric index for each subarea.
+ This function iterates over subareas, selects appropriate initial guesses and damage data depending on the parametric index,
+ and applies the COBYLA optimization algorithm to minimize the objective function (basis risk) for each subarea.
+ The results for each subarea are collected and returned, along with arrays of optimized parameters.
+
+ Parameters
+ ----------
+ self: class instance
+ Instance of the Subarea_Calculations class.
+ attachment : float
+ The attachment point (minimum payout) for payouts.
+ haz_int : dict
+ DataFrame containing paramteric index values for each subarea and additional columns.
+ principal : float
+ Principal of the CAT bond used in the optimization objective function.
+ imp_subarea_evt : pandas.DataFrame
+ Damages per event and subarea.
+
+ Returns
+ -------
+ results : dict
+ Dictionary mapping subarea indices to optimization result objects.
+ opt_min_thresh : numpy.ndarray
+ Array of minimum paramteric index threshold for each subarea
+ opt_max_thresh : numpy.ndarray
+ Array of maximum parametric index threshold for each subarea.
+ """
+ imp_subarea_evt_flt = imp_subarea_evt.copy()
+ imp_subarea_evt_flt.loc[imp_subarea_evt_flt.sum(axis=1) < attachment, :] = 0
+
+ hazard_type = list(haz_int.keys())[0]
+
+ subareas = range(len(haz_int[hazard_type].columns) - 2)
+ subarea_specific_results = {}
+
+ results = {}
+ for subarea in subareas:
+
+ damages = imp_subarea_evt_flt.iloc[:, subarea]
+
+ # Perform optimization for each subarea
+ result = minimize(
+ self._objective_fct,
+ self.initial_guess,
+ args=(haz_int[hazard_type].iloc[:, [subarea, -1]], damages, principal),
+ method="COBYLA",
+ options={"maxiter": 100000},
+ )
+
+ results[subarea] = result
+
+ if result.success:
+ opt_min, opt_max = result.x
+ subarea_specific_results[subarea] = (opt_min, opt_max)
+ else:
+ print(f"Optimization failed for subarea {subarea}: {result.message}")
+
+ opt_min_thresh = np.array(
+ [values[0] for values in subarea_specific_results.values()]
+ )
+ opt_max_thresh = np.array(
+ [values[1] for values in subarea_specific_results.values()]
+ )
+
+ return results, opt_min_thresh, opt_max_thresh
+
+ def _calc_pay_vs_dam(
+ self,
+ impact,
+ imp_subareas_evt,
+ attachment,
+ principal,
+ opt_min_thresh,
+ opt_max_thresh,
+ haz_int,
+ ):
+ """
+ Calculates payouts versus damages for hazard events.
+ This function computes the payout for each event based on optimized threshold parameters and parametric index data.
+ It compares the payouts to the corresponding damages, applying constraints such as minimum payout and principal cap.
+
+ Parameters
+ ----------
+ impact : climada.ImpactCalc
+ Impact calculation object containing results and methods.
+ imp_subareas_evt : pandas.DataFrame
+ Damages per subarea and event used for payout calculations.
+ attachment : float
+ The attachment point (minimum payout) for payouts.
+ principal : float
+ The principal value of the CAT bond.
+ opt_min_thresh : array-like
+ Thresholds for mimimum payouts for each payout function.
+ opt_max_thresh : array-like
+ Thresholds for maximum payouts for each payout function.
+ haz_int : dict
+ Dictionary containing parametric index data for each event, including year and month columns.
+
+ Returns
+ -------
+ pay_dam_df : pandas.DataFrame
+ DataFrame containing calculated payouts, damages, year, and month for each event.
+
+ Notes
+ -----
+ - Payouts are capped at the nominal value and set to zero if below the minimum payout threshold.
+ - The function relies on an external `_calc_payout` function for payout calculation.
+ """
+
+ imp_per_event = impact.at_event
+ imp_per_event_df = pd.DataFrame({"Damage": imp_per_event})
+ imp_per_event_arr = np.array(imp_per_event_df)
+ imp_per_event_arr[imp_per_event_arr < attachment] = 0
+
+ hazard_type = list(haz_int.keys())[0]
+
+ b = len(imp_per_event_arr)
+ max_damage = imp_per_event_arr.max()
+ if max_damage < 1:
+ minimum_payout = 0
+ else:
+ minimum_payout = imp_per_event_arr[imp_per_event_arr > 0].min()
+
+ payout_evt_grd = pd.DataFrame(
+ {letter: [None] * b for letter in haz_int[hazard_type].columns[:-2]}
+ )
+ pay_dam_df = pd.DataFrame(
+ {"pay": [0.0] * b, "damage": [0.0] * b, "year": [0] * b, "month": [0] * b}
+ )
+
+ for i in range(len(imp_per_event_arr)):
+ tot_dam = imp_per_event_arr[i]
+ pay_dam_df.loc[i, "damage"] = tot_dam
+ pay_dam_df.loc[i, "year"] = int(haz_int[hazard_type]["year"][i])
+ pay_dam_df.loc[i, "month"] = int(haz_int[hazard_type]["month"][i])
+ for j in range(len(haz_int[hazard_type].columns) - 2):
+ sub_hazint = haz_int[hazard_type].iloc[:, [j, -1]]
+ max_dam = np.max(imp_subareas_evt.iloc[:, j])
+ if max_dam < principal:
+ max_pay = max_dam
+ else:
+ max_pay = principal
+ payouts = calc_payout(
+ opt_min_thresh[j], opt_max_thresh[j], sub_hazint, max_pay
+ )
+ payout_evt_grd.iloc[:, j] = payouts
+ tot_pay = np.sum(payout_evt_grd.iloc[i, :])
+ if tot_pay > principal:
+ tot_pay = principal
+ elif tot_pay < minimum_payout:
+ tot_pay = 0
+ else:
+ pass
+ pay_dam_df.loc[i, "pay"] = tot_pay
+
+ return pay_dam_df
+
+ def create_pay_vs_dam(self, attachment_point, exhaustion_point, methods_attachment_point=None, methods_exhaustion_point=None):
+
+ imp, imp_subareas_evt = self._calc_impact()
+ parametric_index = self._calc_parametric_index()
+ if methods_attachment_point is not None and methods_exhaustion_point is not None:
+ self.principal, self.attachment = self._calc_attachment_principal(imp, attachment_point, exhaustion_point, methods_attachment_point, methods_exhaustion_point)
+ else:
+ self.principal, self.attachment = exhaustion_point, attachment_point
+ self.results, self.opt_min_thresh, self.opt_max_thresh = self._calibrate_payout_fcts(parametric_index, self.principal, self.attachment, imp_subareas_evt)
+ self.pay_vs_dam = self._calc_pay_vs_dam(impact=imp, imp_subareas_evt=imp_subareas_evt, attachment=self.attachment, principal=self.principal, opt_min_thresh=self.opt_min_thresh, opt_max_thresh=self.opt_max_thresh, haz_int=parametric_index)
+
+
+# this function calculates the payout for an event in a subarea -> defines the payout function
+def calc_payout(min_trig, max_trig, haz_int, max_pay):
+
+ """
+ Calculates payout values based on a linear payout function using hazard intensities and trigger thresholds.
+
+ Parameters
+ ----------
+ min_trig : float
+ The minimum trigger threshold for hazard intensity.
+ max_trig : float
+ The maximum trigger threshold for hazard intensity.
+ haz_int : pandas.DataFrame
+ DataFrame containing hazard intensity values in the first column.
+ max_pay : float
+ The maximum payout value.
+
+ Returns
+ -------
+ payouts : numpy.ndarray
+ Array of calculated payout values corresponding to each hazard intensity.
+ """
+
+ intensities = np.array(haz_int.iloc[:, 0])
+ payouts = np.zeros_like(intensities)
+ payouts[intensities >= max_trig] = max_pay
+ mask = (intensities >= min_trig) & (intensities < max_trig)
+ payouts[mask] = (intensities[mask] - min_trig) / (max_trig - min_trig) * max_pay
+
+ return payouts
diff --git a/climada_petals/engine/cat_bonds/subareas.py b/climada_petals/engine/cat_bonds/subareas.py
new file mode 100644
index 000000000..863686cff
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/subareas.py
@@ -0,0 +1,336 @@
+import numpy as np
+import geopandas as gpd
+from shapely.geometry import box, shape
+import matplotlib.pyplot as plt
+from matplotlib.lines import Line2D
+import pandas as pd
+from shapely.ops import unary_union
+from rasterio.features import shapes, rasterize
+from rasterio.transform import from_bounds
+from sklearn.neighbors import NearestNeighbors
+import cartopy.crs as ccrs
+import networkx as nx
+
+import logging
+
+LOGGER = logging.getLogger(__name__)
+
+
+class Subareas:
+
+ '''Class to handle subareas for CAT bonds.
+
+ Attributes
+ ----------
+ hazard : climada.Hazard
+ Hazard object containing hazard data.
+ vulnerability : climada.Vulnerability
+ Vulnerability object containing vulnerability data.
+ exposure : climada.Exposure
+ Exposure object containing monetary data.
+ resolution : float
+ Resolution for grid cells to create subareas.
+ crs : str, optional
+ Coordinate reference system for spatial data (default: "EPSG:3857").
+ subareas_gdf : geopandas.GeoDataFrame
+ GeoDataFrame containing the subareas as polygons. Needs to contain the whole exposure. If no column subarea_letter is given it will be added.
+ If None, subareas will be generated based on the exposure perimeter and resolution.
+ '''
+
+
+ def __init__(
+ self,
+ hazard,
+ vulnerability,
+ exposure,
+ subareas_gdf,
+ ):
+
+ self.hazard = hazard
+ self.vulnerability = vulnerability
+ self._exposure = exposure
+ self.subareas_gdf = subareas_gdf
+
+ @classmethod
+ def from_resolution(cls, hazard, vulnerability, exposure, resolution, subareas_gdf=None):
+ """Create Subareas instance with specified resolution."""
+ subareas_gdf = cls._init_subareas(exposure, resolution)
+
+ return cls(hazard, vulnerability, exposure, subareas_gdf)
+
+ @classmethod
+ def from_geodataframe(cls, hazard, vulnerability, exposure, gdf):
+ """Create Subareas instance from existing GeoDataFrame."""
+ if (gdf.geometry.type != 'Polygon').any():
+ raise ValueError("All geometries in the GeoDataFrame must be of type 'Polygon'.")
+ exp_gdf = _create_exp_gdf(exposure)
+ logging.info("Number of polygons in exposure perimeter: %d", len(exp_gdf))
+ if gdf.contains(exp_gdf.unary_union).all() is False:
+ raise ValueError("The provided GeoDataFrame does not fully cover the exposure perimeter.")
+ if 'subarea_letter' not in gdf.columns:
+ gdf = gdf.copy()
+ gdf["subarea_letter"] = [chr(65 + i) for i in range(len(gdf))]
+ logging.info("Added 'subarea_letter' column to GeoDataFrame.")
+ subareas_gdf = gdf.crs_convert(exposure.gdf.crs)
+ logging.info("Converted GeoDataFrame to match exposure CRS.")
+ return cls(hazard, vulnerability, exposure, subareas_gdf)
+
+ # --- Properties ---
+ @property
+ def exposure(self):
+ return self._exposure
+
+ def plot(self):
+ if self.subareas_gdf is None:
+ raise ValueError("Subareas have not been generated yet.")
+ else:
+ # Let plot_raster() create the correct cartopy GeoAxes
+ ax = self._exposure.plot_raster()
+
+ # Overlay subareas directly with the correct CRS transform
+ self.subareas_gdf.plot(
+ ax=ax,
+ facecolor="none",
+ edgecolor="red",
+ lw=2,
+ transform=ccrs.PlateCarree(), # CLIMADA rasters use this by default
+ zorder=5,
+ )
+
+ xmin1, ymin1, xmax1, ymax1 = self._exposure.gdf.total_bounds
+ xmin2, ymin2, xmax2, ymax2 = self.subareas_gdf.total_bounds
+
+ xmin = min(xmin1, xmin2)
+ xmax = max(xmax1, xmax2)
+ ymin = min(ymin1, ymin2)
+ ymax = max(ymax1, ymax2)
+
+ # 4️⃣ Add padding (e.g. 5% wider and taller)
+ pad_x = (xmax - xmin) * 0.05 # 10% horizontal padding
+ pad_y = (ymax - ymin) * 0.05 # 5% vertical padding
+
+ ax.set_extent(
+ [xmin - pad_x, xmax + pad_x, ymin - pad_y, ymax + pad_y],
+ crs=ccrs.PlateCarree()
+ )
+
+ # Add legend
+ handles = [Line2D([0], [0], color="red", lw=2, label="Subareas")]
+ ax.legend(handles=handles, loc="upper right")
+
+ plt.show()
+
+ def count_subareas(self):
+ if self.subareas_gdf is None:
+ raise ValueError("Subareas have not been generated yet.")
+ else:
+ return len(self.subareas_gdf)
+
+ @staticmethod
+ def _init_subareas(exposure, resolution):
+ """
+ Divides the exposure set into subareas and returns a geodataframe for the perimeter of exposed assets.
+
+ Parameters
+ ----------
+ exposure : Exposure object
+ Exposure object containing monetary data.
+ resolution : float
+ Resolution for grid cells to create subareas.
+
+ Returns
+ -------
+ subareas_gdf : GeoDataFrame
+ Geodataframe of subareas covering the exposure perimeter.
+ """
+ exp_gdf = _create_exp_gdf(exposure)
+ logging.info("Number of polygons in exposure perimeter: %d", len(exp_gdf))
+ subareas_gdf = _crop_grid_cells_to_polygon(resolution, exp_gdf, exposure)
+ subareas_gdf["subarea_letter"] = [chr(65 + i) for i in range(len(subareas_gdf))]
+
+ return subareas_gdf
+
+def _crop_grid_cells_to_polygon(resolution, exp_gdf, exposure):
+ """
+ Generates subareas based on exposure perimeter stored in a GeoDataFrame.
+ This function takes a GeoDataFrame of polygons and, for each polygon, generates a grid of rectangular cells
+ within its bounding box. Each grid cell is then cropped to the polygon's boundary using geometric intersection.
+ For polygons smaller than a specified minimum area, the polygon itself is retained without cropping.
+ The resulting grid cells are the subareas of the CAT bond.
+
+ Parameters
+ ----------
+ self : class instance
+ Instance of the Subareas class.
+ exp_gdf : geopandas.GeoDataFrame
+ GeoDataFrame containing polygon geometries to be cropped into subareas.
+
+ Returns
+ -------
+ subareas : geopandas.GeoDataFrame
+ GeoDataFrame containing the cropped grid cells for all polygons, with empty geometries removed.
+ """
+ LOGGER.info("Creating subareas from exposure perimeter polygon.")
+ cropped_cells = []
+ LOGGER.info(f"Number of polygons to process: {len(exp_gdf)}")
+ # Loop through each polygon in the GeoDataFrame
+ for idx, polygon in exp_gdf.iterrows():
+
+ # Pad the geometry bounds by 2% of width/height for better coverage
+ minx, miny, maxx, maxy = polygon.geometry.bounds
+ pad_x = (maxx - minx) * 0.02
+ pad_y = (maxy - miny) * 0.02
+ minx -= pad_x
+ maxx += pad_x
+ miny -= pad_y
+ maxy += pad_y
+ LOGGER.info(
+ f"Processing polygon with bounds: {minx}, {miny}, {maxx}, {maxy}"
+ )
+ if maxx - minx < resolution or maxy - miny < resolution:
+ LOGGER.info(
+ "Polygon smaller than resolution; adding polygon bounding box."
+ )
+ # Add a rectangle (bounding box) with 2% buffer around the polygon
+ buffered_bbox = box(minx, miny, maxx, maxy)
+ cropped_cells.append(
+ gpd.GeoDataFrame(geometry=[buffered_bbox], crs=exp_gdf.crs)
+ )
+ continue
+
+ num_cells_x = int((maxx - minx) / resolution) + 1
+ num_cells_y = int((maxy - miny) / resolution) + 1
+ n_cols = int(np.ceil((maxx - minx) / resolution))
+ n_rows = int(np.ceil((maxy - miny) / resolution))
+ LOGGER.info(
+ f"Number of cells in x direction: {num_cells_x}, y direction: {num_cells_y}"
+ )
+
+ grid_cells = []
+ for x in range(n_cols):
+ for y in range(n_rows):
+
+ x1 = minx + x * resolution
+ y1 = miny + y * resolution
+ x2 = x1 + resolution
+ y2 = y1 + resolution
+ grid_cell = box(
+ x1, y1, x2, y2
+ )
+ # Only keep grid cell if at least one exposure point is inside
+ if any(p.within(grid_cell) for p in exposure.gdf.geometry):
+ grid_cells.append(grid_cell)
+ grid_gdf = gpd.GeoDataFrame(
+ grid_cells, columns=["geometry"], crs=exp_gdf.crs
+ )
+
+ cropped_cells.append(grid_gdf)
+
+ grids = gpd.GeoDataFrame(
+ pd.concat(cropped_cells, ignore_index=True), crs=exp_gdf.crs
+ )
+
+ # Merge overlapping grid cells into single polygons
+ merged_grids = _merge_overlapping_grids(grids)
+ merged_grids.reset_index(drop=True, inplace=True)
+ subareas = merged_grids[~merged_grids.is_empty]
+ subareas = subareas.reset_index(drop=True)
+ LOGGER.info("Subareas created.")
+
+ return subareas
+
+def _create_exp_gdf(exposure):
+ """
+ Generates a merged polygon representing the geometric extent of the exposed assets.
+ This function rasterizes the geometries in the input exposure object, identifies contiguous regions
+ where the exposure value is greater than zero, and merges these regions into a single polygon.
+ The result is returned as a GeoDataFrame with the specified coordinate reference system.
+
+ Parameters
+ ----------
+ self : class instance
+ Instance of the Subareas class.
+
+ Returns
+ -------
+ exp_gdf : geopandas.GeoDataFrame
+ A GeoDataFrame containing a single merged polygon geometry representing the geometric extent of
+ the country in the specified CRS.
+ """
+
+ LOGGER.info("Creating exposure perimeter polygon from exposure data.")
+ exp_gdf = exposure.gdf
+ minx, miny, maxx, maxy = exp_gdf.total_bounds
+ LOGGER.info(f"Exposure total bounds: {minx}, {miny}, {maxx}, {maxy}")
+ coords = np.vstack((exp_gdf.geometry.x, exp_gdf.geometry.y)).T
+ nbrs = NearestNeighbors(n_neighbors=2).fit(coords)
+ distances, _ = nbrs.kneighbors(coords)
+ res = distances[:, 1].mean() * 1.2
+ LOGGER.info(f"Approximate resolution: {res} CRS units")
+ width = max(int((maxx - minx) / res), 1)
+ height = max(int((maxy - miny) / res),1)
+ LOGGER.info(f"Rasterizing exposure with width: {width}, height: {height}")
+
+ transform = from_bounds(minx, miny, maxx, maxy, width, height)
+ shapes_gen = (
+ (geom, value) for geom, value in zip(exp_gdf.geometry, exp_gdf["value"])
+ )
+ raster = rasterize(
+ shapes=shapes_gen,
+ out_shape=(height, width),
+ transform=transform,
+ fill=0,
+ dtype="float32",
+ )
+ mask = raster > 0
+ shapes_gen = list(shapes(raster, mask=mask, transform=transform))
+ polygons = [shape(geom) for geom, value in shapes_gen if value > 0]
+ exp_gdf_sep = gpd.GeoDataFrame(geometry=polygons, crs=exp_gdf.crs)
+ merged_exp_gdf_sep = unary_union(exp_gdf_sep.geometry)
+ exp_gdf = gpd.GeoDataFrame(geometry=[merged_exp_gdf_sep], crs=exp_gdf.crs).explode(ignore_index=True, index_parts=True)
+ LOGGER.info("Exposure perimeter polygon created.")
+
+ return exp_gdf
+
+def _merge_overlapping_grids(gdf: gpd.GeoDataFrame) -> gpd.GeoDataFrame:
+ """
+ Merges overlapping grid cells in a GeoDataFrame into single polygons using NetworkX.
+
+ Parameters
+ ----------
+ gdf (gpd.GeoDataFrame): GeoDataFrame containing grid cell geometries.
+
+ Returns
+ -------
+ gpd.GeoDataFrame: GeoDataFrame with merged polygons.
+ """
+
+ LOGGER.info("Merging overlapping grid cells into single polygons.")
+ geoms = gdf.geometry.tolist()
+ # Step 1: Remove polygons strictly within others
+ to_remove = set()
+ for i, geom in enumerate(geoms):
+ for j, candidate in enumerate(geoms):
+ if i == j or j in to_remove:
+ continue
+ if geom.within(candidate):
+ to_remove.add(i)
+ elif candidate.within(geom):
+ to_remove.add(j)
+ geoms_filtered = [geom for i, geom in enumerate(geoms) if i not in to_remove]
+ # Step 2: Merge polygons that overlap with positive area
+ G = nx.Graph()
+ G.add_nodes_from(range(len(geoms_filtered)))
+ for i, geom in enumerate(geoms_filtered):
+ for j, candidate in enumerate(geoms_filtered):
+ if i >= j:
+ continue
+ if geom.intersection(candidate).area > 1e-9:
+ G.add_edge(i, j)
+ merged_polys = [
+ gpd.GeoSeries([geoms_filtered[idx] for idx in comp]).unary_union
+ for comp in nx.connected_components(G)
+ ]
+ merged_gdf = gpd.GeoDataFrame(geometry=merged_polys, crs=gdf.crs)
+ LOGGER.info("Merging completed.")
+ return merged_gdf
\ No newline at end of file
diff --git a/climada_petals/engine/cat_bonds/test/test_premium_class.py b/climada_petals/engine/cat_bonds/test/test_premium_class.py
new file mode 100644
index 000000000..e34198e27
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/test/test_premium_class.py
@@ -0,0 +1,53 @@
+import numpy as np
+import pandas as pd
+import logging
+from climada_petals.engine.cat_bonds.premium_class import PremiumCalculations
+
+logging.basicConfig(
+ format="{asctime} - {levelname} - {message}",
+ style="{",
+ datefmt="%Y-%m-%d %H:%M",
+ level=logging.INFO,
+ )
+LOGGER = logging.getLogger(__name__)
+
+class DummyBondSim:
+ """Minimum mock needed for PremiumCalculations."""
+ def __init__(self, EL_ann, term, df_loss_month=None):
+ self.loss_metrics = {"EL_ann": EL_ann}
+ self.term = term
+ self.df_loss_month = df_loss_month
+
+
+def test_find_sharpe():
+ """
+ Validate net cash flow logic.
+ 1 year, 1 loss in June, simple numbers.
+ """
+ df = pd.DataFrame({
+ "losses": [[0], [0], [0], [0], [0], [0.1]],
+ "months": [[], [], [], [], [] , [1]]
+ })
+ LOGGER.info(df)
+ dummy_el = 0.1
+ bond = DummyBondSim(EL_ann=dummy_el, term=1, df_loss_month=df)
+ pc = PremiumCalculations(bond)
+ manual_premium = 0.1
+ # manually compute NCF with premium=0.1:
+ # Year 1-5:
+ # - NCF: 0.1
+ # Year 6:
+ # - Pre-event NCF: (1.0 * 0.1)/12 * 1 = 0.008333333333333333
+ # - Post-event NCF: (0.8 * 0.1)/12 * (12 - 1) - 0.1 = -0.0175
+ # NCF = 0.008333333333333333 - 0.0175 = -0.009166666666666668
+ NCF_manual = [0.1, 0.1, 0.1, 0.1, 0.1, -0.009166666666666668]
+ manual_sharpe = (np.mean(NCF_manual) / np.std(NCF_manual))
+
+ pc.calc_benchmark_premium(target_sharpe=manual_sharpe)
+
+ assert np.isclose(np.array(pc.benchmark_prem_rate), np.array(manual_premium), rtol=1e-6)
+
+
+if __name__ == "__main__":
+ test_find_sharpe()
+ LOGGER.info("test_find_sharpe passed")
diff --git a/climada_petals/engine/cat_bonds/test/test_sng_bond.py b/climada_petals/engine/cat_bonds/test/test_sng_bond.py
new file mode 100644
index 000000000..0ac0eeb05
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/test/test_sng_bond.py
@@ -0,0 +1,129 @@
+import pandas as pd
+import numpy as np
+import logging
+from climada_petals.engine.cat_bonds.sng_bond_simulation import SingleCountryBondSimulation
+
+logging.basicConfig(
+ format="{asctime} - {levelname} - {message}",
+ style="{",
+ datefmt="%Y-%m-%d %H:%M",
+ level=logging.INFO,
+ )
+LOGGER = logging.getLogger(__name__)
+
+class DummySubareaCalc:
+ def __init__(self, principal=100):
+ self.principal = principal
+ self.pay_vs_dam = pd.DataFrame() # DataFrame to be set in tests
+
+def test_init_bond_loss():
+ sub = DummySubareaCalc(principal=100)
+ sim = SingleCountryBondSimulation(subarea_calc=sub, term=1, number_of_terms=1)
+
+ # Year 0 events:
+ df = pd.DataFrame({
+ "month": [1, 2, 3],
+ "pay": [30, 50, 60], # cumulative = 30, 80 → exhaust occurs at event 2
+ "damage":[40, 60, 70]
+ })
+
+ rel_losses, df_month, tot_pay, tot_dam = sim.init_bond_loss([df])
+
+ # principal exhausted at payout 2: payout[2] becomes (100 - 80) = 20
+ assert np.allclose(rel_losses.values, [100/100])
+ assert np.allclose(tot_pay, 100)
+ assert tot_dam == 40 + 60 + 70
+
+ # Monthly losses divided by principal
+ assert df_month["losses"].iloc[0] == [0.30, 0.50, 0.20]
+ assert df_month["months"].iloc[0] == [1, 2, 3]
+
+def test_init_loss_simulation():
+ sub = DummySubareaCalc(principal=100)
+
+ sub.pay_vs_dam = pd.DataFrame({
+ "year": [2000,2000,2001,2001,2002,2002, 2003,2003],
+ "month": [1, 2, 1, 2, 1, 2, 1, 2],
+ "pay": [0, 10, 50, 0, 100, 0, 0, 0],
+ "damage":[0, 20, 60, 0, 120, 0, 0, 0],
+ })
+
+ sim = SingleCountryBondSimulation(subarea_calc=sub, term=3, number_of_terms=2)
+ sim.init_loss_simulation(confidence_levels=[0.95])
+
+ # Expected annual losses for each year
+ # 2000 → 10
+ # 2001 → 50
+ # 2002 → 40
+ expected = np.array([10/100, 50/100, 40/100, 50/100, 50/100, 0/100])
+ actual = sim.df_loss_month["losses"].apply(sum).to_numpy()
+
+ assert np.allclose(actual, expected)
+
+ metrics = sim.loss_metrics
+ assert np.isclose(metrics["EL_ann"], expected.mean())
+ assert np.isclose(metrics["AP_ann"], (expected > 0).mean())
+ assert metrics["Tot_payout"] == 10 + 50 + 40 + 50 + 50 + 0
+ assert metrics["Tot_damages"] == 20 + 60 + 120 + 60 + 120 + 0
+
+ # VaR and ES present
+ assert "VaR_95_ann" in metrics
+ assert "ES_95_ann" in metrics
+
+def test_init_return_simulation():
+ sub = DummySubareaCalc(principal=100)
+ sim = SingleCountryBondSimulation(subarea_calc=sub, term=3, number_of_terms=2)
+
+ # Create simple df_loss_month:
+ # Year 0: no losses → full premium
+ # Year 1: one loss at month 3 of size 0.20
+ sim.df_loss_month = pd.DataFrame({
+ "losses": [[0.0], [0.25, 0.25], [0.5], [0.25, 0.25], [0.5], [0.2]],
+ "months": [[1], [3, 12], [1], [3, 12], [1], [1]]
+ })
+
+ sim.init_return_simulation(premium=0.1)
+
+ out = sim.return_metrics
+ # First Term:
+ # Year 0 premium: 100 * 0.1 = 10
+ # Year 1 premium:
+ # - first premium: month 3: 100 * 0.1/12 * 3 = 2.5
+ # - loss at month 3: 0.25 * 100 = 25 → new nominal = 75
+ # - second premium: month 3 to 12: 75 * 0.1/12 * 9 = 5.625
+ # - loss at month 12: 0.25 * 100 = 25 → new nominal = 50
+ # Total prem year 1 = 8.125
+ # Year 2 premium:
+ # - first premium month 1: 50 * 0.1/12 * 1 = 0.4167
+ # - loss at month 1: 0.5 * 100 = 50 → new nominal = 0
+ # - premium for rest of year = 0
+ # Total premium year 2: 0.4167
+
+ # Second term:
+ # Year 0 premium:
+ # - first premium: month 3: 100 * 0.1/12 * 3 = 2.5
+ # - loss at month 3: 0.25 * 100 = 25 → new nominal = 75
+ # - second premium: month 3 to 12: 75 * 0.1/12 * 9 = 5.625
+ # - loss at month 12: 0.25 * 100 = 25 → new nominal = 50
+ # Total prem year 0 = 8.125
+ # Year 1 premium:
+ # - first premium month 1: 50 * 0.1/12 * 1 = 0.4167
+ # - loss at month 1: 0.5 * 100 = 50 → new nominal = 0
+ # - premium for rest of year = 0
+ # Total premium year 2: 0.4167
+ # Year 3 premium:
+ # Total premium year 3: 0 (as principal is depleted)
+ assert np.allclose(out["annual_premiums"], [10/100, 8.125/100, 0.4167/100, 8.125/100, 0.4167/100, 0], atol=1e-3)
+
+ # Returns:
+ # Premiums - losses
+ assert np.allclose(out["annual_returns"], [10/100, (8.125/100)-0.5, 0.4167/100-0.5, (8.125/100)-0.5, 0.4167/100-0.5, 0], atol=1e-3)
+
+
+if __name__ == "__main__":
+ test_init_bond_loss()
+ LOGGER.info("test_init_bond_loss passed")
+ test_init_loss_simulation()
+ LOGGER.info("test_init_loss_simulation passed")
+ test_init_return_simulation()
+ LOGGER.info("test_init_return_simulation passed")
\ No newline at end of file
diff --git a/climada_petals/engine/cat_bonds/test/test_subarea.py b/climada_petals/engine/cat_bonds/test/test_subarea.py
new file mode 100644
index 000000000..92c48d509
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/test/test_subarea.py
@@ -0,0 +1,106 @@
+import geopandas as gpd
+from shapely.geometry import Point, MultiPolygon, Polygon
+import logging
+from climada_petals.engine.cat_bonds import subareas
+
+logging.basicConfig(
+ format="{asctime} - {levelname} - {message}",
+ style="{",
+ datefmt="%Y-%m-%d %H:%M",
+ level=logging.INFO,
+ )
+LOGGER = logging.getLogger(__name__)
+
+
+class DummyExposure:
+ """Simple container to mimic the expected `exposure` object"""
+ def __init__(self, gdf):
+ self.gdf = gdf
+
+
+def test_create_exp_gdf_returns_single_polygon():
+ # --- Arrange -------------------------------------------------------------------
+ # Create a small GeoDataFrame with two points that have non-zero "value"
+ geometry = [Point(x, y) for x in range(5) for y in range(4)]
+ geometry = geometry[:20]
+ gdf = gpd.GeoDataFrame(
+ {"value": [1] * 8 + [0] * 4 + [1] * 8},
+ geometry=geometry,
+ crs="EPSG:4326"
+ )
+
+ exposure = DummyExposure(gdf)
+
+ # --- Act -----------------------------------------------------------------------
+ result = subareas._create_exp_gdf(exposure)
+ LOGGER.info(f"Resulting GeoDataFrame:\n{result}")
+
+ # --- Assert --------------------------------------------------------------------
+ # 1. Should contain exactly one merged polygon
+ assert len(result.geometry) == 2
+
+ # 2. All geometries should be of type Polygon and not empty
+ for geom in result.geometry:
+ assert isinstance(geom, Polygon) or isinstance(geom, MultiPolygon)
+ assert not geom.is_empty
+
+ # 3. Check it is within the bounding box of the points
+ minx, miny, maxx, maxy = gdf.total_bounds
+ res_minx, res_miny, res_maxx, res_maxy = geom.bounds
+
+ assert res_minx >= minx - 1e-6
+ assert res_miny >= miny - 1e-6
+ assert res_maxx <= maxx + 1e-6
+ assert res_maxy <= maxy + 1e-6
+
+ return exposure, result
+
+def test_crop_grid_cells_to_polygon(exp_gdf, exposure):
+ resolution = 1.0
+ subareas_gdf = subareas._crop_grid_cells_to_polygon(resolution, exp_gdf, exposure)
+
+ assert not subareas_gdf.empty, "Subareas GeoDataFrame should not be empty."
+ subareas_gdf.plot()
+ assert len(subareas_gdf) == 16, "There should be 16 subareas created."
+ subareas_union = subareas_gdf.unary_union
+ assert all(
+ subareas_union.contains(geom) for geom in exp_gdf.geometry
+ ), "Exposure should be within the exposure perimeter polygon."
+
+def test_merge_overlapping_grids():
+ polygon_over = [
+ Polygon([(0, 0), (2, 0), (2, 2), (0, 2)]),
+ Polygon([(1, 1), (3, 1), (3, 3), (1, 3)]),
+ Polygon([(4, 4), (5, 4), (5, 5), (4, 5)])
+ ]
+ gdf_over = gpd.GeoDataFrame(geometry=polygon_over, crs="EPSG:4326")
+ merged_gdf = subareas._merge_overlapping_grids(gdf_over)
+ assert len(merged_gdf) == 2, "There should be 2 merged polygons."
+ assert merged_gdf.unary_union.equals(gdf_over.unary_union), "The merged geometries should cover the same area as the original."
+
+ polygon_not_over = [
+ Polygon([(0, 0), (1, 0), (1, 1), (0, 1)]),
+ Polygon([(2, 2), (3, 2), (3, 3), (2, 3)]),
+ Polygon([(4, 4), (5, 4), (5, 5), (4, 5)])
+ ]
+ gdf_not_over = gpd.GeoDataFrame(geometry=polygon_not_over, crs="EPSG:4326")
+ merged_gdf_not_over = subareas._merge_overlapping_grids(gdf_not_over)
+ assert len(merged_gdf_not_over) == 3, "There should be 3 polygons as there are no overlaps."
+ assert merged_gdf_not_over.equals(gdf_not_over), "The merged GeoDataFrame should be identical to the input."
+
+ polygon_within = [
+ Polygon([(0, 0), (4, 0), (4, 4), (0, 4)]),
+ Polygon([(1, 1), (2, 1), (2, 2), (1, 2)]),
+ Polygon([(3, 3), (3.5, 3), (3.5, 3.5), (3, 3.5)])
+ ]
+ gdf_within = gpd.GeoDataFrame(geometry=polygon_within, crs="EPSG:4326")
+ merged_gdf_within = subareas._merge_overlapping_grids(gdf_within)
+ assert len(merged_gdf_within) == 1, "There should be 1 merged polygon."
+ assert merged_gdf_within.unary_union.equals(gdf_within.unary_union), "The merged geometries should cover the same area as the original."
+
+
+
+if __name__ == "__main__":
+ exposure, exp_gdf = test_create_exp_gdf_returns_single_polygon()
+ test_crop_grid_cells_to_polygon(exp_gdf, exposure)
+ test_merge_overlapping_grids()
diff --git a/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py b/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py
new file mode 100644
index 000000000..94ff4a296
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py
@@ -0,0 +1,183 @@
+import numpy as np
+import pandas as pd
+import geopandas as gpd
+from climada_petals.engine.cat_bonds import subarea_calculations
+from climada.hazard import Hazard
+from climada.hazard.centroids import Centroids
+from scipy import sparse
+from shapely.geometry import Polygon
+import logging
+logging.basicConfig(
+ format="{asctime} - {levelname} - {message}",
+ style="{",
+ datefmt="%Y-%m-%d %H:%M",
+ level=logging.INFO,
+ )
+LOGGER = logging.getLogger(__name__)
+
+def test_calc_payout_basic():
+ """Test basic functionality of calc_payout function."""
+
+ haz_int = pd.DataFrame({"intensity": [0, 5, 10, 15, 20]})
+ min_trig = 5
+ max_trig = 15
+ max_pay = 100
+
+ payouts = subarea_calculations.calc_payout(min_trig, max_trig, haz_int, max_pay)
+
+ # Expected:
+ # intensity < 5 → 0
+ # 5 → 0
+ # 10 → 50
+ # ≥ 15 → 100
+ assert np.allclose(payouts, [0, 0, 50, 100, 100])
+
+def test_calc_attachment_principal_expected():
+
+ class DummyImpact:
+ def calc_freq_curve(self, rp):
+ return type("obj", (), {"impact": rp * 10}) # simple mapping
+
+ class Dummy:
+ exposure = type("exp", (), {"gdf": {"value": pd.Series([100, 300])}})
+ pass
+
+ dummy = Dummy()
+
+ s = subarea_calculations.SubareaCalculations(dummy, index_stat="mean", intitial_guess=[1,2])
+
+ imp = DummyImpact()
+
+ # Exposure share: 0.1 → 40, 0.5 → 200
+ principal, attachment = s._calc_attachment_principal(
+ imp,
+ attachment_point=0.1,
+ exhaustion_point=0.5,
+ attachment_point_method="Exposure_Share",
+ exhaustion_point_method="Exposure_Share",
+ )
+
+ assert attachment == 40
+ assert principal == 200
+
+ # Return period method (rp→impact=rp*10)
+ principal_rp, attachment_rp = s._calc_attachment_principal(
+ imp,
+ attachment_point=5,
+ exhaustion_point=20,
+ attachment_point_method="Return_Period",
+ exhaustion_point_method="Return_Period",
+ )
+ assert attachment_rp == 50
+ assert principal_rp == 200
+
+def test_calc_parametric_index():
+ centroids = Centroids(lat=np.array([0, 1, 3, 4]), lon=np.array([0, 1, 3, 4]))
+ hazard_dummy = Hazard(haz_type="TC",
+ event_id=np.array([0, 1]),
+ event_name=["evt1", "evt2"],
+ date=np.array([700101, 700102]),
+ intensity=sparse.csr_matrix(np.array([[10, 20, 20, 40], [30, 40, 0, 40]])),
+ centroids=centroids,
+ units="m/s")
+
+ class DummySubareas:
+ hazard = hazard_dummy
+ d = {'subarea_letter': ['A', 'B'], 'geometry': [Polygon([(0, 0), (2, 0), (2, 2), (0, 2)]), Polygon([(3, 3), (5, 3), (5, 5), (3, 5)])]}
+ subareas_gdf = gpd.GeoDataFrame(d, crs="EPSG:4326")
+
+ subareas_dummy = DummySubareas()
+ subareas_calc_dummy = subarea_calculations.SubareaCalculations(
+ subareas=subareas_dummy, index_stat="mean"
+ )
+
+ out = subareas_calc_dummy._calc_parametric_index()
+
+ df = out["TC"]
+
+ # For mean, event 0: mean(10,20)=15; event1: mean(30,40)=35
+ assert df["A"].tolist() == [15, 35]
+ assert df["B"].tolist() == [30, 20]
+ assert df["year"].tolist() == [1917, 1917]
+ assert df["month"].tolist() == [10, 10]
+
+ subareas_calc_dummy_2 = subarea_calculations.SubareaCalculations(
+ subareas=subareas_dummy, index_stat=50
+ )
+
+ out_2 = subareas_calc_dummy_2._calc_parametric_index()
+
+ df_2 = out_2["TC"]
+
+ # For mean, event 0: mean(10,20)=15; event1: mean(30,40)=35
+ assert df_2["A"].tolist() == [15, 35]
+ assert df_2["B"].tolist() == [30, 20]
+
+def test_calc_pay_vs_dam_expected():
+
+ class DummyImpact:
+ at_event = np.array([10, 70]) # event damages
+
+ imp = DummyImpact()
+
+ imp_sub = pd.DataFrame({"A": [0, 30], "B": [5, 40]})
+
+ haz_int = {"TC": pd.DataFrame({
+ "A": [1, 2],
+ "B": [3, 4],
+ "year": [2000, 2000],
+ "month": [1, 2]
+ })}
+
+ s = subarea_calculations.SubareaCalculations(subareas=None, index_stat="mean", intitial_guess=[1,2])
+
+ # thresholds
+ min_t = np.array([1, 0])
+ max_t = np.array([2, 4])
+
+ df = s._calc_pay_vs_dam(
+ imp, imp_sub, attachment=0, principal=50,
+ opt_min_thresh=min_t, opt_max_thresh=max_t, haz_int=haz_int
+ )
+
+ # event 0: no payouts → 0
+ assert df.loc[0,"pay"] == 30
+ # event 1: A pays 30 + B pays 40 → capped at principal = 50
+ assert df.loc[1,"pay"] == 50
+ # year/month copied
+ assert df["year"].tolist() == [2000, 2000]
+ assert df["month"].tolist() == [1, 2]
+
+def test_objective_fct_expected():
+
+ class Dummy:
+ pass
+
+ s = subarea_calculations.SubareaCalculations(subareas=Dummy(), index_stat="mean", intitial_guess=(0, 1))
+
+ damages = np.array([0, 10, 20])
+ haz_int = pd.DataFrame({
+ "A": np.array([0, 1, 2]),
+ "year": [2000, 2000, 2000],
+ "month": [1, 1, 1]
+ })
+
+ # principal less than max_dam → max_pay = principal
+ principal = 20
+
+ out = s._objective_fct((0, 2), haz_int, damages, principal)
+
+ # expected = (0-0)^2 + (10-10)^2 + (20-20)^2 = 0 + 25 + 25 = 0
+ assert out == 0
+
+if __name__ == "__main__":
+ test_calc_payout_basic()
+ LOGGER.info("test_calc_payout_basic passed")
+ test_calc_attachment_principal_expected()
+ LOGGER.info("test_calc_attachment_principal_expected passed")
+ test_calc_parametric_index()
+ LOGGER.info("test_calc_parametric_index passed")
+ test_calc_pay_vs_dam_expected()
+ LOGGER.info("test_calc_pay_vs_dam_expected passed")
+ test_objective_fct_expected()
+ LOGGER.info("test_objective_fct_expected passed")
diff --git a/climada_petals/engine/cat_bonds/test/test_utils_cat_bonds.py b/climada_petals/engine/cat_bonds/test/test_utils_cat_bonds.py
new file mode 100644
index 000000000..fc6072251
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/test/test_utils_cat_bonds.py
@@ -0,0 +1,63 @@
+import pandas as pd
+import numpy as np
+import logging
+from climada_petals.engine.cat_bonds import utils_cat_bonds
+
+logging.basicConfig(
+ format="{asctime} - {levelname} - {message}",
+ style="{",
+ datefmt="%Y-%m-%d %H:%M",
+ level=logging.INFO,
+ )
+LOGGER = logging.getLogger(__name__)
+
+def test_multi_level_es_basic():
+ losses = pd.Series([0, 1, 2, 3, 4, 5])
+ alphas = [0.5, 0.8]
+
+ var_list, es_list = utils_cat_bonds.multi_level_es(losses, alphas)
+
+ # VaR checks
+ assert np.isclose(var_list[0], losses.quantile(0.5))
+ assert np.isclose(var_list[1], losses.quantile(0.8))
+
+ # ES checks (mean of tail losses > VaR)
+ es_expected_50 = losses[losses > var_list[0]].mean() # type: ignore
+ es_expected_80 = losses[losses > var_list[1]].mean() # type: ignore
+
+ assert np.isclose(es_list[0], es_expected_50)
+ assert np.isclose(es_list[1], es_expected_80)
+
+
+def test_multi_level_es_all_equal_losses():
+ losses = pd.Series([1, 1, 1, 1])
+ alphas = [0.95]
+
+ var_list, es_list = utils_cat_bonds.multi_level_es(losses, alphas)
+
+ # VaR = 1
+ assert var_list[0] == 1
+
+ # ES = 1
+ assert es_list[0] == 1
+
+
+def test_multi_level_es_no_tail_losses():
+ losses = pd.Series([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
+ alphas = [0.9] # VaR = 0
+
+ var_list, es_list = utils_cat_bonds.multi_level_es(losses, alphas)
+
+ # VaR must be 0
+ assert var_list[0] == 0
+
+ # ES must be 1
+ assert es_list[0] == 1
+
+if __name__ == "__main__":
+ test_multi_level_es_basic()
+ LOGGER.info("test_multi_level_es_basic passed")
+ test_multi_level_es_all_equal_losses()
+ LOGGER.info("test_multi_level_es_all_equal_losses passed")
+ test_multi_level_es_no_tail_losses()
+ LOGGER.info("test_multi_level_es_no_tail_losses passed")
\ No newline at end of file
diff --git a/climada_petals/engine/cat_bonds/utils_cat_bonds.py b/climada_petals/engine/cat_bonds/utils_cat_bonds.py
new file mode 100644
index 000000000..3960a5f68
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/utils_cat_bonds.py
@@ -0,0 +1,59 @@
+import numpy as np
+
+'''Calculate value at risk and expected shorfall for various alphas'''
+def multi_level_es(losses, confidence_levels):
+ """
+ Calculate Value at Risk (VaR) and Expected Shortfall (ES) for multiple confidence levels.
+
+ Parameters:
+ - losses: array-like, list of losses
+ - confidence_levels: list of floats, confidence levels (e.g., [0.95, 0.99])
+
+ Returns:
+ - var_list: list, list of VaR values in the order of given confidence levels
+ - es_list: list, list of ES values in the order of given confidence levels
+ """
+
+ # Compute VaR and ES
+ var_list = [losses.quantile(confidence_level) for confidence_level in confidence_levels]
+
+ # Avoid empty slices by using conditional logic
+ es_list = [
+ 1 if var == 1 else losses[losses > var].mean()
+ for var in var_list
+ ]
+
+ return var_list, es_list
+
+
+def allocate_single_payout(payout, nominals):
+ """
+ Vectorised allocation of one payout across tranche nominals (FIFO).
+
+ Parameters
+ ----------
+ payout : float
+ nominals : 1D array of tranche nominal values
+
+ Returns
+ -------
+ alloc : array of size (T,) -- how much each tranche pays
+ remaining_nominals : array -- leftover nominals after the payout
+ """
+
+ nominals = np.asarray(nominals, float)
+
+ # cumulative nominal capacity per tranche
+ cum_nom = np.cumsum(nominals)
+ cum_nom_prev = cum_nom - nominals
+
+ # intersection of [0, payout] with each tranche interval [cum_nom_prev, cum_nom]
+ payout_per_tranche = np.minimum(cum_nom, payout) - np.maximum(cum_nom_prev, 0)
+
+ # clip negative / unused intervals
+ payout_per_tranche = np.clip(payout_per_tranche, 0, None)
+
+ remaining_nominals = nominals - payout_per_tranche
+
+
+ return remaining_nominals, payout_per_tranche
\ No newline at end of file
diff --git a/doc/tutorial/climada_engine_CATBonds.ipynb b/doc/tutorial/climada_engine_CATBonds.ipynb
new file mode 100644
index 000000000..94ac84cda
--- /dev/null
+++ b/doc/tutorial/climada_engine_CATBonds.ipynb
@@ -0,0 +1,796 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "a6544fc4",
+ "metadata": {},
+ "source": [
+ "### Import packages"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "48c2d418",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "The autoreload extension is already loaded. To reload it, use:\n",
+ " %reload_ext autoreload\n"
+ ]
+ },
+ {
+ "ename": "ModuleNotFoundError",
+ "evalue": "No module named 'climada_petals.engine.cat_bonds'",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
+ "\u001b[31mModuleNotFoundError\u001b[39m Traceback (most recent call last)",
+ "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[3]\u001b[39m\u001b[32m, line 4\u001b[39m\n\u001b[32m 1\u001b[39m get_ipython().run_line_magic(\u001b[33m'\u001b[39m\u001b[33mload_ext\u001b[39m\u001b[33m'\u001b[39m, \u001b[33m'\u001b[39m\u001b[33mautoreload\u001b[39m\u001b[33m'\u001b[39m)\n\u001b[32m 2\u001b[39m get_ipython().run_line_magic(\u001b[33m'\u001b[39m\u001b[33mautoreload\u001b[39m\u001b[33m'\u001b[39m, \u001b[33m'\u001b[39m\u001b[33m2\u001b[39m\u001b[33m'\u001b[39m)\n\u001b[32m----> \u001b[39m\u001b[32m4\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mclimada_petals\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mengine\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mcat_bonds\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m *\n\u001b[32m 5\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mclimada_petals\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mengine\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mcat_bonds\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01msubareas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Subareas\n\u001b[32m 6\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mclimada_petals\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mengine\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mcat_bonds\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01msubarea_calculations\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m SubareaCalculations\n",
+ "\u001b[31mModuleNotFoundError\u001b[39m: No module named 'climada_petals.engine.cat_bonds'"
+ ]
+ }
+ ],
+ "source": [
+ "%load_ext autoreload\n",
+ "%autoreload 2\n",
+ "\n",
+ "from climada_petals.engine.cat_bonds.subareas import Subareas\n",
+ "from climada_petals.engine.cat_bonds.subarea_calculations import SubareaCalculations\n",
+ "from climada_petals.engine.cat_bonds.sng_bond_simulation import SingleCountryBondSimulation\n",
+ "from climada_petals.engine.cat_bonds.mlt_bond_simulation import MultiCountryBondSimulation\n",
+ "from climada_petals.engine.cat_bonds.premium_class import PremiumCalculations\n",
+ "\n",
+ "from climada.hazard import TCTracks, Centroids, TropCyclone\n",
+ "from climada.entity import LitPop\n",
+ "from climada.entity import ImpfSetTropCyclone\n",
+ "import numpy as np"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "78ef3cc2",
+ "metadata": {},
+ "source": [
+ "### Set CAT Bond Basics"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "id": "89b53a88",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "### Bond Basics ###\n",
+ "countries = [659, 388, 84] # St. Kitts and Nevis, Jamaica, Belize\n",
+ "exhaustion_point = 0.5 # principal should be 50% of exposure \n",
+ "attachment_point = 0.05 # minimum payout should be 5% of exposure\n",
+ "exhaustion_point_method = 'Exposure_Share' # could also be \"Return_Period\" or None\n",
+ "attachment_point_method = 'Exposure_Share' # could also be \"Return_Period\" or None\n",
+ "term = 3 # term of bond in years\n",
+ "num_of_terms = 20 # number of terms to simulate\n",
+ "par_index = 60 # statistic for parametric index (e.g. 60 for 60th percentile)\n",
+ "\n",
+ "### Subarea Basics ###\n",
+ "resolution_st_kitts = 0.05 # resolution used to derive subareas for St. Kitts and Nevis\n",
+ "resolution_jamaica = 0.5 # resolution used to derive subareas for Jamaica\n",
+ "resolution_belize = 0.5 # resolution used to derive subareas for Belize\n",
+ "\n",
+ "### Pricing Basics ###\n",
+ "peak_peril = 0 # indicator if bond is considered peak peril (1) or not (0)\n",
+ "hybrid_trigger = 0 # indicator if bond contains a hybrid trigger (1) or not (0)\n",
+ "investment_graded = 0 # indicator if bond is investment graded (1) or not (0)\n",
+ "target_sharpe = 0.5 # target Sharpe ratio for benchmark pricing \n",
+ "risk_free_rate = 0.0 # risk free rate for Sharpe ratio and simulation of returns"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dd382336",
+ "metadata": {},
+ "source": [
+ "### Define Exposure, Hazard, and Vulnerability"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "id": "a51eb038",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2025-11-28 13:48:53,059 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
+ "2025-11-28 13:48:53,503 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
+ "2025-11-28 13:48:53,826 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
+ "2025-11-28 13:48:58,325 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
+ "2025-11-28 13:48:58,386 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 546 coastal centroids.\n",
+ "2025-11-28 13:48:58,709 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
+ "2025-11-28 13:48:58,971 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
+ "2025-11-28 13:48:59,249 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
+ "2025-11-28 13:48:59,560 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
+ "2025-11-28 13:48:59,845 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
+ "2025-11-28 13:49:00,192 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
+ "2025-11-28 13:49:00,544 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
+ "2025-11-28 13:49:00,853 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
+ "2025-11-28 13:49:01,037 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
+ "2025-11-28 13:49:02,288 - climada.entity.exposures.litpop.litpop - INFO - \n",
+ " LitPop: Init Exposure for country: KNA (659)...\n",
+ "\n",
+ "2025-11-28 13:49:02,340 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+ "2025-11-28 13:49:02,759 - climada.util.finance - INFO - GDP KNA 2020: 8.839e+08.\n",
+ "2025-11-28 13:49:02,777 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+ "2025-11-28 13:49:02,778 - climada.entity.exposures.base - INFO - category_id not set.\n",
+ "2025-11-28 13:49:02,778 - climada.entity.exposures.base - INFO - cover not set.\n",
+ "2025-11-28 13:49:02,779 - climada.entity.exposures.base - INFO - deductible not set.\n",
+ "2025-11-28 13:49:02,779 - climada.entity.exposures.base - INFO - centr_ not set.\n"
+ ]
+ }
+ ],
+ "source": [
+ "### ST. KITTS AND NEVIS ###\n",
+ "tr_irma = TCTracks.from_ibtracs_netcdf(\n",
+ " provider=\"usa\", storm_id=\"2017242N16333\"\n",
+ ") # IRMA 2017\n",
+ "tr_irma.equal_timestep()\n",
+ "tr_irma.calc_perturbed_trajectories(nb_synth_tracks=50)\n",
+ "min_lat, max_lat, min_lon, max_lon = 17.0, 17.5, -62.9, -62.5\n",
+ "cent = Centroids.from_pnt_bounds((min_lon, min_lat, max_lon, max_lat), res=0.02)\n",
+ "\n",
+ "# construct tropical cyclones\n",
+ "tc_irma = TropCyclone.from_tracks(tr_irma, centroids=cent)\n",
+ "\n",
+ "\n",
+ "exp_kit = LitPop.from_countries(\n",
+ " [str(countries[0])], fin_mode='gdp', reference_year=2020\n",
+ " )\n",
+ "\n",
+ "impfset = ImpfSetTropCyclone.from_calibrated_regional_ImpfSet()\n",
+ "iso3n_per_region = impf_id_per_region = impfset.get_countries_per_region()[2]\n",
+ "exp_kit.gdf.loc[exp_kit.gdf.region_id == countries[0], 'impf_TC'] = 1\n",
+ "\n",
+ "# change dates of tc events to allow simulation of multiple years\n",
+ "tc_irma.date = np.array([736694, 736774, 736874, 736981, 737013, 737080, 737099, 737155,\n",
+ " 737206, 737297, 737398, 737401, 737482, 737496, 737535, 737576,\n",
+ " 737630, 737677, 737681, 737732, 737765, 737825, 737887, 737937,\n",
+ " 737990, 738024, 738086, 738175, 738278, 738297, 738334, 738390,\n",
+ " 738452, 738536, 738563, 738582, 738633, 738701, 738738, 738795,\n",
+ " 738850, 738884, 738928, 738989, 739062, 739101, 739143, 739193,\n",
+ " 739221, 739268, 739297])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "id": "890bcd64",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2025-11-28 13:49:04,680 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
+ "2025-11-28 13:49:04,750 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
+ "2025-11-28 13:49:04,800 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
+ "2025-11-28 13:49:08,136 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
+ "2025-11-28 13:49:08,170 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 7938 coastal centroids.\n",
+ "2025-11-28 13:49:13,321 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
+ "2025-11-28 13:49:19,627 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
+ "2025-11-28 13:49:24,452 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
+ "2025-11-28 13:49:29,248 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
+ "2025-11-28 13:49:34,154 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
+ "2025-11-28 13:49:41,063 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
+ "2025-11-28 13:49:46,283 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
+ "2025-11-28 13:49:52,756 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
+ "2025-11-28 13:49:54,540 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
+ "2025-11-28 13:49:56,718 - climada.entity.exposures.litpop.litpop - INFO - \n",
+ " LitPop: Init Exposure for country: JAM (388)...\n",
+ "\n",
+ "2025-11-28 13:49:57,169 - climada.util.finance - INFO - GDP JAM 2020: 1.381e+10.\n",
+ "2025-11-28 13:49:57,201 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+ "2025-11-28 13:49:57,201 - climada.entity.exposures.base - INFO - category_id not set.\n",
+ "2025-11-28 13:49:57,202 - climada.entity.exposures.base - INFO - cover not set.\n",
+ "2025-11-28 13:49:57,203 - climada.entity.exposures.base - INFO - deductible not set.\n",
+ "2025-11-28 13:49:57,204 - climada.entity.exposures.base - INFO - centr_ not set.\n"
+ ]
+ }
+ ],
+ "source": [
+ "tr_melissa = TCTracks.from_ibtracs_netcdf(\n",
+ " provider=\"usa\", storm_id=\"2025291N11319\"\n",
+ ") # Melissa 2025\n",
+ "tr_melissa.equal_timestep()\n",
+ "tr_melissa.calc_perturbed_trajectories(nb_synth_tracks=50)\n",
+ "min_lat, max_lat, min_lon, max_lon = 17.5, 18.75, -78.5, -76\n",
+ "cent = Centroids.from_pnt_bounds((min_lon, min_lat, max_lon, max_lat), res=0.02)\n",
+ "\n",
+ "# construct tropical cyclones\n",
+ "tc_melissa = TropCyclone.from_tracks(tr_melissa, centroids=cent)\n",
+ "\n",
+ "\n",
+ "exp_jam = LitPop.from_countries(\n",
+ " [str(countries[1])], fin_mode='gdp', reference_year=2020\n",
+ " )\n",
+ "\n",
+ "iso3n_per_region = impf_id_per_region = impfset.get_countries_per_region()[2]\n",
+ "exp_jam.gdf.loc[exp_jam.gdf.region_id == countries[1], 'impf_TC'] = 1\n",
+ "\n",
+ "# change dates of tc events to allow simulation of multiple years\n",
+ "tc_melissa.date = np.array([736694, 736774, 736874, 736981, 737013, 737080, 737099, 737155,\n",
+ " 737206, 737297, 737398, 737401, 737482, 737496, 737535, 737576,\n",
+ " 737630, 737677, 737681, 737732, 737765, 737825, 737887, 737937,\n",
+ " 737990, 738024, 738086, 738175, 738278, 738297, 738334, 738390,\n",
+ " 738452, 738536, 738563, 738582, 738633, 738701, 738738, 738795,\n",
+ " 738850, 738884, 738928, 738989, 739062, 739101, 739143, 739193,\n",
+ " 739221, 739268, 739297])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "id": "c42eed8b",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2025-11-28 13:49:59,034 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
+ "2025-11-28 13:49:59,092 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
+ "2025-11-28 13:49:59,125 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
+ "2025-11-28 13:50:01,730 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
+ "2025-11-28 13:50:01,785 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 16463 coastal centroids.\n",
+ "2025-11-28 13:50:09,369 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
+ "2025-11-28 13:50:16,973 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
+ "2025-11-28 13:50:27,121 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
+ "2025-11-28 13:50:37,603 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
+ "2025-11-28 13:50:45,575 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
+ "2025-11-28 13:50:57,931 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
+ "2025-11-28 13:51:08,044 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
+ "2025-11-28 13:51:16,288 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
+ "2025-11-28 13:51:20,271 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
+ "2025-11-28 13:51:25,713 - climada.entity.exposures.litpop.litpop - INFO - \n",
+ " LitPop: Init Exposure for country: BLZ (84)...\n",
+ "\n",
+ "2025-11-28 13:51:26,045 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+ "2025-11-28 13:51:26,078 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+ "2025-11-28 13:51:26,114 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+ "2025-11-28 13:51:26,134 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+ "2025-11-28 13:51:26,154 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+ "2025-11-28 13:51:26,174 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+ "2025-11-28 13:51:26,216 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+ "2025-11-28 13:51:26,238 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+ "2025-11-28 13:51:26,263 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+ "2025-11-28 13:51:26,580 - climada.util.finance - INFO - GDP BLZ 2020: 2.043e+09.\n",
+ "2025-11-28 13:51:26,629 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+ "2025-11-28 13:51:26,630 - climada.entity.exposures.base - INFO - category_id not set.\n",
+ "2025-11-28 13:51:26,630 - climada.entity.exposures.base - INFO - cover not set.\n",
+ "2025-11-28 13:51:26,631 - climada.entity.exposures.base - INFO - deductible not set.\n",
+ "2025-11-28 13:51:26,635 - climada.entity.exposures.base - INFO - centr_ not set.\n"
+ ]
+ }
+ ],
+ "source": [
+ "tr_keith = TCTracks.from_ibtracs_netcdf(\n",
+ " provider=\"usa\", storm_id=\"2000273N16277\"\n",
+ ") # Melissa 2025\n",
+ "tr_keith.equal_timestep()\n",
+ "tr_keith.calc_perturbed_trajectories(nb_synth_tracks=50)\n",
+ "min_lat, max_lat, min_lon, max_lon = 15.5, 18.75, -89.5, -87.5\n",
+ "cent = Centroids.from_pnt_bounds((min_lon, min_lat, max_lon, max_lat), res=0.02)\n",
+ "\n",
+ "# construct tropical cyclones\n",
+ "tc_keith = TropCyclone.from_tracks(tr_keith, centroids=cent)\n",
+ "\n",
+ "\n",
+ "exp_bel = LitPop.from_countries(\n",
+ " [countries[2]], fin_mode='gdp', reference_year=2020\n",
+ " )\n",
+ "\n",
+ "iso3n_per_region = impf_id_per_region = impfset.get_countries_per_region()[2]\n",
+ "exp_bel.gdf.loc[exp_bel.gdf.region_id == countries[2], 'impf_TC'] = 1\n",
+ "\n",
+ "# change dates of tc events to allow simulation of multiple years\n",
+ "tc_keith.date = np.array([736694, 736774, 736874, 736981, 737013, 737080, 737099, 737155,\n",
+ " 737206, 737297, 737398, 737401, 737482, 737496, 737535, 737576,\n",
+ " 737630, 737677, 737681, 737732, 737765, 737825, 737887, 737937,\n",
+ " 737990, 738024, 738086, 738175, 738278, 738297, 738334, 738390,\n",
+ " 738452, 738536, 738563, 738582, 738633, 738701, 738738, 738795,\n",
+ " 738850, 738884, 738928, 738989, 739062, 739101, 739143, 739193,\n",
+ " 739221, 739268, 739297])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7a37023a",
+ "metadata": {},
+ "source": [
+ "### Initialise Subarea Class"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "id": "09fba021",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2025-11-28 13:51:33,651 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2025-11-28 13:51:57,618 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2025-11-28 13:52:20,493 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "st_kitts_subareas = Subareas.from_resolution(tc_irma, impfset, exp_kit, resolution=resolution_st_kitts) # derive subareas for St. Kitts and Nevis\n",
+ "jamaica_subareas = Subareas.from_resolution(tc_melissa, impfset, exp_jam, resolution=resolution_jamaica) # derive subareas for Jamaica\n",
+ "belize_subareas = Subareas.from_resolution(tc_keith, impfset, exp_bel, resolution=resolution_belize) # derive subareas for Belize\n",
+ "jamaica_subareas.plot()\n",
+ "st_kitts_subareas.plot()\n",
+ "belize_subareas.plot()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a284ec39",
+ "metadata": {},
+ "source": [
+ "### Subarea Calculations"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "id": "ac344ab3",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2025-11-28 13:52:49,221 - climada.entity.exposures.base - INFO - Matching 328 exposures with 546 centroids.\n",
+ "2025-11-28 13:52:49,224 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
+ "2025-11-28 13:52:49,236 - climada.engine.impact_calc - INFO - Calculating impact for 984 assets (>0) and 51 events.\n",
+ "2025-11-28 13:52:50,263 - climada.entity.exposures.base - INFO - Matching 13552 exposures with 7938 centroids.\n",
+ "2025-11-28 13:52:50,281 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
+ "2025-11-28 13:52:50,317 - climada.engine.impact_calc - INFO - Calculating impact for 40503 assets (>0) and 51 events.\n",
+ "2025-11-28 13:52:51,002 - climada.entity.exposures.base - INFO - Matching 27265 exposures with 16463 centroids.\n",
+ "2025-11-28 13:52:51,019 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
+ "2025-11-28 13:52:51,083 - climada.engine.impact_calc - INFO - Calculating impact for 81177 assets (>0) and 51 events.\n"
+ ]
+ }
+ ],
+ "source": [
+ "st_kitts_sub_calc = SubareaCalculations(subareas=st_kitts_subareas, index_stat=par_index) # initialize subarea calculations for St. Kitts and Nevis\n",
+ "jamaica_sub_calc = SubareaCalculations(subareas=jamaica_subareas, index_stat=par_index) # initialize subarea calculations for Jamaica\n",
+ "belize_sub_calc = SubareaCalculations(subareas=belize_subareas, index_stat=par_index) # initialize subarea calculations for Belize\n",
+ "st_kitts_sub_calc.create_pay_vs_dam(attachment_point, exhaustion_point, methods_attachment_point=attachment_point_method, methods_exhaustion_point=exhaustion_point_method) # derive payout vs damage dataframe for St. Kitts and Nevis\n",
+ "jamaica_sub_calc.create_pay_vs_dam(attachment_point, exhaustion_point, methods_attachment_point=attachment_point_method, methods_exhaustion_point=exhaustion_point_method) # derive payout vs damage dataframe for Jamaica\n",
+ "belize_sub_calc.create_pay_vs_dam(attachment_point, exhaustion_point, methods_attachment_point=attachment_point_method, methods_exhaustion_point=exhaustion_point_method) # derive payout vs damage dataframe for Belize"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bf3bead9",
+ "metadata": {},
+ "source": [
+ "### Single-Country Bond Simulation"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "id": "4ead6e69",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{'EL_ann': 0.05263157894736842,\n",
+ " 'AP_ann': 0.07602339181286549,\n",
+ " 'Tot_payout': 3977649999.999997,\n",
+ " 'Tot_damages': 14781419626.370327,\n",
+ " 'VaR_95_ann': 0.49999999999999994,\n",
+ " 'ES_95_ann': 0.8647002199585602,\n",
+ " 'VaR_99_ann': 1.0,\n",
+ " 'ES_99_ann': 1}"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Benchmark Sharpe Ratio premium rate: 19.1\n",
+ "Chatoro premium rate: 13.4\n",
+ "IBRD premium rate: 8.8\n"
+ ]
+ }
+ ],
+ "source": [
+ "### ST. KITTS AND NEVIS BOND SIMULATION ###\n",
+ "st_kitts_bond_sim = SingleCountryBondSimulation(subarea_calc=st_kitts_sub_calc, term=term, number_of_terms=num_of_terms) # initialize bond simulation for St. Kitts and Nevis\n",
+ "st_kitts_bond_sim.init_loss_simulation() # derive loss simulation for St. Kitts and Nevis\n",
+ "st_kitts_premiums = PremiumCalculations(bond_simulation_class=st_kitts_bond_sim) # initialize premium calculations for St. Kitts and Nevis\n",
+ "st_kitts_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger) # derive Chatoro premium for St. Kitts and Nevis\n",
+ "st_kitts_premiums.calc_ibrd_premium() # derive IBRD premium for St. Kitts and Nevis\n",
+ "st_kitts_premiums.calc_benchmark_premium(target_sharpe = target_sharpe) # derive benchmark premium for St. Kitts and Nevis using target sharpe ratio\n",
+ "st_kitts_bond_sim.init_return_simulation(premium=st_kitts_premiums.chatoro_prem_rate) # simulate returns for St. Kitts and Nevis using Chatoro premium\n",
+ "display(st_kitts_bond_sim.loss_metrics) \n",
+ "print(f\"Benchmark Sharpe Ratio premium rate: {round(st_kitts_premiums.benchmark_prem_rate*100,1)}\")\n",
+ "print(f\"Chatoro premium rate: {round(st_kitts_premiums.chatoro_prem_rate*100,1)}\")\n",
+ "print(f\"IBRD premium rate: {round(st_kitts_premiums.ibrd_prem_rate*100,1)}\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "id": "6cfb9d55",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{'EL_ann': 0.02693646858871278,\n",
+ " 'AP_ann': 0.08771929824561403,\n",
+ " 'Tot_payout': 31810947621.008274,\n",
+ " 'Tot_damages': 50919862874.32074,\n",
+ " 'VaR_95_ann': 0.12926157820337597,\n",
+ " 'ES_95_ann': 0.4434242652474378,\n",
+ " 'VaR_99_ann': 0.832218608655908,\n",
+ " 'ES_99_ann': 0.85399814094077}"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Benchmark Sharpe Ratio premium rate: 9.8\n",
+ "Chatoro premium rate: 9.8\n",
+ "IBRD premium rate: 6.0\n"
+ ]
+ }
+ ],
+ "source": [
+ "### JAMAICA BOND SIMULATION ###\n",
+ "jamaica_bond_sim = SingleCountryBondSimulation(subarea_calc=jamaica_sub_calc, term=term, number_of_terms=num_of_terms) # initialize bond simulation for Jamaica\n",
+ "jamaica_bond_sim.init_loss_simulation() # derive loss simulation for Jamaica\n",
+ "jamaica_premiums = PremiumCalculations(bond_simulation_class=jamaica_bond_sim) # initialize premium calculations for Jamaica\n",
+ "jamaica_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger) # derive Chatoro premium for Jamaica\n",
+ "jamaica_premiums.calc_ibrd_premium() # derive IBRD premium for Jamaica\n",
+ "jamaica_premiums.calc_benchmark_premium(target_sharpe = target_sharpe) # derive benchmark premium for Jamaica using target sharpe ratio\n",
+ "jamaica_bond_sim.init_return_simulation(premium=jamaica_premiums.chatoro_prem_rate) # simulate returns for Jamaica using Chatoro premium\n",
+ "display(jamaica_bond_sim.loss_metrics) \n",
+ "print(f\"Benchmark Sharpe Ratio premium rate: {round(jamaica_premiums.benchmark_prem_rate*100,1)}\")\n",
+ "print(f\"Chatoro premium rate: {round(jamaica_premiums.chatoro_prem_rate*100,1)}\")\n",
+ "print(f\"IBRD premium rate: {round(jamaica_premiums.ibrd_prem_rate*100,1)}\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "id": "4e590bad",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{'EL_ann': 0.03539460884926218,\n",
+ " 'AP_ann': 0.11695906432748537,\n",
+ " 'Tot_payout': 6182152456.799656,\n",
+ " 'Tot_damages': 9590299020.561695,\n",
+ " 'VaR_95_ann': 0.25031103128297705,\n",
+ " 'ES_95_ann': 0.42061599365154456,\n",
+ " 'VaR_99_ann': 0.5701310343598847,\n",
+ " 'ES_99_ann': 0.6062286122851708}"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Benchmark Sharpe Ratio premium rate: 10.1\n",
+ "Chatoro premium rate: 11.0\n",
+ "IBRD premium rate: 6.9\n"
+ ]
+ }
+ ],
+ "source": [
+ "belize_bond_sim = SingleCountryBondSimulation(subarea_calc=belize_sub_calc, term=term, number_of_terms=num_of_terms) # initialize bond simulation for Belize\n",
+ "belize_bond_sim.init_loss_simulation() # derive loss simulation for Belize\n",
+ "belize_premiums = PremiumCalculations(bond_simulation_class=belize_bond_sim) # initialize premium calculations for Belize\n",
+ "belize_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger) # derive Chatoro premium for Belize\n",
+ "belize_premiums.calc_ibrd_premium() # derive IBRD premium for Belize\n",
+ "belize_premiums.calc_benchmark_premium(target_sharpe = target_sharpe) # derive benchmark premium for Belize using target sharpe ratio\n",
+ "belize_bond_sim.init_return_simulation(premium=belize_premiums.chatoro_prem_rate) # simulate returns for Belize using Chatoro premium\n",
+ "display(belize_bond_sim.loss_metrics)\n",
+ "print(f\"Benchmark Sharpe Ratio premium rate: {round(belize_premiums.benchmark_prem_rate*100,1)}\")\n",
+ "print(f\"Chatoro premium rate: {round(belize_premiums.chatoro_prem_rate*100,1)}\")\n",
+ "print(f\"IBRD premium rate: {round(belize_premiums.ibrd_prem_rate*100,1)}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6fc56ad6",
+ "metadata": {},
+ "source": [
+ "### Multi-Country Bond Simulation"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "id": "65cf6f54",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#create dictionary of single-country bond simulation classes\n",
+ "sng_bonds_dic = {countries[0]: st_kitts_bond_sim,\n",
+ " countries[1]: jamaica_bond_sim,\n",
+ " countries[2]: belize_bond_sim}"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "id": "67403f5f",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{'EL_ann': 0.02989594371046782,\n",
+ " 'AP_ann': 0.14035087719298245,\n",
+ " 'Payout': 41970750077.80792,\n",
+ " 'Damage': 75291581521.25276,\n",
+ " 'VaR_95_ann': 0.15451509699820623,\n",
+ " 'ES_95_ann': 0.43063719800984757,\n",
+ " 'VaR_99_ann': 0.7514713076856494,\n",
+ " 'ES_99_ann': 0.7910451794038681}"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Benchmark Sharpe Ratio premium rate: 9.7\n",
+ "Chatoro premium rate: 10.3\n",
+ "IBRD premium rate: 6.3\n"
+ ]
+ }
+ ],
+ "source": [
+ "mlt_cat_bond = MultiCountryBondSimulation(country_dictionary=sng_bonds_dic, term=term,number_of_terms=num_of_terms) # initialize multi-country bond simulation\n",
+ "mlt_cat_bond.init_required_principal() # calculate minimal required principal to achieve the same coverage as the single-country bonds\n",
+ "mlt_cat_bond.init_loss_simulation(principal=mlt_cat_bond.requ_principal, confidence_levels=[0.95,0.99]) # derive loss simulation for multi-country bond\n",
+ "mlt_bond_premiums = PremiumCalculations(bond_simulation_class=mlt_cat_bond) # initialize premium calculations for multi-country bond\n",
+ "mlt_bond_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger) # derive Chatoro premium for multi-country bond\n",
+ "mlt_bond_premiums.calc_ibrd_premium() # derive IBRD premium for multi-country bond\n",
+ "mlt_bond_premiums.calc_benchmark_premium(target_sharpe = target_sharpe) # derive benchmark premium for multi-country bond using target sharpe ratio\n",
+ "mlt_cat_bond.init_return_simulation_tranches(premiums=[mlt_bond_premiums.chatoro_prem_rate,mlt_bond_premiums.chatoro_prem_rate], tranches=[0.2,0.8]) # simulate returns for multi-country bond tranches using Chatoro premium and 20%-80% tranche structure\n",
+ "mlt_cat_bond.init_return_simulation(premium=mlt_bond_premiums.chatoro_prem_rate) # simulate returns for multi-country bond using Chatoro premium\n",
+ "display(mlt_cat_bond.loss_metrics) \n",
+ "print(f\"Benchmark Sharpe Ratio premium rate: {round(mlt_bond_premiums.benchmark_prem_rate*100,1)}\")\n",
+ "print(f\"Chatoro premium rate: {round(mlt_bond_premiums.chatoro_prem_rate*100,1)}\")\n",
+ "print(f\"IBRD premium rate: {round(mlt_bond_premiums.ibrd_prem_rate*100,1)}\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "id": "7f7e0ab3",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "1 [659]\n",
+ "2 [388, 84]\n",
+ "[659]\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "{'EL_ann': 0.0028332970051640565,\n",
+ " 'AP_ann': 0.07602339181286549,\n",
+ " 'Payout': 3977649999.999997,\n",
+ " 'Damage': 14781419626.370327,\n",
+ " 'VaR_95_ann': 0.02691632154905853,\n",
+ " 'ES_95_ann': 0.046549098327892495,\n",
+ " 'VaR_99_ann': 0.05383264309811707,\n",
+ " 'ES_99_ann': nan}"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[388, 84]\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "{'EL_ann': 0.027062646705303766,\n",
+ " 'AP_ann': 0.14035087719298245,\n",
+ " 'Payout': 37993100077.80792,\n",
+ " 'Damage': 60510161894.88244,\n",
+ " 'VaR_95_ann': 0.13371546074810295,\n",
+ " 'ES_95_ann': 0.43567450148833986,\n",
+ " 'VaR_99_ann': 0.7137884575169681,\n",
+ " 'ES_99_ann': 0.7641288578548096}"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "pool_n_dic, pool_allocation_n_pool, algorithm_result_n_pool = MultiCountryBondSimulation.simulate_bond_pool_n(country_dictionary=sng_bonds_dic, \n",
+ " term=term, \n",
+ " number_of_terms=num_of_terms, \n",
+ " principal=mlt_cat_bond.requ_principal, \n",
+ " number_pools=2, \n",
+ " n_opt_rep=2) # simulate multiple multi-country bond pools based on a fixed number of pools optimization approach\n",
+ "print(pool_n_dic[1].countries)\n",
+ "display(pool_n_dic[1].loss_metrics)\n",
+ "print(pool_n_dic[2].countries)\n",
+ "display(pool_n_dic[2].loss_metrics)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 38,
+ "id": "e88fb28d",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[659, 84]\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "{'EL_ann': 0.007236870482297057,\n",
+ " 'AP_ann': 0.12280701754385964,\n",
+ " 'Payout': 10159802456.799654,\n",
+ " 'Damage': 24371718646.932022,\n",
+ " 'VaR_95_ann': 0.06617199671567744,\n",
+ " 'ES_95_ann': 0.08372708121807745,\n",
+ " 'VaR_99_ann': 0.09540131024744886,\n",
+ " 'ES_99_ann': 0.0977140801614712}"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[388]\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "{'EL_ann': 0.02265907322817077,\n",
+ " 'AP_ann': 0.08771929824561403,\n",
+ " 'Payout': 31810947621.008274,\n",
+ " 'Damage': 50919862874.32074,\n",
+ " 'VaR_95_ann': 0.10873539552718275,\n",
+ " 'ES_95_ann': 0.37301039905430516,\n",
+ " 'VaR_99_ann': 0.7000658728992563,\n",
+ " 'ES_99_ann': 0.7183869091291053}"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "pool_max_prinipal_dic, pool_allocation_max_prin, algorithm_result_max_prin = MultiCountryBondSimulation.simulate_bond_max_principal_pool(country_dictionary=sng_bonds_dic, \n",
+ " term=term, \n",
+ " number_of_terms=num_of_terms, \n",
+ " principal=mlt_cat_bond.requ_principal, \n",
+ " maximum_principal=7000000000, \n",
+ " n_opt_rep=2) # simulate multiple multi-country bond pools based on a maximum principal optimization approach\n",
+ "print(pool_max_prinipal_dic[1].countries)\n",
+ "display(pool_max_prinipal_dic[1].loss_metrics)\n",
+ "print(pool_max_prinipal_dic[2].countries)\n",
+ "display(pool_max_prinipal_dic[2].loss_metrics)"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "climada_env",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.11.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}