From 93e924f505ddadc0516d13353f7a3a94947a4b1a Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 31 Oct 2025 16:37:42 +0100
Subject: [PATCH 001/125] initial commit CAT Bonds

---
 .../engine/cat_bonds/pay_dam_subarea.py       |  49 ++
 .../engine/cat_bonds/subarea_calculations.py  | 482 ++++++++++++++++++
 climada_petals/engine/cat_bonds/subareas.py   | 294 +++++++++++
 climada_petals/engine/cat_bonds/test.ipynb    | 275 ++++++++++
 4 files changed, 1100 insertions(+)
 create mode 100644 climada_petals/engine/cat_bonds/pay_dam_subarea.py
 create mode 100644 climada_petals/engine/cat_bonds/subarea_calculations.py
 create mode 100644 climada_petals/engine/cat_bonds/subareas.py
 create mode 100644 climada_petals/engine/cat_bonds/test.ipynb

diff --git a/climada_petals/engine/cat_bonds/pay_dam_subarea.py b/climada_petals/engine/cat_bonds/pay_dam_subarea.py
new file mode 100644
index 000000000..efa20caab
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/pay_dam_subarea.py
@@ -0,0 +1,49 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+
+import subarea_calculations
+
+class Pay_dam_subarea:
+    def __init__(self, subareas, index_stat, exhaustion_point, attachment_point):
+        self.subareas_class = subareas
+        self.index_stat = index_stat
+        self.exhaustion_point = exhaustion_point
+        self.attachment = attachment_point
+        self._get_pay_vs_dam()
+
+    def _get_pay_vs_dam(self):
+        calculation_class = subarea_calculations.Subarea_Calculations(self.subareas_class, self.index_stat, self.exhaustion_point, self.attachment)
+        self.pay_vs_dam, self.principal = calculation_class.create_pay_vs_dam()
+
+    def plot_pay_vs_dam(self, calculation_class):
+        tot_exp = calculation_class.exposure.gdf['value'].sum()
+
+        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 4))
+
+        ax1.scatter(self.pay_vs_dam/tot_exp, payout_flt/tot_exp, marker='o', color='blue', label='Events')
+        ax1.plot([0, nominal/tot_exp], [0, nominal/tot_exp], color='black', linestyle='--', label='Trendline')
+        ax1.axhline(y = nominal/tot_exp, color = 'r', linestyle = '-', label='Principal') 
+        ax1.axhline(y = 0.05, color = 'r', linestyle = '-', label='Attachment Point') 
+        ax1.axvline(x = 0.05, color = 'r', linestyle = '--', label='Min. Damage') 
+        ax1.set_xlabel("Damage [share of GDP]", fontsize=12)
+        ax1.set_ylabel("Payout [share of GDP]", fontsize=12)
+        ax1.legend(loc='lower right', borderpad=2.0)
+
+        ax2.scatter(damages/tot_exp, pay_dam_df['pay']/tot_exp, marker='o', color='blue', label='Events')
+        ax2.axhline(y = nominal/tot_exp, color = 'r', linestyle = '-', label='Principal') 
+        ax2.axhline(y = 0.05, color = 'r', linestyle = '-', label='Attachment Point') 
+        ax2.axvline(x = 0.05, color = 'black', linestyle = '--', label='Min. Damage') 
+        ax2.set_xscale('log')
+        ax2.set_xlabel("Damage [share of GDP]", fontsize=12)
+        ax2.set_ylabel("Payout [share of GDP]", fontsize=12)
+
+        panel_labels = ["a)", "b)"]
+        for i, ax in enumerate([ax1, ax2]):
+            ax.annotate(panel_labels[i], 
+                xy=(-0.1, 1),  
+                xycoords="axes fraction", 
+                fontsize=14, 
+                fontweight="bold")
+            
+        plt.tight_layout()
+        plt.show()
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..f73bd9045
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/subarea_calculations.py
@@ -0,0 +1,482 @@
+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
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+formatter = logging.Formatter('%(asctime)s %(levelname)s %(name)s: %(message)s')
+for handler in logging.getLogger().handlers:
+    handler.setFormatter(formatter)
+
+
+class Subarea_Calculations:
+    def __init__(self, subareas, index_stat, exhaustion_point, attachment_point):
+
+        '''
+        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.subareas = subareas.subareas_gdf
+        self.exposure = subareas.exposure
+        self.hazard = subareas.hazard
+        self.vulnerability = subareas.vulnerability
+        self.index_stat = index_stat
+        self.exhaustion_point = exhaustion_point
+
+        self.initial_guess_dict = {
+            "TC": (30, 40)
+        }  # initial guess for wind speed in m/s
+
+    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_per_event : numpy.ndarray
+            Array of impact values per event for each exposure point.
+        imp_subareas_evt : pandas.DataFrame
+            DataFrame of aggregated impacts per subarea and event.
+        """
+
+        # perform impact calcualtion
+        imp = ImpactCalc(self.exposure, self.vulnerability, self.hazard).impact(
+            save_mat=True
+        )
+
+        # save impact per exposure point
+        imp_per_event = imp.at_event
+
+        # save impact per exposure point
+        imp_per_exp = imp.imp_mat
+        exp_crs = self.exposure.gdf
+        exp_crs = exp_crs.to_crs(self.subareas.crs)
+
+        # Perform a spatial join to associate each exposure point with calculated impact with a subarea
+        exp_to_admin = exp_crs.sjoin(self.subareas, how="left", predicate="within")
+
+        # group each exposure point according to subarea letter
+        agg_exp = exp_to_admin.groupby("subarea_letter").apply(
+            lambda x: x.index.tolist()
+        )
+
+        # Dictionary to store the impacts for each subarea
+        imp_subarea_csr = {}
+        # Loop through each subarea and its corresponding line numbers
+        for letter, line_numbers in agg_exp.items():
+            selected_values = imp_per_exp[
+                :, line_numbers
+            ]  # Select all impact values per subarea
+            imp_subarea_csr[letter] = (
+                selected_values  # Store them in dictionary per subarea
+            )
+        imp_subareas_evt = {}  # total damage for each event per subarea
+
+        # sum all impacts per subarea
+        for i in imp_subarea_csr:
+            imp_subareas_evt[i] = imp_subarea_csr[i].sum(
+                axis=1
+            )  # calculate sum of impacts per subarea
+            imp_subareas_evt[i] = [
+                matrix.item() for matrix in imp_subareas_evt[i]
+            ]  # single values per event are stored in 1:1 matrix -> only save value
+
+        # transform matrix to data frame
+        imp_subareas_evt = pd.DataFrame.from_dict(imp_subareas_evt)
+
+        return imp, imp_per_event, imp_subareas_evt
+
+    def _calc_attachment_principal(self, impact):
+        """
+        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.
+
+        Returns
+        ----------
+            exhaustion_point: float
+                The calculated exhaustion_point value for the CAT bond.
+        """
+        tot_exp = self.exposure.gdf["value"].sum()
+
+        if isinstance(self.attachment, float):
+            attachment = self.attachment
+
+        elif isinstance(self.attachment, str):
+            if "Exp" in self.attachment:
+                self.attachment = float(self.attachment.split(" ")[0])
+                attachment = tot_exp * self.attachment
+            elif "RP" in self.attachment:
+                self.attachment = float(self.attachment.split(" ")[0])
+                attachment = impact.calc_freq_curve(self.attachment).impact
+            else:
+                raise ValueError(
+                    "Invalid attachment format. Use 'Exp' for exposure share or 'RP' for return period."
+                )
+
+        else:
+            raise ValueError(
+                "Attachment must be a float or a string containing 'Exp' or 'RP'."
+            )
+
+        if isinstance(self.exhaustion_point, float):
+            principal = self.exhaustion_point
+
+        elif isinstance(self.exhaustion_point, str):
+            if "Exp" in self.exhaustion_point:
+                self.exhaustion_point = float(self.exhaustion_point.split(" ")[0])
+                principal = tot_exp * self.exhaustion_point
+            elif "RP" in self.exhaustion_point:
+                self.exhaustion_point = float(self.exhaustion_point.split(" ")[0])
+                principal = impact.calc_freq_curve(self.exhaustion_point).impact
+            else:
+                raise ValueError(
+                    "Invalid exhaustion point format. Use 'Exp' for exposure share or 'RP' for return period."
+                )
+
+        else:
+            raise ValueError(
+                "Exhaustion point must be a float or a string containing 'Exp' or 'RP'."
+            )
+
+        logger.info(
+            f"The attachment point and the principal of the CAT bond is: {round(attachment, 3)} and {round(principal, 3)} [USD], respectively."
+        )
+        logger.info(
+            f"Attachment point and principal as share of exposure: {round(attachment/tot_exp, 3)} and {round(principal/tot_exp, 3)}, respectively."
+        )
+
+        return principal, attachment
+
+    def _calc_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.hazard.centroids.gdf
+        hazard = hazard.to_crs(self.subareas.crs)
+        centrs_to_sub = hazard.sjoin(self.subareas, 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.hazard.event_id) for letter in agg_exp.keys()
+        }
+
+        int_sub["year"] = [0 for _ in range(len(self.hazard.event_id))]
+        int_sub["month"] = [0 for _ in range(len(self.hazard.event_id))]
+
+        # Iterate over each event
+        for i in range(len(self.hazard.event_id)):
+            date = pd.to_datetime(self.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.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.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_dict[hazard_type],
+                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,
+        imp_per_event,
+        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
+        ----------
+        imp_per_event : numpy.ndarray
+            Array of impact values per event for each exposure point.
+        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_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) - 3):
+                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):
+
+        imp, imp_per_event, imp_subareas_evt = self._calc_impact() 
+        par_idx = self._calc_index()
+        self.principal, self.attachment = self._calc_attachment_principal(imp, )
+        self.results, self.opt_min_thresh, self.opt_max_thresh = self._calibrate_payout_fcts(par_idx, self.principal, self.attachment, imp_subareas_evt)
+        pay_vs_dam = self._calc_pay_vs_dam(imp_per_event=imp_per_event, 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=par_idx)
+        
+        return pay_vs_dam, self.principal
+    
+# 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..c136ee9cd
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/subareas.py
@@ -0,0 +1,294 @@
+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
+
+
+# specify resultion to change exposure layer into country polygons
+resolution = 1000
+
+
+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.
+        grid_specs : dict or object
+            Specifications for the spatial grid (number of rows and columns). Defines count of subaraeas.
+        buffer_grid_size : int, optional
+            Size of the buffer around input country. Resulting geometry is used to derive subareas (in km; default is 5).
+        min_pol_size : int, optional
+            Minimum polygon size for subareas (default: 1000 square meters).
+        crs : str, optional
+            Coordinate reference system for spatial data (default: "EPSG:3857").
+        subareas_gdf : geopandas.GeoDataFrame
+            GeoDataFrame containing the subareas as polygons.
+        exp_gdf : geopandas.GeoDataFrame
+            GeoDataFrame containing the exposure perimeter as a polygon.
+    '''
+    
+
+    def __init__(
+        self,
+        hazard,
+        vulnerability,
+        exposure,
+        grid_specs,
+        buffer_grid_size=5.0,
+        min_pol_size=1000,
+        crs="EPSG:3857",
+    ):
+
+        self.hazard = hazard
+        self.vulnerability = vulnerability
+        self._exposure = exposure
+        self._grid_specs = grid_specs
+        self._buffer_grid_size = buffer_grid_size
+        self._min_pol_size = min_pol_size
+        self._crs = crs
+        self._build_subareas()
+
+    def _build_subareas(self):
+        """Recalculate subareas and islands."""
+        self.subareas_gdf, self.exp_gdf = self._init_subareas()
+
+    # --- Properties with auto-rebuild ---
+    @property
+    def exposure(self):
+        return self._exposure
+
+    @exposure.setter
+    def exposure(self, value):
+        self._exposure = value
+        self._build_subareas()
+
+    @property
+    def grid_specs(self):
+        return self._grid_specs
+
+    @grid_specs.setter
+    def grid_specs(self, value):
+        self._grid_specs = value
+        self._build_subareas()
+
+    @property
+    def buffer_grid_size(self):
+        return self._buffer_grid_size
+
+    @buffer_grid_size.setter
+    def buffer_grid_size(self, value):
+        self._buffer_grid_size = value
+        self._build_subareas()
+
+    @property
+    def min_pol_size(self):
+        return self._min_pol_size
+
+    @min_pol_size.setter
+    def min_pol_size(self, value):
+        self._min_pol_size = value
+        self._build_subareas()
+
+    @property
+    def crs(self):
+        return self._crs
+
+    @crs.setter
+    def crs(self, value):
+        self._crs = value
+        self._build_subareas()
+
+    def plot(self):
+        if self.subareas_gdf is None:
+            raise ValueError("Subareas have not been generated yet.")
+        else:
+            fig, ax = plt.subplots(figsize=(6.4, 4.8))
+            self.exp_gdf.plot(ax=ax, color="green", label="Exposure")
+            self.subareas_gdf.plot(
+                ax=ax, facecolor="none", edgecolor="red", lw=2, label="Subarea"
+            )
+            handles = [
+                Line2D([0], [0], color="green", lw=4, label="Exposure"),
+                Line2D([0], [0], color="red", lw=2, label="Subareas"),
+            ]
+            ax.legend(handles=handles, loc="upper right")
+            ax.tick_params(axis="both", which="major", labelsize=12)
+            ax.set_yticks(ax.get_yticks()[1:])
+            ax.set_xticks(ax.get_xticks())
+            xlabel = ax.get_xticks()
+            new_xlabel = []
+            for label in xlabel:
+                new_xlabel.append(str(round(-label, 1)) + "°W")
+            ax.set_xticklabels(new_xlabel)
+            ylabel = ax.get_yticks()
+            new_ylabel = []
+            for label in ylabel:
+                new_ylabel.append(str(round(-label, 1)) + "°S")
+            ax.set_yticklabels(new_ylabel)
+            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)
+
+    def _init_subareas(self):
+
+        """
+        Divides the exposure set into subareas and returns a geodataframe for the perimeter of exposed assets.
+
+        Parameters
+        ----------
+        self : class instance
+            Instance of the Subareas class.
+
+        Returns
+        -------
+        subareas_gdf : GeoDataFrame
+            Geodataframe of subareas covering the exposure perimeter.
+        exp_gdf : GeoDataFrame
+            Geodataframe of the exposure perimeter.
+        """
+
+        exp_gdf = self._create_exp_gdf()
+        exp_gdf = exp_gdf.explode(ignore_index=True, index_parts=True)
+        buffered_geometries = exp_gdf.geometry.buffer(self._buffer_grid_size * 1000)
+        exp_gdf = unary_union(buffered_geometries)
+        exp_gdf = gpd.GeoDataFrame({"geometry": [exp_gdf]}, crs=self._crs).explode(
+            index_parts=True
+        )
+        subareas_gdf = self._crop_grid_cells_to_polygon(
+            exp_gdf
+        )
+        if self._crs == "EPSG:3857":
+            exposure_crs = self._exposure.crs
+            exp_gdf = exp_gdf.to_crs(exposure_crs)
+            subareas_gdf = subareas_gdf.to_crs(exposure_crs)
+        subareas_gdf["subarea_letter"] = [chr(65 + i) for i in range(len(subareas_gdf))]
+
+        return subareas_gdf, exp_gdf
+
+    def _crop_grid_cells_to_polygon(self, exp_gdf):
+
+        """
+        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.
+        """
+
+        cropped_cells = []
+
+        # Loop through each polygon in the GeoDataFrame
+        for idx, polygon in exp_gdf.iterrows():
+            polygon_area_km2 = polygon.geometry.area / 1e6
+            if polygon_area_km2 < self._min_pol_size:
+                grid_gdf = gpd.GeoDataFrame(
+                    {"geometry": [polygon.geometry]}, crs=exp_gdf.crs
+                )
+                cropped_cells.append(grid_gdf)
+            else:
+                minx, miny, maxx, maxy = polygon.geometry.bounds
+
+                num_cells_x = self._grid_specs[0]
+                num_cells_y = self._grid_specs[1]
+                x_coords = np.linspace(minx, maxx, num_cells_x + 1)
+                y_coords = np.linspace(miny, maxy, num_cells_y + 1)
+
+                grid_cells = []
+                for i in range(num_cells_x):
+                    for j in range(num_cells_y):
+                        grid_cell = box(
+                            x_coords[i], y_coords[j], x_coords[i + 1], y_coords[j + 1]
+                        )
+                        cell_cropped = grid_cell.intersection(polygon.geometry)
+                        grid_cells.append(cell_cropped)
+
+                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
+        )
+        grids.reset_index(drop=True, inplace=True)
+        subareas = grids[~grids.is_empty]
+        subareas = subareas.reset_index(drop=True)
+
+        return subareas
+
+    def _create_exp_gdf(self):
+
+        """
+        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.
+        """
+
+        exp_crs = self._exposure.gdf.to_crs(self._crs)
+        minx, miny, maxx, maxy = exp_crs.total_bounds
+
+        width = int((maxx - minx) / resolution)
+        height = int((maxy - miny) / resolution)
+
+        transform = from_bounds(minx, miny, maxx, maxy, width, height)
+
+        shapes_gen = (
+            (geom, value) for geom, value in zip(exp_crs.geometry, exp_crs["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=self._crs)
+        merged_exp_gdf_sep = unary_union(exp_gdf_sep.geometry)
+        exp_gdf = gpd.GeoDataFrame(geometry=[merged_exp_gdf_sep], crs=self._crs)
+
+        return exp_gdf
diff --git a/climada_petals/engine/cat_bonds/test.ipynb b/climada_petals/engine/cat_bonds/test.ipynb
new file mode 100644
index 000000000..6cc79cbfb
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/test.ipynb
@@ -0,0 +1,275 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "48c2d418",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "from subareas import Subareas\n",
+    "from subarea_calculations import Subarea_Calculations\n",
+    "\n",
+    "from climada.hazard import TCTracks, Centroids, TropCyclone\n",
+    "from climada.entity import LitPop\n",
+    "from climada.entity import ImpfSetTropCyclone\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "78ef3cc2",
+   "metadata": {},
+   "source": [
+    "### Set CAT Bond Basics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "89b53a88",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### Bond Basics ###\n",
+    "country = 659  # St. Kitts and Nevis\n",
+    "exhaustion_point = '0.5 Exp' # 50% of exposure\n",
+    "attachment_point = '0.05 Exp' # 5% of exposure\n",
+    "term = 3  # years\n",
+    "par_index = 60 # statistic for parametric index (e.g. 60 for 60th percentile)\n",
+    "\n",
+    "### Subarea Basics ###\n",
+    "grid_specs=[1,2] # 3x3 grid\n",
+    "buffer_grid_size=0.5 # km of buffer around exposure\n",
+    "min_pol_size=100 # minimum subarea size in m² \n",
+    "\n",
+    "### Pricing Basics ###\n",
+    "peak_peril = 0 # indicator if its considered peak peril (1) or not (0)\n",
+    "target_sharpe = 0.5 # target Sharpe ratio\n",
+    "risk_free_rate = 0.0  # risk free rate for Sharpe ratio and return calculation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dd382336",
+   "metadata": {},
+   "source": [
+    "### Define Exposure, Hazard, and Vulnerability"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "a51eb038",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2024-01-01 01:07:04,151 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
+      "2024-01-01 01:07:04,226 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
+      "2024-01-01 01:07:04,283 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "<string>:7: FutureWarning: 'H' is deprecated and will be removed in a future version. Please use 'h' instead of 'H'.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2024-01-01 01:07:10,805 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
+      "2024-01-01 01:07:10,860 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 546 coastal centroids.\n",
+      "2024-01-01 01:07:11,290 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
+      "2024-01-01 01:07:11,792 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
+      "2024-01-01 01:07:12,186 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
+      "2024-01-01 01:07:12,598 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
+      "2024-01-01 01:07:12,970 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
+      "2024-01-01 01:07:13,488 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
+      "2024-01-01 01:07:13,908 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
+      "2024-01-01 01:07:14,263 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
+      "2024-01-01 01:07:14,471 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
+      "2024-01-01 01:07:15,714 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      " LitPop: Init Exposure for country: KNA (659)...\n",
+      "\n",
+      "2024-01-01 01:07:15,775 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2024-01-01 01:07:15,961 - climada.util.finance - WARNING - Internet connection failed while retrieving GDPs.\n",
+      "2024-01-01 01:07:17,376 - climada.util.finance - INFO - GDP KNA 2019: 1.053e+09.\n",
+      "2024-01-01 01:07:17,395 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+      "2024-01-01 01:07:17,396 - climada.entity.exposures.base - INFO - category_id not set.\n",
+      "2024-01-01 01:07:17,396 - climada.entity.exposures.base - INFO - cover not set.\n",
+      "2024-01-01 01:07:17,398 - climada.entity.exposures.base - INFO - deductible not set.\n",
+      "2024-01-01 01:07:17,398 - climada.entity.exposures.base - INFO - centr_ not set.\n",
+      "2024-01-01 01:07:17,400 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 900x1300 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "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 = LitPop.from_countries(\n",
+    "        [str(country)], fin_mode='gdp', reference_year=2020\n",
+    "    )\n",
+    "exp.plot_raster()\n",
+    "impfset = ImpfSetTropCyclone.from_calibrated_regional_ImpfSet()\n",
+    "iso3n_per_region = impf_id_per_region = impfset.get_countries_per_region()[2]\n",
+    "exp.gdf.loc[exp.gdf.region_id == country, 'impf_TC'] = 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7a37023a",
+   "metadata": {},
+   "source": [
+    "### Initialise Subarea Class"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "09fba021",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                                            geometry subarea_letter\n",
+      "0  POLYGON ((-62.53301 17.10417, -62.53303 17.103...              A\n",
+      "1  POLYGON ((-62.53301 17.15265, -62.63247 17.152...              B\n",
+      "2  POLYGON ((-62.62348 17.22756, -62.62351 17.227...              C\n",
+      "3  POLYGON ((-62.79988 17.41679, -62.79944 17.416...              D\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "st_kitts_subareas = Subareas(tc_irma, impfset, exp, grid_specs=grid_specs, buffer_grid_size=buffer_grid_size, min_pol_size=min_pol_size)\n",
+    "print(st_kitts_subareas.subareas_gdf)\n",
+    "st_kitts_subareas.plot()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a284ec39",
+   "metadata": {},
+   "source": [
+    "### Subarea Calculations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "ac344ab3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2024-01-01 01:11:25,220 - climada.entity.exposures.base - INFO - Matching 328 exposures with 546 centroids.\n",
+      "2024-01-01 01:11:25,227 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
+      "2024-01-01 01:11:25,231 - climada.engine.impact_calc - INFO - Calculating impact for 984 assets (>0) and 51 events.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024-01-01 01:11:27,803 INFO subarea_calculations: The attachment point and the principal of the CAT bond is: 52650000.0 and 526500000.0 [USD], respectively.\n",
+      "2024-01-01 01:11:27,803 INFO subarea_calculations: Attachment point and principal as share of exposure: 0.05 and 0.5, respectively.\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 900x1300 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "st_kitts_sub_calc = Subarea_Calculations(subareas=st_kitts_subareas, index_stat=par_index, exhaustion_point=exhaustion_point, attachment_point=attachment_point)\n",
+    "imp, imp_per_event, imp_subareas_evt = st_kitts_sub_calc._calc_impact()\n",
+    "# Compute exceedance frequency curve\n",
+    "freq_curve = imp.calc_freq_curve()\n",
+    "freq_curve.plot()\n",
+    "imp.plot_hexbin_eai_exposure(gridsize=100, adapt_fontsize=False)\n",
+    "par_idx = st_kitts_sub_calc._calc_index()\n",
+    "principal, attachment = st_kitts_sub_calc._calc_attachment_principal(imp)\n",
+    "results, opt_min_thresh, opt_max_thresh = st_kitts_sub_calc._calibrate_payout_fcts(par_idx, principal, attachment, imp_subareas_evt)\n",
+    "pay_vs_dam = st_kitts_sub_calc._calc_pay_vs_dam(imp_per_event=imp_per_event, imp_subareas_evt=imp_subareas_evt, attachment=attachment, principal=principal, opt_min_thresh=opt_min_thresh, opt_max_thresh=opt_max_thresh, haz_int=par_idx)"
+   ]
+  }
+ ],
+ "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
+}

From f502208f0348f7c901d22e3f1af28bf1265a20a8 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 3 Nov 2025 13:00:32 +0100
Subject: [PATCH 002/125] change subarea building to resolution input

---
 climada_petals/engine/cat_bonds/subareas.py | 177 +++++++++-----------
 climada_petals/engine/cat_bonds/test.ipynb  | 124 ++++++++++----
 2 files changed, 173 insertions(+), 128 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/subareas.py b/climada_petals/engine/cat_bonds/subareas.py
index c136ee9cd..0a47f4462 100644
--- a/climada_petals/engine/cat_bonds/subareas.py
+++ b/climada_petals/engine/cat_bonds/subareas.py
@@ -7,10 +7,15 @@
 from shapely.ops import unary_union
 from rasterio.features import shapes, rasterize
 from rasterio.transform import from_bounds
+from sklearn.neighbors import NearestNeighbors
+
+import logging
+
+LOGGER = logging.getLogger(__name__)
 
 
 # specify resultion to change exposure layer into country polygons
-resolution = 1000
+#tc_bound_resolution = 1000
 
 
 class Subareas:
@@ -25,12 +30,10 @@ class Subareas:
             Vulnerability object containing vulnerability data.
         exposure : climada.Exposure
             Exposure object containing monetary data.
-        grid_specs : dict or object
-            Specifications for the spatial grid (number of rows and columns). Defines count of subaraeas.
+        resolution : float
+            Resolution for grid cells to create subareas.
         buffer_grid_size : int, optional
             Size of the buffer around input country. Resulting geometry is used to derive subareas (in km; default is 5).
-        min_pol_size : int, optional
-            Minimum polygon size for subareas (default: 1000 square meters).
         crs : str, optional
             Coordinate reference system for spatial data (default: "EPSG:3857").
         subareas_gdf : geopandas.GeoDataFrame
@@ -45,23 +48,19 @@ def __init__(
         hazard,
         vulnerability,
         exposure,
-        grid_specs,
+        resolution,
         buffer_grid_size=5.0,
-        min_pol_size=1000,
-        crs="EPSG:3857",
     ):
 
         self.hazard = hazard
         self.vulnerability = vulnerability
         self._exposure = exposure
-        self._grid_specs = grid_specs
+        self._resolution = resolution
         self._buffer_grid_size = buffer_grid_size
-        self._min_pol_size = min_pol_size
-        self._crs = crs
         self._build_subareas()
 
     def _build_subareas(self):
-        """Recalculate subareas and islands."""
+        """Calculate subareas and islands."""
         self.subareas_gdf, self.exp_gdf = self._init_subareas()
 
     # --- Properties with auto-rebuild ---
@@ -69,47 +68,14 @@ def _build_subareas(self):
     def exposure(self):
         return self._exposure
 
-    @exposure.setter
-    def exposure(self, value):
-        self._exposure = value
-        self._build_subareas()
-
     @property
-    def grid_specs(self):
-        return self._grid_specs
-
-    @grid_specs.setter
-    def grid_specs(self, value):
-        self._grid_specs = value
-        self._build_subareas()
+    def resolution(self):
+        return self._resolution
 
     @property
     def buffer_grid_size(self):
         return self._buffer_grid_size
 
-    @buffer_grid_size.setter
-    def buffer_grid_size(self, value):
-        self._buffer_grid_size = value
-        self._build_subareas()
-
-    @property
-    def min_pol_size(self):
-        return self._min_pol_size
-
-    @min_pol_size.setter
-    def min_pol_size(self, value):
-        self._min_pol_size = value
-        self._build_subareas()
-
-    @property
-    def crs(self):
-        return self._crs
-
-    @crs.setter
-    def crs(self, value):
-        self._crs = value
-        self._build_subareas()
-
     def plot(self):
         if self.subareas_gdf is None:
             raise ValueError("Subareas have not been generated yet.")
@@ -162,21 +128,15 @@ def _init_subareas(self):
         exp_gdf : GeoDataFrame
             Geodataframe of the exposure perimeter.
         """
-
+        exp_crs = self._exposure.crs
         exp_gdf = self._create_exp_gdf()
+        logging.info("Number of polygons in exposure perimeter: %d", len(exp_gdf))
         exp_gdf = exp_gdf.explode(ignore_index=True, index_parts=True)
-        buffered_geometries = exp_gdf.geometry.buffer(self._buffer_grid_size * 1000)
-        exp_gdf = unary_union(buffered_geometries)
-        exp_gdf = gpd.GeoDataFrame({"geometry": [exp_gdf]}, crs=self._crs).explode(
-            index_parts=True
-        )
+
         subareas_gdf = self._crop_grid_cells_to_polygon(
             exp_gdf
         )
-        if self._crs == "EPSG:3857":
-            exposure_crs = self._exposure.crs
-            exp_gdf = exp_gdf.to_crs(exposure_crs)
-            subareas_gdf = subareas_gdf.to_crs(exposure_crs)
+
         subareas_gdf["subarea_letter"] = [chr(65 + i) for i in range(len(subareas_gdf))]
 
         return subareas_gdf, exp_gdf
@@ -203,38 +163,51 @@ def _crop_grid_cells_to_polygon(self, exp_gdf):
             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():
-            polygon_area_km2 = polygon.geometry.area / 1e6
-            if polygon_area_km2 < self._min_pol_size:
-                grid_gdf = gpd.GeoDataFrame(
-                    {"geometry": [polygon.geometry]}, crs=exp_gdf.crs
-                )
-                cropped_cells.append(grid_gdf)
-            else:
-                minx, miny, maxx, maxy = polygon.geometry.bounds
-
-                num_cells_x = self._grid_specs[0]
-                num_cells_y = self._grid_specs[1]
-                x_coords = np.linspace(minx, maxx, num_cells_x + 1)
-                y_coords = np.linspace(miny, maxy, num_cells_y + 1)
-
-                grid_cells = []
-                for i in range(num_cells_x):
-                    for j in range(num_cells_y):
-                        grid_cell = box(
-                            x_coords[i], y_coords[j], x_coords[i + 1], y_coords[j + 1]
-                        )
-                        cell_cropped = grid_cell.intersection(polygon.geometry)
-                        grid_cells.append(cell_cropped)
-
-                grid_gdf = gpd.GeoDataFrame(
-                    grid_cells, columns=["geometry"], crs=exp_gdf.crs
-                )
-
-                cropped_cells.append(grid_gdf)
+            
+            minx, miny, maxx, maxy = polygon.geometry.bounds
+
+            LOGGER.info(
+                f"Processing polygon with bounds: {minx}, {miny}, {maxx}, {maxy}"
+            )
+
+            num_cells_x = int((maxx - minx) / self._resolution) + 1
+            num_cells_y = int((maxy - miny) / self._resolution) + 1
+            n_cols = int(np.ceil((maxx - minx) / self._resolution))
+            n_rows = int(np.ceil((maxy - miny) / self._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 * self._resolution
+                    y1 = miny + y * self._resolution
+                    x2 = x1 + self._resolution
+                    y2 = y1 + self._resolution
+
+                    grid_cell = box(
+                        x1, y1, x2, y2
+                    )
+
+                    if grid_cell.intersects(polygon.geometry):
+                        #cell_cropped = grid_cell.intersection(polygon.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
@@ -243,6 +216,8 @@ def _crop_grid_cells_to_polygon(self, exp_gdf):
         subareas = grids[~grids.is_empty]
         subareas = subareas.reset_index(drop=True)
 
+        LOGGER.info("Subareas created.")
+
         return subareas
 
     def _create_exp_gdf(self):
@@ -264,17 +239,26 @@ def _create_exp_gdf(self):
             A GeoDataFrame containing a single merged polygon geometry representing the geometric extent of
             the country in the specified CRS.
         """
-
-        exp_crs = self._exposure.gdf.to_crs(self._crs)
-        minx, miny, maxx, maxy = exp_crs.total_bounds
-
-        width = int((maxx - minx) / resolution)
-        height = int((maxy - miny) / resolution)
-
+        LOGGER.info("Creating exposure perimeter polygon from exposure data.")
+        exp_gdf = self._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_crs.geometry, exp_crs["value"])
+            (geom, value) for geom, value in zip(exp_gdf.geometry, exp_gdf["value"])
         )
 
         raster = rasterize(
@@ -284,11 +268,14 @@ def _create_exp_gdf(self):
             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=self._crs)
+        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=self._crs)
+        exp_gdf = gpd.GeoDataFrame(geometry=[merged_exp_gdf_sep], crs=exp_gdf.crs)
+        LOGGER.info("Exposure perimeter polygon created.")
+        exp_gdf.plot()
 
         return exp_gdf
diff --git a/climada_petals/engine/cat_bonds/test.ipynb b/climada_petals/engine/cat_bonds/test.ipynb
index 6cc79cbfb..15f924029 100644
--- a/climada_petals/engine/cat_bonds/test.ipynb
+++ b/climada_petals/engine/cat_bonds/test.ipynb
@@ -61,7 +61,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "a51eb038",
    "metadata": {},
    "outputs": [
@@ -69,9 +69,9 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2024-01-01 01:07:04,151 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
-      "2024-01-01 01:07:04,226 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
-      "2024-01-01 01:07:04,283 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n"
+      "2025-11-03 10:37:37,508 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
+      "2025-11-03 10:37:37,600 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
+      "2025-11-03 10:37:37,678 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n"
      ]
     },
     {
@@ -85,34 +85,33 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2024-01-01 01:07:10,805 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
-      "2024-01-01 01:07:10,860 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 546 coastal centroids.\n",
-      "2024-01-01 01:07:11,290 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
-      "2024-01-01 01:07:11,792 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
-      "2024-01-01 01:07:12,186 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
-      "2024-01-01 01:07:12,598 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
-      "2024-01-01 01:07:12,970 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
-      "2024-01-01 01:07:13,488 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
-      "2024-01-01 01:07:13,908 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
-      "2024-01-01 01:07:14,263 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
-      "2024-01-01 01:07:14,471 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
-      "2024-01-01 01:07:15,714 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      "2025-11-03 10:37:43,886 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
+      "2025-11-03 10:37:43,996 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 546 coastal centroids.\n",
+      "2025-11-03 10:37:44,630 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
+      "2025-11-03 10:37:45,010 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
+      "2025-11-03 10:37:45,421 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
+      "2025-11-03 10:37:45,827 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
+      "2025-11-03 10:37:46,203 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
+      "2025-11-03 10:37:46,585 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
+      "2025-11-03 10:37:46,973 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
+      "2025-11-03 10:37:47,334 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
+      "2025-11-03 10:37:47,538 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
+      "2025-11-03 10:37:48,985 - climada.entity.exposures.litpop.litpop - INFO - \n",
       " LitPop: Init Exposure for country: KNA (659)...\n",
       "\n",
-      "2024-01-01 01:07:15,775 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2024-01-01 01:07:15,961 - climada.util.finance - WARNING - Internet connection failed while retrieving GDPs.\n",
-      "2024-01-01 01:07:17,376 - climada.util.finance - INFO - GDP KNA 2019: 1.053e+09.\n",
-      "2024-01-01 01:07:17,395 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
-      "2024-01-01 01:07:17,396 - climada.entity.exposures.base - INFO - category_id not set.\n",
-      "2024-01-01 01:07:17,396 - climada.entity.exposures.base - INFO - cover not set.\n",
-      "2024-01-01 01:07:17,398 - climada.entity.exposures.base - INFO - deductible not set.\n",
-      "2024-01-01 01:07:17,398 - climada.entity.exposures.base - INFO - centr_ not set.\n",
-      "2024-01-01 01:07:17,400 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+      "2025-11-03 10:37:49,104 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-03 10:37:50,503 - climada.util.finance - INFO - GDP KNA 2020: 8.839e+08.\n",
+      "2025-11-03 10:37:50,526 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+      "2025-11-03 10:37:50,526 - climada.entity.exposures.base - INFO - category_id not set.\n",
+      "2025-11-03 10:37:50,527 - climada.entity.exposures.base - INFO - cover not set.\n",
+      "2025-11-03 10:37:50,528 - climada.entity.exposures.base - INFO - deductible not set.\n",
+      "2025-11-03 10:37:50,528 - climada.entity.exposures.base - INFO - centr_ not set.\n",
+      "2025-11-03 10:37:50,530 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 900x1300 with 2 Axes>"
       ]
@@ -137,6 +136,7 @@
     "exp = LitPop.from_countries(\n",
     "        [str(country)], fin_mode='gdp', reference_year=2020\n",
     "    )\n",
+    "\n",
     "exp.plot_raster()\n",
     "impfset = ImpfSetTropCyclone.from_calibrated_regional_ImpfSet()\n",
     "iso3n_per_region = impf_id_per_region = impfset.get_countries_per_region()[2]\n",
@@ -153,24 +153,82 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 33,
+   "id": "f457cca6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.00029767953921070123"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\n",
+    "minx, miny, maxx, maxy = exp.gdf.total_bounds\n",
+    "\n",
+    "# Compute area of bounding box\n",
+    "width = maxx - minx\n",
+    "height = maxy - miny\n",
+    "bbox_area = width * height\n",
+    "bbox_area /len(exp.gdf)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
    "id": "09fba021",
    "metadata": {},
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2025-11-03 12:41:28,251 INFO subareas: Creating exposure perimeter polygon from exposure data.\n",
+      "2025-11-03 12:41:28,254 INFO subareas: Exposure total bounds: -62.85416667, 17.10416667, -62.5375, 17.4125\n",
+      "2025-11-03 12:41:28,258 INFO subareas: Approximate resolution: 0.009999996219511444 CRS units\n",
+      "2025-11-03 12:41:28,259 INFO subareas: Rasterizing exposure with width: 31, height: 30\n",
+      "2025-11-03 12:41:28,360 INFO subareas: Exposure perimeter polygon created.\n",
+      "2025-11-03 12:41:28,445 INFO root: Number of polygons in exposure perimeter: 1\n",
+      "2025-11-03 12:41:28,449 INFO subareas: Creating subareas from exposure perimeter polygon.\n",
+      "2025-11-03 12:41:28,452 INFO subareas: Number of polygons to process: 2\n",
+      "2025-11-03 12:41:28,454 INFO subareas: Processing polygon with bounds: -62.85416667, 17.217222224333334, -62.619220430967744, 17.4125\n",
+      "2025-11-03 12:41:28,455 INFO subareas: Number of cells in x direction: 3, y direction: 2\n",
+      "2025-11-03 12:41:28,460 INFO subareas: Processing polygon with bounds: -62.62943548483871, 17.10416667, -62.5375, 17.196666669000003\n",
+      "2025-11-03 12:41:28,466 INFO subareas: Number of cells in x direction: 1, y direction: 1\n",
+      "2025-11-03 12:41:28,478 INFO subareas: Subareas created.\n"
+     ]
+    },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "                                            geometry subarea_letter\n",
-      "0  POLYGON ((-62.53301 17.10417, -62.53303 17.103...              A\n",
-      "1  POLYGON ((-62.53301 17.15265, -62.63247 17.152...              B\n",
-      "2  POLYGON ((-62.62348 17.22756, -62.62351 17.227...              C\n",
-      "3  POLYGON ((-62.79988 17.41679, -62.79944 17.416...              D\n"
+      "0  POLYGON ((-62.75417 17.31722, -62.75417 17.289...              A\n",
+      "1  MULTILINESTRING ((-62.83374 17.41250, -62.8235...              B\n",
+      "2  POLYGON ((-62.63669 17.21722, -62.63965 17.217...              C\n",
+      "3  MULTILINESTRING ((-62.61922 17.24806, -62.6192...              D\n",
+      "4  POLYGON ((-62.62944 17.17611, -62.61922 17.176...              E\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -180,7 +238,7 @@
     }
    ],
    "source": [
-    "st_kitts_subareas = Subareas(tc_irma, impfset, exp, grid_specs=grid_specs, buffer_grid_size=buffer_grid_size, min_pol_size=min_pol_size)\n",
+    "st_kitts_subareas = Subareas(tc_irma, impfset, exp, resolution=0.1, buffer_grid_size=buffer_grid_size)\n",
     "print(st_kitts_subareas.subareas_gdf)\n",
     "st_kitts_subareas.plot()"
    ]

From 2c23ff5269e51ee2c1b3adfb791d63d031411b87 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 3 Nov 2025 13:49:46 +0100
Subject: [PATCH 003/125] alter subarea creation test notebook

---
 climada_petals/engine/cat_bonds/test.ipynb | 60 +++++++++++++---------
 1 file changed, 36 insertions(+), 24 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/test.ipynb b/climada_petals/engine/cat_bonds/test.ipynb
index 15f924029..d85668f5b 100644
--- a/climada_petals/engine/cat_bonds/test.ipynb
+++ b/climada_petals/engine/cat_bonds/test.ipynb
@@ -153,7 +153,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 45,
    "id": "f457cca6",
    "metadata": {},
    "outputs": [
@@ -163,7 +163,7 @@
        "0.00029767953921070123"
       ]
      },
-     "execution_count": 33,
+     "execution_count": 45,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -181,7 +181,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 43,
+   "execution_count": 47,
    "id": "09fba021",
    "metadata": {},
    "outputs": [
@@ -189,31 +189,43 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "2025-11-03 12:41:28,251 INFO subareas: Creating exposure perimeter polygon from exposure data.\n",
-      "2025-11-03 12:41:28,254 INFO subareas: Exposure total bounds: -62.85416667, 17.10416667, -62.5375, 17.4125\n",
-      "2025-11-03 12:41:28,258 INFO subareas: Approximate resolution: 0.009999996219511444 CRS units\n",
-      "2025-11-03 12:41:28,259 INFO subareas: Rasterizing exposure with width: 31, height: 30\n",
-      "2025-11-03 12:41:28,360 INFO subareas: Exposure perimeter polygon created.\n",
-      "2025-11-03 12:41:28,445 INFO root: Number of polygons in exposure perimeter: 1\n",
-      "2025-11-03 12:41:28,449 INFO subareas: Creating subareas from exposure perimeter polygon.\n",
-      "2025-11-03 12:41:28,452 INFO subareas: Number of polygons to process: 2\n",
-      "2025-11-03 12:41:28,454 INFO subareas: Processing polygon with bounds: -62.85416667, 17.217222224333334, -62.619220430967744, 17.4125\n",
-      "2025-11-03 12:41:28,455 INFO subareas: Number of cells in x direction: 3, y direction: 2\n",
-      "2025-11-03 12:41:28,460 INFO subareas: Processing polygon with bounds: -62.62943548483871, 17.10416667, -62.5375, 17.196666669000003\n",
-      "2025-11-03 12:41:28,466 INFO subareas: Number of cells in x direction: 1, y direction: 1\n",
-      "2025-11-03 12:41:28,478 INFO subareas: Subareas created.\n"
+      "2025-11-03 12:58:37,956 INFO subareas: Creating exposure perimeter polygon from exposure data.\n",
+      "2025-11-03 12:58:37,961 INFO subareas: Exposure total bounds: -62.85416667, 17.10416667, -62.5375, 17.4125\n",
+      "2025-11-03 12:58:37,971 INFO subareas: Approximate resolution: 0.009999996219511444 CRS units\n",
+      "2025-11-03 12:58:37,972 INFO subareas: Rasterizing exposure with width: 31, height: 30\n",
+      "2025-11-03 12:58:38,085 INFO subareas: Exposure perimeter polygon created.\n",
+      "2025-11-03 12:58:38,207 INFO root: Number of polygons in exposure perimeter: 1\n",
+      "2025-11-03 12:58:38,214 INFO subareas: Creating subareas from exposure perimeter polygon.\n",
+      "2025-11-03 12:58:38,215 INFO subareas: Number of polygons to process: 2\n",
+      "2025-11-03 12:58:38,216 INFO subareas: Processing polygon with bounds: -62.85416667, 17.217222224333334, -62.619220430967744, 17.4125\n",
+      "2025-11-03 12:58:38,216 INFO subareas: Number of cells in x direction: 5, y direction: 4\n",
+      "2025-11-03 12:58:38,221 INFO subareas: Processing polygon with bounds: -62.62943548483871, 17.10416667, -62.5375, 17.196666669000003\n",
+      "2025-11-03 12:58:38,222 INFO subareas: Number of cells in x direction: 2, y direction: 2\n",
+      "2025-11-03 12:58:38,229 INFO subareas: Subareas created.\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "                                            geometry subarea_letter\n",
-      "0  POLYGON ((-62.75417 17.31722, -62.75417 17.289...              A\n",
-      "1  MULTILINESTRING ((-62.83374 17.41250, -62.8235...              B\n",
-      "2  POLYGON ((-62.63669 17.21722, -62.63965 17.217...              C\n",
-      "3  MULTILINESTRING ((-62.61922 17.24806, -62.6192...              D\n",
-      "4  POLYGON ((-62.62944 17.17611, -62.61922 17.176...              E\n"
+      "                                             geometry subarea_letter\n",
+      "0   POLYGON ((-62.80417 17.31722, -62.80417 17.367...              A\n",
+      "1   POLYGON ((-62.80417 17.36722, -62.80417 17.417...              B\n",
+      "2   POLYGON ((-62.75417 17.26722, -62.75417 17.317...              C\n",
+      "3   POLYGON ((-62.75417 17.31722, -62.75417 17.367...              D\n",
+      "4   POLYGON ((-62.75417 17.36722, -62.75417 17.417...              E\n",
+      "5   POLYGON ((-62.70417 17.26722, -62.70417 17.317...              F\n",
+      "6   POLYGON ((-62.70417 17.31722, -62.70417 17.367...              G\n",
+      "7   POLYGON ((-62.70417 17.36722, -62.70417 17.417...              H\n",
+      "8   POLYGON ((-62.65417 17.21722, -62.65417 17.267...              I\n",
+      "9   POLYGON ((-62.65417 17.26722, -62.65417 17.317...              J\n",
+      "10  POLYGON ((-62.65417 17.31722, -62.65417 17.367...              K\n",
+      "11  POLYGON ((-62.60417 17.21722, -62.60417 17.267...              L\n",
+      "12  POLYGON ((-62.60417 17.26722, -62.60417 17.317...              M\n",
+      "13  POLYGON ((-62.57944 17.10417, -62.57944 17.154...              N\n",
+      "14  POLYGON ((-62.57944 17.15417, -62.57944 17.204...              O\n",
+      "15  POLYGON ((-62.52944 17.10417, -62.52944 17.154...              P\n",
+      "16  POLYGON ((-62.52944 17.15417, -62.52944 17.204...              Q\n"
      ]
     },
     {
@@ -228,7 +240,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgEAAAGkCAYAAACo3/ahAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAASxlJREFUeJzt3XtcFOXiP/DP7HKRi4AIGosgEnjDTA3T7CSr5o0IodLsvMI8KZi/9OjhmOkXhUhOlpesvl/9poLaEb8eTxrg/S50s9KyVORYKBdFKeReIbDw/P4gNjcu7i4ryzKf9+s1L92ZZ2ae4XGdDzPPPCMJIQSIiIhIdhTmrgARERGZB0MAERGRTDEEEBERyRRDABERkUwxBBAREckUQwAREZFMMQQQERHJFEMAERGRTDEEEBERyZTJQsCyZcsQEhICT09PSJKEmTNnNlvOx8cHkiQ1O3Xp0sWgfQohMHr0aEiShHnz5jVZnpmZiREjRsDe3h6TJ0/GjRs3dJbX1tZi48aNGD58OFxdXWFvb4/evXtjypQpSElJMaguRERElsZkIWDdunUoLi5GaGgobGxsWiyXkpKC06dP60y7du0CAISHhxu0z/Xr1yM7O7vF5VOnTsVjjz2GQ4cOwc3NDVFRUTrLIyIiMH/+fIwZMwbJycnYt28fli1bBisrKxw5csSguhAREVkcYSJ1dXXavzs4OIgXXnhB73Vfe+01AUAcP35c73VycnKEo6Oj+OijjwQA8fLLL+ssLyoqEt26ddN+Li8vF46OjtrPV69eFQBEbGxss9u/83iIiIg6I5NdCVAojNuUEAJbt26Fr68vxo4dq/d6UVFRGD9+fItXD1xdXSFJEpKTk1FRUYENGzagX79+2uXFxcUAAA8Pj2bXN/Z4iIiILIWVuStw/Phx5OXlISEhAZIk6bVOYmIivvrqK1y6dKnFMgqFAomJiZgxYwYiIiKgUqmQlpamXT5gwAC4uLggPj4eCoUCEyZMgI+PT1sPh4iIyGKYPQQkJSVBqVS22JHwjwoKCrBo0SKsWrUKKpWq1bLh4eEoLCzEtWvX4Ovrq9NXwcHBATt27MALL7yAOXPmAAC6d++OsWPHIiIiAk8++WSL262urkZ1dbX2c319PUpKStC9e3e9gwwREXVuQghUVlZCpVJ13KvLht4/qK2t1Znq6+ublNG3T0BxcbGwtbUVTzzxhN77DwkJEaNHj9bZL5rpE6CvX3/9VaSkpIhFixaJ0aNHC2tr67tuLy4uTgDgxIkTJ06c7jpdu3bNqPNTezDoSkBubi769OmjM+/UqVNQq9WGbEYrOTkZ1dXVmD17tl7ld+/ejcOHD+PTTz9FeXm5zrKamhqUlZXBwcEB1tbWetfBzs4OYWFhCAsLAwDk5+dj8uTJWL9+PebOnYuAgIAm6yxduhTR0dHaz+Xl5fD29sa1a9fg5OSk976JiKjzqqiogJeXF7p27WruqrTIoBCgUqlw5swZnXl3drYzVFJSEnr27ImQkBC9yl+8eBEajQYjR45ssmzz5s3YvHkzUlJStCd0Y3h7eyMqKgoLFy5EZmZmsyHA1tYWtra2TeY7OTkxBBARkY6OfJvYoBBgY2ODwMBAk+z47NmzOH/+PBYvXgwrK/2qMXPmzGavOowZMwZhYWFYsGABBg0apNe2KisrIUkSHB0dmyzLysoCgLv2OSAiIrJkJusYmJGRgaKiIgBAXV0d8vLysHv3bgBAUFAQ3N3ddconJSUBAGbNmtXiNv38/ABAOyCQj49Piz34PT09DbotcfnyZUycOBHTp09HUFAQPDw8UFpaigMHDmDTpk1Qq9UYNWqU3tsjIiKyNCYLAXFxccjIyNB+Tk9PR3p6OoCm/Qaqqqqwc+dOjB49Gn379m1xmxqNxlTVa8LPzw/R0dE4efIk0tLSUFRUBGtra/j7+yMhIQHR0dEdtzcnERGRCUhCCGHuSli6iooKODs7o7y8nH0CiEhvQghoNBrU1dWZuypkBKVSCSsrqxbv+VvCucHs4wQQEclRTU0Nbt68iV9//dXcVaE2sLe3h4eHR6vvzOnIGAKIiNpZfX09cnJyoFQqoVKpYGNj06F7kFNTQgjU1NSgqKgIOTk58Pf3t8hbyAwBRETtrKamBvX19fDy8oK9vb25q0NGsrOzg7W1NfLy8lBTU4MuXbqYu0oGs7zYQkTUSVjib46ky9Lb0LJrT0REREZjCCAiIpIphgAiItLbzJkzIUlSk2nSpEnmrhoZgR0DiYjIIJMmTcLWrVt15jX3PhVLUVtba9CL5zoThgAiIjOK3BuJi0UXzVqHQe6DsDl0s97lbW1tcd999zWZn56ejgkTJuDEiRN47LHHAABr167FypUrceHCBXh4eECtVmvf8ZKcnAylUom5c+dixYoV2sckS0tLsWDBAuzbtw/V1dUICgrCe++9B39/fwBAXl4e5s2bh08//RQ1NTXw8fHB6tWrERwcjG3btmHhwoUoKyvT1is1NRXh4eFoHBvvtddeQ2pqKv76178iISEBubm5qKurQ0VFBV555RWkpqbi9u3bCAwMxLp16/Dggw8a9XO1BAwBRERmdLHoIr64/oW5q2ESarUaCxcuREREBL777jvk5uYiJiYGO3fuhIeHh7bcBx98gFmzZuHLL7/E2bNnERUVhd69eyMyMhJAwy2HH374AXv37oWTkxNeffVVBAcH49KlS7C2tsbLL7+MmpoafPzxx3BwcMClS5eafRlca7Kzs/Hvf/8be/bsgVKpBAA88cQTcHV1xcGDB+Hs7IyNGzdi3Lhx+P777+Hq6mq6H1QHwhBAREQG2b9/f5OT7quvvorly5cjISEBx48fR1RUFDIzMxEREYHw8HCdsl5eXli3bh0kSUK/fv1w4cIFrFu3DpGRkdqT/2effaZ9iduOHTvg5eWF1NRUTJ06Ffn5+Xj66afxwAMPAAB8fX0NPoaamhps375d+3K7kydP4sKFC/jpp5+0tzbWrFmD1NRU7N69G1FRUQbvwxIwBBARkUHGjBmD//3f/9WZ1/ibso2NDZKTkzF48GD07t0b77zzTpP1R44cqTNC4iOPPIK1a9eirq4OWVlZsLKywogRI7TLu3fvjn79+mlf8/7Xv/4Vc+fOxdGjR/H444/j6aefxuDBgw06ht69e+u83fbrr7/Gzz//jO7du+uUq6qqwpUrVwzatiVhCCAiIoM4ODhoX/XenM8//xwAUFJSgpKSEjg4OOi97ZbeaSeE0AaH2bNnY+LEiThw4ACOHj2KlStXYu3atZg/fz4UCkWTbdTW1jZ7DHeqr6+Hh4eH9u23d3JxcdG7/paGIYCIyIwGuQ8ydxVMWocrV67gb3/7GzZv3ox///vfmDFjBk6cOKEzst4XX+j2gfjiiy/g7+8PpVKJgQMHQqPR4Msvv9TeDiguLsb333+PAQMGaNfx8vLCSy+9hJdeeglLly7F5s2bMX/+fLi7u6OyshK//PKL9kT/7bff3rXew4YNQ2FhIaysrODj49P2H4SFYAggIjIjQ3rldxTV1dUoLCzUmWdlZYVu3bohIiICEyZMwF/+8hdMnjwZDzzwANauXYtXXnlFW/batWuIjo7GnDlz8M033+C///u/sXbtWgCAv78/pkyZgsjISGzcuBFdu3bFkiVL4OnpiSlTpgAAFi5ciMmTJ6Nv374oLS3FyZMntQFhxIgRsLe3x3/9139h/vz5+Oqrr7Bt27a7HtPjjz+ORx55BGFhYXjrrbfQr18/3LhxAwcPHkRYWBgCAwNN9NPrWDhYEBERGeTw4cPw8PDQmf70pz/hH//4B3Jzc7Fp0yYAwH333YfExEQsW7ZM57fxGTNmoKqqCg8//DBefvllzJ8/X6fj3datW/HQQw8hJCQEjzzyCIQQOHjwoPZZ/rq6Orz88ssYMGAAJk2ahH79+mHDhg0AGvomJCcn4+DBg3jggQewc+dOvPbaa3c9JkmScPDgQYwePRovvvgi+vbti+nTpyM3Nxc9e/Y03Q+vg5FESzdgSG8VFRVwdnZGeXk5nJyczF0dIurgbt++jZycHPTp08ci3zzXFmq1GkOGDGm2w6Alaq0tLeHcwCsBREREMsUQQEREJFPsGEhERO2muUfwyHx4JYCIiEimGAKIiIhkiiGAiIhIphgCiIiIZIohgIiISKb4dIBcffghEBsLVFaauybGq6oCfv4ZcHQE7OzMXRvDWXr9G3XtCqxYATzzjLlrQkQGYgiQq9hY4D//MXctTKOkxNw1aBtLrz8ALF/OEEB6SU9Px5gxY1BaWtqp385nKRgC5KrxCoBCAXh4mLcuxioo+P3vnp7mq4exLL3+AHDzJlBfb9lXlMggP/30E5YvX45Dhw7hxx9/RLdu3fDggw/itddewyOPPGLu6pGBGALkzsMDuH7d3LUwjlLZcAJSKCzzGCy9/gDQq5dumKFO7+mnn0ZtbS0++OAD+Pr64scff8SJEydQYuYrWjU1NbCxsTFrHSwROwYSEZFeysrK8Omnn+Ktt97CmDFj0Lt3bzz88MNYunQpnnjiCeTm5kKSJJ03BpaVlUGSpCYjBX722Wd48MEH0aVLF4wYMQIXLlzQLisuLsZzzz2HXr16wd7eXvs2wDup1WrMmzcP0dHRcHNzw/jx4wEAly5dQnBwMBwdHdGzZ09ERETg1q1b2vUOHz6MP/3pT3BxcUH37t0REhKCK1euaJfX1NRg3rx58PDwQJcuXeDj44OVK1ea8KfYsTAEEBGRXhwdHeHo6IjU1FRUV1e3aVuvvPIK1qxZgzNnzqBHjx4IDQ1FbW0tgIY38z300EPYv38/Ll68iKioKERERODLL7/U2cYHH3wAKysrfPbZZ9i4cSNu3ryJoKAgDBkyBGfPnsXhw4fx448/Ytq0adp1fvnlF0RHR+PMmTM4ceIEFAoFwsPDUV9fDwB47733sHfvXvz73//G5cuXkZycDB8fnzYda0fG2wFkMlK81K77qxX8B0ydSGAgUFjY/vu97z7g7Fm9ilpZWWHbtm2IjIzE+++/j2HDhiEoKAjTp0/H4MGDDdptXFyc9rf3Dz74AL169UJKSgqmTZsGT09PLFq0SFt2/vz5OHz4MD788EOMGDFCO9/Pzw+rVq3Sfo6NjcWwYcPwxhtvaOdt2bIFXl5e+P7779G3b188/fTTOvVISkpCjx49cOnSJQwaNAj5+fnw9/fHn/70J0iShN69ext0XJaG/4cSEXUEhYUW0b/i6aefxhNPPIFPPvkEp0+fxuHDh7Fq1SokJiZCrVbrvZ07OxG6urqiX79+yMrKAgDU1dXhzTffxK5du1BQUIDq6mpUV1fDwcFBZxuBgYE6n7/++mucOnUKjo6OTfZ35coV9O3bF1euXMHy5cvxxRdf4NatW9orAPn5+Rg0aBBmzpyJ8ePHo1+/fpg0aRJCQkIwYcIEvY/L0jAEEBF1BPfdZzH77dKlC8aPH4/x48cjNjYWs2fPRlxcHD755BMAgBBCW7bxEr8+JKnhauLatWuxbt06vPPOO3jggQfg4OCAhQsXoqamRqf8H0NBfX09nnzySbz11ltNtu3x21NQTz75JLy8vLB582aoVCrU19dj0KBB2m0PGzYMOTk5OHToEI4fP45p06bh8ccfx+7du/U+DkvCEEBE1BHoeUm+Ixo4cCBSU1Ph7u4OALh58yaGDh0KADqdBO/0xRdfwNvbGwBQWlqK77//Hv379wcAfPLJJ5gyZQqef/55AA0n9x9++AEDBgxotR7Dhg3Dnj174OPjAyurpqe34uJiZGVlYePGjXjssccAAJ9++mmTck5OTnj22Wfx7LPP4plnnsGkSZNQUlICV1dXPX4aloUhgIiI9FJcXIypU6fixRdfxODBg9G1a1ecPXsWq1atwpQpU2BnZ4eRI0fizTffhI+PD27duoVly5Y1u63XX38d3bt3R8+ePRETEwM3NzeEhYUBaLjXv2fPHnz++efo1q0b3n77bRQWFt41BLz88svYvHkznnvuObzyyitwc3NDdnY2/vWvf2Hz5s3o1q0bunfvjk2bNsHDwwP5+flYsmSJzjbWrVsHDw8PDBkyBAqFAh9++CHuu+++TjuwEZ8OICIivTg6OmLEiBFYt24dRo8ejUGDBmH58uWIjIzE//zP/wBo6IhXW1uLwMBALFiwAAkJCc1u680338SCBQvw0EMP4ebNm9i7d6/2Of/ly5dj2LBhmDhxItRqNe677z5tQGiNSqXCZ599hrq6OkycOBGDBg3CggUL4OzsDIVCAYVCgX/961/4+uuvMWjQIPztb3/D6tWrmxzjW2+9hcDAQAwfPhy5ubk4ePAgFIrOebqUxJ03b8goFRUVcHZ2Rnl5OZycnMxdHf00DvLi6WmygWra/emAeMBKoGGwnbq6dt23Sdw5WJAl1h+4J/+O5OD27dvIyclBnz590KVLF3NXh9qgtba0hHODyaLNsmXLEBISAk9PT0iShJkzZzZbzsfHB5IkNTsZ+mUQQmD06NGQJAnz5s1rsjwzMxMjRoyAvb09Jk+ejBs3bugsr62txcaNGzF8+HC4urrC3t4evXv3xpQpU5CSkmJQXYiIiCyNyULAunXrUFxcjNDQ0FaHbkxJScHp06d1pl27dgEAwsPDDdrn+vXrkZ2d3eLyqVOn4rHHHsOhQ4fg5uaGqKgoneURERGYP38+xowZg+TkZOzbtw/Lli2DlZUVjhw5YlBdiIiILI3JOgZWVlZq75ls3769xXKNPUbv1HjCnT17tt77y83NxdKlS/HPf/4TTz31VJPlt27dQmFhIdasWaPdr+cdL2nJycnBrl27EBsbi/j4eO38cePGITIyUvvsKBERUWdlsisBxnaaEEJg69at8PX1xdixY/VeLyoqCuPHj2/x6oGrqyskSUJycjIqKiqwYcMG9OvXT7u8uLgYwO/Pjv5RZ+0EQkRE1MjsjwgeP34ceXl5SEhI0A4UcTeJiYn46quvcOnSpRbLKBQKJCYmYsaMGYiIiIBKpUJaWpp2+YABA+Di4oL4+HgoFApMmDChU48P3ZLrFQXwaucOfaamEfWwNuExiDj2lSUieTD7r7tJSUlQKpUtdiT8o4KCAixatAirVq2CSqVqtWx4eDgKCwuRlZWFnJwcnSEmHRwcsGPHDmg0GsyZMwd9+vSBm5sbpk2bhn379rW63erqalRUVOhMRESG4sNZls/S29DgEKDRaHSmtvwASkpKkJqaikmTJuncr2/NSy+9hAcffBCRkZF6lXdwcED//v2b7awYHByM/Px8pKSkYNGiRQgICEBqaipCQ0Obfdqg0cqVK+Hs7KydvLy89KoLEREAWFtbAwB+/fVXM9eE2qqxDRvb1NIYdDsgNzcXffr00Zl36tQpg14acafk5GRUV1fr3SFw9+7dOHz4MD799FOUl5frLKupqUFZWRkcHBwMagw7OzuEhYVpB6LIz8/H5MmTsX79esydOxcBAQFN1lm6dCmio6O1nysqKhgEiEhvSqUSLi4u+OmnnwAA9vb2et8OpY5BCIFff/0VP/30E1xcXKBUKs1dJaMYFAJUKhXOnDmjM+/OznaGSkpKQs+ePRESEqJX+YsXL0Kj0WDkyJFNlm3evBmbN29GSkqKXiNLtcTb2xtRUVFYuHAhMjMzmw0Btra2sLW1NXofRET3/fbinsYgQJbJxcVF25aWyKAQYGNj0+TVjcY6e/Yszp8/j8WLFzf7oofmzJw5s9mrDmPGjEFYWBgWLFiAQYMG6bWtyspKSJLU7CsnG19nebc+B0RExpIkCR4eHujRo4dBb9qjjsPa2tpirwA0MtnTARkZGSgqKgLQ8C7ovLw87asXg4KCtG+XapSUlAQAmDVrVovb9PPzAwDtgEA+Pj4t9uD39PQ06LbE5cuXMXHiREyfPh1BQUHw8PBAaWkpDhw4gE2bNkGtVmPUqFF6b4+IyBhKpdLiTyRkuUwWAuLi4pCRkaH9nJ6ejvT0dABN+w1UVVVh586dGD16NPr27dviNjUajamq14Sfnx+io6Nx8uRJpKWloaioCNbW1vD390dCQgKio6M5VgAREXVqJgsBjSd8fdjZ2aGsrOyu5XJzc/XanjFPKLi4uCAmJgYxMTEGr0tERNQZ8FddIiIimTL7iIFEHY0pX4nM0QeJqCPjlQAiIiKZYgggIiKSKYYAIiIimWIIICIikimGACIiIpliCCAiIpIphgAiIiKZYgggIiKSKYYAIiIimWIIICIikimGACIiIpliCCAiIpIphgAiIiKZYgggIiKSKYYAIiIimWIIICIikimGACIiIpliCCAiIpIphgAiIiKZYgggIiKSKStzV4CoM5PipRaX1YqGL6BG1MO6lXL3kogTZtkvEXUMvBJAREQkUwwBREREMiUJIXg9sI0qKirg7OyM8vJyODk5mbs6+uneHSgpgQBQZ54r0W1m9du/XEs9ho5Qfyupjb8H1Nc3/ClJgErV9gqZS9euwIoVwDPPmLsm1IlYwrmBfQLk6uefAQASfj8ZWSpLPwaz1l/Um2g7AigoMM22zGX5coYAkh2GALlydLT4KwFK0XACtdRj6Aj1N9mVAADw9Gzbtszl5s2G46isNHdNiNodQ4Bc2dkBAAq6Al5/N3NdjFQb3/AbdJ0EWMeZuzaG6wj1F3F1bduAUtlwAlUogOvXTVOp9tarl+VfxSAyEjsGEhERyRRDABERkUwxBBAREckUQwAREZFMsWMgkYy1NqzxnTi8MFHnxCsBREREMsUQQEREJFMMAURERDLFEEBERCRTJgsBy5YtQ0hICDw9PSFJEmbOnNlsOR8fH0iS1OzUpUsXg/YphMDo0aMhSRLmzZvXZHlmZiZGjBgBe3t7TJ48GTdu3NBZXltbi40bN2L48OFwdXWFvb09evfujSlTpiAlJcWguhAREVkak4WAdevWobi4GKGhobCxsWmxXEpKCk6fPq0z7dq1CwAQHh5u0D7Xr1+P7OzsFpdPnToVjz32GA4dOgQ3NzdERUXpLI+IiMD8+fMxZswYJCcnY9++fVi2bBmsrKxw5MgRg+pCRERkaUz2iGBlZSUUioZMsX379hbLDR06tMm8xhPu7Nmz9d5fbm4uli5din/+85946qmnmiy/desWCgsLsWbNGu1+Pe94wUlOTg527dqF2NhYxMfHa+ePGzcOkZGRqK830dvViIiIOiiTXQloDACGEkJg69at8PX1xdixY/VeLyoqCuPHj2/x6oGrqyskSUJycjIqKiqwYcMG9OvXT7u8uLgYAODh4dHs+sYeDxERkaUw+2BBx48fR15eHhISEiBJ+g1ckpiYiK+++gqXLl1qsYxCoUBiYiJmzJiBiIgIqFQqpKWlaZcPGDAALi4uiI+Ph0KhwIQJE+Dj49PWwyEiIrIYZv91NykpCUqlssWOhH9UUFCARYsWYdWqVVCpVK2WDQ8PR2FhIbKyspCTk4PAwEDtMgcHB+zYsQMajQZz5sxBnz594ObmhmnTpmHfvn2tbre6uhoVFRU6ExERkaUxOARoNBqdSQjjhxMtKSlBamoqJk2apHO/vjUvvfQSHnzwQURGRupV3sHBAf3792+2s2JwcDDy8/ORkpKCRYsWISAgAKmpqQgNDW32aYNGK1euhLOzs3by8vLSqy5EREQdiUEhIDc3F9bW1jpTRkaG0TtPTk5GdXW13h0Cd+/ejcOHD2PVqlUoLy9HWVkZysrKAAA1NTUoKytDbW2tQXWws7NDWFgYVq9ejYyMDGRnZ2PgwIFYv349MjMzm11n6dKlKC8v107Xrl0zaJ9EREQdgUEhQKVS4cyZMzrTQw89ZPTOk5KS0LNnT4SEhOhV/uLFi9BoNBg5ciS6deumnQBg8+bN6NatGw4cOGB0fQDA29tb+yhhSyHA1tYWTk5OOhMREZGlMahjoI2Njc599bY4e/Yszp8/j8WLF8PKSr9qzJw5E2q1usn8MWPGICwsDAsWLMCgQYP02lZlZSUkSYKjo2OTZVlZWQBw1z4HRERElsxkTwdkZGSgqKgIAFBXV4e8vDzs3r0bABAUFAR3d3ed8klJSQCAWbNmtbhNPz8/ANAOCOTj49NiD35PT89mA0JLLl++jIkTJ2L69OkICgqCh4cHSktLceDAAWzatAlqtRqjRo3Se3tERESWxmQhIC4uTqd/QHp6OtLT0wEAp06d0jlBV1VVYefOnRg9ejT69u3b4jY1Go2pqteEn58foqOjcfLkSaSlpaGoqAjW1tbw9/dHQkICoqOjOVYAERF1aiYLAY0nfH3Y2dlpO/S1Jjc3V6/tGfOEgouLC2JiYhATE2PwukRERJ0Bf9UlIiKSKYYAIiIimWIIICIikimzvzuAzKuXkydE3PVWy0jx+r3TgTqvlv4N1IqG/0Q0oh7W8RJEnPEjiBJR++OVACIiIpliCCAiIpIphgAiIiKZYgggIiKSKYYAIiIimWIIICIikimGACIiIpliCCAiIpIphgAiIiKZ4oiBdFf6jgLHkQVJ338DHFmQqGPglQAiIiKZYgggIiKSKYYAIiIimWIIICIikimGACIiIpliCCAiIpIphgAiIiKZYgggIiKSKYYAIiIimWIIICIikikOG0wm0+5Dwb6uBER9++6TTILDCxN1DJIQgt+yNqqoqICzszPKy8vh5ORk7urop1cvoKAAUCgADw9z18Y4BQUAAAGgzgJfW2D12zfPUusP3PtjsJLa4WJl/W9BUpIAlere7+9e6doVWLECeOYZc9eEfmMJ5wZeCZCrrl0b/qyv155MLZWE309GlsjS6w/cw2Nozys9Qlj8dwHLlzMEkEEYAuRqxYqG/zAqK81dE+PduAEIYbG/SStFw8nTUusP3PtjaNcrAQDg6Xnv93cv3LzZcByW/H0ms2AIkKtnnrH83xh+u6VR0BXw+ru5K2O42viG357rJMA6zty1Mc69PgYRV2f6jf6RUtlwAlUogOvX7/3+7oXG23tEBuLTAURERDLFEEBERCRTDAFEREQyxRBAREQkUwwBREREMsWnA8ji9XLyhIgzXa9ufUezIyKydLwSQEREJFMMAURERDLFEEBERCRTJgsBy5YtQ0hICDw9PSFJEmbOnNlsOR8fH0iS1OzUpUuXu+7nvffew8iRI+Hm5gZbW1t4e3tj+vTpyMzMbFI2MzMTI0aMgL29PSZPnowbN27oLK+trcXGjRsxfPhwuLq6wt7eHr1798aUKVOQkpJi1M+BiIjIUpgsBKxbtw7FxcUIDQ2FjY1Ni+VSUlJw+vRpnWnXrl0AgPDw8Lvup7i4GJMnT0ZiYiKOHj2K+Ph4nDt3DiNGjMDly5d1yk6dOhWPPfYYDh06BDc3N0RFReksj4iIwPz58zFmzBgkJydj3759WLZsGaysrHDkyBEjfgpERESWw2RPB1RWVkKhaMgU27dvb7Hc0KFDm8xrPOHOnj37rvuJj4/X+RwUFISRI0di4MCB2LFjB15//XUAwK1bt1BYWIg1a9Zo9+t5x8tBcnJysGvXLsTGxupsc9y4cYiMjER9Pd9TT0REnZvJrgQ0BgBDCSGwdetW+Pr6YuzYsUZtw93dHQBgZfV7pnF1dYUkSUhOTkZFRQU2bNiAfv36aZcXFxcDADw8PJrdprHHQ0REZCnMPk7A8ePHkZeXh4SEBEiS/s9n19XVQaPRICcnB0uWLEGPHj3wl7/8RbtcoVAgMTERM2bMQEREBFQqFdLS0rTLBwwYABcXF8THx0OhUGDChAnw8fEx5aERERF1aGYPAUlJSVAqlS12JGyJg4MDqqurAQB9+/ZFeno6vLy8dMqEh4ejsLAQ165dg6+vr05fBQcHB+zYsQMvvPAC5syZAwDo3r07xo4di4iICDz55JMt7ru6ulq7bwCoqKgwqO5EREQdgcHXvDUajc4khDB65yUlJUhNTcWkSZN07tfr4/PPP8fp06eRnJyMrl27YsyYMc0+IeDg4ID+/fs321kxODgY+fn5SElJwaJFixAQEIDU1FSEhoZi3rx5Le575cqVcHZ21k5/DB9ERESWwKArAbm5uejTp4/OvFOnTkGtVhu18+TkZFRXV+vVIfCPhg0bBgAYOXIkQkND4efnh//6r//SueSvDzs7O4SFhSEsLAwAkJ+fj8mTJ2P9+vWYO3cuAgICmqyzdOlSREdHaz9XVFQwCHQiIk6/YMvhhYnI0hkUAlQqFc6cOaMz787OdoZKSkpCz549ERISYvQ2AKBr167o378/vv/++zZtBwC8vb0RFRWFhQsXIjMzs9kQYGtrC1tb2zbvi4iIyJwMCgE2NjYIDAw0yY7Pnj2L8+fPY/HixTq9+o1x69YtXLhwAY8++qje61RWVkKSJDg6OjZZlpWVBaAh9BAREXVWJusYmJGRgaKiIgANPffz8vKwe/duAA3P8jc+xtcoKSkJADBr1qwWt+nn5wcAyM7OBgCUl5dj/Pjx+POf/wx/f3/Y2dnh+++/x7vvvovq6mrExcXpXd/Lly9j4sSJmD59OoKCguDh4YHS0lIcOHAAmzZtglqtxqhRo/T/ARAREVkYk4WAuLg4ZGRkaD+np6cjPT0dQNN+A1VVVdi5cydGjx6Nvn37trhNjUaj87lLly548MEHsWnTJly7dg23b9/GfffdB7VajT179mDgwIF619fPzw/R0dE4efIk0tLSUFRUBGtra/j7+yMhIQHR0dEcK4CIiDo1k4WAxhO+Puzs7FBWVnbXcrm5uTqfbW1tsXnzZsMq1gIXFxfExMQgJibGJNsjIiKyNPxVl4iISKYYAoiIiGSKIYCIiEimGAKIiIhkyuzvDiCyVPqOLNii15WAqIeVpICIqzNNpdrbH47B1KMo6ru9NrcFkUzxSgAREZFMMQQQERHJFEMAERGRTDEEEBERyRRDABERkUwxBBAREckUQwAREZFMMQQQERHJFEMAERGRTDEEEBERyRSHDSYikzH18L36DhvM4YWJjMMrAURERDLFEEBERCRTDAFEREQyxRBAREQkUwwBREREMsUQQEREJFMMAURERDLFEEBERCRTDAFEREQyxREDiajD0neEv7aMLFgrGv4j1Ih6WOu5nUYcgZAsHUMAWb6bN4FevcxdC8PV1//+pyXWH9A9BqXSbNWobcO52Oq3dZUCqI03cOXXzXfMOhrboarKvPUgi8MQQJara9eGP+vrgYIC89alrSy9/sDvJyIzMMV/ZBJ+DwR6E+Y75mZZ8b90Mgz/xZDlWrECWL4cqKw0d02MU1XV8J+2tbW5a2K8GzcA8duZU2G+LkaaNpyMlaIhAAgAdYbdDYCV1EG6VTUGMEv+t0RmwRBAluuZZxomMp9evRquYnh6Atevm60aht7Lv1NtfMMVgDoJsI4zbF0RV2f0fk2qsR2IDNRBYiwRERG1N4YAIiIimWIIICIikimGACIiIpliCCAiIpIphgAiIiKZ4iOCRERG0ne4Yg4vTB0VrwQQERHJlMlCwLJlyxASEgJPT09IkoSZM2c2W87HxweSJDU7denSpdV91NXV4e2338akSZPQq1cv2NvbY8CAAViyZAnKysqalM/MzMSIESNgb2+PyZMn48aNGzrLa2trsXHjRgwfPhyurq6wt7dH7969MWXKFKSkpBj7oyAiIrIIJgsB69atQ3FxMUJDQ2FjY9NiuZSUFJw+fVpn2rVrFwAgPDy81X1UVVXhtddeQ+/evfHOO+/g4MGDiIyMxKZNm/Doo4+i6g8vz5g6dSoee+wxHDp0CG5uboiKitJZHhERgfnz52PMmDFITk7Gvn37sGzZMlhZWeHIkSNG/iSIiIgsg8n6BFRWVkLx29jh27dvb7Hc0KFDm8xrPOHOnj271X3Y2dkhJycH3bt3185Tq9Xw9vbG1KlTsWfPHjz//PMAgFu3bqGwsBBr1qzR7tfT01O7Xk5ODnbt2oXY2FjEx//+6rBx48YhMjIS9WZ8GQoREVF7MNmVAIWRLw8RQmDr1q3w9fXF2LFjWy2rVCp1AkCjhx9+GABw7do17TxXV1dIkoTk5GRUVFRgw4YN6Nevn3Z5cXExAMDDw6PZfRl7PERERJbC7E8HHD9+HHl5eUhISIAkGfcSkJMnTwIAAgICtPMUCgUSExMxY8YMREREQKVSIS0tTbt8wIABcHFxQXx8PBQKBSZMmAAfH582HQsREZElMfuvu0lJSVAqlS12JLybgoICLFmyBIGBgQgJCdFZFh4ejsLCQmRlZSEnJweBgYHaZQ4ODtixYwc0Gg3mzJmDPn36wM3NDdOmTcO+ffta3Wd1dTUqKip0JiIiIktjcAjQaDQ6kxDGP/9aUlKC1NRUTJo0Sed+vSHrBwcHQwiBXbt2NXsJ38HBAf3792+2s2JwcDDy8/ORkpKCRYsWISAgAKmpqQgNDcW8efNa3O/KlSvh7Oysnby8vAyuOxERkbkZFAJyc3NhbW2tM2VkZBi98+TkZFRXV9+1Q2BzSktLMX78eBQUFODYsWPw9fU1qg52dnYICwvD6tWrkZGRgezsbAwcOBDr169HZmZms+ssXboU5eXl2unOvghERESWwqA+ASqVCmfOnNGZd2dnO0MlJSWhZ8+eTS7j301paSkef/xx5OTk4MSJExg8eLDRdfgjb29vREVFYeHChcjMzNTpZ9DI1tYWtra2JtsnEXVuHFmQOiqDQoCNjY3OffW2OHv2LM6fP4/FixfDykr/ajQGgKtXr+LYsWPNPnKoj8rKSkiSBEdHxybLsrKyADSEHiIios7KZE8HZGRkoKioCEDDyH55eXnYvXs3ACAoKAju7u465ZOSkgAAs2bNanGbfn5+AIDs7GwADYMFTZw4EefOncM777wDjUaDL774Qlve3d0d999/v171vXz5MiZOnIjp06cjKCgIHh4eKC0txYEDB7Bp0yao1WqMGjVKz6MnIiKyPCYLAXFxcTr9A9LT05Geng4AOHXqFNRqtXZZVVUVdu7cidGjR6Nv374tblOj0eh8/vHHH7W3IxYsWNCk/AsvvIBt27bpVV8/Pz9ER0fj5MmTSEtLQ1FREaytreHv74+EhARER0dzrAAiIurUTBYCGk/4+rCzs2t2rP8/ys3N1fns4+PTpqcR7uTi4oKYmBjExMSYZHtERESWhr/qEhERyRRDABERkUwxBBAREckUQwAREZFMMQQQERHJFEMAERGRTDEEEBERyRRDABERkUwxBBAREckUQwAREZFMMQQQERHJFEMAERGRTDEEEBERyRRDABERkUwxBBAREckUQwAREZFMWZm7AkREbSXihPErv64ERD2sJAVEXB0AQIqXTFSzBm2qH9E9xCsBREREMsUQQEREJFMMAURERDLFEEBERCRTDAFEREQyxRBAREQkUwwBREREMsUQQEREJFMMAURERDLFEQOJqO1u3gR69TJ3LYxTX//7n78dw7UKE+9j8z3+2RQU3NvtU6fFEEBExuvateHP+vrOcSL67RhMfsqubKefTXR0++yHOg2GACIy3ooVwPLlQGWluWtivKoqwMoKsLY2d03aJjqaIYAMxhBARMZ75pmGiYgsEjsGEhERyRRDABERkUwxBBAREckUQwAREZFMMQQQERHJFEMAERGRTDEEEBERyRRDABERkUwxBBAREcmUyUYMXLZsGb799lucO3cON27cwAsvvIBt27Y1Kefj44O8vLxmt2Fra4vbt2+3uI+6ujq8++67OHr0KC5evIiSkhL07t0bU6ZMwZIlS+Di4qJTPjMzEy+++CIuXLiAoKAgJCUlQaVSaZfX1tZiy5YtSExMxJUrV3D79m24u7tjyJAhmDlzJsLDw436WRARaX34IRAba/lDK//8M+DoCNjZmbs2xuvatWGoa45yqSUJIYQpNuTg4IDBgwdjyJAh2LJlC5577rlmQ8C5c+dQXV2tMy8/Px/PPvsspk+fjp07d7a4j59//hkqlQrPPfccxo8fDzc3N3zzzTdISEiAh4cHzp49C7s7/oEOHDgQwcHBePLJJ5GYmIjS0lLs379fu3z69On46KOPsHDhQqjVatja2uLq1as4fPgw3N3d8f777+t17BUVFXB2dkZ5eTmcnJz0WoeIZGLAAOA//zF3LahR//5AVla77MoSzg0muxJQWVkJhaLh7sL27dtbLDd06NAm844cOQIAmD17dqv7sLOzQ05ODrp3766dp1ar4e3tjalTp2LPnj14/vnnAQC3bt1CYWEh1qxZo92vp6endr2cnBzs2rULsbGxiI+P184fN24cIiMjUd/4elEiorZovAKgUAAeHuati7HufEPkHf+PWpSbNxvedmnJV2TuAZOFgMYAYCghBLZu3QpfX1+MHTu21bJKpVInADR6+OGHAQDXrl3TznN1dYUkSUhOTkZoaCg2bNiAfv36aZcXFxcDADxa+FIaezxERM3y8ACuXzd3LYyjVDacQBUKyz2GXr06x+uuTczsbxE8fvw48vLykJCQAEmSjNrGyZMnAQABAQHaeQqFAomJiZgxYwYiIiKgUqmQlpamXT5gwAC4uLggPj4eCoUCEyZMgI+Pj177q66u1rmlUVFRYVS9iYiIzMnsv+4mJSVBqVRi5syZRq1fUFCAJUuWIDAwECEhITrLwsPDUVhYiKysLOTk5CAwMFC7zMHBATt27IBGo8GcOXPQp08fuLm5Ydq0adi3b1+r+1y5ciWcnZ21k5eXl1F1JyIiMieDQ4BGo9GZ2tKvsKSkBKmpqZg0aZLO/XpD1g8ODoYQArt27Wr2Er6DgwP69+8PGxubJsuCg4ORn5+PlJQULFq0CAEBAUhNTUVoaCjmzZvX4n6XLl2K8vJy7XTnbQgiIiJLYVAIyM3NhbW1tc6UkZFh9M6Tk5NRXV191w6BzSktLcX48eNRUFCAY8eOwdfX16g62NnZISwsDKtXr0ZGRgays7MxcOBArF+/HpmZmc2uY2trCycnJ52JiIjI0hjUJ0ClUuHMmTM68+7sbGeopKQk9OzZs8ll/LspLS3F448/jpycHJw4cQKDBw82ug5/5O3tjaioKCxcuBCZmZk6/QyIiIg6E4NCgI2Njc599bY4e/Yszp8/j8WLF8PKSv9qNAaAq1ev4tixY80+cqiPyspKSJIER0fHJsuyfnuG9M6BhYiI7jUp3rjO0fdarWg4WWhEPazNUEcRZ5LhbKgZJns6ICMjA0VFRQAaRvbLy8vD7t27AQBBQUFwd3fXKZ+UlAQAmDVrVovb9PPzAwBkZ2cDAKqqqjBx4kScO3cO77zzDjQaDb744gtteXd3d9x///161ffy5cuYOHEipk+fjqCgIHh4eKC0tBQHDhzApk2boFarMWrUKD2PnoiIyPKYLATExcXp9A9IT09Heno6AODUqVNQq9XaZVVVVdi5cydGjx6Nvn37trhNjUaj8/nHH3/U3o5YsGBBk/ItDVXcHD8/P0RHR+PkyZNIS0tDUVERrK2t4e/vj4SEBERHR3OsACIi6tRMFgIaT/j6sLOzQ1lZ2V3L5ebm6nz28fFp09MId3JxcUFMTAxiYmJMsj0iIiJLw191iYiIZIohgIiISKYYAoiIiGSKIYCIiEimGAKIiIhkiiGAiIhIpsz+KmEiIqLW6DuSIkcWNByvBBAREckUQwAREZFMMQQQERHJFEMAERGRTDEEEBERyRRDABERkUwxBBAREckUQwAREZFMMQQQERHJFEMAERGRTHHYYCKidnC9ogBeeg5/S9ReeCWAiIhIphgCiIiIZIohgIiISKYYAoiIiGSKIYCIiEimGAKIiIhkiiGAiIhIphgCiIiIZIohgIiISKYYAoiIiGSKIYCIiEimGAKIiIhkiiGAiIhIphgCiIiIZIohgIiISKYYAoiIiGSKIYCIiEimGAKIiIhkiiGAiIhIphgCiIiIZMrKVBtatmwZvv32W5w7dw43btzACy+8gG3btjUp5+Pjg7y8vGa3YWtri9u3b7e4j7q6Orz77rs4evQoLl68iJKSEvTu3RtTpkzBkiVL4OLiolM+MzMTL774Ii5cuICgoCAkJSVBpVJpl9fW1mLLli1ITEzElStXcPv2bbi7u2PIkCGYOXMmwsPDjfpZEBFpVVUBADwrgdp4M9fFSFai4U+l6ODH8Lqy5WX19Q1//tYe1EASQghTbMjBwQGDBw/GkCFDsGXLFjz33HPNhoBz586hurpaZ15+fj6effZZTJ8+HTt37mxxHz///DNUKhWee+45jB8/Hm5ubvjmm2+QkJAADw8PnD17FnZ2dtryAwcORHBwMJ588kkkJiaitLQU+/fv1y6fPn06PvroIyxcuBBqtRq2tra4evUqDh8+DHd3d7z//vt6HXtFRQWcnZ1RXl4OJycnvdYhIpmwtQVqasxdC2rUowfw44/tsitLODeY7EpAZWUlFIqGuwvbt29vsdzQoUObzDty5AgAYPbs2a3uw87ODjk5Oejevbt2nlqthre3N6ZOnYo9e/bg+eefBwDcunULhYWFWLNmjXa/np6e2vVycnKwa9cuxMbGIj7+92g7btw4REZGor4xNRIRtYWjI1BSAgGgTjJ3ZYyjFIAEdPhjsJJaucPd+H+6tXX7VMZCmCwENAYAQwkhsHXrVvj6+mLs2LGtllUqlToBoNHDDz8MALh27Zp2nqurKyRJQnJyMkJDQ7Fhwwb069dPu7y4uBgA4OHh0ey+jD0eIiIdv12dLOgKeP3dzHUxUm18wy2BOgmwjjN3bVom4upaXtirF1BQ0H6VsRAmCwHGOn78OPLy8pCQkABJMi5injx5EgAQEBCgnadQKJCYmIgZM2YgIiICKpUKaWlp2uUDBgyAi4sL4uPjoVAoMGHCBPj4+Oi1v+rqap1bGhUVFUbVm4iIyJzM/utuUlISlEolZs6cadT6BQUFWLJkCQIDAxESEqKzLDw8HIWFhcjKykJOTg4CAwO1yxwcHLBjxw5oNBrMmTMHffr0gZubG6ZNm4Z9+/a1us+VK1fC2dlZO3l5eRlVdyIiInMyOARoNBqdqS39CktKSpCamopJkybp3K83ZP3g4GAIIbBr165mL+E7ODigf//+sLGxabIsODgY+fn5SElJwaJFixAQEIDU1FSEhoZi3rx5Le536dKlKC8v10533oYgIiKyFAaFgNzcXFhbW+tMGRkZRu88OTkZ1dXVd+0Q2JzS0lKMHz8eBQUFOHbsGHx9fY2qg52dHcLCwrB69WpkZGQgOzsbAwcOxPr165GZmdnsOra2tnByctKZiIiILI1BfQJUKhXOnDmjM+/OznaGSkpKQs+ePZtcxr+b0tJSPP7448jJycGJEycwePBgo+vwR97e3oiKisLChQuRmZmp08+AiIioMzEoBNjY2OjcV2+Ls2fP4vz581i8eDGsrPSvRmMAuHr1Ko4dO9bsI4f6qKyshCRJcHR0bLIsKysLAHQGFiIiIupsTPZ0QEZGBoqKigA0jOyXl5eH3bt3AwCCgoLg7u6uUz4pKQkAMGvWrBa36efnBwDIzs4GAFRVVWHixIk4d+4c3nnnHWg0GnzxxRfa8u7u7rj//vv1qu/ly5cxceJETJ8+HUFBQfDw8EBpaSkOHDiATZs2Qa1WY9SoUXoePRERkeUxWQiIi4vT6R+Qnp6O9PR0AMCpU6egVqu1y6qqqrBz506MHj0affv2bXGbGo1G5/OPP/6ovR2xYMGCJuVbGqq4OX5+foiOjsbJkyeRlpaGoqIiWFtbw9/fHwkJCYiOjuZYAURE1KmZLAQ0nvD1YWdnh7KysruWy83N1fns4+PTpqcR7uTi4oKYmBjExMSYZHtERESWhr/qEhERyRRDABERkUwxBBAREckUQwAREZFMMQQQERHJFEMAERGRTDEEEBERyRRDABERkUwxBBAREckUQwAREZFMMQQQERHJFEMAERGRTDEEEBERyRRDABERkUwxBBAREckUQwAREZFMMQQQERHJFEMAERGRTFmZuwJERHLQy8kTIu56q2WkeKmdakPUgFcCiIiIZIohgIiISKYYAoiIiGSKIYCIiEimGAKIiIhkiiGAiIhIphgCiIiIZIohgIiISKYYAoiIiGSKIYCIiEimGAKIiIhkiiGAiIhIphgCiIiIZIohgIiISKYYAoiIiGSKIYCIiEimGAKIiIhkiiGAiIhIphgCiIiIZMrKVBtatmwZvv32W5w7dw43btzACy+8gG3btjUp5+Pjg7y8vGa3YWtri9u3b7e6n08//RTbtm3DuXPncPHiRdTU1CAnJwc+Pj5NymZmZuLFF1/EhQsXEBQUhKSkJKhUKu3y2tpabNmyBYmJibhy5Qpu374Nd3d3DBkyBDNnzkR4eLhBPwMiohbdvAn06tVqkWsV7VQXA1mJhj+VAri21rx1adXmVn6+BQXtVw8LYrIQsG7dOgwePBihoaHYsmVLi+VSUlJQXV2tMy8/Px/PPvusXifdEydO4Pjx4xg6dCicnJyQnp7eYtmpU6ciODgYq1atQmJiIqKiorB//37t8oiICHz00UdYuHAh4uPjYWtri6tXr+Lw4cM4cuQIQwARtV3Xrg1/1tff9UTUekQwPwlAr0pz16IVlXqc6KOj7309LIgkhBCm2FB9fT0Uioa7C46OjnjmmWeavRLQnPj4eLz22ms4fvw4xo0bp/d+1qxZg1deeaXZKwG3bt1C3759UVJSAgCoqKiAp6cnKisb/gXn5OTA19cXsbGxiI+Pb3U/d1NRUQFnZ2eUl5fDyclJr3WISCZ27waWLwcqO/LZ8y6qqgArK8Da2tw1aZvo6HYNAZZwbjDZlQB9T5h/JITA1q1b4evri7Fjx5psP66urpAkCcnJyQgNDcWGDRvQr18/7fLi4mIAgIeHR5v2Q0TUqmeeaZiIOiCThQBjHT9+HHl5eUhISIAkSSbbrkKhQGJiImbMmIGIiAioVCqkpaVplw8YMAAuLi6Ij4+HQqHAhAkTmu1XQERE1FmZ/dfdpKQkKJVKzJw50+TbDg8PR2FhIbKyspCTk4PAwEDtMgcHB+zYsQMajQZz5sxBnz594ObmhmnTpmHfvn2tbre6uhoVFRU6ExERkaUxOARoNBqdqS1dCkpKSpCamopJkybB09PT6O20xsHBAf3794eNjU2TZcHBwcjPz0dKSgoWLVqEgIAApKamIjQ0FPPmzWtxmytXroSzs7N28vLyuid1JyIiupcMCgG5ubmwtrbWmTIyMozeeXJyMqqrqzF79myjt9FWdnZ2CAsLw+rVq5GRkYHs7GwMHDgQ69evR2ZmZrPrLF26FOXl5drp2rVr7VxrIiKitjOoT4BKpcKZM2d05t3Z2c5QSUlJ6NmzJ0JCQozehql5e3sjKioKCxcuRGZmJgICApqUsbW1ha2trRlqR0REZDoGhQAbGxud++ptcfbsWZw/fx6LFy+GlVX790+srKyEJElwdHRssiwrKwsAdAYWIiIi6mxMdvbNyMhAUVERAKCurg55eXnYvXs3ACAoKAju7u465ZOSkgAAs2bNanGbfn5+AIDs7GztvKKiIu0tiAsXLgAADh06BHd3d7i7uyMoKEiv+l6+fBkTJ07E9OnTERQUBA8PD5SWluLAgQPYtGkT1Go1Ro0apde2iIiILJHJBgtSq9Ut9g84deoU1Gq19nNVVRU8PDzw4IMPttqnoPGRvdzcXO289PR0jBkzptnyQUFBrY4geKeysjKsX78eJ0+exOXLl1FUVARra2v4+/vjmWeeQXR0NOzs7PTaliUMCEFERO3LEs4NJgsBcmYJDU1ERO3LEs4NZh8ngIiIiMyDIYCIiEimGAKIiIhkyuzvDugMGrtVcPhgIiJq1HhO6Mhd7xgCTKDxjYQcPpiIiP6ouLgYzs7O5q5GsxgCTMDV1RUAkJ+f32EbWg4qKirg5eWFa9euddieuJ0d26BjYDt0DOXl5fD29taeIzoihgATUCgaulY4OzvzC9cBODk5sR3MjG3QMbAdOobGc0RH1HFrRkRERPcUQwAREZFMMQSYgK2tLeLi4vhmQTNjO5gf26BjYDt0DJbQDhw2mIiISKZ4JYCIiEimGAKIiIhkiiGAiIhIpjptCPj0008RHByMbt26wc7ODv7+/lixYgUAoK6uDm+//TYmTZqEXr16wd7eHgMGDMCSJUtQVlam1/ZramoQGxuLPn36wMbGBr1798bSpUtRVVXVpOwnn3yCgIAAODo64s9//rPO8MKDBg3CgAEDmqyTkpICSZLwyCOPNFm2fft2SJKEvXv36vnTMJ973Q7V1dVYvXo1Bg0aBAcHB/Ts2ROTJ0/G559/3qSsXNvhXrZBbm4uJElqcZo0aZJOebm2AXDvvwsA8MsvvyA2NhZ9+/aFra0tunfvjjFjxuCHH37QKcd2uHftoFar9fouAB2kHUQntGPHDqFQKMT06dPF3r17xcmTJ8XmzZtFfHy8EEKIyspK0bVrVxEVFSU+/PBDcerUKbF27VrRrVs3MXDgQPHrr7/edR9PPfWU6NKli3jjjTfEsWPHxOuvvy5sbGzEk08+qVPu559/Fu7u7uKtt94Sp06dEhMmTBAvv/yydvm8efMEAHHz5k2d9f76178KBwcHYWVlJSoqKnSWvfjii0KhUIjS0lIjf0Ltoz3aISIiQigUChETEyNOnDghPvzwQ/HQQw8JKysr8eWXX2rLybUd7nUb3L59W5w+fbrJ9OqrrwoA4v3339eWlWsbCNE+34XKykoRGBgoVCqVeO+990R6erpIS0sTr776qvj222+15dgO97YdgoKChK+vb5PvRFZWlk65jtIOnS4EXL9+XTg4OIi5c+e2WEaj0Yhbt241mf/hhx8KAGL79u2t7uP06dMCgFi7dq3O/DfeeEMAEEePHtXOO3PmjBg6dKj283fffScGDRqk/bxnzx4BQOzcuVNnW4MHDxYLFiwQ1tbW4uDBgzrLfH19xUMPPdRqHc2tPdrh9u3bQqlUiueff15n/o0bNwQA8de//lU7T47t0B5t0BK1Wi3s7e1FeXm5dp4c20CI9muHBQsWCAcHB3HlypVWy7Ed7m07BAUFiYCAgLuW6yjt0OluByQmJuKXX37Bq6++2mIZpVKJ7t27N5n/8MMPAwCuXbvW6j4+++wzAEBwcLDO/JCQEADAnj17tPO8vb2RnZ2No0ePoqysDJs2bUK/fv20yxsvHaWnp2vnFRcX48KFC3jiiSfw0EMP4dSpU9pl165dw9WrVzFmzJhW62hu7dEOCoUCCoWiyfsanJycoFAo0KVLF+08ObZDe7RBc65cuYKMjAxMmzZNZ8haObYB0D7t8OuvvyIxMRFTp06Fr69vq2XZDu37fWhJR2mHThcCPv74Y7i6uuI///kPhgwZAisrK/To0QMvvfTSXV/1e/LkSQBAQEBAq+VqamoAoMkAEI2fz58/r53Xo0cPvPnmmwgJCUG3bt1w4sQJrF69Wrvc1dUVgwcP1mnMjIwMKJVKjBo1CkFBQTr/CBrLdfQvXHu0g7W1Nf7f//t/+OCDD5CamoqKigrk5uYiMjISzs7OiIyM1JaVYzu0Rxs0Z8uWLRBCYPbs2Trz5dgGQPu0w9dff41ffvkF/v7+mDt3Lrp16wYbGxsEBgbiwIEDOmXZDvf++3DlyhW4urrCysoK999/P2JiYpr0F+sw7WDQdQML0K9fP9GlSxfRtWtX8cYbb4hTp06JVatWCTs7O/Hoo4+K+vr6Zte7fv266NmzpwgMDBR1dXWt7iM1NbXZS0NJSUkCgOjbt2+TdcrKysTly5eFRqNpsmzhwoUCgLhx44YQQoj58+eLkSNHCiGEOHjwoFAqldrLqn/5y1+EUqlsci+oo2mPdhBCiPr6ehEbGysUCoUAIAAIb29vce7cuWbLy6kd2qsN7qTRaISnp6fo379/i2Xk1AZCtE877Ny5UwAQTk5O4tFHHxV79+4V+/fvF2PGjBGSJInDhw83WYftcG++DzExMWLDhg3i5MmT4sCBA2LevHnCyspKjB49utn1zd0OnS4E+Pv7CwBi5cqVOvPfeecdAUAcO3asyTrFxcVi8ODBokePHne9nyaEENXV1cLPz0+oVCpx9OhRUVpaKg4dOiR69uwplEplq/8BNictLU0AEP/3f/8nhBDigQceEEuWLBFCCFFRUSGUSqXYt2+fEEKIPn36iBEjRhi0fXNoj3YQQogVK1YIe3t78frrr4tTp06JtLQ0MX78eOHm5ia++eYbg+rc2dqhvdrgTvv37xcAxOrVq42qc2drAyHapx127NghAAg3Nzedk8Avv/wiVCqVePTRRw2qM9uhQVu/D43WrFkjAIiPPvrIoPXaox06XQgYOXKkANDkBHD58mUBQLz11ls680tKSsSwYcNE9+7dxXfffaf3fn744QftvgAIBwcH8e677wo3Nzcxbtw4g+pcVlYmFAqFiIyMFLdu3RKSJIlDhw5plwcGBoq///3vIi8vTwDQ/iPoyNqjHS5duiQkSWpywqmpqRF+fn5CrVYbVOfO1g7t9V24U3h4uLC2thY//vijUet3tjYQon3a4fDhwwKACA0NbbLsueeeE3Z2dgbVme1gmu9Do8LCQgFALF682KD12qMdOl2fgMGDBzc7X/z2ioQ73+tcWlqKxx9/HDk5OTh27FiL6zbHz88Pp0+fxvXr13H+/Hn89NNPmDp1Km7duoXRo0cbVGdnZ2cMHToU6enpSE9Ph0KhwKOPPqpdHhQUhFOnTlnMvTegfdrhu+++gxACw4cP15lvbW2NBx98EBcvXjSozp2tHdrru9Dop59+wv79+xEaGooePXoYVefO1gZA+7RDa+WEEAa/z57t0PbvQ3M6ZDsYHBs6uCNHjggA4h//+IfO/LffflsAEJ988okQ4veU5+LiIs6cOWOSff/tb38TDg4O4vr16wavu2jRIgFAPPXUU+Lhhx/WWbZ3716hUChEWFiYsLa2Fj///LNJ6nsvtUc7ZGRkCADizTff1Jl/+/Zt0adPHzFkyBCD692Z2qG9vwurV68WAJo8tmSoztQGQrRfOzzyyCOie/fuOo9l/vLLL8LDw8Pgq5NCsB1MeW546623BACRmppq8Lr3uh06XQgQQognn3xS2NraihUrVohjx46JlStXii5duoiQkBAhhBC//vqrGD58uJAkSbz77rtNBnXIzs7W2Z5SqRRjx47VmffWW2+JDz74QJw6dUr861//Ek899ZRQKBRix44dRtX5wIEDAoCQJEm88sorOstKS0uFQqEQkiQZfG/PnO51O9TV1Ynhw4eLLl26iNjYWHH8+HGxZ88eoVarjX7GvbO1Q3t8Fxr1799feHl5GdyZ8I86WxsI0T7t8NlnnwkbGxsxcuRIkZKSIlJTU8Vjjz0mrK2txeeff25wndkOhrfDxx9/LCZOnCjef/99cfToUbF3714xd+5cbTljvhv3uh06ZQj49ddfxauvviq8vLyElZWV8Pb2FkuXLhW3b98WQgiRk5OjvZff3PTCCy/obA+ACAoK0pkXHx8v7r//fmFraytcXFzEpEmTxMcff2x0nSsqKoSVlZUAIPbv399k+ZAhQwQAERMTY/Q+2lt7tENZWZmIiYkRAwYMEPb29qJHjx5CrVYb/dtoZ2uH9mgDIRpOQABEbGxsm+vc2dpAiPZrh08++UQEBQUJe3t7YW9vL8aOHSs+++wzo+rMdjC8HX744QcRHBwsPD09ha2trejSpYt44IEHxD/+8Q/tPgx1r9tB+u1AiIiISGY6XcdAIiIi0g9DABERkUwxBBAREckUQwAREZFMMQQQERHJFEMAERGRTDEEEBERyRRDABERkUwxBBAREckUQwAREZFMMQQQERHJFEMAERGRTP1/MwGbi9VT6WIAAAAASUVORK5CYII=",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -238,7 +250,7 @@
     }
    ],
    "source": [
-    "st_kitts_subareas = Subareas(tc_irma, impfset, exp, resolution=0.1, buffer_grid_size=buffer_grid_size)\n",
+    "st_kitts_subareas = Subareas(tc_irma, impfset, exp, resolution=0.05, buffer_grid_size=buffer_grid_size)\n",
     "print(st_kitts_subareas.subareas_gdf)\n",
     "st_kitts_subareas.plot()"
    ]

From 3e9457e7ff2bdcd5cf961a9265aa8a031024a118 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 08:46:25 +0100
Subject: [PATCH 004/125] take crs from exposure

---
 climada_petals/engine/cat_bonds/subarea_calculations.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/climada_petals/engine/cat_bonds/subarea_calculations.py b/climada_petals/engine/cat_bonds/subarea_calculations.py
index f73bd9045..c2c24d514 100644
--- a/climada_petals/engine/cat_bonds/subarea_calculations.py
+++ b/climada_petals/engine/cat_bonds/subarea_calculations.py
@@ -84,7 +84,6 @@ def _calc_impact(self):
         # save impact per exposure point
         imp_per_exp = imp.imp_mat
         exp_crs = self.exposure.gdf
-        exp_crs = exp_crs.to_crs(self.subareas.crs)
 
         # Perform a spatial join to associate each exposure point with calculated impact with a subarea
         exp_to_admin = exp_crs.sjoin(self.subareas, how="left", predicate="within")

From efe9a75f10e75346ea052202e9fedc1fe2463172 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 09:24:01 +0100
Subject: [PATCH 005/125] dont save exp_gdf and adjust plotting

---
 climada_petals/engine/cat_bonds/subareas.py | 59 ++++++++++++---------
 1 file changed, 34 insertions(+), 25 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/subareas.py b/climada_petals/engine/cat_bonds/subareas.py
index 0a47f4462..a39d2553d 100644
--- a/climada_petals/engine/cat_bonds/subareas.py
+++ b/climada_petals/engine/cat_bonds/subareas.py
@@ -8,6 +8,7 @@
 from rasterio.features import shapes, rasterize
 from rasterio.transform import from_bounds
 from sklearn.neighbors import NearestNeighbors
+import cartopy.crs as ccrs
 
 import logging
 
@@ -61,7 +62,7 @@ def __init__(
 
     def _build_subareas(self):
         """Calculate subareas and islands."""
-        self.subareas_gdf, self.exp_gdf = self._init_subareas()
+        self.subareas_gdf = self._init_subareas()
 
     # --- Properties with auto-rebuild ---
     @property
@@ -80,29 +81,40 @@ def plot(self):
         if self.subareas_gdf is None:
             raise ValueError("Subareas have not been generated yet.")
         else:
-            fig, ax = plt.subplots(figsize=(6.4, 4.8))
-            self.exp_gdf.plot(ax=ax, color="green", label="Exposure")
+            # 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, label="Subarea"
+                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. 10% wider and 5% taller)
+            pad_x = (xmax - xmin) * 0.1   # 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()
             )
-            handles = [
-                Line2D([0], [0], color="green", lw=4, label="Exposure"),
-                Line2D([0], [0], color="red", lw=2, label="Subareas"),
-            ]
+
+            # Add legend
+            handles = [Line2D([0], [0], color="red", lw=2, label="Subareas")]
             ax.legend(handles=handles, loc="upper right")
-            ax.tick_params(axis="both", which="major", labelsize=12)
-            ax.set_yticks(ax.get_yticks()[1:])
-            ax.set_xticks(ax.get_xticks())
-            xlabel = ax.get_xticks()
-            new_xlabel = []
-            for label in xlabel:
-                new_xlabel.append(str(round(-label, 1)) + "°W")
-            ax.set_xticklabels(new_xlabel)
-            ylabel = ax.get_yticks()
-            new_ylabel = []
-            for label in ylabel:
-                new_ylabel.append(str(round(-label, 1)) + "°S")
-            ax.set_yticklabels(new_ylabel)
+
             plt.show()
 
     def count_subareas(self):
@@ -128,7 +140,6 @@ def _init_subareas(self):
         exp_gdf : GeoDataFrame
             Geodataframe of the exposure perimeter.
         """
-        exp_crs = self._exposure.crs
         exp_gdf = self._create_exp_gdf()
         logging.info("Number of polygons in exposure perimeter: %d", len(exp_gdf))
         exp_gdf = exp_gdf.explode(ignore_index=True, index_parts=True)
@@ -139,7 +150,7 @@ def _init_subareas(self):
 
         subareas_gdf["subarea_letter"] = [chr(65 + i) for i in range(len(subareas_gdf))]
 
-        return subareas_gdf, exp_gdf
+        return subareas_gdf
 
     def _crop_grid_cells_to_polygon(self, exp_gdf):
 
@@ -200,7 +211,6 @@ def _crop_grid_cells_to_polygon(self, exp_gdf):
                     )
 
                     if grid_cell.intersects(polygon.geometry):
-                        #cell_cropped = grid_cell.intersection(polygon.geometry)
                         grid_cells.append(grid_cell)
 
             grid_gdf = gpd.GeoDataFrame(
@@ -276,6 +286,5 @@ def _create_exp_gdf(self):
         merged_exp_gdf_sep = unary_union(exp_gdf_sep.geometry)
         exp_gdf = gpd.GeoDataFrame(geometry=[merged_exp_gdf_sep], crs=exp_gdf.crs)
         LOGGER.info("Exposure perimeter polygon created.")
-        exp_gdf.plot()
 
         return exp_gdf

From cbd9b949ec12f7c3d7176ed6ae9a7d5de7ccdb09 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 10:05:10 +0100
Subject: [PATCH 006/125] add buffer to create subareas

---
 climada_petals/engine/cat_bonds/subareas.py | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/climada_petals/engine/cat_bonds/subareas.py b/climada_petals/engine/cat_bonds/subareas.py
index a39d2553d..5e45cc187 100644
--- a/climada_petals/engine/cat_bonds/subareas.py
+++ b/climada_petals/engine/cat_bonds/subareas.py
@@ -182,7 +182,14 @@ def _crop_grid_cells_to_polygon(self, exp_gdf):
         # Loop through each polygon in the GeoDataFrame
         for idx, polygon in exp_gdf.iterrows():
             
+            # Pad the geometry bounds by 1% 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}"

From 716d3a0ee46be340966cbffdaae1c075b6168904 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 10:05:21 +0100
Subject: [PATCH 007/125] streamline calculations

---
 .../engine/cat_bonds/subarea_calculations.py  | 124 +++++++-----------
 1 file changed, 45 insertions(+), 79 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/subarea_calculations.py b/climada_petals/engine/cat_bonds/subarea_calculations.py
index c2c24d514..5971b3eba 100644
--- a/climada_petals/engine/cat_bonds/subarea_calculations.py
+++ b/climada_petals/engine/cat_bonds/subarea_calculations.py
@@ -7,11 +7,8 @@
 from climada.engine import ImpactCalc
 
 # set logging basics
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-formatter = logging.Formatter('%(asctime)s %(levelname)s %(name)s: %(message)s')
-for handler in logging.getLogger().handlers:
-    handler.setFormatter(formatter)
+LOGGER = logging.getLogger(__name__)
+
 
 
 class Subarea_Calculations:
@@ -40,12 +37,10 @@ def __init__(self, subareas, index_stat, exhaustion_point, attachment_point):
             The statistic to calculate. Can either be a number to calculate percentile or the string 'mean' to calculate the average.
         '''
 
-        self.subareas = subareas.subareas_gdf
-        self.exposure = subareas.exposure
-        self.hazard = subareas.hazard
-        self.vulnerability = subareas.vulnerability
+        self.subareas = subareas
         self.index_stat = index_stat
         self.exhaustion_point = exhaustion_point
+        self.attachment_point = attachment_point
 
         self.initial_guess_dict = {
             "TC": (30, 40)
@@ -67,57 +62,27 @@ def _calc_impact(self):
         -------
         imp : climada.ImpactCalc
             Impact calculation object containing results and methods.
-        imp_per_event : numpy.ndarray
-            Array of impact values per event for each exposure point.
         imp_subareas_evt : pandas.DataFrame
             DataFrame of aggregated impacts per subarea and event.
         """
 
         # perform impact calcualtion
-        imp = ImpactCalc(self.exposure, self.vulnerability, self.hazard).impact(
+        imp = ImpactCalc(self.subareas.exposure, self.subareas.vulnerability, self.subareas.hazard).impact(
             save_mat=True
         )
 
-        # save impact per exposure point
-        imp_per_event = imp.at_event
-
-        # save impact per exposure point
-        imp_per_exp = imp.imp_mat
-        exp_crs = self.exposure.gdf
+        # get exp gdf
+        exp_gdf = self.subareas.exposure.gdf
 
         # Perform a spatial join to associate each exposure point with calculated impact with a subarea
-        exp_to_admin = exp_crs.sjoin(self.subareas, how="left", predicate="within")
-
+        exp_to_admin = exp_gdf.sjoin(exp_gdf.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.groupby("subarea_letter").apply(
-            lambda x: x.index.tolist()
-        )
+        agg_exp = exp_to_admin.subarea_letter.to_list()
+        imp_subareas_evt = imp.impact_at_reg(agg_exp)
 
-        # Dictionary to store the impacts for each subarea
-        imp_subarea_csr = {}
-        # Loop through each subarea and its corresponding line numbers
-        for letter, line_numbers in agg_exp.items():
-            selected_values = imp_per_exp[
-                :, line_numbers
-            ]  # Select all impact values per subarea
-            imp_subarea_csr[letter] = (
-                selected_values  # Store them in dictionary per subarea
-            )
-        imp_subareas_evt = {}  # total damage for each event per subarea
-
-        # sum all impacts per subarea
-        for i in imp_subarea_csr:
-            imp_subareas_evt[i] = imp_subarea_csr[i].sum(
-                axis=1
-            )  # calculate sum of impacts per subarea
-            imp_subareas_evt[i] = [
-                matrix.item() for matrix in imp_subareas_evt[i]
-            ]  # single values per event are stored in 1:1 matrix -> only save value
-
-        # transform matrix to data frame
-        imp_subareas_evt = pd.DataFrame.from_dict(imp_subareas_evt)
-
-        return imp, imp_per_event, imp_subareas_evt
+        return imp, imp_subareas_evt
 
     def _calc_attachment_principal(self, impact):
         """
@@ -138,18 +103,18 @@ def _calc_attachment_principal(self, impact):
             exhaustion_point: float
                 The calculated exhaustion_point value for the CAT bond.
         """
-        tot_exp = self.exposure.gdf["value"].sum()
-
-        if isinstance(self.attachment, float):
-            attachment = self.attachment
-
-        elif isinstance(self.attachment, str):
-            if "Exp" in self.attachment:
-                self.attachment = float(self.attachment.split(" ")[0])
-                attachment = tot_exp * self.attachment
-            elif "RP" in self.attachment:
-                self.attachment = float(self.attachment.split(" ")[0])
-                attachment = impact.calc_freq_curve(self.attachment).impact
+        tot_exp = self.subareas.exposure.gdf["value"].sum()
+
+        if isinstance(self.attachment_point, float):
+            attachment = self.attachment_point
+
+        elif isinstance(self.attachment_point, str):
+            if "Exp" in self.attachment_point:
+                self.attachment_point = float(self.attachment_point.split(" ")[0])
+                attachment = tot_exp * self.attachment_point
+            elif "RP" in self.attachment_point:
+                self.attachment_point = float(self.attachment_point.split(" ")[0])
+                attachment = impact.calc_freq_curve(self.attachment_point).impact
             else:
                 raise ValueError(
                     "Invalid attachment format. Use 'Exp' for exposure share or 'RP' for return period."
@@ -180,16 +145,16 @@ def _calc_attachment_principal(self, impact):
                 "Exhaustion point must be a float or a string containing 'Exp' or 'RP'."
             )
 
-        logger.info(
+        LOGGER.info(
             f"The attachment point and the principal of the CAT bond is: {round(attachment, 3)} and {round(principal, 3)} [USD], respectively."
         )
-        logger.info(
+        LOGGER.info(
             f"Attachment point and principal as share of exposure: {round(attachment/tot_exp, 3)} and {round(principal/tot_exp, 3)}, respectively."
         )
 
         return principal, attachment
 
-    def _calc_index(self):
+    def _calc_parametric_index(self):
         """
         Calculates a specified statistic (mean, percentiles) for each events parametrix incex for each subarea.
 
@@ -205,26 +170,26 @@ def _calc_index(self):
                 The key to the dataframe is the hazard type (e.g., 'TC' for tropical cyclones).
         """
 
-        hazard = self.hazard.centroids.gdf
+        hazard = self.subareas.hazard.centroids.gdf
         hazard = hazard.to_crs(self.subareas.crs)
         centrs_to_sub = hazard.sjoin(self.subareas, 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.hazard.event_id) for letter in agg_exp.keys()
+            letter: [np.nan] * len(self.subareas.hazard.event_id) for letter in agg_exp.keys()
         }
 
-        int_sub["year"] = [0 for _ in range(len(self.hazard.event_id))]
-        int_sub["month"] = [0 for _ in range(len(self.hazard.event_id))]
+        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.hazard.event_id)):
-            date = pd.to_datetime(self.hazard.get_event_date()[i])
+        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.hazard.intensity[i, line_numbers]
+                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)):
@@ -238,7 +203,7 @@ def _calc_index(self):
         int_sub = pd.DataFrame.from_dict(int_sub)
 
         int_sub_dict = {}
-        int_sub_dict[self.hazard.haz_type] = int_sub
+        int_sub_dict[self.subareas.hazard.haz_type] = int_sub
 
         return int_sub_dict
 
@@ -351,7 +316,7 @@ def _calibrate_payout_fcts(self, haz_int, principal, attachment, imp_subarea_evt
 
     def _calc_pay_vs_dam(
         self,
-        imp_per_event,
+        impact,
         imp_subareas_evt,
         attachment,
         principal,
@@ -366,8 +331,8 @@ def _calc_pay_vs_dam(
 
         Parameters
         ----------
-        imp_per_event : numpy.ndarray
-            Array of impact values per event for each exposure point.
+        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
@@ -392,6 +357,7 @@ def _calc_pay_vs_dam(
         - 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
@@ -441,11 +407,11 @@ def _calc_pay_vs_dam(
 
     def create_pay_vs_dam(self):
 
-        imp, imp_per_event, imp_subareas_evt = self._calc_impact() 
-        par_idx = self._calc_index()
-        self.principal, self.attachment = self._calc_attachment_principal(imp, )
-        self.results, self.opt_min_thresh, self.opt_max_thresh = self._calibrate_payout_fcts(par_idx, self.principal, self.attachment, imp_subareas_evt)
-        pay_vs_dam = self._calc_pay_vs_dam(imp_per_event=imp_per_event, 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=par_idx)
+        imp, imp_subareas_evt = self._calc_impact() 
+        parametric_index = self._calc_parametric_index()
+        self.principal, self.attachment = self._calc_attachment_principal(imp)
+        self.results, self.opt_min_thresh, self.opt_max_thresh = self._calibrate_payout_fcts(parametric_index, self.principal, self.attachment, imp_subareas_evt)
+        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)
         
         return pay_vs_dam, self.principal
     

From 96c26c4cedb6624faa614f29ca3ec95562a6dfe1 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 10:31:16 +0100
Subject: [PATCH 008/125] change calculation of attachment and prinipal

---
 .../engine/cat_bonds/subarea_calculations.py  | 78 ++++++++-----------
 1 file changed, 34 insertions(+), 44 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/subarea_calculations.py b/climada_petals/engine/cat_bonds/subarea_calculations.py
index 5971b3eba..ef57c9560 100644
--- a/climada_petals/engine/cat_bonds/subarea_calculations.py
+++ b/climada_petals/engine/cat_bonds/subarea_calculations.py
@@ -12,7 +12,7 @@
 
 
 class Subarea_Calculations:
-    def __init__(self, subareas, index_stat, exhaustion_point, attachment_point):
+    def __init__(self, subareas, index_stat):
 
         '''
         Attributes
@@ -39,8 +39,6 @@ def __init__(self, subareas, index_stat, exhaustion_point, attachment_point):
 
         self.subareas = subareas
         self.index_stat = index_stat
-        self.exhaustion_point = exhaustion_point
-        self.attachment_point = attachment_point
 
         self.initial_guess_dict = {
             "TC": (30, 40)
@@ -84,7 +82,7 @@ def _calc_impact(self):
 
         return imp, imp_subareas_evt
 
-    def _calc_attachment_principal(self, impact):
+    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
@@ -97,60 +95,49 @@ def _calc_attachment_principal(self, impact):
                 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
         ----------
-            exhaustion_point: float
-                The calculated exhaustion_point value for the CAT bond.
+            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 isinstance(self.attachment_point, float):
-            attachment = self.attachment_point
-
-        elif isinstance(self.attachment_point, str):
-            if "Exp" in self.attachment_point:
-                self.attachment_point = float(self.attachment_point.split(" ")[0])
-                attachment = tot_exp * self.attachment_point
-            elif "RP" in self.attachment_point:
-                self.attachment_point = float(self.attachment_point.split(" ")[0])
-                attachment = impact.calc_freq_curve(self.attachment_point).impact
-            else:
-                raise ValueError(
-                    "Invalid attachment format. Use 'Exp' for exposure share or 'RP' for return period."
-                )
+        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(
-                "Attachment must be a float or a string containing 'Exp' or 'RP'."
+                "Invalid attachment point method. Choose 'Exposure_Share' or 'Return_Period'."
             )
-
-        if isinstance(self.exhaustion_point, float):
-            principal = self.exhaustion_point
-
-        elif isinstance(self.exhaustion_point, str):
-            if "Exp" in self.exhaustion_point:
-                self.exhaustion_point = float(self.exhaustion_point.split(" ")[0])
-                principal = tot_exp * self.exhaustion_point
-            elif "RP" in self.exhaustion_point:
-                self.exhaustion_point = float(self.exhaustion_point.split(" ")[0])
-                principal = impact.calc_freq_curve(self.exhaustion_point).impact
-            else:
-                raise ValueError(
-                    "Invalid exhaustion point format. Use 'Exp' for exposure share or 'RP' for 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(
-                "Exhaustion point must be a float or a string containing 'Exp' or 'RP'."
+                "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."
         )
-        LOGGER.info(
-            f"Attachment point and principal as share of exposure: {round(attachment/tot_exp, 3)} and {round(principal/tot_exp, 3)}, respectively."
-        )
 
         return principal, attachment
 
@@ -405,11 +392,14 @@ def _calc_pay_vs_dam(
 
         return pay_dam_df
 
-    def create_pay_vs_dam(self):
+    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()
-        self.principal, self.attachment = self._calc_attachment_principal(imp)
+        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)
         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)
         

From cc4fdee7073ee456bd78bdb39494dc0890072cfa Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 10:48:07 +0100
Subject: [PATCH 009/125] keep only grids with exposure point within

---
 climada_petals/engine/cat_bonds/subareas.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/climada_petals/engine/cat_bonds/subareas.py b/climada_petals/engine/cat_bonds/subareas.py
index 5e45cc187..80e78eab3 100644
--- a/climada_petals/engine/cat_bonds/subareas.py
+++ b/climada_petals/engine/cat_bonds/subareas.py
@@ -217,7 +217,8 @@ def _crop_grid_cells_to_polygon(self, exp_gdf):
                         x1, y1, x2, y2
                     )
 
-                    if grid_cell.intersects(polygon.geometry):
+                    # Only keep grid cell if at least one exposure point is inside
+                    if any(p.within(grid_cell) for p in self.exposure.gdf.geometry):
                         grid_cells.append(grid_cell)
 
             grid_gdf = gpd.GeoDataFrame(

From 16caea013edb1c08d403b6e1bfa54945db8d695b Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 10:48:20 +0100
Subject: [PATCH 010/125] fix bugs

---
 climada_petals/engine/cat_bonds/subarea_calculations.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/subarea_calculations.py b/climada_petals/engine/cat_bonds/subarea_calculations.py
index ef57c9560..0ecfd1e09 100644
--- a/climada_petals/engine/cat_bonds/subarea_calculations.py
+++ b/climada_petals/engine/cat_bonds/subarea_calculations.py
@@ -73,7 +73,7 @@ def _calc_impact(self):
         exp_gdf = self.subareas.exposure.gdf
 
         # Perform a spatial join to associate each exposure point with calculated impact with a subarea
-        exp_to_admin = exp_gdf.sjoin(exp_gdf.subareas.subareas_gdf, how="left", predicate="within")
+        exp_to_admin = exp_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
@@ -158,8 +158,8 @@ def _calc_parametric_index(self):
         """
 
         hazard = self.subareas.hazard.centroids.gdf
-        hazard = hazard.to_crs(self.subareas.crs)
-        centrs_to_sub = hazard.sjoin(self.subareas, how="left", predicate="intersects")
+        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 = {

From 6533b493a33d48131fa2d08aa526be652902d5e8 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 10:57:29 +0100
Subject: [PATCH 011/125] adjust calc savings

---
 climada_petals/engine/cat_bonds/subarea_calculations.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/subarea_calculations.py b/climada_petals/engine/cat_bonds/subarea_calculations.py
index 0ecfd1e09..44d793b6d 100644
--- a/climada_petals/engine/cat_bonds/subarea_calculations.py
+++ b/climada_petals/engine/cat_bonds/subarea_calculations.py
@@ -401,9 +401,8 @@ def create_pay_vs_dam(self, attachment_point, exhaustion_point, methods_attachme
         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)
-        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)
-        
-        return pay_vs_dam, self.principal
+        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):

From bf54f9bd083875675fa50fcd8f27ad511b23433b Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 11:03:16 +0100
Subject: [PATCH 012/125] adjust test notebook to changed classes

---
 climada_petals/engine/cat_bonds/test.ipynb | 199 +++++----------------
 1 file changed, 40 insertions(+), 159 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/test.ipynb b/climada_petals/engine/cat_bonds/test.ipynb
index d85668f5b..e16e53835 100644
--- a/climada_petals/engine/cat_bonds/test.ipynb
+++ b/climada_petals/engine/cat_bonds/test.ipynb
@@ -28,15 +28,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 8,
    "id": "89b53a88",
    "metadata": {},
    "outputs": [],
    "source": [
     "### Bond Basics ###\n",
     "country = 659  # St. Kitts and Nevis\n",
-    "exhaustion_point = '0.5 Exp' # 50% of exposure\n",
-    "attachment_point = '0.05 Exp' # 5% of exposure\n",
+    "exhaustion_point = 0.5 # 50% of exposure\n",
+    "attachment_point = 0.05 # 5% of exposure\n",
+    "exhaustion_point_method = 'Exposure_Share' # 50% of exposure\n",
+    "attachment_point_method = 'Exposure_Share' # 5% of exposure\n",
     "term = 3  # years\n",
     "par_index = 60 # statistic for parametric index (e.g. 60 for 60th percentile)\n",
     "\n",
@@ -61,7 +63,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "id": "a51eb038",
    "metadata": {},
    "outputs": [
@@ -69,9 +71,9 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-03 10:37:37,508 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
-      "2025-11-03 10:37:37,600 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
-      "2025-11-03 10:37:37,678 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n"
+      "2025-11-07 10:36:51,618 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
+      "2025-11-07 10:36:51,682 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
+      "2025-11-07 10:36:51,725 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n"
      ]
     },
     {
@@ -85,39 +87,28 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-03 10:37:43,886 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
-      "2025-11-03 10:37:43,996 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 546 coastal centroids.\n",
-      "2025-11-03 10:37:44,630 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
-      "2025-11-03 10:37:45,010 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
-      "2025-11-03 10:37:45,421 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
-      "2025-11-03 10:37:45,827 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
-      "2025-11-03 10:37:46,203 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
-      "2025-11-03 10:37:46,585 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
-      "2025-11-03 10:37:46,973 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
-      "2025-11-03 10:37:47,334 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
-      "2025-11-03 10:37:47,538 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
-      "2025-11-03 10:37:48,985 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      "2025-11-07 10:36:56,358 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
+      "2025-11-07 10:36:56,399 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 546 coastal centroids.\n",
+      "2025-11-07 10:36:56,725 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
+      "2025-11-07 10:36:56,994 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
+      "2025-11-07 10:36:57,279 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
+      "2025-11-07 10:36:57,797 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
+      "2025-11-07 10:36:58,237 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
+      "2025-11-07 10:36:58,623 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
+      "2025-11-07 10:36:59,018 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
+      "2025-11-07 10:36:59,373 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
+      "2025-11-07 10:36:59,612 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
+      "2025-11-07 10:37:01,015 - climada.entity.exposures.litpop.litpop - INFO - \n",
       " LitPop: Init Exposure for country: KNA (659)...\n",
       "\n",
-      "2025-11-03 10:37:49,104 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-03 10:37:50,503 - climada.util.finance - INFO - GDP KNA 2020: 8.839e+08.\n",
-      "2025-11-03 10:37:50,526 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
-      "2025-11-03 10:37:50,526 - climada.entity.exposures.base - INFO - category_id not set.\n",
-      "2025-11-03 10:37:50,527 - climada.entity.exposures.base - INFO - cover not set.\n",
-      "2025-11-03 10:37:50,528 - climada.entity.exposures.base - INFO - deductible not set.\n",
-      "2025-11-03 10:37:50,528 - climada.entity.exposures.base - INFO - centr_ not set.\n",
-      "2025-11-03 10:37:50,530 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+      "2025-11-07 10:37:01,104 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-07 10:37:01,733 - climada.util.finance - INFO - GDP KNA 2020: 8.839e+08.\n",
+      "2025-11-07 10:37:01,750 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+      "2025-11-07 10:37:01,751 - climada.entity.exposures.base - INFO - category_id not set.\n",
+      "2025-11-07 10:37:01,751 - climada.entity.exposures.base - INFO - cover not set.\n",
+      "2025-11-07 10:37:01,752 - climada.entity.exposures.base - INFO - deductible not set.\n",
+      "2025-11-07 10:37:01,753 - climada.entity.exposures.base - INFO - centr_ not set.\n"
      ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 900x1300 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     }
    ],
    "source": [
@@ -137,7 +128,6 @@
     "        [str(country)], fin_mode='gdp', reference_year=2020\n",
     "    )\n",
     "\n",
-    "exp.plot_raster()\n",
     "impfset = ImpfSetTropCyclone.from_calibrated_regional_ImpfSet()\n",
     "iso3n_per_region = impf_id_per_region = impfset.get_countries_per_region()[2]\n",
     "exp.gdf.loc[exp.gdf.region_id == country, 'impf_TC'] = 1"
@@ -153,96 +143,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 45,
-   "id": "f457cca6",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0.00029767953921070123"
-      ]
-     },
-     "execution_count": 45,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "\n",
-    "minx, miny, maxx, maxy = exp.gdf.total_bounds\n",
-    "\n",
-    "# Compute area of bounding box\n",
-    "width = maxx - minx\n",
-    "height = maxy - miny\n",
-    "bbox_area = width * height\n",
-    "bbox_area /len(exp.gdf)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": 14,
    "id": "09fba021",
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2025-11-03 12:58:37,956 INFO subareas: Creating exposure perimeter polygon from exposure data.\n",
-      "2025-11-03 12:58:37,961 INFO subareas: Exposure total bounds: -62.85416667, 17.10416667, -62.5375, 17.4125\n",
-      "2025-11-03 12:58:37,971 INFO subareas: Approximate resolution: 0.009999996219511444 CRS units\n",
-      "2025-11-03 12:58:37,972 INFO subareas: Rasterizing exposure with width: 31, height: 30\n",
-      "2025-11-03 12:58:38,085 INFO subareas: Exposure perimeter polygon created.\n",
-      "2025-11-03 12:58:38,207 INFO root: Number of polygons in exposure perimeter: 1\n",
-      "2025-11-03 12:58:38,214 INFO subareas: Creating subareas from exposure perimeter polygon.\n",
-      "2025-11-03 12:58:38,215 INFO subareas: Number of polygons to process: 2\n",
-      "2025-11-03 12:58:38,216 INFO subareas: Processing polygon with bounds: -62.85416667, 17.217222224333334, -62.619220430967744, 17.4125\n",
-      "2025-11-03 12:58:38,216 INFO subareas: Number of cells in x direction: 5, y direction: 4\n",
-      "2025-11-03 12:58:38,221 INFO subareas: Processing polygon with bounds: -62.62943548483871, 17.10416667, -62.5375, 17.196666669000003\n",
-      "2025-11-03 12:58:38,222 INFO subareas: Number of cells in x direction: 2, y direction: 2\n",
-      "2025-11-03 12:58:38,229 INFO subareas: Subareas created.\n"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "                                             geometry subarea_letter\n",
-      "0   POLYGON ((-62.80417 17.31722, -62.80417 17.367...              A\n",
-      "1   POLYGON ((-62.80417 17.36722, -62.80417 17.417...              B\n",
-      "2   POLYGON ((-62.75417 17.26722, -62.75417 17.317...              C\n",
-      "3   POLYGON ((-62.75417 17.31722, -62.75417 17.367...              D\n",
-      "4   POLYGON ((-62.75417 17.36722, -62.75417 17.417...              E\n",
-      "5   POLYGON ((-62.70417 17.26722, -62.70417 17.317...              F\n",
-      "6   POLYGON ((-62.70417 17.31722, -62.70417 17.367...              G\n",
-      "7   POLYGON ((-62.70417 17.36722, -62.70417 17.417...              H\n",
-      "8   POLYGON ((-62.65417 17.21722, -62.65417 17.267...              I\n",
-      "9   POLYGON ((-62.65417 17.26722, -62.65417 17.317...              J\n",
-      "10  POLYGON ((-62.65417 17.31722, -62.65417 17.367...              K\n",
-      "11  POLYGON ((-62.60417 17.21722, -62.60417 17.267...              L\n",
-      "12  POLYGON ((-62.60417 17.26722, -62.60417 17.317...              M\n",
-      "13  POLYGON ((-62.57944 17.10417, -62.57944 17.154...              N\n",
-      "14  POLYGON ((-62.57944 17.15417, -62.57944 17.204...              O\n",
-      "15  POLYGON ((-62.52944 17.10417, -62.52944 17.154...              P\n",
-      "16  POLYGON ((-62.52944 17.15417, -62.52944 17.204...              Q\n"
+      "2025-11-07 10:45:59,580 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
+       "<Figure size 900x1300 with 2 Axes>"
       ]
      },
      "metadata": {},
@@ -251,7 +167,6 @@
    ],
    "source": [
     "st_kitts_subareas = Subareas(tc_irma, impfset, exp, resolution=0.05, buffer_grid_size=buffer_grid_size)\n",
-    "print(st_kitts_subareas.subareas_gdf)\n",
     "st_kitts_subareas.plot()"
    ]
   },
@@ -265,7 +180,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 19,
    "id": "ac344ab3",
    "metadata": {},
    "outputs": [
@@ -273,51 +188,17 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2024-01-01 01:11:25,220 - climada.entity.exposures.base - INFO - Matching 328 exposures with 546 centroids.\n",
-      "2024-01-01 01:11:25,227 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
-      "2024-01-01 01:11:25,231 - climada.engine.impact_calc - INFO - Calculating impact for 984 assets (>0) and 51 events.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2024-01-01 01:11:27,803 INFO subarea_calculations: The attachment point and the principal of the CAT bond is: 52650000.0 and 526500000.0 [USD], respectively.\n",
-      "2024-01-01 01:11:27,803 INFO subarea_calculations: Attachment point and principal as share of exposure: 0.05 and 0.5, respectively.\n"
+      "2025-11-07 10:54:31,722 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n",
+      "2025-11-07 10:54:31,723 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n",
+      "2025-11-07 10:54:31,724 - climada.entity.exposures.base - INFO - Matching 328 exposures with 546 centroids.\n",
+      "2025-11-07 10:54:31,728 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
+      "2025-11-07 10:54:31,760 - climada.engine.impact_calc - INFO - Calculating impact for 984 assets (>0) and 51 events.\n"
      ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 900x1300 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     }
    ],
    "source": [
-    "st_kitts_sub_calc = Subarea_Calculations(subareas=st_kitts_subareas, index_stat=par_index, exhaustion_point=exhaustion_point, attachment_point=attachment_point)\n",
-    "imp, imp_per_event, imp_subareas_evt = st_kitts_sub_calc._calc_impact()\n",
-    "# Compute exceedance frequency curve\n",
-    "freq_curve = imp.calc_freq_curve()\n",
-    "freq_curve.plot()\n",
-    "imp.plot_hexbin_eai_exposure(gridsize=100, adapt_fontsize=False)\n",
-    "par_idx = st_kitts_sub_calc._calc_index()\n",
-    "principal, attachment = st_kitts_sub_calc._calc_attachment_principal(imp)\n",
-    "results, opt_min_thresh, opt_max_thresh = st_kitts_sub_calc._calibrate_payout_fcts(par_idx, principal, attachment, imp_subareas_evt)\n",
-    "pay_vs_dam = st_kitts_sub_calc._calc_pay_vs_dam(imp_per_event=imp_per_event, imp_subareas_evt=imp_subareas_evt, attachment=attachment, principal=principal, opt_min_thresh=opt_min_thresh, opt_max_thresh=opt_max_thresh, haz_int=par_idx)"
+    "st_kitts_sub_calc = Subarea_Calculations(subareas=st_kitts_subareas, index_stat=par_index)\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)\n"
    ]
   }
  ],

From 688027de35243444192b8094eeb771ac2b1d2ab4 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 11:55:58 +0100
Subject: [PATCH 013/125] inititate bond simulation class

---
 .../engine/cat_bonds/bond_simulation.py       | 143 ++++++++++++++++++
 1 file changed, 143 insertions(+)
 create mode 100644 climada_petals/engine/cat_bonds/bond_simulation.py

diff --git a/climada_petals/engine/cat_bonds/bond_simulation.py b/climada_petals/engine/cat_bonds/bond_simulation.py
new file mode 100644
index 000000000..0c78cd694
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/bond_simulation.py
@@ -0,0 +1,143 @@
+import pandas as pd
+import numpy as np
+import logging
+
+LOGGER = logging.getLogger(__name__)
+
+class bond_simulation:
+
+    def __init__(self, subarea_calc, term, number_terms):
+        self.term = term
+        self.simulated_years = number_terms * term
+        self.subarea_calc = subarea_calc
+
+
+
+    '''Simulate one term of bond to derive losses'''
+def init_bond_exp_loss(term, events_per_year, principal):
+    """
+    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, remaining nominal value, and the timing of losses. It returns the relative
+    losses per year, the total relative loss, and a DataFrame detailing losses and their corresponding months.
+    Parameters
+    ----------
+    term : int
+        The term of the bond in years.
+    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.
+    principal : float
+        The initial principal value of the bond.
+    Returns
+    -------
+    rel_losses : numpy.ndarray
+        Array of relative losses per year (losses divided by principal).
+    att_prob : float
+        Probability of at least one payout occurring during the bond's term.
+    tot_loss : float
+        Total relative loss over the bond's term (sum of 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.
+    """
+
+    losses = []
+    rel_monthly_loss = pd.DataFrame(columns=['losses', 'months'])
+    current_principal = principal.copy()
+
+    for k in range(term):
+
+        if events_per_year[k].empty:
+            sum_payouts = [0]
+            months = []
+        else:
+            events_per_year[k] = events_per_year[k].sort_values(by='month')
+            months = events_per_year[k]['month'].tolist()
+
+            sum_payouts = []
+            for o in range(len(events_per_year[k])):
+                payout = events_per_year[k].loc[events_per_year[k].index[o], 'pay']
+                #If there are events in the year, sample that many payouts and the associated damages
+                if payout == 0 or current_principal == 0:
+                    sum_payouts.append(0)
+                elif payout > 0:
+                    event_payout = payout 
+                    current_principal -= event_payout
+                    if current_principal < 0:
+                        event_payout += current_principal
+                        current_principal = 0
+                    else:
+                        pass
+                    sum_payouts.append(event_payout)
+
+        losses.append(np.sum(sum_payouts))
+        rel_monthly_loss.loc[k] = [sum_payouts, months]
+    rel_term_loss = np.sum(losses) /principal
+    rel_annual_losses = np.array(losses) / principal
+    rel_monthly_loss['losses'] = rel_monthly_loss['losses'].apply(lambda x: [i / principal for i in x])
+    return rel_annual_losses, rel_term_loss, rel_monthly_loss
+
+
+'''Loop over all terms of bond to derive losses'''
+def init_exp_loss_att_prob_simulation(self):
+    """
+    Simulates expected annual loss and attachment probability for a catastrophe bond over multiple years.
+    This function processes a DataFrame of payout and damage events, simulates bond losses over a specified term,
+    and computes risk metrics including Value-at-Risk (VaR) and Expected Shortfall (ES) at 95% and 99% confidence levels.
+    It returns the expected annual loss, attachment probability, a DataFrame of monthly losses, and a dictionary of risk metrics.
+    Parameters
+    ----------
+        pay_dam_df (pd.DataFrame): DataFrame containing payout and damage event data.
+        nominal (float): The nominal value of the bond.
+        print_prob (bool, optional): If True, prints the expected loss and attachment probability. Defaults to True.
+    Returns
+    -------
+        exp_loss_ann (float): Expected annual loss.
+        att_prob (float): Annual attachment probability (probability that the bond is triggered).
+        df_loss_month (pd.DataFrame): DataFrame containing monthly loss data for all simulations.
+        es_metrics (dict): Dictionary containing VaR and ES metrics at 95% and 99% confidence levels for annual and total losses.
+    """
+
+    annual_losses = []
+    total_losses = []
+    list_loss_month = []
+    for i in range(self.simulated_years-self.term):
+        events_per_year = []
+        for j in range(self.term):
+            if 'year' in self.subarea_calc.pay_dam_df.columns:
+                events_per_year.append(self.subarea_calc.pay_dam_df[self.subarea_calc.pay_dam_df['year'] == (i+j)])
+            else:
+                events_per_year.append(pd.DataFrame({'pay': [0], 'damage': [0]}))
+        annual_losses_per_term, term_loss, monthly_losses = init_bond_exp_loss(self.term, events_per_year, self.subarea_calc.principal)
+        list_loss_month.append(monthly_losses)
+
+        annual_losses.extend(annual_losses_per_term)
+        total_losses.append(term_loss)
+    
+    df_loss_month = pd.concat(list_loss_month, ignore_index=True)
+
+    att_prob = annual_losses.count(lambda x: 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_99_ann = annual_losses.quantile(0.99)
+    VaR_95_ann = annual_losses.quantile(0.95)
+    if VaR_99_ann == 1:
+        ES_99_ann = 1
+    else:
+        ES_99_ann = annual_losses[annual_losses > VaR_99_ann].mean()
+    if VaR_95_ann == 1:
+        ES_95_ann = 1
+    else:
+        ES_95_ann = annual_losses[annual_losses > VaR_95_ann].mean()
+
+    metrics = {'EL_ann': exp_loss_ann, 'AP_ann': att_prob, 'VaR_99_ann': VaR_99_ann, 'VaR_95_ann': VaR_95_ann,
+               'ES_99_ann': ES_99_ann, 'ES_95_ann': ES_95_ann}
+
+    LOGGER.info(f'Expected Loss = {exp_loss_ann}')
+    LOGGER.info(f'Attachment Probability = {att_prob}')
+
+    return metrics, df_loss_month
\ No newline at end of file

From 0a35b878a55df9321d8547692615c338e735df12 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 11:56:09 +0100
Subject: [PATCH 014/125] delete pay_dam_subarea class

---
 .../engine/cat_bonds/pay_dam_subarea.py       | 49 -------------------
 1 file changed, 49 deletions(-)
 delete mode 100644 climada_petals/engine/cat_bonds/pay_dam_subarea.py

diff --git a/climada_petals/engine/cat_bonds/pay_dam_subarea.py b/climada_petals/engine/cat_bonds/pay_dam_subarea.py
deleted file mode 100644
index efa20caab..000000000
--- a/climada_petals/engine/cat_bonds/pay_dam_subarea.py
+++ /dev/null
@@ -1,49 +0,0 @@
-import pandas as pd
-import matplotlib.pyplot as plt
-
-import subarea_calculations
-
-class Pay_dam_subarea:
-    def __init__(self, subareas, index_stat, exhaustion_point, attachment_point):
-        self.subareas_class = subareas
-        self.index_stat = index_stat
-        self.exhaustion_point = exhaustion_point
-        self.attachment = attachment_point
-        self._get_pay_vs_dam()
-
-    def _get_pay_vs_dam(self):
-        calculation_class = subarea_calculations.Subarea_Calculations(self.subareas_class, self.index_stat, self.exhaustion_point, self.attachment)
-        self.pay_vs_dam, self.principal = calculation_class.create_pay_vs_dam()
-
-    def plot_pay_vs_dam(self, calculation_class):
-        tot_exp = calculation_class.exposure.gdf['value'].sum()
-
-        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 4))
-
-        ax1.scatter(self.pay_vs_dam/tot_exp, payout_flt/tot_exp, marker='o', color='blue', label='Events')
-        ax1.plot([0, nominal/tot_exp], [0, nominal/tot_exp], color='black', linestyle='--', label='Trendline')
-        ax1.axhline(y = nominal/tot_exp, color = 'r', linestyle = '-', label='Principal') 
-        ax1.axhline(y = 0.05, color = 'r', linestyle = '-', label='Attachment Point') 
-        ax1.axvline(x = 0.05, color = 'r', linestyle = '--', label='Min. Damage') 
-        ax1.set_xlabel("Damage [share of GDP]", fontsize=12)
-        ax1.set_ylabel("Payout [share of GDP]", fontsize=12)
-        ax1.legend(loc='lower right', borderpad=2.0)
-
-        ax2.scatter(damages/tot_exp, pay_dam_df['pay']/tot_exp, marker='o', color='blue', label='Events')
-        ax2.axhline(y = nominal/tot_exp, color = 'r', linestyle = '-', label='Principal') 
-        ax2.axhline(y = 0.05, color = 'r', linestyle = '-', label='Attachment Point') 
-        ax2.axvline(x = 0.05, color = 'black', linestyle = '--', label='Min. Damage') 
-        ax2.set_xscale('log')
-        ax2.set_xlabel("Damage [share of GDP]", fontsize=12)
-        ax2.set_ylabel("Payout [share of GDP]", fontsize=12)
-
-        panel_labels = ["a)", "b)"]
-        for i, ax in enumerate([ax1, ax2]):
-            ax.annotate(panel_labels[i], 
-                xy=(-0.1, 1),  
-                xycoords="axes fraction", 
-                fontsize=14, 
-                fontweight="bold")
-            
-        plt.tight_layout()
-        plt.show()

From 519dcb401abd2aca1d8bbbead86f8166f15bfe6a Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 11:58:00 +0100
Subject: [PATCH 015/125] update function descriptions

---
 climada_petals/engine/cat_bonds/bond_simulation.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/bond_simulation.py b/climada_petals/engine/cat_bonds/bond_simulation.py
index 0c78cd694..437fc5083 100644
--- a/climada_petals/engine/cat_bonds/bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/bond_simulation.py
@@ -31,11 +31,9 @@ def init_bond_exp_loss(term, events_per_year, principal):
         The initial principal value of the bond.
     Returns
     -------
-    rel_losses : numpy.ndarray
+    rel_annual_losses : numpy.ndarray
         Array of relative losses per year (losses divided by principal).
-    att_prob : float
-        Probability of at least one payout occurring during the bond's term.
-    tot_loss : float
+    rel_term_loss : float
         Total relative loss over the bond's term (sum of losses divided by principal).
     rel_monthly_loss : pandas.DataFrame
         DataFrame with columns 'losses' and 'months', detailing the losses and their corresponding

From 8a2accf1a2ce13f6fd095b3d686beb73ac4478ba Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 13:35:21 +0100
Subject: [PATCH 016/125] fix bugs

---
 .../engine/cat_bonds/bond_simulation.py       | 245 +++++++++---------
 1 file changed, 121 insertions(+), 124 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/bond_simulation.py b/climada_petals/engine/cat_bonds/bond_simulation.py
index 437fc5083..ecdf4e837 100644
--- a/climada_petals/engine/cat_bonds/bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/bond_simulation.py
@@ -14,128 +14,125 @@ def __init__(self, subarea_calc, term, number_terms):
 
 
     '''Simulate one term of bond to derive losses'''
-def init_bond_exp_loss(term, events_per_year, principal):
-    """
-    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, remaining nominal value, and the timing of losses. It returns the relative
-    losses per year, the total relative loss, and a DataFrame detailing losses and their corresponding months.
-    Parameters
-    ----------
-    term : int
-        The term of the bond in years.
-    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.
-    principal : float
-        The initial principal value of the bond.
-    Returns
-    -------
-    rel_annual_losses : numpy.ndarray
-        Array of relative losses per year (losses divided by principal).
-    rel_term_loss : float
-        Total relative loss over the bond's term (sum of 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.
-    """
-
-    losses = []
-    rel_monthly_loss = pd.DataFrame(columns=['losses', 'months'])
-    current_principal = principal.copy()
-
-    for k in range(term):
-
-        if events_per_year[k].empty:
-            sum_payouts = [0]
-            months = []
-        else:
-            events_per_year[k] = events_per_year[k].sort_values(by='month')
-            months = events_per_year[k]['month'].tolist()
-
-            sum_payouts = []
-            for o in range(len(events_per_year[k])):
-                payout = events_per_year[k].loc[events_per_year[k].index[o], 'pay']
-                #If there are events in the year, sample that many payouts and the associated damages
-                if payout == 0 or current_principal == 0:
-                    sum_payouts.append(0)
-                elif payout > 0:
-                    event_payout = payout 
-                    current_principal -= event_payout
-                    if current_principal < 0:
-                        event_payout += current_principal
-                        current_principal = 0
-                    else:
-                        pass
-                    sum_payouts.append(event_payout)
-
-        losses.append(np.sum(sum_payouts))
-        rel_monthly_loss.loc[k] = [sum_payouts, months]
-    rel_term_loss = np.sum(losses) /principal
-    rel_annual_losses = np.array(losses) / principal
-    rel_monthly_loss['losses'] = rel_monthly_loss['losses'].apply(lambda x: [i / principal for i in x])
-    return rel_annual_losses, rel_term_loss, rel_monthly_loss
-
-
-'''Loop over all terms of bond to derive losses'''
-def init_exp_loss_att_prob_simulation(self):
-    """
-    Simulates expected annual loss and attachment probability for a catastrophe bond over multiple years.
-    This function processes a DataFrame of payout and damage events, simulates bond losses over a specified term,
-    and computes risk metrics including Value-at-Risk (VaR) and Expected Shortfall (ES) at 95% and 99% confidence levels.
-    It returns the expected annual loss, attachment probability, a DataFrame of monthly losses, and a dictionary of risk metrics.
-    Parameters
-    ----------
-        pay_dam_df (pd.DataFrame): DataFrame containing payout and damage event data.
-        nominal (float): The nominal value of the bond.
-        print_prob (bool, optional): If True, prints the expected loss and attachment probability. Defaults to True.
-    Returns
-    -------
-        exp_loss_ann (float): Expected annual loss.
-        att_prob (float): Annual attachment probability (probability that the bond is triggered).
-        df_loss_month (pd.DataFrame): DataFrame containing monthly loss data for all simulations.
-        es_metrics (dict): Dictionary containing VaR and ES metrics at 95% and 99% confidence levels for annual and total losses.
-    """
-
-    annual_losses = []
-    total_losses = []
-    list_loss_month = []
-    for i in range(self.simulated_years-self.term):
-        events_per_year = []
-        for j in range(self.term):
-            if 'year' in self.subarea_calc.pay_dam_df.columns:
-                events_per_year.append(self.subarea_calc.pay_dam_df[self.subarea_calc.pay_dam_df['year'] == (i+j)])
+    def init_bond_exp_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, remaining nominal value, and the timing of losses. It returns the relative
+        losses per year, the total relative loss, and a DataFrame detailing losses and their corresponding months.
+        Parameters
+        ----------
+        term : int
+            The term of the bond in years.
+        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.
+        principal : float
+            The initial principal value of the bond.
+        Returns
+        -------
+        rel_annual_losses : numpy.ndarray
+            Array of relative losses per year (losses divided by principal).
+        rel_term_loss : float
+            Total relative loss over the bond's term (sum of 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.
+        """
+
+        losses = []
+        rel_monthly_loss = pd.DataFrame(columns=['losses', 'months'])
+        current_principal = self.subarea_calc.principal
+
+        for k in range(self.term):
+
+            if events_per_year[k].empty:
+                sum_payouts = [0]
+                months = []
             else:
-                events_per_year.append(pd.DataFrame({'pay': [0], 'damage': [0]}))
-        annual_losses_per_term, term_loss, monthly_losses = init_bond_exp_loss(self.term, events_per_year, self.subarea_calc.principal)
-        list_loss_month.append(monthly_losses)
-
-        annual_losses.extend(annual_losses_per_term)
-        total_losses.append(term_loss)
-    
-    df_loss_month = pd.concat(list_loss_month, ignore_index=True)
-
-    att_prob = annual_losses.count(lambda x: 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_99_ann = annual_losses.quantile(0.99)
-    VaR_95_ann = annual_losses.quantile(0.95)
-    if VaR_99_ann == 1:
-        ES_99_ann = 1
-    else:
-        ES_99_ann = annual_losses[annual_losses > VaR_99_ann].mean()
-    if VaR_95_ann == 1:
-        ES_95_ann = 1
-    else:
-        ES_95_ann = annual_losses[annual_losses > VaR_95_ann].mean()
-
-    metrics = {'EL_ann': exp_loss_ann, 'AP_ann': att_prob, 'VaR_99_ann': VaR_99_ann, 'VaR_95_ann': VaR_95_ann,
-               'ES_99_ann': ES_99_ann, 'ES_95_ann': ES_95_ann}
-
-    LOGGER.info(f'Expected Loss = {exp_loss_ann}')
-    LOGGER.info(f'Attachment Probability = {att_prob}')
-
-    return metrics, df_loss_month
\ No newline at end of file
+                events_per_year[k] = events_per_year[k].sort_values(by='month')
+                months = events_per_year[k]['month'].tolist()
+
+                sum_payouts = []
+                for o in range(len(events_per_year[k])):
+                    payout = events_per_year[k].loc[events_per_year[k].index[o], 'pay']
+                    #If there are events in the year, sample that many payouts and the associated damages
+                    if payout == 0 or current_principal == 0:
+                        sum_payouts.append(0)
+                    elif payout > 0:
+                        event_payout = payout 
+                        current_principal -= event_payout
+                        if current_principal < 0:
+                            event_payout += current_principal
+                            current_principal = 0
+                        else:
+                            pass
+                        sum_payouts.append(event_payout)
+
+            losses.append(np.sum(sum_payouts))
+            rel_monthly_loss.loc[k] = [sum_payouts, months]
+        rel_term_loss = np.sum(losses) / self.subarea_calc.principal
+        rel_annual_losses = np.array(losses) / self.subarea_calc.principal
+        rel_monthly_loss['losses'] = rel_monthly_loss['losses'].apply(lambda x: [i / self.subarea_calc.principal for i in x])
+        return rel_annual_losses, rel_term_loss, rel_monthly_loss
+
+
+    '''Loop over all terms of bond to derive losses'''
+    def init_exp_loss_att_prob_simulation(self):
+        """
+        Simulates expected annual loss and attachment probability for a catastrophe bond over multiple years.
+        This function processes a DataFrame of payout and damage events, simulates bond losses over a specified term,
+        and computes risk metrics including Value-at-Risk (VaR) and Expected Shortfall (ES) at 95% and 99% confidence levels.
+        It returns the expected annual loss, attachment probability, a DataFrame of monthly losses, and a dictionary of risk metrics.
+        Parameters
+        ----------
+            pay_vs_dam (pd.DataFrame): DataFrame containing payout and damage event data.
+            nominal (float): The nominal value of the bond.
+            print_prob (bool, optional): If True, prints the expected loss and attachment probability. Defaults to True.
+        Returns
+        -------
+            exp_loss_ann (float): Expected annual loss.
+            att_prob (float): Annual attachment probability (probability that the bond is triggered).
+            df_loss_month (pd.DataFrame): DataFrame containing monthly loss data for all simulations.
+            es_metrics (dict): Dictionary containing VaR and ES metrics at 95% and 99% confidence levels for annual and total losses.
+        """
+
+        annual_losses = []
+        total_losses = []
+        list_loss_month = []
+        min_year = self.subarea_calc.pay_vs_dam['year'].min()
+        for i in range(self.simulated_years-self.term):
+            events_per_year = []
+            for j in range(self.term):
+                events_per_year.append(self.subarea_calc.pay_vs_dam[self.subarea_calc.pay_vs_dam['year'] == (min_year+i)+j])
+            annual_losses_per_term, term_loss, monthly_losses = self.init_bond_exp_loss(events_per_year)
+            list_loss_month.append(monthly_losses)
+
+            annual_losses.extend(annual_losses_per_term)
+            total_losses.append(term_loss)
+
+        self.df_loss_month = pd.concat(list_loss_month, ignore_index=True)
+
+        att_prob = 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_99_ann = annual_losses.quantile(0.99)
+        VaR_95_ann = annual_losses.quantile(0.95)
+        if VaR_99_ann == 1:
+            ES_99_ann = 1
+        else:
+            ES_99_ann = annual_losses[annual_losses > VaR_99_ann].mean()
+        if VaR_95_ann == 1:
+            ES_95_ann = 1
+        else:
+            ES_95_ann = annual_losses[annual_losses > VaR_95_ann].mean()
+
+        self.metrics = {'EL_ann': exp_loss_ann, 'AP_ann': att_prob, 'VaR_99_ann': VaR_99_ann, 'VaR_95_ann': VaR_95_ann,
+                   'ES_99_ann': ES_99_ann, 'ES_95_ann': ES_95_ann}
+        
+
+        LOGGER.info(f'Expected Loss = {exp_loss_ann}')
+        LOGGER.info(f'Attachment Probability = {att_prob}')

From 08bd04e2e4c1195fe3fceab7f54534a9664fa749 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 13:49:45 +0100
Subject: [PATCH 017/125] add total payout and damage

---
 .../engine/cat_bonds/bond_simulation.py       | 25 +++++++++++--------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/bond_simulation.py b/climada_petals/engine/cat_bonds/bond_simulation.py
index ecdf4e837..30178b8c6 100644
--- a/climada_petals/engine/cat_bonds/bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/bond_simulation.py
@@ -32,9 +32,9 @@ def init_bond_exp_loss(self, events_per_year):
         Returns
         -------
         rel_annual_losses : numpy.ndarray
-            Array of relative losses per year (losses divided by principal).
-        rel_term_loss : float
-            Total relative loss over the bond's term (sum of losses divided by principal).
+            Array of relative payouts/losses per year (losses divided by principal).
+        term_loss : float
+            Total payout/investor loss over the bond's term.
         rel_monthly_loss : pandas.DataFrame
             DataFrame with columns 'losses' and 'months', detailing the losses and their corresponding
             months for each year.
@@ -44,6 +44,7 @@ def init_bond_exp_loss(self, events_per_year):
         rel_monthly_loss = pd.DataFrame(columns=['losses', 'months'])
         current_principal = self.subarea_calc.principal
 
+        summed_damages = 0
         for k in range(self.term):
 
             if events_per_year[k].empty:
@@ -56,6 +57,7 @@ def init_bond_exp_loss(self, events_per_year):
                 sum_payouts = []
                 for o in range(len(events_per_year[k])):
                     payout = events_per_year[k].loc[events_per_year[k].index[o], 'pay']
+                    summed_damages += events_per_year[k].loc[events_per_year[k].index[o], 'damage']
                     #If there are events in the year, sample that many payouts and the associated damages
                     if payout == 0 or current_principal == 0:
                         sum_payouts.append(0)
@@ -71,10 +73,10 @@ def init_bond_exp_loss(self, events_per_year):
 
             losses.append(np.sum(sum_payouts))
             rel_monthly_loss.loc[k] = [sum_payouts, months]
-        rel_term_loss = np.sum(losses) / self.subarea_calc.principal
+        summed_payouts = np.sum(losses)
         rel_annual_losses = np.array(losses) / self.subarea_calc.principal
         rel_monthly_loss['losses'] = rel_monthly_loss['losses'].apply(lambda x: [i / self.subarea_calc.principal for i in x])
-        return rel_annual_losses, rel_term_loss, rel_monthly_loss
+        return rel_annual_losses, rel_monthly_loss, summed_payouts, summed_damages
 
 
     '''Loop over all terms of bond to derive losses'''
@@ -98,18 +100,20 @@ def init_exp_loss_att_prob_simulation(self):
         """
 
         annual_losses = []
-        total_losses = []
+        total_payouts = 0
+        total_damages = 0
         list_loss_month = []
         min_year = self.subarea_calc.pay_vs_dam['year'].min()
         for i in range(self.simulated_years-self.term):
             events_per_year = []
             for j in range(self.term):
                 events_per_year.append(self.subarea_calc.pay_vs_dam[self.subarea_calc.pay_vs_dam['year'] == (min_year+i)+j])
-            annual_losses_per_term, term_loss, monthly_losses = self.init_bond_exp_loss(events_per_year)
+            annual_losses_per_term, monthly_losses, summed_payouts, summed_damages = self.init_bond_exp_loss(events_per_year)
             list_loss_month.append(monthly_losses)
 
             annual_losses.extend(annual_losses_per_term)
-            total_losses.append(term_loss)
+            total_payouts += summed_payouts
+            total_damages += summed_damages
 
         self.df_loss_month = pd.concat(list_loss_month, ignore_index=True)
 
@@ -117,7 +121,6 @@ def init_exp_loss_att_prob_simulation(self):
         exp_loss_ann = np.mean(annual_losses)
 
         annual_losses = pd.Series(annual_losses)
-        total_losses = pd.Series(total_losses)
 
         VaR_99_ann = annual_losses.quantile(0.99)
         VaR_95_ann = annual_losses.quantile(0.95)
@@ -130,8 +133,8 @@ def init_exp_loss_att_prob_simulation(self):
         else:
             ES_95_ann = annual_losses[annual_losses > VaR_95_ann].mean()
 
-        self.metrics = {'EL_ann': exp_loss_ann, 'AP_ann': att_prob, 'VaR_99_ann': VaR_99_ann, 'VaR_95_ann': VaR_95_ann,
-                   'ES_99_ann': ES_99_ann, 'ES_95_ann': ES_95_ann}
+        self.metrics = {'EL_ann': exp_loss_ann, 'AP_ann': att_prob, 'Tot_payout':total_payouts, 'Tot_damages': total_damages, 
+                        'VaR_99_ann': VaR_99_ann, 'VaR_95_ann': VaR_95_ann, 'ES_99_ann': ES_99_ann, 'ES_95_ann': ES_95_ann}
         
 
         LOGGER.info(f'Expected Loss = {exp_loss_ann}')

From 3d59693576757231cf821d49fdaf54fa84f7e0cd Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 13:57:03 +0100
Subject: [PATCH 018/125] update function description

---
 .../engine/cat_bonds/bond_simulation.py       | 29 +++++++++----------
 1 file changed, 13 insertions(+), 16 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/bond_simulation.py b/climada_petals/engine/cat_bonds/bond_simulation.py
index 30178b8c6..9184ea5aa 100644
--- a/climada_petals/engine/cat_bonds/bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/bond_simulation.py
@@ -18,26 +18,26 @@ def init_bond_exp_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, remaining nominal value, and the timing of losses. It returns the relative
-        losses per year, the total relative loss, and a DataFrame detailing losses and their corresponding months.
+        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
         ----------
-        term : int
-            The term of the bond in years.
+        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.
-        principal : float
-            The initial principal value of the bond.
         Returns
         -------
         rel_annual_losses : numpy.ndarray
             Array of relative payouts/losses per year (losses divided by principal).
-        term_loss : float
-            Total payout/investor loss over the bond's term.
         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.
         """
 
         losses = []
@@ -82,21 +82,18 @@ def init_bond_exp_loss(self, events_per_year):
     '''Loop over all terms of bond to derive losses'''
     def init_exp_loss_att_prob_simulation(self):
         """
-        Simulates expected annual loss and attachment probability for a catastrophe bond over multiple years.
+        Simulates the bonds monthly losses, total payouts and damages, expected annual loss, attachment probability, and other metrics for a catastrophe bond over multiple years.
         This function processes a DataFrame of payout and damage events, simulates bond losses over a specified term,
         and computes risk metrics including Value-at-Risk (VaR) and Expected Shortfall (ES) at 95% and 99% confidence levels.
-        It returns the expected annual loss, attachment probability, a DataFrame of monthly losses, and a dictionary of risk metrics.
+        It returns the a DataFrame of monthly losses, and a dictionary of bond metrics.
         Parameters
         ----------
-            pay_vs_dam (pd.DataFrame): DataFrame containing payout and damage event data.
-            nominal (float): The nominal value of the bond.
-            print_prob (bool, optional): If True, prints the expected loss and attachment probability. Defaults to True.
+            self: bond_simulation
+                An instance of the bond_simulation class containing a payout vs damage table, bond term, and number of simulated years.
         Returns
         -------
-            exp_loss_ann (float): Expected annual loss.
-            att_prob (float): Annual attachment probability (probability that the bond is triggered).
             df_loss_month (pd.DataFrame): DataFrame containing monthly loss data for all simulations.
-            es_metrics (dict): Dictionary containing VaR and ES metrics at 95% and 99% confidence levels for annual and total losses.
+            metrics (dict): Dictionary containing expected loss, attachment probability, total payouts/damages, VaR and ES metrics at 95% and 99% confidence levels for annual losses.
         """
 
         annual_losses = []

From edf659855ef20ff508102ba84464d7c613fb88f8 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 14:26:30 +0100
Subject: [PATCH 019/125] add net cash flow and premium simulation

---
 .../engine/cat_bonds/bond_simulation.py       | 64 ++++++++++++++++++-
 1 file changed, 63 insertions(+), 1 deletion(-)

diff --git a/climada_petals/engine/cat_bonds/bond_simulation.py b/climada_petals/engine/cat_bonds/bond_simulation.py
index 9184ea5aa..bcae58bb3 100644
--- a/climada_petals/engine/cat_bonds/bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/bond_simulation.py
@@ -6,7 +6,8 @@
 
 class bond_simulation:
 
-    def __init__(self, subarea_calc, term, number_terms):
+    def __init__(self, subarea_calc, term, number_terms, premium):
+        self.premium = premium # place holder till we have variable premiums
         self.term = term
         self.simulated_years = number_terms * term
         self.subarea_calc = subarea_calc
@@ -136,3 +137,64 @@ def init_exp_loss_att_prob_simulation(self):
 
         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_bond_simulation(self):
+        """
+        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
+        -------
+            investor_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 * self.premium
+                premiums_tot.append(prem_tmp)
+                ncf_tot.append(prem_tmp)
+            else:
+                ncf_tot_tmp = []
+                premiums_tot_tmp = []
+                prem_tmp = cur_nominal * self.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 * self.premium) / 12 * (next_month - month))
+                        premiums_tot_tmp.append(prem_tmp)
+                        ncf_tot_tmp.append(prem_tmp - loss)
+                    else:
+                        prem_tmp = ((cur_nominal * self.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.investor_metrics = pd.DataFrame({'annual_premiums': np.array(premiums_tot), 'annual_returns': np.array(ncf_tot),
+                                               'total_returns': np.sum(np.array(ncf_tot)), 'total_premiums': np.sum(np.array(premiums_tot)),
+                                               'sharpe_ratio': sharpe_ratio})

From 2388d7c324c3ecd8324b987e284e3b9e814d518a Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 15:24:33 +0100
Subject: [PATCH 020/125] adjust metric naming

---
 climada_petals/engine/cat_bonds/bond_simulation.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/bond_simulation.py b/climada_petals/engine/cat_bonds/bond_simulation.py
index bcae58bb3..42a488a93 100644
--- a/climada_petals/engine/cat_bonds/bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/bond_simulation.py
@@ -94,7 +94,7 @@ def init_exp_loss_att_prob_simulation(self):
         Returns
         -------
             df_loss_month (pd.DataFrame): DataFrame containing monthly loss data for all simulations.
-            metrics (dict): Dictionary containing expected loss, attachment probability, total payouts/damages, VaR and ES metrics at 95% and 99% confidence levels for annual losses.
+            loss_metrics (dict): Dictionary containing expected loss, attachment probability, total payouts/damages, VaR and ES metrics at 95% and 99% confidence levels for annual losses.
         """
 
         annual_losses = []
@@ -131,8 +131,8 @@ def init_exp_loss_att_prob_simulation(self):
         else:
             ES_95_ann = annual_losses[annual_losses > VaR_95_ann].mean()
 
-        self.metrics = {'EL_ann': exp_loss_ann, 'AP_ann': att_prob, 'Tot_payout':total_payouts, 'Tot_damages': total_damages, 
-                        'VaR_99_ann': VaR_99_ann, 'VaR_95_ann': VaR_95_ann, 'ES_99_ann': ES_99_ann, 'ES_95_ann': ES_95_ann}
+        self.loss_metrics = {'EL_ann': exp_loss_ann, 'AP_ann': att_prob, 'Tot_payout':total_payouts, 'Tot_damages': total_damages, 
+                             'VaR_99_ann': VaR_99_ann, 'VaR_95_ann': VaR_95_ann, 'ES_99_ann': ES_99_ann, 'ES_95_ann': ES_95_ann}
         
 
         LOGGER.info(f'Expected Loss = {exp_loss_ann}')
@@ -151,7 +151,7 @@ def init_bond_simulation(self):
                 An instance of the bond_simulation class containing monthly loss data, premium rate, and term. 
         Returns
         -------
-            investor_metrics (pd.DataFrame): DataFrame containing annual premiums, annual returns, total returns, and total premiums for the bond.
+            return_metrics (pd.DataFrame): DataFrame containing annual premiums, annual returns, total returns, and total premiums for the bond.
         """
 
         premiums_tot = []
@@ -195,6 +195,6 @@ def init_bond_simulation(self):
 
         sharpe_ratio = (np.mean(ncf_tot) / np.std(ncf_tot)) if np.std(ncf_tot) != 0 else np.nan
     
-        self.investor_metrics = pd.DataFrame({'annual_premiums': np.array(premiums_tot), 'annual_returns': np.array(ncf_tot),
-                                               'total_returns': np.sum(np.array(ncf_tot)), 'total_premiums': np.sum(np.array(premiums_tot)),
-                                               'sharpe_ratio': sharpe_ratio})
+        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}

From 7db291ca773cf81437f5981baaaaf87315991160 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 15:29:00 +0100
Subject: [PATCH 021/125] update test to classes

---
 climada_petals/engine/cat_bonds/test.ipynb | 213 +++++++++++++++++----
 1 file changed, 179 insertions(+), 34 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/test.ipynb b/climada_petals/engine/cat_bonds/test.ipynb
index e16e53835..e315e8f78 100644
--- a/climada_petals/engine/cat_bonds/test.ipynb
+++ b/climada_petals/engine/cat_bonds/test.ipynb
@@ -12,10 +12,13 @@
     "\n",
     "from subareas import Subareas\n",
     "from subarea_calculations import Subarea_Calculations\n",
+    "from bond_simulation import bond_simulation\n",
     "\n",
     "from climada.hazard import TCTracks, Centroids, TropCyclone\n",
     "from climada.entity import LitPop\n",
-    "from climada.entity import ImpfSetTropCyclone\n"
+    "from climada.entity import ImpfSetTropCyclone\n",
+    "import numpy as np\n",
+    "\n"
    ]
   },
   {
@@ -28,7 +31,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 2,
    "id": "89b53a88",
    "metadata": {},
    "outputs": [],
@@ -71,9 +74,9 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-07 10:36:51,618 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
-      "2025-11-07 10:36:51,682 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
-      "2025-11-07 10:36:51,725 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n"
+      "2025-11-07 15:27:54,824 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
+      "2025-11-07 15:27:54,989 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
+      "2025-11-07 15:27:55,091 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n"
      ]
     },
     {
@@ -87,27 +90,27 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-07 10:36:56,358 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
-      "2025-11-07 10:36:56,399 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 546 coastal centroids.\n",
-      "2025-11-07 10:36:56,725 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
-      "2025-11-07 10:36:56,994 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
-      "2025-11-07 10:36:57,279 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
-      "2025-11-07 10:36:57,797 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
-      "2025-11-07 10:36:58,237 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
-      "2025-11-07 10:36:58,623 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
-      "2025-11-07 10:36:59,018 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
-      "2025-11-07 10:36:59,373 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
-      "2025-11-07 10:36:59,612 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
-      "2025-11-07 10:37:01,015 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      "2025-11-07 15:28:03,073 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
+      "2025-11-07 15:28:03,338 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 546 coastal centroids.\n",
+      "2025-11-07 15:28:04,253 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
+      "2025-11-07 15:28:05,117 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
+      "2025-11-07 15:28:05,885 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
+      "2025-11-07 15:28:06,870 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
+      "2025-11-07 15:28:07,616 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
+      "2025-11-07 15:28:09,211 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
+      "2025-11-07 15:28:10,170 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
+      "2025-11-07 15:28:11,194 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
+      "2025-11-07 15:28:11,616 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
+      "2025-11-07 15:28:13,815 - climada.entity.exposures.litpop.litpop - INFO - \n",
       " LitPop: Init Exposure for country: KNA (659)...\n",
       "\n",
-      "2025-11-07 10:37:01,104 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-07 10:37:01,733 - climada.util.finance - INFO - GDP KNA 2020: 8.839e+08.\n",
-      "2025-11-07 10:37:01,750 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
-      "2025-11-07 10:37:01,751 - climada.entity.exposures.base - INFO - category_id not set.\n",
-      "2025-11-07 10:37:01,751 - climada.entity.exposures.base - INFO - cover not set.\n",
-      "2025-11-07 10:37:01,752 - climada.entity.exposures.base - INFO - deductible not set.\n",
-      "2025-11-07 10:37:01,753 - climada.entity.exposures.base - INFO - centr_ not set.\n"
+      "2025-11-07 15:28:13,913 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-07 15:28:14,598 - climada.util.finance - INFO - GDP KNA 2020: 8.839e+08.\n",
+      "2025-11-07 15:28:14,736 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+      "2025-11-07 15:28:14,738 - climada.entity.exposures.base - INFO - category_id not set.\n",
+      "2025-11-07 15:28:14,740 - climada.entity.exposures.base - INFO - cover not set.\n",
+      "2025-11-07 15:28:14,741 - climada.entity.exposures.base - INFO - deductible not set.\n",
+      "2025-11-07 15:28:14,747 - climada.entity.exposures.base - INFO - centr_ not set.\n"
      ]
     }
    ],
@@ -130,7 +133,15 @@
     "\n",
     "impfset = ImpfSetTropCyclone.from_calibrated_regional_ImpfSet()\n",
     "iso3n_per_region = impf_id_per_region = impfset.get_countries_per_region()[2]\n",
-    "exp.gdf.loc[exp.gdf.region_id == country, 'impf_TC'] = 1"
+    "exp.gdf.loc[exp.gdf.region_id == country, 'impf_TC'] = 1\n",
+    "\n",
+    "# change dates of tc events to allow simulation of multiple years\n",
+    "tc_irma.date = np.array([736576, 736596, 736649, 736659, 736668, 736681, 736701, 736702, 736715, 736726,\n",
+    " 736727, 736731, 736743, 736753, 736762, 736781, 736787, 736803, 736808, 736821,\n",
+    " 736843, 736848, 736854, 736868, 736872, 736878, 736892, 736900, 736904, 736912,\n",
+    " 736921, 736926, 736940, 736945, 736952, 736963, 736976, 736983, 736993, 737003,\n",
+    " 737012, 737020, 737031, 737037, 737048, 737059, 737068, 737074, 737081, 737092,\n",
+    " 737098])"
    ]
   },
   {
@@ -143,7 +154,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 4,
    "id": "09fba021",
    "metadata": {},
    "outputs": [
@@ -151,7 +162,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-07 10:45:59,580 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+      "2025-11-07 15:28:15,506 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
      ]
     },
     {
@@ -180,7 +191,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 5,
    "id": "ac344ab3",
    "metadata": {},
    "outputs": [
@@ -188,17 +199,151 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-07 10:54:31,722 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n",
-      "2025-11-07 10:54:31,723 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n",
-      "2025-11-07 10:54:31,724 - climada.entity.exposures.base - INFO - Matching 328 exposures with 546 centroids.\n",
-      "2025-11-07 10:54:31,728 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
-      "2025-11-07 10:54:31,760 - climada.engine.impact_calc - INFO - Calculating impact for 984 assets (>0) and 51 events.\n"
+      "2025-11-07 15:28:39,012 - climada.entity.exposures.base - INFO - Matching 328 exposures with 546 centroids.\n",
+      "2025-11-07 15:28:39,017 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
+      "2025-11-07 15:28:39,033 - climada.engine.impact_calc - INFO - Calculating impact for 984 assets (>0) and 51 events.\n"
      ]
     }
    ],
    "source": [
     "st_kitts_sub_calc = Subarea_Calculations(subareas=st_kitts_subareas, index_stat=par_index)\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)\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)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bf3bead9",
+   "metadata": {},
+   "source": [
+    "### Bond Simulation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "4ead6e69",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'annual_premiums': array([2.83731021e-02, 8.73102078e-04, 1.66533454e-18, 2.50000000e-03,\n",
+       "        0.00000000e+00, 0.00000000e+00, 2.50000000e-03, 0.00000000e+00,\n",
+       "        0.00000000e+00, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
+       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02]),\n",
+       " 'annual_returns': array([-6.22386067e-01, -3.48367729e-01,  1.66533454e-18, -9.97500000e-01,\n",
+       "         0.00000000e+00,  0.00000000e+00, -9.97500000e-01,  0.00000000e+00,\n",
+       "         0.00000000e+00,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
+       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02]),\n",
+       " 'total_returns': 837183157.1067066,\n",
+       " 'total_premiums': 2163066490.440039,\n",
+       " 'sharpe_ratio': 0.08943209491064437}"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'EL_ann': 0.017543859649122806,\n",
+       " 'AP_ann': 0.023391812865497075,\n",
+       " 'Tot_payout': 1325883333.3333325,\n",
+       " 'Tot_damages': 11037139919.100546,\n",
+       " 'VaR_99_ann': 0.7555314181864904,\n",
+       " 'VaR_95_ann': 0.0,\n",
+       " 'ES_99_ann': 1.0,\n",
+       " 'ES_95_ann': 0.75}"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "st_kitts_bond_sim = bond_simulation(st_kitts_sub_calc, term, 20, 0.03) \n",
+    "st_kitts_bond_sim.init_loss_simulation()\n",
+    "st_kitts_bond_sim.init_return_simulation()\n",
+    "display(st_kitts_bond_sim.return_metrics)\n",
+    "display(st_kitts_bond_sim.loss_metrics)"
    ]
   }
  ],

From f9c6cab159ac045e79607ffc7ac34f47fbcfd4c3 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 15:29:10 +0100
Subject: [PATCH 022/125] change function naming

---
 climada_petals/engine/cat_bonds/bond_simulation.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/bond_simulation.py b/climada_petals/engine/cat_bonds/bond_simulation.py
index 42a488a93..ee048adab 100644
--- a/climada_petals/engine/cat_bonds/bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/bond_simulation.py
@@ -15,7 +15,7 @@ def __init__(self, subarea_calc, term, number_terms, premium):
 
 
     '''Simulate one term of bond to derive losses'''
-    def init_bond_exp_loss(self, events_per_year):
+    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,
@@ -81,7 +81,7 @@ def init_bond_exp_loss(self, events_per_year):
 
 
     '''Loop over all terms of bond to derive losses'''
-    def init_exp_loss_att_prob_simulation(self):
+    def init_loss_simulation(self):
         """
         Simulates the bonds monthly losses, total payouts and damages, expected annual loss, attachment probability, and other metrics for a catastrophe bond over multiple years.
         This function processes a DataFrame of payout and damage events, simulates bond losses over a specified term,
@@ -106,7 +106,7 @@ def init_exp_loss_att_prob_simulation(self):
             events_per_year = []
             for j in range(self.term):
                 events_per_year.append(self.subarea_calc.pay_vs_dam[self.subarea_calc.pay_vs_dam['year'] == (min_year+i)+j])
-            annual_losses_per_term, monthly_losses, summed_payouts, summed_damages = self.init_bond_exp_loss(events_per_year)
+            annual_losses_per_term, monthly_losses, summed_payouts, summed_damages = self.init_bond_loss(events_per_year)
             list_loss_month.append(monthly_losses)
 
             annual_losses.extend(annual_losses_per_term)
@@ -140,7 +140,7 @@ def init_exp_loss_att_prob_simulation(self):
 
 
     '''Simulate over all terms of bond to derive returns'''
-    def init_bond_simulation(self):
+    def init_return_simulation(self):
         """
         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.

From 1168e6206291b90eb4e2132cf84deef49ae4a290 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 15:51:33 +0100
Subject: [PATCH 023/125] inititate premium class

---
 .../engine/cat_bonds/premium_class.py         | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 climada_petals/engine/cat_bonds/premium_class.py

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..441dc5bfc
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/premium_class.py
@@ -0,0 +1,35 @@
+import pandas as pd
+import numpy as np
+import logging
+
+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 premium_calculations:
+
+    def __init__(self, bond_simulation_class):
+        self.bond_simulation_class = bond_simulation_class
+
+    def 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)
+        else:
+            pass
+        if BBSpread is None:
+            BBSpread = 1.6 #ICE BofA BB US High Yield Index Option-Adjusted Spread (January, 2025)
+        else:
+            pass
+
+        self.chatoro_prem_rate = b_0 + b_1 * self.bond_simulation_class.loss_metrics['EL_ann'] + 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
+

From 8ef65cb19658ef31070f6a65f5d9d96c3bf31751 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 15:56:55 +0100
Subject: [PATCH 024/125] add IBRD CAT bonds data file

---
 climada_petals/data/cat_bonds/IBRD_bonds.xlsx | Bin 0 -> 11383 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100755 climada_petals/data/cat_bonds/IBRD_bonds.xlsx

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 0000000000000000000000000000000000000000..64488b9721aca3cccf98611292b16491df0eff1e
GIT binary patch
literal 11383
zcmeHN^;ccV(uLp_+}+(h5Zo_LaF<K)i+gZ)PjCqC1a}SY?iM_FaQ{f=y)`p=^Zf<y
z^$&g4U8i@gb^6xs+FezO00>A7FlaDXFfcGuunYz(kR>=67zz{^7&;j2D{WDbjU&*;
zQU9HrEzm)i$<^A5<TK<enk=waFYEs|{)=~@G@(<zn*}lGM5;wJk=~-(P6)Pa$*=>J
zij|0j;uw!n?lTYm($c1>u}ER5$U&YG{{3@%gELjNu5lG3<n(Bgl}>~PwA!1zqhgbj
zq1}fJAWooa7Y_pE5=7O)#hpdfvPVZm6=PCq)P$gIR8^3K!3Mv^Vv&xSSngcqH@*H^
z4e)lt$m0e_F26`OE6#bxAFzq@pFX`k+B^59@DWZLLG~?E9|*XX0HB5@fXeQ+<A@32
z2W43`ETg#tI$aAyo6qYzSx*vW&};mxNJTtRkql4MH!_(@1=F;#cg5e(=&G8-4GzeO
zV$zJmpuk)D%zq*)6DO~E+!5H!^ouP3^0P>Jv{5W~qwae{D2xrE#>qyL_O^l(G#yIU
zj5T6`PirG`;QB*6OdoH=boIN*F|ygB$~Wyk6oIfi-E!expL+Y8pjuZuD2SkZ4w{N_
z=DZ(>&42!eF6z-vqe!^Qzw&;H`Nh4SpCP~$|Hjc;RTlD#mp8I66hwI8sJ=bW%7K~b
z=lnlz{udMSFP~l-C#UcSHy?uguV+?bP(%PO!cxto@4S4Zmyv5Db13jv+NlXp-r@N}
zNP4$=Jq#|b@JD{{C%yW{Q5ueh!AD-_QWo^_&dv#jj><ks!mf1VE2{I%<;+#Gq>LMl
zb89qRNkd^aU|@}0V(Lun3(6RiIvyN)9zhV++hkv@UOCNGqnmQ@84;DEvY^U(?yT?e
zW2xSAN%{Lof+4)Jhm*;e{SHR&7s@^Rtw=9#@l;jJc+D$~GVI@wx#^o&b)1W(wxd6K
zGRmj*E0b}c-LQ>G_EBbCdTZ5ioDHSBedUJhF6loV@Czp{Tzv^w|49-A!oJM`2rw{R
zI505emz{C7Vs-)9TN;5tmOq17sj4+7hX>`!Yw{81^(B1|l@J)GW-QpE)KRfa_0cM=
z@|KTE>1iB$zO?F*cROnU$3m%m<FRT{<k7|%JNp<Scc!yjev6{smnxjX8@wWT#&2wf
zJ?BD?Z^AhwRq2Go0!)CyFyHCRrWLx^yqg!2JX;xtYF~kgb1JHka%GgO+sQa6>wd)7
z>KG{A;zh088gsARNT5)aDe7lm5$d0H=z^~mKfR&E*|z90!b`AApAxAdNi!7#d!z%V
z7K;vT0@m%j<}M||hdd!r07<N8i$29NL>}?GpSMhseV6#GX!%|X;y<zab?({t<y4p0
zW1Uygsei-Ex=gxAe#Y6y$qX=XA@U!Jkxie%rgCsK=s7~JszTPd;=_?>j|dXhid5r=
zU4@w_h2Rz?TrJg*AlBZeGpW86u}?0NRb^8SWij-lf~Z9vvIi(|xwhiYF!-x<vqrQP
zBO}|l?aGL#=Z=0w3|Q{;CuMVol?I>$Wx@?2knJ@vK<?R|%vD&FcM=s)(&!{lwp;en
zVqondcm~FPCDK&87R!|xsrG$ywWCjO>)l3WCB3Vw^zPjD%I!>jL^Ex)Gc-)~+y|CT
z5RHMiBI=n$6K#lR4<#hY>i)r4(TDx|jpiysdB-_LL*O)j47L<TKk35U86=ypM>yFI
zkzPw<cC?jMa|(#h*Ax$YlE4zfJclL1YAZsnyJM{r*T%z6+9LLtlO!9a7!FR5uZg_*
z7?Qlgbbv3CyXJXn>!Eu*{lmxCLpIm_dv)&W;W~89)M^yl&RG^377v$>jn=O-HOQ20
zCpnQ=%&!GhuF_r^M=&ZTS<%KV2z{s~B#45To89s^U98LD^*yi@Cccy{nL7z?TVk1v
zrs4d6S;$$f%u#zv;=vdM&9qC^U)=T94JMPKLE7jVFC+t#BbF1AM6%@Vw9!Y*+e<Pd
z<vV40fU=UN7VAKYB?Z50Y!yZJ55VWwOH0oUKPoC+I2+l9@gHHa#T?wJ!Fm)w*jp4f
z;oz2UNx6KhLmNTtdXGY4Mb;jzqatcJHYwZ3$<cR+yEu;+G5$SRn5QaNWb5O=z2KdL
zinreNKs<v=S5HK|D-!V_t!^X<-lVxEcE|On!+v{-LKut@Sjm)7-P}ltx*|>C>FPTk
zoM5#Jd9|kYI|CQTiydnjF{E@+u1M3P0oKJ6A};l#UV&EXnG-pP{r;yTZ+1_x6L$A(
zy9?LsjhmsB!()-9CEGgJFec8c6A54M##X`fJMYmh&<f_A0>mPfPE@4qr94%)_Y0^0
zll5^h35Sp`=Yil0^YOr7!CzSaM|Auv_x~L!!CzGD%i90$Q5rX7@s$Np{5tT-f1=Hf
z?So>Fo#}+~C+k!%AKL^TStA(j4_hae%5MfbVr;5drMj+(LYtSoUCM4Ki1FTInn=U@
zl{y2BEul_&hDOLkI?Mo8>6B0qQ1iQU>dopFv6}@3DFPvdM*gq5mqB@mi;BUdc5fGW
ziqcMEjQ1@Uas-Uz?Bny1C&xHR1g9{9m3;*h>Pf<~qeq`Dn~N<t-ts+8#BL*Cv7L_h
zLW%jdQK_A3Q^%ri0q;jrt_a3N;_o#E&qk7PsyK1m(gdMJzoPdQVQ%qg1~lrUOBk1A
zB62zV@zy3W+1FdpAiC47&G!wDRkMPgJNv8WcLo2^hvdH8)?U2ahW07Iz;Iqx{3~)e
zm;r%~4$QwEtUp6YTKrN}Dho=`3H>Eu%t_}w3YucSMZDw8vg!&^Iiay1W<=3Zn%3nC
zUrdZHtunV39L|dZe!}IKC5|e-y6Vy>N+pOT5z8=ZU^1y5n79ThJVCn6e#tkewGoSw
z@A@3P(1$$b&!w#mx4}=s!6ljKU>)>jJ5g~Mx(O4hG+~iu$H0PXzD}a@Gj<W)6pL)7
zQI+s}5z}MCy{ZHq2F^9wi3awsAt}85Yid=s5OQZ8wqeOf<(G|Wj3l#FNypQou?4Pm
ziyVuUPDoC~(!&id9JWdgIi305-kZ4;+>75Qp@e#O(?CNCc44^faW)6-2%<(-U-g_}
zZu~x<074_m8SY+%ufhS!D~}zLt*FBZ9^v}T6XF!UD(prZ3+9LC32Np8yongi(imXV
zV|w&CQnAqF8%hS*KMzlk52$fSxN;rg?*(JP+*=&-)_GyouFLzt39o|6X4v1aEab5q
zEjpE5)=iZeNW#9ZTU+C0Io{G^5Yyc?d)<6gv5FqF9$XPr(dU1wvbL@tp&k-<WO1!Z
zEP&8hL|}pnLr&9jkXFjW7`Q!NWk4vF6E)<7gyQNh<NQoiL%?@+MuMQeO#=^+lA9Bv
z*m0Wfr1i*Oap9($Sh+|~s+T|kM@13Zy@dp{R}yKVF~^}mCFsQOIunPrtIWOD%*Uqu
zDvS#?;mvRNoc{DneEjmG1kEFxO)eDA#13Sk@LZ{|;IBf~)Nw@Q{ge$)jabq#b)dCv
zNrq#V1ai!V1G@%*Tf_27w#}N?Tfz2B;x%IA`U>wyhjaJ(_~z95c4F`LiRZ`D=2UOs
z^UcNPuJ`V4eZlV9iA%G*SvB9XKwzWyxCx$nj<+{K)6!$#hVyg67h_w;`l%kox2LoP
zlgkc=I!23jr)`i(eMFx~`+Ct-2vTKa?X66mhf<G2s}bxh5bQW^MRbtALP@$b3&a(_
zfjXt_Jhb+`JKs&HWSj&SzOIEpz$k90!-V%?1#jImsHdtUW8s4-`PiL%MNZ1Rk(Y3)
zb>C^W;v|2t${gFtlec&4#gdc_4eo##CBo9%V<`_%3ALi4H#c}_;}C&9ml5ecj$BCg
zkxQQBX}Kbh&^O9`aQFQ1)Y$Cy!K-m;<gTyO{Z8C_(r%fMs+HJ@st!BpZMbN!CCk$l
zX~DopjX-oy#3(gaIa}OA%x2zEObPSG;@nL2ouptBia^M&UP#ARo9vO@ro)B_6R9{W
z!8H5gW0}Bk+(c7^M2<#jplyu^(43A`FkMvQiH9db(bS)SDphzKm4VoVLyp}D>_<N2
zddaY1Lr)P#cUEL#-Q4ZTP#c^45th8Uef-oqtObg#Bi#t4NqKc-%OD*OfSmtspcgKB
zfE`>y197w^tT&ehCaWh8ZIPCJZ`F<4bpewz&ThZXRyv+pN2V0ei5>%I=W2BINm7?W
zMcpj{*D!&KoYuXc-xxY8q+mkNU?LS_T;O|;qr_@uAb(0r49xx^4nMdXiWRkK^cE5=
z8jNgw9xAj>9V)bTI;3LIrX=x{@u%6>?VZ>1OWEpG?1SHdn>hZ{B3|v2<6D8kH=KRz
za5w=5ysRE3<J8b4&LOzIeXO`MmlTn6)LaquG*bzWH|I`Q@he!PU58xe6LXle4KNIh
z0YQsKU+Qe>w-~i?H`bTsaeWDRUi@o?rPoRCdT@Re$NHm>X(v^EDE6$Vaf7)2+$UqA
zO4pd+c^~x|@`g4mT%tuQao{Uwqq_?jKGwc7E+-pB3BbO`cH~J@4}F16yk~4_UP&Rq
z!be(=zjzsfgYdlwxsxuY({>l86SkX?=WRy|tw+6TYot)B^paDqW<uQTrN3p(tbM#G
zT=mDP@D-;EDAo}B7>|xzNwY)5FIKkn3{4AzA>TEqU0C>ace>deAk~_LM=~V@mUGo8
z&|k-xMuGRxDYFjpzq@6zj4qBeL@-v7GMEo$#*q{1+1vHhR%)WsGV<58Z_+rQYLl+*
zSC%aNp0TUaz~EcDk*6>$N(l}p*VOXnsN@w@Dz9()_fM$P^KLj-rcvETB-S%2a%AF3
zVZy?)gb-m$no9ivGESq_L4`vc>?N<=xpEK)XW_dLqAvW-!W4L>nQ)bym~_#ZwPK(-
zdffroI`7gC?V;V$Y?PU+-l4${p0Q@BOPgxtzPZzMm{v7c?Hcd$Z4ovgXE6<cM-4m3
zA0dcMG^?$ux4~&SDLk&Xn5NPt2SjF*1Vn+i${ZBekRqRT<>e<PtA0rxem7$jwUCXG
zU;Hottur!_HBzMB<ZyMaFw^jyn3^m9=>zS9YoA9%Th^&MoT2JbOt6Nnh4S3Rs3=#w
z<3P0fZl<zXp_E)dHm!ji(gddM`_>$_;*b7E?n@{!7V&uS)!14}0h0Pc^baZM=ZcAR
zBF4sAs@^t1Us6V-UK>g#qB6Q$fwN7jCv(0!GDB(=&@IImC$&rmB{0`Y(*-Wj*La;3
z6?{&VrW`KadOq;VWQ>qgt@~WU)lxGYQp7GK@sMaa#yhGV`$}Gu9%e3C9{&Vy8(@7;
z_09sn6ti#dK<kiAGsr!GUo4Kb@WlThiReSWnj<(O94SOo(_R`A70nOwajIJ4haZ_B
zTGd)<gTMvA*0=ZBdk1($CB(t~qKCTlv18cKKZvR{nZwR;1&g9^vr8yl7ih_`1Z{><
zHE8v<cng5Lsui@GT<(51!uv~W0bPfIYAs+PZRHb9#Z~>HSu^TuObbnzB@1B!D+ZNR
zUqinYO0*TU#O2z63*1SVFlr%PYAT}@1TDU2(7)fFx_kZ=Dt=8IQ7iC%LKp%1K;CP$
zW-U__1506S;R*w%Y04$?zA55~=J(<*=Sb|s!{OoMi=2L?I71k0Z<jv7PN%=ec9GrS
z4U1=)peLjlVt7qvd~T3J?N*6c7D}a-T2#l3!?a^9N7O^;Tq^UUYJUhifnQ6uGoI30
z{FvYtR99%LZM*GRfX6@?I6(s4Q(pY6RruIstmuK3eV%E-5Y<l%pRND-=??i0xf}ni
zs00;w2K`TJ`^un3xB&(X43+F>viO%$ax?>41DSu#zeLiZ)<`sdJ!U&h|Fh7r?(FcM
zhavBH0r%Ch`$nSfmXvftklv`Rka9CU1~~lgG{E<j`2@gs)tx2`+RO*KaVwhDfL!i5
zgx_8wWg{%C^+_ns$c34G`sD4?PHSHuceKNGe95P51Tu<k={bbs8zQoSh%xi3Lw5zL
zO_?Q8<qeZ4Tm`8)ZS?&Q_9vUs$KN0@V?U9^C~ScryT>Z;3)j-UXNlM*%!q^Z(zZo4
zhN?HxOh@p9b2nB)`p~W!$tuU6u#Ph=pvABkkrk@8zp_L_%-SHAFb%;@HCkg~B#m?U
zz&{S#m;^yJ4rQu~ypw!B1lOocWTZiNlYMZzGgh+Ntlb0Ch@#?Q0<bqe|2VY$>im3s
zm^NwZDEEoRYR<pR3&Owxo7>{xxl90}qZ*gryf?3u-HhYW`I9jq>u@r=c?#Zwt1Y*^
zuA6s{<KA#(5+s!Tba%`i#g}8)-G#3h1Ug*z@R~oFW@rHi-t4??6Zl@+6&uK%6*95q
ziM?V~yEH=38py!I=h($JlD~$xbNUKuqB4@{ZI2(dg??$z4KB7Zm>EfT7?o6+N>vAY
z$Tz*>1~E}Om7qBy8M`h@#Ct;&p}m<$+j|g06f!K6w548$*fFBHfYd0Yoa&qhm{u#=
z);9NAi|f;6`0lgYSr0aI#xnxp1TdFPHEEetJ_*=J{PfiK{CMfI*Z%ypgslHG5cv`K
zP~!dcG*iF!nBcBq5lE}|bX%gX?|u1$+56^+SpQAUHDpH8209*ksC+-A`>?UAkTHC!
zU~*Whv@Dq{BOHORP4M^FFoyL3Ja+7I1uJv`%ow0f$9>6rths8bQVgfz2bM6#b=KX|
zvA`)X<Vzh&1O>H$$+wLfiFVPfZMGwCJ3_bDC+Gq%WOV6ZP`{XEu%*$oP{1ikJ@<~m
z*}bG*6SSP)=CgNF>eF1{ihqzzr%E0#!juXeCynf6w!{{;tp%oT78H&p9~1>|bxCwp
zbqou8iF^X~-n-`69xC&8veM%}z?Srj|FB{-1ujd`onFMTL`gW1<pFkLeRdgnA4!A0
z?l|7FYWHy|)3_f`x&`nulLtR|qHORu+2>2Y>-C}=BNbzPvponUxN`+RalH<ccIb4i
zBE#U)E`ZAK3#p#}4l?8kNJ-GvqR`MvG-u@-N<VZVW(Azf$Qs?-t4LBaBS!5yrOZJ0
z%kcbeFuq#^JomfshpieUwS$_4u<9#rQwRxQlb+*jru`8jLvJ$HA9u3h(9)LVI?EIK
zWxn7Rvc)Fw_+5vQqoV6q(_P>?T;LDnZ$0J-l4y<zejYUn2j&4~t$;OvOG|m+c00GG
zaV1mcileR{V&fM?iYxBA5lD7RKQaTVPoK%vo1jpK9s@&G)g$KzY3nPotv8@)B1+w<
z^9K&XGSL|z+aKI4GLh9T8!+1et<}sG1bQX*R~ue|wIe7MaVoEt25i1HF<RRI@K2uG
zY8L8~KnN*IemiwpcCCINV*K(84YOKkwch5Rp`RSxGtd~nw;1V<<tQVDtKd9mMNG*^
zFqgHt_c4e3c;{yD3ZWijzMrIX22>a}N|q+#O~ax)oHwk>OexbCP#25K_4v+SuHIar
z?3=N`*kXEq`__A^1P#nhF9<w^1)iGXcR@CFKZHj>qAQiUDQX8nK1r=`p_3+Dp(*}i
zmh3lpXfGkwOT&?XVNvU`SCuax%tE`O!-Lze{<3_o@O?xUISl8W&ONQeWpDE$@5#*6
zeZ;^ZDp*;Mu7V54Tx)beCKEy}_i2rI7Y`)@eQLm2BJHUOB&gfXG3owT5Yv|X(y73<
zNL(S+s2UF*uk0%Lv{s&M&K?3VnCwTnhc@d98$K$^p61*NbrHG2CQs^`>vi2_1sBZB
zPFaQd%vD5*sf_d`f-O9?H2#)4KMeM(+4AMZIjGy0k}A|>>rJJjchQze>$;cuR>wiz
z#{nZ@)8fPH$&flnX9QXS0M@8}<js<QErq^s^VsKG%9N@^*9g+Dcx6H!F7lKF#E{7)
zyBMS0b;+e6?UsBh8INV6<z&RhNfJD3%7Y91{;5bnK;N>pwPMpyCN5%=W!Jv)N##k)
zQJYuAY!dxdpZphdEpu^D>ao?`hVw02i4k_K2C(toee}pGju5igA=UM|wOy?2)9~kf
z+>;%{^qO;})J2a{Sea%8hv=2M)PN~8Q1hk#@@3%+-`D&~4qwpg(V_QCo_C0GeJJv%
z>I{5Grf|#2lWcD>d+SvM^mjkXnub!HH!{gozkB+`fRe87)H<%pyA#~!#@T@;l$wIA
zHm^3Wd9>i?UOgmU4b_Y}Iyi56S<KjyI8RV*6DVgnA+D`!EkEs4W@9@0dMINt*U*@@
zVX>C1W&kQ^l9z9I#GZL8nLbf{(Kb-c&$)H&E>iCU3KukH`wEWg_u3|Xb8h!qnTm-*
zs2quP<ok_XAq8=}@%}bXoNjXz?cFuOPiN^Ml5ZovbLqIzCCi?hikz$5YeJA4Pau+x
zSRr}>sLM+1*L41d<E7KxhSifcGwzAP^8`U}=W9|oS9gh;Sk|)y38MNUD<=uS%8#${
z67|}-3OSZ?ym($qTxKJ$d)_zt)#Ic)IB0j|Z8)7s{*orYSDYpc`)I&lQfi(rX%VD9
z0=<Kyn-$REXC9<RO&7Gtg7G1<=Gox(?FdZ3D;ed)NvXsp3uQj@3M#vfVnMRL@k;aO
z4|CE!<5gt`v)D%ZOS>5!W35~h;*30tin^?n#)p}1I7-PyX#>EBcK+N^oSZ?FWb|^1
z$g?E18?xIQ(&FKyse8;kXz+kiqZYROv?iOxvO<!XWV)h&L=kggMA^&9G8s8(y#-Of
zX5ZaN9pO)38N1$@RDh$336=w>RX$S$G2*;8T{1AFsM;S<rjx@WD4czYF)6%~d?Qr5
z%4=TA`~aI|u3FTU23}qg<_El>TnXi~lXez*wN+1gn|%N!`DN}dQc6^P3aR?X1_fOL
z2j<|kRtgTXPoZ4rg;Ftf@*<^T!&0Ky40jDF0fT^ZJdKKuxrxx5ejVdjv2o`<p!vJN
z<B-|!1ILUZ2A)ghP_yGwtJYYEkd+d1aptt?&iNn1aSF`WVGLQmP_OoE-UyO$ld7Vi
zZ+d3#beLiwN<&_n6(-TjDsp?xC&ehhl}+X6E?ft%0Oaao;#a}z?LLVi<T;qlq<5$d
z%_fMYVL>YwF4zOxB@$1Y6?=tvsg*|im8HAN7@E;nz`6!#cCYKw+p#3)oqV^na=Vtd
zScAel;hXS9NLDI)EUB^Dqi2n-4MejZt}6?fu5Q}j96_{C<z5w_(gNCQBgYeOP?Nl$
zQeZQESIT<)zSlHv%KN^iK0&<uUYW`MAvQvSC#F~(S#qXw4s$^u@+=)GrJHcd+#k!b
z7b%{a4xHuuPEk99(b|}KKmYrcUe;H8tr$*j<og~R;@(WN(OI(jle=NAK@JpFfe4T_
z!VUR>|LjhkA0KR+S(#=;yZ+cH_4xsZZSShpAtDTiBh`l0aX@#;f@g+&OGoqFga_Tz
zMz)zASD~{vPZ<wCbrV7z!r7BSxE*M65|l!0cHOAp7wdw1ml6M(e+@UPe;zj)Iy*kd
zi-j2J{hT4*RYNeyQ;~n}dZ}O_4!Ix*ZZLV-yjG<U1Qly=mrAmnj&{5O68-U_dH*v7
zEvxCQKK_yw!hGqV!1xze%na>;CMu5h<~HwtQ6}OYz-EaBV;Oso5Vm|#oJ@(ys5u6M
z!v0l_6hWuFnm9JcB^oNKbYL!gLCI=1_o1{%uQ;k=+yQ0q`RXvf*W^^0**Nle5Ph<t
zJ%KS~Tv6CiFyh*Z9?=L3Thd?{myAeIX6O3U!(;O_PPk4P2X1+pwV-6IAt$Uwlq$mH
z(K0<_p%dT{C0PxkOcu#N9G%k66Af;VQbN{g($rO;r!fAZ$lnM?c85m+X-p-RxyXm3
z$_?-K@-;mt>}n`V+k9OI!@E5hTy&cZO@Jn&kk&hk+HCw)+k1klwzLYYLLTjG%X#~J
zMKtQn@!&W%ud#)`4CL_^xXxOq_~@%gnU$@GHZB1%{;g#TI^FTseUWv3$S^&vcT0Cg
zInk}A6{HWhm-v{RpbqWy2rbHZ9K!5&6{IRMN4IJn9fl9YV=I*S%GjIm17B4WN8v%*
zOu;L6<mAVNuPNM#Dfeu25{4zpo|?%6hLK6-2#XXW(eUN3VKZD)kRQBh(bjBvdbnrN
z1V4K;9OqTOEjB^6F7@mgA#Xay8(M19el`+m&BotiVe1IL$4N#us0O#fGqQX_ALq8K
z*Yi9PH;~;G;C-ibPj%Y=!SWX2A5Y6t$;{~0mp4o=^?8&(Jiyq{%2?FQ(A?(dfoU=^
zWYNun61ee!^n}E8tv{!3A8JSw5`Lu~nPf}aYP?74a}9_%k0XD^3h~LBSYX5Jc{}|k
zH(?itW4#VSxU<*pH8m3PNkzQ^i9M?!2NU$<sT}TA_fCF&??Si94#{_se!P6;By8I1
z^#0VANQA(<Eu47nyw&{pVE`HXPH3Skwd&kaZUqF(g&GAC$c1Fb0&Igx-EHK$-3<xZ
zdcJn!3(_Tq;M75{1Ab-3!!x}GrJPc!&d31^8xtEd8w(pN8yj1-k!jCxSTZI%z3J0=
ztj_a=?LS@-bJxg2RbJR&_p%qLF9jJBkg=jY$ku_`7-SFpxfw4V3;(Obyf{ffoRWe+
z3r66Y+yip%$#~cDGM>Qzhldh6IxF5<%2gDqIjMExQTy!<adk(~C&sfcZ+E@k?&hD_
zQv*)WYiQ{bvsg&_A$sVQ3i*Y{78Wzf$29UG>FJ^17X5{XE`E^haBe3CN$SpIS%ddF
zPylHv&}(Yz@^SFnpax{u2?j$`WdNotO1llF59!-J<RYdTen3CXAnh!DWHCn}cma|F
zWL;;lPSykxVNL&TlCSN02wExC5b138gI&j#bNeVR!&oiYFxR6P{$I>fvXUKHb)Hb#
z1(pS!R3AlZo4@%?YS<2PvS{x+LcRI8rVoT$JU`Yz-He@Qsxs*nXh;Xaqm(@2J{R?!
zHNSZzC*jAAxpImc9NOC9($3)^n@Ci^5=b`LN|E2?NNcS{eHyO!y+?3^{Xxtc@n9Pp
z$o_^hL5%zxYE19VR($S1mvvCr-NEBuJdyTA$DsVx6Af)`|L2G=9{8`37AFT<`q|b6
zaYc-{g3r66i0E7TS&I9j(h&Sx-Fwx1<LoMmkkZ(TIfbf;ubLj;BZ-;y1js1MuUi?R
zL(E!A=IxcLUZq_{+BJu*%(XLlRlbsLl+ZlMGJ+9uW^DIDP2GbKWAhQOveoz!MN`Tn
zxguO)8@tHlq($r@P8-R0yfkapaCw&pBl%FpP{DHurvot}&VyGqV8=QBUJk#4omgNx
zIL0Th@GY%&Dv=584J|4+sYVWF-rSI&gk*GE-nU&ne@xF+j8J!kJ4(DaCedzmby}Jl
z1-@0PSi+|&!ppvcL(4SiN@2cg5N1EV2%V?Qx($R;2gb0{a}}B;<OHMwRoHsDNW^dV
zHrbuQ0{o~u-w|{-IuoUy*z>|G+cFJ9qf1$&k<SJ(tgkuekbMwpNkflDL_Z0r9`T$S
z=3Tql;@B5FsXg(x51!_cXpi*hy;r=~7C)^UJ^wuKOeYf0WUF)ih2(gWDrbc1K)#WX
z1C(+d>G=@6zdN)&^Z7w7zj@TcFY~G4;U%~Bhrj@T#rPs7{<%r>-+$b{pa0OZsR;PH
zfxmZ<{Tul6nft<yzx0#+4*b2V=1=Ir%klqPkInDkzZd8Kgo1&!!~X*RKc)KL?fhP#
z{nHY}%jM+%E7$&R<@e;}pH>*L{xOyLyMf;?MSmK=BKl?E&nwdJ(BC!UpHLCfKcK%W
z#@{Xct}*_!AV&Vn!rv6f@94ir<v+1tV2UqA@BfI=zr+82l>QaINc9)^zYbPK0Mv_b
S{A^W30Bd`Z0XeikfBhdpc_kD8

literal 0
HcmV?d00001


From 6d30ad74509aa7422a05e19d494f307b6a54b51f Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 17:30:51 +0100
Subject: [PATCH 025/125] add ibrd based premium calculation

---
 .../engine/cat_bonds/premium_class.py         | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/climada_petals/engine/cat_bonds/premium_class.py b/climada_petals/engine/cat_bonds/premium_class.py
index 441dc5bfc..a704b0ae1 100644
--- a/climada_petals/engine/cat_bonds/premium_class.py
+++ b/climada_petals/engine/cat_bonds/premium_class.py
@@ -1,7 +1,14 @@
 import pandas as pd
 import numpy as np
+from pathlib import Path
+from scipy.optimize import curve_fit
+
 import logging
 
+# path to data folder
+DATA_DIR = (Path(__file__).parent.parent).joinpath('data/cat_bonds')
+
+# setup logger 
 LOGGER = logging.getLogger(__name__)
 
 # regression coefficients for chatoro premium calculation (extracted from Chatoro et al., 2022)
@@ -19,6 +26,7 @@ class premium_calculations:
     def __init__(self, bond_simulation_class):
         self.bond_simulation_class = bond_simulation_class
 
+    ### CHATORO-PRICING ###
     def 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'''
 
@@ -33,3 +41,43 @@ def chatoro_premium(self, peak_multi, investment_graded, hybrid_trigger, GCIndex
 
         self.chatoro_prem_rate = b_0 + b_1 * self.bond_simulation_class.loss_metrics['EL_ann'] + 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
 
+
+    ### 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 init_prem_ibrd(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']

From fc3edc8800b867eee5bb35ab0867aa4fbcfd99af Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 17:41:17 +0100
Subject: [PATCH 026/125] improve logging and fix bug chatoro

---
 climada_petals/engine/cat_bonds/premium_class.py | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/premium_class.py b/climada_petals/engine/cat_bonds/premium_class.py
index a704b0ae1..8be9f3792 100644
--- a/climada_petals/engine/cat_bonds/premium_class.py
+++ b/climada_petals/engine/cat_bonds/premium_class.py
@@ -27,19 +27,25 @@ def __init__(self, bond_simulation_class):
         self.bond_simulation_class = bond_simulation_class
 
     ### CHATORO-PRICING ###
-    def chatoro_premium(self, peak_multi, investment_graded, hybrid_trigger, GCIndex=None, BBSpread=None):
+    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'] + 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
+        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 ###
@@ -47,7 +53,7 @@ def monoExp(self, x, a, k, b):
         '''Exponential function to fit the risk multiple curve'''
         return a * np.exp(-k * x) + b
 
-    def init_prem_ibrd(self, peril=None, year=None):
+    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,
@@ -81,3 +87,4 @@ def init_prem_ibrd(self, peril=None, year=None):
         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}")
\ No newline at end of file

From c7d1134400dd778c37376a44ebeb1821cdeb1880 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 18:00:04 +0100
Subject: [PATCH 027/125] fix path to data dir

---
 climada_petals/engine/cat_bonds/premium_class.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/climada_petals/engine/cat_bonds/premium_class.py b/climada_petals/engine/cat_bonds/premium_class.py
index 8be9f3792..4c3576a9c 100644
--- a/climada_petals/engine/cat_bonds/premium_class.py
+++ b/climada_petals/engine/cat_bonds/premium_class.py
@@ -6,7 +6,7 @@
 import logging
 
 # path to data folder
-DATA_DIR = (Path(__file__).parent.parent).joinpath('data/cat_bonds')
+DATA_DIR = (Path(__file__).parent.parent.parent).joinpath('data/cat_bonds')
 
 # setup logger 
 LOGGER = logging.getLogger(__name__)

From 6bf627ec20068732561b492edde184e9292fb480 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 18:00:29 +0100
Subject: [PATCH 028/125] remove premium input

---
 climada_petals/engine/cat_bonds/bond_simulation.py | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/bond_simulation.py b/climada_petals/engine/cat_bonds/bond_simulation.py
index ee048adab..5a8f42bf5 100644
--- a/climada_petals/engine/cat_bonds/bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/bond_simulation.py
@@ -6,8 +6,7 @@
 
 class bond_simulation:
 
-    def __init__(self, subarea_calc, term, number_terms, premium):
-        self.premium = premium # place holder till we have variable premiums
+    def __init__(self, subarea_calc, term, number_terms):
         self.term = term
         self.simulated_years = number_terms * term
         self.subarea_calc = subarea_calc
@@ -140,7 +139,7 @@ def init_loss_simulation(self):
 
 
     '''Simulate over all terms of bond to derive returns'''
-    def init_return_simulation(self):
+    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.
@@ -161,13 +160,13 @@ def init_return_simulation(self):
             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 * self.premium
+                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 * self.premium / 12 * months[0]
+                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)):
@@ -181,11 +180,11 @@ def init_return_simulation(self):
                         pass
                     if j + 1 < len(losses):
                         next_month = months[j+1]
-                        prem_tmp = ((cur_nominal * self.premium) / 12 * (next_month - month))
+                        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 * self.premium) / 12 * (12- month))
+                        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))

From c93b8622e185e9663d5670afe115f0ab88acc721 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 18:00:39 +0100
Subject: [PATCH 029/125] adjust test notebook to classes

---
 climada_petals/engine/cat_bonds/test.ipynb | 242 +++++++++++----------
 1 file changed, 123 insertions(+), 119 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/test.ipynb b/climada_petals/engine/cat_bonds/test.ipynb
index e315e8f78..a3ec1f089 100644
--- a/climada_petals/engine/cat_bonds/test.ipynb
+++ b/climada_petals/engine/cat_bonds/test.ipynb
@@ -13,6 +13,7 @@
     "from subareas import Subareas\n",
     "from subarea_calculations import Subarea_Calculations\n",
     "from bond_simulation import bond_simulation\n",
+    "from premium_class import premium_calculations\n",
     "\n",
     "from climada.hazard import TCTracks, Centroids, TropCyclone\n",
     "from climada.entity import LitPop\n",
@@ -74,9 +75,9 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-07 15:27:54,824 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
-      "2025-11-07 15:27:54,989 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
-      "2025-11-07 15:27:55,091 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n"
+      "2025-11-07 17:57:21,527 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
+      "2025-11-07 17:57:21,603 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
+      "2025-11-07 17:57:21,664 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n"
      ]
     },
     {
@@ -90,27 +91,27 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-07 15:28:03,073 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
-      "2025-11-07 15:28:03,338 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 546 coastal centroids.\n",
-      "2025-11-07 15:28:04,253 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
-      "2025-11-07 15:28:05,117 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
-      "2025-11-07 15:28:05,885 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
-      "2025-11-07 15:28:06,870 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
-      "2025-11-07 15:28:07,616 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
-      "2025-11-07 15:28:09,211 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
-      "2025-11-07 15:28:10,170 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
-      "2025-11-07 15:28:11,194 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
-      "2025-11-07 15:28:11,616 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
-      "2025-11-07 15:28:13,815 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      "2025-11-07 17:57:27,993 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
+      "2025-11-07 17:57:28,114 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 546 coastal centroids.\n",
+      "2025-11-07 17:57:28,488 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
+      "2025-11-07 17:57:28,777 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
+      "2025-11-07 17:57:29,079 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
+      "2025-11-07 17:57:29,399 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
+      "2025-11-07 17:57:29,697 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
+      "2025-11-07 17:57:30,708 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
+      "2025-11-07 17:57:31,197 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
+      "2025-11-07 17:57:31,524 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
+      "2025-11-07 17:57:31,718 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
+      "2025-11-07 17:57:32,830 - climada.entity.exposures.litpop.litpop - INFO - \n",
       " LitPop: Init Exposure for country: KNA (659)...\n",
       "\n",
-      "2025-11-07 15:28:13,913 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-07 15:28:14,598 - climada.util.finance - INFO - GDP KNA 2020: 8.839e+08.\n",
-      "2025-11-07 15:28:14,736 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
-      "2025-11-07 15:28:14,738 - climada.entity.exposures.base - INFO - category_id not set.\n",
-      "2025-11-07 15:28:14,740 - climada.entity.exposures.base - INFO - cover not set.\n",
-      "2025-11-07 15:28:14,741 - climada.entity.exposures.base - INFO - deductible not set.\n",
-      "2025-11-07 15:28:14,747 - climada.entity.exposures.base - INFO - centr_ not set.\n"
+      "2025-11-07 17:57:32,997 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-07 17:57:33,867 - climada.util.finance - INFO - GDP KNA 2020: 8.839e+08.\n",
+      "2025-11-07 17:57:33,885 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+      "2025-11-07 17:57:33,886 - climada.entity.exposures.base - INFO - category_id not set.\n",
+      "2025-11-07 17:57:33,886 - climada.entity.exposures.base - INFO - cover not set.\n",
+      "2025-11-07 17:57:33,887 - climada.entity.exposures.base - INFO - deductible not set.\n",
+      "2025-11-07 17:57:33,887 - climada.entity.exposures.base - INFO - centr_ not set.\n"
      ]
     }
    ],
@@ -162,7 +163,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-07 15:28:15,506 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+      "2025-11-07 17:57:34,382 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
      ]
     },
     {
@@ -199,9 +200,9 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-07 15:28:39,012 - climada.entity.exposures.base - INFO - Matching 328 exposures with 546 centroids.\n",
-      "2025-11-07 15:28:39,017 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
-      "2025-11-07 15:28:39,033 - climada.engine.impact_calc - INFO - Calculating impact for 984 assets (>0) and 51 events.\n"
+      "2025-11-07 17:57:49,939 - climada.entity.exposures.base - INFO - Matching 328 exposures with 546 centroids.\n",
+      "2025-11-07 17:57:49,952 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
+      "2025-11-07 17:57:49,969 - climada.engine.impact_calc - INFO - Calculating impact for 984 assets (>0) and 51 events.\n"
      ]
     }
    ],
@@ -220,102 +221,102 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "id": "4ead6e69",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'annual_premiums': array([2.83731021e-02, 8.73102078e-04, 1.66533454e-18, 2.50000000e-03,\n",
-       "        0.00000000e+00, 0.00000000e+00, 2.50000000e-03, 0.00000000e+00,\n",
-       "        0.00000000e+00, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02, 3.00000000e-02,\n",
-       "        3.00000000e-02, 3.00000000e-02, 3.00000000e-02]),\n",
-       " 'annual_returns': array([-6.22386067e-01, -3.48367729e-01,  1.66533454e-18, -9.97500000e-01,\n",
-       "         0.00000000e+00,  0.00000000e+00, -9.97500000e-01,  0.00000000e+00,\n",
-       "         0.00000000e+00,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02,  3.00000000e-02,\n",
-       "         3.00000000e-02,  3.00000000e-02,  3.00000000e-02]),\n",
-       " 'total_returns': 837183157.1067066,\n",
-       " 'total_premiums': 2163066490.440039,\n",
-       " 'sharpe_ratio': 0.08943209491064437}"
+       "{'annual_premiums': array([8.06426380e-02, 2.48154941e-03, 4.73324946e-18, 7.10555351e-03,\n",
+       "        0.00000000e+00, 0.00000000e+00, 7.10555351e-03, 0.00000000e+00,\n",
+       "        0.00000000e+00, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
+       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02]),\n",
+       " 'annual_returns': array([-5.70116531e-01, -3.46759282e-01,  4.73324946e-18, -9.92894446e-01,\n",
+       "         0.00000000e+00,  0.00000000e+00, -9.92894446e-01,  0.00000000e+00,\n",
+       "         0.00000000e+00,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
+       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02]),\n",
+       " 'total_returns': 4822030543.007947,\n",
+       " 'total_premiums': 6147913876.34128,\n",
+       " 'sharpe_ratio': 0.49006333355542275}"
       ]
      },
      "metadata": {},
@@ -339,10 +340,13 @@
     }
    ],
    "source": [
-    "st_kitts_bond_sim = bond_simulation(st_kitts_sub_calc, term, 20, 0.03) \n",
+    "st_kitts_bond_sim = bond_simulation(st_kitts_sub_calc, term, 20) \n",
     "st_kitts_bond_sim.init_loss_simulation()\n",
-    "st_kitts_bond_sim.init_return_simulation()\n",
-    "display(st_kitts_bond_sim.return_metrics)\n",
+    "st_kitts_premiums = premium_calculations(st_kitts_bond_sim)\n",
+    "st_kitts_premiums.calc_chatoro_premium(peak_multi=0, investment_graded=0, hybrid_trigger=0)\n",
+    "st_kitts_premiums.calc_ibrd_premium()\n",
+    "st_kitts_bond_sim.init_return_simulation(st_kitts_premiums.chatoro_prem_rate)\n",
+    "display(st_kitts_bond_sim.rdeturn_metrics)\n",
     "display(st_kitts_bond_sim.loss_metrics)"
    ]
   }

From b820b8cad39bd8f9db570c4dac23ab55268b1270 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 18:10:43 +0100
Subject: [PATCH 030/125] add benchmark premium calculation

---
 .../engine/cat_bonds/premium_class.py         | 78 ++++++++++++++++++-
 1 file changed, 76 insertions(+), 2 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/premium_class.py b/climada_petals/engine/cat_bonds/premium_class.py
index 4c3576a9c..ea908f85c 100644
--- a/climada_petals/engine/cat_bonds/premium_class.py
+++ b/climada_petals/engine/cat_bonds/premium_class.py
@@ -1,7 +1,7 @@
 import pandas as pd
 import numpy as np
 from pathlib import Path
-from scipy.optimize import curve_fit
+from scipy.optimize import curve_fit, minimize
 
 import logging
 
@@ -87,4 +87,78 @@ def calc_ibrd_premium(self, peril=None, year=None):
         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}")
\ No newline at end of file
+        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, ann_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.
+            ann_losses (pd.DataFrame): DataFrame containing annual loss events, 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(ann_losses)):
+            losses = ann_losses['losses'].iloc[i]
+            months = ann_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]
+

From ce9952ca2a3207594abfe293b9995b0b6e73f6d4 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 18:13:45 +0100
Subject: [PATCH 031/125] include all premium methods in test notebook

---
 climada_petals/engine/cat_bonds/test.ipynb | 25 +++++++++++++++++++++-
 1 file changed, 24 insertions(+), 1 deletion(-)

diff --git a/climada_petals/engine/cat_bonds/test.ipynb b/climada_petals/engine/cat_bonds/test.ipynb
index a3ec1f089..882cc5f7c 100644
--- a/climada_petals/engine/cat_bonds/test.ipynb
+++ b/climada_petals/engine/cat_bonds/test.ipynb
@@ -345,10 +345,33 @@
     "st_kitts_premiums = premium_calculations(st_kitts_bond_sim)\n",
     "st_kitts_premiums.calc_chatoro_premium(peak_multi=0, investment_graded=0, hybrid_trigger=0)\n",
     "st_kitts_premiums.calc_ibrd_premium()\n",
+    "st_kitts_premiums.calc_benchmark_premium(0.5)\n",
     "st_kitts_bond_sim.init_return_simulation(st_kitts_premiums.chatoro_prem_rate)\n",
-    "display(st_kitts_bond_sim.rdeturn_metrics)\n",
+    "display(st_kitts_bond_sim.return_metrics)\n",
     "display(st_kitts_bond_sim.loss_metrics)"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "6cfb9d55",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Benchmark Sharpe Ratio premium rate: 8.7\n",
+      "Chatoro premium rate: 8.5\n",
+      "IBRD premium rate: 5.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "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)}\")"
+   ]
   }
  ],
  "metadata": {

From 0d5fbcdd8f43a4c0bf23f4fdc25033470c767f17 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 18:23:51 +0100
Subject: [PATCH 032/125] remove buffer grid size

---
 climada_petals/engine/cat_bonds/subareas.py | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/subareas.py b/climada_petals/engine/cat_bonds/subareas.py
index 80e78eab3..6c0bc217e 100644
--- a/climada_petals/engine/cat_bonds/subareas.py
+++ b/climada_petals/engine/cat_bonds/subareas.py
@@ -33,8 +33,6 @@ class Subareas:
             Exposure object containing monetary data.
         resolution : float
             Resolution for grid cells to create subareas.
-        buffer_grid_size : int, optional
-            Size of the buffer around input country. Resulting geometry is used to derive subareas (in km; default is 5).
         crs : str, optional
             Coordinate reference system for spatial data (default: "EPSG:3857").
         subareas_gdf : geopandas.GeoDataFrame
@@ -50,14 +48,12 @@ def __init__(
         vulnerability,
         exposure,
         resolution,
-        buffer_grid_size=5.0,
     ):
 
         self.hazard = hazard
         self.vulnerability = vulnerability
         self._exposure = exposure
         self._resolution = resolution
-        self._buffer_grid_size = buffer_grid_size
         self._build_subareas()
 
     def _build_subareas(self):
@@ -73,10 +69,6 @@ def exposure(self):
     def resolution(self):
         return self._resolution
 
-    @property
-    def buffer_grid_size(self):
-        return self._buffer_grid_size
-
     def plot(self):
         if self.subareas_gdf is None:
             raise ValueError("Subareas have not been generated yet.")

From 82d185d09a01e3e6d062a8ea4befc6b03f2a38a6 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 18:26:04 +0100
Subject: [PATCH 033/125] define variables

---
 climada_petals/engine/cat_bonds/test.ipynb | 40 +++++++++++-----------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/test.ipynb b/climada_petals/engine/cat_bonds/test.ipynb
index 882cc5f7c..85ddea2eb 100644
--- a/climada_petals/engine/cat_bonds/test.ipynb
+++ b/climada_petals/engine/cat_bonds/test.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "48c2d418",
    "metadata": {},
    "outputs": [],
@@ -18,8 +18,7 @@
     "from climada.hazard import TCTracks, Centroids, TropCyclone\n",
     "from climada.entity import LitPop\n",
     "from climada.entity import ImpfSetTropCyclone\n",
-    "import numpy as np\n",
-    "\n"
+    "import numpy as np"
    ]
   },
   {
@@ -32,7 +31,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "89b53a88",
    "metadata": {},
    "outputs": [],
@@ -41,20 +40,21 @@
     "country = 659  # St. Kitts and Nevis\n",
     "exhaustion_point = 0.5 # 50% of exposure\n",
     "attachment_point = 0.05 # 5% of exposure\n",
-    "exhaustion_point_method = 'Exposure_Share' # 50% of exposure\n",
-    "attachment_point_method = 'Exposure_Share' # 5% of exposure\n",
-    "term = 3  # years\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",
-    "grid_specs=[1,2] # 3x3 grid\n",
-    "buffer_grid_size=0.5 # km of buffer around exposure\n",
-    "min_pol_size=100 # minimum subarea size in m² \n",
+    "resolution = 0.05 # resolution used to derive subareas\n",
     "\n",
     "### Pricing Basics ###\n",
-    "peak_peril = 0 # indicator if its considered peak peril (1) or not (0)\n",
-    "target_sharpe = 0.5 # target Sharpe ratio\n",
-    "risk_free_rate = 0.0  # risk free rate for Sharpe ratio and return calculation"
+    "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"
    ]
   },
   {
@@ -155,7 +155,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "id": "09fba021",
    "metadata": {},
    "outputs": [
@@ -178,7 +178,7 @@
     }
    ],
    "source": [
-    "st_kitts_subareas = Subareas(tc_irma, impfset, exp, resolution=0.05, buffer_grid_size=buffer_grid_size)\n",
+    "st_kitts_subareas = Subareas(tc_irma, impfset, exp, resolution=resolution)\n",
     "st_kitts_subareas.plot()"
    ]
   },
@@ -340,13 +340,13 @@
     }
    ],
    "source": [
-    "st_kitts_bond_sim = bond_simulation(st_kitts_sub_calc, term, 20) \n",
+    "st_kitts_bond_sim = bond_simulation(subarea_calc=st_kitts_sub_calc, term=term, number_terms=num_of_terms) \n",
     "st_kitts_bond_sim.init_loss_simulation()\n",
-    "st_kitts_premiums = premium_calculations(st_kitts_bond_sim)\n",
-    "st_kitts_premiums.calc_chatoro_premium(peak_multi=0, investment_graded=0, hybrid_trigger=0)\n",
+    "st_kitts_premiums = premium_calculations(bond_simulation_class=st_kitts_bond_sim)\n",
+    "st_kitts_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)\n",
     "st_kitts_premiums.calc_ibrd_premium()\n",
-    "st_kitts_premiums.calc_benchmark_premium(0.5)\n",
-    "st_kitts_bond_sim.init_return_simulation(st_kitts_premiums.chatoro_prem_rate)\n",
+    "st_kitts_premiums.calc_benchmark_premium(target_sharpe = target_sharpe)\n",
+    "st_kitts_bond_sim.init_return_simulation(premium=st_kitts_premiums.chatoro_prem_rate)\n",
     "display(st_kitts_bond_sim.return_metrics)\n",
     "display(st_kitts_bond_sim.loss_metrics)"
    ]

From d6a494c604edc8470cc60d5171ccc66650708f3c Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 18:52:46 +0100
Subject: [PATCH 034/125] rename bond_simulation to sng_bond_simulation

---
 .../{bond_simulation.py => sng_bond_simulation.py}          | 6 +++---
 climada_petals/engine/cat_bonds/test.ipynb                  | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)
 rename climada_petals/engine/cat_bonds/{bond_simulation.py => sng_bond_simulation.py} (98%)

diff --git a/climada_petals/engine/cat_bonds/bond_simulation.py b/climada_petals/engine/cat_bonds/sng_bond_simulation.py
similarity index 98%
rename from climada_petals/engine/cat_bonds/bond_simulation.py
rename to climada_petals/engine/cat_bonds/sng_bond_simulation.py
index 5a8f42bf5..1984c1294 100644
--- a/climada_petals/engine/cat_bonds/bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/sng_bond_simulation.py
@@ -4,11 +4,11 @@
 
 LOGGER = logging.getLogger(__name__)
 
-class bond_simulation:
+class sng_bond_simulation:
 
-    def __init__(self, subarea_calc, term, number_terms):
+    def __init__(self, subarea_calc, term, number_of_terms):
         self.term = term
-        self.simulated_years = number_terms * term
+        self.simulated_years = number_of_terms * term
         self.subarea_calc = subarea_calc
 
 
diff --git a/climada_petals/engine/cat_bonds/test.ipynb b/climada_petals/engine/cat_bonds/test.ipynb
index 85ddea2eb..cb2c0c057 100644
--- a/climada_petals/engine/cat_bonds/test.ipynb
+++ b/climada_petals/engine/cat_bonds/test.ipynb
@@ -12,7 +12,7 @@
     "\n",
     "from subareas import Subareas\n",
     "from subarea_calculations import Subarea_Calculations\n",
-    "from bond_simulation import bond_simulation\n",
+    "from sng_bond_simulation import sng_bond_simulation\n",
     "from premium_class import premium_calculations\n",
     "\n",
     "from climada.hazard import TCTracks, Centroids, TropCyclone\n",
@@ -340,7 +340,7 @@
     }
    ],
    "source": [
-    "st_kitts_bond_sim = bond_simulation(subarea_calc=st_kitts_sub_calc, term=term, number_terms=num_of_terms) \n",
+    "st_kitts_bond_sim = bond_simulation(subarea_calc=st_kitts_sub_calc, term=term, number_of_terms=num_of_terms) \n",
     "st_kitts_bond_sim.init_loss_simulation()\n",
     "st_kitts_premiums = premium_calculations(bond_simulation_class=st_kitts_bond_sim)\n",
     "st_kitts_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)\n",

From 7322e0251d87b0fae7cf533cff15bac3e3e5db3f Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 19:43:16 +0100
Subject: [PATCH 035/125] initialize multi country bond simulation

---
 .../engine/cat_bonds/mlt_bond_simulation.py   | 240 ++++++++++++++++++
 1 file changed, 240 insertions(+)
 create mode 100644 climada_petals/engine/cat_bonds/mlt_bond_simulation.py

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..cf77a4c67
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
@@ -0,0 +1,240 @@
+import pandas as pd
+import numpy as np
+import logging
+
+from utils_cat_bonds import multi_level_es
+
+LOGGER = logging.getLogger(__name__)
+
+class mlt_bond_simulation:
+
+    def __init__(self, subarea_calc_list, countries_list, term, number_of_terms, tranches):
+        self.countries = countries_list
+        self.term = term
+        self.simulated_years = number_of_terms * term
+        self.tranches = tranches
+        self.subarea_calc = subarea_calc_list
+
+
+
+    def _prepare_data(self):
+        self.pay_vs_dam_dic = {}
+        self.principal_dic_cty = {}
+        for idx, cty in enumerate(self.countries):
+            self.pay_vs_dam_dic[cty] = self.subarea_calc[idx].pay_vs_dam
+            self.principal_dic_cty[cty] = self.subarea_calc[idx].principal
+
+        
+
+
+
+    '''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() 
+        tot_damage = []
+        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):
+            cty_losses_event = {country: [] for country in self.countries}
+            cty_damages_event = {country: [] for country in self.countries}
+            sum_payouts = np.zeros(len(events_per_year[k]))
+
+            if not events_per_year[k].empty:
+                events = events_per_year[k].sort_values(by='month')
+                months = events['month'].to_numpy()
+                cties = events['country_code'].to_numpy()
+                pay = events['pay'].to_numpy()
+                dam = events['damage'].to_numpy()
+
+                sum_payouts = np.zeros(len(events))  
+                sum_damages = np.zeros(len(events)) 
+                for o in range(len(events)):
+                    payout = pay[o]
+                    cty = cties[o]
+                    damage = dam[o]
+
+                    if payout == 0 or cur_nominal == 0 or cur_nom_cty[int(cty)] == 0:
+                        event_payout = 0
+                    else:
+                        event_payout = payout
+                        cur_nom_cty[int(cty)] -= event_payout
+                        if cur_nom_cty[int(cty)] < 0:
+                            event_payout += cur_nom_cty[int(cty)]
+                            cur_nom_cty[int(cty)] = 0
+                        cur_nominal -= event_payout
+                        if cur_nominal < 0:
+                            event_payout += cur_nominal
+                            cur_nominal = 0
+
+                    sum_payouts[o] = event_payout
+                    sum_damages[o] = damage
+                    cty_losses_event[cty].append(event_payout)
+                    cty_damages_event[cty].append(damage)
+                losses = np.sum(sum_payouts)
+                damages = np.sum(sum_damages)
+                for cty, cty_loss in cty_losses_event.items():
+                    rel_ann_cty_losses[cty][k] = np.sum(cty_loss)
+                    coverage_cty[cty]['payout'] += sum(cty_losses_event[cty])
+                    coverage_cty[cty]['damage'] += sum(cty_damages_event[cty])
+            else:
+                losses = 0
+                damages = 0
+                months = []
+
+            ann_loss[k] = losses
+            tot_damage.append(damages)
+            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)
+        for key in rel_ann_cty_losses.keys():
+            rel_ann_cty_losses[key] = rel_ann_cty_losses[key] / principal 
+        rel_bond_monthly_losses['losses'] = rel_bond_monthly_losses['losses'].values / principal
+        coverage_tot = {'payout': np.sum(ann_loss), 'damage': np.sum(tot_damage)}
+        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.
+
+        """
+
+        self._prepare_data()
+
+        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': [], 'damage': [], 'coverage': [], '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'] == (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'].append(coverage_cty[key]['payout'])
+                self.tot_coverage_cty[key]['damage'].append(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)
+
+        risk_metrics_annual = multi_level_es(annual_losses, confidence_levels)
+
+        for key in self.tot_coverage_cty.keys():
+            self.tot_coverage_cty[key]['payout'] = sum(self.tot_coverage_cty[key]['payout'])
+            self.tot_coverage_cty[key]['damage'] = sum(self.tot_coverage_cty[key]['damage'])
+            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])
+
+        for key in self.tot_coverage_cty:
+            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'], 
+                             'VaR_99_ann': risk_metrics_annual[0.99]['VaR'], 
+                             'VaR_95_ann': risk_metrics_annual[0.95]['VaR'], 
+                             'ES_99_ann': risk_metrics_annual[0.99]['ES'], 
+                             'ES_95_ann': risk_metrics_annual[0.95]['ES']}
+
+        LOGGER.info(f'Expected Loss = {exp_loss_ann}')
+        LOGGER.info(f'Attachment Probability = {att_prob_ann}')
+
+
+  
\ No newline at end of file

From d6250ff8761f52368bf66916cb8b662b612262c2 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 7 Nov 2025 19:43:29 +0100
Subject: [PATCH 036/125] add function to derive VaR and ES

---
 .../engine/cat_bonds/utils_cat_bonds.py       | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 climada_petals/engine/cat_bonds/utils_cat_bonds.py

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..5da8beb89
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/utils_cat_bonds.py
@@ -0,0 +1,29 @@
+
+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:
+    - risk_metrics: dict, VaR and ES values keyed by confidence level
+    """
+    # Convert losses to a NumPy array
+    losses = np.array(losses)
+    # Sort losses once
+    sorted_losses = np.sort(losses)
+    n = len(sorted_losses)
+    risk_metrics = {}
+    for cl in confidence_levels:
+        # Calculate index for VaR
+        var_index = int(np.ceil(n * cl)) - 1
+        var = sorted_losses[var_index]
+        # Calculate ES
+        tail_losses = sorted_losses[var_index + 1:]
+        es = tail_losses.mean() if len(tail_losses) > 0 else var
+        # Store metrics
+        risk_metrics[cl] = {'VaR': var, 'ES': es}
+    return risk_metrics
\ No newline at end of file

From ac4c31787161d6f63ae224f26747862f57da83d9 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Sun, 9 Nov 2025 19:40:11 +0100
Subject: [PATCH 037/125] add jamaica bond

---
 climada_petals/engine/cat_bonds/test.ipynb | 182 +++++++++++++++------
 1 file changed, 130 insertions(+), 52 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/test.ipynb b/climada_petals/engine/cat_bonds/test.ipynb
index cb2c0c057..dcea0617a 100644
--- a/climada_petals/engine/cat_bonds/test.ipynb
+++ b/climada_petals/engine/cat_bonds/test.ipynb
@@ -31,13 +31,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 14,
    "id": "89b53a88",
    "metadata": {},
    "outputs": [],
    "source": [
     "### Bond Basics ###\n",
-    "country = 659  # St. Kitts and Nevis\n",
+    "countries = [659, 388]  # St. Kitts and Nevis\n",
     "exhaustion_point = 0.5 # 50% of exposure\n",
     "attachment_point = 0.05 # 5% of exposure\n",
     "exhaustion_point_method = 'Exposure_Share' # could also be \"Return_Period\" or None\n",
@@ -67,7 +67,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 16,
    "id": "a51eb038",
    "metadata": {},
    "outputs": [
@@ -75,47 +75,35 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-07 17:57:21,527 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
-      "2025-11-07 17:57:21,603 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
-      "2025-11-07 17:57:21,664 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "<string>:7: FutureWarning: 'H' is deprecated and will be removed in a future version. Please use 'h' instead of 'H'.\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "2025-11-07 17:57:27,993 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
-      "2025-11-07 17:57:28,114 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 546 coastal centroids.\n",
-      "2025-11-07 17:57:28,488 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
-      "2025-11-07 17:57:28,777 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
-      "2025-11-07 17:57:29,079 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
-      "2025-11-07 17:57:29,399 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
-      "2025-11-07 17:57:29,697 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
-      "2025-11-07 17:57:30,708 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
-      "2025-11-07 17:57:31,197 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
-      "2025-11-07 17:57:31,524 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
-      "2025-11-07 17:57:31,718 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
-      "2025-11-07 17:57:32,830 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      "2025-11-09 19:34:32,604 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
+      "2025-11-09 19:34:32,914 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
+      "2025-11-09 19:34:33,042 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
+      "2025-11-09 19:34:36,593 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
+      "2025-11-09 19:34:36,625 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 546 coastal centroids.\n",
+      "2025-11-09 19:34:36,958 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
+      "2025-11-09 19:34:37,241 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
+      "2025-11-09 19:34:37,538 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
+      "2025-11-09 19:34:37,859 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
+      "2025-11-09 19:34:38,164 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
+      "2025-11-09 19:34:38,661 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
+      "2025-11-09 19:34:39,027 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
+      "2025-11-09 19:34:39,352 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
+      "2025-11-09 19:34:39,547 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
+      "2025-11-09 19:34:40,701 - climada.entity.exposures.litpop.litpop - INFO - \n",
       " LitPop: Init Exposure for country: KNA (659)...\n",
       "\n",
-      "2025-11-07 17:57:32,997 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-07 17:57:33,867 - climada.util.finance - INFO - GDP KNA 2020: 8.839e+08.\n",
-      "2025-11-07 17:57:33,885 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
-      "2025-11-07 17:57:33,886 - climada.entity.exposures.base - INFO - category_id not set.\n",
-      "2025-11-07 17:57:33,886 - climada.entity.exposures.base - INFO - cover not set.\n",
-      "2025-11-07 17:57:33,887 - climada.entity.exposures.base - INFO - deductible not set.\n",
-      "2025-11-07 17:57:33,887 - climada.entity.exposures.base - INFO - centr_ not set.\n"
+      "2025-11-09 19:34:40,757 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-09 19:34:41,314 - climada.util.finance - INFO - GDP KNA 2020: 8.839e+08.\n",
+      "2025-11-09 19:34:41,332 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+      "2025-11-09 19:34:41,333 - climada.entity.exposures.base - INFO - category_id not set.\n",
+      "2025-11-09 19:34:41,334 - climada.entity.exposures.base - INFO - cover not set.\n",
+      "2025-11-09 19:34:41,336 - climada.entity.exposures.base - INFO - deductible not set.\n",
+      "2025-11-09 19:34:41,337 - 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",
@@ -128,13 +116,13 @@
     "tc_irma = TropCyclone.from_tracks(tr_irma, centroids=cent)\n",
     "\n",
     "\n",
-    "exp = LitPop.from_countries(\n",
-    "        [str(country)], fin_mode='gdp', reference_year=2020\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.gdf.loc[exp.gdf.region_id == country, 'impf_TC'] = 1\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([736576, 736596, 736649, 736659, 736668, 736681, 736701, 736702, 736715, 736726,\n",
@@ -145,6 +133,71 @@
     " 737098])"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "890bcd64",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-11-09 19:35:25,188 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
+      "2025-11-09 19:35:25,273 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
+      "2025-11-09 19:35:25,317 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
+      "2025-11-09 19:35:28,024 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
+      "2025-11-09 19:35:28,062 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 7938 coastal centroids.\n",
+      "2025-11-09 19:35:32,866 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
+      "2025-11-09 19:35:37,386 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
+      "2025-11-09 19:35:42,267 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
+      "2025-11-09 19:35:47,099 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
+      "2025-11-09 19:35:51,563 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
+      "2025-11-09 19:35:57,598 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
+      "2025-11-09 19:36:02,233 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
+      "2025-11-09 19:36:07,878 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
+      "2025-11-09 19:36:09,806 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
+      "2025-11-09 19:36:12,248 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      " LitPop: Init Exposure for country: JAM (388)...\n",
+      "\n",
+      "2025-11-09 19:36:13,023 - climada.util.finance - INFO - GDP JAM 2020: 1.381e+10.\n",
+      "2025-11-09 19:36:13,076 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+      "2025-11-09 19:36:13,076 - climada.entity.exposures.base - INFO - category_id not set.\n",
+      "2025-11-09 19:36:13,077 - climada.entity.exposures.base - INFO - cover not set.\n",
+      "2025-11-09 19:36:13,079 - climada.entity.exposures.base - INFO - deductible not set.\n",
+      "2025-11-09 19:36:13,080 - climada.entity.exposures.base - INFO - centr_ not set.\n"
+     ]
+    }
+   ],
+   "source": [
+    "tr_melissa = TCTracks.from_ibtracs_netcdf(\n",
+    "    provider=\"usa\", storm_id=\"2025291N11319\"\n",
+    ")  # IRMA 2017\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[0], 'impf_TC'] = 1\n",
+    "\n",
+    "# change dates of tc events to allow simulation of multiple years\n",
+    "tc_melissa.date = np.array([736476, 736796, 736849, 736259, 736368, 7366881, 736001, 736102, 736215, 736326,\n",
+    " 736327, 736631, 736843, 736053, 736362, 736381, 736387, 736903, 736108, 736221,\n",
+    " 736743, 736248, 736154, 736668, 736672, 736578, 736992, 736000, 736504, 736312,\n",
+    " 736821, 736126, 736540, 736945, 736252, 736963, 736936, 736083, 736993, 737903,\n",
+    " 737212, 737320, 737931, 737437, 737948, 737959, 737468, 737774, 737381, 737192,\n",
+    " 738098])"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "7a37023a",
@@ -163,22 +216,31 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-07 17:57:34,382 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+      "2025-11-09 19:39:08,588 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 900x1300 with 2 Axes>"
       ]
      },
      "metadata": {},
      "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-11-09 19:39:43,950 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+     ]
     }
    ],
    "source": [
-    "st_kitts_subareas = Subareas(tc_irma, impfset, exp, resolution=resolution)\n",
+    "st_kitts_subareas = Subareas(tc_irma, impfset, exp_kit, resolution=resolution)\n",
+    "jamaica_subareas = Subareas(tc_melissa, impfset, exp_jam, resolution=resolution)\n",
+    "jamaica_subareas.plot()\n",
     "st_kitts_subareas.plot()"
    ]
   },
@@ -192,7 +254,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "id": "ac344ab3",
    "metadata": {},
    "outputs": [
@@ -208,7 +270,9 @@
    ],
    "source": [
     "st_kitts_sub_calc = Subarea_Calculations(subareas=st_kitts_subareas, index_stat=par_index)\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)"
+    "jamaica_sub_calc = Subarea_Calculations(subareas=jamaica_subareas, index_stat=par_index)\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)\n",
+    "jamaica_sub_calc.create_pay_vs_dam(attachment_point, exhaustion_point, methods_attachment_point=attachment_point_method, methods_exhaustion_point=exhaustion_point_method)"
    ]
   },
   {
@@ -340,7 +404,8 @@
     }
    ],
    "source": [
-    "st_kitts_bond_sim = bond_simulation(subarea_calc=st_kitts_sub_calc, term=term, number_of_terms=num_of_terms) \n",
+    "### ST. KITTS AND NEVIS BOND SIMULATION ###\n",
+    "st_kitts_bond_sim = sng_bond_simulation(subarea_calc=st_kitts_sub_calc, term=term, number_of_terms=num_of_terms) \n",
     "st_kitts_bond_sim.init_loss_simulation()\n",
     "st_kitts_premiums = premium_calculations(bond_simulation_class=st_kitts_bond_sim)\n",
     "st_kitts_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)\n",
@@ -348,12 +413,15 @@
     "st_kitts_premiums.calc_benchmark_premium(target_sharpe = target_sharpe)\n",
     "st_kitts_bond_sim.init_return_simulation(premium=st_kitts_premiums.chatoro_prem_rate)\n",
     "display(st_kitts_bond_sim.return_metrics)\n",
-    "display(st_kitts_bond_sim.loss_metrics)"
+    "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": 12,
+   "execution_count": null,
    "id": "6cfb9d55",
    "metadata": {},
    "outputs": [
@@ -368,9 +436,19 @@
     }
    ],
    "source": [
-    "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)}\")"
+    "### JAMAICA BOND SIMULATION ###\n",
+    "jamaica_bond_sim = sng_bond_simulation(subarea_calc=jamaica_sub_calc, term=term, number_of_terms=num_of_terms) \n",
+    "jamaica_bond_sim.init_loss_simulation()\n",
+    "jamaica_premiums = premium_calculations(bond_simulation_class=jamaica_bond_sim)\n",
+    "jamaica_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)\n",
+    "jamaica_premiums.calc_ibrd_premium()\n",
+    "jamaica_premiums.calc_benchmark_premium(target_sharpe = target_sharpe)\n",
+    "jamaica_bond_sim.init_return_simulation(premium=jamaica_premiums.chatoro_prem_rate)\n",
+    "display(jamaica_bond_sim.return_metrics)\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)}\")"
    ]
   }
  ],

From c4d2d99e6069aa702ee7c5cda54315ee28e3341b Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Sun, 9 Nov 2025 19:48:38 +0100
Subject: [PATCH 038/125] fix bugs exp and haz jamaica

---
 climada_petals/engine/cat_bonds/test.ipynb | 332 ++++++++++++++++++---
 1 file changed, 289 insertions(+), 43 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/test.ipynb b/climada_petals/engine/cat_bonds/test.ipynb
index dcea0617a..f1bb10cae 100644
--- a/climada_petals/engine/cat_bonds/test.ipynb
+++ b/climada_petals/engine/cat_bonds/test.ipynb
@@ -2,10 +2,19 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 32,
    "id": "48c2d418",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The autoreload extension is already loaded. To reload it, use:\n",
+      "  %reload_ext autoreload\n"
+     ]
+    }
+   ],
    "source": [
     "%load_ext autoreload\n",
     "%autoreload 2\n",
@@ -31,7 +40,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 20,
    "id": "89b53a88",
    "metadata": {},
    "outputs": [],
@@ -47,7 +56,8 @@
     "par_index = 60 # statistic for parametric index (e.g. 60 for 60th percentile)\n",
     "\n",
     "### Subarea Basics ###\n",
-    "resolution = 0.05 # resolution used to derive subareas\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",
     "\n",
     "### Pricing Basics ###\n",
     "peak_peril = 0 # indicator if bond is considered peak peril (1) or not (0)\n",
@@ -135,7 +145,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "id": "890bcd64",
    "metadata": {},
    "outputs": [
@@ -143,29 +153,29 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-09 19:35:25,188 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
-      "2025-11-09 19:35:25,273 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
-      "2025-11-09 19:35:25,317 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
-      "2025-11-09 19:35:28,024 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
-      "2025-11-09 19:35:28,062 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 7938 coastal centroids.\n",
-      "2025-11-09 19:35:32,866 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
-      "2025-11-09 19:35:37,386 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
-      "2025-11-09 19:35:42,267 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
-      "2025-11-09 19:35:47,099 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
-      "2025-11-09 19:35:51,563 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
-      "2025-11-09 19:35:57,598 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
-      "2025-11-09 19:36:02,233 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
-      "2025-11-09 19:36:07,878 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
-      "2025-11-09 19:36:09,806 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
-      "2025-11-09 19:36:12,248 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      "2025-11-09 19:44:24,446 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
+      "2025-11-09 19:44:24,526 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
+      "2025-11-09 19:44:24,570 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
+      "2025-11-09 19:44:27,512 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
+      "2025-11-09 19:44:27,558 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 7938 coastal centroids.\n",
+      "2025-11-09 19:44:32,440 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
+      "2025-11-09 19:44:36,945 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
+      "2025-11-09 19:44:41,782 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
+      "2025-11-09 19:44:47,088 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
+      "2025-11-09 19:44:51,542 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
+      "2025-11-09 19:44:56,307 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
+      "2025-11-09 19:45:00,234 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
+      "2025-11-09 19:45:05,448 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
+      "2025-11-09 19:45:07,280 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
+      "2025-11-09 19:45:09,635 - climada.entity.exposures.litpop.litpop - INFO - \n",
       " LitPop: Init Exposure for country: JAM (388)...\n",
       "\n",
-      "2025-11-09 19:36:13,023 - climada.util.finance - INFO - GDP JAM 2020: 1.381e+10.\n",
-      "2025-11-09 19:36:13,076 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
-      "2025-11-09 19:36:13,076 - climada.entity.exposures.base - INFO - category_id not set.\n",
-      "2025-11-09 19:36:13,077 - climada.entity.exposures.base - INFO - cover not set.\n",
-      "2025-11-09 19:36:13,079 - climada.entity.exposures.base - INFO - deductible not set.\n",
-      "2025-11-09 19:36:13,080 - climada.entity.exposures.base - INFO - centr_ not set.\n"
+      "2025-11-09 19:45:11,613 - climada.util.finance - INFO - GDP JAM 2020: 1.381e+10.\n",
+      "2025-11-09 19:45:11,658 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+      "2025-11-09 19:45:11,659 - climada.entity.exposures.base - INFO - category_id not set.\n",
+      "2025-11-09 19:45:11,660 - climada.entity.exposures.base - INFO - cover not set.\n",
+      "2025-11-09 19:45:11,661 - climada.entity.exposures.base - INFO - deductible not set.\n",
+      "2025-11-09 19:45:11,663 - climada.entity.exposures.base - INFO - centr_ not set.\n"
      ]
     }
    ],
@@ -187,10 +197,10 @@
     "    )\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[0], 'impf_TC'] = 1\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([736476, 736796, 736849, 736259, 736368, 7366881, 736001, 736102, 736215, 736326,\n",
+    "tc_melissa.date = np.array([736476, 736796, 736849, 736259, 736368, 736681, 736001, 736102, 736215, 736326,\n",
     " 736327, 736631, 736843, 736053, 736362, 736381, 736387, 736903, 736108, 736221,\n",
     " 736743, 736248, 736154, 736668, 736672, 736578, 736992, 736000, 736504, 736312,\n",
     " 736821, 736126, 736540, 736945, 736252, 736963, 736936, 736083, 736993, 737903,\n",
@@ -208,7 +218,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 29,
    "id": "09fba021",
    "metadata": {},
    "outputs": [
@@ -216,12 +226,12 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-09 19:39:08,588 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+      "2025-11-09 19:46:53,396 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA5oAAAEoCAYAAAA5aI7cAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnXmcHEXd/99V3T3H3jnIHUh4AAERkHA/IOGIInIpBkV5EBVEQH74IPigQiCgXCqKPgoIanhA5FIkgvA8gHIa5FDu+0pIIHeym92do7urfn9Ud0/P7Gyy2d1kN1DvvDo7R3dVdVfPTH/6ewmttcZisVgsFovFYrFYLJZBQg71ACwWi8VisVgsFovF8v7CCk2LxWKxWCwWi8VisQwqVmhaLBaLxWKxWCwWi2VQsULTYrFYLBaLxWKxWCyDihWaFovFYrFYLBaLxWIZVKzQtFgsFovFYrFYLBbLoGKFpsVisVgsFovFYrFYBhUrNC0Wi8VisVgsFovFMqi4Qz0Ay/ChWCxSLpeHehgWi8VisVgslvUgk8mQy+U2Sl+byvXixjwmlvpYoWkBzJfG1KlTWbx48VAPxWKxWCwWi8WyHowbN4633nprgwurYrHI1C2aWLw03KD9DAYb65hYescKTQsA5XKZxYsX884779DS0jJk49Ba097eTmtrK0KIIRuHpT52foY/do6GN3Z+hjd2foY3dn7q09HRweTJkymXyxtcVJXLZRYvDXnrqS1oaR6+EXgdaxRTp83fKMfE0jtWaFqqaGlpGXKhqbWmpaXF/ogMQ+z8DH/sHA1v7PwMb+z8DG/s/AwfGpvMMlwJ9VCPwAJWaFosFovFYrFYLJb1QKFRDF81N5zH9kHCCk2LxWKxWCwWi8XSZ3wd4uvhK+Z8rYZ6CBas0LRYLBaLxWKxWCzrgbVoWvqCFZoWi8VisVgs72O01gRBQBgO/0yha0NrTblcplgsfqBiNB3HwXXdYbXPCk04jMWcFZrDAys0LRaLxWKxWN6nlMtl3nvvPbq7u4d6KIOCUooVK1YM9TA2Og0NDYwfP55MJjPUQwHenxbN6dOn8+CDD67XNn/729+YPn36em1z/vnnM3v27A3W/nDCCk2LxWKxWCyW9yFKKd566y0cx2HChAlkMplhZRVbX7TWhGGI4zib9H6sD7EVd9myZbz11ltsvfXWSDn0ZUVCrQmHcYzmxhiblJKtt956g/ezKWOFpsVisVgsFsv7kHK5jFKKyZMn09DQMNTDGTAfRKEJkM/n8TyP+fOHT11IFS3Dlf6M7be//S1dXV1rXefFF1/kc5/7HAAHHnggEydO7EdPFZ577rm1vj916tQBtT/UWKFpeX9y660waxasWTPUI3nf0aI1DPQHvlCAzk5oaoJ8fnAGZkkY8BzZ+dmg2M/Q8GZQ5geguRkuvBA++9mBtzVAhoMFzDIwhtschsM8RrM/Y+uLqLv++uuTx8cdd9x691HLDjvsMOA2hjNWaFren8yaBS+/PNSjeN8homXQWLlyMFuzMMhzZOdn0LGfoeHNoM/PuecOC6FpsQw2oTbLcGVDjE0pxe9+9zsAmpqa+MxnPjP4nbzPsELT8v4ktmRKCePHD+1Y3kdojOuSEGJgF2OLFlUeD9DtxFLNoMyRnZ8Nhv0MDW8GbX7eew+Usl41lvct70fX2XVx//33syj67v3sZz/7vnBH39BYoWl5fzN+PCxcONSjeP+gNR3t7bS2tg7MtcxxzEWYlHZ+BpvBmCM7PxsO+xka3gzW/EyaVH0zwDIkPPDAA+y///6sWrWKtra2oR7O+wqFIBxc+/+gojbA2P7nf/4neTwYbrMfBIaXw7fFYrFYLBaLxQIsXbqUk046ic0335xsNsv48eM55JBDmDdv3lAP7QOP0sN/GUw6Ozu5/fbbAdh8880HreTIjBkzGDVqFJlMhjFjxjB9+nQuueQSVq1aNSjtDzXWommxWCwWi8ViGXYcddRR+L7Pddddx5ZbbsnixYu57777WDnEscnlcnnY1LMcKsJhbtEc7LH94Q9/SDLS/sd//MegZT2+7777ksfLli3jwQcf5MEHH+TSSy9lzpw5HHHEEYPSz1BhLZoWi8VisVgslmHF6tWreeSRR7j00kvZf//92WKLLdh99935r//6Lz71qU/x9ttvI4Tg6aefrtpGCMEDDzxQ1dajjz7KTjvtRC6XY4899qgqKbFixQqOOeYYJk2aRENDAx/5yEf4/e9/X7X99OnT+cY3vsEZZ5zB6NGjmTFjBmBKXRxyyCE0NTUxduxY/uM//oPly5cn291zzz3ss88+tLW1MWrUKA499FDeeOON5P1yucw3vvENxo8fTy6XY8qUKVx88cWDeBQ3HLHQHM4LQEdHR9VSKpX6tb+D7Tb7kY98hHPPPZc///nPPPXUUzz22GNcd911fPzjHwfMuXzUUUdx9913D7ivoWRIheaSJUuYO3cu3/ve9zjooINobW01AfhCcP75569XW/Pnz+fss89m2rRptLW14XkeI0eOZO+99+bCCy9k2bJlgzr2VatW8eMf/5h9992XcePGkc1mmTBhArvvvjtnnnnmOt06brjhBnbeeWdyuRyTJ0/mzDPPpKOjo9f1jz/++OTYCCG455571jnGeN3jjz9+fXfPYrFYLBbL+5VddzVxpBt72XXXPg+xqamJpqYm/vSnP/VbHMScddZZ/OhHP+KJJ55gzJgxHH744fi+D0CxWGTatGnceeedPP/883zta1/jP/7jP/jHP/5R1cZ1112H67o8+uijXH311bz33nvst99+7Lzzzjz55JPcc889LFmyhKOPPjrZpqurizPOOIMnnniC+++/Hykln/70p1HKpKr52c9+xty5c7nlllt45ZVXuOGGG5gyZcqA9nVjobQY9gvA5MmTaW1tTZb+CPmFCxcmNy/23HNPttlmmwEdu29+85s8++yzXHDBBRx66KHssssu7LHHHhx33HH87//+L1dddRUAYRhywgknUCgUBtTfUDKkrrPjxo0blHZuvPFGTjzxRLq7u6teX7VqFfPmzWPevHlcccUV3HLLLRxwwAED7m/u3Ll87WtfY8mSJVWvv/fee7z33ns88cQTvP766/zpT3+qu/0FF1zAeeedlzxfuHAhP/7xj/nrX//Kww8/TGNj4zrHMGvWLA4++OAB7YfFYrFYLJYPIIsXD/tkRa7rMmfOHE488USuuuoqdtllFz72sY8xc+ZMPvrRj65XW+edd15ihbzuuuuYNGkSt99+O0cffTQTJ07kzDPPTNY97bTTuOeee7j11lvZY489kte32morLrvssuT5rFmz2GWXXbjooouS137zm98wefJkXn31VbbZZhuOOuqoqnH8+te/ZsyYMbz44ovssMMOLFiwgK233pp99tkHIQRbbLHFeu3XULKpuM6+8847tLS0JK9ns9n1buuGG25Ibg586UtfGvDY1pWY6qSTTuLJJ5/k2muv5d133+WPf/wjX/ziFwfc71AwbGI0t9xySyZNmsRDDz20XtvNmzeP4447jjAMkVLypS99iSOOOIIJEyawYMECrrvuOv785z+zYsUKDj/8cJ5//vkB3S267bbbOOaYYwiCgFGjRnHyySfzsY99jFGjRrF48WLeeOMN7rzzTjzPq7v9iy++yOzZs8nlcokld8GCBcyaNYt//etfXHjhhVxyySXrHMcTTzzB3LlzOfzww/u9LxaLxWKxWD6ADNKN/g3d71FHHcWnPvUpHn74YebNm8c999zDD3/4Q6655hr233//Prez1157JY9HjhzJhz70IV566SXAWI0uueQSbr75ZhYtWkSpVKJUKvW46b9rjTX2qaee4m9/+xtNTU09+nvjjTfYZptteOONNzj33HN57LHHWL58eSJWFixYwA477MDxxx/PjBkz+NCHPsTBBx/MoYcemrhODndCJOEwjsALo78tLS1VQrM/XH/99YARqZ/73OcGOLK+cdJJJ3HttdcC8OCDD1qh2R9mzZrFHnvswR577MGoUaOSNNTrw0UXXUQYmtPp5z//Oaecckry3m677cZRRx3Ft771LS6//HK6urq4/PLL+dnPftav8b799tscf/zxBEHAbrvtxt13382oUaN6rHfaaaclLhm13HrrrSiluOyyyzjttNMAY4b/93//d7bZZhtuueWWdQrN0aNHs3z5cmbNmsVhhx02aAHJFovFYrFYPgA8+eRQj6DP5HI5ZsyYwYwZMzj33HP56le/yvnnn8+BBx4ImLqnMb1de9Ujvnb68Y9/zE9+8hN++tOf8pGPfITGxka++c1vUi6Xq9avFZ5KKQ477DAuvfTSHm2Pj+p3H3bYYUyePJlrrrmGCRMmoJRihx12SNreZZddeOutt7j77ru57777OProoznooIO47bbb+rwfQ0WgJb4evkIzGKSss08++SQvvvgiAIceeigjRowYnIbXwfbbb588XjTMvQ/WxpCeIbNnz+aQQw6pK9b6yqOPPgrAqFGjqkRmmlmzZiWP//73v/e7rzPOOIOuri5aWlr405/+tNZx92bRjE+WWkE9ceJEtt122z6dTN/+9rcBeOaZZ/jjH//Y1+FbLBaLxWKxbNJst912dHV1sdlmmwEmbCkmnRgozWOPPZY8XrVqFa+++irbbrstAA8//DBHHHEExx57LDvttBNbbrklr7322jrHscsuu/DCCy8wZcoUttpqq6qlsbGRFStW8NJLL3HOOedw4IEHst1229UtWdHS0sLnPvc5rrnmGm6++Wb+8Ic/DHlW3b4Qajnsl8EgnQRoMNxm+0r6BsqmzPC9FdFH4rtCU6dO7XWd1tZWRo8eDdDvgPKFCxcyd+5cAL72ta8xYcKEfrUzZswYwJjB0yxevJhXXnmlT3Grp556KmPHjgVM3EHsimGxWCwWi8XyfmDFihUccMAB3HDDDTz77LO89dZb3Hrrrfz4xz/m8MMPJ5/Ps+eee3LJJZfw4osv8tBDD3HOOefUbeuCCy7g/vvv5/nnn+f4449n9OjRHHnkkYCJvbz33nv5+9//zksvvcRJJ53E4sWL1zm+U089lZUrV3LMMcfw+OOP8+abb/J///d/fOUrXyEMQ0aMGMGoUaP41a9+xeuvv85f//pXzjjjjKo2fvKTn3DTTTfx8ssv8+qrr3Lrrbcybty4dcbwDQcUAoUcxsvAvf183+emm24CYLPNNuOTn/zkgNvsK7EVFei35hgObPJCc+uttwbgrbfe6nWdjo6OJN10fzNF/fGPf0xcdGfOnJm8vnr1al577bWqdNZrI/5iO+uss7j44ot57LHHuO222zjwwAPp6uqqars3GhoaOPvsswF44YUXuPnmm9dzbywWi8VisViGL01NTeyxxx785Cc/4WMf+xg77LADs2bN4qtf/Sr//d//DZjkO77vs+uuu3L66afz/e9/v25bl1xyCaeffjrTpk3jvffeY+7cuUkdzHPPPZdddtmFT3ziE0yfPp1x48Yl12prY8KECTz66KOEYcgnPvEJdthhB04//XRaW1uRUiKl5KabbuKpp55ihx124D//8z/54Q9/2GMfL730UnbddVd222033n77bf7yl78g5fC/PB/q0iV9LW8yEO6+++6kasUXvvAFXHfjRRxeffXVyeP99ttvo/U72AybZED95cQTT+TUU09lxYoVXHXVVXz961/vsc6FF16YPD755JP71U+c5jqbzfLRj36U2267jYsvvph//vOfyTpTpkzhuOOO46yzzqobHA4kX4ZXXHEF3/3ud6vei79E+8LXv/51fvSjH7Fo0SJmz57N0UcfjeM4/do3i8VisVgsluFENpvl4osvripHobUmDMPkeme77bbrUU4u7XI4ffr05Pmhhx5at5+RI0f2WiUgprYuZ8zWW2+91hCmgw46qMoyVTu+E088kRNPPHGtfQ9XBtM9dUMQDoLraX9qZ86ZM4cvf/nLgPE6rC3X+Nxzz5HP59lqq616beNXv/oVv/71rwFToePTn/70eo58+DB8z5A+8rWvfY3Pf/7zgHFjOPHEE/nzn//Mk08+yR//+Ec+85nP8KMf/QggyfLaH+IvikmTJnHuuecyc+bMKpEJJlnQBRdcwB577MHChQt7beunP/0pv/zlL9l+++3xPI9x48Zx2mmn8fDDD/c5M1Yul0uE6iuvvMLvfve7fu2XxWKxWCwWi8WyPhjX2eG9DIRVq1Zx5513AsYQtMsuuwzGYeOpp55i2223ZcaMGVx++eXce++9/POf/+Txxx/nf/7nf/jEJz7BSSedBIDjOFx99dV9Kns4XNnkLZqu63LjjTdyxBFHcMkll3Dttdcm6YBj9t9/f77zne8kNZT6QxyYvXDhQi699FJaWlq46KKLmDlzJq2trTz//POcd9553HXXXbz44ovMnDmTRx55pFcr48knn9xv62rMCSecwKWXXsqCBQu44IILNrpZ32KxWCwWi8XywUMN8/ImioFZNG+++eYkr0tfrZl9JQxD7rvvPu67775e1xk1ahS//vWvN/kyhsP3DFkPXnnlFX7/+9/z/PPP131/3rx5XHfddVWZydaXrq4uwCQTEkIwd+5cTj31VMaMGUM2m2XatGnMnTs3CRR+7LHH+MMf/tDv/vpCJpNJAt/feOMN5syZs0H7s1gsFovFYrFYhjqj7IbOOhvXznQcZ1BrWB5yyCH8+te/5oQTTmDatGlMmjSJfD5PLpdjwoQJfPKTn+SKK67gzTff5Igjjhi0foeKTV5oPvzww+y1117MnTuXSZMmcf3117N48WLK5TLvvPMOv/jFL8jn8/zud79j9913Twr0ri+5XC55fNhhh9UNzJVSVgV6x5mqNiRf/vKX2XLLLQH4/ve/36Puk8VisVgsFovFMpgMfVbZdS8D4dFHH0VrTRAE65X19fjjj0drjda6R3wmmOoTX/nKV7jmmmt48skneeedd+ju7qZQKLBo0SL+8pe/8P/+3//rcyjdcGeT9rMslUocc8wxrF69mnHjxvHYY49VlQeZNGkSp5xyCvvttx+77rorCxcu5LjjjuOJJ55Y776am5uTx5/4xCd6Xe/DH/4wEydOZNGiRTy5EQoiu67LrFmzOP7445k/fz6//vWvB+SSG384hoq4/8EYgwDjOPE+qUU0HLDzM/wZrDmy87NhsJ+h4c37bX7i/VBKvW/q8sW83/ZnXcSl7Oqdn0NxLEItCPXAM7tuKIbz2D5IbNJC85577mHRokUAnHbaab3WoPzwhz/Msccey7XXXsuTTz7JM888w0477bRefU2ePJmXX34ZMAJ2XesuWrSIpUuXrlcf/eXYY4/loosu4tVXX+UHP/gBX/7yl6sssOtDe3v7kAvNzs5OAITo/5dEi9bmR15rOtrbB2l0lsGan9bU43Y7P4PKYMyRnZ8Nh/0MDW/eb79BSinCMKSzszMp57Gp80GtHd7Z2UkYhhQKhR414Ts6Ojb6eMJhHqMZDjBG0zI4bNJCM+0Gu65sUNOmTUuSBL388svrLTS333577r33XoCknmZvxO9vrMQ8juNw3nnn8cUvfpFFixZx9dVXc/rpp/errdbW1iE118cit7W1dUA/8kTbCiFobW1dx8qWvjJo85PCzs/gMthzZOdncLGfoeHN+/E3qFgssmLFCqSUNDQ0DNp5N1Sky5t8ENBa093dzYoVKxg5ciQjRozosc5QzKnSEjWMy5uoD5jFe7iySQvNtJALgmCt6/q+X3e7vvKxj32MK664AoA333xzrevG70+cOHG9++kvn//857nooot44YUXuOSSS/pdl0kIMeQ/QvEYBmMcwjQ44HYsFez8DH8Ga47s/GwY7GdoePN+m5/x48cjhEgKz2/qKKWQcvgKnA1FW1sb48aNq3teDsV1m7VobjoUCgXmzZvHU089xZtvvsnixYvp6urC8zza2trYfPPN+fCHP8wee+zB1ltvPah9b9JCc+rUqcnjhx9+uNdivAAPPvhg3e36ysEHH0xDQwPd3d3cfvvtfOtb3+q1nxUrVgCw7777rnc//UVKyfnnn8/MmTNZvHgxv/zlLzda3xaLxWKxWIYnQgjGjx/PmDFjqm66b4porVmzZg3Nzc1DflN8Y+J53rCz4iqGdxzkB9PBukJnZye33norv//973n44Yf7nCx088035zOf+Qxf/OIXB6V26CYtNA888MBE/F155ZUce+yxfOQjH+mx3t13383tt98OGCvjzjvv3GOd6dOnJ2L0rbfeYsqUKVXvNzQ08I1vfIPLLruMRx99lDlz5nD88cdXrdPZ2ck3v/nN5HlccHVjcdRRR7HTTjvxzDPPcOmll27Uvi0Wi8VisQxfHMcZdmJlfdFaUyqVyOVyHyihORwZjMyuG5LhPLYNyaJFi/jhD3/InDlzWLNmTd28K/l8nhEjRlAoFGhvb6+Ke54/fz4//elP+elPf8puu+3Gt771LWbOnNnv8Qyp0HzkkUd4/fXXk+dxsh2Ap59+ukddyFph19bWxtlnn82sWbNYs2YNe++9N6eddhozZsxgxIgRLFmyhDvuuINrrrkmOYiXXHJJv10uvvvd73L77bfz2muvccIJJ/D444/z2c9+ltbWVp5//nkuvfTSJG705JNPZrfddutXP/1FCMHs2bM58sgjWb58+Ubt22KxWCwWi8XywWAwalVuSIbz2DYEq1ev5vzzz+fqq6+mXC6jtcZ1XfbZZx/23HNPdt99d6ZNm8bYsWOrEoNprWlvb+fVV1/liSee4PHHH+eBBx7gnXfe4fHHH+fzn/88F154IT/84Q/XWnWjN4ZUaF577bVcd911dd+74447uOOOO6peqxWaAOeccw4rV67kiiuuoLOzk4svvpiLL764x3qe53HRRRdx7LHH9nu8ra2t3H333Rx22GG89NJLXHnllVx55ZU91vvyl7+cxHNubI444gh23XXXjVJaxWKxWCwWi8XywUMhUAxfq/JwHtuGYOutt2blypVordl77735whe+wNFHH83o0aPXup0Qgra2NnbffXd23313Tj31VMCEJN54443ceuutPP/88xxyyCFcccUVfOMb31ivcW3SrrNgDtBPfvKTpHzJI488wvz58+nu7qapqYmtttqK/fbbj5NOOoltttlmwP3927/9G//85z+5+uqrueWWW3jllVdYs2YNY8aMYe+99+akk07igAMOGIQ96z8XXHABhxxyyJCOwWKxWCwWi8Xy/qSsXRw9fGVE+QOWC2jFihV86lOf4txzz2X33XcfcHv77rsv++67Lz/+8Y/5xS9+weWXX87KlSvXux2hP2gVby116ejooLW1lfb29iEvb9Le3j7w1PKTJsGiRTBxIixcOHgD/IAzaPPjOKAUSAnrKBdkWT8GZY7s/Gww7GdoeGN/g4Y3gzY/7zM25jVc3NdlT+xLvmn4Cs1CZ8C3d3t4yK9rNxb/+te/+OhHP7rB2i8Wi8yfP58PfehD67Xd8D1DLBaLxWKxWCwWy7BDDfPyJh+0ZEAbUmQC5HK59RaZYIWmxWKxWCwWi8ViWQ+UlqhhnHBnOI/tg4QVmhaLxWKxWCwWi6XPhAjCYZxwZziP7YOEFZoWi8VisVgsFoulz1iL5qZBd3c3TzzxBC+99BLvvPMOnZ2dFAoF8vk8TU1NTJ48me22245dd92VxsbGQe/fCk2LxWKxWCwWi8XSZ0KGt9Xwg54i7ZFHHuGHP/wh9957L6VSaZ3rZ7NZDjroIM4880w+9rGPDdo4rNC0WCwWi8VisVgsfcZaNIcn5XKZE044gd/97neAydTcF4rFInfddRd33XUXX/jCF/j1r39NJpMZ8His0LRYLMMW3/dZsmQJa9aswfM8MplM1eJ5Hp7nIeUH8wfFYrFYLJahINSScBiLueE8tg3JzJkzufPOO9Fa4zgOBx10EPvttx/bbrstkydPprGxkWw2S6lUoquri3feeYeXX36ZBx98kPvuu48wDLnxxhtpb29n7ty5Ax6PFZoWi2XIKZfLLF68mPfee6/q77Jly/p0Ny4WoePGjWPKlClMnTqVqVOnMmLEiI0weovFYrFYPlhoBGoYu87qYTy2DcXNN9/Mn//8Z4QQHHbYYfzyl79k4sSJa91m2rRpAJx99tksXLiQU045hTvvvJO77rqLW265haOPPnpAY7JC0/KB5t133x3qIWxSaK3p7u6mq6trQMWyxwMC0MDs889n6dKlyXvNLS1sNno0U6dOZffdd2P0ZqNpbm4mCAJ8308tAUFQeVwqlVi6dClPPvkk999/v2mruZmJEycmy/jx4/E8b2AHYZgzGHOUnp/37GdkUNkQnyE7R4PHYM3P2DDEAcIwZMkmNj8TJkwY6iFYNgGsRXP4MWfOHAD2339//vSnP633d9ikSZP405/+xEEHHcQDDzzAb37zGys0LZaB8PWdvz3UQ9ikEAJGTm5j5Tur6aPbf882PLhdmXuNWmvmv/AupVUBqjuktFcD7+wbMjr3Jg3uy2ScEKesyK7yEYBA42sXLQRkNHgCnQdHKBAaPVEQ7iyRnS6lhwRLnyuycuEqXmp6CeEItNIEXYryipDS0pDSioCwq587MkwZjDm6XSkcQCllPyODzGDMD9g52lAM1vz8ZkU7o4FVS9s3ufmZu/SGoR6CZRNAaYHSw9dqOJzHtqF45plnEEJw+umn9/tGmZSS//zP/+SBBx7gmWeeGfCYrNC0fKApLF93Ji5LBSEFpWafwooyWq3/VZjbLJk4oxV+D2hjjVny+Rwtrd2MzhZozq+hKbeAjAyMeITI+UVTVh5F7VEMs4RaUlIuvnIItKTR8cnKkJwsk5eKkW0B4miFPFKhtSBUguKqHMWlOQrL8ohXPBqnmCD3sKAoLvUpLgnM36UBqrzpis+BzlEt9jMyuAz2/ICdo8FksOYnFqla2fmxvD8JkYQMX6vhcB7bhmLVqlXAwL0S4u1Xr1490CH1bxaWLFnC3Llz+d73vsdBBx1Ea2srQgiEEJx//vnr1db8+fM5++yzmTZtGm1tbXiex8iRI9l777258MILWbZsWX+G2Cd++ctfJuMWQiQm53o88MADVeuubVnXMWhvb+f0009nwoQJ5HI5dt11V26++ea1bpNuf4sttqBcLq91/Tlz5iTrP/DAA2td12LZGHhtDpOOaEO4oirucsLYDsaM6KSttUhDrownQyTm/dg1UEeFoQMtKSu3SmQGWlJUHl1hhqLyKCsHgcbxNG6TxmkCtwUyk30ap3XROKMDpqygfdlSOletohx2440TjNg1z8RD29jyy6OY9OXRbPbxFlq2zZEZ4fABDPWwWCwWi6VXYovmcF4+aIwbNw6A559/fkDtPPfccwCMHTt2wGPql0Uz3pGBcuONN3LiiSfS3d1d9fqqVauYN28e8+bN44orruCWW27hgAMOGJQ+Y959912+853vDGqbfaGzs5OPfexjPPvss8lrTz31FJ///Od54403+O53v7vONhYsWMA111zDqaeeuiGHarEMGk5OMPHQVlRJs7yjEyEFKI0Qmu1GvosUGokmRKC0uUuqNThoNKAQ+NqhrFy6wgyhkijMD0moJb5yAPO40SnR6JSQiS3U/CAG2kEhkEIz5jCNOFyjdIimRFm5lJVDeVWGpW+3EC72GBloWqdkEFIQlhWlpQHFJRXLZ1jcdK2eFovFYrEMBIVEDWOr4XAe24Zi33335YYbbuAHP/gBhx9+eL8SIq5atYof/OAHCCHYd999BzymAbvObrnllkyaNImHHnpovbabN28exx13HGEYIqXkS1/6EkcccQQTJkxgwYIFXHfddfz5z39mxYoVHH744Tz//PNMmTJloMNN+MY3vkFHRwdjxoypSkTSF37zm9+w22679fr+mDFjen3vwgsv5Nlnn2W77bZj9uzZTJ48mXvvvZcf/OAHnHvuuRx55JFsv/326xzDRRddxFe/+lVyudx6jd1i2egIGDejBeEKFvo+zXu58H8VkeYIhUAjBKBNFrtAy8iKCUobF5hAO4AmJ30CYSybIFFodHTnMhaeZl2BQBNoY/ksa5dQSwqhh68dlDJ9aQSBkkbI5lyWTcqxYmQjTUsCcotLNGdDGlxJfqxD83iPkY7pq1jWlOeXKC427ralFQGojX1wLRaLxWLZ+IRaEA5jq+FwHtuG4pRTTuHGG2/kjTfeYJddduGyyy7j05/+NK67brkXBAF//OMfOfvss3n77beRUg6KQatfQnPWrFnsscce7LHHHowaNYoHHniA/ffff73auOiiiwjDEICf//znnHLKKcl7u+22G0cddRTf+ta3uPzyy+nq6uLyyy/nZz/7WX+G24M77riD22+/nc0224z/+q//4lvf+tZ6bT916lR22GGHfvV9yy230NjYyP3338/48eMB2HPPPWlubuY///M/ue2225g1a1av248ePZrly5fz7rvvcuWVV/Kf//mf/RqHxbKxGLV7I/nxHgv/2YV/4SjyLe0wu/J+HIsZo4FAO0nGOIWILJbGgzUnA0JtLJ9ai0gqCjQmy1xs+VQyhERomtd87dAe5OkOMpRCt+KWq4wLbjl06A49EFA4qA3fCRG5El1oHKFZ1tEAayQt7QEj3iswuj2gecssIhKfWmm0AqK/ZjHBqJX3Ko8r70WP0++FmtLygO73fPzl4QaeJYvFYrFY+k6oHILot3k4EqoP3p3fPffck1mzZnH++eezYMECPv/5z9PS0sJee+3Ftttuy6RJk2hqaiKTyVAul+ns7GThwoW8/PLLzJs3j46OjiS06dxzz2XPPfcc8Jj6JTRnz5697pXWwaOPPgrAqFGjqkRmmlmzZnH55ZcD8Pe//33AfQKsWbOGb3zjGwD86Ec/Qm3kE3HRokXsuOOOiciMOfDAA5P318YhhxzCP//5T55//nkuvfRSTjrpJBoaGjbYeC2WgdA4NcPIjzaw7O+dqGKRrZuX0Zov9rq+ROOiQAZRwh8HpSVl7SRZZ2NbqIpqeGltRKbWRNZKiUDjCoUrFVpH9b60sZTGsRuxS21ca0tpCJSsWEeVIMChGLhkZEjW8xnT0oVuFnSP8Vi2eYZlo5vJ4tPihzQFAa5QSA1+6NBVzqBCiQoEnqNwhCYjQ9CglCQoO6jQuPKKaN8FILQR1I7SjA5MOoOwqCi85ydLaXkA1nPXYrFYLENEGOVOGK4M57FtSGbNmsWECRP49re/zerVq2lvb+d///d/+d///d+1bhcLzNbWVi699FK+9rWvDcp4hizrbJzMZurUqb2u09ramljwSqXBydr2ne98h4ULFzJ9+nSOO+64tSYA2hCMGTOGV155hSVLllQF2cYJe9YV/yqEYPbs2Rx11FEsWbKE//7v/+bb3960UqdbPhh4rQ5j929mzRslVj9bILcNNLplco7f6zYCEEIjtUIDAnO3VGuRJOSJrZCx0EoXZQ61BEXkJqsIa3xZVSTn4jbibTWAjkSrFkm7OhKFSihAk3FNeeoASSgFpW1zKNeh6AVkPYV0FFpAwXdY3NlIsexRLHs05ku4jqItV0BpQSHwWL26ke5CBuGaWFWE2XchjCuwVgJKsNlra9j8b4tpGOsyavdGpGtiRotLAwpLfPwuRVhUhCWN6lLoorbJiywWi8WyQVF6eJcQGaSk3pskJ5xwAjNnzuRXv/oVd9xxB48//jhBEPS6vuM47L777hx55JGccMIJ/Yrt7I0hE5pbb701Tz/9NG+99Vav63R0dLB8+XIAttlmmwH3+Y9//IMrr7ySTCbDlVdeOeD2+sORRx7JL37xCw488EDOP/98Jk2axF//+lcuvPBChBAcddRR62zj05/+NDvvvDNPP/00l112GSeffDLNzc0bYfQWS98QLoz/RAthl2LJA2vMa4LIetf7t78URsi5QhnLI5HgAsrKwVdOlCjIuNOGkUVSxVZLBEo5rC7nE8EYEwvHtFVTIaK4UCNSA2Xe09qMV2lBoexRFC5dpQxZL8CRGleGSKFxpMJzFBkZ4EpjtQy1wJUhI/IFZL4bB0XO85HoJCa0JVNiRKZAqCRl5USiOhLRUZyp0gJXKMRmipXbNLE0dCiVHVqKAU2diobRDm2bZ3DrOGU0NzfTvEwYAVrUqJL5mwjSoqLcHlJc4qN7/+2xWCwWi6UuSkuUHr4Jd4bz2DYGra2tnHXWWZx11ln4vs9rr73GO++8w5o1aygWi+RyOZqbm5k0aRLbbLMNnudtkHEMmdA88cQTOfXUU1mxYgVXXXUVX//613usc+GFFyaPTz755AH15/s+J554IkopzjrrLLbddtt+t/Xd736XBQsWsHTpUhobG5kyZQrTp0/n5JNPXqcgnj17Nvfccw8vvPACM2fOrHpv1qxZ7LjjjuvsXwjBBRdcwOGHH86KFSu44oorOOecc/q9PxbLYDN6zya8Zoc37+2kML4BEIixiu4wwFNrjzes2BMrQjF2kY0zzcaur7F41LELbSw4lUxEW9KGNs63Kno9/b7WIrk7W3mtIjbRAiUEIgRHG+umiC2QaCOghRkRCISAjAyNEBUhWSdAAEXlojWESuA4CsdRCGUsmLElM9QCRys0wrjaZjS6yQElCQKXkhSUBSxVkq6uLKuWN+H5IZmyZrP736NxeZHNJuToWB0gXYGTEbh5B6dFkPEEbgYcz5Q+UkpTaFd0rQrpXuwTvFRA+x/g28AWi8Vi6RNx+MpwZTiPbWPjeR7bb799n5KNDjZDJjS/9rWv8fDDD3PTTTdx6qmn8tRTT3H44Yczfvx4FixYwA033MDtt98OkNTrHAg//OEPee6559hyyy353ve+N6C25s2blzxevXo1Tz/9NE8//TQ/+9nPOPfccznvvPMQov4JPmrUKP7+97/zve99j7lz57J69Wq22247zjjjDI477rg+j+Gwww5j99135/HHH+fyyy/ntNNOo7W1dUD7ZbEMBpkRDq3b51j+WBfLdhlL+77jEAFk8z66eykTWbXONrSO62aajLG+cnpNVZ4Wn3HMZahlSoBWhCjErrckGW5jQiXxA6cqU10sNmP8wMEXknLgIoQm7/lIofBkWBlLJJEzToAjdJRV1/RZDDxKocvKQp685+M5ylhHa/bJkcbJt8H1jStxZA0NM6VkP7v8DI6rIK8oZyVlDZ1HTEIowUQnxyK/WBHa0U47rmKz8e2ECjIdkF2saV0VMHJNiTFbZlC7N7Dq6W54Yh0TJMBtqjMfuv5j5WtU2QpYi8Vieb9gs85a+sKQCU3Xdbnxxhs54ogjuOSSS7j22mu59tprq9bZf//9+c53vsOMGTMG1Nfrr7+eWEd/8YtfkM/n+9XO+PHj+cxnPsM+++zDlltuieu6LFiwgD//+c9cf/31+L7P7NmzKZfLXHTRRb22M2bMGK655hquueaafo0jZvbs2Xzyk59k1apVXH755YOSpMliGSgjd23A71K8i0d2C83oUWsQCjJZn7ZMgUa33Ou2SWKeVC5ZEWV81VqjiZP1xO9gsrbq+HnFsgnGVTcWln60HVAlQtN9xxbNOCZUovGcECF04harI6EnMIIwtnrGbr1VVleh0QKUMGPzlYOvpMmOGzomQZGQSXmX2LLqSOOW6yuFFMZVN3YpDiJZmh5/4nbrCJBm7NqN9iNR1tFrrlnFHyVYnmngrXEeoBj1ZgdbP72ckbs0IJ4UVB0czA2E/ASPhkkZ8pMyON76/YirUBOUFYGvCMoKf1lIsDjA71QEXYqgM7RuvBaLxbKJYF1nLX1hyIQmwCuvvMLvf/97nn/++brvz5s3j+uuu44ddtihR5bW9eHrX/86xWKRmTNncvDBB/erjd1224358+f38GHeZZddOPLIIznppJP4+Mc/Tnt7O5dccglHH300O++8c7/H3BcOPvhg/v3f/51HH32Un/70p5x++umMHDlyg/ZpsawLNy9ZoyTvfuvf2H7ce0wd9ToShSMUbV6BjKhOBqRSAjBySk0sk65QKBmSc3yKoWfKlsRWysjVNZ19NlAy2d4VClco4rxBxcCtJP/R1UmEwLizBqFMJQTSSKlpyRdxhCLjhHT5GfzQoeib74GsEyCEKaFS9L0ecaFCGLda06egM9o+CB3KvlvjvlvZLucFZNyAQElcqWjyyngycsFVDoEy8aShlkagishlt49zlHFCXE/RXczgKwcpNf5OGdbs14Dq9OFX0fgRjD2wmYYJHm6jgw41haU+y8a5dG6VoahdwkAShpJ8xifrBTR5JVyhkhsFjlCIssDpBtktcLpdvC5oHKlxtqu+EAiLivKqkO5FZQqLfBND+sHLUG+xWCzDnvim6nDFus72n+7u7iRHzuabbz6gtoZMaD788MMcfvjhrF69mi222ILvf//7zJgxg5EjR7JkyRLmzp3LOeecw+9+9zsefPBB/u///o/ttttuvfuZM2cO999/Py0tLfz0pz/t93gbGxvX+v7uu+/OL37xC4499li01vziF78YsMWyL1xwwQUceOCBdHR08MMf/pCLL754g/dpGVyEhIZJGZr+LUvD1AzdxZCld7ejV/V0NcyMdGjdPo9wQEjzJdq1oEzX2yX0MCm1GI9aa0lZeXQFnikPIgM8YUqAVK+f/jEwj0VkohPGholE4YqQrPRxtUQhKYYCkbJMpkWq0gIhNVknqCpjonTvQjPejih+M9JuuFIlpVLiREaxS22oJSI0YrEcOihVcwdV6MQtVgHlwCFUsVtvtchMjydQEkLz9exJhSdVZEXVlEIXXzkUyx5KC7IZP7Hi+kUPFdb5cY09aDUUCxmCKD40DKWpTer55D2fjBsiR6qKiVRAbnOXQqFMebFPd0ERCknn1s0E41wKvmviYZXAy5fJZkKcjI8rVTSPRmiGWhIi8FOxscX7fEqP+ARkkI7EdSUZD/KNDq07NzBqVxND2tWpKb1SoPBOmeIyW9bFYrFYhgNxAr7hSu1vvKXv3HrrrXzlK19BCLHWbLV9YUiEZqlU4phjjmH16tWMGzeOxx57rKqsx6RJkzjllFPYb7/92HXXXVm4cCHHHXccTzyxrsChapYtW8aZZ54JmMRCEyZMGNT9qOVzn/scp556Ku3t7Tz44IMbtK+YAw44gOnTp/PAAw/w85//nDPOOIPNNtus3+1prZNaOkNB3P9gjCG+Vq51AaxaRw7NF5FwoGFihsYtMzRukcHJSkqrArqbNU15j+yhI1h8Zwd+e0U9uo2SiYe2oZUm6FagQHjQ8qEWwpKi680Sa14rU1zm90l0yqzAa3LwmiVus8RrljjNDl6Tg9soKyUyosPnd4V0vV5ClkWvx81tkGTaXDq6gUDQVcqyothEi1dEu5AXPo6ono967i0i9VcCDpCTAVkREmgTRxkqgULiKyNq45IgRjBKXEfR5JSM26xy0KFI+qqIvMpYVCjRobEQGldWgUSTl77JNCsUDtrUuYzcdYPAIYhKsBR8lyDsWby659kXu/xWSrSIVLkWwLQbOBTxcB0j2jJOSOhKCr6Hrxw6unK4rqKloZgkN2oPJL4ylk1Rp3OtJe2rGhGORrgKIY3VtjVfpDlbpMEp44rUySNAn1QmgyYnJG6Qoxy6lEoClMITCumFeFIxKtdNc6ZIs1vCi2JM42RJhdAj1IKS8tAY8S4P9BDTG1jc2UxXOWNK08TjVJqmzoDW5QEjFxcZmRfI3RoJS4ol93fSvbB39+vhjpAmWdSAv3vS0zRE32PvR+z8MKTXAOtiMK8R3k8MxfFIbs4OU4bz2DYFBuucGhKhec8997Bo0SIATjvttF5rR374wx/m2GOP5dprr+XJJ5/kmWeeYaeddupzP9deey0rVqygra2NUaNGcdNNN/VY5x//+EfV41wuBxgBN2bMmPXZLVzXZZtttuGJJ55I9m9jcOGFF7LvvvvS1dXFpZdeyo9+9KN+t9Xe3j7kQrOzsxOg14RKfaFFm3tZWms62tt7XW/0lMGrFdQXnEZB6/Z58hM8HE/iO5piRlHMatSWIQ3/JnEzguZ5klEntLHyiS66F/gIVzB2ehPSE7w3UhM2RIJJC0qhoKkMY8fApD0iN1EEpVUBan4RVdS4jRKnQeI2RH9bHGTq+Co0gSRZQgmuEyKFwkEBgqZAstlUl8bGRka91Uj3AiNqwy6Nkxdkx7iM2LkBkYXMlDIjJ68il/HxHJcsObLKJVsanbiSxmRKo4mjLivFT8wPWKhdHC1p0E4SlVlWLiECHeQohS5Z5RJGbqRxDGWoJQ3kyIs8aJMUYGTYXCU0AXJOgJSKrBNQFA7t2sEPjGsrGjI6YFQYIpWJoQzKDeQCl+boB8wtVeK9G3UvhVvS1sp0TGh6fW32uR4i1LiFvDk+QpPRElfDeFxcHZJXbtJOo8gRSJcxImOEdL0QFQFIHVmMFVJrNiMgpzzypVyPH2evYG5chUjwPXTo0hy7KCNwtMbRiryfIaMCHLeMFMYCHZ9iMsiYdgMPAXhOANrBUQ6bqTwtuKh0tw7QapY1m4c0L1xGtgTN3S6tM1t57//aCbs2zQtNIQVtE5pBCPRACr29UTE7b+zvsfczgzU/8m0JIUhHbnLz076W38yhZrCuEd5vdHR0bPQ+bYympS8MidB86aWXkse77LLLWtedNm1akiTo5ZdfXi+hWSqVAJMZ9thjj13n+ldddRVXXXUVAH/729/WW2jC0NxV2meffZgxYwb33nsvv/zlLxMrbn9obW2lpaVlEEe3fsTHr7W1dWA/IiJ2wRRrzca7/O11Z0AdLLw2h4n/3kJJd7N8XpHScQ0E25uPoCNMDcac41OUIZ0Ha9y7XTLbehRUGbdJ0hV0sujeNRR/OBrajOUsVCL6sgelBKV3czSuDmhZ4zNieRcNW2hcRxCWA4qdCn95SNgZEuyTI9zOQzcrVAMEGUFZuZRCN0lMMyLbTc4JaHDLEInAle2NjHldUHq+g9zWLs3bSFSokY4AFMsWraDxlBKiUZOL9jsApAwQIqCc6eghNMvZ5ZHlUle5v4ZIOsNcJDhldIwUhTCDrx1WU6YoPAqhh4+s1ME08olGWaIsi+Y4acl7uD3cfFrcIp4T0uKV6JQZVoZNdIcZispFCMjqANdZkwim90JJIfSi5zqxWqzrVNWRkKxKPlQjLnv96tAYv9skg25o3Ht1QMYJaRSlZL12BX7oIRAsCkuVNnWqq1hoyqg0i9Qgu8hLn6wIKGuH9GaLZTcaCJRDe6gpBnEpF5NsSQpj7c0Jn4wIaRIlPCckI4PEq6BT5Sgrh05t3HKbZIlASXzhsApNEbeuSJdCk8mHtO7eTVkGKFWG65sp0k3728W1H/RhipAm0dLy+asHJjRTs7Qxv8fe7wzW/KhQJX83tfkZzhnsB+0a4X3GUBwLa9G09IUhEZquW+l2Xb6/vl9JHJLebjgSBAGvvvoqwAZ3063lwgsv5N5776VQKHDxxRfz0Y9+tF/tCCGG/Ms7HsNgjEOYBnt9f2AXen0nN9ZlwqFtdOcc3hzt0riLJLOlcU/tLGcS61bWCXFlSN71cT4W0vB4iRaRAw0rJ/nIXRoYObqAdgWl0KU7yBCGUc1ICZ2tDu3NHot0A01jXRpWdSM1KAkZ1ySTac2EyK0C3BZFWTkoLSkFpq3uspe4jpaVJOcEtGSLiRD2PYfOqQ7vFrN4fsjIoETGB51VyJxPZnRAa2sZRxqLVhwb6YkQRygQRkymKWsHRyhcoZNEPwHSuMhGVjMlINAugZK0+3l8LSmGJkZRCG1cQLUiVC4KcByFEoKidvGVyfDqa5n88MQCKfZeDTDlVCpJWgVa66hvkQgmhUnnLhKRqEFE8ZwRtQmBzGu1z3smAIrbW9tprwFUFOeoBKWyi+87SWbZwHfRypwLqWSz9RvS5oJaaegoZSmELo5UPdx/3+tqTkYXaokWmuZsCVeG5JwAFWXTLYcOhbJLp5/BEQrPqfgOFgKPMEpgBOacjxM4lZWDEtXHzXxuzfyECNr9HFknAA/cQkDD5AyrnysA0PyhLGOnN9M1v0x5ZUBpRUh5ZUC5PaTHyTZM0Np89wzW98/G+h77oPBBn5+hvgZYF4N5jfB+YUiE5jCP0RzOY9tQfOUrXxmUdl5//fVBaQeGSGhOnTo1efzwww9z6KGH9rpuOtYxvV1fOP/88zn//PPXus6cOXP48pe/DMBvf/tbjj/++PXqI81NN92UuC/st99+/W6nP+yxxx586lOf4q677uLqq6/mnHPO2aj9W3onv0WGCTNa6C5pnpo+moYWn1yjJHQCtBKUQzcSZEbguFoaS06TIJyhWLMygKIkHOfiakHG9Y0YUxWrZpLoRpgELEJowvEepc0bASPGvEwZ4fpkckHkpqooBB6BlpRDx4ix0EmsVSaJjol1NMlwQiM0XIHaIUfohIQ5RShDHCHwpCQjZSIysyIgECZ20hEqqQVZG6AfaCfKUFoReYGWBJGVMo6nDLSkrByKyiVQTrL/ULmXoCI3VYFCY2pjhsq498hYFKJxpEaK+GfIzIEfOtG6Ikr2Y/6GSlaOSaTedLpj3VMw9risrGPJrGfBFPW2ja2OGE9YJeMxCFRorL2oqD2VyjxbqzTTj5ODbcZfDlxCLZFSEdYkNCr45uaDFJWYS1eaLLw5NyDQxo22FJgkRX7UvKsqQjM+x2Ohr1RciiYSmKl4VaJhCfMfGkExNNZoVyqkKjNyUpaWvRpRoWazj+QRQuA0CFrG5nDz5rzQoabcGVLuCCh3hBQW+BTmV2c8tlgsFkv/sBbN4cecOXOG3Q2YIRGaBx54IA0NDXR3d3PllVdy7LHH8pGPfKTHenfffTe33347ABMnTqxbLmT69OmJGH3rrbeYMmXKoI931apVPPPMM0yfPr3XdR5//HFOO+00wFygfv3rXx/0cayLCy64gLvuuotSqcQVV1yx0fu39KRpqyzjDmhm1UiPt3bJs8VmK+ksZVnW2YSMMnMijOtsnPQFoNPPIgNN0XHJtITkR/jGuVBAKTSioCvI0FHM0VXKmMyfmAt4iGI3fY+SH2UudRQNXjkSqBJfOQRa8k5HG37oGJEShxFGX86x+OoqZYw11A0QWtOgXUIh0MKhy89QkqbWoyeMxdQRmowICByfQBux6ESJYTIq6CE0VwcNOCIkK40w0ZDUpCwrJxlYWTmUI5GZxGNG75kYTRFZzIwg0VHpk6wTGAtxdLxdqchIk/22M8jihw7vdrRQLruUo+Olo/9CJeksZ2I9aWpf1gixHoKxXqymrj629RBRzc/KC5EodqAhV8Z1FBknoBR4BKGkszOKp4xFZmKOTceDVgu45A1lbkpoaR4XS16UGEglGX97bKVjS2P98cc3BOLH5ShrblwbNI67RcevVSyztTVN0UbDCy0IFawqNCDQrJAN5GeWcJ8tM1Y2AFAco+maVqKltYBGEJYkwSoX0S5x2iUN7R5N7VnEhwWFd8ss/usags5hauq0WCyWTQQrNIcvwylZVr+E5iOPPFJlVn355ZeTx08//TRz5sypWr/WStjW1sbZZ5/NrFmzWLNmDXvvvTennXYaM2bMYMSIESxZsoQ77riDa665BqXMBcEll1yClEMT2Nve3s7+++/PjjvuyJFHHsm0adMYP348juOwYMEC7rzzTq6//nrKZZMJ8cwzz2TXXXfd6OOMa3r+6U9/SurfWIaO1g/n2GyfJlavCHlrRjNes8KRxjVSAeg4O6i5qo4vvuO4Sy00vjDWGUnFyhgnvimnLHCxJQ9q3TIjC5IWpnYjmoL08LVDqERk8YvtehWM1tDx6EyNSSXxRFy2wqwXaomMvtCUMNY1X0mEdHB1GAXjC0KMaCjj9hBmQWS1TFc98bURk4F2ovFUYgKdaMWAyLSHsWSqKBGQxuxXLJaEE6etMcdeohPX2epjarLWOo4yNwEEOFLhp1xJlapjiYyFZY/v9Yrgq/9+TTOpGTBiT6Mj1ec6Ck+GZJz4mOqKxbJeu9GNAyFVReSGdb4/I6uhlAoZZaCt25xOjLeIyH04UA7lUCWxsWkRrVPt6+hYxMegkvCJZL4SyyYkAjtpRwuUNlmA0ZIw57JoT8Hba1wcR9HSVqDJdQi9yJLZINBtGk2IjoJodaDp/lFIy4hGJs8cwbuPdFB6zVo3LRaLpb9YoTn8GDVqFCtXruTjH/84V199db/bue222zjrrLMGZUz9EprXXnst1113Xd337rjjDu64446q1+q5o55zzjmsXLmSK664gs7OTi6++OK6NSA9z+Oiiy7qUzKfDc2zzz7Ls88+2+v7juNw7rnnMmvWrI04qmpmz57NHXfcMazuZnwQadsxz2Z7N/Gu6zD/cyPYfsJSk9wmyFItKQxKC1QoCSIxEAu5TjKVi/OUVUwjCENREVfJAvXcMn3tsHyNqQX7rmjpNQ5QpIINY/cLITTlwFg323JFhDBWQS2gGHho19R6lFpTVtDu58nIkLJyyMoAVyrKykXpdCKd2Gwm6A4ziTUsFiHpupcm2UyIJ0PysozwNKGWdJAjjEqZlEOXYlRfUilBwfcS8dKWL9Dg+YnbZ+1xD5U0xzKyCjfmSjQ2mAQ7QeCwvL2p1xjL2IJYV0imf+TW9nGsnYsoNjHJ2CpNTGTWCWh0y3QFGcqBS7tuNNZMVW8yBdJVuE1+4u7rt2ejdaNjn7JiNzcU8VyTJbZYrv5ZUEokIhNMhuL2Yj4S7r3HlFZueMTnaeVmgEqdr0nt0vjGgEj0r3Eljt1oMTc/ir5LWbiQ0zhC0FHKGbdv5eBJEwsshfmMOZHLdzYb0PxfirBrDaX7Wpl0YCvvFdrpXjgwsSmkSfKVGemiA03hPR9Vst+9Fovl/Y/JVzB8M7uGH0Chuccee/CXv/yFl156iS222KLf7YwePXrQxjRk2XWEEPzkJz9Jypc88sgjzJ8/n+7ubpqamthqq63Yb7/9OOmkk9hmm22GapiASexz6623Mm/ePB5//HEWLVrE8uXLKRaLtLa28qEPfYjp06dzwgknbBDX3fVhxx13ZObMmdxyyy1DOo4PMkLCyN0aWV5QLN0jS3OzT1GZ2oftxRyloPpjpzFJWYRIW3pS76eEZiIoqdxNTItMHbsmpq1jmAv0istnRRwkwlJE66UTskTviUj0CKi4O2oTaF+OYjq1Do3wkCkrYWSRFBpcoVBosrLKVpXsf7IvqedJ9lkdWy/BdeIozyhRT+QeGwtGpVJtRceju5whiMYZZ1l1hUIKRTH0CKI4Tq3MsXOlMmVPhCKUklKDKZ/ihw5+2QjZKnFZ5apKxYKZVpC9aQ8BuVzZWFGFJlQmsY4KZJUbdEWEpTsR1YIXUu6z9Oo1WzXh6ZGK1Hspsl6YuFzHtu/E2h2504qa+TTjNuvG1mbSolL1dJ2tuBdHIluY9dPnZXIjIhmzibfVmKRCxdBF60qkq4wyOTdnSmScAFpg9Sc0jX8RTPhUK4tfLtH54JpeJieFhEyrEZSZEQ75D3lkGh0cIaviYbTWlDpC2v9VYM2rRfRgeehG/bvNDl6TxMlLeLLi4+zkBGHRClyLxbLxsBbN4UcsNBcuXMjixYt7LR+5MemX0JwzZ04P99j+Mm3aNKZNm9bv7R944IEB9X/88cevMwFQJpPhs5/9LJ/97GcH1NdAWB8L5c0338zNN9+8AUdjWRsNkzM4nmDhAa00jCuRdwt0BxkKgcuqQr5niJvGuEj2MsfxRXgsKNMiSqv6QrOqbEYd1aFjYRm5Zoo6oqQiRkViuVI6zsxqXHzLgSmHohyRZKYV0fuBdnC0yQabkyEIc+FfnQlOR0KaJAupomLdDLSM6mIay2ZWhlWiVyEjMVoRmFXHRwu6yx7deFXiOhYp8aV6GMrkWLpSkXUDMjJMxlUOXTpLGYKyEwnSSPjE1sSU/mN9ftyEJp8vk8kYy28pcOkueZSVhw6kOZapOa46L9Kus1pUj4HUe5VDjdCxSIxfE1UrxTcR0mTdwLjKlqOyJzptxTTZeakSW+b1+LGumY+0ZTP9eo/zUwDCZPgV8V9pMhALrXGiLh1hEj+VQpdC4FGuyZrb5JUREhoccw6FjuCdg3K0PAnjhaA01iUsKnRoXGx1oFGhRodGwGVGuGRaHUTUYdCt0KMUTNGU2wLCNk2pReIXXXjPpeGvIWOnNzNy1wZWP1ug/cUCeu3J1XtHQMuHcoyc1oDXXElyFBYV4ikzYUIItjx+NEG3YunDa+h6q9zPziwWi6XvWKE5/Nhjjz2Sx//4xz844ogjhnA0huFdL8Ri2QRp3ipLSSkax5oSEL5y6Cjm8FVPF5P42tqTIVnXlDaRQhOEDr6SkQuo+bKsvTivtWamxYbWkM34ZLww2ba7kIl6i62esT4Q6JralrUiFARSarpLHgWZoUtmUJHwDJTJGutJB0foxNoZIHG1wKV+LtUYRyiUdkycH7HF1Fgqw+i1UIskAZDCxIt2+xn8KKOsHzp1LLzVLsSVx0ZsxflZNaBDkVg0/dAxLsFOZf2qCVNpa2ZqEuMftb5asWIzYspamRynyFLoeCHSNdmBw6g8SzFyY47HW2XFTFk4dSgJO73KuEMByoi1tNjUCLq6s0jHJAIKapMdUW1VRQgyjhHGDW45cVWNhX85NHNZViaGOAhkZT7iDMmq57kbJ6Squg0RJS2K3XeFFsjInJlxAuNO7JWTz0MRt4cgD3UlszMa2kt5ispl1Y4eXQXFCKWRODgCMjJEYuJ4RXSeKBlQFEW0DFAyhLwiv5+LO1HiYM5LoRxEVlNq0hRWlQje7ibfkmX03o2M3LuRrvfKlN72CTpCpCdonJwhaMqBK5CuQHggk8cC0eIgRzh4QuMi6RY+K4TP6nKG7kASkK26n7BIB4xoEIw7qIV3bltFeVWIxWKxbEis0Bx+7L777onL7JtvvtnvdnbeeWfOO++8QRmTFZoWyyAiXGickqVDlRmR1xQCj0Lg0VnK9tAf6QtiVyrynk/WMdlQC6GHCFy6ypnETbPaApSydKWFT6rdjBvSmK/EGnZ3Z8zlc9p4Gl3cJ5atlIEurhVp/hgBWcSjiEvB8UCYJDVBlJAocBwCqSKX12orZeLyWUdvSmFWTkqZJJZNkWSWjUVW4iarBYWonEZcwqRaYNZJ2pMcd6jIGSM5dSpza6AkxcC42sqaTLDVVmNM9tb0ftVaNOuNQdR/M9adojI0HC9EOJpyECdvEkkSqKqyILWCUwKBRPmyemzR31hExc+LxYyx8EpdrfRS25lTxZwnnmMSE7XlCngixJUqyWTc7WdMbUy/Zj4gsTYn7sdpoRl3InVieY23i2M0K3VQ45szAXnHryShitZJrNaYEj0mY7G5GbGmnE0s16v2bGQljQihyToBk5tXk5UBTW7JuATH7uNE4lPExyAETJ3YEJmUfpFCkdlH4O4rEaJMqV1Tfj5HpujSNDqD9MyoWloacVYEKD+yoAYa7Zu/yteEHpSnuJD3KW9VojDCQYU5ujpb6C5lTDbp6ysnzpqZTUhZxL1Jsdm+TSya217nxLNYLJbBwwrN4UdbWxtvvfXWgNvZaaed2GmnnQZhRFZoWiwDIjvKpXFqhu5FPsXFPo1bZJGeoFD2yWBqPYZK0pwrmtqYUS1KX0k6S8Yq0ZQt0+CVafJKkeuppqScJDYtsWiqSkwbpERmLJwicRe7ztZqnFiYGOtlbM3TFQFS4z+brCV04suoUChphB1JIhiTobUcOgg03U4mEWlZGRiX2kjWKC3xo0y0cWd+ZM2M6zHGrpW1Fs2ycigp14hBLcm6AY4ylrSucgYVyp5W3l4QkbhtayjgOopypmIJU8KU5ujuykUJlyIhHUpU4NQXdlWPYzECPSZBRMc8cgtFQFd7nqKrkJkQpYyF2PRj5kspjLAIBV1R7KbWwmSRje9epPoXsQBN3qv5G1kEhRDo0LyuhTaWzlqdqaGzmKVSp1UjJTS4ZfKuT4tbxJUhbhTvWlYOReElN0ak0OS9SmmZUuAShJLuIFtV6iQ+ZzNeQGtjIbqxIWjvypusyFpGscASLVUSt6y0oKxc/LhkT3TTQ6QuMAIlEytt4lYdHzOMIDUlcAI8YWrGVkSlTs7JMg5ESXyNFdccIBVZ2wGcqMyPKxQhEpoVXdNglQPBwgCpjadAcw5WjtJ4kVXWi5IWxZ8KNT5D+GEH6QQIAX5g9i25EVFz/VT0PfJ5n1CHaH8tJ77FYrEMEvVCOoYTw3lsHySs0LRY+knTNlnGfqwZBIzaVRAUFDrQFJf7hJsBkYtnLIqMq6GPrySlsGKtzLk++WhJEqzoivUsySQLVa6RFRETW4WipykLaJxQpmJBMutXtkz5Kta5PjVCtLKOjgSMQoCMXRolYCybUjiUQicqQ6JRrkSgI2Fn4i+Dqix15hgZi6VMBEQccxmmYjRNOQ3zlaW0wBUKIeOEMToVm0ldkRn/6IhIxBCJoKwbEHhBsk1XOUO3n6GzkMX3nYogSSy/VIRd4r5qXhM95qbHAY2SPlXMhOWCZ6x4QcXmrUOBUCSWa6UclC8JCl7VPFdbUmORWTOGtPAlPjbRm8rMgTk3NEL3HHrJ91JJd4xlOyNDck5AzvFxhcIRpsyJiqRS7Moq0LiOJuMEVfG55jyqTqikMeVkYit8LDS1EpXDrjFJraROyvOUElddNymzkt6HOMFSvH2SwVlU9L4nTfmYOBa51oqtMG3E27oyxEEj0ahUTdd06Zx4OqXQiI9kYAdpDrcSqHIe7fpIz8d1fDJOQEYGidA0Fv1y8jj+fMQDq7188kOHoCzJScmyd2yMpsVi2fAoRE3OheHFcB7bBwkrNC2WftD64Rxj9m1mcVuGN6Y00FL0mdLVSX65oLglqC2bWVnyaC/mCJSkLV/o0UYsfJq8Mo1uiUanTFG5+NqhvZSju5ypm3m0MV82lhYtKBQzlMpu9UU7gBZ0debo7somz6vKYKQNbrr6NapeM4LMXJGbi2oljTBEAY4Ro1JUXBsdmcGViowMKIQersyRd3wExqJbDt0qfdRezlcyyCaLjCyakeusMnF2K4t5QmWS5DR45agNU5rEuJOu+y5rLDKpcwFfvSKJa6x0NW4uSF7312TQUa1OoVLWw+h9oWteqz2+MvVcUF2mJDU3fkeWRL0mIrKOtbRWZKpeRKeoNlwLLdBKJ/upNYiaUGKljDhWYHxWlbntEcdlhsjISm9KjJRC4y7eVTLnQS7jk7hTx9bmJEaTyj7FolpXxqKVsdyG2tysULJSUmVlZ6Op/xmdnxUbeex+bJ4VtZfcoEj2UUS1aUUsPs1FSTE02aF9KZPpic/NriCb1KvNygBHqiQm2VcOjjTW0LJyCYSmOzAW3i4/QzFwjaVam6RGI50AT4aESrK01FSViVprQc7zackWybs+Umh85VAOHTpLWcI69VALvseyFS38m1hBeaWNz7RYLBse6zpr6QtWaFos64nXIhm9VxPLl4W8sP8IXE/R7ji0t3VTcEJAoAKHIKgkqAm1RGqduPGFtYmBROWB1lFtx9QFd5o4HqzKMlUHrXq/2xh7z6bb7vW15BI+slZBYuUzFp7YLbZSZkSi0dK4uPqRO6PsxZs0js1M+ozGUCl5Ei26UipDRNuJ2MUxio8Ldc+L8PoHx+yOKVsiox8kM8AwlKiwp1iN4/WMs2U9yzJVgq/KOih6rtfjdUX1oYYe4rNudtn0OGLLJqL+qZFY8iKraqqvpKMe5uDKIOM8vbEVT2mZvGeSNVXcl+O5g6hJYSzsSlUsz8k+xUNXIhFSSSwy8bEUVcc0VAKlo7I1onIeVFpLCdb0PZZUtmF0fL6Z8fpKmqy2VDLXxkIzPo9jy6VCoIQijiEWWqNFpWxLoJ3UMalkR06HwWqMa6+vnCprqyNVZOGvPvb1a6ZSiR2mzvRZLBbLBsC6zlr6ghWaFst6Mma/ZsJuxeLFPtlsgJBR2Q4tCZS5yiv4XlRI3lxgrupqSLZPXyg70lg+EutLZFEpR0I1cQOMLiTTX5vJRXUdd8ekn3pftLXr6+pxVb0Vbx5b4GRKwAogNFY9FSXN0VrQpU1WUiGgXQuKgRfF8pnYukBXl58oKYeMDGlwy4mgXF3K44dOxYVWSfKuT3PGR2kjapZ1NpH3fBqzZVpyJZqyJVZ0NuLHtT1r9r9KQAtzQb+4vRmUICi4FcGj61zUJ8coEnAhxrKXcp2tfgwijBIvRdbgHgdWpo6xMHVUEw0b95fUOU2NRdURkvVEpoq6rZ3YSHgJYeJ1ReQ229t5EGd8BTPkUEjayzmKyjU3UKItKrGSkagKJU6kDOOsr+0dDamapaJyLkaPi0WPRe+NTAaa5OGNLOtKV46FkkYuCxndBBBRYimq68QKiCy5ZpxSaLPfcdkerenyMxQC85mN44uTmxhVItvQSRYwSZEcofFkiKclSocUMfva5WcJtMkcHYvPxJU9dguPHifx1ym3dzCxoMZyauq+mvd6zqcAWhuM14R07cWVxWLZ8FiL5qbBV77ylfXeRghBLpejtbWVrbbaij322IMPf/jD/erfCk2LpY+4Ix02+2Qb+SbB0sVd5Hf2CLIlStFFdLfv4UiTxKccOqhYIwAySoYS3wEMk+Qk0F3OEISSUk0WVUNcZiF+BmXfSS6kYwteHAO5TmNGnYvUanMPPQWM0Ma1UuoqC54RY9EFuIytQkZAh9IIDo1JkBJnn5VRspU0SkmUiMx5UdumbIpMWUkj65gwx0Ni4itzbkBWBvjaqbh/kvI27e0wRG/E9TPDUPYU5emDHkpUyakkrlGiWlim3FSFosryKDQgRXIojeeuRsdJeSLxpGXP0VZKsOjq12oFZK3I1FFfStTRuEacxTcwKttHky96HofEcm1UHwXfI4iSEcWrx7G2pcDFD2M35tSh1BVRlYjMqL3knFKpczg9DmlmNY5fjs9JLTAJeoRZXUWqMhaeQosk8ZOI1yG+ZxKdKYLErVcl2WMju3Uqe62oPZAIXB2reVNGRUcJiUJtYkeT+M1YaEZW2lLoUFQuWkAQleaJBbcG/FDSWc6ANrHOReVSjm48Qc3nXEBDpky+uUTZ0Yz9RDPv3t1OaVF/i3daLBbLurEWzU2DOXPmmBvZA2TnnXfmRz/6Efvvv/96bWeFpsXSC7nxHiN3zuPkJU5e4jZKurMuT2/fwtQdAzwE+bCLpV1NFAKXVcV8dHFarQGEgKwbJhekZd9k3gTzRbiqO9+j70rimpQFI9IBhVImiW3TWhjRkBaE9cRkb891zfqJZSxSQCJ6LLURLdGgYsueFkYoCl3JQCuEydBaEi7aMRk4lTaiwBMhWcevsswGWuLUXJAnljEljbuskoQqSH7YBDCyoZuMDMk4AZ3lLGFcQzEeey/uo+kfHx0JzbrHLXWMVFmgypmKNTHWynEsZEVvJAI0Frumn4puStxAkw1iq2Ys9FJzFK8iU0dMpf+KpM30HMYW1YoATSMSNa7deICR2pLpEy56K7JoaiQKU2uzo5BDAKtlQzLIiutmJTuy1jWBqsl5S+XcS/a1F6EfJ29CI1SUNVlXrL86EZfxzpO40hrrZmS5jCZARnGeSONYLqOPDQIciFxtRSI2Y2RyB6PqSCaf+UBLwlBSDDzKYZxBWSTiEozrrFBQCLN06NCcdqnjRtR/QXkUfI81XhYnugGRuBynj03EyIZuxjWsofMzHk33ukw6uI337u2ge4FNDGSxWDYM8ffbcMUKTcPmm2+OEILu7m6WLVuWvJ7NZhkxYgQAq1atolQyifiEEIwePZpcLkdHRwft7e0A/Otf/+Kggw7immuuWS8raR8DmiyWDxZOXjDh4BacNpeuBocVWvBOp+bFaU3ISaZ2X97xaXRLtGULjMwVaMyUybhhEkc4kLt9lZiz+LFOYjOF0OZiWRLVPdSJ5SW25MSlR4TU5go5eZ0eF8s9nkNl/Zi0myMkjytZXiv1EePEPH4oCZWJ0yyGHiVlkgAZi2blSllrYwHu9LN0+lnWlHP4oRO1UykvUgpc1pSyrCllTTmTKOatHLnKZpyQkQ1djGzoIuf5eE69pCjVmWnjhDOJuK67UG25VDXPYyubpjoLbS2p14U2gjQtSkWqn6olva2qaSeevpr30m3VPQNT46jbT4psNiCb9clmfaTUqWQ+pGIuq8vKxMl+gkDSVcxSKGToLmaqXGarbmr0eK32faKESdExVpV+4mOuVXRhka4vmxpXpYZndIEUufDGF0oi6bCSlEprk93YlSop0RLvcxy3WQ4dioFLKXAphW7kOhzfJDHrhjo6l6NMufF3hFKy0l6dxQ8cyr5Z/CBlUa+Z1WyUXCjTELDmgIBuqZl4SCtjD2rGyduLLYvFMvhUXwMMw2WoD9Aw4e233+YPf/gDTU1NZLNZvvWtb/H000/T1dXFu+++y7vvvktXVxdPP/00Z5xxBplMhsbGRm677TZWrVrFwoULueyyy2hpaUFrzcknn7xetTqtRdNiqUN2lIuTlby2qMyyUyYQZ6qc0NJB3i3T4BpLQaglrlSUlUNHOWcyTPpu5cKWXi70U/Tu0aCr1onHkHyBRhatpNZf1JtIWcU0kYVNkIrD66XD3r6VY7fZtMumrnSQJIhRAinjC/nIbVZq3FDRFWZQCBOrWeM6qxGUQodC4EUX4SL114gQDXSXPbrLxprrSkVDpmwyhOKYGDnp09pcpBw6LC00UShlKAdOTV/x2KPdCEVFrKxtGnSNy2q951H22bq6vaY9nRKAOjWpInJHTlasY93sMYdJ/1RccWVl83pj0USWVZ2yYCZzWr1VPl9ObnJ0FbKEAcYVODofEcK4AsdW7qgtrUxsZqnsVbIih6kyPWkRqdMjqx0pRBl6egzPWFqrX9QitY+i8jx2F47P0eQ9IXCkqYuZJKKK3HK1gLwXZbYFVCAI4xhjDWVcc3MnrNxcqohUsw+xKNVE1n8qMZqV9VLTmdqXcm3SsF5ocMtkpCkh47Ro3vzsSJqeCZhUVDR+biTLH+ui4+Vin9qyWCyWvqAQSXjHcKS/5U366ma633778cADD/SrjzQ33XQTv/3tb3n22WdZtWoV48aNY9999+XUU09lzz33HHD77777LocccghdXV089NBD7Lbbbj3WkVKy44478qMf/Yijjz6aAw88kE996lP885//ZNKkSZx55pl8/OMfZ++996ZQKPDzn/+cyy+/vE/9D6lFc8mSJcydO5fvfe97HHTQQbS2tkZuToLzzz9/vdqaP38+Z599NtOmTaOtrQ3P8xg5ciR77703F154YZW5uD90d3dz6623ctZZZ7H//vuz1VZb0dbWRiaTYbPNNmO//fbj0ksvZfny5X1q74YbbmDnnXcml8sxefJkzjzzTDo6Onpd//jjj0+OjRCCe+65Z519xOsef/zxfd1NS0RunIcONToMac6WyHkBrhMm7o5+lFFSClPGIycDMk5oFjdMrB9gPBJLgUPJdyml3GZj0hZLKRQysp7Ei+soHKfyN35slhDHVUgnvWiE1AhHGcuno8xzqRHRe0iiBD+6p7Wzh8UzdSVca2mKX9bV1iOoPA60pL2UZ3Upz5ogS3eYqWo+tvKEqZjMtEUpXbIkfhwqyeruPKuipRyai39XhGSdgCavTMYJSDLWRuPpIaZjC2V63+IkP6ryuIclMxaVCkRYcZftD0JjYj6TvuNpEfX7RiTT1nN/quelz+heHqee11qviecktmqmLYkqPt4iEdaVvyKxSlb2KyU8067MOrVeypqJEka0hvG6orLfqfbqWTirrYgyEYI9l0q22PRrYep8LYcO5cB8rv3AwQ8lQWjeC0OHIIyyTIdmUUoQhtVj0FVjkZVzXQmk1MlnXkqF1gLPDWnIlqs+p7526A4zrPGztJdzdBZzvDO2mX8VM6zUDmOnNzPhsyPwWqtvvFgsFkt/qf3dH47LcKZYLHLYYYdxzDHH8H//938sXryYUqnE/PnzueGGG/j3f/93LrzwwgH386Mf/YilS5dy1lln1RWZtey+++6ceeaZLF++nMsuuyx5fccdd+SEE05Aa83999/f5/6H1KI5bty4QWnnxhtv5MQTT6S7u7vq9VWrVjFv3jzmzZvHFVdcwS233MIBBxzQrz5efPFFjj766LrvLV++nIceeoiHHnqIyy67jOuvv55DDjmk17YuuOACzjvvvOT5woUL+fGPf8xf//pXHn74YRobG9c5nlmzZnHwwQev/45Y1onbLBmxcwOrni/gtmky2RLdvkcpdIltlGXl4ApFToZkZIgjFJnQw3ekETjaww9JrHHlqE5evdIDxihkxF4U/Vgn8Qgpi1EkuGTli95kUTXJeNC6IgbQFWtdfLFPbM0iismL30yJpd6+n3XVn8oTEY1FgU5Kr5BYJzvKOUqOS3OmhCerXVqrLuRV5W9aXJpjJ6q2aS/kzVER0OiVybu+cXHUiiavRKnsmjIrqW3iHUvGXyVqUlZKqNypTQu6lNBDs5Y4yLVTtW6VdY2K1S4xeVbusMZGxx7tReJKxI/7Ss2+9WrsTpkHqwR70peoXleL5LRKBGeyA9F2dbL61hW8gopZEio7GGXpNcck/vxEx8kMOLHzJ+d2dFzjY50kCFISEcWfxi6tQugodLUyzlhkxi7YlX02puRkelJWzSSOKXosiEqmKFnVdu1HTwNu7CYvjMdAEIDnhDTkqmMvfeXQHWToDjJ0+hk6i1l812HNpxpYqgQjV5bYubiEzY8ewcqnu1n1dAH8ft4ZsVgsFqJSY8NYzA00fvTkk0/mlFNO6fX9vlyrr42vfvWr3HnnnQDsv//+nH766UyYMIHnnnuOiy66iDfeeINZs2Yxfvx4TjjhhH73c+eddyKEYMaMGX3e5uMf/zizZ8/mL3/5Cz/72c+S1w8++GB+9rOfsWDBgj63NWxcZ7fccksmTZrEQw89tF7bzZs3j+OOO44wDJFS8qUvfYkjjjiCCRMmsGDBAq677jr+/Oc/s2LFCg4//HCef/55pkyZ0q8xjh49mn333Zd99tmHKVOmMH78eMAIxT/84Q/84Q9/YOXKlXz605/mH//4BzvvvHOPNl588UVmz55NLpdLLLkLFixg1qxZ/Otf/+LCCy/kkksuWedYnnjiCebOncvhhx/er32x9M6YfZoIfc2qLzaQ20zTmO1G6QZKocvqUt4koJEBGRmiMSVJTKkCQUaGtGZLrNaCgm9iEmOx5EhFPusnF6NF30NrgeOoxN1VEJdUqC82idsjbV0SKFkdh5Y8jl0Ata64H8YDiCxoFXfH1FLVYfRlnbJ8Jk3oVFKbSCAlgjeUlDG1KnOej9Ie73S2kXVCUpfkSV3RtMthlTUzcSft6WbYmi/Rli/gOSGhlqwsNeBKRaNbZlxzB6MauswFuO/x3qpWwkT4RA0EAhHIXvabavGZKhciwpRgYv1EZi2xTkqsejVJaHRvHdSKsyhpTn/GIrRIuaBWH4iOdpPwR0gqgkmlzonUnuia41ixKNYfb9p1tsoqHK8fG/9jgYgmKciaqOr4pNSJQBep41HtKyyi7MlGYcZlTso+COH0+MwJoWnvzkVNiCQ7bTpxT7zfIn1KxOcZlc9/fJPI5Oyq3FxJNqo+pVLb6kqfvVw4mdhQh1VdDazuylfiOaPjtHJEjkc+NI5/W7aGLaYJGnZuYuU9qyi849dtz2KxWNZFOrP4cGSgYxszZgw77LDD4AymhgcffJAbb7wRgMMOO4zbb78dxzEeJ7vtthuHH34406ZNY8GCBXz729/ms5/9LG1tbf3qa+HChQC4bt8lXzyWd999t+r12EBYKBT63NaQus7OmjWLu+66i+XLl/PGG28we/bs9W7joosuIgyNheTnP/85v/nNbzjiiCPYbbfdOOqoo5g7dy5nnHEGAF1dXX32Ka7lox/9KEuXLuWPf/wjZ5xxBp/5zGfYa6+92GuvvZg5cyY33XQTf/jDHwAol8tccMEFddu59dZbUUpx2WWXcc4557Dnnnty9NFHc//999PQ0MAtt9yyzrGMHj0aMMdPD+dP+SaIzAoat8iyckER8SEXZ7zAk2ESoxUqmZQvCKJi7L5yKEcF1wWm9l1cWzA9PUKY2ELHUTiyktinIi6rRaaAyJ22t6XidiuEcYlNJwyqXkguZEWklkTKbTa+MO+RBCgZfGQXiqrNS6GRshK7lhBd3CZCOfohii+qi4GxDFdtEltok6VmAPHFfJ1hOVKR9QKTpAaBr4y7okSTcQKaMiVyrk/GDSvjS8RMReTUbTwtMnXKVTXaLu1xPBiIvo5rQ1KnvyCQhIFDEMikDmTl5kR8BHreBOjZbj1LaM06qWNc6zJsjrnosV7d+Ux/fuJzPaL2cyXQkUttZUm7XgWhgx+5wcY3RHomGRJVrrBV7lup5xUX35RbV624rhHlVW7jVG4ipYnLAfmhcdHv8RkSmtLYLC9+eDMe/tBEyq7DpE+1Mf6TLXgtNiegxWJZf2J3/+G8DFdil1THcfjlL3+ZCLuY0aNHc+mllwLGO/PXv/51v/tqbm4G4O9//3uft4nXjbeNiQXmqFGj+tzWkM7C7NmzOeSQQ9ZrwLU8+uijgNnp3kzcs2bNSh6vz4FO4zjOOgOEDz/8cLbddluAXi2zixYtAuhRh2bixIlsu+22yftr49vf/jYAzzzzDH/84x/Xub6l7+Q2MyJItRfZsmkFY3NrTNH0lGjTQDF06QyyLCs28W5nKwvXtLLGz9EdeJSUQ6AllVjFihUtNlyYIuyxMDSizJG6EpeZ+ttjcUK8aIljQjOueey5IZ6rzF9H4bqVuE7HNYuQGulEi6uQnkK4UWxntODoShxnJC6FhOaWAq2tXUwdv4wp45czcbPVNOar3fi0hqwbMLq5i9FNXYxoKFDyXbrLHkXf7ZmgJ7Za1ly4JxZbYotftQitjbnUGpa0N/NeRwudQbaOoK0IWR1KVBzfl4r/E2G0BFFG2BATgxliXguEeTwYJ1tdtDneUVlPbbw0I3dPHVnt1qZwdVr79Y7A1O2MLYlxXGrdJqtFflogmcyvZiE1R3GcZpIpNhaNsd9qZOmMrcOVYxvHpZKMrWpOatZLhGgq1lMKTUtLgREjupgwZjVjR3cwoq0LJypnMqq1k4mjVrP12KVsMXolE0e248kQFVZiKYMgWnyHIIgWP1rKqceBQ+ib9ULfIQxS8ZiBJAzMXx3I5JyLFx0vKrWEMrUIykWPUsGjXPTwSx5aCbq6s6xY1VR17pdDh3JoavBWz49Ijkt8TnQ2efx9+/E8M6INb2KWzT83klG7NyKGjX+TxWLZFKgf2z68luFIZ2dnEuM4Y8YMJk2aVHe9z3zmM7S0tAAM6Fp/zz33RGvNRRdd1CeX1/nz53PxxRcjhOiRjOjFF18EYOzYsX3uf/jK/T5SLpuL3KlTp/a6Tmtra2IFjOvEbCiamprW2s+YMWMAYzZPs3jxYl555ZU+xa2eeuqpySSfd955KKXWsYWlr8ic+UgEZUWo48yQssZaI0w2zcCNLHTG4lEOHWNRU04qJgtiR0hFJYlIqKQRb5FFxREKzwnJuwENXpmc65N1grrWSSlMEfe02HSkiiyMylhUY4ujNAmBqh9rMl5ALuOTy/hkPT8pg1Ipl0KVxdPsgk7a8CJx67ohPV18jTttLJYdoYiTsISR1SVNzjWlGRJDTq1lU4tEiJq3RXJM/dChu+wlCZbiJExrSlnWFHO0F/N0lTIUyl4PgVTltqkr4iZJyBMt1JYh6f/p1WdiAyDRXx13Xvs8EaGknq/nQKuEGtR1z6w5XtXWOZLzSsqU26+uGnBqx2rbTVkqWft6aWGc1DCNdz5lCXSdEM8NyLgBbpScKx5Nxg3JeT4NmTINnlmynlkvSXCUvukRJ+xJWydVnSU+LqnyK0kZlvicSycuql3SpXHibVPJguIyPCahUPVPd7HsUSx7+L25gacRGp1zWDiljSdoZun8kLad8mxx7GiatsmuZUOLxWKpMOTlS/qwDEcef/zxRCPst99+va6XyWQSoff444/j+/0Ldfh//+//ASafzO67786vfvUr1qxZ02O9jo4Orr76avbYY48kgeo3v/nNqnXieM+99tqrz/1v8kJz6623BlhrTZeOjo4kG+w222yzwcbyyiuv8PTTTwMkls1ajjzySADOOussLr74Yh577DFuu+02DjzwQLq6upg5c+Y6+2loaODss88G4IUXXuDmm28elPFbQEcJMgLhsqjQxrJSE92hR6Bl4g4bakF7KcfqUo5VxTy+MvFQhcCj2zfxgOXQrQii6MtOKUF3OUNXVKYDYhdUTd4LGJErMLahg0lN7Yxt6GRErhtHGBFaa9XMOAGtmSKt2SIt2WJURy+djdYsnhNZN6PFjZaRzV2Mbetg3IgONmtbE2W1jNxvXYV0FcTZa2MB2tdvizoXunGCHz9w6CxVZ50d39jBiFx3xZKZEpKJZVOlfjxU5XlHIcc7K0fQVc6gEYxp6aQpW+bt5SN5dekYnn9vPG8s24x3V7YShrISW6iMNSltGUsslzUWNBlGonO9z6b1JDpmVaJRYiyYKctm+nUttbF6StBOtMi164yEeIdiy2E6+26PccVxhrEwqsyHdDSZXJAsIoqFjOeqvmtrTftpIVrjLttjUZU5IkxvI5Ldiq38bnSjI9llDQ2eT5NXptkt0Zop0pYtMKqpi7bGQnRuVQvIagukRKUsk/Fr6b+JC210viUWykAmVkx01E+tRbOeeFXp451yw00dv6WrWli6qoWuQlooruOMFdC+2yj+eeRWPLjtZFa25Rl/QAujdm9Y+3YWi8VCz++k4bcMbP9uvfVWPvShD5HP52lubmbrrbfmS1/6En/7298G1O5LL72UPO5NK9S+HwQBr732Wr/6O/DAA/ne976H1pply5Zx8sknM3LkSLbddlv22Wcf9t13X7bddtvEM3Tp0qUAfO9736vyvnzzzTe588470VrzyU9+ss/9b/JC88QTTwRgxYoVXHXVVXXXSacHPvnkkwe1/+7ubl577TV+8pOfMH36dIIgAOD000+vu/6uu+7K6aefTqFQ4Lvf/W4S4/niiy+yww47VLn5ro2vf/3rTJw4ETAuyHGcqmVgqDgTo5RJEfZy6KK0rMQy9oX4blqdL7rYLkdklapIK40rFJ4IyTtlGlyfJq9Eg+uTkUFiqTQ1I00Zj5wTkHfMhXOTV6LRKydLg+eTizKxVsV2JvGhJDGhMiUoRWQVq8R26mTxQwc/cOksZOksZOkuZnpYVzQmlrVQ9szieyTxZVB9kQzko/1sjQRzuhRG9eETPZa0y23VGLRI+qqyXtYONPqbjr+sWzZkAxLpuB6LTrvJ1qNiOqzOUlu1ff1d769qdt2QbNYnmwnIZgIymYCMF+A5ITJdHzU5hj07EoCbCXBzZpGyx0T3jbT4TL+sIQiN5bwYGEtfqeQl8Tq+kpSVQ0m5kQeCRKcPXq2wjUzG6aQ+1dZI81zXll9JC+34vRrBXOW63aPf9N90X/X3Wddbd10Ic3OiO+/x9LgxLH5P07ZTAzI/PF3OLBbL8GHoheS6l4Hw4osv8uqrr1IsFuns7OT111/nf/7nfzjggAP49Kc/TXt7e7/afeedd5LHvbnNxkyePLnuduvLhRdeyG9+8xtGjRqF1powDHn11VeZN28ef//733n11VcJwxCtNaNGjeK3v/1tj1wzW265JcViEd/3OfTQQ/vc9yYflfG1r32Nhx9+mJtuuolTTz2Vp556isMPP5zx48ezYMECbrjhBm6//XaAJMvrQLntttvWank888wz+eIXv9jr+z/96U/50Ic+xH//93/z2muvMWrUKGbOnMkFF1yQ+GOvi1wux3e/+11OPfVUXnnlFX73u99x3HHHrfe+WKpRgbk601KyqtCApxR5zyeICq0nmStjq00f25XSXB1W18w0Qk7KyuOsE9DolsjIkFAL8o5PSbl0Bx6FwMNXDo1eGU+GtHhFXKEQQuNH7rolVUkEUgpdSspldTFnLKzRhbLSwsSHRqOXQiMdZa5NUxlChYwtU5XXuruzdMosi9aMMDsWJxNKfZ8LTEbdUuAmbrXp9xUkF8ECGJXppNl1yboh761pMcI0ejexQEbUvUMZXWTH8RgqFp9rm5BYLESWvNqMpxv1MruO+6uO4mLTVsdk3bpEZTwkCISxajpEGVbN/unIKqujtat+g9P9128eEOTzZXKpmFylTC1ZVyq6yxnKgaysHneQFpxKIBxFvq1IbNos+g2Efv/uecYJg7TQ4EDs1lvwPURoDppfcil1Z0CAlIqC70V6srKzYXqsvZ07sXhM75NOvUe0XTx3cUxqmDoWiZ4VEKYOenxDJ9mxqBNRsWaCRsj6E9TrBVW9HYnbrtkmbHR5fr8pTH91ASN2bGDFP7rqt2mxWCzUvec1rIjHVlujPpvNks32HibQ0NDA4YcfzoEHHsi2225LU1MTy5Yt48EHH+Sqq65ixYoV/OlPf+KII47g3nvvxfO89RpX2m01DrfrjXQJlc7OzvXqp5bjjz+ez3/+89x+++389a9/5YUXXmDVqlUAjBgxgu23354DDjiAz3zmM+Ryubpt1CYt6gubvNB0XZcbb7yRI444gksuuYRrr72Wa6+9tmqd/fffn+985zvrVUOmP+y4445cffXVPYJn63HyyScP2Lp6wgkncOmll7JgwQIuuOACvvCFL6xX+mJLT2LXWdfVjMgVcDPGTbUQZCgSiTWhjZtnvI0GLUSU5EYkGSCBVPxiKqMspGr4mcvdQEsKgUfgGeuKg8KVGuEWySgXaa5acUIdCcyQvOMnYtGRKrGLmrEJNCFCgOcoICTvliOhISiFLp1lx6yvhMmCi0KJirBMBKYiUShCR8KYSn3KSuZajecq2hq7caWJOS1H8atrStkobrXnBbGDxhPGQpu4OabcXtIlJCoTZcaUz/g0Zst4riJQktWdDRR9t2ZdkQif5OUkAQ5VlqIhteMI4wabiMyq92r/ahraCok1sNSVwS+YH7skfjN2oVVmfREfU1mvPSoqtLZvHbnH5n1a8gWacyUTd4ugy48EnNBknBCtBV1uhlLZY01HvqdlrnaferHQrRc6EtdKgzSCutiZTT57Krp5EtfIbF/TQKdUrJJhcgPEVyaBT48bFFVWwpSArrJ21uxDlcDGCEqie1OxUAyjsjqp9ZLETzJ1V0Gl7sggzIeh3klab94iXFfR2FAyMlhDZ3eOIHDQ5ZoNBJRdh8Uyy9itAys0LRbLWhkMq+GGJB5b2ioIJrfJ+eef3+t2ixYtqltKZMaMGZx22ml88pOf5F//+hcPPvggV155ZRID2VeKxWLyOJPJrGVNqgTx+pQU6Y1cLscxxxzDMcccM+C2+som7zoLJjby97//Pc8//3zd9+fNm8d1113He++9Nyj9ffzjH+e5557jueee44knnuCmm27iqKOO4tlnn+WLX/xiUoB1Q5PJZDjnnHMAeOONN5gzZ85G6ff9TGzRdF1o8MrkPT9JVlNbEiFdOkSAKXkSSvxQEqYscWkXVfMCkMhC81hpgR86SeIhKYwbbU76ZGVA1jF1O10ZknN8ck6AJ0JcERp3W6lwRRhlyK0sroxek4oGz6ch49PoldEayqFLMXAph46JzYyTucR/YyGcdqOVsdqsLHFpFoQRvE25Ei35IiPy3TTnSqZ2qFjb9bGO9jfsUS5Fpy/moeIWGJngMm5IU76E4yiUFnQWs3SXslS711IRCfFjTSXrabz0/7QZHFIWzeR51XuRKy3mfMo0+GSbymSbyzjZsNrtltShkil936vha+1KT0iNmwnIeSZZVVOmTHOmRNYNyDjm89Hg+TRlSzTky+SierGm8TqdDuat8DrtBCUXv+jhl1zC6AZQPJZC0aOzO8vqrgZWd5q6k12FLMVypneRGT+tcl8Vqay3onLAE9dZ81foOJmUqMpwXHlMJeuvqtNHyg22P4fMkYp8zsxLvqFsskzLOgnkonNnmZvFa3LIjrE3LS0Wy1rQm8CCcTltb29Plu985ztr3a211ascO3Yst912WyIQf/7zn6/rKPUgbS2ME5r2RjqxaD6fX+++hgObvNB8+OGH2WuvvZg7dy6TJk3i+uuvZ/HixZTLZd555x1+8YtfkM/n+d3vfsfuu+9eFYTbX1paWthhhx3YYYcd2HXXXfnc5z7Hbbfdxu9+9zveeustjjjiCH77298Owt6tmy9/+ctsueWWAHz/+99f50lrWTs6uv6SDjR7JRrdMjkZ4EpVEZdUxJWASu1KUm6xKeFWcZPVVW6yIrIENXo+Da6Jp5RCRxI0GkfcHjqJy3SjWM1ASwoqQ1eYoSvI0BVmWeNn6QqyFEM3KbEi4wywQiFRUSkVI0JN5lpjfUySBjkhrqNwnNAkCUolCqrU/kxpopT7rJTKxFy6JUZkCozMdtOWKSSW13qs9BtZXmpiebGJLj9TVacwtmSmg/vXlVWuKmFQEhsnEkGglUCEMiphQuTiuHFJNIQE7ehoIRGSVQfYVTgtZZyWMm5zGTzV0+opMK8lSYNqFLRI96Mr1rNo29gFtcqFOBls5bVQm1qlvpL4Shr37MClFLoEtYIyLcZiMRWC9iXF5XmKyxooLm1AldbfFafSfmVJ6m6mYyFT61bFV6abSLuHp99Ya3+i57q6so9JMqkwNZbo+IpexlclNnvMQ0psrkOki/RY17ZSnfNHO5olk5opIcjsN2ItDVgslg88wyAGc63xmdH3dEtLS9WyNrfZvrDlllsmHpKvv/4677777nptn65NuS532K6uimfJutxs15cgCFi2bBnLli1L8stsCDZpoVkqlTjmmGNYvXo148aN47HHHuPYY49l7NixeJ7HpEmTOOWUU3j44YfJ5XIsXLhwg8YxfuELX+Doo49GKcVpp52W+D5vSFzXTRIIzZ8/f0BFXQG01u+PJd6fdeyTkKJqyY2M6mgWQjwR4hHioJBam2t4XSktaZJ96ug1TdrzTSavRQI0fq51YhCMX/Nk1JcwYjb5gkxbM6J13agtoU18XBDKpKyKKSrvEoSmUHGcrTLuN10WU4LJaIvGQUV/K48lOqnzKSNBbCyPkZYR1aIz2XfAQ5ERIVkRkBUBeRmYOqT0vL4FTMKWaAlDp1LqQosqS6N5XPMvukCPLUHpPkTqh4bouYgEiVAgI2tTbULXjbKI6iV+o/o1M9FSgpMJcTIKJ5MS/mmRFbUJukdfxO/JSl+JG3f8V4OMj1+NQEm3pVWUdTUuiJ2qPamr3JHTeldUL6EgLLqobg/V7Ro30gEdz9p5r9LXdQ3Fa1162bZuPzXPZbKfvYyj17GJmjai49ZLX7XEryefzR77ZD5Tcfbk2vfS54Nq9lg8qpkRI0SP78cPzCIYcBtV8zPU+7Oey5D/ftulX8vGRte58Tvclg3F9ttvnzxetGjRem2bTgC0cOHCta6bTgBU6wLcH15++WX+3//7f2y//fbkcjnGjRvHuHHjyOVybL/99nzzm9/k5ZdfHnA/aTZp35h77rknmeDTTjut1xqUH/7whzn22GO59tprefLJJ3nmmWfYaaedNsiYjjjiCG6++Wa6urq4++67+cIXvrBB+klz7LHHctFFF/Hqq6/ygx/8gC9/+cu9BvKui/b29iH5worRWid3eISod0nVN1q0udjSWtOxlsxgo6eMqN5u2xyNuSxtIxSjVYYgkJSViw49csozslGTxGgqLU3pDqL4yGhBGEtJjIiuFNOutw4aoTVNoYfnBHgoGkNJhgAvNAHggXaQysFTHjmhkGgaQ/OxLYUeOsgQhl5y0dikHFNLM+Ual1EuoZLIYiNEF6EZ7aCEIEREWkVG+wDKifZRpfYttY9jyNCaLyCiWLKuYoaS7yIAT3lkipD1yjTobpqEQgtBrtmnGMCSjmZ0zaXy6uVTASNimpQkpysWLi3Mf0Z3iijpSgWnkIFyqznGwGahU7EIi7iBeBIqjQohzUVVpqew2tDEY4utivHu6h5qwgxMuoqMZ6zSOTegnFEoJSmuGYGOxEhDINBepYbiGNcDJ2X9UkRSpmI1FbWxhMJYPWuVzCQ3KsXTmUMWmikJKEVtuCmfXI2mDDha0BQKctKJ1I9I9RELHrFuq1tfiY6XJnX8nLSi01Xr1VdqqYEkqhpz/tSuH78O1dbTeD9V6thiLIXUND/G8ZKmerSfKE5S8Zqp1+qMf6LMIZLbxtp8VuKbNYHGWR27XAnGBI6x9Dvp+U/thwA1bhSb+RDuqikv/2BlNBdS0DahGUQU99tP5NsSQpCO7PE7M9zpbzbNjcFgXSO836hNeLMx2FRiNDdM2/3/bkiL1HWJuvh913XZaqut+t0nwDnnnMOll16KUqrH+LXWvPzyy7zyyiv84he/4Dvf+U6PrLP9ZZMWmmk32F122WWt606bNi1JEvTyyy9vMKE5evTo5PH8+fM3SB+1OI7Deeedxxe/+EUWLVrE1Vdf3Wt5lXXR2tra58y3G4L45G9tbR3Yj0i0rRCC1tbWXldb/vaqyiauoGH3Vpa83c2KsEDOg5Lw6AqydEuPouNFbp2RwMSIsVCaL9swEmNKmDjLSqrVVIbZmqyzjlAUZIm8E5B3fUKnRNYJkZi4zaJy8XEo4ZKRAVkZILwSWgu6pUu7bqBTZyoJgJzI8pkSmiXtokQkMyI3XCWMsCyHpgaoqlk0EEbrBMLYZZUQaCVxpSL02hGOmauV5UY6dcYITR3SFZZocwsoZw1ZGSCFpkiZznKGd3Grv/w1vF6OiiEKoqy36Uy3kWhMCt9Xb0sIRB4f5sZC9CQlonTthXQokCWJ9M2F4Mb+mdQQ1b3UZpiqRiTFwikSP45Q5OkmKwOaMyVK0iUMJStWtxAGNcojZbFaGJQqFvE4ljA2e6UFUfx7IzEX1jUHZGFYiRGpK4pqf29jIaaD1GOqBGaVS+lAEdV/tYju7ieCMxpUvJ6MbnWk9yUlNKXQOI6Kzh1hEudoKjc54se1+5Y61omQjsV7vF2q20V+qSI008cxnvs4a3CyTixYe87RIl1EpESRTgthzFRUBGXNvKTGlnxuPMWE9jUEY32WPt2BDIbu5uPGRkgBWrN8/uoBCU0VquRv+ndmU2Btv5lDzaBdI7zPGJJjUeM1NOzYgGN78cUXk8cTJkxYr2132203MpkM5XKZBx98kLPPPrvueuVymccee6xqm/5yxhlncMUVVySfn+2224499tiDcePGobVmyZIlPP7447z44ouEYcgPfvADOjs7ufzyy/vdZ8wmLTTTGVbX5V/s+37d7QabtAl9sP2p18bnP/95LrroIl544QUuueSSpL7o+iKEGPIv73gMgzEOc0HZezs6ldVx7H7NuA2SN7bNIHZtwsssoRxoCsrFR/YoY5c2bCRWhOixsdxEliOhyXpBIjBjMSeEERrdYQbHUeSFJhSSstYUwgzl0KEzyEbD0zR64KLQmHjJrAhopIjjhqzxswTKSa5X/ZRVEAGuDGnJmGyhngzpCjKmJEo5Z0o71Lg3ah1bE6XJMBtbOlAgdVWMn478ATVQDiXL1jThBw6Oq2hyS2SdIKnwoFTPO6BBGM+3rgjM+PjG4jL1N0GJqgt0DYm7cE/xk35dmG3DynYbi+RaP/59Tlvi4iSkVeLCJC0tll1cqXCdECG1qV0anT9V/kESI86TPnR0OookFlVLbYRQWrOvJRtSVYmZRNRVi6eqTKv1LICxRTUSmFoxeKTFksBYonTN+ESdTaKPaa1JO5v1GdlmLCZaSxYvayEMnOrzRKQbSnUfz2lUGiixQibrRJ4WDugw/g4xx17Exzk5N2rOTC1MFto632f1tL5py4wjEbTE46JyvKrmrHLAXpo8ip3Fclbu2Ij/ZCUd/wcBrc1vw0CEZlV7g9TOxmKorwHWxWBeI7xfGIpjsaHdUwfKhhrbm2++yb333guYeM24pn1faW5u5sADD+Tuu+/mvvvuY+HChXXraf7xj39MLNWf/vSn+z3ev//97/z0pz9FCMH222/Pr371K/bee++6686bN4+vf/3rPPfcc1xxxRXMnDmTvfbaq999wyYeozl16tTk8cMPP7zWdR988MG62w02t912W/J4hx122GD91CKlTNI1L168mF/+8pcbre9NHbdJMumwVpq2zLDsjS6ccYqGRj+pD5iRIVkZkHN88o5P3jVLzjEZN2UqGQ7JtWLFQiUioRcn88k4IZ5UqdInJFbFtDUvqQepIS5D4msHXztJXU9XmHhIN8oym85kG180xhljk0y0kdg04/HJOiarreeESXbdSqZcHbn9xm2Z8fqBQzlwKPsOSlVHOWptEsZ0lzN0lrOsKeXoLmcpRvUxe1wU1+y3aYPqu6W1dyZjd9oeyj9eRPUSH5L036EgOUy65nnq/Vo06FCiwtQ5UrfNXp7XWy85JLr+ur1RKyz7iEhblDc2fZx3KTT5jG8W12SbzjhB1ed6rfSYU53cSNDoatdoND0CL1Prr9O9t2Zn4jI/DZkyuYxfnb1Z1Dirr21fUuNZNKqJJc15Nt8lS+sBrZCxF/UWiyVFr7+/w2hZT/785z+v1XC1ZMkSPvvZzybGq1NPPbXHOnPmzEluhPRWRuXMM88EjJHs1FNPJQyrQxSWL1/Of/3XfwEmC+4JJ5yw/jsTcfXVVwMwZcoUHn300V5FJsBee+3FQw89lCQZveqqq/rdb8wmbdE88MADaWhooLu7myuvvJJjjz2Wj3zkIz3Wu/vuu7n99tsBmDhxIjvvvHOPdaZPn56I0bfeeospU6ZUvX/99dfzmc98pqp4ai0/+9nPuOuuuwDYYost2Hffffu5Z/3jqKOOYqedduKZZ57h0ksv3ah9b6o0b5Vls32bUGXNynyB7IVZtsmtisqJBIkoi62Q8QWc0oKycukMMizrbqYQxU3GGWnNFaNZ1xGKlmyJjAxpcMuUlUMpdOko5wiVseSFWlIMXWPVk1AbxwjG8llUHqEWZGTICK/bCF/HRyMoKYcuP5vUiTcClUSQ5hzfCFMZ4MkArQWtXhGlBSXlRtlEHdrLOUqBa/ZVEsWSAlondTaXdzamhHFljPGoO4tZOouZtPcwcXxrrUhRoUx+EJISKtF6uuZvpS2S+oRJ9zq22vVmmqv5u5HREFmCI4uwrDkUov7QtBIEXR5lrelqyCSvaaqtkhULVSxiKqaqWtdcLbURf7HbrqJ3AVITF1sRSnX6T/+413MBgA1z/FMiW1Ox2OrU+ZfcVtXx+FPjFJqMG7LF2BU0uGXasgXKyqXge7wrRhjv7Nj6V9WfJn0QjMVSVAvGekJVYqyaqYNhnBDiD0LNQVpbnKmAzcesoCVToqwcioHLW0tG4wdusqsIKp63ydzpnjcM0sfLhX9uPZqtFqzh3+RqRm0xku6FPt0Ly3S/UyboHIJ0zRaLZdjwfozRPO200/B9n6OOOoq99tqLKVOmkM/nWb58OQ888ABXX301y5cvB2CfffapKzT7wgEHHMDnP/95brrpJubOncuMGTP45je/yYQJE3juuef4wQ9+wIIFCwC45JJLGDFiRL/6AXjooYcQQnD22Wf3yS2+tbWVb3/723z9619fpxGvLwyp0HzkkUd4/fXXk+fpoNinn366R13I448/vup5W1sbZ599NrNmzWLNmjXsvffenHbaacyYMYMRI0awZMkS7rjjDq655hqUMj+Kl1xyCVKuvyH3xz/+MaeddhpHHXUU++67L1tttRXNzc2sWbOG559/nhtvvDGZEM/z+NWvfrVBXXTrIYRg9uzZHHnkkckHwdI7Tz31FOMOaqEjCNHNq2ma5uDlA/KRIIvsc1FZEOOOKKOrtVBIQq3qut7FiPTFr66EydUj0JJi6OFKk/Cn3nqxHcuPXGRj4RvHerpCVFkyNMbTLuOESXxnvH5WhGjAUZpQCwItkY42IlSEBBlJIfAohS7tpZzRLUma09QXeM1AddWD2pIRlZqWPTZKv5d6P3GXVWkrZ/RmrQDqMYhe6OedzoEQHY5qK1YdvEyA12DulGoNxe5scgwDJekuRjEaiTtkrfKp/zR5LfW6Ftq4W9WKsHrzk25T93iS2jZ1XmgqJUfixxvquCci21hPk1jT9JIWuiJ6IdnOjFsI0EKgtCRQkrJyerpfxWI+EfopsSnomSQi/R0RH7Y4NXVvx0PU/E3aMW3Vesk5QpNzfOPVoFlrOaGqY7EOlJS8NrmNd1vzTH12GaM2l4zZMoMQAqU1vhKUQ0GgjAu8HwrEkiLy3SJhQREWNWFR4beHQ3aDx2KxbEDeh5/rd999l5///OdrrZF51FFHce211w6oVMpvfvMbOjo6+Mtf/sLf/vY3/va3v1W9L6Xk3HPP5aSTTup3H2CssLDuXDZppk2bBhgPyYEypELz2muv5brrrqv73h133MEdd9xR9Vqt0ASTRWnlypVcccUVdHZ2cvHFF3PxxRf3WM/zPC666CKOPfbYfo+3vb2d3/zmN/zmN7/pdZ0JEybw61//mo9//OP97mcgHHHEEey66648+eSTQ9L/pkJ3dze33HILq8a7LN07yw4j2/GEEWKeCBAY8ScEOFolF3xSmFhMoSEQa7ujX/3tW10bsiehEijtkovqZK6t3UA5SDQhEhnljZVC4QiBFCq5aFaY8cduv1kZJGLVESpxjZVa4iiNFCGOMHGVAB1Bjs5ylo5SJYOxqHORWiU5etm/tMCsPQbp2Mu4dmYiyBKLpqjUF0za6p9wEUN5Bza2svUiNp1sSENrETDxrKVCxuy7MOdIoWSylaIrTtLRC1F7qddq56qeaKm6EZBaqHm93iFLC8s0tcJSiapSLBuMlJAUCCOkpcmGm8RLVo1B1L1JpDUEWiQW/uqbJ3UQNW+mhGuP9WrnoK+kLKj1QrGk0GQit3etqbtONb1Map191J6mc2SG5/aazOiRa9h81HIal4V4nbBiSTO6IPECRSYIyQeKbKOHu5VbFTOmfE1xmU9xSUD3wjKFRX7PjiwWyyaFjupSD1f6M7brrruOBx98kHnz5vHmm2+yfPlyOjo6aGpqYvLkyey999586UtfGnDcIkA+n+euu+7ixhtvZM6cOTzzzDOsXr2asWPHsu+++/KNb3xjUPrJZrOUSqWqmpzrIl53oDVHYRN3nQVjxfvJT36SlC955JFHmD9/Pt3d3TQ1NbHVVlux3377cdJJJ7HNNtv0u5877riD++67j7/+9a+88MILLFmyhOXLl5PL5RgzZgw777wzn/rUp/jc5z63VvfajcEFF1zAIYccMqRjGO68+uqrrFmzhvkfbcFTARKNryVKmSyrCCM0AyUpKZfYnhhbG33lUAw9Vpfy+Kq64HzaWAJGPHWWszhSU/CjEilA1gkQDkihCLWM2nRN/GWUXKfn5aC5cFYIAiWRSfkDs5YTXYgao4pCIBJrZkZWxx1oBEEU71lSDnlHkZVBZMGFojIWVhFZvuKYUpEWgaSuTWtjB9OD1yClJpf1e2wvqIjNOEZTpISQ1iRJZHoIo/VlYwiedfSf6GdIhI5wNE6Tj5fzcZ2QUFWyLQmpcfIBQpq5DcsOOkxZiwVksgFexsyvDiUUM2ZzqSviXFYfdzTGhVdTSURT57hU3FBr3qyjVUSt1VmzcURmLSnLZkVskhKBOvE0gMo5GCiJxiPUko7uPO3d+WguqD52UHGbrafZ0scqfj+eD6K/qmbDtNUzPo71vCXq3AhY2dlANo4XB0a1dCZx3EoLglCypitPqexWz09fiNd1NUpC2XMIJ0oEmjeaWujszlbaDAW5+WvILuzC1QJPaDKOoi3r0zxR0DQhw8iPNtC9zGfFo50UF2+4IuEWi2VDsxb3nGHB+o9tv/32Y7/99htQr8cff3xdw1hvfOELX9igpRCnTp3KM888w5133snHPvaxPm0zd+5cgCRWcyAMqdCcM2dOD/fY/jJt2rTE1NsfHnjggbW+v8UWW/DVr36Vr371q/3uYyCsz7H65Cc/OaS1MDcF4sK3XjuELeaiPtQOvpKE0cVaqE3ynWLoJSU/4soQZeVSDF26AlNaRBBZOwGo1LGLRWUx8BBCUxQm9tGRiga3kAi5UiQwy6GDL5wosQ+IuhaXuK6lREViMp5us52xdgmMccmVJs40blMDoTYlWEItCbQk1Oai1BOhGROxy3AkhKKrZdHbFWpdt9jUlTwCIRTZjI8ja9qIREhi2dSgZawyY6tYpZ8BM9QfjUhwxAYfrStiUnrGKqWI7sZGv+NOppIoQIcCHchKPCvG5TbXUAZA+RLKkMTgxYKo5qYEUFXqpNfjEs1J3ayGNTcTzABq3h8KUkK36o5N7Xjjz2lkCQy1QEWWzI5CjtWd+dQ5p5P11+p+Wu8UjV4TUpvymNKUUOmR3EmQZF9Ogqx72bU0awo5mhpMhmdPhrQ0FE2N1SjLdSl0KRQzlHDXU2SmxK5jbnD5oUNsj1SI6ByqiOTiVo0Ut2qEwNyww1GsbCnS0FQkCAStiwK2fLidyUeOYM38Eov/tgaKQ/2htFgs681Q3rTtC8N5bBuRQw45hKeffpqf/exnHHzwwRxwwAFrXf/+++/n5z//OUKIQTFabfIWTYulP4wcOZK2tjZaX9IsW93MqlH56BpSUAg9tIacExixqRy6A49i4FVu7kuFFJq2bMGUCdEiylAb0OSVky+4Dj9HIfBoL+ZwpaIlWyQjQ3Ku///Ze/O4WYry7P9bVd09M896duAACrjvIAIa4x40UYMalywq6msUlZDEJO8vGhVBEtS8CRE10bySKNEQt6hojL5qoogI4hIEXAHZl7M/6yzdXVW/P2rpnnnmOfvqmet85jwzPb1UV/fM1FXXfV8302kXJdxgc7HMkKJJaWSsiQnDLIH6IXB1MYO3h8vxNKTSREXW4oyLFsuG/10QUKOMiTSszhZjyG5He0Unb7JY9tdtCtv2qZnDSGYcPFdKmRW+1ueSQsHUypL49etlHPb2j8X2SNV+gMo0jSMXo/Lc2TwWS+PkZULZVhSLKbqbYIyI9UoDxqe6UbkSwiKlZSLrMZYVLt82VWS2SzMv6CxkUcEL+7Hx/GvKnqTK1xyACKZLwsawY1tX3/C7WSZv94Cqx9rdb3GKxEl87t6SA+ewHEJfh8kPfB/WShjFc1wuxNjPGaxcsUgjLbl/ppiQ85RINs5OMttuRsVaSIs1AuMnFPrK+gxTT4HFboPbNqxmaqzL5HjXuWHvqH9CyO9ykzdx4sB/uUiYbzdp97L4XqlVtS9b9RUASTXjYKxAa4kVgpn1GT98xjSrN5YcL+HIIzM2fHQzdiRujjDCoYUR0Twk8Md//Me8//3vZ35+nl//9V/nNa95Df/rf/0vTjrppOhZY4zhf/7nf/inf/onLrnkEsqyZHp6mj/+4z/e4+OPiOYIhyWEEDzwgQ/kzmuvZ9Nsi16ZkCROXSyj2ifQVmJw5iDahvqXIK0r+6GERfvyAa5GpQs/DUi0RkrlB5pu/URqMl9eRGEwQrhyI0KDAI1E79QXZJ0yug0klTlQMAuy1u0z1NY0NeOTsE0ijA/XFTGMt7CK0i4drg6K5f0vxZBl1XvWCIwY3GcgKHWiUpGgvQkXtbu0jX0i1949ZP8BAKRFpaYanEuw1kazI6eqVbVWo8IVdiUtUrpBvBAWJS1K+WXOsQqlDMrX3HRq8ZB2hNf+pKNj6jJEUdSIf3RWDbViaxMK2yVdBwDCh5tHLBOSagGtZfxcmOUImNspMRlyRzdNeE9YkkSTJSWN1NBSOYVV8ToJr2YKT+oqU9g6GRwupVpLvGcCqTPCfbZ1IHlhH9tTY5eDn6zQRrpQ4l28xtYIjJHxPjTrMjauzVg8ssEjr5nlqOes4J4vz0JvNDIcYYRDBvXyYQcjDua27UesWbOGT37yk5xxxhnkec4HP/hBPvjBD5JlGatWrUIIwZYtW8hzFxVlrSXLMj71qU+xevXqPT7+iGiOcNjixBNP5Hvf+x5rr72Dn556BEevnGNVa9GbgSjmi3qRdkumdAyh1VYiDBhpfBirV+u2M/IK9TRbqmAy6TGmcqSPM2zIksm0R1cnFCZhW+5yP60VcVys/KDT+GNkQpPKklQYMquRWAwSiav/qa3AWsli2aC0Mg6cg/qqhGFNwymZLZW7cGCTsKU3QbtMme01YxvCAHaYmVEYc/e9N0hGjaA0gtnZsSXv25B/GZZHp9Jlwj13BRaE35coRfVagE1qVzcOwitSt4SL2IG/u9IqAVZabAIoNxmQKBcmu9gqsaUi76RufwKyZkFr0pkyaS3pzFWGTI2kXFIBuTSSXpmgPAmdavaYTrtYCXk3oeimNcJTO6E6+QCG+h1HZav2OoqB2+mBg4kzDBLgqJ5XC4si4a4Nq+I6ZqBv6ickhvXhMNRKiAhhWdHsMJn1WJNIVLJA22Rsy1osFJkPofX3qLAof39aK1w4dF3ZHDjkeDNn/eoZH74vuGPjKopSVU3EKaRVu4b0x3IIRLoeEl2fmamv09e3FbpzDXqzjdgP42vbSGWYX5Xww4es4jFyG0c+fxUbPr0F219OboQRRjhIYeuTmAchDua27W8885nP5JprruG1r31tNAvt9Xrce++9S9Y95ZRT+L//9//ymMc8Zq8ce0Q0RzhscdJJJzH3sy7rH9hg8605ZQp5lqCt9C6wXr30BjvSaz5O0bGRiRivQgkkBZKerD5WpVFoP5Nv/YAv5G1aH04KQe00JMJipI5K6WC6m8CZB4UyJUHBDH8D5ZU1yhtVDq/UWhyRc2Ucwvg1rOPyVF04sOzPH7Ni6A+L8mHEgWwWIZxuiDpmzJAZUDvwvE4KdndG0u8jmtMYlu67jmBQFJ4zcJ62Flpa59ODbV+uOd6Ix0rrmhOU3T7TmNDXTtWSyvhjVKN6WctvNcYZsmAtJRJhE0RSooS7RxzptMhAAPoauky/7gzpONRQv+5iYPnAtSy1jGR/ubJFSxDWC0p8fTuvUip/PRJpUNIAMkYOGESt3qztm6wKxmI7uixu4sJ99sNkmKmTy50xAKr3xw76augttJ3byhoBunICNmU1U7JtdcZ384xT9b2sf94K7vt/c+jFUY3OEUY46LHc7+nBgoO5bQcAJ554Itdeey3f/e53+drXvsaNN97I1q1bAZdO9shHPpLTTz+dxz3ucXv1uCOiOcJhCyEEG6+cJ1ud8PDvz/GT2xI2PWstrdQ5oxZa0UxKJrIeqXRlRBYLNyvfSpwdhrGCuV6DXplUSli9lmVtWSFgIc+quohWRpKYCEMiNYnUSGuYSjsUVpEbZxLU00n8zlyRdslkyZjKSX1JkjElogITiGzu3XCND4etK5qlcR/9js4oraa0Lg91sWwwl7u80tI4F94Qkmf9+UQzIt+gdVPzrBjrANDuZdy6cXVFmoaoG0sQTYAcIRQhX1OAVTv5SxEUNuP3of3fHRDBGBksPRmUy6wfQxiHHC+solk6WPdGUSZz+7YNQyEEs1vHPQmpkdVa3qOSjjhIYSmFMwrK0pLxVs9fF8nCTKsWBu0mQ9aunmO8kaOEJZWaLC3RhUTIhHquobVhhsHWBgthEmX7fXxIIXSpFu7amor095MqG6+H26C6FiJc+wHCPoxnuXDa2pyFtCRpyRGTC0w0eqxodFAYNvdWcGuRsbkzjvbu0S58WlQeQNZtj7CQy9q9NYQ0+tfhuk9PtekVCbOz48Nn9S39dWjD569P5RycJdrO5MRAOwYnj4LzsPCTXItbxqr3U0O+XvKzVRM88PpF7v/bK9l81SJzP+sOP94II4xwcGAUOntI4pRTTuGUU07Zb8cbEc0RDmvYEu77yizHvnAlD5nX3PqlWXSqseMJvQeuwY4XyJWGVDkloqcTwIXRghuLGSu8arncQMyi8HURS/eR00bSKdOoRGaqdOVOcITB+KDERBiXv+V1DukHkoknvmFAnAiNEcHBMiisNX4URJeB8NeecQpuTyd0ypS2zii06qv7GcNmTRgE10pr+DDchnJ5qaVy5DaSzHo3CEuzOaR+XiA6XnVcYjSzHEx1fnhyWlcwY1mNJddj4LmoSKYdVKNqG1hsX55iWFbtZxgB8LmXyjpSGzYPkwKe5Ljz8GqYhbJU0HN9ZkxFJpV0J22ERSQGoWVtAgAKrci1ohTS5xoHE5yayy3BHMfSHzrrmMyS23gwTHJ/Yyij2wUEgrYdxa3vMDV1WwhXkidENRRaUpSqn3wObK+kjddKCFBKkyaaVGk/4SPRRUq3rNRL91l2jbSekPWdZu36DOuAvEyYWRgjS0vSpHRXOKwaJ6DC62F9NKDWD+urYAq0vesx2LzaZzN+1ga2SRNN2izI10pum0pY96UuRzxtkrHHTTL/kw7dHy+it+NKKyTOnGmEEUbYrxDVEOSgxMHctsMJI6I5wmGPYs5w1+UzHPH0SR6aCbZ+p82GeyXdVxxHvq4gb1laaUmmShbzDCkMY2lFmIx3ijXLzPg7J0mwRmIK5147H0w/cKGnraRkLM1pqsI7x7qBbQinbXplTwKZLEl8+Gw4YnCMNSIYGCkXfilCPc5KlYwmM0CnTAEX4tstXckWY1zmqKmRzHCO/XmYbn+p1JFo5lL1D2ZrhCpRhsnJzpI6mmEwKowLrduhXWZQR4JqaYTPw9zBdvVdBNKlfFukJ40Dx7a1/90zS9+isL7A1Wysq021c7Sp3S7ZiQqWdey210vp9RKcb5J1yha+LAYaKyFplGitMFpiNVgjyLVCFik9ldCzCaV2QdTRuTYol4FsRumt1pCDiWiGY4cyLHvahkEStCTUNSibVX9PTXRRUiMFLHQabhKnRkTrbRU44pQoTSPRIKqJJCUMPa3cZ6nXoGMtUhiQ0oWwG7cTN18RChT5CyKd4681DL1/unnKPVumGRvLGRvrLZlQCkZTQ5XQne3T2r3Tvzx0hh26r6j6+/MabH+WlkxMdBnLcrIjLfe+fIJNtyhW/0hz1CkWHteke19B2TbITKIaAtkQyEy6v0qwcGuPjVfMb5eQjjDCCHsZe+M7eV/iYG7bYYQR0RxhBCDfqrnzMzOseuwYq04aY+KBhhU/v52Fn0Hnfxz5Ew3IHzuJHZNsKVx+nZDQ6aaUWrlSFKIW7gYxp84EEiEtwjpC00rKmG9pgXaRUmiJ8oNTJQ2ZdHUtU1ECAoNXIYWhaRXCK6IBQYHUPiZUCbcPi6Bbpo5AItx4WkDuQ3ILXztQ1wilC5mVUcnsq/lXC43tlgkLhSuD0ikzlowkd/RlH1nf0k3j8qFqpdi1H7oQ5eOVxTjoFV7JHAiNHDodul3jlzpBCOqoiNGOS9Sg7SpsS49dasVit1G73iLmchrPlos8ASPoJgm5UEhpydIy5u+Fc8gLRZ4nsaRPrLUphjRquIi24/d2FYNKMwPqtvCfoWHXfGfa0EcyBwkmS6+Fv2YhykAI6x1/bQxVDpM5iTIxD1NJg5TOXTpAW1nV4zWChgCFY43OwktEtS9EI1iIyqlMTLzf3edx2GyFoCgU7bYraRMnhoYpjvXJkNg5g59bUVNS6/1Xn2waWL++G2mXkFshatEQkXS6tnbLhFwrFjoNiqmMW+43wYofbmTtYpuVUxK5AgoNpQGtBXoR9Jw73vpjGxzzsgZ33Viir9m2tG9GGGGEvY9R6OxBhTvuuGOf7Pd+97vfHm0/IpojjBBgYOv32izelrPypDHWrResbzm1qLfVULQtY802i5MNNq1r0J5IEMp611SB1cINRDONdxHCKuPJpnsE6mExZKokla6sSK9MfC1Nb+zjjUPG0pymLUmEI4sW6OqURGjGlCJReuAUBAZXPxNczlam3LZtsqhQhvFjYRXG0kcyQ05mfO0VzUA4oSKZ1go6ZYrKmwhBDA2uIxDTGntY2vc1Mmnrg9VAKr3iiWb5kNgdIDQhqpgDZDOSwYBhympIoFtyCiK6cvaF0zLg41o7ryUKZyA/w0pvWEFZShZ1hlC+rI1Xxd39JTEY8kJRFopuw6majawkzbQL46QKn11YbFIUiecSFitFrXZp//Hr5Hko9ibZ9PuLyvaAmmqF9SHTA2RnR22wVIr5Mlw6PAkTA8JPJMVluNB15XNnET6UXWlaaUGiDJlyIe31ZlsEpTfY0t4Ma0waRzStBONvHRkmpGrOx5HQBmMovII9RHoXUOQJRZ4s47a4nZmN8IUwGJVRsd36CVWb2SHvxckb/zqEtQZhs9bZFhtLs3TKFGMEM/Nj2EJhm5Ytp65lC8S87ZgHbUXf98AvypJHbdrICSe2mUknmPtZl97GUWHOEUbYpxgpmgcVjj/++L2+TyEEZbln36UjojnCCAPobS6576tzAGQrFa31KY3VCcmU4sjNc6RtwcM3CbqLhrmNmtlNJZ35KmxMSJh7/FrmHr8OMZljMuPJky8eL/yA0Uq0dYNS53Qr45hMF24o3c4zR/xK79RoYfXKBRo+D2tFKhlXvVjvc6Fs0NUpi2VGbpxCkEjjCGqZoH0ZDEE1UAanVqZS00x0LNcy2265enymytfEunBLayqyObswxkKnydR4ByktK1cs0uslLC42+/q1LCVbt0z0iSSE55EsCDeYrJsChX61tfV3BaL2t/a8Ty2rG8TsKEc0tmNAnoxqUW15JJO22nd98O5JNLWXovY6HKyvKTU1LqhqE60emSoptHLqeq+B8Uw5nJasHaPRKFCJiU7BC/NNdKncu4MTAQpnHjREcew7/XC9dgeCyqRnCMHsO14IczY1hTOc5HaUVzt4jet/64eRlXIppWXBq8ihdmmWapqJi3Jwf516KTxpH7grsAi0dJ8fLSXSWtZmC6RqDi0EWztjzBcNNznkzYoc+aqduL9vhJ8ICMSzfpy6GC0Grk8f8YyfgfCdJarl9c9YuKb1gwxicFntWtQ/vyGk3Mp+oi+soLfQoPClfSyOSDNAYAcp8uDtlycJ3z/yKI7buJUHPFyw4hEttl3XZvM1i0MaPcIII+wVjIjmQQU7fIbxgGNENEcYYTvIt2nybf2qoVAwdkzGxAkNVt8/Y93xKcWcZuHWHu07c/JtmvZ9PUTbYlsC0mpYZP3/BlFTF52KaI3AlhZhbCwDYqSkLCV5kfhaejDRUIjEkltFjiIVSVQfe52Ernb5lj2tKHRCQxUgnQFRqQVlxw38hACbCULIHtIZmVivqgA1l9naYHXgb6klpZbolkQq53RahvIFte89a4UL7RxEGIjW1he+tqYYZvJRJ4w7+0M3QDDsAMHY7jGGIYzs+0Iw640SS5727Xu5AXrY5eBy0b+xtRWZEMKifL8jw+qB8Ni+Q4C7DlJap5J7ohnNbYadtBj4O/h8Z4jeziAoYbUSLlExG3Ythh1vuWW1/S9/fEswZgpqsRDWlToSAoXLp1bSmYMl0uVhunzp5dxoBG6aJ0wiufzrhipppjkWwbxqIMsQoiti3mf0lrJV+HWcqBpyHtvRK4c1a/i1ErUbcPCztSzRHM5ql6idyzTSlLKv3MkSwju44bBcUwAhuH3Nau4eX8lDv/lz1p84RroqYdN3Fim3jNTNEUbY6xgRzYMKH/7whw90E4Zit4jmhg0b+M53vhMf3/3ud5mbcwrQ29/+ds4777yd3tftt9/OBz7wAb761a9yyy23sLi4yOTkJA996EP5jd/4DV73utexdu3a3WlmxLZt27j22mv72rxlyxYAXvGKV/CRj3xkh/v4xje+wdOe9rSdOt6O+mB2dpZzzz2XT33qU2zdupVHPvKR/O///b/57d/+7WW3EbUp6vvd737cdNNNZFm27Pof+chHeNWrXgXA17/+dZ761KfuVNtH2DGshsXbcxZvz12u5VEpEyc0mHxQk5WPcbb998sL5r9+Ezc/aBUbH7MSmTnFw/owWiFgy/w44wsFD/nRPElegO0iFwrsfElvQdObN/TmNd15S5lXSlOiNEJYZoXhjucfweLjVyLmE+SiZe2Hf46cbTs1y0LiB7rFugabXr+O5s0LrPnYbY7QpJLNv/MQyjUZ5RE5E+M9klrtRq0lWteUTK/WuTDLWvkS3KC4mZQ00sKFCuaqz5l26cCxBmWxQcEMpUkswyJIQUDjyDYide0s5zLKmeU/B/GaQQyZjWVM6mQzvq6Wifjf0p3Vz71a7hcYUa0UBs1h/ztqZCCS4VlQN4UjIX1VFkUgRJB6Q6nJrIdowmSmMKJNzyqKUtHJs+hIbLQgSx0xrdxTXZhoCE3ta1ZqXOiyrhSqPoTxf+jXcE8w5LoP64IgYAUlzIqoNtdJ56C6KYTAepOcMHkg+lg68RpYaauQ6XrJHIFTMJVFKINKXKh7mrhw40RpMqVjiGymtHd9doTRhSTTlyfNwOFdhIBTj7WVKCzjykDSwwiYS5q0yxQhFNpYQPmZaa9w+n3EffpJqSWXoK5UxpWF76vwvq2V0xm4HuH+s7YKoa2Tc11fr+/ISyCsQBQDq1icrC6oyhYNm8Soz+uFENlhGLLcKijHJT86/Vg2tDs8Qsxy/P0yyo7B5Ds56hQwvWKKsZnqGLpt2HzNAt0NI8I6wggRoxzNgwqveMUrDnQThmK3iOaRRx65Vw5+2WWX8ZrXvIZ2u923fNu2bVx99dVcffXVXHzxxXzyk5/k6U9/+m4f57GPfSy33XbbHrZ272BhYYEnP/nJXH/99XHZ97//fX7nd36HW265hb/4i7/Y4T7uuOMOPvShD3H22Wfvy6aOsDMw0Lm7oHN3waYrF0inJNmKhGxNwvTDmzyuO8/s9zvcM55x36oW+dFNEI6kTWwsOPGn2+gKyWaZIUtBc0OXZrdkbFXCimMyhHJflGXbkG8tybeV9LZCMacRQjF2h0Y1OqiORPUM4yJBjQuEEgiJ+6vAjCsmr9tCOlfQOj5j4dacxTtykls6MKMRswX2KEvvqNQNxAUxZLZOMoHhRMtWA2JX/qRfodwpBHI5KBDW3keASI3LgwWE2k5dg5oAwnKPuJ71xK3aPEl1ZeZkBGUI6RP1sbOttVcMKJ27fv416YpBztQXcjjwnozuphppLY20pEmJ1oJSOOfZUJZGG4k2Bu1Lo9RdQ+skr68fpZ8M2IEZUl9zY03JHfzYeyKNAKkMSRYScb0BlSes1gp0MaB8he7yOZ2DoUMinJ608b6ODrzCE0zhzHakdMqwUo5oJlKTKpdLHYmmdERTepOg4PwcXtfvn1h7FoGkKleiqMrkhG2VtBgXSoAWLuJBCosNJU+ApTfE8n1fLV96A9ajB1weZfhghfXrJNPWKuAMY4XDmhImJBxJ7FeoqZ3LkEmEgddLwuW3N2ER3pJQrm1wT5KxoZhi3R3zHP2djUvCiQfnI+qfLYlldktlZT2xSnHM81Zw+ye2Ucz2R7iMMMLhimUsBQ4aHMxtO5ywx6GzJ5xwAscccwzf/OY3d2m7q6++mjPPPBOtNVJKXvGKV/C85z2P9evXc8cdd3DppZfyhS98gS1btnDGGWdw4403ctxxx+1WG+uDj2OOOYaHPexhfPWrX92tfQH88z//83aLna5bt27Z9y644AKuv/56Hvawh3H++edz7LHH8tWvfpW/+qu/4m1vexvPf/7zefjDH77DNlx44YW8+tWvptls7nDdEfYfijlDMedI3Lb/aTN2XMaKh7d46DEFD96yyJ3zU2yabrFqoctxG+ZZIGPDxzfAvJsp7xhbfTlKyKYV2UpFtiohW5kwdkzG9CMUIiTcYWF2wT0VwOPHMNqCtr7khSMIVlsm71vEaos4ImX6YS0W78zJ/usXMTR42zPXs+nZxyAnC2joPsfKaE5iqQhVOKZ1Y9V2npFbV0ezV6pqhR192WsR1cx6XUcr6FPXdmdu0kpifcwlOXrgCAgsVTiFZeX0Is2Gk2U63Ywts+P94cNh3B+JuK2YqrD9xiph4OwVv2iUUiejYWFQfgZlXU9mqhzSKrwzPFKpSTA0TcGYzKO4aqyMYbLgHGzzIokOpiaQmAGyHfvIt8nagRIuwzDAR+xyK9fvIa86NsZy1h41E4n0gs9RBih6CXNbxonuq7Fdofts/00SlDO/XCSuBqlKjM/BdORSCkuSaJTPtVTSxJBY5WvECmFJhHXOst4pGuoE05IJR0LdqQk62pUOktiYQy385zvXDToyQePIfip1vDbKCkf4rfRhtMKt5cXG4Gbc3+eWvtn7GmkavFg2TuZU7rZ9DlzCghpYd1cmTvw2YdJIaOFryNpquXTHryZqqrb3DQ7DPvx3w84OHEViEJnFZrDhAZNsnly5VN3w+xUGTGbRmZusEALWNzLuk6tJpnsAJB3NE76xidWPG+O+/5rfuUaMMMIvO+oTwwcjDua2HUbYLaJ57rnnctppp3HaaaexevXqXQorDbjwwgvR2v0ov+997+MNb3hDfO+UU07hhS98IX/6p3/KRRddxOLiIhdddBHvfe97d6e5nHPOOZxwwgmcdtpprF+/nttuu22P3JmOP/54HvnIR+7Wtp/85CcZHx/nv/7rvzjqqKMAePzjH8/k5CRvfOMb+fSnP82555677PZr1qxh8+bN3HPPPXzgAx/gjW98426145cenY77e/fdoNSyq315X1b6tsAv/AMA0TeIt/3/LYUGtvrHLXu/eYJq8Gix8J8CvrTHO3XYwRe88oxNWssv3vDne3jQfYRhiurBiCEMfIecYFeuz6vfvLst2z0sN6Owr/p/J2cwdm61eiPrH4blt96p0xqyUv0a3fKKt+xU60bYA/h5pJ013Ai/OqvpcJn94r5r177AMccc6BZsF1P1Sb09weQkXHABvOhFe76vwxD1OduDEXvhDhlhL2C3iOb555+/xwe+6qqrAFi9enUfyazj3HPP5aKLLgLg29/+9m4f60//9E93e9u9jbvvvptHP/rRkWQGPOMZz4jvbw/Pfvaz+cEPfsCNN97Iu9/9bs466yzGxsb2WXsPWSwsVM/N8mRyeQq6L2APMrIy2J690L5d3F5QDZgPOhykzVqCfdjOA3J99ne/77PjDUpz+wYH9Wfolw270c0SWEtnrzdln2IH45ADiRCUstfwtreNiObuYpSjeVDhT/7kT/jzP/9zjjjiiH2y/8997nPkec5LXvKSXdrugLnO5nkObL/uy/T0dFTwer3e/mraPsW6dev42c9+xoYNG/puhm984xvAjvNfhRCcf/75vPCFL2TDhg28//3v5//7//6/fdnkQxMTE7B1q3suhxVEdNDbIaGHE4K6affWTHG1437EiFUbVTezN4+3N3EoKJrLdN3ORjkCQwU3aQ7g9dne4fbmNdhpJXNfXPg92Ouh9Bk6lDEYnRGi2WurVPx+6dWU1SZsprVv2riPsPboVQe6CcvCZSl4h+Y92dG997pJ6PlRKPRuYxQ6e1DhPe95Dx/84Ad5zWtewxvf+MbdTjesoyxLPvvZz/JXf/VX3HDDDbz97W/f5X0cMKL5oAc9iOuuu45bb7112XXm5ubYvHkzAA9+8IP3V9P2KZ7//Ofz93//9zzjGc/gvPPO45hjjuG///u/ueCCCxBC8MIXvnCH+3jBC17AiSeeyHXXXcdf//Vf8/rXv57Jycn90PpDCC3/w3700XDXXcuu9uvyxfupQQc3kknJcb+7is1XL/KTxx3D4mNXcr8HbKTRdDmKMwtjbJyZRFg4Wja5W/d26jt8zYp5pic6GAR5nnD3vauwRvCL17wJZS1GCE74h3fH9WNdxFoupLAiOlEOGmqKwR86P8HqUkX9qFD5fL4hdRRFXOZfC8uqqUWmxrsoX7KiMAprBaWRbJ0bc7mNdWOkWi6rELBm1TyNtKSRlHSKlMU8Y3625eoD+ly6aK5Uy5frG8X63Drhc9uCaU2o7yiERSqLFAYlrS+7YTlmcoaptMvRtJhNZuialPmiwVzRZK7XRFuB8aVwjHHnZK1gotlz5jO4fNT/ecFfxuvzgA9f6NprhHuEtgcEx2ABfbVJ63+HIVy3QRfgmF9oGZ/uREOmRlKyaqxNIg0Cy33zU3S6GYuzTURikNnwSSPh9xWus/L9p5SJrr0uN9PSTMqYlzmddViRdbh/cwsNWTKpun6QK+jZlNJKcptgrKC0ikT4vE7h2md8bmUmtCtnhGBLMUFPp5Tt9WyWCxS4+rnaSnKjKI0k1wmlkfR8TdRg4GRtPzm9/gUXxGv0oH+9oO8eEhBzeGM/DKYoGsFYM2ei1QMsxkg2zUxgjHOsju624Zr750ILlzs9zPnWgihdXuZBjfDxlbbK4/bfBTIxHL8W7hVtENCdbWBKxap1czSygumFnLGNmuasJdtmac0752FrLPmMprelpLe55OPXfRSF66rfE885cOe6G/jqXZ860E1YHtYyNzvL9PT0nk2KHnPMQa3cHhIYEc2DCi996Uu57LLLeP/738/73/9+Hv/4x/PSl76U3/qt39olE1etNVdddRWXXXYZn/70p9m2bRvWWk444YQYfbkrOGBE8zWveQ1nn302W7Zs4YMf/CCve93rlqxzwQUXxOevf/3r92fztou/+Iu/4I477mDjxo2Mj49z3HHH8dSnPpXXv/71OyTE559/Pl/+8pf50Y9+xItf3E9yzj33XB796Efv8PhCCN7xjndwxhlnsGXLFi6++GLe+ta37tE5jXB4o5w3zP28y8oTW6z+UZepuQ5yHdiGIPXlHfoQXu8gNGVusUWnl2ENGCOxlZHj9hGkAOHyR4UUVWSvrNax3szD1olNjTj2kZ/B/Q80PUtLxlo5K8farGx2ItEsjTugsYKGKOmWKZvnJpwLbW1/qybbtLKc1eOLKGnQVqC1YJGB8ivCGerUTVkiBlP8aiQ0UYZmM3fXQkBeJs40R1jG0oKxLGcsyWmqkoYpaamCTGnwpKddZGAkWVrE2qidIqXQik6egnXXqO+8/OEFuAF5cDIKUo7FmQTViBzBLKg+CBmmDi1nxDSsL4YhrB+MZbRABvOfmpNuPIeahWmsVUnl2Cs9MZN4gyBhyIQGTxJ7JonmOhJDJiyp0Fh8PdzgQItBCCitjE3UVsaHsc6DtqEKxn2ZFCFsLH/S0SnzRZON7QmMcMcOhNiGz8CAOU+WlZQ6OPj4CRSIJB0sjdSVZRlLc7SRzPUaJIkrlbSy0SGTJRLr7ocipSgUva4zNKqXRAm3pJB4Ay+qSZNDJUAkqPhWOEsiWy2zWlAspOTGYIXFlM5Ia36uRd5IsJOC9nRJpryB06KhcW2PtCdImxmtNSmrHmQRP3QXTAjB2t9bg7mpTW9LSee+Et0+VDpqhBGWx8h19uDCRz/6Uc455xze+ta38rWvfY2rr76aa665hnPOOYdjjz2WU045hZNOOol169axcuVKVq5cSafTYdu2bWzbto2bbrqJ7373u/zwhz+MUaTWWtauXcvb3vY2Xve615Eku04bDxjRfO1rX8uVV17Jxz/+cc4++2y+//3vc8YZZ3DUUUdxxx138LGPfYzPfvazALzlLW/h137t1w5UU5fg6quvjs9nZma47rrruO6663jve9/L2972Nt7+9rf31b2sY/Xq1Xz729/mLW95C5///OeZmZnhYQ97GH/yJ3/CmWeeudNt+M3f/E1OPfVUrr32Wi666CLOOeccN8M3wgi7iW0/aDP14CbrGgVztxUUvcAj7NJAv52MzczzhF6eVOrHjspjDCVa1bg6LLdBual/ztwoP76HoL8OY1wvkIx+BVEpQ6NR0EoLxpI8Ek3tGBYWKKwiKQ1b58frXBgLNLOcibEuk1kXBPR0ggrOqMudI7XXkYwFqba/bqaUlix1xAArKLSNfDlVmmZSkkqNEholDKkwJMLQkIqGL9EhhSWRVa3UXumubakVxoiqbuqwaxPcUAZjbWM5l5oMHc5jR4jkdBnY7dxosWttPB9HIv09EFopqnWqhf5prSyJqJFSCATURBVTC4WwBoFAetVSYgDRF7oq+1rldmgQaE9IDY4bp8LQUAWp0ChhERiMlaRSUxrl2xQUWWJYu+vu/vNRyqD9hEgk1bVzEsKVbEmVZrzRozSKjk5iHdCWKhhLc+abOXmp0Lj7IJe+pmtQ4bEVsbe2KnfjXWvFoNp9MKP+4a032QpMLilLVbnlCsg96W6O5STSlZ+R0iCmoPO0Mea0ZKHXoNSKopDYD1aHMS3F1EObJOOuRmr77oL5m7rM35pjC3vYDYhH+CXBSNE86HDqqafyla98he9+97u85z3v4TOf+Qy9Xo877riDO++8k8985jPb3b5udnbyySfz2te+lt/7vd9jfHx8t9t0wIhmkiRcdtllPO95z+Nd73oXl1xyCZdccknfOk972tN485vfzOmnn36AWtmPo446it/6rd/iV3/1VznhhBNIkoQ77riDL3zhC3z0ox+lKArOP/988jznwgsvXHY/69at40Mf+hAf+tCH9qg9559/Pr/xG7/Btm3buOiii/aKSdMIhy+KOcP8TT1WHGeZ+c872bLpaMx4i/GxnHae9RGiSrga+Ca3AwQEEYSDavvlvvzjALraR+Q1xg94BymvcEqbDeGXteV9ipcfLCapZmK64xQkYGGxiS77LaFKK+nqlFRqBDYSTWA4CRtAbhQWwWLRYLHdYGHOh83WfpT7ykZENWVA2fREY1dGoYVV5CYht4rSSjJZ0FQlhh5HtObRCDKpKY2ktIqilJRGos0Q4l7HIIEQtZshvA6ELqxXJ/l1RbNPfV5eybQIOotZ7JausLTnm/EOyHWCNjVlzzgyJKjuu759C/fesDOsl34JyE3Com6woAsSoVEm1LOEyaRLJkpP1EyQe91p10qeWCtciK1R9GxKzyQURtGCqJ66NhkyqQGNBdoqI5HGEVMrYtisCffFQPubWcHKscpwxlh3/kpqT1Yt7SKj0IqjW7M0VUExoZgtWmzNxyisolOmjCU5DSnJVEknzVDSsNhuuPsXXChtmKAJl9r4+0ZbMPKQIk3CunMK90xVIicQaPru3TJPmNk64eqtJiYSeV348HrtQ5wH7qXvPvBIsvt6ZMaw2uQccWzOkcdkrH0azMwJulduo31XcVgOjEc4hDEimgctTjnlFP71X/+Vubk5Lr/8cr7+9a9z5ZVXcssty5cwGBsb4/GPfzxPetKTeP7zn89jHvOYvdKWA0Y0AX72s5/xb//2b9x4441D37/66qu59NJLeeQjH7nEpXV/45RTTuH2228nTdO+5Y997GN5/vOfz1lnncUzn/lMZmdnede73sVLXvISTjzxxH3apl//9V/niU98IldddRXvec97+KM/+iNWrTp4k/hHOPix9Qdt7v/gBlPrDXcXYHRCoXVFtiJJcN/gibJRWTJGOuJZV7diGOOgbFAhSVx4osUN+oypCJYMiqBxoZGDobcxrDY4bwQIltZVxA3us0YRwxBl24b0T6daaUmvTOgIQynlEqKZa0Xh8+YGf8O0kRRlQpcMYwWdIqWXp5S5ioSqUoBEtQMbGtyvqPUdwLq3jREVGbQ1nuoVJ2M9ccSFaVrrlJdUasbTHGNdzcbCKAqTkCqN0hYjrQt7lHZ7Js0R0ueMqpp6p410NS+H1XkM59V3jXY8CnCTAFW/5EUVHlrfVyCAoS9F7T6teO32jrdUOdVWkJuEnknQQiKFI34WQcOUSGlI+whFUJjdfiQ2RpJahK+l6etp1vrN4MiZ9Td3IIYhlNcpmjXyHE+4QispmG523VtWkBvXTw1V+n25eyPXismky0Tai6e9oBtIr943ZInxap1FkGtFnieUwsYJGRvu1dgGUb9EhxyErU381BHr2lbk2miBMQmlUlBWHxRbhomkGkGtoVzRoJxu0LYwawW/MNDqlRw9u8AxZobVz1lB2THM3lEw+/0F9NwotHaEgx+j0NmDH1NTU7z85S/n5S9/OQCbNm3irrvuYtOmTWzdupVms8natWtZu3YtD3jAA1DbKQe4uzhgRPPKK6/kjDPOYGZmhvvf//785V/+JaeffjqrVq1iw4YNfP7zn+etb30r//qv/8oVV1zBV77yFR72sIcdqObuUDY+9dRT+fu//3te9rKXYa3l7//+7/dYsdwZvOMd7+AZz3gGc3Nz/J//83945zvfuc+POcIvL4pZzcLNPVY9psXK8TZmsiRVGlMKFkWjCjG0kKWa1St8GRkLm2cmKMqEwDyr7/gBVjBACNfffwvGCnplwuJMi/ZcEzVeoBolE2M9RwCNpDef0Z1rVGTNw/hB8h6Nci30eil5kbBNjMdwyr6wS68qWa8yDWLjtilHIDzZcWYquLBhSU2xrfdDlIaJ8cG1dZxC5wa6RZEwtyARdTMgDBZBYSRdnZBKg5DQsSkLZUbPqkhaVqaLCJ97GAhUp5mSJoaFPItEsVcM/CxEkuzVHwHTKxbJspLVrUVHSIxi85YpZudbS8Nhh/3YDyPTQ1RPMSz0Ocxl1KI2gwhlrcDoighXoaNE0hlDUrczCjFW0NPO6CcVLRLpTH60dYRRAE2ZUqouiTCkwoUmq1qSYiClIHzOp8ZRTZdzqa1ksWxQWmfO1PThzaWVdEzmjJ6EO1bpiY5cpjsftGIzq7LFmAd6X3cKgHWNeRdGLTXtsQxtJUc1Z2nIotadgqYP4TU4cr0lHyeRLhy7kZTkWjHbblEWirJQUT2O+7DEXF1RI54HPWqTPTHs15NoET7HNtyQtc9lKSDkxA6715eQVpYYnXWyhFtWr+QXU9NML3RZv7jIUWMLtFYq7v7Mtr17niOMsC8wKm9yyCGQyv2JA0I0e70ev/u7v8vMzAxHHnkk11xzTZ8j0jHHHMMb3vAGnvKUp/C4xz2Ou+66izPPPJPvfve7B6K5O43f/u3f5uyzz2Z2dpYrrrhivxzz6U9/Ok996lP5xje+wfve9z7+5E/+ZI9uImvtThek3hcIx98bbYhDg+3sS8jRF9Egtv1Ph2Mf2GDljGaLFUjqhq1VXqAAH/rnvs+lqKlGojbYFLWXS4Ujn5/m/srAtfz+JNardrYiCH3kZKlqWb3HkLBMgS5U3+s+lcgIfzxRhSjWjI+Cclbt1gfd2fB+zeTHDyyXNm+ZBi8jBErhjICEdK6zITRPWNcn0oaZZb/M+pBN48JnU6lJhQGfj2eRWK92CizSWqStPiaDxYD6m+SIhBQWJSyJcKpdEhS4sI3PCQwoS+XI+fLC9pAOGB7mWm9TPI5foEPf1O7TsH64f8eT3OfXWQrv+Cr8NRNOYvQh224Qpb0LK9JifL+VRlFgKUSCENrnvZqB9ovqHqgRGWH95yYwZCuiEi1wodvGSPe5w11LiVe0bc1IqgaFIcGF4IJAYWM4sBTQFCXK51s2RUmCwSBR1sZtlb+2CkviCbNFk0mNsNBUJUW4V7wTbWlVDBMNn1unyg7KzQc7gnqJK5tR/9zWvsfia1H/G2Zhlv8tiXMvffNM/t5QkrmpMeYnxuluTHjw6i3IVGD1cnvb9ziQY4AdYX+PEQ4VHJBrNiwS4GDCwdy2wwgHhGh++ctf5m5vK33OOecsa7v7iEc8gpe97GVccsklfO973+OHP/zhXosZ3hdIkoQHP/jBfPe7343ntz9wwQUX8KQnPYnFxUXe/e538zd/8ze7va/Z2dkDTjQXFpxKtmy+2E5gKtSY81boy2HNcSt3+xi/zGjkYxxTNNHFOBMyZ5yMMdVAAOtkBsKVhFhhTfyxzmSTUqn+7/agCgQpRi5VO9aaCayF3CZMygbdrIGSCoVmzFNZjSSXKXlSc3Dt5yRLl4XXg6PGmVZ8PebYcm19G7cLg+Y+thIEyCWDStE/EAXvyOkX1h1W43vhfd8nIfy3XopFQpKUTE+VUWFd6GSUWqF8IKbC0rIJDVMybRJSNK1yksWiwXzRIMl6NNIuLVU4Jc1IUqvASqbLJk2TMG4zR9IQ5PSHzhytmlVbffun0GRWs0K7UNDSSKRoMZE03L2Ratas7MZ9bN3WIC+S5Qft9WW7gEZWsHpFL3b6zNwY7V5GIrS/JDbuWuCMkB6xapvPh4S7FqfZ3B5HWYMwllQ75TLBkBhDIjWpmUBiSKRFCeOURj2FwVKqnEQVJKrjSptgliilyiqsSchsgi5blFoxZcbIjMYKaJcZuUmiWqqsoGUka42iMAqDoLDKh9mKJX0lgBXlNNPSKbDaSvJy0qmxjDGuuty/uZUx1SMTJUI3KKxi0TSY0mNoM0ZmS5QwPqdUkZkmBiiFYm2iMEqSJ4ZcC7raeHIsmJtLKPMEhATlSBMWhKkRq0NhsBfmBKT73K9VbmgUPp7xe2DwXh1Uxesh8TUco5p9crSwoprQoOqr5ooVTMuSo04U5FsOHNOc3c5v5oHG/h4jHCqYm5vb78cchc6OsDM4IETzJz/5SXz+2Mc+drvrnnzyydEk6Kc//elBTTThwMwq/eqv/iqnn346X/3qV/mHf/gH/uzP/my39zU9Pc3U1NRebN2uIfTf9PT0Hv2IhF9wIcR23Xg33zYKURoGvabLdDLGlm8ssOFJU/TKgk5UeuBu00Vpw7ZuGbdZNF2fzyiCOOAQw8lEzCWk9t7N836AazR5ryAvQfY0Uhsa2rl+GmPRPSjKigjuHNG0wweHfVKX7cvpq7YdUDT9OcTD2YFlkWCKqk1h4OmJo7DeUEaL/pqUYUAeiKayIN36qdT05GLM15vBUFhHNJ0aZchsSWY0HdGmKUp6ImGTWGRWlnRkl67skghXjqGjUwpjKIxisczJjaarnWupsYJC9xPNu003ttMa1zFj3RJVGMZzpzZra1nolXR1DwQ0VIGVC7Ff70PRMynjY71YnqXXS+jlaVXjcvCrc7vqp8MYPdJ0Jm68UVpmjUEZb4Ijg9mOI5qp0Nwv3UZDuUH81o7kXiQKX7IE5wCbCu2UYKnJlEbiroPyIbSJMC7MVfUoVIFM2m4bX0tTUk3AGCvRNqM0ilyNU+iETlGykM5hhaUjnUmQ9gZNHe1yQnOhyHGGR7lMnKK5RG92x7jLdumJquboXOocbBtJgUw66OZGUrVAQxRYQNuUXjlFt2zTkRMUwp2jtpLSStoq9fVBJYVOfJ3PhFwruv61MYKt2Thdk5F3M0ectED4cHFRm0wZVPMOOoT5nlqt3buLnvtoh6+0uitxn3Dtly9DMgHuznt93xdCezJe/64AVK45duss7WKRmdu6Q/e1P3AwO9jv7zHCoYI96ovdxcH+uT6Y23YY4YAQzXodlrIst7MmFEWVS7I79Vv2J8qy5Oc//zkA69ev36/HvuCCC/jqV79Kp9Phne98JyeddNJu7UcIcWC+sIa0YW+0wxGF5fdjzeibaBg6dxWsfqxg8lsL/OIxR4By4WGxJwWURjDXafZvKBzxCC9sH1mwWMWSQu9bt03U1D0HXUh0ISk6afVjVieTw5RLGD6FOezy1/e1HULjCOWQNweFjNi+AZIZV/AH8n9c6KFYel71damdeu2c7eBDOLdZXUraOsUAY1ZSILHCu+jaBFOmaCvZ2h3zTrOuZmYgl668ifTOoktP1Ybzs7DYbgAwR6ufJNe2sYPXSVomJjskyoVlzs616BZJLa6wflCx/PIahLBkSfUbIr2bsHNpdWGey6rcvp3RnEcItP+ukAj/kGiMDw13JyQQcRsjBKVXHIXP0bQ+VjaaAglIbYkQhqZ1ZXNECUI49TORBitKCqGwBqxJqr7zREdYS1/90gFsK8ZIEhfmmgoNEq/CGu88a0hlSUPkTiE10plgCYuSzulWIyitCx1PpcZY4Wt8unxTjCvnoZQzk9JW0mjlaAS9hSy21fr9hqB0oZ2x0EGtLgSuWJ/ziKHyNSIJVcmksOIyBkB9u68rme6mW5LnCmCEoLNFM3ZMxrbrOoO72W840GOAHWF/jhEOFRwoonkofK5HOLBYOj26H3D88cfH51deeeV2163nOta3Oxjx8Y9/PIYvPOUpT9mvxz7ttNN4znOeA8A//uM/ctddd+3X44/wy4XuhgKjLRMrXOhqMy1YPbnIUStmWTO5wKqJBabGulXsTO0RistXz6uBmVgu1iYM/uNjcBn9oaVDjlsPe+17DMNyimh8XSOBQx+i9qjvdHA/VANLLaoyGsNIVF3NrCmt2goW2g0W2k0WOg3vPGsrJVA4tU4IS1cntIuMTpmSG0XqSUSuE3KTUBrJRNpjMu0xkfViTc1dx5D+jl1gKbVk2+y4e8yMU5RDnOwES8u3DF73weUD0FbSLtP4KI0EKzDGmTENbmOB0rh8USUsU40uR07MkyodTadcCKvwxjr+r1d7Q2iqwf3tmYSuTumY6tG1KT2bEqx/ABSOAI7JnHHZoyFLxlTOmMqZTtqsSheZSrqMqXygyUGRdSSvlRZMZj1WNvtJSGkF80WTubzJbNEiN8rnfDqVckE36RjXLmdHBJnUjKuclcki06rNpOpGopoKR1oboiSTpXsuSxqqpKE0DVWSqZJWWtBMC4SyIK0vM2Qd4VTudb0W5e6ER+9PuJBWpzhi8OostVB3p0IKI6CmSgojfI60qN6v77e+jWaJoVmAzSR3NSdoHZ1xxNMnD/r+GuEwx3Z/Iw+SxwgHHAeEaD7jGc9gbGwMgA984APccMMNQ9f70pe+xGc/+1kAjj766KHlQp761KfGma3bbrttn7R327ZtfOMb39juOtdeey3nnHMO4GaWXve61+2TtmwP73jHOwBntnTxxRfv9+OP8MsDq6G3sWR82kkUWVoyPdFhzeQCK8fbrBjvMN7qxfWXcLugfvqBkqi9XjLxOrjxcgqUc1HZOSK5MxDVk77fo6hQiKVq5sCyWOVhUJ2EflJq/CNsG0marbaJ52eJYbve/KfdbbDYzWh3nTtsveUiKKW48iudMqWnE0qjnFqGc4UttFOhxtKCsTRnLC1QnmjuVFfW+2LYyjWyqY1kbqHF7HyL2YUWpV7mp6ZvUsEvihMV1aO6f/onFYwVdMs0Pkpv3BMU48GSJqGupUEgMUxkOatbi6S+ZqX1JNV4YulIpiOexkr/cITT+H7NbULXpPRMSm4doQ+KX4gBCOG4TVnQkgUNWcbnk0mP6aTDeNKjqYq+9gYDLIRTaxuqZDzLmcz6wyqNlbSLjIWywULZiMcXOMW2bTJ6NiW3Cu2vY4KmJXMmVZcJ1WNM5i70V2pSaWL4cBb+Sk0mS1JPPLOaK20glwj669qGx5CP0kEHPyEUjaE8uRT1CSVbX6+2fICMLp24okZch3xXhNUSyW0nHsOPsxVMPrDBkb82eYBGaSOMsBM40CRyRDQPCexWLOq3vvUtbr755vj6pz/9aXx+3XXX8ZGPfKRv/Ve+8pV9r1esWMGb3vQmzj33XObn5/mVX/kVzjnnHE4//XRWrlzJhg0buPzyy/nQhz6E8UXd3vWudyHl7n3jXnfddVx33XXx9ebNm+Pzm2++eUl7X/SiFzExMRFfz87O8rSnPY1HP/rRPP/5z+fkk0/mqKOOQinFHXfcwX/8x3/w0Y9+lDzPAfizP/szHve4x+1WW/cEoabn5z73ub5zHGGE3UH7rpwVJ42RbZEYmdCdSBhXecWLCKRy6bYuqqwilzbUVxw22oykq/be4A+ECMvs0uPVXk9MdciSkmZSoq2kMJLFxSa9XtK/3bBBr629YWvrbC90NmyzMz9o8Rxq2wZ1s94mT6zqf6M6LJ1bqhAWpQxKWJS0SGGQ0jnBSqzX0mpqMkQ31lRolBJIY1HS1NRRV7pk8HSDY7BzvB04//q5Lekjf8KhS61gdn4stqkoVUWo435q5zt4HFG7KNa9LrVk2/xYXCUPobimKkUTjhcMnJwz8IBuaPGurgKQlKaaflDC1YctjQXpQkIdibQ+r9GVBAm1MnsicSVkbELiyWUiTOz7RBqQBVYWGFGR1kBkhyFy7lpIbh1S2Orh2xVKqiTCkAhNaRVdm8XP5KTqACIacfVsyqLJkNbnrMaSLs6Zd75sUlpJIgyFMJRWYlPnUtteuUivl9Be8MZRxoUuC1srDyItaOINJgB2V1Dfx4guzsZW3wWuwOmQEkU1hEpLgyHeg/mqO8A9q1cgb855yPFw1DMF93117oC60I4wwjCMzIBG2BnsFtG85JJLuPTSS4e+d/nll3P55Zf3LRskmgBvfetb2bp1KxdffDELCwu8853vHFoDMk1TLrzwQl72spftTlMB+NznPsf5558/9L2rrrqKq666qm/ZU5/61D6iGXD99ddz/fXXL3scpRRve9vbOPfcc3e7rXuK888/n8svv/ygticf4dDA3M+7rD5lnKPuW2RrklC2oFyhMEJiPSlUqn+kWA3WXW4ahPFVRcaW3JmitnF92RLGE/6GHYmKkPj3m62cZsOFFxZG0SsTerl7VMcZbICt/t/OGHLpFtt5M4bUBpluYMPtnVuNbAUiVlf5RJ1UhJqa/iGEK5tRGxfXjuEOLr2KGklpbKLtb0vthARVjcSqn3YgUVnfiNqF73RT14ZAlr2S2NfMOjkeOIbAVqHH1imnnW4W2xTyS0PObCy9EckmFEa68iTChZdqX7LEkS7r8i+9mikMaOlIpbYGaSVG2NhmlzbpFE+Mz4kVEiUMBuHNgZzRjhLOtdZdREcACxy5LHEmPHo5ollz0wnlbeqI15/6/WBQ0hkXKU8Mc5u4iQaraYrC3SfSoowBg3fNBSMsiS9tYqxzfe6aFGktyvprZyQ2ce0YH+uCaNDuNJzRlXSTShaL8PU1gwuzsNW1iHllB9PPVU0NEVZgpXUfHenbXC+J1TchNfC3DlMjmDtxrqaVcMej1iOvvI0HHQNH/cY09355Frt9S4sRRti/ONhVw4O5bYcRDpi7jhCCv/u7v4vlS771rW9x++230263mZiY4IEPfCBPecpTOOuss3jwgx98oJoJOGOfT33qU1x99dVce+213H333WzevJlut8v09DQPechDeOpTn8rv//7vc9xxxx3Qtj760Y/mxS9+MZ/85CcPaDtGOPRRzhva9+Q8YGwD6ccWMMJyx1kPonf/afIj7yNNNQ9at8mFG+LyALtFwqb5CRJlaGRuVGQtLLSbGCO2r2AsGWMv8ysRJVVL2ihJm9XoS6il28QwzGEYMuU5qNIGg5BI/oBgdGLjCsupmrafNIfcrUF1VdiYmyl8+KyQVb5rJJTS1Y0UwpIqX2pDOsIWiIYUoLy7bbdMXBikquSQuaLpQ34FBunVUKfkSWt3qDIJQb+yOTgBECBt3zaBOCdKs3blvDsnYMvcOL0ijX01oDWyNGTXHTSQSVPWLrCtTRhYgdHC9SeOUJVG8uONR0ZSHvTBSPCk9M7AMqqckCCFgQQsOk6cSGFoKudG21RlPG7POFfWOaAhSwSWSdWNRN7VMFUs6gYLJmOmaLGoG5TeddbY4JM7cNoIOkVGd4iqqTypDI64q7NFMlkyoXrOHAhom4yuTdFWkImSlix8eRxDaRUa6cu+aBqicLVSMXRshrSWMZVT+Nqsyhq0kF5BNUw1UqwWzCYGKwVW165HELY94XSfJ/9d4Cc9Bt1XDwr4e7u/bXZJG4fOGQ2ssysks447TjmGhblFTmQjRz97mru/NIctDqZOGuFwxkjRHGFnsFtE8yMf+ciScNPdxcknn8zJJ5+829vvKHcS4LzzzuO8887b7WNkWcaLXvQiXvSiF+32PvYUu6JQfuITn+ATn/jEPmzNCIcLNn97kaOfM81xTxtn7qYeCxtzzLTFTEustjCOH+CCoMRaaCQlShkyVToyY4IOtsxgMg7Udu4el4GIAVIZpDLREdUagdGSsvRqlXdVHY5ljjds4LjMLiKHHEY2a2Je3yFF7f0lRGpAVawrm4JIkKq/IZwSr2YRFSOnJ9Wb44iVNjGz0y3vI3f1Bm4H9XOztdc7s6lwSnggmlGtC+2IirU/0OBowQ4erKZiLmmgGHhDkOvEt8Mu+Wtr52JFCGl12xmvkBorMELEyQb3biCtwpczkZHAltbna3r1zu3Tlw6xisJWOZ16CMms2lYLBx5837ch9KfyKmao+xlCaWtX3RdgkX6iyO1R+RDfxDviSmy8n5wqa/x5mrh+IgypJ7lOycRNGg1MqlhsVDDDcx+UEP/2ndjBMEhc8l01cD8N3J7x1hz2ud8NmGbC5sYUN1+zgQc+JOWoZ01xz3/M7t7ORhhhX+Bg+JyOcFDj4K4XMsIIIxxQ9DaX3Pm5GdY8fpyVj2qxxswiryu47scr2La6wZ0PLjnmiK2snFzkyNYCSliOHp+NRCY3CZ0yZaHdiAYrgxBymV+qeohsbdnkVIck0TSS0huzSHqlQmvJzMy4U7Eghk4u2XtNmYyLwmC4j5P4F8OiGWtkSPhQzpiLFt4IzwfragogMUuUQKGsVzI9+ZEuDzPmY/rXmdJIYUiU6cvNE4FMWEis9mUz3ESA9ETOAO0yrQxtrCOvwRTIxJHyQH/1sUl3zraec2tqnRg7ZqkSPAzCk+Vh7KlvggL6y+XUJyisiFG6/Udaut9YrSJsQ8UfTLyeFmttDFOVntRjtSeKGikkuUqQWEqpvHmQoGcU2qpI6mbLlidonmQaRbcYZ7O1tI0zbjKe+A0LFZa1+8T4PNtBQy032VMRzMSHzCbC0JIFqxNXQzPxyYIGSddk9GxCz6Q0vRHQumQu9JrLcbYqfoYasiC1Eo325VFcvmYmS1dWRsOGbBKj3QSPDX0djbBqarN0nxdhBNa7t1LLY/Sne3Ah3ErbcTXaiXmWXYcQ3PGsB9CeXeCkbBMrHtVi5oYDV/pkhBEihk2qHEw4mNt2GGFENEcYYYTtopjV3Pv/5kDC9EOaHPf0cR5Z3MPdtza5bXNC73Ewc9wYK9MOiSppiarwe2mdorJd7GhEWXtfAFI6NUxK62o/GoEuFWUpMdopqEvqLUpLs1EgpSVTpVOOrKDdyzA1R1Qhhh9zOdhanFwf+aqTs/qyQcUz/PUxSLEsjBxu/JNIHcNkVS0Xz6lPVH89gawf1vpwUyWC8gnGx59K6YjVMLOZaAZEjYjXTiu+WSd+2+k0awWdXhaV2DTRpL5kRiA4vSKhW6Yh2DTuFiFiO4YJxkswwH2HrR/Jj/D9IzXNtIyqca6dU2tpBEJI5x4qLRb3Xn2nFu9qG0isUXRFSkenNUVZ0TMpXZ24UNkBpb+uTI4lOVKAie958j3QvyE3M7rz1tZxCqV26iZVndFw3KB4JsLQEJXrbYkrSZP40FuB8/LBupIlLg1TA94NN81ZOdZhsZfRyVP/OcSfjb9Z/HmkjTK21RQSXShsLnwuo7tQVuHCVg+mweIBaotpKDatmmTD7ZtZ+/hx2nfl5NtG7kAjHFiMQmcPPXz961/nwx/+MFdffTX33XcfnU6H66+/noc//OFxnSuvvJIbbriBqampPfLHCRgRzRFGGGHnYGDuZz3uLeYwa3sc82jL9M973CBWsmliFceMzzCR9kildnX8dFZtO0xZDBhCSoIStiRiPJAkvzdtJHmp6HVTilwt3V8QJYVlerpNlpasbHTo+XIf92xaSdfIpb9I9X0sp7gSNvOtkbYim3VlM7C6mlozGBIbl3lyKZVxJi1Ku7xM5XLwUuVKT4TwyD4TIH+ewkKCiYqmtdQMb/A1IwPxTCiNqymJtCjvrLqkz0NX1sODI+NbwnqW7y8B2gi2zY8TyNARK+aYavZY01zAWElHJ2xamKA7l7hQy7qw7VmhC7v0/b384Txh89sP5HqG0OK4D0+gUqVZNdaOauqGhQmMFRRGAcKrnKCkZbF0OZNtnfa5vuKvhcZSWGcOlFv3c2uMpNAZbbLhKqaItwKrGm0aqozENfOkb/CcqzBZ14bBPqjR2VqIr0DhtmvIklSUziDIn0NhFdJaF9prDTmJczMWLpfXIN09al2upmkKSiG5b26K3Cj3mbc+5VcIbHBkxdKc7pIkGiUtnU5Gu5PBYoLI/Xp+rkgWFqG3c0MdRrCJ5IbHHs+v3HobRzx9kjs/O3PQuvaOcJhgpGgeMmi327ziFa/gM5/5DBAisKgM2WpIkoQ/+IM/QAjBaaedxoMe9KA9OvaIaI4wwgi7BGtgy3fa9LaUHPn0KY66bYENXzVseXaTzpEJk40ePZ2wULh6frl2YYVRZJFLB8LVk6Vq2iB6vYRCKgppKLWi0NLngdbaGNXE4ecgceGijUaBFZY8T2NYZgz3DOGf250WDYSnUm4azTKGO5aFouglw3O26s0TNUWq5iSrPPFMpI7lS0IorJKmCpcVxPBYhVu/IUtfjsMN7kPeoCvF4RqhpMXinV+loZlaStOvvtaVw/C80XQ1OFNRGRKFcNyFdpNCy2W6vtYRtQkDCOqsZlwYTGuRVBg6vjbmXKcZcxP7urKe4BcJI31T7dVkhQ/JDKR/J/hLUIKNdUq5dhTQ7cM4Qxyw3kDIrW0xUYUUwt3uPZ3E+pXWCNIhBxf+PgrUU4pg8EScXIn5pAP3UyINLVXEWpdjMieRhlQ4M6KOzVC2pmi67MtKCaUKvZaYWI4FoJCS1CowUCL77t1wH1kELVmwIu3QbSYURjJjx1wIrYyfxhgBkCWaRGmEgEZWILAYWWJLGWY0sEC5mGAKhfBlUUR1uxyW0Ery48YqHrtmM9NPW8Hsf80c6CaNcBhjpGgeOnjJS17Cl770Jay1nHbaaTzpSU/ib/7mb4au+4QnPIFHP/rR3HDDDfz7v/87b3rTm/bo2COiOcIII+wW5n/eY/z+Pe5/dIr99N3c+9DjkK2Uo6dn6ZQpc71mNE/R2itqnkj1IfwaBLFvGQIQCEOnmwGV66h7cxipDLGdLHlPSYuwhlYrR6aGokywpqq5GAlmJJ6V7hRbHx1M/HPj1h8bz2PZl85i5pXWgXbUa0zWQmUjyZSujmHinWVTn48ZylWE5yFfL4Q/gguNbVhNMymiE6krb6HQRjBbyKiipVI7EmpkPI42A50lHCWBEIorGGv1yNKSiUZOJksaqiQ3CaWR9PKEosxibmt0GR28zlTqnfDtToQrqTGZ9lg3tsDm3gSdImW+26zHuFY7sNVfGxRjy9J7rE/5FDuYPAjXuVIvrc8FLo2nVcJihduPEY5IKWGwwsS6m1IEtdTS1pmPO3XdsGJYrnLoD1uZPIVaqDJ2XX8fBmRSM5n0aKmcMZXTlAUKlz8pgEXdRIho/xNzelWknO5vUDgzUZIgomOtC/F15VEwAokl2AJJYcEIVOKOZ6xAKFgsMhBuUsNo6T8u7nwaSUGSGKwVLlQ5KyjHlA9pdydojGCRFqYjkD3paloebKG0BwBbjl3BLdsMD3zgVno/SujeN6p5MsIBwkjRPCTw7//+7/znf/4nQgj+6Z/+iVe96lUAyxJNgN/6rd/i+uuv54orrhgRzRFGGOHAYeOV8xz/e6tY8fAW225O0UmTjQ9xNft63t0z1v1b5kvfuZBqmo3Sl2lwuW+lluRF7SsqEAr/JP4fFKwweK8fJ6pagoXFBkql9NopWaMkSdwgWoqKsPURy77Q1sqApRrj2/7zGl4CsabUihgu25ePGY4bwmYjybQVUQxmL9LUcjSNJycVcQj9IWuuoyGXM8EgpCCTvkSHN68xvlSHa2rlDFq/PraPtNslRGfJ+dajVEV1HSpUrxd7DbRx4aWtpGBtcwGBjSQ4rC9EjSz2uQIN6+/ljlZ/7fIBq7kIR3LyMmGm3Yr7MUbGQ1rhDJSCqZWyEuEVYfdPOkIXu8g9qd+zfd0U1FW/QFkLUjojIgRdk5JbFSdSwmdqECFPtyELJlWXlswjgfS9F59H46iaQhocZV0eZ7gX3PJUuOuQCpdDa4RAWIn2+cHGSqS0lFaChKmkC0A56aIZ2kVGp0jpFgmttCTxObBCuG2EN6VSGP/ch9yKKkrBKi8P++t+uCsVt65Yybpt86x9zipu/eI8yX0jc6ARDgBGRPOQwKWXXooQgjPPPDOSzB0hVAP5yU9+ssfHHxHNEUYYYbdhupa5n3WZfliL5i2KDg02HalcyGZNVdpudR5hSRPDxFiXVGpSZVjMM3qlU8jCj0UgUcYlfXnqVpGrOtkcVB+NhcV2E4A5YGqyQ6uVA7gw1yAwRnJZI4J+h8PcPk1fjlSdgvq/faTLVhJeWD2SzeohZVUbM5GVi6gUzrBFiSpHM4TMhhxN7c9BEZRPE/MGnaIlYs6fxeUdah+iG+uFDl4en3Nqa/0UCH+V61kpf/09wQAxFcQDebaw2MvolglWwnTWYVWjTSK0U8pqZFzUyOUwc9z+nl+6qH7tIlGplasI5DMvFYVuxXtA+vgw40M3LTijG+nyTZEuZ1EgfDsFEvpydYMj8aCSGiY18G6yboF3AEbQ08lOjZWUJ4+Z0IzLLhOy54mcy86MdUKp7hdZ27MUxqublTLu7iNLikb6fVsr0EJ6ouoJuNAoa5xDrRFMpl0aypkpFVYxmzfZ1h1D9BqsbHVo+Jqu2vpyRKEfpEGGyQ/TXz4GBVY6RVOY7UwyHCawQvDDY9bzq3ffzvSjWyyOiOYIBwCj0NlDA9/73vcAFz67szjyyCMB2LRp0x4ff0Q0RxhhhD3CzI1dVjxqjNVb72Tjtibm5OMQDQtNHytoRX/o4hBzj0RpJrIeLVXSVAVTaZfSSNrNzJMp48otGMWGmUkKraJGU4+gbLRypC/VURQJeXf4V1ynSCjCYNWTJOHVyxC+WoXO1tTMwV8u4c+tVgpjsZO5ZcYPmKXFDtQUjPsKzrL+r1IGpZzpT+L/SmE90XTkMeRoTqQubLUli0g0nQkLTBiBUTlaCErjQh4bsiCR0JSLFFaRm4RumQCuFIdB0tNqaeis6yR8ACxWwPyCI2KzjMX8Qcc/BUWR1Mh06MNw7sN/+Y0RzLWbmFLQSgsy5XJMg8q5fuUsnTxl8/y4361Th2NQr62IpPXHFVW8KULAmskFMq9id/KU2U6zdjGo7aefxVp/PGesVJ1nRbKrGppB9bTYaOCjBs45KJmByAaCGf1iazzKDMrDQ+DWsPRMytZinK5JOTKbJRMlDVl4tbIKr6wrmi6M1tAUhVcul0LhJjZaoofwTs9GODqa+KzV3Cb0bBLLryhpOLqZO1U2S5lrNlksGy58G1fLtLTST44IT+J9eL2RCAnaWhclIMEaf6WDyW8Y4B7GA8lOlnLPxCTrjp5jUTIyBhph/+Ng/wwezG3bj9iyZQsARx999E5vE8yCjNnzL5YR0RxhhBH2CMWsZvGOHisflLD5+x1k24cjNipzlvr3/bDvfkFldJMEV1UpMV4lUsJQGonUlUFKzWKEMBiXyiB9fqTUy//KOBJYhUQSyEWNSIb6joHERZUznoVAGP9bK0Brt4+Qj2r78snqamadAFUj5ug2Kqpw2L4ameDVSbdOIgypcGVBYkkMLNZKEuPIqfVKVjhFiSGVGmsEpVdG6zCWmj9pvDhLLlqok9gn3dbzVYf3+jLL3TXQ2k0kdHUKiHjeiTQ0khJtZE2ArKtaIayyau4wxpQqV3sVoNBqySmG8NzlWi5qJLJ/fOWOHaOolxHc6vdOMN9xW7trH0uY1Lft6+SB/Q28NhYKq+ialNJKlJBxvboTrVMtQXgVU3kVUy57HHfPKWGcoZCwYF2GZuJDrhUGZb2Ble8hVxbF5XNqJAhBR6eURlEKp14Gx2RjhXOy9Yom3vipfn/aqLQe3mpmhIDbpldyzMI8kw9qMP+z3oFu0QiHG0ZE85DA9PQ0W7ZsYWZmZqe3ueWWWwBYs2bNHh9/RDRHGGGEPcbM9R2Ofu4KpotF5LtuZOHkVWx53rGQGUhrM2LLDMCtD+8rjaQQLtzPWsiUC9tLpKHwA+egAGIC3azyz0QkoUsRQ0MFNLKSRqPwywXznhwGRVMKS5aWpEoz2eg5h1pVOjdO4UgxQGEU7SJlschY6DacqVCo6eAPZgn5hcNjU4UgqpmJcjUlU+UIdwyZ9SZADVXGMhZjqkdLFUyoXl+OpjWCls3QqkfPKlIp0VaRyTIqWMYKEiHJpEb7UFoMmHrRRt9XUriyHzYoTBZsqAjja0/GmNIlnR4IfLW/oTzBk+tekXD3zDSrxxZZN1GyMmu7sE2pSazhXqY8OfeM0/j8Q9sfquplzepOWNK2/jDoViP3ExxQakm3SKuwWdz5SVk5/KraBEAMeaZ/cqAe2qxq6yAsynhn11p4udoOfzLLkneHVGqCxZPx5C48Em/uk4qyaiP9JkDBTEp54lh/D58bGz6H0lpyqyitiusnaKwUjNHz5VBUvB+R0LCly+HEoqX7W/jP0lGNWY5qzrq6tjrjO1uOwwrhIhMEXhWvRQQIwEcJHJahcbXP0kIzZXaLYeVjxkZEc4T9jlHo7KGBBz/4wVx99dVcc801PPnJT96pbT71qU8BcNJJJ+3x8ZezrxhhhBFG2Gm07yrIt5WsfHiTbHOPZLZEFMKFyXqFAhhKRoTPRwyGNMYKukVCu8gojCOf7qEoTAhEHP4Lp7VElxJdKsyw+nvCqZ5ZUtJMC5ppSSMpq1y5utLkFdZmUjKWFIynOeNpzkSaM5H2mEh7jKc5zaQkS7Qnn7VyFNLG0NH68fujIUVFVIRzG411MQcJgXBqZCZLV/dQahKhndLk3UIVOrrShjIVqVc+FZUarHy+ZyK1Iym1MM4leYQi9Efo9/5Q2L46oLEfhzyPq/QTz3qfWQTaX+vSKKcM1zowhpv2tYmqn2uqqrVOubbGhTTnZUK3cOHC5YCiKYUlUYaJrMdE1mMy6zr1c4mibfuvj6jlyNb6T9bek2KAiPozcuVhdHyE/Nu6iVP1GHzd369h38pfa3d8bwSFIfHHyIQmo/THqx5B1ewLqa2p5IGEuvvJTbgkwvRdxnC/hX0OqrZh+xD+HYyumqpkMukymXSZSHrR2EgKV09WJmbJ58bW7sUdRBb/0iLMpdzTyWisSmjdL9vRJiOMsHdhD4HHCDznOc/BWss//MM/sLi4uMP1P//5z/PZz34WIQS/+Zu/ucfHPyyI5oYNG/j85z/PW97yFn7t136N6elphBAIITjvvPN2aV+33347b3rTmzj55JNZsWIFaZqyatUqfuVXfoULLrhgpxJn77nnHl75yleydu1axsbGeMpTnsLXvva1Zde/7bbbYnuFEDz+8Y/f4THOO++8uP5tt922K6c4wgi7hZkbO0wc3yAZlwgtkF2JKF0BdmvxpQnEki//LC3J0pJWMBAxivvmp7hzZiXbumNs67WYyVts7bbY2hlDB+WREN5a7avbzmgvNugsNCjypQEbUhoaYzlTY13WtNqsbLaZbnaX5l56KGGZyrqsyDqszhZZ5R8r0zbTaYeJpMtYmtNKCpQySGmjOiekRSoblwHVFLA/nssJrJxmpTBVvUxh3DLvOJtJzXjSY0XaYUXaZkzlNLxKWZXC8IfxbU+FpiELmir3LrXuuInQNFXBuMqZSHrxvbpXUR1LSKasclipk9Oa4kQ47yFkoFpkEZKa4647f20l7TJlUWcslhkdnZIbFdXs0GdiycMf25NMnUtM4SYdtiyMsWFuig2zk8x2m/3tEdBQJfeb3MYJK7bw0DUbWdNajKQ2qJnBAVgGwid15QgshvyVpm9CIBD7RGiasmQi6cVHUxY0/CRCJnUfCW34uqj1Ry1uOZLTlsqZVF0asiATmlSUNERJUxQ0RUFDFO44oiATpX9o0kAQMSS1UFpZM5RKcMromMh9TqcLQ44OvD7X0x2n9AZF+FxM649TPx/t6366bVoypxnqf4ZHqyCdKBA1smmlrXI3D1OSCYCPNLj9yfdjTqasPHHsQLdohMMM9Z+zg/UxApx99tmsWrWKO++8k+c+97ncfffdQ9ebn5/nggsu4MUvfjEAxx57LK985Sv3+PiHRehscE/aU1x22WW85jWvod1u9y3ftm0bV199NVdffTUXX3wxn/zkJ3n6058+dB/33HMPp512GnfddVdc9s1vfpNnPetZXHrppbzsZS/bYTu+853v8MUvfpHnPOc5e3ZCI4ywFzH38x6rTx1n+hEt5uc1E7fndI4R9DLhTDxqylAfvDwWwmWNNw5yLqZ4clNT+/xmO/wNWWaFoNI4pUrUlJf+UWso/6GtiLmig0TM4gx/tJU1Z10LwoX1BUVGJO7cSuOcOXUp4xHjfmv7rxSy6nUgOi6MVqP6tL7a+QW1r37G/hzqy4e56A7tr6geBmpoozlOPAlPmHeYnylqf0Xl6hrNl/zxtBX0yoT5XtOF1OqErk4caTdBAw3r+/BZXHivQGClb2M4ejCkssPOuUYgqQh0w6vYwfm1PyzWRgLW/6iUwUj+g6oJfa8TYWI4s1MNnb9raX15k1jew/qrFc5z6Y0dQnOVVy/7BOOgrNZUSmrv9+WK9l2rgfugpngqT0gNBoTsc9UV/n1pDVaEUjsS48/bRgLrcjS1VbRNAwt0TBbTbUvjohNMKfs/y4Fwito9N+y2251B5o4+D/0f/gOHWjuScc1dUy0evr6gsSaht3lUV3OE/YSDXTU8mNu2HzE1NcUnPvEJnv3sZ/PNb36TE044gdNOOy2+/+Y3v5lt27Zx7bXXUhQF1lqazSaf/OQnSdN0j49/WCiadZxwwgk7HaNcx9VXX82ZZ55Ju91GSsmrXvUqPve5z3Httdfy6U9/OsrLW7Zs4YwzzlhWRXzjG9/IXXfdxROe8AS+8IUv8K1vfYs3vvGNWGt53eteF92hdoRzzz13l89hhBH2JWwRSp00Gd9YcNTX5xi/rUDk0uUs+nDGRJk620HgTEBK48xgCqOiShKGvi5f0eUv1onC0N+REDZZXymE79bKb4RwPiXM0AFmqSVFqejphMIbBwUiYhAY74Kbm4RemcQ219vXSEumJzusXjnPmlULjE10afiyKuFHWgwSlYHngQAoYWhITUvmtGRB6l1Z66hqJ1Y9YyGWuAhlLqryFsN6sH+Z6COC/orUJg1cmDD9SubAo3LzpaZI0qdiSk/2EmkojGK22+Su+WnunFvBhoVJZrotpx56Z96q5qhXN72KLFR4mCp82VT3RN9kgW9/pnTMf0292rii2WHd+Dyp0lUtU6+0Jb4MTxKJf/U81j6thbsmPuy5Xte0IQumVJdVySJr0gVWpG0mVNepfj6s1qnRJZlXOcNxUqH7rlHiFdBMljRl0UdGXZ6mV1SF9mZA4VGFxap6ORxh6Se0gci6fWWipCEqZbQvJxTj2+JDdUW/OptKt33m1d2OSdlYTLEhn2JzMemOa6FbJBS9lKKTuImCqKC7SSskLndY2sNO2bQQ+6KxusPicSX5vGblY1oHslkjHG6wh8BjBACe8Yxn8N///d8ce+yxFEXBt771rTh5/B//8R9cddVV5HmOtZZjjz2Wr3/965x66ql75diHhaJ57rnnctppp3HaaaexevVqvvGNb/C0pz1tl/Zx4YUXorX7cX/f+97HG97whvjeKaecwgtf+EL+9E//lIsuuojFxUUuuugi3vve9/bto9frcfnll3Psscfy1a9+lfFxZ9X/xCc+EWMMF198MV/84hc588wzl23HmjVr2Lx5Mz/4wQ/47Gc/ywte8IJdOo8RRtiXmL2xw4pHtZg4UjN/132ImaOQnRY68aN8tZTTFXnCfK4ouoknJtArE6SwTKQ9GkozmXYprSsAj3HvzyyMVaonxBqOfRj4oTFG0OukdBspjbR0bqehrIJXRoKrqfXkd1tnjG7qnFCbqkAJ49VOyXzZYD5vsNDLKLXqa4PxheixjsgIYVnRtOhMMpYWroZlVBoro5mgCjnu5ohKU7mwylBfsu4iupzKFWihttKXM3EaqPTE3iBYLBv0dNJnNpOpfhLzkFWbKI1krmiybXGMdp55xhYUzEpZXA4h9DaEEdfJoQymOdKftxxQ1twe/DUO/epKbBgna7k8zPDX1raRro029JcVCE/O63meTkWVbO6NO6VRaQojnbuvNAghojlTva5p5klo6lXmzJPJsL8wQRBCk6VX0cOyxJPDTJQ+vDRBYimtpLCJI384ImUQ5Cap9UaFkH/bkCVjMvehqybECfRfC+oqZrjfdg5CWKTFE1ZvjGSN62e/V3dvuXtOW4nCsEADY9x5Y50Ca3xOZ8+k9PKEI7I5prMOyZRmU3uCDbP3Q5dhBsNfPq9Ux1OKMdj9ZFOYJaEHOzgxfyv7e8J6Elvfti8v1C+IH8MDMaD1TUmkRa2VbFybcPSEJLl2kXJ+VOtkhH2Pgz089WBu24HAE5/4RG666SY+/vGP8/nPf57vf//7bNy4Ea01q1ev5qSTTuKMM87gFa94BVm293K+Dwuief755+/xPq666ioAVq9e3Ucy6zj33HO56KKLAPj2t7+95P0tW7bQ6/U49dRTI8kMeMYznsHFF1+8bOx0wCtf+Ur+5V/+hY0bN/L2t7+d5z//+Yzs3kc4WFDMGRZvz1nxsIy5H22D9mpkLjDau64OiaHQhSTXki4pMjFI5QhIlpY0lKaZFIwlBdqWZErR1ilSWmaFG9wCVcjmErI5GA4LZaEotVNOAXRd7bL9mxgraRcpBkEjKbG4siJO0RR0y5RemZCX/WStmlF1emQo3aLSAmsFSaLplgmFVuS+7mR/KRXir2R0nfUkp1Ita4caaHf9vUDMSlsRYe3bn5uE3CTUqUYiq0GqANaNz1Nohcwti72Mdp4iotvs0p4e/G3vI3SRaHq1tubkGk1zgorbdz6+pIgnGW6XxqvXEivBmPrl74/rFX3L6qHJ1ve92/dC0SCRhqYtK8Iv3LH7w2YrpVJ5RTOTlSoK0NOiuq7US9W42pq2RjZT4VxbpbWUViGtwhjZFwZrEWgR7Yz7EEyGEqqcUBfGuxR1e6XQtl1BaL8U2hN921cSx2f7IjEYIdFIejahF/vS94V1kwy5Sch1QtIwLr+0WVIWkqLwkQ2D8w2DH9LB7vDzH7s1yOyLK7bRiTp+OSy5J0XVnP04qBU23NX+nhoXbHz6JEd+aY4Vj26x+aodG36MMMKeYkQ0Dz2kacrLX/5yXv7yl++3Yx4WRHNvIM9duNvxxx+/7DrT09NRcez1llqNr1y5kiRJ+N73vke73WZsrEre/8Y3vgHsOJ90fHycP//zP+dP//RPueGGG/jUpz7FS17ykt04oxFG2DeYub7DMWes4H4vWcnk3VvZ9O8LbD79ePSEopiw6IJqUGZhzYfuRM25vKKFx61h8cTVoEGnmi2tccYzV8ZDCUNTFkylPVIM91kRiYcXId0uY8iMGMZ6wFq6RQLdRiQYsaamILIVax15KUo36C9LyUQjJ/GKnzaS2W7Tv++IW6ifaf3zXp5QlhIxCYnSZIlmEG4MKyIBEKJy6MyUjrl8iScZ2rqgV1Vz/TRIn38YlKWQdRpqG7p1DdDVrs5iaSW5V1WDu2tfyLFHKjRCwpgqYgkQd6z+0bUI/9mqq9NE08yKuE6vdD85wVCnKhlS/Y3uvXXe7q9Jlb8rUNLnxwpff9FIdx38A5wRVbwnAnH3x0RYVjY7TGQ9MuVI05buOGBZFJlbLxJEUyP7lsQ79U6mXZqyZEz1Yiio9n1bGgnCTUyEyQGFU0elMBCXh34unTKpnKLZlOnAhIIgEcPzZZqyoLSKnk2Y100mUheC2xRFX53McD5912wXEMKmVfjQiZIEp1oGaKHc+aPiveBU3xJhbewfI5zCOZH0SJIO00mHcdkjsS6CYeVkmzk97gh7yMOsK5kwPDxuiMIZvw/6F/RvI4a8FraaUBk6h2Vrucr7b8LX1sridHopeeq+Nza0FEc9tMXW77UxvdEoe4R9jIM9PPVgbtthhBHR3Ek86EEP4rrrruPWW29ddp25uTk2b94MuLo1g2i1WjzrWc/ii1/8Is985jN585vfzMqVK/nc5z7He97zHsbGxnj2s5+9w7a8/vWv52/+5m+49957Oe+883jRi16ElIdduu0IByk69xTc9YUZph/WZN3DGhwhoZi5AzsrMD4SLioqwCOPseANP0o9j/55N6oS9m7LwrEC/WCBaoJKLKnUlFIO/xGph00OLq8NCEsjKbQKvNMTrBAKF9Qzt6mxEqMtpclQypAGVdBKunlaKZn+R7f+2xvKrfRKNxRXsqYg1cPu/EC2rmjW6zEGs5colMYAyLo5UlD7qt4Na3nqjPVmM4VxZMDYipRW5Ly/7wSuLcrXaowLbbDgqXd5IKA+zFIastRNIoRQZGtFH8kMobNKmnisejinjVdEEFQkl3cpXW4oBqzE+r/I0Bc2zjVUHKCWbyqgmZRMNtykYK4VhXY3aCks0tiYM9qnSNaIcSa9e2+SxxzEnk3AJJHQVcZT/twsMT+2XgIkqIQAUvi85hoMEi2Gf88rYSito5SFSbzq6MrdqHo7wmXa7RFYTfsWoKwrn9JP6irjqYoXOnJqMTE/2KmwuHxPHz6cCI1GkihNIyuRqnKb3aUmD+V825E6t8cRd/ReFFjtkIiKgX3sjYFvvT+syyU3pUJJw72tlKPmSqYf2WLrdW3Quz6ZMMIIu4QRmRthBxgRzZ3Ea17zGs4++2y2bNnCBz/4QV73utctWeeCCy6Iz1//+tcP3c973vMerrnmGq666iqe+9znxuVCCN773vdyxBFH7LAtrVaLN7/5zfzhH/4hP/nJT7jssst2yq12hBH2Fzp3F3TuLpDZAuMPaCDXNbBSgHLOlFVeJSze1nNjPwm2obGNIoYzNibg6M0K+/2UOZlx22OmMccXWCF8WJ2oFMwBwhefs/R5t52R99KKvBnp1AsjvJulwBDInXen9Tl5zdQpdKVWzFgRw/sqFc2TNVMRuIWFFkJY5sIgtya2CmWjSjoMBkHPKKwnKEY6Jcj4fM2KQIRw0EqRLZGUVlFY5YiOP6pBOLJpZJXziMsp7ZSVamaBOxZXxpzDwipnuGPBBpYeECcQHDlw5LQiWAhXq9JCzHFUvpyLoFpX9BG0qiGRmnlVUyal63cryI2iVyZR3RTahT2a4JRrhTMQ8m0IIbNNVTCVdN09IVJS5dhd3ZDJqbiWJIQ/14x+ppIOE6rHVNKpyoGYDIXBJo7UJJ5cCXxuo4Vxk2G9ChrCoX0XRsOeRJqBkFQZr1292wGaokRIvLGVZVa3SEXGSuVyKFNvBiRiYOveQQiFzaxT2w0C13pBzyRor6VLLKkosSRgZa32a5VzPG+adGzGbNliphijqUqmpto0Wznzi010qbDdWv3TXQnbi3Mv+2BU3KeEDt9/XYEEXA4p7N4gvf79JkDPZJh2glnVY/aEKe5dNKw5VfLjX1vPmn+6g3RzvhsHGWGEHWMUOjvCzmBENHcSr33ta7nyyiv5+Mc/ztlnn833v/99zjjjDI466ijuuOMOPvaxj/HZz34WINbrHIYHPvCBXHvttbz5zW/mK1/5Ct1ul5NOOom3vvWtO6Vm1tvz13/919x111284x3v4Hd/93dRSu14wxFG2I8wuWX+J134SXfgnYoJbvn29vOJknHJ5IMajJ80wcOvnyX/ieDnD21gJ0QVERddav2C2g9MqLcIPkxWC4yWGAMqcQNzKQ0hdFR4pRBDJYX5kNQYUUfQE91BY/mMcFa2P5y3LAeUKEF0X038scMJ2Li9qL12pEnbEDrrBu9Oo3S/9gLhjFmoSmEYZAxVrGfjhdDeSlMT8ZjG9NOQ+aLhiKIF7dXIukAczif8qZv7SDngiisqIhfDZ2vKbXgv7rZGzMGVJwnkK+SSBuIZVW4rUdZirJu9cLVKiUQzuAzX1dN6m8Lzek5mMC0KIc3Ku7NWLqo69mTiJwEasoglR0JuZiI0wgoyWWJCqGwfc/DtAoQw1aQBAmG9qVAoLVODEprE3xMSS24TjJV0ZYrCoJEoa7BUJj57JkWIvmdhwqbOp6rwbarwbVv1tcvRdK+1FXS0M5+YLVu0jQtdTlMNElTPG3Ahq7IvYnmB8qBDn+Jba/deUDptIf39ITBjCTc/fCXrf7CBlSsFtjGKdBphH6L/q+vgw2627Qc/+AFf/vKXufLKK7nxxhvZuHEjaZqyfv16nvjEJ/LqV7+aX/3VX93j5p133nk77SHz9a9/nac+9am7dZw94QZCCMpyz0omjYjmTiJJEi677DKe97zn8a53vYtLLrmESy65pG+dpz3tabz5zW/m9NNP3+6+TjjhBD7xiU/sUXsajQZvectbeP3rX89NN93Ev/zLv/CqV71qj/Y5wggHI8pFw7brOmy9oUvjiIRjfn2KdZ+c5c7nr8NOCETqFdK6cUhN3WxO9MhaToXUhWJ+W8iNtrTGeySpIwl5ntBuN2IonBWCKoTTmYJ0ywQjHBEofS6m8bmBUcEMzqfbq7lQGx3b2o91UOy0lZTGUkpJWguflcLS886jKJDWkRhrHM3JZInCYjy57JqEnjf8Ed7cpLQyut1q335tXLkW449dx8b5CQJ5VdLQyAqfMynIC/cDFoiLEDDe6JEq77xqJHmpopNsWB5DgmVl/BNyToNBzWDKWyDcIV+zmRTu3K1AihRjJVoYV8ZFunMpdWUi1ExLZ0JEZT5kELRLR3AKq5w7MLaPaAYinwhLK8lpqaKWuxkcgk00F2pSkKqSliz8+VS5mNITxUwWWFmgxHAlO6iOdQXaCkFG6dx1BwZQLVnQoIyh0F2TYhG08yyGqq5OFhiTPdaoBVJbIvdA1gx9GlDfV6i1mYnShcGiUSQUKLo4Y61QWigRrpTNos3o6tQ9LzPv2OvC5KWwjI31KArFYjtxH3PlO0ACpTg0yGaA/6xYUVM2dwW2fztbO3khLd1JxcbVTY7fMM/tBzULGOFQxy+jovmUpzyFb37zm0uW53nOTTfdxE033cRHPvIRXv7yl3PJJZfsVXfWfQU7+IOxnzEimruAn/3sZ/zbv/0bN95449D3r776ai699FIe+chHctRRR+3z9rz61a/m3e9+N7fddhsXXHABL3vZy/ZKcdURRjgYIbQlv8eF5E6sUaTzUKYCE0qnBAx+p4q6Mmb71ol6nojjP682eMnBBpXTZQcWpSNWUtjoVhtmdaO6ubMnZKknD3oH00rpC+pYUNBCRmYgE6G0hxNfHbFKrPABlo44VlUTQ5ixiOVcrK3UwKA+heX9zQzLAuV2/1XmQ74vfT8rGWqAukFw6Nu6q64jaVX+ogzv1/8O9GQQrk183a98Cr9Pi/WDb4uUlcFRCHutSshUIcSJdKGcDVnG/ggks94u5QlSWO7UYheaHNTESsUz8TxkPM8qRHbH90ktPtK/9pmoS0h4LIcj3D0SDKPC9TM4It0zKUY60ro3pAhNqC9bEeb6OVusV49reZm25nob/rPhLEK8QO2sLS4CQS+NCjigPGpPju+3DR5HfdjRPgfUUYQAY7G5M5/CCG4/cpJTf7SJ7EHj9Kwiu6/NQMndEUbYc/wSKpqh8sP69et58YtfzJOe9CTud7/7obXm6quv5m//9m+5++67+ehHP0pZllx22WV7pak33HDDdt/fnhHpjvD2t799h+ssLi7ys5/9jK997Wt0u11OO+00nvWsZ+32MesYEc2dxJVXXskZZ5zBzMwM97///fnLv/xLTj/9dFatWsWGDRv4/Oc/z1vf+lb+9V//lSuuuIKvfOUrPOxhD9unbUrTlLe97W28+tWv5tZbb+Wf//mfOeuss/bpMUcY4UBj8Y6cdU+aYPWPYe4BgoXjRX0svlTZHPZjUyNOQCRdwUIyKpN4vgkgBLMLriC6VMF91Tuhmkppw4gqnDYg5B0OqnTWPZQwTDZ6sZSJC/e0TGcdUuHKZhgrKKxyapUVJEKjhPQqp6I0ChLIhKsB2bNJVIkK60JojZV0ytQ/94pmeOiJOb4AAIUhSURBVG6cU+pg6OxgfVLHUVw8qpThvLxKiCVVuqYMqhhuW+Vhur8h/DSW/JBL8wf764V6Iix8KGnobq+QZUqjhSDBUGgfXmxsVEHH0jzmhlqv6PZ0Qm4U65oLtJKSVlLQ0wnzRbNWlgTfZkOmyqhoAnRM6kx4/PVIpabhTW3S2sh+sCRNOJ/Q9u3rWoGgCoRXQAdv6XRAGVU+HDuETBsEs3qMOSwrVNuHsu7ZKNECiyYDBCtUOy6XwpKio6JZWoUVJRJLUxRI6UJ7tZWOvFtDIkJtUUEqNcJKClOR5vZCg7JIfK3LWiP2QJXdXQy2YbcVHeE2DhNUsS7nThDYJSHDWmA2Nf2bsM1kzKczTD12nBtPuz/HXHw9ort8HvgII+wOfhkVzYc+9KFceOGFvPCFL1wScvr4xz+el7/85TzxiU/k5z//Of/2b//G6173Op785CfvcVsf+chH7vE+lsPOEM2ArVu38upXv5ovfOEL/PZv/zZ/9Ed/tMfHHxHNnUCv1+N3f/d3mZmZ4cgjj+Saa67pK0NyzDHH8IY3vIGnPOUpPO5xj+Ouu+7izDPP5Lvf/e4+b9uZZ57JO9/5Tm6++Wb+6q/+ile+8pU0Go3d3p+19oDK7OH4e6MN8fd6O/sSexI/dhhCSOHrIe5hv9XGPLu6r87dBUIKVsgOC+WEd1kNSmVtX34cXXYTrFdDrO4vsp53MsrcEQKtXY5fdG31A8GosNRyqqxVVciaD5tdIjTUG+3bWFdwqvRPt63C5bEluPBPrKuriABtlCOPJqE0jiL0dOqJ2EAbEZRGkeskkkoXiuiQYDHWmRfZekmQQJgHw/mC+iugqUoaSenLzdjKiEe7mqDaSjCO2Eh/nklN0VM+xFThDGoSX4MyEOwQUhkQVMGQF2o92TZWUhhHnLEugtKZ7khfjsJ4VTLUdYRUVMcKqmVQKluyYEy68GppLR2RRaU7kETppVFtFCGrtrCCAlfqJoSCjqmchijJZFmF4VJzmLUCaV3fI3fle666xwY/MdaHO8uothqMV+INrs9yk6IRbCimmZA9VqhFMqHJRMGuIoR4p/Tnyfb9DYzM+pbb6iF826R/T1jhXXKFc6e1jggnGBCCVqugSAy9hcx/xKv6lvXJm70x6BW1R1hga8+D8a/F1hye6SeHSxTnnTgoIXSimjgLi5esbgPh7TfMihspwV0rpnnIps00Vk6BFLv0PXugQ+22h/09RjhUcECu2S+hovkf//Ef231/zZo1/O3f/i2/+Zu/CcCnP/3pvUI0DxasWrWKT3/60zz+8Y/nz/7szzj11FN5whOesEf7HBHNncCXv/zlKKefc845y9a6fMQjHsHLXvYyLrnkEr73ve/xwx/+kMc85jH7tG1JknDuuedy5plncuedd/KhD32IP/iDP9jt/c3Ozh5wormwsAAQyyTsDqZ8eJa1lrnZ2WXXW3Pcyt0+xuEIIQUr1k+CEFizB/fJLeEnXuzWNRhLJjh2ZYJtNlhQy7QjqJtlA+q57JJqRJr7SZkw8q2PMOPf2v77lNPwfCD+bXDgV29eiP4T3qBIOHLQtAlrjXYupxhHJi2sKGU00MmNQuo0Koyp0nHnIcR23OROVSxX0NQZedn0LqWCxIfflkgKnTgV1Ct/2udphvIjdaynFZ9PS0FLFUxlLn8OoFMqFoqMDimFVqQmQ9lK8XVGJV619MREYcisJrVO+ZMYlHW+qkro2IVV/UdPaIRzMy2tZFE3+hTZUGPTOeg6wulyG912YzZxJUuE8b0WyL9lndG0cO6cbZ0h9XgkofXQ6tSWZFpHdTI3SUXzhcEIi5E5VhVYURJCg51y5fdlQZVT0aW2XuJkdyF769x94Eua+JuMEoVGoEyCNg2KhZRN3SMp1s2TpnMYUSDl0prPO0IgmspfqdL3aTDscRMATu0UViKQSOvuDayiZRqkVpIZRWmVuyeNRBtFx6RoP6lS4MK/JxsJpUpY6DXixI6fRUAo0fd53FOyKYC1PgUlfIUA8bM76CAbVySsbJcwy6OzXZj8HUYs+44R2sHS75oQlCHArlvDRC/n0amlPG4FsrvzsbOz2/nNPNDY32OEQwVzc3P7/6C/hERzZ1A35bnlllv2zUEOIJRS/OEf/iGveMUruOiii/jUpz61R/sbEc2dwE9+8pP4/LGPfex21z355JOjSdBPf/rTfU40AV760pdy4YUX8tOf/pQLL7yQ3//939/tfU1PTzM1NbUXW7drCCR3enp6j35EwjSvEILp6ellV9t827bdP8ZhCCEde9h8+8yeEc3aqGl3rsH4rGDDuOK2pEU3txVRrDepP6Gv/29A3dW0Tizj6/5BY12R7DuTvq5YRuUACPlpoZ6mV8xa5Ai5QNOHZva0I1M5eVTDSiHJZeL3Xjl2CiBTBQ2p6akChaWpU2bUPHP03EDeSDKpvToq6dqErkkphDfNsS7E1YWB0tf+e+jE4/REm3GZY5MFUqmxCHoioS0yOjIlD6omoaQJlarnSbUULsy1pQoaqqDwOaipdDUfG7KaFbAi5PnVyJPOKKyikzfJjQt9daqniSHBXZ061bZGQluyIJGGTOrY9yFsdUW2Dakc4eroJvO26MvNdEeuDGxChwRSXq8N2fVKberLlKRSR0W3KZxZUyo1trGJRJbxela2U4M3Td1FePh3Yi/bAoARJWmNqDtCKNE2ZSafYubbqzF3NhAKHvSsOY5/8GZa6WIswbKzCETTxLbV5mms0yZ7eqxyPfZ/O6ZBYRN6xoV092wS78/cJhRG0tGpI5w6pacVWkoWbUYhFJt9XixGgPZqaTAD8mHye5qLGETFu8teVA1j0ISTiD2h8/dFHxsdjruL3u4Pege/08L3k6Y/jLf2/eUDG5iUsHbLJm48cZKxH80wccPMTh1ye7+ZBxr7e4xwqGCP+mJ3j2n3ThTBvsK+alueVyWDflmrPTziEY8A4Nvf/vYe72tENHcCSVJ1045sfouiCkOqb7cvIaXkvPPO43d+53e49957+cAHPrDb+xJCHJAvrGFt2BvtcMRg+f3sGVk6PGGt67e91Xe7sx+ZCdrjinzMK6vRzSfsdPAgLCWiwFJJgIEVq7g5EQaXliWq31AVIpLf7etVBqfCaa++KaWRuMF02zhlJeYVWuEJgQ9x9UY6yho0xilA1pLi9ocEq0Ej0P5zoBGU/qFximBJcKEl1gWtTq3qjyAmhYqMIBDS5WUaIZDK0C4ytJF9RC3UyqxqU2pSVdJQZczVzKQmEZqGDzkN5+0iASvyZABlFW2VYISgQHqiatDWOKdbq1y/2xDyKqt5h+h0G0J6QUntS5tYlNUoX08ztLkOHaWt0L7KFMkKKHC5rrnPn21Yl58orEUpg8V4Rbsid3VhYOm3lTeBAsoBR+B4D4nwV3iB3e1R4u5ZaST5okTfk7J4T5fmJPz8P0/g3u+t45Sn38i69bOkaaC6A2Y9QxC4lbD+/kX0fcSMFVGNNP6v9veMger8jVOrpQRp/F9rMRiENU4NtZY08RMNyrjcaS1c3K3197g7KGLZFu8CRIzwxchq0smGz3PoGP/cGYJt/zvMsHxf7kx7Krg2xNvALtM2j9tWTnLszBzNh43TmS8Z/+HOTeod6DHAjrA/xwiHCg7INTtMFc0rrrgiPt9bXiynn346P/jBD5ifn2fFihU8/OEP59d//dc566yzWLly5V45xq4gRA1s2bJlj/c1Ipo7gbrb05VXXslzn/vcZdet34B74hK1q3jJS17CX/3VX3HDDTfwrne9izPPPHO/HXuEEfYrJKhUUKQCK3F1BWM8WW09ixt4DkgudnCaM0gY9X3EBEp/yFSTjblJJGshX8wGchlr5ExY0kwzPtXx6wsW5louB7TePOuMYLAuX7JTZCTCYhMR6zdu67awiMotlaquYxXSaYGUwkraOkNZC2WDnui6nETlFLSOdvma3TJxpj9WUGqvOGkZy5wMDomD46wQlvluk8U8Y2t7jEQa1owt0koKJtIeLVugfYhuYVSNhEFTFX3mPw3plNtmyIsUrialFNbVmsTWSmYE4xqHTJYoa5hIchLjQjYTr4iWRlEKSVcnCFw/OkWzMpYJx6kTzaA4pkIzRs6qdJGeLw3TV9dzyc3Yd7uBFZUrrHcHzo2qXGeFIXFTCmgryHHKtcaV85BYspqia7xkFRTN0rvcRrLrEcqBGFy9Vdn3QXDnveWDCY0JwZZr2ui5kqmHLFA+apr/uu801q2/h9N+92ZWZm0SLE2hGRMwKUN4rKCoJVZLBAKBxlJay7y1dEzCjGmQ24Q8KJVICm/8oz3hrPelDLm0YRLCT+IYBtyVcRMWjVZBLqAoK6ZlFS6EFuHVLjejsDtqRgw7VT4HsP59sfSjUamLYeOB8Na4X2Wr9/dABQrhsn3hu4KlbfNvz7cabG01uN/MHDcd+lxqhIMMwtpYG/dgRGjbYFhxo9HYbS8TYwzvete74usXv/jFu9/AGr72ta/F55s2beKKK67giiuu4N3vfjcf+chHeN7znrdXjrOz+NjHPgawbKrgrmBUzXcn8IxnPIOxMVd77wMf+MCyNsRf+tKX+OxnPwvA0UcfzYknnri/mogQgvPOOw+AjRs38pGPfGS/HXuEEfYnVOZGTLmUSwdXIYrWin6SWXt/ySxsfF9UIXAD2whASOsfQxo1OMAUFqksUhmnjg0ZWQanVuEHiaWRlKa//Ii2jvyFv2bIIDz8DY+y5jAbOHMoexHqZBpv1tL/AFha3qQObV0eZ66dAVAgASGkNPXKYiq90Y/06qXUfrnpK9miPKGu16ysxszBQGeg33zfxdqi9JcgIZ5zte6SciA1khn1ZusIp8JEd9q4j9gWRxZVKDlTJxr1y++Jsuxrf8UInELpiFeJ8qHLnoz5a6dtUAOrLM7QitDvg8cdhvCeEuN0NxbkGzW6K9j2Q8tt/zbDtuvabLpvPd+49GTu/OlqenOKFEsqIBPQEIKGgIZ/nfnn7mHJhCXDkgpLIiARYTLER5qGENsh4aX917n/w+nu+ephfC50CHuu7WA42doThK+BZUPra2wxHnu4qrhTr3eiPXbYufa1a8gy4I5V06xZ7DA+BnoiwSQjxjnCXsLgb+rB+ACOPfZYpqen4+Od73znbp/y3/3d33HttdcC8IIXvIDHPe5xu70vgEc96lG87W1v4wtf+ALf//73ueaaa7j00kt55jOfCcDMzAwvfOEL+dKXvrRHx9lZ3HLLLZx99tlccsklCCH4jd/4jT3e52GhaH7rW9/i5ptvjq9/+tOfxufXXXfdElL2yle+su/1ihUreNOb3sS5557L/Pw8v/Irv8I555zD6aefzsqVK9mwYQOXX345H/rQhzDGhVy9613vQsr9y+Nf8IIXcNJJJ/E///M/bN68eb8ee4QR9hdkw32uikTFmX3hS4o4JaNSI+NAsWIALsTIC5h2gCi4dav3wzahBiV4hU8LF684bMxm6qPCAZTS1ZaUlkazIE21I4FGsG1hjLxR5TgC0azHEtxXDdFUpqb4oUBaE9W3nk5oixSlajUfjSMvzh1WYIx7XhqJ1rJGNpdHHMd68qo8qWzIMhLFhioiWQ6hvQ1ZxPBfPAFryMqZNSi11Rm5toTQ2XAJXXCkDxcWJpYUCYQmkGhXd9TVi5T+OhuvIGsrSTA0VBnPySCiqphKzQRdrHWhqkEdNAjGVc6Yyn0epGWmHPOOrlWeTio1mdRMqG5U6oKBUc8klCgaukFHtygRLl/RKlJRkggTVV53TAlYxmTe1w+DuZqhPxOhnVNrjXpaK1i4b4xkvMnma/tn9q2GLdcu0tvQYfUTpvn6llPI5mf532+7llVTmgxFCEdt1veJ9e2wNIQhE5qVWNbbLj1r6VjLzzC0TUbPpssy4ar2qPXhz9BSBXmecPfcNL08odQKo93nT5eycuutf0aNi2oQPlxahAmT/ptnWSUx5jrWvjMGTYCiQ/ByPE1A/AANUzQl8fvJhjxSWVvXt6/P5Ce8NezYNYI5NEoDd6x7Voxz/JaM+x1huPbPH8XaT9/OxA+3LnMSI4yw8zhUcjTvvPPOPu+R3VUzr7jiCt70pjcBsG7duj1KUwP44z/+4ygQ1XHaaadx5pln8o//+I+87nWvQ2vN7//+73PzzTfTarWW7mgHOOGEE3a4jjGGmZkZ5ufn47I1a9bw1re+dZePN4jDgmhecsklXHrppUPfu/zyy7n88sv7lg0STYC3vvWtbN26lYsvvpiFhQXe+c53Dp0VSdOUCy+8kJe97GV7pe27AiEE73jHO6Lt8ggj/FKiNtgS1o/t4kByQJGsbRTUE5mYOIg0Zgi5WkIy8XmpAikNQoJSBiOW1pyMsGB0pV71Ec+KB8cQTi1ciZFQy7JeIxKIpM2pWf3aWNihEHiyRwyttdblZGIl2opKFTWVAhoI5nLjhfp4Pcq7/mkgdsaKSHKlHzGbcPY1dWuwGoTbLpzr0svg1rP1sXjtfUdSAkG10BfGFS5jUC2Dchlul/C6LgI5MjygsMZBuyO3qdB9Yb6OwKq+44a21VVacMQ15FoWVrlcWa9eSlwJmtJW+wr5sSE3dznBLIYp9/WSO8PO5oy7P7+esp2zcPMwh1nBwu2WhTtmmH54k7VPmORvP/A0nvLYX/CI+29x94y/N60FKUEIg5AWKxxFJykYmy5prdIIUZJhaQhNKZzvbbgOwRm4fg6D3CmcC+CVXeFdbOuqaP9d6Ua8nmx6wzIvf/ah7/7xq9jqorlJoKEKZY3o+UkWKf0d6z9XfRNUyymYwt3PMZ9uWPuWIZN9f2ud2Ke6DsBa1x8/PnINT7jtHo60Pcp0pGiOsHcgDHtsvrUvEdo2NTW1xyaXP/rRj3jBC15AWZY0m00+9alPccQRR+zRPlesWLHd98866yy+973vcckll3DPPffwmc98hpe+9KW7fJzbbrttl7c59dRT+fCHP8zRRx+9y9sO4rAgmnsDQgj+7u/+LpYv+da3vsXtt99Ou91mYmKCBz7wgTzlKU/hrLPO4sEPfvABa+dzn/tcTj311CjtjzDCLxtMz/16ZD2LzCUmqQ0fw5grjr0E3hcGLCQNzdT6uTggnL1vkrKXOMVgcBBXP2auyEvJ9JoFskaJbfbQpWTbpskqV7M2GCwKxeyWiYEBqkWk/QPWOqz1JipGxbe0cXpadLgUVY5mgMDSSgoasmQsyUkwjNsOheqxUGYsFA0W8syXTBEUWlZk05czGTQA6m+YGDptbRHMdJuxjS3lFMp6OK/wmwZn2DKE8wI9kzinWUwk3FhHrkNobSZ0DHOt6KGjIYkwCOWUVGdkJCNB6Rmn60mLc4CNeY+Crg/5DWqpI4xOHc1E6XIcjaWUCq2kVyvd+k1ZMKG6TsHFYKxgUWfkNondF4hSmBRAEHMr27rhnHCLCRZE6Qib700jBIWwTgH0y0LfJMKVf0mEQWGRot+UriVzr2TWrw+0Ow1u+vfj6G2Guz4/i9UsDwuzP+rSvq3L2ieM85X8IXzlmu2sPwChc4569AyPeug9/OpD7+BItUBbKgyC3CZoJHO6Rc+m5Hrp0ENisT4kupkUrB5fZLMRGJuBr5sopCO7wsnQnnj2Ey1rLVaFGSL/lnOw6puICly0L98xqom12RzZ/xlGwNhEl4mJLuDq727ZPFlNeA3OqPj9WuMiD7BUf2t9X82m+LaHfExhlyY5DZLZ0La4vYdyxHbrdIO7V4zz4I1b+clo1DfC3kL9vj0YsZfaduutt/LMZz6Tbdu2oZTi4x//+H6rnXnWWWfFShZXXHHFbhHNV7ziFTtcR0rJ5OQkxx9/PE9+8pM56aSTdvk4y+Gw+Mr5yEc+stdyFk8++WROPvnkvbKvncVxxx23S7Utv/Od7+zD1owwwoGF6bnPQlZqV/Wi5i4exoj9G9Bf1Fw6wmZtKItALdRuMOat9tQE5dCpHibWxKytP6DYBZUjhLraWlu0lhRCRREkTTVZommqMqp9vdIRGO0H18JCkpio4oVw0dIoCqMojapUGuvIoDaS0ofIWuuVKdOvZsaBN7W+GugGayFLNanSMYcR4fI2u2XqyJp0RFBbQbvMIpELHWn8iFlgXe6mUa78hzAhshBjpSN9UiNlUBU1dVVaEMJj3SDcWIHCYPzxE2GiMU7IH3W1NUPtPEFpFIl3mhXCkToljDO6kSUt6yzsOyJ1EwBeaazOwRkTlVaSidJdB+sUaSsSggeqwJL7HMzSqhiSWxjpXFZrqim+n6M+KRxxyo1CCVFrZ/99OkjEDYJiQfKzj92fspNw9xdnKOfZKRSLcM/XFsl+0CWdUlgDVlsX7mm9Gif9fSLdZILMBCsfIdj48yn+34/W8Yt1K3jib/8YxqAlC1KrnfotJZl14dJBDQ9XNLcuV3W2bKGlpKG8E3CcWBG+n2zsG4HFSn/DBxdaAFWT6G2g/aL6HXWie395EH9RbZ1kDkwUheeJNLRSF+JcSuXU3TDhNOx7RFhX9zOQW1tNbAXymzRKVKoRuEmgvJMu6yZbb2/VvtqxlgwXBD89ahVP+eldrH1Ygw2sZfyGbajF7bvojzDC9nCohM7uCe655x5+7dd+jXvuuQchBP/8z/+8X415Hv7wh8fnd999927t48Mf/vDeas5u4bAgmiOMMMIvD6wBU1rS0iBKEDv4Fusjn5FQBYIlEFrEkLnlUisrpWJHBxqyTNhqEGxc+QmZGMpSUWoXLqkSzXgrZyzLmcx6aK9sLvQa0Xk0DKxboiD15TdyrSjKhJ5WKJl6FTC4k3pHWW/eE0IfjTdWqbvm2pqiOfQU/fm30oKJLKehSoSwLBYZFsFC2SBTJU1bOpJjFNvyViSath4yKXx+pdQkwtBShSd8laLbUCWldaVPFAZJ5bobqEkibFQ2A+H2V5auTKMJjTuWoTBua+EV0J5JEKJACSLJTEO9TgGJ0DRtQaoblFYxVzaxCAojaQhBIixNUWAVjJmUjnF1RHvGkUxTLr0hpI/1DqRUWuELgFgI9T19d2srAz1CmAwldGWiNKBeSv86X0zYeONq5Jihu0VRdse47yuzFDO7Ht+Wb9XkW7cngfZj/iaALqtPNdz02ONQV2oe98ybmBRdtHCmRqnQFCiapohhsOG8uiajY1LfG6LmVFwLD5XWqZNYl8tYG+haIwJLrxAVz5ozNX5RILmy/44X4b9A8oYQvUxpxjM3EVGUyofb2ip8dhB1lbSvbZ50Wsgmc1qTLrS5zBV5nvQft++LrLajwXaGt/tOy9JLE25Zs4IHbdrG3c89kuLu9ohojrBn+CVXNDdv3szpp5/OL37xCwDe97737feKDrsiMh2sGBHNEUYY4ZCD7hqO6M6wsS2Zf8j0Tm9nC0l3ayuOTk056FzrR2jLqJS9TkZZeGWrXgpkUP2AOAAU9dfS18G0LvZPAMK7szaTwj1UQWlVVN6iw6gFIUTfMuMVyk6RUmpFVyUkWIwZYxPQswndInGuncZva+ous37XteeNpKwGqnFwW5nzKGl8zcn+bV2+pFMEtfA5dV4h6hv726CQOrOegGjgI917uXGkTQmDUhZpHckKbTMDo+vgRJtJTUsV0YG3LmaHUjHSk1RBVdoklozBxvBXicVIT2KVUzBTWZkuCeHqdAaFPDoGQ1wHqC2viKZT9JxTK9b0mUCFUOBg/FQSyLFTeQcVzdDymz9/DAsbwudBkG8rWbg1Z5chnbuzzAQykyQTsOJJgqxhSaUltwnGJmibgBBOBRYCKaqc259e9wDUek1rTZdenpKuKphutkmFpikKENU9k3in31SUzOkORgoyqVEyXJsqmsBJ30sJZJwo6ksEtjGKgfBeXVUchuWUTCBNSybHu4y3eqRSk/tIgbBqZcozwDbrpj+EpgdSLJZusoQ4DlFI6+sOvjeE8FoBt65bwZq5LifftYGbH7aKXtYiu2XzUG48wgg7g4NZ0dwTzM7O8qxnPYsf//jHgDP4PPvss/d7O8LxAdavX7/fj783MCKaI4wwwiGHjd9c4Mhfm+Q0NnPPhh73Tk4y02hg1RCn59oPoSkk3c2tytkxxP7UwkaHRJ1FdBazpcuH/RX94ZDxuXTHCyRHCItSliRxoXgtTzYL40I6Q95m/Vy0lUg/SHZhsZJSZ1Xoq9M9uc8qgntrIJhQEeQl42x/nGbar3JIgcs1xBGDoKqBJ4sEEuDIokV4d1xi+G5oR1CLYjEL/z5QlSqB6NCqtDPcSYUmEVQ1JgXYGjEL4/JUGpS1aJVHZTWoh0FBS2ptD+VKqrIqjsQpdHS1lcL6+qB6ibGQqD2CClmVfKnUwKC4SlzdOY0jwdL4cjki5K/6a4QLP3Yk1u1bWUsXp1ondjAfU9BdyFjYMM2mby8yc2OHZFzGMPPlsOrkMZpHpTVS6Yil3E4JDJEYGpnBZlAmEp24BqpZUN3+7X70nzW/gtSw9qFbOf7Rd7H2yLmYFxvIZmYLGjZhSnXQVtKQZSwhE8vWBMImrIsOCIqmFVhp+0U/XPSDL2rqSWaY5RD9ql+dH27nc93IStasWKCRlKRS09OuJm3YLnzOl5DYJUSx9kVT+/6x29smLh/4GybG6rnUS1IABEiLTgU/bhzJid17ecDxOT8fWw23bcEa+0tLGP7/9s473K6iXNzvrLLL6eknPUECISQUkRJ6EQyIoUgVpSi/K4qIIiJXLoGAAmJ5RC/FK01CQhUBDSI1EGpCCaGGAElOenKS03dbZX5/rLL3Pr2ffZJ5n2flrKw1a2bWzJ6955vvm+9T9CEyNBEqTLpZt0Qiwde//nXeeecdAK666ip+8Ytf9GbNOs1f/vKX8PyII44YkDr0FCVoKhSKQUeiKkPVIzWU7lNM5S4uExoayCQl7w0fybbR7XiX87UeRlkGLe4JLVIKrO2xcK+iEDlmdrkajVY8x2YnpvnpQ1O6QLHgT4KFb/IqBFQUJ4hHLaK6ja55pqEuGk12FMf1hKQg/mCuBrI+GcsxsfQ8XsrmwqgnKmWFufD5fJPZnEdCzBwBSQAThtSQtEw2N5SStE1ERiJEFCTUp6OA5ygn6jsCAkIBzyOrrdN8DaCh54RicQ3fkQ952kQhIeUYaEL3tV1OnpbQ9vPUhRsKvI704lNm91pm26lETyMBSxrhXsogpqcIa6ohcNHJajs1XBBaKKCSkzbXRNkNPfB6OyZtv8MC7WwoaAKWo2Np3n5aRzrowvOuqiExNDfsXwfN095KsIW3sBCUnYsjNeo3lwCCxs/T4ILd0LG5bMWX4xATuDEXabpYpsQ1HBwdYpEMZdEEUdMiErOYsGctkWIHpOCTrWPYsr6C9DOCiGsQKfa0/HbaJVVvYTXa6HYG6bi4trfHODYkhpsYwtb3h2OOTDL86GqGj6z344fqxLU0rtT4ODGajGvgIqiIJ4maNpsbSrEcHU0DzzGQ8LWX/rn0Q5t4De4JngSCnwSR3Yucd4CvHSWrwc87cjWHnja/2Ez7IWxcGqT/OczdS4m32JNL9nOYU26zv6mkGZrLSokXEiUg77vHKysWzxCLe/tEXUfQUB8PFyparJaFqyGSptGCpRWj2H/9RnYdXcf7501FfFxH2esbUCi6wo64RzOTyXDKKafw6quvAnDppZfyq1/9qsv53HvvvVxwwQUAXHPNNS3CmLz//vvE43F23XXXNvP4v//7P+666y4AKisrOeWUU9ot87777utyPTtDT82FlaCpUCgGJXaDS83iBmoWQ2y0yYhDStgjXsOrVgnSbD+GrTBctKgnUEnX02y1FlA+/6Hs3+wENmdO11ydEgiZvnfTXAFUAKbhEDUt4obnHMXyvcLajoaDF6SeIPSILywC2E4rgmIgRAbKjdwjdPgjsvPrdn6ARbNf57hphV5pHVfD8mNGenX1zjVNhqau4KUL4la6gVbV17XKUCvo1dmVXgiWwEttbjiQwHzUlQLHFySDxs0Kp9n3dMlqFD2hNWyhUEgNBG1XiDCMSTAjCQTzQDXV1iciDDuSo9/M/vXPA/NmckLJCE9LKX2BFCSu0EC6CP9dNZn1hhv2q/AcGdl4DoXsZu5jJYLU9ijgYjd1fj+mBAxLoFs6uV61pCYRuknGiGMbLknDZcVnI8gkTDIJT6tvAkiHxJoM2zdaJDdZHQi3CdASlO0eZdSsYjY+OJ7qigzmqDR6ZYYhY+oxShxqrSJ8I2pM3cH1FzICZ1jB5yeov9dCWYVe0DfZf8kZm0GP+ue5l/JapXUEvuY9x0FR0M/5+zSbazD9P/7t0HVuTvmOq+E4OfXJq2pOvv51XXcxIzYCz7GY0DzNqJSi2RjO7o9GgBODlKnztjWG/besZ89YLZ9VRnBNDWG7BS04KAqM3AWbQqQbdTv77LN55plnADj66KP53ve+xwcffNBm+uLiYiZPntzlct5++20uvPBCjjrqKI4//nhmzJjBsGHDsG2bTz75hPnz54f10HWdv/zlLxQXF7eb5/nnn58NndRLCCGUoKlQKBSpjRZbFjcw4RSDyc+uYtXXvuR5o2zFi2xzebD5faDZ5DNHdBOedqK4IunF1BSQTpmkUmb+XswcYVQIEJrb4pqpex5mTc3BcTWarAgZyyBpGeHE2gnNXL3MQ6c6OYKldz1baW/SLXwNW+67+YJQW7E/8YTM5qEncoXWpnSEZMZEy9HQaL7pX10qTkM6mtU6+oK25jt08Sa/nm9ZT8PpmUW6ro6F56xIExJTyzrkCQKFaH7HWNIg43reSS3XEzQjmk1gnptyDCxXJ6I5YSiYwIOtGYRKERJX2sQ1QYmRJq55exg9zWoREeFQrKf90CJuqAFtcGLeHlV/d6gEbALBOzAFFv7+S8+LaqhlDQRNPE/Hxa7paYc1iXBlqMk0fG2yEDIUmiT4wqdnYtokI6TcIASKR50Tp6G6CJeuOXdZ+89aIqMNdB2EBkIX3qGBrnuHpoPQBJoukZkUdrKJdBIS9RKrykGmulCgC/WfpEk1pSkZFyE21CSyLo5ZUkoDw7DTDokJcap3NxkyvjHUWmuaRLgumh/eJBjEuZ/7XM194NzK+5szZvwjtKgLVhZynGF5HSBb0VJ62st6K+p9njSHtONr7gUYhkNpcdLPtm2NpsgtO/dva//NWfTwKt4yUUkk7XnBNSySaZNtNSUUlaYxfRN419VoqCnKvrMf7ikxVGNJyWj2q9rEtFEJPv3RZJwHNhDdlESh6AyDJY5mV3jsscfC8xdeeIG99tqr3fRHHHEEixYt6npBgOM4PPfcczz33HNtphk2bBh33XUXs2fP7lSeheg8SAmaCoVihyC92cZJulQIl1i1g12sYZW0LlRJW8NN+xqcnH2GQNtqrByTOl130YzAmU9WYxmk86e+WfM7X8gUOWkCocR2Jbark7YNMo5OxjbQNBdN813B5AmT+PNNkTNhFnlzUD9JqMUM/t/WxDbv/aTAcnI0W0AyEyFtGf4+z0CIzTrQ8eoosR0NhBZqe7LxPn2hkqyG09NMeqakgQbSRvNiRAZ5B+/k76cLFEGB2avl6lktl/RKyLieUIjrawSFi9AkrnQ9Dab/VrqQmEISETYRzfFMW/FDk2iCqLR950Ce51oHDUvqaNKLdxmQCcxwA7PZHO1lsC802LcZCKJC4tVfaGRNhf0+E17oDCGl77AoKMtFCN8gUwrcZp3Y6ERJb4/itBsosyX2Jgd7U9ee6TESMlWwvSoDZIAm9JggVmkS3SVKSZHB0K0ZNh4SIV3pdbyuuUR0cKQMY8ACIESOPjmr2XYcLc9UVgLCDUzihZ+2VXVm2/gLP4l0BEvzvCbbju5pXg0bXXcxjGD/b/NnZZAFLfSxoRyZo0WXuZdyBneOFtR1NWxLR5reZ900HWxXwzQd4pEMkUhW0ExFIji2huP4+0k1iTQgoeu89qUxTNu4jT1q6tl2WDGb3sqJF6VQtMcOqNHsL0444QTuuusuXn/9dd599102b97Mtm3bkFIydOhQ9t57b2bNmsX5559PWVk724FyWLVqVR/XunsoQVOhUOwwJNZlKB8RYezzjdTtFqX6y/EW4QuQ4NRFcOojofWc1KUnD2nBBJSsYBkIjFpWcAw8lIbpcoK6h1pLzf8bOgbKcWoiIOkY+KEasWydumQsb7KZOwXO1WTm7beU2Wt5r+h7pw0m3sF7Q8u0QX2QnllrYzKaJ5R+sXWYnyiYmMusrSJe7EvpaxcRvmmsEEjhogkBmgtovs7RMw9N2Z5TG13LOuORQuBIwNVCpzuBaauWc+5KT+jLuF6MUdvVQo2m7Wa1ibqQRHVP26kJieuK0MNsXLMo1VNENQtTOKQxyLgGTU6EIs0iIhwvViSW78hHkPa1iEFURhdBkx3BwRMoU46RF0sz4+qewOn/DU0sJaRcg4SMIIL3F2C4GroWxMz0NJxBrFBdE2iSMC6oRk5fAGsTQ4nUmDTaBTyzagcnJWlanaFxdYbtrzVSefJQRr7msOywCrQyh5JoGk145uUpyyCRCZxy+WbGmpvnLTmRjuR5WhbCi6nqhRjCdyIUiJv+Q3n7nFtfeEplTDZsrQgXPirKEsSiFsMqmpDkOu5qrtHM/Z9sdYKep2X1x1e4gOUGe05lmDaVMkmlTSKag4x7XySmaTNkaCPDixLEDG//puN6e0gbG+M0NsSyBfghlxxD8MHYEWwrjjNDbCV6Yhnr169n7NixHXecYqdmR9yj2VsawfPPP5/zzz+/zfsjR47ku9/9Lt/97nd7pTyAiRMn9lpevUn7G5kUCoViEFG/IkW0QiMqGyCZbj9xrhawPW1fK0oP29KxLAPLMnCDPZNhusDkLtiTmX+uay5FkQxxw/YcAQWav5yym5ve5VU7V8jMLThnr1jEcIhGbKIRG0N3Q3VZGC+z2RFqP1udAOf6WA20qVkhtrnJYujdVXMxdYeobhPRvbAgwWQ82LMZPpOruSUrSOvCMxcNQpLgPx+YoXqmqVrWPJVAO50NMaIFzwdCv/+KLsIzwfWPPK0k2Xf2wpx4OdpSI+mapFzT8zgqdWxXD539BHULnAK5UsNxvRA0tusJwp4wrIXntuuFyAgE1FBY9Z0Mtcw3CG+T7ShjlUSzIbnFavNzMxgQACnJ2reS4EimvFOPncnu2hWtHf4ChKm7mJqL6TuaCjTumiY9q4NgnDVz1pXnqTXMtO3JZt7nP7givH23wXeCZTfTCor8ASdE1ttwcIQLUrl1yLWSaCb7BgtPacsg6QudGcsIF2l039GVoTmYen5IotYafmN5Ca9NGocrBDfffDPLli1rO71CAeQ4ECjcQzHgKI2mQqHYYUist7AaHMpKa9lcbQMVbaaVAk/bGdrckRUWczWYwf99ZxwSQVNjLHs917tsrsOfHO1nsKdRE5KYaTOmvM4XMl3qM/HQEU742yhb0TyG13KEzBwhUPr/1zWH8tIEGa0JKaC+MU6dFc9qNN1AU5KfeShYNZtkew6GcrQ/Unr7X/32CvyahM9qoONSFPE86paYGSzfOVBt2n9XNIT0NJ34hqCa8BwDBXWTSKKaRURziGie0xPbFyqtQEtI1vus9xZ+rFA/52B/ZkzLCmCBkBoImACNdhRL6p5gKJ2sgOdrEF0/3EmdHac2U+SZNuObcaJhuVmh0HLy/2Ycb/9p1ikTpNFJCRO0rGMZU/M0mo6moWkupnRxNSfcnyqExMUTkLVmE6jIhw5W2qVpYYIdAfOzBFtSFmNOrGDXJQkadxWkxtJMKMsuxxiaS0kku7CUsgykHYypIA6nhuvLWlISxuIUCD/+pchOTJubFHRggycAxxHUNcXC/+eiabJFFhLpa1WzQmPwbMvvgGDwZhe1grWpuoYi/5okErGpKE+ga56QGdE8Z0olkTQpPSc0U17l8MKbCEFTxGRLSRFl22tZtWoV++yzT7vvrdi52RE1moreRwmaCoVix0F6Ws2KveJoK6Rn1xls5GuF7EQv536LSWaYOLeYMImuu+hGVlvguL5oEHjKDOaGQmIaDhHDIaJ7ApAmJBHdxnY1oqaN7WhYto6hu5iG4+09dDWSmdbigzZzcgLEIhYx08bUBKbmYgVCWI5g2rz+uddDYTKnLcqKUjiuRiJjgvTNYkPpMvQlS/C/PA1nbtHkhGrxPapKQArh77MUoYDpvZsMnQgFekpduJ6mVDr+Prz8/bWB6aL0PbyGmkMtGz4l6A/b91qb86p59Q32ZTY5nhCadg3qm+JU15dRXJrENB3StuGHVBGhdi1XW+lKDdcXsqWviRTSC0/iBIsGOUKTxNPG6W4QWkVDChk6A8p+WpvF0WyKkliXgQJ2zNFVkussVm2RjCbD8CWSjA5r94rTOEbLCpl+B2q+5jtYrInoDoKs9jtj6/6CDzna4CBESjafNuXJNgwMLEtHiAhCeHuUWy7g+I8L2SLr3CIDfa30zSw0TRIxsntnLcvwwhi5tBA2c3EdzTOpNU10f1HMlYQLPV6B3iKRcAS4AmFLylIZhjUmqdxaT4WwOfHEE5k1a1YbjaFQ+OR+YRYihVy3nYhuCZqbN2/mzTffDI+lS5dSX18PtB4vpjmrV6/usjvgiRMnsnr16u5UF/BWNR999FHmz5/P22+/zdatW9E0jcrKSg444AAuuOACvva1r7X5/KJFizjqqKM6VVZHbVBXV8ecOXN45JFH2L59O9OnT+fnP/85Z555ZpvP5LosnjBhAitXriQSaWOFkvwYPi+++CJHHnlkp+quUAx26lekGPaVYoaUSbY5nuJCtuLfQkgI4977gROl5mnkmnuczD4E5AgrCIkZcYjFvD1SEkEiEfE1lIGg6Znu6UJSHM0QNyyKjUwYF9KRnqiWjukkMxFsRydqWBRFLW9fmq2TzBhB4aGZa1YLkg1fUFaUoiSaJq5FiQoby44E0lz2HZopb/JeLWuUF1JZUU8yY9JUPSSrbtG8DIQWZOcLTNIP5+EG5rD5cUCDib/mC4IS77vZFcKPIwngOxRC+GavWYc5Gl68ThCkHQOJlmOGm+sWxivLcj1nLYZrhuazUWGB9Bz5BIKnF1bFRUo9zMd2NTKJGBtXDMfZGMGNQsYqJtFUgjYe7OEZqinC1r36Rg2bmGGH2s2MY3h7NJ1mgiZeOBcLHaQvTCNxNeF7VRXomuubBju+wOB799XwHQXlLzzIVITE2oZWPrCDG/exatYDkSE6ww4r5UsO1MRiOBUQhAkSwhPMorpD8Gksjma8vbsyMFf29ia6LkjpensehQytFILFktDZTh5tz1abUlES6cA0l6wlQzNEG9fDcESBtOn/NXSX8tJkaC5e2xQnYxk4GT1ciPEyJittSoFt69TXFRE1bCx0ikzveyllm56zLgk4krKExfDaFMMaUwxJpjCli4MgWW2zYWkjJ9x2Qod9o1Aojebg47PPPuPJJ5/kvffeY9u2bSSTyXb3pQoheP7553tUZrcEzcrKyh4V2h123333bj9bV1fHySef3KoL4lWrVrFq1SoeeughzjzzTO677752Bbie0tjYyOGHH87y5cvDa2+//TZnnXUWn3/+Ob/85S87zKOqqoq//vWvXHzxxX1WT4VisGI3uCTWZRg5NML6TZL0EIFdLJoFQCffLLZNLWZwvZnGE8JfsZhhURFPYmrezr5GI+rHfyTrzMbXWhm6i6k5JG0TS9PRhIsrNTQBUcPBsp2wEJlbx9wqBVo/N2fPZY6A6PqOaRqsKNX1JQhdUlTixaCQriDZGG3VIZD0/20ebL5ZAqSvNvI0mzk3ZeCwxPMg25CKkhARGvVo+B6OG2gtfa0jMsyv1Xf18077gmLMd9QjRVaYdHLeJVfYdKW3b1LDpMGKhfs8y8yUr/2SlOhp4pqFQJJyDTYky6lZrrP9OR2zJIYRjwJgpWyEEAw10owwtsAmr7zxso6GepfaGptt04qoPqLc80isSSxHR8psTNFw/2qg0fS8DeH6GltXCnR/5UN3fY2wju8AKRtGJhvDMb+lEmszrffbDkCmxmHjM3Xs8p1hjF1ay5YTi4kZdhgKx9AcioyMbzbtff4F0vdMLEMPxJomkFLzFL+ur0PM2dvcyrAgWJUJFlQgiAWb/5E1dYfy4mRObFay5rDNv0MAXZPEI1mT7lTGJG15Cx26kJRG0piaZ7KNhJRlUpsp8sITaTnCZvg3+6e+oYimJu8zjyuJNErGLK9j+tbNlJQKDEPgupKmBqiulTTWeeFqop/Voaf62QuxYvBS6PsgC7lu/UxjYyMXX3wx8+fPbyFYZrcX5F8DWlzvDj02nd1ll10YN24cL7/8cqefGTt2LO+//36H6W688UYWLFgAwHnnndftOp599tmhkDl58mR+/vOfM2PGDCzL4u233+Y3v/kN1dXVPPTQQwwbNoxbb7213fzuvvtu9t9//zbvjxw5ss17119/PcuXL2ePPfZg7ty5jB8/nmeffZZf//rXXH311Zx88slMmzatw3e64YYb+N73vkcsFuswrUKxs1GzLMHYEyOMTDSxobgEJ56j1WzvezO0Z8u1S8sKQdnwJNkNVabuEstx7OOF7/CEi8CzamD2GAiflqv75yLM18hxeON/xSNlS5O75oQTZbJClhcuxSSRjBAryhCPeRNa19FIZgtotQFaLbGZMBtcCwTLXME1cIySsQ2EkKQdPWwDQ/dCd8hwniz8H7m2awOedlFogfdZz7lPUK1c09mskCnC5zx1dVboj+gOhvA0hehpdOFgSJdMo0H8NZ2iVXG0kUUkN2SoeauRhi/SuKnsewsdjGINo0QnOsygbGqMCZOiDKu1WVaj4VQIDN31tbo5QrUE1w36KesAKTSvloQed9G82JmOlJ4Jsf/X+7+b78VPCkQkg93k0v6He5CTkiSrMpSPNag1HIrMDFHdC+GhCy/+qrfwoHn7aoUIx52nUcwKlIGlQcsFF0nrH8aWmv7wsp9c11yKIxk0zdPC5yVrRbWiaZKoaYf5Wo6G8J0ICd+kPqrZGLgUWxmGr8mwx+oGNBcW75Oz2C9b1iyV9szch9Uk2WN9HeXJDK6EdNKm7nOL5AaL1GaL3Gg4Ra28tULRHjtiHM0dEdd1Ofnkk3nxxReRUjJixAjGjh3LsmXLEEJw+OGHU1NTwyeffIJlWQgh2H333XtNqdgtQXPOnDkceOCBHHjggQwbNqxLZqUApmkyffr0dtM4jhMKh6WlpZx88sndqSpvv/02//73vwFPKF62bBmlpaXh/aOOOoozzjiDvffem9raWu644w6uvfZaRowY0WaekydP7rD+bfHwww9TXFzM888/z+jRowE46KCDKC0t5ac//SmPPvooc+bMafP54cOHU11dzYYNG7j99tv56U9/2q16KBQ7Mol1Fk3rLb40aiOxt+PUxIZSvW8ctxicEVZodkeDiXSaTSx9TaIeszFMh+J42gs3obto/i9X2jeLtBydeDRDTLcxfMct3txTEtE8T4+eVsKbCqYcA9vVqE/HKIukiBk2Ec3OE+6k9MIzpC0DTQviTIqwaqF31lCbSTjZrKktpkGT6CJOrZ3292Pl7O6TwrclbvbOzUPA5LTF2i1DcQJHNoE60s9CI5BBJWXxFMWRDGWRFKbmIITXTg1WlKRl4vh7Ij2NrC94IdGEZyJbEUnmeYUNBARXamy3YkR1i4hm4/rvYmpOuB8yCDaTG0Yk15Mt/j0hoDYdD7WCGi44UHN7FFMvIS5dtn+RomFJErux9VmKdMCqd7HqXZIbLGrfTxKrNBh1bBkHLt7Kx2UlbJoxBLM8E5oou64W7l31lNG+JjYUevxFBS2rlQ7eRRMSV/f+ev/PLkgENKwc3N5mO0tqq82QiRFKjRSlZpqobvvehH3TZ3+RQUQ8D8ENVoyM7dJANPTsnDVpJ9QM5pmjQkt1ZRvWBVlFvBc6pySSJqrZoQAc5LXL0G2el+PAaZSroQnPYZYrPa/EGcsglbOAlXYM3H8kGbkJhpV7FgmuLqgvjuZpMSVA7ncBUJLIsEdVDSMbUjTVuXyxxia1KoW5sQNP3ApFF1Cms4ODBx98kBdeeAEhBDfccANXXHEFH330EXvttRdAKGslEgnuvvturrrqKrZt28Ydd9zBEUcc0ePyuxXeZO7cuZxwwgkMGzasxxVoi+eee44NGzYAcNppp1FU1L31tldffTU8/8lPfpInZAZMmDAh3M/oui5vvvlmt8rqDOvXr2fq1KmhkBlwzDHHhPfb44QTTgiF3N/85jckEjuGl0GForfZ+HQdiTUZJnwpxSSzmrKtTRg1GYyUgyZcZMT1J5q0rqzQJLrpEo3aRGMW8ViGoliG4liGWNTyQocYDprmhhkE8RVzomxmNSq+OOlIjaRlkHF1bJkNpREIUIH2D18wEdIzyzN1JxTg2rDxI2MZJFMR0hmDTMZbR5SuwLU173ACQZOWRxs0pSKkMmbeZFaGAiy+x1RPq1sUsSiLpimPpSiNeoKnqTsYfngFU/fMHSOagxEK4N77Bg6SIpoTmgwGGqqMH0YkFLpFVkOZ74AoNwQIOefCn9ALMq5OyjFI2ibpTyMkHhpCxCyl/pM0q+dtp+aFpjaFzLZIbbJZ+3AN6U0W0xJNFFelcfz2DmI5SplznnMt9wjuu64Iw6LkHrlhT3KpXW6xQ2szfTLbbXRNYGY85z+m8D4rnobaDZ1FRXWbmG77oXWCseOGn0NNy5khdzAb1TUXw/A+w1peiJCs6WogcBpB+b6X5IC4aRE3LWL+EY9kvP/rFrEg/I/uOQozdQddc7FdjSG1GrFig62vNvLFo7VIBJsr4n65/nB0BcKSmNUZijcm2fvjLRz+4UZKEhZr30iw4YFtOK/VKSFT0ft4X7KFfSh44IEHADj88MO58sor0TStVZPYoqIifvSjH/Hiiy+SSCT45je/ydq1a3tcfsF6nb3vvvvC856YzWYy2X0ru+yyS5vpvvSlL4Xn6XTffSGPHDmSFStWsHnzZkaNGhVeD1YUOlJVCyGYO3cu3/zmN9m8eTP/+7//yxVXXNFn9VUoBivSkmx6tp7khjhD9yviK85G6t912PZmJRsOilI/VQu9zuYhaKnR8NE1T5sUlQJb6CQtg7Rj0GhFQ4c1CcsMHZEEsSQjmgMCMo5OxtZJpiNEdN/Uz9BxpfecpkuGljRRGkkTN6xQYHVcT7CQwJrqoSTSrewjz92r5QjvANKNETKNkZw9XM1eLHCKkmsLm5ut64eJ8ENABCJ0oOEsjqUZXtZI3LCI+JNkT/OajXdZEvG0wsNjjRh+6IWEbZJyTBqsKCB850gumgBHeua/9ZY3qY7pFhHdm7zr3ua6cM9l4OU30GaF+yHJN+nNNo4n7Jescil5J0Jqi8WWV2pJb7HpCW5asvHpOsZ/cwhfbtzE4uFjsctNdNNBBhpNX5vsaBquq3sOlPw4j5rmNb0jhKfhBDL4Gk08R0iOv3/P06xnzTlTG3cejaaUEnO1hrWnga5JDFw0vBiaQXuYumcTGtMsrIjnFCftGFiuTlMmQsoy2W61tnjdbBEGGDqkkbjv7CuZjlC9vdQbKr45bvDXlYK065mL68LIW7vZmixGIrwFFE1SYnqazyIjE2rlY7pNuijhOZCSGrLKoCJusPmlBuo/STHssBJ0Kdk8NJ4Nz+IKRFojvjHJ9EWrGDY1iutItryXpHZFCpF0d4LlB8WA0cEi5YBTyHXrR9555x2EEHzve9/rVPovf/nLXHzxxfz2t7/llltu4Xe/+12Pyu+WRrOvaWho4PHHHwc8b7OHH354t/OaMmVKeP7FF1+0me7zzz8Pz3fbbbdul9cRJ598Mo2NjRxzzDE8+uijvPHGG6EqWwjBN7/5zQ7zOOWUU8L4VjfffDMNDTuet0GForeo+zDJ6gXbqH6jieJKjcm7VbN79VYqVjWiJV1vn0nzCaYvrLm2hmXpWL6G0LJ1bEf3TOBcgeuHI0lZJpZ/PdBY2baO5R9p2yBtZZ+XUmA7OpZjkLIN0rZ3z/H36Gma9DQpmuPt3dRynAq197LNf1glnsbFzR4ttJiBptLXUrb645x3rWUNAlNOVwqSlkkiEyFhRUjZhuftEvwJuPQFRNc3X82KSy7Cj2Pp/Q12YQq8/at6s4oFgmWoE5WEhwt54VWCxe1w/2atw+j3U9Q3OKx9rOdCZlgnBzY9W08krrHnyu2YmzOhxivXGRBhXX3NcIuDnL9Zod11Rdg+YWtIst6Td3CcJpfGRpuy912srYKUbZByDNKut+DT/LBlTlgPcj7GgWMuwyFq2kRMB8NwcuwQsoRxcLMfVHAAW/iHhnQEsglYYRN5RRJ/1MxTmI56JUXJsjR8loHPLTIN3ndG8H0RaOj1wNy+yWbi2wkamxwaVqYYe2I5Q6fFWW1GsaptomuTxNc0MfazGvb+dCOHVG9i2B5Raj9IsmbBdurfTaAlXGU6qOhTBFnz2YI8BrqBCoRt27YB5EX7ME0zPG/NMvKEEzzP00899VSPyy9Ijeajjz4avvi5557bI69Hs2bNYsKECVRVVXHLLbfw3e9+l+Li4rw069at49577wXg0EMPZcaMGe3m+ctf/pKqqiq2bNlCcXExkyZN4sgjj+QHP/hBh0Lq3Llzefrpp/nwww85/fTT8+7NmTMntJluDyEE1113HbNnz2bbtm3ccsst/M///E+HzykUOyvShtrlSeo+SlI+Lc6QfYqYuSHNFpKsHD2ShnKzxa+SnTCxkwbphkj4i1pUnsIwPW2J62o0NcRo9NOXliaJRmwkYNk6DU2x0OmIl7enEQymu/WJGPW5dZSComiGsiJvP5YAIrrt7QW1NfIr2Hxfac4eytwkoTBJVnvbyuQzFFS0NvIWQXB5mVV6imxaKQUpxwQbNteVkrKN0POmpkmGFzehmVZe0UGMP08QFDRYUX+vXTZVRLPRNZcSw/PAaWhe/ExXCl+Y8DzLBiFOcs1kc7WaeeVKg1GL6zAzkg1P17VsjB6SqXHYsriBMUcJ7H+v56PzJuFKLRT4kYAuPC0nElfHDwsTKJM131GNL7wHTmv8/aqam+91dmeTJbY91cD4kyoY8h+dVQeWYo3xhMaI5WCkAQeSMR03Iig2Mwi8OJJpxyDj6OH+6rLiJBHdoci0vOu2wdatZTiOnrcY4/oxUZOWSToVgUbDGwtuMKGVDLWamLi2juEZEEKjaW0m69lRwpDVNiOKNDL1DjUfJlkxexxyepTJo6oxNC+urhBe6B5bapQukehNsOXxWrSIhlHsLdZMSqeofK8RNyOJjzLRDEGmzqGpKkPte4kum3wrFD1CeZ0dFJimiWVZeVsQy8rKwvMNGzaw66675j0TyEnr1q3rcfkFKWjmms2ee+65PcorGo1y//33c9JJJ/H555+z99578/Of/5zp06eHXmdvvvlmampqmDx5MnfffXeHeb7++uvheW1tLcuWLWPZsmX86U9/4uqrr+aaa65pUzgeNmwYr732GldddRVPPvkktbW17LHHHlx22WVdetdvfOMbHHDAASxZsoQ//OEPXHLJJZSXl3f6eYViZyQUOD9MUjYtzpD9BQdvrGLtCoPV5aU0zRjimYgGth45zmUQErs+iqu5SD8knbTDhKSTJralh5pQkoa3d8vFC60iQDgCqUmkKcG/hiUQjkCzBNrWJMaaWlzdJhmVNEwbjhPVaSrWkQbIiEvG8vLNaiFbOQdfrSeyf3OETvwV3+L3tzG8LoGuQdqGlCtIjsnfxy4sP+alIUMHKhLhW9xK0hmTmsaiUJjO2Lq311AT4V7TpK+90aSvqRUultS9/Ya+6WvKNsNQFAACz5NosPdN93exunimhZ4ppNGqkBnk6brCz8l/dQmOpTEyA42fp7G29U0oh4YVaeKVScZPjeE+u5HPpg4jPSaeLxUGErubc9n/XKH5mlnXM6NFuAghcHBxfedBeSrNnQirxmHNwzWMPKWC3d5I4EjPtNjM+821saXExsVCkpYS0xWkJDTtNYLMsBgi5mCbNsI3v3ZcDSwNvc6hdMV2hm6rRwdKi9PETJcKqSEcDc3WMAWYusTUJDFDYuqQSEL1u000rkzhJHMXAiSr7ttGdKTBkL3ijDywmKEba9i6VuBG0ljCwfWdjJloxKVBsYiw+Y0GnAbv+poHazBKNYrGRIiPM9Gjgm1vNtFUlcGqU+FIFAODcgY0OBg/fny4ZS+gsrKS4uJiEokEb775ZgtB86OPPgI8vzU9peAEzaqqKl566SUADj744BYv3x0OO+ww3nnnHf70pz/x5z//mYsuuijvfklJCddddx0//OEP23VwNHr0aE499VQOPfRQdtllFwzDoKqqin/+85/MmzcPy7KYO3cumUyGG264oc18Ro4cyV//+lf++te/9ui95s6dy/HHH09NTQ1/+MMfmDt3bo/yUyh2FqQDde8nqf8oybADipmwV5yhTdt5K1VCMmbmaSOycSUFVkJHuOCanjAqTTfw9kMq6e+btDSELRAZgWaBbkk0w8FwXSIZFx0HLeJg4IXVMFMS05IIS2CvS2G+0ECmxiZpmtScPhx7iEnTWHDjDrLUQehu1g8JZLWZeQJndo8mMicypm/6F824jKutZ5JdS3RY/qKYnd6Wr9PMaAjdix0ode/53D2bqYxJyjJCzW0YnD6nDROWibA9BzwiMBH0hUrdjz+adEwEnnkt/r1iMv41J/T46/jOcAKNZmhCG5qWZuNW2oGgGVZFMHSNRRTY9HbfOlLb8lIj0oFJ0+OIqlo+qGxlT6AvJHt95e27dMndVyd84d6XPH1t586Ok3DZOH87RRMiRIfqaBFBeruD3eggXTBLdSIV3mFW6BRXGGim16q7fFxDImLSVKyTLNHRihyMjI2ZkuxSnyKSshkVizFpWBqhBap7L+yIa7s4to2TcHGSLnbCpT7h0rQqQ7q6ffPr9BabTc81YJY1UbF3EZW7xdC0KFajQ2qzRWykiVmq41gutSsS1H+UynvebnCpX5GifkWqjRIUin4md2GzECnkuvUj++67LytWrGDZsmXMmjUrvH7ooYfyn//8hz/+8Y+cfvrpRCLeHKa+vp6bb74ZIQRTp07tcfkFJ2jef//94SSvp9rMACklf//73/n73/+Obbf8MWhsbOSBBx5gwoQJbToe2n///VmzZk2eXTN4m2ZPPvlkvv/973PcccdRV1fHTTfdxBlnnBHuo+wrZs2axSGHHMKrr77KH//4Ry699FKGDh3ap2UqFDsS0oHq15toWp1h5FfLOPzTtaytFmxrFLgVQ9B1gVZT4+0t1LwvTF0D3fC8w3p//XONvMPQPPlAa8fy33HBcby/AohWSMQ3hwCQqXeoTKwhWSto+lyQiMVpGjOMhsk6djHISFaQC52YBKaZwjeVlSAcT5OqJ8BszDB19XpGlnlCW90mm83vNGLVO5ilOmaZjjY2FgpmAjj87S/YYkdYM300qTKBG8HTxkrhazcDK93AUZDnX1f4prXSj5spyDHv9c1xJYTOgTSRDU8ReLR1w/2InlOhQMi0c67laTJ9IdPxne+ETpT8/LSEyy4f1lNbY5Op6SNt5kFDKf5SjGERh9KIr6kq0r2+aS2MTKiB9tsn0HIKz2xTiKCNBQIXx9Ep2Zbv1XRnJVGVIVHV8npre271Yg2zXIfpZUSGeJ6kK0xv3Nqud2TSGqm0pDGZpnpVI7YvUDpJFzspkVbPZ65WvcvWxY1Uv9pIbLRJ8YQIsVEmTWsyNK1Ok9xg7TR7bhWDGyElooDNUwu5bv3JV7/6VR544AEWLlzIlVdeGV6/6KKL+M9//sM777zDjBkzmD17Nslkkn/+85+sXbsWIQTf+c53elx+wQma8+bNAzyT1zPPPLPH+bmuy1lnncUjjzwCwPe+9z0uvvhi9thjDxzHYdmyZdx88808+eSTnH/++Sxfvpzf//73LfJpvq+zOQcccAC33nor3/72t5FScuutt/ZYY9kZrrvuOo455hjq6+v57W9/y4033tjnZSoUOxrJjRZVD25nxMxiJk2LM2mkBLwN9LRikS5diZvJHk7GDc+tjCSdkbg515wwbfaaa8kWK67CgEiFQWSoTnSoQWSowbChOpUlOtCEm0qwbXWcTUOL2DoiSjKu+xUiax7rCtBFqL0UjqddHVaTYo/GTURLHLYvTVD3URI3na1AOmWT3mrD52mCikkpYVOayRMkE1dX8cXwCj4bW4orvD2D2X2bvpCZI/2EwqoIzFez6YK9kwjP0Y+pO74HWYEjjTCNG4Z/EeG5EwqUzRzlNAtj0kJodQWj1iWJ6rDp+dzdsb3Ll/Y2KRcWtUURPh1SzMbyYpIR01dY5rdRtrHw9m+Gbep9xtA84VPD614hBTKpsefHvb+3dEfHaXJxmlzYsI32dIJCE5iThlC/Ou31QR8hXUiut0iu3zk8Bit2QFz/KFQKuW79yCmnnMLcuXOpqqriiy++CCNwnHTSSZx33nn87W9/Y+XKlfzhD38ACJV9xxxzDJdcckmPyy8oQXPJkiV88sknAMyePZuKiooe53nbbbeFQua1117LNddck3f/kEMO4YknnuDcc89l3rx5/OEPf+Doo4/m61//epfLOvPMM7n44oupq6sLzX/7mqOPPpojjzySRYsW8ec//5nLLruMESNGdDs/T/swcKtAQfm9UYfQF0o7eYn21E2KFgjNM+XrcbvlKJMKpg8c2PpKE7XLU0SH62glUVwb3LpUjqAocS0X2QtOSkXgcjUXFzLbHTLbHRrJhmbSTIE5OkZ8Ypz42Camp5oQGwWJpKShETZWlrJx+nBwNDQHDARFW6GkykGrrmGMWc/ISkjUS6qersX293W12fY5/bPpmQYYGqFsZhlfcrczYcN2Vowayvrx5ciYRGgAXogHLw6Hr38LzGd9IVggGRJNhiFiMr5zliLdIm5k0IT0HLbYBp5KFpJWBMt2iQjbi5EoXBrsKBnHxHF1L0Zo4PgnN0ZlGKdSC4VRxxaMX5+ifl0Gq87ts89dLGnT4AoaN6QoJUWp3Ja9KTyF5ZAhZQyrqUdKaJpQxtpdhiEdHamDU2EjdbLticBxAFfgOoK93thIzLXyviMLZgztAOzQ33GdZCDnAB3R33OEwcJA9JnSaA4OKioqWL16dav37r77bg455BDuuusuPvzwQyzLYsqUKXznO9/hJz/5CZrW8+AkBSVo9qYToIC77roLgNLS0jyVcXNuuOGGUJt65513dkvQNAyD3XbbjaVLl7J+/fruVbgbXH/99Rx22GE0NTXxm9/8pkcxb+rq6gZc0Gxs9Px49sTbcJn0wkBIKamva3v1f/ikId0uY2dEaIKKMaUgRM9W+z8PfuJFYfaBC6FLWLMETKB9o4b+Ya3EXitpMAWxUTollSbDx5pMiWnYq7dTG42R0A2Gm5BONxItdYhUgGaWUv9REuvTNBVDyqCjJm+tfz50SKwRVOxdxKGOQ+2GBlaPKKGpOIKMaBCYy4rAqDUwnwVdeqaxozQHI9iTiUkKg1HSJS4NkJB2DUy3yDf9leCCLiRR4mgCDM0hbkcwXA3sSGguK6Wn6ZRS4Pgmtp7W1Nd8uoKSOpvKaDEb6mH4JL2POgiKnSKGjTIZPbKdNCXFjBzqNY7QBV/eVEONEWddUSmNFXF890aeMwsJpFxwoHJbil3Kitj2dhPZaXKBjqFByk7zHdcOde38Zg40/T1HGCzU1/edlUabqD2agx4hBBdeeCEXXnhhn5VRMIKmZVk89NBDgOcsJ3fDak/4+OOPAZg2bRrRaLTNdOPGjWPUqFFs3rw51Kp2h4EQ0g499FCOPfZYnn32WW677TYuv/zybudVXl6e5/a4vwnar7y8vEc/IsEMVwjRrjfe6tU13S9jJ0RoAqSkek1tD83KQj+gqg+6y8rsqTk2QvGkCMWjDUpLdMx4CfVb6kj65oJ1HyS7uCex7f7Z+MF2YrvFGPnlOJO3VLO1QeeDL08gXSyQERct4iI0T1AKnAPpQnrCptboeZIVYBoOEc1FRBqRukPKMci4Bo7uTSKlH/LEkRpbHN8GSgocaSER2MIOPdCGMThdEXoQdfE0gCBwXdhtfQObE0nWLd+OUd935oodfZ6FJhg+sSI7hioMyqfGqPhShImxTaxsGk7VsHKcuERPauhNDuMf+pixexgUjzCp+iRF9cuNqDHUN6jvOArag31/zxEGCz1qi+6iwpsoOkHBCJoLFy6kuroagG9961sYRu9UzTAM0ul0q06AmmNZVvhMd7Btm08//RSAMWPGdCuP7nL99dfz7LPPkkwmufHGG9l33327lY8QYmC+sFqpQ2/Uw/NH0nY+fbkHZ0dFSq/deqvtVB/0nMzaNJm1aWrwBZlJLtWrezpR9mgtj9QnSao+TVIxPc6wA4s59IsqPqsoY+2QOHKIjozie0Hy93riKYlt6XlP1ZC+syQXTfPiQkrflFjXXP8ZgbTBlXhxKINrvsuhYHuQFH4oEAGuENmILoHVrm862xCLMN5uBL33PrvdJW8Mbbeofc2ibqlg6DHlTNW3Mamuli3xGMIWGJbLqENi2I0u6/5Z2+qevoF+nx2Nnf07bqDnAB3Rn3OEwcJA9JkKbzI4uP/++znllFM69DXTV/Tc+LaXyDWbbcvza3eYPHkyAB988AG1tbVtpvvggw/Yvn173jNd5cEHHwzNF4444ohu5dFdDjzwwNDc9y9/+UuvBFlVKBSKNnG9mKSrH9xOYmWSaTW1HPHWWkYta4SaCK6tIR0NcmJbbmooZUN9OZsaymiyPFfqGdcg4USot2JkXJ0iI0OxkaHESHsCpNQ8bWXgUdbPy/Gvh86A3GZHcM0ROLbGtvIoGlA0smDWV/OQlqT6mVq+eKKO1KcJRq2vZ8SmOoZU11O7PEnVI9uV4xiFQlE4BBrNQj4UnHvuuYwaNYpvfetbLFy4EMfp39i7BSFobt++nYULFwIwY8aMLoUFOfLII8OVrdY2u37jG98AIJ1Oc9lll7Vq2ppKpfjxj38c/v/EE0/Mu19TU8OiRYvarceSJUtC70xCiBaxOvuD6667DvDe9ZZbbun38hUKxc6H2+Cy9bl6qh6rQVqSfZ1a9lu+lqGvVRP9pAk3oyEdz0GP65u1OlIjaZnUZ6JsTxexPV1EoxUlYUew/fAlttTQNYmhORiagy4CTWeuUWIwl8hqOr2dV77X3eAcaIobpAyN4gIVNAGEC87GjNeeD25n7UPbWftwDdvebOoVB1QKhULRWwi38A+FRyKR4KGHHmL27NlUVlZy8cUX8+qrr/ZL2d36xX3llVf47LPPwv/n7mlctmwZ9957b176888/v938HnzwQTIZz8Nib2ozAS677DLuuusutmzZwj333MPKlSu56KKLmDp1Ko7j8O677/KnP/2Jjz76CIA99tijRX3r6uo46qij2GuvvTj55JPZb7/9GD16NLquU1VVxb/+9S/mzZsXvsPll1/OV77ylV59j84QxPR8/PHHQzNkhUKh6A/SW2zW/aOW0t2jDD+whP3JsPG9JpaPLsMtA810cV3PtNd1BfXpGI1WBF2TaEKiC5e4aWHq/mqrhIjvPAjAdjUSlu57k805gvicvnfbcDE7FDZBaCB12FYSZdioDNsHpIUUCoViB6LQtYaFXLd+5Pnnn2fBggX8/e9/p7a2lm3btnHHHXdwxx13MGHCBL71rW/xrW99iz333LNPyu+WoHnnnXfyt7/9rdV7TzzxBE888UTetY4EzcBsVtd1zjnnnO5UqU2GDx/Of/7zH0499VRWrVrFK6+8wiuvvNJq2n322YfHH3+cSCTS6v3ly5ezfPnyNsvSdZ2rr76aOXPm9Erdu8PcuXN54oknCto9uUKh2HFpWJGm6YsMQ/crYsxecYYtq+KTseVsmlCCVuztrpRaoI0URHQbQ3MwNRdDc7Bdz0RWIojpFpofa9ORgrhukXZ0HKnTkIki8YRRzZDoSCxXw3Z06pJxpOuX4QhkSqPk3RqSdRmiQ3S0qMiLIapQKBSKriFciSjg/ceFXLf+5KijjuKoo47itttu46mnnmL+/Pn861//IpVKsWbNGm666SZuuukmZsyYwbe//W3OOussxo0b12vlD7jp7MqVK3nzzTcBOPbYY6msrOz1MvbZZx/ef/99br31Vo477jgqKyuJRCJEo1HGjx/P7NmzmTdvHkuWLGHixIktnh8zZgyPPPIIl112GYceeiiTJ0+mtLQU0zQZPnw4hxxyCFdddRWfffYZ11xzzYBupN9rr704/fTTB6x8hUKhcC1J9RtNrHm4Bmd9mn021TJtZR2uTaiJDOJfRnWbkkiG0kiamGGTcQ1SjknSNikyMpSbSYZHGxkZa2R0vJ7hsSYqogk04cXjjJs2ZdE0I4obGV6UoKIo6RvR+tgaNOqMeW0ro2uSCCGIDi9c81mFQqEYFAz0/ku1R7NLmKbJSSedxMMPP8yWLVu49957OfbYY9E0DSkly5cv5xe/+AWTJk3iyCOP5M4772zXt01n6dav7b333tvCPLa7TJkypUfat472TgYUFxfzwx/+kB/+8IddLiMSiXDaaadx2mmndfnZ3qIrbfTQQw+FoWIUCoVioLBqHdb/u47orOFMpIGmlRprJ5bhlmYQQuCKrOAZEHzVSemFLtGljivtvD2YnrmsQCCJaDZR/3ClQHM881rPEZBG8aoGpn5Wy8iDYqS322xZ3EByg3Kqo1AoFD3CM1ApXJSc2SYlJSWce+65nHvuuWzZsoWHHnqI+fPns2TJEqSULF68mMWLF3PJJZeQTCZ7VNaAazQVCoVCseMiJGT+Xc32j1LsvqmOsk0WruMJglLmhCmBcM+lZzoLtqtjuTq273U28Dwb3BdAVHeI6A6m5qALTwyVUmAmXaZ8UcfMzTUMizpsebmBqkdqqPswpSYgCoVC0UOElAV/KDpm5MiRXHLJJbzxxht89tlnXHfddZSXlyOlDH3P9ARlP6RQKBSKPqf61QaiI032y2zklfhY7OE6xG3qknGaMlEMzfFj2vk+ZAVsdHSE8OJugqfNtF0NicByDAzNIeUYWK5GyjGoT8dIWCauK5jxwTZGNqap+SJD7asNOEk16VAoFIpeI+v2uzAp4KoVIp9++ikLFizggQceoK6urtfyVYKmQqFQKPoc4cDmhTWMP2Mo+6yq5u3i4bjRQHAEVwpPqAwOJJarg6+7DNJIGZyDixdTUwqBIzUyjk7GNpBSUB0xGaVlqH23SQmZCoVC0dsU+j7IQq5bgbBx40YefPBBFixYwDvvvANkt+pFo1G+/vWv97gMJWgqFAqFol9wkpKNz9Qz7kTBl9/YzNt7j8MenkHGHAQOQnihSGKGRUk0TamRRghJ0jFJ2wbbU0WhoCkRZGydaqsYx9WwbQ27MYKdMnBdwcZRQ9iztgnrayPRFmwc6FdXKBSKHQuXIExxYVLI+0cHkPr6eh599FEWLFjASy+9hOu6oXCpaRpHHnkk55xzDqeddhplZWU9Lk8JmgqFQqHoN9IbLTb+u47K4ys48OP1LJs2BGuUjq65GEIS0W1ihkWxkSFuZBB4mksBxA0rDH+SdgxcqWE7GmKrQ1FVimENDZg2OEBCM7CEoFja9MyVgUKhUCiaU+j7IAu5bv1NJpPhn//8JwsWLOCpp54K914GAua+++7LOeecw9lnn83o0aN7tWwlaCoUCoWiX0mss1j3eA1jTyjnKx9tY0lkFNYwnWjUZkRRE2VmkopIEg2J623aJK5bFBkZmuwIGUdna1MJGUdDNgj2XlpDhS5xLYnd5KCZAqNYB2BcOawc4PdVKBSKHQ5lOjso+O53v8tjjz1GQ0MDkBUud9llF84++2zOOeccpk6d2mflK0FToVAoFP1OZqvN2n/UMPqMYcx8dxOfFEewKzUa944QETaWkUEIb67g+uFPopqN1MEUOk2mRfH6DLsuSyJcl02LGmhclUbaXv6RITojDy9FjxWybZdCoVAMUpSgOSjIDUc5YsQIzjjjDM455xwOOuigfilfCZoKhUKhGBDsepcN86sZc0I509MOq9+xWTNpPFIKYqaVF+4kotmURlKUGMLTcgJDPhAYLqx7qo7UxvzYmJkah3VP1A7AWykUCsVOgBI0BwVFRUWccsopnHPOORx77LHout6v5StBU6FQKBQDhpOUrHuyjtHHlTF5VxP9b+vZPjXOpwdXYsYsdM2lOJohqtuYmosmPDHT1B3q99Yoe0dj7EkVrJUm9S/XE/u4scMy07uVoh9cwdBNTTQ8ux3p9P17KhQKxQ6FcgY0KNi6dSvxeHzAyleCpkKhUCgGFGlJNvy7jlFHljJxShTW2nxUW0q8LI1pOGi652U27RoYwkETEl1I7KmCNROiFL0nGP9FGuvgGMmRkNpskdxsY9U56FGBHtfQ4xqRITolE6PEx0bQtBRM0nHGRWha0/Og1AqFQrEzoZwBDQ4GUsgEJWgqFAqFohBwYfMLDTgJl0n7FBF7YhUffnUUyREmNcTRtBg1TXEEXlTN8qIUQkikLtgwNc4XFeVMXlFHxTSd8j3cVhfaXaAOg3XxOBvGVHDwx2uJjzWVoKlQKBRdRZnOKjqBNpCFb968mSeffJKrrrqKr371q5SXlyOEQAjBtdde2+Hzq1evDtN39pg0aVK36nr++ed3uazcDbjNuf/++9lnn32IxWKMHz+eyy+/nPr6+k6X//TTT3dY5yDt+eef3403VigUiv6n+o0mtr7WSOVonWmrG3CTgpRlkMyY1KXi1CSLqEkVkbRNLFcnmEo0FZu8v+9wXj5kDM/uP5YlU0ewfPJQ3poygtemjuLFPcbyzIyJvD5jAp/vMoKUGaE+ISgaG0FNRxQKhaKLuLLwD8WAM6AazcrKyn4vc/fddx/wsq677jquueaa8P/r1q3j97//PS+88AKLFy+muLi4w7znzJnDrFmzeq2uCoVCUSjULk9iJ11GHVXKzGfWseTIMVglOpruIgSAYGt9Sai1tB3NX1wXIMHWdbaWx0EKT43pCHC9e8LftyM1yebxFYxoqMHepRjzi6aBeVmFQqEYjCiNpqITFIzp7C677MK4ceN4+eWXO/3M2LFjef/99ztMd+ONN7JgwQIAzjvvvG7V79e//jWXX355u2lqamo48sgjcV2XKVOmMHPmzBZpPvroI+bOnUssFgs1uVVVVcyZM4d3332X66+/nptuuqnD+ixdupQnn3yS2bNnd+t9FAqFopBpXJnGSbiMnlXO/h9s5d0JQ8mMjCINCZok7fo/X1LkCZnB3+yRFTLzVJcCtowqhYYaikabWF/0+ysqFArF4EW64Bawxx1ZwHXbiRhQQXPOnDkceOCBHHjggQwbNoxFixZx1FFHdfp50zSZPn16u2kcx2HRokUAlJaWcvLJJ3errmPHjmXs2LHtprn99ttx/UF37rnntprmkUcewXVdbr75Zi655BIADjroIA455BB22203Hn744Q4FzeHDh1NdXc2cOXP4xje+gRCF7PZLoVAoukdyvcW6J2sZe3w5M9/fwlsTJ9EwWuAWuWiGC0K2FDDxF7IDAdOfawjZUthMRQ2aIiYlQx1q+vvlFAqFYjDjNl+9KzCU6WxBMKB7NOfOncsJJ5zAsGHD+qyM5557jg0bNgBw2mmnUVRU1Gdl3XfffYC3N/I73/lOq2nWr18P0EKgHjt2LFOnTg3vt8cVV1wBwHvvvcdjjz3WkyorFApFQZPZarP2HzXgSvbfspbhVU3ENrmIDMhQU5kVMpGeuyDvPCejNuYc24pilFSoxTqFQqHoEtIt/EMx4AyooNkfBMIfdN9stjOsXLmSN954A4AjjjiCiRMntppu5MiRALz00kt51zdt2sSKFSs6tW/14osvZtSoUQBcc801oRZVoVAodkTsBpd1j27H3Zpm3+qt7PafevQtAtfSka7IHo6GdETOnkz/CGhF2NxWHCdWrKEX7fA/hwqFQtF7BHs0C/lQDDg79C9rQ0MDjz/+OAATJ07k8MMP77OycgXatsxmgdB09+c//zk33ngjb7zxBo8++ijHHHMMTU1NnH766R2WVVRUxJVXXgnAhx9+yEMPPdSzyisUCkWB46Yk656sJbXFYeyUesZVNRLdrEFaBzsQKvGO0AGQdy7cHI1nMxqiEQAiFXo/vYlCoVDsAAy0R1nldXZQsEMLmo8++iiJRALwhL++2ssopeT+++8HPCHwtNNOazPtV77yFS699FKSySS//OUvmTlzJqeffjofffQR06dPZ86cOZ0q86KLLgr3jM6dOxfHcXr+IgqFQlHASBs2/Gs79Z+lmOrWMHlDA2Q0pK15QmWzvZnCFZ6Q2ZbRh4TitAVApk59hyoUCkWnGWhtpdJoDgp2aEGzs1rGnvLyyy+zevVqAE455RRKS0vbTf/HP/6R2267jWnTpmGaJpWVlVxyySUsXryYsrKyTpUZi8X45S9/CcCKFSuYP39+j95BoVAoBgUubH6xga1fSL5kVTPz1S8Y8/pWItsM9HodLaEhbIFwWvE0GyA9IVRPCsrrLRxL4jSpLQgKhULRaSQDL0i2ewx0AylgBxY0q6qqwn2QBx98MLvuumufldWdfaA/+MEP+PDDD8lkMmzcuJE//elPVFRUdKncCy+8kAkTJgBebE7btrv0vEKhUAxGhITaZ6rZ9Hw9xTjsG2/ky1UbGbY1iV7voiVctKSLlnQQlptnUqulXbSUd6+0Ns3wpgSpBjUjUSgUii4x4IKk0mgOBgomjmZvc//99yP9D1lfajNTqRSPPvoo4HmOPeaYY/qsrOZEIhH+53/+h//6r//i888/59577+XCCy/st/J3BGJDIgNdhUGFEIJImUmsIhKOr26xPXuq+qB36ZU+GiT9Y1VLNv+nkfguUcqmuuzvJLA3SVK1Luk6l1SdS2JMGXX7V+IIDdIOY174gpJSKB6hESnRcB1JzapMv72nGkOFjeofhaKTuP4m+EJFOcosCHZYQXPevHkARKNRzjzzzD4r5/HHH6e+vh6Ab3/722ha/yqJL7jgAm666Sa++OILfvWrX3HuuecSiXT/R01K2bMf1x4SlN8bdRD4lhPt5HXru+3HLFXkI6UkmUwQjxf1aM+zNvlBcF00TVN90Mv0Rh8Nxv6RUvLFF1+wbt1a1q1bx8aNG30rjzRsWJNNuJdBPB5n112nMGXKFCZPnoxpmv1aTzWGChfVPwzoHKAj+nuOMFgYkD4rdK1hIddtJ2KHFDSXLFnCJ598AsDs2bO7bJLaFfprH2hbGIbBnDlzOP/881mzZg133XUXP/jBD7qdX11d3YALmo2NjQA9+pEvk9L7EZGS+rq6ttOVtb+fVpGPlBJNE5SUlPSacy3VB71Lb/fRYOqffffdh3333QcAx3Gorq4mlUphWRaZTAbLsqioqGDcuHHo+sB4mVVjqLBR/ePNAwqV/p4jDBYChUe/ogRNRSfYIQXN/hL+Nm/ezDPPPAPAfvvtx7Rp0/qsrPb49re/zQ033MCnn37Kr3/9ay644AJisVi38iovL++0Q6K+IBByy8vLe/Yj7z8rhKC8vLw3qqagF/snB9U/vUtv99Fg7p+hQ4cOdBVaoMZQYaP6p7BRc4TW6auoCu3ituVtrUBQ4U0Kgh1O0LQsK4wrOXLkSGbNmtVnZc2fPz8MK9JZJ0B9ga7rXHPNNZxzzjmsX7+ev/zlL1x66aXdyksIMTBfWK3UoTfqITZuhPHje6FWioByKb3+6Ukm/t4J4bqqf/qAHveR6p8+RY2hwkb1T2HTK/2zfj3gmc8ywHOe3mAg5m1SukhZuPsgC7luOxM7nKC5cOFCqqurAfjWt76FYfTdKwaaU9M0Ofvss/usnM5w1llnccMNN/Dhhx9y00038f/+3/8b0PoMOEGIGdcNf1AUPUf4R6+i+qdX6fU+Uv3Tq6gxVNio/ilser1/LrusN3PbuZCysLWGynS2INjhBM3uhBrpDu+//z7vvfceACeccALDhw/vs7I6g6ZpXHvttZx++uls2rSJ2267bUDrM+Bcfz1cfTU0NAx0TXYoJJ7pUo9Xk5NJMAzoRycsOwu90keqf/oMNYYKG9U/hU2v9Q94QqYSNLuPLHDT2V4QNKuqqvjTn/7EwoULqaqqIhqNsuuuu3LGGWfwwx/+kKKiol6oKDz44IPcc889LF++nJqaGiorKznssMO4+OKLOeigg3qljIFihxI0t2/fzsKFCwGYMWMG++yzT6efPfLII8O4m6tWrWLSpEntpv/b3/4Wng+EE6DW+OY3v8nee+/Ne++9x29+85uBrs7Actpp3qHoXXzHCeXl5TuEudEOieqjwkb1T2Gj+qewUf1TOLguiAI2T+2h6ezChQs555xz8pxjJRIJli5dytKlS7nzzjt56qmn2GWXXbpdRiqV4vTTT+df//pX3vU1a9awZs0aFixYwLXXXsvVV1/d7TIGmgEVNF955RU+++yz8P+Bp1iAZcuWce+99+alP//889vN78EHHySTyQB9q810HIcFCxYAnrOJE088sc/K6gpCCObOncvJJ58cmg8rFAqFQqFQKBS9yg6s0Xzvvfc444wzSCQSlJSU8N///d8cddRRJJNJHnzwQf7617+yYsUKvv71r7N06VJKSkq6Vc73vve9UMg86qijuPTSSxkzZgzvv/8+N9xwA59//jlz5sxh9OjRXHjhhd1+n4FkQAXNO++8M08zmMsTTzzBE088kXetI0EzMJvVdZ1zzjmnV+rYGs8++ywbN24EvL2RPYlb2ducdNJJfOUrX+Gtt94a6KooFAqFQqFQKHZApOMghTPQ1WgTKbtft5/85CckEgkMw+CZZ55h5syZ4b2jjz6aKVOmcMUVV/DJJ5/whz/8gTlz5nS5jJdeeilUWn3jG9/gH//4Rxh2a//992f27Nnst99+VFVVccUVV3Daaaf1abjGvkIb6Ar0FitXruTNN98E4Nhjj6WysrLPypo3b154Xihms7lcd911A10FhUKhUCgUCsWOiisL/+gGS5cuZdGiRYCnccwVMgN+9rOfscceewDwxz/+EcuyulzOzTffDHjKsdtuu61FbOfhw4eH2+Bqamq46667ulxGITCggua9996LlLLTR3tMmTIlTPfvf/+7y3VZtGhR+HxH+zPnz58fpj3wwAO7XFZ3yG2rjjj++OPz2q25CbJCoVAoFAqFQtFtpPT2QRbs0T1B8/HHHw/PL7jgglbTaJoWKppqampCwbSzNDY28vzzzwOecmzcuHGtpjv11FPD2PaPPfZYl8ooFHYYjaZCoVAoFAqFQqHoe6QrC/7oDosXLwaguLiY/fbbr810RxxxRHj+yiuvdKmMJUuWkE6nW+TTnEgkEnqdXbJkSbc0pwONEjQVCoVCoVAoFApF5xlwjWUnjm7w8ccfA7DrrrtiGG27spk6dWqLZ7paRvN82ivHtm1WrlzZpXIKASVoKhQKhUKhUCgUik4z0NrKvtBoplKpMGpDW+asAUOGDKG4uBiAtWvXdqmc3PQdlTN+/PhWnxss7FBxNBU9p76+fkDLl1JSX1/vBWNWMbIKDtU/hY/qo8JG9U9ho/qnsFH90zoDMXezZbrHsSr7EhvPzLR520SjUaLRaKvPNDQ0hOedCVlSXFxMU1MTjY2NXapbV8oJhFmgy+UUAkrQVACeHXhlZWXeyolCoVAoFAqFovCprKzsl3B7wXzxlU1P9XlZPaWkpKTFvPaaa67h2muvbTV9KpUKzzvTloHAmkwmu1SvrpSTKxR3tZxCQAmaCgBisRirVq0ik8kMdFUUCoVCoVAoFF0gEokQi8X6vJzBNF+UUrbQfLelzQTy2q8z7xc49InH412qV1fKCcroTjmFgBI0FSGxWKxfvqQUCoVCoVAoFIOTHXW+WFpaGp53xky1qakJ6JyZbXfLCcroTjmFgHIGpFAoFAqFQqFQKHZqYrEYw4cPB2DdunXtpq2pqQmFwK5uO8t1ANRRObkOgAbj9jYlaCoUCoVCoVAoFIqdnj322AOAzz77DNu220z3ySeftHims0ybNq3VfNorxzAMdt111y6VUwgoQVOhUCgUCoVCoVDs9Bx66KGAZ7L69ttvt5nupZdeCs8POeSQLpWx//77h06AcvNpTiaT4Y033mjxzGBCCZoKhUKhUCgUCoVip+fkk08Oz++5555W07iuy3333QdARUUFRx11VJfKKC0t5ZhjjgHgueeea9N89rHHHgvDs5xyyildKqNQUIKmQqFQKBQKhUKh2Ok54IADOOywwwC46667eP3111uk+f3vf8/HH38MwKWXXoppmnn377333jDWa1uhVC6//HIAbNvm4osvxnGcvPvV1dX84he/ADxh9sILL+zRew0UStDcwTjyyCPDD3dnj0WLFrWa15o1a7jyyivZb7/9qKiowDRNhg4dysEHH8z111/P1q1be1zfSZMmdaqOkyZN6jCv+++/n3322YdYLMb48eO5/PLLWw1i/PDDD4f53nbbbe3mOX/+/DBtWVlZiy+C5uy7774IISgvL+8wbWcptD7dsGED559/PiNGjKCoqIgjjjiC5557rtW006ZNQwjBqFGjOsx3ypQpYf1vvvnmdtM+8cQTYdrf/e53HebdWXra1qtXr+7y8535bLeFGj+do9D6VY2hzn1fBSxatIjvfve7TJkyhZKSEsrKypgyZQqnnnoqt912W4+CmKsx1DGF1qc78vhRFAa33HIL8Xgc27Y57rjjuPHGG3njjTd48cUX+f73v88VV1wBwG677cbPfvazbpVx9NFHc9ZZZwHw5JNPcuyxx/Lkk0/y1ltvcc8993DQQQdRVVUFwE033cSQIUN65+X6G6nYoTjiiCMk0OlD0zS5bt26FvnMnz9fFhUVtfvssGHD5PPPP9+j+k6cOLFT9Zw4cWK7+cydO7fV5/bdd1/Z2NiYl3bjxo3h/bPOOqvdfC+66KK8/N56660209bV1UlN0yQgZ82a1ek26IhC6tP169fLcePGtVrmvHnzWqT//ve/H6b55JNP2sx306ZNefmdeOKJ7bbJz372szDtG2+80W7artDTtl61alWXngfkcccd1+36qvHTOQqpX9UY6tz3lZRS1tfXyzPOOKPDPN59991u11eNoY4ppD7d0cePonB48sknZVlZWZuf0d12202uXLmy1WfvueeeMN0111zTZhmJREKecMIJ7Y6l9p4fDKg4mjsY99xzT17Mndb46KOPOPPMMwE45phjGDt2bN79119/nXPPPRfHcdA0jfPOO4+TTjqJMWPGUFVVxd/+9jf++c9/sm3bNmbPns0HH3zQI60MwEknncSvfvWrNu+3twH6o48+Yu7cucRiMa666iq++tWvUlVVxZw5c3j33Xe5/vrruemmm8L0lZWVTJkyhZUrV7J48eJ26xXc13Udx3FYvHgx++23X6tpX331VVzXBeDwww9vN9+uUEh9+tOf/pR169Yxc+ZMfvnLXzJkyBD+/ve/88c//pGLLrqI448/nmHDhoXpDz/8cP7yl78AXlvuvvvurda/eTu/+uqrrQZabp6+uLi4zf7oDj1t67Fjx/L+++93WM6NN97IggULADjvvPN6UGMPNX7ap5D6VY2hjr+vwHPEcfzxx/Pqq68CMGvWLM4++2x22203XNdlzZo1LF26lEceeaRX6q3GUNsUUp/u6ONHUTh84xvfYPny5dxyyy0sXLiQdevWEYlE2HXXXTn99NP50Y9+RFFRUY/KiMfjLFy4kAULFnDvvffy3nvvUVtby6hRozjssMP40Y9+xMyZM3vpjQaIARZ0FQPAFVdcEa6WtLYCeOKJJ4b3b7311lbzuOyyy8I0l1xySbfrEqwmn3feed3O49prr5WA/NOf/pR3fd26dbKoqEhOnjy5xTPf/e53w/p//vnnrea7bds2KYSQgDzzzDMlIE899dQ26/Hf//3fYZ6vvPJKt9+nO/RHn6ZSKRmNRuX48eNbrNBfeumlEpB/+9vf8q5XVVWFeX7nO99ps/4//vGPJSBPOeUUGY1GJSCXL1/eatqmpiZpGIYE5Fe/+tU28+wrOmrrjrBtW44ZM0YCsrS0VDY1NXW7Lmr89B790a9qDHl0pq1/8IMfhCv699xzT5t5ua4rLcvqdl3UGOod+qNP1fhRKAYfao/mTobrusyfPx+AkpISTj311BZpgtXGYcOG8cMf/rDVfObMmROev/baa31Q086zfv16AJp7/Ro7dixTp04N7+eSu9rb1oryK6+8gpSSESNG8L3vfS+81hZBPrFYjP33379rL9ED+qtPt23bRjqd5oADDqC4uDjvXuA9rXlbjx8/PtSMtrdyH9w75phjwtXhttK//vrrYWyrYMN+f9GZtu6I5557jg0bNgBw2mmn9XhFtKfs7OMH+q9f1RjqXFsvW7aMO+64A4DLLruM888/v838hBAYxsAaZ+3sY6i/+lSNH4Vi8KEEzZ2M559/PvwibmsylMlkAJg8eXKb+ZSXlzN8+HAA0ul0H9S084wcORJoGYto06ZNrFixgsrKyhbP5P44tPVjElw/9NBDmTlzJrqus2XLFlasWNEibTqdZunSpQAceOCB/RrrqL/6dMiQIRiGwVtvvUUikci7Fzh+aK+tV69e3aoL7/r6epYvXx6mDWJYddQv0Psmlh3RmbbuiMAlOvSO2WxP2dnHD/Rfv6ox1Lm2vv3225FSEo1GufLKK/u1ft1hZx9D/dWnavwoFIMPJWjuZOROhs4999xW00yZMgWAVatWtZlPfX091dXVgOd1ayAJYh79/Oc/Dz2DPfrooxxzzDE0NTVx+umnt3hml112CfeQvPzyy63mm/sjX1JSwl577ZV3PZclS5aEwll///D0V5/G43G+9rWvsWbNGo477jgWLlzIa6+9xhVXXMEf//hHioqKOOGEE1o8l9serbX1a6+9huM4lJeXM3369DDwcUc/8pFIhAMPPLDN9+kLOtPW7dHQ0MDjjz8OwMSJEwtikrKzjx/ov35VY6jjtpZS8uijjwKeV8Zgv51t21RVVbFmzZoBX9xszs4+hvqrT9X4USgGIQNotqvoZxoaGmRxcbEE5IQJE6Truq2mu/XWW8M9DbfffnuraS6//PIwzbPPPtvtOgX7YyZPnixnzJghi4qKZDwel5MmTZJnnHGG/Mc//tFmPXMJ9mc0P6ZPny7r6upafeass84K023atCnvXiKRkKZpSkC++eabUkopL7nkEgnIc889t0Vev/71r3ulPbpKf/fpypUr5bBhw1q0sxBC3nnnna0+88knn4TpLrroohb3r7rqKgnI448/XkopZXV1dbgv6YsvvshLa1lW6Dn3kEMOabNd+oLOtnV73H333WFbXH311T2ukxo/Pae/+1WNofbb+tNPPw3f9brrrpNbt26V//Vf/yVLS0vD69FoVH7ta1+TL7/8co/rpMZQz+jvPt2Zx49CMRhRguZOxL333ht+2V511VVtprMsK/wB1DRNXnjhhfLJJ5+US5culX//+9/lKaec0ql8OkNnXMsfcsghbbpKz+W2226T06ZNk6ZpysrKSnnJJZfImpqadtMHZTzyyCN591544QUJyOLi4tApwUMPPRROSJoza9YsCUjDMFo4KehLBqJPP//8c3nGGWfIiooKGYvF5MyZM+XChQvbfWbUqFESkHvuuWeLe4cffrgE5A033BBe22OPPVp17PDGG2+E9bzyyivbLbO36Wxbt8eRRx4Z5tGWW/SuoMZPzxmIflVjqO22fvzxx8M0c+fOlaNHj27zsy2EkL/97W97VCc1hnrGQPTpzjp+FIrBiBI0dyKOPvro8AtyxYoV7aZ1XVc+8MADcu+99271x+Coo46SzzzzTI/rNGXKFDl79mz5v//7v3LRokXy3XfflS+++KK84YYb5Pjx48Py9thjD1lbW9vj8nJ5//33w/x//OMf590LYqIdffTR4bX169eH6XMnHY7jhLGWDjjggF6tY0cUYp+2xje/+c1wElFdXR1eT6fTMhaLSSBvJfvCCy+UgLzwwgvz8vntb38b1vepp57qk7q2RVfaujXWrFkTrpIffPDBvVInNX56TiH2a2vsLGMoVzsceP+cNWuWXLJkiUylUnLLli3y9ttvl+Xl5WG6f/7zn92ukxpDPaMQ+7Q1doTxo1AMRpSguZOwdu3aMJDzQQcd1GH6jz/+WM6ePVvqut6qUBKLxeQ555wjN2zY0KN6tbfaW19fL4877riwzJ/+9Kc9Kqs5ruvKoUOHSkDus88+efe++tWvSkDOmTMn7/qkSZMkIB944IHw2jvvvBPW8fLLL+/VOrZHofZpa9xyyy1hOY8//nh4/ZVXXpGAjEQiMplMhteDVfLdd989L5/Zs2dL8LSybZmj9QVdbevWyDVtu+OOO3qlXmr89IxC7dfW2FnG0J///Oe876Vjjz1W2rbdIt3ixYvD/Pbcc89umTxLqcZQTyjUPm2NwT5+FIrBinIGtJNw//33h4GcO/J0uXjxYmbOnMmTTz7JuHHjmDdvHps2bSKTybB27VpuvfVW4vE48+fP54ADDuDjjz/udr0qKiravFdaWsrDDz8cOg74v//7v9B7am8ghAi9yy1fvpy6ujrAc1DwxhtvAC1dl7fmjS73vD9dnRdqn7ZGWx4Wg/P999+fWCwWXg/aecWKFWzZsgUAKWUYpmXvvfemrKysV+vYHl1p67aYN28eANFoNAxs3lPU+OkZhdqvrbGzjKHcdwD4zW9+g67rLdIdeuihYRiNDz/8kPfff79b9VJjqPsUap+2xmAfPwrFoGWABV1FPzFt2rTQbGX79u1tpkulUnLs2LESkJWVlXLjxo2tpvvggw9Cc5OvfOUrfVVtKaWUF198cbgS+eqrr/Zq3r/73e9amMEsWbJEAlLXddnQ0JCX/vbbb5eAnDFjRnjttNNOC01ytm3b1qv1a4/B1KeO44RmUbmmXSeccIIE5C9+8YsWz1RWVkpA/v3vfw/rF/TVpZde2qv164jOtnVbvPnmm2HdTz/99D6oYduo8dM2g6lfd5Yx9OCDD4Z1HDFiRLt5/vWvfw3T3nXXXb1d5RA1hlpnMPXpYB8/CsVgRWk0dwLeeustPvroIwBOPPFEhgwZ0mbap59+OoyHdckll7Qakwpgzz335Nvf/naY/3vvvdfLtc4ybdq08Ly1wNc9IXeVM3B7HgTE3meffSgpKclLH6xyfvDBB9TU1ADZFdHp06czdOjQXq1fWwy2PtU0jYMPPhiAd955h6amJlzX5bXXXgOy7ZpLcxfzAxW7rCtt3RY9DZ/RE9T4aZ3B1q87yxgaP358eD5u3Lh2881NG2id+gI1hloy2Pp0MI8fhWIwowTNnYCuBIjPNZn88pe/3G7a/fbbLzz/5JNPulm7jpFS9lneX/7ylykuLgZa/pi0ZoK05557MmTIEKSUvPLKK3z66ads3rwZ6N8fnsHYp0H72LbN66+/zgcffEBtbS1CiPAHPZfghz+YfOXGP+tP87CutHVrWJbFQw89BHiB3WfNmtVrdesMavy0zmDs151hDOUKdY7jtJs2975hGN2sXceoMdSSwding3X8KBSDGSVo7uBYlsWDDz4IwIgRIzj++OPbTZ/7xW7bdod5t/ZcbxOsmgKMGTOmV/M2DIOZM2cCsHTpUpLJZLia3NoKpxAiTL948eIB2RszWPu0+R6ZoO2CiVNzgh/+9957j4aGhrBfpk6dyogRI3q1bm3R1bZujYULF1JdXQ3At771rT4dK62hxk9LBmu/7gxjqKKighkzZgCwevXqcA9ga3z++efh+dixY3uhtq2jxlA+g7VPB+P4USgGO0rQ3MH597//zdatW4HOTYYmT54cnuf+gLXGSy+91OpzvUldXV2oNSgqKuIrX/lKr5cRrHJmMhnuu+++sL1a+5HPvd78R76/VpMHa5/uv//+xONxwFsZDurSVjvvu+++FBcX4zgO8+fPZ+3atUD/rtp3ta1bo6eas56gxk/rDNZ+3VnGUOAQpr6+nhdeeKHNdI899lh43ldClhpDLRmsfToYx49CMegZyA2iir4niB0FyLfffrvD9DU1NbKoqEgCsrS0VC5fvrzVdE899VTohnzs2LHScZwWaY444oiw7FWrVrW4/+9//1smEok269LQ0JDnWv6SSy7psP7d4cUXXwzL2GWXXSQgp0yZ0mb6l19+WQLSNE05btw4Cchdd921T+rWGgPZpz0l+EzE4/HQ0cL8+fPbTB/EaAv6BZD3339/r9erLbra1s3Ztm2bjEQiLZx3dAY1fvqOgezXnrIzjKEtW7bI0tLSsH1bCyMxb968MN+vf/3rreajxlDfMJB92lMG2/hRKAY7StDcgdm+fXsYHHn69Omdfu66664Lv1BLSkrkf//3f8sXXnhBvvvuu/Lpp5+WP/jBD6RhGGGaefPmtZpPRz/yRxxxhBw6dKi88MIL5b333isXL14s3333Xblo0SJ5ww03yAkTJoTP77777n3mTS+ZTIaTxuC44IILei19bzLQfdpTrr766rx2A+SaNWt6LX1v0t22zuXWW28N6/273/2uS8+q8dM3DHS/9pSdZQzltvHuu+8u7777bvnWW2/JF154Qf7oRz8K4wGXlZXJTz/9tNU81BjqfQa6T3vKYBo/CsWOgBI0d2ACN+iAvPnmmzv9nOu68ic/+YkUQrT4gs09TNOUv/3tb9vMpzM/8u3lHxyHH364XLduXXeaoNMcfPDBeWV25FZ95syZeenvueeePq1fwED3aU955pln8sobP358u+n/85//5KWfOHFin9WtOd1t61wOPPBACV6YgrbCyrSFGj99w0D3a0/ZmcbQ9ddfHwofrR0jRoxoN9yIGkO9z0D3aU8ZTONHodgRUILmDkzww6Xruly/fn2Xn3/rrbfkRRddJKdPny5LS0ulruuyvLxc7rfffvKyyy6TK1asaPf5jn7kly5dKm+66SZ50kknyalTp8rhw4dLwzBkWVmZnDp1qjzvvPPk008/LV3X7XLdu8qVV16Z92PS0bv9/Oc/z0v/+eef93kdpRz4Pu0pjY2NeZrTs88+u9309fX1eZOS73znO31av1x62taffvppWO9Zs2Z1+Xk1fvqGge7XnrIzjSEpvc/5BRdcICdNmiSj0agsKyuT++23n5w7d66sqalp91k1hnqfge7TnjKYxo9CsSMgpOxDv90KhUKhUCgUCoVCodjpUF5nFQqFQqFQKBQKhULRqyhBU6FQKBQKhUKhUCgUvYoSNBUKhUKhUCgUCoVC0asoQVOhUCgUCoVCoVAoFL2KEjQVCoVCoVAoFAqFQtGrKEFToVAoFAqFQqFQKBS9ihI0FQqFQqFQKBQKhULRqyhBU6FQKBQKhUKhUCgUvYoSNBUKhUKhUCgUCoVC0asoQVOhUCgUCoVCoVAoFL2KEjQVCoVCoVAoFAqFQtGrKEFToVAoFAqFQqFQKBS9ihI0FQqFQqFQKBQKhULRqyhBU6FQKBQKhUKhUCgUvYoSNBUKhUKhUCgUCoVC0av8f+5pweW4qg3SAAAAAElFTkSuQmCC",
       "text/plain": [
        "<Figure size 900x1300 with 2 Axes>"
       ]
@@ -233,17 +243,124 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-09 19:39:43,950 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+      "2025-11-09 19:47:13,180 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
      ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 900x1300 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     }
    ],
    "source": [
-    "st_kitts_subareas = Subareas(tc_irma, impfset, exp_kit, resolution=resolution)\n",
-    "jamaica_subareas = Subareas(tc_melissa, impfset, exp_jam, resolution=resolution)\n",
+    "st_kitts_subareas = Subareas(tc_irma, impfset, exp_kit, resolution=resolution_st_kitts)\n",
+    "jamaica_subareas = Subareas(tc_melissa, impfset, exp_jam, resolution=resolution_jamaica)\n",
     "jamaica_subareas.plot()\n",
     "st_kitts_subareas.plot()"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "89441e42",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>value</th>\n",
+       "      <th>region_id</th>\n",
+       "      <th>impf_</th>\n",
+       "      <th>geometry</th>\n",
+       "      <th>impf_TC</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>2.508323e+05</td>\n",
+       "      <td>388</td>\n",
+       "      <td>1</td>\n",
+       "      <td>POINT (-77.88750 18.52083)</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>1.079139e+06</td>\n",
+       "      <td>388</td>\n",
+       "      <td>1</td>\n",
+       "      <td>POINT (-77.87917 18.52083)</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>1.577672e+06</td>\n",
+       "      <td>388</td>\n",
+       "      <td>1</td>\n",
+       "      <td>POINT (-77.87083 18.52083)</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>2.514346e+06</td>\n",
+       "      <td>388</td>\n",
+       "      <td>1</td>\n",
+       "      <td>POINT (-77.86250 18.52083)</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>2.876269e+06</td>\n",
+       "      <td>388</td>\n",
+       "      <td>1</td>\n",
+       "      <td>POINT (-77.85417 18.52083)</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "          value  region_id  impf_                    geometry  impf_TC\n",
+       "0  2.508323e+05        388      1  POINT (-77.88750 18.52083)      NaN\n",
+       "1  1.079139e+06        388      1  POINT (-77.87917 18.52083)      NaN\n",
+       "2  1.577672e+06        388      1  POINT (-77.87083 18.52083)      NaN\n",
+       "3  2.514346e+06        388      1  POINT (-77.86250 18.52083)      NaN\n",
+       "4  2.876269e+06        388      1  POINT (-77.85417 18.52083)      NaN"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "jamaica_sub_calc.subareas.exposure.gdf.head()"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "a284ec39",
@@ -254,7 +371,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 30,
    "id": "ac344ab3",
    "metadata": {},
    "outputs": [
@@ -262,9 +379,16 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-07 17:57:49,939 - climada.entity.exposures.base - INFO - Matching 328 exposures with 546 centroids.\n",
-      "2025-11-07 17:57:49,952 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
-      "2025-11-07 17:57:49,969 - climada.engine.impact_calc - INFO - Calculating impact for 984 assets (>0) and 51 events.\n"
+      "2025-11-09 19:47:37,802 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n",
+      "2025-11-09 19:47:37,804 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n",
+      "2025-11-09 19:47:37,805 - climada.entity.exposures.base - INFO - Matching 328 exposures with 546 centroids.\n",
+      "2025-11-09 19:47:37,811 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
+      "2025-11-09 19:47:37,815 - climada.engine.impact_calc - INFO - Calculating impact for 984 assets (>0) and 51 events.\n",
+      "2025-11-09 19:47:39,344 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n",
+      "2025-11-09 19:47:39,345 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n",
+      "2025-11-09 19:47:39,345 - climada.entity.exposures.base - INFO - Matching 13552 exposures with 7938 centroids.\n",
+      "2025-11-09 19:47:39,354 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
+      "2025-11-09 19:47:39,397 - climada.engine.impact_calc - INFO - Calculating impact for 40503 assets (>0) and 51 events.\n"
      ]
     }
    ],
@@ -285,7 +409,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 33,
    "id": "4ead6e69",
    "metadata": {},
    "outputs": [
@@ -401,6 +525,15 @@
      },
      "metadata": {},
      "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Benchmark Sharpe Ratio premium rate: 8.7\n",
+      "Chatoro premium rate: 8.5\n",
+      "IBRD premium rate: 5.0\n"
+     ]
     }
    ],
    "source": [
@@ -421,17 +554,130 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 34,
    "id": "6cfb9d55",
    "metadata": {},
    "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'annual_premiums': array([9.94631528e-02, 7.56510441e-02, 6.08655049e-02, 7.56510441e-02,\n",
+       "        6.08655049e-02, 5.40729509e-02, 9.94631528e-02, 9.26705987e-02,\n",
+       "        3.73169201e-02, 9.26705987e-02, 3.73169201e-02, 8.27133274e-04,\n",
+       "        5.09020283e-02, 1.32801491e-02, 2.76065706e-18, 9.25661604e-02,\n",
+       "        1.66992440e-02, 1.66992440e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
+       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02]),\n",
+       " 'annual_returns': array([ 9.94631528e-02, -3.12408723e-01,  6.08655049e-02, -3.12408723e-01,\n",
+       "         6.08655049e-02, -8.25113799e-02,  9.94631528e-02, -4.39137320e-02,\n",
+       "        -8.17026774e-01, -4.39137320e-02, -8.17026774e-01, -8.24484145e-03,\n",
+       "        -8.03441666e-01, -1.32376156e-01,  2.76065706e-18, -7.39540067e-01,\n",
+       "         1.66992440e-02,  1.66992440e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
+       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02]),\n",
+       " 'total_returns': 79139000300.62425,\n",
+       " 'total_premiums': 111845006583.64651,\n",
+       " 'sharpe_ratio': 0.466775913661655}"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'EL_ann': 0.02769437494917821,\n",
+       " 'AP_ann': 0.06432748538011696,\n",
+       " 'Tot_payout': 32706006283.02225,\n",
+       " 'Tot_damages': 48195442708.19097,\n",
+       " 'VaR_99_ann': 0.8543436945180888,\n",
+       " 'VaR_95_ann': 0.13658433076314122,\n",
+       " 'ES_99_ann': nan,\n",
+       " 'ES_95_ann': 0.6167018784716115}"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Benchmark Sharpe Ratio premium rate: 8.7\n",
-      "Chatoro premium rate: 8.5\n",
-      "IBRD premium rate: 5.0\n"
+      "Benchmark Sharpe Ratio premium rate: 10.5\n",
+      "Chatoro premium rate: 9.9\n",
+      "IBRD premium rate: 6.1\n"
      ]
     }
    ],

From 78e8b8e72b39ba1f6d5f74298a8355634f2b2e20 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Sun, 9 Nov 2025 21:34:09 +0100
Subject: [PATCH 039/125] test multi-country bond in notebook

---
 climada_petals/engine/cat_bonds/test.ipynb | 356 ++++++++-------------
 1 file changed, 136 insertions(+), 220 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/test.ipynb b/climada_petals/engine/cat_bonds/test.ipynb
index f1bb10cae..aa87ec161 100644
--- a/climada_petals/engine/cat_bonds/test.ipynb
+++ b/climada_petals/engine/cat_bonds/test.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 36,
    "id": "48c2d418",
    "metadata": {},
    "outputs": [
@@ -22,6 +22,7 @@
     "from subareas import Subareas\n",
     "from subarea_calculations import Subarea_Calculations\n",
     "from sng_bond_simulation import sng_bond_simulation\n",
+    "from mlt_bond_simulation import mlt_bond_simulation\n",
     "from premium_class import premium_calculations\n",
     "\n",
     "from climada.hazard import TCTracks, Centroids, TropCyclone\n",
@@ -200,12 +201,13 @@
     "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([736476, 736796, 736849, 736259, 736368, 736681, 736001, 736102, 736215, 736326,\n",
-    " 736327, 736631, 736843, 736053, 736362, 736381, 736387, 736903, 736108, 736221,\n",
-    " 736743, 736248, 736154, 736668, 736672, 736578, 736992, 736000, 736504, 736312,\n",
-    " 736821, 736126, 736540, 736945, 736252, 736963, 736936, 736083, 736993, 737903,\n",
-    " 737212, 737320, 737931, 737437, 737948, 737959, 737468, 737774, 737381, 737192,\n",
-    " 738098])"
+    "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])"
    ]
   },
   {
@@ -218,7 +220,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 67,
    "id": "09fba021",
    "metadata": {},
    "outputs": [
@@ -226,7 +228,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-09 19:46:53,396 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+      "2025-11-09 21:31:38,906 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
      ]
     },
     {
@@ -243,7 +245,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-09 19:47:13,180 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+      "2025-11-09 21:32:01,894 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
      ]
     },
     {
@@ -264,103 +266,6 @@
     "st_kitts_subareas.plot()"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "id": "89441e42",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>value</th>\n",
-       "      <th>region_id</th>\n",
-       "      <th>impf_</th>\n",
-       "      <th>geometry</th>\n",
-       "      <th>impf_TC</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>2.508323e+05</td>\n",
-       "      <td>388</td>\n",
-       "      <td>1</td>\n",
-       "      <td>POINT (-77.88750 18.52083)</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>1.079139e+06</td>\n",
-       "      <td>388</td>\n",
-       "      <td>1</td>\n",
-       "      <td>POINT (-77.87917 18.52083)</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2</th>\n",
-       "      <td>1.577672e+06</td>\n",
-       "      <td>388</td>\n",
-       "      <td>1</td>\n",
-       "      <td>POINT (-77.87083 18.52083)</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>3</th>\n",
-       "      <td>2.514346e+06</td>\n",
-       "      <td>388</td>\n",
-       "      <td>1</td>\n",
-       "      <td>POINT (-77.86250 18.52083)</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>4</th>\n",
-       "      <td>2.876269e+06</td>\n",
-       "      <td>388</td>\n",
-       "      <td>1</td>\n",
-       "      <td>POINT (-77.85417 18.52083)</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "          value  region_id  impf_                    geometry  impf_TC\n",
-       "0  2.508323e+05        388      1  POINT (-77.88750 18.52083)      NaN\n",
-       "1  1.079139e+06        388      1  POINT (-77.87917 18.52083)      NaN\n",
-       "2  1.577672e+06        388      1  POINT (-77.87083 18.52083)      NaN\n",
-       "3  2.514346e+06        388      1  POINT (-77.86250 18.52083)      NaN\n",
-       "4  2.876269e+06        388      1  POINT (-77.85417 18.52083)      NaN"
-      ]
-     },
-     "execution_count": 24,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "jamaica_sub_calc.subareas.exposure.gdf.head()"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "a284ec39",
@@ -371,7 +276,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 68,
    "id": "ac344ab3",
    "metadata": {},
    "outputs": [
@@ -379,16 +284,16 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-09 19:47:37,802 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n",
-      "2025-11-09 19:47:37,804 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n",
-      "2025-11-09 19:47:37,805 - climada.entity.exposures.base - INFO - Matching 328 exposures with 546 centroids.\n",
-      "2025-11-09 19:47:37,811 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
-      "2025-11-09 19:47:37,815 - climada.engine.impact_calc - INFO - Calculating impact for 984 assets (>0) and 51 events.\n",
-      "2025-11-09 19:47:39,344 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n",
-      "2025-11-09 19:47:39,345 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n",
-      "2025-11-09 19:47:39,345 - climada.entity.exposures.base - INFO - Matching 13552 exposures with 7938 centroids.\n",
-      "2025-11-09 19:47:39,354 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
-      "2025-11-09 19:47:39,397 - climada.engine.impact_calc - INFO - Calculating impact for 40503 assets (>0) and 51 events.\n"
+      "2025-11-09 21:32:53,817 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n",
+      "2025-11-09 21:32:53,832 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n",
+      "2025-11-09 21:32:53,837 - climada.entity.exposures.base - INFO - Matching 328 exposures with 546 centroids.\n",
+      "2025-11-09 21:32:53,893 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
+      "2025-11-09 21:32:53,933 - climada.engine.impact_calc - INFO - Calculating impact for 984 assets (>0) and 51 events.\n",
+      "2025-11-09 21:32:56,095 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n",
+      "2025-11-09 21:32:56,096 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n",
+      "2025-11-09 21:32:56,097 - climada.entity.exposures.base - INFO - Matching 13552 exposures with 7938 centroids.\n",
+      "2025-11-09 21:32:56,145 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
+      "2025-11-09 21:32:56,196 - climada.engine.impact_calc - INFO - Calculating impact for 40503 assets (>0) and 51 events.\n"
      ]
     }
    ],
@@ -409,7 +314,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 69,
    "id": "4ead6e69",
    "metadata": {},
    "outputs": [
@@ -554,102 +459,102 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 70,
    "id": "6cfb9d55",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'annual_premiums': array([9.94631528e-02, 7.56510441e-02, 6.08655049e-02, 7.56510441e-02,\n",
-       "        6.08655049e-02, 5.40729509e-02, 9.94631528e-02, 9.26705987e-02,\n",
-       "        3.73169201e-02, 9.26705987e-02, 3.73169201e-02, 8.27133274e-04,\n",
-       "        5.09020283e-02, 1.32801491e-02, 2.76065706e-18, 9.25661604e-02,\n",
-       "        1.66992440e-02, 1.66992440e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02, 9.94631528e-02,\n",
-       "        9.94631528e-02, 9.94631528e-02, 9.94631528e-02]),\n",
-       " 'annual_returns': array([ 9.94631528e-02, -3.12408723e-01,  6.08655049e-02, -3.12408723e-01,\n",
-       "         6.08655049e-02, -8.25113799e-02,  9.94631528e-02, -4.39137320e-02,\n",
-       "        -8.17026774e-01, -4.39137320e-02, -8.17026774e-01, -8.24484145e-03,\n",
-       "        -8.03441666e-01, -1.32376156e-01,  2.76065706e-18, -7.39540067e-01,\n",
-       "         1.66992440e-02,  1.66992440e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02,  9.94631528e-02,\n",
-       "         9.94631528e-02,  9.94631528e-02,  9.94631528e-02]),\n",
-       " 'total_returns': 79139000300.62425,\n",
-       " 'total_premiums': 111845006583.64651,\n",
-       " 'sharpe_ratio': 0.466775913661655}"
+       "{'annual_premiums': array([9.82169321e-02, 8.13626244e-02, 7.03841971e-02, 9.72188933e-02,\n",
+       "        8.62404660e-02, 8.62404660e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.65033813e-02,\n",
+       "        9.82169321e-02, 9.65033813e-02, 8.68177195e-02, 9.65033813e-02,\n",
+       "        8.68177195e-02, 5.87201365e-02, 9.70990243e-02, 6.82189176e-02,\n",
+       "        1.48503588e-04, 8.16338116e-02, 2.38431925e-03, 2.72606749e-18,\n",
+       "        3.01111648e-02, 1.64900113e-02, 1.64900113e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
+       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02]),\n",
+       " 'annual_returns': array([-6.32243649e-02, -4.05762901e-02,  7.03841971e-02, -2.47200212e-02,\n",
+       "         8.62404660e-02,  8.62404660e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02, -8.17617377e-03,\n",
+       "         9.82169321e-02, -8.17617377e-03, -4.97666112e-02, -8.17617377e-03,\n",
+       "        -4.97666112e-02, -7.00015978e-01, -3.94853065e-02, -7.86124777e-01,\n",
+       "        -8.92347113e-03, -7.72709883e-01, -1.43271986e-01,  2.72606749e-18,\n",
+       "        -8.01995062e-01,  1.64900113e-02,  1.64900113e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
+       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02]),\n",
+       " 'total_returns': 79444050915.31145,\n",
+       " 'total_premiums': 111097762521.12311,\n",
+       " 'sharpe_ratio': 0.5016182767396254}"
       ]
      },
      "metadata": {},
@@ -658,14 +563,14 @@
     {
      "data": {
       "text/plain": [
-       "{'EL_ann': 0.02769437494917821,\n",
-       " 'AP_ann': 0.06432748538011696,\n",
-       " 'Tot_payout': 32706006283.02225,\n",
-       " 'Tot_damages': 48195442708.19097,\n",
-       " 'VaR_99_ann': 0.8543436945180888,\n",
-       " 'VaR_95_ann': 0.13658433076314122,\n",
-       " 'ES_99_ann': nan,\n",
-       " 'ES_95_ann': 0.6167018784716115}"
+       "{'EL_ann': 0.02680332628076214,\n",
+       " 'AP_ann': 0.08771929824561403,\n",
+       " 'Tot_payout': 31653711605.811665,\n",
+       " 'Tot_damages': 50919862874.32074,\n",
+       " 'VaR_99_ann': 0.8387774672602343,\n",
+       " 'VaR_95_ann': 0.12926162262991353,\n",
+       " 'ES_99_ann': 0.8543436945180888,\n",
+       " 'ES_95_ann': 0.4462644805505158}"
       ]
      },
      "metadata": {},
@@ -675,9 +580,9 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Benchmark Sharpe Ratio premium rate: 10.5\n",
-      "Chatoro premium rate: 9.9\n",
-      "IBRD premium rate: 6.1\n"
+      "Benchmark Sharpe Ratio premium rate: 9.8\n",
+      "Chatoro premium rate: 9.8\n",
+      "IBRD premium rate: 6.0\n"
      ]
     }
    ],
@@ -696,6 +601,17 @@
     "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": 71,
+   "id": "67403f5f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mlt_cat_bond = mlt_bond_simulation(subarea_calc_list=[st_kitts_sub_calc, jamaica_sub_calc], countries_list=countries, term=term,number_of_terms=num_of_terms, tranches=[50,100])\n",
+    "mlt_cat_bond.init_loss_simulation(principal=6000000000, confidence_levels=[0.95,0.99])"
+   ]
   }
  ],
  "metadata": {

From 4b9c735e44a1542c02c06ba46031f66ac4b59ec9 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Sun, 9 Nov 2025 21:34:18 +0100
Subject: [PATCH 040/125] add minimum simulation year

---
 climada_petals/engine/cat_bonds/mlt_bond_simulation.py | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
index cf77a4c67..c2719a9d0 100644
--- a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
@@ -20,10 +20,15 @@ def __init__(self, subarea_calc_list, countries_list, term, number_of_terms, tra
     def _prepare_data(self):
         self.pay_vs_dam_dic = {}
         self.principal_dic_cty = {}
+        min_year_list = []
         for idx, cty in enumerate(self.countries):
             self.pay_vs_dam_dic[cty] = self.subarea_calc[idx].pay_vs_dam
             self.principal_dic_cty[cty] = self.subarea_calc[idx].principal
+            min_year_list.append(self.subarea_calc[idx].pay_vs_dam['year'].min())
 
+        min_year = min(min_year_list)
+
+        return min_year
         
 
 
@@ -166,7 +171,7 @@ def init_loss_simulation(self, principal, confidence_levels=[0.95, 0.99]):
 
         """
 
-        self._prepare_data()
+        min_year = self._prepare_data()
 
         annual_losses = []
         total_losses = []
@@ -182,10 +187,9 @@ def init_loss_simulation(self, principal, confidence_levels=[0.95, 0.99]):
             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'] == (i + j)].copy()
+                    events = self.pay_vs_dam_dic[int(cty)][self.pay_vs_dam_dic[int(cty)]['year'] == (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)
 

From a440927013842e3fa02e4656f5fefcd3fb906944 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Kai=20Bergm=C3=BCller?=
 <96840853+KaiOBerg@users.noreply.github.com>
Date: Sun, 16 Nov 2025 13:39:57 +0100
Subject: [PATCH 041/125] Update
 climada_petals/engine/cat_bonds/mlt_bond_simulation.py

Co-authored-by: Samuel Juhel <10011382+spjuhel@users.noreply.github.com>
---
 climada_petals/engine/cat_bonds/mlt_bond_simulation.py | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
index c2719a9d0..45c59c9ec 100644
--- a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
@@ -94,10 +94,7 @@ def init_bond_loss(self, events_per_year, principal):
 
                 sum_payouts = np.zeros(len(events))  
                 sum_damages = np.zeros(len(events)) 
-                for o in range(len(events)):
-                    payout = pay[o]
-                    cty = cties[o]
-                    damage = dam[o]
+                for payout, country, damage in zip(pay, countries, damages):
 
                     if payout == 0 or cur_nominal == 0 or cur_nom_cty[int(cty)] == 0:
                         event_payout = 0

From 616bf606ac36110d7bbfc1626fd42ae7a53b5185 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Sun, 16 Nov 2025 14:02:25 +0100
Subject: [PATCH 042/125] make init loss more pythonic

---
 .../engine/cat_bonds/sng_bond_simulation.py   | 84 ++++++++++---------
 1 file changed, 46 insertions(+), 38 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/sng_bond_simulation.py b/climada_petals/engine/cat_bonds/sng_bond_simulation.py
index 1984c1294..f51528e13 100644
--- a/climada_petals/engine/cat_bonds/sng_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/sng_bond_simulation.py
@@ -1,6 +1,7 @@
 import pandas as pd
 import numpy as np
 import logging
+from utils_cat_bonds import multi_level_es
 
 LOGGER = logging.getLogger(__name__)
 
@@ -20,6 +21,7 @@ def init_bond_loss(self, events_per_year):
         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
@@ -79,60 +81,65 @@ def init_bond_loss(self, events_per_year):
         return rel_annual_losses, rel_monthly_loss, summed_payouts, summed_damages
 
 
-    '''Loop over all terms of bond to derive losses'''
-    def init_loss_simulation(self):
+    def init_loss_simulation(self, confidence_levels=[0.95, 0.99]):
         """
-        Simulates the bonds monthly losses, total payouts and damages, expected annual loss, attachment probability, and other metrics for a catastrophe bond over multiple years.
-        This function processes a DataFrame of payout and damage events, simulates bond losses over a specified term,
-        and computes risk metrics including Value-at-Risk (VaR) and Expected Shortfall (ES) at 95% and 99% confidence levels.
-        It returns the a DataFrame of monthly losses, and a dictionary of bond metrics.
-        Parameters
-        ----------
-            self: bond_simulation
-                An instance of the bond_simulation class containing a payout vs damage table, bond term, and number of simulated years.
+        Simulate losses, payouts, damages, and risk metrics for a catastrophe bond.
+
         Returns
         -------
-            df_loss_month (pd.DataFrame): DataFrame containing monthly loss data for all simulations.
-            loss_metrics (dict): Dictionary containing expected loss, attachment probability, total payouts/damages, VaR and ES metrics at 95% and 99% confidence levels for annual losses.
+        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
-        list_loss_month = []
-        min_year = self.subarea_calc.pay_vs_dam['year'].min()
-        for i in range(self.simulated_years-self.term):
-            events_per_year = []
-            for j in range(self.term):
-                events_per_year.append(self.subarea_calc.pay_vs_dam[self.subarea_calc.pay_vs_dam['year'] == (min_year+i)+j])
-            annual_losses_per_term, monthly_losses, summed_payouts, summed_damages = self.init_bond_loss(events_per_year)
-            list_loss_month.append(monthly_losses)
 
-            annual_losses.extend(annual_losses_per_term)
+        # Iterate directly over year-starts
+        for start_year in range(min_year, min_year + self.simulated_years - self.term):
+
+            # Collect events for the full term (vectorized selection)
+            events_per_year = [
+                pay_vs_dam[pay_vs_dam['year'] == (start_year + offset)]
+                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
         self.df_loss_month = pd.concat(list_loss_month, ignore_index=True)
 
-        att_prob = 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)
+        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_99_ann = annual_losses.quantile(0.99)
-        VaR_95_ann = annual_losses.quantile(0.95)
-        if VaR_99_ann == 1:
-            ES_99_ann = 1
-        else:
-            ES_99_ann = annual_losses[annual_losses > VaR_99_ann].mean()
-        if VaR_95_ann == 1:
-            ES_95_ann = 1
-        else:
-            ES_95_ann = annual_losses[annual_losses > VaR_95_ann].mean()
-
-        self.loss_metrics = {'EL_ann': exp_loss_ann, 'AP_ann': att_prob, 'Tot_payout':total_payouts, 'Tot_damages': total_damages, 
-                             'VaR_99_ann': VaR_99_ann, 'VaR_95_ann': VaR_95_ann, 'ES_99_ann': ES_99_ann, 'ES_95_ann': ES_95_ann}
-        
+        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}')
@@ -144,6 +151,7 @@ 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

From d50ceb5166f6247aba0e5cfa3125ddb58f177bfd Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Sun, 16 Nov 2025 14:02:38 +0100
Subject: [PATCH 043/125] change var es function

---
 .../engine/cat_bonds/utils_cat_bonds.py       | 32 ++++++++-----------
 1 file changed, 13 insertions(+), 19 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/utils_cat_bonds.py b/climada_petals/engine/cat_bonds/utils_cat_bonds.py
index 5da8beb89..9aee96ce8 100644
--- a/climada_petals/engine/cat_bonds/utils_cat_bonds.py
+++ b/climada_petals/engine/cat_bonds/utils_cat_bonds.py
@@ -1,29 +1,23 @@
-
-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:
     - risk_metrics: dict, VaR and ES values keyed by confidence level
     """
-    # Convert losses to a NumPy array
-    losses = np.array(losses)
-    # Sort losses once
-    sorted_losses = np.sort(losses)
-    n = len(sorted_losses)
-    risk_metrics = {}
-    for cl in confidence_levels:
-        # Calculate index for VaR
-        var_index = int(np.ceil(n * cl)) - 1
-        var = sorted_losses[var_index]
-        # Calculate ES
-        tail_losses = sorted_losses[var_index + 1:]
-        es = tail_losses.mean() if len(tail_losses) > 0 else var
-        # Store metrics
-        risk_metrics[cl] = {'VaR': var, 'ES': es}
-    return risk_metrics
\ No newline at end of file
+
+    # 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
\ No newline at end of file

From ac20d79a68997bb149da7bc112950833a07a8e15 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Sun, 16 Nov 2025 14:02:59 +0100
Subject: [PATCH 044/125] adjust test notebook for confidence intervals

---
 climada_petals/engine/cat_bonds/test.ipynb | 237 ++++++++++++++-------
 1 file changed, 164 insertions(+), 73 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/test.ipynb b/climada_petals/engine/cat_bonds/test.ipynb
index aa87ec161..d9c90715b 100644
--- a/climada_petals/engine/cat_bonds/test.ipynb
+++ b/climada_petals/engine/cat_bonds/test.ipynb
@@ -2,19 +2,10 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 1,
    "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"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%load_ext autoreload\n",
     "%autoreload 2\n",
@@ -41,7 +32,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 2,
    "id": "89b53a88",
    "metadata": {},
    "outputs": [],
@@ -78,7 +69,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 3,
    "id": "a51eb038",
    "metadata": {},
    "outputs": [
@@ -86,30 +77,43 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-09 19:34:32,604 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
-      "2025-11-09 19:34:32,914 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
-      "2025-11-09 19:34:33,042 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
-      "2025-11-09 19:34:36,593 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
-      "2025-11-09 19:34:36,625 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 546 coastal centroids.\n",
-      "2025-11-09 19:34:36,958 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
-      "2025-11-09 19:34:37,241 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
-      "2025-11-09 19:34:37,538 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
-      "2025-11-09 19:34:37,859 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
-      "2025-11-09 19:34:38,164 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
-      "2025-11-09 19:34:38,661 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
-      "2025-11-09 19:34:39,027 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
-      "2025-11-09 19:34:39,352 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
-      "2025-11-09 19:34:39,547 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
-      "2025-11-09 19:34:40,701 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      "2025-11-16 13:55:42,520 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
+      "2025-11-16 13:55:42,584 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
+      "2025-11-16 13:55:42,651 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "<string>:7: FutureWarning: 'H' is deprecated and will be removed in a future version. Please use 'h' instead of 'H'.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-11-16 13:55:47,717 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
+      "2025-11-16 13:55:47,808 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 546 coastal centroids.\n",
+      "2025-11-16 13:55:48,165 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
+      "2025-11-16 13:55:48,425 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
+      "2025-11-16 13:55:48,704 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
+      "2025-11-16 13:55:49,020 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
+      "2025-11-16 13:55:49,321 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
+      "2025-11-16 13:55:49,660 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
+      "2025-11-16 13:55:50,001 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
+      "2025-11-16 13:55:50,291 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
+      "2025-11-16 13:55:50,462 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
+      "2025-11-16 13:55:51,793 - climada.entity.exposures.litpop.litpop - INFO - \n",
       " LitPop: Init Exposure for country: KNA (659)...\n",
       "\n",
-      "2025-11-09 19:34:40,757 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-09 19:34:41,314 - climada.util.finance - INFO - GDP KNA 2020: 8.839e+08.\n",
-      "2025-11-09 19:34:41,332 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
-      "2025-11-09 19:34:41,333 - climada.entity.exposures.base - INFO - category_id not set.\n",
-      "2025-11-09 19:34:41,334 - climada.entity.exposures.base - INFO - cover not set.\n",
-      "2025-11-09 19:34:41,336 - climada.entity.exposures.base - INFO - deductible not set.\n",
-      "2025-11-09 19:34:41,337 - climada.entity.exposures.base - INFO - centr_ not set.\n"
+      "2025-11-16 13:55:51,881 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-16 13:55:52,193 - climada.util.finance - INFO - GDP KNA 2020: 8.839e+08.\n",
+      "2025-11-16 13:55:52,214 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+      "2025-11-16 13:55:52,215 - climada.entity.exposures.base - INFO - category_id not set.\n",
+      "2025-11-16 13:55:52,215 - climada.entity.exposures.base - INFO - cover not set.\n",
+      "2025-11-16 13:55:52,216 - climada.entity.exposures.base - INFO - deductible not set.\n",
+      "2025-11-16 13:55:52,217 - climada.entity.exposures.base - INFO - centr_ not set.\n"
      ]
     }
    ],
@@ -146,7 +150,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "id": "890bcd64",
    "metadata": {},
    "outputs": [
@@ -154,36 +158,36 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-09 19:44:24,446 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
-      "2025-11-09 19:44:24,526 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
-      "2025-11-09 19:44:24,570 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
-      "2025-11-09 19:44:27,512 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
-      "2025-11-09 19:44:27,558 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 7938 coastal centroids.\n",
-      "2025-11-09 19:44:32,440 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
-      "2025-11-09 19:44:36,945 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
-      "2025-11-09 19:44:41,782 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
-      "2025-11-09 19:44:47,088 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
-      "2025-11-09 19:44:51,542 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
-      "2025-11-09 19:44:56,307 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
-      "2025-11-09 19:45:00,234 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
-      "2025-11-09 19:45:05,448 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
-      "2025-11-09 19:45:07,280 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
-      "2025-11-09 19:45:09,635 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      "2025-11-16 13:55:53,900 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
+      "2025-11-16 13:55:53,951 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
+      "2025-11-16 13:55:53,992 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
+      "2025-11-16 13:55:56,741 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
+      "2025-11-16 13:55:56,770 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 7938 coastal centroids.\n",
+      "2025-11-16 13:56:01,669 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
+      "2025-11-16 13:56:06,894 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
+      "2025-11-16 13:56:12,391 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
+      "2025-11-16 13:56:17,881 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
+      "2025-11-16 13:56:22,665 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
+      "2025-11-16 13:56:27,621 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
+      "2025-11-16 13:56:32,238 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
+      "2025-11-16 13:56:39,713 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
+      "2025-11-16 13:56:41,775 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
+      "2025-11-16 13:56:44,417 - climada.entity.exposures.litpop.litpop - INFO - \n",
       " LitPop: Init Exposure for country: JAM (388)...\n",
       "\n",
-      "2025-11-09 19:45:11,613 - climada.util.finance - INFO - GDP JAM 2020: 1.381e+10.\n",
-      "2025-11-09 19:45:11,658 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
-      "2025-11-09 19:45:11,659 - climada.entity.exposures.base - INFO - category_id not set.\n",
-      "2025-11-09 19:45:11,660 - climada.entity.exposures.base - INFO - cover not set.\n",
-      "2025-11-09 19:45:11,661 - climada.entity.exposures.base - INFO - deductible not set.\n",
-      "2025-11-09 19:45:11,663 - climada.entity.exposures.base - INFO - centr_ not set.\n"
+      "2025-11-16 13:56:45,089 - climada.util.finance - INFO - GDP JAM 2020: 1.381e+10.\n",
+      "2025-11-16 13:56:45,133 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+      "2025-11-16 13:56:45,133 - climada.entity.exposures.base - INFO - category_id not set.\n",
+      "2025-11-16 13:56:45,135 - climada.entity.exposures.base - INFO - cover not set.\n",
+      "2025-11-16 13:56:45,136 - climada.entity.exposures.base - INFO - deductible not set.\n",
+      "2025-11-16 13:56:45,137 - climada.entity.exposures.base - INFO - centr_ not set.\n"
      ]
     }
    ],
    "source": [
     "tr_melissa = TCTracks.from_ibtracs_netcdf(\n",
     "    provider=\"usa\", storm_id=\"2025291N11319\"\n",
-    ")  # IRMA 2017\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",
@@ -220,7 +224,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 67,
+   "execution_count": 5,
    "id": "09fba021",
    "metadata": {},
    "outputs": [
@@ -228,7 +232,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-09 21:31:38,906 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+      "2025-11-16 13:56:47,280 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
      ]
     },
     {
@@ -245,7 +249,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-09 21:32:01,894 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+      "2025-11-16 13:57:09,541 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
      ]
     },
     {
@@ -276,7 +280,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 68,
+   "execution_count": 6,
    "id": "ac344ab3",
    "metadata": {},
    "outputs": [
@@ -284,16 +288,12 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-09 21:32:53,817 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n",
-      "2025-11-09 21:32:53,832 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n",
-      "2025-11-09 21:32:53,837 - climada.entity.exposures.base - INFO - Matching 328 exposures with 546 centroids.\n",
-      "2025-11-09 21:32:53,893 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
-      "2025-11-09 21:32:53,933 - climada.engine.impact_calc - INFO - Calculating impact for 984 assets (>0) and 51 events.\n",
-      "2025-11-09 21:32:56,095 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n",
-      "2025-11-09 21:32:56,096 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n",
-      "2025-11-09 21:32:56,097 - climada.entity.exposures.base - INFO - Matching 13552 exposures with 7938 centroids.\n",
-      "2025-11-09 21:32:56,145 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
-      "2025-11-09 21:32:56,196 - climada.engine.impact_calc - INFO - Calculating impact for 40503 assets (>0) and 51 events.\n"
+      "2025-11-16 13:57:28,101 - climada.entity.exposures.base - INFO - Matching 328 exposures with 546 centroids.\n",
+      "2025-11-16 13:57:28,105 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
+      "2025-11-16 13:57:28,118 - climada.engine.impact_calc - INFO - Calculating impact for 984 assets (>0) and 51 events.\n",
+      "2025-11-16 13:57:29,494 - climada.entity.exposures.base - INFO - Matching 13552 exposures with 7938 centroids.\n",
+      "2025-11-16 13:57:29,504 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
+      "2025-11-16 13:57:29,541 - climada.engine.impact_calc - INFO - Calculating impact for 40503 assets (>0) and 51 events.\n"
      ]
     }
    ],
@@ -314,7 +314,98 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 69,
+   "execution_count": 9,
+   "id": "62108c5e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'EL_ann': 0.017543859649122806,\n",
+       " 'AP_ann': 0.023391812865497075,\n",
+       " 'Tot_payout': 1325883333.3333325,\n",
+       " 'Tot_damages': 11037139919.100546,\n",
+       " 'VaR_95_ann': 0.0,\n",
+       " 'ES_95_ann': 0.75,\n",
+       " 'VaR_99_ann': 0.7555314181864904,\n",
+       " 'ES_99_ann': 1.0}"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Benchmark Sharpe Ratio premium rate: 8.7\n",
+      "Chatoro premium rate: 8.5\n",
+      "IBRD premium rate: 5.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "st_kitts_python_bond_sim = sng_bond_simulation(subarea_calc=st_kitts_sub_calc, term=term, number_of_terms=num_of_terms)\n",
+    "st_kitts_python_bond_sim.init_loss_simulation_pythonic(confidence_levels=[0.95, 0.99])\n",
+    "st_kitts_premiums_pythonic = premium_calculations(bond_simulation_class=st_kitts_python_bond_sim)\n",
+    "st_kitts_premiums_pythonic.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)\n",
+    "st_kitts_premiums_pythonic.calc_ibrd_premium()\n",
+    "st_kitts_premiums_pythonic.calc_benchmark_premium(target_sharpe = target_sharpe)\n",
+    "display(st_kitts_python_bond_sim.loss_metrics)\n",
+    "print(f\"Benchmark Sharpe Ratio premium rate: {round(st_kitts_premiums_pythonic.benchmark_prem_rate*100,1)}\")\n",
+    "print(f\"Chatoro premium rate: {round(st_kitts_premiums_pythonic.chatoro_prem_rate*100,1)}\")\n",
+    "print(f\"IBRD premium rate: {round(st_kitts_premiums_pythonic.ibrd_prem_rate*100,1)}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "f900a3e2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'EL_ann': 0.017543859649122806,\n",
+       " 'AP_ann': 0.023391812865497075,\n",
+       " 'Tot_payout': 1325883333.3333325,\n",
+       " 'Tot_damages': 11037139919.100546,\n",
+       " 'VaR_99_ann': 0.7555314181864904,\n",
+       " 'VaR_95_ann': 0.0,\n",
+       " 'ES_99_ann': 1.0,\n",
+       " 'ES_95_ann': 0.75}"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Benchmark Sharpe Ratio premium rate: 8.7\n",
+      "Chatoro premium rate: 8.5\n",
+      "IBRD premium rate: 5.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "### ST. KITTS AND NEVIS BOND SIMULATION ###\n",
+    "st_kitts_bond_sim = sng_bond_simulation(subarea_calc=st_kitts_sub_calc, term=term, number_of_terms=num_of_terms) \n",
+    "st_kitts_bond_sim.init_loss_simulation()\n",
+    "st_kitts_premiums = premium_calculations(bond_simulation_class=st_kitts_bond_sim)\n",
+    "st_kitts_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)\n",
+    "st_kitts_premiums.calc_ibrd_premium()\n",
+    "st_kitts_premiums.calc_benchmark_premium(target_sharpe = target_sharpe)\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": null,
    "id": "4ead6e69",
    "metadata": {},
    "outputs": [

From 50ac5ef62d9f03de7003f2f2f23b969bea67e226 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 17 Nov 2025 15:17:01 +0100
Subject: [PATCH 045/125] remove nested loop from bond simulation

---
 .../engine/cat_bonds/sng_bond_simulation.py   | 90 +++++++++++--------
 1 file changed, 55 insertions(+), 35 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/sng_bond_simulation.py b/climada_petals/engine/cat_bonds/sng_bond_simulation.py
index f51528e13..2dca3c5d3 100644
--- a/climada_petals/engine/cat_bonds/sng_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/sng_bond_simulation.py
@@ -42,45 +42,64 @@ def init_bond_loss(self, events_per_year):
             The total summed damages over the bond's term.
         """
 
-        losses = []
-        rel_monthly_loss = pd.DataFrame(columns=['losses', 'months'])
-        current_principal = self.subarea_calc.principal
+        principal0 = self.subarea_calc.principal
+        principal = principal0
 
-        summed_damages = 0
-        for k in range(self.term):
+        # Use Python lists only for month-level output (tiny)
+        df_monthly = pd.DataFrame(columns=[
+            "losses", "months"]
+        )
+        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()
 
-            if events_per_year[k].empty:
-                sum_payouts = [0]
-                months = []
             else:
-                events_per_year[k] = events_per_year[k].sort_values(by='month')
-                months = events_per_year[k]['month'].tolist()
-
-                sum_payouts = []
-                for o in range(len(events_per_year[k])):
-                    payout = events_per_year[k].loc[events_per_year[k].index[o], 'pay']
-                    summed_damages += events_per_year[k].loc[events_per_year[k].index[o], 'damage']
-                    #If there are events in the year, sample that many payouts and the associated damages
-                    if payout == 0 or current_principal == 0:
-                        sum_payouts.append(0)
-                    elif payout > 0:
-                        event_payout = payout 
-                        current_principal -= event_payout
-                        if current_principal < 0:
-                            event_payout += current_principal
-                            current_principal = 0
-                        else:
-                            pass
-                        sum_payouts.append(event_payout)
-
-            losses.append(np.sum(sum_payouts))
-            rel_monthly_loss.loc[k] = [sum_payouts, months]
-        summed_payouts = np.sum(losses)
-        rel_annual_losses = np.array(losses) / self.subarea_calc.principal
-        rel_monthly_loss['losses'] = rel_monthly_loss['losses'].apply(lambda x: [i / self.subarea_calc.principal for i in x])
-        return rel_annual_losses, rel_monthly_loss, summed_payouts, summed_damages
+                # 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
+            df_monthly.loc[year, "losses"] = payouts / principal0
+            df_monthly.loc[year, "months"] = 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.
@@ -107,7 +126,7 @@ def init_loss_simulation(self, confidence_levels=[0.95, 0.99]):
 
             # Collect events for the full term (vectorized selection)
             events_per_year = [
-                pay_vs_dam[pay_vs_dam['year'] == (start_year + offset)]
+                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)
             ]
 
@@ -145,6 +164,7 @@ def init_loss_simulation(self, confidence_levels=[0.95, 0.99]):
         LOGGER.info(f'Attachment Probability = {att_prob}')
 
 
+
     '''Simulate over all terms of bond to derive returns'''
     def init_return_simulation(self, premium):
         """

From da53e8ad0ef2677851a1b11f312da23ffdbbfe3a Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 17 Nov 2025 18:27:18 +0100
Subject: [PATCH 046/125] change fucntion description

---
 climada_petals/engine/cat_bonds/premium_class.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/premium_class.py b/climada_petals/engine/cat_bonds/premium_class.py
index ea908f85c..c0d39f126 100644
--- a/climada_petals/engine/cat_bonds/premium_class.py
+++ b/climada_petals/engine/cat_bonds/premium_class.py
@@ -93,7 +93,7 @@ def calc_ibrd_premium(self, peril=None, year=None):
 
     ### 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, ann_losses, target_sharpe):
+    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.
@@ -102,7 +102,7 @@ def find_sharpe(self, premium, ann_losses, target_sharpe):
         Parameters
         ----------
             premium (float): The annual premium rate paid to the investor.
-            ann_losses (pd.DataFrame): DataFrame containing annual loss events, with columns 'losses' (list of loss amounts per event)
+            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
@@ -112,9 +112,9 @@ def find_sharpe(self, premium, ann_losses, target_sharpe):
 
         ncf = []
         cur_nominal = 1
-        for i in range(len(ann_losses)):
-            losses = ann_losses['losses'].iloc[i]
-            months = ann_losses['months'].iloc[i]
+        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:

From c02d1eb1d42777055fc72715df24678be85f096e Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 21 Nov 2025 10:36:21 +0100
Subject: [PATCH 047/125] fix type of single events in df_loss_month

---
 .../engine/cat_bonds/sng_bond_simulation.py        | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/sng_bond_simulation.py b/climada_petals/engine/cat_bonds/sng_bond_simulation.py
index 2dca3c5d3..26a676f32 100644
--- a/climada_petals/engine/cat_bonds/sng_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/sng_bond_simulation.py
@@ -47,8 +47,10 @@ def init_bond_loss(self, events_per_year):
 
         # Use Python lists only for month-level output (tiny)
         df_monthly = pd.DataFrame(columns=[
-            "losses", "months"]
+            "losses", "months"], dtype=object
         )
+
+
         annual_losses = pd.Series(0.0, index=range(self.term))
 
         summed_damages = 0.0
@@ -61,22 +63,18 @@ def init_bond_loss(self, events_per_year):
             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]
@@ -87,10 +85,10 @@ def init_bond_loss(self, events_per_year):
 
                 # 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)
 
-            # Store relative losses and months
-            df_monthly.loc[year, "losses"] = payouts / principal0
-            df_monthly.loc[year, "months"] = months
 
             # Sum for annual loss
             annual_losses[year] = payouts.sum()

From 7c6458ba6d5335641d4eb9b67ea50bbf1f1df93a Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 21 Nov 2025 10:36:37 +0100
Subject: [PATCH 048/125] adjust to chanings in sng_simulation

---
 climada_petals/engine/cat_bonds/test.ipynb | 1952 +++++++++++++++++---
 1 file changed, 1730 insertions(+), 222 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/test.ipynb b/climada_petals/engine/cat_bonds/test.ipynb
index d9c90715b..a9802f715 100644
--- a/climada_petals/engine/cat_bonds/test.ipynb
+++ b/climada_petals/engine/cat_bonds/test.ipynb
@@ -77,9 +77,9 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-16 13:55:42,520 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
-      "2025-11-16 13:55:42,584 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
-      "2025-11-16 13:55:42,651 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n"
+      "2025-11-17 15:06:39,687 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
+      "2025-11-17 15:06:39,747 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
+      "2025-11-17 15:06:39,805 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n"
      ]
     },
     {
@@ -93,27 +93,27 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-16 13:55:47,717 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
-      "2025-11-16 13:55:47,808 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 546 coastal centroids.\n",
-      "2025-11-16 13:55:48,165 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
-      "2025-11-16 13:55:48,425 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
-      "2025-11-16 13:55:48,704 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
-      "2025-11-16 13:55:49,020 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
-      "2025-11-16 13:55:49,321 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
-      "2025-11-16 13:55:49,660 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
-      "2025-11-16 13:55:50,001 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
-      "2025-11-16 13:55:50,291 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
-      "2025-11-16 13:55:50,462 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
-      "2025-11-16 13:55:51,793 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      "2025-11-17 15:06:45,926 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
+      "2025-11-17 15:06:46,030 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 546 coastal centroids.\n",
+      "2025-11-17 15:06:46,361 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
+      "2025-11-17 15:06:46,740 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
+      "2025-11-17 15:06:47,095 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
+      "2025-11-17 15:06:47,478 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
+      "2025-11-17 15:06:47,785 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
+      "2025-11-17 15:06:48,184 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
+      "2025-11-17 15:06:48,570 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
+      "2025-11-17 15:06:48,893 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
+      "2025-11-17 15:06:49,079 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
+      "2025-11-17 15:06:50,191 - climada.entity.exposures.litpop.litpop - INFO - \n",
       " LitPop: Init Exposure for country: KNA (659)...\n",
       "\n",
-      "2025-11-16 13:55:51,881 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-16 13:55:52,193 - climada.util.finance - INFO - GDP KNA 2020: 8.839e+08.\n",
-      "2025-11-16 13:55:52,214 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
-      "2025-11-16 13:55:52,215 - climada.entity.exposures.base - INFO - category_id not set.\n",
-      "2025-11-16 13:55:52,215 - climada.entity.exposures.base - INFO - cover not set.\n",
-      "2025-11-16 13:55:52,216 - climada.entity.exposures.base - INFO - deductible not set.\n",
-      "2025-11-16 13:55:52,217 - climada.entity.exposures.base - INFO - centr_ not set.\n"
+      "2025-11-17 15:06:50,278 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-17 15:06:50,796 - climada.util.finance - INFO - GDP KNA 2020: 8.839e+08.\n",
+      "2025-11-17 15:06:50,814 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+      "2025-11-17 15:06:50,814 - climada.entity.exposures.base - INFO - category_id not set.\n",
+      "2025-11-17 15:06:50,815 - climada.entity.exposures.base - INFO - cover not set.\n",
+      "2025-11-17 15:06:50,815 - climada.entity.exposures.base - INFO - deductible not set.\n",
+      "2025-11-17 15:06:50,816 - climada.entity.exposures.base - INFO - centr_ not set.\n"
      ]
     }
    ],
@@ -158,29 +158,29 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-16 13:55:53,900 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
-      "2025-11-16 13:55:53,951 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
-      "2025-11-16 13:55:53,992 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
-      "2025-11-16 13:55:56,741 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
-      "2025-11-16 13:55:56,770 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 7938 coastal centroids.\n",
-      "2025-11-16 13:56:01,669 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
-      "2025-11-16 13:56:06,894 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
-      "2025-11-16 13:56:12,391 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
-      "2025-11-16 13:56:17,881 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
-      "2025-11-16 13:56:22,665 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
-      "2025-11-16 13:56:27,621 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
-      "2025-11-16 13:56:32,238 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
-      "2025-11-16 13:56:39,713 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
-      "2025-11-16 13:56:41,775 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
-      "2025-11-16 13:56:44,417 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      "2025-11-17 15:06:52,354 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
+      "2025-11-17 15:06:52,407 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
+      "2025-11-17 15:06:52,442 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
+      "2025-11-17 15:06:55,170 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
+      "2025-11-17 15:06:55,199 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 7938 coastal centroids.\n",
+      "2025-11-17 15:07:01,666 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
+      "2025-11-17 15:07:07,538 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
+      "2025-11-17 15:07:12,949 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
+      "2025-11-17 15:07:17,753 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
+      "2025-11-17 15:07:22,188 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
+      "2025-11-17 15:07:26,864 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
+      "2025-11-17 15:07:30,786 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
+      "2025-11-17 15:07:35,924 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
+      "2025-11-17 15:07:37,740 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
+      "2025-11-17 15:07:39,998 - climada.entity.exposures.litpop.litpop - INFO - \n",
       " LitPop: Init Exposure for country: JAM (388)...\n",
       "\n",
-      "2025-11-16 13:56:45,089 - climada.util.finance - INFO - GDP JAM 2020: 1.381e+10.\n",
-      "2025-11-16 13:56:45,133 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
-      "2025-11-16 13:56:45,133 - climada.entity.exposures.base - INFO - category_id not set.\n",
-      "2025-11-16 13:56:45,135 - climada.entity.exposures.base - INFO - cover not set.\n",
-      "2025-11-16 13:56:45,136 - climada.entity.exposures.base - INFO - deductible not set.\n",
-      "2025-11-16 13:56:45,137 - climada.entity.exposures.base - INFO - centr_ not set.\n"
+      "2025-11-17 15:07:40,861 - climada.util.finance - INFO - GDP JAM 2020: 1.381e+10.\n",
+      "2025-11-17 15:07:40,897 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+      "2025-11-17 15:07:40,898 - climada.entity.exposures.base - INFO - category_id not set.\n",
+      "2025-11-17 15:07:40,898 - climada.entity.exposures.base - INFO - cover not set.\n",
+      "2025-11-17 15:07:40,899 - climada.entity.exposures.base - INFO - deductible not set.\n",
+      "2025-11-17 15:07:40,900 - climada.entity.exposures.base - INFO - centr_ not set.\n"
      ]
     }
    ],
@@ -232,7 +232,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-16 13:56:47,280 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+      "2025-11-17 15:07:43,064 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
      ]
     },
     {
@@ -249,7 +249,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-16 13:57:09,541 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+      "2025-11-17 15:08:02,389 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
      ]
     },
     {
@@ -288,12 +288,12 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-16 13:57:28,101 - climada.entity.exposures.base - INFO - Matching 328 exposures with 546 centroids.\n",
-      "2025-11-16 13:57:28,105 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
-      "2025-11-16 13:57:28,118 - climada.engine.impact_calc - INFO - Calculating impact for 984 assets (>0) and 51 events.\n",
-      "2025-11-16 13:57:29,494 - climada.entity.exposures.base - INFO - Matching 13552 exposures with 7938 centroids.\n",
-      "2025-11-16 13:57:29,504 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
-      "2025-11-16 13:57:29,541 - climada.engine.impact_calc - INFO - Calculating impact for 40503 assets (>0) and 51 events.\n"
+      "2025-11-17 15:08:17,502 - climada.entity.exposures.base - INFO - Matching 328 exposures with 546 centroids.\n",
+      "2025-11-17 15:08:17,505 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
+      "2025-11-17 15:08:17,512 - climada.engine.impact_calc - INFO - Calculating impact for 984 assets (>0) and 51 events.\n",
+      "2025-11-17 15:08:18,641 - climada.entity.exposures.base - INFO - Matching 13552 exposures with 7938 centroids.\n",
+      "2025-11-17 15:08:18,648 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
+      "2025-11-17 15:08:18,864 - climada.engine.impact_calc - INFO - Calculating impact for 40503 assets (>0) and 51 events.\n"
      ]
     }
    ],
@@ -314,8 +314,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
-   "id": "62108c5e",
+   "execution_count": 11,
+   "id": "aacf777b",
    "metadata": {},
    "outputs": [
     {
@@ -344,55 +344,10 @@
      ]
     }
    ],
-   "source": [
-    "st_kitts_python_bond_sim = sng_bond_simulation(subarea_calc=st_kitts_sub_calc, term=term, number_of_terms=num_of_terms)\n",
-    "st_kitts_python_bond_sim.init_loss_simulation_pythonic(confidence_levels=[0.95, 0.99])\n",
-    "st_kitts_premiums_pythonic = premium_calculations(bond_simulation_class=st_kitts_python_bond_sim)\n",
-    "st_kitts_premiums_pythonic.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)\n",
-    "st_kitts_premiums_pythonic.calc_ibrd_premium()\n",
-    "st_kitts_premiums_pythonic.calc_benchmark_premium(target_sharpe = target_sharpe)\n",
-    "display(st_kitts_python_bond_sim.loss_metrics)\n",
-    "print(f\"Benchmark Sharpe Ratio premium rate: {round(st_kitts_premiums_pythonic.benchmark_prem_rate*100,1)}\")\n",
-    "print(f\"Chatoro premium rate: {round(st_kitts_premiums_pythonic.chatoro_prem_rate*100,1)}\")\n",
-    "print(f\"IBRD premium rate: {round(st_kitts_premiums_pythonic.ibrd_prem_rate*100,1)}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "f900a3e2",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'EL_ann': 0.017543859649122806,\n",
-       " 'AP_ann': 0.023391812865497075,\n",
-       " 'Tot_payout': 1325883333.3333325,\n",
-       " 'Tot_damages': 11037139919.100546,\n",
-       " 'VaR_99_ann': 0.7555314181864904,\n",
-       " 'VaR_95_ann': 0.0,\n",
-       " 'ES_99_ann': 1.0,\n",
-       " 'ES_95_ann': 0.75}"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Benchmark Sharpe Ratio premium rate: 8.7\n",
-      "Chatoro premium rate: 8.5\n",
-      "IBRD premium rate: 5.0\n"
-     ]
-    }
-   ],
    "source": [
     "### ST. KITTS AND NEVIS BOND SIMULATION ###\n",
     "st_kitts_bond_sim = sng_bond_simulation(subarea_calc=st_kitts_sub_calc, term=term, number_of_terms=num_of_terms) \n",
-    "st_kitts_bond_sim.init_loss_simulation()\n",
+    "st_kitts_bond_sim.init_loss_simulation_pythonic(confidence_levels=[0.95, 0.99])\n",
     "st_kitts_premiums = premium_calculations(bond_simulation_class=st_kitts_bond_sim)\n",
     "st_kitts_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)\n",
     "st_kitts_premiums.calc_ibrd_premium()\n",
@@ -405,7 +360,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "id": "4ead6e69",
    "metadata": {},
    "outputs": [
@@ -513,10 +468,10 @@
        " 'AP_ann': 0.023391812865497075,\n",
        " 'Tot_payout': 1325883333.3333325,\n",
        " 'Tot_damages': 11037139919.100546,\n",
-       " 'VaR_99_ann': 0.7555314181864904,\n",
        " 'VaR_95_ann': 0.0,\n",
-       " 'ES_99_ann': 1.0,\n",
-       " 'ES_95_ann': 0.75}"
+       " 'ES_95_ann': 0.75,\n",
+       " 'VaR_99_ann': 0.7555314181864904,\n",
+       " 'ES_99_ann': 1.0}"
       ]
      },
      "metadata": {},
@@ -550,130 +505,1669 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 70,
-   "id": "6cfb9d55",
+   "execution_count": 55,
+   "id": "053c9ff1",
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "{'annual_premiums': array([9.82169321e-02, 8.13626244e-02, 7.03841971e-02, 9.72188933e-02,\n",
-       "        8.62404660e-02, 8.62404660e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.65033813e-02,\n",
-       "        9.82169321e-02, 9.65033813e-02, 8.68177195e-02, 9.65033813e-02,\n",
-       "        8.68177195e-02, 5.87201365e-02, 9.70990243e-02, 6.82189176e-02,\n",
-       "        1.48503588e-04, 8.16338116e-02, 2.38431925e-03, 2.72606749e-18,\n",
-       "        3.01111648e-02, 1.64900113e-02, 1.64900113e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02, 9.82169321e-02,\n",
-       "        9.82169321e-02, 9.82169321e-02, 9.82169321e-02]),\n",
-       " 'annual_returns': array([-6.32243649e-02, -4.05762901e-02,  7.03841971e-02, -2.47200212e-02,\n",
-       "         8.62404660e-02,  8.62404660e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02, -8.17617377e-03,\n",
-       "         9.82169321e-02, -8.17617377e-03, -4.97666112e-02, -8.17617377e-03,\n",
-       "        -4.97666112e-02, -7.00015978e-01, -3.94853065e-02, -7.86124777e-01,\n",
-       "        -8.92347113e-03, -7.72709883e-01, -1.43271986e-01,  2.72606749e-18,\n",
-       "        -8.01995062e-01,  1.64900113e-02,  1.64900113e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02,  9.82169321e-02,\n",
-       "         9.82169321e-02,  9.82169321e-02,  9.82169321e-02]),\n",
-       " 'total_returns': 79444050915.31145,\n",
-       " 'total_premiums': 111097762521.12311,\n",
-       " 'sharpe_ratio': 0.5016182767396254}"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "{'EL_ann': 0.02680332628076214,\n",
-       " 'AP_ann': 0.08771929824561403,\n",
-       " 'Tot_payout': 31653711605.811665,\n",
-       " 'Tot_damages': 50919862874.32074,\n",
-       " 'VaR_99_ann': 0.8387774672602343,\n",
-       " 'VaR_95_ann': 0.12926162262991353,\n",
-       " 'ES_99_ann': 0.8543436945180888,\n",
-       " 'ES_95_ann': 0.4462644805505158}"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "12\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "test = np.array(12)\n",
+    "test_a = np.atleast_1d(test)\n",
+    "type(test.tolist())\n",
+    "print(test_a[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "id": "6cfb9d55",
+   "metadata": {},
+   "outputs": [
     {
      "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"
+      "[12] [1.11494765e+09] [1.29496354e+09]\n",
+      "1\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "                    losses  months\n",
+      "0  [[0.16144129701791735]]  [[12]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[ 3  6 10 11] [0.00000000e+00 0.00000000e+00 0.00000000e+00 8.42135863e+08] [0.00000000e+00 0.00000000e+00 0.00000000e+00 9.49343016e+08]\n",
+      "4\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "                                   losses            months\n",
+      "0                 [[0.16144129701791735]]            [[12]]\n",
+      "1  [[0.0, 0.0, 0.0, 0.12193891449668587]]  [[3, 6, 10, 11]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[ 1  2  4  5  8 12] [0. 0. 0. 0. 0. 0.] [0. 0. 0. 0. 0. 0.]\n",
+      "6\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "                                   losses                 months\n",
+      "0                 [[0.16144129701791735]]                 [[12]]\n",
+      "1  [[0.0, 0.0, 0.0, 0.12193891449668587]]       [[3, 6, 10, 11]]\n",
+      "2        [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]  [[1, 2, 4, 5, 8, 12]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[ 3  6 10 11] [0.00000000e+00 0.00000000e+00 0.00000000e+00 8.42135863e+08] [0.00000000e+00 0.00000000e+00 0.00000000e+00 9.49343016e+08]\n",
+      "4\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "                                   losses            months\n",
+      "0  [[0.0, 0.0, 0.0, 0.12193891449668587]]  [[3, 6, 10, 11]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[ 1  2  4  5  8 12] [0. 0. 0. 0. 0. 0.] [0. 0. 0. 0. 0. 0.]\n",
+      "6\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "                                   losses                 months\n",
+      "0  [[0.0, 0.0, 0.0, 0.12193891449668587]]       [[3, 6, 10, 11]]\n",
+      "1        [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]  [[1, 2, 4, 5, 8, 12]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[ 2  3  4  5  7  9 11 12] [0. 0. 0. 0. 0. 0. 0. 0.] [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      "8\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "                                       losses                        months\n",
+      "0      [[0.0, 0.0, 0.0, 0.12193891449668587]]              [[3, 6, 10, 11]]\n",
+      "1            [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]         [[1, 2, 4, 5, 8, 12]]\n",
+      "2  [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]  [[2, 3, 4, 5, 7, 9, 11, 12]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[ 1  2  4  5  8 12] [0. 0. 0. 0. 0. 0.] [0. 0. 0. 0. 0. 0.]\n",
+      "6\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "                             losses                 months\n",
+      "0  [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]  [[1, 2, 4, 5, 8, 12]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[ 2  3  4  5  7  9 11 12] [0. 0. 0. 0. 0. 0. 0. 0.] [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      "8\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "                                       losses                        months\n",
+      "0            [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]         [[1, 2, 4, 5, 8, 12]]\n",
+      "1  [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]  [[2, 3, 4, 5, 7, 9, 11, 12]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[ 2  4  5  7  8 10] [0. 0. 0. 0. 0. 0.] [7.59322289e+08 0.00000000e+00 8.52570984e+08 9.55196924e+08\n",
+      " 0.00000000e+00 0.00000000e+00]\n",
+      "6\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "                                       losses                        months\n",
+      "0            [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]         [[1, 2, 4, 5, 8, 12]]\n",
+      "1  [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]  [[2, 3, 4, 5, 7, 9, 11, 12]]\n",
+      "2            [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]         [[2, 4, 5, 7, 8, 10]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[ 2  3  4  5  7  9 11 12] [0. 0. 0. 0. 0. 0. 0. 0.] [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      "8\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "                                       losses                        months\n",
+      "0  [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]  [[2, 3, 4, 5, 7, 9, 11, 12]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[ 2  4  5  7  8 10] [0. 0. 0. 0. 0. 0.] [7.59322289e+08 0.00000000e+00 8.52570984e+08 9.55196924e+08\n",
+      " 0.00000000e+00 0.00000000e+00]\n",
+      "6\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "                                       losses                        months\n",
+      "0  [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]  [[2, 3, 4, 5, 7, 9, 11, 12]]\n",
+      "1            [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]         [[2, 4, 5, 7, 8, 10]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[ 1  5  6  8 10] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
+      " 7.22939086e+08] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
+      " 6.92971219e+08]\n",
+      "5\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "                                        losses                        months\n",
+      "0   [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]  [[2, 3, 4, 5, 7, 9, 11, 12]]\n",
+      "1             [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]         [[2, 4, 5, 7, 8, 10]]\n",
+      "2  [[0.0, 0.0, 0.0, 0.0, 0.10467955511451421]]            [[1, 5, 6, 8, 10]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[ 2  4  5  7  8 10] [0. 0. 0. 0. 0. 0.] [7.59322289e+08 0.00000000e+00 8.52570984e+08 9.55196924e+08\n",
+      " 0.00000000e+00 0.00000000e+00]\n",
+      "6\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "                             losses                 months\n",
+      "0  [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]  [[2, 4, 5, 7, 8, 10]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[ 1  5  6  8 10] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
+      " 7.22939086e+08] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
+      " 6.92971219e+08]\n",
+      "5\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "                                        losses                 months\n",
+      "0             [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]  [[2, 4, 5, 7, 8, 10]]\n",
+      "1  [[0.0, 0.0, 0.0, 0.0, 0.10467955511451421]]     [[1, 5, 6, 8, 10]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[ 1  2  3  4  6  8 10 11 12] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
+      " 0.00000000e+00 0.00000000e+00 0.00000000e+00 9.43280196e+08\n",
+      " 0.00000000e+00] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
+      " 0.00000000e+00 1.51272779e+09 0.00000000e+00 9.06019669e+08\n",
+      " 7.26858410e+08]\n",
+      "9\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "                                              losses  \\\n",
+      "0                   [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]   \n",
+      "1        [[0.0, 0.0, 0.0, 0.0, 0.10467955511451421]]   \n",
+      "2  [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.1365843...   \n",
+      "\n",
+      "                             months  \n",
+      "0             [[2, 4, 5, 7, 8, 10]]  \n",
+      "1                [[1, 5, 6, 8, 10]]  \n",
+      "2  [[1, 2, 3, 4, 6, 8, 10, 11, 12]]  \n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[ 1  5  6  8 10] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
+      " 7.22939086e+08] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
+      " 6.92971219e+08]\n",
+      "5\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "                                        losses              months\n",
+      "0  [[0.0, 0.0, 0.0, 0.0, 0.10467955511451421]]  [[1, 5, 6, 8, 10]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[ 1  2  3  4  6  8 10 11 12] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
+      " 0.00000000e+00 0.00000000e+00 0.00000000e+00 9.43280196e+08\n",
+      " 0.00000000e+00] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
+      " 0.00000000e+00 1.51272779e+09 0.00000000e+00 9.06019669e+08\n",
+      " 7.26858410e+08]\n",
+      "9\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "                                              losses  \\\n",
+      "0        [[0.0, 0.0, 0.0, 0.0, 0.10467955511451421]]   \n",
+      "1  [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.1365843...   \n",
+      "\n",
+      "                             months  \n",
+      "0                [[1, 5, 6, 8, 10]]  \n",
+      "1  [[1, 2, 3, 4, 6, 8, 10, 11, 12]]  \n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[ 2  4  6  8  9 11 12] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
+      " 4.04620234e+09 1.85407541e+09 0.00000000e+00] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
+      " 1.69449885e+09 1.78865783e+09 0.00000000e+00]\n",
+      "5\n",
+      "exhaused [0. 0. 0. 0. 0. 0. 0.]\n",
+      "payouts before exhausion [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
+      " 4.04620234e+09 0.00000000e+00 0.00000000e+00]\n",
+      "payouts at exhausion [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
+      " 4.04620234e+09 1.19378929e+09 0.00000000e+00]\n",
+      "assign to year 2\n",
+      "                                              losses  \\\n",
+      "0        [[0.0, 0.0, 0.0, 0.0, 0.10467955511451421]]   \n",
+      "1  [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.1365843...   \n",
+      "2  [[0.0, 0.0, 0.0, 0.0, 0.5858787676747096, 0.17...   \n",
+      "\n",
+      "                             months  \n",
+      "0                [[1, 5, 6, 8, 10]]  \n",
+      "1  [[1, 2, 3, 4, 6, 8, 10, 11, 12]]  \n",
+      "2         [[2, 4, 6, 8, 9, 11, 12]]  \n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[ 1  2  3  4  6  8 10 11 12] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
+      " 0.00000000e+00 0.00000000e+00 0.00000000e+00 9.43280196e+08\n",
+      " 0.00000000e+00] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
+      " 0.00000000e+00 1.51272779e+09 0.00000000e+00 9.06019669e+08\n",
+      " 7.26858410e+08]\n",
+      "9\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "                                              losses  \\\n",
+      "0  [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.1365843...   \n",
+      "\n",
+      "                             months  \n",
+      "0  [[1, 2, 3, 4, 6, 8, 10, 11, 12]]  \n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[ 2  4  6  8  9 11 12] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
+      " 4.04620234e+09 1.85407541e+09 0.00000000e+00] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
+      " 1.69449885e+09 1.78865783e+09 0.00000000e+00]\n",
+      "7\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "                                              losses  \\\n",
+      "0  [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.1365843...   \n",
+      "1  [[0.0, 0.0, 0.0, 0.0, 0.5858787676747096, 0.26...   \n",
+      "\n",
+      "                             months  \n",
+      "0  [[1, 2, 3, 4, 6, 8, 10, 11, 12]]  \n",
+      "1         [[2, 4, 6, 8, 9, 11, 12]]  \n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[1 2] [0.00000000e+00 5.74670111e+09] [0.00000000e+00 6.01991379e+09]\n",
+      "1\n",
+      "exhaused [0. 0.]\n",
+      "payouts before exhausion [0. 0.]\n",
+      "payouts at exhausion [       0.         62652970.84939575]\n",
+      "assign to year 2\n",
+      "                                              losses  \\\n",
+      "0  [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.1365843...   \n",
+      "1  [[0.0, 0.0, 0.0, 0.0, 0.5858787676747096, 0.26...   \n",
+      "2                      [[0.0, 0.009071974718769974]]   \n",
+      "\n",
+      "                             months  \n",
+      "0  [[1, 2, 3, 4, 6, 8, 10, 11, 12]]  \n",
+      "1         [[2, 4, 6, 8, 9, 11, 12]]  \n",
+      "2                          [[1, 2]]  \n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[ 2  4  6  8  9 11 12] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
+      " 4.04620234e+09 1.85407541e+09 0.00000000e+00] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
+      " 1.69449885e+09 1.78865783e+09 0.00000000e+00]\n",
+      "7\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "                                              losses  \\\n",
+      "0  [[0.0, 0.0, 0.0, 0.0, 0.5858787676747096, 0.26...   \n",
+      "\n",
+      "                      months  \n",
+      "0  [[2, 4, 6, 8, 9, 11, 12]]  \n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[1 2] [0.00000000e+00 5.74670111e+09] [0.00000000e+00 6.01991379e+09]\n",
+      "1\n",
+      "exhaused [0. 0.]\n",
+      "payouts before exhausion [0. 0.]\n",
+      "payouts at exhausion [0.00000000e+00 1.00593317e+09]\n",
+      "assign to year 1\n",
+      "                                              losses  \\\n",
+      "0  [[0.0, 0.0, 0.0, 0.0, 0.5858787676747096, 0.26...   \n",
+      "1                        [[0.0, 0.1456563054819112]]   \n",
+      "\n",
+      "                      months  \n",
+      "0  [[2, 4, 6, 8, 9, 11, 12]]  \n",
+      "1                   [[1, 2]]  \n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "                                              losses  \\\n",
+      "0  [[0.0, 0.0, 0.0, 0.0, 0.5858787676747096, 0.26...   \n",
+      "1                        [[0.0, 0.1456563054819112]]   \n",
+      "2                                               [[]]   \n",
+      "\n",
+      "                      months  \n",
+      "0  [[2, 4, 6, 8, 9, 11, 12]]  \n",
+      "1                   [[1, 2]]  \n",
+      "2                       [[]]  \n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[1 2] [0.00000000e+00 5.74670111e+09] [0.00000000e+00 6.01991379e+09]\n",
+      "2\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "                        losses    months\n",
+      "0  [[0.0, 0.8321062270068676]]  [[1, 2]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "                        losses    months\n",
+      "0  [[0.0, 0.8321062270068676]]  [[1, 2]]\n",
+      "1                         [[]]      [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "                        losses    months\n",
+      "0  [[0.0, 0.8321062270068676]]  [[1, 2]]\n",
+      "1                         [[]]      [[]]\n",
+      "2                         [[]]      [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 0\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 1\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "[] [] []\n",
+      "0\n",
+      "not exhaused\n",
+      "assign to year 2\n",
+      "  losses months\n",
+      "0   [[]]   [[]]\n",
+      "1   [[]]   [[]]\n",
+      "2   [[]]   [[]]\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "<class 'pandas.core.series.Series'>\n",
+      "test\n"
+     ]
+    },
+    {
+     "ename": "ValueError",
+     "evalue": "non-broadcastable output operand with shape (1,) doesn't match the broadcast shape (4,)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
+      "\u001b[31mValueError\u001b[39m                                Traceback (most recent call last)",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[67]\u001b[39m\u001b[32m, line 7\u001b[39m\n\u001b[32m      5\u001b[39m jamaica_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)\n\u001b[32m      6\u001b[39m jamaica_premiums.calc_ibrd_premium()\n\u001b[32m----> \u001b[39m\u001b[32m7\u001b[39m \u001b[43mjamaica_premiums\u001b[49m\u001b[43m.\u001b[49m\u001b[43mcalc_benchmark_premium\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtarget_sharpe\u001b[49m\u001b[43m \u001b[49m\u001b[43m=\u001b[49m\u001b[43m \u001b[49m\u001b[43mtarget_sharpe\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m      8\u001b[39m jamaica_bond_sim.init_return_simulation(premium=jamaica_premiums.chatoro_prem_rate)\n\u001b[32m      9\u001b[39m display(jamaica_bond_sim.return_metrics)\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/climada_petals_repo/climada_petals/climada_petals/engine/cat_bonds/premium_class.py:161\u001b[39m, in \u001b[36mpremium_calculations.calc_benchmark_premium\u001b[39m\u001b[34m(self, target_sharpe)\u001b[39m\n\u001b[32m    145\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mcalc_benchmark_premium\u001b[39m(\u001b[38;5;28mself\u001b[39m, target_sharpe):        \n\u001b[32m    146\u001b[39m \u001b[38;5;250m    \u001b[39m\u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m    147\u001b[39m \u001b[33;03m    Calculates the initial premium required to achieve a target Sharpe ratio for a given set of annual losses.\u001b[39;00m\n\u001b[32m    148\u001b[39m \u001b[33;03m    This function uses numerical optimization to find the premium value that results in the desired Sharpe ratio,\u001b[39;00m\n\u001b[32m   (...)\u001b[39m\u001b[32m    158\u001b[39m \u001b[33;03m        float: The optimal premium value that achieves the target Sharpe ratio.\u001b[39;00m\n\u001b[32m    159\u001b[39m \u001b[33;03m    \"\"\"\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m161\u001b[39m     result = \u001b[43mminimize\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43;01mlambda\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mp\u001b[49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mfind_sharpe\u001b[49m\u001b[43m(\u001b[49m\u001b[43mp\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mbond_simulation_class\u001b[49m\u001b[43m.\u001b[49m\u001b[43mdf_loss_month\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtarget_sharpe\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[32m    162\u001b[39m \u001b[43m                      \u001b[49m\u001b[43mx0\u001b[49m\u001b[43m=\u001b[49m\u001b[43m[\u001b[49m\u001b[32;43m0.05\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    163\u001b[39m     \u001b[38;5;28mself\u001b[39m.benchmark_prem_rate = result.x[\u001b[32m0\u001b[39m]\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/miniforge3/envs/climada_env/lib/python3.11/site-packages/scipy/optimize/_minimize.py:726\u001b[39m, in \u001b[36mminimize\u001b[39m\u001b[34m(fun, x0, args, method, jac, hess, hessp, bounds, constraints, tol, callback, options)\u001b[39m\n\u001b[32m    724\u001b[39m     res = _minimize_cg(fun, x0, args, jac, callback, **options)\n\u001b[32m    725\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m meth == \u001b[33m'\u001b[39m\u001b[33mbfgs\u001b[39m\u001b[33m'\u001b[39m:\n\u001b[32m--> \u001b[39m\u001b[32m726\u001b[39m     res = \u001b[43m_minimize_bfgs\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfun\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx0\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mjac\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcallback\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43moptions\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    727\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m meth == \u001b[33m'\u001b[39m\u001b[33mnewton-cg\u001b[39m\u001b[33m'\u001b[39m:\n\u001b[32m    728\u001b[39m     res = _minimize_newtoncg(fun, x0, args, jac, hess, hessp, callback,\n\u001b[32m    729\u001b[39m                              **options)\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/miniforge3/envs/climada_env/lib/python3.11/site-packages/scipy/optimize/_optimize.py:1371\u001b[39m, in \u001b[36m_minimize_bfgs\u001b[39m\u001b[34m(fun, x0, args, jac, callback, gtol, norm, eps, maxiter, disp, return_all, finite_diff_rel_step, xrtol, c1, c2, hess_inv0, **unknown_options)\u001b[39m\n\u001b[32m   1368\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m maxiter \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m   1369\u001b[39m     maxiter = \u001b[38;5;28mlen\u001b[39m(x0) * \u001b[32m200\u001b[39m\n\u001b[32m-> \u001b[39m\u001b[32m1371\u001b[39m sf = \u001b[43m_prepare_scalar_function\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfun\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx0\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mjac\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m=\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mepsilon\u001b[49m\u001b[43m=\u001b[49m\u001b[43meps\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m   1372\u001b[39m \u001b[43m                              \u001b[49m\u001b[43mfinite_diff_rel_step\u001b[49m\u001b[43m=\u001b[49m\u001b[43mfinite_diff_rel_step\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m   1374\u001b[39m f = sf.fun\n\u001b[32m   1375\u001b[39m myfprime = sf.grad\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/miniforge3/envs/climada_env/lib/python3.11/site-packages/scipy/optimize/_optimize.py:288\u001b[39m, in \u001b[36m_prepare_scalar_function\u001b[39m\u001b[34m(fun, x0, jac, args, bounds, epsilon, finite_diff_rel_step, hess)\u001b[39m\n\u001b[32m    284\u001b[39m     bounds = (-np.inf, np.inf)\n\u001b[32m    286\u001b[39m \u001b[38;5;66;03m# ScalarFunction caches. Reuse of fun(x) during grad\u001b[39;00m\n\u001b[32m    287\u001b[39m \u001b[38;5;66;03m# calculation reduces overall function evaluations.\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m288\u001b[39m sf = \u001b[43mScalarFunction\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfun\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx0\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgrad\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mhess\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    289\u001b[39m \u001b[43m                    \u001b[49m\u001b[43mfinite_diff_rel_step\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbounds\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mepsilon\u001b[49m\u001b[43m=\u001b[49m\u001b[43mepsilon\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    291\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m sf\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/miniforge3/envs/climada_env/lib/python3.11/site-packages/scipy/optimize/_differentiable_functions.py:222\u001b[39m, in \u001b[36mScalarFunction.__init__\u001b[39m\u001b[34m(self, fun, x0, args, grad, hess, finite_diff_rel_step, finite_diff_bounds, epsilon)\u001b[39m\n\u001b[32m    219\u001b[39m     finite_diff_options[\u001b[33m\"\u001b[39m\u001b[33mas_linear_operator\u001b[39m\u001b[33m\"\u001b[39m] = \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[32m    221\u001b[39m \u001b[38;5;66;03m# Initial function evaluation\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m222\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_update_fun\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    224\u001b[39m \u001b[38;5;66;03m# Initial gradient evaluation\u001b[39;00m\n\u001b[32m    225\u001b[39m \u001b[38;5;28mself\u001b[39m._wrapped_grad, \u001b[38;5;28mself\u001b[39m._ngev = _wrapper_grad(\n\u001b[32m    226\u001b[39m     grad,\n\u001b[32m    227\u001b[39m     fun=\u001b[38;5;28mself\u001b[39m._wrapped_fun,\n\u001b[32m    228\u001b[39m     args=args,\n\u001b[32m    229\u001b[39m     finite_diff_options=finite_diff_options\n\u001b[32m    230\u001b[39m )\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/miniforge3/envs/climada_env/lib/python3.11/site-packages/scipy/optimize/_differentiable_functions.py:294\u001b[39m, in \u001b[36mScalarFunction._update_fun\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m    292\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m_update_fun\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[32m    293\u001b[39m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m.f_updated:\n\u001b[32m--> \u001b[39m\u001b[32m294\u001b[39m         fx = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_wrapped_fun\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    295\u001b[39m         \u001b[38;5;28;01mif\u001b[39;00m fx < \u001b[38;5;28mself\u001b[39m._lowest_f:\n\u001b[32m    296\u001b[39m             \u001b[38;5;28mself\u001b[39m._lowest_x = \u001b[38;5;28mself\u001b[39m.x\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/miniforge3/envs/climada_env/lib/python3.11/site-packages/scipy/optimize/_differentiable_functions.py:20\u001b[39m, in \u001b[36m_wrapper_fun.<locals>.wrapped\u001b[39m\u001b[34m(x)\u001b[39m\n\u001b[32m     16\u001b[39m ncalls[\u001b[32m0\u001b[39m] += \u001b[32m1\u001b[39m\n\u001b[32m     17\u001b[39m \u001b[38;5;66;03m# Send a copy because the user may overwrite it.\u001b[39;00m\n\u001b[32m     18\u001b[39m \u001b[38;5;66;03m# Overwriting results in undefined behaviour because\u001b[39;00m\n\u001b[32m     19\u001b[39m \u001b[38;5;66;03m# fun(self.x) will change self.x, with the two no longer linked.\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m20\u001b[39m fx = \u001b[43mfun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnp\u001b[49m\u001b[43m.\u001b[49m\u001b[43mcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m     21\u001b[39m \u001b[38;5;66;03m# Make sure the function returns a true scalar\u001b[39;00m\n\u001b[32m     22\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m np.isscalar(fx):\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/climada_petals_repo/climada_petals/climada_petals/engine/cat_bonds/premium_class.py:161\u001b[39m, in \u001b[36mpremium_calculations.calc_benchmark_premium.<locals>.<lambda>\u001b[39m\u001b[34m(p)\u001b[39m\n\u001b[32m    145\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mcalc_benchmark_premium\u001b[39m(\u001b[38;5;28mself\u001b[39m, target_sharpe):        \n\u001b[32m    146\u001b[39m \u001b[38;5;250m    \u001b[39m\u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m    147\u001b[39m \u001b[33;03m    Calculates the initial premium required to achieve a target Sharpe ratio for a given set of annual losses.\u001b[39;00m\n\u001b[32m    148\u001b[39m \u001b[33;03m    This function uses numerical optimization to find the premium value that results in the desired Sharpe ratio,\u001b[39;00m\n\u001b[32m   (...)\u001b[39m\u001b[32m    158\u001b[39m \u001b[33;03m        float: The optimal premium value that achieves the target Sharpe ratio.\u001b[39;00m\n\u001b[32m    159\u001b[39m \u001b[33;03m    \"\"\"\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m161\u001b[39m     result = minimize(\u001b[38;5;28;01mlambda\u001b[39;00m p: \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mfind_sharpe\u001b[49m\u001b[43m(\u001b[49m\u001b[43mp\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mbond_simulation_class\u001b[49m\u001b[43m.\u001b[49m\u001b[43mdf_loss_month\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtarget_sharpe\u001b[49m\u001b[43m)\u001b[49m, \n\u001b[32m    162\u001b[39m                       x0=[\u001b[32m0.05\u001b[39m])\n\u001b[32m    163\u001b[39m     \u001b[38;5;28mself\u001b[39m.benchmark_prem_rate = result.x[\u001b[32m0\u001b[39m]\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m<string>:31\u001b[39m, in \u001b[36mfind_sharpe\u001b[39m\u001b[34m(self, premium, monthly_losses, target_sharpe)\u001b[39m\n",
+      "\u001b[31mValueError\u001b[39m: non-broadcastable output operand with shape (1,) doesn't match the broadcast shape (4,)"
      ]
     }
    ],
@@ -695,10 +2189,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 71,
+   "execution_count": 14,
    "id": "67403f5f",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'countries' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
+      "\u001b[31mNameError\u001b[39m                                 Traceback (most recent call last)",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[14]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m      1\u001b[39m mlt_cat_bond = mlt_bond_simulation(subarea_calc_list=[st_kitts_sub_calc, jamaica_sub_calc], countries_list=countries, term=term,number_of_terms=num_of_terms, tranches=[\u001b[32m50\u001b[39m,\u001b[32m100\u001b[39m])\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m \u001b[43mmlt_cat_bond\u001b[49m\u001b[43m.\u001b[49m\u001b[43minit_loss_simulation\u001b[49m\u001b[43m(\u001b[49m\u001b[43mprincipal\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m6000000000\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mconfidence_levels\u001b[49m\u001b[43m=\u001b[49m\u001b[43m[\u001b[49m\u001b[32;43m0.95\u001b[39;49m\u001b[43m,\u001b[49m\u001b[32;43m0.99\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m<string>:49\u001b[39m, in \u001b[36minit_loss_simulation\u001b[39m\u001b[34m(self, principal, confidence_levels)\u001b[39m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/climada_petals_repo/climada_petals/climada_petals/engine/cat_bonds/mlt_bond_simulation.py:97\u001b[39m, in \u001b[36mmlt_bond_simulation.init_bond_loss\u001b[39m\u001b[34m(self, events_per_year, principal)\u001b[39m\n\u001b[32m     95\u001b[39m sum_payouts = np.zeros(\u001b[38;5;28mlen\u001b[39m(events))  \n\u001b[32m     96\u001b[39m sum_damages = np.zeros(\u001b[38;5;28mlen\u001b[39m(events)) \n\u001b[32m---> \u001b[39m\u001b[32m97\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m payout, country, damage \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(pay, \u001b[43mcountries\u001b[49m, damages):\n\u001b[32m     99\u001b[39m     \u001b[38;5;28;01mif\u001b[39;00m payout == \u001b[32m0\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m cur_nominal == \u001b[32m0\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m cur_nom_cty[\u001b[38;5;28mint\u001b[39m(cty)] == \u001b[32m0\u001b[39m:\n\u001b[32m    100\u001b[39m         event_payout = \u001b[32m0\u001b[39m\n",
+      "\u001b[31mNameError\u001b[39m: name 'countries' is not defined"
+     ]
+    }
+   ],
    "source": [
     "mlt_cat_bond = mlt_bond_simulation(subarea_calc_list=[st_kitts_sub_calc, jamaica_sub_calc], countries_list=countries, term=term,number_of_terms=num_of_terms, tranches=[50,100])\n",
     "mlt_cat_bond.init_loss_simulation(principal=6000000000, confidence_levels=[0.95,0.99])"

From ad92d3919200552884cdac35cef8bb6a3d842ff1 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 21 Nov 2025 12:03:11 +0100
Subject: [PATCH 049/125] implement return simulation mlt bonds

---
 .../engine/cat_bonds/mlt_bond_simulation.py   | 238 ++++++++++++++----
 1 file changed, 193 insertions(+), 45 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
index 45c59c9ec..1c32e01b7 100644
--- a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
@@ -74,67 +74,56 @@ def init_bond_loss(self, events_per_year, principal):
         loss_month_data = []
         cur_nominal = principal
         cur_nom_cty = self.principal_dic_cty.copy() 
-        tot_damage = []
+        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):
-            cty_losses_event = {country: [] for country in self.countries}
-            cty_damages_event = {country: [] for country in self.countries}
-            sum_payouts = np.zeros(len(events_per_year[k]))
 
             if not events_per_year[k].empty:
                 events = events_per_year[k].sort_values(by='month')
                 months = events['month'].to_numpy()
-                cties = events['country_code'].to_numpy()
+                countries = events['country_code'].to_numpy()
                 pay = events['pay'].to_numpy()
-                dam = events['damage'].to_numpy()
+                damages = events['damage'].to_numpy()
+                sum_damages += np.sum(damages)
 
                 sum_payouts = np.zeros(len(events))  
-                sum_damages = np.zeros(len(events)) 
-                for payout, country, damage in zip(pay, countries, damages):
+                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(cty)] == 0:
+                    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(cty)] -= event_payout
-                        if cur_nom_cty[int(cty)] < 0:
-                            event_payout += cur_nom_cty[int(cty)]
-                            cur_nom_cty[int(cty)] = 0
+                        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[o] = event_payout
-                    sum_damages[o] = damage
-                    cty_losses_event[cty].append(event_payout)
-                    cty_damages_event[cty].append(damage)
-                losses = np.sum(sum_payouts)
-                damages = np.sum(sum_damages)
-                for cty, cty_loss in cty_losses_event.items():
-                    rel_ann_cty_losses[cty][k] = np.sum(cty_loss)
-                    coverage_cty[cty]['payout'] += sum(cty_losses_event[cty])
-                    coverage_cty[cty]['damage'] += sum(cty_damages_event[cty])
+                    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:
-                losses = 0
-                damages = 0
+                sum_payouts = 0
                 months = []
 
-            ann_loss[k] = losses
-            tot_damage.append(damages)
+            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)
-        for key in rel_ann_cty_losses.keys():
-            rel_ann_cty_losses[key] = rel_ann_cty_losses[key] / principal 
         rel_bond_monthly_losses['losses'] = rel_bond_monthly_losses['losses'].values / principal
-        coverage_tot = {'payout': np.sum(ann_loss), 'damage': np.sum(tot_damage)}
+        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
 
 
@@ -177,7 +166,7 @@ def init_loss_simulation(self, principal, confidence_levels=[0.95, 0.99]):
         coverage = {'payout': 0, 'damage': 0}
         self.tot_coverage_cty = {}
         for cty in self.countries:
-            self.tot_coverage_cty[cty] = {'payout': [], 'damage': [], 'coverage': [], 'EL': 0, 'share_EL': 0}
+            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 = []
@@ -198,8 +187,8 @@ def init_loss_simulation(self, principal, confidence_levels=[0.95, 0.99]):
             coverage['damage'] += coverage_tot['damage']
 
             for key in coverage_cty.keys():
-                self.tot_coverage_cty[key]['payout'].append(coverage_cty[key]['payout'])
-                self.tot_coverage_cty[key]['damage'].append(coverage_cty[key]['damage'])
+                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])
@@ -212,15 +201,11 @@ def init_loss_simulation(self, principal, confidence_levels=[0.95, 0.99]):
         annual_losses = pd.Series(annual_losses)
         total_losses = pd.Series(total_losses)
 
-        risk_metrics_annual = multi_level_es(annual_losses, confidence_levels)
+        var_list, es_list = multi_level_es(annual_losses, confidence_levels)
 
         for key in self.tot_coverage_cty.keys():
-            self.tot_coverage_cty[key]['payout'] = sum(self.tot_coverage_cty[key]['payout'])
-            self.tot_coverage_cty[key]['damage'] = sum(self.tot_coverage_cty[key]['damage'])
             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])
-
-        for key in self.tot_coverage_cty:
             self.tot_coverage_cty[key]['share_EL'] = self.tot_coverage_cty[key]['EL'] / exp_loss_ann
         
 
@@ -228,14 +213,177 @@ def init_loss_simulation(self, principal, confidence_levels=[0.95, 0.99]):
         self.loss_metrics = {'EL_ann': exp_loss_ann,
                              'AP_ann': att_prob_ann,
                              'Payout': coverage['payout'], 
-                             'Damage': coverage['damage'], 
-                             'VaR_99_ann': risk_metrics_annual[0.99]['VaR'], 
-                             'VaR_95_ann': risk_metrics_annual[0.95]['VaR'], 
-                             'ES_99_ann': risk_metrics_annual[0.99]['ES'], 
-                             'ES_95_ann': risk_metrics_annual[0.95]['ES']}
+                             '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}')
 
 
-  
\ No newline at end of file
+    '''reduced function to derive returns of the bond -> was used to save time during calculation'''
+    def simulate_ncf_prem(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] = 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 simulate_ncf_prem_tranches(self, premiums, 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.
+        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 = {tranche['RP']: [] for _, tranche in self.tranches.iterrows()}
+        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_it_alt = 0
+                for k, tranche in enumerate(self.tranches):
+                    ncf[tranche['RP']].append(cur_nominal * tranche['nominal'] * premiums[k] + rf)
+                    prem_it_alt += cur_nominal * tranche['nominal'] * premiums[k]
+                premiums_tot.append(prem_it_alt)
+            else:
+                ncf_tmp = {tranche['RP']: [] for _, tranche in self.tranches.iterrows()}
+                prem_it_alt = 0
+                premiums_tot_tmp = []
+                for k, tranche in enumerate(self.tranches):
+                    ncf_tmp[tranche['RP']].append(cur_nominal * tranche['nominal'] * (premiums[k] + rf) / 12 * months[0])
+                    prem_it_alt += cur_nominal * tranche['nominal'] * premiums[k] / 12 * months[0]
+                premiums_tot_tmp.append(prem_it_alt)
+                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]
+                        prem_it_alt = 0
+                        for k, tranche in enumerate(self.tranches):
+                            ncf_tmp[tranche['RP']].append(((cur_nominal * tranche['nominal'] * (premiums[k] + rf)) / 12 * (nex_month - month)))
+                            prem_it_alt += cur_nominal * tranche['nominal'] * premiums[k] / 12 * (nex_month - month)
+                        premiums_tot_tmp.append(prem_it_alt)
+                    else:
+                        prem_it_alt = 0
+                        for k, tranche in enumerate(self.tranches):
+                            ncf_tmp[tranche['RP']].append(((cur_nominal * tranche['nominal'] * (premiums[k] + rf)) / 12 * (12- month)))
+                            prem_it_alt += cur_nominal * tranche['nominal'] * premiums[k] / 12 * (12- month)
+                        premiums_tot_tmp.append(prem_it_alt)
+                tmp_loss = np.sum(losses)
+                for _, tranche in self.tranches.iloc[::-1].iterrows():
+                    to_cover = tmp_loss - tranche['lower_bound']
+                    if to_cover < 0:
+                        to_cover = 0
+                    ncf[tranche['RP']].append(np.sum(ncf_tmp[tranche['RP']]) - to_cover)
+                    tmp_loss -= to_cover
+                premiums_tot.append(np.sum(premiums_tot_tmp))
+            if (i + 1) % self.term == 0:
+                cur_nominal = 1
+
+        ncf['Total'] = ncf_tot
+        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
+
+        ncf = pd.DataFrame(ncf)
+        prem_cty_df = pd.DataFrame(prem_cty_dic)
+        return ncf, prem_cty_df

From 9c5ca134654e4556f752b9c5f0bea8c9069f3773 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 21 Nov 2025 12:10:13 +0100
Subject: [PATCH 050/125] rename funciton names

---
 climada_petals/engine/cat_bonds/mlt_bond_simulation.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
index 1c32e01b7..aa62a1977 100644
--- a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
@@ -224,7 +224,7 @@ def init_loss_simulation(self, principal, confidence_levels=[0.95, 0.99]):
 
 
     '''reduced function to derive returns of the bond -> was used to save time during calculation'''
-    def simulate_ncf_prem(self, premium, rf=0.0):
+    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, 
@@ -298,7 +298,7 @@ def simulate_ncf_prem(self, premium, rf=0.0):
 
   
     '''reduced function to derive returns of the bond -> was used to save time during calculation'''
-    def simulate_ncf_prem_tranches(self, premiums, rf=0.0):
+    def init_return_simulation_tranches(self, premiums, 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, 

From 0e95f181f02381ec9ee3b55738ca684433a3b8e4 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 21 Nov 2025 15:17:04 +0100
Subject: [PATCH 051/125] init function to calculate returns with trances

---
 .../engine/cat_bonds/mlt_bond_simulation.py   | 85 ++++++++++++-------
 1 file changed, 54 insertions(+), 31 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
index aa62a1977..ddabf9737 100644
--- a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
@@ -286,12 +286,11 @@ def init_return_simulation(self, premium, rf=0.0):
                 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] = premiums_tot * self.tot_coverage_cty[country]['share_EL']
+            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)
 
@@ -326,64 +325,88 @@ def init_return_simulation_tranches(self, premiums, rf=0.0):
         - Losses are allocated to tranches in reverse order (from highest to lowest risk).
         """
 
-        ncf = {tranche['RP']: [] for _, tranche in self.tranches.iterrows()}
+        ncf = {str(tranche): [] for tranche in self.tranches}
         premiums_tot = []
-        ncf_tot = []
-        cur_nominal = 1
+        cur_nominal_tranches = self.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(self.tranches):
-                    ncf[tranche['RP']].append(cur_nominal * tranche['nominal'] * premiums[k] + rf)
-                    prem_it_alt += cur_nominal * tranche['nominal'] * premiums[k]
+                    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 = {tranche['RP']: [] for _, tranche in self.tranches.iterrows()}
+                ncf_tmp = {str(tranche): [] for tranche in self.tranches}
                 prem_it_alt = 0
                 premiums_tot_tmp = []
                 for k, tranche in enumerate(self.tranches):
-                    ncf_tmp[tranche['RP']].append(cur_nominal * tranche['nominal'] * (premiums[k] + rf) / 12 * months[0])
-                    prem_it_alt += cur_nominal * tranche['nominal'] * premiums[k] / 12 * months[0]
+                    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(self.tranches))  # accumulate over all events in this period
                 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
+                    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(self.tranches):
-                            ncf_tmp[tranche['RP']].append(((cur_nominal * tranche['nominal'] * (premiums[k] + rf)) / 12 * (nex_month - month)))
-                            prem_it_alt += cur_nominal * tranche['nominal'] * premiums[k] / 12 * (nex_month - month)
+                            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(self.tranches):
-                            ncf_tmp[tranche['RP']].append(((cur_nominal * tranche['nominal'] * (premiums[k] + rf)) / 12 * (12- month)))
-                            prem_it_alt += cur_nominal * tranche['nominal'] * premiums[k] / 12 * (12- month)
+                            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)
-                tmp_loss = np.sum(losses)
-                for _, tranche in self.tranches.iloc[::-1].iterrows():
-                    to_cover = tmp_loss - tranche['lower_bound']
-                    if to_cover < 0:
-                        to_cover = 0
-                    ncf[tranche['RP']].append(np.sum(ncf_tmp[tranche['RP']]) - to_cover)
-                    tmp_loss -= to_cover
                 premiums_tot.append(np.sum(premiums_tot_tmp))
+                for idx, tranche in enumerate(self.tranches):
+                    ncf[str(tranche)].append(np.sum(ncf_tmp[str(tranche)]) - losses_per_tranche[idx])
             if (i + 1) % self.term == 0:
-                cur_nominal = 1
+                cur_nominal_tranches = self.tranches.copy()
 
-        ncf['Total'] = ncf_tot
         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
 
-        ncf = pd.DataFrame(ncf)
-        prem_cty_df = pd.DataFrame(prem_cty_dic)
-        return ncf, prem_cty_df
+        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)
+    
+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

From 805bbe1d0dcf71d01ef6774a37d1b4dec79e4338 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 21 Nov 2025 15:54:15 +0100
Subject: [PATCH 052/125] add required principal calculation

---
 .../engine/cat_bonds/mlt_bond_simulation.py   | 85 +++++++++++++++++++
 1 file changed, 85 insertions(+)

diff --git a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
index ddabf9737..1ae138815 100644
--- a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
@@ -378,6 +378,91 @@ def init_return_simulation_tranches(self, premiums, rf=0.0):
         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 requ_nom(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.
+        Args:
+            countries (list): List of country codes to include in the simulation.
+            pay_dam_df_dic (dict): Dictionary mapping country codes to pandas DataFrames containing event loss data.
+                Each DataFrame must have a 'year' column and relevant loss information.
+            nominal_dic_cty (dict): Dictionary mapping country codes to their respective nominal values.
+        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'] == (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)
+
+        requ_nominal = np.max(total_losses)
+
+        return requ_nominal
+    
+    '''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
     
 def allocate_single_payout(payout, nominals):
     """

From d692beaa4583b64ea530efe826a292e7f04e001c Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 21 Nov 2025 15:55:07 +0100
Subject: [PATCH 053/125] save required principal to mlt_bond class

---
 climada_petals/engine/cat_bonds/mlt_bond_simulation.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
index 1ae138815..8cf859e04 100644
--- a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
@@ -410,9 +410,8 @@ def requ_nom(self):
 
             total_losses.append(tot_loss)
 
-        requ_nominal = np.max(total_losses)
+        self.requ_principal = np.max(total_losses)
 
-        return requ_nominal
     
     '''derives losses for one term of bond'''
     def init_equ_nom_sim(self, events_per_year, nominal_dic_cty):

From 05a88ee20489bd7fd4a60cef35b75415a50e230c Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 21 Nov 2025 15:57:04 +0100
Subject: [PATCH 054/125] rename functions

---
 climada_petals/engine/cat_bonds/mlt_bond_simulation.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
index 8cf859e04..f030666ec 100644
--- a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
@@ -381,7 +381,7 @@ def init_return_simulation_tranches(self, premiums, rf=0.0):
 
 
     '''Calculates required nominal for multi-country bonds -> derives maximal loss over simulation period'''
-    def requ_nom(self):
+    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,
@@ -406,7 +406,7 @@ def requ_nom(self):
                 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)
+            tot_loss = self._init_equ_nom_sim(events_per_year, self.principal_dic_cty)
 
             total_losses.append(tot_loss)
 
@@ -414,7 +414,7 @@ def requ_nom(self):
 
     
     '''derives losses for one term of bond'''
-    def init_equ_nom_sim(self, events_per_year, nominal_dic_cty):
+    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

From 61802b502bfda760252073f97bc236d92cb032c2 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 21 Nov 2025 15:57:54 +0100
Subject: [PATCH 055/125] make bond term function private

---
 climada_petals/engine/cat_bonds/mlt_bond_simulation.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
index f030666ec..7d5f1a382 100644
--- a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
@@ -34,7 +34,7 @@ def _prepare_data(self):
 
 
     '''Simulate one term of bond to derive losses'''
-    def init_bond_loss(self, events_per_year, principal):
+    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
@@ -179,7 +179,7 @@ def init_loss_simulation(self, principal, confidence_levels=[0.95, 0.99]):
                 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)
+            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)

From 2b3484b8fc84be753500e575ac6f8b16b9b651aa Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 21 Nov 2025 15:58:56 +0100
Subject: [PATCH 056/125] adapt changes in mlt class to test notebook

---
 climada_petals/engine/cat_bonds/test.ipynb | 1946 +-------------------
 1 file changed, 87 insertions(+), 1859 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/test.ipynb b/climada_petals/engine/cat_bonds/test.ipynb
index a9802f715..aaab6f54a 100644
--- a/climada_petals/engine/cat_bonds/test.ipynb
+++ b/climada_petals/engine/cat_bonds/test.ipynb
@@ -77,9 +77,9 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-17 15:06:39,687 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
-      "2025-11-17 15:06:39,747 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
-      "2025-11-17 15:06:39,805 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n"
+      "2025-11-21 14:52:05,791 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
+      "2025-11-21 14:52:05,854 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
+      "2025-11-21 14:52:05,916 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n"
      ]
     },
     {
@@ -93,27 +93,27 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-17 15:06:45,926 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
-      "2025-11-17 15:06:46,030 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 546 coastal centroids.\n",
-      "2025-11-17 15:06:46,361 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
-      "2025-11-17 15:06:46,740 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
-      "2025-11-17 15:06:47,095 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
-      "2025-11-17 15:06:47,478 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
-      "2025-11-17 15:06:47,785 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
-      "2025-11-17 15:06:48,184 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
-      "2025-11-17 15:06:48,570 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
-      "2025-11-17 15:06:48,893 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
-      "2025-11-17 15:06:49,079 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
-      "2025-11-17 15:06:50,191 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      "2025-11-21 14:52:10,784 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
+      "2025-11-21 14:52:10,866 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 546 coastal centroids.\n",
+      "2025-11-21 14:52:11,191 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
+      "2025-11-21 14:52:11,454 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
+      "2025-11-21 14:52:11,736 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
+      "2025-11-21 14:52:12,039 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
+      "2025-11-21 14:52:12,323 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
+      "2025-11-21 14:52:12,667 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
+      "2025-11-21 14:52:13,008 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
+      "2025-11-21 14:52:13,308 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
+      "2025-11-21 14:52:13,484 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
+      "2025-11-21 14:52:14,528 - climada.entity.exposures.litpop.litpop - INFO - \n",
       " LitPop: Init Exposure for country: KNA (659)...\n",
       "\n",
-      "2025-11-17 15:06:50,278 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-17 15:06:50,796 - climada.util.finance - INFO - GDP KNA 2020: 8.839e+08.\n",
-      "2025-11-17 15:06:50,814 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
-      "2025-11-17 15:06:50,814 - climada.entity.exposures.base - INFO - category_id not set.\n",
-      "2025-11-17 15:06:50,815 - climada.entity.exposures.base - INFO - cover not set.\n",
-      "2025-11-17 15:06:50,815 - climada.entity.exposures.base - INFO - deductible not set.\n",
-      "2025-11-17 15:06:50,816 - climada.entity.exposures.base - INFO - centr_ not set.\n"
+      "2025-11-21 14:52:14,610 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-21 14:52:15,449 - climada.util.finance - INFO - GDP KNA 2020: 8.839e+08.\n",
+      "2025-11-21 14:52:15,467 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+      "2025-11-21 14:52:15,468 - climada.entity.exposures.base - INFO - category_id not set.\n",
+      "2025-11-21 14:52:15,469 - climada.entity.exposures.base - INFO - cover not set.\n",
+      "2025-11-21 14:52:15,470 - climada.entity.exposures.base - INFO - deductible not set.\n",
+      "2025-11-21 14:52:15,471 - climada.entity.exposures.base - INFO - centr_ not set.\n"
      ]
     }
    ],
@@ -158,29 +158,29 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-17 15:06:52,354 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
-      "2025-11-17 15:06:52,407 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
-      "2025-11-17 15:06:52,442 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
-      "2025-11-17 15:06:55,170 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
-      "2025-11-17 15:06:55,199 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 7938 coastal centroids.\n",
-      "2025-11-17 15:07:01,666 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
-      "2025-11-17 15:07:07,538 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
-      "2025-11-17 15:07:12,949 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
-      "2025-11-17 15:07:17,753 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
-      "2025-11-17 15:07:22,188 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
-      "2025-11-17 15:07:26,864 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
-      "2025-11-17 15:07:30,786 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
-      "2025-11-17 15:07:35,924 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
-      "2025-11-17 15:07:37,740 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
-      "2025-11-17 15:07:39,998 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      "2025-11-21 14:52:17,068 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
+      "2025-11-21 14:52:17,125 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
+      "2025-11-21 14:52:17,160 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
+      "2025-11-21 14:52:19,866 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
+      "2025-11-21 14:52:19,895 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 7938 coastal centroids.\n",
+      "2025-11-21 14:52:24,550 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
+      "2025-11-21 14:52:28,951 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
+      "2025-11-21 14:52:33,751 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
+      "2025-11-21 14:52:38,839 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
+      "2025-11-21 14:52:43,392 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
+      "2025-11-21 14:52:48,070 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
+      "2025-11-21 14:52:51,716 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
+      "2025-11-21 14:52:56,840 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
+      "2025-11-21 14:52:58,630 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
+      "2025-11-21 14:53:00,854 - climada.entity.exposures.litpop.litpop - INFO - \n",
       " LitPop: Init Exposure for country: JAM (388)...\n",
       "\n",
-      "2025-11-17 15:07:40,861 - climada.util.finance - INFO - GDP JAM 2020: 1.381e+10.\n",
-      "2025-11-17 15:07:40,897 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
-      "2025-11-17 15:07:40,898 - climada.entity.exposures.base - INFO - category_id not set.\n",
-      "2025-11-17 15:07:40,898 - climada.entity.exposures.base - INFO - cover not set.\n",
-      "2025-11-17 15:07:40,899 - climada.entity.exposures.base - INFO - deductible not set.\n",
-      "2025-11-17 15:07:40,900 - climada.entity.exposures.base - INFO - centr_ not set.\n"
+      "2025-11-21 14:53:01,398 - climada.util.finance - INFO - GDP JAM 2020: 1.381e+10.\n",
+      "2025-11-21 14:53:01,431 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+      "2025-11-21 14:53:01,431 - climada.entity.exposures.base - INFO - category_id not set.\n",
+      "2025-11-21 14:53:01,432 - climada.entity.exposures.base - INFO - cover not set.\n",
+      "2025-11-21 14:53:01,432 - climada.entity.exposures.base - INFO - deductible not set.\n",
+      "2025-11-21 14:53:01,433 - climada.entity.exposures.base - INFO - centr_ not set.\n"
      ]
     }
    ],
@@ -232,7 +232,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-17 15:07:43,064 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+      "2025-11-21 14:53:03,542 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
      ]
     },
     {
@@ -249,7 +249,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-17 15:08:02,389 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+      "2025-11-21 14:53:22,037 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
      ]
     },
     {
@@ -288,12 +288,12 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-17 15:08:17,502 - climada.entity.exposures.base - INFO - Matching 328 exposures with 546 centroids.\n",
-      "2025-11-17 15:08:17,505 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
-      "2025-11-17 15:08:17,512 - climada.engine.impact_calc - INFO - Calculating impact for 984 assets (>0) and 51 events.\n",
-      "2025-11-17 15:08:18,641 - climada.entity.exposures.base - INFO - Matching 13552 exposures with 7938 centroids.\n",
-      "2025-11-17 15:08:18,648 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
-      "2025-11-17 15:08:18,864 - climada.engine.impact_calc - INFO - Calculating impact for 40503 assets (>0) and 51 events.\n"
+      "2025-11-21 14:53:37,039 - climada.entity.exposures.base - INFO - Matching 328 exposures with 546 centroids.\n",
+      "2025-11-21 14:53:37,041 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
+      "2025-11-21 14:53:37,046 - climada.engine.impact_calc - INFO - Calculating impact for 984 assets (>0) and 51 events.\n",
+      "2025-11-21 14:53:37,952 - climada.entity.exposures.base - INFO - Matching 13552 exposures with 7938 centroids.\n",
+      "2025-11-21 14:53:37,961 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
+      "2025-11-21 14:53:37,996 - climada.engine.impact_calc - INFO - Calculating impact for 40503 assets (>0) and 51 events.\n"
      ]
     }
    ],
@@ -314,8 +314,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
-   "id": "aacf777b",
+   "execution_count": 7,
+   "id": "4ead6e69",
    "metadata": {},
    "outputs": [
     {
@@ -347,11 +347,12 @@
    "source": [
     "### ST. KITTS AND NEVIS BOND SIMULATION ###\n",
     "st_kitts_bond_sim = sng_bond_simulation(subarea_calc=st_kitts_sub_calc, term=term, number_of_terms=num_of_terms) \n",
-    "st_kitts_bond_sim.init_loss_simulation_pythonic(confidence_levels=[0.95, 0.99])\n",
+    "st_kitts_bond_sim.init_loss_simulation()\n",
     "st_kitts_premiums = premium_calculations(bond_simulation_class=st_kitts_bond_sim)\n",
     "st_kitts_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)\n",
     "st_kitts_premiums.calc_ibrd_premium()\n",
     "st_kitts_premiums.calc_benchmark_premium(target_sharpe = target_sharpe)\n",
+    "st_kitts_bond_sim.init_return_simulation(premium=st_kitts_premiums.chatoro_prem_rate)\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",
@@ -360,118 +361,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
-   "id": "4ead6e69",
+   "execution_count": 8,
+   "id": "6cfb9d55",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'annual_premiums': array([8.06426380e-02, 2.48154941e-03, 4.73324946e-18, 7.10555351e-03,\n",
-       "        0.00000000e+00, 0.00000000e+00, 7.10555351e-03, 0.00000000e+00,\n",
-       "        0.00000000e+00, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02, 8.52666421e-02,\n",
-       "        8.52666421e-02, 8.52666421e-02, 8.52666421e-02]),\n",
-       " 'annual_returns': array([-5.70116531e-01, -3.46759282e-01,  4.73324946e-18, -9.92894446e-01,\n",
-       "         0.00000000e+00,  0.00000000e+00, -9.92894446e-01,  0.00000000e+00,\n",
-       "         0.00000000e+00,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02,  8.52666421e-02,\n",
-       "         8.52666421e-02,  8.52666421e-02,  8.52666421e-02]),\n",
-       " 'total_returns': 4822030543.007947,\n",
-       " 'total_premiums': 6147913876.34128,\n",
-       " 'sharpe_ratio': 0.49006333355542275}"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "{'EL_ann': 0.017543859649122806,\n",
-       " 'AP_ann': 0.023391812865497075,\n",
-       " 'Tot_payout': 1325883333.3333325,\n",
-       " 'Tot_damages': 11037139919.100546,\n",
-       " 'VaR_95_ann': 0.0,\n",
-       " 'ES_95_ann': 0.75,\n",
-       " 'VaR_99_ann': 0.7555314181864904,\n",
-       " 'ES_99_ann': 1.0}"
+       "{'EL_ann': 0.02680332628076214,\n",
+       " 'AP_ann': 0.08771929824561403,\n",
+       " 'Tot_payout': 31653711605.811665,\n",
+       " 'Tot_damages': 50919862874.32074,\n",
+       " 'VaR_95_ann': 0.12926162262991353,\n",
+       " 'ES_95_ann': 0.4462644805505158,\n",
+       " 'VaR_99_ann': 0.8387774672602343,\n",
+       " 'ES_99_ann': 0.8543436945180888}"
       ]
      },
      "metadata": {},
@@ -481,1693 +385,9 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Benchmark Sharpe Ratio premium rate: 8.7\n",
-      "Chatoro premium rate: 8.5\n",
-      "IBRD premium rate: 5.0\n"
-     ]
-    }
-   ],
-   "source": [
-    "### ST. KITTS AND NEVIS BOND SIMULATION ###\n",
-    "st_kitts_bond_sim = sng_bond_simulation(subarea_calc=st_kitts_sub_calc, term=term, number_of_terms=num_of_terms) \n",
-    "st_kitts_bond_sim.init_loss_simulation()\n",
-    "st_kitts_premiums = premium_calculations(bond_simulation_class=st_kitts_bond_sim)\n",
-    "st_kitts_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)\n",
-    "st_kitts_premiums.calc_ibrd_premium()\n",
-    "st_kitts_premiums.calc_benchmark_premium(target_sharpe = target_sharpe)\n",
-    "st_kitts_bond_sim.init_return_simulation(premium=st_kitts_premiums.chatoro_prem_rate)\n",
-    "display(st_kitts_bond_sim.return_metrics)\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": 55,
-   "id": "053c9ff1",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "12\n"
-     ]
-    }
-   ],
-   "source": [
-    "import numpy as np\n",
-    "test = np.array(12)\n",
-    "test_a = np.atleast_1d(test)\n",
-    "type(test.tolist())\n",
-    "print(test_a[0])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 67,
-   "id": "6cfb9d55",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[12] [1.11494765e+09] [1.29496354e+09]\n",
-      "1\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "                    losses  months\n",
-      "0  [[0.16144129701791735]]  [[12]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[ 3  6 10 11] [0.00000000e+00 0.00000000e+00 0.00000000e+00 8.42135863e+08] [0.00000000e+00 0.00000000e+00 0.00000000e+00 9.49343016e+08]\n",
-      "4\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "                                   losses            months\n",
-      "0                 [[0.16144129701791735]]            [[12]]\n",
-      "1  [[0.0, 0.0, 0.0, 0.12193891449668587]]  [[3, 6, 10, 11]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[ 1  2  4  5  8 12] [0. 0. 0. 0. 0. 0.] [0. 0. 0. 0. 0. 0.]\n",
-      "6\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "                                   losses                 months\n",
-      "0                 [[0.16144129701791735]]                 [[12]]\n",
-      "1  [[0.0, 0.0, 0.0, 0.12193891449668587]]       [[3, 6, 10, 11]]\n",
-      "2        [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]  [[1, 2, 4, 5, 8, 12]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[ 3  6 10 11] [0.00000000e+00 0.00000000e+00 0.00000000e+00 8.42135863e+08] [0.00000000e+00 0.00000000e+00 0.00000000e+00 9.49343016e+08]\n",
-      "4\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "                                   losses            months\n",
-      "0  [[0.0, 0.0, 0.0, 0.12193891449668587]]  [[3, 6, 10, 11]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[ 1  2  4  5  8 12] [0. 0. 0. 0. 0. 0.] [0. 0. 0. 0. 0. 0.]\n",
-      "6\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "                                   losses                 months\n",
-      "0  [[0.0, 0.0, 0.0, 0.12193891449668587]]       [[3, 6, 10, 11]]\n",
-      "1        [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]  [[1, 2, 4, 5, 8, 12]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[ 2  3  4  5  7  9 11 12] [0. 0. 0. 0. 0. 0. 0. 0.] [0. 0. 0. 0. 0. 0. 0. 0.]\n",
-      "8\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "                                       losses                        months\n",
-      "0      [[0.0, 0.0, 0.0, 0.12193891449668587]]              [[3, 6, 10, 11]]\n",
-      "1            [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]         [[1, 2, 4, 5, 8, 12]]\n",
-      "2  [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]  [[2, 3, 4, 5, 7, 9, 11, 12]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[ 1  2  4  5  8 12] [0. 0. 0. 0. 0. 0.] [0. 0. 0. 0. 0. 0.]\n",
-      "6\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "                             losses                 months\n",
-      "0  [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]  [[1, 2, 4, 5, 8, 12]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[ 2  3  4  5  7  9 11 12] [0. 0. 0. 0. 0. 0. 0. 0.] [0. 0. 0. 0. 0. 0. 0. 0.]\n",
-      "8\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "                                       losses                        months\n",
-      "0            [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]         [[1, 2, 4, 5, 8, 12]]\n",
-      "1  [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]  [[2, 3, 4, 5, 7, 9, 11, 12]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[ 2  4  5  7  8 10] [0. 0. 0. 0. 0. 0.] [7.59322289e+08 0.00000000e+00 8.52570984e+08 9.55196924e+08\n",
-      " 0.00000000e+00 0.00000000e+00]\n",
-      "6\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "                                       losses                        months\n",
-      "0            [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]         [[1, 2, 4, 5, 8, 12]]\n",
-      "1  [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]  [[2, 3, 4, 5, 7, 9, 11, 12]]\n",
-      "2            [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]         [[2, 4, 5, 7, 8, 10]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[ 2  3  4  5  7  9 11 12] [0. 0. 0. 0. 0. 0. 0. 0.] [0. 0. 0. 0. 0. 0. 0. 0.]\n",
-      "8\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "                                       losses                        months\n",
-      "0  [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]  [[2, 3, 4, 5, 7, 9, 11, 12]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[ 2  4  5  7  8 10] [0. 0. 0. 0. 0. 0.] [7.59322289e+08 0.00000000e+00 8.52570984e+08 9.55196924e+08\n",
-      " 0.00000000e+00 0.00000000e+00]\n",
-      "6\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "                                       losses                        months\n",
-      "0  [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]  [[2, 3, 4, 5, 7, 9, 11, 12]]\n",
-      "1            [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]         [[2, 4, 5, 7, 8, 10]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[ 1  5  6  8 10] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
-      " 7.22939086e+08] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
-      " 6.92971219e+08]\n",
-      "5\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "                                        losses                        months\n",
-      "0   [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]  [[2, 3, 4, 5, 7, 9, 11, 12]]\n",
-      "1             [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]         [[2, 4, 5, 7, 8, 10]]\n",
-      "2  [[0.0, 0.0, 0.0, 0.0, 0.10467955511451421]]            [[1, 5, 6, 8, 10]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[ 2  4  5  7  8 10] [0. 0. 0. 0. 0. 0.] [7.59322289e+08 0.00000000e+00 8.52570984e+08 9.55196924e+08\n",
-      " 0.00000000e+00 0.00000000e+00]\n",
-      "6\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "                             losses                 months\n",
-      "0  [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]  [[2, 4, 5, 7, 8, 10]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[ 1  5  6  8 10] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
-      " 7.22939086e+08] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
-      " 6.92971219e+08]\n",
-      "5\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "                                        losses                 months\n",
-      "0             [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]  [[2, 4, 5, 7, 8, 10]]\n",
-      "1  [[0.0, 0.0, 0.0, 0.0, 0.10467955511451421]]     [[1, 5, 6, 8, 10]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[ 1  2  3  4  6  8 10 11 12] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
-      " 0.00000000e+00 0.00000000e+00 0.00000000e+00 9.43280196e+08\n",
-      " 0.00000000e+00] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
-      " 0.00000000e+00 1.51272779e+09 0.00000000e+00 9.06019669e+08\n",
-      " 7.26858410e+08]\n",
-      "9\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "                                              losses  \\\n",
-      "0                   [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]   \n",
-      "1        [[0.0, 0.0, 0.0, 0.0, 0.10467955511451421]]   \n",
-      "2  [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.1365843...   \n",
-      "\n",
-      "                             months  \n",
-      "0             [[2, 4, 5, 7, 8, 10]]  \n",
-      "1                [[1, 5, 6, 8, 10]]  \n",
-      "2  [[1, 2, 3, 4, 6, 8, 10, 11, 12]]  \n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[ 1  5  6  8 10] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
-      " 7.22939086e+08] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
-      " 6.92971219e+08]\n",
-      "5\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "                                        losses              months\n",
-      "0  [[0.0, 0.0, 0.0, 0.0, 0.10467955511451421]]  [[1, 5, 6, 8, 10]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[ 1  2  3  4  6  8 10 11 12] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
-      " 0.00000000e+00 0.00000000e+00 0.00000000e+00 9.43280196e+08\n",
-      " 0.00000000e+00] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
-      " 0.00000000e+00 1.51272779e+09 0.00000000e+00 9.06019669e+08\n",
-      " 7.26858410e+08]\n",
-      "9\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "                                              losses  \\\n",
-      "0        [[0.0, 0.0, 0.0, 0.0, 0.10467955511451421]]   \n",
-      "1  [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.1365843...   \n",
-      "\n",
-      "                             months  \n",
-      "0                [[1, 5, 6, 8, 10]]  \n",
-      "1  [[1, 2, 3, 4, 6, 8, 10, 11, 12]]  \n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[ 2  4  6  8  9 11 12] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
-      " 4.04620234e+09 1.85407541e+09 0.00000000e+00] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
-      " 1.69449885e+09 1.78865783e+09 0.00000000e+00]\n",
-      "5\n",
-      "exhaused [0. 0. 0. 0. 0. 0. 0.]\n",
-      "payouts before exhausion [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
-      " 4.04620234e+09 0.00000000e+00 0.00000000e+00]\n",
-      "payouts at exhausion [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
-      " 4.04620234e+09 1.19378929e+09 0.00000000e+00]\n",
-      "assign to year 2\n",
-      "                                              losses  \\\n",
-      "0        [[0.0, 0.0, 0.0, 0.0, 0.10467955511451421]]   \n",
-      "1  [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.1365843...   \n",
-      "2  [[0.0, 0.0, 0.0, 0.0, 0.5858787676747096, 0.17...   \n",
-      "\n",
-      "                             months  \n",
-      "0                [[1, 5, 6, 8, 10]]  \n",
-      "1  [[1, 2, 3, 4, 6, 8, 10, 11, 12]]  \n",
-      "2         [[2, 4, 6, 8, 9, 11, 12]]  \n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[ 1  2  3  4  6  8 10 11 12] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
-      " 0.00000000e+00 0.00000000e+00 0.00000000e+00 9.43280196e+08\n",
-      " 0.00000000e+00] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
-      " 0.00000000e+00 1.51272779e+09 0.00000000e+00 9.06019669e+08\n",
-      " 7.26858410e+08]\n",
-      "9\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "                                              losses  \\\n",
-      "0  [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.1365843...   \n",
-      "\n",
-      "                             months  \n",
-      "0  [[1, 2, 3, 4, 6, 8, 10, 11, 12]]  \n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[ 2  4  6  8  9 11 12] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
-      " 4.04620234e+09 1.85407541e+09 0.00000000e+00] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
-      " 1.69449885e+09 1.78865783e+09 0.00000000e+00]\n",
-      "7\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "                                              losses  \\\n",
-      "0  [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.1365843...   \n",
-      "1  [[0.0, 0.0, 0.0, 0.0, 0.5858787676747096, 0.26...   \n",
-      "\n",
-      "                             months  \n",
-      "0  [[1, 2, 3, 4, 6, 8, 10, 11, 12]]  \n",
-      "1         [[2, 4, 6, 8, 9, 11, 12]]  \n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[1 2] [0.00000000e+00 5.74670111e+09] [0.00000000e+00 6.01991379e+09]\n",
-      "1\n",
-      "exhaused [0. 0.]\n",
-      "payouts before exhausion [0. 0.]\n",
-      "payouts at exhausion [       0.         62652970.84939575]\n",
-      "assign to year 2\n",
-      "                                              losses  \\\n",
-      "0  [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.1365843...   \n",
-      "1  [[0.0, 0.0, 0.0, 0.0, 0.5858787676747096, 0.26...   \n",
-      "2                      [[0.0, 0.009071974718769974]]   \n",
-      "\n",
-      "                             months  \n",
-      "0  [[1, 2, 3, 4, 6, 8, 10, 11, 12]]  \n",
-      "1         [[2, 4, 6, 8, 9, 11, 12]]  \n",
-      "2                          [[1, 2]]  \n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[ 2  4  6  8  9 11 12] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
-      " 4.04620234e+09 1.85407541e+09 0.00000000e+00] [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
-      " 1.69449885e+09 1.78865783e+09 0.00000000e+00]\n",
-      "7\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "                                              losses  \\\n",
-      "0  [[0.0, 0.0, 0.0, 0.0, 0.5858787676747096, 0.26...   \n",
-      "\n",
-      "                      months  \n",
-      "0  [[2, 4, 6, 8, 9, 11, 12]]  \n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[1 2] [0.00000000e+00 5.74670111e+09] [0.00000000e+00 6.01991379e+09]\n",
-      "1\n",
-      "exhaused [0. 0.]\n",
-      "payouts before exhausion [0. 0.]\n",
-      "payouts at exhausion [0.00000000e+00 1.00593317e+09]\n",
-      "assign to year 1\n",
-      "                                              losses  \\\n",
-      "0  [[0.0, 0.0, 0.0, 0.0, 0.5858787676747096, 0.26...   \n",
-      "1                        [[0.0, 0.1456563054819112]]   \n",
-      "\n",
-      "                      months  \n",
-      "0  [[2, 4, 6, 8, 9, 11, 12]]  \n",
-      "1                   [[1, 2]]  \n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "                                              losses  \\\n",
-      "0  [[0.0, 0.0, 0.0, 0.0, 0.5858787676747096, 0.26...   \n",
-      "1                        [[0.0, 0.1456563054819112]]   \n",
-      "2                                               [[]]   \n",
-      "\n",
-      "                      months  \n",
-      "0  [[2, 4, 6, 8, 9, 11, 12]]  \n",
-      "1                   [[1, 2]]  \n",
-      "2                       [[]]  \n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[1 2] [0.00000000e+00 5.74670111e+09] [0.00000000e+00 6.01991379e+09]\n",
-      "2\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "                        losses    months\n",
-      "0  [[0.0, 0.8321062270068676]]  [[1, 2]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "                        losses    months\n",
-      "0  [[0.0, 0.8321062270068676]]  [[1, 2]]\n",
-      "1                         [[]]      [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "                        losses    months\n",
-      "0  [[0.0, 0.8321062270068676]]  [[1, 2]]\n",
-      "1                         [[]]      [[]]\n",
-      "2                         [[]]      [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 0\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 1\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "[] [] []\n",
-      "0\n",
-      "not exhaused\n",
-      "assign to year 2\n",
-      "  losses months\n",
-      "0   [[]]   [[]]\n",
-      "1   [[]]   [[]]\n",
-      "2   [[]]   [[]]\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "<class 'pandas.core.series.Series'>\n",
-      "test\n"
-     ]
-    },
-    {
-     "ename": "ValueError",
-     "evalue": "non-broadcastable output operand with shape (1,) doesn't match the broadcast shape (4,)",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
-      "\u001b[31mValueError\u001b[39m                                Traceback (most recent call last)",
-      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[67]\u001b[39m\u001b[32m, line 7\u001b[39m\n\u001b[32m      5\u001b[39m jamaica_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)\n\u001b[32m      6\u001b[39m jamaica_premiums.calc_ibrd_premium()\n\u001b[32m----> \u001b[39m\u001b[32m7\u001b[39m \u001b[43mjamaica_premiums\u001b[49m\u001b[43m.\u001b[49m\u001b[43mcalc_benchmark_premium\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtarget_sharpe\u001b[49m\u001b[43m \u001b[49m\u001b[43m=\u001b[49m\u001b[43m \u001b[49m\u001b[43mtarget_sharpe\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m      8\u001b[39m jamaica_bond_sim.init_return_simulation(premium=jamaica_premiums.chatoro_prem_rate)\n\u001b[32m      9\u001b[39m display(jamaica_bond_sim.return_metrics)\n",
-      "\u001b[36mFile \u001b[39m\u001b[32m~/climada_petals_repo/climada_petals/climada_petals/engine/cat_bonds/premium_class.py:161\u001b[39m, in \u001b[36mpremium_calculations.calc_benchmark_premium\u001b[39m\u001b[34m(self, target_sharpe)\u001b[39m\n\u001b[32m    145\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mcalc_benchmark_premium\u001b[39m(\u001b[38;5;28mself\u001b[39m, target_sharpe):        \n\u001b[32m    146\u001b[39m \u001b[38;5;250m    \u001b[39m\u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m    147\u001b[39m \u001b[33;03m    Calculates the initial premium required to achieve a target Sharpe ratio for a given set of annual losses.\u001b[39;00m\n\u001b[32m    148\u001b[39m \u001b[33;03m    This function uses numerical optimization to find the premium value that results in the desired Sharpe ratio,\u001b[39;00m\n\u001b[32m   (...)\u001b[39m\u001b[32m    158\u001b[39m \u001b[33;03m        float: The optimal premium value that achieves the target Sharpe ratio.\u001b[39;00m\n\u001b[32m    159\u001b[39m \u001b[33;03m    \"\"\"\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m161\u001b[39m     result = \u001b[43mminimize\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43;01mlambda\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mp\u001b[49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mfind_sharpe\u001b[49m\u001b[43m(\u001b[49m\u001b[43mp\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mbond_simulation_class\u001b[49m\u001b[43m.\u001b[49m\u001b[43mdf_loss_month\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtarget_sharpe\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[32m    162\u001b[39m \u001b[43m                      \u001b[49m\u001b[43mx0\u001b[49m\u001b[43m=\u001b[49m\u001b[43m[\u001b[49m\u001b[32;43m0.05\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    163\u001b[39m     \u001b[38;5;28mself\u001b[39m.benchmark_prem_rate = result.x[\u001b[32m0\u001b[39m]\n",
-      "\u001b[36mFile \u001b[39m\u001b[32m~/miniforge3/envs/climada_env/lib/python3.11/site-packages/scipy/optimize/_minimize.py:726\u001b[39m, in \u001b[36mminimize\u001b[39m\u001b[34m(fun, x0, args, method, jac, hess, hessp, bounds, constraints, tol, callback, options)\u001b[39m\n\u001b[32m    724\u001b[39m     res = _minimize_cg(fun, x0, args, jac, callback, **options)\n\u001b[32m    725\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m meth == \u001b[33m'\u001b[39m\u001b[33mbfgs\u001b[39m\u001b[33m'\u001b[39m:\n\u001b[32m--> \u001b[39m\u001b[32m726\u001b[39m     res = \u001b[43m_minimize_bfgs\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfun\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx0\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mjac\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcallback\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43moptions\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    727\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m meth == \u001b[33m'\u001b[39m\u001b[33mnewton-cg\u001b[39m\u001b[33m'\u001b[39m:\n\u001b[32m    728\u001b[39m     res = _minimize_newtoncg(fun, x0, args, jac, hess, hessp, callback,\n\u001b[32m    729\u001b[39m                              **options)\n",
-      "\u001b[36mFile \u001b[39m\u001b[32m~/miniforge3/envs/climada_env/lib/python3.11/site-packages/scipy/optimize/_optimize.py:1371\u001b[39m, in \u001b[36m_minimize_bfgs\u001b[39m\u001b[34m(fun, x0, args, jac, callback, gtol, norm, eps, maxiter, disp, return_all, finite_diff_rel_step, xrtol, c1, c2, hess_inv0, **unknown_options)\u001b[39m\n\u001b[32m   1368\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m maxiter \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m   1369\u001b[39m     maxiter = \u001b[38;5;28mlen\u001b[39m(x0) * \u001b[32m200\u001b[39m\n\u001b[32m-> \u001b[39m\u001b[32m1371\u001b[39m sf = \u001b[43m_prepare_scalar_function\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfun\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx0\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mjac\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m=\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mepsilon\u001b[49m\u001b[43m=\u001b[49m\u001b[43meps\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m   1372\u001b[39m \u001b[43m                              \u001b[49m\u001b[43mfinite_diff_rel_step\u001b[49m\u001b[43m=\u001b[49m\u001b[43mfinite_diff_rel_step\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m   1374\u001b[39m f = sf.fun\n\u001b[32m   1375\u001b[39m myfprime = sf.grad\n",
-      "\u001b[36mFile \u001b[39m\u001b[32m~/miniforge3/envs/climada_env/lib/python3.11/site-packages/scipy/optimize/_optimize.py:288\u001b[39m, in \u001b[36m_prepare_scalar_function\u001b[39m\u001b[34m(fun, x0, jac, args, bounds, epsilon, finite_diff_rel_step, hess)\u001b[39m\n\u001b[32m    284\u001b[39m     bounds = (-np.inf, np.inf)\n\u001b[32m    286\u001b[39m \u001b[38;5;66;03m# ScalarFunction caches. Reuse of fun(x) during grad\u001b[39;00m\n\u001b[32m    287\u001b[39m \u001b[38;5;66;03m# calculation reduces overall function evaluations.\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m288\u001b[39m sf = \u001b[43mScalarFunction\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfun\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx0\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgrad\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mhess\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    289\u001b[39m \u001b[43m                    \u001b[49m\u001b[43mfinite_diff_rel_step\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbounds\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mepsilon\u001b[49m\u001b[43m=\u001b[49m\u001b[43mepsilon\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    291\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m sf\n",
-      "\u001b[36mFile \u001b[39m\u001b[32m~/miniforge3/envs/climada_env/lib/python3.11/site-packages/scipy/optimize/_differentiable_functions.py:222\u001b[39m, in \u001b[36mScalarFunction.__init__\u001b[39m\u001b[34m(self, fun, x0, args, grad, hess, finite_diff_rel_step, finite_diff_bounds, epsilon)\u001b[39m\n\u001b[32m    219\u001b[39m     finite_diff_options[\u001b[33m\"\u001b[39m\u001b[33mas_linear_operator\u001b[39m\u001b[33m\"\u001b[39m] = \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[32m    221\u001b[39m \u001b[38;5;66;03m# Initial function evaluation\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m222\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_update_fun\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    224\u001b[39m \u001b[38;5;66;03m# Initial gradient evaluation\u001b[39;00m\n\u001b[32m    225\u001b[39m \u001b[38;5;28mself\u001b[39m._wrapped_grad, \u001b[38;5;28mself\u001b[39m._ngev = _wrapper_grad(\n\u001b[32m    226\u001b[39m     grad,\n\u001b[32m    227\u001b[39m     fun=\u001b[38;5;28mself\u001b[39m._wrapped_fun,\n\u001b[32m    228\u001b[39m     args=args,\n\u001b[32m    229\u001b[39m     finite_diff_options=finite_diff_options\n\u001b[32m    230\u001b[39m )\n",
-      "\u001b[36mFile \u001b[39m\u001b[32m~/miniforge3/envs/climada_env/lib/python3.11/site-packages/scipy/optimize/_differentiable_functions.py:294\u001b[39m, in \u001b[36mScalarFunction._update_fun\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m    292\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m_update_fun\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[32m    293\u001b[39m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m.f_updated:\n\u001b[32m--> \u001b[39m\u001b[32m294\u001b[39m         fx = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_wrapped_fun\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    295\u001b[39m         \u001b[38;5;28;01mif\u001b[39;00m fx < \u001b[38;5;28mself\u001b[39m._lowest_f:\n\u001b[32m    296\u001b[39m             \u001b[38;5;28mself\u001b[39m._lowest_x = \u001b[38;5;28mself\u001b[39m.x\n",
-      "\u001b[36mFile \u001b[39m\u001b[32m~/miniforge3/envs/climada_env/lib/python3.11/site-packages/scipy/optimize/_differentiable_functions.py:20\u001b[39m, in \u001b[36m_wrapper_fun.<locals>.wrapped\u001b[39m\u001b[34m(x)\u001b[39m\n\u001b[32m     16\u001b[39m ncalls[\u001b[32m0\u001b[39m] += \u001b[32m1\u001b[39m\n\u001b[32m     17\u001b[39m \u001b[38;5;66;03m# Send a copy because the user may overwrite it.\u001b[39;00m\n\u001b[32m     18\u001b[39m \u001b[38;5;66;03m# Overwriting results in undefined behaviour because\u001b[39;00m\n\u001b[32m     19\u001b[39m \u001b[38;5;66;03m# fun(self.x) will change self.x, with the two no longer linked.\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m20\u001b[39m fx = \u001b[43mfun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnp\u001b[49m\u001b[43m.\u001b[49m\u001b[43mcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m     21\u001b[39m \u001b[38;5;66;03m# Make sure the function returns a true scalar\u001b[39;00m\n\u001b[32m     22\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m np.isscalar(fx):\n",
-      "\u001b[36mFile \u001b[39m\u001b[32m~/climada_petals_repo/climada_petals/climada_petals/engine/cat_bonds/premium_class.py:161\u001b[39m, in \u001b[36mpremium_calculations.calc_benchmark_premium.<locals>.<lambda>\u001b[39m\u001b[34m(p)\u001b[39m\n\u001b[32m    145\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mcalc_benchmark_premium\u001b[39m(\u001b[38;5;28mself\u001b[39m, target_sharpe):        \n\u001b[32m    146\u001b[39m \u001b[38;5;250m    \u001b[39m\u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m    147\u001b[39m \u001b[33;03m    Calculates the initial premium required to achieve a target Sharpe ratio for a given set of annual losses.\u001b[39;00m\n\u001b[32m    148\u001b[39m \u001b[33;03m    This function uses numerical optimization to find the premium value that results in the desired Sharpe ratio,\u001b[39;00m\n\u001b[32m   (...)\u001b[39m\u001b[32m    158\u001b[39m \u001b[33;03m        float: The optimal premium value that achieves the target Sharpe ratio.\u001b[39;00m\n\u001b[32m    159\u001b[39m \u001b[33;03m    \"\"\"\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m161\u001b[39m     result = minimize(\u001b[38;5;28;01mlambda\u001b[39;00m p: \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mfind_sharpe\u001b[49m\u001b[43m(\u001b[49m\u001b[43mp\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mbond_simulation_class\u001b[49m\u001b[43m.\u001b[49m\u001b[43mdf_loss_month\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtarget_sharpe\u001b[49m\u001b[43m)\u001b[49m, \n\u001b[32m    162\u001b[39m                       x0=[\u001b[32m0.05\u001b[39m])\n\u001b[32m    163\u001b[39m     \u001b[38;5;28mself\u001b[39m.benchmark_prem_rate = result.x[\u001b[32m0\u001b[39m]\n",
-      "\u001b[36mFile \u001b[39m\u001b[32m<string>:31\u001b[39m, in \u001b[36mfind_sharpe\u001b[39m\u001b[34m(self, premium, monthly_losses, target_sharpe)\u001b[39m\n",
-      "\u001b[31mValueError\u001b[39m: non-broadcastable output operand with shape (1,) doesn't match the broadcast shape (4,)"
+      "Benchmark Sharpe Ratio premium rate: 9.8\n",
+      "Chatoro premium rate: 9.8\n",
+      "IBRD premium rate: 6.0\n"
      ]
     }
    ],
@@ -2180,7 +400,6 @@
     "jamaica_premiums.calc_ibrd_premium()\n",
     "jamaica_premiums.calc_benchmark_premium(target_sharpe = target_sharpe)\n",
     "jamaica_bond_sim.init_return_simulation(premium=jamaica_premiums.chatoro_prem_rate)\n",
-    "display(jamaica_bond_sim.return_metrics)\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",
@@ -2189,27 +408,36 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "id": "67403f5f",
    "metadata": {},
    "outputs": [
     {
-     "ename": "NameError",
-     "evalue": "name 'countries' is not defined",
+     "ename": "AttributeError",
+     "evalue": "'mlt_bond_simulation' object has no attribute 'init_required_principal'",
      "output_type": "error",
      "traceback": [
       "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
-      "\u001b[31mNameError\u001b[39m                                 Traceback (most recent call last)",
-      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[14]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m      1\u001b[39m mlt_cat_bond = mlt_bond_simulation(subarea_calc_list=[st_kitts_sub_calc, jamaica_sub_calc], countries_list=countries, term=term,number_of_terms=num_of_terms, tranches=[\u001b[32m50\u001b[39m,\u001b[32m100\u001b[39m])\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m \u001b[43mmlt_cat_bond\u001b[49m\u001b[43m.\u001b[49m\u001b[43minit_loss_simulation\u001b[49m\u001b[43m(\u001b[49m\u001b[43mprincipal\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m6000000000\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mconfidence_levels\u001b[49m\u001b[43m=\u001b[49m\u001b[43m[\u001b[49m\u001b[32;43m0.95\u001b[39;49m\u001b[43m,\u001b[49m\u001b[32;43m0.99\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n",
-      "\u001b[36mFile \u001b[39m\u001b[32m<string>:49\u001b[39m, in \u001b[36minit_loss_simulation\u001b[39m\u001b[34m(self, principal, confidence_levels)\u001b[39m\n",
-      "\u001b[36mFile \u001b[39m\u001b[32m~/climada_petals_repo/climada_petals/climada_petals/engine/cat_bonds/mlt_bond_simulation.py:97\u001b[39m, in \u001b[36mmlt_bond_simulation.init_bond_loss\u001b[39m\u001b[34m(self, events_per_year, principal)\u001b[39m\n\u001b[32m     95\u001b[39m sum_payouts = np.zeros(\u001b[38;5;28mlen\u001b[39m(events))  \n\u001b[32m     96\u001b[39m sum_damages = np.zeros(\u001b[38;5;28mlen\u001b[39m(events)) \n\u001b[32m---> \u001b[39m\u001b[32m97\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m payout, country, damage \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(pay, \u001b[43mcountries\u001b[49m, damages):\n\u001b[32m     99\u001b[39m     \u001b[38;5;28;01mif\u001b[39;00m payout == \u001b[32m0\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m cur_nominal == \u001b[32m0\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m cur_nom_cty[\u001b[38;5;28mint\u001b[39m(cty)] == \u001b[32m0\u001b[39m:\n\u001b[32m    100\u001b[39m         event_payout = \u001b[32m0\u001b[39m\n",
-      "\u001b[31mNameError\u001b[39m: name 'countries' is not defined"
+      "\u001b[31mAttributeError\u001b[39m                            Traceback (most recent call last)",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[44]\u001b[39m\u001b[32m, line 3\u001b[39m\n\u001b[32m      1\u001b[39m mlt_cat_bond = mlt_bond_simulation(subarea_calc_list=[st_kitts_sub_calc, jamaica_sub_calc], countries_list=countries, term=term,number_of_terms=num_of_terms, tranches=[\u001b[32m0.2\u001b[39m,\u001b[32m0.8\u001b[39m])\n\u001b[32m      2\u001b[39m mlt_cat_bond.init_loss_simulation(principal=jamaica_sub_calc.principal + st_kitts_sub_calc.principal, confidence_levels=[\u001b[32m0.95\u001b[39m,\u001b[32m0.99\u001b[39m])\n\u001b[32m----> \u001b[39m\u001b[32m3\u001b[39m \u001b[43mmlt_cat_bond\u001b[49m\u001b[43m.\u001b[49m\u001b[43minit_required_principal\u001b[49m()\n\u001b[32m      4\u001b[39m mlt_bond_premiums = premium_calculations(bond_simulation_class=mlt_cat_bond)\n\u001b[32m      5\u001b[39m mlt_bond_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)\n",
+      "\u001b[31mAttributeError\u001b[39m: 'mlt_bond_simulation' object has no attribute 'init_required_principal'"
      ]
     }
    ],
    "source": [
-    "mlt_cat_bond = mlt_bond_simulation(subarea_calc_list=[st_kitts_sub_calc, jamaica_sub_calc], countries_list=countries, term=term,number_of_terms=num_of_terms, tranches=[50,100])\n",
-    "mlt_cat_bond.init_loss_simulation(principal=6000000000, confidence_levels=[0.95,0.99])"
+    "mlt_cat_bond = mlt_bond_simulation(subarea_calc_list=[st_kitts_sub_calc, jamaica_sub_calc], countries_list=countries, term=term,number_of_terms=num_of_terms, tranches=[0.2,0.8])\n",
+    "mlt_cat_bond.init_loss_simulation(principal=jamaica_sub_calc.principal + st_kitts_sub_calc.principal, confidence_levels=[0.95,0.99])\n",
+    "mlt_cat_bond.init_required_principal()\n",
+    "mlt_bond_premiums = premium_calculations(bond_simulation_class=mlt_cat_bond)\n",
+    "mlt_bond_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)\n",
+    "mlt_bond_premiums.calc_ibrd_premium()\n",
+    "mlt_bond_premiums.calc_benchmark_premium(target_sharpe = target_sharpe)\n",
+    "mlt_cat_bond.init_return_simulation_tranches(premiums=[mlt_bond_premiums.chatoro_prem_rate,mlt_bond_premiums.chatoro_prem_rate])\n",
+    "mlt_cat_bond.init_return_simulation(premium=mlt_bond_premiums.chatoro_prem_rate)\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)}\")"
    ]
   }
  ],

From 1d5897dda87ea17fbd154fb427e9bf693af13960 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 21 Nov 2025 16:07:51 +0100
Subject: [PATCH 057/125] fix min year in requ_principal and initialze min_year
 at class init

---
 .../engine/cat_bonds/mlt_bond_simulation.py   | 23 +++++++++++++++----
 1 file changed, 18 insertions(+), 5 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
index 7d5f1a382..7e7dc200c 100644
--- a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
@@ -14,6 +14,7 @@ def __init__(self, subarea_calc_list, countries_list, term, number_of_terms, tra
         self.simulated_years = number_of_terms * term
         self.tranches = tranches
         self.subarea_calc = subarea_calc_list
+        self._prepare_data()
 
 
 
@@ -28,7 +29,7 @@ def _prepare_data(self):
 
         min_year = min(min_year_list)
 
-        return min_year
+        self.min_year = min_year
         
 
 
@@ -41,6 +42,7 @@ def _init_bond_loss(self, events_per_year, principal):
         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
@@ -50,6 +52,7 @@ def _init_bond_loss(self, events_per_year, principal):
         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
@@ -64,6 +67,7 @@ def _init_bond_loss(self, events_per_year, principal):
         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`.
@@ -134,6 +138,7 @@ def init_loss_simulation(self, principal, confidence_levels=[0.95, 0.99]):
         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
@@ -142,6 +147,7 @@ def init_loss_simulation(self, principal, confidence_levels=[0.95, 0.99]):
             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
@@ -150,6 +156,7 @@ def init_loss_simulation(self, principal, confidence_levels=[0.95, 0.99]):
             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.
@@ -157,8 +164,6 @@ def init_loss_simulation(self, principal, confidence_levels=[0.95, 0.99]):
 
         """
 
-        min_year = self._prepare_data()
-
         annual_losses = []
         total_losses = []
         list_loss_month = []
@@ -173,7 +178,7 @@ def init_loss_simulation(self, principal, confidence_levels=[0.95, 0.99]):
             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'] == (min_year+i)+j].copy()
+                    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()
@@ -230,6 +235,7 @@ def init_return_simulation(self, premium, rf=0.0):
         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
@@ -238,12 +244,14 @@ def init_return_simulation(self, premium, rf=0.0):
             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.
@@ -303,6 +311,7 @@ def init_return_simulation_tranches(self, premiums, rf=0.0):
         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
@@ -311,12 +320,14 @@ def init_return_simulation_tranches(self, premiums, rf=0.0):
             List of annual premium rates 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.
@@ -401,7 +412,7 @@ def init_required_principal(self):
         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'] == (i + j)].assign(country_code=cty) for cty in self.countries]
+                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)
@@ -421,6 +432,7 @@ def _init_equ_nom_sim(self, events_per_year, nominal_dic_cty):
         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
@@ -428,6 +440,7 @@ def _init_equ_nom_sim(self, events_per_year, nominal_dic_cty):
             '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

From 499bf9714c9d61abd653d6ce2aaa1202a95124d1 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 21 Nov 2025 18:38:51 +0100
Subject: [PATCH 058/125] add function for overlapping subareas

---
 climada_petals/engine/cat_bonds/subareas.py | 107 +++++++++++++++++++-
 1 file changed, 104 insertions(+), 3 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/subareas.py b/climada_petals/engine/cat_bonds/subareas.py
index 6c0bc217e..d37c6ec2b 100644
--- a/climada_petals/engine/cat_bonds/subareas.py
+++ b/climada_petals/engine/cat_bonds/subareas.py
@@ -9,6 +9,7 @@
 from rasterio.transform import from_bounds
 from sklearn.neighbors import NearestNeighbors
 import cartopy.crs as ccrs
+import networkx as nx
 
 import logging
 
@@ -174,7 +175,7 @@ def _crop_grid_cells_to_polygon(self, exp_gdf):
         # Loop through each polygon in the GeoDataFrame
         for idx, polygon in exp_gdf.iterrows():
             
-            # Pad the geometry bounds by 1% of width/height for better coverage
+            # 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
@@ -186,6 +187,16 @@ def _crop_grid_cells_to_polygon(self, exp_gdf):
             LOGGER.info(
                 f"Processing polygon with bounds: {minx}, {miny}, {maxx}, {maxy}"
             )
+            if maxx - minx < self._resolution or maxy - miny < self._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) / self._resolution) + 1
             num_cells_y = int((maxy - miny) / self._resolution) + 1
@@ -222,8 +233,10 @@ def _crop_grid_cells_to_polygon(self, exp_gdf):
         grids = gpd.GeoDataFrame(
             pd.concat(cropped_cells, ignore_index=True), crs=exp_gdf.crs
         )
-        grids.reset_index(drop=True, inplace=True)
-        subareas = grids[~grids.is_empty]
+        # Merge overlapping grid cells into single polygons
+        merged_grids = self.merge_overlapping_grids_nx(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.")
@@ -288,3 +301,91 @@ def _create_exp_gdf(self):
         LOGGER.info("Exposure perimeter polygon created.")
 
         return exp_gdf
+
+
+    def merge_overlapping_grids(self, gdf: gpd.GeoDataFrame) -> gpd.GeoDataFrame:
+
+        """
+        Merges overlapping grid cells in a GeoDataFrame into single polygons.
+        
+        Parameters
+        ----------
+        gdf : geopandas.GeoDataFrame
+            GeoDataFrame containing grid cell geometries.
+
+        Returns
+        -------
+        merged_gdf : geopandas.GeoDataFrame
+            GeoDataFrame with overlapping grid cells merged into single polygons.
+        """
+      
+        LOGGER.info("Merging overlapping grid cells into single polygons.")
+
+        geoms = gdf.geometry.tolist()
+        to_delete = []
+        for idx, geom in enumerate(geoms):
+            for idx_inner, candidate in enumerate(geoms):
+                if idx >= idx_inner:
+                    continue
+                else:
+                    # Example grid cells
+                    cell1 = box(geom.bounds[0], geom.bounds[1], geom.bounds[2], geom.bounds[3])
+                    cell2 = box(candidate.bounds[0], candidate.bounds[1], candidate.bounds[2], candidate.bounds[3])
+                    is_contained_1 = cell1.contains(cell2)
+                    is_contained_2 = cell2.contains(cell1)
+                    if is_contained_1:
+                        to_delete.append(idx_inner)
+                        continue
+                    elif is_contained_2:
+                        geoms[idx] = geoms[idx_inner]
+                        to_delete.append(idx_inner)
+                        continue
+                    else:
+                        # Calculate intersection area
+                        overlap = cell1.intersection(cell2).area
+                        print("Overlapping area:", overlap)
+                        if overlap > 0:
+                            geoms[idx] = geoms[idx].union(geoms[idx_inner])
+                            to_delete.append(idx_inner)
+                            continue
+                        else:
+                            continue
+        geoms = [geom for i, geom in enumerate(geoms) if i not in to_delete]
+        merged_gdf = gpd.GeoDataFrame(geometry=geoms, crs=gdf.crs)
+        LOGGER.info("Merging completed.")
+        return merged_gdf
+                    
+    def merge_overlapping_grids_nx(self, gdf: gpd.GeoDataFrame) -> gpd.GeoDataFrame:
+        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

From 0fef13e01b2a4b6b98b11f6df915fc6a118f5b43 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 21 Nov 2025 18:40:57 +0100
Subject: [PATCH 059/125] add belize

---
 climada_petals/engine/cat_bonds/test.ipynb | 373 +++++++++++++++++----
 1 file changed, 302 insertions(+), 71 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/test.ipynb b/climada_petals/engine/cat_bonds/test.ipynb
index aaab6f54a..57c2d13ae 100644
--- a/climada_petals/engine/cat_bonds/test.ipynb
+++ b/climada_petals/engine/cat_bonds/test.ipynb
@@ -32,15 +32,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 22,
    "id": "89b53a88",
    "metadata": {},
    "outputs": [],
    "source": [
     "### Bond Basics ###\n",
-    "countries = [659, 388]  # St. Kitts and Nevis\n",
-    "exhaustion_point = 0.5 # 50% of exposure\n",
-    "attachment_point = 0.05 # 5% of exposure\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",
@@ -50,6 +50,7 @@
     "### 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",
@@ -77,9 +78,9 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-21 14:52:05,791 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
-      "2025-11-21 14:52:05,854 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
-      "2025-11-21 14:52:05,916 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n"
+      "2025-11-21 15:59:53,987 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
+      "2025-11-21 15:59:54,049 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
+      "2025-11-21 15:59:54,110 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n"
      ]
     },
     {
@@ -93,27 +94,27 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-21 14:52:10,784 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
-      "2025-11-21 14:52:10,866 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 546 coastal centroids.\n",
-      "2025-11-21 14:52:11,191 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
-      "2025-11-21 14:52:11,454 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
-      "2025-11-21 14:52:11,736 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
-      "2025-11-21 14:52:12,039 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
-      "2025-11-21 14:52:12,323 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
-      "2025-11-21 14:52:12,667 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
-      "2025-11-21 14:52:13,008 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
-      "2025-11-21 14:52:13,308 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
-      "2025-11-21 14:52:13,484 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
-      "2025-11-21 14:52:14,528 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      "2025-11-21 16:00:00,772 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
+      "2025-11-21 16:00:00,890 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 546 coastal centroids.\n",
+      "2025-11-21 16:00:01,514 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
+      "2025-11-21 16:00:02,107 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
+      "2025-11-21 16:00:02,718 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
+      "2025-11-21 16:00:03,193 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
+      "2025-11-21 16:00:03,753 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
+      "2025-11-21 16:00:04,491 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
+      "2025-11-21 16:00:05,091 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
+      "2025-11-21 16:00:05,652 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
+      "2025-11-21 16:00:06,040 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
+      "2025-11-21 16:00:07,209 - climada.entity.exposures.litpop.litpop - INFO - \n",
       " LitPop: Init Exposure for country: KNA (659)...\n",
       "\n",
-      "2025-11-21 14:52:14,610 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-21 14:52:15,449 - climada.util.finance - INFO - GDP KNA 2020: 8.839e+08.\n",
-      "2025-11-21 14:52:15,467 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
-      "2025-11-21 14:52:15,468 - climada.entity.exposures.base - INFO - category_id not set.\n",
-      "2025-11-21 14:52:15,469 - climada.entity.exposures.base - INFO - cover not set.\n",
-      "2025-11-21 14:52:15,470 - climada.entity.exposures.base - INFO - deductible not set.\n",
-      "2025-11-21 14:52:15,471 - climada.entity.exposures.base - INFO - centr_ not set.\n"
+      "2025-11-21 16:00:07,265 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-21 16:00:07,969 - climada.util.finance - INFO - GDP KNA 2020: 8.839e+08.\n",
+      "2025-11-21 16:00:07,992 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+      "2025-11-21 16:00:07,993 - climada.entity.exposures.base - INFO - category_id not set.\n",
+      "2025-11-21 16:00:07,993 - climada.entity.exposures.base - INFO - cover not set.\n",
+      "2025-11-21 16:00:07,994 - climada.entity.exposures.base - INFO - deductible not set.\n",
+      "2025-11-21 16:00:07,994 - climada.entity.exposures.base - INFO - centr_ not set.\n"
      ]
     }
    ],
@@ -158,29 +159,29 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-21 14:52:17,068 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
-      "2025-11-21 14:52:17,125 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
-      "2025-11-21 14:52:17,160 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
-      "2025-11-21 14:52:19,866 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
-      "2025-11-21 14:52:19,895 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 7938 coastal centroids.\n",
-      "2025-11-21 14:52:24,550 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
-      "2025-11-21 14:52:28,951 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
-      "2025-11-21 14:52:33,751 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
-      "2025-11-21 14:52:38,839 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
-      "2025-11-21 14:52:43,392 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
-      "2025-11-21 14:52:48,070 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
-      "2025-11-21 14:52:51,716 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
-      "2025-11-21 14:52:56,840 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
-      "2025-11-21 14:52:58,630 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
-      "2025-11-21 14:53:00,854 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      "2025-11-21 16:00:09,959 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
+      "2025-11-21 16:00:10,006 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
+      "2025-11-21 16:00:10,045 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
+      "2025-11-21 16:00:13,021 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
+      "2025-11-21 16:00:13,065 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 7938 coastal centroids.\n",
+      "2025-11-21 16:00:23,029 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
+      "2025-11-21 16:00:27,883 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
+      "2025-11-21 16:00:33,102 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
+      "2025-11-21 16:00:39,542 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
+      "2025-11-21 16:00:45,759 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
+      "2025-11-21 16:00:52,034 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
+      "2025-11-21 16:00:57,008 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
+      "2025-11-21 16:01:05,721 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
+      "2025-11-21 16:01:08,980 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
+      "2025-11-21 16:01:13,102 - climada.entity.exposures.litpop.litpop - INFO - \n",
       " LitPop: Init Exposure for country: JAM (388)...\n",
       "\n",
-      "2025-11-21 14:53:01,398 - climada.util.finance - INFO - GDP JAM 2020: 1.381e+10.\n",
-      "2025-11-21 14:53:01,431 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
-      "2025-11-21 14:53:01,431 - climada.entity.exposures.base - INFO - category_id not set.\n",
-      "2025-11-21 14:53:01,432 - climada.entity.exposures.base - INFO - cover not set.\n",
-      "2025-11-21 14:53:01,432 - climada.entity.exposures.base - INFO - deductible not set.\n",
-      "2025-11-21 14:53:01,433 - climada.entity.exposures.base - INFO - centr_ not set.\n"
+      "2025-11-21 16:01:13,560 - climada.util.finance - INFO - GDP JAM 2020: 1.381e+10.\n",
+      "2025-11-21 16:01:13,591 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+      "2025-11-21 16:01:13,591 - climada.entity.exposures.base - INFO - category_id not set.\n",
+      "2025-11-21 16:01:13,591 - climada.entity.exposures.base - INFO - cover not set.\n",
+      "2025-11-21 16:01:13,592 - climada.entity.exposures.base - INFO - deductible not set.\n",
+      "2025-11-21 16:01:13,593 - climada.entity.exposures.base - INFO - centr_ not set.\n"
      ]
     }
    ],
@@ -214,6 +215,140 @@
     "       739221, 739268, 739297])"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "95c26af7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-11-21 16:22:41,261 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      " LitPop: Init Exposure for country: BLZ (84)...\n",
+      "\n",
+      "2025-11-21 16:22:41,814 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-21 16:22:41,849 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-21 16:22:41,891 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-21 16:22:41,919 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-21 16:22:41,949 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-21 16:22:41,972 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-21 16:22:42,023 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-21 16:22:42,050 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-21 16:22:42,071 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-21 16:22:44,005 - climada.util.finance - INFO - GDP BLZ 2020: 2.043e+09.\n",
+      "2025-11-21 16:22:44,072 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+      "2025-11-21 16:22:44,073 - climada.entity.exposures.base - INFO - category_id not set.\n",
+      "2025-11-21 16:22:44,074 - climada.entity.exposures.base - INFO - cover not set.\n",
+      "2025-11-21 16:22:44,074 - climada.entity.exposures.base - INFO - deductible not set.\n",
+      "2025-11-21 16:22:44,075 - climada.entity.exposures.base - INFO - centr_ not set.\n",
+      "2025-11-21 16:22:44,092 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<GeoAxes: >"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 900x1300 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "exp_bel = LitPop.from_countries(\n",
+    "        [countries[2]], fin_mode='gdp', reference_year=2020\n",
+    "    )\n",
+    "exp_bel.plot_raster()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "c42eed8b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-11-21 16:24:16,897 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
+      "2025-11-21 16:24:17,170 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
+      "2025-11-21 16:24:17,246 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
+      "2025-11-21 16:24:20,411 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
+      "2025-11-21 16:24:20,595 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 16463 coastal centroids.\n",
+      "2025-11-21 16:24:36,868 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
+      "2025-11-21 16:24:48,134 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
+      "2025-11-21 16:25:01,556 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
+      "2025-11-21 16:25:14,041 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
+      "2025-11-21 16:25:24,325 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
+      "2025-11-21 16:25:32,434 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
+      "2025-11-21 16:25:41,287 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
+      "2025-11-21 16:25:49,288 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
+      "2025-11-21 16:25:54,137 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
+      "2025-11-21 16:25:59,806 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      " LitPop: Init Exposure for country: BLZ (84)...\n",
+      "\n",
+      "2025-11-21 16:26:00,575 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-21 16:26:00,606 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-21 16:26:00,783 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-21 16:26:00,812 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-21 16:26:00,849 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-21 16:26:00,877 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-21 16:26:00,952 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-21 16:26:00,977 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-21 16:26:01,024 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-21 16:26:01,666 - climada.util.finance - INFO - GDP BLZ 2020: 2.043e+09.\n",
+      "2025-11-21 16:26:01,808 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+      "2025-11-21 16:26:01,836 - climada.entity.exposures.base - INFO - category_id not set.\n",
+      "2025-11-21 16:26:01,838 - climada.entity.exposures.base - INFO - cover not set.\n",
+      "2025-11-21 16:26:01,847 - climada.entity.exposures.base - INFO - deductible not set.\n",
+      "2025-11-21 16:26:01,851 - 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",
@@ -224,7 +359,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 53,
    "id": "09fba021",
    "metadata": {},
    "outputs": [
@@ -232,7 +367,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-21 14:53:03,542 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+      "2025-11-21 18:36:44,599 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
      ]
     },
     {
@@ -249,7 +384,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-21 14:53:22,037 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+      "2025-11-21 18:37:08,081 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
      ]
     },
     {
@@ -261,13 +396,32 @@
      },
      "metadata": {},
      "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-11-21 18:37:23,621 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 900x1300 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     }
    ],
    "source": [
     "st_kitts_subareas = Subareas(tc_irma, impfset, exp_kit, resolution=resolution_st_kitts)\n",
     "jamaica_subareas = Subareas(tc_melissa, impfset, exp_jam, resolution=resolution_jamaica)\n",
+    "belize_subareas = Subareas(tc_keith, impfset, exp_bel, resolution=resolution_belize)\n",
     "jamaica_subareas.plot()\n",
-    "st_kitts_subareas.plot()"
+    "st_kitts_subareas.plot()\n",
+    "belize_subareas.plot()"
    ]
   },
   {
@@ -280,7 +434,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 54,
    "id": "ac344ab3",
    "metadata": {},
    "outputs": [
@@ -288,20 +442,29 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-21 14:53:37,039 - climada.entity.exposures.base - INFO - Matching 328 exposures with 546 centroids.\n",
-      "2025-11-21 14:53:37,041 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
-      "2025-11-21 14:53:37,046 - climada.engine.impact_calc - INFO - Calculating impact for 984 assets (>0) and 51 events.\n",
-      "2025-11-21 14:53:37,952 - climada.entity.exposures.base - INFO - Matching 13552 exposures with 7938 centroids.\n",
-      "2025-11-21 14:53:37,961 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
-      "2025-11-21 14:53:37,996 - climada.engine.impact_calc - INFO - Calculating impact for 40503 assets (>0) and 51 events.\n"
+      "2025-11-21 18:39:14,452 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n",
+      "2025-11-21 18:39:14,454 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n",
+      "2025-11-21 18:39:14,456 - climada.entity.exposures.base - INFO - Matching 328 exposures with 546 centroids.\n",
+      "2025-11-21 18:39:14,468 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
+      "2025-11-21 18:39:14,479 - climada.engine.impact_calc - INFO - Calculating impact for 984 assets (>0) and 51 events.\n",
+      "2025-11-21 18:39:16,808 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n",
+      "2025-11-21 18:39:16,809 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n",
+      "2025-11-21 18:39:16,810 - climada.entity.exposures.base - INFO - Matching 13552 exposures with 7938 centroids.\n",
+      "2025-11-21 18:39:16,859 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
+      "2025-11-21 18:39:16,962 - climada.engine.impact_calc - INFO - Calculating impact for 40503 assets (>0) and 51 events.\n",
+      "2025-11-21 18:39:18,171 - climada.entity.exposures.base - INFO - Matching 27265 exposures with 16463 centroids.\n",
+      "2025-11-21 18:39:18,372 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
+      "2025-11-21 18:39:18,580 - climada.engine.impact_calc - INFO - Calculating impact for 81177 assets (>0) and 51 events.\n"
      ]
     }
    ],
    "source": [
     "st_kitts_sub_calc = Subarea_Calculations(subareas=st_kitts_subareas, index_stat=par_index)\n",
     "jamaica_sub_calc = Subarea_Calculations(subareas=jamaica_subareas, index_stat=par_index)\n",
+    "belize_sub_calc = Subarea_Calculations(subareas=belize_subareas, index_stat=par_index)\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)\n",
-    "jamaica_sub_calc.create_pay_vs_dam(attachment_point, exhaustion_point, methods_attachment_point=attachment_point_method, methods_exhaustion_point=exhaustion_point_method)"
+    "jamaica_sub_calc.create_pay_vs_dam(attachment_point, exhaustion_point, methods_attachment_point=attachment_point_method, methods_exhaustion_point=exhaustion_point_method)\n",
+    "belize_sub_calc.create_pay_vs_dam(attachment_point, exhaustion_point, methods_attachment_point=attachment_point_method, methods_exhaustion_point=exhaustion_point_method)"
    ]
   },
   {
@@ -309,7 +472,7 @@
    "id": "bf3bead9",
    "metadata": {},
    "source": [
-    "### Bond Simulation"
+    "### Single-Country Bond Simulation"
    ]
   },
   {
@@ -408,26 +571,94 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 55,
+   "id": "4e590bad",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'EL_ann': 0.03539315772390796,\n",
+       " 'AP_ann': 0.11695906432748537,\n",
+       " 'Tot_payout': 6181898997.912401,\n",
+       " 'Tot_damages': 9590299020.561695,\n",
+       " 'VaR_95_ann': 0.2502831832790935,\n",
+       " 'ES_95_ann': 0.42061594416208714,\n",
+       " 'VaR_99_ann': 0.5701643301269493,\n",
+       " 'ES_99_ann': 0.6061999788723924}"
+      ]
+     },
+     "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 = sng_bond_simulation(subarea_calc=belize_sub_calc, term=term, number_of_terms=num_of_terms) \n",
+    "belize_bond_sim.init_loss_simulation()\n",
+    "belize_premiums = premium_calculations(bond_simulation_class=belize_bond_sim)\n",
+    "belize_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)\n",
+    "belize_premiums.calc_ibrd_premium()\n",
+    "belize_premiums.calc_benchmark_premium(target_sharpe = target_sharpe)\n",
+    "belize_bond_sim.init_return_simulation(premium=belize_premiums.chatoro_prem_rate)\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": 56,
    "id": "67403f5f",
    "metadata": {},
    "outputs": [
     {
-     "ename": "AttributeError",
-     "evalue": "'mlt_bond_simulation' object has no attribute 'init_required_principal'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
-      "\u001b[31mAttributeError\u001b[39m                            Traceback (most recent call last)",
-      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[44]\u001b[39m\u001b[32m, line 3\u001b[39m\n\u001b[32m      1\u001b[39m mlt_cat_bond = mlt_bond_simulation(subarea_calc_list=[st_kitts_sub_calc, jamaica_sub_calc], countries_list=countries, term=term,number_of_terms=num_of_terms, tranches=[\u001b[32m0.2\u001b[39m,\u001b[32m0.8\u001b[39m])\n\u001b[32m      2\u001b[39m mlt_cat_bond.init_loss_simulation(principal=jamaica_sub_calc.principal + st_kitts_sub_calc.principal, confidence_levels=[\u001b[32m0.95\u001b[39m,\u001b[32m0.99\u001b[39m])\n\u001b[32m----> \u001b[39m\u001b[32m3\u001b[39m \u001b[43mmlt_cat_bond\u001b[49m\u001b[43m.\u001b[49m\u001b[43minit_required_principal\u001b[49m()\n\u001b[32m      4\u001b[39m mlt_bond_premiums = premium_calculations(bond_simulation_class=mlt_cat_bond)\n\u001b[32m      5\u001b[39m mlt_bond_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)\n",
-      "\u001b[31mAttributeError\u001b[39m: 'mlt_bond_simulation' object has no attribute 'init_required_principal'"
+     "data": {
+      "text/plain": [
+       "{'EL_ann': 0.029481977291732603,\n",
+       " 'AP_ann': 0.14035087719298245,\n",
+       " 'Payout': 39161493937.057396,\n",
+       " 'Damage': 71547301813.98299,\n",
+       " 'VaR_95_ann': 0.15776731924400075,\n",
+       " 'ES_95_ann': 0.43875569600979597,\n",
+       " 'VaR_99_ann': 0.7602314866443391,\n",
+       " 'ES_99_ann': 0.807913900425695}"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Benchmark Sharpe Ratio premium rate: 9.8\n",
+      "Chatoro premium rate: 10.2\n",
+      "IBRD premium rate: 6.3\n"
      ]
     }
    ],
    "source": [
-    "mlt_cat_bond = mlt_bond_simulation(subarea_calc_list=[st_kitts_sub_calc, jamaica_sub_calc], countries_list=countries, term=term,number_of_terms=num_of_terms, tranches=[0.2,0.8])\n",
-    "mlt_cat_bond.init_loss_simulation(principal=jamaica_sub_calc.principal + st_kitts_sub_calc.principal, confidence_levels=[0.95,0.99])\n",
+    "mlt_cat_bond = mlt_bond_simulation(subarea_calc_list=[st_kitts_sub_calc, jamaica_sub_calc, belize_sub_calc], countries_list=countries, term=term,number_of_terms=num_of_terms, tranches=[0.2,0.8])\n",
     "mlt_cat_bond.init_required_principal()\n",
+    "mlt_cat_bond.init_loss_simulation(principal=mlt_cat_bond.requ_principal, confidence_levels=[0.95,0.99])\n",
     "mlt_bond_premiums = premium_calculations(bond_simulation_class=mlt_cat_bond)\n",
     "mlt_bond_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)\n",
     "mlt_bond_premiums.calc_ibrd_premium()\n",

From a53e32edc7156f31d3bce45ec36c6fa7970ae7b5 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 21 Nov 2025 18:47:56 +0100
Subject: [PATCH 060/125] make build_subareas optional

---
 climada_petals/engine/cat_bonds/subareas.py |  3 +-
 climada_petals/engine/cat_bonds/test.ipynb  | 64 ++-------------------
 2 files changed, 5 insertions(+), 62 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/subareas.py b/climada_petals/engine/cat_bonds/subareas.py
index d37c6ec2b..daf778961 100644
--- a/climada_petals/engine/cat_bonds/subareas.py
+++ b/climada_petals/engine/cat_bonds/subareas.py
@@ -55,9 +55,8 @@ def __init__(
         self.vulnerability = vulnerability
         self._exposure = exposure
         self._resolution = resolution
-        self._build_subareas()
 
-    def _build_subareas(self):
+    def build_subareas(self):
         """Calculate subareas and islands."""
         self.subareas_gdf = self._init_subareas()
 
diff --git a/climada_petals/engine/cat_bonds/test.ipynb b/climada_petals/engine/cat_bonds/test.ipynb
index 57c2d13ae..6b36e6f6f 100644
--- a/climada_petals/engine/cat_bonds/test.ipynb
+++ b/climada_petals/engine/cat_bonds/test.ipynb
@@ -215,65 +215,6 @@
     "       739221, 739268, 739297])"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "id": "95c26af7",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "2025-11-21 16:22:41,261 - climada.entity.exposures.litpop.litpop - INFO - \n",
-      " LitPop: Init Exposure for country: BLZ (84)...\n",
-      "\n",
-      "2025-11-21 16:22:41,814 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-21 16:22:41,849 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-21 16:22:41,891 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-21 16:22:41,919 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-21 16:22:41,949 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-21 16:22:41,972 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-21 16:22:42,023 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-21 16:22:42,050 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-21 16:22:42,071 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-21 16:22:44,005 - climada.util.finance - INFO - GDP BLZ 2020: 2.043e+09.\n",
-      "2025-11-21 16:22:44,072 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
-      "2025-11-21 16:22:44,073 - climada.entity.exposures.base - INFO - category_id not set.\n",
-      "2025-11-21 16:22:44,074 - climada.entity.exposures.base - INFO - cover not set.\n",
-      "2025-11-21 16:22:44,074 - climada.entity.exposures.base - INFO - deductible not set.\n",
-      "2025-11-21 16:22:44,075 - climada.entity.exposures.base - INFO - centr_ not set.\n",
-      "2025-11-21 16:22:44,092 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "<GeoAxes: >"
-      ]
-     },
-     "execution_count": 18,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 900x1300 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "exp_bel = LitPop.from_countries(\n",
-    "        [countries[2]], fin_mode='gdp', reference_year=2020\n",
-    "    )\n",
-    "exp_bel.plot_raster()"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 19,
@@ -359,7 +300,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 53,
+   "execution_count": null,
    "id": "09fba021",
    "metadata": {},
    "outputs": [
@@ -417,8 +358,11 @@
    ],
    "source": [
     "st_kitts_subareas = Subareas(tc_irma, impfset, exp_kit, resolution=resolution_st_kitts)\n",
+    "st_kitts_subareas.build_subareas()\n",
     "jamaica_subareas = Subareas(tc_melissa, impfset, exp_jam, resolution=resolution_jamaica)\n",
+    "jamaica_subareas.build_subareas()\n",
     "belize_subareas = Subareas(tc_keith, impfset, exp_bel, resolution=resolution_belize)\n",
+    "belize_subareas.build_subareas()\n",
     "jamaica_subareas.plot()\n",
     "st_kitts_subareas.plot()\n",
     "belize_subareas.plot()"

From 0b09fe560d83105c3e3fa1cc0a5ca559cdf53330 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 21 Nov 2025 18:52:21 +0100
Subject: [PATCH 061/125] minor adjustments

---
 climada_petals/engine/cat_bonds/subareas.py | 63 +++------------------
 1 file changed, 9 insertions(+), 54 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/subareas.py b/climada_petals/engine/cat_bonds/subareas.py
index daf778961..5e01871a3 100644
--- a/climada_petals/engine/cat_bonds/subareas.py
+++ b/climada_petals/engine/cat_bonds/subareas.py
@@ -16,10 +16,6 @@
 LOGGER = logging.getLogger(__name__)
 
 
-# specify resultion to change exposure layer into country polygons
-#tc_bound_resolution = 1000
-
-
 class Subareas:
 
     '''Class to handle subareas for CAT bonds.
@@ -60,7 +56,7 @@ def build_subareas(self):
         """Calculate subareas and islands."""
         self.subareas_gdf = self._init_subareas()
 
-    # --- Properties with auto-rebuild ---
+    # --- Properties ---
     @property
     def exposure(self):
         return self._exposure
@@ -94,8 +90,8 @@ def plot(self):
             ymin = min(ymin1, ymin2)
             ymax = max(ymax1, ymax2)
 
-            # 4️⃣ Add padding (e.g. 10% wider and 5% taller)
-            pad_x = (xmax - xmin) * 0.1   # 10% horizontal padding
+            # 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(
@@ -233,7 +229,7 @@ def _crop_grid_cells_to_polygon(self, exp_gdf):
             pd.concat(cropped_cells, ignore_index=True), crs=exp_gdf.crs
         )
         # Merge overlapping grid cells into single polygons
-        merged_grids = self.merge_overlapping_grids_nx(grids)
+        merged_grids = self._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)
@@ -301,60 +297,19 @@ def _create_exp_gdf(self):
 
         return exp_gdf
 
-
-    def merge_overlapping_grids(self, gdf: gpd.GeoDataFrame) -> gpd.GeoDataFrame:
-
+    def _merge_overlapping_grids(self, gdf: gpd.GeoDataFrame) -> gpd.GeoDataFrame:
         """
-        Merges overlapping grid cells in a GeoDataFrame into single polygons.
-        
+        Merges overlapping grid cells in a GeoDataFrame into single polygons using NetworkX.
+
         Parameters
         ----------
-        gdf : geopandas.GeoDataFrame
-            GeoDataFrame containing grid cell geometries.
+            gdf (gpd.GeoDataFrame): GeoDataFrame containing grid cell geometries.
 
         Returns
         -------
-        merged_gdf : geopandas.GeoDataFrame
-            GeoDataFrame with overlapping grid cells merged into single polygons.
+            gpd.GeoDataFrame: GeoDataFrame with merged polygons.
         """
-      
-        LOGGER.info("Merging overlapping grid cells into single polygons.")
 
-        geoms = gdf.geometry.tolist()
-        to_delete = []
-        for idx, geom in enumerate(geoms):
-            for idx_inner, candidate in enumerate(geoms):
-                if idx >= idx_inner:
-                    continue
-                else:
-                    # Example grid cells
-                    cell1 = box(geom.bounds[0], geom.bounds[1], geom.bounds[2], geom.bounds[3])
-                    cell2 = box(candidate.bounds[0], candidate.bounds[1], candidate.bounds[2], candidate.bounds[3])
-                    is_contained_1 = cell1.contains(cell2)
-                    is_contained_2 = cell2.contains(cell1)
-                    if is_contained_1:
-                        to_delete.append(idx_inner)
-                        continue
-                    elif is_contained_2:
-                        geoms[idx] = geoms[idx_inner]
-                        to_delete.append(idx_inner)
-                        continue
-                    else:
-                        # Calculate intersection area
-                        overlap = cell1.intersection(cell2).area
-                        print("Overlapping area:", overlap)
-                        if overlap > 0:
-                            geoms[idx] = geoms[idx].union(geoms[idx_inner])
-                            to_delete.append(idx_inner)
-                            continue
-                        else:
-                            continue
-        geoms = [geom for i, geom in enumerate(geoms) if i not in to_delete]
-        merged_gdf = gpd.GeoDataFrame(geometry=geoms, crs=gdf.crs)
-        LOGGER.info("Merging completed.")
-        return merged_gdf
-                    
-    def merge_overlapping_grids_nx(self, gdf: gpd.GeoDataFrame) -> gpd.GeoDataFrame:
         LOGGER.info("Merging overlapping grid cells into single polygons.")
 
         geoms = gdf.geometry.tolist()

From 6051337feb30402220a1c8bb241772b07001a1b8 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 21 Nov 2025 18:56:03 +0100
Subject: [PATCH 062/125] rename class names

---
 .../engine/cat_bonds/mlt_bond_simulation.py   |  2 +-
 .../engine/cat_bonds/premium_class.py         |  2 +-
 .../engine/cat_bonds/sng_bond_simulation.py   |  2 +-
 .../engine/cat_bonds/subarea_calculations.py  |  3 +-
 climada_petals/engine/cat_bonds/test.ipynb    | 42 +++++++++----------
 5 files changed, 25 insertions(+), 26 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
index 7e7dc200c..473c0f8a2 100644
--- a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
@@ -6,7 +6,7 @@
 
 LOGGER = logging.getLogger(__name__)
 
-class mlt_bond_simulation:
+class MultiCountryBondSimulation:
 
     def __init__(self, subarea_calc_list, countries_list, term, number_of_terms, tranches):
         self.countries = countries_list
diff --git a/climada_petals/engine/cat_bonds/premium_class.py b/climada_petals/engine/cat_bonds/premium_class.py
index c0d39f126..be0b96352 100644
--- a/climada_petals/engine/cat_bonds/premium_class.py
+++ b/climada_petals/engine/cat_bonds/premium_class.py
@@ -21,7 +21,7 @@
 b_6 = -2.6742
 b_7 = 0.7057
 
-class premium_calculations:
+class PremiumCalculations:
 
     def __init__(self, bond_simulation_class):
         self.bond_simulation_class = bond_simulation_class
diff --git a/climada_petals/engine/cat_bonds/sng_bond_simulation.py b/climada_petals/engine/cat_bonds/sng_bond_simulation.py
index 26a676f32..7938702f7 100644
--- a/climada_petals/engine/cat_bonds/sng_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/sng_bond_simulation.py
@@ -5,7 +5,7 @@
 
 LOGGER = logging.getLogger(__name__)
 
-class sng_bond_simulation:
+class SingleCountryBondSimulation:
 
     def __init__(self, subarea_calc, term, number_of_terms):
         self.term = term
diff --git a/climada_petals/engine/cat_bonds/subarea_calculations.py b/climada_petals/engine/cat_bonds/subarea_calculations.py
index 44d793b6d..71ffcbd5c 100644
--- a/climada_petals/engine/cat_bonds/subarea_calculations.py
+++ b/climada_petals/engine/cat_bonds/subarea_calculations.py
@@ -11,9 +11,8 @@
 
 
 
-class Subarea_Calculations:
+class SubareaCalculations:
     def __init__(self, subareas, index_stat):
-
         '''
         Attributes
         ----------
diff --git a/climada_petals/engine/cat_bonds/test.ipynb b/climada_petals/engine/cat_bonds/test.ipynb
index 6b36e6f6f..3b5e49a6e 100644
--- a/climada_petals/engine/cat_bonds/test.ipynb
+++ b/climada_petals/engine/cat_bonds/test.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "48c2d418",
    "metadata": {},
    "outputs": [],
@@ -11,10 +11,10 @@
     "%autoreload 2\n",
     "\n",
     "from subareas import Subareas\n",
-    "from subarea_calculations import Subarea_Calculations\n",
-    "from sng_bond_simulation import sng_bond_simulation\n",
-    "from mlt_bond_simulation import mlt_bond_simulation\n",
-    "from premium_class import premium_calculations\n",
+    "from subarea_calculations import SubareaCalculations\n",
+    "from sng_bond_simulation import SingleCountryBondSimulation\n",
+    "from mlt_bond_simulation import MultiCountryBondSimulation\n",
+    "from premium_class import PremiumCalculations\n",
     "\n",
     "from climada.hazard import TCTracks, Centroids, TropCyclone\n",
     "from climada.entity import LitPop\n",
@@ -378,7 +378,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 54,
+   "execution_count": null,
    "id": "ac344ab3",
    "metadata": {},
    "outputs": [
@@ -403,9 +403,9 @@
     }
    ],
    "source": [
-    "st_kitts_sub_calc = Subarea_Calculations(subareas=st_kitts_subareas, index_stat=par_index)\n",
-    "jamaica_sub_calc = Subarea_Calculations(subareas=jamaica_subareas, index_stat=par_index)\n",
-    "belize_sub_calc = Subarea_Calculations(subareas=belize_subareas, index_stat=par_index)\n",
+    "st_kitts_sub_calc = SubareaCalculations(subareas=st_kitts_subareas, index_stat=par_index)\n",
+    "jamaica_sub_calc = SubareaCalculations(subareas=jamaica_subareas, index_stat=par_index)\n",
+    "belize_sub_calc = SubareaCalculations(subareas=belize_subareas, index_stat=par_index)\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)\n",
     "jamaica_sub_calc.create_pay_vs_dam(attachment_point, exhaustion_point, methods_attachment_point=attachment_point_method, methods_exhaustion_point=exhaustion_point_method)\n",
     "belize_sub_calc.create_pay_vs_dam(attachment_point, exhaustion_point, methods_attachment_point=attachment_point_method, methods_exhaustion_point=exhaustion_point_method)"
@@ -421,7 +421,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "id": "4ead6e69",
    "metadata": {},
    "outputs": [
@@ -453,9 +453,9 @@
    ],
    "source": [
     "### ST. KITTS AND NEVIS BOND SIMULATION ###\n",
-    "st_kitts_bond_sim = sng_bond_simulation(subarea_calc=st_kitts_sub_calc, term=term, number_of_terms=num_of_terms) \n",
+    "st_kitts_bond_sim = SingleCountryBondSimulation(subarea_calc=st_kitts_sub_calc, term=term, number_of_terms=num_of_terms) \n",
     "st_kitts_bond_sim.init_loss_simulation()\n",
-    "st_kitts_premiums = premium_calculations(bond_simulation_class=st_kitts_bond_sim)\n",
+    "st_kitts_premiums = PremiumCalculations(bond_simulation_class=st_kitts_bond_sim)\n",
     "st_kitts_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)\n",
     "st_kitts_premiums.calc_ibrd_premium()\n",
     "st_kitts_premiums.calc_benchmark_premium(target_sharpe = target_sharpe)\n",
@@ -468,7 +468,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "id": "6cfb9d55",
    "metadata": {},
    "outputs": [
@@ -500,9 +500,9 @@
    ],
    "source": [
     "### JAMAICA BOND SIMULATION ###\n",
-    "jamaica_bond_sim = sng_bond_simulation(subarea_calc=jamaica_sub_calc, term=term, number_of_terms=num_of_terms) \n",
+    "jamaica_bond_sim = SingleCountryBondSimulation(subarea_calc=jamaica_sub_calc, term=term, number_of_terms=num_of_terms) \n",
     "jamaica_bond_sim.init_loss_simulation()\n",
-    "jamaica_premiums = premium_calculations(bond_simulation_class=jamaica_bond_sim)\n",
+    "jamaica_premiums = PremiumCalculations(bond_simulation_class=jamaica_bond_sim)\n",
     "jamaica_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)\n",
     "jamaica_premiums.calc_ibrd_premium()\n",
     "jamaica_premiums.calc_benchmark_premium(target_sharpe = target_sharpe)\n",
@@ -515,7 +515,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 55,
+   "execution_count": null,
    "id": "4e590bad",
    "metadata": {},
    "outputs": [
@@ -546,9 +546,9 @@
     }
    ],
    "source": [
-    "belize_bond_sim = sng_bond_simulation(subarea_calc=belize_sub_calc, term=term, number_of_terms=num_of_terms) \n",
+    "belize_bond_sim = SingleCountryBondSimulation(subarea_calc=belize_sub_calc, term=term, number_of_terms=num_of_terms) \n",
     "belize_bond_sim.init_loss_simulation()\n",
-    "belize_premiums = premium_calculations(bond_simulation_class=belize_bond_sim)\n",
+    "belize_premiums = PremiumCalculations(bond_simulation_class=belize_bond_sim)\n",
     "belize_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)\n",
     "belize_premiums.calc_ibrd_premium()\n",
     "belize_premiums.calc_benchmark_premium(target_sharpe = target_sharpe)\n",
@@ -569,7 +569,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 56,
+   "execution_count": null,
    "id": "67403f5f",
    "metadata": {},
    "outputs": [
@@ -600,10 +600,10 @@
     }
    ],
    "source": [
-    "mlt_cat_bond = mlt_bond_simulation(subarea_calc_list=[st_kitts_sub_calc, jamaica_sub_calc, belize_sub_calc], countries_list=countries, term=term,number_of_terms=num_of_terms, tranches=[0.2,0.8])\n",
+    "mlt_cat_bond = MultiCountryBondSimulation(subarea_calc_list=[st_kitts_sub_calc, jamaica_sub_calc, belize_sub_calc], countries_list=countries, term=term,number_of_terms=num_of_terms, tranches=[0.2,0.8])\n",
     "mlt_cat_bond.init_required_principal()\n",
     "mlt_cat_bond.init_loss_simulation(principal=mlt_cat_bond.requ_principal, confidence_levels=[0.95,0.99])\n",
-    "mlt_bond_premiums = premium_calculations(bond_simulation_class=mlt_cat_bond)\n",
+    "mlt_bond_premiums = PremiumCalculations(bond_simulation_class=mlt_cat_bond)\n",
     "mlt_bond_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)\n",
     "mlt_bond_premiums.calc_ibrd_premium()\n",
     "mlt_bond_premiums.calc_benchmark_premium(target_sharpe = target_sharpe)\n",

From d2ec6c4f22521cb2b03d9e3262b4d27ef85b3c38 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 21 Nov 2025 19:11:50 +0100
Subject: [PATCH 063/125] initialize pooling optimization problems

---
 .../engine/cat_bonds/pooling_functions.py     | 139 ++++++++++++++++++
 1 file changed, 139 insertions(+)
 create mode 100644 climada_petals/engine/cat_bonds/pooling_functions.py

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..28fd33503
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/pooling_functions.py
@@ -0,0 +1,139 @@
+'''Risk pooling optimization functions adapted from Ciullo et al., 2022'''
+import numpy as np
+from math import comb
+from pymoo.core.problem import ElementwiseProblem
+from pymoo.core.variable import Integer
+
+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

From edfb591ef10668e98c05a6fa5cb01df8b7476b7a Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 21 Nov 2025 19:34:13 +0100
Subject: [PATCH 064/125] add function to derive optimal fixed pools

---
 .../engine/cat_bonds/pooling_functions.py     | 79 +++++++++++++++++++
 1 file changed, 79 insertions(+)

diff --git a/climada_petals/engine/cat_bonds/pooling_functions.py b/climada_petals/engine/cat_bonds/pooling_functions.py
index 28fd33503..b426d65d6 100644
--- a/climada_petals/engine/cat_bonds/pooling_functions.py
+++ b/climada_petals/engine/cat_bonds/pooling_functions.py
@@ -3,6 +3,85 @@
 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(n, cntry_names, sng_ann_losses, principal_sng_dic, 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.
+    cntry_names : list of str
+        List of country names corresponding to the columns in the loss data.
+    sng_ann_losses : pandas.DataFrame
+        Dataframe of annual loss data for each country.
+    principal_sng_dic : dict
+        Principal values for each country.
+    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.
+    """
+    opt_rep = range(0,n_opt_rep,1)
+    df_losses = pd.DataFrame(sng_ann_losses)
+
+    ### TRANSFROM PRINCIPAL VALUES TO LIST ###
+    principal_sng = principal_sng_dic.set_index('Key').loc[cntry_names, 'Value'].tolist()
+
+    ### CALCULATE ALPHA FOR RISK CONCENTRATION OPTIMIZATION ###
+    RT = len(df_losses[cntry_names[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, n, 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=[cntry_names, 'min_conc'])
+            country_allocation = pd.DataFrame([x], columns=cntry_names)
+            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 

From 7efc9a2712221354fbc8856b641cca82b9125494 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 24 Nov 2025 10:34:14 +0100
Subject: [PATCH 065/125] move allocate tranche payout to utils

---
 .../engine/cat_bonds/mlt_bond_simulation.py   | 35 +-----------------
 .../engine/cat_bonds/utils_cat_bonds.py       | 37 ++++++++++++++++++-
 2 files changed, 38 insertions(+), 34 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
index 473c0f8a2..367ba0ca7 100644
--- a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
@@ -2,7 +2,7 @@
 import numpy as np
 import logging
 
-from utils_cat_bonds import multi_level_es
+from utils_cat_bonds import multi_level_es, allocate_single_payout
 
 LOGGER = logging.getLogger(__name__)
 
@@ -475,35 +475,4 @@ def _init_equ_nom_sim(self, events_per_year, nominal_dic_cty):
 
         tot_loss = np.sum(ann_loss)
         return tot_loss
-    
-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
+    
\ 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
index 9aee96ce8..7fa927d37 100644
--- a/climada_petals/engine/cat_bonds/utils_cat_bonds.py
+++ b/climada_petals/engine/cat_bonds/utils_cat_bonds.py
@@ -1,3 +1,5 @@
+import numpy as np
+
 '''Calculate value at risk and expected shorfall for various alphas'''
 def multi_level_es(losses, confidence_levels):
     """
@@ -20,4 +22,37 @@ def multi_level_es(losses, confidence_levels):
         for var in var_list
     ]
 
-    return var_list, es_list
\ No newline at end of file
+    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

From 5a29cc358dd801bd2a467646f61a3c8b100f06d4 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 24 Nov 2025 14:59:46 +0100
Subject: [PATCH 066/125] rename test notebook to tutorial

---
 climada_petals/engine/cat_bonds/{test.ipynb => tutorial.ipynb} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename climada_petals/engine/cat_bonds/{test.ipynb => tutorial.ipynb} (100%)

diff --git a/climada_petals/engine/cat_bonds/test.ipynb b/climada_petals/engine/cat_bonds/tutorial.ipynb
similarity index 100%
rename from climada_petals/engine/cat_bonds/test.ipynb
rename to climada_petals/engine/cat_bonds/tutorial.ipynb

From 58bf8e1f2aebf64cdd7e5b3b53e8df04a4361ec1 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Thu, 27 Nov 2025 16:31:31 +0100
Subject: [PATCH 067/125] move tutorial

---
 .../cat_bonds/{tutorial.ipynb => climada_engine_CATBonds.ipynb}   | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename climada_petals/engine/cat_bonds/{tutorial.ipynb => climada_engine_CATBonds.ipynb} (100%)

diff --git a/climada_petals/engine/cat_bonds/tutorial.ipynb b/climada_petals/engine/cat_bonds/climada_engine_CATBonds.ipynb
similarity index 100%
rename from climada_petals/engine/cat_bonds/tutorial.ipynb
rename to climada_petals/engine/cat_bonds/climada_engine_CATBonds.ipynb

From 9166134026ce58cc8fcfc5db134d267b26c4f82d Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Thu, 27 Nov 2025 16:56:49 +0100
Subject: [PATCH 068/125] initialize subareas with resolution

---
 climada_petals/engine/cat_bonds/subareas.py | 412 +++++++++-----------
 1 file changed, 194 insertions(+), 218 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/subareas.py b/climada_petals/engine/cat_bonds/subareas.py
index 5e01871a3..64f8c4bbf 100644
--- a/climada_petals/engine/cat_bonds/subareas.py
+++ b/climada_petals/engine/cat_bonds/subareas.py
@@ -44,27 +44,26 @@ def __init__(
         hazard,
         vulnerability,
         exposure,
-        resolution,
+        subareas_gdf,
     ):
 
         self.hazard = hazard
         self.vulnerability = vulnerability
         self._exposure = exposure
-        self._resolution = resolution
+        self.subareas_gdf = subareas_gdf
 
-    def build_subareas(self):
-        """Calculate subareas and islands."""
-        self.subareas_gdf = self._init_subareas()
+    @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)
 
     # --- Properties ---
     @property
     def exposure(self):
         return self._exposure
 
-    @property
-    def resolution(self):
-        return self._resolution
-
     def plot(self):
         if self.subareas_gdf is None:
             raise ValueError("Subareas have not been generated yet.")
@@ -111,235 +110,212 @@ def count_subareas(self):
         else:
             return len(self.subareas_gdf)
 
-    def _init_subareas(self):
-
+    @staticmethod
+    def _init_subareas(exposure, resolution):
         """
         Divides the exposure set into subareas and returns a geodataframe for the perimeter of exposed assets.
 
         Parameters
         ----------
-        self : class instance
-            Instance of the Subareas class.
+        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 : GeoDataFrame
-            Geodataframe of the exposure perimeter.
         """
-        exp_gdf = self._create_exp_gdf()
+        exp_gdf = _create_exp_gdf(exposure)
         logging.info("Number of polygons in exposure perimeter: %d", len(exp_gdf))
         exp_gdf = exp_gdf.explode(ignore_index=True, index_parts=True)
-
-        subareas_gdf = self._crop_grid_cells_to_polygon(
-            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(self, exp_gdf):
-
-        """
-        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
-
+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(
-                f"Processing polygon with bounds: {minx}, {miny}, {maxx}, {maxy}"
+                "Polygon smaller than resolution; adding polygon bounding box."
             )
-            if maxx - minx < self._resolution or maxy - miny < self._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) / self._resolution) + 1
-            num_cells_y = int((maxy - miny) / self._resolution) + 1
-            n_cols = int(np.ceil((maxx - minx) / self._resolution))
-            n_rows = int(np.ceil((maxy - miny) / self._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 * self._resolution
-                    y1 = miny + y * self._resolution
-                    x2 = x1 + self._resolution
-                    y2 = y1 + self._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 self.exposure.gdf.geometry):
-                        grid_cells.append(grid_cell)
-
-            grid_gdf = gpd.GeoDataFrame(
-                grid_cells, columns=["geometry"], crs=exp_gdf.crs
+            # 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)
             )
-
-            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 = self._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(self):
-
-        """
-        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 = self._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}")
+            continue
         
-        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",
+        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
         )
 
-        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)
-        LOGGER.info("Exposure perimeter polygon created.")
-
-        return exp_gdf
-
-    def _merge_overlapping_grids(self, 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
+        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)
+    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

From e5d2d47bbbf9d1912ba5fa2cf5beab6516696807 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Thu, 27 Nov 2025 17:07:39 +0100
Subject: [PATCH 069/125] initiate subareas by resolution

---
 .../cat_bonds/climada_engine_CATBonds.ipynb   | 175 +++++++++---------
 1 file changed, 86 insertions(+), 89 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/climada_engine_CATBonds.ipynb b/climada_petals/engine/cat_bonds/climada_engine_CATBonds.ipynb
index 3b5e49a6e..8bec4a61e 100644
--- a/climada_petals/engine/cat_bonds/climada_engine_CATBonds.ipynb
+++ b/climada_petals/engine/cat_bonds/climada_engine_CATBonds.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "id": "48c2d418",
    "metadata": {},
    "outputs": [],
@@ -32,7 +32,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 2,
    "id": "89b53a88",
    "metadata": {},
    "outputs": [],
@@ -78,9 +78,9 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-21 15:59:53,987 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
-      "2025-11-21 15:59:54,049 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
-      "2025-11-21 15:59:54,110 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n"
+      "2025-11-27 16:54:34,915 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
+      "2025-11-27 16:54:34,987 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
+      "2025-11-27 16:54:35,055 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n"
      ]
     },
     {
@@ -94,27 +94,27 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-21 16:00:00,772 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
-      "2025-11-21 16:00:00,890 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 546 coastal centroids.\n",
-      "2025-11-21 16:00:01,514 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
-      "2025-11-21 16:00:02,107 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
-      "2025-11-21 16:00:02,718 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
-      "2025-11-21 16:00:03,193 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
-      "2025-11-21 16:00:03,753 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
-      "2025-11-21 16:00:04,491 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
-      "2025-11-21 16:00:05,091 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
-      "2025-11-21 16:00:05,652 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
-      "2025-11-21 16:00:06,040 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
-      "2025-11-21 16:00:07,209 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      "2025-11-27 16:54:40,760 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
+      "2025-11-27 16:54:40,855 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 546 coastal centroids.\n",
+      "2025-11-27 16:54:41,198 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
+      "2025-11-27 16:54:41,510 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
+      "2025-11-27 16:54:41,875 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
+      "2025-11-27 16:54:42,252 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
+      "2025-11-27 16:54:42,608 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
+      "2025-11-27 16:54:43,081 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
+      "2025-11-27 16:54:44,007 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
+      "2025-11-27 16:54:45,668 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
+      "2025-11-27 16:54:46,105 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
+      "2025-11-27 16:54:48,355 - climada.entity.exposures.litpop.litpop - INFO - \n",
       " LitPop: Init Exposure for country: KNA (659)...\n",
       "\n",
-      "2025-11-21 16:00:07,265 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-21 16:00:07,969 - climada.util.finance - INFO - GDP KNA 2020: 8.839e+08.\n",
-      "2025-11-21 16:00:07,992 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
-      "2025-11-21 16:00:07,993 - climada.entity.exposures.base - INFO - category_id not set.\n",
-      "2025-11-21 16:00:07,993 - climada.entity.exposures.base - INFO - cover not set.\n",
-      "2025-11-21 16:00:07,994 - climada.entity.exposures.base - INFO - deductible not set.\n",
-      "2025-11-21 16:00:07,994 - climada.entity.exposures.base - INFO - centr_ not set.\n"
+      "2025-11-27 16:54:48,452 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-27 16:54:49,631 - climada.util.finance - INFO - GDP KNA 2020: 8.839e+08.\n",
+      "2025-11-27 16:54:49,655 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+      "2025-11-27 16:54:49,655 - climada.entity.exposures.base - INFO - category_id not set.\n",
+      "2025-11-27 16:54:49,656 - climada.entity.exposures.base - INFO - cover not set.\n",
+      "2025-11-27 16:54:49,658 - climada.entity.exposures.base - INFO - deductible not set.\n",
+      "2025-11-27 16:54:49,659 - climada.entity.exposures.base - INFO - centr_ not set.\n"
      ]
     }
    ],
@@ -159,29 +159,29 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-21 16:00:09,959 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
-      "2025-11-21 16:00:10,006 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
-      "2025-11-21 16:00:10,045 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
-      "2025-11-21 16:00:13,021 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
-      "2025-11-21 16:00:13,065 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 7938 coastal centroids.\n",
-      "2025-11-21 16:00:23,029 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
-      "2025-11-21 16:00:27,883 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
-      "2025-11-21 16:00:33,102 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
-      "2025-11-21 16:00:39,542 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
-      "2025-11-21 16:00:45,759 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
-      "2025-11-21 16:00:52,034 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
-      "2025-11-21 16:00:57,008 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
-      "2025-11-21 16:01:05,721 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
-      "2025-11-21 16:01:08,980 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
-      "2025-11-21 16:01:13,102 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      "2025-11-27 16:54:51,793 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
+      "2025-11-27 16:54:51,852 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
+      "2025-11-27 16:54:51,886 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
+      "2025-11-27 16:54:55,165 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
+      "2025-11-27 16:54:55,207 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 7938 coastal centroids.\n",
+      "2025-11-27 16:55:02,894 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
+      "2025-11-27 16:55:11,155 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
+      "2025-11-27 16:55:19,222 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
+      "2025-11-27 16:55:25,735 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
+      "2025-11-27 16:55:30,128 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
+      "2025-11-27 16:55:34,931 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
+      "2025-11-27 16:55:38,579 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
+      "2025-11-27 16:55:43,673 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
+      "2025-11-27 16:55:45,448 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
+      "2025-11-27 16:55:47,848 - climada.entity.exposures.litpop.litpop - INFO - \n",
       " LitPop: Init Exposure for country: JAM (388)...\n",
       "\n",
-      "2025-11-21 16:01:13,560 - climada.util.finance - INFO - GDP JAM 2020: 1.381e+10.\n",
-      "2025-11-21 16:01:13,591 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
-      "2025-11-21 16:01:13,591 - climada.entity.exposures.base - INFO - category_id not set.\n",
-      "2025-11-21 16:01:13,591 - climada.entity.exposures.base - INFO - cover not set.\n",
-      "2025-11-21 16:01:13,592 - climada.entity.exposures.base - INFO - deductible not set.\n",
-      "2025-11-21 16:01:13,593 - climada.entity.exposures.base - INFO - centr_ not set.\n"
+      "2025-11-27 16:55:59,642 - climada.util.finance - INFO - GDP JAM 2020: 1.381e+10.\n",
+      "2025-11-27 16:55:59,677 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+      "2025-11-27 16:55:59,678 - climada.entity.exposures.base - INFO - category_id not set.\n",
+      "2025-11-27 16:55:59,678 - climada.entity.exposures.base - INFO - cover not set.\n",
+      "2025-11-27 16:55:59,679 - climada.entity.exposures.base - INFO - deductible not set.\n",
+      "2025-11-27 16:55:59,680 - climada.entity.exposures.base - INFO - centr_ not set.\n"
      ]
     }
    ],
@@ -217,7 +217,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 5,
    "id": "c42eed8b",
    "metadata": {},
    "outputs": [
@@ -225,38 +225,38 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-21 16:24:16,897 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
-      "2025-11-21 16:24:17,170 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
-      "2025-11-21 16:24:17,246 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
-      "2025-11-21 16:24:20,411 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
-      "2025-11-21 16:24:20,595 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 16463 coastal centroids.\n",
-      "2025-11-21 16:24:36,868 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
-      "2025-11-21 16:24:48,134 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
-      "2025-11-21 16:25:01,556 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
-      "2025-11-21 16:25:14,041 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
-      "2025-11-21 16:25:24,325 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
-      "2025-11-21 16:25:32,434 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
-      "2025-11-21 16:25:41,287 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
-      "2025-11-21 16:25:49,288 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
-      "2025-11-21 16:25:54,137 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
-      "2025-11-21 16:25:59,806 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      "2025-11-27 16:56:02,011 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
+      "2025-11-27 16:56:02,091 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
+      "2025-11-27 16:56:02,127 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
+      "2025-11-27 16:56:04,973 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
+      "2025-11-27 16:56:05,036 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 16463 coastal centroids.\n",
+      "2025-11-27 16:56:12,772 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
+      "2025-11-27 16:56:20,487 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
+      "2025-11-27 16:56:28,147 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
+      "2025-11-27 16:56:37,256 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
+      "2025-11-27 16:56:47,310 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
+      "2025-11-27 16:56:57,107 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
+      "2025-11-27 16:57:06,706 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
+      "2025-11-27 16:57:18,615 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
+      "2025-11-27 16:57:23,268 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
+      "2025-11-27 16:57:27,974 - climada.entity.exposures.litpop.litpop - INFO - \n",
       " LitPop: Init Exposure for country: BLZ (84)...\n",
       "\n",
-      "2025-11-21 16:26:00,575 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-21 16:26:00,606 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-21 16:26:00,783 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-21 16:26:00,812 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-21 16:26:00,849 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-21 16:26:00,877 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-21 16:26:00,952 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-21 16:26:00,977 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-21 16:26:01,024 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-21 16:26:01,666 - climada.util.finance - INFO - GDP BLZ 2020: 2.043e+09.\n",
-      "2025-11-21 16:26:01,808 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
-      "2025-11-21 16:26:01,836 - climada.entity.exposures.base - INFO - category_id not set.\n",
-      "2025-11-21 16:26:01,838 - climada.entity.exposures.base - INFO - cover not set.\n",
-      "2025-11-21 16:26:01,847 - climada.entity.exposures.base - INFO - deductible not set.\n",
-      "2025-11-21 16:26:01,851 - climada.entity.exposures.base - INFO - centr_ not set.\n"
+      "2025-11-27 16:57:28,274 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-27 16:57:28,297 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-27 16:57:28,330 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-27 16:57:28,347 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-27 16:57:28,367 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-27 16:57:28,385 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-27 16:57:28,419 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-27 16:57:28,436 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-27 16:57:28,453 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-27 16:57:35,994 - climada.util.finance - INFO - GDP BLZ 2020: 2.043e+09.\n",
+      "2025-11-27 16:57:36,062 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+      "2025-11-27 16:57:36,063 - climada.entity.exposures.base - INFO - category_id not set.\n",
+      "2025-11-27 16:57:36,063 - climada.entity.exposures.base - INFO - cover not set.\n",
+      "2025-11-27 16:57:36,064 - climada.entity.exposures.base - INFO - deductible not set.\n",
+      "2025-11-27 16:57:36,065 - climada.entity.exposures.base - INFO - centr_ not set.\n"
      ]
     }
    ],
@@ -300,7 +300,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "id": "09fba021",
    "metadata": {},
    "outputs": [
@@ -308,12 +308,12 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-21 18:36:44,599 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+      "2025-11-27 16:57:42,838 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 900x1300 with 2 Axes>"
       ]
@@ -325,12 +325,12 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-21 18:37:08,081 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+      "2025-11-27 16:58:05,202 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 900x1300 with 2 Axes>"
       ]
@@ -342,12 +342,12 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-21 18:37:23,621 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+      "2025-11-27 16:58:23,466 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 900x1300 with 2 Axes>"
       ]
@@ -357,12 +357,9 @@
     }
    ],
    "source": [
-    "st_kitts_subareas = Subareas(tc_irma, impfset, exp_kit, resolution=resolution_st_kitts)\n",
-    "st_kitts_subareas.build_subareas()\n",
-    "jamaica_subareas = Subareas(tc_melissa, impfset, exp_jam, resolution=resolution_jamaica)\n",
-    "jamaica_subareas.build_subareas()\n",
-    "belize_subareas = Subareas(tc_keith, impfset, exp_bel, resolution=resolution_belize)\n",
-    "belize_subareas.build_subareas()\n",
+    "st_kitts_subareas = Subareas.from_resolution(tc_irma, impfset, exp_kit, resolution=resolution_st_kitts)\n",
+    "jamaica_subareas = Subareas.from_resolution(tc_melissa, impfset, exp_jam, resolution=resolution_jamaica)\n",
+    "belize_subareas = Subareas.from_resolution(tc_keith, impfset, exp_bel, resolution=resolution_belize)\n",
     "jamaica_subareas.plot()\n",
     "st_kitts_subareas.plot()\n",
     "belize_subareas.plot()"

From 5abe3c113762ec7f1ccfb1b2f440187e7f7d816e Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Thu, 27 Nov 2025 17:49:31 +0100
Subject: [PATCH 070/125] implement pooling n pools

---
 .../cat_bonds/climada_engine_CATBonds.ipynb   | 99 +++++++++++++++----
 .../engine/cat_bonds/pooling_functions.py     | 37 ++++---
 2 files changed, 100 insertions(+), 36 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/climada_engine_CATBonds.ipynb b/climada_petals/engine/cat_bonds/climada_engine_CATBonds.ipynb
index 8bec4a61e..0f3fe7141 100644
--- a/climada_petals/engine/cat_bonds/climada_engine_CATBonds.ipynb
+++ b/climada_petals/engine/cat_bonds/climada_engine_CATBonds.ipynb
@@ -2,10 +2,19 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 20,
    "id": "48c2d418",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The autoreload extension is already loaded. To reload it, use:\n",
+      "  %reload_ext autoreload\n"
+     ]
+    }
+   ],
    "source": [
     "%load_ext autoreload\n",
     "%autoreload 2\n",
@@ -15,6 +24,7 @@
     "from sng_bond_simulation import SingleCountryBondSimulation\n",
     "from mlt_bond_simulation import MultiCountryBondSimulation\n",
     "from premium_class import PremiumCalculations\n",
+    "import pooling_functions as pf\n",
     "\n",
     "from climada.hazard import TCTracks, Centroids, TropCyclone\n",
     "from climada.entity import LitPop\n",
@@ -375,7 +385,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 9,
    "id": "ac344ab3",
    "metadata": {},
    "outputs": [
@@ -383,19 +393,15 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-21 18:39:14,452 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n",
-      "2025-11-21 18:39:14,454 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n",
-      "2025-11-21 18:39:14,456 - climada.entity.exposures.base - INFO - Matching 328 exposures with 546 centroids.\n",
-      "2025-11-21 18:39:14,468 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
-      "2025-11-21 18:39:14,479 - climada.engine.impact_calc - INFO - Calculating impact for 984 assets (>0) and 51 events.\n",
-      "2025-11-21 18:39:16,808 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n",
-      "2025-11-21 18:39:16,809 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n",
-      "2025-11-21 18:39:16,810 - climada.entity.exposures.base - INFO - Matching 13552 exposures with 7938 centroids.\n",
-      "2025-11-21 18:39:16,859 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
-      "2025-11-21 18:39:16,962 - climada.engine.impact_calc - INFO - Calculating impact for 40503 assets (>0) and 51 events.\n",
-      "2025-11-21 18:39:18,171 - climada.entity.exposures.base - INFO - Matching 27265 exposures with 16463 centroids.\n",
-      "2025-11-21 18:39:18,372 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
-      "2025-11-21 18:39:18,580 - climada.engine.impact_calc - INFO - Calculating impact for 81177 assets (>0) and 51 events.\n"
+      "2025-11-27 17:21:27,069 - climada.entity.exposures.base - INFO - Matching 328 exposures with 546 centroids.\n",
+      "2025-11-27 17:21:27,096 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
+      "2025-11-27 17:21:27,124 - climada.engine.impact_calc - INFO - Calculating impact for 984 assets (>0) and 51 events.\n",
+      "2025-11-27 17:21:29,349 - climada.entity.exposures.base - INFO - Matching 13552 exposures with 7938 centroids.\n",
+      "2025-11-27 17:21:29,388 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
+      "2025-11-27 17:21:29,446 - climada.engine.impact_calc - INFO - Calculating impact for 40503 assets (>0) and 51 events.\n",
+      "2025-11-27 17:21:30,538 - climada.entity.exposures.base - INFO - Matching 27265 exposures with 16463 centroids.\n",
+      "2025-11-27 17:21:30,594 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
+      "2025-11-27 17:21:30,745 - climada.engine.impact_calc - INFO - Calculating impact for 81177 assets (>0) and 51 events.\n"
      ]
     }
    ],
@@ -418,7 +424,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "id": "4ead6e69",
    "metadata": {},
    "outputs": [
@@ -465,7 +471,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
    "id": "6cfb9d55",
    "metadata": {},
    "outputs": [
@@ -512,7 +518,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "id": "4e590bad",
    "metadata": {},
    "outputs": [
@@ -566,7 +572,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 13,
    "id": "67403f5f",
    "metadata": {},
    "outputs": [
@@ -611,6 +617,59 @@
     "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": 22,
+   "id": "6d1432f4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "171\n",
+      "171\n",
+      "171\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(len(st_kitts_bond_sim.df_loss_month))\n",
+    "print(len(jamaica_bond_sim.df_loss_month))\n",
+    "print(len(belize_bond_sim.df_loss_month))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "7f7e0ab3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "171 171 171\n",
+      "[441961111.11111087, 6906210917.868449, 1021425000.0000002]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(   659  388  84  min_conc\n",
+       " 0    2    2   1     0.805,\n",
+       " <pymoo.core.result.Result at 0x145c56c10>)"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pf.process_n(2, countries, [st_kitts_bond_sim, jamaica_bond_sim, belize_bond_sim], n_opt_rep=3)"
+   ]
   }
  ],
  "metadata": {
diff --git a/climada_petals/engine/cat_bonds/pooling_functions.py b/climada_petals/engine/cat_bonds/pooling_functions.py
index b426d65d6..7cd684a19 100644
--- a/climada_petals/engine/cat_bonds/pooling_functions.py
+++ b/climada_petals/engine/cat_bonds/pooling_functions.py
@@ -1,4 +1,3 @@
-'''Risk pooling optimization functions adapted from Ciullo et al., 2022'''
 import numpy as np
 from math import comb
 from pymoo.core.problem import ElementwiseProblem
@@ -11,22 +10,21 @@
 from pymoo.optimize import minimize
 from pymoo.operators.repair.rounding import RoundingRepair
 
-def process_n(n, cntry_names, sng_ann_losses, principal_sng_dic, n_opt_rep=100):
+def process_n(n, 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.
-    cntry_names : list of str
-        List of country names corresponding to the columns in the loss data.
-    sng_ann_losses : pandas.DataFrame
-        Dataframe of annual loss data for each country.
-    principal_sng_dic : dict
-        Principal values for each country.
+    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
@@ -34,21 +32,27 @@ def process_n(n, cntry_names, sng_ann_losses, principal_sng_dic, n_opt_rep=100):
     algorithm_result: pymoo.core.result.Result
         Result object from the optimization containing details of the optimization process.
     """
-    opt_rep = range(0,n_opt_rep,1)
-    df_losses = pd.DataFrame(sng_ann_losses)
 
-    ### TRANSFROM PRINCIPAL VALUES TO LIST ###
-    principal_sng = principal_sng_dic.set_index('Key').loc[cntry_names, 'Value'].tolist()
+    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[cntry_names[0]])
+    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
+    print(opt_rep)
     for index in opt_rep:
+        print(f"Starting optimization repetition {index+1}/{n_opt_rep}...")
         # Define Problem and Algorithm (same as inside the loop)
         problem = PoolOptimizationFixedNumber(principal_sng, df_losses, bools, alpha, n, calc_pool_conc)
         algorithm = GA(
@@ -65,6 +69,7 @@ def process_n(n, cntry_names, sng_ann_losses, principal_sng_dic, n_opt_rep=100):
         # Process results (same code as inside the loop)
         x = res_reg.X
         risk_concentration_new = res_reg.F
+        print(f"Optimization repetition {index+1}/{n_opt_rep}, Risk Concentration: {risk_concentration_new}")
         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
@@ -73,11 +78,11 @@ def process_n(n, cntry_names, sng_ann_losses, principal_sng_dic, n_opt_rep=100):
             x = [rank_dict[value] for value in x]
 
             # Add to dump dataframe
-            country_allocation = pd.DataFrame(columns=[cntry_names, 'min_conc'])
-            country_allocation = pd.DataFrame([x], columns=cntry_names)
+            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
+    return country_allocation, algorithm_result
 
 
 

From d8f70a0afcca5c0e5c41ea430c133c9044848e24 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 28 Nov 2025 09:55:26 +0100
Subject: [PATCH 071/125] initialise class with optimized n pools

---
 .../engine/cat_bonds/mlt_bond_simulation.py   | 84 ++++++++++++++-----
 1 file changed, 65 insertions(+), 19 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
index 367ba0ca7..3eda90036 100644
--- a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
@@ -3,17 +3,16 @@
 import logging
 
 from utils_cat_bonds import multi_level_es, allocate_single_payout
+import pooling_functions as pf
 
 LOGGER = logging.getLogger(__name__)
 
 class MultiCountryBondSimulation:
 
-    def __init__(self, subarea_calc_list, countries_list, term, number_of_terms, tranches):
-        self.countries = countries_list
+    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.tranches = tranches
-        self.subarea_calc = subarea_calc_list
         self._prepare_data()
 
 
@@ -21,11 +20,12 @@ def __init__(self, subarea_calc_list, countries_list, term, number_of_terms, tra
     def _prepare_data(self):
         self.pay_vs_dam_dic = {}
         self.principal_dic_cty = {}
+        self.countries = list(self.country_dictionary.keys())
         min_year_list = []
-        for idx, cty in enumerate(self.countries):
-            self.pay_vs_dam_dic[cty] = self.subarea_calc[idx].pay_vs_dam
-            self.principal_dic_cty[cty] = self.subarea_calc[idx].principal
-            min_year_list.append(self.subarea_calc[idx].pay_vs_dam['year'].min())
+        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)
 
@@ -33,6 +33,52 @@ def _prepare_data(self):
         
 
 
+    @classmethod
+    def simulate_bond_pool_n(cls, country_dictionary, term, number_of_terms, principal, n, n_opt_rep=100):
+        """
+        Class method to create an instance of MultiCountryBondSimulation and run the loss simulation.
+
+        Parameters
+        ----------
+        n : int
+            Number of countries to include in the pool.
+        subarea_calc_list : list
+            List of subarea_calc instances for each country.
+        countries_list : list
+            List of country codes.
+        term : int
+            Term of the bond in years.
+        number_of_terms : int
+            Number of terms to simulate.
+        tranches : list
+            List of tranche nominal values.
+        principal : float
+            Total principal value of the bond.
+
+        Returns
+        -------
+        bond_simulation : MultiCountryBondSimulation
+            Instance of MultiCountryBondSimulation with simulated losses.
+        """
+        countries_list = list(country_dictionary.keys())
+        cls_bond_simulation = [country_dictionary[cty] for cty in countries_list]
+        pool_allocation, algorithm_result = pf.process_n(n, 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)
+
+        mlt_bond_simulation_dic = {}
+        for key, countries in pool_dict:
+            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)
+
+        return mlt_bond_simulation_dic[key], pool_allocation, algorithm_result
+
+
 
     '''Simulate one term of bond to derive losses'''
     def _init_bond_loss(self, events_per_year, principal):
@@ -305,7 +351,7 @@ def init_return_simulation(self, premium, rf=0.0):
 
   
     '''reduced function to derive returns of the bond -> was used to save time during calculation'''
-    def init_return_simulation_tranches(self, premiums, rf=0.0):
+    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, 
@@ -336,27 +382,27 @@ def init_return_simulation_tranches(self, premiums, rf=0.0):
         - Losses are allocated to tranches in reverse order (from highest to lowest risk).
         """
 
-        ncf = {str(tranche): [] for tranche in self.tranches}
+        ncf = {str(tranche): [] for tranche in tranches}
         premiums_tot = []
-        cur_nominal_tranches = self.tranches.copy()
+        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(self.tranches):
+                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 self.tranches}
+                ncf_tmp = {str(tranche): [] for tranche in tranches}
                 prem_it_alt = 0
                 premiums_tot_tmp = []
-                for k, tranche in enumerate(self.tranches):
+                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(self.tranches))  # accumulate over all events in this period
+                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]
@@ -365,21 +411,21 @@ def init_return_simulation_tranches(self, premiums, rf=0.0):
                     if j + 1 < len(losses):
                         nex_month = months[j+1]
                         prem_it_alt = 0
-                        for k, tranche in enumerate(self.tranches):
+                        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(self.tranches):
+                        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(self.tranches):
+                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 = self.tranches.copy()
+                cur_nominal_tranches = tranches.copy()
 
         prem_cty_dic = {country: [] for country in self.tot_coverage_cty}
         for country in prem_cty_dic:

From fc1a62f85a78b79a76391665b003d5a3f3ed369b Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 28 Nov 2025 09:56:22 +0100
Subject: [PATCH 072/125] rename n to n_pools

---
 climada_petals/engine/cat_bonds/mlt_bond_simulation.py | 4 ++--
 climada_petals/engine/cat_bonds/pooling_functions.py   | 8 +++-----
 2 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
index 3eda90036..83413433b 100644
--- a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
@@ -34,7 +34,7 @@ def _prepare_data(self):
 
 
     @classmethod
-    def simulate_bond_pool_n(cls, country_dictionary, term, number_of_terms, principal, n, n_opt_rep=100):
+    def simulate_bond_pool_n(cls, country_dictionary, term, number_of_terms, principal, number_pools, n_opt_rep=100):
         """
         Class method to create an instance of MultiCountryBondSimulation and run the loss simulation.
 
@@ -62,7 +62,7 @@ def simulate_bond_pool_n(cls, country_dictionary, term, number_of_terms, princip
         """
         countries_list = list(country_dictionary.keys())
         cls_bond_simulation = [country_dictionary[cty] for cty in countries_list]
-        pool_allocation, algorithm_result = pf.process_n(n, countries_list, cls_bond_simulation, n_opt_rep=n_opt_rep)
+        pool_allocation, algorithm_result = pf.process_n(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:
diff --git a/climada_petals/engine/cat_bonds/pooling_functions.py b/climada_petals/engine/cat_bonds/pooling_functions.py
index 7cd684a19..669c2fd99 100644
--- a/climada_petals/engine/cat_bonds/pooling_functions.py
+++ b/climada_petals/engine/cat_bonds/pooling_functions.py
@@ -10,7 +10,7 @@
 from pymoo.optimize import minimize
 from pymoo.operators.repair.rounding import RoundingRepair
 
-def process_n(n, countries, cls_bond_simulations, n_opt_rep=100):
+def process_n(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.
@@ -50,11 +50,9 @@ def process_n(n, countries, cls_bond_simulations, n_opt_rep=100):
 
     risk_concentration = 1.0
     # Loop through repetitions for seed analysis
-    print(opt_rep)
     for index in opt_rep:
-        print(f"Starting optimization repetition {index+1}/{n_opt_rep}...")
         # Define Problem and Algorithm (same as inside the loop)
-        problem = PoolOptimizationFixedNumber(principal_sng, df_losses, bools, alpha, n, calc_pool_conc)
+        problem = PoolOptimizationFixedNumber(principal_sng, df_losses, bools, alpha, number_pools, calc_pool_conc)
         algorithm = GA(
             pop_size=2000,
             sampling=IntegerRandomSampling(),
@@ -69,7 +67,6 @@ def process_n(n, countries, cls_bond_simulations, n_opt_rep=100):
         # Process results (same code as inside the loop)
         x = res_reg.X
         risk_concentration_new = res_reg.F
-        print(f"Optimization repetition {index+1}/{n_opt_rep}, Risk Concentration: {risk_concentration_new}")
         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
@@ -82,6 +79,7 @@ def process_n(n, countries, cls_bond_simulations, n_opt_rep=100):
             country_allocation = pd.DataFrame([x], columns=countries)
             country_allocation['min_conc'] = pd.DataFrame([res_reg.F], columns=['min_conc'])
 
+    # Optionally, you can return pool_dict as well if needed
     return country_allocation, algorithm_result
 
 

From 71864180522eb277ad50c3de68573a5e3d132122 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 28 Nov 2025 09:57:53 +0100
Subject: [PATCH 073/125] rename fct process_n to process_n_pools

---
 climada_petals/engine/cat_bonds/mlt_bond_simulation.py | 2 +-
 climada_petals/engine/cat_bonds/pooling_functions.py   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
index 83413433b..99a4c5146 100644
--- a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
@@ -62,7 +62,7 @@ def simulate_bond_pool_n(cls, country_dictionary, term, number_of_terms, princip
         """
         countries_list = list(country_dictionary.keys())
         cls_bond_simulation = [country_dictionary[cty] for cty in countries_list]
-        pool_allocation, algorithm_result = pf.process_n(number_pools, countries_list, cls_bond_simulation, n_opt_rep=n_opt_rep)
+        pool_allocation, algorithm_result = pf.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:
diff --git a/climada_petals/engine/cat_bonds/pooling_functions.py b/climada_petals/engine/cat_bonds/pooling_functions.py
index 669c2fd99..1cc161a51 100644
--- a/climada_petals/engine/cat_bonds/pooling_functions.py
+++ b/climada_petals/engine/cat_bonds/pooling_functions.py
@@ -10,7 +10,7 @@
 from pymoo.optimize import minimize
 from pymoo.operators.repair.rounding import RoundingRepair
 
-def process_n(number_pools, countries, cls_bond_simulations, n_opt_rep=100):
+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.

From 62e4808f14d2f4f2e12957fffcf30900c82401f1 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 28 Nov 2025 10:03:58 +0100
Subject: [PATCH 074/125] add maximum principal wrapper function

---
 .../engine/cat_bonds/pooling_functions.py     | 73 ++++++++++++++++++-
 1 file changed, 72 insertions(+), 1 deletion(-)

diff --git a/climada_petals/engine/cat_bonds/pooling_functions.py b/climada_petals/engine/cat_bonds/pooling_functions.py
index 1cc161a51..227d6ee48 100644
--- a/climada_petals/engine/cat_bonds/pooling_functions.py
+++ b/climada_petals/engine/cat_bonds/pooling_functions.py
@@ -79,7 +79,78 @@ def process_n_pools(number_pools, countries, cls_bond_simulations, n_opt_rep=100
             country_allocation = pd.DataFrame([x], columns=countries)
             country_allocation['min_conc'] = pd.DataFrame([res_reg.F], columns=['min_conc'])
 
-    # Optionally, you can return pool_dict as well if needed
+    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
 
 

From f5c774b94efa41fc31b2081294e277d881d93ff7 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 28 Nov 2025 10:25:42 +0100
Subject: [PATCH 075/125] fix iterration bug

---
 climada_petals/engine/cat_bonds/mlt_bond_simulation.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
index 99a4c5146..952085bb9 100644
--- a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
@@ -65,12 +65,15 @@ def simulate_bond_pool_n(cls, country_dictionary, term, number_of_terms, princip
         pool_allocation, algorithm_result = pf.process_n_pools(number_pools, countries_list, cls_bond_simulation, n_opt_rep=n_opt_rep)
         pool_dict = {}
         for cty in countries_list:
+            print(cty)
             if pool_dict.get(pool_allocation[cty][0]) is None:
                 pool_dict[pool_allocation[cty][0]] = []
             pool_dict[pool_allocation[cty][0]].append(cty)
+            print(pool_dict)
 
         mlt_bond_simulation_dic = {}
-        for key, countries in pool_dict:
+        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)

From 5e14044775040025436e81c8c31e5fd58cd5631d Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 28 Nov 2025 10:28:09 +0100
Subject: [PATCH 076/125] return whole dictionary conatining multiple class
 instances

---
 climada_petals/engine/cat_bonds/mlt_bond_simulation.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
index 952085bb9..803cb0932 100644
--- a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
@@ -79,7 +79,7 @@ def simulate_bond_pool_n(cls, country_dictionary, term, number_of_terms, princip
             mlt_bond_simulation_dic[key] = cls(pool_country_dictionary, term, number_of_terms)
             mlt_bond_simulation_dic[key].init_loss_simulation(principal)
 
-        return mlt_bond_simulation_dic[key], pool_allocation, algorithm_result
+        return mlt_bond_simulation_dic, pool_allocation, algorithm_result
 
 
 

From b311758d12a300ed71402227fed0999a061eace9 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 28 Nov 2025 10:31:51 +0100
Subject: [PATCH 077/125] add logging to simulate_bond_pool_n

---
 climada_petals/engine/cat_bonds/mlt_bond_simulation.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
index 803cb0932..bfc39693a 100644
--- a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
@@ -60,16 +60,16 @@ def simulate_bond_pool_n(cls, country_dictionary, term, number_of_terms, princip
         bond_simulation : MultiCountryBondSimulation
             Instance of MultiCountryBondSimulation with simulated losses.
         """
+        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 = pf.process_n_pools(number_pools, countries_list, cls_bond_simulation, n_opt_rep=n_opt_rep)
         pool_dict = {}
         for cty in countries_list:
-            print(cty)
             if pool_dict.get(pool_allocation[cty][0]) is None:
                 pool_dict[pool_allocation[cty][0]] = []
             pool_dict[pool_allocation[cty][0]].append(cty)
-            print(pool_dict)
+        LOGGER.info("Completed pooling optimization.")
 
         mlt_bond_simulation_dic = {}
         for key, countries in pool_dict.items():
@@ -78,6 +78,7 @@ def simulate_bond_pool_n(cls, country_dictionary, term, number_of_terms, princip
             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
 

From b262e71103cdcdd3d453da683a5a147a080624e1 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 28 Nov 2025 10:38:52 +0100
Subject: [PATCH 078/125] add max_principal pooling optimization function

---
 .../engine/cat_bonds/mlt_bond_simulation.py   | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
index bfc39693a..1f234bb4a 100644
--- a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
@@ -81,6 +81,54 @@ def simulate_bond_pool_n(cls, country_dictionary, term, number_of_terms, princip
             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 create an instance of MultiCountryBondSimulation and run the loss simulation.
+
+        Parameters
+        ----------
+        n : int
+            Number of countries to include in the pool.
+        subarea_calc_list : list
+            List of subarea_calc instances for each country.
+        countries_list : list
+            List of country codes.
+        term : int
+            Term of the bond in years.
+        number_of_terms : int
+            Number of terms to simulate.
+        tranches : list
+            List of tranche nominal values.
+        principal : float
+            Total principal value of the bond.
+
+        Returns
+        -------
+        bond_simulation : MultiCountryBondSimulation
+            Instance of MultiCountryBondSimulation with simulated losses.
+        """
+        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 = pf.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
 
 
 

From 4dbea02b39c961c91cbd17a4c8a94cfd37fb8d69 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 28 Nov 2025 10:39:06 +0100
Subject: [PATCH 079/125] adapt to changes in mlt_cty_bond

---
 .../cat_bonds/climada_engine_CATBonds.ipynb   | 307 ++++++++++--------
 1 file changed, 178 insertions(+), 129 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/climada_engine_CATBonds.ipynb b/climada_petals/engine/cat_bonds/climada_engine_CATBonds.ipynb
index 0f3fe7141..b112e6c79 100644
--- a/climada_petals/engine/cat_bonds/climada_engine_CATBonds.ipynb
+++ b/climada_petals/engine/cat_bonds/climada_engine_CATBonds.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 8,
    "id": "48c2d418",
    "metadata": {},
    "outputs": [
@@ -42,7 +42,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 9,
    "id": "89b53a88",
    "metadata": {},
    "outputs": [],
@@ -80,7 +80,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 10,
    "id": "a51eb038",
    "metadata": {},
    "outputs": [
@@ -88,43 +88,30 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-27 16:54:34,915 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
-      "2025-11-27 16:54:34,987 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
-      "2025-11-27 16:54:35,055 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "<string>:7: FutureWarning: 'H' is deprecated and will be removed in a future version. Please use 'h' instead of 'H'.\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "2025-11-27 16:54:40,760 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
-      "2025-11-27 16:54:40,855 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 546 coastal centroids.\n",
-      "2025-11-27 16:54:41,198 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
-      "2025-11-27 16:54:41,510 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
-      "2025-11-27 16:54:41,875 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
-      "2025-11-27 16:54:42,252 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
-      "2025-11-27 16:54:42,608 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
-      "2025-11-27 16:54:43,081 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
-      "2025-11-27 16:54:44,007 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
-      "2025-11-27 16:54:45,668 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
-      "2025-11-27 16:54:46,105 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
-      "2025-11-27 16:54:48,355 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      "2025-11-28 10:04:14,222 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
+      "2025-11-28 10:04:14,317 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
+      "2025-11-28 10:04:14,417 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
+      "2025-11-28 10:04:17,972 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
+      "2025-11-28 10:04:18,027 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 546 coastal centroids.\n",
+      "2025-11-28 10:04:18,393 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
+      "2025-11-28 10:04:18,693 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
+      "2025-11-28 10:04:19,011 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
+      "2025-11-28 10:04:19,347 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
+      "2025-11-28 10:04:19,673 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
+      "2025-11-28 10:04:20,053 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
+      "2025-11-28 10:04:20,431 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
+      "2025-11-28 10:04:20,767 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
+      "2025-11-28 10:04:20,985 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
+      "2025-11-28 10:04:22,116 - climada.entity.exposures.litpop.litpop - INFO - \n",
       " LitPop: Init Exposure for country: KNA (659)...\n",
       "\n",
-      "2025-11-27 16:54:48,452 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-27 16:54:49,631 - climada.util.finance - INFO - GDP KNA 2020: 8.839e+08.\n",
-      "2025-11-27 16:54:49,655 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
-      "2025-11-27 16:54:49,655 - climada.entity.exposures.base - INFO - category_id not set.\n",
-      "2025-11-27 16:54:49,656 - climada.entity.exposures.base - INFO - cover not set.\n",
-      "2025-11-27 16:54:49,658 - climada.entity.exposures.base - INFO - deductible not set.\n",
-      "2025-11-27 16:54:49,659 - climada.entity.exposures.base - INFO - centr_ not set.\n"
+      "2025-11-28 10:04:22,164 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-28 10:04:28,839 - climada.util.finance - INFO - GDP KNA 2020: 8.839e+08.\n",
+      "2025-11-28 10:04:28,857 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+      "2025-11-28 10:04:28,857 - climada.entity.exposures.base - INFO - category_id not set.\n",
+      "2025-11-28 10:04:28,857 - climada.entity.exposures.base - INFO - cover not set.\n",
+      "2025-11-28 10:04:28,858 - climada.entity.exposures.base - INFO - deductible not set.\n",
+      "2025-11-28 10:04:28,859 - climada.entity.exposures.base - INFO - centr_ not set.\n"
      ]
     }
    ],
@@ -161,7 +148,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 11,
    "id": "890bcd64",
    "metadata": {},
    "outputs": [
@@ -169,29 +156,29 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-27 16:54:51,793 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
-      "2025-11-27 16:54:51,852 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
-      "2025-11-27 16:54:51,886 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
-      "2025-11-27 16:54:55,165 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
-      "2025-11-27 16:54:55,207 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 7938 coastal centroids.\n",
-      "2025-11-27 16:55:02,894 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
-      "2025-11-27 16:55:11,155 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
-      "2025-11-27 16:55:19,222 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
-      "2025-11-27 16:55:25,735 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
-      "2025-11-27 16:55:30,128 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
-      "2025-11-27 16:55:34,931 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
-      "2025-11-27 16:55:38,579 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
-      "2025-11-27 16:55:43,673 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
-      "2025-11-27 16:55:45,448 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
-      "2025-11-27 16:55:47,848 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      "2025-11-28 10:04:30,360 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
+      "2025-11-28 10:04:30,441 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
+      "2025-11-28 10:04:30,483 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
+      "2025-11-28 10:04:34,100 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
+      "2025-11-28 10:04:34,207 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 7938 coastal centroids.\n",
+      "2025-11-28 10:04:39,812 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
+      "2025-11-28 10:04:44,285 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
+      "2025-11-28 10:04:49,208 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
+      "2025-11-28 10:04:54,024 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
+      "2025-11-28 10:04:58,485 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
+      "2025-11-28 10:05:03,177 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
+      "2025-11-28 10:05:07,108 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
+      "2025-11-28 10:05:12,622 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
+      "2025-11-28 10:05:14,466 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
+      "2025-11-28 10:05:16,827 - climada.entity.exposures.litpop.litpop - INFO - \n",
       " LitPop: Init Exposure for country: JAM (388)...\n",
       "\n",
-      "2025-11-27 16:55:59,642 - climada.util.finance - INFO - GDP JAM 2020: 1.381e+10.\n",
-      "2025-11-27 16:55:59,677 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
-      "2025-11-27 16:55:59,678 - climada.entity.exposures.base - INFO - category_id not set.\n",
-      "2025-11-27 16:55:59,678 - climada.entity.exposures.base - INFO - cover not set.\n",
-      "2025-11-27 16:55:59,679 - climada.entity.exposures.base - INFO - deductible not set.\n",
-      "2025-11-27 16:55:59,680 - climada.entity.exposures.base - INFO - centr_ not set.\n"
+      "2025-11-28 10:05:17,256 - climada.util.finance - INFO - GDP JAM 2020: 1.381e+10.\n",
+      "2025-11-28 10:05:17,295 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+      "2025-11-28 10:05:17,296 - climada.entity.exposures.base - INFO - category_id not set.\n",
+      "2025-11-28 10:05:17,299 - climada.entity.exposures.base - INFO - cover not set.\n",
+      "2025-11-28 10:05:17,299 - climada.entity.exposures.base - INFO - deductible not set.\n",
+      "2025-11-28 10:05:17,300 - climada.entity.exposures.base - INFO - centr_ not set.\n"
      ]
     }
    ],
@@ -227,7 +214,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 12,
    "id": "c42eed8b",
    "metadata": {},
    "outputs": [
@@ -235,38 +222,38 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-27 16:56:02,011 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
-      "2025-11-27 16:56:02,091 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
-      "2025-11-27 16:56:02,127 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
-      "2025-11-27 16:56:04,973 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
-      "2025-11-27 16:56:05,036 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 16463 coastal centroids.\n",
-      "2025-11-27 16:56:12,772 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
-      "2025-11-27 16:56:20,487 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
-      "2025-11-27 16:56:28,147 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
-      "2025-11-27 16:56:37,256 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
-      "2025-11-27 16:56:47,310 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
-      "2025-11-27 16:56:57,107 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
-      "2025-11-27 16:57:06,706 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
-      "2025-11-27 16:57:18,615 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
-      "2025-11-27 16:57:23,268 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
-      "2025-11-27 16:57:27,974 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      "2025-11-28 10:05:19,071 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
+      "2025-11-28 10:05:19,146 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
+      "2025-11-28 10:05:19,190 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
+      "2025-11-28 10:05:21,702 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
+      "2025-11-28 10:05:21,764 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 16463 coastal centroids.\n",
+      "2025-11-28 10:05:29,444 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
+      "2025-11-28 10:05:37,352 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
+      "2025-11-28 10:05:45,007 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
+      "2025-11-28 10:05:52,790 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
+      "2025-11-28 10:06:00,515 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
+      "2025-11-28 10:06:08,315 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
+      "2025-11-28 10:06:16,402 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
+      "2025-11-28 10:06:24,076 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
+      "2025-11-28 10:06:28,252 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
+      "2025-11-28 10:06:31,914 - climada.entity.exposures.litpop.litpop - INFO - \n",
       " LitPop: Init Exposure for country: BLZ (84)...\n",
       "\n",
-      "2025-11-27 16:57:28,274 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-27 16:57:28,297 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-27 16:57:28,330 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-27 16:57:28,347 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-27 16:57:28,367 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-27 16:57:28,385 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-27 16:57:28,419 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-27 16:57:28,436 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-27 16:57:28,453 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-27 16:57:35,994 - climada.util.finance - INFO - GDP BLZ 2020: 2.043e+09.\n",
-      "2025-11-27 16:57:36,062 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
-      "2025-11-27 16:57:36,063 - climada.entity.exposures.base - INFO - category_id not set.\n",
-      "2025-11-27 16:57:36,063 - climada.entity.exposures.base - INFO - cover not set.\n",
-      "2025-11-27 16:57:36,064 - climada.entity.exposures.base - INFO - deductible not set.\n",
-      "2025-11-27 16:57:36,065 - climada.entity.exposures.base - INFO - centr_ not set.\n"
+      "2025-11-28 10:06:32,183 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-28 10:06:32,207 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-28 10:06:32,252 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-28 10:06:32,281 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-28 10:06:32,306 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-28 10:06:32,337 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-28 10:06:32,382 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-28 10:06:32,403 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-28 10:06:32,423 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
+      "2025-11-28 10:06:32,876 - climada.util.finance - INFO - GDP BLZ 2020: 2.043e+09.\n",
+      "2025-11-28 10:06:32,933 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+      "2025-11-28 10:06:32,934 - climada.entity.exposures.base - INFO - category_id not set.\n",
+      "2025-11-28 10:06:32,934 - climada.entity.exposures.base - INFO - cover not set.\n",
+      "2025-11-28 10:06:32,934 - climada.entity.exposures.base - INFO - deductible not set.\n",
+      "2025-11-28 10:06:32,935 - climada.entity.exposures.base - INFO - centr_ not set.\n"
      ]
     }
    ],
@@ -310,7 +297,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 13,
    "id": "09fba021",
    "metadata": {},
    "outputs": [
@@ -318,7 +305,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-27 16:57:42,838 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+      "2025-11-28 10:06:38,729 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
      ]
     },
     {
@@ -335,7 +322,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-27 16:58:05,202 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+      "2025-11-28 10:06:56,861 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
      ]
     },
     {
@@ -352,7 +339,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-27 16:58:23,466 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+      "2025-11-28 10:07:11,311 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
      ]
     },
     {
@@ -385,7 +372,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 14,
    "id": "ac344ab3",
    "metadata": {},
    "outputs": [
@@ -393,15 +380,15 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-27 17:21:27,069 - climada.entity.exposures.base - INFO - Matching 328 exposures with 546 centroids.\n",
-      "2025-11-27 17:21:27,096 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
-      "2025-11-27 17:21:27,124 - climada.engine.impact_calc - INFO - Calculating impact for 984 assets (>0) and 51 events.\n",
-      "2025-11-27 17:21:29,349 - climada.entity.exposures.base - INFO - Matching 13552 exposures with 7938 centroids.\n",
-      "2025-11-27 17:21:29,388 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
-      "2025-11-27 17:21:29,446 - climada.engine.impact_calc - INFO - Calculating impact for 40503 assets (>0) and 51 events.\n",
-      "2025-11-27 17:21:30,538 - climada.entity.exposures.base - INFO - Matching 27265 exposures with 16463 centroids.\n",
-      "2025-11-27 17:21:30,594 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
-      "2025-11-27 17:21:30,745 - climada.engine.impact_calc - INFO - Calculating impact for 81177 assets (>0) and 51 events.\n"
+      "2025-11-28 10:07:31,712 - climada.entity.exposures.base - INFO - Matching 328 exposures with 546 centroids.\n",
+      "2025-11-28 10:07:31,722 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
+      "2025-11-28 10:07:31,729 - climada.engine.impact_calc - INFO - Calculating impact for 984 assets (>0) and 51 events.\n",
+      "2025-11-28 10:07:32,673 - climada.entity.exposures.base - INFO - Matching 13552 exposures with 7938 centroids.\n",
+      "2025-11-28 10:07:32,682 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
+      "2025-11-28 10:07:32,711 - climada.engine.impact_calc - INFO - Calculating impact for 40503 assets (>0) and 51 events.\n",
+      "2025-11-28 10:07:33,569 - climada.entity.exposures.base - INFO - Matching 27265 exposures with 16463 centroids.\n",
+      "2025-11-28 10:07:33,585 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
+      "2025-11-28 10:07:33,646 - climada.engine.impact_calc - INFO - Calculating impact for 81177 assets (>0) and 51 events.\n"
      ]
     }
    ],
@@ -424,7 +411,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 15,
    "id": "4ead6e69",
    "metadata": {},
    "outputs": [
@@ -471,7 +458,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 16,
    "id": "6cfb9d55",
    "metadata": {},
    "outputs": [
@@ -518,7 +505,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 17,
    "id": "4e590bad",
    "metadata": {},
    "outputs": [
@@ -572,7 +559,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 18,
+   "id": "65cf6f54",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#create dictionary of 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": 19,
    "id": "67403f5f",
    "metadata": {},
    "outputs": [
@@ -603,14 +603,14 @@
     }
    ],
    "source": [
-    "mlt_cat_bond = MultiCountryBondSimulation(subarea_calc_list=[st_kitts_sub_calc, jamaica_sub_calc, belize_sub_calc], countries_list=countries, term=term,number_of_terms=num_of_terms, tranches=[0.2,0.8])\n",
+    "mlt_cat_bond = MultiCountryBondSimulation(country_dictionary=sng_bonds_dic, term=term,number_of_terms=num_of_terms)\n",
     "mlt_cat_bond.init_required_principal()\n",
     "mlt_cat_bond.init_loss_simulation(principal=mlt_cat_bond.requ_principal, confidence_levels=[0.95,0.99])\n",
     "mlt_bond_premiums = PremiumCalculations(bond_simulation_class=mlt_cat_bond)\n",
     "mlt_bond_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)\n",
     "mlt_bond_premiums.calc_ibrd_premium()\n",
     "mlt_bond_premiums.calc_benchmark_premium(target_sharpe = target_sharpe)\n",
-    "mlt_cat_bond.init_return_simulation_tranches(premiums=[mlt_bond_premiums.chatoro_prem_rate,mlt_bond_premiums.chatoro_prem_rate])\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])\n",
     "mlt_cat_bond.init_return_simulation(premium=mlt_bond_premiums.chatoro_prem_rate)\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",
@@ -620,55 +620,104 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
-   "id": "6d1432f4",
+   "execution_count": null,
+   "id": "7f7e0ab3",
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "171\n",
-      "171\n",
-      "171\n"
+      "659\n",
+      "{2: [659]}\n",
+      "388\n",
+      "{2: [659, 388]}\n",
+      "84\n",
+      "{2: [659, 388], 1: [84]}\n",
+      "2 [659, 388]\n",
+      "1 [84]\n"
      ]
     }
    ],
    "source": [
-    "print(len(st_kitts_bond_sim.df_loss_month))\n",
-    "print(len(jamaica_bond_sim.df_loss_month))\n",
-    "print(len(belize_bond_sim.df_loss_month))"
+    "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)\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": 27,
-   "id": "7f7e0ab3",
+   "execution_count": null,
+   "id": "e88fb28d",
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "171 171 171\n",
-      "[441961111.11111087, 6906210917.868449, 1021425000.0000002]\n"
+      "2 [659, 388]\n",
+      "1 [84]\n",
+      "[84]\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "(   659  388  84  min_conc\n",
-       " 0    2    2   1     0.805,\n",
-       " <pymoo.core.result.Result at 0x145c56c10>)"
+       "{'EL_ann': 0.0046539237284759375,\n",
+       " 'AP_ann': 0.11695906432748537,\n",
+       " 'Payout': 6181898997.912401,\n",
+       " 'Damage': 9590299020.561695,\n",
+       " 'VaR_95_ann': 0.03291028324139181,\n",
+       " 'ES_95_ann': 0.05530771055753955,\n",
+       " 'VaR_99_ann': 0.07497215495174554,\n",
+       " 'ES_99_ann': 0.07971056123003463}"
       ]
      },
-     "execution_count": 27,
      "metadata": {},
-     "output_type": "execute_result"
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[659, 388]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'EL_ann': 0.02482805356325667,\n",
+       " 'AP_ann': 0.0935672514619883,\n",
+       " 'Payout': 32979594939.144997,\n",
+       " 'Damage': 61957002793.421295,\n",
+       " 'VaR_95_ann': 0.1214322895521304,\n",
+       " 'ES_95_ann': 0.44214232744004733,\n",
+       " 'VaR_99_ann': 0.7457273298119343,\n",
+       " 'ES_99_ann': 0.7595667109843475}"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     }
    ],
    "source": [
-    "pf.process_n(2, countries, [st_kitts_bond_sim, jamaica_bond_sim, belize_bond_sim], n_opt_rep=3)"
+    "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=1000000000, \n",
+    "                                                                                                                                         n_opt_rep=2)\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)"
    ]
   }
  ],

From 20b08fa7799daedac580711bc2f35bfd057b96be Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 28 Nov 2025 10:49:25 +0100
Subject: [PATCH 080/125] update funciton descriptions

---
 .../engine/cat_bonds/mlt_bond_simulation.py   | 62 ++++++++++---------
 1 file changed, 34 insertions(+), 28 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
index 1f234bb4a..3e5805e52 100644
--- a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
@@ -36,30 +36,33 @@ def _prepare_data(self):
     @classmethod
     def simulate_bond_pool_n(cls, country_dictionary, term, number_of_terms, principal, number_pools, n_opt_rep=100):
         """
-        Class method to create an instance of MultiCountryBondSimulation and run the loss simulation.
+        Class method to optimize pool allocation using a fixed number of pools, create instances of MultiCountryBondSimulation per pool, and run the loss simulation.
 
         Parameters
         ----------
-        n : int
-            Number of countries to include in the pool.
-        subarea_calc_list : list
-            List of subarea_calc instances for each country.
-        countries_list : list
-            List of country codes.
+        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.
-        tranches : list
-            List of tranche nominal values.
         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
         -------
-        bond_simulation : MultiCountryBondSimulation
-            Instance of MultiCountryBondSimulation with simulated losses.
+        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]
@@ -85,30 +88,33 @@ def simulate_bond_pool_n(cls, country_dictionary, term, number_of_terms, princip
     @classmethod
     def simulate_bond_max_principal_pool(cls, country_dictionary, term, number_of_terms, principal, maximum_principal, n_opt_rep=100):
         """
-        Class method to create an instance of MultiCountryBondSimulation and run the loss simulation.
+        Class method to optimize pool allocation using a maximum principal, create instances of MultiCountryBondSimulation per pool, and run the loss simulation.
 
         Parameters
         ----------
-        n : int
-            Number of countries to include in the pool.
-        subarea_calc_list : list
-            List of subarea_calc instances for each country.
-        countries_list : list
-            List of country codes.
+        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.
-        tranches : list
-            List of tranche nominal values.
         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
         -------
-        bond_simulation : MultiCountryBondSimulation
-            Instance of MultiCountryBondSimulation with simulated losses.
+        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]
@@ -416,6 +422,8 @@ def init_return_simulation_tranches(self, premiums, tranches, rf=0.0):
             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).
 
@@ -496,11 +504,9 @@ def init_required_principal(self):
         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.
-        Args:
-            countries (list): List of country codes to include in the simulation.
-            pay_dam_df_dic (dict): Dictionary mapping country codes to pandas DataFrames containing event loss data.
-                Each DataFrame must have a 'year' column and relevant loss information.
-            nominal_dic_cty (dict): Dictionary mapping country codes to their respective nominal values.
+        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.
         """

From c486f9c980ecb3b3631cd08228cebf347c790fde Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 28 Nov 2025 10:54:55 +0100
Subject: [PATCH 081/125] comment tutorial script

---
 .../cat_bonds/climada_engine_CATBonds.ipynb   | 166 +++++++++---------
 1 file changed, 86 insertions(+), 80 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/climada_engine_CATBonds.ipynb b/climada_petals/engine/cat_bonds/climada_engine_CATBonds.ipynb
index b112e6c79..aa617ae1d 100644
--- a/climada_petals/engine/cat_bonds/climada_engine_CATBonds.ipynb
+++ b/climada_petals/engine/cat_bonds/climada_engine_CATBonds.ipynb
@@ -1,8 +1,16 @@
 {
  "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "a6544fc4",
+   "metadata": {},
+   "source": [
+    "### Import packages"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "id": "48c2d418",
    "metadata": {},
    "outputs": [
@@ -24,7 +32,6 @@
     "from sng_bond_simulation import SingleCountryBondSimulation\n",
     "from mlt_bond_simulation import MultiCountryBondSimulation\n",
     "from premium_class import PremiumCalculations\n",
-    "import pooling_functions as pf\n",
     "\n",
     "from climada.hazard import TCTracks, Centroids, TropCyclone\n",
     "from climada.entity import LitPop\n",
@@ -80,7 +87,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "id": "a51eb038",
    "metadata": {},
    "outputs": [
@@ -138,12 +145,13 @@
     "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([736576, 736596, 736649, 736659, 736668, 736681, 736701, 736702, 736715, 736726,\n",
-    " 736727, 736731, 736743, 736753, 736762, 736781, 736787, 736803, 736808, 736821,\n",
-    " 736843, 736848, 736854, 736868, 736872, 736878, 736892, 736900, 736904, 736912,\n",
-    " 736921, 736926, 736940, 736945, 736952, 736963, 736976, 736983, 736993, 737003,\n",
-    " 737012, 737020, 737031, 737037, 737048, 737059, 737068, 737074, 737081, 737092,\n",
-    " 737098])"
+    "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])"
    ]
   },
   {
@@ -297,7 +305,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "id": "09fba021",
    "metadata": {},
    "outputs": [
@@ -354,9 +362,9 @@
     }
    ],
    "source": [
-    "st_kitts_subareas = Subareas.from_resolution(tc_irma, impfset, exp_kit, resolution=resolution_st_kitts)\n",
-    "jamaica_subareas = Subareas.from_resolution(tc_melissa, impfset, exp_jam, resolution=resolution_jamaica)\n",
-    "belize_subareas = Subareas.from_resolution(tc_keith, impfset, exp_bel, resolution=resolution_belize)\n",
+    "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()"
@@ -372,7 +380,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "id": "ac344ab3",
    "metadata": {},
    "outputs": [
@@ -393,12 +401,12 @@
     }
    ],
    "source": [
-    "st_kitts_sub_calc = SubareaCalculations(subareas=st_kitts_subareas, index_stat=par_index)\n",
-    "jamaica_sub_calc = SubareaCalculations(subareas=jamaica_subareas, index_stat=par_index)\n",
-    "belize_sub_calc = SubareaCalculations(subareas=belize_subareas, index_stat=par_index)\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)\n",
-    "jamaica_sub_calc.create_pay_vs_dam(attachment_point, exhaustion_point, methods_attachment_point=attachment_point_method, methods_exhaustion_point=exhaustion_point_method)\n",
-    "belize_sub_calc.create_pay_vs_dam(attachment_point, exhaustion_point, methods_attachment_point=attachment_point_method, methods_exhaustion_point=exhaustion_point_method)"
+    "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"
    ]
   },
   {
@@ -411,7 +419,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "id": "4ead6e69",
    "metadata": {},
    "outputs": [
@@ -443,14 +451,14 @@
    ],
    "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) \n",
-    "st_kitts_bond_sim.init_loss_simulation()\n",
-    "st_kitts_premiums = PremiumCalculations(bond_simulation_class=st_kitts_bond_sim)\n",
-    "st_kitts_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)\n",
-    "st_kitts_premiums.calc_ibrd_premium()\n",
-    "st_kitts_premiums.calc_benchmark_premium(target_sharpe = target_sharpe)\n",
-    "st_kitts_bond_sim.init_return_simulation(premium=st_kitts_premiums.chatoro_prem_rate)\n",
-    "display(st_kitts_bond_sim.loss_metrics)\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)}\")"
@@ -458,7 +466,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "id": "6cfb9d55",
    "metadata": {},
    "outputs": [
@@ -490,14 +498,14 @@
    ],
    "source": [
     "### JAMAICA BOND SIMULATION ###\n",
-    "jamaica_bond_sim = SingleCountryBondSimulation(subarea_calc=jamaica_sub_calc, term=term, number_of_terms=num_of_terms) \n",
-    "jamaica_bond_sim.init_loss_simulation()\n",
-    "jamaica_premiums = PremiumCalculations(bond_simulation_class=jamaica_bond_sim)\n",
-    "jamaica_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)\n",
-    "jamaica_premiums.calc_ibrd_premium()\n",
-    "jamaica_premiums.calc_benchmark_premium(target_sharpe = target_sharpe)\n",
-    "jamaica_bond_sim.init_return_simulation(premium=jamaica_premiums.chatoro_prem_rate)\n",
-    "display(jamaica_bond_sim.loss_metrics)\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)}\")"
@@ -505,7 +513,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "id": "4e590bad",
    "metadata": {},
    "outputs": [
@@ -536,13 +544,13 @@
     }
    ],
    "source": [
-    "belize_bond_sim = SingleCountryBondSimulation(subarea_calc=belize_sub_calc, term=term, number_of_terms=num_of_terms) \n",
-    "belize_bond_sim.init_loss_simulation()\n",
-    "belize_premiums = PremiumCalculations(bond_simulation_class=belize_bond_sim)\n",
-    "belize_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)\n",
-    "belize_premiums.calc_ibrd_premium()\n",
-    "belize_premiums.calc_benchmark_premium(target_sharpe = target_sharpe)\n",
-    "belize_bond_sim.init_return_simulation(premium=belize_premiums.chatoro_prem_rate)\n",
+    "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",
@@ -559,12 +567,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "id": "65cf6f54",
    "metadata": {},
    "outputs": [],
    "source": [
-    "#create dictionary of country bond simulation classes\n",
+    "#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}"
@@ -572,7 +580,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "id": "67403f5f",
    "metadata": {},
    "outputs": [
@@ -603,16 +611,16 @@
     }
    ],
    "source": [
-    "mlt_cat_bond = MultiCountryBondSimulation(country_dictionary=sng_bonds_dic, term=term,number_of_terms=num_of_terms)\n",
-    "mlt_cat_bond.init_required_principal()\n",
-    "mlt_cat_bond.init_loss_simulation(principal=mlt_cat_bond.requ_principal, confidence_levels=[0.95,0.99])\n",
-    "mlt_bond_premiums = PremiumCalculations(bond_simulation_class=mlt_cat_bond)\n",
-    "mlt_bond_premiums.calc_chatoro_premium(peak_multi=peak_peril, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)\n",
-    "mlt_bond_premiums.calc_ibrd_premium()\n",
-    "mlt_bond_premiums.calc_benchmark_premium(target_sharpe = target_sharpe)\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])\n",
-    "mlt_cat_bond.init_return_simulation(premium=mlt_bond_premiums.chatoro_prem_rate)\n",
-    "display(mlt_cat_bond.loss_metrics)\n",
+    "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)}\")"
@@ -645,7 +653,7 @@
     "                                                                                                              number_of_terms=num_of_terms, \n",
     "                                                                                                              principal=mlt_cat_bond.requ_principal, \n",
     "                                                                                                              number_pools=2, \n",
-    "                                                                                                              n_opt_rep=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",
@@ -662,22 +670,20 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2 [659, 388]\n",
-      "1 [84]\n",
-      "[84]\n"
+      "[659, 84]\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "{'EL_ann': 0.0046539237284759375,\n",
-       " 'AP_ann': 0.11695906432748537,\n",
-       " 'Payout': 6181898997.912401,\n",
-       " 'Damage': 9590299020.561695,\n",
-       " 'VaR_95_ann': 0.03291028324139181,\n",
-       " 'ES_95_ann': 0.05530771055753955,\n",
-       " 'VaR_99_ann': 0.07497215495174554,\n",
-       " 'ES_99_ann': 0.07971056123003463}"
+       "{'EL_ann': 0.005652089487617996,\n",
+       " 'AP_ann': 0.12280701754385964,\n",
+       " 'Payout': 7507782331.245733,\n",
+       " 'Damage': 20627438939.662247,\n",
+       " 'VaR_95_ann': 0.04603557927941944,\n",
+       " 'ES_95_ann': 0.06749577691106026,\n",
+       " 'VaR_99_ann': 0.08204313595733179,\n",
+       " 'ES_99_ann': 0.08864223424002583}"
       ]
      },
      "metadata": {},
@@ -687,18 +693,18 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[659, 388]\n"
+      "[388]\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "{'EL_ann': 0.02482805356325667,\n",
-       " 'AP_ann': 0.0935672514619883,\n",
-       " 'Payout': 32979594939.144997,\n",
-       " 'Damage': 61957002793.421295,\n",
-       " 'VaR_95_ann': 0.1214322895521304,\n",
-       " 'ES_95_ann': 0.44214232744004733,\n",
+       "{'EL_ann': 0.023829887804114613,\n",
+       " 'AP_ann': 0.08771929824561403,\n",
+       " 'Payout': 31653711605.811665,\n",
+       " 'Damage': 50919862874.32074,\n",
+       " 'VaR_95_ann': 0.11492192918083803,\n",
+       " 'ES_95_ann': 0.3967579393350537,\n",
        " 'VaR_99_ann': 0.7457273298119343,\n",
        " 'ES_99_ann': 0.7595667109843475}"
       ]
@@ -712,8 +718,8 @@
     "                                                                                                                                         term=term, \n",
     "                                                                                                                                         number_of_terms=num_of_terms, \n",
     "                                                                                                                                         principal=mlt_cat_bond.requ_principal, \n",
-    "                                                                                                                                         maximum_principal=1000000000, \n",
-    "                                                                                                                                         n_opt_rep=2)\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",

From ad94804c9a79f412dc16b56627740fa91627bed1 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 28 Nov 2025 11:46:09 +0100
Subject: [PATCH 082/125] change inital guess values to percentiles of hazard
 intensity

---
 climada_petals/engine/cat_bonds/subarea_calculations.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/subarea_calculations.py b/climada_petals/engine/cat_bonds/subarea_calculations.py
index 71ffcbd5c..7718639c2 100644
--- a/climada_petals/engine/cat_bonds/subarea_calculations.py
+++ b/climada_petals/engine/cat_bonds/subarea_calculations.py
@@ -39,9 +39,7 @@ def __init__(self, subareas, index_stat):
         self.subareas = subareas
         self.index_stat = index_stat
 
-        self.initial_guess_dict = {
-            "TC": (30, 40)
-        }  # initial guess for wind speed in m/s
+        self.initial_guess = (np.percentile(subareas.hazard.intensity.data, 30), np.percentile(subareas.hazard.intensity.data, 60))
 
     def _calc_impact(self):
         """
@@ -277,7 +275,7 @@ def _calibrate_payout_fcts(self, haz_int, principal, attachment, imp_subarea_evt
             # Perform optimization for each subarea
             result = minimize(
                 self._objective_fct,
-                self.initial_guess_dict[hazard_type],
+                self.initial_guess,
                 args=(haz_int[hazard_type].iloc[:, [subarea, -1]], damages, principal),
                 method="COBYLA",
                 options={"maxiter": 100000},

From df09dd3b853e192895592192d323e4416ee4f17f Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 28 Nov 2025 11:47:26 +0100
Subject: [PATCH 083/125] implement option to plug in manuall init guess

---
 .../engine/cat_bonds/subarea_calculations.py          | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/subarea_calculations.py b/climada_petals/engine/cat_bonds/subarea_calculations.py
index 7718639c2..8cbf201d7 100644
--- a/climada_petals/engine/cat_bonds/subarea_calculations.py
+++ b/climada_petals/engine/cat_bonds/subarea_calculations.py
@@ -12,7 +12,7 @@
 
 
 class SubareaCalculations:
-    def __init__(self, subareas, index_stat):
+    def __init__(self, subareas, index_stat, intitial_guess=None):
         '''
         Attributes
         ----------
@@ -34,12 +34,17 @@ def __init__(self, subareas, index_stat):
             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
-
-        self.initial_guess = (np.percentile(subareas.hazard.intensity.data, 30), np.percentile(subareas.hazard.intensity.data, 60))
+        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):
         """

From a84e767d3354faf6678fe83aca46c908ce1f8380 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 28 Nov 2025 12:02:54 +0100
Subject: [PATCH 084/125] add function to initialize subarea class with a gdf

---
 climada_petals/engine/cat_bonds/subareas.py | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/climada_petals/engine/cat_bonds/subareas.py b/climada_petals/engine/cat_bonds/subareas.py
index 64f8c4bbf..7aba7c4e2 100644
--- a/climada_petals/engine/cat_bonds/subareas.py
+++ b/climada_petals/engine/cat_bonds/subareas.py
@@ -58,6 +58,22 @@ def from_resolution(cls, hazard, vulnerability, exposure, resolution, subareas_g
         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)
+        return cls(hazard, vulnerability, exposure, subareas_gdf)
 
     # --- Properties ---
     @property

From d422c83b20082b27ba63c78d6fee1c6876b60229 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 28 Nov 2025 13:42:31 +0100
Subject: [PATCH 085/125] update function description

---
 climada_petals/engine/cat_bonds/subareas.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/subareas.py b/climada_petals/engine/cat_bonds/subareas.py
index 7aba7c4e2..51bf48034 100644
--- a/climada_petals/engine/cat_bonds/subareas.py
+++ b/climada_petals/engine/cat_bonds/subareas.py
@@ -33,9 +33,8 @@ class Subareas:
         crs : str, optional
             Coordinate reference system for spatial data (default: "EPSG:3857").
         subareas_gdf : geopandas.GeoDataFrame
-            GeoDataFrame containing the subareas as polygons.
-        exp_gdf : geopandas.GeoDataFrame
-            GeoDataFrame containing the exposure perimeter as a polygon.
+            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.
     '''
     
 
@@ -73,6 +72,7 @@ def from_geodataframe(cls, hazard, vulnerability, exposure, gdf):
             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 ---

From 9c4a252184d6d54bfa7a03a13e60bfdd2ac91175 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 28 Nov 2025 14:25:09 +0100
Subject: [PATCH 086/125] move turotial to docs and create init

---
 climada_petals/engine/cat_bonds/__init__.py   |  24 ++
 .../tutorial}/climada_engine_CATBonds.ipynb   | 357 ++++++++++--------
 2 files changed, 225 insertions(+), 156 deletions(-)
 create mode 100644 climada_petals/engine/cat_bonds/__init__.py
 rename {climada_petals/engine/cat_bonds => doc/tutorial}/climada_engine_CATBonds.ipynb (97%)

diff --git a/climada_petals/engine/cat_bonds/__init__.py b/climada_petals/engine/cat_bonds/__init__.py
new file mode 100644
index 000000000..5ff84d591
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/__init__.py
@@ -0,0 +1,24 @@
+"""
+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 <https://www.gnu.org/licenses/>.
+
+---
+"""
+
+import logging
+
+LOGGER = logging.getLogger(__name__)
+
+from cat_bonds import *
diff --git a/climada_petals/engine/cat_bonds/climada_engine_CATBonds.ipynb b/doc/tutorial/climada_engine_CATBonds.ipynb
similarity index 97%
rename from climada_petals/engine/cat_bonds/climada_engine_CATBonds.ipynb
rename to doc/tutorial/climada_engine_CATBonds.ipynb
index aa617ae1d..94ac84cda 100644
--- a/climada_petals/engine/cat_bonds/climada_engine_CATBonds.ipynb
+++ b/doc/tutorial/climada_engine_CATBonds.ipynb
@@ -21,17 +21,28 @@
       "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 subareas import Subareas\n",
-    "from subarea_calculations import SubareaCalculations\n",
-    "from sng_bond_simulation import SingleCountryBondSimulation\n",
-    "from mlt_bond_simulation import MultiCountryBondSimulation\n",
-    "from premium_class import PremiumCalculations\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",
@@ -49,7 +60,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 25,
    "id": "89b53a88",
    "metadata": {},
    "outputs": [],
@@ -87,7 +98,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 26,
    "id": "a51eb038",
    "metadata": {},
    "outputs": [
@@ -95,30 +106,30 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-28 10:04:14,222 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
-      "2025-11-28 10:04:14,317 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
-      "2025-11-28 10:04:14,417 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
-      "2025-11-28 10:04:17,972 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
-      "2025-11-28 10:04:18,027 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 546 coastal centroids.\n",
-      "2025-11-28 10:04:18,393 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
-      "2025-11-28 10:04:18,693 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
-      "2025-11-28 10:04:19,011 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
-      "2025-11-28 10:04:19,347 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
-      "2025-11-28 10:04:19,673 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
-      "2025-11-28 10:04:20,053 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
-      "2025-11-28 10:04:20,431 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
-      "2025-11-28 10:04:20,767 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
-      "2025-11-28 10:04:20,985 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
-      "2025-11-28 10:04:22,116 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      "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 10:04:22,164 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-28 10:04:28,839 - climada.util.finance - INFO - GDP KNA 2020: 8.839e+08.\n",
-      "2025-11-28 10:04:28,857 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
-      "2025-11-28 10:04:28,857 - climada.entity.exposures.base - INFO - category_id not set.\n",
-      "2025-11-28 10:04:28,857 - climada.entity.exposures.base - INFO - cover not set.\n",
-      "2025-11-28 10:04:28,858 - climada.entity.exposures.base - INFO - deductible not set.\n",
-      "2025-11-28 10:04:28,859 - climada.entity.exposures.base - INFO - centr_ not set.\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"
      ]
     }
    ],
@@ -156,7 +167,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 27,
    "id": "890bcd64",
    "metadata": {},
    "outputs": [
@@ -164,29 +175,29 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-28 10:04:30,360 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
-      "2025-11-28 10:04:30,441 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
-      "2025-11-28 10:04:30,483 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
-      "2025-11-28 10:04:34,100 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
-      "2025-11-28 10:04:34,207 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 7938 coastal centroids.\n",
-      "2025-11-28 10:04:39,812 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
-      "2025-11-28 10:04:44,285 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
-      "2025-11-28 10:04:49,208 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
-      "2025-11-28 10:04:54,024 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
-      "2025-11-28 10:04:58,485 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
-      "2025-11-28 10:05:03,177 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
-      "2025-11-28 10:05:07,108 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
-      "2025-11-28 10:05:12,622 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
-      "2025-11-28 10:05:14,466 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
-      "2025-11-28 10:05:16,827 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      "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 10:05:17,256 - climada.util.finance - INFO - GDP JAM 2020: 1.381e+10.\n",
-      "2025-11-28 10:05:17,295 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
-      "2025-11-28 10:05:17,296 - climada.entity.exposures.base - INFO - category_id not set.\n",
-      "2025-11-28 10:05:17,299 - climada.entity.exposures.base - INFO - cover not set.\n",
-      "2025-11-28 10:05:17,299 - climada.entity.exposures.base - INFO - deductible not set.\n",
-      "2025-11-28 10:05:17,300 - climada.entity.exposures.base - INFO - centr_ not set.\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"
      ]
     }
    ],
@@ -222,7 +233,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 28,
    "id": "c42eed8b",
    "metadata": {},
    "outputs": [
@@ -230,38 +241,38 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-28 10:05:19,071 - climada.hazard.tc_tracks - INFO - Progress: 100%\n",
-      "2025-11-28 10:05:19,146 - climada.hazard.tc_tracks - INFO - Interpolating 1 tracks to 1h time steps.\n",
-      "2025-11-28 10:05:19,190 - climada.hazard.tc_tracks_synth - INFO - Computing 50 synthetic tracks.\n",
-      "2025-11-28 10:05:21,702 - climada.util.coordinates - INFO - Sampling from /Users/kbergmueller/climada/data/GMT_intermediate_coast_distance_01d.tif\n",
-      "2025-11-28 10:05:21,764 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Mapping 51 tracks to 16463 coastal centroids.\n",
-      "2025-11-28 10:05:29,444 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 11%\n",
-      "2025-11-28 10:05:37,352 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 23%\n",
-      "2025-11-28 10:05:45,007 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 35%\n",
-      "2025-11-28 10:05:52,790 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 47%\n",
-      "2025-11-28 10:06:00,515 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 58%\n",
-      "2025-11-28 10:06:08,315 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 70%\n",
-      "2025-11-28 10:06:16,402 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 82%\n",
-      "2025-11-28 10:06:24,076 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 94%\n",
-      "2025-11-28 10:06:28,252 - climada.hazard.trop_cyclone.trop_cyclone - INFO - Progress: 100%\n",
-      "2025-11-28 10:06:31,914 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      "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 10:06:32,183 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-28 10:06:32,207 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-28 10:06:32,252 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-28 10:06:32,281 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-28 10:06:32,306 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-28 10:06:32,337 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-28 10:06:32,382 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-28 10:06:32,403 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-28 10:06:32,423 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n",
-      "2025-11-28 10:06:32,876 - climada.util.finance - INFO - GDP BLZ 2020: 2.043e+09.\n",
-      "2025-11-28 10:06:32,933 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
-      "2025-11-28 10:06:32,934 - climada.entity.exposures.base - INFO - category_id not set.\n",
-      "2025-11-28 10:06:32,934 - climada.entity.exposures.base - INFO - cover not set.\n",
-      "2025-11-28 10:06:32,934 - climada.entity.exposures.base - INFO - deductible not set.\n",
-      "2025-11-28 10:06:32,935 - climada.entity.exposures.base - INFO - centr_ not set.\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"
      ]
     }
    ],
@@ -305,7 +316,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 29,
    "id": "09fba021",
    "metadata": {},
    "outputs": [
@@ -313,7 +324,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-28 10:06:38,729 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+      "2025-11-28 13:51:33,651 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
      ]
     },
     {
@@ -330,7 +341,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-28 10:06:56,861 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+      "2025-11-28 13:51:57,618 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
      ]
     },
     {
@@ -347,7 +358,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-28 10:07:11,311 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
+      "2025-11-28 13:52:20,493 - climada.util.coordinates - INFO - Raster from resolution 0.00833332999999925 to 0.00833332999999925.\n"
      ]
     },
     {
@@ -380,7 +391,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 30,
    "id": "ac344ab3",
    "metadata": {},
    "outputs": [
@@ -388,15 +399,15 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2025-11-28 10:07:31,712 - climada.entity.exposures.base - INFO - Matching 328 exposures with 546 centroids.\n",
-      "2025-11-28 10:07:31,722 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
-      "2025-11-28 10:07:31,729 - climada.engine.impact_calc - INFO - Calculating impact for 984 assets (>0) and 51 events.\n",
-      "2025-11-28 10:07:32,673 - climada.entity.exposures.base - INFO - Matching 13552 exposures with 7938 centroids.\n",
-      "2025-11-28 10:07:32,682 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
-      "2025-11-28 10:07:32,711 - climada.engine.impact_calc - INFO - Calculating impact for 40503 assets (>0) and 51 events.\n",
-      "2025-11-28 10:07:33,569 - climada.entity.exposures.base - INFO - Matching 27265 exposures with 16463 centroids.\n",
-      "2025-11-28 10:07:33,585 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n",
-      "2025-11-28 10:07:33,646 - climada.engine.impact_calc - INFO - Calculating impact for 81177 assets (>0) and 51 events.\n"
+      "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"
      ]
     }
    ],
@@ -419,21 +430,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 31,
    "id": "4ead6e69",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'EL_ann': 0.017543859649122806,\n",
-       " 'AP_ann': 0.023391812865497075,\n",
-       " 'Tot_payout': 1325883333.3333325,\n",
-       " 'Tot_damages': 11037139919.100546,\n",
-       " 'VaR_95_ann': 0.0,\n",
-       " 'ES_95_ann': 0.75,\n",
-       " 'VaR_99_ann': 0.7555314181864904,\n",
-       " 'ES_99_ann': 1.0}"
+       "{'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": {},
@@ -443,9 +454,9 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Benchmark Sharpe Ratio premium rate: 8.7\n",
-      "Chatoro premium rate: 8.5\n",
-      "IBRD premium rate: 5.0\n"
+      "Benchmark Sharpe Ratio premium rate: 19.1\n",
+      "Chatoro premium rate: 13.4\n",
+      "IBRD premium rate: 8.8\n"
      ]
     }
    ],
@@ -466,21 +477,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 32,
    "id": "6cfb9d55",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'EL_ann': 0.02680332628076214,\n",
+       "{'EL_ann': 0.02693646858871278,\n",
        " 'AP_ann': 0.08771929824561403,\n",
-       " 'Tot_payout': 31653711605.811665,\n",
+       " 'Tot_payout': 31810947621.008274,\n",
        " 'Tot_damages': 50919862874.32074,\n",
-       " 'VaR_95_ann': 0.12926162262991353,\n",
-       " 'ES_95_ann': 0.4462644805505158,\n",
-       " 'VaR_99_ann': 0.8387774672602343,\n",
-       " 'ES_99_ann': 0.8543436945180888}"
+       " 'VaR_95_ann': 0.12926157820337597,\n",
+       " 'ES_95_ann': 0.4434242652474378,\n",
+       " 'VaR_99_ann': 0.832218608655908,\n",
+       " 'ES_99_ann': 0.85399814094077}"
       ]
      },
      "metadata": {},
@@ -513,21 +524,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 33,
    "id": "4e590bad",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'EL_ann': 0.03539315772390796,\n",
+       "{'EL_ann': 0.03539460884926218,\n",
        " 'AP_ann': 0.11695906432748537,\n",
-       " 'Tot_payout': 6181898997.912401,\n",
+       " 'Tot_payout': 6182152456.799656,\n",
        " 'Tot_damages': 9590299020.561695,\n",
-       " 'VaR_95_ann': 0.2502831832790935,\n",
-       " 'ES_95_ann': 0.42061594416208714,\n",
-       " 'VaR_99_ann': 0.5701643301269493,\n",
-       " 'ES_99_ann': 0.6061999788723924}"
+       " 'VaR_95_ann': 0.25031103128297705,\n",
+       " 'ES_95_ann': 0.42061599365154456,\n",
+       " 'VaR_99_ann': 0.5701310343598847,\n",
+       " 'ES_99_ann': 0.6062286122851708}"
       ]
      },
      "metadata": {},
@@ -567,7 +578,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 34,
    "id": "65cf6f54",
    "metadata": {},
    "outputs": [],
@@ -580,21 +591,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 35,
    "id": "67403f5f",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'EL_ann': 0.029481977291732603,\n",
+       "{'EL_ann': 0.02989594371046782,\n",
        " 'AP_ann': 0.14035087719298245,\n",
-       " 'Payout': 39161493937.057396,\n",
-       " 'Damage': 71547301813.98299,\n",
-       " 'VaR_95_ann': 0.15776731924400075,\n",
-       " 'ES_95_ann': 0.43875569600979597,\n",
-       " 'VaR_99_ann': 0.7602314866443391,\n",
-       " 'ES_99_ann': 0.807913900425695}"
+       " '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": {},
@@ -604,8 +615,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Benchmark Sharpe Ratio premium rate: 9.8\n",
-      "Chatoro premium rate: 10.2\n",
+      "Benchmark Sharpe Ratio premium rate: 9.7\n",
+      "Chatoro premium rate: 10.3\n",
       "IBRD premium rate: 6.3\n"
      ]
     }
@@ -628,7 +639,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 37,
    "id": "7f7e0ab3",
    "metadata": {},
    "outputs": [
@@ -636,15 +647,49 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "659\n",
-      "{2: [659]}\n",
-      "388\n",
-      "{2: [659, 388]}\n",
-      "84\n",
-      "{2: [659, 388], 1: [84]}\n",
-      "2 [659, 388]\n",
-      "1 [84]\n"
+      "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": [
@@ -662,7 +707,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 38,
    "id": "e88fb28d",
    "metadata": {},
    "outputs": [
@@ -676,14 +721,14 @@
     {
      "data": {
       "text/plain": [
-       "{'EL_ann': 0.005652089487617996,\n",
+       "{'EL_ann': 0.007236870482297057,\n",
        " 'AP_ann': 0.12280701754385964,\n",
-       " 'Payout': 7507782331.245733,\n",
-       " 'Damage': 20627438939.662247,\n",
-       " 'VaR_95_ann': 0.04603557927941944,\n",
-       " 'ES_95_ann': 0.06749577691106026,\n",
-       " 'VaR_99_ann': 0.08204313595733179,\n",
-       " 'ES_99_ann': 0.08864223424002583}"
+       " '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": {},
@@ -699,14 +744,14 @@
     {
      "data": {
       "text/plain": [
-       "{'EL_ann': 0.023829887804114613,\n",
+       "{'EL_ann': 0.02265907322817077,\n",
        " 'AP_ann': 0.08771929824561403,\n",
-       " 'Payout': 31653711605.811665,\n",
+       " 'Payout': 31810947621.008274,\n",
        " 'Damage': 50919862874.32074,\n",
-       " 'VaR_95_ann': 0.11492192918083803,\n",
-       " 'ES_95_ann': 0.3967579393350537,\n",
-       " 'VaR_99_ann': 0.7457273298119343,\n",
-       " 'ES_99_ann': 0.7595667109843475}"
+       " 'VaR_95_ann': 0.10873539552718275,\n",
+       " 'ES_95_ann': 0.37301039905430516,\n",
+       " 'VaR_99_ann': 0.7000658728992563,\n",
+       " 'ES_99_ann': 0.7183869091291053}"
       ]
      },
      "metadata": {},

From e9078d41d05be142e8464f77f4dd483b3e657659 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 28 Nov 2025 15:34:14 +0100
Subject: [PATCH 087/125] fix file paths

---
 climada_petals/engine/cat_bonds/__init__.py            |  2 --
 climada_petals/engine/cat_bonds/mlt_bond_simulation.py | 10 +++++-----
 climada_petals/engine/cat_bonds/sng_bond_simulation.py |  2 +-
 3 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/__init__.py b/climada_petals/engine/cat_bonds/__init__.py
index 5ff84d591..f703c791c 100644
--- a/climada_petals/engine/cat_bonds/__init__.py
+++ b/climada_petals/engine/cat_bonds/__init__.py
@@ -20,5 +20,3 @@
 import logging
 
 LOGGER = logging.getLogger(__name__)
-
-from cat_bonds import *
diff --git a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
index 3e5805e52..9e707d11e 100644
--- a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
@@ -2,12 +2,12 @@
 import numpy as np
 import logging
 
-from utils_cat_bonds import multi_level_es, allocate_single_payout
-import pooling_functions as pf
+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 MultiCountryBondSimulation:
+class MultiCountryBond:
 
     def __init__(self, country_dictionary, term, number_of_terms):
         self.country_dictionary = country_dictionary
@@ -66,7 +66,7 @@ def simulate_bond_pool_n(cls, country_dictionary, term, number_of_terms, princip
         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 = pf.process_n_pools(number_pools, countries_list, cls_bond_simulation, n_opt_rep=n_opt_rep)
+        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:
@@ -118,7 +118,7 @@ def simulate_bond_max_principal_pool(cls, country_dictionary, term, number_of_te
         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 = pf.process_maximum_principal_pools(maximum_principal, countries_list, cls_bond_simulation, n_opt_rep=n_opt_rep)
+        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:
diff --git a/climada_petals/engine/cat_bonds/sng_bond_simulation.py b/climada_petals/engine/cat_bonds/sng_bond_simulation.py
index 7938702f7..0e14dc11b 100644
--- a/climada_petals/engine/cat_bonds/sng_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/sng_bond_simulation.py
@@ -1,7 +1,7 @@
 import pandas as pd
 import numpy as np
 import logging
-from utils_cat_bonds import multi_level_es
+from .utils_cat_bonds import multi_level_es
 
 LOGGER = logging.getLogger(__name__)
 

From f30d74b3d2ffe3c7d728d653a12dbcf9ce9094d0 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 28 Nov 2025 16:12:17 +0100
Subject: [PATCH 088/125] move explode into exp_gdf function

---
 climada_petals/engine/cat_bonds/subareas.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/subareas.py b/climada_petals/engine/cat_bonds/subareas.py
index 51bf48034..05f0e25b7 100644
--- a/climada_petals/engine/cat_bonds/subareas.py
+++ b/climada_petals/engine/cat_bonds/subareas.py
@@ -145,7 +145,6 @@ def _init_subareas(exposure, resolution):
         """
         exp_gdf = _create_exp_gdf(exposure)
         logging.info("Number of polygons in exposure perimeter: %d", len(exp_gdf))
-        exp_gdf = exp_gdf.explode(ignore_index=True, index_parts=True)
         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))]
 
@@ -288,7 +287,7 @@ def _create_exp_gdf(exposure):
     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)
+    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

From fa871c81036653058952962b49b56e08f5e9df56 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 28 Nov 2025 16:26:16 +0100
Subject: [PATCH 089/125] initialize subaarea unit tests

---
 .../engine/cat_bonds/test/test_subarea.py     | 73 +++++++++++++++++++
 1 file changed, 73 insertions(+)
 create mode 100644 climada_petals/engine/cat_bonds/test/test_subarea.py

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..d91eee2f2
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/test/test_subarea.py
@@ -0,0 +1,73 @@
+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 _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) == 20, "There should be 20 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."
+
+
+if __name__ == "__main__":
+    exposure, exp_gdf = test_create_exp_gdf_returns_single_polygon()
+    _crop_grid_cells_to_polygon(exp_gdf, exposure)

From 16ce43db994445abdf9c26c434b736eb05945b86 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 28 Nov 2025 16:26:47 +0100
Subject: [PATCH 090/125] remove padding of exposure resolution

---
 climada_petals/engine/cat_bonds/subareas.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/climada_petals/engine/cat_bonds/subareas.py b/climada_petals/engine/cat_bonds/subareas.py
index 05f0e25b7..a272a1b11 100644
--- a/climada_petals/engine/cat_bonds/subareas.py
+++ b/climada_petals/engine/cat_bonds/subareas.py
@@ -265,7 +265,7 @@ def _create_exp_gdf(exposure):
     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
+    res = distances[:, 1].mean()
     LOGGER.info(f"Approximate resolution: {res} CRS units")
     width = max(int((maxx - minx) / res), 1)
     height = max(int((maxy - miny) / res),1)

From d784b82b60c1689b34bafb6962a4975ca187df5c Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 28 Nov 2025 16:32:13 +0100
Subject: [PATCH 091/125] add 1.2 padding to exposure resolution

---
 climada_petals/engine/cat_bonds/subareas.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/climada_petals/engine/cat_bonds/subareas.py b/climada_petals/engine/cat_bonds/subareas.py
index a272a1b11..863686cff 100644
--- a/climada_petals/engine/cat_bonds/subareas.py
+++ b/climada_petals/engine/cat_bonds/subareas.py
@@ -265,7 +265,7 @@ def _create_exp_gdf(exposure):
     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()
+    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)

From b7e95b424cbf696fd0501a3ba813dd63e1675d40 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 28 Nov 2025 17:02:12 +0100
Subject: [PATCH 092/125] add testing of merging polygons

---
 .../engine/cat_bonds/test/test_subarea.py     | 29 +++++++++++++++++--
 1 file changed, 26 insertions(+), 3 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/test/test_subarea.py b/climada_petals/engine/cat_bonds/test/test_subarea.py
index d91eee2f2..c2fcf9a3d 100644
--- a/climada_petals/engine/cat_bonds/test/test_subarea.py
+++ b/climada_petals/engine/cat_bonds/test/test_subarea.py
@@ -55,19 +55,42 @@ def test_create_exp_gdf_returns_single_polygon():
 
     return exposure, result
 
-def _crop_grid_cells_to_polygon(exp_gdf, exposure):
+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) == 20, "There should be 20 subareas created."
+    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():
+    # Create a GeoDataFrame with overlapping grid cells
+    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."
+
+    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."
+
 
 if __name__ == "__main__":
     exposure, exp_gdf = test_create_exp_gdf_returns_single_polygon()
-    _crop_grid_cells_to_polygon(exp_gdf, exposure)
+    test_crop_grid_cells_to_polygon(exp_gdf, exposure)
+    test_merge_overlapping_grids()

From c1f5d4dc82940280d3c46dc03495c9b308d810ef Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 28 Nov 2025 17:13:14 +0100
Subject: [PATCH 093/125] add more test cases to merging polyons

---
 .../engine/cat_bonds/test/test_subarea.py         | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/test/test_subarea.py b/climada_petals/engine/cat_bonds/test/test_subarea.py
index c2fcf9a3d..01b9752ae 100644
--- a/climada_petals/engine/cat_bonds/test/test_subarea.py
+++ b/climada_petals/engine/cat_bonds/test/test_subarea.py
@@ -75,10 +75,9 @@ def test_merge_overlapping_grids():
         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)]),
@@ -88,6 +87,18 @@ def test_merge_overlapping_grids():
     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__":

From 70cd21d5b791eecd1619a3b6410979982dad434c Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 1 Dec 2025 13:42:40 +0000
Subject: [PATCH 094/125] fromatting

---
 climada_petals/engine/cat_bonds/test/test_subarea.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/climada_petals/engine/cat_bonds/test/test_subarea.py b/climada_petals/engine/cat_bonds/test/test_subarea.py
index 01b9752ae..92c48d509 100644
--- a/climada_petals/engine/cat_bonds/test/test_subarea.py
+++ b/climada_petals/engine/cat_bonds/test/test_subarea.py
@@ -68,7 +68,6 @@ def test_crop_grid_cells_to_polygon(exp_gdf, exposure):
     ), "Exposure should be within the exposure perimeter polygon."
 
 def test_merge_overlapping_grids():
-    # Create a GeoDataFrame with overlapping grid cells
     polygon_over = [
         Polygon([(0, 0), (2, 0), (2, 2), (0, 2)]),
         Polygon([(1, 1), (3, 1), (3, 3), (1, 3)]),

From e5d515ab86bbaa25ce466c026490a136abe25c90 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 1 Dec 2025 13:42:53 +0000
Subject: [PATCH 095/125] init test subarea_calculations

---
 .../test/test_subarea_calculations.py         | 109 ++++++++++++++++++
 1 file changed, 109 insertions(+)
 create mode 100644 climada_petals/engine/cat_bonds/test/test_subarea_calculations.py

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..58a3db398
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py
@@ -0,0 +1,109 @@
+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_mean():
+    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]
+
+
+if __name__ == "__main__":
+    test_calc_payout_basic()
+    test_calc_attachment_principal_expected()
+    test_calc_parametric_index_mean()
+    print("All tests passed.")
\ No newline at end of file

From 963515185a7cf85aea9408978c69c38cff69fd41 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 1 Dec 2025 13:43:31 +0000
Subject: [PATCH 096/125] clearify variable origin

---
 climada_petals/engine/cat_bonds/subarea_calculations.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/subarea_calculations.py b/climada_petals/engine/cat_bonds/subarea_calculations.py
index 8cbf201d7..ccda88529 100644
--- a/climada_petals/engine/cat_bonds/subarea_calculations.py
+++ b/climada_petals/engine/cat_bonds/subarea_calculations.py
@@ -71,11 +71,8 @@ def _calc_impact(self):
             save_mat=True
         )
 
-        # get exp gdf
-        exp_gdf = self.subareas.exposure.gdf
-
         # Perform a spatial join to associate each exposure point with calculated impact with a subarea
-        exp_to_admin = exp_gdf.sjoin(self.subareas.subareas_gdf, how="left", predicate="within")
+        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
@@ -126,6 +123,7 @@ def _calc_attachment_principal(self, impact, attachment_point, exhaustion_point,
             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":

From b353942961dc8f64272f10d68b230edc7e518ae1 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 1 Dec 2025 14:16:31 +0000
Subject: [PATCH 097/125] fix bug

---
 climada_petals/engine/cat_bonds/subarea_calculations.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/climada_petals/engine/cat_bonds/subarea_calculations.py b/climada_petals/engine/cat_bonds/subarea_calculations.py
index ccda88529..6bd8c30d1 100644
--- a/climada_petals/engine/cat_bonds/subarea_calculations.py
+++ b/climada_petals/engine/cat_bonds/subarea_calculations.py
@@ -370,7 +370,7 @@ def _calc_pay_vs_dam(
             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) - 3):
+            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:

From f2e8f9083b177c517a68f77e1bf6f4d95f67d8f6 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 1 Dec 2025 14:16:42 +0000
Subject: [PATCH 098/125] add pay_vs_dam test function

---
 .../test/test_subarea_calculations.py         | 57 ++++++++++++++++++-
 1 file changed, 54 insertions(+), 3 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py b/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py
index 58a3db398..56e1d80e5 100644
--- a/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py
+++ b/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py
@@ -71,7 +71,7 @@ class Dummy:
     assert attachment_rp == 50
     assert principal_rp == 200
 
-def test_calc_parametric_index_mean():
+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]),
@@ -101,9 +101,60 @@ class DummySubareas:
     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
+    )
+    LOGGER.info(df)
+    # 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]
+
 
 if __name__ == "__main__":
     test_calc_payout_basic()
+    LOGGER.info("test_calc_payout_basic passed")
     test_calc_attachment_principal_expected()
-    test_calc_parametric_index_mean()
-    print("All tests passed.")
\ No newline at end of file
+    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")

From cd7432a98fbdfca69e600fe612f26fa8c0bc6fde Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 1 Dec 2025 14:43:48 +0000
Subject: [PATCH 099/125] add  test objective_function

---
 .../test/test_subarea_calculations.py         | 26 ++++++++++++++++++-
 1 file changed, 25 insertions(+), 1 deletion(-)

diff --git a/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py b/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py
index 56e1d80e5..f86b94312 100644
--- a/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py
+++ b/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py
@@ -139,7 +139,7 @@ class DummyImpact:
         imp, imp_sub, attachment=0, principal=50,
         opt_min_thresh=min_t, opt_max_thresh=max_t, haz_int=haz_int
     )
-    LOGGER.info(df)
+
     # event 0: no payouts → 0
     assert df.loc[0,"pay"] == 30
     # event 1: A pays 30 + B pays 40 → capped at principal = 50
@@ -148,6 +148,28 @@ class DummyImpact:
     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()
@@ -158,3 +180,5 @@ class DummyImpact:
     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")

From b2640012a784ab6a6cce01b875d6f704293a9ef2 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 1 Dec 2025 15:26:13 +0000
Subject: [PATCH 100/125] initiate test script for single country bonds

---
 .../engine/cat_bonds/test/test_sng_bond.py    | 45 +++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 climada_petals/engine/cat_bonds/test/test_sng_bond.py

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..1d4bdcc29
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/test/test_sng_bond.py
@@ -0,0 +1,45 @@
+import pandas as pd
+import numpy as np
+from scipy import sparse
+import logging
+from climada_petals.engine.cat_bonds.sng_bond_simulation import SingleCountryBondSimulation
+
+class DummySubareaCalc:
+    def __init__(self, principal=100):
+        self.principal = principal
+        self.pay_vs_dam = None  # filled separately
+
+logging.basicConfig(
+     format="{asctime} - {levelname} - {message}",
+     style="{",
+     datefmt="%Y-%m-%d %H:%M",
+     level=logging.INFO,
+ )
+LOGGER = logging.getLogger(__name__)
+
+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]
+
+
+if __name__ == "__main__":
+    test_init_bond_loss()
+    LOGGER.info("test_init_bond_loss passed")
\ No newline at end of file

From 56bee84ba432eff276d119e17627fdcb5c514717 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 1 Dec 2025 15:46:21 +0000
Subject: [PATCH 101/125] fix loop bug and remove simulated years

---
 climada_petals/engine/cat_bonds/sng_bond_simulation.py | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/sng_bond_simulation.py b/climada_petals/engine/cat_bonds/sng_bond_simulation.py
index 0e14dc11b..d1edde833 100644
--- a/climada_petals/engine/cat_bonds/sng_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/sng_bond_simulation.py
@@ -9,11 +9,9 @@ class SingleCountryBondSimulation:
 
     def __init__(self, subarea_calc, term, number_of_terms):
         self.term = term
-        self.simulated_years = number_of_terms * 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):
         """
@@ -118,10 +116,8 @@ def init_loss_simulation(self, confidence_levels=[0.95, 0.99]):
         list_loss_month = []
         total_payouts = 0
         total_damages = 0
-
         # Iterate directly over year-starts
-        for start_year in range(min_year, min_year + self.simulated_years - self.term):
-
+        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'])
@@ -138,6 +134,7 @@ def init_loss_simulation(self, confidence_levels=[0.95, 0.99]):
             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)

From 5de50d6085f9d02cb1556d7ec0d31a6e33d23d4d Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 1 Dec 2025 15:46:29 +0000
Subject: [PATCH 102/125] test simulate loss

---
 .../engine/cat_bonds/test/test_sng_bond.py    | 38 ++++++++++++++++++-
 1 file changed, 36 insertions(+), 2 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/test/test_sng_bond.py b/climada_petals/engine/cat_bonds/test/test_sng_bond.py
index 1d4bdcc29..86ad80176 100644
--- a/climada_petals/engine/cat_bonds/test/test_sng_bond.py
+++ b/climada_petals/engine/cat_bonds/test/test_sng_bond.py
@@ -7,7 +7,7 @@
 class DummySubareaCalc:
     def __init__(self, principal=100):
         self.principal = principal
-        self.pay_vs_dam = None  # filled separately
+        self.pay_vs_dam = pd.DataFrame()  # DataFrame to be set in tests
 
 logging.basicConfig(
      format="{asctime} - {levelname} - {message}",
@@ -39,7 +39,41 @@ def test_init_bond_loss():
     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
+
 
 if __name__ == "__main__":
     test_init_bond_loss()
-    LOGGER.info("test_init_bond_loss passed")
\ No newline at end of file
+    LOGGER.info("test_init_bond_loss passed")
+    test_init_loss_simulation()
+    LOGGER.info("test_init_loss_simulation passed")
\ No newline at end of file

From a7305bd06124bfaa8c97eec6b7159a9720c49521 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 1 Dec 2025 16:51:18 +0000
Subject: [PATCH 103/125] finish tests for single country bonds

---
 .../engine/cat_bonds/test/test_sng_bond.py    | 54 ++++++++++++++++++-
 1 file changed, 52 insertions(+), 2 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/test/test_sng_bond.py b/climada_petals/engine/cat_bonds/test/test_sng_bond.py
index 86ad80176..eddaa3fcc 100644
--- a/climada_petals/engine/cat_bonds/test/test_sng_bond.py
+++ b/climada_petals/engine/cat_bonds/test/test_sng_bond.py
@@ -1,6 +1,5 @@
 import pandas as pd
 import numpy as np
-from scipy import sparse
 import logging
 from climada_petals.engine.cat_bonds.sng_bond_simulation import SingleCountryBondSimulation
 
@@ -71,9 +70,60 @@ def test_init_loss_simulation():
     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")
\ No newline at end of file
+    LOGGER.info("test_init_loss_simulation passed")
+    test_init_return_simulation()
+    LOGGER.info("test_init_return_simulation passed")
\ No newline at end of file

From f7aae4214cc76bbc1a06cffe4e805ed9207bec5a Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 1 Dec 2025 16:51:29 +0000
Subject: [PATCH 104/125] formatting

---
 .../engine/cat_bonds/test/test_subarea_calculations.py           | 1 -
 1 file changed, 1 deletion(-)

diff --git a/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py b/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py
index f86b94312..94ff4a296 100644
--- a/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py
+++ b/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py
@@ -170,7 +170,6 @@ class Dummy:
     # 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")

From 76b10bcda9cd226be5ff554e4aea64614a93ee8d Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 1 Dec 2025 16:59:43 +0000
Subject: [PATCH 105/125] adjust descriptions

---
 climada_petals/engine/cat_bonds/premium_class.py | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/climada_petals/engine/cat_bonds/premium_class.py b/climada_petals/engine/cat_bonds/premium_class.py
index be0b96352..a1873182d 100644
--- a/climada_petals/engine/cat_bonds/premium_class.py
+++ b/climada_petals/engine/cat_bonds/premium_class.py
@@ -59,12 +59,14 @@ def calc_ibrd_premium(self, peril=None, year=None):
         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
@@ -99,12 +101,14 @@ def find_sharpe(self, premium, monthly_losses, target_sharpe):
         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.
@@ -147,12 +151,14 @@ 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.

From f53bc2e34c1624e3c3bca240eb53591055e13481 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 1 Dec 2025 17:07:49 +0000
Subject: [PATCH 106/125] initialize test for premium calculations

---
 .../cat_bonds/test/test_premium_class.py      | 87 +++++++++++++++++++
 1 file changed, 87 insertions(+)
 create mode 100644 climada_petals/engine/cat_bonds/test/test_premium_class.py

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..63b7ed336
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/test/test_premium_class.py
@@ -0,0 +1,87 @@
+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
+
+
+# ---------------------------------------------------------
+# TEST SHARPE OPTIMIZATION
+# ---------------------------------------------------------
+
+def test_find_sharpe_single_loss_event():
+    """
+    Validate net cash flow logic. 
+    1 year, 1 loss in June, simple numbers.
+    """
+    df = pd.DataFrame({
+        "losses": [[0.2]],
+        "months": [[6]]
+    })
+
+    bond = DummyBondSim(EL_ann=0.02, term=1, df_loss_month=df)
+    pc = PremiumCalculations(bond)
+
+    # manually compute NCF:
+    # Pre-event premium: (1 * p)/12 * 6
+    # Post-event premium: (0.8 * p)/12 * (12 - 6) - 0.2 loss
+    # NCF = p/2 + (0.8p/2 - 0.2) = 0.9p - 0.2
+    p = 0.05
+    expected_ncf = 0.9 * p - 0.2
+
+    sharpe = pc.find_sharpe(premium=p, monthly_losses=df, target_sharpe=0)
+
+    # extracted NCF from method
+    ncf = []
+    cur_nominal = 1
+    losses = [0.2]
+    months = [6]
+    ncf_pre = (cur_nominal * p) / 12 * 6
+    cur_nominal -= 0.2
+    ncf_post = (cur_nominal * p) / 12 * 6 - 0.2
+    manual_list = [ncf_pre + ncf_post]
+
+    manual_sharpe = (np.mean(manual_list) / np.std(manual_list + [manual_list[0] * 1.0001]))**2  # std>0
+
+    assert np.isclose(sharpe, manual_sharpe, rtol=1e-6)  # just ensure valid number
+    assert np.isclose(expected_ncf, manual_list[0], rtol=1e-6)
+
+
+def test_calc_benchmark_premium_converges():
+    """
+    Test that optimization finds higher premium when losses > 0.
+    """
+
+    df = pd.DataFrame({
+        "losses": [[0.1], [0.2], [0.0]],
+        "months": [[3], [6], [0]]
+    })
+
+    bond = DummyBondSim(EL_ann=0.02, term=1, df_loss_month=df)
+    pc = PremiumCalculations(bond)
+
+    pc.calc_benchmark_premium(target_sharpe=0.2)
+
+    assert pc.benchmark_prem_rate > 0
+    assert pc.benchmark_prem_rate < 1.0  # sanity bound
+
+
+if __name__ == "__main__":
+    test_calc_benchmark_premium_converges()
+    LOGGER.info("test_calc_benchmark_premium_converges passed")
+    test_find_sharpe_single_loss_event()
+    LOGGER.info("test_find_sharpe_single_loss_event passed")

From bcd29f726a913f04a69852b4d0bf400d13d16722 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 1 Dec 2025 17:07:56 +0000
Subject: [PATCH 107/125] format

---
 climada_petals/engine/cat_bonds/test/test_sng_bond.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/test/test_sng_bond.py b/climada_petals/engine/cat_bonds/test/test_sng_bond.py
index eddaa3fcc..0ac0eeb05 100644
--- a/climada_petals/engine/cat_bonds/test/test_sng_bond.py
+++ b/climada_petals/engine/cat_bonds/test/test_sng_bond.py
@@ -3,11 +3,6 @@
 import logging
 from climada_petals.engine.cat_bonds.sng_bond_simulation import SingleCountryBondSimulation
 
-class DummySubareaCalc:
-    def __init__(self, principal=100):
-        self.principal = principal
-        self.pay_vs_dam = pd.DataFrame()  # DataFrame to be set in tests
-
 logging.basicConfig(
      format="{asctime} - {levelname} - {message}",
      style="{",
@@ -16,6 +11,11 @@ def __init__(self, principal=100):
  )
 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)

From e63caaa42ba856291d5fa1ed5fe1f9e5389b2a25 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 1 Dec 2025 17:57:00 +0000
Subject: [PATCH 108/125] test benchmark sharpe ration function

---
 .../cat_bonds/test/test_premium_class.py      | 74 +++++--------------
 1 file changed, 20 insertions(+), 54 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/test/test_premium_class.py b/climada_petals/engine/cat_bonds/test/test_premium_class.py
index 63b7ed336..e34198e27 100644
--- a/climada_petals/engine/cat_bonds/test/test_premium_class.py
+++ b/climada_petals/engine/cat_bonds/test/test_premium_class.py
@@ -19,69 +19,35 @@ def __init__(self, EL_ann, term, df_loss_month=None):
         self.df_loss_month = df_loss_month
 
 
-# ---------------------------------------------------------
-# TEST SHARPE OPTIMIZATION
-# ---------------------------------------------------------
-
-def test_find_sharpe_single_loss_event():
+def test_find_sharpe():
     """
     Validate net cash flow logic. 
     1 year, 1 loss in June, simple numbers.
     """
     df = pd.DataFrame({
-        "losses": [[0.2]],
-        "months": [[6]]
-    })
-
-    bond = DummyBondSim(EL_ann=0.02, term=1, df_loss_month=df)
-    pc = PremiumCalculations(bond)
-
-    # manually compute NCF:
-    # Pre-event premium: (1 * p)/12 * 6
-    # Post-event premium: (0.8 * p)/12 * (12 - 6) - 0.2 loss
-    # NCF = p/2 + (0.8p/2 - 0.2) = 0.9p - 0.2
-    p = 0.05
-    expected_ncf = 0.9 * p - 0.2
-
-    sharpe = pc.find_sharpe(premium=p, monthly_losses=df, target_sharpe=0)
-
-    # extracted NCF from method
-    ncf = []
-    cur_nominal = 1
-    losses = [0.2]
-    months = [6]
-    ncf_pre = (cur_nominal * p) / 12 * 6
-    cur_nominal -= 0.2
-    ncf_post = (cur_nominal * p) / 12 * 6 - 0.2
-    manual_list = [ncf_pre + ncf_post]
-
-    manual_sharpe = (np.mean(manual_list) / np.std(manual_list + [manual_list[0] * 1.0001]))**2  # std>0
-
-    assert np.isclose(sharpe, manual_sharpe, rtol=1e-6)  # just ensure valid number
-    assert np.isclose(expected_ncf, manual_list[0], rtol=1e-6)
-
-
-def test_calc_benchmark_premium_converges():
-    """
-    Test that optimization finds higher premium when losses > 0.
-    """
-
-    df = pd.DataFrame({
-        "losses": [[0.1], [0.2], [0.0]],
-        "months": [[3], [6], [0]]
+        "losses": [[0], [0], [0], [0], [0], [0.1]],
+        "months": [[], [], [], [], [] , [1]]
     })
-
-    bond = DummyBondSim(EL_ann=0.02, term=1, df_loss_month=df)
+    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=0.2)
+    pc.calc_benchmark_premium(target_sharpe=manual_sharpe)
 
-    assert pc.benchmark_prem_rate > 0
-    assert pc.benchmark_prem_rate < 1.0  # sanity bound
+    assert np.isclose(np.array(pc.benchmark_prem_rate), np.array(manual_premium), rtol=1e-6) 
 
 
 if __name__ == "__main__":
-    test_calc_benchmark_premium_converges()
-    LOGGER.info("test_calc_benchmark_premium_converges passed")
-    test_find_sharpe_single_loss_event()
-    LOGGER.info("test_find_sharpe_single_loss_event passed")
+    test_find_sharpe()
+    LOGGER.info("test_find_sharpe passed")

From b8b65f161560bfd932aa0aeee0629a8e0c526017 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 1 Dec 2025 17:57:16 +0000
Subject: [PATCH 109/125] formatting

---
 climada_petals/engine/cat_bonds/premium_class.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/climada_petals/engine/cat_bonds/premium_class.py b/climada_petals/engine/cat_bonds/premium_class.py
index a1873182d..a863e5ee6 100644
--- a/climada_petals/engine/cat_bonds/premium_class.py
+++ b/climada_petals/engine/cat_bonds/premium_class.py
@@ -66,7 +66,7 @@ def calc_ibrd_premium(self, peril=None, year=None):
             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

From 9434653cb079750a4f90af64d4efa631b57ef81b Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 1 Dec 2025 18:14:33 +0000
Subject: [PATCH 110/125] update function description

---
 climada_petals/engine/cat_bonds/utils_cat_bonds.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/climada_petals/engine/cat_bonds/utils_cat_bonds.py b/climada_petals/engine/cat_bonds/utils_cat_bonds.py
index 7fa927d37..b98e452d2 100644
--- a/climada_petals/engine/cat_bonds/utils_cat_bonds.py
+++ b/climada_petals/engine/cat_bonds/utils_cat_bonds.py
@@ -10,7 +10,8 @@ def multi_level_es(losses, confidence_levels):
     - confidence_levels: list of floats, confidence levels (e.g., [0.95, 0.99])
 
     Returns:
-    - risk_metrics: dict, VaR and ES values keyed by confidence level
+    - 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

From bd5b76ddfe2b54fd34ba07cb8c7c24b9561a124e Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 1 Dec 2025 18:24:52 +0000
Subject: [PATCH 111/125] test multi_level_es function

---
 .../cat_bonds/test/test_utils_cat_bonds.py    | 63 +++++++++++++++++++
 1 file changed, 63 insertions(+)
 create mode 100644 climada_petals/engine/cat_bonds/test/test_utils_cat_bonds.py

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

From a3ca2a0bec8baab95bc7f812735a5f4a59b381f0 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 1 Dec 2025 18:24:59 +0000
Subject: [PATCH 112/125] formatting

---
 climada_petals/engine/cat_bonds/utils_cat_bonds.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/climada_petals/engine/cat_bonds/utils_cat_bonds.py b/climada_petals/engine/cat_bonds/utils_cat_bonds.py
index b98e452d2..3960a5f68 100644
--- a/climada_petals/engine/cat_bonds/utils_cat_bonds.py
+++ b/climada_petals/engine/cat_bonds/utils_cat_bonds.py
@@ -11,7 +11,7 @@ def multi_level_es(losses, confidence_levels):
 
     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
+    - es_list: list, list of ES values in the order of given confidence levels
     """
 
     # Compute VaR and ES

From 64c233c927dda014b9c9f495d7182df13a76b730 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 12 Dec 2025 09:21:44 +0100
Subject: [PATCH 113/125] update logging to petals LOGGER

---
 climada_petals/engine/cat_bonds/__init__.py   |  3 -
 .../engine/cat_bonds/mlt_bond_simulation.py   |  4 +-
 .../engine/cat_bonds/premium_class.py         |  4 +-
 .../engine/cat_bonds/sng_bond_simulation.py   |  4 +-
 .../engine/cat_bonds/subarea_calculations.py  |  5 +-
 climada_petals/engine/cat_bonds/subareas.py   |  3 +-
 .../cat_bonds/test/test_premium_class.py      | 11 +---
 .../engine/cat_bonds/test/test_sng_bond.py    |  9 +--
 .../engine/cat_bonds/test/test_subarea.py     | 10 +--
 .../test/test_subarea_calculations.py         | 10 +--
 .../cat_bonds/test/test_utils_cat_bonds.py    | 61 ++++++++++++++++---
 11 files changed, 68 insertions(+), 56 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/__init__.py b/climada_petals/engine/cat_bonds/__init__.py
index f703c791c..85dfc1f8e 100644
--- a/climada_petals/engine/cat_bonds/__init__.py
+++ b/climada_petals/engine/cat_bonds/__init__.py
@@ -17,6 +17,3 @@
 ---
 """
 
-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
index 9e707d11e..13fbe770d 100644
--- a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
@@ -1,11 +1,11 @@
 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__)
+from climada_petals.util.config import LOGGER
+
 
 class MultiCountryBond:
 
diff --git a/climada_petals/engine/cat_bonds/premium_class.py b/climada_petals/engine/cat_bonds/premium_class.py
index a863e5ee6..3aef093a9 100644
--- a/climada_petals/engine/cat_bonds/premium_class.py
+++ b/climada_petals/engine/cat_bonds/premium_class.py
@@ -3,13 +3,11 @@
 from pathlib import Path
 from scipy.optimize import curve_fit, minimize
 
-import logging
+from climada_petals.util.config import LOGGER
 
 # 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
diff --git a/climada_petals/engine/cat_bonds/sng_bond_simulation.py b/climada_petals/engine/cat_bonds/sng_bond_simulation.py
index d1edde833..1ba431574 100644
--- a/climada_petals/engine/cat_bonds/sng_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/sng_bond_simulation.py
@@ -1,9 +1,9 @@
 import pandas as pd
 import numpy as np
-import logging
 from .utils_cat_bonds import multi_level_es
 
-LOGGER = logging.getLogger(__name__)
+from climada_petals.util.config import LOGGER
+
 
 class SingleCountryBondSimulation:
 
diff --git a/climada_petals/engine/cat_bonds/subarea_calculations.py b/climada_petals/engine/cat_bonds/subarea_calculations.py
index 6bd8c30d1..d296bb706 100644
--- a/climada_petals/engine/cat_bonds/subarea_calculations.py
+++ b/climada_petals/engine/cat_bonds/subarea_calculations.py
@@ -1,13 +1,12 @@
 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__)
+from climada_petals.util.config import LOGGER
+
 
 
 
diff --git a/climada_petals/engine/cat_bonds/subareas.py b/climada_petals/engine/cat_bonds/subareas.py
index 863686cff..31e8b65ed 100644
--- a/climada_petals/engine/cat_bonds/subareas.py
+++ b/climada_petals/engine/cat_bonds/subareas.py
@@ -11,9 +11,8 @@
 import cartopy.crs as ccrs
 import networkx as nx
 
-import logging
+from climada_petals.util.config import LOGGER
 
-LOGGER = logging.getLogger(__name__)
 
 
 class Subareas:
diff --git a/climada_petals/engine/cat_bonds/test/test_premium_class.py b/climada_petals/engine/cat_bonds/test/test_premium_class.py
index e34198e27..bf7c1a91e 100644
--- a/climada_petals/engine/cat_bonds/test/test_premium_class.py
+++ b/climada_petals/engine/cat_bonds/test/test_premium_class.py
@@ -1,15 +1,9 @@
 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__)
+from climada_petals.util.config import LOGGER
+
 
 class DummyBondSim:
     """Minimum mock needed for PremiumCalculations."""
@@ -28,7 +22,6 @@ def test_find_sharpe():
         "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)
diff --git a/climada_petals/engine/cat_bonds/test/test_sng_bond.py b/climada_petals/engine/cat_bonds/test/test_sng_bond.py
index 0ac0eeb05..7234000c9 100644
--- a/climada_petals/engine/cat_bonds/test/test_sng_bond.py
+++ b/climada_petals/engine/cat_bonds/test/test_sng_bond.py
@@ -1,15 +1,8 @@
 import pandas as pd
 import numpy as np
-import logging
 from climada_petals.engine.cat_bonds.sng_bond_simulation import SingleCountryBondSimulation
+from climada_petals.util.config import LOGGER
 
-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):
diff --git a/climada_petals/engine/cat_bonds/test/test_subarea.py b/climada_petals/engine/cat_bonds/test/test_subarea.py
index 92c48d509..3b7ef2975 100644
--- a/climada_petals/engine/cat_bonds/test/test_subarea.py
+++ b/climada_petals/engine/cat_bonds/test/test_subarea.py
@@ -1,15 +1,9 @@
 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__)
+from climada_petals.util.config import LOGGER
+
 
 
 class DummyExposure:
diff --git a/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py b/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py
index 94ff4a296..8c31155a3 100644
--- a/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py
+++ b/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py
@@ -6,14 +6,8 @@
 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__)
+from climada_petals.util.config import LOGGER
+
 
 def test_calc_payout_basic():
     """Test basic functionality of calc_payout function."""
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
index fc6072251..d2a1f1c92 100644
--- a/climada_petals/engine/cat_bonds/test/test_utils_cat_bonds.py
+++ b/climada_petals/engine/cat_bonds/test/test_utils_cat_bonds.py
@@ -1,15 +1,9 @@
 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__)
+from climada_petals.util.config import LOGGER
+
 
 def test_multi_level_es_basic():
     losses = pd.Series([0, 1, 2, 3, 4, 5])
@@ -54,6 +48,57 @@ def test_multi_level_es_no_tail_losses():
     # ES must be 1
     assert es_list[0] == 1
 
+
+def test_allocate_single_payout_partial_first_tranche():
+    nominals = np.array([100, 100, 100])
+    payout = 30
+
+    remaining, alloc = utils_cat_bonds.allocate_single_payout(payout, nominals)
+
+    assert np.allclose(alloc, [30, 0, 0])
+    assert np.allclose(remaining, [70, 100, 100])
+
+
+def test_allocate_single_payout_exact_first_tranche():
+    nominals = np.array([50, 100])
+    payout = 50
+
+    remaining, alloc = utils_cat_bonds.allocate_single_payout(payout, nominals)
+
+    assert np.allclose(alloc, [50, 0])
+    assert np.allclose(remaining, [0, 100])
+
+
+def test_allocate_single_payout_spans_multiple_tranches():
+    nominals = np.array([50, 100, 200])
+    payout = 180  # eats all of tranche 1 and 2, 30 of tranche 3
+
+    remaining, alloc = utils_cat_bonds.allocate_single_payout(payout, nominals)
+
+    assert np.allclose(alloc, [50, 100, 30])
+    assert np.allclose(remaining, [0, 0, 170])
+
+
+def test_allocate_single_payout_larger_than_all_nominals():
+    nominals = np.array([40, 40])
+    payout = 200  # everything wiped
+
+    remaining, alloc = utils_cat_bonds.allocate_single_payout(payout, nominals)
+
+    assert np.allclose(alloc, [40, 40])
+    assert np.allclose(remaining, [0, 0])
+
+
+def test_allocate_single_payout_zero_payout():
+    nominals = np.array([50, 100])
+    payout = 0
+
+    remaining, alloc = utils_cat_bonds.allocate_single_payout(payout, nominals)
+
+    assert np.allclose(alloc, [0, 0])
+    assert np.allclose(remaining, nominals)
+
+
 if __name__ == "__main__":
     test_multi_level_es_basic()
     LOGGER.info("test_multi_level_es_basic passed")

From 301b4859c445968e1e24352dce738633cc86047d Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 12 Dec 2025 14:22:18 +0100
Subject: [PATCH 114/125] restructure tests

---
 .../test/test_subarea_calculations.py         | 294 +++++++++---------
 1 file changed, 152 insertions(+), 142 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py b/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py
index 8c31155a3..533d9cfde 100644
--- a/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py
+++ b/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py
@@ -7,171 +7,181 @@
 from scipy import sparse
 from shapely.geometry import Polygon
 from climada_petals.util.config import LOGGER
+import unittest
+from unittest.mock import MagicMock
+from scipy.optimize import OptimizeResult
+from climada.engine import ImpactCalc
+
+class TestSubareaCalculations(unittest.TestCase):
+
+    def setUp(self):
+        self.mock_subarea_calc_test = MagicMock()
+        self.mock_subarea_calc_test.haz_int = pd.DataFrame({"intensity": [0, 5, 10, 15, 20]})
+        self.mock_subarea_calc_test.haz_int_dict = {"TC": pd.DataFrame({
+            "A": [1, 2],
+            "B": [3, 4],
+            "year": [2000, 2000],
+            "month": [1, 2]
+        })}
+        self.mock_subarea_calc_test.principal = 100
+        self.mock_subarea_calc_test.exposure = type("exp", (), {"gdf": {"value": pd.Series([100, 300])}})
+        self.mock_subarea_calc_test.imp_subarea = pd.DataFrame({"A": [0, 60], "B": [5, 80]})
+
+        
+    def test_calc_payout_basic(self):
+        """Test basic functionality of calc_payout function."""
+        min_trig = 5
+        max_trig = 15
+
+        payouts = subarea_calculations.calc_payout(min_trig, max_trig, self.mock_subarea_calc_test.haz_int, self.mock_subarea_calc_test.principal )
+
+        # Expected:
+        # intensity < 5 → 0
+        # 5 → 0
+        # 10 → 100
+        # ≥ 15 → 100
+        assert np.allclose(payouts, [0, 0, 50, 100, 100])
+
+    def test_calc_attachment_principal_expected(self):
+
+        class DummyImpact:
+            def calc_freq_curve(self, rp):
+                return type("obj", (), {"impact": rp * 10})  # simple mapping
+
+
+        s = subarea_calculations.SubareaCalculations(self.mock_subarea_calc_test, 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(self):
+        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")
+        d = {'subarea_letter': ['A', 'B'], 'geometry': [Polygon([(0, 0), (2, 0), (2, 2), (0, 2)]), Polygon([(3, 3), (5, 3), (5, 5), (3, 5)])]}
+        self.mock_subarea_calc_test.hazard = hazard_dummy
+        self.mock_subarea_calc_test.subareas_gdf = gpd.GeoDataFrame(d, crs="EPSG:4326")
 
+        subareas_calc_dummy = subarea_calculations.SubareaCalculations(
+            subareas=self.mock_subarea_calc_test, index_stat="mean"
+        )
 
-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()
 
-    out = subareas_calc_dummy._calc_parametric_index()
+        df = out["TC"]
 
-    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]
 
-    # 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=self.mock_subarea_calc_test, index_stat=50
+        )
 
-    subareas_calc_dummy_2 = subarea_calculations.SubareaCalculations(
-        subareas=subareas_dummy, index_stat=50
-    )
+        out_2 = subareas_calc_dummy_2._calc_parametric_index()
 
-    out_2 = subareas_calc_dummy_2._calc_parametric_index()
+        df_2 = out_2["TC"]
 
-    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]
 
-    # 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(self):
 
-def test_calc_pay_vs_dam_expected():
+        class DummyImpact:
+            at_event = np.array([5, 130])  # event damages
 
-    class DummyImpact:
-        at_event = np.array([10, 70])  # event damages
+        imp = DummyImpact()
 
-    imp = DummyImpact()
+        s = subarea_calculations.SubareaCalculations(subareas=None, index_stat="mean", intitial_guess=[1,2])
 
-    imp_sub = pd.DataFrame({"A": [0, 30], "B": [5, 40]})
+        # thresholds
+        min_t = np.array([1, 0])
+        max_t = np.array([2, 4])
 
-    haz_int = {"TC": pd.DataFrame({
-        "A": [1, 2],
-        "B": [3, 4],
-        "year": [2000, 2000],
-        "month": [1, 2]
-    })}
+        df = s._calc_pay_vs_dam(
+            imp, self.mock_subarea_calc_test.imp_subarea, attachment=0, principal=self.mock_subarea_calc_test.principal,
+            opt_min_thresh=min_t, opt_max_thresh=max_t, haz_int=self.mock_subarea_calc_test.haz_int_dict
+        )
 
-    s = subarea_calculations.SubareaCalculations(subareas=None, index_stat="mean", intitial_guess=[1,2])
+        # event 0: Payout for Subarea B -> 60
+        assert df.loc[0,"pay"] == 60
+        # event 1: A pays 30 + B pays 60 → capped at principal = 40
+        assert df.loc[1,"pay"] == 100
+        # damage 
+        assert df['damage'].to_list() == [5, 130]
+        # year/month copied
+        assert df["year"].tolist() == [2000, 2000]
+        assert df["month"].tolist() == [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
-    )
+    def test_objective_fct_expected(self):
 
-    # 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]
+        s = subarea_calculations.SubareaCalculations(subareas=self.mock_subarea_calc_test, index_stat="mean", intitial_guess=(0, 1))
 
-def test_objective_fct_expected():
+        damages = np.array([100, 200])
 
-    class Dummy:
-        pass
+        out = s._objective_fct((0, 2), self.mock_subarea_calc_test.haz_int_dict['TC'], damages, self.mock_subarea_calc_test.principal)
 
-    s = subarea_calculations.SubareaCalculations(subareas=Dummy(), index_stat="mean", intitial_guess=(0, 1))
+        # expected = (100-50)^2 + (200-100)^2 = 50^2 + 100^2 = 12500
+        assert out == 12500
 
-    damages = np.array([0, 10, 20])
-    haz_int = pd.DataFrame({
-        "A": np.array([0, 1, 2]), 
-        "year": [2000, 2000, 2000],
-        "month": [1, 1, 1]
-    })
+    def test_calibration_converges_to_expected_thresholds(self):
+        """
+        Test that the optimization converges and reports a thresholds for all subareas.
+        """
+        subareas_calc_dummy = subarea_calculations.SubareaCalculations(
+            subareas=self.mock_subarea_calc_test, index_stat=50, intitial_guess=[2,4]
+        )
 
-    # principal less than max_dam → max_pay = principal
-    principal = 20
+        attachment = 0 
 
-    out = s._objective_fct((0, 2), haz_int, damages, principal)
+        results, opt_min, opt_max = subareas_calc_dummy._calibrate_payout_fcts(
+            haz_int=self.mock_subarea_calc_test.haz_int_dict,
+            principal=self.mock_subarea_calc_test.principal,
+            attachment=attachment,
+            imp_subarea_evt=self.mock_subarea_calc_test.imp_subarea
+        )
 
-    # expected = (0-0)^2 + (10-10)^2 + (20-20)^2 = 0 + 25 + 25 = 0
-    assert out == 0
+        # optimizer should converge near
+        assert np.allclose(opt_min, [1, 2], atol=1)
+        assert np.allclose(opt_max, [3, 4], atol=1)
+
+        # ensure both subareas were optimized
+        assert len(results) == 2
+        assert all(isinstance(r, OptimizeResult) for r in results.values())
+        assert all(r.success for r in results.values())
+
+    
 
 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")
+    TESTS = unittest.TestLoader().loadTestsFromTestCase(TestSubareaCalculations)
+    unittest.TextTestRunner(verbosity=2).run(TESTS)

From d857f33d5690ee2cb08f49995db3c85f96d66a24 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 12 Dec 2025 14:39:50 +0100
Subject: [PATCH 115/125] changed structure of tests

---
 .../engine/cat_bonds/test/test_subarea.py     | 166 +++++++++---------
 .../test/test_subarea_calculations.py         |   1 -
 2 files changed, 82 insertions(+), 85 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/test/test_subarea.py b/climada_petals/engine/cat_bonds/test/test_subarea.py
index 3b7ef2975..a229e46ad 100644
--- a/climada_petals/engine/cat_bonds/test/test_subarea.py
+++ b/climada_petals/engine/cat_bonds/test/test_subarea.py
@@ -3,7 +3,8 @@
 from climada_petals.engine.cat_bonds import subareas
 
 from climada_petals.util.config import LOGGER
-
+import unittest
+from unittest.mock import MagicMock
 
 
 class DummyExposure:
@@ -11,90 +12,87 @@ class DummyExposure:
     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."
+class TestSubarea(unittest.TestCase):
+
+    def setUp(self):
+        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"
+        )
+
+        self.exposure = MagicMock()
+        self.exposure.gdf = gdf
+        result = subareas._create_exp_gdf(self.exposure)
+        self.exposure.result = result
+
+    def test_create_exp_gdf_returns_single_polygon(self):
+        # --- Assert --------------------------------------------------------------------
+        # 1. Should contain exactly one merged polygon
+        assert len(self.exposure.result.geometry) == 2
+
+        # 2. All geometries should be of type Polygon and not empty
+        for geom in self.exposure.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 = self.exposure.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
+
+
+    def test_crop_grid_cells_to_polygon(self):
+        resolution = 1.0
+        subareas_gdf = subareas._crop_grid_cells_to_polygon(resolution, self.exposure.result, self.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 self.exposure.result.geometry
+        ), "Exposure should be within the exposure perimeter polygon."
+
+    def test_merge_overlapping_grids(self):
+        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()
+    TESTS = unittest.TestLoader().loadTestsFromTestCase(TestSubarea)
+    unittest.TextTestRunner(verbosity=2).run(TESTS)
diff --git a/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py b/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py
index 533d9cfde..9fe80b419 100644
--- a/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py
+++ b/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py
@@ -10,7 +10,6 @@
 import unittest
 from unittest.mock import MagicMock
 from scipy.optimize import OptimizeResult
-from climada.engine import ImpactCalc
 
 class TestSubareaCalculations(unittest.TestCase):
 

From 675f46014120f91d826dbfab4ef63f7a99e89cf7 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 12 Dec 2025 14:43:56 +0100
Subject: [PATCH 116/125] change structure of tests

---
 .../engine/cat_bonds/test/test_sng_bond.py    | 217 +++++++++---------
 1 file changed, 106 insertions(+), 111 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/test/test_sng_bond.py b/climada_petals/engine/cat_bonds/test/test_sng_bond.py
index 7234000c9..dc6bb89b1 100644
--- a/climada_petals/engine/cat_bonds/test/test_sng_bond.py
+++ b/climada_petals/engine/cat_bonds/test/test_sng_bond.py
@@ -2,121 +2,116 @@
 import numpy as np
 from climada_petals.engine.cat_bonds.sng_bond_simulation import SingleCountryBondSimulation
 from climada_petals.util.config import LOGGER
+import unittest
+from unittest.mock import MagicMock
 
 
-class DummySubareaCalc:
-    def __init__(self, principal=100):
-        self.principal = principal
+class TestSingleCountryBond(unittest.TestCase):
+    def setUp(self):
+        self.principal = 100
         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)
+    def test_init_bond_loss(self):
+        sim = SingleCountryBondSimulation(subarea_calc=self, 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(self):
+
+        self.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=self, 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(self):
+        sim = SingleCountryBondSimulation(subarea_calc=self, 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
+    TESTS = unittest.TestLoader().loadTestsFromTestCase(TestSingleCountryBond)
+    unittest.TextTestRunner(verbosity=2).run(TESTS)
\ No newline at end of file

From c8c5e241db7e705cea5f6a13884c7a260be31c26 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 12 Dec 2025 14:57:55 +0100
Subject: [PATCH 117/125] adjust test structure

---
 .../cat_bonds/test/test_premium_class.py      | 94 +++++++++++++------
 .../engine/cat_bonds/test/test_sng_bond.py    |  2 -
 2 files changed, 65 insertions(+), 31 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/test/test_premium_class.py b/climada_petals/engine/cat_bonds/test/test_premium_class.py
index bf7c1a91e..fe1033ec5 100644
--- a/climada_petals/engine/cat_bonds/test/test_premium_class.py
+++ b/climada_petals/engine/cat_bonds/test/test_premium_class.py
@@ -3,44 +3,80 @@
 from climada_petals.engine.cat_bonds.premium_class import PremiumCalculations  
 
 from climada_petals.util.config import LOGGER
+import unittest
 
+# 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 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
 
+class TestPremiumCalculations(unittest.TestCase):
 
-def test_find_sharpe():
-    """
-    Validate net cash flow logic. 
-    1 year, 1 loss in June, simple numbers.
-    """
-    df = pd.DataFrame({
+    def setUp(self):
+        self.loss_metrics = {"EL_ann":  0.1}
+        self.term = 1
+        self.df_loss_month = pd.DataFrame({
         "losses": [[0], [0], [0], [0], [0], [0.1]],
         "months": [[], [], [], [], [] , [1]]
     })
-    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))
+        
+    def test_find_sharpe(self):
+        """
+        Validate net cash flow logic. 
+        1 year, 1 loss in June, simple numbers.
+        """
+
+        pc = PremiumCalculations(self)
+        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) 
+
+    def test_calc_chatoro_premium(self):
+        """
+        Test if the formula for chatoro premium is used as intended.
+        """
+        peak_multi = 0
+        investment_graded = 0
+        hybrid_trigger = 0
+        GCIndex = 180
+        BBSpread = 1.6
+        pc = PremiumCalculations(self)
+        pc.calc_chatoro_premium(peak_multi=peak_multi, investment_graded=investment_graded, hybrid_trigger=hybrid_trigger)
+
+        manual_chat_prem = (b_0 + b_1 * self.loss_metrics['EL_ann'] * 100 + b_2 * peak_multi + b_3 * GCIndex + b_4 * BBSpread + b_5 * self.term * 12 + b_6 * investment_graded + b_7 * hybrid_trigger) / 100
+
+        assert manual_chat_prem == pc.chatoro_prem_rate
+
+    def test_ibrd_premium(self):
+        """
+        Test if premium rates for the IBRD method are calculated as intended.
+        """
+        pc = PremiumCalculations(self)
+        pc.calc_ibrd_premium()
+
+        assert 0.1 < pc.ibrd_prem_rate < 0.3
+
 
-    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")
+    TESTS = unittest.TestLoader().loadTestsFromTestCase(TestPremiumCalculations)
+    unittest.TextTestRunner(verbosity=2).run(TESTS)
diff --git a/climada_petals/engine/cat_bonds/test/test_sng_bond.py b/climada_petals/engine/cat_bonds/test/test_sng_bond.py
index dc6bb89b1..5eb909afd 100644
--- a/climada_petals/engine/cat_bonds/test/test_sng_bond.py
+++ b/climada_petals/engine/cat_bonds/test/test_sng_bond.py
@@ -3,8 +3,6 @@
 from climada_petals.engine.cat_bonds.sng_bond_simulation import SingleCountryBondSimulation
 from climada_petals.util.config import LOGGER
 import unittest
-from unittest.mock import MagicMock
-
 
 class TestSingleCountryBond(unittest.TestCase):
     def setUp(self):

From 8eaa0c0f2b3a71597e674c55035204d6c7e793a4 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 12 Dec 2025 15:36:32 +0100
Subject: [PATCH 118/125] change test structure

---
 .../cat_bonds/test/test_utils_cat_bonds.py    | 127 +++++++++---------
 1 file changed, 63 insertions(+), 64 deletions(-)

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
index d2a1f1c92..63f059e58 100644
--- a/climada_petals/engine/cat_bonds/test/test_utils_cat_bonds.py
+++ b/climada_petals/engine/cat_bonds/test/test_utils_cat_bonds.py
@@ -3,106 +3,105 @@
 from climada_petals.engine.cat_bonds import utils_cat_bonds
 
 from climada_petals.util.config import LOGGER
+import unittest
 
 
-def test_multi_level_es_basic():
-    losses = pd.Series([0, 1, 2, 3, 4, 5])
-    alphas = [0.5, 0.8]
+class TestUtils(unittest.TestCase):
 
-    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))
+    def test_multi_level_es_basic(self):
+        losses = pd.Series([0, 1, 2, 3, 4, 5])
+        alphas = [0.5, 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
+        var_list, es_list = utils_cat_bonds.multi_level_es(losses, alphas)
 
-    assert np.isclose(es_list[0], es_expected_50)
-    assert np.isclose(es_list[1], es_expected_80)
+        # 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
 
-def test_multi_level_es_all_equal_losses():
-    losses = pd.Series([1, 1, 1, 1])
-    alphas = [0.95]
+        assert np.isclose(es_list[0], es_expected_50)
+        assert np.isclose(es_list[1], es_expected_80)
 
-    var_list, es_list = utils_cat_bonds.multi_level_es(losses, alphas)
 
-    # VaR = 1
-    assert var_list[0] == 1
+    def test_multi_level_es_all_equal_losses(self):
+        losses = pd.Series([1, 1, 1, 1])
+        alphas = [0.95]
 
-    # ES = 1
-    assert es_list[0] == 1
+        var_list, es_list = utils_cat_bonds.multi_level_es(losses, alphas)
 
+        # VaR = 1
+        assert var_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
+        # ES = 1
+        assert es_list[0] == 1
 
-    var_list, es_list = utils_cat_bonds.multi_level_es(losses, alphas)
 
-    # VaR must be 0
-    assert var_list[0] == 0
+    def test_multi_level_es_no_tail_losses(self):
+        losses = pd.Series([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
+        alphas = [0.9]  # VaR = 0
 
-    # ES must be 1
-    assert es_list[0] == 1
+        var_list, es_list = utils_cat_bonds.multi_level_es(losses, alphas)
 
+        # VaR must be 0
+        assert var_list[0] == 0
 
-def test_allocate_single_payout_partial_first_tranche():
-    nominals = np.array([100, 100, 100])
-    payout = 30
+        # ES must be 1
+        assert es_list[0] == 1
 
-    remaining, alloc = utils_cat_bonds.allocate_single_payout(payout, nominals)
 
-    assert np.allclose(alloc, [30, 0, 0])
-    assert np.allclose(remaining, [70, 100, 100])
+    def test_allocate_single_payout_partial_first_tranche(self):
+        nominals = np.array([100, 100, 100])
+        payout = 30
 
+        remaining, alloc = utils_cat_bonds.allocate_single_payout(payout, nominals)
+        assert np.allclose(alloc, [30., 0., 0.])
+        assert np.allclose(remaining, [70., 100., 100.])
 
-def test_allocate_single_payout_exact_first_tranche():
-    nominals = np.array([50, 100])
-    payout = 50
 
-    remaining, alloc = utils_cat_bonds.allocate_single_payout(payout, nominals)
+    def test_allocate_single_payout_exact_first_tranche(self):
+        nominals = np.array([50, 100])
+        payout = 50
 
-    assert np.allclose(alloc, [50, 0])
-    assert np.allclose(remaining, [0, 100])
+        remaining, alloc = utils_cat_bonds.allocate_single_payout(payout, nominals)
 
+        assert np.allclose(alloc, [50, 0])
+        assert np.allclose(remaining, [0, 100])
 
-def test_allocate_single_payout_spans_multiple_tranches():
-    nominals = np.array([50, 100, 200])
-    payout = 180  # eats all of tranche 1 and 2, 30 of tranche 3
 
-    remaining, alloc = utils_cat_bonds.allocate_single_payout(payout, nominals)
+    def test_allocate_single_payout_spans_multiple_tranches(self):
+        nominals = np.array([50, 100, 200])
+        payout = 180  # eats all of tranche 1 and 2, 30 of tranche 3
 
-    assert np.allclose(alloc, [50, 100, 30])
-    assert np.allclose(remaining, [0, 0, 170])
+        remaining, alloc = utils_cat_bonds.allocate_single_payout(payout, nominals)
 
+        assert np.allclose(alloc, [50, 100, 30])
+        assert np.allclose(remaining, [0, 0, 170])
 
-def test_allocate_single_payout_larger_than_all_nominals():
-    nominals = np.array([40, 40])
-    payout = 200  # everything wiped
 
-    remaining, alloc = utils_cat_bonds.allocate_single_payout(payout, nominals)
+    def test_allocate_single_payout_larger_than_all_nominals(self):
+        nominals = np.array([40, 40])
+        payout = 200  # everything wiped
 
-    assert np.allclose(alloc, [40, 40])
-    assert np.allclose(remaining, [0, 0])
+        remaining, alloc = utils_cat_bonds.allocate_single_payout(payout, nominals)
 
+        assert np.allclose(alloc, [40, 40])
+        assert np.allclose(remaining, [0, 0])
 
-def test_allocate_single_payout_zero_payout():
-    nominals = np.array([50, 100])
-    payout = 0
 
-    remaining, alloc = utils_cat_bonds.allocate_single_payout(payout, nominals)
+    def test_allocate_single_payout_zero_payout(self):
+        nominals = np.array([50, 100])
+        payout = 0
 
-    assert np.allclose(alloc, [0, 0])
-    assert np.allclose(remaining, nominals)
+        remaining, alloc = utils_cat_bonds.allocate_single_payout(payout, nominals)
+
+        assert np.allclose(alloc, [0, 0])
+        assert np.allclose(remaining, nominals)
 
 
 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
+    TESTS = unittest.TestLoader().loadTestsFromTestCase(TestUtils)
+    unittest.TextTestRunner(verbosity=2).run(TESTS)
\ No newline at end of file

From da8d4c464e89c9f7f17627267983ecd88c0b6b93 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 12 Dec 2025 17:10:55 +0100
Subject: [PATCH 119/125] remove bug of missing last term

---
 climada_petals/engine/cat_bonds/mlt_bond_simulation.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
index 13fbe770d..e3bc83ea5 100644
--- a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
@@ -12,7 +12,7 @@ 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.number_of_terms = number_of_terms
         self._prepare_data()
 
 
@@ -277,7 +277,7 @@ def init_loss_simulation(self, principal, confidence_levels=[0.95, 0.99]):
         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):
+        for i in range(self.min_year, self.min_year + self.number_of_terms):
             events_per_year = []
             for j in range(self.term):
                 events_per_cty = []  
@@ -513,7 +513,7 @@ def init_required_principal(self):
 
         total_losses = []
 
-        for i in range(self.simulated_years-self.term):
+        for i in range(self.min_year, self.min_year + self.number_of_terms):
             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]

From c24c18e067196d0cdf30c210cc8a209441f45623 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 12 Dec 2025 17:47:17 +0100
Subject: [PATCH 120/125] fix bug of starting year

---
 climada_petals/engine/cat_bonds/mlt_bond_simulation.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
index e3bc83ea5..00c2a8dfb 100644
--- a/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
+++ b/climada_petals/engine/cat_bonds/mlt_bond_simulation.py
@@ -277,12 +277,12 @@ def init_loss_simulation(self, principal, confidence_levels=[0.95, 0.99]):
         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.min_year, self.min_year + self.number_of_terms):
+        for start_year in range(self.min_year, self.min_year + self.number_of_terms):
             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 = self.pay_vs_dam_dic[int(cty)][self.pay_vs_dam_dic[int(cty)]['year'] == start_year+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()
@@ -513,10 +513,10 @@ def init_required_principal(self):
 
         total_losses = []
 
-        for i in range(self.min_year, self.min_year + self.number_of_terms):
+        for start_year in range(self.min_year, self.min_year + self.number_of_terms):
             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]
+                events_per_cty = [self.pay_vs_dam_dic[int(cty)].loc[self.pay_vs_dam_dic[int(cty)]['year'] == start_year + 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)

From ef05eae7d15c1c8545fa1ce15e6dd9842440906d Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Fri, 12 Dec 2025 17:47:26 +0100
Subject: [PATCH 121/125] test multi country cat bond class

---
 .../engine/cat_bonds/test/test_mlt_bond.py    | 345 ++++++++++++++++++
 1 file changed, 345 insertions(+)
 create mode 100644 climada_petals/engine/cat_bonds/test/test_mlt_bond.py

diff --git a/climada_petals/engine/cat_bonds/test/test_mlt_bond.py b/climada_petals/engine/cat_bonds/test/test_mlt_bond.py
new file mode 100644
index 000000000..ce3cbf8f7
--- /dev/null
+++ b/climada_petals/engine/cat_bonds/test/test_mlt_bond.py
@@ -0,0 +1,345 @@
+import unittest
+import pandas as pd
+import numpy as np
+from unittest.mock import MagicMock
+
+from climada_petals.engine.cat_bonds.mlt_bond_simulation import MultiCountryBond
+from climada_petals.util.config import LOGGER
+
+# ================================
+# MOCK CLASS FOR COUNTRY BOND SIM
+# ================================
+class DummySubareaCalc:
+    def __init__(self, pay_vs_dam, principal):
+        self.pay_vs_dam = pay_vs_dam
+        self.principal = principal
+
+class DummyBondSim:
+    def __init__(self, pay_vs_dam, principal, df_loss_month):
+        self.subarea_calc = DummySubareaCalc(pay_vs_dam, principal)
+        self.df_loss_month = df_loss_month
+
+# ================================
+# UNIT TESTS
+# ================================
+
+class TestMultiCountryBond(unittest.TestCase):
+
+    def setUp(self):
+        # simple mock event data
+        self.pay_vs_dam_0 = pd.DataFrame({
+            "year": [2000, 2001],
+            "month": [6, 6],
+            "pay": [0.1, 0.2],
+            "damage": [0.1, 0.2]
+        })
+        self.pay_vs_dam_1 = pd.DataFrame({
+            "year": [2000, 2001],
+            "month": [6, 6],
+            "pay": [0.05, 0.1],
+            "damage": [0.05, 0.1]
+        })
+
+        self.df_loss_month_0 = pd.DataFrame({
+            'losses': [0.1, 0.2],
+            'months': [6, 6]
+        })
+
+        self.df_loss_month_1 = pd.DataFrame({
+            'losses': [0.05, 0.1],
+            'months': [6, 6]
+        })
+
+        self.country_dict = {
+            0: DummyBondSim(self.pay_vs_dam_0, principal=1.0, df_loss_month = self.df_loss_month_0),
+            1: DummyBondSim(self.pay_vs_dam_1, principal=1.0, df_loss_month = self.df_loss_month_1)
+        }
+
+    def test_prepare_data(self):
+        bond = MultiCountryBond(self.country_dict, term=1, number_of_terms=2)
+        # check min_year is correctly detected
+        self.assertEqual(bond.min_year, 2000)
+        # check pay_vs_dam_dic populated
+        self.assertIn(0, bond.pay_vs_dam_dic)
+        self.assertIn(1, bond.pay_vs_dam_dic)
+        self.assertIn(0, bond.principal_dic_cty)
+        self.assertIn(1, bond.principal_dic_cty)
+
+    def test_init_bond_loss(self):
+        bond = MultiCountryBond(self.country_dict, term=1, number_of_terms=2)
+        events_per_year = [
+            pd.DataFrame({
+                "month": [6],
+                "country_code": [0],
+                "pay": [0.1],
+                "damage": [0.1]
+            })
+        ]
+        rel_ann_bond_losses, rel_ann_cty_losses, rel_bond_monthly_losses, coverage_tot, coverage_cty = bond._init_bond_loss(events_per_year, principal=1.0)
+        self.assertEqual(rel_ann_bond_losses[0], 0.1)
+        self.assertEqual(rel_ann_cty_losses[0][0], 0.1)
+        self.assertEqual(rel_ann_cty_losses[1][0], 0.0)
+        self.assertEqual(coverage_tot['payout'], 0.1)
+        self.assertEqual(coverage_cty[0]['payout'], 0.1)
+        self.assertEqual(coverage_cty[0]['damage'], 0.1)
+        self.assertEqual(coverage_cty[1]['payout'], 0.0)
+        self.assertEqual(coverage_cty[1]['damage'], 0.0)
+        pd.testing.assert_frame_equal(rel_bond_monthly_losses, pd.DataFrame({
+            'losses': [0.1],
+            'months': [6]},
+            dtype='object'))
+
+    def test_init_loss_simulation(self):
+        # -------------------------
+        # Create bond
+        # -------------------------
+        bond = MultiCountryBond(
+            country_dictionary=self.country_dict,
+            term=1,
+            number_of_terms=2
+        )
+
+        principal = 2.0
+        bond.init_loss_simulation(principal)
+
+        # -------------------------
+        # Expected results
+        # -------------------------
+        expected_annual_losses = np.array([0.075, 0.15]) # toatal payout / 2 as principal = 2
+        expected_EL = expected_annual_losses.mean()
+        expected_AP = 1.0
+        expected_total_payout = 0.45
+        expected_total_damage = 0.45
+
+        # -------------------------
+        # Assertions (results only)
+        # -------------------------
+        self.assertAlmostEqual(bond.loss_metrics["EL_ann"], expected_EL, places=5)
+        self.assertAlmostEqual(bond.loss_metrics["AP_ann"], expected_AP, places=5)
+        self.assertAlmostEqual(bond.loss_metrics["Payout"], expected_total_payout, places=5)
+        self.assertAlmostEqual(bond.loss_metrics["Damage"], expected_total_damage, places=5)
+        # Monthly losses should match annual losses
+        pd.testing.assert_frame_equal(bond.df_loss_month, pd.DataFrame({
+            'losses': [[0.05 , 0.025], [0.1, 0.05]],
+            'months': [[6, 6], [6, 6]]
+        }))
+
+    def test_init_return_simulation(self):
+        bond = MultiCountryBond(self.country_dict, term=1, number_of_terms=2)
+        # One year, one loss in June
+        bond.df_loss_month = pd.DataFrame({
+            "losses": [[0.2]],   # 20% principal loss
+            "months": [[6]]      # loss occurs in June
+        })
+
+        # Two countries with simple shares
+        bond.tot_coverage_cty = {
+            0: {"share_EL": 0.5},
+            1: {"share_EL": 0.5}
+        }
+
+        premium = 0.1   # 10% annual premium
+        rf = 0.0
+
+        # -------------------------
+        # Run function
+        # -------------------------
+        bond.init_return_simulation(premium=premium, rf=rf)
+
+        # -------------------------
+        # Manual calculations
+        # -------------------------
+        # Pre-loss premium (Jan–Jun):
+        #   1.0 * 0.1 / 12 * 6 = 0.05
+        #
+        # Nominal after loss:
+        #   1.0 - 0.2 = 0.8
+        #
+        # Post-loss premium (Jun–Dec):
+        #   0.8 * 0.1 / 12 * 6 = 0.04
+        #
+        # Total premium:
+        #   0.05 + 0.04 = 0.09
+        #
+        # Net cash flow:
+        #   0.05 + 0.04 - 0.2 = -0.11
+
+        expected_total_premium = [0.09]
+        expected_ncf = [-0.11]
+
+        # Country allocations (50/50)
+        expected_cty_0 = [0.045]
+        expected_cty_1 = [0.045]
+
+        # -------------------------
+        # Assertions
+        # -------------------------
+        np.testing.assert_allclose(
+            bond.ncf["Total"].to_numpy(),
+            expected_ncf,
+            rtol=1e-10
+        )
+
+        np.testing.assert_allclose(
+            bond.prem_cty_df["Total"].to_numpy(),
+            expected_total_premium,
+            rtol=1e-10
+        )
+
+        np.testing.assert_allclose(
+            bond.prem_cty_df[0].to_numpy(),
+            expected_cty_0,
+            rtol=1e-10
+        )
+
+        np.testing.assert_allclose(
+            bond.prem_cty_df[1].to_numpy(),
+            expected_cty_1,
+            rtol=1e-10
+        )
+
+    def test_init_required_principal(self):
+        bond = MultiCountryBond(self.country_dict, term=3, number_of_terms=2)
+        # Two countries
+        bond.countries = [0, 1]
+
+        # Uneven country nominals
+        bond.principal_dic_cty = {
+            0: 1.0,   # country 0
+            1: 0.5    # country 1
+        }
+
+        # Dummy pay_vs_dam_dic (only structure matters here)
+        bond.pay_vs_dam_dic = {
+            0: pd.DataFrame({"year": [2000, 2001, 2002, 2003], "pay": [0.0, 0.0, 0.2, 0.0]}),
+            1: pd.DataFrame({"year": [2000, 2001, 2002, 2003], "pay": [0.2, 0.2, 0.1, 0.0]}),
+        }
+
+        bond.init_required_principal()
+
+        self.assertEqual(bond.requ_principal, 0.7)
+        
+    def test__init_equ_nom_sim(self):
+        bond = MultiCountryBond(self.country_dict, term=1, number_of_terms=2)
+        events_per_year = [
+            pd.DataFrame({
+                "pay": [0.1, 0.2, 0.4, 0.9],
+                "country_code": [0, 1, 0, 1]
+            })
+        ]
+        nominal_dic_cty = {0: 1.0, 1: 1.0}
+        tot_loss = bond._init_equ_nom_sim(events_per_year, nominal_dic_cty)
+        self.assertEqual(tot_loss, 1.5)
+
+    def test_init_return_simulation_tranches(self):
+
+        bond = MultiCountryBond.__new__(MultiCountryBond)
+        bond.term = 1
+
+        bond.df_loss_month = pd.DataFrame({
+            "losses": [[0.2]],
+            "months": [[6]]
+        })
+
+        bond.tot_coverage_cty = {
+            0: {"share_EL": 0.5},
+            1: {"share_EL": 0.5}
+        }
+
+        premiums = [0.1, 0.1]
+        tranches = [0.6, 0.4]
+
+        bond.init_return_simulation_tranches(premiums, tranches)
+
+        # Tranche cashflows
+        self.assertAlmostEqual(bond.ncf_tranches["0.6"][0], -0.15, places=5)
+        self.assertAlmostEqual(bond.ncf_tranches["0.4"][0], 0.04, places=5)
+
+        # Total cashflow
+        self.assertAlmostEqual(bond.ncf_tranches["Total"][0], -0.11, places=5)
+
+        # Premium allocation
+        self.assertAlmostEqual(bond.prem_cty_df_tranches["Total"][0], 0.09, places=5)
+        self.assertAlmostEqual(bond.prem_cty_df_tranches[0][0], 0.045, places=5)
+        self.assertAlmostEqual(bond.prem_cty_df_tranches[1][0], 0.045, places=5)
+
+    def test_simulate_bond_pool_n_structure_and_membership(self):
+        """
+        Verify:
+        - all returned objects are MultiCountryBond
+        - every country is assigned to exactly one bond
+        - pool_allocation contains all countries
+        - pool_allocation and bond contents are consistent
+        """
+
+        # ----------------------------------
+        # Deterministic pool allocation
+        # ----------------------------------
+        pool_allocation = {
+            0: [0],
+            1: [0]
+        }
+
+        # ----------------------------------
+        # Run function
+        # ----------------------------------
+        mlt_bond_simulation_dic, pool_alloc, algo_res = MultiCountryBond.simulate_bond_pool_n(
+            country_dictionary=self.country_dict,
+            term=1,
+            number_of_terms=2,
+            principal=2.0,
+            number_pools=1,
+            n_opt_rep=1
+        )
+
+        # ----------------------------------
+        # Assertions: pool allocation
+        # ----------------------------------
+        self.assertEqual(pool_alloc, pool_allocation)
+
+        # All original countries must appear in pool_allocation
+        self.assertEqual(
+            set(pool_alloc.keys()),
+            set(self.country_dict.keys())
+        )
+
+        # ----------------------------------
+        # Assertions: MultiCountryBond objects
+        # ----------------------------------
+        for bond in mlt_bond_simulation_dic.values():
+            self.assertIsInstance(bond, MultiCountryBond)
+
+        # ----------------------------------
+        # Assertions: country membership in bonds
+        # ----------------------------------
+        countries_in_bonds = []
+
+        for bond in mlt_bond_simulation_dic.values():
+            countries_in_bonds.extend(bond.country_dictionary.keys())
+
+        # Every country must appear exactly once
+        self.assertCountEqual(
+            countries_in_bonds,
+            list(self.country_dict.keys())
+        )
+
+        # ----------------------------------
+        # Cross-check: pool allocation ↔ bond contents
+        # ----------------------------------
+        for pool_id, bond in mlt_bond_simulation_dic.items():
+            allocated_countries = [
+                cty for cty, pool in pool_alloc.items()
+                if pool[0] == pool_id
+            ]
+
+            self.assertCountEqual(
+                allocated_countries,
+                list(bond.country_dictionary.keys())
+            )
+
+
+
+
+if __name__ == "__main__":
+    TESTS = unittest.TestLoader().loadTestsFromTestCase(TestMultiCountryBond)
+    unittest.TextTestRunner(verbosity=2).run(TESTS)
\ No newline at end of file

From 43dc34eea529fd3f2f7e3be79478c8f609a58fbd Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 15 Dec 2025 12:01:57 +0100
Subject: [PATCH 122/125] ensure valid results

---
 climada_petals/engine/cat_bonds/pooling_functions.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/climada_petals/engine/cat_bonds/pooling_functions.py b/climada_petals/engine/cat_bonds/pooling_functions.py
index 227d6ee48..d0f34a6a0 100644
--- a/climada_petals/engine/cat_bonds/pooling_functions.py
+++ b/climada_petals/engine/cat_bonds/pooling_functions.py
@@ -139,7 +139,7 @@ def process_maximum_principal_pools(maximum_principal, countries, cls_bond_simul
         # 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:
+        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))

From 007155d13f6c6c90f843b64d1cd573dc03799fc9 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 15 Dec 2025 12:08:28 +0100
Subject: [PATCH 123/125] get country location even if risk concentration does
 not improve

---
 climada_petals/engine/cat_bonds/pooling_functions.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/climada_petals/engine/cat_bonds/pooling_functions.py b/climada_petals/engine/cat_bonds/pooling_functions.py
index d0f34a6a0..accba0caa 100644
--- a/climada_petals/engine/cat_bonds/pooling_functions.py
+++ b/climada_petals/engine/cat_bonds/pooling_functions.py
@@ -9,6 +9,8 @@
 from pymoo.algorithms.soo.nonconvex.ga import GA
 from pymoo.optimize import minimize
 from pymoo.operators.repair.rounding import RoundingRepair
+from climada_petals.util.config import LOGGER
+
 
 def process_n_pools(number_pools, countries, cls_bond_simulations, n_opt_rep=100):
     """
@@ -67,7 +69,9 @@ def process_n_pools(number_pools, countries, cls_bond_simulations, n_opt_rep=100
         # 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:
+        LOGGER.info(res_reg.F)
+        if risk_concentration_new is not None and risk_concentration is not None and risk_concentration_new <= risk_concentration:
+            LOGGER.info("True")
             algorithm_result = res_reg
             risk_concentration = risk_concentration_new
             sorted_unique = sorted(set(x))
@@ -140,6 +144,7 @@ def process_maximum_principal_pools(maximum_principal, countries, cls_bond_simul
         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))

From 819677eb893a159888faacf679350ec760c9b37a Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 15 Dec 2025 12:15:24 +0100
Subject: [PATCH 124/125] finsih mlt_bond_class tests

---
 .../engine/cat_bonds/test/test_mlt_bond.py    | 37 ++-----------------
 1 file changed, 4 insertions(+), 33 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/test/test_mlt_bond.py b/climada_petals/engine/cat_bonds/test/test_mlt_bond.py
index ce3cbf8f7..2fd2b3da1 100644
--- a/climada_petals/engine/cat_bonds/test/test_mlt_bond.py
+++ b/climada_petals/engine/cat_bonds/test/test_mlt_bond.py
@@ -41,12 +41,12 @@ def setUp(self):
         })
 
         self.df_loss_month_0 = pd.DataFrame({
-            'losses': [0.1, 0.2],
+            'losses': [[0.1], [0.2]],
             'months': [6, 6]
         })
 
         self.df_loss_month_1 = pd.DataFrame({
-            'losses': [0.05, 0.1],
+            'losses': [[0.05], [0.1]],
             'months': [6, 6]
         })
 
@@ -263,7 +263,7 @@ def test_init_return_simulation_tranches(self):
         self.assertAlmostEqual(bond.prem_cty_df_tranches[0][0], 0.045, places=5)
         self.assertAlmostEqual(bond.prem_cty_df_tranches[1][0], 0.045, places=5)
 
-    def test_simulate_bond_pool_n_structure_and_membership(self):
+    def test_simulate_bond_pool_n(self):
         """
         Verify:
         - all returned objects are MultiCountryBond
@@ -272,14 +272,6 @@ def test_simulate_bond_pool_n_structure_and_membership(self):
         - pool_allocation and bond contents are consistent
         """
 
-        # ----------------------------------
-        # Deterministic pool allocation
-        # ----------------------------------
-        pool_allocation = {
-            0: [0],
-            1: [0]
-        }
-
         # ----------------------------------
         # Run function
         # ----------------------------------
@@ -295,13 +287,8 @@ def test_simulate_bond_pool_n_structure_and_membership(self):
         # ----------------------------------
         # Assertions: pool allocation
         # ----------------------------------
-        self.assertEqual(pool_alloc, pool_allocation)
+        self.assertEqual(len(pool_alloc), 1)
 
-        # All original countries must appear in pool_allocation
-        self.assertEqual(
-            set(pool_alloc.keys()),
-            set(self.country_dict.keys())
-        )
 
         # ----------------------------------
         # Assertions: MultiCountryBond objects
@@ -323,22 +310,6 @@ def test_simulate_bond_pool_n_structure_and_membership(self):
             list(self.country_dict.keys())
         )
 
-        # ----------------------------------
-        # Cross-check: pool allocation ↔ bond contents
-        # ----------------------------------
-        for pool_id, bond in mlt_bond_simulation_dic.items():
-            allocated_countries = [
-                cty for cty, pool in pool_alloc.items()
-                if pool[0] == pool_id
-            ]
-
-            self.assertCountEqual(
-                allocated_countries,
-                list(bond.country_dictionary.keys())
-            )
-
-
-
 
 if __name__ == "__main__":
     TESTS = unittest.TestLoader().loadTestsFromTestCase(TestMultiCountryBond)

From e9917d7db5a4ffd4fb41549c3d0a986a643c4c87 Mon Sep 17 00:00:00 2001
From: KaiOBerg <bergmueller98@web.de>
Date: Mon, 15 Dec 2025 12:16:06 +0100
Subject: [PATCH 125/125] remove unnecessary packages

---
 climada_petals/engine/cat_bonds/test/test_mlt_bond.py           | 2 --
 climada_petals/engine/cat_bonds/test/test_subarea.py            | 1 -
 .../engine/cat_bonds/test/test_subarea_calculations.py          | 1 -
 3 files changed, 4 deletions(-)

diff --git a/climada_petals/engine/cat_bonds/test/test_mlt_bond.py b/climada_petals/engine/cat_bonds/test/test_mlt_bond.py
index 2fd2b3da1..23a286765 100644
--- a/climada_petals/engine/cat_bonds/test/test_mlt_bond.py
+++ b/climada_petals/engine/cat_bonds/test/test_mlt_bond.py
@@ -1,10 +1,8 @@
 import unittest
 import pandas as pd
 import numpy as np
-from unittest.mock import MagicMock
 
 from climada_petals.engine.cat_bonds.mlt_bond_simulation import MultiCountryBond
-from climada_petals.util.config import LOGGER
 
 # ================================
 # MOCK CLASS FOR COUNTRY BOND SIM
diff --git a/climada_petals/engine/cat_bonds/test/test_subarea.py b/climada_petals/engine/cat_bonds/test/test_subarea.py
index a229e46ad..0a10cef4a 100644
--- a/climada_petals/engine/cat_bonds/test/test_subarea.py
+++ b/climada_petals/engine/cat_bonds/test/test_subarea.py
@@ -2,7 +2,6 @@
 from shapely.geometry import Point, MultiPolygon, Polygon
 from climada_petals.engine.cat_bonds import subareas
 
-from climada_petals.util.config import LOGGER
 import unittest
 from unittest.mock import MagicMock
 
diff --git a/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py b/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py
index 9fe80b419..e4b861044 100644
--- a/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py
+++ b/climada_petals/engine/cat_bonds/test/test_subarea_calculations.py
@@ -6,7 +6,6 @@
 from climada.hazard.centroids import Centroids
 from scipy import sparse
 from shapely.geometry import Polygon
-from climada_petals.util.config import LOGGER
 import unittest
 from unittest.mock import MagicMock
 from scipy.optimize import OptimizeResult