From aa90de3ef876008caacf8f91932b771468659432 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Tue, 18 Jan 2022 14:14:03 +0100
Subject: [PATCH 001/121] Add methods to set imp vars from imp mat

---
 climada/engine/impact.py | 81 ++++++++++++++++++++++++++++++++++++----
 1 file changed, 74 insertions(+), 7 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index aea49b6b1..b5e2c24ef 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -1111,6 +1111,80 @@ def _cen_return_imp(imp, freq, imp_th, return_periods):
 
         return imp_fit
 
+    def set_imp_mat(self, imp_mat):
+        """
+        Set Impact attributes from the impact matrix. Returns a copy.
+        Overwrites eai_exp, at_event, aai_agg, imp_mat.
+        Parameters
+        ----------
+        imp_mat : sparse.csr_matrix
+            matrix num_events x num_exp with impacts.
+        Returns
+        -------
+        imp : Impact
+            Copy of impact with eai_exp, at_event, aai_agg, imp_mat set.
+        """
+        imp = copy.deepcopy(self)
+        imp.eai_exp = self.eai_exp_from_mat(imp_mat, imp.frequency)
+        imp.at_event = self.at_event_from_mat(imp_mat)
+        imp.aai_agg = self.aai_agg_from_at_event(imp.at_event, imp.frequency)
+        imp.imp_mat = imp_mat
+        return imp
+
+    def eai_exp_from_mat(self, imp_mat, freq):
+        """
+        Compute impact for each exposures from the total impact matrix
+        Parameters
+        ----------
+        imp_mat : sparse.csr_matrix
+            matrix num_events x num_exp with impacts.
+        frequency : np.array
+            annual frequency of events
+        Returns
+        -------
+        eai_exp : np.array
+            expected annual impact for each exposure
+        """
+        freq_mat = freq.reshape(len(freq), 1)
+        return imp_mat.multiply(freq_mat).sum(axis=0).A1
+
+    def at_event_from_mat(self, imp_mat):
+        """
+        Compute impact for each hazard event from the total impact matrix
+        Parameters
+        ----------
+        imp_mat : sparse.csr_matrix
+            matrix num_events x num_exp with impacts.
+        Returns
+        -------
+        at_event : np.array
+            impact for each hazard event
+        """
+        return np.squeeze(np.asarray(np.sum(imp_mat, axis=1)))
+
+    def aai_agg_from_at_event(self, at_event, freq):
+        """
+        Aggregate impact.at_event
+        Parameters
+        ----------
+        at_event : np.array
+            impact for each hazard event
+        frequency : np.array
+            annual frequency of event
+        Returns
+        -------
+        float
+            average annual impact aggregated
+        """
+        return sum(at_event * freq)
+
+        def _selected_exposures_idx(self, coord_exp):
+            assigned_idx = u_coord.assign_coordinates(self.coord_exp, coord_exp, threshold=0)
+            sel_exp = (assigned_idx >= 0).nonzero()[0]
+            if sel_exp.size == 0:
+                LOGGER.warning("No exposure coordinates match the selection.")
+            return sel_exp
+
 
     def select(self,
                event_ids=None, event_names=None, dates=None,
@@ -1226,13 +1300,6 @@ def select(self,
 
         return imp
 
-    def _selected_exposures_idx(self, coord_exp):
-        assigned_idx = u_coord.assign_coordinates(self.coord_exp, coord_exp, threshold=0)
-        sel_exp = (assigned_idx >= 0).nonzero()[0]
-        if sel_exp.size == 0:
-            LOGGER.warning("No exposure coordinates match the selection.")
-        return sel_exp
-
     def _selected_events_idx(self, event_ids, event_names, dates, nb_events):
         if all(var is None for var in [dates, event_ids, event_names]):
             return None

From 06f940313d846f1030d1e8a5965385227be95a0d Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Tue, 18 Jan 2022 16:04:40 +0100
Subject: [PATCH 002/121] Cosmetics

---
 climada/engine/impact.py | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index b5e2c24ef..0a8e73f42 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -1115,6 +1115,7 @@ def set_imp_mat(self, imp_mat):
         """
         Set Impact attributes from the impact matrix. Returns a copy.
         Overwrites eai_exp, at_event, aai_agg, imp_mat.
+
         Parameters
         ----------
         imp_mat : sparse.csr_matrix
@@ -1129,11 +1130,13 @@ def set_imp_mat(self, imp_mat):
         imp.at_event = self.at_event_from_mat(imp_mat)
         imp.aai_agg = self.aai_agg_from_at_event(imp.at_event, imp.frequency)
         imp.imp_mat = imp_mat
+        imp.event_id
         return imp
 
     def eai_exp_from_mat(self, imp_mat, freq):
         """
         Compute impact for each exposures from the total impact matrix
+
         Parameters
         ----------
         imp_mat : sparse.csr_matrix
@@ -1151,6 +1154,7 @@ def eai_exp_from_mat(self, imp_mat, freq):
     def at_event_from_mat(self, imp_mat):
         """
         Compute impact for each hazard event from the total impact matrix
+
         Parameters
         ----------
         imp_mat : sparse.csr_matrix
@@ -1165,6 +1169,7 @@ def at_event_from_mat(self, imp_mat):
     def aai_agg_from_at_event(self, at_event, freq):
         """
         Aggregate impact.at_event
+
         Parameters
         ----------
         at_event : np.array
@@ -1178,14 +1183,6 @@ def aai_agg_from_at_event(self, at_event, freq):
         """
         return sum(at_event * freq)
 
-        def _selected_exposures_idx(self, coord_exp):
-            assigned_idx = u_coord.assign_coordinates(self.coord_exp, coord_exp, threshold=0)
-            sel_exp = (assigned_idx >= 0).nonzero()[0]
-            if sel_exp.size == 0:
-                LOGGER.warning("No exposure coordinates match the selection.")
-            return sel_exp
-
-
     def select(self,
                event_ids=None, event_names=None, dates=None,
                coord_exp=None):
@@ -1345,6 +1342,13 @@ def _selected_events_idx(self, event_ids, event_names, dates, nb_events):
 
         return sel_ev
 
+    def _selected_exposures_idx(self, coord_exp):
+        assigned_idx = u_coord.assign_coordinates(self.coord_exp, coord_exp, threshold=0)
+        sel_exp = (assigned_idx >= 0).nonzero()[0]
+        if sel_exp.size == 0:
+            LOGGER.warning("No exposure coordinates match the selection.")
+        return sel_exp
+
 class ImpactFreqCurve():
     """Impact exceedence frequency curve.
 

From 41ad79b292cbaa9b1ee5c970f1f5442fabe011e5 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Wed, 19 Jan 2022 20:46:52 +0100
Subject: [PATCH 003/121] Change set to calc

---
 climada/engine/impact.py | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 0a8e73f42..806214373 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -1111,7 +1111,7 @@ def _cen_return_imp(imp, freq, imp_th, return_periods):
 
         return imp_fit
 
-    def set_imp_mat(self, imp_mat):
+    def calc_imp_from_mat(self, imp_mat, freq):
         """
         Set Impact attributes from the impact matrix. Returns a copy.
         Overwrites eai_exp, at_event, aai_agg, imp_mat.
@@ -1120,20 +1120,19 @@ def set_imp_mat(self, imp_mat):
         ----------
         imp_mat : sparse.csr_matrix
             matrix num_events x num_exp with impacts.
+        freq : np.array
+            array with the frequency per event
         Returns
         -------
         imp : Impact
             Copy of impact with eai_exp, at_event, aai_agg, imp_mat set.
         """
-        imp = copy.deepcopy(self)
-        imp.eai_exp = self.eai_exp_from_mat(imp_mat, imp.frequency)
-        imp.at_event = self.at_event_from_mat(imp_mat)
-        imp.aai_agg = self.aai_agg_from_at_event(imp.at_event, imp.frequency)
-        imp.imp_mat = imp_mat
-        imp.event_id
-        return imp
+        eai_exp = self._eai_exp_from_mat(imp_mat, freq)
+        at_event = self._at_event_from_mat(imp_mat)
+        aai_agg = self._aai_agg_from_at_event(at_event, freq)
+        return eai_exp, at_event, aai_agg
 
-    def eai_exp_from_mat(self, imp_mat, freq):
+    def _eai_exp_from_mat(self, imp_mat, freq):
         """
         Compute impact for each exposures from the total impact matrix
 
@@ -1151,7 +1150,7 @@ def eai_exp_from_mat(self, imp_mat, freq):
         freq_mat = freq.reshape(len(freq), 1)
         return imp_mat.multiply(freq_mat).sum(axis=0).A1
 
-    def at_event_from_mat(self, imp_mat):
+    def _at_event_from_mat(self, imp_mat):
         """
         Compute impact for each hazard event from the total impact matrix
 
@@ -1166,7 +1165,7 @@ def at_event_from_mat(self, imp_mat):
         """
         return np.squeeze(np.asarray(np.sum(imp_mat, axis=1)))
 
-    def aai_agg_from_at_event(self, at_event, freq):
+    def _aai_agg_from_at_event(self, at_event, freq):
         """
         Aggregate impact.at_event
 

From e9d0fd7072c68317186ad287832ecb7562ac3059 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Wed, 16 Mar 2022 13:33:24 +0100
Subject: [PATCH 004/121] Ordering the code

---
 climada/engine/impact.py          | 345 ++++++++++++-----------
 doc/tutorial/1_main_climada.ipynb | 453 ++++++++++++++++++++----------
 2 files changed, 487 insertions(+), 311 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index b5bea0d2a..a123f2418 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -100,38 +100,6 @@ def __init__(self):
         self.unit = ''
         self.imp_mat = sparse.csr_matrix(np.empty((0, 0)))
 
-    def calc_freq_curve(self, return_per=None):
-        """Compute impact exceedance frequency curve.
-
-        Parameters
-        ----------
-        return_per : np.array, optional
-            return periods where to compute
-            the exceedance impact. Use impact's frequencies if not provided
-
-        Returns
-        -------
-            ImpactFreqCurve
-        """
-        ifc = ImpactFreqCurve()
-        ifc.tag = self.tag
-        # Sort descendingly the impacts per events
-        sort_idxs = np.argsort(self.at_event)[::-1]
-        # Calculate exceedence frequency
-        exceed_freq = np.cumsum(self.frequency[sort_idxs])
-        # Set return period and imact exceeding frequency
-        ifc.return_per = 1 / exceed_freq[::-1]
-        ifc.impact = self.at_event[sort_idxs][::-1]
-        ifc.unit = self.unit
-        ifc.label = 'Exceedance frequency curve'
-
-        if return_per is not None:
-            interp_imp = np.interp(return_per, ifc.return_per, ifc.impact)
-            ifc.return_per = return_per
-            ifc.impact = interp_imp
-
-        return ifc
-
     def calc(self, exposures, impact_funcs, hazard, save_mat=False):
         """Compute impact of an hazard to exposures.
 
@@ -171,31 +139,21 @@ def calc(self, exposures, impact_funcs, hazard, save_mat=False):
         # 1. Assign centroids to each exposure if not done
         assign_haz = INDICATOR_CENTR + hazard.tag.haz_type
         if assign_haz not in exposures.gdf:
+            LOGGER.warning(
+                "Exposures have no assigned centroids for Hazard %s.\
+                Centroids will be assigned now.", hazard.tag.haz_type
+                )
             exposures.assign_centroids(hazard)
         else:
             LOGGER.info('Exposures matching centroids found in %s', assign_haz)
 
-        # 2. Initialize values
-        self.unit = exposures.value_unit
-        self.event_id = hazard.event_id
-        self.event_name = hazard.event_name
-        self.date = hazard.date
-        self.coord_exp = np.stack([exposures.gdf.latitude.values,
-                                   exposures.gdf.longitude.values], axis=1)
-        self.frequency = hazard.frequency
-        self.at_event = np.zeros(hazard.intensity.shape[0])
-        self.eai_exp = np.zeros(exposures.gdf.value.size)
-        self.tag = {'exp': exposures.tag, 'impf_set': impact_funcs.tag,
-                    'haz': hazard.tag}
-        self.crs = exposures.crs
-
         # Select exposures with positive value and assigned centroid
         exp_idx = np.where((exposures.gdf.value > 0) & (exposures.gdf[assign_haz] >= 0))[0]
         if exp_idx.size == 0:
             LOGGER.warning("No affected exposures.")
 
         num_events = hazard.intensity.shape[0]
-        LOGGER.info('Calculating damage for %s assets (>0) and %s events.',
+        LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
                     exp_idx.size, num_events)
 
         # Get damage functions for this hazard
@@ -239,6 +197,20 @@ def calc(self, exposures, impact_funcs, hazard, save_mat=False):
             shape = (self.date.size, exposures.gdf.value.size)
             self.imp_mat = sparse.csr_matrix(self.imp_mat, shape=shape)
 
+
+        # 2. Initialize values
+        self.unit = exposures.value_unit
+        self.event_id = hazard.event_id
+        self.event_name = hazard.event_name
+        self.date = hazard.date
+        self.coord_exp = np.stack([exposures.gdf.latitude.values,
+                                   exposures.gdf.longitude.values], axis=1)
+        self.frequency = hazard.frequency
+        self.tag = {'exp': exposures.tag, 'impf_set': impact_funcs.tag,
+                    'haz': hazard.tag}
+        self.crs = exposures.crs
+
+
     def calc_risk_transfer(self, attachment, cover):
         """Compute traaditional risk transfer over impact. Returns new impact
         with risk transfer applied and the insurance layer resulting Impact metrics.
@@ -308,6 +280,113 @@ def plot_hexbin_eai_exposure(self, mask=None, ignore_zero=True,
         axis.set_title('Expected annual impact')
         return axis
 
+    def calc_impact_year_set(self, all_years=True, year_range=None):
+        """Calculate yearly impact from impact data.
+
+        Parameters
+        ----------
+        all_years : boolean
+            return values for all years between first and
+            last year with event, including years without any events.
+        year_range : tuple or list with integers
+            start and end year
+
+        Returns
+        -------
+        Impact year set of type numpy.ndarray with summed impact per year.
+        """
+        if year_range is None:
+            year_range = []
+
+        orig_year = np.array([dt.datetime.fromordinal(date).year
+                              for date in self.date])
+        if orig_year.size == 0 and len(year_range) == 0:
+            return dict()
+        if orig_year.size == 0 or (len(year_range) > 0 and all_years):
+            years = np.arange(min(year_range), max(year_range) + 1)
+        elif all_years:
+            years = np.arange(min(orig_year), max(orig_year) + 1)
+        else:
+            years = np.array(sorted(np.unique(orig_year)))
+        if not len(year_range) == 0:
+            years = years[years >= min(year_range)]
+            years = years[years <= max(year_range)]
+
+        year_set = dict()
+
+        for year in years:
+            year_set[year] = sum(self.at_event[orig_year == year])
+        return year_set
+
+    def local_exceedance_imp(self, return_periods=(25, 50, 100, 250)):
+        """Compute exceedance impact map for given return periods.
+        Requires attribute imp_mat.
+
+        Parameters
+        ----------
+        return_periods : np.array return periods to consider
+
+        Returns
+        -------
+        np.array
+        """
+        LOGGER.info('Computing exceedance impact map for return periods: %s',
+                    return_periods)
+        try:
+            self.imp_mat.shape[1]
+        except AttributeError as err:
+            raise ValueError('attribute imp_mat is empty. Recalculate Impact'
+                             'instance with parameter save_mat=True') from err
+        num_cen = self.imp_mat.shape[1]
+        imp_stats = np.zeros((len(return_periods), num_cen))
+        cen_step = CONFIG.max_matrix_size.int() // self.imp_mat.shape[0]
+        if not cen_step:
+            raise ValueError('Increase max_matrix_size configuration parameter to > %s'
+                             % str(self.imp_mat.shape[0]))
+        # separte in chunks
+        chk = -1
+        for chk in range(int(num_cen / cen_step)):
+            self._loc_return_imp(np.array(return_periods),
+                                 self.imp_mat[:, chk * cen_step:(chk + 1) * cen_step].toarray(),
+                                 imp_stats[:, chk * cen_step:(chk + 1) * cen_step])
+        self._loc_return_imp(np.array(return_periods),
+                             self.imp_mat[:, (chk + 1) * cen_step:].toarray(),
+                             imp_stats[:, (chk + 1) * cen_step:])
+
+        return imp_stats
+
+    def calc_freq_curve(self, return_per=None):
+        """Compute impact exceedance frequency curve.
+
+        Parameters
+        ----------
+        return_per : np.array, optional
+            return periods where to compute
+            the exceedance impact. Use impact's frequencies if not provided
+
+        Returns
+        -------
+            ImpactFreqCurve
+        """
+        ifc = ImpactFreqCurve()
+        ifc.tag = self.tag
+        # Sort descendingly the impacts per events
+        sort_idxs = np.argsort(self.at_event)[::-1]
+        # Calculate exceedence frequency
+        exceed_freq = np.cumsum(self.frequency[sort_idxs])
+        # Set return period and imact exceeding frequency
+        ifc.return_per = 1 / exceed_freq[::-1]
+        ifc.impact = self.at_event[sort_idxs][::-1]
+        ifc.unit = self.unit
+        ifc.label = 'Exceedance frequency curve'
+
+        if return_per is not None:
+            interp_imp = np.interp(return_per, ifc.return_per, ifc.impact)
+            ifc.return_per = return_per
+            ifc.impact = interp_imp
+
+        return ifc
+
     def plot_scatter_eai_exposure(self, mask=None, ignore_zero=True,
                                   pop_name=True, buffer=0.0, extend='neither',
                                   axis=None, adapt_fontsize=True, **kwargs):
@@ -526,6 +605,53 @@ def plot_basemap_impact_exposure(self, event_id=1, mask=None, ignore_zero=True,
 
         return axis
 
+    def plot_rp_imp(self, return_periods=(25, 50, 100, 250),
+                    log10_scale=True, smooth=True, axis=None, **kwargs):
+        """Compute and plot exceedance impact maps for different return periods.
+        Calls local_exceedance_imp.
+
+        Parameters
+        ----------
+        return_periods : tuple(int), optional
+            return periods to consider
+        log10_scale : boolean, optional
+            plot impact as log10(impact)
+        smooth : bool, optional
+            smooth plot to plot.RESOLUTIONxplot.RESOLUTION
+        kwargs : optional
+            arguments for pcolormesh matplotlib function
+            used in event plots
+
+        Returns
+        --------
+        matplotlib.axes._subplots.AxesSubplot,
+        np.ndarray (return_periods.size x num_centroids)
+        """
+        imp_stats = self.local_exceedance_imp(np.array(return_periods))
+        if imp_stats == []:
+            raise ValueError('Error: Attribute imp_mat is empty. Recalculate Impact'
+                             'instance with parameter save_mat=True')
+        if log10_scale:
+            if np.min(imp_stats) < 0:
+                imp_stats_log = np.log10(abs(imp_stats) + 1)
+                colbar_name = 'Log10(abs(Impact)+1) (' + self.unit + ')'
+            elif np.min(imp_stats) < 1:
+                imp_stats_log = np.log10(imp_stats + 1)
+                colbar_name = 'Log10(Impact+1) (' + self.unit + ')'
+            else:
+                imp_stats_log = np.log10(imp_stats)
+                colbar_name = 'Log10(Impact) (' + self.unit + ')'
+        else:
+            imp_stats_log = imp_stats
+            colbar_name = 'Impact (' + self.unit + ')'
+        title = list()
+        for ret in return_periods:
+            title.append('Return period: ' + str(ret) + ' years')
+        axis = u_plot.geo_im_from_array(imp_stats_log, self.coord_exp,
+                                        colbar_name, title, smooth=smooth, axes=axis, **kwargs)
+
+        return axis, imp_stats
+
     def write_csv(self, file_name):
         """Write data into csv file. imp_mat is not saved.
 
@@ -606,128 +732,6 @@ def write_sparse_csr(self, file_name):
         np.savez(file_name, data=self.imp_mat.data, indices=self.imp_mat.indices,
                  indptr=self.imp_mat.indptr, shape=self.imp_mat.shape)
 
-    def calc_impact_year_set(self, all_years=True, year_range=None):
-        """Calculate yearly impact from impact data.
-
-        Parameters
-        ----------
-        all_years : boolean
-            return values for all years between first and
-            last year with event, including years without any events.
-        year_range : tuple or list with integers
-            start and end year
-
-        Returns
-        -------
-        Impact year set of type numpy.ndarray with summed impact per year.
-        """
-        if year_range is None:
-            year_range = []
-
-        orig_year = np.array([dt.datetime.fromordinal(date).year
-                              for date in self.date])
-        if orig_year.size == 0 and len(year_range) == 0:
-            return dict()
-        if orig_year.size == 0 or (len(year_range) > 0 and all_years):
-            years = np.arange(min(year_range), max(year_range) + 1)
-        elif all_years:
-            years = np.arange(min(orig_year), max(orig_year) + 1)
-        else:
-            years = np.array(sorted(np.unique(orig_year)))
-        if not len(year_range) == 0:
-            years = years[years >= min(year_range)]
-            years = years[years <= max(year_range)]
-
-        year_set = dict()
-
-        for year in years:
-            year_set[year] = sum(self.at_event[orig_year == year])
-        return year_set
-
-    def local_exceedance_imp(self, return_periods=(25, 50, 100, 250)):
-        """Compute exceedance impact map for given return periods.
-        Requires attribute imp_mat.
-
-        Parameters
-        ----------
-        return_periods : np.array return periods to consider
-
-        Returns
-        -------
-        np.array
-        """
-        LOGGER.info('Computing exceedance impact map for return periods: %s',
-                    return_periods)
-        try:
-            self.imp_mat.shape[1]
-        except AttributeError as err:
-            raise ValueError('attribute imp_mat is empty. Recalculate Impact'
-                             'instance with parameter save_mat=True') from err
-        num_cen = self.imp_mat.shape[1]
-        imp_stats = np.zeros((len(return_periods), num_cen))
-        cen_step = CONFIG.max_matrix_size.int() // self.imp_mat.shape[0]
-        if not cen_step:
-            raise ValueError('Increase max_matrix_size configuration parameter to > %s'
-                             % str(self.imp_mat.shape[0]))
-        # separte in chunks
-        chk = -1
-        for chk in range(int(num_cen / cen_step)):
-            self._loc_return_imp(np.array(return_periods),
-                                 self.imp_mat[:, chk * cen_step:(chk + 1) * cen_step].toarray(),
-                                 imp_stats[:, chk * cen_step:(chk + 1) * cen_step])
-        self._loc_return_imp(np.array(return_periods),
-                             self.imp_mat[:, (chk + 1) * cen_step:].toarray(),
-                             imp_stats[:, (chk + 1) * cen_step:])
-
-        return imp_stats
-
-    def plot_rp_imp(self, return_periods=(25, 50, 100, 250),
-                    log10_scale=True, smooth=True, axis=None, **kwargs):
-        """Compute and plot exceedance impact maps for different return periods.
-        Calls local_exceedance_imp.
-
-        Parameters
-        ----------
-        return_periods : tuple(int), optional
-            return periods to consider
-        log10_scale : boolean, optional
-            plot impact as log10(impact)
-        smooth : bool, optional
-            smooth plot to plot.RESOLUTIONxplot.RESOLUTION
-        kwargs : optional
-            arguments for pcolormesh matplotlib function
-            used in event plots
-
-        Returns
-        --------
-        matplotlib.axes._subplots.AxesSubplot,
-        np.ndarray (return_periods.size x num_centroids)
-        """
-        imp_stats = self.local_exceedance_imp(np.array(return_periods))
-        if imp_stats == []:
-            raise ValueError('Error: Attribute imp_mat is empty. Recalculate Impact'
-                             'instance with parameter save_mat=True')
-        if log10_scale:
-            if np.min(imp_stats) < 0:
-                imp_stats_log = np.log10(abs(imp_stats) + 1)
-                colbar_name = 'Log10(abs(Impact)+1) (' + self.unit + ')'
-            elif np.min(imp_stats) < 1:
-                imp_stats_log = np.log10(imp_stats + 1)
-                colbar_name = 'Log10(Impact+1) (' + self.unit + ')'
-            else:
-                imp_stats_log = np.log10(imp_stats)
-                colbar_name = 'Log10(Impact) (' + self.unit + ')'
-        else:
-            imp_stats_log = imp_stats
-            colbar_name = 'Impact (' + self.unit + ')'
-        title = list()
-        for ret in return_periods:
-            title.append('Return period: ' + str(ret) + ' years')
-        axis = u_plot.geo_im_from_array(imp_stats_log, self.coord_exp,
-                                        colbar_name, title, smooth=smooth, axes=axis, **kwargs)
-
-        return axis, imp_stats
-
     @staticmethod
     def read_sparse_csr(file_name):
         """Read imp_mat matrix from numpy's npz format.
@@ -992,7 +996,7 @@ def _loc_return_imp(self, return_periods, imp, exc_imp):
                 0, return_periods)
 
     def _exp_impact(self, exp_iimp, exposures, hazard, imp_fun, insure_flag):
-        """Compute impact for inpute exposure indexes and impact function.
+        """Compute impact for input exposure indexes and impact function.
 
         Parameters
         ----------
@@ -1348,6 +1352,7 @@ def _selected_exposures_idx(self, coord_exp):
             LOGGER.warning("No exposure coordinates match the selection.")
         return sel_exp
 
+
 class ImpactFreqCurve():
     """Impact exceedence frequency curve.
 
diff --git a/doc/tutorial/1_main_climada.ipynb b/doc/tutorial/1_main_climada.ipynb
index b8f16ff1c..424a8f515 100644
--- a/doc/tutorial/1_main_climada.ipynb
+++ b/doc/tutorial/1_main_climada.ipynb
@@ -142,15 +142,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
+   "execution_count": 3,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2022-03-09T16:14:07.505695Z",
+     "start_time": "2022-03-09T16:14:05.379337Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2021-10-19 16:41:37,771 - climada.hazard.tc_tracks - WARNING - 1125 storm events are discarded because no valid wind/pressure values have been found: 1851175N26270, 1851181N19275, 1851187N22262, 1851192N12300, 1851214N14321, ...\n",
-      "2021-10-19 16:41:37,783 - climada.hazard.tc_tracks - WARNING - 127 storm events are discarded because only one valid timestep has been found: 1852232N21293, 1853242N12336, 1855236N12304, 1856221N25277, 1856235N13302, ...\n"
+      "2022-03-09 17:14:05,526 - climada.hazard.tc_tracks - WARNING - The cached IBTrACS data set dates from 2020-08-08 03:51:21 (older than 180 days). Very likely, a more recent version is available. Consider manually removing the file /Users/ckropf/climada/data/IBTrACS.ALL.v04r00.nc and re-running this function, which will download the most recent version of the IBTrACS data set from the official URL.\n",
+      "2022-03-09 17:14:06,528 - climada.hazard.tc_tracks - WARNING - 27 storm events are discarded because no valid wind/pressure values have been found: 1985252N20333, 1985255N12300, 1985342N11283, 1986205N24305, 1986216N24267, ...\n",
+      "2022-03-09 17:14:06,654 - climada.hazard.tc_tracks - INFO - Progress: 11%\n",
+      "2022-03-09 17:14:06,762 - climada.hazard.tc_tracks - INFO - Progress: 22%\n",
+      "2022-03-09 17:14:06,867 - climada.hazard.tc_tracks - INFO - Progress: 34%\n",
+      "2022-03-09 17:14:06,973 - climada.hazard.tc_tracks - INFO - Progress: 45%\n",
+      "2022-03-09 17:14:07,082 - climada.hazard.tc_tracks - INFO - Progress: 57%\n",
+      "2022-03-09 17:14:07,192 - climada.hazard.tc_tracks - INFO - Progress: 68%\n",
+      "2022-03-09 17:14:07,299 - climada.hazard.tc_tracks - INFO - Progress: 80%\n",
+      "2022-03-09 17:14:07,403 - climada.hazard.tc_tracks - INFO - Progress: 91%\n",
+      "2022-03-09 17:14:07,478 - climada.hazard.tc_tracks - INFO - Progress: 100%\n"
      ]
     }
    ],
@@ -158,7 +172,7 @@
     "import numpy as np\n",
     "from climada.hazard import TCTracks\n",
     "\n",
-    "tracks = TCTracks.from_ibtracs_netcdf(provider='usa', basin='NA')"
+    "tracks = TCTracks.from_ibtracs_netcdf(provider='usa', basin='NA', year_range=(1985, 1990))"
    ]
   },
   {
@@ -170,8 +184,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
+   "execution_count": 4,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2022-03-09T16:14:26.088216Z",
+     "start_time": "2022-03-09T16:14:11.296099Z"
+    }
+   },
    "outputs": [
     {
      "data": {
@@ -179,13 +198,13 @@
        "<GeoAxesSubplot:>"
       ]
      },
-     "execution_count": 2,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 648x936 with 1 Axes>"
       ]
@@ -197,7 +216,7 @@
     }
    ],
    "source": [
-    "tracks.plot()"
+    "tracks.plot();"
    ]
   },
   {
@@ -209,9 +228,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 5,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2022-03-09T16:14:31.769431Z",
+     "start_time": "2022-03-09T16:14:26.089991Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2022-03-09 17:14:26,090 - climada.hazard.tc_tracks - INFO - Interpolating 61 tracks to 0.5h time steps.\n"
+     ]
+    }
+   ],
    "source": [
     "tracks.equal_timestep(time_step_h=0.5)"
    ]
@@ -236,22 +268,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
+   "execution_count": 7,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2022-03-09T16:16:23.376895Z",
+     "start_time": "2022-03-09T16:16:22.165304Z"
+    }
+   },
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "<GeoAxesSubplot:>"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/ckropf/opt/anaconda3/envs/climada_311/lib/python3.8/site-packages/pyproj/crs/crs.py:1256: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n",
+      "  return self._crs.to_proj4(version=version)\n"
+     ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 648x936 with 1 Axes>"
       ]
@@ -268,7 +303,7 @@
     "min_lat, max_lat, min_lon, max_lon = 17.5, 19.0, -68.0, -65.0\n",
     "cent = Centroids.from_pnt_bounds((min_lon, min_lat, max_lon, max_lat), res=0.05)\n",
     "cent.check()\n",
-    "cent.plot()"
+    "cent.plot();"
    ]
   },
   {
@@ -284,23 +319,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
+   "execution_count": 8,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2022-03-09T16:16:30.884930Z",
+     "start_time": "2022-03-09T16:16:26.237508Z"
+    }
+   },
    "outputs": [
     {
-     "name": "stderr",
+     "name": "stdout",
      "output_type": "stream",
      "text": [
-      "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
-      "  return _prepare_from_string(\" \".join(pjargs))\n",
-      "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
-      "  return _prepare_from_string(\" \".join(pjargs))\n",
-      "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
-      "  return _prepare_from_string(\" \".join(pjargs))\n",
-      "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
-      "  return _prepare_from_string(\" \".join(pjargs))\n",
-      "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
-      "  return _prepare_from_string(\" \".join(pjargs))\n"
+      "2022-03-09 17:16:26,240 - climada.hazard.centroids.centr - INFO - Convert centroids to GeoSeries of Point shapes.\n",
+      "2022-03-09 17:16:26,882 - climada.util.coordinates - INFO - dist_to_coast: UTM 32619 (1/2)\n",
+      "2022-03-09 17:16:27,619 - climada.util.coordinates - INFO - dist_to_coast: UTM 32620 (2/2)\n",
+      "2022-03-09 17:16:27,887 - climada.hazard.trop_cyclone - INFO - Mapping 61 tracks to 1891 coastal centroids.\n",
+      "2022-03-09 17:16:28,286 - climada.hazard.trop_cyclone - INFO - Progress: 11%\n",
+      "2022-03-09 17:16:28,697 - climada.hazard.trop_cyclone - INFO - Progress: 22%\n",
+      "2022-03-09 17:16:28,872 - climada.hazard.trop_cyclone - INFO - Progress: 34%\n",
+      "2022-03-09 17:16:29,274 - climada.hazard.trop_cyclone - INFO - Progress: 45%\n",
+      "2022-03-09 17:16:29,636 - climada.hazard.trop_cyclone - INFO - Progress: 57%\n",
+      "2022-03-09 17:16:29,913 - climada.hazard.trop_cyclone - INFO - Progress: 68%\n",
+      "2022-03-09 17:16:30,395 - climada.hazard.trop_cyclone - INFO - Progress: 80%\n",
+      "2022-03-09 17:16:30,546 - climada.hazard.trop_cyclone - INFO - Progress: 91%\n",
+      "2022-03-09 17:16:30,770 - climada.hazard.trop_cyclone - INFO - Progress: 100%\n"
      ]
     }
    ],
@@ -320,30 +363,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
+   "execution_count": 9,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2022-03-09T16:16:32.680624Z",
+     "start_time": "2022-03-09T16:16:32.673915Z"
+    }
+   },
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "<GeoAxesSubplot:>"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 648x936 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2022-03-09 17:16:32,676 - climada.hazard.tc_tracks - INFO - No tracks to plot\n"
+     ]
     }
    ],
    "source": [
@@ -359,30 +392,34 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
+   "execution_count": 10,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2022-03-09T16:16:34.528281Z",
+     "start_time": "2022-03-09T16:16:34.224702Z"
+    }
+   },
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "<GeoAxesSubplot:title={'center':'Event ID 948: 2017260N12310'}>"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/ckropf/opt/anaconda3/envs/climada_311/lib/python3.8/site-packages/pyproj/crs/crs.py:1256: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n",
+      "  return self._crs.to_proj4(version=version)\n"
+     ]
     },
     {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 648x936 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
+     "ename": "ValueError",
+     "evalue": "No event with name: 2017260N12310",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "Input \u001b[0;32mIn [10]\u001b[0m, in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mhaz\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mplot_intensity\u001b[49m\u001b[43m(\u001b[49m\u001b[43mevent\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m2017260N12310\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/Documents/Climada/climada_python/climada/hazard/base.py:926\u001b[0m, in \u001b[0;36mHazard.plot_intensity\u001b[0;34m(self, event, centr, smooth, axis, adapt_fontsize, **kwargs)\u001b[0m\n\u001b[1;32m    924\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m event \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    925\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(event, \u001b[38;5;28mstr\u001b[39m):\n\u001b[0;32m--> 926\u001b[0m         event \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_event_id\u001b[49m\u001b[43m(\u001b[49m\u001b[43mevent\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    927\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_event_plot(event, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mintensity, col_label,\n\u001b[1;32m    928\u001b[0m                             smooth, crs_epsg, axis, adapt_fontsize\u001b[38;5;241m=\u001b[39madapt_fontsize, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m    929\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m centr \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n",
+      "File \u001b[0;32m~/Documents/Climada/climada_python/climada/hazard/base.py:1007\u001b[0m, in \u001b[0;36mHazard.get_event_id\u001b[0;34m(self, event_name)\u001b[0m\n\u001b[1;32m   1004\u001b[0m list_id \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mevent_id[[i_name \u001b[38;5;28;01mfor\u001b[39;00m i_name, val_name \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mevent_name)\n\u001b[1;32m   1005\u001b[0m                          \u001b[38;5;28;01mif\u001b[39;00m val_name \u001b[38;5;241m==\u001b[39m event_name]]\n\u001b[1;32m   1006\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m list_id\u001b[38;5;241m.\u001b[39msize \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[0;32m-> 1007\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNo event with name: \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m event_name)\n\u001b[1;32m   1008\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m list_id\n",
+      "\u001b[0;31mValueError\u001b[0m: No event with name: 2017260N12310"
+     ]
     }
    ],
    "source": [
@@ -398,34 +435,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
+   "execution_count": 11,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2022-03-09T16:16:50.205767Z",
+     "start_time": "2022-03-09T16:16:44.776361Z"
+    }
+   },
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "(array([[<GeoAxesSubplot:title={'center':'Return period: 5 years'}>,\n",
-       "         <GeoAxesSubplot:title={'center':'Return period: 10 years'}>],\n",
-       "        [<GeoAxesSubplot:title={'center':'Return period: 20 years'}>,\n",
-       "         <GeoAxesSubplot:title={'center':'Return period: 40 years'}>]],\n",
-       "       dtype=object),\n",
-       " array([[15.08108124, 15.11391293, 15.04906939, ..., 16.39247373,\n",
-       "         16.53654363, 16.73792023],\n",
-       "        [23.28332256, 23.25727297, 23.23369223, ..., 27.39433861,\n",
-       "         27.73305539, 27.91210025],\n",
-       "        [31.48556389, 31.40063301, 31.41831506, ..., 38.3962035 ,\n",
-       "         38.92956714, 39.08628027],\n",
-       "        [39.68780521, 39.54399305, 39.60293789, ..., 49.39806839,\n",
-       "         50.1260789 , 50.26046029]]))"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2022-03-09 17:16:44,777 - climada.hazard.base - WARNING - Return period 10.0 exceeds max. event return period.\n",
+      "2022-03-09 17:16:44,779 - climada.hazard.base - WARNING - Return period 20.0 exceeds max. event return period.\n",
+      "2022-03-09 17:16:44,779 - climada.hazard.base - WARNING - Return period 40.0 exceeds max. event return period.\n",
+      "2022-03-09 17:16:44,780 - climada.hazard.base - INFO - Computing exceedance intenstiy map for return periods: [ 5 10 20 40]\n"
+     ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 648x936 with 8 Axes>"
       ]
@@ -437,7 +467,7 @@
     }
    ],
    "source": [
-    "haz.plot_rp_intensity(return_periods=(5,10,20,40))"
+    "haz.plot_rp_intensity(return_periods=(5,10,20,40));"
    ]
   },
   {
@@ -470,8 +500,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
+   "execution_count": 12,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2022-03-09T16:16:59.528716Z",
+     "start_time": "2022-03-09T16:16:59.378667Z"
+    }
+   },
    "outputs": [],
    "source": [
     "from climada.entity import Entity\n",
@@ -494,16 +529,76 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
+   "execution_count": 13,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2022-03-09T16:17:05.159458Z",
+     "start_time": "2022-03-09T16:17:01.966610Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2021-10-19 16:43:39,830 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n",
-      "2021-10-19 16:43:40,203 - climada.util.finance - WARNING - No data available for country. Using non-financial wealth instead\n",
-      "2021-10-19 16:43:40,850 - climada.util.finance - WARNING - No data for country, using mean factor.\n"
+      "2022-03-09 17:17:02,204 - climada.entity.exposures.litpop.litpop - INFO - \n",
+      " LitPop: Init Exposure for country: PRI (630)...\n",
+      "\n",
+      "2022-03-09 17:17:02,206 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n",
+      "2022-03-09 17:17:02,208 - climada.entity.exposures.litpop.gpw_population - INFO - GPW Version v4.11\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/ckropf/Documents/Climada/climada_python/climada/entity/exposures/litpop/litpop.py:607: ShapelyDeprecationWarning: __len__ for multi-part geometries is deprecated and will be removed in Shapely 2.0. Check the length of the `geoms` property instead to get the  number of parts of a multi-part geometry.\n",
+      "  for idx, polygon in enumerate(list(country_geometry)):\n",
+      "/Users/ckropf/Documents/Climada/climada_python/climada/entity/exposures/litpop/litpop.py:607: ShapelyDeprecationWarning: Iteration over multi-part geometries is deprecated and will be removed in Shapely 2.0. Use the `geoms` property to access the constituent parts of a multi-part geometry.\n",
+      "  for idx, polygon in enumerate(list(country_geometry)):\n",
+      "/Users/ckropf/Documents/Climada/climada_python/climada/entity/exposures/litpop/litpop.py:621: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
+      "  litpop_gdf = litpop_gdf.append(gdf_tmp)\n",
+      "/Users/ckropf/Documents/Climada/climada_python/climada/entity/exposures/litpop/litpop.py:621: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
+      "  litpop_gdf = litpop_gdf.append(gdf_tmp)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2022-03-09 17:17:02,560 - climada.util.finance - WARNING - No data available for country. Using non-financial wealth instead\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/ckropf/Documents/Climada/climada_python/climada/entity/exposures/litpop/litpop.py:621: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
+      "  litpop_gdf = litpop_gdf.append(gdf_tmp)\n",
+      "/Users/ckropf/Documents/Climada/climada_python/climada/entity/exposures/litpop/litpop.py:621: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
+      "  litpop_gdf = litpop_gdf.append(gdf_tmp)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2022-03-09 17:17:03,349 - climada.util.finance - INFO - GDP PRI 2018: 1.009e+11.\n",
+      "2022-03-09 17:17:03,353 - climada.util.finance - WARNING - No data for country, using mean factor.\n",
+      "2022-03-09 17:17:03,362 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+      "2022-03-09 17:17:03,362 - climada.entity.exposures.base - INFO - category_id not set.\n",
+      "2022-03-09 17:17:03,363 - climada.entity.exposures.base - INFO - cover not set.\n",
+      "2022-03-09 17:17:03,363 - climada.entity.exposures.base - INFO - deductible not set.\n",
+      "2022-03-09 17:17:03,364 - climada.entity.exposures.base - INFO - centr_ not set.\n",
+      "2022-03-09 17:17:03,365 - climada.util.coordinates - INFO - Setting geometry points.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/ckropf/opt/anaconda3/envs/climada_311/lib/python3.8/site-packages/pyproj/crs/crs.py:1256: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n",
+      "  return self._crs.to_proj4(version=version)\n"
      ]
     },
     {
@@ -512,13 +607,13 @@
        "<GeoAxesSubplot:title={'center':\"LitPop Exposure for ['Puerto Rico'] at 120 as, year: 2018, financial\\nmode: pc, exp: (1, 1), admin1_calc: False\"}>"
       ]
      },
-     "execution_count": 10,
+     "execution_count": 13,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAs0AAADbCAYAAACWX6wuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOyddZwd1fXAv2fm+Wp2N56N68YdEgIhWHFaoLiUttTwutDS/qBCS1sobZFCcXfXJJAEibv7xrO7WXkuc35/zOzLy7JJNglEynw/n/m892buvXOuzLwzZ849V1QVFxcXFxcXFxcXF5fdYxxqAVxcXFxcXFxcXFwOd1yl2cXFxcXFxcXFxWUvuEqzi4uLi4uLi4uLy15wlWYXFxcXFxcXFxeXveAqzS4uLi4uLi4uLi57wVWaXVxcXFxcXFxcXPaCqzS77IKIjBORZYeBHEEReVVE6kTk2UMtz+HE4dJHLl9eRKStiHwoIg0icoeI/EJE/nOIZVokIuNbmFZFpOcXK1Gz571FRB472Od1cXH5fHCV5i8pIrJWRE5sul9Vp6hqn92lE5Guzh9O2NnWisjPvgARzwPaAqWqev6BFiYi40XEcmRuEJFlIvKNAxez2XNdKSJTDyD/LSKScmStFZGPROToxuNN++hgICKTReRbe0lzn9Oulohc2eTYFSIyS0TqRWSDiNwuIp6c4yUi8qKIRERknYhc/AVV5YhBRPwi8oDTHg0iMkdETm2S5gQRWSoiURGZJCJdco4d7+yrE5G1uznH9SKyxmn3JSLSu4XiXQ1UAYWq+kNV/b2q7nF8fNGoan9VnXwoZfhfQmyuEZH5zvja4twHLsxJM1lE4s69qkpEXhCR9iJytHOtmzlp79/NvnsOdt1cXPYXV2l22V+KVTUfuAj4tYh85XMuvwuwXFXT+5oxVxlrwiZH5kLgp8D9IlJxADLuy7n3lacdWcuAScCRYG2fB3wfmN3MsRBwA3Z9RgMnAD/KOf5PIIn9oHQJ8G8R6f9FCnso2Mfx4QEqgeOAIuBm4BkR6eqUVQa84OwvAWYCT+fkjwAPAj/ejSzfAr4JnA7kA2dgK8ItoQuwWN3Vsf6XuQv7mv0hUAp0BH4FNL3XX+Pcq3oDxcDfsMeiCQzLSTcO2NRk37HAh5+/6C4uXxCq6m5fwg1YC5zYzP7xwAbn+6OABcSAMPAToCuggCcnzwxsBcjAvqmuA7YBjwBFTprGfFdj3zg3Az/cjWy/xVagUs55v9nCsr8JrAc+3FO9cvZtx7Zo3wI8lrN/lzpiKywPODJvBG4FTOfYlcA07D+KGuB5IA5kHNlrc8p4xDnnOqcuxm7q31SeCkee1s3VBSjHVp62A9XA3c7+3bZZM+dsBbzmlLHD+d7JOXabU5+4U6e79zK2pgJX7iXNTcCrzvc8p7975xx/FPjjbvL2ACY6da0CHsd+iGs8/lOnnxqAZcAJLbgefgw832TfP4C/t2AM7E2etY5M84EEOdfOfly384Fzne9XAx/lHMvDvlb7NslzIrC2yT4DWyHfa9s0I8ND2Ndm0hkPJ+aOWXZeP1dgX49VwC9z8o8CPgZqnfa8G/DlHFfgu8AKZyz+E5Cc498Gljj9uxgY1vSe1sJz9NxN/SY7/fuRU79XsZXGx4F67Ptd15z0Y5x9dc7nmJxj3YAPHFnfdeTIvbaPcs5Ti/3QOX4/+mMy8AdguiPDy0BJzvFjcs5RyV6uTSdPb+xrfkQLzv2tnN8/ABY639/HuccDbYDV2Pf23H2Kc59xN3c7EjbX0uyyW1T1Muw/vTNVNV9Vb8897ry+Gwv0B+ZgK5BXAscD3bGtV3c3KfZ4oBdwMvCz3biI/Ab4PY61VVUfaGHZxwH9gFP2VC8RMUTkq9hWkQV7SuvwMJAGegJDHdlzX0WPxv5DaANciv2H/7Eje7GT5h/Yild3R87Lgb26h4iIz0lbja1AND1uYiu467CVlY7AU87hK9l7mzViAP/FtiB2xla+7gZQ1V8CU3AsSqp6zd7kbgHHAouc772BjKouzzk+D3tcNYdgKwkdsPu7HFtpQ0T6ANcAI1W1AHssrG2BPI8BXxGRYqccD3ABtvIOex4Du5Unh4uwLbrFqpoWkdcc15vmttearbRIW+y2amy3/tjtBICqRoBV7L7dcunkbANEpNJx0fitiOz1P0FVr8RWIG93xsN7u0l6DNAH+63Cr0Wkn7M/A9yI/dbhaOf495vkPQMYCQwGvo5zTYvI+dhtezn2G6OzsK+NprTkHHviQuAy7OupB7YC/l9si/4S4DeOPCXA69hW2VLgr8DrIlLqlPMEMMuR4/+wHyRw8nZ08t7qlPsj4HkRae0c/9cexsj8JvJeDlyFPQbTjjyISGfgTez7T2tgCDC3BfWfAFSq6swWpG2sTxlwLvZ/AdgW5GOd78diP0xPbbJvjapuaOk5XFwOOYdaa3e3Q7PRAktzc+nYaUWqxVbilgDXOcfeB76fk7YPtkXKk5Ovb87x24EHdiPfLexqkWlJ2d33UN/x2FbzWmyL8Fzgwt2cq7E8D7a7QAII5hy/CJjkfL8SWN/kXFcCU3N+m04ZFTn7vgNM3kPdk46sGWylYHxzfYStEGynGevlntqsBeNjCLAj5/dkcixKe8m7R0sz9sPCBqDM+T0O2NIkzbd31z7NlHcOMMf53hPbqn4i4N3Ha+JN4NvO9zOw3Q/Y2xjYkzw519BV+yJLM2V6gfeAe3P2PUATazz2W48rm+xrztI8xhnjr2M/PHYFljfWvwXyPATc2mTMNrU0d8o5Ph3nemumrBuAF3N+K3BMzu9ngJ85398Grt9NOWtp5p62h3PsydKcaxm/A3gz5/eZwFzn+2XA9Cb5P8a+B3TGVmDzco49kdNOPwUebZL3beCKfRwbk3PHAfabqST2fefnufXehzJ/BXzSZN8G7HtSHOiSc+6os38j9sNU7huxauyHyjuxr+l8YGvOvv8eyHXhbu52sLfPy//S5ctHmX7W37gDtsWzkXXsVDwbqWxyfGALz7evZTfHJlXt1MLzNdIFW2HZLCKN+xpfbbf0vGWAj8/K33EPeZ5R1Usd683zwHDsP6imlAPrmukL2HObbcxNKCIhbBeTr2C7agAUiIipqpk9yLlPiMg5wB+xlZtG/9kwttUwl0LsV9rNldEG25I2DijA7o8dAKq6UkRuwFbi+ovI28BNqrqpBeI9DHwPuB/7jUGjlXmPY2BP8uSwtzGyWxzr76PYilCulX+f2q0JMefzdlWtBWpF5F7gNOz6fx5syfkexVaYcCYb/hUYge3r7sG2xu41L/Z4X7W3E7fwHHtia873WDO/G+Vpeo3Bzmu7A/aDZ6TJsXLnexfgfBE5M+e4F3sOw77S9L7qxb7vtKi9mqEaaJ+7Q1U7OW9gUthKbyPXqWpzkVM+wW6nAdhW5X+ralhEKnP2NVrE38S+fgC+o6qP74fMLi5fOK57hsve0H1Iuwn7j6CRRktL7h9OeZPjLVFmWlr2vsiaSwT7j7WRdjnfK7GtjGWqWuxshaqa+wq86Xmb/q7C/qNpKv9G9oKjWH4HuEVE2jeTpBLovJsJZi1ps0Z+iG2JHq2qhex8hdr457i/bZvFmSx6P7a7T65bzHLAIyK9cvYNZqcbQlP+4MgzyJH10hw5UdUnVPUY7Lor8KcWivgSMEhEBmBbmhv/uPc2BvYoT6NYuT9E5E3ZGYGm6fZmTjrBtii3xfZlTuUUswi7nRrT5mG7Euyu3XJZhq2EH3C/7gf/BpYCvZz2+gWfba/dUYldxy/yHPtC02sMdl7bm4FWTr/kHmukEtvSXJyz5anqHwFE5J49jJGmfdz0vprCvu+0tL2aMhHoJCIj9iMvAKoax/bxPgNor6pLnUNTnH2DcCYBquqparv65LsKs8vhjKs0f7nxikggZ2tO8dqK7Q/bEp4EbhSRbiKSz06/5Fwr6M0iEnIiI3yDXWf7H2jZ+8tc4FgR6SwiRdivNAFQ1c3AO8AdIlLo+EP3EJHj9lDeVuw/HJ9TRgb7FfNtIlIgdliwm7D9aPeK82fzNvZEzKZMx/5z/qOI5Dn9ONY5ti9tVoBtQat1/DR/00yd9jgORMQnIgFs5aRxbBnOsQnYSui5qjq9Sf0i2BMZf+fUYSxwNjstvc3JGnZk7UhOdAgR6SMiE0TEj/0aOYbt4tIYdnC3SqLzJ/8c9iv06aq63tm/tzGwW3n2cK5cJaHplhtW7t/YftJnqmqsSTEvYvskn+u0+6+B+Y3KiSNnANvqKE5/NI7JKPa19xNnTHbCfn3+mpO3MbRk173VZT8owJ5QFxaRvtjW/ZbyH+BHIjJcbHpKTpi9z+kc+8IbQG8RuVhEPCJyAbZ7xGuqug47isRvnWvjGGzXjkYeA84UkVNExHT6Z7zTF6jqd/cwRpr6rV8qIhXOG6PfAc85953HgRNF5OuOfKUiMgSyoTHXNlcpVV0G3As8JSIniR0338R269kXPsR2jfkoZ99UZ98WVd0fK7iLyyHDVZq/3LyBrVQ0brc0k+YPwK/Ennzyo2aO5/IgtqLzIbAGW2m5tkmaD4CV2P62f1HVd1ooa0vK3i9U9V1sBWI+9ivcphOxLsd2r1iM/dr9OZq8umzCRGxr3xYRaXRBuBbbor0a+0/jCew6tZQ/A1eL7QqQK3sG+4+4J/akzQ3YE9hg39rs70AQ2zr1CfBWk+N3AueJyA4RuWs3ZbyDPY7GAPc53xst1jdjT4R8ozmLKvYkrSC2P/KTwPdUdXcW099ih62qw/bJfSHnmB/b/aMK+xV/G2wrI9jWuI93U2YjD2O7DDVV2Pc0BvYkz37jKIPfwfYv35LTbpcAqOp27IlXtzkyjcaewNbIsdh98AY7J3fmXm/XYCv7m7DbJXdMlmO/5t/r25D94EfAxdhuJPfT8gdnVPVZ7Po+4eR/CXsS3ed2jn1BVauxraY/xHZp+AlwRo7r0cXY/VKD/SD6SE7eSuyHw19gz0uoxH7g2p//5Uex/cy3AAHgOucc67Fdbn7IzrkcjW8nyrF94HfHD7DdJ/7q5N2APZnxAux7TUv4APsazI1bP9XZ54aaczniENVD8XbO5cuGY7Fagz056/OwDru47BNir1j3rKq+vYc0nbFf67dT1fqDJtxhhoj8Ctiuqvceallc9oyITMaeXLhPKzKKyDvYkyqXfCGCubj8D+JOBHRxcflSoHtZsc5xJbkJeOrLrDADqOqth1oGly8WVT35UMvg4nKk4SrNLi4uX3qcyVpbsV0SPu/VLV1cXFxc/gdw3TNcXFxcXFxcXFxc9oI7EdDFxcXFxcXFxcVlL7hKs4uLi4vLYYkTgs1yooZ84W4zIvJN51wqIj2/6PO5uLgcWbhKs4vLlxgR8YvIAyKyTkQaRGSOiJzaJM0JIrJURKIiMik3Lq6IHO/sq2su5quIrBWRWE64tJaGGEREJotI3MlXJyIfisjAnOO3OMrNdU3y3eDsv2Vf2uJQIiK9ReRlEdkuIjUi8raI9GmS5kYR2eK0xYNix6JuPHaNiMwUkYSIPNRM+SER+ZeIVDW25UGo1ufFJic28VsAItJeRF4RkU37E0taRO4TkWWOMn5l7jFVfUBV83eT1cXF5UuOqzS7uPyPIc0vUrM7PNjxYY/DjqN8M/BMoyIi9jLeLzj7S7AXa8iNeRvBju27pwU9zsxZlGFfZ+xf4ygxpdjLiDeNn7wcuKLJvsud/YeUfeyHYuAV7FUZ22IvWvNyTlmnAD8DTgC6Yi8089uc/JuAW9l97O/7sPuvn/N54z7IdrhhYccRP3c/88/Djgs++3OTyMXF5UuBqzS7uBwkROTHIvJ8k33/EJG/O9+LHKvvZhHZKCK3OqtwIfYKdBNFpNqxFj4uIsU55awVkZ+KyHwg0lKFTVUjqnqLqq5VVUtVX8OOpz3cSfI1YJGqPuusmHcLMFjsVdZQ1emq+ij2oi1fGE5s76ewV1vLZQbQuMIkzmfQ2d8sIvK6iFzbZN98ETnH+d5XRN51LL7LROTrOelOd6zx9SJSmWvNlp2r6H1TRNZjL3LT0vpNd6ycNc5S2X8D+ohIqZPkCuABVV2kqjuwF5m4Mif/C6r6EvYCG03r2wc4C7haVberakZVZ7VUtt21hzMma0RkmPO7gzM2xzu/J4vIH0RkumPdflns1SYPCFXdqqr/Yg99vJf8/1TV97EX+3FxcXFpMa7S7OJy8HgM+Eqjsusothew03r6MJDGXt1vKHAy0BhbWLBXZ+yAbS0s57MrOF4EnA4Uq2paRF4TeyXH5ramqx7iyNQW6I29oiFAf2zLHJBd8nqVs7+lPO64HbwjIoP3nrxZuXzAJdirFTblUWzrMtjK5SPNpMnlYeDSnLIHAx2xVyvMA97FXnGuDXab/qtRKce2rF+ObRk+Hfheo7Kdw3HYfXSKU/7u+qBWRH62GxmPxV5muFEJ3qUfnO9tc5TqPTEaO5Tebx2ldoGItMhKu6f2cJZA/il2/4aA/wIPqerknCIuB67CHrdp7BXmGsven3ZxcXFxOWS4cZpdXA4SqrrZ8SU9H3tp368AVao6y1FWT8VWeGPY1uK/AVcD96rqSuzlxwG2i8hfsZflzeUuZ2nexvOdsS/yiYgXeBx4WFWXOrvzsZf4zaUOKGhhsZdgvwYX4HrgbRHpq6q1Lcx/l4j8BQhhLwP9tWbSPAZMFXsVuwuBsdgPGLvjZeAeEemlqiuAy4CnVTUpIl8F1qrqf520s523A+dhW9wn55QzX0SexFaSX8rZf4vzcAGAqha3sK4AiEgn4J/YC600ko/d7o00fi+gGetyEzoBA4DnsZXXo4HXRWRxC1aDO4M9t8f9InIm8Cmg2BbtXB5V1YVOvW4G5orIFY61u3gv53ZxcXE5rHAtzS4uB5dcK+el7LQydwG8wOZGaxtwL7Z1DxFpIyJPOW4b9diKYlmTsivZT8ReDe9RIAlck3MoDBQ2SV4INLSkXFWdpqoxVY2q6h+AWmDcPoh2naNcBbAVuOdEZFCTc6zHfqD4PbAi98EBQETelJ0TES9R1QTwDHCpU++L2LUfRudaPbEV/3ZOWaPFnvi4XUTqgO/y+fZDa+Ad4F+q+mTOoab90Pi9Jf0QA1LAraqaVNUPgEnYbzL2xh7bw+F+bKX8H07b5pLbFuuwx3jT9nJxcXE5InCVZheXg8tLwCARGYCtBD7u7K8EEkCZqhY7W6GqNroF/AHbkjdIVQuxFW5pUvYuKxU1URabbm/mpBPgAewJaOc6PrWNLAIG56TNA3qw031jX9Fm5N57Jtvfegq2ctycsvcI8EOacc1Q1VNzJiI2tvfD2MrfCUBUVT929lcCH+T0QbGT73vO8SewJ+yVq2oRcE8z9WnaD7vrg7CI/CInXStshfkVVb2tSZm79IPzfWuO+8aemN+CNLtjj+0hIvnA37HHzy3N+CyX53zvjK28Vzl5W9QuLi4uhydiR/HZJiILW5C2i4i8L/b8kcnOG7UjDldpdnE5iDiT6Z7DVr6mO1ZSVHUztsJ0h4gUiogh9kSr45ysBdjWxloR6cieo1U0nitXWWy65YaV+ze2D+6ZjmtILi8CA0TkXBEJAL8G5je6bzhyBrAtiCIiAcf/GBHpLCJjRcTn7P8xtpVxmnO8ceJc15a0nYgcjT0RsDmF/WlsZfqZlpTlKMkWcAe7RuR4DegtIpeJiNfZRopIP+d4AVCjqnERGQVc3IJz7a4P8lX1907dCoG3gWmq2pw/7yPAN0WkwlGufwU81HhQRDxOP5iA6bR3o/vdh8B64OdOurHAeOd8iMiV0ky4wBa2x53ALFX9FvA69kNELpc6MoeA3wHPqWqmpe2yO5y6Nobc8zu/G4/dIiKT95DX56QXwOu0lftf6OKy7zyE7WbYEv4CPKKqg7DvBXtyoTtscW8ULi4Hn4eBgXw2fNrlgA9YDOzAVq7bO8d+CwzD9mV9HTsM3AEjdszl7wBDgC25bgwAqrodO7TXbY5Mo7H9hhs5Fvv1/xvYlsQYtvIPtoL5byffRuyb66k51tFy7Ff2G/cg4t2NMmG3169U9c2miRwXkPeaUfr3xCPY/fBYTjkN2Mr3hdhh3LYAf2KngvZ94Hci0oD9ANEiJb0FfBUYCXyjicW1syPXW8Dt2G4V65wt16f9V9ht/zPstxAxZx/Om4OzgdOwx8/9wOU5fuvlOA8yTdlTe4jI2dh9+l0n+U3AsMax4/Ao9h/rFmwXm11iah8AMeyHSIClzu9Gdlsfh3ec9GOwQ/HFsMexi4vLPqCqHwI1ufscY89bIjJLRKaIE2kJ2+DxvvN9EvY96YhDVHXvqVxcXD43HEVoKdBOVesPtTyHCrEn7m1X1XsP0fkvxw7DdsyhOP/hgtgLzlzfgkmB+1ruZOAxVf3PAZRxLLZFPAFcoKpvtyDPXOCEFrquNM37DexwfwGgQlW/0FCKLi5HOs6bwtdUdYDz+33gu6q6QkRGA39Q1Qki8gTwqareKSJfw56YXLY/1+mhxFWaXVwOIs5r4L8Chap61aGW58uK4y4wEXvC3d5C1LnsB5+H0uzi4nJ4k6s0O3MctgPLcpL4VbWfiHQA7ga6YbuMnQv0V9W6pmUezrgh51xcDhLOJLqt2K/WW+oH5vI5I/bqei8A72H7lru4uLi4HDgGUKuqQ5oeUNVNOCFDHeX63CNNYQZXaXZxOWg4sXvzD7UcX3acV/x5h1qO/3VUdfyhlsHFxeXgoar1IrJGRM5X1WedyEyDVHWeiJRhT6K2gJ8DDx5aafcPdyKgi4uLi4uLi4vLPiH24k4fA31EZIOIfBM7lOc3RWQedqSjxgl/44FlIrIcO7xp07CaRwSuT7OLi4uLi4uLi4vLXtirpbm54NUiMkREPhGRuSIy04lX2lzeYhF5TkSWisgSJ84qItJBRCaKyMuOb0tjbM2oiLTJyR9urlwXFxcXFxcXFxeXg0lLfJofwp7xmDvD/Hbgt6r6poic5vwe30zeO4G3VPU8Z8GDkLP/OuBaoDt2TNHGgPhV2Kt6/bQlwn/lK1/Rqqqq7G9VxXahcTmccPvl8MXtm8MTt18OX9y+OXxx+wZmzZr1tqo2O9H8lJ6i1dGDLdHembWZ3cp8uLFXpVlVP2xmxS4FCp3vRdhB73fBWeHqWOBKp5wkkHQOm9ircVnsugTtg8CVIvInVd0lYHZzVFVVMXPmzOzvhoYGCgoK9pbN5SDj9svhi9s3hyduvxy+uH1z+OL2DTgT7pqlOgqffudgStMyPLewW5kPN/Y3esYNwNsi8hdsF48xzaTpjh2v778iMhiYhR1AP4JtuX4Ue3Wq3GVow9iK8/XsutqVi4uLi4uLi4vL/iLsaqZ02Wf2N3rG94AbVbUcuBF4oJk0Huxlf/+tqkOBCPYSr6jqOlU9VlXPdJZpzeUu4ArHUu3i4uLi4uLi4uJyyNlfS/MV2NZggGeB5lZ82gBsUNVPnd/P4SjNe0JVa53lFr/fgrQ0NOzUuSORyN6yuBwC3H45fHH75vDE7ZfDF7dvDl/cvmkBrqX5gNhfpXkTcBwwGZgArGiaQFW3iEiliPRR1WXACcDiFpb/V2DG3uQTkc/4L33Z/ZkOV9x+OXxx++bwxO2Xwxe3bw5f3L7ZC67SfEC0JORcc8Grvw3c4QSv/j1wtZO2g4i8kZP9WuBxEZkPDHHS7hVVrQJeBPz7UBcXFxcXFxcXF5fdIYfhtidxRQIiMl1E5onIIhH5bTNpRETuEpGVIjJfRIbtT9O0hJZEz7hoN4eGN5N2E3Bazu+5wIiWCKKqtzT5fRNwU0vyuri4uLi4uLi47JkjMCJfApigqmER8QJTReRNVf0kJ82pQC9nGw382/n83Nlf9wwXFxcXFxcXF5cjhSMweobay1Y3LnTndbamS1mfDTzipP3EWVivvapu/rzl2d/oGS4uLi4uLi4uLi4HSpmzunTjdnXuQRExRWQusA14NyfARCMdgcqc3xucfZ87rqXZxcXFxcXFxeXLwOFpaa5S1d268qpqBhgiIsXAiyIyQFUX5iRprlZNrdGfC66l2cXFxcXFxcXly8ChnvS3jxMBc1HVWuyobU2X3N4AlOf87kQzK1V/HrhKs4uLi4uLi4vLl4FDrSDve/SM1o6FGREJAicCS5skewW43ImicRRQ90X4M4PrnuHi4uLi4uLi8uXg8HTP2BPtgYdFxMQ29D6jqq+JyHcBVPUe4A3syG0rgSjwjS9KGFdpdnFxcXFxcXFxOexQ1fnA0Gb235PzXYEfHAx5XKXZxcXFxcXFxeV/nSMw5Nzhhqs0u7i4uLi4uLh8GXCV5gPCVZpdXFxcXFxcXL4MuErzAeEqzS4uhyGKkqEWJYWHVgje7LEMYSzCmBRhEPxM3jS1KAlMWmHgO5hiu7i4uLgczrhK8wHhKs0uLocZGRqo5iFSbKGh1mL1EmXDkjZEGwzwVCGeejxewfQKQU97Qt7ueD1ePF4h6V2AeHbQqYeHjl2CFHEaeYw61FVycXFxcTkccJXmA2KvSrOIPAicAWxT1QHOviHAPUAASAPfV9XpzeRdCzQAGSDduOKLiHQAHnOOXaKqYRG5BfgJ0FVVtznpwqqaf4B1dHE5YkilUsxf+QoLF69m7RIf9bVJuvaFnv3q6FR6PDXp1yBVjjfdn/rUDJLprQRTFWRSXqLpdUQi1VjJ1rw0sZ5QUS0jx7/A8UMH4/X4D3XVXFxcXFwOJQLiKs0HREsszQ8BdwOP5Oy7Hfitqr4pIqc5v8fvJv/xqlrVZN91wLVAd+BSbAUcoAr4IfDTlgjv4nKko6ps2bKFJUuWsHjxYlatWkXbDnl0qRC+dslguncZTJ3xHAb5tKILVXjxUUQh/allOWnitGUsHkoI8yl1rCdEH/znD+TT+Y8y44MGJj7/G4455hjGjRtHUVHRoa6yi4uLi8uhwlWaD4i9Ks2q+qGIdG26Gyh0vhex78sVmoDlbLld+CBwpYj8SVVr9rFMF5cjing8zt///ncaGhqoqKhgzJgxXHXVVfhDluOesYhaFiEEKOIr+OhCkKHEmEMV9wAG+RyLSSsAQgwhxgKizCZqzKbPEC+jhlxM3aZOfPDBB/zud7+jf//+jB07li5duhAIBA5tA7i4uLi4uBxB7K9P8w3A2yLyF+wVWsbsJp0C74iIAveq6n3O/ruBR4E64OKc9GFsxfl64Df7KZuLy2GPqvLoo49SXl7OxRdfjDR5Z9aaHzgTAdN4KM5OBCzh62Q43ZkIWLjLREADP635FhnqsEhgUoyBj7wOcNFFF3H22Wfz8ccf8/LLL7Np0yaKi4vp1q0bHTp0oLy8nPLycvLy8g5qO7i4uLi4HERcS/MBsb9K8/eAG1X1eRH5OvAA9nrgTRmrqptEpA3wrogsVdUPVXUdcOxuyr4LmCsid+xNCFWloaEh+zsSiexzRVy+eNx++SxTpkwhGo1y3nnnEQ6Hd5PK42xxZ8slhD2doKFpJuzn2CCQcLadjBo1ilGjRpHJZKiqqmLDhg1s376dpUuXsnXrVgKBAO3ataNDhw60a9eOdu3aUVBQcCBVbRGpVIr6+npqa2uzW11dHalUiqKiIoqKimjXrh2dO3fGNM0vVBbLsojFYkQiEcLhMIlEgry8PIqKisjPz//Czw8Hfs1UVUW57baPeffdNWzZEqGoyE9FRSk33jiKCRO6fE5SNs9ppz1Dv36l3HHHCV/oeQ4V7v3s8MXtmxbgKs0HxP4qzVdgW4MBngX+01wiVd3kfG4TkReBUcCHeypYVWtF5Ang+3sTQkQ+84d+MP7gXfYdt192snDhQqZMmcKPf/JN/IWfosTxSX880hMRwdIocRaS1o34pAd++iGSE3JOa4kzH0vr8UlvfPRExEA1TkLnk9JVeKUnfhmISI4LhlUPmS1gtgajFcXFxbRt25b8/ABJXUAis5zaqlZs2ZDPhsqtTJ06lfWVazFNpWN5CV3Ke9Olcx/Ky8spKSkBLDLUACYmrXaxlie1kgRLAZMAFWiqhJqaGqq3Lad6y1RqqndQ3VBKda1BTU0N0WiUVq1aUdoqn9JWeZS0Lqdfv354vV473/ZKZn36NrV1cQb378zwo86gZ+++GIZFgsUkdSVeyvHLAAwJ7awyMWIsIcUm/HRDY+WsX7eJ6uoqdjSspq5+E9GwQaTeJByO0dDQQCQSIRgMUlAQoqCggGAwn4aGBmpqagiHwxQW5VFU4qFL17aMHnkiXTr1RURIsZU4i1EsAvTFR8esHKqKRQ2KhUkJIjsV7zTVxFiMEsdPL3zYSu3+XjOqcU497Wmi0Qj33D+Yfr2Hs317mg8+WEckYhGN1bF12zq6dO5FUWGb/TrHnjBNE5/P9z99zf8v1+1Ix+2bveAqzQfE/irNm4DjgMnABGBF0wQikgcYqtrgfD8Z+F0Ly/8rMOMA5HNxOSzZtm0bjzzyCFd9+1Qy+X8hYpkIXqK8Qcg4i6Axnir9Kxa1GBQS1Sl46U4JP7AVM91Ejd6FkkEIENGJBBlDIWexI/0HMmzGoJg4k4jSkVaeXyB4oOH/IPIfbOu0QPACKPoLqkpt5m+kdRUGRQTL6uhRVsKIEb8izEc06Ebqa/xsrmxgS+UnTP2oko2V1aRScdqWW7QrV9p1EjqWl1HIedTVWGyqmsGWmjnUVQt1NRlqq58nETMoaZVPSd5KSgsjlBRbDOy4ndIREyjt/ksK88CovBgiU+2GMvKg/e1QchnE18H8S6BzHdtjnZmzuoAXn17Fjlgr+g4S+g6N0LVnMWJ+iKkllBo/xpAQyXQ9CzfeReXaHWxea7Bx7Vs01EJ5p24Uta4lUFBLfqsAbbokycsP0LHwCooLOyJ5S4iYb6COpd5HISVchyF+qlIvsKX2E+prhNVL13Dfff/E52nFkOHd6D5yOWVtg6RTsG3zO0Q2DUaSnVAixOVDVOoRA0wJkmceh9doT1q2EzEmgRiYhgfkHTqWjaVt3oT9Gl+qSdZX/Y5pU/08+2oD5T2fZVXlJKo3D0dkIzNmrmP+ogytygwmveNl4cICaqo9hEI+xo/vxp13foWOHe3pKpMnr+X44x/mvfcu4xe/mMiCBVupqGjNffedybBh7Vss0/jxDzFgQBvuvvu07L4rr3yJqqoor71me+e99dZKbrttCgsXbkMERo7syN//fgr9+rUGYO3aWrp1u5Pnnjufe+6ZxbRp6+natZg77/wKJ53UY7/aysXlS4e7jPYB05KQc09iR8YoE5EN2L7G3wbuFJHGd8dXO2k7AP9R1dOAtsCLjvXJAzyhqm+1RChVrXIs0zfuc41cXA5jpk2bxtFHH03HbhuIq0W+cTFCkLD1OHHrIwyjExa1BBmDj57EmEaSVWSowUMpcZ2HkiSf0zEpIczrxJhBUAeSYTM+GY5fhpPQmSR1Nmldj9cyIHIPePpB0Z+g/v8g9hSELiZDGWldhVf6EpBjSelS4vohKV1GTGZhSh5dSs+mc2mMuiEvEaInxfIj1uz4K5UbNlBb2Z/lczYz6dXNeMwHKCvpTF7pFgpKDIYMGktJaR5myfuUFg6grH4T1H0ArX4DZgfY8X9gPQfFf4bq+2yFudXlUPQ1qLwKNv8CWl0MO16HdA10/Cmt8wZxcumfOLn/Q2zp/jHT5v6X91/2Ub8jQmmbIN7ANgqC91Bbk2HjxkqKy5Tyru3o3aMnY0/YRnH7zbQ1LqRG78BDN/KYQJoNRJhIodQSpA9beBPBSwmXE2U2MWYTYw4hRpP0zqWsdRndW5/CwD61jD/rTWrXDmDOzGU89vcGTMkQicRp1RradVxIcUBIZFaQ0npMqxzUR8JahegUPNqbpG4gpQk8VjtUDZJWhLc3TyTom0+PHj2oqKigT58+hEKhPY6rWCzGxo0bWbd+FivXVOHzdeDWX3k448xiOnWto1u50n/gOPydtlKY34Fivoov/zlO/Oo2gumezJ+3mTffXMiECat57LET6NevX7bsn//8ff70pxNp376A669/i0sueYHFi7//GT/8XFRhy5YtWJbVousiEklyww2jGTSoLbFYmltv/ZAzz3ySxYt/gM+30yr/y19O5M9/Pol//es0br11Chde+Dzr1t1Afr67iI+Li8sXT0uiZ1y0m0PDm0m7CTjN+b4aGNxSQVT1lia/bwJuaml+F5cjAa/XdrMwpTUoJHUhXumFEsUjXfBQCkCSpfilHymtRPBhYr9y9EgZKCRYQlBGkdEaPLTDlDJASOkyAsYYUtYywMCQEmCHc3bT1mbEcH4rJvmk8ZLSNQSNE0hai7LymZSQZDUWYRLOyyQPJQAUFJn0KvJQ1H8YFjto4HVCHEWRcR479AlizCWfAizqiWLgpQwaY0VH34X8CyCzAbz9HVHUkcnAnj9sYFvFgYBjSdzxOuQNgdhi8LajTZt+jD0pwDEnGVi1X2ND9SvEYgbeeH9KW3WjfWcf9YH7MfFRxGB28BTgw9RSDPJJsxkRg4QudlqnNNsuICiWI4eNIJiUkGYrSpo4SxERunfrRadu+Yw/dxrx7f0pKWlF3DuNIEMp4TzqrSeJ6XbyZSQGhdTrOry0o8T8Fg18SD1vE6AcP92o4w182oPw2uNZs2YN06ZN45FHHqFTp05UVFRQUVFBUVERGzdupLKyksrKSjZs2EB9fT3t27enY6fWdOmu/P4v9dz2mzL+8uckA4cEGTc2j3PPD9Gtr+HUDS77Vj5JtlPKSfilK598spKjj36c996bzpNPPkks1haAa68dwHHHdcEwDH7962M55pj/snFjA506FZJLNBpl2bJlbN26lXB4Nf/4xzQMw2DNGpNAoJ6lS5fSs2dPPJ7P/u2ce27FLr//+9+zKSz8I9Onb+SYYzpn999441GceWYfAH7/+wk88sg85s7dsksaFxeXPeBamg8I1/3BxeUg4vf7qa+vJ2h8BYsG4tY0kjoXnwwj3zwfU0op5OtEdSq1+gBeepAvJyNiW9ICDHd8YKdTr0/hp4J8OcPOZ15N1HqH+sw/8Eh3QsYpmNIKzGIIfQuiD0LN2bYgwfPBOwxJRCkyf0DUep36zD/xUE6eeToeKadYz6OeN6jnVYQQeYwjj7EAFMip7NBHqeMxwFY482Q8AIWcBQhh3gcMQoymgJMg3wvp9RB+Aqqvh+Ap0OpmW55WF0Ldc7DjIXuTIHT4I4gJxSdD1z/D1vth+UVQdCJ0/i2GEaKVfouw9Q6p4ifpVtyJPDmHoLFzBUSDrxHhY2p4FB9dKeB4TAlQzFWE9S1q9SFM2lAg5+AXWxkr1NOo53VqeBAAH10JMgSAEi6inreo5TlMiijgBIIMIUB/1EhitJ1FHCXIEIps+wEhOZGkLiesLwEg5JFvnA5APmOwCBNhFnGWEGAARfIVAmUeunXrxoQJE0gmk6xcuZLFixfz8MMP09DQQKdOnSgvL2fIkCGcccYZtGnTJjtBMWEN4Ohj3uTCK1YwY1o3Zk8fyHtvb+dvf53Dzbf24Lu/WE01/2bBbOHO37Vm0dyXqKmJoc6Dy3HHncXIke144omPuOeeycyb9w6LFr1MRUUFrVp1B2DbtggdOuSzbt26bIzxTZs20b17d/x+PwMHdufWW88D4P3378fns3jllVfYunUrFRUVVFUpmczOBXdWrarh5psnMXXqGrZvjwKCZSmrVlXtohAPGtQ2+71Dh4KsLADr169nzpw59O/fn+7du2MYOx94XFxcHFyl+YAQzVp4jjxGjBihM2fOzP5uaGhwJwEchrj9spMpU6awfv16LrnkkoN/cqsGMpvBaAtmGXBgfaOaJk0VgolJKSIHqKSoQqoSMvXg6wrmoVsM1NIEGWoQAnik1QGXp2qRoQrIYNIa27Nt93wR18y3vvUKjzwyj/qG64mndtCr29OceGIPvve9EbRpk0dVVZRx4/7LpElXMH5816xP8/btP0Y1wqJFi/jww/n85jc7uPZaP35/NUVFRfTr14+Kigp69uyJ1+v9jA/zhAkP069fGf/85+nU1dWxcOFCbrxxKlVVDVx3XRmDBg3iu99dSCiUol+/Gk466Sii0Qauv34FF1wQ5NFHf0hlZQPdut3JjBnfZsSIDkSjUd544w3OP38RDz10GldcMZKamhr++te/UlNTQ15eHv3792fgwIFUVFQQDAb30jotx72fHb64fQMiMqtx9eWmjOgiOuMXB1uivWN8l93KfLjhWppdXA4igUCAeLxp+LiDhFFib58TIh68tPvcykMEfIfHa3ZD/Bi0fLLb3hAx8PD5R6rYFyoqWpNOWyQTflat8FJVFeP3v59At272Q8ELLyzZbd7WrVszfvx4unYdwm9+cyfHHXccEyb0pVWrvT9QtG6dx+bNdljFoqIixo4dSzQ6j759OzJhwiA++mguK1bs4Prri/i///sZBQUFzJ69GctagWl6ePrppxkzZuckQsuyeOihh7KuTs8//zxXXDGSkpISbrzxRu68804GDBhAu3bt+OSTT3j88cfp0qULAwcOZODAgbRu3fpAmhGwXVE+/fRT2rZtS+fOncnPP3QPeC4u+8QRZmkWkXLsFanbYS+Id5+q3tkkzXjgZWCNs+sFVW1p4Il9wlWaXVwOIgUFBdkJUoa1HmJvgRWGwHHgGwEiqIZJpz8lY63BYw7ANIdl3TPADjmXtOZgUYdX+uGVXogYWJogyWKSuhafdMNPBSI+28ppLSSdWYBICV7PaMfX2UY1TYKlJFmDhw4EqMCQIKpKijUkdSlCgIAMxpTSnHwZUrqEpC7DlNb4ZSiG2FaelG6wfX4x8NMfr9iv1S2rinTmYyytxWMOxjQG7GKhTutW4iwCMvjph1c62fk0TJyFZLQKn/TERy9ETFSTaGoKmpqFePoh3uMRY6cCY2mMBItI6SZ80h0/fRHxoGRIsJIEa/FQSoB+mNgLu2QyK0lnZgIePJ6jMI1OOXVubMv5GNIKj3kUhlHq1NkOOQcWAfrhlQ45+RQrswgrMxMIYnrHYRgdnDpXE2cRSgI/vfHS2ckTJp3+GCuzBtMzANMc8ZlxkNC5WFqHT/pmx0FVVTVfP+9hrrw0zOAhFRSUjGXWrBpuv30aJxxfQoFxF+VlZfj9JnffPZ0f/GAUS5Zs5+abJwIQtaYSs7ZjaWFW9qSuIaHLiDovJrt06WIrzKm1EH4DNAKh8eDf1ViUttZxzPgGfnJTJS++/DEVfXtx772zqKyso3OXFD37LaNPv+HcfPNWtm0rZ+vWFLNnr+XHN72KxwPHdg+zdNE8iorsMHzxRB2PP/Ms4dh2fnD1xVx99bOUlOwck6WlpVnFuaCggO9///skk0mWLZ7Nglnv8M6bzxMMhhg4ZBSDBg2la5dyzA2T0MrJSHFP6HkOEipjbzz11JPU1W0ho2E2VkYoKCikc+eu9OjRg94VbSlosx0RCz998NFht+Wo6h4nVLq4fK4cmdEz0sAPVXW2iBQAs0TkXVVnMspOpqjqGV+0MK7S7OJyEOnduzc+n4+PPnyMY3r8HDBAfFD/Zyj6GVrwTSLRa1DdjlBIKvU8pjmIYOCPiAhp3ciO9J+AFEKAKG8SMMaTb5xLjfVX0mzBIJ+oTsZDB0qNHxJP/Ydk+m0gD4gTTz1KfuBPmEY5qkoN95FkDQZ5WHxImFaU6Q1E9QMi+gZCACVNWF+hlXEdPrH9Whsy95PQmQh5KFEivEArz80kWE6dPofgQ7Fo4HVa8Q28mkck9iPse2CAZOppfJ4zCfi/A0BcF1KrDwJeBCHMmxRyPn76UqV/RYkiBInoRAIMoYhLydRfBenZICVo/CEwOmEWPYcYhVgapUrvwGJHtk0aw/fVyNPEWYRBCIsYBu/Qhh+QSU0jnvwXEAAsEqmHCfpvxuux/aTjyftIpd/ItiU8TF7wzySlnh086qzcKDTwNsV6PiEZCUA6+RipxH+wF6VJkUrciz/0N9JmIdXcCxgIHhp4lwJOQbWCaORHqG5DpJhU6llMczCB4J+dcbCJHZnbUVIIfqL6FkE5jnzjq+SlLmX0kBD/+GdnVq6ZTSI5n44dy7jovDp+de2TEAvQOhjloX/05Jd/DPLPf85g0KC2/PbPUc4/HRK6hHr9lHqrBDCIMImMTkTwE9EMkEdKN0J0NWw61/Y7xws1f4TSm7GsIjweg3jmA8KZRzj/cj9z5uXzrW++iTCZ736vH6edVUNN9Q4SmYUoL/HQ48fy05u2MmDAv+jZxcsdZ97PuYsuwLvlPa4YuJ6/vpoEirnvP/cy6hiLr327mDrzISCP6uoQ//d/H9CjRwlf+1o/WrVqxY033shdd91FIpHg7NOPZVDmMgb1W4c1oIzKbbBg+zqefXYlNVvW0c+/km75DXQ2H6Jj0a/wXzETKdj5oNSURYsWsW79Ir530xb8vhAZK0H19jDVm8ewfMVC3nr3OQxD6N7PT7d+bzC47zm0Do3dpYxMJsPEiRN54403yM/Pp3PnzowYMYKhQ4ce0P3FxeV/DVXdDGx2vjeIyBKgI9BUaT4ouEqzi8tBxDAMLrzwQu6+6w8M+ZZBfofbwCiEHT+B8JOkg8NR3Y7XczqGOYh06jUymfmobkWkHQlrFpAgZHwVk1Ii1ovErY/wyUjSbMHPEAIyhLjOJsF8krqOZHoiIm0JeC7B0q0k0o+TynyEaVxAhlqSrMFHD4IcTZIVxPiUBCuJ6ccIeRTI+ShRGvQZ4joDn3S3Lbg6E5NyQsappKkkZr1J0ppHVBYAJoV8HchQx5NEdQahtAdI4PN+A0PKSKQeIpl+L6s0x3Q6AEWcDxjU8SQx/RSVDEqEPE7AQwcivEecuRRkRtkKs/doxHc+pKehiefR9HTEdyJJVmCxgyBH46MXMT4iyUpSbCDOIry0J59jSbGJMFOIsxRNvwt4CfivBU0RT/6dVPo9vJ5RtuU9/R4ibfB7L8fSbSRTj5BKTyPqTTiynwsY1PIUEaYTolFpfgPIxxf8IWo1kEr8lXTqHWJmd8CiiHMQAtTxIlFm4MsIhmzD4z0T0xhCKv0ymcw8VLcg0p64NQslQZ6cg0kpYX2JmH5MXqo7fs8ybvvtadzmPwkSr0HyLaToaai9GIx2kP9TSK/jgrNv54KLT0PyfkVat1Nt/Y7qdC+CMo6kLuXo8R8Rs75Jvb6KEqKQc6noGmVz5nmCrIOqKUAayv4MRgFsvwnqH2fLlstp3z6fuPUBYNIqcCX/+meK2+96EJ8MwUOSeGYTQfMiDCkhln6Ko4+dzsKFD9gXycSvQuUqwov6ggyEaVdw5+mfcNFV1+Arm02fbqfgpQNTZrxLSWkDCxduwTQzTJ5cwI9+9A4vv3whI0d25MYbb+Tuu+8mVruYc7ttwNfxWxhFJ9Al/166lL7I6ef+lB33HsdicyzrQmfwycatbNmUoPPf/s6QsacyYMAAWrdunZ1Q2NDQwLRp0/joo48475JaAv7WBM0LsHQ7RtunKe8Qpc9RxZyoRaS2nMjyJZuY9/EMXn/sSdq3m5b1/fZ4PDzxxBPk5eXx85//HMuyWLduHS+//DILFy7k/PPPJxDIWZTIxeVz5DB9sVEmIjNzft+nqvc1TSQiXYGhwKfNlHG0iMzDXkfkR6q66IsQ1FWaXVwOMuXl5Qwf3IqXPxjAJV+bDP6jQOvAMxjDsN0Y0plZBDyjyFjLAT8ixQBOaDlI6UJM4xgsqjHpgEdKQIUUKwnJUSR1FWDgkVIMaYOlm0CUdGYWAIbjLmGQB3hIsYE8/CRZDoCHUkzKSLECJUJSl9rnxz6/4EcoJMMmRDwkMwuccltjUkqK9WTYSsZZ5ttDKYazOmEmMxPDcyKq2zGMrtl2MbPh9lZjUIA9aa40G+YuwRK8Uk5at2JQgBgdUHyQno8ErsRKfWTL5rhT7CxvGQEZQEorAQ8mZRiESLENwUPcqbNJCZa0w2IFam3C0m12nQzbb1tEMKQtlm4AyZBJ72xLD2ESQJJ1GAQBKxs+0JapPZrZhFo1WJm5TrkdMLN1W46P7igxTDoiTj9n0jPxBEZjZZYDAcSZlGg6oQeTuoigMRZLazBph5gdUQxIfYoEv46mpgMmmJ3ALIfMKiADqYlOo3d2xkEh4CXNegzx5fS33f5JVmFJhKQ640NKwOP4n8cmQ2AUW7ameX3aEFasqOHEE7tjymLSupq0bsKiLmd8tHHG8Fz8xnH2GJYcX/YC+00GW6dAsB1YSTxF3Rgxcjg1zCPBUjKxDlxxTpg7/mNw3ok/YuLESUyZMoXBg3tx1llPsmbNDeTn53P99dfz2EP/4NcvX8gJA1cw7tTTCTTMBCMAeT0pLggyJjGJsSd9D/3oWZLbFrNi2APM27yZSZMmEYlEaN++PUVFRSxfvpwhQ4Zw2WWX0abz/WR0I4hFKjPPbiujDSYNiAit2jdwdPu2DJiQjzc1iB2rh7BkyRKeeeYZduzYwVe/+lWOOuqorGtGu3btGDx4MM8++yy33XYbAwcOpFu3bnTt2pWysjLXhcPl8+PwHEpVe5sIKCL5wPPADapa3+TwbKCLqoZF5DTgJaDXFyGoGz3D5QvH7ZfPsmnjWu675y/c8p03QcMQPA2KfwueziRTb5BKvYplrcU0+uPzXYzHMwywfWqj1qvErY+wqMUnA8gzv4ZHOhKzZhPRiaSpxEtn8owTCMgQMtYa4slHSVtzECnFZ56A33sBIgYNDQ348jfRwHukWIuH9uQxlpCMJq1VhK0XSLAAIUhQRpMvZ2cjP6SsVUSsF0npUkzaEDCOJWicgkWYen2JOHMBIchICuVsBC+J1OOk0u+iugOPOQK/7xuYhu2vammcBn2ZGNMBJcBQCuQc27WCSUT1EzJU4aMX+XIqPumKlfwQK3YvpOeA2QcjcClG4NxsO0f1E6I6hTSb8dKNfDkJv/QlwTrqeY8kq+1weYwin7Go1hJP3Ec6MwUw8HpOJOD7NiJ29IWMtZZE8mHSmVmOf/iJ+L0XoySp4xVi2PejIEMo5CxMsf2rLWszqfg/yaSnACE8vlPx+r8HCPW8TpSZKAkC9KeQM4mFvQT8H5JKvYRlrcUwB+DzXYrHMzw7DiLWa8T1Iyzq8EkF+YY9DjT+Ohq7D9ILwDMICV2N+E9DU4sh8kdITrYtzoELIO/GrE95QpcQsd4ixWo8dCAoxxIyxpLWahr0ZRIsRAgQZBQFcgZCBqp+DfVPgkboceL3wCzhxhuP4ZprRmFpPeHMkySt6YDgN44hz7wAwU8s/RyJzAcotXiNwQQ9F+Np9B1PhWHGDbDiQUCh64Uw6k400JoIHxDhU557opbnHy3irTcvwif2+AmHwzz88MM89FCaG2+cwMUXD8yOgw3z/sHb705h2cY8RveN0LbbiZSWj6Mss57SxX+CyknQqhcy6Dsw/KaskhqNRtm0aRPV1dVUVFRQUFBAQ0MDwbwdxNJPkrLmIbTCbx5H0HMeKknqeIMos5xxMIgizsj6y9t9t2c/5jVr1rBy5UrWrl3LmjVrSKfTdOnSha5du9K/f3+6du3aspvMlxD3v2Yv0TO6is789cGWaO/IN/ccPUNEvMBrwNuq+te9lieyFhihqlWfn5RO2a7S7PJF4/bLZ1m7di1PPfUUP/vZzw6pHG7fHJ64/bJn/u//PiCRyHDrrbsuN7548WKuueZFJkwYx69+dexn8m3dupVZs2ZRXV1NTU0Nq1at4le/+hVt2rQ8ssnB7pva2lrWrl3L2rVrmTFjBh07duSss86iU6fd+11/WXGvmxYozb852BLtHblq90qz2E+YDwM1qnrDbtK0A7aqqorIKOA5bMvz567guu4ZLi6HgGg0utelkV1cXJqnR48SHnlk3mf29+nTh7VrkxQUpJvN17ZtW0477TRSqRQrVqxg8+bNpNPNpz1cKC4uZsiQIQwZMoTTTz+dKVOmcPfdd9O7d2/OP//8L72S6LIPHJnRM8YClwELRGSus+8XYIcZUtV7gPOA74lIGogBF34RCjO4SrOLyyEhGp6P37uCVM0IDP95GIFLEdO2HKkqcWYR0xmk2UyQo8iT4zAkjwTriPApMeYRYgT5HL1LrOQYi4kyiwSryWMk+YzFpIgUWwjzMVFmEWIIeYzCR2cyxKjjY6LMwEt7Qgwj5Kx+B5CmmjAfEWEGQSoIMYIAPbFIEGYaUWZhkE8ewwhhR5iIMpsos0mzzZFhnOPnC0qGMB8RZTYAIYaRzxgEkxiLiDKTBGscd4ljMCnEyqwklXyBTOpNTO/JeHznYJr9sjJm0rNIJV8nk56Gx3s6Xv+5GEZH0rrdkfFTggwgxGj80jObL8l6InxKlDk5bdmejNYR0Q+I8gk+ehKSUQRkAKpponxIVGcgCEEZRYhxiNgr8VkaJcyHRPkUD+0JMZyQDLddaviUKLOwiBBiBHmMwxAfcV1BlOnEWUweo8ljLB4nrJ+qkk6/Tzr1Dpa1Bo/3NHy+cxEpzBkHcwkx8rPjQBcRYyYJVhFiFPmMw5QiUrqZCNOIMpMgQ8njKHzSBUsbiKffIJGZhGl0xm8eh9/MifiQWgP190L9o5B3GhRcCsHjUI0Ts94hnpmKIYX4jbEEjONAhChzmoyDsRg4D4qagup/Q90TgELRJVD6PRAvxN6A6FOQ/BhCl0L+d8Bsh6YWo7FHIP4s55z4NX70o1JefnkpZ5/dF4A4K3nutUnU1kPSmkyawbZfeXwlbLmbmjVPs7DmVBZt6s6KNTV07NiR8ePH08ZYCx//AtY8Cj2+Cb2vgVaDsKwqkqmXSKbfxmMOxOs5Ca/naLBSsObPsOG/9pL0Hb8BXa4Dw+u0VQ1s/CtseQBC/aHtldD2UhSLCNOJMhuLqDP2j8HAR5yVRJlJjCVOW43J+vIDRHUWUWaR9mxmxPGjOeroH/P6axO58847uf766z+jOK9du5b33nuPUaNGMWjQoJbckly+LBxhSrOqTmUvUqvq3cDdB0OevbpniMiDwBnANlUd4OwbAtyDHZcpDXxf1Zn6/tn8JjAT2NgYQ09EOgCPAQ3AJY7z9i3AT4CuqvYMHBEJq+puo8a77hlHBm6/7Eo6sZjHH70Zj8fLhV8fhxW/F4xyPEWvISLEdA51+ige2uGlGzE+xk9/Coxz2codCAb5HEcD72MQoC0/xcBHgjVU8R9MiggyiDBT8NKRMr7JFv6MkqCACYT5AIC23MTGhpcwC5aRx2gSrCbNdkq4iCADUCy2cgcZailgAhE+wSJOG64hzFSizCbIYDLsIMl6ijgTgwA7eBoP7fDRmSjTCVBBKZcBUMc7hPkAP70BewJcAePx092RvZggAx3Zy2mtlxNruACI4/VfSSrxCGASzH8cMUqxMquJRa4GycfrPYdU8hE7Ukj+o2zndjLUks+JRJiGkqA1N+KVtmSoYyt3AFDA8dTzHoKfdvyUGutfzsTI44kxB4taSuT7JHUJESbipwIlQ5Jl5HEyBcZXAKjW/5JgCSGOIska0mylFZeQoYF6XsNHFwyKiDOfEKPI4yi2czcGQUKMJsxETEpow48IhyMEArNIxH+PYXTBMAeQTr2OaY7GG/rhnseBrqaa+5xxMIQwH+ClE6V8i638wRkHJxHGngzYhp8QTd1LypqH3zyRlLUYSzeR770enzkK1IINI+0l0It/DPUPgFUHHSfSYHxKwpqK3xhNRqtI6yryzItRs4wdPIOHtvgoJ8pMAvSjlEvti2Db76DqDsg/yf4dfhfKfgRFx0P1+WB2hMBZEPk3eIehpU+h1ceARpG869HIP5kxt5SvXnk2gwa1Z8jwQj6ZNYul8w0ee34g778xkYIiL0XBHgRiE9lc46c+WUpF+3X077SWihMfIa90KEQ3wSvOfKEBv4D5t4C3AM5ZRzj9ayxrBT7vuaTSH6K6nVDgD8QWvUDBplug9emgaah6G3rcDL2ctRQWnQ01r0O7q6F+GkQXQd8nCbfuSB2v46MLJkXEmO88rB3FNv6FQYA8RtPAJExKaMuNCAYxnccOHnfashtRPsFPP0q4kldeeYUFCxZwww03ZBdYiUQi/OEPf2D06NFMnDiR22677UvzVsv9r9mLe0Y30Zm/PdgS7R254shZEbAl694+BHylyb7bgd+q6hDg187v3XE90HSpqeuAa4H/QONdFIAq4IctkMnF5YiktraWO//xKHX1Pk4/7Sgwe4NnGFiVoNUApHQtACHG4aMvBoUkWUOKzUCaIMPw0oYA/bCIksae65BkPQB5HIWXcjy0IcUmUmxBiRGgP15aE2QISooUm0mxBYNCfPQkjzG7lGPRQIZafHTDSzsnfJpFkkqSVCL4CDCAEEc5+dZl8+YzhgC9Mcgnybps/ZNUAkKIEYQYAQgJ1ufIPgYvnfHQmhQbsDJrgTCm5zjEKMf0ngzEsKzVAGQyywALj/dMDLM7hjkY1a1kdJ0je0+8tCeP0YBFikq7jdmCkiLIUDy0JkB/lBgp3UyKDc4DS2fyGOukX0uStdgTG0cT5Ghn/5qcuq3DoAA/vbP5ctskxBiCDEbwOvs3ABYhRuOhPT66kqEGi4jd/hn7tun1ftVZ2KSETGZxi8dBiDF4KMdDO1JsIJ0dBwPw0IYgw5xxsIm0tQKhFR4ZQMC0b/dpy46UQWarrTAHxoKvAgouBzKQmEPaWgX48clIAobtX5zWVU3GQR8M8rL7AIjakwMpvsLeEIh+Ckl7Ah2hb4J3OHh6Q2oOpJeB1oP/K2B2h8A5jByykZWLh3P55YPxBaOcd7nFvNVHMfboPlz9k/4cf7aXY47uxqBOy7jkpDh//NkJXPn1wYzstpI8y4lGtWMeZKLQ7TIo7AvlX4XkDrR+EZa1AkO6YEgffJ7TnfG2FBrmAgZ0+hZ0utq5sD/aWbf6T8DbDlqdDB2udfZ9lDPGRxNgoDMO1mfHQR6jnIfNxnEQzo4hO98x+OmNQQFJ1iEinHXWWQwYMIA777yTcDjMmjVruOeeexgyZAhdu3bF7/djWRaZTIYpU6ZQVfW5z4tycflSsVf3DFX90ImNt8tuoND5XoQdF+8ziEgn4HTgNuCmnEMm9nKIFrua3R8ErhSRP6lqTUsq4OJypLBkyRIefvhhjh03kBNGv4dhrEZTx9uxhs2+4LyW90sfojqFMO/ioS0W9QQYho9OCEGiTAeSxFmESTFeJ4SXnx6AQQMf4qc7abbhpzs+OmBSRJwFGHiJMhchiJdO+OmCxXyizCDFFqcc2/JmUIiHtiRZQ4xC4ixG8OKnGym2EuEjIkzL/rkH6I0QIMLHNDARD62xCBNk54INAXqRZDVhJjt7lAC98NMVMAjzAT66kmY7fnpimD0QaU0m/T6Il0zqXZAiDMO2VJvmQMBPOvk86hmLlZmHGN0wpSse2pBkJSaFxFmA4MVHNwC8dHTaciaQIc4CTIrwSUd82pMkK4kzhwQrAQMfvUGUlK4mzHvYty7wS9+cuvUmxlyifEqarU5b9sYiTJz5hHkfgxBKCj+98dMN8BBhKgEqSDrRSwzysR8UhpNKvUgy+TiG0QXVGjye4/E2Ow6K8NI6Ow4anLa0x8EWfHTHS8espVvwEWM2Qggv5aSNQSStT0hak0hbtnLnMZzX+mY78FZAfBqY7SH6BkgQAkfhFZOM9S4x6x0ao0B5ZQAeSojwCQ1MwkMZFhGCOW4/5J8A0SlQ9efsOCD/BPCPg4Y/Q+Qf4DsK0svBd6x9fqMdJF5DxQ/xl0BaESwcysUXtyJNB7axlAwfE6MCX8EGuhd0oo1+BfHebK+8WdcKdrwERggK7AdESkeArwRWPQBWAtY/C6FOSNFgzNQgMtZ80pnJZDILAAOPOZhk8TpoeAlW3QZk7HLKcuxKrU6G7U/Clvsg6tiLWp2En7bEWEADk7LjIEAvZ0x6CPMRAfqRZC1e2jlhF+0xFGEqYd7HQxssGrJtKSKcffbZAPzmN78hFAoxYcIEhg0bxq233so3vvENZs+ezQcf2G+Xpk6dyo9//GM8Htcz80vLEeaecbjRougZjtL8Wo57Rj/gbezmN4AxqrqumXzPAX8ACrCDTTe6Z3QBHgXqgIudVV5uAcLYS2aZqvob1z3jf4Mve79YlsUbb7zBtGnTuPLKK+nTpw+aXoKVeBUr/TGG7wwM/1cRY6cPY0KXE9MZZKgmKMMJMhIRHym2E2U2cRYRZDAhhuOhOJsvyXqizCFJJUGGkMdwDIKkqSXKLGLMJ0B/QgzDSxl1DTWYBcuIMg8PZeQx1FG+bTKEiTKLKHPx04s8huKlPUqaKHOJMs9xLxhKENvPOM4Koswmw46sDPZKeaBYxFhAlLkAhBhCkIEIBgnWEWU2KTY4+UZiEMCytpBOvkkmPRHTcxwe71cwzJ2RAzKZVaRTb9sxjb0n4vWeihityGgDUWYQYw5+ehNiBF5pn823a1sOIsQIPBRjaYwo04npLHx0Jigj8UkXVC3izCGmsxAMAjKMAEOz4cMsTRJjJlHm4KGUEMPxSy/HR30xMWZjEXfqPAwRk5RucnzQVxJkKCFGYEp+9ppJp2eTTr2HZW3C452A13syIoHdyp4dB7qeKLNIst7xUx+BIUHSuoMYM4kx13lLMAKPtEY1TiLzIYnMNExpj98ch9fsv3MQZ7ZDw+MQfh6C4yH/AvDbft4J62MS1icIefjNMfiNIc44WJkzDgYTYhgGzjLgakH981D3jP276OtQeK7tI5ycAdFnbQtz8FwIXQxGIZrZgMaeg8Sr4D8VCZyLeLrl9OdmIswhwQpCDCHEcEzyIbUVtj8C1U9C0UlQdimEdoajo345rH4YKp+HLhdBj29AXmdUwyTT75JKT8Y0euP1TMBj9qOhvo6C8Guw6XFb3vaXQPsLd64akYnC1odh2+MQ7AFtLoNWJ6IocZYQZS5KzGmToQgmSTYRdR7SdpE9ez9YYfs0U+1cayMwcpZUV1U2bNhAhw4dME2T1157jXfeeQePx0NFRQVjxoyhX79+3HvvvbRu3Zpzz90ZlvF/iS/7fw3sxT2ju+jM3x1sifaOXHbkuGfsr9J8F/CBqj4vIl8HrlbVE5vkOQM4TVW/LyLjyVGad3OOW7CV5v8Ac4FBwCZXaT7y+TL3S2VlJU899RQej4errrqKoqKiQy3SLnyZ++Zwxu2Xw5cjoW82bNhAOByma9euu6wuGA6H+f3vf8+ll15KRUXFIZTwi+FI6JsvGldp/mLZ33c0V2D7KgM8i63oNmUscJazOksAKBSRx1T10mbSZlHVWhF5Avj+3oRQVRoaGrK/I5FIC8V3OZh8GfslHA7zwQcfsHTpUo4//niGDBmCYRi7jNfDgSOpb+wHfM0uxvG/zOfRL6rWl6KtDjZHwjVTVFREUVERqVSKVDJhW8QdLrzwQp599lmuvvrq7OTB/xWOhL455LjuGQfE/irNm4DjgMnABGBF0wSq+nPg5wA5luY9Ksw5/BWYsTf5ROQzT5Vf9qfMw5X/5X6xQ41NJWJNZ/2yPOZMS7Ni6RZGjRrFj67tSp78DdI7IHA+hL6JSJA4q4gykzhLnRn0Y/DQKltmIvMRicxU0rqRgHksAfMrGJJHStcQs6YQ1xkEZQxBYzyeHJeDuC4kZn1KkhWE5GhCMt4JNbaFCB8TZSYhhhJiND4px9IYkvcBMf0IDx0JylEEjOHZ8tJaRVQ/JKaf4JeBBOUo/NILiyQRphFhNib5WRcAgBjzHDeL7eQx3Ak1tjPkXIRPiDgh5/IYRh5HOSHnGsPlrckJl1eIquWsmjcdJYWH1hRyOgHHnzihq7Jh2+yoFGPwSKkTLu9jJ3JDBXmMwE/3bN2SVBJhBlHmksdwZwJlWzLUZ8Ps+elOiOEE6YtqhghTnVX/hBAjCTFmZ8g5YvY4YAZe2toh5xiCqkUyM9FZAa8Bn3kcAfM0RPzNjIOjs6HGCgoKHBeYWaTYukvYNtv94hNizCbEKEKMwSt2yLmITiGi72NRj0EReXICeXIMACndTFSnEWUGQYYRkqPxSWcsnDHMTGfS53BCDG5mHHzsjIOjHdeTBBGdRNz6BINCAsYogjLW/l+OPAfhpyC1AvIvgcLvgFlsF6gpqL4Xdjxh/251MZR+B8SLrn4FFj8IGz+EAd+GITcgee3R6gWw6J+w/CHodSlUfBdpnWOc2jIJVv0HKl+Cnt+GPtdBQXe0dhXMuwsW/gd6nAMDvo10Gp/NpqkFWPGn0MQrSOBcjMDFiKc3xDfBmr/D+vuhdDyUXwVtz0QzafKX3Y8uegjEQPpfCUOvQQz770pjO9Dpf0Pn/gdaD0AGXYkx4GJULYg/hcafB61B/OdB6Cp7tcnEFIg+CYl3IHSJPRGycZlyIJmeQjIziYxVic9zAn7P6RhSQFLXE+ETYsxxxv7R2XFA9b1Q9TdIbwZPByi7CUq/zaBBg1i5ZgEPP3YXJ1+kdOs00glBWc7KVYuYNPk5xk7YRqeOXfCb4/CbRzd739sbmUyGyZMnU1lZSZ8+fRg9ejSG8cU/xP0v/9d8LrhK8wGxV6VZRJ4ExgNlIrIB+A3wbeBOsdfTjQNXO2k7AP9R1dMORChVrRKRF4EbD6QcF5eDQWX9E0z/eBFzpwn+UDVDxwoXXHIxxSyA8C12dAxPBUT+DJlNpAqvpZqHnBBTRxPmA+Isc0JMCYnMdMLpezClIz5jELHMy6R1PXmeK9mR+Rsg5BmnELHeIJ6ZTZl5GyI+krqSWut+DIoJymgiOpGkrqSVcQ3V3IdFnAIm0MBkYsyjjf6YsPUyHp1PUMaS1BXU6UOgJgGxlb0d1r/JUE2enERUpxHXOZQaPyYsdsznIANJU0stL6FkMAixg2fx0IYAvWhgEim2UsolADQwkQYmZycb1vEGFlH8dKeGRzEpIsQwwnxIgjW04fvEWUSEafjoRgGnUMOD7OAp2unNpNlONQ8gBMjjGMJMIs4SWutNVMmDTri88YT5hBgLaMO1eGlDhnqqeACAAo5z2mQhbfkR1TxGio3kM5YoC4izmDK+RYKlTsi5vigZ6nkFixgFnAzADp4lzhJCjCTJOnbwNIKJZDYSSz+EKb0wpQvx9NNYWoXPe2Yz42ApbZ050zEWOOH72hCgLw1MJMVmivUsqrkHAfKZQJj3iTOfNvoLMtTRoC9iUkIJP6SWB2nQF/DTF4MCqvVfKHHy5STCOpG4zqU1P2OHvEiCZYQYRZI17OApBNMOPagWO6x/OePgZKI6NTsOYtZkYvoRfhmGpTU0WE+BkSEUrYGqH4C3LwQnQN0dkFoMbR62L5qtf4Ttf7Yn/wFs/gWkd6CpY+C1syG/HPpdAbNuh40foue8Da8eB6kGGHYzzPkDrHoavXAFEmoHtQth4sngLYS+N8Ki22DjK+gZy+CFE6BhHYz6Fcy7G1Y8g148DymtQK1tZOquACyM0Hewov8mk3gTs9X7yKyvQu106HYTbH4atr4ER32ALpiMzvoNdDsVrDQ6+UaI70DG2rG8rFevhBWvIEO+hW6Yhr58CWp6oWsUDf/WuR/0R6N3gLUJCVwCNReDFELetyF8J8TfhdbTQIRk5mOiqTsxpBNecxiJ9HNkrLUEfd+jmnudMTyBhuw4+DlGshK2/AS8XaD7FKi8BLb8CApOwPJ1ZPQZq2BykqfutujccwpjTpnFmhmDmD59GkNHRfnvv/I45cwtDBn1L8CD3xy5T/fE6upq7rvvPkKhEEOHDuXVV1+lTZs29OjRY++ZXb5YXKX5gNjrY5+qXqSq7VXVq6qdVPUBVZ2qqsNVdbCqjlbVWU7aTc0pzKo6eU/+zE6aW1T1Lzm/b1JVt3tdDktUleXLl/PAAw9w5+/mUFtlcsU3z+SHP7uQ4eN8GMHNkJphJw5+A/xfBQKQmuGEXbMc605HfHQhQ3U2CkVa7VBffuNkvDIEoYi0tZy0VgIpgnIUJh3wyWCUcDZSQ1Lt8GchORYv3fHQnhTrSbEFiygB+uOhLaFsqLHNpKjEoBgf/QjJeABSaodzs6gnQzVeeuCVToRkDGCR0nV2yCt8BBhEnhN+zQ6jthaAfMYSoK8TamznHOEE69hppR1JcyHnfHTNhpxTMtkQbB7ak6EWkyKUBEraCSFnkcdovHTERzcy1JBmkxNyrrsTcm4Udri8DXYd2eyEnBuCl7YEqMAiSootpNiIhzZ46UJ+tm7rnfByQpBROWH21uTUbS0GBQTokw05l2AtaWup3Z/mqfiMcYCPtLVsN+NgZ6ixhNOWeYx1wrYVkGAtKTbZ44AReGiHnwosIqTZnm0rk7Zk2I7HiaxiH9+GEiXAQDy0I8QIlCQpNjnh8gqdcHmNoQfXNRkHPZ1xMNYZB+tJ6ipnHIwkaOSMn8SndqMUfgeCp4BRBvEZOy+g6CeAQMlV9obY+7Y4odsGXwsdxkFJBWz5FKrnQ2IHdDsPWlVAr8sgFYZqZ1XA6ul2zORe34WSYdBmPITXQPUcW2HuNAFaD4UB3wErDVttWTS9FIgi/rPA7IX4TgKtg9QyW2HOHwCtjoGu19nn2fERbJ1tuzsMvBoGf9fev2nazrptmAp57aDH6cjIG+zzVE5FU878m+AV4D8LCEJqpj3hkQzkXQ6egeAdDZm1YG0DIJ1xxo/ndDzGcIRiMtZSUmx0xvBwPLRzxnCEDNshY4evxN8HkqvAb0ebIV1Dmu1gxjjuhGH84pbL6VTemcfvqqOqehPX/DjJyafncc11ZzJtso/nnwgQiTeNGLtnNm7cyB133MGoUaO47rrrOPbYY2nbti2JRGKfynFxORxx4864uLSQVCrFqlWrWLx4MQsWLEBEGDduHF+50IuEFuNnHeHcsG2+MCReh+hdYJQAcfAd2yTEVAVJ1uGhnRNqzA7ZFecd4plXMY2OKHX4jKPwSleEIDGdhpImqXMxaIXHWQnOJ71BDSL6Pn7pTZrN2TjFhhN2zcBPlNlOyLmOeOmOxSxi+glpR6H0OW4PBkVOjN9VxLWEhM4DvPikB36qiPAxET7KKnl+emEQJMKnNDDZCTm3a6gxO+TcmuwCK3bIuZ5O+DUhnA2Xtx0/PRBMAgwgzAdE+YgotlIV4mgM8ePTxrBt0wgwgCRr8NAWDx3x0Jokq4lTRIyFTri8LnYbZ0POzQIs4ix04lV3wEc3kqwhzgISrAIMx60jRZI1RJiEHXUT/PTZpW4x5hNhRvZBJkAvxMgjZX1CPPOCE0YsidcYhJeuzYyDttmQcwF6EeEjwkxyQg82EGQQXsoRAo67SoYEC52+agMYeOlOkiUknfD4PnrgpROQcULOzUM0QIwZzjgod2RfQIyZThxo8NOzyThY6YyDuc446E5a+hHTyUSZiGXVO+OnHwTbQ8ODUPc38PYCqwryciI25E+AyBTY3mgncULOBceA/Nq2MHc6HmoWQ/kJUDYUQu1h1dPgzYdl/wV/CZQ5rkStx4EZgGV3QufzYNtkKOpvHy/pBxsmQkE5rHgWPEHoYD/UiGcASBGaeAGw0ORbYLSx41GXjIeaybD5Kah6H8SEsglIRxM2vAzT/wBqh5yTLidnqybdTkYXP4XOvR+2L8zuwxtGE69D9J9gtAJi4BsHvtGAHyL/gcBpkPoUPP1sOQCvOZhk5nXi6RcwpRylFq851hkHQaLMwA6bmDMOgm0gNBbC79gbQGgcBAfjQZ37wUJCgQAjT6lm1CltaMvVRFP/JWlNp1W7+Xz3hhivvgB3/WUpV397Ex06dGBPqCpTp07l1Vdf5etf/zojRux0ndmyZQtt27bdY36Xg4RrijwgWhQ943DFjZ5xZHAk90t1dTXz5s1jyZIlrFq1ivbt29OvXz/69+9P165dEREsTWZDm3koJchwAtLbnriWeBPiL9gLMwS+CoHzEPGSZKMTYqoxPNbIXUJMJa35JDJTyeg2/OYYAsZxiPhJ62bi1ickdA5+GUnQGIPpxHcGSOpqYjqdlK4lKCMJytEYEiKtNc4yvXMJMpAgw/FKG+rqq/HmLyCm0/FIWwIyepfYwxmtJ6afENMZ+KUfQRmJV8qdkHOzdwk5F6ACQYiznChzSFOTDZ/VGGrMDjk3zwk5J4QY7Cz4YZBgLVFmk6SSEEOdkHOOL7SmSbAaiyhe2u302wSSupEYs4iz3PHXHoUpBWSoJ8IsYsx1Qs4NxcfOP/7GsG0xFhLKhu9rhUWUCLOIMgcf5YQYhh875FyM2U58Y4MAQwkyNDvZziJJdJeQc8MIYI+DlDWDZOYDVKP4zGPwmcch4tntOGi8Zuy2nO2EGrOPG/hI6VZizCTOAoIMJcgoPNLKaSuLFOvIUI1JKV66ZGVMaw0xnU6M2QQYREhG4pG2WCRyZG/tyN6ryTj4mJjOxC99Ccooexxomph+QtyagSF5zvgZZIfhi06EyNOQWgf550H+xXaMZLBDztU+bW8AxRfYmxjopqmw5GHbwtz3Muj/LSTQCq1fA8sehJVPQvfzoc+VSPHOhxZq5sDqh2DTW/ZiJT2/BcF2aGQzLHoAljwKXU+FiiuR1kOy2TS9GivxIpp4C/GfiRH4mr2kfWoHrP8PbHwEio+GTldAyVjq6+soqHwZXfKY7dPc71Lod3G2jTUZQec9iC54FCnpiQy6Eul+sn0/SL6Nxl8ErUP850Dga4j4IDUfos9A4gMInmeH2TNb7xyrmbkkM5OxrC34POPwmSfYoQd1KzFmEWMBQYYQyhkHqAWx6ZBcC75uEByZnRCYZofT33OdJeaH46UNqnHimQ9IWNMwpR1+cxyzp0d44YUXGDp0KG3atKF169aUlZVRVlaGz2df17W1tTz22GOEw2GuuOIK2rffOc+irq6OW2+9ldtvvz0bnvGL4kj+r/m82GP0jB6iM39/sCXaO3LhoYmeISJ5QFzVefptSR5XaXb5ojlS+8WyLH75y19SUVFB//796du37//ccrRHat/8r+P2y+HLl7Fvtm7dysKFC6mqqspu1dXV5OXlUVZWxrZt2xg3bhynnnoqpmnuknfBggVMmjSJ66677guX88vYN03Zq9L8h4Mt0d6RCw6O0iz2k+2FwCXASCAB+IHtwBvAfar6mcAWubjuGS4uu2Hz5s14PB4uu+yyQy2Ki4uLyyGjbdu2n3GvsCyL2tpaqqqqyM/P3637RmVlJZ07d272mIvLQWYS8B52ZLeFqmoBiEgJcDzwRxF5UVUf210BrtLs4rIbSktLicfjbNu2jeLWDYQzT5OmEjAIyBgKjAtRIoTT95Oy7AlJXqkgz/stTCkDIGOtJ5q6l4xlT+7zmmMIeb8LCA2Zh0ha9oQkj/Qg37wcUzoS5j2iTMMigkkZBZxCUIYAoKSp5ZWsL66XDhRxJn66Esu8TyzzBhY1GJQSNE8naB5PUldTx8uk2QQYhBhFIedkQ6UlMp8QzbyIxVaEQgLmSQSNM0iziXrrGVLOhLSADKNQLsQQPwBxllPHm6TZhuAnj5EUcgoZ6tjBcySxJxQG6Esx52GonzpedJauVrx0pIhz8IntZ5whQi3PE2cZAD6604qvYWoRYX2ZmH6EEsekPQXGOfilgihzqed9MtRgkE8+YyjgOKetlDAfEOYjpy1LKeQEQgwmzjLqeCtH9lEUcjIZatnBC9kJfrbs52Jiv2FIsI46XnX8fg1CDKOYM7GIs4PnSeBM4qQ7xZybXaUvxRZqeTE74THIIIr5GgC1vEiMBU6dO1PMOShB6plEhI9zZD+REPbS1qpp6njJaUt7HBRyDn7pStT6kIj1LhY7MGhFnnEyIWMcCdY0kX0ExZyFYI+DqM6lgXfJUI1BPnmMIZ/jsXQt8cS/yTgTGj3msQT916BAg/UYCbXDB3rpToF5STYEomVtIRH/M1ZmLgCmeRT+wE9AQmQit6GJFwELzH6Yeb/A8DpjPFYF738D1r5mX4gdj4cTHkQKOsPyn8CG+yDTAHn9ofefofWpUPsMbP89JNeApw2UfA9a21FIUIXVf4B1d0JyG4R6Qs/fQYeLoOYNWP1TiC4GswDafwe6/QHSlVB9g710ONiTGcvuBNNZtbP+I1h5PUTmACa0+wb0uAtLEjSkHySl8537QV/yPVdlXajSuon6zOOknWvDL8MpMC5FgIbMwyR05/2gwLwckw7E0y+QSL+FUo8h7Qh6LsDnGbNzHOiLxJgOWHjoSJF8FZ90I6K2P7xFLSbF5DGBPDmaBGup47WccTCcYs7MjoOYNZuwvk6GKgzyCclx5MlJZHQDkczDpHWlPVaN0bRqdRUlRV7YdC0setFpq9HQ4U4I2CuErl+/npEj9y36hssXyJfbp/lEVU013amqNcDzwPMi4t1TAW7kexeX3RAIBDjmmGN4//33qc88RJqNFBnX4pMBxHUqcf2IaPp5UtY8guY5hMyLSelioukns2VEU/eRsZYT8t6AzzyBVOYj4ulXiWbeImnNwG8cS4F5NWldRTjzKCnWEOYdDAop5TosotTyJJbG7fKYRZQZBOhLKd8gxRZ28CwZ3UIk8xhgUOz5DQCRzCOkdRu1PEWarZTwbfz0ceL72m5NlsYIZ+5DiVLk+Q2GFBLLPE9aV1FvPU2KdRTJlQRlNHGdTVQnA3a85RqeJkMtZXwbL+0JM5U4S6jjNZKspogzyWc8cZbSwLtEme7I3p8SriLFZnbwdLatGniPOMvI5ziKOIMkq6njDRLMJ6oT8dCJVsYNZKimznqIjIbZwXMoCVrzfQxC1POOE5XCjnhRz7sY5NOa76HE2MFzZAjnyH41XtoRZgpxllLH6yRZQxFnkc84R/b3szLu4DknhN6VBOjt+IXOop73SLCcAo6niNNIsJo63szmq+UlkqynFRcQYiQx5hNmCmGmEmMBIUbQiq+TZD21vEyKTTTwHiYFObI/i0XjOJhBlOkE6EcJ33SU8qdI63YarGcAgxLzp3a7Wk+T0u3s4BlSbKOUqxzZpzsPX/Y4qOUZlDhlXINBHg28Q4r1xBP/ImMtJej/CV7PiaQzH5JMvUTUepeEziYo4yg0riTFahoyO8d+MvFvrMxcfP5r8fouJpP5hGTyIazEc2jiecR3PGbBvyCzgkz4VzsvvE9/bSvMw38B4+6CjZNg6o2w7SVYdwcUDoWRUyC2BhZcBOkq2PgdW5HuPgnMUtj2W4g6rnu1n8CKX4KvDRw9A1K1sOAySFbBkksgvg4Gfwh5g2DDX6D6Vai52VaYS/4EhddC7G2o/fNOGZddCdEFMOB1KD0dtvwHtv6XaOZFUjqfoHEmeeaFpHQpkXTOGM88QZrVFBpXEZBjSOgsota7RK23SegMAnIsBea3SesqGjKPkLGWEU8/gyHFFPhvQzVCJHU3qtHsOIjxCX76USLfJs1mavVJ0lpFPS8iCGXcAEA9L5DWamcMb6OUbzjjYAZRJ266pVHq9FEsYpQaP8SggLC+Toq1RDIPkdaV5Jvfx2+MI2l9Ssx6C6ruhPoXodU3oOP9EPsUNt+UrbNraT7MkMNwO0g0KswiMlBEzne2Ac2l2R2u0uzisgfGjx/PzJkzCTc0YFCEpQ146ATYobgs7IgBQgkiIcDE0vpsftU6IISSxpBO2X2KvTKgSQeUNEIQSxvIOJEovHQkTTUeygALJQaQc7wdGcKYFNhhptQpTzqS1m2YYr8qtbQeiwgGBWRowONMhGssxy7XwpS2dj7Knf11WIQRgkAa04nQYTlyK2mUBCZFZKjDi2NdJOyEPTMR/JiOpTVDJEf29o5M+dnIG41p7DYpRvDZbUkYS+00HjqS0R2YlKDEydAAKB7KSFOD15Gx8TyN4de8tCfNDkxKAYsMDShJTIrJUJsje8SRwYPgxXQWm2ksR1HH6ltAhnA2X4ZIth4mhQgBwGhStzBCAMXCmw0DF86m8dIGxUIIkCGM5fS3h/akqcnK3qg0N+bz0A6LMIYzDhrHnof2pK3teBwZlTAW0c/I3lg3q3EcUOq0Zfus3JbWAXmoJjGMzs64qs2OBVPa2qsPEsjuA1CtxX6ZGUSkrbNvB1g1AIjZB7V2gJSA1mTzEbNDrVHQBXwFYHghus22EgMUDIV4JQS7QLoBkpsBC/w97Ulvgf5Oo2+3P7P5hkB0NeT1tqNeJDbainagCyTWQ/5QO11qK1jbAZ89cdHTZdfyVCG1HbztbMU7b1D2PI3tb0grBOd+wM77gUUDQhDVDB5nMqvSkNOW7UEtJ00DFnX2fqMrGWsbhrQDMlja2G+N46cDGW0cB2Hn2sCJelKVjbCToaHJGG63SzmN48BDG9JajYeOWbktrUcIoaQwG/dr/c528fex29UohLS9r6GhgXg8TllZGS4u+4OIlIvIJBFZIiKLROT6ZtKIiNwlIitFZL6IDNtNWUUiMhl4CbgY27f5Zaf8wpbI47pnuLjsgaKiIoYPH860dyo56dy1NOhDAAj5BGQUGbMLKWsu0cyDTg4hYO4MP+X3nEEs9R9iqbsb9+DznACYxK2PiVpPZdOGzK/hpzce2hJjZtYaHGAApjMjPsQQInxMAxOz+QqYgFe64ZFepHQeqYztKuKRPnilKyGOIcJE6rDPZZBPkKHO91YYMpSUziGdsV+7mtIJr/QnRIQGfZ46x71L8BOUo5x8tjtGhOns4Bk7H8UE6I8QJMlT1PKcI6FJPkdhUkiUj2jg3RzZT8p+z2e0Y+19OduWeYzBL12I6DvE+ICY2qHqgnIMXmlHgD7EWZaNKeylHX56OC3dw2nLucSY67Rlv+yKd1Fm5sjeigD9EHzs4FlqeT4rux3jGQQhnzE0MClbN4MQIQaTpjNxllObI3tjjGe7bmOp4xVqedY56nPiVEOUudTxRk7ak8hQjkUbYswhxhxH9v5Zd48gw5xwdO/n5DsBr3TBSw+SLCSpC5026YGXzuQxhjCTqXXqbJBH0Fn1z65/BXEWU4u9Sp+Htvjpiek9i3jyPuLJvztnCuLznIzHMIlnphO2nsvKEDLOyX73er9KInMrycTtzh4PXu/ZGFKKFX8KK/avbFoj+P3sdwb+ANa8CpO/k21LBl9nx15e80dYf+fOtJ2+A8EBkP8VCL/lxH8G/APsEGsApSdA/kDY/Ji9AbQ5G/IHQbtv2lbipc5itf6uUHoOJMsg8T2outY5kQ8KvuGII9Dxelh/Kyy/wqlaGbS5mICZIJmeTyTzSFb2oHliVtygMYGw9RQN+jCofU0FjGMAJW59TMR6OiftV/EaAzGkE8nMhyQzH9rtaozEcNy/ggwjylTCOddUPifhozNeupFgCYls6MFu+Ch3xvDk7FjcdRyU4GcgCRZQ58R999AeH71R8xSimceIZO53zhQgYBwLrfrb7jFbfrazX0pvAWwrc3l5+RceNeNwYvny5Wzfvp3GIAuNn2VlZZSXlx/6pcuPvK5IAz9U1dkiUgDMEpF3VXVxTppTgV7ONhr4t/PZlP8DZgITcvyZDeCPwG3Atc3k2QU3eobLF86R3i+RSIRbb72Vy688i669DAwCeKUPhgQAsLSOlLUEUDxGH0wp2SV/xtpCxloB4sFjDMSQfCdfhJQuQTWN1+iOKbYFUjVNktVkqMNDWzsea86fjkWCBKtQ4k6s5UYrnkVaV5DRrZjSDo/0zIbBSqm9aIdBAB+9MMQOFdXQ0EB+fj5pXU1GN2FICV7pg73YJ6R1Oyldh4gHH70xZGf0EEWdBVK2YJKHn+4ItjtYmlpnoRM7xnFjOD1L4yRYiZLASye8suvkogxhEqwBLHx0ySqJqimSLMfSMB7piIeOiIgjQyUptmNSjJ+uWd9MW8YMCdY41vA2eOmEIC2QfV2O7Hm7yJhiGyk2Ivjx0wMDf47sqwHFT1dMinbJl6aaJOsRPPjpmQ2nZxFz+jONj3I8lNr9UhBqVvbsONCE05bxXdrSDjm3moxux5TWeOm+cxyw1ZE94Mjg29lWardlmm2YFOGj+84lwq1Njl++D485CMkZw0ldBmTwSresL39WRmsbVmYhYGCagxGjMSxeFE19DBpFzP6Ip/su+TS6DTZOti2X7Y9BCsqdARKHmomQ3A4Fg+1NxLb+xmZCYhl4O0HeWMh1TbRSsONDiK2H/AooGrUzX2QuhOfb7hvFx4MRcDpsA8Sn2/GZA2PBtOuWvZ9FFkN4NngKoXgCmI1tUkfKWoZ9P+j1mftBWreT1jWAB5/0wZC8bFumdClKCq/sej9IW4uxtBrTKMeUHrveDzRBkhVY2XHQLjsOkqwlQxUeyvDStck42OSM4ebGwTrSugVTWuGjZ3YcZHQbaWsliBevVGRlJ10DkQ/t5dFDI+wQd8Bbb71FJBLh3HNzYnR/gRwO/zW//e1vKSoqoqysDBGx71OqbNu2jQ0bNuD3++ncuTOdOnWiS5cu9OvXD4/n87Nf7jF6Rk/Rmbc3d+TQIue2PHqGiLwM3K2q7+bsuxeYrKpPOr+XAeNVdXOTvIuBQaqabrLfAyxQ1X57Pb+rNLt80fwv9MuCBQt45pln+OUvf0kgEDjU4nxu/C/0zf8ibr8cvrh903Luv/9+hgwZctAmAh4OfTNt2jRee+01vvvd79KlS5ddjlmWRXV1NZWVlVRWVrJq1Sqqq6s54YQTGDNmzOfy37JXpfnPzR05tMjXWqY0i0hX4ENggOpOP0gReQ34o6pOdX6/D/xUVWc2yT9XVYfspuzdHsvFdc9wcWkBAwcOZM6cObz++uvNWk0srSetGxG8eKRr1lKrmnSsShamdN5pmdkLqunsMrke2mE6lj1FSbOVDPV4KHF8nltGWreS0RpMKcakXdZaldEG0mxG8DlWbXMvJTXWOepYqwwn3x4nHe/MR8JZCtr2xWy01CoWKTY5FrM2mLTIxczJZy8V7qEUj+OLDJCmhjQ1GITw0n4XS+2eyFBHiu32WwU6IAc4/UNJkWQjdqSL9lkr897zpUk6y2Z7aJu12NvjYJszDv6fvfcOs6O48v4/1d0338nKAQUkAcoSQSBAEgJjhAkCY6INGK8N2Gtsdv06rN931/a73vXuvru/Xds4gI0x2IADOYkgFEhCCeWAEsphNPHm2+H8/ui6PfeORtKQBcx5nnmk6b7Vfarq23Vrqk99Tt3b0oEr+3DlIAZ1mGpAFzqI+Kvab0sHu1GYulz46IUAkRyu51MkTGM4SpUS2Xg47EAkh6n6Y6rabl5PcGUHHilM1RdTdSQHcaURV/ZjUIWpjut2uIArrTjsxyCGxaCORDaSxxE/JXxIHYdS3ZvsvD/jwTvTgc1BXFowqcaiT/BsuKR1RssQYQZWvLk5knmSwZEdKEw9BoZJpVJUV3fvOf642JlnnkkikeCOO+7ghhtuYMyYMcE5wzD85DC9axkzuR4Yx57tDi88t4A5c+Ywbdo0ZsyY8f6GcByb4Rm9lFLlE9w7ReTO8g8o//XWQ8A3yyfMpdNdXLOrFeGoUmpSF59XoL+IjmI9k+Ye67Fu2qWXXso///M/M2PGDBoaOrLw5d0FpN0/AB7gxwnXhL6DSIZ2+yeI3mwFIaqsrxI2T8GTIm38NYi1DTOMGi4npPriSDMH+WWwCQgMauQy4upkmvg9BTYH944xkTquRKF0+uqX9BdhHVVMJ8GpiAht3j0UZFlQLqxOpNa4lZy3jIz3eJnvtdQbX8dSDZrI8GgQLxxjIrVchkGYnKyiVf4A6DTCxGngVkJqAI600MpfKeIz4qOM8ZFzKkGBrTTxe4SiLhemgRuw6MNB7sLhoPZQUc2nqGI6gkc7z5FhCUIei37UcAFRRuJR4CC/xWZ3ULcEU6nlM7TyBBkWBcdDDKYXX8QgonF5c3DYjyKmcXnno1C0M08TM/wx16I3vfgyJgkK7NC4rt348c4nU8NFeORp5WHy+Fi2CCOo5TIsaimyh4PcHWzmBIt6riTGGDyKtPIwOVZqHQylltlAHIdmGrmrbCOZQS0XE2cyTdyrU3yXdDCBOj7n60AWkWae1kE9Sc4hoaYgIqTcX1P0Xu9oEzWGauubZFlMuzxSoYMGvoal6rFlH208qsNtIMYkargMQ4XJy8pDdFDPrYTUQFxpIu3cja1DD8NqEknrJgyVxHHXkCn8GPTGRoiSiHwfwziOFvc/cTkQ6CBhXELCuAARj4J9L0X7WSCDYQwlGvoiljUJkTxtzr/h6jhcgKjxKRLWdWSc+8i7HTG/ljqe6tB3UCpK0VtD2n0Il90o4kSNaSSMy1BKkfaeIy3PBDow6UODcRu2t5Um5y4INByh2vw6YWMUnqRp9+6nECAET6TauBZT1eF42/V4UNogGiJpfZWIeQqeFGiTv5DX8eshhlGjriCk+unx4NedxoNL9XhwX6fxoEwHLCbFwkPHA4QW/kyOVUG5CCNo4AtkWUYrTwY6MKmhF1/Gog6b/Xo8KOmgYzwoeEtJOb/GDz/1dyPUWN+mUCh8rN7MddcmTpxIVVUVd911F5deeilnnNGxv8FmL438NhgPwkNMPv/lq2jffwkvvPACP/zhD7n99tuPmrb8Y2YHj7TSrDFwDwF/FJGHu/jILtC72H0bBHplptL2Af91mNvs646jR10+UUrdrZQ6oJRaU3ZsolJqkVJqhVJqqVLqtC7KRZVSi5VSK/WOxx+WnRuglHpRKfWY/usBpdQPlFJZpXQgl38s3fm6PdZjH5bV1NQwbdo0nnzyyYrjWfcJFFGqzK8QMy7Go4W8u5C8+xxChrh5HQnrK8FnATIsIMcK4pxKLVdTZBtt+GNBltfxaCPJedRyDYoIKV6gwFsU2EyEE6jnBkIMIscKHA7i0EQrjwNCb24FPFp5FIcWXPZRkGVYDKNG3UqYkyjKBmy2kpVXUcSoUdeTUOfj0UpO/EmVzxXeTh1XE2MSOVaQwefWpmUuoKjhGqq4BCFLRl4CoJ0nKLKJai7RyLm1tOuNSikWItjUcBk1XIZgk2IhOVbicJAEZ1DPNRhUkWIegkue9aR5iRB96cXf4NJEM39C8MizEZvdxJhAPZ/HojcZXsWmkQyLsOhDPV8gxnhsdlLgTY3LexCXFo3L602aheTZgOCSYj4m1dRzLQlOx6ExmNS28Bds9tLA9UQZQUZj29p5njwbqGIG1cyiwGbaNXIuw2sIOaq5kFo+q9vB39CY1nXvQM69RSuP6nJL8Winipn6D6MIKeZTZDsFthBhFPVcr3Xgt58jB7WOhF58HcGljYdwpBmXvRS91zUD+JuE1DhsWYstm0nL8yii1PB5EpzXSQcPU+QtarmaGJPJ8QYZXqrQQTXXBjrI+m9IyTgPYMs6EuY1xIwLKcobZF2f5VuwHwUKREO3Eg3dChQo2I+SlyW4HCCmZlCtvoxBDRnvGURcHHcxRfthTGMI8ei/4Hl7yBb+HRGXorcSV7YRVmdQZX7D5xt7z+N4e8m7z2OqgVRZtxM2TseRLRS9VYi4tLt34dJIjfm/MFU/ct4cirISEZe0PI9BDTXqi8Q5C5cD5GQZOe8VwCZpfoGk8XmEAjnvOd0eT1FgNQn1aZLqMopsICV+nf3xIF0xHuTcx3VfzyfPG8Q4jVp1LTbbaJO/6vFgsR4PzqWWq7UOXtQ62Ny1DmjSm1I7jwfNWs+rCDGYeq4nwkgKbNaIxnkoItRxFVXMwKVNs8BL48FbGps4mRwrSPOyrsdTgCJp/g1x0+fX57wXyOfzn8hJM8Dxxx/P7bffztNPP80zzzwTbAhM82rZeHAFoEixgL59+3Ldddcxe/Zs7rnnHhzHOfIN3ql92Hi5t4mcU/5rod8C60XkcBPex4HrNUXjdKCtczwzgIjMEJFzDvdzZE986847x3uACzod+3fghzr+4x/1752tgL9DcQIwEbhAVwbgNvxdir8BPl9W5iDw991xvMd67MOw8847j3Xr1rFr167gmCKiV05jHQg6FYEg7CCrX+87qGDTWAkJ1R8BjRpL6ev5r7e9AFNWxCASbNbxylBzAAbhChSdQ2uAmPKvUfIjhamqyzB5YRQhhAI+8q694v5uCY+lk2eU++374gIGQjZoh47PmChiGpXWgarzy4ku6wCCQbjingYJhLzemKcqMHwu7ZjUIeQR7IpyJkk8soBBB/Yti0kSt6zOgq2Rc3V6k10Jq5XGZ2SE8MhjkOhUToK2d8kF5dwydJxJLYZGjZX8Lvko5PGHXLeij0v9JkiFDgy9MdEt04EiVFHWr3OHDjpQdANwaKlAAZb6x5MUhqrTKDm/3/z6FTGIBX1VCrPoQA9KmQ7K6+aiMAJMXod/bfj4vgSGXgsJ7qmiWge2/hGUinb4SDuGqkLIBToQafHb2BiB5zVjqL5ADijq582fGipVo9vB1H1h4EnaP66vUXpm/WQ5vfCkBYuhwb1LOhByGBX6iej6CYhT9sak1LYaOUc9BgnKEZSqy/GgtJm4NB4MQAT/eQzGg1LdyseD8BF1cOTxoFQuo5+Njr4s6aCEPizvz47xQAKUYQdiMIL/PJsBQ1oR+URPmsHPpPitb32LFStW8MADD+C6btCff7hrPj/67h9YMi8TtDHA1KlTqaur46mnnvqw3D7W7EzgC8BMvVC7Qil1oVLqFqXULfozTwNbgc3AXcBXu7qQUupUpfROWf/36/Xi7U91VsCj2lHDM0RkoQ6+rjgMQcBhDV0sg4v/Z1XHeyj/pxRjYuK///Go/DvjbuBGpdS/6QwtPdZjx5TFYjEuuOACHnvsMb72ta8BkLC+QNr5HSnXR2GF1DiixrlgFHDtHeT06pqpBpCwrgMgzmnkWEY7jwfXTvJp/3qcSZG3yLKILIswqaeGywgxmCTTSfMKjfzcfy3MhZjUYJAgzHHk2RCECIQZ4sfjKpOkMZuMN4dm79+AEAl1PhbHkTQuwOMRWuXXAEQYTVydpf05kzaeDBBlPibNf4NWrS6lRf5IG3/U9xpOUp0blGvhAdqCxCUGCfy/l6v5NA5NtOl6+5nsPo1JNQW2kGM1edZgUKWz1RnEGE2aBWR4NQh0iXMKBhGijCLOqWRZSiO/wiBOLZdi6fLtPEcjv9Q+nEaEkSidyS/Lsk64vJNQGNRxGa08wUF8tFaM8cSZiEKR4AzSLCjDdZWQc4PJszFYJQZFUte5ihnY7A0wgRa9qeFCXY9TybKcNjreXiT5FAIkOIMCO3QSksWY1FHLpYQYRJJppHmVRn6hdTAr0EGIIRRYRwEdFsFQQgxEKZO4eSU59wnanH8CwsSMi7DUUGq4gjb5My26zhFOIs6ZWo9TaedJWnV/KsIkAh3MplX+QBt/0P05nITyEWsx4zxS7q9Ju7/RNTOJmjP964euw/X2krf9c4YaTiR0HYbqRVFtoCDLKMhyDGqoMq5BKQPLPB2l/kLR6XhmQtb5KBUjxHgixgwK3gLanR+hSJIwb8AwakhYXyTr/Il2+weAImLMJGSMQyk/s2deXiHlaT+oJ6ImopRBjXEV7d7DtMjPAIiqScTUKRTMfsBe0t4Duj+PI2HO1nU+m4K3hpSUkrwo4mqaf866BMfe3vV4oKaQk2WkAv1AQpXGgzP0ePA6WV7X48Hso+qg6/HAj1Gu5gJSzNPlQiSZToiB1HEpLTxCM7/XOhgVPLtJph52PEiaV5Ny7iTt+uOIpUYRNy8in1/8iZ40g/+G8vbbb+fOO+/krrvu4oabPocd3kPvoRt5a1ue1+eaXDD9AjCgWCyycuVKxo0bx/3338+4ceMYPnz40W/yduzYjGk+rOnNfUf0Ws83v9aNy/0aOA9AKTUNHzX3dfyF3TuBK452gW7RM/Sk+UkRGat/Pwl4Fr8iBjBVRLZ3Uc4ElgEjgDtE5Dv6+BDgPqANuFZEUkqpH+BPsuOAKSL/pJRKi8hhI+J76BkfDfu49Ytt2/zoRz/iC1/4AqNGjQL8TUj+qph1yEYokTyCYKjKzV+eZCiwSaPGhmCVbVzyy9k68Um0YuOS4OqV0BjlG9QElyLbsWkkRG/CDK08L55e5YoFm7xKyLnD+W7TqDFpIaKM0Ct35XXIAUaQWrtkjrToNNqKCCMxVWX/exQAgk2AHXVw9EpXjAq8GkUKbMEjTYgBenNe5zYpYBDt1CaebqsIlSg6wWY3NnsxSBJlBCXkXOm83yZhVKe1BZt9FNmFQZQII8uQc+0Bci7MsACXV14H8DConES4ZDQ6ziHCECx6VTwz/sq41kF36iwuRbbh0IhFH8IMCzaw+ecP1YF/XPQKv3XIpk5HGimyHUXIr7Pqng5cOajxawZhYzSGqsTwiejV6U7Phq/9Iop4pfalgOOuRKQF0zgewzi+03lH1yHeRZ0zus5W2XHBke047MSgmrA6qeIZ8Nsk668w63KlvvEk779d7rQJ0JU2ivImIITViEOQc0ceD95EsH39vK3xoCvtH2U8OMKzEeiASh0cfTzIojBRKoLrutx22238/Oc//8A4zcfyd43jOPzhD3+gsbGRW2+9FSsMP/rBj3Ecl2HDhnH55ZcTi8X453/+Z5RS1NTUcMUVVwTfMd21I9IzRipZergAhw/R1CXdR869q/sotVJHP6CUugNoFJEf6N+7Rc94p5PmnwILROQhpdSVwFdE5LwjlK8FHgG+LiJrDvOZH+BPmn8DrADGA3uONGk++eSTZf78+cHvmUyGRKJ7u5F77IOzj2O/rFu3jieeeIIBAwYwZMgQjjvuOAYMGEA43D1ywLFiH8e++ThYT78cu9bTN92zXC7HT3/6U77zne98YPc81vtGRJg7dy7btm3jpptuYsWKFaxatYpBgwaxZs0aHMfBtm0Mw+Bb3/rWO+I3V1dXH3nS/P+962q856Yu/sAmzWuAiSLiKKU24M9dF5bOlea4R7J3Ss+4ASilMvwL/kT3sCYirTp14QVAl5PmTp+9n8PEpJSbUuqQvyqP1b8yP+n2ceuXKVOmMGbMGLZu3crmzZt55pln2L17N/X19QwePJhBgwZx/PHHM3z4cRpN5WGqQcEKXQkd58cVNhyyKiniIO6bCAUMYxjKqC0r16hTYtdh0WkVCw+bvQgFLHpVYNscmnBo1YipXsGqZbzK0BSJsMayVSKmHFpxacIgjkW/oJxHDpt9gEmYAcGKrIgb4LFC9DsEq+VJAUdHdFkMCFYnK33vjUlVmQ9NuLRiUE2ITitwR2hLR1pxOYhBEou+nVYl/bb0dJy0pTqIKC7tOBzEx6/1D1bofFzeXkBpdFzlH0kuGRwOoLD0aripfbQp4qd7DtEvWG0+ku9VVVUILjZ7EBws+gSJVrqng32aNtI9Hfi+70cRqvA9qJu04nAQg4SvA92WnuSw2YuPnBtYhlt0sdmFj8vr330diIej0YMWfTBVpe+H1YEIDns1erBXBarOlWZcacRQSUwGHKIDT3Yh3kEMoy+GMaCsXBuu7EOpSuRcIhnGYRegsBh4yAq7J2kc9gGhCnyfiK3bxNN1jgU++L5ntO91Fdd7Jzro0HCUEP3ojE08sg4O1XBHudJ4kPCfqdJ4IFndnyYhBmPbNp7nfeBj/7H+XTN79mx+9rOfsWjRIj71qU/xxBNPcOONN3LZZZfR3t6OZVlEIpH3NOFJhX3EwjPeY3sAWKCUOoi/IeIlAKXUCAjwNEe0d9ore4DpwHxgJmi2VJkppXoDtp4Ex/DjSP6tm9f/L2DJu/Cvx3rsfbdkMsn48eMZP348AK7rsm/fPnbt2sXOnTv51a9/wRduLjBgcDly7lZCxuhDMGlJzqZG77f13L0U019FZL8+axKKfRszMosm/kCh7HGLMYk6PotC4ZLhIL/BKcN1VfMpkkyjhb8EBAjwYxUb+Dw5VtHOHDoQU7X04m8C1nErTwbEDL8Gg+nFlyiwmWb+TAkxZZCgFzehJERTBS7PpEY+S1z5yQ0KsoUW+S2iwzP8nfpfwlL9NHKuscz380lylva9A48V5QTquQ6FqZFzv8NmZ3A+wZnUciFt8jgZXi3z/Tga5G8wVBgRl2bupcDGjraUidRyFWm1UNM+Ssi5PvTib3DYTxP3VWz+auB6InoDWYalmlhQiesSjcXz9IZJHzl3FRGO5yB360lUSQdnUcMsABxaOMhduGWosVouIc6kLnQwkTqueMc68FFj5b7X0ouvBDpokyfJaFJCSQcN8jcU2EQL91fooEG+giJEs/dzPFoDHVSrK4kbU46sA/rSzC8rfK+SWSTUdI1J6/A9yonU83lfB1KgmTux2dGhAzmbanUJKfcv5GRecNxiGHXmbSgVQcQhl/8Rrruk47w1g2jk22TlWY1jLCHn+lNn3k5RtpP17q303biZsPLTt2dlEe3y16AtDWqp528R8jR7d1COoKw1rifMSJrl1518n0G1cXGZDn6DG7Tl0XWQYn4nbKJPnjGJ4yPnOutgZBly7gkONx608TTpQ8aDL1KUDbR69+Fv6gRFAsu4kWKxiOM4798E8CNoSik+//nP85Of/ITx48czcOBAdu3axejRo6mpqTn6Bd61A+//LY5VE5Ef68Qn/YHnpCPUwqAbKbRLHzyiKaUeAF4DTlBK7VJKfQn4MvCfSqmVwL8AX9GfHaCUeloX7Q/MU0qtwp8APy8iTx56hy4rdhA/nKNbsOke67FjwUzTZODAgUyZMoUrrriC8y7oxYtzbOLmNSTMvwGEnPskedZrTNpE6vkCFr1I83JAH3CLjyGyHytyE6H4j0DFcfJ3U2A7BTYR4QQaAuTcGzg0AWjc1AESnE491wbYNpt95FjpT3S4QSOm3qTIDtK8ricsV5NkBi6tAWLKI0uGV7DoTT03EGMCNjvJs5EU8wGo5QqqmYVHhjSvkWWRxmOdTy3XoQiRpoORm5F5CEWq+RzVfA6hSEbmaXReo0bOdfZ9FWGO074fT56NFPUk2UfO7dTIues1cu4VHGkkw6tY9KWOG4kyHpsdFPSmKB/XtZEII6nni4Q4jhwrsNlHOy+WIeem4HCAHKsCXF4ts6nlUoQCaY1eA0jxYtCWVZyDSxsZlpDmFTyyVPOZMuTcfK2DXZ108EqggwxLcGmjinOo4yoUYVLM075v0hPecvRgSQertA6mUM+1mFTrttx/WB2084L2/RqSnKN14E8kPcmS4WUs+ui2nKDxfRtIM1fr4GqquQiPDBleJiev4tFKQs2iRl3v60DmHFUHed7A4QBxzqSW6zGoIs3z2OJr2NfBF4kwgjwbAh0UWI/NDqJMopYvYtGHDC/heAfIyTxM+lNj3EpEnYzDNgqy1n/WvHW47hJMczLRyP/FME7EcebjetvIeE9jUEu1cTNRNR2XveRlCTlvke+7upoqdSVCgYz3YlC3tDyHIkINXyBBCeP4GlmZj5ChSl1GjboOEDLe8xRYp32fTC1fwqQ3GRbgaQqFr4PWbuvAZn8ZNvE6EpyGw/7gD88SQrFSB5sosp32Mg13NR6kg/Hg+orxIO35z3iN+jxVajZCBqt6Gf369WP9+vVvdyj92Ft9fT2XXHIJv//979m9ezeDBw8+eqEee9emCRlvAguAiFKqTimlRORNEVnenWt0h55xzWFOndzFZ/eAvy1cRFYBk7rjhP78Dzr9/nfA33W3fI/12LFmp50xgHkvbGfHW/sYOnQkJdRYaXONRxqDhJ4kGVB6DRq8pm71N9pIHoy6AEHmY6PKEVP+8Q40VBqDuF4JM8uQVdmKcj6+zEKwMYiUHS+FHJj42LYSfi1dVi5ECTUmOkFFx3EfZ6UYqLFwHasnAa4LF0EA6aJNfN/9jUglPJbvu1vme/m/PqouXtaWYTqQc4kAxVa6Xke5DEZFm0RQWLrO8Yr7lXwXPCRI5tERnuEjyjIa/VZezr9XaYNahw46kGGH6sApa5MsJVSeItmpjct9t7qoWxyPvNZBZVt6nermkTuKDnKYxMvastQmbqCTUrkAsycZlBqoNXaoDoQSi/bwOqAMs+eSRZHoQgelupXQg6W2jFDCIhpUBWi3jnI6TEbaMIxaJMDDxehAziWQMhyk386iNaB1ULZx0m/LFKq8LVUYJSX0YA5I6LKhijqbJPR5I+hP47A66EDHVfZnWGu4oDXc0V/l/759HViBDvzrpirK+W8bKnUwadIkVqxYwbhx4+ixSjvzzDNZvnw5ffv2/WBDSj7BK834YIrS6nKpJZJ6AfhvROSto12gWxsBj1XroWd8NOyT2i+utPDC/H9n7epmrr+liEk/qqxbMI1BtPIYWfwMfYoYNcwiof8OFUlTzPxvPGexf171JRT/PkboZNqZQ5rX8CdeEao4hyrO9sth08JD5HQ2MoMktVxMjLGkWKiThRQBiyRTqeZ8mlLrcKqeCkIA/JXXq4OY2wxLaOMZStmr/GQss7HZQzN/xtWrm2GGUM+1KDFp4b4gG6BJHTVcRUS/unbkIC1yDw4+d96iP3XqRkxVQzN/Ja+3PPi+X0KMMaRYQIr5Zb6fSTWfQqEQPN2WS8va8tMkOJWMvE47c7TvijinUsNslDL87HjM0a+aHRRhksykSs0gxxpaeSKYHMYYRx1X4NBKM/frFMMQoj/1XBvEkRbYQgsPB6/RI4ygnmsQijTzAEX9+t2iF3VcSYh+XejgAhKcQiqVIlEVopkHgoxvJrXUcjkRhmsdLKLE/n63OiiwhVb+WqaDUTrJjNaBLNZtmQ10UMNl2OyhhftxdSbHEEOo53oUJq3ePRR5U/tQR41xLRE1skwHvy+LadY6oIZWHiSvV0UNqqjhMqJqnA45KPf9rCCLo4hHGw+RYwn+BDxGNZ/xUW7ey6S9R7Xviqg6kyrj6kAHxeLvKNqP4ocWxAiHryYSvpK8t5y096eAax5Rk6k2bqQ1tRs38WCZhgdSa9yEpfwU1gXZRJs8iEeLfjZOoFZdj1Ck1fsdts6oZ9KbWuN6LAbQJn8lh37eiVOtLiKu/FAWjzzNPBiEYVTq4Fk9HlTqIMtq2ngimPiWNFyaiB+qgzOo5tNaBw8fZTx4tmw8OIVaLsWR3bR6v8fV4VUhhlFr3MSfHniSXr16cf755/NB2Eftu6ZYLOJ53nuK5TsqPeOn79mt3jNTF34wGwEPe3+lLsffFNg5J8mhn+2ZNPfY+22f5H5xHIfvfe+7fPd7t1Nf12kDEk6wotl5kw5oHJcUQVV3gZjKaeSceWg5bDydqKIzgqpzuVQqRbLKX5lTWIdsbPPLeXhkNdKqDNelsWx+EonOG6GKgE1nZFjHef9LtzN26+34Xlmu67YUKfNdHfpiTaTsuuX4NTx9vGP1M/BdT8I7o+NKbXK4tvQxex6HouMO9b38mfEoIji67u+PDjp8z6IIda2Dw7RlCbfoI+cq28STAv6E7m3qQOxgpbQCHXe0OktZW3aJnIsegtMrlRNJo1RVJwxfqVwkQNF1IOf8SXhn3zvaJAtYXWwSzOPrIHYILs/TK9vlvgfl3qYOjqThI5c7vIY7rtvFeNBJB67r8r3vfY9vf/vb9OrV65DrvB/2Sf6uKdkRJ82jjtFJ86wPd9IMoJRaLiKTj/a5nuj8Huux99Esy2L8+AmseGMD5547sOKcwsLksERFn13bxReywjxyOUKYXXxJHq6cQmF24q1WnjcOW04dppyhwtDFF27H+UPr5V/z7fnecb7rtlSqa987zh+uTYyAUNDZDLr23S93+Lbs/IdFR5kj68CfuBzalu+PDg6P6zpcWyp1JB10ZMbs+vxhdKDeoQ7U4XWgOPxkSikLVUbb6E65zqzqynJ+Kpyuy3W9quj7fngf364OjqThI5d7h+NBJx2U0kDv2LGjYtLc2tpKY2MjI0eOPOw9eux9tE92eEaXppRK0r0M2T2T5h7rsffbJk+ezNNPP825555bcbwoO8ixEo8MUcb6GemUiSvN5GUptmwiosYTUSdXfEH7m6L8jV9RxhBjLEpZuKTJsYo8G4lyIjHGYZJEsMmxhhzrsOhFnAmECDKJ4kmWvCwnL2uIqJFE1WRMVYfgkmc9OdZhkCDOBMIM6ihHkRxryLOWEAOJMx6LXghCgTfJsQaFRYxxRPCzWtnsI8tKXJqJMpoYYypWqwpsJcdqBIcYY4kwCoXC4SBZVmGzO6izoeMvc6wix3oiHE+c8ZhlsbMOreRYTYGtxDiRGOPxU0UXdPbBddr3CWW+byTHWu37eCIMC64nOORYq9uyvqItC2wlyyrAI8aYwHe/nEueDeRYq9tyPGH8zT9FdpJlFR4ZYowhyollvq+iwDZinESMcRUT9lJbOjQTK2vLw+pAbPI646JJb2JMIqTKdECOHKt1Ww4nxjgsahFxybOOvPY9xkTCSvsu28mxAo+c1vDoYJVURCiwgRyrdVtOCMJ0bNmrNdxcoeFKHawq08EJZTpYqXUwWvdnGJEUjj0f13kF05qMac3AMPoE13OlhbwspyCbiKqxRNVkDBVHJItXfA6vOA/DGoMRvgBlHucj4Lxl2M5rKBUmZJ6JZXYgXEUc8rKSvKzCUr2IqpMJKR9V5zgrcZyXAAfLOgvTPDlYURbxKMobFL3lKJJEjCmEjOFBW+ZlmT8eqPFEGItSJo60kmMlRbZ21Fm9HR28SZQTOo0HazuNB32ProMjjAeO9yZF51WENCHzNELGKUQiEW677TZ+9vOf8ebWpYwab7BiyX7eeH0fI0eM7Jk0f1j2CZ40K6W62idXB1wC/Lxb1+gJz+ix99s+6f3ih2h8j+9973vU1/vxr3nZQDP3YJDEIK5pB9NIcibN7j8j5AgxDJstWAymzvwOShkUZScH+RWKEBb12OwhxkRq1GUc4Ke4tBJmGEW2YVJHH26jlYfIsYoQA3BoQnDoza2EGUh7exvFxK9w2EOI47HZ6mPDjO+QUi9pAkUfPDJ4ZGngBqL4X3YH+R0FNvtMVvaiMOjN18izjnaexaQBcHBpo44rsGigkbtQhLGow2YvMSZRrzOXZnmDFv6qJ70mLs1UcwFRTqKROxA8QvTHZicRRtDADRzg5zjs13V+C4M4ffgGpt64eICf4pElzBCKvEWIfvTmazRxNwW2EOY4iuxBYdCHr5NjLe08h0mDDm9op47PEWciAM0aexaiPw7Nui2/jM0BWnm4k++zqMJPSd7GM6R5GYveeGTxyNDA9QA0cS8GCQwSOBwgyVlIaiK5qrvxyGsf3yJEf3rzVRQGRXbRyJ2ddDCBWi49rA7a5C/kWYHFQFyaEGx68beE1CAEjwPcgcM+wgylyHbdlreRlnmaotIXjzQeWer5IuAcouEkM6hWforwlMwnxdO6LR082qjlKix6aw2Hy3yfTJ26UutgOS38pQsdjKaRnx+qA7mRXPZmxNuGYY7Hc9eAqiYe/w3KqMOVdpq8f8MjQ4jh+pkaSIPxLZzULYizGGWOR9wNgEWo5kEK3hIK9h8wVH+EIiJNxMLfJGxNJ5VK4SYeJS/LsBiEy0EEm3rjNpTzJvnCf+MTVy1E9hIJf4lw+HIAMs6fyXnPYtIfjwxCO9XWNxBl0eLdiUESf6PjfuLqHBLqHBr57046GEAv/tYfDwIdWLot9x5VB6080sV4cDNhBiJ4NHIHdhc6SLFQ66ByPDDcdjLFf0dRg1JJPNlNxLqEeMhPEb6z+RnmL3iOTas9Rk+Os3dXltEnnMKnz/nCez7WftK/a6Ab4Rl3fNAeHd3U+R9YcpN/6nRIgCZgoYis7s41urUc3WM91mPv3CzLYty4caxYsSI4VtrwVsUsqjgfRZQ8q7FlE0KGmJpOVJ1DiBNw2BlsuMuzDnCp4jwSzMCknhxrKMouXFqJMZEkpxNjPC4tFNlNjrWYNJBkBlXMBL1iBODSgsMewpxEXJ1NjLPwSGOzRa8sxqnmPKo5H3/fv4/q8sjrCfMAkpxFFdMQihTYRI41+JTiT1Ot2dP+Svd6wKOKc0kyHZPaoB1KnwGo5gLNrDb1KvGbCEWqmEaSswgxgAKbKbIbh/1EGEWCKSQ4DY8MRb3Rqsg2PDIkOJ0EpxNhpE6BvYcCWwgxiARnkdS+5wPfLWr4dMDNLtVZdP1N6kkyvawtN5T5PotqPg0YwbFS3RRRqviUPo9e7Vury32aKs5DEfP7k914ZMt8Px6bvbh6c5nffy7VzCTJNK2DtRTZ3bUOZDd5VmsdnEOS87Tv64BSoot9RBgZ3NNvy23a9zhVfIoqLsDngKwpq/OFJLkARbSCp51nNWBSzYVU8xld51X6nl6Zhmv1ZzvrYJZmVpvkWKNTzhepYjpJpgU6cL0tiLcN0zwNy5qNFboYpBXX9a9j6/TrMc4mrs4mzIk47MbxtuoJ8xiM6BcwojcCWTz7VWznVSBENHQ9UesG/zrua74ORMjLKkwaSKjzSKoLAJeCrMV2fIZxJPwlIpGbADM4BlDwlqGIEzcvI2F+Vh9bTl78dkuqi6lSF6KIk5cVWsNZEpxBnKmEGYHNHlyaK3RQxUz9TJV0UBoPJhxhPJhWoWFfB83Yh9FBnjV6g2XleGC7/gbGaOhaYtZVKOLY7utBnSP125h5WRXf+8evcMlFV1NdZ5DKdXDVe6zHPigTkR92+vmRiNzR3Qkz9Eyae6zHPhCbPHkyy5d3YCAt+gOQYxk2OxHyhOiHpQYAioIsA5XFZhOKOKbOFBfS5bIsw6UZl2ZC9COkV7byrMcjr78ELUL0JkRfXJpwaSHL8orrmFSjiFHkTYQ8Bd7Aj7Ltj0U/PLIU2U2WN3Q5/3W+IoKpV4s90hXn/Wu7ehK6utNxyLFc+96KVRYmUrq2HzbxJuASon9Znd/AI4XNHkzqsOiDIkKBLYgOtwADiz66jfsCSr/mL1BgK352tD6Y1GKzG480ucD3/toHhwKbgwlgR52Vbstm3Zad64ye3L1JKfNfed2EPDa7yspV1s1ml37D0I8Qvcp8z1NgG4pYEHrSUW45Li1aB311uS50oHoTon+gg5ymjZR0aFGLIkqBrQh5XXeFRV9C9EfIYrOLXJl+yn2w2a413JFNr6SDAm8GNIwQAw6jg/6dynXWQb+gPbMsx6M90IFhDAISuO4bQAbHmQ8YGMaQsjoqCixHyFNkk9+WajAY/RF3HUgTXtFPI6DMEzCNoYCN463E9vykLqYa6p9Xqqwtm8iJP2kMqQGYhh/K4zgv4TpLAVdfyzdLDULI4sg2Ct6rwTFLt1telmCzAyFLiAFlGl6pfd+qdVDbSQdvdNJBaTzYgEfhMONBa9l40E+3VU2ZDgqddNAPIXfIeGDqdrbdl3BkE0IWUx13iA7yOmRr0plhlixspK2tWwnYeuy9NnUM/nxAppS6UynVZapspVRCKXWTUuq6I16jJzyjx95v6+kXP0Tju9/9Lt///vepq6tDxCPNQrIsxaWJOFOo4jxMlaTgrSArC7FlAxE1mbjxKULK/2ISEbIsIstSbHYT5xSSzMRS9RTYQppXybOBKCeS5EwiDMehmRQvkmWZXl09hTinoVCkUikiyWYy3osUWEGYE4kbZxFV43BJk2IuGRZj0Zs4k0lyFiUSg80BUszHTzoxVF93Eh552nmRLEtQREhwMlWcA5hkWESWZdjsJa6Pl7KNCQ4p5pFhGUKROKdQzUwMomR5gwxLKfIWMSZQxQxC9KHITlK8RJ61wepYTMcEA+RYT4bXKbCJKGOp4mzCDNIJIOZp34eR4NQy3+eSZSkGMeJMpooZQdy1Qwsp5um2HECck0kwBT9psd/Ggk2CU6ji3GDzn9+WL+q2bNBt6SPi0rxEluU4NJHgVKo4l2xKsKp2at83E2MsSe2731ZChtd1W+7Rfs7Eou7wOpBm0rxAjiWEGESM04hzehBv67fly+RZQ4QRJJhCjNG4kiLFXLIswqI3MU4p832+1nCz1vD5mDpdtid5UjxPlsUoIsR13cAky2va95KGz8VS5Tp4UeugoHVwntbBcjIs0TqYqHXQF9ddj138E67zEqZ5Klb4EixraqCDvKwm671MkQ1EmEjSmElIDcFzNuPlf4tXfAZlnYwRuRwz8hlEMuTtP1F0nkepBGFzJpHQ51AqRCqVIpYskpHnyMnrWAwmrqYQU2cCDsXiA9jO84jkCYU+TSR8LUrvSfAkRdZ9jLw3H5M+RMwziRl+BsiMvEhOXsflIDE1laS6AFNVkZO1ZFmkNTyOJNMJq3ehA5q1hpcTYiAJTg7GA18Hu/Qz1UkHhxkPEMg7j1F0F+DJfiLmeURDn8PQ6c89CsEzpQiT4GQWPJlj86Yt3HbbbZjmoRSUd2o93zVHCc84QcnSX3zQHh3d1HkfWHjGROAfgHHAGqARiAIjgWrgbuBXIlI47DV6Js099n5bT7/4du+99zJo0CBmzpz5YbsSWE/fHJvW0y/HrvX0zbs3z/P4xS9+wYABA7j88svfs+v29E3PpLlb9/NpGafgZ67OAetFZGN3yvaEZ/RYj31ANmnSJN54440P240e67Ee67H33XK5HE8//TSPPfYYc+bMCRB0AIZhcMkllzB37lx27979IXr5CbQPOxTjQwzPKJmIpEVkvog8ICKPdnfCDD3IuR7rsQ/MTjrpJH7/+9+ze/duBg4cCIUVkHkYvBaIXwix80GZeNJEwV2E420gZEwmbE6pQM653k6K7iu4sp+wcSoh81SUCuFKmjyrgtexUSZgqoTGpK0jz3os6okxgRAdOC6PvI4f3UCYYcQZh0mNRkxtJMc6TBLEGE+YgWXliuRZS471hOlPjPFYNGhs2+ZOyLmhANjs18i5Fo3POolK5NxbnZBzI/BRY03kWEWRvcQ4iShjypBza8izIcBjmVR3tBVtZFlNkW0Bfs0gWobL20CYAdr3eu37Jo2cC2nfhwTXO7Qtxwe4roJsIS8rAZeoGk+YURWosTzrybMGg3glto1d5FiFR5YoowPk3OF8L5nNAXIaNRblJGKMxkeNZYJ44CijdJuUdLCWPOuwaNA6KEeNHUYH4mrfy5FzfniALTvIyXKErI9HLEfOHUEH4mzGKz6NeLsxQjNR4ZkVSUcKbOukg5G+DqSJHCux2UOUk4gyDkOF8SRHnhUUZB1hNUJrv7ZDB9JKQZZRlDeJqHEa4xhDihlk3UPIxsdQ/Sejxl6Dqh+OiEBxARSeARWFyEWo8KkdOhAbx3kVx30NQ/XDsmZgmlrj3kYKnh/PHDYmE1JjynTg4jmv4BYXooxqzNCnMKyTAHC8rRTdV/EkTdg8hZAxGaWMo+rA9XZgOwvxZB+WOYWQeTpKhfCknaK7CNtbSciYqMeR6qPrQPIadbieMMOJMR5T1SDiUWCd1nBCIwsHddJwTmv4BF599VXWr1/P6NGjWbt2La7r8pnP+BtClyxZwl/+8hdmz55N//4d8ew99gGYcSwy544c8aCUuhu4CDggIofEJCulZgCPAdv0oYdF5EfvrY/6XkcLz+jKWR0X8iv8WBAH+KqI3g3RUW4wcC/QD/CAO0Xkf/S5AcAfgBRwnYiklVI/AL4NDBWRA/pzaRE5LMm+Jzzjo2E9/dJhixcv5qGHHuKm6yZxQs03wKgHoxacLVD9t3i1t9FW+C5CBlMNx5XNmGoY1eEfoZSB420mVfhHIIypeuPKDsLm2cRCX6aR/8KlRaOi3sKkgd7cTqvyEVMW/XBpRnADxFR7qo181X3Y7NVIq50dqDEWkuYVjUnL4JGjgRuJMgKAg9xDgU2EGIDNAXxs29fIsZ525mBSp1FjKer4nEbO+Zg0k1oc9hNnMnX4FIEsK2jhLxhU6clfC9VcQIyTOBAg5/pgs4cII2ng+jJMWsn3BH24rQvk3GCK7AiwbU3cowkaA7HZh8LSvq/VuLx6jZxLUceVxJkAQDN/IccKLPri0qpxXV/Bkb20yYMY1KA0Jq1KXUJSTQegTZ4iwwJMeiHkNLbtJlBKI+diGtt2kCRna+TcbzVqbJD2fQC9uZVK5JwVtGWMiWWosRaN2duOST19+DqtPEyOlZ10cGsZauwX2OzVCMFdnZBzL1XooJ4vATat3l0akxbDpZGEOpcq42IAUrzUpQ6ijonbfoM/GTX6g7sJFb4UK/l/tQ7eoIU/Y1Ct27KFamYRk9E08lOtg77Y7Nbpvm+kSf4Th72EGIrNdgyS9FL/C0Ml8SRFk/vPCGkshuKwDYtB1Jnfxbvv07D1Beh/MhxYA2YY45Y3IPIcZH4CxnFAHrwDUP1TVPRSUqkUVuhXOM5cDGMYnrcfKBKP/Rc2B0m7v8WgDjDxOEjCvIqY6aeRtnN34BT+iDKOQ6QdpI1w4v/hGnHS9n+gSGps216i5meIhC7WGs4RYhA2Oyt04LibyBS+C4QwVB882U7InEEsfCttxe/iSSOWGoUjb2KoPtSEf0KLeqQLbKLWgXgc5OfY7CHEcdh6POjNN8kwnwwLMbUOROtAVDk2MaY1PI1f//tKLr74Yk466SRaW1v5l3/5F2677TYGDRrEd7/7XW6++WaGDetgoL8X1vNd043wjF8fe5NmdY4cMTxDKTUNSAP3HmHS/C0Rueh9c1Jbd8Iz7gE65+P+d+CHIjIR+Ef9e2dzgL8XkZOA04GvKaVG63O3AV8HfgN8vqzMQeDvu+t8j/XYR81OO+00vvSlL3H3fQtZtGYw1P0T1H4fjBrIPI7trUdIETHPJ2peiKXG4Mo2PGkEwHaXAS4x6woi1uUYqg9Fd5FGTLUQYxIJzibKRFya9AqQj5iqqkDO+YgplzZs9upNdFMPQY35yLkSJk0CHJiPnNukkXPTAuRcBzHDpIZZ1OAze0vJEkrIuSrOwaQ2oGuUPgNQw4VlqLHV5APU2LQy1NgmjZzbp5FzUzVyLn0Y5NxUIozAZm8Zcm4gSab5k1QKZb5b1HCB9qEDgSa6/ib1VHFOBb7PX2GGai6hiosAIzgGkGeVxnXNoooL8bFtqzRyTqjmAo0ejJFjNUV2lSHnpmrk3J5DkHNVzNRtWadRdSUdTCDJVI0aa9aosTVaBzP1hrwO9KCPGvN1kOTMTqix1fjIuQvKfF9NQdfPx6RdhCJKXlaU9WcJPTirrC1XI8UXAQcj+lWM6M1gDECKzx5GBxeW6WAjQpEk00kwXevgTWzZhcNeH5vINGJMxSNFka2+DmQTQoqYmk5MnUuYk3DYhZvb5E+YB5yKOuu7qLO+A8UUsnkOFJ4CIpD8B0j+H92JT/k6EMFxXkKp/oRC1xIJfx5wcJzXKHhLAIibV5IwPweYwTEA134RVBVW9BZC0a8BgmvPx/YWA0LMupqYeRWKBEX3dQplyDl/I1+lDhx3MeAQCV1NxLoKQ/XDdl/B9rbiSSNhYypRaxZhYyqeHMCWrYEOkpxziA5cmoI/ShOcRZwzysaDVV3qoBwVWcJn5liD53k0NvrjVm1tLbNnz+buu+/mgQceoFgsMnToUHrsAzaFv9J8rP0cxURkIWjO4nvZHEodPmXmYeyok+bDOCsQvAOtAfZ0UW6viCzX/08B6yF4t2virz57VEa03A1cpZSqfxt16LEe+0jZqFGjuP3mE3n4xQnsfethKK4Crw3CJ2GqgYCi6C4C8jiyAUUcQz8SJZRT0X0JkYN4cgBTDdaoMZM86zUveR0diKk+uDTh0U6WFUAHYsqkCh/btlVnCutATPnJLLLY7D2knI+cq8VmL0K27Hxf/Rk3eDVfKld6BZxjBS6tR0DOraXAZjpQY365LCs0+mwvJrVlyLmS72u07yXkXB98XNdqBFtj2yKE6I1JDTZ7ELLkWFnme1985NzWMt/76jqXI+fayOk6W/QLkGl5VlMMkHMdr50tjeuy2R0g7iz6V7SJw54y5FwDHcg5mwJvoYgGyDkraKsVuLTh0lKGnDPJswHB7hI15tF2CELQR411pYM+2vcsNnsqkHMdmLRlGpOWD451tFtJB+uC+ynTT44jxSfB2w3enuBYpQ7WdNJBR5270kGRTaBsCqwMNAxgqX6AIi/LQBU0ci6KER0K1YNhz1LINSEr7/P7uc84sE4ECmC/CoUndSf6YTNKKQxjCCJ7QQ5gO3MBMIxhWKVwBVmOLT5T3VQdWTSVcTxICnE34tpz/HLmcB9/BxS9V3Flm/+myRisw6hKOiiW6cD/+i3h7GxnPkIjnuzDNIZgGf0Bi6K3HKFA0VsOhLBU/wod5DrpwCxDD0JRowLLkXNZHPaS1+UMrx8Hd0VwHSHHCo1NzBOiL1/84hd58skn2b59OwBnnHEGM2fOpH///txyyy1ByEqPfcCm1LH3897YGUqplUqpZ5RSY47cBGqqUmod/rwUpdQEpVS3tkh2i56hlBoKPFkWnnES8Cz67xZgqohsP0r5hcBYEWlXSg0B7gPagGtFJKXDM9JAHDBF5J96wjM+HtbTL12YuMyf8yOWr9jKN695FqPqeqj9Nph9KLqLybsv4HhrCRmnErMuxjL89MMiQsGdQ9GZjytvETanE7WuwDT6kJc3yfAyBTYQ4USSnE1EjcShiXbmkeONCkxagJyratGIqXVEOF4jpsbgkqKdF8iy1E/kwMkkObsMObdfI+dWEeY44pxKgska2/aCRkxFiHMy1czER86VUGP7KvBY4McLd2DbKlFjGZaTZQlFdhBjfIAaK7CDNAvJs74Cj1WyHGs1tm0LUUZr5Nxx2OzTvq8mzJAy5FyOduaSYUmAnKtmZhlyroTve4MQ/XVbng7ikJJnybEEoUiMKVSpCzCUH3vqY9ueI8vrmDRozNo5oCDNAjKaWRznVKo5TyPntmvftxJljPZ9sG4rqcD3xZhENTOxqCfPZtK8QoE3iXACSc4kyvFaB3PLdHAKCU4vQ43t6FoHFb730r7PACAjz5OTxbg0aUzaLEzlP+uH1YGYeIU/4hUeA3cjKnwJZuxWlDmwTAc+oszXwalU8ykfOSdLybAEm+16Nf0cQqofRXmLjLxIgTWEGUVcnUlUjQt0UIlxnEDcOJ+QGobsX40s/DGy9k8w+EzUyV/BmHg94rVB5r8g94D/Fij6OUh8E6XCpFIpEokMheIfcJwXMIzjCVnnEwpdAjhk3cfJey8jFIgaZxM3Zwdpr8Vrxs7/Brf4KMoYiBm+ECtyPaDIu49TcBdqbNtMYtYVGKqmk4Y76UCEovMURecFPNlGyDyHaOgaDKMvtruGvPsMtreCkDGRqDmLkDn26DqQHaRZQJ61hBnhYxzVWFxpJ81zpN1F7NiUZPOKJGtXHsQ0TUQVmHp+nHFnOFSHTqOa8zBJsmDBAubOncsPf/jDD2SS3PNdc5TwjBOVLP3Ne4f4e69Mne1ux480KNmdInJnxWc6zUM7nasGPB3qeyHwPyJy2DztSqnXgSuAx0Vkkj62pqtrH1L2HU6afwosEJGHlFJXAl8RkfMOUzYJLAB+LCIPH+EeP8CfNP8GWAGMB/b0TJo/+tbTL11bOp3mH/7hH/jJT35CPB4/eoH3wXr65ti0nn45du2T2jfFYpHXXnuNF154gUQiweTJk5kwYQJ9+/Zl69atPP300+zdu5czzjiDQYMGISL86U9/YtasWUyfPv0D8fGT2jfldtRJ82+PPf6DOss5KnLuSJPmLj77FnCKiBw8zPnXRWSKUuqNsknzShGZcLRrv9PWuwH4hv7/X/Anul05FgIeAv54pAlzuYlIq1LqfuCr3fgsqVQq+D2TyXTnFj32AVtPv3RtCxcu5LTTTsN13Qodf5DW0zfHpvX0y7Frn6S+8TyPgwcPsnHjRpYsWcLAgQO55pprGDx4cPCZVCpF7969ueGGG9i9ezcbNmxgyZIltLe3c+211zJs2LAPbHz7JPXNO7P3NBzimDGlVD9gv4iIUuo0/AiIpiMU2amUmgqIUiqMv89ufXfu9U4nzXuA6cB8YCawqfMHlP8u5rf40Oj/epvX/y9gydH8U0od8lflJ/2vzGPVevql0na/9UcWzHuJv7tpIUlvESS+htLoKREh7z1H3nsJV3YTMaYRN2djqjrysp4sr1BgIxHGkGQGYZ3eFyDDUjIsxWYnMSZSzTlY9KLAW6R5WYcxjCLJGUQZhUsKp+p5sizDoi8JTibB1LJX9ntIs1CHMQwnwWnEGYdHNghjMKnWoRbTAUWaV3SGuwM6xOLcIAbTo6izvS1FoXRWwJkYhMnIYrIs0b5PoopzsVQvCmwjzStlvk8lSsebtyyryfA6RbYRYxxJphFmgPbdD8HoCDfoeGWf503SvEaBN4lyEknOIsJQbA7qbIErCDGYBKeQ4BTt+1ztuxFkLFT4qDSXNh1eshSLvjpj2pmAR4r5OuV1igSnUc25GMTIsooMiwPf/bATP740WZUsa8v9wf1MasizUfu+Sft+dgUa7+3roE2HRHStA1v2kOJF8qwizPH6lf0EPMnq0I1FmFQT41SSzATVfR0AOoPikXUgxcV4ud9B8QUIT8eI3YAKnx3UueAuouDOxfHWETamELUuwTKG4nhvkXOfpOi9jqVOImqeR8Q8raOcrCfrzafIOiKMI26cS1gdjyP7yXrPkJfFWAwlZpxJzDgTT4pI4kVy8hpgEFenk1QX4H/3grj7kOxPIf8gmKNQ0Ssg9iXAI+s9Td57DY82YsbZxI2LMVQCt/gCbvERPGc5Rug8rOgNGOaIYDwoOE9QdF7Ekx2EzfOIhq7CMBooyHoy8pLOdDiWhDqHsBqGTaMOP1qhQ6dOIcHJHXU+jA4A9u3bx9KlS9m6dSvbt28nmUwyatQovvzlLzNgQEfMeld24okncuKJJx7xM++39XzXHMEUH8lJs1LqAWAG0EsptQv4J/AHXhH5FX6oxa1KKQc/WcnVcuQwiluA/8HfZ7cLeA74Wnd8Oeqk+TDOfhn4H6WUBeSBr+jPDgB+IyIXAmcCXwBWK6VW6Mv9g4g8fbR7ishBpdQjwO3dqUSP9dhHyba8+Qx33jWXz87aR99h34fU/wb7daRhEUqZFLyXybgPYqnjiZuXkXUfwZNGEtZNtHAPiig1XEkbD1NkM33kf2OoKHk20sojWPSmhs/QxlPY7KY3N9PEPQDU8lnaeIomttCX22ljDhZbqOY8cqynjacxiBNnEoJLE/fgkaOW2bTzIi08iEUdaV4mx2oSnInDAVLMRWFhEKOdOYQ5jipmkuJFXFrpxRcBaOd5MrxKjEmAkOYlBJeoDKeNh7HoQzUX0c6T2OyhgZtp4vdd+P53WNRSZBctPIhJDbVcSitPUGArffkWTdytfb+cdl6gmQfoTT1hBuLQQhP3oQjr6z5OgS3049s08wccGqnhIjK8TiuPYFJNnjfJ8JpuGz8NOngBGaKZv1JkK1WcS543aecZDGJ4pEjxIhFOIMpJZHgNjyxJzqCFP5X5/jgF3qIf3wYgy3LaeYYQg6niXFLMxaGZOmbTxB9QRKjlcl1uC/34DgZR8rz5tnXQwl8p8hbVfIoc6yp1IC5N/AaPLDV8lhQv0MIfMaWeDAvIs5IEZ+NwgDTPobBQJLvQQQu9uKmTDiYClOng+C510Nv7Il7b3wCgqn6CpH+MV3wVo/4FlDkAx9tKxv4ZBvXErS+RdX6HXVxPTfi/abf/HSFDwvoSWedh0s7PMdWPsIyhuNJEq/drFGGq1XW0y58peBvpbfxf2txf47KPpPE5ct5CUt4fMaglKxtQspCoOg1wychcBJdqdRkAkvp7sF9Dxb+JFBcgmX9BGTXkQkmy3pOE1ThMNYGc9yKeZEhyOnb2/4DqixX7Dk7uPyg6bxCpfgylTIrui+TtezCNUUStq8nbD+LJPqKRb9Aiv0URpVpdTbv8laK8SS/+kWb1BxwOag0vopWHMakmykg8cofo4KC3ieb1F7Fw3lJ27tzJlClTmDFjBsOGDeuZhH7c7KM3Z0ZErjnK+Z8DP38b1zsIXPdOfDnqpPkIzp7c+YCI7AGfMSUiL/M2ukdEftDp978D/q675Xusxz4KtmXLFn79mzlcP3sVYyZcCdSBNRGc5SDNoHrjyC4AIsZUzaqtwZGdOBwAPGKMRxEhwigKrMOlGYMB2OwHIMZEDKqx6INDIzaNCHaQECTGGLIsw6ERh4OEqcakN3FitLEbm30AmsmbIcwQFDHiTCDNS9js12zjMGGGEKI/BTZhsw+DuPZhMiYxDBLY7A3q77APUDqBh+jkHPuwy8oZ1GDS2/dPGhFlE2Ws9n20Xr08iEVtWZ0noIhrHvN2HA5o34ehiAa+O+zXk+ZG3Zb+dSOMJM86bN0mFn0wqCLGRFI8j80+3S6KSOD7qkPqZlBFiD4YJGhjJzb78EhpH8djECLL0rLr+f3V4fsOPLIAwfk4kzBJYJDEYV8n3yNEGUme9Tg0E2ZAxXUrdXBA62C0bsuxZFmKwwHdd9V6o9/kTjpI45EmzFAUMWJMJMMC7cteFGFCDMNiIAU2YrMXpVeUK3Ww7zA6QCcs2YfZSQcWvXE4gDjbgByEL0CpOBI+HwoPgbsFzAG43k4AwuaZKJJYaiSObMRjN0IKS50IEidink7efQZXdmlm837AJcJElIoSkdEUWIkj+3DZj0l/DKkhqqaQkcdx2I0jBwihiDAGH7u2HEfKAFLORjB6I+ZIiDZA+g3EWY9j+au0YeNUlISAl3FkF563BQAzfD5QgzLHIO5qkFZQDXjedl23c1CqGkUtrrdd++4RZTwGESKcQIG1uDTi0IRFXwySWsMvYLOPKCM1m7lDByp3An/41cs4uac595xZ3HzzzYRCHYlmeuxjZh/Bleb32pRSv6OLjCoictPRyh57EeE91mMfU9u7dy+//vWvufH6yzmp74uQvQussf6EOXQayugNQMSYRN57nqz7MIaqQ2gjapxDmKEYVJPldRwOUGSrRoL5aK0oJ9DOXNIsCCYbUU4izAAsepFnrWauvoVBNWEG65WnpaSYh0sbYBDFDxMxqNJJQ7YDQpHdKKJEOB6XFlLMI8VzeOQBiDFGky4WkeI5DKo0J3lK0AZRxlJgK+3M0UeEKGOJcBwp5pLmRSx649JIlDGE1QBMGsizJuDFmtQQxsd4RTgeRZQ0rxBmIEV2EOY4LAYQYhBFtuEHA+xEESOCTyEJM1i35VIcDlLkLSx6EWYAUU4kz3rSLMShEUWIKCegCFFkm/ZdACFGx56UGGPJsJh2XsSlHTCIMRpPZ+hrZw6KMIJNjDE622GUNC+X+T4EkySQIsZoMrxGO89jUo1HmjinEuY4DKq0743a994Bvu7wOhiodbAOj2yZDo4LJtBd66CaEEPK+Nd+W4YZgUszaV4gxTOI1kGUcRjE37YOYl3owNE6UKHRiDkUinPwpBnsxX5iFGsiAJY5BuXEybtPY6njceRNLDUSg6H69w3geTiyBUUCy/AJKyGGYlBLntdwvUZsNmPSh5AaTFiNoyiryMpzuOwHQkTUGCIqhMcG0vIYonUQVRM7HvTIBZC/H7I/BW8/YKLCnyZiWBTcJWTdh1BEgSIRYzKGcQqQxC08gDJPQtzVKHMCymjwfTSnUHCeJm//EaUaEFoJW+cTZggG1eR4HUcOYLPV952BRBmlQ3hewuGA1vAoXee+gQ7S6XZ+//N1DBwS44arvoNlvG1sbY991Kxn0gzwZNn/o8BldIFO7sq6Rc84Vq2HnvHRsJ5+8e3xxx/H8zxmz56NuDsg/wTYyyFyvp+mt+wLy/G2U/AW4dFC2DiZsJqEUhautJFnlcaJjSbGhIoU2zaNetXuADFGE2MMihAu2SBFcpSRxBiLSTXtqRasql3kWYdJDXEmVPCFPQq63Ho9uRqPRR2CR56N5FmLIkqM8UTQDGl2k2MVrp74RTkJhY858lMrbwkYyP5E6XgUClsOaF7xAaKMIcZYPz14kBZ6o/Z9HCYdenJo0Sm2d+h00uMwiJSlhV5HmKGB7yVzadeptDcF6YlN4ppTvJYc6wjRR6cZ7l3m+2pAEWMcUT0J9+vmJ4nwk8nU6LTj/upige0BazfKGKKM8jO60ayTmVT6Xnpmiuwhx0pc2nVbjtZZ8tp13TYT5UTieqL69nQwIkg7Lrg6PfhhdKBTK/sYsqHEmICl6nVq5Q06eUtUp9ge+r7oQLxmpPAMUpyHCp2Nil4Y/KEJ4HqNFL3XcLxN/jNjTkGpGJ7kKHqvU/SWEVInEDZPx1S9OspJGwV5g4KsJ6LGElWTMVQCkaI+vhKTAUSNU7BUP9rb24lU7dGJXBRRNbFTynQbis8jhWfB6IeKXoqy/Em67W2hIEvwJE/EmExYjUUpA8/dg2c/j+eswQhNwwzPpDzvguNtw3ZewpMmQuYUQuZpejxoJ88bFGQjUTWGKBMxVKIsxf06QvTTGi6rM1n2t73OnT99ktFjh3H57C9gqRo+6vZefdeICO3t7bS1tdGrV68PjW70TuyI9IzRhiy9N/JBu3RUU6fmj0rPeF/vr5QBvCAiM4/62Z5Jc4+939bTL7795Cc/4fLLL2fUqFEftiuB9fTNsWk9/XLs2sehb1KpFP/v//0/Tj/9dC644IKPTaKRt9s3tm3T2NjI/v372b9/P/v27ePAgQPs378fwzCoqamhqamJaDTK8OHDmTRpEmPHjiUajb6PtXh3dtRJ833Hnu/qlNyHPWk+AXhKREYc7bM94Rk91mMfgKVSKQ4cOMDw4cMrjntSABwU8ffki0tw8chiEA9W9d7d9QSPHAoTg+6vUAiiX9crDN6bQVqw8ShiEAsSrLy763m6rSIBAaN75QSPLIoQBuGKc36oiqCIBuSJ7phHAcHVdXuvdJDT1/sQdSB+GhaFgVLvzWqdSBEhjyKJv0D0bq9XpgP13sTyepLD10HsbT3XInkEW9ftPdCBOAhZFAmU0qv8Itx///1MmDCBWbNmvet7HOtWWjUuTYzLf1pbW2loaKBv37707duHEaOGcPbZU+nbdwDJpJ8iwvM8Wlpa2LhxI4sWLeL+++/nhBNOYPLkyYwbN+6IE+h3Oh68f/bxRM69XVNKpfBj7JT+dx/wne6U7Zk091iPfQC2YcMGRo0ahWX5j5wraVq5jyJbATCpp1auIayGIiI4xb/i2HMQbwtW6GJCkRtRRgN52UiGVyiwgWgJr6aGIAgpnifNy/pLN0SSaVTj5xwqsF1j29YS5QQSTCXKCFxStDCXLEsqMtwpFAXeooW/4tICQJhh1HMtJnGdOe9FMizGpJoEk0kyDYWJzT6aeVBvWIMQA6jnOixqEewg6x8QZIlThMiwlCzLKLJDI+xmYNGA4NDCw0G6a4M4NXyGuCYv5FhDhsUU2KKzBU4nRD+NnFtAjlVl2QL9GOQsb9DG08GmuxgTqeNyFCYOTQEiLswQjeuarO+1gVYeDTb3RTmBOq7GI0Mz92PrsDiLPtRzNSH6IrikWEiWZUFccjUzMYjh6nKleGGTOur4HFCPiJDlZbIswWEvcU4nyXmYqoY8mzRybiNRxmhc3nFaB3M76eBsqjn3KDpoo515ZTqYTIIzjq4DyWoM3+s6rONkkkxHKRPX20G6+N94stuvmxpOMvz3GEavMh0s0TrwkXSKEFlvETlZhM1bxNRpJNT5PnJOHNLubyh6iwBQVJEwryFiTvXr5i0j5y3ElvVE1GnEzQuw1CBs2U1GXiAvy/1sgcZZRJWfwyAry2jnaTx8vm9MJlHLFShl4nBQ62CZ1sGpJDgZEZuU9yRZXkehiDGFpPoUSoVxpJkW+T0Ou7QO+lLL9YRUP62DBVoHKeJl6EFP2knZP8ORjVrjvUmGbiZkjAqygBbchbiynYh5LjHrcgxVB43Pwo6fQeNT0PezMPTvoe4MXzve42S95wAbCBM3zidhXsLixYtpbGzkppuOuufpI2k51nAw+yovz9vA1jUhmvYXsawQvfvUUt/PprZPCxNGDuK4vp9iYO+pmKZJluV6PPB1UGQiwhUoTDyjBaNhPkOmLmfk1OMgcwWbVykWL36d+x+4jyGjLIaOipCMDKMmPJ5wOIYRKpAPz0eFmwiFFdFQL/qELyceHkg4HP5wV/Z75syIyDt+VdQzae6xHvsAbO3atYwe3ZHeOcNCimwlwQxCDKaVP9LOY/TiG7j2HOzCHRjmSZjhG3CKv8fzdmPFv08zv0MRoYbP0sZjFHiTvvJ9XNVKinn6S/pztPJnUswlxnhMqmjiHgSPWmbTxhzybNbIuWex2Kwxaetp40mdPnoibTyJSxv1fJ6iZiWneZkazqeVx8mxigRn4NBIOy8AFlWcTRvP4tBILZfjkaGdZ0kxlzo+SxvPk+EVYviTFh/b5hLh+ACTVs0s2nmGInvoy9d1fPFKopxIkmk0cR+tPEqMsdjsp5kHMKimhkto6xI5N5t25tLM/fTmbwnRhxYexSBML24OmMxRTiDOeJr4Aw4HqOFCMiymlYcwqSLCCFp5FCFPAzeR5Q1yvKHTe+/FZg/VzMIgSiuP0M6zNHA9aV4mxQtEGIXFKDK8ikeWej5Hmpcp8hZJnRq5mQdp40liXE+OpbTzOCEGk+Q80rygMWKfo4l7NXJuNq08SYHN9OPbuLSV6eCztPIXUrwYxIF36OAy2ngm0EELD1Fkm9bBBtp4SiPnynVwHUXeqtBBG4+RYyUJpuLQSIrnUJgkmU7W/iOe7CYeugWRFDnnj+Scv5AI30obz3bSwQIEh5gMp10exKQPVepSUvIYtuykl/kdit5Sit4iQmoiMfMzpJz/Ju3eQ9g4DYfdtLu/xqCWpHEdae9+bGcDdea/0iK/wCNLtfocaXmWVu93NBjfwqIfrTyidXCL1sEbOr59gtbBfqq5kCyLaeWvmCTJyDoULxHlFMAlw1xEXKrVJaTlWRx2UcXFKKK08xdS8iT16m9I8xIpntc6OIEMr+CRoZ6ryLnP4MhGosaFWMYI0s4dZJw/UBv+EUXvJbLOfZjqeKLm5eTdh3FlH9XOtbD8IrCqYMxdsP5v4eCzcM5uXDNN1nsKkwFUmV8k5f6OrPckufYTeOihh/jbv/3bjyUhoyj7WPDyPcx7LM+YccM497MH6N2vgWGJb3OAn+CRo4arSPECHk/iMRyDvrTyKIpQmQ5W6L0CEw4ZD5zEU0w64wZOOmMYTdndvLVqALu2t7GvuA7sA1DsRaa4k4Ldjlesxi56FIrbcOz/xi4oamtrmTJlClOmTKGhoeGDb6RP8EqzUmrykc6LyPKjXaNn0txjPfY+m+d5bNiwgYsuuig4JhQBf9VUcFFYCLb+/GYATGsWStWiVAOetzlATMWYgEG8AjknuPp6CYRMsClMsDViqqiRc7Ey1FgjDo2EqdbJOOK0sUdj1CYGK5VCEUVMX88B0FixMGGGE2IQBTYH+DW/HgagUDp8obycjxrz/4AoYdtK/saZjEmtJifsR3DL2iqhQw6iuLQjeGVYtokYJALah8O+MuScP/nzSQL7sGgAPBRRPDKaVuH7KDg4NGrkXA0xJmnk3F4ijEBwUIS1H4mycn7fdYR5GMGxUrv4/RYiy/JObVXSgVOhg9KqdYxTMUhiUI3NHuwAPTgWg1gFcg68Mh1ktY+NXegg2gk5t1fj6Uo62N1JB75f5bqq1MHxWgebyjB8RcDEX9qK6nKFTjoYU6EDS/zQj5g6DYN6TPrisE+HGfhlDVWNJ2kUcYRmwMUNMI2n+8g5RuCwCYc9Gpc3AkWSqDqFrLyII3swVR+tgxguWQy9uVSwtQ4OYNEXkzpinEyKZ7HZh8N+jZwbi4+cewNH91WHDsI6hKgrHUzEIKzRg+VtBUol9eet4JijkXMRczqKDuQc6XUgDvS7EkJ10GsWHHgUsluRZK1uqySepFAqgXjw4B8fZ/r06Rx33HF83KxYLPLE48+ybVuem/9uOoP6n0SGV/3xQPZrHQxHkSDGZDIswGYvJr11aFQ1Htmy8cA+wniwD5u9ROMmZ5w+E04XWniQCAPoxU008wA51lDDxShCtPIoYYbSS25i+/btLFq0iJ/85Cdcd911TJw48YNrpI9ocpP30P7zCOcEP1nfEa1n0txjPfY+2+7du4lEIvTq1bF7PcGZ5FlNilKuH4ukDqUwrbNwio9gF3+LUr0RacIKXYzFEI0ae11j0jZj0RuLPviIsDHkWUuTDvmIMU4TEDyNbVuLkKPAVo2TG0yUEXgsI808HFr1dXx2bhXn0MLDtPBnwEfQJTlNX3sMKeZ3Qs6N1uWm08wfaeUhwOdM+Jnx/HJFttLOs7reQpQxRBhCO/NIMT/gCpdoCz7K7XWyLNNhHYoqZmi+8vAy5JzPaA4xGIuBhBiokXNQZDuKKGGGYxChimmkWEAzfwD8EJIYo1FYRDmBPBtI87L+Q8XStAtFNTNp4xlaeMDvKxqIM4kIwymwmTYe13UOk2Q6AFHGaOTcsxhENHJutNbB6eRYU9YeFlXMxNXlsrxCijmY1ODRTowpGjmX1BPeJo0e7EXoMDqIMrYLHeTLdHBcwO7uvg6mBNdO8yIpng10UJoIR63ZpIv/Sdb+pW6TBFHrYq2DsVoHzwQ6iDGWiDqOtDxLRp7Hoi8u+4kwDqUswsYp5L0XKXgLKbDQV5ZxCUpFCHEiihg573lCajgOm7DUMCwGE+I4imxGBGy2+bg8NRJDhUnKDNLMo4V7tQ4GEmWs1kE5erBDBxHl4fEmaZ6ghHqNKj/TZELNoCBv0h5oP0xSnVumg1W0M6dMB7qtjPMouEvIuX/W7REiZl4KQNg4mYI7h5zzZwyNnIuY50DtGRDpBzvvhMyb0DwPEidAcjSWsgiryRRlOba8CcDKRUNIpxwuuOACPm62Z88efve73zFoUF+++O3ehCKrydDaaTwYrMPhhCI7NIJyBAZhqphOivk0BzoY4FNbjjgeHIqgLGk/yVnk2UwbTwC+DqqYjlKKoUOHMnToUM444wzuuOMOGhoaKtKSv+/2CZ4zi8g57/YaPfSMHnvf7ZPeL6+99hobN27kxhtvrDgu4mCzG8ElRL8KdJznbsSxX0C8RszQNEzrbB+/Jm3kWKFTP4/RyLkyNBUHcWnDpAarAjGV0cgwP21unPFlyLkd5FiLRS0xJhBmYIcfZLHZj8IixIAyZJhHng3kWINBhBgTiDC0rFwhWE0MMyBYgfVRY5s1ts2f2Pu8YoXNfrKsxGE/UcYQZ1xZOQ+H/XjksOgVpGP269xMjpUU2K7xauMxiGrk3CpyrCHCMB+TRn1Zm7Th0IRBDIt+wUYdj6JG0a0tw3X1KSuX1uzbsG4TIyjn11kI0b9iw1yBt8ixEo8iMcYQ5cSgnOBgs6dDB8SCZ8aWXeRYjksbUcb5Ezpl4dJGltVBCnA/DOed60BwAsyeRU33dSAeedaTZ3WAnIuUpXUXyfmroihMY1hHqmmEAps66WAkCoUj+8jJMhzZS1SNJ6omdpQTD1d2IWQwVT8/rrdUN2kk7y3Gls1EjElE1KkYGjmXlzfIy0rC6nii6mQs1VBWrg2Hg1oH/YN4U18HqzvpoK9Gzu0mLyvpGjlXxGY3IFgMwFAdG8UKbNM6KGhkYZkOxMGRtwAHUw2ufK69rRTcVxBpJmSeStjwkXPkd8PeB+HgHOhzKfS/GsId/e3IfjxpoaVZ8Z///lu++c1vHjUV9kfJUqkUTz75JG+88QaXXHIJ48ePJ17tdD0eSI4cK8mzhjDDiTERS3UeDw5iEO/WeFCpYVUxloG/Ul1kDyIeTfsMlISIxWLE4/Egrnnu3LnMnTuXH/zgB4TD4a6q+LbtiPSMMaYsffDYY3Gr8akPnJ6hlBoLjKb0GgwQkXuPWq5n0txj77d90vtl0aJFbNy4kRtuuOHDduUQ+6T3zbFqPf1y7NpHrW88z+N//ud/GDNmDOeff/6H7c57YtlslldffZXnnnuOU045hc985jMkEoljrm/eeOMNHn/8cWzbJhKJkM1myeVyOI5DPB5HRJg+fToXXnghhvHuSTDQjUnzn5PvyX3eS1Nj2z/QSbNS6p+AGfiT5qeBWcDLInLF0cr2hGf0WI+9z6YMhesVNS6tcjVBpKBjWSuRcz4yrIBBtEu8WinerjPKSMRDyGnUlVF2XPTxsL9Cdcj1PDzyGr9mlh0voePMQ3zvOK+v22k48QLkXKRTma597yhXAOQQVJ0fO+zHV1fU+TC+d5zvui1LGDXjsL4bR6hzHoVFZ1SdV4q77QLLdqS29KQIuH6blOtAHCALh8GrHVYHeGXIuco6H873jnJvTwe+7x6KSJdUAE+0DtTb1IFoHahOOpAiSBZUTae2Kmk/GuDVKu937OvAx+l1pQNX3yvWtQ6kqJ+NxCF9sGDBAhzH4bzzzjuk3EfBSuOBa5usXbuWJUuWsH79ek4afSLfvP1W+vcf+qGOB11ZKpXiwQcfZM+ePVx99dWMGjWqol8cxyGXyxEKhY5p5vPH2K4AJgBviMgXlVJ9gd90p2DPpLnHeux9tAI7SBtzyLjN7OWHhBlOPdegxCVt/xTHWweAofqSCN2KZRxPG0+RYTGlTUrVnEeS0wH/VWELfyKPX86khlpmE5ETSPM8GRboL88wCTmHKnUeeVlHK4/g0QZAVMZSy9UY+pV3mtdo54XgizzBFGq4kCI7NGqsGfBTVtdzdbAZLMtK2niqA9elsW0OB2nmTzr+D0IMop5rMIjRwp/Js6HC91J6X4dWmnkAuwzXVc9VWPTSyLkVfluR0Mi5CaR5lXbmlvl+OjXMQqEQPNp4hgyvU5qQ+m15BllWVCCm4kyilstwaNS+H9C+D6aBazDxs6Xl2Ugrj+lU0xDlJOq4UiPnHtCv5Uu+Xx2EdRSCtmwCCHSACC38sQw92ECdXIlILfnCL7DtpwAXSBKJ3EA4dHGZDv5MnvVlbXlpWQrtlwMd+Mi5meTYQBuPl/k+mjo+F0wEDtXBaVoHO7vUgYhHC/eX+d6LOrmSsPI3mdmyj1b+iKM3a4ZkMHVcj1JH1oErrTRzHzY7/baUftRxrY8fTH8fKTzmP1yqAZX4Hkb0YtLyMimeR8j5vssZVHMxSr2fOnikU1tedVQdFNlB8yE6uBolQqvcS5HNQVvWcC0hjiMlj5LlNe17jCouJK78PQIiebLFn2J7PrpPqQbioa8QMn1IwP79+3n66af51re+9Z6tZL4f1tTUxLx587BtG9v2N06GI9CSXU86lSGTFtqbhIEDBzPltDO48LokxNcg/IZ9ZeNBljdIseCQscwfD4Q2nn7XOqiXq2lrdtmyZQtbt26lf//+TJs2LZgUL1myhIceeogpU6Zwww03dBl2YVnWh7MirhQYn+Cg5g7LiYinlHKUUtXAAWD40QoBR88QoJS6Wyl1QCm1puzYRKXUIqXUCqXUUqXUad0tq48PUEq9qJR6TCmV1Md+oJTKKqX6lH0u3Z1KvJfmui6FQoF0Ok1raysHDx5k37597Ny5k23btrFp0ybWr1/PqlWr2LFjB67rftAu9thHyNp4EswMpjuYJGdSZCtpXiLvPIXjrSNqfoak9Q08aSRr30uBbWRYRJjB9OarKCzaeBKPHABZlpBnHTEm0cCX8MjSwiPY7CPN85jU0cA3MKglzbPYsp9WHkLI0sBXiDGRPGvI4Yc1ueQ0Zi5Cb75KiAF6x/k22ngCl1bquY4EUymwhTSvAP5qjY9f8+jFV4gwihwryLGGNubgsJ9aLqea87HZRYoXybCEPBuIM5kGvohLhlYeC9oqxYvY7KKa8/UX1n7amEOONeRYQYQT6MVXEDxaeRSHNo1Gi2rf+5PhFYr4tIEib5HhVUIMoDdfxSBCG0/i0EYrjwJCL24mwkiNj1unfT9ALZ+livOw2Uk7L+o6Cy08ikeWBm7SbbmeLEtJMReb3VRzATXMxmF/2eY+NLathTquIclZgQ4yvKTRg2dTx+dxafHb3d2IbT+OYZxIPPYzlIpSKPwCkZTWwVLyrCfGRBq4SevgUYrsJ8WLmNTSm69hUkOKuRQ5oPnSWRr4EjEmkGddwMt2yXShg9co8tZhdZAOsInTqeU6XJqCjU9+fz6Fwz5q+BxVXIjNTlI8p30/kg6ex2YnVcyihitw2Ec7TyHF5/wJc2gGqvoBwEHS/wdHmmnncQwi9OLr2veXyzaBHk4H7WUavpkIo7rUQTWfOkQH/h+hpbacpNtyidZwZx3MCerW2qUOXiYj8ymymTgzqOFGXJppl4cpspksL/uTNW5HEaZdHsYTzRN2X8T2lhAyppEI/yMiKbLFXyMieJ7Hvffey4UXXkjfvn3f3UD2Pptt28yfP5+6ujpGjhzJiBEjqOrdzLDRNuecN5VrPn8Rt/ygihv+rh+Tz6qF+Bo9Htysx4NHcGglxYJO48GrAQP97etgbZkOLsfKTOPVeZv453/+Mf/xH//BypUraWhoYOHChTzyyCO4rsuzzz7LU089xS233MJll132nsUpv6em1LH388HbUqVULXAXsAxYDizuTsHurDTfA/wcKA+Q/nfghyLyjFLqQv37jG6WBbgN+Dr+zP7zwK/08YPA39PNzCzvlW3atImnnnqKTZs2ARAKhbAs65CfzsebmpoQEb72ta9VkBF6rMdKJhQxTRPPc1ABoswO8FmKJB5FIISQ78BqkcQjpTFrKY2hilHCr5lU6ax0EX29Ylm5NCZJXA4gFPGRYVGN1fI30JVeH5cjzzxSmFRh469kehRRhPCwA7yap+/jo+AcTJIa01Qd1Nf3xcDPhBXudLyEjstqgkCxoq38Nil90RgV5fw6Z3RSkNayV+BxXWff91IbehXlUhjEcWkry75XrZFznX03KQ8PKbVR6TOKiK5zVXDMq0CNKcAI7t9RzgpCcTrqK0GbdKDdClDSh6rD85pRqhqRg4gUUYpu6iCFQRIfOVcs8z2jj3fU7Ug6KKEHfR0ky9rW1j4koAxPWNmfBlLWp35blfqtax14FTpQgQ6QrJZFb/CaQVWD7NWriqXrpQONS6DVw+kgj+AGuuroz0KFDpQOsejsY9c66PC9Qwed9XOoDjrav7ItO/qzumw8aOvoNynppMZHyxELtLN48WJM02T69Okc69avXz9OP/108vl8QPdoZic5GqlhKAqLVqyjjAcdGM/K8aCkg0JZue7ooEhba4a3tjlsW7mAdau3c/xYxcVXjWLyyK8EK8tTp07lV7/6Fd/4xjfo3bs33/zmN6mtrf0AW+9t2id4oVkp9XPgfhH5qj70K6XUHKBaRFZ15xpHnTSLyEKlyrZD68MQbF+vAQ2p7F5Z8EcjT/+Ud+HdwI1KqX8Tkeaj+fZe2D333MPWrVuZNWsWX/va19428H3BggX853/+J7fccgtDhgx5n7zssY+qVXEOjnM/BW8PKZ7DIEmCKRimTdF9nZz7J/1Jk5g1mzAjCTOEPGvJsxaAOKcGE7s4k8mwVCcFAVDUcCFhBhNhNAXWUWQLUEKNDaSKc2nnaVo1Xs3HpJ0MgEU1cU4hy1KauA/wM75FOR7hHFp4hNYANeb77v8/rLFt8wNsm0U/YozFpIZm7qeVR7SHUZKciUk1WZaT5iXtu0ENFwZtleRM8mzyV+fxmcdVTCfMYNIsIstSsnqFvIoZhOhNnMlkWU6T/rs8zHAi+i1blOMJM4w864JwljinEKYPSc4mXYGc60+M0ZgkaeJ+Wnm4zPep+v/lyLkHdVvWlyHnNpUh50JUMa1CBy08RCt/KWvL0wEhxypSwWqkSZJzcczBmMYYXPdlXPdl30frQgyjoUwHy8raUlHDLMIMJMpJ5FlfhpwbTZgBVDGTduZ08n2i7rvaLnQwVOtgxmF04JJnDe0BNtGkqgxzmuAcitxLu66zIkqCaZjUHEUH0yiwkXa9+uxnNTwHFe6PmPdB4S9IQV8zdgsW/YlxCjmW0szvynRwPOCHk7w9HYzRiWA66+DMMh2cSxtPlaEH64kzmQjtb1MHCT8Dp/LIy0rSPNWhA/UpIowixDAKrKKA/50e4wxMVevX05pO0Z1L0X3Cj+JBEQ3dgFKKPXv2MGbMmGM6LKPcLrroIn784x8zbdo06uvr9XjwZhm2zW/LMMeR4bUux4MYY7BZVjYeDAvGg651cHKggzZ3Pmt23sPubQ57toXYvfURioUc/Yd5DDtxN7deESeRjNOLz1TEUCcSCf7+7//+g2yqd2efbE7zJuA/lVL9gT8BD4jIirdzgW7RM/TE90kRGat/Pwl4ltIyAEwVke3dKauPDQHuA9qAa0UkpZT6AZAG4oApIv+klEqLyGG3er5besbOnTv55S9/yQ9/+MN3lR1pxYoV3Hffffzrv/7rsfk65kO2Y21H8wdpu3fv5mc//xmzr5jGpJPHEGZgsMlExMaRrSAOpnEchiqtcAgO+3FJY1FfgUnzz7vY7MajSIi+wcoIgCMHcGn1E4R0RDrhSjsO+1FECDEw2ChV6huHJhxaMEli0Tf4UnDJ6Nhks8L34H60BriuEP3pwK/lA+RciAFB3Kzv+54y3ysfbx/btocObFtptdfDZm+AnLOoLfOha98Pbcs6ndjkaL7ntO9Ghe9BW5LC5gBGgJwzy3z3Y1nLfe8ol9XxvWYnHTgU2QUBetCnACSTSTxvGyKtGEZ/DKN/FzootWWfCh3YNAbIuRC9y3xox6bxEN872qQZh+Zu66Ar3yv6U3LY7EGhCDGoDDl3eN/9cqW29Pw+UDq5jnjgrgevDcxhKLOjTRxpwqEJkyofGabeHx2UnhlfB/t1Ww7spINDNdwdHdjsRHB0nfWbKREc9uo3AL0qcHn+eRdXtiKSxzQGBRi+u+++mzFjxjBlyhQ+KvbYY4/R3t7OF77wBeDtjwepVIpYVbFb40EuFWLH1la2bt3Ktm3b2LFzBw0N1QwdPpgRw8cwfNjx9OnTB1EF7UPX48GxZkekZ4yzZOnD1V2d+lBNjWo5Ij1DKXU3cBFwoHwuWXZeAf8DXIi/c/rGI2X303PQq/VPFHgAeFBEQ82PYO90I+CtwO0i8pBS6krgt0C3t+bqCfa0w5z+KbBCKXWkzC2l65BKpYLfM5lMd10AYN68eUybNo18Pk8+n39bZctt+PDhJBIJmpqaSCaPPZzLh21vt18+Lnbw4EHuvfdeZl86mzGjxlBMQVHHJndYOTM1Vfb/BJDQL2HLj5fM/2I89HxM/3Q+roB+ABTIBkc7+iYM9NXX67yVwJ90Heo7+C+N+urrdu7nXrpcR7iBb7Xad6HrujXocjaUvdr2X25Vd1HnI/kOh2/LI/leqnNn30tW2uCX7XS8VOfOvne+bue2LNXZA1Jl/dI7KNN1W9UCXekgCkSxgfwhOjic7wAh3r4OKn0/1Er3O5wOOvteslJbOp3Ol2ez66yD/u+7DirHs1K5zm15OA13vm7ntizVuXNbVumfzr6XrF/Z/1OBn/F4vOI78li3qVOncscdd7Blyxb69Cn90d/98cDvmwSdNey6LgcOHGDXrl3s3LmT3bt3k81mGTRoEIMHD2bmzJkMHDjwEJJFOl3S0dHGg4+QfTRXmu+h61Dfks0CRuqfKcAv9b9dmp6D/hvwb0qpSfhRDv8EXeBWOtk7nTTfAHxD//8vdBPV0R0TkVal1P3AV4/2WaXUISuY3V3RLBQKLF26lH/9138lnojjsI8iezGIEeH44K9JlzYKeiNBhGEVSRVK9sILLxCLxejTpw+medQ2/0TaJ3Gled26dfTuU8/JJxeBpZjmaAxDb8iRPBReAXc/hEZDaELFYOZJFlvWIVLAMoZjKX9FTcTFljdxOYhFfyw1vBNaLovYi8BrQ1mjUdYJ+riH623ElT0Yqg+WMTpYbY4l0zjeNj+zmhodrOr55QScVeBsBKMPhM9AaXSYQzNFdgAmEYYHyTU8chTYgmATYjChsuQa4K92FvQmrfJnyqNIgc145AgzQGex6zA/jtr20WYVq0cOBbbgkiJEP73q5++Wt9mFzX5MqnX2QKviekXewqEZi96EOQ6FoVej3tl4YNOIzS4UIZ1tzP8SdiWtyQgeIYYGSRVEbApswSOFRT+9GuvXraqqCk9yFGUDQpGQGoql+ga+F9iGS0uF7x118xAKuq3K9eFRZIdOEV3vpxkv4dnsTVB8A4wERM4Go7qsnOCwHUf2YFBDWI1CqdD7rIO81kG/oE6+741YNBBmSCcs3geng3iV9650IHiED9HBZjzasRhQoQNA62B9mQ5KbeJS4C1cmrHoQ5jBQX83NjbSt2/fj9TYW1VVxbRp07jvvvsYOXIkvXr1qviJRqO0tbXR0tJCc3MzLS0ttLS0kEqlGDJkCCNHjqRfv44/IHbs2MELL7zA6tWrqaurY9iwYYwYMYLzzz+fvn37fmRCV95T+whOmo8Q6luyS4F7xQ+dWKSUqlVK9ReRvV19WPmD1wX4K83nAguAH3bHl3c6ad4DTAfm4+fq3vQOr3M4+y9gCe8jEi8cDjNo0CA2btzI8Ml7yfBqcM6gij7cSpHdNHM/pc06YNDA54lyQvDZnTt38vzzz/Od73ynZ8LcYxU2bLjHQw+tIZefE4xT0cjthIzJ0HghuG91fDj2Oaj/GQCO7KbN/jFSWoVyIW5+jphxHq3Ov+OwIygWUmOoMb+OUgbi7sNtuwqkMTivotdjxP8XmeKPcbzVwXFTHU8y8iNy7gIK9iMdnydOTegfOibpqduh8HiHn+ZQqH2ErLEpiFn2zaI3X0IRoZFfB5tuAKqZRRVnAZBjA838EX87A4BBPdcRoh+N/AKvbBUtydnUcCElUkeW5bpElUZMjcMjxwF+GSC8AGJMoJ4raeFPQcY538Ne9OYWDGIINo3cFYRTgB/z2MCNGk/29seDFAsriBmKKL25GZEMTdwJOMG5GrmKKCfRyM87+T6ZOq4GwJG9NLv/1aEDIGlcStyYQSO/0q+MS76PpIEbURi08yJpFgaT5iqmU8U5fmYy7g6wZuDjAHvJzajUL6H9Xzq6U9VAnychNBKAdu8eCrIkOG3Smzrz2+TUhiDut6OVv4TRpQ4uoIqzgaPp4Jd4ZSvFSc6imk/TxO8o6Djtku+9+TIK6yg6+DM5Ovb4dF8Hc8hoWozvoa+DPNto56+8XR14kj1EB7VyJVFO4qD8TyffT6ZWXQv4Omhx/6NCBwljNnFjJo3c2UkHI2jgBjxXaG1tPbY3pB3GZsyYwYABAzhw4AAHDx5k+/btHDx4kIMHD1IsFqmurqauri746d27N8OGDWPLli28+qr/3I4dO5adO3dy4MABzjnnHK688sqet8AlOzbnzL2UUkvLfr9TRO58G+UHgmZU+rZLH6uYNCulPgVcA3wGn5bxIPAVEen26/CjTkqVUg/gkzF6KaV24S9hfxn4H+VnScgDX9GfHQD8RkQuPFxZEfnt0e4pIgeVUo8At3e3Im/XlFLMmjWLxx9/jBsmFrCMBqo5F5s9pHlZp83cCChquQyf8fgIaRYFg6OI8Oc//5mLL76Y+vr6I9+wxz5xVlX1CqGQ0NryBfr1602heAdF+3FC0uRPmBM3QPh0SP0Mcn8B94dg1vvpcskRN6/AoI6M+yA59zksNQSHHUTUKYTVJPKyAFvW4rIPiwFIcQ5IIyr6JbBGIdk7kPwDuNErcLzVWMY4QuZ52O5rON4iHG8jBe9V4lSTMK/EpYmc+wgF91Us67OId9CfMFtjIPYVsBdB/gEoziMd3YkiTA2XIBRo4wkyLMYgjlCgmk9jUkUbT5PmlWDSnGERINRyOSC08igZFhFhOB4pkkzHoi8pXiDNa1TzaXKsJctyIoyiinNo4ve08jAxRpNnIy5NxDmVCMNJ8xI5VlJkOjlWE2IASc6mwGayLCPPm8SZQIEd2OzWqcjHkmUpBbZgs5cMr2NSTxXn4rCPNC8FKasBarm8y/EgzSuaIT0Lh3aNV1uO0AI4VHMZijBtPEwGf3Of7/vphBlGmvnkWE6N+CzmnPc6Qo6kugSDGlLyCFlvHqYxBJs9RBlHjLFkeJ0Cm3Dw/1hK8TwWfajjKlp4kHaeI8pYwKXIZsIcT5zTyLOaPGso8haR9K99KkXNP4K7G9p/Atk/Q8338SRFQZZgMZiYOg+bTeTlZYqyhrRafIgOsofVwavBpLlDB5cBaB28RoQReKRJMq1MB4uIMY4CW4kwgjgn6/TW6yiygwjDj6KDVe9QB4u61EGOLZhH1MGrWgcX4JKmnWfJskxz0h2qma1xZw+TrtDBGYQYToZ55FhGtVyCoZLkvdcQciTUbAxqSMtD5LwXMY3hWgdjiTGGDIspsBmHRp547BVGjhz5kdxjYxgGJ554IieeeGLFcRFBRA67OnzaaafR3t5OS0sLa9asYerUqZx88sk9i1kV9qEh3o5mB99lRsCuKtXVhr1/AO4HvvVOYRNHfTchIteISH8RCYnIIBH5rYi8LCIni8gEEZkiIsv0Z/eUJsyHK3uE+/xARP5f2e9/JyLva++OHTsWKxTiobsy7N/XpBE1/h8mBkmN//HwyOLRDlCxcWnZsmUUi0WmTp36frrZYx9RU6qW40fkWb9+CygbKKBULZj6NXVxFZiDwd0BKua/FgeU3hDoyE6UiiKkMVQ1hqoOjpuqN47sw8+4pzWpyQq461BGH/D2gapGqTpA4Xq7MI2+ePKW/3FVjaESCCmUiuHKzuC470gSiIC7HWUOAmd1cB+ThEY5ecFkzX9mfF9s9qEI45GreGb8Z0rwSOtEAoJBMviMzR5MqnBp00lUjDJUVA2uRkX52QHdsvvtwaIWhybA0tez9Cv3uuC5Lt2nFEJgsw+LBmwOBG3pI6zasagOVvHMoG6CRyZYES+vWwm/p4gECT3K28TlID7iwNbXq9I+7MaiHpdmFKEAcWaoZHDe10EGg6rgeg57sWjQiRdUMFH1fSm1YQdGzW9PpUMzGsrGuiqNcWsCowbstbqz/DhORRQI4dKIZfz/7b13mBzVlb//3qrO0z1BI2mU0yjnOMoBGYEQYBGFwdgGs9h4bQy212mf9S72flnb6x/GZlkb2xgcFmPAIhghIwkkhFDOCeU8SiNN7txddX9/1J2enkEzo8wI3fd5+pnp6rrVp+49t/p09bmf05a0PKza5WISvEA/iLTgBzUY+NXxBClOKtvr+zf7r+MHBZfYDwIt+EGO8gNfo8+Tej9w/DeV5VeQohSXaINFuZKs8yk/UPOeUoyMH+Rm3jOtbHf6X7Bx3R42btzI/fffzycJIUSL6RRCCLp3786NN95ISUmJDpgbI3CKm7S2x4VTCnTNet6FM6i6SSmvkVL+7kLU2c5KPaO1cqHqGQDJZJJ33pvL4ndW0GeoyZRZITq2caoI2dRSyask1M+ZXvpSwO2YBInFYjz++OPcd9999O7d+6Ke1yeNq1U9Q8ow27f/lLlzj/ONbx7HZQ7B53sYQ3Ry7uRF/gSyElx9IPcH4L9OtUsRtv5AwnZ+anSJXgTNz+EyehC1FhKz38GmCoN25Jg34TPGq3YWdvSnyPhcIAZmP4yc72K4x5FILyGRnostTyJEIV7XzfhcN1JZvQMRmEtaqtxSYyJB83OZfFWZWIiM/AysfSAKwH8vIvAoaVFOFa9lCgf4GEQBtyEwqeT1TPU+N13J59N41IJHixo1p5yMLi99KOA2DHKo5i2irFM5sB3J4yZ1BzrKKX6XqcoFEGQqeVyHRFLLO0RYg00UF+3I5Tr8DCTGdmpYRJpTGATIYRwhpmfyoZ0CHcuVykQbQkwjh1Ek2Ec181XA5ybA6CauB33U9cDx7SRHqeJN6irZOVXFZiNlmmpeJo5T48lDL/K4A5O21LKACKuQRHHRnlxuwCcGKfUMHzX2i8Slo7nvoju55l24RTdqWUaYD7CpUbZPJ4dRSCwqeCFTKdAZmwG04V4EBlG5jloWY1GBQS5BphAUk5xc5srvQ8oZNwJ3QcF/g8pfT9ibCNtvYHESQQ5+MYUc46ZL5AfzibJe+UEH8rgRL72IsI5a3sOiEpM8gkzKyAE6fvAuEVZfcj+orj1BOrTgvPygilca+EE+t2PSlrB8mwgrlB8UERKz8InBmetBrf0X4nKV8oMehMzP4BbdqeUDwizP+EFt6VB+99QiHn74Ybp2zY4hrg6u1s+abJpVzxjqluveLLjcJrWI6HGqWfUMOLMSW9ZrNwJfw1HPGAs8JaU8Y9G9C7b1ag+a64hGoyxatIgPPviAcePGcf311zeZA5VKpXjqqafo1q0bd95553m939XE1Xwh279/Pz//+c957LHHWmUBnCtlbByJqWNZElOt78J/MbmQcXEWsGVJD9K+wcJJzYXRGudMbW0tO3bs4LXXXuO2225jzJgxH7dJHwutcWwuNy0GzW+1vlRS0a2sJcm5TKovcBInTdgNIKV8RknOPY2zuC8K3C+lXHfmo10Yl2yh3ZVGIBBg9uzZTJs2jfnz5/OjH/2IRx99lE6dOn1k37feeotgMMjtt9/+MViquVJYsGABS5Ys4YEHHmiVAfOVhMDAQ5eP24wrAkcTuQg3rbt0sub8OXHiBFu3buXQoUMcOnSIaDRK9+7due++++jXr1/LB9BcxVx5X6CllHe38LoEvno5bNFBcyPy8vK4++676datG88//zzf+c53PlL4ZNu2bXz+85+/OuVqNGfFli1bWLZsGd/73iN4804Tk5vw0B1TFR5wikLUS4256PxRiSn2IGUSt+iWKVQipSOPVSc15qZbwyIOMo5MrQZZizD7IVx91HabFEdIcxqTfCU15vhvWp4iyVEMPHgoxlA/yTvtJGlKScsTGCIXD8U4638hLStJcQhHaqwYQwSU7fGM1JiHLrhEwy8Mtqwibe8CwGX0w1DVzWySJNmPTRw3HTNBn5Q2abkfizIM2uIWvRvK7JEmwQHVl0WqaIfIyKRZ8jgGebhF34zt9X2yX/3cX9eXqk/sI1jyMIIc3MbATFEOS9aQYj9O0ZZemKJRUQ7rCLa1EyF8GK6RiEyBihrS1laQFqbZH8OoG880KbkDKWswRWdM0b3ReEZJ2R8CCUzRC9Oolx60rO1IWYZhdMYw+jXqkxQJ9mMT+0hfNuUHjkzaUQQeJa+W5QdIUhwjTRkGIbyqtDFAmkqSHEFg4qWnyvl1Ctwk2F/vB1kFRcApElOX1uGhRya9oUk/wCbJESwqlO3dG8nspUlwUPlB+3o/aMb2+uMeVHfmCxvItqU4SYrjGPjwUoxwbm5hUUOSQ8r2nh8p0pPmNEmOKsm5XvWSc0RJcgCJhYdumaIczvVgL7asxSU6fvR6kNWXlSc8/PLnzzNq1CiGDBnCzTffTLt27fTnkaZl6srRac4bHTQ3wYQJE9i5cydPP/00JSUlhEIhkskkR48epbq6uoEWpEaTTSwW4y9/+Qv3PXATsbyniGUkpoSSGutPuXwKi3ppOD8l5Ik6qbETVNhZUmMSguIWAmIK5fyKFKWZdl76UyDvV5JzJ0nX3A32yczrhu8+jMC3qOC5jPoDODmmbeVDROQaalmU2S7w007+My7hLAKrli8Qr/uVS4JJewqNR4mznWpeoX6BsptC+RACL6f5NZL6YkG58kaCwlFNSFqbCKd+jqr5C5gE3d/EMHtwimc+IjmXK6+j2nqSlKzP0XWJYvLNf0EINzYxTvHrzCI0py9H0IY51FrPkpCrM9tNOpDv+lcMEUDKFBXyf0llyfd56EcBDxK1/krc+kd9H1JArucxUhynSj5PtkxaAQ/gFQMASCX+Qjr+K+oJ4g0+gyRGNPavQDLTyz7vNzFdJVSnfogt68fLa0wm6H4QAMs+Sm3y35FZBTf8rs/iNa8jGvs2tl2v9Gmao/H7fogQBhbVlPFMZvGyY8kkcuX1TfpBWKygJlPKW/kBX8lUE6xkLjE21o+Bkm2LsUNJzknVzk1bvqikB3/b0A+ypAfj7KKc/2vQl4V8FhcdzuwHXEc5fyChSsQ749WNtjyQkZw7xTOkOV3fVwynDXdSySvE2Jxlezva8eVGknP1alV18n01LMioWzgW5tKeh5Tk3NxGtmdLzi1r1JdKco44p/k9ZF0PCrgdn+xLuf1k/fVAgl+UkCc+CzhfZhz5Pud68Pr8MOOn9efWWXeh0ZwzrVM944pBf+doAiEE999/P6NGjWL//v0sW7aMTZs2kUql+O53v3tFSvloLg91lSE79D5CncRUHncBLiIsI8GHWJzCz3jyuBcXHYmxBltJRcbkKiUxdTO54nMIgkTlYpLsJ0UpPoaSx7146EWCnZmA0U7+A+yTGL4vYgR/CkZX7PgLpCglwW48FJPPZ/ExmBRHSHKQGOsxCJLPHILMcAI81jvHk2Hich0uOpMnPo+fcViUkZAfEmEZAjd53EUus4EUUVYSZS2SOCFmks8cDAINAo+EtQCwCbgeJOD6J8AmYS0gxlYlOTeFfO7ApIAwK0lziJTcgVsMIGR8GY8YTlruIyWd4Cmuzj/AGAr4DG46EWMjKXmMhFyNi+6EjAfxiklYnCApHQWQJAdIcRgvQ8jj87jpTZJdpGQpcWsRBu0Jmg/hM2dhU0nSWk1ULgMkudxFLnMAm6isP7d04iUQ+bh9/4bL+yUgjJWcTzL1FpDE6/kKXs83AA/J1Osk7Y3Y8iRe4xpyzK9giq4k7GXYslb11XtIIvjMzxBw/TOCXOLpt7Csbdj2HkxzEl7vv2IaQ7CsddhK/STGNmxqCDKJfO7EpA1hVpLiWJN+EGYZBkEKmEOokR9YRIixETcdKWAOAUaT5jRxdhFmOQI3+dxOLjchSRFhjVrIFyeX68nnduUH9ZrHYVYCkjxuIY9bAEmYVVl+MLmBHzi278NLMQU4GtdJDquiKk4QnuY0AUZTwBzlB5tIcpIYm3HTiQLuIsAo0pwirr44JDhEiiP4GEgBd6s5tUdJj67EpA353EmQSdjUKMm5zdTJ5Tm224RZlXVujvRgAXcQ4jokcaJsIMJqIE0eN5HP7QhchFlOQm5X14MJ5InP46ITMVl/PXD6MkaIGRRwB92Kczh2ov7Lg0Zz9ijJudb2uILQd5qbwTAMpkxpqtq3RnNmkskkHo9HyWqhqnUV4UiN5WS2pzmGnzFYVCqJKSU1lpGmOo6LDkgimHTMtEtxghyuyUhM1f0cLpTknLR2Ybgng10GIheDPBypsdMfkesS+LGpQuAnzU61XUnf4cGRGqvApA1ppeBjCEeOMa3ktNKqKINBDiIjg1WGi7YqPSA/0zeCEHVaBw4SQQiRdW5eeitpOT9CVVqz5AlMoz2WXWdDqIGtKY6rYK4CR2osF3BhcQpDtMOSC9X+de3q5bpMCrEyUmO5CALYVCJEGyxruXq/3IxMmhQxJGmQZM4XHIlBaR8AEURajuIFRr7qR7DlCQyjK470YB5G5twO4zUmY8vTkJEai2ekxmxZiik6I6nFFF0RIs/pOfsQhuiILUtxMplzG/XJCbz0U7JtPnXuIlNRL9VIFi/NKQQ+0pxscBynCp6LNJWYtCGlgl+DHExyMvJ6FhWZ7XU+maIMH4XKD+p/ncv0ZaZgh1Ttsm3vk/GD+jlzGhdtlTRcto317Rr6QZ3kXCVmluRc3f5m5rhlSrbtdFafOJJzJrmZu+zO/PXjJHXEqPvFpO54df+nOamkB7P70lb9VIWLdkhSzjmLIMi660GJ6kd3xm+MLBvdFNFvJCz+e5xEIoHXW59Co9GcFVdWjNrq0OoZmkvO1TYuO3fuZMGCBTz89Qep4iUSfAiAm57qzl9bwvItoqxAEsekHSFxEz4xBAApk9TIFzNpES66kWs4UmNhuYQIy7CpxaSAIDMIiDGqXRo78hPsxFwgCWYfzMB3MTzjicjVhFmMRSUGISU1NpWKmt1YoQWZimh+RpDPbRnJubjcTK09D4tTCPwExCSCYhYWp6jiFVKZUsKDyOcuwKSaV7OkxrqQx614RGcAbFlBOPUb0rYju+UyBhN0P4QQuVQzjwjrAQsXReRzI16KidlLiVpvYVOBQT5+4zoCppLnQ1LDQiXbFsekkDxm4mcwCXsdEes1JZMWwG9MJ2DMzuSKRuQSInIpNjUYFBAUMwiIcSTtbUTTL2DJUsCN15hKjutebGqpli+SVDJpHvqSJ+7BrAtu0ztIxp9AWs6XD9N9PW7/d4Ak8fgvSFvO3UjTGITP9whCdCJqvULCWowkiiE6kGPehcccpSTnvERTvyVpO3ezTdGLgPsBXEYxieQrpFKvIWUlQrTH67kHt/t61ScW1byl+jKNiyLymIWP3k36QZIjVPF6Ro/YzwgKuDWTwxtjO9UsUBrCPnIYSy4zSHNaSc45+b0+BlDA7YBJFa9n0iLcdCaf2Xhw/MCimkrmZtItnDvIt2MQbNIPIqyhlqVYVGEQIsRkgkzM8oNFRFid5QfX42cQMbZRzUJlu58gYwlxbUZRxJHvq5tT+Uq+bwxx9lLNfBX4ushhFHncSHXtSdKht7Ns760k5xw/SFJKFX/PmlPDKeAWJGkqmZuRA/TQnXxuwyULCct5RKVT1MikPSHjZnxiqDq3VCP5vk789ekYE8ZNY/ToC6kH8cnjavusORPNqmcM88h1C9tfbpNaRHQ42qLkXGtBB82aS87VNi47duzghRdeYM6cOQwePBghBKlUipqaGgoLCxst9LIbLODKpm5uijP8fNVyO3nG1xu3qxub5t6rufdrql3Lx2uiHcr2M2SONXfOTlv7/No1eW42IC7euZ3DeGbPmfP2g/PoS5nJTW7i3Jrq4ybatXy85to1YXsTNrRs4/m3cyxUQXbdnLmgcztzu5bH02m3atUqNm3axEMPPdTk+VyNXG2fNWei2aB5uEeuXdj61mMZRUeumKBZp2doNBeZfv36cfPNN/P222/z8ssv4/F4KC8vx+v1UlRUxE033ZSRhWoumGsqKDu7dmdu21S75t7rfNq1fLwm2nHutte3bcrGlqqInVu78z63CxrP82h3Hn3Zkp5zk33c1Pu0eLzz8IMWluI0bePFbXdh59ZEmxbH02HYsGG8/PLLRKNRAoFAs3ZoNPUIJLpK4oWgg2aN5iJjGAZjx45l7NixlJY6ShcdOnTAMAzWr1/PH/7wB+655x76DHETZQMWtQQYToBRCFykOEmUDcTZiZ/h5DAq89MvQIL9RNmg8jeHE2AMBl7SlBNlA1G2EmAIAUbhog02caKsJ8om3HQkwEi89Mgcz6KGCOuIsRkf/QkwEjdFalHXBmJsxiSXACMyCgFOuwhR1hFlI156EmAkHroipUXCXknCXu1Ibpnj8YjRzh13ewcJ+wPS8hheYzw+YwpCOHJcEkmcbUTZiCSFn+EEGIHAIG3vJZl+j7T9IR5zKh7XdAzhlIqOsF7ZPkDZXv/zY0qeIMo6EuzAzwgCjMEUecr29cr2XgQY4ehAyzTE50L8VRAB8N0O3hvrF6tYtVD+R6j4K/gHQ5vPQmgyUkpkYj4y8QbIJML3aYR3NkKY6txSamw2YRIiwEh89AcgLncSZQM2NeqcR2fZvp6E8gPH9mw/ONDID0Zj4MWSZSSsZSTsNXiNErzmZEzRHlvGibGamFyPm074RQke0eus/MCx/aN+EGMnMTZiESbAMAKMzMi5SWkTYwNRNiJwEWAUPoYghFA+vJEUJzO+XydxV+8Hm7L8YDgCgySlRNlAgoOZczYJKD9YR4xN+BiYsT3jBw3m1DByGI1JLrYME5Mridlr8Ig++I2xuEV3R9rR+oCEvRyBF685CbdRkvkC4/TlGmJyPS464hdj8IpilaW9jRgbkVj4GZax3emTNFHWEmMjJiH8jMan1Fficgcx1mNRo3x1NEK4SXGike1jSCRsvF4vpaWl9O3b9xyuTpqrnits4V1r46KlZwghngNuAsrqyhwKIYYDzwA+HJ2df5bSqQkrhPgZcA3wLSnlUlUi8QDwdSnl/6h9ngbWSSn/cKb31OkZVwZ6XBqyfPly1qx7jzmPhDEpxEU+CfYRoIQQ0yjjKSQ2foaoD9dCingUgUGC/ZzmWQyCeOhCnB0qj/ROTvIkNlECjCTKBgxyKOIbVPASCXZnFAdsorTln/DSg5raKqKh32NRQYARRNmKwKSIR6jhXaKsx0tv0lRgUUEb7sHPIADK+BUpjuBnKHF2IUnTnq+RTK8kZs/DJYqRJLBkKTnmZ3GJDtSkf4YgD5foQUpuwiNGEXI/DDiKCtX8HRcdMPCQ5DAhriHH7kdt4ruAF7c5nJS1AlP0Iej7T07yJBaV6pw3I3BRxKOY5GLJKsp4IhO8xFiPSSHt+RdOid+Q4mgj27+Ku/Y5iD4N7jEgayG9E0I/gcDnnMHbdydUz4e8GyGyDtJl0Ocf2OZ+ZOT/gdkfhA/SmxCBhzFyvg5AJa8RZQ1eiklTmelLpKSSv2BSiEkBSfYSoARZO5Z46DfKD4YSYwMmbWnPNxHCIMEBTvN7DHKUH+zER38K5G1Upb6PpBavMYmE/QGCEPnun1ItXyDBh3gZTIqD2ERoI76KR/RCYnGSX3zED9rzdWpZrPygoe0Si0peUj6cR4L95FBCPrMBqJELCPMubrojSZLmOHncgkt04DTPKR/urGwfSCGfVX6wimrebOQH0/AzhDJ+hcCNjz7E2IqbrrTjQU7yhPKDUUTZpPzgG5jkYVHNSX6JxCLAEKJsxKQNRTxKRfrnpDmEV4wiKbcjSVNofpdk+n3i1t9xib5IYljyCAHX/fhc11JbW0sq5xUSbMfLIFIcxiZMG/EVUqKMauapRY9uUhwhxHRy+RQA1XIuUVbhoTcWlViUk8+9AFTxf438YCw54lrKeBKJTYChRNlAxfEQL/1vlEmTJnH99de3+MvH1YT+rGkpPcMnVy9qfeXVXe33XjHpGRdTcu4POCUMs/lv4IdSyuHAv6vnCCH6q9en0LCKSxnwiKirJKDRfMKoqalh9erVDBrlXNhz+RQ5jEfgI8FukhxGkiTIOPz0VwoC5VhUApBgLyBVEDESkwLi7CHJMWwi6i5gX/wMwyZMkuMk2ItJIX5GEGIqINVxnAVZFhV46YeP/uRQgiRBgsPE2YNBgBzGEuIaAOJqEZxNnBRHcNMFH4MJMgWwSLCPlNwGuPAbN+A3bgYgZW8jaW8HJH7zJrzGJAwKMxJwzrk5xw4xXR3PJM5u0vZ2wMLnuhmXMR5TFGPJPaTkESwq8dIfH/0yttfJkCU5hCRBDuPxMRAv/bEoJ8VRUhzFTVd8DFKLySwSHIDke4AXAl+BnEccw5LvOX+lhJp3wNMT2twLHf4FkFC7GJlaBoAIfBXh/xLgQibfzzq33WoB3YRMABVnd0YzOcSnyGECAj8JdpPmGJKksn0AXvpicTqjUFHvB1PxM0L5wV7S8jCSGjzGRNzGUDxiPJIa0vIQCXZi0hYfY8jhU44fSOf9674UNfaDJEdIsBeBnxzGEWJalu17lA9fk/HhOv+oO2cwCTKVENNVu11qnzofHoFJfuZYDf3gGoJMVn6whwT7AYsgk/AxGDedlWTeMeUHA5TtYzO2O35wWPlBCT76K0WRCpLyKGkO4aIHXoYTEJ8C0iTlblL2FsCNz7wRn+sW5cNblBtI1ZeF+BlNUPVlUu7OSNmFuIYQkwGjUZ/sUn05iSAzMtvq/CDIDHKYpPxgl/LhJDmMw8cAju/pyJ9+cZRZN09j5syZOmDWnBMSkMJsdY8riYuWniGlfF/dLW6wGTK/K+eBWpoNJo7+jqRh4topYDnwBeB3F8s2jebjJJlMsmXLFrZt28a2bdsoKSlh7NhuhHmDMMtx0R5JHA/9cNMZMImwDoGHBHsxCGEq2TYP3QBHC9ZHfywq8dALNx0QeImyBZM2xNiKwIuHIjx0I8lBkhxssHIfwCQXg6DS7+2stHlNPHTCSzdibCPOjoyqQt37C7y4aE+KUlIcI8o6HJG6riCKScuDJOwV1BXmcBm9cYmOxG2IW4vwGIOxKcctBmb6yUM34uwgwipVQc1yqigafQBBIr0Aj+saLLkPQ3TFRScMckiwK8t2F246AY5yB5hEWYuBjwS7MAjhoiMu2pHiSCPbu4B7NKS3QfxvYDsBKm51A0QIyBkH4fedR80CZ3vOWISrHTK5FBn/i5PWQRrhmMhf1QAAJoFJREFUHpV1bt2JsZk42zNSb05FO0mUdURYjosiJDE89AWKSGVs95Jgj/KDgkZ+sBIf/ZQf9MQluiDwkbRXYYr2JOUaBH5cogtu2YMU+0mxjwSOeolHXbJdFDTpBx66EWOr8oPjWf5jEWUDYVYqCbU4Hvo3OOcUR4ixHlsVOfHQA5eSnguzAh99sKjCS3EjP9hJhNUqZcOpnuehKyCIsIoAo0hxVFX+K1K271S2r2vkB52UH6xXfrAbgyBuOmJSRJqDWBwhJlcCArfogTT6YlkHSdgfIJVutsvoq9xA4KEHSfaRZH+9Oo7oAer4EVYryTg7M1aOLd2Js4k4W7P8wBmDGGuIsAw3HZDEcNNPqY2YROQaNqw6wfzXdnHr/YWMH3ANGs25I6CFNR6a5rmo6hkqaJ6XlZ4xAFiAExgbwAQp5SH12v8AE4BvSykX17UFbgb+AQwCfolOz7jiuVrHJZFIsGLFChYuXEjnzp0ZOnQow4YNIy8vD4lUObXr1c/KowkySX2oHyDCWmJsI4fR5DA+U5kNIMZWIqwjyRFyKCHIJEyCJDlKhNVE2UiAkeQwFg+dsAgTZjkR1uKhGzmMxM9gwBkbXyhOhJVEWIefIeQwBi89sIkT5gMirMdFGwKMUjnGzvfcNFWE+YAoa/HSlxxG46MfUqaI2YtIWB+A8OEzJuIzrnHSCqw1JOxlpOUBfMY0fOZ1GT1iiU2EVaqYQ5IAowgyEYGblLWRZPpdUvYmvOa1eF03YhjtSFGmbF+Pn6HK9u71YyAPEGU1MTYToIQcJuIW7UlTSZgVyvZ+yvY+IGMQfRZiL4EIgX8O+L9Q/0GTKoOyp+H085AzGgo/BwW3IaWFjP0ZmXgVZALhuw3hvw+hSpLX9WWUdZgUqL4cBRJirCPKetIZP5hMJJzCEzxFlDXE2EaAMQSZkKnU6PjBNiKsV34whiATMQmStg8StxeTsJfjNSbiMz6Fy+iOJWuJyqVEWYmHHvhFCT4xLHO8FKea8YPlRFjXwA+ATE67RTUBRiofVrnJMkWYD4ipL4B+5ctCGETZSpT1pDia8f06zWTHD1YTZYPyg5EEmYDATZxdRFhPgj31fUK+8oMVyvah5FDSIG8/wUE1p7Y2mFOWrCBqLyEql+MVg/CL8XiNgUiZJG79g4T1PgI/XnMKXvNahDCora0lEISIfF+lWnTDL0rwi2FZPrwBSTrLduf+lC3jRHifKGswaUOA0fgZo8ZzLTHWkaZC+eoUDOFjf+lqXnn5deLxMHM+X0LvLjMbXA809VytnzXZNJeeMWq4X656t/flNqlFPG23XTHpGZc6aH4KWCqlnCuEmAN8SUp5bUtthRB/AhYBY9FB8xXP1TYuVVVVLF26lOXLl1NcXMwNN9xAt27dWm74MXCljE0qlWLDhg0cOHCAgwcPYts211xzDWPGjMHl+uStZ75SxuVq5HKNTTgc5s0332TTpk3cdNNNTJw4EcPQdwmbQ8+bloLmgFy5uPUtHPUWbr5iguZL/WnzBUAlBvIK8OxZtvsv4G/A+83tJKWktrY28zwSiZyHiZpLzdUyLhUVFSxbtoxdu3YxZMgQvvrVr9KmTRuABn7amrgSxmbv3r28/fbb5OXl0adPH4YMGUIqleKdd96htraW8ePHf9wmXnSuhHG5WrnUY2PbNhs2bOC9995j0KBBfOtb38Lv92ufOAt0H50NOg/+QrjUQfMxYCrwHjAdslZENIOUcqcQ4kMcNY41Te0nhPjIt8qr/Vtma+VqGJdXXnkFn8/H9773PXJycpzKfrxJlLWAhY+h5PJpTFUGOc6eLMm5YSr1wUWKMiUxtTsj42VS338JDmbJdTmvG3hJywqirCPOFnwMJcBoXMIJ2mN8SC3vq8V7HQkyMfMTeyBUlyqSLTXWHklaSY1tyZIa6wOAJSuptV8lwSbAjV+MJSRuRQgPUtrE5Tricp2jdGCMwcswJTV2kCgbSHMKP0MztjuFtRcTZZ3Kce1NLjN5Z/5mVq9ezR133MGQIUMa9Pe+ffvOeA3IxunLjcTZmdWXudiylmR6CSlrGaYxEI9rGi6jp9PGPkjEfp2U3IFBIT5jIgFjFkIIpIyRTv2DdOpdDKMnLvf1mK4hSiZtu5JJswgwDD9DERjYJKnmLZUnbOFjMPnchEnTfgDg8/moqKjg2LFjHDp0iMOHD1NaWsqwYcO45ZZbcOWcOrMfUEGUDcTYhp8hBBiJS+VCN+cHFjUZaTnHD0Y4fiDTxFhPjA0Y5BFgFF7hSM7Z9ikSid+QtpYDHtyua/F6v4QQXlVoerNSNXETYDg+BiIQJO09JOyVpDmOT5TgM8YjhE/5wRKVtlTnB9dlKgkmOUqUjSQ5qOQYR2IQQFonIT4XmXgTPNOd9BhXfZ502j5Kwv6AlL0RjzEBnzkFQ+RDuhxO/9mREAxNhsJ7IOD0R1IeoVa+RZI9mBTgF2MJ4vxQGgy6idsriMvVuOiMzxiP2+iDlJI4W4mxQY31cPyMQIg6P5hPlI1AWvnBrIwfAOzZs4dXXnkFv9/Pgw8+SJcuXZq75GjOwNXwWXPeCHHFLbxrbVy0oFkI8SIwDWgrhCgF/gN4EPilEMIFxIEvncMhHwc2Xiz7NJpLTSqVYuTIkeTkOLmZtbxLlFX4GYWL9tTyDyQWbbiPGNuo4EVM2mCSlylhHGQqp3hGyaQNooaFRNlAex5RknP1UmNuOlHNPBLso0DezmmexiaCnxGEeZcoq2kvv40UFhW8iMBLIfdRyVwq+RtuuiBxc4pnsSjHz3CVw7yKIr5BjQpivfQiyWFibKYNn8XPQGrsl0myjaCYTZqjxOQHGAQJihuJyH8QkW/jUlJj1fbvCYk5mKKzkhrLtv0AhdxDjK3U8g4eupHHLCp4kQpe4NixNowcORKXy8XevXspLi7OKAbE43Esy2LHjh1nHA+bCIngG7TvAgExRJVZ3kARjxBJ/BhL7sFtjidpLSZpLSLk/SmG6EKN9Rtsqsg1v0zUXkDU/jsu0RGvGEki9l9Y6eWYrnGk0ytJp97GF3iCmCtKNfNwUYTARSWvkKaCXKarIHANfhWE1rCAKmwK+dxH/GDP8bmsWfA2xw/ZlJeXk5+fT4cOHejevTvTp0+nqKiIJUuW8KP/fIxpt8CwsQV4RJd6P+AOTvEb5QfDqGUJEdZQxDeQNO0HLtpk+cEwlcO8miIeoZZFxFiNh2JSHKSCjRTIL+ATg4knnsay1uD1PIBl7yeVno8QeXi9n6eWxdSyBDddkdRQwV/I49N47HyqrSedRZmiG2H7ryTlLvJcDxFjG7W8i5uu5DGTCl6ighcp4lukKeMUv0HgwksfavgHcbbTVn4RWfUZsI+AdzbEnnMWZBa8jTCLsGQFNakfIknhMUqIWa+QsJeR7/4JYu9tEFkL+bfC6T/BqWdhwAqkrz9V8o9YVJMvPk9EvkdYvo1LtAd6UWM9R1JuwiOGkJBbiFvLyeNbpMQpangdFx0QuKnmr1iUE+I6wiwlytpGfmAhKmaxadMmNmzYQGVlJbfeeiujRo3SyhiaS4K8qKJplwchxEycNW4m8KyU8ieNXp8GvIEjWwzwqpTyR5fCloupnnF3Ey+NamJ74/YHQa1Ocp5v5uJK4mk0lxTLshrkHNbJg3koRuBG4M5sq5OmymU6Ai+VHCfObjz0UPJYE/HSDZsoCfZgUYmLwgZSYwa5pDmlJOeOYhPGzyh8OIoUMTaQ4jgCL3Wr+G0SeCkmxiYsqrDwYFGOl374GYRBDhGWk+AQcXYrybnx2MSpYi5xduNnIBblCDwYFOAmhzjrsCgHICE/BFzkiBmATbV8joT8EIMoIAkyDZMQacoyUlt1/eKlLxKJSSEWlfTpW8LmTVvYsGED4XCYH//4x3g8jiJl9+7d2bBhAydOnDjzeBDmdHklLsNPyfg4A0p64M0/6EjVyT2Yog8uYwIGXUhYr5C2t+MxO2BThUl7pLTxiMGk5UEseQopJVZ6DUJ0xHTdgGmOJpl4Giu9jrjKq85lOiCo4K/E2U0u0zNygV6KkbaLZMIkGj9JMn6cstgajp9KUFUa4Ojhk5w4EWbsdJNZ136FTp06nTGHdc6cOQweC397cRl7Nkju+9Iw0q6yBn7g/CrQX/nBJlKcaKDm0NgPnP4qx0tf/AxUfrCCBIdJsBNBgACTkMSo5mWlrTwYKU8CPoRoh2mESLMEW57M8nGTEFOUpvNfSbALZAiQ+I1ZGOSRlsdJym3KBqevfBk/aKPsc+QMHcm5abhoj0WlIydn7XYCZs90hHcG0siH2B8hvRHMmaTtPUhi+IzrcRn9kDJCSm7GTu3GjKyFnDFQcAf4B8Hx/we174GvDxbVmLQFKfHSnxSHsahAyp4k5TYM2uIVE3GLgUTsl0jJD0kIZw44cnIGVfyZBLsIcR3pjB/0pKoizuqNKXZu2EBl2WaGDBnCzJkz6d+//ycyR1/TWhBwhd1pFk6FqP8FZgClwFohxN+llB822nWZlPKmS22Pnp0azUXCtm1Ms/6CFGA0cTZTzasIDCQpApQA4KErUdYTZqWquhbHQ59G8lh+JTkXzEjOuXGE6cOsypKc66Ek5zzE2IyLdsTYjMCLm/YIfLjpTIJdpDiCTRQXbZUUXTQjNealu5Lrqpcai7ONOLuyJOec9/eLcYTla9TKF5FYgIFPjHVsFD1Jy8PE5TokUaed6IGh2kZZpXSHq/DgVKTzM5hallLLYgReJDECjGbqlGmMGjman/zkJ3zhC1/IBMwAkyZNYtKkSU2OR5pyTshfcHQ/fLjqJO/+50E69/QwdVwZPft1ANcebHmIpLUIECTiXThZcZwjZX04Vb6bqvI/EAlbBHLcFOZWkRtayqCB/Qn4tmLb27DSKwAwzIF4iCmpsbVZwWlXysrKmL/gNDt21JCIP0cqIXF7we+L4ff9DrcvTagwRccuZUy8riNFvSPkeYfgrs1rdtFXz+5Duf/bm3j12Spe/POb3PiFKF6jZ8YPomxVfrA1Iw9o4M3yg1JsIhk/EJhKvm8PXro1kpzrTpwtJNhBiqPKDxyFErfrehLJ3xJP/BKnfpWB23Wt2qcbKY6qlJV4ZptbFBAD4vaSLOnBfsoPBio/WILAgySeqZTpoQuO5NwacjKSc+3ALAbRxtHTdg135AJxg8v58ugyegAuEvb7CBEiJbcgyMVwFYO3j3OnOb4VTj0PCMgZjRAu/HIUlbE1bNr6AqUHExw/LLETSyks3IHpDRIIVdCucClFXU7QvjPkBnphK+m7KKsyX1bdSnIuXl7Mqo2r2bHhj1Sesug71M31syYxrN8tOlDWXBbqdJqvMEqAvVLK/QBCiL8Cs4HGQfNl4aKqZ1xutHrGlcHVMi5PPfUU1157LQMH1msPp+Up4jiVxrz0w00XJzdW6fM6+b2V5DSQnNufJY81hhwmNJCYirKFqJIa89tjeH9ehIMHjjJgcBeKh4bxt92u5L0m4KYztm0jDIuE2EOSw7jpjI9+GHiV5Fw0I79WL9fVC5uYStdYh4tCAoxUAYxASkmawyTkDqdUthiakUOTMklELiEuncDBJ8YSEFOV1NhmZftRJZPmyOUBWNQS50MsqvHQCy+9kDb86le/onPnztx6663nPCb18n1bcCVHsH9THmtXfcihQwfo2s2L23OaqoogFRUgpUFhYSGFhYUUFBrkF8YJBQtIxtoTrk1x+PBhDMPii/d5SCXncfBQXw6XFjN58ufJCfoJszIjNWZEB7Po9TI2bdzM1KlTGTOuH0bOYdxeCBiOHrfgTH4wypGcq021OGeibKE6uZbn/2cLPXt0Zc7tX8YkRJLSjGSbIz04LpMTLEkRV0V0sv0AIG4dZ9+xRezZt4Xyo7mkorkkooJEIkZBO5tOxdUMH9OZAt84/IxROd4S295N2tqAwIPLNR7D6JR5L8d/nNdyGKmKoBjE7TXE7RWk5UF8xmQCxoyM9KBFuJEf9MyUoY6xU+Xt78nI7LkoQKZ3I2N/gvhL4L0Z4fsMwlOS6auUvYO4tYSkvQqvcQ0+8zpcRmdIHIST/wOnfw95M6Htfdih69izZw8rVqxg67bN9OpTQHGfLvTqOpqcQCGnT58mHq+ivGYDZaf2cfyIh5PH07Rt255u3boSyKtFuk5gmBKf2QUj3Y2tW7dTXl7OkGH9GDgil1792pBj1vuB5uJwtXzWNEdz6hkjR4TkB+8Nv8wWtUxO/gdN2iyEuAOYKaX8J/X8c8BYKeXXsvaZBszFuRN9DPgXKeX2S2GrDpo1l5yrZVyefPJJZs6cyYABAxpsl1Kybt06CgsL6dWr10V7v2g0yvPPP08qlWLq1Kls27aNrVu3kkgknFQCy0JKiWEYeDweioqK6NChAx07dqR9+/YEg0GklBQUFOD3+zO52K0BKSWbN2/mzTffpE2bNjz00EMN7uJfKOFwmP3795NOpzOBck5OTrN5pKlUiscff5wpU6ZQWlrKzp076du3L9u3b2fixIlMmTKF6upqDh48yMKFCxk6dCizZ88mEAics33nMmcikQhPPPEEEydO5FOf+tQ5vU8ymWTJkiXs3LmTQ4cOkZ+fT3FxMV27diUYDOLz+fB6vZw4cYIPP/yQffv2MWPGDCZPntzgrv+VQCqVwrIsXC4Xpmk2GGspJeXl5axZs4aVK1fi8/kYP348JSUlBIPBBsc509ik02mOHTvG4cOHqa2txbKszANgwIAB9O3b96L6sOajXC2fNc3RYtC89KwyZi8rOXlLDwGnszb9Vkr5WwAhxJ3A9Y2C5hIp5cN1OwshcgFbShkWQswCfiml7HMpbNVBs+aSc7WMy7x58zh9+jT33XdfZls0GuXPf/4z5eXlRCIRunbtys0330znzp0v6L327dvHn//8ZwYOHMjtt9+e+TC2bZtkMolpmpnAQAhBJBLhxIkTmcfJkyeJxWLYtk1NTQ3hcJhp06bx6U9/+mNdgCSlZNeuXbzxxhtYlsWnP/1pBg0a1GoWRe3cuZOXXnqJMWPGMG3aNAKBAOXl5SxcuJC1a9fSrl07unTpwvjx4+nd+/yLCJzrnKmoqODnP/85I0eOZPbs2WcVnO3evZsXXniBbt26UVJSQs+ePT8SIDbm6NGjvPHGG9TU1PDoo4/i8/nO2sbLTTQaZd++fezZs4d9+/ZRWlqKYRik02ksy8I0zUwAnUql8Hq9jBo1ivHjx9O1a9cmfe5quZ5dieixaSFoHpkrly0dc7lNapFg7uLm7jSPBx6TUl6vnn8fQEr546aOJ4Q4CIyWUp5uap/zRQfNmkvO1TIu8Xicxx57jK985St07+7kfD7xxBN07NiRO++8E4Bly5axcOFC+vXrx4wZM2jXrh1er/es3+PgwYPMmzePEydOMHv2bMaMubALYN3Y1NbW8stf/pLhw4dz0031aykSHKCGxSTZj4siVYFwHBbVVPMPlTPrIcBI8piJwH3ONkQiEXbt2sWOHTvYsWMHbrebG2+8kZEjR161xRzOZ86Ew2H++Mc/Eo1GueuLg/AU7sCiAi99yGVGJkUjHo/z+uuvs2XLFj7zmc8wdOjQc3ofKSUvvvgitbW1/NOXP9PID0aQxw2AQQ2LiLIBmwg+BpDHDbgobHAs27ZZuHAhRUVFjBgxAiklYRYTY42yvR8hbsAtOhPjQ8IsVaklXQgyiQDDPmJfZWUlCxYsYO3atXTv3p3evXtTXFxMz549M3fH636JqQugXS7XWc/Dq+V6diWix6bloPn9pWMvt0ktEsp9p7mg2QXsBj4FHAXWAvdkp18IIToAJ6WUUghRglPno7u8BAGuDpo1l5yraVxWr17NokWL+O53v4vb7eY3v/kNw4YNY9y4cZl94vE4ixcvZvXq1VRVVWGaJnl5eeTm5pKXl0deXh75+fm0adOGwsJCqqqqOHDgAPv27eP06dPMnDmTCRMmXJTFQ9ljU1tbyy9+8QtGjRrFrFmzkKQ5zo+RpGnDZ6jhbdKcpi0PEmYZx09tR9aMxh2owQjuwR0fh1U9iJqaGmzbxu1243a78Xg8mf8ty+LUqVOcPHmSsrIyjh8/TllZGb1792bAgAEMGDCAoqKiVnNn+ePifOeMbdu8/e5fWPLOSmbd1YURg68j4nkNkzyK+Bd27dzFCy+8QJ8+fbjjjjvOK3UEnFSHH/7wh8z+XAc69TtOLteR4gQxthBiOgZ+qnkLL33x0Z9q/o6H7rTLUh1NJpM8//zzhMNhampq6N27N7PnDCTi+StuupLDZKp4EZMC2vBVToqfIvDShruoZC42YYr4Ji7aAlBdXc2CBQtYs2YNEyZMYMaMGZfkunM1Xc+uNPTYtBQ058ml77e+YlC5oQXNVgRUKRe/wJGce05K+bgQ4iEAKeUzQoivAV/BWY0cA74ppVxxKWzVS3Y1motISUkJmzdvZt68edx6660MGzaMLVu2NAiafT4fs2bNcgJTKYnFYlRXV2ceNTU1lJeXs2fPHsrLywmFQvTq1Yvrr7+evn374naf+93csyEUCvHII4/w5JNPYhgGM2ZOQBJXOrtpvPQlzWnSVPDewj2sfKeWdu22E4vGqQ3X4PUtpSB3N7m5uZimSTKZJJVKkU6nM/8bhkG7du0oKiqiT58+TJo0iW7dul2yc7raMAyDyTO607b3Vha8WMNrf/wDbo8kt6CaXP+TnD5dzj333MOgQYMu6H3cbjd33303f3j+GWbfF2JIcS5ed5AYW0hTgYEfQC009GOQQ1pJEoIT4D7zzDMUFRXxxS9+EcuyeP7553nz9aVMnwNeBgACk7ZYlCspOhsvPbBJZuTy0lQRq/WycOFCVq5cybhx4/jBD35AXl7emQ3XaK56rrwbElLK+cD8Rtueyfr/aeDpy2GLDpo1mouIEIK7776bxx9/nCFDhjBo0CBefvllUqnUGQNDIQSBQIBAIEDHjh0/Bosbkpuby6OPPsqTTz4JwKjre5MUe6lmHjYRDILIWFeW/aOKh/4jl9x8A/AiKaCQ+/Bx/nm8mouDn4F06fkeX/zXJEJ2IBwOk6jog6weTZ8+ffD7/RflfQYNGsTsO8ax5I1VvHLiWQoKDYL5BoW5J8nPy8fITxLKf51O3f2E8pMEmYqUkgMHDvDcc88xYcIEbrjhBoQQuN1u7rjjDn70ox9xze15hM13MPCrIi1j8IguuOlEnB1Ki7qGZLgN8xdtYuWK1YwZM4Z/+7d/Iz8//6Kcm0bzSUSiKwJeKDpo1mguMqFQiLvvvps//elP3HvvveTn57Nr1y4GDx7ccuNWQF5eHo8++ii//vWv2b8/l9s/eyvevDLctMfHQPYcOky3rj3olX8HcXYj8OBjIG71M7nm48VFIUU8SoztWKKKNqFivKHijGzbxWTi6HsoGT2Z6vh2Kk4niVe3I1wlqa6upvLYIA5tK2X+/53G5/PTqeNeDh9ejNfrbZCPv3v3bpYuXcquXbu45pprKDKvJc5WLCrx0gcPfRAYtOXLJNhFZWQXq96tZOWyXYwa2YXvf//7tGnT5qKfm0bzSUQHzReGDpo1mkvAsGHDOHr0KPPmzcM0TeLx+Mdt0jmRn5/Pt7/9bebPn8+TP/4bN954Ix075lNQEKOqqoq8vDw8dMOjCjdoWhcmIYKMa3nHC0Qg8NCNdr5utOsCdPnoPlJKTp48ybFjx5gzZw5t2zb8crV27Vp8Pl+DtIocJn7kOPFomsWLD7F06WqGDx/O97/3fQoLCz+yn0ajaQqBLrR8YeigWaO5RNTlLV+puFyujOTbe++9x+rVq6msrKS6upqpU6d+3OZprhCEEHTo0IEOHTqc8fV+/frxzjvvYBgGr776KkePHqW2thYAj8dDOp0mEokQDocZMWIE3/nOd2jXrt0Zj6XRaJpH32m+MHTQrNFomqW4uJji4uLMc9u2P0ZrNJ80Ro4cyYoVK/jBD37A2LFjmT59ekYBoU5zPBgMEgqFWrUutEbT+hFIdNB8IbQYNAshngNuAsqklIPVtpeAfmqXfKBKSjn8DG0fAR7E+U3gd1LKX6jtnYD/A2qBz6oqLo8B3wF6SCnL1H5hKWXzavsajeaycrVqJ2suDYZh8MADD1BdXU2nTp0+bnM0mk8uArjK5TwvlLO50/wHHCmPP9VtkFLeVfe/EOIJoLpxIyHEYJyAuQRIAm8LId6SUu4Bvg48DPQC7gXqpENOA98Cvnse56LRaDSaK5CcnJxWVcZdo/kkIvWd5gumxVtGUsr3gYozvSacCgRzgBfP8PIAYJWUMiqlTANLgVvVayZgq0f2157ngLuEEHoptEaj0Wg0Gs1FRAqj1T2uJC40p3kyTunCPWd4bRvwuBCiEKdCyyygrnzf08Cfce5Q35PVJowTOD8C/McF2qbRaDQajUajAUCAXgh4QVxo0Hw3Z77LjJRyhxDip8AinGB4M06JQ6SUh4ApTRzzKWCTSvvQaDQajUaj0VwEdHrGhXHeQbMQwgXcBoxqah8p5e+B36v9/wsobem4UsoqIcRfgH8+i30z0kQAkUikZcM1lx09Lq0XPTatEz0urRc9Nq0XPTYtIZB6IeAFcSF3mq8FdkopmwyEhRDtpZRlQohuOAH2+LM89s+BtS3ZJ4TISBPV0fi5pnWgx6X1osemdaLHpfWix6b1osemJfSd5guhxQxsIcSLwEqgnxCiVAjxgHrpMzRKzRBCdBJCzM/aNFcI8SHwJvBVKWXl2RglpTwNvAZ4z2Z/jUaj0Wg0Gk1zCKQwW93jSqLFO81Syrub2H7fGbYdw1nwV/d88tkaIqV8rNHzbwLfPNv2Go1Go9FoNJozIwGpy2hfELoioEaj0Wg0Gs0nHSGuuDu7rQ0dNGs0Go1Go9FcDeig+YLQ9+k1Go1Go9FoPvEIVRWwdT1atFqImUKIXUKIvUKI753hdSGEeEq9vkUIMfKSdB/6TrNGo9FoNBrNVcGVlp4hhDCB/wVm4MgWrxVC/F1K+WHWbjcAfdRjLPBr9feio4NmjUaj0Wg0mk88giswwaAE2Cul3A8ghPgrMBvIDppnA3+SUkpglRAiXwjRUUp5/GIbo4NmjUaj0Wg0mquAK+1OM9AZOJL1vJSP3kU+0z6dAR00Z7N+/fr1Qle30Wg0Go1GowE43dQLW9afWNBF/Ffby2nMWeITQqzLev5bKeVv1f9nCvJko+dns89F4YoOmqWUoz9uGzQajUaj0WhaO1LKmR+3DedBKdA163kX4Nh57HNRuOKSWzQajUaj0Wg0VwVrgT5CiJ5CCA9ONeq/N9rn78DnlYrGOKD6UuQzwxV+p1mj0Wg0Go1G88lESpkWQnwNWACYwHNSyu1CiIfU688A83GqUe8FosD9l8oe4Sw21Gg0Go1Go9FoNE3RatMzlGTI34QQO4UQO4QQ44UQw4UQq4QQm4QQ64QQJVn7/0xtm6qevyaEuCXr9V1CiH/Lej5XCHHbZT2pK5AmxuElNQabhBAHhRCbmmh7UAixtW68srZ3EkIsFkK8IYQIqvcoF2pVp3oPKYToop7nCSEqhBCt1l9bC+c6XnreXHzONAZq+8OqP7cLIf67ibZ6zlxmznW89Jy5NDRx7XpMCHE06/o1q4m2et5oLgut2TF+CbwtpewPDAN2AP8N/FBKORz4d/UcIUR/1WYK8FX1/wpggnq9EAgD47OOP17to2mej4yDlPIuKeVwNQ5zgVebaX+N2jd70ebXgYeBZ4F7pZRVwAlggHp9ArBR/QUYB6yWUtoX6Zw+yZz1eOl5c8n4yBgIIa7B0RIdKqUcBPx/zbTXc+byctbjpefMJeVMn/kAT9Zdv6SU85tpr+eN5pLTKoNmIUQuzkXp9wBSyqRydgnkqt3yqF8daQK2er1OemQ59RNhAjAPaCccegIxKeWJS3wqVzTNjEPd6wKYA7x4joeuGy+bpsfryUbP9YdOC5zHeOl5c5FpZgy+AvxESplQ28vO8dB6zlwCzmO89Jy5BLR07boA9LzRXFRaZdAM9AJOAc8LITYKIZ4VQuQAjwI/E0Icwfnm/30AKeV2IAB8gFM+EWA9MFg4qy0nACuBXTjfMCfgTBxN8zQ1DnVMBk5KKfc00V4CC4UQ64UQX8ra/jTwG+Ah4P/UtszdGvW+rwB1dwz0eJ0d5zReet5cEpoag77AZCHEaiHEUiHEmCba6zlzeTmn8dJz5pLR3LXra0KILUKI54QQBU201/NGc1lorUGzCxgJ/FpKOQKIAN/D+fb/DSllV+AbqG+lAFLKh6WUo6SUi9XzBLBdHWccsBrnYjYB/W3ybGlqHOq4m+bvMk+UUo7EqQv/VSHEFAAp5SEp5RQp5c1Sylq173Jggrozc1BKGce5ORoERgFrLuqZfTI55/HS8+ai09QYuIACnD79NvByXV5lI/Scubyc83jpOXNJaGocfg0UA8Nxqrs90UR7PW80l4XWGjSXAqVSytXq+d9wJtQXqM+ffQWnJnlzrMD5ySckpawEVlF/IdPfJlumqXFACOECbgNeaqqxlPKY+lsGvEYz46XufhYAN+N84IBzB+d+4ICUMnxBZ3J1cEHjlYWeN+dPU2NQCrwqHdbg/Fz8kcpces5cdi5ovLLQc+bCOOM4SClPSiktlWP8O5qYD3reaC4XrTJoVvlfR4QQ/dSmTwEf4uQwT1XbpgNNpQXUsRz4MrBZPd+CcyegG86dAU0zNDMOANcCO6WUpWdqK4TIEUKE6v4HrgO2tfCWK4FHqL+QrcRJydF3as6CCxmvRuh5c540Mwav41yzEEL0BTw0Kner58zl50LGqxF6zlwATY2DEKJj1m63cob5oOeN5nLSmoubPAy8oPLE9uN8C3wD+KW6axYHvtRMe3AmQC/gx5ARyS4DjujVsWfNmcYBnKo8DX7qF0J0Ap6VUs4CioDX1C+aLuAvUsq3W3iv5TgC5XWSQStxxk9fyM6esx6vZtDz5sI40xhEgOeEENuAJPAFKaXUc6ZVcNbj1cwx9Jy5cM40Dk8JIYbj5CwfxPlioj9rNB8buriJRqPRaDQajUbTAq0yPUOj0Wg0Go1Go2lN6KBZo9FoNBqNRqNpAR00azQajUaj0Wg0LaCDZo1Go9FoNBqNpgV00KzRaDQajUaj0bSADpo1Go1Go9FoNJoW0EGzRqPRaDQajUbTAjpo1mg0Go1Go9FoWuD/B57GN8ZtiPRaAAAAAElFTkSuQmCC\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 648x936 with 2 Axes>"
       ]
@@ -561,8 +656,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
+   "execution_count": 14,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2022-03-09T16:17:11.067502Z",
+     "start_time": "2022-03-09T16:17:10.931959Z"
+    }
+   },
    "outputs": [
     {
      "data": {
@@ -570,13 +670,13 @@
        "<AxesSubplot:title={'center':'TC 1: Emanuel 2011'}, xlabel='Intensity (m/s)', ylabel='Impact (%)'>"
       ]
      },
-     "execution_count": 13,
+     "execution_count": 14,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEWCAYAAABxMXBSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAxQ0lEQVR4nO3deZyP9f7/8cfL2HcyImOZCiWyHKdNZT2JZG0hiZYjrdoP7aVT/dLitKeNE4miKCnlSw4ia1KoFLKUJbLMjDHm9fvjc9GQZcbMZ675zDzvt9vnNp/rel/L6/0xPq95v9/X9b7M3REREcmsQmEHICIisUWJQ0REskSJQ0REskSJQ0REskSJQ0REskSJQ0REskSJQyQGmVktM3MzKxx2LFLwKHFIrjCzHRle6WaWnGG5p5mVNbMhZrY6WPdjsFzpEMcbZGbfmFmamT2YxVgeNLPdB8S0NSfqmReYWTEze93MVpnZdjNbaGbtDtimtZktM7MkM5tqZjUzlLUM1v1hZisPcvyj/uwlf1DikFzh7qX3voDVwIUZlt8FpgCnAOcDZYGzgM3AaYc45I/AXcDEowxpdMaY3L38UR4nLyoM/AI0B8oB9wFjzKwWQJCMxwXrKwLzgNEZ9t8JvAHceYjjZ/ezlxinxCF5wRVADaCLu3/n7unuvsHdB7n7xwfbwd2Hu/skYHtOBxN0AV1vZj8Ef7EPMrMTzOxLM9tmZmPMrGiwbQUz+8jMNprZluB9QoZjTQv2nxkca/LeVpSZtTCzNQece6WZtQneFzKzAWa2wsw2B+eteKT43X2nuz/o7iuDz/Ij4Gfgb8EmXYFv3f1dd08BHgQamtlJwf5fuftbwE+HOH7UPnuJDUockhe0AT5x9x05cTAzq2FmW82sRjYOcz6RL9oziPx1PRToCVQH6gM9gu0KAW8CNYkkv2Tg+QOOdRlwJVAZKArckckYbgY6E2k5HAdsAV7IakXM7FigDvBtsOoU4Ou95e6+E1gRrBc5IiUOyQuOAdbn1MHcfbW7l3f31YfZ7JIguex9TT2g/P+5+zZ3/xZYAkx295/c/Q9gEtA4ONdmdx/r7knuvh34N5Ev+ozedPfv3T0ZGAM0ymRVrgXucfc17r6LSMvgoqwMiJtZEWAkMNzdlwWrSwN/HLDpH0CZzB5XCjZdkSF5wWagai6fc4y7X36Y8t8yvE8+yHIVADMrCTxDpIVSISgvY2Zx7r4nWP41w75JRL64M6Mm8L6ZpWdYtwc4NjM7m1kh4C0gFbgxQ9EOIuNIGZVFXU+SSWpxSF7wOdDWzEqFHchRuB2oC5zu7mWBc4P1lol9dwIl9y6YWRwQn6H8F6Bd0Hra+yru7muPdGAzM+B1Ikmmm7vvzlD8LdAww7algBP4sytL5LCUOCQveIvIl+RYMzspGBQ+xszuNrP2B9vBzIqYWXEiv8OFzax48MWb28oQaYFsDQauH8jCvt8Dxc3sgqBL6V6gWIbyl4F/771U1szizaxTJo/9EnAykavXkg8oex+ob2bdgs/wfmDx3q6s4PMvDhSJLFrxvRcDBOV55bOXkChxSOiC/vs2wDLgM2Ab8BVQCZhziN1eJfKF3QO4J3jfC/YNju84wuD4pQfcx7HDzCofRfhDgBLAJmA28ElmdwzGS64HXgPWEmmBZLzK6j/ABGCymW0Pjn/6kY4bJJpriYyl/Jqhfj2D824EuhEZj9kSHLN7hkOcS+Tz/Jg/B/wnZyg/5GcvBYPpQU4iIpIVanGIiEiWKHGIiEiWKHGIiEiWKHGIiEiWxPQNgJUqVfJatWqFHYaISEyZP3/+JnePP/KWBxfTiaNWrVrMmzcv7DBERGKKma3Kzv7qqhIRkSxR4hARkSxR4hARkSxR4hARkSxR4hARkSyJWuIwszfMbIOZLcmwrqKZfRY8kvMzM6uQoWygmf1oZsvNrG204hIRkeyJZotjGJGH22Q0AJji7rWBKcEyZlaPyOycpwT7vKhpmkVE8qao3cfh7tPNrNYBqzsBLYL3w4FpwL+C9e8E02v/bGY/AqcBXx72JMuXQ4sWh91ERERyVm6PcRzr7usBgp97n39QjciDfPZaE6z7CzPra2bzzGze7t27D7aJiIhEUV65c/xgj9k86INC3H0oMBSgadOmzrRpUQxLRCQfssw82fjQcrvF8ZuZVQUIfm4I1q8BqmfYLgFYl8uxiYhIJuR24pgA9A7e9wbGZ1jf3cyKmVkiUJvIo0NFRCSPiVpXlZmNIjIQXsnM1gAPAI8DY8zsamA1cDGAu39rZmOA74A04AZ33xOt2ERE5OhF86qqHocoan2I7f8N/Dta8YiISM7QneMiIpIlShwiIpIlShwiIpIlShwiIpIlShwiIpIlShwiIpIlShwiIpIlShwiIpIlShwiIpIlShwiIpIlShwiIpIlShwiIpIlShwiIpIlShwiIpIlShwiIpIlShwiIpIlShwiIpIlShwiIgXI5s3Zfyp31B4dKyIi4du2bRevv/4lc+Yk8/PP7Zg7Nz3bx1SLQ0QkH0lPh/feW0KHDk9SqdL5lCtXgdtua8no0fdQuDDce2+RbJ9DLQ4RkRg3Y8ZKhg+fxfbtlzFlCmza9DDwLsWK1aNhw39y4YVtuPba5iQkRLYfNCh751PiEBGJMb//nsxTT33G++9/zA8/fE5a2goA4uOb0b59TerX/zetWw+hSZPjonJ+JQ4RkRiwatVWJk8uxKefluXDD98lNbU3UIZjj23J2Wf3p0+fNrRvX4NChQBqRzUWJQ4RkTzq66/X88QT4/n00/fZvHkqMJiqVftz+eUdqV17Mjff3IKSJbM/ZpFVShwiInnIihXw3ntpPPpoK7ZtmwE4RYqcyN//fgs339yKyy6DQoXKA/8ILUYlDhGREKWnO++9t5gXXhjHkiUb+f33F4HCHHPMybRq9Q9uvLELnTqdQqFCFnao+yhxiIiEYNGi9dx991tMmTKM1NSlQCHKl2/JU0/toWvXOGrVeiXsEA9JiUNEJJfs2JHKxInGW28V4eOPh+M+kDJlmnHxxa8wcGBnTjmlctghZooSh4hIlI0evYjHHnuTxYtH4v4c1ar14Oabr+H887tw/vl1ww4vy5Q4RESi4Lff0rj++heZNOlNkpMXAUWpXr0zt99+AjfeCHFxlYBKIUd5dJQ4RERySEpKGq+/vpSpUxswfnwcaWmvULJkcS6++Hkee6wHJ5xQMewQc0QoicPMbgWuARz4BrgSKAmMBmoBK4FL3H1LGPGJiGTF0qUbuf76F5k+/RXS03dQqdJ6brqpFN26zaRZs/Jhh5fjcn2SQzOrBtwMNHX3+kAc0B0YAExx99rAlGBZRCTPmjZtFaecch316tVg2rQHqVSpCQMG/JeVK4vy9NPky6QB4XVVFQZKmNluIi2NdcBAoEVQPhyYBvwrjOBERA7F3Zk2bRfPPVec99/fDLzJSSddwVNP3Ub79ieFHV6uyPXE4e5rzexJYDWQDEx298lmdqy7rw+2WW9mB70uzcz6An0BatSokVthi0gBl5q6h3vu+YCXX36SHTvqULHicO67rwk9e66nbt0KYYeXq3I9cZhZBaATkAhsBd41s8szu7+7DwWGAjRt2tSjEaOIyF4bN+7kxhuHMW7c06Sl/UThwsfTvXsfXnsNSpUCKFhJA8J5kFMb4Gd33+juu4FxwFnAb2ZWFSD4uSGE2EREAPjtN7j/fqhR42HGjLmRYsXiueOO99i583tGjbo2SBoFUxhjHKuBM8ysJJGuqtbAPGAn0Bt4PPg5PoTYRKSAmz79Z6699jFWrLiMtLQWnHfeTXTseCH9+jXLU/NFhSmMMY45ZvYesABIAxYS6XoqDYwxs6uJJJeLczs2ESm4li/fRPfuj7Bo0YtAIc4+uxGvvdaCunUTgISww8tTQrmqyt0fAB44YPUuIq0PEZFck5QEl176HB99dC+wg7p1r2LEiAdp2rRa2KHlWWGMcYiIhC4lJY1XXknnxBPho49SqFKlBRMmfMOyZa8qaRyBEoeIFCjp6c7dd4+nXLlT6dfvbWrVgunT72D9+vFceGG9sMOLCUocIlJgvPLKLMqXP4fHHusMpHPfffHMnAnnnKNB76zQJIciku8tWwYdOtzGihXPUKhQFXr2fJnXXrua4sX1FXg09KmJSL61aNF6nn22LP/9bymKFm1B69YVefvtW6lcuQDfhJED1FUlIvlOSkoa7ds/QePGJzJ8+NNcfz2sWtWRzz+/V0kjB6jFISL5yujRi7jyyqtJTl5AlSqdGDnyMlq1Cjuq/EUtDhHJF1JSoH37oXTv3pRdu9Zy223vsnbt+7RqdULYoeU7anGISMybPj2dvn0LsXz56dSu3ZtJkwbnm6ft5UVqcYhIzFqzZhsNGtxA8+ZXs2sXTJ7ckO+/f11JI8qUOEQkJj344ERq1TqFJUteolGjcixenM4//hF2VAWDEoeIxJRlyzZRq1ZPHnqoA4ULl+XVV2excOEQypTR11lu0SctIjHBHd5+G846axerVn1G8+YPsHHjAq655oywQytwlDhEJM+bM+cX6tS5j549nTp1qvHVVz8xbdqDlClTLOzQCiQlDhHJ066/fiRnnHEKP/74NHfd9S0zZ8Lf/1467LAKNF2OKyJ50tatKTRrdgvfffcKZcuew4cfDufccxPDDktQ4hCRPOjnn6Fx40v4448POf30fzFt2iOakDAPUVeViOQp48c7TZrAnj13cffd45k9+3EljTxG/xoikiekpKTRvPk9fPVVHE2aPMp7751Nonqm8iS1OEQkdAsWrOPYY1vx1VdPUK/eVmbMcCWNPEyJQ0RC9dRTU2natDHbts3nuutG8O23L1KihJ7Il5epq0pEQpGeDvfeu5HHHutA0aI1ePfdqXTsqGd+xwIlDhHJdb/8ksS115Zk0qR4WrUaz8iRZ1Cliu7NiBXqqhKRXPXGG1+RmHgykye/w0svweeft1HSiDFKHCKSK9LTnYsvfp6rrz4bs0K88caJ9OsHpuGMmKOuKhGJupSUNBo3voFly4ZSuXIHZs/+L4mJFcIOS46SWhwiElVJSdC8+WcsWzaUM88cyNq145U0YpwSh4hEzYYN6bRuDXPntuOOO+Ywa9ajFC6sr51Yd9iuKjMrDnQAzgGOA5KBJcBEd/82+uGJSKyaPv1nzjuvK+4vM3bs6XTpclrYIUkOOWTiMLMHgQuBacAcYANQHKgDPB4kldvdfXH0wxSRWDJy5AKuuKI97qm88EIaXbqEHZHkpMO1OOa6+4OHKHvazCoDNY7mpGZWHngNqA84cBWwHBgN1AJWApe4+5ajOb6IhOexxyZz993diIuryPjxU+nQ4eSwQ5IcdsjORnefeOA6MytuZmWD8g3uPu8oz/sf4BN3PwloCCwFBgBT3L02MCVYFpEYcv/9X3L33RdQvPgJfPXVl0oa+VSmR6nM7BrgU2CimT16tCcMEs+5wOsA7p7q7luBTsDwYLPhQOejPYeI5C53ePxxGDToNBIT72f58i9o0uS4sMOSKDlk4jCzCw9Y1cbdm7v7OcAF2Tjn8cBG4E0zW2hmr5lZKeBYd18PEPysfIi4+prZPDObt3HjxmyEISI5ITV1D6ed9gADB66lR484li27jxo1yoUdlkTR4VocDc1svJk1DJYXm9lIMxsBZOeKqsJAE+Ald28M7CQL3VLuPtTdm7p70/j4+GyEISLZ9fvvySQmXsy8eQ/TsuV7jBgBRYuGHZVE2yEHx939ETOrAjxskTkB7gdKAyWzeSXVGmCNu88Jlt8jkjh+M7Oq7r7ezKoSuYpLRPKoFSt+p0mTjmzbNosuXYYwblz/sEOSXHKkMY6dwC3AC8BQoAfwfXZO6O6/Ar+YWd1gVWvgO2AC0DtY1xsYn53ziEj0zJmzhnr1zmbbtrnccss7ShoFzOHu43iEyCB2EWC0u3c0s45EBseHuftb2TjvTcBIMysK/ARcSSSJjTGzq4HVwMXZOL6IRMmyZdC5cyn27KnIkCEv0b9/87BDklx2uPs4Orh7I4v0U80Hhrj7BDP7GLghOyd190VA04MUtc7OcUUkuqZOXUWPHlWACixY8D9OPVVT2xZEh0scS8zsLaAE8MXele6eRuQ+DBEpQKZM+ZHzzmtOkSL/YMGCYdSrp6RRUB1ucPxyM2sA7Hb3ZbkYk4jkMV988RNt27bEfRdvv3079fSE1wLtcPdxnO3u3xwqaZhZWTOrH73QRCQvmDlzFa1btyQ9PYl33plC164Nwg5JQna4rqpuZvYE8AmRMY6NRCY5PBFoCdQEbo96hCISmtWrnVatupKevo233prCJZc0PPJOku8drqvqVjOrAFxE5AqnqkSmVV8KvOLuM3InRBEJw9q10Lq1UaTIqwwduoeePZuEHZLkEYd9HkcwO+2rwUtECohFi9bTtu14kpP78fnnTTjjjLAjkrxEzxwXkf0sWfIbp5/emtTU1YwdewFnnFE97JAkj1HiEJF9li7dSNOmrUlNXcWzz06ia1clDfmrI06rbmbFMrNORGLbDz9spkmTNuzatYInn/yQm246N+yQJI/KzPM4vszkOhGJUVu2QNu2X5CS8iOPPTaB229vFXZIkocdbq6qKkA1oISZNQb23iZaFiiZC7GJSC7YssU57zxj7dqujBhxFj17Vgk7JMnjDjfG0RboAyQAT/Fn4tgG3B3dsEQkN6xZs4169TqRlDSQDz44jw4dlDTkyA53H8dwYLiZdXP3sbkYk4jkgg0bdlKvXju2b/+KAQOS6dAh7IgkVmRmjONvZlZ+74KZVQimXBeRGJWSkkb9+pewfftsbrttFI891inskCSGZCZxtHP3rXsXgpsC20ctIhGJqvR0p1Gj69m48WMuu+xFnnrqorBDkhiTmcQRl/HyWzMrAehyXJEY9fDD6SxfDmeddQ8jR14bdjgSgzJzA+AIYIqZvQk4cBUwPKpRiUhUDB26m4ceKkKvXq8wbFjY0UisOmKLw92fAP4NnAycAgwK1olIDHnkkU+49tp6NGu2gtdeMwoV0oOY5OhkasoRd58ETIpyLCISJSNGzOe++y6iRInajBlTmaJFw45IYllmphw5w8zmmtkOM0s1sz1mti03ghOR7Js+/Wd6976AuLhKzJr1MccdVybskCTGZWZw/HmgB/ADkeePXwM8F82gRCRnLF++iTZtzsc9lQ8+mESjRlXDDknygcwkDtz9RyDO3fe4+5tEngAoInlYUhJcfnkh0tJq8PzzH9Khw8lhhyT5RGbGOJLMrCiwKHiU7HqgVHTDEpHsSE3dQ/fuacyfX5ExYyZz0UUaCJeck5kWR69guxuBnUB1oFs0gxKRo5ee7vztb/358MO2PPnkLiUNyXFHbHG4+6qgxVELGAcsd/fUaAcmIkfnggueYMmSF/j73+/kttt0r67kvCMmDjO7AHgZWEFkhtxEM7s2uERXRPKQ664bySefDKBGje7MmvV42OFIPpWZMY6ngJbBADlmdgIwEd3XIZKnPPHEFF5++UrKl2/JN98Mo3DhTF37IpJlmfnN2rA3aQR+AjZEKR4ROQqLFsFDD1WhdOl/sGjROMqWVReVRE9mWhzfmtnHwBgic1VdDMw1s64A7j4uivGJyBEsX76Ddu1KUaHCKXz55USqVw87IsnvMpM4igO/Ac2D5Y1AReBCIolEiUMkJBs27KRx4+akpbVk/vwnlTQkV2TmqqorcyMQEcmatLR0GjfuTXLyIh54YBANGoQdkRQUmbmqKhG4icjluPu2d/eO2TmxmcUB84C17t7BzCoCo4PzrAQuCR4aJSIH0bLlg6xbN5YLL3yKBx/Us9Uk92Smq+oD4HXgQyA9B8/dH1gKlA2WBwBT3P1xMxsQLP8rB88nkm/ceOMoZswYRJ06V/PBB7eGHY4UMJlJHCnu/mxOntTMEoALiDzn47ZgdSegRfB+ODANJQ6Rv5gzB155pRQVK7Zn/vwX9VwNyXWZSRz/MbMHgMnArr0r3X1BNs47BLgLyDi/87Huvj449nozq3ywHc2sL9AXoEaNGtkIQST2/PxzGp06FaZ69Y7MmXMhpUsraUjuy0ziaEBkvqpW/NlV5cFylplZByL3hsw3sxZZ3d/dhwJDAZo2bepHE4NILNqwYSf167dkz56+TJlyDfHxShoSjswkji7A8Tk4P1UzoKOZtSdyqW9ZMxsB/GZmVYPWRlV0k6HIPpErqK4gKWk+Dz1UjVNOCTsiKcgyc+f410D5nDqhuw909wR3rwV0B/7P3S8HJgC9g816A+Nz6pwisa5Fi/tZt24cnTo9yf33tws7HCngMtPiOBZYZmZz2X+MI1uX4x7E48AYM7saWE3kDnWRAu+GG95m5sx/U7fuNYwbd0vY4YhkKnE8EK2Tu/s0IldP4e6bgdbROpdILJo9G155ZS3lyrVg3rwXdAWV5AmZuXP8i9wIRET2t2qV07mzUbPmncyceSulS2fm7zyR6Dvkb6KZbSdy9dRfigB397IHKRORHPDrrzuoX78z6en38n//14IqVZQ0JO845OC4u5dx97IHeZVR0hCJnrS0dJo06cWOHVMZMCCFevXCjkhkf/ozRiSPad78Ptav/4DOnYdw333nhx2OyF/oEWEiech1141g1qxHOemkfzJ27M1hhyNyUEocInnE7NkwdOhkypdvwdy5z+sKKsmz1FUlkgesXg2dO0PNmsOZOnUnpUsXDTskkUNSi0MkZBs27KRhw8vYufMnPvrIqFmzdNghiRyWEodIiPbOQbV162juvHO5rqCSmKCuKpEQtWz5AOvWjaNjx6c0B5XEDLU4REJy002jmDHjEWrXvor339dT/CR2KHGIhGD27HReeOF5ypY9hwULXtIVVBJT1FUlksvWroWuXQtRvfpkJk9O0RVUEnPU4hDJRZs2JfG3v/2Lbdu2M3FiKerWPSbskESyTIlDJJekpzuNG1/Jb78NZsCAOdSvH3ZEIkdHXVUiuaR164dZs2YM7ds/wb33tgk7HJGjphaHSC647bZ3mTbtQU44oTcffnhH2OGIZIsSh0iUzZ6dypAhd1GmzFksWPCKrqCSmKeuKpEoWr8eLrqoKFWrTuPTT4tTtmyxsEMSyTa1OESi5PffkznzzBfZsiWdjz+uSf36x4YdkkiOUOIQiYL0dKdJk6tZteoG7rtvNg0bhh2RSM5R4hCJgrZtH2XVqlGcd96jDBhwVtjhiOQoJQ6RHHbDDW/z+ef3UrPmZUyaNCDscERynBKHSA4aN24zL754LeXKNWfRotd1BZXkS7qqSiSHfP019OlzDImJnzB16imUL1887JBEokItDpEcMHPmKlq0GEO5cjB9ejNq1iwfdkgiUaMWh0g2rVjxO61anU9q6q989FEbEhIqhh2SSFQpcYhkw++/J9O4cUdSU39iyJDJNGumpCH5nxKHyFFKTd1DgwaXs337LG655R36928edkgiuUKJQ+QouEPXrpNYt24cXboM4ZlnLgk7JJFck+uJw8yqA/8FqgDpwFB3/4+ZVQRGA7WAlcAl7r4lt+MTyYwnnoCJEzvQo8dM3n5bN/jFkt27d7NmzRpSUlLCDiXqihcvTkJCAkWKFMnR44bR4kgDbnf3BWZWBphvZp8BfYAp7v64mQ0ABgD/CiE+kcO64YZ3ePHFE+nRoykjRihpxJo1a9ZQpkwZatWqhVn+vc/G3dm8eTNr1qwhMTExR4+d65fjuvt6d18QvN8OLAWqAZ2A4cFmw4HOuR2byJE89thkXnyxF5UqPcybb0IhXdAec1JSUjjmmGPyddIAMDOOOeaYqLSsQv21N7NaQGNgDnCsu6+HSHIBKh9in75mNs/M5m3cuDHXYhV5++0F3H13N4oXr8f8+W9RTDOkx6z8njT2ilY9Q0scZlYaGAvc4u7bMrufuw9196bu3jQ+Pj56AYpkMH36z/TqdQFxcRWZOXMSNWqUCzskkdCEkjjMrAiRpDHS3ccFq38zs6pBeVVgQxixiRxo0ybo1Olp3HfxwQef0KTJcWGHJDHOzOjVq9e+5bS0NOLj4+nQoQMAw4YNIz4+nsaNG1O7dm3atm3LrFmz9m3fp08fEhMTadiwIXXq1OGKK65g7dq1uRZ/ricOi7SdXgeWuvvTGYomAL2D972B8bkdm8iBkpKgY0dISnqGt96aRYcOJ4cdkuQDpUqVYsmSJSQnJwPw2WefUa1atf22ufTSS1m4cCE//PADAwYMoGvXrixdunRf+eDBg/n6669Zvnw5jRs3pmXLlqSmpuZK/GFcVdUM6AV8Y2aLgnV3A48DY8zsamA1cHEIsYnss2NHKo0a3cuKFbcxdmwVunY9KeyQJIfdcgssWpSzx2zUCIYMOfJ27dq1Y+LEiVx00UWMGjWKHj168L///e+g27Zs2ZK+ffsydOhQnnnmmf3KzIxbb72V999/n0mTJtGpU6fsV+IIwriqaoa7m7uf6u6NgtfH7r7Z3Vu7e+3g5++5HZvIXlu2JHP88V1YsWIwl1/+CV27hh2R5Dfdu3fnnXfeISUlhcWLF3P66acfdvsmTZqwbNmyoy7PSbpzXOQAv/66g3r1OrFly1R69nyFt97qE3ZIEiWZaRlEy6mnnsrKlSsZNWoU7du3P+L27p6t8pykq9BFMli1ait16rRly5Zp9Ov3X0aM6Bt2SJKPdezYkTvuuIMePXoccduFCxdy8smHHmM7UnlOUotDJLBpE1x44W62b9/JHXeMYfDgbmGHJPncVVddRbly5WjQoAHTpk075HZffPEFQ4cOZerUqX8pc3eee+451q9fz/nnnx/FaP+kxCECLFmykUsvLc9PP8UzYcI8LrxQ/zUk+hISEujfv/9By0aPHs2MGTNISkoiMTGRsWPH7teiuPPOOxk0aBBJSUmcccYZTJ06laJFi+ZK3Jab/WI5rWnTpj5v3ryww5AY9+WXq2nevDXu5zB58hu0bBl2RBJNS5cuzbUunbzgYPU1s/nu3vRoj6kxDinQpkz5kXPOOYfduzfywgv/VNIQyQS1x6XAmjDhO7p0aYP7bkaOnMpllzUOOySRmKDEIQXS3LlpdOnSEXA++OALOnasF3ZIIjFDiUMKnC+/hHbtChMf/xYjR8bTuvWJYYckElM0xiEFypAh02jR4j/Ex8OcOWcqaYgcBSUOKTAeeeQTbr21HWZD+fTTZGrWDDsikdikxCEFwl13jeO++zpSosTJfP31Fxx/fImwQ5ICLC4ujkaNGlG/fn0uvvhikpKSgMj06pUqVWLgwIEH3a9hw4aZuss82pQ4JF9LTYWzzrqPwYO7Ubp0U5Yu/T/q1q0UdlhSwJUoUYJFixaxZMkSihYtyssvvwzA5MmTqVu3LmPGjPnL3FNLly4lPT2d6dOns3PnzjDC3keD45Jv/fADXHYZzJtXjXr1+vHFF09RqVLJsMOSvCTMedUD55xzDosXLwZg1KhR9O/fn5deeonZs2dz5pln7tvu7bffplevXixdupQJEyaE2vJQi0PynfR0p2/f/9KgwWhWrIBx4/rx7bcvKWlInpOWlsakSZNo0KABycnJTJkyhQ4dOtCjRw9GjRq137ajR4/m0ksvPWhZblOLQ/KVNWu2cfbZ17Fq1dtUrHghCxdeQo0aFnZYkleFNK96cnIyjRo1AiItjquvvprx48fTsmVLSpYsSbdu3Rg0aBDPPPMMcXFxzJ07l/j4eGrWrElCQgJXXXUVW7ZsoUKFCqHEr8Qh+cbrr8+mX7/LSEtbTevWg/j444EULaqkIXnP3jGOjEaNGsXMmTOpVasWAJs3b2bq1Km0adOGUaNGsWzZsn1l27ZtY+zYsVxzzTW5G3hAXVUS8/bsgdtv/55rrjkH93Refnk6n39+L0WLxoUdmkimbNu2jRkzZrB69WpWrlzJypUreeGFFxg1ahTp6em8++67LF68eF/Z+PHjQ+2uUuKQmPbzz7s47zx4+uk6NG36EitWLOLaa88KOyyRLBk3bhytWrWiWLFi+9Z16tSJCRMm8Nlnn1GtWjWqVau2r+zcc8/lu+++Y/369WGEq2nVJXbdd9+HPProdRQt+hEvvNCIK68EU8+UHIGmVc/+tOoa45CYs3VrCueeeyfffPM8JUo0YuzYErRrF3ZUIgWHuqokpnzwwbdUrXoa33zzPI0b38Kvv86mXbu6YYclUqAocUhM+Ppr6NEDunb9gF27fuXBByeyYMEzlC1b7Mg7i0iOUuKQPO3FF2dQufIFNGr0Dh99BDfddBPffLOEBx5oH3ZoIgWWxjgkz0lPdwYNmsTTTz/Gtm0zMKtEly4X8frrUKFCWaBs2CGKFGhKHJJnpKXBe+9Bv36X8scf7xIXV4Nu3Z7l5Zev1nQhInmIuqokdH/8kUKvXq9Sp84OevSA0qV7cs01w9i27Ufee+8mJQ3Jd8yMXr167VtOS0sjPj6eDh06ADBs2DDi4+Np3LgxtWvXpm3btsyaNWvf9n369CExMZFGjRrRsGFDpkyZkqvxK3FIaNat206HDoOpWDGRESP6AuMYNw5Wr+7Eq6/2pmTJImGHKBIVpUqVYsmSJSQnJwPsu8kvo0svvZSFCxfyww8/MGDAALp27crSpUv3lQ8ePJhFixYxZMgQ+vXrl6vxq6tKctXWrTB9uvPww3exYMFruG+lQoXWDBw4gttvb0Uh/SkjuaxFixZ/WXfJJZdw/fXXk5SURPv2f70Qo0+fPvTp04dNmzZx0UUX7Vc2bdq0TJ23Xbt2TJw4kYsuuohRo0bRo0cP/ve//x1025YtW9K3b1+GDh3KM888s1/ZmWeeydq1azN1zpyi/6YSVStW/M7AgR/QpMmtVKrUj4oVoVMnY8GCuVSt2ophw77i998/5847W1OokG77loKje/fuvPPOO6SkpLB48WJOP/30w27fpEkTli1b9pf1n3zyCZ07d45SlAenFofkqE2bYPp0eO65l5k9+yVSUhYHJcWpWLEV99/vtGxpnHbaVEqUUKKQ8B2uhVCyZMnDlleqVCnTLYwDnXrqqaxcuZJRo0YdtFVzoAOnh7rzzju566672LBhA7Nnzz6qGI5WnkscZnY+8B8gDnjN3R8POSQ5iPR0Z/36HSxd+hsff7yQzz//gu+/n86uXV8AFShSJIUyZSrTrNkgunRpQa9efz/gZj0lDZGOHTtyxx13MG3aNDZv3nzYbRcuXLjfnFODBw+ma9euPPvss/Tu3Zv58+dHO9x98lTiMLM44AXgH8AaYK6ZTXD378KNrGBIStrNhg3O1q1FWb78N6ZO/Yx16zawYcMGNm/ewB9//EalSg+zc+ffWL9+DLt3d8+wdymOOaYZN964ma5dK9C06S0ULXpLWFURiQlXXXUV5cqVo0GDBodtuXzxxRcMHTqUqVOn7re+UKFC9O/fn+HDh/Ppp5/Stm3bKEcckacSB3Aa8KO7/wRgZu8AnYCDJo5Fi36hePFT9ltXuPBx1Kz5GQDr1v2T5ORZ+5UXLVqb6tU/AGDNmp7s2rVov/JixRqRkDASgF9+6Uxq6g/7lZcocRbHHfcqAKtW/YO0tHX7lZcq9Q+qVBkCwM8/n0V6+h/7lZcu3Yljj30UgBUrGgJp+5WXLXsZ8fH34L6bn35q9Jc6ly//T4455hb27NnKypXN/lJesWJ/ypXry65dv/DLLy2BdNz37PtZuvQjFC16Famp37JtWzMgHdgTvHYBI4HLgO+BvZcLFiUurjLFilXm+ON3ctppUKRIE9avH8xxx1Xm9NPr0qNHE10FJZJFCQkJ9O/f/6Blo0ePZsaMGSQlJZGYmMjYsWMPOquvmXHvvffyxBNPFNjEUQ34JcPyGmC/ESMz6wv0BShSpAqVKtXb7wDFisVTb9+qGvzxx9b9ykuWrLGvPD29Ftu3p+5XXqZMrX3lu3efQFLS/l+G5cr9uX9KSm127Sq/X3nFignUDebc27mzLmlpO/Yrj4+vxoknRt5v316P9PT9E0eVKlVITIT0dNi2bf+6AVSrVpkaNWD37jh27PhreY0alUhIgN27i+N+BoUKFcKsEIUKxVGoUCFq165F9eqQnFyBhQt7ExcXh1kh4uLiKFmyJM2a1adJEyhX7m/s2bOck046loSEsgcZuK4N3PGX84vIke3YseMv61q0aLHvCq+9V20dyrBhw/Zb7tatG926dcvBCA8vTz2Pw8wuBtq6+zXBci/gNHe/6WDb63kcIpJVeh5H9p/Hkdcux10DVM+wnACsO8S2IiISgryWOOYCtc0s0cyKAt2BCSHHJCL5TF7qaYmmaNUzTyUOd08DbgQ+BZYCY9z923CjEpH8pHjx4mzevDnfJw93Z/PmzRQvXjzHj53XBsdx94+Bj8OOQ0Typ4SEBNasWcPGjRvDDiXqihcvTkJCQo4fN88lDhGRaCpSpAiJiYlhhxHT8lRXlYiI5H1KHCIikiVKHCIikiV56gbArDKz7cDysOOIokrAprCDiCLVL7bl5/rl57oB1HX3Mke7c6wPji/Pzt2PeZ2ZzVP9YpfqF7vyc90gUr/s7K+uKhERyRIlDhERyZJYTxxDww4gylS/2Kb6xa78XDfIZv1ienBcRERyX6y3OEREJJcpcYiISJbEbOIws/PNbLmZ/WhmA8KOJ7vMrLqZTTWzpWb2rZn1D9ZXNLPPzOyH4GeFsGM9WmYWZ2YLzeyjYDk/1a28mb1nZsuCf8Mz81n9bg1+L5eY2SgzKx7L9TOzN8xsg5ktybDukPUxs4HBd81yM8ud57NmwyHqNzj4/VxsZu+bWfkMZVmqX0wmDjOLA14A2gH1gB5m9tfnqMaWNOB2dz8ZOAO4IajTAGCKu9cGpgTLsao/keny98pPdfsP8Im7nwQ0JFLPfFE/M6sG3Aw0dff6QByRZ+XEcv2GAecfsO6g9Qn+H3YHTgn2eTH4DsrLhvHX+n0G1Hf3U4HvgYFwdPWLycQBnAb86O4/uXsq8A7QKeSYssXd17v7guD9diJfPNWI1Gt4sNlwoHMoAWaTmSUAFwCvZVidX+pWFjgXeB3A3VPdfSv5pH6BwkAJMysMlCTyZM6YrZ+7Twd+P2D1oerTCXjH3Xe5+8/Aj0S+g/Ksg9XP3ScHzzwCmE3kCatwFPWL1cRRDfglw/KaYF2+YGa1gMbAHOBYd18PkeQCVA4xtOwYAtwFpGdYl1/qdjywEXgz6Ip7zcxKkU/q5+5rgSeB1cB64A93n0w+qV8Gh6pPfvy+uQqYFLzPcv1iNXHYQdbli+uKzaw0MBa4xd23hR1PTjCzDsAGd58fdixRUhhoArzk7o2BncRWt81hBX39nYBE4DiglJldHm5UuSpffd+Y2T1EusZH7l11kM0OW79YTRxrgOoZlhOINJ1jmpkVIZI0Rrr7uGD1b2ZWNSivCmwIK75saAZ0NLOVRLoVW5nZCPJH3SDy+7jG3ecEy+8RSST5pX5tgJ/dfaO77wbGAWeRf+q316Hqk2++b8ysN9AB6Ol/3sSX5frFauKYC9Q2s0QzK0pkYGdCyDFli5kZkT7ype7+dIaiCUDv4H1vYHxux5Zd7j7Q3RPcvRaRf6v/c/fLyQd1A3D3X4FfzKxusKo18B35pH5EuqjOMLOSwe9payJjcPmlfnsdqj4TgO5mVszMEoHawFchxJctZnY+8C+go7snZSjKev3cPSZfQHsiVwasAO4JO54cqM/ZRJqHi4FFwas9cAyRKzx+CH5WDDvWbNazBfBR8D7f1A1oBMwL/v0+ACrks/o9BCwDlgBvAcViuX7AKCLjNbuJ/MV99eHqA9wTfNcsB9qFHf9R1u9HImMZe79fXj7a+mnKERERyZJY7aoSEZGQKHGIiEiWKHGIiEiWKHGIiEiWKHGIiEiWKHFIvmFmOzKxzS1mVjKHz3ucmb0XvG9kZu2P4hidzez+o9hvoJn1PERZAzMbltVjihyJEocUNLcQmaQvx7j7One/KFhsROT+m6y6C3jxKPY7D5h8iLi+ARLMrMZRHFfkkJQ4JN8xsxZmNi3D8zFGWsTNROZammpmU4NtzzOzL81sgZm9G8wVhpmtNLOHgvXfmNlJwfrmZrYoeC00szJmVit4TkVR4GHg0qD80uDZDvHBvoWCZx5UOiDeOsAud98ULA8zs5cs8nyWn4JzvmGR53wMy7BfWaCou280s4uDGL42s+kZDv8hkbv1RXKMEofkV42JtC7qEZm9tpm7P0tkDp6W7t4y+AK/F2jj7k2I3Pl9W4ZjbArWvwTcEay7A7jB3RsB5wDJezf2yBT/9wOj3b2Ru48GRgB7u5LaAF/vTRAZNAMWHLCuAtAKuJXIl/8zRJ6X0MDMGmU43pTg/f1AW3dvCHTMcJx5QZwiOUaJQ/Krr9x9jbunE5leodZBtjmDSGKZaWaLiMxPVDND+d6JJudn2H8m8HTQeinvfz7f4FDeAK4I3l8FvHmQbaoSmZY9ow89Mq3DN8Bv7v5NUJdvM8RyPn9OjT0TGGZm/yTyoKW9NhBpZYnkGCUOya92ZXi/h8jU5wcy4LOgddDI3eu5+9UHOca+/d39ceAaoAQwe28X1qG4+y9EZl1tBZzOn1/0GSUDxQ8Rf/oBdUnPUJfTCCajc/d+RFpP1YFFZnZMsE1xMrSKRHKCEocUNNuBMsH72UAzMzsRIJj9tc7hdjazE4K//v8fkW6gAxNHxuPv9RqRLqsx7r7nIIddCpyYlUqY2SnAsr3HC+Ka4+73A5v4c5rsOkQmJhTJMUocUtAMBSaZ2VR33wj0AUaZ2WIiieSwLQjglr2D0ET+kj+wBTEVqLd3cDxYNwEozcG7qQCmA42DKcszqx3wSYblwcEg/pLgeF8H61sCE7NwXJEj0uy4IlFmZk2BZ9z9kIPUZvYfIuMan2fymJ8BV3jwqNNDbFMM+AI4OxNjMSKZpsQhEkVmNgC4jsgT12YcZrtjgdPdPcceSGZmtYFq7j4tp44pAkocIiKSRRrjEBGRLFHiEBGRLFHiEBGRLFHiEBGRLFHiEBGRLPn/B9NKwXFnKs4AAAAASUVORK5CYII=\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -605,8 +705,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
+   "execution_count": 15,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2022-03-09T16:17:12.881010Z",
+     "start_time": "2022-03-09T16:17:12.878532Z"
+    }
+   },
    "outputs": [],
    "source": [
     "imp_fun_set = ImpactFuncSet()\n",
@@ -624,14 +729,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
+   "execution_count": 16,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2022-03-09T16:17:14.348197Z",
+     "start_time": "2022-03-09T16:17:14.341539Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2021-10-19 16:43:43,386 - climada.entity.impact_funcs.base - WARNING - For intensity = 0, mdd != 0 or paa != 0. Consider shifting the origin of the intensity scale. In impact.calc the impact is always null at intensity = 0.\n"
+      "2022-03-09 17:17:14,343 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n",
+      "2022-03-09 17:17:14,343 - climada.entity.exposures.base - INFO - category_id not set.\n",
+      "2022-03-09 17:17:14,344 - climada.entity.exposures.base - INFO - cover not set.\n",
+      "2022-03-09 17:17:14,345 - climada.entity.exposures.base - INFO - deductible not set.\n",
+      "2022-03-09 17:17:14,345 - climada.entity.exposures.base - INFO - centr_ not set.\n",
+      "2022-03-09 17:17:14,346 - climada.entity.impact_funcs.base - WARNING - For intensity = 0, mdd != 0 or paa != 0. Consider shifting the origin of the intensity scale. In impact.calc the impact is always null at intensity = 0.\n"
      ]
     }
    ],
@@ -908,9 +1023,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 17,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2022-03-09T16:17:21.140809Z",
+     "start_time": "2022-03-09T16:17:21.114515Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2022-03-09 17:17:21,127 - climada.entity.exposures.base - INFO - Matching 691 exposures with 1891 centroids.\n",
+      "2022-03-09 17:17:21,130 - climada.engine.impact - INFO - Calculating damage for 691 assets (>0) and 61 events.\n"
+     ]
+    }
+   ],
    "source": [
     "from climada.engine import Impact\n",
     "\n",
@@ -929,19 +1058,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
+   "execution_count": 18,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2022-03-09T16:18:04.231193Z",
+     "start_time": "2022-03-09T16:18:04.121356Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Expected average annual impact: 1.754e+09 USD\n"
+      "Expected average annual impact: 1.616e+09 USD\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -968,24 +1102,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
+   "execution_count": 19,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2022-03-09T16:18:08.663509Z",
+     "start_time": "2022-03-09T16:18:06.303726Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2021-04-23 11:52:47,128 - climada.util.coordinates - INFO - Setting geometry points.\n",
-      "2021-04-23 11:52:47,249 - climada.entity.exposures.base - INFO - Setting latitude and longitude attributes.\n"
+      "2022-03-09 17:18:06,305 - climada.util.coordinates - INFO - Setting geometry points.\n",
+      "2022-03-09 17:18:06,363 - climada.entity.exposures.base - INFO - Setting latitude and longitude attributes.\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/Users/zeliestalhanske/python_projects/climada_python/climada/entity/exposures/base.py:190: FutureWarning: Assigning CRS to a GeoDataFrame without a geometry column is now deprecated and will not be supported in the future.\n",
-      "  self.gdf = GeoDataFrame(*args, **kwargs)\n",
-      "/Users/zeliestalhanske/miniconda3/envs/climada_env/lib/python3.8/site-packages/contextily/tile.py:265: FutureWarning: The url format using 'tileX', 'tileY', 'tileZ' as placeholders is deprecated. Please use '{x}', '{y}', '{z}' instead.\n",
+      "/Users/ckropf/opt/anaconda3/envs/climada_311/lib/python3.8/site-packages/pyproj/crs/crs.py:1256: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n",
+      "  return self._crs.to_proj4(version=version)\n",
+      "/Users/ckropf/opt/anaconda3/envs/climada_311/lib/python3.8/site-packages/contextily/tile.py:265: FutureWarning: The url format using 'tileX', 'tileY', 'tileZ' as placeholders is deprecated. Please use '{x}', '{y}', '{z}' instead.\n",
       "  warnings.warn(\n"
      ]
     },
@@ -993,12 +1132,12 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2021-04-23 11:52:50,676 - climada.entity.exposures.base - INFO - Setting latitude and longitude attributes.\n"
+      "2022-03-09 17:18:08,468 - climada.entity.exposures.base - INFO - Setting latitude and longitude attributes.\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 648x936 with 2 Axes>"
       ]
@@ -1108,10 +1247,11 @@
   }
  ],
  "metadata": {
+  "hide_input": false,
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python [conda env:climada_311]",
    "language": "python",
-   "name": "python3"
+   "name": "conda-env-climada_311-py"
   },
   "language_info": {
    "codemirror_mode": {
@@ -1123,7 +1263,38 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.10"
+   "version": "3.8.12"
+  },
+  "latex_envs": {
+   "LaTeX_envs_menu_present": true,
+   "autoclose": false,
+   "autocomplete": true,
+   "bibliofile": "biblio.bib",
+   "cite_by": "apalike",
+   "current_citInitial": 1,
+   "eqLabelWithNumbers": true,
+   "eqNumInitial": 1,
+   "hotkeys": {
+    "equation": "Ctrl-E",
+    "itemize": "Ctrl-I"
+   },
+   "labels_anchors": false,
+   "latex_user_defs": false,
+   "report_style_numbering": false,
+   "user_envs_cfg": false
+  },
+  "toc": {
+   "base_numbering": 1,
+   "nav_menu": {},
+   "number_sections": true,
+   "sideBar": true,
+   "skip_h1_title": false,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": false,
+   "toc_position": {},
+   "toc_section_display": true,
+   "toc_window_display": false
   }
  },
  "nbformat": 4,

From a15b2df1549f04f28ba8ebb0941c46db9b949439 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Fri, 18 Mar 2022 14:02:23 +0100
Subject: [PATCH 005/121] Make init

---
 climada/engine/impact.py | 134 ++++++++++++++++++++++-----------------
 1 file changed, 77 insertions(+), 57 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index a123f2418..ec9d98ea2 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -84,23 +84,37 @@ class Impact():
         only filled if save_mat is True in calc()
     """
 
-    def __init__(self):
-        """Empty initialization."""
-        self.tag = dict()
-        self.event_id = np.array([], int)
-        self.event_name = list()
-        self.date = np.array([], int)
-        self.coord_exp = np.ndarray([], float)
-        self.crs = DEF_CRS
-        self.eai_exp = np.array([])
-        self.at_event = np.array([])
-        self.frequency = np.array([])
-        self.tot_value = 0
-        self.aai_agg = 0
-        self.unit = ''
-        self.imp_mat = sparse.csr_matrix(np.empty((0, 0)))
+    def __init__(self,
+                 event_id=np.array([], int),
+                 event_name=[],
+                 date=np.array([], int),
+                 frequency=np.array([],float),
+                 coord_exp=np.ndarray([], float),
+                 crs=DEF_CRS,
+                 eai_exp=np.array([], float),
+                 at_event=np.array([], float),
+                 tot_value=0,
+                 aai_agg=0,
+                 unit='',
+                 imp_mat=sparse.csr_matrix(np.empty((0, 0))),
+                 tag={}):
+
+        self.tag = tag
+        self.event_id = event_id
+        self.event_name = event_name
+        self.date = date
+        self.coord_exp = coord_exp
+        self.crs = crs
+        self.eai_exp = eai_exp
+        self.at_event = at_event
+        self.frequency = frequency
+        self.tot_value = tot_value
+        self.aai_agg = aai_agg
+        self.unit = unit
+        self.imp_mat = imp_mat
 
-    def calc(self, exposures, impact_funcs, hazard, save_mat=False):
+    @classmethod
+    def calc(cls, exposures, impact_funcs, hazard, save_mat=False):
         """Compute impact of an hazard to exposures.
 
         Parameters
@@ -120,8 +134,7 @@ def calc(self, exposures, impact_funcs, hazard, save_mat=False):
             >>> haz.check()
             >>> ent = Entity.from_excel(ENT_TEMPLATE_XLS) # Set exposures
             >>> ent.check()
-            >>> imp = Impact()
-            >>> imp.calc(ent.exposures, ent.impact_funcs, haz)
+            >>> imp = Impact.calc(ent.exposures, ent.impact_funcs, haz)
             >>> imp.calc_freq_curve().plot()
 
             Specify only exposures and impact functions:
@@ -132,50 +145,55 @@ def calc(self, exposures, impact_funcs, hazard, save_mat=False):
             >>> funcs.check()
             >>> exp = Exposures(pd.read_excel(ENT_TEMPLATE_XLS)) # Set exposures
             >>> exp.check()
-            >>> imp = Impact()
-            >>> imp.calc(exp, funcs, haz)
+            >>> imp = Impact.calc(exp, funcs, haz)
             >>> imp.aai_agg
         """
+
+        haz_type = hazard.tag.haz_type
         # 1. Assign centroids to each exposure if not done
-        assign_haz = INDICATOR_CENTR + hazard.tag.haz_type
+        assign_haz = INDICATOR_CENTR + haz_type
         if assign_haz not in exposures.gdf:
             LOGGER.warning(
                 "Exposures have no assigned centroids for Hazard %s.\
-                Centroids will be assigned now.", hazard.tag.haz_type
+                Centroids will be assigned now.", haz_type
                 )
             exposures.assign_centroids(hazard)
         else:
             LOGGER.info('Exposures matching centroids found in %s', assign_haz)
 
         # Select exposures with positive value and assigned centroid
-        exp_idx = np.where((exposures.gdf.value > 0) & (exposures.gdf[assign_haz] >= 0))[0]
-        if exp_idx.size == 0:
+        affected_exp_idx = np.where((exposures.gdf.value > 0) & (exposures.gdf[assign_haz] >= 0))[0]
+        if affected_exp_idx.size == 0:
             LOGGER.warning("No affected exposures.")
 
         num_events = hazard.intensity.shape[0]
         LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
-                    exp_idx.size, num_events)
+                    affected_exp_idx.size, num_events)
 
         # Get damage functions for this hazard
-        impf_haz = exposures.get_impf_column(hazard.tag.haz_type)
-        haz_imp = impact_funcs.get_func(hazard.tag.haz_type)
+        exp_impf_col_for_haz_type = exposures.get_impf_column(hazard.tag.haz_type)
+        impf_for_haz_type = impact_funcs.get_func(haz_type)
+
+        # Check if impf match
+        impf_ids = [impf.id for impf in impf_for_haz_type]
+        unq_impf_aff_exp = set(exposures[exp_impf_col_for_haz_type])
+        unq_impf = set(impf_ids)
+        if not unq_impf_aff_exp.intersection(unq_impf):
+            raise AttributeError('No impact functions match the exposures.\
+                                 for the hazard type %s', haz_type)
 
         # Check if deductible and cover should be applied
-        insure_flag = False
         if ('deductible' in exposures.gdf) and ('cover' in exposures.gdf) \
         and exposures.gdf.cover.max():
-            insure_flag = True
-
-        if save_mat:
-            # (data, (row_ind, col_ind))
-            self.imp_mat = ([], ([], []))
+           raise DeprecationWarning(
+               "This method is deprecated for exposures with deductible \
+               and cover. Please use ... instead.")
 
         # 3. Loop over exposures according to their impact function
-        tot_exp = 0
-        for imp_fun in haz_imp:
+        exp_impf_id = exposures.gdf[exp_impf_col_for_haz_type].values[affected_exp_idx]
+        for impf in impf_for_haz_type:
             # get indices of all the exposures with this impact function
-            exp_iimp = np.where(exposures.gdf[impf_haz].values[exp_idx] == imp_fun.id)[0]
-            tot_exp += exp_iimp.size
+            exp_idx = np.where(exp_impf_id = impf.id)[0]
             exp_step = CONFIG.max_matrix_size.int() // num_events
             if not exp_step:
                 raise ValueError('Increase max_matrix_size configuration parameter to > %s'
@@ -189,26 +207,28 @@ def calc(self, exposures, impact_funcs, hazard, save_mat=False):
             self._exp_impact(exp_idx[exp_iimp[(chk + 1) * exp_step:]],
                              exposures, hazard, imp_fun, insure_flag)
 
-        if not tot_exp:
-            LOGGER.warning('No impact functions match the exposures.')
-        self.aai_agg = sum(self.at_event * hazard.frequency)
-
-        if save_mat:
-            shape = (self.date.size, exposures.gdf.value.size)
-            self.imp_mat = sparse.csr_matrix(self.imp_mat, shape=shape)
-
-
-        # 2. Initialize values
-        self.unit = exposures.value_unit
-        self.event_id = hazard.event_id
-        self.event_name = hazard.event_name
-        self.date = hazard.date
-        self.coord_exp = np.stack([exposures.gdf.latitude.values,
-                                   exposures.gdf.longitude.values], axis=1)
-        self.frequency = hazard.frequency
-        self.tag = {'exp': exposures.tag, 'impf_set': impact_funcs.tag,
-                    'haz': hazard.tag}
-        self.crs = exposures.crs
+
+
+        return cls(
+            event_id = hazard.event_id,
+            event_name = hazard.event_name,
+            date = hazard.data,
+            frequency = hazard.frequency,
+            coord_exp = np.stack([exposures.gdf.latitude.values,
+                                  exposures.gdf.longitude.values],
+                                 axis=1),
+            crs = exposures.crs,
+            unit = exposures.value_unit,
+            tot_value = tot_value,
+            eai_exp = eai_exp,
+            at_event = at_event,
+            aai_agg = aai_agg,
+            imp_mat = imp_mat,
+            tag = {'exp': exposures.tag,
+                   'impf_set': impact_funcs.tag,
+                   'haz': hazard.tag
+                   }
+            )
 
 
     def calc_risk_transfer(self, attachment, cover):

From 7f18c4d361796aa1caedfac716de5519c6e7e062 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Mon, 11 Apr 2022 14:28:39 +0200
Subject: [PATCH 006/121] Add haz_type as property

---
 climada/hazard/base.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/climada/hazard/base.py b/climada/hazard/base.py
index c19d55074..e345fb691 100644
--- a/climada/hazard/base.py
+++ b/climada/hazard/base.py
@@ -1764,3 +1764,7 @@ def change_centroids(self, centroids, threshold=NEAREST_NEIGHBOR_THRESHOLD):
                     ))
 
         return haz_new_cent
+
+    @property
+    def haz_type(self):
+        return self.tag.haz_type

From c6070de1a5650ff4f444e263e3bc924d9ce503b2 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Mon, 11 Apr 2022 14:29:00 +0200
Subject: [PATCH 007/121] Add centroid columns name in exposures as property

---
 climada/hazard/base.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/climada/hazard/base.py b/climada/hazard/base.py
index e345fb691..893ced111 100644
--- a/climada/hazard/base.py
+++ b/climada/hazard/base.py
@@ -1764,6 +1764,11 @@ def change_centroids(self, centroids, threshold=NEAREST_NEIGHBOR_THRESHOLD):
                     ))
 
         return haz_new_cent
+        
+    @property
+    def cent_exp_col(self):
+        from climada.entity.exposures import INDICATOR_CENTR
+        return INDICATOR_CENTR + self.tag.haz_type
 
     @property
     def haz_type(self):

From d4820f3012729d351c8aca17894ea446f085254a Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Mon, 11 Apr 2022 15:14:10 +0200
Subject: [PATCH 008/121] Add overwrite variable to assign_centroids

---
 climada/entity/exposures/base.py | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/climada/entity/exposures/base.py b/climada/entity/exposures/base.py
index 8f6595f28..49bbde54e 100644
--- a/climada/entity/exposures/base.py
+++ b/climada/entity/exposures/base.py
@@ -367,7 +367,8 @@ def get_impf_column(self, haz_type=''):
         raise ValueError(f"Missing exposures impact functions {INDICATOR_IMPF}.")
 
     def assign_centroids(self, hazard, distance='euclidean',
-                         threshold=u_coord.NEAREST_NEIGHBOR_THRESHOLD):
+                         threshold=u_coord.NEAREST_NEIGHBOR_THRESHOLD,
+                         overwrite=True):
         """Assign for each exposure coordinate closest hazard coordinate.
         -1 used for disatances > threshold in point distances. If raster hazard,
         -1 used for centroids outside raster.
@@ -406,6 +407,15 @@ def assign_centroids(self, hazard, distance='euclidean',
         and works only for non-gridded data.
 
         """
+        haz_type = hazard.tag.haz_type
+        centr_haz = INDICATOR_CENTR + haz_type
+        if centr_haz in self.gdf:
+            LOGGER.info('Exposures matching centroids already found for %s', haz_type)
+            if overwrite:
+                LOGGER.info('Existing centroids will be overwritten for %s', haz_type)
+            else:
+                return None
+
         LOGGER.info('Matching %s exposures with %s centroids.',
                     str(self.gdf.shape[0]), str(hazard.centroids.size))
         if not u_coord.equal_crs(self.crs, hazard.centroids.crs):
@@ -419,7 +429,7 @@ def assign_centroids(self, hazard, distance='euclidean',
             assigned = u_coord.assign_coordinates(
                 np.stack([self.gdf.latitude.values, self.gdf.longitude.values], axis=1),
                 hazard.centroids.coord, distance=distance, threshold=threshold)
-        self.gdf[INDICATOR_CENTR + hazard.tag.haz_type] = assigned
+        self.gdf[centr_haz] = assigned
 
     def set_geometry_points(self, scheduler=None):
         """Set geometry attribute of GeoDataFrame with Points from latitude and

From f49d49226cfd28807d281fa84ec1027f6a16019b Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Mon, 11 Apr 2022 15:14:37 +0200
Subject: [PATCH 009/121] Add method affect_values_gdf

---
 climada/entity/exposures/base.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/climada/entity/exposures/base.py b/climada/entity/exposures/base.py
index 49bbde54e..159f0bf1f 100644
--- a/climada/entity/exposures/base.py
+++ b/climada/entity/exposures/base.py
@@ -997,6 +997,9 @@ def concat(exposures_list):
 
         return exp
 
+    def affected_values_gdf(self, hazard):
+        return self.gdf[(self.gdf.value != 0) & (self.gdf[hazard.cent_exp_col] >= 0)]
+
 
 def add_sea(exposures, sea_res, scheduler=None):
     """Add sea to geometry's surroundings with given resolution. region_id

From f8bf6b0332d6017479f36a78a8dee082c81810e0 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Mon, 11 Apr 2022 15:14:54 +0200
Subject: [PATCH 010/121] Remove warning impf at int=0

---
 climada/entity/impact_funcs/base.py | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/climada/entity/impact_funcs/base.py b/climada/entity/impact_funcs/base.py
index 1bf0cc276..41742c29a 100644
--- a/climada/entity/impact_funcs/base.py
+++ b/climada/entity/impact_funcs/base.py
@@ -130,14 +130,14 @@ def check(self):
 
         # Warning for non-vanishing impact at intensity 0. If positive
         # and negative intensity warning for interpolation at intensity 0.
-        zero_idx = np.where(self.intensity == 0)[0]
-        if zero_idx.size != 0:
-            if self.mdd[zero_idx[0]] != 0 or self.paa[zero_idx[0]] != 0:
-                LOGGER.warning('For intensity = 0, mdd != 0 or paa != 0. '
-                               'Consider shifting the origin of the intensity '
-                               'scale. In impact.calc the impact is always '
-                               'null at intensity = 0.')
-        elif self.intensity[0] < 0 and self.intensity[-1] > 0:
+        # zero_idx = np.where(self.intensity == 0)[0]
+        # if zero_idx.size != 0:
+        #     if self.mdd[zero_idx[0]] != 0 or self.paa[zero_idx[0]] != 0:
+        #         LOGGER.warning('For intensity = 0, mdd != 0 or paa != 0. '
+        #                        'Consider shifting the origin of the intensity '
+        #                        'scale. In impact.calc the impact is always '
+        #                        'null at intensity = 0.')
+        if self.intensity[0] < 0 and self.intensity[-1] > 0:
             LOGGER.warning('Impact function might be interpolated to non-zero'
                            ' value at intensity = 0. Consider shifting the '
                            'origin of the intensity scale. In impact.calc '

From 48ca4d78e75c847b3a3b249ceca4e0cae04d68ca Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Mon, 11 Apr 2022 15:15:59 +0200
Subject: [PATCH 011/121] First commit - overhaul impact

---
 climada/engine/impact.py           | 549 +++++++++++++++++++++--------
 climada/engine/test/test_impact.py |   2 +-
 2 files changed, 402 insertions(+), 149 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index ec9d98ea2..427751991 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -37,7 +37,6 @@
 
 
 from climada.entity import Exposures, Tag
-from climada.entity.exposures import INDICATOR_CENTR
 from climada.hazard import Tag as TagHaz
 import climada.util.plot as u_plot
 from climada import CONFIG
@@ -48,6 +47,130 @@
 
 LOGGER = logging.getLogger(__name__)
 
+def eai_exp_from_mat(imp_mat, freq):
+        """
+        Compute impact for each exposures from the total impact matrix
+        Parameters
+        ----------
+        imp_mat : sparse.csr_matrix
+            matrix num_events x num_exp with impacts.
+        frequency : np.array
+            annual frequency of events
+        Returns
+        -------
+        eai_exp : np.array
+            expected annual impact for each exposure
+        """
+        return imp_mat.multiply(sparse.csr_matrix(freq.reshape(-1, 1))).sum(axis=0).A1
+
+def at_event_from_mat(imp_mat):
+    """
+    Compute impact for each hazard event from the total impact matrix
+    Parameters
+    ----------
+    imp_mat : sparse.csr_matrix
+        matrix num_events x num_exp with impacts.
+    Returns
+    -------
+    at_event : np.array
+        impact for each hazard event
+    """
+    return np.squeeze(np.asarray(np.sum(imp_mat, axis=1)))
+
+def aai_agg_from_eai_exp(eai_exp):
+    """
+    Aggregate impact.eai_exp
+
+    Parameters
+    ----------
+    eai_exp : np.array
+        expected annual impact for each exposure point
+
+    Returns
+    -------
+    float
+        average annual impact aggregated
+    """
+    return sum(eai_exp)
+
+def get_mdr(hazard, cent_idx, impf):
+    uniq_cent_idx, indices = np.unique(cent_idx, return_inverse=True)
+    mdr = hazard.intensity[:, uniq_cent_idx]
+    if impf.calc_mdr(0) == 0:
+        mdr.data = impf.calc_mdr(mdr.data)
+    else:
+        LOGGER.warning("Impact function id=%d has mdr(0) != 0."
+        "The impact must thus be computed for all values of"
+        " intensity including 0.", impf.id)
+    return mdr[:, indices]
+
+def get_fraction(hazard, cent_idx):
+    return hazard.fraction[:, cent_idx]
+
+# def make_full_imp_mat(imp_mat, haz_size, exp_size, exp_idx):
+#     data = imp_mat.data
+#     row, col = imp_mat.nonzero()
+#     return sparse.csr_matrix((data, (row, exp_idx[col])), shape=(haz_size, exp_size))
+
+# def make_full_imp_mat(imp_mat, haz_size, exp_size, exp_idx):
+#     data = imp_mat.data
+#     row, col = imp_mat.nonzero()
+#     return [data, row, exp_idx[col]]
+
+# def calc_impact(mdr, fraction, exp_values):
+#     return mdr.multiply(fraction).multiply(exp_values)
+
+# def calc_imp_mat_per_impf(hazard, n_exp_pnt, exp_gdf, impf_col, impf_set):
+#     n_events = hazard.size
+#     imp_mat_list = []
+#     for impf_id, exp_impf_gdf in exp_gdf.groupby(impf_col):
+#         exp_step = CONFIG.max_matrix_size.int() // n_events
+#         chk = -1
+#         for chk in range(int(len(exp_impf_gdf) / exp_step)):
+#             exp = exp_impf_gdf[chk * exp_step:(chk + 1) * exp_step]
+#             imp_mat_list.append(calc_one_imp_mat(exp, hazard, n_events, n_exp_pnt, impf_set, impf_id))
+#         exp = exp_impf_gdf[(chk + 1) * exp_step:]
+#         imp_mat_list.append(calc_one_imp_mat(exp, hazard, n_events, n_exp_pnt, impf_set, impf_id))
+#     return imp_mat_list
+
+# def calc_one_imp_mat(exp, hazard, n_events, n_exp_pnt, impf_set, impf_id):
+#     cent_idx = exp[hazard.cent_exp_col].values
+#     mdr = get_mdr(hazard, cent_idx, impf_id, impf_set)
+#     fract = get_fraction(hazard, cent_idx)
+#     imp_mat = calc_impact(mdr=mdr, fraction=fract, exp_values=exp.value.values)
+#     return make_full_imp_mat(imp_mat, n_events, n_exp_pnt, exp.index.to_numpy())
+
+# def make_imp_data(imp_mat, exp_idx):
+#     data = imp_mat.data
+#     row, col = imp_mat.nonzero()
+#     return [data, row, exp_idx[col]]
+
+def calc_impact(mdr, fraction, exp_values):
+    return fraction.multiply(mdr).multiply(sparse.csr_matrix(exp_values))
+
+def calc_imp_mat_per_impf(hazard, exp_gdf, impf_col, impf_set):
+    imp_mat_list = []
+    for impf_id, exp_impf_gdf in exp_gdf.groupby(impf_col):
+        impf = impf_set.get_func(haz_type=hazard.haz_type, fun_id=impf_id)
+        exp_step = CONFIG.max_matrix_size.int() // hazard.size
+        if not exp_step:
+            raise ValueError('Increase max_matrix_size configuration parameter to > %s'
+                         % str(hazard.size))
+        chk = -1
+        for chk in range(int(len(exp_impf_gdf) / exp_step)):
+            exp = exp_impf_gdf[chk * exp_step:(chk + 1) * exp_step]
+            imp_mat_list.append(calc_one_imp_mat(exp, hazard, impf))
+        exp = exp_impf_gdf[(chk + 1) * exp_step:]
+        imp_mat_list.append(calc_one_imp_mat(exp, hazard, impf))
+    return imp_mat_list
+
+def calc_one_imp_mat(exp, hazard, impf):
+    cent_idx = exp[hazard.cent_exp_col].values
+    mdr = get_mdr(hazard, cent_idx, impf)
+    fract = get_fraction(hazard, cent_idx)
+    imp_mat = calc_impact(mdr=mdr, fraction=fract, exp_values=exp.value.values)
+    return imp_mat, exp.index.to_numpy()
+
 class Impact():
     """Impact definition. Compute from an entity (exposures and impact
     functions) and hazard.
@@ -113,15 +236,76 @@ def __init__(self,
         self.unit = unit
         self.imp_mat = imp_mat
 
+    def calc(self, exposures, impact_funcs, hazard, save_mat=False):
+        if ('deductible' in exposures.gdf) and ('cover' in exposures.gdf) \
+            and exposures.gdf.cover.max():
+            #raise DeprecationWarning("To compute the risk transfer value"
+            #    "please use Impact.calc_insured_risk")
+            #self.__dict__ = self.calc_insured_risk(exposures, *args, **kwargs).__dict__
+            self.__dict__ = self.calc_risk(exposures, impact_funcs, hazard, save_mat).__dict__
+        else:
+            self.__dict__ = self.calc_risk(exposures, impact_funcs, hazard, save_mat).__dict__
+
     @classmethod
-    def calc(cls, exposures, impact_funcs, hazard, save_mat=False):
+    def calc_insured_risk(cls, exposures, impact_funcs, hazard, save_mat=False):
+        pass
+
+    @staticmethod
+    def calc_imp_mat(exposures, impact_funcs, hazard):
         """Compute impact of an hazard to exposures.
 
         Parameters
         ----------
         exposures : climada.entity.Exposures
         impact_funcs : climada.entity.ImpactFuncSet
-            impact functions
+            impact functions set
+        hazard : climada.Hazard
+
+        """
+
+        n_events = hazard.size
+        n_exp_pnt = exposures.gdf.shape[0]
+
+        exposures.assign_centroids(hazard, overwrite=False)
+
+        exp_gdf = exposures.affected_values_gdf(hazard)
+        if exp_gdf.size == 0:
+            LOGGER.warning("No exposures with value >0 in the vicinity of the hazard.")
+            return sparse.csr_matrix(np.empty((0, 0)))
+
+        LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
+                    exp_gdf.size, n_events)
+        impf_col = exposures.get_impf_column(hazard.haz_type)
+        imp_mat_per_impf = calc_imp_mat_per_impf(hazard, exp_gdf, impf_col, impact_funcs)
+        data = np.hstack([mat.data for mat, _ in imp_mat_per_impf])
+        row = np.hstack([mat.nonzero()[0] for mat, _ in imp_mat_per_impf])
+        col = np.hstack([idx[mat.nonzero()[1]] for mat, idx in imp_mat_per_impf])
+        imp_mat = sparse.csr_matrix((data, (row, col)), shape=(n_events, n_exp_pnt))
+        return imp_mat
+        # at_event = np.zeros(n_events)
+        # eai_exp = np.zeros(n_exp_pnt)
+        # for imp_mat, exp_idx in imp_mat_per_impf:
+        #     at_event += at_event_from_mat(imp_mat)
+        #     eai_exp[exp_idx] += eai_exp_from_mat(imp_mat, hazard.frequency)
+        # aai_agg = aai_agg_from_eai_exp(eai_exp)
+        # return imp_mat_per_impf[0][0]
+
+    @classmethod
+    def calc_risk(cls, exposures, impact_funcs, hazard, save_mat=True):
+        imp_mat = cls.calc_imp_mat(exposures, impact_funcs, hazard)
+        impact = cls.set_from_imp_mat(imp_mat, exposures, impact_funcs, hazard)
+        return impact
+        # return None
+
+    @classmethod
+    def calc_risk_quick(cls, exposures, impact_funcs, hazard, save_mat=False):
+        """Compute impact of an hazard to exposures.
+
+        Parameters
+        ----------
+        exposures : climada.entity.Exposures
+        impact_funcs : climada.entity.ImpactFuncSet
+            impact functions set
         hazard : climada.Hazard
         save_mat : bool
             self impact matrix: events x exposures
@@ -149,70 +333,130 @@ def calc(cls, exposures, impact_funcs, hazard, save_mat=False):
             >>> imp.aai_agg
         """
 
-        haz_type = hazard.tag.haz_type
-        # 1. Assign centroids to each exposure if not done
-        assign_haz = INDICATOR_CENTR + haz_type
-        if assign_haz not in exposures.gdf:
-            LOGGER.warning(
-                "Exposures have no assigned centroids for Hazard %s.\
-                Centroids will be assigned now.", haz_type
+        n_events = hazard.size
+        n_exp_pnt = exposures.gdf.shape[0]
+
+        exposures.assign_centroids(hazard, overwrite=False)
+
+        exp_gdf = exposures.affected_values_gdf(hazard)
+        if exp_gdf.size == 0:
+            LOGGER.warning("No exposures with value >0 in the vicinity of the hazard.")
+            return cls(
+                event_id = hazard.event_id,
+                event_name = hazard.event_name,
+                date = hazard.date,
+                frequency = hazard.frequency,
+                coord_exp = np.stack([exposures.gdf.latitude.values,
+                                    exposures.gdf.longitude.values],
+                                    axis=1),
+                crs = exposures.crs,
+                unit = exposures.value_unit,
+                tag = {'exp': exposures.tag,
+                    'impf_set': impact_funcs.tag,
+                    'haz': hazard.tag
+                    }
                 )
-            exposures.assign_centroids(hazard)
-        else:
-            LOGGER.info('Exposures matching centroids found in %s', assign_haz)
-
-        # Select exposures with positive value and assigned centroid
-        affected_exp_idx = np.where((exposures.gdf.value > 0) & (exposures.gdf[assign_haz] >= 0))[0]
-        if affected_exp_idx.size == 0:
-            LOGGER.warning("No affected exposures.")
 
-        num_events = hazard.intensity.shape[0]
         LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
-                    affected_exp_idx.size, num_events)
-
-        # Get damage functions for this hazard
-        exp_impf_col_for_haz_type = exposures.get_impf_column(hazard.tag.haz_type)
-        impf_for_haz_type = impact_funcs.get_func(haz_type)
-
-        # Check if impf match
-        impf_ids = [impf.id for impf in impf_for_haz_type]
-        unq_impf_aff_exp = set(exposures[exp_impf_col_for_haz_type])
-        unq_impf = set(impf_ids)
-        if not unq_impf_aff_exp.intersection(unq_impf):
-            raise AttributeError('No impact functions match the exposures.\
-                                 for the hazard type %s', haz_type)
-
-        # Check if deductible and cover should be applied
-        if ('deductible' in exposures.gdf) and ('cover' in exposures.gdf) \
-        and exposures.gdf.cover.max():
-           raise DeprecationWarning(
-               "This method is deprecated for exposures with deductible \
-               and cover. Please use ... instead.")
-
-        # 3. Loop over exposures according to their impact function
-        exp_impf_id = exposures.gdf[exp_impf_col_for_haz_type].values[affected_exp_idx]
-        for impf in impf_for_haz_type:
-            # get indices of all the exposures with this impact function
-            exp_idx = np.where(exp_impf_id = impf.id)[0]
-            exp_step = CONFIG.max_matrix_size.int() // num_events
-            if not exp_step:
-                raise ValueError('Increase max_matrix_size configuration parameter to > %s'
-                                 % str(num_events))
-            # separate in chunks
-            chk = -1
-            for chk in range(int(exp_iimp.size / exp_step)):
-                self._exp_impact(
-                    exp_idx[exp_iimp[chk * exp_step:(chk + 1) * exp_step]],
-                    exposures, hazard, imp_fun, insure_flag)
-            self._exp_impact(exp_idx[exp_iimp[(chk + 1) * exp_step:]],
-                             exposures, hazard, imp_fun, insure_flag)
+                    exp_gdf.size, n_events)
+
+        def get_fraction_mdr(hazard, cent_idx, impf_id):
+            fraction = hazard.fraction[:, cent_idx]
+            impf = impact_funcs.get_func(hazard.haz_type)[impf_id]
+            mdr = hazard.intensity[:, cent_idx]
+            if impf.calc_mdr(0) == 0:
+                mdr.data = impf.calc_mdr(mdr.data)
+            else:
+                LOGGER.warning("Impact function id=%d has mdr(0) != 0."
+                "The impact must thus be computed for all values of"
+                " intensity including 0.", impf_id)
+                mdr = sparse.csr_matrix(impf.calc_mdr(mdr.toarray()))
+            return fraction, mdr
+
+        def make_full_imp_mat(imp_mat, haz_size, exp_size, exp_idx):
+            data = imp_mat.data
+            row, col = imp_mat.nonzero()
+            return sparse.coo_matrix((data, (row, exp_idx[col])), shape=(haz_size, exp_size))
+        def calc_impact(mdr, fraction, exp_values):
+            return fraction.multiply(mdr).multiply(exp_values)
+
+        def calc_impact_stats(hazard, n_exp_pnt, exp_gdf, impf_col):
+            n_events = hazard.size
+            tot_value = 0
+            at_event = np.zeros(n_events)
+            eai_exp = np.zeros(n_exp_pnt)
+            imp_mat_list = []
+            for impf_id, exp_impf_gdf in exp_gdf.groupby(impf_col):
+                cent_idx = exp_impf_gdf[hazard.cent_exp_col].values
+                mdr, fract = get_fraction_mdr(hazard, cent_idx, impf_id)
+                imp_mat = calc_impact(mdr=mdr, fraction=fract, exp_values=exp_impf_gdf.value.values)
+
+                exp_idx = exp_impf_gdf.index.to_numpy()
+                eai_exp[exp_idx] += eai_exp_from_mat(imp_mat, hazard.frequency)
+                at_event += at_event_from_mat(imp_mat)
+                tot_value += exp_impf_gdf.value.sum()
+                if save_mat:
+                    imp_mat_list.append(make_full_imp_mat(imp_mat, n_events, n_exp_pnt, exp_idx).tocsr())
+            return imp_mat_list, at_event, eai_exp, tot_value
+
+        impf_col = exposures.get_impf_column(hazard.haz_type)
+        imp_mat_list, at_event, eai_exp, tot_value = calc_impact_stats(hazard, n_exp_pnt, exp_gdf, impf_col)
+        aai_agg = aai_agg_from_eai_exp(eai_exp)
+
+        if save_mat:
+            imp_mat = sparse.csr_matrix((n_events, n_exp_pnt))
+            for imp in imp_mat_list:
+                imp_mat += imp
+        else:
+            imp_mat = sparse.csr_matrix(np.empty((0, 0)))
 
+        return cls(
+            event_id = hazard.event_id,
+            event_name = hazard.event_name,
+            date = hazard.date,
+            frequency = hazard.frequency,
+            coord_exp = np.stack([exposures.gdf.latitude.values,
+                                  exposures.gdf.longitude.values],
+                                 axis=1),
+            crs = exposures.crs,
+            unit = exposures.value_unit,
+            tot_value = tot_value,
+            eai_exp = eai_exp,
+            at_event = at_event,
+            aai_agg = aai_agg,
+            imp_mat = imp_mat,
+            tag = {'exp': exposures.tag,
+                   'impf_set': impact_funcs.tag,
+                   'haz': hazard.tag
+                   }
+            )
 
+    @classmethod
+    def set_from_imp_mat(cls, imp_mat, exposures, impf_set, hazard):
+        """
+        Set Impact attributes from the impact matrix.
 
+        Parameters
+        ----------
+        imp_mat : sparse.csr_matrix
+            matrix num_events x num_exp with impacts.
+        exposures : climada.entity.Exposures
+        impf_set: climada.entity.ImpactFuncSet
+            impact functions set
+        hazard : climada.Hazard
+        Returns
+        -------
+        imp : Impact
+            Copy of impact with eai_exp, at_event, aai_agg, imp_mat set.
+        """
+        eai_exp = eai_exp_from_mat(imp_mat, hazard.frequency)
+        at_event = at_event_from_mat(imp_mat)
+        aai_agg = aai_agg_from_eai_exp(eai_exp)
+        tot_value = exposures.affected_values_gdf(hazard).value.sum()
         return cls(
             event_id = hazard.event_id,
             event_name = hazard.event_name,
-            date = hazard.data,
+            date = hazard.date,
             frequency = hazard.frequency,
             coord_exp = np.stack([exposures.gdf.latitude.values,
                                   exposures.gdf.longitude.values],
@@ -225,15 +469,57 @@ def calc(cls, exposures, impact_funcs, hazard, save_mat=False):
             aai_agg = aai_agg,
             imp_mat = imp_mat,
             tag = {'exp': exposures.tag,
-                   'impf_set': impact_funcs.tag,
+                   'impf_set': impf_set.tag,
                    'haz': hazard.tag
                    }
             )
 
+    def calc_transfer_risk(self, attachment, cover):
+        """Compute the risk transfer
+
+        Parameters
+        ----------
+        attachment : _type_
+            _description_
+        cover : _type_
+            _description_
+
+        Returns
+        -------
+        _type_
+            _description_
+        """
+        transfer_at_event = np.minimum(np.maximum(self.at_event - attachment, 0), cover)
+        transfer_aai_agg = np.sum(transfer_at_event * self.frequency)
+        return transfer_at_event, transfer_aai_agg
+
+    def calc_residual_risk(self, attachment, cover):
+        """Compute the residual risk after application of insurance
+        attachment (deductible of full portfolio) and cover.
+
+        Parameters
+        ----------
+        attachment : float
+            The amount that must be paid by the customer per event before
+            the cover takes over
+        cover : float
+            The maximum amount that is covered per event.
+        Returns
+        -------
+        climada.engine.Impact:
+            Impact object that desribes the residual (not cover, not deduced)
+            impact per event. The impact matrix is always defined.
+
+        """
+        transfer_at_event, _ = self.calc_transfer_risk(attachment, cover)
+        residual_at_event = np.maximum(self.at_event - transfer_at_event, 0)
+        residual_aai_agg = np.sum(residual_at_event * self.frequency)
+        return residual_at_event, residual_aai_agg
 
     def calc_risk_transfer(self, attachment, cover):
         """Compute traaditional risk transfer over impact. Returns new impact
-        with risk transfer applied and the insurance layer resulting Impact metrics.
+        with risk transfer applied and the insurance layer resulting
+        Impact metrics.
 
         Parameters
         ----------
@@ -245,6 +531,10 @@ def calc_risk_transfer(self, attachment, cover):
         -------
         climada.engine.Impact
         """
+        LOGGER.warning("The use of Impact.calc_risk_transfer is deprecated."
+                       "Use Impact.calc_residual_risk and "
+                       "Impact.calc_transfer_risk instead."
+                       )
         new_imp = copy.deepcopy(self)
         if attachment or cover:
             imp_layer = np.minimum(np.maximum(new_imp.at_event - attachment, 0), cover)
@@ -262,47 +552,13 @@ def calc_risk_transfer(self, attachment, cover):
 
         return new_imp, Impact()
 
-    def plot_hexbin_eai_exposure(self, mask=None, ignore_zero=True,
-                                 pop_name=True, buffer=0.0, extend='neither',
-                                 axis=None, adapt_fontsize=True, **kwargs):
-        """Plot hexbin expected annual impact of each exposure.
-
-        Parameters
-        ----------
-            mask : np.array, optional
-                mask to apply to eai_exp plotted.
-            ignore_zero : bool, optional
-                flag to indicate if zero and negative
-                values are ignored in plot. Default: False
-            pop_name : bool, optional
-                add names of the populated places
-            buffer : float, optional
-                border to add to coordinates.
-                Default: 1.0.
-            extend : str, optional
-                extend border colorbar with arrows.
-                [ 'neither' | 'both' | 'min' | 'max' ]
-            axis : matplotlib.axes._subplots.AxesSubplot, optional
-                axis to use
-            kwargs : optional
-                arguments for hexbin matplotlib function
-
-        Returns
-        -------
-            cartopy.mpl.geoaxes.GeoAxesSubplot
-        """
-        if 'cmap' not in kwargs:
-            kwargs['cmap'] = CMAP_IMPACT
-
-        eai_exp = self._build_exp()
-        axis = eai_exp.plot_hexbin(mask, ignore_zero, pop_name, buffer,
-                                   extend, axis=axis, adapt_fontsize=adapt_fontsize, **kwargs)
-        axis.set_title('Expected annual impact')
-        return axis
-
-    def calc_impact_year_set(self, all_years=True, year_range=None):
+    def calc_impact_per_year(self, all_years=True, year_range=None):
         """Calculate yearly impact from impact data.
 
+        Note: the impact in a given year is summed over all events.
+        Thus, the impact in a given year can be larger than the
+        total affected exposure value.
+
         Parameters
         ----------
         all_years : boolean
@@ -310,10 +566,10 @@ def calc_impact_year_set(self, all_years=True, year_range=None):
             last year with event, including years without any events.
         year_range : tuple or list with integers
             start and end year
-
         Returns
         -------
-        Impact year set of type numpy.ndarray with summed impact per year.
+        year_set: dict
+            Key=year, value=Summed impact per year.
         """
         if year_range is None:
             year_range = []
@@ -338,6 +594,12 @@ def calc_impact_year_set(self, all_years=True, year_range=None):
             year_set[year] = sum(self.at_event[orig_year == year])
         return year_set
 
+    def calc_impact_year_set(self, *args, **kwargs):
+        """This function is deprecated, use Impact.calc_impact_per_year instead."""
+        LOGGER.warning("The use of Impact.calc_impact_year_set is deprecated."
+                       "Use Impact.calc_impact_per_year instead.")
+        return self.calc_impact_per_year(*args, **kwargs)
+
     def local_exceedance_imp(self, return_periods=(25, 50, 100, 250)):
         """Compute exceedance impact map for given return periods.
         Requires attribute imp_mat.
@@ -448,6 +710,44 @@ def plot_scatter_eai_exposure(self, mask=None, ignore_zero=True,
         axis.set_title('Expected annual impact')
         return axis
 
+    def plot_hexbin_eai_exposure(self, mask=None, ignore_zero=True,
+                                 pop_name=True, buffer=0.0, extend='neither',
+                                 axis=None, adapt_fontsize=True, **kwargs):
+        """Plot hexbin expected annual impact of each exposure.
+
+        Parameters
+        ----------
+            mask : np.array, optional
+                mask to apply to eai_exp plotted.
+            ignore_zero : bool, optional
+                flag to indicate if zero and negative
+                values are ignored in plot. Default: False
+            pop_name : bool, optional
+                add names of the populated places
+            buffer : float, optional
+                border to add to coordinates.
+                Default: 1.0.
+            extend : str, optional
+                extend border colorbar with arrows.
+                [ 'neither' | 'both' | 'min' | 'max' ]
+            axis : matplotlib.axes._subplots.AxesSubplot, optional
+                axis to use
+            kwargs : optional
+                arguments for hexbin matplotlib function
+
+        Returns
+        -------
+            cartopy.mpl.geoaxes.GeoAxesSubplot
+        """
+        if 'cmap' not in kwargs:
+            kwargs['cmap'] = CMAP_IMPACT
+
+        eai_exp = self._build_exp()
+        axis = eai_exp.plot_hexbin(mask, ignore_zero, pop_name, buffer,
+                                   extend, axis=axis, adapt_fontsize=adapt_fontsize, **kwargs)
+        axis.set_title('Expected annual impact')
+        return axis
+
     def plot_raster_eai_exposure(self, res=None, raster_res=None, save_tiff=None,
                                  raster_f=lambda x: np.log10((np.fmax(x + 1, 1))),
                                  label='value (log10)', axis=None, adapt_fontsize=True,
@@ -1015,53 +1315,6 @@ def _loc_return_imp(self, return_periods, imp, exc_imp):
                 imp_sort[:, cen_idx], freq_sort[:, cen_idx],
                 0, return_periods)
 
-    def _exp_impact(self, exp_iimp, exposures, hazard, imp_fun, insure_flag):
-        """Compute impact for input exposure indexes and impact function.
-
-        Parameters
-        ----------
-        exp_iimp : np.array exposures indexes
-        exposures: climada.entity.Exposures instance
-        hazard : climada.Hazard
-        imp_fun : climada.entity.ImpactFunc
-            impact function instance
-        insure_flag : bool
-            consider deductible and cover of exposures
-        """
-        if not exp_iimp.size:
-            return
-
-        # get assigned centroids
-        icens = exposures.gdf[INDICATOR_CENTR + hazard.tag.haz_type].values[exp_iimp]
-
-        # get affected intensities
-        inten_val = hazard.intensity[:, icens]
-        # get affected fractions
-        fract = hazard.fraction[:, icens]
-        # impact = fraction * mdr * value
-        inten_val.data = imp_fun.calc_mdr(inten_val.data)
-        impact = fract.multiply(inten_val).multiply(exposures.gdf.value.values[exp_iimp])
-
-        if insure_flag and impact.nonzero()[0].size:
-            inten_val = hazard.intensity[:, icens].toarray()
-            paa = np.interp(inten_val, imp_fun.intensity, imp_fun.paa)
-            impact = impact.toarray()
-            impact -= exposures.gdf.deductible.values[exp_iimp] * paa
-            impact = np.clip(impact, 0, exposures.gdf.cover.values[exp_iimp])
-            self.eai_exp[exp_iimp] += np.einsum('ji,j->i', impact, hazard.frequency)
-            impact = sparse.coo_matrix(impact)
-        else:
-            self.eai_exp[exp_iimp] += np.squeeze(np.asarray(np.sum(
-                impact.multiply(hazard.frequency.reshape(-1, 1)), axis=0)))
-
-        self.at_event += np.squeeze(np.asarray(np.sum(impact, axis=1)))
-        self.tot_value += np.sum(exposures.gdf.value.values[exp_iimp])
-        if isinstance(self.imp_mat, tuple):
-            row_ind, col_ind = impact.nonzero()
-            self.imp_mat[0].extend(list(impact.data))
-            self.imp_mat[1][0].extend(list(row_ind))
-            self.imp_mat[1][1].extend(list(exp_iimp[col_ind]))
-
     def _build_exp(self):
         return Exposures(
             data={
diff --git a/climada/engine/test/test_impact.py b/climada/engine/test/test_impact.py
index 01be9fd1a..4a92cc83d 100644
--- a/climada/engine/test/test_impact.py
+++ b/climada/engine/test/test_impact.py
@@ -207,7 +207,7 @@ def test_ref_value_pass(self):
         self.assertEqual(0, impact.at_event[0])
         self.assertEqual(0, impact.at_event[int(num_events / 2)])
         self.assertAlmostEqual(1.472482938320243e+08, impact.at_event[13809])
-        self.assertEqual(7.076504723057620e+10, impact.at_event[12147])
+        self.assertAlmostEqual(7.076504723057620e+10, impact.at_event[12147])
         self.assertEqual(0, impact.at_event[num_events - 1])
         # impact.eai_exp == EDS.ED_at_centroid in MATLAB
         self.assertEqual(num_exp, len(impact.eai_exp))

From 51fdbb6b712c8093c82369eb26f0d46d973b9b6e Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Tue, 12 Apr 2022 14:25:51 +0200
Subject: [PATCH 012/121] Add insurance layers

---
 climada/engine/impact.py | 393 ++++++++++++---------------------------
 1 file changed, 117 insertions(+), 276 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 427751991..394f9a51c 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -93,57 +93,26 @@ def aai_agg_from_eai_exp(eai_exp):
     """
     return sum(eai_exp)
 
-def get_mdr(hazard, cent_idx, impf):
-    uniq_cent_idx, indices = np.unique(cent_idx, return_inverse=True)
-    mdr = hazard.intensity[:, uniq_cent_idx]
-    if impf.calc_mdr(0) == 0:
-        mdr.data = impf.calc_mdr(mdr.data)
-    else:
-        LOGGER.warning("Impact function id=%d has mdr(0) != 0."
-        "The impact must thus be computed for all values of"
-        " intensity including 0.", impf.id)
-    return mdr[:, indices]
-
-def get_fraction(hazard, cent_idx):
-    return hazard.fraction[:, cent_idx]
-
-# def make_full_imp_mat(imp_mat, haz_size, exp_size, exp_idx):
-#     data = imp_mat.data
-#     row, col = imp_mat.nonzero()
-#     return sparse.csr_matrix((data, (row, exp_idx[col])), shape=(haz_size, exp_size))
-
-# def make_full_imp_mat(imp_mat, haz_size, exp_size, exp_idx):
-#     data = imp_mat.data
-#     row, col = imp_mat.nonzero()
-#     return [data, row, exp_idx[col]]
-
-# def calc_impact(mdr, fraction, exp_values):
-#     return mdr.multiply(fraction).multiply(exp_values)
-
-# def calc_imp_mat_per_impf(hazard, n_exp_pnt, exp_gdf, impf_col, impf_set):
-#     n_events = hazard.size
-#     imp_mat_list = []
-#     for impf_id, exp_impf_gdf in exp_gdf.groupby(impf_col):
-#         exp_step = CONFIG.max_matrix_size.int() // n_events
-#         chk = -1
-#         for chk in range(int(len(exp_impf_gdf) / exp_step)):
-#             exp = exp_impf_gdf[chk * exp_step:(chk + 1) * exp_step]
-#             imp_mat_list.append(calc_one_imp_mat(exp, hazard, n_events, n_exp_pnt, impf_set, impf_id))
-#         exp = exp_impf_gdf[(chk + 1) * exp_step:]
-#         imp_mat_list.append(calc_one_imp_mat(exp, hazard, n_events, n_exp_pnt, impf_set, impf_id))
-#     return imp_mat_list
-
-# def calc_one_imp_mat(exp, hazard, n_events, n_exp_pnt, impf_set, impf_id):
-#     cent_idx = exp[hazard.cent_exp_col].values
-#     mdr = get_mdr(hazard, cent_idx, impf_id, impf_set)
-#     fract = get_fraction(hazard, cent_idx)
-#     imp_mat = calc_impact(mdr=mdr, fraction=fract, exp_values=exp.value.values)
-#     return make_full_imp_mat(imp_mat, n_events, n_exp_pnt, exp.index.to_numpy())
-
-# def make_imp_data(imp_mat, exp_idx):
-#     data = imp_mat.data
-#     row, col = imp_mat.nonzero()
-#     return [data, row, exp_idx[col]]
+def calc_impstats_from_mat(self, imp_mat, freq):
+    """
+    Compute impact statistics eai_exp, at_event, aai_agg
+    for an impact matrix and frequency vector.
+
+    Parameters
+    ----------
+    imp_mat : sparse.csr_matrix
+        matrix num_events x num_exp with impacts.
+    freq : np.array
+        array with the frequency per event
+    Returns
+    -------
+    imp : Impact
+        Copy of impact with eai_exp, at_event, aai_agg, imp_mat set.
+    """
+    eai_exp = eai_exp_from_mat(imp_mat, freq)
+    at_event = at_event_from_mat(imp_mat)
+    aai_agg = aai_agg_from_eai_exp(eai_exp)
+    return eai_exp, at_event, aai_agg
 
 def calc_impact(mdr, fraction, exp_values):
     return fraction.multiply(mdr).multiply(sparse.csr_matrix(exp_values))
@@ -166,11 +135,23 @@ def calc_imp_mat_per_impf(hazard, exp_gdf, impf_col, impf_set):
 
 def calc_one_imp_mat(exp, hazard, impf):
     cent_idx = exp[hazard.cent_exp_col].values
-    mdr = get_mdr(hazard, cent_idx, impf)
-    fract = get_fraction(hazard, cent_idx)
+    mdr = hazard.get_mdr(cent_idx, impf)
+    fract = hazard.get_fraction(cent_idx)
     imp_mat = calc_impact(mdr=mdr, fraction=fract, exp_values=exp.value.values)
     return imp_mat, exp.index.to_numpy()
 
+
+def apply_deductible_to_imp_mat(imp_mat, deductible, hazard, cent_idx, impf):
+    paa = hazard.get_paa(cent_idx, impf)
+    imp_mat -= paa.multiply(sparse.csr_matrix(deductible))
+    return imp_mat
+
+
+def apply_cover_to_imp_mat(imp_mat, cover):
+    imp_mat.data = np.clip(imp_mat.data, 0, cover.to_numpy()[imp_mat.nonzero()[1]])
+    return imp_mat
+
+
 class Impact():
     """Impact definition. Compute from an entity (exposures and impact
     functions) and hazard.
@@ -239,19 +220,67 @@ def __init__(self,
     def calc(self, exposures, impact_funcs, hazard, save_mat=False):
         if ('deductible' in exposures.gdf) and ('cover' in exposures.gdf) \
             and exposures.gdf.cover.max():
-            #raise DeprecationWarning("To compute the risk transfer value"
-            #    "please use Impact.calc_insured_risk")
-            #self.__dict__ = self.calc_insured_risk(exposures, *args, **kwargs).__dict__
-            self.__dict__ = self.calc_risk(exposures, impact_funcs, hazard, save_mat).__dict__
+            # raise DeprecationWarning("To compute the risk transfer value"
+            #     "please use Impact.calc_insured_risk")
+            self.__dict__ = self.calc_insured_risk(exposures, impact_funcs, hazard, save_mat).__dict__
         else:
             self.__dict__ = self.calc_risk(exposures, impact_funcs, hazard, save_mat).__dict__
 
     @classmethod
     def calc_insured_risk(cls, exposures, impact_funcs, hazard, save_mat=False):
-        pass
+        n_exp_pnt = exposures.gdf.shape[0]
+        n_events = hazard.size
+        imp_mat_list = cls.calc_imp_mat_list(exposures, impact_funcs, hazard)
+        at_event = np.zeros(n_events)
+        eai_exp = np.zeros(n_exp_pnt)
+        impf_col = exposures.get_impf_column(hazard.haz_type)
+        imp_mat_list2 = []
+        for mat, exp_idx in imp_mat_list:
+            impf_id = exposures.gdf[impf_col][exp_idx].unique()[0]
+            deductible = exposures.gdf['deductible'][exp_idx]
+            cent_idx = exposures.gdf['centr_TC'][exp_idx]
+            impf = impact_funcs.get_func(haz_type=hazard.haz_type, fun_id=impf_id)
+            mat = apply_deductible_to_imp_mat(mat, deductible, hazard, cent_idx, impf)
+            cover = exposures.gdf['cover'][exp_idx]
+            mat = apply_cover_to_imp_mat(mat, cover)
+            imp_mat_list2.append((mat, exp_idx))
+        imp_mat_list = imp_mat_list2
+        if save_mat:
+            data = np.hstack([mat.data for mat, _ in imp_mat_list])
+            row = np.hstack([mat.nonzero()[0] for mat, _ in imp_mat_list])
+            col = np.hstack([idx[mat.nonzero()[1]] for mat, idx in imp_mat_list])
+            imp_mat = sparse.csr_matrix((data, (row, col)), shape=(n_events, n_exp_pnt))
+            return cls.set_from_imp_mat(imp_mat, exposures, impact_funcs, hazard)
+        else:
+            at_event = np.zeros(n_events)
+            eai_exp = np.zeros(n_exp_pnt)
+            for imp_mat, exp_idx in imp_mat_list:
+                at_event += at_event_from_mat(imp_mat)
+                eai_exp[exp_idx] += eai_exp_from_mat(imp_mat, hazard.frequency)
+            aai_agg = aai_agg_from_eai_exp(eai_exp)
+            tot_value = exposures.affected_values_gdf(hazard).value.sum()
+            return cls(
+                event_id = hazard.event_id,
+                event_name = hazard.event_name,
+                date = hazard.date,
+                frequency = hazard.frequency,
+                coord_exp = np.stack([exposures.gdf.latitude.values,
+                                      exposures.gdf.longitude.values],
+                                     axis=1),
+                crs = exposures.crs,
+                unit = exposures.value_unit,
+                tot_value = tot_value,
+                eai_exp = eai_exp,
+                at_event = at_event,
+                aai_agg = aai_agg,
+                tag = {'exp': exposures.tag,
+                       'impf_set': impact_funcs.tag,
+                       'haz': hazard.tag
+                       }
+                )
 
     @staticmethod
-    def calc_imp_mat(exposures, impact_funcs, hazard):
+    def calc_imp_mat_list(exposures, impact_funcs, hazard):
         """Compute impact of an hazard to exposures.
 
         Parameters
@@ -263,9 +292,6 @@ def calc_imp_mat(exposures, impact_funcs, hazard):
 
         """
 
-        n_events = hazard.size
-        n_exp_pnt = exposures.gdf.shape[0]
-
         exposures.assign_centroids(hazard, overwrite=False)
 
         exp_gdf = exposures.affected_values_gdf(hazard)
@@ -274,163 +300,49 @@ def calc_imp_mat(exposures, impact_funcs, hazard):
             return sparse.csr_matrix(np.empty((0, 0)))
 
         LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
-                    exp_gdf.size, n_events)
+                    exp_gdf.size, hazard.size)
         impf_col = exposures.get_impf_column(hazard.haz_type)
-        imp_mat_per_impf = calc_imp_mat_per_impf(hazard, exp_gdf, impf_col, impact_funcs)
-        data = np.hstack([mat.data for mat, _ in imp_mat_per_impf])
-        row = np.hstack([mat.nonzero()[0] for mat, _ in imp_mat_per_impf])
-        col = np.hstack([idx[mat.nonzero()[1]] for mat, idx in imp_mat_per_impf])
-        imp_mat = sparse.csr_matrix((data, (row, col)), shape=(n_events, n_exp_pnt))
-        return imp_mat
-        # at_event = np.zeros(n_events)
-        # eai_exp = np.zeros(n_exp_pnt)
-        # for imp_mat, exp_idx in imp_mat_per_impf:
-        #     at_event += at_event_from_mat(imp_mat)
-        #     eai_exp[exp_idx] += eai_exp_from_mat(imp_mat, hazard.frequency)
-        # aai_agg = aai_agg_from_eai_exp(eai_exp)
-        # return imp_mat_per_impf[0][0]
+        return calc_imp_mat_per_impf(hazard, exp_gdf, impf_col, impact_funcs)
 
     @classmethod
     def calc_risk(cls, exposures, impact_funcs, hazard, save_mat=True):
-        imp_mat = cls.calc_imp_mat(exposures, impact_funcs, hazard)
-        impact = cls.set_from_imp_mat(imp_mat, exposures, impact_funcs, hazard)
-        return impact
-        # return None
-
-    @classmethod
-    def calc_risk_quick(cls, exposures, impact_funcs, hazard, save_mat=False):
-        """Compute impact of an hazard to exposures.
-
-        Parameters
-        ----------
-        exposures : climada.entity.Exposures
-        impact_funcs : climada.entity.ImpactFuncSet
-            impact functions set
-        hazard : climada.Hazard
-        save_mat : bool
-            self impact matrix: events x exposures
-
-        Examples
-        --------
-            Use Entity class:
-
-            >>> haz = Hazard.from_mat(HAZ_DEMO_MAT)  # Set hazard
-            >>> haz.check()
-            >>> ent = Entity.from_excel(ENT_TEMPLATE_XLS) # Set exposures
-            >>> ent.check()
-            >>> imp = Impact.calc(ent.exposures, ent.impact_funcs, haz)
-            >>> imp.calc_freq_curve().plot()
-
-            Specify only exposures and impact functions:
-
-            >>> haz = Hazard.from_mat(HAZ_DEMO_MAT)  # Set hazard
-            >>> haz.check()
-            >>> funcs = ImpactFuncSet.from_excel(ENT_TEMPLATE_XLS) # Set impact functions
-            >>> funcs.check()
-            >>> exp = Exposures(pd.read_excel(ENT_TEMPLATE_XLS)) # Set exposures
-            >>> exp.check()
-            >>> imp = Impact.calc(exp, funcs, haz)
-            >>> imp.aai_agg
-        """
-
-        n_events = hazard.size
         n_exp_pnt = exposures.gdf.shape[0]
-
-        exposures.assign_centroids(hazard, overwrite=False)
-
-        exp_gdf = exposures.affected_values_gdf(hazard)
-        if exp_gdf.size == 0:
-            LOGGER.warning("No exposures with value >0 in the vicinity of the hazard.")
+        n_events = hazard.size
+        imp_mat_list = cls.calc_imp_mat_list(exposures, impact_funcs, hazard)
+        if save_mat:
+            data = np.hstack([mat.data for mat, _ in imp_mat_list])
+            row = np.hstack([mat.nonzero()[0] for mat, _ in imp_mat_list])
+            col = np.hstack([idx[mat.nonzero()[1]] for mat, idx in imp_mat_list])
+            imp_mat = sparse.csr_matrix((data, (row, col)), shape=(n_events, n_exp_pnt))
+            return cls.set_from_imp_mat(imp_mat, exposures, impact_funcs, hazard)
+        else:
+            at_event = np.zeros(n_events)
+            eai_exp = np.zeros(n_exp_pnt)
+            for imp_mat, exp_idx in imp_mat_list:
+                at_event += at_event_from_mat(imp_mat)
+                eai_exp[exp_idx] += eai_exp_from_mat(imp_mat, hazard.frequency)
+            aai_agg = aai_agg_from_eai_exp(eai_exp)
+            tot_value = exposures.affected_values_gdf(hazard).value.sum()
             return cls(
                 event_id = hazard.event_id,
                 event_name = hazard.event_name,
                 date = hazard.date,
                 frequency = hazard.frequency,
                 coord_exp = np.stack([exposures.gdf.latitude.values,
-                                    exposures.gdf.longitude.values],
-                                    axis=1),
+                                      exposures.gdf.longitude.values],
+                                     axis=1),
                 crs = exposures.crs,
                 unit = exposures.value_unit,
+                tot_value = tot_value,
+                eai_exp = eai_exp,
+                at_event = at_event,
+                aai_agg = aai_agg,
                 tag = {'exp': exposures.tag,
-                    'impf_set': impact_funcs.tag,
-                    'haz': hazard.tag
-                    }
+                       'impf_set': impact_funcs.tag,
+                       'haz': hazard.tag
+                       }
                 )
 
-        LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
-                    exp_gdf.size, n_events)
-
-        def get_fraction_mdr(hazard, cent_idx, impf_id):
-            fraction = hazard.fraction[:, cent_idx]
-            impf = impact_funcs.get_func(hazard.haz_type)[impf_id]
-            mdr = hazard.intensity[:, cent_idx]
-            if impf.calc_mdr(0) == 0:
-                mdr.data = impf.calc_mdr(mdr.data)
-            else:
-                LOGGER.warning("Impact function id=%d has mdr(0) != 0."
-                "The impact must thus be computed for all values of"
-                " intensity including 0.", impf_id)
-                mdr = sparse.csr_matrix(impf.calc_mdr(mdr.toarray()))
-            return fraction, mdr
-
-        def make_full_imp_mat(imp_mat, haz_size, exp_size, exp_idx):
-            data = imp_mat.data
-            row, col = imp_mat.nonzero()
-            return sparse.coo_matrix((data, (row, exp_idx[col])), shape=(haz_size, exp_size))
-        def calc_impact(mdr, fraction, exp_values):
-            return fraction.multiply(mdr).multiply(exp_values)
-
-        def calc_impact_stats(hazard, n_exp_pnt, exp_gdf, impf_col):
-            n_events = hazard.size
-            tot_value = 0
-            at_event = np.zeros(n_events)
-            eai_exp = np.zeros(n_exp_pnt)
-            imp_mat_list = []
-            for impf_id, exp_impf_gdf in exp_gdf.groupby(impf_col):
-                cent_idx = exp_impf_gdf[hazard.cent_exp_col].values
-                mdr, fract = get_fraction_mdr(hazard, cent_idx, impf_id)
-                imp_mat = calc_impact(mdr=mdr, fraction=fract, exp_values=exp_impf_gdf.value.values)
-
-                exp_idx = exp_impf_gdf.index.to_numpy()
-                eai_exp[exp_idx] += eai_exp_from_mat(imp_mat, hazard.frequency)
-                at_event += at_event_from_mat(imp_mat)
-                tot_value += exp_impf_gdf.value.sum()
-                if save_mat:
-                    imp_mat_list.append(make_full_imp_mat(imp_mat, n_events, n_exp_pnt, exp_idx).tocsr())
-            return imp_mat_list, at_event, eai_exp, tot_value
-
-        impf_col = exposures.get_impf_column(hazard.haz_type)
-        imp_mat_list, at_event, eai_exp, tot_value = calc_impact_stats(hazard, n_exp_pnt, exp_gdf, impf_col)
-        aai_agg = aai_agg_from_eai_exp(eai_exp)
-
-        if save_mat:
-            imp_mat = sparse.csr_matrix((n_events, n_exp_pnt))
-            for imp in imp_mat_list:
-                imp_mat += imp
-        else:
-            imp_mat = sparse.csr_matrix(np.empty((0, 0)))
-
-        return cls(
-            event_id = hazard.event_id,
-            event_name = hazard.event_name,
-            date = hazard.date,
-            frequency = hazard.frequency,
-            coord_exp = np.stack([exposures.gdf.latitude.values,
-                                  exposures.gdf.longitude.values],
-                                 axis=1),
-            crs = exposures.crs,
-            unit = exposures.value_unit,
-            tot_value = tot_value,
-            eai_exp = eai_exp,
-            at_event = at_event,
-            aai_agg = aai_agg,
-            imp_mat = imp_mat,
-            tag = {'exp': exposures.tag,
-                   'impf_set': impact_funcs.tag,
-                   'haz': hazard.tag
-                   }
-            )
-
     @classmethod
     def set_from_imp_mat(cls, imp_mat, exposures, impf_set, hazard):
         """
@@ -594,11 +506,11 @@ def calc_impact_per_year(self, all_years=True, year_range=None):
             year_set[year] = sum(self.at_event[orig_year == year])
         return year_set
 
-    def calc_impact_year_set(self, *args, **kwargs):
+    def calc_impact_year_set(self,all_years=True, year_range=None):
         """This function is deprecated, use Impact.calc_impact_per_year instead."""
         LOGGER.warning("The use of Impact.calc_impact_year_set is deprecated."
                        "Use Impact.calc_impact_per_year instead.")
-        return self.calc_impact_per_year(*args, **kwargs)
+        return self.calc_impact_per_year(all_years=all_years, year_range=year_range)
 
     def local_exceedance_imp(self, return_periods=(25, 50, 100, 250)):
         """Compute exceedance impact map for given return periods.
@@ -1388,77 +1300,6 @@ def _cen_return_imp(imp, freq, imp_th, return_periods):
 
         return imp_fit
 
-    def calc_imp_from_mat(self, imp_mat, freq):
-        """
-        Set Impact attributes from the impact matrix. Returns a copy.
-        Overwrites eai_exp, at_event, aai_agg, imp_mat.
-
-        Parameters
-        ----------
-        imp_mat : sparse.csr_matrix
-            matrix num_events x num_exp with impacts.
-        freq : np.array
-            array with the frequency per event
-        Returns
-        -------
-        imp : Impact
-            Copy of impact with eai_exp, at_event, aai_agg, imp_mat set.
-        """
-        eai_exp = self._eai_exp_from_mat(imp_mat, freq)
-        at_event = self._at_event_from_mat(imp_mat)
-        aai_agg = self._aai_agg_from_at_event(at_event, freq)
-        return eai_exp, at_event, aai_agg
-
-    def _eai_exp_from_mat(self, imp_mat, freq):
-        """
-        Compute impact for each exposures from the total impact matrix
-
-        Parameters
-        ----------
-        imp_mat : sparse.csr_matrix
-            matrix num_events x num_exp with impacts.
-        frequency : np.array
-            annual frequency of events
-        Returns
-        -------
-        eai_exp : np.array
-            expected annual impact for each exposure
-        """
-        freq_mat = freq.reshape(len(freq), 1)
-        return imp_mat.multiply(freq_mat).sum(axis=0).A1
-
-    def _at_event_from_mat(self, imp_mat):
-        """
-        Compute impact for each hazard event from the total impact matrix
-
-        Parameters
-        ----------
-        imp_mat : sparse.csr_matrix
-            matrix num_events x num_exp with impacts.
-        Returns
-        -------
-        at_event : np.array
-            impact for each hazard event
-        """
-        return np.squeeze(np.asarray(np.sum(imp_mat, axis=1)))
-
-    def _aai_agg_from_at_event(self, at_event, freq):
-        """
-        Aggregate impact.at_event
-
-        Parameters
-        ----------
-        at_event : np.array
-            impact for each hazard event
-        frequency : np.array
-            annual frequency of event
-        Returns
-        -------
-        float
-            average annual impact aggregated
-        """
-        return sum(at_event * freq)
-
     def select(self,
                event_ids=None, event_names=None, dates=None,
                coord_exp=None):

From ad093affb86878e74b72dd58ef442f600d5d4e94 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Tue, 12 Apr 2022 14:26:04 +0200
Subject: [PATCH 013/121] Add methods get mdr, paa, fraction

---
 climada/hazard/base.py | 54 +++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 53 insertions(+), 1 deletion(-)

diff --git a/climada/hazard/base.py b/climada/hazard/base.py
index 893ced111..5441b2e6c 100644
--- a/climada/hazard/base.py
+++ b/climada/hazard/base.py
@@ -1764,7 +1764,7 @@ def change_centroids(self, centroids, threshold=NEAREST_NEIGHBOR_THRESHOLD):
                     ))
 
         return haz_new_cent
-        
+
     @property
     def cent_exp_col(self):
         from climada.entity.exposures import INDICATOR_CENTR
@@ -1773,3 +1773,55 @@ def cent_exp_col(self):
     @property
     def haz_type(self):
         return self.tag.haz_type
+
+    def get_mdr(self, cent_idx, impf):
+        """
+        Return Mean Damage Ratio (mdr) for chosen centroids (cent_idx)
+        for given impact function.
+
+        Parameters
+        ----------
+        cent_idx : array-like
+            array of indices of chosen centroids from hazard
+        impf : ImpactFunc
+            impact function to compute mdr
+
+        Returns
+        -------
+        sparse.csr_matrix
+            sparse matrix (n_events x len(cent_idx)) with mdr values
+
+        """
+        uniq_cent_idx, indices = np.unique(cent_idx, return_inverse=True)
+        mdr = self.intensity[:, uniq_cent_idx]
+        if impf.calc_mdr(0) == 0:
+            mdr.data = impf.calc_mdr(mdr.data)
+        else:
+            LOGGER.warning("Impact function id=%d has mdr(0) != 0."
+            "The mean damage ratio must thus be computed for all values of"
+            "hazard intensity including 0 which can be very time consuming.",
+            impf.id)
+        return mdr[:, indices]
+
+    def get_paa(self, cent_idx, impf):
+        uniq_cent_idx, indices = np.unique(cent_idx, return_inverse=True)
+        paa = self.intensity[:, uniq_cent_idx]
+        paa.data = np.interp(paa.data, impf.intensity, impf.paa)
+        return paa[:, indices]
+
+    def get_fraction(self, cent_idx):
+        """
+        Return fraction for chosen centroids (cent_idx).
+
+        Parameters
+        ----------
+        cent_idx : array-like
+            array of indices of chosen centroids from hazard
+
+        Returns
+        -------
+        sparse.csr_matrix
+            sparse matrix (n_events x len(cent_idx)) with fraction values
+
+        """
+        return self.fraction[:, cent_idx]

From 998541429ffdaed89570b86d9a8f563079c8ac33 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Tue, 12 Apr 2022 16:30:25 +0200
Subject: [PATCH 014/121] Change sum to np.sum

---
 climada/engine/impact.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 394f9a51c..012ea2e4f 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -91,7 +91,7 @@ def aai_agg_from_eai_exp(eai_exp):
     float
         average annual impact aggregated
     """
-    return sum(eai_exp)
+    return np.sum(eai_exp)
 
 def calc_impstats_from_mat(self, imp_mat, freq):
     """

From 3f5f4021ba3ba9eb61798f85ccac47246313fce6 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Tue, 12 Apr 2022 16:31:15 +0200
Subject: [PATCH 015/121] Add affect_total_value

---
 climada/engine/impact.py         | 6 +++---
 climada/entity/exposures/base.py | 4 ++++
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 012ea2e4f..a83dfe076 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -258,7 +258,7 @@ def calc_insured_risk(cls, exposures, impact_funcs, hazard, save_mat=False):
                 at_event += at_event_from_mat(imp_mat)
                 eai_exp[exp_idx] += eai_exp_from_mat(imp_mat, hazard.frequency)
             aai_agg = aai_agg_from_eai_exp(eai_exp)
-            tot_value = exposures.affected_values_gdf(hazard).value.sum()
+            tot_value = exposures.affected_total_value(hazard)
             return cls(
                 event_id = hazard.event_id,
                 event_name = hazard.event_name,
@@ -322,7 +322,7 @@ def calc_risk(cls, exposures, impact_funcs, hazard, save_mat=True):
                 at_event += at_event_from_mat(imp_mat)
                 eai_exp[exp_idx] += eai_exp_from_mat(imp_mat, hazard.frequency)
             aai_agg = aai_agg_from_eai_exp(eai_exp)
-            tot_value = exposures.affected_values_gdf(hazard).value.sum()
+            tot_value = exposures.affected_total_value(hazard)
             return cls(
                 event_id = hazard.event_id,
                 event_name = hazard.event_name,
@@ -364,7 +364,7 @@ def set_from_imp_mat(cls, imp_mat, exposures, impf_set, hazard):
         eai_exp = eai_exp_from_mat(imp_mat, hazard.frequency)
         at_event = at_event_from_mat(imp_mat)
         aai_agg = aai_agg_from_eai_exp(eai_exp)
-        tot_value = exposures.affected_values_gdf(hazard).value.sum()
+        tot_value = exposures.affected_total_value(hazard)
         return cls(
             event_id = hazard.event_id,
             event_name = hazard.event_name,
diff --git a/climada/entity/exposures/base.py b/climada/entity/exposures/base.py
index 159f0bf1f..c5fe6f55c 100644
--- a/climada/entity/exposures/base.py
+++ b/climada/entity/exposures/base.py
@@ -1000,6 +1000,10 @@ def concat(exposures_list):
     def affected_values_gdf(self, hazard):
         return self.gdf[(self.gdf.value != 0) & (self.gdf[hazard.cent_exp_col] >= 0)]
 
+    def affected_total_value(self, hazard):
+        exp_idx = np.where((self.gdf.value > 0) & (self.gdf[hazard.cent_exp_col] >= 0))[0]
+        return np.sum(self.gdf.value.values[exp_idx])
+
 
 def add_sea(exposures, sea_res, scheduler=None):
     """Add sea to geometry's surroundings with given resolution. region_id

From a2aa1e70415ad32f57db58cce6ad99372ca37769 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Tue, 12 Apr 2022 16:31:39 +0200
Subject: [PATCH 016/121] Reduce gdf to minimum necessary

---
 climada/engine/impact.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index a83dfe076..e96c821ca 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -294,7 +294,8 @@ def calc_imp_mat_list(exposures, impact_funcs, hazard):
 
         exposures.assign_centroids(hazard, overwrite=False)
 
-        exp_gdf = exposures.affected_values_gdf(hazard)
+        exp_gdf = exposures.gdf[['value', 'impf_TC', 'centr_TC']]
+        exp_gdf = exp_gdf[(exp_gdf.value != 0) & (exp_gdf[hazard.cent_exp_col] >= 0)]
         if exp_gdf.size == 0:
             LOGGER.warning("No exposures with value >0 in the vicinity of the hazard.")
             return sparse.csr_matrix(np.empty((0, 0)))
@@ -306,9 +307,9 @@ def calc_imp_mat_list(exposures, impact_funcs, hazard):
 
     @classmethod
     def calc_risk(cls, exposures, impact_funcs, hazard, save_mat=True):
+        imp_mat_list = cls.calc_imp_mat_list(exposures, impact_funcs, hazard)
         n_exp_pnt = exposures.gdf.shape[0]
         n_events = hazard.size
-        imp_mat_list = cls.calc_imp_mat_list(exposures, impact_funcs, hazard)
         if save_mat:
             data = np.hstack([mat.data for mat, _ in imp_mat_list])
             row = np.hstack([mat.nonzero()[0] for mat, _ in imp_mat_list])

From b172eedf845252c1243d876dabe75216251dd28b Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Tue, 12 Apr 2022 17:01:40 +0200
Subject: [PATCH 017/121] Correct exposure gdf column selection

---
 climada/engine/impact.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index e96c821ca..50a6bb4fe 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -293,8 +293,9 @@ def calc_imp_mat_list(exposures, impact_funcs, hazard):
         """
 
         exposures.assign_centroids(hazard, overwrite=False)
+        impf_col = exposures.get_impf_column(hazard.haz_type)
 
-        exp_gdf = exposures.gdf[['value', 'impf_TC', 'centr_TC']]
+        exp_gdf = exposures.gdf[['value', impf_col, hazard.cent_exp_col]]
         exp_gdf = exp_gdf[(exp_gdf.value != 0) & (exp_gdf[hazard.cent_exp_col] >= 0)]
         if exp_gdf.size == 0:
             LOGGER.warning("No exposures with value >0 in the vicinity of the hazard.")
@@ -302,7 +303,7 @@ def calc_imp_mat_list(exposures, impact_funcs, hazard):
 
         LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
                     exp_gdf.size, hazard.size)
-        impf_col = exposures.get_impf_column(hazard.haz_type)
+
         return calc_imp_mat_per_impf(hazard, exp_gdf, impf_col, impact_funcs)
 
     @classmethod

From 8567c5da20ba173b7b89abba186cc2fb57bf607c Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Wed, 13 Apr 2022 17:04:03 +0200
Subject: [PATCH 018/121] Update docstrings

---
 climada/engine/impact.py | 300 ++++++++++++++++++++++++++++-----------
 1 file changed, 216 insertions(+), 84 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 50a6bb4fe..946fea9d7 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -93,10 +93,10 @@ def aai_agg_from_eai_exp(eai_exp):
     """
     return np.sum(eai_exp)
 
-def calc_impstats_from_mat(self, imp_mat, freq):
+def risk_metrics_from_mat(imp_mat, freq):
     """
-    Compute impact statistics eai_exp, at_event, aai_agg
-    for an impact matrix and frequency vector.
+    Compute risk metricss eai_exp, at_event, aai_agg
+    for an impact matrix and a frequency vector.
 
     Parameters
     ----------
@@ -104,17 +104,41 @@ def calc_impstats_from_mat(self, imp_mat, freq):
         matrix num_events x num_exp with impacts.
     freq : np.array
         array with the frequency per event
+
     Returns
     -------
-    imp : Impact
-        Copy of impact with eai_exp, at_event, aai_agg, imp_mat set.
+    eai_exp: np.array
+        expected annual impact at each exposure point
+    at_event: np.array()
+        total impact for each event
+    aai_agg : float
+        average annual impact aggregated over all exposure points
     """
     eai_exp = eai_exp_from_mat(imp_mat, freq)
     at_event = at_event_from_mat(imp_mat)
     aai_agg = aai_agg_from_eai_exp(eai_exp)
     return eai_exp, at_event, aai_agg
 
-def calc_impact(mdr, fraction, exp_values):
+def impact_matrix(mdr, fraction, exp_values):
+    """
+    Compute the impact matrix from the mean damage ratio (mdr), the fraction
+    and the exposure value
+
+    Parameters
+    ----------
+    mdr : scipy.sparse.csr_matrix
+        Mean damage ratio per event (rows) per exposure point (columns)
+    fraction : scipy.sparse.csr_matrix
+       Hazard fraction per event (rows) per exposure point (columns)
+    exp_values : np.array()
+        Exposure value at each exposure point
+
+    Returns
+    -------
+    scipy.sparse.csr_matrix
+        Impact per event (rows) per exposure point (columns)
+
+    """
     return fraction.multiply(mdr).multiply(sparse.csr_matrix(exp_values))
 
 def calc_imp_mat_per_impf(hazard, exp_gdf, impf_col, impf_set):
@@ -137,17 +161,104 @@ def calc_one_imp_mat(exp, hazard, impf):
     cent_idx = exp[hazard.cent_exp_col].values
     mdr = hazard.get_mdr(cent_idx, impf)
     fract = hazard.get_fraction(cent_idx)
-    imp_mat = calc_impact(mdr=mdr, fraction=fract, exp_values=exp.value.values)
+    imp_mat = impact_matrix(mdr=mdr, fraction=fract, exp_values=exp.value.values)
     return imp_mat, exp.index.to_numpy()
 
+def stich_impact_matrix(imp_mat_list, n_events, n_exp_pnt):
+        data = np.hstack([mat.data for mat, _ in imp_mat_list])
+        row = np.hstack([mat.nonzero()[0] for mat, _ in imp_mat_list])
+        col = np.hstack([idx[mat.nonzero()[1]] for mat, idx in imp_mat_list])
+        return sparse.csr_matrix((data, (row, col)), shape=(n_events, n_exp_pnt))
+
+def stich_risk_metrics_from_mat(self, imp_mat_list, freq, n_events, n_exp_pnt):
+    at_event = np.zeros(n_events)
+    eai_exp = np.zeros(n_exp_pnt)
+    for imp_mat, exp_idx in imp_mat_list:
+        at_event += at_event_from_mat(imp_mat)
+        eai_exp[exp_idx] += eai_exp_from_mat(imp_mat, freq)
+    aai_agg = aai_agg_from_eai_exp(eai_exp)
+    return at_event, eai_exp, aai_agg
+
+def calc_imp_mat_list(exposures, impact_funcs, hazard):
+    """Compute impact of an hazard to exposures.
+
+    Parameters
+    ----------
+    exposures : climada.entity.Exposures
+    impact_funcs : climada.entity.ImpactFuncSet
+        impact functions set
+    hazard : climada.Hazard
+
+    """
+
+    exposures.assign_centroids(hazard, overwrite=False)
+    impf_col = exposures.get_impf_column(hazard.haz_type)
+
+    exp_gdf = exposures.gdf[['value', impf_col, hazard.cent_exp_col]]
+    exp_gdf = exp_gdf[(exp_gdf.value != 0) & (exp_gdf[hazard.cent_exp_col] >= 0)]
+    if exp_gdf.size == 0:
+        LOGGER.warning("No exposures with value >0 in the vicinity of the hazard.")
+        return sparse.csr_matrix(np.empty((0, 0)))
+
+    LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
+                exp_gdf.size, hazard.size)
+
+    return calc_imp_mat_per_impf(hazard, exp_gdf, impf_col, impact_funcs)
+
 
 def apply_deductible_to_imp_mat(imp_mat, deductible, hazard, cent_idx, impf):
+    """
+    Apply a deductible per exposure point to an impact matrix at given
+    centroid points for given impact function.
+
+    All exposure points must have the same impact function. For different
+    impact functions apply use this method repeatedly on the same impact
+    matrix.
+
+    Parameters
+    ----------
+    imp_mat : scipy.sparse.csr_matrix
+        impact matrix (events x exposure points)
+    deductible : np.array()
+        deductible for each exposure point
+    hazard : Hazard
+        hazard used to compute the imp_mat
+    cent_idx : np.array()
+        index of centroids associated with each exposure point
+    impf : ImpactFunc
+        impact function associated with the exposure points
+
+    Returns
+    -------
+    imp_mat : scipy.sparse.csr_matrix
+        impact matrix with applied deductible
+
+    """
     paa = hazard.get_paa(cent_idx, impf)
     imp_mat -= paa.multiply(sparse.csr_matrix(deductible))
     return imp_mat
 
 
 def apply_cover_to_imp_mat(imp_mat, cover):
+    """
+    Apply cover to impact matrix.
+
+    The impact data is clipped to the range [0, cover]. The cover is defined
+    per exposure point.
+
+    Parameters
+    ----------
+    imp_mat : scipy.sparse.csr_matrix
+        impact matrix
+    cover : np.array()
+        cover per exposures point (columns of imp_mat)
+
+    Returns
+    -------
+    imp_mat : scyp.sparse.csr_matrix
+        impact matrix with applied cover
+
+    """
     imp_mat.data = np.clip(imp_mat.data, 0, cover.to_numpy()[imp_mat.nonzero()[1]])
     return imp_mat
 
@@ -218,46 +329,57 @@ def __init__(self,
         self.imp_mat = imp_mat
 
     def calc(self, exposures, impact_funcs, hazard, save_mat=False):
+        """This function is deprecated, use Impact.calc_risk and Impact.calc_insured_risk instead."""
         if ('deductible' in exposures.gdf) and ('cover' in exposures.gdf) \
             and exposures.gdf.cover.max():
-            # raise DeprecationWarning("To compute the risk transfer value"
-            #     "please use Impact.calc_insured_risk")
+            LOGGER.warning("To compute the risk transfer value"
+                 "please use Impact.calc_insured_risk")
             self.__dict__ = self.calc_insured_risk(exposures, impact_funcs, hazard, save_mat).__dict__
         else:
+            LOGGER.warning("The use of Impact.calc() is deprecated."
+                 "Please use Impact.calc_risk() or Impact.calc_risk_insured().")
             self.__dict__ = self.calc_risk(exposures, impact_funcs, hazard, save_mat).__dict__
 
     @classmethod
-    def calc_insured_risk(cls, exposures, impact_funcs, hazard, save_mat=False):
+    def calc_risk(cls, exposures, impact_funcs, hazard, save_mat=True):
+        """Compute impact of an hazard to exposures including risk metrics.
+
+        Parameters
+        ----------
+        exposures : climada.entity.Exposures
+            the exposures
+        impact_funcs : climada.entity.ImpactFuncSet
+            the set of impact functions
+        hazard : climada.Hazard
+            the hazard
+        save_mat : bool
+            if true, save the total impact matrix (events x exposures)
+
+        Examples
+        --------
+            Use Entity class:
+
+            >>> haz = Hazard.from_mat(HAZ_DEMO_MAT)  # Set hazard
+            >>> ent = Entity.from_excel(ENT_TEMPLATE_XLS) # Set exposures
+            >>> imp = Impact.calc_risk(ent.exposures, ent.impact_funcs, haz)
+            >>> imp.calc_freq_curve().plot()
+
+            Specify only exposures and impact functions:
+
+            >>> haz = Hazard.from_mat(HAZ_DEMO_MAT)  # Set hazard
+            >>> funcs = ImpactFuncSet.from_excel(ENT_TEMPLATE_XLS) # Set impact functions
+            >>> exp = Exposures(pd.read_excel(ENT_TEMPLATE_XLS)) # Set exposures
+            >>> imp = Impact.calc_risk(exp, funcs, haz)
+            >>> imp.aai_agg
+        """
+        imp_mat_list = cls.calc_imp_mat_list(exposures, impact_funcs, hazard)
         n_exp_pnt = exposures.gdf.shape[0]
         n_events = hazard.size
-        imp_mat_list = cls.calc_imp_mat_list(exposures, impact_funcs, hazard)
-        at_event = np.zeros(n_events)
-        eai_exp = np.zeros(n_exp_pnt)
-        impf_col = exposures.get_impf_column(hazard.haz_type)
-        imp_mat_list2 = []
-        for mat, exp_idx in imp_mat_list:
-            impf_id = exposures.gdf[impf_col][exp_idx].unique()[0]
-            deductible = exposures.gdf['deductible'][exp_idx]
-            cent_idx = exposures.gdf['centr_TC'][exp_idx]
-            impf = impact_funcs.get_func(haz_type=hazard.haz_type, fun_id=impf_id)
-            mat = apply_deductible_to_imp_mat(mat, deductible, hazard, cent_idx, impf)
-            cover = exposures.gdf['cover'][exp_idx]
-            mat = apply_cover_to_imp_mat(mat, cover)
-            imp_mat_list2.append((mat, exp_idx))
-        imp_mat_list = imp_mat_list2
         if save_mat:
-            data = np.hstack([mat.data for mat, _ in imp_mat_list])
-            row = np.hstack([mat.nonzero()[0] for mat, _ in imp_mat_list])
-            col = np.hstack([idx[mat.nonzero()[1]] for mat, idx in imp_mat_list])
-            imp_mat = sparse.csr_matrix((data, (row, col)), shape=(n_events, n_exp_pnt))
+            imp_mat = stich_impact_matrix(imp_mat_list, n_events, n_exp_pnt)
             return cls.set_from_imp_mat(imp_mat, exposures, impact_funcs, hazard)
         else:
-            at_event = np.zeros(n_events)
-            eai_exp = np.zeros(n_exp_pnt)
-            for imp_mat, exp_idx in imp_mat_list:
-                at_event += at_event_from_mat(imp_mat)
-                eai_exp[exp_idx] += eai_exp_from_mat(imp_mat, hazard.frequency)
-            aai_agg = aai_agg_from_eai_exp(eai_exp)
+            at_event, eai_exp, aai_agg = stich_risk_metrics_from_mat(imp_mat_list, hazard.frequency, n_events, n_exp_pnt)
             tot_value = exposures.affected_total_value(hazard)
             return cls(
                 event_id = hazard.event_id,
@@ -279,38 +401,47 @@ def calc_insured_risk(cls, exposures, impact_funcs, hazard, save_mat=False):
                        }
                 )
 
-    @staticmethod
-    def calc_imp_mat_list(exposures, impact_funcs, hazard):
-        """Compute impact of an hazard to exposures.
+    @classmethod
+    def calc_insured_risk(cls, exposures, impact_funcs, hazard, save_mat=False):
+        """
+        To be document and written more nicely.
 
         Parameters
         ----------
-        exposures : climada.entity.Exposures
-        impact_funcs : climada.entity.ImpactFuncSet
-            impact functions set
-        hazard : climada.Hazard
-
-        """
+        cls : TYPE
+            DESCRIPTION.
+        exposures : TYPE
+            DESCRIPTION.
+        impact_funcs : TYPE
+            DESCRIPTION.
+        hazard : TYPE
+            DESCRIPTION.
+        save_mat : TYPE, optional
+            DESCRIPTION. The default is False.
 
-        exposures.assign_centroids(hazard, overwrite=False)
-        impf_col = exposures.get_impf_column(hazard.haz_type)
-
-        exp_gdf = exposures.gdf[['value', impf_col, hazard.cent_exp_col]]
-        exp_gdf = exp_gdf[(exp_gdf.value != 0) & (exp_gdf[hazard.cent_exp_col] >= 0)]
-        if exp_gdf.size == 0:
-            LOGGER.warning("No exposures with value >0 in the vicinity of the hazard.")
-            return sparse.csr_matrix(np.empty((0, 0)))
-
-        LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
-                    exp_gdf.size, hazard.size)
-
-        return calc_imp_mat_per_impf(hazard, exp_gdf, impf_col, impact_funcs)
+        Returns
+        -------
+        TYPE
+            DESCRIPTION.
 
-    @classmethod
-    def calc_risk(cls, exposures, impact_funcs, hazard, save_mat=True):
-        imp_mat_list = cls.calc_imp_mat_list(exposures, impact_funcs, hazard)
+        """
         n_exp_pnt = exposures.gdf.shape[0]
         n_events = hazard.size
+        imp_mat_list = cls.calc_imp_mat_list(exposures, impact_funcs, hazard)
+        at_event = np.zeros(n_events)
+        eai_exp = np.zeros(n_exp_pnt)
+        impf_col = exposures.get_impf_column(hazard.haz_type)
+        imp_mat_list2 = []
+        for mat, exp_idx in imp_mat_list:
+            impf_id = exposures.gdf[impf_col][exp_idx].unique()[0]
+            deductible = exposures.gdf['deductible'][exp_idx]
+            cent_idx = exposures.gdf['centr_TC'][exp_idx]
+            impf = impact_funcs.get_func(haz_type=hazard.haz_type, fun_id=impf_id)
+            mat = apply_deductible_to_imp_mat(mat, deductible, hazard, cent_idx, impf)
+            cover = exposures.gdf['cover'][exp_idx]
+            mat = apply_cover_to_imp_mat(mat, cover)
+            imp_mat_list2.append((mat, exp_idx))
+        imp_mat_list = imp_mat_list2
         if save_mat:
             data = np.hstack([mat.data for mat, _ in imp_mat_list])
             row = np.hstack([mat.nonzero()[0] for mat, _ in imp_mat_list])
@@ -345,6 +476,7 @@ def calc_risk(cls, exposures, impact_funcs, hazard, save_mat=True):
                        }
                 )
 
+
     @classmethod
     def set_from_imp_mat(cls, imp_mat, exposures, impf_set, hazard):
         """
@@ -355,17 +487,18 @@ def set_from_imp_mat(cls, imp_mat, exposures, impf_set, hazard):
         imp_mat : sparse.csr_matrix
             matrix num_events x num_exp with impacts.
         exposures : climada.entity.Exposures
+            exposure used to compute imp_mat
         impf_set: climada.entity.ImpactFuncSet
-            impact functions set
+            impact functions set used to compute imp_mat
         hazard : climada.Hazard
+            hazard used to compute imp_mat
+
         Returns
         -------
-        imp : Impact
-            Copy of impact with eai_exp, at_event, aai_agg, imp_mat set.
+        Impact
+            impact with all risk metrics set based on the given impact matrix
         """
-        eai_exp = eai_exp_from_mat(imp_mat, hazard.frequency)
-        at_event = at_event_from_mat(imp_mat)
-        aai_agg = aai_agg_from_eai_exp(eai_exp)
+        at_event, eai_exp, aai_agg = risk_metrics_from_mat(imp_mat, hazard.frequency)
         tot_value = exposures.affected_total_value(hazard)
         return cls(
             event_id = hazard.event_id,
@@ -389,19 +522,21 @@ def set_from_imp_mat(cls, imp_mat, exposures, impf_set, hazard):
             )
 
     def calc_transfer_risk(self, attachment, cover):
-        """Compute the risk transfer
+        """Compute the risk transfer for the full portfolio
 
         Parameters
         ----------
-        attachment : _type_
-            _description_
-        cover : _type_
-            _description_
+        attachment : float
+           attachment per event for entire portfolio.
+        cover : float
+            cover per event for entire portfolio.
 
         Returns
         -------
-        _type_
-            _description_
+        transfer_at_event: np.array()
+            risk transfered per event
+        transfer_aai_agg: float
+            average  annual risk transfered
         """
         transfer_at_event = np.minimum(np.maximum(self.at_event - attachment, 0), cover)
         transfer_aai_agg = np.sum(transfer_at_event * self.frequency)
@@ -409,20 +544,21 @@ def calc_transfer_risk(self, attachment, cover):
 
     def calc_residual_risk(self, attachment, cover):
         """Compute the residual risk after application of insurance
-        attachment (deductible of full portfolio) and cover.
+        attachment and cover to entire portfolio.
 
         Parameters
         ----------
         attachment : float
-            The amount that must be paid by the customer per event before
-            the cover takes over
+            attachment per event for entire portfolio.
         cover : float
-            The maximum amount that is covered per event.
+            cover per event for entire portfolio.
+
         Returns
         -------
-        climada.engine.Impact:
-            Impact object that desribes the residual (not cover, not deduced)
-            impact per event. The impact matrix is always defined.
+        residual_at_event: np.array()
+            residual risk per event
+        residual_aai_agg: float
+            average annual residual risk
 
         """
         transfer_at_event, _ = self.calc_transfer_risk(attachment, cover)
@@ -445,10 +581,6 @@ def calc_risk_transfer(self, attachment, cover):
         -------
         climada.engine.Impact
         """
-        LOGGER.warning("The use of Impact.calc_risk_transfer is deprecated."
-                       "Use Impact.calc_residual_risk and "
-                       "Impact.calc_transfer_risk instead."
-                       )
         new_imp = copy.deepcopy(self)
         if attachment or cover:
             imp_layer = np.minimum(np.maximum(new_imp.at_event - attachment, 0), cover)

From 53a2bc1741fe1c9ed4af889e6a95dbb66db68ca6 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Wed, 13 Apr 2022 17:31:22 +0200
Subject: [PATCH 019/121] Fix bug at_event / eai_exp

---
 climada/engine/impact.py | 128 ++++++++++++++++++++-------------------
 1 file changed, 66 insertions(+), 62 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 946fea9d7..bda6ce103 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -117,7 +117,7 @@ def risk_metrics_from_mat(imp_mat, freq):
     eai_exp = eai_exp_from_mat(imp_mat, freq)
     at_event = at_event_from_mat(imp_mat)
     aai_agg = aai_agg_from_eai_exp(eai_exp)
-    return eai_exp, at_event, aai_agg
+    return at_event, eai_exp, aai_agg
 
 def impact_matrix(mdr, fraction, exp_values):
     """
@@ -142,6 +142,9 @@ def impact_matrix(mdr, fraction, exp_values):
     return fraction.multiply(mdr).multiply(sparse.csr_matrix(exp_values))
 
 def calc_imp_mat_per_impf(hazard, exp_gdf, impf_col, impf_set):
+    """
+    List of impact matrices for the exposure and of corresponding exposures indices
+    """
     imp_mat_list = []
     for impf_id, exp_impf_gdf in exp_gdf.groupby(impf_col):
         impf = impf_set.get_func(haz_type=hazard.haz_type, fun_id=impf_id)
@@ -158,6 +161,9 @@ def calc_imp_mat_per_impf(hazard, exp_gdf, impf_col, impf_set):
     return imp_mat_list
 
 def calc_one_imp_mat(exp, hazard, impf):
+    """
+    Impact matrix for exposure, hazard, impact function
+    """
     cent_idx = exp[hazard.cent_exp_col].values
     mdr = hazard.get_mdr(cent_idx, impf)
     fract = hazard.get_fraction(cent_idx)
@@ -165,12 +171,18 @@ def calc_one_imp_mat(exp, hazard, impf):
     return imp_mat, exp.index.to_numpy()
 
 def stich_impact_matrix(imp_mat_list, n_events, n_exp_pnt):
-        data = np.hstack([mat.data for mat, _ in imp_mat_list])
-        row = np.hstack([mat.nonzero()[0] for mat, _ in imp_mat_list])
-        col = np.hstack([idx[mat.nonzero()[1]] for mat, idx in imp_mat_list])
-        return sparse.csr_matrix((data, (row, col)), shape=(n_events, n_exp_pnt))
+    """
+    Make an impact matrix from an impact matrix list
+    """
+    data = np.hstack([mat.data for mat, _ in imp_mat_list])
+    row = np.hstack([mat.nonzero()[0] for mat, _ in imp_mat_list])
+    col = np.hstack([idx[mat.nonzero()[1]] for mat, idx in imp_mat_list])
+    return sparse.csr_matrix((data, (row, col)), shape=(n_events, n_exp_pnt))
 
-def stich_risk_metrics_from_mat(self, imp_mat_list, freq, n_events, n_exp_pnt):
+def stich_risk_metrics_from_mat(imp_mat_list, freq, n_events, n_exp_pnt):
+    """
+    Compute the impact metrics from an impact matrix list
+    """
     at_event = np.zeros(n_events)
     eai_exp = np.zeros(n_exp_pnt)
     for imp_mat, exp_idx in imp_mat_list:
@@ -372,7 +384,7 @@ def calc_risk(cls, exposures, impact_funcs, hazard, save_mat=True):
             >>> imp = Impact.calc_risk(exp, funcs, haz)
             >>> imp.aai_agg
         """
-        imp_mat_list = cls.calc_imp_mat_list(exposures, impact_funcs, hazard)
+        imp_mat_list = calc_imp_mat_list(exposures, impact_funcs, hazard)
         n_exp_pnt = exposures.gdf.shape[0]
         n_events = hazard.size
         if save_mat:
@@ -380,26 +392,7 @@ def calc_risk(cls, exposures, impact_funcs, hazard, save_mat=True):
             return cls.set_from_imp_mat(imp_mat, exposures, impact_funcs, hazard)
         else:
             at_event, eai_exp, aai_agg = stich_risk_metrics_from_mat(imp_mat_list, hazard.frequency, n_events, n_exp_pnt)
-            tot_value = exposures.affected_total_value(hazard)
-            return cls(
-                event_id = hazard.event_id,
-                event_name = hazard.event_name,
-                date = hazard.date,
-                frequency = hazard.frequency,
-                coord_exp = np.stack([exposures.gdf.latitude.values,
-                                      exposures.gdf.longitude.values],
-                                     axis=1),
-                crs = exposures.crs,
-                unit = exposures.value_unit,
-                tot_value = tot_value,
-                eai_exp = eai_exp,
-                at_event = at_event,
-                aai_agg = aai_agg,
-                tag = {'exp': exposures.tag,
-                       'impf_set': impact_funcs.tag,
-                       'haz': hazard.tag
-                       }
-                )
+            return cls.set_from_imp_metrics(at_event, eai_exp, aai_agg, exposures, impact_funcs, hazard)
 
     @classmethod
     def calc_insured_risk(cls, exposures, impact_funcs, hazard, save_mat=False):
@@ -427,9 +420,7 @@ def calc_insured_risk(cls, exposures, impact_funcs, hazard, save_mat=False):
         """
         n_exp_pnt = exposures.gdf.shape[0]
         n_events = hazard.size
-        imp_mat_list = cls.calc_imp_mat_list(exposures, impact_funcs, hazard)
-        at_event = np.zeros(n_events)
-        eai_exp = np.zeros(n_exp_pnt)
+        imp_mat_list = calc_imp_mat_list(exposures, impact_funcs, hazard)
         impf_col = exposures.get_impf_column(hazard.haz_type)
         imp_mat_list2 = []
         for mat, exp_idx in imp_mat_list:
@@ -443,38 +434,52 @@ def calc_insured_risk(cls, exposures, impact_funcs, hazard, save_mat=False):
             imp_mat_list2.append((mat, exp_idx))
         imp_mat_list = imp_mat_list2
         if save_mat:
-            data = np.hstack([mat.data for mat, _ in imp_mat_list])
-            row = np.hstack([mat.nonzero()[0] for mat, _ in imp_mat_list])
-            col = np.hstack([idx[mat.nonzero()[1]] for mat, idx in imp_mat_list])
-            imp_mat = sparse.csr_matrix((data, (row, col)), shape=(n_events, n_exp_pnt))
+            imp_mat = stich_impact_matrix(imp_mat_list, n_events, n_exp_pnt)
             return cls.set_from_imp_mat(imp_mat, exposures, impact_funcs, hazard)
         else:
-            at_event = np.zeros(n_events)
-            eai_exp = np.zeros(n_exp_pnt)
-            for imp_mat, exp_idx in imp_mat_list:
-                at_event += at_event_from_mat(imp_mat)
-                eai_exp[exp_idx] += eai_exp_from_mat(imp_mat, hazard.frequency)
-            aai_agg = aai_agg_from_eai_exp(eai_exp)
-            tot_value = exposures.affected_total_value(hazard)
-            return cls(
-                event_id = hazard.event_id,
-                event_name = hazard.event_name,
-                date = hazard.date,
-                frequency = hazard.frequency,
-                coord_exp = np.stack([exposures.gdf.latitude.values,
-                                      exposures.gdf.longitude.values],
-                                     axis=1),
-                crs = exposures.crs,
-                unit = exposures.value_unit,
-                tot_value = tot_value,
-                eai_exp = eai_exp,
-                at_event = at_event,
-                aai_agg = aai_agg,
-                tag = {'exp': exposures.tag,
-                       'impf_set': impact_funcs.tag,
-                       'haz': hazard.tag
-                       }
-                )
+            at_event, eai_exp, aai_agg = stich_risk_metrics_from_mat(imp_mat_list, hazard.frequency, n_events, n_exp_pnt)
+            return cls.set_from_imp_metrics(at_event, eai_exp, aai_agg, exposures, impact_funcs, hazard)
+
+    @classmethod
+    def set_from_imp_metrics(cls, at_event, eai_exp, aai_agg, exposures, impf_set, hazard):
+        """
+        Set Impact attributes from the impact matrix.
+
+        Parameters
+        ----------
+        imp_mat : sparse.csr_matrix
+            matrix num_events x num_exp with impacts.
+        exposures : climada.entity.Exposures
+            exposure used to compute imp_mat
+        impf_set: climada.entity.ImpactFuncSet
+            impact functions set used to compute imp_mat
+        hazard : climada.Hazard
+            hazard used to compute imp_mat
+
+        Returns
+        -------
+        Impact
+            impact with all risk metrics set based on the given impact matrix
+        """
+        return cls(
+            event_id = hazard.event_id,
+            event_name = hazard.event_name,
+            date = hazard.date,
+            frequency = hazard.frequency,
+            coord_exp = np.stack([exposures.gdf.latitude.values,
+                                  exposures.gdf.longitude.values],
+                                 axis=1),
+            crs = exposures.crs,
+            unit = exposures.value_unit,
+            tot_value = exposures.affected_total_value(hazard),
+            eai_exp = eai_exp,
+            at_event = at_event,
+            aai_agg = aai_agg,
+            tag = {'exp': exposures.tag,
+                   'impf_set': impf_set.tag,
+                   'haz': hazard.tag
+                   }
+            )
 
 
     @classmethod
@@ -499,7 +504,6 @@ def set_from_imp_mat(cls, imp_mat, exposures, impf_set, hazard):
             impact with all risk metrics set based on the given impact matrix
         """
         at_event, eai_exp, aai_agg = risk_metrics_from_mat(imp_mat, hazard.frequency)
-        tot_value = exposures.affected_total_value(hazard)
         return cls(
             event_id = hazard.event_id,
             event_name = hazard.event_name,
@@ -510,7 +514,7 @@ def set_from_imp_mat(cls, imp_mat, exposures, impf_set, hazard):
                                  axis=1),
             crs = exposures.crs,
             unit = exposures.value_unit,
-            tot_value = tot_value,
+            tot_value = exposures.affected_total_value(hazard),
             eai_exp = eai_exp,
             at_event = at_event,
             aai_agg = aai_agg,

From 69ac24771be5b9ef48366229c5c21dd108e71ab3 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Wed, 13 Apr 2022 22:26:03 +0200
Subject: [PATCH 020/121] Refactoring of methods to simplify code

---
 climada/engine/impact.py | 87 ++++++++++++++++++----------------------
 1 file changed, 40 insertions(+), 47 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index bda6ce103..a10a68921 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -119,29 +119,7 @@ def risk_metrics_from_mat(imp_mat, freq):
     aai_agg = aai_agg_from_eai_exp(eai_exp)
     return at_event, eai_exp, aai_agg
 
-def impact_matrix(mdr, fraction, exp_values):
-    """
-    Compute the impact matrix from the mean damage ratio (mdr), the fraction
-    and the exposure value
-
-    Parameters
-    ----------
-    mdr : scipy.sparse.csr_matrix
-        Mean damage ratio per event (rows) per exposure point (columns)
-    fraction : scipy.sparse.csr_matrix
-       Hazard fraction per event (rows) per exposure point (columns)
-    exp_values : np.array()
-        Exposure value at each exposure point
-
-    Returns
-    -------
-    scipy.sparse.csr_matrix
-        Impact per event (rows) per exposure point (columns)
-
-    """
-    return fraction.multiply(mdr).multiply(sparse.csr_matrix(exp_values))
-
-def calc_imp_mat_per_impf(hazard, exp_gdf, impf_col, impf_set):
+def calc_imp_mat_list(hazard, exp_gdf, impf_col, impf_set):
     """
     List of impact matrices for the exposure and of corresponding exposures indices
     """
@@ -155,20 +133,34 @@ def calc_imp_mat_per_impf(hazard, exp_gdf, impf_col, impf_set):
         chk = -1
         for chk in range(int(len(exp_impf_gdf) / exp_step)):
             exp = exp_impf_gdf[chk * exp_step:(chk + 1) * exp_step]
-            imp_mat_list.append(calc_one_imp_mat(exp, hazard, impf))
+            imp_mat_list.append((impact_matrix(exp, hazard, impf), exp.index.to_numpy()))
         exp = exp_impf_gdf[(chk + 1) * exp_step:]
-        imp_mat_list.append(calc_one_imp_mat(exp, hazard, impf))
+        imp_mat_list.append((impact_matrix(exp, hazard, impf), exp.index.to_numpy()))
     return imp_mat_list
 
-def calc_one_imp_mat(exp, hazard, impf):
+def impact_matrix(exp_gdf, hazard, impf):
     """
-    Impact matrix for exposure, hazard, impact function
+    Compute the impact matrix for an exposures geodataframe, a hazard,
+    and one impact function.
+
+    Parameters
+    ----------
+    exp_gdf : GeoDataFrame
+        Exposures geodataframe with columns 'value' and 'centr_haz_type'
+    hazard : Hazard
+       Hazard object
+    impf : ImpactFunction
+        one impactfunction comon to all exposure elements in exp_gdf
+
+    Returns
+    -------
+    scipy.sparse.csr_matrix
+        Impact per event (rows) per exposure point (columns)
     """
-    cent_idx = exp[hazard.cent_exp_col].values
+    cent_idx = exp_gdf[hazard.cent_exp_col].values
     mdr = hazard.get_mdr(cent_idx, impf)
     fract = hazard.get_fraction(cent_idx)
-    imp_mat = impact_matrix(mdr=mdr, fraction=fract, exp_values=exp.value.values)
-    return imp_mat, exp.index.to_numpy()
+    return fract.multiply(mdr).multiply(sparse.csr_matrix(exp_gdf.value))
 
 def stich_impact_matrix(imp_mat_list, n_events, n_exp_pnt):
     """
@@ -179,7 +171,7 @@ def stich_impact_matrix(imp_mat_list, n_events, n_exp_pnt):
     col = np.hstack([idx[mat.nonzero()[1]] for mat, idx in imp_mat_list])
     return sparse.csr_matrix((data, (row, col)), shape=(n_events, n_exp_pnt))
 
-def stich_risk_metrics_from_mat(imp_mat_list, freq, n_events, n_exp_pnt):
+def stich_risk_metrics(imp_mat_list, freq, n_events, n_exp_pnt):
     """
     Compute the impact metrics from an impact matrix list
     """
@@ -191,31 +183,25 @@ def stich_risk_metrics_from_mat(imp_mat_list, freq, n_events, n_exp_pnt):
     aai_agg = aai_agg_from_eai_exp(eai_exp)
     return at_event, eai_exp, aai_agg
 
-def calc_imp_mat_list(exposures, impact_funcs, hazard):
-    """Compute impact of an hazard to exposures.
+def get_minimal_exp(exposures, hazard, impf_col):
+    """Get minimal exposures geodataframe for impact computation
 
     Parameters
     ----------
     exposures : climada.entity.Exposures
-    impact_funcs : climada.entity.ImpactFuncSet
-        impact functions set
     hazard : climada.Hazard
+    impf_col: stirng
+        name of the impact function column in exposures.gdf
 
     """
-
     exposures.assign_centroids(hazard, overwrite=False)
-    impf_col = exposures.get_impf_column(hazard.haz_type)
 
     exp_gdf = exposures.gdf[['value', impf_col, hazard.cent_exp_col]]
     exp_gdf = exp_gdf[(exp_gdf.value != 0) & (exp_gdf[hazard.cent_exp_col] >= 0)]
     if exp_gdf.size == 0:
         LOGGER.warning("No exposures with value >0 in the vicinity of the hazard.")
         return sparse.csr_matrix(np.empty((0, 0)))
-
-    LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
-                exp_gdf.size, hazard.size)
-
-    return calc_imp_mat_per_impf(hazard, exp_gdf, impf_col, impact_funcs)
+    return exp_gdf
 
 
 def apply_deductible_to_imp_mat(imp_mat, deductible, hazard, cent_idx, impf):
@@ -384,14 +370,18 @@ def calc_risk(cls, exposures, impact_funcs, hazard, save_mat=True):
             >>> imp = Impact.calc_risk(exp, funcs, haz)
             >>> imp.aai_agg
         """
-        imp_mat_list = calc_imp_mat_list(exposures, impact_funcs, hazard)
+        impf_col = exposures.get_impf_column(hazard.haz_type)
+        exp_gdf = get_minimal_exp(exposures, hazard, impf_col)
+        LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
+                    exp_gdf.size, hazard.size)
+        imp_mat_list = calc_imp_mat_list(hazard, exp_gdf, impf_col, impact_funcs)
         n_exp_pnt = exposures.gdf.shape[0]
         n_events = hazard.size
         if save_mat:
             imp_mat = stich_impact_matrix(imp_mat_list, n_events, n_exp_pnt)
             return cls.set_from_imp_mat(imp_mat, exposures, impact_funcs, hazard)
         else:
-            at_event, eai_exp, aai_agg = stich_risk_metrics_from_mat(imp_mat_list, hazard.frequency, n_events, n_exp_pnt)
+            at_event, eai_exp, aai_agg = stich_risk_metrics(imp_mat_list, hazard.frequency, n_events, n_exp_pnt)
             return cls.set_from_imp_metrics(at_event, eai_exp, aai_agg, exposures, impact_funcs, hazard)
 
     @classmethod
@@ -418,10 +408,13 @@ def calc_insured_risk(cls, exposures, impact_funcs, hazard, save_mat=False):
             DESCRIPTION.
 
         """
+        impf_col = exposures.get_impf_column(hazard.haz_type)
+        exp_gdf = get_minimal_exp(exposures, hazard, impf_col)
+        LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
+                    exp_gdf.size, hazard.size)
+        imp_mat_list = calc_imp_mat_list(hazard, exp_gdf, impf_col, impact_funcs)
         n_exp_pnt = exposures.gdf.shape[0]
         n_events = hazard.size
-        imp_mat_list = calc_imp_mat_list(exposures, impact_funcs, hazard)
-        impf_col = exposures.get_impf_column(hazard.haz_type)
         imp_mat_list2 = []
         for mat, exp_idx in imp_mat_list:
             impf_id = exposures.gdf[impf_col][exp_idx].unique()[0]
@@ -437,7 +430,7 @@ def calc_insured_risk(cls, exposures, impact_funcs, hazard, save_mat=False):
             imp_mat = stich_impact_matrix(imp_mat_list, n_events, n_exp_pnt)
             return cls.set_from_imp_mat(imp_mat, exposures, impact_funcs, hazard)
         else:
-            at_event, eai_exp, aai_agg = stich_risk_metrics_from_mat(imp_mat_list, hazard.frequency, n_events, n_exp_pnt)
+            at_event, eai_exp, aai_agg = stich_risk_metrics(imp_mat_list, hazard.frequency, n_events, n_exp_pnt)
             return cls.set_from_imp_metrics(at_event, eai_exp, aai_agg, exposures, impact_funcs, hazard)
 
     @classmethod

From 1a028ff728fb55d080e4bc94aadeaf2b775d7f8e Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 14 Apr 2022 08:30:34 +0200
Subject: [PATCH 021/121] Use generator instead of list

---
 climada/engine/impact.py | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index a10a68921..8a4976266 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -123,7 +123,7 @@ def calc_imp_mat_list(hazard, exp_gdf, impf_col, impf_set):
     """
     List of impact matrices for the exposure and of corresponding exposures indices
     """
-    imp_mat_list = []
+    # imp_mat_list = []
     for impf_id, exp_impf_gdf in exp_gdf.groupby(impf_col):
         impf = impf_set.get_func(haz_type=hazard.haz_type, fun_id=impf_id)
         exp_step = CONFIG.max_matrix_size.int() // hazard.size
@@ -133,10 +133,12 @@ def calc_imp_mat_list(hazard, exp_gdf, impf_col, impf_set):
         chk = -1
         for chk in range(int(len(exp_impf_gdf) / exp_step)):
             exp = exp_impf_gdf[chk * exp_step:(chk + 1) * exp_step]
-            imp_mat_list.append((impact_matrix(exp, hazard, impf), exp.index.to_numpy()))
+        #     imp_mat_list.append((impact_matrix(exp, hazard, impf), exp.index.to_numpy()))
+            yield (impact_matrix(exp, hazard, impf), exp.index.to_numpy())
+    #     imp_mat_list.append((impact_matrix(exp, hazard, impf), exp.index.to_numpy()))
+    # return imp_mat_list
         exp = exp_impf_gdf[(chk + 1) * exp_step:]
-        imp_mat_list.append((impact_matrix(exp, hazard, impf), exp.index.to_numpy()))
-    return imp_mat_list
+        yield (impact_matrix(exp, hazard, impf), exp.index.to_numpy())
 
 def impact_matrix(exp_gdf, hazard, impf):
     """
@@ -166,6 +168,7 @@ def stich_impact_matrix(imp_mat_list, n_events, n_exp_pnt):
     """
     Make an impact matrix from an impact matrix list
     """
+    imp_mat_list = list(imp_mat_list)
     data = np.hstack([mat.data for mat, _ in imp_mat_list])
     row = np.hstack([mat.nonzero()[0] for mat, _ in imp_mat_list])
     col = np.hstack([idx[mat.nonzero()[1]] for mat, idx in imp_mat_list])

From 7fc364ddfcbe0d022a20c1006e148804027f34b1 Mon Sep 17 00:00:00 2001
From: Thomas Vogt <thomas.vogt@pik-potsdam.de>
Date: Thu, 21 Apr 2022 13:35:36 +0200
Subject: [PATCH 022/121] Impact: improve performance by avoiding pandas
 operations

---
 climada/engine/impact.py         | 71 ++++++++++++++++++--------------
 climada/entity/exposures/base.py |  7 +++-
 2 files changed, 45 insertions(+), 33 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 8a4976266..62aabdb3d 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -61,7 +61,11 @@ def eai_exp_from_mat(imp_mat, freq):
         eai_exp : np.array
             expected annual impact for each exposure
         """
-        return imp_mat.multiply(sparse.csr_matrix(freq.reshape(-1, 1))).sum(axis=0).A1
+        n_events = freq.size
+        freq_csr = sparse.csr_matrix(
+            (freq, np.zeros(n_events), np.arange(n_events + 1)),
+            shape=(n_events, 1))
+        return imp_mat.multiply(freq_csr).sum(axis=0).A1
 
 def at_event_from_mat(imp_mat):
     """
@@ -123,32 +127,29 @@ def calc_imp_mat_list(hazard, exp_gdf, impf_col, impf_set):
     """
     List of impact matrices for the exposure and of corresponding exposures indices
     """
-    # imp_mat_list = []
-    for impf_id, exp_impf_gdf in exp_gdf.groupby(impf_col):
-        impf = impf_set.get_func(haz_type=hazard.haz_type, fun_id=impf_id)
+    for impf in impf_set.get_func(haz_type=hazard.haz_type):
+        exp_iimp = (exp_gdf[impf_col].values == impf.id).nonzero()[0]
         exp_step = CONFIG.max_matrix_size.int() // hazard.size
         if not exp_step:
-            raise ValueError('Increase max_matrix_size configuration parameter to > %s'
-                         % str(hazard.size))
-        chk = -1
-        for chk in range(int(len(exp_impf_gdf) / exp_step)):
-            exp = exp_impf_gdf[chk * exp_step:(chk + 1) * exp_step]
-        #     imp_mat_list.append((impact_matrix(exp, hazard, impf), exp.index.to_numpy()))
-            yield (impact_matrix(exp, hazard, impf), exp.index.to_numpy())
-    #     imp_mat_list.append((impact_matrix(exp, hazard, impf), exp.index.to_numpy()))
-    # return imp_mat_list
-        exp = exp_impf_gdf[(chk + 1) * exp_step:]
-        yield (impact_matrix(exp, hazard, impf), exp.index.to_numpy())
-
-def impact_matrix(exp_gdf, hazard, impf):
+            raise ValueError(
+                f'Increase max_matrix_size configuration parameter to > {hazard.size}')
+        for chk in range(int(exp_iimp.size / exp_step) + 1):
+            exp_idx = exp_iimp[chk * exp_step:(chk + 1) * exp_step]
+            exp_values = exp_gdf.value.values[exp_idx]
+            cent_idx = exp_gdf[hazard.cent_exp_col].values[exp_idx]
+            yield (impact_matrix(exp_values, cent_idx, hazard, impf), exp_iimp)
+
+def impact_matrix(exp_values, cent_idx, hazard, impf):
     """
-    Compute the impact matrix for an exposures geodataframe, a hazard,
+    Compute the impact matrix for given exposure values, assigned centroids, a hazard,
     and one impact function.
 
     Parameters
     ----------
-    exp_gdf : GeoDataFrame
-        Exposures geodataframe with columns 'value' and 'centr_haz_type'
+    exp_values : np.array
+        Exposure values
+    cent_idx : np.array
+        Hazard centroids assigned to each exposure location
     hazard : Hazard
        Hazard object
     impf : ImpactFunction
@@ -159,10 +160,13 @@ def impact_matrix(exp_gdf, hazard, impf):
     scipy.sparse.csr_matrix
         Impact per event (rows) per exposure point (columns)
     """
-    cent_idx = exp_gdf[hazard.cent_exp_col].values
+    n_centroids = cent_idx.size
     mdr = hazard.get_mdr(cent_idx, impf)
     fract = hazard.get_fraction(cent_idx)
-    return fract.multiply(mdr).multiply(sparse.csr_matrix(exp_gdf.value))
+    exp_values_csr = sparse.csr_matrix(
+        (exp_values, np.arange(n_centroids), [0, n_centroids]),
+        shape=(1, n_centroids))
+    return fract.multiply(mdr).multiply(exp_values_csr)
 
 def stich_impact_matrix(imp_mat_list, n_events, n_exp_pnt):
     """
@@ -199,11 +203,16 @@ def get_minimal_exp(exposures, hazard, impf_col):
     """
     exposures.assign_centroids(hazard, overwrite=False)
 
-    exp_gdf = exposures.gdf[['value', impf_col, hazard.cent_exp_col]]
-    exp_gdf = exp_gdf[(exp_gdf.value != 0) & (exp_gdf[hazard.cent_exp_col] >= 0)]
+    mask = (
+        (exposures.gdf.value.values != 0)
+        & (exposures.gdf[hazard.cent_exp_col].values >= 0)
+    )
+    exp_gdf = pd.DataFrame({
+        col: exposures.gdf[col].values[mask]
+        for col in ['value', impf_col, hazard.cent_exp_col]
+    })
     if exp_gdf.size == 0:
         LOGGER.warning("No exposures with value >0 in the vicinity of the hazard.")
-        return sparse.csr_matrix(np.empty((0, 0)))
     return exp_gdf
 
 
@@ -382,10 +391,10 @@ def calc_risk(cls, exposures, impact_funcs, hazard, save_mat=True):
         n_events = hazard.size
         if save_mat:
             imp_mat = stich_impact_matrix(imp_mat_list, n_events, n_exp_pnt)
-            return cls.set_from_imp_mat(imp_mat, exposures, impact_funcs, hazard)
+            return cls.from_imp_mat(imp_mat, exposures, impact_funcs, hazard)
         else:
             at_event, eai_exp, aai_agg = stich_risk_metrics(imp_mat_list, hazard.frequency, n_events, n_exp_pnt)
-            return cls.set_from_imp_metrics(at_event, eai_exp, aai_agg, exposures, impact_funcs, hazard)
+            return cls.from_imp_metrics(at_event, eai_exp, aai_agg, exposures, impact_funcs, hazard)
 
     @classmethod
     def calc_insured_risk(cls, exposures, impact_funcs, hazard, save_mat=False):
@@ -431,13 +440,13 @@ def calc_insured_risk(cls, exposures, impact_funcs, hazard, save_mat=False):
         imp_mat_list = imp_mat_list2
         if save_mat:
             imp_mat = stich_impact_matrix(imp_mat_list, n_events, n_exp_pnt)
-            return cls.set_from_imp_mat(imp_mat, exposures, impact_funcs, hazard)
+            return cls.from_imp_mat(imp_mat, exposures, impact_funcs, hazard)
         else:
             at_event, eai_exp, aai_agg = stich_risk_metrics(imp_mat_list, hazard.frequency, n_events, n_exp_pnt)
-            return cls.set_from_imp_metrics(at_event, eai_exp, aai_agg, exposures, impact_funcs, hazard)
+            return cls.from_imp_metrics(at_event, eai_exp, aai_agg, exposures, impact_funcs, hazard)
 
     @classmethod
-    def set_from_imp_metrics(cls, at_event, eai_exp, aai_agg, exposures, impf_set, hazard):
+    def from_imp_metrics(cls, at_event, eai_exp, aai_agg, exposures, impf_set, hazard):
         """
         Set Impact attributes from the impact matrix.
 
@@ -479,7 +488,7 @@ def set_from_imp_metrics(cls, at_event, eai_exp, aai_agg, exposures, impf_set, h
 
 
     @classmethod
-    def set_from_imp_mat(cls, imp_mat, exposures, impf_set, hazard):
+    def from_imp_mat(cls, imp_mat, exposures, impf_set, hazard):
         """
         Set Impact attributes from the impact matrix.
 
diff --git a/climada/entity/exposures/base.py b/climada/entity/exposures/base.py
index c5fe6f55c..28933ffb0 100644
--- a/climada/entity/exposures/base.py
+++ b/climada/entity/exposures/base.py
@@ -1001,8 +1001,11 @@ def affected_values_gdf(self, hazard):
         return self.gdf[(self.gdf.value != 0) & (self.gdf[hazard.cent_exp_col] >= 0)]
 
     def affected_total_value(self, hazard):
-        exp_idx = np.where((self.gdf.value > 0) & (self.gdf[hazard.cent_exp_col] >= 0))[0]
-        return np.sum(self.gdf.value.values[exp_idx])
+        nz_mask = (
+            (self.gdf.value.values > 0)
+            & (self.gdf[hazard.cent_exp_col].values >= 0)
+        )
+        return np.sum(self.gdf.value.values[nz_mask])
 
 
 def add_sea(exposures, sea_res, scheduler=None):

From d694e5e7fa454d25fefe230a46888ede20f637b2 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 21 Apr 2022 14:10:07 +0200
Subject: [PATCH 023/121] Add notimplementederror for mdf(0)

---
 climada/hazard/base.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/climada/hazard/base.py b/climada/hazard/base.py
index 5441b2e6c..865f8c1cd 100644
--- a/climada/hazard/base.py
+++ b/climada/hazard/base.py
@@ -1792,7 +1792,7 @@ def get_mdr(self, cent_idx, impf):
             sparse matrix (n_events x len(cent_idx)) with mdr values
 
         """
-        uniq_cent_idx, indices = np.unique(cent_idx, return_inverse=True)
+        uniq_cent_idx, indices = np.unique(cent_idx, return_inverse=True)      #costs about 30ms for small datasets
         mdr = self.intensity[:, uniq_cent_idx]
         if impf.calc_mdr(0) == 0:
             mdr.data = impf.calc_mdr(mdr.data)
@@ -1801,10 +1801,11 @@ def get_mdr(self, cent_idx, impf):
             "The mean damage ratio must thus be computed for all values of"
             "hazard intensity including 0 which can be very time consuming.",
             impf.id)
+            raise NotImplementedError("Not yet implemented.")
         return mdr[:, indices]
 
     def get_paa(self, cent_idx, impf):
-        uniq_cent_idx, indices = np.unique(cent_idx, return_inverse=True)
+        uniq_cent_idx, indices = np.unique(cent_idx, return_inverse=True)      #costs about 30ms for small datasets
         paa = self.intensity[:, uniq_cent_idx]
         paa.data = np.interp(paa.data, impf.intensity, impf.paa)
         return paa[:, indices]

From 05ccc9a19fd45852ec45f7cc85971bd440f1d386 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 21 Apr 2022 15:19:51 +0200
Subject: [PATCH 024/121] Toggle logger warning for speed test

---
 climada/engine/impact.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 62aabdb3d..4035e37b4 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -342,12 +342,12 @@ def calc(self, exposures, impact_funcs, hazard, save_mat=False):
         """This function is deprecated, use Impact.calc_risk and Impact.calc_insured_risk instead."""
         if ('deductible' in exposures.gdf) and ('cover' in exposures.gdf) \
             and exposures.gdf.cover.max():
-            LOGGER.warning("To compute the risk transfer value"
-                 "please use Impact.calc_insured_risk")
+            # LOGGER.warning("To compute the risk transfer value"
+            #      "please use Impact.calc_insured_risk")
             self.__dict__ = self.calc_insured_risk(exposures, impact_funcs, hazard, save_mat).__dict__
         else:
-            LOGGER.warning("The use of Impact.calc() is deprecated."
-                 "Please use Impact.calc_risk() or Impact.calc_risk_insured().")
+            # LOGGER.warning("The use of Impact.calc() is deprecated."
+            #      "Please use Impact.calc_risk() or Impact.calc_risk_insured().")
             self.__dict__ = self.calc_risk(exposures, impact_funcs, hazard, save_mat).__dict__
 
     @classmethod

From 5a777aff12c69c2ab4f41f2deec699a192d915ea Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 21 Apr 2022 16:28:00 +0200
Subject: [PATCH 025/121] Fetch only assigned impf

---
 climada/engine/impact.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 4035e37b4..35d3cebdb 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -127,7 +127,8 @@ def calc_imp_mat_list(hazard, exp_gdf, impf_col, impf_set):
     """
     List of impact matrices for the exposure and of corresponding exposures indices
     """
-    for impf in impf_set.get_func(haz_type=hazard.haz_type):
+    for impf_id in exp_gdf[impf_col].unique():
+        impf = impf_set.get_func(haz_type=hazard.haz_type, fun_id=impf_id)
         exp_iimp = (exp_gdf[impf_col].values == impf.id).nonzero()[0]
         exp_step = CONFIG.max_matrix_size.int() // hazard.size
         if not exp_step:

From 337e24ee3e1eb54fb76f0b472e1bbf209795545e Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 21 Apr 2022 16:28:23 +0200
Subject: [PATCH 026/121] Return the reduced exp indices only

---
 climada/engine/impact.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 35d3cebdb..790d5f491 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -138,7 +138,7 @@ def calc_imp_mat_list(hazard, exp_gdf, impf_col, impf_set):
             exp_idx = exp_iimp[chk * exp_step:(chk + 1) * exp_step]
             exp_values = exp_gdf.value.values[exp_idx]
             cent_idx = exp_gdf[hazard.cent_exp_col].values[exp_idx]
-            yield (impact_matrix(exp_values, cent_idx, hazard, impf), exp_iimp)
+            yield (impact_matrix(exp_values, cent_idx, hazard, impf), exp_idx)
 
 def impact_matrix(exp_values, cent_idx, hazard, impf):
     """

From bb8b45756598cd9bbc0c25bcf8a81fab3687e9cc Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 21 Apr 2022 16:28:38 +0200
Subject: [PATCH 027/121] Remove 0 from insured impacts

---
 climada/engine/impact.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 790d5f491..b8bcbafcb 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -247,6 +247,7 @@ def apply_deductible_to_imp_mat(imp_mat, deductible, hazard, cent_idx, impf):
     """
     paa = hazard.get_paa(cent_idx, impf)
     imp_mat -= paa.multiply(sparse.csr_matrix(deductible))
+    imp_mat.eliminate_zeros()
     return imp_mat
 
 
@@ -271,6 +272,7 @@ def apply_cover_to_imp_mat(imp_mat, cover):
 
     """
     imp_mat.data = np.clip(imp_mat.data, 0, cover.to_numpy()[imp_mat.nonzero()[1]])
+    imp_mat.eliminate_zeros()
     return imp_mat
 
 

From 54df06e644d48c39be49e892ab059de3ab87ed14 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 21 Apr 2022 17:17:49 +0200
Subject: [PATCH 028/121] Stich imp mat from generator

---
 climada/engine/impact.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index b8bcbafcb..d50444cb9 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -173,10 +173,10 @@ def stich_impact_matrix(imp_mat_list, n_events, n_exp_pnt):
     """
     Make an impact matrix from an impact matrix list
     """
-    imp_mat_list = list(imp_mat_list)
-    data = np.hstack([mat.data for mat, _ in imp_mat_list])
-    row = np.hstack([mat.nonzero()[0] for mat, _ in imp_mat_list])
-    col = np.hstack([idx[mat.nonzero()[1]] for mat, idx in imp_mat_list])
+    data, row, col = np.hstack([
+        (mat.data, mat.nonzero()[0], idx[mat.nonzero()[1]])
+        for mat, idx in imp_mat_list
+        ])
     return sparse.csr_matrix((data, (row, col)), shape=(n_events, n_exp_pnt))
 
 def stich_risk_metrics(imp_mat_list, freq, n_events, n_exp_pnt):

From 738108b41fa7f30a6e53f524e7c8b903224a1088 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 21 Apr 2022 17:17:58 +0200
Subject: [PATCH 029/121] Rename impat_mat_list to _gen

---
 climada/engine/impact.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index d50444cb9..9b3005de9 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -123,7 +123,7 @@ def risk_metrics_from_mat(imp_mat, freq):
     aai_agg = aai_agg_from_eai_exp(eai_exp)
     return at_event, eai_exp, aai_agg
 
-def calc_imp_mat_list(hazard, exp_gdf, impf_col, impf_set):
+def imp_mat_gen(hazard, exp_gdf, impf_col, impf_set):
     """
     List of impact matrices for the exposure and of corresponding exposures indices
     """
@@ -389,7 +389,7 @@ def calc_risk(cls, exposures, impact_funcs, hazard, save_mat=True):
         exp_gdf = get_minimal_exp(exposures, hazard, impf_col)
         LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
                     exp_gdf.size, hazard.size)
-        imp_mat_list = calc_imp_mat_list(hazard, exp_gdf, impf_col, impact_funcs)
+        imp_mat_list = imp_mat_gen(hazard, exp_gdf, impf_col, impact_funcs)
         n_exp_pnt = exposures.gdf.shape[0]
         n_events = hazard.size
         if save_mat:
@@ -427,7 +427,7 @@ def calc_insured_risk(cls, exposures, impact_funcs, hazard, save_mat=False):
         exp_gdf = get_minimal_exp(exposures, hazard, impf_col)
         LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
                     exp_gdf.size, hazard.size)
-        imp_mat_list = calc_imp_mat_list(hazard, exp_gdf, impf_col, impact_funcs)
+        imp_mat_list = imp_mat_gen(hazard, exp_gdf, impf_col, impact_funcs)
         n_exp_pnt = exposures.gdf.shape[0]
         n_events = hazard.size
         imp_mat_list2 = []

From d22ce454d79baa25c8fc642417ae04fd6e333c56 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 21 Apr 2022 17:23:44 +0200
Subject: [PATCH 030/121] Avoid generator to list conversion in insured risk

---
 climada/engine/impact.py | 23 ++++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 9b3005de9..b9077c70c 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -430,17 +430,18 @@ def calc_insured_risk(cls, exposures, impact_funcs, hazard, save_mat=False):
         imp_mat_list = imp_mat_gen(hazard, exp_gdf, impf_col, impact_funcs)
         n_exp_pnt = exposures.gdf.shape[0]
         n_events = hazard.size
-        imp_mat_list2 = []
-        for mat, exp_idx in imp_mat_list:
-            impf_id = exposures.gdf[impf_col][exp_idx].unique()[0]
-            deductible = exposures.gdf['deductible'][exp_idx]
-            cent_idx = exposures.gdf['centr_TC'][exp_idx]
-            impf = impact_funcs.get_func(haz_type=hazard.haz_type, fun_id=impf_id)
-            mat = apply_deductible_to_imp_mat(mat, deductible, hazard, cent_idx, impf)
-            cover = exposures.gdf['cover'][exp_idx]
-            mat = apply_cover_to_imp_mat(mat, cover)
-            imp_mat_list2.append((mat, exp_idx))
-        imp_mat_list = imp_mat_list2
+
+        def insured_mat_gen(imp_mat_gen, exposures, impact_funcs, hazard, impf_col):
+            for mat, exp_idx in imp_mat_gen:
+                impf_id = exposures.gdf[impf_col][exp_idx].unique()[0]
+                deductible = exposures.gdf['deductible'][exp_idx]
+                cent_idx = exposures.gdf['centr_TC'][exp_idx]
+                impf = impact_funcs.get_func(haz_type=hazard.haz_type, fun_id=impf_id)
+                mat = apply_deductible_to_imp_mat(mat, deductible, hazard, cent_idx, impf)
+                cover = exposures.gdf['cover'][exp_idx]
+                mat = apply_cover_to_imp_mat(mat, cover)
+                yield (mat, exp_idx)
+        imp_mat_list = insured_mat_gen(imp_mat_list, exposures, impact_funcs, hazard, impf_col)
         if save_mat:
             imp_mat = stich_impact_matrix(imp_mat_list, n_events, n_exp_pnt)
             return cls.from_imp_mat(imp_mat, exposures, impact_funcs, hazard)

From a6703c98733379e67881e626ae282a0060ba1ad0 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 21 Apr 2022 17:37:51 +0200
Subject: [PATCH 031/121] Rename exp_iimp

---
 climada/engine/impact.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index b9077c70c..f1250e22c 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -129,13 +129,13 @@ def imp_mat_gen(hazard, exp_gdf, impf_col, impf_set):
     """
     for impf_id in exp_gdf[impf_col].unique():
         impf = impf_set.get_func(haz_type=hazard.haz_type, fun_id=impf_id)
-        exp_iimp = (exp_gdf[impf_col].values == impf.id).nonzero()[0]
+        idx_exp_impf = (exp_gdf[impf_col].values == impf.id).nonzero()[0]
         exp_step = CONFIG.max_matrix_size.int() // hazard.size
         if not exp_step:
             raise ValueError(
                 f'Increase max_matrix_size configuration parameter to > {hazard.size}')
-        for chk in range(int(exp_iimp.size / exp_step) + 1):
-            exp_idx = exp_iimp[chk * exp_step:(chk + 1) * exp_step]
+        for chk in range(int(idx_exp_impf.size / exp_step) + 1):
+            exp_idx = idx_exp_impf[chk * exp_step:(chk + 1) * exp_step]
             exp_values = exp_gdf.value.values[exp_idx]
             cent_idx = exp_gdf[hazard.cent_exp_col].values[exp_idx]
             yield (impact_matrix(exp_values, cent_idx, hazard, impf), exp_idx)

From 4cb346087cca6b4a3f4a9717a0faa2cadad84d84 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Tue, 3 May 2022 14:27:21 +0200
Subject: [PATCH 032/121] Add impact_calc class

---
 climada/engine/impact.py | 502 ++++++++++++++++++++-------------------
 1 file changed, 259 insertions(+), 243 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index f1250e22c..0fd992ed0 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -123,158 +123,270 @@ def risk_metrics_from_mat(imp_mat, freq):
     aai_agg = aai_agg_from_eai_exp(eai_exp)
     return at_event, eai_exp, aai_agg
 
-def imp_mat_gen(hazard, exp_gdf, impf_col, impf_set):
-    """
-    List of impact matrices for the exposure and of corresponding exposures indices
+
+class Impact_calc():
     """
-    for impf_id in exp_gdf[impf_col].unique():
-        impf = impf_set.get_func(haz_type=hazard.haz_type, fun_id=impf_id)
-        idx_exp_impf = (exp_gdf[impf_col].values == impf.id).nonzero()[0]
-        exp_step = CONFIG.max_matrix_size.int() // hazard.size
-        if not exp_step:
-            raise ValueError(
-                f'Increase max_matrix_size configuration parameter to > {hazard.size}')
-        for chk in range(int(idx_exp_impf.size / exp_step) + 1):
-            exp_idx = idx_exp_impf[chk * exp_step:(chk + 1) * exp_step]
-            exp_values = exp_gdf.value.values[exp_idx]
-            cent_idx = exp_gdf[hazard.cent_exp_col].values[exp_idx]
-            yield (impact_matrix(exp_values, cent_idx, hazard, impf), exp_idx)
-
-def impact_matrix(exp_values, cent_idx, hazard, impf):
+    Class to compute impacts from exposures, impact function set and hazard
     """
-    Compute the impact matrix for given exposure values, assigned centroids, a hazard,
-    and one impact function.
 
-    Parameters
-    ----------
-    exp_values : np.array
-        Exposure values
-    cent_idx : np.array
-        Hazard centroids assigned to each exposure location
-    hazard : Hazard
-       Hazard object
-    impf : ImpactFunction
-        one impactfunction comon to all exposure elements in exp_gdf
+    def __init__(self,
+                 exposures,
+                 impfset,
+                 hazard):
 
-    Returns
-    -------
-    scipy.sparse.csr_matrix
-        Impact per event (rows) per exposure point (columns)
-    """
-    n_centroids = cent_idx.size
-    mdr = hazard.get_mdr(cent_idx, impf)
-    fract = hazard.get_fraction(cent_idx)
-    exp_values_csr = sparse.csr_matrix(
-        (exp_values, np.arange(n_centroids), [0, n_centroids]),
-        shape=(1, n_centroids))
-    return fract.multiply(mdr).multiply(exp_values_csr)
-
-def stich_impact_matrix(imp_mat_list, n_events, n_exp_pnt):
-    """
-    Make an impact matrix from an impact matrix list
-    """
-    data, row, col = np.hstack([
-        (mat.data, mat.nonzero()[0], idx[mat.nonzero()[1]])
-        for mat, idx in imp_mat_list
-        ])
-    return sparse.csr_matrix((data, (row, col)), shape=(n_events, n_exp_pnt))
+        self.exposures = exposures
+        self.impfset = impfset
+        self.hazard = hazard
 
-def stich_risk_metrics(imp_mat_list, freq, n_events, n_exp_pnt):
-    """
-    Compute the impact metrics from an impact matrix list
-    """
-    at_event = np.zeros(n_events)
-    eai_exp = np.zeros(n_exp_pnt)
-    for imp_mat, exp_idx in imp_mat_list:
-        at_event += at_event_from_mat(imp_mat)
-        eai_exp[exp_idx] += eai_exp_from_mat(imp_mat, freq)
-    aai_agg = aai_agg_from_eai_exp(eai_exp)
-    return at_event, eai_exp, aai_agg
+    def risk(self, save_mat=True):
+        """Compute impact of an hazard to exposures including risk metrics.
 
-def get_minimal_exp(exposures, hazard, impf_col):
-    """Get minimal exposures geodataframe for impact computation
+        Parameters
+        ----------
+        exposures : climada.entity.Exposures
+            the exposures
+        impact_funcs : climada.entity.ImpactFuncSet
+            the set of impact functions
+        hazard : climada.Hazard
+            the hazard
+        save_mat : bool
+            if true, save the total impact matrix (events x exposures)
 
-    Parameters
-    ----------
-    exposures : climada.entity.Exposures
-    hazard : climada.Hazard
-    impf_col: stirng
-        name of the impact function column in exposures.gdf
+        Examples
+        --------
+            Use Entity class:
 
-    """
-    exposures.assign_centroids(hazard, overwrite=False)
-
-    mask = (
-        (exposures.gdf.value.values != 0)
-        & (exposures.gdf[hazard.cent_exp_col].values >= 0)
-    )
-    exp_gdf = pd.DataFrame({
-        col: exposures.gdf[col].values[mask]
-        for col in ['value', impf_col, hazard.cent_exp_col]
-    })
-    if exp_gdf.size == 0:
-        LOGGER.warning("No exposures with value >0 in the vicinity of the hazard.")
-    return exp_gdf
-
-
-def apply_deductible_to_imp_mat(imp_mat, deductible, hazard, cent_idx, impf):
-    """
-    Apply a deductible per exposure point to an impact matrix at given
-    centroid points for given impact function.
+            >>> haz = Hazard.from_mat(HAZ_DEMO_MAT)  # Set hazard
+            >>> ent = Entity.from_excel(ENT_TEMPLATE_XLS) # Set exposures
+            >>> imp = Impact.calc_risk(ent.exposures, ent.impact_funcs, haz)
+            >>> imp.calc_freq_curve().plot()
 
-    All exposure points must have the same impact function. For different
-    impact functions apply use this method repeatedly on the same impact
-    matrix.
+            Specify only exposures and impact functions:
 
-    Parameters
-    ----------
-    imp_mat : scipy.sparse.csr_matrix
-        impact matrix (events x exposure points)
-    deductible : np.array()
-        deductible for each exposure point
-    hazard : Hazard
-        hazard used to compute the imp_mat
-    cent_idx : np.array()
-        index of centroids associated with each exposure point
-    impf : ImpactFunc
-        impact function associated with the exposure points
+            >>> haz = Hazard.from_mat(HAZ_DEMO_MAT)  # Set hazard
+            >>> funcs = ImpactFuncSet.from_excel(ENT_TEMPLATE_XLS) # Set impact functions
+            >>> exp = Exposures(pd.read_excel(ENT_TEMPLATE_XLS)) # Set exposures
+            >>> imp = Impact.calc_risk(exp, funcs, haz)
+            >>> imp.aai_agg
+        """
+        impf_col = self.exposures.get_impf_column(self.hazard.haz_type)
+        exp_gdf = self.get_minimal_exp(self.exposures, self.hazard, impf_col)
+        LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
+                    exp_gdf.size, self.hazard.size)
+        imp_mat_list = self.imp_mat_gen(exp_gdf, impf_col)
+        n_exp_pnt = self.exposures.gdf.shape[0]
+        n_events = self.hazard.size
+        if save_mat:
+            imp_mat = self.stich_impact_matrix(imp_mat_list, n_events, n_exp_pnt)
+            return Impact.from_imp_mat(imp_mat, self.exposures, self.impfset, self.hazard)
+        else:
+            at_event, eai_exp, aai_agg = self.stich_risk_metrics(imp_mat_list, self.hazard.frequency, n_events, n_exp_pnt)
+            return Impact.from_imp_metrics(at_event, eai_exp, aai_agg, self.exposures, self.impfset, self.hazard)
 
-    Returns
-    -------
-    imp_mat : scipy.sparse.csr_matrix
-        impact matrix with applied deductible
+    def insured_risk(self, save_mat=False):
+        """
+        To be document and written more nicely.
 
-    """
-    paa = hazard.get_paa(cent_idx, impf)
-    imp_mat -= paa.multiply(sparse.csr_matrix(deductible))
-    imp_mat.eliminate_zeros()
-    return imp_mat
+        Parameters
+        ----------
+        cls : TYPE
+            DESCRIPTION.
+        exposures : TYPE
+            DESCRIPTION.
+        impact_funcs : TYPE
+            DESCRIPTION.
+        hazard : TYPE
+            DESCRIPTION.
+        save_mat : TYPE, optional
+            DESCRIPTION. The default is False.
+
+        Returns
+        -------
+        TYPE
+            DESCRIPTION.
 
+        """
+        impf_col = self.exposures.get_impf_column(self.hazard.haz_type)
+        exp_gdf = self.get_minimal_exp(impf_col)
+        LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
+                    exp_gdf.size, self.hazard.size)
+        imp_mat_list = self.imp_mat_gen(exp_gdf, impf_col)
+        n_exp_pnt = self.exposures.gdf.shape[0]
+        n_events = self.hazard.size
 
-def apply_cover_to_imp_mat(imp_mat, cover):
-    """
-    Apply cover to impact matrix.
+        def insured_mat_gen(imp_mat_gen, exposures, impact_funcs, hazard, impf_col):
+            for mat, exp_idx in imp_mat_gen:
+                impf_id = exposures.gdf[impf_col][exp_idx].unique()[0]
+                deductible = exposures.gdf['deductible'][exp_idx]
+                cent_idx = exposures.gdf['centr_TC'][exp_idx]
+                impf = impact_funcs.get_func(haz_type=hazard.haz_type, fun_id=impf_id)
+                mat = self.apply_deductible_to_imp_mat(mat, deductible, hazard, cent_idx, impf)
+                cover = exposures.gdf['cover'][exp_idx]
+                mat = self.apply_cover_to_imp_mat(mat, cover)
+                yield (mat, exp_idx)
 
-    The impact data is clipped to the range [0, cover]. The cover is defined
-    per exposure point.
+        imp_mat_list = insured_mat_gen(imp_mat_list, self.exposures, self.impfset, self.hazard, impf_col)
+        if save_mat:
+            imp_mat = self.stich_impact_matrix(imp_mat_list, n_events, n_exp_pnt)
+            return Impact.from_imp_mat(imp_mat, self.exposures, self.impfset, self.hazard)
+        else:
+            at_event, eai_exp, aai_agg = self.stich_risk_metrics(imp_mat_list, self.hazard.frequency, n_events, n_exp_pnt)
+            return Impact.from_imp_metrics(at_event, eai_exp, aai_agg, self.exposures, self.impfset, self.hazard)
 
-    Parameters
-    ----------
-    imp_mat : scipy.sparse.csr_matrix
-        impact matrix
-    cover : np.array()
-        cover per exposures point (columns of imp_mat)
 
-    Returns
-    -------
-    imp_mat : scyp.sparse.csr_matrix
-        impact matrix with applied cover
+    def get_minimal_exp(self, impf_col):
+        """Get minimal exposures geodataframe for impact computation
 
-    """
-    imp_mat.data = np.clip(imp_mat.data, 0, cover.to_numpy()[imp_mat.nonzero()[1]])
-    imp_mat.eliminate_zeros()
-    return imp_mat
+        Parameters
+        ----------
+        exposures : climada.entity.Exposures
+        hazard : climada.Hazard
+        impf_col: stirng
+            name of the impact function column in exposures.gdf
 
+        """
+        self.exposures.assign_centroids(self.hazard, overwrite=False)
+
+        mask = (
+            (self.exposures.gdf.value.values != 0)
+            & (self.exposures.gdf[self.hazard.cent_exp_col].values >= 0)
+        )
+        exp_gdf = pd.DataFrame({
+            col: self.exposures.gdf[col].values[mask]
+            for col in ['value', impf_col, self.hazard.cent_exp_col]
+        })
+        if exp_gdf.size == 0:
+            LOGGER.warning("No exposures with value >0 in the vicinity of the hazard.")
+        return exp_gdf
+
+    def imp_mat_gen(self, exp_gdf, impf_col):
+        """
+        List of impact matrices for the exposure and of corresponding exposures indices
+        """
+        for impf_id in exp_gdf[impf_col].unique():
+            impf = self.impfset.get_func(haz_type=self.hazard.haz_type, fun_id=impf_id)
+            idx_exp_impf = (exp_gdf[impf_col].values == impf.id).nonzero()[0]
+            exp_step = CONFIG.max_matrix_size.int() // self.hazard.size
+            if not exp_step:
+                raise ValueError(
+                    f'Increase max_matrix_size configuration parameter to > {self.hazard.size}')
+            for chk in range(int(idx_exp_impf.size / exp_step) + 1):
+                exp_idx = idx_exp_impf[chk * exp_step:(chk + 1) * exp_step]
+                exp_values = exp_gdf.value.values[exp_idx]
+                cent_idx = exp_gdf[self.hazard.cent_exp_col].values[exp_idx]
+                yield (self.impact_matrix(exp_values, cent_idx, impf), exp_idx)
+
+    def impact_matrix(self, exp_values, cent_idx, impf):
+        """
+        Compute the impact matrix for given exposure values, assigned centroids, a hazard,
+        and one impact function.
+
+        Parameters
+        ----------
+        exp_values : np.array
+            Exposure values
+        cent_idx : np.array
+            Hazard centroids assigned to each exposure location
+        hazard : Hazard
+           Hazard object
+        impf : ImpactFunction
+            one impactfunction comon to all exposure elements in exp_gdf
+
+        Returns
+        -------
+        scipy.sparse.csr_matrix
+            Impact per event (rows) per exposure point (columns)
+        """
+        n_centroids = cent_idx.size
+        mdr = self.hazard.get_mdr(cent_idx, impf)
+        fract = self.hazard.get_fraction(cent_idx)
+        exp_values_csr = sparse.csr_matrix(
+            (exp_values, np.arange(n_centroids), [0, n_centroids]),
+            shape=(1, n_centroids))
+        return fract.multiply(mdr).multiply(exp_values_csr)
+
+    @staticmethod
+    def stich_impact_matrix(imp_mat_list, n_events, n_exp_pnt):
+        """
+        Make an impact matrix from an impact matrix list
+        """
+        data, row, col = np.hstack([
+            (mat.data, mat.nonzero()[0], idx[mat.nonzero()[1]])
+            for mat, idx in imp_mat_list
+            ])
+        return sparse.csr_matrix((data, (row, col)), shape=(n_events, n_exp_pnt))
+
+    @staticmethod
+    def stich_risk_metrics(imp_mat_list, freq, n_events, n_exp_pnt):
+        """
+        Compute the impact metrics from an impact matrix list
+        """
+        at_event = np.zeros(n_events)
+        eai_exp = np.zeros(n_exp_pnt)
+        for imp_mat, exp_idx in imp_mat_list:
+            at_event += at_event_from_mat(imp_mat)
+            eai_exp[exp_idx] += eai_exp_from_mat(imp_mat, freq)
+        aai_agg = aai_agg_from_eai_exp(eai_exp)
+        return at_event, eai_exp, aai_agg
+
+    @staticmethod
+    def apply_deductible_to_imp_mat(imp_mat, deductible, hazard, cent_idx, impf):
+        """
+        Apply a deductible per exposure point to an impact matrix at given
+        centroid points for given impact function.
+
+        All exposure points must have the same impact function. For different
+        impact functions apply use this method repeatedly on the same impact
+        matrix.
+
+        Parameters
+        ----------
+        imp_mat : scipy.sparse.csr_matrix
+            impact matrix (events x exposure points)
+        deductible : np.array()
+            deductible for each exposure point
+        hazard : Hazard
+            hazard used to compute the imp_mat
+        cent_idx : np.array()
+            index of centroids associated with each exposure point
+        impf : ImpactFunc
+            impact function associated with the exposure points
+
+        Returns
+        -------
+        imp_mat : scipy.sparse.csr_matrix
+            impact matrix with applied deductible
+
+        """
+        paa = hazard.get_paa(cent_idx, impf)
+        imp_mat -= paa.multiply(sparse.csr_matrix(deductible))
+        imp_mat.eliminate_zeros()
+        return imp_mat
+
+    @staticmethod
+    def apply_cover_to_imp_mat(imp_mat, cover):
+        """
+        Apply cover to impact matrix.
+
+        The impact data is clipped to the range [0, cover]. The cover is defined
+        per exposure point.
+
+        Parameters
+        ----------
+        imp_mat : scipy.sparse.csr_matrix
+            impact matrix
+        cover : np.array()
+            cover per exposures point (columns of imp_mat)
+
+        Returns
+        -------
+        imp_mat : scyp.sparse.csr_matrix
+            impact matrix with applied cover
+
+        """
+        imp_mat.data = np.clip(imp_mat.data, 0, cover.to_numpy()[imp_mat.nonzero()[1]])
+        imp_mat.eliminate_zeros()
+        return imp_mat
 
 class Impact():
     """Impact definition. Compute from an entity (exposures and impact
@@ -343,114 +455,19 @@ def __init__(self,
 
     def calc(self, exposures, impact_funcs, hazard, save_mat=False):
         """This function is deprecated, use Impact.calc_risk and Impact.calc_insured_risk instead."""
+        impcalc= Impact_calc(exposures, impact_funcs, hazard)
         if ('deductible' in exposures.gdf) and ('cover' in exposures.gdf) \
             and exposures.gdf.cover.max():
             # LOGGER.warning("To compute the risk transfer value"
             #      "please use Impact.calc_insured_risk")
-            self.__dict__ = self.calc_insured_risk(exposures, impact_funcs, hazard, save_mat).__dict__
+            self.__dict__ = impcalc.insured_risk(save_mat).__dict__
         else:
             # LOGGER.warning("The use of Impact.calc() is deprecated."
             #      "Please use Impact.calc_risk() or Impact.calc_risk_insured().")
-            self.__dict__ = self.calc_risk(exposures, impact_funcs, hazard, save_mat).__dict__
-
-    @classmethod
-    def calc_risk(cls, exposures, impact_funcs, hazard, save_mat=True):
-        """Compute impact of an hazard to exposures including risk metrics.
-
-        Parameters
-        ----------
-        exposures : climada.entity.Exposures
-            the exposures
-        impact_funcs : climada.entity.ImpactFuncSet
-            the set of impact functions
-        hazard : climada.Hazard
-            the hazard
-        save_mat : bool
-            if true, save the total impact matrix (events x exposures)
-
-        Examples
-        --------
-            Use Entity class:
-
-            >>> haz = Hazard.from_mat(HAZ_DEMO_MAT)  # Set hazard
-            >>> ent = Entity.from_excel(ENT_TEMPLATE_XLS) # Set exposures
-            >>> imp = Impact.calc_risk(ent.exposures, ent.impact_funcs, haz)
-            >>> imp.calc_freq_curve().plot()
-
-            Specify only exposures and impact functions:
-
-            >>> haz = Hazard.from_mat(HAZ_DEMO_MAT)  # Set hazard
-            >>> funcs = ImpactFuncSet.from_excel(ENT_TEMPLATE_XLS) # Set impact functions
-            >>> exp = Exposures(pd.read_excel(ENT_TEMPLATE_XLS)) # Set exposures
-            >>> imp = Impact.calc_risk(exp, funcs, haz)
-            >>> imp.aai_agg
-        """
-        impf_col = exposures.get_impf_column(hazard.haz_type)
-        exp_gdf = get_minimal_exp(exposures, hazard, impf_col)
-        LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
-                    exp_gdf.size, hazard.size)
-        imp_mat_list = imp_mat_gen(hazard, exp_gdf, impf_col, impact_funcs)
-        n_exp_pnt = exposures.gdf.shape[0]
-        n_events = hazard.size
-        if save_mat:
-            imp_mat = stich_impact_matrix(imp_mat_list, n_events, n_exp_pnt)
-            return cls.from_imp_mat(imp_mat, exposures, impact_funcs, hazard)
-        else:
-            at_event, eai_exp, aai_agg = stich_risk_metrics(imp_mat_list, hazard.frequency, n_events, n_exp_pnt)
-            return cls.from_imp_metrics(at_event, eai_exp, aai_agg, exposures, impact_funcs, hazard)
-
-    @classmethod
-    def calc_insured_risk(cls, exposures, impact_funcs, hazard, save_mat=False):
-        """
-        To be document and written more nicely.
-
-        Parameters
-        ----------
-        cls : TYPE
-            DESCRIPTION.
-        exposures : TYPE
-            DESCRIPTION.
-        impact_funcs : TYPE
-            DESCRIPTION.
-        hazard : TYPE
-            DESCRIPTION.
-        save_mat : TYPE, optional
-            DESCRIPTION. The default is False.
-
-        Returns
-        -------
-        TYPE
-            DESCRIPTION.
-
-        """
-        impf_col = exposures.get_impf_column(hazard.haz_type)
-        exp_gdf = get_minimal_exp(exposures, hazard, impf_col)
-        LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
-                    exp_gdf.size, hazard.size)
-        imp_mat_list = imp_mat_gen(hazard, exp_gdf, impf_col, impact_funcs)
-        n_exp_pnt = exposures.gdf.shape[0]
-        n_events = hazard.size
-
-        def insured_mat_gen(imp_mat_gen, exposures, impact_funcs, hazard, impf_col):
-            for mat, exp_idx in imp_mat_gen:
-                impf_id = exposures.gdf[impf_col][exp_idx].unique()[0]
-                deductible = exposures.gdf['deductible'][exp_idx]
-                cent_idx = exposures.gdf['centr_TC'][exp_idx]
-                impf = impact_funcs.get_func(haz_type=hazard.haz_type, fun_id=impf_id)
-                mat = apply_deductible_to_imp_mat(mat, deductible, hazard, cent_idx, impf)
-                cover = exposures.gdf['cover'][exp_idx]
-                mat = apply_cover_to_imp_mat(mat, cover)
-                yield (mat, exp_idx)
-        imp_mat_list = insured_mat_gen(imp_mat_list, exposures, impact_funcs, hazard, impf_col)
-        if save_mat:
-            imp_mat = stich_impact_matrix(imp_mat_list, n_events, n_exp_pnt)
-            return cls.from_imp_mat(imp_mat, exposures, impact_funcs, hazard)
-        else:
-            at_event, eai_exp, aai_agg = stich_risk_metrics(imp_mat_list, hazard.frequency, n_events, n_exp_pnt)
-            return cls.from_imp_metrics(at_event, eai_exp, aai_agg, exposures, impact_funcs, hazard)
+            self.__dict__ = impcalc.risk(save_mat).__dict__
 
     @classmethod
-    def from_imp_metrics(cls, at_event, eai_exp, aai_agg, exposures, impf_set, hazard):
+    def from_imp_metrics(cls, at_event, eai_exp, aai_agg, exposures, impfset, hazard):
         """
         Set Impact attributes from the impact matrix.
 
@@ -485,14 +502,13 @@ def from_imp_metrics(cls, at_event, eai_exp, aai_agg, exposures, impf_set, hazar
             at_event = at_event,
             aai_agg = aai_agg,
             tag = {'exp': exposures.tag,
-                   'impf_set': impf_set.tag,
+                   'impf_set': impfset.tag,
                    'haz': hazard.tag
                    }
             )
 
-
     @classmethod
-    def from_imp_mat(cls, imp_mat, exposures, impf_set, hazard):
+    def from_imp_mat(cls, imp_mat, exposures, impfset, hazard):
         """
         Set Impact attributes from the impact matrix.
 
@@ -529,12 +545,12 @@ def from_imp_mat(cls, imp_mat, exposures, impf_set, hazard):
             aai_agg = aai_agg,
             imp_mat = imp_mat,
             tag = {'exp': exposures.tag,
-                   'impf_set': impf_set.tag,
+                   'impf_set': impfset.tag,
                    'haz': hazard.tag
                    }
             )
 
-    def calc_transfer_risk(self, attachment, cover):
+    def transfer_risk(self, attachment, cover):
         """Compute the risk transfer for the full portfolio
 
         Parameters
@@ -555,7 +571,7 @@ def calc_transfer_risk(self, attachment, cover):
         transfer_aai_agg = np.sum(transfer_at_event * self.frequency)
         return transfer_at_event, transfer_aai_agg
 
-    def calc_residual_risk(self, attachment, cover):
+    def residual_risk(self, attachment, cover):
         """Compute the residual risk after application of insurance
         attachment and cover to entire portfolio.
 
@@ -574,7 +590,7 @@ def calc_residual_risk(self, attachment, cover):
             average annual residual risk
 
         """
-        transfer_at_event, _ = self.calc_transfer_risk(attachment, cover)
+        transfer_at_event, _ = self.transfer_risk(attachment, cover)
         residual_at_event = np.maximum(self.at_event - transfer_at_event, 0)
         residual_aai_agg = np.sum(residual_at_event * self.frequency)
         return residual_at_event, residual_aai_agg
@@ -611,7 +627,7 @@ def calc_risk_transfer(self, attachment, cover):
 
         return new_imp, Impact()
 
-    def calc_impact_per_year(self, all_years=True, year_range=None):
+    def impact_per_year(self, all_years=True, year_range=None):
         """Calculate yearly impact from impact data.
 
         Note: the impact in a given year is summed over all events.
@@ -654,10 +670,10 @@ def calc_impact_per_year(self, all_years=True, year_range=None):
         return year_set
 
     def calc_impact_year_set(self,all_years=True, year_range=None):
-        """This function is deprecated, use Impact.calc_impact_per_year instead."""
+        """This function is deprecated, use Impact.impact_per_year instead."""
         LOGGER.warning("The use of Impact.calc_impact_year_set is deprecated."
-                       "Use Impact.calc_impact_per_year instead.")
-        return self.calc_impact_per_year(all_years=all_years, year_range=year_range)
+                       "Use Impact.impact_per_year instead.")
+        return self.impact_per_year(all_years=all_years, year_range=year_range)
 
     def local_exceedance_imp(self, return_periods=(25, 50, 100, 250)):
         """Compute exceedance impact map for given return periods.

From 7457e3a676c2c0d8b09d60439a0b84c95af9801b Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Tue, 3 May 2022 14:44:14 +0200
Subject: [PATCH 033/121] Correct function signature

---
 climada/engine/impact.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 0fd992ed0..7befcd61d 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -170,7 +170,7 @@ def risk(self, save_mat=True):
             >>> imp.aai_agg
         """
         impf_col = self.exposures.get_impf_column(self.hazard.haz_type)
-        exp_gdf = self.get_minimal_exp(self.exposures, self.hazard, impf_col)
+        exp_gdf = self.get_minimal_exp(impf_col)
         LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
                     exp_gdf.size, self.hazard.size)
         imp_mat_list = self.imp_mat_gen(exp_gdf, impf_col)

From 075836ad139244f9d76e7267dd16eb7e9c5084d0 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Tue, 3 May 2022 14:57:22 +0200
Subject: [PATCH 034/121] Adjust class name

---
 climada/engine/impact.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 7befcd61d..3c6ee37f0 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -124,7 +124,7 @@ def risk_metrics_from_mat(imp_mat, freq):
     return at_event, eai_exp, aai_agg
 
 
-class Impact_calc():
+class ImpactCalc():
     """
     Class to compute impacts from exposures, impact function set and hazard
     """
@@ -455,7 +455,7 @@ def __init__(self,
 
     def calc(self, exposures, impact_funcs, hazard, save_mat=False):
         """This function is deprecated, use Impact.calc_risk and Impact.calc_insured_risk instead."""
-        impcalc= Impact_calc(exposures, impact_funcs, hazard)
+        impcalc= ImpactCalc(exposures, impact_funcs, hazard)
         if ('deductible' in exposures.gdf) and ('cover' in exposures.gdf) \
             and exposures.gdf.cover.max():
             # LOGGER.warning("To compute the risk transfer value"

From 31845f95584a7492c89d5580c8ddea658cc4dfc7 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Tue, 3 May 2022 16:02:27 +0200
Subject: [PATCH 035/121] Correct indent

---
 climada/engine/impact.py | 36 ++++++++++++++++++------------------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 3c6ee37f0..8fda51570 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -48,24 +48,24 @@
 LOGGER = logging.getLogger(__name__)
 
 def eai_exp_from_mat(imp_mat, freq):
-        """
-        Compute impact for each exposures from the total impact matrix
-        Parameters
-        ----------
-        imp_mat : sparse.csr_matrix
-            matrix num_events x num_exp with impacts.
-        frequency : np.array
-            annual frequency of events
-        Returns
-        -------
-        eai_exp : np.array
-            expected annual impact for each exposure
-        """
-        n_events = freq.size
-        freq_csr = sparse.csr_matrix(
-            (freq, np.zeros(n_events), np.arange(n_events + 1)),
-            shape=(n_events, 1))
-        return imp_mat.multiply(freq_csr).sum(axis=0).A1
+    """
+    Compute impact for each exposures from the total impact matrix
+    Parameters
+    ----------
+    imp_mat : sparse.csr_matrix
+        matrix num_events x num_exp with impacts.
+    frequency : np.array
+        annual frequency of events
+    Returns
+    -------
+    eai_exp : np.array
+        expected annual impact for each exposure
+    """
+    n_events = freq.size
+    freq_csr = sparse.csr_matrix(
+        (freq, np.zeros(n_events), np.arange(n_events + 1)),
+        shape=(n_events, 1))
+    return imp_mat.multiply(freq_csr).sum(axis=0).A1
 
 def at_event_from_mat(imp_mat):
     """

From e2384d41ecd83849aee1338d9a2285131c619444 Mon Sep 17 00:00:00 2001
From: Thomas Vogt <thomas.vogt@pik-potsdam.de>
Date: Mon, 9 May 2022 11:23:44 +0200
Subject: [PATCH 036/121] Typo: stich -> stitch

---
 climada/engine/impact.py | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 8fda51570..3b749b021 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -177,10 +177,10 @@ def risk(self, save_mat=True):
         n_exp_pnt = self.exposures.gdf.shape[0]
         n_events = self.hazard.size
         if save_mat:
-            imp_mat = self.stich_impact_matrix(imp_mat_list, n_events, n_exp_pnt)
+            imp_mat = self.stitch_impact_matrix(imp_mat_list, n_events, n_exp_pnt)
             return Impact.from_imp_mat(imp_mat, self.exposures, self.impfset, self.hazard)
         else:
-            at_event, eai_exp, aai_agg = self.stich_risk_metrics(imp_mat_list, self.hazard.frequency, n_events, n_exp_pnt)
+            at_event, eai_exp, aai_agg = self.stitch_risk_metrics(imp_mat_list, self.hazard.frequency, n_events, n_exp_pnt)
             return Impact.from_imp_metrics(at_event, eai_exp, aai_agg, self.exposures, self.impfset, self.hazard)
 
     def insured_risk(self, save_mat=False):
@@ -227,10 +227,10 @@ def insured_mat_gen(imp_mat_gen, exposures, impact_funcs, hazard, impf_col):
 
         imp_mat_list = insured_mat_gen(imp_mat_list, self.exposures, self.impfset, self.hazard, impf_col)
         if save_mat:
-            imp_mat = self.stich_impact_matrix(imp_mat_list, n_events, n_exp_pnt)
+            imp_mat = self.stitch_impact_matrix(imp_mat_list, n_events, n_exp_pnt)
             return Impact.from_imp_mat(imp_mat, self.exposures, self.impfset, self.hazard)
         else:
-            at_event, eai_exp, aai_agg = self.stich_risk_metrics(imp_mat_list, self.hazard.frequency, n_events, n_exp_pnt)
+            at_event, eai_exp, aai_agg = self.stitch_risk_metrics(imp_mat_list, self.hazard.frequency, n_events, n_exp_pnt)
             return Impact.from_imp_metrics(at_event, eai_exp, aai_agg, self.exposures, self.impfset, self.hazard)
 
 
@@ -263,7 +263,7 @@ def imp_mat_gen(self, exp_gdf, impf_col):
         """
         List of impact matrices for the exposure and of corresponding exposures indices
         """
-        for impf_id in exp_gdf[impf_col].unique():
+        for impf_id in exp_gdf[impf_col].dropna().unique():
             impf = self.impfset.get_func(haz_type=self.hazard.haz_type, fun_id=impf_id)
             idx_exp_impf = (exp_gdf[impf_col].values == impf.id).nonzero()[0]
             exp_step = CONFIG.max_matrix_size.int() // self.hazard.size
@@ -306,7 +306,7 @@ def impact_matrix(self, exp_values, cent_idx, impf):
         return fract.multiply(mdr).multiply(exp_values_csr)
 
     @staticmethod
-    def stich_impact_matrix(imp_mat_list, n_events, n_exp_pnt):
+    def stitch_impact_matrix(imp_mat_list, n_events, n_exp_pnt):
         """
         Make an impact matrix from an impact matrix list
         """
@@ -317,7 +317,7 @@ def stich_impact_matrix(imp_mat_list, n_events, n_exp_pnt):
         return sparse.csr_matrix((data, (row, col)), shape=(n_events, n_exp_pnt))
 
     @staticmethod
-    def stich_risk_metrics(imp_mat_list, freq, n_events, n_exp_pnt):
+    def stitch_risk_metrics(imp_mat_list, freq, n_events, n_exp_pnt):
         """
         Compute the impact metrics from an impact matrix list
         """
@@ -469,7 +469,7 @@ def calc(self, exposures, impact_funcs, hazard, save_mat=False):
     @classmethod
     def from_imp_metrics(cls, at_event, eai_exp, aai_agg, exposures, impfset, hazard):
         """
-        Set Impact attributes from the impact matrix.
+        Set Impact attributes from precalculated impact metrics.
 
         Parameters
         ----------

From 2e36267d74a093a7c1743668064979b4c6d0cbe3 Mon Sep 17 00:00:00 2001
From: emanuel-schmid <schmide@ethz.ch>
Date: Mon, 9 May 2022 16:35:40 +0200
Subject: [PATCH 037/121] PEP8

---
 climada/engine/impact.py | 62 ++++++++++++++++++++++++----------------
 1 file changed, 37 insertions(+), 25 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 65a09bf99..7a69c8ce9 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -180,8 +180,11 @@ def risk(self, save_mat=True):
             imp_mat = self.stitch_impact_matrix(imp_mat_list, n_events, n_exp_pnt)
             return Impact.from_imp_mat(imp_mat, self.exposures, self.impfset, self.hazard)
         else:
-            at_event, eai_exp, aai_agg = self.stitch_risk_metrics(imp_mat_list, self.hazard.frequency, n_events, n_exp_pnt)
-            return Impact.from_imp_metrics(at_event, eai_exp, aai_agg, self.exposures, self.impfset, self.hazard)
+            at_event, eai_exp, aai_agg = self.stitch_risk_metrics(imp_mat_list,
+                                                                  self.hazard.frequency,
+                                                                  n_events, n_exp_pnt)
+            return Impact.from_imp_metrics(at_event, eai_exp, aai_agg, self.exposures,
+                                           self.impfset, self.hazard)
 
     def insured_risk(self, save_mat=False):
         """
@@ -225,13 +228,17 @@ def insured_mat_gen(imp_mat_gen, exposures, impact_funcs, hazard, impf_col):
                 mat = self.apply_cover_to_imp_mat(mat, cover)
                 yield (mat, exp_idx)
 
-        imp_mat_list = insured_mat_gen(imp_mat_list, self.exposures, self.impfset, self.hazard, impf_col)
+        imp_mat_list = insured_mat_gen(imp_mat_list, self.exposures, self.impfset, self.hazard,
+                                       impf_col)
         if save_mat:
             imp_mat = self.stitch_impact_matrix(imp_mat_list, n_events, n_exp_pnt)
             return Impact.from_imp_mat(imp_mat, self.exposures, self.impfset, self.hazard)
         else:
-            at_event, eai_exp, aai_agg = self.stitch_risk_metrics(imp_mat_list, self.hazard.frequency, n_events, n_exp_pnt)
-            return Impact.from_imp_metrics(at_event, eai_exp, aai_agg, self.exposures, self.impfset, self.hazard)
+            at_event, eai_exp, aai_agg = self.stitch_risk_metrics(imp_mat_list,
+                                                                  self.hazard.frequency,
+                                                                  n_events, n_exp_pnt)
+            return Impact.from_imp_metrics(at_event, eai_exp, aai_agg, self.exposures,
+                                           self.impfset, self.hazard)
 
 
     def get_minimal_exp(self, impf_col):
@@ -426,7 +433,7 @@ class Impact():
 
     def __init__(self,
                  event_id=np.array([], int),
-                 event_name=[],
+                 event_name=None,
                  date=np.array([], int),
                  frequency=np.array([],float),
                  coord_exp=np.ndarray([], float),
@@ -437,11 +444,11 @@ def __init__(self,
                  aai_agg=0,
                  unit='',
                  imp_mat=sparse.csr_matrix(np.empty((0, 0))),
-                 tag={}):
+                 tag=None):
 
-        self.tag = tag
+        self.tag = tag or {}
         self.event_id = event_id
-        self.event_name = event_name
+        self.event_name = event_name or []
         self.date = date
         self.coord_exp = coord_exp
         self.crs = crs
@@ -454,7 +461,8 @@ def __init__(self,
         self.imp_mat = imp_mat
 
     def calc(self, exposures, impact_funcs, hazard, save_mat=False):
-        """This function is deprecated, use Impact.calc_risk and Impact.calc_insured_risk instead."""
+        """This function is deprecated, use Impact.calc_risk and Impact.calc_insured_risk instead.
+        """
         impcalc= ImpactCalc(exposures, impact_funcs, hazard)
         if ('deductible' in exposures.gdf) and ('cover' in exposures.gdf) \
             and exposures.gdf.cover.max():
@@ -698,8 +706,8 @@ def local_exceedance_imp(self, return_periods=(25, 50, 100, 250)):
         imp_stats = np.zeros((len(return_periods), num_cen))
         cen_step = CONFIG.max_matrix_size.int() // self.imp_mat.shape[0]
         if not cen_step:
-            raise ValueError('Increase max_matrix_size configuration parameter to > %s'
-                             % str(self.imp_mat.shape[0]))
+            raise ValueError('Increase max_matrix_size configuration parameter to > '
+                             f'{self.imp_mat.shape[0]}')
         # separte in chunks
         chk = -1
         for chk in range(int(num_cen / cen_step)):
@@ -767,8 +775,8 @@ def plot_scatter_eai_exposure(self, mask=None, ignore_zero=True,
         axis  : matplotlib.axes._subplots.AxesSubplot, optional
             axis to use
         adapt_fontsize : bool, optional
-                If set to true, the size of the fonts will be adapted to the size of the figure. Otherwise
-                the default matplotlib font size is used. Default is True.
+                If set to true, the size of the fonts will be adapted to the size of the figure.
+                Otherwise the default matplotlib font size is used. Default is True.
         kwargs : optional
             arguments for hexbin matplotlib function
 
@@ -845,8 +853,8 @@ def plot_raster_eai_exposure(self, res=None, raster_res=None, save_tiff=None,
         axis : matplotlib.axes._subplots.AxesSubplot, optional
             axis to use
         adapt_fontsize : bool, optional
-                If set to true, the size of the fonts will be adapted to the size of the figure. Otherwise
-                the default matplotlib font size is used. Default is True.
+                If set to true, the size of the fonts will be adapted to the size of the figure.
+                Otherwise the default matplotlib font size is used. Default is True.
         kwargs : optional
             arguments for imshow matplotlib function
 
@@ -931,8 +939,8 @@ def plot_hexbin_impact_exposure(self, event_id=1, mask=None, ignore_zero=False,
         axis : matplotlib.axes._subplots.AxesSubplot
             optional axis to use
         adapt_fontsize : bool, optional
-            If set to true, the size of the fonts will be adapted to the size of the figure. Otherwise
-            the default matplotlib font size is used. Default is True.
+            If set to true, the size of the fonts will be adapted to the size of the figure.
+            Otherwise the default matplotlib font size is used. Default is True.
 
         Returns
         --------
@@ -945,7 +953,8 @@ def plot_hexbin_impact_exposure(self, event_id=1, mask=None, ignore_zero=False,
             kwargs['cmap'] = CMAP_IMPACT
         impact_at_events_exp = self._build_exp_event(event_id)
         axis = impact_at_events_exp.plot_hexbin(mask, ignore_zero, pop_name,
-                                                buffer, extend, axis=axis, adapt_fontsize=adapt_fontsize,
+                                                buffer, extend, axis=axis,
+                                                adapt_fontsize=adapt_fontsize,
                                                 **kwargs)
 
         return axis
@@ -1023,7 +1032,7 @@ def plot_rp_imp(self, return_periods=(25, 50, 100, 250),
         np.ndarray (return_periods.size x num_centroids)
         """
         imp_stats = self.local_exceedance_imp(np.array(return_periods))
-        if imp_stats == []:
+        if imp_stats.size == 0:
             raise ValueError('Error: Attribute imp_mat is empty. Recalculate Impact'
                              'instance with parameter save_mat=True')
         if log10_scale:
@@ -1056,7 +1065,7 @@ def write_csv(self, file_name):
             absolute path of the file
         """
         LOGGER.info('Writing %s', file_name)
-        with open(file_name, "w") as imp_file:
+        with open(file_name, "w", encoding='utf-8') as imp_file:
             imp_wr = csv.writer(imp_file)
             imp_wr.writerow(["tag_hazard", "tag_exposure", "tag_impact_func",
                              "unit", "tot_value", "aai_agg", "event_id",
@@ -1157,6 +1166,7 @@ def from_csv(cls, file_name):
         imp : climada.engine.impact.Impact
             Impact from csv file
         """
+        # pylint: disable=no-member
         LOGGER.info('Reading %s', file_name)
         imp_df = pd.read_csv(file_name)
         imp = cls()
@@ -1419,10 +1429,10 @@ def _build_exp_event(self, event_id):
         event_id : int
             id of the event
         """
-        [[ix]] = (self.event_id == event_id).nonzero()
+        [[idx]] = (self.event_id == event_id).nonzero()
         return Exposures(
             data={
-                'value': self.imp_mat[ix].toarray().ravel(),
+                'value': self.imp_mat[idx].toarray().ravel(),
                 'latitude': self.coord_exp[:, 0],
                 'longitude': self.coord_exp[:, 1],
             },
@@ -1608,7 +1618,8 @@ def _selected_events_idx(self, event_ids, event_names, dates, nb_events):
         if event_ids is None:
             sel_id = np.array([], dtype=int)
         else:
-            sel_id = np.isin(self.event_id, event_ids).nonzero()[0]
+            (sel_id,) = np.isin(self.event_id, event_ids).nonzero()
+            # pylint: disable=no-member
             if sel_id.size == 0:
                 LOGGER.info('No impact event with given ids %s found.', event_ids)
 
@@ -1616,7 +1627,8 @@ def _selected_events_idx(self, event_ids, event_names, dates, nb_events):
         if event_names is None:
             sel_na = np.array([], dtype=int)
         else:
-            sel_na = np.isin(self.event_name, event_names).nonzero()[0]
+            (sel_na,) = np.isin(self.event_name, event_names).nonzero()
+            # pylint: disable=no-member
             if sel_na.size == 0:
                 LOGGER.info('No impact event with given names %s found.', event_names)
 

From 07d12bc55bf2721eff5260e9020c8dd96f6b5c2a Mon Sep 17 00:00:00 2001
From: emanuel-schmid <schmide@ethz.ch>
Date: Wed, 18 May 2022 11:38:12 +0200
Subject: [PATCH 038/121] impact: pydoc cosmetics

---
 climada/engine/impact.py | 40 ++++++++++++++++++++--------------------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 7a69c8ce9..c9eb8026c 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -111,9 +111,9 @@ def risk_metrics_from_mat(imp_mat, freq):
 
     Returns
     -------
-    eai_exp: np.array
+    eai_exp : np.array
         expected annual impact at each exposure point
-    at_event: np.array()
+    at_event : np.array()
         total impact for each event
     aai_agg : float
         average annual impact aggregated over all exposure points
@@ -294,9 +294,9 @@ def impact_matrix(self, exp_values, cent_idx, impf):
             Exposure values
         cent_idx : np.array
             Hazard centroids assigned to each exposure location
-        hazard : Hazard
+        hazard : climada.Hazard
            Hazard object
-        impf : ImpactFunction
+        impf : climada.entity.ImpactFunc
             one impactfunction comon to all exposure elements in exp_gdf
 
         Returns
@@ -352,11 +352,11 @@ def apply_deductible_to_imp_mat(imp_mat, deductible, hazard, cent_idx, impf):
             impact matrix (events x exposure points)
         deductible : np.array()
             deductible for each exposure point
-        hazard : Hazard
+        hazard : climada.Hazard
             hazard used to compute the imp_mat
         cent_idx : np.array()
             index of centroids associated with each exposure point
-        impf : ImpactFunc
+        impf : climada.entity.ImpactFunc
             impact function associated with the exposure points
 
         Returns
@@ -387,7 +387,7 @@ def apply_cover_to_imp_mat(imp_mat, cover):
 
         Returns
         -------
-        imp_mat : scyp.sparse.csr_matrix
+        imp_mat : scipy.sparse.csr_matrix
             impact matrix with applied cover
 
         """
@@ -492,7 +492,7 @@ def from_imp_metrics(cls, at_event, eai_exp, aai_agg, exposures, impfset, hazard
 
         Returns
         -------
-        Impact
+        climada.engine.impact.Impact
             impact with all risk metrics set based on the given impact matrix
         """
         return cls(
@@ -533,7 +533,7 @@ def from_imp_mat(cls, imp_mat, exposures, impfset, hazard):
 
         Returns
         -------
-        Impact
+        climada.engine.impact.Impact
             impact with all risk metrics set based on the given impact matrix
         """
         at_event, eai_exp, aai_agg = risk_metrics_from_mat(imp_mat, hazard.frequency)
@@ -570,9 +570,9 @@ def transfer_risk(self, attachment, cover):
 
         Returns
         -------
-        transfer_at_event: np.array()
+        transfer_at_event : np.array()
             risk transfered per event
-        transfer_aai_agg: float
+        transfer_aai_agg : float
             average  annual risk transfered
         """
         transfer_at_event = np.minimum(np.maximum(self.at_event - attachment, 0), cover)
@@ -592,9 +592,9 @@ def residual_risk(self, attachment, cover):
 
         Returns
         -------
-        residual_at_event: np.array()
+        residual_at_event : np.array()
             residual risk per event
-        residual_aai_agg: float
+        residual_aai_agg : float
             average annual residual risk
 
         """
@@ -616,7 +616,7 @@ def calc_risk_transfer(self, attachment, cover):
 
         Returns
         -------
-        climada.engine.Impact
+        climada.engine.impact.Impact
         """
         new_imp = copy.deepcopy(self)
         if attachment or cover:
@@ -759,7 +759,7 @@ def plot_scatter_eai_exposure(self, mask=None, ignore_zero=True,
 
         Parameters
         ----------
-        mask  : np.array, optional
+        mask : np.array, optional
             mask to apply to eai_exp plotted.
         ignore_zero : bool, optional
             flag to indicate if zero and negative
@@ -971,7 +971,7 @@ def plot_basemap_impact_exposure(self, event_id=1, mask=None, ignore_zero=False,
         event_id : int, optional
             id of the event for which to plot the impact.
             Default: 1.
-        mask  : np.array, optional
+        mask : np.array, optional
             mask to apply to impact plotted.
         ignore_zero : bool, optional
             flag to indicate if zero and negative
@@ -1268,9 +1268,9 @@ def video_direct_impact(exp, impf_set, haz_list, file_name='',
 
         Parameters
         ----------
-        exp : Exposures
+        exp : climada.entity.Exposures
             exposures instance, constant during all video
-        impf_set : ImpactFuncSet
+        impf_set : climada.entity.ImactFuncSet
             impact functions
         haz_list : (list(Hazard))
             every Hazard contains an event; all hazards
@@ -1511,7 +1511,7 @@ def select(self,
             than start-date and <= than end-date. Dates in same format
             as impact.date (ordinal format of datetime library)
             The default is None.
-        coord_exp : np.ndarray), optional
+        coord_exp : np.ndarray, optional
             Selection of exposures coordinates [lat, lon] (in degrees)
             The default is None.
 
@@ -1523,7 +1523,7 @@ def select(self,
 
         Returns
         -------
-        imp : climada.engine.Impact
+        imp : climada.engine.impact.Impact
             A new impact object with a selection of events and/or exposures
 
         """

From ed9b0135123797097e1b5c035b5021daff8b5982 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Wed, 18 May 2022 14:44:13 +0200
Subject: [PATCH 039/121] Include all helper methods in ImpactCalc

---
 climada/engine/impact.py | 302 ++++++++++++++++++---------------------
 1 file changed, 137 insertions(+), 165 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 7a69c8ce9..c861ea5fc 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -47,83 +47,7 @@
 
 LOGGER = logging.getLogger(__name__)
 
-def eai_exp_from_mat(imp_mat, freq):
-    """
-    Compute impact for each exposures from the total impact matrix
-    Parameters
-    ----------
-    imp_mat : sparse.csr_matrix
-        matrix num_events x num_exp with impacts.
-    frequency : np.array
-        annual frequency of events
-    Returns
-    -------
-    eai_exp : np.array
-        expected annual impact for each exposure
-    """
-    n_events = freq.size
-    freq_csr = sparse.csr_matrix(
-        (freq, np.zeros(n_events), np.arange(n_events + 1)),
-        shape=(n_events, 1))
-    return imp_mat.multiply(freq_csr).sum(axis=0).A1
-
-def at_event_from_mat(imp_mat):
-    """
-    Compute impact for each hazard event from the total impact matrix
-    Parameters
-    ----------
-    imp_mat : sparse.csr_matrix
-        matrix num_events x num_exp with impacts.
-    Returns
-    -------
-    at_event : np.array
-        impact for each hazard event
-    """
-    return np.squeeze(np.asarray(np.sum(imp_mat, axis=1)))
-
-def aai_agg_from_eai_exp(eai_exp):
-    """
-    Aggregate impact.eai_exp
-
-    Parameters
-    ----------
-    eai_exp : np.array
-        expected annual impact for each exposure point
-
-    Returns
-    -------
-    float
-        average annual impact aggregated
-    """
-    return np.sum(eai_exp)
-
-def risk_metrics_from_mat(imp_mat, freq):
-    """
-    Compute risk metricss eai_exp, at_event, aai_agg
-    for an impact matrix and a frequency vector.
-
-    Parameters
-    ----------
-    imp_mat : sparse.csr_matrix
-        matrix num_events x num_exp with impacts.
-    freq : np.array
-        array with the frequency per event
-
-    Returns
-    -------
-    eai_exp: np.array
-        expected annual impact at each exposure point
-    at_event: np.array()
-        total impact for each event
-    aai_agg : float
-        average annual impact aggregated over all exposure points
-    """
-    eai_exp = eai_exp_from_mat(imp_mat, freq)
-    at_event = at_event_from_mat(imp_mat)
-    aai_agg = aai_agg_from_eai_exp(eai_exp)
-    return at_event, eai_exp, aai_agg
-
-
+#TODO put in ImpactCalc class
 class ImpactCalc():
     """
     Class to compute impacts from exposures, impact function set and hazard
@@ -132,11 +56,18 @@ class ImpactCalc():
     def __init__(self,
                  exposures,
                  impfset,
-                 hazard):
+                 hazard,
+                 imp_mat = None):
 
         self.exposures = exposures
         self.impfset = impfset
         self.hazard = hazard
+        imp_mat = sparse.csr_matrix(np.empty((0, 0))) if imp_mat is None else imp_mat
+        self.imp_mat = imp_mat
+        self.n_exp_pnt = self.exposures.gdf.shape[0]
+        self.n_events = self.hazard.size
+        self.deductible = exposures.gdf['deductible']
+        self.cover = exposures.gdf['cover']
 
     def risk(self, save_mat=True):
         """Compute impact of an hazard to exposures including risk metrics.
@@ -173,18 +104,18 @@ def risk(self, save_mat=True):
         exp_gdf = self.get_minimal_exp(impf_col)
         LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
                     exp_gdf.size, self.hazard.size)
-        imp_mat_list = self.imp_mat_gen(exp_gdf, impf_col)
-        n_exp_pnt = self.exposures.gdf.shape[0]
-        n_events = self.hazard.size
+        imp_mat_gen = self.imp_mat_gen(exp_gdf, impf_col)
         if save_mat:
-            imp_mat = self.stitch_impact_matrix(imp_mat_list, n_events, n_exp_pnt)
-            return Impact.from_imp_mat(imp_mat, self.exposures, self.impfset, self.hazard)
+            self.imp_mat = self.stitch_impact_matrix(imp_mat_gen)
+            at_event, eai_exp, aai_agg = self.risk_metrics_from_mat(
+                self.imp_mat, self.hazard.frequency
+                )
         else:
-            at_event, eai_exp, aai_agg = self.stitch_risk_metrics(imp_mat_list,
-                                                                  self.hazard.frequency,
-                                                                  n_events, n_exp_pnt)
-            return Impact.from_imp_metrics(at_event, eai_exp, aai_agg, self.exposures,
-                                           self.impfset, self.hazard)
+            at_event, eai_exp, aai_agg = self.stitch_risk_metrics(imp_mat_gen)
+        return Impact.from_eih(
+            self.exposures, self.impfset, self.hazard,
+            at_event, eai_exp, aai_agg, self.imp_mat
+            )
 
     def insured_risk(self, save_mat=False):
         """
@@ -213,33 +144,32 @@ def insured_risk(self, save_mat=False):
         exp_gdf = self.get_minimal_exp(impf_col)
         LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
                     exp_gdf.size, self.hazard.size)
-        imp_mat_list = self.imp_mat_gen(exp_gdf, impf_col)
+        imp_mat_gen = self.imp_mat_gen(exp_gdf, impf_col)
         n_exp_pnt = self.exposures.gdf.shape[0]
         n_events = self.hazard.size
 
         def insured_mat_gen(imp_mat_gen, exposures, impact_funcs, hazard, impf_col):
             for mat, exp_idx in imp_mat_gen:
                 impf_id = exposures.gdf[impf_col][exp_idx].unique()[0]
-                deductible = exposures.gdf['deductible'][exp_idx]
+                deductible = self.exposures.gdf['deductible'][exp_idx]
                 cent_idx = exposures.gdf['centr_TC'][exp_idx]
                 impf = impact_funcs.get_func(haz_type=hazard.haz_type, fun_id=impf_id)
-                mat = self.apply_deductible_to_imp_mat(mat, deductible, hazard, cent_idx, impf)
-                cover = exposures.gdf['cover'][exp_idx]
-                mat = self.apply_cover_to_imp_mat(mat, cover)
+                mat = self.apply_deductible_to_mat(mat, deductible, hazard, cent_idx, impf)
+                cover = self.exposures.gdf['cover'][exp_idx]
+                mat = self.apply_cover_to_mat(mat, cover)
                 yield (mat, exp_idx)
 
-        imp_mat_list = insured_mat_gen(imp_mat_list, self.exposures, self.impfset, self.hazard,
+        imp_mat_gen = insured_mat_gen(imp_mat_gen, self.exposures, self.impfset, self.hazard,
                                        impf_col)
         if save_mat:
-            imp_mat = self.stitch_impact_matrix(imp_mat_list, n_events, n_exp_pnt)
-            return Impact.from_imp_mat(imp_mat, self.exposures, self.impfset, self.hazard)
+            self.imp_mat = self.stitch_impact_matrix(imp_mat_gen)
+            at_event, eai_exp, aai_agg = self.risk_metrics()
         else:
-            at_event, eai_exp, aai_agg = self.stitch_risk_metrics(imp_mat_list,
-                                                                  self.hazard.frequency,
-                                                                  n_events, n_exp_pnt)
-            return Impact.from_imp_metrics(at_event, eai_exp, aai_agg, self.exposures,
-                                           self.impfset, self.hazard)
-
+            at_event, eai_exp, aai_agg = self.stitch_risk_metrics(imp_mat_gen)
+        return Impact.from_eih(
+            self.exposures, self.impfset, self.hazard,
+            at_event, eai_exp, aai_agg, self.imp_mat
+            )
 
     def get_minimal_exp(self, impf_col):
         """Get minimal exposures geodataframe for impact computation
@@ -312,32 +242,32 @@ def impact_matrix(self, exp_values, cent_idx, impf):
             shape=(1, n_centroids))
         return fract.multiply(mdr).multiply(exp_values_csr)
 
-    @staticmethod
-    def stitch_impact_matrix(imp_mat_list, n_events, n_exp_pnt):
+    def stitch_impact_matrix(self, imp_mat_gen):
         """
         Make an impact matrix from an impact matrix list
         """
         data, row, col = np.hstack([
             (mat.data, mat.nonzero()[0], idx[mat.nonzero()[1]])
-            for mat, idx in imp_mat_list
+            for mat, idx in imp_mat_gen
             ])
-        return sparse.csr_matrix((data, (row, col)), shape=(n_events, n_exp_pnt))
+        return sparse.csr_matrix(
+            (data, (row, col)), shape=(self.n_events, self.n_exp_pnt)
+            )
 
-    @staticmethod
-    def stitch_risk_metrics(imp_mat_list, freq, n_events, n_exp_pnt):
+    def stitch_risk_metrics(self, imp_mat_gen):
         """
         Compute the impact metrics from an impact matrix list
         """
-        at_event = np.zeros(n_events)
-        eai_exp = np.zeros(n_exp_pnt)
-        for imp_mat, exp_idx in imp_mat_list:
-            at_event += at_event_from_mat(imp_mat)
-            eai_exp[exp_idx] += eai_exp_from_mat(imp_mat, freq)
-        aai_agg = aai_agg_from_eai_exp(eai_exp)
+        at_event = np.zeros(self.n_events)
+        eai_exp = np.zeros(self.n_exp_pnt)
+        for sub_imp_mat, exp_idx in imp_mat_gen:
+            at_event += self.at_event_from_mat(sub_imp_mat)
+            eai_exp[exp_idx] += self.eai_exp_from_mat(sub_imp_mat, self.hazard.frequency)
+        aai_agg = self.aai_agg_from_eai_exp(eai_exp)
         return at_event, eai_exp, aai_agg
 
     @staticmethod
-    def apply_deductible_to_imp_mat(imp_mat, deductible, hazard, cent_idx, impf):
+    def apply_deductible_to_mat(mat, deductible, hazard, cent_idx, impf):
         """
         Apply a deductible per exposure point to an impact matrix at given
         centroid points for given impact function.
@@ -366,12 +296,12 @@ def apply_deductible_to_imp_mat(imp_mat, deductible, hazard, cent_idx, impf):
 
         """
         paa = hazard.get_paa(cent_idx, impf)
-        imp_mat -= paa.multiply(sparse.csr_matrix(deductible))
-        imp_mat.eliminate_zeros()
-        return imp_mat
+        mat -= paa.multiply(sparse.csr_matrix(deductible))
+        mat.eliminate_zeros()
+        return mat
 
     @staticmethod
-    def apply_cover_to_imp_mat(imp_mat, cover):
+    def apply_cover_to_mat(mat, cover):
         """
         Apply cover to impact matrix.
 
@@ -391,9 +321,89 @@ def apply_cover_to_imp_mat(imp_mat, cover):
             impact matrix with applied cover
 
         """
-        imp_mat.data = np.clip(imp_mat.data, 0, cover.to_numpy()[imp_mat.nonzero()[1]])
-        imp_mat.eliminate_zeros()
-        return imp_mat
+        mat.data = np.clip(mat.data, 0, cover.to_numpy()[mat.nonzero()[1]])
+        mat.eliminate_zeros()
+        return mat
+
+    @staticmethod
+    def eai_exp_from_mat(mat, freq):
+        """
+        Compute impact for each exposures from the total impact matrix
+        Parameters
+        ----------
+        imp_mat : sparse.csr_matrix
+            matrix num_events x num_exp with impacts.
+        frequency : np.array
+            annual frequency of events
+        Returns
+        -------
+        eai_exp : np.array
+            expected annual impact for each exposure
+        """
+        n_events = freq.size
+        freq_csr = sparse.csr_matrix(
+            (freq, np.zeros(n_events), np.arange(n_events + 1)),
+            shape=(n_events, 1))
+        return mat.multiply(freq_csr).sum(axis=0).A1
+
+    @staticmethod
+    def at_event_from_mat(mat):
+        """
+        Compute impact for each hazard event from the total impact matrix
+        Parameters
+        ----------
+        imp_mat : sparse.csr_matrix
+            matrix num_events x num_exp with impacts.
+        Returns
+        -------
+        at_event : np.array
+            impact for each hazard event
+        """
+        return np.squeeze(np.asarray(np.sum(mat, axis=1)))
+
+    @staticmethod
+    def aai_agg_from_eai_exp(eai_exp):
+        """
+        Aggregate impact.eai_exp
+
+        Parameters
+        ----------
+        eai_exp : np.array
+            expected annual impact for each exposure point
+
+        Returns
+        -------
+        float
+            average annual impact aggregated
+        """
+        return np.sum(eai_exp)
+
+
+    def risk_metrics(self):
+        """
+        Compute risk metricss eai_exp, at_event, aai_agg
+        for an impact matrix and a frequency vector.
+
+        Parameters
+        ----------
+        imp_mat : sparse.csr_matrix
+            matrix num_events x num_exp with impacts.
+        freq : np.array
+            array with the frequency per event
+
+        Returns
+        -------
+        eai_exp: np.array
+            expected annual impact at each exposure point
+        at_event: np.array()
+            total impact for each event
+        aai_agg : float
+            average annual impact aggregated over all exposure points
+        """
+        eai_exp = self.eai_exp_from_mat(self.imp_mat, self.hazard.frequency)
+        at_event = self.at_event_from_mat(self.imp_mat)
+        aai_agg = self.aai_agg_from_eai_exp(eai_exp)
+        return at_event, eai_exp, aai_agg
 
 class Impact():
     """Impact definition. Compute from an entity (exposures and impact
@@ -431,6 +441,7 @@ class Impact():
         only filled if save_mat is True in calc()
     """
 
+#TODO: change init
     def __init__(self,
                  event_id=np.array([], int),
                  event_name=None,
@@ -474,8 +485,9 @@ def calc(self, exposures, impact_funcs, hazard, save_mat=False):
             #      "Please use Impact.calc_risk() or Impact.calc_risk_insured().")
             self.__dict__ = impcalc.risk(save_mat).__dict__
 
+#TODO: new name
     @classmethod
-    def from_imp_metrics(cls, at_event, eai_exp, aai_agg, exposures, impfset, hazard):
+    def from_eih(cls, exposures, impfset, hazard, at_event, eai_exp, aai_agg, imp_mat=None):
         """
         Set Impact attributes from precalculated impact metrics.
 
@@ -495,48 +507,7 @@ def from_imp_metrics(cls, at_event, eai_exp, aai_agg, exposures, impfset, hazard
         Impact
             impact with all risk metrics set based on the given impact matrix
         """
-        return cls(
-            event_id = hazard.event_id,
-            event_name = hazard.event_name,
-            date = hazard.date,
-            frequency = hazard.frequency,
-            coord_exp = np.stack([exposures.gdf.latitude.values,
-                                  exposures.gdf.longitude.values],
-                                 axis=1),
-            crs = exposures.crs,
-            unit = exposures.value_unit,
-            tot_value = exposures.affected_total_value(hazard),
-            eai_exp = eai_exp,
-            at_event = at_event,
-            aai_agg = aai_agg,
-            tag = {'exp': exposures.tag,
-                   'impf_set': impfset.tag,
-                   'haz': hazard.tag
-                   }
-            )
-
-    @classmethod
-    def from_imp_mat(cls, imp_mat, exposures, impfset, hazard):
-        """
-        Set Impact attributes from the impact matrix.
-
-        Parameters
-        ----------
-        imp_mat : sparse.csr_matrix
-            matrix num_events x num_exp with impacts.
-        exposures : climada.entity.Exposures
-            exposure used to compute imp_mat
-        impf_set: climada.entity.ImpactFuncSet
-            impact functions set used to compute imp_mat
-        hazard : climada.Hazard
-            hazard used to compute imp_mat
-
-        Returns
-        -------
-        Impact
-            impact with all risk metrics set based on the given impact matrix
-        """
-        at_event, eai_exp, aai_agg = risk_metrics_from_mat(imp_mat, hazard.frequency)
+        imp_mat = sparse.csr_matrix(np.empty((0, 0))) if imp_mat is None else imp_mat
         return cls(
             event_id = hazard.event_id,
             event_name = hazard.event_name,
@@ -558,6 +529,7 @@ def from_imp_mat(cls, imp_mat, exposures, impfset, hazard):
                    }
             )
 
+
     def transfer_risk(self, attachment, cover):
         """Compute the risk transfer for the full portfolio
 

From a9458e31b50e9b1bd48f7b0401410d0430e028a4 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 19 May 2022 16:13:20 +0200
Subject: [PATCH 040/121] Remove unused module

---
 climada/engine/test/test_impact.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/climada/engine/test/test_impact.py b/climada/engine/test/test_impact.py
index 10b789b6d..dd9e29306 100644
--- a/climada/engine/test/test_impact.py
+++ b/climada/engine/test/test_impact.py
@@ -19,7 +19,6 @@
 Test Impact class.
 """
 import unittest
-from pathlib import Path
 import numpy as np
 from scipy import sparse
 

From 6bec23a52a49f54211280dd29e8818b93c129409 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 19 May 2022 16:13:42 +0200
Subject: [PATCH 041/121] Improve cosmetics

---
 climada/engine/impact.py | 214 ++++++++++++++++++++++-----------------
 1 file changed, 123 insertions(+), 91 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 8fc35a237..18c78c110 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -47,7 +47,6 @@
 
 LOGGER = logging.getLogger(__name__)
 
-#TODO put in ImpactCalc class
 class ImpactCalc():
     """
     Class to compute impacts from exposures, impact function set and hazard
@@ -57,59 +56,71 @@ def __init__(self,
                  exposures,
                  impfset,
                  hazard,
-                 imp_mat = None):
+                 imp_mat=None):
 
+        imp_mat = sparse.csr_matrix(np.empty((0, 0))) if imp_mat is None else imp_mat
         self.exposures = exposures
         self.impfset = impfset
         self.hazard = hazard
-        imp_mat = sparse.csr_matrix(np.empty((0, 0))) if imp_mat is None else imp_mat
         self.imp_mat = imp_mat
         self.n_exp_pnt = self.exposures.gdf.shape[0]
         self.n_events = self.hazard.size
-        self.deductible = exposures.gdf['deductible']
-        self.cover = exposures.gdf['cover']
 
-    def risk(self, save_mat=True):
-        """Compute impact of an hazard to exposures including risk metrics.
+    @property
+    def deductible(self):
+        """
+        Deductible from the exposures
+
+        Returns
+        -------
+        np.array
+            The deductible per exposure point
+
+        """
+        return self.exposures.gdf['deductible']
+
+    @property
+    def cover(self):
+        """
+        Cover from the exposures
+
+        Returns
+        -------
+        np.array
+            The cover per exposure point
+
+        """
+        return self.exposures.gdf['cover']
+
+    def impact(self, save_mat=True):
+        """Compute the impact of a hazard on exposures.
 
         Parameters
         ----------
-        exposures : climada.entity.Exposures
-            the exposures
-        impact_funcs : climada.entity.ImpactFuncSet
-            the set of impact functions
-        hazard : climada.Hazard
-            the hazard
         save_mat : bool
             if true, save the total impact matrix (events x exposures)
 
         Examples
         --------
-            Use Entity class:
-
             >>> haz = Hazard.from_mat(HAZ_DEMO_MAT)  # Set hazard
-            >>> ent = Entity.from_excel(ENT_TEMPLATE_XLS) # Set exposures
-            >>> imp = Impact.calc_risk(ent.exposures, ent.impact_funcs, haz)
-            >>> imp.calc_freq_curve().plot()
-
-            Specify only exposures and impact functions:
-
-            >>> haz = Hazard.from_mat(HAZ_DEMO_MAT)  # Set hazard
-            >>> funcs = ImpactFuncSet.from_excel(ENT_TEMPLATE_XLS) # Set impact functions
+            >>> impfset = ImpactFuncSet.from_excel(ENT_TEMPLATE_XLS) # Set impact functions
             >>> exp = Exposures(pd.read_excel(ENT_TEMPLATE_XLS)) # Set exposures
-            >>> imp = Impact.calc_risk(exp, funcs, haz)
+            >>> impcalc = ImpactCal(exp, impfset, haz)
+            >>> imp = impcalc.insured_impact()
             >>> imp.aai_agg
+
+        Note
+        ----
+        Deductible and/or cover values in the exposures are ignored.
         """
         impf_col = self.exposures.get_impf_column(self.hazard.haz_type)
-        exp_gdf = self.get_minimal_exp(impf_col)
+        exp_gdf = self.minimal_exp_gdf(impf_col)
         LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
-                    exp_gdf.size, self.hazard.size)
+                    self.n_events, self.n_events)
         imp_mat_gen = self.imp_mat_gen(exp_gdf, impf_col)
         if save_mat:
             self.imp_mat = self.stitch_impact_matrix(imp_mat_gen)
-            at_event, eai_exp, aai_agg = self.risk_metrics_from_mat(
-                self.imp_mat, self.hazard.frequency
-                )
+            at_event, eai_exp, aai_agg = self.risk_metrics()
         else:
             at_event, eai_exp, aai_agg = self.stitch_risk_metrics(imp_mat_gen)
         return Impact.from_eih(
@@ -117,61 +128,53 @@ def risk(self, save_mat=True):
             at_event, eai_exp, aai_agg, self.imp_mat
             )
 
-    def insured_risk(self, save_mat=False):
-        """
-        To be document and written more nicely.
+    def insured_impact(self, save_mat=False):
+        """Compute the impact of a hazard on exposures with a deductible and/or
+        cover.
+
+        For each exposure point, the impact per event is obtained by
+        substracting the deductible (and is maximally equal to the cover).
 
         Parameters
         ----------
-        cls : TYPE
-            DESCRIPTION.
-        exposures : TYPE
-            DESCRIPTION.
-        impact_funcs : TYPE
-            DESCRIPTION.
-        hazard : TYPE
-            DESCRIPTION.
-        save_mat : TYPE, optional
-            DESCRIPTION. The default is False.
+        save_mat : bool
+            if true, save the total impact matrix (events x exposures)
 
-        Returns
-        -------
-        TYPE
-            DESCRIPTION.
+        Examples
+        --------
+            >>> haz = Hazard.from_mat(HAZ_DEMO_MAT)  # Set hazard
+            >>> impfset = ImpactFuncSet.from_excel(ENT_TEMPLATE_XLS) # Set impact functions
+            >>> exp = Exposures(pd.read_excel(ENT_TEMPLATE_XLS)) # Set exposures
+            >>> impcalc = ImpactCal(exp, impfset, haz)
+            >>> imp = impcalc.insured_impact()
+            >>> imp.aai_agg
 
+        See also
+        --------
+        apply_deductible_to_mat:
+            apply deductible to impact matrix
+        apply_cover_to_mat:
+            apply cover to impact matrix
         """
         impf_col = self.exposures.get_impf_column(self.hazard.haz_type)
-        exp_gdf = self.get_minimal_exp(impf_col)
+        exp_gdf = self.minimal_exp_gdf(impf_col)
         LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
                     exp_gdf.size, self.hazard.size)
+
         imp_mat_gen = self.imp_mat_gen(exp_gdf, impf_col)
-        n_exp_pnt = self.exposures.gdf.shape[0]
-        n_events = self.hazard.size
-
-        def insured_mat_gen(imp_mat_gen, exposures, impact_funcs, hazard, impf_col):
-            for mat, exp_idx in imp_mat_gen:
-                impf_id = exposures.gdf[impf_col][exp_idx].unique()[0]
-                deductible = self.exposures.gdf['deductible'][exp_idx]
-                cent_idx = exposures.gdf['centr_TC'][exp_idx]
-                impf = impact_funcs.get_func(haz_type=hazard.haz_type, fun_id=impf_id)
-                mat = self.apply_deductible_to_mat(mat, deductible, hazard, cent_idx, impf)
-                cover = self.exposures.gdf['cover'][exp_idx]
-                mat = self.apply_cover_to_mat(mat, cover)
-                yield (mat, exp_idx)
-
-        imp_mat_gen = insured_mat_gen(imp_mat_gen, self.exposures, self.impfset, self.hazard,
-                                       impf_col)
+        ins_mat_gen = self.insured_mat_gen(imp_mat_gen, impf_col)
+
         if save_mat:
-            self.imp_mat = self.stitch_impact_matrix(imp_mat_gen)
+            self.imp_mat = self.stitch_impact_matrix(ins_mat_gen)
             at_event, eai_exp, aai_agg = self.risk_metrics()
         else:
-            at_event, eai_exp, aai_agg = self.stitch_risk_metrics(imp_mat_gen)
+            at_event, eai_exp, aai_agg = self.stitch_risk_metrics(ins_mat_gen)
         return Impact.from_eih(
             self.exposures, self.impfset, self.hazard,
             at_event, eai_exp, aai_agg, self.imp_mat
             )
 
-    def get_minimal_exp(self, impf_col):
+    def minimal_exp_gdf(self, impf_col):
         """Get minimal exposures geodataframe for impact computation
 
         Parameters
@@ -198,7 +201,7 @@ def get_minimal_exp(self, impf_col):
 
     def imp_mat_gen(self, exp_gdf, impf_col):
         """
-        List of impact matrices for the exposure and of corresponding exposures indices
+        Geneartor of impact sub-matrices and correspoding exposures indices
         """
         for impf_id in exp_gdf[impf_col].dropna().unique():
             impf = self.impfset.get_func(haz_type=self.hazard.haz_type, fun_id=impf_id)
@@ -213,10 +216,25 @@ def imp_mat_gen(self, exp_gdf, impf_col):
                 cent_idx = exp_gdf[self.hazard.cent_exp_col].values[exp_idx]
                 yield (self.impact_matrix(exp_values, cent_idx, impf), exp_idx)
 
+    def insured_mat_gen(self, imp_mat_gen, impf_col):
+        """
+        Generator of insured impact sub-matrices (with applied cover and deductible)
+        and corresponding exposures indices
+        """
+        for mat, exp_idx in imp_mat_gen:
+            impf_id = self.exposures.gdf[impf_col][exp_idx].unique()[0]
+            deductible = self.deductible[exp_idx]
+            cent_idx = self.exposures.gdf['centr_TC'][exp_idx]
+            impf = self.impfset.get_func(haz_type=self.hazard.haz_type, fun_id=impf_id)
+            mat = self.apply_deductible_to_mat(mat, deductible, self.hazard, cent_idx, impf)
+            cover = self.cover[exp_idx]
+            mat = self.apply_cover_to_mat(mat, cover)
+            yield (mat, exp_idx)
+
     def impact_matrix(self, exp_values, cent_idx, impf):
         """
-        Compute the impact matrix for given exposure values, assigned centroids, a hazard,
-        and one impact function.
+        Compute the impact matrix for given exposure values,
+        assigned centroids, a hazard, and one impact function.
 
         Parameters
         ----------
@@ -244,7 +262,7 @@ def impact_matrix(self, exp_values, cent_idx, impf):
 
     def stitch_impact_matrix(self, imp_mat_gen):
         """
-        Make an impact matrix from an impact matrix list
+        Make an impact matrix from an impact sub-matrix generator
         """
         data, row, col = np.hstack([
             (mat.data, mat.nonzero()[0], idx[mat.nonzero()[1]])
@@ -256,7 +274,7 @@ def stitch_impact_matrix(self, imp_mat_gen):
 
     def stitch_risk_metrics(self, imp_mat_gen):
         """
-        Compute the impact metrics from an impact matrix list
+        Compute the impact metrics from an impact sub-matrix generator
         """
         at_event = np.zeros(self.n_events)
         eai_exp = np.zeros(self.n_exp_pnt)
@@ -329,6 +347,7 @@ def apply_cover_to_mat(mat, cover):
     def eai_exp_from_mat(mat, freq):
         """
         Compute impact for each exposures from the total impact matrix
+
         Parameters
         ----------
         imp_mat : sparse.csr_matrix
@@ -441,35 +460,34 @@ class Impact():
         only filled if save_mat is True in calc()
     """
 
-#TODO: change init
     def __init__(self,
-                 event_id=np.array([], int),
+                 event_id=None,
                  event_name=None,
-                 date=np.array([], int),
-                 frequency=np.array([],float),
-                 coord_exp=np.ndarray([], float),
+                 date=None,
+                 frequency=None,
+                 coord_exp=None,
                  crs=DEF_CRS,
-                 eai_exp=np.array([], float),
-                 at_event=np.array([], float),
+                 eai_exp=None,
+                 at_event=None,
                  tot_value=0,
                  aai_agg=0,
                  unit='',
-                 imp_mat=sparse.csr_matrix(np.empty((0, 0))),
+                 imp_mat=None,
                  tag=None):
 
         self.tag = tag or {}
-        self.event_id = event_id
+        self.event_id = np.array([], int) if event_id is None else event_id
         self.event_name = event_name or []
-        self.date = date
-        self.coord_exp = coord_exp
+        self.date = np.array([], int) if date is None else date
+        self.coord_exp = np.ndarray([], float) if coord_exp is None else coord_exp
         self.crs = crs
-        self.eai_exp = eai_exp
-        self.at_event = at_event
-        self.frequency = frequency
+        self.eai_exp = np.array([], float) if eai_exp is None else eai_exp
+        self.at_event = np.array([], float) if at_event is None else at_event
+        self.frequency = np.array([],float) if frequency is None else frequency
         self.tot_value = tot_value
         self.aai_agg = aai_agg
         self.unit = unit
-        self.imp_mat = imp_mat
+        self.imp_mat = sparse.csr_matrix(np.empty((0, 0))) if imp_mat is None else imp_mat
 
     def calc(self, exposures, impact_funcs, hazard, save_mat=False):
         """This function is deprecated, use Impact.calc_risk and Impact.calc_insured_risk instead.
@@ -479,15 +497,16 @@ def calc(self, exposures, impact_funcs, hazard, save_mat=False):
             and exposures.gdf.cover.max():
             # LOGGER.warning("To compute the risk transfer value"
             #      "please use Impact.calc_insured_risk")
-            self.__dict__ = impcalc.insured_risk(save_mat).__dict__
+            self.__dict__ = impcalc.insured_impact(save_mat).__dict__
         else:
             # LOGGER.warning("The use of Impact.calc() is deprecated."
             #      "Please use Impact.calc_risk() or Impact.calc_risk_insured().")
-            self.__dict__ = impcalc.risk(save_mat).__dict__
+            self.__dict__ = impcalc.impact(save_mat).__dict__
 
 #TODO: new name
     @classmethod
-    def from_eih(cls, exposures, impfset, hazard, at_event, eai_exp, aai_agg, imp_mat=None):
+    def from_eih(cls, exposures, impfset, hazard,
+                 at_event, eai_exp, aai_agg, imp_mat=None):
         """
         Set Impact attributes from precalculated impact metrics.
 
@@ -531,7 +550,11 @@ def from_eih(cls, exposures, impfset, hazard, at_event, eai_exp, aai_agg, imp_ma
 
 
     def transfer_risk(self, attachment, cover):
-        """Compute the risk transfer for the full portfolio
+        """Compute the risk transfer for the full portfolio. This is the risk
+        of the full portfolio summed over all events. For each
+        event, the transfered risk amounts to the impact minus the attachment
+        (but maximally equal to the cover) multiplied with the probability
+        of the event.
 
         Parameters
         ----------
@@ -553,7 +576,11 @@ def transfer_risk(self, attachment, cover):
 
     def residual_risk(self, attachment, cover):
         """Compute the residual risk after application of insurance
-        attachment and cover to entire portfolio.
+        attachment and cover to entire portfolio. This is the residual risk
+        of the full portfolio summed over all events. For each
+        event, the residual risk is obtained by subtracting the transfered risk
+        from the trom the total risk per event.
+        of the event.
 
         Parameters
         ----------
@@ -569,12 +596,17 @@ def residual_risk(self, attachment, cover):
         residual_aai_agg : float
             average annual residual risk
 
+        See also
+        --------
+        transfer_risk: compute the transfer risk per portfolio.
+
         """
         transfer_at_event, _ = self.transfer_risk(attachment, cover)
         residual_at_event = np.maximum(self.at_event - transfer_at_event, 0)
         residual_aai_agg = np.sum(residual_at_event * self.frequency)
         return residual_at_event, residual_aai_agg
 
+#TODO deprecate method
     def calc_risk_transfer(self, attachment, cover):
         """Compute traaditional risk transfer over impact. Returns new impact
         with risk transfer applied and the insurance layer resulting

From 6abd90297c5d0c8f74fb408a987e1c3603ea5689 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 19 May 2022 17:15:29 +0200
Subject: [PATCH 042/121] Improve docstring

---
 climada/engine/impact.py | 27 +++++++++++++++++++++++++--
 1 file changed, 25 insertions(+), 2 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 18c78c110..eded99b55 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -57,6 +57,29 @@ def __init__(self,
                  impfset,
                  hazard,
                  imp_mat=None):
+        """
+        Initialize an ImpactCalc object.
+
+        The dimension of the imp_mat variable must be compatible with the
+        exposures and hazard objects.
+
+        Parameters
+        ----------
+        exposures : climada.entity.Exposures
+            exposure used to compute imp_mat
+        impf_set: climada.entity.ImpactFuncSet
+            impact functions set used to compute imp_mat
+        hazard : climada.Hazard
+            hazard used to compute imp_mat
+        imp_mat : sparse.csr_matrix, optional
+            matrix num_events x num_exp with impacts.
+            Default is an empty matrix.
+
+        Returns
+        -------
+        None.
+
+        """
 
         imp_mat = sparse.csr_matrix(np.empty((0, 0))) if imp_mat is None else imp_mat
         self.exposures = exposures
@@ -512,14 +535,14 @@ def from_eih(cls, exposures, impfset, hazard,
 
         Parameters
         ----------
-        imp_mat : sparse.csr_matrix
-            matrix num_events x num_exp with impacts.
         exposures : climada.entity.Exposures
             exposure used to compute imp_mat
         impf_set: climada.entity.ImpactFuncSet
             impact functions set used to compute imp_mat
         hazard : climada.Hazard
             hazard used to compute imp_mat
+        imp_mat : sparse.csr_matrix
+            matrix num_events x num_exp with impacts.
 
         Returns
         -------

From 6c69ce60bbc16e55fa23ba4441a370c591845f4a Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 2 Jun 2022 15:23:33 +0200
Subject: [PATCH 043/121] Import new class in init

---
 climada/engine/impact.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index eded99b55..97ed22ac3 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -19,7 +19,7 @@
 Define Impact and ImpactFreqCurve classes.
 """
 
-__all__ = ['ImpactFreqCurve', 'Impact']
+__all__ = ['ImpactFreqCurve', 'Impact', 'ImpactCalc']
 
 import logging
 import copy

From 414b369c8004761978f1af00ef46de3872a51925 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 2 Jun 2022 16:28:07 +0200
Subject: [PATCH 044/121] Compute insured impact from existing imp_mat if
 available

---
 climada/engine/impact.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 97ed22ac3..99573a115 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -184,9 +184,13 @@ def insured_impact(self, save_mat=False):
         LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
                     exp_gdf.size, self.hazard.size)
 
-        imp_mat_gen = self.imp_mat_gen(exp_gdf, impf_col)
+        if self.imp_mat.size == 0:
+            imp_mat_gen = self.imp_mat_gen(exp_gdf, impf_col)
+        else:
+            imp_mat_gen = ((self.imp_mat, self.exposures.gdf.index.values) for n in range(1))
         ins_mat_gen = self.insured_mat_gen(imp_mat_gen, impf_col)
 
+
         if save_mat:
             self.imp_mat = self.stitch_impact_matrix(ins_mat_gen)
             at_event, eai_exp, aai_agg = self.risk_metrics()

From 8790eb4cb8be6382b2c9f0f06ef25b0ba4142e8f Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Wed, 8 Jun 2022 14:00:42 +0200
Subject: [PATCH 045/121] Make two test files

---
 climada/engine/test/test_impact.py      | 220 ++++++++++--------------
 climada/engine/test/test_impact_calc.py | 181 +++++++++++++++++++
 2 files changed, 270 insertions(+), 131 deletions(-)
 create mode 100644 climada/engine/test/test_impact_calc.py

diff --git a/climada/engine/test/test_impact.py b/climada/engine/test/test_impact.py
index dd9e29306..3a9ac72fd 100644
--- a/climada/engine/test/test_impact.py
+++ b/climada/engine/test/test_impact.py
@@ -26,7 +26,7 @@
 from climada.hazard.tag import Tag as TagHaz
 from climada.entity.entity_def import Entity
 from climada.hazard.base import Hazard
-from climada.engine.impact import Impact
+from climada.engine.impact import Impact, ImpactCalc
 from climada.util.constants import ENT_DEMO_TODAY, DEF_CRS, DEMO_DIR
 from climada.util.api_client import Client
 import climada.util.coordinates as u_coord
@@ -45,139 +45,20 @@ def get_haz_test_file(ds_name):
 
 HAZ_TEST_MAT = get_haz_test_file('atl_prob_no_name')
 
+ENT = Entity.from_excel(ENT_DEMO_TODAY)
+HAZ = Hazard.from_mat(HAZ_TEST_MAT)
+
 DATA_FOLDER = DEMO_DIR / 'test-results'
 DATA_FOLDER.mkdir(exist_ok=True)
 
 
-class TestFreqCurve(unittest.TestCase):
-    """Test exceedence frequency curve computation"""
-    def test_ref_value_pass(self):
-        """Test result against reference value"""
-        imp = Impact()
-        imp.frequency = np.ones(10) * 6.211180124223603e-04
-        imp.at_event = np.zeros(10)
-        imp.at_event[0] = 0
-        imp.at_event[1] = 0.400665463736549e9
-        imp.at_event[2] = 3.150330960044466e9
-        imp.at_event[3] = 3.715826406781887e9
-        imp.at_event[4] = 2.900244271902339e9
-        imp.at_event[5] = 0.778570745161971e9
-        imp.at_event[6] = 0.698736262566472e9
-        imp.at_event[7] = 0.381063674256423e9
-        imp.at_event[8] = 0.569142464157450e9
-        imp.at_event[9] = 0.467572545849132e9
-        imp.unit = 'USD'
-
-        ifc = imp.calc_freq_curve()
-        self.assertEqual(10, len(ifc.return_per))
-        self.assertEqual(1610.0000000000000, ifc.return_per[9])
-        self.assertEqual(805.00000000000000, ifc.return_per[8])
-        self.assertEqual(536.66666666666663, ifc.return_per[7])
-        self.assertEqual(402.500000000000, ifc.return_per[6])
-        self.assertEqual(322.000000000000, ifc.return_per[5])
-        self.assertEqual(268.33333333333331, ifc.return_per[4])
-        self.assertEqual(230.000000000000, ifc.return_per[3])
-        self.assertEqual(201.250000000000, ifc.return_per[2])
-        self.assertEqual(178.88888888888889, ifc.return_per[1])
-        self.assertEqual(161.000000000000, ifc.return_per[0])
-        self.assertEqual(10, len(ifc.impact))
-        self.assertEqual(3.715826406781887e9, ifc.impact[9])
-        self.assertEqual(3.150330960044466e9, ifc.impact[8])
-        self.assertEqual(2.900244271902339e9, ifc.impact[7])
-        self.assertEqual(0.778570745161971e9, ifc.impact[6])
-        self.assertEqual(0.698736262566472e9, ifc.impact[5])
-        self.assertEqual(0.569142464157450e9, ifc.impact[4])
-        self.assertEqual(0.467572545849132e9, ifc.impact[3])
-        self.assertEqual(0.400665463736549e9, ifc.impact[2])
-        self.assertEqual(0.381063674256423e9, ifc.impact[1])
-        self.assertEqual(0, ifc.impact[0])
-        self.assertEqual('Exceedance frequency curve', ifc.label)
-        self.assertEqual('USD', ifc.unit)
-
-    def test_ref_value_rp_pass(self):
-        """Test result against reference value with given return periods"""
-        imp = Impact()
-        imp.frequency = np.ones(10) * 6.211180124223603e-04
-        imp.at_event = np.zeros(10)
-        imp.at_event[0] = 0
-        imp.at_event[1] = 0.400665463736549e9
-        imp.at_event[2] = 3.150330960044466e9
-        imp.at_event[3] = 3.715826406781887e9
-        imp.at_event[4] = 2.900244271902339e9
-        imp.at_event[5] = 0.778570745161971e9
-        imp.at_event[6] = 0.698736262566472e9
-        imp.at_event[7] = 0.381063674256423e9
-        imp.at_event[8] = 0.569142464157450e9
-        imp.at_event[9] = 0.467572545849132e9
-        imp.unit = 'USD'
-
-        ifc = imp.calc_freq_curve(np.array([100, 500, 1000]))
-        self.assertEqual(3, len(ifc.return_per))
-        self.assertEqual(100, ifc.return_per[0])
-        self.assertEqual(500, ifc.return_per[1])
-        self.assertEqual(1000, ifc.return_per[2])
-        self.assertEqual(3, len(ifc.impact))
-        self.assertEqual(0, ifc.impact[0])
-        self.assertEqual(2320408028.5695677, ifc.impact[1])
-        self.assertEqual(3287314329.129928, ifc.impact[2])
-        self.assertEqual('Exceedance frequency curve', ifc.label)
-        self.assertEqual('USD', ifc.unit)
-
-class TestOneExposure(unittest.TestCase):
-    """Test one_exposure function"""
-    def test_ref_value_insure_pass(self):
-        """Test result against reference value"""
-        # Read demo entity values
-        # Set the entity default file to the demo one
-        ent = Entity.from_excel(ENT_DEMO_TODAY)
-        ent.check()
-
-        # Read default hazard file
-        hazard = Hazard.from_mat(HAZ_TEST_MAT)
-
-        # Create impact object
-        impact = Impact()
-        impact.at_event = np.zeros(hazard.intensity.shape[0])
-        impact.eai_exp = np.zeros(len(ent.exposures.gdf.value))
-        impact.tot_value = 0
-
-        # Assign centroids to exposures
-        ent.exposures.assign_centroids(hazard)
-
-        # Compute impact for 6th exposure
-        iexp = 5
-        # Take its impact function
-        imp_id = ent.exposures.gdf.impf_TC[iexp]
-        imp_fun = ent.impact_funcs.get_func(hazard.tag.haz_type, imp_id)
-        # Compute
-        insure_flag = True
-        impact._exp_impact(np.array([iexp]), ent.exposures, hazard, imp_fun, insure_flag)
-
-        self.assertEqual(impact.eai_exp.size, ent.exposures.gdf.shape[0])
-        self.assertEqual(impact.at_event.size, hazard.intensity.shape[0])
-
-        events_pos = hazard.intensity[:, ent.exposures.gdf.centr_TC[iexp]].nonzero()[0]
-        res_exp = np.zeros((ent.exposures.gdf.shape[0]))
-        res_exp[iexp] = np.sum(impact.at_event[events_pos] * hazard.frequency[events_pos])
-        np.testing.assert_array_equal(res_exp, impact.eai_exp)
-
-        self.assertEqual(0, impact.at_event[12])
-        # Check first 3 values
-        self.assertEqual(0, impact.at_event[12])
-        self.assertEqual(0, impact.at_event[41])
-        self.assertEqual(1.0626600695059455e+06, impact.at_event[44])
-
-        # Check intermediate values
-        self.assertEqual(0, impact.at_event[6281])
-        self.assertEqual(0, impact.at_event[4998])
-        self.assertEqual(0, impact.at_event[9527])
-        self.assertEqual(1.3318063850487845e+08, impact.at_event[7192])
-        self.assertEqual(4.667108555054083e+06, impact.at_event[8624])
-
-        # Check last 3 values
-        self.assertEqual(0, impact.at_event[14349])
-        self.assertEqual(0, impact.at_event[14347])
-        self.assertEqual(0, impact.at_event[14309])
+class TestImpactCalc(unittest.TestCase):
+    """Test Impact calc methods"""
+    def test_init(self):
+        icalc = ImpactCalc(ENT.exposures, ENT.impact_funcs, HAZ)
+        self.assertEqual(icalc.n_exp_pnt, ENT.exposures.gdf.shape[0])
+        self.assertEqual(icalc.n_events, HAZ.size)
+        np.testing.assert_array_equal(icalc.deductible, ENT.exposures.gdf.deductible)
 
 class TestCalc(unittest.TestCase):
     """Test impact calc method."""
@@ -289,6 +170,81 @@ def test_calc_impf_pass(self):
         self.assertAlmostEqual(6.512201157564421e+09, impact.aai_agg, 5)
         self.assertAlmostEqual(6.512201157564421e+09, impact.aai_agg, 5)
 
+
+class TestFreqCurve(unittest.TestCase):
+    """Test exceedence frequency curve computation"""
+    def test_ref_value_pass(self):
+        """Test result against reference value"""
+        imp = Impact()
+        imp.frequency = np.ones(10) * 6.211180124223603e-04
+        imp.at_event = np.zeros(10)
+        imp.at_event[0] = 0
+        imp.at_event[1] = 0.400665463736549e9
+        imp.at_event[2] = 3.150330960044466e9
+        imp.at_event[3] = 3.715826406781887e9
+        imp.at_event[4] = 2.900244271902339e9
+        imp.at_event[5] = 0.778570745161971e9
+        imp.at_event[6] = 0.698736262566472e9
+        imp.at_event[7] = 0.381063674256423e9
+        imp.at_event[8] = 0.569142464157450e9
+        imp.at_event[9] = 0.467572545849132e9
+        imp.unit = 'USD'
+
+        ifc = imp.calc_freq_curve()
+        self.assertEqual(10, len(ifc.return_per))
+        self.assertEqual(1610.0000000000000, ifc.return_per[9])
+        self.assertEqual(805.00000000000000, ifc.return_per[8])
+        self.assertEqual(536.66666666666663, ifc.return_per[7])
+        self.assertEqual(402.500000000000, ifc.return_per[6])
+        self.assertEqual(322.000000000000, ifc.return_per[5])
+        self.assertEqual(268.33333333333331, ifc.return_per[4])
+        self.assertEqual(230.000000000000, ifc.return_per[3])
+        self.assertEqual(201.250000000000, ifc.return_per[2])
+        self.assertEqual(178.88888888888889, ifc.return_per[1])
+        self.assertEqual(161.000000000000, ifc.return_per[0])
+        self.assertEqual(10, len(ifc.impact))
+        self.assertEqual(3.715826406781887e9, ifc.impact[9])
+        self.assertEqual(3.150330960044466e9, ifc.impact[8])
+        self.assertEqual(2.900244271902339e9, ifc.impact[7])
+        self.assertEqual(0.778570745161971e9, ifc.impact[6])
+        self.assertEqual(0.698736262566472e9, ifc.impact[5])
+        self.assertEqual(0.569142464157450e9, ifc.impact[4])
+        self.assertEqual(0.467572545849132e9, ifc.impact[3])
+        self.assertEqual(0.400665463736549e9, ifc.impact[2])
+        self.assertEqual(0.381063674256423e9, ifc.impact[1])
+        self.assertEqual(0, ifc.impact[0])
+        self.assertEqual('Exceedance frequency curve', ifc.label)
+        self.assertEqual('USD', ifc.unit)
+
+    def test_ref_value_rp_pass(self):
+        """Test result against reference value with given return periods"""
+        imp = Impact()
+        imp.frequency = np.ones(10) * 6.211180124223603e-04
+        imp.at_event = np.zeros(10)
+        imp.at_event[0] = 0
+        imp.at_event[1] = 0.400665463736549e9
+        imp.at_event[2] = 3.150330960044466e9
+        imp.at_event[3] = 3.715826406781887e9
+        imp.at_event[4] = 2.900244271902339e9
+        imp.at_event[5] = 0.778570745161971e9
+        imp.at_event[6] = 0.698736262566472e9
+        imp.at_event[7] = 0.381063674256423e9
+        imp.at_event[8] = 0.569142464157450e9
+        imp.at_event[9] = 0.467572545849132e9
+        imp.unit = 'USD'
+
+        ifc = imp.calc_freq_curve(np.array([100, 500, 1000]))
+        self.assertEqual(3, len(ifc.return_per))
+        self.assertEqual(100, ifc.return_per[0])
+        self.assertEqual(500, ifc.return_per[1])
+        self.assertEqual(1000, ifc.return_per[2])
+        self.assertEqual(3, len(ifc.impact))
+        self.assertEqual(0, ifc.impact[0])
+        self.assertEqual(2320408028.5695677, ifc.impact[1])
+        self.assertEqual(3287314329.129928, ifc.impact[2])
+        self.assertEqual('Exceedance frequency curve', ifc.label)
+        self.assertEqual('USD', ifc.unit)
+
 class TestImpactYearSet(unittest.TestCase):
     """Test calc_impact_year_set method"""
 
@@ -783,6 +739,7 @@ def test_select_imp_map_fail(self):
         with self.assertRaises(ValueError):
             imp.select(event_ids=[0], event_names=[1, 'two'], dates=(0, 2))
 
+class TestConvertExp(unittest.TestCase):
     def test__build_exp(self):
         """Test that an impact set can be converted to an exposure"""
 
@@ -811,7 +768,7 @@ def test__exp_build_event(self):
 
 # Execute Tests
 if __name__ == "__main__":
-    TESTS = unittest.TestLoader().loadTestsFromTestCase(TestOneExposure)
+    TESTS = unittest.TestLoader().loadTestsFromTestCase(TestImpactCalc)
     TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestCalc))
     TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestFreqCurve))
     TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestImpactYearSet))
@@ -819,4 +776,5 @@ def test__exp_build_event(self):
     TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestRPmatrix))
     TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestRiskTrans))
     TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestSelect))
+    TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestConvertExp))
     unittest.TextTestRunner(verbosity=2).run(TESTS)
diff --git a/climada/engine/test/test_impact_calc.py b/climada/engine/test/test_impact_calc.py
new file mode 100644
index 000000000..7b19a3541
--- /dev/null
+++ b/climada/engine/test/test_impact_calc.py
@@ -0,0 +1,181 @@
+"""
+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/>.
+
+---
+
+Test Impact class.
+"""
+import unittest
+import numpy as np
+from scipy import sparse
+
+from climada.entity.entity_def import Entity
+from climada.hazard.base import Hazard
+from climada.engine.impact import Impact, ImpactCalc
+from climada.util.constants import ENT_DEMO_TODAY, DEF_CRS, DEMO_DIR
+from climada.util.api_client import Client
+import climada.engine.test as engine_test
+
+
+def get_haz_test_file(ds_name):
+    # As this module is part of the installation test suite, we want tom make sure it is running
+    # also in offline mode even when installing from pypi, where there is no test configuration.
+    # So we set cache_enabled explicitly to true
+    client = Client(cache_enabled=True)
+    test_ds = client.get_dataset_info(name=ds_name, status='test_dataset')
+    _, [haz_test_file] = client.download_dataset(test_ds)
+    return haz_test_file
+
+
+HAZ_TEST_MAT = get_haz_test_file('atl_prob_no_name')
+
+ENT = Entity.from_excel(ENT_DEMO_TODAY)
+HAZ = Hazard.from_mat(HAZ_TEST_MAT)
+
+DATA_FOLDER = DEMO_DIR / 'test-results'
+DATA_FOLDER.mkdir(exist_ok=True)
+
+
+class TestImpactCalc(unittest.TestCase):
+    """Test Impact calc methods"""
+    def test_init(self):
+        icalc = ImpactCalc(ENT.exposures, ENT.impact_funcs, HAZ)
+        self.assertEqual(icalc.n_exp_pnt, ENT.exposures.gdf.shape[0])
+        self.assertEqual(icalc.n_events, HAZ.size)
+        np.testing.assert_array_equal(icalc.deductible, ENT.exposures.gdf.deductible)
+        np.testing.assert_array_equal(icalc.cover, ENT.exposures.gdf.cover)
+        self.assertEqual(icalc.imp_mat.size, 0)
+        self.assertTrue(ENT.exposures.gdf.equals(icalc.exposures.gdf))
+        self.assertEqual(HAZ.event_id, icalc.hazard.event_id)
+        self.assertEqual(HAZ.event_name, icalc.hazard.event_name)
+
+class TestCalc(unittest.TestCase):
+    """Test impact calc method."""
+
+    def test_ref_value_pass(self):
+        """Test result against reference value"""
+        # Read default entity values
+        ent = Entity.from_excel(ENT_DEMO_TODAY)
+        ent.check()
+
+        # Read default hazard file
+        hazard = Hazard.from_mat(HAZ_TEST_MAT)
+
+        # Create impact object
+        impact = Impact()
+
+        # Assign centroids to exposures
+        ent.exposures.assign_centroids(hazard)
+
+        # Compute the impact over the whole exposures
+        impact.calc(ent.exposures, ent.impact_funcs, hazard)
+
+        # Check result
+        num_events = len(hazard.event_id)
+        num_exp = ent.exposures.gdf.shape[0]
+        # Check relative errors as well when absolute value gt 1.0e-7
+        # impact.at_event == EDS.damage in MATLAB
+        self.assertEqual(num_events, len(impact.at_event))
+        self.assertEqual(0, impact.at_event[0])
+        self.assertEqual(0, impact.at_event[int(num_events / 2)])
+        self.assertAlmostEqual(1.472482938320243e+08, impact.at_event[13809])
+        self.assertAlmostEqual(7.076504723057620e+10, impact.at_event[12147])
+        self.assertEqual(0, impact.at_event[num_events - 1])
+        # impact.eai_exp == EDS.ED_at_centroid in MATLAB
+        self.assertEqual(num_exp, len(impact.eai_exp))
+        self.assertAlmostEqual(1.518553670803242e+08, impact.eai_exp[0])
+        self.assertAlmostEqual(1.373490457046383e+08, impact.eai_exp[int(num_exp / 2)], 6)
+        self.assertAlmostEqual(1.373490457046383e+08, impact.eai_exp[int(num_exp / 2)], 5)
+        self.assertAlmostEqual(1.066837260150042e+08, impact.eai_exp[num_exp - 1], 6)
+        self.assertAlmostEqual(1.066837260150042e+08, impact.eai_exp[int(num_exp - 1)], 5)
+        # impact.tot_value == EDS.Value in MATLAB
+        # impact.aai_agg == EDS.ED in MATLAB
+        self.assertAlmostEqual(6.570532945599105e+11, impact.tot_value)
+        self.assertAlmostEqual(6.512201157564421e+09, impact.aai_agg, 5)
+        self.assertAlmostEqual(6.512201157564421e+09, impact.aai_agg, 5)
+
+    def test_calc_imp_mat_pass(self):
+        """Test save imp_mat"""
+        # Read default entity values
+        ent = Entity.from_excel(ENT_DEMO_TODAY)
+        ent.check()
+
+        # Read default hazard file
+        hazard = Hazard.from_mat(HAZ_TEST_MAT)
+
+        # Create impact object
+        impact = Impact()
+
+        # Assign centroids to exposures
+        ent.exposures.assign_centroids(hazard)
+
+        # Compute the impact over the whole exposures
+        impact.calc(ent.exposures, ent.impact_funcs, hazard, save_mat=True)
+        self.assertIsInstance(impact.imp_mat, sparse.csr_matrix)
+        self.assertEqual(impact.imp_mat.shape, (hazard.event_id.size,
+                                                ent.exposures.gdf.value.size))
+        np.testing.assert_array_almost_equal_nulp(
+            np.array(impact.imp_mat.sum(axis=1)).ravel(), impact.at_event, nulp=5)
+        np.testing.assert_array_almost_equal_nulp(
+            np.sum(impact.imp_mat.toarray() * impact.frequency[:, None], axis=0).reshape(-1),
+            impact.eai_exp)
+
+    def test_calc_impf_pass(self):
+        """Execute when no impf_HAZ present, but only impf_"""
+        ent = Entity.from_excel(ENT_DEMO_TODAY)
+        self.assertTrue('impf_TC' in ent.exposures.gdf.columns)
+        ent.exposures.gdf.rename(columns={'impf_TC': 'impf_'}, inplace=True)
+        self.assertFalse('impf_TC' in ent.exposures.gdf.columns)
+        ent.check()
+
+        # Read default hazard file
+        hazard = Hazard.from_mat(HAZ_TEST_MAT)
+
+        # Create impact object
+        impact = Impact()
+        impact.calc(ent.exposures, ent.impact_funcs, hazard)
+
+        # Check result
+        num_events = len(hazard.event_id)
+        num_exp = ent.exposures.gdf.shape[0]
+        # Check relative errors as well when absolute value gt 1.0e-7
+        # impact.at_event == EDS.damage in MATLAB
+        self.assertEqual(num_events, len(impact.at_event))
+        self.assertEqual(0, impact.at_event[0])
+        self.assertEqual(0, impact.at_event[int(num_events / 2)])
+        self.assertAlmostEqual(1.472482938320243e+08, impact.at_event[13809])
+        self.assertEqual(7.076504723057620e+10, impact.at_event[12147])
+        self.assertEqual(0, impact.at_event[num_events - 1])
+        # impact.eai_exp == EDS.ED_at_centroid in MATLAB
+        self.assertEqual(num_exp, len(impact.eai_exp))
+        self.assertAlmostEqual(1.518553670803242e+08, impact.eai_exp[0])
+        self.assertAlmostEqual(1.373490457046383e+08, impact.eai_exp[int(num_exp / 2)], 6)
+        self.assertAlmostEqual(1.373490457046383e+08, impact.eai_exp[int(num_exp / 2)], 5)
+        self.assertAlmostEqual(1.066837260150042e+08, impact.eai_exp[num_exp - 1], 6)
+        self.assertAlmostEqual(1.066837260150042e+08, impact.eai_exp[int(num_exp - 1)], 5)
+        # impact.tot_value == EDS.Value in MATLAB
+        # impact.aai_agg == EDS.ED in MATLAB
+        self.assertAlmostEqual(6.570532945599105e+11, impact.tot_value)
+        self.assertAlmostEqual(6.512201157564421e+09, impact.aai_agg, 5)
+        self.assertAlmostEqual(6.512201157564421e+09, impact.aai_agg, 5)
+
+
+
+# Execute Tests
+if __name__ == "__main__":
+    TESTS = unittest.TestLoader().loadTestsFromTestCase(TestImpactCalc)
+    TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestCalc))
+    unittest.TextTestRunner(verbosity=2).run(TESTS)

From 82460c4fe379dc87aa689e8b7b8ca6fca70e4a7d Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 9 Jun 2022 16:07:35 +0200
Subject: [PATCH 046/121] Add _return_impact method

---
 climada/engine/impact.py | 38 +++++++++++++++++++++++++++-----------
 1 file changed, 27 insertions(+), 11 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 99573a115..5ac9b9974 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -141,16 +141,10 @@ def impact(self, save_mat=True):
         LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
                     self.n_events, self.n_events)
         imp_mat_gen = self.imp_mat_gen(exp_gdf, impf_col)
-        if save_mat:
-            self.imp_mat = self.stitch_impact_matrix(imp_mat_gen)
-            at_event, eai_exp, aai_agg = self.risk_metrics()
-        else:
-            at_event, eai_exp, aai_agg = self.stitch_risk_metrics(imp_mat_gen)
-        return Impact.from_eih(
-            self.exposures, self.impfset, self.hazard,
-            at_event, eai_exp, aai_agg, self.imp_mat
-            )
+        self._return_impact(imp_mat_gen, save_mat)
 
+#TODO: make a better impact matrix generator for insured impacts when
+# the impact matrix is already present
     def insured_impact(self, save_mat=False):
         """Compute the impact of a hazard on exposures with a deductible and/or
         cover.
@@ -189,13 +183,34 @@ def insured_impact(self, save_mat=False):
         else:
             imp_mat_gen = ((self.imp_mat, self.exposures.gdf.index.values) for n in range(1))
         ins_mat_gen = self.insured_mat_gen(imp_mat_gen, impf_col)
+        self._return_impact(ins_mat_gen, save_mat)
+
+    def _return_impact(self, imp_mat_gen, save_mat):
+        """Return an impact object from an impact matrix generator
 
+        Parameters
+        ----------
+        imp_mat_gen : generator
+            Generator of impact matrix and corresponding exposures index
+        save_mat : boolean
+            if true, save the impact matrix
+
+        Returns
+        -------
+        Impact
+            Impact Object initialize from the impact matrix
 
+        See Also
+        --------
+        imp_mat_gen: impact matrix generator
+        insured_mat_gen: insured impact matrix generator
+
+        """
         if save_mat:
-            self.imp_mat = self.stitch_impact_matrix(ins_mat_gen)
+            self.imp_mat = self.stitch_impact_matrix(imp_mat_gen)
             at_event, eai_exp, aai_agg = self.risk_metrics()
         else:
-            at_event, eai_exp, aai_agg = self.stitch_risk_metrics(ins_mat_gen)
+            at_event, eai_exp, aai_agg = self.stitch_risk_metrics(imp_mat_gen)
         return Impact.from_eih(
             self.exposures, self.impfset, self.hazard,
             at_event, eai_exp, aai_agg, self.imp_mat
@@ -714,6 +729,7 @@ def calc_impact_year_set(self,all_years=True, year_range=None):
                        "Use Impact.impact_per_year instead.")
         return self.impact_per_year(all_years=all_years, year_range=year_range)
 
+#TODO: improve method
     def local_exceedance_imp(self, return_periods=(25, 50, 100, 250)):
         """Compute exceedance impact map for given return periods.
         Requires attribute imp_mat.

From 057e719872b83ccb5b4c883c2191fff4dc69bb11 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 9 Jun 2022 16:12:32 +0200
Subject: [PATCH 047/121] Return impact object

---
 climada/engine/impact.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 5ac9b9974..93e44c3c6 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -183,7 +183,7 @@ def insured_impact(self, save_mat=False):
         else:
             imp_mat_gen = ((self.imp_mat, self.exposures.gdf.index.values) for n in range(1))
         ins_mat_gen = self.insured_mat_gen(imp_mat_gen, impf_col)
-        self._return_impact(ins_mat_gen, save_mat)
+        return self._return_impact(ins_mat_gen, save_mat)
 
     def _return_impact(self, imp_mat_gen, save_mat):
         """Return an impact object from an impact matrix generator

From e2719254131cabe0f0893e4576e6d3a957c70abf Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 9 Jun 2022 16:16:12 +0200
Subject: [PATCH 048/121] Make risk_metrics a class method

---
 climada/engine/impact.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 93e44c3c6..712888d7c 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -208,7 +208,7 @@ def _return_impact(self, imp_mat_gen, save_mat):
         """
         if save_mat:
             self.imp_mat = self.stitch_impact_matrix(imp_mat_gen)
-            at_event, eai_exp, aai_agg = self.risk_metrics()
+            at_event, eai_exp, aai_agg = self.risk_metrics(self.imp_mat, self.hazard.frequency)
         else:
             at_event, eai_exp, aai_agg = self.stitch_risk_metrics(imp_mat_gen)
         return Impact.from_eih(
@@ -439,8 +439,8 @@ def aai_agg_from_eai_exp(eai_exp):
         """
         return np.sum(eai_exp)
 
-
-    def risk_metrics(self):
+    @classmethod
+    def risk_metrics(cls, imp_mat, freq):
         """
         Compute risk metricss eai_exp, at_event, aai_agg
         for an impact matrix and a frequency vector.
@@ -461,9 +461,9 @@ def risk_metrics(self):
         aai_agg : float
             average annual impact aggregated over all exposure points
         """
-        eai_exp = self.eai_exp_from_mat(self.imp_mat, self.hazard.frequency)
-        at_event = self.at_event_from_mat(self.imp_mat)
-        aai_agg = self.aai_agg_from_eai_exp(eai_exp)
+        eai_exp = cls.eai_exp_from_mat(imp_mat, freq)
+        at_event = cls.at_event_from_mat(imp_mat)
+        aai_agg = cls.aai_agg_from_eai_exp(eai_exp)
         return at_event, eai_exp, aai_agg
 
 class Impact():

From a84d2feef6d1709c84cd246f7470101e5c9cb4de Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 9 Jun 2022 19:32:00 +0200
Subject: [PATCH 049/121] Separate Impact and ImpactCalc

---
 climada/engine/__init__.py              |   1 +
 climada/engine/impact.py                | 422 +---------------------
 climada/engine/impact_calc.py           | 451 ++++++++++++++++++++++++
 climada/engine/test/test_impact_calc.py |   2 +-
 4 files changed, 455 insertions(+), 421 deletions(-)
 create mode 100644 climada/engine/impact_calc.py

diff --git a/climada/engine/__init__.py b/climada/engine/__init__.py
index 127ad5d33..5ed316ca2 100755
--- a/climada/engine/__init__.py
+++ b/climada/engine/__init__.py
@@ -20,3 +20,4 @@
 """
 from .impact import *
 from .cost_benefit import *
+from .impact_calc import *
\ No newline at end of file
diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 712888d7c..16b734064 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -19,7 +19,7 @@
 Define Impact and ImpactFreqCurve classes.
 """
 
-__all__ = ['ImpactFreqCurve', 'Impact', 'ImpactCalc']
+__all__ = ['ImpactFreqCurve', 'Impact']
 
 import logging
 import copy
@@ -47,425 +47,6 @@
 
 LOGGER = logging.getLogger(__name__)
 
-class ImpactCalc():
-    """
-    Class to compute impacts from exposures, impact function set and hazard
-    """
-
-    def __init__(self,
-                 exposures,
-                 impfset,
-                 hazard,
-                 imp_mat=None):
-        """
-        Initialize an ImpactCalc object.
-
-        The dimension of the imp_mat variable must be compatible with the
-        exposures and hazard objects.
-
-        Parameters
-        ----------
-        exposures : climada.entity.Exposures
-            exposure used to compute imp_mat
-        impf_set: climada.entity.ImpactFuncSet
-            impact functions set used to compute imp_mat
-        hazard : climada.Hazard
-            hazard used to compute imp_mat
-        imp_mat : sparse.csr_matrix, optional
-            matrix num_events x num_exp with impacts.
-            Default is an empty matrix.
-
-        Returns
-        -------
-        None.
-
-        """
-
-        imp_mat = sparse.csr_matrix(np.empty((0, 0))) if imp_mat is None else imp_mat
-        self.exposures = exposures
-        self.impfset = impfset
-        self.hazard = hazard
-        self.imp_mat = imp_mat
-        self.n_exp_pnt = self.exposures.gdf.shape[0]
-        self.n_events = self.hazard.size
-
-    @property
-    def deductible(self):
-        """
-        Deductible from the exposures
-
-        Returns
-        -------
-        np.array
-            The deductible per exposure point
-
-        """
-        return self.exposures.gdf['deductible']
-
-    @property
-    def cover(self):
-        """
-        Cover from the exposures
-
-        Returns
-        -------
-        np.array
-            The cover per exposure point
-
-        """
-        return self.exposures.gdf['cover']
-
-    def impact(self, save_mat=True):
-        """Compute the impact of a hazard on exposures.
-
-        Parameters
-        ----------
-        save_mat : bool
-            if true, save the total impact matrix (events x exposures)
-
-        Examples
-        --------
-            >>> haz = Hazard.from_mat(HAZ_DEMO_MAT)  # Set hazard
-            >>> impfset = ImpactFuncSet.from_excel(ENT_TEMPLATE_XLS) # Set impact functions
-            >>> exp = Exposures(pd.read_excel(ENT_TEMPLATE_XLS)) # Set exposures
-            >>> impcalc = ImpactCal(exp, impfset, haz)
-            >>> imp = impcalc.insured_impact()
-            >>> imp.aai_agg
-
-        Note
-        ----
-        Deductible and/or cover values in the exposures are ignored.
-        """
-        impf_col = self.exposures.get_impf_column(self.hazard.haz_type)
-        exp_gdf = self.minimal_exp_gdf(impf_col)
-        LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
-                    self.n_events, self.n_events)
-        imp_mat_gen = self.imp_mat_gen(exp_gdf, impf_col)
-        self._return_impact(imp_mat_gen, save_mat)
-
-#TODO: make a better impact matrix generator for insured impacts when
-# the impact matrix is already present
-    def insured_impact(self, save_mat=False):
-        """Compute the impact of a hazard on exposures with a deductible and/or
-        cover.
-
-        For each exposure point, the impact per event is obtained by
-        substracting the deductible (and is maximally equal to the cover).
-
-        Parameters
-        ----------
-        save_mat : bool
-            if true, save the total impact matrix (events x exposures)
-
-        Examples
-        --------
-            >>> haz = Hazard.from_mat(HAZ_DEMO_MAT)  # Set hazard
-            >>> impfset = ImpactFuncSet.from_excel(ENT_TEMPLATE_XLS) # Set impact functions
-            >>> exp = Exposures(pd.read_excel(ENT_TEMPLATE_XLS)) # Set exposures
-            >>> impcalc = ImpactCal(exp, impfset, haz)
-            >>> imp = impcalc.insured_impact()
-            >>> imp.aai_agg
-
-        See also
-        --------
-        apply_deductible_to_mat:
-            apply deductible to impact matrix
-        apply_cover_to_mat:
-            apply cover to impact matrix
-        """
-        impf_col = self.exposures.get_impf_column(self.hazard.haz_type)
-        exp_gdf = self.minimal_exp_gdf(impf_col)
-        LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
-                    exp_gdf.size, self.hazard.size)
-
-        if self.imp_mat.size == 0:
-            imp_mat_gen = self.imp_mat_gen(exp_gdf, impf_col)
-        else:
-            imp_mat_gen = ((self.imp_mat, self.exposures.gdf.index.values) for n in range(1))
-        ins_mat_gen = self.insured_mat_gen(imp_mat_gen, impf_col)
-        return self._return_impact(ins_mat_gen, save_mat)
-
-    def _return_impact(self, imp_mat_gen, save_mat):
-        """Return an impact object from an impact matrix generator
-
-        Parameters
-        ----------
-        imp_mat_gen : generator
-            Generator of impact matrix and corresponding exposures index
-        save_mat : boolean
-            if true, save the impact matrix
-
-        Returns
-        -------
-        Impact
-            Impact Object initialize from the impact matrix
-
-        See Also
-        --------
-        imp_mat_gen: impact matrix generator
-        insured_mat_gen: insured impact matrix generator
-
-        """
-        if save_mat:
-            self.imp_mat = self.stitch_impact_matrix(imp_mat_gen)
-            at_event, eai_exp, aai_agg = self.risk_metrics(self.imp_mat, self.hazard.frequency)
-        else:
-            at_event, eai_exp, aai_agg = self.stitch_risk_metrics(imp_mat_gen)
-        return Impact.from_eih(
-            self.exposures, self.impfset, self.hazard,
-            at_event, eai_exp, aai_agg, self.imp_mat
-            )
-
-    def minimal_exp_gdf(self, impf_col):
-        """Get minimal exposures geodataframe for impact computation
-
-        Parameters
-        ----------
-        exposures : climada.entity.Exposures
-        hazard : climada.Hazard
-        impf_col: stirng
-            name of the impact function column in exposures.gdf
-
-        """
-        self.exposures.assign_centroids(self.hazard, overwrite=False)
-
-        mask = (
-            (self.exposures.gdf.value.values != 0)
-            & (self.exposures.gdf[self.hazard.cent_exp_col].values >= 0)
-        )
-        exp_gdf = pd.DataFrame({
-            col: self.exposures.gdf[col].values[mask]
-            for col in ['value', impf_col, self.hazard.cent_exp_col]
-        })
-        if exp_gdf.size == 0:
-            LOGGER.warning("No exposures with value >0 in the vicinity of the hazard.")
-        return exp_gdf
-
-    def imp_mat_gen(self, exp_gdf, impf_col):
-        """
-        Geneartor of impact sub-matrices and correspoding exposures indices
-        """
-        for impf_id in exp_gdf[impf_col].dropna().unique():
-            impf = self.impfset.get_func(haz_type=self.hazard.haz_type, fun_id=impf_id)
-            idx_exp_impf = (exp_gdf[impf_col].values == impf.id).nonzero()[0]
-            exp_step = CONFIG.max_matrix_size.int() // self.hazard.size
-            if not exp_step:
-                raise ValueError(
-                    f'Increase max_matrix_size configuration parameter to > {self.hazard.size}')
-            for chk in range(int(idx_exp_impf.size / exp_step) + 1):
-                exp_idx = idx_exp_impf[chk * exp_step:(chk + 1) * exp_step]
-                exp_values = exp_gdf.value.values[exp_idx]
-                cent_idx = exp_gdf[self.hazard.cent_exp_col].values[exp_idx]
-                yield (self.impact_matrix(exp_values, cent_idx, impf), exp_idx)
-
-    def insured_mat_gen(self, imp_mat_gen, impf_col):
-        """
-        Generator of insured impact sub-matrices (with applied cover and deductible)
-        and corresponding exposures indices
-        """
-        for mat, exp_idx in imp_mat_gen:
-            impf_id = self.exposures.gdf[impf_col][exp_idx].unique()[0]
-            deductible = self.deductible[exp_idx]
-            cent_idx = self.exposures.gdf['centr_TC'][exp_idx]
-            impf = self.impfset.get_func(haz_type=self.hazard.haz_type, fun_id=impf_id)
-            mat = self.apply_deductible_to_mat(mat, deductible, self.hazard, cent_idx, impf)
-            cover = self.cover[exp_idx]
-            mat = self.apply_cover_to_mat(mat, cover)
-            yield (mat, exp_idx)
-
-    def impact_matrix(self, exp_values, cent_idx, impf):
-        """
-        Compute the impact matrix for given exposure values,
-        assigned centroids, a hazard, and one impact function.
-
-        Parameters
-        ----------
-        exp_values : np.array
-            Exposure values
-        cent_idx : np.array
-            Hazard centroids assigned to each exposure location
-        hazard : climada.Hazard
-           Hazard object
-        impf : climada.entity.ImpactFunc
-            one impactfunction comon to all exposure elements in exp_gdf
-
-        Returns
-        -------
-        scipy.sparse.csr_matrix
-            Impact per event (rows) per exposure point (columns)
-        """
-        n_centroids = cent_idx.size
-        mdr = self.hazard.get_mdr(cent_idx, impf)
-        fract = self.hazard.get_fraction(cent_idx)
-        exp_values_csr = sparse.csr_matrix(
-            (exp_values, np.arange(n_centroids), [0, n_centroids]),
-            shape=(1, n_centroids))
-        return fract.multiply(mdr).multiply(exp_values_csr)
-
-    def stitch_impact_matrix(self, imp_mat_gen):
-        """
-        Make an impact matrix from an impact sub-matrix generator
-        """
-        data, row, col = np.hstack([
-            (mat.data, mat.nonzero()[0], idx[mat.nonzero()[1]])
-            for mat, idx in imp_mat_gen
-            ])
-        return sparse.csr_matrix(
-            (data, (row, col)), shape=(self.n_events, self.n_exp_pnt)
-            )
-
-    def stitch_risk_metrics(self, imp_mat_gen):
-        """
-        Compute the impact metrics from an impact sub-matrix generator
-        """
-        at_event = np.zeros(self.n_events)
-        eai_exp = np.zeros(self.n_exp_pnt)
-        for sub_imp_mat, exp_idx in imp_mat_gen:
-            at_event += self.at_event_from_mat(sub_imp_mat)
-            eai_exp[exp_idx] += self.eai_exp_from_mat(sub_imp_mat, self.hazard.frequency)
-        aai_agg = self.aai_agg_from_eai_exp(eai_exp)
-        return at_event, eai_exp, aai_agg
-
-    @staticmethod
-    def apply_deductible_to_mat(mat, deductible, hazard, cent_idx, impf):
-        """
-        Apply a deductible per exposure point to an impact matrix at given
-        centroid points for given impact function.
-
-        All exposure points must have the same impact function. For different
-        impact functions apply use this method repeatedly on the same impact
-        matrix.
-
-        Parameters
-        ----------
-        imp_mat : scipy.sparse.csr_matrix
-            impact matrix (events x exposure points)
-        deductible : np.array()
-            deductible for each exposure point
-        hazard : climada.Hazard
-            hazard used to compute the imp_mat
-        cent_idx : np.array()
-            index of centroids associated with each exposure point
-        impf : climada.entity.ImpactFunc
-            impact function associated with the exposure points
-
-        Returns
-        -------
-        imp_mat : scipy.sparse.csr_matrix
-            impact matrix with applied deductible
-
-        """
-        paa = hazard.get_paa(cent_idx, impf)
-        mat -= paa.multiply(sparse.csr_matrix(deductible))
-        mat.eliminate_zeros()
-        return mat
-
-    @staticmethod
-    def apply_cover_to_mat(mat, cover):
-        """
-        Apply cover to impact matrix.
-
-        The impact data is clipped to the range [0, cover]. The cover is defined
-        per exposure point.
-
-        Parameters
-        ----------
-        imp_mat : scipy.sparse.csr_matrix
-            impact matrix
-        cover : np.array()
-            cover per exposures point (columns of imp_mat)
-
-        Returns
-        -------
-        imp_mat : scipy.sparse.csr_matrix
-            impact matrix with applied cover
-
-        """
-        mat.data = np.clip(mat.data, 0, cover.to_numpy()[mat.nonzero()[1]])
-        mat.eliminate_zeros()
-        return mat
-
-    @staticmethod
-    def eai_exp_from_mat(mat, freq):
-        """
-        Compute impact for each exposures from the total impact matrix
-
-        Parameters
-        ----------
-        imp_mat : sparse.csr_matrix
-            matrix num_events x num_exp with impacts.
-        frequency : np.array
-            annual frequency of events
-        Returns
-        -------
-        eai_exp : np.array
-            expected annual impact for each exposure
-        """
-        n_events = freq.size
-        freq_csr = sparse.csr_matrix(
-            (freq, np.zeros(n_events), np.arange(n_events + 1)),
-            shape=(n_events, 1))
-        return mat.multiply(freq_csr).sum(axis=0).A1
-
-    @staticmethod
-    def at_event_from_mat(mat):
-        """
-        Compute impact for each hazard event from the total impact matrix
-        Parameters
-        ----------
-        imp_mat : sparse.csr_matrix
-            matrix num_events x num_exp with impacts.
-        Returns
-        -------
-        at_event : np.array
-            impact for each hazard event
-        """
-        return np.squeeze(np.asarray(np.sum(mat, axis=1)))
-
-    @staticmethod
-    def aai_agg_from_eai_exp(eai_exp):
-        """
-        Aggregate impact.eai_exp
-
-        Parameters
-        ----------
-        eai_exp : np.array
-            expected annual impact for each exposure point
-
-        Returns
-        -------
-        float
-            average annual impact aggregated
-        """
-        return np.sum(eai_exp)
-
-    @classmethod
-    def risk_metrics(cls, imp_mat, freq):
-        """
-        Compute risk metricss eai_exp, at_event, aai_agg
-        for an impact matrix and a frequency vector.
-
-        Parameters
-        ----------
-        imp_mat : sparse.csr_matrix
-            matrix num_events x num_exp with impacts.
-        freq : np.array
-            array with the frequency per event
-
-        Returns
-        -------
-        eai_exp: np.array
-            expected annual impact at each exposure point
-        at_event: np.array()
-            total impact for each event
-        aai_agg : float
-            average annual impact aggregated over all exposure points
-        """
-        eai_exp = cls.eai_exp_from_mat(imp_mat, freq)
-        at_event = cls.at_event_from_mat(imp_mat)
-        aai_agg = cls.aai_agg_from_eai_exp(eai_exp)
-        return at_event, eai_exp, aai_agg
-
 class Impact():
     """Impact definition. Compute from an entity (exposures and impact
     functions) and hazard.
@@ -534,6 +115,7 @@ def __init__(self,
     def calc(self, exposures, impact_funcs, hazard, save_mat=False):
         """This function is deprecated, use Impact.calc_risk and Impact.calc_insured_risk instead.
         """
+        from climada.engine.impact_calc import ImpactCalc
         impcalc= ImpactCalc(exposures, impact_funcs, hazard)
         if ('deductible' in exposures.gdf) and ('cover' in exposures.gdf) \
             and exposures.gdf.cover.max():
diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
new file mode 100644
index 000000000..523ce9a1c
--- /dev/null
+++ b/climada/engine/impact_calc.py
@@ -0,0 +1,451 @@
+"""
+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/>.
+
+---
+
+Define Impact and ImpactFreqCurve classes.
+"""
+
+__all__ = ['ImpactCalc']
+
+import logging
+import numpy as np
+from scipy import sparse
+import pandas as pd
+
+from climada import CONFIG
+from climada.engine import Impact
+
+LOGGER = logging.getLogger(__name__)
+
+class ImpactCalc():
+    """
+    Class to compute impacts from exposures, impact function set and hazard
+    """
+
+    def __init__(self,
+                 exposures,
+                 impfset,
+                 hazard,
+                 imp_mat=None):
+        """
+        Initialize an ImpactCalc object.
+
+        The dimension of the imp_mat variable must be compatible with the
+        exposures and hazard objects.
+
+        Parameters
+        ----------
+        exposures : climada.entity.Exposures
+            exposure used to compute imp_mat
+        impf_set: climada.entity.ImpactFuncSet
+            impact functions set used to compute imp_mat
+        hazard : climada.Hazard
+            hazard used to compute imp_mat
+        imp_mat : sparse.csr_matrix, optional
+            matrix num_events x num_exp with impacts.
+            Default is an empty matrix.
+
+        Returns
+        -------
+        None.
+
+        """
+
+        imp_mat = sparse.csr_matrix(np.empty((0, 0))) if imp_mat is None else imp_mat
+        self.exposures = exposures
+        self.impfset = impfset
+        self.hazard = hazard
+        self.imp_mat = imp_mat
+        self.n_exp_pnt = self.exposures.gdf.shape[0]
+        self.n_events = self.hazard.size
+
+    @property
+    def deductible(self):
+        """
+        Deductible from the exposures
+
+        Returns
+        -------
+        np.array
+            The deductible per exposure point
+
+        """
+        return self.exposures.gdf['deductible']
+
+    @property
+    def cover(self):
+        """
+        Cover from the exposures
+
+        Returns
+        -------
+        np.array
+            The cover per exposure point
+
+        """
+        return self.exposures.gdf['cover']
+
+    def impact(self, save_mat=True):
+        """Compute the impact of a hazard on exposures.
+
+        Parameters
+        ----------
+        save_mat : bool
+            if true, save the total impact matrix (events x exposures)
+
+        Examples
+        --------
+            >>> haz = Hazard.from_mat(HAZ_DEMO_MAT)  # Set hazard
+            >>> impfset = ImpactFuncSet.from_excel(ENT_TEMPLATE_XLS) # Set impact functions
+            >>> exp = Exposures(pd.read_excel(ENT_TEMPLATE_XLS)) # Set exposures
+            >>> impcalc = ImpactCal(exp, impfset, haz)
+            >>> imp = impcalc.insured_impact()
+            >>> imp.aai_agg
+
+        Note
+        ----
+        Deductible and/or cover values in the exposures are ignored.
+        """
+        impf_col = self.exposures.get_impf_column(self.hazard.haz_type)
+        exp_gdf = self.minimal_exp_gdf(impf_col)
+        LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
+                    self.n_events, self.n_events)
+        imp_mat_gen = self.imp_mat_gen(exp_gdf, impf_col)
+        self._return_impact(imp_mat_gen, save_mat)
+
+#TODO: make a better impact matrix generator for insured impacts when
+# the impact matrix is already present
+    def insured_impact(self, save_mat=False):
+        """Compute the impact of a hazard on exposures with a deductible and/or
+        cover.
+
+        For each exposure point, the impact per event is obtained by
+        substracting the deductible (and is maximally equal to the cover).
+
+        Parameters
+        ----------
+        save_mat : bool
+            if true, save the total impact matrix (events x exposures)
+
+        Examples
+        --------
+            >>> haz = Hazard.from_mat(HAZ_DEMO_MAT)  # Set hazard
+            >>> impfset = ImpactFuncSet.from_excel(ENT_TEMPLATE_XLS) # Set impact functions
+            >>> exp = Exposures(pd.read_excel(ENT_TEMPLATE_XLS)) # Set exposures
+            >>> impcalc = ImpactCal(exp, impfset, haz)
+            >>> imp = impcalc.insured_impact()
+            >>> imp.aai_agg
+
+        See also
+        --------
+        apply_deductible_to_mat:
+            apply deductible to impact matrix
+        apply_cover_to_mat:
+            apply cover to impact matrix
+        """
+        impf_col = self.exposures.get_impf_column(self.hazard.haz_type)
+        exp_gdf = self.minimal_exp_gdf(impf_col)
+        LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
+                    exp_gdf.size, self.hazard.size)
+
+        if self.imp_mat.size == 0:
+            imp_mat_gen = self.imp_mat_gen(exp_gdf, impf_col)
+        else:
+            imp_mat_gen = ((self.imp_mat, self.exposures.gdf.index.values) for n in range(1))
+        ins_mat_gen = self.insured_mat_gen(imp_mat_gen, impf_col)
+        return self._return_impact(ins_mat_gen, save_mat)
+
+    def _return_impact(self, imp_mat_gen, save_mat):
+        """Return an impact object from an impact matrix generator
+
+        Parameters
+        ----------
+        imp_mat_gen : generator
+            Generator of impact matrix and corresponding exposures index
+        save_mat : boolean
+            if true, save the impact matrix
+
+        Returns
+        -------
+        Impact
+            Impact Object initialize from the impact matrix
+
+        See Also
+        --------
+        imp_mat_gen: impact matrix generator
+        insured_mat_gen: insured impact matrix generator
+
+        """
+        if save_mat:
+            self.imp_mat = self.stitch_impact_matrix(imp_mat_gen)
+            at_event, eai_exp, aai_agg = self.risk_metrics(self.imp_mat, self.hazard.frequency)
+        else:
+            at_event, eai_exp, aai_agg = self.stitch_risk_metrics(imp_mat_gen)
+        return Impact.from_eih(
+            self.exposures, self.impfset, self.hazard,
+            at_event, eai_exp, aai_agg, self.imp_mat
+            )
+
+    def minimal_exp_gdf(self, impf_col):
+        """Get minimal exposures geodataframe for impact computation
+
+        Parameters
+        ----------
+        exposures : climada.entity.Exposures
+        hazard : climada.Hazard
+        impf_col: stirng
+            name of the impact function column in exposures.gdf
+
+        """
+        self.exposures.assign_centroids(self.hazard, overwrite=False)
+
+        mask = (
+            (self.exposures.gdf.value.values != 0)
+            & (self.exposures.gdf[self.hazard.cent_exp_col].values >= 0)
+        )
+        exp_gdf = pd.DataFrame({
+            col: self.exposures.gdf[col].values[mask]
+            for col in ['value', impf_col, self.hazard.cent_exp_col]
+        })
+        if exp_gdf.size == 0:
+            LOGGER.warning("No exposures with value >0 in the vicinity of the hazard.")
+        return exp_gdf
+
+    def imp_mat_gen(self, exp_gdf, impf_col):
+        """
+        Geneartor of impact sub-matrices and correspoding exposures indices
+        """
+        for impf_id in exp_gdf[impf_col].dropna().unique():
+            impf = self.impfset.get_func(haz_type=self.hazard.haz_type, fun_id=impf_id)
+            idx_exp_impf = (exp_gdf[impf_col].values == impf.id).nonzero()[0]
+            exp_step = CONFIG.max_matrix_size.int() // self.hazard.size
+            if not exp_step:
+                raise ValueError(
+                    f'Increase max_matrix_size configuration parameter to > {self.hazard.size}')
+            for chk in range(int(idx_exp_impf.size / exp_step) + 1):
+                exp_idx = idx_exp_impf[chk * exp_step:(chk + 1) * exp_step]
+                exp_values = exp_gdf.value.values[exp_idx]
+                cent_idx = exp_gdf[self.hazard.cent_exp_col].values[exp_idx]
+                yield (self.impact_matrix(exp_values, cent_idx, impf), exp_idx)
+
+    def insured_mat_gen(self, imp_mat_gen, impf_col):
+        """
+        Generator of insured impact sub-matrices (with applied cover and deductible)
+        and corresponding exposures indices
+        """
+        for mat, exp_idx in imp_mat_gen:
+            impf_id = self.exposures.gdf[impf_col][exp_idx].unique()[0]
+            deductible = self.deductible[exp_idx]
+            cent_idx = self.exposures.gdf['centr_TC'][exp_idx]
+            impf = self.impfset.get_func(haz_type=self.hazard.haz_type, fun_id=impf_id)
+            mat = self.apply_deductible_to_mat(mat, deductible, self.hazard, cent_idx, impf)
+            cover = self.cover[exp_idx]
+            mat = self.apply_cover_to_mat(mat, cover)
+            yield (mat, exp_idx)
+
+    def impact_matrix(self, exp_values, cent_idx, impf):
+        """
+        Compute the impact matrix for given exposure values,
+        assigned centroids, a hazard, and one impact function.
+
+        Parameters
+        ----------
+        exp_values : np.array
+            Exposure values
+        cent_idx : np.array
+            Hazard centroids assigned to each exposure location
+        hazard : climada.Hazard
+           Hazard object
+        impf : climada.entity.ImpactFunc
+            one impactfunction comon to all exposure elements in exp_gdf
+
+        Returns
+        -------
+        scipy.sparse.csr_matrix
+            Impact per event (rows) per exposure point (columns)
+        """
+        n_centroids = cent_idx.size
+        mdr = self.hazard.get_mdr(cent_idx, impf)
+        fract = self.hazard.get_fraction(cent_idx)
+        exp_values_csr = sparse.csr_matrix(
+            (exp_values, np.arange(n_centroids), [0, n_centroids]),
+            shape=(1, n_centroids))
+        return fract.multiply(mdr).multiply(exp_values_csr)
+
+    def stitch_impact_matrix(self, imp_mat_gen):
+        """
+        Make an impact matrix from an impact sub-matrix generator
+        """
+        data, row, col = np.hstack([
+            (mat.data, mat.nonzero()[0], idx[mat.nonzero()[1]])
+            for mat, idx in imp_mat_gen
+            ])
+        return sparse.csr_matrix(
+            (data, (row, col)), shape=(self.n_events, self.n_exp_pnt)
+            )
+
+    def stitch_risk_metrics(self, imp_mat_gen):
+        """
+        Compute the impact metrics from an impact sub-matrix generator
+        """
+        at_event = np.zeros(self.n_events)
+        eai_exp = np.zeros(self.n_exp_pnt)
+        for sub_imp_mat, exp_idx in imp_mat_gen:
+            at_event += self.at_event_from_mat(sub_imp_mat)
+            eai_exp[exp_idx] += self.eai_exp_from_mat(sub_imp_mat, self.hazard.frequency)
+        aai_agg = self.aai_agg_from_eai_exp(eai_exp)
+        return at_event, eai_exp, aai_agg
+
+    @staticmethod
+    def apply_deductible_to_mat(mat, deductible, hazard, cent_idx, impf):
+        """
+        Apply a deductible per exposure point to an impact matrix at given
+        centroid points for given impact function.
+
+        All exposure points must have the same impact function. For different
+        impact functions apply use this method repeatedly on the same impact
+        matrix.
+
+        Parameters
+        ----------
+        imp_mat : scipy.sparse.csr_matrix
+            impact matrix (events x exposure points)
+        deductible : np.array()
+            deductible for each exposure point
+        hazard : climada.Hazard
+            hazard used to compute the imp_mat
+        cent_idx : np.array()
+            index of centroids associated with each exposure point
+        impf : climada.entity.ImpactFunc
+            impact function associated with the exposure points
+
+        Returns
+        -------
+        imp_mat : scipy.sparse.csr_matrix
+            impact matrix with applied deductible
+
+        """
+        paa = hazard.get_paa(cent_idx, impf)
+        mat -= paa.multiply(sparse.csr_matrix(deductible))
+        mat.eliminate_zeros()
+        return mat
+
+    @staticmethod
+    def apply_cover_to_mat(mat, cover):
+        """
+        Apply cover to impact matrix.
+
+        The impact data is clipped to the range [0, cover]. The cover is defined
+        per exposure point.
+
+        Parameters
+        ----------
+        imp_mat : scipy.sparse.csr_matrix
+            impact matrix
+        cover : np.array()
+            cover per exposures point (columns of imp_mat)
+
+        Returns
+        -------
+        imp_mat : scipy.sparse.csr_matrix
+            impact matrix with applied cover
+
+        """
+        mat.data = np.clip(mat.data, 0, cover.to_numpy()[mat.nonzero()[1]])
+        mat.eliminate_zeros()
+        return mat
+
+    @staticmethod
+    def eai_exp_from_mat(mat, freq):
+        """
+        Compute impact for each exposures from the total impact matrix
+
+        Parameters
+        ----------
+        imp_mat : sparse.csr_matrix
+            matrix num_events x num_exp with impacts.
+        frequency : np.array
+            annual frequency of events
+        Returns
+        -------
+        eai_exp : np.array
+            expected annual impact for each exposure
+        """
+        n_events = freq.size
+        freq_csr = sparse.csr_matrix(
+            (freq, np.zeros(n_events), np.arange(n_events + 1)),
+            shape=(n_events, 1))
+        return mat.multiply(freq_csr).sum(axis=0).A1
+
+    @staticmethod
+    def at_event_from_mat(mat):
+        """
+        Compute impact for each hazard event from the total impact matrix
+        Parameters
+        ----------
+        imp_mat : sparse.csr_matrix
+            matrix num_events x num_exp with impacts.
+        Returns
+        -------
+        at_event : np.array
+            impact for each hazard event
+        """
+        return np.squeeze(np.asarray(np.sum(mat, axis=1)))
+
+    @staticmethod
+    def aai_agg_from_eai_exp(eai_exp):
+        """
+        Aggregate impact.eai_exp
+
+        Parameters
+        ----------
+        eai_exp : np.array
+            expected annual impact for each exposure point
+
+        Returns
+        -------
+        float
+            average annual impact aggregated
+        """
+        return np.sum(eai_exp)
+
+    @classmethod
+    def risk_metrics(cls, imp_mat, freq):
+        """
+        Compute risk metricss eai_exp, at_event, aai_agg
+        for an impact matrix and a frequency vector.
+
+        Parameters
+        ----------
+        imp_mat : sparse.csr_matrix
+            matrix num_events x num_exp with impacts.
+        freq : np.array
+            array with the frequency per event
+
+        Returns
+        -------
+        eai_exp: np.array
+            expected annual impact at each exposure point
+        at_event: np.array()
+            total impact for each event
+        aai_agg : float
+            average annual impact aggregated over all exposure points
+        """
+        eai_exp = cls.eai_exp_from_mat(imp_mat, freq)
+        at_event = cls.at_event_from_mat(imp_mat)
+        aai_agg = cls.aai_agg_from_eai_exp(eai_exp)
+        return at_event, eai_exp, aai_agg
\ No newline at end of file
diff --git a/climada/engine/test/test_impact_calc.py b/climada/engine/test/test_impact_calc.py
index 7b19a3541..5b1db690c 100644
--- a/climada/engine/test/test_impact_calc.py
+++ b/climada/engine/test/test_impact_calc.py
@@ -24,7 +24,7 @@
 
 from climada.entity.entity_def import Entity
 from climada.hazard.base import Hazard
-from climada.engine.impact import Impact, ImpactCalc
+from climada.engine import Impact, ImpactCalc
 from climada.util.constants import ENT_DEMO_TODAY, DEF_CRS, DEMO_DIR
 from climada.util.api_client import Client
 import climada.engine.test as engine_test

From bcf1590e941c90adcb371fb9ff9d36aa0d42fe0c Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 9 Jun 2022 20:56:02 +0200
Subject: [PATCH 050/121] Add deprecation warnings

---
 climada/engine/impact.py | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 16b734064..a2d2ebd1b 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -113,18 +113,21 @@ def __init__(self,
         self.imp_mat = sparse.csr_matrix(np.empty((0, 0))) if imp_mat is None else imp_mat
 
     def calc(self, exposures, impact_funcs, hazard, save_mat=False):
-        """This function is deprecated, use Impact.calc_risk and Impact.calc_insured_risk instead.
+        """This function is deprecated, use ImpactCalc.impact
+        and ImpactCalc.insured_impact instead.
         """
         from climada.engine.impact_calc import ImpactCalc
         impcalc= ImpactCalc(exposures, impact_funcs, hazard)
         if ('deductible' in exposures.gdf) and ('cover' in exposures.gdf) \
             and exposures.gdf.cover.max():
-            # LOGGER.warning("To compute the risk transfer value"
-            #      "please use Impact.calc_insured_risk")
+            LOGGER.warning(
+                "The use of Impact().calc() is deprecated for exposures with "
+                "deductible and/or cover. Use ImpactCalc().impact() instead."
+                )
             self.__dict__ = impcalc.insured_impact(save_mat).__dict__
         else:
-            # LOGGER.warning("The use of Impact.calc() is deprecated."
-            #      "Please use Impact.calc_risk() or Impact.calc_risk_insured().")
+            LOGGER.warning("The use of Impact().calc() is deprecated."
+                           "Use ImpactCalc().impact() instead.")
             self.__dict__ = impcalc.impact(save_mat).__dict__
 
 #TODO: new name
@@ -144,6 +147,7 @@ def from_eih(cls, exposures, impfset, hazard,
             hazard used to compute imp_mat
         imp_mat : sparse.csr_matrix
             matrix num_events x num_exp with impacts.
+            Default is None (empty sparse csr matrix)
 
         Returns
         -------
@@ -172,7 +176,6 @@ def from_eih(cls, exposures, impfset, hazard,
                    }
             )
 
-
     def transfer_risk(self, attachment, cover):
         """Compute the risk transfer for the full portfolio. This is the risk
         of the full portfolio summed over all events. For each
@@ -230,7 +233,7 @@ def residual_risk(self, attachment, cover):
         residual_aai_agg = np.sum(residual_at_event * self.frequency)
         return residual_at_event, residual_aai_agg
 
-#TODO deprecate method
+#TODO: rewrite and deprecate method
     def calc_risk_transfer(self, attachment, cover):
         """Compute traaditional risk transfer over impact. Returns new impact
         with risk transfer applied and the insurance layer resulting
@@ -311,7 +314,7 @@ def calc_impact_year_set(self,all_years=True, year_range=None):
                        "Use Impact.impact_per_year instead.")
         return self.impact_per_year(all_years=all_years, year_range=year_range)
 
-#TODO: improve method
+#TODO: rewrite and deprecate method
     def local_exceedance_imp(self, return_periods=(25, 50, 100, 250)):
         """Compute exceedance impact map for given return periods.
         Requires attribute imp_mat.
@@ -1009,6 +1012,7 @@ def run(i_time):
 
         return imp_list
 
+#TODO: rewrite and deprecate method
     def _loc_return_imp(self, return_periods, imp, exc_imp):
         """Compute local exceedence impact for given return period.
 

From c462290dd02d1a98b3ab2a8428ed3acb622a7695 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 9 Jun 2022 20:56:53 +0200
Subject: [PATCH 051/121] Return min exp gdf instead of df

---
 climada/engine/impact_calc.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index 523ce9a1c..8b82a3b10 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -24,7 +24,7 @@
 import logging
 import numpy as np
 from scipy import sparse
-import pandas as pd
+import geopandas as gpd
 
 from climada import CONFIG
 from climada.engine import Impact
@@ -217,7 +217,7 @@ def minimal_exp_gdf(self, impf_col):
             (self.exposures.gdf.value.values != 0)
             & (self.exposures.gdf[self.hazard.cent_exp_col].values >= 0)
         )
-        exp_gdf = pd.DataFrame({
+        exp_gdf = gpd.GeoDataFrame({
             col: self.exposures.gdf[col].values[mask]
             for col in ['value', impf_col, self.hazard.cent_exp_col]
         })

From 425cebf8beb0a4eafeadcfcc26b415cc763504bc Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 9 Jun 2022 20:57:19 +0200
Subject: [PATCH 052/121] Improve cover and deductible

---
 climada/engine/impact_calc.py | 19 ++++++++++++++-----
 1 file changed, 14 insertions(+), 5 deletions(-)

diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index 8b82a3b10..5a24a3757 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -76,7 +76,8 @@ def __init__(self,
     @property
     def deductible(self):
         """
-        Deductible from the exposures
+        Deductibles from the exposures. Returns empty array
+        if no deductibles defined.
 
         Returns
         -------
@@ -84,12 +85,14 @@ def deductible(self):
             The deductible per exposure point
 
         """
-        return self.exposures.gdf['deductible']
+        if 'deductible' in self.exposures.gdf.columns:
+            return self.exposures.gdf['deductible'].to_numpy()
+        return np.array([])
 
     @property
     def cover(self):
         """
-        Cover from the exposures
+        Covers from the exposures. Returns empty array if no covers defined.
 
         Returns
         -------
@@ -97,7 +100,9 @@ def cover(self):
             The cover per exposure point
 
         """
-        return self.exposures.gdf['cover']
+        if 'cover' in self.exposures.gdf.columns:
+            return self.exposures.gdf['cover'].to_numpy()
+        return np.array([])
 
     def impact(self, save_mat=True):
         """Compute the impact of a hazard on exposures.
@@ -157,6 +162,10 @@ def insured_impact(self, save_mat=False):
         apply_cover_to_mat:
             apply cover to impact matrix
         """
+        if self.cover.size == 0 and self.deductible.size == 0:
+            raise AttributeError("Neither cover nor deductible defined."
+                                 "Please set exposures.gdf.cover"
+                                 "and/or exposures.gdf.deductible")
         impf_col = self.exposures.get_impf_column(self.hazard.haz_type)
         exp_gdf = self.minimal_exp_gdf(impf_col)
         LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
@@ -365,7 +374,7 @@ def apply_cover_to_mat(mat, cover):
             impact matrix with applied cover
 
         """
-        mat.data = np.clip(mat.data, 0, cover.to_numpy()[mat.nonzero()[1]])
+        mat.data = np.clip(mat.data, 0, cover[mat.nonzero()[1]])
         mat.eliminate_zeros()
         return mat
 

From 15b7d57bfb2e8c40fbd5a376c1a5d06db39bf800 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 9 Jun 2022 20:57:33 +0200
Subject: [PATCH 053/121] Rename imp_mat to mat

---
 climada/engine/impact_calc.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index 5a24a3757..e93bfd73b 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -130,7 +130,7 @@ def impact(self, save_mat=True):
         LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
                     self.n_events, self.n_events)
         imp_mat_gen = self.imp_mat_gen(exp_gdf, impf_col)
-        self._return_impact(imp_mat_gen, save_mat)
+        return self._return_impact(imp_mat_gen, save_mat)
 
 #TODO: make a better impact matrix generator for insured impacts when
 # the impact matrix is already present
@@ -433,14 +433,14 @@ def aai_agg_from_eai_exp(eai_exp):
         return np.sum(eai_exp)
 
     @classmethod
-    def risk_metrics(cls, imp_mat, freq):
+    def risk_metrics(cls, mat, freq):
         """
         Compute risk metricss eai_exp, at_event, aai_agg
         for an impact matrix and a frequency vector.
 
         Parameters
         ----------
-        imp_mat : sparse.csr_matrix
+        mat : sparse.csr_matrix
             matrix num_events x num_exp with impacts.
         freq : np.array
             array with the frequency per event
@@ -454,7 +454,7 @@ def risk_metrics(cls, imp_mat, freq):
         aai_agg : float
             average annual impact aggregated over all exposure points
         """
-        eai_exp = cls.eai_exp_from_mat(imp_mat, freq)
-        at_event = cls.at_event_from_mat(imp_mat)
+        eai_exp = cls.eai_exp_from_mat(mat, freq)
+        at_event = cls.at_event_from_mat(mat)
         aai_agg = cls.aai_agg_from_eai_exp(eai_exp)
         return at_event, eai_exp, aai_agg
\ No newline at end of file

From bd7306e4f4976b9ca170a3bc2df353db62997c14 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 9 Jun 2022 20:57:47 +0200
Subject: [PATCH 054/121] Add tests for most exposed methods

---
 climada/engine/test/test_impact_calc.py | 232 ++++++++++++++----------
 1 file changed, 133 insertions(+), 99 deletions(-)

diff --git a/climada/engine/test/test_impact_calc.py b/climada/engine/test/test_impact_calc.py
index 5b1db690c..6a8cc3a7a 100644
--- a/climada/engine/test/test_impact_calc.py
+++ b/climada/engine/test/test_impact_calc.py
@@ -24,10 +24,9 @@
 
 from climada.entity.entity_def import Entity
 from climada.hazard.base import Hazard
-from climada.engine import Impact, ImpactCalc
-from climada.util.constants import ENT_DEMO_TODAY, DEF_CRS, DEMO_DIR
+from climada.engine import ImpactCalc
+from climada.util.constants import ENT_DEMO_TODAY, DEMO_DIR
 from climada.util.api_client import Client
-import climada.engine.test as engine_test
 
 
 def get_haz_test_file(ds_name):
@@ -55,127 +54,162 @@ def test_init(self):
         icalc = ImpactCalc(ENT.exposures, ENT.impact_funcs, HAZ)
         self.assertEqual(icalc.n_exp_pnt, ENT.exposures.gdf.shape[0])
         self.assertEqual(icalc.n_events, HAZ.size)
-        np.testing.assert_array_equal(icalc.deductible, ENT.exposures.gdf.deductible)
-        np.testing.assert_array_equal(icalc.cover, ENT.exposures.gdf.cover)
         self.assertEqual(icalc.imp_mat.size, 0)
         self.assertTrue(ENT.exposures.gdf.equals(icalc.exposures.gdf))
-        self.assertEqual(HAZ.event_id, icalc.hazard.event_id)
-        self.assertEqual(HAZ.event_name, icalc.hazard.event_name)
-
-class TestCalc(unittest.TestCase):
-    """Test impact calc method."""
-
-    def test_ref_value_pass(self):
-        """Test result against reference value"""
-        # Read default entity values
-        ent = Entity.from_excel(ENT_DEMO_TODAY)
-        ent.check()
+        np.testing.assert_array_equal(HAZ.event_id, icalc.hazard.event_id)
+        np.testing.assert_array_equal(HAZ.event_name, icalc.hazard.event_name)
+        np.testing.assert_array_equal(icalc.deductible, ENT.exposures.gdf.deductible)
+        np.testing.assert_array_equal(icalc.cover, ENT.exposures.gdf.cover)
 
-        # Read default hazard file
-        hazard = Hazard.from_mat(HAZ_TEST_MAT)
 
-        # Create impact object
-        impact = Impact()
+    def test_metrics(self):
+        """Test methods to get impact metrics"""
+        mat = sparse.csr_matrix(np.array(
+            [[1, 0, 1],
+             [2, 2, 0]]
+            ))
+        freq = np.array([1, 1/10])
+        at_event = ImpactCalc.at_event_from_mat(mat)
+        eai_exp = ImpactCalc.eai_exp_from_mat(mat, freq)
+        aai_agg = ImpactCalc.aai_agg_from_eai_exp(eai_exp)
+        np.testing.assert_array_equal(at_event, [2, 4])
+        np.testing.assert_array_equal(eai_exp, [1.2, 0.2, 1])
+        self.assertEqual(aai_agg, 2.4)
+
+        ae, eai, aai = ImpactCalc.risk_metrics(mat, freq)
+        self.assertEqual(aai, aai_agg)
+        np.testing.assert_array_equal(at_event, ae)
+        np.testing.assert_array_equal(eai_exp, eai)
+
+    def test_insured_matrics(self):
+        """Test methods to get insured metrics"""
+        mat = sparse.csr_matrix(np.array(
+            [[1, 0, 1],
+             [2, 2, 0]]
+            ))
+        cover = np.array([0, 1, 10])
+        imp = ImpactCalc.apply_cover_to_mat(mat, cover)
+        np.testing.assert_array_equal(
+            imp.todense(), np.array([[0, 0, 1], [0, 1, 0]])
+            )
+
+    def test_calc_impact_pass(self):
+        """Test compute impact"""
+        icalc = ImpactCalc(ENT.exposures, ENT.impact_funcs, HAZ)
+        impact = icalc.impact()
+        self.assertEqual(icalc.n_events, len(impact.at_event))
+        self.assertEqual(0, impact.at_event[0])
+        self.assertEqual(0, impact.at_event[7225])
+        self.assertAlmostEqual(1.472482938320243e+08, impact.at_event[13809], delta=1)
+        self.assertAlmostEqual(7.076504723057620e+10, impact.at_event[12147], delta=1)
+        self.assertEqual(0, impact.at_event[14449])
+        self.assertEqual(icalc.n_exp_pnt, len(impact.eai_exp))
+        self.assertAlmostEqual(1.518553670803242e+08, impact.eai_exp[0], delta=1)
+        self.assertAlmostEqual(1.373490457046383e+08, impact.eai_exp[25], 6)
+        self.assertAlmostEqual(1.066837260150042e+08, impact.eai_exp[49], 6)
+        self.assertAlmostEqual(6.570532945599105e+11, impact.tot_value)
+        self.assertAlmostEqual(6.512201157564421e+09, impact.aai_agg, 5)
 
-        # Assign centroids to exposures
-        ent.exposures.assign_centroids(hazard)
+    def test_calc_impact_save_mat_pass(self):
+        """Test compute impact with impact matrix"""
+        icalc = ImpactCalc(ENT.exposures, ENT.impact_funcs, HAZ)
+        impact = icalc.impact(save_mat=True)
 
-        # Compute the impact over the whole exposures
-        impact.calc(ent.exposures, ent.impact_funcs, hazard)
+        self.assertIsInstance(impact.imp_mat, sparse.csr_matrix)
+        self.assertEqual(impact.imp_mat.shape, (HAZ.event_id.size,
+                                                ENT.exposures.gdf.value.size))
+        np.testing.assert_array_almost_equal_nulp(
+            np.array(impact.imp_mat.sum(axis=1)).ravel(), impact.at_event, nulp=5)
+        np.testing.assert_array_almost_equal_nulp(
+            np.sum(impact.imp_mat.toarray() * impact.frequency[:, None], axis=0).reshape(-1),
+            impact.eai_exp)
 
-        # Check result
-        num_events = len(hazard.event_id)
-        num_exp = ent.exposures.gdf.shape[0]
-        # Check relative errors as well when absolute value gt 1.0e-7
-        # impact.at_event == EDS.damage in MATLAB
-        self.assertEqual(num_events, len(impact.at_event))
+        self.assertEqual(icalc.n_events, len(impact.at_event))
         self.assertEqual(0, impact.at_event[0])
-        self.assertEqual(0, impact.at_event[int(num_events / 2)])
-        self.assertAlmostEqual(1.472482938320243e+08, impact.at_event[13809])
-        self.assertAlmostEqual(7.076504723057620e+10, impact.at_event[12147])
-        self.assertEqual(0, impact.at_event[num_events - 1])
-        # impact.eai_exp == EDS.ED_at_centroid in MATLAB
-        self.assertEqual(num_exp, len(impact.eai_exp))
-        self.assertAlmostEqual(1.518553670803242e+08, impact.eai_exp[0])
-        self.assertAlmostEqual(1.373490457046383e+08, impact.eai_exp[int(num_exp / 2)], 6)
-        self.assertAlmostEqual(1.373490457046383e+08, impact.eai_exp[int(num_exp / 2)], 5)
-        self.assertAlmostEqual(1.066837260150042e+08, impact.eai_exp[num_exp - 1], 6)
-        self.assertAlmostEqual(1.066837260150042e+08, impact.eai_exp[int(num_exp - 1)], 5)
-        # impact.tot_value == EDS.Value in MATLAB
-        # impact.aai_agg == EDS.ED in MATLAB
+        self.assertEqual(0, impact.at_event[7225])
+        self.assertAlmostEqual(1.472482938320243e+08, impact.at_event[13809], delta=1)
+        self.assertAlmostEqual(7.076504723057620e+10, impact.at_event[12147], delta=1)
+        self.assertEqual(0, impact.at_event[14449])
+        self.assertEqual(icalc.n_exp_pnt, len(impact.eai_exp))
+        self.assertAlmostEqual(1.518553670803242e+08, impact.eai_exp[0], delta=1)
+        self.assertAlmostEqual(1.373490457046383e+08, impact.eai_exp[25], 6)
+        self.assertAlmostEqual(1.066837260150042e+08, impact.eai_exp[49], 6)
         self.assertAlmostEqual(6.570532945599105e+11, impact.tot_value)
         self.assertAlmostEqual(6.512201157564421e+09, impact.aai_agg, 5)
-        self.assertAlmostEqual(6.512201157564421e+09, impact.aai_agg, 5)
-
-    def test_calc_imp_mat_pass(self):
-        """Test save imp_mat"""
-        # Read default entity values
-        ent = Entity.from_excel(ENT_DEMO_TODAY)
-        ent.check()
-
-        # Read default hazard file
-        hazard = Hazard.from_mat(HAZ_TEST_MAT)
 
-        # Create impact object
-        impact = Impact()
+    def test_calc_insured_impact_pass(self):
+        """Test compute insured impact"""
+        exp = ENT.exposures.copy()
+        exp.gdf.cover /= 1e3
+        exp.gdf.deductible += 1e5
+        icalc = ImpactCalc(exp, ENT.impact_funcs, HAZ)
+        impact = icalc.insured_impact()
+        self.assertEqual(icalc.n_events, len(impact.at_event))
+        self.assertEqual(0, impact.at_event[0])
+        self.assertEqual(0, impact.at_event[7225])
+        self.assertAlmostEqual(62989686, impact.at_event[13809], delta=1)
+        self.assertAlmostEqual(657053294, impact.at_event[12147], delta=1)
+        self.assertEqual(0, impact.at_event[14449])
+        self.assertEqual(icalc.n_exp_pnt, len(impact.eai_exp))
+        self.assertAlmostEqual(3072092, impact.eai_exp[0], delta=1)
+        self.assertAlmostEqual(2778593, impact.eai_exp[25], delta=1)
+        self.assertAlmostEqual(2716548, impact.eai_exp[49], delta=1)
+        self.assertAlmostEqual(6.570532945599105e+11, impact.tot_value)
+        self.assertAlmostEqual(143180396, impact.aai_agg, delta=1)
 
-        # Assign centroids to exposures
-        ent.exposures.assign_centroids(hazard)
+    def test_calc_insured_impact_save_mat_pass(self):
+        """Test compute impact with impact matrix"""
+        exp = ENT.exposures.copy()
+        exp.gdf.cover /= 1e3
+        exp.gdf.deductible += 1e5
+        icalc = ImpactCalc(exp, ENT.impact_funcs, HAZ)
+        impact = icalc.insured_impact(save_mat=True)
 
-        # Compute the impact over the whole exposures
-        impact.calc(ent.exposures, ent.impact_funcs, hazard, save_mat=True)
         self.assertIsInstance(impact.imp_mat, sparse.csr_matrix)
-        self.assertEqual(impact.imp_mat.shape, (hazard.event_id.size,
-                                                ent.exposures.gdf.value.size))
+        self.assertEqual(impact.imp_mat.shape, (HAZ.event_id.size,
+                                                ENT.exposures.gdf.value.size))
         np.testing.assert_array_almost_equal_nulp(
             np.array(impact.imp_mat.sum(axis=1)).ravel(), impact.at_event, nulp=5)
         np.testing.assert_array_almost_equal_nulp(
             np.sum(impact.imp_mat.toarray() * impact.frequency[:, None], axis=0).reshape(-1),
             impact.eai_exp)
 
-    def test_calc_impf_pass(self):
-        """Execute when no impf_HAZ present, but only impf_"""
-        ent = Entity.from_excel(ENT_DEMO_TODAY)
-        self.assertTrue('impf_TC' in ent.exposures.gdf.columns)
-        ent.exposures.gdf.rename(columns={'impf_TC': 'impf_'}, inplace=True)
-        self.assertFalse('impf_TC' in ent.exposures.gdf.columns)
-        ent.check()
-
-        # Read default hazard file
-        hazard = Hazard.from_mat(HAZ_TEST_MAT)
-
-        # Create impact object
-        impact = Impact()
-        impact.calc(ent.exposures, ent.impact_funcs, hazard)
-
-        # Check result
-        num_events = len(hazard.event_id)
-        num_exp = ent.exposures.gdf.shape[0]
-        # Check relative errors as well when absolute value gt 1.0e-7
-        # impact.at_event == EDS.damage in MATLAB
-        self.assertEqual(num_events, len(impact.at_event))
+        self.assertEqual(icalc.n_events, len(impact.at_event))
         self.assertEqual(0, impact.at_event[0])
-        self.assertEqual(0, impact.at_event[int(num_events / 2)])
-        self.assertAlmostEqual(1.472482938320243e+08, impact.at_event[13809])
-        self.assertEqual(7.076504723057620e+10, impact.at_event[12147])
-        self.assertEqual(0, impact.at_event[num_events - 1])
-        # impact.eai_exp == EDS.ED_at_centroid in MATLAB
-        self.assertEqual(num_exp, len(impact.eai_exp))
-        self.assertAlmostEqual(1.518553670803242e+08, impact.eai_exp[0])
-        self.assertAlmostEqual(1.373490457046383e+08, impact.eai_exp[int(num_exp / 2)], 6)
-        self.assertAlmostEqual(1.373490457046383e+08, impact.eai_exp[int(num_exp / 2)], 5)
-        self.assertAlmostEqual(1.066837260150042e+08, impact.eai_exp[num_exp - 1], 6)
-        self.assertAlmostEqual(1.066837260150042e+08, impact.eai_exp[int(num_exp - 1)], 5)
-        # impact.tot_value == EDS.Value in MATLAB
-        # impact.aai_agg == EDS.ED in MATLAB
+        self.assertEqual(0, impact.at_event[7225])
+        self.assertAlmostEqual(62989686, impact.at_event[13809], delta=1)
+        self.assertAlmostEqual(657053294, impact.at_event[12147], delta=1)
+        self.assertEqual(0, impact.at_event[14449])
+        self.assertEqual(icalc.n_exp_pnt, len(impact.eai_exp))
+        self.assertAlmostEqual(3072092, impact.eai_exp[0], delta=1)
+        self.assertAlmostEqual(2778593, impact.eai_exp[25], delta=1)
+        self.assertAlmostEqual(2716548, impact.eai_exp[49], delta=1)
         self.assertAlmostEqual(6.570532945599105e+11, impact.tot_value)
-        self.assertAlmostEqual(6.512201157564421e+09, impact.aai_agg, 5)
-        self.assertAlmostEqual(6.512201157564421e+09, impact.aai_agg, 5)
-
+        self.assertAlmostEqual(143180396, impact.aai_agg, delta=1)
+
+    def test_calc_insured_impact_fail(self):
+        """Test raise error for insured impact calc if no cover and
+        no deductibles defined
+        """
+        exp = ENT.exposures.copy()
+        exp.gdf = exp.gdf.drop(columns = ['cover', 'deductible'])
+        icalc = ImpactCalc(exp, ENT.impact_funcs, HAZ)
+        with self.assertRaises(AttributeError):
+            icalc.insured_impact()
+
+    def test_minimal_exp_gdf(self):
+        """Test obtain minimal exposures gdf"""
+        icalc = ImpactCalc(ENT.exposures, ENT.impact_funcs, HAZ)
+        exp_min_gdf = icalc.minimal_exp_gdf('impf_TC')
+        self.assertSetEqual(
+            set(exp_min_gdf.columns), set(['value', 'impf_TC', 'centr_TC'])
+            )
+        np.testing.assert_array_equal(exp_min_gdf.value, ENT.exposures.gdf.value)
+        np.testing.assert_array_equal(exp_min_gdf.impf_TC, ENT.exposures.gdf.impf_TC)
+        np.testing.assert_array_equal(exp_min_gdf.centr_TC, ENT.exposures.gdf.centr_TC)
 
 
 # Execute Tests
 if __name__ == "__main__":
     TESTS = unittest.TestLoader().loadTestsFromTestCase(TestImpactCalc)
-    TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestCalc))
     unittest.TextTestRunner(verbosity=2).run(TESTS)

From 41eb14e6ac62877e0516a36de8d73dcbcabd783c Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 9 Jun 2022 21:00:00 +0200
Subject: [PATCH 055/121] Remove calc tests

---
 climada/engine/test/test_impact.py | 125 +----------------------------
 1 file changed, 2 insertions(+), 123 deletions(-)

diff --git a/climada/engine/test/test_impact.py b/climada/engine/test/test_impact.py
index 3a9ac72fd..419250cae 100644
--- a/climada/engine/test/test_impact.py
+++ b/climada/engine/test/test_impact.py
@@ -26,7 +26,7 @@
 from climada.hazard.tag import Tag as TagHaz
 from climada.entity.entity_def import Entity
 from climada.hazard.base import Hazard
-from climada.engine.impact import Impact, ImpactCalc
+from climada.engine.impact import Impact
 from climada.util.constants import ENT_DEMO_TODAY, DEF_CRS, DEMO_DIR
 from climada.util.api_client import Client
 import climada.util.coordinates as u_coord
@@ -52,125 +52,6 @@ def get_haz_test_file(ds_name):
 DATA_FOLDER.mkdir(exist_ok=True)
 
 
-class TestImpactCalc(unittest.TestCase):
-    """Test Impact calc methods"""
-    def test_init(self):
-        icalc = ImpactCalc(ENT.exposures, ENT.impact_funcs, HAZ)
-        self.assertEqual(icalc.n_exp_pnt, ENT.exposures.gdf.shape[0])
-        self.assertEqual(icalc.n_events, HAZ.size)
-        np.testing.assert_array_equal(icalc.deductible, ENT.exposures.gdf.deductible)
-
-class TestCalc(unittest.TestCase):
-    """Test impact calc method."""
-
-    def test_ref_value_pass(self):
-        """Test result against reference value"""
-        # Read default entity values
-        ent = Entity.from_excel(ENT_DEMO_TODAY)
-        ent.check()
-
-        # Read default hazard file
-        hazard = Hazard.from_mat(HAZ_TEST_MAT)
-
-        # Create impact object
-        impact = Impact()
-
-        # Assign centroids to exposures
-        ent.exposures.assign_centroids(hazard)
-
-        # Compute the impact over the whole exposures
-        impact.calc(ent.exposures, ent.impact_funcs, hazard)
-
-        # Check result
-        num_events = len(hazard.event_id)
-        num_exp = ent.exposures.gdf.shape[0]
-        # Check relative errors as well when absolute value gt 1.0e-7
-        # impact.at_event == EDS.damage in MATLAB
-        self.assertEqual(num_events, len(impact.at_event))
-        self.assertEqual(0, impact.at_event[0])
-        self.assertEqual(0, impact.at_event[int(num_events / 2)])
-        self.assertAlmostEqual(1.472482938320243e+08, impact.at_event[13809])
-        self.assertAlmostEqual(7.076504723057620e+10, impact.at_event[12147])
-        self.assertEqual(0, impact.at_event[num_events - 1])
-        # impact.eai_exp == EDS.ED_at_centroid in MATLAB
-        self.assertEqual(num_exp, len(impact.eai_exp))
-        self.assertAlmostEqual(1.518553670803242e+08, impact.eai_exp[0])
-        self.assertAlmostEqual(1.373490457046383e+08, impact.eai_exp[int(num_exp / 2)], 6)
-        self.assertAlmostEqual(1.373490457046383e+08, impact.eai_exp[int(num_exp / 2)], 5)
-        self.assertAlmostEqual(1.066837260150042e+08, impact.eai_exp[num_exp - 1], 6)
-        self.assertAlmostEqual(1.066837260150042e+08, impact.eai_exp[int(num_exp - 1)], 5)
-        # impact.tot_value == EDS.Value in MATLAB
-        # impact.aai_agg == EDS.ED in MATLAB
-        self.assertAlmostEqual(6.570532945599105e+11, impact.tot_value)
-        self.assertAlmostEqual(6.512201157564421e+09, impact.aai_agg, 5)
-        self.assertAlmostEqual(6.512201157564421e+09, impact.aai_agg, 5)
-
-    def test_calc_imp_mat_pass(self):
-        """Test save imp_mat"""
-        # Read default entity values
-        ent = Entity.from_excel(ENT_DEMO_TODAY)
-        ent.check()
-
-        # Read default hazard file
-        hazard = Hazard.from_mat(HAZ_TEST_MAT)
-
-        # Create impact object
-        impact = Impact()
-
-        # Assign centroids to exposures
-        ent.exposures.assign_centroids(hazard)
-
-        # Compute the impact over the whole exposures
-        impact.calc(ent.exposures, ent.impact_funcs, hazard, save_mat=True)
-        self.assertIsInstance(impact.imp_mat, sparse.csr_matrix)
-        self.assertEqual(impact.imp_mat.shape, (hazard.event_id.size,
-                                                ent.exposures.gdf.value.size))
-        np.testing.assert_array_almost_equal_nulp(
-            np.array(impact.imp_mat.sum(axis=1)).ravel(), impact.at_event, nulp=5)
-        np.testing.assert_array_almost_equal_nulp(
-            np.sum(impact.imp_mat.toarray() * impact.frequency[:, None], axis=0).reshape(-1),
-            impact.eai_exp)
-
-    def test_calc_impf_pass(self):
-        """Execute when no impf_HAZ present, but only impf_"""
-        ent = Entity.from_excel(ENT_DEMO_TODAY)
-        self.assertTrue('impf_TC' in ent.exposures.gdf.columns)
-        ent.exposures.gdf.rename(columns={'impf_TC': 'impf_'}, inplace=True)
-        self.assertFalse('impf_TC' in ent.exposures.gdf.columns)
-        ent.check()
-
-        # Read default hazard file
-        hazard = Hazard.from_mat(HAZ_TEST_MAT)
-
-        # Create impact object
-        impact = Impact()
-        impact.calc(ent.exposures, ent.impact_funcs, hazard)
-
-        # Check result
-        num_events = len(hazard.event_id)
-        num_exp = ent.exposures.gdf.shape[0]
-        # Check relative errors as well when absolute value gt 1.0e-7
-        # impact.at_event == EDS.damage in MATLAB
-        self.assertEqual(num_events, len(impact.at_event))
-        self.assertEqual(0, impact.at_event[0])
-        self.assertEqual(0, impact.at_event[int(num_events / 2)])
-        self.assertAlmostEqual(1.472482938320243e+08, impact.at_event[13809])
-        self.assertEqual(7.076504723057620e+10, impact.at_event[12147])
-        self.assertEqual(0, impact.at_event[num_events - 1])
-        # impact.eai_exp == EDS.ED_at_centroid in MATLAB
-        self.assertEqual(num_exp, len(impact.eai_exp))
-        self.assertAlmostEqual(1.518553670803242e+08, impact.eai_exp[0])
-        self.assertAlmostEqual(1.373490457046383e+08, impact.eai_exp[int(num_exp / 2)], 6)
-        self.assertAlmostEqual(1.373490457046383e+08, impact.eai_exp[int(num_exp / 2)], 5)
-        self.assertAlmostEqual(1.066837260150042e+08, impact.eai_exp[num_exp - 1], 6)
-        self.assertAlmostEqual(1.066837260150042e+08, impact.eai_exp[int(num_exp - 1)], 5)
-        # impact.tot_value == EDS.Value in MATLAB
-        # impact.aai_agg == EDS.ED in MATLAB
-        self.assertAlmostEqual(6.570532945599105e+11, impact.tot_value)
-        self.assertAlmostEqual(6.512201157564421e+09, impact.aai_agg, 5)
-        self.assertAlmostEqual(6.512201157564421e+09, impact.aai_agg, 5)
-
-
 class TestFreqCurve(unittest.TestCase):
     """Test exceedence frequency curve computation"""
     def test_ref_value_pass(self):
@@ -768,9 +649,7 @@ def test__exp_build_event(self):
 
 # Execute Tests
 if __name__ == "__main__":
-    TESTS = unittest.TestLoader().loadTestsFromTestCase(TestImpactCalc)
-    TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestCalc))
-    TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestFreqCurve))
+    TESTS = unittest.TestLoader().loadTestsFromTestCase(TestFreqCurve)
     TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestImpactYearSet))
     TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestIO))
     TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestRPmatrix))

From c4084147837d0ed7b942cd43aa57e2e9ef9f8dcc Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 9 Jun 2022 21:10:27 +0200
Subject: [PATCH 056/121] Add test overwrite centroids flag

---
 climada/entity/exposures/base.py           | 3 +++
 climada/entity/exposures/test/test_base.py | 4 ++++
 2 files changed, 7 insertions(+)

diff --git a/climada/entity/exposures/base.py b/climada/entity/exposures/base.py
index 6f4d9b1b7..df855ff50 100644
--- a/climada/entity/exposures/base.py
+++ b/climada/entity/exposures/base.py
@@ -387,6 +387,9 @@ def assign_centroids(self, hazard, distance='euclidean',
             the index `-1` is assigned.
             Set `threshold` to 0, to disable nearest neighbor matching.
             Default: 100 (km)
+        overwrite: bool
+            If True, overwrite centroids already present. If False, do
+            not assign new centroids. Default is True.
 
         See Also
         --------
diff --git a/climada/entity/exposures/test/test_base.py b/climada/entity/exposures/test/test_base.py
index c4d800bf7..962571dd2 100644
--- a/climada/entity/exposures/test/test_base.py
+++ b/climada/entity/exposures/test/test_base.py
@@ -79,6 +79,10 @@ def test_assign_pass(self):
             exp.assign_centroids(haz)
             self.assertEqual(exp.gdf.shape[0], len(exp.gdf[INDICATOR_CENTR + 'FL']))
             np.testing.assert_array_equal(exp.gdf[INDICATOR_CENTR + 'FL'].values, expected_result)
+            exp.assign_centroids(Hazard(), overwrite=False)
+            self.assertEqual(exp.gdf.shape[0], len(exp.gdf[INDICATOR_CENTR + 'FL']))
+            np.testing.assert_array_equal(exp.gdf[INDICATOR_CENTR + 'FL'].values, expected_result)
+
 
     def test_read_raster_pass(self):
         """from_raster"""

From 4598f13afb5584d78297d144780e46247999a8c3 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 9 Jun 2022 21:29:22 +0200
Subject: [PATCH 057/121] Remove warning for impf nonzero at zero

---
 climada/entity/impact_funcs/base.py | 15 ---------------
 climada/hazard/base.py              |  7 ++++---
 2 files changed, 4 insertions(+), 18 deletions(-)

diff --git a/climada/entity/impact_funcs/base.py b/climada/entity/impact_funcs/base.py
index 41742c29a..3d4fe8acf 100644
--- a/climada/entity/impact_funcs/base.py
+++ b/climada/entity/impact_funcs/base.py
@@ -128,21 +128,6 @@ def check(self):
                            " intensity.", self.haz_type, self.name, self.id)
             return
 
-        # Warning for non-vanishing impact at intensity 0. If positive
-        # and negative intensity warning for interpolation at intensity 0.
-        # zero_idx = np.where(self.intensity == 0)[0]
-        # if zero_idx.size != 0:
-        #     if self.mdd[zero_idx[0]] != 0 or self.paa[zero_idx[0]] != 0:
-        #         LOGGER.warning('For intensity = 0, mdd != 0 or paa != 0. '
-        #                        'Consider shifting the origin of the intensity '
-        #                        'scale. In impact.calc the impact is always '
-        #                        'null at intensity = 0.')
-        if self.intensity[0] < 0 and self.intensity[-1] > 0:
-            LOGGER.warning('Impact function might be interpolated to non-zero'
-                           ' value at intensity = 0. Consider shifting the '
-                           'origin of the intensity scale. In impact.calc '
-                           'the impact is always null at intensity = 0.')
-
     @classmethod
     def from_step_impf(cls, intensity, mdd=(0, 1), paa=(1, 1), impf_id=1):
 
diff --git a/climada/hazard/base.py b/climada/hazard/base.py
index 3d94c4a86..379c38e75 100644
--- a/climada/hazard/base.py
+++ b/climada/hazard/base.py
@@ -1811,7 +1811,7 @@ def get_mdr(self, cent_idx, impf):
             sparse matrix (n_events x len(cent_idx)) with mdr values
 
         """
-        uniq_cent_idx, indices = np.unique(cent_idx, return_inverse=True)      #costs about 30ms for small datasets
+        uniq_cent_idx, indices = np.unique(cent_idx, return_inverse=True)
         mdr = self.intensity[:, uniq_cent_idx]
         if impf.calc_mdr(0) == 0:
             mdr.data = impf.calc_mdr(mdr.data)
@@ -1820,11 +1820,12 @@ def get_mdr(self, cent_idx, impf):
             "The mean damage ratio must thus be computed for all values of"
             "hazard intensity including 0 which can be very time consuming.",
             impf.id)
-            raise NotImplementedError("Not yet implemented.")
+            mdr_array = impf.calc_mdr(mdr.toarray().ravel())
+            mdr = sparse.csr_matrix(mdr_array, shape=mdr.shape)
         return mdr[:, indices]
 
     def get_paa(self, cent_idx, impf):
-        uniq_cent_idx, indices = np.unique(cent_idx, return_inverse=True)      #costs about 30ms for small datasets
+        uniq_cent_idx, indices = np.unique(cent_idx, return_inverse=True)
         paa = self.intensity[:, uniq_cent_idx]
         paa.data = np.interp(paa.data, impf.intensity, impf.paa)
         return paa[:, indices]

From 3b34df9990de0a9e26ddd1f59f75b215fd42785e Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Thu, 9 Jun 2022 21:37:01 +0200
Subject: [PATCH 058/121] Add docstrings

---
 climada/hazard/base.py | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/climada/hazard/base.py b/climada/hazard/base.py
index 379c38e75..8b6ecdc71 100644
--- a/climada/hazard/base.py
+++ b/climada/hazard/base.py
@@ -1786,11 +1786,30 @@ def change_centroids(self, centroids, threshold=NEAREST_NEIGHBOR_THRESHOLD):
 
     @property
     def cent_exp_col(self):
+        """
+        Name of the centroids columns for this hazard in an exposures
+
+        Returns
+        -------
+        String
+            centroids string indicator with hazard type defining column
+            in an exposures gdf. E.g. "centr_TC"
+
+        """
         from climada.entity.exposures import INDICATOR_CENTR
         return INDICATOR_CENTR + self.tag.haz_type
 
     @property
     def haz_type(self):
+        """
+        Hazard type
+
+        Returns
+        -------
+        String
+            Two-letters hazard type string. E.g. "TC", "RF", or "WF"
+
+        """
         return self.tag.haz_type
 
     def get_mdr(self, cent_idx, impf):
@@ -1825,6 +1844,23 @@ def get_mdr(self, cent_idx, impf):
         return mdr[:, indices]
 
     def get_paa(self, cent_idx, impf):
+        """
+        Return Percentage of Affected Assets (paa) for chosen centroids (cent_idx)
+        for given impact function.
+
+        Parameters
+        ----------
+        cent_idx : array-like
+            array of indices of chosen centroids from hazard
+        impf : ImpactFunc
+            impact function to compute mdr
+
+        Returns
+        -------
+        sparse.csr_matrix
+            sparse matrix (n_events x len(cent_idx)) with paa values
+
+        """
         uniq_cent_idx, indices = np.unique(cent_idx, return_inverse=True)
         paa = self.intensity[:, uniq_cent_idx]
         paa.data = np.interp(paa.data, impf.intensity, impf.paa)

From a32de31e32489912a685099edc4e35e920359d16 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Fri, 10 Jun 2022 12:09:54 +0200
Subject: [PATCH 059/121] Update test precision to account for different
 floating number

---
 climada/engine/test/test_cost_benefit.py | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/climada/engine/test/test_cost_benefit.py b/climada/engine/test/test_cost_benefit.py
index a26a46b0d..33cb7da84 100644
--- a/climada/engine/test/test_cost_benefit.py
+++ b/climada/engine/test/test_cost_benefit.py
@@ -323,10 +323,10 @@ def test_calc_cb_change_pass(self):
         self.assertAlmostEqual(cost_ben.imp_meas_future['Building code']['risk'],
                                4.462999483999791e+10, places=3)
 
-        self.assertAlmostEqual(cost_ben.benefit['Mangroves'], 113345027690.81276, places=3)
-        self.assertAlmostEqual(cost_ben.benefit['Beach nourishment'], 89444869971.53653, places=3)
-        self.assertAlmostEqual(cost_ben.benefit['Seawall'], 347977469896.1333, places=3)
-        self.assertAlmostEqual(cost_ben.benefit['Building code'], 144216478822.05154, places=3)
+        self.assertAlmostEqual(cost_ben.benefit['Mangroves'], 113345027690.81276, places=2)
+        self.assertAlmostEqual(cost_ben.benefit['Beach nourishment'], 89444869971.53653, places=2)
+        self.assertAlmostEqual(cost_ben.benefit['Seawall'], 347977469896.1333, places=2)
+        self.assertAlmostEqual(cost_ben.benefit['Building code'], 144216478822.05154, places=2)
 
         self.assertAlmostEqual(cost_ben.cost_ben_ratio['Mangroves'], 0.011573232523528404)
         self.assertAlmostEqual(cost_ben.cost_ben_ratio['Beach nourishment'], 0.01931916274851638)
@@ -772,10 +772,10 @@ def test_calc_change_pass(self):
         self.assertAlmostEqual(cost_ben.imp_meas_future['Building code']['risk'],
                                4.462999483999791e+10, places=3)
 
-        self.assertAlmostEqual(cost_ben.benefit['Mangroves'], 113345027690.81276, places=3)
-        self.assertAlmostEqual(cost_ben.benefit['Beach nourishment'], 89444869971.53653, places=3)
-        self.assertAlmostEqual(cost_ben.benefit['Seawall'], 347977469896.1333, places=3)
-        self.assertAlmostEqual(cost_ben.benefit['Building code'], 144216478822.05154, places=3)
+        self.assertAlmostEqual(cost_ben.benefit['Mangroves'], 113345027690.81276, places=2)
+        self.assertAlmostEqual(cost_ben.benefit['Beach nourishment'], 89444869971.53653, places=2)
+        self.assertAlmostEqual(cost_ben.benefit['Seawall'], 347977469896.1333, places=2)
+        self.assertAlmostEqual(cost_ben.benefit['Building code'], 144216478822.05154, places=2)
 
         self.assertAlmostEqual(cost_ben.cost_ben_ratio['Mangroves'], 0.011573232523528404)
         self.assertAlmostEqual(cost_ben.cost_ben_ratio['Beach nourishment'], 0.01931916274851638)

From 7f810525e5dff9cd3107ab290b16291cf0b914ad Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Fri, 10 Jun 2022 12:10:15 +0200
Subject: [PATCH 060/121] Fix bug in insure mat

---
 climada/engine/impact_calc.py             | 10 +++++-----
 climada/entity/measures/test/test_base.py |  2 +-
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index e93bfd73b..e9d708181 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -174,8 +174,8 @@ def insured_impact(self, save_mat=False):
         if self.imp_mat.size == 0:
             imp_mat_gen = self.imp_mat_gen(exp_gdf, impf_col)
         else:
-            imp_mat_gen = ((self.imp_mat, self.exposures.gdf.index.values) for n in range(1))
-        ins_mat_gen = self.insured_mat_gen(imp_mat_gen, impf_col)
+            imp_mat_gen = ((self.imp_mat, np.arange(1, len(exp_gdf))) for n in range(1))
+        ins_mat_gen = self.insured_mat_gen(imp_mat_gen, exp_gdf, impf_col)
         return self._return_impact(ins_mat_gen, save_mat)
 
     def _return_impact(self, imp_mat_gen, save_mat):
@@ -251,15 +251,15 @@ def imp_mat_gen(self, exp_gdf, impf_col):
                 cent_idx = exp_gdf[self.hazard.cent_exp_col].values[exp_idx]
                 yield (self.impact_matrix(exp_values, cent_idx, impf), exp_idx)
 
-    def insured_mat_gen(self, imp_mat_gen, impf_col):
+    def insured_mat_gen(self, imp_mat_gen, exp_gdf, impf_col):
         """
         Generator of insured impact sub-matrices (with applied cover and deductible)
         and corresponding exposures indices
         """
         for mat, exp_idx in imp_mat_gen:
-            impf_id = self.exposures.gdf[impf_col][exp_idx].unique()[0]
+            impf_id = exp_gdf[impf_col][exp_idx].unique()[0]
             deductible = self.deductible[exp_idx]
-            cent_idx = self.exposures.gdf['centr_TC'][exp_idx]
+            cent_idx = exp_gdf[self.hazard.cent_exp_col].values[exp_idx]
             impf = self.impfset.get_func(haz_type=self.hazard.haz_type, fun_id=impf_id)
             mat = self.apply_deductible_to_mat(mat, deductible, self.hazard, cent_idx, impf)
             cover = self.cover[exp_idx]
diff --git a/climada/entity/measures/test/test_base.py b/climada/entity/measures/test/test_base.py
index bc002ac0f..17e0451cc 100644
--- a/climada/entity/measures/test/test_base.py
+++ b/climada/entity/measures/test/test_base.py
@@ -385,7 +385,7 @@ def test_calc_impact_pass(self):
         imp, risk_transf = entity.measures.get_measure('TC', 'Mangroves').calc_impact(
                 entity.exposures, entity.impact_funcs, hazard)
 
-        self.assertAlmostEqual(imp.aai_agg, 4.850407096284983e+09)
+        self.assertAlmostEqual(imp.aai_agg, 4.850407096284983e+09, delta=1)
         self.assertAlmostEqual(imp.at_event[0], 0)
         self.assertAlmostEqual(imp.at_event[12], 1.470194187501225e+07)
         self.assertAlmostEqual(imp.at_event[41], 4.7226357936631286e+08)

From e0a6a0adb4c4f0dfb958a331ee333746a9ce9cf4 Mon Sep 17 00:00:00 2001
From: Lukas Riedel <34276446+peanutfun@users.noreply.github.com>
Date: Fri, 10 Jun 2022 16:32:42 +0200
Subject: [PATCH 061/121] Make 'imp_mat' an empty matrix by default

* Use empty csr matrix instead of 'None' as default argument for
  'imp_mat' in 'Impact' and 'ImpactCalc'.
* Consistently check for matrix contents via its 'size' attribute.
---
 climada/engine/impact.py      | 27 ++++++++++++---------------
 climada/engine/impact_calc.py |  5 ++---
 2 files changed, 14 insertions(+), 18 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index a2d2ebd1b..3b275663b 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -95,7 +95,7 @@ def __init__(self,
                  tot_value=0,
                  aai_agg=0,
                  unit='',
-                 imp_mat=None,
+                 imp_mat=sparse.csr_matrix((0, 0)),
                  tag=None):
 
         self.tag = tag or {}
@@ -110,7 +110,7 @@ def __init__(self,
         self.tot_value = tot_value
         self.aai_agg = aai_agg
         self.unit = unit
-        self.imp_mat = sparse.csr_matrix(np.empty((0, 0))) if imp_mat is None else imp_mat
+        self.imp_mat = imp_mat
 
     def calc(self, exposures, impact_funcs, hazard, save_mat=False):
         """This function is deprecated, use ImpactCalc.impact
@@ -133,7 +133,7 @@ def calc(self, exposures, impact_funcs, hazard, save_mat=False):
 #TODO: new name
     @classmethod
     def from_eih(cls, exposures, impfset, hazard,
-                 at_event, eai_exp, aai_agg, imp_mat=None):
+                 at_event, eai_exp, aai_agg, imp_mat=sparse.csr_matrix((0, 0))):
         """
         Set Impact attributes from precalculated impact metrics.
 
@@ -147,14 +147,13 @@ def from_eih(cls, exposures, impfset, hazard,
             hazard used to compute imp_mat
         imp_mat : sparse.csr_matrix
             matrix num_events x num_exp with impacts.
-            Default is None (empty sparse csr matrix)
+            Default is empty sparse csr matrix.
 
         Returns
         -------
         climada.engine.impact.Impact
             impact with all risk metrics set based on the given impact matrix
         """
-        imp_mat = sparse.csr_matrix(np.empty((0, 0))) if imp_mat is None else imp_mat
         return cls(
             event_id = hazard.event_id,
             event_name = hazard.event_name,
@@ -257,7 +256,7 @@ def calc_risk_transfer(self, attachment, cover):
             # next values are no longer valid
             new_imp.eai_exp = np.array([])
             new_imp.coord_exp = np.array([])
-            new_imp.imp_mat = sparse.csr_matrix(np.empty((0, 0)))
+            new_imp.imp_mat = sparse.csr_matrix((0, 0))
             # insurance layer metrics
             risk_transfer = copy.deepcopy(new_imp)
             risk_transfer.at_event = imp_layer
@@ -329,11 +328,9 @@ def local_exceedance_imp(self, return_periods=(25, 50, 100, 250)):
         """
         LOGGER.info('Computing exceedance impact map for return periods: %s',
                     return_periods)
-        try:
-            self.imp_mat.shape[1]
-        except AttributeError as err:
-            raise ValueError('attribute imp_mat is empty. Recalculate Impact'
-                             'instance with parameter save_mat=True') from err
+        if self.imp_mat.size == 0:
+            raise ValueError('Attribute imp_mat is empty. Recalculate Impact'
+                             'instance with parameter save_mat=True')
         num_cen = self.imp_mat.shape[1]
         imp_stats = np.zeros((len(return_periods), num_cen))
         cen_step = CONFIG.max_matrix_size.int() // self.imp_mat.shape[0]
@@ -578,8 +575,8 @@ def plot_hexbin_impact_exposure(self, event_id=1, mask=None, ignore_zero=False,
         --------
             matplotlib.figure.Figure, cartopy.mpl.geoaxes.GeoAxesSubplot
         """
-        if not hasattr(self.imp_mat, "shape") or self.imp_mat.shape[1] == 0:
-            raise ValueError('attribute imp_mat is empty. Recalculate Impact'
+        if self.imp_mat.size == 0:
+            raise ValueError('Attribute imp_mat is empty. Recalculate Impact'
                              'instance with parameter save_mat=True')
         if 'cmap' not in kwargs:
             kwargs['cmap'] = CMAP_IMPACT
@@ -627,8 +624,8 @@ def plot_basemap_impact_exposure(self, event_id=1, mask=None, ignore_zero=False,
         -------
         cartopy.mpl.geoaxes.GeoAxesSubplot
         """
-        if not hasattr(self.imp_mat, "shape") or self.imp_mat.shape[1] == 0:
-            raise ValueError('attribute imp_mat is empty. Recalculate Impact'
+        if self.imp_mat.size == 0:
+            raise ValueError('Attribute imp_mat is empty. Recalculate Impact'
                              'instance with parameter save_mat=True')
 
         if event_id not in self.event_id:
diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index e9d708181..4ecc13c4a 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -40,7 +40,7 @@ def __init__(self,
                  exposures,
                  impfset,
                  hazard,
-                 imp_mat=None):
+                 imp_mat=sparse.csr_matrix((0, 0))):
         """
         Initialize an ImpactCalc object.
 
@@ -65,7 +65,6 @@ def __init__(self,
 
         """
 
-        imp_mat = sparse.csr_matrix(np.empty((0, 0))) if imp_mat is None else imp_mat
         self.exposures = exposures
         self.impfset = impfset
         self.hazard = hazard
@@ -457,4 +456,4 @@ def risk_metrics(cls, mat, freq):
         eai_exp = cls.eai_exp_from_mat(mat, freq)
         at_event = cls.at_event_from_mat(mat)
         aai_agg = cls.aai_agg_from_eai_exp(eai_exp)
-        return at_event, eai_exp, aai_agg
\ No newline at end of file
+        return at_event, eai_exp, aai_agg

From 90536e4e96fd67756fcfc0584e4e5a8efcf02d46 Mon Sep 17 00:00:00 2001
From: Lukas Riedel <34276446+peanutfun@users.noreply.github.com>
Date: Fri, 10 Jun 2022 17:50:15 +0200
Subject: [PATCH 062/121] Avoid mutables in Impact and ImpactCalc signatures

---
 climada/engine/impact.py      | 8 ++++----
 climada/engine/impact_calc.py | 4 ++--
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index e3d9bd1ad..13c84c581 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -95,7 +95,7 @@ def __init__(self,
                  tot_value=0,
                  aai_agg=0,
                  unit='',
-                 imp_mat=sparse.csr_matrix((0, 0)),
+                 imp_mat=None,
                  tag=None):
 
         self.tag = tag or {}
@@ -110,7 +110,7 @@ def __init__(self,
         self.tot_value = tot_value
         self.aai_agg = aai_agg
         self.unit = unit
-        self.imp_mat = imp_mat
+        self.imp_mat = imp_mat if imp_mat is not None else sparse.csr_matrix((0, 0))
 
     def calc(self, exposures, impact_funcs, hazard, save_mat=False):
         """This function is deprecated, use ImpactCalc.impact
@@ -133,7 +133,7 @@ def calc(self, exposures, impact_funcs, hazard, save_mat=False):
 #TODO: new name
     @classmethod
     def from_eih(cls, exposures, impfset, hazard,
-                 at_event, eai_exp, aai_agg, imp_mat=sparse.csr_matrix((0, 0))):
+                 at_event, eai_exp, aai_agg, imp_mat=None):
         """
         Set Impact attributes from precalculated impact metrics.
 
@@ -168,7 +168,7 @@ def from_eih(cls, exposures, impfset, hazard,
             eai_exp = eai_exp,
             at_event = at_event,
             aai_agg = aai_agg,
-            imp_mat = imp_mat,
+            imp_mat = imp_mat if imp_mat is not None else sparse.csr_matrix((0, 0)),
             tag = {'exp': exposures.tag,
                    'impf_set': impfset.tag,
                    'haz': hazard.tag
diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index 4ecc13c4a..e71b519fe 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -40,7 +40,7 @@ def __init__(self,
                  exposures,
                  impfset,
                  hazard,
-                 imp_mat=sparse.csr_matrix((0, 0))):
+                 imp_mat=None):
         """
         Initialize an ImpactCalc object.
 
@@ -68,7 +68,7 @@ def __init__(self,
         self.exposures = exposures
         self.impfset = impfset
         self.hazard = hazard
-        self.imp_mat = imp_mat
+        self.imp_mat = imp_mat if imp_mat is not None else sparse.csr_matrix((0, 0))
         self.n_exp_pnt = self.exposures.gdf.shape[0]
         self.n_events = self.hazard.size
 

From a54eb333fffd2976febbd682d0908ca7edb9344c Mon Sep 17 00:00:00 2001
From: Lukas Riedel <34276446+peanutfun@users.noreply.github.com>
Date: Fri, 10 Jun 2022 18:00:28 +0200
Subject: [PATCH 063/121] Add test case for ImpactCalc.impact_matrix

Use unittest.mock to mock behavior of hazard object.
---
 climada/engine/test/test_impact_calc.py | 44 +++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/climada/engine/test/test_impact_calc.py b/climada/engine/test/test_impact_calc.py
index 6a8cc3a7a..cff94c680 100644
--- a/climada/engine/test/test_impact_calc.py
+++ b/climada/engine/test/test_impact_calc.py
@@ -19,6 +19,7 @@
 Test Impact class.
 """
 import unittest
+import unittest.mock
 import numpy as np
 from scipy import sparse
 
@@ -209,7 +210,50 @@ def test_minimal_exp_gdf(self):
         np.testing.assert_array_equal(exp_min_gdf.centr_TC, ENT.exposures.gdf.centr_TC)
 
 
+class TestImpactMatrixCalc(unittest.TestCase):
+    """Verify the computation of the impact matrix"""
+
+    def setUp(self):
+        # Mock the methods called by 'impact_matrix'
+        self.hazard = unittest.mock.create_autospec(HAZ)
+        self.hazard.get_mdr.return_value = sparse.csr_matrix(
+            [[0.0, 0.5, -1.0], [1.0, 2.0, 1.0]]
+        )
+        self.hazard.get_fraction.return_value = sparse.csr_matrix(
+            [[1.0, 1.0, 1.0], [-0.5, 0.5, 2.0]]
+        )
+        self.exposure_values = np.array([10.0, 20.0, -30.0])
+        self.centroids = np.array([1, 2, 4])
+        self.icalc = ImpactCalc(ENT.exposures, ENT.impact_funcs, self.hazard)
+
+    def test_correct_calculation(self):
+        """Assert that the calculation of the impact matrix is correct"""
+        impact_matrix = self.icalc.impact_matrix(
+            self.exposure_values, self.centroids, ENT.impact_funcs
+        )
+        np.testing.assert_array_equal(
+            impact_matrix.toarray(), [[0.0, 10.0, 30.0], [-5.0, 20.0, -60.0]]
+        )
+
+        # Check if hazard methods were called with expected arguments
+        with self.subTest("Internal call to hazard instance"):
+            self.hazard.get_mdr.assert_called_once_with(
+                self.centroids, ENT.impact_funcs
+            )
+            self.hazard.get_fraction.assert_called_once_with(self.centroids)
+
+    def test_wrong_sizes(self):
+        """Calling 'impact_matrix' with wrongly sized argument results in errors"""
+        centroids = np.array([1, 2, 4, 5])  # Too long
+        with self.assertRaises(ValueError):
+            self.icalc.impact_matrix(self.exposure_values, centroids, ENT.impact_funcs)
+        exposure_values = np.array([1.0])  # Too short
+        with self.assertRaises(ValueError):
+            self.icalc.impact_matrix(exposure_values, self.centroids, ENT.impact_funcs)
+
+
 # Execute Tests
 if __name__ == "__main__":
     TESTS = unittest.TestLoader().loadTestsFromTestCase(TestImpactCalc)
+    TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestImpactMatrixCalc))
     unittest.TextTestRunner(verbosity=2).run(TESTS)

From 84f82450ec1b3405d9800db1fbddf2f41e2d459b Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Sat, 11 Jun 2022 18:22:32 +0200
Subject: [PATCH 064/121] Add input attribute consistency checks to init

---
 climada/engine/impact.py | 78 +++++++++++++++++++++++++++++++++++++---
 1 file changed, 74 insertions(+), 4 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index a2d2ebd1b..f819fc3f5 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -56,9 +56,9 @@ class Impact():
     tag : dict
         dictionary of tags of exposures, impact functions set and
         hazard: {'exp': Tag(), 'impf_set': Tag(), 'haz': TagHazard()}
-    event_id :
-        np.array id (>0) of each hazard event
-    event_name :
+    event_id : np.array
+        id (>0) of each hazard event
+    event_name : list
         list name of each hazard event
     date : np.array
         date if events as integer date corresponding to the
@@ -97,6 +97,41 @@ def __init__(self,
                  unit='',
                  imp_mat=None,
                  tag=None):
+        """
+        Init Impact object
+
+        Attributes
+        ----------
+        tag : dict
+            dictionary of tags of exposures, impact functions set and
+            hazard: {'exp': Tag(), 'impf_set': Tag(), 'haz': TagHazard()}
+        event_id : np.array
+            id (>0) of each hazard event
+        event_name : list
+            list name of each hazard event
+        date : np.array
+            date if events as integer date corresponding to the
+            proleptic Gregorian ordinal, where January 1 of year 1 has
+            ordinal 1 (ordinal format of datetime library)
+        coord_exp : np.array
+            exposures coordinates [lat, lon] (in degrees)
+        eai_exp : np.array
+            expected annual impact for each exposure
+        at_event : np.array
+            impact for each hazard event
+        frequency : np.array
+            annual frequency of event
+        tot_value : float
+            total exposure value affected
+        aai_agg : float
+            average annual impact (aggregated)
+        unit : str
+            value unit used (given by exposures unit)
+        imp_mat : sparse.csr_matrix
+            matrix num_events x num_exp with impacts.
+            only filled if save_mat is True in calc()
+
+        """
 
         self.tag = tag or {}
         self.event_id = np.array([], int) if event_id is None else event_id
@@ -110,7 +145,42 @@ def __init__(self,
         self.tot_value = tot_value
         self.aai_agg = aai_agg
         self.unit = unit
-        self.imp_mat = sparse.csr_matrix(np.empty((0, 0))) if imp_mat is None else imp_mat
+
+        if len(event_id) != len(event_name):
+            raise AttributeError('Hazard event ids and event names'
+                                 ' are not of the same length')
+        if len(event_id) != len(date):
+            raise AttributeError('Hazard event ids and event dates'
+                             ' are not of the same length')
+        if len(event_id) != len(frequency):
+            raise AttributeError('Hazard event ids and event frequency'
+                                 ' are not of the same length')
+        if len(event_id) != len(at_event):
+            raise AttributeError('Number of hazard event ids different '
+                                 'from number of at_event values')
+        if len(coord_exp) != len(eai_exp):
+            raise AttributeError('Number of exposures points different from'
+                                 'number of eai_exp values')
+        if imp_mat is not None:
+            self.imp_mat = imp_mat
+            if len(event_id) != imp_mat.shape[0]:
+                raise AttributeError(
+                    f'The number of rows {imp_mat.shape[0]} of the impact '
+                    'matrix is inconsistent with the number {len(event_id} '
+                    'of hazard events.')
+            if len(coord_exp) != imp_mat.shape[1]:
+                raise AttributeError(
+                    'The number of columns {imp_mat.shape[1]} of the impact'
+                    ' matrix is inconsistent with the number {len(coord_exp)}'
+                    ' exposures points.')
+        else:
+            self.imp_mat = sparse.csr_matrix(np.empty((0, 0)))
+
+        if np.sum(eai_exp) != aai_agg:
+            raise AttributeError('The aai_agg value does not correspond'
+                                 'to the sum of eai_exp.')
+
+
 
     def calc(self, exposures, impact_funcs, hazard, save_mat=False):
         """This function is deprecated, use ImpactCalc.impact

From 0d17a90163200b3a1fa16ea86a33597dae7e8c55 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Sat, 11 Jun 2022 18:23:08 +0200
Subject: [PATCH 065/121] Add unfinished impact init test

---
 climada/engine/test/test_impact.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/climada/engine/test/test_impact.py b/climada/engine/test/test_impact.py
index 419250cae..effc11df0 100644
--- a/climada/engine/test/test_impact.py
+++ b/climada/engine/test/test_impact.py
@@ -51,6 +51,10 @@ def get_haz_test_file(ds_name):
 DATA_FOLDER = DEMO_DIR / 'test-results'
 DATA_FOLDER.mkdir(exist_ok=True)
 
+class TestImpact(unittest.TestCase):
+    "Test initialization and more"
+    def test_from_eih_pass(self):
+        imp = Impact.from_eih(ENT.exposures, ENT.impact_funcs, HAZ)
 
 class TestFreqCurve(unittest.TestCase):
     """Test exceedence frequency curve computation"""

From 660dbc234741b52c364d122bb1aea86a7c46e958 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Sat, 11 Jun 2022 18:33:17 +0200
Subject: [PATCH 066/121] Set default imp_mat to None

---
 climada/engine/impact.py      | 33 +++++++++++++++++----------------
 climada/engine/impact_calc.py |  4 ++--
 2 files changed, 19 insertions(+), 18 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 885e09859..17d6445ca 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -95,7 +95,7 @@ def __init__(self,
                  tot_value=0,
                  aai_agg=0,
                  unit='',
-                 imp_mat=sparse.csr_matrix((0, 0)),
+                 imp_mat=None,
                  tag=None):
         """
         Init Impact object
@@ -129,7 +129,7 @@ def __init__(self,
             value unit used (given by exposures unit)
         imp_mat : sparse.csr_matrix
             matrix num_events x num_exp with impacts.
-            only filled if save_mat is True in calc()
+            Default is None (empty matrix)
 
         """
 
@@ -156,23 +156,24 @@ def __init__(self,
             raise AttributeError('Hazard event ids and event frequency'
                                  ' are not of the same length')
         if len(event_id) != len(at_event):
-            raise AttributeError('Number of hazard event ids different '
+            raise AttributeError('Number of hazard event ids is different '
                                  'from number of at_event values')
         if len(coord_exp) != len(eai_exp):
-            raise AttributeError('Number of exposures points different from'
+            raise AttributeError('Number of exposures points is different from'
                                  'number of eai_exp values')
         if imp_mat is not None:
             self.imp_mat = imp_mat
-            if len(event_id) != imp_mat.shape[0]:
-                raise AttributeError(
-                    f'The number of rows {imp_mat.shape[0]} of the impact '
-                    'matrix is inconsistent with the number {len(event_id} '
-                    'of hazard events.')
-            if len(coord_exp) != imp_mat.shape[1]:
-                raise AttributeError(
-                    'The number of columns {imp_mat.shape[1]} of the impact'
-                    ' matrix is inconsistent with the number {len(coord_exp)}'
-                    ' exposures points.')
+            if imp_mat.size > 0:
+                if len(event_id) != imp_mat.shape[0]:
+                    raise AttributeError(
+                        f'The number of rows {imp_mat.shape[0]} of the impact ' +
+                        f'matrix is inconsistent with the number {len(event_id)} '
+                        'of hazard events.')
+                if len(coord_exp) != imp_mat.shape[1]:
+                    raise AttributeError(
+                        f'The number of columns {imp_mat.shape[1]} of the impact' +
+                        f' matrix is inconsistent with the number {len(coord_exp)}'
+                        ' exposures points.')
         else:
             self.imp_mat = sparse.csr_matrix(np.empty((0, 0)))
 
@@ -203,7 +204,7 @@ def calc(self, exposures, impact_funcs, hazard, save_mat=False):
 #TODO: new name
     @classmethod
     def from_eih(cls, exposures, impfset, hazard,
-                 at_event, eai_exp, aai_agg, imp_mat=sparse.csr_matrix((0, 0))):
+                 at_event, eai_exp, aai_agg, imp_mat=None):
         """
         Set Impact attributes from precalculated impact metrics.
 
@@ -217,7 +218,7 @@ def from_eih(cls, exposures, impfset, hazard,
             hazard used to compute imp_mat
         imp_mat : sparse.csr_matrix
             matrix num_events x num_exp with impacts.
-            Default is empty sparse csr matrix.
+            Default is None (empty sparse csr matrix).
 
         Returns
         -------
diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index 4ecc13c4a..484d3f197 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -40,7 +40,7 @@ def __init__(self,
                  exposures,
                  impfset,
                  hazard,
-                 imp_mat=sparse.csr_matrix((0, 0))):
+                 imp_mat=None):
         """
         Initialize an ImpactCalc object.
 
@@ -68,7 +68,7 @@ def __init__(self,
         self.exposures = exposures
         self.impfset = impfset
         self.hazard = hazard
-        self.imp_mat = imp_mat
+        self.imp_mat = sparse.csr_matrix((0, 0)) if imp_mat is None else imp_mat
         self.n_exp_pnt = self.exposures.gdf.shape[0]
         self.n_events = self.hazard.size
 

From 01e4e272fd6b6206d56fd34003030d81fdecd513 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Sat, 11 Jun 2022 19:01:13 +0200
Subject: [PATCH 067/121] Update init consistency tests

---
 climada/engine/impact.py | 24 ++++++++++--------------
 1 file changed, 10 insertions(+), 14 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 963162228..07f01c539 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -135,9 +135,9 @@ def __init__(self,
 
         self.tag = tag or {}
         self.event_id = np.array([], int) if event_id is None else event_id
-        self.event_name = event_name or []
+        self.event_name = [] if event_name is None else event_name
         self.date = np.array([], int) if date is None else date
-        self.coord_exp = np.ndarray([], float) if coord_exp is None else coord_exp
+        self.coord_exp = np.array([], float) if coord_exp is None else coord_exp
         self.crs = crs
         self.eai_exp = np.array([], float) if eai_exp is None else eai_exp
         self.at_event = np.array([], float) if at_event is None else at_event
@@ -146,30 +146,30 @@ def __init__(self,
         self.aai_agg = aai_agg
         self.unit = unit
 
-        if len(event_id) != len(event_name):
+        if len(self.event_id) != len(self.event_name):
             raise AttributeError('Hazard event ids and event names'
                                  ' are not of the same length')
-        if len(event_id) != len(date):
+        if len(self.event_id) != len(self.date):
             raise AttributeError('Hazard event ids and event dates'
                              ' are not of the same length')
-        if len(event_id) != len(frequency):
+        if len(self.event_id) != len(self.frequency):
             raise AttributeError('Hazard event ids and event frequency'
                                  ' are not of the same length')
-        if len(event_id) != len(at_event):
+        if len(self.event_id) != len(self.at_event):
             raise AttributeError('Number of hazard event ids is different '
                                  'from number of at_event values')
-        if len(coord_exp) != len(eai_exp):
+        if len(self.coord_exp) != len(self.eai_exp):
             raise AttributeError('Number of exposures points is different from'
                                  'number of eai_exp values')
         if imp_mat is not None:
             self.imp_mat = imp_mat
-            if imp_mat.size > 0:
-                if len(event_id) != imp_mat.shape[0]:
+            if self.imp_mat.size > 0:
+                if len(self.event_id) != self.imp_mat.shape[0]:
                     raise AttributeError(
                         f'The number of rows {imp_mat.shape[0]} of the impact ' +
                         f'matrix is inconsistent with the number {len(event_id)} '
                         'of hazard events.')
-                if len(coord_exp) != imp_mat.shape[1]:
+                if len(self.coord_exp) != self.imp_mat.shape[1]:
                     raise AttributeError(
                         f'The number of columns {imp_mat.shape[1]} of the impact' +
                         f' matrix is inconsistent with the number {len(coord_exp)}'
@@ -177,10 +177,6 @@ def __init__(self,
         else:
             self.imp_mat = sparse.csr_matrix(np.empty((0, 0)))
 
-        if np.sum(eai_exp) != aai_agg:
-            raise AttributeError('The aai_agg value does not correspond'
-                                 'to the sum of eai_exp.')
-
 
 
     def calc(self, exposures, impact_funcs, hazard, save_mat=False):

From 963a65fe1a3a71674961b0370fda6e055974d30e Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Sat, 11 Jun 2022 19:01:21 +0200
Subject: [PATCH 068/121] Add from_eih test

---
 climada/engine/test/test_impact.py | 24 +++++++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/climada/engine/test/test_impact.py b/climada/engine/test/test_impact.py
index effc11df0..5534ac601 100644
--- a/climada/engine/test/test_impact.py
+++ b/climada/engine/test/test_impact.py
@@ -54,7 +54,29 @@ def get_haz_test_file(ds_name):
 class TestImpact(unittest.TestCase):
     "Test initialization and more"
     def test_from_eih_pass(self):
-        imp = Impact.from_eih(ENT.exposures, ENT.impact_funcs, HAZ)
+        exp = ENT.exposures
+        tot_value = exp.affected_total_value(HAZ)
+        fake_eai_exp = np.arange(len(exp.gdf))
+        fake_at_event = np.arange(len(HAZ.size))
+        fake_aai_agg = np.sum(fake_eai_exp)
+        imp = Impact.from_eih(exp, ENT.impact_funcs, HAZ,
+                              fake_eai_exp, fake_at_event, fake_aai_agg)
+        self.assertEqual(imp.crs, exp.crs)
+        self.assertEqual(imp.aai_agg, fake_aai_agg)
+        self.assertIsNone(imp.imp_mat)
+        self.assertEqual(imp.unit, exp.value_unit)
+        self.assertEqual(imp.tot_value, tot_value)
+        np.testing.assert_array_almost_equal(imp.event_id, HAZ.event_id)
+        np.testing.assert_array_almost_equal(imp.event_name, HAZ.event_name)
+        np.testing.assert_array_almost_equal(imp.data, HAZ.data)
+        np.testing.assert_array_almost_equal(imp.frequency, HAZ.frequency)
+        np.testing.assert_array_almost_equal(imp.eai_exp, fake_eai_exp)
+        np.testing.assert_array_almost_equal(imp.at_event, fake_at_event)
+        np.testing.assert_array_almost_equal(
+            imp.coord_exp,
+            np.stack([exp.gdf.latitude.values, exp.gdf.longitude.values], axis=1)
+            )
+
 
 class TestFreqCurve(unittest.TestCase):
     """Test exceedence frequency curve computation"""

From 76cbf9aa8790a0f82cb78af9fa2297d32bd84f9f Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Sat, 11 Jun 2022 19:09:16 +0200
Subject: [PATCH 069/121] Add test risk transfer and residual risk

---
 climada/engine/test/test_impact.py | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/climada/engine/test/test_impact.py b/climada/engine/test/test_impact.py
index 5534ac601..6566aec67 100644
--- a/climada/engine/test/test_impact.py
+++ b/climada/engine/test/test_impact.py
@@ -52,7 +52,7 @@ def get_haz_test_file(ds_name):
 DATA_FOLDER.mkdir(exist_ok=True)
 
 class TestImpact(unittest.TestCase):
-    "Test initialization and more"
+    """"Test initialization and more"""
     def test_from_eih_pass(self):
         exp = ENT.exposures
         tot_value = exp.affected_total_value(HAZ)
@@ -77,6 +77,24 @@ def test_from_eih_pass(self):
             np.stack([exp.gdf.latitude.values, exp.gdf.longitude.values], axis=1)
             )
 
+    def test_transfer_risk_pass(self):
+        """Test transfer risk"""
+        imp = Impact()
+        imp.at_event = np.array([1.5, 2, 3])
+        imp.frequency = np.array([0.1, 0, 2])
+        transfer_at_event, transfer_aai_agg = imp.transfer_risk(attachment=1, cover=2)
+        self.assertTrue(transfer_aai_agg, 4.05)
+        np.testing.assert_array_almost_equal(transfer_at_event, np.array([0.5, 1, 2]))
+
+    def test_residual_risk_pass(self):
+        """Test residual risk"""
+        imp = Impact()
+        imp.at_event = np.array([1.5, 2, 3])
+        imp.frequency = np.array([0.1, 0, 2])
+        residual_at_event, residual_aai_agg = imp.residual_risk(attachment=1, cover=1.5)
+        self.assertTrue(residual_aai_agg, 3.1)
+        np.testing.assert_array_almost_equal(residual_at_event, np.array([1, 1, 1.5]))
+
 
 class TestFreqCurve(unittest.TestCase):
     """Test exceedence frequency curve computation"""

From eb5eba1bd40d8e108e05463a58ea3e9be8bb902b Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Sat, 11 Jun 2022 19:15:54 +0200
Subject: [PATCH 070/121] Add test impact_per_year

---
 climada/engine/test/test_impact.py | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/climada/engine/test/test_impact.py b/climada/engine/test/test_impact.py
index 6566aec67..04741369a 100644
--- a/climada/engine/test/test_impact.py
+++ b/climada/engine/test/test_impact.py
@@ -170,10 +170,10 @@ def test_ref_value_rp_pass(self):
         self.assertEqual('Exceedance frequency curve', ifc.label)
         self.assertEqual('USD', ifc.unit)
 
-class TestImpactYearSet(unittest.TestCase):
+class TestImpactPerYear(unittest.TestCase):
     """Test calc_impact_year_set method"""
 
-    def test_impact_year_set_sum(self):
+    def test_impact_per_year_sum(self):
         """Test result against reference value with given events"""
         imp = Impact()
         imp.frequency = np.ones(10) * 6.211180124223603e-04
@@ -192,11 +192,11 @@ def test_impact_year_set_sum(self):
         imp.date = np.array([732801, 716160, 718313, 712468, 732802,
                              729285, 732931, 715419, 722404, 718351])
 
-        iys_all = imp.calc_impact_year_set()
-        iys = imp.calc_impact_year_set(all_years=False)
-        iys_all_yr = imp.calc_impact_year_set(year_range=(1975, 2000))
-        iys_yr = imp.calc_impact_year_set(all_years=False, year_range=[1975, 2000])
-        iys_all_yr_1940 = imp.calc_impact_year_set(all_years=True, year_range=[1940, 2000])
+        iys_all = imp.impact_per_year()
+        iys = imp.impact_per_year(all_years=False)
+        iys_all_yr = imp.impact_per_year(year_range=(1975, 2000))
+        iys_yr = imp.impact_per_year(all_years=False, year_range=[1975, 2000])
+        iys_all_yr_1940 = imp.impact_per_year(all_years=True, year_range=[1940, 2000])
         self.assertEqual(np.around(sum([iys[year] for year in iys])),
                          np.around(sum(imp.at_event)))
         self.assertEqual(sum([iys[year] for year in iys]),
@@ -218,11 +218,11 @@ def test_impact_year_set_sum(self):
         self.assertFalse(1959 in iys_yr)
         self.assertEqual(len(iys_all_yr_1940), 61)
 
-    def test_impact_year_set_empty(self):
+    def test_impact_per_year_empty(self):
         """Test result for empty impact"""
         imp = Impact()
-        iys_all = imp.calc_impact_year_set()
-        iys = imp.calc_impact_year_set(all_years=False)
+        iys_all = imp.impact_per_year()
+        iys = imp.impact_per_year(all_years=False)
         self.assertEqual(len(iys), 0)
         self.assertEqual(len(iys_all), 0)
 
@@ -694,7 +694,7 @@ def test__exp_build_event(self):
 # Execute Tests
 if __name__ == "__main__":
     TESTS = unittest.TestLoader().loadTestsFromTestCase(TestFreqCurve)
-    TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestImpactYearSet))
+    TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestImpactPerYear))
     TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestIO))
     TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestRPmatrix))
     TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestRiskTrans))

From e9845437f99544ee8a6f64ab57c9259ced8a4cc4 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Sat, 11 Jun 2022 19:18:08 +0200
Subject: [PATCH 071/121] Cosmetics

---
 climada/engine/test/test_impact.py | 36 +++++++++++++++---------------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/climada/engine/test/test_impact.py b/climada/engine/test/test_impact.py
index 04741369a..600c42bac 100644
--- a/climada/engine/test/test_impact.py
+++ b/climada/engine/test/test_impact.py
@@ -77,24 +77,6 @@ def test_from_eih_pass(self):
             np.stack([exp.gdf.latitude.values, exp.gdf.longitude.values], axis=1)
             )
 
-    def test_transfer_risk_pass(self):
-        """Test transfer risk"""
-        imp = Impact()
-        imp.at_event = np.array([1.5, 2, 3])
-        imp.frequency = np.array([0.1, 0, 2])
-        transfer_at_event, transfer_aai_agg = imp.transfer_risk(attachment=1, cover=2)
-        self.assertTrue(transfer_aai_agg, 4.05)
-        np.testing.assert_array_almost_equal(transfer_at_event, np.array([0.5, 1, 2]))
-
-    def test_residual_risk_pass(self):
-        """Test residual risk"""
-        imp = Impact()
-        imp.at_event = np.array([1.5, 2, 3])
-        imp.frequency = np.array([0.1, 0, 2])
-        residual_at_event, residual_aai_agg = imp.residual_risk(attachment=1, cover=1.5)
-        self.assertTrue(residual_aai_agg, 3.1)
-        np.testing.assert_array_almost_equal(residual_at_event, np.array([1, 1, 1.5]))
-
 
 class TestFreqCurve(unittest.TestCase):
     """Test exceedence frequency curve computation"""
@@ -421,6 +403,24 @@ def test_risk_trans_pass(self):
         np.testing.assert_array_almost_equal_nulp(imp_rt.at_event, [0, 0, 0, 1, 2, 3, 4, 5, 6, 10])
         self.assertAlmostEqual(imp_rt.aai_agg, 6.2)
 
+    def test_transfer_risk_pass(self):
+        """Test transfer risk"""
+        imp = Impact()
+        imp.at_event = np.array([1.5, 2, 3])
+        imp.frequency = np.array([0.1, 0, 2])
+        transfer_at_event, transfer_aai_agg = imp.transfer_risk(attachment=1, cover=2)
+        self.assertTrue(transfer_aai_agg, 4.05)
+        np.testing.assert_array_almost_equal(transfer_at_event, np.array([0.5, 1, 2]))
+
+    def test_residual_risk_pass(self):
+        """Test residual risk"""
+        imp = Impact()
+        imp.at_event = np.array([1.5, 2, 3])
+        imp.frequency = np.array([0.1, 0, 2])
+        residual_at_event, residual_aai_agg = imp.residual_risk(attachment=1, cover=1.5)
+        self.assertTrue(residual_aai_agg, 3.1)
+        np.testing.assert_array_almost_equal(residual_at_event, np.array([1, 1, 1.5]))
+
 def dummy_impact():
 
     imp = Impact()

From 1238cdbdbb30d7de1dba60cc0f53572c7aa4a2c3 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Mon, 13 Jun 2022 12:00:52 +0200
Subject: [PATCH 072/121] Remove unsued method

---
 climada/entity/exposures/base.py | 20 +++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)

diff --git a/climada/entity/exposures/base.py b/climada/entity/exposures/base.py
index f52b840c5..9e37e6dac 100644
--- a/climada/entity/exposures/base.py
+++ b/climada/entity/exposures/base.py
@@ -1010,10 +1010,24 @@ def concat(exposures_list):
 
         return exp
 
-    def affected_values_gdf(self, hazard):
-        return self.gdf[(self.gdf.value != 0) & (self.gdf[hazard.cent_exp_col] >= 0)]
-
     def affected_total_value(self, hazard):
+        """
+        Total value of the exposures that are close enough to be affected
+        by the hazard (sum of value of all exposures points for which
+        a centroids is assigned)
+
+        Parameters
+        ----------
+        hazard : Hazard
+           Hazard affecting Exposures
+
+        Returns
+        -------
+        float
+            Sum of value of all exposures points for which
+            a centroids is assigned
+
+        """
         nz_mask = (
             (self.gdf.value.values > 0)
             & (self.gdf[hazard.cent_exp_col].values >= 0)

From 8e25d09107ebe8b8b674fa9798662fb57c681f67 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Mon, 13 Jun 2022 18:46:26 +0200
Subject: [PATCH 073/121] Add test for affected value

---
 climada/entity/exposures/test/test_base.py | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/climada/entity/exposures/test/test_base.py b/climada/entity/exposures/test/test_base.py
index 962571dd2..1662f0f7e 100644
--- a/climada/entity/exposures/test/test_base.py
+++ b/climada/entity/exposures/test/test_base.py
@@ -165,6 +165,25 @@ def test_assign_large_hazard_subset_pass(self):
         np.testing.assert_array_equal(assigned_centroids.lat, exp.gdf.latitude)
         np.testing.assert_array_equal(assigned_centroids.lon, exp.gdf.longitude)
 
+    def test_affected_total_value(self):
+        exp = Exposures.from_raster(HAZ_DEMO_FL, window=Window(25, 90, 10, 5))
+        haz = Hazard.from_raster([HAZ_DEMO_FL], haz_type='FL', window=Window(25, 90, 10, 5))
+        exp.assign_centroids(haz)
+        tot_val = exp.affected_total_value(haz)
+        self.assertEqual(tot_val, np.sum(exp.gdf.value))
+        new_centr = exp.gdf.centr_FL
+        new_centr[6] = -1
+        exp.gdf.centr_FL = new_centr
+        tot_val = exp.affected_total_value(haz)
+        self.assertAlmostEqual(tot_val, np.sum(exp.gdf.value) - exp.gdf.value[6], places=4)
+        new_vals = exp.gdf.value
+        new_vals[7] = 0
+        exp.gdf.value = new_vals
+        tot_val = exp.affected_total_value(haz)
+        self.assertAlmostEqual(tot_val, np.sum(exp.gdf.value) - exp.gdf.value[6], places=4)
+        exp.gdf.centr_FL = -1
+        tot_val = exp.affected_total_value(haz)
+        self.assertEqual(tot_val, 0)
 
 class TestChecker(unittest.TestCase):
     """Test logs of check function"""

From f8b53766098631b8bf583532f444dc45be060333 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Mon, 13 Jun 2022 18:54:59 +0200
Subject: [PATCH 074/121] Add property tests

---
 climada/hazard/test/test_base.py | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/climada/hazard/test/test_base.py b/climada/hazard/test/test_base.py
index a6c91b392..9ae71424a 100644
--- a/climada/hazard/test/test_base.py
+++ b/climada/hazard/test/test_base.py
@@ -1321,6 +1321,23 @@ def test_clear_pool(self):
         pool.join()
         pool.clear()
 
+class TestImpactFuncs(unittest.TestCase):
+    """Test methods mainly for computing impacts"""
+    def test_haz_type(self):
+        """Test haz_type property"""
+        haz = dummy_hazard()
+        self.assertEqual(haz.haz_type, 'TC')
+        haz.tag.haz_type = 'random'
+        self.assertEqual(haz.haz_type, 'random')
+
+    def test_cent_exp_col(self):
+        """Test return of centroid exposures column"""
+        haz = dummy_hazard()
+        self.assertEqual(haz.centr_exp_col, 'centr_TC')
+        haz.tag.haz_type = 'random'
+        self.assertEqual(haz.cent_exp_col, 'centr_random')
+        haz = Hazard()
+        self.assertEqual(haz.cent_exp_col, 'centr_')
 
 # Execute Tests
 if __name__ == "__main__":

From 597bdd78ab4ac29679385fe28675a6a612b49c47 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Tue, 14 Jun 2022 11:55:10 +0200
Subject: [PATCH 075/121] Add test get_mdr

---
 climada/hazard/base.py           |  6 +--
 climada/hazard/test/test_base.py | 67 ++++++++++++++++++++++++--------
 2 files changed, 53 insertions(+), 20 deletions(-)

diff --git a/climada/hazard/base.py b/climada/hazard/base.py
index 8b6ecdc71..367823d71 100644
--- a/climada/hazard/base.py
+++ b/climada/hazard/base.py
@@ -1785,7 +1785,7 @@ def change_centroids(self, centroids, threshold=NEAREST_NEIGHBOR_THRESHOLD):
         return haz_new_cent
 
     @property
-    def cent_exp_col(self):
+    def centr_exp_col(self):
         """
         Name of the centroids columns for this hazard in an exposures
 
@@ -1839,8 +1839,8 @@ def get_mdr(self, cent_idx, impf):
             "The mean damage ratio must thus be computed for all values of"
             "hazard intensity including 0 which can be very time consuming.",
             impf.id)
-            mdr_array = impf.calc_mdr(mdr.toarray().ravel())
-            mdr = sparse.csr_matrix(mdr_array, shape=mdr.shape)
+            mdr_array = impf.calc_mdr(mdr.toarray().ravel()).reshape(mdr.shape)
+            mdr = sparse.csr_matrix(mdr_array)
         return mdr[:, indices]
 
     def get_paa(self, cent_idx, impf):
diff --git a/climada/hazard/test/test_base.py b/climada/hazard/test/test_base.py
index 9ae71424a..a60c5fc46 100644
--- a/climada/hazard/test/test_base.py
+++ b/climada/hazard/test/test_base.py
@@ -54,7 +54,7 @@ def dummy_hazard():
     hazard.intensity = sparse.csr_matrix([[0.2, 0.3, 0.4],
                                           [0.1, 0.1, 0.01],
                                           [4.3, 2.1, 1.0],
-                                          [5.3, 0.2, 1.3]])
+                                          [5.3, 0.2, 0.0]])
     hazard.units = 'm/s'
 
     return hazard
@@ -287,7 +287,7 @@ def test_select_event_name(self):
                                        np.array([[0.3, 0.2, 0.0],
                                                  [0.02, 0.03, 0.04]])))
         self.assertTrue(np.array_equal(sel_haz.intensity.toarray(),
-                                       np.array([[5.3, 0.2, 1.3],
+                                       np.array([[5.3, 0.2, 0.0],
                                                  [0.2, 0.3, 0.4]])))
         self.assertEqual(sel_haz.event_name, ['ev4', 'ev1'])
         self.assertIsInstance(sel_haz, Hazard)
@@ -310,7 +310,7 @@ def test_select_event_id(self):
                                        np.array([[0.3, 0.2, 0.0],
                                                  [0.02, 0.03, 0.04]])))
         self.assertTrue(np.array_equal(sel_haz.intensity.toarray(),
-                                       np.array([[5.3, 0.2, 1.3],
+                                       np.array([[5.3, 0.2, 0.0],
                                                  [0.2, 0.3, 0.4]])))
         self.assertEqual(sel_haz.event_name, ['ev4', 'ev1'])
         self.assertIsInstance(sel_haz, Hazard)
@@ -332,7 +332,7 @@ def test_select_orig_pass(self):
         self.assertTrue(np.array_equal(
             sel_haz.fraction.toarray(), np.array([[0.02, 0.03, 0.04], [0.3, 0.2, 0.0]])))
         self.assertTrue(np.array_equal(
-            sel_haz.intensity.toarray(), np.array([[0.2, 0.3, 0.4], [5.3, 0.2, 1.3]])))
+            sel_haz.intensity.toarray(), np.array([[0.2, 0.3, 0.4], [5.3, 0.2, 0.0]])))
         self.assertEqual(sel_haz.event_name, ['ev1', 'ev4'])
         self.assertIsInstance(sel_haz, Hazard)
         self.assertIsInstance(sel_haz.intensity, sparse.csr_matrix)
@@ -378,7 +378,7 @@ def test_select_date_pass(self):
         self.assertTrue(np.array_equal(
             sel_haz.intensity.toarray(), np.array([[0.1, 0.1, 0.01],
                                                    [4.3, 2.1, 1.0],
-                                                   [5.3, 0.2, 1.3]])))
+                                                   [5.3, 0.2, 0.0]])))
         self.assertEqual(sel_haz.event_name, ['ev2', 'ev3', 'ev4'])
         self.assertIsInstance(sel_haz, Hazard)
         self.assertIsInstance(sel_haz.intensity, sparse.csr_matrix)
@@ -1321,6 +1321,12 @@ def test_clear_pool(self):
         pool.join()
         pool.clear()
 
+def dummy_step_impf(haz):
+    from climada.entity import ImpactFunc
+    intensity = (0, 1, haz.intensity.max())
+    impf = ImpactFunc.from_step_impf(intensity)
+    return impf
+
 class TestImpactFuncs(unittest.TestCase):
     """Test methods mainly for computing impacts"""
     def test_haz_type(self):
@@ -1335,21 +1341,48 @@ def test_cent_exp_col(self):
         haz = dummy_hazard()
         self.assertEqual(haz.centr_exp_col, 'centr_TC')
         haz.tag.haz_type = 'random'
-        self.assertEqual(haz.cent_exp_col, 'centr_random')
+        self.assertEqual(haz.centr_exp_col, 'centr_random')
         haz = Hazard()
-        self.assertEqual(haz.cent_exp_col, 'centr_')
+        self.assertEqual(haz.centr_exp_col, 'centr_')
+
+    def test_get_mdr(self):
+        haz = dummy_hazard()
+        impf = dummy_step_impf(haz)
+
+        #single index
+        for idx in range(3):
+            cent_idx = np.array([idx])
+            mdr = haz.get_mdr(cent_idx, impf)
+            true_mdr = np.digitize(haz.intensity[:, idx].toarray(), [0, 1]) - 1
+            np.testing.assert_array_almost_equal(mdr.toarray(), true_mdr)
+
+        #repeated index
+        cent_idx = np.array([0, 0])
+        mdr = haz.get_mdr(cent_idx, impf)
+        true_mdr = np.digitize(haz.intensity[:, cent_idx].toarray(), [0, 1]) - 1
+        np.testing.assert_array_almost_equal(mdr.toarray(), true_mdr)
+
+        #impf is not zero at 0
+        impf.mdd += 1
+        #single index
+        for idx in range(3):
+            cent_idx = np.array([idx])
+            mdr = haz.get_mdr(cent_idx, impf)
+            true_mdr = np.digitize(haz.intensity[:, idx].toarray(), [0, 1])
+            np.testing.assert_array_almost_equal(mdr.toarray(), true_mdr)
 
 # Execute Tests
 if __name__ == "__main__":
     TESTS = unittest.TestLoader().loadTestsFromTestCase(TestLoader)
-    TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestHDF5))
-    TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestReaderExcel))
-    TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestReaderMat))
-    TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestRemoveDupl))
-    TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestSelect))
-    TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestStats))
-    TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestYearset))
-    TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestAppend))
-    TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestCentroids))
-    TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestClear))
+    # TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestHDF5))
+    # TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestReaderExcel))
+    # TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestReaderMat))
+    # TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestRemoveDupl))
+    # TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestSelect))
+    # TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestStats))
+    # TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestYearset))
+    # TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestAppend))
+    # TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestCentroids))
+    # TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestClear))
+    TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestImpactFuncs))
     unittest.TextTestRunner(verbosity=2).run(TESTS)

From 3d3774a0c31b5a28240fde0846e3254fff58a356 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Tue, 14 Jun 2022 13:49:55 +0200
Subject: [PATCH 076/121] Add test get paa

---
 climada/hazard/test/test_base.py | 30 ++++++++++++++++++++++++++++--
 1 file changed, 28 insertions(+), 2 deletions(-)

diff --git a/climada/hazard/test/test_base.py b/climada/hazard/test/test_base.py
index a60c5fc46..4f2a82a11 100644
--- a/climada/hazard/test/test_base.py
+++ b/climada/hazard/test/test_base.py
@@ -1357,12 +1357,12 @@ def test_get_mdr(self):
             np.testing.assert_array_almost_equal(mdr.toarray(), true_mdr)
 
         #repeated index
-        cent_idx = np.array([0, 0])
+        cent_idx = np.array([0, 0, 1])
         mdr = haz.get_mdr(cent_idx, impf)
         true_mdr = np.digitize(haz.intensity[:, cent_idx].toarray(), [0, 1]) - 1
         np.testing.assert_array_almost_equal(mdr.toarray(), true_mdr)
 
-        #impf is not zero at 0
+        #mdr is not zero at 0
         impf.mdd += 1
         #single index
         for idx in range(3):
@@ -1371,6 +1371,32 @@ def test_get_mdr(self):
             true_mdr = np.digitize(haz.intensity[:, idx].toarray(), [0, 1])
             np.testing.assert_array_almost_equal(mdr.toarray(), true_mdr)
 
+    def test_get_paa(self):
+        haz = dummy_hazard()
+        impf = dummy_step_impf(haz)
+
+        idx = [0, 1]
+        cent_idx = np.array([idx])
+        paa = haz.get_paa(cent_idx, impf)
+        true_paa = np.ones(haz.intensity[:, idx].shape)
+        np.testing.assert_array_almost_equal(paa.toarray(), true_paa)
+
+        #repeated index
+        idx = [0, 0]
+        cent_idx = np.array([idx])
+        paa = haz.get_paa(cent_idx, impf)
+        true_paa = np.ones(haz.intensity[:, idx].shape)
+        np.testing.assert_array_almost_equal(paa.toarray(), true_paa)
+
+        #paa is not zero at 0
+        impf.paa += 1
+        #repeated index
+        idx = [0, 0, 1]
+        cent_idx = np.array([idx])
+        paa = haz.get_paa(cent_idx, impf)
+        true_paa = np.ones(haz.intensity[:, idx].shape) + 1
+        np.testing.assert_array_almost_equal(paa.toarray(), true_paa)
+
 # Execute Tests
 if __name__ == "__main__":
     TESTS = unittest.TestLoader().loadTestsFromTestCase(TestLoader)

From 7792e7c0d83216de108b801968c17a2aa1e5e4ac Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Tue, 14 Jun 2022 17:15:32 +0200
Subject: [PATCH 077/121] Add test get fraction

---
 climada/hazard/test/test_base.py | 23 ++++++++++++++++++++---
 1 file changed, 20 insertions(+), 3 deletions(-)

diff --git a/climada/hazard/test/test_base.py b/climada/hazard/test/test_base.py
index 4f2a82a11..241978d0f 100644
--- a/climada/hazard/test/test_base.py
+++ b/climada/hazard/test/test_base.py
@@ -1376,14 +1376,14 @@ def test_get_paa(self):
         impf = dummy_step_impf(haz)
 
         idx = [0, 1]
-        cent_idx = np.array([idx])
+        cent_idx = np.array(idx)
         paa = haz.get_paa(cent_idx, impf)
         true_paa = np.ones(haz.intensity[:, idx].shape)
         np.testing.assert_array_almost_equal(paa.toarray(), true_paa)
 
         #repeated index
         idx = [0, 0]
-        cent_idx = np.array([idx])
+        cent_idx = np.array(idx)
         paa = haz.get_paa(cent_idx, impf)
         true_paa = np.ones(haz.intensity[:, idx].shape)
         np.testing.assert_array_almost_equal(paa.toarray(), true_paa)
@@ -1392,11 +1392,28 @@ def test_get_paa(self):
         impf.paa += 1
         #repeated index
         idx = [0, 0, 1]
-        cent_idx = np.array([idx])
+        cent_idx = np.array(idx)
         paa = haz.get_paa(cent_idx, impf)
         true_paa = np.ones(haz.intensity[:, idx].shape) + 1
         np.testing.assert_array_almost_equal(paa.toarray(), true_paa)
 
+    def test_get_fraction(self):
+        haz = dummy_hazard()
+
+        idx = [0, 1]
+        cent_idx = np.array(idx)
+        frac = haz.get_fraction(cent_idx)
+        true_frac = haz.fraction[:, idx]
+        np.testing.assert_array_almost_equal(frac.toarray(), true_frac.toarray())
+
+        #repeated index
+        idx = [0, 0]
+        cent_idx = np.array(idx)
+        frac = haz.get_fraction(cent_idx)
+        true_frac = haz.fraction[:, idx]
+        np.testing.assert_array_almost_equal(frac.toarray(), true_frac.toarray())
+
+
 # Execute Tests
 if __name__ == "__main__":
     TESTS = unittest.TestLoader().loadTestsFromTestCase(TestLoader)

From 87cda771c21945fa4cf485fa111f2445bcad68a6 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Tue, 14 Jun 2022 17:18:11 +0200
Subject: [PATCH 078/121] Add docstring

---
 climada/hazard/base.py | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/climada/hazard/base.py b/climada/hazard/base.py
index 367823d71..615fa5962 100644
--- a/climada/hazard/base.py
+++ b/climada/hazard/base.py
@@ -1829,6 +1829,11 @@ def get_mdr(self, cent_idx, impf):
         sparse.csr_matrix
             sparse matrix (n_events x len(cent_idx)) with mdr values
 
+        See Also
+        --------
+        get_fraction: get the fraction for the given centroids
+        get_paa: get the paa ffor the given centroids
+
         """
         uniq_cent_idx, indices = np.unique(cent_idx, return_inverse=True)
         mdr = self.intensity[:, uniq_cent_idx]
@@ -1848,6 +1853,9 @@ def get_paa(self, cent_idx, impf):
         Return Percentage of Affected Assets (paa) for chosen centroids (cent_idx)
         for given impact function.
 
+        Note that value as intensity = 0 are ignored. This is different from
+        get_mdr.
+
         Parameters
         ----------
         cent_idx : array-like
@@ -1860,6 +1868,11 @@ def get_paa(self, cent_idx, impf):
         sparse.csr_matrix
             sparse matrix (n_events x len(cent_idx)) with paa values
 
+        See Also
+        --------
+        get_mdr: get the mean-damage ratio for the given centroids
+        get_fraction: get the fraction for the given centroids
+
         """
         uniq_cent_idx, indices = np.unique(cent_idx, return_inverse=True)
         paa = self.intensity[:, uniq_cent_idx]
@@ -1880,5 +1893,9 @@ def get_fraction(self, cent_idx):
         sparse.csr_matrix
             sparse matrix (n_events x len(cent_idx)) with fraction values
 
+        See Also
+        --------
+        get_mdr: get the mdr for the given centroids
+        get_paa: get the paa ffor the given centroids
         """
         return self.fraction[:, cent_idx]

From cc353e6c77e6023eb12e77f8fa0613e54a820ef9 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Wed, 15 Jun 2022 11:38:52 +0200
Subject: [PATCH 079/121] Add chunk method

---
 climada/engine/impact_calc.py | 22 ++++++++++++++--------
 1 file changed, 14 insertions(+), 8 deletions(-)

diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index e71b519fe..7b3cdaee2 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -237,17 +237,23 @@ def imp_mat_gen(self, exp_gdf, impf_col):
         """
         Geneartor of impact sub-matrices and correspoding exposures indices
         """
+
+        def _chunk_exp_idx_iter(self, idx_exp_impf):
+            max_size = CONFIG.max_matrix_size.int()
+            if self.hazard.size > max_size:
+                raise ValueError(
+                    f'Increase max_matrix_size configuration parameter to > {self.hazard.size}')
+            n_chunks =  np.ceil(self.hazard.size * len(idx_exp_impf) / max_size)
+            exp_chunk_size = int(len(idx_exp_impf) / n_chunks)
+            for chk in range(int(n_chunks)):
+                yield idx_exp_impf[chk * exp_chunk_size:(chk + 1) * exp_chunk_size]
+
         for impf_id in exp_gdf[impf_col].dropna().unique():
             impf = self.impfset.get_func(haz_type=self.hazard.haz_type, fun_id=impf_id)
             idx_exp_impf = (exp_gdf[impf_col].values == impf.id).nonzero()[0]
-            exp_step = CONFIG.max_matrix_size.int() // self.hazard.size
-            if not exp_step:
-                raise ValueError(
-                    f'Increase max_matrix_size configuration parameter to > {self.hazard.size}')
-            for chk in range(int(idx_exp_impf.size / exp_step) + 1):
-                exp_idx = idx_exp_impf[chk * exp_step:(chk + 1) * exp_step]
+            for exp_idx in _chunk_exp_idx_iter(self, idx_exp_impf):
                 exp_values = exp_gdf.value.values[exp_idx]
-                cent_idx = exp_gdf[self.hazard.cent_exp_col].values[exp_idx]
+                cent_idx = exp_gdf[self.hazard.centr_exp_col].values[exp_idx]
                 yield (self.impact_matrix(exp_values, cent_idx, impf), exp_idx)
 
     def insured_mat_gen(self, imp_mat_gen, exp_gdf, impf_col):
@@ -258,7 +264,7 @@ def insured_mat_gen(self, imp_mat_gen, exp_gdf, impf_col):
         for mat, exp_idx in imp_mat_gen:
             impf_id = exp_gdf[impf_col][exp_idx].unique()[0]
             deductible = self.deductible[exp_idx]
-            cent_idx = exp_gdf[self.hazard.cent_exp_col].values[exp_idx]
+            cent_idx = exp_gdf[self.hazard.centr_exp_col].values[exp_idx]
             impf = self.impfset.get_func(haz_type=self.hazard.haz_type, fun_id=impf_id)
             mat = self.apply_deductible_to_mat(mat, deductible, self.hazard, cent_idx, impf)
             cover = self.cover[exp_idx]

From b33ba54c535c7e0635e5fb328e950480e9b90539 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Wed, 15 Jun 2022 11:39:00 +0200
Subject: [PATCH 080/121] Update name cent to centr

---
 climada/engine/impact_calc.py    | 4 ++--
 climada/entity/exposures/base.py | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index 7b3cdaee2..005bf9ce7 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -223,11 +223,11 @@ def minimal_exp_gdf(self, impf_col):
 
         mask = (
             (self.exposures.gdf.value.values != 0)
-            & (self.exposures.gdf[self.hazard.cent_exp_col].values >= 0)
+            & (self.exposures.gdf[self.hazard.centr_exp_col].values >= 0)
         )
         exp_gdf = gpd.GeoDataFrame({
             col: self.exposures.gdf[col].values[mask]
-            for col in ['value', impf_col, self.hazard.cent_exp_col]
+            for col in ['value', impf_col, self.hazard.centr_exp_col]
         })
         if exp_gdf.size == 0:
             LOGGER.warning("No exposures with value >0 in the vicinity of the hazard.")
diff --git a/climada/entity/exposures/base.py b/climada/entity/exposures/base.py
index 9e37e6dac..21f41a1e7 100644
--- a/climada/entity/exposures/base.py
+++ b/climada/entity/exposures/base.py
@@ -1030,7 +1030,7 @@ def affected_total_value(self, hazard):
         """
         nz_mask = (
             (self.gdf.value.values > 0)
-            & (self.gdf[hazard.cent_exp_col].values >= 0)
+            & (self.gdf[hazard.centr_exp_col].values >= 0)
         )
         return np.sum(self.gdf.value.values[nz_mask])
 

From 10f68e90d43586f05a04d2fffa247e976593e0fe Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Wed, 15 Jun 2022 11:45:39 +0200
Subject: [PATCH 081/121] Update docstring

---
 climada/engine/impact_calc.py | 25 ++++++++++++++++++++++++-
 1 file changed, 24 insertions(+), 1 deletion(-)

diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index 005bf9ce7..447efdaa2 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -235,7 +235,30 @@ def minimal_exp_gdf(self, impf_col):
 
     def imp_mat_gen(self, exp_gdf, impf_col):
         """
-        Geneartor of impact sub-matrices and correspoding exposures indices
+        Generator of impact sub-matrices and correspoding exposures indices
+
+        The exposures gdf is decomposed into chunks that fit into the max
+        defined memory size. For each chunk, the impact matrix is computed
+        and returned, together with the corresponding exposures points index.
+
+        Parameters
+        ----------
+        exp_gdf : GeoDataFrame
+            Geodataframe of the exposures with columns required for impact
+            computation.
+        impf_col : string
+            name of the desired impact column in the exposures.
+
+        Raises
+        ------
+        ValueError
+            if the hazard is larger than the memory limit
+
+        Yields
+        ------
+        scipy.sparse.crs_matrix, np.ndarray
+            impact matrix and corresponding exposures indices for each chunk.
+
         """
 
         def _chunk_exp_idx_iter(self, idx_exp_impf):

From 1183d6f2fe372489b3ab4ff2599f1a5df019e648 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Wed, 15 Jun 2022 13:57:05 +0200
Subject: [PATCH 082/121] Use np.array_split for chunks

---
 climada/engine/impact_calc.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index 447efdaa2..06eda1c41 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -267,9 +267,7 @@ def _chunk_exp_idx_iter(self, idx_exp_impf):
                 raise ValueError(
                     f'Increase max_matrix_size configuration parameter to > {self.hazard.size}')
             n_chunks =  np.ceil(self.hazard.size * len(idx_exp_impf) / max_size)
-            exp_chunk_size = int(len(idx_exp_impf) / n_chunks)
-            for chk in range(int(n_chunks)):
-                yield idx_exp_impf[chk * exp_chunk_size:(chk + 1) * exp_chunk_size]
+            return np.array_split(idx_exp_impf, n_chunks)
 
         for impf_id in exp_gdf[impf_col].dropna().unique():
             impf = self.impfset.get_func(haz_type=self.hazard.haz_type, fun_id=impf_id)

From 246267bd41befb579c3139602388a25a6b0b144b Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Wed, 15 Jun 2022 14:10:22 +0200
Subject: [PATCH 083/121] Update naming

---
 climada/engine/impact_calc.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index 06eda1c41..89396647e 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -261,7 +261,7 @@ def imp_mat_gen(self, exp_gdf, impf_col):
 
         """
 
-        def _chunk_exp_idx_iter(self, idx_exp_impf):
+        def _chunk_exp_idx(self, idx_exp_impf):
             max_size = CONFIG.max_matrix_size.int()
             if self.hazard.size > max_size:
                 raise ValueError(
@@ -272,7 +272,7 @@ def _chunk_exp_idx_iter(self, idx_exp_impf):
         for impf_id in exp_gdf[impf_col].dropna().unique():
             impf = self.impfset.get_func(haz_type=self.hazard.haz_type, fun_id=impf_id)
             idx_exp_impf = (exp_gdf[impf_col].values == impf.id).nonzero()[0]
-            for exp_idx in _chunk_exp_idx_iter(self, idx_exp_impf):
+            for exp_idx in _chunk_exp_idx(self, idx_exp_impf):
                 exp_values = exp_gdf.value.values[exp_idx]
                 cent_idx = exp_gdf[self.hazard.centr_exp_col].values[exp_idx]
                 yield (self.impact_matrix(exp_values, cent_idx, impf), exp_idx)

From a60c0b6cc85a56f1de3dde32a705ac115788952f Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Wed, 15 Jun 2022 14:23:32 +0200
Subject: [PATCH 084/121] Simplify argument chunker

---
 climada/engine/impact_calc.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index 89396647e..9e5fe4831 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -261,18 +261,18 @@ def imp_mat_gen(self, exp_gdf, impf_col):
 
         """
 
-        def _chunk_exp_idx(self, idx_exp_impf):
+        def _chunk_exp_idx(haz_size, idx_exp_impf):
             max_size = CONFIG.max_matrix_size.int()
-            if self.hazard.size > max_size:
+            if haz_size > max_size:
                 raise ValueError(
                     f'Increase max_matrix_size configuration parameter to > {self.hazard.size}')
-            n_chunks =  np.ceil(self.hazard.size * len(idx_exp_impf) / max_size)
+            n_chunks =  np.ceil(haz_size * len(idx_exp_impf) / max_size)
             return np.array_split(idx_exp_impf, n_chunks)
 
         for impf_id in exp_gdf[impf_col].dropna().unique():
             impf = self.impfset.get_func(haz_type=self.hazard.haz_type, fun_id=impf_id)
             idx_exp_impf = (exp_gdf[impf_col].values == impf.id).nonzero()[0]
-            for exp_idx in _chunk_exp_idx(self, idx_exp_impf):
+            for exp_idx in _chunk_exp_idx(self.hazard.size, idx_exp_impf):
                 exp_values = exp_gdf.value.values[exp_idx]
                 cent_idx = exp_gdf[self.hazard.centr_exp_col].values[exp_idx]
                 yield (self.impact_matrix(exp_values, cent_idx, impf), exp_idx)

From 670fcb1a2db9171a6528329f299c503a26f6f708 Mon Sep 17 00:00:00 2001
From: Lukas Riedel <34276446+peanutfun@users.noreply.github.com>
Date: Wed, 15 Jun 2022 16:28:06 +0200
Subject: [PATCH 085/121] Add test case for ImpactCalc.imp_mat_gen

---
 climada/engine/test/test_impact_calc.py | 104 +++++++++++++++++++++++-
 1 file changed, 102 insertions(+), 2 deletions(-)

diff --git a/climada/engine/test/test_impact_calc.py b/climada/engine/test/test_impact_calc.py
index cff94c680..4ee4227fb 100644
--- a/climada/engine/test/test_impact_calc.py
+++ b/climada/engine/test/test_impact_calc.py
@@ -19,10 +19,13 @@
 Test Impact class.
 """
 import unittest
-import unittest.mock
+from unittest.mock import create_autospec, MagicMock, call
 import numpy as np
 from scipy import sparse
+import pandas as pd
+from copy import deepcopy
 
+from climada import CONFIG
 from climada.entity.entity_def import Entity
 from climada.hazard.base import Hazard
 from climada.engine import ImpactCalc
@@ -215,7 +218,7 @@ class TestImpactMatrixCalc(unittest.TestCase):
 
     def setUp(self):
         # Mock the methods called by 'impact_matrix'
-        self.hazard = unittest.mock.create_autospec(HAZ)
+        self.hazard = create_autospec(HAZ)
         self.hazard.get_mdr.return_value = sparse.csr_matrix(
             [[0.0, 0.5, -1.0], [1.0, 2.0, 1.0]]
         )
@@ -252,8 +255,105 @@ def test_wrong_sizes(self):
             self.icalc.impact_matrix(exposure_values, self.centroids, ENT.impact_funcs)
 
 
+class TestImpactMatrixGenerator(unittest.TestCase):
+    """Check the impact matrix generator"""
+
+    def setUp(self):
+        """"Initialize mocks"""
+        # Alter the default config to enable chunking
+        self.CONFIG_COPY = deepcopy(CONFIG)
+        CONFIG.max_matrix_size.int = MagicMock(return_value=1)
+
+        # Mock the hazard
+        self.hazard = create_autospec(HAZ)
+        self.hazard.haz_type = "haz_type"
+        self.hazard.centr_exp_col = "centr_col"
+        self.hazard.size = 1
+
+        # Mock the Impact function (set)
+        self.impf = MagicMock(name="impact_function")
+        self.impfset = create_autospec(ENT.impact_funcs)
+        self.impfset.get_func.return_value = self.impf
+
+        # Mock the impact matrix call
+        self.icalc = ImpactCalc(ENT.exposures, self.impfset, self.hazard)
+        self.icalc.impact_matrix = MagicMock()
+
+        # Set up a dummy exposure dataframe
+        self.exp_gdf = pd.DataFrame(
+            {
+                "impact_functions": [0, 11, 11],
+                "centr_col": [0, 10, 20],
+                "value": [0.0, 1.0, 2.0],
+            }
+        )
+
+    def tearDown(self):
+        """Reset the original config"""
+        CONFIG = self.CONFIG_COPY
+
+    def test_selection(self):
+        """Verify the impact matrix generator returns the right values"""
+        gen = self.icalc.imp_mat_gen(exp_gdf=self.exp_gdf, impf_col="impact_functions")
+        out_list = [exp_idx for _, exp_idx in gen]
+
+        np.testing.assert_array_equal(out_list, [[0], [1], [2]])
+
+        # Verify calls
+        self.impfset.get_func.assert_has_calls(
+            [call(haz_type="haz_type", fun_id=0), call(haz_type="haz_type", fun_id=11),]
+        )
+        self.icalc.impact_matrix.assert_has_calls(
+            [
+                call(np.array([0.0]), np.array([0]), self.impf),
+                call(np.array([1.0]), np.array([10]), self.impf),
+                call(np.array([2.0]), np.array([20]), self.impf),
+            ]
+        )
+
+    def test_chunking(self):
+        """Verify that chunking works as expected"""
+        # n_chunks = hazard.size * len(centr_idx) / max_size = 2 * 5 / 4 = 2.5
+        CONFIG.max_matrix_size.int = MagicMock(return_value=4)
+        self.hazard.size = 2
+
+        arr_len = 5
+        exp_gdf = pd.DataFrame(
+            {
+                "impact_functions": np.zeros(arr_len, dtype=np.int64),
+                "centr_col": np.array(list(range(arr_len))),
+                "value": np.ones(arr_len, dtype=np.float64),
+            }
+        )
+        gen = self.icalc.imp_mat_gen(exp_gdf=exp_gdf, impf_col="impact_functions")
+        out_list = [exp_idx for _, exp_idx in gen]
+
+        # Expect three chunks
+        self.assertEqual(len(out_list[0]), 2)
+        self.assertEqual(len(out_list[1]), 2)
+        self.assertEqual(len(out_list[2]), 1)
+
+    def test_chunk_error(self):
+        """Assert that too large hazard results in error"""
+        self.hazard.size = 2
+        gen = self.icalc.imp_mat_gen(exp_gdf=self.exp_gdf, impf_col="impact_functions")
+        with self.assertRaises(ValueError):
+            list(gen)
+
+    def test_empty_exp(self):
+        """imp_mat_gen should return an empty iterator for an empty dataframe"""
+        exp_gdf = pd.DataFrame({"impact_functions": [], "centr_col": [], "value": []})
+        self.assertEqual(
+            [],
+            list(self.icalc.imp_mat_gen(exp_gdf=exp_gdf, impf_col="impact_functions")),
+        )
+
+
 # Execute Tests
 if __name__ == "__main__":
     TESTS = unittest.TestLoader().loadTestsFromTestCase(TestImpactCalc)
     TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestImpactMatrixCalc))
+    TESTS.addTests(
+        unittest.TestLoader().loadTestsFromTestCase(TestImpactMatrixGenerator)
+    )
     unittest.TextTestRunner(verbosity=2).run(TESTS)

From 3b35a3eb7c24429fd5e33d7b9d5e4fcd961c4d39 Mon Sep 17 00:00:00 2001
From: Lukas Riedel <34276446+peanutfun@users.noreply.github.com>
Date: Wed, 15 Jun 2022 16:54:04 +0200
Subject: [PATCH 086/121] Add test for ImpactCalc.stitch_impact_matrix

---
 climada/engine/test/test_impact_calc.py | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/climada/engine/test/test_impact_calc.py b/climada/engine/test/test_impact_calc.py
index 4ee4227fb..98bf3e556 100644
--- a/climada/engine/test/test_impact_calc.py
+++ b/climada/engine/test/test_impact_calc.py
@@ -212,6 +212,23 @@ def test_minimal_exp_gdf(self):
         np.testing.assert_array_equal(exp_min_gdf.impf_TC, ENT.exposures.gdf.impf_TC)
         np.testing.assert_array_equal(exp_min_gdf.centr_TC, ENT.exposures.gdf.centr_TC)
 
+    def test_stitch_impact_matrix(self):
+        """Check how sparse matrices from a generator are stitched together"""
+        icalc = ImpactCalc(ENT.exposures, ENT.impact_funcs, HAZ)
+        icalc.n_events = 3
+        icalc.n_exp_pnt = 4
+
+        imp_mat_gen = [
+            (sparse.csr_matrix([[1.0, 1.0], [0.0, 1.0]]), np.array([0, 1])),
+            (sparse.csr_matrix([[0.0, 0.0], [2.0, 2.0], [2.0, 2.0]]), np.array([1, 2])),
+            (sparse.csr_matrix([[0.0], [0.0], [4.0]]), np.array([3])),
+        ]
+        mat = icalc.stitch_impact_matrix(imp_mat_gen)
+        np.testing.assert_array_equal(
+            mat.toarray(),
+            [[1.0, 1.0, 0.0, 0.0], [0.0, 3.0, 2.0, 0.0], [0.0, 2.0, 2.0, 4.0]],
+        )
+
 
 class TestImpactMatrixCalc(unittest.TestCase):
     """Verify the computation of the impact matrix"""

From ffd0804cb2f934dc5ede2177fcfce288077ad2b5 Mon Sep 17 00:00:00 2001
From: Lukas Riedel <34276446+peanutfun@users.noreply.github.com>
Date: Wed, 15 Jun 2022 17:30:48 +0200
Subject: [PATCH 087/121] Add test for ImpactCalc.apply_deductible_to_mat

---
 climada/engine/test/test_impact_calc.py | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/climada/engine/test/test_impact_calc.py b/climada/engine/test/test_impact_calc.py
index 98bf3e556..98a54a6df 100644
--- a/climada/engine/test/test_impact_calc.py
+++ b/climada/engine/test/test_impact_calc.py
@@ -229,6 +229,19 @@ def test_stitch_impact_matrix(self):
             [[1.0, 1.0, 0.0, 0.0], [0.0, 3.0, 2.0, 0.0], [0.0, 2.0, 2.0, 4.0]],
         )
 
+    def test_apply_deductible_to_mat(self):
+        """Test applying a deductible to an impact matrix"""
+        hazard = create_autospec(HAZ)
+        hazard.get_paa.return_value = sparse.csr_matrix([[1.0, 0.0], [0.1, 1.0]])
+
+        mat = sparse.csr_matrix([[10.0, 20.0], [30.0, 40.0]])
+        deductible = np.array([1.0, 0.5])
+
+        centr_idx = np.ones(2)
+        impf = None
+        mat = ImpactCalc.apply_deductible_to_mat(mat, deductible, hazard, centr_idx, impf)
+        np.testing.assert_array_equal(mat.toarray(), [[9.0, 20.0], [29.9, 39.5]])
+        hazard.get_paa.assert_called_once_with(centr_idx, impf)
 
 class TestImpactMatrixCalc(unittest.TestCase):
     """Verify the computation of the impact matrix"""

From 6fe861177960d70d090e8db1440e45523721565f Mon Sep 17 00:00:00 2001
From: Lukas Riedel <34276446+peanutfun@users.noreply.github.com>
Date: Wed, 15 Jun 2022 17:34:52 +0200
Subject: [PATCH 088/121] Fix bug and formatting in ImpactCalc.imp_mat_gen

* Use the original impf_id instead of relying on the ID of the returned
  impact function object.
* Remove superfluous whitespace
---
 climada/engine/impact_calc.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index 9e5fe4831..e0520f3cb 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -266,12 +266,12 @@ def _chunk_exp_idx(haz_size, idx_exp_impf):
             if haz_size > max_size:
                 raise ValueError(
                     f'Increase max_matrix_size configuration parameter to > {self.hazard.size}')
-            n_chunks =  np.ceil(haz_size * len(idx_exp_impf) / max_size)
+            n_chunks = np.ceil(haz_size * len(idx_exp_impf) / max_size)
             return np.array_split(idx_exp_impf, n_chunks)
 
         for impf_id in exp_gdf[impf_col].dropna().unique():
             impf = self.impfset.get_func(haz_type=self.hazard.haz_type, fun_id=impf_id)
-            idx_exp_impf = (exp_gdf[impf_col].values == impf.id).nonzero()[0]
+            idx_exp_impf = (exp_gdf[impf_col].values == impf_id).nonzero()[0]
             for exp_idx in _chunk_exp_idx(self.hazard.size, idx_exp_impf):
                 exp_values = exp_gdf.value.values[exp_idx]
                 cent_idx = exp_gdf[self.hazard.centr_exp_col].values[exp_idx]

From 4a2dac93bee6373ed25491d655b83bd776d642e4 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Wed, 15 Jun 2022 18:25:02 +0200
Subject: [PATCH 089/121] Add test with fraction not equal 1

---
 climada/engine/test/test_impact_calc.py | 22 ++++++++++++++++++++--
 1 file changed, 20 insertions(+), 2 deletions(-)

diff --git a/climada/engine/test/test_impact_calc.py b/climada/engine/test/test_impact_calc.py
index 98a54a6df..2b7e22d30 100644
--- a/climada/engine/test/test_impact_calc.py
+++ b/climada/engine/test/test_impact_calc.py
@@ -23,7 +23,7 @@
 import numpy as np
 from scipy import sparse
 import pandas as pd
-from copy import deepcopy
+from copy import deepcopy, copy
 
 from climada import CONFIG
 from climada.entity.entity_def import Entity
@@ -85,7 +85,7 @@ def test_metrics(self):
         np.testing.assert_array_equal(at_event, ae)
         np.testing.assert_array_equal(eai_exp, eai)
 
-    def test_insured_matrics(self):
+    def test_apply_cover_to_mat(self):
         """Test methods to get insured metrics"""
         mat = sparse.csr_matrix(np.array(
             [[1, 0, 1],
@@ -114,6 +114,24 @@ def test_calc_impact_pass(self):
         self.assertAlmostEqual(6.570532945599105e+11, impact.tot_value)
         self.assertAlmostEqual(6.512201157564421e+09, impact.aai_agg, 5)
 
+        x = 0.6
+        HAZf = deepcopy(HAZ)
+        HAZf.fraction *= 0.6
+        icalc = ImpactCalc(ENT.exposures, ENT.impact_funcs, HAZf)
+        impact = icalc.impact()
+        self.assertEqual(icalc.n_events, len(impact.at_event))
+        self.assertEqual(0, impact.at_event[0])
+        self.assertEqual(0, impact.at_event[7225])
+        self.assertAlmostEqual(1.472482938320243e+08 * x, impact.at_event[13809], delta=1)
+        self.assertAlmostEqual(7.076504723057620e+10 * x, impact.at_event[12147], delta=1)
+        self.assertEqual(0, impact.at_event[14449])
+        self.assertEqual(icalc.n_exp_pnt, len(impact.eai_exp))
+        self.assertAlmostEqual(1.518553670803242e+08 * x, impact.eai_exp[0], delta=1)
+        self.assertAlmostEqual(1.373490457046383e+08 * x, impact.eai_exp[25], 6)
+        self.assertAlmostEqual(1.066837260150042e+08 * x, impact.eai_exp[49], 6)
+        self.assertAlmostEqual(6.570532945599105e+11, impact.tot_value)
+        self.assertAlmostEqual(6.512201157564421e+09 * x, impact.aai_agg, 5)
+
     def test_calc_impact_save_mat_pass(self):
         """Test compute impact with impact matrix"""
         icalc = ImpactCalc(ENT.exposures, ENT.impact_funcs, HAZ)

From c263c509b32a50432c1993919b71b4c799980d67 Mon Sep 17 00:00:00 2001
From: Lukas Riedel <34276446+peanutfun@users.noreply.github.com>
Date: Thu, 16 Jun 2022 11:12:07 +0200
Subject: [PATCH 090/121] Improve error message in impact matrix chunking

---
 climada/engine/impact_calc.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index e0520f3cb..a6fcd4bf0 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -265,7 +265,9 @@ def _chunk_exp_idx(haz_size, idx_exp_impf):
             max_size = CONFIG.max_matrix_size.int()
             if haz_size > max_size:
                 raise ValueError(
-                    f'Increase max_matrix_size configuration parameter to > {self.hazard.size}')
+                    f"Hazard size '{haz_size}' exceeds maximum matrix size '{max_size}'. "
+                    "Increase max_matrix_size configuration parameter accordingly."
+                )
             n_chunks = np.ceil(haz_size * len(idx_exp_impf) / max_size)
             return np.array_split(idx_exp_impf, n_chunks)
 

From 78c9be40ba6e807e690928618c2e393c0b2a6154 Mon Sep 17 00:00:00 2001
From: emanuel-schmid <schmide@ethz.ch>
Date: Thu, 16 Jun 2022 13:22:59 +0200
Subject: [PATCH 091/121] test_impact_calc: persistently revert the CONFIG
 changes in tearDown

---
 climada/engine/test/test_impact_calc.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/climada/engine/test/test_impact_calc.py b/climada/engine/test/test_impact_calc.py
index 2b7e22d30..aa4542121 100644
--- a/climada/engine/test/test_impact_calc.py
+++ b/climada/engine/test/test_impact_calc.py
@@ -338,7 +338,8 @@ def setUp(self):
 
     def tearDown(self):
         """Reset the original config"""
-        CONFIG = self.CONFIG_COPY
+        import climada
+        climada.CONFIG = self.CONFIG_COPY
 
     def test_selection(self):
         """Verify the impact matrix generator returns the right values"""

From 2a1122f9e18cecb6a8d8d43f8d104f06a0314ddf Mon Sep 17 00:00:00 2001
From: Lukas Riedel <34276446+peanutfun@users.noreply.github.com>
Date: Thu, 16 Jun 2022 13:33:21 +0200
Subject: [PATCH 092/121] Replace instances in CONFIG instead of mocking

Explicitly replace instances in the CONFIG tree with new/old values
in the TestImpactMatrixGenerator test case, because CONFIG cannot be
deepcopied. This avoids errors in tests that are executed after this
test case.
---
 climada/engine/test/test_impact_calc.py | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/climada/engine/test/test_impact_calc.py b/climada/engine/test/test_impact_calc.py
index aa4542121..03086285d 100644
--- a/climada/engine/test/test_impact_calc.py
+++ b/climada/engine/test/test_impact_calc.py
@@ -23,7 +23,6 @@
 import numpy as np
 from scipy import sparse
 import pandas as pd
-from copy import deepcopy, copy
 
 from climada import CONFIG
 from climada.entity.entity_def import Entity
@@ -31,6 +30,7 @@
 from climada.engine import ImpactCalc
 from climada.util.constants import ENT_DEMO_TODAY, DEMO_DIR
 from climada.util.api_client import Client
+from climada.util.config import Config
 
 
 def get_haz_test_file(ds_name):
@@ -309,8 +309,8 @@ class TestImpactMatrixGenerator(unittest.TestCase):
     def setUp(self):
         """"Initialize mocks"""
         # Alter the default config to enable chunking
-        self.CONFIG_COPY = deepcopy(CONFIG)
-        CONFIG.max_matrix_size.int = MagicMock(return_value=1)
+        self._max_matrix_size = CONFIG.max_matrix_size.int()
+        CONFIG.max_matrix_size = Config(val=1, root=CONFIG)
 
         # Mock the hazard
         self.hazard = create_autospec(HAZ)
@@ -338,8 +338,7 @@ def setUp(self):
 
     def tearDown(self):
         """Reset the original config"""
-        import climada
-        climada.CONFIG = self.CONFIG_COPY
+        CONFIG.max_matrix_size = Config(val=self._max_matrix_size, root=CONFIG)
 
     def test_selection(self):
         """Verify the impact matrix generator returns the right values"""
@@ -363,7 +362,7 @@ def test_selection(self):
     def test_chunking(self):
         """Verify that chunking works as expected"""
         # n_chunks = hazard.size * len(centr_idx) / max_size = 2 * 5 / 4 = 2.5
-        CONFIG.max_matrix_size.int = MagicMock(return_value=4)
+        CONFIG.max_matrix_size = Config(val=4, root=CONFIG)
         self.hazard.size = 2
 
         arr_len = 5

From 8a699f84e0ec3fc02b9b2d393fbfbef376874b54 Mon Sep 17 00:00:00 2001
From: Lukas Riedel <34276446+peanutfun@users.noreply.github.com>
Date: Thu, 16 Jun 2022 14:07:29 +0200
Subject: [PATCH 093/121] Add test for ImpactCalc.stitch_risk_metrics and
 update docstring

---
 climada/engine/impact_calc.py           | 21 +++++++++++++++++++--
 climada/engine/test/test_impact_calc.py | 19 +++++++++++++++++++
 2 files changed, 38 insertions(+), 2 deletions(-)

diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index a6fcd4bf0..6c000c482 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -336,8 +336,25 @@ def stitch_impact_matrix(self, imp_mat_gen):
             )
 
     def stitch_risk_metrics(self, imp_mat_gen):
-        """
-        Compute the impact metrics from an impact sub-matrix generator
+        """Compute the impact metrics from an impact sub-matrix generator
+
+        This method is used to compute the risk metrics if the user decided not to store
+        the full impact matrix.
+
+        Parameters
+        ----------
+        imp_mat_gen : Generator yielding (sparse.csr_matrix, np.array)
+            The generator for creating the impact matrix. It returns a part of the full
+            matrix and the associated exposure indices.
+
+        Returns
+        -------
+        at_event : np.array
+            Accumulated damage for each event
+        eai_exp : np.array
+            Expected annual impact for each exposure point
+        aai_agg : float
+            Average annual impact aggregated
         """
         at_event = np.zeros(self.n_events)
         eai_exp = np.zeros(self.n_exp_pnt)
diff --git a/climada/engine/test/test_impact_calc.py b/climada/engine/test/test_impact_calc.py
index 03086285d..7f5628193 100644
--- a/climada/engine/test/test_impact_calc.py
+++ b/climada/engine/test/test_impact_calc.py
@@ -261,6 +261,25 @@ def test_apply_deductible_to_mat(self):
         np.testing.assert_array_equal(mat.toarray(), [[9.0, 20.0], [29.9, 39.5]])
         hazard.get_paa.assert_called_once_with(centr_idx, impf)
 
+    def test_stitch_risk_metrics(self):
+        """Test computing risk metrics from an impact matrix generator"""
+        icalc = ImpactCalc(ENT.exposures, ENT.impact_funcs, HAZ)
+        icalc.n_events = 2
+        icalc.n_exp_pnt = 3
+        icalc.hazard.frequency = np.array([2, 0.5])
+
+        # Matrices overlap at central exposure point
+        imp_mat_gen = (
+            (sparse.csc_matrix([[1.0, 0.0], [0.5, 1.0]]), np.array([0, 1])),
+            (sparse.csc_matrix([[0.0, 2.0], [1.5, 1.0]]), np.array([1, 2])),
+        )
+        at_event, eai_exp, aai_agg = icalc.stitch_risk_metrics(imp_mat_gen)
+
+        np.testing.assert_array_equal(at_event, [3.0, 4.0])
+        np.testing.assert_array_equal(eai_exp, [2.25, 1.25, 4.5])
+        self.assertEqual(aai_agg, 8.0)  # Sum of eai_exp
+
+
 class TestImpactMatrixCalc(unittest.TestCase):
     """Verify the computation of the impact matrix"""
 

From d43c36be2522b4ce23b24a23c101b484a03398a5 Mon Sep 17 00:00:00 2001
From: Lukas Riedel <34276446+peanutfun@users.noreply.github.com>
Date: Thu, 16 Jun 2022 14:09:38 +0200
Subject: [PATCH 094/121] Add deepcopy import to test_impact_calc

---
 climada/engine/test/test_impact_calc.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/climada/engine/test/test_impact_calc.py b/climada/engine/test/test_impact_calc.py
index 7f5628193..e3e3dfa3b 100644
--- a/climada/engine/test/test_impact_calc.py
+++ b/climada/engine/test/test_impact_calc.py
@@ -23,6 +23,7 @@
 import numpy as np
 from scipy import sparse
 import pandas as pd
+from copy import deepcopy
 
 from climada import CONFIG
 from climada.entity.entity_def import Entity

From 6ed55b04177a0e1a5db0d17ce00ffac6df515196 Mon Sep 17 00:00:00 2001
From: Lukas Riedel <34276446+peanutfun@users.noreply.github.com>
Date: Thu, 16 Jun 2022 15:03:23 +0200
Subject: [PATCH 095/121] Add test for ImpactCalc.insured_mat_gen and update
 docstring

---
 climada/engine/impact_calc.py           | 24 ++++++++++++
 climada/engine/test/test_impact_calc.py | 52 +++++++++++++++++++++++++
 2 files changed, 76 insertions(+)

diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index 6c000c482..60958c7b1 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -283,6 +283,30 @@ def insured_mat_gen(self, imp_mat_gen, exp_gdf, impf_col):
         """
         Generator of insured impact sub-matrices (with applied cover and deductible)
         and corresponding exposures indices
+
+        This generator takes a 'regular' impact matrix generator and applies cover and
+        deductible onto the impacts. It yields the same sub-matrices as the original
+        generator.
+
+        Deductible and cover are taken from the dataframe stored in `exposures.gdf`.
+
+        Parameters
+        ----------
+        imp_mat_gen : Generator yielding (sparse.csr_matrix, np.array)
+            The generator for creating the impact matrix. It returns a part of the full
+            matrix and the associated exposure indices.
+        exp_gdf : GeoDataFrame
+            Geodataframe of the exposures with columns required for impact computation.
+        impf_col : str
+            Name of the column in 'exp_gdf' indicating the impact function (id)
+
+        Yields
+        ------
+        mat : scipy.sparse.csr_matrix
+            Impact sub-matrix (with applied cover and deductible) with size
+            (n_events, len(exp_idx))
+        exp_idx : np.array
+            Exposure indices for impacts in mat
         """
         for mat, exp_idx in imp_mat_gen:
             impf_id = exp_gdf[impf_col][exp_idx].unique()[0]
diff --git a/climada/engine/test/test_impact_calc.py b/climada/engine/test/test_impact_calc.py
index e3e3dfa3b..61b5c6048 100644
--- a/climada/engine/test/test_impact_calc.py
+++ b/climada/engine/test/test_impact_calc.py
@@ -417,6 +417,58 @@ def test_empty_exp(self):
         )
 
 
+class TestInsuredImpactMatrixGenerator(unittest.TestCase):
+    def setUp(self):
+        hazard = create_autospec(HAZ)
+        self.icalc = ImpactCalc(ENT.exposures, ENT.impact_funcs, hazard)
+        self.icalc.exposures.gdf = pd.DataFrame(
+            {"deductible": [10.0, 20.0], "cover": [1.0, 100.0]}
+        )
+        self.icalc.hazard.centr_exp_col = "centr_col"
+        self.icalc.hazard.haz_type = "haz_type"
+        self.icalc.apply_deductible_to_mat = MagicMock(
+            side_effect=["mat_deduct_1", "mat_deduct_2"]
+        )
+        self.icalc.apply_cover_to_mat = MagicMock(
+            side_effect=["mat_cov_1", "mat_cov_2"]
+        )
+        self.icalc.impfset.get_func = MagicMock(side_effect=["impf_0", "impf_2"])
+
+    def test_insured_mat_gen(self):
+        exp_gdf = pd.DataFrame(
+            {"impact_functions": [0, 2], "centr_col": [0, 10], "value": [1.0, 2.0],}
+        )
+        imp_mat_gen = ((i, np.array([i])) for i in range(2))
+        gen = self.icalc.insured_mat_gen(imp_mat_gen, exp_gdf, "impact_functions")
+        out_list = list(gen)
+
+        # Assert expected output
+        self.assertEqual(len(out_list), 2)
+        np.testing.assert_array_equal(
+            [item[0] for item in out_list], ["mat_cov_1", "mat_cov_2"]
+        )
+        np.testing.assert_array_equal([item[1] for item in out_list], [[0], [1]])
+
+        # Check if correct impf_id was selected
+        self.icalc.impfset.get_func.assert_has_calls(
+            [call(haz_type="haz_type", fun_id=0), call(haz_type="haz_type", fun_id=2),]
+        )
+        # Check if correct deductible and cent_idx were selected
+        self.icalc.apply_deductible_to_mat.assert_has_calls(
+            [
+                call(0, np.array([10.0]), self.icalc.hazard, np.array([0]), "impf_0"),
+                call(1, np.array([20.0]), self.icalc.hazard, np.array([10]), "impf_2"),
+            ]
+        )
+        # Check if correct cover was selected
+        self.icalc.apply_cover_to_mat.assert_has_calls(
+            [
+                call("mat_deduct_1", np.array([1.0])),
+                call("mat_deduct_2", np.array([100.0])),
+            ]
+        )
+
+
 # Execute Tests
 if __name__ == "__main__":
     TESTS = unittest.TestLoader().loadTestsFromTestCase(TestImpactCalc)

From 96924eacf919ba33c45e11352bab7ece3c9ecb7d Mon Sep 17 00:00:00 2001
From: Lukas Riedel <34276446+peanutfun@users.noreply.github.com>
Date: Thu, 16 Jun 2022 15:19:57 +0200
Subject: [PATCH 096/121] Add test for ImpactCalc.impact_matrix

---
 climada/engine/test/test_impact_calc.py | 27 +++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/climada/engine/test/test_impact_calc.py b/climada/engine/test/test_impact_calc.py
index 61b5c6048..25c6f8f39 100644
--- a/climada/engine/test/test_impact_calc.py
+++ b/climada/engine/test/test_impact_calc.py
@@ -469,9 +469,36 @@ def test_insured_mat_gen(self):
         )
 
 
+class TestImpactMatrix(unittest.TestCase):
+    def setUp(self):
+        hazard = create_autospec(HAZ)
+        impact_funcs = create_autospec(ENT.impact_funcs)
+        self.icalc = ImpactCalc(ENT.exposures, impact_funcs, hazard)
+
+        mdr = sparse.csr_matrix([[1.0, 0.0, 2.0], [-1.0, 0.5, 1.0]])
+        mdr.eliminate_zeros()
+        self.icalc.hazard.get_mdr.return_value = mdr
+        fraction = sparse.csr_matrix([[1.0, 1.0, 1.0], [1.0, 0.0, -1.0]])
+        fraction.eliminate_zeros()
+        self.icalc.hazard.get_fraction.return_value = fraction
+
+    def test_impact_matrix(self):
+        """Check if impact matrix calculations and calls to hazard are correct"""
+        exp_values = np.array([1.0, 2.0, 4.0])
+        centroid_idx = np.array([0, 2, 3])
+        impact_matrix = self.icalc.impact_matrix(exp_values, centroid_idx, "impf")
+
+        np.testing.assert_array_equal(
+            impact_matrix.toarray(), [[1.0, 0.0, 8.0], [-1.0, 0.0, -4.0]]
+        )
+        self.icalc.hazard.get_mdr.assert_called_once_with(centroid_idx, "impf")
+        self.icalc.hazard.get_fraction.assert_called_once_with(centroid_idx)
+
+
 # Execute Tests
 if __name__ == "__main__":
     TESTS = unittest.TestLoader().loadTestsFromTestCase(TestImpactCalc)
+    TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestImpactMatrix))
     TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestImpactMatrixCalc))
     TESTS.addTests(
         unittest.TestLoader().loadTestsFromTestCase(TestImpactMatrixGenerator)

From b8a39fd6c152f982fbcb4e43ff748f981af44fc9 Mon Sep 17 00:00:00 2001
From: Lukas Riedel <34276446+peanutfun@users.noreply.github.com>
Date: Thu, 16 Jun 2022 15:21:52 +0200
Subject: [PATCH 097/121] Add TestInsuredImpactMatrixGenerator to test loader

The test was previously not added to the loader, but this only had an
effect when the file was executed directly (as __main__).
---
 climada/engine/test/test_impact_calc.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/climada/engine/test/test_impact_calc.py b/climada/engine/test/test_impact_calc.py
index 25c6f8f39..066c8af4c 100644
--- a/climada/engine/test/test_impact_calc.py
+++ b/climada/engine/test/test_impact_calc.py
@@ -503,4 +503,7 @@ def test_impact_matrix(self):
     TESTS.addTests(
         unittest.TestLoader().loadTestsFromTestCase(TestImpactMatrixGenerator)
     )
+    TESTS.addTests(
+        unittest.TestLoader().loadTestsFromTestCase(TestInsuredImpactMatrixGenerator)
+    )
     unittest.TextTestRunner(verbosity=2).run(TESTS)

From 2e21f9cc8f1c511745d3a51040c90624b36936bf Mon Sep 17 00:00:00 2001
From: Lukas Riedel <34276446+peanutfun@users.noreply.github.com>
Date: Fri, 17 Jun 2022 13:28:36 +0200
Subject: [PATCH 098/121] Add test for ImpactCalc._return_matrix

---
 climada/engine/test/test_impact_calc.py | 66 ++++++++++++++++++++++++-
 1 file changed, 64 insertions(+), 2 deletions(-)

diff --git a/climada/engine/test/test_impact_calc.py b/climada/engine/test/test_impact_calc.py
index 066c8af4c..f8f14b38f 100644
--- a/climada/engine/test/test_impact_calc.py
+++ b/climada/engine/test/test_impact_calc.py
@@ -19,7 +19,7 @@
 Test Impact class.
 """
 import unittest
-from unittest.mock import create_autospec, MagicMock, call
+from unittest.mock import create_autospec, MagicMock, call, patch
 import numpy as np
 from scipy import sparse
 import pandas as pd
@@ -28,7 +28,7 @@
 from climada import CONFIG
 from climada.entity.entity_def import Entity
 from climada.hazard.base import Hazard
-from climada.engine import ImpactCalc
+from climada.engine import ImpactCalc, Impact
 from climada.util.constants import ENT_DEMO_TODAY, DEMO_DIR
 from climada.util.api_client import Client
 from climada.util.config import Config
@@ -495,9 +495,71 @@ def test_impact_matrix(self):
         self.icalc.hazard.get_fraction.assert_called_once_with(centroid_idx)
 
 
+@patch.object(Impact, "from_eih")
+class TestReturnImpact(unittest.TestCase):
+    """Test the functionality of _return_impact without digging into the called methods
+
+    This test patches the classmethod `Impact.from_eih` with a mock, so that the input
+    variables don't need to make sense. The mock is passed to the test methods via the
+    `from_eih_mock` argument for convenience.
+    """
+
+    def setUp(self):
+        """Mock the methods called by _return_impact"""
+        self.icalc = ImpactCalc(ENT.exposures, ENT.impact_funcs, HAZ)
+        self.icalc.stitch_impact_matrix = MagicMock(return_value="stitched_matrix")
+        self.icalc.risk_metrics = MagicMock(
+            return_value=("at_event", "eai_exp", "aai_agg")
+        )
+        self.icalc.stitch_risk_metrics = MagicMock(
+            return_value=("at_event", "eai_exp", "aai_agg")
+        )
+        self.imp_mat_gen = "imp_mat_gen"
+
+    def test_save_mat(self, from_eih_mock):
+        """Test _return_impact when impact matrix is saved"""
+        self.icalc._return_impact(self.imp_mat_gen, save_mat=True)
+        from_eih_mock.assert_called_once_with(
+            ENT.exposures,
+            ENT.impact_funcs,
+            HAZ,
+            "at_event",
+            "eai_exp",
+            "aai_agg",
+            "stitched_matrix",
+        )
+
+        self.icalc.stitch_impact_matrix.assert_called_once_with(self.imp_mat_gen)
+        self.icalc.risk_metrics.assert_called_once_with(
+            "stitched_matrix", HAZ.frequency
+        )
+        self.icalc.stitch_risk_metrics.assert_not_called()
+
+    def test_skip_mat(self, from_eih_mock):
+        """Test _return_impact when impact matrix is NOT saved"""
+        self.icalc._return_impact(self.imp_mat_gen, save_mat=False)
+
+        # Need to check every argument individually due to the last one being a matrix
+        call_args = from_eih_mock.call_args.args
+        self.assertEqual(call_args[0], ENT.exposures)
+        self.assertEqual(call_args[1], ENT.impact_funcs)
+        self.assertEqual(call_args[2], HAZ)
+        self.assertEqual(call_args[3], "at_event")
+        self.assertEqual(call_args[4], "eai_exp")
+        self.assertEqual(call_args[5], "aai_agg")
+        np.testing.assert_array_equal(
+            from_eih_mock.call_args.args[-1], sparse.csr_matrix((0, 0)).toarray()
+        )
+
+        self.icalc.stitch_impact_matrix.assert_not_called()
+        self.icalc.risk_metrics.assert_not_called()
+        self.icalc.stitch_risk_metrics.assert_called_once_with(self.imp_mat_gen)
+
+
 # Execute Tests
 if __name__ == "__main__":
     TESTS = unittest.TestLoader().loadTestsFromTestCase(TestImpactCalc)
+    TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestReturnImpact))
     TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestImpactMatrix))
     TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestImpactMatrixCalc))
     TESTS.addTests(

From d5341f33baaafd67a1d754157f79c465578e53d8 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Mon, 20 Jun 2022 10:06:05 +0200
Subject: [PATCH 099/121] Update docstring

---
 climada/engine/test/test_impact_calc.py | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/climada/engine/test/test_impact_calc.py b/climada/engine/test/test_impact_calc.py
index f8f14b38f..cd6f78cef 100644
--- a/climada/engine/test/test_impact_calc.py
+++ b/climada/engine/test/test_impact_calc.py
@@ -27,6 +27,7 @@
 
 from climada import CONFIG
 from climada.entity.entity_def import Entity
+from climada.entity import Exposures, ImpactFuncSet
 from climada.hazard.base import Hazard
 from climada.engine import ImpactCalc, Impact
 from climada.util.constants import ENT_DEMO_TODAY, DEMO_DIR
@@ -233,7 +234,7 @@ def test_minimal_exp_gdf(self):
 
     def test_stitch_impact_matrix(self):
         """Check how sparse matrices from a generator are stitched together"""
-        icalc = ImpactCalc(ENT.exposures, ENT.impact_funcs, HAZ)
+        icalc = ImpactCalc(Exposures(), ImpactFuncSet(), Hazard())
         icalc.n_events = 3
         icalc.n_exp_pnt = 4
 
@@ -264,7 +265,7 @@ def test_apply_deductible_to_mat(self):
 
     def test_stitch_risk_metrics(self):
         """Test computing risk metrics from an impact matrix generator"""
-        icalc = ImpactCalc(ENT.exposures, ENT.impact_funcs, HAZ)
+        icalc = ImpactCalc(Exposures(), ImpactFuncSet(), Hazard())
         icalc.n_events = 2
         icalc.n_exp_pnt = 3
         icalc.hazard.frequency = np.array([2, 0.5])
@@ -285,7 +286,7 @@ class TestImpactMatrixCalc(unittest.TestCase):
     """Verify the computation of the impact matrix"""
 
     def setUp(self):
-        # Mock the methods called by 'impact_matrix'
+        """Mock the methods called by 'impact_matrix'"""
         self.hazard = create_autospec(HAZ)
         self.hazard.get_mdr.return_value = sparse.csr_matrix(
             [[0.0, 0.5, -1.0], [1.0, 2.0, 1.0]]
@@ -418,7 +419,9 @@ def test_empty_exp(self):
 
 
 class TestInsuredImpactMatrixGenerator(unittest.TestCase):
+    """Verify the computation of the insured impact matrix"""
     def setUp(self):
+        """"Initialize mocks"""
         hazard = create_autospec(HAZ)
         self.icalc = ImpactCalc(ENT.exposures, ENT.impact_funcs, hazard)
         self.icalc.exposures.gdf = pd.DataFrame(
@@ -435,6 +438,7 @@ def setUp(self):
         self.icalc.impfset.get_func = MagicMock(side_effect=["impf_0", "impf_2"])
 
     def test_insured_mat_gen(self):
+        """Test insured impact matrix generator"""
         exp_gdf = pd.DataFrame(
             {"impact_functions": [0, 2], "centr_col": [0, 10], "value": [1.0, 2.0],}
         )
@@ -470,7 +474,9 @@ def test_insured_mat_gen(self):
 
 
 class TestImpactMatrix(unittest.TestCase):
+    """Test Impact matrix computation"""
     def setUp(self):
+        """Initialize mock"""
         hazard = create_autospec(HAZ)
         impact_funcs = create_autospec(ENT.impact_funcs)
         self.icalc = ImpactCalc(ENT.exposures, impact_funcs, hazard)

From 4eead8615bd919ef629aeea4e59432c5d74bbb41 Mon Sep 17 00:00:00 2001
From: emanuel-schmid <schmide@ethz.ch>
Date: Mon, 20 Jun 2022 14:17:14 +0200
Subject: [PATCH 100/121] pydoc cosmetics

---
 climada/engine/impact.py      | 18 +++++++++---------
 climada/engine/impact_calc.py |  4 ++--
 climada/engine/impact_data.py | 10 +++++-----
 3 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 07f01c539..69f6c3222 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -630,17 +630,17 @@ def plot_hexbin_impact_exposure(self, event_id=1, mask=None, ignore_zero=False,
         extend : str, optional
             extend border colorbar with arrows.
             [ 'neither' | 'both' | 'min' | 'max' ]
-        kwargs : optional
-            arguments for hexbin matplotlib function
         axis : matplotlib.axes._subplots.AxesSubplot
             optional axis to use
         adapt_fontsize : bool, optional
             If set to true, the size of the fonts will be adapted to the size of the figure.
             Otherwise the default matplotlib font size is used. Default is True.
-
+        kwargs : optional
+            arguments for hexbin matplotlib function
+        
         Returns
-        --------
-            matplotlib.figure.Figure, cartopy.mpl.geoaxes.GeoAxesSubplot
+        -------
+        matplotlib.figure.Figure | cartopy.mpl.geoaxes.GeoAxesSubplot
         """
         if self.imp_mat.size == 0:
             raise ValueError('Attribute imp_mat is empty. Recalculate Impact'
@@ -723,7 +723,7 @@ def plot_rp_imp(self, return_periods=(25, 50, 100, 250),
             used in event plots
 
         Returns
-        --------
+        -------
         matplotlib.axes._subplots.AxesSubplot,
         np.ndarray (return_periods.size x num_centroids)
         """
@@ -838,7 +838,7 @@ def read_sparse_csr(file_name):
 
         Parameters
         ----------
-        file_name : str file name
+        file_name : str
 
         Returns
         -------
@@ -1185,8 +1185,8 @@ def select(self,
         If multiple input variables are not None, it returns all the impacts
         matching at least one of the conditions.
 
-        Note
-        ----
+        Notes
+        -----
             the frequencies are NOT adjusted. Method to adjust frequencies
         and obtain correct eai_exp:
             1- Select subset of impact according to your choice
diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index 60958c7b1..92d696116 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -120,8 +120,8 @@ def impact(self, save_mat=True):
             >>> imp = impcalc.insured_impact()
             >>> imp.aai_agg
 
-        Note
-        ----
+        Notes
+        -----
         Deductible and/or cover values in the exposures are ignored.
         """
         impf_col = self.exposures.get_impf_column(self.hazard.haz_type)
diff --git a/climada/engine/impact_data.py b/climada/engine/impact_data.py
index 82bf63772..38c672d68 100644
--- a/climada/engine/impact_data.py
+++ b/climada/engine/impact_data.py
@@ -283,6 +283,7 @@ def hit_country_per_hazard(intensity_path, names_path, reg_id_path, date_path):
     # retrun data frame with all hit countries per hazard
     return hit_countries
 
+
 def create_lookup(emdat_data, start, end, disaster_subtype='Tropical cyclone'):
     """create_lookup: prepare a lookup table of EMdat events to which hazards can be assigned
 
@@ -440,6 +441,7 @@ def assign_track_to_em(lookup, possible_tracks_1, possible_tracks_2, level):
             lookup.possible_track_all.values[i] = possible_tracks_1[i]
     return lookup
 
+
 def check_assigned_track(lookup, checkset):
     """compare lookup with assigned tracks to a set with checked sets
 
@@ -670,13 +672,10 @@ def scale_impact2refyear(impact_values, year_values, iso3a_values, reference_yea
         Year of each impact (same length as impact_values)
     iso3a_values : list or array
         ISO3alpha code of country for each impact (same length as impact_values)
-
-    Optional Parameters
-    -------------------
-    reference_year : int
+    reference_year : int, optional
         Impact is scaled proportional to GDP to the value of the reference year.
         No scaling for reference_year=None (default)
-        """
+    """
     impact_values = np.array(impact_values)
     year_values = np.array(year_values)
     iso3a_values = np.array(iso3a_values)
@@ -831,6 +830,7 @@ def emdat_impact_event(emdat_file_csv, countries=None, hazard=None, year_range=N
         df_data['impact_scaled'] *= 1e3
     return df_data.reset_index(drop=True)
 
+
 def emdat_to_impact(emdat_file_csv, hazard_type_climada, year_range=None, countries=None,
                     hazard_type_emdat=None,
                     reference_year=None, imp_str="Total Damages"):

From a2c773dda0010c35d6b7281e84886c7b773fcc81 Mon Sep 17 00:00:00 2001
From: emanuel-schmid <schmide@ethz.ch>
Date: Mon, 20 Jun 2022 14:53:34 +0200
Subject: [PATCH 101/121] pydoc cosmetics

---
 climada/engine/forecast.py    |  2 +-
 climada/engine/impact.py      | 27 ++++++++++++++-------------
 climada/engine/impact_calc.py |  1 +
 climada/engine/impact_data.py |  3 +++
 4 files changed, 19 insertions(+), 14 deletions(-)

diff --git a/climada/engine/forecast.py b/climada/engine/forecast.py
index 2afd208f7..7e9acc508 100644
--- a/climada/engine/forecast.py
+++ b/climada/engine/forecast.py
@@ -1211,7 +1211,7 @@ def plot_hexbin_ei_exposure(self, run_datetime=None, figsize=(9, 13)):
             The default is (9, 13)
         Returns
         -------
-        axes : cartopy.mpl.geoaxes.GeoAxesSubplot
+        cartopy.mpl.geoaxes.GeoAxesSubplot
         """
         # select hazard with run_datetime
         if run_datetime is None:
diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 69f6c3222..084a054cd 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -258,7 +258,7 @@ def transfer_risk(self, attachment, cover):
 
         Returns
         -------
-        transfer_at_event : np.array()
+        transfer_at_event : np.array
             risk transfered per event
         transfer_aai_agg : float
             average  annual risk transfered
@@ -284,7 +284,7 @@ def residual_risk(self, attachment, cover):
 
         Returns
         -------
-        residual_at_event : np.array()
+        residual_at_event : np.array
             residual risk per event
         residual_aai_agg : float
             average annual residual risk
@@ -348,7 +348,7 @@ def impact_per_year(self, all_years=True, year_range=None):
             start and end year
         Returns
         -------
-        year_set: dict
+        year_set : dict
             Key=year, value=Summed impact per year.
         """
         if year_range is None:
@@ -427,7 +427,7 @@ def calc_freq_curve(self, return_per=None):
 
         Returns
         -------
-            ImpactFreqCurve
+        ImpactFreqCurve
         """
         ifc = ImpactFreqCurve()
         ifc.tag = self.tag
@@ -478,7 +478,7 @@ def plot_scatter_eai_exposure(self, mask=None, ignore_zero=True,
 
         Returns
         -------
-            cartopy.mpl.geoaxes.GeoAxesSubplot
+        cartopy.mpl.geoaxes.GeoAxesSubplot
         """
         if 'cmap' not in kwargs:
             kwargs['cmap'] = CMAP_IMPACT
@@ -516,7 +516,7 @@ def plot_hexbin_eai_exposure(self, mask=None, ignore_zero=True,
 
         Returns
         -------
-            cartopy.mpl.geoaxes.GeoAxesSubplot
+        cartopy.mpl.geoaxes.GeoAxesSubplot
         """
         if 'cmap' not in kwargs:
             kwargs['cmap'] = CMAP_IMPACT
@@ -640,7 +640,7 @@ def plot_hexbin_impact_exposure(self, event_id=1, mask=None, ignore_zero=False,
         
         Returns
         -------
-        matplotlib.figure.Figure | cartopy.mpl.geoaxes.GeoAxesSubplot
+        cartopy.mpl.geoaxes.GeoAxesSubplot
         """
         if self.imp_mat.size == 0:
             raise ValueError('Attribute imp_mat is empty. Recalculate Impact'
@@ -683,7 +683,8 @@ def plot_basemap_impact_exposure(self, event_id=1, mask=None, ignore_zero=False,
             zoom coefficient used in the satellite image
         url : str, optional
             image source, e.g. ctx.sources.OSM_C
-        axis  : matplotlib.axes._subplots.AxesSubplot, optional axis to use
+        axis  : matplotlib.axes._subplots.AxesSubplot, optional
+            axis to use
         kwargs : optional arguments for scatter matplotlib function, e.g.
             cmap='Greys'. Default: 'Wistia'
 
@@ -724,8 +725,9 @@ def plot_rp_imp(self, return_periods=(25, 50, 100, 250),
 
         Returns
         -------
-        matplotlib.axes._subplots.AxesSubplot,
-        np.ndarray (return_periods.size x num_centroids)
+        axis : matplotlib.axes._subplots.AxesSubplot
+        imp_stats : np.array
+            return_periods.size x num_centroids
         """
         imp_stats = self.local_exceedance_imp(np.array(return_periods))
         if imp_stats.size == 0:
@@ -992,7 +994,7 @@ def video_direct_impact(exp, impf_set, haz_list, file_name='',
 
         Returns
         -------
-        list(Impact)
+        list of Impact
         """
         if args_exp is None:
             args_exp = dict()
@@ -1208,7 +1210,7 @@ def select(self,
             than start-date and <= than end-date. Dates in same format
             as impact.date (ordinal format of datetime library)
             The default is None.
-        coord_exp : np.ndarray, optional
+        coord_exp : np.array, optional
             Selection of exposures coordinates [lat, lon] (in degrees)
             The default is None.
 
@@ -1222,7 +1224,6 @@ def select(self,
         -------
         imp : climada.engine.impact.Impact
             A new impact object with a selection of events and/or exposures
-
         """
 
         nb_events = self.event_id.size
diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index 92d696116..e4c69fb0c 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -31,6 +31,7 @@
 
 LOGGER = logging.getLogger(__name__)
 
+
 class ImpactCalc():
     """
     Class to compute impacts from exposures, impact function set and hazard
diff --git a/climada/engine/impact_data.py b/climada/engine/impact_data.py
index 38c672d68..985bb1480 100644
--- a/climada/engine/impact_data.py
+++ b/climada/engine/impact_data.py
@@ -621,6 +621,7 @@ def clean_emdat_df(emdat_file, countries=None, hazard=None, year_range=None,
             (df_data[VARNAMES_EMDAT[target_version]['Disaster Subtype']].isin(disaster_subtypes))]
     return df_data.reset_index(drop=True)
 
+
 def emdat_countries_by_hazard(emdat_file_csv, hazard=None, year_range=None):
     """return list of all countries exposed to a chosen hazard type
     from EMDAT data as CSV.
@@ -701,6 +702,7 @@ def scale_impact2refyear(impact_values, year_values, iso3a_values, reference_yea
         return impact_values
     raise ValueError('Invalid reference_year')
 
+
 def emdat_impact_yearlysum(emdat_file_csv, countries=None, hazard=None, year_range=None,
                            reference_year=None, imp_str="Total Damages ('000 US$)",
                            version=2020):
@@ -768,6 +770,7 @@ def emdat_impact_yearlysum(emdat_file_csv, countries=None, hazard=None, year_ran
     out = out.reset_index(drop=True)
     return out
 
+
 def emdat_impact_event(emdat_file_csv, countries=None, hazard=None, year_range=None,
                        reference_year=None, imp_str="Total Damages ('000 US$)",
                        version=2020):

From 1c318a4b1f31c47f1a88ece4f1f6887fd83353e3 Mon Sep 17 00:00:00 2001
From: emanuel-schmid <schmide@ethz.ch>
Date: Mon, 20 Jun 2022 17:39:57 +0200
Subject: [PATCH 102/121] pydoc consolidation

---
 climada/engine/impact.py      | 140 +++++++++++++++++++---------------
 climada/engine/impact_calc.py |  10 +--
 2 files changed, 84 insertions(+), 66 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 084a054cd..b70a749e7 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -102,35 +102,35 @@ def __init__(self,
 
         Attributes
         ----------
-        tag : dict
-            dictionary of tags of exposures, impact functions set and
-            hazard: {'exp': Tag(), 'impf_set': Tag(), 'haz': TagHazard()}
-        event_id : np.array
+        event_id : np.array, optional
             id (>0) of each hazard event
-        event_name : list
+        event_name : list, optional
             list name of each hazard event
-        date : np.array
+        date : np.array, optional
             date if events as integer date corresponding to the
             proleptic Gregorian ordinal, where January 1 of year 1 has
             ordinal 1 (ordinal format of datetime library)
-        coord_exp : np.array
+        frequency : np.array, optional
+            annual frequency of event impact for each hazard event
+        coord_exp : np.array, optional
             exposures coordinates [lat, lon] (in degrees)
-        eai_exp : np.array
+        crs : Any, optional
+            coordinate reference system
+        eai_exp : np.array, optional
             expected annual impact for each exposure
-        at_event : np.array
+        at_event : np.array, optional
             impact for each hazard event
-        frequency : np.array
-            annual frequency of event
-        tot_value : float
+        tot_value : float, optional
             total exposure value affected
-        aai_agg : float
+        aai_agg : float, optional
             average annual impact (aggregated)
-        unit : str
+        unit : str, optional
             value unit used (given by exposures unit)
-        imp_mat : sparse.csr_matrix
+        imp_mat : sparse.csr_matrix, optional
             matrix num_events x num_exp with impacts.
-            Default is None (empty matrix)
-
+        tag : dict, optional
+            dictionary of tags of exposures, impact functions set and
+            hazard: {'exp': Tag(), 'impf_set': Tag(), 'haz': TagHazard()}
         """
 
         self.tag = tag or {}
@@ -208,11 +208,17 @@ def from_eih(cls, exposures, impfset, hazard,
         ----------
         exposures : climada.entity.Exposures
             exposure used to compute imp_mat
-        impf_set: climada.entity.ImpactFuncSet
+        impfset: climada.entity.ImpactFuncSet
             impact functions set used to compute imp_mat
         hazard : climada.Hazard
             hazard used to compute imp_mat
-        imp_mat : sparse.csr_matrix
+        at_event : np.array
+            impact for each hazard event
+        eai_exp : np.array
+            expected annual impact for each exposure
+        aai_agg : float
+            average annual impact (aggregated)
+        imp_mat : sparse.csr_matrix, optional
             matrix num_events x num_exp with impacts.
             Default is None (empty sparse csr matrix).
 
@@ -252,7 +258,7 @@ def transfer_risk(self, attachment, cover):
         Parameters
         ----------
         attachment : float
-           attachment per event for entire portfolio.
+            attachment per event for entire portfolio.
         cover : float
             cover per event for entire portfolio.
 
@@ -341,10 +347,11 @@ def impact_per_year(self, all_years=True, year_range=None):
 
         Parameters
         ----------
-        all_years : boolean
+        all_years : boolean, optional
             return values for all years between first and
             last year with event, including years without any events.
-        year_range : tuple or list with integers
+            Default: True
+        year_range : tuple or list with integers, optional
             start and end year
         Returns
         -------
@@ -387,7 +394,9 @@ def local_exceedance_imp(self, return_periods=(25, 50, 100, 250)):
 
         Parameters
         ----------
-        return_periods : np.array return periods to consider
+        return_periods : Any, optional
+            return periods to consider
+            Dafault is (25, 50, 100, 250)
 
         Returns
         -------
@@ -468,12 +477,12 @@ def plot_scatter_eai_exposure(self, mask=None, ignore_zero=True,
         extend : str
             optional extend border colorbar with arrows.
             [ 'neither' | 'both' | 'min' | 'max' ]
-        axis  : matplotlib.axes._subplots.AxesSubplot, optional
+        axis : matplotlib.axes.Axes, optional
             axis to use
         adapt_fontsize : bool, optional
-                If set to true, the size of the fonts will be adapted to the size of the figure.
-                Otherwise the default matplotlib font size is used. Default is True.
-        kwargs : optional
+            If set to true, the size of the fonts will be adapted to the size of the figure.
+            Otherwise the default matplotlib font size is used. Default is True.
+        kwargs : dict, optional
             arguments for hexbin matplotlib function
 
         Returns
@@ -509,9 +518,12 @@ def plot_hexbin_eai_exposure(self, mask=None, ignore_zero=True,
             extend : str, optional
                 extend border colorbar with arrows.
                 [ 'neither' | 'both' | 'min' | 'max' ]
-            axis : matplotlib.axes._subplots.AxesSubplot, optional
+            axis : matplotlib.axes.Axes, optional
                 axis to use
-            kwargs : optional
+            adapt_fontsize : bool, optional
+                If set to true, the size of the fonts will be adapted to the size of the figure.
+                Otherwise the default matplotlib font size is used. Default: True
+            kwargs : dict, optional
                 arguments for hexbin matplotlib function
 
         Returns
@@ -545,13 +557,14 @@ def plot_raster_eai_exposure(self, res=None, raster_res=None, save_tiff=None,
             format, if provided
         raster_f : lambda function
             transformation to use to data. Default: log10 adding 1.
-        label : str colorbar label
-        axis : matplotlib.axes._subplots.AxesSubplot, optional
+        label : str
+            colorbar label
+        axis : matplotlib.axes.Axes, optional
             axis to use
         adapt_fontsize : bool, optional
-                If set to true, the size of the fonts will be adapted to the size of the figure.
-                Otherwise the default matplotlib font size is used. Default is True.
-        kwargs : optional
+            If set to true, the size of the fonts will be adapted to the size of the figure.
+            Otherwise the default matplotlib font size is used. Default is True.
+        kwargs : dict, optional
             arguments for imshow matplotlib function
 
         Returns
@@ -588,9 +601,9 @@ def plot_basemap_eai_exposure(self, mask=None, ignore_zero=False, pop_name=True,
             zoom coefficient used in the satellite image
         url : str, optional
             image source, e.g. ctx.sources.OSM_C
-        axis : matplotlib.axes._subplots.AxesSubplot, optional
+        axis : matplotlib.axes.Axes, optional
             axis to use
-        kwargs : optional
+        kwargs : dict, optional
             arguments for scatter matplotlib function, e.g.
             cmap='Greys'. Default: 'Wistia'
 
@@ -630,12 +643,12 @@ def plot_hexbin_impact_exposure(self, event_id=1, mask=None, ignore_zero=False,
         extend : str, optional
             extend border colorbar with arrows.
             [ 'neither' | 'both' | 'min' | 'max' ]
-        axis : matplotlib.axes._subplots.AxesSubplot
+        axis : matplotlib.axes.Axes
             optional axis to use
         adapt_fontsize : bool, optional
             If set to true, the size of the fonts will be adapted to the size of the figure.
             Otherwise the default matplotlib font size is used. Default is True.
-        kwargs : optional
+        kwargs : dict, optional
             arguments for hexbin matplotlib function
         
         Returns
@@ -683,10 +696,11 @@ def plot_basemap_impact_exposure(self, event_id=1, mask=None, ignore_zero=False,
             zoom coefficient used in the satellite image
         url : str, optional
             image source, e.g. ctx.sources.OSM_C
-        axis  : matplotlib.axes._subplots.AxesSubplot, optional
+        axis : matplotlib.axes.Axes, optional
             axis to use
-        kwargs : optional arguments for scatter matplotlib function, e.g.
-            cmap='Greys'. Default: 'Wistia'
+        kwargs : dict, optional
+            arguments for scatter matplotlib function, e.g. cmap='Greys'.
+            Default: 'Wistia'
 
         Returns
         -------
@@ -713,19 +727,19 @@ def plot_rp_imp(self, return_periods=(25, 50, 100, 250),
 
         Parameters
         ----------
-        return_periods : tuple(int), optional
-            return periods to consider
+        return_periods : tuple of int, optional
+            return periods to consider. Default: (25, 50, 100, 250)
         log10_scale : boolean, optional
-            plot impact as log10(impact)
+            plot impact as log10(impact). Default: True
         smooth : bool, optional
-            smooth plot to plot.RESOLUTIONxplot.RESOLUTION
-        kwargs : optional
+            smooth plot to plot.RESOLUTIONxplot.RESOLUTION. Default: True
+        kwargs : dict, optional
             arguments for pcolormesh matplotlib function
             used in event plots
 
         Returns
         -------
-        axis : matplotlib.axes._subplots.AxesSubplot
+        axis : matplotlib.axes.Axes
         imp_stats : np.array
             return_periods.size x num_centroids
         """
@@ -857,7 +871,8 @@ def from_csv(cls, file_name):
 
         Parameters
         ----------
-        file_name : str absolute path of the file
+        file_name : str
+            absolute path of the file
 
         Returns
         -------
@@ -907,7 +922,8 @@ def from_excel(cls, file_name):
 
         Parameters
         ----------
-        file_name : str absolute path of the file
+        file_name : str
+            absolute path of the file
 
         Returns
         -------
@@ -977,12 +993,12 @@ def video_direct_impact(exp, impf_set, haz_list, file_name='',
             file name to save video, if provided
         writer : matplotlib.animation.*, optional
             video writer. Default: pillow with bitrate=500
-        imp_thresh : float
-            represent damages greater than threshold
-        args_exp : optional
+        imp_thresh : float, optional
+            represent damages greater than threshold. Default: 0
+        args_exp : dict, optional
             arguments for scatter (points) or hexbin (raster)
             matplotlib function used in exposures
-        args_imp : optional
+        args_imp : dict, optional
             arguments for scatter (points) or hexbin (raster)
             matplotlib function used in impact
         ignore_zero : bool, optional
@@ -1084,8 +1100,10 @@ def _loc_return_imp(self, return_periods, imp, exc_imp):
 
         Parameters
         ----------
-        return_periods : np.array return periods to consider
-        cen_pos (int): centroid position
+        return_periods : np.array
+            return periods to consider
+        cen_pos :int
+            centroid position
 
         Returns
         -------
@@ -1201,11 +1219,11 @@ def select(self,
 
         Parameters
         ----------
-        event_ids : list[int], optional
+        event_ids : list of int, optional
             Selection of events by their id. The default is None.
-        event_names : list[str], optional
+        event_names : list of str, optional
             Selection of events by their name. The default is None.
-        dates : tuple(), optional
+        dates : tuple, optional
             (start-date, end-date), events are selected if they are >=
             than start-date and <= than end-date. Dates in same format
             as impact.date (ordinal format of datetime library)
@@ -1376,16 +1394,16 @@ def plot(self, axis=None, log_frequency=False, **kwargs):
 
         Parameters
         ----------
-        axis  : matplotlib.axes._subplots.AxesSubplot, optional
+        axis : matplotlib.axes.Axes, optional
             axis to use
         log_frequency : boolean, optional
             plot logarithmioc exceedance frequency on x-axis
-        kwargs : optional
+        kwargs : dict, optional
             arguments for plot matplotlib function, e.g. color='b'
 
         Returns
         -------
-        matplotlib.axes._subplots.AxesSubplot
+        matplotlib.axes.Axes
         """
         if not axis:
             _, axis = plt.subplots(1, 1)
diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index e4c69fb0c..c82c6935c 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -195,7 +195,7 @@ def _return_impact(self, imp_mat_gen, save_mat):
 
         See Also
         --------
-        imp_mat_gen: impact matrix generator
+        imp_mat_gen : impact matrix generator
         insured_mat_gen: insured impact matrix generator
 
         """
@@ -216,7 +216,7 @@ def minimal_exp_gdf(self, impf_col):
         ----------
         exposures : climada.entity.Exposures
         hazard : climada.Hazard
-        impf_col: stirng
+        impf_col: str
             name of the impact function column in exposures.gdf
 
         """
@@ -247,7 +247,7 @@ def imp_mat_gen(self, exp_gdf, impf_col):
         exp_gdf : GeoDataFrame
             Geodataframe of the exposures with columns required for impact
             computation.
-        impf_col : string
+        impf_col : str
             name of the desired impact column in the exposures.
 
         Raises
@@ -293,7 +293,7 @@ def insured_mat_gen(self, imp_mat_gen, exp_gdf, impf_col):
 
         Parameters
         ----------
-        imp_mat_gen : Generator yielding (sparse.csr_matrix, np.array)
+        imp_mat_gen : generator of tuples (sparse.csr_matrix, np.array)
             The generator for creating the impact matrix. It returns a part of the full
             matrix and the associated exposure indices.
         exp_gdf : GeoDataFrame
@@ -368,7 +368,7 @@ def stitch_risk_metrics(self, imp_mat_gen):
 
         Parameters
         ----------
-        imp_mat_gen : Generator yielding (sparse.csr_matrix, np.array)
+        imp_mat_gen : generator of tuples (sparse.csr_matrix, np.array)
             The generator for creating the impact matrix. It returns a part of the full
             matrix and the associated exposure indices.
 

From e4daf2b52b68bbd6ee61f040631666cc1519f695 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Fri, 24 Jun 2022 13:39:26 +0200
Subject: [PATCH 103/121] Improve attribute error message from_eih

---
 climada/engine/impact.py | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index b70a749e7..812467fa2 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -147,17 +147,21 @@ def __init__(self,
         self.unit = unit
 
         if len(self.event_id) != len(self.event_name):
-            raise AttributeError('Hazard event ids and event names'
-                                 ' are not of the same length')
+            raise AttributeError(
+                f'Hazard event ids {len(self.event_id)} and event names'
+                f' {len(self.event_name)} are not of the same length')
         if len(self.event_id) != len(self.date):
-            raise AttributeError('Hazard event ids and event dates'
-                             ' are not of the same length')
+            raise AttributeError(
+                f'Hazard event ids {len(self.event_id)} and event dates'
+                f' {len(self.date)} are not of the same length')
         if len(self.event_id) != len(self.frequency):
-            raise AttributeError('Hazard event ids and event frequency'
-                                 ' are not of the same length')
+            raise AttributeError(
+                f'Hazard event ids {len(self.event_id)} and event frequency'
+                f' {len(self.frequency)} are not of the same length')
         if len(self.event_id) != len(self.at_event):
-            raise AttributeError('Number of hazard event ids is different '
-                                 'from number of at_event values')
+            raise AttributeError(
+                f'Number of hazard event ids {len(self.event_id)} is different '
+                f'from number of at_event values {len(self.at_event)}')
         if len(self.coord_exp) != len(self.eai_exp):
             raise AttributeError('Number of exposures points is different from'
                                  'number of eai_exp values')
@@ -650,7 +654,7 @@ def plot_hexbin_impact_exposure(self, event_id=1, mask=None, ignore_zero=False,
             Otherwise the default matplotlib font size is used. Default is True.
         kwargs : dict, optional
             arguments for hexbin matplotlib function
-        
+
         Returns
         -------
         cartopy.mpl.geoaxes.GeoAxesSubplot

From 1f5322e4f1c1282c9f8fe3a3a5b3b037d14d5c89 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Fri, 24 Jun 2022 13:39:37 +0200
Subject: [PATCH 104/121] Update from_eih tests

---
 climada/engine/test/test_impact.py | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/climada/engine/test/test_impact.py b/climada/engine/test/test_impact.py
index 600c42bac..5a6a09c06 100644
--- a/climada/engine/test/test_impact.py
+++ b/climada/engine/test/test_impact.py
@@ -55,20 +55,21 @@ class TestImpact(unittest.TestCase):
     """"Test initialization and more"""
     def test_from_eih_pass(self):
         exp = ENT.exposures
+        exp.assign_centroids(HAZ)
         tot_value = exp.affected_total_value(HAZ)
         fake_eai_exp = np.arange(len(exp.gdf))
-        fake_at_event = np.arange(len(HAZ.size))
+        fake_at_event = np.arange(HAZ.size)
         fake_aai_agg = np.sum(fake_eai_exp)
         imp = Impact.from_eih(exp, ENT.impact_funcs, HAZ,
-                              fake_eai_exp, fake_at_event, fake_aai_agg)
+                              fake_at_event, fake_eai_exp, fake_aai_agg)
         self.assertEqual(imp.crs, exp.crs)
         self.assertEqual(imp.aai_agg, fake_aai_agg)
-        self.assertIsNone(imp.imp_mat)
+        self.assertEqual(imp.imp_mat.size, 0)
         self.assertEqual(imp.unit, exp.value_unit)
         self.assertEqual(imp.tot_value, tot_value)
         np.testing.assert_array_almost_equal(imp.event_id, HAZ.event_id)
         np.testing.assert_array_almost_equal(imp.event_name, HAZ.event_name)
-        np.testing.assert_array_almost_equal(imp.data, HAZ.data)
+        np.testing.assert_array_almost_equal(imp.date, HAZ.date)
         np.testing.assert_array_almost_equal(imp.frequency, HAZ.frequency)
         np.testing.assert_array_almost_equal(imp.eai_exp, fake_eai_exp)
         np.testing.assert_array_almost_equal(imp.at_event, fake_at_event)
@@ -700,4 +701,5 @@ def test__exp_build_event(self):
     TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestRiskTrans))
     TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestSelect))
     TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestConvertExp))
+    TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestImpact))
     unittest.TextTestRunner(verbosity=2).run(TESTS)

From 8c393c91cc7a60bd441d8fc0a42ef9325661e5be Mon Sep 17 00:00:00 2001
From: emanuel-schmid <schmide@ethz.ch>
Date: Fri, 24 Jun 2022 17:49:43 +0200
Subject: [PATCH 105/121] impact_calc.ImpactCalc: remove imp_mat attribute turn
 n_exp_pnt and n_events into properties set cover and deductible to None if
 not set (instead of an empty array)

---
 climada/engine/impact_calc.py           | 59 ++++++++++++-------------
 climada/engine/test/test_impact_calc.py | 13 +++---
 2 files changed, 34 insertions(+), 38 deletions(-)

diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index c82c6935c..f35796d73 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -40,10 +40,9 @@ class ImpactCalc():
     def __init__(self,
                  exposures,
                  impfset,
-                 hazard,
-                 imp_mat=None):
+                 hazard):
         """
-        Initialize an ImpactCalc object.
+        ImpactCalc constructor
 
         The dimension of the imp_mat variable must be compatible with the
         exposures and hazard objects.
@@ -51,33 +50,33 @@ def __init__(self,
         Parameters
         ----------
         exposures : climada.entity.Exposures
-            exposure used to compute imp_mat
+            exposures used to compute imp_mat, the object is subject to change when ImpactCalc
+            methods are executed.
         impf_set: climada.entity.ImpactFuncSet
             impact functions set used to compute imp_mat
         hazard : climada.Hazard
             hazard used to compute imp_mat
-        imp_mat : sparse.csr_matrix, optional
-            matrix num_events x num_exp with impacts.
-            Default is an empty matrix.
-
-        Returns
-        -------
-        None.
 
         """
 
         self.exposures = exposures
         self.impfset = impfset
         self.hazard = hazard
-        self.imp_mat = imp_mat if imp_mat is not None else sparse.csr_matrix((0, 0))
-        self.n_exp_pnt = self.exposures.gdf.shape[0]
-        self.n_events = self.hazard.size
+
+    @property
+    def n_exp_pnt(self):
+        """Number of exposure points (rows in gdf)"""
+        return self.exposures.gdf.shape[0]
+    
+    @property
+    def n_events(self):
+        """Number of hazard events (size of event_id array)"""
+        return self.hazard.size
 
     @property
     def deductible(self):
         """
-        Deductibles from the exposures. Returns empty array
-        if no deductibles defined.
+        Deductibles from the exposures. Returns None if no deductibles defined.
 
         Returns
         -------
@@ -87,12 +86,11 @@ def deductible(self):
         """
         if 'deductible' in self.exposures.gdf.columns:
             return self.exposures.gdf['deductible'].to_numpy()
-        return np.array([])
 
     @property
     def cover(self):
         """
-        Covers from the exposures. Returns empty array if no covers defined.
+        Covers from the exposures. Returns None if no covers defined.
 
         Returns
         -------
@@ -102,9 +100,8 @@ def cover(self):
         """
         if 'cover' in self.exposures.gdf.columns:
             return self.exposures.gdf['cover'].to_numpy()
-        return np.array([])
 
-    def impact(self, save_mat=True):
+    def impact(self):
         """Compute the impact of a hazard on exposures.
 
         Parameters
@@ -130,7 +127,7 @@ def impact(self, save_mat=True):
         LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
                     self.n_events, self.n_events)
         imp_mat_gen = self.imp_mat_gen(exp_gdf, impf_col)
-        return self._return_impact(imp_mat_gen, save_mat)
+        return self._return_impact(imp_mat_gen, True)
 
 #TODO: make a better impact matrix generator for insured impacts when
 # the impact matrix is already present
@@ -162,7 +159,7 @@ def insured_impact(self, save_mat=False):
         apply_cover_to_mat:
             apply cover to impact matrix
         """
-        if self.cover.size == 0 and self.deductible.size == 0:
+        if self.cover is None and self.deductible is None:
             raise AttributeError("Neither cover nor deductible defined."
                                  "Please set exposures.gdf.cover"
                                  "and/or exposures.gdf.deductible")
@@ -171,10 +168,8 @@ def insured_impact(self, save_mat=False):
         LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
                     exp_gdf.size, self.hazard.size)
 
-        if self.imp_mat.size == 0:
-            imp_mat_gen = self.imp_mat_gen(exp_gdf, impf_col)
-        else:
-            imp_mat_gen = ((self.imp_mat, np.arange(1, len(exp_gdf))) for n in range(1))
+        imp_mat_gen = self.imp_mat_gen(exp_gdf, impf_col)
+        
         ins_mat_gen = self.insured_mat_gen(imp_mat_gen, exp_gdf, impf_col)
         return self._return_impact(ins_mat_gen, save_mat)
 
@@ -200,13 +195,14 @@ def _return_impact(self, imp_mat_gen, save_mat):
 
         """
         if save_mat:
-            self.imp_mat = self.stitch_impact_matrix(imp_mat_gen)
-            at_event, eai_exp, aai_agg = self.risk_metrics(self.imp_mat, self.hazard.frequency)
+            imp_mat = self.stitch_impact_matrix(imp_mat_gen)
+            at_event, eai_exp, aai_agg = self.risk_metrics(imp_mat, self.hazard.frequency)
         else:
+            imp_mat = None
             at_event, eai_exp, aai_agg = self.stitch_risk_metrics(imp_mat_gen)
         return Impact.from_eih(
             self.exposures, self.impfset, self.hazard,
-            at_event, eai_exp, aai_agg, self.imp_mat
+            at_event, eai_exp, aai_agg, imp_mat
             )
 
     def minimal_exp_gdf(self, impf_col):
@@ -220,7 +216,10 @@ def minimal_exp_gdf(self, impf_col):
             name of the impact function column in exposures.gdf
 
         """
-        self.exposures.assign_centroids(self.hazard, overwrite=False)
+        # since the original exposures object will be "spoiled" through assign_centroids
+        # (a column cent_XY is added), overwrite=True makes sure the exposures can be reused
+        # for ImpactCalc with another Hazard object of the same hazard type.
+        self.exposures.assign_centroids(self.hazard, overwrite=True)
 
         mask = (
             (self.exposures.gdf.value.values != 0)
diff --git a/climada/engine/test/test_impact_calc.py b/climada/engine/test/test_impact_calc.py
index cd6f78cef..fa5706ae0 100644
--- a/climada/engine/test/test_impact_calc.py
+++ b/climada/engine/test/test_impact_calc.py
@@ -60,7 +60,6 @@ def test_init(self):
         icalc = ImpactCalc(ENT.exposures, ENT.impact_funcs, HAZ)
         self.assertEqual(icalc.n_exp_pnt, ENT.exposures.gdf.shape[0])
         self.assertEqual(icalc.n_events, HAZ.size)
-        self.assertEqual(icalc.imp_mat.size, 0)
         self.assertTrue(ENT.exposures.gdf.equals(icalc.exposures.gdf))
         np.testing.assert_array_equal(HAZ.event_id, icalc.hazard.event_id)
         np.testing.assert_array_equal(HAZ.event_name, icalc.hazard.event_name)
@@ -137,7 +136,7 @@ def test_calc_impact_pass(self):
     def test_calc_impact_save_mat_pass(self):
         """Test compute impact with impact matrix"""
         icalc = ImpactCalc(ENT.exposures, ENT.impact_funcs, HAZ)
-        impact = icalc.impact(save_mat=True)
+        impact = icalc.impact()
 
         self.assertIsInstance(impact.imp_mat, sparse.csr_matrix)
         self.assertEqual(impact.imp_mat.shape, (HAZ.event_id.size,
@@ -234,9 +233,8 @@ def test_minimal_exp_gdf(self):
 
     def test_stitch_impact_matrix(self):
         """Check how sparse matrices from a generator are stitched together"""
-        icalc = ImpactCalc(Exposures(), ImpactFuncSet(), Hazard())
-        icalc.n_events = 3
-        icalc.n_exp_pnt = 4
+        icalc = ImpactCalc(Exposures({'blank': [1, 2, 3, 4]}), ImpactFuncSet(), Hazard())
+        icalc.hazard.event_id = np.array([1, 2, 3])
 
         imp_mat_gen = [
             (sparse.csr_matrix([[1.0, 1.0], [0.0, 1.0]]), np.array([0, 1])),
@@ -265,9 +263,8 @@ def test_apply_deductible_to_mat(self):
 
     def test_stitch_risk_metrics(self):
         """Test computing risk metrics from an impact matrix generator"""
-        icalc = ImpactCalc(Exposures(), ImpactFuncSet(), Hazard())
-        icalc.n_events = 2
-        icalc.n_exp_pnt = 3
+        icalc = ImpactCalc(Exposures({'blank': [1, 2, 3]}), ImpactFuncSet(), Hazard())
+        icalc.hazard.event_id = np.array([1, 2])
         icalc.hazard.frequency = np.array([2, 0.5])
 
         # Matrices overlap at central exposure point

From 58449fd29c3431d89b9f2b83c6647c2e674f4c22 Mon Sep 17 00:00:00 2001
From: emanuel-schmid <schmide@ethz.ch>
Date: Fri, 24 Jun 2022 18:09:54 +0200
Subject: [PATCH 106/121] ImpactCalc.impact: re-establish save_mat argument

---
 climada/engine/impact.py      | 4 ++--
 climada/engine/impact_calc.py | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 812467fa2..5135c99a9 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -193,11 +193,11 @@ def calc(self, exposures, impact_funcs, hazard, save_mat=False):
             and exposures.gdf.cover.max():
             LOGGER.warning(
                 "The use of Impact().calc() is deprecated for exposures with "
-                "deductible and/or cover. Use ImpactCalc().impact() instead."
+                "deductible and/or cover. Use ImpactCalc().insured_impact() instead."
                 )
             self.__dict__ = impcalc.insured_impact(save_mat).__dict__
         else:
-            LOGGER.warning("The use of Impact().calc() is deprecated."
+            LOGGER.warning("The use of Impact().calc() is deprecated. "
                            "Use ImpactCalc().impact() instead.")
             self.__dict__ = impcalc.impact(save_mat).__dict__
 
diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index f35796d73..c76429479 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -101,7 +101,7 @@ def cover(self):
         if 'cover' in self.exposures.gdf.columns:
             return self.exposures.gdf['cover'].to_numpy()
 
-    def impact(self):
+    def impact(self, save_mat=True):
         """Compute the impact of a hazard on exposures.
 
         Parameters
@@ -127,7 +127,7 @@ def impact(self):
         LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
                     self.n_events, self.n_events)
         imp_mat_gen = self.imp_mat_gen(exp_gdf, impf_col)
-        return self._return_impact(imp_mat_gen, True)
+        return self._return_impact(imp_mat_gen, save_mat)
 
 #TODO: make a better impact matrix generator for insured impacts when
 # the impact matrix is already present

From 55e5ae7715744d2a4f335b7af6716f981904170f Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Fri, 24 Jun 2022 22:57:43 +0200
Subject: [PATCH 107/121] Set assigned_centroids overwrite=False

---
 climada/engine/impact_calc.py | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index c76429479..7785790f3 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -50,12 +50,11 @@ def __init__(self,
         Parameters
         ----------
         exposures : climada.entity.Exposures
-            exposures used to compute imp_mat, the object is subject to change when ImpactCalc
-            methods are executed.
+            exposures used to compute impacts
         impf_set: climada.entity.ImpactFuncSet
-            impact functions set used to compute imp_mat
+            impact functions set used to compute impacts
         hazard : climada.Hazard
-            hazard used to compute imp_mat
+            hazard used to compute impacts
 
         """
 
@@ -67,7 +66,7 @@ def __init__(self,
     def n_exp_pnt(self):
         """Number of exposure points (rows in gdf)"""
         return self.exposures.gdf.shape[0]
-    
+
     @property
     def n_events(self):
         """Number of hazard events (size of event_id array)"""
@@ -121,6 +120,9 @@ def impact(self, save_mat=True):
         Notes
         -----
         Deductible and/or cover values in the exposures are ignored.
+
+        In case the exposures has no centroids assigned for the given hazard,
+        the column is added to the exposures geodataframe.
         """
         impf_col = self.exposures.get_impf_column(self.hazard.haz_type)
         exp_gdf = self.minimal_exp_gdf(impf_col)
@@ -169,7 +171,7 @@ def insured_impact(self, save_mat=False):
                     exp_gdf.size, self.hazard.size)
 
         imp_mat_gen = self.imp_mat_gen(exp_gdf, impf_col)
-        
+
         ins_mat_gen = self.insured_mat_gen(imp_mat_gen, exp_gdf, impf_col)
         return self._return_impact(ins_mat_gen, save_mat)
 
@@ -216,10 +218,7 @@ def minimal_exp_gdf(self, impf_col):
             name of the impact function column in exposures.gdf
 
         """
-        # since the original exposures object will be "spoiled" through assign_centroids
-        # (a column cent_XY is added), overwrite=True makes sure the exposures can be reused
-        # for ImpactCalc with another Hazard object of the same hazard type.
-        self.exposures.assign_centroids(self.hazard, overwrite=True)
+        self.exposures.assign_centroids(self.hazard, overwrite=False)
 
         mask = (
             (self.exposures.gdf.value.values != 0)

From 7d4e5f609d70902365e6c2ffc395e9a29ac54a39 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Mon, 27 Jun 2022 13:36:18 +0200
Subject: [PATCH 108/121] (Re)-Set ignore zero to False

---
 climada/engine/impact.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 5135c99a9..9bd007321 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -461,7 +461,7 @@ def calc_freq_curve(self, return_per=None):
 
         return ifc
 
-    def plot_scatter_eai_exposure(self, mask=None, ignore_zero=True,
+    def plot_scatter_eai_exposure(self, mask=None, ignore_zero=False,
                                   pop_name=True, buffer=0.0, extend='neither',
                                   axis=None, adapt_fontsize=True, **kwargs):
         """Plot scatter expected annual impact of each exposure.
@@ -502,7 +502,7 @@ def plot_scatter_eai_exposure(self, mask=None, ignore_zero=True,
         axis.set_title('Expected annual impact')
         return axis
 
-    def plot_hexbin_eai_exposure(self, mask=None, ignore_zero=True,
+    def plot_hexbin_eai_exposure(self, mask=None, ignore_zero=False,
                                  pop_name=True, buffer=0.0, extend='neither',
                                  axis=None, adapt_fontsize=True, **kwargs):
         """Plot hexbin expected annual impact of each exposure.
@@ -543,6 +543,7 @@ def plot_hexbin_eai_exposure(self, mask=None, ignore_zero=True,
         axis.set_title('Expected annual impact')
         return axis
 
+
     def plot_raster_eai_exposure(self, res=None, raster_res=None, save_tiff=None,
                                  raster_f=lambda x: np.log10((np.fmax(x + 1, 1))),
                                  label='value (log10)', axis=None, adapt_fontsize=True,

From 1aa558104c978139c58ed1636949be31b56f9cd7 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Mon, 27 Jun 2022 15:04:10 +0200
Subject: [PATCH 109/121] Update deprecation warning message

---
 climada/engine/impact.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/climada/engine/impact.py b/climada/engine/impact.py
index 9bd007321..ea38fef93 100755
--- a/climada/engine/impact.py
+++ b/climada/engine/impact.py
@@ -193,7 +193,9 @@ def calc(self, exposures, impact_funcs, hazard, save_mat=False):
             and exposures.gdf.cover.max():
             LOGGER.warning(
                 "The use of Impact().calc() is deprecated for exposures with "
-                "deductible and/or cover. Use ImpactCalc().insured_impact() instead."
+                "deductible and/or cover. Use ImpactCalc().insured_impact() "
+                " for insured impacts instead. For non-insured impacts "
+                "please use ImpactCalc().impact()"
                 )
             self.__dict__ = impcalc.insured_impact(save_mat).__dict__
         else:

From aaf2f9324894126f2db5d59d83afeb35e7967df1 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Mon, 27 Jun 2022 19:05:36 +0200
Subject: [PATCH 110/121] Correct bug wrong exp_idx

The exposures index from the impact matrix generator was indexed for the reduced exposures only, instead of the total exposures. This leads to wrong indexing.
---
 climada/engine/impact_calc.py | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index 7785790f3..f982c01e1 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -171,7 +171,6 @@ def insured_impact(self, save_mat=False):
                     exp_gdf.size, self.hazard.size)
 
         imp_mat_gen = self.imp_mat_gen(exp_gdf, impf_col)
-
         ins_mat_gen = self.insured_mat_gen(imp_mat_gen, exp_gdf, impf_col)
         return self._return_impact(ins_mat_gen, save_mat)
 
@@ -224,10 +223,11 @@ def minimal_exp_gdf(self, impf_col):
             (self.exposures.gdf.value.values != 0)
             & (self.exposures.gdf[self.hazard.centr_exp_col].values >= 0)
         )
-        exp_gdf = gpd.GeoDataFrame({
-            col: self.exposures.gdf[col].values[mask]
-            for col in ['value', impf_col, self.hazard.centr_exp_col]
-        })
+        exp_gdf = gpd.GeoDataFrame(
+            {col: self.exposures.gdf[col].values[mask]
+            for col in ['value', impf_col, self.hazard.centr_exp_col]},
+            index=self.exposures.gdf.index[mask]
+            )
         if exp_gdf.size == 0:
             LOGGER.warning("No exposures with value >0 in the vicinity of the hazard.")
         return exp_gdf
@@ -276,7 +276,8 @@ def _chunk_exp_idx(haz_size, idx_exp_impf):
             for exp_idx in _chunk_exp_idx(self.hazard.size, idx_exp_impf):
                 exp_values = exp_gdf.value.values[exp_idx]
                 cent_idx = exp_gdf[self.hazard.centr_exp_col].values[exp_idx]
-                yield (self.impact_matrix(exp_values, cent_idx, impf), exp_idx)
+                yield (self.impact_matrix(exp_values, cent_idx, impf),
+                       exp_gdf.index[exp_idx].values)
 
     def insured_mat_gen(self, imp_mat_gen, exp_gdf, impf_col):
         """
@@ -308,9 +309,9 @@ def insured_mat_gen(self, imp_mat_gen, exp_gdf, impf_col):
             Exposure indices for impacts in mat
         """
         for mat, exp_idx in imp_mat_gen:
-            impf_id = exp_gdf[impf_col][exp_idx].unique()[0]
+            impf_id = exp_gdf.iloc[exp_idx][impf_col].unique()[0]
             deductible = self.deductible[exp_idx]
-            cent_idx = exp_gdf[self.hazard.centr_exp_col].values[exp_idx]
+            cent_idx = exp_gdf.iloc[exp_idx][self.hazard.centr_exp_col].values
             impf = self.impfset.get_func(haz_type=self.hazard.haz_type, fun_id=impf_id)
             mat = self.apply_deductible_to_mat(mat, deductible, self.hazard, cent_idx, impf)
             cover = self.cover[exp_idx]

From f59e04d505332a4814e3a22a8820ff0d3716a3fc Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Mon, 27 Jun 2022 19:20:10 +0200
Subject: [PATCH 111/121] Make new index in case the index is not ordered

---
 climada/engine/impact_calc.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index f982c01e1..26d75e002 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -25,6 +25,7 @@
 import numpy as np
 from scipy import sparse
 import geopandas as gpd
+import pandas as pd
 
 from climada import CONFIG
 from climada.engine import Impact
@@ -226,7 +227,7 @@ def minimal_exp_gdf(self, impf_col):
         exp_gdf = gpd.GeoDataFrame(
             {col: self.exposures.gdf[col].values[mask]
             for col in ['value', impf_col, self.hazard.centr_exp_col]},
-            index=self.exposures.gdf.index[mask]
+            index=pd.Index(mask.nonzero()[0])
             )
         if exp_gdf.size == 0:
             LOGGER.warning("No exposures with value >0 in the vicinity of the hazard.")

From bf3a8131e27113db688af2c49d5ed3f1342aedda Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Mon, 27 Jun 2022 19:38:22 +0200
Subject: [PATCH 112/121] Slice numpy instead of gdf

---
 climada/engine/impact_calc.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index 26d75e002..1122ca540 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -310,9 +310,9 @@ def insured_mat_gen(self, imp_mat_gen, exp_gdf, impf_col):
             Exposure indices for impacts in mat
         """
         for mat, exp_idx in imp_mat_gen:
-            impf_id = exp_gdf.iloc[exp_idx][impf_col].unique()[0]
+            impf_id = np.unique(self.exposures.gdf[impf_col].values[exp_idx])[0]
             deductible = self.deductible[exp_idx]
-            cent_idx = exp_gdf.iloc[exp_idx][self.hazard.centr_exp_col].values
+            cent_idx = self.exposures.gdf[self.hazard.centr_exp_col].values[exp_idx]
             impf = self.impfset.get_func(haz_type=self.hazard.haz_type, fun_id=impf_id)
             mat = self.apply_deductible_to_mat(mat, deductible, self.hazard, cent_idx, impf)
             cover = self.cover[exp_idx]

From 7c910d0bdd6c1254b180a24d54453acc7f743187 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Tue, 28 Jun 2022 12:23:34 +0200
Subject: [PATCH 113/121] Add _orig_exp_idx to tests

---
 climada/engine/impact_calc.py           | 19 +++++++++----------
 climada/engine/test/test_impact_calc.py |  3 +++
 2 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index 1122ca540..d07dec7f3 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -219,7 +219,6 @@ def minimal_exp_gdf(self, impf_col):
 
         """
         self.exposures.assign_centroids(self.hazard, overwrite=False)
-
         mask = (
             (self.exposures.gdf.value.values != 0)
             & (self.exposures.gdf[self.hazard.centr_exp_col].values >= 0)
@@ -227,10 +226,10 @@ def minimal_exp_gdf(self, impf_col):
         exp_gdf = gpd.GeoDataFrame(
             {col: self.exposures.gdf[col].values[mask]
             for col in ['value', impf_col, self.hazard.centr_exp_col]},
-            index=pd.Index(mask.nonzero()[0])
             )
         if exp_gdf.size == 0:
             LOGGER.warning("No exposures with value >0 in the vicinity of the hazard.")
+        self._orig_exp_idx = mask.nonzero()[0]
         return exp_gdf
 
     def imp_mat_gen(self, exp_gdf, impf_col):
@@ -278,7 +277,7 @@ def _chunk_exp_idx(haz_size, idx_exp_impf):
                 exp_values = exp_gdf.value.values[exp_idx]
                 cent_idx = exp_gdf[self.hazard.centr_exp_col].values[exp_idx]
                 yield (self.impact_matrix(exp_values, cent_idx, impf),
-                       exp_gdf.index[exp_idx].values)
+                       exp_idx)
 
     def insured_mat_gen(self, imp_mat_gen, exp_gdf, impf_col):
         """
@@ -310,12 +309,12 @@ def insured_mat_gen(self, imp_mat_gen, exp_gdf, impf_col):
             Exposure indices for impacts in mat
         """
         for mat, exp_idx in imp_mat_gen:
-            impf_id = np.unique(self.exposures.gdf[impf_col].values[exp_idx])[0]
-            deductible = self.deductible[exp_idx]
-            cent_idx = self.exposures.gdf[self.hazard.centr_exp_col].values[exp_idx]
+            impf_id = exp_gdf[impf_col][exp_idx[0]]
+            deductible = self.deductible[self._orig_exp_idx[exp_idx]]
+            cent_idx = exp_gdf[self.hazard.centr_exp_col].values[exp_idx]
             impf = self.impfset.get_func(haz_type=self.hazard.haz_type, fun_id=impf_id)
             mat = self.apply_deductible_to_mat(mat, deductible, self.hazard, cent_idx, impf)
-            cover = self.cover[exp_idx]
+            cover = self.cover[self._orig_exp_idx[exp_idx]]
             mat = self.apply_cover_to_mat(mat, cover)
             yield (mat, exp_idx)
 
@@ -353,7 +352,7 @@ def stitch_impact_matrix(self, imp_mat_gen):
         Make an impact matrix from an impact sub-matrix generator
         """
         data, row, col = np.hstack([
-            (mat.data, mat.nonzero()[0], idx[mat.nonzero()[1]])
+            (mat.data, mat.nonzero()[0], self._orig_exp_idx[idx][mat.nonzero()[1]])
             for mat, idx in imp_mat_gen
             ])
         return sparse.csr_matrix(
@@ -383,9 +382,9 @@ def stitch_risk_metrics(self, imp_mat_gen):
         """
         at_event = np.zeros(self.n_events)
         eai_exp = np.zeros(self.n_exp_pnt)
-        for sub_imp_mat, exp_idx in imp_mat_gen:
+        for sub_imp_mat, idx in imp_mat_gen:
             at_event += self.at_event_from_mat(sub_imp_mat)
-            eai_exp[exp_idx] += self.eai_exp_from_mat(sub_imp_mat, self.hazard.frequency)
+            eai_exp[self._orig_exp_idx[idx]] += self.eai_exp_from_mat(sub_imp_mat, self.hazard.frequency)
         aai_agg = self.aai_agg_from_eai_exp(eai_exp)
         return at_event, eai_exp, aai_agg
 
diff --git a/climada/engine/test/test_impact_calc.py b/climada/engine/test/test_impact_calc.py
index fa5706ae0..74a3d8752 100644
--- a/climada/engine/test/test_impact_calc.py
+++ b/climada/engine/test/test_impact_calc.py
@@ -235,6 +235,7 @@ def test_stitch_impact_matrix(self):
         """Check how sparse matrices from a generator are stitched together"""
         icalc = ImpactCalc(Exposures({'blank': [1, 2, 3, 4]}), ImpactFuncSet(), Hazard())
         icalc.hazard.event_id = np.array([1, 2, 3])
+        icalc._orig_exp_idx = np.array([0, 1, 2, 3])
 
         imp_mat_gen = [
             (sparse.csr_matrix([[1.0, 1.0], [0.0, 1.0]]), np.array([0, 1])),
@@ -266,6 +267,7 @@ def test_stitch_risk_metrics(self):
         icalc = ImpactCalc(Exposures({'blank': [1, 2, 3]}), ImpactFuncSet(), Hazard())
         icalc.hazard.event_id = np.array([1, 2])
         icalc.hazard.frequency = np.array([2, 0.5])
+        icalc._orig_exp_idx = np.array([0, 1, 2])
 
         # Matrices overlap at central exposure point
         imp_mat_gen = (
@@ -424,6 +426,7 @@ def setUp(self):
         self.icalc.exposures.gdf = pd.DataFrame(
             {"deductible": [10.0, 20.0], "cover": [1.0, 100.0]}
         )
+        self.icalc._orig_exp_idx = np.array([0, 1])
         self.icalc.hazard.centr_exp_col = "centr_col"
         self.icalc.hazard.haz_type = "haz_type"
         self.icalc.apply_deductible_to_mat = MagicMock(

From 24a77ad871c7e8a3b5e5715d8815e2f69627fb18 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Tue, 28 Jun 2022 12:38:21 +0200
Subject: [PATCH 114/121] Add tests with Flood

---
 climada/engine/test/test_impact_calc.py | 51 ++++++++++++++++++++++++-
 1 file changed, 50 insertions(+), 1 deletion(-)

diff --git a/climada/engine/test/test_impact_calc.py b/climada/engine/test/test_impact_calc.py
index 74a3d8752..05f8166b6 100644
--- a/climada/engine/test/test_impact_calc.py
+++ b/climada/engine/test/test_impact_calc.py
@@ -24,6 +24,7 @@
 from scipy import sparse
 import pandas as pd
 from copy import deepcopy
+from pathlib import Path
 
 from climada import CONFIG
 from climada.entity.entity_def import Entity
@@ -53,6 +54,19 @@ def get_haz_test_file(ds_name):
 DATA_FOLDER = DEMO_DIR / 'test-results'
 DATA_FOLDER.mkdir(exist_ok=True)
 
+def check_impact(self, imp, haz, exp, aai_agg, eai_exp, at_event, imp_mat_array=None):
+    """Test properties of imapcts"""
+    self.assertEqual(len(haz.event_id), len(imp.at_event))
+    self.assertIsInstance(imp, Impact)
+    np.testing.assert_allclose(imp.coord_exp[:,0], exp.gdf.latitude)
+    np.testing.assert_allclose(imp.coord_exp[:,1], exp.gdf.longitude)
+    self.assertAlmostEqual(imp.aai_agg, aai_agg, 3)
+    np.testing.assert_allclose(imp.eai_exp, eai_exp, rtol=1e-5)
+    np.testing.assert_allclose(imp.at_event, at_event, rtol=1e-5)
+    if imp_mat_array is not None:
+        np.testing.assert_allclose(imp.imp_mat.toarray().ravel(),
+                                   imp_mat_array.ravel())
+
 
 class TestImpactCalc(unittest.TestCase):
     """Test Impact calc methods"""
@@ -98,7 +112,7 @@ def test_apply_cover_to_mat(self):
             imp.todense(), np.array([[0, 0, 1], [0, 1, 0]])
             )
 
-    def test_calc_impact_pass(self):
+    def test_calc_impact_TC_pass(self):
         """Test compute impact"""
         icalc = ImpactCalc(ENT.exposures, ENT.impact_funcs, HAZ)
         impact = icalc.impact()
@@ -133,6 +147,41 @@ def test_calc_impact_pass(self):
         self.assertAlmostEqual(6.570532945599105e+11, impact.tot_value)
         self.assertAlmostEqual(6.512201157564421e+09 * x, impact.aai_agg, 5)
 
+    def test_calc_impact_RF_pass(self):
+        from climada_petals.entity.impact_funcs.river_flood import flood_imp_func_set
+        haz = Hazard.from_hdf5(Path.home() / 'climada/data/hazard/test_hazard_US_flood_random_locations.hdf5')
+        exp = Exposures.from_hdf5(Path.home() / 'climada/data/exposures/test_exposure_US_flood_random_locations.hdf5')
+        impf_set = flood_imp_func_set()
+        icalc = ImpactCalc(exp, impf_set, haz)
+        impact = icalc.impact()
+        aai_agg = 161436.05112960344
+        eai_exp = np.array([
+            1.61159701e+05, 1.33742847e+02, 0.00000000e+00, 4.21352988e-01,
+            1.42185609e+02, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00
+            ])
+        at_event = np.array([
+            0.00000000e+00, 0.00000000e+00, 9.85233619e+04, 3.41245461e+04,
+            7.73566566e+07, 0.00000000e+00, 0.00000000e+00
+            ])
+        imp_mat_array = np.array([
+            [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,
+             0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],
+            [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,
+             0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],
+            [0.00000000e+00, 6.41965663e+04, 0.00000000e+00, 2.02249434e+02,
+             3.41245461e+04, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],
+            [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,
+             3.41245461e+04, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],
+            [7.73566566e+07, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,
+             0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],
+            [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,
+             0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],
+            [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,
+             0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]
+            ])
+        check_impact(self, impact, haz, exp, aai_agg, eai_exp, at_event, imp_mat_array)
+
+
     def test_calc_impact_save_mat_pass(self):
         """Test compute impact with impact matrix"""
         icalc = ImpactCalc(ENT.exposures, ENT.impact_funcs, HAZ)

From 3aea1752fa1a7b79f38b5859f5843c2280fc6743 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Tue, 28 Jun 2022 14:43:55 +0200
Subject: [PATCH 115/121] Return empty impact if no exposures matching hazard

---
 climada/engine/impact_calc.py           | 28 +++++++++++++++++++++++++
 climada/engine/test/test_impact_calc.py | 19 +++++++++++++++++
 2 files changed, 47 insertions(+)

diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index d07dec7f3..7d1bee03b 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -127,6 +127,8 @@ def impact(self, save_mat=True):
         """
         impf_col = self.exposures.get_impf_column(self.hazard.haz_type)
         exp_gdf = self.minimal_exp_gdf(impf_col)
+        if exp_gdf.size == 0:
+            return self._return_empty(save_mat)
         LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
                     self.n_events, self.n_events)
         imp_mat_gen = self.imp_mat_gen(exp_gdf, impf_col)
@@ -168,6 +170,8 @@ def insured_impact(self, save_mat=False):
                                  "and/or exposures.gdf.deductible")
         impf_col = self.exposures.get_impf_column(self.hazard.haz_type)
         exp_gdf = self.minimal_exp_gdf(impf_col)
+        if exp_gdf.size == 0:
+            return self._return_empty(save_mat)
         LOGGER.info('Calculating impact for %s assets (>0) and %s events.',
                     exp_gdf.size, self.hazard.size)
 
@@ -207,6 +211,30 @@ def _return_impact(self, imp_mat_gen, save_mat):
             at_event, eai_exp, aai_agg, imp_mat
             )
 
+    def _return_empty(self, save_mat):
+        """
+        Return empty impact.
+
+        Parameters
+        ----------
+        save_mat : bool
+              If true, save impact matrix
+
+        Returns
+        -------
+        Impact
+            Empty impact object with correct array sizes.
+        """
+        at_event = np.zeros(self.n_events)
+        eai_exp = np.zeros(self.n_exp_pnt)
+        aai_agg = 0.0
+        if save_mat:
+            imp_mat = sparse.csr_matrix((self.n_events, self.n_exp_pnt), dtype=np.float64)
+        else:
+            imp_mat = None
+        return Impact.from_eih(self.exposures, self.impfset, self.hazard,
+                        at_event, eai_exp, aai_agg, imp_mat)
+
     def minimal_exp_gdf(self, impf_col):
         """Get minimal exposures geodataframe for impact computation
 
diff --git a/climada/engine/test/test_impact_calc.py b/climada/engine/test/test_impact_calc.py
index 05f8166b6..4d1516353 100644
--- a/climada/engine/test/test_impact_calc.py
+++ b/climada/engine/test/test_impact_calc.py
@@ -181,6 +181,25 @@ def test_calc_impact_RF_pass(self):
             ])
         check_impact(self, impact, haz, exp, aai_agg, eai_exp, at_event, imp_mat_array)
 
+    def test_empty_impact(self):
+        exp = ENT.exposures.copy()
+        exp.gdf['centr_TC'] = -1
+        icalc = ImpactCalc(exp, ENT.impact_funcs, HAZ)
+        impact = icalc.impact()
+        aai_agg = 0.0
+        eai_exp = np.zeros(len(exp.gdf))
+        at_event = np.zeros(HAZ.size)
+        check_impact(self, impact, HAZ, exp, aai_agg, eai_exp, at_event, None)
+
+        icalc = ImpactCalc(exp, ENT.impact_funcs, HAZ)
+        impact = icalc.impact(save_mat=True)
+        aai_agg = 0.0
+        eai_exp = np.zeros(len(exp.gdf))
+        at_event = np.zeros(HAZ.size)
+        imp_mat_array = sparse.csr_matrix((HAZ.size, len(exp.gdf))).toarray()
+        check_impact(self, impact, HAZ, exp, aai_agg, eai_exp, at_event, imp_mat_array)
+
+
 
     def test_calc_impact_save_mat_pass(self):
         """Test compute impact with impact matrix"""

From 0a6c9e188a14a0d926992ac036839ac1e5d6dc27 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Tue, 28 Jun 2022 15:54:46 +0200
Subject: [PATCH 116/121] Repalce squeeze by ravel for atevent single event

---
 climada/engine/impact_calc.py           |  2 +-
 climada/engine/test/test_impact_calc.py | 18 ++++++++++++++----
 2 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index 7d1bee03b..8962f08dd 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -510,7 +510,7 @@ def at_event_from_mat(mat):
         at_event : np.array
             impact for each hazard event
         """
-        return np.squeeze(np.asarray(np.sum(mat, axis=1)))
+        return np.asarray(np.sum(mat, axis=1)).ravel()
 
     @staticmethod
     def aai_agg_from_eai_exp(eai_exp):
diff --git a/climada/engine/test/test_impact_calc.py b/climada/engine/test/test_impact_calc.py
index 4d1516353..d59924f67 100644
--- a/climada/engine/test/test_impact_calc.py
+++ b/climada/engine/test/test_impact_calc.py
@@ -182,6 +182,7 @@ def test_calc_impact_RF_pass(self):
         check_impact(self, impact, haz, exp, aai_agg, eai_exp, at_event, imp_mat_array)
 
     def test_empty_impact(self):
+        """Check that empty impact is returned if no centroids matching the exposures"""
         exp = ENT.exposures.copy()
         exp.gdf['centr_TC'] = -1
         icalc = ImpactCalc(exp, ENT.impact_funcs, HAZ)
@@ -191,14 +192,23 @@ def test_empty_impact(self):
         at_event = np.zeros(HAZ.size)
         check_impact(self, impact, HAZ, exp, aai_agg, eai_exp, at_event, None)
 
-        icalc = ImpactCalc(exp, ENT.impact_funcs, HAZ)
         impact = icalc.impact(save_mat=True)
-        aai_agg = 0.0
-        eai_exp = np.zeros(len(exp.gdf))
-        at_event = np.zeros(HAZ.size)
         imp_mat_array = sparse.csr_matrix((HAZ.size, len(exp.gdf))).toarray()
         check_impact(self, impact, HAZ, exp, aai_agg, eai_exp, at_event, imp_mat_array)
 
+    def test_single_event_impact(self):
+        """Check impact for single event"""
+        haz = HAZ.select([1])
+        icalc = ImpactCalc(ENT.exposures, ENT.impact_funcs, haz)
+        impact = icalc.impact()
+        aai_agg = 0.0
+        eai_exp = np.zeros(len(ENT.exposures.gdf))
+        at_event = np.array([0])
+        check_impact(self, impact, haz, ENT.exposures, aai_agg, eai_exp, at_event, None)
+        impact = icalc.impact(save_mat=True)
+        imp_mat_array = sparse.csr_matrix((haz.size, len(ENT.exposures.gdf))).toarray()
+        check_impact(self, impact, haz, ENT.exposures, aai_agg, eai_exp, at_event, imp_mat_array)
+
 
 
     def test_calc_impact_save_mat_pass(self):

From 5bdfd02cc34307f14b738761029efdbc82defd0d Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Tue, 28 Jun 2022 16:20:50 +0200
Subject: [PATCH 117/121] Add _orig_exp_idx as argument from beginning on

---
 climada/engine/impact_calc.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index 8962f08dd..975046b13 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -62,6 +62,7 @@ def __init__(self,
         self.exposures = exposures
         self.impfset = impfset
         self.hazard = hazard
+        self._orig_exp_idx = np.arange(self.exposures.gdf.shape[0]) #exposures index to use for matrix reconstruction
 
     @property
     def n_exp_pnt(self):

From 60c25ca839a06012417ce2a74fe3222210a418e4 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Tue, 28 Jun 2022 16:21:04 +0200
Subject: [PATCH 118/121] Update comment cosmetics

---
 climada/engine/impact_calc.py           | 25 ++++++++++++++-----------
 climada/engine/test/test_impact_calc.py |  1 -
 2 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index 975046b13..7352164c4 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -113,8 +113,8 @@ def impact(self, save_mat=True):
         Examples
         --------
             >>> haz = Hazard.from_mat(HAZ_DEMO_MAT)  # Set hazard
-            >>> impfset = ImpactFuncSet.from_excel(ENT_TEMPLATE_XLS) # Set impact functions
-            >>> exp = Exposures(pd.read_excel(ENT_TEMPLATE_XLS)) # Set exposures
+            >>> impfset = ImpactFuncSet.from_excel(ENT_TEMPLATE_XLS)
+            >>> exp = Exposures(pd.read_excel(ENT_TEMPLATE_XLS))
             >>> impcalc = ImpactCal(exp, impfset, haz)
             >>> imp = impcalc.insured_impact()
             >>> imp.aai_agg
@@ -152,8 +152,8 @@ def insured_impact(self, save_mat=False):
         Examples
         --------
             >>> haz = Hazard.from_mat(HAZ_DEMO_MAT)  # Set hazard
-            >>> impfset = ImpactFuncSet.from_excel(ENT_TEMPLATE_XLS) # Set impact functions
-            >>> exp = Exposures(pd.read_excel(ENT_TEMPLATE_XLS)) # Set exposures
+            >>> impfset = ImpactFuncSet.from_excel(ENT_TEMPLATE_XLS)
+            >>> exp = Exposures(pd.read_excel(ENT_TEMPLATE_XLS))
             >>> impcalc = ImpactCal(exp, impfset, haz)
             >>> imp = impcalc.insured_impact()
             >>> imp.aai_agg
@@ -258,7 +258,7 @@ def minimal_exp_gdf(self, impf_col):
             )
         if exp_gdf.size == 0:
             LOGGER.warning("No exposures with value >0 in the vicinity of the hazard.")
-        self._orig_exp_idx = mask.nonzero()[0]
+        self._orig_exp_idx = mask.nonzero()[0]  #update index of kept exposures points in exp_gdf within the full exposures
         return exp_gdf
 
     def imp_mat_gen(self, exp_gdf, impf_col):
@@ -290,6 +290,9 @@ def imp_mat_gen(self, exp_gdf, impf_col):
         """
 
         def _chunk_exp_idx(haz_size, idx_exp_impf):
+            '''
+            Chunk computations in sizes that roughly fit into memory
+            '''
             max_size = CONFIG.max_matrix_size.int()
             if haz_size > max_size:
                 raise ValueError(
@@ -368,19 +371,19 @@ def impact_matrix(self, exp_values, cent_idx, impf):
         scipy.sparse.csr_matrix
             Impact per event (rows) per exposure point (columns)
         """
-        n_centroids = cent_idx.size
+        n_exp_pnt = len(cent_idx) #implicitly checks in matrix assignement whether len(cent_idx) == len(exp_values)
         mdr = self.hazard.get_mdr(cent_idx, impf)
         fract = self.hazard.get_fraction(cent_idx)
-        exp_values_csr = sparse.csr_matrix(
-            (exp_values, np.arange(n_centroids), [0, n_centroids]),
-            shape=(1, n_centroids))
+        exp_values_csr = sparse.csr_matrix( #vector 1 x exp_size
+            (exp_values, np.arange(n_exp_pnt), [0, n_exp_pnt]),
+            shape=(1, n_exp_pnt))
         return fract.multiply(mdr).multiply(exp_values_csr)
 
     def stitch_impact_matrix(self, imp_mat_gen):
         """
         Make an impact matrix from an impact sub-matrix generator
         """
-        data, row, col = np.hstack([
+        data, row, col = np.hstack([  #rows=events index, cols=exposure point index within self.exposures
             (mat.data, mat.nonzero()[0], self._orig_exp_idx[idx][mat.nonzero()[1]])
             for mat, idx in imp_mat_gen
             ])
@@ -493,7 +496,7 @@ def eai_exp_from_mat(mat, freq):
             expected annual impact for each exposure
         """
         n_events = freq.size
-        freq_csr = sparse.csr_matrix(
+        freq_csr = sparse.csr_matrix(   #vector n_events x 1
             (freq, np.zeros(n_events), np.arange(n_events + 1)),
             shape=(n_events, 1))
         return mat.multiply(freq_csr).sum(axis=0).A1
diff --git a/climada/engine/test/test_impact_calc.py b/climada/engine/test/test_impact_calc.py
index d59924f67..23ef04294 100644
--- a/climada/engine/test/test_impact_calc.py
+++ b/climada/engine/test/test_impact_calc.py
@@ -210,7 +210,6 @@ def test_single_event_impact(self):
         check_impact(self, impact, haz, ENT.exposures, aai_agg, eai_exp, at_event, imp_mat_array)
 
 
-
     def test_calc_impact_save_mat_pass(self):
         """Test compute impact with impact matrix"""
         icalc = ImpactCalc(ENT.exposures, ENT.impact_funcs, HAZ)

From 2014af8da758b64669b3270f4af5342d627ca886 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Tue, 28 Jun 2022 22:30:49 +0200
Subject: [PATCH 119/121] Reduce lines to max length

---
 climada/engine/impact_calc.py | 32 ++++++++++++++++++++++----------
 1 file changed, 22 insertions(+), 10 deletions(-)

diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index 7352164c4..4c4157591 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -203,7 +203,8 @@ def _return_impact(self, imp_mat_gen, save_mat):
         """
         if save_mat:
             imp_mat = self.stitch_impact_matrix(imp_mat_gen)
-            at_event, eai_exp, aai_agg = self.risk_metrics(imp_mat, self.hazard.frequency)
+            at_event, eai_exp, aai_agg = \
+                self.risk_metrics(imp_mat, self.hazard.frequency)
         else:
             imp_mat = None
             at_event, eai_exp, aai_agg = self.stitch_risk_metrics(imp_mat_gen)
@@ -230,7 +231,9 @@ def _return_empty(self, save_mat):
         eai_exp = np.zeros(self.n_exp_pnt)
         aai_agg = 0.0
         if save_mat:
-            imp_mat = sparse.csr_matrix((self.n_events, self.n_exp_pnt), dtype=np.float64)
+            imp_mat = sparse.csr_matrix((
+                self.n_events, self.n_exp_pnt), dtype=np.float64
+                )
         else:
             imp_mat = None
         return Impact.from_eih(self.exposures, self.impfset, self.hazard,
@@ -303,13 +306,17 @@ def _chunk_exp_idx(haz_size, idx_exp_impf):
             return np.array_split(idx_exp_impf, n_chunks)
 
         for impf_id in exp_gdf[impf_col].dropna().unique():
-            impf = self.impfset.get_func(haz_type=self.hazard.haz_type, fun_id=impf_id)
+            impf = self.impfset.get_func(
+                haz_type=self.hazard.haz_type, fun_id=impf_id
+                )
             idx_exp_impf = (exp_gdf[impf_col].values == impf_id).nonzero()[0]
             for exp_idx in _chunk_exp_idx(self.hazard.size, idx_exp_impf):
                 exp_values = exp_gdf.value.values[exp_idx]
                 cent_idx = exp_gdf[self.hazard.centr_exp_col].values[exp_idx]
-                yield (self.impact_matrix(exp_values, cent_idx, impf),
-                       exp_idx)
+                yield (
+                    self.impact_matrix(exp_values, cent_idx, impf),
+                    exp_idx
+                    )
 
     def insured_mat_gen(self, imp_mat_gen, exp_gdf, impf_col):
         """
@@ -344,8 +351,12 @@ def insured_mat_gen(self, imp_mat_gen, exp_gdf, impf_col):
             impf_id = exp_gdf[impf_col][exp_idx[0]]
             deductible = self.deductible[self._orig_exp_idx[exp_idx]]
             cent_idx = exp_gdf[self.hazard.centr_exp_col].values[exp_idx]
-            impf = self.impfset.get_func(haz_type=self.hazard.haz_type, fun_id=impf_id)
-            mat = self.apply_deductible_to_mat(mat, deductible, self.hazard, cent_idx, impf)
+            impf = self.impfset.get_func(
+                haz_type=self.hazard.haz_type, fun_id=impf_id
+                )
+            mat = self.apply_deductible_to_mat(
+                mat, deductible, self.hazard, cent_idx, impf
+                )
             cover = self.cover[self._orig_exp_idx[exp_idx]]
             mat = self.apply_cover_to_mat(mat, cover)
             yield (mat, exp_idx)
@@ -383,10 +394,10 @@ def stitch_impact_matrix(self, imp_mat_gen):
         """
         Make an impact matrix from an impact sub-matrix generator
         """
-        data, row, col = np.hstack([  #rows=events index, cols=exposure point index within self.exposures
+        data, row, col = np.hstack((  #rows=events index, cols=exposure point index within self.exposures
             (mat.data, mat.nonzero()[0], self._orig_exp_idx[idx][mat.nonzero()[1]])
             for mat, idx in imp_mat_gen
-            ])
+            ))
         return sparse.csr_matrix(
             (data, (row, col)), shape=(self.n_events, self.n_exp_pnt)
             )
@@ -416,7 +427,8 @@ def stitch_risk_metrics(self, imp_mat_gen):
         eai_exp = np.zeros(self.n_exp_pnt)
         for sub_imp_mat, idx in imp_mat_gen:
             at_event += self.at_event_from_mat(sub_imp_mat)
-            eai_exp[self._orig_exp_idx[idx]] += self.eai_exp_from_mat(sub_imp_mat, self.hazard.frequency)
+            eai_exp[self._orig_exp_idx[idx]] += \
+                self.eai_exp_from_mat(sub_imp_mat, self.hazard.frequency)
         aai_agg = self.aai_agg_from_eai_exp(eai_exp)
         return at_event, eai_exp, aai_agg
 

From cdc536d566e9c2f715bfe042d21cfa3c93b1a173 Mon Sep 17 00:00:00 2001
From: Chahan Kropf <chahan.kropf@posteo.com>
Date: Tue, 28 Jun 2022 22:37:19 +0200
Subject: [PATCH 120/121] Replace generator by list due to deprecation in
 np.hstack

---
 climada/engine/impact_calc.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py
index 4c4157591..3793618c8 100644
--- a/climada/engine/impact_calc.py
+++ b/climada/engine/impact_calc.py
@@ -394,10 +394,10 @@ def stitch_impact_matrix(self, imp_mat_gen):
         """
         Make an impact matrix from an impact sub-matrix generator
         """
-        data, row, col = np.hstack((  #rows=events index, cols=exposure point index within self.exposures
+        data, row, col = np.hstack([  #rows=events index, cols=exposure point index within self.exposures
             (mat.data, mat.nonzero()[0], self._orig_exp_idx[idx][mat.nonzero()[1]])
             for mat, idx in imp_mat_gen
-            ))
+            ])
         return sparse.csr_matrix(
             (data, (row, col)), shape=(self.n_events, self.n_exp_pnt)
             )

From 74e3a8e0994dfdd2f4a614a07fc40af4569b6d7b Mon Sep 17 00:00:00 2001
From: emanuel-schmid <schmide@ethz.ch>
Date: Fri, 15 Jul 2022 10:35:10 +0200
Subject: [PATCH 121/121] test_impact_calc: organize test data

---
 climada/engine/test/data/flood_imp_func_set.xls | Bin 0 -> 7017 bytes
 climada/engine/test/test_impact_calc.py         |  11 +++++------
 2 files changed, 5 insertions(+), 6 deletions(-)
 create mode 100644 climada/engine/test/data/flood_imp_func_set.xls

diff --git a/climada/engine/test/data/flood_imp_func_set.xls b/climada/engine/test/data/flood_imp_func_set.xls
new file mode 100644
index 0000000000000000000000000000000000000000..57aa00455fd13c4fee22c1e85366e954e47456bf
GIT binary patch
literal 7017
zcmZ`;1z1#D*B&IKyCtL>1{?&WQ@TOAhma2GoS{p)qy<Deq&uXB?vM~fq$EUA;2*sA
z`}{7?{b!!D_dI*fdiOc++VQTnRTU7C2mt^9D*O@!oXfwXQ9}R#;*bCU0(gtQq@#ly
z*ul+M)5{6$YRKtnZ&#iKQ|<xcN}tL8lKjFU|EWd{m3JS~kI$+m(m9{lS7NT8ZDVtr
zEq96g*g9%asm$X0C)fU1AySS<sT_~<u-XZ)^O<-KpONmqEA)ILwAnx_slLKYB9vr?
z%q-Ibi|Vo<LU{81R3|cnc||UwIaJ0JkJht7lZH3)oL32~>0MOxxYDQX(R(P<VUor!
zO(^tX@$@IP)5b4jyYy%jk$e6ecDjYC+|NphoDDf!FT@A=f+2!}ShG*pi7<kHC68<0
zpx9j+dD<rM#>HsmTg_C-XXN&?NF|kVowoeKf1;T@(@FIsR3F_Mkqqc%p&)Bvn(D=+
zABJ=r=6F`TFOtychHtY8P@y6+e*msR$?YSuokFx&zeSrJyBYj7`W0|USFqrNTI-6l
zR3ZJgOcb&jq2><T)(F6<`624|rB2?&h~-Gw=``_nr)`9$<;vn5P4yohQ1w;r+JQ5#
z_y7RFfY-(@U^`bX&bzWaVMHF08#nL(a)A4FWuzVw4q8&c^CozY17xff-D4z3P-}2>
z#3f{_J6YpSOm}Q2vusPhE?8mS41xxMwV?SX3s`wi4qF3sJ_QXyx<2;?VNx*n6g9Q$
ziB1HoN4kjimZ39PAhyZ2&OKYo7Wx`V7jiu1a?HG${)}=Wc0S%{=4ZLGDA_m#_sl4n
ztY8CDov2iE@QA&j&SH(<Pr@%!QO0B;(eLTFfhw0-Q|H}6+Q{gaA7DE!sU2I>*+`V=
zFJTeH+{ruik_)>HvF2Ag-4{<bGRH>(IKwRS)&{a(bdz>OpG;tZsQ*bx*jk9q9VN|h
zO32~0rybW{tav!O*qS*y+TIPzzZvR!2_KtM2O&4mc^?izj>4pYreKK*`%44~J$=S{
z`VUJ5H&>CtMcBdPP!%(oy<zC`=8n&|k5mM&y4Z>%@sYd<?6&lgbCw#yNN{@>^_L&M
zMwg-2nK|=-dF=6S(YP4W$7=|&I1L|Z$@5@8RFV$=_CtkWGFJdLJyblR+`vo%zF?mM
zA?`#eR#&4>_Gv$^H}Ac*2rJsgtbksSkN-$U_d>OKjven>tjtjZsg*uH*OXR9_M)`p
zX2RUk{e>tnl<1ZC*;yH7y?X4Cuw>>*`Q<y^-7IBmQT|QWH|mP}#-v`(&OdSf$xxu@
z5HR*301&_n0FeI0&>c6f)?l!kE7$Le`;MfTB_)jw8QicVpORxrgLbR(^zT%1gjIDZ
zb#mD6<u~`gBO_EGN7d9R9PiUX8HC;j@Hs(j*ngR@U(4ffQQ!JC=J+|fUn#Y;rM2KJ
z_|Do@F7A$;o|@g98RrDBey#OuSTU+RSh9EJzO7ss6E(Uy@43)uxoYmP&2X4?G;Qff
zTYa^>v0zr+(QHdKdxf)aUc1l4xBuOA`KR%B2a>CP!`gO#|M8ydZYy0Kp)$Uu3mEaJ
z`@w>Yk85qyOYQxchA_*eHam;CPn9h<7Y7GVUte8pUi>V|p@dkreEn*6GnjQv@yplQ
z>*m+n+XaxyRpOY{@+B;1#LsnxckbHJL_{#j&t|DI>~rO{y1VB$v*Y=(v9X=A<-O)6
z-GG*Z8|xf@o2LyPh8=ih0gEq}%elrp_NVO5T92+bE)QWYR$jMKmDo`^moqoqVN5sI
zJc7o)2Lbal&h<iBO`h6WqrO7=S)<I^Gw+_nTIHx%;g9)?WQ91_e_QGk!$B1GzEpS(
zVQXxL=oeoP5)38AP3gu5XO7BKNC1OP24F8wX)gS<dYV1J=_j37GZrUt6OxW+z&+D>
z#20KLv#Le~0d|K7ypMS8rVp2RAJ`(zQoLZQjK!=Z2h(f^Ju3P54e#yqmG5X(Or6<*
zD+gNqvq%YXZT|E)MqNs?UCbCVx}GiUVPFAv*u+Z7&}(oA#&!#;L(ynV#;4-J)e069
zB?Mda4*}(o=1S>mJbGOt(;;daq`V)Ocp1uAOqC*HQMCl7WxvOCJZl_m1`Wx-E%R*|
z2A_+)>8jswsUayo^r$>^@jH)ysSHx|$<HG$80h+(yW!HD*ty!?4Xbn2j<1dUBp3-K
z%6#6^P}rl>31bUuT4U$p$H1Hz2g~C<h0+-myf>wY!`TiRH09&Rz#dJI1ZnmFsVFvp
z!w>n+gA}rVA()BrE8vdON`W+Mt7tRV*hlaj0;Qa$<}ehxb(5S@81nPTLj^wPQlxk`
zxj>mOg?+LuO=b9Dc%zWtCJY9#wN;Ft1|n1=od;aziATFbYTfX#W~4ANU#v+fV)Btg
zGYfP{$wt*fYt!KE?Ce-C*4gc__{`qs4qjnm^yv0FrEurxrEFI7_@dMbX@~X?b;9Zz
zl0I{Qr6lW6pY#YC6aah7E!Q>|^@k6MpXBFd6l5kGTAx*&49THwmIb@$bqjHsW~YT`
zeoms@!&GUMb?xIn+*a;32YV`zt*Fb~y%~?t274K%C@Y<PckdxFcdK-?b@5YEGtVw1
za_-i(Ij7BPuGUQq#|v8W60La>ku}ym4AJar**8GW)({NG&+uj?QW7dwvxrnS(KXtf
zR@F3umG$5Te)t<P52G2c!3$BR{4^<3MNbTZm2NmSZ-I=y5%A*IZh905U87q+>5v#s
zCb4uHeo_~6chX};v{r*eX|x(<I0mgEnoFZ>9+Ij2+GYm3e4KQIbupu<eBAScHw<@e
zMDX8#-KyeW=^XEp4t1J%9C}hLi0%6|5~SEPZECa&<Z>VP=>{@}JJ08a4iaU?6DTHy
znySSypw~#jy8yDI<5QscsZM;0=vFb}Qbezj6(?qavl${Mj$nn1EDy@hPb*HTVjFNl
z)~yH+eM#z$yvdK54J)>Gla6mr0kRK3kaerze-MQti;J_PdB4qnp;N`BA~Gp8j9HT=
z{@XR->EaB^!7!qj;lreCDLPE7np|;W5Zt{VNy#(2$~Igsp9*qPpMb<^%<ZcRvFbnE
z4T&-=cYc_-D0d%<QN=<xivB#j6TChYb32MuCV#VmNFsRiB#Qpx+L<-9`f1uY^}=yu
z<|P_eCFv6=hh^2rXzOpXEb0!WCI$uE<`hoeAj{2J^dBqeKfa>-s}ReeV2pMTtQ|GW
zdJlKw6fe-C==Z`qAY?>&NKuFf?cb$M<Rd~s(eE_DAe~Sh>F!*kurf6{M2$XKgUyrJ
zT|hXDr6hULuOJu{A%0zzbK;ZC?CAAUT`A1)sSzUGb%^;fp_<u~P<jWgFWUr0VCO|k
z{!$GhOoNN9&}uOFEyC@VNr%A9MuJ`G4#!r4BDOmNw+!z6s6w=A(4F_o(2g2qCxT6s
z);9InmBI^udtV7P?}a&w4uPi^!+*{D<?&{Nft-^dno18ni^Ma6(_o!!To}QGDwf9g
zIYNq1VHzlt%U0Q&k;5KaZpT&7!D`YOy_unGXG8|4#kh3Wwo*OBi-wr1cU>B!*#hLE
z?>9^%;W^Cz!t*iL#3URUvpVq3Bbb;hPQ)mo(Vb~4@sHC;&G01I&EOA@K_Drg84^K*
zi_Zps`b~^#Up%b3{6IgvHKI6hXFKY7H>yzuG$hL8Zo){Dk|5kon9@M!pwwM>lTPDr
zze*oA%63V2Hg>{ZRXO3Y8%XuYO|E~*ai^MV7;)TP-nVSYS?1%rhF(I)eCvHKsB^Z)
zT27BHYHx6l3iq2&P0x2KbdC91dR|<|-xk@oe2(hrz>m3o_Uc0PpL_Vn0rFXOxb)_R
zs~ns^d-#9!O-%gYo$L-hkZpx-3XbH{=W8X(+vVdwz%CS~HCG`oU9k`>XccxZA#8L$
z{#EOn5zuNtStyocLOEB`x4`}pm2f7y)GucBDb9;IQUMi0ItjMoBNG1Bmz-QF(E2c(
zavWwrQmOM+n=XCCTT0n=%f&$SWNm#p-#GUie)AyU9D*lHf{;?F6n@2FL{-(T>9_h#
z!tbDc2Ic^W4sLJQPs9G0o{^f(2lY(P!%2TATFhTD1Mzz=eENi|$VtR^5N_!0938wl
z^O>jcnMM}AluBdjO=5JQl`5S$RkjZNV0G`S;0Wuw#*~hT6|6|3dYMV``GaxdkbHC~
z_lon^mbl`{3xP9K-_;B9u~OEU!!IO$t*a-rycrvlxI3#$MiWQ4pJ8UNC^Id(W+7pn
z6}nGr7y%3r6yqbZM?dn1zmnFq;Wp5m<!6J)5S*=#r+pFsNx$@(ogpHe{z5qYckvKh
zWV%|Lx_~V-++1uNtX%KpQ*wg1LXQ}3$N}WmbfIOLm6=sep80f5yl_VVbHV0GTvm)A
zLG|qlk+;0su=5I^;|g@y>?e`;j|e$t7aJ}T1>3l#ZxLsOegR7cpY-U^_wrsx7YgUj
zYrXQ<4lf=wN||&o>1lJFbSD)fb`~48AkhGfm@f*F;X_if)g%upQeclr0_QWH#+C`3
zac;#bQqxtu9;z!x&np>^>;{xSZHa$$95PknB)W#G8y|84MDEJj!v-+nGw$3zTl%8?
ztPm67-J-keqzS9tC28Axj|e^B>!rGd{J7`ZkQFE2_q)av61At)eMze(u^TLm`-+rK
z4s~0^L0fe`F&nqF1~-;7eE%dZ7us794=2q65dgsYn>05sJMeF|3KP|AKLIiOS07$u
z_Z`@N$JVZoFTjC9B?Qsix{Um)6Q0bwR3&fJs2B?<Ckm48nX07RCio|CwD`92vyI~B
zAL$J4U(29(_Sr%W83HIzb2{Yl<npv<=`>w}nW=YMRKNuj-AibJNOVB$W2xx?uE_b!
z&i9@NK4PaIMEIp!u?+F90P_7wU+k)v?5NP+VGcFh39A#vP{%b!=@!GzpJyh6!E8~@
zcCA0faW`m?t06<;vFCYZ0w{^S+5+bN><0<JSD=0Ys0e-a08tTxOG34~jR{k&YHAxT
zB+zFid_g2yIQ4mZOmzDC4c;;`uY-qi1%6S;E|uT7@73J%F?B;d>j(nKwz3VwD#@VS
z7s^MA#iMU)&@SS+A4S`DE;fMjR`;>4CebNAtxP0V(2qUKy6O26YWc+cnDMC6CjEL<
z$Jxg50>hitP10C1{;T0&&bHhF5lt+#+TxH4>xqW(tPvB}d%BKKZ&-)N$4j~<O`Ww}
z>Wtxv%uhexXk=lEqHb}_Mtv#lJ@lu~^ua%Uw_U{0Sc41zXgvBW)Q1mvH*2sx_^<MJ
zxUjFQ^m<8(w4LsVTBf}rmOyZ%BBT82LP3c8(u{-N^hR&`{8Y5??65^cQ{HKKa4>T?
z20kA)YVowZ!BC|xGlcdh*Wo4Ipy!hn%Oz>TIsy9ZqaXeO=agH=$ya!iVN$X~8}*w8
zWxC<LBGeQ7*7^+(uQ50<<U%&^EQJ{DZDk5xfp>dwI5(7t62c$nzTRYX(9csJEV5Ui
zuCHz#Ai(cw<0iq=t|AN)#y>|rml>{@d#NPY4XRg-rZe%e6)F-Dhb9%)@mj5z9}=;p
zJDe+0oTp1=(e}hLDqqrB)xeOR^_JNOW#WmF$6XCcU@9Q<EoyUI>734jeZ+e;k;`S~
z#zc?}#eo^qPoCjnk_0QSE;oLtT{9lLs9g7MGiumkKL-Q$u1wz7LS9{QynC|sKIj;x
zwX&S?!WHHj6JU<qF|qB|8iU_n-P^);u3f(EFsI<@5pkyd^T5udWdwgkfBg;H`AuO=
zk$#_5Zrp@t4McgPDSY?=&)2;Syp;!@w%GuMq;l{JW$MxrgQ!Dc&P%`mB#I~|K7+v`
z+OPAKGl-Dz-Gf8MuEi{0SSp+Tdv<z1ae|q85oMreFaGiI!fUP^VR85+;(vH@-o@3A
zLro=mz98m_)gPpMzJA4Zb91V3GM9K@By>3xo%-zNEJx&Oe~xQJtPn9L;QIXayVp4Z
zKQ3}ag?Ks}kg0YK5n{rn_y+M7xA5jIam7N{?FgZ`Q~1c(2sVIIO`QiTnWmQAuVfdz
zJdi*Dg2SB?Be^-Ksv;3DpfXGitq~@$>tqVr@@7@wvm$?J`Pr;w<CI$jH26Im)!s2f
zj8TIC<{&Ho@;i6<Q*2p9LivLuG#ZqemZX$l%?f^94Ag9HsrlGNGO3u~RMR6WCQ#RT
zp0J?iab8%SVedFunsrEG!(^FJhZWh;*qV-5vso#~c>D0C;`yr3mE@_0gN<DpHF38C
zfwA6nw1p90Q__;B+hX$w$a>mgmTF`ygjs2Ee88<|E@3LoG_m+^M?u)H_MW>uV2PZd
zdLhH$*(5Q^+l$bj{JC8+;+ekgYLU3La@@(NCZS==bO0TB&TKSUh{LaTva!!ght@pF
zy@SLCAy?E-S15&I&QQNxUbSDfAGAmLHI$^x?bpLlY<FFq`?yLd68e*>5qZtOgbwS~
zA{9ROn;#}7n=oTkk!WP^O?C?ET;Rnw@RQK;#9c?~<xdY5BQ8UXz~}r-Z=!WP8k<NM
zJ$Bl9L54f7vwy7CzC1n_it%)THLf{VX2`_QG)BRZad<GuR^C;p7IdI#Q~y<|7$tZr
zv16)iE1$+3NcVR7Kmh8cGb${_(@Uq`JHSo84w`k--<>g<DzFEwC@ww|pZwTFwBG6(
zu5QmDfBI6Orm<Dxd2aHHGxjeV1@<wf2@n`Ff<KSFSQ@hP(y^B55L?tmLD$z0ZZDHj
zQl;o6N+{WTGFe-A176{C{jBtH*a`c=-8mjJJC#4-awEyHmzc+}!F{Clanwck(}sq0
zuQ>lR3CX8KSEMKIKlaGg(8i)KeQ9zfmT8ZMl8rUH248@rUzwx?H-3}j;5Zc!YBBm2
zR}T8QhrVn)mDDGYvEJ5FRFIBgZfl-IS!{xdOIj$fSl_5h6ULboJbi#cO2MO>O9H8p
z)skTM`<%HWkDcnrwiVCU^jPx>BnFXqr;+#ALWRh^9g?mwms9B~Bb}pL%$E4eLlztD
zQNhfT;(miF{{dqN9nYu1+=ZeYa+K=^&tqpc#+<2sXyM~C_S*1LUcY^{sv}F*%p)~@
zK7E6;S^sH9r*pAw5|9I{Z+)iYLtpCr*Te)25UJL2)*;7g0i-Pb3}=?o0FP+B&|EFN
zgC7(kyjFaynSRZUa~}0phjkv!rTa7Zb#+k1dcBK{2%LkUJxYFNrSyc0rGhJ`>Alfg
z9)QScg4^!B#90XaFcuShdsc&M8a(*+Y~g6G>f-3+%4P280=^S8SqUl%@QmWe1IViB
zpda5Lab55-NAZb;cvZe9#^47mhnqO5hU?R!mi_vWY$4^9H><5=>Lc~dBmP|v!AddK
z;;JYzI`4;@We#9oBGS6ypJZ3`5P28H#cIEv7U9RD?S7uoe<;F=s!N;R8C*KSDANzb
zHbcw^qZLrZe=%!IrLjFX?|d{e7pNfdy*hM&;WfoUP}8G`Z-Gf>Qq9z>rvMh<hup5-
zKpXL+!AD)YPIY-NMl<z3W<g75-|{y%h{yC*>_$3F>TCE%ijr_SUY9iST<N2UDKQ`u
zP<ei6e}Cu|k3DycOS0X^hJ5Utdcx)yCLJmgr;FYh+W36a{P?6b^KB75I6W~ebA@9t
zNv)gl#8&h;{}yRFjOLb+3PJKaOlABR!aq08W|1Ip5S-OVaM6SNzpR=%IsGP8z3b%$
z5Vwu%ggW|rM5byA!vHIT{dOJ<C854Qe`rHTDka#`EaCbxnQ|STXWf~4lfL!t-8($K
zus%x;DbNa$-O~|W6y>YQM*FU8KAc2jc1iUL%~?U_dAzvgfl_KSBELXc6rch=HikAq
z2=Z33tu>+Y)O?}brukduWM`P478#a@(ZM69-Yu`2#GateWL4$v#{<fdQ7P?gdfv+y
zJ*gwy^ujC-l2tNn@(oEHF|kyB(hJw(P$FL;LOE+JZ)z+`Fz0zAp=~)kdty~tk~HqG
zw=`7Zuky;1BABHWqKH8kX?YiK%-+=Q8Pd49qtBLDC(*g*XGKyi1rlzSz7{M)Kt-m`
z5T<bLpErQ%s>rS-3_PSmGuHb=S`!#hk{o#wvavAld=L~Pl)=cX<T$gk%~?ODJZ5#{
zF*Ny(+AuN!=i6W-rASyzhX&G?3D+Al!%|eRcNEQe9t~AukG0@UjkW{EX8I4W@$xR1
z&D^G)$jH=O$4wK{dA~L+Kve<Z0pV{E|L=zyaG(AD)Cb*F|8m4}AK-pY{x5R?pgsr!
z9|!-Fp}%i<KXd)ZFd052|NlJpeVqIG-9I=D@IeU2`PXdkeU$qV<{uOv_({XxDF2B!
z?;GEbkNy~6V*Y!ybRXe<u<!?g3;QpG|Ar3tP48>fKc>6zQ2Ae!>wSRxE8!o2QKElY
m7w?<jpYngq=}G>_{O<)oRRJ00?hbVLHxTaUsk@Xs;Qs&_n_nOR

literal 0
HcmV?d00001

diff --git a/climada/engine/test/test_impact_calc.py b/climada/engine/test/test_impact_calc.py
index 23ef04294..d426157a6 100644
--- a/climada/engine/test/test_impact_calc.py
+++ b/climada/engine/test/test_impact_calc.py
@@ -36,7 +36,7 @@
 from climada.util.config import Config
 
 
-def get_haz_test_file(ds_name):
+def get_test_file(ds_name):
     # As this module is part of the installation test suite, we want tom make sure it is running
     # also in offline mode even when installing from pypi, where there is no test configuration.
     # So we set cache_enabled explicitly to true
@@ -46,7 +46,7 @@ def get_haz_test_file(ds_name):
     return haz_test_file
 
 
-HAZ_TEST_MAT = get_haz_test_file('atl_prob_no_name')
+HAZ_TEST_MAT = get_test_file('atl_prob_no_name')
 
 ENT = Entity.from_excel(ENT_DEMO_TODAY)
 HAZ = Hazard.from_mat(HAZ_TEST_MAT)
@@ -148,10 +148,9 @@ def test_calc_impact_TC_pass(self):
         self.assertAlmostEqual(6.512201157564421e+09 * x, impact.aai_agg, 5)
 
     def test_calc_impact_RF_pass(self):
-        from climada_petals.entity.impact_funcs.river_flood import flood_imp_func_set
-        haz = Hazard.from_hdf5(Path.home() / 'climada/data/hazard/test_hazard_US_flood_random_locations.hdf5')
-        exp = Exposures.from_hdf5(Path.home() / 'climada/data/exposures/test_exposure_US_flood_random_locations.hdf5')
-        impf_set = flood_imp_func_set()
+        haz = Hazard.from_hdf5(get_test_file('test_hazard_US_flood_random_locations'))
+        exp = Exposures.from_hdf5(get_test_file('test_exposure_US_flood_random_locations'))
+        impf_set = ImpactFuncSet.from_excel(Path(__file__).parent / 'data' / 'flood_imp_func_set.xls')
         icalc = ImpactCalc(exp, impf_set, haz)
         impact = icalc.impact()
         aai_agg = 161436.05112960344