From 5efad8304f2ad84854ace7cb6795111068a747ae Mon Sep 17 00:00:00 2001 From: spjuhel Date: Wed, 17 Dec 2025 17:10:19 +0100 Subject: [PATCH 01/61] cherry pick snapshots from feature/risk_trajectories --- climada/trajectories/snapshot.py | 163 +++++++++++++++++++++ climada/trajectories/test/test_snapshot.py | 132 +++++++++++++++++ 2 files changed, 295 insertions(+) create mode 100644 climada/trajectories/snapshot.py create mode 100644 climada/trajectories/test/test_snapshot.py diff --git a/climada/trajectories/snapshot.py b/climada/trajectories/snapshot.py new file mode 100644 index 0000000000..d8c78c0c20 --- /dev/null +++ b/climada/trajectories/snapshot.py @@ -0,0 +1,163 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +This modules implements the Snapshot class. + +Snapshot are used to store a snapshot of Exposure, Hazard and Vulnerability +at a specific date. + +""" + +import copy +import datetime +import logging + +import pandas as pd + +from climada.entity.exposures import Exposures +from climada.entity.impact_funcs import ImpactFuncSet +from climada.entity.measures.base import Measure +from climada.hazard import Hazard + +LOGGER = logging.getLogger(__name__) + +__all__ = ["Snapshot"] + + +class Snapshot: + """ + A snapshot of exposure, hazard, and impact function at a specific date. + + Parameters + ---------- + exposure : Exposures + hazard : Hazard + impfset : ImpactFuncSet + date : int | datetime.date | str + The date of the Snapshot, it can be an integer representing a year, + a datetime object or a string representation of a datetime object + with format "YYYY-MM-DD". + + Attributes + ---------- + date : datetime + Date of the snapshot. + measure: Measure | None + The possible measure applied to the snapshot. + + Notes + ----- + + The object creates deep copies of the exposure hazard and impact function set. + + Also note that exposure, hazard and impfset are read-only properties. + Consider snapshot as immutable objects. + + To create a snapshot with a measure, create a snapshot `snap` without + the measure and call `snap.apply_measure(measure)`, which returns a new Snapshot object + with the measure applied to its risk dimensions. + """ + + def __init__( + self, + *, + exposure: Exposures, + hazard: Hazard, + impfset: ImpactFuncSet, + date: int | datetime.date | str, + ) -> None: + self._exposure = copy.deepcopy(exposure) + self._hazard = copy.deepcopy(hazard) + self._impfset = copy.deepcopy(impfset) + self._measure = None + self._date = self._convert_to_date(date) + + @property + def exposure(self) -> Exposures: + """Exposure data for the snapshot.""" + return self._exposure + + @property + def hazard(self) -> Hazard: + """Hazard data for the snapshot.""" + return self._hazard + + @property + def impfset(self) -> ImpactFuncSet: + """Impact function set data for the snapshot.""" + return self._impfset + + @property + def measure(self) -> Measure | None: + """(Adaptation) Measure data for the snapshot.""" + return self._measure + + @property + def date(self) -> datetime.date: + """Date of the snapshot.""" + return self._date + + @property + def impact_calc_data(self) -> dict: + """Convenience function for ImpactCalc class.""" + return { + "exposures": self.exposure, + "hazard": self.hazard, + "impfset": self.impfset, + } + + @staticmethod + def _convert_to_date(date_arg) -> datetime.date: + """Convert date argument of type int or str to a datetime.date object.""" + if isinstance(date_arg, int): + # Assume the integer represents a year + return datetime.date(date_arg, 1, 1) + elif isinstance(date_arg, str): + # Try to parse the string as a date + try: + return datetime.datetime.strptime(date_arg, "%Y-%m-%d").date() + except ValueError: + raise ValueError("String must be in the format 'YYYY-MM-DD'") + elif isinstance(date_arg, datetime.date): + # Already a date object + return date_arg + else: + raise TypeError("date_arg must be an int, str, or datetime.date") + + def apply_measure(self, measure: Measure) -> "Snapshot": + """Create a new snapshot by applying a Measure object. + + This method creates a new `Snapshot` object by applying a measure on + the current one. + + Parameters + ---------- + measure : Measure + The measure to be applied to the snapshot. + + Returns + ------- + The Snapshot with the measure applied. + + """ + + LOGGER.debug(f"Applying measure {measure.name} on snapshot {id(self)}") + exp, impfset, haz = measure.apply(self.exposure, self.impfset, self.hazard) + snap = Snapshot(exposure=exp, hazard=haz, impfset=impfset, date=self.date) + snap._measure = measure + return snap diff --git a/climada/trajectories/test/test_snapshot.py b/climada/trajectories/test/test_snapshot.py new file mode 100644 index 0000000000..4e3b465d8e --- /dev/null +++ b/climada/trajectories/test/test_snapshot.py @@ -0,0 +1,132 @@ +import datetime +import unittest +from unittest.mock import MagicMock + +import numpy as np +import pandas as pd + +from climada.entity.exposures import Exposures +from climada.entity.impact_funcs import ImpactFunc, ImpactFuncSet +from climada.entity.measures.base import Measure +from climada.hazard import Hazard +from climada.trajectories.snapshot import Snapshot +from climada.util.constants import EXP_DEMO_H5, HAZ_DEMO_H5 + + +class TestSnapshot(unittest.TestCase): + + def setUp(self): + # Create mock objects for testing + self.mock_exposure = Exposures.from_hdf5(EXP_DEMO_H5) + self.mock_hazard = Hazard.from_hdf5(HAZ_DEMO_H5) + self.mock_impfset = ImpactFuncSet( + [ + ImpactFunc( + "TC", + 3, + intensity=np.array([0, 20]), + mdd=np.array([0, 0.5]), + paa=np.array([0, 1]), + ) + ] + ) + self.mock_measure = MagicMock(spec=Measure) + self.mock_measure.name = "Test Measure" + + # Setup mock return values for measure.apply + self.mock_modified_exposure = MagicMock(spec=Exposures) + self.mock_modified_hazard = MagicMock(spec=Hazard) + self.mock_modified_impfset = MagicMock(spec=ImpactFuncSet) + self.mock_measure.apply.return_value = ( + self.mock_modified_exposure, + self.mock_modified_impfset, + self.mock_modified_hazard, + ) + + def test_init_with_int_date(self): + snapshot = Snapshot( + exposure=self.mock_exposure, + hazard=self.mock_hazard, + impfset=self.mock_impfset, + date=2023, + ) + self.assertEqual(snapshot.date, datetime.date(2023, 1, 1)) + + def test_init_with_str_date(self): + snapshot = Snapshot( + exposure=self.mock_exposure, + hazard=self.mock_hazard, + impfset=self.mock_impfset, + date="2023-01-01", + ) + self.assertEqual(snapshot.date, datetime.date(2023, 1, 1)) + + def test_init_with_date_object(self): + date_obj = datetime.date(2023, 1, 1) + snapshot = Snapshot( + exposure=self.mock_exposure, + hazard=self.mock_hazard, + impfset=self.mock_impfset, + date=date_obj, + ) + self.assertEqual(snapshot.date, date_obj) + + def test_init_with_invalid_date(self): + with self.assertRaises(ValueError): + Snapshot( + exposure=self.mock_exposure, + hazard=self.mock_hazard, + impfset=self.mock_impfset, + date="invalid-date", + ) + + def test_init_with_invalid_type(self): + with self.assertRaises(TypeError): + Snapshot( + exposure=self.mock_exposure, + hazard=self.mock_hazard, + impfset=self.mock_impfset, + date=2023.5, # type: ignore + ) + + def test_properties(self): + snapshot = Snapshot( + exposure=self.mock_exposure, + hazard=self.mock_hazard, + impfset=self.mock_impfset, + date=2023, + ) + + # We want a new reference + self.assertIsNot(snapshot.exposure, self.mock_exposure) + self.assertIsNot(snapshot.hazard, self.mock_hazard) + self.assertIsNot(snapshot.impfset, self.mock_impfset) + + # But we want equality + pd.testing.assert_frame_equal(snapshot.exposure.gdf, self.mock_exposure.gdf) + + self.assertEqual(snapshot.hazard.haz_type, self.mock_hazard.haz_type) + self.assertEqual(snapshot.hazard.intensity.nnz, self.mock_hazard.intensity.nnz) + self.assertEqual(snapshot.hazard.size, self.mock_hazard.size) + + self.assertEqual(snapshot.impfset, self.mock_impfset) + + def test_apply_measure(self): + snapshot = Snapshot( + exposure=self.mock_exposure, + hazard=self.mock_hazard, + impfset=self.mock_impfset, + date=2023, + ) + new_snapshot = snapshot.apply_measure(self.mock_measure) + + self.assertIsNotNone(new_snapshot.measure) + self.assertEqual(new_snapshot.measure.name, "Test Measure") # type: ignore + self.assertEqual(new_snapshot.exposure, self.mock_modified_exposure) + self.assertEqual(new_snapshot.hazard, self.mock_modified_hazard) + self.assertEqual(new_snapshot.impfset, self.mock_modified_impfset) + + +if __name__ == "__main__": + TESTS = unittest.TestLoader().loadTestsFromTestCase(TestSnapshot) + unittest.TextTestRunner(verbosity=2).run(TESTS) From ecae36e8b016a82c6447060f0684e89b28a99320 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Wed, 17 Dec 2025 17:30:38 +0100 Subject: [PATCH 02/61] Cherrypicks from risk traj --- climada/trajectories/interpolation.py | 439 ++++++++++++++++++ .../trajectories/test/test_interpolation.py | 352 ++++++++++++++ 2 files changed, 791 insertions(+) create mode 100644 climada/trajectories/interpolation.py create mode 100644 climada/trajectories/test/test_interpolation.py diff --git a/climada/trajectories/interpolation.py b/climada/trajectories/interpolation.py new file mode 100644 index 0000000000..9f6687e449 --- /dev/null +++ b/climada/trajectories/interpolation.py @@ -0,0 +1,439 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +This modules implements different sparce matrices and numpy arrays +interpolation approaches. + +""" + +import logging +from abc import ABC +from collections.abc import Callable +from typing import Any, Dict, List, Optional + +import numpy as np +from scipy import sparse + +LOGGER = logging.getLogger(__name__) + +__all__ = [ + "AllLinearStrategy", + "ExponentialExposureStrategy", + "linear_interp_arrays", + "linear_interp_imp_mat", + "exponential_interp_arrays", + "exponential_interp_imp_mat", +] + + +def linear_interp_imp_mat( + mat_start: sparse.csr_matrix, + mat_end: sparse.csr_matrix, + number_of_interpolation_points: int, +) -> List[sparse.csr_matrix]: + r""" + Linearly interpolates between two sparse impact matrices. + + Creates a sequence of matrices representing a linear transition from a starting + matrix to an ending matrix. The interpolation includes both the start and end + points. + + Parameters + ---------- + mat_start : scipy.sparse.csr_matrix + The starting impact matrix. Must have a shape compatible with `mat_end` + for arithmetic operations. + mat_end : scipy.sparse.csr_matrix + The ending impact matrix. Must have a shape compatible with `mat_start` + for arithmetic operations. + number_of_interpolation_points : int + The total number of matrices to return, including the start and end points. + Must be $\ge 2$. + + Returns + ------- + list of scipy.sparse.csr_matrix + A list of matrices, where the first element is `mat_start` and the last + element is `mat_end`. The total length of the list is + `number_of_interpolation_points`. + + Notes + ----- + The formula used for interpolation at proportion $p$ is: + $$M_p = M_{start} \cdot (1 - p) + M_{end} \cdot p$$ + The proportions $p$ range from 0 to 1, inclusive. + """ + + return [ + mat_start + prop * (mat_end - mat_start) + for prop in np.linspace(0, 1, number_of_interpolation_points) + ] + + +def exponential_interp_imp_mat( + mat_start: sparse.csr_matrix, + mat_end: sparse.csr_matrix, + number_of_interpolation_points: int, +) -> List[sparse.csr_matrix]: + r""" + Exponentially interpolates between two "impact matrices". + + This function performs interpolation in a logarithmic space, effectively + achieving an exponential-like transition between `mat_start` and `mat_end`. + It is designed for objects that wrap NumPy arrays and expose them via a + `.data` attribute. + + Parameters + ---------- + mat_start : object + The starting matrix object. Must have a `.data` attribute that is a + NumPy array of positive values. + mat_end : object + The ending matrix object. Must have a `.data` attribute that is a + NumPy array of positive values and have a compatible shape with `mat_start`. + number_of_interpolation_points : int + The total number of matrix objects to return, including the start and + end points. Must be $\ge 2$. + + Returns + ------- + list of object + A list of interpolated matrix objects. The first element corresponds to + `mat_start` and the last to `mat_end` (after the conversion/reversion). + The list length is `number_of_interpolation_points`. + + Notes + ----- + The interpolation is achieved by: + + 1. Mapping the matrix data to a transformed logarithmic space: + $$M'_{i} = \ln(M_{i})}$$ + (where $\ln$ is the natural logarithm, and $\epsilon$ is added to $M_{i}$ + to prevent $\ln(0)$). + 2. Performing standard linear interpolation on the transformed matrices + $M'_{start}$ and $M'_{end}$ to get $M'_{interp}$: + $$M'_{interp} = M'_{start} \cdot (1 - \text{ratio}) + M'_{end} \cdot \text{ratio}$$ + 3. Mapping the result back to the original domain: + $$M_{interp} = \exp(M'_{interp}$$ + """ + + mat_start = mat_start.copy() + mat_end = mat_end.copy() + mat_start.data = np.log(mat_start.data + np.finfo(float).eps) + mat_end.data = np.log(mat_end.data + np.finfo(float).eps) + + # Perform linear interpolation in the logarithmic domain + res = [] + num_points = number_of_interpolation_points + for point in range(num_points): + ratio = point / (num_points - 1) + mat_interpolated = mat_start * (1 - ratio) + ratio * mat_end + mat_interpolated.data = np.exp(mat_interpolated.data) + res.append(mat_interpolated) + return res + + +def linear_interp_arrays(arr_start: np.ndarray, arr_end: np.ndarray) -> np.ndarray: + r""" + Performs linear interpolation between two NumPy arrays over their first dimension. + + This function interpolates each metric (column) linearly across the time steps + (rows), including both the start and end states. + + Parameters + ---------- + arr_start : numpy.ndarray + The starting array of metrics. The first dimension (rows) is assumed to + represent the interpolation steps (e.g., dates/time points). + arr_end : numpy.ndarray + The ending array of metrics. Must have the exact same shape as `arr_start`. + + Returns + ------- + numpy.ndarray + An array with the same shape as `arr_start` and `arr_end`. The values + in the first dimension transition linearly from those in `arr_start` + to those in `arr_end`. + + Raises + ------ + ValueError + If `arr_start` and `arr_end` do not have the same shape. + + Notes + ----- + The interpolation is performed element-wise along the first dimension + (axis 0). For each row $i$ and proportion $p_i$, the result $R_i$ is calculated as: + + $$R_i = arr\_start_i \cdot (1 - p_i) + arr\_end_i \cdot p_i$$ + + where $p_i$ is generated by $\text{np.linspace}(0, 1, n)$ and $n$ is the + size of the first dimension ($\text{arr\_start.shape}[0]$). + """ + if arr_start.shape != arr_end.shape: + raise ValueError( + f"Cannot interpolate arrays of different shapes: {arr_start.shape} and {arr_end.shape}." + ) + interpolation_range = arr_start.shape[0] + prop1 = np.linspace(0, 1, interpolation_range) + prop0 = 1 - prop1 + if arr_start.ndim > 1: + prop0, prop1 = prop0.reshape(-1, 1), prop1.reshape(-1, 1) + + return np.multiply(arr_start, prop0) + np.multiply(arr_end, prop1) + + +def exponential_interp_arrays(arr_start: np.ndarray, arr_end: np.ndarray) -> np.ndarray: + r""" + Performs exponential interpolation between two NumPy arrays over their first dimension. + + This function achieves an exponential-like transition by performing linear + interpolation in the logarithmic space, suitable to interpolate over a dimension which has + a growth factor. + + Parameters + ---------- + arr_start : numpy.ndarray + The starting array of metrics. Values must be positive. + arr_end : numpy.ndarray + The ending array of metrics. Must have the exact same shape as `arr_start`. + + Returns + ------- + numpy.ndarray + An array with the same shape as `arr_start` and `arr_end`. The values + in the first dimension transition exponentially from those in `arr_start` + to those in `arr_end`. + + Raises + ------ + ValueError + If `arr_start` and `arr_end` do not have the same shape. + + Notes + ----- + The interpolation is performed by transforming the arrays to a logarithmic + domain, linearly interpolating, and then transforming back. + + The formula for the interpolated result $R$ at proportion $\text{prop}$ is: + $$ + R = \exp \left( + \ln(A_{start}) \cdot (1 - \text{prop}) + + \ln(A_{end}) \cdot \text{prop} + \right) + $$ + where $A_{start}$ and $A_{end}$ are the input arrays (with $\epsilon$ added + to prevent $\ln(0)$) and $\text{prop}$ ranges from 0 to 1. + """ + if arr_start.shape != arr_end.shape: + raise ValueError( + f"Cannot interpolate arrays of different shapes: {arr_start.shape} and {arr_end.shape}." + ) + interpolation_range = arr_start.shape[0] + + prop1 = np.linspace(0, 1, interpolation_range) + prop0 = 1 - prop1 + if arr_start.ndim > 1: + prop0, prop1 = prop0.reshape(-1, 1), prop1.reshape(-1, 1) + + # Perform log transformation, linear interpolation, and exponential back-transformation + log_arr_start = np.log(arr_start + np.finfo(float).eps) + log_arr_end = np.log(arr_end + np.finfo(float).eps) + + interpolated_log_arr = np.multiply(log_arr_start, prop0) + np.multiply( + log_arr_end, prop1 + ) + + return np.exp(interpolated_log_arr) + + +class InterpolationStrategyBase(ABC): + r""" + Base abstract class for defining a set of interpolation strategies. + + This class serves as a blueprint for implementing specific interpolation + methods (e.g., 'Linear', 'Exponential') across different impact dimensions: + Exposure (matrices), Hazard, and Vulnerability (arrays/metrics). + + Attributes + ---------- + exposure_interp : Callable + The function used to interpolate sparse impact matrices over the + exposure dimension. + Signature: (mat_start, mat_end, num_points, **kwargs) -> list[sparse.csr_matrix]. + hazard_interp : Callable + The function used to interpolate NumPy arrays of metrics over the + hazard dimension. + Signature: (arr_start, arr_end, **kwargs) -> np.ndarray. + vulnerability_interp : Callable + The function used to interpolate NumPy arrays of metrics over the + vulnerability dimension. + Signature: (arr_start, arr_end, **kwargs) -> np.ndarray. + """ + + exposure_interp: Callable + hazard_interp: Callable + vulnerability_interp: Callable + + def interp_over_exposure_dim( + self, + imp_E0: sparse.csr_matrix, + imp_E1: sparse.csr_matrix, + interpolation_range: int, + /, + **kwargs: Optional[Dict[str, Any]], + ) -> List[sparse.csr_matrix]: + """ + Interpolates between two impact matrices using the defined exposure strategy. + + This method calls the function assigned to :attr:`exposure_interp` to generate + a sequence of matrices. + + Parameters + ---------- + imp_E0 : scipy.sparse.csr_matrix + A sparse matrix of the impacts at the start of the range. + imp_E1 : scipy.sparse.csr_matrix + A sparse matrix of the impacts at the end of the range. + interpolation_range : int + The total number of time points to interpolate, including the start and end. + **kwargs : Optional[Dict[str, Any]] + Keyword arguments to pass to the underlying :attr:`exposure_interp` function. + + Returns + ------- + list of scipy.sparse.csr_matrix + A list of ``interpolation_range`` interpolated impact matrices. + + Raises + ------ + ValueError + If the underlying interpolation function raises a ``ValueError`` + indicating incompatible matrix shapes. + """ + try: + res = self.exposure_interp(imp_E0, imp_E1, interpolation_range, **kwargs) + except ValueError as err: + if str(err) == "inconsistent shapes": + raise ValueError( + "Tried to interpolate impact matrices of different shapes. " + "A possible reason could be Exposures of different shapes." + ) from err + + raise err + + return res + + def interp_over_hazard_dim( + self, + metric_0: np.ndarray, + metric_1: np.ndarray, + /, + **kwargs: Optional[Dict[str, Any]], + ) -> np.ndarray: + """ + Interpolates between two metric arrays using the defined hazard strategy. + + This method calls the function assigned to :attr:`hazard_interp`. + + Parameters + ---------- + metric_0 : numpy.ndarray + The starting array of metrics. + metric_1 : numpy.ndarray + The ending array of metrics. Must have the same shape as ``metric_0``. + **kwargs : Optional [Dict[str, Any]] + Keyword arguments to pass to the underlying :attr:`hazard_interp` function. + + Returns + ------- + numpy.ndarray + The resulting interpolated array. + """ + return self.hazard_interp(metric_0, metric_1, **kwargs) + + def interp_over_vulnerability_dim( + self, + metric_0: np.ndarray, + metric_1: np.ndarray, + /, + **kwargs: Optional[Dict[str, Any]], + ) -> np.ndarray: + """ + Interpolates between two metric arrays using the defined vulnerability strategy. + + This method calls the function assigned to :attr:`vulnerability_interp`. + + Parameters + ---------- + metric_0 : numpy.ndarray + The starting array of metrics. + metric_1 : numpy.ndarray + The ending array of metrics. Must have the same shape as ``metric_0``. + **kwargs : Optional[Dict[str, Any]] + Keyword arguments to pass to the underlying :attr:`vulnerability_interp` function. + + Returns + ------- + numpy.ndarray + The resulting interpolated array. + """ + # Note: Assuming the Callable takes the exact positional arguments + return self.vulnerability_interp(metric_0, metric_1, **kwargs) + + +class InterpolationStrategy(InterpolationStrategyBase): + r"""Interface for interpolation strategies. + + This is the class to use to define your own custom interpolation strategy. + """ + + def __init__( + self, + exposure_interp: Callable, + hazard_interp: Callable, + vulnerability_interp: Callable, + ) -> None: + super().__init__() + self.exposure_interp = exposure_interp + self.hazard_interp = hazard_interp + self.vulnerability_interp = vulnerability_interp + + +class AllLinearStrategy(InterpolationStrategyBase): + r"""Linear interpolation strategy over all dimensions.""" + + def __init__(self) -> None: + super().__init__() + self.exposure_interp = linear_interp_imp_mat + self.hazard_interp = linear_interp_arrays + self.vulnerability_interp = linear_interp_arrays + + +class ExponentialExposureStrategy(InterpolationStrategyBase): + r"""Exponential interpolation strategy for exposure and linear for Hazard and Vulnerability.""" + + def __init__(self) -> None: + super().__init__() + self.exposure_interp = ( + lambda mat_start, mat_end, points: exponential_interp_imp_mat( + mat_start, mat_end, points + ) + ) + self.hazard_interp = linear_interp_arrays + self.vulnerability_interp = linear_interp_arrays diff --git a/climada/trajectories/test/test_interpolation.py b/climada/trajectories/test/test_interpolation.py new file mode 100644 index 0000000000..693c9b9c33 --- /dev/null +++ b/climada/trajectories/test/test_interpolation.py @@ -0,0 +1,352 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +Tests for interpolation + +""" + +import unittest +from unittest.mock import MagicMock + +import numpy as np +from scipy.sparse import csr_matrix + +from climada.trajectories.interpolation import ( + AllLinearStrategy, + ExponentialExposureStrategy, + InterpolationStrategy, + exponential_interp_arrays, + exponential_interp_imp_mat, + linear_interp_arrays, + linear_interp_imp_mat, +) + + +class TestInterpolationFuncs(unittest.TestCase): + def setUp(self): + # Create mock impact matrices for testing + self.imp_mat0 = csr_matrix(np.array([[1, 2], [3, 4]])) + self.imp_mat1 = csr_matrix(np.array([[5, 6], [7, 8]])) + self.imp_mat2 = csr_matrix(np.array([[5, 6, 7], [8, 9, 10]])) # Different shape + self.time_points = 5 + self.interpolation_range_5 = 5 + self.interpolation_range_1 = 1 + self.interpolation_range_2 = 2 + self.rtol = 1e-5 + self.atol = 1e-8 + + def test_linear_interp_arrays(self): + arr_start = np.array([10, 100]) + arr_end = np.array([20, 200]) + expected = np.array([10.0, 200.0]) + result = linear_interp_arrays(arr_start, arr_end) + np.testing.assert_allclose(result, expected, rtol=self.rtol, atol=self.atol) + + def test_linear_interp_arrays2D(self): + arr_start = np.array([[10, 100], [10, 100]]) + arr_end = np.array([[20, 200], [20, 200]]) + expected = np.array([[10.0, 100.0], [20, 200]]) + result = linear_interp_arrays(arr_start, arr_end) + np.testing.assert_allclose(result, expected, rtol=self.rtol, atol=self.atol) + + def test_linear_interp_arrays_shape(self): + arr_start = np.array([10, 100, 5]) + arr_end = np.array([20, 200]) + with self.assertRaises(ValueError): + linear_interp_arrays(arr_start, arr_end) + + def test_linear_interp_arrays_start_equals_end(self): + arr_start = np.array([5, 5]) + arr_end = np.array([5, 5]) + expected = np.array([5.0, 5.0]) + result = linear_interp_arrays(arr_start, arr_end) + np.testing.assert_allclose(result, expected, rtol=self.rtol, atol=self.atol) + + def test_exponential_interp_arrays_1d(self): + arr_start = np.array([1, 10, 100]) + arr_end = np.array([2, 20, 200]) + expected = np.array([1.0, 14.142136, 200.0]) + result = exponential_interp_arrays(arr_start, arr_end) + np.testing.assert_allclose(result, expected, rtol=self.rtol, atol=self.atol) + + def test_exponential_interp_arrays_shape(self): + arr_start = np.array([10, 100, 5]) + arr_end = np.array([20, 200]) + with self.assertRaises(ValueError): + exponential_interp_arrays(arr_start, arr_end) + + def test_exponential_interp_arrays_2d(self): + arr_start = np.array( + [ + [1, 10, 100], # date 1 metric a,b,c + [1, 10, 100], # date 2 metric a,b,c + [1, 10, 100], + ] + ) # date 3 metric a,b,c + arr_end = np.array([[2, 20, 200], [2, 20, 200], [2, 20, 200]]) + expected = np.array( + [[1.0, 10.0, 100.0], [1.4142136, 14.142136, 141.42136], [2, 20, 200]] + ) + result = exponential_interp_arrays(arr_start, arr_end) + np.testing.assert_allclose(result, expected, rtol=self.rtol, atol=self.atol) + + def test_exponential_interp_arrays_start_equals_end(self): + arr_start = np.array([5, 5]) + arr_end = np.array([5, 5]) + expected = np.array([5.0, 5.0]) + result = exponential_interp_arrays(arr_start, arr_end) + np.testing.assert_allclose(result, expected, rtol=self.rtol, atol=self.atol) + + def test_linear_impmat_interpolate(self): + result = linear_interp_imp_mat(self.imp_mat0, self.imp_mat1, self.time_points) + self.assertEqual(len(result), self.time_points) + for mat in result: + self.assertIsInstance(mat, csr_matrix) + + dense = np.array([r.todense() for r in result]) + expected = np.array( + [ + [[1.0, 2.0], [3.0, 4.0]], + [[2.0, 3.0], [4.0, 5.0]], + [[3.0, 4.0], [5.0, 6.0]], + [[4.0, 5.0], [6.0, 7.0]], + [[5.0, 6.0], [7.0, 8.0]], + ] + ) + np.testing.assert_array_equal(dense, expected) + + def test_linear_impmat_interpolate_inconsistent_shape(self): + with self.assertRaises(ValueError): + linear_interp_imp_mat(self.imp_mat0, self.imp_mat2, self.time_points) + + def test_exp_impmat_interpolate(self): + result = exponential_interp_imp_mat( + self.imp_mat0, self.imp_mat1, self.time_points + ) + self.assertEqual(len(result), self.time_points) + for mat in result: + self.assertIsInstance(mat, csr_matrix) + + dense = np.array([r.todense() for r in result]) + expected = np.array( + [ + [[1.0, 2.0], [3.0, 4.0]], + [[1.49534878, 2.63214803], [3.70779275, 4.75682846]], + [[2.23606798, 3.46410162], [4.58257569, 5.65685425]], + [[3.34370152, 4.55901411], [5.66374698, 6.72717132]], + [[5.0, 6.0], [7.0, 8.0]], + ] + ) + np.testing.assert_array_almost_equal(dense, expected) + + def test_exp_impmat_interpolate_inconsistent_shape(self): + with self.assertRaises(ValueError): + exponential_interp_imp_mat(self.imp_mat0, self.imp_mat2, self.time_points) + + +class TestInterpolationStrategies(unittest.TestCase): + + def setUp(self): + self.interpolation_range = 3 + self.dummy_metric_0 = np.array([10, 20]) + self.dummy_metric_1 = np.array([100, 200]) + self.dummy_matrix_0 = csr_matrix(np.array([[1, 2], [3, 4]])) + self.dummy_matrix_1 = csr_matrix(np.array([[10, 20], [30, 40]])) + + def test_InterpolationStrategy_init(self): + def mock_exposure(a, b, r): + return a + b + + def mock_hazard(a, b, r): + return a * b + + def mock_vulnerability(a, b, r): + return a / b + + strategy = InterpolationStrategy(mock_exposure, mock_hazard, mock_vulnerability) + self.assertEqual(strategy.exposure_interp, mock_exposure) + self.assertEqual(strategy.hazard_interp, mock_hazard) + self.assertEqual(strategy.vulnerability_interp, mock_vulnerability) + + def test_InterpolationStrategy_interp_exposure_dim(self): + mock_exposure = MagicMock(return_value=["mock_result"]) + strategy = InterpolationStrategy( + mock_exposure, linear_interp_arrays, linear_interp_arrays + ) + + result = strategy.interp_over_exposure_dim( + self.dummy_matrix_0, self.dummy_matrix_1, self.interpolation_range + ) + mock_exposure.assert_called_once_with( + self.dummy_matrix_0, self.dummy_matrix_1, self.interpolation_range + ) + self.assertEqual(result, ["mock_result"]) + + def test_InterpolationStrategy_interp_exposure_dim_inconsistent_shapes(self): + mock_exposure = MagicMock(side_effect=ValueError("inconsistent shapes")) + strategy = InterpolationStrategy( + mock_exposure, linear_interp_arrays, linear_interp_arrays + ) + + with self.assertRaisesRegex( + ValueError, "Tried to interpolate impact matrices of different shape" + ): + strategy.interp_over_exposure_dim( + self.dummy_matrix_0, + csr_matrix(np.array([[1]])), + self.interpolation_range, + ) + mock_exposure.assert_called_once() # Ensure it was called + + def test_InterpolationStrategy_interp_hazard_dim(self): + mock_hazard = MagicMock(return_value=np.array([1, 2, 3])) + strategy = InterpolationStrategy( + linear_interp_imp_mat, mock_hazard, linear_interp_arrays + ) + + result = strategy.interp_over_hazard_dim( + self.dummy_metric_0, self.dummy_metric_1 + ) + mock_hazard.assert_called_once_with(self.dummy_metric_0, self.dummy_metric_1) + np.testing.assert_array_equal(result, np.array([1, 2, 3])) + + def test_InterpolationStrategy_interp_vulnerability_dim(self): + mock_vulnerability = MagicMock(return_value=np.array([4, 5, 6])) + strategy = InterpolationStrategy( + linear_interp_imp_mat, linear_interp_arrays, mock_vulnerability + ) + + result = strategy.interp_over_vulnerability_dim( + self.dummy_metric_0, self.dummy_metric_1 + ) + mock_vulnerability.assert_called_once_with( + self.dummy_metric_0, self.dummy_metric_1 + ) + np.testing.assert_array_equal(result, np.array([4, 5, 6])) + + +class TestConcreteInterpolationStrategies(unittest.TestCase): + + def setUp(self): + self.interpolation_range = 3 + self.dummy_metric_0 = np.array([10, 20, 30]) + self.dummy_metric_1 = np.array([100, 200, 300]) + self.dummy_matrix_0 = csr_matrix([[1, 2], [3, 4]]) + self.dummy_matrix_1 = csr_matrix([[10, 20], [30, 40]]) + self.dummy_matrix_0_1_lin = csr_matrix([[5.5, 11], [16.5, 22]]) + self.dummy_matrix_0_1_exp = csr_matrix( + [[3.162278, 6.324555], [9.486833, 12.649111]] + ) + self.rtol = 1e-5 + self.atol = 1e-8 + + def test_AllLinearStrategy_init_and_methods(self): + strategy = AllLinearStrategy() + self.assertEqual(strategy.exposure_interp, linear_interp_imp_mat) + self.assertEqual(strategy.hazard_interp, linear_interp_arrays) + self.assertEqual(strategy.vulnerability_interp, linear_interp_arrays) + + # Test hazard interpolation + expected_hazard_interp = linear_interp_arrays( + self.dummy_metric_0, self.dummy_metric_1 + ) + result_hazard = strategy.interp_over_hazard_dim( + self.dummy_metric_0, self.dummy_metric_1 + ) + np.testing.assert_allclose( + result_hazard, expected_hazard_interp, rtol=self.rtol, atol=self.atol + ) + + # Test vulnerability interpolation + expected_vulnerability_interp = linear_interp_arrays( + self.dummy_metric_0, self.dummy_metric_1 + ) + result_vulnerability = strategy.interp_over_vulnerability_dim( + self.dummy_metric_0, self.dummy_metric_1 + ) + np.testing.assert_allclose( + result_vulnerability, + expected_vulnerability_interp, + rtol=self.rtol, + atol=self.atol, + ) + + # Test exposure interpolation (using mock for linear_interp_imp_mat) + result_exposure = strategy.interp_over_exposure_dim( + self.dummy_matrix_0, self.dummy_matrix_1, self.interpolation_range + ) + # Verify the structure/first/last elements of the mock output + self.assertEqual(len(result_exposure), self.interpolation_range) + np.testing.assert_allclose(result_exposure[0].data, self.dummy_matrix_0.data) + np.testing.assert_allclose( + result_exposure[1].data, self.dummy_matrix_0_1_lin.data + ) + np.testing.assert_allclose(result_exposure[2].data, self.dummy_matrix_1.data) + + def test_ExponentialExposureInterpolation_init_and_methods(self): + strategy = ExponentialExposureStrategy() + # Test hazard interpolation (should be linear) + expected_hazard_interp = linear_interp_arrays( + self.dummy_metric_0, self.dummy_metric_1 + ) + result_hazard = strategy.interp_over_hazard_dim( + self.dummy_metric_0, self.dummy_metric_1 + ) + np.testing.assert_allclose( + result_hazard, expected_hazard_interp, rtol=self.rtol, atol=self.atol + ) + + # Test vulnerability interpolation (should be linear) + expected_vulnerability_interp = linear_interp_arrays( + self.dummy_metric_0, self.dummy_metric_1 + ) + result_vulnerability = strategy.interp_over_vulnerability_dim( + self.dummy_metric_0, self.dummy_metric_1 + ) + np.testing.assert_allclose( + result_vulnerability, + expected_vulnerability_interp, + rtol=self.rtol, + atol=self.atol, + ) + + # Test exposure interpolation (using mock for exponential_interp_imp_mat) + result_exposure = strategy.interp_over_exposure_dim( + self.dummy_matrix_0, self.dummy_matrix_1, self.interpolation_range + ) + # Verify the structure/first/last elements of the mock output + self.assertEqual(len(result_exposure), self.interpolation_range) + np.testing.assert_allclose(result_exposure[0].data, self.dummy_matrix_0.data) + np.testing.assert_allclose( + result_exposure[1].data, + self.dummy_matrix_0_1_exp.data, + rtol=self.rtol, + atol=self.atol, + ) + np.testing.assert_allclose(result_exposure[-1].data, self.dummy_matrix_1.data) + + +if __name__ == "__main__": + TESTS = unittest.TestLoader().loadTestsFromTestCase( + TestConcreteInterpolationStrategies + ) + TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestInterpolationFuncs)) + TESTS.addTests( + unittest.TestLoader().loadTestsFromTestCase(TestInterpolationStrategies) + ) + unittest.TextTestRunner(verbosity=2).run(TESTS) From da997e7a0496917fc0412b2207acf04b0b31cf12 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Wed, 17 Dec 2025 17:52:11 +0100 Subject: [PATCH 03/61] Cherrypick from risk traj --- climada/trajectories/impact_calc_strat.py | 137 ++++++++++++++++++ .../test/test_impact_calc_strat.py | 84 +++++++++++ 2 files changed, 221 insertions(+) create mode 100644 climada/trajectories/impact_calc_strat.py create mode 100644 climada/trajectories/test/test_impact_calc_strat.py diff --git a/climada/trajectories/impact_calc_strat.py b/climada/trajectories/impact_calc_strat.py new file mode 100644 index 0000000000..a58aceeab2 --- /dev/null +++ b/climada/trajectories/impact_calc_strat.py @@ -0,0 +1,137 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +This modules implements the impact computation strategy objects for risk +trajectories. + +""" + +from abc import ABC, abstractmethod + +from climada.engine.impact import Impact +from climada.engine.impact_calc import ImpactCalc +from climada.entity.exposures.base import Exposures +from climada.entity.impact_funcs.impact_func_set import ImpactFuncSet +from climada.hazard.base import Hazard + +__all__ = ["ImpactCalcComputation"] + + +class ImpactComputationStrategy(ABC): + """ + Interface for impact computation strategies. + + This abstract class defines the contract for all concrete strategies + responsible for calculating and optionally modifying with a risk transfer, + the impact computation, based on a set of inputs (exposure, hazard, vulnerability). + + It revolves around a `compute_impacts()` method that takes as arguments + the three dimensions of risk (exposure, hazard, vulnerability) and return an + Impact object. + """ + + @abstractmethod + def compute_impacts( + self, + exp: Exposures, + haz: Hazard, + vul: ImpactFuncSet, + ) -> Impact: + """ + Calculates the total impact, including optional risk transfer application. + + Parameters + ---------- + exp : Exposures + The exposure data. + haz : Hazard + The hazard data (e.g., event intensity). + vul : ImpactFuncSet + The set of vulnerability functions. + + Returns + ------- + Impact + An object containing the computed total impact matrix and metrics. + + See Also + -------- + ImpactCalcComputation : The default implementation of this interface. + """ + ... + + +class ImpactCalcComputation(ImpactComputationStrategy): + r""" + Default impact computation strategy using the core engine of climada. + + This strategy first calculates the raw impact using the standard + :class:`ImpactCalc` logic. + + """ + + def compute_impacts( + self, + exp: Exposures, + haz: Hazard, + vul: ImpactFuncSet, + ) -> Impact: + """ + Calculates the impact and applies the "global" risk transfer mechanism. + + Parameters + ---------- + exp : Exposures + The exposure data. + haz : Hazard + The hazard data. + vul : ImpactFuncSet + The set of vulnerability functions. + + Returns + ------- + Impact + The final impact object. + """ + impact = self.compute_impacts_pre_transfer(exp, haz, vul) + return impact + + def compute_impacts_pre_transfer( + self, + exp: Exposures, + haz: Hazard, + vul: ImpactFuncSet, + ) -> Impact: + """ + Calculates the raw impact matrix before any risk transfer is applied. + + Parameters + ---------- + exp : Exposures + The exposure data. + haz : Hazard + The hazard data. + vul : ImpactFuncSet + The set of vulnerability functions. + + Returns + ------- + Impact + An Impact object containing the raw, pre-transfer impact matrix. + """ + return ImpactCalc(exposures=exp, impfset=vul, hazard=haz).impact() diff --git a/climada/trajectories/test/test_impact_calc_strat.py b/climada/trajectories/test/test_impact_calc_strat.py new file mode 100644 index 0000000000..a828ec51e6 --- /dev/null +++ b/climada/trajectories/test/test_impact_calc_strat.py @@ -0,0 +1,84 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +Tests for impact_calc_strat + +""" + +import unittest +from unittest.mock import MagicMock, patch + +from climada.engine import Impact +from climada.entity import ImpactFuncSet +from climada.entity.exposures import Exposures +from climada.hazard import Hazard +from climada.trajectories import Snapshot +from climada.trajectories.impact_calc_strat import ImpactCalcComputation + + +class TestImpactCalcComputation(unittest.TestCase): + def setUp(self): + self.mock_snapshot0 = MagicMock(spec=Snapshot) + self.mock_snapshot0.exposure = MagicMock(spec=Exposures) + self.mock_snapshot0.hazard = MagicMock(spec=Hazard) + self.mock_snapshot0.impfset = MagicMock(spec=ImpactFuncSet) + self.mock_snapshot1 = MagicMock(spec=Snapshot) + self.mock_snapshot1.exposure = MagicMock(spec=Exposures) + self.mock_snapshot1.hazard = MagicMock(spec=Hazard) + self.mock_snapshot1.impfset = MagicMock(spec=ImpactFuncSet) + + self.impact_calc_computation = ImpactCalcComputation() + + @patch.object(ImpactCalcComputation, "compute_impacts_pre_transfer") + def test_compute_impacts(self, mock_calculate_impacts_for_snapshots): + mock_impacts = MagicMock(spec=Impact) + mock_calculate_impacts_for_snapshots.return_value = mock_impacts + + result = self.impact_calc_computation.compute_impacts( + exp=self.mock_snapshot0.exposure, + haz=self.mock_snapshot0.hazard, + vul=self.mock_snapshot0.impfset, + ) + + self.assertEqual(result, mock_impacts) + mock_calculate_impacts_for_snapshots.assert_called_once_with( + self.mock_snapshot0.exposure, + self.mock_snapshot0.hazard, + self.mock_snapshot0.impfset, + ) + + def test_calculate_impacts_for_snapshots(self): + mock_imp_E0H0 = MagicMock(spec=Impact) + + with patch( + "climada.trajectories.impact_calc_strat.ImpactCalc" + ) as mock_impact_calc: + mock_impact_calc.return_value.impact.side_effect = [mock_imp_E0H0] + + result = self.impact_calc_computation.compute_impacts_pre_transfer( + exp=self.mock_snapshot0.exposure, + haz=self.mock_snapshot0.hazard, + vul=self.mock_snapshot0.impfset, + ) + + self.assertEqual(result, mock_imp_E0H0) + + +if __name__ == "__main__": + TESTS = unittest.TestLoader().loadTestsFromTestCase(TestImpactCalcComputation) + unittest.TextTestRunner(verbosity=2).run(TESTS) From a734bfa896b69170a9951b54507b16c6d707d145 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 18 Dec 2025 10:34:06 +0100 Subject: [PATCH 04/61] cherrypick from risk_traj --- climada/trajectories/calc_risk_metrics.py | 1214 +++++++++++++++ climada/trajectories/constants.py | 55 + climada/trajectories/test/test_riskperiod.py | 1389 ++++++++++++++++++ 3 files changed, 2658 insertions(+) create mode 100644 climada/trajectories/calc_risk_metrics.py create mode 100644 climada/trajectories/constants.py create mode 100644 climada/trajectories/test/test_riskperiod.py diff --git a/climada/trajectories/calc_risk_metrics.py b/climada/trajectories/calc_risk_metrics.py new file mode 100644 index 0000000000..04846d18d3 --- /dev/null +++ b/climada/trajectories/calc_risk_metrics.py @@ -0,0 +1,1214 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +This modules implements the CalcRiskPeriod class. + +CalcRiskPeriod are used to compute risk metrics (and intermediate requirements) +in between two snapshots. + +As these computations are not always required and can become "heavy", a so called "lazy" +approach is used: computation is only done when required, and then stored. + +""" + +import datetime +import itertools +import logging + +import numpy as np +import pandas as pd +from scipy.sparse import csr_matrix + +from climada.engine.impact import Impact, ImpactFreqCurve +from climada.engine.impact_calc import ImpactCalc +from climada.entity.measures.base import Measure +from climada.trajectories.constants import ( + AAI_METRIC_NAME, + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + CONTRIBUTION_TOTAL_RISK_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + COORD_ID_COL_NAME, + DATE_COL_NAME, + DEFAULT_PERIOD_INDEX_NAME, + EAI_METRIC_NAME, + GROUP_COL_NAME, + GROUP_ID_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + NO_MEASURE_VALUE, + RISK_COL_NAME, + RP_VALUE_PREFIX, + UNIT_COL_NAME, +) +from climada.trajectories.impact_calc_strat import ImpactComputationStrategy +from climada.trajectories.interpolation import ( + InterpolationStrategyBase, + linear_interp_arrays, +) +from climada.trajectories.snapshot import Snapshot + +LOGGER = logging.getLogger(__name__) + +__all__ = [ + "CalcRiskMetricsPoints", + "CalcRiskMetricsPeriod", + "calc_per_date_aais", + "calc_per_date_eais", + "calc_per_date_rps", + "calc_freq_curve", +] + + +def lazy_property(method): + # This function is used as a decorator for properties + # that require "heavy" computation and are not always needed. + # When requested, if a property is none, it uses the corresponding + # computation method and caches the result in the corresponding + # private attribute + attr_name = f"_{method.__name__}" + + @property + def _lazy(self): + if getattr(self, attr_name) is None: + # LOGGER.debug( + # f"Computing {method.__name__} for {self._snapshot0.date}-{self._snapshot1.date} with {meas_n}." + # ) + setattr(self, attr_name, method(self)) + return getattr(self, attr_name) + + return _lazy + + +class CalcRiskMetricsPoints: + """This class handles the computation of impacts for a list of `Snapshot`. + + Note that most attribute like members are properties with their own docstring. + + Attributes + ---------- + + impact_computation_strategy: ImpactComputationStrategy, optional + The method used to calculate the impact from the (Haz,Exp,Vul) of the snapshots. + Defaults to ImpactCalc + measure: Measure, optional + The measure applied to snapshots. Defaults to None. + + Notes + ----- + + This class is intended for internal computation. + """ + + def __init__( + self, + snapshots: list[Snapshot], + impact_computation_strategy: ImpactComputationStrategy, + ) -> None: + """Initialize a new `CalcRiskMetricsPoints` + + This initializes and instantiate a new `CalcRiskMetricsPoints` object. + No computation is done at initialisation and only done "just in time". + + Parameters + ---------- + snapshots : List[Snapshot] + The `Snapshot` list to compute risk for. + impact_computation_strategy: ImpactComputationStrategy, optional + The method used to calculate the impact from the (Haz,Exp,Vul) of the two snapshots. + Defaults to ImpactCalc + + """ + + self._reset_impact_data() + self.snapshots = snapshots + self.impact_computation_strategy = impact_computation_strategy + self._date_idx = pd.DatetimeIndex( + [snap.date for snap in self.snapshots], name=DATE_COL_NAME + ) + self.measure = None + try: + self._group_id = np.unique( + np.concatenate( + [ + snap.exposure.gdf[GROUP_ID_COL_NAME] + for snap in self.snapshots + if GROUP_ID_COL_NAME in snap.exposure.gdf.columns + ] + ) + ) + except ValueError as e: + error_message = str(e).lower() + if "need at least one array to concatenate" in error_message: + self._group_id = np.array([]) + + def _reset_impact_data(self): + """Util method that resets computed data, for instance when changing the computation strategy.""" + self._impacts = None + self._eai_gdf = None + self._per_date_eai = None + self._per_date_aai = None + + @property + def impact_computation_strategy(self) -> ImpactComputationStrategy: + """The method used to calculate the impact from the (Haz,Exp,Vul) of the snapshots.""" + return self._impact_computation_strategy + + @impact_computation_strategy.setter + def impact_computation_strategy(self, value, /): + if not isinstance(value, ImpactComputationStrategy): + raise ValueError("Not an impact computation strategy") + + self._impact_computation_strategy = value + self._reset_impact_data() + + @lazy_property + def impacts(self) -> list[Impact]: + """Return Impact object for the different snapshots.""" + + return [ + self.impact_computation_strategy.compute_impacts( + snap.exposure, snap.hazard, snap.impfset + ) + for snap in self.snapshots + ] + + @lazy_property + def per_date_eai(self) -> np.ndarray: + """Expected annual impacts per snapshot.""" + + return np.array([imp.eai_exp for imp in self.impacts]) + + @lazy_property + def per_date_aai(self) -> np.ndarray: + """Average annual impacts per snapshot.""" + + return np.array([imp.aai_agg for imp in self.impacts]) + + @lazy_property + def eai_gdf(self) -> pd.DataFrame: + """Convenience function returning a DataFrame (with both datetime and coordinates) from `per_date_eai`. + + This can easily be merged with the GeoDataFrame of the exposure object of one of the `Snapshot`. + + Notes + ----- + + The DataFrame from the first snapshot of the list is used as a basis (notably for `value` and `group_id`). + """ + return self.calc_eai_gdf() + + def calc_eai_gdf(self) -> pd.DataFrame: + """Merge the per date EAIs of the risk period with the Dataframe of the exposure of the starting snapshot.""" + + df = pd.DataFrame(self.per_date_eai, index=self._date_idx) + df = df.reset_index().melt( + id_vars=DATE_COL_NAME, var_name=COORD_ID_COL_NAME, value_name=RISK_COL_NAME + ) + eai_gdf = pd.concat( + [ + snap.exposure.gdf.reset_index(names=[COORD_ID_COL_NAME]).assign( + date=pd.to_datetime(snap.date) + ) + for snap in self.snapshots + ] + ) + if GROUP_ID_COL_NAME in eai_gdf.columns: + eai_gdf = eai_gdf[[DATE_COL_NAME, COORD_ID_COL_NAME, GROUP_ID_COL_NAME]] + else: + eai_gdf[[GROUP_ID_COL_NAME]] = pd.NA + eai_gdf = eai_gdf[[DATE_COL_NAME, COORD_ID_COL_NAME, GROUP_ID_COL_NAME]] + + eai_gdf = eai_gdf.merge(df, on=[DATE_COL_NAME, COORD_ID_COL_NAME]) + eai_gdf = eai_gdf.rename(columns={GROUP_ID_COL_NAME: GROUP_COL_NAME}) + eai_gdf[GROUP_COL_NAME] = pd.Categorical( + eai_gdf[GROUP_COL_NAME], categories=self._group_id + ) + eai_gdf[METRIC_COL_NAME] = EAI_METRIC_NAME + eai_gdf[MEASURE_COL_NAME] = ( + self.measure.name if self.measure else NO_MEASURE_VALUE + ) + eai_gdf[UNIT_COL_NAME] = self.snapshots[0].exposure.value_unit + return eai_gdf + + def calc_aai_metric(self) -> pd.DataFrame: + """Compute a DataFrame of the AAI for each snapshot.""" + + aai_df = pd.DataFrame( + index=self._date_idx, columns=[RISK_COL_NAME], data=self.per_date_aai + ) + aai_df[GROUP_COL_NAME] = pd.Categorical( + [pd.NA] * len(aai_df), categories=self._group_id + ) + aai_df[METRIC_COL_NAME] = AAI_METRIC_NAME + aai_df[MEASURE_COL_NAME] = ( + self.measure.name if self.measure else NO_MEASURE_VALUE + ) + aai_df[UNIT_COL_NAME] = self.snapshots[0].exposure.value_unit + aai_df.reset_index(inplace=True) + return aai_df + + def calc_aai_per_group_metric(self) -> pd.DataFrame | None: + """Compute a DataFrame of the AAI distinguised per group id in the exposures, for each snapshot.""" + + if len(self._group_id) < 1: + LOGGER.warning( + "No group id defined in the Exposures object. Per group aai will be empty." + ) + return None + + eai_pres_groups = self.eai_gdf[ + [DATE_COL_NAME, COORD_ID_COL_NAME, GROUP_COL_NAME, RISK_COL_NAME] + ].copy() + aai_per_group_df = eai_pres_groups.groupby( + [DATE_COL_NAME, GROUP_COL_NAME], as_index=False, observed=True + )[RISK_COL_NAME].sum() + aai_per_group_df[METRIC_COL_NAME] = AAI_METRIC_NAME + aai_per_group_df[MEASURE_COL_NAME] = ( + self.measure.name if self.measure else NO_MEASURE_VALUE + ) + aai_per_group_df[UNIT_COL_NAME] = self.snapshots[0].exposure.value_unit + return aai_per_group_df + + def calc_return_periods_metric(self, return_periods: list[int]) -> pd.DataFrame: + """Compute a DataFrame of the estimated impacts for a list of return periods, for each snapshot. + + Parameters + ---------- + + return_periods : list of int + The return periods to estimate impacts for. + """ + + per_date_rp = np.array( + [ + imp.calc_freq_curve(return_per=return_periods).impact + for imp in self.impacts + ] + ) + rp_df = pd.DataFrame( + index=self._date_idx, columns=return_periods, data=per_date_rp + ).melt(value_name=RISK_COL_NAME, var_name="rp", ignore_index=False) + rp_df.reset_index(inplace=True) + rp_df[GROUP_COL_NAME] = pd.Categorical( + [pd.NA] * len(rp_df), categories=self._group_id + ) + rp_df[METRIC_COL_NAME] = RP_VALUE_PREFIX + "_" + rp_df["rp"].astype(str) + rp_df = rp_df.drop("rp", axis=1) + rp_df[MEASURE_COL_NAME] = ( + self.measure.name if self.measure else NO_MEASURE_VALUE + ) + rp_df[UNIT_COL_NAME] = self.snapshots[0].exposure.value_unit + return rp_df + + def apply_measure(self, measure: Measure) -> "CalcRiskMetricsPoints": + """Creates a new `CalcRiskMetricsPoints` object with a measure. + + The given measure is applied to both snapshot of the risk period. + + Parameters + ---------- + measure : Measure + The measure to apply. + + Returns + ------- + + CalcRiskPeriod + The risk period with given measure applied. + + """ + snapshots = [snap.apply_measure(measure) for snap in self.snapshots] + risk_period = CalcRiskMetricsPoints( + snapshots, + self.impact_computation_strategy, + ) + + risk_period.measure = measure + return risk_period + + +class CalcRiskMetricsPeriod: + """This class handles the computation of impacts for a risk period. + + This object handles the interpolations and computations of risk metrics in + between two given snapshots, along a DateTimeIndex build from either a + `time_resolution` (which must be a valid "freq" string to build a DateTimeIndex) + and defaults to "Y" (start of the year) or `time_points` integer argument, in which case + the DateTimeIndex will have that many periods. + + Note that most attribute like members are properties with their own docstring. + + Attributes + ---------- + + date_idx: pd.PeriodIndex + The date index for the different interpolated points between the two snapshots + interpolation_strategy: InterpolationStrategy, optional + The approach used to interpolate impact matrices in between the two snapshots, linear by default. + impact_computation_strategy: ImpactComputationStrategy, optional + The method used to calculate the impact from the (Haz,Exp,Vul) of the two snapshots. + Defaults to ImpactCalc + measure: Measure, optional + The measure to apply to both snapshots. Defaults to None. + + Notes + ----- + + This class is intended for internal computation. + """ + + def __init__( + self, + snapshot0: Snapshot, + snapshot1: Snapshot, + time_resolution: str, + interpolation_strategy: InterpolationStrategyBase, + impact_computation_strategy: ImpactComputationStrategy, + ): + """Initialize a new `CalcRiskMetricsPeriod` + + This initializes and instantiate a new `CalcRiskMetricsPeriod` object. + No computation is done at initialisation and only done "just in time". + + Parameters + ---------- + snapshot0 : Snapshot + The `Snapshot` at the start of the risk period. + snapshot1 : Snapshot + The `Snapshot` at the end of the risk period. + time_resolution : str, optional + One of pandas date offset strings or corresponding objects. See :func:`pandas.period_range`. + time_points : int, optional + Number of periods to generate for the PeriodIndex. + interpolation_strategy: InterpolationStrategy, optional + The approach used to interpolate impact matrices in between the two snapshots, linear by default. + impact_computation_strategy: ImpactComputationStrategy, optional + The method used to calculate the impact from the (Haz,Exp,Vul) of the two snapshots. + Defaults to ImpactCalc + + """ + + LOGGER.debug("Instantiating new CalcRiskPeriod.") + self._snapshot0 = snapshot0 + self._snapshot1 = snapshot1 + self.date_idx = self._set_date_idx( + date1=snapshot0.date, + date2=snapshot1.date, + freq=time_resolution, + name=DEFAULT_PERIOD_INDEX_NAME, + ) + self.interpolation_strategy = interpolation_strategy + self.impact_computation_strategy = impact_computation_strategy + self.measure = None # Only possible to set with apply_measure to make sure snapshots are consistent + + self._group_id_E0 = ( + np.array(self.snapshot_start.exposure.gdf[GROUP_ID_COL_NAME].values) + if GROUP_ID_COL_NAME in self.snapshot_start.exposure.gdf.columns + else np.array([]) + ) + self._group_id_E1 = ( + np.array(self.snapshot_end.exposure.gdf[GROUP_ID_COL_NAME].values) + if GROUP_ID_COL_NAME in self.snapshot_end.exposure.gdf.columns + else np.array([]) + ) + self._groups_id = np.unique( + np.concatenate([self._group_id_E0, self._group_id_E1]) + ) + + def _reset_impact_data(self): + """Util method that resets computed data, for instance when changing the time resolution.""" + for fut in list(itertools.product([0, 1], repeat=3)): + setattr(self, f"_E{fut[0]}H{fut[1]}V{fut[2]}", None) + + for fut in list(itertools.product([0, 1], repeat=2)): + setattr(self, f"_imp_mats_H{fut[0]}V{fut[1]}", None) + setattr(self, f"_per_date_eai_H{fut[0]}V{fut[1]}", None) + setattr(self, f"_per_date_aai_H{fut[0]}V{fut[1]}", None) + + self._eai_gdf = None + self._per_date_eai = None + self._per_date_aai = None + self._per_date_return_periods_H0, self._per_date_return_periods_H1 = None, None + + @staticmethod + def _set_date_idx( + date1: str | pd.Timestamp | datetime.date, + date2: str | pd.Timestamp | datetime.date, + freq: str | None = None, + name: str | None = None, + ) -> pd.PeriodIndex: + """Generate a date range index based on the provided parameters. + + Parameters + ---------- + date1 : str or pd.Timestamp or datetime.date + The start date of the period range. + date2 : str or pd.Timestamp or datetime.date + The end date of the period range. + freq : str, optional + Frequency string for the period range. + See `here `_. + name : str, optional + Name of the resulting period range index. + + Returns + ------- + pd.PeriodIndex + A PeriodIndex representing the date range. + + Raises + ------ + ValueError + If the number of periods and frequency given to period_range are inconsistent. + """ + ret = pd.period_range( + date1, + date2, + freq=freq, # type: ignore + name=name, + ) + return ret + + @property + def snapshot_start(self) -> Snapshot: + """The `Snapshot` at the start of the risk period.""" + return self._snapshot0 + + @property + def snapshot_end(self) -> Snapshot: + """The `Snapshot` at the end of the risk period.""" + return self._snapshot1 + + @property + def date_idx(self) -> pd.PeriodIndex: + """The pandas PeriodIndex representing the time dimension of the risk period.""" + return self._date_idx + + @date_idx.setter + def date_idx(self, value, /): + if not isinstance(value, pd.PeriodIndex): + raise ValueError("Not a PeriodIndex") + + self._date_idx = value # Avoids weird hourly data + self._time_points = len(self.date_idx) + self._time_resolution = self.date_idx.freq + self._reset_impact_data() + + @property + def time_points(self) -> int: + """The numbers of different time points (periods) in the risk period.""" + return self._time_points + + @property + def time_resolution(self) -> str: + """The time resolution of the risk periods, expressed as a pandas period frequency string.""" + return self._time_resolution # type: ignore + + @time_resolution.setter + def time_resolution(self, value, /): + self.date_idx = pd.period_range( + self.snapshot_start.date, + self.snapshot_end.date, + freq=value, + name=DEFAULT_PERIOD_INDEX_NAME, + ) + + @property + def interpolation_strategy(self) -> InterpolationStrategyBase: + """The approach used to interpolate impact matrices in between the two snapshots.""" + return self._interpolation_strategy + + @interpolation_strategy.setter + def interpolation_strategy(self, value, /): + if not isinstance(value, InterpolationStrategyBase): + raise ValueError("Not an interpolation strategy") + + self._interpolation_strategy = value + self._reset_impact_data() + + @property + def impact_computation_strategy(self) -> ImpactComputationStrategy: + """The method used to calculate the impact from the (Haz,Exp,Vul) of the two snapshots.""" + return self._impact_computation_strategy + + @impact_computation_strategy.setter + def impact_computation_strategy(self, value, /): + if not isinstance(value, ImpactComputationStrategy): + raise ValueError("Not an impact computation strategy") + + self._impact_computation_strategy = value + self._reset_impact_data() + + ##### Impact objects cube / Risk Cube ##### + + @lazy_property + def E0H0V0(self) -> Impact: + """Impact object corresponding to starting exposure, starting hazard and starting vulnerability.""" + return self.impact_computation_strategy.compute_impacts( + self.snapshot_start.exposure, + self.snapshot_start.hazard, + self.snapshot_start.impfset, + ) + + @lazy_property + def E1H0V0(self) -> Impact: + """Impact object corresponding to future exposure, starting hazard and starting vulnerability.""" + return self.impact_computation_strategy.compute_impacts( + self.snapshot_end.exposure, + self.snapshot_start.hazard, + self.snapshot_start.impfset, + ) + + @lazy_property + def E0H1V0(self) -> Impact: + """Impact object corresponding to starting exposure, future hazard and starting vulnerability.""" + return self.impact_computation_strategy.compute_impacts( + self.snapshot_start.exposure, + self.snapshot_end.hazard, + self.snapshot_start.impfset, + ) + + @lazy_property + def E1H1V0(self) -> Impact: + """Impact object corresponding to future exposure, future hazard and starting vulnerability.""" + return self.impact_computation_strategy.compute_impacts( + self.snapshot_end.exposure, + self.snapshot_end.hazard, + self.snapshot_start.impfset, + ) + + @lazy_property + def E0H0V1(self) -> Impact: + """Impact object corresponding to starting exposure, starting hazard and future vulnerability.""" + return self.impact_computation_strategy.compute_impacts( + self.snapshot_start.exposure, + self.snapshot_start.hazard, + self.snapshot_end.impfset, + ) + + @lazy_property + def E1H0V1(self) -> Impact: + """Impact object corresponding to future exposure, starting hazard and future vulnerability.""" + return self.impact_computation_strategy.compute_impacts( + self.snapshot_end.exposure, + self.snapshot_start.hazard, + self.snapshot_end.impfset, + ) + + @lazy_property + def E0H1V1(self) -> Impact: + """Impact object corresponding to starting exposure, future hazard and future vulnerability.""" + return self.impact_computation_strategy.compute_impacts( + self.snapshot_start.exposure, + self.snapshot_end.hazard, + self.snapshot_end.impfset, + ) + + @lazy_property + def E1H1V1(self) -> Impact: + """Impact object corresponding to future exposure, future hazard and future vulnerability.""" + return self.impact_computation_strategy.compute_impacts( + self.snapshot_end.exposure, + self.snapshot_end.hazard, + self.snapshot_end.impfset, + ) + + ############################### + + ### Impact Matrices arrays #### + + def _interp_mats(self, start_attr, end_attr) -> list: + """Helper to reduce repetition in impact matrix interpolation.""" + start = getattr(self, start_attr).imp_mat + end = getattr(self, end_attr).imp_mat + return self.interpolation_strategy.interp_over_exposure_dim( + start, end, self.time_points + ) + + @property + def imp_mats_H0V0(self) -> list: + """List of `time_points` impact matrices with changing exposure, starting hazard and starting vulnerability.""" + return self._interp_mats("E0H0V0", "E1H0V0") + + @property + def imp_mats_H1V0(self) -> list: + """List of `time_points` impact matrices with changing exposure, future hazard and starting vulnerability.""" + return self._interp_mats("E0H1V0", "E1H1V0") + + @property + def imp_mats_H0V1(self) -> list: + """List of `time_points` impact matrices with changing exposure, starting hazard and future vulnerability.""" + return self._interp_mats("E0H0V1", "E1H0V1") + + @property + def imp_mats_H1V1(self) -> list: + """List of `time_points` impact matrices with changing exposure, future hazard and future vulnerability.""" + return self._interp_mats("E0H1V1", "E1H1V1") + + @property + def imp_mats_E0H0V0(self) -> list: + """List of `time_points` impact matrices with base exposure, base hazard and base vulnerability.""" + return self._interp_mats("E0H0V0", "E0H0V0") + + @property + def imp_mats_E0H1V0(self) -> list: + """List of `time_points` impact matrices with base exposure, future hazard and base vulnerability.""" + return self._interp_mats("E0H1V0", "E0H1V0") + + @property + def imp_mats_E0H0V1(self) -> list: + """List of `time_points` impact matrices with base exposure, base hazard and base vulnerability.""" + return self._interp_mats("E0H0V1", "E0H0V1") + + ############################### + + ########## Core EAI ########### + + @property + def per_date_eai_H0V0(self) -> np.ndarray: + """Expected annual impacts for changing exposure, starting hazard and starting vulnerability.""" + return calc_per_date_eais( + self.imp_mats_H0V0, self.snapshot_start.hazard.frequency + ) + + @property + def per_date_eai_H1V0(self) -> np.ndarray: + """Expected annual impacts for changing exposure, future hazard and starting vulnerability.""" + return calc_per_date_eais( + self.imp_mats_H1V0, self.snapshot_end.hazard.frequency + ) + + @property + def per_date_eai_H0V1(self) -> np.ndarray: + """Expected annual impacts for changing exposure, starting hazard and future vulnerability.""" + return calc_per_date_eais( + self.imp_mats_H0V1, self.snapshot_start.hazard.frequency + ) + + @property + def per_date_eai_H1V1(self) -> np.ndarray: + """Expected annual impacts for changing exposure, future hazard and future vulnerability.""" + return calc_per_date_eais( + self.imp_mats_H1V1, self.snapshot_end.hazard.frequency + ) + + @property + def per_date_eai_E0H0V0(self) -> np.ndarray: + """Expected annual impacts for base exposure, base hazard and base vulnerability.""" + return calc_per_date_eais( + self.imp_mats_E0H0V0, self.snapshot_start.hazard.frequency + ) + + @property + def per_date_eai_E0H1V0(self) -> np.ndarray: + """Expected annual impacts for base exposure, future hazard and base vulnerability.""" + return calc_per_date_eais( + self.imp_mats_E0H1V0, self.snapshot_end.hazard.frequency + ) + + @property + def per_date_eai_E0H0V1(self) -> np.ndarray: + """Expected annual impacts for base exposure, future hazard and base vulnerability.""" + return calc_per_date_eais( + self.imp_mats_E0H0V1, self.snapshot_start.hazard.frequency + ) + + ################################## + + ######### Core AAIs ########## + + @property + def per_date_aai_H0V0(self) -> np.ndarray: + """Average annual impacts for changing exposure, starting hazard and starting vulnerability.""" + return calc_per_date_aais(self.per_date_eai_H0V0) + + @property + def per_date_aai_H1V0(self) -> np.ndarray: + """Average annual impacts for changing exposure, future hazard and starting vulnerability.""" + return calc_per_date_aais(self.per_date_eai_H1V0) + + @property + def per_date_aai_H0V1(self) -> np.ndarray: + """Average annual impacts for changing exposure, starting hazard and future vulnerability.""" + return calc_per_date_aais(self.per_date_eai_H0V1) + + @property + def per_date_aai_H1V1(self) -> np.ndarray: + """Average annual impacts for changing exposure, future hazard and future vulnerability.""" + return calc_per_date_aais(self.per_date_eai_H1V1) + + @property + def per_date_aai_E0H0V0(self) -> np.ndarray: + """Average annual impacts for base exposure, base hazard and base vulnerability.""" + return calc_per_date_aais(self.per_date_eai_E0H0V0) + + @property + def per_date_aai_E0H1V0(self) -> np.ndarray: + """Average annual impacts for base exposure, base hazard and base vulnerability.""" + return calc_per_date_aais(self.per_date_eai_E0H1V0) + + @property + def per_date_aai_E0H0V1(self) -> np.ndarray: + """Average annual impacts for base exposure, base hazard and base vulnerability.""" + return calc_per_date_aais(self.per_date_eai_E0H0V1) + + ################################# + + ######### Core RPs ######### + + def per_date_return_periods_H0V0(self, return_periods: list[int]) -> np.ndarray: + """Estimated impacts per dates for given return periods, with changing exposure, starting hazard and starting vulnerability.""" + return calc_per_date_rps( + self.imp_mats_H0V0, + self.snapshot_start.hazard.frequency, + self.date_idx.freqstr[0], + return_periods, + ) + + def per_date_return_periods_H1V0(self, return_periods: list[int]) -> np.ndarray: + """Estimated impacts per dates for given return periods, with changing exposure, future hazard and starting vulnerability.""" + return calc_per_date_rps( + self.imp_mats_H1V0, + self.snapshot_end.hazard.frequency, + self.date_idx.freqstr[0], + return_periods, + ) + + def per_date_return_periods_H0V1(self, return_periods: list[int]) -> np.ndarray: + """Estimated impacts per dates for given return periods, with changing exposure, starting hazard and future vulnerability.""" + return calc_per_date_rps( + self.imp_mats_H0V1, + self.snapshot_start.hazard.frequency, + self.date_idx.freqstr[0], + return_periods, + ) + + def per_date_return_periods_H1V1(self, return_periods: list[int]) -> np.ndarray: + """Estimated impacts per dates for given return periods, with changing exposure, future hazard and future vulnerability.""" + return calc_per_date_rps( + self.imp_mats_H1V1, + self.snapshot_end.hazard.frequency, + self.date_idx.freqstr[0], + return_periods, + ) + + ################################## + + ##### Interpolation of metrics ##### + + def calc_eai(self) -> np.ndarray: + """Compute the EAIs at each date of the risk period (including changes in exposure, hazard and vulnerability).""" + per_date_eai_H0V0, per_date_eai_H1V0, per_date_eai_H0V1, per_date_eai_H1V1 = ( + self.per_date_eai_H0V0, + self.per_date_eai_H1V0, + self.per_date_eai_H0V1, + self.per_date_eai_H1V1, + ) + per_date_eai_V0 = self.interpolation_strategy.interp_over_hazard_dim( + per_date_eai_H0V0, per_date_eai_H1V0 + ) + per_date_eai_V1 = self.interpolation_strategy.interp_over_hazard_dim( + per_date_eai_H0V1, per_date_eai_H1V1 + ) + per_date_eai = self.interpolation_strategy.interp_over_vulnerability_dim( + per_date_eai_V0, per_date_eai_V1 + ) + return per_date_eai + + ### Fully interpolated metrics ### + + @lazy_property + def per_date_eai(self) -> np.ndarray: + """Expected annual impacts per date with changing exposure, changing hazard and changing vulnerability""" + return self.calc_eai() + + @lazy_property + def per_date_aai(self) -> np.ndarray: + """Average annual impacts per date with changing exposure, changing hazard and changing vulnerability.""" + return calc_per_date_aais(self.per_date_eai) + + @lazy_property + def eai_gdf(self) -> pd.DataFrame: + """Convenience function returning a DataFrame (with both datetime and coordinates ids) from `per_date_eai`. + + This dataframe can easily be merged with one of the snapshot exposure geodataframe. + + Notes + ----- + + The DataFrame from the starting snapshot is used as a basis (notably for `value` and `group_id`). + + """ + return self.calc_eai_gdf() + + #################################### + + ### Metrics from impact matrices ### + + # These methods might go in a utils file instead, to be reused + # for a no interpolation case (and maybe the timeseries?) + + #################################### + + def calc_eai_gdf(self) -> pd.DataFrame: + """Merge the per date EAIs of the risk period with the GeoDataframe of the exposure of the starting snapshot.""" + df = pd.DataFrame(self.per_date_eai, index=self.date_idx) + df = df.reset_index().melt( + id_vars=DEFAULT_PERIOD_INDEX_NAME, + var_name=COORD_ID_COL_NAME, + value_name=RISK_COL_NAME, + ) + if GROUP_ID_COL_NAME in self.snapshot_start.exposure.gdf: + eai_gdf = self.snapshot_start.exposure.gdf[[GROUP_ID_COL_NAME]] + eai_gdf[COORD_ID_COL_NAME] = eai_gdf.index + eai_gdf = eai_gdf.merge(df, on=COORD_ID_COL_NAME) + eai_gdf = eai_gdf.rename(columns={GROUP_ID_COL_NAME: GROUP_COL_NAME}) + else: + eai_gdf = df + eai_gdf[GROUP_COL_NAME] = pd.NA + + eai_gdf[GROUP_COL_NAME] = pd.Categorical( + eai_gdf[GROUP_COL_NAME], categories=self._groups_id + ) + eai_gdf[METRIC_COL_NAME] = EAI_METRIC_NAME + eai_gdf[MEASURE_COL_NAME] = ( + self.measure.name if self.measure else NO_MEASURE_VALUE + ) + eai_gdf[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit + return eai_gdf + + def calc_aai_metric(self) -> pd.DataFrame: + """Compute a DataFrame of the AAI at each dates of the risk period (including changes in exposure, hazard and vulnerability).""" + aai_df = pd.DataFrame( + index=self.date_idx, columns=[RISK_COL_NAME], data=self.per_date_aai + ) + aai_df[GROUP_COL_NAME] = pd.Categorical( + [pd.NA] * len(aai_df), categories=self._groups_id + ) + aai_df[METRIC_COL_NAME] = AAI_METRIC_NAME + aai_df[MEASURE_COL_NAME] = ( + self.measure.name if self.measure else NO_MEASURE_VALUE + ) + aai_df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit + aai_df.reset_index(inplace=True) + return aai_df + + def calc_aai_per_group_metric(self) -> pd.DataFrame | None: + """Compute a DataFrame of the AAI distinguised per group id in the exposures, at each dates of the risk period (including changes in exposure, hazard and vulnerability). + + Notes + ----- + + If group ids changes between starting and ending snapshots of the risk period, the AAIs are linearly interpolated (with a warning for transparency). + + """ + if len(self._group_id_E0) < 1 or len(self._group_id_E1) < 1: + LOGGER.warning( + "No group id defined in at least one of the Exposures object. Per group aai will be empty." + ) + return None + + eai_pres_groups = self.eai_gdf[ + [ + DEFAULT_PERIOD_INDEX_NAME, + COORD_ID_COL_NAME, + GROUP_COL_NAME, + RISK_COL_NAME, + ] + ].copy() + aai_per_group_df = eai_pres_groups.groupby( + [DEFAULT_PERIOD_INDEX_NAME, GROUP_COL_NAME], as_index=False, observed=True + )[RISK_COL_NAME].sum() + if not np.array_equal(self._group_id_E0, self._group_id_E1): + LOGGER.warning( + "Group id are changing between present and future snapshot. Per group AAI will be linearly interpolated." + ) + eai_fut_groups = self.eai_gdf.copy() + eai_fut_groups[GROUP_COL_NAME] = pd.Categorical( + np.tile(self._group_id_E1, len(self.date_idx)), + categories=self._groups_id, + ) + aai_fut_groups = eai_fut_groups.groupby( + [DEFAULT_PERIOD_INDEX_NAME, GROUP_COL_NAME], as_index=False + )[RISK_COL_NAME].sum() + aai_per_group_df[RISK_COL_NAME] = linear_interp_arrays( + aai_per_group_df[RISK_COL_NAME].values, + aai_fut_groups[RISK_COL_NAME].values, + ) + + aai_per_group_df[METRIC_COL_NAME] = AAI_METRIC_NAME + aai_per_group_df[MEASURE_COL_NAME] = ( + self.measure.name if self.measure else NO_MEASURE_VALUE + ) + aai_per_group_df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit + return aai_per_group_df + + def calc_return_periods_metric(self, return_periods: list[int]) -> pd.DataFrame: + """Compute a DataFrame of the estimated impacts for a list of return + periods, at each dates of the risk period (including changes in exposure, + hazard and vulnerability). + + Parameters + ---------- + + return_periods : list of int + The return periods to estimate impacts for. + + """ + + # currently mathematicaly wrong, but approximatively correct, to be reworked when concatenating the impact matrices for the interpolation + per_date_rp_H0V0, per_date_rp_H1V0, per_date_rp_H0V1, per_date_rp_H1V1 = ( + self.per_date_return_periods_H0V0(return_periods), + self.per_date_return_periods_H1V0(return_periods), + self.per_date_return_periods_H0V1(return_periods), + self.per_date_return_periods_H1V1(return_periods), + ) + per_date_rp_V0 = self.interpolation_strategy.interp_over_hazard_dim( + per_date_rp_H0V0, per_date_rp_H1V0 + ) + per_date_rp_V1 = self.interpolation_strategy.interp_over_hazard_dim( + per_date_rp_H0V1, per_date_rp_H1V1 + ) + per_date_rp = self.interpolation_strategy.interp_over_vulnerability_dim( + per_date_rp_V0, per_date_rp_V1 + ) + rp_df = pd.DataFrame( + index=self.date_idx, columns=return_periods, data=per_date_rp + ).melt(value_name=RISK_COL_NAME, var_name="rp", ignore_index=False) + rp_df.reset_index(inplace=True) + rp_df[GROUP_COL_NAME] = pd.Categorical( + [pd.NA] * len(rp_df), categories=self._groups_id + ) + rp_df[METRIC_COL_NAME] = RP_VALUE_PREFIX + "_" + rp_df["rp"].astype(str) + rp_df = rp_df.drop("rp", axis=1) + rp_df[MEASURE_COL_NAME] = ( + self.measure.name if self.measure else NO_MEASURE_VALUE + ) + rp_df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit + return rp_df + + def calc_risk_contributions_metric(self) -> pd.DataFrame: + """Compute a DataFrame of the individual contributions of risk (impact), + at each dates of the risk period (including changes in exposure, + hazard and vulnerability). + + """ + per_date_aai_E0V0 = self.interpolation_strategy.interp_over_hazard_dim( + self.per_date_aai_E0H0V0, self.per_date_aai_E0H1V0 + ) + per_date_aai_E0H0 = self.interpolation_strategy.interp_over_vulnerability_dim( + self.per_date_aai_E0H0V0, self.per_date_aai_E0H0V1 + ) + df = pd.DataFrame( + { + CONTRIBUTION_TOTAL_RISK_NAME: self.per_date_aai, + CONTRIBUTION_BASE_RISK_NAME: self.per_date_aai[0], + CONTRIBUTION_EXPOSURE_NAME: self.per_date_aai_H0V0 + - self.per_date_aai[0], + CONTRIBUTION_HAZARD_NAME: per_date_aai_E0V0 + # - (self.per_date_aai_H0V0 - self.per_date_aai[0]) + - self.per_date_aai[0], + CONTRIBUTION_VULNERABILITY_NAME: per_date_aai_E0H0 + - self.per_date_aai[0], + # - (self.per_date_aai_H0V0 - self.per_date_aai[0]), + }, + index=self.date_idx, + ) + df[CONTRIBUTION_INTERACTION_TERM_NAME] = df[CONTRIBUTION_TOTAL_RISK_NAME] - ( + df[CONTRIBUTION_BASE_RISK_NAME] + + df[CONTRIBUTION_EXPOSURE_NAME] + + df[CONTRIBUTION_HAZARD_NAME] + + df[CONTRIBUTION_VULNERABILITY_NAME] + ) + df = df.melt( + value_vars=[ + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + ], + var_name=METRIC_COL_NAME, + value_name=RISK_COL_NAME, + ignore_index=False, + ) + df.reset_index(inplace=True) + df[GROUP_COL_NAME] = pd.Categorical( + [pd.NA] * len(df), categories=self._groups_id + ) + df[MEASURE_COL_NAME] = self.measure.name if self.measure else NO_MEASURE_VALUE + df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit + return df + + def apply_measure(self, measure: Measure) -> "CalcRiskMetricsPeriod": + """Creates a new `CalcRiskMetricsPeriod` object with a measure. + + The given measure is applied to both snapshot of the risk period. + + Parameters + ---------- + measure : Measure + The measure to apply. + + Returns + ------- + + CalcRiskPeriod + The risk period with given measure applied. + + """ + snap0 = self.snapshot_start.apply_measure(measure) + snap1 = self.snapshot_end.apply_measure(measure) + + risk_period = CalcRiskMetricsPeriod( + snap0, + snap1, + self.time_resolution, + self.interpolation_strategy, + self.impact_computation_strategy, + ) + + risk_period.measure = measure + return risk_period + + +def calc_per_date_eais(imp_mats: list[csr_matrix], frequency: np.ndarray) -> np.ndarray: + """Calculate expected average impact (EAI) values from a list of impact matrices + corresponding to impacts at different dates (with possible changes along + exposure, hazard and vulnerability). + + Parameters + ---------- + imp_mats : list of np.ndarray + List of impact matrices. + frequency : np.ndarray + Hazard frequency values. + + Returns + ------- + np.ndarray + 2D array of EAI (1D) for each dates. + + """ + per_date_eai_exp = np.array( + [ImpactCalc.eai_exp_from_mat(imp_mat, frequency) for imp_mat in imp_mats] + ) + return per_date_eai_exp + + +def calc_per_date_aais(per_date_eai_exp: np.ndarray) -> np.ndarray: + """Calculate per_date aggregate annual impact (AAI) values + resulting from a list arrays corresponding to EAI at different + dates (with possible changes along exposure, hazard and vulnerability). + + Parameters + ---------- + per_date_eai_exp: np.ndarray + EAIs arrays. + + Returns + ------- + np.ndarray + 1D array of AAI (0D) for each dates. + """ + per_date_aai = np.array( + [ImpactCalc.aai_agg_from_eai_exp(eai_exp) for eai_exp in per_date_eai_exp] + ) + return per_date_aai + + +def calc_per_date_rps( + imp_mats: list[csr_matrix], + frequency: np.ndarray, + frequency_unit: str, + return_periods: list[int], +) -> np.ndarray: + """Calculate per date return period impact values from a + list of impact matrices corresponding to impacts at different + dates (with possible changes along exposure, hazard and vulnerability). + + Parameters + ---------- + imp_mats: list of scipy.crs_matrix + List of impact matrices. + frequency: np.ndarray + Frequency values. + return_periods : list of int + Return periods to calculate impact values for. + + Returns + ------- + np.ndarray + 2D array of impacts per return periods (1D) for each dates. + + """ + rp = np.array( + [ + calc_freq_curve(imp_mat, frequency, frequency_unit, return_periods).impact + for imp_mat in imp_mats + ] + ) + return rp + + +def calc_freq_curve( + imp_mat_intrpl, frequency, frequency_unit, return_per=None +) -> ImpactFreqCurve: + """Calculate the estimated impacts for given return periods. + + Parameters + ---------- + + imp_mat_intrpl: scipy.csr_matrix + An impact matrix. + frequency: np.ndarray + The frequency of the hazard. + return_per: np.ndarray + The return periods to compute impacts for. + + Returns + ------- + np.ndarray + The estimated impacts for the different return periods. + + """ + + at_event = np.sum(imp_mat_intrpl, axis=1).A1 + + # Sort descendingly the impacts per events + sort_idxs = np.argsort(at_event)[::-1] + # Calculate exceedence frequency + exceed_freq = np.cumsum(frequency[sort_idxs]) + # Set return period and impact exceeding frequency + ifc_return_per = 1 / exceed_freq[::-1] + ifc_impact = at_event[sort_idxs][::-1] + + if return_per is not None: + interp_imp = np.interp(return_per, ifc_return_per, ifc_impact) + ifc_return_per = return_per + ifc_impact = interp_imp + + return ImpactFreqCurve( + return_per=ifc_return_per, + impact=ifc_impact, + frequency_unit=frequency_unit, + label="Exceedance frequency curve", + ) diff --git a/climada/trajectories/constants.py b/climada/trajectories/constants.py new file mode 100644 index 0000000000..c315f17761 --- /dev/null +++ b/climada/trajectories/constants.py @@ -0,0 +1,55 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +Define constants for trajectories module. +""" + +DEFAULT_TIME_RESOLUTION = "Y" +DATE_COL_NAME = "date" +PERIOD_COL_NAME = "period" +GROUP_COL_NAME = "group" +GROUP_ID_COL_NAME = "group_id" +MEASURE_COL_NAME = "measure" +NO_MEASURE_VALUE = "no_measure" +METRIC_COL_NAME = "metric" +UNIT_COL_NAME = "unit" +RISK_COL_NAME = "risk" +COORD_ID_COL_NAME = "coord_id" + +DEFAULT_PERIOD_INDEX_NAME = "date" + +DEFAULT_RP = [20, 50, 100] +"""Default return periods to use when computing return period impact estimates.""" + +DEFAULT_ALLGROUP_NAME = "All" +"""Default string to use to define the exposure subgroup containing all exposure points.""" + +EAI_METRIC_NAME = "eai" +AAI_METRIC_NAME = "aai" +AAI_PER_GROUP_METRIC_NAME = "aai_per_group" +CONTRIBUTIONS_METRIC_NAME = "risk_contributions" +RETURN_PERIOD_METRIC_NAME = "return_periods" +RP_VALUE_PREFIX = "rp" + + +CONTRIBUTION_BASE_RISK_NAME = "base risk" +CONTRIBUTION_TOTAL_RISK_NAME = "total risk" +CONTRIBUTION_EXPOSURE_NAME = "exposure contribution" +CONTRIBUTION_HAZARD_NAME = "hazard contribution" +CONTRIBUTION_VULNERABILITY_NAME = "vulnerability contribution" +CONTRIBUTION_INTERACTION_TERM_NAME = "interaction contribution" diff --git a/climada/trajectories/test/test_riskperiod.py b/climada/trajectories/test/test_riskperiod.py new file mode 100644 index 0000000000..8ae328109d --- /dev/null +++ b/climada/trajectories/test/test_riskperiod.py @@ -0,0 +1,1389 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +This modules implements different sparce matrices interpolation approaches. + +""" + +import types +import unittest +from unittest.mock import MagicMock, call, patch + +import geopandas as gpd +import numpy as np +import pandas as pd +from scipy.sparse import csr_matrix, issparse +from shapely import Point + +# Assuming these are the necessary imports from climada +from climada.entity.exposures import Exposures +from climada.entity.impact_funcs import ImpactFuncSet +from climada.entity.impact_funcs.trop_cyclone import ImpfTropCyclone +from climada.entity.measures.base import Measure +from climada.hazard import Hazard +from climada.trajectories.constants import ( + AAI_METRIC_NAME, + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + COORD_ID_COL_NAME, + DATE_COL_NAME, + EAI_METRIC_NAME, + GROUP_COL_NAME, + GROUP_ID_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + NO_MEASURE_VALUE, + RISK_COL_NAME, + UNIT_COL_NAME, +) + +# Import the CalcRiskPeriod class and other necessary classes/functions +from climada.trajectories.impact_calc_strat import ( + ImpactCalcComputation, + ImpactComputationStrategy, +) +from climada.trajectories.interpolation import ( + AllLinearStrategy, + InterpolationStrategyBase, +) +from climada.trajectories.riskperiod import ( + CalcRiskMetricsPeriod, + CalcRiskMetricsPoints, + calc_freq_curve, + calc_per_date_aais, + calc_per_date_eais, + calc_per_date_rps, +) +from climada.trajectories.snapshot import Snapshot +from climada.util.constants import EXP_DEMO_H5, HAZ_DEMO_H5 + + +class TestCalcRiskMetricsPoints(unittest.TestCase): + def setUp(self): + # Create mock objects for testing + self.present_date = 2020 + self.future_date = 2025 + self.exposure_present = Exposures.from_hdf5(EXP_DEMO_H5) + self.exposure_present.gdf.rename(columns={"impf_": "impf_TC"}, inplace=True) + self.exposure_present.gdf["impf_TC"] = 1 + self.exposure_present.gdf[GROUP_ID_COL_NAME] = ( + self.exposure_present.gdf["value"] + > self.exposure_present.gdf["value"].mean() + ) * 1 + self.hazard_present = Hazard.from_hdf5(HAZ_DEMO_H5) + self.exposure_present.assign_centroids(self.hazard_present, distance="approx") + self.impfset_present = ImpactFuncSet([ImpfTropCyclone.from_emanuel_usa()]) + + self.exposure_future = Exposures.from_hdf5(EXP_DEMO_H5) + n_years = self.future_date - self.present_date + 1 + growth_rate = 1.02 + growth = growth_rate**n_years + self.exposure_future.gdf["value"] = self.exposure_future.gdf["value"] * growth + self.exposure_future.gdf.rename(columns={"impf_": "impf_TC"}, inplace=True) + self.exposure_future.gdf["impf_TC"] = 1 + self.exposure_future.gdf[GROUP_ID_COL_NAME] = ( + self.exposure_future.gdf["value"] > self.exposure_future.gdf["value"].mean() + ) * 1 + self.hazard_future = Hazard.from_hdf5(HAZ_DEMO_H5) + self.hazard_future.intensity *= 1.1 + self.exposure_future.assign_centroids(self.hazard_future, distance="approx") + self.impfset_future = ImpactFuncSet( + [ + ImpfTropCyclone.from_emanuel_usa(impf_id=1, v_half=60.0), + ] + ) + + self.measure = MagicMock(spec=Measure) + self.measure.name = "Test Measure" + + # Setup mock return values for measure.apply + self.measure_exposure = MagicMock(spec=Exposures) + self.measure_hazard = MagicMock(spec=Hazard) + self.measure_impfset = MagicMock(spec=ImpactFuncSet) + self.measure.apply.return_value = ( + self.measure_exposure, + self.measure_impfset, + self.measure_hazard, + ) + + # Create mock snapshots + self.mock_snapshot_start = Snapshot( + exposure=self.exposure_present, + hazard=self.hazard_present, + impfset=self.impfset_present, + date=self.present_date, + ) + self.mock_snapshot_end = Snapshot( + exposure=self.exposure_future, + hazard=self.hazard_future, + impfset=self.impfset_future, + date=self.future_date, + ) + + # Create an instance of CalcRiskPeriod + self.calc_risk_metrics_points = CalcRiskMetricsPoints( + [self.mock_snapshot_start, self.mock_snapshot_end], + impact_computation_strategy=ImpactCalcComputation(), + ) + + self.expected_eai = np.array( + [ + [ + 8702904.63375606, + 7870925.19290905, + 1805021.12653289, + 3827196.02428828, + 5815346.97427834, + 7870925.19290905, + 7871847.53906951, + 7870925.19290905, + 7886487.76136572, + 7870925.19290905, + 7876058.84500811, + 3858228.67061225, + 8401461.85304853, + 9210350.19520265, + 1806363.23553602, + 6922250.59852326, + 6711006.70101515, + 6886568.00391817, + 6703749.80009753, + 6704689.17531993, + 6703401.93516038, + 6818839.81873556, + 6716262.5286998, + 6703369.87656195, + 6703952.06070945, + 5678897.05935781, + 4984034.77073219, + 6708908.84462217, + 6702586.9472999, + 4961843.43826371, + 5139913.92380089, + 5255310.96072403, + 4981705.85074492, + 4926529.74583162, + 4973726.6063121, + 4926015.68274236, + 4937618.79350358, + 4926144.19851468, + 4926015.68274236, + 9575288.06765627, + 5100904.22956578, + 3501325.10900064, + 5093920.89144773, + 3505527.05928994, + 4002552.92232482, + 3512012.80001039, + 3514993.26161994, + 3562009.79687436, + 3869298.39771648, + 3509317.94922485, + ], + [ + 46651387.10647343, + 42191612.28496882, + 14767621.68800634, + 24849532.38841432, + 32260334.11128166, + 42191612.28496882, + 42196556.46505447, + 42191612.28496882, + 42275034.47974126, + 42191612.28496882, + 42219130.91253302, + 24227735.90988531, + 45035521.54835925, + 49371517.94999501, + 14778602.03484606, + 39909758.65668079, + 38691846.52720026, + 39834520.43061425, + 38650007.36519716, + 38655423.2682883, + 38648001.77388126, + 39313550.93419428, + 38722148.63941796, + 38647816.9422419, + 38651173.48481285, + 33700748.42359267, + 30195870.8789255, + 38679751.48077733, + 38643303.01755095, + 30061424.26274527, + 31140267.73715352, + 31839402.91317674, + 30181761.07222111, + 29847475.57538872, + 30133418.66577969, + 29844361.11423809, + 29914658.78479145, + 29845139.72952577, + 29844361.11423809, + 58012067.61585025, + 30903926.75151934, + 23061159.87895984, + 33550647.3781805, + 23088835.64296583, + 26362451.35547444, + 23131553.38525813, + 23151183.92499699, + 23460854.06493051, + 24271571.95828693, + 23113803.99527559, + ], + ] + ) + + self.expected_aai = np.array([2.88895461e08, 1.69310367e09]) + self.expected_aai_per_group = np.array( + [2.33513758e08, 5.53817034e07, 1.37114041e09, 3.21963264e08] + ) + self.expected_return_period_metric = np.array( + [ + 0.00000000e00, + 0.00000000e00, + 7.10925472e09, + 4.53975437e10, + 1.36547014e10, + 7.69981714e10, + ] + ) + + def test_reset_impact_data(self): + self.calc_risk_metrics_points._impacts = "A" # type:ignore + self.calc_risk_metrics_points._eai_gdf = "B" # type:ignore + self.calc_risk_metrics_points._per_date_eai = "C" # type:ignore + self.calc_risk_metrics_points._per_date_aai = "D" # type:ignore + self.calc_risk_metrics_points._reset_impact_data() + self.assertIsNone(self.calc_risk_metrics_points._impacts) + self.assertIsNone(self.calc_risk_metrics_points._eai_gdf) + self.assertIsNone(self.calc_risk_metrics_points._per_date_aai) + self.assertIsNone(self.calc_risk_metrics_points._per_date_eai) + + def test_set_impact_computation_strategy(self): + new_impact_computation_strategy = MagicMock(spec=ImpactComputationStrategy) + self.calc_risk_metrics_points.impact_computation_strategy = ( + new_impact_computation_strategy + ) + self.assertEqual( + self.calc_risk_metrics_points.impact_computation_strategy, + new_impact_computation_strategy, + ) + + def test_set_impact_computation_strategy_wtype(self): + with self.assertRaises(ValueError): + self.calc_risk_metrics_points.impact_computation_strategy = "A" + + @patch.object(CalcRiskMetricsPoints, "impact_computation_strategy") + def test_impacts_arrays(self, mock_impact_compute): + mock_impact_compute.compute_impacts.side_effect = ["A", "B"] + results = self.calc_risk_metrics_points.impacts + mock_impact_compute.compute_impacts.assert_has_calls( + [ + call( + self.mock_snapshot_start.exposure, + self.mock_snapshot_start.hazard, + self.mock_snapshot_start.impfset, + ), + call( + self.mock_snapshot_end.exposure, + self.mock_snapshot_end.hazard, + self.mock_snapshot_end.impfset, + ), + ] + ) + self.assertEqual(results, ["A", "B"]) + + def test_per_date_eai(self): + np.testing.assert_allclose( + self.calc_risk_metrics_points.per_date_eai, self.expected_eai + ) + + def test_per_date_aai(self): + np.testing.assert_allclose( + self.calc_risk_metrics_points.per_date_aai, + self.expected_aai, + ) + + def test_eai_gdf(self): + result_gdf = self.calc_risk_metrics_points.calc_eai_gdf() + self.assertIsInstance(result_gdf, pd.DataFrame) + self.assertEqual( + result_gdf.shape[0], + len(self.mock_snapshot_start.exposure.gdf) + + len(self.mock_snapshot_end.exposure.gdf), + ) + expected_columns = [ + DATE_COL_NAME, + COORD_ID_COL_NAME, + GROUP_COL_NAME, + RISK_COL_NAME, + METRIC_COL_NAME, + MEASURE_COL_NAME, + UNIT_COL_NAME, + ] + self.assertTrue( + all(col in list(result_gdf.columns) for col in expected_columns) + ) + np.testing.assert_allclose( + np.array(result_gdf[RISK_COL_NAME].values), self.expected_eai.flatten() + ) + # Check constants and column transformations + self.assertEqual(result_gdf[METRIC_COL_NAME].unique(), EAI_METRIC_NAME) + self.assertEqual(result_gdf[MEASURE_COL_NAME].iloc[0], NO_MEASURE_VALUE) + self.assertEqual( + result_gdf[UNIT_COL_NAME].iloc[0], + self.mock_snapshot_start.exposure.value_unit, + ) + self.assertEqual(result_gdf[GROUP_COL_NAME].dtype.name, "category") + self.assertListEqual( + list(result_gdf[GROUP_COL_NAME].cat.categories), + list(self.calc_risk_metrics_points._group_id), + ) + + def test_calc_aai_metric(self): + result_df = self.calc_risk_metrics_points.calc_aai_metric() + self.assertIsInstance(result_df, pd.DataFrame) + self.assertEqual( + result_df.shape[0], len(self.calc_risk_metrics_points.snapshots) + ) + expected_columns = [ + DATE_COL_NAME, + GROUP_COL_NAME, + RISK_COL_NAME, + METRIC_COL_NAME, + MEASURE_COL_NAME, + UNIT_COL_NAME, + ] + self.assertTrue(all(col in result_df.columns for col in expected_columns)) + np.testing.assert_allclose( + np.array(result_df[RISK_COL_NAME].values), self.expected_aai + ) + # Check constants and column transformations + self.assertEqual(result_df[METRIC_COL_NAME].unique(), AAI_METRIC_NAME) + self.assertEqual(result_df[MEASURE_COL_NAME].iloc[0], NO_MEASURE_VALUE) + self.assertEqual( + result_df[UNIT_COL_NAME].iloc[0], + self.mock_snapshot_start.exposure.value_unit, + ) + self.assertEqual(result_df[GROUP_COL_NAME].dtype.name, "category") + + def test_calc_aai_per_group_metric(self): + result_df = self.calc_risk_metrics_points.calc_aai_per_group_metric() + self.assertIsInstance(result_df, pd.DataFrame) + self.assertEqual( + result_df.shape[0], + len(self.calc_risk_metrics_points.snapshots) + * len(self.calc_risk_metrics_points._group_id), + ) + expected_columns = [ + DATE_COL_NAME, + GROUP_COL_NAME, + RISK_COL_NAME, + METRIC_COL_NAME, + MEASURE_COL_NAME, + UNIT_COL_NAME, + ] + self.assertTrue(all(col in result_df.columns for col in expected_columns)) + np.testing.assert_allclose( + np.array(result_df[RISK_COL_NAME].values), self.expected_aai_per_group + ) + # Check constants and column transformations + self.assertEqual(result_df[METRIC_COL_NAME].unique(), AAI_METRIC_NAME) + self.assertEqual(result_df[MEASURE_COL_NAME].iloc[0], NO_MEASURE_VALUE) + self.assertEqual( + result_df[UNIT_COL_NAME].iloc[0], + self.mock_snapshot_start.exposure.value_unit, + ) + self.assertEqual(result_df[GROUP_COL_NAME].dtype.name, "category") + self.assertListEqual(list(result_df[GROUP_COL_NAME].unique()), [0, 1]) + + def test_calc_return_periods_metric(self): + result_df = self.calc_risk_metrics_points.calc_return_periods_metric( + [20, 50, 100] + ) + self.assertIsInstance(result_df, pd.DataFrame) + self.assertEqual( + result_df.shape[0], len(self.calc_risk_metrics_points.snapshots) * 3 + ) + expected_columns = [ + DATE_COL_NAME, + GROUP_COL_NAME, + RISK_COL_NAME, + METRIC_COL_NAME, + MEASURE_COL_NAME, + UNIT_COL_NAME, + ] + self.assertTrue(all(col in result_df.columns for col in expected_columns)) + np.testing.assert_allclose( + np.array(result_df[RISK_COL_NAME].values), + self.expected_return_period_metric, + ) + # Check constants and column transformations + self.assertListEqual( + list(result_df[METRIC_COL_NAME].unique()), ["rp_20", "rp_50", "rp_100"] + ) + self.assertEqual(result_df[MEASURE_COL_NAME].iloc[0], NO_MEASURE_VALUE) + self.assertEqual( + result_df[UNIT_COL_NAME].iloc[0], + self.mock_snapshot_start.exposure.value_unit, + ) + self.assertEqual(result_df[GROUP_COL_NAME].dtype.name, "category") + + @patch.object(Snapshot, "apply_measure") + @patch("climada.trajectories.riskperiod.CalcRiskMetricsPoints") + def test_apply_measure(self, mock_CalcRiskMetricPoints, mock_snap_apply_measure): + mock_CalcRiskMetricPoints.return_value = MagicMock(spec=CalcRiskMetricsPeriod) + mock_snap_apply_measure.return_value = 42 + result = self.calc_risk_metrics_points.apply_measure(self.measure) + mock_snap_apply_measure.assert_called_with(self.measure) + mock_CalcRiskMetricPoints.assert_called_with( + [42, 42], + self.calc_risk_metrics_points.impact_computation_strategy, + ) + self.assertEqual(result.measure, self.measure) + + +class TestCalcRiskMetricsPeriod_TopLevel(unittest.TestCase): + def setUp(self): + # Create mock objects for testing + self.present_date = 2020 + self.future_date = 2025 + self.exposure_present = Exposures.from_hdf5(EXP_DEMO_H5) + self.exposure_present.gdf.rename(columns={"impf_": "impf_TC"}, inplace=True) + self.exposure_present.gdf["impf_TC"] = 1 + self.exposure_present.gdf[GROUP_ID_COL_NAME] = ( + self.exposure_present.gdf["value"] > 500000 + ) * 1 + self.hazard_present = Hazard.from_hdf5(HAZ_DEMO_H5) + self.exposure_present.assign_centroids(self.hazard_present, distance="approx") + self.impfset_present = ImpactFuncSet([ImpfTropCyclone.from_emanuel_usa()]) + + self.exposure_future = Exposures.from_hdf5(EXP_DEMO_H5) + n_years = self.future_date - self.present_date + 1 + growth_rate = 1.02 + growth = growth_rate**n_years + self.exposure_future.gdf["value"] = self.exposure_future.gdf["value"] * growth + self.exposure_future.gdf.rename(columns={"impf_": "impf_TC"}, inplace=True) + self.exposure_future.gdf["impf_TC"] = 1 + self.exposure_future.gdf[GROUP_ID_COL_NAME] = ( + self.exposure_future.gdf["value"] > 500000 + ) * 1 + self.hazard_future = Hazard.from_hdf5(HAZ_DEMO_H5) + self.hazard_future.intensity *= 1.1 + self.exposure_future.assign_centroids(self.hazard_future, distance="approx") + self.impfset_future = ImpactFuncSet( + [ + ImpfTropCyclone.from_emanuel_usa(impf_id=1, v_half=60.0), + ] + ) + + self.measure = MagicMock(spec=Measure) + self.measure.name = "Test Measure" + + # Setup mock return values for measure.apply + self.measure_exposure = MagicMock(spec=Exposures) + self.measure_hazard = MagicMock(spec=Hazard) + self.measure_impfset = MagicMock(spec=ImpactFuncSet) + self.measure.apply.return_value = ( + self.measure_exposure, + self.measure_impfset, + self.measure_hazard, + ) + + # Create mock snapshots + self.mock_snapshot_start = Snapshot( + exposure=self.exposure_present, + hazard=self.hazard_present, + impfset=self.impfset_present, + date=self.present_date, + ) + self.mock_snapshot_end = Snapshot( + exposure=self.exposure_future, + hazard=self.hazard_future, + impfset=self.impfset_future, + date=self.future_date, + ) + + # Create an instance of CalcRiskPeriod + self.calc_risk_period = CalcRiskMetricsPeriod( + self.mock_snapshot_start, + self.mock_snapshot_end, + time_resolution="Y", + interpolation_strategy=AllLinearStrategy(), + impact_computation_strategy=ImpactCalcComputation(), + # These will have to be tested when implemented + # risk_transf_attach=0.1, + # risk_transf_cover=0.9, + # calc_residual=False + ) + + def test_init(self): + self.assertEqual(self.calc_risk_period.snapshot_start, self.mock_snapshot_start) + self.assertEqual(self.calc_risk_period.snapshot_end, self.mock_snapshot_end) + self.assertEqual(self.calc_risk_period.time_resolution, "Y") + self.assertEqual( + self.calc_risk_period.time_points, self.future_date - self.present_date + 1 + ) + self.assertIsInstance( + self.calc_risk_period.interpolation_strategy, AllLinearStrategy + ) + self.assertIsInstance( + self.calc_risk_period.impact_computation_strategy, ImpactCalcComputation + ) + np.testing.assert_array_equal( + self.calc_risk_period._group_id_E0, + self.mock_snapshot_start.exposure.gdf[GROUP_ID_COL_NAME].values, + ) + np.testing.assert_array_equal( + self.calc_risk_period._group_id_E1, + self.mock_snapshot_end.exposure.gdf[GROUP_ID_COL_NAME].values, + ) + self.assertIsInstance(self.calc_risk_period.date_idx, pd.PeriodIndex) + self.assertEqual( + len(self.calc_risk_period.date_idx), + self.future_date - self.present_date + 1, + ) + + def test_set_date_idx_wrong_type(self): + with self.assertRaises(ValueError): + self.calc_risk_period.date_idx = "A" + + def test_set_date_idx_periods(self): + new_date_idx = pd.period_range("2023-01-01", periods=24) + self.calc_risk_period.date_idx = new_date_idx + self.assertEqual(len(self.calc_risk_period.date_idx), 24) + + def test_set_date_idx_freq(self): + new_date_idx = pd.period_range("2023-01-01", "2023-12-01", freq="M") + self.calc_risk_period.date_idx = new_date_idx + self.assertEqual(len(self.calc_risk_period.date_idx), 12) + pd.testing.assert_index_equal( + self.calc_risk_period.date_idx, + pd.period_range("2023-01-01", "2023-12-01", freq="M"), + ) + + def test_set_time_resolution(self): + self.calc_risk_period.time_resolution = "M" + self.assertEqual(self.calc_risk_period.time_resolution, "M") + pd.testing.assert_index_equal( + self.calc_risk_period.date_idx, + pd.PeriodIndex( + [ + "2020-01-01", + "2020-02-01", + "2020-03-01", + "2020-04-01", + "2020-05-01", + "2020-06-01", + "2020-07-01", + "2020-08-01", + "2020-09-01", + "2020-10-01", + "2020-11-01", + "2020-12-01", + "2021-01-01", + "2021-02-01", + "2021-03-01", + "2021-04-01", + "2021-05-01", + "2021-06-01", + "2021-07-01", + "2021-08-01", + "2021-09-01", + "2021-10-01", + "2021-11-01", + "2021-12-01", + "2022-01-01", + "2022-02-01", + "2022-03-01", + "2022-04-01", + "2022-05-01", + "2022-06-01", + "2022-07-01", + "2022-08-01", + "2022-09-01", + "2022-10-01", + "2022-11-01", + "2022-12-01", + "2023-01-01", + "2023-02-01", + "2023-03-01", + "2023-04-01", + "2023-05-01", + "2023-06-01", + "2023-07-01", + "2023-08-01", + "2023-09-01", + "2023-10-01", + "2023-11-01", + "2023-12-01", + "2024-01-01", + "2024-02-01", + "2024-03-01", + "2024-04-01", + "2024-05-01", + "2024-06-01", + "2024-07-01", + "2024-08-01", + "2024-09-01", + "2024-10-01", + "2024-11-01", + "2024-12-01", + "2025-01-01", + ], + name=DATE_COL_NAME, + freq="M", + ), + ) + + def test_set_interpolation_strategy(self): + new_interpolation_strategy = MagicMock(spec=InterpolationStrategyBase) + self.calc_risk_period.interpolation_strategy = new_interpolation_strategy + self.assertEqual( + self.calc_risk_period.interpolation_strategy, new_interpolation_strategy + ) + + def test_set_interpolation_strategy_wtype(self): + with self.assertRaises(ValueError): + self.calc_risk_period.interpolation_strategy = "A" + + def test_set_impact_computation_strategy(self): + new_impact_computation_strategy = MagicMock(spec=ImpactComputationStrategy) + self.calc_risk_period.impact_computation_strategy = ( + new_impact_computation_strategy + ) + self.assertEqual( + self.calc_risk_period.impact_computation_strategy, + new_impact_computation_strategy, + ) + + def test_set_impact_computation_strategy_wtype(self): + with self.assertRaises(ValueError): + self.calc_risk_period.impact_computation_strategy = "A" + + # The computation are tested in the CalcImpactStrategy / InterpolationStrategyBase tests + # Here we just make sure that the calling works + @patch.object(CalcRiskMetricsPeriod, "impact_computation_strategy") + def test_impacts_arrays(self, mock_impact_compute): + mock_impact_compute.compute_impacts.side_effect = [1, 2, 3, 4, 5, 6, 7, 8] + self.assertEqual(self.calc_risk_period.E0H0V0, 1) + self.assertEqual(self.calc_risk_period.E1H0V0, 2) + self.assertEqual(self.calc_risk_period.E0H1V0, 3) + self.assertEqual(self.calc_risk_period.E1H1V0, 4) + self.assertEqual(self.calc_risk_period.E0H0V1, 5) + self.assertEqual(self.calc_risk_period.E1H0V1, 6) + self.assertEqual(self.calc_risk_period.E0H1V1, 7) + self.assertEqual(self.calc_risk_period.E1H1V1, 8) + mock_impact_compute.compute_impacts.assert_has_calls( + [ + call( + exp, + haz, + impf, + ) + for exp, haz, impf in [ + ( + self.mock_snapshot_start.exposure, + self.mock_snapshot_start.hazard, + self.mock_snapshot_start.impfset, + ), + ( + self.mock_snapshot_end.exposure, + self.mock_snapshot_start.hazard, + self.mock_snapshot_start.impfset, + ), + ( + self.mock_snapshot_start.exposure, + self.mock_snapshot_end.hazard, + self.mock_snapshot_start.impfset, + ), + ( + self.mock_snapshot_end.exposure, + self.mock_snapshot_end.hazard, + self.mock_snapshot_start.impfset, + ), + ( + self.mock_snapshot_start.exposure, + self.mock_snapshot_start.hazard, + self.mock_snapshot_end.impfset, + ), + ( + self.mock_snapshot_end.exposure, + self.mock_snapshot_start.hazard, + self.mock_snapshot_end.impfset, + ), + ( + self.mock_snapshot_start.exposure, + self.mock_snapshot_end.hazard, + self.mock_snapshot_end.impfset, + ), + ( + self.mock_snapshot_end.exposure, + self.mock_snapshot_end.hazard, + self.mock_snapshot_end.impfset, + ), + ] + ] + ) + + @patch.object(CalcRiskMetricsPeriod, "interpolation_strategy") + def test_imp_mats_H0V0(self, mock_interpolate): + mock_interpolate.interp_over_exposure_dim.return_value = 1 + result = self.calc_risk_period.imp_mats_H0V0 + self.assertEqual(result, 1) + mock_interpolate.interp_over_exposure_dim.assert_called_with( + self.calc_risk_period.E0H0V0.imp_mat, + self.calc_risk_period.E1H0V0.imp_mat, + self.calc_risk_period.time_points, + ) + + @patch.object(CalcRiskMetricsPeriod, "interpolation_strategy") + def test_imp_mats_H1V0(self, mock_interpolate): + mock_interpolate.interp_over_exposure_dim.return_value = 1 + result = self.calc_risk_period.imp_mats_H1V0 + self.assertEqual(result, 1) + mock_interpolate.interp_over_exposure_dim.assert_called_with( + self.calc_risk_period.E0H1V0.imp_mat, + self.calc_risk_period.E1H1V0.imp_mat, + self.calc_risk_period.time_points, + ) + + @patch.object(CalcRiskMetricsPeriod, "interpolation_strategy") + def test_imp_mats_H0V1(self, mock_interpolate): + mock_interpolate.interp_over_exposure_dim.return_value = 1 + result = self.calc_risk_period.imp_mats_H0V1 + self.assertEqual(result, 1) + mock_interpolate.interp_over_exposure_dim.assert_called_with( + self.calc_risk_period.E0H0V1.imp_mat, + self.calc_risk_period.E1H0V1.imp_mat, + self.calc_risk_period.time_points, + ) + + @patch.object(CalcRiskMetricsPeriod, "interpolation_strategy") + def test_imp_mats_H1V1(self, mock_interpolate): + mock_interpolate.interp_over_exposure_dim.return_value = 1 + result = self.calc_risk_period.imp_mats_H1V1 + self.assertEqual(result, 1) + mock_interpolate.interp_over_exposure_dim.assert_called_with( + self.calc_risk_period.E0H1V1.imp_mat, + self.calc_risk_period.E1H1V1.imp_mat, + self.calc_risk_period.time_points, + ) + + @patch("climada.trajectories.riskperiod.calc_per_date_eais") + def test_per_date_eai_H0V0(self, mock_calc_per_date_eais): + mock_calc_per_date_eais.return_value = 1 + result = self.calc_risk_period.per_date_eai_H0V0 + + actual_arg0 = mock_calc_per_date_eais.call_args[0][0] + expected_arg0 = self.calc_risk_period.imp_mats_H0V0 + + actual_arg1 = mock_calc_per_date_eais.call_args[0][1] + expected_arg1 = self.calc_risk_period.snapshot_start.hazard.frequency + + assert_sparse_matrix_array_equal(actual_arg0, expected_arg0) + np.testing.assert_array_equal(actual_arg1, expected_arg1) + self.assertEqual(result, 1) + + @patch("climada.trajectories.riskperiod.calc_per_date_eais") + def test_per_date_eai_H1V0(self, mock_calc_per_date_eais): + mock_calc_per_date_eais.return_value = 1 + result = self.calc_risk_period.per_date_eai_H1V0 + actual_arg0 = mock_calc_per_date_eais.call_args[0][0] + expected_arg0 = self.calc_risk_period.imp_mats_H1V0 + + actual_arg1 = mock_calc_per_date_eais.call_args[0][1] + expected_arg1 = self.calc_risk_period.snapshot_start.hazard.frequency + + assert_sparse_matrix_array_equal(actual_arg0, expected_arg0) + np.testing.assert_array_equal(actual_arg1, expected_arg1) + self.assertEqual(result, 1) + + @patch("climada.trajectories.riskperiod.calc_per_date_eais") + def test_per_date_eai_H0V1(self, mock_calc_per_date_eais): + mock_calc_per_date_eais.return_value = 1 + result = self.calc_risk_period.per_date_eai_H0V1 + + actual_arg0 = mock_calc_per_date_eais.call_args[0][0] + expected_arg0 = self.calc_risk_period.imp_mats_H0V1 + + actual_arg1 = mock_calc_per_date_eais.call_args[0][1] + expected_arg1 = self.calc_risk_period.snapshot_start.hazard.frequency + + assert_sparse_matrix_array_equal(actual_arg0, expected_arg0) + np.testing.assert_array_equal(actual_arg1, expected_arg1) + self.assertEqual(result, 1) + + @patch("climada.trajectories.riskperiod.calc_per_date_eais") + def test_per_date_eai_H1V1(self, mock_calc_per_date_eais): + mock_calc_per_date_eais.return_value = 1 + result = self.calc_risk_period.per_date_eai_H1V1 + actual_arg0 = mock_calc_per_date_eais.call_args[0][0] + expected_arg0 = self.calc_risk_period.imp_mats_H1V1 + + actual_arg1 = mock_calc_per_date_eais.call_args[0][1] + expected_arg1 = self.calc_risk_period.snapshot_start.hazard.frequency + + assert_sparse_matrix_array_equal(actual_arg0, expected_arg0) + np.testing.assert_array_equal(actual_arg1, expected_arg1) + self.assertEqual(result, 1) + + @patch("climada.trajectories.riskperiod.calc_per_date_aais") + def test_per_date_aai_H0V0(self, mock_calc_per_date_aais): + mock_calc_per_date_aais.return_value = 1 + result = self.calc_risk_period.per_date_aai_H0V0 + + actual_arg0 = mock_calc_per_date_aais.call_args[0][0] + expected_arg0 = self.calc_risk_period.per_date_eai_H0V0 + self.assertEqual(result, 1) + np.testing.assert_array_equal(actual_arg0, expected_arg0) + + @patch("climada.trajectories.riskperiod.calc_per_date_aais") + def test_per_date_aai_H1V0(self, mock_calc_per_date_aais): + mock_calc_per_date_aais.return_value = 1 + result = self.calc_risk_period.per_date_aai_H1V0 + + actual_arg0 = mock_calc_per_date_aais.call_args[0][0] + expected_arg0 = self.calc_risk_period.per_date_eai_H1V0 + self.assertEqual(result, 1) + np.testing.assert_array_equal(actual_arg0, expected_arg0) + + @patch("climada.trajectories.riskperiod.calc_per_date_aais") + def test_per_date_aai_H0V1(self, mock_calc_per_date_aais): + mock_calc_per_date_aais.return_value = 1 + result = self.calc_risk_period.per_date_aai_H0V1 + + actual_arg0 = mock_calc_per_date_aais.call_args[0][0] + expected_arg0 = self.calc_risk_period.per_date_eai_H0V1 + self.assertEqual(result, 1) + np.testing.assert_array_equal(actual_arg0, expected_arg0) + + @patch("climada.trajectories.riskperiod.calc_per_date_aais") + def test_per_date_aai_H1V1(self, mock_calc_per_date_aais): + mock_calc_per_date_aais.return_value = 1 + result = self.calc_risk_period.per_date_aai_H1V1 + + actual_arg0 = mock_calc_per_date_aais.call_args[0][0] + expected_arg0 = self.calc_risk_period.per_date_eai_H1V1 + self.assertEqual(result, 1) + np.testing.assert_array_equal(actual_arg0, expected_arg0) + + @patch("climada.trajectories.riskperiod.calc_per_date_rps") + def test_per_date_return_periods_H0V0(self, mock_calc_per_date_rps): + mock_calc_per_date_rps.return_value = 1 + result = self.calc_risk_period.per_date_return_periods_H0V0([10, 50]) + + actual_arg0 = mock_calc_per_date_rps.call_args[0][0] + expected_arg0 = self.calc_risk_period.imp_mats_H0V0 + + actual_arg1 = mock_calc_per_date_rps.call_args[0][1] + expected_arg1 = self.calc_risk_period.snapshot_start.hazard.frequency + + actual_arg2 = mock_calc_per_date_rps.call_args[0][2] + expected_arg2 = [10, 50] + + assert_sparse_matrix_array_equal(actual_arg0, expected_arg0) + np.testing.assert_array_equal(actual_arg1, expected_arg1) + self.assertEqual(actual_arg2, expected_arg2) + self.assertEqual(result, 1) + + @patch("climada.trajectories.riskperiod.calc_per_date_rps") + def test_per_date_return_periods_H1V0(self, mock_calc_per_date_rps): + mock_calc_per_date_rps.return_value = 1 + result = self.calc_risk_period.per_date_return_periods_H1V0([10, 50]) + + actual_arg0 = mock_calc_per_date_rps.call_args[0][0] + expected_arg0 = self.calc_risk_period.imp_mats_H1V0 + + actual_arg1 = mock_calc_per_date_rps.call_args[0][1] + expected_arg1 = self.calc_risk_period.snapshot_end.hazard.frequency + + actual_arg2 = mock_calc_per_date_rps.call_args[0][2] + expected_arg2 = [10, 50] + + assert_sparse_matrix_array_equal(actual_arg0, expected_arg0) + np.testing.assert_array_equal(actual_arg1, expected_arg1) + self.assertEqual(actual_arg2, expected_arg2) + self.assertEqual(result, 1) + + @patch("climada.trajectories.riskperiod.calc_per_date_rps") + def test_per_date_return_periods_H0V1(self, mock_calc_per_date_rps): + mock_calc_per_date_rps.return_value = 1 + result = self.calc_risk_period.per_date_return_periods_H0V1([10, 50]) + + actual_arg0 = mock_calc_per_date_rps.call_args[0][0] + expected_arg0 = self.calc_risk_period.imp_mats_H0V1 + + actual_arg1 = mock_calc_per_date_rps.call_args[0][1] + expected_arg1 = self.calc_risk_period.snapshot_start.hazard.frequency + + actual_arg2 = mock_calc_per_date_rps.call_args[0][2] + expected_arg2 = [10, 50] + + assert_sparse_matrix_array_equal(actual_arg0, expected_arg0) + np.testing.assert_array_equal(actual_arg1, expected_arg1) + self.assertEqual(actual_arg2, expected_arg2) + self.assertEqual(result, 1) + + @patch("climada.trajectories.riskperiod.calc_per_date_rps") + def test_per_date_return_periods_H1V1(self, mock_calc_per_date_rps): + mock_calc_per_date_rps.return_value = 1 + result = self.calc_risk_period.per_date_return_periods_H1V1([10, 50]) + + actual_arg0 = mock_calc_per_date_rps.call_args[0][0] + expected_arg0 = self.calc_risk_period.imp_mats_H1V1 + + actual_arg1 = mock_calc_per_date_rps.call_args[0][1] + expected_arg1 = self.calc_risk_period.snapshot_end.hazard.frequency + + actual_arg2 = mock_calc_per_date_rps.call_args[0][2] + expected_arg2 = [10, 50] + + assert_sparse_matrix_array_equal(actual_arg0, expected_arg0) + np.testing.assert_array_equal(actual_arg1, expected_arg1) + self.assertEqual(actual_arg2, expected_arg2) + self.assertEqual(result, 1) + + @patch.object(CalcRiskMetricsPeriod, "calc_eai_gdf", return_value=1) + def test_eai_gdf(self, mock_calc_eai_gdf): + result = self.calc_risk_period.eai_gdf + mock_calc_eai_gdf.assert_called_once() + self.assertEqual(result, 1) + + # Here we mock the impact calc method just to make sure it is rightfully called + def test_calc_per_date_eais(self): + results = calc_per_date_eais( + imp_mats=[ + csr_matrix( + [ + [1, 1, 1], + [2, 2, 2], + ] + ), + csr_matrix( + [ + [2, 0, 1], + [2, 0, 2], + ] + ), + ], + frequency=np.array([1, 1]), + ) + np.testing.assert_array_equal(results, np.array([[3, 3, 3], [4, 0, 3]])) + + def test_calc_per_date_aais(self): + results = calc_per_date_aais(np.array([[3, 3, 3], [4, 0, 3]])) + np.testing.assert_array_equal(results, np.array([9, 7])) + + def test_calc_freq_curve(self): + results = calc_freq_curve( + imp_mat_intrpl=csr_matrix( + [ + [0.1, 0, 0], + [1, 0, 0], + [10, 0, 0], + ] + ), + frequency=np.array([0.5, 0.05, 0.005]), + return_per=[10, 50, 100], + ) + np.testing.assert_array_equal(results, np.array([0.55045, 2.575, 5.05])) + + def test_calc_per_date_rps(self): + base_imp = csr_matrix( + [ + [0.1, 0, 0], + [1, 0, 0], + [10, 0, 0], + ] + ) + results = calc_per_date_rps( + [base_imp, base_imp * 2, base_imp * 4], + frequency=np.array([0.5, 0.05, 0.005]), + return_periods=[10, 50, 100], + ) + np.testing.assert_array_equal( + results, + np.array( + [[0.55045, 2.575, 5.05], [1.1009, 5.15, 10.1], [2.2018, 10.3, 20.2]] + ), + ) + + +class TestCalcRiskPeriod_LowLevel(unittest.TestCase): + def setUp(self): + # Create mock objects for testing + self.calc_risk_period = MagicMock(spec=CalcRiskMetricsPeriod) + + # Little trick to bind the mocked object method to the real one + self.calc_risk_period.calc_eai = types.MethodType( + CalcRiskMetricsPeriod.calc_eai, self.calc_risk_period + ) + + self.calc_risk_period.calc_eai_gdf = types.MethodType( + CalcRiskMetricsPeriod.calc_eai_gdf, self.calc_risk_period + ) + self.calc_risk_period.calc_aai_metric = types.MethodType( + CalcRiskMetricsPeriod.calc_aai_metric, self.calc_risk_period + ) + + self.calc_risk_period.calc_aai_per_group_metric = types.MethodType( + CalcRiskMetricsPeriod.calc_aai_per_group_metric, self.calc_risk_period + ) + self.calc_risk_period.calc_return_periods_metric = types.MethodType( + CalcRiskMetricsPeriod.calc_return_periods_metric, self.calc_risk_period + ) + self.calc_risk_period.calc_risk_components_metric = types.MethodType( + CalcRiskMetricsPeriod.calc_risk_contributions_metric, self.calc_risk_period + ) + self.calc_risk_period.apply_measure = types.MethodType( + CalcRiskMetricsPeriod.apply_measure, self.calc_risk_period + ) + + self.calc_risk_period.per_date_eai_H0V0 = np.array( + [[1, 0, 1], [1, 2, 0], [3, 3, 3]] + ) + self.calc_risk_period.per_date_eai_H1V0 = np.array( + [[2, 0, 2], [2, 4, 0], [12, 6, 6]] + ) + self.calc_risk_period.per_date_aai_H0V0 = np.array([2, 3, 9]) + self.calc_risk_period.per_date_aai_H1V0 = np.array([4, 6, 24]) + + self.calc_risk_period.per_date_eai_H0V1 = np.array( + [[1, 0, 1], [1, 2, 0], [3, 3, 3]] + ) + self.calc_risk_period.per_date_eai_H1V1 = np.array( + [[2, 0, 2], [2, 4, 0], [12, 6, 6]] + ) + self.calc_risk_period.per_date_aai_H0V1 = np.array([2, 3, 9]) + self.calc_risk_period.per_date_aai_H1V1 = np.array([4, 6, 24]) + + self.calc_risk_period.date_idx = pd.PeriodIndex( + ["2020-01-01", "2025-01-01", "2030-01-01"], name=DATE_COL_NAME, freq="5Y" + ) + self.calc_risk_period.snapshot_start.exposure.gdf = gpd.GeoDataFrame( + { + GROUP_ID_COL_NAME: [1, 2, 2], + "geometry": [Point(0, 0), Point(1, 1), Point(2, 2)], + "value": [10, 10, 20], + } + ) + self.calc_risk_period.snapshot_end.exposure.gdf = gpd.GeoDataFrame( + { + GROUP_ID_COL_NAME: [1, 2, 2], + "geometry": [Point(0, 0), Point(1, 1), Point(2, 2)], + "value": [10, 10, 20], + } + ) + self.calc_risk_period.measure = MagicMock(spec=Measure) + self.calc_risk_period.measure.name = "dummy_measure" + + def test_calc_eai(self): + # Mock the return values of interp_over_hazard_dim + self.calc_risk_period.interpolation_strategy.interp_over_hazard_dim.side_effect = [ + "V0_interpolated_data", # First call (for per_date_eai_V0) + "V1_interpolated_data", # Second call (for per_date_eai_V1) + ] + # Mock the return value of interp_over_vulnerability_dim + self.calc_risk_period.interpolation_strategy.interp_over_vulnerability_dim.return_value = ( + "final_eai_result" + ) + + result = self.calc_risk_period.calc_eai() + + # Assert that interp_over_hazard_dim was called with the correct arguments + self.calc_risk_period.interpolation_strategy.interp_over_hazard_dim.assert_has_calls( + [ + call( + self.calc_risk_period.per_date_eai_H0V0, + self.calc_risk_period.per_date_eai_H1V0, + ), + call( + self.calc_risk_period.per_date_eai_H0V1, + self.calc_risk_period.per_date_eai_H1V1, + ), + ] + ) + + # Assert that interp_over_vulnerability_dim was called with the results of interp_over_hazard_dim + self.calc_risk_period.interpolation_strategy.interp_over_vulnerability_dim.assert_called_once_with( + "V0_interpolated_data", "V1_interpolated_data" + ) + + # Assert the final returned value + self.assertEqual(result, "final_eai_result") + + def test_calc_eai_gdf(self): + self.calc_risk_period._groups_id = np.array([0]) + expected_risk = np.array([[1.0, 1.5, 12], [0, 3, 6], [1, 0, 6]]) + self.calc_risk_period.per_date_eai = expected_risk + result = self.calc_risk_period.calc_eai_gdf() + expected_columns = { + GROUP_COL_NAME, + COORD_ID_COL_NAME, + DATE_COL_NAME, + RISK_COL_NAME, + METRIC_COL_NAME, + MEASURE_COL_NAME, + } + self.assertTrue(expected_columns.issubset(set(result.columns))) + self.assertTrue((result[METRIC_COL_NAME] == EAI_METRIC_NAME).all()) + self.assertTrue((result[MEASURE_COL_NAME] == "dummy_measure").all()) + # Check calculated risk values by coord_id, date + actual_risk = result[RISK_COL_NAME].values + np.testing.assert_allclose(expected_risk.T.flatten(), actual_risk) + + def test_calc_aai_metric(self): + expected_aai = np.array([2, 4.5, 24]) + self.calc_risk_period.per_date_aai = expected_aai + self.calc_risk_period._groups_id = np.array([0]) + result = self.calc_risk_period.calc_aai_metric() + expected_columns = { + GROUP_COL_NAME, + DATE_COL_NAME, + RISK_COL_NAME, + METRIC_COL_NAME, + MEASURE_COL_NAME, + } + self.assertTrue(expected_columns.issubset(set(result.columns))) + self.assertTrue((result[METRIC_COL_NAME] == AAI_METRIC_NAME).all()) + self.assertTrue((result[MEASURE_COL_NAME] == "dummy_measure").all()) + + # Check calculated risk values by coord_id, date + actual_risk = result[RISK_COL_NAME].values + np.testing.assert_allclose(expected_aai, actual_risk) + + def test_calc_aai_per_group_metric(self): + self.calc_risk_period._group_id_E0 = np.array([1, 1, 2]) + self.calc_risk_period._group_id_E1 = np.array([2, 2, 2]) + self.calc_risk_period._groups_id = np.array([1, 2]) + self.calc_risk_period.eai_gdf = pd.DataFrame( + { + DATE_COL_NAME: pd.PeriodIndex( + ["2020-01-01"] * 3 + ["2025-01-01"] * 3 + ["2030-01-01"] * 3, + name=DATE_COL_NAME, + freq="5Y", + ), + COORD_ID_COL_NAME: [0, 1, 2, 0, 1, 2, 0, 1, 2], + GROUP_COL_NAME: [1, 1, 2, 1, 1, 2, 1, 1, 2], + RISK_COL_NAME: [2, 3, 4, 5, 6, 7, 8, 9, 10], + METRIC_COL_NAME: [EAI_METRIC_NAME, EAI_METRIC_NAME, EAI_METRIC_NAME] + * 3, + MEASURE_COL_NAME: ["dummy_measure", "dummy_measure", "dummy_measure"] + * 3, + } + ) + self.calc_risk_period.eai_gdf[GROUP_COL_NAME] = self.calc_risk_period.eai_gdf[ + GROUP_COL_NAME + ].astype("category") + result = self.calc_risk_period.calc_aai_per_group_metric() + expected_columns = { + GROUP_COL_NAME, + DATE_COL_NAME, + RISK_COL_NAME, + METRIC_COL_NAME, + MEASURE_COL_NAME, + } + self.assertTrue(expected_columns.issubset(set(result.columns))) + self.assertTrue((result[METRIC_COL_NAME] == AAI_METRIC_NAME).all()) + self.assertTrue((result[MEASURE_COL_NAME] == "dummy_measure").all()) + # Check calculated risk values by coord_id, date + expected_risk = np.array([5, 5, 6.6, 13.6, 3.4, 27]) + actual_risk = result[RISK_COL_NAME].values + np.testing.assert_allclose(expected_risk, actual_risk) + + def test_calc_return_periods_metric(self): + self.calc_risk_period._groups_id = np.array([0]) + self.calc_risk_period.per_date_return_periods_H0V0.return_value = "H0V0" + self.calc_risk_period.per_date_return_periods_H1V0.return_value = "H1V0" + self.calc_risk_period.per_date_return_periods_H0V1.return_value = "H0V1" + self.calc_risk_period.per_date_return_periods_H1V1.return_value = "H1V1" + # Mock the return values of interp_over_hazard_dim + self.calc_risk_period.interpolation_strategy.interp_over_hazard_dim.side_effect = [ + "V0_interpolated_data", # First call (for per_date_rp_V0) + "V1_interpolated_data", # Second call (for per_date_rp_V1) + ] + # Mock the return value of interp_over_vulnerability_dim + self.calc_risk_period.interpolation_strategy.interp_over_vulnerability_dim.return_value = np.array( + [[1, 2, 3], [4, 5, 6], [7, 8, 9]] + ) + + result = self.calc_risk_period.calc_return_periods_metric([10, 20, 30]) + + # Assert that interp_over_hazard_dim was called with the correct arguments + self.calc_risk_period.interpolation_strategy.interp_over_hazard_dim.assert_has_calls( + [call("H0V0", "H1V0"), call("H0V1", "H1V1")] + ) + + # Assert that interp_over_vulnerability_dim was called with the results of interp_over_hazard_dim + self.calc_risk_period.interpolation_strategy.interp_over_vulnerability_dim.assert_called_once_with( + "V0_interpolated_data", "V1_interpolated_data" + ) + + # Assert the final returned value + + expected_columns = { + GROUP_COL_NAME, + DATE_COL_NAME, + RISK_COL_NAME, + METRIC_COL_NAME, + MEASURE_COL_NAME, + } + self.assertTrue(expected_columns.issubset(set(result.columns))) + self.assertTrue( + all(result[METRIC_COL_NAME].unique() == ["rp_10", "rp_20", "rp_30"]) + ) + self.assertTrue((result[MEASURE_COL_NAME] == "dummy_measure").all()) + + # Check calculated risk values by rp, date + np.testing.assert_allclose( + result[RISK_COL_NAME].values, np.array([1, 4, 7, 2, 5, 8, 3, 6, 9]) + ) + + def test_calc_risk_components_metric(self): + self.calc_risk_period._groups_id = np.array([0]) + self.calc_risk_period.per_date_aai_H0V0 = np.array([1, 3, 5]) + self.calc_risk_period.per_date_aai_E0H0V0 = np.array([1, 1, 1]) + self.calc_risk_period.per_date_aai_E0H1V0 = np.array( + [2, 2, 2] + ) # Haz change doubles damages in fut + self.calc_risk_period.per_date_aai_E0H0V1 = np.array( + [3, 3, 3] + ) # Vul change triples damages in fut + self.calc_risk_period.per_date_aai = np.array([1, 6, 10]) + + # Mock the return values of interp_over_hazard_dim + self.calc_risk_period.interpolation_strategy.interp_over_hazard_dim.return_value = np.array( + [1, 1.5, 2] + ) + + # Mock the return value of interp_over_vulnerability_dim + self.calc_risk_period.interpolation_strategy.interp_over_vulnerability_dim.return_value = np.array( + [1, 2, 3] + ) + + result = self.calc_risk_period.calc_risk_components_metric() + + # Assert that interp_over_hazard_dim was called with the correct arguments + self.calc_risk_period.interpolation_strategy.interp_over_hazard_dim.assert_called_once_with( + self.calc_risk_period.per_date_aai_E0H0V0, + self.calc_risk_period.per_date_aai_E0H1V0, + ) + + # Assert that interp_over_vulnerability_dim was called with the results of interp_over_hazard_dim + self.calc_risk_period.interpolation_strategy.interp_over_vulnerability_dim.assert_called_once_with( + self.calc_risk_period.per_date_aai_E0H0V0, + self.calc_risk_period.per_date_aai_E0H0V1, + ) + + # Assert the final returned value + expected_columns = { + GROUP_COL_NAME, + DATE_COL_NAME, + RISK_COL_NAME, + METRIC_COL_NAME, + MEASURE_COL_NAME, + } + self.assertTrue(expected_columns.issubset(set(result.columns))) + self.assertTrue( + all( + result[METRIC_COL_NAME].unique() + == [ + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + ] + ) + ) + self.assertTrue((result[MEASURE_COL_NAME] == "dummy_measure").all()) + + np.testing.assert_allclose( + result[RISK_COL_NAME].values, + np.array([1.0, 1.0, 1.0, 0, 2.0, 4.0, 0, 0.5, 1.0, 0, 1, 2, 0, 1.5, 2.0]), + ) + + @patch("climada.trajectories.riskperiod.CalcRiskMetricsPeriod") + def test_apply_measure(self, mock_CalcRiskPeriod): + mock_CalcRiskPeriod.return_value = MagicMock(spec=CalcRiskMetricsPeriod) + self.calc_risk_period.snapshot_start.apply_measure.return_value = 2 + self.calc_risk_period.snapshot_end.apply_measure.return_value = 3 + result = self.calc_risk_period.apply_measure(self.calc_risk_period.measure) + self.assertEqual(result.measure, self.calc_risk_period.measure) + mock_CalcRiskPeriod.assert_called_with( + 2, + 3, + self.calc_risk_period.time_resolution, + self.calc_risk_period.interpolation_strategy, + self.calc_risk_period.impact_computation_strategy, + ) + + +def assert_sparse_matrix_array_equal(expected_array, actual_array): + """ + Compares two numpy arrays where elements are sparse matrices. + Uses numpy testing for robust comparison of the sparse matrix internals. + """ + if len(expected_array) != len(actual_array): + raise AssertionError( + f"Expected array length {len(expected_array)} but got {len(actual_array)}" + ) + + for i, (expected_mat, actual_mat) in enumerate(zip(expected_array, actual_array)): + if not (issparse(expected_mat) and issparse(actual_mat)): + raise TypeError(f"Element at index {i} is not a sparse matrix.") + + # Robustly compare the underlying data + np.testing.assert_array_equal( + expected_mat.data, + actual_mat.data, + err_msg=f"Data differs at matrix index {i}", + ) + np.testing.assert_array_equal( + expected_mat.indices, + actual_mat.indices, + err_msg=f"Indices differ at matrix index {i}", + ) + np.testing.assert_array_equal( + expected_mat.indptr, + actual_mat.indptr, + err_msg=f"Indptr differs at matrix index {i}", + ) + # You may also want to assert equal shapes: + assert ( + expected_mat.shape == actual_mat.shape + ), f"Shape differs at matrix index {i}" + + +if __name__ == "__main__": + TESTS = unittest.TestLoader().loadTestsFromTestCase( + TestCalcRiskMetricsPeriod_TopLevel + ) + TESTS.addTests( + unittest.TestLoader().loadTestsFromTestCase(TestCalcRiskMetricsPoints) + ) + TESTS.addTests( + unittest.TestLoader().loadTestsFromTestCase(TestCalcRiskPeriod_LowLevel) + ) + unittest.TextTestRunner(verbosity=2).run(TESTS) From 40f37b07615bce14462e9fcd60465f3ddb32f790 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 18 Dec 2025 11:05:52 +0100 Subject: [PATCH 05/61] cherry pick, renaming --- climada/trajectories/calc_risk_metrics.py | 895 +---------- climada/trajectories/static_trajectory.py | 316 ++++ .../test/test_calc_risk_metrics.py | 448 ++++++ climada/trajectories/test/test_riskperiod.py | 1389 ----------------- climada/trajectories/test/test_trajectory.py | 326 ++++ climada/trajectories/trajectory.py | 268 ++++ 6 files changed, 1361 insertions(+), 2281 deletions(-) create mode 100644 climada/trajectories/static_trajectory.py create mode 100644 climada/trajectories/test/test_calc_risk_metrics.py delete mode 100644 climada/trajectories/test/test_riskperiod.py create mode 100644 climada/trajectories/test/test_trajectory.py create mode 100644 climada/trajectories/trajectory.py diff --git a/climada/trajectories/calc_risk_metrics.py b/climada/trajectories/calc_risk_metrics.py index 04846d18d3..2d325fb495 100644 --- a/climada/trajectories/calc_risk_metrics.py +++ b/climada/trajectories/calc_risk_metrics.py @@ -16,9 +16,9 @@ --- -This modules implements the CalcRiskPeriod class. +This modules implements the CalcRiskMetrics classes. -CalcRiskPeriod are used to compute risk metrics (and intermediate requirements) +CalcRiskMetrics are used to compute risk metrics (and intermediate requirements) in between two snapshots. As these computations are not always required and can become "heavy", a so called "lazy" @@ -26,28 +26,17 @@ """ -import datetime -import itertools import logging import numpy as np import pandas as pd -from scipy.sparse import csr_matrix -from climada.engine.impact import Impact, ImpactFreqCurve -from climada.engine.impact_calc import ImpactCalc +from climada.engine.impact import Impact from climada.entity.measures.base import Measure from climada.trajectories.constants import ( AAI_METRIC_NAME, - CONTRIBUTION_BASE_RISK_NAME, - CONTRIBUTION_EXPOSURE_NAME, - CONTRIBUTION_HAZARD_NAME, - CONTRIBUTION_INTERACTION_TERM_NAME, - CONTRIBUTION_TOTAL_RISK_NAME, - CONTRIBUTION_VULNERABILITY_NAME, COORD_ID_COL_NAME, DATE_COL_NAME, - DEFAULT_PERIOD_INDEX_NAME, EAI_METRIC_NAME, GROUP_COL_NAME, GROUP_ID_COL_NAME, @@ -59,21 +48,12 @@ UNIT_COL_NAME, ) from climada.trajectories.impact_calc_strat import ImpactComputationStrategy -from climada.trajectories.interpolation import ( - InterpolationStrategyBase, - linear_interp_arrays, -) from climada.trajectories.snapshot import Snapshot LOGGER = logging.getLogger(__name__) __all__ = [ "CalcRiskMetricsPoints", - "CalcRiskMetricsPeriod", - "calc_per_date_aais", - "calc_per_date_eais", - "calc_per_date_rps", - "calc_freq_curve", ] @@ -343,872 +323,3 @@ def apply_measure(self, measure: Measure) -> "CalcRiskMetricsPoints": risk_period.measure = measure return risk_period - - -class CalcRiskMetricsPeriod: - """This class handles the computation of impacts for a risk period. - - This object handles the interpolations and computations of risk metrics in - between two given snapshots, along a DateTimeIndex build from either a - `time_resolution` (which must be a valid "freq" string to build a DateTimeIndex) - and defaults to "Y" (start of the year) or `time_points` integer argument, in which case - the DateTimeIndex will have that many periods. - - Note that most attribute like members are properties with their own docstring. - - Attributes - ---------- - - date_idx: pd.PeriodIndex - The date index for the different interpolated points between the two snapshots - interpolation_strategy: InterpolationStrategy, optional - The approach used to interpolate impact matrices in between the two snapshots, linear by default. - impact_computation_strategy: ImpactComputationStrategy, optional - The method used to calculate the impact from the (Haz,Exp,Vul) of the two snapshots. - Defaults to ImpactCalc - measure: Measure, optional - The measure to apply to both snapshots. Defaults to None. - - Notes - ----- - - This class is intended for internal computation. - """ - - def __init__( - self, - snapshot0: Snapshot, - snapshot1: Snapshot, - time_resolution: str, - interpolation_strategy: InterpolationStrategyBase, - impact_computation_strategy: ImpactComputationStrategy, - ): - """Initialize a new `CalcRiskMetricsPeriod` - - This initializes and instantiate a new `CalcRiskMetricsPeriod` object. - No computation is done at initialisation and only done "just in time". - - Parameters - ---------- - snapshot0 : Snapshot - The `Snapshot` at the start of the risk period. - snapshot1 : Snapshot - The `Snapshot` at the end of the risk period. - time_resolution : str, optional - One of pandas date offset strings or corresponding objects. See :func:`pandas.period_range`. - time_points : int, optional - Number of periods to generate for the PeriodIndex. - interpolation_strategy: InterpolationStrategy, optional - The approach used to interpolate impact matrices in between the two snapshots, linear by default. - impact_computation_strategy: ImpactComputationStrategy, optional - The method used to calculate the impact from the (Haz,Exp,Vul) of the two snapshots. - Defaults to ImpactCalc - - """ - - LOGGER.debug("Instantiating new CalcRiskPeriod.") - self._snapshot0 = snapshot0 - self._snapshot1 = snapshot1 - self.date_idx = self._set_date_idx( - date1=snapshot0.date, - date2=snapshot1.date, - freq=time_resolution, - name=DEFAULT_PERIOD_INDEX_NAME, - ) - self.interpolation_strategy = interpolation_strategy - self.impact_computation_strategy = impact_computation_strategy - self.measure = None # Only possible to set with apply_measure to make sure snapshots are consistent - - self._group_id_E0 = ( - np.array(self.snapshot_start.exposure.gdf[GROUP_ID_COL_NAME].values) - if GROUP_ID_COL_NAME in self.snapshot_start.exposure.gdf.columns - else np.array([]) - ) - self._group_id_E1 = ( - np.array(self.snapshot_end.exposure.gdf[GROUP_ID_COL_NAME].values) - if GROUP_ID_COL_NAME in self.snapshot_end.exposure.gdf.columns - else np.array([]) - ) - self._groups_id = np.unique( - np.concatenate([self._group_id_E0, self._group_id_E1]) - ) - - def _reset_impact_data(self): - """Util method that resets computed data, for instance when changing the time resolution.""" - for fut in list(itertools.product([0, 1], repeat=3)): - setattr(self, f"_E{fut[0]}H{fut[1]}V{fut[2]}", None) - - for fut in list(itertools.product([0, 1], repeat=2)): - setattr(self, f"_imp_mats_H{fut[0]}V{fut[1]}", None) - setattr(self, f"_per_date_eai_H{fut[0]}V{fut[1]}", None) - setattr(self, f"_per_date_aai_H{fut[0]}V{fut[1]}", None) - - self._eai_gdf = None - self._per_date_eai = None - self._per_date_aai = None - self._per_date_return_periods_H0, self._per_date_return_periods_H1 = None, None - - @staticmethod - def _set_date_idx( - date1: str | pd.Timestamp | datetime.date, - date2: str | pd.Timestamp | datetime.date, - freq: str | None = None, - name: str | None = None, - ) -> pd.PeriodIndex: - """Generate a date range index based on the provided parameters. - - Parameters - ---------- - date1 : str or pd.Timestamp or datetime.date - The start date of the period range. - date2 : str or pd.Timestamp or datetime.date - The end date of the period range. - freq : str, optional - Frequency string for the period range. - See `here `_. - name : str, optional - Name of the resulting period range index. - - Returns - ------- - pd.PeriodIndex - A PeriodIndex representing the date range. - - Raises - ------ - ValueError - If the number of periods and frequency given to period_range are inconsistent. - """ - ret = pd.period_range( - date1, - date2, - freq=freq, # type: ignore - name=name, - ) - return ret - - @property - def snapshot_start(self) -> Snapshot: - """The `Snapshot` at the start of the risk period.""" - return self._snapshot0 - - @property - def snapshot_end(self) -> Snapshot: - """The `Snapshot` at the end of the risk period.""" - return self._snapshot1 - - @property - def date_idx(self) -> pd.PeriodIndex: - """The pandas PeriodIndex representing the time dimension of the risk period.""" - return self._date_idx - - @date_idx.setter - def date_idx(self, value, /): - if not isinstance(value, pd.PeriodIndex): - raise ValueError("Not a PeriodIndex") - - self._date_idx = value # Avoids weird hourly data - self._time_points = len(self.date_idx) - self._time_resolution = self.date_idx.freq - self._reset_impact_data() - - @property - def time_points(self) -> int: - """The numbers of different time points (periods) in the risk period.""" - return self._time_points - - @property - def time_resolution(self) -> str: - """The time resolution of the risk periods, expressed as a pandas period frequency string.""" - return self._time_resolution # type: ignore - - @time_resolution.setter - def time_resolution(self, value, /): - self.date_idx = pd.period_range( - self.snapshot_start.date, - self.snapshot_end.date, - freq=value, - name=DEFAULT_PERIOD_INDEX_NAME, - ) - - @property - def interpolation_strategy(self) -> InterpolationStrategyBase: - """The approach used to interpolate impact matrices in between the two snapshots.""" - return self._interpolation_strategy - - @interpolation_strategy.setter - def interpolation_strategy(self, value, /): - if not isinstance(value, InterpolationStrategyBase): - raise ValueError("Not an interpolation strategy") - - self._interpolation_strategy = value - self._reset_impact_data() - - @property - def impact_computation_strategy(self) -> ImpactComputationStrategy: - """The method used to calculate the impact from the (Haz,Exp,Vul) of the two snapshots.""" - return self._impact_computation_strategy - - @impact_computation_strategy.setter - def impact_computation_strategy(self, value, /): - if not isinstance(value, ImpactComputationStrategy): - raise ValueError("Not an impact computation strategy") - - self._impact_computation_strategy = value - self._reset_impact_data() - - ##### Impact objects cube / Risk Cube ##### - - @lazy_property - def E0H0V0(self) -> Impact: - """Impact object corresponding to starting exposure, starting hazard and starting vulnerability.""" - return self.impact_computation_strategy.compute_impacts( - self.snapshot_start.exposure, - self.snapshot_start.hazard, - self.snapshot_start.impfset, - ) - - @lazy_property - def E1H0V0(self) -> Impact: - """Impact object corresponding to future exposure, starting hazard and starting vulnerability.""" - return self.impact_computation_strategy.compute_impacts( - self.snapshot_end.exposure, - self.snapshot_start.hazard, - self.snapshot_start.impfset, - ) - - @lazy_property - def E0H1V0(self) -> Impact: - """Impact object corresponding to starting exposure, future hazard and starting vulnerability.""" - return self.impact_computation_strategy.compute_impacts( - self.snapshot_start.exposure, - self.snapshot_end.hazard, - self.snapshot_start.impfset, - ) - - @lazy_property - def E1H1V0(self) -> Impact: - """Impact object corresponding to future exposure, future hazard and starting vulnerability.""" - return self.impact_computation_strategy.compute_impacts( - self.snapshot_end.exposure, - self.snapshot_end.hazard, - self.snapshot_start.impfset, - ) - - @lazy_property - def E0H0V1(self) -> Impact: - """Impact object corresponding to starting exposure, starting hazard and future vulnerability.""" - return self.impact_computation_strategy.compute_impacts( - self.snapshot_start.exposure, - self.snapshot_start.hazard, - self.snapshot_end.impfset, - ) - - @lazy_property - def E1H0V1(self) -> Impact: - """Impact object corresponding to future exposure, starting hazard and future vulnerability.""" - return self.impact_computation_strategy.compute_impacts( - self.snapshot_end.exposure, - self.snapshot_start.hazard, - self.snapshot_end.impfset, - ) - - @lazy_property - def E0H1V1(self) -> Impact: - """Impact object corresponding to starting exposure, future hazard and future vulnerability.""" - return self.impact_computation_strategy.compute_impacts( - self.snapshot_start.exposure, - self.snapshot_end.hazard, - self.snapshot_end.impfset, - ) - - @lazy_property - def E1H1V1(self) -> Impact: - """Impact object corresponding to future exposure, future hazard and future vulnerability.""" - return self.impact_computation_strategy.compute_impacts( - self.snapshot_end.exposure, - self.snapshot_end.hazard, - self.snapshot_end.impfset, - ) - - ############################### - - ### Impact Matrices arrays #### - - def _interp_mats(self, start_attr, end_attr) -> list: - """Helper to reduce repetition in impact matrix interpolation.""" - start = getattr(self, start_attr).imp_mat - end = getattr(self, end_attr).imp_mat - return self.interpolation_strategy.interp_over_exposure_dim( - start, end, self.time_points - ) - - @property - def imp_mats_H0V0(self) -> list: - """List of `time_points` impact matrices with changing exposure, starting hazard and starting vulnerability.""" - return self._interp_mats("E0H0V0", "E1H0V0") - - @property - def imp_mats_H1V0(self) -> list: - """List of `time_points` impact matrices with changing exposure, future hazard and starting vulnerability.""" - return self._interp_mats("E0H1V0", "E1H1V0") - - @property - def imp_mats_H0V1(self) -> list: - """List of `time_points` impact matrices with changing exposure, starting hazard and future vulnerability.""" - return self._interp_mats("E0H0V1", "E1H0V1") - - @property - def imp_mats_H1V1(self) -> list: - """List of `time_points` impact matrices with changing exposure, future hazard and future vulnerability.""" - return self._interp_mats("E0H1V1", "E1H1V1") - - @property - def imp_mats_E0H0V0(self) -> list: - """List of `time_points` impact matrices with base exposure, base hazard and base vulnerability.""" - return self._interp_mats("E0H0V0", "E0H0V0") - - @property - def imp_mats_E0H1V0(self) -> list: - """List of `time_points` impact matrices with base exposure, future hazard and base vulnerability.""" - return self._interp_mats("E0H1V0", "E0H1V0") - - @property - def imp_mats_E0H0V1(self) -> list: - """List of `time_points` impact matrices with base exposure, base hazard and base vulnerability.""" - return self._interp_mats("E0H0V1", "E0H0V1") - - ############################### - - ########## Core EAI ########### - - @property - def per_date_eai_H0V0(self) -> np.ndarray: - """Expected annual impacts for changing exposure, starting hazard and starting vulnerability.""" - return calc_per_date_eais( - self.imp_mats_H0V0, self.snapshot_start.hazard.frequency - ) - - @property - def per_date_eai_H1V0(self) -> np.ndarray: - """Expected annual impacts for changing exposure, future hazard and starting vulnerability.""" - return calc_per_date_eais( - self.imp_mats_H1V0, self.snapshot_end.hazard.frequency - ) - - @property - def per_date_eai_H0V1(self) -> np.ndarray: - """Expected annual impacts for changing exposure, starting hazard and future vulnerability.""" - return calc_per_date_eais( - self.imp_mats_H0V1, self.snapshot_start.hazard.frequency - ) - - @property - def per_date_eai_H1V1(self) -> np.ndarray: - """Expected annual impacts for changing exposure, future hazard and future vulnerability.""" - return calc_per_date_eais( - self.imp_mats_H1V1, self.snapshot_end.hazard.frequency - ) - - @property - def per_date_eai_E0H0V0(self) -> np.ndarray: - """Expected annual impacts for base exposure, base hazard and base vulnerability.""" - return calc_per_date_eais( - self.imp_mats_E0H0V0, self.snapshot_start.hazard.frequency - ) - - @property - def per_date_eai_E0H1V0(self) -> np.ndarray: - """Expected annual impacts for base exposure, future hazard and base vulnerability.""" - return calc_per_date_eais( - self.imp_mats_E0H1V0, self.snapshot_end.hazard.frequency - ) - - @property - def per_date_eai_E0H0V1(self) -> np.ndarray: - """Expected annual impacts for base exposure, future hazard and base vulnerability.""" - return calc_per_date_eais( - self.imp_mats_E0H0V1, self.snapshot_start.hazard.frequency - ) - - ################################## - - ######### Core AAIs ########## - - @property - def per_date_aai_H0V0(self) -> np.ndarray: - """Average annual impacts for changing exposure, starting hazard and starting vulnerability.""" - return calc_per_date_aais(self.per_date_eai_H0V0) - - @property - def per_date_aai_H1V0(self) -> np.ndarray: - """Average annual impacts for changing exposure, future hazard and starting vulnerability.""" - return calc_per_date_aais(self.per_date_eai_H1V0) - - @property - def per_date_aai_H0V1(self) -> np.ndarray: - """Average annual impacts for changing exposure, starting hazard and future vulnerability.""" - return calc_per_date_aais(self.per_date_eai_H0V1) - - @property - def per_date_aai_H1V1(self) -> np.ndarray: - """Average annual impacts for changing exposure, future hazard and future vulnerability.""" - return calc_per_date_aais(self.per_date_eai_H1V1) - - @property - def per_date_aai_E0H0V0(self) -> np.ndarray: - """Average annual impacts for base exposure, base hazard and base vulnerability.""" - return calc_per_date_aais(self.per_date_eai_E0H0V0) - - @property - def per_date_aai_E0H1V0(self) -> np.ndarray: - """Average annual impacts for base exposure, base hazard and base vulnerability.""" - return calc_per_date_aais(self.per_date_eai_E0H1V0) - - @property - def per_date_aai_E0H0V1(self) -> np.ndarray: - """Average annual impacts for base exposure, base hazard and base vulnerability.""" - return calc_per_date_aais(self.per_date_eai_E0H0V1) - - ################################# - - ######### Core RPs ######### - - def per_date_return_periods_H0V0(self, return_periods: list[int]) -> np.ndarray: - """Estimated impacts per dates for given return periods, with changing exposure, starting hazard and starting vulnerability.""" - return calc_per_date_rps( - self.imp_mats_H0V0, - self.snapshot_start.hazard.frequency, - self.date_idx.freqstr[0], - return_periods, - ) - - def per_date_return_periods_H1V0(self, return_periods: list[int]) -> np.ndarray: - """Estimated impacts per dates for given return periods, with changing exposure, future hazard and starting vulnerability.""" - return calc_per_date_rps( - self.imp_mats_H1V0, - self.snapshot_end.hazard.frequency, - self.date_idx.freqstr[0], - return_periods, - ) - - def per_date_return_periods_H0V1(self, return_periods: list[int]) -> np.ndarray: - """Estimated impacts per dates for given return periods, with changing exposure, starting hazard and future vulnerability.""" - return calc_per_date_rps( - self.imp_mats_H0V1, - self.snapshot_start.hazard.frequency, - self.date_idx.freqstr[0], - return_periods, - ) - - def per_date_return_periods_H1V1(self, return_periods: list[int]) -> np.ndarray: - """Estimated impacts per dates for given return periods, with changing exposure, future hazard and future vulnerability.""" - return calc_per_date_rps( - self.imp_mats_H1V1, - self.snapshot_end.hazard.frequency, - self.date_idx.freqstr[0], - return_periods, - ) - - ################################## - - ##### Interpolation of metrics ##### - - def calc_eai(self) -> np.ndarray: - """Compute the EAIs at each date of the risk period (including changes in exposure, hazard and vulnerability).""" - per_date_eai_H0V0, per_date_eai_H1V0, per_date_eai_H0V1, per_date_eai_H1V1 = ( - self.per_date_eai_H0V0, - self.per_date_eai_H1V0, - self.per_date_eai_H0V1, - self.per_date_eai_H1V1, - ) - per_date_eai_V0 = self.interpolation_strategy.interp_over_hazard_dim( - per_date_eai_H0V0, per_date_eai_H1V0 - ) - per_date_eai_V1 = self.interpolation_strategy.interp_over_hazard_dim( - per_date_eai_H0V1, per_date_eai_H1V1 - ) - per_date_eai = self.interpolation_strategy.interp_over_vulnerability_dim( - per_date_eai_V0, per_date_eai_V1 - ) - return per_date_eai - - ### Fully interpolated metrics ### - - @lazy_property - def per_date_eai(self) -> np.ndarray: - """Expected annual impacts per date with changing exposure, changing hazard and changing vulnerability""" - return self.calc_eai() - - @lazy_property - def per_date_aai(self) -> np.ndarray: - """Average annual impacts per date with changing exposure, changing hazard and changing vulnerability.""" - return calc_per_date_aais(self.per_date_eai) - - @lazy_property - def eai_gdf(self) -> pd.DataFrame: - """Convenience function returning a DataFrame (with both datetime and coordinates ids) from `per_date_eai`. - - This dataframe can easily be merged with one of the snapshot exposure geodataframe. - - Notes - ----- - - The DataFrame from the starting snapshot is used as a basis (notably for `value` and `group_id`). - - """ - return self.calc_eai_gdf() - - #################################### - - ### Metrics from impact matrices ### - - # These methods might go in a utils file instead, to be reused - # for a no interpolation case (and maybe the timeseries?) - - #################################### - - def calc_eai_gdf(self) -> pd.DataFrame: - """Merge the per date EAIs of the risk period with the GeoDataframe of the exposure of the starting snapshot.""" - df = pd.DataFrame(self.per_date_eai, index=self.date_idx) - df = df.reset_index().melt( - id_vars=DEFAULT_PERIOD_INDEX_NAME, - var_name=COORD_ID_COL_NAME, - value_name=RISK_COL_NAME, - ) - if GROUP_ID_COL_NAME in self.snapshot_start.exposure.gdf: - eai_gdf = self.snapshot_start.exposure.gdf[[GROUP_ID_COL_NAME]] - eai_gdf[COORD_ID_COL_NAME] = eai_gdf.index - eai_gdf = eai_gdf.merge(df, on=COORD_ID_COL_NAME) - eai_gdf = eai_gdf.rename(columns={GROUP_ID_COL_NAME: GROUP_COL_NAME}) - else: - eai_gdf = df - eai_gdf[GROUP_COL_NAME] = pd.NA - - eai_gdf[GROUP_COL_NAME] = pd.Categorical( - eai_gdf[GROUP_COL_NAME], categories=self._groups_id - ) - eai_gdf[METRIC_COL_NAME] = EAI_METRIC_NAME - eai_gdf[MEASURE_COL_NAME] = ( - self.measure.name if self.measure else NO_MEASURE_VALUE - ) - eai_gdf[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit - return eai_gdf - - def calc_aai_metric(self) -> pd.DataFrame: - """Compute a DataFrame of the AAI at each dates of the risk period (including changes in exposure, hazard and vulnerability).""" - aai_df = pd.DataFrame( - index=self.date_idx, columns=[RISK_COL_NAME], data=self.per_date_aai - ) - aai_df[GROUP_COL_NAME] = pd.Categorical( - [pd.NA] * len(aai_df), categories=self._groups_id - ) - aai_df[METRIC_COL_NAME] = AAI_METRIC_NAME - aai_df[MEASURE_COL_NAME] = ( - self.measure.name if self.measure else NO_MEASURE_VALUE - ) - aai_df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit - aai_df.reset_index(inplace=True) - return aai_df - - def calc_aai_per_group_metric(self) -> pd.DataFrame | None: - """Compute a DataFrame of the AAI distinguised per group id in the exposures, at each dates of the risk period (including changes in exposure, hazard and vulnerability). - - Notes - ----- - - If group ids changes between starting and ending snapshots of the risk period, the AAIs are linearly interpolated (with a warning for transparency). - - """ - if len(self._group_id_E0) < 1 or len(self._group_id_E1) < 1: - LOGGER.warning( - "No group id defined in at least one of the Exposures object. Per group aai will be empty." - ) - return None - - eai_pres_groups = self.eai_gdf[ - [ - DEFAULT_PERIOD_INDEX_NAME, - COORD_ID_COL_NAME, - GROUP_COL_NAME, - RISK_COL_NAME, - ] - ].copy() - aai_per_group_df = eai_pres_groups.groupby( - [DEFAULT_PERIOD_INDEX_NAME, GROUP_COL_NAME], as_index=False, observed=True - )[RISK_COL_NAME].sum() - if not np.array_equal(self._group_id_E0, self._group_id_E1): - LOGGER.warning( - "Group id are changing between present and future snapshot. Per group AAI will be linearly interpolated." - ) - eai_fut_groups = self.eai_gdf.copy() - eai_fut_groups[GROUP_COL_NAME] = pd.Categorical( - np.tile(self._group_id_E1, len(self.date_idx)), - categories=self._groups_id, - ) - aai_fut_groups = eai_fut_groups.groupby( - [DEFAULT_PERIOD_INDEX_NAME, GROUP_COL_NAME], as_index=False - )[RISK_COL_NAME].sum() - aai_per_group_df[RISK_COL_NAME] = linear_interp_arrays( - aai_per_group_df[RISK_COL_NAME].values, - aai_fut_groups[RISK_COL_NAME].values, - ) - - aai_per_group_df[METRIC_COL_NAME] = AAI_METRIC_NAME - aai_per_group_df[MEASURE_COL_NAME] = ( - self.measure.name if self.measure else NO_MEASURE_VALUE - ) - aai_per_group_df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit - return aai_per_group_df - - def calc_return_periods_metric(self, return_periods: list[int]) -> pd.DataFrame: - """Compute a DataFrame of the estimated impacts for a list of return - periods, at each dates of the risk period (including changes in exposure, - hazard and vulnerability). - - Parameters - ---------- - - return_periods : list of int - The return periods to estimate impacts for. - - """ - - # currently mathematicaly wrong, but approximatively correct, to be reworked when concatenating the impact matrices for the interpolation - per_date_rp_H0V0, per_date_rp_H1V0, per_date_rp_H0V1, per_date_rp_H1V1 = ( - self.per_date_return_periods_H0V0(return_periods), - self.per_date_return_periods_H1V0(return_periods), - self.per_date_return_periods_H0V1(return_periods), - self.per_date_return_periods_H1V1(return_periods), - ) - per_date_rp_V0 = self.interpolation_strategy.interp_over_hazard_dim( - per_date_rp_H0V0, per_date_rp_H1V0 - ) - per_date_rp_V1 = self.interpolation_strategy.interp_over_hazard_dim( - per_date_rp_H0V1, per_date_rp_H1V1 - ) - per_date_rp = self.interpolation_strategy.interp_over_vulnerability_dim( - per_date_rp_V0, per_date_rp_V1 - ) - rp_df = pd.DataFrame( - index=self.date_idx, columns=return_periods, data=per_date_rp - ).melt(value_name=RISK_COL_NAME, var_name="rp", ignore_index=False) - rp_df.reset_index(inplace=True) - rp_df[GROUP_COL_NAME] = pd.Categorical( - [pd.NA] * len(rp_df), categories=self._groups_id - ) - rp_df[METRIC_COL_NAME] = RP_VALUE_PREFIX + "_" + rp_df["rp"].astype(str) - rp_df = rp_df.drop("rp", axis=1) - rp_df[MEASURE_COL_NAME] = ( - self.measure.name if self.measure else NO_MEASURE_VALUE - ) - rp_df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit - return rp_df - - def calc_risk_contributions_metric(self) -> pd.DataFrame: - """Compute a DataFrame of the individual contributions of risk (impact), - at each dates of the risk period (including changes in exposure, - hazard and vulnerability). - - """ - per_date_aai_E0V0 = self.interpolation_strategy.interp_over_hazard_dim( - self.per_date_aai_E0H0V0, self.per_date_aai_E0H1V0 - ) - per_date_aai_E0H0 = self.interpolation_strategy.interp_over_vulnerability_dim( - self.per_date_aai_E0H0V0, self.per_date_aai_E0H0V1 - ) - df = pd.DataFrame( - { - CONTRIBUTION_TOTAL_RISK_NAME: self.per_date_aai, - CONTRIBUTION_BASE_RISK_NAME: self.per_date_aai[0], - CONTRIBUTION_EXPOSURE_NAME: self.per_date_aai_H0V0 - - self.per_date_aai[0], - CONTRIBUTION_HAZARD_NAME: per_date_aai_E0V0 - # - (self.per_date_aai_H0V0 - self.per_date_aai[0]) - - self.per_date_aai[0], - CONTRIBUTION_VULNERABILITY_NAME: per_date_aai_E0H0 - - self.per_date_aai[0], - # - (self.per_date_aai_H0V0 - self.per_date_aai[0]), - }, - index=self.date_idx, - ) - df[CONTRIBUTION_INTERACTION_TERM_NAME] = df[CONTRIBUTION_TOTAL_RISK_NAME] - ( - df[CONTRIBUTION_BASE_RISK_NAME] - + df[CONTRIBUTION_EXPOSURE_NAME] - + df[CONTRIBUTION_HAZARD_NAME] - + df[CONTRIBUTION_VULNERABILITY_NAME] - ) - df = df.melt( - value_vars=[ - CONTRIBUTION_BASE_RISK_NAME, - CONTRIBUTION_EXPOSURE_NAME, - CONTRIBUTION_HAZARD_NAME, - CONTRIBUTION_VULNERABILITY_NAME, - CONTRIBUTION_INTERACTION_TERM_NAME, - ], - var_name=METRIC_COL_NAME, - value_name=RISK_COL_NAME, - ignore_index=False, - ) - df.reset_index(inplace=True) - df[GROUP_COL_NAME] = pd.Categorical( - [pd.NA] * len(df), categories=self._groups_id - ) - df[MEASURE_COL_NAME] = self.measure.name if self.measure else NO_MEASURE_VALUE - df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit - return df - - def apply_measure(self, measure: Measure) -> "CalcRiskMetricsPeriod": - """Creates a new `CalcRiskMetricsPeriod` object with a measure. - - The given measure is applied to both snapshot of the risk period. - - Parameters - ---------- - measure : Measure - The measure to apply. - - Returns - ------- - - CalcRiskPeriod - The risk period with given measure applied. - - """ - snap0 = self.snapshot_start.apply_measure(measure) - snap1 = self.snapshot_end.apply_measure(measure) - - risk_period = CalcRiskMetricsPeriod( - snap0, - snap1, - self.time_resolution, - self.interpolation_strategy, - self.impact_computation_strategy, - ) - - risk_period.measure = measure - return risk_period - - -def calc_per_date_eais(imp_mats: list[csr_matrix], frequency: np.ndarray) -> np.ndarray: - """Calculate expected average impact (EAI) values from a list of impact matrices - corresponding to impacts at different dates (with possible changes along - exposure, hazard and vulnerability). - - Parameters - ---------- - imp_mats : list of np.ndarray - List of impact matrices. - frequency : np.ndarray - Hazard frequency values. - - Returns - ------- - np.ndarray - 2D array of EAI (1D) for each dates. - - """ - per_date_eai_exp = np.array( - [ImpactCalc.eai_exp_from_mat(imp_mat, frequency) for imp_mat in imp_mats] - ) - return per_date_eai_exp - - -def calc_per_date_aais(per_date_eai_exp: np.ndarray) -> np.ndarray: - """Calculate per_date aggregate annual impact (AAI) values - resulting from a list arrays corresponding to EAI at different - dates (with possible changes along exposure, hazard and vulnerability). - - Parameters - ---------- - per_date_eai_exp: np.ndarray - EAIs arrays. - - Returns - ------- - np.ndarray - 1D array of AAI (0D) for each dates. - """ - per_date_aai = np.array( - [ImpactCalc.aai_agg_from_eai_exp(eai_exp) for eai_exp in per_date_eai_exp] - ) - return per_date_aai - - -def calc_per_date_rps( - imp_mats: list[csr_matrix], - frequency: np.ndarray, - frequency_unit: str, - return_periods: list[int], -) -> np.ndarray: - """Calculate per date return period impact values from a - list of impact matrices corresponding to impacts at different - dates (with possible changes along exposure, hazard and vulnerability). - - Parameters - ---------- - imp_mats: list of scipy.crs_matrix - List of impact matrices. - frequency: np.ndarray - Frequency values. - return_periods : list of int - Return periods to calculate impact values for. - - Returns - ------- - np.ndarray - 2D array of impacts per return periods (1D) for each dates. - - """ - rp = np.array( - [ - calc_freq_curve(imp_mat, frequency, frequency_unit, return_periods).impact - for imp_mat in imp_mats - ] - ) - return rp - - -def calc_freq_curve( - imp_mat_intrpl, frequency, frequency_unit, return_per=None -) -> ImpactFreqCurve: - """Calculate the estimated impacts for given return periods. - - Parameters - ---------- - - imp_mat_intrpl: scipy.csr_matrix - An impact matrix. - frequency: np.ndarray - The frequency of the hazard. - return_per: np.ndarray - The return periods to compute impacts for. - - Returns - ------- - np.ndarray - The estimated impacts for the different return periods. - - """ - - at_event = np.sum(imp_mat_intrpl, axis=1).A1 - - # Sort descendingly the impacts per events - sort_idxs = np.argsort(at_event)[::-1] - # Calculate exceedence frequency - exceed_freq = np.cumsum(frequency[sort_idxs]) - # Set return period and impact exceeding frequency - ifc_return_per = 1 / exceed_freq[::-1] - ifc_impact = at_event[sort_idxs][::-1] - - if return_per is not None: - interp_imp = np.interp(return_per, ifc_return_per, ifc_impact) - ifc_return_per = return_per - ifc_impact = interp_imp - - return ImpactFreqCurve( - return_per=ifc_return_per, - impact=ifc_impact, - frequency_unit=frequency_unit, - label="Exceedance frequency curve", - ) diff --git a/climada/trajectories/static_trajectory.py b/climada/trajectories/static_trajectory.py new file mode 100644 index 0000000000..73944b6639 --- /dev/null +++ b/climada/trajectories/static_trajectory.py @@ -0,0 +1,316 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +This file implements \"static\" risk trajectory objects, for an easier evaluation +of risk at multiple points in time (snapshots). + +""" + +import logging + +import pandas as pd + +from climada.entity.disc_rates.base import DiscRates +from climada.trajectories.constants import ( + AAI_METRIC_NAME, + AAI_PER_GROUP_METRIC_NAME, + COORD_ID_COL_NAME, + DATE_COL_NAME, + EAI_METRIC_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + RETURN_PERIOD_METRIC_NAME, + RISK_COL_NAME, + RP_VALUE_PREFIX, +) +from climada.trajectories.impact_calc_strat import ( + ImpactCalcComputation, + ImpactComputationStrategy, +) +from climada.trajectories.riskperiod import CalcRiskMetricsPoints +from climada.trajectories.snapshot import Snapshot +from climada.trajectories.trajectory import ( + DEFAULT_ALLGROUP_NAME, + DEFAULT_DF_COLUMN_PRIORITY, + DEFAULT_RP, + RiskTrajectory, +) +from climada.util import log_level +from climada.util.dataframe_handling import reorder_dataframe_columns + +LOGGER = logging.getLogger(__name__) + +__all__ = ["StaticRiskTrajectory"] + + +class StaticRiskTrajectory(RiskTrajectory): + """This class implements static risk trajectories, objects that + regroup impacts computations for multiple dates. + + This class computes risk metrics over a series of snapshots, + optionally applying risk discounting. It does not interpolate risk + between the snapshot and only provides results for each snapshot. + + """ + + POSSIBLE_METRICS = [ + EAI_METRIC_NAME, + AAI_METRIC_NAME, + RETURN_PERIOD_METRIC_NAME, + AAI_PER_GROUP_METRIC_NAME, + ] + """Class variable listing the risk metrics that can be computed. + + Currently: + + - eai, expected impact (per exposure point within a period of 1/frequency unit of the hazard object) + - aai, average annual impact (aggregated eai over the whole exposure) + - aai_per_group, average annual impact per exposure subgroup (defined from the exposure geodataframe) + - return_periods, estimated impacts aggregated over the whole exposure for different return periods + """ + + _DEFAULT_ALL_METRICS = [ + AAI_METRIC_NAME, + RETURN_PERIOD_METRIC_NAME, + AAI_PER_GROUP_METRIC_NAME, + ] + + def __init__( + self, + snapshots_list: list[Snapshot], + *, + return_periods: list[int] = DEFAULT_RP, + all_groups_name: str = DEFAULT_ALLGROUP_NAME, + risk_disc_rates: DiscRates | None = None, + impact_computation_strategy: ImpactComputationStrategy | None = None, + ): + """Initialize a new `StaticRiskTrajectory`. + + Parameters + ---------- + snapshots_list : list[Snapshot] + The list of `Snapshot` object to compute risk from. + return_periods: list[int], optional + The return periods to use when computing the `return_periods_metric`. + Defaults to `DEFAULT_RP` ([20, 50, 100]). + all_groups_name: str, optional + The string to use to define all exposure points subgroup. + Defaults to `DEFAULT_ALLGROUP_NAME` ("All"). + risk_disc_rates: DiscRates, optional + The discount rate to apply to future risk. Defaults to None. + impact_computation_strategy: ImpactComputationStrategy, optional + The method used to calculate the impact from the (Haz,Exp,Vul) + of the two snapshots. Defaults to :class:`ImpactCalcComputation`. + + """ + super().__init__( + snapshots_list, + return_periods=return_periods, + all_groups_name=all_groups_name, + risk_disc_rates=risk_disc_rates, + ) + self._risk_metrics_calculators = CalcRiskMetricsPoints( + self._snapshots, + impact_computation_strategy=impact_computation_strategy + or ImpactCalcComputation(), + ) + + @property + def impact_computation_strategy(self) -> ImpactComputationStrategy: + """The approach or strategy used to calculate the impact from the snapshots.""" + return self._risk_metrics_calculators.impact_computation_strategy + + @impact_computation_strategy.setter + def impact_computation_strategy(self, value, /): + if not isinstance(value, ImpactComputationStrategy): + raise ValueError("Not an interpolation strategy") + + self._reset_metrics() + self._risk_metrics_calculators.impact_computation_strategy = value + + def _generic_metrics( + self, + metric_name: str | None = None, + metric_meth: str | None = None, + **kwargs, + ) -> pd.DataFrame: + """Generic method to compute metrics based on the provided metric name and method. + + This method calls the appropriate method from the calculator to return + the results for the given metric, in a tidy formatted dataframe. + + It first checks whether the requested metric is a valid one. + Then looks for a possible cached value and otherwised asks the + calculators (`self._risk_metric_calculators`) to run the computation. + The results are then regrouped in a nice and tidy DataFrame. + If a `risk_disc_rates` was set, values are converted to net present values. + Results are then cached within `self.__metrics` and returned. + + Parameters + ---------- + metric_name : str, optional + The name of the metric to return results for. + metric_meth : str, optional + The name of the specific method of the calculator to call. + + Returns + ------- + pd.DataFrame + A tidy formatted dataframe of the risk metric computed for the + different snapshots. + + Raises + ------ + NotImplementedError + If the requested metric is not part of `POSSIBLE_METRICS`. + ValueError + If either of the arguments are not provided. + + """ + if metric_name is None or metric_meth is None: + raise ValueError("Both metric_name and metric_meth must be provided.") + + if metric_name not in self.POSSIBLE_METRICS: + raise NotImplementedError( + f"{metric_name} not implemented ({self.POSSIBLE_METRICS})." + ) + + # Construct the attribute name for storing the metric results + attr_name = f"_{metric_name}_metrics" + + if getattr(self, attr_name) is not None: + LOGGER.debug(f"Returning cached {attr_name}") + return getattr(self, attr_name) + + with log_level(level="WARNING", name_prefix="climada"): + tmp = getattr(self._risk_metrics_calculators, metric_meth)(**kwargs) + if tmp is None: + return tmp + + tmp = tmp.set_index( + [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME] + ) + if COORD_ID_COL_NAME in tmp.columns: + tmp = tmp.set_index([COORD_ID_COL_NAME], append=True) + + # When more than 2 snapshots, there might be duplicated rows, we need to remove them. + # Should not be the case in static trajectory, but in any case we really don't want + # duplicated rows, which would mess up some dataframe manipulation down the road. + tmp = tmp[~tmp.index.duplicated(keep="first")] + tmp = tmp.reset_index() + if self._all_groups_name not in tmp[GROUP_COL_NAME].cat.categories: + tmp[GROUP_COL_NAME] = tmp[GROUP_COL_NAME].cat.add_categories( + [self._all_groups_name] + ) + tmp[GROUP_COL_NAME] = tmp[GROUP_COL_NAME].fillna(self._all_groups_name) + + if self._risk_disc_rates: + tmp = self.npv_transform(tmp, self._risk_disc_rates) + + tmp = reorder_dataframe_columns(tmp, DEFAULT_DF_COLUMN_PRIORITY) + + setattr(self, attr_name, tmp) + return getattr(self, attr_name) + + def eai_metrics(self, **kwargs) -> pd.DataFrame: + """Return the estimated annual impacts at each exposure point for each date. + + This method computes and return a `DataFrame` with eai metric + (for each exposure point) for each date. + + Notes + ----- + + This computation may become quite expensive for big areas with high resolution. + + """ + df = self._compute_metrics( + metric_name=EAI_METRIC_NAME, metric_meth="calc_eai_gdf", **kwargs + ) + return df + + def aai_metrics(self, **kwargs) -> pd.DataFrame: + """Return the average annual impacts for each date. + + This method computes and return a `DataFrame` with aai metric for each date. + + """ + + return self._compute_metrics( + metric_name=AAI_METRIC_NAME, metric_meth="calc_aai_metric", **kwargs + ) + + def return_periods_metrics(self, **kwargs) -> pd.DataFrame: + """Return the estimated impacts for different return periods. + + Return periods to estimate impacts for are defined by `self.return_periods`. + + """ + return self._compute_metrics( + metric_name=RETURN_PERIOD_METRIC_NAME, + metric_meth="calc_return_periods_metric", + return_periods=self.return_periods, + **kwargs, + ) + + def aai_per_group_metrics(self, **kwargs) -> pd.DataFrame: + """Return the average annual impacts for each exposure group ID. + + This method computes and return a `DataFrame` with aai metric for each + of the exposure group defined by a group id, for each date. + + """ + + return self._compute_metrics( + metric_name=AAI_PER_GROUP_METRIC_NAME, + metric_meth="calc_aai_per_group_metric", + **kwargs, + ) + + def per_date_risk_metrics( + self, + metrics: list[str] | None = None, + ) -> pd.DataFrame | pd.Series: + """Returns a DataFrame of risk metrics for each dates. + + This methods collects (and if needed computes) the `metrics` + (Defaulting to AAI_METRIC_NAME, RETURN_PERIOD_METRIC_NAME and AAI_PER_GROUP_METRIC_NAME). + + Parameters + ---------- + metrics : list[str], optional + The list of metrics to return (defaults to + [AAI_METRIC_NAME,RETURN_PERIOD_METRIC_NAME,AAI_PER_GROUP_METRIC_NAME]) + + Returns + ------- + pd.DataFrame | pd.Series + A tidy DataFrame with metric values for all possible dates. + + """ + + metrics = ( + [AAI_METRIC_NAME, RETURN_PERIOD_METRIC_NAME, AAI_PER_GROUP_METRIC_NAME] + if metrics is None + else metrics + ) + return pd.concat( + [getattr(self, f"{metric}_metrics")() for metric in metrics], + ignore_index=True, + ) diff --git a/climada/trajectories/test/test_calc_risk_metrics.py b/climada/trajectories/test/test_calc_risk_metrics.py new file mode 100644 index 0000000000..493736d350 --- /dev/null +++ b/climada/trajectories/test/test_calc_risk_metrics.py @@ -0,0 +1,448 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +This modules implements different sparce matrices interpolation approaches. + +""" + +import unittest +from unittest.mock import MagicMock, call, patch + +import numpy as np +import pandas as pd + +# Assuming these are the necessary imports from climada +from climada.entity.exposures import Exposures +from climada.entity.impact_funcs import ImpactFuncSet +from climada.entity.impact_funcs.trop_cyclone import ImpfTropCyclone +from climada.entity.measures.base import Measure +from climada.hazard import Hazard +from climada.trajectories.calc_risk_metrics import CalcRiskMetricsPoints +from climada.trajectories.constants import ( + AAI_METRIC_NAME, + COORD_ID_COL_NAME, + DATE_COL_NAME, + EAI_METRIC_NAME, + GROUP_COL_NAME, + GROUP_ID_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + NO_MEASURE_VALUE, + RISK_COL_NAME, + UNIT_COL_NAME, +) + +# Import the CalcRiskPeriod class and other necessary classes/functions +from climada.trajectories.impact_calc_strat import ( + ImpactCalcComputation, + ImpactComputationStrategy, +) +from climada.trajectories.snapshot import Snapshot +from climada.util.constants import EXP_DEMO_H5, HAZ_DEMO_H5 + + +class TestCalcRiskMetricsPoints(unittest.TestCase): + def setUp(self): + # Create mock objects for testing + self.present_date = 2020 + self.future_date = 2025 + self.exposure_present = Exposures.from_hdf5(EXP_DEMO_H5) + self.exposure_present.gdf.rename(columns={"impf_": "impf_TC"}, inplace=True) + self.exposure_present.gdf["impf_TC"] = 1 + self.exposure_present.gdf[GROUP_ID_COL_NAME] = ( + self.exposure_present.gdf["value"] + > self.exposure_present.gdf["value"].mean() + ) * 1 + self.hazard_present = Hazard.from_hdf5(HAZ_DEMO_H5) + self.exposure_present.assign_centroids(self.hazard_present, distance="approx") + self.impfset_present = ImpactFuncSet([ImpfTropCyclone.from_emanuel_usa()]) + + self.exposure_future = Exposures.from_hdf5(EXP_DEMO_H5) + n_years = self.future_date - self.present_date + 1 + growth_rate = 1.02 + growth = growth_rate**n_years + self.exposure_future.gdf["value"] = self.exposure_future.gdf["value"] * growth + self.exposure_future.gdf.rename(columns={"impf_": "impf_TC"}, inplace=True) + self.exposure_future.gdf["impf_TC"] = 1 + self.exposure_future.gdf[GROUP_ID_COL_NAME] = ( + self.exposure_future.gdf["value"] > self.exposure_future.gdf["value"].mean() + ) * 1 + self.hazard_future = Hazard.from_hdf5(HAZ_DEMO_H5) + self.hazard_future.intensity *= 1.1 + self.exposure_future.assign_centroids(self.hazard_future, distance="approx") + self.impfset_future = ImpactFuncSet( + [ + ImpfTropCyclone.from_emanuel_usa(impf_id=1, v_half=60.0), + ] + ) + + self.measure = MagicMock(spec=Measure) + self.measure.name = "Test Measure" + + # Setup mock return values for measure.apply + self.measure_exposure = MagicMock(spec=Exposures) + self.measure_hazard = MagicMock(spec=Hazard) + self.measure_impfset = MagicMock(spec=ImpactFuncSet) + self.measure.apply.return_value = ( + self.measure_exposure, + self.measure_impfset, + self.measure_hazard, + ) + + # Create mock snapshots + self.mock_snapshot_start = Snapshot( + exposure=self.exposure_present, + hazard=self.hazard_present, + impfset=self.impfset_present, + date=self.present_date, + ) + self.mock_snapshot_end = Snapshot( + exposure=self.exposure_future, + hazard=self.hazard_future, + impfset=self.impfset_future, + date=self.future_date, + ) + + # Create an instance of CalcRiskPeriod + self.calc_risk_metrics_points = CalcRiskMetricsPoints( + [self.mock_snapshot_start, self.mock_snapshot_end], + impact_computation_strategy=ImpactCalcComputation(), + ) + + self.expected_eai = np.array( + [ + [ + 8702904.63375606, + 7870925.19290905, + 1805021.12653289, + 3827196.02428828, + 5815346.97427834, + 7870925.19290905, + 7871847.53906951, + 7870925.19290905, + 7886487.76136572, + 7870925.19290905, + 7876058.84500811, + 3858228.67061225, + 8401461.85304853, + 9210350.19520265, + 1806363.23553602, + 6922250.59852326, + 6711006.70101515, + 6886568.00391817, + 6703749.80009753, + 6704689.17531993, + 6703401.93516038, + 6818839.81873556, + 6716262.5286998, + 6703369.87656195, + 6703952.06070945, + 5678897.05935781, + 4984034.77073219, + 6708908.84462217, + 6702586.9472999, + 4961843.43826371, + 5139913.92380089, + 5255310.96072403, + 4981705.85074492, + 4926529.74583162, + 4973726.6063121, + 4926015.68274236, + 4937618.79350358, + 4926144.19851468, + 4926015.68274236, + 9575288.06765627, + 5100904.22956578, + 3501325.10900064, + 5093920.89144773, + 3505527.05928994, + 4002552.92232482, + 3512012.80001039, + 3514993.26161994, + 3562009.79687436, + 3869298.39771648, + 3509317.94922485, + ], + [ + 46651387.10647343, + 42191612.28496882, + 14767621.68800634, + 24849532.38841432, + 32260334.11128166, + 42191612.28496882, + 42196556.46505447, + 42191612.28496882, + 42275034.47974126, + 42191612.28496882, + 42219130.91253302, + 24227735.90988531, + 45035521.54835925, + 49371517.94999501, + 14778602.03484606, + 39909758.65668079, + 38691846.52720026, + 39834520.43061425, + 38650007.36519716, + 38655423.2682883, + 38648001.77388126, + 39313550.93419428, + 38722148.63941796, + 38647816.9422419, + 38651173.48481285, + 33700748.42359267, + 30195870.8789255, + 38679751.48077733, + 38643303.01755095, + 30061424.26274527, + 31140267.73715352, + 31839402.91317674, + 30181761.07222111, + 29847475.57538872, + 30133418.66577969, + 29844361.11423809, + 29914658.78479145, + 29845139.72952577, + 29844361.11423809, + 58012067.61585025, + 30903926.75151934, + 23061159.87895984, + 33550647.3781805, + 23088835.64296583, + 26362451.35547444, + 23131553.38525813, + 23151183.92499699, + 23460854.06493051, + 24271571.95828693, + 23113803.99527559, + ], + ] + ) + + self.expected_aai = np.array([2.88895461e08, 1.69310367e09]) + self.expected_aai_per_group = np.array( + [2.33513758e08, 5.53817034e07, 1.37114041e09, 3.21963264e08] + ) + self.expected_return_period_metric = np.array( + [ + 0.00000000e00, + 0.00000000e00, + 7.10925472e09, + 4.53975437e10, + 1.36547014e10, + 7.69981714e10, + ] + ) + + def test_reset_impact_data(self): + self.calc_risk_metrics_points._impacts = "A" # type:ignore + self.calc_risk_metrics_points._eai_gdf = "B" # type:ignore + self.calc_risk_metrics_points._per_date_eai = "C" # type:ignore + self.calc_risk_metrics_points._per_date_aai = "D" # type:ignore + self.calc_risk_metrics_points._reset_impact_data() + self.assertIsNone(self.calc_risk_metrics_points._impacts) + self.assertIsNone(self.calc_risk_metrics_points._eai_gdf) + self.assertIsNone(self.calc_risk_metrics_points._per_date_aai) + self.assertIsNone(self.calc_risk_metrics_points._per_date_eai) + + def test_set_impact_computation_strategy(self): + new_impact_computation_strategy = MagicMock(spec=ImpactComputationStrategy) + self.calc_risk_metrics_points.impact_computation_strategy = ( + new_impact_computation_strategy + ) + self.assertEqual( + self.calc_risk_metrics_points.impact_computation_strategy, + new_impact_computation_strategy, + ) + + def test_set_impact_computation_strategy_wtype(self): + with self.assertRaises(ValueError): + self.calc_risk_metrics_points.impact_computation_strategy = "A" + + @patch.object(CalcRiskMetricsPoints, "impact_computation_strategy") + def test_impacts_arrays(self, mock_impact_compute): + mock_impact_compute.compute_impacts.side_effect = ["A", "B"] + results = self.calc_risk_metrics_points.impacts + mock_impact_compute.compute_impacts.assert_has_calls( + [ + call( + self.mock_snapshot_start.exposure, + self.mock_snapshot_start.hazard, + self.mock_snapshot_start.impfset, + ), + call( + self.mock_snapshot_end.exposure, + self.mock_snapshot_end.hazard, + self.mock_snapshot_end.impfset, + ), + ] + ) + self.assertEqual(results, ["A", "B"]) + + def test_per_date_eai(self): + np.testing.assert_allclose( + self.calc_risk_metrics_points.per_date_eai, self.expected_eai + ) + + def test_per_date_aai(self): + np.testing.assert_allclose( + self.calc_risk_metrics_points.per_date_aai, + self.expected_aai, + ) + + def test_eai_gdf(self): + result_gdf = self.calc_risk_metrics_points.calc_eai_gdf() + self.assertIsInstance(result_gdf, pd.DataFrame) + self.assertEqual( + result_gdf.shape[0], + len(self.mock_snapshot_start.exposure.gdf) + + len(self.mock_snapshot_end.exposure.gdf), + ) + expected_columns = [ + DATE_COL_NAME, + COORD_ID_COL_NAME, + GROUP_COL_NAME, + RISK_COL_NAME, + METRIC_COL_NAME, + MEASURE_COL_NAME, + UNIT_COL_NAME, + ] + self.assertTrue( + all(col in list(result_gdf.columns) for col in expected_columns) + ) + np.testing.assert_allclose( + np.array(result_gdf[RISK_COL_NAME].values), self.expected_eai.flatten() + ) + # Check constants and column transformations + self.assertEqual(result_gdf[METRIC_COL_NAME].unique(), EAI_METRIC_NAME) + self.assertEqual(result_gdf[MEASURE_COL_NAME].iloc[0], NO_MEASURE_VALUE) + self.assertEqual( + result_gdf[UNIT_COL_NAME].iloc[0], + self.mock_snapshot_start.exposure.value_unit, + ) + self.assertEqual(result_gdf[GROUP_COL_NAME].dtype.name, "category") + self.assertListEqual( + list(result_gdf[GROUP_COL_NAME].cat.categories), + list(self.calc_risk_metrics_points._group_id), + ) + + def test_calc_aai_metric(self): + result_df = self.calc_risk_metrics_points.calc_aai_metric() + self.assertIsInstance(result_df, pd.DataFrame) + self.assertEqual( + result_df.shape[0], len(self.calc_risk_metrics_points.snapshots) + ) + expected_columns = [ + DATE_COL_NAME, + GROUP_COL_NAME, + RISK_COL_NAME, + METRIC_COL_NAME, + MEASURE_COL_NAME, + UNIT_COL_NAME, + ] + self.assertTrue(all(col in result_df.columns for col in expected_columns)) + np.testing.assert_allclose( + np.array(result_df[RISK_COL_NAME].values), self.expected_aai + ) + # Check constants and column transformations + self.assertEqual(result_df[METRIC_COL_NAME].unique(), AAI_METRIC_NAME) + self.assertEqual(result_df[MEASURE_COL_NAME].iloc[0], NO_MEASURE_VALUE) + self.assertEqual( + result_df[UNIT_COL_NAME].iloc[0], + self.mock_snapshot_start.exposure.value_unit, + ) + self.assertEqual(result_df[GROUP_COL_NAME].dtype.name, "category") + + def test_calc_aai_per_group_metric(self): + result_df = self.calc_risk_metrics_points.calc_aai_per_group_metric() + self.assertIsInstance(result_df, pd.DataFrame) + self.assertEqual( + result_df.shape[0], + len(self.calc_risk_metrics_points.snapshots) + * len(self.calc_risk_metrics_points._group_id), + ) + expected_columns = [ + DATE_COL_NAME, + GROUP_COL_NAME, + RISK_COL_NAME, + METRIC_COL_NAME, + MEASURE_COL_NAME, + UNIT_COL_NAME, + ] + self.assertTrue(all(col in result_df.columns for col in expected_columns)) + np.testing.assert_allclose( + np.array(result_df[RISK_COL_NAME].values), self.expected_aai_per_group + ) + # Check constants and column transformations + self.assertEqual(result_df[METRIC_COL_NAME].unique(), AAI_METRIC_NAME) + self.assertEqual(result_df[MEASURE_COL_NAME].iloc[0], NO_MEASURE_VALUE) + self.assertEqual( + result_df[UNIT_COL_NAME].iloc[0], + self.mock_snapshot_start.exposure.value_unit, + ) + self.assertEqual(result_df[GROUP_COL_NAME].dtype.name, "category") + self.assertListEqual(list(result_df[GROUP_COL_NAME].unique()), [0, 1]) + + def test_calc_return_periods_metric(self): + result_df = self.calc_risk_metrics_points.calc_return_periods_metric( + [20, 50, 100] + ) + self.assertIsInstance(result_df, pd.DataFrame) + self.assertEqual( + result_df.shape[0], len(self.calc_risk_metrics_points.snapshots) * 3 + ) + expected_columns = [ + DATE_COL_NAME, + GROUP_COL_NAME, + RISK_COL_NAME, + METRIC_COL_NAME, + MEASURE_COL_NAME, + UNIT_COL_NAME, + ] + self.assertTrue(all(col in result_df.columns for col in expected_columns)) + np.testing.assert_allclose( + np.array(result_df[RISK_COL_NAME].values), + self.expected_return_period_metric, + ) + # Check constants and column transformations + self.assertListEqual( + list(result_df[METRIC_COL_NAME].unique()), ["rp_20", "rp_50", "rp_100"] + ) + self.assertEqual(result_df[MEASURE_COL_NAME].iloc[0], NO_MEASURE_VALUE) + self.assertEqual( + result_df[UNIT_COL_NAME].iloc[0], + self.mock_snapshot_start.exposure.value_unit, + ) + self.assertEqual(result_df[GROUP_COL_NAME].dtype.name, "category") + + @patch.object(Snapshot, "apply_measure") + @patch("climada.trajectories.riskperiod.CalcRiskMetricsPoints") + def test_apply_measure(self, mock_CalcRiskMetricPoints, mock_snap_apply_measure): + mock_CalcRiskMetricPoints.return_value = MagicMock(spec=CalcRiskMetricsPoints) + mock_snap_apply_measure.return_value = 42 + result = self.calc_risk_metrics_points.apply_measure(self.measure) + mock_snap_apply_measure.assert_called_with(self.measure) + mock_CalcRiskMetricPoints.assert_called_with( + [42, 42], + self.calc_risk_metrics_points.impact_computation_strategy, + ) + self.assertEqual(result.measure, self.measure) + + +if __name__ == "__main__": + TESTS = unittest.TestLoader().loadTestsFromTestCase(TestCalcRiskMetricsPoints) + unittest.TextTestRunner(verbosity=2).run(TESTS) diff --git a/climada/trajectories/test/test_riskperiod.py b/climada/trajectories/test/test_riskperiod.py deleted file mode 100644 index 8ae328109d..0000000000 --- a/climada/trajectories/test/test_riskperiod.py +++ /dev/null @@ -1,1389 +0,0 @@ -""" -This file is part of CLIMADA. - -Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. - -CLIMADA is free software: you can redistribute it and/or modify it under the -terms of the GNU General Public License as published by the Free -Software Foundation, version 3. - -CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY -WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A -PARTICULAR PURPOSE. See the GNU General Public License for more details. - -You should have received a copy of the GNU General Public License along -with CLIMADA. If not, see . - ---- - -This modules implements different sparce matrices interpolation approaches. - -""" - -import types -import unittest -from unittest.mock import MagicMock, call, patch - -import geopandas as gpd -import numpy as np -import pandas as pd -from scipy.sparse import csr_matrix, issparse -from shapely import Point - -# Assuming these are the necessary imports from climada -from climada.entity.exposures import Exposures -from climada.entity.impact_funcs import ImpactFuncSet -from climada.entity.impact_funcs.trop_cyclone import ImpfTropCyclone -from climada.entity.measures.base import Measure -from climada.hazard import Hazard -from climada.trajectories.constants import ( - AAI_METRIC_NAME, - CONTRIBUTION_BASE_RISK_NAME, - CONTRIBUTION_EXPOSURE_NAME, - CONTRIBUTION_HAZARD_NAME, - CONTRIBUTION_INTERACTION_TERM_NAME, - CONTRIBUTION_VULNERABILITY_NAME, - COORD_ID_COL_NAME, - DATE_COL_NAME, - EAI_METRIC_NAME, - GROUP_COL_NAME, - GROUP_ID_COL_NAME, - MEASURE_COL_NAME, - METRIC_COL_NAME, - NO_MEASURE_VALUE, - RISK_COL_NAME, - UNIT_COL_NAME, -) - -# Import the CalcRiskPeriod class and other necessary classes/functions -from climada.trajectories.impact_calc_strat import ( - ImpactCalcComputation, - ImpactComputationStrategy, -) -from climada.trajectories.interpolation import ( - AllLinearStrategy, - InterpolationStrategyBase, -) -from climada.trajectories.riskperiod import ( - CalcRiskMetricsPeriod, - CalcRiskMetricsPoints, - calc_freq_curve, - calc_per_date_aais, - calc_per_date_eais, - calc_per_date_rps, -) -from climada.trajectories.snapshot import Snapshot -from climada.util.constants import EXP_DEMO_H5, HAZ_DEMO_H5 - - -class TestCalcRiskMetricsPoints(unittest.TestCase): - def setUp(self): - # Create mock objects for testing - self.present_date = 2020 - self.future_date = 2025 - self.exposure_present = Exposures.from_hdf5(EXP_DEMO_H5) - self.exposure_present.gdf.rename(columns={"impf_": "impf_TC"}, inplace=True) - self.exposure_present.gdf["impf_TC"] = 1 - self.exposure_present.gdf[GROUP_ID_COL_NAME] = ( - self.exposure_present.gdf["value"] - > self.exposure_present.gdf["value"].mean() - ) * 1 - self.hazard_present = Hazard.from_hdf5(HAZ_DEMO_H5) - self.exposure_present.assign_centroids(self.hazard_present, distance="approx") - self.impfset_present = ImpactFuncSet([ImpfTropCyclone.from_emanuel_usa()]) - - self.exposure_future = Exposures.from_hdf5(EXP_DEMO_H5) - n_years = self.future_date - self.present_date + 1 - growth_rate = 1.02 - growth = growth_rate**n_years - self.exposure_future.gdf["value"] = self.exposure_future.gdf["value"] * growth - self.exposure_future.gdf.rename(columns={"impf_": "impf_TC"}, inplace=True) - self.exposure_future.gdf["impf_TC"] = 1 - self.exposure_future.gdf[GROUP_ID_COL_NAME] = ( - self.exposure_future.gdf["value"] > self.exposure_future.gdf["value"].mean() - ) * 1 - self.hazard_future = Hazard.from_hdf5(HAZ_DEMO_H5) - self.hazard_future.intensity *= 1.1 - self.exposure_future.assign_centroids(self.hazard_future, distance="approx") - self.impfset_future = ImpactFuncSet( - [ - ImpfTropCyclone.from_emanuel_usa(impf_id=1, v_half=60.0), - ] - ) - - self.measure = MagicMock(spec=Measure) - self.measure.name = "Test Measure" - - # Setup mock return values for measure.apply - self.measure_exposure = MagicMock(spec=Exposures) - self.measure_hazard = MagicMock(spec=Hazard) - self.measure_impfset = MagicMock(spec=ImpactFuncSet) - self.measure.apply.return_value = ( - self.measure_exposure, - self.measure_impfset, - self.measure_hazard, - ) - - # Create mock snapshots - self.mock_snapshot_start = Snapshot( - exposure=self.exposure_present, - hazard=self.hazard_present, - impfset=self.impfset_present, - date=self.present_date, - ) - self.mock_snapshot_end = Snapshot( - exposure=self.exposure_future, - hazard=self.hazard_future, - impfset=self.impfset_future, - date=self.future_date, - ) - - # Create an instance of CalcRiskPeriod - self.calc_risk_metrics_points = CalcRiskMetricsPoints( - [self.mock_snapshot_start, self.mock_snapshot_end], - impact_computation_strategy=ImpactCalcComputation(), - ) - - self.expected_eai = np.array( - [ - [ - 8702904.63375606, - 7870925.19290905, - 1805021.12653289, - 3827196.02428828, - 5815346.97427834, - 7870925.19290905, - 7871847.53906951, - 7870925.19290905, - 7886487.76136572, - 7870925.19290905, - 7876058.84500811, - 3858228.67061225, - 8401461.85304853, - 9210350.19520265, - 1806363.23553602, - 6922250.59852326, - 6711006.70101515, - 6886568.00391817, - 6703749.80009753, - 6704689.17531993, - 6703401.93516038, - 6818839.81873556, - 6716262.5286998, - 6703369.87656195, - 6703952.06070945, - 5678897.05935781, - 4984034.77073219, - 6708908.84462217, - 6702586.9472999, - 4961843.43826371, - 5139913.92380089, - 5255310.96072403, - 4981705.85074492, - 4926529.74583162, - 4973726.6063121, - 4926015.68274236, - 4937618.79350358, - 4926144.19851468, - 4926015.68274236, - 9575288.06765627, - 5100904.22956578, - 3501325.10900064, - 5093920.89144773, - 3505527.05928994, - 4002552.92232482, - 3512012.80001039, - 3514993.26161994, - 3562009.79687436, - 3869298.39771648, - 3509317.94922485, - ], - [ - 46651387.10647343, - 42191612.28496882, - 14767621.68800634, - 24849532.38841432, - 32260334.11128166, - 42191612.28496882, - 42196556.46505447, - 42191612.28496882, - 42275034.47974126, - 42191612.28496882, - 42219130.91253302, - 24227735.90988531, - 45035521.54835925, - 49371517.94999501, - 14778602.03484606, - 39909758.65668079, - 38691846.52720026, - 39834520.43061425, - 38650007.36519716, - 38655423.2682883, - 38648001.77388126, - 39313550.93419428, - 38722148.63941796, - 38647816.9422419, - 38651173.48481285, - 33700748.42359267, - 30195870.8789255, - 38679751.48077733, - 38643303.01755095, - 30061424.26274527, - 31140267.73715352, - 31839402.91317674, - 30181761.07222111, - 29847475.57538872, - 30133418.66577969, - 29844361.11423809, - 29914658.78479145, - 29845139.72952577, - 29844361.11423809, - 58012067.61585025, - 30903926.75151934, - 23061159.87895984, - 33550647.3781805, - 23088835.64296583, - 26362451.35547444, - 23131553.38525813, - 23151183.92499699, - 23460854.06493051, - 24271571.95828693, - 23113803.99527559, - ], - ] - ) - - self.expected_aai = np.array([2.88895461e08, 1.69310367e09]) - self.expected_aai_per_group = np.array( - [2.33513758e08, 5.53817034e07, 1.37114041e09, 3.21963264e08] - ) - self.expected_return_period_metric = np.array( - [ - 0.00000000e00, - 0.00000000e00, - 7.10925472e09, - 4.53975437e10, - 1.36547014e10, - 7.69981714e10, - ] - ) - - def test_reset_impact_data(self): - self.calc_risk_metrics_points._impacts = "A" # type:ignore - self.calc_risk_metrics_points._eai_gdf = "B" # type:ignore - self.calc_risk_metrics_points._per_date_eai = "C" # type:ignore - self.calc_risk_metrics_points._per_date_aai = "D" # type:ignore - self.calc_risk_metrics_points._reset_impact_data() - self.assertIsNone(self.calc_risk_metrics_points._impacts) - self.assertIsNone(self.calc_risk_metrics_points._eai_gdf) - self.assertIsNone(self.calc_risk_metrics_points._per_date_aai) - self.assertIsNone(self.calc_risk_metrics_points._per_date_eai) - - def test_set_impact_computation_strategy(self): - new_impact_computation_strategy = MagicMock(spec=ImpactComputationStrategy) - self.calc_risk_metrics_points.impact_computation_strategy = ( - new_impact_computation_strategy - ) - self.assertEqual( - self.calc_risk_metrics_points.impact_computation_strategy, - new_impact_computation_strategy, - ) - - def test_set_impact_computation_strategy_wtype(self): - with self.assertRaises(ValueError): - self.calc_risk_metrics_points.impact_computation_strategy = "A" - - @patch.object(CalcRiskMetricsPoints, "impact_computation_strategy") - def test_impacts_arrays(self, mock_impact_compute): - mock_impact_compute.compute_impacts.side_effect = ["A", "B"] - results = self.calc_risk_metrics_points.impacts - mock_impact_compute.compute_impacts.assert_has_calls( - [ - call( - self.mock_snapshot_start.exposure, - self.mock_snapshot_start.hazard, - self.mock_snapshot_start.impfset, - ), - call( - self.mock_snapshot_end.exposure, - self.mock_snapshot_end.hazard, - self.mock_snapshot_end.impfset, - ), - ] - ) - self.assertEqual(results, ["A", "B"]) - - def test_per_date_eai(self): - np.testing.assert_allclose( - self.calc_risk_metrics_points.per_date_eai, self.expected_eai - ) - - def test_per_date_aai(self): - np.testing.assert_allclose( - self.calc_risk_metrics_points.per_date_aai, - self.expected_aai, - ) - - def test_eai_gdf(self): - result_gdf = self.calc_risk_metrics_points.calc_eai_gdf() - self.assertIsInstance(result_gdf, pd.DataFrame) - self.assertEqual( - result_gdf.shape[0], - len(self.mock_snapshot_start.exposure.gdf) - + len(self.mock_snapshot_end.exposure.gdf), - ) - expected_columns = [ - DATE_COL_NAME, - COORD_ID_COL_NAME, - GROUP_COL_NAME, - RISK_COL_NAME, - METRIC_COL_NAME, - MEASURE_COL_NAME, - UNIT_COL_NAME, - ] - self.assertTrue( - all(col in list(result_gdf.columns) for col in expected_columns) - ) - np.testing.assert_allclose( - np.array(result_gdf[RISK_COL_NAME].values), self.expected_eai.flatten() - ) - # Check constants and column transformations - self.assertEqual(result_gdf[METRIC_COL_NAME].unique(), EAI_METRIC_NAME) - self.assertEqual(result_gdf[MEASURE_COL_NAME].iloc[0], NO_MEASURE_VALUE) - self.assertEqual( - result_gdf[UNIT_COL_NAME].iloc[0], - self.mock_snapshot_start.exposure.value_unit, - ) - self.assertEqual(result_gdf[GROUP_COL_NAME].dtype.name, "category") - self.assertListEqual( - list(result_gdf[GROUP_COL_NAME].cat.categories), - list(self.calc_risk_metrics_points._group_id), - ) - - def test_calc_aai_metric(self): - result_df = self.calc_risk_metrics_points.calc_aai_metric() - self.assertIsInstance(result_df, pd.DataFrame) - self.assertEqual( - result_df.shape[0], len(self.calc_risk_metrics_points.snapshots) - ) - expected_columns = [ - DATE_COL_NAME, - GROUP_COL_NAME, - RISK_COL_NAME, - METRIC_COL_NAME, - MEASURE_COL_NAME, - UNIT_COL_NAME, - ] - self.assertTrue(all(col in result_df.columns for col in expected_columns)) - np.testing.assert_allclose( - np.array(result_df[RISK_COL_NAME].values), self.expected_aai - ) - # Check constants and column transformations - self.assertEqual(result_df[METRIC_COL_NAME].unique(), AAI_METRIC_NAME) - self.assertEqual(result_df[MEASURE_COL_NAME].iloc[0], NO_MEASURE_VALUE) - self.assertEqual( - result_df[UNIT_COL_NAME].iloc[0], - self.mock_snapshot_start.exposure.value_unit, - ) - self.assertEqual(result_df[GROUP_COL_NAME].dtype.name, "category") - - def test_calc_aai_per_group_metric(self): - result_df = self.calc_risk_metrics_points.calc_aai_per_group_metric() - self.assertIsInstance(result_df, pd.DataFrame) - self.assertEqual( - result_df.shape[0], - len(self.calc_risk_metrics_points.snapshots) - * len(self.calc_risk_metrics_points._group_id), - ) - expected_columns = [ - DATE_COL_NAME, - GROUP_COL_NAME, - RISK_COL_NAME, - METRIC_COL_NAME, - MEASURE_COL_NAME, - UNIT_COL_NAME, - ] - self.assertTrue(all(col in result_df.columns for col in expected_columns)) - np.testing.assert_allclose( - np.array(result_df[RISK_COL_NAME].values), self.expected_aai_per_group - ) - # Check constants and column transformations - self.assertEqual(result_df[METRIC_COL_NAME].unique(), AAI_METRIC_NAME) - self.assertEqual(result_df[MEASURE_COL_NAME].iloc[0], NO_MEASURE_VALUE) - self.assertEqual( - result_df[UNIT_COL_NAME].iloc[0], - self.mock_snapshot_start.exposure.value_unit, - ) - self.assertEqual(result_df[GROUP_COL_NAME].dtype.name, "category") - self.assertListEqual(list(result_df[GROUP_COL_NAME].unique()), [0, 1]) - - def test_calc_return_periods_metric(self): - result_df = self.calc_risk_metrics_points.calc_return_periods_metric( - [20, 50, 100] - ) - self.assertIsInstance(result_df, pd.DataFrame) - self.assertEqual( - result_df.shape[0], len(self.calc_risk_metrics_points.snapshots) * 3 - ) - expected_columns = [ - DATE_COL_NAME, - GROUP_COL_NAME, - RISK_COL_NAME, - METRIC_COL_NAME, - MEASURE_COL_NAME, - UNIT_COL_NAME, - ] - self.assertTrue(all(col in result_df.columns for col in expected_columns)) - np.testing.assert_allclose( - np.array(result_df[RISK_COL_NAME].values), - self.expected_return_period_metric, - ) - # Check constants and column transformations - self.assertListEqual( - list(result_df[METRIC_COL_NAME].unique()), ["rp_20", "rp_50", "rp_100"] - ) - self.assertEqual(result_df[MEASURE_COL_NAME].iloc[0], NO_MEASURE_VALUE) - self.assertEqual( - result_df[UNIT_COL_NAME].iloc[0], - self.mock_snapshot_start.exposure.value_unit, - ) - self.assertEqual(result_df[GROUP_COL_NAME].dtype.name, "category") - - @patch.object(Snapshot, "apply_measure") - @patch("climada.trajectories.riskperiod.CalcRiskMetricsPoints") - def test_apply_measure(self, mock_CalcRiskMetricPoints, mock_snap_apply_measure): - mock_CalcRiskMetricPoints.return_value = MagicMock(spec=CalcRiskMetricsPeriod) - mock_snap_apply_measure.return_value = 42 - result = self.calc_risk_metrics_points.apply_measure(self.measure) - mock_snap_apply_measure.assert_called_with(self.measure) - mock_CalcRiskMetricPoints.assert_called_with( - [42, 42], - self.calc_risk_metrics_points.impact_computation_strategy, - ) - self.assertEqual(result.measure, self.measure) - - -class TestCalcRiskMetricsPeriod_TopLevel(unittest.TestCase): - def setUp(self): - # Create mock objects for testing - self.present_date = 2020 - self.future_date = 2025 - self.exposure_present = Exposures.from_hdf5(EXP_DEMO_H5) - self.exposure_present.gdf.rename(columns={"impf_": "impf_TC"}, inplace=True) - self.exposure_present.gdf["impf_TC"] = 1 - self.exposure_present.gdf[GROUP_ID_COL_NAME] = ( - self.exposure_present.gdf["value"] > 500000 - ) * 1 - self.hazard_present = Hazard.from_hdf5(HAZ_DEMO_H5) - self.exposure_present.assign_centroids(self.hazard_present, distance="approx") - self.impfset_present = ImpactFuncSet([ImpfTropCyclone.from_emanuel_usa()]) - - self.exposure_future = Exposures.from_hdf5(EXP_DEMO_H5) - n_years = self.future_date - self.present_date + 1 - growth_rate = 1.02 - growth = growth_rate**n_years - self.exposure_future.gdf["value"] = self.exposure_future.gdf["value"] * growth - self.exposure_future.gdf.rename(columns={"impf_": "impf_TC"}, inplace=True) - self.exposure_future.gdf["impf_TC"] = 1 - self.exposure_future.gdf[GROUP_ID_COL_NAME] = ( - self.exposure_future.gdf["value"] > 500000 - ) * 1 - self.hazard_future = Hazard.from_hdf5(HAZ_DEMO_H5) - self.hazard_future.intensity *= 1.1 - self.exposure_future.assign_centroids(self.hazard_future, distance="approx") - self.impfset_future = ImpactFuncSet( - [ - ImpfTropCyclone.from_emanuel_usa(impf_id=1, v_half=60.0), - ] - ) - - self.measure = MagicMock(spec=Measure) - self.measure.name = "Test Measure" - - # Setup mock return values for measure.apply - self.measure_exposure = MagicMock(spec=Exposures) - self.measure_hazard = MagicMock(spec=Hazard) - self.measure_impfset = MagicMock(spec=ImpactFuncSet) - self.measure.apply.return_value = ( - self.measure_exposure, - self.measure_impfset, - self.measure_hazard, - ) - - # Create mock snapshots - self.mock_snapshot_start = Snapshot( - exposure=self.exposure_present, - hazard=self.hazard_present, - impfset=self.impfset_present, - date=self.present_date, - ) - self.mock_snapshot_end = Snapshot( - exposure=self.exposure_future, - hazard=self.hazard_future, - impfset=self.impfset_future, - date=self.future_date, - ) - - # Create an instance of CalcRiskPeriod - self.calc_risk_period = CalcRiskMetricsPeriod( - self.mock_snapshot_start, - self.mock_snapshot_end, - time_resolution="Y", - interpolation_strategy=AllLinearStrategy(), - impact_computation_strategy=ImpactCalcComputation(), - # These will have to be tested when implemented - # risk_transf_attach=0.1, - # risk_transf_cover=0.9, - # calc_residual=False - ) - - def test_init(self): - self.assertEqual(self.calc_risk_period.snapshot_start, self.mock_snapshot_start) - self.assertEqual(self.calc_risk_period.snapshot_end, self.mock_snapshot_end) - self.assertEqual(self.calc_risk_period.time_resolution, "Y") - self.assertEqual( - self.calc_risk_period.time_points, self.future_date - self.present_date + 1 - ) - self.assertIsInstance( - self.calc_risk_period.interpolation_strategy, AllLinearStrategy - ) - self.assertIsInstance( - self.calc_risk_period.impact_computation_strategy, ImpactCalcComputation - ) - np.testing.assert_array_equal( - self.calc_risk_period._group_id_E0, - self.mock_snapshot_start.exposure.gdf[GROUP_ID_COL_NAME].values, - ) - np.testing.assert_array_equal( - self.calc_risk_period._group_id_E1, - self.mock_snapshot_end.exposure.gdf[GROUP_ID_COL_NAME].values, - ) - self.assertIsInstance(self.calc_risk_period.date_idx, pd.PeriodIndex) - self.assertEqual( - len(self.calc_risk_period.date_idx), - self.future_date - self.present_date + 1, - ) - - def test_set_date_idx_wrong_type(self): - with self.assertRaises(ValueError): - self.calc_risk_period.date_idx = "A" - - def test_set_date_idx_periods(self): - new_date_idx = pd.period_range("2023-01-01", periods=24) - self.calc_risk_period.date_idx = new_date_idx - self.assertEqual(len(self.calc_risk_period.date_idx), 24) - - def test_set_date_idx_freq(self): - new_date_idx = pd.period_range("2023-01-01", "2023-12-01", freq="M") - self.calc_risk_period.date_idx = new_date_idx - self.assertEqual(len(self.calc_risk_period.date_idx), 12) - pd.testing.assert_index_equal( - self.calc_risk_period.date_idx, - pd.period_range("2023-01-01", "2023-12-01", freq="M"), - ) - - def test_set_time_resolution(self): - self.calc_risk_period.time_resolution = "M" - self.assertEqual(self.calc_risk_period.time_resolution, "M") - pd.testing.assert_index_equal( - self.calc_risk_period.date_idx, - pd.PeriodIndex( - [ - "2020-01-01", - "2020-02-01", - "2020-03-01", - "2020-04-01", - "2020-05-01", - "2020-06-01", - "2020-07-01", - "2020-08-01", - "2020-09-01", - "2020-10-01", - "2020-11-01", - "2020-12-01", - "2021-01-01", - "2021-02-01", - "2021-03-01", - "2021-04-01", - "2021-05-01", - "2021-06-01", - "2021-07-01", - "2021-08-01", - "2021-09-01", - "2021-10-01", - "2021-11-01", - "2021-12-01", - "2022-01-01", - "2022-02-01", - "2022-03-01", - "2022-04-01", - "2022-05-01", - "2022-06-01", - "2022-07-01", - "2022-08-01", - "2022-09-01", - "2022-10-01", - "2022-11-01", - "2022-12-01", - "2023-01-01", - "2023-02-01", - "2023-03-01", - "2023-04-01", - "2023-05-01", - "2023-06-01", - "2023-07-01", - "2023-08-01", - "2023-09-01", - "2023-10-01", - "2023-11-01", - "2023-12-01", - "2024-01-01", - "2024-02-01", - "2024-03-01", - "2024-04-01", - "2024-05-01", - "2024-06-01", - "2024-07-01", - "2024-08-01", - "2024-09-01", - "2024-10-01", - "2024-11-01", - "2024-12-01", - "2025-01-01", - ], - name=DATE_COL_NAME, - freq="M", - ), - ) - - def test_set_interpolation_strategy(self): - new_interpolation_strategy = MagicMock(spec=InterpolationStrategyBase) - self.calc_risk_period.interpolation_strategy = new_interpolation_strategy - self.assertEqual( - self.calc_risk_period.interpolation_strategy, new_interpolation_strategy - ) - - def test_set_interpolation_strategy_wtype(self): - with self.assertRaises(ValueError): - self.calc_risk_period.interpolation_strategy = "A" - - def test_set_impact_computation_strategy(self): - new_impact_computation_strategy = MagicMock(spec=ImpactComputationStrategy) - self.calc_risk_period.impact_computation_strategy = ( - new_impact_computation_strategy - ) - self.assertEqual( - self.calc_risk_period.impact_computation_strategy, - new_impact_computation_strategy, - ) - - def test_set_impact_computation_strategy_wtype(self): - with self.assertRaises(ValueError): - self.calc_risk_period.impact_computation_strategy = "A" - - # The computation are tested in the CalcImpactStrategy / InterpolationStrategyBase tests - # Here we just make sure that the calling works - @patch.object(CalcRiskMetricsPeriod, "impact_computation_strategy") - def test_impacts_arrays(self, mock_impact_compute): - mock_impact_compute.compute_impacts.side_effect = [1, 2, 3, 4, 5, 6, 7, 8] - self.assertEqual(self.calc_risk_period.E0H0V0, 1) - self.assertEqual(self.calc_risk_period.E1H0V0, 2) - self.assertEqual(self.calc_risk_period.E0H1V0, 3) - self.assertEqual(self.calc_risk_period.E1H1V0, 4) - self.assertEqual(self.calc_risk_period.E0H0V1, 5) - self.assertEqual(self.calc_risk_period.E1H0V1, 6) - self.assertEqual(self.calc_risk_period.E0H1V1, 7) - self.assertEqual(self.calc_risk_period.E1H1V1, 8) - mock_impact_compute.compute_impacts.assert_has_calls( - [ - call( - exp, - haz, - impf, - ) - for exp, haz, impf in [ - ( - self.mock_snapshot_start.exposure, - self.mock_snapshot_start.hazard, - self.mock_snapshot_start.impfset, - ), - ( - self.mock_snapshot_end.exposure, - self.mock_snapshot_start.hazard, - self.mock_snapshot_start.impfset, - ), - ( - self.mock_snapshot_start.exposure, - self.mock_snapshot_end.hazard, - self.mock_snapshot_start.impfset, - ), - ( - self.mock_snapshot_end.exposure, - self.mock_snapshot_end.hazard, - self.mock_snapshot_start.impfset, - ), - ( - self.mock_snapshot_start.exposure, - self.mock_snapshot_start.hazard, - self.mock_snapshot_end.impfset, - ), - ( - self.mock_snapshot_end.exposure, - self.mock_snapshot_start.hazard, - self.mock_snapshot_end.impfset, - ), - ( - self.mock_snapshot_start.exposure, - self.mock_snapshot_end.hazard, - self.mock_snapshot_end.impfset, - ), - ( - self.mock_snapshot_end.exposure, - self.mock_snapshot_end.hazard, - self.mock_snapshot_end.impfset, - ), - ] - ] - ) - - @patch.object(CalcRiskMetricsPeriod, "interpolation_strategy") - def test_imp_mats_H0V0(self, mock_interpolate): - mock_interpolate.interp_over_exposure_dim.return_value = 1 - result = self.calc_risk_period.imp_mats_H0V0 - self.assertEqual(result, 1) - mock_interpolate.interp_over_exposure_dim.assert_called_with( - self.calc_risk_period.E0H0V0.imp_mat, - self.calc_risk_period.E1H0V0.imp_mat, - self.calc_risk_period.time_points, - ) - - @patch.object(CalcRiskMetricsPeriod, "interpolation_strategy") - def test_imp_mats_H1V0(self, mock_interpolate): - mock_interpolate.interp_over_exposure_dim.return_value = 1 - result = self.calc_risk_period.imp_mats_H1V0 - self.assertEqual(result, 1) - mock_interpolate.interp_over_exposure_dim.assert_called_with( - self.calc_risk_period.E0H1V0.imp_mat, - self.calc_risk_period.E1H1V0.imp_mat, - self.calc_risk_period.time_points, - ) - - @patch.object(CalcRiskMetricsPeriod, "interpolation_strategy") - def test_imp_mats_H0V1(self, mock_interpolate): - mock_interpolate.interp_over_exposure_dim.return_value = 1 - result = self.calc_risk_period.imp_mats_H0V1 - self.assertEqual(result, 1) - mock_interpolate.interp_over_exposure_dim.assert_called_with( - self.calc_risk_period.E0H0V1.imp_mat, - self.calc_risk_period.E1H0V1.imp_mat, - self.calc_risk_period.time_points, - ) - - @patch.object(CalcRiskMetricsPeriod, "interpolation_strategy") - def test_imp_mats_H1V1(self, mock_interpolate): - mock_interpolate.interp_over_exposure_dim.return_value = 1 - result = self.calc_risk_period.imp_mats_H1V1 - self.assertEqual(result, 1) - mock_interpolate.interp_over_exposure_dim.assert_called_with( - self.calc_risk_period.E0H1V1.imp_mat, - self.calc_risk_period.E1H1V1.imp_mat, - self.calc_risk_period.time_points, - ) - - @patch("climada.trajectories.riskperiod.calc_per_date_eais") - def test_per_date_eai_H0V0(self, mock_calc_per_date_eais): - mock_calc_per_date_eais.return_value = 1 - result = self.calc_risk_period.per_date_eai_H0V0 - - actual_arg0 = mock_calc_per_date_eais.call_args[0][0] - expected_arg0 = self.calc_risk_period.imp_mats_H0V0 - - actual_arg1 = mock_calc_per_date_eais.call_args[0][1] - expected_arg1 = self.calc_risk_period.snapshot_start.hazard.frequency - - assert_sparse_matrix_array_equal(actual_arg0, expected_arg0) - np.testing.assert_array_equal(actual_arg1, expected_arg1) - self.assertEqual(result, 1) - - @patch("climada.trajectories.riskperiod.calc_per_date_eais") - def test_per_date_eai_H1V0(self, mock_calc_per_date_eais): - mock_calc_per_date_eais.return_value = 1 - result = self.calc_risk_period.per_date_eai_H1V0 - actual_arg0 = mock_calc_per_date_eais.call_args[0][0] - expected_arg0 = self.calc_risk_period.imp_mats_H1V0 - - actual_arg1 = mock_calc_per_date_eais.call_args[0][1] - expected_arg1 = self.calc_risk_period.snapshot_start.hazard.frequency - - assert_sparse_matrix_array_equal(actual_arg0, expected_arg0) - np.testing.assert_array_equal(actual_arg1, expected_arg1) - self.assertEqual(result, 1) - - @patch("climada.trajectories.riskperiod.calc_per_date_eais") - def test_per_date_eai_H0V1(self, mock_calc_per_date_eais): - mock_calc_per_date_eais.return_value = 1 - result = self.calc_risk_period.per_date_eai_H0V1 - - actual_arg0 = mock_calc_per_date_eais.call_args[0][0] - expected_arg0 = self.calc_risk_period.imp_mats_H0V1 - - actual_arg1 = mock_calc_per_date_eais.call_args[0][1] - expected_arg1 = self.calc_risk_period.snapshot_start.hazard.frequency - - assert_sparse_matrix_array_equal(actual_arg0, expected_arg0) - np.testing.assert_array_equal(actual_arg1, expected_arg1) - self.assertEqual(result, 1) - - @patch("climada.trajectories.riskperiod.calc_per_date_eais") - def test_per_date_eai_H1V1(self, mock_calc_per_date_eais): - mock_calc_per_date_eais.return_value = 1 - result = self.calc_risk_period.per_date_eai_H1V1 - actual_arg0 = mock_calc_per_date_eais.call_args[0][0] - expected_arg0 = self.calc_risk_period.imp_mats_H1V1 - - actual_arg1 = mock_calc_per_date_eais.call_args[0][1] - expected_arg1 = self.calc_risk_period.snapshot_start.hazard.frequency - - assert_sparse_matrix_array_equal(actual_arg0, expected_arg0) - np.testing.assert_array_equal(actual_arg1, expected_arg1) - self.assertEqual(result, 1) - - @patch("climada.trajectories.riskperiod.calc_per_date_aais") - def test_per_date_aai_H0V0(self, mock_calc_per_date_aais): - mock_calc_per_date_aais.return_value = 1 - result = self.calc_risk_period.per_date_aai_H0V0 - - actual_arg0 = mock_calc_per_date_aais.call_args[0][0] - expected_arg0 = self.calc_risk_period.per_date_eai_H0V0 - self.assertEqual(result, 1) - np.testing.assert_array_equal(actual_arg0, expected_arg0) - - @patch("climada.trajectories.riskperiod.calc_per_date_aais") - def test_per_date_aai_H1V0(self, mock_calc_per_date_aais): - mock_calc_per_date_aais.return_value = 1 - result = self.calc_risk_period.per_date_aai_H1V0 - - actual_arg0 = mock_calc_per_date_aais.call_args[0][0] - expected_arg0 = self.calc_risk_period.per_date_eai_H1V0 - self.assertEqual(result, 1) - np.testing.assert_array_equal(actual_arg0, expected_arg0) - - @patch("climada.trajectories.riskperiod.calc_per_date_aais") - def test_per_date_aai_H0V1(self, mock_calc_per_date_aais): - mock_calc_per_date_aais.return_value = 1 - result = self.calc_risk_period.per_date_aai_H0V1 - - actual_arg0 = mock_calc_per_date_aais.call_args[0][0] - expected_arg0 = self.calc_risk_period.per_date_eai_H0V1 - self.assertEqual(result, 1) - np.testing.assert_array_equal(actual_arg0, expected_arg0) - - @patch("climada.trajectories.riskperiod.calc_per_date_aais") - def test_per_date_aai_H1V1(self, mock_calc_per_date_aais): - mock_calc_per_date_aais.return_value = 1 - result = self.calc_risk_period.per_date_aai_H1V1 - - actual_arg0 = mock_calc_per_date_aais.call_args[0][0] - expected_arg0 = self.calc_risk_period.per_date_eai_H1V1 - self.assertEqual(result, 1) - np.testing.assert_array_equal(actual_arg0, expected_arg0) - - @patch("climada.trajectories.riskperiod.calc_per_date_rps") - def test_per_date_return_periods_H0V0(self, mock_calc_per_date_rps): - mock_calc_per_date_rps.return_value = 1 - result = self.calc_risk_period.per_date_return_periods_H0V0([10, 50]) - - actual_arg0 = mock_calc_per_date_rps.call_args[0][0] - expected_arg0 = self.calc_risk_period.imp_mats_H0V0 - - actual_arg1 = mock_calc_per_date_rps.call_args[0][1] - expected_arg1 = self.calc_risk_period.snapshot_start.hazard.frequency - - actual_arg2 = mock_calc_per_date_rps.call_args[0][2] - expected_arg2 = [10, 50] - - assert_sparse_matrix_array_equal(actual_arg0, expected_arg0) - np.testing.assert_array_equal(actual_arg1, expected_arg1) - self.assertEqual(actual_arg2, expected_arg2) - self.assertEqual(result, 1) - - @patch("climada.trajectories.riskperiod.calc_per_date_rps") - def test_per_date_return_periods_H1V0(self, mock_calc_per_date_rps): - mock_calc_per_date_rps.return_value = 1 - result = self.calc_risk_period.per_date_return_periods_H1V0([10, 50]) - - actual_arg0 = mock_calc_per_date_rps.call_args[0][0] - expected_arg0 = self.calc_risk_period.imp_mats_H1V0 - - actual_arg1 = mock_calc_per_date_rps.call_args[0][1] - expected_arg1 = self.calc_risk_period.snapshot_end.hazard.frequency - - actual_arg2 = mock_calc_per_date_rps.call_args[0][2] - expected_arg2 = [10, 50] - - assert_sparse_matrix_array_equal(actual_arg0, expected_arg0) - np.testing.assert_array_equal(actual_arg1, expected_arg1) - self.assertEqual(actual_arg2, expected_arg2) - self.assertEqual(result, 1) - - @patch("climada.trajectories.riskperiod.calc_per_date_rps") - def test_per_date_return_periods_H0V1(self, mock_calc_per_date_rps): - mock_calc_per_date_rps.return_value = 1 - result = self.calc_risk_period.per_date_return_periods_H0V1([10, 50]) - - actual_arg0 = mock_calc_per_date_rps.call_args[0][0] - expected_arg0 = self.calc_risk_period.imp_mats_H0V1 - - actual_arg1 = mock_calc_per_date_rps.call_args[0][1] - expected_arg1 = self.calc_risk_period.snapshot_start.hazard.frequency - - actual_arg2 = mock_calc_per_date_rps.call_args[0][2] - expected_arg2 = [10, 50] - - assert_sparse_matrix_array_equal(actual_arg0, expected_arg0) - np.testing.assert_array_equal(actual_arg1, expected_arg1) - self.assertEqual(actual_arg2, expected_arg2) - self.assertEqual(result, 1) - - @patch("climada.trajectories.riskperiod.calc_per_date_rps") - def test_per_date_return_periods_H1V1(self, mock_calc_per_date_rps): - mock_calc_per_date_rps.return_value = 1 - result = self.calc_risk_period.per_date_return_periods_H1V1([10, 50]) - - actual_arg0 = mock_calc_per_date_rps.call_args[0][0] - expected_arg0 = self.calc_risk_period.imp_mats_H1V1 - - actual_arg1 = mock_calc_per_date_rps.call_args[0][1] - expected_arg1 = self.calc_risk_period.snapshot_end.hazard.frequency - - actual_arg2 = mock_calc_per_date_rps.call_args[0][2] - expected_arg2 = [10, 50] - - assert_sparse_matrix_array_equal(actual_arg0, expected_arg0) - np.testing.assert_array_equal(actual_arg1, expected_arg1) - self.assertEqual(actual_arg2, expected_arg2) - self.assertEqual(result, 1) - - @patch.object(CalcRiskMetricsPeriod, "calc_eai_gdf", return_value=1) - def test_eai_gdf(self, mock_calc_eai_gdf): - result = self.calc_risk_period.eai_gdf - mock_calc_eai_gdf.assert_called_once() - self.assertEqual(result, 1) - - # Here we mock the impact calc method just to make sure it is rightfully called - def test_calc_per_date_eais(self): - results = calc_per_date_eais( - imp_mats=[ - csr_matrix( - [ - [1, 1, 1], - [2, 2, 2], - ] - ), - csr_matrix( - [ - [2, 0, 1], - [2, 0, 2], - ] - ), - ], - frequency=np.array([1, 1]), - ) - np.testing.assert_array_equal(results, np.array([[3, 3, 3], [4, 0, 3]])) - - def test_calc_per_date_aais(self): - results = calc_per_date_aais(np.array([[3, 3, 3], [4, 0, 3]])) - np.testing.assert_array_equal(results, np.array([9, 7])) - - def test_calc_freq_curve(self): - results = calc_freq_curve( - imp_mat_intrpl=csr_matrix( - [ - [0.1, 0, 0], - [1, 0, 0], - [10, 0, 0], - ] - ), - frequency=np.array([0.5, 0.05, 0.005]), - return_per=[10, 50, 100], - ) - np.testing.assert_array_equal(results, np.array([0.55045, 2.575, 5.05])) - - def test_calc_per_date_rps(self): - base_imp = csr_matrix( - [ - [0.1, 0, 0], - [1, 0, 0], - [10, 0, 0], - ] - ) - results = calc_per_date_rps( - [base_imp, base_imp * 2, base_imp * 4], - frequency=np.array([0.5, 0.05, 0.005]), - return_periods=[10, 50, 100], - ) - np.testing.assert_array_equal( - results, - np.array( - [[0.55045, 2.575, 5.05], [1.1009, 5.15, 10.1], [2.2018, 10.3, 20.2]] - ), - ) - - -class TestCalcRiskPeriod_LowLevel(unittest.TestCase): - def setUp(self): - # Create mock objects for testing - self.calc_risk_period = MagicMock(spec=CalcRiskMetricsPeriod) - - # Little trick to bind the mocked object method to the real one - self.calc_risk_period.calc_eai = types.MethodType( - CalcRiskMetricsPeriod.calc_eai, self.calc_risk_period - ) - - self.calc_risk_period.calc_eai_gdf = types.MethodType( - CalcRiskMetricsPeriod.calc_eai_gdf, self.calc_risk_period - ) - self.calc_risk_period.calc_aai_metric = types.MethodType( - CalcRiskMetricsPeriod.calc_aai_metric, self.calc_risk_period - ) - - self.calc_risk_period.calc_aai_per_group_metric = types.MethodType( - CalcRiskMetricsPeriod.calc_aai_per_group_metric, self.calc_risk_period - ) - self.calc_risk_period.calc_return_periods_metric = types.MethodType( - CalcRiskMetricsPeriod.calc_return_periods_metric, self.calc_risk_period - ) - self.calc_risk_period.calc_risk_components_metric = types.MethodType( - CalcRiskMetricsPeriod.calc_risk_contributions_metric, self.calc_risk_period - ) - self.calc_risk_period.apply_measure = types.MethodType( - CalcRiskMetricsPeriod.apply_measure, self.calc_risk_period - ) - - self.calc_risk_period.per_date_eai_H0V0 = np.array( - [[1, 0, 1], [1, 2, 0], [3, 3, 3]] - ) - self.calc_risk_period.per_date_eai_H1V0 = np.array( - [[2, 0, 2], [2, 4, 0], [12, 6, 6]] - ) - self.calc_risk_period.per_date_aai_H0V0 = np.array([2, 3, 9]) - self.calc_risk_period.per_date_aai_H1V0 = np.array([4, 6, 24]) - - self.calc_risk_period.per_date_eai_H0V1 = np.array( - [[1, 0, 1], [1, 2, 0], [3, 3, 3]] - ) - self.calc_risk_period.per_date_eai_H1V1 = np.array( - [[2, 0, 2], [2, 4, 0], [12, 6, 6]] - ) - self.calc_risk_period.per_date_aai_H0V1 = np.array([2, 3, 9]) - self.calc_risk_period.per_date_aai_H1V1 = np.array([4, 6, 24]) - - self.calc_risk_period.date_idx = pd.PeriodIndex( - ["2020-01-01", "2025-01-01", "2030-01-01"], name=DATE_COL_NAME, freq="5Y" - ) - self.calc_risk_period.snapshot_start.exposure.gdf = gpd.GeoDataFrame( - { - GROUP_ID_COL_NAME: [1, 2, 2], - "geometry": [Point(0, 0), Point(1, 1), Point(2, 2)], - "value": [10, 10, 20], - } - ) - self.calc_risk_period.snapshot_end.exposure.gdf = gpd.GeoDataFrame( - { - GROUP_ID_COL_NAME: [1, 2, 2], - "geometry": [Point(0, 0), Point(1, 1), Point(2, 2)], - "value": [10, 10, 20], - } - ) - self.calc_risk_period.measure = MagicMock(spec=Measure) - self.calc_risk_period.measure.name = "dummy_measure" - - def test_calc_eai(self): - # Mock the return values of interp_over_hazard_dim - self.calc_risk_period.interpolation_strategy.interp_over_hazard_dim.side_effect = [ - "V0_interpolated_data", # First call (for per_date_eai_V0) - "V1_interpolated_data", # Second call (for per_date_eai_V1) - ] - # Mock the return value of interp_over_vulnerability_dim - self.calc_risk_period.interpolation_strategy.interp_over_vulnerability_dim.return_value = ( - "final_eai_result" - ) - - result = self.calc_risk_period.calc_eai() - - # Assert that interp_over_hazard_dim was called with the correct arguments - self.calc_risk_period.interpolation_strategy.interp_over_hazard_dim.assert_has_calls( - [ - call( - self.calc_risk_period.per_date_eai_H0V0, - self.calc_risk_period.per_date_eai_H1V0, - ), - call( - self.calc_risk_period.per_date_eai_H0V1, - self.calc_risk_period.per_date_eai_H1V1, - ), - ] - ) - - # Assert that interp_over_vulnerability_dim was called with the results of interp_over_hazard_dim - self.calc_risk_period.interpolation_strategy.interp_over_vulnerability_dim.assert_called_once_with( - "V0_interpolated_data", "V1_interpolated_data" - ) - - # Assert the final returned value - self.assertEqual(result, "final_eai_result") - - def test_calc_eai_gdf(self): - self.calc_risk_period._groups_id = np.array([0]) - expected_risk = np.array([[1.0, 1.5, 12], [0, 3, 6], [1, 0, 6]]) - self.calc_risk_period.per_date_eai = expected_risk - result = self.calc_risk_period.calc_eai_gdf() - expected_columns = { - GROUP_COL_NAME, - COORD_ID_COL_NAME, - DATE_COL_NAME, - RISK_COL_NAME, - METRIC_COL_NAME, - MEASURE_COL_NAME, - } - self.assertTrue(expected_columns.issubset(set(result.columns))) - self.assertTrue((result[METRIC_COL_NAME] == EAI_METRIC_NAME).all()) - self.assertTrue((result[MEASURE_COL_NAME] == "dummy_measure").all()) - # Check calculated risk values by coord_id, date - actual_risk = result[RISK_COL_NAME].values - np.testing.assert_allclose(expected_risk.T.flatten(), actual_risk) - - def test_calc_aai_metric(self): - expected_aai = np.array([2, 4.5, 24]) - self.calc_risk_period.per_date_aai = expected_aai - self.calc_risk_period._groups_id = np.array([0]) - result = self.calc_risk_period.calc_aai_metric() - expected_columns = { - GROUP_COL_NAME, - DATE_COL_NAME, - RISK_COL_NAME, - METRIC_COL_NAME, - MEASURE_COL_NAME, - } - self.assertTrue(expected_columns.issubset(set(result.columns))) - self.assertTrue((result[METRIC_COL_NAME] == AAI_METRIC_NAME).all()) - self.assertTrue((result[MEASURE_COL_NAME] == "dummy_measure").all()) - - # Check calculated risk values by coord_id, date - actual_risk = result[RISK_COL_NAME].values - np.testing.assert_allclose(expected_aai, actual_risk) - - def test_calc_aai_per_group_metric(self): - self.calc_risk_period._group_id_E0 = np.array([1, 1, 2]) - self.calc_risk_period._group_id_E1 = np.array([2, 2, 2]) - self.calc_risk_period._groups_id = np.array([1, 2]) - self.calc_risk_period.eai_gdf = pd.DataFrame( - { - DATE_COL_NAME: pd.PeriodIndex( - ["2020-01-01"] * 3 + ["2025-01-01"] * 3 + ["2030-01-01"] * 3, - name=DATE_COL_NAME, - freq="5Y", - ), - COORD_ID_COL_NAME: [0, 1, 2, 0, 1, 2, 0, 1, 2], - GROUP_COL_NAME: [1, 1, 2, 1, 1, 2, 1, 1, 2], - RISK_COL_NAME: [2, 3, 4, 5, 6, 7, 8, 9, 10], - METRIC_COL_NAME: [EAI_METRIC_NAME, EAI_METRIC_NAME, EAI_METRIC_NAME] - * 3, - MEASURE_COL_NAME: ["dummy_measure", "dummy_measure", "dummy_measure"] - * 3, - } - ) - self.calc_risk_period.eai_gdf[GROUP_COL_NAME] = self.calc_risk_period.eai_gdf[ - GROUP_COL_NAME - ].astype("category") - result = self.calc_risk_period.calc_aai_per_group_metric() - expected_columns = { - GROUP_COL_NAME, - DATE_COL_NAME, - RISK_COL_NAME, - METRIC_COL_NAME, - MEASURE_COL_NAME, - } - self.assertTrue(expected_columns.issubset(set(result.columns))) - self.assertTrue((result[METRIC_COL_NAME] == AAI_METRIC_NAME).all()) - self.assertTrue((result[MEASURE_COL_NAME] == "dummy_measure").all()) - # Check calculated risk values by coord_id, date - expected_risk = np.array([5, 5, 6.6, 13.6, 3.4, 27]) - actual_risk = result[RISK_COL_NAME].values - np.testing.assert_allclose(expected_risk, actual_risk) - - def test_calc_return_periods_metric(self): - self.calc_risk_period._groups_id = np.array([0]) - self.calc_risk_period.per_date_return_periods_H0V0.return_value = "H0V0" - self.calc_risk_period.per_date_return_periods_H1V0.return_value = "H1V0" - self.calc_risk_period.per_date_return_periods_H0V1.return_value = "H0V1" - self.calc_risk_period.per_date_return_periods_H1V1.return_value = "H1V1" - # Mock the return values of interp_over_hazard_dim - self.calc_risk_period.interpolation_strategy.interp_over_hazard_dim.side_effect = [ - "V0_interpolated_data", # First call (for per_date_rp_V0) - "V1_interpolated_data", # Second call (for per_date_rp_V1) - ] - # Mock the return value of interp_over_vulnerability_dim - self.calc_risk_period.interpolation_strategy.interp_over_vulnerability_dim.return_value = np.array( - [[1, 2, 3], [4, 5, 6], [7, 8, 9]] - ) - - result = self.calc_risk_period.calc_return_periods_metric([10, 20, 30]) - - # Assert that interp_over_hazard_dim was called with the correct arguments - self.calc_risk_period.interpolation_strategy.interp_over_hazard_dim.assert_has_calls( - [call("H0V0", "H1V0"), call("H0V1", "H1V1")] - ) - - # Assert that interp_over_vulnerability_dim was called with the results of interp_over_hazard_dim - self.calc_risk_period.interpolation_strategy.interp_over_vulnerability_dim.assert_called_once_with( - "V0_interpolated_data", "V1_interpolated_data" - ) - - # Assert the final returned value - - expected_columns = { - GROUP_COL_NAME, - DATE_COL_NAME, - RISK_COL_NAME, - METRIC_COL_NAME, - MEASURE_COL_NAME, - } - self.assertTrue(expected_columns.issubset(set(result.columns))) - self.assertTrue( - all(result[METRIC_COL_NAME].unique() == ["rp_10", "rp_20", "rp_30"]) - ) - self.assertTrue((result[MEASURE_COL_NAME] == "dummy_measure").all()) - - # Check calculated risk values by rp, date - np.testing.assert_allclose( - result[RISK_COL_NAME].values, np.array([1, 4, 7, 2, 5, 8, 3, 6, 9]) - ) - - def test_calc_risk_components_metric(self): - self.calc_risk_period._groups_id = np.array([0]) - self.calc_risk_period.per_date_aai_H0V0 = np.array([1, 3, 5]) - self.calc_risk_period.per_date_aai_E0H0V0 = np.array([1, 1, 1]) - self.calc_risk_period.per_date_aai_E0H1V0 = np.array( - [2, 2, 2] - ) # Haz change doubles damages in fut - self.calc_risk_period.per_date_aai_E0H0V1 = np.array( - [3, 3, 3] - ) # Vul change triples damages in fut - self.calc_risk_period.per_date_aai = np.array([1, 6, 10]) - - # Mock the return values of interp_over_hazard_dim - self.calc_risk_period.interpolation_strategy.interp_over_hazard_dim.return_value = np.array( - [1, 1.5, 2] - ) - - # Mock the return value of interp_over_vulnerability_dim - self.calc_risk_period.interpolation_strategy.interp_over_vulnerability_dim.return_value = np.array( - [1, 2, 3] - ) - - result = self.calc_risk_period.calc_risk_components_metric() - - # Assert that interp_over_hazard_dim was called with the correct arguments - self.calc_risk_period.interpolation_strategy.interp_over_hazard_dim.assert_called_once_with( - self.calc_risk_period.per_date_aai_E0H0V0, - self.calc_risk_period.per_date_aai_E0H1V0, - ) - - # Assert that interp_over_vulnerability_dim was called with the results of interp_over_hazard_dim - self.calc_risk_period.interpolation_strategy.interp_over_vulnerability_dim.assert_called_once_with( - self.calc_risk_period.per_date_aai_E0H0V0, - self.calc_risk_period.per_date_aai_E0H0V1, - ) - - # Assert the final returned value - expected_columns = { - GROUP_COL_NAME, - DATE_COL_NAME, - RISK_COL_NAME, - METRIC_COL_NAME, - MEASURE_COL_NAME, - } - self.assertTrue(expected_columns.issubset(set(result.columns))) - self.assertTrue( - all( - result[METRIC_COL_NAME].unique() - == [ - CONTRIBUTION_BASE_RISK_NAME, - CONTRIBUTION_EXPOSURE_NAME, - CONTRIBUTION_HAZARD_NAME, - CONTRIBUTION_VULNERABILITY_NAME, - CONTRIBUTION_INTERACTION_TERM_NAME, - ] - ) - ) - self.assertTrue((result[MEASURE_COL_NAME] == "dummy_measure").all()) - - np.testing.assert_allclose( - result[RISK_COL_NAME].values, - np.array([1.0, 1.0, 1.0, 0, 2.0, 4.0, 0, 0.5, 1.0, 0, 1, 2, 0, 1.5, 2.0]), - ) - - @patch("climada.trajectories.riskperiod.CalcRiskMetricsPeriod") - def test_apply_measure(self, mock_CalcRiskPeriod): - mock_CalcRiskPeriod.return_value = MagicMock(spec=CalcRiskMetricsPeriod) - self.calc_risk_period.snapshot_start.apply_measure.return_value = 2 - self.calc_risk_period.snapshot_end.apply_measure.return_value = 3 - result = self.calc_risk_period.apply_measure(self.calc_risk_period.measure) - self.assertEqual(result.measure, self.calc_risk_period.measure) - mock_CalcRiskPeriod.assert_called_with( - 2, - 3, - self.calc_risk_period.time_resolution, - self.calc_risk_period.interpolation_strategy, - self.calc_risk_period.impact_computation_strategy, - ) - - -def assert_sparse_matrix_array_equal(expected_array, actual_array): - """ - Compares two numpy arrays where elements are sparse matrices. - Uses numpy testing for robust comparison of the sparse matrix internals. - """ - if len(expected_array) != len(actual_array): - raise AssertionError( - f"Expected array length {len(expected_array)} but got {len(actual_array)}" - ) - - for i, (expected_mat, actual_mat) in enumerate(zip(expected_array, actual_array)): - if not (issparse(expected_mat) and issparse(actual_mat)): - raise TypeError(f"Element at index {i} is not a sparse matrix.") - - # Robustly compare the underlying data - np.testing.assert_array_equal( - expected_mat.data, - actual_mat.data, - err_msg=f"Data differs at matrix index {i}", - ) - np.testing.assert_array_equal( - expected_mat.indices, - actual_mat.indices, - err_msg=f"Indices differ at matrix index {i}", - ) - np.testing.assert_array_equal( - expected_mat.indptr, - actual_mat.indptr, - err_msg=f"Indptr differs at matrix index {i}", - ) - # You may also want to assert equal shapes: - assert ( - expected_mat.shape == actual_mat.shape - ), f"Shape differs at matrix index {i}" - - -if __name__ == "__main__": - TESTS = unittest.TestLoader().loadTestsFromTestCase( - TestCalcRiskMetricsPeriod_TopLevel - ) - TESTS.addTests( - unittest.TestLoader().loadTestsFromTestCase(TestCalcRiskMetricsPoints) - ) - TESTS.addTests( - unittest.TestLoader().loadTestsFromTestCase(TestCalcRiskPeriod_LowLevel) - ) - unittest.TextTestRunner(verbosity=2).run(TESTS) diff --git a/climada/trajectories/test/test_trajectory.py b/climada/trajectories/test/test_trajectory.py new file mode 100644 index 0000000000..c39d6c9aac --- /dev/null +++ b/climada/trajectories/test/test_trajectory.py @@ -0,0 +1,326 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +unit tests for risk_trajectory + +""" + +import datetime +import unittest +from unittest.mock import MagicMock, Mock, call, patch + +import pandas as pd + +from climada.entity.disc_rates.base import DiscRates +from climada.trajectories.constants import AAI_METRIC_NAME +from climada.trajectories.snapshot import Snapshot +from climada.trajectories.trajectory import ( + DEFAULT_ALLGROUP_NAME, + DEFAULT_RP, + RiskTrajectory, +) + + +class TestRiskTrajectory(unittest.TestCase): + def setUp(self) -> None: + self.mock_snapshot1 = MagicMock(spec=Snapshot) + self.mock_snapshot1.date = datetime.date(2023, 1, 1) + + self.mock_snapshot2 = MagicMock(spec=Snapshot) + self.mock_snapshot2.date = datetime.date(2024, 1, 1) + + self.mock_snapshot3 = MagicMock(spec=Snapshot) + self.mock_snapshot3.date = datetime.date(2025, 1, 1) + + self.risk_disc_rates = MagicMock(spec=DiscRates) + self.risk_disc_rates.years = [2023, 2024, 2025] + self.risk_disc_rates.rates = [0.01, 0.02, 0.03] # Example rates + + self.snapshots_list: list[Snapshot] = [ + self.mock_snapshot1, + self.mock_snapshot2, + self.mock_snapshot3, + ] + + self.custom_all_groups_name = "custom" + self.custom_return_periods = [10, 20] + + def test_init_basic(self): + rt = RiskTrajectory(self.snapshots_list) + self.assertEqual(rt.start_date, self.mock_snapshot1.date) + self.assertEqual(rt.end_date, self.mock_snapshot3.date) + self.assertIsNone(rt._risk_disc_rates) + self.assertEqual(rt._all_groups_name, DEFAULT_ALLGROUP_NAME) + self.assertEqual(rt._return_periods, DEFAULT_RP) + # Check that metrics are reset (initially None) + for metric in RiskTrajectory.POSSIBLE_METRICS: + self.assertIsNone(getattr(rt, "_" + metric + "_metrics")) + + def test_init_args(self): + rt = RiskTrajectory( + self.snapshots_list, + return_periods=self.custom_return_periods, + all_groups_name=self.custom_all_groups_name, + risk_disc_rates=self.risk_disc_rates, + ) + self.assertEqual(rt.start_date, self.mock_snapshot1.date) + self.assertEqual(rt.end_date, self.mock_snapshot3.date) + self.assertEqual(rt._risk_disc_rates, self.risk_disc_rates) + self.assertEqual(rt._all_groups_name, self.custom_all_groups_name) + self.assertEqual(rt._return_periods, self.custom_return_periods) + self.assertEqual(rt.return_periods, self.custom_return_periods) + # Check that metrics are reset (initially None) + for metric in RiskTrajectory.POSSIBLE_METRICS: + self.assertIsNone(getattr(rt, "_" + metric + "_metrics")) + + @patch.object(RiskTrajectory, "_generic_metrics", new_callable=Mock) + def test_compute_metrics(self, mock_generic_metrics): + mock_generic_metrics.return_value = "42" + rt = RiskTrajectory(self.snapshots_list) + result = rt._compute_metrics( + metric_name="dummy_name", + metric_meth="dummy_meth", + dummy_kwarg1="A", + dummy_kwarg2=12, + ) + mock_generic_metrics.assert_called_once_with( + metric_name="dummy_name", + metric_meth="dummy_meth", + dummy_kwarg1="A", + dummy_kwarg2=12, + ) + self.assertEqual(result, "42") + + def test_set_return_periods(self): + rt = RiskTrajectory(self.snapshots_list) + with self.assertRaises(ValueError): + rt.return_periods = "A" + with self.assertRaises(ValueError): + rt.return_periods = ["A"] + + rt.return_periods = [1, 2] + self.assertEqual(rt._return_periods, [1, 2]) + self.assertEqual(rt.return_periods, [1, 2]) + + @patch.object(RiskTrajectory, "_reset_metrics", new_callable=Mock) + def test_set_disc_rates(self, mock_reset_metrics): + rt = RiskTrajectory(self.snapshots_list) + mock_reset_metrics.assert_called_once() # Called during init + with self.assertRaises(ValueError): + rt.risk_disc_rates = "A" + + rt.risk_disc_rates = self.risk_disc_rates + mock_reset_metrics.assert_has_calls([call(), call()]) + self.assertEqual(rt._risk_disc_rates, self.risk_disc_rates) + self.assertEqual(rt.risk_disc_rates, self.risk_disc_rates) + + def test_npv_transform_no_group_col(self): + df_input = pd.DataFrame( + { + "date": pd.to_datetime(["2023-01-01", "2024-01-01"] * 2), + "measure": ["m1", "m1", "m2", "m2"], + "metric": [ + AAI_METRIC_NAME, + AAI_METRIC_NAME, + AAI_METRIC_NAME, + AAI_METRIC_NAME, + ], + "risk": [100.0, 200.0, 80.0, 180.0], + } + ) + # Mock the internal calc_npv_cash_flows + with patch( + "climada.trajectories.trajectory.RiskTrajectory._calc_npv_cash_flows" + ) as mock_calc_npv: + # For each group, it will be called + mock_calc_npv.side_effect = [ + pd.Series( + [100.0 * (1 / (1 + 0.01)) ** 0, 200.0 * (1 / (1 + 0.02)) ** 1], + index=[pd.Timestamp("2023-01-01"), pd.Timestamp("2024-01-01")], + ), + pd.Series( + [80.0 * (1 / (1 + 0.01)) ** 0, 180.0 * (1 / (1 + 0.02)) ** 1], + index=[pd.Timestamp("2023-01-01"), pd.Timestamp("2024-01-01")], + ), + ] + result_df = RiskTrajectory.npv_transform( + df_input.copy(), self.risk_disc_rates + ) + # Assertions for mock calls + # Grouping by 'measure', 'metric' (default _grouper) + pd.testing.assert_series_equal( + mock_calc_npv.mock_calls[0].args[0], + pd.Series( + [100.0, 200.0], + index=pd.Index( + [ + pd.Timestamp("2023-01-01"), + pd.Timestamp("2024-01-01"), + ], + name="date", + ), + name=("m1", AAI_METRIC_NAME), + ), + ) + assert mock_calc_npv.mock_calls[0].args[1] == pd.Timestamp("2023-01-01") + assert mock_calc_npv.mock_calls[0].args[2] == self.risk_disc_rates + pd.testing.assert_series_equal( + mock_calc_npv.mock_calls[1].args[0], + pd.Series( + [80.0, 180.0], + index=pd.Index( + [ + pd.Timestamp("2023-01-01"), + pd.Timestamp("2024-01-01"), + ], + name="date", + ), + name=("m2", AAI_METRIC_NAME), + ), + ) + assert mock_calc_npv.mock_calls[1].args[1] == pd.Timestamp("2023-01-01") + assert mock_calc_npv.mock_calls[1].args[2] == self.risk_disc_rates + + expected_df = pd.DataFrame( + { + "date": pd.to_datetime(["2023-01-01", "2024-01-01"] * 2), + "measure": ["m1", "m1", "m2", "m2"], + "metric": [ + AAI_METRIC_NAME, + AAI_METRIC_NAME, + AAI_METRIC_NAME, + AAI_METRIC_NAME, + ], + "risk": [ + 100.0 * (1 / (1 + 0.01)) ** 0, + 200.0 * (1 / (1 + 0.02)) ** 1, + 80.0 * (1 / (1 + 0.01)) ** 0, + 180.0 * (1 / (1 + 0.02)) ** 1, + ], + } + ) + pd.testing.assert_frame_equal( + result_df.sort_values("date").reset_index(drop=True), + expected_df.sort_values("date").reset_index(drop=True), + rtol=1e-6, + ) + + def test_npv_transform_with_group_col(self): + df_input = pd.DataFrame( + { + "date": pd.to_datetime(["2023-01-01", "2024-01-01", "2023-01-01"]), + "group": ["G1", "G1", "G2"], + "measure": ["m1", "m1", "m1"], + "metric": [AAI_METRIC_NAME, AAI_METRIC_NAME, AAI_METRIC_NAME], + "risk": [100.0, 200.0, 150.0], + } + ) + with patch( + "climada.trajectories.trajectory.RiskTrajectory._calc_npv_cash_flows" + ) as mock_calc_npv: + mock_calc_npv.side_effect = [ + # First group G1, m1, aai + pd.Series( + [100.0 * (1 / (1 + 0.01)) ** 0, 200.0 * (1 / (1 + 0.02)) ** 1], + index=[pd.Timestamp("2023-01-01"), pd.Timestamp("2024-01-01")], + ), + # Second group G2, m1, aai + pd.Series( + [150.0 * (1 / (1 + 0.01)) ** 0], index=[pd.Timestamp("2023-01-01")] + ), + ] + result_df = RiskTrajectory.npv_transform( + df_input.copy(), self.risk_disc_rates + ) + + expected_df = pd.DataFrame( + { + "date": pd.to_datetime(["2023-01-01", "2024-01-01", "2023-01-01"]), + "group": ["G1", "G1", "G2"], + "measure": ["m1", "m1", "m1"], + "metric": [AAI_METRIC_NAME, AAI_METRIC_NAME, AAI_METRIC_NAME], + "risk": [ + 100.0 * (1 / (1 + 0.01)) ** 0, + 200.0 * (1 / (1 + 0.02)) ** 1, + 150.0 * (1 / (1 + 0.01)) ** 0, + ], + } + ) + pd.testing.assert_frame_equal( + result_df.sort_values(["group", "date"]).reset_index(drop=True), + expected_df.sort_values(["group", "date"]).reset_index(drop=True), + rtol=1e-6, + ) + + # --- Test NPV Transformation (`npv_transform` and `calc_npv_cash_flows`) --- + + ## Test `calc_npv_cash_flows` (standalone function) + def test_calc_npv_cash_flows_no_disc(self): + cash_flows = pd.Series( + [100, 200, 300], + index=pd.to_datetime(["2023-01-01", "2024-01-01", "2025-01-01"]), + ) + start_date = datetime.date(2023, 1, 1) + result = RiskTrajectory._calc_npv_cash_flows( + cash_flows, start_date, disc_rates=None + ) + # If no disc, it should return the original cash_flows Series + pd.testing.assert_series_equal(result, cash_flows) + + def test_calc_npv_cash_flows_with_disc(self): + cash_flows = pd.Series( + [100, 200, 300], + index=pd.period_range(start="2023-01-01", end="2025-01-01", freq="Y"), + ) + start_date = datetime.date(2023, 1, 1) + # Using the risk_disc_rates from SetUp + + # year 2023: (2023-01-01 - 2023-01-01) days // 365 = 0, factor = (1/(1+0.01))^0 = 1 + # year 2024: (2024-01-01 - 2023-01-01) days // 365 = 1, factor = (1/(1+0.02))^1 = 0.98039215... + # year 2025: (2025-01-01 - 2023-01-01) days // 365 = 2, factor = (1/(1+0.03))^2 = 0.9425959... + expected_cash_flows = pd.Series( + [ + 100 * (1 / (1 + 0.01)) ** 0, + 200 * (1 / (1 + 0.02)) ** 1, + 300 * (1 / (1 + 0.03)) ** 2, + ], + index=pd.period_range(start="2023-01-01", end="2025-01-01", freq="Y"), + name="npv_cash_flow", + ) + + result = RiskTrajectory._calc_npv_cash_flows( + cash_flows, start_date, disc_rates=self.risk_disc_rates + ) + pd.testing.assert_series_equal( + result, expected_cash_flows, check_dtype=False, rtol=1e-6 + ) + + def test_calc_npv_cash_flows_invalid_index(self): + cash_flows = pd.Series([100, 200, 300]) # No datetime index + start_date = datetime.date(2023, 1, 1) + with self.assertRaises( + ValueError, msg="cash_flows must be a pandas Series with a datetime index" + ): + RiskTrajectory._calc_npv_cash_flows( + cash_flows, start_date, disc_rates=self.risk_disc_rates + ) + + +if __name__ == "__main__": + TESTS = unittest.TestLoader().loadTestsFromTestCase(TestRiskTrajectory) + unittest.TextTestRunner(verbosity=2).run(TESTS) diff --git a/climada/trajectories/trajectory.py b/climada/trajectories/trajectory.py new file mode 100644 index 0000000000..5675521710 --- /dev/null +++ b/climada/trajectories/trajectory.py @@ -0,0 +1,268 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +This file implements abstract trajectory objects, to factorise the code common to +interpolated and static trajectories. + +""" + +import datetime +import logging +from abc import ABC + +import pandas as pd + +from climada.entity.disc_rates.base import DiscRates +from climada.trajectories.constants import ( + DATE_COL_NAME, + DEFAULT_ALLGROUP_NAME, + DEFAULT_RP, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + PERIOD_COL_NAME, + RISK_COL_NAME, + UNIT_COL_NAME, +) +from climada.trajectories.snapshot import Snapshot + +LOGGER = logging.getLogger(__name__) + +__all__ = ["RiskTrajectory"] + +DEFAULT_DF_COLUMN_PRIORITY = [ + DATE_COL_NAME, + PERIOD_COL_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + UNIT_COL_NAME, +] +INDEXING_COLUMNS = [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME] + + +class RiskTrajectory(ABC): + _grouper = [MEASURE_COL_NAME, METRIC_COL_NAME] + """Results dataframe grouper used in most `groupby()` calls.""" + + POSSIBLE_METRICS = [] + """Class variable listing the risk metrics that can be computed.""" + + def __init__( + self, + snapshots_list: list[Snapshot], + *, + return_periods: list[int] = DEFAULT_RP, + all_groups_name: str = DEFAULT_ALLGROUP_NAME, + risk_disc_rates: DiscRates | None = None, + ): + """Base abstract class for risk trajectory objects. + + See concrete implementation :class:`StaticRiskTrajectory` and + :class:`InterpolatedRiskTrajectory` for more details. + + """ + + self._reset_metrics() + self._snapshots = sorted(snapshots_list, key=lambda snap: snap.date) + self._all_groups_name = all_groups_name + self._return_periods = return_periods + self.start_date = min([snapshot.date for snapshot in snapshots_list]) + self.end_date = max([snapshot.date for snapshot in snapshots_list]) + self._risk_disc_rates = risk_disc_rates + + def _reset_metrics(self) -> None: + """Resets the computed metrics to None. + + This method is called to inititialize the `POSSIBLE_METRICS` to `None` during + the initialisation. + + It is also called when properties that would change the results of + computed metrics (for instance changing the time resolution in + :class:`InterpolatedRiskMetrics`) + + """ + for metric in self.POSSIBLE_METRICS: + setattr(self, "_" + metric + "_metrics", None) + + def _generic_metrics( + self, /, metric_name: str, metric_meth: str, **kwargs + ) -> pd.DataFrame: + """Main method to return the results of a specific metric. + + This method should call the `_generic_metrics()` of its parent and + define the part of the computation and treatment that + is specific to a child class of :class:`RiskTrajectory`. + + See also + -------- + + - :method:`_compute_metrics` + + """ + ... + + def _compute_metrics( + self, /, metric_name: str, metric_meth: str, **kwargs + ) -> pd.DataFrame: + """Helper method to compute metrics. + + Notes + ----- + + This method exists for the sake of the children classes for option appraisal, for which + `_generic_metrics` can have a different signature and extend on its + parent method. This method can stay the same (same signature) for all classes. + """ + return self._generic_metrics( + metric_name=metric_name, metric_meth=metric_meth, **kwargs + ) + + @property + def return_periods(self) -> list[int]: + """The return period values to use when computing risk period metrics. + + Notes + ----- + + Changing its value resets the corresponding metric. + """ + return self._return_periods + + @return_periods.setter + def return_periods(self, value, /): + if not isinstance(value, list): + raise ValueError("Return periods need to be a list of int.") + if any(not isinstance(i, int) for i in value): + raise ValueError("Return periods need to be a list of int.") + self._return_periods_metrics = None + self._return_periods = value + + @property + def risk_disc_rates(self) -> DiscRates | None: + """The discount rate applied to compute net present values. + None means no discount rate. + + Notes + ----- + + Changing its value resets all the metrics. + """ + return self._risk_disc_rates + + @risk_disc_rates.setter + def risk_disc_rates(self, value, /): + if value is not None and not isinstance(value, (DiscRates)): + raise ValueError("Risk discount needs to be a `DiscRates` object.") + + self._reset_metrics() + self._risk_disc_rates = value + + @classmethod + def npv_transform( + cls, df: pd.DataFrame, risk_disc_rates: DiscRates + ) -> pd.DataFrame: + """Apply provided discount rate to the provided metric `DataFrame`. + + Parameters + ---------- + df : pd.DataFrame + The `DataFrame` of the metric to discount. + risk_disc_rates : DiscRate + The discount rate to apply. + + Returns + ------- + pd.DataFrame + The discounted risk metric. + + """ + + def _npv_group(group, disc): + start_date = group.index.get_level_values(DATE_COL_NAME).min() + return cls._calc_npv_cash_flows(group, start_date, disc) + + df = df.set_index(DATE_COL_NAME) + grouper = cls._grouper + if GROUP_COL_NAME in df.columns: + grouper = [GROUP_COL_NAME] + grouper + + df[RISK_COL_NAME] = df.groupby( + grouper, + dropna=False, + as_index=False, + group_keys=False, + observed=True, + )[RISK_COL_NAME].transform(_npv_group, risk_disc_rates) + df = df.reset_index() + return df + + @staticmethod + def _calc_npv_cash_flows( + cash_flows: pd.DataFrame, + start_date: datetime.date, + disc_rates: DiscRates | None = None, + ): + """Apply discount rate to cash flows. + + If it is defined, applies a discount rate `disc` to a given cash flow + `cash_flows` assuming present year corresponds to `start_date`. + + Parameters + ---------- + cash_flows : pd.DataFrame + The cash flow to apply the discount rate to. + start_date : datetime.date + The date representing the present. + end_date : datetime.date, optional + disc : DiscRates, optional + The discount rate to apply. + + Returns + ------- + + A dataframe (copy) of `cash_flows` where values are discounted according to `disc`. + + """ + + if not disc_rates: + return cash_flows + + if not isinstance(cash_flows.index, (pd.PeriodIndex, pd.DatetimeIndex)): + raise ValueError( + "cash_flows must be a pandas Series with a PeriodIndex or DatetimeIndex" + ) + + df = cash_flows.to_frame(name="cash_flow") # type: ignore + df["year"] = df.index.year + + # Merge with the discount rates based on the year + tmp = df.merge( + pd.DataFrame({"year": disc_rates.years, "rate": disc_rates.rates}), + on="year", + how="left", + ) + tmp.index = df.index + df = tmp.copy() + df["discount_factor"] = (1 / (1 + df["rate"])) ** ( + df.index.year - start_date.year + ) + + # Apply the discount factors to the cash flows + df["npv_cash_flow"] = df["cash_flow"] * df["discount_factor"] + return df["npv_cash_flow"] From bf0026264b5072212ed008637cc3704b5df20aa9 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 18 Dec 2025 11:07:14 +0100 Subject: [PATCH 06/61] adds __init__ --- climada/trajectories/__init__.py | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 climada/trajectories/__init__.py diff --git a/climada/trajectories/__init__.py b/climada/trajectories/__init__.py new file mode 100644 index 0000000000..91aca62d1c --- /dev/null +++ b/climada/trajectories/__init__.py @@ -0,0 +1,28 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +This module implements risk trajectory objects which enable computation and +possibly interpolation of risk metric over multiple dates. + +""" + +from .snapshot import Snapshot + +__all__ = [ + "Snapshot", +] From 6eee8c5798a2296ce81370f912324c5b2c8c1aec Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 18 Dec 2025 11:09:03 +0100 Subject: [PATCH 07/61] cherry picks __init__ --- climada/trajectories/__init__.py | 35 ++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 climada/trajectories/__init__.py diff --git a/climada/trajectories/__init__.py b/climada/trajectories/__init__.py new file mode 100644 index 0000000000..db58a711ca --- /dev/null +++ b/climada/trajectories/__init__.py @@ -0,0 +1,35 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +This module implements risk trajectory objects which enable computation and +possibly interpolation of risk metric over multiple dates. + +""" + +from .interpolated_trajectory import InterpolatedRiskTrajectory +from .interpolation import AllLinearStrategy, ExponentialExposureStrategy +from .snapshot import Snapshot +from .static_trajectory import StaticRiskTrajectory + +__all__ = [ + "InterpolatedRiskTrajectory", + "AllLinearStrategy", + "ExponentialExposureStrategy", + "Snapshot", + "StaticRiskTrajectory", +] From d11871fbd1cd5b0d0cb6c32e74ef1594075131d9 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 18 Dec 2025 11:09:34 +0100 Subject: [PATCH 08/61] cherry pick __init__ (for real) --- climada/trajectories/__init__.py | 6 ------ 1 file changed, 6 deletions(-) diff --git a/climada/trajectories/__init__.py b/climada/trajectories/__init__.py index db58a711ca..5e0016c39d 100644 --- a/climada/trajectories/__init__.py +++ b/climada/trajectories/__init__.py @@ -21,15 +21,9 @@ """ -from .interpolated_trajectory import InterpolatedRiskTrajectory from .interpolation import AllLinearStrategy, ExponentialExposureStrategy -from .snapshot import Snapshot -from .static_trajectory import StaticRiskTrajectory __all__ = [ - "InterpolatedRiskTrajectory", "AllLinearStrategy", "ExponentialExposureStrategy", - "Snapshot", - "StaticRiskTrajectory", ] From 50ab78bf8abcf465d53c684e11fb4b6d417fc7d4 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 18 Dec 2025 11:10:45 +0100 Subject: [PATCH 09/61] cherry picks __init__ --- climada/trajectories/__init__.py | 33 ++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 climada/trajectories/__init__.py diff --git a/climada/trajectories/__init__.py b/climada/trajectories/__init__.py new file mode 100644 index 0000000000..575b993969 --- /dev/null +++ b/climada/trajectories/__init__.py @@ -0,0 +1,33 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +This module implements risk trajectory objects which enable computation and +possibly interpolation of risk metric over multiple dates. + +""" + +from .interpolation import AllLinearStrategy, ExponentialExposureStrategy +from .snapshot import Snapshot +from .static_trajectory import StaticRiskTrajectory + +__all__ = [ + "AllLinearStrategy", + "ExponentialExposureStrategy", + "Snapshot", + "StaticRiskTrajectory", +] From 6be5e6cfd5592c46ff28541d20b7e0172788d5fe Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 18 Dec 2025 11:17:14 +0100 Subject: [PATCH 10/61] namespace fixes --- climada/trajectories/static_trajectory.py | 2 +- climada/trajectories/test/test_calc_risk_metrics.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/climada/trajectories/static_trajectory.py b/climada/trajectories/static_trajectory.py index 73944b6639..c9da1949a6 100644 --- a/climada/trajectories/static_trajectory.py +++ b/climada/trajectories/static_trajectory.py @@ -26,6 +26,7 @@ import pandas as pd from climada.entity.disc_rates.base import DiscRates +from climada.trajectories.calc_risk_metrics import CalcRiskMetricsPoints from climada.trajectories.constants import ( AAI_METRIC_NAME, AAI_PER_GROUP_METRIC_NAME, @@ -43,7 +44,6 @@ ImpactCalcComputation, ImpactComputationStrategy, ) -from climada.trajectories.riskperiod import CalcRiskMetricsPoints from climada.trajectories.snapshot import Snapshot from climada.trajectories.trajectory import ( DEFAULT_ALLGROUP_NAME, diff --git a/climada/trajectories/test/test_calc_risk_metrics.py b/climada/trajectories/test/test_calc_risk_metrics.py index 493736d350..7485f3cd3f 100644 --- a/climada/trajectories/test/test_calc_risk_metrics.py +++ b/climada/trajectories/test/test_calc_risk_metrics.py @@ -430,7 +430,7 @@ def test_calc_return_periods_metric(self): self.assertEqual(result_df[GROUP_COL_NAME].dtype.name, "category") @patch.object(Snapshot, "apply_measure") - @patch("climada.trajectories.riskperiod.CalcRiskMetricsPoints") + @patch("climada.trajectories.calc_risk_metrics.CalcRiskMetricsPoints") def test_apply_measure(self, mock_CalcRiskMetricPoints, mock_snap_apply_measure): mock_CalcRiskMetricPoints.return_value = MagicMock(spec=CalcRiskMetricsPoints) mock_snap_apply_measure.return_value = 42 From 0e99117c6f1bd4007063c7a3fa7b351c6f50ca86 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 18 Dec 2025 11:17:26 +0100 Subject: [PATCH 11/61] cherry picks dataframe handling --- climada/util/dataframe_handling.py | 63 ++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 climada/util/dataframe_handling.py diff --git a/climada/util/dataframe_handling.py b/climada/util/dataframe_handling.py new file mode 100644 index 0000000000..b5ac6bef97 --- /dev/null +++ b/climada/util/dataframe_handling.py @@ -0,0 +1,63 @@ +""" +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 . + +--- + +Define functions to handle with coordinates +""" + +import pandas as pd + + +def reorder_dataframe_columns( + df: pd.DataFrame, priority_order: list[str], keep_remaining: bool = True +) -> pd.DataFrame | pd.Series: + """ + Applies a column priority list to a DataFrame to reorder its columns. + + This function is robust to cases where: + 1. Columns in 'priority_order' are not in the DataFrame (they are ignored). + 2. Columns in the DataFrame are not in 'priority_order'. + + Parameters + ---------- + df: pd.DataFrame + The input DataFrame. + priority_order: list[str] + A list of strings defining the desired column + order. Columns listed first have higher priority. + keep_remaining: bool + If True, any columns in the DataFrame but NOT in + 'priority_order' will be appended to the end in their + original relative order. If False, these columns + are dropped. + + Returns: + pd.DataFrame: The DataFrame with columns reordered according to the priority list. + """ + + present_priority_columns = [col for col in priority_order if col in df.columns] + + new_column_order = present_priority_columns + + if keep_remaining: + remaining_columns = [ + col for col in df.columns if col not in present_priority_columns + ] + + new_column_order.extend(remaining_columns) + + return df[new_column_order] From dd63bf497c9310b0721ca038ae38767a9d2ac4b0 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 18 Dec 2025 14:44:23 +0100 Subject: [PATCH 12/61] Introduces on/off option for caching --- climada/trajectories/calc_risk_metrics.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/climada/trajectories/calc_risk_metrics.py b/climada/trajectories/calc_risk_metrics.py index 2d325fb495..ce3818593c 100644 --- a/climada/trajectories/calc_risk_metrics.py +++ b/climada/trajectories/calc_risk_metrics.py @@ -56,6 +56,8 @@ "CalcRiskMetricsPoints", ] +_CACHE_SETTINGS = {"ENABLE_LAZY_CACHE": False} + def lazy_property(method): # This function is used as a decorator for properties @@ -67,11 +69,12 @@ def lazy_property(method): @property def _lazy(self): + if not _CACHE_SETTINGS.get("ENABLE_LAZY_CACHE", True): + return method(self) + if getattr(self, attr_name) is None: - # LOGGER.debug( - # f"Computing {method.__name__} for {self._snapshot0.date}-{self._snapshot1.date} with {meas_n}." - # ) setattr(self, attr_name, method(self)) + return getattr(self, attr_name) return _lazy From a6932e810ec3a9cb749d246af5a963d9ec7635ef Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 18 Dec 2025 14:44:55 +0100 Subject: [PATCH 13/61] removes redondant code --- climada/trajectories/calc_risk_metrics.py | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/climada/trajectories/calc_risk_metrics.py b/climada/trajectories/calc_risk_metrics.py index ce3818593c..e7ba88c143 100644 --- a/climada/trajectories/calc_risk_metrics.py +++ b/climada/trajectories/calc_risk_metrics.py @@ -185,8 +185,7 @@ def per_date_aai(self) -> np.ndarray: return np.array([imp.aai_agg for imp in self.impacts]) - @lazy_property - def eai_gdf(self) -> pd.DataFrame: + def calc_eai_gdf(self) -> pd.DataFrame: """Convenience function returning a DataFrame (with both datetime and coordinates) from `per_date_eai`. This can easily be merged with the GeoDataFrame of the exposure object of one of the `Snapshot`. @@ -196,10 +195,6 @@ def eai_gdf(self) -> pd.DataFrame: The DataFrame from the first snapshot of the list is used as a basis (notably for `value` and `group_id`). """ - return self.calc_eai_gdf() - - def calc_eai_gdf(self) -> pd.DataFrame: - """Merge the per date EAIs of the risk period with the Dataframe of the exposure of the starting snapshot.""" df = pd.DataFrame(self.per_date_eai, index=self._date_idx) df = df.reset_index().melt( @@ -257,7 +252,7 @@ def calc_aai_per_group_metric(self) -> pd.DataFrame | None: ) return None - eai_pres_groups = self.eai_gdf[ + eai_pres_groups = self.calc_eai_gdf()[ [DATE_COL_NAME, COORD_ID_COL_NAME, GROUP_COL_NAME, RISK_COL_NAME] ].copy() aai_per_group_df = eai_pres_groups.groupby( From 49e1cad666e740602b29016434ba2f282e255cf2 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 18 Dec 2025 14:55:42 +0100 Subject: [PATCH 14/61] Clarifies docstring --- climada/trajectories/static_trajectory.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/climada/trajectories/static_trajectory.py b/climada/trajectories/static_trajectory.py index c9da1949a6..281887f347 100644 --- a/climada/trajectories/static_trajectory.py +++ b/climada/trajectories/static_trajectory.py @@ -110,7 +110,7 @@ def __init__( The return periods to use when computing the `return_periods_metric`. Defaults to `DEFAULT_RP` ([20, 50, 100]). all_groups_name: str, optional - The string to use to define all exposure points subgroup. + The string that should be used to define "all exposure points" subgroup. Defaults to `DEFAULT_ALLGROUP_NAME` ("All"). risk_disc_rates: DiscRates, optional The discount rate to apply to future risk. Defaults to None. From cc74d4abd28d96f851c38dbc13d8135e06ae259e Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 18 Dec 2025 14:58:52 +0100 Subject: [PATCH 15/61] Cherry picks tests --- climada/test/test_trajectories.py | 289 +++++++++++++ .../test/test_static_risk_trajectory.py | 379 ++++++++++++++++++ 2 files changed, 668 insertions(+) create mode 100644 climada/test/test_trajectories.py create mode 100644 climada/trajectories/test/test_static_risk_trajectory.py diff --git a/climada/test/test_trajectories.py b/climada/test/test_trajectories.py new file mode 100644 index 0000000000..bc47ff531e --- /dev/null +++ b/climada/test/test_trajectories.py @@ -0,0 +1,289 @@ +""" +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 . +--- + +Test trajectories. + +""" + +import copy +from itertools import groupby +from unittest import TestCase + +import geopandas as gpd +import numpy as np +import pandas as pd + +from climada.engine.impact_calc import ImpactCalc +from climada.entity.disc_rates.base import DiscRates +from climada.entity.impact_funcs.base import ImpactFunc +from climada.entity.impact_funcs.impact_func_set import ImpactFuncSet +from climada.test.reusable import ( + CATEGORIES, + reusable_minimal_exposures, + reusable_minimal_hazard, + reusable_minimal_impfset, + reusable_snapshot, +) +from climada.trajectories import StaticRiskTrajectory +from climada.trajectories.constants import ( + AAI_METRIC_NAME, + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + DATE_COL_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + NO_MEASURE_VALUE, + PERIOD_COL_NAME, + RISK_COL_NAME, + UNIT_COL_NAME, +) +from climada.trajectories.snapshot import Snapshot +from climada.trajectories.trajectory import DEFAULT_RP + + +class TestStaticTrajectory(TestCase): + PRESENT_DATE = 2020 + HAZ_INCREASE_INTENSITY_FACTOR = 2 + EXP_INCREASE_VALUE_FACTOR = 10 + FUTURE_DATE = 2040 + + def setUp(self) -> None: + self.base_snapshot = reusable_snapshot(date=self.PRESENT_DATE) + self.future_snapshot = reusable_snapshot( + hazard_intensity_increase_factor=self.HAZ_INCREASE_INTENSITY_FACTOR, + exposure_value_increase_factor=self.EXP_INCREASE_VALUE_FACTOR, + date=self.FUTURE_DATE, + ) + + self.expected_base_imp = ImpactCalc( + **self.base_snapshot.impact_calc_data + ).impact() + self.expected_future_imp = ImpactCalc( + **self.future_snapshot.impact_calc_data + ).impact() + # self.group_vector = self.base_snapshot.exposure.gdf[GROUP_ID_COL_NAME] + self.expected_base_return_period_impacts = { + rp: imp + for rp, imp in zip( + self.expected_base_imp.calc_freq_curve(DEFAULT_RP).return_per, + self.expected_base_imp.calc_freq_curve(DEFAULT_RP).impact, + ) + } + self.expected_future_return_period_impacts = { + rp: imp + for rp, imp in zip( + self.expected_future_imp.calc_freq_curve(DEFAULT_RP).return_per, + self.expected_future_imp.calc_freq_curve(DEFAULT_RP).impact, + ) + } + + # fmt: off + self.expected_static_metrics = pd.DataFrame.from_dict( + {'index': [0, 1, 2, 3, 4, 5, 6, 7], + 'columns': [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME, UNIT_COL_NAME, RISK_COL_NAME], + 'data': [ + [pd.Timestamp(str(self.PRESENT_DATE)), 'All', NO_MEASURE_VALUE, 'aai', 'USD', self.expected_base_imp.aai_agg], + [pd.Timestamp(str(self.FUTURE_DATE)), 'All', NO_MEASURE_VALUE, 'aai', 'USD', self.expected_future_imp.aai_agg], + [pd.Timestamp(str(self.PRESENT_DATE)), 'All', NO_MEASURE_VALUE, f'rp_{DEFAULT_RP[0]}', 'USD', self.expected_base_return_period_impacts[DEFAULT_RP[0]]], + [pd.Timestamp(str(self.FUTURE_DATE)), 'All', NO_MEASURE_VALUE, f'rp_{DEFAULT_RP[0]}', 'USD', self.expected_future_return_period_impacts[DEFAULT_RP[0]]], + [pd.Timestamp(str(self.PRESENT_DATE)), 'All', NO_MEASURE_VALUE, f'rp_{DEFAULT_RP[1]}', 'USD', self.expected_base_return_period_impacts[DEFAULT_RP[1]]], + [pd.Timestamp(str(self.FUTURE_DATE)), 'All', NO_MEASURE_VALUE, f'rp_{DEFAULT_RP[1]}', 'USD', self.expected_future_return_period_impacts[DEFAULT_RP[1]]], + [pd.Timestamp(str(self.PRESENT_DATE)), 'All', NO_MEASURE_VALUE, f'rp_{DEFAULT_RP[2]}', 'USD', self.expected_base_return_period_impacts[DEFAULT_RP[2]]], + [pd.Timestamp(str(self.FUTURE_DATE)), 'All', NO_MEASURE_VALUE, f'rp_{DEFAULT_RP[2]}', 'USD', self.expected_future_return_period_impacts[DEFAULT_RP[2]]], + ], + 'index_names': [None], + 'column_names': [None]}, + orient="tight" + ) + # fmt: on + + def test_static_trajectory(self): + static_traj = StaticRiskTrajectory([self.base_snapshot, self.future_snapshot]) + print(static_traj.per_date_risk_metrics()) + pd.testing.assert_frame_equal( + static_traj.per_date_risk_metrics(), + self.expected_static_metrics, + check_dtype=False, + check_categorical=False, + ) + + def test_static_trajectory_one_snap(self): + static_traj = StaticRiskTrajectory([self.base_snapshot]) + expected = pd.DataFrame.from_dict( + # fmt: off + { + "index": [0, 1, 2, 3], + "columns": [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME, UNIT_COL_NAME, RISK_COL_NAME,], + "data": [ + [pd.Timestamp(str(self.PRESENT_DATE)), "All", NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", self.expected_base_imp.aai_agg,], + [pd.Timestamp(str(self.PRESENT_DATE)), "All", NO_MEASURE_VALUE, f"rp_{DEFAULT_RP[0]}", "USD", self.expected_base_return_period_impacts[DEFAULT_RP[0]],], + [pd.Timestamp(str(self.PRESENT_DATE)), "All", NO_MEASURE_VALUE, f"rp_{DEFAULT_RP[1]}", "USD", self.expected_base_return_period_impacts[DEFAULT_RP[1]],], + [pd.Timestamp(str(self.PRESENT_DATE)), "All", NO_MEASURE_VALUE, f"rp_{DEFAULT_RP[2]}", "USD", self.expected_base_return_period_impacts[DEFAULT_RP[2]],], + ], + "index_names": [None], + "column_names": [None], + }, + # fmt: on + orient="tight", + ) + + pd.testing.assert_frame_equal( + static_traj.per_date_risk_metrics(), + expected, + check_dtype=False, + check_categorical=False, + ) + + def test_static_trajectory_with_group(self): + exp0 = reusable_minimal_exposures(group_id=CATEGORIES) + exp1 = reusable_minimal_exposures( + group_id=CATEGORIES, increase_value_factor=self.EXP_INCREASE_VALUE_FACTOR + ) + snap0 = Snapshot( + exposure=exp0, + hazard=reusable_minimal_hazard(), + impfset=reusable_minimal_impfset(), + date=self.PRESENT_DATE, + ) + snap1 = Snapshot( + exposure=exp1, + hazard=reusable_minimal_hazard( + intensity_factor=self.HAZ_INCREASE_INTENSITY_FACTOR + ), + impfset=reusable_minimal_impfset(), + date=self.FUTURE_DATE, + ) + + expected_static_metrics = pd.concat( + [ + self.expected_static_metrics, + pd.DataFrame.from_dict( + # fmt: off + { + "index": [8, 9, 10, 11], + "columns": [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME, UNIT_COL_NAME, RISK_COL_NAME,], + "data": [ + [pd.Timestamp(str(self.PRESENT_DATE)), 1, NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", self.expected_base_imp.eai_exp[CATEGORIES == 1].sum(),], + [pd.Timestamp(str(self.PRESENT_DATE)), 2, NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", self.expected_base_imp.eai_exp[CATEGORIES == 2].sum(),], + [pd.Timestamp(str(self.FUTURE_DATE)), 1, NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", self.expected_future_imp.eai_exp[CATEGORIES == 1].sum(),], + [pd.Timestamp(str(self.FUTURE_DATE)), 2, NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", self.expected_future_imp.eai_exp[CATEGORIES == 2].sum(),], + ], + "index_names": [None], + "column_names": [None], + }, + # fmt: on + orient="tight", + ), + ] + ) + + static_traj = StaticRiskTrajectory([snap0, snap1]) + pd.testing.assert_frame_equal( + static_traj.per_date_risk_metrics(), + expected_static_metrics, + check_dtype=False, + check_categorical=False, + ) + + def test_static_trajectory_change_rp(self): + static_traj = StaticRiskTrajectory( + [self.base_snapshot, self.future_snapshot], return_periods=[10, 60, 1000] + ) + expected = pd.DataFrame.from_dict( + # fmt: off + { + "index": [0, 1, 2, 3, 4, 5, 6, 7], + "columns": [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME, UNIT_COL_NAME, RISK_COL_NAME,], + "data": [ + [pd.Timestamp(str(self.PRESENT_DATE)),"All", NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", self.expected_base_imp.aai_agg,], + [pd.Timestamp(str(self.FUTURE_DATE)), "All", NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", self.expected_future_imp.aai_agg,], + [pd.Timestamp(str(self.PRESENT_DATE)),"All", NO_MEASURE_VALUE, "rp_10", "USD", 0.0,], + [pd.Timestamp(str(self.FUTURE_DATE)), "All", NO_MEASURE_VALUE, "rp_10", "USD", 0.0,], + [pd.Timestamp(str(self.PRESENT_DATE)),"All", NO_MEASURE_VALUE, "rp_60", "USD", 700.0,], + [pd.Timestamp(str(self.FUTURE_DATE)), "All", NO_MEASURE_VALUE, "rp_60", "USD", 14000.0,], + [pd.Timestamp(str(self.PRESENT_DATE)),"All", NO_MEASURE_VALUE, "rp_1000", "USD", 1500.0,], + [pd.Timestamp(str(self.FUTURE_DATE)), "All", NO_MEASURE_VALUE, "rp_1000", "USD", 30000.0,], + ], + "index_names": [None], + "column_names": [None], + }, + # fmt: on + orient="tight", + ) + pd.testing.assert_frame_equal( + static_traj.per_date_risk_metrics(), + expected, + check_dtype=False, + check_categorical=False, + ) + + # Also check change to other return period + static_traj.return_periods = DEFAULT_RP + pd.testing.assert_frame_equal( + static_traj.per_date_risk_metrics(), + self.expected_static_metrics, + check_dtype=False, + check_categorical=False, + ) + + def test_static_trajectory_risk_disc_rate(self): + risk_disc_rate = DiscRates( + years=np.array(range(self.PRESENT_DATE, 2041)), rates=np.ones(21) * 0.01 + ) + static_traj = StaticRiskTrajectory( + [self.base_snapshot, self.future_snapshot], risk_disc_rates=risk_disc_rate + ) + expected = pd.DataFrame.from_dict( + # fmt: off + { + "index": [0, 1, 2, 3, 4, 5, 6, 7], + "columns": [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME, UNIT_COL_NAME, RISK_COL_NAME,], + "data": [ + [pd.Timestamp(str(self.PRESENT_DATE)),"All", NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", self.expected_base_imp.aai_agg,], + [pd.Timestamp(str(self.FUTURE_DATE)), "All", NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", self.expected_future_imp.aai_agg * ((1 / (1 + 0.01)) ** 20),], + [pd.Timestamp(str(self.PRESENT_DATE)),"All", NO_MEASURE_VALUE, f"rp_{DEFAULT_RP[0]}", "USD", self.expected_base_return_period_impacts[DEFAULT_RP[0]],], + [pd.Timestamp(str(self.FUTURE_DATE)), "All", NO_MEASURE_VALUE, f"rp_{DEFAULT_RP[0]}", "USD", self.expected_future_return_period_impacts[DEFAULT_RP[0]] * ((1 / (1 + 0.01)) ** 20),], + [pd.Timestamp(str(self.PRESENT_DATE)),"All", NO_MEASURE_VALUE, f"rp_{DEFAULT_RP[1]}", "USD", self.expected_base_return_period_impacts[DEFAULT_RP[1]],], + [pd.Timestamp(str(self.FUTURE_DATE)), "All", NO_MEASURE_VALUE, f"rp_{DEFAULT_RP[1]}", "USD", self.expected_future_return_period_impacts[DEFAULT_RP[1]] * ((1 / (1 + 0.01)) ** 20),], + [pd.Timestamp(str(self.PRESENT_DATE)),"All", NO_MEASURE_VALUE, f"rp_{DEFAULT_RP[2]}", "USD", self.expected_base_return_period_impacts[DEFAULT_RP[2]],], + [pd.Timestamp(str(self.FUTURE_DATE)), "All", NO_MEASURE_VALUE, f"rp_{DEFAULT_RP[2]}", "USD", self.expected_future_return_period_impacts[DEFAULT_RP[2]] * ((1 / (1 + 0.01)) ** 20),], + ], + "index_names": [None], + "column_names": [None], + }, + # fmt: on + orient="tight", + ) + pd.testing.assert_frame_equal( + static_traj.per_date_risk_metrics(), + expected, + check_dtype=False, + check_categorical=False, + ) + + # Also check change to other return period + static_traj.risk_disc_rates = None + pd.testing.assert_frame_equal( + static_traj.per_date_risk_metrics(), + self.expected_static_metrics, + check_dtype=False, + check_categorical=False, + ) diff --git a/climada/trajectories/test/test_static_risk_trajectory.py b/climada/trajectories/test/test_static_risk_trajectory.py new file mode 100644 index 0000000000..7576c957f9 --- /dev/null +++ b/climada/trajectories/test/test_static_risk_trajectory.py @@ -0,0 +1,379 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +unit tests for static_risk_trajectory + +""" + +import datetime +import types +import unittest +from itertools import product +from unittest.mock import MagicMock, Mock, call, patch + +import numpy as np # For potential NaN/NA comparisons +import pandas as pd + +from climada.entity.disc_rates.base import DiscRates +from climada.trajectories.calc_risk_metrics import ( # ImpactComputationStrategy, # If needed to mock its base class directly + CalcRiskMetricsPoints, +) +from climada.trajectories.constants import ( + AAI_METRIC_NAME, + AAI_PER_GROUP_METRIC_NAME, + DATE_COL_NAME, + EAI_METRIC_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + RETURN_PERIOD_METRIC_NAME, + RISK_COL_NAME, +) +from climada.trajectories.impact_calc_strat import ImpactCalcComputation +from climada.trajectories.snapshot import Snapshot +from climada.trajectories.static_trajectory import ( + DEFAULT_ALLGROUP_NAME, + DEFAULT_RP, + StaticRiskTrajectory, +) + + +class TestStaticRiskTrajectory(unittest.TestCase): + def setUp(self) -> None: + self.dates1 = [pd.Timestamp("2023-01-01"), pd.Timestamp("2024-01-01")] + self.dates2 = [pd.Timestamp("2026-01-01")] + self.groups = ["GroupA", "GroupB", pd.NA] + self.measures = ["MEAS1", "MEAS2"] + self.metrics = [AAI_METRIC_NAME] + self.aai_dates1 = pd.DataFrame( + product(self.groups, self.dates1, self.measures, self.metrics), + columns=[GROUP_COL_NAME, DATE_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME], + ) + self.aai_dates1[RISK_COL_NAME] = np.arange(12) * 100 + self.aai_dates1[GROUP_COL_NAME] = self.aai_dates1[GROUP_COL_NAME].astype( + "category" + ) + + self.aai_dates2 = pd.DataFrame( + product(self.groups, self.dates2, self.measures, self.metrics), + columns=[GROUP_COL_NAME, DATE_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME], + ) + self.aai_dates2[RISK_COL_NAME] = np.arange(6) * 100 + 1200 + self.aai_dates2[GROUP_COL_NAME] = self.aai_dates2[GROUP_COL_NAME].astype( + "category" + ) + + self.aai_alldates = pd.DataFrame( + product( + self.groups, self.dates1 + self.dates2, self.measures, self.metrics + ), + columns=[GROUP_COL_NAME, DATE_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME], + ) + self.aai_alldates[RISK_COL_NAME] = np.arange(18) * 100 + self.aai_alldates[GROUP_COL_NAME] = self.aai_alldates[GROUP_COL_NAME].astype( + "category" + ) + self.aai_alldates[GROUP_COL_NAME] = self.aai_alldates[ + GROUP_COL_NAME + ].cat.add_categories([DEFAULT_ALLGROUP_NAME]) + self.aai_alldates[GROUP_COL_NAME] = self.aai_alldates[GROUP_COL_NAME].fillna( + DEFAULT_ALLGROUP_NAME + ) + self.expected_pre_npv_aai = self.aai_alldates + self.expected_pre_npv_aai = self.expected_pre_npv_aai[ + [ + DATE_COL_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + RISK_COL_NAME, + ] + ] + + self.expected_npv_aai = pd.DataFrame( + product( + self.dates1 + self.dates2, self.groups, self.measures, self.metrics + ), + columns=[DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME], + ) + self.expected_npv_aai[RISK_COL_NAME] = np.arange(18) * 90 + self.expected_npv_aai[GROUP_COL_NAME] = self.expected_npv_aai[ + GROUP_COL_NAME + ].astype("category") + self.expected_npv_aai[GROUP_COL_NAME] = self.expected_npv_aai[ + GROUP_COL_NAME + ].cat.add_categories(["All"]) + self.expected_npv_aai[GROUP_COL_NAME] = self.expected_npv_aai[ + GROUP_COL_NAME + ].fillna(DEFAULT_ALLGROUP_NAME) + expected_npv_df = self.expected_npv_aai + expected_npv_df = expected_npv_df[ + [ + DATE_COL_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + RISK_COL_NAME, + ] + ] + + self.mock_snapshot1 = MagicMock(spec=Snapshot) + self.mock_snapshot1.date = datetime.date(2023, 1, 1) + + self.mock_snapshot2 = MagicMock(spec=Snapshot) + self.mock_snapshot2.date = datetime.date(2024, 1, 1) + + self.mock_snapshot3 = MagicMock(spec=Snapshot) + self.mock_snapshot3.date = datetime.date(2026, 1, 1) + + self.snapshots_list: list[Snapshot] = [ + self.mock_snapshot1, + self.mock_snapshot2, + self.mock_snapshot3, + ] + + self.risk_disc_rates = MagicMock(spec=DiscRates) + self.risk_disc_rates.years = [2023, 2024, 2025, 2026] + self.risk_disc_rates.rates = [0.01, 0.02, 0.03, 0.04] # Example rates + + self.mock_impact_computation_strategy = MagicMock(spec=ImpactCalcComputation) + + self.custom_all_groups_name = "custom" + self.custom_return_periods = [10, 20] + + self.mock_static_traj = MagicMock(spec=StaticRiskTrajectory) + self.mock_static_traj._all_groups_name = DEFAULT_ALLGROUP_NAME + self.mock_static_traj._risk_disc_rates = None + self.mock_static_traj._risk_metrics_calculators = MagicMock( + spec=CalcRiskMetricsPoints + ) + + @patch( + "climada.trajectories.static_trajectory.CalcRiskMetricsPoints", + autospec=True, + ) + def test_init_basic(self, MockCalcRiskPoints): + mock_calculator = MagicMock(spec=CalcRiskMetricsPoints) + mock_calculator.impact_computation_strategy = ( + self.mock_impact_computation_strategy + ) + MockCalcRiskPoints.return_value = mock_calculator + rt = StaticRiskTrajectory( + self.snapshots_list, + impact_computation_strategy=self.mock_impact_computation_strategy, + ) + MockCalcRiskPoints.assert_has_calls( + [ + call( + self.snapshots_list, + impact_computation_strategy=self.mock_impact_computation_strategy, + ), + ] + ) + self.assertEqual(rt.start_date, self.mock_snapshot1.date) + self.assertEqual(rt.end_date, self.mock_snapshot3.date) + self.assertIsNone(rt._risk_disc_rates) + self.assertEqual(rt._all_groups_name, DEFAULT_ALLGROUP_NAME) + self.assertEqual(rt._return_periods, DEFAULT_RP) + self.assertEqual( + rt.impact_computation_strategy, self.mock_impact_computation_strategy + ) + # Check that metrics are reset (initially None) + for metric in StaticRiskTrajectory.POSSIBLE_METRICS: + self.assertIsNone(getattr(rt, "_" + metric + "_metrics")) + + @patch( + "climada.trajectories.static_trajectory.CalcRiskMetricsPoints", + autospec=True, + ) + def test_init_args(self, mock_calc_risk_metrics_points): + rt = StaticRiskTrajectory( + self.snapshots_list, + return_periods=self.custom_return_periods, + all_groups_name=self.custom_all_groups_name, + risk_disc_rates=self.risk_disc_rates, + impact_computation_strategy=self.mock_impact_computation_strategy, + ) + self.assertEqual(rt.start_date, self.mock_snapshot1.date) + self.assertEqual(rt.end_date, self.mock_snapshot3.date) + self.assertEqual(rt._risk_disc_rates, self.risk_disc_rates) + self.assertEqual(rt._all_groups_name, self.custom_all_groups_name) + self.assertEqual(rt._return_periods, self.custom_return_periods) + self.assertEqual(rt.return_periods, self.custom_return_periods) + # Check that metrics are reset (initially None) + for metric in StaticRiskTrajectory.POSSIBLE_METRICS: + self.assertIsNone(getattr(rt, "_" + metric + "_metrics")) + self.assertIsInstance(rt._risk_metrics_calculators, CalcRiskMetricsPoints) + mock_calc_risk_metrics_points.assert_called_with( + self.snapshots_list, + impact_computation_strategy=self.mock_impact_computation_strategy, + ) + + @patch.object(StaticRiskTrajectory, "_reset_metrics", new_callable=Mock) + @patch( + "climada.trajectories.static_trajectory.CalcRiskMetricsPoints", + autospec=True, + ) + def test_set_impact_computation_strategy( + self, mock_calc_risk_metrics_points, mock_reset_metrics + ): + rt = StaticRiskTrajectory( + self.snapshots_list, + impact_computation_strategy=self.mock_impact_computation_strategy, + ) + mock_reset_metrics.assert_called_once() # Called during init + with self.assertRaises(ValueError): + rt.impact_computation_strategy = "A" + + # There is only one possibility at the moment so we just check against a new object + new_impact_calc = ImpactCalcComputation() + rt.impact_computation_strategy = new_impact_calc + self.assertEqual(rt.impact_computation_strategy, new_impact_calc) + mock_reset_metrics.assert_has_calls([call(), call()]) + + def test_generic_metrics(self): + self.mock_static_traj.POSSIBLE_METRICS = StaticRiskTrajectory.POSSIBLE_METRICS + self.mock_static_traj._generic_metrics = types.MethodType( + StaticRiskTrajectory._generic_metrics, self.mock_static_traj + ) + self.mock_static_traj._risk_disc_rates = self.risk_disc_rates + self.mock_static_traj._aai_metrics = None + with self.assertRaises(ValueError): + self.mock_static_traj._generic_metrics(None, "dummy_meth") + + with self.assertRaises(NotImplementedError): + self.mock_static_traj._generic_metrics("dummy_name", "dummy_meth") + + self.mock_static_traj._risk_metrics_calculators.calc_aai_metric.return_value = ( + self.aai_alldates + ) + self.mock_static_traj.npv_transform.return_value = self.expected_npv_aai + result = self.mock_static_traj._generic_metrics( + AAI_METRIC_NAME, "calc_aai_metric" + ) + + self.mock_static_traj._risk_metrics_calculators.calc_aai_metric.assert_called_once_with() + self.mock_static_traj.npv_transform.assert_called_once() + pd.testing.assert_frame_equal( + self.mock_static_traj.npv_transform.call_args[0][0].reset_index(drop=True), + self.expected_pre_npv_aai.reset_index(drop=True), + ) + self.assertEqual( + self.mock_static_traj.npv_transform.call_args[0][1], self.risk_disc_rates + ) + pd.testing.assert_frame_equal( + result, self.expected_npv_aai + ) # Final result is from NPV transform + + # Check internal storage + stored_df = getattr(self.mock_static_traj, "_aai_metrics") + # Assert that the stored DF is the one *before* NPV transformation + pd.testing.assert_frame_equal( + stored_df.reset_index(drop=True), + self.expected_npv_aai.reset_index(drop=True), + ) + + result2 = self.mock_static_traj._generic_metrics( + AAI_METRIC_NAME, "calc_aai_metric" + ) + # Check no new call + self.mock_static_traj._risk_metrics_calculators.calc_aai_metric.assert_called_once_with() + pd.testing.assert_frame_equal( + result2, + self.expected_npv_aai.reset_index(drop=True), + ) + + def test_eai_metrics(self): + self.mock_static_traj.eai_metrics = types.MethodType( + StaticRiskTrajectory.eai_metrics, self.mock_static_traj + ) + self.mock_static_traj.eai_metrics(some_arg="test") + self.mock_static_traj._compute_metrics.assert_called_once_with( + metric_name=EAI_METRIC_NAME, metric_meth="calc_eai_gdf", some_arg="test" + ) + + def test_aai_metrics(self): + self.mock_static_traj.aai_metrics = types.MethodType( + StaticRiskTrajectory.aai_metrics, self.mock_static_traj + ) + self.mock_static_traj.aai_metrics(some_arg="test") + self.mock_static_traj._compute_metrics.assert_called_once_with( + metric_name=AAI_METRIC_NAME, metric_meth="calc_aai_metric", some_arg="test" + ) + + def test_return_periods_metrics(self): + self.mock_static_traj.return_periods = [1, 2] + self.mock_static_traj.return_periods_metrics = types.MethodType( + StaticRiskTrajectory.return_periods_metrics, self.mock_static_traj + ) + self.mock_static_traj.return_periods_metrics(some_arg="test") + self.mock_static_traj._compute_metrics.assert_called_once_with( + metric_name=RETURN_PERIOD_METRIC_NAME, + metric_meth="calc_return_periods_metric", + return_periods=[1, 2], + some_arg="test", + ) + + def test_aai_per_group_metrics(self): + self.mock_static_traj.aai_per_group_metrics = types.MethodType( + StaticRiskTrajectory.aai_per_group_metrics, self.mock_static_traj + ) + self.mock_static_traj.aai_per_group_metrics(some_arg="test") + self.mock_static_traj._compute_metrics.assert_called_once_with( + metric_name=AAI_PER_GROUP_METRIC_NAME, + metric_meth="calc_aai_per_group_metric", + some_arg="test", + ) + + def test_per_date_risk_metrics_defaults(self): + self.mock_static_traj.per_date_risk_metrics = types.MethodType( + StaticRiskTrajectory.per_date_risk_metrics, self.mock_static_traj + ) + # Set up mock return values for each method + self.mock_static_traj.aai_metrics.return_value = pd.DataFrame( + {METRIC_COL_NAME: [AAI_METRIC_NAME], RISK_COL_NAME: [100]} + ) + self.mock_static_traj.return_periods_metrics.return_value = pd.DataFrame( + {METRIC_COL_NAME: ["rp"], RISK_COL_NAME: [50]} + ) + self.mock_static_traj.aai_per_group_metrics.return_value = pd.DataFrame( + {METRIC_COL_NAME: ["aai_grp"], RISK_COL_NAME: [10]} + ) + result = self.mock_static_traj.per_date_risk_metrics() + + # Assert calls with default arguments + self.mock_static_traj.aai_metrics.assert_called_once_with() + self.mock_static_traj.return_periods_metrics.assert_called_once_with() + self.mock_static_traj.aai_per_group_metrics.assert_called_once_with() + + # Assert concatenation + expected_df = pd.concat( + [ + self.mock_static_traj.aai_metrics.return_value, + self.mock_static_traj.return_periods_metrics.return_value, + self.mock_static_traj.aai_per_group_metrics.return_value, + ] + ) + pd.testing.assert_frame_equal( + result.reset_index(drop=True), expected_df.reset_index(drop=True) + ) + + +if __name__ == "__main__": + TESTS = unittest.TestLoader().loadTestsFromTestCase(TestStaticRiskTrajectory) + unittest.TextTestRunner(verbosity=2).run(TESTS) From 6bf3416a313685804c7d95b9903f27b44673824e Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 18 Dec 2025 15:01:12 +0100 Subject: [PATCH 16/61] Initial data --- climada/test/common_test_fixtures.py | 210 +++++++++++++++++++++++++++ 1 file changed, 210 insertions(+) create mode 100644 climada/test/common_test_fixtures.py diff --git a/climada/test/common_test_fixtures.py b/climada/test/common_test_fixtures.py new file mode 100644 index 0000000000..5847b42e3e --- /dev/null +++ b/climada/test/common_test_fixtures.py @@ -0,0 +1,210 @@ +""" +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 . +--- + +A set of reusable objects for testing purpose. + +The objective of this file is to provide minimalistic, understandable and consistent +default objects for unit and integration testing. + +""" + +import copy +from unittest import TestCase + +import geopandas as gpd +import numpy as np +import pandas as pd +from scipy.sparse import csr_matrix +from shapely.geometry import Point + +from climada.entity import Exposures, ImpactFunc, ImpactFuncSet, ImpfTropCyclone +from climada.hazard import Centroids, Hazard +from climada.trajectories import InterpolatedRiskTrajectory, StaticRiskTrajectory +from climada.trajectories.snapshot import Snapshot + +# --------------------------------------------------------------------------- +# Coordinate system and metadata +# --------------------------------------------------------------------------- +CRS_WGS84 = "EPSG:4326" + +# --------------------------------------------------------------------------- +# Exposure attributes +# --------------------------------------------------------------------------- +EXP_DESC = "Test exposure dataset" +EXP_DESC_LATLON = "Test exposure dataset (lat/lon)" +EXPOSURE_REF_YEAR = 2020 +EXPOSURE_VALUE_UNIT = "USD" +VALUES = np.array([0, 1000, 2000, 3000]) +REGIONS = np.array(["A", "A", "B", "B"]) +CATEGORIES = np.array([1, 1, 2, 1]) + +# Exposure coordinates +EXP_LONS = np.array([4, 4.5, 4, 4.5]) +EXP_LATS = np.array([45, 45, 45.5, 45.5]) + +# --------------------------------------------------------------------------- +# Hazard definition +# --------------------------------------------------------------------------- +HAZARD_TYPE = "TEST_HAZARD_TYPE" +HAZARD_UNIT = "TEST_HAZARD_UNIT" + +# Hazard centroid positions +HAZ_JITTER = 0.1 # To test centroid matching +HAZ_LONS = EXP_LONS + HAZ_JITTER +HAZ_LATS = EXP_LATS + HAZ_JITTER + +# Hazard events +EVENT_IDS = np.array([1, 2, 3, 4]) +EVENT_NAMES = ["ev1", "ev2", "ev3", "ev4"] +DATES = np.array([1, 2, 3, 4]) + +# Frequency are choosen so that they cumulate nicely +# to correspond to 100, 50, and 20y return periods (for impacts) +FREQUENCY = np.array([0.1, 0.03, 0.01, 0.01]) +FREQUENCY_UNIT = "1/year" + +# Hazard maximum intensity +# 100 to match 0 to 100% idea +# also in line with linear 1:1 impact function +# for easy mental calculus +HAZARD_MAX_INTENSITY = 100 + +# --------------------------------------------------------------------------- +# Impact function +# --------------------------------------------------------------------------- +IMPF_ID = 1 +IMPF_NAME = "IMPF_1" + +# --------------------------------------------------------------------------- +# Future years +# --------------------------------------------------------------------------- +EXPOSURE_FUTURE_YEAR = 2040 + + +def reusable_minimal_exposures( + values=VALUES, + regions=REGIONS, + group_id=None, + lon=EXP_LONS, + lat=EXP_LATS, + crs=CRS_WGS84, + desc=EXP_DESC, + ref_year=EXPOSURE_REF_YEAR, + value_unit=EXPOSURE_VALUE_UNIT, + assign_impf=IMPF_ID, + increase_value_factor=1, +) -> Exposures: + data = gpd.GeoDataFrame( + { + "value": values * increase_value_factor, + "region_id": regions, + f"impf_{HAZARD_TYPE}": assign_impf, + "geometry": [Point(lon, lat) for lon, lat in zip(lon, lat)], + }, + crs=crs, + ) + if group_id is not None: + data["group_id"] = group_id + return Exposures( + data=data, + description=desc, + ref_year=ref_year, + value_unit=value_unit, + ) + + +def reusable_intensity_mat(max_intensity=HAZARD_MAX_INTENSITY): + # Choosen such that: + # - 1st event has 0 intensity + # - 2nd event has max intensity in first exposure point (defaulting to 0 value) + # - 3rd event has 1/2* of max intensity in second centroid + # - 4th event has 1/4* of max intensity everywhere + # *: So that you can double intensity of the hazard and expect double impacts + return csr_matrix( + [ + [0, 0, 0, 0], + [max_intensity, 0, 0, 0], + [0, max_intensity / 2, 0, 0], + [ + max_intensity / 4, + max_intensity / 4, + max_intensity / 4, + max_intensity / 4, + ], + ] + ) + + +def reusable_minimal_hazard( + haz_type=HAZARD_TYPE, + units=HAZARD_UNIT, + lat=HAZ_LATS, + lon=HAZ_LONS, + crs=CRS_WGS84, + event_id=EVENT_IDS, + event_name=EVENT_NAMES, + date=DATES, + frequency=FREQUENCY, + frequency_unit=FREQUENCY_UNIT, + intensity=None, + intensity_factor=1, +) -> Hazard: + intensity = reusable_intensity_mat() if intensity is None else intensity + intensity *= intensity_factor + return Hazard( + haz_type=haz_type, + units=units, + centroids=Centroids(lat=lat, lon=lon, crs=crs), + event_id=event_id, + event_name=event_name, + date=date, + frequency=frequency, + frequency_unit=frequency_unit, + intensity=intensity, + ) + + +def reusable_minimal_impfset( + hazard=None, name=IMPF_NAME, impf_id=IMPF_ID, max_intensity=HAZARD_MAX_INTENSITY +): + hazard = reusable_minimal_hazard() if hazard is None else hazard + return ImpactFuncSet( + [ + ImpactFunc( + haz_type=hazard.haz_type, + intensity_unit=hazard.units, + name=name, + intensity=np.array([0, max_intensity / 2, max_intensity]), + mdd=np.array([0, 0.5, 1]), + paa=np.array([1, 1, 1]), + id=impf_id, + ) + ] + ) + + +def reusable_snapshot( + hazard_intensity_increase_factor=1, + exposure_value_increase_factor=1, + date=EXPOSURE_REF_YEAR, +): + exposures = reusable_minimal_exposures( + increase_value_factor=exposure_value_increase_factor + ) + hazard = reusable_minimal_hazard(intensity_factor=hazard_intensity_increase_factor) + impfset = reusable_minimal_impfset() + return Snapshot(exposure=exposures, hazard=hazard, impfset=impfset, date=date) From 7ec7db12187894bec8f57696af583703f61f89ee Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 18 Dec 2025 15:04:12 +0100 Subject: [PATCH 17/61] cleanups test --- climada/test/test_trajectories.py | 13 +------------ 1 file changed, 1 insertion(+), 12 deletions(-) diff --git a/climada/test/test_trajectories.py b/climada/test/test_trajectories.py index bc47ff531e..5df15e2651 100644 --- a/climada/test/test_trajectories.py +++ b/climada/test/test_trajectories.py @@ -19,19 +19,14 @@ """ -import copy -from itertools import groupby from unittest import TestCase -import geopandas as gpd import numpy as np import pandas as pd from climada.engine.impact_calc import ImpactCalc from climada.entity.disc_rates.base import DiscRates -from climada.entity.impact_funcs.base import ImpactFunc -from climada.entity.impact_funcs.impact_func_set import ImpactFuncSet -from climada.test.reusable import ( +from climada.test.common_test_fixtures import ( CATEGORIES, reusable_minimal_exposures, reusable_minimal_hazard, @@ -41,17 +36,11 @@ from climada.trajectories import StaticRiskTrajectory from climada.trajectories.constants import ( AAI_METRIC_NAME, - CONTRIBUTION_BASE_RISK_NAME, - CONTRIBUTION_EXPOSURE_NAME, - CONTRIBUTION_HAZARD_NAME, - CONTRIBUTION_INTERACTION_TERM_NAME, - CONTRIBUTION_VULNERABILITY_NAME, DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME, NO_MEASURE_VALUE, - PERIOD_COL_NAME, RISK_COL_NAME, UNIT_COL_NAME, ) From 7349bc7392e9f4cc55bb5e0121d390266b5a5766 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 18 Dec 2025 15:04:40 +0100 Subject: [PATCH 18/61] cleansup --- climada/test/common_test_fixtures.py | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/climada/test/common_test_fixtures.py b/climada/test/common_test_fixtures.py index 5847b42e3e..64ed519fe4 100644 --- a/climada/test/common_test_fixtures.py +++ b/climada/test/common_test_fixtures.py @@ -22,18 +22,13 @@ """ -import copy -from unittest import TestCase - import geopandas as gpd import numpy as np -import pandas as pd from scipy.sparse import csr_matrix from shapely.geometry import Point -from climada.entity import Exposures, ImpactFunc, ImpactFuncSet, ImpfTropCyclone +from climada.entity import Exposures, ImpactFunc, ImpactFuncSet from climada.hazard import Centroids, Hazard -from climada.trajectories import InterpolatedRiskTrajectory, StaticRiskTrajectory from climada.trajectories.snapshot import Snapshot # --------------------------------------------------------------------------- From cf7a80a96aab365d1848ad7d474e7229c6f07f6a Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 18 Dec 2025 15:12:25 +0100 Subject: [PATCH 19/61] cherry pick --- .../trajectories/interpolated_trajectory.py | 874 +++++++ .../test/test_interpolated_risk_trajectory.py | 1416 +++++++++++ doc/user-guide/climada_trajectories.ipynb | 2209 +++++++++++++++++ 3 files changed, 4499 insertions(+) create mode 100644 climada/trajectories/interpolated_trajectory.py create mode 100644 climada/trajectories/test/test_interpolated_risk_trajectory.py create mode 100644 doc/user-guide/climada_trajectories.ipynb diff --git a/climada/trajectories/interpolated_trajectory.py b/climada/trajectories/interpolated_trajectory.py new file mode 100644 index 0000000000..c2f87b37e7 --- /dev/null +++ b/climada/trajectories/interpolated_trajectory.py @@ -0,0 +1,874 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +This file implements interpolated risk trajectory objects, to allow a better evaluation +of risk in between points in time (snapshots). + +""" + +import datetime +import itertools +import logging +from typing import cast + +import matplotlib.dates as mdates +import matplotlib.pyplot as plt +import matplotlib.ticker as mticker +import pandas as pd + +from climada.entity.disc_rates.base import DiscRates +from climada.trajectories.constants import ( + AAI_METRIC_NAME, + AAI_PER_GROUP_METRIC_NAME, + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTIONS_METRIC_NAME, + COORD_ID_COL_NAME, + DATE_COL_NAME, + DEFAULT_TIME_RESOLUTION, + EAI_METRIC_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + PERIOD_COL_NAME, + RETURN_PERIOD_METRIC_NAME, + RISK_COL_NAME, + UNIT_COL_NAME, +) +from climada.trajectories.impact_calc_strat import ( + ImpactCalcComputation, + ImpactComputationStrategy, +) +from climada.trajectories.interpolation import ( + AllLinearStrategy, + InterpolationStrategyBase, +) +from climada.trajectories.riskperiod import CalcRiskMetricsPeriod +from climada.trajectories.snapshot import Snapshot +from climada.trajectories.trajectory import ( + DEFAULT_ALLGROUP_NAME, + DEFAULT_RP, + RiskTrajectory, +) +from climada.util import log_level +from climada.util.dataframe_handling import reorder_dataframe_columns + +LOGGER = logging.getLogger(__name__) + +__all__ = ["InterpolatedRiskTrajectory"] + +from climada.trajectories.trajectory import DEFAULT_DF_COLUMN_PRIORITY, INDEXING_COLUMNS + + +class InterpolatedRiskTrajectory(RiskTrajectory): + """This class implements interpolated risk trajectories, objects that + regroup impacts computations for multiple dates, and interpolate risk + metrics in between. + + This class computes risk metrics over a series of snapshots, + optionally applying risk discounting. It interpolate risk + between each pair of snapshots and provides dataframes of risk metric on a + given time resolution. + + """ + + _grouper = [MEASURE_COL_NAME, METRIC_COL_NAME] + """Results dataframe grouper""" + + POSSIBLE_METRICS = [ + EAI_METRIC_NAME, + AAI_METRIC_NAME, + RETURN_PERIOD_METRIC_NAME, + CONTRIBUTIONS_METRIC_NAME, + AAI_PER_GROUP_METRIC_NAME, + ] + """Class variable listing the risk metrics that can be computed. + + Currently: + + - eai, expected impact (per exposure point within a period of 1/frequency unit of the hazard object) + - aai, average annual impact (aggregated eai over the whole exposure) + - aai_per_group, average annual impact per exposure subgroup (defined from the exposure geodataframe) + - return_periods, estimated impacts aggregated over the whole exposure for different return periods + - risk_contributions, estimated contribution part of, respectively exposure, hazard, vulnerability and their interaction to the change in risk over the considered period + """ + + _DEFAULT_ALL_METRICS = [ + AAI_METRIC_NAME, + RETURN_PERIOD_METRIC_NAME, + AAI_PER_GROUP_METRIC_NAME, + ] + + def __init__( + self, + snapshots_list: list[Snapshot], + *, + return_periods: list[int] = DEFAULT_RP, + time_resolution: str = DEFAULT_TIME_RESOLUTION, + all_groups_name: str = DEFAULT_ALLGROUP_NAME, + risk_disc_rates: DiscRates | None = None, + interpolation_strategy: InterpolationStrategyBase | None = None, + impact_computation_strategy: ImpactComputationStrategy | None = None, + ): + """Initialize a new `StaticRiskTrajectory`. + + Parameters + ---------- + snapshot_list : list[Snapshot] + The list of `Snapshot` object to compute risk from. + return_periods: list[int], optional + The return periods to use when computing the `return_periods_metric`. + Defaults to `DEFAULT_RP` ([20, 50, 100]). + time_resolution: str, optional + The time resolution to use for interpolation. + It must be a valid pandas string used to define periods, + e.g., "Y" for years, "M" for months, "3M" for trimester, etc. + Defaults to `DEFAULT_TIME_RESOLUTION` ("Y"). + all_groups_name: str, optional + The string to use to define all exposure points subgroup. + Defaults to `DEFAULT_ALLGROUP_NAME` ("All"). + risk_disc_rates: DiscRates, optional + The discount rate to apply to future risk. Defaults to None. + interpolation_strategy: InterpolationStrategyBase, optional + The interpolation strategy to use when interpolating. + Defaults to :class:`AllLinearStrategy` + impact_computation_strategy: ImpactComputationStrategy, optional + The method used to calculate the impact from the (Haz,Exp,Vul) + of the two snapshots. Defaults to :class:`ImpactCalcComputation`. + + """ + super().__init__( + snapshots_list, + return_periods=return_periods, + all_groups_name=all_groups_name, + risk_disc_rates=risk_disc_rates, + ) + self._risk_metrics_up_to_date: bool = False + self.start_date = min([snapshot.date for snapshot in snapshots_list]) + self.end_date = max([snapshot.date for snapshot in snapshots_list]) + self._risk_metrics_calculators = self._reset_risk_metrics_calculators( + self._snapshots, + time_resolution, + interpolation_strategy or AllLinearStrategy(), + impact_computation_strategy or ImpactCalcComputation(), + ) + + @property + def interpolation_strategy(self) -> InterpolationStrategyBase: + """The approach used to interpolate impact matrices in between the two snapshots.""" + return self._risk_metrics_calculators[0].interpolation_strategy + + @interpolation_strategy.setter + def interpolation_strategy(self, value, /): + if not isinstance(value, InterpolationStrategyBase): + raise ValueError("Not an interpolation strategy") + + self._reset_metrics() + for rmcalc in self._risk_metrics_calculators: + rmcalc.interpolation_strategy = value + + @property + def impact_computation_strategy(self) -> ImpactComputationStrategy: + """The method used to calculate the impact from the (Haz,Exp,Vul) triplets.""" + return self._risk_metrics_calculators[0].impact_computation_strategy + + @impact_computation_strategy.setter + def impact_computation_strategy(self, value, /): + if not isinstance(value, ImpactComputationStrategy): + raise ValueError("Not an interpolation strategy") + + self._reset_metrics() + for rmcalc in self._risk_metrics_calculators: + rmcalc.impact_computation_strategy = value + + @property + def time_resolution(self) -> str: + """The time resolution to use when interpolating. + + It must be a valid pandas string used to define periods, + e.g., "Y" for years, "M" for months, "3M" for trimester, etc. + + See `here `_ + + Notes + ----- + + Changing its value resets the corresponding metric. + """ + return self._risk_metrics_calculators[0].time_resolution + + @time_resolution.setter + def time_resolution(self, value, /): + if not isinstance(value, str): + raise ValueError( + 'time_resolution should be a valid pandas Period frequency string (e.g., `"Y"`, `"M"`, `"D"`).' + ) + self._reset_metrics() + for rmcalc in self._risk_metrics_calculators: + rmcalc.time_resolution = value + + @staticmethod + def _reset_risk_metrics_calculators( + snapshots: list[Snapshot], + time_resolution, + interpolation_strategy, + impact_computation_strategy, + ) -> list[CalcRiskMetricsPeriod]: + """Initialize or reset the internal risk metrics calculators. + + Notes + ----- + + This methods sorts the snapshots per date. + """ + + def pairwise(container: list): + """ + Generate pairs of successive elements from an iterable. + + Parameters + ---------- + iterable : iterable + An iterable sequence from which successive pairs of elements are generated. + + Returns + ------- + zip + A zip object containing tuples of successive pairs from the input iterable. + + Example + ------- + >>> list(pairwise([1, 2, 3, 4])) + [(1, 2), (2, 3), (3, 4)] + """ + a, b = itertools.tee(container) + next(b, None) + return zip(a, b) + + return [ + CalcRiskMetricsPeriod( + start_snapshot, + end_snapshot, + time_resolution=time_resolution, + interpolation_strategy=interpolation_strategy, + impact_computation_strategy=impact_computation_strategy, + ) + for start_snapshot, end_snapshot in pairwise( + sorted(snapshots, key=lambda snap: snap.date) + ) + ] + + def _generic_metrics( + self, + metric_name: str | None = None, + metric_meth: str | None = None, + **kwargs, + ) -> pd.DataFrame: + """Generic method to compute metrics based on the provided metric name and method. + + This method calls the appropriate method from the calculator to return + the results for the given metric, in a tidy formatted dataframe. + + It first checks whether the requested metric is a valid one. + Then looks for a possible cached value and otherwised asks the + calculators (`self._risk_metric_calculators`) to run the computations. + The results are then regrouped in a nice and tidy DataFrame. + If a `risk_disc_rates` was set, values are converted to net present values. + Results are then cached within `self.__metrics` and returned. + + Parameters + ---------- + metric_name : str, optional + The name of the metric to return results for. + metric_meth : str, optional + The name of the specific method of the calculator to call. + + Returns + ------- + pd.DataFrame + A tidy formatted dataframe of the risk metric computed for the + different snapshots. + + Raises + ------ + NotImplementedError + If the requested metric is not part of `POSSIBLE_METRICS`. + ValueError + If either of the arguments are not provided. + + """ + + if metric_name is None or metric_meth is None: + raise ValueError("Both metric_name and metric_meth must be provided.") + + if metric_name not in self.POSSIBLE_METRICS: + raise NotImplementedError( + f"{metric_name} not implemented ({self.POSSIBLE_METRICS})." + ) + + # Construct the attribute name for storing the metric results + attr_name = f"_{metric_name}_metrics" + + if getattr(self, attr_name) is not None: + LOGGER.debug(f"Returning cached {attr_name}") + return getattr(self, attr_name) + + LOGGER.debug(f"Computing {attr_name}") + with log_level(level="WARNING", name_prefix="climada"): + tmp = [ + getattr(calc_period, metric_meth)(**kwargs) + for calc_period in self._risk_metrics_calculators + ] + + # Notably for per_group_aai being None: + try: + tmp = pd.concat(tmp) + if len(tmp) == 0: + return pd.DataFrame() + except ValueError as e: + if str(e) == "All objects passed were None": + return pd.DataFrame() + else: + raise e + + else: + tmp = tmp.set_index(INDEXING_COLUMNS) + if COORD_ID_COL_NAME in tmp.columns: + tmp = tmp.set_index([COORD_ID_COL_NAME], append=True) + + # When more than 2 snapshots, there are duplicated rows, we need to remove them. + tmp = tmp[~tmp.index.duplicated(keep="first")] + tmp = tmp.reset_index() + if self._all_groups_name not in tmp[GROUP_COL_NAME].cat.categories: + tmp[GROUP_COL_NAME] = tmp[GROUP_COL_NAME].cat.add_categories( + [self._all_groups_name] + ) + tmp[GROUP_COL_NAME] = tmp[GROUP_COL_NAME].fillna(self._all_groups_name) + + if metric_name == CONTRIBUTIONS_METRIC_NAME and len(self._snapshots) > 2: + # If there is more than one Snapshot, we need to update the + # contributions from previous periods for continuity + # and to set the base risk from the first period + # This is not elegant, but we need the concatenated metrics from each period, + # so we can't do it in the calculators, and we need + # to do it before caching in the private attribute + tmp = self._risk_contributions_post_treatment(tmp) + + if self._risk_disc_rates: + LOGGER.debug("Found risk discount rate. Computing NPV.") + tmp = self.npv_transform(tmp, self._risk_disc_rates) + + tmp = reorder_dataframe_columns(tmp, DEFAULT_DF_COLUMN_PRIORITY) + LOGGER.debug("All computing done, caching value.") + setattr(self, attr_name, tmp) + return getattr(self, attr_name) + + def _compute_period_metrics( + self, metric_name: str, metric_meth: str, **kwargs + ) -> pd.DataFrame: + """Helper method to compute total metrics per period (i.e. whole ranges between pairs of consecutive snapshots).""" + df = self._generic_metrics( + metric_name=metric_name, metric_meth=metric_meth, **kwargs + ) + return self._date_to_period_agg(df, grouper=self._grouper) + + def eai_metrics(self, **kwargs) -> pd.DataFrame: + """Return the estimated annual impacts at each exposure point for each date. + + This method computes and return a `DataFrame` with eai metric + (for each exposure point) for each date. + + Notes + ----- + + This computation may become quite expensive for big areas with high resolution. + + """ + df = self._compute_metrics( + metric_name=EAI_METRIC_NAME, metric_meth="calc_eai_gdf", **kwargs + ) + return df + + def aai_metrics(self, **kwargs) -> pd.DataFrame: + """Return the average annual impacts for each date. + + This method computes and return a `DataFrame` with aai metric for each date. + + """ + + return self._compute_metrics( + metric_name=AAI_METRIC_NAME, metric_meth="calc_aai_metric", **kwargs + ) + + def return_periods_metrics(self, **kwargs) -> pd.DataFrame: + """Return the estimated impacts for different return periods. + + Return periods to estimate impacts for are defined by `self.return_periods`. + + """ + + return self._compute_metrics( + metric_name=RETURN_PERIOD_METRIC_NAME, + metric_meth="calc_return_periods_metric", + return_periods=self.return_periods, + **kwargs, + ) + + def aai_per_group_metrics(self, **kwargs) -> pd.DataFrame: + """Return the average annual impacts for each exposure group ID. + + This method computes and return a `DataFrame` with aai metric for each + of the exposure group defined by a group id, for each date. + + """ + + return self._compute_metrics( + metric_name=AAI_PER_GROUP_METRIC_NAME, + metric_meth="calc_aai_per_group_metric", + **kwargs, + ) + + def risk_contributions_metrics(self, **kwargs) -> pd.DataFrame: + """Return the "contributions" of change in future risk (Exposure and Hazard) + + This method returns the contributions of the change in risk at each date: + + - The 'base risk', i.e., the risk without change in hazard or exposure, compared to trajectory's earliest date. + - The 'exposure contribution', i.e., the additional risks due to change in exposure (only) + - The 'hazard contribution', i.e., the additional risks due to change in hazard (only) + - The 'vulnerability contribution', i.e., the additional risks due to change in vulnerability (only) + - The 'interaction contribution', i.e., the additional risks due to the interaction term + + + """ + + return self._compute_metrics( + metric_name=CONTRIBUTIONS_METRIC_NAME, + metric_meth="calc_risk_contributions_metric", + **kwargs, + ) + + def _risk_contributions_post_treatment(self, df) -> pd.DataFrame: + """Post treat the risk contributions metrics. + + When more than two snapshots are provided, the total risk of the previous pair + (period) becomes the base risk for the subsequent one. + This method straightens this by resetting the base risk to the risk from + the first snapshot of the list and correcting the different contributions + by cumulating the contributions from the previous periods. + + """ + + df.set_index(INDEXING_COLUMNS, inplace=True) + start_dates = [snap.date for snap in self._snapshots[:-1]] + end_dates = [snap.date for snap in self._snapshots[1:]] + periods_dates = list(zip(start_dates, end_dates)) + df.loc[pd.IndexSlice[:, :, :, CONTRIBUTION_BASE_RISK_NAME]] = df.loc[ + pd.IndexSlice[ + pd.to_datetime(self.start_date).to_period(self.time_resolution), + :, + :, + CONTRIBUTION_BASE_RISK_NAME, + ] # type: ignore + ].values + for p2 in periods_dates[1:]: + for metric in [ + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + ]: + mask_last_previous = ( + df.index.get_level_values(0) + == pd.to_datetime(p2[0]).to_period(self.time_resolution) + ) & (df.index.get_level_values(3) == metric) + mask_to_update = ( + ( + df.index.get_level_values(0) + > pd.to_datetime(p2[0]).to_period(self.time_resolution) + ) + & ( + df.index.get_level_values(0) + <= pd.to_datetime(p2[1]).to_period(self.time_resolution) + ) + & (df.index.get_level_values(3) == metric) + ) + + df.loc[mask_to_update, RISK_COL_NAME] += df.loc[ + mask_last_previous, RISK_COL_NAME + ].iloc[0] + + return df.reset_index() + + def per_date_risk_metrics( + self, + metrics: list[str] | None = None, + ) -> pd.DataFrame: + """Returns a DataFrame of risk metrics for each dates + + This methods collects (and if needed computes) the `metrics` + (Defaulting to AAI_METRIC_NAME, RETURN_PERIOD_METRIC_NAME and AAI_PER_GROUP_METRIC_NAME). + + Parameters + ---------- + metrics : list[str], optional + The list of metrics to return (defaults to + [AAI_METRIC_NAME,RETURN_PERIOD_METRIC_NAME,AAI_PER_GROUP_METRIC_NAME]) + return_periods : list[int], optional + The return periods to consider for the return periods metric + (default to the value of the `.default_rp` attribute) + + Returns + ------- + pd.DataFrame | pd.Series + A tidy DataFrame with metrics value for all possible dates. + + """ + + metrics = self._DEFAULT_ALL_METRICS if metrics is None else metrics + return pd.concat( + [getattr(self, f"{metric}_metrics")() for metric in metrics], + ignore_index=True, + ) + + @staticmethod + def _get_risk_periods( + risk_periods: list[CalcRiskMetricsPeriod], + start_date: datetime.date, + end_date: datetime.date, + strict: bool = True, + ): + """Returns risk periods from the given list that are within `start_date` and `end_date`. + + Either using a strict inclusion (period is stricly within start and end) or extending + to overlap inclusion, i.e., start or end is within the period. + + Parameters + ---------- + risk_periods : list[CalcRiskPeriod] + The list of risk periods to look through + start_date : datetime.date + end_date : datetime.date + strict: bool, default True + If true, only returns periods stricly within start and end dates. Else, + additionaly returns periods that have an overlap within start and end. + """ + if strict: + return [ + period + for period in risk_periods + if ( + start_date <= period.snapshot_start.date + and end_date >= period.snapshot_end.date + ) + ] + else: + return [ + period + for period in risk_periods + if not ( + start_date >= period.snapshot_end.date + or end_date <= period.snapshot_start.date + ) + ] + + @staticmethod + def _identify_continuous_periods(group, time_unit): + """Calculate the difference between consecutive dates.""" + + if time_unit == "year": + group["date_diff"] = group[DATE_COL_NAME].dt.year.diff() + if time_unit == "month": + group["date_diff"] = group[DATE_COL_NAME].dt.month.diff() + if time_unit == "day": + group["date_diff"] = group[DATE_COL_NAME].dt.day.diff() + if time_unit == "hour": + group["date_diff"] = group[DATE_COL_NAME].dt.hour.diff() + # Identify breaks in continuity + group["period_id"] = (group["date_diff"] != 1).cumsum() + return group + + @classmethod + def _date_to_period_agg( + cls, + df: pd.DataFrame, + grouper: list[str], + time_unit: str = "year", + colname: str | list[str] = RISK_COL_NAME, + ) -> pd.DataFrame: + """Group per date risk metric to periods.""" + + def conditional_agg(group): + try: + if "rp" in group.name[2]: + return group.mean() + else: + return group.sum() + except IndexError: + return group.sum() + + df_sorted = df.sort_values(by=grouper + [DATE_COL_NAME]) + + if GROUP_COL_NAME in df.columns and GROUP_COL_NAME not in grouper: + grouper = [GROUP_COL_NAME] + grouper + + # Apply the function to identify continuous periods + df_periods = df_sorted.groupby( + grouper, dropna=False, group_keys=False, observed=True + )[df_sorted.columns].apply(cls._identify_continuous_periods, time_unit) + + if isinstance(colname, str): + colname = [colname] + agg_dict = { + "start_date": pd.NamedAgg(column=DATE_COL_NAME, aggfunc="min"), + "end_date": pd.NamedAgg(column=DATE_COL_NAME, aggfunc="max"), + } + df_periods_dates = ( + df_periods.groupby(grouper + ["period_id"], dropna=False, observed=True) + .agg(func=None, **agg_dict) # type: ignore + .reset_index() + ) + + df_periods_dates[PERIOD_COL_NAME] = ( + df_periods_dates["start_date"].astype(str) + + " to " + + df_periods_dates["end_date"].astype(str) + ) + df_periods = ( + df_periods.groupby(grouper + ["period_id"], dropna=False, observed=True)[ + colname + ] + .apply("mean") + .reset_index() + ) + df_periods = pd.merge( + df_periods_dates[grouper + [PERIOD_COL_NAME, "period_id"]], + df_periods, + on=grouper + ["period_id"], + ) + df_periods = df_periods.drop(["period_id"], axis=1) + return df_periods[ + [PERIOD_COL_NAME] + + [col for col in df_periods.columns if col != PERIOD_COL_NAME] + ] + + def per_period_risk_metrics( + self, + metrics: list[str] = [ + AAI_METRIC_NAME, + RETURN_PERIOD_METRIC_NAME, + AAI_PER_GROUP_METRIC_NAME, + ], + **kwargs, + ) -> pd.DataFrame: + """Return a tidy dataframe of the risk metrics with the total for each different period (pair of snapshots).""" + + df = self.per_date_risk_metrics(metrics=metrics, **kwargs) + return self._date_to_period_agg( + df, grouper=self._grouper + [UNIT_COL_NAME], **kwargs + ) + + def _calc_waterfall_plot_data( + self, + start_date: datetime.date | None = None, + end_date: datetime.date | None = None, + ): + """Compute the required data for the waterfall plot between `start_date` and `end_date`.""" + start_date = self.start_date if start_date is None else start_date + end_date = self.end_date if end_date is None else end_date + risk_contributions = self.risk_contributions_metrics() + risk_contributions = risk_contributions.loc[ + (risk_contributions[DATE_COL_NAME] >= str(start_date)) + & (risk_contributions[DATE_COL_NAME] <= str(end_date)) + ] + risk_contributions = risk_contributions.set_index( + [DATE_COL_NAME, METRIC_COL_NAME] + )[RISK_COL_NAME].unstack() + return risk_contributions + + def plot_time_waterfall( + self, + ax=None, + figsize=(12, 6), + ): + """Plot a waterfall chart of risk contributions over a specified date range. + + This method generates a stacked bar chart to visualize the + risk contributions. + + Parameters + ---------- + ax : matplotlib.axes.Axes, optional + The matplotlib axes on which to plot. If None, a new figure and axes are created. + + Returns + ------- + matplotlib.axes.Axes + The matplotlib axes with the plotted waterfall chart. + + """ + if ax is None: + fig, ax = plt.subplots(figsize=figsize) + else: + fig = ax.figure # get parent figure from the axis + + risk_contribution = self._calc_waterfall_plot_data( + start_date=self.start_date, end_date=self.end_date + ) + risk_contribution = risk_contribution[ + [ + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + ] + ] + risk_contribution[CONTRIBUTION_BASE_RISK_NAME] = risk_contribution.iloc[0][ + CONTRIBUTION_BASE_RISK_NAME + ] + # risk_contribution.plot(x=DATE_COL_NAME, ax=ax, kind="bar", stacked=True) + ax.stackplot( + risk_contribution.index.to_timestamp(), # type: ignore + [risk_contribution[col] for col in risk_contribution.columns], + labels=risk_contribution.columns, + ) + ax.legend() + # bottom = [0] * len(risk_contribution) + # for col in risk_contribution.columns: + # bottom = [b + v for b, v in zip(bottom, risk_contribution[col])] + # Construct y-axis label and title based on parameters + value_label = "USD" + title_label = ( + f"Risk between {self.start_date} and {self.end_date} (Average impact)" + ) + + locator = mdates.AutoDateLocator() + formatter = mdates.ConciseDateFormatter(locator) + + ax.xaxis.set_major_locator(locator) + ax.xaxis.set_major_formatter(formatter) + ax.yaxis.set_major_formatter(mticker.EngFormatter()) + ax.set_title(title_label) + ax.set_ylabel(value_label) + ax.set_ylim(0.0, 1.1 * ax.get_ylim()[1]) + return fig, ax + + def plot_waterfall( + self, + ax=None, + ): + """Plot a waterfall chart of risk contributions between two dates. + + This method generates a waterfall plot to visualize the changes in risk contributions. + + Parameters + ---------- + ax : matplotlib.axes.Axes, optional + The matplotlib axes on which to plot. If None, a new figure and axes are created. + + Returns + ------- + matplotlib.axes.Axes + The matplotlib axes with the plotted waterfall chart. + + """ + start_date_p = pd.to_datetime(self.start_date).to_period(self.time_resolution) + end_date_p = pd.to_datetime(self.end_date).to_period(self.time_resolution) + risk_contribution = self._calc_waterfall_plot_data( + start_date=self.start_date, end_date=self.end_date + ) + if ax is None: + _, ax = plt.subplots(figsize=(8, 5)) + + risk_contribution = risk_contribution.loc[ + (risk_contribution.index == str(self.end_date)) + ].squeeze() + risk_contribution = cast(pd.Series, risk_contribution) + + labels = [ + f"Risk {start_date_p}", + f"Exposure contribution {end_date_p}", + f"Hazard contribution {end_date_p}", + f"Vulnerability contribution {end_date_p}", + f"Interaction contribution {end_date_p}", + f"Total Risk {end_date_p}", + ] + values = [ + risk_contribution[CONTRIBUTION_BASE_RISK_NAME], + risk_contribution[CONTRIBUTION_EXPOSURE_NAME], + risk_contribution[CONTRIBUTION_HAZARD_NAME], + risk_contribution[CONTRIBUTION_VULNERABILITY_NAME], + risk_contribution[CONTRIBUTION_INTERACTION_TERM_NAME], + risk_contribution.sum(), + ] + bottoms = [ + 0.0, + risk_contribution[CONTRIBUTION_BASE_RISK_NAME], + risk_contribution[CONTRIBUTION_BASE_RISK_NAME] + + risk_contribution[CONTRIBUTION_EXPOSURE_NAME], + risk_contribution[CONTRIBUTION_BASE_RISK_NAME] + + risk_contribution[CONTRIBUTION_EXPOSURE_NAME] + + risk_contribution[CONTRIBUTION_HAZARD_NAME], + risk_contribution[CONTRIBUTION_BASE_RISK_NAME] + + risk_contribution[CONTRIBUTION_EXPOSURE_NAME] + + risk_contribution[CONTRIBUTION_HAZARD_NAME] + + risk_contribution[CONTRIBUTION_VULNERABILITY_NAME], + 0.0, + ] + + ax.bar( + labels, + values, + bottom=bottoms, + edgecolor="black", + color=[ + "tab:cyan", + "tab:orange", + "tab:green", + "tab:red", + "tab:purple", + "tab:blue", + ], + ) + for i in range(len(values)): + ax.text( + labels[i], # type: ignore + values[i] + bottoms[i], + f"{values[i]:.0e}", + ha="center", + va="bottom", + color="black", + ) + + # Construct y-axis label and title based on parameters + value_label = "USD" + title_label = f"Evolution of the contributions of risk between {start_date_p} and {end_date_p} (Average impact)" + ax.yaxis.set_major_formatter(mticker.EngFormatter()) + ax.set_title(title_label) + ax.set_ylabel(value_label) + ax.set_ylim(0.0, 1.1 * ax.get_ylim()[1]) + ax.tick_params( + axis="x", + labelrotation=90, + ) + + return ax diff --git a/climada/trajectories/test/test_interpolated_risk_trajectory.py b/climada/trajectories/test/test_interpolated_risk_trajectory.py new file mode 100644 index 0000000000..87d5f66952 --- /dev/null +++ b/climada/trajectories/test/test_interpolated_risk_trajectory.py @@ -0,0 +1,1416 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +unit tests for interpolated_risk_trajectory + +""" + +import datetime +import unittest +from itertools import product +from unittest.mock import MagicMock, Mock, call, patch + +import numpy as np # For potential NaN/NA comparisons +import pandas as pd + +from climada.entity.disc_rates.base import DiscRates +from climada.trajectories.constants import ( + AAI_METRIC_NAME, + AAI_PER_GROUP_METRIC_NAME, + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + CONTRIBUTION_TOTAL_RISK_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTIONS_METRIC_NAME, + COORD_ID_COL_NAME, + DATE_COL_NAME, + EAI_METRIC_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + PERIOD_COL_NAME, + RETURN_PERIOD_METRIC_NAME, + RISK_COL_NAME, + UNIT_COL_NAME, +) +from climada.trajectories.impact_calc_strat import ImpactCalcComputation +from climada.trajectories.interpolated_trajectory import ( + INDEXING_COLUMNS, + InterpolatedRiskTrajectory, +) +from climada.trajectories.interpolation import ( + AllLinearStrategy, + ExponentialExposureStrategy, +) +from climada.trajectories.riskperiod import ( # ImpactComputationStrategy, # If needed to mock its base class directly + CalcRiskMetricsPeriod, +) +from climada.trajectories.snapshot import Snapshot + + +class TestInterpolatedRiskTrajectory(unittest.TestCase): + def setUp(self): + # Common setup for all tests + self.dates1 = [ + pd.Period("2023-01-01", freq="Y"), + pd.Period("2024-01-01", freq="Y"), + ] + self.dates2 = [ + pd.Period("2025-01-01", freq="Y"), + pd.Period("2026-01-01", freq="Y"), + ] + self.groups = ["GroupA", "GroupB", pd.NA] + self.measures = ["MEAS1", "MEAS2"] + self.metrics = [AAI_METRIC_NAME] + self.aai_dates1 = pd.DataFrame( + product(self.dates1, self.groups, self.measures, self.metrics), + columns=INDEXING_COLUMNS, + ) + self.aai_dates1[RISK_COL_NAME] = np.arange(12) * 100 + self.aai_dates1[GROUP_COL_NAME] = self.aai_dates1[GROUP_COL_NAME].astype( + "category" + ) + + self.aai_dates2 = pd.DataFrame( + product(self.dates2, self.groups, self.measures, self.metrics), + columns=INDEXING_COLUMNS, + ) + self.aai_dates2[RISK_COL_NAME] = np.arange(12) * 100 + 1200 + self.aai_dates2[GROUP_COL_NAME] = self.aai_dates2[GROUP_COL_NAME].astype( + "category" + ) + + self.aai_alldates = pd.DataFrame( + product( + self.dates1 + self.dates2, self.groups, self.measures, self.metrics + ), + columns=INDEXING_COLUMNS, + ) + self.aai_alldates[RISK_COL_NAME] = np.arange(24) * 100 + self.aai_alldates[GROUP_COL_NAME] = self.aai_alldates[GROUP_COL_NAME].astype( + "category" + ) + self.aai_alldates[GROUP_COL_NAME] = self.aai_alldates[ + GROUP_COL_NAME + ].cat.add_categories(["All"]) + self.aai_alldates[GROUP_COL_NAME] = self.aai_alldates[GROUP_COL_NAME].fillna( + "All" + ) + self.expected_pre_npv_aai = self.aai_alldates + self.expected_pre_npv_aai = self.expected_pre_npv_aai[ + [ + DATE_COL_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + RISK_COL_NAME, + ] + ] + + self.expected_npv_aai = pd.DataFrame( + product( + self.dates1 + self.dates2, self.groups, self.measures, self.metrics + ), + columns=INDEXING_COLUMNS, + ) + self.expected_npv_aai[RISK_COL_NAME] = np.arange(24) * 90 + self.expected_npv_aai[GROUP_COL_NAME] = self.expected_npv_aai[ + GROUP_COL_NAME + ].astype("category") + self.expected_npv_aai[GROUP_COL_NAME] = self.expected_npv_aai[ + GROUP_COL_NAME + ].cat.add_categories(["All"]) + self.expected_npv_aai[GROUP_COL_NAME] = self.expected_npv_aai[ + GROUP_COL_NAME + ].fillna("All") + expected_npv_df = self.expected_npv_aai + expected_npv_df = expected_npv_df[ + [ + GROUP_COL_NAME, + DATE_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + RISK_COL_NAME, + ] + ] + self.mock_snapshot1 = MagicMock(spec=Snapshot) + self.mock_snapshot1.date = datetime.date(2023, 1, 1) + + self.mock_snapshot2 = MagicMock(spec=Snapshot) + self.mock_snapshot2.date = datetime.date(2024, 1, 1) + + self.mock_snapshot3 = MagicMock(spec=Snapshot) + self.mock_snapshot3.date = datetime.date(2025, 1, 1) + + self.snapshots_list: list[Snapshot] = [ + self.mock_snapshot1, + self.mock_snapshot2, + self.mock_snapshot3, + ] + # self.snapshots_list = cast(list[Snapshot], self.snapshots_list) + + # Mock interpolation strategy and impact computation strategy + self.mock_interpolation_strategy = MagicMock(spec=AllLinearStrategy) + self.mock_impact_computation_strategy = MagicMock(spec=ImpactCalcComputation) + + # Mock DiscRates if needed for NPV tests + self.mock_disc_rates = MagicMock(spec=DiscRates) + self.mock_disc_rates.years = [2023, 2024, 2025] + self.mock_disc_rates.rates = [0.01, 0.02, 0.03] # Example rates + + self.mock_risk_period_calc1 = MagicMock(spec=CalcRiskMetricsPeriod) + self.mock_risk_period_calc2 = MagicMock(spec=CalcRiskMetricsPeriod) + # Mock npv_transform return value + self.mock_risk_period_calc1.calc_aai_metric.return_value = self.aai_dates1 + self.mock_risk_period_calc2.calc_aai_metric.return_value = self.aai_dates2 + self.mock_risk_metric_calculators = [ + self.mock_risk_period_calc1, + self.mock_risk_period_calc2, + ] + + self.mock_interpolated_risk_traj = MagicMock(spec=InterpolatedRiskTrajectory) + self.mock_interpolated_risk_traj._risk_metrics_calcultators = ( + self.mock_risk_metric_calculators + ) + self.mock_interpolated_risk_traj._risk_disc_rates = ( + self.mock_disc_rates + ) # For NPV transform check + + # --- Test Initialization and Properties --- + # These tests focus on the __init__ method and property getters/setters. + + ## Test `__init__` method + @patch.object( + InterpolatedRiskTrajectory, "_reset_risk_metrics_calculators", return_value=1 + ) + def test_init_basic(self, mock_reset_metrics_calculators): + # Test basic initialization with defaults + rt = InterpolatedRiskTrajectory( + self.snapshots_list, + interpolation_strategy=self.mock_interpolation_strategy, + impact_computation_strategy=self.mock_impact_computation_strategy, + ) + self.assertEqual(rt.start_date, self.mock_snapshot1.date) + self.assertEqual(rt.end_date, self.mock_snapshot3.date) + self.assertIsNone(rt._risk_disc_rates) + mock_reset_metrics_calculators.assert_called_once_with( + self.snapshots_list, + "Y", + self.mock_interpolation_strategy, + self.mock_impact_computation_strategy, + ) + self.assertEqual(rt._risk_metrics_calculators, 1) + # Check that metrics are reset (initially None) + for metric in InterpolatedRiskTrajectory.POSSIBLE_METRICS: + self.assertIsNone(getattr(rt, "_" + metric + "_metrics")) + + @patch.object( + InterpolatedRiskTrajectory, "_reset_risk_metrics_calculators", return_value=1 + ) + def test_init_with_custom_params(self, _): + # Test initialization with custom parameters + mock_disc = Mock(spec=DiscRates) + rt = InterpolatedRiskTrajectory( + self.snapshots_list, + time_resolution="MS", + all_groups_name="CustomAll", + risk_disc_rates=mock_disc, + interpolation_strategy=Mock(), + impact_computation_strategy=Mock(), + ) + self.assertEqual(rt._all_groups_name, "CustomAll") + self.assertEqual(rt._risk_disc_rates, mock_disc) + + @patch.object(InterpolatedRiskTrajectory, "_reset_risk_metrics_calculators") + @patch.object(InterpolatedRiskTrajectory, "_reset_metrics", new_callable=Mock) + @patch( + "climada.trajectories.interpolated_trajectory.CalcRiskMetricsPeriod", + autospec=True, + ) + def test_set_impact_computation_strategy( + self, + mock_calc_risk_metrics, + mock_reset_metrics, + mock_reset_risk_metrics_calculators, + ): + mock_reset_risk_metrics_calculators.return_value = ( + self.mock_risk_metric_calculators + ) + rt = InterpolatedRiskTrajectory( + self.snapshots_list, + interpolation_strategy=self.mock_interpolation_strategy, + impact_computation_strategy=self.mock_impact_computation_strategy, + ) + mock_reset_metrics.assert_called_once() # Called during init + with self.assertRaises(ValueError): + rt.impact_computation_strategy = "A" + + # There is only one possibility at the moment so we just check against a new object + new_impact_calc = ImpactCalcComputation() + rt.impact_computation_strategy = new_impact_calc + self.assertEqual(rt.impact_computation_strategy, new_impact_calc) + mock_reset_metrics.assert_has_calls([call(), call()]) + for rp in self.mock_risk_metric_calculators: + self.assertEqual(rp.impact_computation_strategy, new_impact_calc) + + @patch.object(InterpolatedRiskTrajectory, "_reset_risk_metrics_calculators") + @patch.object(InterpolatedRiskTrajectory, "_reset_metrics", new_callable=Mock) + @patch( + "climada.trajectories.interpolated_trajectory.CalcRiskMetricsPeriod", + autospec=True, + ) + def test_set_interpolation_strategy( + self, + mock_calc_risk_metrics, + mock_reset_metrics, + mock_reset_risk_metrics_calculators, + ): + mock_reset_risk_metrics_calculators.return_value = ( + self.mock_risk_metric_calculators + ) + rt = InterpolatedRiskTrajectory( + self.snapshots_list, + interpolation_strategy=self.mock_interpolation_strategy, + impact_computation_strategy=self.mock_impact_computation_strategy, + ) + mock_reset_metrics.assert_called_once() # Called during init + with self.assertRaises(ValueError): + rt.interpolation_strategy = "A" + + # There is only one possibility at the moment so we just check against a new object + new_interp = ExponentialExposureStrategy() + rt.interpolation_strategy = new_interp + self.assertEqual(rt.interpolation_strategy, new_interp) + mock_reset_metrics.assert_has_calls([call(), call()]) + for rp in self.mock_risk_metric_calculators: + self.assertEqual(rp.interpolation_strategy, new_interp) + + @patch( + "climada.trajectories.interpolated_trajectory.CalcRiskMetricsPeriod", + autospec=True, + ) + def test_risk_periods_lazy_computation(self, MockCalcRiskPeriod): + # Test that _calc_risk_periods is called only once, lazily + rt = InterpolatedRiskTrajectory( + self.snapshots_list, + interpolation_strategy=self.mock_interpolation_strategy, + impact_computation_strategy=self.mock_impact_computation_strategy, + ) + + # First access should trigger calculation + risk_periods = rt._risk_metrics_calculators + MockCalcRiskPeriod.assert_has_calls( + [ + call( + self.mock_snapshot1, + self.mock_snapshot2, + time_resolution="Y", + interpolation_strategy=self.mock_interpolation_strategy, + impact_computation_strategy=self.mock_impact_computation_strategy, + ), + call( + self.mock_snapshot2, + self.mock_snapshot3, + time_resolution="Y", + interpolation_strategy=self.mock_interpolation_strategy, + impact_computation_strategy=self.mock_impact_computation_strategy, + ), + ] + ) + self.assertEqual(MockCalcRiskPeriod.call_count, 2) + self.assertIsInstance(risk_periods, list) + self.assertEqual(len(risk_periods), 2) # N-1 periods for N snapshots + + @patch( + "climada.trajectories.interpolated_trajectory.CalcRiskMetricsPeriod", + autospec=True, + ) + def test_calc_risk_periods_sorting(self, MockCalcRiskPeriod): + # Test that snapshots are sorted by date before pairing + unsorted_snapshots: list[Snapshot] = [ + self.mock_snapshot3, + self.mock_snapshot1, + self.mock_snapshot2, + ] + _ = InterpolatedRiskTrajectory(unsorted_snapshots) + # Access the property to trigger calculation + MockCalcRiskPeriod.assert_has_calls( + [ + call( + self.mock_snapshot1, + self.mock_snapshot2, + **MockCalcRiskPeriod.call_args[1], + ), + call( + self.mock_snapshot2, + self.mock_snapshot3, + **MockCalcRiskPeriod.call_args[1], + ), + ] + ) + self.assertEqual(MockCalcRiskPeriod.call_count, 2) + + @patch.object(InterpolatedRiskTrajectory, "_reset_metrics", new_callable=Mock) + @patch( + "climada.trajectories.interpolated_trajectory.CalcRiskMetricsPeriod", + autospec=True, + ) + def test_set_time_resolution( + self, mock_calc_risk_metrics_points, mock_reset_metrics + ): + rt = InterpolatedRiskTrajectory( + self.snapshots_list, + impact_computation_strategy=self.mock_impact_computation_strategy, + ) + mock_reset_metrics.assert_called_once() # Called during init + with self.assertRaises(ValueError): + rt.time_resolution = 75 + + # There is only one possibility at the moment so we just check against a new object + rt.time_resolution = "5M" + self.assertEqual(rt.time_resolution, "5M") + mock_reset_metrics.assert_has_calls([call(), call()]) + + # --- Test Generic Metric Computation (`_generic_metrics`) --- + # This is a core internal method and deserves thorough testing. + + @patch.object( + InterpolatedRiskTrajectory, "_reset_risk_metrics_calculators", new_callable=Mock + ) + @patch.object(InterpolatedRiskTrajectory, "npv_transform", new_callable=Mock) + def test_generic_metrics_basic_flow( + self, mock_npv_transform, mock_risk_metrics_calculators + ): + mock_risk_metrics_calculators.return_value = self.mock_risk_metric_calculators + mock_npv_transform.return_value = self.expected_npv_aai + rt = InterpolatedRiskTrajectory(self.snapshots_list) + rt._risk_disc_rates = self.mock_disc_rates + result = rt._generic_metrics( + metric_name=AAI_METRIC_NAME, metric_meth="calc_aai_metric" + ) + # Assertions + self.mock_risk_period_calc1.calc_aai_metric.assert_called_once() + self.mock_risk_period_calc2.calc_aai_metric.assert_called_once() + + # Check concatenated DataFrame before NPV + # We need to manually recreate the expected intermediate DataFrame before NPV for assertion + # npv_transform should be called with the correctly formatted (concatenated and ordered) DataFrame + # and the risk_disc_rates attribute + mock_npv_transform.assert_called_once() + pd.testing.assert_frame_equal( + mock_npv_transform.call_args[0][0].reset_index(drop=True), + self.expected_pre_npv_aai.reset_index(drop=True), + ) + self.assertEqual(mock_npv_transform.call_args[0][1], self.mock_disc_rates) + + pd.testing.assert_frame_equal( + result, self.expected_npv_aai + ) # Final result is from NPV transform + + # Check internal storage + stored_df = getattr(rt, "_aai_metrics") + # Assert that the stored DF is the one *before* NPV transformation + pd.testing.assert_frame_equal( + stored_df.reset_index(drop=True), + self.expected_npv_aai.reset_index(drop=True), + ) + + result2 = rt._generic_metrics( + metric_name=AAI_METRIC_NAME, metric_meth="calc_aai_metric" + ) + # Check no new calls + self.mock_risk_period_calc1.calc_aai_metric.assert_called_once() + self.mock_risk_period_calc2.calc_aai_metric.assert_called_once() + pd.testing.assert_frame_equal( + result2, + self.expected_npv_aai.reset_index(drop=True), + ) + + @patch.object( + InterpolatedRiskTrajectory, "_reset_risk_metrics_calculators", new_callable=Mock + ) + def test_generic_metrics_not_implemented_error( + self, mock_reset_risk_metrics_calculators + ): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + with self.assertRaises(NotImplementedError): + rt._generic_metrics(metric_name="non_existent", metric_meth="some_method") + + @patch.object( + InterpolatedRiskTrajectory, "_reset_risk_metrics_calculators", new_callable=Mock + ) + def test_generic_metrics_value_error_no_name_or_method( + self, mock_reset_risk_metrics_calculators + ): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + with self.assertRaises(ValueError): + rt._generic_metrics(metric_name=None, metric_meth="some_method") + with self.assertRaises(ValueError): + rt._generic_metrics(metric_name=AAI_METRIC_NAME, metric_meth=None) + + @patch.object( + InterpolatedRiskTrajectory, "_reset_risk_metrics_calculators", new_callable=Mock + ) + # @patch.object(InterpolatedRiskTrajectory, "npv_transform", new_callable=Mock) + def test_generic_metrics_None_concat_returns_empty( + self, mock_reset_risk_metrics_calculators + ): + self.mock_risk_period_calc1.calc_aai_per_group_metric.return_value = None + self.mock_risk_period_calc2.calc_aai_per_group_metric.return_value = None + mock_reset_risk_metrics_calculators.return_value = ( + self.mock_risk_metric_calculators + ) + rt = InterpolatedRiskTrajectory(self.snapshots_list) + # rt = self.mock_interpolated_risk_traj + # Mock CalcRiskPeriod instances return None, mimicking `calc_aai_per_group_metric` possibly + + result = rt._generic_metrics( + metric_name=AAI_PER_GROUP_METRIC_NAME, + metric_meth="calc_aai_per_group_metric", + ) + pd.testing.assert_frame_equal(result, pd.DataFrame()) + + @patch.object( + InterpolatedRiskTrajectory, "_reset_risk_metrics_calculators", new_callable=Mock + ) + # @patch.object(InterpolatedRiskTrajectory, "npv_transform", new_callable=Mock) + def test_generic_metrics_empty_df_concat_returns_empty( + self, mock_reset_risk_metrics_calculators + ): + self.mock_risk_period_calc1.calc_aai_per_group_metric.return_value = ( + pd.DataFrame() + ) + self.mock_risk_period_calc2.calc_aai_per_group_metric.return_value = ( + pd.DataFrame() + ) + mock_reset_risk_metrics_calculators.return_value = ( + self.mock_risk_metric_calculators + ) + rt = InterpolatedRiskTrajectory(self.snapshots_list) + # rt = self.mock_interpolated_risk_traj + # Mock CalcRiskPeriod instances return None, mimicking `calc_aai_per_group_metric` possibly + + result = rt._generic_metrics( + metric_name=AAI_PER_GROUP_METRIC_NAME, + metric_meth="calc_aai_per_group_metric", + ) + pd.testing.assert_frame_equal(result, pd.DataFrame()) + + @patch.object( + InterpolatedRiskTrajectory, "_reset_risk_metrics_calculators", new_callable=Mock + ) + @patch.object( + InterpolatedRiskTrajectory, + "_risk_contributions_post_treatment", + new_callable=Mock, + ) + def test_generic_metrics_risk_contribution_treatment( + self, + mock_risk_contributions_post_treatment, + mock_reset_risk_metrics_calculators, + ): + mock_risk_contributions_post_treatment.return_value = pd.DataFrame([42]) + self.mock_risk_period_calc1.calc_risk_contributions_metric.return_value = ( + self.aai_dates1 + ) + self.mock_risk_period_calc2.calc_risk_contributions_metric.return_value = ( + self.aai_dates2 + ) + mock_reset_risk_metrics_calculators.return_value = ( + self.mock_risk_metric_calculators + ) + rt = InterpolatedRiskTrajectory(self.snapshots_list) + # rt = self.mock_interpolated_risk_traj + # Mock CalcRiskPeriod instances return None, mimicking `calc_aai_per_group_metric` possibly + result = rt._generic_metrics( + metric_name=CONTRIBUTIONS_METRIC_NAME, + metric_meth="calc_risk_contributions_metric", + ) + mock_risk_contributions_post_treatment.assert_called_once() + pd.testing.assert_frame_equal(result, pd.DataFrame([42])) + + @patch.object( + InterpolatedRiskTrajectory, "_reset_risk_metrics_calculators", new_callable=Mock + ) + @patch.object(InterpolatedRiskTrajectory, "npv_transform", new_callable=Mock) + def test_generic_metrics_coord_id_handling( + self, mock_npv_transform, mock_risk_metric_calc + ): + mock_risk_metric_calc.return_value = self.mock_risk_metric_calculators + self.mock_risk_period_calc1.calc_eai_gdf.return_value = pd.DataFrame( + { + DATE_COL_NAME: [pd.Timestamp("2023-01-01"), pd.Timestamp("2023-01-01")], + GROUP_COL_NAME: pd.Categorical([pd.NA, pd.NA]), + MEASURE_COL_NAME: ["MEAS1", "MEAS1"], + METRIC_COL_NAME: [EAI_METRIC_NAME, EAI_METRIC_NAME], + COORD_ID_COL_NAME: [1, 2], + RISK_COL_NAME: [10.0, 20.0], + } + ) + self.mock_risk_period_calc2.calc_eai_gdf.return_value = pd.DataFrame() + rt = InterpolatedRiskTrajectory(self.snapshots_list) + result = rt._generic_metrics( + metric_name=EAI_METRIC_NAME, metric_meth="calc_eai_gdf" + ) + + expected_df = pd.DataFrame( + { + GROUP_COL_NAME: pd.Categorical(["All", "All"]), + DATE_COL_NAME: [pd.Timestamp("2023-01-01"), pd.Timestamp("2023-01-01")], + MEASURE_COL_NAME: ["MEAS1", "MEAS1"], + METRIC_COL_NAME: [EAI_METRIC_NAME, EAI_METRIC_NAME], + RISK_COL_NAME: [10.0, 20.0], + COORD_ID_COL_NAME: [ + 1, + 2, + ], # This column should remain and be placed at the end before risk if not in front_columns + } + ) + # The internal logic reorders columns, ensure it matches + cols_order = [ + DATE_COL_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + COORD_ID_COL_NAME, + RISK_COL_NAME, + ] + pd.testing.assert_frame_equal(result[cols_order], expected_df[cols_order]) + + # --- Test Specific Metric Methods (e.g., `eai_metrics`, `aai_metrics`) --- + # These are mostly thin wrappers around _compute_metrics/_generic_metrics. + # Focus on ensuring they call _compute_metrics with the correct arguments. + + @patch.object(InterpolatedRiskTrajectory, "_compute_metrics") + def test_eai_metrics(self, mock_compute_metrics): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + rt.eai_metrics(npv=True, some_arg="test") + mock_compute_metrics.assert_called_once_with( + npv=True, + metric_name=EAI_METRIC_NAME, + metric_meth="calc_eai_gdf", + some_arg="test", + ) + + @patch.object(InterpolatedRiskTrajectory, "_compute_metrics") + def test_aai_metrics(self, mock_compute_metrics): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + rt.aai_metrics(other_arg=123) + mock_compute_metrics.assert_called_once_with( + metric_name=AAI_METRIC_NAME, metric_meth="calc_aai_metric", other_arg=123 + ) + + @patch.object(InterpolatedRiskTrajectory, "_compute_metrics") + def test_return_periods_metrics(self, mock_compute_metrics): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + rt.return_periods_metrics(npv=True, rp_arg="xyz") + mock_compute_metrics.assert_called_once_with( + npv=True, + metric_name=RETURN_PERIOD_METRIC_NAME, + metric_meth="calc_return_periods_metric", + return_periods=rt.return_periods, + rp_arg="xyz", + ) + + @patch.object(InterpolatedRiskTrajectory, "_compute_metrics") + def test_aai_per_group_metrics(self, mock_compute_metrics): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + rt.aai_per_group_metrics() + mock_compute_metrics.assert_called_once_with( + metric_name=AAI_PER_GROUP_METRIC_NAME, + metric_meth="calc_aai_per_group_metric", + ) + + @patch.object(InterpolatedRiskTrajectory, "_compute_metrics") + def test_risk_components_metrics(self, mock_compute_metrics): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + rt.risk_contributions_metrics() + mock_compute_metrics.assert_called_once_with( + metric_name=CONTRIBUTIONS_METRIC_NAME, + metric_meth="calc_risk_contributions_metric", + ) + + ## Test `npv_transform` (class method) + def test_npv_transform_no_group_col(self): + df_input = pd.DataFrame( + { + DATE_COL_NAME: pd.to_datetime(["2023-01-01", "2024-01-01"] * 2), + MEASURE_COL_NAME: ["m1", "m1", "m2", "m2"], + METRIC_COL_NAME: [ + AAI_METRIC_NAME, + AAI_METRIC_NAME, + AAI_METRIC_NAME, + AAI_METRIC_NAME, + ], + RISK_COL_NAME: [100.0, 200.0, 80.0, 180.0], + } + ) + # Mock the internal calc_npv_cash_flows + with patch( + "climada.trajectories.trajectory.RiskTrajectory._calc_npv_cash_flows" + ) as mock_calc_npv: + # For each group, it will be called + mock_calc_npv.side_effect = [ + pd.Series( + [100.0 * (1 / (1 + 0.01)) ** 0, 200.0 * (1 / (1 + 0.02)) ** 1], + index=[pd.Timestamp("2023-01-01"), pd.Timestamp("2024-01-01")], + ), + pd.Series( + [80.0 * (1 / (1 + 0.01)) ** 0, 180.0 * (1 / (1 + 0.02)) ** 1], + index=[pd.Timestamp("2023-01-01"), pd.Timestamp("2024-01-01")], + ), + ] + result_df = InterpolatedRiskTrajectory.npv_transform( + df_input.copy(), self.mock_disc_rates + ) + # Assertions for mock calls + # Grouping by 'measure', 'metric' (default _grouper) + pd.testing.assert_series_equal( + mock_calc_npv.mock_calls[0].args[0], + pd.Series( + [100.0, 200.0], + index=pd.Index( + [ + pd.Timestamp("2023-01-01"), + pd.Timestamp("2024-01-01"), + ], + name=DATE_COL_NAME, + ), + name=("m1", AAI_METRIC_NAME), + ), + ) + assert mock_calc_npv.mock_calls[0].args[1] == pd.Timestamp("2023-01-01") + assert mock_calc_npv.mock_calls[0].args[2] == self.mock_disc_rates + pd.testing.assert_series_equal( + mock_calc_npv.mock_calls[1].args[0], + pd.Series( + [80.0, 180.0], + index=pd.Index( + [ + pd.Timestamp("2023-01-01"), + pd.Timestamp("2024-01-01"), + ], + name=DATE_COL_NAME, + ), + name=("m2", AAI_METRIC_NAME), + ), + ) + assert mock_calc_npv.mock_calls[1].args[1] == pd.Timestamp("2023-01-01") + assert mock_calc_npv.mock_calls[1].args[2] == self.mock_disc_rates + + expected_df = pd.DataFrame( + { + DATE_COL_NAME: pd.to_datetime(["2023-01-01", "2024-01-01"] * 2), + MEASURE_COL_NAME: ["m1", "m1", "m2", "m2"], + METRIC_COL_NAME: [ + AAI_METRIC_NAME, + AAI_METRIC_NAME, + AAI_METRIC_NAME, + AAI_METRIC_NAME, + ], + RISK_COL_NAME: [ + 100.0 * (1 / (1 + 0.01)) ** 0, + 200.0 * (1 / (1 + 0.02)) ** 1, + 80.0 * (1 / (1 + 0.01)) ** 0, + 180.0 * (1 / (1 + 0.02)) ** 1, + ], + } + ) + pd.testing.assert_frame_equal( + result_df.sort_values(DATE_COL_NAME).reset_index(drop=True), + expected_df.sort_values(DATE_COL_NAME).reset_index(drop=True), + rtol=1e-6, + ) + + def test_npv_transform_with_group_col(self): + df_input = pd.DataFrame( + { + DATE_COL_NAME: pd.to_datetime( + ["2023-01-01", "2024-01-01", "2023-01-01"] + ), + GROUP_COL_NAME: ["G1", "G1", "G2"], + MEASURE_COL_NAME: ["m1", "m1", "m1"], + METRIC_COL_NAME: [AAI_METRIC_NAME, AAI_METRIC_NAME, AAI_METRIC_NAME], + RISK_COL_NAME: [100.0, 200.0, 150.0], + } + ) + with patch( + "climada.trajectories.trajectory.RiskTrajectory._calc_npv_cash_flows" + ) as mock_calc_npv: + mock_calc_npv.side_effect = [ + # First group G1, m1, aai + pd.Series( + [100.0 * (1 / (1 + 0.01)) ** 0, 200.0 * (1 / (1 + 0.02)) ** 1], + index=[pd.Timestamp("2023-01-01"), pd.Timestamp("2024-01-01")], + ), + # Second group G2, m1, aai + pd.Series( + [150.0 * (1 / (1 + 0.01)) ** 0], index=[pd.Timestamp("2023-01-01")] + ), + ] + result_df = InterpolatedRiskTrajectory.npv_transform( + df_input.copy(), self.mock_disc_rates + ) + + expected_df = pd.DataFrame( + { + DATE_COL_NAME: pd.to_datetime( + ["2023-01-01", "2024-01-01", "2023-01-01"] + ), + GROUP_COL_NAME: ["G1", "G1", "G2"], + MEASURE_COL_NAME: ["m1", "m1", "m1"], + METRIC_COL_NAME: [ + AAI_METRIC_NAME, + AAI_METRIC_NAME, + AAI_METRIC_NAME, + ], + RISK_COL_NAME: [ + 100.0 * (1 / (1 + 0.01)) ** 0, + 200.0 * (1 / (1 + 0.02)) ** 1, + 150.0 * (1 / (1 + 0.01)) ** 0, + ], + } + ) + pd.testing.assert_frame_equal( + result_df.sort_values([GROUP_COL_NAME, DATE_COL_NAME]).reset_index( + drop=True + ), + expected_df.sort_values([GROUP_COL_NAME, DATE_COL_NAME]).reset_index( + drop=True + ), + rtol=1e-6, + ) + + @patch.object(InterpolatedRiskTrajectory, "_generic_metrics") + @patch.object(InterpolatedRiskTrajectory, "_date_to_period_agg") + def test_compute_period_metrics(self, mock_date_to_period, mock_generic_metrics): + mock_date_to_period.return_value = 42 + mock_generic_metrics.return_value = 46 + rt = InterpolatedRiskTrajectory(self.snapshots_list) + result = rt._compute_period_metrics("name", "method", other_args=5) + mock_generic_metrics.assert_called_once_with( + metric_name="name", metric_meth="method", other_args=5 + ) + mock_date_to_period.assert_called_once_with(46, grouper=rt._grouper) + self.assertEqual(result, 42) + + def test_risk_contributions_post_treatment(self): + # Create a sample DataFrame + data = { + GROUP_COL_NAME: ["All"] * 15, + DATE_COL_NAME: [ + pd.Period("2023-01-01", freq="Y"), + pd.Period("2024-01-02", freq="Y"), + pd.Period("2025-01-02", freq="Y"), + ] + * 5, + MEASURE_COL_NAME: ["measure1"] * 15, + METRIC_COL_NAME: [ + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + ], + RISK_COL_NAME: [100, 100, 195, 0, 50, 100, 0, 10, 20, 0, 5, 10, 0, 30, 60], + } + df = pd.DataFrame(data) + + # Call the method + rt = InterpolatedRiskTrajectory(self.snapshots_list) + result_df = rt._risk_contributions_post_treatment(df) + + # Expected output + expected_data = { + DATE_COL_NAME: [ + pd.Period("2023-01-01", freq="Y"), + pd.Period("2024-01-02", freq="Y"), + pd.Period("2025-01-02", freq="Y"), + ] + * 5, + GROUP_COL_NAME: ["All"] * 15, + MEASURE_COL_NAME: ["measure1"] * 15, + METRIC_COL_NAME: [ + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + ], + RISK_COL_NAME: [100, 100, 100, 0, 50, 150, 0, 10, 30, 0, 5, 15, 0, 30, 90], + } + expected_df = pd.DataFrame(expected_data) + + # Assert the result + pd.testing.assert_frame_equal( + result_df.reset_index(drop=True), expected_df.reset_index(drop=True) + ) + + # --- Test Per Period Risk Aggregation (`_per_period_risk`) --- + def test_per_period_risk_basic(self): + df_input = pd.DataFrame( + { + DATE_COL_NAME: pd.to_datetime( + ["2023-01-01", "2024-01-01", "2025-01-01", "2023-01-01"] + ), + GROUP_COL_NAME: ["All", "All", "All", "GroupB"], + MEASURE_COL_NAME: ["m1", "m1", "m1", "m1"], + METRIC_COL_NAME: [ + AAI_METRIC_NAME, + AAI_METRIC_NAME, + AAI_METRIC_NAME, + AAI_METRIC_NAME, + ], + RISK_COL_NAME: [100.0, 200.0, 300.0, 50.0], + } + ) + result_df = InterpolatedRiskTrajectory._date_to_period_agg( + df_input, grouper=InterpolatedRiskTrajectory._grouper + ) + + expected_df = pd.DataFrame( + { + PERIOD_COL_NAME: [ + "2023-01-01 to 2025-01-01", + "2023-01-01 to 2023-01-01", + ], + GROUP_COL_NAME: ["All", "GroupB"], + MEASURE_COL_NAME: ["m1", "m1"], + METRIC_COL_NAME: [AAI_METRIC_NAME, AAI_METRIC_NAME], + RISK_COL_NAME: [200.0, 50.0], # 100+200+300 for 'All', 50 for 'GroupB' + } + ) + # Sorting for comparison consistency + pd.testing.assert_frame_equal( + result_df.sort_values([GROUP_COL_NAME, PERIOD_COL_NAME]).reset_index( + drop=True + ), + expected_df.sort_values([GROUP_COL_NAME, PERIOD_COL_NAME]).reset_index( + drop=True + ), + ) + + def test_per_period_risk_multiple_risk_cols(self): + df_input = pd.DataFrame( + { + DATE_COL_NAME: pd.to_datetime(["2023-01-01", "2024-01-01"]), + GROUP_COL_NAME: ["All", "All"], + MEASURE_COL_NAME: ["m1", "m1"], + METRIC_COL_NAME: ["risk_components", "risk_components"], + CONTRIBUTION_BASE_RISK_NAME: [10.0, 20.0], + CONTRIBUTION_EXPOSURE_NAME: [5.0, 8.0], + } + ) + result_df = InterpolatedRiskTrajectory._date_to_period_agg( + df_input, + grouper=InterpolatedRiskTrajectory._grouper, + colname=[CONTRIBUTION_BASE_RISK_NAME, CONTRIBUTION_EXPOSURE_NAME], + ) + + expected_df = pd.DataFrame( + { + PERIOD_COL_NAME: ["2023-01-01 to 2024-01-01"], + GROUP_COL_NAME: ["All"], + MEASURE_COL_NAME: ["m1"], + METRIC_COL_NAME: ["risk_components"], + CONTRIBUTION_BASE_RISK_NAME: [15.0], + CONTRIBUTION_EXPOSURE_NAME: [6.5], + } + ) + pd.testing.assert_frame_equal(result_df, expected_df) + + def test_per_period_risk_non_yearly_intervals(self): + df_input = pd.DataFrame( + { + DATE_COL_NAME: pd.to_datetime( + ["2023-01-01", "2023-02-01", "2023-03-01"] + ), + GROUP_COL_NAME: ["All", "All", "All"], + MEASURE_COL_NAME: ["m1", "m1", "m1"], + METRIC_COL_NAME: [AAI_METRIC_NAME, AAI_METRIC_NAME, AAI_METRIC_NAME], + RISK_COL_NAME: [10.0, 20.0, 30.0], + } + ) + # Test with 'month' time_unit + result_df_month = InterpolatedRiskTrajectory._date_to_period_agg( + df_input, grouper=InterpolatedRiskTrajectory._grouper, time_unit="month" + ) + expected_df_month = pd.DataFrame( + { + PERIOD_COL_NAME: ["2023-01-01 to 2023-03-01"], + GROUP_COL_NAME: ["All"], + MEASURE_COL_NAME: ["m1"], + METRIC_COL_NAME: [AAI_METRIC_NAME], + RISK_COL_NAME: [20.0], + } + ) + pd.testing.assert_frame_equal(result_df_month, expected_df_month) + + # Introduce a gap for 'month' time_unit + df_gap = pd.DataFrame( + { + DATE_COL_NAME: pd.to_datetime( + ["2023-01-01", "2023-02-01", "2023-04-01"] + ), # Gap in March + GROUP_COL_NAME: ["All", "All", "All"], + MEASURE_COL_NAME: ["m1", "m1", "m1"], + METRIC_COL_NAME: [AAI_METRIC_NAME, AAI_METRIC_NAME, AAI_METRIC_NAME], + RISK_COL_NAME: [10.0, 20.0, 40.0], + } + ) + result_df_gap = InterpolatedRiskTrajectory._date_to_period_agg( + df_gap, grouper=InterpolatedRiskTrajectory._grouper, time_unit="month" + ) + expected_df_gap = pd.DataFrame( + { + PERIOD_COL_NAME: [ + "2023-01-01 to 2023-02-01", + "2023-04-01 to 2023-04-01", + ], + GROUP_COL_NAME: ["All", "All"], + MEASURE_COL_NAME: ["m1", "m1"], + METRIC_COL_NAME: [AAI_METRIC_NAME, AAI_METRIC_NAME], + RISK_COL_NAME: [15.0, 40.0], + } + ) + pd.testing.assert_frame_equal( + result_df_gap.sort_values(PERIOD_COL_NAME).reset_index(drop=True), + expected_df_gap.sort_values(PERIOD_COL_NAME).reset_index(drop=True), + ) + + # --- Test Combined Metrics (`per_date_risk_metrics`, `per_period_risk_metrics`) --- + + @patch.object(InterpolatedRiskTrajectory, "aai_metrics") + @patch.object(InterpolatedRiskTrajectory, "return_periods_metrics") + @patch.object(InterpolatedRiskTrajectory, "aai_per_group_metrics") + def test_per_date_risk_metrics_defaults( + self, mock_aai_per_group, mock_return_periods, mock_aai + ): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + # Set up mock return values for each method + mock_aai.return_value = pd.DataFrame( + {METRIC_COL_NAME: [AAI_METRIC_NAME], RISK_COL_NAME: [100]} + ) + mock_return_periods.return_value = pd.DataFrame( + {METRIC_COL_NAME: ["rp"], RISK_COL_NAME: [50]} + ) + mock_aai_per_group.return_value = pd.DataFrame( + {METRIC_COL_NAME: ["aai_grp"], RISK_COL_NAME: [10]} + ) + + result = rt.per_date_risk_metrics() + + # Assert calls with default arguments + mock_aai.assert_called_once_with() + mock_return_periods.assert_called_once_with() + mock_aai_per_group.assert_called_once_with() + + # Assert concatenation + expected_df = pd.concat( + [ + mock_aai.return_value, + mock_return_periods.return_value, + mock_aai_per_group.return_value, + ] + ) + pd.testing.assert_frame_equal( + result.reset_index(drop=True), expected_df.reset_index(drop=True) + ) + + @patch.object(InterpolatedRiskTrajectory, "aai_metrics") + @patch.object(InterpolatedRiskTrajectory, "return_periods_metrics") + @patch.object(InterpolatedRiskTrajectory, "aai_per_group_metrics") + def test_per_date_risk_metrics_custom_metrics_and_rps( + self, mock_aai_per_group, mock_return_periods, mock_aai + ): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + mock_aai.return_value = pd.DataFrame( + {METRIC_COL_NAME: [AAI_METRIC_NAME], RISK_COL_NAME: [100]} + ) + mock_return_periods.return_value = pd.DataFrame( + {METRIC_COL_NAME: ["rp"], RISK_COL_NAME: [50]} + ) + + custom_metrics = [AAI_METRIC_NAME, RETURN_PERIOD_METRIC_NAME] + result = rt.per_date_risk_metrics(metrics=custom_metrics) + + mock_aai.assert_called_once_with() + mock_return_periods.assert_called_once_with() + mock_aai_per_group.assert_not_called() # Not in custom_metrics + + expected_df = pd.concat( + [mock_aai.return_value, mock_return_periods.return_value] + ) + pd.testing.assert_frame_equal( + result.reset_index(drop=True), expected_df.reset_index(drop=True) + ) + + @patch.object(InterpolatedRiskTrajectory, "per_date_risk_metrics") + @patch.object(InterpolatedRiskTrajectory, "_date_to_period_agg") + def test_per_period_risk_metrics( + self, mock_per_period_risk, mock_per_date_risk_metrics + ): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + mock_date_df = pd.DataFrame( + {METRIC_COL_NAME: [AAI_METRIC_NAME], RISK_COL_NAME: [100]} + ) + mock_per_date_risk_metrics.return_value = mock_date_df + mock_per_period_risk.return_value = pd.DataFrame( + {PERIOD_COL_NAME: ["P1"], RISK_COL_NAME: [200]} + ) + + test_metrics = [AAI_METRIC_NAME] + result = rt.per_period_risk_metrics(metrics=test_metrics, time_unit="month") + + mock_per_date_risk_metrics.assert_called_once_with( + metrics=test_metrics, time_unit="month" + ) + mock_per_period_risk.assert_called_once_with( + mock_date_df, grouper=rt._grouper + [UNIT_COL_NAME], time_unit="month" + ) + pd.testing.assert_frame_equal(result, mock_per_period_risk.return_value) + + # --- Test Plotting Related Methods --- + # These methods primarily generate data for plotting or call plotting functions. + # The actual plotting logic (matplotlib.pyplot calls) should be mocked. + + @patch.object(InterpolatedRiskTrajectory, "risk_contributions_metrics") + def test_calc_waterfall_plot_data(self, mock_risk_contributions_metrics): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + rt.start_date = datetime.date(2023, 1, 1) + rt.end_date = datetime.date(2025, 1, 1) + + # Mock the return of risk_components_metrics + mock_risk_contributions_metrics.return_value = pd.DataFrame( + { + DATE_COL_NAME: pd.to_datetime( + ["2023-01-01"] * 5 + + ["2024-01-01"] * 5 + + ["2025-01-01"] * 5 + + ["2026-01-01"] * 5 + ), + METRIC_COL_NAME: [ + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + ] + * 4, + RISK_COL_NAME: np.arange(20) + * 1.0, # Dummy data for different components and dates + } + ) # .pivot_table(index=DATE_COL_NAME, columns=METRIC_COL_NAME, values=RISK_COL_NAME) + # Flattened for simplicity, in reality it's more structured + + result = rt._calc_waterfall_plot_data( + start_date=datetime.date(2024, 1, 1), + end_date=datetime.date(2025, 1, 1), + ) + + mock_risk_contributions_metrics.assert_called_once_with() + + # Expected output should be filtered by date and unstacked + expected_df = pd.DataFrame( + { + DATE_COL_NAME: pd.to_datetime(["2024-01-01"] * 5 + ["2025-01-01"] * 5), + METRIC_COL_NAME: [ + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + ] + * 2, + RISK_COL_NAME: np.array([5.0, 6, 7, 8, 9, 10, 11, 12, 13, 14]), + } + ).pivot_table( + index=DATE_COL_NAME, columns=METRIC_COL_NAME, values=RISK_COL_NAME + ) + pd.testing.assert_frame_equal( + result.sort_index(axis=1), expected_df.sort_index(axis=1) + ) # Sort columns for stable comparison + + @patch("matplotlib.pyplot.subplots") + @patch("matplotlib.dates.AutoDateLocator") + @patch("matplotlib.dates.ConciseDateFormatter") + @patch.object(InterpolatedRiskTrajectory, "_calc_waterfall_plot_data") + def test_plot_per_date_waterfall( + self, mock_calc_data, mock_formatter, mock_locator, mock_subplots + ): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + rt.start_date = datetime.date(2023, 1, 1) + rt.end_date = datetime.date(2023, 1, 2) + + # Mock matplotlib objects + mock_ax = Mock() + mock_fig = Mock() + mock_subplots.return_value = (mock_fig, mock_ax) + mock_ax.get_ylim.return_value = (0, 100) # For ylim scaling + + # Mock data returned by _calc_waterfall_plot_data + mock_df_data = pd.DataFrame( + { + CONTRIBUTION_BASE_RISK_NAME: [10, 10], + CONTRIBUTION_EXPOSURE_NAME: [2, 3], + CONTRIBUTION_HAZARD_NAME: [5, 6], + CONTRIBUTION_VULNERABILITY_NAME: [1, 2], + CONTRIBUTION_INTERACTION_TERM_NAME: [0.5, 0.7], + }, + index=pd.period_range(start="2023-01-01", end="2023-01-02", freq="D"), + ) + mock_calc_data.return_value = mock_df_data + + # Call the method + fig, ax = rt.plot_time_waterfall() + + # Assertions + mock_calc_data.assert_called_once_with( + start_date=datetime.date(2023, 1, 1), + end_date=datetime.date(2023, 1, 2), + ) + mock_ax.stackplot.assert_called_once() + self.assertEqual( + mock_ax.stackplot.call_args[0][0].tolist(), + mock_df_data.index.to_timestamp().tolist(), # type: ignore + ) # Check x-axis data + self.assertEqual( + mock_ax.stackplot.call_args[0][1][0].tolist(), + mock_df_data[CONTRIBUTION_BASE_RISK_NAME].tolist(), + ) # Check first stacked data + mock_ax.set_title.assert_called_once_with( + "Risk between 2023-01-01 and 2023-01-02 (Average impact)" + ) + mock_ax.set_ylabel.assert_called_once_with("USD") + mock_ax.set_ylim.assert_called_once() # Check ylim was set + mock_ax.xaxis.set_major_locator.assert_called_once() + mock_ax.xaxis.set_major_formatter.assert_called_once() + self.assertEqual(fig, mock_fig) + self.assertEqual(ax, mock_ax) + + @patch("matplotlib.pyplot.subplots") + @patch.object(InterpolatedRiskTrajectory, "_calc_waterfall_plot_data") + def test_plot_waterfall(self, mock_calc_data, mock_subplots): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + rt.start_date = datetime.date(2023, 1, 1) + rt.end_date = datetime.date(2024, 1, 1) + + mock_ax = Mock() + mock_fig = Mock() + mock_subplots.return_value = (mock_fig, mock_ax) + mock_ax.get_ylim.return_value = (0, 100) + + # Mock _calc_waterfall_plot_data to return a DataFrame for two dates, + # where the second date (end_date) is relevant for plot_waterfall + start_date = "2023-01-01" + end_date = "2024-01-01" + mock_data = pd.DataFrame( + { + DATE_COL_NAME: pd.to_datetime([start_date] * 5 + [end_date] * 5), + METRIC_COL_NAME: [ + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + ] + * 2, + RISK_COL_NAME: [ + 10, + 2, + 5, + 1, + 0.5, + 15, + 3, + 7, + 2, + 1, + ], # values for 2023-01-01 and 2024-01-01 + } + ).pivot_table( + index=DATE_COL_NAME, columns=METRIC_COL_NAME, values=RISK_COL_NAME + ) + mock_calc_data.return_value = mock_data + # Call the method + ax = rt.plot_waterfall() + + # Assertions + mock_calc_data.assert_called_once_with( + start_date=datetime.date.fromisoformat(start_date), + end_date=datetime.date.fromisoformat(end_date), + ) + mock_ax.bar.assert_called_once() + # Verify the bar arguments are correct for the end_date data + end_date_data = mock_data.loc[pd.Timestamp(end_date)] + expected_values = [ + end_date_data[CONTRIBUTION_BASE_RISK_NAME], + end_date_data[CONTRIBUTION_EXPOSURE_NAME], + end_date_data[CONTRIBUTION_HAZARD_NAME], + end_date_data[CONTRIBUTION_VULNERABILITY_NAME], + end_date_data[CONTRIBUTION_INTERACTION_TERM_NAME], + end_date_data.sum(), + ] + # Compare values passed to bar + np.testing.assert_allclose(mock_ax.bar.call_args[0][1], expected_values) + start_date_p = pd.to_datetime(start_date).to_period(rt.time_resolution) + end_date_p = pd.to_datetime(end_date).to_period(rt.time_resolution) + mock_ax.set_title.assert_called_once_with( + f"Evolution of the contributions of risk between {start_date_p} and {end_date_p} (Average impact)" + ) + mock_ax.set_ylabel.assert_called_once_with("USD") + mock_ax.set_ylim.assert_called_once() + mock_ax.tick_params.assert_called_once_with(axis="x", labelrotation=90) + self.assertEqual(ax, mock_ax) + + # --- Test Private Helper Methods (`_reset_metrics`, `_get_risk_periods`) --- + + def test_reset_metrics(self): + rt = InterpolatedRiskTrajectory(self.snapshots_list) + # Set some metrics to non-None values + rt._eai_metrics = "dummy_eai" # type:ignore + rt._aai_metrics = "dummy_aai" # type:ignore + rt._reset_metrics() + + for metric in rt.POSSIBLE_METRICS: + self.assertIsNone(getattr(rt, "_" + metric + "_metrics")) + + def test_get_risk_periods(self): + # Create dummy CalcRiskPeriod mocks with specific dates + mock_rp1 = Mock() + mock_rp1.snapshot_start.date = datetime.date(2020, 1, 1) + mock_rp1.snapshot_end.date = datetime.date(2021, 1, 1) + + mock_rp2 = Mock() + mock_rp2.snapshot_start.date = datetime.date(2021, 1, 1) + mock_rp2.snapshot_end.date = datetime.date(2022, 1, 1) + + mock_rp3 = Mock() + mock_rp3.snapshot_start.date = datetime.date(2022, 1, 1) + mock_rp3.snapshot_end.date = datetime.date(2023, 1, 1) + + all_risk_periods: list[CalcRiskMetricsPeriod] = [mock_rp1, mock_rp2, mock_rp3] + + # Strict case + + # Test case 1: Full range, all periods included + result = InterpolatedRiskTrajectory._get_risk_periods( + all_risk_periods, datetime.date(2020, 1, 1), datetime.date(2023, 1, 1) + ) + self.assertEqual(len(result), 3) + self.assertListEqual(result, all_risk_periods) + + # Test case 1b: More than full range, all periods included + result = InterpolatedRiskTrajectory._get_risk_periods( + all_risk_periods, datetime.date(2018, 1, 1), datetime.date(2024, 1, 1) + ) + self.assertEqual(len(result), 3) + self.assertListEqual(result, all_risk_periods) + + # Test case 2: Range including some period + result = InterpolatedRiskTrajectory._get_risk_periods( + all_risk_periods, datetime.date(2021, 1, 1), datetime.date(2023, 1, 1) + ) + self.assertEqual(len(result), 2) + self.assertListEqual(result, all_risk_periods[1:]) + + # Test case 2: Range including no period + result = InterpolatedRiskTrajectory._get_risk_periods( + all_risk_periods, datetime.date(2021, 6, 1), datetime.date(2022, 6, 1) + ) + self.assertEqual(len(result), 0) + self.assertListEqual(result, []) + + # Overlap case + + # Test case 1: Full range, all periods included (should still work) + result = InterpolatedRiskTrajectory._get_risk_periods( + all_risk_periods, + datetime.date(2020, 1, 1), + datetime.date(2023, 1, 1), + strict=False, + ) + self.assertEqual(len(result), 3) + self.assertListEqual(result, all_risk_periods) + + # Test case 1b: More than full range, all periods included + result = InterpolatedRiskTrajectory._get_risk_periods( + all_risk_periods, + datetime.date(2018, 1, 1), + datetime.date(2024, 1, 1), + strict=False, + ) + self.assertEqual(len(result), 3) + self.assertListEqual(result, all_risk_periods) + + # Test case 2: Range including some period + result = InterpolatedRiskTrajectory._get_risk_periods( + all_risk_periods, + datetime.date(2021, 1, 1), + datetime.date(2023, 1, 1), + strict=False, + ) + self.assertEqual(len(result), 2) + self.assertListEqual(result, all_risk_periods[1:]) + + # Test case 2: Range including no period but overlap + result = InterpolatedRiskTrajectory._get_risk_periods( + all_risk_periods, + datetime.date(2021, 6, 1), + datetime.date(2022, 6, 1), + strict=False, + ) + self.assertEqual(len(result), 2) + self.assertListEqual(result, all_risk_periods[1:]) + + # Test case 2: Range including no period at all + result = InterpolatedRiskTrajectory._get_risk_periods( + all_risk_periods, + datetime.date(2024, 6, 1), + datetime.date(2026, 6, 1), + strict=False, + ) + self.assertEqual(len(result), 0) + self.assertListEqual(result, []) + + +if __name__ == "__main__": + TESTS = unittest.TestLoader().loadTestsFromTestCase(TestInterpolatedRiskTrajectory) + unittest.TextTestRunner(verbosity=2).run(TESTS) diff --git a/doc/user-guide/climada_trajectories.ipynb b/doc/user-guide/climada_trajectories.ipynb new file mode 100644 index 0000000000..7fa347b4ea --- /dev/null +++ b/doc/user-guide/climada_trajectories.ipynb @@ -0,0 +1,2209 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "96920214-a14b-4094-9949-36a1175b1df8", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "id": "56a07dee-25a8-4bb5-a01c-933ee955f067", + "metadata": {}, + "source": [ + "Currently, to run this tutorial, from within a climada_python git repo please run:\n", + "\n", + "```\n", + "mamba create -n climada_trajectory \"python==3.11.*\"\n", + "git fetch\n", + "git checkout feature/risk_trajectory\n", + "mamba env update -n climada_trajectory -f requirements/env_climada.yml\n", + "mamba activate climada_trajectory\n", + "python -m pip install -e ./\n", + "\n", + "```\n", + "\n", + "To be able to select that environment in jupyter you possibly might also need:\n", + "\n", + "```\n", + "mamba install ipykernel\n", + "python -m ipykernel install --user --name climada_trajectory\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "856ac388-9edb-497e-a2ff-a325f2a22562", + "metadata": {}, + "source": [ + "# Important disclaimers" + ] + }, + { + "cell_type": "markdown", + "id": "f7d4fdab-8662-4848-bb87-9b6045447957", + "metadata": {}, + "source": [ + "## Interpolation of risk can be... risky" + ] + }, + { + "cell_type": "markdown", + "id": "8f9531a7-9a1a-400f-8c82-3a51fdc6671a", + "metadata": {}, + "source": [ + "One purpose of this module is to improve the evaluation of risk in between two \"known\" points in time.\n", + "\n", + "This part relies on interpolation (linear by default) of impacts and risk metrics in between the different specified points, \n", + "which may lead to incoherent results in cases where this simplification drifts too far from reality.\n", + "\n", + "For instance if you are using different historical events as you points in time, a static comparison of the different risk\n", + "estimates may be interesting, but interpolating in between makes very little sense.\n", + "\n", + "As always users should carefully consider if the tool fits the purpose and if the limitations \n", + "remain acceptable, even more so when used to design Disaster Risk Reduction or Climate Change Adaptation measures." + ] + }, + { + "cell_type": "markdown", + "id": "c588329e-f5a5-4945-aad1-900b7bb675e3", + "metadata": {}, + "source": [ + "## Memory and computation requirements\n", + "\n", + "This module adds a new dimension (time) to the risk, as such, it **multiplies** the memory and computation requirement along that dimension (although we avoid running a full-fledge impact computation for each \"interpolated\" point, we still have to define an impact matrix for each of those). \n", + "\n", + "This can of course (very) quickly increase the memory and computation requirements for bigger data. We encourage you to first try on small examples before running big computations.\n" + ] + }, + { + "cell_type": "markdown", + "id": "b53b1da2-7be1-4507-96bb-2efd8dd3e910", + "metadata": {}, + "source": [ + "# Using the `trajectories` module" + ] + }, + { + "cell_type": "markdown", + "id": "4e0f3261-f443-4cc6-b85b-c6a3d90b73e3", + "metadata": {}, + "source": [ + "The fundamental idea behing the `trajectories` module is to enable a better assessment of the evolution of risk over time, both by facilitating point by point comparison, and risk \"evolutions\".\n", + "\n", + "It aims at facilitating answering questions such as:\n", + "\n", + "- How does future hazards (probabilistic event set), exposure and vulnerability change impacts with respect to present?\n", + "- How would the impacts compare if a past event were to happen again with present / future exposure?\n", + "- etc." + ] + }, + { + "cell_type": "markdown", + "id": "6396ab9f-7b09-49a7-81a5-a45e7a99a4ff", + "metadata": {}, + "source": [ + "## `Snapshot`: A snapshot of risk at a specific year" + ] + }, + { + "cell_type": "markdown", + "id": "274a342f-54c0-4590-9110-5e297010955e", + "metadata": {}, + "source": [ + "We use `Snapshot` objects to define a point in time for risk. This object acts as a wrapper of the classic risk framework composed of Exposure, Hazard and Vulnerability. As such it is defined for a specific date (usually a year), and contains references to an `Exposures`, a `Hazard`, and an `ImpactFuncSet` object.\n", + "\n", + "Instantiating such a `Snapshot` is done simply with:\n", + "\n", + "```python\n", + "snap = Snapshot(\n", + " exposure=your_exposure,\n", + " hazard=your_hazard,\n", + " impfset=your_impfset,\n", + " date=your_date\n", + " )\n", + "```\n", + "\n", + "Note that to avoid any ambiguity, you need to write explicitly `exposure=your_exposure`.\n", + "\n", + "Think of `Snapshot` as a representation of risk at, or around, a specific date. Your hazard should thus be a probabilistic set of events representative for the specified date.\n", + "Note that the date does not need to be a year and can be a datetime if you want to make comparisons on a sub-yearly level.\n", + "\n", + "Below is an example of how to setup a such Snapshot using data from the data API for tropical cyclones in Haiti:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "dec203d1-943f-41d8-9542-009f288b937b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "ERROR 1: PROJ: proj_create_from_database: Open of /home/sjuhel/miniforge3/envs/cb_refactoring/share/proj failed\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-11-03 18:28:45,600 - climada.entity.exposures.base - INFO - Reading /home/sjuhel/climada/data/exposures/litpop/LitPop_150arcsec_HTI/v3/LitPop_150arcsec_HTI.hdf5\n", + "2025-11-03 18:28:51,465 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020/v2/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020.hdf5\n", + "2025-11-03 18:28:51,489 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-11-03 18:28:51,491 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n" + ] + } + ], + "source": [ + "from climada.util.api_client import Client\n", + "from climada.entity import ImpactFuncSet, ImpfTropCyclone\n", + "from climada.trajectories.snapshot import Snapshot\n", + "\n", + "client = Client()\n", + "\n", + "exp_present = client.get_litpop(country=\"Haiti\")\n", + "\n", + "haz_present = client.get_hazard(\n", + " \"tropical_cyclone\",\n", + " properties={\n", + " \"country_name\": \"Haiti\",\n", + " \"climate_scenario\": \"historical\",\n", + " \"nb_synth_tracks\": \"10\",\n", + " },\n", + ")\n", + "exp_present.assign_centroids(haz_present, distance=\"approx\")\n", + "\n", + "impf_set = ImpactFuncSet([ImpfTropCyclone.from_emanuel_usa()])\n", + "exp_present.gdf.rename(columns={\"impf_\": \"impf_TC\"}, inplace=True)\n", + "exp_present.gdf[\"impf_TC\"] = 1\n", + "\n", + "# Trajectories allow to look at the risk faced by specifics groups of coordinates based on the \"group_id\" column of the exposure\n", + "exp_present.gdf[\"group_id\"] = (exp_present.gdf[\"value\"] > 500000) * 1\n", + "\n", + "snap = Snapshot(exposure=exp_present, hazard=haz_present, impfset=impf_set, date=2018)" + ] + }, + { + "cell_type": "markdown", + "id": "044e2b4f-506a-492f-9627-471f46ad7c3a", + "metadata": {}, + "source": [ + "All risk dimensions are freely accessible from the snapshot:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "aa0becca-d334-40b4-86c0-1959c750f6d5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-11-03 18:28:51,822 - climada.util.coordinates - INFO - Raster from resolution 0.04166665999999708 to 0.04166665999999708.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/sjuhel/Repos/climada_python/climada/util/coordinates.py:3130: FutureWarning: The `drop` keyword argument is deprecated and in future the only supported behaviour will match drop=False. To silence this warning and adopt the future behaviour, stop providing `drop` as a keyword to `set_geometry`. To replicate the `drop=True` behaviour you should update your code to\n", + "`geo_col_name = gdf.active_geometry_name; gdf.set_geometry(new_geo_col).drop(columns=geo_col_name).rename_geometry(geo_col_name)`.\n", + " df_poly.set_geometry(\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "snap.exposure.plot_raster()\n", + "snap.hazard.plot_intensity(0)\n", + "snap.impfset.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "d2e6daae-6345-41ac-a560-71040942db39", + "metadata": {}, + "source": [ + "## Evaluating risk from multiple snapshots using trajectories" + ] + }, + { + "cell_type": "markdown", + "id": "8e8458c3-a3f9-4210-9de0-15293167f2f9", + "metadata": {}, + "source": [ + "Trajectories facilitate the evaluation of risk of multiple snapshot. There are two kinds of trajectories:\n", + "\n", + "- `StaticRiskTrajectory`: which estimate the risk at each snaphot only, and regroups the results nicely.\n", + "- `InterpolatedRiskTrajectory`: which also includes the evolution of risk in between the snapshots through interpolation.\n", + "\n", + "So first, let us define `Snapshot` for a future point in time. We will increase the value of the exposure following a certain growth rate, and use future tropical cyclone data:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c516c861-c5c1-475b-82e2-c867c5c08ec9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-11-03 18:28:58,942 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2040/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2040.hdf5\n", + "2025-11-03 18:28:58,967 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-11-03 18:28:58,968 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-11-03 18:28:58,970 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n" + ] + } + ], + "source": [ + "import copy\n", + "\n", + "future_year = 2040\n", + "exp_future = copy.deepcopy(exp_present)\n", + "exp_future.ref_year = future_year\n", + "n_years = exp_future.ref_year - exp_present.ref_year + 1\n", + "growth_rate = 1.02\n", + "growth = growth_rate**n_years\n", + "exp_future.gdf[\"value\"] = exp_future.gdf[\"value\"] * growth\n", + "\n", + "haz_future = client.get_hazard(\n", + " \"tropical_cyclone\",\n", + " properties={\n", + " \"country_name\": \"Haiti\",\n", + " \"climate_scenario\": \"rcp60\",\n", + " \"ref_year\": str(future_year),\n", + " \"nb_synth_tracks\": \"10\",\n", + " },\n", + ")\n", + "exp_future.assign_centroids(haz_future, distance=\"approx\")\n", + "impf_set = ImpactFuncSet(\n", + " [\n", + " ImpfTropCyclone.from_emanuel_usa(v_half=60.0),\n", + " ]\n", + ")\n", + "exp_future.gdf.rename(columns={\"impf_\": \"impf_TC\"}, inplace=True)\n", + "exp_future.gdf[\"impf_TC\"] = 1\n", + "snap2 = Snapshot(exposure=exp_future, hazard=haz_future, impfset=impf_set, date=2040)\n", + "\n", + "# Now we can define a list of two snapshots, present and future:\n", + "snapcol = [snap, snap2]" + ] + }, + { + "cell_type": "markdown", + "id": "27ca72b1-b1fa-4cd2-8f74-a69dc6eb3c9c", + "metadata": {}, + "source": [ + "Based on such a list of snapshots, we can then evaluate a risk trajectory using a `StaticRiskTrajectory` or a `InterpolatedRiskTrajectory` object." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e782ab8b", + "metadata": {}, + "outputs": [], + "source": [ + "from climada.trajectories import StaticRiskTrajectory, InterpolatedRiskTrajectory\n", + "\n", + "static_risk_traj = StaticRiskTrajectory(snapcol)\n", + "interpolated_risk_traj = InterpolatedRiskTrajectory(snapcol)" + ] + }, + { + "cell_type": "markdown", + "id": "2d7e8653-4ef9-40f5-8f8a-ef0e8b3b8a8c", + "metadata": {}, + "source": [ + "### Tidy format\n", + "\n", + "We use the \"tidy\" format to output most of the results.\n", + "\n", + "A **tidy data** format is a standardized way to structure datasets, making them easier to analyze and visualize. It's based on three main principles:\n", + "\n", + "1. **Each variable forms a column.**\n", + "2. **Each observation forms a row.**\n", + "3. **Each type of observational unit forms a table.**\n", + "\n", + "Example:\n", + "\n", + "| group | date | metric | risk |\n", + "| :---: | :---: | :---: | :---: |\n", + "| All | 2018-01-01 | aai | $1.840432 \\times 10^{8}$ |\n", + "| All | 2040-01-01 | aai | $6.946753 \\times 10^{8}$ |\n", + "| All | 2018-01-01 | rp\\_20 | $1.420589 \\times 10^{8}$ |\n", + "\n", + "In this example, every descriptive quality (variable) of the risk evaluation is placed in its own column:\n", + "\n", + "* **`group`**: The exposure subgroup for the risk evalution point.\n", + "* **`date`**: The date for the risk evalution point.\n", + "* **`metric`**: The specific risk measure (e.g., 'aai', 'rp\\_20', 'rp\\_100').\n", + "* **`unit`**: The unit of the risk evaluation.\n", + "* **`risk`**: The actual value being measured.\n", + "\n", + "Each row represents a single, complete observation. For example, the very first row is a measurement of the **'aai' metric** for **group 'All'** on **'2018-01-01'**, with the resulting **risk** value of **$1.840432 \\times 10^{8}$ USD**." + ] + }, + { + "cell_type": "markdown", + "id": "ca8951cc-4a0a-4f3d-9c21-96dd6a835810", + "metadata": {}, + "source": [ + "### Static and Interpolated trajectories" + ] + }, + { + "cell_type": "markdown", + "id": "dc76cb91", + "metadata": {}, + "source": [ + "`StaticRiskTrajectory` will compute and hold risk metrics for all the given snapshots without interpolation:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "14453563", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
groupdatemeasuremetricunitrisk
0All2018-01-01no_measureaaiUSD1.840432e+08
1All2040-01-01no_measureaaiUSD6.946753e+08
0All2018-01-01no_measurerp_20USD1.420589e+08
1All2040-01-01no_measurerp_20USD8.253342e+08
2All2018-01-01no_measurerp_50USD3.059112e+09
3All2040-01-01no_measurerp_50USD1.368563e+10
4All2018-01-01no_measurerp_100USD5.719050e+09
5All2040-01-01no_measurerp_100USD2.330623e+10
002018-01-01no_measureaaiUSD2.721881e+05
112018-01-01no_measureaaiUSD1.837711e+08
202040-01-01no_measureaaiUSD1.040877e+06
312040-01-01no_measureaaiUSD6.936344e+08
\n", + "
" + ], + "text/plain": [ + " group date measure metric unit risk\n", + "0 All 2018-01-01 no_measure aai USD 1.840432e+08\n", + "1 All 2040-01-01 no_measure aai USD 6.946753e+08\n", + "0 All 2018-01-01 no_measure rp_20 USD 1.420589e+08\n", + "1 All 2040-01-01 no_measure rp_20 USD 8.253342e+08\n", + "2 All 2018-01-01 no_measure rp_50 USD 3.059112e+09\n", + "3 All 2040-01-01 no_measure rp_50 USD 1.368563e+10\n", + "4 All 2018-01-01 no_measure rp_100 USD 5.719050e+09\n", + "5 All 2040-01-01 no_measure rp_100 USD 2.330623e+10\n", + "0 0 2018-01-01 no_measure aai USD 2.721881e+05\n", + "1 1 2018-01-01 no_measure aai USD 1.837711e+08\n", + "2 0 2040-01-01 no_measure aai USD 1.040877e+06\n", + "3 1 2040-01-01 no_measure aai USD 6.936344e+08" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "static_risk_traj.per_date_risk_metrics()" + ] + }, + { + "cell_type": "markdown", + "id": "82a7a819", + "metadata": {}, + "source": [ + " The `InterpolatedRiskTrajectory` object goes further and computes the metrics for all the dates between the different snapshots in the given collection for a given time resolution (one year by default). In this example, from the snapshot in 2018 to the one in 2040. \n", + "\n", + "Note that this can require a bit of computation and memory, especially for large regions or extended range of time with high time resolution.\n", + "Also note, that most computations are only run and stored when needed, not at instantiation.\n", + "\n", + "From this object you can access different risk metrics:\n", + "\n", + "* Average Annual Impact (aai) both for all exposure points (group == \"All\") and specific groups of exposure points (defined by a \"group_id\" in the exposure).\n", + "* Estimated impact for different return periods (20, 50 and 100 by default)\n", + "\n", + "Both as totals over the whole period:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "9c485dc4-c009-46fb-aa4a-603bc9dcf5b4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
periodgroupmeasuremetricrisk
02018 to 20400no_measureaai1.414905e+07
12018 to 20401no_measureaai9.465607e+09
22018 to 2040Allno_measureaai9.479757e+09
32018 to 2040Allno_measurerp_1001.355590e+10
42018 to 2040Allno_measurerp_204.334959e+08
52018 to 2040Allno_measurerp_507.748316e+09
\n", + "
" + ], + "text/plain": [ + " period group measure metric risk\n", + "0 2018 to 2040 0 no_measure aai 1.414905e+07\n", + "1 2018 to 2040 1 no_measure aai 9.465607e+09\n", + "2 2018 to 2040 All no_measure aai 9.479757e+09\n", + "3 2018 to 2040 All no_measure rp_100 1.355590e+10\n", + "4 2018 to 2040 All no_measure rp_20 4.334959e+08\n", + "5 2018 to 2040 All no_measure rp_50 7.748316e+09" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "interpolated_risk_traj.per_period_risk_metrics()" + ] + }, + { + "cell_type": "markdown", + "id": "af53286d-ee62-44a5-907b-84103302663d", + "metadata": {}, + "source": [ + "Or on a per-date basis:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "6b73a589-9ee4-41e8-90e0-910bfe4dd8fc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
groupdatemeasuremetricunitrisk
0All2018no_measureaaiUSD1.840432e+08
1All2019no_measureaaiUSD2.000396e+08
2All2020no_measureaaiUSD2.166844e+08
3All2021no_measureaaiUSD2.339834e+08
4All2022no_measureaaiUSD2.519424e+08
.....................
4112038no_measureaaiUSD6.328297e+08
4202039no_measureaaiUSD9.943382e+05
4312039no_measureaaiUSD6.628505e+08
4402040no_measureaaiUSD1.040877e+06
4512040no_measureaaiUSD6.936344e+08
\n", + "

138 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " group date measure metric unit risk\n", + "0 All 2018 no_measure aai USD 1.840432e+08\n", + "1 All 2019 no_measure aai USD 2.000396e+08\n", + "2 All 2020 no_measure aai USD 2.166844e+08\n", + "3 All 2021 no_measure aai USD 2.339834e+08\n", + "4 All 2022 no_measure aai USD 2.519424e+08\n", + ".. ... ... ... ... ... ...\n", + "41 1 2038 no_measure aai USD 6.328297e+08\n", + "42 0 2039 no_measure aai USD 9.943382e+05\n", + "43 1 2039 no_measure aai USD 6.628505e+08\n", + "44 0 2040 no_measure aai USD 1.040877e+06\n", + "45 1 2040 no_measure aai USD 6.936344e+08\n", + "\n", + "[138 rows x 6 columns]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "interpolated_risk_traj.per_date_risk_metrics()" + ] + }, + { + "cell_type": "markdown", + "id": "00e0a09b-9dd6-4378-81a1-cda5290f9aa4", + "metadata": {}, + "source": [ + "You can also plot the \"contribution\" or \"components\" of the change in risk (Average ) via a waterfall graph:\n", + "\n", + " - The 'base risk', i.e., the risk without change in hazard or exposure, compared to trajectory's earliest date.\n", + " - The 'exposure contribution', i.e., the additional risks due to change in exposure (only)\n", + " - The 'hazard contribution', i.e., the additional risks due to change in hazard (only)\n", + " - The 'vulnerability contribution', i.e., the additional risks due to change in vulnerability (only)\n", + " - The 'interaction contribution', i.e., the additional risks due to the interaction term" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "08c226a4-944b-4301-acfa-602adde980a5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "interpolated_risk_traj.plot_waterfall()" + ] + }, + { + "cell_type": "markdown", + "id": "7896af66-b0aa-4418-b22e-c64fd4d2cfe1", + "metadata": {}, + "source": [ + "And as well on a per date basis (keep in mind this is an interpolation, thus should be interpreted with caution):" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "cf40380a-5814-4164-a592-7ab181776b5a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(
,\n", + " )" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "interpolated_risk_traj.plot_time_waterfall()" + ] + }, + { + "cell_type": "markdown", + "id": "501e455b-e7c6-4672-9191-d5fefe38d424", + "metadata": {}, + "source": [ + "### DiscRates" + ] + }, + { + "cell_type": "markdown", + "id": "0dba0218-55fe-423d-a520-61d3cb2a991c", + "metadata": {}, + "source": [ + "To correctly assess the future risk, you may also want to apply a discount rate, in order to express future costs in net present value.\n", + "\n", + "This can easily be done providing an instance of the already existing `DiscRates` class when instantiating the trajectory." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "651e31cb-5a55-4a22-a7c3-b5f79b3a20ef", + "metadata": {}, + "outputs": [], + "source": [ + "from climada.entity import DiscRates\n", + "import numpy as np\n", + "\n", + "year_range = np.arange(exp_present.ref_year, exp_future.ref_year + 1)\n", + "annual_discount_stern = np.ones(n_years) * 0.014\n", + "discount_stern = DiscRates(year_range, annual_discount_stern)\n", + "discounted_risk_traj = InterpolatedRiskTrajectory(\n", + " snapcol, risk_disc_rates=discount_stern\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "d86bedbb-6c0a-4f7d-a63e-5012510339d3", + "metadata": {}, + "source": [ + "You can easily notice the difference with the previously defined trajectory without discount rate." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "ee3b0217-fe14-44a9-98f5-e1fc7f45e613", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = interpolated_risk_traj.aai_metrics().plot(\n", + " x=\"date\", y=\"risk\", label=\"No discount rate\"\n", + ")\n", + "discounted_risk_traj.aai_metrics().plot(\n", + " x=\"date\", y=\"risk\", label=\"Stern discount rate\", ax=ax\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "0152e9fa-55fa-4cf2-b187-59e6228af563", + "metadata": {}, + "source": [ + "# Advanced usage\n", + "\n", + "In this section we present some more advanced features and use of this module." + ] + }, + { + "cell_type": "markdown", + "id": "42c9daed-6488-488b-b01a-fd6dfc5d0274", + "metadata": {}, + "source": [ + "## Higher number of snapshots" + ] + }, + { + "cell_type": "markdown", + "id": "6db14802-fa35-4e33-91ef-7dddd4d43da7", + "metadata": {}, + "source": [ + "You can of course use the module to evaluate more that two snapshots. With the `StaticRiskTrajectory` you will get a collection of results for each snapshot.\n", + "\n", + "For the `InterpolatedRiskTrajectory` the interpolation will be done between each pair of consecutive snapshots and all results will be collected together, this is usefull if you want to explore a trajectory for which you have clear \"intermediate points\", for instance if you are evaluating the risk in an area for which you know some specific development projects will start at a certain date.\n", + "\n", + "Below is an example featuring three snapshots:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "d93eb82b-65d2-48fe-a195-6cb12f23bf47", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-11-03 15:17:54,936 - climada.entity.exposures.base - INFO - Reading /home/sjuhel/climada/data/exposures/litpop/LitPop_150arcsec_HTI/v3/LitPop_150arcsec_HTI.hdf5\n", + "2025-11-03 15:18:00,684 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020/v2/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020.hdf5\n", + "2025-11-03 15:18:00,714 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-11-03 15:18:00,718 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n", + "2025-11-03 15:18:06,229 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2040/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2040.hdf5\n", + "2025-11-03 15:18:06,255 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-11-03 15:18:06,255 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-11-03 15:18:06,257 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n", + "2025-11-03 15:18:11,586 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2060/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2060.hdf5\n", + "2025-11-03 15:18:11,615 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-11-03 15:18:11,616 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-11-03 15:18:11,619 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n", + "2025-11-03 15:18:16,770 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2080/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2080.hdf5\n", + "2025-11-03 15:18:16,799 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-11-03 15:18:16,800 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-11-03 15:18:16,802 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n" + ] + } + ], + "source": [ + "from climada.engine.impact_calc import ImpactCalc\n", + "from climada.util.api_client import Client\n", + "from climada.entity import ImpactFuncSet, ImpfTropCyclone\n", + "from climada.trajectories.snapshot import Snapshot\n", + "from climada.trajectories import InterpolatedRiskTrajectory\n", + "import copy\n", + "\n", + "client = Client()\n", + "\n", + "\n", + "future_years = [2040, 2060, 2080]\n", + "\n", + "exp_present = client.get_litpop(country=\"Haiti\")\n", + "haz_present = client.get_hazard(\n", + " \"tropical_cyclone\",\n", + " properties={\n", + " \"country_name\": \"Haiti\",\n", + " \"climate_scenario\": \"historical\",\n", + " \"nb_synth_tracks\": \"10\",\n", + " },\n", + ")\n", + "exp_present.assign_centroids(haz_present, distance=\"approx\")\n", + "\n", + "impf_set = ImpactFuncSet([ImpfTropCyclone.from_emanuel_usa()])\n", + "exp_present.gdf.rename(columns={\"impf_\": \"impf_TC\"}, inplace=True)\n", + "exp_present.gdf[\"impf_TC\"] = 1\n", + "exp_present.gdf[\"group_id\"] = (exp_present.gdf[\"value\"] > 500000) * 1\n", + "\n", + "snapcol = [\n", + " Snapshot(exposure=exp_present, hazard=haz_present, impfset=impf_set, date=2018)\n", + "]\n", + "\n", + "for year in future_years:\n", + " exp_future = copy.deepcopy(exp_present)\n", + " exp_future.ref_year = year\n", + " n_years = exp_future.ref_year - exp_present.ref_year + 1\n", + " growth_rate = 1.02\n", + " growth = growth_rate**n_years\n", + " exp_future.gdf[\"value\"] = exp_future.gdf[\"value\"] * growth\n", + "\n", + " haz_future = client.get_hazard(\n", + " \"tropical_cyclone\",\n", + " properties={\n", + " \"country_name\": \"Haiti\",\n", + " \"climate_scenario\": \"rcp60\",\n", + " \"ref_year\": str(year),\n", + " \"nb_synth_tracks\": \"10\",\n", + " },\n", + " )\n", + " exp_future.assign_centroids(haz_future, distance=\"approx\")\n", + " impf_set = ImpactFuncSet(\n", + " [\n", + " ImpfTropCyclone.from_emanuel_usa(v_half=60.0),\n", + " ]\n", + " )\n", + " exp_future.gdf.rename(columns={\"impf_\": \"impf_TC\"}, inplace=True)\n", + " exp_future.gdf[\"impf_TC\"] = 1\n", + " snapcol.append(\n", + " Snapshot(exposure=exp_future, hazard=haz_future, impfset=impf_set, date=year)\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "b85d5b95-4316-481a-9eed-86977647b791", + "metadata": {}, + "outputs": [], + "source": [ + "risk_traj = InterpolatedRiskTrajectory(snapcol)" + ] + }, + { + "cell_type": "markdown", + "id": "537a9dd8-96e9-4ef4-a137-358990c658d2", + "metadata": {}, + "source": [ + "By default the \"static\" waterfall plot shows the evolution of risk between the earliest and latest snapshot." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "1c5aeb4b-6320-479d-82a6-9b2c3901868e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "risk_traj.plot_waterfall()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "16faf81c-8760-4c02-a575-ae033bcb637d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(
,\n", + " )" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "risk_traj.plot_time_waterfall()" + ] + }, + { + "cell_type": "markdown", + "id": "fed22016-ab8f-4761-892a-c893d18357b7", + "metadata": {}, + "source": [ + "## Non-default return periods" + ] + }, + { + "cell_type": "markdown", + "id": "fcaed625-82a8-4cc4-82de-e36b67601dcb", + "metadata": {}, + "source": [ + "You can easily change the default return periods computed, either at initialisation time, or via the property `return_periods`.\n", + "Note that estimates of impacts for specific return periods are highly dependant on the quality of the data you provided." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "0ade93f9-c43a-4e8a-8225-9343bbbb3615", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
groupdatemeasuremetricunitrisk
0All2018no_measurerp_10USD1.489354e+07
1All2019no_measurerp_10USD1.678277e+07
2All2020no_measurerp_10USD1.879207e+07
3All2021no_measurerp_10USD2.092467e+07
4All2022no_measurerp_10USD2.318382e+07
.....................
87All2036no_measurerp_30USD2.607961e+09
88All2037no_measurerp_30USD2.766248e+09
89All2038no_measurerp_30USD2.929978e+09
90All2039no_measurerp_30USD3.099231e+09
91All2040no_measurerp_30USD3.274085e+09
\n", + "

92 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " group date measure metric unit risk\n", + "0 All 2018 no_measure rp_10 USD 1.489354e+07\n", + "1 All 2019 no_measure rp_10 USD 1.678277e+07\n", + "2 All 2020 no_measure rp_10 USD 1.879207e+07\n", + "3 All 2021 no_measure rp_10 USD 2.092467e+07\n", + "4 All 2022 no_measure rp_10 USD 2.318382e+07\n", + ".. ... ... ... ... ... ...\n", + "87 All 2036 no_measure rp_30 USD 2.607961e+09\n", + "88 All 2037 no_measure rp_30 USD 2.766248e+09\n", + "89 All 2038 no_measure rp_30 USD 2.929978e+09\n", + "90 All 2039 no_measure rp_30 USD 3.099231e+09\n", + "91 All 2040 no_measure rp_30 USD 3.274085e+09\n", + "\n", + "[92 rows x 6 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
groupdatemeasuremetricunitrisk
0All2018no_measurerp_150USD9.900032e+09
1All2019no_measurerp_150USD1.072504e+10
2All2020no_measurerp_150USD1.158105e+10
3All2021no_measurerp_150USD1.246823e+10
4All2022no_measurerp_150USD1.338673e+10
.....................
64All2036no_measurerp_500USD4.618632e+10
65All2037no_measurerp_500USD4.801525e+10
66All2038no_measurerp_500USD4.987944e+10
67All2039no_measurerp_500USD5.177889e+10
68All2040no_measurerp_500USD5.371361e+10
\n", + "

69 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " group date measure metric unit risk\n", + "0 All 2018 no_measure rp_150 USD 9.900032e+09\n", + "1 All 2019 no_measure rp_150 USD 1.072504e+10\n", + "2 All 2020 no_measure rp_150 USD 1.158105e+10\n", + "3 All 2021 no_measure rp_150 USD 1.246823e+10\n", + "4 All 2022 no_measure rp_150 USD 1.338673e+10\n", + ".. ... ... ... ... ... ...\n", + "64 All 2036 no_measure rp_500 USD 4.618632e+10\n", + "65 All 2037 no_measure rp_500 USD 4.801525e+10\n", + "66 All 2038 no_measure rp_500 USD 4.987944e+10\n", + "67 All 2039 no_measure rp_500 USD 5.177889e+10\n", + "68 All 2040 no_measure rp_500 USD 5.371361e+10\n", + "\n", + "[69 rows x 6 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "snapcol = [snap, snap2]\n", + "risk_traj = InterpolatedRiskTrajectory(snapcol, return_periods=[10, 15, 20, 30])\n", + "display(risk_traj.return_periods_metrics())\n", + "\n", + "risk_traj.return_periods = [150, 250, 500]\n", + "display(risk_traj.return_periods_metrics())" + ] + }, + { + "cell_type": "markdown", + "id": "39059ec5-9125-4cfc-b8c6-e6327d8b98cc", + "metadata": {}, + "source": [ + "## Non-yearly date index" + ] + }, + { + "cell_type": "markdown", + "id": "4f8f83d6-a45d-4d3b-b25d-d3294e6e1955", + "metadata": {}, + "source": [ + "You can use any valid pandas [frequency string for periods](https://pandas.pydata.org/docs/user_guide/timeseries.html#period-aliases) for the time resolution,\n", + "for instance \"5Y\" for every five years. This reduces the resolution of the interpolation, which can reduce the required computations at the cost of \"precision\".\n", + "Conversely you can also increase the time resolution to a monthly base for instance.\n", + "\n", + "Same as for the return periods, you can change that at initialisation or afterward via the property.\n", + "\n", + "Keep in mind that risk metrics are still computed the same way so you would still get \"Average Annual Impacts\"\n", + "values for every months and not average monthly ones !" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "128fac77-e077-4241-a003-a60c4afcad74", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
groupdatemeasuremetricunitrisk
0All2018no_measureaaiUSD1.840432e+08
1All2023no_measureaaiUSD2.801311e+08
2All2028no_measureaaiUSD3.966228e+08
3All2033no_measureaaiUSD5.344827e+08
4All2038no_measureaaiUSD6.946753e+08
\n", + "
" + ], + "text/plain": [ + " group date measure metric unit risk\n", + "0 All 2018 no_measure aai USD 1.840432e+08\n", + "1 All 2023 no_measure aai USD 2.801311e+08\n", + "2 All 2028 no_measure aai USD 3.966228e+08\n", + "3 All 2033 no_measure aai USD 5.344827e+08\n", + "4 All 2038 no_measure aai USD 6.946753e+08" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "snapcol = [snap, snap2]\n", + "risk_traj = InterpolatedRiskTrajectory(snapcol, time_resolution=\"5Y\")\n", + "risk_traj.per_date_risk_metrics().head()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "c1e66906-63e3-4a29-8a0b-0e706e6a2a09", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
groupdatemeasuremetricunitrisk
0All2018-01no_measureaaiUSD1.840432e+08
1All2018-02no_measureaaiUSD1.853516e+08
2All2018-03no_measureaaiUSD1.866645e+08
3All2018-04no_measureaaiUSD1.879819e+08
4All2018-05no_measureaaiUSD1.893037e+08
\n", + "
" + ], + "text/plain": [ + " group date measure metric unit risk\n", + "0 All 2018-01 no_measure aai USD 1.840432e+08\n", + "1 All 2018-02 no_measure aai USD 1.853516e+08\n", + "2 All 2018-03 no_measure aai USD 1.866645e+08\n", + "3 All 2018-04 no_measure aai USD 1.879819e+08\n", + "4 All 2018-05 no_measure aai USD 1.893037e+08" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# snapcol = [snap, snap2]\n", + "\n", + "# Here we use \"1MS\" to get a monthly basis\n", + "risk_traj.time_resolution = \"1M\"\n", + "\n", + "# We would have to divide results by 12 to get \"average monthly impacts\"\n", + "risk_traj.per_date_risk_metrics().head()" + ] + }, + { + "cell_type": "markdown", + "id": "f5d6b725-41ee-495b-bc72-5806db4cfdba", + "metadata": {}, + "source": [ + "## Non-linear interpolation" + ] + }, + { + "cell_type": "markdown", + "id": "a8065729-5d0b-4250-8324-2ce82cb0d644", + "metadata": {}, + "source": [ + "The module allows you to define your own interpolation strategy. Thus you can decide how to interpolate along each dimension of risk (Exposure, Hazard and Vulnerability).\n", + "This is done via `InterpolationStrategy` objects, which simply require three functions stating how to interpolate along each dimensions.\n", + "\n", + "For convenience the module provides an `AllLinearStrategy` (the risk is linearly interpolated along all dimensions) and a `ExponentialExposureStrategy` (uses exponential interpolation along exposure, and linear for the two other dimensions).\n", + "\n", + "This can prove helpfull if you are interpolating between two distant dates with an exponential growth factor for the exposure value. On the example below, we show the difference in risk estimates using an the two different interpolation strategy for the exposure dimension:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "c97e768e-bd4c-47d7-bace-96645f8b3bc4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-11-03 15:07:00,438 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2080/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2080.hdf5\n", + "2025-11-03 15:07:00,465 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-11-03 15:07:00,466 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-11-03 15:07:00,469 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Comparison of average annual impact estimate for different interpolation approaches')" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from climada.trajectories import StaticRiskTrajectory, InterpolatedRiskTrajectory\n", + "from climada.trajectories import ExponentialExposureStrategy\n", + "import seaborn as sns\n", + "\n", + "future_year = 2100\n", + "exp_future = copy.deepcopy(exp_present)\n", + "exp_future.ref_year = future_year\n", + "n_years = exp_future.ref_year - exp_present.ref_year + 1\n", + "growth_rate = 1.04\n", + "growth = growth_rate**n_years\n", + "exp_future.gdf[\"value\"] = exp_future.gdf[\"value\"] * growth\n", + "\n", + "haz_future = client.get_hazard(\n", + " \"tropical_cyclone\",\n", + " properties={\n", + " \"country_name\": \"Haiti\",\n", + " \"climate_scenario\": \"rcp60\",\n", + " \"ref_year\": \"2080\",\n", + " \"nb_synth_tracks\": \"10\",\n", + " },\n", + ")\n", + "exp_future.assign_centroids(haz_future, distance=\"approx\")\n", + "impf_set = ImpactFuncSet(\n", + " [\n", + " ImpfTropCyclone.from_emanuel_usa(v_half=60.0),\n", + " ]\n", + ")\n", + "exp_future.gdf.rename(columns={\"impf_\": \"impf_TC\"}, inplace=True)\n", + "exp_future.gdf[\"impf_TC\"] = 1\n", + "\n", + "snap2 = Snapshot(exposure=exp_future, hazard=haz_future, impfset=impf_set, date=2100)\n", + "snapcol = [snap, snap2]\n", + "\n", + "exp_interp = ExponentialExposureStrategy()\n", + "risk_traj = InterpolatedRiskTrajectory(snapcol)\n", + "risk_traj_exp = InterpolatedRiskTrajectory(snapcol, interpolation_strategy=exp_interp)\n", + "ax = risk_traj.aai_metrics().plot(\n", + " x=\"date\", y=\"risk\", label=\"Linear interpolation for exposure\"\n", + ")\n", + "risk_traj_exp.aai_metrics().plot(\n", + " x=\"date\", y=\"risk\", label=\"Exponential interpolation for exposure\", ax=ax\n", + ")\n", + "\n", + "ax.set_title(\n", + " \"Comparison of average annual impact estimate for different interpolation approaches\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "4a5991b8-659e-4b0a-81cc-bc0d085ff1e7", + "metadata": {}, + "source": [ + "## Spatial mapping" + ] + }, + { + "cell_type": "markdown", + "id": "d47bcc7e-defe-4058-b7a3-4dafd4374f35", + "metadata": {}, + "source": [ + "You can access a DataFrame with the estimated annual impacts at each coordinates through \"eai_metrics\" which can easily be merged to the exposure GeoDataFrame:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "431d26f1-c19f-4654-814b-20e8a243848e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
groupdatemeasuremetriccoord_idunitrisk
012018no_measureeai0USD3515.056865
112019no_measureeai0USD4668.296006
212020no_measureeai0USD5861.455974
312021no_measureeai0USD7094.788880
412022no_measureeai0USD8368.546832
........................
11030212096no_measureeai1328USD100317.858444
11030312097no_measureeai1328USD102579.412184
11030412098no_measureeai1328USD104869.907377
11030512099no_measureeai1328USD107189.486993
11030612100no_measureeai1328USD109538.294005
\n", + "

110307 rows × 7 columns

\n", + "
" + ], + "text/plain": [ + " group date measure metric coord_id unit risk\n", + "0 1 2018 no_measure eai 0 USD 3515.056865\n", + "1 1 2019 no_measure eai 0 USD 4668.296006\n", + "2 1 2020 no_measure eai 0 USD 5861.455974\n", + "3 1 2021 no_measure eai 0 USD 7094.788880\n", + "4 1 2022 no_measure eai 0 USD 8368.546832\n", + "... ... ... ... ... ... ... ...\n", + "110302 1 2096 no_measure eai 1328 USD 100317.858444\n", + "110303 1 2097 no_measure eai 1328 USD 102579.412184\n", + "110304 1 2098 no_measure eai 1328 USD 104869.907377\n", + "110305 1 2099 no_measure eai 1328 USD 107189.486993\n", + "110306 1 2100 no_measure eai 1328 USD 109538.294005\n", + "\n", + "[110307 rows x 7 columns]" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = risk_traj.eai_metrics()\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "61abb90f-42f8-446c-aa27-8a5b5eaa3729", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "gdf = snap.exposure.gdf\n", + "gdf[\"coord_id\"] = gdf.index\n", + "gdf = gdf.merge(df, on=\"coord_id\")\n", + "\n", + "fig, axs = plt.subplots(1, 3, figsize=(20, 4))\n", + "\n", + "gdf.loc[gdf[\"date\"] == \"2018-01-01\"].plot(\n", + " column=\"risk\",\n", + " legend=True,\n", + " vmin=gdf[\"risk\"].min(),\n", + " vmax=gdf[\"risk\"].max(),\n", + " ax=axs[0],\n", + ")\n", + "gdf.loc[gdf[\"date\"] == \"2050-01-01\"].plot(\n", + " column=\"risk\",\n", + " legend=True,\n", + " vmin=gdf[\"risk\"].min(),\n", + " vmax=gdf[\"risk\"].max(),\n", + " ax=axs[1],\n", + ")\n", + "gdf.loc[gdf[\"date\"] == \"2100-01-01\"].plot(\n", + " column=\"risk\",\n", + " legend=True,\n", + " vmin=gdf[\"risk\"].min(),\n", + " vmax=gdf[\"risk\"].max(),\n", + " ax=axs[2],\n", + ")\n", + "\n", + "axs[0].set_title(\"Average Annual Risk in 2018\")\n", + "axs[1].set_title(\"Average Annual Risk in 2050\")\n", + "axs[2].set_title(\"Average Annual Risk in 2100\")\n", + "\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "cb_refactoring", + "language": "python", + "name": "cb_refactoring" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From b8b4881f3ab37b573b092ad9d552a0af93964b7d Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 18 Dec 2025 15:16:11 +0100 Subject: [PATCH 20/61] Updates from feature/risk_trajectory --- climada/trajectories/calc_risk_metrics.py | 891 +++++++++++++++++++++- 1 file changed, 890 insertions(+), 1 deletion(-) diff --git a/climada/trajectories/calc_risk_metrics.py b/climada/trajectories/calc_risk_metrics.py index e7ba88c143..2ab97ab61b 100644 --- a/climada/trajectories/calc_risk_metrics.py +++ b/climada/trajectories/calc_risk_metrics.py @@ -26,17 +26,28 @@ """ +import datetime +import itertools import logging import numpy as np import pandas as pd +from scipy.sparse import csr_matrix -from climada.engine.impact import Impact +from climada.engine.impact import Impact, ImpactFreqCurve +from climada.engine.impact_calc import ImpactCalc from climada.entity.measures.base import Measure from climada.trajectories.constants import ( AAI_METRIC_NAME, + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + CONTRIBUTION_TOTAL_RISK_NAME, + CONTRIBUTION_VULNERABILITY_NAME, COORD_ID_COL_NAME, DATE_COL_NAME, + DEFAULT_PERIOD_INDEX_NAME, EAI_METRIC_NAME, GROUP_COL_NAME, GROUP_ID_COL_NAME, @@ -48,12 +59,21 @@ UNIT_COL_NAME, ) from climada.trajectories.impact_calc_strat import ImpactComputationStrategy +from climada.trajectories.interpolation import ( + InterpolationStrategyBase, + linear_interp_arrays, +) from climada.trajectories.snapshot import Snapshot LOGGER = logging.getLogger(__name__) __all__ = [ "CalcRiskMetricsPoints", + "CalcRiskMetricsPeriod", + "calc_per_date_aais", + "calc_per_date_eais", + "calc_per_date_rps", + "calc_freq_curve", ] _CACHE_SETTINGS = {"ENABLE_LAZY_CACHE": False} @@ -321,3 +341,872 @@ def apply_measure(self, measure: Measure) -> "CalcRiskMetricsPoints": risk_period.measure = measure return risk_period + + +class CalcRiskMetricsPeriod: + """This class handles the computation of impacts for a risk period. + + This object handles the interpolations and computations of risk metrics in + between two given snapshots, along a DateTimeIndex build from either a + `time_resolution` (which must be a valid "freq" string to build a DateTimeIndex) + and defaults to "Y" (start of the year) or `time_points` integer argument, in which case + the DateTimeIndex will have that many periods. + + Note that most attribute like members are properties with their own docstring. + + Attributes + ---------- + + date_idx: pd.PeriodIndex + The date index for the different interpolated points between the two snapshots + interpolation_strategy: InterpolationStrategy, optional + The approach used to interpolate impact matrices in between the two snapshots, linear by default. + impact_computation_strategy: ImpactComputationStrategy, optional + The method used to calculate the impact from the (Haz,Exp,Vul) of the two snapshots. + Defaults to ImpactCalc + measure: Measure, optional + The measure to apply to both snapshots. Defaults to None. + + Notes + ----- + + This class is intended for internal computation. + """ + + def __init__( + self, + snapshot0: Snapshot, + snapshot1: Snapshot, + time_resolution: str, + interpolation_strategy: InterpolationStrategyBase, + impact_computation_strategy: ImpactComputationStrategy, + ): + """Initialize a new `CalcRiskMetricsPeriod` + + This initializes and instantiate a new `CalcRiskMetricsPeriod` object. + No computation is done at initialisation and only done "just in time". + + Parameters + ---------- + snapshot0 : Snapshot + The `Snapshot` at the start of the risk period. + snapshot1 : Snapshot + The `Snapshot` at the end of the risk period. + time_resolution : str, optional + One of pandas date offset strings or corresponding objects. See :func:`pandas.period_range`. + time_points : int, optional + Number of periods to generate for the PeriodIndex. + interpolation_strategy: InterpolationStrategy, optional + The approach used to interpolate impact matrices in between the two snapshots, linear by default. + impact_computation_strategy: ImpactComputationStrategy, optional + The method used to calculate the impact from the (Haz,Exp,Vul) of the two snapshots. + Defaults to ImpactCalc + + """ + + LOGGER.debug("Instantiating new CalcRiskPeriod.") + self._snapshot0 = snapshot0 + self._snapshot1 = snapshot1 + self.date_idx = self._set_date_idx( + date1=snapshot0.date, + date2=snapshot1.date, + freq=time_resolution, + name=DEFAULT_PERIOD_INDEX_NAME, + ) + self.interpolation_strategy = interpolation_strategy + self.impact_computation_strategy = impact_computation_strategy + self.measure = None # Only possible to set with apply_measure to make sure snapshots are consistent + + self._group_id_E0 = ( + np.array(self.snapshot_start.exposure.gdf[GROUP_ID_COL_NAME].values) + if GROUP_ID_COL_NAME in self.snapshot_start.exposure.gdf.columns + else np.array([]) + ) + self._group_id_E1 = ( + np.array(self.snapshot_end.exposure.gdf[GROUP_ID_COL_NAME].values) + if GROUP_ID_COL_NAME in self.snapshot_end.exposure.gdf.columns + else np.array([]) + ) + self._groups_id = np.unique( + np.concatenate([self._group_id_E0, self._group_id_E1]) + ) + + def _reset_impact_data(self): + """Util method that resets computed data, for instance when changing the time resolution.""" + for fut in list(itertools.product([0, 1], repeat=3)): + setattr(self, f"_E{fut[0]}H{fut[1]}V{fut[2]}", None) + + for fut in list(itertools.product([0, 1], repeat=2)): + setattr(self, f"_imp_mats_H{fut[0]}V{fut[1]}", None) + setattr(self, f"_per_date_eai_H{fut[0]}V{fut[1]}", None) + setattr(self, f"_per_date_aai_H{fut[0]}V{fut[1]}", None) + + self._eai_gdf = None + self._per_date_eai = None + self._per_date_aai = None + self._per_date_return_periods_H0, self._per_date_return_periods_H1 = None, None + + @staticmethod + def _set_date_idx( + date1: str | pd.Timestamp | datetime.date, + date2: str | pd.Timestamp | datetime.date, + freq: str | None = None, + name: str | None = None, + ) -> pd.PeriodIndex: + """Generate a date range index based on the provided parameters. + + Parameters + ---------- + date1 : str or pd.Timestamp or datetime.date + The start date of the period range. + date2 : str or pd.Timestamp or datetime.date + The end date of the period range. + freq : str, optional + Frequency string for the period range. + See `here `_. + name : str, optional + Name of the resulting period range index. + + Returns + ------- + pd.PeriodIndex + A PeriodIndex representing the date range. + + Raises + ------ + ValueError + If the number of periods and frequency given to period_range are inconsistent. + """ + ret = pd.period_range( + date1, + date2, + freq=freq, # type: ignore + name=name, + ) + return ret + + @property + def snapshot_start(self) -> Snapshot: + """The `Snapshot` at the start of the risk period.""" + return self._snapshot0 + + @property + def snapshot_end(self) -> Snapshot: + """The `Snapshot` at the end of the risk period.""" + return self._snapshot1 + + @property + def date_idx(self) -> pd.PeriodIndex: + """The pandas PeriodIndex representing the time dimension of the risk period.""" + return self._date_idx + + @date_idx.setter + def date_idx(self, value, /): + if not isinstance(value, pd.PeriodIndex): + raise ValueError("Not a PeriodIndex") + + self._date_idx = value # Avoids weird hourly data + self._time_points = len(self.date_idx) + self._time_resolution = self.date_idx.freq + self._reset_impact_data() + + @property + def time_points(self) -> int: + """The numbers of different time points (periods) in the risk period.""" + return self._time_points + + @property + def time_resolution(self) -> str: + """The time resolution of the risk periods, expressed as a pandas period frequency string.""" + return self._time_resolution # type: ignore + + @time_resolution.setter + def time_resolution(self, value, /): + self.date_idx = pd.period_range( + self.snapshot_start.date, + self.snapshot_end.date, + freq=value, + name=DEFAULT_PERIOD_INDEX_NAME, + ) + + @property + def interpolation_strategy(self) -> InterpolationStrategyBase: + """The approach used to interpolate impact matrices in between the two snapshots.""" + return self._interpolation_strategy + + @interpolation_strategy.setter + def interpolation_strategy(self, value, /): + if not isinstance(value, InterpolationStrategyBase): + raise ValueError("Not an interpolation strategy") + + self._interpolation_strategy = value + self._reset_impact_data() + + @property + def impact_computation_strategy(self) -> ImpactComputationStrategy: + """The method used to calculate the impact from the (Haz,Exp,Vul) of the two snapshots.""" + return self._impact_computation_strategy + + @impact_computation_strategy.setter + def impact_computation_strategy(self, value, /): + if not isinstance(value, ImpactComputationStrategy): + raise ValueError("Not an impact computation strategy") + + self._impact_computation_strategy = value + self._reset_impact_data() + + ##### Impact objects cube / Risk Cube ##### + + @lazy_property + def E0H0V0(self) -> Impact: + """Impact object corresponding to starting exposure, starting hazard and starting vulnerability.""" + return self.impact_computation_strategy.compute_impacts( + self.snapshot_start.exposure, + self.snapshot_start.hazard, + self.snapshot_start.impfset, + ) + + @lazy_property + def E1H0V0(self) -> Impact: + """Impact object corresponding to future exposure, starting hazard and starting vulnerability.""" + return self.impact_computation_strategy.compute_impacts( + self.snapshot_end.exposure, + self.snapshot_start.hazard, + self.snapshot_start.impfset, + ) + + @lazy_property + def E0H1V0(self) -> Impact: + """Impact object corresponding to starting exposure, future hazard and starting vulnerability.""" + return self.impact_computation_strategy.compute_impacts( + self.snapshot_start.exposure, + self.snapshot_end.hazard, + self.snapshot_start.impfset, + ) + + @lazy_property + def E1H1V0(self) -> Impact: + """Impact object corresponding to future exposure, future hazard and starting vulnerability.""" + return self.impact_computation_strategy.compute_impacts( + self.snapshot_end.exposure, + self.snapshot_end.hazard, + self.snapshot_start.impfset, + ) + + @lazy_property + def E0H0V1(self) -> Impact: + """Impact object corresponding to starting exposure, starting hazard and future vulnerability.""" + return self.impact_computation_strategy.compute_impacts( + self.snapshot_start.exposure, + self.snapshot_start.hazard, + self.snapshot_end.impfset, + ) + + @lazy_property + def E1H0V1(self) -> Impact: + """Impact object corresponding to future exposure, starting hazard and future vulnerability.""" + return self.impact_computation_strategy.compute_impacts( + self.snapshot_end.exposure, + self.snapshot_start.hazard, + self.snapshot_end.impfset, + ) + + @lazy_property + def E0H1V1(self) -> Impact: + """Impact object corresponding to starting exposure, future hazard and future vulnerability.""" + return self.impact_computation_strategy.compute_impacts( + self.snapshot_start.exposure, + self.snapshot_end.hazard, + self.snapshot_end.impfset, + ) + + @lazy_property + def E1H1V1(self) -> Impact: + """Impact object corresponding to future exposure, future hazard and future vulnerability.""" + return self.impact_computation_strategy.compute_impacts( + self.snapshot_end.exposure, + self.snapshot_end.hazard, + self.snapshot_end.impfset, + ) + + ############################### + + ### Impact Matrices arrays #### + + def _interp_mats(self, start_attr, end_attr) -> list: + """Helper to reduce repetition in impact matrix interpolation.""" + start = getattr(self, start_attr).imp_mat + end = getattr(self, end_attr).imp_mat + return self.interpolation_strategy.interp_over_exposure_dim( + start, end, self.time_points + ) + + @property + def imp_mats_H0V0(self) -> list: + """List of `time_points` impact matrices with changing exposure, starting hazard and starting vulnerability.""" + return self._interp_mats("E0H0V0", "E1H0V0") + + @property + def imp_mats_H1V0(self) -> list: + """List of `time_points` impact matrices with changing exposure, future hazard and starting vulnerability.""" + return self._interp_mats("E0H1V0", "E1H1V0") + + @property + def imp_mats_H0V1(self) -> list: + """List of `time_points` impact matrices with changing exposure, starting hazard and future vulnerability.""" + return self._interp_mats("E0H0V1", "E1H0V1") + + @property + def imp_mats_H1V1(self) -> list: + """List of `time_points` impact matrices with changing exposure, future hazard and future vulnerability.""" + return self._interp_mats("E0H1V1", "E1H1V1") + + @property + def imp_mats_E0H0V0(self) -> list: + """List of `time_points` impact matrices with base exposure, base hazard and base vulnerability.""" + return self._interp_mats("E0H0V0", "E0H0V0") + + @property + def imp_mats_E0H1V0(self) -> list: + """List of `time_points` impact matrices with base exposure, future hazard and base vulnerability.""" + return self._interp_mats("E0H1V0", "E0H1V0") + + @property + def imp_mats_E0H0V1(self) -> list: + """List of `time_points` impact matrices with base exposure, base hazard and base vulnerability.""" + return self._interp_mats("E0H0V1", "E0H0V1") + + ############################### + + ########## Core EAI ########### + + @property + def per_date_eai_H0V0(self) -> np.ndarray: + """Expected annual impacts for changing exposure, starting hazard and starting vulnerability.""" + return calc_per_date_eais( + self.imp_mats_H0V0, self.snapshot_start.hazard.frequency + ) + + @property + def per_date_eai_H1V0(self) -> np.ndarray: + """Expected annual impacts for changing exposure, future hazard and starting vulnerability.""" + return calc_per_date_eais( + self.imp_mats_H1V0, self.snapshot_end.hazard.frequency + ) + + @property + def per_date_eai_H0V1(self) -> np.ndarray: + """Expected annual impacts for changing exposure, starting hazard and future vulnerability.""" + return calc_per_date_eais( + self.imp_mats_H0V1, self.snapshot_start.hazard.frequency + ) + + @property + def per_date_eai_H1V1(self) -> np.ndarray: + """Expected annual impacts for changing exposure, future hazard and future vulnerability.""" + return calc_per_date_eais( + self.imp_mats_H1V1, self.snapshot_end.hazard.frequency + ) + + @property + def per_date_eai_E0H0V0(self) -> np.ndarray: + """Expected annual impacts for base exposure, base hazard and base vulnerability.""" + return calc_per_date_eais( + self.imp_mats_E0H0V0, self.snapshot_start.hazard.frequency + ) + + @property + def per_date_eai_E0H1V0(self) -> np.ndarray: + """Expected annual impacts for base exposure, future hazard and base vulnerability.""" + return calc_per_date_eais( + self.imp_mats_E0H1V0, self.snapshot_end.hazard.frequency + ) + + @property + def per_date_eai_E0H0V1(self) -> np.ndarray: + """Expected annual impacts for base exposure, future hazard and base vulnerability.""" + return calc_per_date_eais( + self.imp_mats_E0H0V1, self.snapshot_start.hazard.frequency + ) + + ################################## + + ######### Core AAIs ########## + + @property + def per_date_aai_H0V0(self) -> np.ndarray: + """Average annual impacts for changing exposure, starting hazard and starting vulnerability.""" + return calc_per_date_aais(self.per_date_eai_H0V0) + + @property + def per_date_aai_H1V0(self) -> np.ndarray: + """Average annual impacts for changing exposure, future hazard and starting vulnerability.""" + return calc_per_date_aais(self.per_date_eai_H1V0) + + @property + def per_date_aai_H0V1(self) -> np.ndarray: + """Average annual impacts for changing exposure, starting hazard and future vulnerability.""" + return calc_per_date_aais(self.per_date_eai_H0V1) + + @property + def per_date_aai_H1V1(self) -> np.ndarray: + """Average annual impacts for changing exposure, future hazard and future vulnerability.""" + return calc_per_date_aais(self.per_date_eai_H1V1) + + @property + def per_date_aai_E0H0V0(self) -> np.ndarray: + """Average annual impacts for base exposure, base hazard and base vulnerability.""" + return calc_per_date_aais(self.per_date_eai_E0H0V0) + + @property + def per_date_aai_E0H1V0(self) -> np.ndarray: + """Average annual impacts for base exposure, base hazard and base vulnerability.""" + return calc_per_date_aais(self.per_date_eai_E0H1V0) + + @property + def per_date_aai_E0H0V1(self) -> np.ndarray: + """Average annual impacts for base exposure, base hazard and base vulnerability.""" + return calc_per_date_aais(self.per_date_eai_E0H0V1) + + ################################# + + ######### Core RPs ######### + + def per_date_return_periods_H0V0(self, return_periods: list[int]) -> np.ndarray: + """Estimated impacts per dates for given return periods, with changing exposure, starting hazard and starting vulnerability.""" + return calc_per_date_rps( + self.imp_mats_H0V0, + self.snapshot_start.hazard.frequency, + self.date_idx.freqstr[0], + return_periods, + ) + + def per_date_return_periods_H1V0(self, return_periods: list[int]) -> np.ndarray: + """Estimated impacts per dates for given return periods, with changing exposure, future hazard and starting vulnerability.""" + return calc_per_date_rps( + self.imp_mats_H1V0, + self.snapshot_end.hazard.frequency, + self.date_idx.freqstr[0], + return_periods, + ) + + def per_date_return_periods_H0V1(self, return_periods: list[int]) -> np.ndarray: + """Estimated impacts per dates for given return periods, with changing exposure, starting hazard and future vulnerability.""" + return calc_per_date_rps( + self.imp_mats_H0V1, + self.snapshot_start.hazard.frequency, + self.date_idx.freqstr[0], + return_periods, + ) + + def per_date_return_periods_H1V1(self, return_periods: list[int]) -> np.ndarray: + """Estimated impacts per dates for given return periods, with changing exposure, future hazard and future vulnerability.""" + return calc_per_date_rps( + self.imp_mats_H1V1, + self.snapshot_end.hazard.frequency, + self.date_idx.freqstr[0], + return_periods, + ) + + ################################## + + ##### Interpolation of metrics ##### + + def calc_eai(self) -> np.ndarray: + """Compute the EAIs at each date of the risk period (including changes in exposure, hazard and vulnerability).""" + per_date_eai_H0V0, per_date_eai_H1V0, per_date_eai_H0V1, per_date_eai_H1V1 = ( + self.per_date_eai_H0V0, + self.per_date_eai_H1V0, + self.per_date_eai_H0V1, + self.per_date_eai_H1V1, + ) + per_date_eai_V0 = self.interpolation_strategy.interp_over_hazard_dim( + per_date_eai_H0V0, per_date_eai_H1V0 + ) + per_date_eai_V1 = self.interpolation_strategy.interp_over_hazard_dim( + per_date_eai_H0V1, per_date_eai_H1V1 + ) + per_date_eai = self.interpolation_strategy.interp_over_vulnerability_dim( + per_date_eai_V0, per_date_eai_V1 + ) + return per_date_eai + + ### Fully interpolated metrics ### + + @lazy_property + def per_date_eai(self) -> np.ndarray: + """Expected annual impacts per date with changing exposure, changing hazard and changing vulnerability""" + return self.calc_eai() + + @lazy_property + def per_date_aai(self) -> np.ndarray: + """Average annual impacts per date with changing exposure, changing hazard and changing vulnerability.""" + return calc_per_date_aais(self.per_date_eai) + + @lazy_property + def eai_gdf(self) -> pd.DataFrame: + """Convenience function returning a DataFrame (with both datetime and coordinates ids) from `per_date_eai`. + + This dataframe can easily be merged with one of the snapshot exposure geodataframe. + + Notes + ----- + + The DataFrame from the starting snapshot is used as a basis (notably for `value` and `group_id`). + + """ + return self.calc_eai_gdf() + + #################################### + + ### Metrics from impact matrices ### + + # These methods might go in a utils file instead, to be reused + # for a no interpolation case (and maybe the timeseries?) + + #################################### + + def calc_eai_gdf(self) -> pd.DataFrame: + """Merge the per date EAIs of the risk period with the GeoDataframe of the exposure of the starting snapshot.""" + df = pd.DataFrame(self.per_date_eai, index=self.date_idx) + df = df.reset_index().melt( + id_vars=DEFAULT_PERIOD_INDEX_NAME, + var_name=COORD_ID_COL_NAME, + value_name=RISK_COL_NAME, + ) + if GROUP_ID_COL_NAME in self.snapshot_start.exposure.gdf: + eai_gdf = self.snapshot_start.exposure.gdf[[GROUP_ID_COL_NAME]] + eai_gdf[COORD_ID_COL_NAME] = eai_gdf.index + eai_gdf = eai_gdf.merge(df, on=COORD_ID_COL_NAME) + eai_gdf = eai_gdf.rename(columns={GROUP_ID_COL_NAME: GROUP_COL_NAME}) + else: + eai_gdf = df + eai_gdf[GROUP_COL_NAME] = pd.NA + + eai_gdf[GROUP_COL_NAME] = pd.Categorical( + eai_gdf[GROUP_COL_NAME], categories=self._groups_id + ) + eai_gdf[METRIC_COL_NAME] = EAI_METRIC_NAME + eai_gdf[MEASURE_COL_NAME] = ( + self.measure.name if self.measure else NO_MEASURE_VALUE + ) + eai_gdf[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit + return eai_gdf + + def calc_aai_metric(self) -> pd.DataFrame: + """Compute a DataFrame of the AAI at each dates of the risk period (including changes in exposure, hazard and vulnerability).""" + aai_df = pd.DataFrame( + index=self.date_idx, columns=[RISK_COL_NAME], data=self.per_date_aai + ) + aai_df[GROUP_COL_NAME] = pd.Categorical( + [pd.NA] * len(aai_df), categories=self._groups_id + ) + aai_df[METRIC_COL_NAME] = AAI_METRIC_NAME + aai_df[MEASURE_COL_NAME] = ( + self.measure.name if self.measure else NO_MEASURE_VALUE + ) + aai_df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit + aai_df.reset_index(inplace=True) + return aai_df + + def calc_aai_per_group_metric(self) -> pd.DataFrame | None: + """Compute a DataFrame of the AAI distinguised per group id in the exposures, at each dates of the risk period (including changes in exposure, hazard and vulnerability). + + Notes + ----- + + If group ids changes between starting and ending snapshots of the risk period, the AAIs are linearly interpolated (with a warning for transparency). + + """ + if len(self._group_id_E0) < 1 or len(self._group_id_E1) < 1: + LOGGER.warning( + "No group id defined in at least one of the Exposures object. Per group aai will be empty." + ) + return None + + eai_pres_groups = self.eai_gdf[ + [ + DEFAULT_PERIOD_INDEX_NAME, + COORD_ID_COL_NAME, + GROUP_COL_NAME, + RISK_COL_NAME, + ] + ].copy() + aai_per_group_df = eai_pres_groups.groupby( + [DEFAULT_PERIOD_INDEX_NAME, GROUP_COL_NAME], as_index=False, observed=True + )[RISK_COL_NAME].sum() + if not np.array_equal(self._group_id_E0, self._group_id_E1): + LOGGER.warning( + "Group id are changing between present and future snapshot. Per group AAI will be linearly interpolated." + ) + eai_fut_groups = self.eai_gdf.copy() + eai_fut_groups[GROUP_COL_NAME] = pd.Categorical( + np.tile(self._group_id_E1, len(self.date_idx)), + categories=self._groups_id, + ) + aai_fut_groups = eai_fut_groups.groupby( + [DEFAULT_PERIOD_INDEX_NAME, GROUP_COL_NAME], as_index=False + )[RISK_COL_NAME].sum() + aai_per_group_df[RISK_COL_NAME] = linear_interp_arrays( + aai_per_group_df[RISK_COL_NAME].values, + aai_fut_groups[RISK_COL_NAME].values, + ) + + aai_per_group_df[METRIC_COL_NAME] = AAI_METRIC_NAME + aai_per_group_df[MEASURE_COL_NAME] = ( + self.measure.name if self.measure else NO_MEASURE_VALUE + ) + aai_per_group_df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit + return aai_per_group_df + + def calc_return_periods_metric(self, return_periods: list[int]) -> pd.DataFrame: + """Compute a DataFrame of the estimated impacts for a list of return + periods, at each dates of the risk period (including changes in exposure, + hazard and vulnerability). + + Parameters + ---------- + + return_periods : list of int + The return periods to estimate impacts for. + + """ + + # currently mathematicaly wrong, but approximatively correct, to be reworked when concatenating the impact matrices for the interpolation + per_date_rp_H0V0, per_date_rp_H1V0, per_date_rp_H0V1, per_date_rp_H1V1 = ( + self.per_date_return_periods_H0V0(return_periods), + self.per_date_return_periods_H1V0(return_periods), + self.per_date_return_periods_H0V1(return_periods), + self.per_date_return_periods_H1V1(return_periods), + ) + per_date_rp_V0 = self.interpolation_strategy.interp_over_hazard_dim( + per_date_rp_H0V0, per_date_rp_H1V0 + ) + per_date_rp_V1 = self.interpolation_strategy.interp_over_hazard_dim( + per_date_rp_H0V1, per_date_rp_H1V1 + ) + per_date_rp = self.interpolation_strategy.interp_over_vulnerability_dim( + per_date_rp_V0, per_date_rp_V1 + ) + rp_df = pd.DataFrame( + index=self.date_idx, columns=return_periods, data=per_date_rp + ).melt(value_name=RISK_COL_NAME, var_name="rp", ignore_index=False) + rp_df.reset_index(inplace=True) + rp_df[GROUP_COL_NAME] = pd.Categorical( + [pd.NA] * len(rp_df), categories=self._groups_id + ) + rp_df[METRIC_COL_NAME] = RP_VALUE_PREFIX + "_" + rp_df["rp"].astype(str) + rp_df = rp_df.drop("rp", axis=1) + rp_df[MEASURE_COL_NAME] = ( + self.measure.name if self.measure else NO_MEASURE_VALUE + ) + rp_df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit + return rp_df + + def calc_risk_contributions_metric(self) -> pd.DataFrame: + """Compute a DataFrame of the individual contributions of risk (impact), + at each dates of the risk period (including changes in exposure, + hazard and vulnerability). + + """ + per_date_aai_E0V0 = self.interpolation_strategy.interp_over_hazard_dim( + self.per_date_aai_E0H0V0, self.per_date_aai_E0H1V0 + ) + per_date_aai_E0H0 = self.interpolation_strategy.interp_over_vulnerability_dim( + self.per_date_aai_E0H0V0, self.per_date_aai_E0H0V1 + ) + df = pd.DataFrame( + { + CONTRIBUTION_TOTAL_RISK_NAME: self.per_date_aai, + CONTRIBUTION_BASE_RISK_NAME: self.per_date_aai[0], + CONTRIBUTION_EXPOSURE_NAME: self.per_date_aai_H0V0 + - self.per_date_aai[0], + CONTRIBUTION_HAZARD_NAME: per_date_aai_E0V0 + # - (self.per_date_aai_H0V0 - self.per_date_aai[0]) + - self.per_date_aai[0], + CONTRIBUTION_VULNERABILITY_NAME: per_date_aai_E0H0 + - self.per_date_aai[0], + # - (self.per_date_aai_H0V0 - self.per_date_aai[0]), + }, + index=self.date_idx, + ) + df[CONTRIBUTION_INTERACTION_TERM_NAME] = df[CONTRIBUTION_TOTAL_RISK_NAME] - ( + df[CONTRIBUTION_BASE_RISK_NAME] + + df[CONTRIBUTION_EXPOSURE_NAME] + + df[CONTRIBUTION_HAZARD_NAME] + + df[CONTRIBUTION_VULNERABILITY_NAME] + ) + df = df.melt( + value_vars=[ + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + ], + var_name=METRIC_COL_NAME, + value_name=RISK_COL_NAME, + ignore_index=False, + ) + df.reset_index(inplace=True) + df[GROUP_COL_NAME] = pd.Categorical( + [pd.NA] * len(df), categories=self._groups_id + ) + df[MEASURE_COL_NAME] = self.measure.name if self.measure else NO_MEASURE_VALUE + df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit + return df + + def apply_measure(self, measure: Measure) -> "CalcRiskMetricsPeriod": + """Creates a new `CalcRiskMetricsPeriod` object with a measure. + + The given measure is applied to both snapshot of the risk period. + + Parameters + ---------- + measure : Measure + The measure to apply. + + Returns + ------- + + CalcRiskPeriod + The risk period with given measure applied. + + """ + snap0 = self.snapshot_start.apply_measure(measure) + snap1 = self.snapshot_end.apply_measure(measure) + + risk_period = CalcRiskMetricsPeriod( + snap0, + snap1, + self.time_resolution, + self.interpolation_strategy, + self.impact_computation_strategy, + ) + + risk_period.measure = measure + return risk_period + + +def calc_per_date_eais(imp_mats: list[csr_matrix], frequency: np.ndarray) -> np.ndarray: + """Calculate expected average impact (EAI) values from a list of impact matrices + corresponding to impacts at different dates (with possible changes along + exposure, hazard and vulnerability). + + Parameters + ---------- + imp_mats : list of np.ndarray + List of impact matrices. + frequency : np.ndarray + Hazard frequency values. + + Returns + ------- + np.ndarray + 2D array of EAI (1D) for each dates. + + """ + per_date_eai_exp = np.array( + [ImpactCalc.eai_exp_from_mat(imp_mat, frequency) for imp_mat in imp_mats] + ) + return per_date_eai_exp + + +def calc_per_date_aais(per_date_eai_exp: np.ndarray) -> np.ndarray: + """Calculate per_date aggregate annual impact (AAI) values + resulting from a list arrays corresponding to EAI at different + dates (with possible changes along exposure, hazard and vulnerability). + + Parameters + ---------- + per_date_eai_exp: np.ndarray + EAIs arrays. + + Returns + ------- + np.ndarray + 1D array of AAI (0D) for each dates. + """ + per_date_aai = np.array( + [ImpactCalc.aai_agg_from_eai_exp(eai_exp) for eai_exp in per_date_eai_exp] + ) + return per_date_aai + + +def calc_per_date_rps( + imp_mats: list[csr_matrix], + frequency: np.ndarray, + frequency_unit: str, + return_periods: list[int], +) -> np.ndarray: + """Calculate per date return period impact values from a + list of impact matrices corresponding to impacts at different + dates (with possible changes along exposure, hazard and vulnerability). + + Parameters + ---------- + imp_mats: list of scipy.crs_matrix + List of impact matrices. + frequency: np.ndarray + Frequency values. + return_periods : list of int + Return periods to calculate impact values for. + + Returns + ------- + np.ndarray + 2D array of impacts per return periods (1D) for each dates. + + """ + rp = np.array( + [ + calc_freq_curve(imp_mat, frequency, frequency_unit, return_periods).impact + for imp_mat in imp_mats + ] + ) + return rp + + +def calc_freq_curve( + imp_mat_intrpl, frequency, frequency_unit, return_per=None +) -> ImpactFreqCurve: + """Calculate the estimated impacts for given return periods. + + Parameters + ---------- + + imp_mat_intrpl: scipy.csr_matrix + An impact matrix. + frequency: np.ndarray + The frequency of the hazard. + return_per: np.ndarray + The return periods to compute impacts for. + + Returns + ------- + np.ndarray + The estimated impacts for the different return periods. + + """ + + at_event = np.sum(imp_mat_intrpl, axis=1).A1 + + # Sort descendingly the impacts per events + sort_idxs = np.argsort(at_event)[::-1] + # Calculate exceedence frequency + exceed_freq = np.cumsum(frequency[sort_idxs]) + # Set return period and impact exceeding frequency + ifc_return_per = 1 / exceed_freq[::-1] + ifc_impact = at_event[sort_idxs][::-1] + + if return_per is not None: + interp_imp = np.interp(return_per, ifc_return_per, ifc_impact) + ifc_return_per = return_per + ifc_impact = interp_imp + + return ImpactFreqCurve( + return_per=ifc_return_per, + impact=ifc_impact, + frequency_unit=frequency_unit, + label="Exceedance frequency curve", + ) From 64438767fb32d1b2c3eaec5a94f4d886fdb5efe2 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 18 Dec 2025 15:18:11 +0100 Subject: [PATCH 21/61] updates from feature/risk_trajectory --- climada/test/test_trajectories.py | 365 +++++++++++++++++++++++++++++- 1 file changed, 364 insertions(+), 1 deletion(-) diff --git a/climada/test/test_trajectories.py b/climada/test/test_trajectories.py index 5df15e2651..933e277225 100644 --- a/climada/test/test_trajectories.py +++ b/climada/test/test_trajectories.py @@ -19,8 +19,11 @@ """ +import copy +from itertools import groupby from unittest import TestCase +import geopandas as gpd import numpy as np import pandas as pd @@ -33,15 +36,26 @@ reusable_minimal_impfset, reusable_snapshot, ) -from climada.trajectories import StaticRiskTrajectory +from climada.trajectories import InterpolatedRiskTrajectory, StaticRiskTrajectory from climada.trajectories.constants import ( AAI_METRIC_NAME, + AAI_PER_GROUP_METRIC_NAME, + CONTRIBUTION_BASE_RISK_NAME, + CONTRIBUTION_EXPOSURE_NAME, + CONTRIBUTION_HAZARD_NAME, + CONTRIBUTION_INTERACTION_TERM_NAME, + CONTRIBUTION_VULNERABILITY_NAME, + COORD_ID_COL_NAME, DATE_COL_NAME, + EAI_METRIC_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME, NO_MEASURE_VALUE, + PERIOD_COL_NAME, + RETURN_PERIOD_METRIC_NAME, RISK_COL_NAME, + RP_VALUE_PREFIX, UNIT_COL_NAME, ) from climada.trajectories.snapshot import Snapshot @@ -276,3 +290,352 @@ def test_static_trajectory_risk_disc_rate(self): check_dtype=False, check_categorical=False, ) + + +class TestInterpolatedTrajectory(TestCase): + PRESENT_DATE = 2020 + HAZ_INCREASE_INTENSITY_FACTOR = 2 + EXP_INCREASE_VALUE_FACTOR = 6 + FUTURE_DATE = 2022 + + def setUp(self) -> None: + self.base_snapshot = reusable_snapshot(date=self.PRESENT_DATE) + self.future_snapshot = reusable_snapshot( + hazard_intensity_increase_factor=self.HAZ_INCREASE_INTENSITY_FACTOR, + exposure_value_increase_factor=self.EXP_INCREASE_VALUE_FACTOR, + date=self.FUTURE_DATE, + ) + + self.expected_base_imp = ImpactCalc( + **self.base_snapshot.impact_calc_data + ).impact() + self.expected_future_imp = ImpactCalc( + **self.future_snapshot.impact_calc_data + ).impact() + # self.group_vector = self.base_snapshot.exposure.gdf[GROUP_ID_COL_NAME] + self.expected_base_return_period_impacts = { + rp: imp + for rp, imp in zip( + self.expected_base_imp.calc_freq_curve(DEFAULT_RP).return_per, + self.expected_base_imp.calc_freq_curve(DEFAULT_RP).impact, + ) + } + self.expected_future_return_period_impacts = { + rp: imp + for rp, imp in zip( + self.expected_future_imp.calc_freq_curve(DEFAULT_RP).return_per, + self.expected_future_imp.calc_freq_curve(DEFAULT_RP).impact, + ) + } + + # fmt: off + self.expected_interp_metrics = pd.DataFrame.from_dict( + {'index': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + 'columns': [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME, UNIT_COL_NAME, RISK_COL_NAME], + 'data': [[ pd.Period(2020), 'All',NO_MEASURE_VALUE, 'aai', 'USD', 20.0], + [ pd.Period(2021), 'All',NO_MEASURE_VALUE, 'aai', 'USD', 105.0], # This should indeed not be 240+20 / 2 (because we interpolate each contributor separately) + [ pd.Period(2022), 'All',NO_MEASURE_VALUE, 'aai', 'USD', 240.0], + [ pd.Period(2020), 'All',NO_MEASURE_VALUE, 'rp_20', 'USD', 0.0], + [ pd.Period(2021), 'All',NO_MEASURE_VALUE, 'rp_20', 'USD', 0.0], + [ pd.Period(2022), 'All',NO_MEASURE_VALUE, 'rp_20', 'USD', 0.0], + [ pd.Period(2020), 'All',NO_MEASURE_VALUE, 'rp_50', 'USD', 500.0], + [ pd.Period(2021), 'All',NO_MEASURE_VALUE, 'rp_50', 'USD', 2625.0], + [ pd.Period(2022), 'All',NO_MEASURE_VALUE, 'rp_50', 'USD', 6000.0], + [ pd.Period(2020), 'All',NO_MEASURE_VALUE, 'rp_100', 'USD', 1500.0], + [ pd.Period(2021), 'All',NO_MEASURE_VALUE, 'rp_100', 'USD', 7875.0], + [ pd.Period(2022), 'All',NO_MEASURE_VALUE, 'rp_100', 'USD', 18000.0]], + 'index_names': [None], + 'column_names': [None]}, + orient="tight" + ) + + self.expected_period_metrics = pd.DataFrame.from_dict( + {'index': [0, 1, 2, 3], + 'columns': [PERIOD_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME, UNIT_COL_NAME, RISK_COL_NAME], + 'data': [[f"{self.PRESENT_DATE} to {self.FUTURE_DATE}", 'All', NO_MEASURE_VALUE, 'aai', 'USD', 365.0/3], + [f"{self.PRESENT_DATE} to {self.FUTURE_DATE}", 'All', NO_MEASURE_VALUE, 'rp_100', 'USD', 27375/3], + [f"{self.PRESENT_DATE} to {self.FUTURE_DATE}", 'All', NO_MEASURE_VALUE, 'rp_20', 'USD', 0.0], + [f"{self.PRESENT_DATE} to {self.FUTURE_DATE}", 'All', NO_MEASURE_VALUE, 'rp_50', 'USD', 9125.0/3]], + 'index_names': [None], + 'column_names': [None]}, + orient="tight" + ) + # fmt: on + + def test_interp_trajectory(self): + interp_traj = InterpolatedRiskTrajectory( + [self.base_snapshot, self.future_snapshot] + ) + pd.testing.assert_frame_equal( + interp_traj.per_date_risk_metrics(), + self.expected_interp_metrics, + check_dtype=False, + check_categorical=False, + ) + pd.testing.assert_frame_equal( + interp_traj.per_period_risk_metrics(), + self.expected_period_metrics, + check_dtype=False, + check_categorical=False, + ) + + def test_interp_trajectory_with_group(self): + exp0 = reusable_minimal_exposures(group_id=CATEGORIES) + exp1 = reusable_minimal_exposures( + group_id=CATEGORIES, increase_value_factor=self.EXP_INCREASE_VALUE_FACTOR + ) + snap0 = Snapshot( + exposure=exp0, + hazard=reusable_minimal_hazard(), + impfset=reusable_minimal_impfset(), + date=self.PRESENT_DATE, + ) + snap1 = Snapshot( + exposure=exp1, + hazard=reusable_minimal_hazard( + intensity_factor=self.HAZ_INCREASE_INTENSITY_FACTOR + ), + impfset=reusable_minimal_impfset(), + date=self.FUTURE_DATE, + ) + + expected_interp_metrics = pd.concat( + [ + self.expected_interp_metrics, + # fmt: off + pd.DataFrame.from_dict( + { + "index": [0, 1, 2, 3, 4, 5], + "columns": [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME, UNIT_COL_NAME, RISK_COL_NAME,], + "data": [ + [pd.Period("2020"), 1, NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", 15.0,], + [pd.Period("2020"), 2, NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", 5.0,], + [pd.Period("2021"), 1, NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", 78.75,], + [pd.Period("2021"), 2, NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", 26.25,], + [pd.Period("2022"), 1, NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", 180.0,], + [pd.Period("2022"), 2, NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", 60.0,], + ], + "index_names": [None], + "column_names": [None], + }, + orient="tight", + ), + # fmt: on + ], + ignore_index=True, + ) + + interp_traj = InterpolatedRiskTrajectory([snap0, snap1]) + pd.testing.assert_frame_equal( + interp_traj.per_date_risk_metrics(), + expected_interp_metrics, + check_dtype=False, + check_categorical=False, + ) + + def test_interp_trajectory_change_rp(self): + interp_traj = InterpolatedRiskTrajectory( + [self.base_snapshot, self.future_snapshot], return_periods=[10, 60, 1000] + ) + expected = pd.DataFrame.from_dict( + # fmt: off + { + "index": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + "columns": [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME, UNIT_COL_NAME, RISK_COL_NAME,], + "data": [ + [pd.Period(2020), "All", NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", 20.0,], + [pd.Period(2021), "All", NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", 105.0,], + [pd.Period(2022), "All", NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", 240.0,], + [pd.Period(2020), "All", NO_MEASURE_VALUE, "rp_10", "USD", 0.0], + [pd.Period(2021), "All", NO_MEASURE_VALUE, "rp_10", "USD", 0.0], + [pd.Period(2022), "All", NO_MEASURE_VALUE, "rp_10", "USD", 0.0], + [pd.Period(2020), "All", NO_MEASURE_VALUE, "rp_60", "USD", 700.0], + [pd.Period(2021), "All", NO_MEASURE_VALUE, "rp_60", "USD", 3675.0], + [pd.Period(2022), "All", NO_MEASURE_VALUE, "rp_60", "USD", 8400.0], + [pd.Period(2020), "All", NO_MEASURE_VALUE, "rp_1000", "USD", 1500.0,], + [pd.Period(2021), "All", NO_MEASURE_VALUE, "rp_1000", "USD", 7875.0,], + [pd.Period(2022), "All", NO_MEASURE_VALUE, "rp_1000", "USD", 18000.0,], + ], + "index_names": [None], + "column_names": [None], + }, + # fmt: on + orient="tight", + ) + pd.testing.assert_frame_equal( + interp_traj.per_date_risk_metrics(), + expected, + check_dtype=False, + check_categorical=False, + ) + + # Also check change to other return period + interp_traj.return_periods = DEFAULT_RP + pd.testing.assert_frame_equal( + interp_traj.per_date_risk_metrics(), + self.expected_interp_metrics, + check_dtype=False, + check_categorical=False, + ) + + def test_interp_trajectory_risk_disc_rate(self): + risk_disc_rate = DiscRates( + years=np.array(range(2020, 2023)), rates=np.ones(3) * 0.05 + ) # Easy check for year 2021 -> 105.0 * 1/(1+0.05) == 100. + interp_traj = InterpolatedRiskTrajectory( + [self.base_snapshot, self.future_snapshot], risk_disc_rates=risk_disc_rate + ) + expected = pd.DataFrame.from_dict( + # fmt: off + { + "index": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + "columns": [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME, UNIT_COL_NAME, RISK_COL_NAME,], + "data": [ + [pd.Period(2020), "All", NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", 20.0,], + [pd.Period(2021), "All", NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", 100.0,], + [pd.Period(2022), "All", NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", 217.68707482993196,], + [pd.Period(2020), "All", NO_MEASURE_VALUE, "rp_20", "USD", 0.0], + [pd.Period(2021), "All", NO_MEASURE_VALUE, "rp_20", "USD", 0.0], + [pd.Period(2022), "All", NO_MEASURE_VALUE, "rp_20", "USD", 0.0], + [pd.Period(2020), "All", NO_MEASURE_VALUE, "rp_50", "USD", 500.0], + [pd.Period(2021), "All", NO_MEASURE_VALUE, "rp_50", "USD", 2500.0], + [pd.Period(2022), "All", NO_MEASURE_VALUE, "rp_50", "USD", 5442.176870748299,], + [pd.Period(2020), "All", NO_MEASURE_VALUE, "rp_100", "USD", 1500.0], + [pd.Period(2021), "All", NO_MEASURE_VALUE, "rp_100", "USD", 7500.0], + [pd.Period(2022), "All", NO_MEASURE_VALUE, "rp_100", "USD", 16326.530612244896,], + ], + "index_names": [None], + "column_names": [None], + }, + # fmt: on + orient="tight", + ) + pd.testing.assert_frame_equal( + interp_traj.per_date_risk_metrics(), + expected, + check_dtype=False, + check_categorical=False, + ) + + # Also check change to other return period + interp_traj.risk_disc_rates = None + pd.testing.assert_frame_equal( + interp_traj.per_date_risk_metrics(), + self.expected_interp_metrics, + check_dtype=False, + check_categorical=False, + ) + + def test_interp_trajectory_risk_contributions(self): + interp_traj = InterpolatedRiskTrajectory( + [self.base_snapshot, self.future_snapshot] + ) + expected = pd.DataFrame.from_dict( + # fmt: off + {'index': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], + 'columns': [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME, UNIT_COL_NAME, RISK_COL_NAME,], + 'data': [ + [pd.Period(str(2020)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_BASE_RISK_NAME, 'USD', 20.0], + [pd.Period(str(2021)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_BASE_RISK_NAME, 'USD', 20.0], + [pd.Period(str(2022)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_BASE_RISK_NAME, 'USD', 20.0], + [pd.Period(str(2020)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_EXPOSURE_NAME, 'USD', 0.0], + [pd.Period(str(2021)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_EXPOSURE_NAME, 'USD', 50.0], + [pd.Period(str(2022)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_EXPOSURE_NAME, 'USD', 100.0], + [pd.Period(str(2020)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_HAZARD_NAME, 'USD', 0.0], + [pd.Period(str(2021)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_HAZARD_NAME, 'USD', 10.0], + [pd.Period(str(2022)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_HAZARD_NAME, 'USD', 20.0], + [pd.Period(str(2020)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_VULNERABILITY_NAME, 'USD', 0.0], + [pd.Period(str(2021)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_VULNERABILITY_NAME, 'USD', 0.0], + [pd.Period(str(2022)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_VULNERABILITY_NAME, 'USD', 0.0], + [pd.Period(str(2020)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_INTERACTION_TERM_NAME, 'USD', 0.0], + [pd.Period(str(2021)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_INTERACTION_TERM_NAME, 'USD', 25.0], + [pd.Period(str(2022)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_INTERACTION_TERM_NAME, 'USD', 100.0]], + 'index_names': [None], + 'column_names': [None]}, + # fmt: on + orient="tight", + ) + pd.testing.assert_frame_equal( + interp_traj.risk_contributions_metrics(), + expected, + check_dtype=False, + check_categorical=False, + ) + + # With changing vulnerability + hazard = reusable_minimal_hazard() + impfset1 = ImpactFuncSet( + [ + ImpactFunc( + haz_type=hazard.haz_type, + intensity_unit=hazard.units, + name="linear", + intensity=np.array([0, 100 / 2, 100]), + mdd=np.array([0, 0.5, 1]), + paa=np.array([1, 1, 1]), + id=1, + ), + ] + ) + impfset2 = ImpactFuncSet( + [ + ImpactFunc( + haz_type=hazard.haz_type, + intensity_unit=hazard.units, + name="linear-half-paa", + intensity=np.array([0, 100 / 2, 100]), + mdd=np.array([0, 0.5, 1]), + paa=np.array([0.5, 0.5, 0.5]), + id=1, + ) + ] + ) + base_snapshot = Snapshot( + exposure=reusable_minimal_exposures(), + hazard=hazard, + impfset=impfset1, + date=2020, + ) + future_snapshot = Snapshot( + exposure=reusable_minimal_exposures( + increase_value_factor=self.EXP_INCREASE_VALUE_FACTOR, + ), + hazard=reusable_minimal_hazard( + intensity_factor=self.HAZ_INCREASE_INTENSITY_FACTOR + ), + impfset=impfset2, + date=2022, + ) + + interp_traj = InterpolatedRiskTrajectory([base_snapshot, future_snapshot]) + expected = pd.DataFrame.from_dict( + # fmt: off + {'index': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], + 'columns': [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME, UNIT_COL_NAME, RISK_COL_NAME,], + 'data': [ + [pd.Period(str(2020)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_BASE_RISK_NAME, 'USD', 20.0], + [pd.Period(str(2021)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_BASE_RISK_NAME, 'USD', 20.0], + [pd.Period(str(2022)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_BASE_RISK_NAME, 'USD', 20.0], + [pd.Period(str(2020)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_EXPOSURE_NAME, 'USD', 0.0], + [pd.Period(str(2021)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_EXPOSURE_NAME, 'USD', 50.0], + [pd.Period(str(2022)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_EXPOSURE_NAME, 'USD', 100.0], + [pd.Period(str(2020)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_HAZARD_NAME, 'USD', 0.0], + [pd.Period(str(2021)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_HAZARD_NAME, 'USD', 10.0], + [pd.Period(str(2022)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_HAZARD_NAME, 'USD', 20.0], + [pd.Period(str(2020)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_VULNERABILITY_NAME, 'USD', 0.0], + [pd.Period(str(2021)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_VULNERABILITY_NAME, 'USD', -5.0], + [pd.Period(str(2022)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_VULNERABILITY_NAME, 'USD', -10.0], + [pd.Period(str(2020)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_INTERACTION_TERM_NAME, 'USD', 0.0], + [pd.Period(str(2021)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_INTERACTION_TERM_NAME, 'USD', 3.75], + [pd.Period(str(2022)), 'All', NO_MEASURE_VALUE, CONTRIBUTION_INTERACTION_TERM_NAME, 'USD', -10.0]], + 'index_names': [None], + 'column_names': [None]}, + # fmt: on + orient="tight", + ) + pd.testing.assert_frame_equal( + interp_traj.risk_contributions_metrics(), + expected, + check_dtype=False, + check_categorical=False, + ) From 2a0cf66dde8c2ea96e685b929208d95badd51c16 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 18 Dec 2025 15:21:01 +0100 Subject: [PATCH 22/61] fixes namespace --- climada/trajectories/interpolated_trajectory.py | 2 +- .../trajectories/test/test_interpolated_risk_trajectory.py | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/climada/trajectories/interpolated_trajectory.py b/climada/trajectories/interpolated_trajectory.py index c2f87b37e7..1d9a1c23b8 100644 --- a/climada/trajectories/interpolated_trajectory.py +++ b/climada/trajectories/interpolated_trajectory.py @@ -32,6 +32,7 @@ import pandas as pd from climada.entity.disc_rates.base import DiscRates +from climada.trajectories.calc_risk_metrics import CalcRiskMetricsPeriod from climada.trajectories.constants import ( AAI_METRIC_NAME, AAI_PER_GROUP_METRIC_NAME, @@ -61,7 +62,6 @@ AllLinearStrategy, InterpolationStrategyBase, ) -from climada.trajectories.riskperiod import CalcRiskMetricsPeriod from climada.trajectories.snapshot import Snapshot from climada.trajectories.trajectory import ( DEFAULT_ALLGROUP_NAME, diff --git a/climada/trajectories/test/test_interpolated_risk_trajectory.py b/climada/trajectories/test/test_interpolated_risk_trajectory.py index 87d5f66952..e09738260d 100644 --- a/climada/trajectories/test/test_interpolated_risk_trajectory.py +++ b/climada/trajectories/test/test_interpolated_risk_trajectory.py @@ -29,6 +29,9 @@ import pandas as pd from climada.entity.disc_rates.base import DiscRates +from climada.trajectories.calc_risk_metrics import ( # ImpactComputationStrategy, # If needed to mock its base class directly + CalcRiskMetricsPeriod, +) from climada.trajectories.constants import ( AAI_METRIC_NAME, AAI_PER_GROUP_METRIC_NAME, @@ -59,9 +62,6 @@ AllLinearStrategy, ExponentialExposureStrategy, ) -from climada.trajectories.riskperiod import ( # ImpactComputationStrategy, # If needed to mock its base class directly - CalcRiskMetricsPeriod, -) from climada.trajectories.snapshot import Snapshot From f0f635b80fd5ec065ecfb629d283450c93a77b8f Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 18 Dec 2025 16:29:51 +0100 Subject: [PATCH 23/61] Tidies up `calc_risk_metrics` --- climada/trajectories/calc_risk_metrics.py | 136 +++++++++++----------- 1 file changed, 67 insertions(+), 69 deletions(-) diff --git a/climada/trajectories/calc_risk_metrics.py b/climada/trajectories/calc_risk_metrics.py index 2ab97ab61b..92131d71a1 100644 --- a/climada/trajectories/calc_risk_metrics.py +++ b/climada/trajectories/calc_risk_metrics.py @@ -555,7 +555,39 @@ def impact_computation_strategy(self, value, /): self._impact_computation_strategy = value self._reset_impact_data() - ##### Impact objects cube / Risk Cube ##### + def apply_measure(self, measure: Measure) -> "CalcRiskMetricsPeriod": + """Creates a new `CalcRiskMetricsPeriod` object with a measure. + + The given measure is applied to both snapshot of the risk period. + + Parameters + ---------- + measure : Measure + The measure to apply. + + Returns + ------- + + CalcRiskPeriod + The risk period with given measure applied. + + """ + snap0 = self.snapshot_start.apply_measure(measure) + snap1 = self.snapshot_end.apply_measure(measure) + + risk_period = CalcRiskMetricsPeriod( + snap0, + snap1, + self.time_resolution, + self.interpolation_strategy, + self.impact_computation_strategy, + ) + + risk_period.measure = measure + return risk_period + + ################################################### + ##### Impact objects cube / Risk Cube corners ##### @lazy_property def E0H0V0(self) -> Impact: @@ -631,7 +663,8 @@ def E1H1V1(self) -> Impact: ############################### - ### Impact Matrices arrays #### + ################################################# + ### Impact Matrices arrays / Risk Cube edges #### def _interp_mats(self, start_attr, end_attr) -> list: """Helper to reduce repetition in impact matrix interpolation.""" @@ -661,23 +694,26 @@ def imp_mats_H1V1(self) -> list: """List of `time_points` impact matrices with changing exposure, future hazard and future vulnerability.""" return self._interp_mats("E0H1V1", "E1H1V1") + ### The following are for risk contributions + @property def imp_mats_E0H0V0(self) -> list: """List of `time_points` impact matrices with base exposure, base hazard and base vulnerability.""" - return self._interp_mats("E0H0V0", "E0H0V0") + return [self.E0H0V0.imp_mat] * self.time_points @property def imp_mats_E0H1V0(self) -> list: """List of `time_points` impact matrices with base exposure, future hazard and base vulnerability.""" - return self._interp_mats("E0H1V0", "E0H1V0") + return [self.E0H1V0.imp_mat] * self.time_points @property def imp_mats_E0H0V1(self) -> list: """List of `time_points` impact matrices with base exposure, base hazard and base vulnerability.""" - return self._interp_mats("E0H0V1", "E0H0V1") + return [self.E0H0V1.imp_mat] * self.time_points ############################### + ############################### ########## Core EAI ########### @property @@ -729,10 +765,12 @@ def per_date_eai_E0H0V1(self) -> np.ndarray: self.imp_mats_E0H0V1, self.snapshot_start.hazard.frequency ) - ################################## - + ############################## ######### Core AAIs ########## + # Not required for final AAIs computation (we use final EAIs instead), + # but could be useful in the future? + @property def per_date_aai_H0V0(self) -> np.ndarray: """Average annual impacts for changing exposure, starting hazard and starting vulnerability.""" @@ -768,8 +806,7 @@ def per_date_aai_E0H0V1(self) -> np.ndarray: """Average annual impacts for base exposure, base hazard and base vulnerability.""" return calc_per_date_aais(self.per_date_eai_E0H0V1) - ################################# - + ############################# ######### Core RPs ######### def per_date_return_periods_H0V0(self, return_periods: list[int]) -> np.ndarray: @@ -809,8 +846,9 @@ def per_date_return_periods_H1V1(self, return_periods: list[int]) -> np.ndarray: ) ################################## + ##### Interpolation of metrics ### - ##### Interpolation of metrics ##### + # Actual results def calc_eai(self) -> np.ndarray: """Compute the EAIs at each date of the risk period (including changes in exposure, hazard and vulnerability).""" @@ -843,8 +881,10 @@ def per_date_aai(self) -> np.ndarray: """Average annual impacts per date with changing exposure, changing hazard and changing vulnerability.""" return calc_per_date_aais(self.per_date_eai) - @lazy_property - def eai_gdf(self) -> pd.DataFrame: + #################################### + ######## Tidying results ########### + + def calc_eai_gdf(self) -> pd.DataFrame: """Convenience function returning a DataFrame (with both datetime and coordinates ids) from `per_date_eai`. This dataframe can easily be merged with one of the snapshot exposure geodataframe. @@ -855,19 +895,6 @@ def eai_gdf(self) -> pd.DataFrame: The DataFrame from the starting snapshot is used as a basis (notably for `value` and `group_id`). """ - return self.calc_eai_gdf() - - #################################### - - ### Metrics from impact matrices ### - - # These methods might go in a utils file instead, to be reused - # for a no interpolation case (and maybe the timeseries?) - - #################################### - - def calc_eai_gdf(self) -> pd.DataFrame: - """Merge the per date EAIs of the risk period with the GeoDataframe of the exposure of the starting snapshot.""" df = pd.DataFrame(self.per_date_eai, index=self.date_idx) df = df.reset_index().melt( id_vars=DEFAULT_PERIOD_INDEX_NAME, @@ -924,7 +951,8 @@ def calc_aai_per_group_metric(self) -> pd.DataFrame | None: ) return None - eai_pres_groups = self.eai_gdf[ + eai_gdf = self.calc_eai_gdf() + eai_pres_groups = eai_gdf[ [ DEFAULT_PERIOD_INDEX_NAME, COORD_ID_COL_NAME, @@ -939,7 +967,7 @@ def calc_aai_per_group_metric(self) -> pd.DataFrame | None: LOGGER.warning( "Group id are changing between present and future snapshot. Per group AAI will be linearly interpolated." ) - eai_fut_groups = self.eai_gdf.copy() + eai_fut_groups = eai_gdf.copy() eai_fut_groups[GROUP_COL_NAME] = pd.Categorical( np.tile(self._group_id_E1, len(self.date_idx)), categories=self._groups_id, @@ -1009,11 +1037,13 @@ def calc_risk_contributions_metric(self) -> pd.DataFrame: hazard and vulnerability). """ - per_date_aai_E0V0 = self.interpolation_strategy.interp_over_hazard_dim( + aai_changes_hazard_only = self.interpolation_strategy.interp_over_hazard_dim( self.per_date_aai_E0H0V0, self.per_date_aai_E0H1V0 ) - per_date_aai_E0H0 = self.interpolation_strategy.interp_over_vulnerability_dim( - self.per_date_aai_E0H0V0, self.per_date_aai_E0H0V1 + aai_changes_vulnerability_only = ( + self.interpolation_strategy.interp_over_vulnerability_dim( + self.per_date_aai_E0H0V0, self.per_date_aai_E0H0V1 + ) ) df = pd.DataFrame( { @@ -1021,12 +1051,10 @@ def calc_risk_contributions_metric(self) -> pd.DataFrame: CONTRIBUTION_BASE_RISK_NAME: self.per_date_aai[0], CONTRIBUTION_EXPOSURE_NAME: self.per_date_aai_H0V0 - self.per_date_aai[0], - CONTRIBUTION_HAZARD_NAME: per_date_aai_E0V0 - # - (self.per_date_aai_H0V0 - self.per_date_aai[0]) + CONTRIBUTION_HAZARD_NAME: aai_changes_hazard_only - self.per_date_aai[0], - CONTRIBUTION_VULNERABILITY_NAME: per_date_aai_E0H0 + CONTRIBUTION_VULNERABILITY_NAME: aai_changes_vulnerability_only - self.per_date_aai[0], - # - (self.per_date_aai_H0V0 - self.per_date_aai[0]), }, index=self.date_idx, ) @@ -1056,36 +1084,9 @@ def calc_risk_contributions_metric(self) -> pd.DataFrame: df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit return df - def apply_measure(self, measure: Measure) -> "CalcRiskMetricsPeriod": - """Creates a new `CalcRiskMetricsPeriod` object with a measure. - - The given measure is applied to both snapshot of the risk period. - - Parameters - ---------- - measure : Measure - The measure to apply. - Returns - ------- - - CalcRiskPeriod - The risk period with given measure applied. - - """ - snap0 = self.snapshot_start.apply_measure(measure) - snap1 = self.snapshot_end.apply_measure(measure) - - risk_period = CalcRiskMetricsPeriod( - snap0, - snap1, - self.time_resolution, - self.interpolation_strategy, - self.impact_computation_strategy, - ) - - risk_period.measure = measure - return risk_period +#################################### +### Metrics from impact matrices ### def calc_per_date_eais(imp_mats: list[csr_matrix], frequency: np.ndarray) -> np.ndarray: @@ -1106,10 +1107,9 @@ def calc_per_date_eais(imp_mats: list[csr_matrix], frequency: np.ndarray) -> np. 2D array of EAI (1D) for each dates. """ - per_date_eai_exp = np.array( + return np.array( [ImpactCalc.eai_exp_from_mat(imp_mat, frequency) for imp_mat in imp_mats] ) - return per_date_eai_exp def calc_per_date_aais(per_date_eai_exp: np.ndarray) -> np.ndarray: @@ -1127,10 +1127,9 @@ def calc_per_date_aais(per_date_eai_exp: np.ndarray) -> np.ndarray: np.ndarray 1D array of AAI (0D) for each dates. """ - per_date_aai = np.array( + return np.array( [ImpactCalc.aai_agg_from_eai_exp(eai_exp) for eai_exp in per_date_eai_exp] ) - return per_date_aai def calc_per_date_rps( @@ -1158,13 +1157,12 @@ def calc_per_date_rps( 2D array of impacts per return periods (1D) for each dates. """ - rp = np.array( + return np.array( [ calc_freq_curve(imp_mat, frequency, frequency_unit, return_periods).impact for imp_mat in imp_mats ] ) - return rp def calc_freq_curve( From 063a4ce4192651bf2f7b62d2bb0bc98f4d80431a Mon Sep 17 00:00:00 2001 From: spjuhel Date: Fri, 19 Dec 2025 09:45:00 +0100 Subject: [PATCH 24/61] fixes imports --- climada/trajectories/interpolated_trajectory.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/climada/trajectories/interpolated_trajectory.py b/climada/trajectories/interpolated_trajectory.py index 1d9a1c23b8..1b016e7ca8 100644 --- a/climada/trajectories/interpolated_trajectory.py +++ b/climada/trajectories/interpolated_trajectory.py @@ -65,7 +65,9 @@ from climada.trajectories.snapshot import Snapshot from climada.trajectories.trajectory import ( DEFAULT_ALLGROUP_NAME, + DEFAULT_DF_COLUMN_PRIORITY, DEFAULT_RP, + INDEXING_COLUMNS, RiskTrajectory, ) from climada.util import log_level @@ -75,8 +77,6 @@ __all__ = ["InterpolatedRiskTrajectory"] -from climada.trajectories.trajectory import DEFAULT_DF_COLUMN_PRIORITY, INDEXING_COLUMNS - class InterpolatedRiskTrajectory(RiskTrajectory): """This class implements interpolated risk trajectories, objects that From 480c89d0b91371c0f41e1b1a7eb8a3c3fbdc8fdf Mon Sep 17 00:00:00 2001 From: spjuhel Date: Fri, 19 Dec 2025 15:18:22 +0100 Subject: [PATCH 25/61] updates Tutorial [wip] --- doc/user-guide/climada_trajectories.ipynb | 65 +++++++---------------- 1 file changed, 19 insertions(+), 46 deletions(-) diff --git a/doc/user-guide/climada_trajectories.ipynb b/doc/user-guide/climada_trajectories.ipynb index 7fa347b4ea..9a32caea4e 100644 --- a/doc/user-guide/climada_trajectories.ipynb +++ b/doc/user-guide/climada_trajectories.ipynb @@ -1,41 +1,5 @@ { "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "96920214-a14b-4094-9949-36a1175b1df8", - "metadata": {}, - "outputs": [], - "source": [ - "%load_ext autoreload\n", - "%autoreload 2" - ] - }, - { - "cell_type": "markdown", - "id": "56a07dee-25a8-4bb5-a01c-933ee955f067", - "metadata": {}, - "source": [ - "Currently, to run this tutorial, from within a climada_python git repo please run:\n", - "\n", - "```\n", - "mamba create -n climada_trajectory \"python==3.11.*\"\n", - "git fetch\n", - "git checkout feature/risk_trajectory\n", - "mamba env update -n climada_trajectory -f requirements/env_climada.yml\n", - "mamba activate climada_trajectory\n", - "python -m pip install -e ./\n", - "\n", - "```\n", - "\n", - "To be able to select that environment in jupyter you possibly might also need:\n", - "\n", - "```\n", - "mamba install ipykernel\n", - "python -m ipykernel install --user --name climada_trajectory\n", - "```" - ] - }, { "cell_type": "markdown", "id": "856ac388-9edb-497e-a2ff-a325f2a22562", @@ -94,13 +58,19 @@ "id": "4e0f3261-f443-4cc6-b85b-c6a3d90b73e3", "metadata": {}, "source": [ - "The fundamental idea behing the `trajectories` module is to enable a better assessment of the evolution of risk over time, both by facilitating point by point comparison, and risk \"evolutions\".\n", + "The fundamental idea behing the `trajectories` module is to enable a better assessment of the evolution of risk over time, both by facilitating point by point comparison, and the \"evolution\" or risk.\n", "\n", - "It aims at facilitating answering questions such as:\n", + "This module aims at facilitating answering questions such as:\n", "\n", "- How does future hazards (probabilistic event set), exposure and vulnerability change impacts with respect to present?\n", "- How would the impacts compare if a past event were to happen again with present / future exposure?\n", - "- etc." + "- How will risk evolve in the future under different assumptions on the evolution of hazard, exposure, vulnerability and discount rate?\n", + "- *etc*.\n", + "\n", + "To achieve this, this module introduces two concepts:\n", + "\n", + "- Snapshots of risk, a fixed representation of risk (via its three components Exposure, Hazard and Vulnerability) for a given date. This concept is intended to be generic, as such the given date can be something else than a year, a month or a day for instance, but keep in mind that we will not check that the data you provide makes sense for it!\n", + "- Trajectories of risk, a collection of snapshots,for which risk metrics can be computed and regrouped to ease their evaluation." ] }, { @@ -116,7 +86,7 @@ "id": "274a342f-54c0-4590-9110-5e297010955e", "metadata": {}, "source": [ - "We use `Snapshot` objects to define a point in time for risk. This object acts as a wrapper of the classic risk framework composed of Exposure, Hazard and Vulnerability. As such it is defined for a specific date (usually a year), and contains references to an `Exposures`, a `Hazard`, and an `ImpactFuncSet` object.\n", + "We use `Snapshot` objects to define a point in time for risk. This object acts as a wrapper of the classic risk framework composed of Exposure, Hazard and Vulnerability. As such it is defined for a specific date (usually a year), and contains an `Exposures`, a `Hazard`, and an `ImpactFuncSet` object.\n", "\n", "Instantiating such a `Snapshot` is done simply with:\n", "\n", @@ -131,10 +101,16 @@ "\n", "Note that to avoid any ambiguity, you need to write explicitly `exposure=your_exposure`.\n", "\n", - "Think of `Snapshot` as a representation of risk at, or around, a specific date. Your hazard should thus be a probabilistic set of events representative for the specified date.\n", - "Note that the date does not need to be a year and can be a datetime if you want to make comparisons on a sub-yearly level.\n", + "Think of `Snapshot` as a representation of risk at, or around, a specific date. Your hazard should be a probabilistic set of events that are representative for the designated date.\n", + "\n", + "To be consistent with the intuitive idea of a snapshot, `Snapshot` objects are make a \"deep copy\" of the risk triplet and are immutable. \n", + "This means that they do not change once created (notably even if you change one of the component, e.g. the Hazard object, outside of the `Snapshot`).\n", + "If you want a `Snapshot` with a different `Hazard`, you need to create a new one.\n", "\n", - "Below is an example of how to setup a such Snapshot using data from the data API for tropical cyclones in Haiti:" + "In that spirit, you cannot directly instantiate a Snapshot with an adaptation measure. To include adaptation, you need to first create the snapshot without adaptation, and then use `apply_measure()`, which\n", + "will return a new `Snapshot`, with the changed (Exposure, Hazard, ImpactFuncSet) according to the given measure.\n", + "\n", + "Below is an concrete example of how to create a Snapshot using data from the data API for tropical cyclones in Haiti:" ] }, { @@ -184,9 +160,6 @@ "exp_present.gdf.rename(columns={\"impf_\": \"impf_TC\"}, inplace=True)\n", "exp_present.gdf[\"impf_TC\"] = 1\n", "\n", - "# Trajectories allow to look at the risk faced by specifics groups of coordinates based on the \"group_id\" column of the exposure\n", - "exp_present.gdf[\"group_id\"] = (exp_present.gdf[\"value\"] > 500000) * 1\n", - "\n", "snap = Snapshot(exposure=exp_present, hazard=haz_present, impfset=impf_set, date=2018)" ] }, From e12e01461b005550854f833ca2b29b64f2d57fdf Mon Sep 17 00:00:00 2001 From: spjuhel Date: Fri, 19 Dec 2025 15:23:16 +0100 Subject: [PATCH 26/61] Adds option to have references instead of deep copies of members --- climada/trajectories/snapshot.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/climada/trajectories/snapshot.py b/climada/trajectories/snapshot.py index d8c78c0c20..cc4a26f871 100644 --- a/climada/trajectories/snapshot.py +++ b/climada/trajectories/snapshot.py @@ -52,6 +52,9 @@ class Snapshot: The date of the Snapshot, it can be an integer representing a year, a datetime object or a string representation of a datetime object with format "YYYY-MM-DD". + ref_only : bool, default False + Should the `Snapshot` contain deep copies of the Exposures, Hazard and Impfset (False) + or references only (True). Attributes ---------- @@ -80,10 +83,11 @@ def __init__( hazard: Hazard, impfset: ImpactFuncSet, date: int | datetime.date | str, + ref_only: bool = False, ) -> None: - self._exposure = copy.deepcopy(exposure) - self._hazard = copy.deepcopy(hazard) - self._impfset = copy.deepcopy(impfset) + self._exposure = exposure if ref_only else copy.deepcopy(exposure) + self._hazard = hazard if ref_only else copy.deepcopy(hazard) + self._impfset = impfset if ref_only else copy.deepcopy(impfset) self._measure = None self._date = self._convert_to_date(date) From e4ec92d197d4f992350164cfdfd12e74cc674a4b Mon Sep 17 00:00:00 2001 From: spjuhel Date: Fri, 19 Dec 2025 17:39:57 +0100 Subject: [PATCH 27/61] fixes init imports --- climada/trajectories/__init__.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/climada/trajectories/__init__.py b/climada/trajectories/__init__.py index 575b993969..2cfaa41d7d 100644 --- a/climada/trajectories/__init__.py +++ b/climada/trajectories/__init__.py @@ -21,6 +21,7 @@ """ +from .interpolated_trajectory import InterpolatedRiskTrajectory from .interpolation import AllLinearStrategy, ExponentialExposureStrategy from .snapshot import Snapshot from .static_trajectory import StaticRiskTrajectory @@ -30,4 +31,5 @@ "ExponentialExposureStrategy", "Snapshot", "StaticRiskTrajectory", + "InterpolatedRiskTrajectory", ] From 2a95391e76b29011e9dff8d88ac9710e7614c669 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Fri, 19 Dec 2025 17:40:16 +0100 Subject: [PATCH 28/61] waterfall time plot with negative contributions --- .../trajectories/interpolated_trajectory.py | 39 +++++++++++-------- 1 file changed, 22 insertions(+), 17 deletions(-) diff --git a/climada/trajectories/interpolated_trajectory.py b/climada/trajectories/interpolated_trajectory.py index 1b016e7ca8..114e3ce655 100644 --- a/climada/trajectories/interpolated_trajectory.py +++ b/climada/trajectories/interpolated_trajectory.py @@ -26,6 +26,7 @@ import logging from typing import cast +import matplotlib as mpl import matplotlib.dates as mdates import matplotlib.pyplot as plt import matplotlib.ticker as mticker @@ -735,31 +736,35 @@ def plot_time_waterfall( ) risk_contribution = risk_contribution[ [ - CONTRIBUTION_BASE_RISK_NAME, CONTRIBUTION_EXPOSURE_NAME, CONTRIBUTION_HAZARD_NAME, CONTRIBUTION_VULNERABILITY_NAME, CONTRIBUTION_INTERACTION_TERM_NAME, ] ] - risk_contribution[CONTRIBUTION_BASE_RISK_NAME] = risk_contribution.iloc[0][ - CONTRIBUTION_BASE_RISK_NAME - ] - # risk_contribution.plot(x=DATE_COL_NAME, ax=ax, kind="bar", stacked=True) + positive_contrib = ( + risk_contribution[risk_contribution > 0].dropna(how="all", axis=1).fillna(0) + ) # + base_risk.iloc[0] + negative_contrib = ( + risk_contribution[risk_contribution < 0].dropna(how="all", axis=1).fillna(0) + ) # + base_risk.iloc[0] + ax.stackplot( - risk_contribution.index.to_timestamp(), # type: ignore - [risk_contribution[col] for col in risk_contribution.columns], - labels=risk_contribution.columns, + positive_contrib.index.to_timestamp(), # type: ignore + [positive_contrib[col] for col in positive_contrib.columns], + labels=positive_contrib.columns, + colors=mpl.color_sequences["tab10"][1:], ) + if not (negative_contrib.empty): + ax.stackplot( + negative_contrib.index.to_timestamp(), # type: ignore + [negative_contrib[col] for col in negative_contrib.columns], + labels=negative_contrib.columns, + colors=mpl.color_sequences["tab10"][3:], + ) ax.legend() - # bottom = [0] * len(risk_contribution) - # for col in risk_contribution.columns: - # bottom = [b + v for b, v in zip(bottom, risk_contribution[col])] - # Construct y-axis label and title based on parameters - value_label = "USD" - title_label = ( - f"Risk between {self.start_date} and {self.end_date} (Average impact)" - ) + value_label = "Deviation from base risk" + title_label = f"Contributions to change in risk between {self.start_date} and {self.end_date} (Average)" locator = mdates.AutoDateLocator() formatter = mdates.ConciseDateFormatter(locator) @@ -769,7 +774,7 @@ def plot_time_waterfall( ax.yaxis.set_major_formatter(mticker.EngFormatter()) ax.set_title(title_label) ax.set_ylabel(value_label) - ax.set_ylim(0.0, 1.1 * ax.get_ylim()[1]) + ax.set_ylim(top=1.1 * ax.get_ylim()[1]) return fig, ax def plot_waterfall( From 50b4286499f4d8dbf4694719b2a93403c20d569b Mon Sep 17 00:00:00 2001 From: spjuhel Date: Fri, 19 Dec 2025 17:40:42 +0100 Subject: [PATCH 29/61] updates tutorial --- doc/user-guide/climada_trajectories.ipynb | 883 +++++++++++++--------- 1 file changed, 512 insertions(+), 371 deletions(-) diff --git a/doc/user-guide/climada_trajectories.ipynb b/doc/user-guide/climada_trajectories.ipynb index 9a32caea4e..caca6591e6 100644 --- a/doc/user-guide/climada_trajectories.ipynb +++ b/doc/user-guide/climada_trajectories.ipynb @@ -1,5 +1,15 @@ { "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "63d1b536-a7bf-4aff-812c-57f9a06c9856", + "metadata": {}, + "outputs": [], + "source": [ + "%autoreload 2" + ] + }, { "cell_type": "markdown", "id": "856ac388-9edb-497e-a2ff-a325f2a22562", @@ -103,7 +113,7 @@ "\n", "Think of `Snapshot` as a representation of risk at, or around, a specific date. Your hazard should be a probabilistic set of events that are representative for the designated date.\n", "\n", - "To be consistent with the intuitive idea of a snapshot, `Snapshot` objects are make a \"deep copy\" of the risk triplet and are immutable. \n", + "To be consistent with the intuitive idea of a snapshot, by default `Snapshot` objects make a \"deep copy\" of the risk triplet and are immutable.\n", "This means that they do not change once created (notably even if you change one of the component, e.g. the Hazard object, outside of the `Snapshot`).\n", "If you want a `Snapshot` with a different `Hazard`, you need to create a new one.\n", "\n", @@ -115,25 +125,18 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 61, "id": "dec203d1-943f-41d8-9542-009f288b937b", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "ERROR 1: PROJ: proj_create_from_database: Open of /home/sjuhel/miniforge3/envs/cb_refactoring/share/proj failed\n" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ - "2025-11-03 18:28:45,600 - climada.entity.exposures.base - INFO - Reading /home/sjuhel/climada/data/exposures/litpop/LitPop_150arcsec_HTI/v3/LitPop_150arcsec_HTI.hdf5\n", - "2025-11-03 18:28:51,465 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020/v2/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020.hdf5\n", - "2025-11-03 18:28:51,489 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", - "2025-11-03 18:28:51,491 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n" + "2025-12-19 17:28:13,750 - climada.entity.exposures.base - INFO - Reading /home/sjuhel/climada/data/exposures/litpop/LitPop_150arcsec_HTI/v3/LitPop_150arcsec_HTI.hdf5\n", + "2025-12-19 17:28:19,358 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020/v2/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020.hdf5\n", + "2025-12-19 17:28:19,380 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-12-19 17:28:19,383 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n" ] } ], @@ -173,7 +176,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 62, "id": "aa0becca-d334-40b4-86c0-1959c750f6d5", "metadata": {}, "outputs": [ @@ -181,7 +184,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2025-11-03 18:28:51,822 - climada.util.coordinates - INFO - Raster from resolution 0.04166665999999708 to 0.04166665999999708.\n" + "2025-12-19 17:28:19,415 - climada.util.coordinates - INFO - Raster from resolution 0.04166665999999708 to 0.04166665999999708.\n" ] }, { @@ -199,7 +202,7 @@ "" ] }, - "execution_count": 3, + "execution_count": 62, "metadata": {}, "output_type": "execute_result" }, @@ -253,17 +256,18 @@ "id": "8e8458c3-a3f9-4210-9de0-15293167f2f9", "metadata": {}, "source": [ - "Trajectories facilitate the evaluation of risk of multiple snapshot. There are two kinds of trajectories:\n", + "Trajectories facilitate the evaluation of risk of multiple snapshot. The module implements two kinds of trajectories:\n", "\n", "- `StaticRiskTrajectory`: which estimate the risk at each snaphot only, and regroups the results nicely.\n", - "- `InterpolatedRiskTrajectory`: which also includes the evolution of risk in between the snapshots through interpolation.\n", + "- `InterpolatedRiskTrajectory`: which also includes the evolution of risk in between the snapshots using interpolation.\n", "\n", - "So first, let us define `Snapshot` for a future point in time. We will increase the value of the exposure following a certain growth rate, and use future tropical cyclone data:" + "So first, let us define `Snapshot` for a future point in time. We will increase the value of the exposure following a certain growth rate, and use future tropical\n", + "cyclone data for the hazard, we will also change the vulnerability to be slightly lower in the future:" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 63, "id": "c516c861-c5c1-475b-82e2-c867c5c08ec9", "metadata": {}, "outputs": [ @@ -271,10 +275,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "2025-11-03 18:28:58,942 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2040/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2040.hdf5\n", - "2025-11-03 18:28:58,967 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", - "2025-11-03 18:28:58,968 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", - "2025-11-03 18:28:58,970 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n" + "2025-12-19 17:28:25,975 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2040/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2040.hdf5\n", + "2025-12-19 17:28:25,996 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-12-19 17:28:25,996 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-12-19 17:28:25,999 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n" ] } ], @@ -301,7 +305,7 @@ "exp_future.assign_centroids(haz_future, distance=\"approx\")\n", "impf_set = ImpactFuncSet(\n", " [\n", - " ImpfTropCyclone.from_emanuel_usa(v_half=60.0),\n", + " ImpfTropCyclone.from_emanuel_usa(v_half=78.0),\n", " ]\n", ")\n", "exp_future.gdf.rename(columns={\"impf_\": \"impf_TC\"}, inplace=True)\n", @@ -322,9 +326,15 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 64, "id": "e782ab8b", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "outputs": [], "source": [ "from climada.trajectories import StaticRiskTrajectory, InterpolatedRiskTrajectory\n", @@ -333,10 +343,52 @@ "interpolated_risk_traj = InterpolatedRiskTrajectory(snapcol)" ] }, + { + "cell_type": "code", + "execution_count": 65, + "id": "483767e7-9089-4b5e-a307-514ac302e773", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "remove-input" + ] + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%html\n", + "" + ] + }, { "cell_type": "markdown", "id": "2d7e8653-4ef9-40f5-8f8a-ef0e8b3b8a8c", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "source": [ "### Tidy format\n", "\n", @@ -370,7 +422,13 @@ { "cell_type": "markdown", "id": "ca8951cc-4a0a-4f3d-9c21-96dd6a835810", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "source": [ "### Static and Interpolated trajectories" ] @@ -385,10 +443,17 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 66, "id": "14453563", "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-12-19 17:28:26,135 - climada.trajectories.calc_risk_metrics - WARNING - No group id defined in the Exposures object. Per group aai will be empty.\n" + ] + }, { "data": { "text/html": [ @@ -410,8 +475,8 @@ " \n", " \n", " \n", - " group\n", " date\n", + " group\n", " measure\n", " metric\n", " unit\n", @@ -421,8 +486,8 @@ " \n", " \n", " 0\n", - " All\n", " 2018-01-01\n", + " All\n", " no_measure\n", " aai\n", " USD\n", @@ -430,124 +495,84 @@ " \n", " \n", " 1\n", - " All\n", " 2040-01-01\n", + " All\n", " no_measure\n", " aai\n", " USD\n", - " 6.946753e+08\n", + " 2.749295e+08\n", " \n", " \n", - " 0\n", - " All\n", + " 2\n", " 2018-01-01\n", + " All\n", " no_measure\n", " rp_20\n", " USD\n", " 1.420589e+08\n", " \n", " \n", - " 1\n", - " All\n", + " 3\n", " 2040-01-01\n", + " All\n", " no_measure\n", " rp_20\n", " USD\n", - " 8.253342e+08\n", + " 2.357976e+08\n", " \n", " \n", - " 2\n", - " All\n", + " 4\n", " 2018-01-01\n", + " All\n", " no_measure\n", " rp_50\n", " USD\n", " 3.059112e+09\n", " \n", " \n", - " 3\n", - " All\n", + " 5\n", " 2040-01-01\n", + " All\n", " no_measure\n", " rp_50\n", " USD\n", - " 1.368563e+10\n", + " 4.580720e+09\n", " \n", " \n", - " 4\n", - " All\n", + " 6\n", " 2018-01-01\n", + " All\n", " no_measure\n", " rp_100\n", " USD\n", " 5.719050e+09\n", " \n", " \n", - " 5\n", - " All\n", + " 7\n", " 2040-01-01\n", + " All\n", " no_measure\n", " rp_100\n", " USD\n", - " 2.330623e+10\n", - " \n", - " \n", - " 0\n", - " 0\n", - " 2018-01-01\n", - " no_measure\n", - " aai\n", - " USD\n", - " 2.721881e+05\n", - " \n", - " \n", - " 1\n", - " 1\n", - " 2018-01-01\n", - " no_measure\n", - " aai\n", - " USD\n", - " 1.837711e+08\n", - " \n", - " \n", - " 2\n", - " 0\n", - " 2040-01-01\n", - " no_measure\n", - " aai\n", - " USD\n", - " 1.040877e+06\n", - " \n", - " \n", - " 3\n", - " 1\n", - " 2040-01-01\n", - " no_measure\n", - " aai\n", - " USD\n", - " 6.936344e+08\n", + " 8.477125e+09\n", " \n", " \n", "\n", "" ], "text/plain": [ - " group date measure metric unit risk\n", - "0 All 2018-01-01 no_measure aai USD 1.840432e+08\n", - "1 All 2040-01-01 no_measure aai USD 6.946753e+08\n", - "0 All 2018-01-01 no_measure rp_20 USD 1.420589e+08\n", - "1 All 2040-01-01 no_measure rp_20 USD 8.253342e+08\n", - "2 All 2018-01-01 no_measure rp_50 USD 3.059112e+09\n", - "3 All 2040-01-01 no_measure rp_50 USD 1.368563e+10\n", - "4 All 2018-01-01 no_measure rp_100 USD 5.719050e+09\n", - "5 All 2040-01-01 no_measure rp_100 USD 2.330623e+10\n", - "0 0 2018-01-01 no_measure aai USD 2.721881e+05\n", - "1 1 2018-01-01 no_measure aai USD 1.837711e+08\n", - "2 0 2040-01-01 no_measure aai USD 1.040877e+06\n", - "3 1 2040-01-01 no_measure aai USD 6.936344e+08" + " date group measure metric unit risk\n", + "0 2018-01-01 All no_measure aai USD 1.840432e+08\n", + "1 2040-01-01 All no_measure aai USD 2.749295e+08\n", + "2 2018-01-01 All no_measure rp_20 USD 1.420589e+08\n", + "3 2040-01-01 All no_measure rp_20 USD 2.357976e+08\n", + "4 2018-01-01 All no_measure rp_50 USD 3.059112e+09\n", + "5 2040-01-01 All no_measure rp_50 USD 4.580720e+09\n", + "6 2018-01-01 All no_measure rp_100 USD 5.719050e+09\n", + "7 2040-01-01 All no_measure rp_100 USD 8.477125e+09" ] }, - "execution_count": 6, + "execution_count": 66, "metadata": {}, "output_type": "execute_result" } @@ -557,8 +582,9 @@ ] }, { + "attachments": {}, "cell_type": "markdown", - "id": "82a7a819", + "id": "cd169d1b-741c-471c-b402-391096e20613", "metadata": {}, "source": [ " The `InterpolatedRiskTrajectory` object goes further and computes the metrics for all the dates between the different snapshots in the given collection for a given time resolution (one year by default). In this example, from the snapshot in 2018 to the one in 2040. \n", @@ -571,15 +597,22 @@ "* Average Annual Impact (aai) both for all exposure points (group == \"All\") and specific groups of exposure points (defined by a \"group_id\" in the exposure).\n", "* Estimated impact for different return periods (20, 50 and 100 by default)\n", "\n", - "Both as totals over the whole period:" + "Both as average over the whole period:" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 67, "id": "9c485dc4-c009-46fb-aa4a-603bc9dcf5b4", "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-12-19 17:28:26,669 - climada.trajectories.calc_risk_metrics - WARNING - No group id defined in at least one of the Exposures object. Per group aai will be empty.\n" + ] + }, { "data": { "text/html": [ @@ -605,6 +638,7 @@ " group\n", " measure\n", " metric\n", + " unit\n", " risk\n", " \n", " \n", @@ -612,66 +646,52 @@ " \n", " 0\n", " 2018 to 2040\n", - " 0\n", - " no_measure\n", - " aai\n", - " 1.414905e+07\n", - " \n", - " \n", - " 1\n", - " 2018 to 2040\n", - " 1\n", - " no_measure\n", - " aai\n", - " 9.465607e+09\n", - " \n", - " \n", - " 2\n", - " 2018 to 2040\n", " All\n", " no_measure\n", " aai\n", - " 9.479757e+09\n", + " USD\n", + " 2.309016e+08\n", " \n", " \n", - " 3\n", + " 1\n", " 2018 to 2040\n", " All\n", " no_measure\n", " rp_100\n", - " 1.355590e+10\n", + " USD\n", + " 7.148372e+09\n", " \n", " \n", - " 4\n", + " 2\n", " 2018 to 2040\n", " All\n", " no_measure\n", " rp_20\n", - " 4.334959e+08\n", + " USD\n", + " 1.896739e+08\n", " \n", " \n", - " 5\n", + " 3\n", " 2018 to 2040\n", " All\n", " no_measure\n", " rp_50\n", - " 7.748316e+09\n", + " USD\n", + " 3.847129e+09\n", " \n", " \n", "\n", "" ], "text/plain": [ - " period group measure metric risk\n", - "0 2018 to 2040 0 no_measure aai 1.414905e+07\n", - "1 2018 to 2040 1 no_measure aai 9.465607e+09\n", - "2 2018 to 2040 All no_measure aai 9.479757e+09\n", - "3 2018 to 2040 All no_measure rp_100 1.355590e+10\n", - "4 2018 to 2040 All no_measure rp_20 4.334959e+08\n", - "5 2018 to 2040 All no_measure rp_50 7.748316e+09" + " period group measure metric unit risk\n", + "0 2018 to 2040 All no_measure aai USD 2.309016e+08\n", + "1 2018 to 2040 All no_measure rp_100 USD 7.148372e+09\n", + "2 2018 to 2040 All no_measure rp_20 USD 1.896739e+08\n", + "3 2018 to 2040 All no_measure rp_50 USD 3.847129e+09" ] }, - "execution_count": 7, + "execution_count": 67, "metadata": {}, "output_type": "execute_result" } @@ -690,10 +710,17 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 68, "id": "6b73a589-9ee4-41e8-90e0-910bfe4dd8fc", "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-12-19 17:28:26,700 - climada.trajectories.calc_risk_metrics - WARNING - No group id defined in at least one of the Exposures object. Per group aai will be empty.\n" + ] + }, { "data": { "text/html": [ @@ -715,8 +742,8 @@ " \n", " \n", " \n", - " group\n", " date\n", + " group\n", " measure\n", " metric\n", " unit\n", @@ -726,8 +753,8 @@ " \n", " \n", " 0\n", - " All\n", " 2018\n", + " All\n", " no_measure\n", " aai\n", " USD\n", @@ -735,39 +762,39 @@ " \n", " \n", " 1\n", - " All\n", " 2019\n", + " All\n", " no_measure\n", " aai\n", " USD\n", - " 2.000396e+08\n", + " 1.885312e+08\n", " \n", " \n", " 2\n", - " All\n", " 2020\n", + " All\n", " no_measure\n", " aai\n", " USD\n", - " 2.166844e+08\n", + " 1.929908e+08\n", " \n", " \n", " 3\n", - " All\n", " 2021\n", + " All\n", " no_measure\n", " aai\n", " USD\n", - " 2.339834e+08\n", + " 1.974211e+08\n", " \n", " \n", " 4\n", - " All\n", " 2022\n", + " All\n", " no_measure\n", " aai\n", " USD\n", - " 2.519424e+08\n", + " 2.018214e+08\n", " \n", " \n", " ...\n", @@ -779,73 +806,73 @@ " ...\n", " \n", " \n", - " 41\n", - " 1\n", - " 2038\n", + " 87\n", + " 2036\n", + " All\n", " no_measure\n", - " aai\n", + " rp_100\n", " USD\n", - " 6.328297e+08\n", + " 8.025179e+09\n", " \n", " \n", - " 42\n", - " 0\n", - " 2039\n", + " 88\n", + " 2037\n", + " All\n", " no_measure\n", - " aai\n", + " rp_100\n", " USD\n", - " 9.943382e+05\n", + " 8.140512e+09\n", " \n", " \n", - " 43\n", - " 1\n", - " 2039\n", + " 89\n", + " 2038\n", + " All\n", " no_measure\n", - " aai\n", + " rp_100\n", " USD\n", - " 6.628505e+08\n", + " 8.254300e+09\n", " \n", " \n", - " 44\n", - " 0\n", - " 2040\n", + " 90\n", + " 2039\n", + " All\n", " no_measure\n", - " aai\n", + " rp_100\n", " USD\n", - " 1.040877e+06\n", + " 8.366514e+09\n", " \n", " \n", - " 45\n", - " 1\n", + " 91\n", " 2040\n", + " All\n", " no_measure\n", - " aai\n", + " rp_100\n", " USD\n", - " 6.936344e+08\n", + " 8.477125e+09\n", " \n", " \n", "\n", - "

138 rows × 6 columns

\n", + "

92 rows × 6 columns

\n", "" ], "text/plain": [ - " group date measure metric unit risk\n", - "0 All 2018 no_measure aai USD 1.840432e+08\n", - "1 All 2019 no_measure aai USD 2.000396e+08\n", - "2 All 2020 no_measure aai USD 2.166844e+08\n", - "3 All 2021 no_measure aai USD 2.339834e+08\n", - "4 All 2022 no_measure aai USD 2.519424e+08\n", - ".. ... ... ... ... ... ...\n", - "41 1 2038 no_measure aai USD 6.328297e+08\n", - "42 0 2039 no_measure aai USD 9.943382e+05\n", - "43 1 2039 no_measure aai USD 6.628505e+08\n", - "44 0 2040 no_measure aai USD 1.040877e+06\n", - "45 1 2040 no_measure aai USD 6.936344e+08\n", + " date group measure metric unit risk\n", + "0 2018 All no_measure aai USD 1.840432e+08\n", + "1 2019 All no_measure aai USD 1.885312e+08\n", + "2 2020 All no_measure aai USD 1.929908e+08\n", + "3 2021 All no_measure aai USD 1.974211e+08\n", + "4 2022 All no_measure aai USD 2.018214e+08\n", + ".. ... ... ... ... ... ...\n", + "87 2036 All no_measure rp_100 USD 8.025179e+09\n", + "88 2037 All no_measure rp_100 USD 8.140512e+09\n", + "89 2038 All no_measure rp_100 USD 8.254300e+09\n", + "90 2039 All no_measure rp_100 USD 8.366514e+09\n", + "91 2040 All no_measure rp_100 USD 8.477125e+09\n", "\n", - "[138 rows x 6 columns]" + "[92 rows x 6 columns]" ] }, - "execution_count": 8, + "execution_count": 68, "metadata": {}, "output_type": "execute_result" } @@ -865,12 +892,12 @@ " - The 'exposure contribution', i.e., the additional risks due to change in exposure (only)\n", " - The 'hazard contribution', i.e., the additional risks due to change in hazard (only)\n", " - The 'vulnerability contribution', i.e., the additional risks due to change in vulnerability (only)\n", - " - The 'interaction contribution', i.e., the additional risks due to the interaction term" + " - The 'interaction contribution', i.e., the additional risks due to the interaction term (between exposure, hazard and vulnerability)" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 69, "id": "08c226a4-944b-4301-acfa-602adde980a5", "metadata": {}, "outputs": [ @@ -880,13 +907,13 @@ "" ] }, - "execution_count": 9, + "execution_count": 69, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAt0AAAKKCAYAAADhvOe9AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAjbJJREFUeJzt3QeYE9X6x/GX3jvSpCtVUCmKYgFRKaKgqKDSBCzYrihYsIIFbCBebFelStUr2BVQigKiiCJFREBAUBBFei/5P79zTf5JNrvsLjs7u8n38zx5dneSTSZzZiZvzrznPTkCgUDAAAAAAHgmp3dPDQAAAICgGwAAAMgE9HQDAAAAHiPoBgAAADxG0A0AAAB4jKAbAAAA8BhBNwAAAOAxgm4AAADAYwTdAAAAgMcSNugePXq05ciRI9nb7NmzPXvtqlWr2vXXX5+u/50wYYINGzYs5n1a7wEDBlhW9vnnn1vjxo2tUKFCbn3ffffdmI/7/fff3XtZvHhxkvu07QoXLmzx6uWXX3b7Z1pof43eb73YTvPnz3ftsn379iT3NW/e3N2yu9Tuo2ltj9SeGy699NI0v97x/m9yBg0alK73n13MnDnTevbsabVr13btfeKJJ1r79u1t0aJFMR//3Xff2UUXXeSOq+LFi1uHDh3sl19+SfI4naN1X7Vq1dx+kNJxMWvWLLv44outTJky7nlPPfVU+/e//21HjhyxrCQ1ny8///yz9evXzxo1auS2T8mSJe2cc86x//73vzEfv2XLFneeKl26tBUsWNDOPvtsd/ylZN++fVazZk23Ps8991yS+w8dOmQDBw50x0O+fPlc2w4fPjxN7/Wxxx6zunXr2tGjR5Pc99dff7nn1et/++23aXreRImr1q1bZ9nd/BQ+684//3zr06dP+p44kKBGjRoV0NvXz6+++irJbceOHZ69dpUqVQLdu3dP1/+2bdvW/X8sWu8NGzYEsqqjR48GSpYsGTjrrLMCn332mVvfv//+O+ZjFy5cGGqfaNp2hQoVCsSrU045JdCsWbM0/Y/21+j91ovt9Oyzz7p2Wbt2bZL7li9f7m7ZWVr20bS2R2ro2NYxnh7H87/J0f6T3nNVdnDVVVcFLrjggsDLL78cmD17duDtt992bZ87d+7A559/HvHYFStWBIoUKRI477zzAh999FHgnXfeccdqhQoVAlu2bIl4bK1atQINGzYM9OzZM3DCCSckezzPmDEjkDNnzkDz5s0D7777rvv7jjvucMfYv/71r0BWonV69NFHU3zM8OHDA7Vr1w48+eSTgenTpwc+/vhjt//ofwcOHBjx2P379wfq1asXqFixYmDcuHHu8e3bt3fbXm2RnL59+7ptrufU+SjaDTfcEMiXL1/gmWeeCcyaNStw//33B3LkyOHWKTV+++03t99rX4hl6NCh7rV16927d6qeM1HoONB5T22b3T2bwmed9s88efIEfvrppzQ/b8IH3QruMptXQXdWt3HjRrcTP/3008d8LEF36oLugwcPBg4dOhTzvswOuuNBWvbRtLZHahB0Z64//vgjybJdu3YFypYtG7jwwgsjll999dWB0qVLR3yRWrdunfvwvffeeyMee+TIkVR9ie7cubMLEHfv3h2xvGXLloGiRYsGslvQ/eeff7ovrrE+twoWLBgRjL300kvuOefPnx9apmOnbt26gTPPPDPm83/99deBvHnzuoA4VtC9bNkyF2APGjQoYvmNN94YKFCgQGDr1q3HfJ9qyxNPPDGiDcPpi0KZMmUCZ5xxRqBYsWKBvXv3BjLbnj17Mv01E82zx/is036g/SqtEja9JLUaNGhg5513XpLluvSnS5G6hBj0999/26233uqW582b16pXr24PPvigHThwIF2XZKIvUesS5UcffWTr16+PSIVJ6fLfsmXL3OXSEiVKWP78+e3000+3MWPGxHydiRMnuvWtUKGCFS1a1F1GXblyZaq209y5c+3CCy+0IkWKuMuETZs2desapPWqWLGi+/2+++5zr6fLf7Fofc444wz3e48ePULvM/q9rV692i655BJ3SbZSpUrWt2/fJNv64MGD9sQTT7hLjLokeMIJJ7jn/PPPP1P1vr7++mu77LLLrFSpUm77nXTSSUkuKx3rvYe3sS4l33LLLe5yqp5T+49SaYK0TZYvX25z5swJve/gdgq205tvvuneq/YzvSdth5TSGfR8Wj9dPtf7v/32223v3r2h+7Xf6X9jpbSEb3f9vOeee9zvwcvm0ftn9GX01B4Teh6tl95bnTp13HY87bTT7MMPP4x4nNrtpptucu0dbE9dvv7ss88ydR9NT3soDeGaa65xx5ceV7ZsWbc+sVKootONcufObY8++qilxtSpU12KgvZXbW+lKkTbuXOnSwNQO6pdtO7ar/fs2RN6jNZff+t8EWxrta/+V+vz7LPPRlxyz5kzpxUrVswOHz4cWv6vf/3LtdH/Yrb/UVvpfesco3ZQ+8VKKVi1apVdd911Lu1C20v7xUsvvZSh5y49dzSdT5RasGHDhtAyvSfti1deeaV7/qAqVarYBRdc4LZ5OG2L1MiTJ4/b/gUKFIhYrtQMtd+xzJgxw53ftd/q8SeffLLdfPPNrj3Cad/WdtK54Nprr3XtpP1PqTU7duyIeKza98Ybb3TnJ22L1q1bu7SR1NB5LfwzKejMM8905xydD4K0zWrVquVSSoK0X3Xp0sW++eYb++2335Kcy7W+t912m0v/ikWpUNrXdI4Pp7+VlvLpp5+muP56jREjRrj9LlYb6vNAn6ldu3Z120jb7p133gndr2NI51ltw2idOnVy21zpL0GTJ09271//o23dqlUr+/777yP+L5gmuHTpUmvZsqU7f+n4SUv7y3vvvefOCzqWdF544YUXQvtFOG0/nXMUK2i/VOxw1VVXxUyjSk0so3NGvXr17KuvvnLnXD2nzqujRo1y9+sc3LBhQ3cuqF+/fpI2Cq6jtos+L3X8af/VfhL9Oa7tqW1Uvnx59zo6Z9x///0R57XUfLYf67NOtA8o3XfXrl3H3C7RGzih00sWLFjgvl2H3w4fPhx63AsvvOAe9/PPP0f8vy6bafn777/v/t63b1/g1FNPdT2Lzz33nLtU9vDDD7tLZZdcckmKPd3BdYn+RqVLY1qun6JL9+ecc06gXLlyEakwyfVE6NKHLoeedNJJgbFjx7pLotdee22Snrzg61StWtX1vOhxEydODFSuXDlQo0aNiO0RS/BSS6NGjQKTJ092l0nVU6Meh0mTJrnHKO1lypQp7nV0+VTr/d1338V8PvUkBbfJQw89FHqfwdQZbTv1dtSpU8dta6UBPPLII+71wi9hqqeidevWrk20XJdu33jjDdeLod6UY/VQfPrpp+59qV1Hjx4dmDlzZmDkyJGBa665Jk3vPbyNq1ev7t7/tGnT3LqUKFHCXd4O0jbRYxo0aBB638HtFGwnrb8ui2vf+/DDD13vTfS+Er6d1I7By70DBgxw++Sll14aepz2u+RSecL3KW3/4KVvtWV0KpZ688J79NJyTAT3P/VwvfXWW+740iV3PXbNmjWhx7Vq1cpdrn/ttdfcttf2VtuHb+vM2EfT0x5KOTj55JMDb775ZmDOnDkuPUGXysMfE97TrR5D3a/1jtU20fS/Whe1t/ZTbUMdz9E9guolO/30012vrS6V6/jReU69di1atAj1VOr9q3dQbRVs62D6kFIwtP2CtA3z58/vtue8efNCy3WMduzYMfS33rsec/nll7tt/cEHH7h9MVeuXG49gvQ6Wp/69eu7c5f2HW0LpWJoH86oc1cs27dvd699xRVXRJxL9TrqnY3Wr18/9560v8eSUk+3Pn/U033bbbe5tIZt27a596s21zFzLK+88kpg8ODBbt/TPjVmzJjAaaed5vY1XXUJ0jGs9ddyHS86F6rt9do9evQIPU5tr/ORlgfPGfpfnZNS09OdHB3LOm7D20OfY7p6EE3HkF5L58hwDz74oGtnXRUInrOie7p1btbrRNP/6PH9+/dPcT2/+OIL9zgdO7GoZ1P3a//cuXOn673Xewv64Ycf3P2vv/56xP+pXbVN77777tAybV/tN0pB0nvW8XD22We782V4mp7O49of9N7V1kp7Cm6b1Lb/J598Ekpjmjp1qrtS0KRJE/ec0WGg3qNeT8ebPgMnTJjgUoZ09Wfz5s0pbr9YsYz2/VKlSrl1GjFihFt3HfPBlCMd4zpmtc11XtF20rEQve/q/HbPPfe4/9e+q+2kz8nw9/n4448Hnn/+eXce0Dn/1VdfDVSrVi3iMzY1n+3H+qwLXnUJjwFTK+GD7lg3fQAE/fXXXy5weeCBByI2nD5ItBMGLyWrcfW/ChjCKbjVcp28jjfoPlZ6SfRJUTuQduBff/014nFt2rRxJwt9uIS/TnQgpPei5eGBfSw6UHS5TZdlg3RyDebrBT/EkztRpie9JNa21vrrwA7SgazHKbiJ9dzK40yJvqzoltyHaVree7CNb7311oj/V96hlm/atOmYH9LBdjr//POTvS866NYyBVThdLLX8rlz56Yp6D7WJbfooDstx4T+1vGkD7IgneD1QaEPlaDChQsH+vTpE0grL/bRtLSHziP6e9iwYSk+ZzDo1hfCK6+80gV/4cHosf5XH+KLFy+OWH7xxRe7VIXgJWltT23X6NS6//73v0kCjuRyuvVlWAF5MF1AebT6gqsPseAXX31w6vn0BUn0+sqXv+yyyyKeS1+OFSiEpxToy5XaJTon/vbbb3fBfTDP/njPXbEoeNeXvW+//Ta0TF8k9Hw6p0RTKoPu+/3339M1RkPPHcxRDn7+6LyQVtqH9Xm0fv169zzvvfdeksAl+nl1PtL2DO7/Cs5SOmekJ+hWABrrORX03HzzzUker3QTPV7BXtD333/vHq9gKaXjVPt6+GdAOH2O33TTTSmua/DcFCu41P6r40jnkiAdGzrmVq9eHVqmXP6mTZtG/K8+a/S8S5cudX/rM1n7mAK7cDo/6ctI+BfV4HlcQWF621+pMJUqVQocOHAg4rUUDIcH3Tpe9PeQIUMinltBqI736DSq1AbdWhZ+PG3dutXt53rO8ABb5y499t///neSffeuu+6KeK3x48e75RoPkNL20JcRPU5fiNLy2X6s9BIF+2r7++67L5AWCZ9eMnbsWFu4cGHETZcdgnTpQZcgdIk1OJJ527Zt7lJNt27d3OWw4Ch4XSLSZZhwwSolxxqR7QWtky5D6VJ89DrpUp8u94Rr165dxN+6FCVKZ0mOLttoe+l9h1fKyJUrl7v8snHjxlSnqKSFLvWoXaLXN3xddTlYl2n1OF0eDt502axcuXIpVpbQ5dQ1a9ZYr169kr3Mm573np5tHE2XuNOic+fOEX/r0qko1cVLaT0mdJlel06DdClWl//Dt40uU+sSplKGFixYEHGp1q99NDXtoSoOunyplIyhQ4e6S6WxKiPI1q1brUWLFu4SezAlJrVOOeUUl5YT3d663K3KG8HjQpd7dRyEHxe6tJ3aiitaJ12u1wj/YMqIKnAorUOXvIPLRMtEj1V6Qffu3SNeV9tBKQw696qt9u/f7/aNK664wl1yDn+s0sl0v9o+o48refjhh238+PH2/PPPuwoc0WKlTqTmvuSoSorep17rgw8+cMdM//797aGHHrLHH3/8mP+v6h+9e/d253h9FildRSkvsmLFiiSPj7WdtD31POHnhOTOGWn1ySefuHQQHXt33HFHuran2l1pJUrP0D56LMfTRkr102OUJhPtrbfecseR1iVIv6vPIJgqEUxl0b4efk7R/UqZ1HEn06ZNc+9LMUT4/q3PmmbNmsU8BmOdZ1LT/jqmVGXl8ssvd6lMQToXRn+G6tyg96/UjfD10uelzivpreqmdI/w46lkyZLu3K5zkFLCgpQOktxxG71PduzY0b3n8M8xpcBoX9X66vyu7aHtGb49UvPZnhp6bsUX0WlQx/K/iDGBqZGTyw8LP7CUt6UPEx30yh9UTmp42T99UKqhow9q7VjaMXR/ZtNramePFtzJo9dJXzDCKfdL9OGaHH0B0UknLa+TEfRhHH3AaH31ARL0xx9/uHI/4SeacLHy3oKCuWLBHN+Meu/p2cbRYr1ecrTvRb+m9tNY65bR0npMRK9ncPuEbxvl7CngfuONN1yApA8OBS3PPPNM6H1l9j6amvbQNlAgqVJkWlflgOuDRx8kTz75ZMSXDX0oaJ2VMxr8kE6tWNsgur11XCjvXB8aaT0ugpSbqWNQgbU+8JXDqaBbX2BUnm337t3uPuWOKicy+LoS/SUsnIJy5dLqg17Pk1ypt+h1zIjjSmXmtG+pPTS+INbzx9pPtM5qX30Ap5UCUn25VH6zgoTgl09tA+WVav/QNoxFX1aUv6pAUceC8mH1JVfLzzrrrJjv/VjbSe8vpXNGWiiwVA6u9gt9kYk+D+g1ktueouMjWH5RwZSC3mD5tmDOtM73WqbjR9tPzxlrjIQCT+VrB58zOdoOOi6CbRFOud76zNEXxOB66EuL8pPVEaD9R/+nNtN4CS0bPHiw/fjjj+4LpfKkg4LHQnDsUrTofHIda+FjCdLS/sHzn/azaNHLtF7JPVaS2xePJdZ2z5s3b5Llwc/q8M/x5PbB4H4a3Id0ztH4O7WRjmOVldR209gM7YfB7ZGaz/bU0mul5Rzj1vu4XzUBKNDWh7O+rep3/WzSpIkbbBOkxldvmnbY8JOLvonqAyTWN+egYPAYPbgsNR9+KdE6bdq0Kcny4MC9lNYptTTIQicIr18nPYKDFZMbPBMe6ETT4C9REJHV3ntaetS07+mkFP4hunnzZvczuCy5/e94g/LjOSaSo//Rh7Buv/76q73//vtuoIyeM7l29rqdUtse6oHSB3cwsFYQocBKwcCrr74aepwGVl199dWuJ0ZeeeWVVA/MC7ZtrGXB9tZ71SCjkSNHxnyO1GwLfTiee+65LrDWh5c+EPWhH/xQVo+YvmSE1w0PPq8CaQUFsejDXvtG8CqEgtJYgoF8RlHApLbQ7YEHHkhyv65SaJtpMFs0LdMAtvT0milA1MDG6CBPwZiCJ/XOJRfoaEDfDz/84II7XT0I0heq9NI+ktI5Iy0Bt3pW1cuoDqtYHR/aX5LbnhL8wqn3qQGLNWrUSPJYBZu66cqRek31nJMmTXLrGx6kRT9ncrSP6nhUkK4ANkjHq646SeXKlZN9z7oSo/ONBjfqKrqCP8UL2jfUzuGvI6pfHuyZTus5JrXtr/XR/wcD/XDR7RocCPvll1+GvpCFi7Uss2zevNkN+A6K3k91lUjnc517gr3bEl1nOzWf7amlLzRp/exI+PSS1Ah+AGhktHZGXaoJv8QUvNyqb1rRE0nowAven5xghYQlS5ZELFdAcayev5ToNYM7YvQ66Rtgch98aaETk76ATJkyJWK99IExbtw494Gsb5xplZ6eqmj6wNdBqUozupoRfdPI+eRonfVBq8AkueozXr7343nf0dTLFE4jriVYaUSBjj4Uovc/pVDFWjdJzfodzzGRGvrwU4+ketKCqROZ2U7HQ6+nFAIFCbHWXR+iCh70ga1L0KmdKEXVKfRBHN3e+oKpCgHB40KXV/VhFeu4CK/YktK+qLQRpUcoqAqmkGhb67yiwFrnneByUZUS9Qar5y/W6+qm4EznJvX2KpBST2Ksx8W6KpJeSuNQsK32SK5CjHrVdCle+1B4tQJ98dPl7fAqVmmhzhx9nkS3bzD1L6XeuGAgFh0I/ec//7H00nZP6ZyRGtOnT3cBt76U6dhPLlDTFaqffvopIp1TgZSOSR2vwatQ+lKtbRx+09VmUWqF/taXHlGwq+0SXaFLgam+NKmXOiWqciU6PsIFvyy//vrrSdbl448/dr3j4V9ilWKi/V/36f3ovYZfCVHnnfYpvU5yx8KxpLb9dUzq+dQW+kIRpHNzdHUonRvUSaKUiVjrpPOVX8ZH7ZPqtND+EvwcS+32SM1ne/jzJHf+U/uqRz688zU1Er6nW98Ww0tcBalRgt+IREH2008/7fKFdPAqvyycPhhVzkoflrrUqp1T34w1o5u+/YZ/+ERTr4YCQF2S0rrom6kuNwa/WYfT8+rEr94v5UipByy5A1QfIDqodCJ95JFH3KUc7bgq0aNL3Cq7kxF0CU2Bj15H70EfnLqUpm2rk2N6ch2DPUtaX6UAKY1AJ+Hw/K9jUXk2/b+2/5133unygXVy1DdcnSx1gtbJMDlqT33QKoi46667XJCnD1n1aARPAF6892BvjVIp1MulgDi9Jzutz5AhQ9wJVvuZcg3V+9KmTRv3oSjBHD6dhLTdlbunfOJYH7TB9VC5Ke3r2p7ad2NdNTieYyIW9XZpO+sY1IejXlOXbdXDfaygx4t2Sgt9odEXBPVgq8dOr68vxFquoCIWpWEoANVPnfi1nsmlSgXp+FDeroJIpb3oA19pcTp36blEZbEUKGtWNe3XCmz1BUT7tgImpb4o6BG1mXqOlG+s59M2D35Z1ZcmBYvq0Q4PctSuOvdomyo3PUjHsIJx7Q9KIdD7UqqRLvfqi4J+6rwW3L+0f+pysUps6ouAgl314gVznzOCjg2dGxWMtW3bNkmueHjHhHrDdQwpMFGb6QNX/6ueLm2zcAqkg2XTlAqhQCY4K6OeI9i7qe2vsoo6z6jUm9pI21Prpe0YnZ8fTseAjleti55f53dtm2BOfXooXUH7xb333ut6e/XZMm/ePFcWMzV0fCvgVi+zrhhEp3ooQAmmSegzVecHHRNPPfWU2xd0TCoXOrwEqN5nMBgOCm5bvf/wMqUa06ArRNr/1Fmmba19+rXXXnPnvWOllwSfS/tBcFyAPpPVUaDPoRtuuCHm/6n91EmmfVhxg7ajvjCpXKp6aKNLGGp/VqqZylwqdUb7nz731Rutc68CZe1vKUlL++u1tH8r2NdnoY5bjS/RMRlexlFfjFWSVeurfVj7gtZFVwnVtjof6Hj0w5QpU9wXFZ3H1bmgKxw6PpTbHUx50zbUFzG1vz6b9Dkd3QmR2s/2Y33WBc8VwS+qqRZIUMFRtsndokv+iEYk6z6Nbo9FI3I1Q1X58uXdyGRVE1CJoujZmWJNjqOShMEJEVTySKOaVfYmuiKFRu2rPFnx4sXdyNnwJow1ulyjpVUtQFUQNHpbVQKiq1QEKwBEz8CVUlWLaF9++aUrN6ZqBxqRrBHeKgcW6/lSUxlCVClApYo0aj38vSU36UtwlHM4jV5W6S29b43SV/ULPadGza9ateqY66DR3Kr2ou2nSjAa8Rw9ijo17z24v0VXjIhVdUQTbmhfULnHYKmk8MfGmiktueolWqclS5a4UlFaN1WPuOWWW5JMxqEqEapAoQoi+h/tM1qPWPuU9mlVW1AFjPDXjK5ekpZjQs+jsmnRwo8V/Y+eSxUydJzo/ahSgdYvNZNFZPQ+mpb20CQs119/vdv39PraD/U+VN4qvIxarMlx9Bx6vKqDpFTmMvi/qkKiihk63lUSTOW1oqn9VYFE20+PC5bn074dXrlB1QRUplTVjvR+wttX1QFUdlDLwysQBCt9qIpDLKomoPXUvqhjW2UO9Xes84/Kqel+PU7nRZ2Dn3jiiQw7dwUrKyR3i6YKDJo0R9tD+6BKH4ZXroiuOBHrFr1Oqq507rnnum2pfUNtp9Jn0cdoLD/++KOr2KFzhcqPqgSfKmNEH7fBc6MmrzlWtQlVtdJ212eM3qeeP1gy8VjVS4Kvk9wt/Pwk2te6devm9gWdn3VMqpzhsaR0nKqqhNZDZSO1b9esWTOiGsaxaMbR8Go4Ki96rMpDqqoSXfVDFc+0TFVDkptoR8+tcnbal/T5omNYn+/hFYtSmuQste0vKhWoYzxYRvapp55ys57q/6KpUopKCgbPlfrcUzuFVyBJS/US7dOpnQjMoj4LgvvUokWL3OeSzoV6vyp/HD25lSrfqOyi9ludL/SZprKvsY671Hy2J/dZJ127dnXbM61y/PMmAQAAEpquAulKtipohOcQxxtVflIevN6jrgZkVQMGDHC9/rqK4Nf4sGi6eqWriqpypAHvaUFONwAAgJlLVVNailLS4onSbpS2qNmOgzM3aqCuUomQNgq2lZISnTaUGgmf0w0AACAai6ABk8rR1liH1FYOyuo0JkLjWdRjrPxkDazWQM+0jq2BuXEJGpwbnKclLUgvAQAAADwWH1/hAAAAgCyMoBsAAADwGEE3AAAA4DEGUmYADbbQ7EQqmu71JBsAAABIO1XJ1qBSlfzzY5AsQXcGUMBdqVKljHgqAAAAeGjDhg1u1tDMRtCdAYLTgqoRg1PcAgAAIOvYuXOn6yQNxm2ZjaA7AwRTShRwE3QDAABkXTl8SgVmICUAAADgMYJuAAAAwGME3QAAAIDHCLoBAAAAjxF0AwAAAB4j6AYAAAA8RtANAAAAeIygGwAAAPAYQTcAAADgMYJuAAAAwGME3QAAAIDHCLoBAAAAjxF0AwAAAB4j6AYAAAA8RtANAAAAeIygGwAAAPAYQTcAAADgMYJuAAAAwGME3QAAAIDHCLoBJLTBgwfbGWecYUWKFLEyZcrY5ZdfbitXrvT8dd955x2rW7eu5cuXz/2cOnVqxP1Vq1a1HDlyJLnddtttnq8bACDjEXQDSGhz5sxxgeyCBQtsxowZdvjwYWvZsqXt2bMn3c85evRoa968ebL3f/XVV9apUyfr2rWr/fDDD+5nx44d7euvvw49ZuHChbZp06bQTesmV199dbrXCwDgnxyBQCDg4+vHhZ07d1qxYsVsx44dVrRoUb9XB8Bx+PPPP12Pt4Lx888/3y07ePCgPfTQQzZ+/Hjbvn271atXz55++ulkA2sF3brNnj075v0KuHXe+OSTT0LLWrdubSVKlLCJEyfG/J8+ffrYhx9+aKtWrXI93gCA7BWv0dMNAGF0MpaSJUuGlvXo0cPmzZtnkyZNsiVLlrjeZgXJCoDTQz3d6k0P16pVK5s/f37MxyvoHzdunPXs2ZOAGwCyKYJuAPiHLvzdfffddu6557rebFmzZo3rfX777bftvPPOs5NOOsn69evnHjNq1Kh0bbvNmzdb2bJlI5bpby2P5d1333U97Ndffz1tBQDZVG6/VwAAsorbb7/d9WTPnTs3tOy7775zwXjNmjUjHnvgwAErVaqU+/3XX391gyGDlBd+6NAhK1y4cGhZly5d7NVXXw39HZ0iotdILm1kxIgR1qZNG6tQoUIGvEsAgB8IugHAzO644w57//337YsvvrCKFSuGtsnRo0ctV65ctmjRIvczXDCoVjC8ePHi0PIpU6a46iTKAQ8Kzx8sV65ckl7tLVu2JOn9lvXr19tnn33mnhMAkH0RdANIaOphVsCtkn0a+FitWrWI+xs0aGBHjhxxQbHSS2LJnTu3nXzyyaG/NRCzQIECEcvCnX322a4ayV133RVaNn36dGvatGmSxyqFRc/Xtm3b43iXAAC/EXQDSGgqFzhhwgR77733XK3uYA+0RrgrcFZaSefOna1bt242ZMgQF4T/9ddfNnPmTKtfv75dcsklaX7NO++801VGUQWU9u3bu9dWb3Z4Wkuwl11Bd/fu3V1gDwDIvhhICSChvfLKK65iicr/lS9fPnSbPHly6DEKfBV09+3b12rVqmXt2rVzNbUrVaqUrtdUj7Yqoeh5Tz31VFdeUK/XpEmTiMcpEFe+uKqWAACyN+p0x0HdRwAAAGTteI2ebgAAAMBjJAkCyNaUfqEca6RN6dKlrXLlyrRBnLQBgKyPoBtAtg64a9WuZfv37fd7VbKd/AXy28qfVh530Kc2qFOrlu3dTxukVcH8+W3FyuNvAwDZA0E3gGxLPdwKuCveVNHyVcjn9+pkGwd+P2AbX9vott/xBnx6DgXcT5cvbyflpQ1Sa83BA3bfpk0Z0gYAsgeCbgDZngLuAlUL+L0aCU0Bd938+f1eDQDIshhICQAAAHiMoBsAAADwGEE3AAAA4DGCbgAAACCeg25Nv6wpkDUrkG5nn322ffLJJxGPCQQCNmDAAKtQoYIVKFDATdW8fPnyiMccOHDA7rjjDlfztFChQm6K5o0bN6b42tdff73lyJHDevfuneS+W2+91d2nxwAAAADZOuiuWLGiPfXUU/btt9+6W4sWLax9+/YRQfUzzzxjQ4cOtRdffNEWLlxo5cqVs4svvth27doVekyfPn1s6tSpNmnSJJs7d67t3r3bLr30Ujty5EiKr1+pUiX3P/v27Qst279/v02cOJESTgAAAIiPoPuyyy6zSy65xGrWrOluTz75pBUuXNgWLFgQ6uUeNmyYPfjgg9ahQwerV6+ejRkzxvbu3WsTJkxwj9mxY4eNGDHChgwZYhdddJE1aNDAxo0bZ0uXLrXPPvssxddv2LChC66nTJkSWqbfFYzreQAAAIC4yulWr7R6nffs2ePSTGTt2rW2efNma9myZehx+fLls2bNmtn8+fPd34sWLbJDhw5FPEapKArQg49JSY8ePWzUqFGhv0eOHGk9e/ZM8X+UzrJz586IG5BeX3zxhfsCqv1WaU3vvvuu5xvznXfesbp167rjST91pSjc4cOH7aGHHrJq1aq5tK7q1avbY489ZkePHvV83QAAiEe+B93qkVbvtj78lV+tD38FAaKAW8qWLRvxP/o7eJ9+5s2b10qUKJHsY1LStWtXl5Kybt06W79+vc2bN8+6dOmS4v8MHjzYihUrFrqpZxxIL33RPO2001wKVUYYPXq0G/uQnK+++so6derk9v0ffvjB/ezYsaN9/fXXocc8/fTT9uqrr7p1WrFihUvzevbZZ2348OEZso4AACQa34PuWrVq2eLFi11KyS233GLdu3e3H3/8MeIx6v0Lp7ST6GXRUvMY0eDLtm3burQV9Xjrdy1LSf/+/V1aS/C2YcOGY74OkJw2bdrYE0884VKoYjl48KDde++9duKJJ7qBwk2aNLHZs2ene4MqZUvjIrQf165d2/288MIL3fLwwFzjK3Q8VK1a1a666ip3NUljLwAAQDYMutVLffLJJ1vjxo1dD7J6/F544QV3nwZNSnSP9ZYtW0K933qMgpJt27Yl+5hjUTqJegcVeB8rtUTUKx+suBK8AV5RCpSuwCj9asmSJXb11Vdb69atbdWqVel6PgXU4elY0qpVq4h0rHPPPdc+//xz+/nnn93f6hHXFSGNwQAAANkw6I7VQ62caVE+qYLqGTNmhO5XgD1nzhxr2rSp+7tRo0aWJ0+eiMds2rTJli1bFnrMsSiA0fPqpuADyCrWrFnjqum8/fbbdt5559lJJ51k/fr1c0Fx+FiEtNCX2JRStuS+++6za6+91vWE6/jSwGJVCdIyAACQdrnNRw888IC7tK6caJUAVE+eLpt/+umn7n6lh+iDftCgQVajRg130+8FCxa06667zj1GOdW9evWyvn37WqlSpaxkyZIuKKlfv76rZpIauXLlcnmrwd+BrOK7775zX0RV3Secvphqf5dff/01NA4iOAhSg4s1ViJI4xSUo53alK3Jkye7KkCqEnTKKae4FDAdixrsqRQwAACQjYLuP/74ww3iUs+0gmdNlKOAW/mmQcplVR1tTVijFBLls06fPt2KFCkSeszzzz9vuXPndoPB9FjlpypdJC0BNCkiyIpULUT7sar0RO/PwaBagbCC4vCyl6pOMn78+Jj7t64epZSyJffcc4/df//9ds0117i/9SVWA42VAkbQDQBANgu6VV/7WNT7phkpdUtO/vz5XVWFtFRWUFCekswo2wYci9I6VE5TQbHSS2LRF06NiwgqU6aMK/MXviycSnIqHeuuu+4KLdMX2fB0LNXCz5kzMvtMQT8lAwEAyIZBNwBzM6iuXr06tClUn14910qVUlpJ586drVu3bm4CKAXhf/31l82cOdP1PqdnYOOdd95p559/visLqAol7733nptISgMlg1Q3XJNVafIopZd8//33bmbY1Aw0Bo7Hi3/9aZ/s2mWbDx2yPDlyWN38+e3O0ifYaQUKeLphJ27bZiO3/W1/Hj5sJ+fNa/eXKWuNCxYM3V935U8x/6/vCSdYr5L/S/UCgJQQdAM+Uxm+Cy64IPT33Xff7X4qjUNXZDRgUiUFNW7ht99+c7nc6q1ObyUR9Whr/IQmv3n44Yfd4EzlcCt1K0hXjXSf0rrUy64UlptvvtkeeeSRDHjHQPKq5s1rD5Ypa5Xy5LH9gYCN3fa33bhxg31arbqVzJ073YH874cO2aDyFWLe/8nOnTZ4yx/2SNly1qBAAXtrx3a7eeMG+6BadauQJ497zJyTIq8cfblntz2sydsK/3+qIwCkJEdAI6hwXDQjpXLSVbOb3HAgcweaqoLRSQNOsgJVve0JjSf71u2zNQPWuLECDRs2zJA2+G+Vqq5XOqPtPnLEzly9ykZUrGRnFyrklu06csSe+3OLfb57tx0IBKxe/vx23wllrHYyr3+soLvT+nVWN19+e/SfMrVy6dpfrEXhwnb3CWVi/s/tv220PUeP2qhKldP1vn7cv9+uWr8uQ9oAQPaI1+jpBo6DKoco3QOpp8mnlLaSkQ78/r8yo4iv7XUwEHC9zkVy5rTa+fK5ZeonuuW3jVYsZy57tWJFK5wzl721fbv13LjBPq5W3YqnsQKVXkMB8I1RKSJNCxayxfv2xfyfvw4fti9277ZB5csfx7sDkGgIuoHjCLjr1K5le/ftZxumQcEC+W3FTyszJPBWAJ+/QH7b+NpG2iCNtN2ONfuuX2bv3m19f//NpZeckDu3vVGxkpX4J7Xk67177ecDB2zuSSdb3n8G+95bpox9vnuXTd+1yzoWL56m19p+5LAdMbNSuSODdf391x7dk9R7O3ZYwZw57WJSSwCkAUE3kE7q4VbAPe6KAlbnhCw3z1SWtOLPo9Zl6j637TIi6NZzrPxpJVcbssgVh7T6YOcOGxBWvvI/FSu5wYtnFixoU6pWs+1HjtjbO7bb3Zt+t0mVq1ip3Llt+YH9tvfoUTt7deSMrEoz2XDooPv92717XU520KF/siin7doVWnZTqVJ2c6n//9KRw6Jq17vqWbHXe8rOHXZp0aKWL6rCDwCkhKAbOE4KuBuWZ1Ilvyhw9Dt4RPooZ/rUqtVCf5f9pzdbvchV8ua1KmauaknrX9bYOzt2uEBZ8bN6v0fHyKUu+k8QrBxvBe1B47Ztsy2HD0XkZxf7Jw2leK7cluuflJFwfx8+YqVipKoooF978KANSSY/HACSQ9ANAPBFoZy5rFDeY39hVa/zwcBR97sGaypAzp3D7MQ8eWM+Pv8/QXtQsVw5bc/RyGVBef8pSzh/7x67KGzSNf2tLwXRpuzYbqfky5/soE0ASA5BNwAgS1DayH+2bnXBbuncuW3HkSM2cfs2++PwYWtV5H+VBs4uWND1ft/+22+uRna1vHltixvYuMcuLFLY6uVPexWb60uUtPs2/W6n5M9vp+cv4FJaNh06ZJ2Kl0hSSUUpKveUiV3RBABSQkIaACBLUJ/32oMH7M7ff7NL1v5it2zcaH8fOWJvVqpsNf6pXqJZiv9TsaI1LlDQHtq82dr88ov1/f13++3QISuVK339SG2KFrX+ZcraK3/9ZR3Wr3MpJMovP/GfGt1BH+/a5Xrd2/7zBSCeJ+y6/fbbrWLFim522zp16tgrr7zi+eu+/PLLVq1aNTfLtMpQfvnll0kes2LFCmvXrp0r+1akSBE766yz3KD2eKHtfOqpp7pydrppToZPPvnE09d85513rG7dupYvXz73c+rUqRH3Hz582M3roLbR/lC9enV77LHHmKE4HejpBgBkCRqY+O8TK6YqLeXBsmXdLTVuL33CMR9zbYkS7pYSVUZJa3WU7Oiuu+6yWbNm2bhx46xq1ao2ffp0N1GWJsnSLLbpMWDAAFu3bp2b8CsWTdDVp08fF3ifc8459p///MfatGljP/74Y2jMxpo1a+zcc8+1Xr162cCBA13grSBcQXq80Bedp556yk4++X+TMY0ZM8Ztc80KrNmB00rbW7fZs2fHvP+rr76yTp062eOPP25XXHGFC7g7duzoZigOTpim2YtfffVVty5aB03o1qNHD7f9NcMxUo+gGwBw3NYczB61v+N1e2XknAEKuC+++GLX0/r3339b48aNrUaNGvbBBx9YpUqV3GN27dplL7zwggvmDh486HrDNWtuzZo1Yz7npk2bbOvWrW4ypVgU9KkHWxMF7du3z7p162bvvfeePfroo3bHHXe4x/Tv39/1bF9zzTWuXvv27dutfPnytnHjRnfLrlV8wl122WURfz/55JOu93vBggUu4NW2Vq/z+PHj3fuvV6+eC4qbN2+ertcbNmyYa2ttW9HPOXPmuOUTJ04MBeYK/Nu2bev+1hcx3afgG2lD0A0ASDcFLQU1I+SmTWzFNNJ2y4ha6Qq4a9euY/v27c2wNlCvsno3w/300082YsSImI9XAHbttdce83k//PDDZO9bvny5S3WI1VMb7uOPP7aMUqBAQfvppxVZKvAOOqKSmW+/bXv27HFpJqIeZl0xmDRpkrvyoJ7p1q1b29KlS90Xo7RSQK0rG+FatWrlgu4gXV3QvvDzzz+7L1U//PCD6wkPfwxSh6AbAJBuClZWrKRWup+9rOrhVsDdvUV/K1f8+J/vyNHD9ul342zZr19bzhw5LUeOnNa6YRerV/l/6Qbrt/xkUxb8x+5o+4zlzvX/ee//mfaINal5sZ1e7bwkzzn3xw9tx96t1rZx9yT37dq33V7+pL91btbPKpY6KbT8q58+sWW/LrAbWw603ft32Esf3295cuW18+q2s8on1LS1f/xoc5a/Z9ee18f9nVabt/9qY2YOzrB5AzKKAmgF2fv377fChQu7wFq51voipB5m9eor4JZ+/frZp59+aqNGjbJBgwal+bU2b95sZaPStPS3lgfdd999btr02rVrW65cudyXAfXAp+ZLFiIRdAMAjgu10rMGBdyV0hh8Llz1mU384vnQ37deMtjWbfnJtuz4zW5u9biVLFLWVm9aau9/84ZVK1vXaldsZCt/+94OHTlowz+6N+K5tOzI0SNuHVZvWmIvf/y/lIVgIB+wgP38++LQslYNrrNWDTvb9j3/S4spG7X+yzcstDy587llwcecWu1c69D0Fvd74xoX2tbdf7jnPKfupRYvatWqZYsXL3bpI+r57969u0v50JUApdVEp/AcOHDASpUqFbrqoQA9fBDkoUOHXPAe1KVLl4irGBqcHE6vEb5M+fbK758wYYJLcdG6Kf9egb/WDalH0A0AQIKqX6WpVb2qTujvYoVK2/AP73G9y/WqnOWWnVjqJNu4dbV9/sPbLugO2FErVrCk3XnZ0CTPVyDv/4K7yifUsv5XvRZaPnvZVBc4X97kxtCygvn+Vxe9cP5irkd9175tEc+1e982K1KgxP8/JmcuK19CUyZFftH4ZfMyiyd58+YNDaRUPv3ChQtd/nyLFi1cT/OiRYvcz3DBoFqBsILioClTprjAXTngQcrVDypXrlxEr7Zs2bIlovf7nnvusfvvv9/l0kv9+vVt/fr1NnjwYILuNCLoBgAgQeXPW9DdgvYd3ON6paN7PxUUK9iWiqVr2M69f7sguFSRcjGfN2/ufHZCsRMjAuz9B/dELAtSiop6s3/auMhOq3ZuaLn+rl/1nNBjqpxQy/7YviHif7fs2GgliqSuik12pZ5n9WY3aNDApXYoKD7vvKQpPJI7d+5QwC5lypRxZf7Cl4VTGsuMGTMi8rpVraZp06ahv/fu3Ws5/5ntNUhB/9Gj/9sfkHoE3QAAwCmQt5CdXP40e3fBay61o2RhpZf8YN/8PMM6nP2/tI7aJzZyqSavTXvE2je50coWr2Q79my15b9+badWO8cFx2nVov5VNnbWUy43W889b8VH9vfuLXZe3f+v5nHRaZ1s5GeP28nlT7WaFU63HzcstGXrv4rZ455dPfDAA65UoqrEqEKMBkyqQozytpVW0rlzZ1fZZciQIS4IVz76zJkzXe/zJZdckubXU8m/888/31VAUYUSVYz57LPP3EDJ8IoqyuFWGpnSS1S+cOjQodazZ88Mfvfxj6AbAACE9LzoIXvv6zdszOeDbO+BXS6v+9Ize9q5/wTA6gW/pc1g+2DhSBs/+1k3yLFowZJ2crn6VvSfdJC0anTyBbbnwE77ZNGbrhe9fMmqdmubwe61g9QLfs15fWz69xPtv/NetDLFK9kNLQfYSeXrx03r/fHHH9a1a1dXYlF1sDVRjgJulfUTDZh84oknXHnG3377zeVyq7c6PQG3qEdbgb3KED788MN20kknuRzuYI1uGT58uLtPtdrVy64UlptvvtkeeeSRDHvfiSJHQNctcFx27tzpDg6N7g3PlUJ8U71ZzZq26KZC1rB8ZH4dktlmm45Yo9f2uJxE1eMFkHHnovs6vJLmgZSJbMOfP9vTU27hfJRAdvocrzENPAAAAOAx0ksAAIgDqjsN/7ZXRs4KmkhKZ7FZQb1E0A0AQDYPWjSzoiZ6Qdpou2XUrKC1atex/Rk4K2iiyF+goK3MorOCZjSCbgAAsjEFK5rKnF5Wf2cFVcBd6tK+lqdUpeN+vkRxaOsG2/rhkCw3K6hXCLoBAMjmmBU0a1DAna9c7JrYAAMpAQAAAI8RdAMAAAAeI+gGAAAAPEbQDQAAAHiMoBsAAADwGEE3AAAA4DGCbgAAAMBjBN0AAACAxwi6AQAAAI8RdAMAAAAeI+gGAAAAPEbQDQAAAHiMoBsAAADwGEE3AAAA4DGCbgAAAMBjBN0AAACAxwi6AQAAAI8RdAMAAAAeI+gGAAAAPEbQDQAAAHiMoBsAAACI56B78ODBdsYZZ1iRIkWsTJkydvnll9vKlSsjHnP99ddbjhw5Im5nnXVWxGMOHDhgd9xxh5UuXdoKFSpk7dq1s40bN6b42sHn7d27d5L7br31VnefHgMAAABk66B7zpw5dtttt9mCBQtsxowZdvjwYWvZsqXt2bMn4nGtW7e2TZs2hW4ff/xxxP19+vSxqVOn2qRJk2zu3Lm2e/duu/TSS+3IkSMpvn6lSpXc/+zbty+0bP/+/TZx4kSrXLlyBr9bAAAAJKrcfr74p59+GvH3qFGjXI/3okWL7Pzzzw8tz5cvn5UrVy7mc+zYscNGjBhhb775pl100UVu2bhx41xA/dlnn1mrVq2Sff2GDRvaL7/8YlOmTLHOnTu7Zfpd/1u9evUMepcAAABIdFkqp1sBtJQsWTJi+ezZs10wXrNmTbvxxhtty5YtofsUoB86dMj1kAdVqFDB6tWrZ/Pnzz/ma/bo0cMF+0EjR460nj17pvg/SmfZuXNnxA0AAADI8kF3IBCwu+++284991wXMAe1adPGxo8fbzNnzrQhQ4bYwoULrUWLFi7wlc2bN1vevHmtRIkSEc9XtmxZd9+xdO3a1aWkrFu3ztavX2/z5s2zLl26HDMXvVixYqGbesYBAACALJleEu7222+3JUuWuAA4XKdOnUK/Kxhv3LixValSxT766CPr0KFDikG8BkMeiwZftm3b1saMGeP+R79rWUr69+/vviAEqaebwBsAAABZOuhW5ZH333/fvvjiC6tYsWKKjy1fvrwLuletWuX+Vq73wYMHbdu2bRG93UpBadq0aapeX+kkCvrlpZdeOubjlWOuGwAAAJDl00vUs6xgV4MXlT5SrVq1Y/7P1q1bbcOGDS74lkaNGlmePHlc9ZMgVThZtmxZqoNuVUdR4K5bSgMvAQAAgGzX061ygRMmTLD33nvP1eoO5mArT7pAgQKu9N+AAQPsyiuvdEG28q4feOABl/5xxRVXhB7bq1cv69u3r5UqVcoNwuzXr5/Vr18/VM3kWHLlymUrVqwI/Q4AAADETdD9yiuvuJ/NmzePWK5qIpqYRgHw0qVLbezYsbZ9+3YXeF9wwQU2efJkF6QHPf/885Y7d27r2LGjq7l94YUX2ujRo9MUQBctWjQD3xkAAACQRYJupZekRL3d06ZNO+bz5M+f34YPH+5uqaWgPCXvvvtuqp8LAAAAyBYlAwEAAIB4RdANAAAAeIygGwAAAPAYQTcAAADgMYJuAAAAwGME3QAAAIDHCLoBAAAAjxF0AwAAAB4j6AYAAAA8RtANAAAAeIygGwAAAPAYQTcAAADgMYJuAAAAwGME3QAAAIDHCLoBAAAAjxF0AwAAAB4j6AYAAAA8RtANAAAAeIygGwAAAPAYQTcAAADgMYJuAAAAwGME3QAAAIDHCLoBAAAAjxF0AwAAAB4j6AYAAAA8RtANAAAAeIygGwAAAPAYQTcAAADgMYJuAAAAwGME3QAAAIDHCLoBAAAAjxF0AwAAAB4j6AYAAAA8RtANAAAAeIygGwAAAPAYQTcAAADgMYJuAAAAwGME3QAAAIDHCLoBAAAAjxF0AwAAAB4j6AYAAAA8RtANAAAAeIygGwAAAPAYQTcAAADgMYJuAAAAIJ6D7sGDB9sZZ5xhRYoUsTJlytjll19uK1eujHhMIBCwAQMGWIUKFaxAgQLWvHlzW758ecRjDhw4YHfccYeVLl3aChUqZO3atbONGzem+NrXX3+95ciRw3r37p3kvltvvdXdp8cAAAAA2TronjNnjt122222YMECmzFjhh0+fNhatmxpe/bsCT3mmWeesaFDh9qLL75oCxcutHLlytnFF19su3btCj2mT58+NnXqVJs0aZLNnTvXdu/ebZdeeqkdOXIkxdevVKmS+599+/aFlu3fv98mTpxolStX9uhdAwAAINH4GnR/+umnrjf5lFNOsdNOO81GjRplv/76qy1atCjUyz1s2DB78MEHrUOHDlavXj0bM2aM7d271yZMmOAes2PHDhsxYoQNGTLELrroImvQoIGNGzfOli5dap999lmKr9+wYUMXXE+ZMiW0TL8rGNfzAAAAAHGX060AWkqWLOl+rl271jZv3ux6v4Py5ctnzZo1s/nz57u/FaAfOnQo4jFKRVGAHnxMSnr06OGC/aCRI0daz549U/wfpbPs3Lkz4gYAAABk+aBbvdp33323nXvuuS5gFgXcUrZs2YjH6u/gffqZN29eK1GiRLKPSUnXrl1dSsq6dets/fr1Nm/ePOvSpcsxc9GLFSsWuqlnHAAAAEhObssibr/9dluyZIkLgKNpUGN0gB69LFpqHiMafNm2bVuXtqL/0e9alpL+/fu7LwhB6ukm8AYAAECWDrpVeeT999+3L774wipWrBharkGToh7r8uXLh5Zv2bIl1Putxxw8eNC2bdsW0dutxzRt2jRVr690EgX98tJLLx3z8Upx0Q0AAADI8ukl6llWsKvBizNnzrRq1apF3K+/FVSrskmQAmxVPQkG1I0aNbI8efJEPGbTpk22bNmyVAfdrVu3ds+rW6tWrTLs/QEAAAC+93SrXKCqkLz33nuuVncwB1t50qrJrfQQlQMcNGiQ1ahRw930e8GCBe26664LPbZXr17Wt29fK1WqlBuE2a9fP6tfv76rZpIauXLlshUrVoR+BwAAAOIm6H7llVfcT014E07VRIIT09x7772ujrYmrFEKSZMmTWz69OkuSA96/vnnLXfu3NaxY0f32AsvvNBGjx6dpgC6aNGiGfa+AAAAgCyVXhLrFj4TpHq7NSOlUkY0cY1SS4LVTYLy589vw4cPt61bt7oa3h988MExBzYqKH/33XeTvV/36THxLDUzgnrhnXfesbp167q8eP3UxEbhNEnSQw895NKLdMWjevXq9thjj9nRo0c9XzcAAIC4LhmIrDkjaFrpi0r0lYtwX331lXXq1MmVavzhhx/cT12h+Prrr0OPefrpp+3VV191s5Aq7Uezkj777LPuixUAAEB2RNCdwI41I6hocKlSfE488UQrVKiQS++ZPXt2ul9TM4xefPHFruxi7dq13U+lA2l5eGDevn17V76xatWqdtVVV7kvA99+++1xv2cAAAA/EHQj2RlBgzN2asKgSZMmuTrqV199tav2smrVqnRtOQXU4bOHiirGhM8eqgmSPv/8c/v555/d3+oRV/32Sy65hNYCAADZUpao042sOSPomjVrbOLEibZx40arUKGCW6bKMOohV6+4KsmklSrUpDTDqNx3333uC4B6wjUY9siRI/bkk0/atddee9zvEwAAwA8E3Uh2RtDvvvvOBeM1a9aM2EoHDhxw5RlF6SgaDBmkvPBDhw5Z4cKFQ8u6dOnicrRTO8Po5MmTbdy4ca6cpFJfFi9e7EpHKvDv3r07LQYAALIdgm4kOyOoqoWop1k53tHlF4NBtQJhBcVBmuhI1UnGjx8fsxyjJjsK79WOnmFU7rnnHrv//vvtmmuucX+r5vr69etdtRWCbgAAkB0RdCcw9TAr4FbJPg2OjJ4RtEGDBi61Q0HxeeedF/M5VB/95JNPDv2t0oMq8xe+LNzZZ5/tKqXcddddoWWqux4+e6jKPubMGTncQEE/JQMBAEB2RdCdwI41I6jSSjp37mzdunWzIUOGuCD8r7/+spkzZ7re5/QMbLzzzjvt/PPPd2UBVaFEr/3ZZ59FpLVcdtllLoe7cuXKLr3k+++/t6FDh1rPnj0z9P0DAABkFqqXJDDNCKoBi6qrXb58+dBNOdVBGjCpoLtv375Wq1Yta9eunaupfazJh5KjHm1VQtHznnrqqa6ut15PpQiDVI9bZQI1C2mdOnXc4M2bb77ZHn/88Qx53wAAAJmNnu4ETy85ljx58tjAgQPdLTVU9zt8RtFYFFDrlhz1uqtud3jtbgAAgOyMoDubUtUQpXogbUqXLu3SVjLSij+Znp5tBQBAygi6s2nAXatOHdu/d6/fq5Lt5C9Y0FauWJEhgbcC+IIF8luXqfsyZN0ShbaZth0AAImEoDsbUg+3Au6iDzxpuStHVhxB8g7/utZ2DnrQbb+MCLr1HCt+WskVhyxwtQEAgKyOoDsbU8Cdp2Ydv1cjoSl4JIAEAADHQvUSAAAAwGME3QAAAEBWSy/RrICqrazpvtetW2c5cuRwMxmqBFzXrl3d3wAAAADS2dOtus6aHOWGG26w3377zc1KqBkD169f72ozX3HFFWl5OgAAACAhpKmnWz3cX3zxhX3++ed2wQUXRNynqcEvv/xyGzt2rJvBEAAAAEA6eronTpxoDzzwQJKAW1q0aGH333+/jR8/Pi1PCQAAAMS9NAXdS5YssdatWyd7f5s2beyHH37IiPUCAAAAEjPo/vvvv61s2bLJ3q/7tm3blhHrBQAAACRm0H3kyBHLnTv5NPBcuXLZ4cOHM2K9AAAAgMQcSKnqJapSki9fvpj3HzhwIKPWCwAAAEjMoLt79+7HfAyVSwAAAIDjCLpHjRqVlocDAAAAyKhp4DU5zo8//uhmqwQAAABwHEH3mDFjbNiwYRHLbrrpJqtevbqbnbJevXq2YcOGtDwlAAAAEPfSFHS/+uqrVqxYsdDfn376qUs50SyUCxcutOLFi9vAgQO9WE8AAAAgMXK6f/75Z2vcuHHo7/fee8/atWtnnTt3dn8PGjTIevTokfFrCQAAACRKT/e+ffusaNGiob/nz59v559/fuhvpZls3rw5Y9cQAAAASKSgu0qVKrZo0SL3+19//WXLly+3c889N3S/Au7w9BMAAAAAaUwvUQ3u2267zQXbM2fOtNq1a1ujRo0ier41mBIAAABAOoPu++67z/bu3WtTpkyxcuXK2dtvvx1x/7x58+zaa69Ny1MCAAAAcS9NQXfOnDnt8ccfd7dYooNwAAAAAGnM6VbQnStXriS3EiVK2FlnneV6wAEAAAAcR0/31KlTYy7fvn27ffPNN9alSxc3gc7VV1+dlqcFAAAA4lqagu727dsne1/37t2tbt269txzzxF0AwAAAOlNLzmWli1bugl0AAAAAHgUdGvynPz582fkUwIAAADZXoYG3a+//ro1aNAgI58SAAAASKyc7rvvvjvm8h07dti3335ra9assS+//DKj1g0AAABIvKD7+++/j7m8aNGi1rp1a7v11lvdVPEAAAAA0hl0z5o1Ky0PBwAAAJDROd0AAAAAkiLoBgAAAOI56P7iiy/ssssuswoVKliOHDns3XffTfKY66+/3t0XftOU8+EOHDhgd9xxh5UuXdoKFSpk7dq1s40bN6b42sHn7d27d5L7lJuu+/QYAAAAIFsH3Xv27LHTTjvNXnzxxRQfp0GamzZtCt0+/vjjiPv79OnjpqifNGmSzZ0713bv3m2XXnqpHTlyJMXnrVSpkvsf1RcP2r9/v02cONEqV658nO8OAAAASMdAyozWpk0bdzuWfPnyWbly5ZItVzhixAh788037aKLLnLLxo0b5wLqzz77zFq1apXs8zZs2NB++eUXmzJlinXu3Nkt0+/63+rVq6f7fQEAAADZLqd79uzZVqZMGatZs6bdeOONtmXLltB9ixYtskOHDrkp6IOUrlKvXj2bP3/+MZ+7R48eNmrUqNDfI0eOtJ49e6b4P0pn2blzZ8QNAAAAyLZBt3rCx48fbzNnzrQhQ4bYwoULrUWLFi7wlc2bN1vevHmtRIkSEf9XtmxZd9+xdO3a1aWkrFu3ztavX2/z5s2zLl26pPg/gwcPtmLFioVu6hkHAAAAsmR6SWp06tQp9Lt6rxs3buwm4Pnoo4+sQ4cOyf5fIBBwgyGPRYMv27Zta2PGjHH/o9+1LCX9+/ePmJ1TPd0E3gAAAMi2QXe08uXLu6B71apV7m/leh88eNC2bdsW0dutFJSmTZum6jmVTnL77be731966aVU5ZjrBgAAAMRFekm0rVu32oYNG1zwLY0aNbI8efLYjBkzQo9RhZNly5alOuhWdRQF7rqlNPASAAAAyHY93Srtt3r16tDfa9eutcWLF1vJkiVdyT7dP2DAALvyyitdkK286wceeMClf1xxxRXuf5RT3atXL+vbt6+VKlXK/W+/fv2sfv36oWomx5IrVy5bsWJF6HcAAAAgboLub7/91i644ILQ38E86e7du9vo0aNdALx06VIbO3asbd++3QXeevzkyZOtSJEiof97/vnnLXfu3NaxY0dXc/vCCy8M/X9qFS1aNIPfHQAAAJAFgu7mzZu7wYvJKVCggE2bNu2Yz5M/f34bPny4u6WWgvKUxJodEwAAAEiInG4AAAAguyHoBgAAADxG0A0AAAB4jKAbAAAA8BhBNwAAAOAxgm4AAADAYwTdAAAAgMcIugEAAACPEXQDAAAAHiPoBgAAADxG0A0AAAB4jKAbAAAA8BhBNwAAAOAxgm4AAADAYwTdAAAAgMcIugEAAACPEXQDAAAAHiPoBgAAADxG0A0AAAB4jKAbAAAA8BhBNwAAAOAxgm4AAADAYwTdAAAAgMcIugEAAACPEXQDAAAAHiPoBgAAADxG0A0AAAB4jKAbAAAA8BhBNwAAAOAxgm4AAADAYwTdAAAAgMcIugEAAACPEXQDAAAAHiPoBgAAADxG0A0AAAB4jKAbAAAA8BhBNwAAAOAxgm4AAADAYwTdAAAAgMcIugEAAACPEXQDAAAAHiPoBgAAADxG0A0AAAB4jKAbAAAA8BhBNwAAABDPQfcXX3xhl112mVWoUMFy5Mhh7777bpLHBAIBGzBggHtMgQIFrHnz5rZ8+fKIxxw4cMDuuOMOK126tBUqVMjatWtnGzduTPG1r7/+eveavXv3TnLfrbfe6u7TYwAAAIBsHXTv2bPHTjvtNHvxxReTfcwzzzxjQ4cOdY9ZuHChlStXzi6++GLbtWtX6DF9+vSxqVOn2qRJk2zu3Lm2e/duu/TSS+3IkSMpvn6lSpXc/+zbty+0bP/+/TZx4kSrXLlyBr1LAAAAJDpfg+42bdrYE088YR06dIh5v3q5hw0bZg8++KB7TL169WzMmDG2d+9emzBhgnvMjh07bMSIETZkyBC76KKLrEGDBjZu3DhbunSpffbZZym+fsOGDV1wPWXKlNAy/a5gXM8DAAAAxH1O99q1a23z5s3WsmXL0LJ8+fJZs2bNbP78+e7vRYsW2aFDhyIeo1QUBejBx6SkR48eNmrUqNDfI0eOtJ49e6b4P0pn2blzZ8QNAAAAyJZBtwJuKVu2bMRy/R28Tz/z5s1rJUqUSPYxKenatatLSVm3bp2tX7/e5s2bZ126dEnxfwYPHmzFihUL3dQzDgAAACQnt2UDGtQYnXYSvSxaah4jGnzZtm1bl7ai/9HvWpaS/v3729133x36Wz3dBN4AAADIlkG3Bk2KeqzLly8fWr5ly5ZQ77cec/DgQdu2bVtEb7ce07Rp01S9jtJJbr/9dvf7Sy+9dMzHK8VFNwAAACDbp5dUq1bNBdUzZswILVOAPWfOnFBA3ahRI8uTJ0/EYzZt2mTLli1LddDdunVr97y6tWrVyoN3AgAAgETma0+3SvutXr06YuDk4sWLrWTJkq6qiNJDVA5w0KBBVqNGDXfT7wULFrTrrrvO/Y9yqnv16mV9+/a1UqVKuf/t16+f1a9f31UzSY1cuXLZihUrQr8DAAAAcRN0f/vtt3bBBReE/g7mSXfv3t1Gjx7tfr/33ntdHW1NWKMUkiZNmtj06dOtSJEiof97/vnnLXfu3NaxY0f32AsvvND9f1oC6KJFi2boewMAAACyRNCt2SU1eDEl6u3WjJS6JSd//vw2fPhwd0utYFCfnFizYwIAAABxl9MNAAAAxAOCbgAAAMBjBN0AAACAxwi6AQAAAI8RdAMAAAAeI+gGAAAAPEbQDQAAAHiMoBsAAADwGEE3AAAA4DGCbgAAAMBjBN0AAACAxwi6AQAAAI8RdAMAAAAeI+gGAAAAPEbQDQAAABB0AwAAANkbPd0AAACAxwi6AQAAAI8RdAMAAAAeI+gGAAAAPEbQDQAAAHiMoBsAAADwGEE3AAAA4DGCbgAAAMBjBN0AAACAxwi6AQAAAI8RdAMAAAAeI+gGAAAAPEbQDQAAAHiMoBsAAADwGEE3AAAA4DGCbgAAAMBjBN0AAACAxwi6AQAAAI8RdAMAAAAeI+gGAAAAPEbQDQAAAHiMoBsAAADwGEE3AAAA4DGCbgAAAMBjBN0AAACAxwi6AQAAAI8RdAMAAAAeI+gGAAAAPEbQDQAAACRy0D1gwADLkSNHxK1cuXIRjwkEAu5xFSpUsAIFCljz5s1t+fLlqXre1q1bJ7nvmWeecffpeQAAAIC4D7rllFNOsU2bNoVuS5cuTRIkDx061F588UVbuHChC8ovvvhi27VrV4rPW758eZs1a5Zt3LgxYvmoUaOscuXKnrwXAAAAJKYsH3Tnzp3bBdLB2wknnBDRyz1s2DB78MEHrUOHDlavXj0bM2aM7d271yZMmJDi85YpU8ZatmzpHh80f/58++uvv6xt27aevicAAAAkliwfdK9atcqljlSrVs2uueYa++WXX0L3rV271jZv3uyC56B8+fJZs2bNXAB9LD179rTRo0eH/h45cqR17tzZ8ubNm+L/HThwwHbu3BlxAwAAALJl0N2kSRMbO3asTZs2zV5//XUXYDdt2tS2bt3q7tffUrZs2Yj/09/B+1Jy6aWXuoD5iy++sD179thbb73lAvFjGTx4sBUrVix0q1SpUrrfIwAAAOJflg6627RpY1deeaXVr1/fLrroIvvoo4/c8vCUENHAx3BKO4leFkuePHmsS5cuLo/77bfftpo1a9qpp556zP/r37+/7dixI3TbsGFDmt8bAAAAEkduy0YKFSrkAnClnEiwkol6tTUwMmjLli1Jer+To55t9agvW7YsVb3cwRQW3QAAAIBs39MdK5d6xYoVoQBbed4KvGfMmBF6zMGDB23OnDkuDSW11VF0U9B93XXXebbuAAAASFxZuqe7X79+dtlll7kSfuq9fuKJJ1wOdvfu3d39SiHp06ePDRo0yGrUqOFu+r1gwYJpCqBnzpxphw4dsuLFi3v4bgAAAJCosnTQrRra1157rSvjp1KBZ511li1YsMCqVKkSesy9995r+/bts1tvvdW2bdvmUkWmT59uRYoUSVPaCgAAAJCQQfekSZOO+Rj1dmuGSd1S61iPV+1vAAAAICFzugEAAIDsiKAbAAAA8BhBNwAAAOAxgm4AAADAYwTdAAAAgMcIugEAAACPEXQDAAAAHiPoBgAAADxG0A0AAAB4jKAbAAAA8BhBNwAAAOAxgm4AAADAYwTdAAAAgMcIugEAAACPEXQDAAAAHiPoBgAAADxG0A0AAAB4jKAbAAAA8BhBNwAAAOAxgm4AAADAYwTdAAAAgMcIugEAAACPEXQDAAAAHiPoBgAAADxG0A0AAAB4jKAbAAAAIOgGAAAAsjd6ugEAAACPEXQDAAAAHiPoBgAAADxG0A0AAAB4jKAbAAAA8BhBNwAAAOAxgm4AAADAYwTdAAAAgMcIugEAAACPEXQDAAAAHiPoBgAAADxG0A0AAAB4jKAbAAAA8BhBNwAAAOAxgm4AAADAYwTdAAAAgMcIugEAAACPEXQDAAAAHiPoBgAAADxG0B3m5ZdftmrVqln+/PmtUaNG9uWXX3q9/QEAAJAACLr/MXnyZOvTp489+OCD9v3339t5551nbdq0sV9//dXfFgIAAEC2R9D9j6FDh1qvXr3shhtusDp16tiwYcOsUqVK9sorr/jbQgAAAMj2cvu9AlnBwYMHbdGiRXb//fdHLG/ZsqXNnz8/yeMPHDjgbkE7duxwP3fu3JkJa2u2e/du9/PQqhUW2Lc3U14zHhzeuD60/TKrrQAA8S/4uXxg82o7enC/36uTbRz6e2Omfi4HXyMQCJgfCLrN7K+//rIjR45Y2bJlIzaO/t68eXOSjTZ48GAbOHBgkuXqGc9Mu4Y8nqmvFy+aNWvm9yoAAOLQtmkv+r0K2VKzTP5c3rVrlxUrVswyG0F3mBw5ckRsHH0Til4m/fv3t7vvvjv099GjR+3vv/+2UqVKxXx8ItG3SH352LBhgxUtWtTv1UlYtIP/aAP/0Qb+ow38RxtExnUKuCtUqGB+IOg2s9KlS1uuXLmS9Gpv2bIlSe+35MuXz93CFS9e3Ou2ylYUcBN0+4928B9t4D/awH+0gf9og//xo4c7iIGUZpY3b15XInDGjBkRG0d/N23a1K+2AQAAQJygp/sfShfp2rWrNW7c2M4++2x77bXXXLnA3r17+9tCAAAAyPYIuv/RqVMn27p1qz322GO2adMmq1evnn388cdWpUoVf1som1HazaOPPpok/Qa0Q6LhWPAfbeA/2sB/tEHWkSPgV90UAAAAIEGQ0w0AAAB4jKAbAAAA8BhBNwAAAOAxgm4AAADAYwTdAAAAgMcoGYh0++CDD+zbb7+11q1bu9rmM2fOtOeee86OHj1qHTp0sJtuuomtmwn27NljEyZMsPnz57tZVXPkyOFmUj3nnHPs2muvtUKFCtEOHtu4caO98sorSdpAk2up1n+lSpVog0ywatWqmG1Qo0YNtn8m4DjwH22QtVEyEOny6quv2h133GGnnXaa+6B7+eWX7ZZbbnH1znPlymVjx461wYMH25133skW9tCPP/5oF198se3du9eaNWvmggxVAd2yZYvNmTPHBdzTp0+3unXr0g4emTt3rrVp08YF1i1btoxoA81qu2HDBvvkk0/clyB4Y8eOHdatWzfXEaApnsuUKePa4M8//7SdO3faZZdd5s5JmgYb3uA48B9tkA2oTjeQVnXq1Am89tpr7veZM2cG8ufPH3jppZdC948aNco9Bt5q3rx54JprrgkcOHAgyX1adu2117rHwDuNGzcO9OnTJ9n7dZ8eA+907do1UL9+/cCCBQuS3Kdlp556aqBbt240gYc4DvxHG2R99HQjXQoWLGg//fSTVa5c2f2dN29e++6779xMnrJu3To75ZRTXOoDvG0Hpfgk15O9bNkyO/PMM11POLxRoEABW7x4sdWqVSvm/TpOGjRoYPv27aMJPFK8eHGbNm2aNWnSJOb9CxYscGlw27dvpw08wnHgP9og62MgJdKlVKlStn79evf777//bocPH7Zff/01dL/uK1myJFvXYyVKlHDpPclZvXq1ewy8U758eZdHnJyvvvrKPQbeUg53eu5DxuA48B9tkPUxkBLp0r59e+vVq5d1797d3n//fZdP2bdvX8uZM6f7gLvnnntcfiu8deONN7o2eOihh1xut/KJtf01kEz5xIMGDbI+ffrQDB7q16+fGyy5aNGimG3wxhtv2LBhw2gDDylnW8fCiBEjrHHjxhH36UqQ2qddu3a0gYc4DvxHG2QDfue3IHvavXt34IYbbgjUq1cv0Lt378DBgwcDzz77bCBv3ryBHDlyuDziP/74w+/VTAhPPfVUoHz58m6758yZ0930u5Y9/fTTfq9eQpg0aVKgSZMmgdy5c7ttr5t+17LJkyf7vXpxb9u2bYHWrVu77V6iRIlArVq1ArVr13a/63ho06aNewy8xXHgP9ogayOnGxlq//79dujQIStSpAhbNpOtXbvW9a5KuXLlrFq1arRBJtO+/9dff7nfS5cubXny5KENMpHy55XOE34cqJxp7dq1aYdMxHHgP9ogayLoBuKQyqWRx+r/lyCVEcydmyw+JC6OA//RBlkHAynhCdUm7tmzJ1vXJ/ny5bMVK1aw/X2kaiYpDXKF91q0aBEa8A1/cBz4jzbIOuiCgSf+/vtvGzNmjI0cOZIt7KG777475vIjR47YU0895arMyNChQ2kHj2j21eTa4F//+lco1WrKlCm0gUc0mDuWL774wj788MPQjKAMpvQOx4H/aIOsj6AbGfohF/TLL7+wZTOBqmJoVlDVKY5OL1FPt2akJM3EW++++66df/75MXPoCxcu7GZIhLcuv/xyt59rv4+mmXNF9+uLELzBceA/2iAb8HskJ7KnYKWMYKWGWDfdD28NGjQoUK1atcDnn38esVyVM5YvX87mzwQTJ04MVKxYMTBy5EjawCeqXNK2bdskFZM4DjIPx4H/aIOsj5xupLsI/zvvvGNHjx6NedPslPBe//79bfLkyXbLLbe4Gq0asY7Mdc0119jcuXNdKtWVV15p27Ztowky2SeffGIXXnihnXHGGS6dBJmP48B/tEHWR9CNdGnUqFGKgXVyl3qR8RRoaGKWP//8000MsnTpUlJKMlmVKlVszpw5Vq9ePZfuoynJSevJXHfddZdLe7vvvvvs5ptvtr1792byGoDjwH+0QdZGTjfSRTNO7tmzJ9n7Tz75ZJs1axZbN5Mod1gDVydNmuRmRSR3NfNpNtaBAwe6mVi7du1KG/hAX3g0A6UC8NNPP50v/j7gOPAfbZB1UacbiMNyjboKcdFFF7mBlMh8u3fvtjVr1rhJWVS+EZlPvd764q8UrDJlytAEPuA48B9tkLUQdANABtEVBs1IqdQSlWvMlSsX2xYJh+PAf7RB1kRON9Jt4cKF1rlzZ1cqrUCBAlawYEH3u5bpEi8yB+3gv6lTp9o555zjjoEKFSq4gcb6XctUxgveU7rb66+/bj169LA2bdrYJZdc4n5/4403UkyFQ8bhOPAfbZC10dONdFEg0bFjR1cxoFWrVla2bFmXP7llyxabPn26ff755/bWW29Z+/bt2cIeoh3895///MdNgqMZWKOPBQ2oHDVqlA0fPtxuvPFGv1c1bv34449uLIMGTzZr1iyiDTTAVWlWOi/VrVvX71WNWxwH/qMNsgG/axYiezrllFMCgwcPTvb+p556KlC3bt1MXadERDv476STTgq88cYbyd4/YsSIQPXq1TN1nRJN8+bNA9dcc03gwIEDSe7TsmuvvdY9Bt7hOPAfbZD10dONdMmfP78tWbLEatasGfP+lStXukoC+/fvZwt7iHbwn1KrFi9ebLVq1Yp5/08//WQNGjSwffv2Zfq6JQql8iilLbme7GXLltmZZ55JGUEPcRz4jzbI+sjpRrqcdNJJKeaqvvfee1a9enW2rsdoB/+dcsop9tprryV7v/KM9Rh4p0SJErZq1apk71+9erV7DLzDceA/2iDro0430uWxxx5zs18pX1J1iZVDqYoNmzdvthkzZrj8SdWMhrdoB/8NGTLE2rZta59++mnMY2H9+vX28ccf+72acU358t27d7eHHnrI5XZHt8GgQYOsT58+fq9mXOM48B9tkPWRXoJ0++qrr+yFF15wP/XhJuXKlbOzzz7b7rzzTvcT3qMd/Ldu3Tp75ZVXbMGCBUmOhd69e1vVqlX9XsW49/TTT7vzkbZ/cDZQDaZUOyjgvvfee/1exbjHceA/2iBrI+gGAMSNtWvXRnzxURlTAMgKCLoBAAAAjzGQEun2ww8/2BNPPGEvv/yym4Uv3M6dO13dYniPdvDfRx99ZDfccINLYVixYkXEfdu2bbMWLVr4tm6JQtVh5s6d62p2R1MVpbFjx/qyXomE48B/tEEW53fNQmRP06ZNC+TNm9fVia5cuXKgdOnSgZkzZ4bu37x5cyBnzpy+rmMioB38N378+ECuXLkCbdu2DZx77rmB/PnzB8aNGxe6n2PBeytXrgxUqVIlkCNHDnfeadasWeD333+nDTIRx4H/aIOsj6Ab6XL22WcHHnjgAff70aNHA88880ygcOHCgU8++cQtI9DIHLSD/xo0aBD497//Hfr77bffdsdCcMIcjgXvXX755YFLL7008OeffwZWrVoVuOyyywLVqlULrF+/njbIJBwH/qMNsj6CbqRL0aJFA6tXr45YNmHChEChQoUC77//PoFGJqEd/Kd9/pdffolYNmvWrECRIkUCr7zyCsdCJihTpkxgyZIlEctuvfVWdxVuzZo1tEEm4DjwH22Q9VGnG+mSL18+2759e8Sya6+91nLmzOnqd6teKLxHO/ivaNGi9scff0RUyWjevLl98MEHdumll9rGjRt9Xb9EyefOnTvy4+yll15y56NmzZrZhAkTfFu3RMFx4D/aIOsj6Ea6nH766TZr1ixr1KhRxPJOnTrZ0aNH3UQV8B7t4D9NL/7JJ5/YWWedFbFcwV4w8Ia3ateu7aaBr1OnTsTy4cOHu1rd7dq1owk8xnHgP9og66N6CdLllltusd9++y3mferxHjNmjJ1//vlsXY/RDv676667LH/+/DHvU4/3hx9+aN26dcv09UokV1xxhU2cODHmfS+++KI7Jyn4hnc4DvxHG2R91OkGAAAAPEZPNwAAAOAxgm4AAADAYwTdAAAAgMcIugEAAACPEXTjuCxZsiTZ+9599122LgAAmejzzz9P9j5V84F/qF6C41K+fHmbN2+eVa9ePWL5O++848qk7dmzhy2cCY4cOWKjR492J9stW7a4WunhZs6cSTt4TPv6U089lWwb/PLLL7RBJvj5559t9uzZMdvgkUceoQ08xnHgv+LFi9uMGTPsjDPOiFg+bNgwdwzs3LnTt3VLdEyOg+OuE33hhRfa/PnzXQAukydPtp49e7ogEJnjzjvvdNu7bdu2Vq9ePcuRIwebPpPdcMMNNmfOHOvatas7FmiDzPf666+7c1Lp0qWtXLlyEW2g3wm6vcdx4L/nn3/eLrnkEnc+qlu3rlv23HPP2eOPP24fffSR36uX0OjpRoYEfJ999pl9+eWX9umnn7qT7ptvvmlXXnklWzeTKMgYO3asO9HCv94lfaCdc845NIFPqlSpYrfeeqvdd999tIFPOA6yBgXZ6tmeO3eu6wgbNGiQmzm3adOmfq9aQqOnG8fthRdecL17mgZbs1RqZrj27duzZTNR3rx57eSTT2ab+6hEiRJWsmRJ2sBH27Zts6uvvpo28BHHQdbQr18/27p1qzVu3NilH06fPt2aNGni92olPHq6kWbvv/9+kmWHDh1yU9C2bNnS2rVrF1oe/ju8M2TIEJczrEEypDX4Y9y4cfbee+/ZmDFjrGDBgj6tRWLr1auXy2Pt3bu336uSsDgO/PHvf/872R7v888/384888zQsn/961+ZuGYIR9CNNMuZM3VFbxT86Rs2vHfFFVfYrFmzXE/rKaecYnny5Im4f8qUKTSDxxo0aGBr1qyxQCBgVatWTdIG3333HW3gscGDB9vQoUPd2Ib69esnaQOCDe9xHPijWrVqqf5cZlC3f0gvQZpFVwRA1sijVOAN/1x++eVsfp+99tprVrhwYTeATLfoYIOg23scB/5Yu3atT6+MtKCnGxlu+/btLggEAAD+0hXnpUuXuoHGyrmHf5gcB8fl6aefdiOjgzSISSkOJ554ov3www9s3Uz2559/utHqqp2u35H5Fi1a5PJax48fb99//z1N4BOl+egGf3Ac+KdPnz42YsSIUMCtnO6GDRtapUqVXA17+CgAHIdq1aoF5s2b536fPn16oHjx4oFp06YFevXqFbj44ovZtplk9+7dgR49egRy5coVyJEjh7vlzp070LNnz8CePXtoh0zwxx9/BC644AK37UuUKOGOBf3eokWLwJYtW2iDTDJmzJhAvXr1Avny5XO3+vXrB8aOHcv2zyQcB/478cQTAwsXLnS/T506NVChQoXAypUrAw8++GCgadOmfq9eQqOnG8dl06ZN7tuzfPjhh9axY0dXweTee++1hQsXsnUzyd133+1yWD/44AOX3qObKmloWd++fWmHTHDHHXe4md6WL19uf//9tytft2zZMreMXOLMoUGUmhxH9erfeustdxWudevWrpqJJgyB9zgO/PfXX3+5yaHk448/dlega9as6ar7KM0EPvI76kf2Vr58+VBPd82aNQNvvfWW+/2nn34KFClSxOe1SxylSpUKzJo1K8nymTNnBkqXLu3LOiWaokWLBr755psky7/++utAsWLFfFmnRFO1alXX0x1t9OjR7j54j+PAf5UrV3ZXnA8fPhyoVKlS4IMPPnDLly1b5q7AwT9UL8Fx6dChg1133XVWo0YNV4i/TZs2bvnixYuZrCUT7d2718qWLZtkeZkyZdx9yJyqPtEl6kTLqPiTeVfeYs24p2W6D97jOPBfjx493FXn8uXLu6o9F198sVv+9ddfW+3atf1evYRGegmOiy7Z3n777Va3bl2bMWOGK9cl+oDTdMzIHGeffbY9+uijtn///tCyffv22cCBA9198F6LFi3szjvvtN9//z20TDO0atKoCy+8kCbIBJqVVWkl0ZRmoo4BeI/jwH8DBgywN954w2666SY3qD5fvnxuea5cuez+++/3e/USGiUDgTig3GHlriroPu2001zvhq425M+f36ZNm+YmzIG3NmzYYO3bt3dtoXEOaoNff/3VTdKi/PqKFSvSBB575513rFOnTnbRRRfZOeec49pA1Xw+//xzF4xTy957HAdA8gi6ka5p4JVGosvmsaaED8c08JlHPdsqVffTTz+5Umm6+tC5c2crUKBAJq4FdMUnvA0UACJzS9XpCtyKFStCbaDBxJopEZmH4yDzp4FXz7Y6WpKbEj6Igd3+IehGuqaB37x5s8sXTmlKeKaBBwAgc6aB//bbb61UqVIpTgnPNPD+IugGsimuOPiP3iX/qSRj0aJFQ7+nJPg4ZCyOAyB1CLrhGQ0i08yU8AZXHPxH75L/NDhMA7eDV97UkxdNaSZcefMOx0H2ofkzzjjjDL9XI2ERdCPDKfXkySefdKOnlWcMAF7RBFAaNJk7d273e0qaNWtGQyDu7d69230ZDR/Po4H1Dz/8sJssR1PDwx+UDES6aMZDDdI74YQTrEKFCu7youqzPvLII1a9enVbsGCBjRw5kq2bScaOHWsHDhxIsvzgwYPuPnjvsccei1kTXV88dR+8oUBaAXewx/X88893y8JvWpZSnisyDseBfzZu3Oi+gBYrVszdNFOxzkndunVzvdsqHahqPvAPPd1IF9Xg1pTjKs/16aefukoBrVq1ciXrVC+aHiX/LrGH04RFWkbPBm2QCDgO/Ecb+KdLly5umvcbb7zRlc/84osv7PTTT3dlZNXLzRdP/zEjJdLlo48+slGjRrlyaArANSlFzZo1bdiwYWxRHwRzVmP1fKjHA/61wQ8//GAlS5akCXxsA11uVyk1+NcGHAfemzVrlqtHr97uq666yl2Fvvrqq5kQJwsh6Ea6aNY91b8VpZPoA+2GG25ga2Yy1R7WB5xumvUweJld1Lu9du1aN2kOvFOiRIlQG+iLZ3jAoTZQwNe7d2+awEO6jC7a9urRK1iwYEQbaPpr9fjBOxwHWWM81UknneR+L1eunMvp1oRdyDoIupEuyt/W5DjhlxQLFSrE1sxkl19+eWiQjNJ7ChcuHLovb968VrVqVbvyyitpFw/p6o5693r27GkDBw6MuLIQbIOzzz6bNvDQ999/736qHXR5Xds9vA10eb1fv360gYc4DrIGfRYHqZoPV3iyFnK6kS46mDUrpQZmiPK7W7RokSTwnjJlCls4E4wZM8bl13OC9Y8qZzRt2jTiyygyV48ePeyFF16gHrePOA78/VyuV69e6IrnkiVLrHbt2hFfQuW7777zaQ1B0I10f7ilhvK+gUTw66+/pnh/5cqVM21dAL9wHPhHV9pSQ8UO4A+CbiAOJDcpSBDVS2iDRKCrbSmZOXNmpq1LouJcBCSPnG4gDiiNJzzoPnTokMtzVdpJans/kDF5xdFtMHToUDdZFLyn3O3oNtB4h2XLlln37t1pgkzAcQAkj55uII5NmDDBJk+ebO+9957fq5LQ5TWfffZZmz17tt+rkrAGDBjgqsg899xzfq9KwuI4AAi6gbi2Zs0aO/XUU23Pnj1+r0rCWrVqlStXRxv4Z/Xq1XbmmWfa33//7eNaJDaOA4D0EiBuafrx4cOHW8WKFf1elYSwc+fOiL9Vvk6zhKqXtUaNGr6tF8y++uorKvtkEo4DIHnkdANxNDFFeMC3a9cuN0nIuHHjfF23RFG8ePEkg1nVDpUqVbJJkyb5tl6JpEOHDjG/+Hz77bdu0hx4j+MASB453UAc0IDJ6AoCJ5xwgjVp0sQF5Mic+sSx2uDkk0+OmCkUmVfKNNgGqmrSsmVLNn0m4Djwx7///e9UP/Zf//qXp+uC5BF0AwAAZGPVqlVL1eN0Ne6XX37xfH0QG0E3ECe2bdtmI0aMsBUrVrgTa506dVzPX8mSJf1etYSxcuVKl0cfbAPNBnf77be7n8g8SicJPw4aNWrE5s9EHAdAbDmTWQ4gm13SrVq1qrvEqOBbVRr0u3o/oi/3whv//e9/3RTMixYtcvWiVTVG0y3Xr1/f3n77bTZ7Jti4caOdd955rlLJnXfe6S6jn3HGGXbuuefahg0baINMwHEAJI+ebiAOKNhr2rSpvfLKK5YrV67QLJS33nqrzZs3z00OAm9Vr17dunTpYo899liSKZfffPNNLulmAuVtq3qGxjjUqlUr1Ovas2dPK1SokE2fPj0zViOhcRxknS+g77//vv3666928ODBiPs0YRf8QdANxIECBQq4mfeCgUaQAg7ViFb5QHhLlWKWLFniBk5G1ydWz/fevXtpgkw4DubPn28NGjSIWK4rDueccw7HQSbgOPDf559/bu3atXNXOvUZoE6ZdevWuWo+DRs2tJkzZ/q9igmL9BIgDuhEqhzWaFqmoBvea968uX355ZdJls+dO9elPMB7lStXdlO/Rzt8+LCdeOKJNEEm4DjwX//+/a1v377uCmf+/PntnXfecelVzZo1s6uvvtrv1Uto1LECsin1qgYpd1U5rJp576yzznLLFixYYC+99JI99dRTPq5lfNPl2yD1LN13330upzu8DZTPPXDgQB/XMnE888wzdscdd7j9XoMnNZBSgyp1bDAFvHc4DrIWdbZMnDjR/a5ypbrSWbhwYZf61r59e7vlllv8XsWERXoJkE2pBrGCCl0yTIkeo/xueNMGqUEbZN7EUHv27HE928Ha6MHfldPNNPDe4DjIWsqVK+dSSOrWrWunnHKKDR482HUK/PDDDy7Navfu3X6vYsKipxvIptauXev3KiS8o0ePJvw28NuwYcP8XoWEx3GQtehKmwbQK+hu27atSzVZunSpTZkyJXQVDv6gpxsAACBOaPIb9WarbKkGcPfr18+NLdEg7+eff96qVKni9yomLIJuIBvnUbZp08by5MkTkVMZiy4tIuOpFvpNN93kBisdaxpmpl72hkoEFi1aNPR7SoKPQ8biOABSh6AbyMZ5lJs3b7YyZcqkmFNJPrF3VJJLA/VKlSqV4jTMTL3sHdWl37RpU+g4CM/vDtK4B44D73AcZL1a6QsXLnTnpXDbt293la6YBt4/5HQDcZBHSU6l/3n15Nj7QwPGSpYs6X6fNWuWT2uR2DgOshbV5I41eP7AgQP222+/+bJO+B+CbiCbU11izcT3n//8x2rWrOn36iRsG2hiog8//NANXkLmUe3hYJWS2bNnu9knK1WqRBP4gOPAX+FphtOmTbNixYqF/lYQrklzqlat6tPaQQi6gWxOOd2aBCHWZXVkXhuoF4k28I/KAqoWd/fu3X1ci8TGceCvyy+/3P3UeSj6OFDbKOAeMmSIT2sHYUZKIA5069bNRowY4fdqJDRNyvL000+7Hlf448ILL3S93fAPx4F/lGaom2Zm3bJlS+hv3dQpoCnhL730Uh/XEPR0A3Hg4MGD9sYbb9iMGTOscePGbiKQcEOHDvVt3RLF119/7S7fTp8+3erXr5+kDVQjF95SNR9Nga0rP5qRMroNqOLjPY4D/zG+JOuiegkQBy644IIU72eAmfd69OiR4v2jRo3KhLVIbFTx8R/HQdYwZ84cl26lKeGVblKnTh2755577LzzzvN71RIaQTcAAECcGDdunPvy06FDBzftu0pmzp8/36ZOnWqjR4+26667zu9VTFjkdANxQBUbdu3alWT5nj173H3wXosWLVwd3GiasEX3wXtjx451uaux0q90H7zHceC/J5980p555hmbPHmym5TrzjvvdL8/9dRT9vjjj/u9egmNnm4gziYICffXX39ZuXLlGNyXyZMVhdOAphNPPNGVU4M/x8HWrVvdsli1i5GxOA78ly9fPlu+fLmb9j3c6tWrrV69erZ//37f1i3RMZASyMbUi6pLh7qpp1vTkQcpwPj444+TBCDIWEuWLAn9/uOPP7rAO7wNPv30Uxd0w3vBmSejbdy4MaJmMTIex0HWoTr1GtQdHXRrGTXs/UXQDWRjxYsXd0GGbrEmxtHygQMH+rJuieL0008PtUGsNJICBQrY8OHDfVm3RNGgQYNQG6hsoGp2h3/xUTWH1q1b+7qO8Y7jwH9KJXzhhResb9++Lq1k8eLF1rRpU3dczJ071+Vz6374h/QSIJuPUFfvnoK9d955JzQdtuTNm9eqVKliFSpU8HUd49369etdG1SvXt2++eYbO+GEEyLaQFcalPYA7wS/WOqnAo7ChQtHtIEmBbnyyivd7/AGx0HWSq/SoElNhKPqJRKsXtK+fXu/VzOhEXQDcfKBp8uGKZVMA+LdmDFjrFOnThFpVkCi59Mj6yDoBuKEKmeopzU4E1n0jJXw3s8//+xmRIzVBo888ghNkElUrSRWG2imPniP48C/oPuPP/6IuNqGrIWgG4gDH3zwgXXu3NmVCCxSpEjEYDL9/vfff/u6fong9ddft1tuucVKly7tKsZEt8F3333n6/olglWrVrm8VtUkjjXAkuol3uM48Dfo1oDhWIOJw/F54B+CbiAOaBDlJZdcYoMGDbKCBQv6vToJSfnzt956q913331+r0rC0kQgGkR5//33W/ny5ZMEH6eddppv65YoOA78DbqHDRt2zEo93bt3z7R1QiSCbiAOFCpUyJYuXeoG88EfRYsWddUCaAN/j4NFixZZ7dq1fVyLxMZx4B9yurM+Rl0BcaBVq1b27bff+r0aCe3qq6+26dOn+70aCa1u3bpuQij4h+PAP8dKK4H/qNMNxIG2bdu6clCanKV+/fqWJ0+eiPvbtWvn27olCk1E8fDDD9uCBQtitoHq5sJbTz/9tN17770uzSpWG6gXFt7iOPCPxi4gayO9BIgDKZUKZABZ5qhWrVqKbfDLL79k0pokruBxEN3jx0DKzMNxACSPoBsAEDeTRaWkWbNmmbYuABCNoBsAPLrMS44lEhnHARCJgZRAHPXyXXbZZS6nskaNGi6P+8svv/R7tRLK2LFjXS5xgQIF3O3UU0+1N9980+/VSrhJojT99Q033GA33nijPf/887Zjxw6/VyuhcBwAsRF0A3Fg3LhxdtFFF7ka3Rqwd/vtt7ug78ILL7QJEyb4vXoJYejQoW5yHNVLf+utt2zy5MnWunVr6927twv84D1V8DnppJPc9tYEIKpkonbRMiYnyhwcB0DySC8B4kCdOnXspptusrvuuivJB6BmiFuxYoVv65ZIA8gGDhxo3bp1i1g+ZswYGzBggK1du9a3dUsU5513nrvSo31ek+TI4cOHXa+3BrJ+8cUXfq9i3OM4AJJH0A3EgXz58tny5ctdwBFu9erVVq9ePdu/f79v65Yo8ufPb8uWLUvSBpqaXCkntIH3dHXn+++/TzI5jkppNm7c2Pbu3ZsJa5HYOA6A5JFeAsSBSpUq2eeff55kuZbpPnhPwbbSSqIpzUQ59vCe6nD/+uuvSZZv2LDBihQpQhNkAo4DIHlMjgPEgb59+7pcbk1D3rRpU1c1Y+7cuTZ69Gh74YUX/F69hKDUkk6dOrkUhnPOOSfUBvriEysYR8bT9u/Vq5c999xzEceBJo669tpr2eSZgOMASB7pJUCcmDp1qqvaEMzfVp63go327dv7vWoJY9GiRW4Qn9pA5dI0Lbm+EDVo0MDvVUsIBw8edPv8q6++6nK5RbNSaoDrU0895dKw4D2OAyA2gm4AQFxR7vaaNWvcFx+lO6iqDwD4jaAbiAMLFy60o0ePWpMmTSKWf/3115YrVy43iAze+vjjj922btWqVcTyadOmubZp06YNTeAx1eM+cuSIlSxZMmK5ygeqmolyvuEtjgMgeQykBOLAbbfd5gaLRfvtt9/cffDe/fff7wK+aOpt1X3w3jXXXGOTJk1Kslw59boP3uM4AJJH0A3EAZVEa9iwYZLlyiXWffCeSgMqhzuaytepdCO8pys7F1xwQZLlzZs3d/fBexwHQPIIuoE4oAFif/zxR5LlmzZtCk0SAm8VK1bMTcASTQF3oUKF2PyZ4MCBA6EBlOEOHTpk+/btow0yAccBkDyCbiAOXHzxxda/f3+X0xq0fft2e+CBB9x98F67du2sT58+bgBfeMCt6iW6D94744wz7LXXXkuyXNVMGjVqRBNkAo4DIHkMpATigHK3zz//fNu6dWuoPJ1qdpctW9ZmzJjBBDmZQF94Wrdubd9++61VrFjRLdu4caObmnzKlClWvHjxzFiNhDZv3jy76KKLXPB94YUXumWqk66BxtOnT3dtAW9xHADJI+gG4sSePXts/Pjx9sMPP7jpsE899VQ3IYjqFCNzaNCkvuSEt4G+DCHz6Mvms88+634G20BXgZgVNPNwHACxEXQDAAAAHiOnGwAAAPAYQTcAAADgMYJuAAAAwGME3QAAAIDHmDUDiBOqy/3f//7X1Ym+5557rGTJkvbdd9+5soEnnnii36sXl3bu3JnqxxYtWtTTdYHZ6NGjrWPHjlawYEE2h4+OHj3qatRv2bLF/R6Oaj5IZFQvAeLAkiVLXH1izQa3bt06W7lypVWvXt0efvhhW79+vY0dO9bvVYxLOXPmtBw5cqTqsUeOHPF8fRJd+fLlXenMq6++2nr16mVNmzb1e5USzoIFC+y6665z5x2VDgynY4XjAImM9BIgDtx99912/fXX26pVqyx//vyh5W3atLEvvvjC13WLZ7NmzbKZM2e628iRI61MmTJ277332tSpU91Nv+tKg+6D9zQZ0bhx42zbtm12wQUXWO3ate3pp5+2zZs3s/kzSe/eva1x48a2bNky+/vvv11bBG/6G0hk9HQDcUA93EolOemkk6xIkSJuchb1dKu3qVatWrZ//36/VzHuaQbEG264wU1IFG7ChAluavLZs2f7tm6JSKkNCsCVcvLTTz+52ULV+33ZZZe5KxTwRqFChdz55+STT2YTA1E48wBxQL3bsfKLlWZywgkn+LJOiearr75yPXzRtOybb77xZZ0Sma46nHPOOXb22We7IHvp0qXuapC+mPIFyDtNmjRx+dwAkiLoBuJA+/bt7bHHHrNDhw6Fcid//fVXu//+++3KK6/0e/USQqVKlezVV19Nsvw///mPuw+Z448//rDnnnvOTjnlFGvevLn7Mvrhhx/a2rVr7ffff7cOHTpY9+7daQ6P3HHHHda3b193hWHRokVuvEn4DUhkpJcAcUCBxSWXXGLLly+3Xbt2WYUKFVweq3r5Pv74Y3fJF97SdtYXHPWknnXWWaFBZaom884777j2gbeUOjJt2jSrWbOmS/Xp1q2bq+ITToF3xYoVk1TVQMaIlbqjTgANqmQgJRIdQTcQRzSgT7ndCigaNmzoKpogcwfyvfLKK7ZixQoXZNStW9cNLKOnO3MoZ1vBtr5sJkftoqtAVapUyaS1SiwaR5IStjsSGUE3kM0dPnzY5XQvXrzY6tWr5/fqJCSl9bRs2dKlkqiXFf5QacxOnTpZvnz5IpYfPHjQJk2a5Hq+AcAv5HQD2Vzu3Lld7xH1b/2TJ08eVyIttTW74Y0ePXrYjh07kixXypXuQ+ZQSpVyu3Wl7eKLL7Z//etfbhmQ6Ai6gTjw0EMPWf/+/amD6yP1oo4YMcLPVUh4wbzhWGk/KqsJ7ymnXmlVqthz6qmnuqtvX3/9tRvYOmPGDJoACY30EiAONGjQwJXpUpqDer2jB04qzxveUs+e0htUn1hlAqPbYOjQoTSBh/u/gm3Vh1Zwp6s/QboCpMolqtP91ltv0QaZ0BatWrWyp556KmK5KilNnz6dcxES2v+fmQBkW5dffrnfq5DwlF6iwavy888/R2wP0k4yZ//XuAYFfIULFw7dlzdvXqtatSqlMzOJBhHH+nLTs2dPGzZsWGatBpAlEXQDceDRRx/1exUSnqaEh7/7v4JrDaTUwGL4Q5Nx6ctPjRo1IpZrmSYsAhIZQTcAIC4w6Y3/brzxRrvpppvsl19+saZNm7qrPHPnzrWnn37aTZoDJDJyuoE4mZAipRQGKptkjoULF9rbb7/t6kCrTF24KVOmZNJaJBZNfqN0ntKlS1uJEiVSPA7+/vvvTF23RB3MqjSSIUOGuImIRJN13XPPPa6KCalWSGT0dANxYOrUqRF/a0Dl999/b2PGjLGBAwf6tl6JJFgHWvW6VaVBP1etWuVmBr3iiiv8Xr249fzzz1uRIkVCvxPU+Uvb/6677nI3lWqUYPsAiY6ebiCOTZgwwSZPnmzvvfee36sS91Qe7eabb7bbbrvNBRmqpFGtWjW3rHz58nz5AYAER9ANxDFNSKFgcM+ePX6vStxTicDly5e7wXxKddDAyvr167tqDi1atLBNmzb5vYpxaefOnal+bNGiRT1dl0Slqj2ff/65S+8Jlm9MDuVLkchILwHi1L59+2z48OFWsWJFv1clYXKLg5fTTzzxRFdCUEH39u3bbe/evX6vXtwqXrz4MVNKgpPmMLbBG+3bt7d8+fKFfifFB4iNoBuIA9EDyBRkKAAsWLCgjRs3ztd1SxTnnXeey+VWoN2xY0e78847bebMmW7ZhRde6PfqxS1KNWatkqUDBgzwdV2ArIz0EiAOjB49OiLoVjUT1ctt0qSJC8jhPVXG2L9/v6vUcPToUXvuuedcqTTNUPnwww/TDkgI1atXd1V8SpUqFbFcV3yUhqJSgkCiIugGAGRbS5YssXr16rkvmvo9JRrfAG+pHVSxJ3oinD/++MMqVaqUpJQmkEhILwHiwKeffuqmvj733HPd3y+99JK9/vrrVrduXfc7vd3e02DJZs2aJZkddNu2bW4KcqWaIOOdfvrpoSBPv+uKj9KropHT7a33338/9Pu0adOsWLFiob+VS6+BlqrmAyQyerqBOKA8Ys34dskll9jSpUutcePGbvY3BXp16tSxUaNG+b2KCdHDp0vq55xzjo0fP95VMwn28CnlhEF83li/fr1VrlzZBdX6PSVVqlTxaC2g/V9ifenJkyePq+qjCXMuvfRSNhYSFkE3EAfUy61qGfpg00Am/f7f//7XledSIK6eQHgfdGhCItXlVonGDz74wLUHQTcSiXqzldOtspkAIv3vqymAbC1v3ryhsnSfffaZmw0xWMYuLXWMcXw0Cc6cOXNc7vAZZ5xhs2fPZpNmspUrV9rtt9/uKsZcdNFF7nctQ+ZYu3YtATeQDIJuIA4ol/vuu++2xx9/3L755htr27atW/7zzz9TpzuTBKvHqF6x0ktUMrB169b28ssvZ9YqJDxd3dGgykWLFtlpp53mvvzoao+Wvf322wm/fTLDv/71L/v3v/+dZPmLL75offr0oQ2Q0EgvAeLAr7/+arfeeqtt2LDBfej16tXLLb/rrrtcLnGsD0F4X7XhnXfese7du7uJisjpzpxydV26dLHHHnssYrkGt7755puUq8sEmhhKgyobNWoUsVxfftq1a2cbN27MjNUAsiSCbgDI4AF94ZRfr55XBd/wliaDUtlA1UYPt2rVKtfzzcyg3sufP7/b56PbYPXq1e6Kg2rZA4mKkoFAnFBP6rvvvmsrVqxwgZ+qlmhK5ly5cvm9agkhucoYCjR0g/eaN29uX375ZZKAT5MUacZQeE/bXiVMlUsf7pNPPnFXIoBERtANxAH1IqlKyW+//Wa1atVyJbuUz63JKD766CM76aST/F7FhKCqDcodVrpP9CQgU6ZM8W29EqU+tNIX7rvvPndl4ayzznLLFixY4Npk4MCBPq5l4tDYEgXcf/75p6tdL6rRrXKBw4YN83v1AF+RXgLEAQXcCrQ1gE8VS2Tr1q0uv1W5xgq84a1JkyZZt27dXOWYGTNmuJ9Ka1Ce9xVXXEGtdI/rQx8Lk+NknldeecWefPJJ+/33393fwVKmOj6AREbQDcQBTcSiHj1NkhPuhx9+cJO17N6927d1SxSqlKEa3bfddpsVKVLEbXvVLNYylRKkpxWJRr3dBQoUcPMIAKBkIBAXVKZu165dSZYr2FYNb3hvzZo1oVKNag9NkKPeVVWQee2112gCJJwTTjiBgBsIQ043EAc0tfJNN91kI0aMsDPPPNMt+/rrr613794uzxXeU1pP8IuPyqapgoOuPGzfvp2qGZlIX3Y0QVGsvHqV00Tm1Et/6623YraBSgcCiYqgG4gDqsOtknRnn3225cmTxy07fPiwC7hfeOEFv1cvIag6hnK5FWh37NjRTY4zc+ZMt0yzI8J733//vRvfoNKACr71Reivv/5ypQRVP52gO3PORQ8++KA7H7333nvWo0cPdxVIg4yVegUkMnK6gTiigXsqGSh169ZNUjoN3vn7779dDeIKFSrY0aNH7bnnnnOl6tQGDz/8sJUoUYLNnwklA2vWrOkG8hUvXtzl1etLqAYU60tQhw4daAOP1a5d201GdO2114bGNqhU4COPPOKOEc1MCSQqgm4gzqiKiURP0gLEOwXaSqtS2Uz9/tVXX7l69VqmnteffvrJ71WMe7qqoC/+qluvqwu60qOJidQhoDKOqqoEJKrU1VoCkOUpn1uTsGhGON30+xtvvOH3asW9nTt3puoG76lXO/hls2zZsi6nWIoVKxb6Hd4qV65cKLBW4K2qSrJ27dpQhwCQqMjpBuKA0heef/55u+OOO1xet6iXT5Uz1q1bZ0888YTfqxi31KOa0lUFBRrUiM4cDRo0sG+//dalmFxwwQUupUE53W+++WaScprwhibE+eCDD6xhw4bWq1cvdw7SwEq1C+k9SHSklwBxoHTp0jZ8+HCXRxlu4sSJLhBX4AFvqFJGeICtgXy6wqAKJuGaNWtGE3hMgZ0qyCjgVo1opZQE8+pHjRrl0hzgLY1n0C137v/16amKSbANVE2JEqZIZATdQBzQIL1vvvnGatSoEbFcU8GrhKDK1iFzhA8eQ+bRFx6lkCiPWBOyIPOpYpJmouzZs6dVqlSJJgCikNMNxAFVZ1DFhmialKVz586+rBOQ2UG3vnRu3LiRDe8T9W4/++yzduTIEdoAiIGcbiCOBlJOnz7dVQgQDWDasGGDdevWze6+++7Q44YOHerjWgLeyJkzpwu6NYgv+ooPMs9FF11ks2fPtuuvv57NDkQh6AbigGY/1MAl0UQUwSmYddN9QZQRzBxsZ38888wzds8997irPqreg8zXpk0b69+/vzvvNGrUyAoVKhRxPzPkIpGR0w0AxyG6IoMqN6iCQ3SwMWXKFLZzJoxt0GyUyi3WgL3o3G5NzgLvrzgkhyo+SHT0dANx4I8//nB1iWNZsmSJnXrqqZm+TolCNaCj8+vhj2HDhrHpfabKJQBio6cbiAOq2KAyddGXbjUVuWp479u3z7d1A5CY9u/f7ybqAvA/VC8B4sB9991nnTp1cnVwFWD/9ttvLsVBlQQmT57s9+oBmUZjGh566CFXs37Lli1u2aeffmrLly+nFTKBKpc8/vjjrk594cKF7ZdffnHL9eVfg72BREbQDcSBvn37umol8+bNc6kkuimfVaklDFxCIk1UpJknv/76a5dDv3v3brdcx8Gjjz7q9+olBNXpHj16tBvUGj4RjtpFV+OAREbQDcQJTcZyyimnuGnfd+7caR07dkw2zxuIR/fff7898cQTNmPGjIiATzNUfvXVV76uW6IYO3ZsaH6AXLlyhZarI+Cnn37ydd0AvxF0A3Eg2MO9evVq16unkmma/l2B97Zt2/xePSBTLF261K644ooky1U6U/W74T2ltmnK91gDLA8dOkQTIKERdANxQPnbyulWb16dOnXshhtusO+//97NzqfLukAiKF68uG3atCnJch0LyjGG93S17csvv0yy/O2337YGDRrQBEholAwE4oBmomzWrFnEspNOOsnmzp3rciyBRHDddde5QcUK8FQTWr2rugrUr18/NzMrvKfc+a5du7oeb21/5davXLnSpZ18+OGHNAESGiUDAQBxQekLmn580qRJFggELHfu3K6ahoJxDe4LzzGGd6ZNm2aDBg2yRYsWucBbs+U+8sgj1rJlSzY7EhpBN5CNXXLJJTZx4sTQBC3q1b7tttvcZXZRHut5551nP/74o89rCmRu2UCllCjgU0pDjRo12PwAfEfQDWRj6rlTDqsmx5GiRYva4sWLXSWT4EyVFSpUcL19AOA1nXsWLlxopUqVili+fft21+MdrNsNJCJyuoFsTJfQU/obSCT6cqk0ks8//9xNjBM9JfnMmTN9W7dEoZKlsb7kHzhwwOV5A4mMoBsAEBfuvPNOF3S3bdvW6tWr5wZTInO8//77ETndwZQ3URCuL0JVq1alOZDQCLqBbExBRXRgQaCBRKUBlG+99ZYb64DMdfnll4fOP927d4+4L0+ePC7gHjJkCM2ChEbQDWRjSidRtYZ8+fK5v/fv32+9e/e2QoUKhS7pAolCs1DGmpgF3gum8lSrVs3ldJcuXZrNDkRhICWQjfXo0SNVjxs1apTn6wL4TT2pGqj34osvcsUHQJZD0A0AiAuaAn7WrFlWsmRJNzOi0hrCaaIWeE/528kNZh05ciRNgIRFegkAIC6oPr0Cb/hn4MCB9thjj1njxo2tfPnyXHEAwtDTDQAAMoQC7WeeecZNBQ8gUs6ovwEAANLl4MGD1rRpU7YeEAM93QCAbEvTvKe2TOZ3333n+fokuvvuu88KFy5sDz/8sN+rAmQ55HQDALJ9fWhkDSpb+tprr9lnn31mp556apLBrEOHDvVt3QC/0dMNAAAyxAUXXJB8wJEjh82cOZMtjYRF0A0AAAB4jPQSAEBcyJkzZ4r53UeOHMnU9QGAcATdAIC4MHXq1Ii/Dx06ZN9//72NGTPG1Y+Gdzp06JCqxzFBERIZQTcAIC60b98+ybKrrrrKzU45efJk69Wrly/rlQiKFSvm9yoAWR453QCAuLZmzRpXSWPPnj1+rwqABMbkOACAuLVv3z4bPny4VaxY0e9VAZDgSC8BAMSFEiVKRAykDAQCtmvXLitYsKCNGzfO13UDANJLAADZ2uLFi+300093Ayajq5mccMIJ1qRJExeQA4CfCLoBANmagmtNB3/DDTfYddddx6A+AFkSOd0AgGxt3rx51rBhQ7v//vutfPny1rVrV5s1a5bfqwUAEejpBgDEzaDJt956y0aNGmVffvmlVa1a1Xr27Gndu3dnICUA3xF0AwDiskyggu+xY8fapk2b7OKLL7aPP/7Y79UCkMAIugEAcWn37t02fvx4e+CBB2z79u1MAw/AV5QMBADElTlz5tjIkSPtnXfesVy5clnHjh2ZjRKA7+jpBgBkexs2bLDRo0e729q1a61p06Yu0FbAXahQIb9XDwDo6QYAZG/K11a1EtXk7tatmxs8WatWLb9XCwAikF4CAMjWChQo4FJJLr30UpdOAgBZEeklAAAAgMeYHAcAAADwGEE3AAAA4DGCbgAAAMBjBN0AAACAxwi6AQAAAIJuAAAAIHujpxsAAAAwb/0f9MHu9TS1/wkAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -909,24 +936,24 @@ }, { "cell_type": "code", - "execution_count": 10, - "id": "cf40380a-5814-4164-a592-7ab181776b5a", + "execution_count": 70, + "id": "6a15775f-af9e-4940-b18d-eb16bd0c8c85", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, - "execution_count": 10, + "execution_count": 70, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -959,7 +986,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 71, "id": "651e31cb-5a55-4a22-a7c3-b5f79b3a20ef", "metadata": {}, "outputs": [], @@ -985,7 +1012,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 72, "id": "ee3b0217-fe14-44a9-98f5-e1fc7f45e613", "metadata": {}, "outputs": [ @@ -995,13 +1022,13 @@ "" ] }, - "execution_count": 12, + "execution_count": 72, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjUAAAHACAYAAABaopmvAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAV+pJREFUeJzt3QdY1fX+B/A3e4OCICi4EQeCllaaOcptpmmO6qa2u5kNLUeWpZmrbJfd/71dvWZW7p1p5TZzJIIiuEWRKcqUec7/+XwPBwEBBYGz3q/nOc85vzN//H6ezrvPd1lptVotiIiIiEyctaF3gIiIiKg6MNQQERGRWWCoISIiIrPAUENERERmgaGGiIiIzAJDDREREZkFhhoiIiIyCww1REREZBYYaoiIiMgsMNQQERGRWTCpULNr1y4MGjQIDRo0gJWVFdauXVvp9/j1119x3333wc3NDd7e3hg2bBjOnTtXI/tLREREtcekQk1mZiZCQ0Px1VdfVen1Z8+exeDBg/Hggw8iLCxMBZzk5GQMHTq02veViIiIapeVqS5oKZWaNWvWYMiQIUX35ebm4p133sEPP/yAa9euITg4GPPmzUOPHj3U4ytXrsTjjz+OnJwcWFvr8tyGDRtU0JH77OzsDPb3EBERkQVVam7l6aefxt69e/HTTz8hPDwcw4cPR79+/XDq1Cn1eMeOHWFjY4NFixahoKAAqamp+P7779GnTx8GGiIiIhNnNpWaM2fOIDAwEJcuXVJ9bvR69eqFe+65B7Nnzy7qlyNh58qVKyrYdO7cGZs3b0adOnUM9rcQERHRnTObSs3ff/8NyWctW7aEq6tr0WXnzp0q8Ij4+Hg899xzGDNmDA4ePKges7e3x2OPPaZeS0RERKbLFmZCo9GopqXDhw+r6+Ik3Iivv/4a7u7umD9/ftFjS5cuRUBAAP766y81KoqIiIhMk9mEmg4dOqjmpMTERDzwwANlPicrK+umwKPfllBEREREpsukmp8yMjLUUGy5CJlfRm7HxMSoZqcnn3wSo0ePxurVq9Vj0sQko5+kz4wYOHCgum/mzJmq87A0WUnn4saNG6tQRERERKbLpDoK79ixAz179rzpfukjs3jxYuTl5WHWrFlYsmQJYmNj4eXlpToCz5gxA+3atVPPlZFR0vx08uRJODs7q8cl+LRq1coAfxERERFZZKghIiIiMovmJyIiIqLyMNQQERGRWTCJ0U8yMuny5ctqEUqZdI+IiIiMn1arRXp6upoUV788ESw91EigkblkiIiIyPRcvHgR/v7+Nf45JhFqpEKjPygyeR4REREZv7S0NFWU0P+O1zSTCDX6JicJNAw1REREpsWqlrqOsKMwERERmQWGGiIiIjILDDVERERkFkyiT83tkgUtZakEIlNnZ2d30+KrRERkAaFGxsHHx8fj2rVrht4VompTp04d+Pr6cm4mIiJLCjX6QOPj46MWqeQEfWTqIT0rKwuJiYlq28/Pz9C7RERkEmzNoclJH2hkVW4ic+Dk5KSuJdjIv202RRERWUBHYX0fGqnQEJkT/b9p9hMjIrKQUKPHJicyN/w3TURkoaGGiIiILBtDjYV4//330b59+6LtsWPHYsiQIQbdJyIiourEUGMgEiqkeWHu3Lkl7l+7dm2tNDt8/vnnWLx4MUyJHBc5PjWlR48eeP3112vs/YmIqGYx1BiQo6Mj5s2bh6tXr9b6Z3t4eKh5UCwBO9oSERnGpZSsWv08hhoD6tWrl5pcbc6cORU+b9WqVWjbti0cHBzQpEkTLFiw4JbvLRWg+vXrq+Xen332WWRnZ5d4vHTz08qVK9GuXTs1lFiGxsu+ZWZmFj3+3//+t2gfZN6UV155peixmJgYDB48GK6urmoV9REjRiAhIaHczxJSEZHKiJ7cfvXVVzFp0iR4enqq4yJNZnryd4tHH31UVWz026WdP39ePb58+XL1nhIcly5diitXruDxxx+Hv7+/GlUkf+uPP/5YYh937typKljyernIe4nIyEgMGDBA/X1yTJ966ikkJyff8hwQEVmqnPwCfPXHKTzy9d5a/Vxrs5y4LDffIBf57MqQuUdmz56NL7/8EpcuXSrzOYcPH1YhYdSoUYiIiFA/9O+++26FTUfyg/7ee+/hww8/xKFDh1QI+eabb8p9flxcnPrBf+aZZ3DixAns2LEDQ4cOLfp7Fi5ciHHjxuGFF15Q+7B+/Xq0aNGi6HhLYElJSVGhYNu2bThz5gxGjhyJyvrf//4HFxcX/PXXX5g/fz5mzpyp3k8cPHhQXS9atEjtr367PJMnT1YhSf6evn37qlB39913Y+PGjTh27Jj6WyScyGcJCTOdO3fG888/r95fLgEBAeq6e/fuqj+SHMstW7aowCbnhIiIbrbnVDL6f7YbH289idx8DWqTyU++V9r1vAK0mf6rQT47cmZfONtX7pBK5UF+MCWEfPfddzc9/sknn+Chhx5SQUa0bNlSVQ4++ugjVV0oy2effaYCynPPPae2Z82ahd9+++2mao2e/HDn5+erINO4cWN1n1Qy9OT1EydOxGuvvVZ0X6dOndS1vG94eDjOnTunQoD4/vvvVVVHgof+ebcjJCREHQcRGBiIr776Cr///jt69+4Nb2/vEksH3IpUguTvKe7NN98suj1+/HgVUFasWIF7771XNcfZ29urKk7x95dAd9ddd6nwqSdVK/lbT548qc4HEREBCWnZmLXpBDYcvawORz1XB0wY2BxPflZ7R8fsKjWmSPrVSJVCwkppUmm4//77S9wn26dOnVKzKZdFXiNVh+JKbxcXGhqqgpMEmeHDh+Pf//53UT8fmdH28uXL6vHyPkt+4PWBRrRp00aFD3msMiTUFCcVJv1SAZXVsWPHEttyrKRyJZ8hzWvSlLR161bVdFYRqZRt375dPV9/adWqlXpMKlJERJYuv0CD/+45h4cW7FSBxtoKGNulCX6f2B0Phzao1X0xu0qNk52NqpgY6rOrolu3bqqJ5O23376p+iLNO6VHQ1W2met2msGkmWffvn3qh16aw6ZNm6aaZurVq1fha8vav9L3W1tb37TPZXXelZWpi5PXazRVK11KM1Zx0g/p008/VVUsCW/yuFRzcnNzK3wf+fxBgwap4Fka12QiIkt3+MJVvLP2GE7Epant0IA6+HBIMIIbeqjttLzrtbo/Zhdq5Iewsk1AxkA69kozVOnmDKl67Nmzp8R9Ej7keeWtB9S6dWvs378fo0ePLrpPtm913KQCJJfp06erZqg1a9ZgwoQJqlOuNAP17NnzptfJ/km14+LFi0XVGqk4paamqv0Q0nQk/ViKCwsLuynE3Io8v7zq1K3s3r1bdWb+xz/+URRWpNql30chzU+l31+anqSjthwDW1vT+3dFRFQTrmbmYt6WKPx08KLa9nCyw+R+rTCqUwCspVRjIGx+MhJSPXjyySdVlaQ46csigeKDDz5QfTikmUr6mhTvH1Ka9H2Rfh9ykddIP5Xjx4+X+3ypyEifEekIKwFl9erVSEpKKvrBl87JUun44osvVBD4+++/i/ZTRklJk47su9x/4MABFaakc62+CejBBx9U771kyRL1etmf0iHndujDlazKXtlh8NKxWV+NkmaxF198Ub1P6feXYyGjnmR0kwQf6SAtnaClI7X8bWfPnlXVLOmzVNWARURkqjQaLX4+GIMHF+woCjTD7/bHHxO744l7Gxk00AiGGiMiwaV0M41UCmQ0008//YTg4GBVRZFRQeV1EhYy8kieJyOAZMTPhQsX8M9//rPc58sw7F27dqlhy1IBeuedd1SI6d+/v3p8zJgxqtlGRlBJB+CHH35YhZPiE+LVrVtXNaNJyGnWrBl+/vnnoveXpjXp6CzDtaXjcHp6eokq0u2SfZJgIhWhDh06VOq18vlyLGVfZKi3dAYuPcxcgqJUv6T6JNUlCXgNGjTA3r17VYCR18o5kNAoHYulWY2IyFJEXk7DY9/uw+RVEbialYeg+m5Y8VJnfDQ8FF6uDjAGVtrq7qBRA9LS0tSPiDRpyA9wcTKiR0beNG3aVM1JQmQu+G+biIxBenYePt12Cv/78zwKNFq42Nvgjd4tMaZLE9jZWFf597smsJMAERER3URqHpsi4vDBxkgkpOWo+wa288M7D7eGn4cTjBFDDREREZVwNikD760/jt2ndLOnN/FyxozBwejeUjdnmLFiqCEiIiIlO68AX28/jX/tPIvcAg3sba0xrkcLvNi9GRyrOG1JbWKoISIiIvwRlaCqMxdTdHPLSFVm5uC2aOxVct4vY8ZQQ0REZMFir13HjPXHsTVStxCxn4cj3hvUBn3b+pY5uaoxY6ghIiKyQHmFyxt89tsptW6irbUVnn2gKV59MBAuDqYZD0xzr4mIiKjKDp1PwbQ1xxCdkK6272niiQ+GBCPI182kjypDDRERkYUovbxBXWc7vD2gNR6729/kmprKwlBDRERkAXPOrPo7FrM3n0BKpm4h35EdAzClfyvUdbGHueA871QpixcvRp06dYq2ZV0oWYiTiIiM0+nEdIz6v/14c8VRFWhkeYOVL3XGvMdCzCrQCIYaA0lMTFSLKjZq1AgODg5qLSJZW+jPP/8seo5+XSVjJuslySKTpkQWrpS1rGqKrMtVel0pIqLadj23AB/9GoX+n+/GX+dS4GRng6n9W2Hjq13RsYmnWZ4QNj8ZyLBhw5CXl6dW3ZYFIBMSElQ4kBWhq5t8jp2dHWqCq6uruliCmjyORETVaXtUIqavP1Y050yv1j54/5G28K/rbNYHmpUaA7h27Rr27NmDefPmoWfPnmjcuDHuueceTJ06FQMHDiyqJohHH31UVWz022LDhg1q9W1ZwFMC0YwZM5Cfn1/0uDz/22+/xeDBg+Hi4oJZs2YVNRN9//336r1kgbFRo0apFbNv1dwk1SRnZ2e1L1euXCnxeOnmpx07dqi/RT5Xmqnuv/9+tUq43vr169GxY0e17/Xq1cPQoUOLHrt69apavVtW/JbPk1XC9auBl/VZQiouxY+Nvkry8ccfw8/PD15eXhg3bpwKJEJW6Jb9eeONN9RxqqhjXFnHUVbrfvbZZ9UCqk5OTggKCsLnn39eYh8lqK5bt67o/eWYiNjYWLWCuvx9sl/yvufPn6/w+BMRVUZc6nX8c+lhPL34oAo0DTwc8X9P3Y3/jOlk9oHGPEONLDqem2mYy20ueK6vbkjTUk6ObpGw0g4ePKiuFy1ahLi4uKLtX3/9Ff/4xz/w6quvIjIyEv/6179U8Pjwww9LvP69995TP5oRERF45pln1H1nzpxRn7lx40Z12blzJ+bOnVvufv7111/qtS+//DLCwsJUAJMf9vJIsJJA0b17d4SHh6umtBdeeKEoOGzatEmFGAluR44cUZUpCTjFA8mhQ4dU8JHXSse2AQMGFAWS27V9+3b1t8q1BAw5PnIRq1evhr+/P2bOnKmOq1wqUvo4ajQa9frly5er4z99+nS8/fbbalvfHDdixAj069ev6P27dOmCrKwsdfzkvO/atUuFWrktz8vN1XXaIyKqqvwCDb7bcw69FuzEL8fiYWNthRe6NcO2Cd3Rp62vxRxY82t+yssCZjcwzGe/fRmwv/V00ra2tupH9vnnn1eVgLvuuksFAamchISEqOd4e+sWDZNqh/S30ZPwMmXKFIwZM0ZtS6Xmgw8+wKRJk9QPsN4TTzxRFGb05AdZPtfNTTcPwVNPPaWCRelApCcVCOnnI58nWrZsiX379mHLli3lLjEvy8s//PDDaN68ubqvdevWJfZd/kapLOmFhoaqa6nISJjZu3evCgHihx9+QEBAgApiw4cPx+2SSshXX30FGxsbtGrVSoUo+TvleHt6eqr75RgUP67lKes4Ft9/qdjIMZFQI2FGgopUcCSsFn//pUuXwtraGv/5z3+KQp4EVjm/Usnp06fPbf99RETFHYm5quaciYxLU9t3NaqDDx9th9Z+7hZ3oMyvUmNCfWouX76sfsglOMgPm4QbfUWhPIcPH1ZVBn21Ry7yYy0VAakG6BWvgOhJM40+0AhpnpEOy+U5ceIEOnfuXOK+0tvFSWCQaov8PYMGDVKhqHglRKo9Dz30ULmfJWHv3nvvLbpPmmikeUceq4y2bduq4HK7f2dFyjqOEkTlfgmecvz//e9/IyYm5pbn7fTp0+r468+bHK/s7GxVVSIiqqzU63l4Z20Ehi7cpwKNh5Md5gxth5UvdbHIQGOelRo7Z13FxFCfXQnSr6R3797qIs0Yzz33nKq2SDAoj1RbpFJQvC9K8ffTkz4gN+1eqU6uUjGQ9yuPNP9UllQfpGlMqjk///wz3nnnHWzbtg333XefqmBU9rPkfn1lQyodpZ9XVtNUZf/OipQ+jlKRkf44CxYsUAFPQspHH32kmuoqIp8v/aCk+lSavipHRHQ75L+D68IuY9amSCRn6Jqvh93lj7cHtIKXq4NFH0TzCzXyA3gbTUDGqE2bNiWGcMuPs3RMLU6qOdHR0WjRokWt7M/+/ftL3Fd6uywdOnRQF+n4LD/8y5YtU6FGmtakGejpp58u87OkT46EA33zk3RKPnnyZFETlvz4x8fHlwg6Uv2pLHt7+5uO6+3avXu32j/pZ6RXutJS1vvLeZOQ5+PjA3d3y/w/KCK6c2eSMvDu2mPYd0Y3aKO5twtmDWmHzs29eHjZ/GQY8mP94IMPqn4W0qH23LlzWLFiBebPn686pRZvLpIQID/kMjJISEVnyZIlapTN8ePHVdOMviJS3fQVF9kvCRfST6W8/jRC/g4JMtLJV0YYbd26tUQokSrUjz/+qK5lv6Xzrby3CAwMVH+7NKVJJ9qjR4+qDtENGzYsOiYycikpKUm9RoLE119/jV9++aXSf5ccV+msK6ORkpOTK/VaCZPSmVk6bMvf9u677xZ14i7+/nJeJXzK+0s16cknn1SjveRvkWAkx0o6ar/22mu4dOlSpf8GIrIs2XkF+GTbSfT/bLcKNA621nirbxB+ea0bA00x7FNjANKfQvqOfPrpp+jWrRuCg4PVj6P8oEtw0JMmDmm6kc6yUvkQ0l9FRi7J/Z06dVIVkE8++UQNC69u8t7SsfXLL79UQ6klpFQUnmQYdlRUlOovJJ2KZeTTK6+8oiYZ1IcSCW/Sj0jeT4Jd8WYbabqSJhrpaCwVHqnIbN68uag5ScLRN998o8KMdDA+cOCAGm1UWdInSYZSS2fmyjb9vPTSS6rpT4ZmyzmUgFq8aiPkPEpfIH2/G+n8LMdGgpQMj5fXy98iHZCvX7/Oyg0RVWjv6WQ1gd4Xv59CboEGPYK8se2N7hjXswXsbfkzXpyVtiodJ2qZjKqReVVkZE3p0r10tJT/65VRKMX7lBCZOv7bJrJsyRk5+HDTCaw5Equ2fdwc1AR6/YN9TWbxybQKfr9rgvn1qSEiIjJhGo0WKw5fxOzNUWqEk+SX0fc1xsS+QXB35KzmFWGoISIiMhKnEtLVnDMHzuuWzGnj547ZQ9uhfcCNhYSpfAw1RERERtAR+Ks/TuNfu84gr0CrFp+c2KclxnZpAlsb9pu5XQw1REREBrT7VBLeWXsMF65kWdTikzXBbEKNCfR3JqoU/psmMm9J6TlqAj2ZSE/4ujuqMNO3bX2T6QhsbEw+1OiH+8oSARXNWEtkavTLXpSeIZmITL8j8M+HLmLO5hNIy86HtXQE7txENTe5sSOwZYcaWeNHFgXUr+0j84Ew4ZKpV2gk0Mi/afm3XXwdKyIybdHx0hE4Aocu6CZUDW7ojtmPtkOIPzsCVweTDzVCvxpyVRctJDJGpVdoJyLTdT23AF/+cQr/t+ss8jVaONtLR+AgjOncmB2Bq5FZhBqpzMhKzLKuTlkLHBKZGmlyYoWGyDzsPJmk1muKSdE1KfduUx8zHmmLBnXYZaK6mUWo0ZMfAf4QEBGRMUhMz8YHG09gw1FdR2A/D31HYFZga4pZhRoiIiJj6Ai87EAM5m2JQnphR+CxXZpiQp+WcHXgz25N4tElIiKqJlHxaXh7dQT+jrmmtts19MCcoe0Q3NCDx7gWMNQQERFVw4zAsoq2viOwi70N3uwbpIZq20iphmoFQw0REdEd2Hs6GW+viSiaEbiPdAQe3BZ+HuwIXNsYaoiIiKrgSkYOPtx0AquPxBbNCCxhhh2BDYehhoiIqJITZK7+O1YtcXA1Kw+yosHo+xqr5ibOCGxYDDVERES36XxyJqatjcDe01fUditfN8we2g53NarLY2gEGGqIiIhuIa9AozoBS2fgnHwNHGyt8VqvQDz/QDPY2Vjz+BkJhhoiIqIKHL5wVQ3Tjk5IV9tdW9TDh48Go7GXC4+bkWGoISIiKkNadh4+2hKNpX9dgFYLeLrY492HW2NI+4ZcONlIMdQQERGVsuVYPN5bfwwJaTlq+7G7/fH2gNYq2JDxYqghIiIqFJd6HdPXHce2yAS13cTLGbMfbYcuLerxGJmASvVumjNnDjp16gQ3Nze1IvaQIUMQHR19y9fl5ORg2rRpaNy4MRwcHNC8eXP897//vZP9JiIiqjYFGi0W7z2HXgt2qkBja22FV3q2wJbXuzHQmGulZufOnRg3bpwKNvn5+Sqo9OnTB5GRkXBxKb/D1IgRI5CQkIDvvvsOLVq0QGJiono9ERGRoZ2IS8OU1RE4elG3XtNdjepgztAQBPm6GXrXqJKstDKLUBUlJSWpio2EnW7dupX5nC1btmDUqFE4e/YsPD09q/Q5aWlp8PDwQGpqKtzd3au6u0REREWu5xbg899P4d+7z6pKjZuDLSb1b4Un72kEa67XVC1q+/f7jvrUyE6KisLK+vXr0bFjR8yfPx/ff/+9qug88sgj+OCDD+Dk5FRuc5Vcih8UIiKi6rL7VBKmrTmGmBTdek39g33x/iNtUd/dkQfZhFU51EiBZ8KECejatSuCg4PLfZ5UaPbs2QNHR0esWbMGycnJePnll5GSklJuvxrpuzNjxoyq7hoREVGZUjJzMWtjZNF6TX4ejpg5OBi929TnEbPk5ifpW7Np0yYVWPz9/ct9nvS52b17N+Lj41UJSqxevRqPPfYYMjMzy6zWlFWpCQgIYPMTERFVifzUrQu7jJkbI1WwkfWaxnRuotZrcnXgQGCLbn4aP368albatWtXhYFG+Pn5oWHDhkWBRrRu3Vr9A7t06RICAwNveo2MkJILERHRnbqYkoVpa49h18mkovWa5gxthw5cr8nsVCrUSBCRQCPNSDt27EDTpk1v+Zr7778fK1asQEZGBlxdXdV9J0+ehLW19S0DERERUVXlF2iweN95LNh6EtfzCmAv6zU9FIgXunG9JnNlXdkmp6VLl2LZsmVqrhppUpLL9evXi54zdepUjB49umj7iSeegJeXF55++mk19FuqO2+99RaeeeaZcjsKExER3YnIy2kYunAfZm06oQLNvU09seW1BzCuZwsuQGnGKlWpWbhwobru0aNHifsXLVqEsWPHqttxcXGIiYkpekyqM9u2bVMVHhkFJQFH5q2ZNWtW9fwFREREhbLzdMO0ZUVtNUzb0VYtbzCyYwCHaVuAO5qnprZwnhoiIrqVfaeT8faaCJy/ohumPaCdL94f1BY+HKZtMCbRUZiIiMhYXMvKxezNJ7D80CW17esuw7Tbok9bX0PvGtUyhhoiIjJJ0tCwMTwOMzYcR3JGrrrvqfsaY1K/ILg52hl698gAGGqIiMjkxF67jnfXHsMfUYlqu4WPK+YObYeOTaq2HA+ZB4YaIiIyGdL59/s/z+OjX6ORmVsAOxsrNaLpnz2aw8HWxtC7RwbGUENERCYhOj4dU1aH40iMbjXtuxvXVdWZwPpcTZt0GGqIiMjoh2l/s/00Fu48g7wCrVrWYDJX06YyMNQQEZHROnAuRVVnziZlqm1ZeFJGNvl5cPJWuhlDDRERGZ207DzM/SUKy/7STebq7eaAmY+0Rb9gX1jJapREZWCoISIio7ItMgHvrI1AQlqO2n78ngBM6dcaHs4cpk0VY6ghIiKjkJSeg/c3HMem8Di13cTLGXOGhqBzcy9D7xqZCIYaIiIy+CR6q/6OxQcbI5F6PQ821lZ4/oFmeL1XIBztOEybbh9DDRERGczFlCy1XtPuU8lqu20Dd8wbFoLghh48K1RpDDVERGSQSfQW7zuPj3+NxvW8AjjYWuP1Xi3x3ANNYWdjzTNCVcJQQ0REtT6J3uRV4Qi7qJtE796mnpg7LARN67nwTNAdYaghIqJakZNfgK+3n8HCHafVJHpuDraYMqAVHu/UCNbWHKZNd46hhoiIatzhC1cxZVU4TiVmqO1eretj1pBg+Ho48uhTtWGoISKiGpOZk68Wn/zfn+eh1QL1XO3x/iNtMbCdHyfRo2rHUENERDVi58kkvL06ArHXrqvtoXc1xLsD26Cuiz2PONUIhhoiIqpWVzNz1Zwzq4/Equ2GdZwwe2g7dG/pzSNNNYqhhoiIqm0SvQ3hcZix/jiuZOZClmga26UJ3uwTBBcH/txQzeO/MiIiumNxqdfxzppj+D0qUW23rO+qhmnf1agujy7VGoYaIiKqMo1Gi2UHYtSK2hk5+bCzscK4ni3wco8WsLflJHpUuxhqiIioSs4lZ6pJ9A6cS1HbHRrVUUsctKzvxiNKBsFQQ0RElZJfoMF3e87hk20nkZOvgZOdDd7qG4QxXZqoxSiJDIWhhoiIbltUfBomrQxH+KVUtd21RT3MGdoOAZ7OPIpkcAw1RER0S7n5Gny1/TS+2X4a+Rot3Bxt1Zwzwzv6cxI9MhoMNUREVCFZeHLSyqM4maBb4qB3G90SB/XducQBGReGGiIiKtP13AJ8si1a9Z/RaAEvF90SBw+HcIkDMk4MNUREdJP9Z6+oBSjPX8lS20PaN8D0QW3hySUOyIgx1BARUZH07Dw158wPf8WobV93R8weGowHW9XnUSKjx1BDRETK9qhEvL0mAnGp2Wr78XsaYeqAVnB3tOMRIpPAUENEZOFkAcqZGyOxpnABykaezpg7rB26NK9n6F0jqhSGGiIiC16AclNEHN5bp1uAUubNe+b+ppjYJwhO9jaG3j2iSmOoISKyQIlp2Xhn7TFsjUxQ24E+rpj/WAg6cAFKMmEMNUREFladWXH4EmZtjERadj5sra3wco/mGPdgCzjYsjpDpo2hhojIQlxMyVIdgXefSlbb7Rp6qOpMaz93Q+8aUbVgqCEiMnMajRbf77+AeVuikJVbAAdba7zRuyWe69oUtjbWht49omrDUENEZMbOJWdi8spwHDiforY7NamLecNC0Mzb1dC7RlTtGGqIiMxQgUaL/+45h4+3RiMnXwNnextM7tcKT93XGNYyzInIDDHUEBGZmVMJ6XhrZbhaiFJ0bVEPc4a2Q4Cns6F3jahGMdQQEZmJ/AIN/rXrLD7/7RRyCzRwc7DFtIGtMbJTAKysWJ0h88dQQ0RkBk7EpeGtlUdxLDZNbfcI8sbsR9uhQR0nQ+8aUa1hqCEiMmG5+Rp8vf20uuRrtHB3tMV7g9pi6F0NWZ0hi8NQQ0RkoiIuparqTFR8utru06Y+Zg0Jho+7o6F3jcggGGqIiExMdl4Bvvj9lOo/I6OcPF3sMeORtng4xI/VGbJoDDVERCbk75irmLQyHKcTM9S2BBkJNF6uDobeNSKDY6ghIjIB13ML8Mm2aHy35xw0WqCeq4NqauoX7GvoXSMyGgw1RERG7sC5FExaeRTnr2Sp7aEdGmL6oDao42xv6F0jMioMNURERiozJx/zt0Thf39eUNu+7o6YPTQYD7aqb+hdIzJKDDVEREZo7+lkTF4VjktXr6vtkR0DMO3h1nB3tDP0rhEZLYYaIiIjkp6dh9mbo/DjgRi13bCOE+YOa4cHAr0NvWtERo+hhojISOw8mYQpq8IRl5qttmXxycn9W8HVgf+pJrod/KYQERlY6vU8fLgpEssPXVLbjTydMW9YCDo39zL0rhGZFIYaIiID2h6diKmrIhCflg1Zc/LpLk3xZt+WcLbnf56JKovfGiIiA1VnZm2MxIrDuupMEy9nfDQ8FJ2aePJ8EFURQw0RUS37IyoBU1dHICEtR1Vnnrm/Kd7sEwQnexueC6I7wFBDRFRLUrPyMHNjJFb9ravONK3ngo8eC0FHVmeIqgVDDRFRLfj9hK46k5iuq84817UpJvYJgqMdqzNE1YWhhoiohqszMzYcx+ojsWq7mVRnhofg7sbsO0NU3RhqiIhqyG+RCXh7ja46Yy3VmQeaYULvlqzOENUQhhoiomp2LSsXMzZEYk1hdaa5t1RnQnFXo7o81kQ1iKGGiKgabT0ej7fXHENyhq4683y3ZnijF6szRLWBoYaIqBpczczF+xuOY13YZbXdwsdVjWzqwOoMUa2xrsyT58yZg06dOsHNzQ0+Pj4YMmQIoqOjb/v1e/fuha2tLdq3b1+VfSUiMkq/Ho9H7093qUAj1Zl/9miOjeO7MtAQGXOo2blzJ8aNG4f9+/dj27ZtyM/PR58+fZCZmXnL16ampmL06NF46KGH7mR/iYiMRkpmLl798Qhe/P6wam4K9HHF6pfvx+R+rdgZmMgArLRarbaqL05KSlIVGwk73bp1q/C5o0aNQmBgIGxsbLB27VqEhYXd9uekpaXBw8NDBSN3d/eq7i4RUbXZciwO76yVvjO5sLG2wkvdm+HVhwLhYMt5Z4gM9ft9R31qZCeFp2fF8y0sWrQIZ86cwdKlSzFr1qxbvm9OTo66FD8oRETGUp2Zvu4YNobHqe2W9V3x8fBQhPjXMfSuEVm8KocaKfBMmDABXbt2RXBwcLnPO3XqFKZMmYLdu3er/jS323dnxowZFn9yiMi4bDkWj3fWRhRVZ/7ZvTnGP9SC1RkiUw81r7zyCsLDw7Fnz55yn1NQUIAnnnhCBZSWLVve9ntPnTpVBabilZqAgICq7ioRUbWObGJ1hsiM+tSMHz9e9YvZtWsXmjZtWu7zrl27hrp166p+NHoajUZVeeS+rVu34sEHH7zl57FPDREZyrbCWYGTCmcFfql7c7zWi31niEy+T42EEQk0a9aswY4dOyoMNEL+gIiIiBL3ffPNN/jjjz+wcuXKW76eiMhY1mySeWek70z7APadITJWlQo1Mpx72bJlWLdunZqrJj4+Xt0vKczJyamo6Sg2NhZLliyBtbX1Tf1tZLSUo6Njhf1wiIgM6Y8o3YraCWmcFZjIbEPNwoUL1XWPHj1uGt00duxYdTsuLg4xMTHVuY9ERLUi9XoeZm2MxIrDl4qtqB2KuxtzzSYis5+nprawTw0R1bQd0YmYsioC8WnZsJIVtbs2xcQ+QZxEj8hc+9QQEZmb9Ow8fLjpBH46eFFtN/FyVn1nOjapeP4tIjI+DDVEZLF2n0rC5JXhuJyqq86M7dIEk/q2gpM9ZwUmMkUMNURkcTJy8jF78wks+0vX/6+Rp7NaUfveZl6G3jUiugMMNURkUfadTsZbK8MRe+262h7TuTEm928FZ3v+55DI1PFbTEQWITMnH3N/icL3+y+obf+6Tpj/WAi6NK9n6F0jomrCUENEZm//2St4a+VRXEzRVWeevLcRpg5oDVcH/ieQyJzwG01EZisrNx/zt0Rj8b7zarthHSfMGxaCroGszhCZI4YaIjJLB8+n4K0VR3H+SpbafvyeALw9oDXcHO0MvWtEVEMYaojIrGTnFWDB1mj8Z885yNSifh6OmDssBN1beht614iohjHUEJHZCLt4DROXh+FMUqbafuxuf0wf1AburM4QWQSGGiIyebn5Gnzx+yks3HkGBRotvN0cMHdoOzzUur6hd42IahFDDRGZtMjLaZiwPAxR8elq+5HQBpjxSFvUdbE39K4RUS1jqCEik5RfoMHCHWfwxR+nkFeghaeLPWYNCcaAdn6G3jUiMhCGGiIyOacS0jFxxVGEX0pV233a1MeHj7ZTzU5EZLkYaojIZEh/me/2nMXHW0+qfjTujraYMbgthrRvCCtZkZKILBpDDRGZhPPJmXhzxVEcunBVbfcI8sbcoSHw9XA09K4RkZFgqCEio6bRaNV6TbJu0/W8ArW0wbsPt8aIjgGszhBRCQw1RGS0Ll3NwqSV4dh35ora7tLcSy1C6V/X2dC7RkRGiKGGiIyOVqvFzwcvYtamE8jIyYeTnQ2mDmiFf9zbGNbW7DtDRGVjqCEio5KQlo3Jq8KxIzpJbXdsXBcfDw9Fk3ouht41IjJyDDVEZDTVmbVhsXhv3XGkZefD3tYab/ZpiWe7NoMNqzNEdBsYaojI4JIzcjBtTQR+PZ6gtkP8PbBgeCgC67sZeteIyIQw1BCRQf0SEYdpa48hJTMXdjZWePXBQPyzR3PY2ljzzBBRpTDUEJFBpGblYfr6Y1gXdlltt/J1w4IRoWjbwINnhIiqhKGGiGrdjuhE1Rk4IS0H0l1GKjOvPdRS9aMhIqoqhhoiqjWZOfn4cPMJLPsrRm03q+eiqjMdGtXlWSCiO8ZQQ0S14sC5FExcEYaLKdfV9tguTTC5Xys42dvwDBBRtWCoIaIalZ1XgAVbo/GfPeeg1QIN6zjho+Eh6NK8Ho88EVUrhhoiqjERl1IxYXkYTiVmqO0RHf3x7sNt4OZox6NORNWOoYaIql1egQZfbz+Nr/44jXyNFvVcHTB3aDv0alOfR5uIagxDDRFVq1MJ6Ziw/CgiYlPV9sB2fvhgSDA8Xex5pImoRjHUEFG1KNBo8d895/DR1mjk5mvg4WSHmYPb4pHQBrCy4iKURFTzGGqI6I7FXMnCmyuO4sD5FLXdI8gb84aFoL67I48uEdUahhoiuqNFKH88cBGzNkUiK7cALvY2eOfhNhjVKYDVGSKqdQw1RFQlCWnZalbgHdFJavuepp74+LFQNPJy5hElIoNgqCGiSldn1h+9jOnrjiP1ep5a2mBS3yA8c39TWMuaB0REBsJQQ0S3TVbSfmdtBDZHxKvtdg098MmIUATWd+NRJCKDY6ghotvyW2QCpqyOQHJGDmytrTD+wUC83LM57Gy4CCURGQeGGiKqUHp2Hj7YGInlhy6p7UAfV3wyoj3a+XvwyBGRUWGoIaJy7T97BROXH0XsteuQqWaef6AZJvRuCUc7LkJJRMaHoYaIbrkIpX9dJ1WdkRFORETGiqGGiEo4FpuKN36+sQilzDkjc8+4OvA/F0Rk3PhfKSJS8gs0+HbnGXz226nCRSjtMXdoCBehJCKTwVBDRDiXnIkJy8NwJOaaOhr92vriw0eD4eXqwKNDRCaDoYbIwifSW7r/AmZvjsL1vAK4OdhixuC2eLRDQy5zQEQmh6GGyELFp2bjrZVHsftUstru0twLHw0PRcM6TobeNSKiKmGoIbJA68Ji8e7aY0jLzoeDrTWm9G+FMZ2bcJkDIjJpDDVEFuRalixzcAwbw+PUdoi/bpmDFj5c5oCITB9DDZGF2BGdiEkrw5GYngMbtcxBC4zr2YLLHBCR2WCoITJzWbn5+HDTCfzwV4zabubtgk9HtEdoQB1D7xoRUbViqCEyY4cvXFVDtS9cyVLbY7s0Uf1nuMwBEZkjhhoiM5Sbr8Hnv5/Ewh1noNECfh6O+Hh4KO5vUc/Qu0ZEVGMYaojMTHR8Ol7/OQwn4tLU9tAODfHeI23h4WRn6F0jIqpRDDVEZqJAo8V3e87i419PIrdAg7rOdpj9aDv0b+dn6F0jIqoVDDVEZuBiShYmrjiKA+dS1PZDrXwwZ1g7+Lg5GnrXiIhqDUMNkYkvc7Dq71i8v/44MnLy4Wxvg+kPt8HITgFc5oCILA5DDZGJSsnMxdurI7DleLzavrtxXTWRXmMvF0PvGhGRQTDUEJmg7VGJeGtlOJIzcmBrbYU3erfES92bq0n1iIgsFUMNkQlPpBfo44pPR7ZHcEMPQ+8aEZHBMdQQmYi/Y65iws9hOF84kd6zXZvirb5BnEiPiKgQQw2Rkcsr0ODL30/hq+2nOZEeEVEFGGqIjNjpxAy88XMYImJT1faQ9g0wY3AwJ9IjIioDQw2REdJotPh+/wXM3nwCOfkaFWJmDQnGoNAGht41IiKjZV2ZJ8+ZMwedOnWCm5sbfHx8MGTIEERHR1f4mtWrV6N3797w9vaGu7s7OnfujF9//fVO95vIbMWnZmPMogN4b/1xFWgeCKyHX1/vxkBDRFSdoWbnzp0YN24c9u/fj23btiE/Px99+vRBZmZmua/ZtWuXCjWbN2/G4cOH0bNnTwwaNAhHjhypzEcTWYQNRy+j72e7sPtUMhxsrTFzcFsseeYe+HpwZmAiolux0sqUpFWUlJSkKjYSdrp163bbr2vbti1GjhyJ6dOn39bz09LS4OHhgdTUVFXtITI3qVl5mL7+GNaFXVbbIf4e+GREe7TwcTX0rhERVVlt/37fUZ8a2Unh6el526/RaDRIT0+v8DU5OTnqUvygEJmrvaeT8eaKo4hLzVaT543r2QLjH2wBO5tKFVKJiCxelUONFHgmTJiArl27Ijg4+LZft2DBAtVcNWLEiAr77syYMcPiTw6Zt+y8AszbEoVFe8+r7SZezvhkZHvc1aiuoXeNiMiymp+kb82mTZuwZ88e+Pv739ZrfvzxRzz33HNYt24devXqValKTUBAAJufyGwci03F6z+HqSHb4sl7G2HawNZwtueARCIyH2mm0Pw0fvx4rF+/XnUCvt1A8/PPP+PZZ5/FihUrKgw0wsHBQV2IzE2BRotvd57Bp9tOIl+jRT1XB3z0WAh6tvIx9K4REZm8SoUaKepIoFmzZg127NiBpk2b3naF5plnnlHXAwcOrOq+Epm0iylZaiK9Qxeuqu1+bX0xe2g7eLrYG3rXiIgsL9RIk9OyZctU85HMVRMfH6/ul9KSk5OTuj116lTExsZiyZIlaluCzOjRo/H555/jvvvuK3qNPF9eR2Tu5H8GVh6+hBkbIpGRkw9XB1u8/0hbDLurIaysuKo2EZFB+tSU9x/gRYsWYezYseq2XJ8/f15VckSPHj3UkO/SxowZg8WLF9/W53JIN5mqq5m5mLo6AluO68J8x8Z11araAZ7Oht41IqIaV9u/33c0T01tYaghU7TzZBLeWnEUiek5sLW2whu9W+Kl7s3VsG0iIkuQZgodhYmo4qHaczafwP/+vKC2m3u74PNRHRDckM2tREQ1iaGGqAaHao/p3BhT+reGk70NjzMRUQ1jqCGqgaHa3m4O+Hh4KLq39ObxJSKqJQw1RNUwVHvC8jAcPM+h2kREhsRQQ1RF0sd+1d+xeH/9cTVU28XeRg3Vfuxufw7VJiIyAIYaoioO1X57TQR+OXZjqLasqt3Ii0O1iYgMhaGGqJJ2nUxSq2pzqDYRkXFhqCGqxFDtub9EYfG+80VDtT8b2QHt/DlUm4jIGDDUEFVhqPbozo0xlUO1iYiMCkMN0S2Gav9rl26odl6Bbqi2rKrdI4irahMRGRuGGqIKhmpPXH4UB86nqO2+betjztAQrqpNRGSkGGqIyhiqveZILN5bdxzphUO133ukLYZzqDYRkVFjqCEqJjUrD9PWRmBjeJzavltW1eZQbSIik8BQQ1Ro35lk1dwUl5qtVtJ+/aFA/LNHc9jaWPMYERGZAIYasng5+QX4ZOtJ/N/us9Bqgab1XPDpyPZoH1DH4o8NEZEpYaghi3YqIR2v/RSGyLg0tf34PQF4Z2AbuDjwq0FEZGr4X26y2M7AS/68gNmbTyAnX4O6znaYOywEfdv6GnrXiIioihhqyOIkpmdj0spw7IhOUtvdW3qruWd83B0NvWtERHQHGGrIomyLTMDkVeFIycyFva013u7fCmO6NOGq2kREZoChhixCVm4+Pth4Aj8eiFHbrf3c8fmo9mhZ383Qu0ZERNWEoYbMXvila3j9pzCcTc5U2y90a4aJfVrCwdbG0LtGRETViKGGzHrdpoU7TuOz304hX6OFr7sjPhkRii4t6hl614iIqAYw1JDZrts0YXkYDp6/qrYHhvjhwyHBqONsb+hdIyKiGsJQQ2ZFhmqvDYvF9LW6dZtcHWwx45G2GHpXQ3YGJiIycww1ZNbrNn02sj0CPJ0NvWtERFQLGGrILPx55gomLg/DZa7bRERksRhqyKTl5muwYFs0/m+Xbt2mJl7O+GxUB67bRERkgRhqyGSdTtSt23T8MtdtIiIihhoy0c7AP/wVg1mbIpGdx3WbiIhIh5UaMilXMnLUMge/nUhU2w8E1sOC4aFct4mIiBhqyHTsiE7EmyvCkZyRA3sba0zu3wpPd2kCa2srQ+8aEREZAVZqyOhl5xVg3pYoLNp7Xm23rO+Kz0d1UOs3ERER6THUkFGLik/Daz+GITohXW2P7dIEU/q3gqMd120iIqKSGGrIaDsDL953HnN+iVLDtuu52uOjx0LRs5WPoXeNiIiMFEMNGZ3E9Gy8tSIcO08mqe2eQd74aHgo6rk6GHrXiIjIiDHUkFH5LTIBk1aFIyUzFw621pg2sDWeuq8x120iIqJbYqgho3A9twAfbo7E0v0xaruVrxu+eLwDWtZ3M/SuERGRiWCoIYM7FpuK1346gjNJmWr7ua5N8Va/IDjYsjMwERHdPoYaMhiNRov/7DmLj36NRl6BFj5uDlgwIhQPBHrzrBARUaUx1JBBxKdmY+KKMOw9fUVt925TH/OGhcDTxZ5nhIiIqoShhmrdlmNxmLI6Atey8uBkZ4Ppg9pgVKcAdgYmIqI7wlBDtSYzJx8zN0Ti50MX1Xa7hh74bFR7NPd25VkgIqI7xlBDteLoxWt4/ecwnEvOhJUV8FL35nijV0vY21rzDBARUbVgqKEaVaDR4tudZ/DptpPI12jh5+GIT0a0R+fmXjzyRERUrRhqqMZcvnYdb/wchr/OpajtAe18MfvRdqjjzM7ARERU/RhqqEb8EqHrDJx6PQ/O9jZ4/5G2GH63PzsDExFRjWGooWqVlZuPGetvdAYO8ffA56M6oGk9Fx5pIiKqUQw1VG0iLulmBj7LzsBERGQADDVULTMD/3v3WXy8VTczsK+7Iz4ZGYouzevx6BIRUa1hqKFqnRm4X1tfzBnaDnU5MzAREdUyhhqqsq3H4zF5VTiucmZgIiIyAgw1VGnXcwswa1MkfvgrRm23beCuOgO38OHMwEREZDgMNVQpxy9LZ+AwnE7MUNsvdGuGiX1awsHWhkeSiIgMiqGGbrsz8H/3nsP8LdHILdDAx80BC0aE4oFAbx5BIiIyCgw1dEuJ6dmYuPwodp9KVtu9WtfH/MdC4MnOwEREZEQYaqhCf0Ql4K0V4biSmQsHW2u8+3AbPHlvI84MTERERoehhsqUnVeAOZtP4H9/XlDbrf3c8cWo9gis78YjRkQktFpAkw/k5wAFubqLup0HaAt0j6mL3C7cLnG/ptR9xZ5XdH/xx/LlQ3Wfq9uBwqvS27ixfcvnFj0ZsLIGrG0AKyvAyqbYtnWxbetS28Uft7r5+VnZtfpvhaGGbhIVn4bXfgxDdEK62n62a1NM6hfEzsBEZHzkR1lCRF4WkHe92LX+dlYZ9xVeSwDRh5AC/e3cMkJK6etiz7+RIKgsObV7fBhqqIhWq8X/9p3H7F+ikJuvQT1XB3w8PAQ9gnx4lIioegKIhImcdCAnA8hJA3Izbmznphd7LF33mFzKCiS5xW5LRcMYSGXCxgGwsddVLNTFVndRVQ3bYvdJJcOm8vfJ++g+rMTVjW2rMrYreky/LVUdje4iVSE5V3Jci7YLH1P3aYvdV9Zzim1nSfDbi9rCUENKckYOJq0Mxx9RiWq7Z5A3PhoeqoINEZH6kcpOBbKvAdevlbyW+0uEkTLCif5afuhqivzg27kAdk66i73+tvON+4puOwO2hQFELvrb6loudjdu29oXuy5+u9i1up8/qTdJSwNe90Bt4Rkg7DqZhAnLj6pgY29rjWkDWmN058bsDExkbqTZRAJI6VBy/Wr5geV64f1SVak2VoCDO+DgCti7Ag5uuttybV/8duHj9sWCSNF1GfdJECmqPpAlYqixYNLEJItQ/t+us2q7ZX1XfPF4B7TydTf0rhHRrUgn05xUIPMKkKW/JOuuM+U6peR9sl0dwUQqIU51AMc6N64dPQBH95IBRYWTcsKKBBCGDzJ0qJkzZw5Wr16NqKgoODk5oUuXLpg3bx6CgoIqfN3OnTsxYcIEHD9+HA0aNMCkSZPw0ksv3em+0x04m5SBV386gmOxuv/IPXVfY0wb2BqOdpwZmMggCvJ1ASQjoTCYlBVWit93pep9SaRKooKIPph43BxUnOqWfFwfXqS5hcgcQo2Ek3HjxqFTp07Iz8/HtGnT0KdPH0RGRsLFxaXM15w7dw4DBgzA888/j6VLl2Lv3r14+eWX4e3tjWHDhlXX30GV6Ay84vAlvL/+OLJyC1DH2Q7zh4WgT1tfHkOi6iYdKqXpJiNRF1aKrovfLryW6kpVRtJIBcTFC3DWX+oBzp6AS71S98m1py7QsO8HmSkrrfzKVVFSUhJ8fHxU2OnWrVuZz5k8eTLWr1+PEydOFN0nVZqjR4/izz//vK3PSUtLg4eHB1JTU+HuzqaRqkq9noe310RgU3ic2u7czAufjmwPXw/HKr8nkUWSUTfp8bpAklk6sJS6lmHAleno6uKtCyE3BRWvUmGlMLxIZ1YiI5VWy7/fd9SnRnZSeHp6lvscCS5SzSmub9+++O6775CXlwc7O7s72QW6TYfOp6iFKGOvXYettRUm9GmJF7s1h401O9URFZH/x5N+J2mXgbRYIC3uxu30YrelY21lSNONa33A1afwuvjtYvdJSJFhu0RUu6FGCjzST6Zr164IDg4u93nx8fGoX79+iftkW5qvkpOT4efnd9NrcnJy1KV40qOqyS/Q4Kvtp/HF76eg0QKNPJ1VZ+D2AXV4SMnyOtZKP5T0y8VCi1zH3bgtwUWGHd8OW8cyAkoZt6XyYsdqKJFRh5pXXnkF4eHh2LNnzy2fa1Wql7u+xav0/cU7JM+YMaOqu0aFpCrz+k9HcPC87v8qh3ZoiBmD28LNkdUxMkO5mcC1i8C1GCA1Rnc79WJhcCkMLLfbFCSVFfeGgLsf4N5Ad9vNr/A+2fbTPYcjeIhMP9SMHz9e9ZPZtWsX/P39K3yur6+vqtYUl5iYCFtbW3h5eZX5mqlTp6oqUPFKTUBAQFV21WJtjojDlFXhSMvOh6uDLWYNCcaQDg0NvVtEVSfzpkhIKQoucn3hRniRKswtWemqJyWCSoNiAabwPpkXhYjMO9RIhUUCzZo1a7Bjxw40bdr0lq/p3LkzNmzYUOK+rVu3omPHjuX2p3FwcFAXqrys3HzMWB+Jnw9dVNuhAXXw5agOaOTF/0iTEZPqrcyjoiosMaWCS+G2zMlyKzLkuE4jwKMRUCcA8JCLBBUJLg0AN1/dBG1EZJYqFWpkOPeyZcuwbt06uLm5FVVgpGezzFujr7LExsZiyZIlRSOdvvrqK1V5kWHd0nFYOgn/+OOPNfH3WLRjsal49ccjOJucqariL/dojtd7tYSdjX6tECIDz2YrAeXqOSCl8KK/LRUXWcPnVmTUjwotAbpr/UVtB+hCDRFZrEqFmoULF6rrHj16lLh/0aJFGDt2rLodFxeHmJiYosekmrN582a88cYb+Prrr9Xke1988QXnqKlGGo0W/917DvO2RCGvQAtfd0d8MjIUXZrXq86PIbo1WWTw6nkg5Wyx8FJ4W6ott5osztVXF06KB5U6jW/clrV8iIhqYp6a2sJ5asqXlJ6DiSuOqvWbRJ829TFvWAjqunDWT6oh0kxUVrVFwktGyf5zZY4YqtsU8JRLM6BuE91tuU/6s3CUEJFZSTOleWrIsHZEJ+LNFbIQZS4cbK3x7sNt8OS9jbgQJVVPxSXlDJB8Ekg+DVw5BVw5rQsvMkNuRaQJSAWW4uGl8LZUYqzZHEpENYOhxgTl5Bdg3i/RqslJtPJ1U3PPtKzvZuhdI1MiRVoZ6iyBJbnwor8tHXQrIuGkdGDRV1xkAjkiIgNgqDExpxMzVGfgyDjdhIRjuzTBlP6tuBAlVVx1kSqLVF3U9anC22eAvMzyXycLGnoFAvUKL14tbjQZsW8LERkhhhoTIV2flh+6iPfXR+J6XgE8Xezx0WMheKh1ydmayYKrLrLOUOKJkhUXuaRdKv91Vja6Cku9lrrQosKLhJiWurWHiIhMCEONCS5EeX8LL3wyoj3qu3PqdYskqzlLeJFLklxH6a4rWo/IyVMXVOq1KFZ9aamrunDeFiIyEww1Ru7whRS8+uONhSgn9gnCi92awZoLUZo/CSkSWBIjgaSoG0EmK7n8FZ6leaheULHwIkEmkP1ciMgiMNQYqQKNFgt3nManv51St7kQpRnLTrsRWtR1pC7MlDs82gqo2xjwbg34FF68W+kCDIdEE5EFY6gxQvGp2Xj95yPYfzZFbT8S2gAfPhrMhShNXX6uroNufASQeLyw8hJVcZ8XmXROAkvx8OIdxI66RERlYKgxMtsiE/DWyqO4lpUHZ3sbzBwcjGF3NeTcM6Y4QV3CMSBeLhFAggSZKECTV/bzZRFFFV7aAD4SXCTABAGONT9ZFRGRuWCoMRLZeQWYs/kE/vfnBbUd3NAdX4zqgGberobeNaqIRqObUVcFl8IAI0GmvOqLgzvg2w6o37aw8iIVmFa64dNERHRHGGqMwKmEdIz/8Qii4tPV9vMPNMWbfYPgYGtj6F2j0vO9SH8XFVwKQ0zCcSA3o+zjJGsWSYBRISZYdy1rGslqo0REVO0Yagw898xPBy9ixobjyM7ToJ6rPT4eHooeQT6G3C0SGUlAXBgQH36jCUmWDdBqbj4+Ng5A/TaFwSUE8A3WVWK4YjQRUa1iqDGQ1Kw8TF0Tjs0RuhEuDwTWw4IRofBx49wztS7zChB3BLgcBlwuvC6v+cjFu1j1pfBaJq2z4VeJiMjQ+F9iAzh0PgWv/XRj7plJ/YLwXFfOPVNrc78UhZcjumrMtZgynmilCyt+obrKiz7EuHEGZyIiY8VQU4tkvpmvt5/GZ7+dhEYLNPZyVp2BQwPq1OZuWI7sVCDu6I0AI5er58t+rmdzoEGHwkt7XTMSRx4REZkUhppaEpd6XVVnDpzTzT0ztENDzBwSDFcHnoJqm8BO+r/om4/kWvrAlEVWkpbgog8xEmCcGCyJiEwdf1Frwa/H4zF5Vbiae8bF3gYfDAnG0Lv8a+OjzVNBnm7U0aWDwKVDwOW/dQs3Qnvzc2W0kQQXv8IQI81Jzp6G2GsiIqphDDU1PPfMrE2RWLpf12cjxN9DNTc1qedSkx9rftLiCgOMPsQcAfKv3/w8d/9iFZj2gF8HrjRNRGRBGGpqyEmZe2bZEUQn6OaekUUoZTFKe1vrmvpI85CXresHUzzElDUSSYZLN+wI+HcCGt6tCzKu3obYYyIiMhIMNTUw98yyAzGYuSESOfky94wDPhkRim4t+YNbxsHSddyV4KIPMTIfTOmlBGT1aZ+2gH9hiJGLjEyyZkAkIqIbGGqqUer1PExdfWPuGQkyC4aHwtvNoTo/xnTlpOuaji4euBFkspLLngvG/54bIUaqMA5cLoKIiCrGUFNNDl+4ild/PFI098zkfq3wbNemsLa24CnxUy8BMfuBC/uAi3/plhgoPSOvtZ2u866qwBSGGC4lQEREVcBQUw1zz3y78ww+2XZS3W7k6YwvH7fAuWdkYcfkaCDmT+DCn7owk1rGpHYejUo2I8mkdnacRZmIiO4cQ80dSEzLxhvLw7D39BW1Pbh9A8waEgw3RzuYvfxc3Wy8UoWRAHNxv2623uKsbAC/EKBRZ6DRfbomJXc/Q+0xERGZOYaaKtoenYg3lx/FlcxcONnZYObgtnjsbn9YmesKzDK5nfSFkUqMhJjYQ0B+dsnn2DnrqjCNuhSGmE7sC0NERLWGoaaScvM1mL8lCv/Zc05tt/ZzV81NLXzMrCNrevyNKkzMPt1kd6X7wzh7FVZhCi9SlbGxgCoVEREZJYaaSjifnIlXfzqC8EupantslyaY0r8VHO1sYBZDq8/vKQwy+8peI6luk5Ihpl4gYK6VKSIiMjkMNbdp7ZFYTFsTgczcAtRxtsP8YSHo09YXJuvaReD8buDcbt116sVST7DSrU6tb0qSEMP+MEREZMQYam4hMycf09cdx6q/dbPa3tPUE5+Pag8/DyeY3FIDKsTs0l2XrsRY2+pm6G1yvy7IBHTSzdpLRERkIhhqKnD8cqpa6uBsciZkuplXHwrE+AcDYWMKc89kJJasxFw5ffPIJJnUrukDQJMHdNUYe65JRUREpouhppylDhbvO485m6OQW6CBr7ujqs7c28wLRivzCnBhz40QkxRV6glWuknuVIjppgsxju4G2lkiIqLqx1BTSkpmLiatPIrfTiSq7V6t6+Ojx0JQ18UeRkXmhJFOvfoQk3Ds5ufUb3ejEtO4C+BkYRMCEhGRRWGoKWb/2St4/acwxKdlw97GGtMGtsbozo2NY+4ZWb1aJrg78wdwdgcQFy41pZLP8W59I8Q06Qo4expqb4mIiGodQ41MjlugwRd/nMZXf5yCRgs083ZRc8+0beBh2GHWslaShJgz23VVmfzrJZ/jFVgsxDwAuHIlcCIislwWH2ouX7uuqjMHzqeoAzL8bn/MGNwWzvYGODTpCboqjKrGbAcyEko+7uoLNO8JNOsJNO3GIdZERETFWHSo2Xo8Hm+tDEfq9Ty4Otjiw0eDMbh9w9rbgbzrugqMBBipxpTuF2PrpBti3fxBXZDxac3J7oiIiMphkaEmO68Ac3+JUiOcRIi/h2puauzlUvMrWSceL2xS+kO3mnVBTsnnyAglfYiREUq2DjW7T0RERGbC4kLN2aQMvLLsCCLj0tT2C92a4c0+QbC3ta65Se/0lRi5zkwq+bh7Q12AUc1KPQCXejWzH0RERGbOokLN6r8v4Z21x5CVWwBPF3ssGBGKnkE+1fsh+bm6tZNObdNVY6Szb3F2LrqRSVKNkSBTryWblIiIiKqBraUsdfDuumNY/Xes2u7czAufjWqP+u6O1fMBaZd1IebUVl1H39yMYg9a6Wbu1YcY/3sAWyOb84aIiMgM2FraUgev92qJcT1b3NlSB5oC4NJBXYiRS3xEycddfIDAPkCLh3RNSpwvhoiIqMbZmvNSB0v+vIAPN51QSx34echSBx3UgpRVXobgzO/AyV911zKjbxErwL+jLsgE9gZ8QwHrGuqjQ0RERJYTaq5lyVIH4dgamVD1pQ5kpFJ8+I1qzKVDJWfwdawDtOh1oyLDDr5EREQGZXah5tD5FLz64xFcTtUtdTB1QCuM7dLk9pY6yE7V9Yk5uRU4ve3mye9kLaWWUo3pAzTsCNiY3eEjIiIyWWbzq1yg0WLhjtP49LdT6nYTL2d89cRdCG7oUfFSBEnRN6oxMX8CmvySI5Wkc680KUmQcW9QK38LERERWWioSUzLxhvLw7D39BW1PaR9A8x6tJ2aJfgmBfm6hSGjNgPRm4Crugn4SqynpO8bIytbc/I7IiIik2DyoWbnySRMXB6G5IxcONnZ4IMhwRh2V8OSzU25mcDp34HozbqOvtd16zwpNg66eWNa9tX1kfFqbpC/g4iIiCw01OQVaPDx1mj8a+dZtd3K1001N7XwcdU9ISMRiP5FF2Skn0x+9o0XO9UFWvYDggbo5o9xKHwNERERmSyTDDUXU7Iw/scjCLt4TW2P7twYbw9oDcdrZ4A9m3RNSzKPTPHRSnUaA60eBloNAALuYydfIiIiM2NyoWZzRBwmrwpHenY+6jha49seGtyXtxz4dhNw5XTJJ8tMvkEDdUHGpw2XIyAiIjJjJhVqZm44jg0R8ehqHYHH60Sgp9XfsNmRfOMJ1nZA0266ECNNSxytREREZDFMKtR0OToFM51OwNkqB9B3kXHw0M0dIyFGOvo6uht4L4mIiMgQTCrU9LI5AmcZ1eTuf6MaIyOXbOwMvWtERERkYCYVajI7jYd75xGAbwj7xxAREZHphhqXXpMBdzYvERER0c24lDQRERGZBYYaIiIiMgsMNURERGQWGGqIiIjILDDUEBERkVlgqCEiIiKzwFBDREREZoGhhoiIiCwz1OzatQuDBg1CgwYNYGVlhbVr197yNT/88ANCQ0Ph7OwMPz8/PP3007hy5UpV95mIiIjozkNNZmamCihfffXVbT1/z549GD16NJ599lkcP34cK1aswMGDB/Hcc89V9qOJiIiIqm+ZhP79+6vL7dq/fz+aNGmCV199VW03bdoUL774IubPn1/ZjyYiIiIyXJ+aLl264NKlS9i8eTO0Wi0SEhKwcuVKDBw4sKY/moiIiCxIrYQa6VMzcuRI2Nvbw9fXF3Xq1MGXX35Z7mtycnKQlpZW4kJERERk0FATGRmpmp6mT5+Ow4cPY8uWLTh37hxeeumlcl8zZ84ceHh4FF0CAgJqejeJiIjIxFlppU2oqi+2ssKaNWswZMiQcp/z1FNPITs7W3UQLt55+IEHHsDly5fVaKiyKjVy0UtNTUWjRo1w8eJFuLu7V3V3iYiIqBZJS4sUJq5du6aKFEbXUbiysrKyYGtb8mNsbGzUdXl5ysHBQV309M1PrNgQERGZnitXrhhnqMnIyMDp06eLtqUpKSwsDJ6enqqaMnXqVMTGxmLJkiXqcZnT5vnnn8fChQvRt29fxMXF4fXXX8c999yj5rq5HfK85s2bq+YrqQ5Vp06dOqkh5jWVTmuiulRT+2yq781zaNrHuabeuya/g4LHueaPB8+h6f+7Sy1saZGMUBsqHWoOHTqEnj17Fm1PmDBBXY8ZMwaLFy9WoSUmJqbo8bFjxyI9PV3NazNx4kTVSfjBBx/EvHnzbvszra2tVSfjmkh5UjWqySYtee/qfv+a3GdTfG+eQ9M/zjX53jXxHRQ8zrVzPATPoWn/u9P/jhtlqOnRo0e5zUZCgk1p48ePV5c7MW7cuDt6fW2/b02qyX02xffmOTT948xzaPrHmefQtI/zOBP8Laz2jsJUcdlUKktSemPnZtPEc2jaeP5MH8+h6Uur5d9CLmhZQ6Sj83vvvVeiwzOZFp5D08bzZ/p4Dk2fQy3/FrJSQ0RERGaBlRoiIiIyCww1REREZBYYaoiIiMgsMNRUsP6UTEbk5uYGHx8ftRREdHR0iefIwLH3339fTQ7o5OSkhrsfP3686PGUlBQ1lD0oKAjOzs5qAiJZB0t6gRd39epVtZyEfq0ruS1TSpPpnMMmTZqoiSGLX6ZMmcJTaATnULz44otqAk953NvbG4MHD0ZUVFSJ5/B7aNrnj9/BmlFd57D4c/v376/+G7l27drq/w7KkG66Wd++fbWLFi3SHjt2TBsWFqYdOHCgtlGjRtqMjIyi58ydO1fr5uamXbVqlTYiIkI7cuRIrZ+fnzYtLU09LvcNHTpUu379eu3p06e1v//+uzYwMFA7bNiwEp/Vr18/bXBwsHbfvn3qIrcffvhhnhYTOoeNGzfWzpw5UxsXF1d0SU9P5zk0gnMo/vWvf2l37typPXfunPbw4cPaQYMGaQMCArT5+flFz+H30LTPH7+DNaO6zqHeJ598ou3fv79MJaNds2ZNiceq4zvIUHObEhMT1UmQL5bQaDRaX19fdTL1srOztR4eHtpvv/223PdZvny51t7eXpuXl6e2IyMj1fvu37+/6Dl//vmnui8qKqpSJ5MMcw71/0H99NNPeQpM5BwePXpUvY8EVcHvoWmfP8HvYO24k3Moocjf31/9T1/pUFNd30E2P90mfXODfv0KWfMqPj4effr0KXqOjMPv3r079u3bV+H7yARE+kU+//zzT1Vmu/fee4uec99996n7KnofMp5zqCdLf3h5eaF9+/b48MMPkZuby9NkhOcwMzMTixYtQtOmTYsWyeX30LTPnx6/g8Z7DmVx68cff1wtmeTr63vT+1bXd7DGV+k2B1LRkjWuunbtiuDgYHWfnERRv379Es+V7QsXLpS7SukHH3yg2of15H2knbI0uU//GWTc51C89tpruOuuu1C3bl0cOHBALewqX/b//Oc/PH1Gcg6/+eYbTJo0Sf0otmrVCtu2bVNryunfh99D0z1/gt/Bmncn5/CNN95Aly5dVH+oslTXd5Ch5ja88sorCA8Px549e256rPSq4XLSy1pJXKaKHjhwINq0aaNmV6zoPSp6HzLOcyhfWL2QkBAVbh577LGi/3Mkw5/DJ598Er1791aL7n788ccYMWIE9u7dC0dHxzLfo7z3IeM8f/wO1ryqnsP169fjjz/+wJEjRyp8/+r4DrL56RZk5IuckO3bt8Pf37/ofn35rHSCTExMvCmxyirl/fr1g6urK9asWQM7O7sS75OQkHDT5yYlJd30PmSc57AsUjYVp0+f5mkzknMoZezAwEB069YNK1euVKNn5Fzq34ffQ9M9f2Xhd9B4zqEEmjNnzqBOnTqq2V7fdD9s2DA1Uqo6v4MMNeWQdCipdPXq1eqESPttcbItJ0FKoHrSh2Lnzp2qxFb8/+6lrVHKpPIPQv9/FXqdO3dWbZTSZKH3119/qfuKvw8Z7zksi/7/SPz8/HjqjOAclvfeOTk56ja/h6Z9/srC76DxnEOZ3kIqPGFhYUUX8emnn6r+UdX6HbzDjtBm65///Kfqvb1jx44Sw3SzsrKKniO9veU5q1evVsPYHn/88RLD2OT63nvv1bZr10710i/+PqWHkoaEhKie3nKR53NIt+mcQxl6KMMUjxw5oj179qz2559/1jZo0ED7yCOPVMNfYdmq4xyeOXNGO3v2bO2hQ4e0Fy5cUOdr8ODBWk9PT21CQkLR+/B7aLrnj99B4z6HZSlvSPed/hYy1JR3YIAyLzJeX0+Gsr333ntqOJuDg4O2W7du6oTqbd++vdz3kfkW9K5cuaJ98skn1Th/ucjtq1evVupEkuHOocybIcFHvtSOjo7aoKAg9Z6ZmZk8LUZwDmNjY9W8GD4+Plo7Ozs1pPSJJ564aZgov4eme/74HTTuc3i7oaY6voNcpZuIiIjMAvvUEBERkVlgqCEiIiKzwFBDREREZoGhhoiIiMwCQw0RERGZBYYaIiIiMgsMNURERGQWGGqIiIjILDDUEFGNkgXrXn/9dR5lIqpxDDVEZDR27NgBKysrXLt2zdC7QkQmiKGGiIiIzAJDDRFVm8zMTIwePRqurq7w8/PDggULSjy+dOlSdOzYEW5ubvD19cUTTzyBxMRE9dj58+fRs2dPdbtu3bqqYjN27Fi1LevfzZ8/H82aNYOTkxNCQ0OxcuVKnjkiKoGhhoiqzVtvvYXt27djzZo12Lp1q2pOOnz4cNHjubm5+OCDD3D06FGsXbsW586dKwouAQEBWLVqlbodHR2NuLg4fP7552r7nXfewaJFi7Bw4UIcP34cb7zxBv7xj39g586dPHtEVISrdBNRtcjIyICXlxeWLFmCkSNHqvtSUlLg7++PF154AZ999tlNrzl48CDuuecepKenq+qOhCCp1ly9ehV16tQpqv7Uq1cPf/zxBzp37lz02ueeew5ZWVlYtmwZzyARKba6KyKiO3PmzBlViSkePDw9PREUFFS0feTIEbz//vsICwtTgUej0aj7Y2Ji0KZNmzLfNzIyEtnZ2ejdu3eJ++WzOnTowNNGREUYaoioWki/l4pIxaVPnz7qIn1rvL29VZjp27evCijl0QefTZs2oWHDhiUec3Bw4NkjoiIMNURULVq0aAE7Ozvs378fjRo1UvdJM9LJkyfRvXt3REVFITk5GXPnzlX9Z8ShQ4dKvIe9vb26LigoKLpPKjgSXiQAyfsQEZWHoYaIqoX0iXn22WdVZ2HpW1O/fn1MmzYN1ta68QgSdCS0fPnll3jppZdw7Ngx1Wm4uMaNG6tRTxs3bsSAAQPUSCcZKfXmm2+qzsFStenatSvS0tKwb98+9ZljxozhGSQihaOfiKjafPTRR+jWrRseeeQR9OrVSwWQu+++Wz0mzU2LFy/GihUrVPVFKjYff/xxiddL89KMGTMwZcoUFYpeeeUVdb+En+nTp2POnDlo3bq1arLasGEDmjZtyrNHREU4+omIiIjMAis1REREZBYYaoiIiMgsMNQQERGRWWCoISIiIrPAUENERERmgaGGiIiIzAJDDREREZkFhhoiIiIyCww1REREZBYYaoiIiMgsMNQQERGRWWCoISIiIpiD/weRwcGGpjV6PAAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -1029,6 +1056,36 @@ "In this section we present some more advanced features and use of this module." ] }, + { + "cell_type": "markdown", + "id": "dbf4b23d-d502-4c06-8e0d-eb832af8ebe4", + "metadata": {}, + "source": [ + "## Exposure sub groups" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "43cff641-6288-48d6-81bb-40d9755c24d1", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "4fcc943d-e5c6-4667-8ec6-8f7d2f0b3ce4", + "metadata": {}, + "source": [ + "## Deactivate results caching" + ] + }, + { + "cell_type": "markdown", + "id": "b3f326db-458b-4238-a30b-fcc9215f8f36", + "metadata": {}, + "source": [] + }, { "cell_type": "markdown", "id": "42c9daed-6488-488b-b01a-fd6dfc5d0274", @@ -1051,7 +1108,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 73, "id": "d93eb82b-65d2-48fe-a195-6cb12f23bf47", "metadata": {}, "outputs": [ @@ -1059,22 +1116,22 @@ "name": "stdout", "output_type": "stream", "text": [ - "2025-11-03 15:17:54,936 - climada.entity.exposures.base - INFO - Reading /home/sjuhel/climada/data/exposures/litpop/LitPop_150arcsec_HTI/v3/LitPop_150arcsec_HTI.hdf5\n", - "2025-11-03 15:18:00,684 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020/v2/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020.hdf5\n", - "2025-11-03 15:18:00,714 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", - "2025-11-03 15:18:00,718 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n", - "2025-11-03 15:18:06,229 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2040/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2040.hdf5\n", - "2025-11-03 15:18:06,255 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", - "2025-11-03 15:18:06,255 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", - "2025-11-03 15:18:06,257 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n", - "2025-11-03 15:18:11,586 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2060/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2060.hdf5\n", - "2025-11-03 15:18:11,615 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", - "2025-11-03 15:18:11,616 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", - "2025-11-03 15:18:11,619 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n", - "2025-11-03 15:18:16,770 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2080/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2080.hdf5\n", - "2025-11-03 15:18:16,799 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", - "2025-11-03 15:18:16,800 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", - "2025-11-03 15:18:16,802 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n" + "2025-12-19 17:28:29,892 - climada.entity.exposures.base - INFO - Reading /home/sjuhel/climada/data/exposures/litpop/LitPop_150arcsec_HTI/v3/LitPop_150arcsec_HTI.hdf5\n", + "2025-12-19 17:28:35,372 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020/v2/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020.hdf5\n", + "2025-12-19 17:28:35,396 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-12-19 17:28:35,399 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n", + "2025-12-19 17:28:40,931 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2040/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2040.hdf5\n", + "2025-12-19 17:28:40,951 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-12-19 17:28:40,951 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-12-19 17:28:40,953 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n", + "2025-12-19 17:28:46,842 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2060/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2060.hdf5\n", + "2025-12-19 17:28:46,862 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-12-19 17:28:46,862 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-12-19 17:28:46,864 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n", + "2025-12-19 17:28:52,511 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2080/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2080.hdf5\n", + "2025-12-19 17:28:52,531 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-12-19 17:28:52,532 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-12-19 17:28:52,534 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n" ] } ], @@ -1143,7 +1200,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 74, "id": "b85d5b95-4316-481a-9eed-86977647b791", "metadata": {}, "outputs": [], @@ -1161,7 +1218,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 75, "id": "1c5aeb4b-6320-479d-82a6-9b2c3901868e", "metadata": {}, "outputs": [ @@ -1171,13 +1228,13 @@ "" ] }, - "execution_count": 15, + "execution_count": 75, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAuAAAAKKCAYAAAB8se41AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAjZZJREFUeJzt3QeYE1X7//+b3jtIkY5UQQULgiJNmijFgqICUlQEEQQbtkcsoKiIYntsFKn6AHYFFEGxAoJYAAGRoiCKFOkt/+tzvr/kn2Szyy5sZpbk/bquwO4km0zmzCT3nLnPfbIFAoGAAQAAAPBEdm9eBgAAAAABOAAAAOAxesABAAAADxGAAwAAAB4iAAcAAAA8RAAOAAAAeIgAHAAAAPAQATgAAADgIQJwAAAAwEME4GY2btw4y5YtW6q3efPmxa0BKleubNddd90x/e3kyZNt9OjRMe/Tej/wwAOWlX3yySd21llnWYECBdz6vvXWWzEf98cff7j3snTp0hT3adsVLFjQEtXzzz/v9s+M0P4avd/GYzt9+eWXrl22b9+e4r5mzZq524kuvftoRtsjvZ8NF198cYZf73j/NjXDhw8/pvd/opg7d6716tXLatWq5dr75JNPto4dO9rixYtjPv67776zCy+80B1XRYsWtUsvvdR+/fXXFI/TZ7Tuq1KlitsP0jouPv30U2vVqpWddNJJ7nlPO+00e+aZZ+zw4cOWlaTn++WXX36x2267zc4880y3fYoXL27nnXee/e9//4v5+C1btrjPqZIlS1r+/PmtUaNG7viLtn//fnv88cetbt26rp1Kly5t7dq1c59H0Q4ePGjDhg1zx0OePHlc244ZMyZD7/XBBx+0OnXq2JEjR1Lc9/fff7vn1fZYtGhRhp43WeKq3377zU50X6bxXXfBBRfYoEGDju2JNRV9shs7dmxAm0L/f/XVVyluO3bsiNtrV6pUKdCjR49j+tv27du7v49F671hw4ZAVnXkyJFA8eLFA+eee27g448/duv7zz//xHzswoULQ+0TTduuQIECgUR16qmnBpo2bZqhv9H+Gr3fxmM7Pf74465d1q5dm+K+n376yd1OZBnZRzPaHumhY1vH+LE4nr9NjfafY/2sOhFcfvnlgebNmweef/75wLx58wJvvvmma/ucOXMGPvnkk4jHLl++PFCoUKFAkyZNAu+//35g+vTp7lgtV65cYMuWLRGPrVmzZqBBgwaBXr16BUqVKpXq8TxnzpxA9uzZA82aNQu89dZb7vcBAwa4Y+yWW24JZCVap//85z9pPmbMmDGBWrVqBR555JHA7NmzAx988IHbf/S3w4YNi3jsvn37AnXr1g2UL18+MHHiRPf4jh07um2vtgjXrVs3t53uuece1y5qpzPPPNM99ptvvol4bJ8+fQJ58uQJjBw5MvDpp58G7rrrrkC2bNncOqXH77//7vZ7vUYso0aNcu9Ht759+6brOZOFjgN97qltT3SPp/Fdp/0zV65cgRUrVmT4eQnAwwJwBXpei1cAntVt3LjRbfPHHnvsqI8lAE9fAH7gwIHAwYMHY97ndQCeCDKyj2a0PdKDANxbf/75Z4pl//77b6B06dKBli1bRiy/4oorAiVLlow4qfrtt9/cF/Edd9wR8djDhw+n64T6mmuuccHirl27Ipa3bt06ULhw4cCJFoD/9ddf7iQ21vdW/vz5IwKz5557zj3nl19+GVqmY6dOnTqBc845J7RMf5MjR47AtddeG/Gcf/zxR4oTlR9//NEF28OHD4947PXXXx/Ily9fYOvWrUd9n2rLk08+OaINw+mk4aSTTgqcffbZgSJFigT27NkT8Nru3bs9f81k8/hRvuu0H2i/yihSUDKgfv361qRJkxTLdXlQlyt1mTHon3/+sX79+rnluXPntqpVq9o999zjLp8dy2Wb6MvYuoz5/vvv27p16yLSZdK6RPjjjz+6S6rFihWzvHnz2hlnnGHjx4+P+TpTpkxx61uuXDkrXLiwu9S6cuXKdG2nBQsWWMuWLa1QoULuUmLjxo3dugZpvcqXL+9+vvPOO93r6RJhLFqfs88+2/3cs2fP0PuMfm+rV6+2iy66yF22rVChgg0ZMiTFtj5w4IA9/PDD7jKkLhuWKlXKPedff/2Vrvf1zTff2CWXXGIlSpRw269atWopLj0d7b2Ht7EuN990003ukqueU/uP0m2CtE1++uknmz9/fuh9B7dTsJ1ef/119161n+k9aTuklfKg59P66dKt3v/NN99se/bsCd2v/U5/GyvtJXy76//bb7/d/Ry8tB69f0Zfak/vMaHn0XrpvdWuXdttx9NPP93ee++9iMep3W644QbX3sH21CXujz/+2NN99FjaQ6kKV111lTu+9DhdRtf6xEqzik5Jypkzp/3nP/+x9Jg5c6ZLY9D+qu2tdIZoO3fudKkCake1i9Zd+/Xu3btDj9H663d9XgTbWu2rv9X6KCUg/LJ89uzZrUiRInbo0KHQ8ltuucW10f/Fb/9HbaX3rc8YtYPaL1bawapVq+zqq692qRnaXtovnnvuuUz97NJzR9PnidIPNmzYEFqm96R98bLLLnPPH1SpUiVr3ry52+bhtC3SI1euXG7758uXL2K50jfUfkczZ84c9/mu/VaPP+WUU+zGG2907RFO+7a2kz4Lunbt6tpJ+5/Sb3bs2BHxWLXv9ddf7z6ftC3atm3rUkvSQ59r4d9JQeecc477zNHnQZC2Wc2aNV3aSZD2q2uvvda+/fZb+/3330PbMrhvhVM7aHn4dlK6lPY1fcaH0+979+61jz76KM311/fFq6++6va7WG2o7wN9p3br1s1tI2276dOnh+7XMaTPWW3DaFdeeaXb5kqRCZo2bZp7//obbes2bdrYkiVLIv4umEr4ww8/WOvWrd3nl46fjLS/vP322+5zQceSPheefvrp0H4RTttPnzmKFbRfKna4/PLLY6ZapSeW0WeGUoe++uor95mr59Tn6tixY939+gxu0KCB+yyoV69eijYKrqO2i74v1e7aF7SfRH+Pa3tqG5UtW9a9jj4z7rrrrojPtfR8tx/tu060Dygl+N9//z3qdonewEkv2AP+9ddfu7Pu8NuhQ4dC2+fpp592j/vll18itpkurWn5O++8437fu3dv4LTTTnM9jk888YS7nHbfffe5S2QXXXRRmj3gwXWJPtPS5TMt1/+iy/vnnXdeoEyZMhHpMqn1UOjyiC6ZVqtWLTBhwgR32bRr164peviCr1O5cmXXI6PHTZkyJVCxYsVA9erVI7ZHLMHLMbokOG3aNHcpVT046omYOnWqe4xSY2bMmOFeR5dYtd7fffddzOdTD1Nwm9x7772h9xlMr9G2y507d6B27dpuWytV4P7773evF36ZUz0Ybdu2dW2i5bq8+8orr7jeDfWyHK3n4qOPPnLvS+06bty4wNy5cwOvvfZa4KqrrsrQew9v46pVq7r3P2vWLLcuxYoVc5fAg7RN9Jj69euH3ndwOwXbSeuvS+fa99577z3XqxO9r4RvJ7Vj8JLwAw884PbJiy++OPQ47XeppfuE71Pa/sHL42rL6HQt9fKF9/Rl5JgI7n/q+XrjjTfc8aXL8nrsmjVrQo9r06aNu6T/0ksvuW2v7a22D9/WXuyjx9IeSks45ZRTAq+//npg/vz5LoVhyJAhEY8J7wFXT6Lu13rHapto+luti9pb+6m2oY5nrYd6c8J7z8444wzXm6vL6Tp+9Dmn3rwWLVqEejD1/tVrqLYKtnUwxUhpGtp+QdqGefPmddvziy++CC3XMdqlS5fQ73rvekynTp3ctn733XfdvqgeTq1HkF5H61OvXj332aV9R9tCaQjahzPrsyuW7du3u9fu3LlzxGepXke9ttFuu+029560v8eSVg+4vn/UA96/f3+X+rBt2zb3ftXmOmaO5oUXXgiMGDHC7Xvap8aPHx84/fTT3b6mqzFBOoa1/lqu40WfhWp7vXbPnj1Dj1Pb6/NIy4OfGfpbfSalpwc8NTqWddyGt4e+x3RVIZqOIb2WPiODBg4cGChYsGBg5syZ7vNGn1n6LtPn56pVq0KP02ezXiearjDoOYcOHZrmen722WfucTp2YlGPp+7X/rlz507Xq6/3FvT999+7+19++eWIv1O7apsOHjw4tEzbV/uN0pT0nnU8NGrUyH1ehqfy6XNc+4P2cbW1UnCC2ya97f/hhx+GUp20DZVe07BhQ/ec0SGh3qNeT8ebvgMnT57s0op0VWjz5s1pbr9YsYz2/RIlSrh1evXVV92665gPpiXpGNcxq22uzxVtJx0L0fuuPt9uv/129/fad7Wd9D0Z/j4feuihwFNPPeU+B/SZ/+KLLwaqVKkS8R2bnu/2o33XiVKfwmPA9CIAD9tRYt30ZRD0999/uyDm7rvvjtiI+lLRDhm83KyG1t8qeAinQFfL9UF2vAH40VJQoj8gtTNpZ16/fn3E49q1a+c+OPRFE/460UGR3ouWhwf5seig0SU5XboN0gdtML8v+IUeDPTCg4FjTUGJta21/jrIg3RQ63EKdGI9t/I+06ITF91S+2LNyHsPtnG/fv0i/l55ilq+adOmo35hB9vpggsuSPW+6ABcyxRchdMHv5YvWLAgQwH40S7LRQfgGTkm9LuOJ32pBenDXl8a+oIJ0pfwoEGDAhkVj300I+2hzxH9Pnr06DSfMxiA6+Twsssuc4FgeGB6tL/VF/rSpUsjlrdq1cqlMwQvW2t7artGp9/973//SxF8pJYDrhNjBefBlALl3epkV19owZNgfYnq+XSyJHp95ddfcsklEc+lE2UFDeFpBzrRUrtE59DffPPNLtAP5uUf72dXLArkdeK3aNGi0DKdVOj59JkSTekOuk8pEccypkPPrTzy8O8ffS5klPZhfR+tW7fOPc/bb7+dIoiJfl59Hml7Bvd/BWppfWYcSwCuYDTWcyoAuvHGG1M8XikperwCv/D3phMH7bfB7aSTrCVLlqTY18O/A8Lpe/yGG25Ic12Dn02xAk3tvzqO9FkSpGNDx9zq1atDy5T737hx44i/1XeNnveHH35wv+s7WfuYgrxw+nzSiUn4SWvwc1wB4rG2v9JlKlSoENi/f3/EaykwDg/Adbzo9yeffDLiuRWQ6niPTrVKbwCuZeHH09atW91+rucMD7b12aXHPvPMMyn23VtvvTXitSZNmuSWa/xAWttDJyZ6nE6OMvLdfrQUFAX+avs777wzkBGkoISZMGGCLVy4MOKmSxNBujyhyxS6DBscEb1t2zZ3Oad79+7ukllwNL0uI+lSTbhgtZNYl1jjTeukS1W6XB+9TrocqEtC4Tp06BDxuy5XiVJeUqNLO9peet/hFTdy5MjhLtFs3Lgx3WksGaHLQWqX6PUNX1ddMtalXD1Ol5CDN11aK1OmTJoVKnTJdc2aNda7d+9ULwUfy3s/lm0cTZfBM+Kaa66J+F2XV0XpMPGU0WNCl/J1eTVIl2uVIhC+bXQpW5c5lVb09ddfR1zO9WsfTU97qBqELnEqbWPUqFHucmqsCguydetWa9GihbsMH0ybSa9TTz3Vpe5Et7cuiauCR/C40CVhHQfhx4Uuf6e3covWSZf0g1UolFaiSh5K/dBl8eAy0TLRY5WC0KNHj4jX1XZQmoM+e9VW+/btc/tG586d3WXp8Mcq5Uz3q+0z+7iS++67zyZNmmRPPfWUq+QRLVZ6RXruS42qreh96rXeffddd8wMHTrU7r33XnvooYeO+veqItK3b1/3Ga/vIqW0KC1Gli9fnuLxsbaTtqeeJ/wzIbXPjIz68MMPrX///u7YGzBgwDFvz0ceecSeeOIJlxqgddT3r9JXtM9Fp2wcTxspHVCPUSpNtDfeeMMdR0rbCdLP6j8IplME0120r4d/puh+pVXquJNZs2a5/VkxRPj+re+apk2bxjwGY33OpKf9dUypWkunTp1culOQPgujv0P12aD3r/SO8PXS96U+V461OpxSQsKPp+LFi7vPdn0GKW0sSCkjqR230ftkly5d3HsO/x5Tmoz2Va2vPt+1PbQ9w7dHer7b00PPrfgimCqVXv8XMSLU4Co5lhYdZMrz0heLvqSUb6gc1vBSgvrSVKNHH+DaybST6H6v6TW140cL7vDR66STjXDKFRN90aZGJyP6AMrI62QGfTFHHzxaX32ZBP3555+uhFD4h064WHlyQcHcsmBOcGa992PZxtFivV5qtO9Fv6b201jrltkyekxEr2dw+4RvG+X4Kfh+5ZVXXLCkLxEFMCNHjgy9L6/30fS0h7aBgkqVN9O6KmdcX0L6UlFwEX7ioS8IrbNyTINf2OkVaxtEt7eOC+Wp6wsko8dFkHI5dQwqyNaXv3I+FQzpZEYl33bt2uXuU66pciiDryvRJ2ThFKAr91Zf+nqe1MrHRa9jZhxXKl2nfUvtofEIsZ4/1n6idVb76ss4oxSc6kRT+dAKGIInotoGCja1f2gbxqITF+W7KmjUsaD8WZ3wavm5554b870fbTvp/aX1mZERCjKVs6v9Qic10Z8Deo3Utqfo+AgGTvfff787bjRuIUhlCJWrP3jw4FAQpueMNaZCQajyu4PPmRptBx0XwbYIp9xwfefoZDFYmk4nMMpnVqeA9h/9ndpM66llI0aMsJ9//tmdXCqvOih4LATHOkWLzj/XsRY+9iAj7R/8/NN+Fi16mdYrtcdKavvi0cTa7rlz506xPPhdHf49nto+GNxPg/uQPnM0Xk9tpOO4Ro0abrtpLIf2w+D2SM93e3rptTLyGePW+7hfNcko6NYXtc5i9bP+b9iwoTv4g7QjqJdNO2/4B43OUPVlEuuMOigYSEYPTEvPF2FatE6bNm1KsTw46C+tdUovDdDQh0W8X+dYBAc6pjbwJjzoiaaBY6KAIqu994z0tGnf0wdU+Bfq5s2b3f/BZantf8cboB/PMZEa/Y1qLOu2fv16e+edd9wgGz1nau0c73ZKb3uoZ0pf4sEgWz1qCrIUGLz44ouhx2lQ1hVXXOF6aOSFF15I96C+YNvGWhZsb71XDVB67bXXYj5HeraFvijPP/98F2Tri0xfjgoAgl/Q6inTCUd4XfLg8yqoVoAQi774tW8Er04oQI0lGNRnFgVPagvd7r777hT36+qFtpkGwkXTMg1+O5beNAWLGhQZHfApMFMgpeAztaBHgwG///57F+jpqkKQTq6OlfaRtD4zMhJ8q8dVvY/qvIrVCaL9JbXtKcGTT71HfYZEB6sKlNUrqwHr4c85depUt77hAVv0c6ZG+6iORwXsCmaDdLzqapRUrFgx1fesKzT6vNHASF1dVyCoeEH7hto5/HVE9dGDPdYZ/YxJb/trffT3waA/XHS7BgfRfv7556GTs3Cxlnll8+bNbrB4UPR+qqtH+jzXZ0+w11ui63in57s9vXRyk9HvDlJQMij4ZaAR1toxdTkn/DJU8JKszsCiJ63QQRi8PzXBSgvLli2LWK7g4mg9gmnRawZ3yuh10plhal+CGaEPKZ2MzJgxI2K99OUxceJE9+WsM9GMOpYerGj68tcBqoo1usoRfdMlzNRonfWlqyAltSo28Xzvx/O+o6n3KZxGbkuwYomCHn1BRO9/uswba90kPet3PMdEeuiLUD2V6mELpld42U7HQ6+nNAMFDLHWXV+oCiT05a3L1OmdlEVVLvSlHN3eOtlUpYHgcaFLsPriinVchFd+SWtfVGqJUigUYAXTTLSt9bmiIFufO8Hlomon6iVWj2Cs19VNgZo+m9QLrNQC9TDGelysqyXHSqkeCrzVHqlVmlFvmy7Xax8Kr3qgk0D1voZXw8oIdezo+yS6fYPpgWn10gWDsuig6L///a8dK233tD4z0mP27Nku+NYJmo791II2XblasWJFRMqngiodkzpeg1engv9Hpx3pc1nHTvg2UuCr7RJd6UtBqk6g1HudFlXLEh0f4YInzi+//LJr7/DbBx984E4Gwk9olYai/V/36f3ovYZfIVFHnvYpvU5qx8LRpLf9dUzq+dQWOrkI0mdzdJUpfTboZEdpFbHWSZ9XfpkUtU+qA0P7S/B7LL3bIz3f7eHPk9rnn9pXPfXhHbHpQQ941FlkeNmsIDVQ8ExJFHA/9thjLr9IB7JKCoXTl6RKZOmLU5djtaPqjFkzyemsOPyLKJrO7BUM6rKV1kVnrLokGTzjDqfn1ZeAesWUU6WesdQOVn2Z6ADTh6ou4elyj3Zilf3R5bzosk7HSpfZFATpdfQe9CWqy23atkrXOZbcyGCPk9ZXaUJKNdAHcXi+2NGo5Jv+Xtt/4MCBLn9YH5Q689UHpz6s9cGYGrWnvnQVUNx6660u4NMXrno6gh8G8XjvwV4cpVuo90vB8bF+8Gl9nnzySfdhq/1MuYnqldHlW31BSjDnTx9I2u7qVVL+cawv3eB6qISV9nVtT+27sa4mHM8xEYtKfmk76xjUF6VeU5d21fN9tAAoHu2UETq50cmCerarV6/uXl8nx1quHvxYlKqhYFT/60tA65laOlWQjg/l+SqgVGqMvvyVOqfPLj2XqNSWgmbN5qb9WkGuTka0byt4UnqMAiBRm6lHSfnJej5t8+CJq06gFDiqpzs84FG76rNH21S57EE6hhWYa39QmoHel9KRdElYJw36X59rwf1L+6cuKatsp04KFPiqdy+YK50ZdGzos1GBWfv27VMEeeGdFOol1zGkIEVtpi9f/a16wLTNwimoDpZiU96wgprgbJB6jmCvp7a/SjXqc0bl49RG2p5aL23H6Hz+cDoGdLxqXfT8+nzXtgnm4B8LpTRov7jjjjtcL7C+W7744gtXajM9dHwr+Fbvs64kRKeDKFgJplLoO1WfDzomHn30Ubcv6JhU7nR4WVHtB9pm2qc1dknrp88C7Utr166NWDeNgdCVI+1/6jjT32mffumll9zn3tFSUILBnPaD4DgCfSer00DfQ3369In5d2o/dZhpH1bcoO2oEwOVYFXPbXRZRO3PSkdT6UzlLWv/0/e+eqn12augWftbWjLS/not7d8K/PVdqONW41F0TIaXhtRJssq8an21D2tba1109VBtq88DHY9+mDFjhjtp0ee4OhqUdqPjQ7ngwbQ4bUPlxKv99d2k7+noDon0frcf7bsu+FkRPGlNtwwN2UzCKiixygiJRjbrPo2Sj0UjezUzVtmyZd0IZ1UlUNmj6FmhYk3EozKHwckXVEZJo6NVSie6soVG/6vkWdGiRd0I3PDmjDVKXaOuVXVA1RQ0ClzVBqKrXQQrCUTP/JVWdYxon3/+uSthpqoJGtmskeIqMRbr+dJTYUJUcUDljzRaPvy9pTbBTHC0dDiNglY5L71vjfZXFQ09p0bfh5evSo1GhatqjLafKspo5HT0aOz0vPfUJn6KVb1Ek3toX1AJyWD5pfDHxpqhLbUqKFqnZcuWufJTWjdVobjppptSTPyhahOqZKFKJPob7TNaj1j7lPZpVW0IViQIvmZ0FZSMHBN6HpViixZ+rOhv9FyqtKHjRO9HFQ+0fumZmCKz99GMtIcmfLnuuuvcvqfX136o96GSWeGl2WJNxKPn0ONVZSSt0pnBv1U1E1Xe0PGuMmMq2RVN7a9KJtp+elyw5J/27fAKEKpKoNKnqpqk9xPevqoyoFKGWh5eySBYMUTVIGJRVQKtp/ZFHdsqnajfY33+qESb7tfj9Lmoz+CHH3440z67ghUaUrtFUyUHTdCj7aF9UOUUwytgRFeuiHWLXidVaTr//PPdttS+obZTObXoYzSWn3/+2VX+0GeFSvKprJ8qbEQft8HPRk2Uc7SqFaqOpe2u7xi9Tz1/sAzj0aqgBF8ntVv455NoX+vevbvbF/T5rGNSJRKjaZ00C6bKWmqdVNFIn2mxygWqOoXWQ1VStG/XqFEjoqrG0Wim0/CqOipZerQKRiprF109RJXTtEzVR1Kb1EfPrRJ52pf0/aJjWN/v4ZWP0ppQLb3tLyo/qGM8WJr20UcfdZMY6e+iqeKKyhQGPyv1vad2Cq9kkpEqKNqn0zvpmEV9FwT3qcWLF7vvJX0W6v2qDGX0RFqqoKNSjtpH9Hmh7zSVko113KXnuz2177rg7KzanhmV7f+9SQAAAPw/ujqkK9yqxBGec5xoVEFKVUj0HnWVIKt64IEH3NUAXV3wazxZNF3V0tVGVUvSYPmMIAccAAAgitLZlLqitLVEotQcpTZq0GpwxkgN8lW6ETJGgbfSVqJTi9KDHHAAAIAoGrugwZbK6dbYiPRWIMrqNIZC41/Uk6x8Zg3K1iDRjI7FgblxDBrYG5wHJiNIQQEAAAA8lBincwAAAMAJggAcAAAA8BABOAAAAOAhBmFmMg3U0KxIKtAe7wk9AAAAkHGqwq0BqSoj6McAWwLwTKbgu0KFCpn9tAAAAMhkGzZscLOVeo0APJMFpyZVgwan2QUAAEDWsXPnTtdhGozbvEYAnsmCaScKvgnAAQAAsq5sPqULMwgTAAAA8BABOAAAAOAhAnAAAADAQwTgAAAAgIcIwAEAAAAPJWQAPmLECDv77LNdaZmTTjrJOnXqZCtXrjzq3x04cMAef/xxa9CggRUoUMCKFClip59+ut17772uvjcAAABwvBIyAJ8/f77179/fvv76a5szZ44dOnTIWrdubbt37071b/bv32+tWrWy4cOH23XXXWefffaZLV682EaOHGlbt261MWPGePoeAAAAkJiyBTQXZ4L766+/XE+4AvMLLrgg5mMeffRRu+eee2zRokVWv379FPdrM6WnVqQKu6vnfMeOHdQBBwAAyIJ2+hyvJcVEPNq4Urx48VQfM2XKFNcDHiv4ltSCb/Wc6xbeoAAAAEBSpaBE91wPHjzYzj//fKtbt26qj/vll1+sZs2aEcs6d+5sBQsWdLfGjRunmm+uM6jgTdOaAgAAAEkbgN988822bNky18N9NNG93M8//7wtXbrUevXqZXv27In5N0OHDnU97MHbhg0bMm3dAQAAkHgSOgVlwIAB9s4777gBleXLl0/zsdWrV7cVK1ZELCtbtuxRU1fy5MnjbgAAAEDS9oAr7UQ93zNmzLC5c+dalSpVjvo3Xbt2dRVTlixZ4sk6AgAAIDklZA+4ShBOnjzZ3n77bVcLfPPmzW65crTz5csX829uvfVWe//9961Fixb2wAMPWJMmTaxYsWIuN/zDDz+0HDlyePwuAAAAkIgSsgxhahVLxo4d62p8p0bVTEaPHu3yxRV4HzlyxPWet2vXzgXo6Rlg6XdZGwAAAGTteC0hA/BkblAAAABk7XgtIXPAAQAAgKyKABwAAADwEAE4AAAA4CECcAAAAMBDBOAAAACAhwjAAQAAAA8RgAMAAAAeIgAHAAAAPEQADgAAAHiIABwAAADwEAE4AAAA4CECcAAAAMBDBOAAAACAhwjAAQAAAA8RgAMAAAAeIgAHAAAAPEQADgAAAHiIABwAAADwEAE4AAAA4CECcAAAAMBDBOAAACDCCy+8YKeddpoVLlzY3Ro1amQffvhhXLfS9OnTrU6dOpYnTx73/8yZMyPur1y5smXLli3FrX///gnZeiNGjLCzzz7bChUqZCeddJJ16tTJVq5cGffXPVo7/PvvvzZo0CCrVKmS5cuXzxo3bmwLFy6M+3olGgJwAAAQoXz58vboo4/aokWL3K1FixbWsWNH++mnn45pS40bN86aNWuW6v1fffWVXXnlldatWzf7/vvv3f9dunSxb775JvQYBXmbNm0K3ebMmeOWX3HFFQnZevPnz3cnF19//bV7r4cOHbLWrVvb7t27j/k5M6Md+vTp49bn9ddftx9++MGt04UXXmi///77Ma9XUgogU+3YsSOgzar/AQBIFMWKFQu88sor7uf9+/cHbr/99kC5cuUC+fPnD5xzzjmBTz/9NNW/HTt2bKBp06ap3t+lS5dA27ZtI5a1adMmcNVVV6X6NwMHDgxUq1YtcOTIkUAy2LJli4sv5s+fH1rmdTvs2bMnkCNHjsB7770X8ZjTTz89cM899wROJDt8jtfoAQcAAKk6fPiwTZ061fW8KhVFevbsaV988YVbvmzZMtcL3bZtW1u1atUxbUn1vKonNVybNm3syy+/jPn4AwcO2MSJE61Xr14uDSUZ7Nixw/1fvHjx0DKv20G98Nof8ubNG/EYpaIsWLDgmF4zWRGAAwCAFJReULBgQZcL3LdvX5cLrJzgNWvW2JQpU+zNN9+0Jk2aWLVq1ey2226z888/38aOHXtMW3Lz5s1WunTpiGX6Xctjeeutt2z79u123XXXJUXLBQIBGzx4sNvGdevWdcv8aAflo+sk7KGHHrI//vjDBeM6EVKKitKCkH4E4ACALCUrDgBUz9+9995rVapUcb19VatWtQcffNCOHDliiapmzZq2dOlSl4N80003WY8ePeznn3+27777zgWENWrUcAF68KacZQWFsn79+oj7FMB//vnnKZaFi+7J1muk1rv96quvWrt27axcuXKWDG6++WbXw62AO8ivdlDut5adfPLJ7nh55pln7Oqrr7YcOXLEfTskkpx+rwAAALEGAJ5yyinu9/Hjx7sBgEuWLLFTTz31mAae6TZv3rw0B56pV69z584u+NbAM11Sb9iwoXvMY489Zi+++KJbF62DBibq8n+RIkVs4MCBCdmAuXPnDrXBWWed5QZBPv30025ApoKtxYsXpwi6FNCJAmMF70EzZsxwJzmTJk0KLdPJVVCZMmVS9HZv2bIlRW+srFu3zj7++GP3nMlgwIAB9s4779hnn33mjo0gnfz50Q7qaVeQr5SknTt3WtmyZd3xo5NTpB8BOAAgS7nkkksifn/kkUdcr7h6YhX8Kv9XvdEKIpSGoEvyCpDTqu6QltGjR1urVq1s6NCh7nf9rwBDy4M9jgrSdRLQvn37UEk83adAPFmo13P//v1Wv359l3qgwEypD7HkzJkzFLyLyujpykH4snC6yqHKGrfeemto2ezZs12Ju2hKr9DzBdsikbe3gm+dEOrkMTrA9bsdChQo4G7btm2zWbNm2ciRI4/j3SYfAnAAQJalAEM5rtEDAH/77Tc38Ew9fApQNPBMOcvVq1fP8GsouA4POIIDzxSABymvVj3gv/zyi7vkrxJt6iEPf0wiufvuu12KR4UKFVzdZ21rBYEfffSRe//XXHONde/e3Z588kkXCP799982d+5cq1evnl100UUZfj1dRbjgggvciZROdN5++23Xyx09sE+9vgrAlQ6j4DKRqQTh5MmT3bZQ7nWwZ1pXXRRE+9UOCrZ1cqAUpdWrV9vtt9/uftZxiQzwpfZKAvO7rA0AJIJly5YFChQo4EqeFSlSJPD++++75atXrw5ky5Yt8Pvvv0c8vmXLloGhQ4ceU+m1XLlyBSZNmhSxTL/nzp079LtK3d11113utXPmzOn+Hz58eCBR9erVK1CpUiW3DUqVKuW27+zZs0P3HzhwIHD//fcHKleu7LZfmTJlAp07d3btdixtIG+++WagZs2a7vlq1aoVmD59eorHzJo1y33Hrly5MpDo9D5j3bQt/WyHadOmBapWrer2Db1e//79A9u3bw+caHb4HK9l0z8ZCdiRNuVD6exU5YLC86oAAOmnNBMNIFOKiXJWX3nlFZcWoolglJ+tS9/hlBpx6aWX2rRp09zfaSBl+ADKgwcPul7DoGuvvdb1aAdznZXb3bVr19D9Sm/p3bu37du3z/2uHmD19D3++OMuDUZ5tZoNcNSoUa43FsCJZafP8VpiX78BAJyQstoAQAXfd911l1111VXud13i12BATRee1QJwnYAoFQEZU7JkSatYsSJtkCBtkNURgAMAsjy/BwDu2bPHsmePrNyrE4CsVoZQwXetWrVt7949fq/KCSdfvvy2YsXy4w4A1QY1a9W2fbRBhuXNl99WZkIbnAgIwAEAWUpWHACoyiyqxqLAQCkoKomo9BPNxJiVaFso+O7RYqiVKZr4QUxm2bx9vY2fO8Jtv+MN/vQcCr5LXDzEcpWokGnrmOgObt1gW997MlPa4ERAAA4AyFL+/PNP69atm5tZTzmampRHwbdKBYqqYDz88MM2ZMgQ+/33361EiRKuF/tYgm9RT7eCfJU2vO+++1ydY+WSB2uAy5gxY9x9/fr1c73vSnO58cYb7f7777esSMF3hVI1/F6NpKbgO0+Z2FddAF9nwlRRefUq6INMsyxpatmj0bSzemz0LXxyBk24EOsxwcE0aV3ifPnll90HufIDlU+o51XviErtAADiT7McqsygUk4U7Ko3Ohh8S65cuWzYsGG2du1aN1hTgbryvNUDntr3RmqT8ARdfvnltmLFCvd8y5cvdwM6w6kMnEoOKu977969bqZBnQQoVx0ATqgAXHVdTz/9dHv22WfT/TcahKMP2+Btw4YNVrx4cbviiisiHqcAOvxxuuXNmzfN4FtTqd5yyy2uF0X5f5r2VVOsKndQH7QAAADACZ2Cohw/3TJClyN1C1KvuWZhii4Arx5vjWxPL11u1CVI5f516NAhtLxq1arWsmVLF6ADANJGBY6sUf1BOc1geyHrypkIlyovvPBCq1SpUsTyXbt2uWUaLX/GGWfYQw895AbrpEZTCmsmp/DgOzqgj0WXSHULrysJAMkafNeuWdP2HCXdDynlz5vXlq9cedxBuAJ5VfPQgEJkjLabth/ghRM6AFdayYcffuimag1Xq1YtlweufEAFxEpbOe+889zUwalNU6zphRWAh9MkC5r8QYoWLWobN25M8XeqAatcRABIdqpeoOD7sbJlrVruPH6vzgljzYH9duemTZlS/UF/r1J61AHPuGSqQQ3/ndABuIJsBcadOnWKWH7uuee6W5CC7wYNGrhR7MrpTk10L/c999xjN998sxvcM3z48Jh/M3ToUBs8eHDodwX8Kp0FAMlKwXedNMbcIL4URBJIAlnbCRuAKyf7tddec6WqjjYKXZMnnH322bZq1apUH6OecY2AD1eqVCl30yQOqcmTJ4+7AQAAAFm+CsrxmD9/visN2Lt373QF65qWuGzZsqk+pmvXrrZy5Uo3CBMAAABIyB5wDZQMr6+tmq4KlFVWMHj5TCkemmhhwoQJKQZfapKEunXrpnhe5WQrBUW92koJUdqJnve5555LdV2uuuoql2qi//Wabdq0sdKlS7uar6qQoimHAQAAgBM6AF+0aJE1b9489Hswl7pHjx4uvzs40FIj68Pt2LHDpk+f7gZXxrJ9+3a74YYbbPPmza5koaqfaNKfc845J838bwXamohHs6yNHDnSDh48aOXLl3dlCDXlMAAAAHBCB+DNmjU7an3tYCAeTkH1nj17Uv2bp556yt0ySrnimlpYNwAAACAeTtgccAAAAOBERAAOAAAAeIgAHAAAAPAQATgAAADgIQJwAAAAwEME4AAAAICHCMABAAAADxGAAwAAAB4iAAcAAAA8RAAOAAAAeIgAHAAAAPAQATgAAADgIQJwAAAAwEME4AAAAICHCMABAAAADxGAAwAAAB4iAAcAAAA8RAAOAAAAeIgAHAAAAPAQATgAAADgIQJwAAAAwEME4AAAAICHCMABAAAADxGAAwAAAB4iAAcAAAA8RAAOAAAAeIgAHAAAAPAQATgAAADgIQJwAAAAwEME4AAAAICHCMABAAAADxGAAwAAAB4iAAcAAAA8RAAOAAAAeIgAHAAAAPAQATgAAADgoSwdgH/22Wd2ySWXWLly5Sxbtmz21ltvHfVv5s2b5x4bfVuxYsVR/3b69OnWokULK1asmOXPn99q1qxpvXr1siVLlmTSOwIAAECyy9IB+O7du+3000+3Z599NsN/u3LlStu0aVPoVr169TQff+edd9qVV15pZ5xxhr3zzjv2008/2UsvvWTVqlWzu++++zjeBQAAAPD/y2lZWLt27dztWJx00klWtGjRdD3266+/tpEjR9rTTz9tt9xyS2h5lSpVrGnTphYIBI5pHQAAAIATqgf8eNSvX9/Kli1rLVu2tE8//TTNx06ZMsUKFixo/fr1i3m/UlhSs3//ftu5c2fEDQAAAEiaAFxBt1JHlM89Y8YMl8etIFz55Kn55ZdfrGrVqpYz5/9/QWDUqFEuKA/eduzYEfNvR4wYYUWKFAndKlSoEJf3BQAAgMSQpVNQjoUCbt2CGjVqZBs2bLAnnnjCLrjgglT/LrqXW4MvO3ToYN98841de+21qaahDB061AYPHhz6XT3gBOEAAABImh7wWM4991xbtWpVqvdrgOaaNWvs4MGDoWXKHz/llFPs5JNPTvO58+TJY4ULF464AQAAAEkdgKuMoFJTUtO1a1fbtWuXPf/8856uFwAAAJJPlg7AFRQvXbrU3WTt2rXu5/Xr10ekgHTv3j30++jRo129cPV4q5Sg7lc++M0335zq6yhNZciQIe6mdJIFCxbYunXrXHWUV1991aWnZM+epTcVgEygMR1nn322FSpUyFVS6tSpkytpGm/6jKpTp467oqb/Z86cGXH/oUOH7N5773WVmfLly+fGrDz44IN25MiRuK8bACDzZemoctGiRa6aiW6i4Fg/33///aHHqMZ3eEB+4MABu+222+y0006zJk2auGD6/ffft0svvTTN11KO+OTJk11v+cUXX+zSUq644gr3BffVV1+RWgIkgfnz51v//v3dyfecOXNc4Nu6dWs3J8GxGjdunDVr1izV+/X5ojkIunXrZt9//737v0uXLm78SdBjjz1mL774opsTYfny5a5s6uOPP25jxow55vUCAPgnSw/C1JfW0Wpw68st3B133OFux0JferoBSE4fffRRxO9jx451PeGLFy8ODeLWSb56oydNmmTbt2+3unXrugA5rSA7Lbpq16pVK3e1TvS/TgS0XCVSg0F6x44drX379u73ypUru/vUSQEAOPFk6R5wAPBTsPxo8eLFQ8t69uxpX3zxhU2dOtWWLVvmrpS1bds2zYHeaVFwrV72cG3atLEvv/wy9Pv5559vn3zyiSuZKuop19W9iy666BjfGQDAT1m6BxwA/KKrb0p7U/CrXm5RtST1PG/cuNHKlSvnlinlTT3n6i0fPnx4hl9n8+bNVrp06Yhl+l3Lg+688053MlCrVi3LkSOHHT582B555BE3gBwAcOIhAAeAGDRwWz3c6mkO+u6771xgXqNGjRQz4pYoUcL9rDEpGkgZpDxylTjVhF5BmltAOd2pzUOg1whfNm3aNJs4caIbp3Lqqae6weiDBg1yJwE9evSg/QDgBEMADgBRBgwYYO+8846bQbd8+fKh5RqUrR5o5YTr/3DBAFtBcbByk2hGXlU5Uc54UPh8AWXKlIno7ZYtW7ZE9Irffvvtdtddd9lVV13lfq9Xr56r1KSqLQTgAHDiIQAHgLCeZwXfKgM4b948V/YvnKowKf1DAbKqLMX8UM2Z003iFaRBnCodGL4sugyqKq7ceuutoWWzZ8+2xo0bh37fs2dPilKoOgGgDCEAnJgIwAHg/1EJQqV5vP32264WeLBnukiRIi6IVurJNddc4+YeePLJJ11A/vfff9vcuXNdr/SxDIocOHCgq7CiSiqqdKLX/vjjjyNSXy655BKX812xYkWXgqJyqaNGjbJevXrRdgBwAqIKCgD8Py+88IIb7KiSgpo9N3hTDnaQBlsqANfEXTVr1rQOHTq4mt0VKlQ4pu2onm5VVNHzav4ClVbV6zVs2DD0GNX7vvzyy61fv35Wu3ZtN/DzxhtvtIceeoi2A4ATULbA0QptI0N27tzpesv0JR6e5wkAiU6DVM8880z7X6XKVidvXr9X54Tx8759dvm639zYggYNGvi9Osik46BMj9GWp0zs1DOktH/zats8fpBnx4Hf8RopKAAShiqQKCUEGVOyZEmX3pJZ1hzYTxOwvQCkgQAcQMIE3zVr1bR9e/f5vSonnLz58trKFSuPOwhXIJ8/b167c9OmTFu3ZKHtpu0HIDkQgANICOr5VvBd/obylqdcHr9X54Sx/4/9tvGljW77HW8Arr9fvnIlVyGywFUIAFkbATiAhKLgO1/lfH6vRtJSEEkgCQBpowoKAAAA4CECcAAAAMBDBOAAAACAhwjAAQAAAA8RgAMAAAAeIgAHAAAAPEQADgAAAHiIABwAAADwEAE4AAAA4CECcAAAAMBDBOAAAACAhwjAAQAAAA8RgAMAAAAeIgAHAAAAPEQADgAAAHiIABwAAADwEAE4AAAA4CECcAAAAMBDBOAAAACAhwjAAQAAAA8RgAMAAAAeIgAHAAAAPEQADgAAAHiIABwAAABIlgD8s88+s0suucTKlStn2bJls7feeuuofzNjxgxr1aqVlSpVygoXLmyNGjWyWbNmRTxm3Lhx7vmib/v27UvzuQOBgL388svuOfXcBQsWtFNPPdUGDhxoq1evPu73CwAAAPgagO/evdtOP/10e/bZZzMUtCsA/+CDD2zx4sXWvHlzF8QvWbIk4nEKoDdt2hRxy5s3b5rB99VXX2233HKLXXTRRTZ79mxbtmyZPfPMM5YvXz57+OGHj+u9AgAAAJLTz83Qrl07d8uI0aNHR/w+fPhwe/vtt+3dd9+1+vXrh5arx7tMmTLpft5p06bZ1KlT3XN16NAhtLxq1arWsmVLF6DHsn//fncL2rlzZ4beDwAAAJLLCZ8DfuTIEfv333+tePHiEct37dpllSpVsvLly9vFF1+cooc82pQpU6xmzZoRwXc4BfSxjBgxwooUKRK6VahQ4TjeDQAAABLdCR+AP/nkky6VpUuXLqFltWrVcnng77zzjguslXpy3nnn2apVq1J9nl9++cUF4OEGDRrk8sB1UyAfy9ChQ23Hjh2h24YNGzLx3QEAACDRnNABuILrBx54wKWPnHTSSaHl5557rl177bUuv7xJkyb2xhtvWI0aNWzMmDFpPl90L/c999xjS5cutfvvv9/1qMeSJ08el28efgMAAACyZA748VDQ3bt3b3vzzTftwgsvTPOx2bNnt7PPPjvNHvDq1avbihUrIpap0opu4cE9AAAAkHQ94Or5vu6662zy5MnWvn37oz5eAyjVk122bNlUH9O1a1dbuXKlG4QJnEilOY/X9OnTrU6dOu5qjv6fOXNmxP0aY6F0LI2pUEWgxo0b28KFC+O+XgAAJCpfA3CldSgw1k3Wrl3rfl6/fn1EjnX37t0jgm/9rtxvpZps3rzZ3ZR/HTRs2DBXG/zXX391z6eecv3ft2/fVNflqquusssvv9z9/+CDD9o333xjv/32m82fP9/1tufIkSNu2wE4ntKcadFYiGbNmqV6/1dffWVXXnmldevWzb7//nv3v8ZTaP8P6tOnj82ZM8def/11++GHH6x169buqtPvv/9OwwEAcKIF4IsWLXKlA4PlAwcPHux+Vs51kOp3hwfk//3vf+3QoUPWv39/16MdvGmynKDt27fbDTfcYLVr13bBggIF9Syec845qa6LehsVaKvMoWqMq/SgBmX26tXLVTZZsGBB3LYDEKSynKo5f+mll8bcKAcOHLA77rjDTj75ZCtQoIA1bNjQ5s2bd8wbUPu76urrRFeDl/W/9v1guc+9e/e6HvKRI0faBRdcYKeccoobd1GlShV74YUXaDgAAE60HHD1zKVWXzu8By9ceoKNp556yt0ySrniN954o7sBWVHPnj3dlRnVrFeaitJF2rZt63qmNY4ho9QDfuutt0Ysa9OmTSgA18nu4cOHU0xipVQUTkoBAEiiHHAgGa1Zs8alYGngsar7VKtWzW677TY7//zzbezYscf0nErfKl26dMQy/a7lUqhQIWvUqJE99NBD9scff7hgfOLEiS5FRVenAABAElVBAZLNd999564YqaRmOM3EWqJECfez0rU0kDJIPdgHDx50teyDVKLzxRdfTLX8pl4jfJlyv5WKpbQXjYVo0KCBXX311W59AABAxhGAAyfQrK8KgBcvXpxiUHAwwFZaSnBQs8yYMcPlcE+aNCm0LLxWfZkyZUK93UFbtmyJ6BVXT7sGI2uA6M6dO92YCw3cVB44AADIOAJw4AShAcpKAVGArBSUWHLmzOkGSgaphr3ytcOXhVN6iSqchOeBz54925UajKZBn7pt27bNVRnSwEwAAJBxBOBAFqLSnKtXrw79HizNWbx4cZd6cs0114TKcCog//vvv23u3LlWr149u+iiizL8eqoepOomjz32mHXs2NHVwf/4448jBlgq2FZaiqoCad1uv/1297MGhAIAgIxjECaQhRytNKcGWyoAHzJkiAuCO3To4AZEqlTmsVBPtyqq6HlPO+00V3VI5ThV3jBINfZV9lNlCvXaGvSpXvJcuXJl0rsGACC50AMOZCFHK82poFcTTemWHpoxVre0aAIq3VKjiXl0AwAAmYMecAAAAMBD9IADmUQlAJWTjYwpWbKkVaxYMdM22/4/9tMEbC8AyNIIwIFMCr5r16ppe/buY3tmUP58eW35ipXHHYQrkM+bL69tfGkjbZBB2m7afgAAbxCAA5lAPd8Kvid2zme1S5HZlV7L/zpi187c67bf8Qbg+vuVK1ZyFSILXIUAAKSNABzIRAq+G5SNnCQH3lEQSSAJAMjq6KoDAAAAPEQADgAAAHiIABwAAADwEAE4AAAA4CECcAAAAMBDBOAAAACAhwjAAQAAAA8RgAMAAAAeIgAHAAAAPEQADgAAAHiIABwAAADwUM6M/sGRI0ds3LhxNmPGDPvtt98sW7ZsVqVKFbv88sutW7du7ncAAAAAmdADHggErEOHDtanTx/7/fffrV69enbqqafaunXr7LrrrrPOnTtn5OkAAACApJOhHnD1fH/22Wf2ySefWPPmzSPumzt3rnXq1MkmTJhg3bt3z+z1BAAAAJKvB3zKlCl29913pwi+pUWLFnbXXXfZpEmTMnP9AAAAgOQNwJctW2Zt27ZN9f527drZ999/nxnrBQAAACSkDAXg//zzj5UuXTrV+3Xftm3bMmO9AAAAgISUoQD88OHDljNn6mnjOXLksEOHDmXGegEAAAAJKWdGq6Co2kmePHli3r9///7MWi8AAAAgIWUoAO/Ro8dRH0MFFAAAACCTAvCxY8dm5OEAAAAA4jEVvSbi+fnnn90smQAAAAAyKQAfP368jR49OmLZDTfcYFWrVnWzYtatW9c2bNiQkacEAAAAkkqGAvAXX3zRihQpEvr9o48+cmkpmv1y4cKFVrRoURs2bJj5TbN1XnLJJVauXDnLli2bvfXWW+n6uwMHDtjjjz9uDRo0sAIFCrj3evrpp9u9995rf/zxR9zXGwAAAIkvQwH4L7/8YmeddVbo97fffts6dOhg11xzjQtahw8f7qap99vu3btd4Pzss8+m+29UwaVVq1buPajSi4L4xYsX28iRI23r1q02ZsyYuK4zAAAAkkOGBmHu3bvXChcuHPr9yy+/tF69eoV+VyrK5s2bzW+akVO3jHjqqadswYIFtmjRIqtfv35o+SmnnGJt2rRxJRgBAAAATwPwSpUquV5h/f/333/bTz/9ZOeff37ofgXf4SkqJ5IpU6a4HvDw4DucUllS6zkPr3++c+fOuK0jAAAAkiwFRTW++/fvbw899JBdccUVVqtWLTvzzDMjesQ1EPNEpPSamjVrRizr3LmzFSxY0N0aN24c8+9GjBjhTjqCtwoVKni0xgAAAEj4APzOO++0Pn362IwZMyxv3rz25ptvRtz/xRdfWNeuXe1EFd3L/fzzz9vSpUtdms2ePXti/s3QoUNtx44doRtVYAAAAJBpKSjZs2d3vd+6xRIdkJ9IqlevbitWrIhYVrZsWfd/8eLFU/27PHnyuBsAAACQ6T3gCsBz5MiR4lasWDE799xzXc/4iUo993PmzLElS5b4vSoAAABIYBnqAZ85c2bM5du3b7dvv/3Wrr32WjdZj/LD/bRr1y5bvXp16Pe1a9e6VBL1ZFesWDHm39x66632/vvvW4sWLeyBBx6wJk2auBML5YZ/+OGH7kQDAAAA8DQA79ixY6r39ejRw+rUqWNPPPGE7wG4Sgk2b9489PvgwYND6zhu3LiYf6OcdtUw10yfmlxIud1HjhyxKlWquJKGCtABAAAATwPwo2ndurWbNdJvzZo1O6a63crl1kBT3QAAAADfc8DTM1GPepIBAAAAeBCAv/zyy6lOZAMAAAAggykowVzqaKp/rbzrNWvW2Oeff852BQAAADIjAE+tRF/hwoWtbdu21q9fPzdNPQAAAIBMCMA//fTTjDwcAAAAQDxzwAEAAACkjQAcAAAA8BABOAAAAOAhAnAAAADAQwTgAAAAgIcIwAEAAAAPEYADAAAAHiIABwAAADxEAA4AAAB4iAAcAAAA8BABOAAAAOAhAnAAAADAQwTgAAAAgIcIwAEAAAAPEYADAAAAHiIABwAAADxEAA4AAAB4iAAcAAAA8BABOAAAAOAhAnAAAADAQwTgAAAAgIcIwAEAAAAPEYADAAAAHiIABwAAADxEAA4AAAB4iAAcAAAA8BABOAAAAEAADgAAACQmesABAAAADxGAAwAAAB4iAAcAAACSMQCvXLmyZcuWLcWtf//+ocdcd911Ke4/99xzI55n//79NmDAACtZsqQVKFDAOnToYBs3bkzztYPP27dv3xT39evXz92nxwAAAAAJE4AvXLjQNm3aFLrNmTPHLb/iiisiHte2bduIx33wwQcR9w8aNMhmzpxpU6dOtQULFtiuXbvs4osvtsOHD6f5+hUqVHB/s3fv3tCyffv22ZQpU6xixYqZ+l4BAACQvHJaFlGqVKmI3x999FGrVq2aNW3aNGJ5njx5rEyZMjGfY8eOHfbqq6/a66+/bhdeeKFbNnHiRBdcf/zxx9amTZtUX79Bgwb266+/2owZM+yaa65xy/Sz/rZq1aqZ8A4BAACALNQDHu7AgQMucO7Vq5dL/wg3b948O+mkk6xGjRp2/fXX25YtW0L3LV682A4ePGitW7cOLStXrpzVrVvXvvzyy6O+bs+ePW3s2LGh31977TW3DmlRysvOnTsjbgAAAMAJFYC/9dZbtn379hR51+3atbNJkybZ3Llz7cknn3RpKy1atHBBsGzevNly585txYoVi/i70qVLu/uOplu3bi5t5bfffrN169bZF198Yddee22afzNixAgrUqRI6KYecwAAACDLp6CEUxqJgm31Xoe78sorQz+rV/uss86ySpUq2fvvv2+XXnppqs8XCARS9KTHooGb7du3t/Hjx7u/0c9alpahQ4fa4MGDQ7+rB5wgHAAAACdMAK6eZ+VrK//6aMqWLesC8FWrVrnflRuu9JVt27ZF9IIrTaVx48bpen2lnNx8883u5+eee+6oj1dOum4AAADACZmCohxs5Xir9/lotm7dahs2bHCBuJx55pmWK1euUAUVUaWUH3/8Md0BuKqsKIjXLa1BmwAAAMAJ3wN+5MgRF4D36NHDcuaMXDWVE3zggQfssssucwG38rTvvvtulyLSuXNn9xjlYPfu3duGDBliJUqUsOLFi9ttt91m9erVC1VFOZocOXLY8uXLQz8DAAAACRuAK/Vk/fr1MSuPKBj+4YcfbMKECW6ApoLw5s2b27Rp06xQoUKhxz311FMueO/SpYur6d2yZUsbN25choLpwoULZ9p7AgAAALJsAK7ygRr8GEu+fPls1qxZR32OvHnz2pgxY9wtvRSgH60qCwAAAJCQOeAAAABAIiMABwAAADxEAA4AAAB4iAAcAAAA8BABOAAAAOAhAnAAAADAQwTgAAAAgIcIwAEAAAAPEYADAAAAHiIABwAAADxEAA4AAAB4iAAcAAAA8BABOAAAAOAhAnAAAADAQwTgAAAAgIcIwAEAAAAPEYADAAAAHiIABwAAADxEAA4AAAB4iAAcAAAA8BABOAAAAOAhAnAAAADAQwTgAAAAgIcIwAEAAAAPEYADAAAAHiIABwAAADxEAA4AAAB4iAAcAAAA8BABOAAAAOAhAnAAAADAQwTgAAAAgIcIwAEAAAAPEYADAAAAHiIABwAAADxEAA4AAAB4iAAcAAAASMYA/IEHHrBs2bJF3MqUKRPxmEAg4B5Xrlw5y5cvnzVr1sx++umniMfs37/fBgwYYCVLlrQCBQpYhw4dbOPGjWm+9nXXXeder2/fvinu69evn7tPjwEAAAASJgCXU0891TZt2hS6/fDDDxH3jxw50kaNGmXPPvusLVy40AXorVq1sn///Tf0mEGDBtnMmTNt6tSptmDBAtu1a5ddfPHFdvjw4TRfu0KFCu5v9u7dG1q2b98+mzJlilWsWDEO7xYAAADJKEsF4Dlz5nRBdfBWqlSpiN7v0aNH2z333GOXXnqp1a1b18aPH2979uyxyZMnu8fs2LHDXn31VXvyySftwgsvtPr169vEiRNdIP/xxx+n+doNGjRwgfaMGTNCy/SzAnM9T2rU475z586IGwAAAHBCBOCrVq1y6SVVqlSxq666yn799dfQfWvXrrXNmzdb69atQ8vy5MljTZs2tS+//NL9vnjxYjt48GDEY/R8CtaDj0lLz549bezYsaHfX3vtNevVq1eafzNixAgrUqRI6KaAHQAAAMjyAXjDhg1twoQJNmvWLHv55ZddsN24cWPbunWru1+/S+nSpSP+Tr8H79P/uXPntmLFiqX6mLR069bNpa389ttvtm7dOvviiy/s2muvTfNvhg4d6nreg7cNGzZk+L0DAAAgeeS0LKJdu3ahn+vVq2eNGjWyatWquTSTwYMHh+7TgMhwSk2JXhYtPY8RDdxs3769e039jX7WsrSoF143AAAA4ITqAY+mCiYKxJWWIsGKKNE92Vu2bAn1iusxBw4csG3btqX6mKNRysm4ceNcEH609BMAAAAgYQJwDW5cvny5lS1b1v2uvHAF2HPmzAk9RsH2/PnzXaqKnHnmmZYrV66Ix6iayo8//hh6zNG0bdvWPa9ubdq0yfT3BQAAgOSWZVJQbrvtNrvkkktcJRL1WD/88MOuokiPHj3c/UohUYnB4cOHW/Xq1d1NP+fPn9+uvvpq9xgNguzdu7cNGTLESpQoYcWLF3fPq550VUVJjxw5crjAP/gzAAAAkJABuCbL6dq1q/3999+u/OC5555rX3/9tVWqVCn0mDvuuMPV6dbkOEoz0cDN2bNnW6FChUKPeeqpp1w5wy5durjHtmzZ0qWUZCSYLly4cKa/PwAAACBLBeCaBOdo1AuumTB1S03evHltzJgx7pZeCtDT8tZbb6X7uQAAAIATMgccAAAASEQE4AAAAICHCMABAAAADxGAAwAAAB4iAAcAAAA8RAAOAAAAeIgAHAAAAPAQATgAAADgIQJwAAAAwEME4AAAAICHCMABAAAADxGAAwAAAB4iAAcAAAA8RAAOAAAAeIgAHAAAAPAQATgAAADgIQJwAAAAwEME4AAAAICHCMABAAAADxGAAwAAAB4iAAcAAAA8RAAOAAAAeIgAHAAAAPAQATgAAADgIQJwAAAAwEME4AAAAICHCMABAAAADxGAAwAAAB4iAAcAAAA8RAAOAAAAeIgAHAAAAPAQATgAAADgIQJwAAAAwEME4AAAAICHCMABAACAZAzAR4wYYWeffbYVKlTITjrpJOvUqZOtXLky4jHXXXedZcuWLeJ27rnnRjxm//79NmDAACtZsqQVKFDAOnToYBs3bkzztYPP27dv3xT39evXz92nxwAAAAAJE4DPnz/f+vfvb19//bXNmTPHDh06ZK1bt7bdu3dHPK5t27a2adOm0O2DDz6IuH/QoEE2c+ZMmzp1qi1YsMB27dplF198sR0+fDjN169QoYL7m71794aW7du3z6ZMmWIVK1bM5HcLAACAZJXTsoiPPvoo4vexY8e6nvDFixfbBRdcEFqeJ08eK1OmTMzn2LFjh7366qv2+uuv24UXXuiWTZw40QXXH3/8sbVp0ybV12/QoIH9+uuvNmPGDLvmmmvcMv2sv61atWomvUsAAAAkuyzTAx4rmJbixYtHLJ83b54LzGvUqGHXX3+9bdmyJXSfgvWDBw+6nvOgcuXKWd26de3LL7886mv27NnTBf5Br732mvXq1SvNv1HKy86dOyNuAAAAwAkVgAcCARs8eLCdf/75LngOateunU2aNMnmzp1rTz75pC1cuNBatGjhgmDZvHmz5c6d24oVKxbxfKVLl3b3HU23bt1c2spvv/1m69atsy+++MKuvfbao+auFylSJHRTj/mJKD05+PEwffp0q1Onjruyof+VPhROqUj33nuvValSxfLly+euRjz44IN25MiRuK8bAABA0gTgN998sy1btszlX4e78sorrX379i4ov+SSS+zDDz+0X375xd5///2jBvQaSHk0Grip5x8/frzrCdfPWpaWoUOHut764G3Dhg12IkpvDn5GjBs3zpo1a5bq/V999ZVrU534fP/99+7/Ll262DfffBN6zGOPPWYvvviiPfvss7Z8+XIbOXKkPf744zZmzJhjXi8AAAA/ZZkc8CBVMHnnnXfss88+s/Lly6f52LJly1qlSpVs1apV7nflhh84cMC2bdsW0QuuNJXGjRun6/WVcqITAHnuueeO+nj13Op2oktPDr62rXqjdRVi+/bt7kRIAXJaQXZaRo8eba1atXInMaL/dSKg5cGTLwXpHTt2dCdDUrlyZXffokWLjvMdAwAAJHkPuHqpFfhq4KNSTJRycDRbt251Pc4KxOXMM8+0XLlyuR7cIFVK+fHHH9MdgKvKigJN3dIatJnoYuXgK0deaTmqFqMrFFdccYXbXsEToIxScB2ery/a5uH5+kpD+uSTT9yVDlFPudKELrroomN8ZwAAAP7KMj3gSn+YPHmyvf322y4POZizrbxq5f6qnOADDzxgl112mQu4lad99913uxSRzp07hx7bu3dvGzJkiJUoUcIFj7fddpvVq1cvVBXlaHLkyOFSHYI/J6NYOfhr1qxxPc+qqa6BraJtq55z9ZYPHz48w6+jNlZ+flr5+nfeeac7GahVq5ZrD5WTfOSRR6xr167H/T4BAACSOgB/4YUX3P/R6QwK7jQJjoKvH374wSZMmODSHxSEN2/e3KZNm+YC9qCnnnrKcubM6XKJVdO7ZcuWLhc5I8F04cKFLZkFc/DV0xz03XffucBc1WfCaQCsTnZk/fr1biBlkPLIVZWmYMGCoWUa1Kqc7qDo3PzofH21r0pJ6uTs1FNPtaVLl7pa7zoJ6NGjRya/cwAAgCQKwBV4pUW94LNmzTrq8+TNm9cN0MvIID0F6Gl56623LFmkloOvqiM6iVFOePTJTDDAVlCsADlI6USqcqKc8VgnN8rZj65Oo3z98F7x22+/3e666y676qqr3O+6mqEKNaraQgAOAABORFkmAIf/J0AKvlUGULXWo3Pw69ev79I/FCA3adIk5nPoysMpp5wS+l2DOHXiFL4sXKNGjVy+/q233hpaNnv27Ih8/T179lj27JFDFXQCQBlCAABwoiIAR7py8JV6ohlCu3fv7mqwKyD/+++/3YBZ9Uofy6DIgQMHugorqqSiSid6bc1YGp76onKTyvmuWLGiS0FZsmSJjRo16qgTJAEAAGRVWaYKCvzPwddgR+XgK78+eFMOdng+vgJwDXKtWbOmdejQwdXsPtbJh9TTrYoqet7TTjvNpQLp9Ro2bBh6jFKJLr/8cuvXr5/Vrl3bDfy88cYb7aGHHsqU9w0AAOA1esCRrhx8UYnHYcOGuVt6aPCsbmlRcK1batQbr7rgugEAACQCAvAEoQokSglB+qmEpVJbMtPyv47QBGwvAADSRACeIMF3zdq1bd+ePX6vygklb/78tnL58kwJwhXM58+X166duTdT1i2ZaLtp+wEAkCwIwBOAer4VfBe++xHLWfHoM4jC7ND6tbZz+D1u22VGAK7nWL5iJVchssiVCAAAsjIC8ASi4DtXjdp+r0bSUhBJIAkAAI6GKigAAACAhwjAAQAAAA8RgAMAAAAeIgAHAAAAPEQADgAAAHiIABwAAADwEAE4AAAA4CECcAAAAMBDBOAAAACAhwjAAQAAAA8RgAMAAAAeIgAHAAAAPEQADgAAAHiIABwAAADwEAE4AAAA4CECcAAAAMBDBOAAAACAhwjAAQAAAA8RgAMAAAAeIgAHAAAAPEQADgAAAHiIABwAAADwEAE4AAAA4CECcAAAAMBDBOAAAACAhwjAAQAAAA8RgAMAAAAeIgAHAAAAPEQAnornn3/eqlSpYnnz5rUzzzzTPv/8cy/bBQAAAAmKADyGadOm2aBBg+yee+6xJUuWWJMmTaxdu3a2fv1671sIAAAACYUAPIZRo0ZZ7969rU+fPla7dm0bPXq0VahQwV544QXvWwgAAAAJJaffK5DVHDhwwBYvXmx33XVXxPLWrVvbl19+meLx+/fvd7egHTt2uP937txpXtm1a5f7/+Cq5RbYu8ez1z2RHdq4LrTtvGwrAEBiC34n79+82o4c2Of36pwwDv6z0dPv5eBrBAIB8wMBeJS///7bDh8+bKVLl45Yrt83b96cYgOOGDHChg0blmK5esy99u+TD3n+mie6pk2b+r0KAIAEtG3Ws36vwgmpqcffy//++68VKVLEvEYAnops2bJF/K4zpOhlMnToUBs8eHDo9yNHjtg///xjJUqUiPn4ZKKzS52IbNiwwQoXLuz36iQt2sF/tIH/aAP/0Qb+ow0i4zoF3+XKlTM/EIBHKVmypOXIkSNFb/eWLVtS9IpLnjx53C1c0aJF49FWJywF3wTg/qMd/Ecb+I828B9t4D/a4P/40fMdxCDMKLlz53ZlB+fMmROxXL83btzYy7YBAABAAqIHPAallHTr1s3OOussa9Sokb300kuuBGHfvn29byEAAAAkFALwGK688krbunWrPfjgg7Zp0yarW7euffDBB1apUiXvW+gEptSc//znPylSdEA7JBuOBf/RBv6jDfxHG2Qd2QJ+1V8BAAAAkhA54AAAAICHCMABAAAADxGAAwAAAB4iAAcAAAA8RAAOAAAAeIgyhMgU7777ri1atMjatm3raqfPnTvXnnjiCTty5IhdeumldsMNN7ClPbB7926bPHmyffnll24212zZsrkZXM877zzr2rWrFShQgHaIs40bN9oLL7yQog00kZfmEqhQoQJt4IFVq1bFbIPq1auz/T3AceA/2iBrowwhjtuLL75oAwYMsNNPP9196T3//PN20003uXrqOXLksAkTJtiIESNs4MCBbO04+vnnn61Vq1a2Z88ea9q0qQs4VGV0y5YtNn/+fBd8z5492+rUqUM7xMmCBQusXbt2Lshu3bp1RBtoNt0NGzbYhx9+6E6IEB87duyw7t27u04BTTN90kknuTb466+/bOfOnXbJJZe4zyRNxY344DjwH21wAlAdcOB41K5dO/DSSy+5n+fOnRvImzdv4LnnngvdP3bsWPcYxFezZs0CV111VWD//v0p7tOyrl27uscgfs4666zAoEGDUr1f9+kxiJ9u3boF6tWrF/j6669T3Kdlp512WqB79+40QRxxHPiPNsj66AHHccufP7+tWLHCKlas6H7PnTu3fffdd24GUfntt9/s1FNPdekRiG87KA0otR7uH3/80c455xzXQ474yJcvny1dutRq1qwZ834dJ/Xr17e9e/fSBHFStGhRmzVrljVs2DDm/V9//bVLldu+fTttECccB/6jDbI+BmHiuJUoUcLWrVvnfv7jjz/s0KFDtn79+tD9uq948eJs6TgrVqyYSwFKzerVq91jED9ly5Z1ecep+eqrr9xjEF/K+T6W+5A5OA78RxtkfQzCxHHr2LGj9e7d23r06GHvvPOOy78cMmSIZc+e3X3Z3X777S4fFvF1/fXXuza49957XS648o+1/TUITfnHw4cPt0GDBtEMcXTbbbe5gZaLFy+O2QavvPKKjR49mjaII+V461h49dVX7ayzzoq4T1eI1D4dOnSgDeKI48B/tMEJwO8cGJz4du3aFejTp0+gbt26gb59+wYOHDgQePzxxwO5c+cOZMuWzeUd//nnn36vZlJ49NFHA2XLlnXbPXv27O6mn7Xsscce83v1ksLUqVMDDRs2DOTMmdNte930s5ZNmzbN79VLeNu2bQu0bdvWbfdixYoFatasGahVq5b7WcdDu3bt3GMQXxwH/qMNsjZywBE3+/bts4MHD1qhQoXYyh5bu3at63WVMmXKWJUqVWgDj2nf//vvv93PJUuWtFy5ctEGHlq+fLnL9w4/DlQitVatWrSDhzgO/EcbZE0E4ADgAZXCI/8YyY7jwH+0QdbAIEzEnWof9+rViy3tgTFjxrg88DfeeMP9/vrrr7uqKOr1u/vuu90AWcTP/v373fgH1WF//PHH3bKHH37Y1WAvWLCgXX311a4WNeLr+++/t7Fjx7orQfLTTz9Zv379XP63KqQgvjgO/EcbnAD8zoFB4lu6dKnLvUR8Pfjgg4FChQoFLrvsskCZMmVcPniJEiUCDz/8cGD48OGBUqVKBe6//36aIY5uvfXWQLly5QJDhgxxte/79+8fqFixYmDixImByZMnB0455ZTAgAEDaIM4+t///hfIkSOH2/d1PHz88ceBokWLBi688MJAmzZt3H2TJk2iDeKI48B/tEHWRwCO4/b222+neXvqqacIwD1QtWrVwPTp00MnPQo0FPgFzZgxwwWAiJ8KFSoE5syZ435es2aN2+/feuut0P2zZ88OVKpUiSaIowYNGriTTpkyZYoLvnVyGvTEE08EzjjjDNogjjgO/EcbZH3kgOO4BcsN6oQuNbr/8OHDbG2PJ0RasmSJmwQpWI9d6ShMiORfGzApVfwp1UeTTlWuXNl9JuXJk8eVhaxXr567/9dff7XTTz/d/v33Xw/WJjlxHPiPNsj6yAFHphT8nz59uh05ciTmTbNiIv5U5eHnn392P2tCHp3wBH8P5sGedNJJNEUcKfDWZDuycOFCd+L57bffhu7/5ptv7OSTT6YN4khVl7Zu3ep+1myXGvcQ/F30s4J0xA/Hgf9og6yPiXhw3M4880wXZHfq1Cnm/UfrHUfm0AA/TYKkiZE++eQTu/POO91kDAo41AaPPPKIXX755WzuONIgv+uuu85NuKNe1yeffNINflWvuK4UvfDCC26QJuLnwgsvtP79+9uAAQNs2rRp1qZNGxs6dKgblBmcGOz888+nCeKI48B/tEHWRwoKjtvnn3/u0hratm0b837dpxnoVBkC8aMe70cffdTVPlaAoQB86tSpdscdd9iePXvcDIHPPvusq8iB+Jk0aVKoDa688kqbN2+e3X///aE2uO+++1wwjvj4888/7dprr3Vt0KRJE3cM3HPPPfbcc8+5ALxatWr24Ycfuv8RPxwH/qMNsjYCcABAwlPut06CVJIzZ04u/gLwFwE4AMTpioRmwlSva4kSJSxHjhxsZyQdjgP/0QZZE9dBkSk04Oyaa65xU57ny5fPjcDWz1qm9BN4g3bw38yZM+28885zx0C5cuXcIGX9rGVvvfWW36uXFJT29vLLL1vPnj2tXbt2dtFFF7mflZtPFSBvcBz4jzbI2ugBx3FTUNGlSxdr2bKlG/BUunRpN+hyy5YtNnv2bDcgUDMzanAg4od28N9///tfu+WWW9zMr9HHgmZg1EBAzVZ6/fXX+72qCUuVf1q1auXSTTTuJLwN5s+f78ZA6HNJJTkRHxwH/qMNTgB+FyLHie/UU08NjBgxItX7NSNjnTp1PF2nZEQ7+K9atWqBV155JdX7X331VTdhEuKnWbNmgauuuiqwf//+FPdpWdeuXd1jED8cB/6jDbI+esBx3PLmzWvLli2zGjVqxLx/5cqVbuKLffv2sbXjiHbwn9Kvli5dajVr1ox5v8oR1q9f3/bu3ev5uiULpfso7S21Hm5N0nPOOee4HnLEB8eB/2iDrI8ccBw3lfNKK7f17bfftqpVq7Kl44x28J9mvHzppZdSvV95ycFZMREfxYoVcxNRpWb16tXuMYgfjgP/0QZZH7WYcNwefPBBu+qqq1x+ZevWrV3OpSo/bN682ebMmePyLVWLF/FFO/hPE++0b9/ePvroo5jHwrp16+yDDz7wezUTmvLre/ToYffee6/LBY9ug+HDh9ugQYP8Xs2ExnHgP9og6yMFBZlC028//fTT7n990QWnRm/UqJENHDjQ/Y/4ox3899tvv7kZLzURTPSxoNnpKleu7PcqJrzHHnvMfR5p+yv4Fg3EVDso+NbkVIgvjgP/0QZZGwE4ACAhrV27NuIkSKVRASArIAAHAAAAPMQgTGSK77//3h5++GF7/vnn3ex/4Xbu3OnqIiP+aAf/vf/++9anTx+X5rB8+fKI+7Zt22YtWrTwbd2SharMLFiwwNUEj6ZqTBMmTPBlvZIJx4H/aIMszu86iDjxzZo1K5A7d25Xh7pixYqBkiVLBubOnRu6f/PmzYHs2bP7uo7JgHbw36RJkwI5cuQItG/fPnD++ecH8ubNG5g4cWLofo6F+Fu5cmWgUqVKgWzZsrnPnaZNmwb++OMP2sBDHAf+ow2yPgJwHLdGjRoF7r77bvfzkSNHAiNHjgwULFgw8OGHH7plBB3eoB38V79+/cAzzzwT+v3NN990x0Jwch6Ohfjr1KlT4OKLLw789ddfgVWrVgUuueSSQJUqVQLr1q2jDTzCceA/2iDrIwDHcStcuHBg9erVEcsmT54cKFCgQOCdd94h6PAI7eA/7fO//vprxLJPP/00UKhQocALL7zAseCBk046KbBs2bKIZf369XNX59asWUMbeIDjwH+0QdZHHXActzx58tj27dsjlnXt2tWyZ8/u6oOrHinij3bwX+HChe3PP/+MqLbRrFkze/fdd+3iiy+2jRs3+rp+yZL/nTNn5Ffbc8895z6PmjZtapMnT/Zt3ZIFx4H/aIOsjwAcx+2MM86wTz/91M4888yI5VdeeaUdOXLETYqB+KMd/Kcpzj/88EM799xzI5Yr8AsG4YivWrVquanoa9euHbF8zJgxrhZ4hw4daII44zjwH22Q9VEFBcftpptust9//z3mfeoJHz9+vF1wwQVs6TijHfx36623Wt68eWPep57w9957z7p37+75eiWTzp0725QpU2Le9+yzz7rPJAXiiB+OA//RBlkfdcABAAAAD9EDDgAAAHiIABwAAADwEAE4AAAA4CECcAAAAMBDBODINMuWLUv1vrfeeostDQCAhz755JNU71NVIPiHKijINGXLlrUvvvjCqlatGrF8+vTprvTa7t272doeOHz4sI0bN8598G7ZssXVYg83d+5c2iHOtK8/+uijqbbBr7/+Sht44JdffrF58+bFbIP777+fNogzjgP/FS1a1ObMmWNnn312xPLRo0e7Y2Dnzp2+rVuyYyIeZGod6pYtW9qXX37pgnGZNm2a9erVywWE8MbAgQPd9m7fvr3VrVvXsmXLxqb3WJ8+fWz+/PnWrVs3dyzQBt57+eWX3WdSyZIlrUyZMhFtoJ8JwOOP48B/Tz31lF100UXu86hOnTpu2RNPPGEPPfSQvf/++36vXlKjBxyZHvx9/PHH9vnnn9tHH33kPoBff/11u+yyy9jSHlHAMWHCBPehC/96nfTldt5559EEPqlUqZL169fP7rzzTtrAJxwHWYMCbvV4L1iwwHWKDR8+3M3Y27hxY79XLanRA45M9fTTT7teP03FrdkxNSNdx44d2coeyp07t51yyilscx8VK1bMihcvThv4aNu2bXbFFVfQBj7iOMgabrvtNtu6daudddZZLkVx9uzZ1rBhQ79XK+nRA47j8s4776RYdvDgQTcNbuvWra1Dhw6h5eE/I36efPJJl2OsATakPvhj4sSJ9vbbb9v48eMtf/78Pq1Fcuvdu7fLe+3bt6/fq5K0OA788cwzz6TaE37BBRfYOeecE1p2yy23eLhmCEcAjuOSPXv6CukoENSZN+Kvc+fO9umnn7oe2FNPPdVy5coVcf+MGTNohjirX7++rVmzxgKBgFWuXDlFG3z33Xe0QZyNGDHCRo0a5cZC1KtXL0UbEHjEH8eBP6pUqZLu72UGhPuHFBQcl+jKAsgaeZcKwuGfTp06sfl99tJLL1nBggXd4DPdogMPAvD44zjwx9q1a316ZWQEPeCIq+3bt7uAEAAA+EtXon/44Qc3SFk5+vAPE/Eg0zz22GNuhHWQBkApDeLkk0+277//ni3tsb/++suNeldtdv0M7y1evNjlwU6aNMmWLFlCE/hEqUC6wR8cB/4ZNGiQvfrqq6HgWzngDRo0sAoVKrga+fBRAMgkVapUCXzxxRfu59mzZweKFi0amDVrVqB3796BVq1asZ09smvXrkDPnj0DOXLkCGTLls3dcubMGejVq1dg9+7dtIMH/vzzz0Dz5s3dti9WrJg7FvRzixYtAlu2bKENPDJ+/PhA3bp1A3ny5HG3evXqBSZMmMD29wjHgf9OPvnkwMKFC93PM2fODJQrVy6wcuXKwD333BNo3Lix36uX1OgBR6bZtGmTO6uW9957z7p06eIqodxxxx22cOFCtrRHBg8e7HJe3333XZcCpJsqcmjZkCFDaAcPDBgwwM0w99NPP9k///zjSuL9+OOPbhm5x97QAExNxKN6+G+88Ya7Ote2bVtXFUWTkyD+OA789/fff7uJqOSDDz5wV6Zr1KjhqgQpFQU+8vsMAImjbNmyoR7wGjVqBN544w3384oVKwKFChXyee2SR4kSJQKffvppiuVz584NlCxZ0pd1SjaFCxcOfPvttymWf/PNN4EiRYr4sk7JpnLlyq4HPNq4cePcfYg/jgP/VaxY0V2JPnToUKBChQqBd9991y3/8ccf3ZU5+IcqKMg0l156qV199dVWvXp1V/S/Xbt2bvnSpUuZGMZDe/bssdKlS6dYftJJJ7n74E11oOiyd6JlVA7y7opcrJn+tEz3If44DvzXs2dPdzW6bNmyrvpPq1at3PJvvvnGatWq5ffqJTVSUJBpdFn35ptvtjp16ticOXNcCTDRl52mhIY3GjVqZP/5z39s3759oWV79+61YcOGufsQfy1atLCBAwfaH3/8EVqmmWE1QVXLli1pAg9oNlilnkRTKoo6CRB/HAf+e+CBB+yVV16xG264wQ3Iz5Mnj1ueI0cOu+uuu/xevaRGGUIgwSjXWLmuCsBPP/101+uhqxB58+a1WbNmucl5EF8bNmywjh07urbQuAi1wfr1692EMMrHL1++PE0QZ9OnT7crr7zSLrzwQjvvvPNcG6gq0CeffOICc2rlxx/HAZA6AnAc91T0SjXRpfVY09KHYyp676jHW+XvVqxY4cqv6arENddcY/ny5fNwLaArQeFtoGAQ3pa/05W55cuXh9pAA5E1QyO8w3Hg/VT06vFWp0tq09IHMSjcPwTgOO6p6Ddv3uzyi9Oalp6p6AEA8GYq+kWLFlmJEiXSnJaeqej9RQAOJACuRPiPXif/qcxj4cKFQz+nJfg4ZC6OAyB9CMDhCQ1A04yYiA+uRPiPXif/aWCZBn0Hr8iphy+aUlG4Ihc/HAcnDs3PcfbZZ/u9GkmLABxxpfSURx55xI3CVl4yAMSLJpvSgMucOXO6n9PStGlTGgIJb9euXe7ENHz8jwbl33fffW5iHk1PD39QhhDHTTMtaoBfqVKlrFy5cu4SpOq/3n///Va1alX7+uuv7bXXXmNLe2TChAm2f//+FMsPHDjg7kP8PfjggzFrruskVPchPhRUK/gO9sRecMEFbln4TcvSyotF5uE48M/GjRvdyWiRIkXcTTMk6zOpe/furtdb5QhVFQj+oQccx001vjXtuUp+ffTRR67iQJs2bVwZPNWjpqfJv8vw4TQ5kpbR40EbJAOOA//RBv659tpr3VTz119/vSvJ+dlnn9kZZ5zhStOq95uTUP8xEyaO2/vvv29jx451JdYUjGsCjBo1atjo0aPZuj4I5rjG6hFRTwj8a4Pvv//eihcvThP42Aa6JK/ybPCvDTgO4u/TTz919e7VC3755Ze7q9NXXHEFk+9kIQTgOG6a7U/1dUUpJ/py69OnD1vWY6ptrC873TTbYvBSvKjXe+3atW6CHsRPsWLFQm2gk9Dw4ENtoOCvb9++NEEc6VK7aNurpy9//vwRbaApuNUTiPjhOMga46+qVavmfi5TpozLAdfkYMg6CMBx3JTvrYl4wi87FihQgC3rsU6dOoUG2CgFqGDBgqH7cufObZUrV7bLLruMdokjXfVRr1+vXr1s2LBhEVccgm3QqFEj2iCOlixZ4v5XO+gSvLZ7eBvoEvxtt91GG8QRx0HWoO/iIFUF4spP1kIOOI6bDmzNhqlBHaJ88BYtWqQIwmfMmMHW9sD48eNdPj4ftv5RBY7GjRtHnJjCWz179rSnn36aet8+4jjw93u5bt26oSuhy5Yts1q1akWckMp3333n0xqCAByZ8kWXHsoTB5LB+vXr07y/YsWKnq0L4BeOA//oClx6qFAC/EEADiSY1CYgCaIKCm2QDHQVLi1z5871bF2SFZ9FQOrIAQcSjFJ9wgPwgwcPurxYpaakt1cEmZOHHN0Go0aNchNTIf6U6x3dBhof8eOPP1qPHj1oAg9wHACpowccSBKTJ0+2adOm2dtvv+33qiR1yc7HH3/c5s2b5/eqJK0HHnjAVaN54okn/F6VpMVxABCAA0ljzZo1dtppp9nu3bv9XpWktWrVKlcCjzbwz+rVq+2cc86xf/75x8e1SG4cBwApKEBS0BToY8aMsfLly/u9Kklh586dEb+rJJ5mJ1Xva/Xq1X1bL5h99dVXVAjyCMcBkDpywIEEnQQjPPj7999/3YQkEydO9HXdkkXRokVTDIRVO1SoUMGmTp3q23olk0svvTTmSdCiRYvcBD2IP44DIHXkgAMJRoMtoysRlCpVyho2bOiCc3hT/zhWG5xyyikRM5TCu/KowTZQdZTWrVuz6T3AceCPZ555Jt2PveWWW+K6LkgdATgAAECCqFKlSroep6t0v/76a9zXB7ERgAMJaNu2bfbqq6/a8uXL3Yds7dq1XY9g8eLF/V61pLFy5UqXdx9sA81Cd/PNN7v/4R2lnIQfB2eeeSab30McB0Bs2VNZDuAEvuxbuXJldxlSgbiqPehn9YpEXxJGfPzvf/9z00AvXrzY1aNW9RlN+VyvXj1788032ewe2LhxozVp0sRVPBk4cKC71H722Wfb+eefbxs2bKANPMBxAKSOHnAgwSjwa9y4sb3wwguWI0eO0OyX/fr1sy+++MJNRIL4qlq1ql177bX24IMPppj2+fXXX+eyrweU560qHBoTUbNmzVBvbK9evaxAgQI2e/ZsL1YjqXEcZJ2T0XfeecfWr19vBw4ciLhPk4PBHwTgQILJly+fm/EvGHQEKfhQDWqVJER8qeLMsmXL3KDL6PrH6hHfs2cPTeDBcfDll19a/fr1I5brSsR5553HceABjgP/ffLJJ9ahQwd3BVTfAeqg+e2331xVoAYNGtjcuXP9XsWkRQoKkGD0oaqc12hapgAc8desWTP7/PPPUyxfsGCBS4tA/FWsWNFNPx/t0KFDdvLJJ9MEHuA48N/QoUNtyJAh7spn3rx5bfr06S4Fq2nTpnbFFVf4vXpJjXpYQAJQb2uQcl2V86oZ/84991y37Ouvv7bnnnvOHn30UR/XMrHpEm+QepzuvPNOlwMe3gbK/x42bJiPa5k8Ro4caQMGDHD7vQZeahCmBmTq2GAa+vjhOMha1PEyZcoU97NKoOoKaMGCBV16XMeOHe2mm27yexWTFikoQAJQjWMFGLqsmBY9RvngiE8bpAdt4N0kVLt373Y93sHa68GflQPOVPTxwXGQtZQpU8almdSpU8dOPfVUGzFihOsg+P77710q1q5du/xexaRFDziQANauXev3KiS9I0eOJP028Nvo0aP9XoWkx3GQtegKnAbfKwBv3769S0f54YcfbMaMGaGrc/AHPeAAAAAJSBPtqJdbpVA1+Pu2225zY1E0QPypp56ySpUq+b2KSYsAHEiQvMt27dpZrly5InIwY9HlR2Q+1Vq/4YYb3ECno00FzfTP8aGyg4ULFw79nJbg45C5OA6A9CEABxIk73Lz5s120kknpZmDSf5x/KjMlwb5lShRIs2poJn+OX5U937Tpk2h4yA8HzxI4yQ4DuKH4yDr1WJfuHCh+1wKt337dlcxi6no/UMOOJBgeZfkYPqfh09Ovj802Kx48eLu508//dSntUhuHAdZi2p+xxp4v3//fvv99999WSf8HwJwIIGo7rFmAPzvf/9rNWrU8Ht1krYNNAnSe++95wY+wTuqbRysdjJv3jw362WFChVoAh9wHPgrPBVx1qxZVqRIkdDvCsg1QU/lypV9WjsIATiQQJQDrgkXYl16h3dtoN4l2sA/KjWoWt89evTwcS2SG8eBvzp16uT+1+dQ9HGgtlHw/eSTT/q0dhBmwgQSTPfu3e3VV1/1ezWSmiaAeeyxx1xPLPzRsmVL1wsO/3Ac+EepiLppRtgtW7aEftdNHQSalv7iiy/2cQ1BDziQYA4cOGCvvPKKzZkzx8466yw36Ui4UaNG+bZuyeKbb75xl3hnz55t9erVS9EGqsGL+FJVIE3DrStCmgkzug2oBhR/HAf+YzxK1kUVFCDBNG/ePM37GZwWfz179kzz/rFjx3qwFsmNakD+4zjIGubPn+9SsjQtvVJSateubbfffrs1adLE71VLagTgAAAACWjixInuROjSSy91U8+rDOeXX35pM2fOtHHjxtnVV1/t9yomLXLAgQSjyg///vtviuW7d+929yH+WrRo4ersRtPkMLoP8TdhwgSX6xorRUv3If44Dvz3yCOP2MiRI23atGluArCBAwe6nx999FF76KGH/F69pEYPOJDAk5GE+/vvv61MmTIMDPR4YqRwGgx18sknuxJt8Oc42Lp1q1sWqzYyMhfHgf/y5MljP/30k5t6Ptzq1autbt26tm/fPt/WLdkxCBNIEOpd1eVF3dQDrinRgxRsfPDBBymCEWSuZcuWhX7++eefXRAe3gYfffSRC8ARf8EZL6Nt3LgxoiYyMh/HQdahOvgaEB4dgGsZNfL9RQAOJIiiRYu6gEO3WJPwaPmwYcN8WbdkccYZZ4TaIFaqSb58+WzMmDG+rFuyqF+/fqgNVIpQNcHDT4JUFaJt27a+rmOi4zjwn9INn376aRsyZIhLPVm6dKk1btzYHRcLFixw+d+6H/4hBQVIoJHu6vVT4Dd9+vTQlNySO3duq1SpkpUrV87XdUx069atc21QtWpV+/bbb61UqVIRbaArEEqNQPwETzL1v4KPggULRrSBJiC57LLL3M+ID46DrJWCpQGXmnRHVVAkWAWlY8eOfq9mUiMABxLwy0+XFtMqwwYkuvHjx9uVV14ZkYoFJHv+PbIOAnAgAakCh3pggzOgRc+Uifj75Zdf3EyMsdrg/vvvpwk8oqonsdpAMwQi/jgO/AvA//zzz4ircMhaCMCBBPPuu+/aNddc48oOFipUKGIgmn7+559/fF2/ZPDyyy/bTTfdZCVLlnSVZ6Lb4LvvvvN1/ZLBqlWrXB6sah7HGpxJFZT44zjwNwDXYONYA5HD8X3gHwJwIMFoAOZFF11kw4cPt/z58/u9OklJ+fb9+vWzO++80+9VSVqadEQDMO+66y4rW7ZsikDk9NNP923dkgXHgb8B+OjRo49a8adHjx6erRMiEYADCaZAgQL2ww8/uIGA8EfhwoVd1QHawN/jYPHixVarVi0f1yK5cRz4hxzwrI9RWkCCadOmjS1atMjv1UhqV1xxhc2ePdvv1UhqderUcZNPwT8cB/45WuoJ/EcdcCDBtG/f3pWY0kQw9erVs1y5ckXc36FDB9/WLVlo0ov77rvPvv7665htoLq8iK/HHnvM7rjjDpeKFasN1DuL+OI48I/GOiBrIwUFSDBplR9k8Jk3qlSpkmYb/Prrrx6tSfIKHgfRPYEMwvQOxwGQOgJwAEBCTkyVlqZNm3q2LgAQjQAcADy4FExOJpIZxwEQiUGYQIL2/l1yySUuB7N69eou7/vzzz/3e7WSyoQJE1zucb58+dzttNNOs9dff93v1Uq6Cak0BXefPn3s+uuvt6eeesp27Njh92olFY4DIDYCcCDBTJw40S688EJXA1yD/W6++WYXALZs2dImT57s9+olhVGjRrmJeFSP/Y033rBp06ZZ27ZtrW/fvi4IRPypElC1atXc9tZkI6qIonbRMiZC8gbHAZA6UlCABFO7dm274YYb7NZbb03xZaiZ6ZYvX+7buiXT4LNhw4ZZ9+7dI5aPHz/eHnjgAVu7dq1v65YsmjRp4q4AaZ/XhDxy6NAh1xuuQbCfffaZ36uY8DgOgNQRgAMJJk+ePPbTTz+54CPc6tWrrW7durZv3z7f1i1Z5M2b13788ccUbaDp0ZWWQhvEn676LFmyJMVEPCrPedZZZ9mePXs8WIvkxnEApI4UFCDBVKhQwT755JMUy7VM9yH+FHgr9SSaUlGUk4/4U53v9evXp1i+YcMGK1SoEE3gAY4DIHVMxAMkmCFDhrjcb02F3rhxY1d9Y8GCBTZu3Dh7+umn/V69pKD0kyuvvNKlOZx33nmhNtBJUKzAHJlP27937972xBNPRBwHmqSqa9eubHIPcBwAqSMFBUhAM2fOdNUfgvneygtX4NGxY0e/Vy1pLF682A0AVBuoBJumRtfJUf369f1etaRw4MABt8+/+OKLLvdbNBumBsc++uijLlUL8cdxAMRGAA4ASFjK9V6zZo07CVJKhKoDAYDfCMCBBLNw4UI7cuSINWzYMGL5N998Yzly5HAD0BBfH3zwgdvWbdq0iVg+a9Ys1zbt2rWjCeJM9b4PHz5sxYsXj1iukoSqiqIcccQXxwGQOgZhAgmmf//+bqBZtN9//93dh/i76667XPAXTb2wug/xd9VVV9nUqVNTLFcOvu5D/HEcAKkjAAcSjMqsNWjQIMVy5R7rPsSfyg0q5zuaSuKpHCTiT1d8mjdvnmJ5s2bN3H2IP44DIHUE4ECC0eCyP//8M8XyTZs2hSYkQXwVKVLETfYSTcF3gQIF2Pwe2L9/f2jwZbiDBw/a3r17aQMPcBwAqSMABxJMq1atbOjQoS4HNmj79u129913u/sQfx06dLBBgwa5wX/hwbeqoOg+xN/ZZ59tL730Uorlqopy5pln0gQe4DgAUscgTCDBKNf7ggsusK1bt4ZK3qkmeOnSpW3OnDlMxuMBnfy0bdvWFi1aZOXLl3fLNm7c6KZHnzFjhhUtWtSL1UhqX3zxhV144YUuEG/ZsqVbpjrsGqQ8e/Zs1xaIL44DIHUE4EAC2r17t02aNMm+//57NyX3aaed5iYfUR1keEMDLnXCE94GOjGCd3Ti+fjjj7v/g22gq0PMRuodjgMgNgJwAAAAwEPkgAMAAAAeIgAHAAAAPEQADgAAAHiIABwAAADwELNyAAlIdb//97//uTrUt99+uxUvXty+++47V4rw5JNP9nv1EtLOnTvT/djChQvHdV1gNm7cOOvSpYvlz5+fzeGjI0eOuBr4W7ZscT+HoyoQkhlVUIAEs2zZMlf/WLPQ/fbbb7Zy5UqrWrWq3XfffbZu3TqbMGGC36uYkLJnz27ZsmVL12MPHz4c9/VJdmXLlnXlOK+44grr3bu3NW7c2O9VSjpff/21XX311e5zR+UIw+lY4ThAMiMFBUgwgwcPtuuuu85WrVplefPmDS1v166dffbZZ76uWyL79NNPbe7cue722muv2UknnWR33HGHzZw50930s65A6D7EnyY+mjhxom3bts2aN29utWrVsscee8w2b97M5vdI37597ayzzrIff/zR/vnnH9cWwZt+B5IZPeBAglHPt9JNqlWrZoUKFXITwagHXL1QNWvWtH379vm9iglPMy/26dPHTX4UbvLkyW569Hnz5vm2bslI6Q8KxpWWsmLFCjdLqXrFL7nkEnflAvFRoEAB9/lzyimnsImBKHzyAAlGvd6x8pGVilKqVClf1inZfPXVV67nL5qWffvtt76sUzLT1YjzzjvPGjVq5ALuH374wV0l0kkqJ0Px07BhQ5f/DSAlAnAgwXTs2NEefPBBO3jwYCjXcv369XbXXXfZZZdd5vfqJYUKFSrYiy++mGL5f//7X3cfvPHnn3/aE088Yaeeeqo1a9bMnZi+9957tnbtWvvjjz/s0ksvtR49etAccTJgwAAbMmSIu/KwePFiNz4l/AYkM1JQgASjIOOiiy6yn376yf79918rV66cy3tV798HH3zgLgsjvrSddbKjHtZzzz03NCBNVWmmT5/u2gfxpfSSWbNmWY0aNVw6UPfu3V01oHAKwsuXL5+iOgcyR6z0HnUIaEAmgzCR7AjAgQSlwYDKBVdw0aBBA1cZBd4OAnzhhRds+fLlLuCoU6eOG5RGD7g3lOOtwFsnnqlRu+jqUKVKlTxaq+SicSdpYbsjmRGAAwnk0KFDLgd86dKlVrduXb9XJykp9ad169Yu3US9r/CHym1eeeWVlidPnojlBw4csKlTp7oecQDwCzngQALJmTOn61Wivq5/cuXK5cqupbcmOOKjZ8+etmPHjhTLlZal++ANpV0pF1xX4Fq1amW33HKLWwYkOwJwIMHce++9NnToUOrs+ki9q6+++qqfq5D0gnnGsVKDVKoT8accfKVeqfLPaaed5q7KffPNN25Q7Jw5c2gCJDVSUIAEU79+fVf6S6kQ6g2PHnSpvHDEl3r8lAKh+scqPRjdBqNGjaIJ4rj/K/BW/WkFeroqFKQrQ6qAojrgb7zxBm3gQVu0adPGHn300Yjlqsg0e/ZsPouQ1P7/TyYACaFTp05+r0LSUwqKBr7KL7/8ErE9SE3xZv/XOAgFfwULFgzdlzt3bqtcuTLlOD2iAcixTnR69eplo0eP9mo1gCyJABxIMP/5z3/8XoWkp2np4e/+r0BbgzA1KBn+0MRfOhGqXr16xHIt0+RIQDIjAAcAJBwm2PHf9ddfbzfccIP9+uuv1rhxY3f1Z8GCBfbYY4+5CXqAZEYOOJCAk1+kleZAhRRvLFy40N58801XZ1ql78LNmDHDo7VILppoRyk/JUuWtGLFiqV5HPzzzz+erluyDoRVqsmTTz7pJj0STQx2++23u2oopGMhmdEDDiSYmTNnRvyuwZhLliyx8ePH27Bhw3xbr2QSrDOteuCq9qD/V61a5WYk7dy5s9+rl7CeeuopK1SoUOhnAjx/afvfeuut7qbyjxJsHyDZ0QMOJInJkyfbtGnT7O233/Z7VRKeSq7deOON1r9/fxdwqCJHlSpV3LKyZctyIgQASY4AHEgSmvxCgeHu3bv9XpWEp7KDP/30kxsIqHQIDcqsV6+eqwrRokUL27Rpk9+rmJB27tyZ7scWLlw4ruuSrFT955NPPnEpQMGSkKmhJCqSGSkoQBLYu3evjRkzxsqXL+/3qiRNLnLwkvvJJ5/syhIqAN++fbvt2bPH79VLWEWLFj1q2klwgh7GQsRHx44dLU+ePKGfSQMCYiMABxJM9OAzBRwKBvPnz28TJ070dd2SRZMmTVzut4LuLl262MCBA23u3LluWcuWLf1evYRF+cesVQb1gQce8HVdgKyMFBQgwYwbNy4iAFdVFNXjbdiwoQvOEX+qsLFv3z5X8eHIkSP2xBNPuPJrmhnzvvvuox2QFKpWreqqAZUoUSJiua4EKVVF5QmBZEUADgBICMuWLbO6deu6k079nBaNh0B8qR1U+Sd60p0///zTKlSokKI8J5BMSEEBEsxHH33kpt8+//zz3e/PPfecvfzyy1anTh33M73g8aeBlk2bNk0xK+m2bdvcNOhKR0HmO+OMM0IBn37WlSClYEUjBzy+3nnnndDPs2bNsiJFioR+V+69BmmqKhCQzOgBBxKM8o4109xFF11kP/zwg5111llu1jkFfbVr17axY8f6vYpJ0fOny+7nnXeeTZo0yVVFCfb8KS2FAYDxsW7dOqtYsaILsPVzWipVqhSntYD2f4l1ApQrVy5XHUiT81x88cVsLCQtAnAgwaj3W1U39CWnQVD6+X//+58r+aWgXD2EiH8AosmPVPdbZR/fffdd1x4E4Egm6uVWDrhKcQKI9H+nqQASRu7cuUOl7j7++GM3C2OwNF5G6iTj+GjCnfnz57tc47PPPtvmzZvHJvXYypUr7eabb3aVZy688EL3s5bBG2vXriX4BlJBAA4kGOV+Dx482B566CH79ttvrX379m75L7/8Qh1wjwSr0KgeslJQVIawbdu29vzzz3u1CklPV300IHPx4sV2+umnuxMhXQXSsjfffDPpt48XbrnlFnvmmWdSLH/22Wdt0KBBtAGSGikoQIJZv3699evXzzZs2OC+AHv37u2W33rrrS73ONYXIuJf/WH69OnWo0cPNykSOeDelMC79tpr7cEHH4xYroGxr7/+OiXwPKBJqDQg88wzz4xYrhOhDh062MaNG71YDSBLIgAHgDgOBgynfHz1yCoQR3xp4imVIlTt9XCrVq1yPeLMSBp/efPmdft8dBusXr3aXYlQrXwgWVGGEEhA6mF96623bPny5S4IVPUTTQudI0cOv1ctKaRWYUNBh26Iv2bNmtnnn3+eIvjThEiaqRTxp22vsqjKvQ/34YcfuisUQDIjAAcSjHqXVO3k999/t5o1a7oyYMr/1sQX77//vlWrVs3vVUwKqv6gXGOlBEVPODJjxgzf1itZ6k8rxeHOO+90VxzOPfdct+zrr792bTJs2DAf1zJ5aCyKgu+//vrL1cYX1QBXCcLRo0f7vXqAr0hBARKMgm8F3Rr8p8onsnXrVpcPq9xkBeGIr6lTp1r37t1dBZo5c+a4/5X6oLzwzp07U4s9zvWnj4aJeLzzwgsv2COPPGJ//PGH+z1YHlXHB5DMCMCBBKNJX9TTpwl5wn3//fduYphdu3b5tm7JQhU3VAO8f//+VqhQIbftVRNZy1SekB5YJBv1gufLl8/NUwCAMoRAwlHpu3///TfFcgXeqhGO+FuzZk2o/KPaQ5PxqNdVlWheeuklmgBJp1SpUgTfQBhywIEEo+mdb7jhBnv11VftnHPOccu++eYb69u3r8uLRfwp9Sd4EqRSbKoEoSsS27dvp/qGh3Tio8mQYuXhq0QnvKnH/sYbb8RsA5UjBJIVATiQYFTnW2XuGjVqZLly5XLLDh065ILvp59+2u/VSwqqsqHcbwXdXbp0cRPxzJ071y3TrIyIvyVLlrjxECo3qEBcJ0V///23K0+o+uwE4N58Ft1zzz3u8+jtt9+2nj17uqtDGqCs9CwgmZEDDiQoDfpTGUKpU6dOinJsiJ9//vnH1TguV66cHTlyxJ544glX/k5tcN9991mxYsXY/B6UIaxRo4YbBFi0aFGXh68TUg1G1gnRpZdeShvEWa1atdzER127dg2NhVD5wfvvv98dI5oRE0hWBOBAAlM1FImeEAZIdAq6lXqlUpz6+auvvnL18LVMPbIrVqzwexUTnq42qBNAdfF11UFXgDQJkjoHVBpS1ZmAZJW+mk0ATijK/9aEL5qJTjf9/Morr/i9Wglv586d6boh/tTbHTzxLF26tMtBliJFioR+RnyVKVMmFGQrCFd1Jlm7dm2ocwBIVuSAAwlGKQ5PPfWUDRgwwOWBi3r/VIHjt99+s4cfftjvVUxY6mlN62qDgg5qUHujfv36tmjRIpeG0rx5c5f2oBzw119/PUWJTsSHJt959913rUGDBta7d2/3GaRBmWoXUoCQ7EhBARJMyZIlbcyYMS7vMtyUKVNcUK4gBPGhihvhwbYGAerKgyqhhGvatClNEGcK8lSJRsG3alAr7SSYhz927FiXCoH40vgH3XLm/L++PlVDCbaBqjJRFhXJjAAcSDAa4Pftt99a9erVI5ZrOnqVJVQpPHgjfOAZvKOTH6WZKO9Yk7/Ae6q8pBkwe/XqZRUqVKAJgCjkgAMJRlUeVPkhmiaAueaaa3xZJ8DrAFwnoBs3bmTD+0S93o8//rgdPnyYNgBiIAccSNBBmLNnz3aVBkSDnzZs2GDdu3e3wYMHhx43atQoH9cSiI/s2bO7AFwDAKOvBME7F154oc2bN8+uu+46NjsQhQAcSDCadVGDnkSTXgSngdZN9wVRmtAbbGd/jBw50m6//XZ3NUhVgOC9du3a2dChQ93nzplnnmkFChSIuJ+ZeZHMyAEHgEwSXdlBFSBUCSI68JgxYwbb3IOxEJoFU7nIGuwXnQuuiWAQ/ysRqaEaEJIdPeBAgvnzzz9d3eNYli1bZqeddprn65QsVGM6Oh8f/hg9ejSb3meqgAIgNnrAgQSjyg8qfRd9eVfToatG+N69e31bNwDJad++fW5SMAD/hyooQIK588477corr3R1dhVs//777y4NQhUJpk2b5vfqAZ7RGIh7773X1cTfsmWLW/bRRx/ZTz/9RCt4QBVQHnroIVcHv2DBgvbrr7+65eoI0EBxIJkRgAMJZsiQIa7qyRdffOHSTXRT/qvSTxj0hGSaFEkzXn7zzTcu537Xrl1uuY6D//znP36vXlJQHfBx48a5AbHhk+6oXXSVDkhmBOBAAtLEL6eeeqqben7nzp3WpUuXVPPCgUR011132cMPP2xz5syJCP40M+ZXX33l67oliwkTJoTmH8iRI0douToFVqxY4eu6AX4jAAcSTLDne/Xq1a63T2XYNAW9gvBt27b5vXqAJ3744Qfr3LlziuUqx6n64Ig/pb9p2vlYgzMPHjxIEyCpEYADCUb53soBVy9f7dq1rU+fPrZkyRI3K6Au/QLJoGjRorZp06YUy3UsKCcZ8aercJ9//nmK5W+++abVr1+fJkBSowwhkGA0A2bTpk0jllWrVs0WLFjgcjKBZHD11Ve7AckK9lRzWr2uujp02223uRlhEX/Kte/WrZvrCdf2Vy7+ypUrXWrKe++9RxMgqVGGEACQcJTioCnQp06daoFAwHLmzOmqcigw18DA8JxkxM+sWbNs+PDhtnjxYheEa5be+++/31q3bs1mR1IjAAcSxEUXXWRTpkwJTQaj3u7+/fu7S/GivNcmTZrYzz//7POaAt6WIlTaiYI/pT1Ur16dzQ/AdwTgQIJQj55yXjURjxQuXNiWLl3qKqIEZ8gsV66c6wUEgHjTZ8/ChQutRIkSEcu3b9/uesKDdcGBZEQOOJAgdJk9rd+BZKITTaWafPLJJ24Snuhp0efOnevbuiULlUGNdcK/f/9+lxcOJDMCcABAwhk4cKALwNu3b29169Z1AzHhjXfeeSciBzyYFicKyHVSVLlyZZoDSY0AHEgQCjCigwyCDiQrDb5844033NgIeKtTp06hz58ePXpE3JcrVy4XfD/55JM0C5IaATiQIJRyoqoPefLkcb/v27fP+vbtawUKFAhd9gWShWa/jDUJDOIvmO5TpUoVlwNesmRJNjsQhUGYQILo2bNnuh43duzYuK8L4Df1sGqQ37PPPsuVIABZDgE4ACDhaBr6Tz/91IoXL+5mZFTqQzhNCoP4U753agNhX3vtNZoASYsUFABAwlH9ewXh8M+wYcPswQcftLPOOsvKli3LlQggDD3gAAAg0ynoHjlypJuOHkCk7FG/AwAAHLcDBw5Y48aN2ZJADPSAAwASgqaaT2/pze+++y7u65Ps7rzzTitYsKDdd999fq8KkOWQAw4ASKj608gaVAr1pZdeso8//thOO+20FANhR40a5du6AX6jBxwAAGS65s2bpx58ZMtmc+fOZasjaRGAAwAAAB4iBQUAkHCyZ8+eZj744cOHPV0fAAhHAA4ASDgzZ86M+P3gwYO2ZMkSGz9+vKtPjfi59NJL0/U4JkNCMiMABwAknI4dO6ZYdvnll7tZMadNm2a9e/f2Zb2SQZEiRfxeBSDLIwccAJA01qxZ4ypy7N692+9VAZDEmIgHAJAU9u7da2PGjLHy5cv7vSoAkhwpKACAhFOsWLGIQZiBQMD+/fdfy58/v02cONHXdQMAUlAAAAlj6dKldsYZZ7jBltFVUUqVKmUNGzZ0wTkA+IkAHACQMBRoa0r6Pn362NVXX82AQABZEjngAICE8cUXX1iDBg3srrvusrJly1q3bt3s008/9Xu1ACACPeAAgIQccPnGG2/Y2LFj7fPPP7fKlStbr169rEePHgzCBOA7AnAAQMKXHlQgPmHCBNu0aZO1atXKPvjgA79XC0ASIwAHACS8Xbt22aRJk+zuu++27du3MxU9AF9RhhAAkLDmz59vr732mk2fPt1y5MhhXbp0YRZMAL6jBxwAkFA2bNhg48aNc7e1a9da48aNXdCt4LtAgQJ+rx4A0AMOAEgcyu9W1RPV/O7evbsbeFmzZk2/VwsAIpCCAgBIGPny5XPpJhdffLFLOQGArIgUFAAAAMBDTMQDAAAAeIgAHAAAAPAQATgAAADgIQJwAAAAwEME4AAAAICHCMABAAAADxGAAwAAAOad/w/9nKMM/Yfi4wAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -1192,7 +1249,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 76, "id": "16faf81c-8760-4c02-a575-ae033bcb637d", "metadata": {}, "outputs": [ @@ -1200,16 +1257,16 @@ "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, - "execution_count": 16, + "execution_count": 76, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1236,12 +1293,14 @@ "metadata": {}, "source": [ "You can easily change the default return periods computed, either at initialisation time, or via the property `return_periods`.\n", - "Note that estimates of impacts for specific return periods are highly dependant on the quality of the data you provided." + "Note that estimates of impacts for specific return periods are highly dependant on the data you provided.\n", + "\n", + "**We cannot check if the event set you provide is fit for computing impacts for a specific return period.** " ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 77, "id": "0ade93f9-c43a-4e8a-8225-9343bbbb3615", "metadata": {}, "outputs": [ @@ -1266,8 +1325,8 @@ " \n", " \n", " \n", - " group\n", " date\n", + " group\n", " measure\n", " metric\n", " unit\n", @@ -1277,8 +1336,8 @@ " \n", " \n", " 0\n", - " All\n", " 2018\n", + " All\n", " no_measure\n", " rp_10\n", " USD\n", @@ -1286,39 +1345,39 @@ " \n", " \n", " 1\n", - " All\n", " 2019\n", + " All\n", " no_measure\n", " rp_10\n", " USD\n", - " 1.678277e+07\n", + " 1.540368e+07\n", " \n", " \n", " 2\n", - " All\n", " 2020\n", + " All\n", " no_measure\n", " rp_10\n", " USD\n", - " 1.879207e+07\n", + " 1.591591e+07\n", " \n", " \n", " 3\n", - " All\n", " 2021\n", + " All\n", " no_measure\n", " rp_10\n", " USD\n", - " 2.092467e+07\n", + " 1.642993e+07\n", " \n", " \n", " 4\n", - " All\n", " 2022\n", + " All\n", " no_measure\n", " rp_10\n", " USD\n", - " 2.318382e+07\n", + " 1.694544e+07\n", " \n", " \n", " ...\n", @@ -1331,48 +1390,48 @@ " \n", " \n", " 87\n", - " All\n", " 2036\n", + " All\n", " no_measure\n", " rp_30\n", " USD\n", - " 2.607961e+09\n", + " 8.996046e+08\n", " \n", " \n", " 88\n", - " All\n", " 2037\n", + " All\n", " no_measure\n", " rp_30\n", " USD\n", - " 2.766248e+09\n", + " 9.151713e+08\n", " \n", " \n", " 89\n", - " All\n", " 2038\n", + " All\n", " no_measure\n", " rp_30\n", " USD\n", - " 2.929978e+09\n", + " 9.305707e+08\n", " \n", " \n", " 90\n", - " All\n", " 2039\n", + " All\n", " no_measure\n", " rp_30\n", " USD\n", - " 3.099231e+09\n", + " 9.457952e+08\n", " \n", " \n", " 91\n", - " All\n", " 2040\n", + " All\n", " no_measure\n", " rp_30\n", " USD\n", - " 3.274085e+09\n", + " 9.608368e+08\n", " \n", " \n", "\n", @@ -1380,18 +1439,18 @@ "" ], "text/plain": [ - " group date measure metric unit risk\n", - "0 All 2018 no_measure rp_10 USD 1.489354e+07\n", - "1 All 2019 no_measure rp_10 USD 1.678277e+07\n", - "2 All 2020 no_measure rp_10 USD 1.879207e+07\n", - "3 All 2021 no_measure rp_10 USD 2.092467e+07\n", - "4 All 2022 no_measure rp_10 USD 2.318382e+07\n", + " date group measure metric unit risk\n", + "0 2018 All no_measure rp_10 USD 1.489354e+07\n", + "1 2019 All no_measure rp_10 USD 1.540368e+07\n", + "2 2020 All no_measure rp_10 USD 1.591591e+07\n", + "3 2021 All no_measure rp_10 USD 1.642993e+07\n", + "4 2022 All no_measure rp_10 USD 1.694544e+07\n", ".. ... ... ... ... ... ...\n", - "87 All 2036 no_measure rp_30 USD 2.607961e+09\n", - "88 All 2037 no_measure rp_30 USD 2.766248e+09\n", - "89 All 2038 no_measure rp_30 USD 2.929978e+09\n", - "90 All 2039 no_measure rp_30 USD 3.099231e+09\n", - "91 All 2040 no_measure rp_30 USD 3.274085e+09\n", + "87 2036 All no_measure rp_30 USD 8.996046e+08\n", + "88 2037 All no_measure rp_30 USD 9.151713e+08\n", + "89 2038 All no_measure rp_30 USD 9.305707e+08\n", + "90 2039 All no_measure rp_30 USD 9.457952e+08\n", + "91 2040 All no_measure rp_30 USD 9.608368e+08\n", "\n", "[92 rows x 6 columns]" ] @@ -1420,8 +1479,8 @@ " \n", " \n", " \n", - " group\n", " date\n", + " group\n", " measure\n", " metric\n", " unit\n", @@ -1431,8 +1490,8 @@ " \n", " \n", " 0\n", - " All\n", " 2018\n", + " All\n", " no_measure\n", " rp_150\n", " USD\n", @@ -1440,39 +1499,39 @@ " \n", " \n", " 1\n", - " All\n", " 2019\n", + " All\n", " no_measure\n", " rp_150\n", " USD\n", - " 1.072504e+10\n", + " 1.013594e+10\n", " \n", " \n", " 2\n", - " All\n", " 2020\n", + " All\n", " no_measure\n", " rp_150\n", " USD\n", - " 1.158105e+10\n", + " 1.037016e+10\n", " \n", " \n", " 3\n", - " All\n", " 2021\n", + " All\n", " no_measure\n", " rp_150\n", " USD\n", - " 1.246823e+10\n", + " 1.060266e+10\n", " \n", " \n", " 4\n", - " All\n", " 2022\n", + " All\n", " no_measure\n", " rp_150\n", " USD\n", - " 1.338673e+10\n", + " 1.083340e+10\n", " \n", " \n", " ...\n", @@ -1485,48 +1544,48 @@ " \n", " \n", " 64\n", - " All\n", " 2036\n", + " All\n", " no_measure\n", " rp_500\n", " USD\n", - " 4.618632e+10\n", + " 2.706309e+10\n", " \n", " \n", " 65\n", - " All\n", " 2037\n", + " All\n", " no_measure\n", " rp_500\n", " USD\n", - " 4.801525e+10\n", + " 2.746566e+10\n", " \n", " \n", " 66\n", - " All\n", " 2038\n", + " All\n", " no_measure\n", " rp_500\n", " USD\n", - " 4.987944e+10\n", + " 2.786502e+10\n", " \n", " \n", " 67\n", - " All\n", " 2039\n", + " All\n", " no_measure\n", " rp_500\n", " USD\n", - " 5.177889e+10\n", + " 2.826115e+10\n", " \n", " \n", " 68\n", - " All\n", " 2040\n", + " All\n", " no_measure\n", " rp_500\n", " USD\n", - " 5.371361e+10\n", + " 2.865402e+10\n", " \n", " \n", "\n", @@ -1534,18 +1593,18 @@ "" ], "text/plain": [ - " group date measure metric unit risk\n", - "0 All 2018 no_measure rp_150 USD 9.900032e+09\n", - "1 All 2019 no_measure rp_150 USD 1.072504e+10\n", - "2 All 2020 no_measure rp_150 USD 1.158105e+10\n", - "3 All 2021 no_measure rp_150 USD 1.246823e+10\n", - "4 All 2022 no_measure rp_150 USD 1.338673e+10\n", + " date group measure metric unit risk\n", + "0 2018 All no_measure rp_150 USD 9.900032e+09\n", + "1 2019 All no_measure rp_150 USD 1.013594e+10\n", + "2 2020 All no_measure rp_150 USD 1.037016e+10\n", + "3 2021 All no_measure rp_150 USD 1.060266e+10\n", + "4 2022 All no_measure rp_150 USD 1.083340e+10\n", ".. ... ... ... ... ... ...\n", - "64 All 2036 no_measure rp_500 USD 4.618632e+10\n", - "65 All 2037 no_measure rp_500 USD 4.801525e+10\n", - "66 All 2038 no_measure rp_500 USD 4.987944e+10\n", - "67 All 2039 no_measure rp_500 USD 5.177889e+10\n", - "68 All 2040 no_measure rp_500 USD 5.371361e+10\n", + "64 2036 All no_measure rp_500 USD 2.706309e+10\n", + "65 2037 All no_measure rp_500 USD 2.746566e+10\n", + "66 2038 All no_measure rp_500 USD 2.786502e+10\n", + "67 2039 All no_measure rp_500 USD 2.826115e+10\n", + "68 2040 All no_measure rp_500 USD 2.865402e+10\n", "\n", "[69 rows x 6 columns]" ] @@ -1582,16 +1641,28 @@ "\n", "Same as for the return periods, you can change that at initialisation or afterward via the property.\n", "\n", - "Keep in mind that risk metrics are still computed the same way so you would still get \"Average Annual Impacts\"\n", - "values for every months and not average monthly ones !" + "Keep in mind that risk metrics are still computed the same way, so if you initialy had hazards with annual frequency values, you would still have \"Average Annual Impacts\" values for every months and not average monthly ones!\n", + "\n", + "Also note that `InterpolatedRiskTrajectory` uses `PeriodIndex` for the time dimension. These indexes are defined with the dates of the first and last snapshot, and the given time resolution.\n", + "\n", + "This means that an `InterpolatedRiskTrajectory` for a 2020 `Snapshot` and 2040 `Snapshot` with a yearly time resolution will include all years from 2020 to 2040 included (11 years in total).\n", + "\n", + "However, a trajectory with the same snapshots with a monthly resolution will have January 2040 as a last period if you only provided year 2040 for the last date. If you want to include the whole 2040 year, you need to explicitly give the date \"2040-12-31\" to the last snapshot." ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 78, "id": "128fac77-e077-4241-a003-a60c4afcad74", "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-12-19 17:28:57,703 - climada.trajectories.calc_risk_metrics - WARNING - No group id defined in at least one of the Exposures object. Per group aai will be empty.\n" + ] + }, { "data": { "text/html": [ @@ -1613,8 +1684,8 @@ " \n", " \n", " \n", - " group\n", " date\n", + " group\n", " measure\n", " metric\n", " unit\n", @@ -1624,8 +1695,8 @@ " \n", " \n", " 0\n", - " All\n", " 2018\n", + " All\n", " no_measure\n", " aai\n", " USD\n", @@ -1633,54 +1704,54 @@ " \n", " \n", " 1\n", - " All\n", " 2023\n", + " All\n", " no_measure\n", " aai\n", " USD\n", - " 2.801311e+08\n", + " 2.083634e+08\n", " \n", " \n", " 2\n", - " All\n", " 2028\n", + " All\n", " no_measure\n", " aai\n", " USD\n", - " 3.966228e+08\n", + " 2.317103e+08\n", " \n", " \n", " 3\n", - " All\n", " 2033\n", + " All\n", " no_measure\n", " aai\n", " USD\n", - " 5.344827e+08\n", + " 2.539452e+08\n", " \n", " \n", " 4\n", - " All\n", " 2038\n", + " All\n", " no_measure\n", " aai\n", " USD\n", - " 6.946753e+08\n", + " 2.749295e+08\n", " \n", " \n", "\n", "" ], "text/plain": [ - " group date measure metric unit risk\n", - "0 All 2018 no_measure aai USD 1.840432e+08\n", - "1 All 2023 no_measure aai USD 2.801311e+08\n", - "2 All 2028 no_measure aai USD 3.966228e+08\n", - "3 All 2033 no_measure aai USD 5.344827e+08\n", - "4 All 2038 no_measure aai USD 6.946753e+08" + " date group measure metric unit risk\n", + "0 2018 All no_measure aai USD 1.840432e+08\n", + "1 2023 All no_measure aai USD 2.083634e+08\n", + "2 2028 All no_measure aai USD 2.317103e+08\n", + "3 2033 All no_measure aai USD 2.539452e+08\n", + "4 2038 All no_measure aai USD 2.749295e+08" ] }, - "execution_count": 13, + "execution_count": 78, "metadata": {}, "output_type": "execute_result" } @@ -1693,10 +1764,17 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 80, "id": "c1e66906-63e3-4a29-8a0b-0e706e6a2a09", "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-12-19 17:29:33,001 - climada.trajectories.calc_risk_metrics - WARNING - No group id defined in at least one of the Exposures object. Per group aai will be empty.\n" + ] + }, { "data": { "text/html": [ @@ -1718,8 +1796,8 @@ " \n", " \n", " \n", - " group\n", " date\n", + " group\n", " measure\n", " metric\n", " unit\n", @@ -1729,8 +1807,8 @@ " \n", " \n", " 0\n", - " All\n", " 2018-01\n", + " All\n", " no_measure\n", " aai\n", " USD\n", @@ -1738,54 +1816,117 @@ " \n", " \n", " 1\n", - " All\n", " 2018-02\n", + " All\n", " no_measure\n", " aai\n", " USD\n", - " 1.853516e+08\n", + " 1.844183e+08\n", " \n", " \n", " 2\n", - " All\n", " 2018-03\n", + " All\n", " no_measure\n", " aai\n", " USD\n", - " 1.866645e+08\n", + " 1.847932e+08\n", " \n", " \n", " 3\n", - " All\n", " 2018-04\n", + " All\n", " no_measure\n", " aai\n", " USD\n", - " 1.879819e+08\n", + " 1.851679e+08\n", " \n", " \n", " 4\n", - " All\n", " 2018-05\n", + " All\n", " no_measure\n", " aai\n", " USD\n", - " 1.893037e+08\n", + " 1.855424e+08\n", + " \n", + " \n", + " ...\n", + " ...\n", + " ...\n", + " ...\n", + " ...\n", + " ...\n", + " ...\n", + " \n", + " \n", + " 1055\n", + " 2039-09\n", + " All\n", + " no_measure\n", + " rp_100\n", + " USD\n", + " 8.440435e+09\n", + " \n", + " \n", + " 1056\n", + " 2039-10\n", + " All\n", + " no_measure\n", + " rp_100\n", + " USD\n", + " 8.449624e+09\n", + " \n", + " \n", + " 1057\n", + " 2039-11\n", + " All\n", + " no_measure\n", + " rp_100\n", + " USD\n", + " 8.458802e+09\n", + " \n", + " \n", + " 1058\n", + " 2039-12\n", + " All\n", + " no_measure\n", + " rp_100\n", + " USD\n", + " 8.467969e+09\n", + " \n", + " \n", + " 1059\n", + " 2040-01\n", + " All\n", + " no_measure\n", + " rp_100\n", + " USD\n", + " 8.477125e+09\n", " \n", " \n", "\n", + "

1060 rows × 6 columns

\n", "" ], "text/plain": [ - " group date measure metric unit risk\n", - "0 All 2018-01 no_measure aai USD 1.840432e+08\n", - "1 All 2018-02 no_measure aai USD 1.853516e+08\n", - "2 All 2018-03 no_measure aai USD 1.866645e+08\n", - "3 All 2018-04 no_measure aai USD 1.879819e+08\n", - "4 All 2018-05 no_measure aai USD 1.893037e+08" + " date group measure metric unit risk\n", + "0 2018-01 All no_measure aai USD 1.840432e+08\n", + "1 2018-02 All no_measure aai USD 1.844183e+08\n", + "2 2018-03 All no_measure aai USD 1.847932e+08\n", + "3 2018-04 All no_measure aai USD 1.851679e+08\n", + "4 2018-05 All no_measure aai USD 1.855424e+08\n", + "... ... ... ... ... ... ...\n", + "1055 2039-09 All no_measure rp_100 USD 8.440435e+09\n", + "1056 2039-10 All no_measure rp_100 USD 8.449624e+09\n", + "1057 2039-11 All no_measure rp_100 USD 8.458802e+09\n", + "1058 2039-12 All no_measure rp_100 USD 8.467969e+09\n", + "1059 2040-01 All no_measure rp_100 USD 8.477125e+09\n", + "\n", + "[1060 rows x 6 columns]" ] }, - "execution_count": 14, + "execution_count": 80, "metadata": {}, "output_type": "execute_result" } @@ -1797,7 +1938,7 @@ "risk_traj.time_resolution = \"1M\"\n", "\n", "# We would have to divide results by 12 to get \"average monthly impacts\"\n", - "risk_traj.per_date_risk_metrics().head()" + "risk_traj.per_date_risk_metrics()" ] }, { @@ -1818,12 +1959,12 @@ "\n", "For convenience the module provides an `AllLinearStrategy` (the risk is linearly interpolated along all dimensions) and a `ExponentialExposureStrategy` (uses exponential interpolation along exposure, and linear for the two other dimensions).\n", "\n", - "This can prove helpfull if you are interpolating between two distant dates with an exponential growth factor for the exposure value. On the example below, we show the difference in risk estimates using an the two different interpolation strategy for the exposure dimension:" + "This can prove helpfull if you are interpolating between two distant dates with an exponential growth factor for the exposure value. On the example below, we show the difference in risk estimates using an the two different interpolation strategies for the exposure dimension:" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 42, "id": "c97e768e-bd4c-47d7-bace-96645f8b3bc4", "metadata": {}, "outputs": [ @@ -1831,10 +1972,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "2025-11-03 15:07:00,438 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2080/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2080.hdf5\n", - "2025-11-03 15:07:00,465 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", - "2025-11-03 15:07:00,466 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", - "2025-11-03 15:07:00,469 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n" + "2025-12-19 17:10:20,033 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2080/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2080.hdf5\n", + "2025-12-19 17:10:20,054 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2025-12-19 17:10:20,054 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", + "2025-12-19 17:10:20,057 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n" ] }, { @@ -1843,7 +1984,7 @@ "Text(0.5, 1.0, 'Comparison of average annual impact estimate for different interpolation approaches')" ] }, - "execution_count": 19, + "execution_count": 42, "metadata": {}, "output_type": "execute_result" }, @@ -1925,7 +2066,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 43, "id": "431d26f1-c19f-4654-814b-20e8a243848e", "metadata": {}, "outputs": [ @@ -1950,64 +2091,64 @@ " \n", " \n", " \n", - " group\n", " date\n", + " group\n", " measure\n", " metric\n", - " coord_id\n", " unit\n", + " coord_id\n", " risk\n", " \n", " \n", " \n", " \n", " 0\n", - " 1\n", " 2018\n", + " All\n", " no_measure\n", " eai\n", - " 0\n", " USD\n", + " 0\n", " 3515.056865\n", " \n", " \n", " 1\n", - " 1\n", " 2019\n", + " All\n", " no_measure\n", " eai\n", - " 0\n", " USD\n", + " 0\n", " 4668.296006\n", " \n", " \n", " 2\n", - " 1\n", " 2020\n", + " All\n", " no_measure\n", " eai\n", - " 0\n", " USD\n", + " 0\n", " 5861.455974\n", " \n", " \n", " 3\n", - " 1\n", " 2021\n", + " All\n", " no_measure\n", " eai\n", - " 0\n", " USD\n", + " 0\n", " 7094.788880\n", " \n", " \n", " 4\n", - " 1\n", " 2022\n", + " All\n", " no_measure\n", " eai\n", - " 0\n", " USD\n", + " 0\n", " 8368.546832\n", " \n", " \n", @@ -2022,52 +2163,52 @@ " \n", " \n", " 110302\n", - " 1\n", " 2096\n", + " All\n", " no_measure\n", " eai\n", - " 1328\n", " USD\n", + " 1328\n", " 100317.858444\n", " \n", " \n", " 110303\n", - " 1\n", " 2097\n", + " All\n", " no_measure\n", " eai\n", - " 1328\n", " USD\n", + " 1328\n", " 102579.412184\n", " \n", " \n", " 110304\n", - " 1\n", " 2098\n", + " All\n", " no_measure\n", " eai\n", - " 1328\n", " USD\n", + " 1328\n", " 104869.907377\n", " \n", " \n", " 110305\n", - " 1\n", " 2099\n", + " All\n", " no_measure\n", " eai\n", - " 1328\n", " USD\n", + " 1328\n", " 107189.486993\n", " \n", " \n", " 110306\n", - " 1\n", " 2100\n", + " All\n", " no_measure\n", " eai\n", - " 1328\n", " USD\n", + " 1328\n", " 109538.294005\n", " \n", " \n", @@ -2076,23 +2217,23 @@ "" ], "text/plain": [ - " group date measure metric coord_id unit risk\n", - "0 1 2018 no_measure eai 0 USD 3515.056865\n", - "1 1 2019 no_measure eai 0 USD 4668.296006\n", - "2 1 2020 no_measure eai 0 USD 5861.455974\n", - "3 1 2021 no_measure eai 0 USD 7094.788880\n", - "4 1 2022 no_measure eai 0 USD 8368.546832\n", - "... ... ... ... ... ... ... ...\n", - "110302 1 2096 no_measure eai 1328 USD 100317.858444\n", - "110303 1 2097 no_measure eai 1328 USD 102579.412184\n", - "110304 1 2098 no_measure eai 1328 USD 104869.907377\n", - "110305 1 2099 no_measure eai 1328 USD 107189.486993\n", - "110306 1 2100 no_measure eai 1328 USD 109538.294005\n", + " date group measure metric unit coord_id risk\n", + "0 2018 All no_measure eai USD 0 3515.056865\n", + "1 2019 All no_measure eai USD 0 4668.296006\n", + "2 2020 All no_measure eai USD 0 5861.455974\n", + "3 2021 All no_measure eai USD 0 7094.788880\n", + "4 2022 All no_measure eai USD 0 8368.546832\n", + "... ... ... ... ... ... ... ...\n", + "110302 2096 All no_measure eai USD 1328 100317.858444\n", + "110303 2097 All no_measure eai USD 1328 102579.412184\n", + "110304 2098 All no_measure eai USD 1328 104869.907377\n", + "110305 2099 All no_measure eai USD 1328 107189.486993\n", + "110306 2100 All no_measure eai USD 1328 109538.294005\n", "\n", "[110307 rows x 7 columns]" ] }, - "execution_count": 20, + "execution_count": 43, "metadata": {}, "output_type": "execute_result" } @@ -2104,15 +2245,15 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 57, "id": "61abb90f-42f8-446c-aa27-8a5b5eaa3729", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -2126,7 +2267,7 @@ "gdf[\"coord_id\"] = gdf.index\n", "gdf = gdf.merge(df, on=\"coord_id\")\n", "\n", - "fig, axs = plt.subplots(1, 3, figsize=(20, 4))\n", + "fig, axs = plt.subplots(1, 3, figsize=(24, 5))\n", "\n", "gdf.loc[gdf[\"date\"] == \"2018-01-01\"].plot(\n", " column=\"risk\",\n", From 08ebe0e87b05aca5e86ad084825c2330d5f8f04a Mon Sep 17 00:00:00 2001 From: spjuhel Date: Mon, 22 Dec 2025 13:45:19 +0100 Subject: [PATCH 30/61] Makes caching configurable --- climada/conf/climada.conf | 3 ++- climada/trajectories/calc_risk_metrics.py | 5 ++--- climada/trajectories/interpolated_trajectory.py | 10 +++++++--- 3 files changed, 11 insertions(+), 7 deletions(-) diff --git a/climada/conf/climada.conf b/climada/conf/climada.conf index 5fd35b1c42..d0573ff7a6 100644 --- a/climada/conf/climada.conf +++ b/climada/conf/climada.conf @@ -69,5 +69,6 @@ "cache_dir": "{local_data.system}/.apicache", "supported_hazard_types": ["river_flood", "tropical_cyclone", "storm_europe", "relative_cropyield", "wildfire", "earthquake", "flood", "hail", "aqueduct_coastal_flood"], "supported_exposures_types": ["litpop", "crop_production", "ssp_population", "crops"] - } + }, + "trajectory_caching": true } diff --git a/climada/trajectories/calc_risk_metrics.py b/climada/trajectories/calc_risk_metrics.py index 92131d71a1..ee2c6a3557 100644 --- a/climada/trajectories/calc_risk_metrics.py +++ b/climada/trajectories/calc_risk_metrics.py @@ -64,6 +64,7 @@ linear_interp_arrays, ) from climada.trajectories.snapshot import Snapshot +from climada.util.config import CONFIG LOGGER = logging.getLogger(__name__) @@ -76,8 +77,6 @@ "calc_freq_curve", ] -_CACHE_SETTINGS = {"ENABLE_LAZY_CACHE": False} - def lazy_property(method): # This function is used as a decorator for properties @@ -89,7 +88,7 @@ def lazy_property(method): @property def _lazy(self): - if not _CACHE_SETTINGS.get("ENABLE_LAZY_CACHE", True): + if not CONFIG.trajectory_caching.bool(): return method(self) if getattr(self, attr_name) is None: diff --git a/climada/trajectories/interpolated_trajectory.py b/climada/trajectories/interpolated_trajectory.py index 114e3ce655..10eb38272d 100644 --- a/climada/trajectories/interpolated_trajectory.py +++ b/climada/trajectories/interpolated_trajectory.py @@ -72,6 +72,7 @@ RiskTrajectory, ) from climada.util import log_level +from climada.util.config import CONFIG from climada.util.dataframe_handling import reorder_dataframe_columns LOGGER = logging.getLogger(__name__) @@ -378,9 +379,12 @@ def _generic_metrics( tmp = self.npv_transform(tmp, self._risk_disc_rates) tmp = reorder_dataframe_columns(tmp, DEFAULT_DF_COLUMN_PRIORITY) - LOGGER.debug("All computing done, caching value.") - setattr(self, attr_name, tmp) - return getattr(self, attr_name) + if CONFIG.trajectory_caching.bool(): + LOGGER.debug("All computing done, caching value.") + setattr(self, attr_name, tmp) + return getattr(self, attr_name) + else: + return tmp def _compute_period_metrics( self, metric_name: str, metric_meth: str, **kwargs From ed8ed0ffc666daa90eb9a340551d45170e7f69a4 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Mon, 22 Dec 2025 13:45:52 +0100 Subject: [PATCH 31/61] Fixes legend colors for non always negative contributions --- .../trajectories/interpolated_trajectory.py | 23 ++++++++++++++++--- 1 file changed, 20 insertions(+), 3 deletions(-) diff --git a/climada/trajectories/interpolated_trajectory.py b/climada/trajectories/interpolated_trajectory.py index 10eb38272d..af194ec01b 100644 --- a/climada/trajectories/interpolated_trajectory.py +++ b/climada/trajectories/interpolated_trajectory.py @@ -753,26 +753,43 @@ def plot_time_waterfall( risk_contribution[risk_contribution < 0].dropna(how="all", axis=1).fillna(0) ) # + base_risk.iloc[0] + color_index = { + CONTRIBUTION_EXPOSURE_NAME: 1, + CONTRIBUTION_HAZARD_NAME: 2, + CONTRIBUTION_VULNERABILITY_NAME: 3, + CONTRIBUTION_INTERACTION_TERM_NAME: 4, + } + csequence = mpl.color_sequences["tab10"] ax.stackplot( positive_contrib.index.to_timestamp(), # type: ignore [positive_contrib[col] for col in positive_contrib.columns], labels=positive_contrib.columns, - colors=mpl.color_sequences["tab10"][1:], + colors=[csequence[color_index[col]] for col in positive_contrib.columns], ) if not (negative_contrib.empty): ax.stackplot( negative_contrib.index.to_timestamp(), # type: ignore [negative_contrib[col] for col in negative_contrib.columns], labels=negative_contrib.columns, - colors=mpl.color_sequences["tab10"][3:], + colors=[ + csequence[color_index[col]] for col in negative_contrib.columns + ], ) - ax.legend() + handles, labels = plt.gca().get_legend_handles_labels() + newLabels, newHandles = [], [] + for handle, label in zip(handles, labels): + if label not in newLabels: + newLabels.append(label) + newHandles.append(handle) + + ax.legend(newHandles, newLabels) value_label = "Deviation from base risk" title_label = f"Contributions to change in risk between {self.start_date} and {self.end_date} (Average)" locator = mdates.AutoDateLocator() formatter = mdates.ConciseDateFormatter(locator) + ax.axhline(y=0, linestyle="--", color="black", linewidth=2) ax.xaxis.set_major_locator(locator) ax.xaxis.set_major_formatter(formatter) ax.yaxis.set_major_formatter(mticker.EngFormatter()) From ad941d847239e0d9f3824fb01313639a3177bf25 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Mon, 22 Dec 2025 13:54:18 +0100 Subject: [PATCH 32/61] clean Notebook --- doc/user-guide/climada_trajectories.ipynb | 1431 ++++++--------------- 1 file changed, 420 insertions(+), 1011 deletions(-) diff --git a/doc/user-guide/climada_trajectories.ipynb b/doc/user-guide/climada_trajectories.ipynb index caca6591e6..f222cd7c93 100644 --- a/doc/user-guide/climada_trajectories.ipynb +++ b/doc/user-guide/climada_trajectories.ipynb @@ -1,15 +1,5 @@ { "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "63d1b536-a7bf-4aff-812c-57f9a06c9856", - "metadata": {}, - "outputs": [], - "source": [ - "%autoreload 2" - ] - }, { "cell_type": "markdown", "id": "856ac388-9edb-497e-a2ff-a325f2a22562", @@ -125,21 +115,10 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": null, "id": "dec203d1-943f-41d8-9542-009f288b937b", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2025-12-19 17:28:13,750 - climada.entity.exposures.base - INFO - Reading /home/sjuhel/climada/data/exposures/litpop/LitPop_150arcsec_HTI/v3/LitPop_150arcsec_HTI.hdf5\n", - "2025-12-19 17:28:19,358 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020/v2/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020.hdf5\n", - "2025-12-19 17:28:19,380 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", - "2025-12-19 17:28:19,383 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n" - ] - } - ], + "outputs": [], "source": [ "from climada.util.api_client import Client\n", "from climada.entity import ImpactFuncSet, ImpfTropCyclone\n", @@ -157,13 +136,12 @@ " \"nb_synth_tracks\": \"10\",\n", " },\n", ")\n", - "exp_present.assign_centroids(haz_present, distance=\"approx\")\n", "\n", "impf_set = ImpactFuncSet([ImpfTropCyclone.from_emanuel_usa()])\n", "exp_present.gdf.rename(columns={\"impf_\": \"impf_TC\"}, inplace=True)\n", "exp_present.gdf[\"impf_TC\"] = 1\n", "\n", - "snap = Snapshot(exposure=exp_present, hazard=haz_present, impfset=impf_set, date=2018)" + "snap1 = Snapshot(exposure=exp_present, hazard=haz_present, impfset=impf_set, date=2018)" ] }, { @@ -176,33 +154,17 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": null, "id": "aa0becca-d334-40b4-86c0-1959c750f6d5", "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2025-12-19 17:28:19,415 - climada.util.coordinates - INFO - Raster from resolution 0.04166665999999708 to 0.04166665999999708.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/sjuhel/Repos/climada_python/climada/util/coordinates.py:3130: FutureWarning: The `drop` keyword argument is deprecated and in future the only supported behaviour will match drop=False. To silence this warning and adopt the future behaviour, stop providing `drop` as a keyword to `set_geometry`. To replicate the `drop=True` behaviour you should update your code to\n", - "`geo_col_name = gdf.active_geometry_name; gdf.set_geometry(new_geo_col).drop(columns=geo_col_name).rename_geometry(geo_col_name)`.\n", - " df_poly.set_geometry(\n" - ] - }, { "data": { "text/plain": [ "" ] }, - "execution_count": 62, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" }, @@ -238,9 +200,9 @@ } ], "source": [ - "snap.exposure.plot_raster()\n", - "snap.hazard.plot_intensity(0)\n", - "snap.impfset.plot()" + "snap1.exposure.plot_raster()\n", + "snap1.hazard.plot_intensity(0)\n", + "snap1.impfset.plot()" ] }, { @@ -267,21 +229,10 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": null, "id": "c516c861-c5c1-475b-82e2-c867c5c08ec9", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2025-12-19 17:28:25,975 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2040/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2040.hdf5\n", - "2025-12-19 17:28:25,996 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", - "2025-12-19 17:28:25,996 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", - "2025-12-19 17:28:25,999 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n" - ] - } - ], + "outputs": [], "source": [ "import copy\n", "\n", @@ -302,7 +253,7 @@ " \"nb_synth_tracks\": \"10\",\n", " },\n", ")\n", - "exp_future.assign_centroids(haz_future, distance=\"approx\")\n", + "\n", "impf_set = ImpactFuncSet(\n", " [\n", " ImpfTropCyclone.from_emanuel_usa(v_half=78.0),\n", @@ -313,7 +264,7 @@ "snap2 = Snapshot(exposure=exp_future, hazard=haz_future, impfset=impf_set, date=2040)\n", "\n", "# Now we can define a list of two snapshots, present and future:\n", - "snapcol = [snap, snap2]" + "snapcol = [snap1, snap2]" ] }, { @@ -326,7 +277,7 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": null, "id": "e782ab8b", "metadata": { "editable": true, @@ -345,7 +296,7 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": null, "id": "483767e7-9089-4b5e-a307-514ac302e773", "metadata": { "editable": true, @@ -356,22 +307,7 @@ "remove-input" ] }, - "outputs": [ - { - "data": { - "text/html": [ - "\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "%%html\n", "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
dategroupmeasuremetricunitrisk
02018Allno_measureaaiUSD1.840432e+08
12023Allno_measureaaiUSD2.083634e+08
22028Allno_measureaaiUSD2.317103e+08
32033Allno_measureaaiUSD2.539452e+08
42038Allno_measureaaiUSD2.749295e+08
\n", - "" - ], - "text/plain": [ - " date group measure metric unit risk\n", - "0 2018 All no_measure aai USD 1.840432e+08\n", - "1 2023 All no_measure aai USD 2.083634e+08\n", - "2 2028 All no_measure aai USD 2.317103e+08\n", - "3 2033 All no_measure aai USD 2.539452e+08\n", - "4 2038 All no_measure aai USD 2.749295e+08" - ] - }, - "execution_count": 78, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "snapcol = [snap, snap2]\n", - "risk_traj = InterpolatedRiskTrajectory(snapcol, time_resolution=\"5Y\")\n", - "risk_traj.per_date_risk_metrics().head()" + "## Higher number of snapshots" ] }, { - "cell_type": "code", - "execution_count": 80, - "id": "c1e66906-63e3-4a29-8a0b-0e706e6a2a09", + "cell_type": "markdown", + "id": "6db14802-fa35-4e33-91ef-7dddd4d43da7", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2025-12-19 17:29:33,001 - climada.trajectories.calc_risk_metrics - WARNING - No group id defined in at least one of the Exposures object. Per group aai will be empty.\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
dategroupmeasuremetricunitrisk
02018-01Allno_measureaaiUSD1.840432e+08
12018-02Allno_measureaaiUSD1.844183e+08
22018-03Allno_measureaaiUSD1.847932e+08
32018-04Allno_measureaaiUSD1.851679e+08
42018-05Allno_measureaaiUSD1.855424e+08
.....................
10552039-09Allno_measurerp_100USD8.440435e+09
10562039-10Allno_measurerp_100USD8.449624e+09
10572039-11Allno_measurerp_100USD8.458802e+09
10582039-12Allno_measurerp_100USD8.467969e+09
10592040-01Allno_measurerp_100USD8.477125e+09
\n", - "

1060 rows × 6 columns

\n", - "
" - ], - "text/plain": [ - " date group measure metric unit risk\n", - "0 2018-01 All no_measure aai USD 1.840432e+08\n", - "1 2018-02 All no_measure aai USD 1.844183e+08\n", - "2 2018-03 All no_measure aai USD 1.847932e+08\n", - "3 2018-04 All no_measure aai USD 1.851679e+08\n", - "4 2018-05 All no_measure aai USD 1.855424e+08\n", - "... ... ... ... ... ... ...\n", - "1055 2039-09 All no_measure rp_100 USD 8.440435e+09\n", - "1056 2039-10 All no_measure rp_100 USD 8.449624e+09\n", - "1057 2039-11 All no_measure rp_100 USD 8.458802e+09\n", - "1058 2039-12 All no_measure rp_100 USD 8.467969e+09\n", - "1059 2040-01 All no_measure rp_100 USD 8.477125e+09\n", - "\n", - "[1060 rows x 6 columns]" - ] - }, - "execution_count": 80, - "metadata": {}, - "output_type": "execute_result" - } - ], + "source": [ + "You can of course use the module to evaluate more that two snapshots. With the `StaticRiskTrajectory` you will get a collection of results for each snapshot.\n", + "\n", + "For the `InterpolatedRiskTrajectory` the interpolation will be done between each pair of consecutive snapshots and all results will be collected together, this is usefull if you want to explore a trajectory for which you have clear \"intermediate points\", for instance if you are evaluating the risk in an area for which you know some specific development projects will start at a certain date.\n", + "\n", + "Below is an example featuring three snapshots:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d93eb82b-65d2-48fe-a195-6cb12f23bf47", + "metadata": {}, + "outputs": [], + "source": [ + "from climada.engine.impact_calc import ImpactCalc\n", + "from climada.util.api_client import Client\n", + "from climada.entity import ImpactFuncSet, ImpfTropCyclone\n", + "from climada.trajectories.snapshot import Snapshot\n", + "from climada.trajectories import InterpolatedRiskTrajectory\n", + "import copy\n", + "\n", + "client = Client()\n", + "\n", + "\n", + "future_years = [2040, 2060, 2080]\n", + "\n", + "exp_present = client.get_litpop(country=\"Haiti\")\n", + "haz_present = client.get_hazard(\n", + " \"tropical_cyclone\",\n", + " properties={\n", + " \"country_name\": \"Haiti\",\n", + " \"climate_scenario\": \"historical\",\n", + " \"nb_synth_tracks\": \"10\",\n", + " },\n", + ")\n", + "\n", + "impf_set = ImpactFuncSet([ImpfTropCyclone.from_emanuel_usa()])\n", + "exp_present.gdf.rename(columns={\"impf_\": \"impf_TC\"}, inplace=True)\n", + "exp_present.gdf[\"impf_TC\"] = 1\n", + "exp_present.gdf[\"group_id\"] = (exp_present.gdf[\"value\"] > 500000) * 1\n", + "\n", + "snapcol = [\n", + " Snapshot(exposure=exp_present, hazard=haz_present, impfset=impf_set, date=2018)\n", + "]\n", + "\n", + "for year in future_years:\n", + " exp_future = copy.deepcopy(exp_present)\n", + " exp_future.ref_year = year\n", + " n_years = exp_future.ref_year - exp_present.ref_year + 1\n", + " growth_rate = 1.02\n", + " growth = growth_rate**n_years\n", + " exp_future.gdf[\"value\"] = exp_future.gdf[\"value\"] * growth\n", + "\n", + " haz_future = client.get_hazard(\n", + " \"tropical_cyclone\",\n", + " properties={\n", + " \"country_name\": \"Haiti\",\n", + " \"climate_scenario\": \"rcp60\",\n", + " \"ref_year\": str(year),\n", + " \"nb_synth_tracks\": \"10\",\n", + " },\n", + " )\n", + " impf_set = ImpactFuncSet(\n", + " [\n", + " ImpfTropCyclone.from_emanuel_usa(v_half=78.0),\n", + " ]\n", + " )\n", + " exp_future.gdf.rename(columns={\"impf_\": \"impf_TC\"}, inplace=True)\n", + " exp_future.gdf[\"impf_TC\"] = 1\n", + " snapcol.append(\n", + " Snapshot(exposure=exp_future, hazard=haz_future, impfset=impf_set, date=year)\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b85d5b95-4316-481a-9eed-86977647b791", + "metadata": {}, + "outputs": [], + "source": [ + "risk_traj = InterpolatedRiskTrajectory(snapcol)" + ] + }, + { + "cell_type": "markdown", + "id": "537a9dd8-96e9-4ef4-a137-358990c658d2", + "metadata": {}, + "source": [ + "The \"static\" waterfall plot shows the evolution of risk between the earliest and latest snapshot." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1c5aeb4b-6320-479d-82a6-9b2c3901868e", + "metadata": {}, + "outputs": [], + "source": [ + "risk_traj.plot_waterfall()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "16faf81c-8760-4c02-a575-ae033bcb637d", + "metadata": {}, + "outputs": [], + "source": [ + "risk_traj.plot_time_waterfall()" + ] + }, + { + "cell_type": "markdown", + "id": "fed22016-ab8f-4761-892a-c893d18357b7", + "metadata": {}, + "source": [ + "## Non-default return periods" + ] + }, + { + "cell_type": "markdown", + "id": "fcaed625-82a8-4cc4-82de-e36b67601dcb", + "metadata": {}, + "source": [ + "You can easily change the default return periods computed, either at initialisation time, or via the property `return_periods`.\n", + "Note that estimates of impacts for specific return periods are highly dependant on the data you provided.\n", + "\n", + "**We cannot check if the event set you provide is fit for computing impacts for a specific return period.** " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0ade93f9-c43a-4e8a-8225-9343bbbb3615", + "metadata": {}, + "outputs": [], + "source": [ + "snapcol = [snap1, snap2]\n", + "risk_traj = InterpolatedRiskTrajectory(snapcol, return_periods=[10, 15, 20, 30])\n", + "display(risk_traj.return_periods_metrics())\n", + "\n", + "risk_traj.return_periods = [150, 250, 500]\n", + "display(risk_traj.return_periods_metrics())" + ] + }, + { + "cell_type": "markdown", + "id": "39059ec5-9125-4cfc-b8c6-e6327d8b98cc", + "metadata": {}, + "source": [ + "## Non-yearly date index" + ] + }, + { + "cell_type": "markdown", + "id": "4f8f83d6-a45d-4d3b-b25d-d3294e6e1955", + "metadata": {}, + "source": [ + "You can use any valid pandas [frequency string for periods](https://pandas.pydata.org/docs/user_guide/timeseries.html#period-aliases) for the time resolution,\n", + "for instance \"5Y\" for every five years. This reduces the resolution of the interpolation, which can reduce the required computations at the cost of \"precision\".\n", + "Conversely you can also increase the time resolution to a monthly base for instance.\n", + "\n", + "Same as for the return periods, you can change that at initialisation or afterward via the property.\n", + "\n", + "Keep in mind that risk metrics are still computed the same way, so if you initialy had hazards with annual frequency values, you would still have \"Average Annual Impacts\" values for every months and not average monthly ones!\n", + "\n", + "Also note that `InterpolatedRiskTrajectory` uses `PeriodIndex` for the time dimension. These indexes are defined with the dates of the first and last snapshot, and the given time resolution.\n", + "\n", + "This means that an `InterpolatedRiskTrajectory` for a 2020 `Snapshot` and 2040 `Snapshot` with a yearly time resolution will include all years from 2020 to 2040 included (11 years in total).\n", + "\n", + "However, a trajectory with the same snapshots with a monthly resolution will have January 2040 as a last period if you only provided year 2040 for the last date. If you want to include the whole 2040 year, you need to explicitly give the date \"2040-12-31\" to the last snapshot." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "128fac77-e077-4241-a003-a60c4afcad74", + "metadata": {}, + "outputs": [], + "source": [ + "snapcol = [snap1, snap2]\n", + "risk_traj = InterpolatedRiskTrajectory(snapcol, time_resolution=\"5Y\")\n", + "risk_traj.per_date_risk_metrics().head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c1e66906-63e3-4a29-8a0b-0e706e6a2a09", + "metadata": {}, + "outputs": [], "source": [ "# snapcol = [snap, snap2]\n", "\n", @@ -1964,41 +1496,10 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": null, "id": "c97e768e-bd4c-47d7-bace-96645f8b3bc4", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2025-12-19 17:10:20,033 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2080/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2080.hdf5\n", - "2025-12-19 17:10:20,054 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", - "2025-12-19 17:10:20,054 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n", - "2025-12-19 17:10:20,057 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n" - ] - }, - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Comparison of average annual impact estimate for different interpolation approaches')" - ] - }, - "execution_count": 42, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from climada.trajectories import StaticRiskTrajectory, InterpolatedRiskTrajectory\n", "from climada.trajectories import ExponentialExposureStrategy\n", @@ -2021,7 +1522,6 @@ " \"nb_synth_tracks\": \"10\",\n", " },\n", ")\n", - "exp_future.assign_centroids(haz_future, distance=\"approx\")\n", "impf_set = ImpactFuncSet(\n", " [\n", " ImpfTropCyclone.from_emanuel_usa(v_half=60.0),\n", @@ -2031,7 +1531,7 @@ "exp_future.gdf[\"impf_TC\"] = 1\n", "\n", "snap2 = Snapshot(exposure=exp_future, hazard=haz_future, impfset=impf_set, date=2100)\n", - "snapcol = [snap, snap2]\n", + "snapcol = [snap1, snap2]\n", "\n", "exp_interp = ExponentialExposureStrategy()\n", "risk_traj = InterpolatedRiskTrajectory(snapcol)\n", @@ -2066,178 +1566,10 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": null, "id": "431d26f1-c19f-4654-814b-20e8a243848e", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
dategroupmeasuremetricunitcoord_idrisk
02018Allno_measureeaiUSD03515.056865
12019Allno_measureeaiUSD04668.296006
22020Allno_measureeaiUSD05861.455974
32021Allno_measureeaiUSD07094.788880
42022Allno_measureeaiUSD08368.546832
........................
1103022096Allno_measureeaiUSD1328100317.858444
1103032097Allno_measureeaiUSD1328102579.412184
1103042098Allno_measureeaiUSD1328104869.907377
1103052099Allno_measureeaiUSD1328107189.486993
1103062100Allno_measureeaiUSD1328109538.294005
\n", - "

110307 rows × 7 columns

\n", - "
" - ], - "text/plain": [ - " date group measure metric unit coord_id risk\n", - "0 2018 All no_measure eai USD 0 3515.056865\n", - "1 2019 All no_measure eai USD 0 4668.296006\n", - "2 2020 All no_measure eai USD 0 5861.455974\n", - "3 2021 All no_measure eai USD 0 7094.788880\n", - "4 2022 All no_measure eai USD 0 8368.546832\n", - "... ... ... ... ... ... ... ...\n", - "110302 2096 All no_measure eai USD 1328 100317.858444\n", - "110303 2097 All no_measure eai USD 1328 102579.412184\n", - "110304 2098 All no_measure eai USD 1328 104869.907377\n", - "110305 2099 All no_measure eai USD 1328 107189.486993\n", - "110306 2100 All no_measure eai USD 1328 109538.294005\n", - "\n", - "[110307 rows x 7 columns]" - ] - }, - "execution_count": 43, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "df = risk_traj.eai_metrics()\n", "df" @@ -2245,25 +1577,14 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": null, "id": "61abb90f-42f8-446c-aa27-8a5b5eaa3729", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAB2oAAAGkCAYAAADwj6VkAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Qd4U2UXB/B/0r2hQJll77333lNAHDgYigNFBf1wAgoOQEVFRUAUQRyACgIKsvfee+9VRqF0zyTfc96S0AkdaTPu/+dzpb1Nbm5v0+bknPc9r85kMplARERERERERERERERERET5Rp9/D0VERERERERERERERERERIKFWiIiIiIiIiIiIiIiIiKifMZCLRERERERERERERERERFRPmOhloiIiIiIiIiIiIiIiIgon7FQS0RERERERERERERERESUz1ioJSIiIiIiIiIiIiIiIiLKZyzUEhERERERERERERERERHlMxZqiYiIiIiIiIiIiIiIiIjyGQu1RERERERERERERERERET5jIVaIiIiIiIiIiIiIiIiIqJ8xkItERERpbJx40b06tULJUqUgE6nw6JFi7J9hf744w/UrVsX3t7eKFOmDD7//HNeZSIiIiInxhiSiIiIiBg/Zh8LtURERJRKdHQ06tSpgylTpuToyvz333946qmnMHToUBw+fBhTp07Fl19+mePjEREREZH9YwxJRERERIwfs09nMplMObgfERERaYDMqP3777/Rp08fy76EhASMHj0av/32G+7cuYOaNWvi008/Rdu2bdXXn3zySSQmJuLPP/+03Gfy5Mn44osvcPHiRXVMIiIiInJejCGJiIiIiPFj1nBGLREREWXLM888gy1btmDevHk4ePAgHn30UXTt2hWnTp1SX4+Pj4enp2eq+3h5eeHy5cu4cOECrzYRERGRBjGGJCIiIiLGj+mxUEtERERZdubMGcydO1fNlm3VqhUqVKiAkSNHomXLlpg1a5a6TZcuXbBw4UKsWbMGRqMRJ0+eVDNqRUhICK82ERERkcYwhiQiIiIixo8Zc81kPxEREVE6e/fuhayaULly5VT7ZRZtoUKF1MfPP/+8Ssb17NlTtUD29/fH8OHDMXbsWLi4uPCqEhEREWkMY0giIiIiYvyYMRZqiYiIKMtkhqwUW/fs2ZOu6Orr62tZk0zWrB0/fjyuXbuGIkWKqNm1omzZsrzaRERERBrDGJKIiIiIGD9mjIVaIiIiyrJ69erBYDDgxo0bqvXx/Ught2TJkupjaZfcrFkzBAUF8WoTERERaQxjSCIiIiJi/JgxFmqJiIgolaioKJw+fdry+blz57B//34EBgaqlsdPPfUUBg4ciC+++EIl3UJDQ7F27VrUqlUL3bt3V5//9ddfaNu2LeLi4tTatbKm7YYNG3iliYiIiJwUY0giIiIiYvyYfTqTLDRHREREdNf69evRrl27dNdj0KBBmD17tlp39uOPP8acOXNw5coVtTatzJYdN26cKtZKobZXr144dOiQWs9WvvbJJ5+gSZMmvMZERERETooxJBERERExfsw+FmqJiIiIiIiIiIiIiIiIiPKZPr8fkIiIiIiIiIiIiIiIiIhI61ioJSIiIiIiIiIiIiIiIiLKZ675/YBERETkmOLi4pCQkGCVY7m7u8PT09MqxyIiIiIi+8T4kYiIiIgYQ94fC7VERESUpSRbuTK+uHbDYJWrVaxYMZw7d47FWiIiIiInxfiRiIiIiBhDPhgLtURERPRAMpNWirQX9pSFv1/uVk6IiDSiTIPz6picVUtERETknBg/EhERERFjyAdjoZaIiIiyzNdPp7bcMCJ39yciIiIix8H4kYiIiIgYQ2aOhVoiIiLKMoPJCIMp98cgIiIiIm1g/EhEREREjCEzl7vehURERERERERERERERERElG2cUUtERERZZoRJbbmR2/sTERERkeNg/EhEREREjCEzx0ItERERZZlR/Zc7uT8CERERETkKxo9ERERExBgyc2x9TERERERERERERERERESUzzijloiIiLLMYDKpLTdye38iIiIichyMH4mIiIiIMWTmOKOW7MI333wDnU6HmjVr2vpU7Fr9+vXVdZo0aRIc2eDBg1G2bNks3U6+X/Pm7u6OChUqYOTIkYiIiEh3e7nN2LFjs30uvr6+yAl5LHlMawkJCcHo0aPRrFkzFC5cGP7+/mjQoAFmzJgBg8GQ7vZRUVEYMWIESpQoAU9PT9StWxfz5s1Ld7vNmzfjueeeU8fy8PBQ53z+/PkMz+HatWt45ZVXUL58eXh5eaFMmTIYMmQILl68aLXvk5xjjbHcbkRE1sAYMmsYQzKGzEkMmTYWN29Vq1bN8Hn27bffqq9JvFmuXDmMGzcOiYmJOfrdJufC+JGI7Anjx6xh/Mj40SwyMhJvvfUWOnfujCJFijww/7p371507NhR5VsLFCiAhx9+GGfPns3wtowf6X6MGspBslBLduGnn35S/x45cgQ7duyw9enYpf3792Pfvn3q45kzZ0IrpFi4bds2tS1ZsgTt2rXDF198gUceeSTdbeU2UpDML/JY8pjWsmfPHsyZMwcdOnRQ/y5YsABt2rTBSy+9hOeffz7d7SXQ+fnnn/HBBx/gv//+Q6NGjfDEE0/g999/T3W7NWvWYPXq1ShdujSaN2+e6ePHx8ejdevWmD9/viqGyzHfe+89LF26VN1PAjMiIiJ7whjywRhDMobMaQyZNhY3bxIrpvXJJ59g+PDh6tgrVqzAyy+/jPHjx2PYsGE5/v0mIiLKC4wfH4zxI+PHlG7duqUmkUjesE+fPvd97hw/fhxt27ZFQkIC/vjjD/X7dvLkSbRq1Qo3b95MdVvGj0QpmIhsbNeuXTKswdSjRw/17/PPP5/v52A0Gk0xMTEmezZs2LBU12nLli0mRzVo0CBTmTJlsnQ7Hx+fdPvbtWunrsHZs2etci4ZPYYt3L5925SQkJDpz/7ixYuWfUuXLlX7fv/991S37dSpk6lEiRKmpKQkyz6DwWD5+PPPP1f3O3fuXLrHWbVqlfrajz/+mGq/PIbsX7hwYa6/R3Jc4eHhyc+d48VNoVdK5mqTY8ix5JhERDnFGDJrGEPewxgyezFkVuPk0NBQk6enp+mFF15Itf+TTz4x6XQ605EjR7L4bCVnw/iRiOwN48esYfx4D+PH5Ly5bOLmzZsqlvzggw8yfO48+uijpsKFC6fK95w/f97k5uZmeuuttyz7GD/S/YRrMAfJGbVkc+bZoRMnTlSz9qTtVkxMjNonrbKCgoIwYMCAdPe7c+eOGuH9xhtvWPZJO1yZCSittqRNbsmSJVVbr+jo6FT3lRYN0t51+vTpqFatmmrPJaPKhbToatKkCQIDA1XrWWn1IedoSrOmoowi+t///odixYrB29tbzUSUGZHS0lfahKVtJ/viiy+iVKlS6rzMrcCSkpKydI3i4uLUCHdpXfvVV1+lGgGYUStemZkso+IDAgJQtGhRPPvsswgPD8/wGvzyyy/qGsj3UKdOHfz7779ZalOcUdvf7777Tl0H+Zn5+PigVq1a+Oyzz6ze8qxhw4bq3+vXr6f7nlK23pDnkfn5IG3d5Gcq9507d+59j79lyxbVerhnz57pnjsPugZyreR+y5cvV88deY5KC7iMfl5pFSxYEG5ubun2N27cWP17+fJly76///5btRB59NFHU932mWeewdWrV1PNTNfrs/an3vzY8rxJSdqUCLmGRFpqO0JE9o0x5IMxhkyNMWT2YsiskrhXnmtyjLTHlPdQixYtyvYxybkwfiQie8H48cEYP6bG+DE535qVpd8kzy155X79+qmcupksqyYdEiUONWP8SFlh1FAO0tXWJ0DaFhsbq4pm0m5L1qeVgqK0k/3zzz8xaNAgVTh6+umnVUFVioAp/8jL/VImBKQoJ21ipZgl7Vpr166tCpbvv/8+Dh06pFq/pnxRkYTBpk2b1Nel2CrFRSFrd0pRVdrEiu3bt+PVV1/FlStX1G3N5HGl7Zf06G/fvj2OHj2Kvn37pls7VYq0UmiTYpncX9ZYlZZhH3/8sXqsWbNmPfA6LVy4EGFhYer6VKpUCS1btlSPPXny5AzXV5UXxMcff1ytLSrf+7vvvqv2py0WSkvbXbt24cMPP1THkaKqfA8nTpxQa5Rm15kzZ/Dkk09aCuUHDhxQbSyk7UVWCpVZde7cObi6uj7wHKWIL4Voudb16tVTRdfDhw+rlh2ZkbYcAwcOVNda1klwcXHJ9vnJ9y1F/HfeeUcVyn/88Uf1s6hYsaIqZGfX2rVr1fdbuXJlyz75PqTALvtTkue9+ev3a3OckRYtWqjBAFKAliBKji/tSeT3SYrOsr4EERGRPWAMyRgyJxhDZj+GlN81ea8kreqKFy+u2t3JewcZAGkm9xEySDMlub0MfjR/nYiIyJYYPzJ+zAnGj9nLC8vvmTmuTEn2rVq1SuXyZSII40eiNGw9pZe0bc6cOWrq+fTp09XnkZGRJl9fX1OrVq0stzl48KC6zYwZM1Ldt3HjxqYGDRpYPp8wYYJJr9erNiYp/fXXX+r+y5Yts+yTzwMCAlSr2fuRlrGJiYmmDz/80FSoUCFLmwdp3yXHePvtt1Pdfu7cuWq/tAkze/HFF9X3dOHChVS3nTRpkrptVlqBtW/fXrUTCwsLU5/PmjVL3XfmzJmpbidtJ2T/Z599lmr/yy+/rO5vPn/zNShatKgpIiLCsu/atWvqGsq1fFCbYvNjPejayc/YxcUl1bXObutjOY5s0hZj2rRp6hzfe++9dLdP23qjZs2apj59+mTpMcTEiRPVuX766aemrMjoGsj3Jdc65c87NjbWFBgYqJ4L2bVixQr1/b7++uup9leqVMnUpUuXdLe/evWqOqfx48dneLz7tT4W8nzo1auXuo15a9u2renWrVvZPndyzrYjJ48VNYVcLp6rTY7hCG1HiMh+MYZkDHk/jCGtE0N++eWXalu5cqXaRo0aZfL29jZVrVpVvW8zk6VrPDw8MvxZVK5c2dS5c+cc/JaTM2D8SET2hPEj48f7YfyYefyY0v1aH8syffI1yY+nJTGmfE1iTsH4ke4nXIM5SLY+Jpu3HJHWsP3791efm9twyUzXU6dOWUZmyyy/lDNPjx07hp07d6pZj2bSWkFm5datW1e1WjBvXbp0UTNp169fn+qxZRastJrNaPaizByU9q8ym1Jm9cpMWJmFeePGDXWbDRs2qH8fe+yxVPd95JFH0o1Ol/OS9g4lSpRIdV7dunVLdaz7jdxat24dHn74YUsLWrlGfn5+mc5Sfeihh9KNWpIRS+bzN5PzkuOYyexPmVl84cIF5MS+ffvUYxcqVMhy7WR2qsFgUDMzc0JmwcpxZJMR+S+99JKaLSwzdR9EZjL/999/amar/PxlVFdGpMYrs6g/+OAD1WJaZknnhjwHzTOyhYwUk9mw2b2ue/fuVc+xpk2bYsKECem+fr+2I1lpSZKWtKiWa7t//3788MMP2Lhxo2oJLrPJO3XqlK59NmmT0UobEVFuMIZkDPkgjCFzH0O+/vrrapM4UDbpUjNnzhzVLUdixZwck7SJ8SMR2QPGj4wfH4TxY+bxY3ZkNS5k/EgPYtRQDpKFWrKZ06dPq0JQjx49VKFM1pyVTYqdImURUgqy0i5YkgJCirayrqysw2om65UePHjQUtQzb1KIlOOHhoama8WVlhR/O3furD6W5IOsVSqtgUeNGqX2mQt95ta5UthMSYq0UqRMSc7rn3/+SXdeNWrUUF9Pe15pyXWQ85frYr5GUlCTgqicn/mapJT2HORapTz/zG5nvm1mBc37uXjxIlq1aqWKel9//bUqtsu1k5bVGT12VkkhX44jm1zHtm3bqrbXsqbxg3zzzTd4++23VZtrKUpLizZp12YeBGCWkJCgWknLz8RcQM8Na1xXKXpLQkxaXS9btszyM0z5GBm1cL59+7b6N2U7uuy8aZHCtrTalhbk8vOUQrusGyFFY2m1TUREZGuMIRlDZgVjyLyJIWWZFB8fH7U8TMpjyqBQWYomo+PmJC4lIiKyJsaPjB+zgvFjxvFjdvOhmcWaUpg1T0Ji/EiUGteoJZsxFyD/+usvtaUlM/lk1LbMzJSCrKw3Onv2bDWTUtYdlYJbyhmxMttSXlAzm2UqX08po1E78+bNU0VUmQUrsyDNpNCX0QuPFGFLlixp2S8zZdO+GMnjyozWzGaAykzbzBiNRvU9C5lRmxH5fmVt2bwi1yE+Pj7d/rQFZrlGMvJMinyyvqmZzM7MDVnbt2HDhpbPpXgpM6zHjRuHp556CsHBwZneV5JIcjvZ5Gdlnl3bq1evVAVuCUBk1rLMvpbZ1FKYzGi2dX6RIq2ch1zHlStXqtndaclMcylYy3Mu5SxuWZNYyOzy7JKflfy+yXq0KclawPKc5/piJAwwqS03cnt/ItI2xpDJGEPeH2PIvIsh5T2cXN+UxzQfo0mTJpb9165dU+8ZchKXknNh/EhEtsb4MRnjx/tj/Jhx/JhVFSpUULl5c1yZkuyrWLGiJd/O+JGywqChHCRn1JJNSCtcKcTKH3ApkKXd/ve//yEkJEQV1oQUzaQwK622pIgqb/pTtj0WPXv2VIuWS0FJCntpt7Jlyz7wvKR4KwkLKVaZySxIKQyn1Lp1a/WvzMJMSQrOkvRIe15S4JLvNaPzul+QtGLFCly+fBnDhg3L8DrJDFC5Jmkf05rkuknLZCl0ppyBKueWUeE75agrSeKkbYuWW3J8maUro/alkJ9VMvt58ODBquh/4sSJdCP+69Wrp9pQy/WWWbtp20TnFymWSpG2VKlSWLVqVaYFY5nNEBUVhQULFqTaL79X8pxKmSTLKrmf/G7K7OWUpG21DECQcyIymGCVjYgoJxhDMobMKcaQ1okh5f2OxNHSFs+sa9euKulmHmBqJp/LewR5H0faxviRiGz6N4g5SOYgc4jxY/ZITl0mx8gknsjIyFRdGM3L+pkxfqSsMGgoB8kZtWQTUoC9evUqPv30U1UUS0tGXU+ZMkW1YpVCp5DCrBRGX3nlFVUwkmJWSiNGjFAJBymiylpKMotVZqTKi4HMSpTi74MSD9KG+csvv8STTz6JF154QRWnJk2alK7lgxRIpeD3xRdfqKKurHd75MgR9bmMPEo5wvzDDz9UBbfmzZvjtddeQ5UqVVSR8fz586qdxPTp0zMtgMn3Ly9y7733XoYFXVlXVY65dOlS9O7dG3lB1iyVNXplHeE333xTnbu0FJZANyWZ6eru7q6ui6zxKrebNm0awsLCrH5Obdq0Qffu3VULbJkhW65cuQxvJz9vef7Ic0EKnrK2sRTdmzVrBm9v73S3r1atmmrZLM8teR6tXr06X4uTUkA2P69lBra0aE7ZplmK/UWKFFEfS4tmueayZm9ERIQalSazI2Q28K+//ppqsMHNmzctayGbR7XJ76AcSza5nuKZZ57BV199hX79+mH06NHquXr27FmMHz9ezU4eOnRovl0LIiKijDCGZAyZG4whsx5DXrhwQb0nkvcAchspuEo8KUthyHshWSbDTFobS+w4ZswY9bEsJSMD/8aOHatuV716df5BIyIim2H8yPgxNxg/3vs9kk6K5gLs0aNHLR0yJUdrzrNKV8NGjRqpfKzkbCU/LHll6TgpuXkzxo9EaZiIbKBPnz4md3d3040bNzK9Tf/+/U2urq6ma9euqc8NBoMpODhYxkCYRo0aleF9oqKiTKNHjzZVqVJFHT8gIMBUq1Yt0+uvv245jpBjDBs2LMNj/PTTT+r+Hh4epvLly5smTJhgmjlzprrPuXPnLLeLi4szvfHGG6agoCCTp6enqWnTpqZt27apx5THS+nmzZum1157zVSuXDmTm5ubKTAw0NSgQQP1fcg5Z0TuI9+DXKvMhIWFmby8vEy9evVSn3/wwQfqPOW+Kc2aNSvd+Wd2DcqUKWMaNGhQqn3Lli0z1a1bVz2WXJMpU6ZYHiulf/75x1SnTh11PUqWLGl68803Tf/995+63bp16yy3k+PL4zyI3M7HxyfDrx06dMik1+tNzzzzTKrvSc7L7J133jE1bNjQVLBgQcvPU342oaGh932My5cvm6pWrWoqW7as6cyZM5meX0bXQL6vHj16pLttmzZt1HY/5p9TZpt8PaXIyEj1vCpWrJh6rtSuXds0d+7cdMeVa5/ZMdOe06lTp0wDBgxQ37tcs9KlS5sef/xx05EjR+577uT8wsPD1XNm/9Eg05lLxXK1yTHkWHJMIqLsYAzJGJIxZP7EkLdv3zb17dtXxYTyHkBuV6lSJdNbb71lunPnToa/n19//bWpcuXK6rYSQ0qsnJCQwD9yGsb4kYjsAeNHxo+MH3MfP8o1zOy2KfPNYvfu3aYOHTqYvL29Tf7+/up38PTp0xn+fjJ+pIyEazAHqZP/pS3eElHObN26FS1atMBvv/2mRqATETkLmXUjHQP2Hi0KX7/crZwQFWlE/erXER4eDn9/f6udIxGRo2IMSUTOiPEjEVHeYfxIRM4qQoM5SLY+JsohaWe8bds2NGjQQC2UfuDAAUycOBGVKlVK1XOfiIiIiIgxJBERERExB0lERGmxUEuUQzICQ9a+lXWapD+/9NqXNZ8mTJgAT09PXlcickpGU/KW22MQEWkVY0gi0hrGj0REucP4kYi0yKihHCQLtUQ51KRJE2zevJnXj4g0xQCd2nJ7DCIirWIMSURaw/iRiCh3GD8SkRYZNJSDzF2DZyIiIiIiIiIiIiIiIiIiyjbOqCUiIqIs09JoNiIiIiLKPcaPRERERMQYMnMs1BIREVGWGU06teVGbu9PRERERI6D8SMRERERMYbMnKYKtUajEVevXoWfnx90OiaJiYjIcZlMJkRGRqJEiRLQ67mSAVFeYfxIRETOhDEkUf5gDElERM6C8WPe01ShVoq0wcHBtj4NIiIiq7l06RJKlSqVb1eUretIaxg/EhGRM8rPGJLxI2kRY0giInI2zEHmHU0VamUmrfkJ5e/vb+vTISIiyrGIiAg1+Mj82pZfDNCrLXfHIHIcjB+JiMiZ2CKGZPxIWsQYkoiInAVzkHlPU4Vac7tjKdKyUEtERM6ArfyJ8ud3jPEjERE5E8aQRPnzO8YYkoiInAXjx7yjqUItERER5Y7JpIPRpMv1MYiIiIhIGxg/EhERERFjyMyxUEtERERZxjXGiIiIiCg7GD8SERERUXYZoFNbbuT2/vkld4vMERERERERERERERERERFRtnFGLREREWWZwaRXW24YTLzgRERERFrB+JGIiIiIGENmjoVaIiIiyjIjdDDmsiGHEazUEhEREWkF40ciIiIiYgyZObY+JiIiIiIiIiIiIiIiIiLKZ5xRS0RERFlmgE5tuZHb+xMRERGR42D8SERERESMITPHQi0R2ZXDm49h4dfLcGD9Eeh0QIPOddDn1W4IuxaOxd/9h1N7zsLNww0tH26CnkM7q8+XTFuByyevwsffGx2eaoXOg9ti59J9WPbjaoRevY3AogXQ9dn2aNG3Mdb+thkr56xHZFgUSpQvip4vdkbHgW3g7uFm62+dSENrjLH1MRERWY/EdUu/X4Xls9bhzs1wBAUXRvfnO6JhlzpYPnMt1s7djNioOARXKYmHXu6C8rXLYMnUFdi6eCeSEgyo0qiCijd9C/ri72+XYf+aQ+q4dTvUQt9XuyEqLBp/f/sfTu46A1d3F7To0xh9XuuOMtVK8cdIlKXYj/EjERHZn71rDuHvb5biyJYT0Lvo0bRHfTz0SleEnLmhcpDnDl2Ep7cH2jzaDN1f6IhDG4/h3+9XIeTcdfgH+qHTwDZo/2RLbF64EytmrcXt63dQpFQhdBvSAY2718PK2eux5rdNiI6IQXDlEuj1UheVt3RxdbH1t07kEAwaiiF1JpODnKkVREREICAgAOHh4fD397f16RBRGn99+Q++HzkHLq56GJKMap/eRQejIfnPlARNRkPyfp2LDjCaIH/BdHodTMbk28jHMldP9ptkHUzzXzgdoNfr1OdG8211OsifwBotqmDiijEq+CJyFPn9mmZ+vL8PVIKPX+7eVERHGtC3zim+HpNDYPxIZN9uXr6FES1Hq3/N8WByMHg39tNJLHk3rtTrVBwogwElrrwXb96LMbMSh8ptJI4cu/BNNOnRwBbfNpFDvK4xfiQtYwxJZN9+/mA+fv3oL+hd9TA+KAcpMaWElyqOTM4lpstBmvfd/XraONScu5QJKR8teRtu7pwwQo6DOci8xzVqicguHNtxShVphTk5JswBUvLH9/abDMlFWvWxOSl392NJwKkAKeUwFCnQGpK/Ztl19wDHtp/CrFFz8+YbI3IyRuisshEREVnDhKe+Vh1UUsaD5hhQ4r6U8aM5DpQQMHW8ee/jrMShchtDkgEfPvoFwkMj+IMkegDGj0REZE/2rDqgirTCXKS9bw5S8oyWODKTHKR5392P08ah5vvvXX0Qc8f/nUffGZFzMWooB8lCLRHZhUXfLlOzE2xBAidpkxwbFWuTxydyJEboYcjlJscgIiLKrfNHLuHQpmOpEmz5RXJwiQlJWDFrXb4/NpGjYfxIRET2ZOHXS22Wg5SC7eLvliMxIdEmj0/kSIwaykE6xlkSkdOTJFvKGQz5LS46HuePXLbZ4xMRERFR9hzddtKml0xmTBzddsKm50BERERE2SNr0toyBxlxKxLXzt2w2eMTkf1xtfUJEBGZ136wNVuNpiNyJAaTXm25O0bKvuRERESOGT/KqmS2PgciR8D4kYiI7Ik9xG/2cA5E9s6goRwkC7VEZBcad62n2g/bakSbp48Hfv3wL8THJqBcrdLo+WInFAgKwMqf12PPqoMwGgyo3rQKuj3fAYVLBNrkHInsgdEKbUOMqRaQJiIiypm67WpItdSyJq0tZtSGh0bi7c4fwtvfG20ebYbmfRrh5K4zWP7TOty4FIrAYgXQ4enWaNCpNvR6JuRImxg/EhGRPWnYpQ42/rnNZjlI34I+mP7Gz0iMT0TFeuXQ48VO8PH3xvKf1mL/+iNqjY1araqj65D2KBgUYJNzJLIHRg3lIHWmlKtdO7mIiAgEBAQgPDwc/v7+tj4dIkrhwrHLeLHO/2AwGG2WbNPpdWqtCBnVJuvWunu6ITE+CSY5IVPyaDe9Xod3fxuO1o8048+PNPWaZn683/fXhLefS66OFRNpwJN1D/P1mBwC40ci+zbukUnYuniXit1s1ZFFknwSIxqNJnj7eyEmIvbe/rtxZb0OtTBu0Vvw8vG0yXkS2eJ1jfEjaRljSCL7dWLXabza9D016M5WdDqdenyJFU1GI1zdXZGUaFB5SfV1vQ5uHm4Yu2AkGnWtZ7PzJBLMQeY9DuklIrtQplopvPf7CLi4uqRq/6GKo3c/T9uaWIKYlPsliBEeXu6W+6b890HMwZA50ZcQl5gctN2N22R/UpIB45+cjLMHL+TuGyZyUAaTziobERGRNYyc+RIqNSivPk4bM7rfjQklEZZyv5u7qyVuTLk/Zdyp7pfiNpkxz8SQIq2QIm2q/XfjygPrjuCbl3/I9fdL5IgYPxIRkT2p0qgi/jfzJTXQLm3s5+KWPDBd8pNq391wUCZzZCUHmZX4UZiLxBIryodqosjdeFJ93WhCYlwiPuj7Ga6euZb7b5rIARk0lINk62MishsyS1WCpX+/X4UD64+oYKh+x9ro8UJHRN6Owj/TV+HknjMqCGrRuzE6DmyNi0cvY+kPq3Hp+BX4BPig3RMt0frRpji4/ihWzFqLGxdD4eXvpZJjVnE3Zvr7m2X4348vWeeYRA7EAL3acncMzTTzICKiPCbx3+RNH6lZtavmbMDtkDAULRuEbkPao0aLKlg/fxs2/LEF0eExKFM9WMWVpSqXwIpZ67Dt391qYF61xpXQc2gnePl5Yen3q7B/3WF1bGlrHHL2ulVm6xqNRqz5bROGTHiKy2iQ5jB+JCIie9NlcDvUbFkV/05fhcNbjsPVzQUNu9RF9+c6IPTKbfwzfSXOHrgAL19PtOrXFO2faomTu8/iv5mrcfXUNQQEBaDjU63QrHcj7F5xAKt+Xo9bV2+reFJymtYgxVwZ/Ldk6goM/WKQVY5J5EgMGspBZqv18YQJE7Bw4UIcP34cXl5eaN68OT799FNUqVLFchs53Lhx4zBjxgyEhYWhSZMm+O6771CjRo37HnvBggUYM2YMzpw5gwoVKuCTTz5B3759U91m6tSp+PzzzxESEqKON3nyZLRq1SrL3yzbjhBp04Kv/sX3b85JNTIttwKK+OOv6zOtdjwiR2k7MntfHau0Ph5c7wBbH2sE40cickTyvra75xOqBZ01vTX7FXQa2MaqxySy99bHjB8pJxhDEpEjmjP2D/w+foFV178tUbEYfj75rdWOR5RdzEHmvWyVozds2IBhw4Zh+/btWLVqFZKSktC5c2dER0dbbvPZZ5/hyy+/xJQpU7Br1y4UK1YMnTp1QmRkZKbH3bZtGx5//HEMGDAABw4cUP8+9thj2LFjh+U28+fPx4gRIzBq1Cjs27dPFWi7deuGixcv5vR7JyKNkASbueWd9Y6ZZNXjETkKo0lvlY20g/EjETkqQx6se5uYwBiStIfxI+UEY0gickQq1rNyDlLaIhNpkVFDOchszahN6+bNmwgKClLBU+vWrdWo4xIlSqiC6ttvv61uEx8fj6JFi6qZty+++GKGx5EirVTl//vvP8u+rl27omDBgpg7d676XGbm1q9fH9OmTbPcplq1aujTp48aZZcVnFFLpE3Svu7NDuOsdjxZd6J+h1qYsHy01Y5J5Cij2X7Y28AqM2qfr7+HM2o1ivEjETmKlxu+hdP7z1u1K8v0fZ+jQp2yVjsekSPMqGX8SNbAGJKIHMGWRTsx9uHPrXY8WRO3Zb+mGD33dasdkyi7mIPMe7kqJ0tgLwIDA9W/586dw7Vr19QsWzMPDw+0adMGW7duve+M2pT3EV26dLHcJyEhAXv27El3G/n8fseVIrE8iVJuRKQ9ddrWQKnKxVWB1RpknbI+r3W3yrGIiLSG8SMROYq+r/WwWpFWkmzVmlZmkZaIKIcYQxKRI2jaswEKlShotRyktFDuM6yrVY5FRPYrx38xZPbsG2+8gZYtW6JmzZpqnxRphcygTUk+N38tI/K1+90nNDQUBoMh28eVmbYyetO8BQcH5+A7JSJHJ22P3//zf/D290odKJk7keiSZ8laduvvtSjRu97bb77No//rhcbd6uXHqRPZHWkCaTDpcrVZv5EkOQrGj0TkSDoOaI3Og9uqj/Up40OXex+n7Gync9Gpz9MuuSExZECRALz762v5cdpEdofxI+UWY0gichQuri74YMGb8PByVwP1LFKEhyn36x+Qgxz8YX/UbFktz8+byB4ZNZSDzHGh9pVXXsHBgwctrYlTSvvGVAKqB60PmZX7ZPe47777rhpxZ94uXbp033MgIudVrlYZfL9/Eh4e3gMBRfzh6uaCEhWK4YXPB2LKjonoPKgtfAK84ebhqmY6/O/HlzBp3Vg069kQnj4ecPN0Q82WVTF24Zt4/rMBVl/zlshRGKG3ykbaxPiRiByJxHsjZ76Md38bjiqNKqo40cvPE20fb4HJWz7GK98OQXC1UnB1d4VfoC96vdgZ3+3+FIM/6o+g0oVVvBlYrAD6v90H0/d+huLlUw88JtIKxo+UW4whiciRVGtSSeUgew3tomJEiRVLVy2JYV8/i2+2jUfb/i3g7eelYsvKDSvgnV9ew8QVo9Gwcx1V4HX3dEO99jUxftl7eGp0P1t/O0Q2Y9RQDtI1J3d69dVXsWTJEmzcuBGlSpWy7C9WrJj6V2a5Fi9e3LL/xo0b6WbDpiT3SzszNuV9ChcuDBcXl/veJiPSdlk2IiIRFFwYL04aqLa0qvz4kirOplWnTQ1ePCIiK2D8SESOWqxt/0RLtaVVo1kV9M6gFV2leuXx5HsP59MZEhE5N8aQROSIZIDesG+eVVtGhdyMNOhUJx/OjIjsUbbKyTKDVUaxLVy4EGvXrkW5cuVSfV0+l6LrqlWrLPtkfdkNGzagefPmmR63WbNmqe4jVq5cabmPu7s7GjRokO428vn9jktERETWZTDprbKRdjB+JCIi0jbGj5QTjCGJiIi0TUsxZLZm1A4bNgy///47Fi9eDD8/P8sMV1n/1cvLS402HjFiBMaPH49KlSqpTT729vbGk08+aTnOwIEDUbJkSbWGrBg+fDhat26NTz/9FL1791bHX716NTZv3my5j6yHO2DAADRs2FAVdmfMmIGLFy9i6NCh1rsaROSQb95O7T2LK6euqdbFddvVgLunO4xGI45sOYHQK7dRsGgAarWupmbmJyYk4sD6o4i8HYVi5YJQtXFFtjEmygYjZH2H3LX+zu39ybEwfiQiexR1JxoH1h9BUkISKtYvh5IVkztChV69jaNbT6j4sFqzyihcIlDtv3wqBGf2nVOt6+q0rQHfAj42/g6IHAfjR8oJxpBEZI85yOM7T+PauRuqpXGdttXh5u4Gg8GAQxuPIex6OAqXDESNFlWg1+uREJeA/euOIDo8BqUqF0fFeuWYgyTKBqOGcpDZKtROmzZN/du2bdtU+2fNmoXBgwerj9966y3Exsbi5ZdfRlhYGJo0aaJmx0ph10wKrPLHykxmxc6bNw+jR4/GmDFjUKFCBcyfP1/d1+zxxx/HrVu38OGHHyIkJAQ1a9bEsmXLUKZMmZx/90Tk0E7sOo0vn5+OswcvWPZJsbb1I82wZ/UB3LgQatkvgVKjbvWw5e+diLgVadkfXLUEXv9+KGq1qpbv509EpAWMH4nInsigvR/e/hX/Tl+JxPgky/5aravDJ8ALO5buhcloUvv0Lno06V4f0RExOLjhqOW2bh5u6PVSZzz/6dNwdcvRakJERPQAjCGJyJ4c2HAEk4fOwOUTVy37/Av7oUWfxti5bC9uXQ2z7A8qUxj1O9TGpgXbVZHWrEKdMnj9h5dQpWGFfD9/IrJvOpMMBdGIiIgINfs3PDwc/v7+tj4dIsqF0/vPYXiL0UiKT4TxbjItJ3R6HVxc9Phi/ThUb1aFPxNyGPn9mmZ+vK92N4eXb+6S0rFRSXi94dYsn7t04JBlF44fP646eMgAL+nCUaXK/X9nZekF6chx5MgRlChRQg0mYycOyi7Gj0TOQ976fvTYF9j8905LMTanZMZtq35NMHr+G5wZQQ4lP1/XGD+SljGGJHIeR7aewMh2H8BgMOYqhpRBgG7urvhm23iUr83JZ+Q4mIP8NM9zkI7RoJmIKI2fRs1VrepyU6QVEmAZDUY1s4KIHswAvVW27JBgR1qfbd++Xa1Pn5SUhM6dOyM6OjrT+5w7dw7du3dHq1atsG/fPrz33nt47bXXsGDBAv6YiYg0nGTbtGBHrou05qLvxr+249j2k1Y5NyJnxviRiIgc2fdvzlG5w9zGkHKMxIQkzBo912rnRuTMDBrKQbJPExE5nLAb4di1fB9gpX4AUuw9vPk4Qs5dR/FyRa1zUCKymuXLl6dbciEoKAh79uxRa9xnZPr06ShdujQmT56sPq9WrRp2796NSZMmoV+/fvzpEBFp0MrZ6+HiqochyWiV47m4uqhjsisLkf1h/EhERNYQcvY6jm2z3sA8KdbKUhvhoREIKMyOn0T2ZrmNcpCcUUtEDufOjXCrFWlTuh1yx/oHJXIyRpPOKpu5dUrKLT4+PkvnIK36RGBgYKa32bZtmxrxllKXLl1UoJSYmJira0BERI7pdkiY1Yq0wpBkwK1r99YjI6KMMX4kIiJHdSvE+rGedGZRuU0iui+jhnKQLNQSkZKYkIjLJ6/i2vkbKmAwi42Ow6UTVxB65VaqKxV1JxoXj1/BnZupAwv5XPZHh6duByD3l+PI8czkceTx5HHl8VMmva6cDsHVM9dgMBgs+xPiEpJvG5+UJz81OR85x/jYe3+ojUajGj13+VQIkhLvPa58LPvka3IbIq0wWqHliBxDBAcHqzXSzJusRZuV31NZ86Fly5aoWbNmpre7du0aihZNPUNePpeWJaGhoVa4EkREJG5fC1OxX0xkbKq/1Tcu3lRxm8RvaeMqifMk3ksVh0pcde56qjg0LiZexWY3L6eOQyXOlMeULispycwE2S9xakqhV2+r4/gX9lczaq1FjhVQyC85Vr56O9XXIsOi1LnIOaUk55xRrEzkzBg/EhFRSub8nsSLKWM/iSclTpL4MqWI25Fqf8StyFT7w67fSY6rImJSx6GXQnOd3zPHocklHutLjE9MFytLDlRyoRnGyhnkbImcnVFDOUi2PibSOAlafv1oAf6dvtKS1CpZqTgeGtYVF49ewqo5G5AQl1xErdKoIro/3wF7Vx9U63tJuw6JWBp2qoO2jzfH2rmbsXf1IUviqmW/pqjfoRaWzliNk7vPqP0eXu7oOKA1SlcvhcVTluPq6Wtqv29BH/R4oSM8vT2wZOoKhF1PTrwVLlUIvV/ugjs3I/DfzDWIiUhOAnr6eiIu6l7RN7c8fTzweqsxlo+7DG6HYuWCsGjKf7h+/qba71/YD72GdoZOp8M/01YgPDQ5QCxapggee7M3er2U/DUiyppLly7B3/9eqx8PD48H3ueVV17BwYMHsXnz5gfeNu3vo/kNDX9PiYhyb9/aQ5gz9g+1fIRwdXdFhydbonKjiiqWu3Dkktrv5eeJbkM6ILBYASz+bjluXkouuhYsGoCeQ7sgKSFRxaGRYclxaIkKRfHQy11VgkraCsfHJievKtUvjx4vdsKBdYex8a9tlpmx9TrUQvsnW2LDH9uwe+V+1XVF76JHy76N0bBLXSz7YTWO7zxtOUfrzqg1Ys3vm7Fi9nr1ebUmldD1uQ7YvXw/tizaaYmVG3Wth9b9mmLN75uwf+1hS9vk1o82xTMfP8GlN4iygfEjEZHjkkKsxI/LflyN2MjknF6ZGsF46KUuOLn7tIqrkhKSi6g1W1ZVublt/+xWm6wPK+/lm/Ssjxa9G2PlnPU4tPGYuq2rmwvaPdES1ZpWVvm6c4cuqv1evp7o8kw7BAUXwqLvVuDGheT8XkARf5Xfk8Lsv9NXWQrAkgeUfOj18zew/Kd1iI9JLvR6eHtYPs41neQdPfFSg7fVp97+Xuj+XAeVc1zy3QqEXkke/FewWAE89HIXlfuUvGrKnG3/d/qiy+C2zG0QOVEMqTNpaBiGTGmWarlMV075QyHSKhm19Xbnj3B06wm1Tmta8ock1Z8I+btiAnR6nQqQLLvvfp7V/ebjWP7NiuzcNgfkb2aGfw2z8bi9h3XFK98OsfapEdnFa5r58cbvbAdP39yN84qLSsJ7jddl+9xfffVVLFq0CBs3bkS5cuXue1tZN6JevXr4+uuvLfv+/vtvPPbYY4iJiYGbm1uuvgfSDsaPROltWrgDHz36hYqfjBnFfmljyBzIdRx69/7p4tC8lM1zlIGN3v7e+Hb7eJSsWDx/zpE0Lz9f1xg/kpYxhiRKLTYqFq+3fl8VUdVgtjTSx3LJebps5yDzIg61ttzkOO/e98n3HlYD/ojyA3OQ5fI8B8nWx0QaJiOyjmzJuEgr0gUldz9Nm+wyf57V/ZZgJDtBSR7n1zKNv7LxuDJL5MjWE9Y6JSK7ZIDOKlt2yN8iGcW2cOFCrF279oFFWtGsWTOsWrUq1b6VK1eiYcOGLNISEeWyG8sXQ6bCBFO6GNIS+1khsZXrOPTu/fOtSKseLPU5PegcZUZudHgMpr0+O//OkcgGGD8SEdGCr5bi3MELGRZpM47lcpiDzIs41NpMub/v7+MX4tzh5JnDRM7KoKEcJAu1RBq2ZNoKW5+CU5FZEUtnpP6jTES5N2zYMPz666/4/fff4efnp9Z+kC029t56iO+++y4GDhxo+Xzo0KG4cOGCWkvi2LFj+OmnnzBz5kyMHDmSPxIiolzYvHCnKi7m9SA6rZBk5c5l+xB6JfU6vESUO4wfiYjshxQ+JAeZ2UQRyj69q14t8UFEzhFDslBLpGEhZ65xEXorklkRF49dtuYhieyO0aS3ypYd06ZNU+352rZti+LFi1u2+fPnW24TEhKCixfvjSaVEW/Lli3D+vXrUbduXXz00Uf45ptv0K9fP6teDyIirbl88ipc3FxsfRpOl7y8cvqarU+DKM8wfiQi0jZZei3s2h1bn4ZTMSYZcfnEVVufBlGeMmooB5m7ReaIyKHJ4vVqRgRZhaxh4RPgw6tJTs1wt/VIbo9h7bZDs2enbxvZpk0b7N27N5uPRkRE9+Pt5wVTJi3rKOd8Arx5+chpMX4kItI2V3dXNdDPkJjdbABlRu+ih08Bxo/k3AwaykGyUEvkhE7vO4e/vvoH2xbvRmJiEirWKYs+r3ZDgaAALPh6KQ6sO6IWe/Av5IeYiJjM12elbP8hl1km3b2egLunO1o+3AS9XuqCw5uO4Z/pK3H9wk2VhOv4dGs8PKIHgoIL8woTERGR3aw9u/T71VgyfQWun78Xs3Qa1AZbFu7EfzPX4M7NCBU/sm2ddXn5eeLN9mMRH5uA4Kol0XtYN5SuVhJ/f70UO5fvhzHJgCqNK+Lh4T3Qok9jNTiQiIiIyB4c23EKC776BzuW7bPELH1f6wF3D1cs/Hopjmw5AZ1ehwJB/rgVEgZwvJ/Vls84tv2UykF6eHug3eMt0O35jtiz8oBali30ym34B/qi8+B26PtaNwQWK2idByaiPKEz5fnq2PYjIiICAQEBauqyv7+/rU+HKE9sWrgDn/T/0tKKV+j1OktCTUZcyYu5kEDJxPUhrCrlNdW7JF93SaWpPXf/2srPQGajfLlhHMrVKmPdEyDNyO/XNPPjjd7eGZ6+brk6VlxUIj5uupKvx+QQGD+SFsRExuLNDuNwau/Z5BHEpntxjfpY/mHMmC/xY6pY0lWv2tqljOH7vtYdL301mMVacojXNcaPpGWMIUkLVv68HpOenaryX5YcZIq8I3OQeUsG75lLO/IzSI4h7+0z/wxkoOVXmz5CqUrF8/iMyFkxB5n3uEYtkRO5czMcE576GgaD0RIgiZSzHszBkmDCzfpSXlOjITnRqeKjFENi5GcgCdFxj3zBNYLJ4RhMeqtsRERkP35673fVkUXFMSliFvlcEj2MGfNWyuubKpZMGc/fjeH//mYZti3ZncdnRGRdjB+JiJyPdI374rlpKlZMlYNMkXdkDjJvpSzISg5SjbdMMydPfgYRtyMx/snJeXw2RNZn0FAO0jHOkoiyZPlP65CUmJQqwUb2SQKlK6dCsG/tYVufChEREWlYbFQslv+0NlUijeyXzIqQYi0RERGRLf37/Sr+AByEDP47tecsTu45Y+tTIaJMsFBL5ERO7j7NIq2DJdpO7jpt69MgyhZp5m3M5ZbcEJyIiOzBxeNX1dqo5BikoH58J+NHciyMH4mInM/xnac40M+R6IATjCHJwZg0lIN0tfUJEJH1uLi5plqfgOycyaR+ZkSOxBptQxyl7QgRkRa4urnY+hQom1zd+DpKjoXxIxGR83GVfJbUP5iCdAym5LwxkSMxaCgHyd9OIgdgSDJg65LdWDVnPW6HhKFIcGF0fbY9arWuho1/bMP6P7YiKixKBUlGI9vWOQpZO3jnf3uxfv4WBAUXQpdn2qN22+rY9Nd2tS/ydhSCq5ZEj+c7okyNYKz6eQO2LN6JhLgEVKpfAb2GdkK5WmVs/W0QERGRnQo5ex3/Tl+JQ5uPw8VVj4ad66Lbc+1x+9od/Dt9FU7vPwcPL3d4+XkiNjLO1qdLWaB30aFQiUAMbzFKdWep37E2uj/fEeE3I9TP+uTes/D09kCLPo3RaWBrnD14Ect+XI3LJ67CL9AX7fq3RNvHm8Pd053Xm4iIiNJJTEjE5oU7sfrXDSq+KFa+KLoP6YCqTSphzW+bsGnBNsRExKmYhEVax7Ju3mYs+2EVipULQtdnO6B688pY9/tmbPxrG6LDY1G2ZjB6vtgJxcsXVcvr7Vi2B4nxSajetDJ6Du2E4Colbf0tEDktnUlDU+8iIiIQEBCA8PBw+Pv72/p0iLIkJjIWo3qMx+HNx1UyRtqdmf/18HZHfEwCdHodTEaTSsAZkliodSRZ/Zm6e7qp4Mj8J9u8/4XPBuDRkQ/Z+tsgDbymmR/vf1t6wsPXLVfHio9KxBct/uXrMTkExo/kqCSR9tngKepj8/qzEl9IzGFINNyLGzkTwuHo9To14M/8sU4vP8v0P1M3D4kfEy37zfFlcJUS+HztWBQqXtDW3wo5+esa40fSMsaQ5Igibkfi7U4f4fS+c5Z4wxxHyOC++LiE5DBDZmcyB+m4OUhXvVq39t7PNLk7o/ln6ubuiqQkg4obzfeTj1+b+rwq5JL2MAeZ9xxj3i+Rhk0eOgNHt51MlWQz/ysFPWF+4WSR1vFk9WeaEJeYqqW1ef+Mt37BjqV78v28SbsM0FtlIyKivCMzZT8d9K2KL8wxhjm+kCKt+ntuHtynmWG7zsNcpDV/LEXajH6mUqRNud8cX145fQ0fPjIpn8+atIzxIxGRY5g44FucPXghVbxhjiPiYxNUjGFOTTEH6cA5yHQ/09Q/68SEJEvcaL6f3Obrl2fg0KZjNjl30iaDhnKQjnGWRBp18/It1QI3ZYKNKCUZ1fbHpCW8KERERGSx6JtlahYEUUbkvYUMBD2x6zQvEBERESmXTlzBrv/2MQdJmXJx0eOvL//hFSLKA1yjlsiOHVh/JNUIJqKMEm2HNh692+7OhReI8pzRpFNbbo9BRER5Z8eyfZzlQA8c7Ldn1UFUaVSRV4ryHONHIiL7t3f1Ieh0yS1wiTIiM24lfiTKL0YN5SBZqCWyY5xJS1khMTQDacovRujVlttjEBFR3mEMSQ+i08HSMpkorzF+JCJykPjx7jr3RJk/Txg/Uv4xaigHyUItkY1ER8Rg7W+bcP7IJXh6e6BF38ao1rQy7twIx+pfNiLk3A0W3+jBdECxMkUw481f1POlZstqaNGnkQqwN/y5DSd3nYGLqx4Nu9ZD/Y61oNdn78Xp8qkQ9Ty9czMCQcGF0HFAaxQuWYg/GSIiIhuQ13ppWbt10U7ExcSjbM3SaP9kS3j5emL3igPYs/KAigGKli2CyDtRMBmYaaPMZ0RcO3cD3wz7EYWKF0SHp1uhWNkgnDt0Aevnb0VkWDRKVCiqYr8CRQKydRkT4hKwacEOHN9xSsWhDTrXUVt241AiIiKyjojbkVjz6yZcPnkV3n5eaPVIU1RuUEEtuSY5SPk3KSGRXf3ovnR6HYpXKIbvhv+kZl/XbVcTTXrUR0J8ItbP24Iz+8/DzcMNTXs2QO021dVtskNy5HKciNtRKF4uSMWhBYsW4E+FNEFn0tA0rIiICAQEBCA8PBz+/v62Ph3SMCmgfT54CuLjEuDq6qJmRMqIdnkRun4xVE2R1Lno1b/mhdyJ7sfFLbntsSHRAL9AX/V8iomITbW/TI1gjF/6LoJKF3ngxZT7fzPsByz7YY1qjSfBmLThlpeMp0c/ggEfPJrtgIsc+zXN/HgvbXoYHr5uuTpWfFQiprVayNdjcgiMH8meEmxj+36OQ5uOqeUO5GU4KckAdw839dp/62qYet2XV+ekRI50pweTGE/WMjYaTarAX7JScVw5FaKKq/IEk31SXH1x0kD0fa17li7p4S3H8UGfzxBxKxKubi5qUo7EocFVS+CTpe+heLmi/NFo6HWN8SNpGWNIshfLZ63DNy/PQFKCAXrXe7lGGZAlk0Qkt2PO+bArC2VFylxjgSB/xEXHq03tv5vjrtywAj5a8jYCixV84PGk0Dvp2alYN3ezJQ41GYzqeTlkwtN49H+9+IOxMeYg8x6HtBLlM0muffLEV6pIKy9ekkgztx2TAEmCIkmWyIsdi7SUVer5cjcpG3k7ShVp0+6/fOIK3uwwTgVAD/LjO7/ivx/XqI/lOSnHkH8lcP/lwz+x+Lvl/OFofH2I3G5ERJR1MlDq/d6f4cjWE+pziR1VMdYksxcTVZFW7U+8u58oK6/pBqN6vpiTslKkTX5+Jcd+EvfJc23qiFlYN2/LA48XcvY63unyMSLDotTn6n3O3efjldPX8Gb7cWomOGkP40ciItvYsWwvvhgyFYnxSSqeTJlrvHrmuqU4a875EGVFylzjnRsRqkhr2X83x316/zm82/UTGLLQKvnbYT9i/fwtqeJQlRtPMmLGm3Ow6pcN/MFolFFDOUgWaony2W8f/5U8E1Ezc9nJXkiAI4H4xj+33fd2MgNi0ZTlaqZ3Zn77eAGSEpOsf5JERESU4UC/I1uOM4FGNiFvXeaM++OBy7Is/HopEjNpm2hMMuL6hZuqnR0RERHlj1/G/almJRLlN4n9zh68gJ3L9t33djcuhWLFrHX3bbs9Z+wfMBo5kICcW7YLtRs3bkSvXr1QokQJVWxatGhRqq9fv34dgwcPVl/39vZG165dcerUqfses23btsltFtJsPXr0sNxm7Nix6b5erFix7J4+kU3FRsViz6qDTLKRzUiAvmnB9geOuExKuH8RVtZSlnXHSHtMJj2MudzkGKQtjB+Jckdeu6XdMZEtSH328omral27+5G1bSUpd784dONf9x8wSM6J8SPlFGNIopy7FRKGE7tOc91ZshlpY7xp4f1zkFsX73rgca6du4ELRy5Z8czIUZg0lIPM9llGR0ejTp06mDJlSrqvyQjbPn364OzZs1i8eDH27duHMmXKoGPHjup+mVm4cCFCQkIs2+HDh+Hi4oJHH3001e1q1KiR6naHDh3K7ukT2VR8bAJ/AmRTMkItJjK5LXJmzC1LHiQ2Ks5KZ0WOxACdVTbSFsaPRLmT/NrMdixkWw+K/eIf0NY4K3EoOSfGj5RTjCGJci4umjkbsi2jwYS4B8SP8j4nK7O+mYPUJoOGcpCu2b1Dt27d1JYRmTm7fft2VWiVoqqYOnUqgoKCMHfuXDz33HMZ3i8wMDDV5/PmzVOzcdMWal1dXTmLlhyaX6Cv2mQNUSJbjWYrWyM43X5ZM2LfmsO4ceEmwkMjsnQsWWvs5o9rEFylBGq2rKo6HciIzb2rD6oZuZUbVkCFOmWR12Sts13L9yPyViSKli2Cuu1rqsE+RGQ/GD8S5U7paqXUOk1EtiIzuouXL5puv7QzPrD+iOoYJHHYhaOXM525o3fRoUBhfyz7cQ08fTzQsEsd+Af6qTh0/9rDuH7+pnqv1KhbPXh6e+T593TmwHmc3H0Gru6uqN+xNgoVL5jnj0lE2cMYkijnCpcMhIe3xwMHUhHlFSnAyvuYtGQpNek4eevKbcRExqTuPClrbpjdXXZDjnPmwAWcP3IZZWsGo1qTSioHKW2TJYaU+1drWgllqqfPd1qbDDqUHGT0nWiUqFgMtdtUh17vGDM2yckKtfcTH5/8h9/T09OyT5Ll7u7u2Lx5c6aF2rRmzpyJ/v37w8fHJ10hWFoqe3h4oEmTJhg/fjzKly9/3/Mxn5OIiMha8YEor8jvQ6+hnTF34t9sPUI2W6e2xwudUu3b9s9ufP3SDNy6GmbZJ0HQ/daHkK9/99pPls9LViyGUlVKqGAlZYAlwdPbv7yKkhWLW/17kS4Of3+9DD+PnY+YiHuzMwqXKoQR019Ak+71rf6YBMjTwmjK3Wg01hooJcaPRA/WeVAbzHz3Vxj4B5RsQK/XoW3/5vAr6GvZFx0ejS+en47NC3Y8cO3alLMqtizepTYhBdImPerjxM7TCL1y23I7Lz9PDPzgMfR7vadKwlnb1TPXMPHpb3AsxTIeehc9Oj7dGq9+91y+FIm1hvEj5QXGkET35+Hlga7PtMOSaSuYgySbkHVluz/XIdW+9fO34Lvhs9SSamYS75kk5tPpU8V+JlmX1mRQH3/z8g+W/aWrlURQ6cLYs/JgqjhUiqZvz3kVQcGFrf69yOP8Pn4h5k74O9Xgh2LlgjBy5suo0zZ50iJZl1FDOUirlvurVq2qWh2/++67CAsLQ0JCAiZOnIhr166pVsVZsXPnTjUjN21RVwqzc+bMwYoVK/DDDz+oYzZv3hy3bt3K9FgTJkxAQECAZQsOzvtRFUQP0uLhJrxIZDMSQEhAY7ZrxX580Ocz3A65V6QV9yvSZvR1mV27Y+nedOsvn9h9BiNajlEzba3try/+wbQ3Zqcq0goZkTfmoYnYu4bt8fNCbteGMG9EZowfiR4soLA/qjapzEtFNiGzuVs/0izVLIh3unyMLX/vzHKRNiPSgUWOkbJIK2Ij4/D9yDn44/MlsLbb18IwouVoFaOmJDHs6l82YNzDn+fqe6KMMX6kvMAYkujBWj3SlK9rZDNla5RGkRRF041/bcMnT0xOVaQVJuig07ukH6CnCrXpc5AXj13B7hUH0j23j2w5jtdbjUHE7Uirfy8/vz8fs8fMSzdDXbrLvNPlIxzdftLqj0nQVAxp1bN0c3PDggULcPLkSdXOWNoXr1+/XrUqyWobSplNW7NmTTRu3DjVfjlGv379UKtWLbXm7dKlS9X+n3/+OdNjScE4PDzcsl26xEWnyfYWTv43T0aGE2XFtXM3VHsRIQHNjDfn3P04b66fJL0ibkVi4eTkv9nWEh0Rg58/mJ/h18yB2g9v/WLVxySivMH4kejBzh+5pBIPRLYgnVT+nHSvaLp54Q4c33k63QA9a5szdr6K+axJYtLw0MgMz10K0rtXHsD+dYet+phElDcYQxJlbYA727KSrZw/fNHSwURm18pAvAxl0Do4ObdnynYXwZuXb2Hp96thTWHX72Dep39n+DUpIksMOWvUXKs+JmmP1cvJDRo0wP79+3Hnzh01i3b58uVq1mu5cuUeeN+YmBi1Pm1WWiRLW2Qp2ko75MxIi2R/f/9UG5EtJcQlYP38rXme1CDKjLR1k9kC5oDp/OFLeT66Up7vy2etteoxty7ahfjYhEy/LoHS6X3ncPH4Fas+LgFG6KyyEaXE+JHo/tb8ulGtM09kCxJXHd58HDcu3lSfr5yzQcWUeS0hLlHNuLWmFbPX3fe9mPyerbobK5P1MH6kvMIYkihzMqswo85nRPnFxdUFq+ckx1VHt57AjYuh6W+U2WQmmU2bw7h1+U9rYE0b/timirGZkd8xGegXejV1lxjKPaOGcpB59u5KWg0XKVJEFVJ3796N3r17P/A+f/zxh1pj4umnn37gbeV2x44dQ/Hi1l/3kCivREfEwpCY3FufyBYkeDC3IQ67kX/rdkfejrLq8aRNSlYShGnbqVDuGUw6q2xEGWH8SHS/1zP+7STbMseOsmRGfiR9JdazdiwXcSvqgTMxwq7dsepjEuNHynuMIYkyfs1jO3+yJYkXw+7GcpnnIDN7j5PzSSV3rJzvzGoOMvxm/uVZtcKgoRyka3bvEBUVhdOnT1s+P3funJpBK62OS5cujT///FMVaOXjQ4cOYfjw4ejTpw86d+5suc/AgQNRsmRJtYZs2rbHcttChQqle9yRI0eiV69e6rg3btzAxx9/jIiICAwaNCj73zWRjfgW8Ia7p5saHU5kCzJLoGDRAJzccwZJCfn3PJTHPL3/nGr7HVy1JNw93NT+mMhYXDkVAld3V7V2rrlNvrRLvnb+Brz9vFCyUnFLu3AZnXbrahjcPN2ylCAsUir960lm4mPjcenEVdUWSM7F1S35JTI6PFqtwevh5a7OnW2DiLKP8SNR7hQuVYiJNrK52KhYFUMWKlEQ5w5dzPNirRxfYj5ZT1Yes3CJQLVfks4Sm0WHx6BY2SJqDWdhMBhw6fhVJMYnqvhR4kiRmJCo1jKT+xUsFoBbV5IHLWYWKwelWEstKyRmlXbKRUoFIrBYQcs5Xj55FbFRcShWLgj+gX65uBJE2sUYkijnCgb5q+ISZ9SSrcjzzy/QV8VypsxmyJpkvz59y+Oc1ml1QMHiBVWXPXn8DPN73h4oXbWkJdcoxWSZ7etX0AclKhSzHOrGpVCEXQ+Hh48HjEn3j3vlWIHFk+PArIiNjsOVkyEq9ixdrZSafSwiw6IQcvY6PH08EVylBJdP1JBsF2pldmy7du0sn7/xxhvqXymYzp49W7U7ln3Xr19Xs12lKDtmzJhUx7h48WK6RLesa7t582asXLkyw8e9fPkynnjiCYSGhqpCcNOmTbF9+3aUKVMmu98Ckc24ubuh04A2WPbTGpgMedtuliizWQIb/9yO9fO2qs/za+BAVFg0Xqr/lvpYAp/uz3dC1J0orJqzwfL4RYILoeeLnXDmwAW19pn5zUSZ6qXQdUh77F6+37K+rtC76GDM5PdI1lKr0bwKipcvmqWW5D9/8Af+/X4lYiJi1b6AIv7o8UIn3A65jTW/bUJifJLaX7RsETw9+hF0fbY9tMpo0qstt8cgbWH8SJQ7nQa2wa8f/8XLSLahk5jRHW+2H6c+lURS/syo1WHq8FmWz+t3rIVG3eph+U/rcOHIpbu30aPlw41RoU5Z/Pv9Kty8dMsS43Z8ujX8C/th6ferEBkWrfZL4fdBsXKXLMZ5B9YfwY/v/KrW61V0QONu9VC3XU0s+3ENLp+4arlebR9vjuc/G4BC2UjgORPGj5RTjCGJcs4nwAet+jXBxr+2q3awRPnNkGTAip/W4r8fk1sRyySNpISkjG4Ik9SKctjuOBUTcOPCDbzU4C1Lfk9yjbJ27drfN1seX/KFPV7oiKPbTmLbP7stvyMV65VDpwGtsXnRThzaeOyBHZrV1/Q6NOleHwWDArI08HHW6HkqVoyPiVf7pMAr53L19DW1ZKJcN1GqcnEM+OAxtH+iJbTKqKEcpM6koR4IMgNX2qGEh4dzvVqymTMHzqsXCwZJpHkS5JgyHoWW0UuTBD7Z+b0ZNW8E2j7W4r63SUpMwnvdx6u1JDI6tgRiqU7l7jkPGvc4nh7ziKZe08yP99iaAXD3cc/VsRKiE/BHh1/4ekwOgfEj2Yv/tX0fB1MkC4i0FiuaY8TM4jNrKFWlBH46OvmBsxd2LNuL93t/qs4nZQxpiWPTnJPMlpAk3Hc7J6Jg0QLQyusa40fSMsaQZA8ObTqK/7X9IPXrJpEGpYsfM8s13o3hspuDHP/fKDTqUveBnfxGthuLk3vOZjjoMV0+9O65vDz5GfR9rTtsiTnIvOcY5WQiJ7Lq5/VsW0AkMol3Mhs/lJ0ASWZgLJ+59oG3k9F0+9YcyvTY6U7l7uc/j52v2twRERHlh9Art3Bo83FebNIWU8YxYmbxmTXILNizBy/c9zYyy+GL56ap+DFtDGmJY03pZ+reCgnDL+P+tN7JEhERPcCK2euhS9PVkkiLMhuskC4faMpJDlKPFbMenINc9sManNh1JtPONOnyoXc//X7kHMtav+S8+JeaKB/Jm/plM9dwfQiiPCYtkfesPqjWk7gfaZEno+SyS9r3L//pwUGYMzJBB2MuNzkGERFl3cqfN3CgH1E+kJmv5vZ8mdm9Yj/Crt3J9rrRsrbZyp/Xq2U3tIbxIxFR/pMWq7KUE9eoJcpb8jsmS7hF3I687+3+mb4SphyMMDQajVj9y0ZokUlDOUgWaonyUcTtKMRGxvGaE+UHE3D9/M373uTq6ZActyG/dk6bM2qNJp1VNiIiyrqQM9dYqCXKBzLz9eqZa/e9zdUz13M00E/Exybgzs0IaA3jRyKi/Hcr5E7G64ESUZ7EkKGXb9/3NtfOXc9RJxgXFz1Czl6HFhk1lINkoZYoH3n5ekKfwzf1RJR9PgFeMBgM6fbLDAgZkeZb0DdHl1XWjfAJ8OaPhIiI8kVOX6+IKHukdZ1foK+KHzOaMSv7fQv65Hignwzo9/H34o+FiIjynG8B5iyI7CEHKflH2XwCfHJ0XIlJ+fvs/FxtfQJEWuLp7YFmDzXCtn92s/UIUR7z8vPEsMbvqhGkJSoWQ++XuyK4agksnLwUe9W6tEYULFYgx23M2z3RElpkNOnVlttjEBFR1rXt3wJ/ffkPLxlRPrSu27fmELq69Ye7pxtaPdIUPV/ohF3L92PpD6sRfjNCxZhS0M1uK0mZhduwS90cJ+kcGeNHIqL8V6BIAOq0rYFDm44xB0mUx2Qg36DKr8GQaEDpaiXR55VuKFQyUOUgD248qhbJVTlImb9lyv5s3Xb9W0CLjBrKQbJQS5TPnhrdDzuW7VWjYXI8EpuIHiguOt7yOyYt7Ka9MVt9nDKxdvvanRxdyXK1SqNG8yqa/ClYo22Io7QdISKyF1UaVkDTng2w8799TLQR5bGw6+Hq34S4RKybuxlrft2kiqzmuDKnS9nI/R97qze0iPEjEZFtDBr3OEa2HwudTtWJiCiPxITHwHg3Vrx0/Aq+GfajJQdpjiFVDjIHv4c1W1ZFuVploEVGDeUgHaOcTOREKtUvj0+WvoeAwv7qcxdXlxyvcUREmUs1ECLFh6lmP+Twjcrlk1cReTuKl5+IiPLNqHmvo9XDTdTHEjtKDElEectoSA4WrTHAVpbOOLjuiBXOioiIKGtqtaqGsQvfhG+B5GU0mIMkyhvmIq0wWTkHeebAecRG52ygIDkOzqglsoH6HWph7qXp2P7vHlw4chkmmPDrh3+pdqpEZP+SEg1Y+fN6PPJGL2iNETq15fYYRESU/SU0Rs9/A898EoJtS3YjPiYBx3acwq4V+2BMyl4LViLKf9JRacnU5arDktYGWjB+JCKynWa9GmLe1RnYtngXLp24qgpHv370V4ZrsROR/ZFuLuvnbUG3IR2gNUYN5SBZqCWy1S+fmyta9m2itiNbT+Dn9+fzZ0HkIGRGxOn956BFWmo7QkRkj0pWLG4ZKDS8xSgWaYkcSHhopGp7V6RUIWgJ40ciItty93BDm8eaq49lKQ0WaYkch4ubC07vYw7S2XOQbH1MZAfcPDhmgsjRCrVu7m62Pg0iItI4D293OMgAYSK6i+/9iIjIlvg6RORgTPJ7yxyks2OhlsgOVKhTFgWLBtj6NIgoi6RNedOeDTR5vcwzInK7ERFR7jXt2RA6VmqJHIMOqFS/PAoU0d77PsaPRET2o1rTyvD297L1aRBRFjEHqdNEDpKFWiI7IGsU9X+7r61Pg4iyqEhwYRZqNRAkERHZu86D2sIv0Bd6F76tI7J7JqD/u9p8z8dCLRGR/fD09sAjr/diVxYiB1G6WknUaVsDWmTU0GQRvqMnshN9h3dHv9d7qo9dXPUqYFL/Aggo7Hd3v8vd/S7qc/9C5v166HSwJOl8ArzVv/K5tGjV6XXqY3N7PPlcNvnY3dNdHU/t0yXfTqjRdXePqY5991wkGZjRuaQ9R72LY/wRJMqJuJg4JCUm8eIREZFN+RbwwaerxsD/bnyWMvZzdXdVre0ssaDEfpKc8/FQH1tivLuxn29BnzRxqMv941DL/tRxq5xTynORfyUulMdNGYeqZQQ8XOHqlj4OJXJWEaGRtj4FIiIiPDn6YXQb0uEBsV/qGO9ePjBFDKkDvP280sWhsqamtGo1f27OQao4VMWG9+LElPFj2se8F29mloNMvj1zkOTMYiJjYTQYbX0alMe4MCaRnZAAZegXg9D12fZYPnMNrp2/Ab9AP7R/sqUaNXNs+ymsmrMBd27cQeGShdDlmXaoULcsdq84gPV/bEFMRCxKVSqObs91ULP9Ni/cge3/7kZifBIq1i2Hbs+1h6ePJ1b/shEHNhyByWRC7VbV0WlgayTEJ2H5zLU4ueeMSuo17lYPbR5thltXw7DsxzW4dOIKvHw90fqRZmjcvR7OH76E5T+txc1LoQgo7I+OA9qgRosqOLz5ONb8uhHhoREwJBmx/d89tr6sRHki8lYUNvyxTc1k0hprjEZzlNFsRESOQOK8X85Nxbq5m7F39UHVGqtak8oqVpTE1crZ63F02wmVCKvfoTbaPdkSUWHR+O/HNTh3+CI8vNzRvHcjtV05fU3FhCHnrsOvgA/aPdESddrVwMndZ7Hq5/W4fS0MgcUD0WVwW1RqUB57Vh3E+vlbEB0eg5IViqk4tGjZItjy905s+2c3EuISUb52GbXfx98La37bjP3rDsFoNKFmi6rqdVQGPq2YtR4ndp2C3tUFB9cfVfGuyWTrK0tkZTrgzy+WoMcLHdV7Py1h/EhEZF9cXFzwxoyheOilLlgxax1uXg5Vrfk7DmiN6s2r4NDGY1jz2yZE3IpA0TJB6PpsO5SuVkrl+Tb/vQOxUXEoU60Uuj/fEQWC/FV+ZNeK/TAkJqFKo0rq9lJUXfnzehzeclwNEqzbrhY6PNUS0RGxKg49e/AC3D3d0KxXQ7To2xjXzt1Q+6+eva4moLR9vAUadKqNU3vOYsXs9bgdchuBxQqi06C2qNywPA6sO6Li38g70UiITcSu5ftsfVmJ8kTo5dvqd69Fn8aau8JGDeUgdSap1mhEREQEAgICEB4eDn9/f1ufDpFTm/7GbCz6bjkMiQZbnwqR1cmozfZPtcJbs17RzGua+fE6LnsRrjIrKheSouOxuvv3fD0mh8D4kSj/hN0Ix2PFnuMlJ6c278oMFCpeUBOva4wfScsYQxLln0nPTsXqXzeoSSNEzkZmqPca2hnDvn7WZufAHGTeY28pIsoT2hkCQpp9fvM5TkRElAcvsETOTUNj5YmIiPKFiQkacnYMH50eC7VElCdqtqzK2bTktGRtiMiwaHw66Ft8N/wnHNl6QjNJN3PbkdxuREREaRUICkCxckGqRSyRMwoo4o85Y//AZ89MweLvliM6IgZawPiRiIjyUq2W1TiblpyWdKsMvXpb5SClg6UsXagVRg3lIFmoJaI80eyhhihcMlCth0bkjHYu24t1v2/GP9NWYkTL0Xi32yeIjYqFs9NSkERERPlL1u3s93pPjhgnpxV+M0KtG732t02Y8tpM9C/5Anb+5/xr6jF+JCKivNS2fwv4BfqqtXCJnNHWxbvUmsyLpizHsEbvYNwjk5AQlwBnZ9RQDpIVFCLKE65urvjon3fg4++Vqlhr/lin10Hvqk+15mdGH+v4V4rseFatQbak5HWY9605hM8Gf2fr0yIiInJoD73cBZ0GtlEfp4whpYhr/tyShLv7j4urC3TysXk3k3RkxyR2VGvomYD4mAR80PcznDt80danRURE5LA8vT3w0ZJ34OHtkSp+NOcXJY7MLO/IHCQ5TA4y6V4Ocsuinfj2lZm2Pi2yIldrHoyIKKWKdcvhxyNfYemM1Vg3bwtiI2NRtmYwer3UBaWrlcK/01Zg6z+7kRSfhOrNK6P3sG7w9PHA4in/Yd/aw5Yk281Lt9QLEpE9k+fo5oU7cPnkVZSqXALOyhqj0RxlNBsREeU/vV6PN2cNQ+tHmmHJ1OU4e+givH090fbxFujyTDsc3HhUxZbXzl1XrZI7D2yL1o80weZFu7Bi9jqEXQuHfyFfnDvEwhfZP1k6w2Q0YcFX/2LkzJfhrBg/EhFRXqvRvApmHp2Mf6atwKYF2xEXHY+K9cvhoZe6IKh0YSz+bgV2Ld8HY5IRtdpUQ59Xuqk8jsxQPLz5mBr4l5SQhNshYTAatbG0FTkuiR/lvc+gDx9H4RKBcFZGDeUgdSatLKoHICIiAgEBAQgPD4e/v7+tT4eIHsBoNKK75xNcZ4IchszweW7i03h05ENO95pmfryWS4bB1ccjV8dKio7H5oe+4+sxOQTGj0SOZ/aYeZj36d+MIclhePt7YfGdOU73usb4kbSMMSSRY5GlrB7yH2jr0yDKlte/fxHdn++Y51eNOci8x6aiRGT3bR2IHIVOr0d8rPOvEUFERGTP4mLiVYs7IkeRGJ9o61MgIiLStIQ4vhaTY5FOlMxBOg8WaonIrte5LV6hqGW9MSJ7J2tFlKtVGs7MZNJZZSMiIsor5WuXQVJi8vpNRI6QZCtbIxjOjPEjERHZO79AX7WsBpEjtT9mDlLnNDlIFmqJyK7JmhGO8eeUCCgQ5I+mPRs49aUwQmeVjYiIKK+0frQZfAK8OauWHCbJ1vuVbnBmjB+JiMje6fV6PPRyFzWAisjeSfeg4uWDUKdtDTgzo4ZykCzUEpFd6/VSZ9TvWDtdos0cOKULoBzjby85qXrta8HF1cXWp0FERKRpnt4eePfX16B30astJXNMqXdh0Ej2wdXdFfU61LT1aRAREWneY28+hGpNK6fLNWaWg+RKG2QrJpMJDbvU48BUJ8JCLRHZNTd3N3z0zzt4/tOnEVS6sGV/3XY1MfbvN9H/7T6qPYk5YHL3cLPh2ZLWbfxrG8Ku34EzM5p0VtmIiIjyUpMeDfD1lo/RrFdD6O8m1QIK++HJUQ/jgwUjUbNlNcttzbEkkS0YDUYsnrLCqS8+40ciInIEHl4e+GzVGAwa9zgCixewFGMbda2Lj5a8jX4jeqquLULvqudAfbKpFbPWIjoixql/CkYN5SCzXajduHEjevXqhRIlSqiK/aJFi1J9/fr16xg8eLD6ure3N7p27YpTp07d95izZ89Wx0q7xcXFpbrd1KlTUa5cOXh6eqJBgwbYtGlTdk+fiBy0WPvoyIfw67mpWHTnZyyN+Q2frXofLXo3xrOfPIm/bszEorDZmLh8NBLiEm19uqRhRqMJG//aDmfGNcYoJxg/EpEtVGlUEWMXvol/Y35TseIf137E4A/7o2XfJvhi3Tj8G/2rii2Lly/Krixk00LtqjnrnfonwPiRcooxJBHZolj71Kh+mHd5hooT/435HZ/8+x6a9myIFycNxMJbs/D37dkYM+91JCUa+AMim5Ec+LYlu536J2DK4hq0mlyjNjo6GnXq1MGUKVMynHLdp08fnD17FosXL8a+fftQpkwZdOzYUd3vfvz9/RESEpJqk4Ks2fz58zFixAiMGjVKHbdVq1bo1q0bLl68mN1vgYgclAzg8PH3hrune7p1JHwCfBAdEWuzcyNSz0UXPSJCI3kxiNJg/EhEth70J7GixIxpE3ESW4bfjABMNjs9IkTejuJVIMoAY0gisnkOMk3nPoknfQv4ICqcOUiyLekaxByk83DN7h2kOCpbRmTm7Pbt23H48GHUqFHDMgs2KCgIc+fOxXPPPXffP37FihXL9OtffvklhgwZYjnG5MmTsWLFCkybNg0TJkzI7rdBRE6oaJl7rZGJbMGQZEDRskWc+uJbo22Io7QdIeth/EhE9qxY+SDcvBSqOmMQ2UKRYOd+H8P4kXKKMSQR2SvmIMnW5L0Lc5DOk4O06hq18fHx6t+UM2FdXFzg7u6OzZs33/e+UVFRavZtqVKl0LNnTzVr1iwhIQF79uxB586dU91HPt+6das1vwUicmCV6pdHmRrBaq1aIlvw9PZAq35NnPria6ntCOUPxo9EZGs9nu/EIi3Zjg7o+WInp/4JMH6kvMAYkohsqU7bGggqXVhNPrMKOY5eD52Li9rkY7Uvo/1E0qG2kB8ad6/n1NfCpKEcpFV/s6tWraqKre+++y7CwsJUgXXixIm4du2aamV8v/vJOrVLlixRM2+l0NuiRQvL2rahoaEwGAwoWrRoqvvJ53Ls+wVtERERqTYicl4SHA2f+jxcXPSq/QNRfmvVrym8fL144YmygfEjEdla60eaol6HWhzsRzbh5u6KjgNa8+oTZRNjSCKyJWmBPHzaC2rAVa4njNwtyqYs+qqP725WKwaTU+k4oI1a4oWcg1ULtW5ubliwYAFOnjyJwMBAeHt7Y/369apVicyszUzTpk3x9NNPq7VvZe3ZP/74A5UrV8a3336b6nZp/yjJmrj3+0MlLZEDAgIsW3BwsBW+SyKyZ7VaVcPna8eiUoMKqfZzli3lh00LtiM2yrnXKZGRaMZcbo4ymo3yB+NHIrI1F1cXfPzPO3j4te7w8Pa4t9/NRSXfiPJSUqIBq3/Z6NQXmfEj5QXGkERka4271cPE5aNRrmbpVPuzW1iV22d0nwz3G405O1lyOqt/2YDEhEQ4M5OGcpBWnyvfoEED7N+/H3fu3FGzaJcvX45bt26hXLlyWT8pvR6NGjWyzKgtXLiwKvSmnT1748aNdLNsU5KZveHh4Zbt0qVLufjOiMhR1GxRFVN2TMCs41/j8zUf4PnPBsDENccoH8TFxGPTgh1Ofa1l9T6TKZebrb8JsjuMH4nI1tw93TH0y8H4I+QHfLXxQ7UFFPLjixblOXmf8u/3q5z6SjN+pLzCGJKIbK1+x9qYvu9z/Hj4S5WDHDj20ewdQK9Xk9GyIqu3I22IuBWJncvuLR/qjEwaykHmWVNzmcFapEgRVWzdvXs3evfuneX7yh8dKfYWL15cfS5r3ErwtWpV6jcv8nnz5s0zPY6Hhwf8/f1TbUSkHaUql0DddjVhSDSomRJEeU2eZ9fP3+SFJsohxo9EZGvefl6o2bIaarSoitvX7tj6dEgjbl4KtfUpEDk0xpBEZEsy67VM9WCVg4yPSYCLa/ZKLmxtTDkhy/4xB+k8XLN7h6ioKJw+fdry+blz51RRVVodly5dGn/++acq0MrHhw4dwvDhw9GnTx907tzZcp+BAweiZMmSqjWxGDdunGp/XKlSJbWO7DfffKOO+d1331nu88Ybb2DAgAFo2LAhmjVrhhkzZuDixYsYOnRo7q8CETm1gMJ+ap1rorxmNBjhX9jPqS+0ETr1X26PQdrC+JGIHI0kzHwCvBEdHmPrUyEN8Av0hTNj/Eg5xRiSiBxNQGF/lRvKjgct70iUEaPRxBykE+Ugs12oldmx7dq1S1VAFYMGDcLs2bNVu2PZd/36dTUjVoqyY8aMSXUMKbBKe2MzaZP8wgsvqNbGMgquXr162LhxIxo3bmy5zeOPP65aKH/44YfqMWrWrIlly5ahTJkyOf3eiUgjWj7cBN++8qNa/4koL8layK0faerUF9lkhfUdHGV9CLIexo9E5Ig6DWiDJdNXwJiU3bXA7r7OScLN0qLOUZpukS3ix04D2zr1hWf8SDnFGJKIHE2bx5vjh7d/zfodJFaUmFE2vR46nf5em2Oj4W4smfx1FVrKx7KfNM/d0w3NHmro1NfBpKEcpM6koebmMltXCsGyXi3bIBNpy+wx8/DbJwtsfRrk5Nr2b4FRv49wytc08+PV/nMkXLw9cnUsQ0w8Dj46ia/H5BAYPxJp1/ULNzG03puIiYzNxsyIFEVaM1N2C72kJa5uLvj59BQEBRd2utc1xo+kZYwhibRrymszseS75ffG6z2Azs0NOr1Lqpm1JqPx3oA/czHXvJ+FWgLQc2hnDJ/6fL5cC+YgHXiNWiIiezJw3GN4eswjcPNIbiSgd0n+8+dfyBd129dUI9klryb9/YlyRAccWHcYSYlJTn0BjSadVTYiIiJ7V7RMEXy5YRxKVS6uPpd4UeXIdEDt1tUQWLxAqrgSMgNCxZQpi7SaGRdNOSRdf/atOeTU14/xIxERaclLXw1Gvzd6wcXVJTnXeDdWLFi0AGq3qW6eIHs3F6lTRVqRaftjxpaU7imhw55VB5JnXjsxo4ZykNlufUxE5Iik3fqgcY/j4RE9sHXxLkTejkLx8kXRpEd9uLq5IvTKLexYuhfxMQnYt/YQdi3fB0O229yRppmAsOvh6nnUos+91v3ORmLA3MaBTh5HEhGREylXqwx+PPwVDm06htN7z6lBfw271kXxckVhMBiwe/l+XD4ZgsSEJMwcNZcdjinbJEm7eMp/6DL43hJTzobxIxERaYmLiwte/HwgHn+rN7Yt2Y2YiFiUrFQcjbrWVcXba+dvYNfy/UiMS8SOFQdwaPOJ9DnIDBInqijHTi1097kQcuY6Dqw/grrtajrtNTFpKAfJQi0RaYpfQd8MkyCFSxZCjxc6qY/Xzd/CIi3liATc5w5ddOpCLRERkRZHrNduXV1taZNwTXo0QJMeUAO1uAwt5YTJaML5I5d48YiIiJxMgSIB6DakQ7r9xcoGodfQzurjpT+tZw6ScjzYT3KQzlyo1RIWaomI0vD08VBdRRxlxA3Z14g2Dy93ODOTSae23B6DiIjImbg7+es/5S03DzenvsSMH4mIiDLm4e3BS0M5i6+MzEE6Uw6Sa9QSEaXRsm8TToigHDEajGj2UENNJNpyuxERETmTGs0rwyfA+15/LmlLp1rTceQfPbgjS6t+TZ36MjF+JCIiylirhxurmZEmoxHGxEQY4+PUZjIkqckAJpMx+eOkRMCQxMtIFvK8ady9nlNfES3FkCzUEhGl0XFAa/j4e/O6ULbV71QbpSqX4JWzso0bN6JXr14oUaKEaj+5aNGi+95+/fr16nZpt+PHj/NnQ0REecLd0x0Pj+h+tzDL4ixlnSRm+73ek5csDzCGJCIie9ftmbZwc9PDlJggo//vfUEG/klh1mBgyz/KUOtHmqql/Mg54ke2PiYiSiM6PAZx0fG8LpQ9OuDWldtqxKO8IDsro0kHXS5Ho8kxsiM6Ohp16tTBM888g379+mX5fidOnIC/v7/l8yJFimTrcYmIiLLj+vkbXD6Dss1oNCH08i2Uq1naaa+eLeJHwRiSiIjsXcStSMRHxdj6NMjR6ICbl27B2Rk1lINkoZaIKI2l369SxTaibDEBF45exqFNx1C7dXWnvXjmjo65PUZ2dOvWTW3ZFRQUhAIFCmT7fkRERNkVHhqBtb9tyvVrJGmP3kWPBV/9i0Zdnbd1nS3iR8EYkoiI7N2S75ZDr9fBYGQQSdlgAo5uO4kzB86jQp2yTnvpTBrKQbL1MRFRGgc2HFFrjRJll4urXhVqyT7Uq1cPxYsXR4cOHbBu3Tpbnw4RETmxk7vPICkxRbs6oiyS9x2MH+0LY0giIsov+9cdhiGJOUjKPunmxxjSeeJHzqglIkrDmdvWUt6SUVrO/vxJHs2ms8potoiIiFT7PTw81JZbEhjNmDEDDRo0QHx8PH755RcVKMm6Ea1bt8718YmIiNJx8td/yluMH20fPwrGkERElO8YQ1Kunj7O/R7EpKEcJAu1RKQZ0s5435pDWDdvCyLDolCsbBC6DWmPkpWKY9uS3diyeCfiYxKg1+uh0+tgYtsRysGMiLrtajj1dZMAKfdBUvL9g4ODU+3/4IMPMHbsWORWlSpV1GbWrFkzXLp0CZMmTWKhloiIsu32tTAs/2kdTu87C1d3VzTp3gCtHmmq1hX978c1uHwqBG7urqqzBmdEUHbpXfWo276mU184R4gfBWNIIiKyFoPBgN0rDmDjX9sQHR6DUpWKo+uQDggqXRibF+7AjqV7kBifCB9/L+YgKcd57jptmYN0lhwkC7VEpAkxkbEY89BEHNxwNDmJZjDC5e56UH4FfRAZFq3WhzIZjWo0Eou0lF3yvCpfpyyqNa3Mi5dFErj4+/tbPrfWbIiMNG3aFL/++mueHZ+IiJzT2rmb8fngKSp2lLWgZDDfurlb8O0rPyI6IkYN8DMajSqONLJtHeWAPG/6vd6T184O40fBGJKIiLIr4lYk3us+Hid2nbbkICVmnP/ZYvgW8EHUHXMOUoJLMAdJ2SbPn9ptqqNsjdTFR3LcHCQLtUSkCZ8NmoLDm4+rj80zHcz/SpFWmNellRFJRA9innUtXUbkGVO4VCGMXTDS+duO3N1yewwhAVLKICkv7du3T7UjISIiyqqj209i4oBvUiXPTIbkj2VmRMr4kUVayoqUXXvMM7BfnDQQ9drXcuoL6Kjxo2AMSURE2fXhY1/g1N6zqXKP5phRirQpP8/1CyRpLAcpXUpMqjvke78Nh7MzOWgMmZP4kYVaInJ60o5uy6Kdtj4NcjKVG5RHTEQs/AJ90eGp1ug4oDW8/bzg7KzZui6roqKicPr0acvn586dw/79+xEYGIjSpUvj3XffxZUrVzBnzhz19cmTJ6Ns2bKoUaMGEhIS1Ci2BQsWqI2IiCir/py0BHq9DgYuh0FWIAm2gkUDUDCogGp1WKNFFTz0cldUrFfO6a+vLeJHwRiSiIjy28k9Z3Bg3RFeeLJ6DjI6PBYFigag04A2aP9kS3h6521XEXtg0lAOkoVaInJ6O5ft5XoPZFUuri4oV6sM/vfjS7yy+WD37t1o166d5fM33nhD/Tto0CDMnj0bISEhuHjxouXrEhiNHDlSBU5eXl4qWFq6dCm6d+/OnxcREWWJjFTf/u8erjlLViOzIG6H3MH3+yehQJEAXtl8wBiSiIjy245/96r159lthayZg6zZshqGfjGIF9WJ40cWaonI6SXEJSa3hmA/EbJi8jYxIVGb19OafUeyqG3btvdtSS6BUkpvvfWW2oiIiHLDkGTgBSSrS4xP0t5VtUH8KBhDEhFRfkuIT85BElmNTuJH5iCdPQfJQi0ROb1K9cvdW/uByArkBbtiXedvU5chK7QdkWMQERHZM0mwla0ZjPOHL6Vao5YoNwIK+yGwWAHtXUTGj0REpBGypIEhkYP9yHrk+aSFpTK0HkPqbX0CRER5rV6HWihWLgh6F/7JIyvQAa5urug8qC0vJxERkRPr+2p3FmnJqmvUypq00r6OiIiInFPz3g1RICgAer1jFIfI/gePevt7oW3/FrY+FcpjrFoQkdPT6/UYPf8NeHi5w8VVny5hom7DIi5lgTx/5Pn0zi+vwr+QnyavmXT/sMZGRERk7zoPbovWjzZTH6dsYad3Sf44bVc7drmje8+FFE8OXfJ7jpotqqL/O300eZEYPxIRkVa4ubthzB9vwNXdNV0OUmICwRwkZYU8f2QbPe91ePl4avKimTSUg2Shlog0oUrDCpi29zN0fbYDPLw91L7A4gUw4P1HMWndWLTq1wSubsmj2wsWDbDx2ZI9KXi3PZ2Lmwua926MyZs/RutHkpO2WiQtR6yxERER2TsXFxe89/twvD5jKEpXL2VJrDXuXh+frhyNIROeRlDpwmq/m4cr3D3dbXzGZC88vN1V7CiKlQ3CC58NwMQVozX7HGH8SEREWlK7dXVM3f0pOj7dGu6ebmpfkeBCGPLJk/h01Rg07dnAUsTV5JIIlKkCRf3Vv1Lob/NYc3y7YwIada2n2Stm0lAOkmvUEpFmlKxYHCOmv4Dh055Xa9ambDtWp00Nte6o0WjE+w99il0r9rPVHanZD2Wrl8LcS9PVTNpUsyOIiIhIE8Xa7s91UJvBYEgVD9TvWAePv9UbhiQDjm0/iddbv2/r0yU7ERcdjyk7J6Ji3bJsdUxERKRBZaoHY+RPw/C/mS+ny0HW71DbkoN8vdX7CLt+x2Fm/VHekQGhtVpWx6i5I9THzEFqCwu1RKQ58kKX0dpQar+LC8JvRbJIS4rJaFLPB3le0F0yEi23o9EcZDQbERFRSpnFAxJXRt2J4cWiVKLDY1ikNWP8SEREGvWgHGSE5CBZpCVAFfTl+ZDR80WzTNrJQbJQS0SaIjMhjm0/hcjbUShWLgjlapZW+xPiEnBk6wnExySgUImCqgWJIclo69MlG5PnQZGShbD93z1w93JHzRZVNNuyzswa6zvwTQgRETmam5dv4eyB86oNWfXmVSzrRF0+eRWXT4Yg4nakrU+R7Myd63dUDBlctYTq7KNljB+JiEiLpOuK5Bpl8FapysURXKWk2h8XE4+jW08gMT4RRUoXRsjZ66pIR9omOUhZjk/iR08fD9RoUUWteaxlJg3lIFmoJSLNWP3rRsx873eEXr5l2VepQXlUb1YZa37dhKg70TY9P7I/UqzfsWyv2oRPgDceHfkQnni3r2p9SERERM7tVkgYvnn5B2xbslu1qBNevp5o/1QrnD98EUe2nLDcVka/S0KONE6XPPt6wtPfWHbVbVdTLb9SqnIJm54aERER5Y9/v1+FOWPnI+x6uGVf9eaVUb52Gaz9bTNiImOTd8pkPwcpJFHe5yDXz9+qNuEX6IunRvXDwyN6sA2yBrBQS0SasHTGKkweOiPd/lN7z+LUnrM2OSdyPDIKcvaYeWr9kFe+GQJNMlnhTQTfhBARkQOQ1mPDW4xSg/zMRVoRGxWHpd+vQtql61mkJcWU/rlwcONRvNZsFL7bPRHFyxXV3oVi/EhERBryx+eL8cPbv6bbf3TrSbWlwvwIZUK6QU7/38/q38Ef9dfmdTJpJwfJ6UBE5PRio+PUC5sj/7Em+7J4ynJcOHYZWmQy6ayyERER2buFk5fi5qVbmS6H4ShttMj2pJ1hTGQMfv3wL2gR40ciItLSQL9Zo+fa+jTIifw+fqFahkWLTBrKQWa7ULtx40b06tULJUqUUFOuFy1alOrr169fx+DBg9XXvb290bVrV5w6deq+x/zhhx/QqlUrFCxYUG0dO3bEzp07U91m7Nix6vFSbsWKFcvu6RORBm35eyfiouNtfRrkZOtGrJy93tanQeQwGD8SkSNa9uNqrhdGViMF/7W/b1Lr0hFR1jCGJCJHs27eFhi43ixZkU6vw6o5G3hNnVy2C7XR0dGoU6cOpkyZku5r0g6qT58+OHv2LBYvXox9+/ahTJkyqvAq98vM+vXr8cQTT2DdunXYtm0bSpcujc6dO+PKlSupblejRg2EhIRYtkOHDmX39IlIg2QmhBTWiKxFZtCEXtHmaLZUrUdyupHmMH4kIkcj721TrilGZA1JiQZEhEZo82IyfqQcYAxJRI7m5qVQuLgwB0nWo9fr1FIsmmXSRg4y22vUduvWTW0ZkZmz27dvx+HDh1VRVUydOhVBQUGYO3cunnvuuQzv99tvv6WbYfvXX39hzZo1GDhw4L2TdXXlLFoiyraCRQM4mo2sSro6+BX0Va1HvP294OPvbfmazJKQ9SP8An3h6e3hdFfeGm1DHKXtCFkP40cicsTXet+CPogKy3zAMVG2n1d6HYxGE0Kv3lbvUVxcXFIMDLijnncFggLUv86E8SPlFGNIInI08jouSx4QWYvEjpJjlBykT4A3vP28LF+LjYpF1J0Y+BfyhYcXc5COnIO06vCO+PjkFj6enp6WffLGw93dHZs3b87ycWJiYpCYmIjAwMB0hWBpqVyuXDn0799fzdwlInqQlg83gZt7tselEGXKkGTAfzPX4MnSQ9Gn4CCM6jkeG/7ahglPf40+BQYl7y8wSH1++VQIryTRfTB+JCJ71WVwO1VYI7IKHVRibUD5YXii1It4svRL+P2ThVgw+V8MqDAMj5d4AY8Vfx7PVhuOZT+uUcVbIsocY0giskdt+7eQEX+2Pg1yIlL4/3PSEpVr7FtwEMY+/LnKQX746BfoU3Dw3dzkYEwaMhXXL9y09emSPRRqq1atqlodv/vuuwgLC0NCQgImTpyIa9euqVbFWfXOO++gZMmSqmWyWZMmTTBnzhysWLFCzbiVYzZv3hy3bt26b9AWERGRaiMi7fEt4IP2T7ay9WmQk0mIS0z+wATsWr4fHz/2JdbLWiRJBrVb/l3/x1YMa/Q2zh26AKeR25YjDtZ6hPIe40cisld9XukKPVvXkbWYgJiIWMunt0PCMGvMXEx/4+dUSTUZ5PfVC9Px3Ws/OU+xlvEj5QHGkERkjwqXCESzXg1tfRrkTHRAYkKSZXbt1iW7VA5yy6KdltnbSQlJWP3LBrzc8G1cOe1EE0ZM2slBWrVQ6+bmhgULFuDkyZNqNqy3t7daf1ZalZhb+jzIZ599ptokL1y4MNXMXDlGv379UKtWLVXAXbp0qdr/888/Z3qsCRMmICAgwLIFBwdb4bskIkcjBbOd/+1TL2xEecFkNFkCppSMSUbERcdj0pBpTnThdVbaiJIxfiQie7Xtnz3qtZzIWjItvJrSf7z4u+U4uPGok1x8xo9kfYwhicgexcfGY/+6w7Y+DXImpkxykGlabBuSjIi6E41vXv4BzkOnmRyk1Ve2btCgAfbv3487d+6oWbTLly9Xs16lXfGDTJo0CePHj8fKlStRu3bt+97Wx8dHFW2lHXJmZGZveHi4Zbt06VKOvicicmw7lu1F2LU7DjOChpyLBE4nd5/BmQPnbX0qRHaL8SMR2aPF3/0HEwNIshEXVz3+mb6S15/oPhhDEpG92fjXdkSHx9j6NEjDOci9qw8h5Nx1W58K2bpQayYzWIsUKaIKqbt370bv3r3ve/vPP/8cH330kSrsNmz44PYA0tb42LFjKF68eKa38fDwgL+/f6qNiLTn4tHL0Lvm2Z87oqw9D49dcY4rpaG2I5T/GD8SkT3NfLx6+hpfs8hmZFbEuYNOsnwG40fKY4whiciecpCublnrLEqUVy4dv+ocF9eknRyka3bvEBUVhdOnT1s+P3funJpBK62OS5cujT///FMVaOXjQ4cOYfjw4ejTpw86d+5suc/AgQPVGrTSmtjc7njMmDH4/fffUbZsWbX+rPD19VWbGDlyJHr16qWOe+PGDXz88cdqzdlBgwZZ4zoQkRPz9PW0tIUgshUv33vt/B2aNYIc/jpqDuNHInI0Op0Obp7uSIhNsPWpkIZ5+3nBKTB+pBxiDElEjpiDTLssFlF+Yw4yBQf5dcz2FDOZHVuvXj21iTfeeEN9/P7776vPpd3xgAEDULVqVbz22mvqY1lzNqWLFy+q25lNnToVCQkJeOSRR9QMWfMmrZDNLl++jCeeeAJVqlTBww8/DHd3d2zfvh1lypTJzfdPRBrQvHcjh/mjTM5JRlN+++pM9AkchJcbvY3/Zq5BYkKirU+LKN8wfiQiR9T6kabQuzjGmkbknCLDovFwocF4vMTz+GbYj7h0wkk6tBBlEWNIInI0LR9ukm7tUKL85O7ljglPfY2+gYPxWvNRWPXLBhiSDPwh2DmdSXo6aYTMwJV2KLJeLdsgE2nLuEcmYfPCHbY+DdIonU5aKN79WK9TM7zrtK2BT5a+Cw8vD4d4TTM/XvB346D3yt3sYGNsHC4N+4Cvx+QQGD8SadfZg+cxtP5b7MxCNqN30VuSvbKUi4uLHuMWvY1GXeo6xOsa40fSMsaQRNr1Zsdx2L/2sK1PgzTcGchc8tPrdWqGd5OeDTB2wUi4umW7wa7CHGTe46KNROT05MXp0vErACdEkM2egyk+vtsC59DGo5gz9k+H/F6ssRERETnC+vJcPoNsKeWMHGOSEUkJBnzYbxKi7kTDkTB+JCIirTAYDLh6KnlZRyJbSDkv09yGe+eyvfjj8yUO9wMxaSgHyUItETm9I1uO48LRy2x/THZFgqV/v1+J+Nh4W58KERERZWDh5KVqFDqRPSXe4mMTsPLn9bY+FSIiIsrA7uX7ceNSKK8N2RUZfLro22VsgWzHWKglIqd3dNtJ1TaMyN7ERMTi0omrcCgmK21ERER2XhA7seu0ZRQ6kd3QAce2n4RDYfxIREQacWTrCbi4udj6NIjSCbse7niDCEzayUHmrCk1EZEDUUVaR+lzQJrj4upgAbxJFtzN5eyi3N6fiIgoH8i68mChluxw3THGj0RERPacg7T1WRBljDGk/eIUMyJyevU71uZsCLJLBYsGoHTVkrY+DSIiIsqgGFavfS12ZSG7XLe2bvtatj4NIiIiykCDTnXYXpbs8r1NiQpFUaRUIVufCmWChVoicnrla5dBnXY1oHflnzyyL/1e7+lwo9l0JutsRERE9u7RkQ+pohiRPfEL9EW7/s3hSBg/EhGRVtRsWRUV65WDC3OQZGfLush7GynYOhKdhnKQrFoQkSaMmvu6ZeaiamOn2j0k/wl093RTaz2ZX6v0Lo71okWOy83DDQ5HQ+tDEBGRtklXlpcnP6PixFQD/nSAq7trqnjS0ZIe5Lhk3Tud3sFSOYwfiYhIIyQmHLfoLRQtUyTDHKTkgVLGjcxBUn5hDtK+cY1aItKEgkEB+G7Xp9j013as+W0jwkMjUbJSMXR/riMq1i+HNb9uwuaFOxAbHSe5N5zYdUaNNiLKS39OWoLer3SFi4tjzaolIiLSir6vdUf9jrXwz7SVOL7rNDw83dG0V0N0eaYtLp+4in+/X4WLxy7D09cTR7ecQGJCkq1PmZzcnevh2LxgO9o/2crWp0JEREQZCAoujBkHv8C6eVuxbt5mRN+JRnDVkujxQieUqV4KK2evx9YluxAfm6C6t5zedw4mI3OQlHdkbMD8zxaj86C2HGBqp1ioJSLNcPdwQ4enWqktrd7DuqpN/K/dByzSUr4IvXIbl45fRdkawY5zxU265C23xyAiInIQZaoH45Vvh6TbX71ZFbWJvasP4u3OH9ng7Ehr9C567Fy+z7EKtYwfiYhIYzy8PND1mXZqy2gZLNnEi3VHskhLeU7mIl06fkXlIR1qnVqTdnKQLNQSEaWRGM+ZEJR/khId7PlmjdbFHChKREROhjNpKb9I1x9DosGxLjjjRyIiogwlJiTyylC+YQ7SfjnYwiZERHmvetNKaqQ6UV7z9PFAyUrFeaGJiIgcXIW6ZS1rkBHltcoNK/IiExEROQHpzmJev5YoL/kX8nOs2bQaw78CRERp9HypC4xGI68L5e0LsIterZHs5ePpmDMicrsRERE5kcIlAtHq4SYs1lLe0gFu7q7oMritY11pxo9EREQZkmXYDEnMQVLekgGl8lxzdXOwBrsm7eQgWaglIkqjSKlABBT253Uhq9HpUsyw0SV/XrlBeQz+6HHHu8oaCpKIiIiyo2qTSlxjjKwqZQjp4uoCFxc93vt9hJoR4VAYPxIREWWoRIWi8Pb35tWhPMlBqg91QJ02NdD/3b6Od5VN2slBOlgJnYgo762btxXhNyN4qclqXNxc4OXnidjIOBQrF4ReQzujxwsd4eHlwatMRETkJOs9/fH5ElufBjkTHRBUujBuX7sDN3c3tOjbGA+P6IGKdcvZ+syIiIjISlbMWo/YyFheT7Iady93uHm4Ii46HqUqF8dDL3dF12fbqXiS7BcLtUREaWz4Y4tqCWEyOsiQG7J7SQlJePvnV9Gke304PJMuecvtMYiIiJzIse2ncOdGuK1Pg5xMYIlA/HpuGhwe40ciIqIMrZu3GSYT849kPfEx8Zi4YjRqtqjq+JfVpJ0cJAu1RERpRIZFs0hLVhcT4RwjJHWm5C23xyAiInIm0eExtj4FcjYmIPpONJwB40ciIqLMc5BE1sYcpOPlIFmoJSKnZDQacXjzcYReuY2CRQNQu011uLi4IDEhEfvXHUHk7SjVgrZak0qqd39MZCz2rzuM+JgEFCpeAC6uehiSjLb+NsiJSLsRIiIism+hV27hyNaTaj2n6s2roHCJQLX/8smrOL3vHFzdXVGnbQ34FfRVsx9k3+WTIYiJYKGWrEvej5SuVoqXlYiIyM4Zkgw4uPEowq6Ho3DJQNRsWRV6vR4JcQnYt/awGtAnOaFK9curHGTUnWgcWH8EifGJapmDa+euMwdJVlWyUjFeUQfDQi0ROZ2tS3bhu9d+wo2LoZZ9hUoURONu9bD5752qSGtWsnJxVazdtGCHag1BZG16Fz3K1QxGxXpOsp6YjETL7Wg0BxnNRkRE2iEJs69fmoENf26zdFaRpTCadK+nRqQf3HjMcltZ86nlw01w4cglnD14MdVrvtHAgX5kHTJotOeLnZzjcjJ+JCIiJ7Vu3hZM/9/PuB0SZtlXpHRhNOhQC5sW7kjVdaVszWCUr10WmxZuR2Jcoo3OmJyZvB+p0aIKSlZ0kskiJu3kIFmoJSKnsv3fPRjb9/N0f4VvXQ3DfzPXprv9lZMhaiOyCl3qp54ESG4ebnj9h5fUqEkiIiKyPzLb4a2OH+LMgfOplr+Qj7f/uzfd7RPjk7Bu7pZ0+1mkJWvqPLgt6neszYtKRERkp9bO3YwJT32dbv/Ni6FYPmtduv3nD19SG1Fe5SC9fD0xfOrzvMAOiIVaInKqdsffDf9JvUqZHGS0DDkXKcZKG0Tzx0161MczH/VHuVplbH1qRERElIm1v2/Gqb1neX3IJiRm9PB2R1x0cnefwqUK4ZHXe6Lv8O4c6EdERGSnkhKTMO312bY+DdIwaa9tHigqRdqWfRvjmY+fQKnKJWx9apQDLNQSkdM4vuMUrp27YevTIA2TIu2LXwxE4271USDIH/6BfnDGAXu6XA6E4NxiIiKyJ8t/WqvaHKecTUuUn/GjbwEfTN/3uSrMFi1bBC4uLk71A2D8SEREzmbfmkO4cyPc1qdBGiZF2hHfv4BaraojsFgBFU86G52GcpAs1BKR07gVcsfWp0Aa5+LqgtiIOJSuWtLWp0JERERZFHrlNou0ZFOS6HWatcSIiIg0gDlIsjW9Xof46ATmIJ0EC7VE5DQKFS9g61MgjTMkGRDo7M9Dky55y+0xiIiI7EThkoG4cSmUxVqymQJFA5z76jN+JCIiJ8McJNma0WhiDtKJcpB6W58AEZG1VG1SCcXLB0HnGH9/yQm5ubui9aPN4NRMVtqIiIjsRNdn27NISzYja4p1H9LRuX8CjB+JiMjJ1OtQCwWCnHygFdk1b38vNO3VEE7NpJ0cJAu1RORUi6i/PPlZ1X2exVqyhUHj+sOvoC8vPhERkQNp/2RLVKpfXhXMiPKT3lWPIqUKofcrXXnhiYiIHIirmyte+mqwrU+DNOz5TwfA09vD1qdBVsJ3okTkVJr2bICxf7+JIsGFU+3X6TnNlvKOX0EfDPv6WTz25kPOf5k1NJqNiIi0wd3THZ+tfh+tH2maOmZk+EjWpEv/nqRe+1qYvPkj+Bfyc+5rzfiRiIicUPsnWuK930cgsHjBVPs5eYTyUkARf/zvx5fQ88VOzn+hTdrJQWa7ULtx40b06tULJUqUgE6nw6JFi1J9/fr16xg8eLD6ure3N7p27YpTp0498LgLFixA9erV4eHhof79+++/091m6tSpKFeuHDw9PdGgQQNs2rQpu6dPRBrQ/KFG+OXsd/hi/Ti8+9twDBz7GNvZkVXJjJsez3dUAfn4Ze9h3tUf0OfVbup10dnpTNbZSFsYPxKRvfMt4INRc1/H7xemYcwfb6hNZjoSWY0peVDAqHkjMGruCPx86ltMXD4ahUs6//OM8SPlFGNIIrJ37fq3wO8Xp6lBf5KD7P92H0epC5GDkIF+fV/rrp5fE1eMxrzL36ulW7RAp6EcZLYLtdHR0ahTpw6mTJmS7msmkwl9+vTB2bNnsXjxYuzbtw9lypRBx44d1f0ys23bNjz++OMYMGAADhw4oP597LHHsGPHDstt5s+fjxEjRmDUqFHquK1atUK3bt1w8eLF7H4LRKSRNsi1W1dXo9tk3VAXVzYQIOuKi4lXAXmjrvXg7uHGy0t0H4wfichRSNGs9SPN0KpfU9y8dMvWp0NOJj4mHtWbVUHbx1ugRIVitj4dIrvHGJKIHIGLi4vqkiE5SKmPuLq62PqUyIm4uOiRlGhQz68GneqottvkfLJduZDi6Mcff4yHH3443ddk5uz27dsxbdo0NGrUCFWqVFGzYKOiojB37txMjzl58mR06tQJ7777LqpWrar+7dChg9pv9uWXX2LIkCF47rnnUK1aNfW14OBg9VhERPfj7e8No8FBhs+QQ5CZs95+XtAkDbUdIeth/EhEjvha7+nDNZ/I+rx8PbV3WRk/Ug4xhiQiR+MT4AOjkUkPsh4p/vv4MwcJJ89BWnWKWXx8vPpXWhOnHFHi7u6OzZs333dGbefOnVPt69KlC7Zu3ao+TkhIwJ49e9LdRj4334aIKDPN+zTiGrVkVYYkA9o81lybV5WJNrIyxo9EZK9k1iO7spA1l86o16EW/Ar6au+iMn6kPMAYkojsUatHmsJoMNr6NMiJGJKMaP1oM2iSSTuTRaxaqJXZsNLqWGbEhoWFqQLrxIkTce3aNYSEhGR6P/l60aJFU+2Tz2W/CA0NhcFguO9tMgvaIiIiUm1EpD2FSwSix4udNLF+KOVPkq1my6qo3aY6LzeRFTB+JCJ79ejIh+Di6gq9njEk5ZIueTbEgPcf5aUkshLGkERkj0pVKo72T7bkhBGyWg6ySY/6qFS/PK+ok7NqodbNzQ0LFizAyZMnERgYCG9vb6xfv161KpGZtfeTtoAib2LS7svKbVKaMGECAgICLJu0SiYibXr5q8Ho9lx7lSSRFzlXN64XQem5uLnA5e5aIsXKFoFPgLf6WJ4v+rvrHNdtXxMfLXlHs4V/nck6G5EZ40cislelq5bExBWj4V/Y3xIPcIYtpWV+byGxocSS5WqVTrVfyJIZY/74H2q1qqbJC8j4kfICY0gislf/+/EltOvfQn3MHCRlJQdZomIxy/IYKgfpkpyDbNKjAUbNHaHZi6jTUA7S6isPN2jQAPv370d4eLiaUVukSBE0adIEDRs2zPQ+xYoVSzcz9saNG5YZtIULF1aF3vvdJiMys/eNN96wfC4zalmsJdImWWj99e+Hov87fbFh/lZE3o7Czcu3sG7eFlufGtkBCYDK1ghG4+711awZaUtXp20NJCYkYfOC7Th78ALcPd3RvHcjVKxXDppmkikhuSxS5/b+5HQYPxKRvZLC2u8Xp2Hrol04tfcs9K4uWPztf4iJjLX1qZGdeOilLnD3dENQmSJo90QL+Af64cLRS9i0YAdio+JQulpJtWSGp7eG1zxm/Eh5hDEkEdkjyR+9++tw1Uljw5/bEBMRi6tnrmHLop0wcf1azZOBn5UbVFB5RynWNupaD9WbVUZ8bAI2/rkNF45eVkXblg83UblKTTNpJwdp9UKtmcxgFadOncLu3bvx0UcfZXrbZs2aYdWqVXj99dct+1auXInmzZPX/5M1biX4ktv07dvXchv5vHfv3pke18PDQ21ERGbFyxVVxVrxxZCpauSSrDdK2ibrh4ScvY4h459Mtd/dww3tn2ylNiLKe4wficgeubm7qUKbbFdOh2Du+IW2PiWyI2VqBKPni51S76serDYiyh+MIYnIHpWqXAJPjeqnPv7w0UkOs1Ym5f2aszcuhWLIhKdS7ZdBfZ0HteXl16hsF2qjoqJw+vRpy+fnzp1TM2il1XHp0qXx559/qlm08vGhQ4cwfPhw9OnTB507d7bcZ+DAgShZsqRqTSzkNq1bt8ann36qCq+LFy/G6tWrsXnzZst9ZGbsgAED1MxcKezOmDEDFy9exNChQ3N/FYhIk1zd82ysCjkgGcVGWSBvLHL75oJvTjSH8SMROQs3xo+UBpdUyQLGj5RDjCGJyJlykDq9DiYDEyIkOUjmpLPEpJ0cZLafETI7tl27dpbPza2FBw0ahNmzZyMkJETtu379OooXL66KsmPGjEl1DCmw6vX3lseVmbPz5s3D6NGj1W0rVKiA+fPnq5bJZo8//jhu3bqFDz/8UD1GzZo1sWzZMpQpUyan3zuR04oMi8KKWeuwbcluxMcloErDCuj1Uhe13ubSGauwb80h9TeqbtsaavR3XEwC/pm2Asd2nFIzCKX/fddn2+HqmetY+v1KnD9yCd7+XmjzaHO0f6oVvHySe+Y7Omkt8e/3q2x9GmQnrY8LlSiI15qPgt5Fhwad6qD78x1RqHhBW5+a3bHG+g6Osj4EWQ/jRyL7ZzKZcHDDUSz9YRWunLoG/0K+qqNEy35NsXflAaycvR6hV26hSHBhdHmmHeq0q4FNf21Xy0jIkhLBVUqgxwudULZmMFb9vAFbFu9U7bsq1y+PnkM7o3xt53jfJt9/yUrF1cxaR3nTT3lrzW+b8M/0lShWrgi6DemIBp1qq/Vq6R7Gj5RTjCGJ7N+dm+FYPnMtdizbi6REA2o0q6xiPylM/jt9JQ5uPJacZ+lYB92e74CI0Ei1/+Tes/DwckeL3o3RaVAbnDt0Ect+WI1LJ67CL9BXrfEqm7QRdgaNutTDurlcfo0kB6mDXwEfvNrsPTXgr0n3+ug6pD0KFEnuUEvajCF1JnlHrhGyRq20Q5H1c/39/W19OkR5QtbOervTR4i6E60SbkLvqocxyaj+lYSStHlV+2VhcpMJRqPJchtFl7yma1JCkuqbLy0ZJNlggglBwYUxad1Y1ULY0UnL42erj8D18zfU90jaJmvTyu+C+WNXDzd8uOgtVbS1R/n9mmZ+vPIfjIfeM3eDNYxxcTg77j2+HpNDYPxIWmAwGDDp2alY/ctGS+xnfl308HZHfEyCihslhjT/a96vZgYYTZb7uXm6ISk+yRKHmvdLa6/+b/eBM1g+a51aQoNImH9XzM91WU9s1NwR6v2U1l/XGD+SljGGJC04vOU43uv+CeKi4y1rr6pY0ZicR5QtZQ5SxjHJa6X5NdPMzcMNifGJ93KQd+NLGQj42ZoPULhEIBxdQlwCBlZ8BWHXwy3XhLTL/J5KyPPd08cT45e9h5otqsIeMQeZ9+5NayUihxcbHYd3u36C6IgYS3JMmAuw8m/KYEA+NhemLEVaYYIq0gpz4KSOZwJCr97G6J4TVNDl6GR92onLR6NwyUKWF0b1rwtHwGuR+XfB/LG8SXi/z2fqOU8ZtB3J7UZERHbjj8+WYPWvG1PFfubXRSnGqs/vxpDmf837zUk58/0S4xJTxaHm/TPf/Q3b/90DZ9BlcFv0f6ev+lgSiiJlxyjSFvPvivm5vuXvnfj5gz9sfFZ2hvEjEZHTibgdiVE9xqcq0lpiRUkhGk3pcpDm18q0kyUk/5Jyv/l4V85cw7h+k1LFlo5KZgZ/unIMChRJHiRl7r5hzkWStqT83ZDne1x0nPp9ki6ZpM0Yku8miZyItNAID43I05FZUtC9eOwK9qw6CGdQvHxRzDz6Fd6a/Qqa9WqI+h1roXrTygyUSAVKMiNoKdtjp3a37UhuNkcJkoiItCApMQkLvvonz/82y6jxPz5fDGcgibUh45/EjAOT0PPFzqjXoRYa96jHtUpJkWTy4in/qUG0dBfjRyIip7Ni1nrERsWlKtLmRQ7y+I5Taqk2Z1CmejBmn/oWr88YiiY9G6jlEmS5OtXxkDRNfo9iI+PUUoakzRiSfwWInMi+NQdV6638mIm6f80hOAsPLw90GtgG4/5+C5+ufF/NiMjLQJMch8wc371iv61Pg4iIKM+cP3IJ4aGReX6FZSDhoU3HVGHYWZSrVQavfDsEn616H72HdVPrshEJSVyf3nuOF4OIiJzW3lUH8iV3JkXMfU6Ug/Ty8UT35zrgo8VvY+KKMYiLiWcrZLIM9tu72jkmRlH22eeiKUSUIwaDUZaczXtqTQnnTUQ58/dG2cekaxrWGI3GcRBERHYjv9fISrnUgDPhWmOUFt9TpMD4kYjIKXOQ+UE6BKdars3JMIaklJiD1G4MyUItkRORlr2bF+7I8z9AhkQDbl8Lxzcv/4CAIv5o/2RLBFcpiYvHr2Dt75sQERqJoNKF0XFgGxQqXhDHd55W5yUjy0tXK4kOT7WCX0Ff2KuaLaupc2awRLJesW9BH3wz7Ed4eLmj2UMNUatVNctaIpqkoSCJiEgLSlcrBU9fT8RF5XGbVh1QtHQR/Pj2r2r2RY0WVdCib2MVb238cztO7DqturY07FIHDTrXQUxErFo3V5bc8PLxQIuHm6Bak0p2+xpcqX456F31Tp1IpKyT5/KWRTux8a/tDvH+J88xfiQicjo1mlfBgfVH8jx3JuvWXj17XeUgCxYrgI5Pt1bLmJ09eAHr529BVFg0ilcoho4DWqv1Xw9vPo6ti3chPjYB5WqVVjlLH39v2KtararjyqmQdOv2kvbI+xxXN1eVg3SE9z/5wqSdHKTO5AyrcWdRREQEAgICEB4eDn//5IW7iZxJxO1I9C/1IhLjEvP8saQ9sN5Fp2ZFSFBWslJxFVhIgkqv06l9RpMJxcsVRcjZ6ypZIQk6SV65ebiq9RgkuLJHIeeuY3Dl11ioJQsXNxf1wi4zIyRI+nDJ2yhQJEBTr2nmxys/ajxcPD1zdSxDXBzOfvIeX4/JITB+JC2Y/r+fsWDyv/nyJla9pt4d+OcX6KteW6Uom/K1tnDJQISHRiApwaBiS/P+uu1r4oO/RsK3gA/s0YSnv8b6+VsZQ5Jir+9/8vN1jfEjaRljSHJ2Ny/fwtPlX86XQWrS/lin16nBfsk5yGK4cuoaXFz1qogls3ulllUkuDCun79peQ2W+NHTywNv//IqWvZtAnt07tAFvFB3pMMUkyhvyfNYL89fO3v/wxxk3uMatUROREaIBRYtkG9rd0o7BvPIOSnSqv1Jd/dLWzsTVJFWyIuLJORkbEhCXCI+HfQt9qw6AHskxeW3Zr+igkAJ+lIGhpaPU+zX8S+p05Pnrrl93YndZzCqxwT1O6BFOpN1NiIish8y2yC/kkPqNfXuWq6Rt6NUkTbta23oldtIjE9ScWPK/Qc3HMW4Ryap/fZI1qstU71U8qj3lAPfdfcSjKQdGb3/0eq6Y4wfiYicT0BhP/gH+uXLY0nu0ZAqB3lN/Wu4m4NMLuCaVJE2ef/deNMExMXG46PHvsTRbSdgj8rVKoPXvntexYupc5C6DPORzEE6N3mbk/b9z4ePfmG373/ymk5DOUiWF4icyI6le3H9QnJQYu9kRu5vnyyAvZL2ZFN3fYr2T7ZCgaAANeOjcfd6+HTV+/hs9fto2qOB2ietnwsVD0wVQJFzkzcGJ3efwb41h2x9KkRERLkmb/p/H78wdWHRjl+D9689rJaosEfS2vbrrZ/g5cnPoGyNYPgU8FZdZ4aMfwo/HZuMgR88hhIViqoR8TIThLRFr9fh14//svVpEBERWcWGP7bhzo1w+7+aUqTRAfM+XQR71WtoZ3yzdTxaPdI0uQBeyA8t+jTBlxvG4ZOl76FBp9rwK+iDgkUDVHc3Dv7TDnn/I/lHWSaGnBvXqCVyIpsWblejrxxhXQN5oTm08RgibkWqAMQeVaxXTs2szUi99rXUvwlxCejp+7QavUfaIW10Ni3YgQad6tj6VIiIiHLl4rHLuHo6eVaCo7wGb16wXS1FYI+8fDzR59Vuakvr6TGPqM3cbnrRt/9ZRsuT85OZPur9z+3IfJuBRERElFc2LthmaUds76T73/Z/9yAxIRFu7m6wRxLbjvr99Qy/1rhbPfWvLA3ySNCQfD4zspccZNXG9vn+h6yDM2qJnEhcdLxal8GRxEXHwZFJGzNHCErJ+rOPHP25m2MmK21ERGQ38aMjka7CsVFxznHdHWAWM1mfo/3OWQXjRyIipyPLVzhSPkzONSE2AY5MkzEEqfcMzvD+J0dM2slBckYtkRMpXbWkailsXrPB3nn6emLvmkMqWKrSqCLK1y6j9l8+eRWHt5xQibjabaqrNWPtlbe/l2qN7BDtXshqTEYjXN1dseyH1fAt6INGXevCy9dLE1fYGus7OMr6EEREWlC8fFGH6cgiZB0yCRLlNdivkB8ad6sLDy8P1eVk1/L9CL8ZgSLBhVC/Y201+txeyVq2MruDtEW9/1l9MN37H2fH+JGIyPmUq1kaR7Ycd5gYUloKb/57p3oNrtasMspUK6X2nz9yCcd3nFLrwNZtXxNBwYVhrwoWKwAvP0/ERmq0aKdRsmat5Mjl/Y9/YT+Vg5T3P1qg01AOkoVaIifS7bkOmDvxbzgKmZH4xZBpls8r1S8PD293HN58/N6NdECzXg0x8qeX7bJFmBTGH3qpC3796E8YHWgkIeWOyQSsmLVObcLD2wNPjeqH/u/0gU6iJyIiIgchS1C0eaw51s/f6jCD/f6ZtiLVoLmGXepiz8oDiA6PseyXNbxenfIcWvVrCnvUcUBr/PD2r0iMT7T1qZAN3/9Ub1YZ7/zymhowQURE5Eh6vNgJi79bDkcRHhqJSc9OtXwuxVop2kqR1kzyOW0ea4bXZwyFt5/9DcZ393BD9yEd8Pe3/zlM3E7WsWRq6vc/gz/sr5ZaYQ7SebD1MZETKVY2CEMnDVIf6/UOUCxKU9c8tfds6iLt3dvsWLoXb3UYp2ZK2KNHRvZS69nK6LtUHOBHQNYRHxOPn0b9jl/G/amNS5rPLUc2btyIXr16oUSJEioIXbRo0QPvs2HDBjRo0ACenp4oX748pk+fnrPvlYhIA174fCAKlSjokLGMtN3b+Oe2VEVaEXY9HB8+9gW2LtkFe+RX0Bevz3hRXeN0152cV5o46MSu0xjRcjTCtNCdxwYt6xhDEhHl7YzagR88pj6WtWodzbFtJ1MVac3LXG38azve6/4JDEkG2KOn338UpSoXd8i4naz3/mfqiFlYOHmpNi6pRnKQfEdI5GQeHtEDYxe+iUoNKlj2ednhKLDskFFiZw5cwIY/tsEeefl4YtK6sXj8rd7wK+iTaj9HNmnL3AkLER4aAadmg/UhoqOjUadOHUyZMiVLtz937hy6d++OVq1aYd++fXjvvffw2muvYcGCBTn7nomInFyh4gXx3c6J6PliJ3h4uSfv1AGubo7dgEnyVTPe/EUl3exRpwFt8OmKMajZsqpln3TpIO2QdpF3bkZg0TfL4NRstL4YY0giorw14INH8e5vw1XRNuVsP0fPQR7ZckJNGrFHvgV88PWWT9BvRA94+3tb9qsYnsVaTZn9/jzERsXCqZm0k4PUmez1XWseiIiIQEBAAMLDw+Hv72/r0yHKcxG3IpEQn4hP+n+FI1tPqJYejkpG59VuXR2T1o6FPZMRdzIiXtasfan+W7Y+HcpnUph/dcoQ9Hqpi9O9ppkfr+Lb4+Hi4ZmrYxni43D60/dydO5yjf/++2/06dMn09u8/fbbWLJkCY4dO2bZN3ToUBw4cADbttnngA+yX4wfSWskdowIjcDxXacx7uFJcAZTdkxQ64Has6g70aotroyO37JoF9vZaUxg8QKYf+UHp3tds5f4UTCGpPzGGJK0RMoLkoNMSjTgnS4fqXVfc9oNwR7IbNVmDzXE2AVvwp4lJiQi/GYEQs5exxttPrD16ZANvPvra2j/ZKs8fxzmIPvkeQ6SM2qJnHzNscIlAhF2/Y5DF2mFnP/tkP+3dxfwUVxbGMC/jQtJSEjQ4O7u7u41ilUopd5Sd3c36i2PGjUotLhLcXd3CIQgcc++37mbXXZjZJP1+f59+8hOViazszNnzr333Ctwdd4+3mqbZ6ZnOXtVyAm8fLxwNdazR9Tq9La5GQM981t6erpN1lECoX79+lks69+/P7Zs2YLMTM4FSER0vbmvIquUQ1qSbY7JrkA60Lk6GR0h213iCM45pj0JcYnwZO4QPwrGkEREJSOdYcIiQ1WVFpUTce8UpIrFLsdchavz9TPE7empzHNokUx7yBwknB5D2ip+ZEMtkQZUqB7lHnPWXqc3W2SVCBzaehTH95xCTk6O6XdSalbmdzpzOMZlStvJupL2yIjqyGgP/+xtWHakatWqapSF8fbmm2/aZBXPnz+PChUqWCyT+1lZWYiLi7PJexARebqo6HLwFNnZOTi45aga6XFtWTaO7z6pYktXKhlWvlokvH14ma415SozfnR2/CgYQxIRlV5U1XJuPw2YdMKXahcSP57cf8Yi1yiDYSQHKaNYXUWUp+ehqEA5OXrmIPWek4N070mHiKhYBt7ZG9uW7nb73my71uzHfW2fMiWxBk/uiyPbj1mUh6vRpCpuf3UMOg1v6/TkZoteTbBz5V63H81Mxefn74duN3bkJium06dPW5Su8/e33bx8eS8MjRdW7n7BSETkKE27NVSJtrgzl+Ai/eBKxNffFy+OeEf9LA2gXUa3R43G1TDvqyWIO3vZNKdXv9t64s43xiA4LNip6zvgjl5Y9vMap64DOZgO6rqGnB8/qo+DMSQRUakMvqsPPrrna7feijlZOdjwzxb8N3uTul+5TkUMnNQbe/87gI3/bjPlF+q2roU7Xr8Vbfo1d+r6Vm9UFXVb1cLh7cfcfjQzWVeRp8OQ1txkHpKDZFddIg3oMqq9SrbJqFSruFh7RnZmtunn2FNx+OG5X7F21iaL8nAn957BiyPfwaLpK+BsIx8cyEZajel+c0cEhwbBk9mydJ0ESOY3WwVJFStWVD3azMXGxsLHxwflynnOCDEiInvy8vLCg5/fpQJCd+7kkpl+rdxUdlYOVv2+Hv974TdTI61IT83AvK+X4NGeLyE1OQ3O1LxHY1SsWd6p60COL1vY//YeHr3Z3SF+FIwhiYhKr++E7qjbslbhOcjCwkoXCzclbjQ6d+Q8vnvqZ4tGWnFk+3E8M/B1rJm1Ec424oGBbKTVmH4Te8AvwA+eTOcGMaSt4kc21BJpgI+vD96Y/ywGTeoNH79rA+l9fL3Rc0xndBzWBjqz0sgBZQIw6K4+aNq1Yb75V10tT5e31LHx/qf3f+f0MnYLvltufeM4ubW1szYiLcVz5vSzd+lje+nYsSOWLFlisWzx4sVo06YNfH197fvmREQeRHpov/rPU6hSt6LF8qoNqmDUw4MRUSncYnmDDnUx9N7+CHLlTkuFnIOk49+xXScx57OFcKYDm47g/PFYp64DOVZWRhZWzlzn2ZvdDeJHwRiSiKj0pOHo3WUvoPe4riqPaOQb4It+E7qjbf8WFo2ywWFBGHpPfzRsX9fiddRUEK6eg8zRQ/77cPKXyMxw7jyxC79fbpHbJc+3/Ne1yMrMgkfTu34Maav4kaWPiTQiIMgfD30xGbe/PgYHNx1RJezqt62NsEjDkP+4s5dwdMcJ1ZDbqFN9BAYHqOUy7+uZg+eQdDUZb0/4FO4iPTUdK39bp8o+O8Pl81fy9bQjz5eamKYaa/uM6+bsVfEoSUlJOHLkiOn+8ePHsWPHDkRERKBatWp4+umncfbsWcyYMUP9fsqUKfjss88wdepU3HXXXVi/fj2+++47/Prrr078K4iI3FP7Qa3QbmBLHNp6DJdjrqBc5XBVWk1G2U5+Zzz2rT+E5PgUVKpdAdUbRqvn3P3ueOxddwiZaRn4+7OF2LZslyoh5+ok2fbvl4txy5MjnLYO879ZqhKT5qM4yLNJgnful4tU5weyLcaQRETOIVNJPPHD/SpWPLTlmGpAlIZYKdUqLpy8iBN7TsE3wA+NO9WDf6BhZJvMBxtz9AIun7+qGj/dgh5IvJyE9XO3oNsNzpkK6+yRGOxes98p703OczU2HpsX7kDHoW34MXhA/MiGWiKNCY0IQdsBLfMtj6xSTt3yiq5bSd02L9oBd+Lj442YYxec9v4XTsaxkVaDvJ283zmELXqjWfn8LVu2oGfPnqb7EvyIiRMnYvr06YiJicGpU6dMv69Zsybmz5+PRx55BJ9//jkqV66MTz75BKNHjy7lihMRaZM0ytZvU7vA817eCixCkm2tejdVP3/z1M9u0UhrFHvaEMM5q9zz2cMxbKTVGj1w4cRFeDQnxI+CMSQRkXOVjQpTHf7yqlA9St3ykk5/clv1u3tVmpBqejHHnFcRxZnvTc4jHSCYg/ScHCQbaomoWELCDb3e3IWUr5OeetlZ2RalVhzF3bYX2UZOjmG/82Tm8zuU5jWs0aNHjyI7PkiglFf37t2xbdu2kqweERHZUGi5MqrR012qjASWCVTrKjeZp9fRQsqVUck+iWVJO4JCA+HJnBE/CsaQRETuqYyb5dQMuaAg5iDJ4dWAmIP0nBwkJ08komKp16Y2yleLdJutlZOjx69vzsYAv1swInwivpw6XZV3dpQqdSuhZtNqThuNQc7T9YYO3PxERES5et/aVZV2dQc6L5kuxA8DfG9Wt0e6PY///t7k0HXodUsXNtJqcDREX06bQUREZNKseyOElgtxmy2igw5fP/6jykGOirwd3z71E67Exjvs/eu2roXyBYxQJs/m6++DjsNY9thTsKGWiIp3sPDywp1v3Oo+W0sHNa+ukHnTZn+6AFNaPaHmbXDI2+t0uOP1W90mMUm20WVUe0RWjtBG6brS3oiISBN6j+uGyrUqqHlXXZ0+ByqpJh2o5Sbz77406l1Mf2Gmw9ah88h2qNWsuhpVS9ogn/WIBwfCozF+JCIiK/j6+eK2V252o22mR0piqvpJ5qv94/1/cG+bJ3HxjGMGjLhdzpZsou/4HggJL+PZW1OvnRwkr/6IqNh63doVj3x1N/yD/FVDqJQUlgZJSbw17tzA7L7jSw3nk+cgLOXjJFh6Z+JnDluFDkNa4+kfHzSVMlPbx4sjbD2WDti//hCys7Ph0TQUJBERUekFBPnj/ZUvo27r2qZGKWMjZOU6FUwVWySedIXGSSkhZmQsP/zza39hz38HHPL+Pr4+eHvJ82jazTD3r2wTd2jkppLLzszGvnWHPHsTMn4kIiIrDb2nP+5+bwJ8A3xNOUj518fPW+UgJUaSHJsr5CDzVkmVGPLK+Sv46O6vHLYOvcZ0yZezJc8l+ffda/a5zfQyJabXTg6Sc9QSkVUG3dUHPcd0xpq/NiL2VBzCokLR7YYOCIsMxdWL8Wp5/MUE9bsF3y1zqa0rgZKMjDi++yRqNq3usMZtGRmxdtYmNcF7Rnomfn1jlkPemxxMD8SdvYzNC3aoRnoiIiIyiKxSDp+ufwMHNx/B9uV7VGNoky4N1E2SC9uX7cbBzUfh5a3Db+/MQdIVQ1UUVyENpXM/X4gmnRs45P3KRoXhvWUv4ejOE9iyaKea72z93C04tPUoyyJ7IC8vHWZ/Ml9dNxAREdE1N0wdioF39sLqPzfg0rkriKgUrnKQMi/npZgrWPPXBiRfTcHpQ2ex/Oe1LtVolZ2Vg00Lt+P8iVhUrFHeKTnblIRU/PH+XIe8NzmW7OunD57DnrUH0LSroYMnuTeru+auXr0aQ4cOReXKlVXL/d9//23x+6SkJNx///2Ijo5GYGAgGjZsiC+++OK6E/TKa+W9DR482PSYl156Kd/vK1asaO3qE5ENBJYJRL+JPTDu+RswdEo/1UhrTCrJfVnuH+gHH1/X7L11ZPsJh76ff6A/eo/tqrZLtQZVHPre5FjSY/HI9uMevdl1etvcSFsYPxKRqN+2Dm55cgTGPD1SJRTkmk5KtbXu2xy3PjMKfSf0cLlGWmOiTRqSHa128xq4+YnhattcOBnLRloPlZOjV43ynozxI5UUY0giCg4LxsA7e6uc2qBJvVUjrShXKRwj7h+Isc+NVvGkztsFK9jpgWM7TzotZ1uhRpSKt8kzyYhy5iDhMTlIq0fUJicno3nz5rj99tsxevTofL9/5JFHsGLFCvz000+oUaMGFi9ejHvvvVc17A4fPrzA15w1axYyMjJM9y9duqTe48Ybb7R4XOPGjbF06VLTfW9v12wEIiLAL8A3X+kPV5ps3Xnv7eu09ybH9Gjz+M/YFmVDXPTYQPbD+JGIXD1GK05s60weH19onI+f6+77NsH4kUqIMSQRFYevnw90Uu/XBanSzc56b3/JzTIB46mYgywmN/kKWH01MHDgQHUrzPr16zFx4kQ1SlZMnjwZX331FbZs2VJoQ21ERITF/ZkzZyIoKChfQ62Pjw9H0RK5ifZDWuP391yvvIaM8m3Vp5nT3r9l7yYqEZOVkeW0dSD7ltfuMKQVNzFRHowfiag4QiNC1Kjbw1Li12yuWGeTOdBkKgtn6jyiHeZ8vpCjaj2QlNbuNLyts1eDyCUxhiSi4ugwtA3mf+ta06+JgDIBaqoPZ2k7oIUadSnTjthO3gZx14nZtUY6J7Qb2MLZq0HOKn18PV26dMHcuXNx9uxZ1aovo2sPHTqE/v37F/s1vvvuO9xyyy0IDjaUMjA6fPiwGplbs2ZN9ftjx44V+Trp6elISEiwuBGRY0g5u3ptaqvEgyuR8h+h5UKcmoAccndfFSiRZ5EkbrtBLVG9UVV4MpauI3tg/EhERlLm15UaaYXEsxK/OdPw+wfA29eb5es8jLEc4Q2PDIUnY/xI9sIYkoiE5GKqNqjicjnIYVP6ITA4wGnvHxVdTk3F5mWzHGTu60j8wpLKTs9BynzE5atFwZPpNDT9ms2PXp988gkaNWqk5qj18/PDgAEDMG3aNBU8FcemTZuwZ88eTJo0yWJ5+/btMWPGDCxatAjffPMNzp8/j06dOqkyyYV58803ERYWZrpVrerZyXMiV0s6vPbPU6ZGKy8fL3UOlxOJnNeDQgMNy71z55320qnHSFk5433VmKkD/IP81PMksFBzmclrlGilgITLiXC2ye+OR9dR7dXPKojU5f4LICzS0Igs91XcwwZdlyX7rvln17BDXTzz80PweHob3YjMMH4kIiMZWXjPh7cZYkNvs/gRQEhEmevGT+bLjZ3zvEoZV2VlZiMlMc2pH1KVOpXw2tynVFxsESvLaI1gfxUnG7ZXKWJlcgjz6x+ptPPszKmo07KmZ299xo9kJ4whicg4PeJbC59FpVoV1H1TDJkbLwWWMTSWGu/LedjH30edh433ZZ5bIY8tKA4tUQ7ySpLTP6CHvpiM1v2aFxIrl7EiVjZrpCUn5iANU4G27NUED391t+d/Enrt5CB97BEkbdiwQY2qrV69OlavXq3mqK1UqRL69OlTrNG0TZo0Qbt2lqWlzMstN23aFB07dkTt2rXxv//9D1OnTi3wtZ5++mmL38mIWjbWEjlOeIWymLb1bWyctw1rZ21EalIaqjWogoGTeiOiYlms+mM9Ni/crsoA12tTBwPu6KnmlVgyYzV2r92vzv3NezRRvb/kuQu/W46jO4/Dx88Xm+ZvQ3J8inUrpAf+m70ZsacuOrXHka+fL577bSoObDqCJf9bicsXriKycgT6TuyBuq1qYuuSXVj12zokJ6QgLTkdWxbtcNq6UuHa9G0OvyB/lAkLQo9bOqNl76amwJ6IrMP4kYjMjXposCr1u+DbZTi5/4xKmHUZ2R7tB7fCqf1nsOiHFTh/8iLCyoWg19iuqpLLvnUHsfSnNbh6MV6NHuh/e0/UbFoNWxbuwKo/1yM1MQ0pCanYvmwXrJ2qS5JW/0xbhPs+ucOpH5RM3/HLqS+xZMYq7F13UCUbW/RsorZB8tVkLPhuOY7vPqmSjhv/3YaUxFSnri/loQPKRoWhRa/GyM7MRv22ddH/9h5qGRGVDGNIIjKSPN83uz/AujmbsW7uZmSkZqBmk+oYcGcvlAkPxopf/1NxYHZ2Dhp3rI++E7urPOGi6Suxf+Mh1QDWuk8zld9JuJRoiEP3nVZx1bq/NyM9NcO6ja0Hls5YhbveGufUyn4BQf54fd4z2L1mP5b/vAZX4xJQvmokBtzRC9UbR2PT/O1Y89cGlXeVPOuO5XsKmNe2sEZaN2kB8wDtBrZS1XWM1z/NujVipR0Po9OXYkZp6W0ye/ZsjBgxQt1PTU1VI1dl2eDBg02Pk9GxZ86cwcKFC4t8vZSUFNWg+8orr+Chh64/Kqlv376oU6cOvvjii2KtrzTUyvrFx8cjNDS0WM8hItdz+uBZ3NHw4RI//6kfH1SNv+7gzXEfY+Vv6zgfmYuRHpW9x3XFEz/c77R1cPQ5zfh+De99A97+pSvdk52ehv3TnuH5WKMYPxKRs7w06h2sm7OlgOTT9UXXr4wf9n8Md3B8zylMbvaos1eDCjHz7NcoVylcEzEk40eyJcaQROQMBzYdxgMdninx81+d+xQ6DGkNd/DskDdUw21+BZQ6VvE0G2odQRpoh07ph/s+dl6nUeYg7c+mQ38yMzPVLe+IIik/kJOTc93n//7772pe2XHjxl33sfK4/fv3q4ZdItKWkncvMT7ffQIJd1pXzdHoR6Oz0Y3IiPEjETmKhFX6Ep7A3Somc6d11SC32pdshPEj2QNjSCJyBG3lIJ29BlQojX42Og3lIK1uqE1KSsKOHTvUTRw/flz9fOrUKdUbs3v37nj88cexcuVK9bvp06eruWVHjhxpeo0JEyaossQFlT2W0bnlypXL97vHHnsMq1atUq+5ceNG3HDDDaolf+LEidb/1UTk1irXrmCai8xqOqBx5/pwF027NCxWRxdyrJzsHDTp0pCbnaiYGD8SkSuQc7eMyLKWzOPVsmcTuIsq9SojJDzY2atBBahQI0pNAUNExcMYkoicrUaTqgjIneO2JDFkg/Z14S6adW1Y+Dy1eVtxOVetw8iUGU26Mgfp6axuqN2yZQtatmypbkLmgJWfX3jhBXV/5syZaNu2LcaOHYtGjRrhrbfewuuvv44pU6aYXkMadWNiYixe99ChQ1i7di3uvPPOAt9XSiePGTMG9evXx6hRo+Dn56fmwpV5cIlIW3x8fTDigUFWJ9qkXG3HIW1QqWYFuIve47ohODRIzUFGrkGCVpnfpOeYztAkvY1upCmMH4nIFch8oP4BflbHkDnZegy7bwDchZ+/r1rfkjRKk33d8MjQfBXINIHxI5UQY0gicrbA4AAMmdy38AbMInKQvW7tivDy7jMXvczn6+vvW0AMWVgSh7Gmvcl+VK5yODqPaAtN0msnB1mqOWrdDeeoJfIcWZlZePXmD7Du783qpCUjHBWdlFv3QnZWjgqi9Dl61clLDnTVG0bj/ZUvIyzSveao3rV6H54Z9AYy0zNNf6f0ylN/o04HL2+d+tl8ed6fVbccDswtEZ23Dvpsw6lS9jX/QD+8ufA5NO7k3JHZzpofovEU28xRu/dLzlFL7oHxI5Fn2bpkJ54f/rbqmZ43riroZ2mkffS7e9D/tp5wJ5kZmXhp9HvYNG9bAbGyN7Kzss1iZZ0qy+ftY5iySJaph+b+nqynrj9yN51x+/cZ1w2PT7/P6Q21zpijlvEjaRFjSCLPkZGWgeeGvoXty3argRQ5Eh9JG6Ve4kVvZGdnG+7qr8VP9drUwjtLX1SDL9zJ5oXb8eLId1Q8nC9W1nlZxMqSj1SPUXGkWQ4yd9uQ9czjb4khg0IC8e6yF1GnZU2nbk7mIO3PxwHvQURkl1G1L/zxqGqo/efLxTh94CyCw4LQe2w39J3QXQUW879dhounL6meRwPu6IU+47upnnDuplm3Rvh+34eYO20R1s7ehIzUDNRrU1uNlAivEIY5ny3ElsU71Im8Rc8mGPHAQKSnZuDvzxZg37pD8PHzRnpyOq7ExjPZZi0dUK1BFaTEp8Iv0A/dbuiAIVP6oXzVSLt81kRERGRfrfs2x3d7P8Q/0xbhvzmbkZmWqUrSDb9/AMqUDcbfny5QSTiJAVr1bqaW125ew+0+Fl8/X7zy9xNY+9dG/PPVYpw9FIOQ8DKqWkuvsV2wef52zP9uGeLOXEZklXAMvLM32g9ujeW/rMHSH1cj8UoSQiLK4PjuU87+U9ySX6A/oqqWQ1pSGmo0qYZh9/ZHhyGtOcqZiIjIDfkF+OHNBc9i1e/r8O/XS3Du6AWElQtR+cceN3fG+rmbseD75bgccxXlq0Vi0KTe6HVrF/U8d9N2QEt8u+dDzP18Idb9swVZGVlo1LEeRtw/EAHBAfj7s4XYvnyPimna9DPEyldj4zHn84U4tPkofAN8kXg5CUlXkt1qfl5XUb1RtNp2gSGB6HlzZwy+uw8iKoY7e7XIATiilojIwyVcTsToyDucvRpuS+Y0/mjNa3A1TuvNdreNRtR+xRG15B44GoKItOrDyV9i0fSVavQtWe/j/15Do47OrcDiMiNqGT+SBjGGJCItijl+ARNq3+/s1XDb0bTtBrXCa3OfgqthDtL+OKKWiMjDyQhcKrm05HRuvrzYKZKIiMjjpadlcCREabYfY3BLjB+JiIg8HnOQJSeVEtNTmIPUagzJhlonOrH3NHas2KO+hDJiq17r2upCeP+GQziw6Yiqcd+6X3NE162kat1vW7obp/adQUCwPzoMbYNylcKRkZ6Jjf9uxYWTFxFaLgSdhrdVJbtSElOxbs5mVXogKrocOg5ro8otSOnT9XO3IDUxFdH1K6NN/+ZqjiIi8lzhFcoiJDwYiVeSnb0qbkfm2KjbqpazV4OIyCQtJV3FcpfOXUZExbLoOLytKusv1RPWzdmCpCtJqFSrAtoPbqWmCbh45hI2/LtVXTDXbFYdLXo2VvMjntx/RpV3lTmFZM7t+m3rqDhUYlCJRWU+nNZ9m6Fq/Spqzkp57Ik9p+Ef5I8OQ1ohsko5fipEHq5W0+pY/staZ6+G246IqNYw2tmrQURkcmTHcexevV+VK23eoxFqNq2uYr9dq/fh6PYT8PX3QduBLVGxRnlVSWHzwh04c+icmmJKcoplo8KQnmqIQ+POXlZ5hk7D2yCwTKAqly85SCl3WqFGeRUrSgn+uLOXsHHeNtX5uXrjqmjVp6nT5+kmIvuSY4BcM163wdH8WJCTO7et0OmuTXKrsdLJXj5ebjnlCtkGG2qdQBpL3xz3MbYv3W2Yo0Zn6DEhyTOp+y5zbcqFneF4pFfJswun4hB35pJhwnK9Hl73fYvmPRrjyPbjKhCSZJok2nz8fdCiRxPsXr1P9eA1Lg8KDUTD9nVVw7BM7G1cLnN3PjH9frTq08wZm4KIHEA6fci8qjPf/ptz1FpJjpey7egand5wK43SPp9Iq+Z9vQRfPT4DqYlpplhOOvA16dIAO1bsVXGkcXloZIhqZNm5aq+KJ710OuTk6FGhehQiKpXF/g2HLeJQmUNRn5ODk/vOWMShDTvWU3NYXjwdZ4pDP7lPh/639cQDn0+Cn7+vszcLEdlJv9t64Ptnf0F2TmEnbjmGyPEi9/fqZ7NEm0ZJkq3jEEPHajJg/EjkPNJp7/VbPsTedQctYrx6bWqpeRBlrk3Dcr0atNSsa0OcPhSDK+evmuJK73u8VWe//RsPIyUh1bTcL9APzbo1ws6Ve5CZfi0OlTnO67SsoeJTizi0RhSe/ukhleckIs8UEOSP/rf1wD9fLjHkIM1jReGlg87bW12LyvFB/Zujh17FkNJAa2BYngPkaGcKDjl+Dp7cx9mr4VJ0GspBshuTg2WkZeDx3i9j58q96r4ckNRBC8DxXSdVI61arg5QhuUSTEkjrZDARiIn+eLKyAZppFXLsw0XxFnpWdiyaIepzJJxuQRSW5fsUo0O5ssvn7+KZwa9oYItIvJc7Qa30lxPtNKQxggx7vkbUL9NbWevjmvR2+hGRFZZNH0FPprytWqkNY/lZITClkU7VSOt+fKEuERT5RYVO+bGm1KFRRpp88ahJ/acUo20eePQ/esPqUZa9dq5ryW/l/V5e8Kn/BSJPJiMnpLOxAW7lkhTCbi8STiNUB1ezEgjRUTFcNz/6R1OWyeXxPiRyCmSE1IwtfsLOLDpcL4Y79CWY6qR9tpyw3d11+r9qpHWPK6UEbaSU5TcovlyqdgiOUhppDVfLrnK7cvyx6EXT8XhiT6v4Pjukw7eEkTkSO0HtzYcU4xxkjFW9PKCl49PgXGUTuel7htv+UbaejCJH8XkdyaoilakzRiSDbUOtmLmfzi59zRychtMnc0YpM148TdnrwoR2dEf786FjiWGCiVBYFhkiOl+3da18fzvUzHx5Zu5XxKR00ly7Lunf4YrkRhy9R/rcXTnCWevChHZiST2j2w7XvAvjQk3C26SBbEhL28dvH0NUwlJFauRDw7CtM1vsTw8EbmERT+swIUTF02DNpxNGmyzsrLw8xuznL0qRGRHv7071zQAwpzO28s0itbI2HkkL8NyD40tdVBTWBpJlYFX5z6FGx8d6tTVIudi6WMHW/rjalVSxDh6wRVIj7ctS3Yi4VKixUGCiDyDzFm94Z8tpl6sVHAAKPN4z02YoRq0pVQLFUxLZUeIXIXMHXblQjxcsbT+8p/XcB4dIg+17Oc16nsunUUs5Y6ezddQqz3S+PH0zw+i3cBWCAwJgLe3odGWLDF+JHKOJTNWFdoI4iwycGXtXxtUxUG5Biciz3Ip5gp2rdqX/xeqj58VsaMnj6bVAxEVy+LHY5/D28cL/oHMQRZGSzEkG2od7OrFeJdqpDXRAwmXk9hQS+SBkuNT2EhbDHIMDCwTaP8PxN3ZolOjC54GiVyZlDF2VfEuvG5EVDpSurLQBD8baU2bIelKCsqUDebuVhTGj0ROEX8xwWU7uSQnpLKhlsgDGadpzM/aDn6enTiKj0tAUAhzkNel104Okg21DpCVmYXD246ruRsiq0Tg1P6zpnkbXKkWeuypi7h07jJqNK6KsMhQtTw1KRVHdxhK2tVuUcMlGzFkzo1jO0+qkcp1WtY0jYS7EhuPU/vOwC/QD3Vb1YSPL3d30iYp6esb4IvMtExnr4rLkl59FapHOns1iIgsSGwmc4dlpLvm8VsacILCAtVcuCERZVCrWXV1PJXlp/afUaOAJfaNrlcZrkbWUebllYbmqKrlUKVOJbU8OzsbR7afQFpSGqrUrcjypaRpFapHWS7w8TF8x2WErfmIWuMo0rylNY2/d7HRXLYkf1qFGnm2ExGRE0nceGTbMWRmZCEyOkLl+Vytupbk6SRWPH3gLGo2rYaQ8DJqeXJ8Mo7uPKlylOb5PVeScDkRJ/acVhUnJNdoHBUcd+4yzh6KQUCwP+q0qskKC6RZ5SqHq++wse1DH+AHfbA/kJkNXWqGqblW7+8H+PpAn5kJmC2Hjzeg8zIMg8w0zH/taaQNo2LNCs5eDXIxbLmycwJo1kfz8Otbs0292Fyt7LFQc3l7e+HJvq+q+xJsdL2xA8qEBmHJj6uRnpKulvsH+WPI5D64441bXaLXW2pyGr554ics/GG5qQFKyk31Hd9dNdL+N3uT6aQQFhWKMU+NxKiHB1tXZoHIA8j3tc+4buq7os92reOPKxk8ua+zV8EtaKnsCJGznDpwFp8/+B22Ld1tWiZzIGZn5i0/6lwSZ83+eL66ieh6ldBzTBes+3uTSrIZ1W9bB/d8eJuae8cVbJy/Dd888SNO7jtjWta4c3206NkEi6avRNyZS2qZxIztB7fCvR/fjkq8kCYN6n97T/zyxizoAgPgFRSkpocwXufqMzKgz8iCzs/XdH2llqenA1lZgJeX5fLsbM8rYacDwsuHoU2/5s5eE5fH+JHI/nJycjDzrb/x5/tzkXglWS1TjSUuloOUY6fEkI/1fEnd9fHzQc9bOsHL2xvLf1mLzPRr+b0R9w/EhJducomBF0lXk/HVYzOw9KfVyMowNB4FhwWpc+W5o+ex8d9tpioU0lA17vkbMXhyH+YgSXOk40WXke2wetFOZDSMhj4q1NR5LyslHT4n4+AVFAwEmw0GS04Dzl5UxwGdz7Xve3ZaGvRX4z0uhpS2ITk+0PXpNJSDdP6ZzoNJAuiP9/+xWOZqjbRC4ghjkCFkDqKVv/6X73HSYDvrk/k4vucU3pj/rGrQdZbMjEw8PeA17F9/WAWjRqmJaZg7bZGhmoLZppaG8i8f/R8ux1zBXe+Md85KEzmRBAALv1/umZ9Bnu+7cTRXccnFq/TiHXQXg6Ri0VDZESJnOHPoHB7s+AxSk9IslrtaI21BzhyKwY8v/5GvqtXhrUfxWM8X8e6yF9GkS0M405pZG/Hqje/nW75v3SHs/e+gxTI5l2xasB37Nx7GtC1vo3xVVl4gbalcuyIa926Bg7uudWowkkZbnYyEyLtc/q+geVrdJMFWWByZd7mxEfqhLyY79brYbTB+JLK7j6Z8jQXfLrNY5mrV/JQ8OUj5ecmM1fkeJvk9aXiWDowv/vmYUxs8ZaCIxLLH95y22KYyzZQM0JFVMz91XDp3BR/f87UqbTr22dHOWWkiJxr0yGAsTUyH3ltGxuosq7NERaqYyvwbrdPr4e3vnz8Gy8hwnRgyT+7xusuLyEE26lgPvW7tYsu181x67eQgDV1iyeZOHzybr5HWE0hDs4zuWDtro1PXY9lPa1QyzbyRtjhfwN/fm6sSoERaM+/rpW7fkzPv6tduXh0TX74JVetXsVjepGsDjH1utCq3aXqulw6dRrTFqEcGW8wh5uvvo3rAvr/yZZcsq0RE2vPtUz+rRlqXTKwVV544TEZyZGfn4ON7v7GqI409piP5RNZB/suzHoWtl3wOSVeSMOOl3x20lkSu49zx2AIbaVU2uqCvjIyaLeC7pEbTOovOUJHASFWJursveo/tCh+z5VK+/cZHh6lR9OYxc/lqkRj3/A1q1L256o2j8fq8p9F5RDsH/SFERIU7uPlIvkZaTyDxmVTL27J4p1PXY/7XS3Fs16lC4/PCwtv/vfgb4s4aKrUQacmcVfuh8/cBvMwSeXo9fJINMaFFfjJHD6/LSSq0NF+uz8qCPslQHcAZJI9orn6bOpjw4o2oVNusZLEOaN2nGW55agTKlg8zLfb28UL3Gzti+P0DVHUAI/9APwy7pz/eXPgcfP18HfOHkNvgiFo7Wfj9CvWlzM47T48HkJ4f875Ziu43dXLaOvz79ZISlZGWz2TRDytw55tj7bZuRK4mIy1Dledx66S/osO4F0ajRY8mKFshDNUbRqulY5+7Qc0zmHApCeWrR5rKU45/8UbDPIPJaahavzIiKoar5Xe+fiuObD+ujs8ykta84ZaKQUO92YgcTXrdr5u72SUrsJSW/E0yn9fRHSfUnGPOsHnhDlyNjbf6eXK+WPbzGtz/6Z3s1EOasvjX9RZzjJkUFlNKyeM8VCcIZ46E0BsaYWU0liQIazWvgaAQQ6k9KWsuxyUpuynzDBoTZmqewcMx6nG1W9SAl5cXJr58syptefH0JTWtTvVG0W7fCdKhGD8S2dWC75Z7bg7Sx0s1Qrft38Jp6/DvV0tURz9ryXli6Y+rcctTI+2yXkSuKDEpDas3SAVMy++MLlsPrwKmY9OlpqsRtXnpU1Ph7OvXu94ep6bxkXLm0fUqq+XjXrgRR3eeUCPqK9WqYKq6JLGi5Boz0jJRrWEVlI0yNNxOemucWp43DqXifhDQTA6SDbV2Envqokcm2YRcqMccveDUdbhwomTbV55z/uRFu6wTkauKj0s0zePszuTCMz05Hc17NM538VOzafX8j/f2Rv02tQucs7dRR9eYJ9EdaWl+CCJHizt72WPjR6PzJ2Kd1lB74eRFq8vjm5flk0beijXK22XdiFxR7JnLhWQ2CvkOOXHEfFGuXohHww51VWxoLjQiBM26Ncr3+MjKEepWUClouZH1GD8S2deFk7Ee2UgrcrJyVEcZZ7p4Oq5EiX4ZYHL+BHOQpC1xl5MKnBtbGmoLlJVtGE2bZ7E+y7lT/8jUFpkZWQXmIOu0yH89K3NpN2hXN99yqd7XpHMDu66rJ9NpKAfJ0sd2EhIRoubt8UTScTgsKgTJCSlIT023+J2UIk6OT1ZzyJrLzs5G0tVkVXLOnNyX5fJ7cxnpmep1CkukhZYLKdm6e3khNKKMes9865hlWEf515w8TpYXWmaZyMUFhwXBK0/JDnckgV5Ybo80IiJPVNL4xt3OSQXFVVL9QWLLvLGfzAmWmmTZm1oeU1QcKnFkYdu3pKWX5YLcL8C34HVMSlXrWdA6yt9F5K5Cw4MtS9BJRwdvHSxnFctd7sKjS6XkXN5GWiIiTxIWGaoqIHgiyWWULR9qiPHyxFUS+9kiv6fi0CJykGXCS1iFS69XVR2syYfKOsq6MAdJ7iqkzLVSv0Kn0yMwMB1evpbfO70OyPaDYR5b8+VykyqaTm5XkYFqcmwlchSOqLUTmfPmny8WwRNJ3HLu6AWMKDtR3W/WvRFGPjBQlRj996vFavSeBFIdh7XFwEm9sXnBdiyavgJpyelqPsheY7qossnLflmDVb+tQ1ZmNoJCAzHwjl5o0bsp/vlysXqOjCgJrxCGoff0x42PDbMoNddvYg9898zPVo86kSBNyo7MnbZIBbFdRrVD/9t6Yv3cLVgyYxXSUzPgF+iHvuO6ofPIdlj0v5VY+9cG1TMxuGwQBt/VFzc/OVz1viZyF1JWo8PQNlj/71boJS7y8ro2oshYjk5yazqd5XIXGxUh3/ceNzuv5Dppr+wIkaNFRZdT8yDuW3fQ1Q7BNiENnU/1f01d9ErSSuaJrN+2Nv7+dCF2rNhjmg9y+H0DVIn7WR/NU6WSRfXGVTHqocFIS0nD35/MR8yxWLW8SZcGGPngIFW+dO4XixB/MUGNXpB5Jsc8PQqNOtQzvX+HIa3V/JTpKZYNvNcjr1cmLAg3V56s7leqVR4jHhikGn9kHeW9hZRIHf3wYFyJjceczxYi9lScWt6iZxM1b1Hrvs1ttCWJHKPn6HaY8+0KZIcEILNiGHJCAw29djOy4BNzBT5X04CwMkCAn+EJ6RlA3BVAOlf4+KhOsrrcOcZy0tIKLI1sbzpvHfqO7+7w96U8GD8S2VWvW7uqaRo8kXTYPrj5KEaE36ZOQa36NFOx4p7/DmL+N0tVY6dU3+oyugP6T+yh5rRd8tNqZKRmqPkg+4zvjs4j2mLhD8uxdtYmQxwaHozBk/uqagtzPl+IbUt3q/eKjC6nXnvUw4Ph5+9rkYP87Z05Vk8nJbnEvz+dj5lvzVbzoksutNfYrlj9x3os/2UNMtOzEBDsr/KSbQe2VCWe18/drP5m6WA4dEo/3PTEcJZKJbcSGVEGLZpE49CxY+jVawu6dNmD4OA0ZGfrsGdrDcxf0BoHykcisSGg99VBlxWEkK06lFuVBp1XIPTS0Ctf9uwo4NxF6E5dMJVGdmTOUo4rXUe3t+t7UDHotZOD1OlL2q3cDSUkJCAsLAzx8fEIDbVvjwjZrFNaPY5jO0/C0+m8pAHF7GBpWm6YQ1Yabc1LHnh565AjdenzzHdkenwBy+u1ro13l7+IwGBDr5zEK0mY0vJxXDp3uVTlXQp7z8LWUe5XrFkeH//3mqnWPJE72LPuAKb2eNlwcjIfGaFabg09MCxGTEjjrYudHiTp/to/Tzt7NTR5TjN/vxbjX4e3n2UPSWtlZ6Rhx4/POmzdidzpu7bh3y14ftjb8ETGuMt0Pzd2LHAOzAIef+0X1y62jI/JG4eqUSU64MU/HkOn4W1Ny39/dw6+efKn4q+zznA6LGxdLN7XbL3MGf++h7+crJKCRO7knls+wb6E3FHtxlhRr4dPUgZ8krNyvyC5yyV+jLsKyAhzs9hSRgXpk5OlzJJT5jb8bu9HiK5byeHv7aoceV5j/Eha5sjvmhxnb6v/oNOnKXMEU+yXN66Uig/W5BoLiUPl8c27N8br858xNdZePn8Fd7d4HAmXEq1rrM0TGxaV9ywwN+nlheqNo/Hh6lcQHFbCUb1ETrBr/z6cSxiDChWuwMvr2pfgbHIYntkzEokZAWrUrJH/WT0qLgB0WYbvppHu4hXoDhk6xRqXOqqhts+4bnhyxgN2fQ93whyk/XlmXQwXcOXCVZzcewZacK2dx/IAaQyY8tallwZQw785BT++gOWHtx7Fb2/9bVoWEl4GH6x6BXVb1zYFNcYDeYP2dVRjqnG56UheQDWuwt6zsHWU++ePx+Lbp34uYosQuZ7NC3YayrHnKUunBtLmXqQgb9DjYvb+d5AlJInI4234d5shfvFAeRs6jbFjYQmvQiun6PM/Jm8cKq+pz87BW+M/sShLLFVaJr01To2wEMYygWXKBqF132aq57RanvsZGF+2sHWxeN9CVtf4931y37eIO3up4AcRuaCr8Sk4lJJhiB/Nk2ZZOYZGWnXH7HiVkgZdclq+2BIZGU5ppDV+/7Yu3umU9yYichTJU53PrTbi6UyxX9640tpco77wx+9ctVdVRzGKqBiuGktrNqlqloM0/K5xp/qIqlpO/Ww+5ZQ6D+aJDYvKexa0XBrgT+47gx9f/qPIbULkaiIq/IKKFa9aNNKKr453Q1KWv0UjLXKA8it00OVcy+0rmVnQHTa0reS7OrZ3zlIHbF++O19pciJ7YuljO1n4/QrOJ2BD0tgrJZHHv3ijmsxbVKgehU/Xv4HD246pBhwJlFr0bIzqjaqqgGvXqn04uvOEOnZ/+9RPyMqwTaktCZykpMyU9yeiTFn2aCPXJyW///l6af4ksws2xhZFShqt+WujKi1PTqShsiNEjpaSmIrFM1ZaPbUDFUxOc9JIu3Lmfxh4Z2+1TC7+b35iOIZM6aumvpBSyVJuuf2Q1mrUhHS2XP/PVqQlpalqFFI+z9oyd0VZ8N1yjH/hRn5k5BbmL9mN7AKOR97JmYYiLXl/kZCcb7lcl+nTrSs3bmt/f7ZAlbIkJ2L8SGRX875eahiVmdtYSaUjsfjfn83HDVOHmBqOoutVxhfb3sX+jYdxcNMRlZts3a8ZqtSppPK/Uj751L4zqmFHBnfYKn6U15n/7TLc8cat8DNONUDkwrJzUnA5+TfodJbfgZjUUOyOj873+MAzgE9y/teR0bSqQkveXzgil6kHLp27gs0Ldqjpc8iJ9NrJQbKh1k6O7zlVWPUzKiEpMRIfl6B6spmr26qWupmTQKp5j8bqdmTHcZs10hrJ6507el6VZCZydVcuxCPpSgFRT2FctAFX5nQ5tuskG2qdTCcVDku5i5T2+USePBoiMy3T2avhUXx8vHF896l8y4NDg1Q5q7zCK5TFoEmGRt3Ni7bbtJFWkn5yjUDkLo6duGgq/23OK6uApJnIyCo4mebM2FIPnDl4TiXOvb0NHX7J8Rg/EtnX8d0nbRqzEBB7Mk5V9PIP9LfINTbqUE/dzEmJ4jb9mqubjMa19WeRmpSGi2cuqUZhIleXmX0Gev21ikZGJ1MMI8/z8rsM6KV4S95wUaoiFdS44qC4UiotyXUkG2qdS6ehHCRLH9uJf4Cfx5atc6aS9B4zlrazNXu9LpGt+XnIvpqj1yMg6NpFEhGRp/GU47Urkev4ksZskpizZTwvr8X4kdyJv5+PZQk6o/zVHHOXF/RYnUt09pMkOhGRp/IPsm3MQoa4zcfX+vFNzEGS1ul0AQUu9/cqeBCVXvrRFRRYOjl2k+qevHYjR+KIWhuO9pz/zVJVEjfxSjJCy5VBdhZ7s9mMDihXKRz3tnkCWZnZaNy5PobfNxC+fj6qlNWulfug89ahbf8WGHbfAFWeYO60hTi89ZhKepYJD7ZuROF1VKpVHlUbVLFYdnLfaTWHxaaF21W5mabdG2LE/QPRoF1dm70vuQYpdTNH9rvV+1UPq7YDWmLYff1Vj8u5XyzC0e3HERDsj66jO2DQXX2wb/0hzPt6Cc4ejkFoRAj6jO+GnmO6YMM/W7DwhxW4dO4yIqPLYdCdvdF2YAss/XENlv9iOJZUbVAZQ+7uh7qta2LeV0uxdvZGZKRmoF6b2qqEW9kKZTF32iJsWbQT+pwcNO/ZWO138pg50xap9/b29UZEhTBcvhBfwF+jg9400fS1Za5YDyAnKwdrZm3AvG+WIKJiWfS7rSf639YDgWUCnb1q2qKhsiNE9iYlQbct3aWO44e2HFUxS0h4sDr+k+3K/2+cvw1LflyFsuXD0G9iD3V+XvPXBiz+30pcjY1HxRrl1fm6Ra8mWPT9Cqz47T+kJKQiJCLYpmWoZXRFp+HtLJbJSI2lP63Bgu+W4eLpOERUCseA23uh78TuCAwuOMlB7ik5PlmVvl4yY5WqElSpdkU1ert590Zq+arf1yElMQ21mlXD0Hv6I7peJXVs2Dhvq9XXP5Kw7zqqPQZP7oMDW45h/rfLceZwjJq2pfeYzuh9axdsWnUAi37biLjz8ShXIQz9b26Pdn0aY/nSfVi2aDcS5DtQNhD61CzofXXQy/zNavJZIL1cAHyvpqsSyF6Z2UBW7vxdYSHQJyZBJ/dz57WVp3iVKYOc5GSnjKz18tapOHtcrXtV/NGyVxOMeGAQ6rSs6fB10TTGj0Q2JVM1/PvVEqyYaZ+YRfN0UPPOTqz3gMrvNevRSOVZMjOyMOfzBWr6NekE1H5wawy7tz/OHIrBP18swrFdpxBYJgABZfyRlpRuswbjWs2qI7KK5WhEqR4oOUi5lhCt+jTD8PsHoE4Lnt88za7V+1QOcv+Gw/Dx80GnYW0w5J5+OLn3jJom8MSe0wgKDUTPmztjwB09sW3Zbiz4dhnOn4i97vWP5BAX/7DSdP1To0lVDLunP6o1rYZ5M/7DhsW7VRzasHVNDLu9G7wrl8Eva3Zg8+HTqjNfx/rVcEuXFkgJuox/z63BocRT8PPyQf2ALmgbvA3V/dJQztsH/jod6kRdxJUa2/Hj6YZIuBQMr6ve0GV5ITVIj+TKWQg8n61eU+8tMaSU0KwEb30OvGKvQCdDbo2kQkpOjt3jSjmmLvxhOX5/b46KJQfe0Uvlc81H2ZMD6LWTg9TpjbOna0BCQgLCwsIQHx+P0NBQm73umUPnMLXHi+pAZwyMvLy9WHbExry8dKo3i5DGMWNDuPnPciGekzsnh5ePl2rYsUe702Pf34v+t/U03ZfEyhtjP1b5iLzrdc8Ht2HUw4Nt9+bkVH+8/w++fnyGxX4nSTL13ddbfvcloJZ9QvZJ8/1X9kdvby9kZ+cYdk0p4yDBiF6vXlcel/dYIv8K42ub3t/Ly/Ba5vudvK5OZ7mO6vXzj2rQFxbcGBtvXYyad0e2Te6fUbVeZby/6hWElw+D1tjrnHa992s15nV4+5Wu8SA7Iw3bfn3WYetO5IrfNTnmf/HIdMz+ZL5dYxbKc+7Qy7nSGznZ2YbNrL/2e/kckKM3na9tGc/La1euVQHf7P7ANDpDGu4e7/0KDm87ZloHVWYWQLUGVfD+ypdRNkp75zdPFHvqIqZ2fxGxp+KgR27MmBsb5o3xjPudiiPlMQVc8xTn+kdeR+fjo8I88zhU5+0F76hyyNF5mcoaq3hVRi1UCoc82xgayvOyvICMsr6GBcY4Uq+HT0I6/M8kGhbn/p0q1ExLA1LT1THOOBpX5u5TDbUZGXAG8++yMVZ++IvJGDy5L7TIkTEk40fSMnt912Q6oMd6voTkhJR85w6y47mjgHOw5IIkdlTnWjt+Bi/+9Ri6jGxvui8d/D6c/JWKAczXS+KBR76+GwPvNEzjQe7vfy/+hp9e/dNyv8sdPa+uX/LlIHWmODL/9U+OKQ4t6vpH7+MLn8gI6LzMvgPeXkioHoz4VpHw9tIh25if9wJCGl9Gmbrx8IIXclQkCfgiB09W3o72ZS6aYkL5NyHdHxPnDsehS+UMcaMMHoEePml6ROzNgnemMW9qCFJ1ianw2XZENcwauv8ZrqPVly4nt6OgHV2LlQ3rWbt5Dby3/CXV+VFrmIO0P9b/KSU5OLw48h3EX0yw6L3GAMn2TI1canREToE/G5MU6mfzEc3FSHhKgCMnHjn5icjoCPWvnMxkuUp26HS4/bUxFo20Mccv4M1xH6vPvKD1+mLqdOxdd7AEfzG5mt1r9qtGWmH+WUsPS+M+Zv7dl2OCcZ8033/lser5ZlN2GfvMyPKCjiXyr/lrG97fcFGQd78zJsUs1tFD+uSYtk1uj6qzR87jnYmfOnu1iIistuLXtaqRtiQxC5Xi3JE7yladFvWWv5fPIacE8byKFXPjx+CwIPj6G8rFyjL5nYiuWwlvL3nBooTep/d/h6M7T1isg3G9ZGTGu7dP40ftIV675SPEnb2Um1gyLDPua3ljPOPPKo4s5JqnONc/Mous6T3M49CQEBi6Cl6LQ+XX2eVCVNLNPGSU+xlheRpp5cfMnHyNtIblWaqR1vBws99IA62TGmlFvhhaD3x0z9dqNBIRkTuRGOa5oW9aNNIK5iBtL3/+BQXmgkznUisbac1zjSKyilkO0sdLdZaS39338R0WjbQyH7E00kpMkXe9ZJn8Th5D7k+qqkgjbb79zmxwR/4c5LU40vCD+fWP/vrXP9LpICJcLTN/7dQQH8S3NIzqNjbSCr9KSaqRVj03t5FWjIw4jrbBFy1iQvn3jbVdcOSy7OvS7Jq7XA+EHcmGqoycW5HFuDI+O4+pf42Pvbai9m+kFRY5W718/07h43u+dsh7k/aw9HEp7Vy5F6f2n7XNp0FO1f3GToYSsRXD0XdCd1RvFK1K3EoiNTk+BZVqVkD/23ugfLUoi+f9++WSIqstSIA1+9P5aNypvv3/CLKrWR/Ps+jF5ly6guf9Ur29ro1gyPd4M6ZeaPl/AXchgaOUfZZyfpIEJwfQUNkRInv684N/r/V0JrckybPoepXRsH1ddTpu3rMJut3YEekp6aq8rTQC+fn7ocOQ1mpqA28p02VWslBKjBWW1JPlmxZsQ8yxC6hUq4ID/yqyNRkxvX/DIcdvWC9DJ9O8yxDgnz9+9PMBCpiHLzvAWO7Y8vG+l1MLji7T0guMN3NSDY93JZIcl5KRj357j7NXRRsYPxLZxIZ/t+Li6Uvcmh6gxy2d1ek1KrqcmtapSp2KanDA6j/WIyUxVcWY/W/vqaaBMzfn80W5I2kLvoaQ38ljHv5ysoP+ErKXPz/81+Gj5XVBhqnF8saQyXVCc0unWD6+TF0ZuCYjdK8t80YOhpY9gbzTZselBGL+kbrI0VuOG/RN1sMvOf/+7BV7FTqZYiMvqQzoJPJZrP5zA6Z8cCXfd5PsRK+dHKTVI2pXr16NoUOHonLlyupL+/fff1v8PikpCffffz+io6MRGBiIhg0b4osvvijyNadPn65eK+8tTcommZk2bRpq1qyJgIAAtG7dGmvWrIGzyUnU2IOe3Jd8htUaRuPJ/z2Au94ehxqNq6p9sFGHeqr32hPT78f4F2/M10grdq7aW+RJUxr1dizfY+e/gBxh16p9LtJImytfY6xxcQHLzXuleaC9/x1w9ipohvR2tMWNtIXxo6XMjEzVeMNGWvcm8V/MsfNqSoxHv7sXfcZ1g5+/L0LCy2DUQ4PxxA/3qySZNNSaN9KKA5uOWI6kLoge2MPzm9uT60VjiTqHyb2ezsfPt8Dlej/fAjvq5fgWfJ0rc9MW+Bdly1CIvC8upelcKH42v0ZbwWs0R2H8SCXFGLKAHKSvZUxB7kfigvptaqsc5B2v36o6ncv5uVm3Rrj/0ztVDvLWZ0YV2BC0Y+WeIvNS8rvty3fb+S8gR+W5HD1aXufnV+DyjKgA5Gt5hR5+4ekWjbSiom8Kyvpk5nuNXRcqIDtPI63wTVQFmfOvS3wyzKemvfa2zo0r5TNxSidMjdJpKAdpdQtjcnIymjdvjs8++6zA3z/yyCNYuHAhfvrpJ+zfv1/df+CBBzBnzpwiX1fma4iJibG4SYOs0W+//YaHH34Yzz77LLZv346uXbti4MCBOHXqFJzJUKOc3J2x3nxJFOd5JX1tci38GF0Xv2NEro3xoyUeszyIHeNHax5Hrss9PsOCr2gLXXN3+JM85rMh0jbGkJZ43PIQzEFScbhpnCKFiguis1lrmfO3C4/F5BKlj6VxVG6FWb9+PSZOnIgePXqo+5MnT8ZXX32FLVu2YPjw4UXu4BUrViz09x988AHuvPNOTJo0Sd3/6KOPsGjRIjVa980334SztOjZWE3sTe5NesPIyJaXRr2D8Apl0XdiD9RvWxvbl+3Bypn/IelqEirVqogBd/ZS5Uj+m70J6+ZuRnpqBnz9fIosXShlR2SuiVdufE+VrGjTr4UqcZIQl4D53yzDiX2nERDkj84j2qHT8LY4ffAcFn63DOdPxKoRGT1v7ar2s33rD2Hpj6txNfYqylWOUCVQareoocq+rvpjHVLiU1ClbmUMnNQb5atFYu1fG7Bh3lZkpmehTouaat0Dgv2x7Kc1ahSwlCFr1rUR+k7ohoy0TCz8fgUObT0KHz8ftBvQEt1v6gi/gIJ7UmlVqz7NsPrP9S4yqtZYttgYoBj3P52hpLFxxnvjz4YrAcNNjWqwnK+igDtuZdOC7Vg3ZxMqVC+v9vWaTao5e5U8l4bKjpDtMH60JPOUNuxYDwc3HracO5LcisR4lWqWxys3va+uZVr0aIze47ohNSkNC75dpuaflflqOwxujS6jOyD2VJxafvbwOfj6+xarlNmGf7dg7awNqFhDzm+9EV2vEtbP3YL//t6EtJR0VQVm0KTeCI0MVdN1bF2yU71mw/b1VKwoYcLi6Suxb/1B9X6tejdDz1u7IOlKslqXY7tPwj/QD52Gt0PnEW3V3O+y/PzxCyhTtgx6jumMFr2a4ODmo1jyv5WqZHNEpQj0v60H6rauha2Ld2Ll7+uQfDUZlWtXxKC7+qhSfXSNxPEOHz0v5Yazs6GTUsdqDr1sQ0wo//r7q/LHusxM5CQly0RjwBUfoHpFIDgQSEyB7nKCeqxPkB9yapeHPsgf3rHx8I5NUHGkXueNHJ1hdK4+KRn6lNxSyDKS18eQYtCnp0OflTvC1hiXutj3NywyBC/f8B6vfxyB8SOVEGPI/OeUPz/4h/uTm5Ocza41+7BjxW5EVimHAXf0Qs1m1bB5wQ6Vc1Klj+tWUnGV5BOl1OrG+duQlZGl8oRyDjOfo96c/C40oozp/NZ+UCt0u6ED4s5eVjHe6UPnEBQSiG43dFRTcxzfdQoLv1+OuLOXEBYZij7ju6Nx5/qqotyyn9cg8XKiqi448M5eqhLh+n+2YO3sjUhLTkf1htEqBxleIQwrf1uHLYt2qLlQ67etq6aOk/l2l/xvFfasO6Dm3G3Rsyl6j+2ippdb8N1yHNt1En4BvugwpA26jGoHX6nwQSYtejZRsbYjR9XmJCbBSyoB+fhAn5qq4jk5h5f5LwcJnaoCvl4IOBAHv5hE9fiMVD18h3tDl+kFrAD0J4GzvkH4t39V9Ot7BhcvBGPRvBo4d7YMfAJyUCYjFUkVAuB3PgXBey7DJykDej8fePmGQR8SAN2VJHidvwJkZuVWZckdbavym8bt4NyY0svLCyt/+w9LZqzk9Y8j6LWTg9TpVUa/hE/W6TB79myMGDHCtGzKlCnYunWrKoks5ZFXrlyJYcOGYcGCBejSpUuhpY+lAbZKlSrIzs5GixYt8Oqrr6Jly5bq9xkZGQgKCsIff/yBkSNHmp730EMPYceOHVi1alWBr5uenq5uRgkJCahatSri4+PVCF5bkM03ufmjOLHntE1ej5xHAggJKIxzkIZGhiAhLtFwPzvHkEzLykGZ8GCV3JL7+pwc9T24XpL12sTpktvQI7BMgEquqeSGvIaXIVFXJrwMkq4kmd5T5k6SdZEkQrxaF2/1HTEuDy0XgoRLZuuY+zrBYUEq8DGso8xXanhzSRZK47Kp548eKlEof3eONN5JW56XNFzrUa5yON5e8oIKvMhA5ix+sOMz3BwuKO93RkpOTvlgokf3cpNzWlhYmE3PacV5v9Y3vQ4f32sVL0oiKzMNW39/1mHrTq6F8aPBmlkb8coN7zn506BSU32gdKbrAr9AP2SlGxILqq+Uly5fbCYxl/F8Ze35LSQ8GInmcaiX4d+A4ADVQCxJMGM/LokbZc2ysqSR7locKh33MlIz1ALLONQQ4xYZh6pY2fBv3jjU+Pixz43GxJdv9uhzsLUe6fY89qx1oWkaCmk41UkDrjEhZlwm+7a/L3RZ0kBrluiQBltjEs2cuu8e2RBVktrseyrJ8LcWP+/x1z+OjCEZP5ItMYaUPjTZmFjnflw4Gcedy82VNL8nJ+brdQDLe34LDg1CcmKK4TXN4tCQcmWQeKn4OciQiDJIvCwNeYbXMb5eUJlA1bgs9w0DB6TB2Evdl8Zl4/gC+Z0MVJHBIuq+WRxaqVYFvL3keVSqWcERm98tbFu6C0/2e9UlYkX1k5d0yPMGpJOAWUzoVTYAXoEhUIGiLJN+gjlAcDkgOSMYXt45yMnWwctbj+wsHbITr8LrcjJUFWS5HJJ/s/XIkeuqjMxr8abcz3HNuFKL1z/MQdqfzSdX/eSTT9CoUSM1R62fnx8GDBig5pYtrJFWNGjQQDXWzp07F7/++qsqedy5c2ccPnxY/T4uLk6dGCpUsDxYy/3z588X+roy0lYuQIw3aaS1NfkCSm8mcn+ScDL8a0iaSSOt6b504sldLgksIYGEYcql658wJBiRm/GxkkiTwMr0Grm9o6SR1vw9jesiAZJpHc2WSxBnsY65ryNB3LV1NLyv/JyekmEYiCkJGLnp9chIy1Cva7xv7JV35UI8nuz7impQJgMJkCXYJNeT9zsz6+N5+OvDf529WkRUTFqLH4X0dCcPYBZXyc8ZKRkq5soxxVX5YzPz85W15zdppDW+jjGGlH8ltlTLc99X1kcSY5kZWddivNw4VEZA5BQYhyZfPw41+zdvHGp8/M+v/aVGZtA1Lne9WFAjrYyEzd0XVB9PY90WLy/oMg2fuZrjKff5+oxMt26kFdeufwx/9+XzV3n9Q+RmtBZDSsNXcFiwzV+XHK+k+b3iVOnIe35LTki59prmceUl63KQ0khrXBfz15NGWrU859o6ZmdmIzM903TfGCurOFRi5Txx6IVTF/FUv1eRJZ3ASAkuG+y8hr88MZ4hLtQBWTmGn3NjQp2vL3R+IdBnm3fmkxJSPqqRVt3NljyqdBrwgv5qgmqkVa+Zk/sashtlZalGWpi/tos20gpe/5DbNNRu2LBBBTwysvb999/Hvffei6VLlxb6nA4dOmDcuHFq7luZe/b3339HvXr18Omnn1o8Lu/BSQ72RR2wnn76adVL1Hg7fdr2o16lTMPuNftt/rpEzibB0qVzV1TpZzKY/fE8d50iQpN+e2cOg3x7MJbULu2NSMPxo5j59t/s/EOeSQf88sYsQ7UWQszxC1j/7xbX3hJSslgaZAs6NhqnzjAnJZQLpPeM65/f1jl7VTwP40eyE63FkFKdQfKQRJ5GBsecO3pBTfFBBn9+MFeVsnYJpkqRluvjFRRU4HL4++bL+8gIaiQYGvstlntIjojXP3ai104O0uo5aouSmpqKZ555RpVDHjx4sFrWrFkzVZ74vffeQ58+fYrdQ6xt27am3myRkZHw9vbO13MtNjY2Xw83c/7+/upmTxvnbSvW/FJE7khOtBv+3armyyDgvzmbXWR+WiqOq7HxOLrjBOq3rcMNZkOqd2MpY5zSPp88ixbjRxmlIXOJOnzeSiJH0APnj8fi7OEYVK1fRfPbXOabM68Y7JKkDHZBDRDGsnd5Gys8+NpXykTK3NADZI5nst12ZfxIdqDFGHLjvK2mKQiIPI2Xjxc2zNuKrqM7OHtVXMKGf7a6Tg5SOvUV1FHF36/g+NGrgLGBaTLfbQERcaGdO106es5Hrn/OHTmP6HqVnb0qHkWnoRjSpiNqMzMz1U2CHHMS4FjTo1ouEiWwqlSpkrov5Utat26NJUuWWDxO7nfq1AnOJGUcPLn+OGmbKo2cbig9QUAWt4XbkWM0Ebk2LcaPcsHNRlrydJkyVy/xetHNyLE5M3fuPCJybVqMIeXcyhQkeSw5BzOHY6Lm93VxBVdjKeTBbtJYVhrcf8mhI2qTkpJw5MgR0/3jx4+rgCYiIgLVqlVD9+7d8fjjjyMwMBDVq1fHqlWrMGPGDHzwwQem50yYMAFVqlRR8zeIl19+WZUeqVu3rpqYWEqXyGt+/vnnpudMnToV48ePR5s2bdCxY0d8/fXXOHXqFKZMmQJHS7yShNV/rFdz2Fy9mMCebOTRPcr9A3zx06t/IrBMADqPbIeKNcqr+SdW/7kBF0/HoWxUKLre0AFlo8JwJTYea/7cgPi4BJSvFoluN3RAYJlAVfJt3d+b1fxp1RpWQcdhbeDr54ujO09gy6KdKvio17Y2Wvdtpk7yUk5cSvrIz817NkbD9nUL7RAhc+yunb1JjdqQOWS7jGqP8lUjkRyfrNYx7uxlhFcoi243dkBoRIjV2+DQ1qPYtmSXmiS+Qs3ySIo/weS6m/Dx9Ua1htHOXg3PY4tpQjQQoJMlxo+GJOCu1fuw97+D6pwWVTUCF09f5q5CHsk3wFeNSpTydbWaV0e7gS1VFaIDm45g54o9ao7cxp3ro1m3Ruq7sW3pbhzcfESNEmrTvznqtKiJzIxM9fxT+88iINgfnUe0Q6VaFZCalIo1f23EhZMXEVouRMWbEutJ/CnXaHJ9FlU1El1Ht0dwqKEcW0GO7zmFTfO3qzi0butaaN2vmUr27/3vAHat3q++p826N0KjjvWs7pgrc8FJTHzxzCUkxSeb5gd2WdKg4e19rfycsYFD/m5vb/X3q3J1ppLHuSXEjCNuPYjsp3Vb1XL2angexo9UQowhgasXDXkWOb9JTiUrd95wIk+To0qUAj++8gfKlA1W+b2o6HJIupqsYrxLMVcQUVHyex0REl4GcecuY+1fG1WevnLtiipnGRDkjzOHzqkYMj01A7WaVUf7wa1UjHlwy1FsX2rI70l816JnE0NHjeV7sH/jYXh7e6F1v+ZFxgGpyWn4b/YmnD9xESHhwWr0r6yTzDEsOcgrF64iskqEik+tnU9a1mX/hkPYuXKf+rlirQrqb3GJ/InMNWxeZSU3/stJTZVyAoZYMT1detAYRt9K/Bjgr+JHfVIykJFp+DNyK7gY4k3DHMim0sduHlf6B/mrz4xsTK+dHKTVDbVbtmxBz549LRpQxcSJEzF9+nTMnDlTzcswduxYXL58WTXWvv766xYNqtLAat7j7erVq5g8ebIqKxIWFoaWLVti9erVaNeunekxN998My5duoRXXnkFMTExaNKkCebPn69e31HkwCFzHs546TdkZmSpXnpSuo7Ik3uUSyPo+n+2qh6pXz72PzTqUE+Vk01Py1CBjswj8dmD36vG1AObDiMnW6/KlUgpnk/u+xa1m1dXAY+ciOV7L8vLhJdBhWqRqqFWkiFyLpbRRZHREfDz98O5o+dN8/ZJWfF6bWrjxb8eUw2w5tbM2oj3J01D8tUUePt6q8d+OfV/aNihLg5vO64SfKo3bXYOPn/oe4x/4UaMeXpksZJtEly9fMP7Klmn1kVnmDOD3IN8xj1u6awSuGTjbZtjuJX2NUhbtBw/ijOHY/DSqHdxcu9pi/MbkaeSEYn/e/F3U4xXtkKY6jB3av8Zi+9ApdoVkJ2ZjdhTcfD28VK5me+e/lk17saduYSES0mGeDMnB189PkPFm8d3n0Jacroh9svKwbSHv0fDDvVwcNMR9V7GOPSz+7/F3e9NwNB7+lusmyTz3rj1I9VZ0CIOrRKhGoTPHIqxWMfaLWrgpVmPq86KxTHn84X4+okfVWdCY6zsDvSZuQm0vLKyoC8scebGybTCSEJx0F29nb0aHofxI5WU1nOQ/3vhN8x8+291PjKe34g8lh5YMfM/U37vi6nTVYx3eOtRUx5eln/24Heo16aOatQUErdJPBkYEoBqDarg4Oaj8PLSQZebg5QBJmHlQ3Fy7xmL2K9izSjoc6A6/5ni0Gd+QZOuDfHC71NVR0BzS35crfKf0mHCGJ9Okxxkuzo4uOmwZRz6wHeY9NY4jHxwULH+9NhTF/HS6PdweOsx17xeNMZ8eWK/nCtXDZ39zDv6iYREVRYZmVn5Sht7YlwpA50G3tELgcEBzl4Vj6PTUA5Sp1fdFrRBRutKEBYfH4/Q0FCrnz/r43n44pHpdlk3IiqcBEzlq0Xhqx3vqhG6Ytuy3Xiq36vQq+5Xxd96krC7YerQIh8j5Z7vbf2E6rnmMvNBkNUe/+E+9JvYw2O3XGnPaSV9v7YjX4OPb+mCz6zMNGye/ZzD1p3Imd81GeV3V7NH1b/u0mBD5EmemH4/+k7orn6WTrYPd34Oh7YeK3byS+LQcpUj8PWu94scoSsW/28l3r39WlUocj8VakThf4c/VclgT+XIGJLxI2lZab9rMqpwxku/22XdiKjo2K9qgyr4fPPb8PP3Vcv+m7NZDebIS1UcKaJpZeo3UzDwzqI7gEnVwsnNH1WdFJmDdF8vzX4cnYdf6/DjaZiDdLM5aj2Z9Ij+8eU/nL0aRJokgYqUT1760xrTsukvzDRU3NBbf7GTnppe5GOkpMrJfWcYILkx2Td+fWu2oYQK2afsSGlvRBox7+uluBobz0ZaIif5/rlfTVWQtizcocovWzNCQeLQi6cvYfH0lUU/Ljsb3z/7S6nXl5zrwomL2LxgBz8GW2P8SGR1Cf2Zb83mViNyAon9Tuw5jbWzNqr7klf64bncHKQZU8neIvzw/MzrjoRfMmOVGtXLRlq49YjamW/ymG0Xeu3kINlQW0zbl+9RNfGJyDkkHlr202r1s8z3tX/9oRLN95WSkIqti3cV+ZgVv65VJ1lyXxIrnzl4Dif2nHL2qngcnd42NyKtWPrTas5tTuREMjrhwMYj6ucVv/1nKidnDUnEyXe5KPs3HMalc1dKvJ7kGmT/WDFzrbNXw+MwfiSyzsZ/tyIjLZObjchJJCe4/BfDYJFT+8/i1IGzJarMe+X8Vez570CRj1n28xqV8yT3njpQOoNKCWuyLZ2GcpBsqC2mxMtJ9v0kiKhIEhAZv4el7TRxvefHX0pkUt1DJF1NcfYqEJHGJV1hDEnkbMbYL+lyconn+7re9WDSFXbq9QSyf/Dan4icLfFKcr7Re0Tk2IY3Uw6ysBivmC2314sREyQH6SYNSVQ05iCpNHxK9WwNqVynorNXgQha790eGR2BjfO2IiszG17eOuRklyySSUtOw/p/tqBizfKo2aSaqbz53nUHkZ6SgXKVw9WcFCw74v7izl3Ghn+3olrDKqhcu6KpjJSMepHyM3Va1kS5SuHOXk33UozyPsV6DSKNqFynEuIvJpSoCgQR2YYkwCQeCIkoU6IYT+LQqKrlVBzq4+eDRp3qIzDYMF/7mUPncOZQDBIuJ/Lj8gCyf4SWC1H7S2CZADTqVA++fr5qVPXRnSdUGeywqFA0aFcHXl7s915sjB+JrFK5dgVeMhE5OR4Ir1hWxQNpKenQQw9d7rjXa1NsFW8+tqSrSSoHWaVuJVRrUEUtk9fct+4gMtMzEVUtEjHHLpS4MyG5BslTnzt2HhdPx6FGk2qoUD1KLU+8koQDGw+rY3q9NrVQNirM2avqXvTayUGyobaYGravi+j6lXH2cAxH2hE5gQQs25buVjfh7eMN6LKtrjMvibZP7//OdL9Oq5po3LG+KjXC8uYeRAd4e3vjjTEfmRY169FINdau+GUt0lMzTPtD19Ed8ODnk1RSjoqxaW1QNsRdyo4Q2cKQu/ti73XKXRGRfeOBdyZ+Vuo4dNfqfdi1ap+6H1AmAL1v7YoTe09h738HTY+T+PR685CRa5NGfLkukJsIjQxB7zFdsWPlHhzffW1KjQo1onD3uxNUHEnXx/iRyDqt+jZDZJUIVVL/WqMQETkyHvhv9iZ1M8V40vE239exiMZaFYd64b07vjAtatihLmo3r4Flv6xBamLadV+C3INUQNDpvPDyqPdyFwBt+jVH2fJhWPX7OmSmZ5n2o15ju+C+j+9AcGiQc1faTeg0lINkF9Bi0ul0ePSbKeoLVZJ5jYjItlQSrAQH2rw91I5sO445ny9kI62n0efuI2Z2rdyHhd8tNzXSGveHNX9twMNdn0dKYqoTVpSIPF3PWzqjdb/mnPucyEXigdK8llFaUhrmfb1EVWMxx0Zaz5MQl4jZn87H8T3XGmnFhRMX8cqN72P5r5zPlohsTzoZTf1mioof5UZEzqViPGsrJKk41DIHKdXd/v1qybVG2tzHkXuT/jQW1wF6YMuinVj642pTI62Qxyz7aQ0e7/WyquxIZI4tjlZo0qUhPlz9Cpp2bWixnEETEZH7ksZaKVs476slzl4V96C30Y1II6ST3ytznsTNT4xAcNi1XrN+gb6qIyARuTGez6D1z/rzh75HZkamo9fG/TB+JLJa2wEt8c7SF1SFPyJytgKu29RodwaDZH0O8vD2Y6oRl4pBr50cJBtqrdSgXV28t/wl/HLqS3y26S3c+eZYt/mwiYioYPocvRoZQ8UvO1LaG5GW+Pn74s43bsXvMd/gi23vqJuPrw9L2RERecCI280Ldzh7NVwe40eikmnevTE+/u91/HR8mspBjn1uNAeLEDmvti23Pdlod9Jh3jdLuTWLs6302slBsqG2hKKiy6F+m9pIS06Dlw83IxGRu4s7d8XZq0BEHs4vwA91WtRE1fqVkZLAcutERO5OcrZxZy47ezWIyMNVqB6lcpDJ8SlqzksiInLvwSIXT8c5ezXIxfg4ewXcnUwKnXfOSyIicj9hkSG4FHMFXl46dWxnSdJCSHkfVeKnFEr7fCIPaLD1D/JHekq6s1eFiIhKGdIEhgQg9nSciiX9A/25PQvbUIwfiWyTg7R2nkwisi3T+YzfRSohHVC2Qhjizl1WUyWVjQplDrIwGooh2Q2rlLrf1AleXtyMRETuTnon31JlMm6qdBfubPwwFn6/nGVJNV52hMhepCNIvwndofNm+SwiIncm1bXevf1zjK1+D0ZG3IYP7vpCNdqSJcaPRLbRe2xX5ORwsAiRw+lzrt3cadJLh5HrWikP7WW4meb0NVtu/Fkt1gFeXtB5e6t/NVdWWg9cOHERY6Lvxk0VJ2FKy8ex/Ne1zl4rl6TTUA6SLYylFF4+DF1Ht7fNp0FERE5tqDU6c/Ac3p/0Bb569H/8RIjILkY+NAg60wUsERG5I322XpWvE5npWVj8v5W4t82TiDl+wdmrRkQeqGKN8mjTr4WzV4OIyIxZ46vFYi/L5cZ/cxtmjVXstFrNznwqpON7TuHNsR/jx5f/cOo6kXOxobaUMtIzsXXxTtt8GkRE5BKMVTH++mge9q0/6OzVcS16G92INO6/2ZtMyX0iInJP+jyl1LKzcpB4OQmfP/i909bJJTF+JLKJ5IQU7F6zn1uTiFxLvkbaQhpvvfI3zqpYyk1K09qLMS8w4+XfcWLvaWevjmvRaycHyYZaGyTZEq8k2+bTICIil+Lt44V/vlzs7NVwKVoqO0JkL3IxOmfaIpZXJyLyQDnZOdg4fxsunrnk7FVxGYwfiWxjxa//IT01nZuTiFyEdaNhpYFWqyNoi5uDnPfVEmevhkvRaSgHyYbaUjq1/wy8fb1t82kQEZFLkVERx3eddPZqEJGHyUzPRBwT+EREnksPnD54ztlrQUQemIP08WEOkohchDS6lrbhVeOjafPlIPeecvZqkJP4OOuNPUVAcADL1hEReSodEBQa5Oy1cC1SkqW05VpZ7pU0Tjr5SW9ZuRAjIiLPFFgmwNmr4DoYPxLZRECwPyuyEJHrkEZWjpC1GZ2XDkEhgbZ7QU+Qo50cJBtqS6nzyHb49qmfbPNpEBGRa9EDl89fwYiIifAP8EPX0R0wZEo/7Ft/CP9+uQjnjl5AmbLB6D22K4bfPwARFcPh8Wwxv4N7xEhEduPt7Y1Ow9vhvzmbkMPGWiIij2xMefmG95CWnIbqDaMx/L4BqNYoGnM+W4gN/25FVmYWGrSvi5EPDEK7gS3h8Rg/EtmEXI/++uZsbk0ichHG+WV1hSR6LJfrs1VrZJ7F5nd0mk4eyVy1p/afVTnIgCB/9Li5Mwbd1Rs7lu/Fv18vRuzJOISWC0G/iT0w9J5+CIsMhcfTaycHydLHpRRdtxJ63NIZXrmTYRMRkWeJORaL5KspuHz+KuZ+uQiTmz2KDyd/iSM7TiA5PgUXTl7EzLf/xl1NH8XJfaedvboea9q0aahZsyYCAgLQunVrrFmzptDHrly50jT3ifntwIEDDl1noqLc/OQI6OQ/hpBERB4nPTUDl85eVjHkgY2H8ea4T3BP6yewZMZKXI2NR9KVZGxbsgvPDn4D3zzxI0fI2RFjSPIkdVvVQtsBLeDlzXQuEbkSffGXS8NuvsVyUayzXTllNxZz9LyKHy+du4JZH8/DpCZT8ekD3+LE7lMqBxlz7AJ+fPl33N3iMcQcv+Ds1fVY05yQg+SZ3QYe++4edBrRVv0sZeyknJ0MVZefK9SIyl3uDR/OZUtE5HZysq+VJtVn602JNOnpZv6YpKvJeGnUux6faFPhs76UNyvf87fffsPDDz+MZ599Ftu3b0fXrl0xcOBAnDpV9NwdBw8eRExMjOlWt27dUv3tRLZUv01tvDTrcTWNhnwpJE6UeFFUqB51LZ7MLZNMRETuwyJONP6sN8w9ljfG/P29uVj/zxZ4MmfEj4IxJHmiZ2c+glZ9mlrkGiUh7Ovvg6iq5UzLJYYkInIthZzNjY2zGm6gzRc35saTKqY0Dlw2e4x0/Hvt5g/h6XQaykGy9LEN+Af648U/H8exXSex6vd1KllfuXZF9BnfTQ1H37P2ANbP3YyMtEyc3HcGu5BG7y8AAEdFSURBVFbvs0j8ExGR+5Pj+plDMdi+fA9a9TZcOHsk1fuxlI3RVj7/gw8+wJ133olJkyap+x999BEWLVqEL774Am+++WahzytfvjzKli1bunUlsqMOQ1rjt3NfY8XMdTi28wT8AnzRcVhbNOnSAAmXErHspzU4eyRGXVn8M22xx3cEISLSIhkZN+ujeeg0zND52yM5IX4UjCHJEwWHBuHNBc/h4JajWPvXBqQkpqJqgyroM64bgsOC1PXopvnbkJWRhcPbjuHg5iMWnUSIiJyKjbE2Icf1Q1uOqnOBdAL3WBrKQbKh1oZqNauubnk17dpQ3cTdLR9jIy0RkYeSUW/71x/y7IZaB8vIyMDWrVvx1FNPWSzv168f1q1bV+RzW7ZsibS0NDRq1AjPPfccevbsaee1JbJeYJlADJrUO99ymW9m1MOD1c9r/tqAuZ8v4uYlIvLQzn77Nhxy9mp4HMaQ5OkkMV9Qcl6uRY3Xo+Nq3stGWiJy00ZadlK+/ubUqRykRzfUaih+ZEOtgxlL2hERkeeRTlqeXqLUWDqktK8hEhISLJb7+/urm7m4uDhkZ2ejQoUKFsvl/vnz5wt8/UqVKuHrr79W80ikp6fjxx9/RO/evdW8Ed26dSvdyhM5AechIyLybN4ePt+ko+NHwRiSCPDy8GtTIiJt0zMH6UE5SDbUOli7AS1xdMcJjqolIvLQEREt+zSDR9PboGNj7vOrVq1qsfjFF1/ESy+9VGhPQYuX0OvzLTOqX7++uhl17NgRp0+fxnvvvceGWnJLUplF5h/Lysx29qoQEZGNSSe/1n2be/Z2dVL8KBhDkpa1H9gKc79YxBwkEbkGvbEMuy5PYGC8n3c5Fbk59UBLT6/op9dODpINtQ42+O6++OP9ucjU504GTUREHpNka9CuLkuOWEECl9DQUNP9gkZDREZGwtvbO1/PtdjY2Hw93IrSoUMH/PTTT9asHpHLCC0Xgn6398SCb5cxfiQi8jDZ2Tm4YeoQZ6+GR8WPgjEkETDsvv7458vFbPsgIhejL+Q+20qsqbrVpn9zRNerbNNPxpOddvEcJGtgOFhUdDm8MudJ+Pr7wstLZ/Hl0sl9XZ7ydjrAx8/Qnm4sp2lsvfcL9LNYbnw9/yDDTmZ8HfW6RERkU17eOotjb+U6lfDCn496/FbWSS8yG9yEBEjmt4KCJD8/P1U+ZMmSJRbL5X6nTp2Kvd7bt29X5UiI3NW9H96Glr2aWMR4xn+NsZ8x5jPGhn4BvobEXG4oaFwuo3N1eeNQnU7d8sahRERkQ2bHVWMO4OEvJqNJl4YevZkdHT8KxpBEQNX6VfD871Ph4+NtEeN5eXnliyeNfP3z5CBNuUa/YsWhutzrZCIiskMOMvfYW6t5dTw54wGP38Q6DeUgOaLWCaSs0Ywjn2H+N0uxbekuVYKkWbdGarStlLT798vF2Lf+kEqitRvUCgPu6IkLJ+Mw76vFOLb7FIJDA9F1dEf0urUzDmw8ggXfL0PM0ViULR+KPuO6ocPQ1ti8YAeWzFiFy+evwD/YH7tW7nPGn0pE5LEadaqPzLQshJQrg15juqD7jR3hF2C4ePVoUqkmxwavYYWpU6di/PjxaNOmjSohInM/nDp1ClOmTFG/f/rpp3H27FnMmDFD3f/oo49Qo0YNNG7cGBkZGaoX219//aVuRO7KP9Afbyx4VsV4i35YjotnLiGySjn0m9gDLfs2xbrZm7HslzVIiEtEdL1KGHhnb9RuWQPLflqDtbM2Ii0lDXVa1MSQKf0QUbEs5n+zDFsW70B2Vo4qrTzk7r6qnI/EoXv+O6ji0Jjjsbh07jJH8RIR2YA0YoSXD0PluhWRlZGNxh3rqWOyJkZCOCF+FIwhiYDOI9rhf4c/xbyvl2LHij3qWNSyV1MMntwHSVdTVOx3cMtR1cGv07C26HdbD5zaf1blLE/uP4MyZYPR4+bO6H5TB+xefQALf1iO2JMXEVEpXMWhbfq3wLo5m7Hs59WIv5igBpXsXr2fm56IyIYad2mIjJR0lC0fptp/Oo9sB18/X8/fxjnayUFa3VC7evVqvPvuu9i6dStiYmIwe/ZsjBgxwvT7pKQkPPXUU/j7779x6dIltZIPPvgg7rnnnkJf85tvvlF/2J49e9R9abV+44030K5dO9NjpF70yy+/XOxJfF1duUrhGP/CjeqW15T3J+ZbVjYqDPXb5N+Grfo0U7e8uo7uoG7iu2d+wd61B5GdxXnNiIhsQXoXR9ephEe/u5cb1AFuvvlmFVO88sorKvZo0qQJ5s+fj+rVq6vfyzIJmowkMHrsscdU4BQYGKiCpXnz5mHQoEH8vJyE8aNtSAmeDkNaq1tevcd2Vbe8ht83QN3yGvvcaHXLa/K7E9S/KYmpGB5m+JmIiEpPpj66fP4qvtzxnmqwJftjDOn+GEPaRvlqUbj9tTH5lkunv/s/vTPf8sad6qtbXu0GtlS3vKTjstzEJ/d9i33rDjEHSURkI96+3qjXsiamfHAbt6kHx49WN9QmJyejefPmuP322zF6dP7kziOPPIIVK1aolmNppF28eDHuvfdeVK5cGcOHDy/wNVeuXIkxY8ao4cMBAQF455130K9fP+zduxdVqlQxPU7+yKVLl1okq+j6sjOzWLqOiMiGpGpGlkY7v5iXDSnNa1hLYgm5FWT69OkW95944gl1I9fB+NH9ZEn8SERE9rk+1xhnxY+CMaR7YwzpfrR4jCMisjepwqpFOg3lIK1uqB04cKC6FWb9+vWYOHEievTooe5PnjwZX331FbZs2VJoQ+3PP/+cb4Ttn3/+iWXLlmHChGs9+X18fFCxYkVrV1nz6retg2yNfpmJiOw1IqJ+mzra3LgS35QuRir988ntMH50PyHhZVC+epQqbUdERLYRXrGsumkO40cqIcaQ7pmDnP/tMng24zy8vLAld91/ue+6E2nXkWOrJum1k4O0nDHeBrp06YK5c+eqob4yz5WMrj106BD69+9f7NdISUlBZmYmIiIiLJYfPnxYjcytWbMmbrnlFhw7dqzI10lPT0dCQoLFTYs6jWiL8Aph8PIyBhJERFQavgE+6DuhGzcikY0wfnQ9Op0Oox4cBB3DRyIiGx1YgRH3D2RlMCIbYgzpenre2gVBoYFqLlzPo5MJx83u2jytTmQnOrOb8T65izLhweh2o2GKS/JcNj+jfPLJJ2jUqBGio6Ph5+eHAQMGYNq0aSp4Ki6Z41ZKHvfp08e0rH379moe20WLFqkRtzI3rZRKlnrRhXnzzTcRFhZmulWtWhVaJBNLvzTrcfgF+sHL59pHbp54s1jukcFUIUr4p5o3eptvr8K2o5f3teVe3oU8V5bL/8zPm8VYR0mkErkK8++GVzG+A5bfJbiNijXKIyg0CJokJUNscSMyw/jRNY14YCA6Dmtrs5jFnRUW+5WGzlun4ri8ryf3Zbn5udO4bWWbFxZvyvzpVq2j2UPc6RxMns/4Hcj33VDHnTzfDXeiBxq01+poCMaPZB+MIV1PYHAAXvzzMfj4ehcam1gds7gE88ApNxB20HVt4bkVK3OQuuvHoddjkYN0l49O88wuJMxvHsAiv1jId6OwPLw7Xf9UrVcZ/oH+0CS9dmJIq0sfFydI2rBhgxpVKxPsrl69WtVzrlSpkkXDa2Fkftpff/1VzVsr89UamZdbbtq0KTp27IjatWvjf//7H6ZOnVrgaz399NMWv5MRtVptrG3UsT6+2vEeZn00D8t/XYu05DRUqVsJw+4dgDota2DOZwuxfu4WZGZmIbx8GGJPx7nNsHBrRUWXw9WL8QgMCURqQioyM6ybP0POZYGhgar0qTy3RuOqGPnAIJSvHonZH8/H1iU7kZOdg8adG2Dkg4PU42Z9PA/7NxyCl4832vZvgZEPDsTZw+cx5/OFOLn/DPwD/NDthg4YfHdf7Fq1D/98uRixp+IQHBqEpKtJyM7KKXR9fP194B/kh7TkdJQtH4aLpwvvvEBkTxLwhJQLQUZahpo7oV6rWuo7EFw2WH0Hdq3cq75AzXs0wqiHhyAhLhGzP52PI9uPw9fXBz7+Pki8nKS+M67u1P6z2LlyL1r0bAKt0ekNt9K+BpE5xo+uydvHGy/8+SiWzFiNuZ8vwIl9hpil6w0dMCQ3Zvn3y8W4oGKWQCRdTUG2B87fLee30MhQpKemq/ObVKq5eOqSqh5kraiq5XA1Nh6BZQLQ69au6H9HT2yatx3zvl6Cy+evIiwyFAPv7KW28bIfV2PxjJVqu1aoFokhU/qhWffG+PerxVjz5wakp2WgRqNoDLtvIKrUqYBZH8/HlsU7kZOVbYgJz1wq8pxavlokrlyIh6+fj0q6JSekeGz8T64vMjoCV2MTUKZsMPpN6I7e47pi9Z8bsPD7FYiPS0C5SuEYdFcftBvUEou+X4Hlv65BalKaW13/SNJw5lt/o1XvZtAaxo9kL4whXVOrPs3wxbZ3MevDf9WxXGKW6g2jMfy+AahSr5LKnW1etKPYMYtLNXRZuP46R1aJwNWLCSgTFoyEy4kqX2h9nqUMMtOyVM62bsuaKs8SElFG5Vl2rtyn1kNixNEPD1Y5ldmfzMfh3DxLx2FtMOy+/ji64yTmTluIs4djEBAcgF5juqiYc/PCHZj39VLEnbuMkLLBuBqXUORnERDsrzoNZqRmILxCWZW7JDeQd991k4ar68VVZaNCkZKUpo4lDTvUw6iHB6vfyXdg37qD6jFt+jXHyIcG4/zxWPz92QKc2Hva7a5/9m88jMPbjqFuq1rQGp2GcpA6fUkyDMYn63SYPXs2RowYoe6npqaqkauybPBgwxdDTJo0CWfOnMHChQuLfL333nsPr732GpYuXYo2bdpc9/379u2LOnXq4IsvvijW+kpDraxffHw8QkNDi/UcLZrS6nEc3XECnppwHHBHLzz85WRsWrAdzw5+o8Sv9cOBjxFdrzLsafWf6/HqTR9c93HvLntRNRi9c/tnWP7zmiIbdons7Y8L36JsVJhVz5GLgjHRd8OdjiWDJvXGg9Pucto6OPqcZny/7p2eh4/PtY5UJZGVlYZV617l+VijGD96pjV/bcArN74PT/ZX3PcIjQjBpCaP4OS+M1Y/X0aP9BnXHY99fy/sbVzNe3GhiPmF5XvYsncTvL34BZw6cBZ3NnrY7utEVFRcJSP4p7w/0eqN9M5tn2H5L+51/TPr0g9qHnAtxJCMH8mWGEN6pnG17sWFE4XHLK6hgBGIKp2uv+75bfQjQ3DX2+OwYuZ/eOPWj0q8Br+d+xoRFcNhTwu+W4YP7vryuo+btuVt1WD04sh3sP6fLS7eyE4FDh3Vu0/cdL2ODP8k/mj1aFN3u/6R68gbHx2GO98c67R1YA7S/mw6yFvmlZWbl5fly3p7eyMnp+gDwLvvvotXX31VNeYWp5FW5p/dv3+/GqlLtpUcn+Kxm1T6JaQkGv6+1MTUUr1WckLpnl8cKYlpxXtc7rqkJqYh28reeUS2Jvuh9c+x//fJ9scS91pnm9FQ2RFyDMaPnkELx0Tj+c0Yd1krJ/taHGpvKdI7/DrnsaQryW55DiYPpCv590qOPe7USCtkJLDmMH4kO2AMqd38gXud32yTgyxufrC0n4V5meVC1yX3nJ10NZmNtO7Ag/Mv0kkgPSXD5tdKrsYw+lej12x67eQgrS59nJSUhCNHjpjuHz9+HDt27EBERASqVauG7t274/HHH0dgYKAqfbxq1So1t+wHH1wbFThhwgQ1B63MIWssd/z888/jl19+QY0aNdT8s6JMmTLqJh577DEMHTpUvUdsbKwaeSst+RMnWt/rlopWrVG0Kl1hbTkOdxFd1zAKVsqtlJSU+ahYIwr2Fl3MdTT+LdF1K6mOEp762ZHr8w/0Q0SlslY/T8oB+Qb4IjMtE+5CysdrkS7HcCvta5C2MH70fPauMuJsUuZNSh6Lqg2r4FLMlRKVrquSG4faW9UGVXBg42HkFDLCQXplS8wvKtSIUmXBGD+Ss8i+V7V+yb4b6vrHjfZfKXsuZT61hvEjlRRjSM8nx3+ZKqywmMU1SKK/oNLHRZNzkzFGLk0O0i/AF+Uq23c0rXEdr/s56IDKdSqqH6Wc9d7/DrhdhykSsi+78neueELCgxFcNsjq51WsWd6t4kcZlFXcNgJPo9NQDtLqEbVbtmxBy5Yt1U3IHLDy8wsvvKDuz5w5E23btsXYsWPRqFEjvPXWW3j99dcxZcoU02ucOnUKMTExpvvTpk1DRkYGbrjhBjVC1niTUshGUjp5zJgxqF+/PkaNGgU/Pz81F640BpNtDb27n9scqKwlowcG3NlL/VynRU3UaVnTYoLx4jbSdh3dQc0hZm+NO9VXB+K8o9RN6+LthUYd66ngSAyc1Pu6o9eJ7EX2x34Te5RogvvAMoHoM66b1d9Hp5FjyR2GYwkRXR/jR88n8UjVBpWL1Qvf3ci5acDtveAX4KfuD51SslhZYjQpm+8IQ+/pX2SiTRJqgyf3VT/LdAVdRrZTjbdEzvqO9Z3YvUTPVdc/bnLtqo4ld/SCn7+vs1eFyG0whvR814tZXEeeUVmq0dZ4K5i3nN8mGM5vzbo1QqXaFVTHPWtzkH0n9EBgcOmmHyqONv2bqwbhwtZRzmPtBrZEVHQ5dV/mjmcjLdxk33WPWMkasj/K9YxUcrWWu13/SBn1PuO7OXs1yJXnqHU3nKO2eGSXeHPcJ1gxc23BnWvcsNONlAiQv2vyO+Nx42PDTMtlIu5Hur2AzPRMiwt8CUqkfILxX/MAKaxcCD7b+CbKV7P/iFqxd91BPN7nZWRnZluso5yQ/IP88PHa11Cz6bUOCz+//hemPz9TxYyl/XYbt1vezz7vdnHHfcIl5Nluhe13puV5Pw87fqaFrkvu8wv6bpSvGolPN7xh9fy0RlcuXMX97Z9W89XmmPfIdKH9zrgOd783ATdMHQpnctb8ED3aPWuTOWpXbnqdc9SSW2D8WHz71h/EY73zxyyFnVNcUp5zi8RbUkXlk/VvmDrpSYPr67d8qOblLfC0nPf8nnvuvP21Mbj1mVEO+COkITYbLwx/G5sX7igwdhh2b3888Nkk0/3YUxfVOTjhUqJFwu26sYkdYxayUt64qLAYL/cawRmfad7XML72g59PUon6krLl9Y9djyU1y+PT9W8gtFyIM9fMKXPUMn4kLWIMWTzZ2dl4ceS72DR/W4Fxousc23MbLwuaq1Yd8/Of3x7+crKpY5zYs3Y/nuj7ioq1LGLlIvIsUVXKqTxLeAXrK5eVxNYlO/Hs4DfV+pivozRoBYUGqXWpUufayL5vnvgRv78317r8TCGPLW7MwhxkCZk6F5ht35ycwrevAz9Ta+NQiatkNP7H/72G4LBglMSFk4brn8TLxbv+cWYO8pGvpzisw29hmIO0P/foNkAOJQe/J2fcj8lvj7corSE/3/7aLbjpsWEIDguyKN9kbY8wR5DSIEbVG0fj2V8ftmikFXVb1VJBRsehbUx/g/z9HYa0xqPf3YOmXRuaHuvj54Pet3bF55vfdlgjrXFU7Sf/vY42A1qYzqdyQuo8oh0+2/iWRSOtGPvsaDz144Oq5J2RBFM3PjoUd7xxqyoxayQlaie+cjNufmI4ypQNtih3cs9Ht2Pw5D4W27FB2zqY+s0UdLuxo0WvI+klSNaTfc30s5cOnYa3xdRv71GfuZGvv48apfrA55NQraH5ZxqI0Y8MwaS3xiKqqqE3o5CyjBNeuhm3PDVSlQAxktI093wwEUOm9FXliY3qta6NR766Gz1u6mTxmbbq3VR9B1r3bW6x33W7sYPaB+q3qW16rOwjA+/orZLYJW2kNax7WfV97H9bT1UG2ahhh3qY+s096DqqvcWI28JGmtua+XegRuOqeG7mI05vpHUqvY1uRORxGnWsj0/Wva562hvPcXJ+k5hl6rdT1KhbI29f63s+251OjvnXzpFyvpQLYvNGWuP555lfHsYdb4xFeMVrSbPI6HK4841bcePUoeo8bSTn76d/etBhjbTGXtcvzX4cE166CWFR19Zdyhzf/+md6mZOYtvPNr2FXrd2hY/ZZyOxsMQD7Qe3svhMOw3LjVk6N7CIlftN6G6IWXLLKougkECMengwJr09ziJmkXLSVlYQpNwEl2y7a59dJO56exxGPTgYgSEBFjHLg9PuQt/x3dVnY9REPtNv7yn29Y9UPJHXqdGkqsX138gHB+Gud8ahfPVr10VS0nf8Czfi1mdHWTRGVqpVQXVykw4C/kHX1r128xp4adbjpWqkLer654ZHh+W7/gmQa1d773g6wD/PsWTwXX3U8dHZjbROw/iRiAoho+Fe+usxTHjRMmaR88td74zHiAcHqfOOZfzgpACioPfNbfzyNauWINX7Xv77CYtGWtGkS0N8tPY1tO5nmWfpOrq9yrM0aF/X9FjJiQy8vZdDG2mF5IA+WPUyWvRsbBFXSh7w881vWTTSConvpBGpcq0KpmUhEWUw5qmRKg41L/cvceCkt8Zh1EN5YpYmVVX8KHGkRczSxRCzSNxpnnd22ufv5gy5W0MyRvJ/3W/qhIe/ulvlBfPGLPd+fLvFZ10mPBg3Pzkct71yc4HXPzc8Ynn9U71RNB749E5Dfs//2mfaqFN9dV0o14fmcWj7Qa1UHNq8+7X9Tq5Jet3aBQ99ORm1mlWzOAZITCnfpZI20ooK1aPUPt1zTBeL6x8Z/S77nfn1j3xfdUWMnrclX7PvgBxLXpnzpNMbaZ1Kr50cJEfU0nV7tl04cdGU2DGWE8hIz0TsyYvISMvElFaPu9zoCAl0pKHpvk/uUI0sUVUjr3siT7iciKuxCShbPhShESEWo/ySriajXOUIlWhyJhnlcPVigmqMCwk3zN9cGOlpdPF0nPqMJMA1ltgyfqbye+nVbfxMMzMy1XIJiuRkZdxeqclpiDtzCYEhgYisfC3JIdvk8vmr2LvuAD6Y9KVd/26PpQPu/fB2FaTn/Uwvn7+C5PgUi/3O4jOtFmlKJsvInvPHYw2faY3yKog2faYn41TAYf6ZpqWkq9eRi53IKtcSpsnxhs9UgmrzBtf4uATExyUiomJZiwZ9GfmampiqAjNbl+FJTUpF3NnLKslWrtK1DiOJV5Jw5UI8dq7ci0/u/QaOOJa07tsM9350O/wC/VSJH1e5KHBab7a2NhpRu5kjask9cDSEbWMWmds1JSEFf37wLxb9sEKN/HQ1by9+XiWSinN+k/U/fyJWnRssYuW0DMSeiit2HGpPWZlZOH/iokrISDxwvY5OyQkpuBxzRZ3zzRODxs80b6xsbcwi8ab8+0SfV9Q2IuvJvib7qXyWao7h3M+0sP0uJTEVl85dVp1tIyqGl+j6R32mZy4hIzVDfT+MU10YP1OZO6tSzWtxaGH7ncShcm0hDbbG0om2Iusof79USyrs+mdqtxdUvOsI7yx9QTUS2yNWdrsRtYwfSYMYQ1pP4qqY47GqQcn8/JaeKjmMSyof8GDHZ+Eyo2lh1tg6qj0mvnxjvjxLYZyRZ7HWldh4JF5OQrlKZa/bICbnWBmhmJWZjQrVI+Hr52sRK9sqZtmyaAe+mDrdbRpeXM1j39+rBkNIns18EFbc2UtITUqz2O9Mn2lGlvrs8n6mxb3+uV5+r2xUqEVHNolDE69IHBqO4NBr6yhxaHpKukUcaivXu/7Z8O8WfPvkz3avGCRxc9cbOmLCi8U/ljgKc5D2d62JnqgAcrCtXNswSbw5ueiNrlcZZw6dc7lGWiHlOSS4kXUsLklOmCcojOQA7cjea0WRE1dxe2HLCbGgkb+FfaZywi1oe8kJumr9a73TjeTkJbdtS3a5RylDFySfhQSh1cx6/xtJQGoelBb1mUqgW+hnWjf/ZPMBQf4FfqYSeBcUfMsoooLmZDZvuLc1mbO2oHWUZL/cNv67VV0M2XtOMnn9S+euWHUs8XQ6KclU2tKHrlG7ioicELPIxbncVIndbNdrpBUyT1pB56CCSKNU3pEFQhomXeXc4ePrU2A8UBhJiJgnRa73mVobs8joSmPyj0rm6oV4q/Y7aWwNKmCftub6R32mVSOL/EyLs99JHGqv74ZKGJqN8C3o+keSbY6it+JY4ukYPxJRceOqgs4d0igj546Dm484b0MW0elO8gbScc2aY74z8izWCi8fpm7FPQfLwIHSxsrXi1nW/LlBndddsbOnq5PPSBpjC8pBFtQgaKvP9Hr5veLm4W3dwc+a65/lP69Rpchlih97khLM0mDM+FGbMSTrlVKpSFkSVyx7LA040nuH7E/KJ7ORtmQkQS0jFagk+1243RtpjccS6cV36sBZ1ZOQ8+3lzr1jixsRaZqMHnDVqRNk1ADZX3ETf1TAtnORTqTuSEZtOIxOp2JIqVCkeYwficgGzEuuOlwR17DSgCMjEckxOUhX7ezp6iSfxRxkKXKQZvPY2nNErezjEj/GnmblIa3FkK6ZHSG3IT1fZK4A83kjXYE04Ay4vaezV0MTpGa/ebkMKj4ZmS5zkZD1Oo1oazE/mz2PJTtW7MWdjR7GuJr34q5mj2Llb//Z/X2JiDydzL8uPYZdiXQ+rNWsOmo0uTYHEtnPoEl9HDbfvCeR/XSgluepKqWBd/Z2yLWrTJnxZN9XVAx5Q9Qd+Pier1WZSyIiKjmp7NC8R2Mn5CCLTvJLA07/iT0ctjZa1nV0B4v5gKn4pCpi+0EtuclKoPtNHVUjqr3J9fHaWZtU/Di2+j24p/UTWDd3s93fl1wDr4yp1G579RZ1knSVxlpZjyZdGqiJycn+pATN5HcnOG9Tu96A7mK74/VbCyytQdcnJbknvTXOIZtK5jkzOrXvDF4f8xH+eP8faJZco+aU8uYendmIyI7qt62DnmO6uMy837IecpvywUSXWSdPN+y+/ihfPVKNQilQYR+Dhj8euc6REnRD7+nn7FVxWyMfGqSqpdg72ZaZdi1+lLma53+7DA92fEa7jbWMH4nIRu56e5w6H3o5urpfIfGhdKBqO6AFWvZu4tj10XBj4+2vjnH2arilye+OV+WJyXpSpnz8izc5ZNPJnMBGR3eewIsj3sH8b5ZCs/TayUG6RssaubUajaviw9WvqBEI5iRwslmeS2cIfszvt+zdFO0GtrRIpskFd59x3fDG/GdUzXxyjEGTeuPxH+5D2Twl7CrVroD+t/dEYIhhInqjOq1qocctneHjZzlNdotejdUIXfPPWpJ3nUe0RZMuDS0eK5PT9xnbFTXzjHqRoE16ykviz1xklQgMnNQn39xq0fUrq1E9eUdnNmhXB91u7GC5H+mA1n2boU3/5hZJQnlM1xs6oGGHehav4R/kj74TuqNqnvkfZB0enHYXRj8yxGI5WWf4fQPwyNdTVAl2c1XqVUK/23ogoIzlfmcLxtLH3zz5o2bLkBjnhyjtjYjoien34cZHh6pzuv0OWpZ3wyuEYdBdfdS/eWOWNxc8i5a9mvKDcWBlno/WvobWfZpZfE4SH0qv9Xqta1s8PrBMAPrf1hNVcucaNZL4Uz5TKRNmrmLN8qrCTlBooMXy2s1roNeYLvD1t4xDm3VvhI7D2ljGod5e6Di0jfqdOd8AX/S6tQtqN7e8/gkKDcKAO3qp985bLk3i5XwxS92KKmaRv81cvTa10P2mTvDxtYxD2/Rrjo/WvlrgfF5U/ETbx/+9jhY9LRPqsj/0vKUz6rSqabFcdUYuwTVt3ukypErL+RMX8dOrf2ryo2L8SES27Oz33vKX8uVZSnq8Lox5PCB5x3YDm6FV76b5YpYhd/fFS389yiohDiTXDw98NgkhEZbxULWGVVQOTnJx5hp1rKdydub5PflM2/Rvgdb9LPN7Ent1u6mjygmak5yh5A4lh2guLDJExXjSCcyc5CQlJsxbgbBWs2roPa5bvuufJl0boNNwy4qVsg92GNKq2DGLxLySg5XrGnNy3fPE9PtVrpRKbszTI3HvR7ejTHiwxfIaTaqiz/hu8A+0fSO4carBTx/4DgmXEqFFOg3lIHV6DU24l5CQgLCwMMTHxyM01IFz02jIkR3HcebgOaQkpuLDyV/Z9LUlgfHod/eoLIUkLyrVNJx4pLHkwMbD0Hl5oUnn+pyzyYmys7Kxc9U+xF9MQIXqkarhUoKftJR07FyxxzBpfcNoU6N+wuVE7F69X/UWqtu6FirnJt4unrmE/RsOqec27lwfERUNAc/pg2dxbOdJlRyTcjcyGlUOYYe3HcO5I+dVcqxFz8aqh1hOTg72/ncQcWcvq3nwJOjx9vZGZkYmdq7ch8TLSahUq7wK8uV9UpNS1fL0lHRUb1xVdUAQVy/GY8/aA6r8hARqFapHqeUyX+mBTUdUENW0awOUjTIkfE/uO40Te06rcmeyLoFlAtU6Htx8BDHHYlUg2bxHI/j6sVSLrWRlZmHnyr1IuJSECjWi0LB9XcNnmpyGnSv2Ii05Dav/3IB1czbZrMymfO7jnr8B41+4EVo5pxnfr1fLp+DjXbpG8KzsNCzf/hbPx+QWGD/aX3J8soofZATa/G+XqpLztpqHXM4Hox4erM730kjWvHsjlaQxj1nKV4tUCRyOpHWemGMXcGjrMZUca9qtIUIjDB3rju8+iZP7zqjrgOY9myAgyF/FVfs3HsaFExdVckwaUX18fdRnumv1PlyNTUBU1XJo3Km++kzTU9PVPpWamKqSa3VaGJJaSVeTsUv2u/RMleiqUqeSWh537jL2rz+kfm7UqT7KVTLEoWcOx+Do9uOqkpC8p3QOFEe2H8eZQ+dUHCoxnlSbkTh037qDuHjmMsqWD1WPlzhUYhZ5T0m0lK9ecMxSvVE0ajbNjZUvJaq/SeIX8+sfso2zR2JwZNtxlWiXz8jYAC6jF04fOIuUpDR8eNeXNt3ckuj9K+4HNQWKFs5rjB9JyxhD2pfEA4e2HFUxxJUL8Zj28A82fX2JG6WDvcxt2KB9XVV2WcQcj1XvK/FkM4lZ8gwGIMeR/J7EeMlXk1GpVgXUa1NbxVWSk5YcUUZqhmpEq97oWn5v95oD6jqjYfs6KF/NkN87fyIWBzfLZyr5vYaqU5c4sfc0Tu49rRp+m0t+LzhA7XeSCzx/PBah5SS/19gQh2Znq/ym7ItR0REqhpQpPjLSMtQ6piSkoErdSqjbqla+65/aLWogup6hAfhSzBUVQ8r7yPVJZBXD3Mfnjp7HYYmVC4lZ8sbK+9YfQuypOIvrH7KNjPRMleNOjk9B5ToV1Wcq+11yQora7+QzXfjDcmxftttmOUhptJ/y/kSMemgwnIU5SPtjQy3ZxYZ/t+L5YW/Z/HVnnv3alCwhIiquR7o9rxrcbUUaaqUH41M/Pqi9IKmFNNSWbn7grOx0LN/BhlpyD0yyOdbtDR5SjV62Ig1/Q6b0w30f32Gz1yQibdi8cDueGfSGzV/355NfmBL+mmmoZfxIGsQY0nGW/bwGb43/xOav+0/ST6rhi4jIGpOaTlWN/La8ppUqkQ9+PslpHwRzkPZnWe+JyEbylnawCZ1hVC0RkbVk1Iv0QDOWDSn14UinQ1CIZSlFzZBCHKUtxqGdYh5EZKW8paRKS3qUcz54InKZa9rcSlGaw/iRiNzseC2jK/NOk0BEVBwhck0rJbX1trymZQ7S03OQnKOW7ELKM+Sd+6s0pIFF5g7QbMMIEZWKzPNmq0ZaIeUV5TWJiMi2pFqBLUsQS7mpbjd2tNnrEZF21G9XJ9+cc6W9pm3ZuynnGCYisrEWvZrkm5O+NLy8dYY5Tb1ZLpaIrNfj5s423Wy8ptUGNtSSXUjt+xumDrPZ60kDy5inRtrs9YhIWyRJX7V+ZdUr1haqNYpW84JoUo6NbkREBeh/Ww8EhthutFnjzg1Qq5lhvk8iImtIgv62V26x7TXt0xq9pmX8SER2JOWJh983wGavp88BbnpsuM1ej4i0pe+E7mqaCy8b5SAbdqhnmt9Yc3K0k4NkQy3ZzcHNh1WvYVuQgRUyEToRUUn4+fvinWUvolbzGuq+NNh6+5a8d+z547FIjk/R5Ieh0+ttciMiKsi5oxeQkpBqs41zav8ZZKRncmMTUYkMuKMX7n5vAnz8fNRof5kjrKSD/uX5Wr2mZfxIRPZ2YPMRm+UgpczogU1HbPJaRKQ9UhH0vRUvoWr9KqYBbXIrqdMHziA9NR1apNNQDpINtWQXcecuY82sjTYrNSrfp78/nY+cHDfpAkFELieycgQ+3/QWPlzzKm55aiRufHQY6retU6IebplpmVgyY5Vd1pOISMvmTltks+oHIvFyEtb8ucFmr0dE2nPD1KH47ezXuO+TOzDq4SElHrUlif85ny1Adna2zdeRiEjLzhyOwfalu22Wg5QOObM+nmeT1yIibapUswK+2fU+3ln6Am5+YjhuenwYajSpCi9v6691k66mYNXv6+2ynuQ6OCs62cXRHSdsOh+kuHTuCq7GxiOiou3mCSIibZGRDE06N1A3cWPFScjJsr4DiPTUPbhFoz1spedMaXujuUlvNiJyvH3rDqo5eGxFqicc3HwEvcd2tdlrEpH2hJYLMTXQ/v3ZAhVTSsOrta5ciMflmKuIii4HTWH8SER2dGjLUZsfss4cPKdGsPkH+tv0tYlIOyRebNmrqbqJWR/NQ052TomvaftN7AHN0WsnB8mGWrILXz/77FpScoqIyHbHFO8S97D19dXo8UhDQRIROZ6vv69tX1Bvv7iUiLRJjiklaaTV9DUt40cisiN7xXqlKVVKRGTLY4pmr2n12slBavQTJntr2KEuAoL9kZZso/rpOqBcpXC8OOIdZGVmo3HHehgypR+i61Uu9UtL6amN87Zh0Q8rcPHMJURWiUD/23qiVd+mWPvXJiz/dQ0S4hIRXb8yBk3qg2bdG6keMUTk/joOaYP53y61evSWPL7twJZ2Wy8iIq3qMKQ1ju85VaKexgXJzspWc5bd1/ZJlK0Qhr7ju6PzyHbw9St9g/CFkxfx71dLsHPlXtWBp2Xvphg8uS+Sribjny8W49DWo/AL8EWnYW3R77YeCI0IscnfRETO1apvM3V9Kh1BrK3IUrNJNZSNCrXXqhERaZLk6WQOcckX2oIcrytUj8JjPV9CTo4eTbs2xJApfVUp09LKyszCujmb1VRKl2OuoHz1KDUfetNuDbFy5jqs+v0/Vea0eqNoFVc27lTfJn8TETlf+8GtsPrP9dbnIDOzmYPUAJ2+NF1B3UxCQgLCwsIQHx+P0FBeHNnbd8/8gt/e/rtUvY3NmZeXkjklpbTyw1/ejUGTepf4NdNS0vH8sLewY/keVSNekoLGf/2D/JCekqECNHkvmS9NDqR9J3THo9/dA29v9qwjcncn95/B3c0fM8wVZsWhqlzlcPx0fBp8nDiq1tHnNOP79W74KHy8S1f+KSs7Hcv2v8/zMbkFxo+OJZ3mbq//IDLSM202jYbEjVLm3stLp5JtdVvVwttLnkdIeJkSv+aavzbg9Vs/UutobFQ2zjck941xo5BYskxYsJqfqE7Lmjb5m4jIuV69+X2snbXJ6k4lT//8EHqN6QKtnNcYP5KWMYZ0rE/u+0Z1oLPZPLW5uUBjjCed8p6c8SB63tK5xK+ZHJ+Mpwe+jv0bDufLQfoF+iEjNcOU+zTGksPvH4D7Pr6DA0aIPICUL36g4zNWH6eq1K2I7/d/DC8v6+e3tRXmIO3PeZ8uebzbXrkZ3W/qqH6WAMOYKCsp8wZfSbbJQe3Du7/EvvUHS/ya0x7+AbtW7jW8Zu5FtvFfaaRV75t78DQm25b8uAp/vPdPid+TiFxH9YbReOGPR1UJEbkQKy7pqSvJfk3KsdGNiKgAMm/ja/8+Df9AP8vjcimKmRjnIjcet4/uPIF3b/u8xK936sBZvD7mQzVa17yRRn423jfvJS2xZHJCCp7q/5rqJEhE7u/Rb+81jXIydtLw8r7+gSozPROaxPiRiOxsyvsT0W5QK8scZDGOy4Uxb0iR+E5iu7fGf4Lju0+W+DXfv+tLHNx8tMAcpDTSmuc+jbHknM8WqgZoInJ/9dvWwVMzHlDHKGP8WJyinZKD1NBYS83GkGyoJbvWXX/ml4fx4ZpXVZk5KQfXboBtS4V6e3vhr4/+LdFzr16Mx+LpK61vbNEDf37wjypXQkTur9Pwtmp07MSXbkbbAS3UxV2FGlFFNtzGX0zAmj83OHQ9iYi0okXPJvj5xBe4661xqsSTHJurNahiupgtLUmIrf9nC84dPV+i58/5bIGhCIPeuveMj0vAil/Xlug9ici1BIUE4r0VL6mOJdI5Wa51W/ZuVuRzJBH32ztztJtoIyKyI78AP7w650lVwaTXrV3VcblN/xY2fQ85jv/96YIST5khFVmsnt5DB/z+7hzk5LhJSwMRFUmOTz8em4ZbnxmFNv2bqxxkRMWyRY6av3DiIjYv2MEt6+E4Ry3ZlRxkmnRuoG7i788WqPlgbXVxKj3MtizcWaLn7ll7QI2EKAlppDm57wxqN69RoucTkWuJqBiOsc+NVj9npGVgcNDYIh8vvd+2LduF3mO7Qmt0er26lfY1iIiKElouBDc+NkzdxJDgsTabt9Zo+7LdqFy7otXP27xwu2mUrjWkVNW2Zbsx8M6ST9tBRK5DvtPtB7VSN/Hl1OnYsWKPmkesIBL+nD5wFlcuXFWxp5YwfiQihxxrdDq07NVU3cTPr/+FLYt22iyGlBzkpgXbS/RcOT9YO7e5ogfOH49F7Kk4VKxRvkTvTUSuV0Vq4ss3q5+vxMbjpoqTiny8t683ti3dhQ5DWkNrdBrKQbKhlhxKBUfSQcSG34+S9iorbaBm62QhEbmG4oyyl3O8Zo8B8seXNshxkyCJiFyHzUcR6Ep+HDcva2wNPa7NZ0tEnie7mN9vTR4HGD8SkRPI8bY4ZUXtcawvaF1KQ5PnDiINKO53W7PHAL12cpAsfUwO1ahjPasnzC6KlMAzzg1krQbt6hRZVqAogSEBqNqgSomeS0SuLSDIH9UbVy3y+CANBo06luzYQ0RE1mvYoZ7NSh8reqBRCWPIpt0amuY+s/Y9G/PcQeSxJDYsbDStUWR0OURU0tZoWiIiZ+YgS9rBriAS/zXr1rDE61JSZcuHoUL1qBI/n4hcV3iFMJSvFlnkYyS+LOm1K7kPNtSSwyfNrtu6VsmSW4X0Jhn50OASPbd8tSh0HN7G6qSfl5cOQyb3VY05ROSZRj88uNAS7TJ3bWCZQE2WPVaks40tbkREVhj10GCb9SKWOFSSZSWdwmLE/QOtTvpJ5x+/QF/0ndi9RO9JRK6vy6h2Kple2PWl9AEc9eAgVTJZcxg/EpETyDy1VepWsllnP4n/JA4sieqNqqJZ90ZW50Ml/yDv6e3jXaL3JSLXJnHhyAcHFTr6X45fYVGh6DKqPTQpRzs5SA1eIZAzSZLq+d+mIiwqTAUb5svVv146iwBKGkUNvzAk1YyMP495eqRpTqCSeOSru1GlTkXD++c5IMp6mN4/d91Ek64NMfEVQx15IvJM/W/viX639VA/WxyTfLzg4+eDl2c/jqCQQGi67Ehpb0REVug0vC1ufHRo/uOy97VYLW/cpmI3+Z9ZjCfLwiuG45lfHi7x9m/Qri6mvD9R/Wwen1qsi9k6ymNkXqEX/3wMIeFlSvy+ROTafP188ercJ+Ef5JfnOGX4ufPIdhj1cMk6Gbs9xo9E5KQGkJdmPY4yZYMtjsvG/J7KQVrEcvnzjmp57s+T3hqHJl1KNqJWPPXjg4isUs4iH2rMRXoVkg9tO7Albn5yeInfk4hcnzTUGhti88aQ/oF+eGXOk/Dz94Um6bWTg+QcteRwlWpVwNc738O/Xy3B4ukrEH8pERVrlMfgyX3RsldjzP9mGVb+tg6pyWmo0aQaht/bH9H1K2Pu5wux/p+tyM7KVuWORzwwEK37Ni/VupSNCsNnm97Cwu+WY943S3Ep5jIiKoZj0KTe6DisDZb9tAZLflyFpKvJqFy7Iobc3Rd9xndTF+FE5NkXdI99dy86Dm2DOZ8vxNHtx+EX6IeuozuoY0+VOpWcvYpERJoinerueme8Ghnx92cLsH/9Yfj4eaPTsLYYdt8AnNhzCnOnLcLJ/WcQWCYAPW/pgoF39sT2ZXvw79dLcOHkRYRFhmLA7b0w+O4+CI0IKdX6jH5kCOq3q4PZH8/DjhV7VWNw637NMfz+gYi/mIA5ny3AoS3H4Bvgiy4j26lzR9X6nDaDyNNJR45vd3+AOZ8vwopf16prWhlFNeze/uh+U0d4e3NEFBGRI9VoXBXf7H5fxYlLf1qN5PgUNWBjyJT+aNi+jspNrv5zAzLTMlG7ZQ01ejWySgRmfzofWxbtVNO3yUhYaUhp1q1RqdYlKrocvtj2jsp7Lvx+Oa7EXkX56EgMmtwHbfo3x6IfVmL5L2uQkpiq4kY5d/S8pTNH0xJ5OBkx/+zMR7D6jw2Y+8UidW0bGByAHjd3UteXLH2uDTp9YbUdC7F69Wq8++672Lp1K2JiYjB79myMGDHC9PukpCQ89dRT+Pvvv3Hp0iXUqFEDDz74IO65554iX/evv/7C888/j6NHj6J27dp4/fXXMXLkSIvHTJs2Tb23vG/jxo3x0UcfoWvX4peeTEhIQFhYGOLj4xEaGmrNn01ERORSHH1OM75fn1oPwserdKXfs3LSsfTYJzwfawjjRyIiIu3FkIwfqbQYQxIRETkfc5AuWPo4OTkZzZs3x2effVbg7x955BEsXLgQP/30E/bv36/uP/DAA5gzZ06hr7l+/XrcfPPNGD9+PHbu3Kn+vemmm7Bx40bTY3777Tc8/PDDePbZZ7F9+3bVQDtw4ECcOnXK2j+BiIiISkpDZUfIdhg/EhERaRjjRyohxpBEREQaptdODtLqEbUWT9bp8o2obdKkiWp0ldGxRq1bt8agQYPw6quvFvg68nhplV+wYIFp2YABAxAeHo5ff/1V3W/fvj1atWqFL774wvSYhg0bqvd+8803i7W+HFFLRESewmm92Wo+YJsRtcc/5YhajWL8SEREpLERtYwfyQYYQxIRETkHc5AuOKL2erp06YK5c+fi7NmzkDbgFStW4NChQ+jfv3+RI2r79etnsUwev27dOvVzRkaGKrWc9zFy3/iYgqSnp6udyPxGREREpZCjt82NyAzjRyIiIg/G+JHshDEkERGRB8vRTg7S5g21n3zyCRo1aoTo6Gj4+fmpkbEyt6wET4U5f/48KlSoYLFM7styERcXh+zs7CIfUxAZaSu9N423qlWrlvrvIyIi0jR9jm1uRGYYPxIREXkwxo9kJ4whiYiIPJheOzlIuzTUbtiwQY2qlVGw77//Pu69914sXbr0uiVMzMlo3LzLivMYc08//bQq52O8nT59ukR/ExERERHZD+NHIiIiImIMSURERFrkY8sXS01NxTPPPKPmrR08eLBa1qxZM+zYsQPvvfce+vTpU+DzKlasmG9kbGxsrGkEbWRkJLy9vYt8TEH8/f3VjYiIiGxEprYv+fT2116DKBfjRyIiIg/H+JHsgDEkERGRh9NrJwdp0xG1mZmZ6ublZfmy0siak1P4EOOOHTtiyZIlFssWL16MTp06qZ+lhHLr1q3zPUbuGx9DREREDqCh+SHIMRg/EhEReTjGj2QHjCGJiIg8XI52cpBWj6hNSkrCkSNHTPePHz+uRsxGRESgWrVq6N69Ox5//HEEBgaievXqWLVqFWbMmIEPPvjA9JwJEyagSpUqag5Z8dBDD6Fbt254++23MXz4cMyZM0eVSl67dq3pOVOnTsX48ePRpk0b1bD79ddf49SpU5gyZUrptwIRERER2Q3jRyIiIiJiDElERERkg4baLVu2oGfPnhYNqGLixImYPn06Zs6cqeaGHTt2LC5fvqwaa19//XWLBlVpYDUfdSujYuV5zz33HJ5//nnUrl0bv/32G9q3b296zM0334xLly7hlVdeQUxMDJo0aYL58+er1y8umdNWJCQkWPtnExERuRTjucx4bnMYDZUdIdth/EhERKThGJLxI5UQY0giIiLnYw7S/nR6h2d4nefMmTOoWrWqs1eDiIjIZk6fPo3o6GiHBGVhYWHoU+lu+Hj5leq1snIysDTmK8THxyM0NNRm60hkD4wfiYjIEzkihmT8SFrGGJKIiDwNc5AuNKLWnVWuXFntTCEhIdDpdCW+0JDGXnkdJpe5Xbi/lAy/R9wu3GdKT/pZJSYmqnMbEdkP40f7YTzA7cJ9ht8le+IxpmCMIYkcgzGk/fD4zu3C/YXfI3viMSY/xo/2p6mGWim3bKseo9JIy4ZabhfuL/we2QOPL9w2xSUjXB2OpetIYxg/2h/Pe9wu3Gf4XeIxxsNjSMaPpEGMIe2PMSS3C/cXfo94jHEc5iDtS1MNtURERFRKOTnyfzZ4DSIiIiLSBMaPRERERMQYslBehf+KiIiIiIiIiIiIiIiIiIjsgSNqreTv748XX3xR/UvcLtxfSobfI24X7jNujKXriKzG8x63C/cX2+B3iduF+4ubYvxIVCI873G7cH8pPX6PuF24z7gxvd5wK+1ruAGdXmYCJiIiIipCQkKCmo+iT+Qd8PHyK9W2ysrJwNK47xEfH8/53omIiIg8FONHIiIiImIMeX0sfUxERERERERERERERERE5GAsfUxERETFlyOFOPQ2eA0iIiIi0gTGj0RERETEGLJQbKglIiKiYtPrc9StNEr7fCIiIiJyH4wfiYiIiIgxZOFY+piIiIiIiIiIiIiIiIiIyMHYUGtm5cqV0Ol0Bd42b96cb+NdunQJ0dHR6vdXr14tckP36NEj32vecsst0Pp2SU9PxwMPPIDIyEgEBwdj2LBhOHPmDDxlu8i2GDBgACpXrgx/f39UrVoV999/PxISEjS9v5R0u7jz/lLcbbNz506MGTNGbZPAwEA0bNgQH3/88XVf29P3mZJuF3ffZ1ySXm8oX1eam7wGkYdg/Oj47eLux3bGkI7fLu68zzB+dPx2cef9xWUxfiTKhzFkwRhDlny7MAfJ+NHafYY5SMaQLk+vnRykTq93kzV1gIyMDFy+fNli2fPPP4+lS5fi2LFj6kBmbsSIEeo5CxYswJUrV1C2bNkiG1Hq1auHV155xbRMLhbDwsKg5e1yzz334J9//sH06dNRrlw5PProo+q9tm7dCm9vb7j7dpG/f+bMmWjbti2ioqJw5MgR3HfffWjVqhV++eUXze4vJd0u7ry/FHfbfP/999ixYwdGjx6tkkrr1q3D5MmT8c4776hEpFb3mZJuF3ffZ1yJJMFlf+odNh4+Or9SvVaWPgPL4n9EfHw8QkNDbbaORM7A+NHx28Xdj+2MIR2/Xdx5n2H86Pjt4s77i6th/EhUOMaQjt8u7nx8Z/zo+O3izvuLYAzp+O3i7vuMK0nQYg5SGmqpYBkZGfry5cvrX3nllXy/mzZtmr579+76ZcuWSUO3/sqVK0VuRnnsQw895BGb2lbb5erVq3pfX1/9zJkzTcvOnj2r9/Ly0i9cuFDvSdvF3Mcff6yPjo4u8jFa2V+s2S6etr9Ys23uvfdefc+ePYt8jBb3mettF0/cZ5wpPj5eHdd7h43X9y97Z6lu8hryWvKaRJ6G8aN9t4snHtsZQ9p3u3jaPsP40b7bxdP2F2dj/EhUfIwh7btdPO34zvjRvtvF0/YXwRjSvtvFE/cZZ4rXYA6SpY+LMHfuXMTFxeG2226zWL5v3z41am3GjBnw8ir+Jvz5559V+aTGjRvjscceQ2JiIrS8XaQ3SWZmJvr162daJmXMmjRponqqeMp2MXfu3DnMmjUL3bt3h9b3F2u3i6ftL8XdNkJ6/ERERFz39bS0zxRnu3jiPuMScnJscyPyUIwf7btdPPHYzhjSvtvF0/YZxo/23S6etr+4DMaPRNfFGNK+28XTju+MH+27XTxtfxGMIe27XTxxn3EJOdrJQfo4ewVc2XfffYf+/furIe7m89XIPDfvvvsuqlWrpobEF8fYsWNRs2ZNVKxYEXv27MHTTz+t6sAvWbIEWt0u58+fh5+fH8LDwy2WV6hQQf3OE7aLkWybOXPmIDU1FUOHDsW3336r6f2lJNvF0/aX620bo/Xr1+P333/HvHnzinwtrewz1mwXT9xnXIKaMaGUsyZw1gXyYIwf7btdPPHYzhjSvtvF0/YZxo/23S6etr+4DMaPRNfFGNK+28XTju+MH+27XTxtfxGMIe27XTxxn3EJeu3kIDUxovall14qdPJs423Lli0Wzzlz5gwWLVqEO++802K5NH40bNgQ48aNs2od7rrrLvTp00f1orjlllvw559/qtrn27Ztg5a3S0Fk2uS8c06463Yx+vDDD9Vn/ffff+Po0aOYOnWqpveXkm4XV9xf7LVtxN69ezF8+HC88MIL6Nu3b5HroJV9xtrt4qr7DBG5PleIkzz92O5J8aOrxEqevs94UgzpCnGSVvYXwfiRiLQUK3n68d2TYkhXiJM8fX/xpPjRVWIlrewzgjEkOYomRtTKJM9y0ChKjRo1LO7/8MMPatLnYcOGWSxfvnw5du/erQ5AxgO0kHKjzz77LF5++eVirZNMWO7r64vDhw+rn7W4XWTkn0zgLZO6m/c2iY2NRadOneAsttwu5n+r3Bo0aKAe17VrVzVReaVKlTS5v5Rku7jq/mKvbSNlfHr16qWCn+eee87qdfLUfcaa7eLK+4w70+fkQK8rXdkQvd49yo6Qtjk7TtLCsd2T4kdXiJW0sM94Ugzp7DhJS/sL40fnY/xIWuLsWEkLx3dPiiGdHSdpYX/xpPjRFWIlLe0zjCGdT6+hHKQmGmrlRC234pITvHxRJ0yYoA4y5v766y9VIsFo8+bNuOOOO7BmzRrUrl272O8hvTGkbnlxT5KeuF1at26tXkdKs950001qWUxMjCrb+s4778ATtkthjzeWatHq/lLY44vaLq66v9hj28jnLQHSxIkT8frrr5donTxxn7F2u7jyPuPWNFR2hLTN2XGSFo7tnhQ/ukKspIV9prDHu2MM6ew4SSv7C+NHF8H4kTTE2bGSFo7vnhRDOjtO0sL+Utjj3TF+dIVYSSv7DGNIF6HXUA5ST/ksXbpU7QH79u277tZZsWKFeuyVK1dMy86cOaOvX7++fuPGjer+kSNH9C+//LJ+8+bN+uPHj+vnzZunb9Cggb5ly5b6rKwszW4XMWXKFH10dLR67W3btul79eqlb968ucdsF/msv//+e/3u3btNn33jxo31nTt31vT+UpLt4in7y/W2zZ49e/RRUVH6sWPH6mNiYky32NhYTe8zJdkunrTPuIL4+Hj1+fQKvFnfL2h8qW7yGvJa8ppEnoLxo2O2iycd2xlDOma7eMo+w/jRMdvFU/YXV8H4kej6GEM6Zrt4yvGd8aNjtoun7C+CMaRjtosn7TOuIF6DOUhNjKgtySTSUsZA5jsoCelBcvDgQaSkpKj7MpH0smXL8PHHHyMpKUlNTj148GC8+OKL8Pb2hla3i3F+AB8fH9U7SXrD9e7dG9OnT/eY7RIYGIhvvvkGjzzyiOqlJZ/9qFGj8NRTT2l6fynJdvGU/eV62+aPP/7AxYsX8fPPP6ubUfXq1XHixAnN7jMl2S6etM+4lBw9oNNIbzYiKzB+dMx28aRjO2NIx2wXT9lnGD86Zrt4yv7ichg/EhWKMaRjtounHN8ZPzpmu3jK/iIYQzpmu3jSPuNScrSTg9RJa62zV4KIiIhcW0JCAsLCwtDL70b46K5fSqgoWfpMLM/4A/Hx8QgNDbXZOhIRERGR62D8SERERESMIa/PqxiPISIiIiIiIiIiIiIiIiIiG2LpYyIiIio2fY4e+lKWHWExDyIiIiLtYPxIRERERIwhC8eGWiIiIio+fY5MEmGD1yAiIiIiTWD8SERERESMIQvF0sdERERERERERERERERERA7GEbVERERUbCxdR0RERETWYPxIRERERNbSa2j6NTbUEhERUfGxdB0RERERWYPxIxERERFZS6+d6dfYUEtERETFloVMQG+D1yAiIiIiTWD8SERERESMIQvHhloiIiK6Lj8/P1SsWBFrz8+3ydaS15LXJCIiIiLPxPiRiIiIiBhDXp9O7y5FmomIiMip0tLSkJGRYbPEXUBAgE1ei4iIiIhcE+NHIiIiImIMWTQ21BIREREREREREREREREROZiXo9+QiIiIiIiIiIiIiIiIiEjr2FBLRERERERERERERERERORgbKglIiIiIiIiIiIiIiIiInIwNtQSERERERERERERERERETkYG2qJiIiIiIiIiIiIiIiIiByMDbVERERERERERERERERERA7GhloiIiIiIiIiIiIiIiIiIjjW/wHDHzWyYpqnYQAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "\n", - "gdf = snap.exposure.gdf\n", + "gdf = snap1.exposure.gdf\n", "gdf[\"coord_id\"] = gdf.index\n", "gdf = gdf.merge(df, on=\"coord_id\")\n", "\n", @@ -2297,6 +1618,94 @@ "\n", "plt.show()" ] + }, + { + "cell_type": "markdown", + "id": "98159b83-677e-4c23-a926-d03da8c80f3b", + "metadata": {}, + "source": [ + "## Custom Impact Computation strategy" + ] + }, + { + "cell_type": "markdown", + "id": "825b9b95-3343-4250-8e1c-e89120359482", + "metadata": {}, + "source": [ + "By default, trajectory objects use `ImpactCalc().impact()` to compute the `Impact` object and the resulting metric, but you can customize this behaviour via the `impact_computation_strategy` argument.\n", + "\n", + "The value has to be a class derived from `ImpactComputationStrategy`, and should at the very least implement a `compute_impacts()` method, taking `Exposures`, `Hazard` and `ImpactFuncSet` arguments and returning an `Impact` object.\n", + "\n", + "For instance, if you don't want the matching of the exposure and hazard centroids to be done internally you can do the following:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f3b8d931-e4e5-40bf-b702-31183c6c7ec3", + "metadata": {}, + "outputs": [], + "source": [ + "from climada.trajectories.impact_calc_strat import ImpactComputationStrategy\n", + "\n", + "\n", + "class ImpactCalcNoAssign(ImpactComputationStrategy):\n", + " def compute_impacts(\n", + " self,\n", + " exp,\n", + " haz,\n", + " vul,\n", + " ):\n", + " return ImpactCalc(exposures=exp, impfset=vul, hazard=haz).impact(\n", + " assign_centroids=False\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "998fa84d-12e7-4e18-aa96-41ca4bac3ed7", + "metadata": {}, + "source": [ + "Note that you now have to assign the centroids before running the computations or else they will fail:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8d8d3b88-2c17-471e-acc3-afd8391a469d", + "metadata": {}, + "outputs": [], + "source": [ + "exp_present = client.get_litpop(country=\"Haiti\")\n", + "exp_present.gdf.rename(columns={\"impf_\": \"impf_TC\"}, inplace=True)\n", + "exp_present.gdf[\"impf_TC\"] = 1\n", + "\n", + "\n", + "exp_future = copy.deepcopy(exp_present)\n", + "exp_future.gdf[\"value\"] = exp_future.gdf[\"value\"] * growth\n", + "\n", + "exp_present.assign_centroids(haz_present)\n", + "exp_future.assign_centroids(haz_future)\n", + "\n", + "snap1 = Snapshot(exposure=exp_present, hazard=haz_present, impfset=impf_set, date=2018)\n", + "snap2 = Snapshot(exposure=exp_future, hazard=haz_future, impfset=impf_set, date=2040)\n", + "\n", + "impact_calc_no_assign = ImpactCalcNoAssign()\n", + "\n", + "static_risk_traj = StaticRiskTrajectory(\n", + " [snap1, snap2], impact_computation_strategy=impact_calc_no_assign\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a94d99b5-2c7b-418e-88e9-a9dff39ab21e", + "metadata": {}, + "outputs": [], + "source": [ + "static_risk_traj.per_date_risk_metrics()" + ] } ], "metadata": { From a2ae1f08f7106caec27b0834b5f88ff1ce880047 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Mon, 22 Dec 2025 14:00:24 +0100 Subject: [PATCH 33/61] Adds ref to notebook in rst index --- doc/user-guide/impact.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/doc/user-guide/impact.rst b/doc/user-guide/impact.rst index 9046118297..df7e459407 100644 --- a/doc/user-guide/impact.rst +++ b/doc/user-guide/impact.rst @@ -17,6 +17,7 @@ Additionally you can find a guide on how to populate impact data from EM-DAT dat climada_entity_ImpactFuncSet climada_entity_MeasureSet Discount Rates + Risk trajectories Using EM-DAT data Cost Benefit Calculation Probabilistic Yearly Impacts From 765bb0045a4fe8382b1ced64fa9e2dc7fbff0b08 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 23 Dec 2025 10:33:17 +0100 Subject: [PATCH 34/61] First suggestion --- climada/test/common_test_fixtures.py | 205 ----------------------- climada/test/conftest.py | 232 +++++++++++++++++++++++++++ 2 files changed, 232 insertions(+), 205 deletions(-) delete mode 100644 climada/test/common_test_fixtures.py create mode 100644 climada/test/conftest.py diff --git a/climada/test/common_test_fixtures.py b/climada/test/common_test_fixtures.py deleted file mode 100644 index 64ed519fe4..0000000000 --- a/climada/test/common_test_fixtures.py +++ /dev/null @@ -1,205 +0,0 @@ -""" -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 . ---- - -A set of reusable objects for testing purpose. - -The objective of this file is to provide minimalistic, understandable and consistent -default objects for unit and integration testing. - -""" - -import geopandas as gpd -import numpy as np -from scipy.sparse import csr_matrix -from shapely.geometry import Point - -from climada.entity import Exposures, ImpactFunc, ImpactFuncSet -from climada.hazard import Centroids, Hazard -from climada.trajectories.snapshot import Snapshot - -# --------------------------------------------------------------------------- -# Coordinate system and metadata -# --------------------------------------------------------------------------- -CRS_WGS84 = "EPSG:4326" - -# --------------------------------------------------------------------------- -# Exposure attributes -# --------------------------------------------------------------------------- -EXP_DESC = "Test exposure dataset" -EXP_DESC_LATLON = "Test exposure dataset (lat/lon)" -EXPOSURE_REF_YEAR = 2020 -EXPOSURE_VALUE_UNIT = "USD" -VALUES = np.array([0, 1000, 2000, 3000]) -REGIONS = np.array(["A", "A", "B", "B"]) -CATEGORIES = np.array([1, 1, 2, 1]) - -# Exposure coordinates -EXP_LONS = np.array([4, 4.5, 4, 4.5]) -EXP_LATS = np.array([45, 45, 45.5, 45.5]) - -# --------------------------------------------------------------------------- -# Hazard definition -# --------------------------------------------------------------------------- -HAZARD_TYPE = "TEST_HAZARD_TYPE" -HAZARD_UNIT = "TEST_HAZARD_UNIT" - -# Hazard centroid positions -HAZ_JITTER = 0.1 # To test centroid matching -HAZ_LONS = EXP_LONS + HAZ_JITTER -HAZ_LATS = EXP_LATS + HAZ_JITTER - -# Hazard events -EVENT_IDS = np.array([1, 2, 3, 4]) -EVENT_NAMES = ["ev1", "ev2", "ev3", "ev4"] -DATES = np.array([1, 2, 3, 4]) - -# Frequency are choosen so that they cumulate nicely -# to correspond to 100, 50, and 20y return periods (for impacts) -FREQUENCY = np.array([0.1, 0.03, 0.01, 0.01]) -FREQUENCY_UNIT = "1/year" - -# Hazard maximum intensity -# 100 to match 0 to 100% idea -# also in line with linear 1:1 impact function -# for easy mental calculus -HAZARD_MAX_INTENSITY = 100 - -# --------------------------------------------------------------------------- -# Impact function -# --------------------------------------------------------------------------- -IMPF_ID = 1 -IMPF_NAME = "IMPF_1" - -# --------------------------------------------------------------------------- -# Future years -# --------------------------------------------------------------------------- -EXPOSURE_FUTURE_YEAR = 2040 - - -def reusable_minimal_exposures( - values=VALUES, - regions=REGIONS, - group_id=None, - lon=EXP_LONS, - lat=EXP_LATS, - crs=CRS_WGS84, - desc=EXP_DESC, - ref_year=EXPOSURE_REF_YEAR, - value_unit=EXPOSURE_VALUE_UNIT, - assign_impf=IMPF_ID, - increase_value_factor=1, -) -> Exposures: - data = gpd.GeoDataFrame( - { - "value": values * increase_value_factor, - "region_id": regions, - f"impf_{HAZARD_TYPE}": assign_impf, - "geometry": [Point(lon, lat) for lon, lat in zip(lon, lat)], - }, - crs=crs, - ) - if group_id is not None: - data["group_id"] = group_id - return Exposures( - data=data, - description=desc, - ref_year=ref_year, - value_unit=value_unit, - ) - - -def reusable_intensity_mat(max_intensity=HAZARD_MAX_INTENSITY): - # Choosen such that: - # - 1st event has 0 intensity - # - 2nd event has max intensity in first exposure point (defaulting to 0 value) - # - 3rd event has 1/2* of max intensity in second centroid - # - 4th event has 1/4* of max intensity everywhere - # *: So that you can double intensity of the hazard and expect double impacts - return csr_matrix( - [ - [0, 0, 0, 0], - [max_intensity, 0, 0, 0], - [0, max_intensity / 2, 0, 0], - [ - max_intensity / 4, - max_intensity / 4, - max_intensity / 4, - max_intensity / 4, - ], - ] - ) - - -def reusable_minimal_hazard( - haz_type=HAZARD_TYPE, - units=HAZARD_UNIT, - lat=HAZ_LATS, - lon=HAZ_LONS, - crs=CRS_WGS84, - event_id=EVENT_IDS, - event_name=EVENT_NAMES, - date=DATES, - frequency=FREQUENCY, - frequency_unit=FREQUENCY_UNIT, - intensity=None, - intensity_factor=1, -) -> Hazard: - intensity = reusable_intensity_mat() if intensity is None else intensity - intensity *= intensity_factor - return Hazard( - haz_type=haz_type, - units=units, - centroids=Centroids(lat=lat, lon=lon, crs=crs), - event_id=event_id, - event_name=event_name, - date=date, - frequency=frequency, - frequency_unit=frequency_unit, - intensity=intensity, - ) - - -def reusable_minimal_impfset( - hazard=None, name=IMPF_NAME, impf_id=IMPF_ID, max_intensity=HAZARD_MAX_INTENSITY -): - hazard = reusable_minimal_hazard() if hazard is None else hazard - return ImpactFuncSet( - [ - ImpactFunc( - haz_type=hazard.haz_type, - intensity_unit=hazard.units, - name=name, - intensity=np.array([0, max_intensity / 2, max_intensity]), - mdd=np.array([0, 0.5, 1]), - paa=np.array([1, 1, 1]), - id=impf_id, - ) - ] - ) - - -def reusable_snapshot( - hazard_intensity_increase_factor=1, - exposure_value_increase_factor=1, - date=EXPOSURE_REF_YEAR, -): - exposures = reusable_minimal_exposures( - increase_value_factor=exposure_value_increase_factor - ) - hazard = reusable_minimal_hazard(intensity_factor=hazard_intensity_increase_factor) - impfset = reusable_minimal_impfset() - return Snapshot(exposure=exposures, hazard=hazard, impfset=impfset, date=date) diff --git a/climada/test/conftest.py b/climada/test/conftest.py new file mode 100644 index 0000000000..b5aff96041 --- /dev/null +++ b/climada/test/conftest.py @@ -0,0 +1,232 @@ +""" +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 . +--- + +A set of reusable fixtures for testing purpose. + +The objective of this file is to provide minimalistic, understandable and consistent +default objects for unit and integration testing. + +Values are chosen such that: + - Exposure value of the first points is 0. (First location should always have 0 impacts) + - Category / Group id of all points is 1, except for third point, valued at 2000 (Impacts on that category are always a share of 2000) + - Hazard centroids are the exposure centroids shifted by `HAZARD_JITTER` on both lon and lat. + - There are 4 events, with frequencies == 0.03, 0.01, 0.006, 0.004, 0, + such that impacts for RP250, 100 and 50 and 20 are at_event, + (freq sorted cumulate to 1/250, 1/100, 1/50 and 1/20). + - Hazard intensity is: + * Event 1: zero everywhere (always no impact) + * Event 2: max intensity at first centroid (also always no impact (first centroid is 0)) + * Event 3: half max intensity at second centroid (impact == half second centroid) + * Event 4: quarter max intensity everywhere (impact == 1/4 total value) + * Event 5: max intensity everywhere (but zero frequency) + With max intensity set at 100 + - Impact function is the "identity function", x intensity is x% damages + - Impact values should be round. + +""" + +import geopandas as gpd +import numpy as np +import pytest +from scipy.sparse import csr_matrix +from shapely.geometry import Point + +from climada.entity import Exposures, ImpactFunc, ImpactFuncSet +from climada.hazard import Centroids, Hazard + +# --------------------------------------------------------------------------- +# Coordinate system and metadata +# --------------------------------------------------------------------------- +CRS_WGS84 = "EPSG:4326" + +# --------------------------------------------------------------------------- +# Exposure attributes +# --------------------------------------------------------------------------- +EXP_DESC = "Test exposure dataset" +EXPOSURE_REF_YEAR = 2020 +EXPOSURE_VALUE_UNIT = "USD" +VALUES = np.array([0, 1000, 2000, 3000, 4000, 5000]) +CATEGORIES = np.array([1, 1, 2, 1, 1, 3]) + +# Exposure coordinates +EXP_LONS = np.array([4, 4.25, 4.5, 4, 4.25, 4.5]) +EXP_LATS = np.array([45, 45, 45, 45.25, 45.25, 45.25]) + +# --------------------------------------------------------------------------- +# Hazard definition +# --------------------------------------------------------------------------- +HAZARD_TYPE = "TEST_HAZARD_TYPE" +HAZARD_UNIT = "TEST_HAZARD_UNIT" + +# Hazard centroid positions +HAZ_JITTER = 0.1 # To test centroid matching +HAZ_LONS = EXP_LONS + HAZ_JITTER +HAZ_LATS = EXP_LATS + HAZ_JITTER + +# Hazard events +EVENT_IDS = np.array([1, 2, 3, 4, 5]) +EVENT_NAMES = ["ev1", "ev2", "ev3", "ev4", "ev5"] +DATES = np.array([1, 2, 3, 4, 5]) + +# Frequency are choosen so that they cumulate nicely +# to correspond to 250, 100, 50, and 20y return periods (for impacts) +FREQUENCY = np.array([0.03, 0.01, 0.006, 0.004, 0.0]) +FREQUENCY_UNIT = "1/year" + +# Hazard maximum intensity +# 100 to match 0 to 100% idea +# also in line with linear 1:1 impact function +# for easy mental calculus +HAZARD_MAX_INTENSITY = 100 + +# --------------------------------------------------------------------------- +# Impact function +# --------------------------------------------------------------------------- +IMPF_ID = 1 +IMPF_NAME = "IMPF_1" + +# Sanity checks +for const in [VALUES, CATEGORIES, EXP_LONS, EXP_LATS]: + assert len(const) == len( + VALUES + ), "VALUES, REGIONS, CATEGORIES, EXP_LONS, EXP_LATS should all have the same lengths." + +for const in [EVENT_IDS, EVENT_NAMES, DATES, FREQUENCY]: + assert len(const) == len( + EVENT_IDS + ), "EVENT_IDS, EVENT_NAMES, DATES, FREQUENCY should all have the same lengths." + + +@pytest.fixture(scope="session") +def exposure_values(): + return VALUES.copy() + + +@pytest.fixture(scope="session") +def categories(): + return CATEGORIES.copy() + + +@pytest.fixture(scope="session") +def exposure_geometry(): + return [Point(lon, lat) for lon, lat in zip(EXP_LONS, EXP_LATS)] + + +@pytest.fixture(scope="session") +def exposures( + exposure_values, + exposure_geometry, + categories, + hazard_type=HAZARD_TYPE, +): + """Minimal exposure set with geometry and impact-function assignment.""" + gdf = gpd.GeoDataFrame( + { + "value": exposure_values, + "group_id": categories, + f"impf_{hazard_type}": IMPF_ID, + "geometry": exposure_geometry, + }, + crs=CRS_WGS84, + ) + return Exposures( + data=gdf, + description=EXP_DESC, + ref_year=EXPOSURE_REF_YEAR, + value_unit=EXPOSURE_VALUE_UNIT, + ) + + +@pytest.fixture(scope="session") +def hazard_frequency(): + return FREQUENCY.copy() + + +@pytest.fixture(scope="session") +def hazard_intensity_matrix(): + """ + Intensity matrix designed for analytical expectations: + - Event 1: zero + - Event 2: max intensity at first centroid + - Event 3: half max intensity at second centroid + - Event 4: quarter max intensity everywhere + """ + return csr_matrix( + [ + [0, 0, 0, 0, 0, 0], + [HAZARD_MAX_INTENSITY, 0, 0, 0, 0, 0], + [0, HAZARD_MAX_INTENSITY / 2, 0, 0, 0, 0], + [ + HAZARD_MAX_INTENSITY / 4, + HAZARD_MAX_INTENSITY / 4, + HAZARD_MAX_INTENSITY / 4, + HAZARD_MAX_INTENSITY / 4, + HAZARD_MAX_INTENSITY / 4, + HAZARD_MAX_INTENSITY / 4, + ], + [ + HAZARD_MAX_INTENSITY, + HAZARD_MAX_INTENSITY, + HAZARD_MAX_INTENSITY, + HAZARD_MAX_INTENSITY, + HAZARD_MAX_INTENSITY, + HAZARD_MAX_INTENSITY, + ], + ] + ) + + +@pytest.fixture(scope="session") +def centroids(): + return Centroids(lat=HAZ_LATS, lon=HAZ_LONS, crs=CRS_WGS84) + + +@pytest.fixture(scope="session") +def hazard( + hazard_intensity_matrix, + hazard_frequency, + centroids, +): + return Hazard( + haz_type=HAZARD_TYPE, + units=HAZARD_UNIT, + centroids=centroids, + event_id=EVENT_IDS, + event_name=EVENT_NAMES, + date=DATES, + frequency=hazard_frequency, + frequency_unit=FREQUENCY_UNIT, + intensity=hazard_intensity_matrix, + ) + + +@pytest.fixture(scope="session") +def linear_impact_function(hazard): + return ImpactFunc( + haz_type=hazard.haz_type, + intensity_unit=hazard.units, + name=IMPF_NAME, + intensity=np.array([0, HAZARD_MAX_INTENSITY / 2, HAZARD_MAX_INTENSITY]), + mdd=np.array([0, 0.5, 1]), + paa=np.array([1, 1, 1]), + id=IMPF_ID, + ) + + +@pytest.fixture(scope="session") +def impfset(linear_impact_function): + return ImpactFuncSet([linear_impact_function]) From ca23d1952c78227ba79c1e6b1e496f4a5cb1b608 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Mon, 5 Jan 2026 14:23:23 +0100 Subject: [PATCH 35/61] updates tests and fixtures --- climada/test/conftest.py | 169 ++++++++++---- climada/test/test_trajectories.py | 357 +++++++++++++++++++++++------- 2 files changed, 394 insertions(+), 132 deletions(-) diff --git a/climada/test/conftest.py b/climada/test/conftest.py index b5aff96041..5d43854a92 100644 --- a/climada/test/conftest.py +++ b/climada/test/conftest.py @@ -127,37 +127,59 @@ def exposure_geometry(): @pytest.fixture(scope="session") -def exposures( +def exposures_factory( exposure_values, exposure_geometry, - categories, - hazard_type=HAZARD_TYPE, ): - """Minimal exposure set with geometry and impact-function assignment.""" - gdf = gpd.GeoDataFrame( - { - "value": exposure_values, - "group_id": categories, - f"impf_{hazard_type}": IMPF_ID, - "geometry": exposure_geometry, - }, - crs=CRS_WGS84, - ) - return Exposures( - data=gdf, - description=EXP_DESC, + def _make_exposures( + value_factor=1.0, ref_year=EXPOSURE_REF_YEAR, - value_unit=EXPOSURE_VALUE_UNIT, - ) + hazard_type=HAZARD_TYPE, + group_id=None, + ): + gdf = gpd.GeoDataFrame( + { + "value": exposure_values * value_factor, + f"impf_{hazard_type}": IMPF_ID, + "geometry": exposure_geometry, + }, + crs=CRS_WGS84, + ) + if group_id is not None: + gdf["group_id"] = group_id + + return Exposures( + data=gdf, + description=EXP_DESC, + ref_year=ref_year, + value_unit=EXPOSURE_VALUE_UNIT, + ) + + return _make_exposures + + +@pytest.fixture(scope="session") +def exposures(exposures_factory): + return exposures_factory() + + +@pytest.fixture(scope="session") +def hazard_frequency_factory(): + base = FREQUENCY + + def _make_frequency(scale=1.0): + return base * scale + + return _make_frequency @pytest.fixture(scope="session") def hazard_frequency(): - return FREQUENCY.copy() + return hazard_frequency_factory() @pytest.fixture(scope="session") -def hazard_intensity_matrix(): +def hazard_intensity_factory(): """ Intensity matrix designed for analytical expectations: - Event 1: zero @@ -165,7 +187,7 @@ def hazard_intensity_matrix(): - Event 3: half max intensity at second centroid - Event 4: quarter max intensity everywhere """ - return csr_matrix( + base = csr_matrix( [ [0, 0, 0, 0, 0, 0], [HAZARD_MAX_INTENSITY, 0, 0, 0, 0, 0], @@ -189,6 +211,16 @@ def hazard_intensity_matrix(): ] ) + def _make_intensity(scale=1.0): + return base * scale + + return _make_intensity + + +@pytest.fixture(scope="session") +def hazard_intensity_matrix(hazard_intensity_factory): + return hazard_intensity_factory() + @pytest.fixture(scope="session") def centroids(): @@ -196,37 +228,80 @@ def centroids(): @pytest.fixture(scope="session") -def hazard( - hazard_intensity_matrix, - hazard_frequency, +def hazard_factory( + hazard_intensity_factory, + hazard_frequency_factory, centroids, ): - return Hazard( - haz_type=HAZARD_TYPE, - units=HAZARD_UNIT, - centroids=centroids, - event_id=EVENT_IDS, - event_name=EVENT_NAMES, - date=DATES, - frequency=hazard_frequency, - frequency_unit=FREQUENCY_UNIT, - intensity=hazard_intensity_matrix, - ) + def _make_hazard( + intensity_scale=1.0, + frequency_scale=1.0, + hazard_type=HAZARD_TYPE, + hazard_unit=HAZARD_UNIT, + ): + return Hazard( + haz_type=hazard_type, + units=hazard_unit, + centroids=centroids, + event_id=EVENT_IDS, + event_name=EVENT_NAMES, + date=DATES, + frequency=hazard_frequency_factory(scale=frequency_scale), + frequency_unit=FREQUENCY_UNIT, + intensity=hazard_intensity_factory(scale=intensity_scale), + ) + + return _make_hazard @pytest.fixture(scope="session") -def linear_impact_function(hazard): - return ImpactFunc( - haz_type=hazard.haz_type, - intensity_unit=hazard.units, - name=IMPF_NAME, - intensity=np.array([0, HAZARD_MAX_INTENSITY / 2, HAZARD_MAX_INTENSITY]), - mdd=np.array([0, 0.5, 1]), - paa=np.array([1, 1, 1]), - id=IMPF_ID, - ) +def hazard(hazard_factory): + return hazard_factory() + + +@pytest.fixture(scope="session") +def impf_factory(): + def _make_impf( + paa_scale=1.0, + max_intensity=HAZARD_MAX_INTENSITY, + hazard_type=HAZARD_TYPE, + hazard_unit=HAZARD_UNIT, + impf_id=IMPF_ID, + ): + return ImpactFunc( + haz_type=hazard_type, + intensity_unit=hazard_unit, + name=IMPF_NAME, + intensity=np.array([0, max_intensity / 2, max_intensity]), + mdd=np.array([0, 0.5, 1]), + paa=np.array([1, 1, 1]) * paa_scale, + id=impf_id, + ) + + return _make_impf + + +@pytest.fixture(scope="session") +def linear_impact_function(impf_factory): + return impf_factory() + + +@pytest.fixture(scope="session") +def impfset_factory(impf_factory): + def _make_impfset( + paa_scale=1.0, + max_intensity=HAZARD_MAX_INTENSITY, + hazard_type=HAZARD_TYPE, + hazard_unit=HAZARD_UNIT, + impf_id=IMPF_ID, + ): + return ImpactFuncSet( + [impf_factory(paa_scale, max_intensity, hazard_type, hazard_unit, impf_id)] + ) + + return _make_impfset @pytest.fixture(scope="session") -def impfset(linear_impact_function): - return ImpactFuncSet([linear_impact_function]) +def impfset(impfset_factory): + return impfset_factory() diff --git a/climada/test/test_trajectories.py b/climada/test/test_trajectories.py index 933e277225..6cbb5c6e29 100644 --- a/climada/test/test_trajectories.py +++ b/climada/test/test_trajectories.py @@ -26,15 +26,27 @@ import geopandas as gpd import numpy as np import pandas as pd +import pytest from climada.engine.impact_calc import ImpactCalc from climada.entity.disc_rates.base import DiscRates -from climada.test.common_test_fixtures import ( +from climada.entity.exposures.base import Exposures +from climada.entity.impact_funcs.base import ImpactFunc +from climada.entity.impact_funcs.impact_func_set import ImpactFuncSet +from climada.hazard.base import Hazard +from climada.test.conftest import ( CATEGORIES, - reusable_minimal_exposures, - reusable_minimal_hazard, - reusable_minimal_impfset, - reusable_snapshot, + DATES, + EVENT_IDS, + EVENT_NAMES, + EXPOSURE_REF_YEAR, + FREQUENCY, + FREQUENCY_UNIT, + HAZARD_MAX_INTENSITY, + HAZARD_TYPE, + HAZARD_UNIT, + IMPF_ID, + IMPF_NAME, ) from climada.trajectories import InterpolatedRiskTrajectory, StaticRiskTrajectory from climada.trajectories.constants import ( @@ -61,99 +73,274 @@ from climada.trajectories.snapshot import Snapshot from climada.trajectories.trajectory import DEFAULT_RP +EXPOSURE_FUTURE_YEAR = 2040 -class TestStaticTrajectory(TestCase): - PRESENT_DATE = 2020 - HAZ_INCREASE_INTENSITY_FACTOR = 2 - EXP_INCREASE_VALUE_FACTOR = 10 - FUTURE_DATE = 2040 +from climada.trajectories.snapshot import Snapshot - def setUp(self) -> None: - self.base_snapshot = reusable_snapshot(date=self.PRESENT_DATE) - self.future_snapshot = reusable_snapshot( - hazard_intensity_increase_factor=self.HAZ_INCREASE_INTENSITY_FACTOR, - exposure_value_increase_factor=self.EXP_INCREASE_VALUE_FACTOR, - date=self.FUTURE_DATE, + +@pytest.fixture(scope="session") +def snapshot_factory( + exposures_factory, + hazard_factory, + impfset_factory, +): + """ + Factory for Snapshot objects. + + Allows controlled construction of baseline / future / counterfactual + scenarios by scaling exposure values, hazard intensity, and impact function. + """ + + def _make_snapshot( + *, + date=EXPOSURE_REF_YEAR, + exposure_value_factor=1.0, + hazard_intensity_factor=1.0, + hazard_frequency_factor=1.0, + paa_scale=1.0, + group_id=None, + ): + exposures = exposures_factory( + value_factor=exposure_value_factor, ref_year=date, group_id=group_id ) - self.expected_base_imp = ImpactCalc( - **self.base_snapshot.impact_calc_data - ).impact() - self.expected_future_imp = ImpactCalc( - **self.future_snapshot.impact_calc_data - ).impact() - # self.group_vector = self.base_snapshot.exposure.gdf[GROUP_ID_COL_NAME] - self.expected_base_return_period_impacts = { - rp: imp - for rp, imp in zip( - self.expected_base_imp.calc_freq_curve(DEFAULT_RP).return_per, - self.expected_base_imp.calc_freq_curve(DEFAULT_RP).impact, - ) - } - self.expected_future_return_period_impacts = { - rp: imp - for rp, imp in zip( - self.expected_future_imp.calc_freq_curve(DEFAULT_RP).return_per, - self.expected_future_imp.calc_freq_curve(DEFAULT_RP).impact, - ) - } + hazard = hazard_factory( + intensity_scale=hazard_intensity_factor, + frequency_scale=hazard_frequency_factor, + ) - # fmt: off - self.expected_static_metrics = pd.DataFrame.from_dict( - {'index': [0, 1, 2, 3, 4, 5, 6, 7], - 'columns': [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME, UNIT_COL_NAME, RISK_COL_NAME], - 'data': [ - [pd.Timestamp(str(self.PRESENT_DATE)), 'All', NO_MEASURE_VALUE, 'aai', 'USD', self.expected_base_imp.aai_agg], - [pd.Timestamp(str(self.FUTURE_DATE)), 'All', NO_MEASURE_VALUE, 'aai', 'USD', self.expected_future_imp.aai_agg], - [pd.Timestamp(str(self.PRESENT_DATE)), 'All', NO_MEASURE_VALUE, f'rp_{DEFAULT_RP[0]}', 'USD', self.expected_base_return_period_impacts[DEFAULT_RP[0]]], - [pd.Timestamp(str(self.FUTURE_DATE)), 'All', NO_MEASURE_VALUE, f'rp_{DEFAULT_RP[0]}', 'USD', self.expected_future_return_period_impacts[DEFAULT_RP[0]]], - [pd.Timestamp(str(self.PRESENT_DATE)), 'All', NO_MEASURE_VALUE, f'rp_{DEFAULT_RP[1]}', 'USD', self.expected_base_return_period_impacts[DEFAULT_RP[1]]], - [pd.Timestamp(str(self.FUTURE_DATE)), 'All', NO_MEASURE_VALUE, f'rp_{DEFAULT_RP[1]}', 'USD', self.expected_future_return_period_impacts[DEFAULT_RP[1]]], - [pd.Timestamp(str(self.PRESENT_DATE)), 'All', NO_MEASURE_VALUE, f'rp_{DEFAULT_RP[2]}', 'USD', self.expected_base_return_period_impacts[DEFAULT_RP[2]]], - [pd.Timestamp(str(self.FUTURE_DATE)), 'All', NO_MEASURE_VALUE, f'rp_{DEFAULT_RP[2]}', 'USD', self.expected_future_return_period_impacts[DEFAULT_RP[2]]], - ], - 'index_names': [None], - 'column_names': [None]}, - orient="tight" + impfset = impfset_factory( + paa_scale=paa_scale, ) - # fmt: on - def test_static_trajectory(self): - static_traj = StaticRiskTrajectory([self.base_snapshot, self.future_snapshot]) - print(static_traj.per_date_risk_metrics()) - pd.testing.assert_frame_equal( - static_traj.per_date_risk_metrics(), - self.expected_static_metrics, - check_dtype=False, - check_categorical=False, + return Snapshot( + exposure=exposures, + hazard=hazard, + impfset=impfset, + date=date, ) - def test_static_trajectory_one_snap(self): - static_traj = StaticRiskTrajectory([self.base_snapshot]) - expected = pd.DataFrame.from_dict( - # fmt: off - { - "index": [0, 1, 2, 3], - "columns": [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME, UNIT_COL_NAME, RISK_COL_NAME,], - "data": [ - [pd.Timestamp(str(self.PRESENT_DATE)), "All", NO_MEASURE_VALUE, AAI_METRIC_NAME, "USD", self.expected_base_imp.aai_agg,], - [pd.Timestamp(str(self.PRESENT_DATE)), "All", NO_MEASURE_VALUE, f"rp_{DEFAULT_RP[0]}", "USD", self.expected_base_return_period_impacts[DEFAULT_RP[0]],], - [pd.Timestamp(str(self.PRESENT_DATE)), "All", NO_MEASURE_VALUE, f"rp_{DEFAULT_RP[1]}", "USD", self.expected_base_return_period_impacts[DEFAULT_RP[1]],], - [pd.Timestamp(str(self.PRESENT_DATE)), "All", NO_MEASURE_VALUE, f"rp_{DEFAULT_RP[2]}", "USD", self.expected_base_return_period_impacts[DEFAULT_RP[2]],], + return _make_snapshot + + +@pytest.fixture(scope="session") +def snapshot_base(snapshot_factory): + return snapshot_factory() + + +@pytest.fixture(scope="session") +def snapshot_future(snapshot_factory): + return snapshot_factory( + date=2040, + exposure_value_factor=2.0, + hazard_intensity_factor=2.0, + ) + + +def expected_static_metrics_from_snapshots(snapshots): + rows = [] + group_p = False + for snap in snapshots: + imp = ImpactCalc(**snap.impact_calc_data).impact() + curve = imp.calc_freq_curve(DEFAULT_RP) + + rows.append( + [ + pd.Timestamp(str(snap.date)), + "All", + NO_MEASURE_VALUE, + "aai", + "USD", + imp.aai_agg, + ] + ) + + rows.extend( + [ + [ + pd.Timestamp(str(snap.date)), + "All", + NO_MEASURE_VALUE, + f"rp_{rp}", + "USD", + val, + ] + for rp, val in zip(curve.return_per, curve.impact) + ] + ) + if "group_id" in snap.exposure.gdf.columns: + group_p = True + aai_per_group = [ + [ + pd.Timestamp(str(snap.date)), + group, + NO_MEASURE_VALUE, + "aai", + "USD", + val, + ] + for group, val in zip(snap.exposure.gdf["group_id"], imp.eai_exp) + ] + group_df = pd.DataFrame( + aai_per_group, + columns=[ + DATE_COL_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + UNIT_COL_NAME, + RISK_COL_NAME, ], - "index_names": [None], - "column_names": [None], - }, - # fmt: on - orient="tight", + ) + + res = pd.DataFrame( + rows, + columns=[ + DATE_COL_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + UNIT_COL_NAME, + RISK_COL_NAME, + ], + ) + if group_p: + res = pd.concat([res, group_df]) + + return res.set_index( + [ + DATE_COL_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + UNIT_COL_NAME, + ] + ).sort_index() + + +def test_static_trajectory(snapshot_factory): + present_date = 2020 + future_date = 2040 + + hazard_intensity_factor = 2.0 + exposure_value_factor = 10.0 + + snapshot_base = snapshot_factory( + date=present_date, + ) + + snapshot_fut = snapshot_factory( + date=future_date, + hazard_intensity_factor=hazard_intensity_factor, + exposure_value_factor=exposure_value_factor, + ) + + expected_static_metrics = expected_static_metrics_from_snapshots( + [snapshot_base, snapshot_fut] + ) + static_traj = StaticRiskTrajectory([snapshot_base, snapshot_fut]) + result = ( + static_traj.per_date_risk_metrics() + .set_index( + [ + DATE_COL_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + UNIT_COL_NAME, + ] ) + .sort_index() + ) - pd.testing.assert_frame_equal( - static_traj.per_date_risk_metrics(), - expected, - check_dtype=False, - check_categorical=False, + # --- Assertion ---------------------------------------------------------- + pd.testing.assert_frame_equal( + result, + expected_static_metrics, + check_index_type=False, + check_categorical=False, + check_like=False, + ) + + +def test_static_trajectory_one_snap(snapshot_factory): + present_date = 2020 + + snapshot_base = snapshot_factory( + date=present_date, + ) + + expected_static_metrics = expected_static_metrics_from_snapshots([snapshot_base]) + static_traj = StaticRiskTrajectory([snapshot_base]) + result = ( + static_traj.per_date_risk_metrics() + .set_index( + [ + DATE_COL_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + UNIT_COL_NAME, + ] ) + .sort_index() + ) + + # --- Assertion ---------------------------------------------------------- + pd.testing.assert_frame_equal( + result, + expected_static_metrics, + check_index_type=False, + check_categorical=False, + check_like=False, + ) + + +def test_static_trajectory_with_group(snapshot_factory): + present_date = 2020 + future_date = 2040 + + hazard_intensity_factor = 2.0 + exposure_value_factor = 10.0 + + snapshot_base = snapshot_factory(date=present_date, group_id=CATEGORIES) + + snapshot_fut = snapshot_factory( + date=future_date, + hazard_intensity_factor=hazard_intensity_factor, + exposure_value_factor=exposure_value_factor, + group_id=CATEGORIES, + ) + + expected_static_metrics = expected_static_metrics_from_snapshots( + [snapshot_base, snapshot_fut] + ) + static_traj = StaticRiskTrajectory([snapshot_base, snapshot_fut]) + result = ( + static_traj.per_date_risk_metrics() + .set_index( + [ + DATE_COL_NAME, + GROUP_COL_NAME, + MEASURE_COL_NAME, + METRIC_COL_NAME, + UNIT_COL_NAME, + ] + ) + .sort_index() + ) + + # --- Assertion ---------------------------------------------------------- + pd.testing.assert_frame_equal( + result, + expected_static_metrics, + check_index_type=False, + check_categorical=False, + check_like=False, + ) + + +class TestStaticTrajectory: def test_static_trajectory_with_group(self): exp0 = reusable_minimal_exposures(group_id=CATEGORIES) From b4f05e1f5986248551d29f121098b664157988ad Mon Sep 17 00:00:00 2001 From: spjuhel Date: Mon, 5 Jan 2026 14:24:46 +0100 Subject: [PATCH 36/61] Pylint fix --- climada/trajectories/snapshot.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/climada/trajectories/snapshot.py b/climada/trajectories/snapshot.py index cc4a26f871..ae844305fb 100644 --- a/climada/trajectories/snapshot.py +++ b/climada/trajectories/snapshot.py @@ -27,8 +27,6 @@ import datetime import logging -import pandas as pd - from climada.entity.exposures import Exposures from climada.entity.impact_funcs import ImpactFuncSet from climada.entity.measures.base import Measure From 4a8c770fe0f1ad0d7832566d5dd4f911556551da Mon Sep 17 00:00:00 2001 From: spjuhel Date: Mon, 5 Jan 2026 15:07:58 +0100 Subject: [PATCH 37/61] Fixes pylint --- climada/trajectories/snapshot.py | 71 +++++++++++++++++++++++++++----- 1 file changed, 61 insertions(+), 10 deletions(-) diff --git a/climada/trajectories/snapshot.py b/climada/trajectories/snapshot.py index ae844305fb..24a90ca0e1 100644 --- a/climada/trajectories/snapshot.py +++ b/climada/trajectories/snapshot.py @@ -80,15 +80,65 @@ def __init__( exposure: Exposures, hazard: Hazard, impfset: ImpactFuncSet, + measure: Measure | None, date: int | datetime.date | str, ref_only: bool = False, ) -> None: self._exposure = exposure if ref_only else copy.deepcopy(exposure) self._hazard = hazard if ref_only else copy.deepcopy(hazard) self._impfset = impfset if ref_only else copy.deepcopy(impfset) - self._measure = None + self._measure = measure if ref_only else copy.deepcopy(impfset) self._date = self._convert_to_date(date) + @classmethod + def from_triplet( + cls, + *, + exposure: Exposures, + hazard: Hazard, + impfset: ImpactFuncSet, + date: int | datetime.date | str, + ref_only: bool = False, + ) -> "Snapshot": + """Create a Snapshot from exposure, hazard and impact functions set + + This method is the main point of entry for the creation of Snapshot. It + creates a new Snapshot object for the given date with copies of the + hazard, exposure and impact function set given in argument (or + references if ref_only is True) + + Parameters + ---------- + exposure : Exposures + hazard : Hazard + impfset : ImpactFuncSet + date : int | datetime.date | str + ref_only : bool + If true, uses references to the exposure, hazard and impact + function objects. Note that modifying the original objects after + computations using the Snapshot might lead to inconsistencies in + results. + + Returns + ------- + Snapshot + + Notes + ----- + + To create a Snapshot with a measure, first create the Snapshot without + the measure using this method, and use `apply_measure(measure)` afterward. + + """ + return cls( + exposure=exposure, + hazard=hazard, + impfset=impfset, + measure=None, + date=date, + ref_only=ref_only, + ) + @property def exposure(self) -> Exposures: """Exposure data for the snapshot.""" @@ -129,17 +179,17 @@ def _convert_to_date(date_arg) -> datetime.date: if isinstance(date_arg, int): # Assume the integer represents a year return datetime.date(date_arg, 1, 1) - elif isinstance(date_arg, str): + if isinstance(date_arg, str): # Try to parse the string as a date try: return datetime.datetime.strptime(date_arg, "%Y-%m-%d").date() - except ValueError: - raise ValueError("String must be in the format 'YYYY-MM-DD'") - elif isinstance(date_arg, datetime.date): + except ValueError as exc: + raise ValueError("String must be in the format 'YYYY-MM-DD'") from exc + if isinstance(date_arg, datetime.date): # Already a date object return date_arg - else: - raise TypeError("date_arg must be an int, str, or datetime.date") + + raise TypeError("date_arg must be an int, str, or datetime.date") def apply_measure(self, measure: Measure) -> "Snapshot": """Create a new snapshot by applying a Measure object. @@ -158,8 +208,9 @@ def apply_measure(self, measure: Measure) -> "Snapshot": """ - LOGGER.debug(f"Applying measure {measure.name} on snapshot {id(self)}") + LOGGER.debug("Applying measure %s on snapshot %s", measure.name, id(self)) exp, impfset, haz = measure.apply(self.exposure, self.impfset, self.hazard) - snap = Snapshot(exposure=exp, hazard=haz, impfset=impfset, date=self.date) - snap._measure = measure + snap = Snapshot( + exposure=exp, hazard=haz, impfset=impfset, date=self.date, measure=measure + ) return snap From 87332be211ccf32dc660831610c64276d98b05c3 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Mon, 5 Jan 2026 15:22:09 +0100 Subject: [PATCH 38/61] Complies with pylint --- climada/trajectories/impact_calc_strat.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/climada/trajectories/impact_calc_strat.py b/climada/trajectories/impact_calc_strat.py index a58aceeab2..75cf08f545 100644 --- a/climada/trajectories/impact_calc_strat.py +++ b/climada/trajectories/impact_calc_strat.py @@ -32,6 +32,10 @@ __all__ = ["ImpactCalcComputation"] +# The following is acceptable. +# We design a pattern, and currently it requires only to +# define the compute_impacts method. +# pylint: disable=too-few-public-methods class ImpactComputationStrategy(ABC): """ Interface for impact computation strategies. @@ -73,7 +77,6 @@ def compute_impacts( -------- ImpactCalcComputation : The default implementation of this interface. """ - ... class ImpactCalcComputation(ImpactComputationStrategy): From 463568cb6076ebc59124baa5f80a949f66bca03b Mon Sep 17 00:00:00 2001 From: spjuhel Date: Mon, 5 Jan 2026 15:25:15 +0100 Subject: [PATCH 39/61] complies with pylint --- climada/trajectories/interpolation.py | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/climada/trajectories/interpolation.py b/climada/trajectories/interpolation.py index 9f6687e449..c07c53883c 100644 --- a/climada/trajectories/interpolation.py +++ b/climada/trajectories/interpolation.py @@ -430,10 +430,6 @@ class ExponentialExposureStrategy(InterpolationStrategyBase): def __init__(self) -> None: super().__init__() - self.exposure_interp = ( - lambda mat_start, mat_end, points: exponential_interp_imp_mat( - mat_start, mat_end, points - ) - ) + self.exposure_interp = exponential_interp_imp_mat self.hazard_interp = linear_interp_arrays self.vulnerability_interp = linear_interp_arrays From e01c330e42bb336f2b28a590e875c06e002e7b41 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Mon, 5 Jan 2026 16:02:53 +0100 Subject: [PATCH 40/61] Pylint compliance --- climada/trajectories/calc_risk_metrics.py | 68 +++++++++++++++++------ climada/trajectories/constants.py | 2 +- climada/trajectories/static_trajectory.py | 24 ++++---- climada/trajectories/trajectory.py | 59 +++++++++++--------- 4 files changed, 98 insertions(+), 55 deletions(-) diff --git a/climada/trajectories/calc_risk_metrics.py b/climada/trajectories/calc_risk_metrics.py index e7ba88c143..674b3eb599 100644 --- a/climada/trajectories/calc_risk_metrics.py +++ b/climada/trajectories/calc_risk_metrics.py @@ -60,11 +60,31 @@ def lazy_property(method): - # This function is used as a decorator for properties - # that require "heavy" computation and are not always needed. - # When requested, if a property is none, it uses the corresponding - # computation method and caches the result in the corresponding - # private attribute + """ + Decorator that converts a method into a cached, lazy-evaluated property. + + This decorator is intended for properties that require heavy computation. + The result is calculated only when first accessed and then stored in a + corresponding private attribute (e.g., a method named `impact` will + cache its result in `_impact`). + + Parameters + ---------- + method : callable + The method to be converted into a lazy property. + + Returns + ------- + property + A property object that handles the caching logic and attribute access. + + Notes + ----- + The caching behavior can be globally toggled via the + `_CACHE_SETTINGS["ENABLE_LAZY_CACHE"]` flag. If disabled, the + method will be re-evaluated on every access. + + """ attr_name = f"_{method.__name__}" @property @@ -137,13 +157,16 @@ def __init__( ] ) ) - except ValueError as e: - error_message = str(e).lower() + except ValueError as exc: + error_message = str(exc).lower() if "need at least one array to concatenate" in error_message: self._group_id = np.array([]) def _reset_impact_data(self): - """Util method that resets computed data, for instance when changing the computation strategy.""" + """Util method that resets computed data, for instance when + changing the computation strategy. + + """ self._impacts = None self._eai_gdf = None self._per_date_eai = None @@ -151,7 +174,10 @@ def _reset_impact_data(self): @property def impact_computation_strategy(self) -> ImpactComputationStrategy: - """The method used to calculate the impact from the (Haz,Exp,Vul) of the snapshots.""" + """The method used to calculate the impact from the (Haz,Exp,Vul) + of the snapshots. + + """ return self._impact_computation_strategy @impact_computation_strategy.setter @@ -186,18 +212,22 @@ def per_date_aai(self) -> np.ndarray: return np.array([imp.aai_agg for imp in self.impacts]) def calc_eai_gdf(self) -> pd.DataFrame: - """Convenience function returning a DataFrame (with both datetime and coordinates) from `per_date_eai`. + """Convenience function returning a DataFrame + from `per_date_eai`. - This can easily be merged with the GeoDataFrame of the exposure object of one of the `Snapshot`. + This can easily be merged with the GeoDataFrame of + the exposure object of one of the `Snapshot`. Notes ----- - The DataFrame from the first snapshot of the list is used as a basis (notably for `value` and `group_id`). + The DataFrame from the first snapshot of the list is used + as a basis (notably for `value` and `group_id`). + """ - df = pd.DataFrame(self.per_date_eai, index=self._date_idx) - df = df.reset_index().melt( + metric_df = pd.DataFrame(self.per_date_eai, index=self._date_idx) + metric_df = metric_df.reset_index().melt( id_vars=DATE_COL_NAME, var_name=COORD_ID_COL_NAME, value_name=RISK_COL_NAME ) eai_gdf = pd.concat( @@ -214,7 +244,7 @@ def calc_eai_gdf(self) -> pd.DataFrame: eai_gdf[[GROUP_ID_COL_NAME]] = pd.NA eai_gdf = eai_gdf[[DATE_COL_NAME, COORD_ID_COL_NAME, GROUP_ID_COL_NAME]] - eai_gdf = eai_gdf.merge(df, on=[DATE_COL_NAME, COORD_ID_COL_NAME]) + eai_gdf = eai_gdf.merge(metric_df, on=[DATE_COL_NAME, COORD_ID_COL_NAME]) eai_gdf = eai_gdf.rename(columns={GROUP_ID_COL_NAME: GROUP_COL_NAME}) eai_gdf[GROUP_COL_NAME] = pd.Categorical( eai_gdf[GROUP_COL_NAME], categories=self._group_id @@ -244,7 +274,10 @@ def calc_aai_metric(self) -> pd.DataFrame: return aai_df def calc_aai_per_group_metric(self) -> pd.DataFrame | None: - """Compute a DataFrame of the AAI distinguised per group id in the exposures, for each snapshot.""" + """Compute a DataFrame of the AAI distinguised per group id + in the exposures, for each snapshot. + + """ if len(self._group_id) < 1: LOGGER.warning( @@ -266,7 +299,8 @@ def calc_aai_per_group_metric(self) -> pd.DataFrame | None: return aai_per_group_df def calc_return_periods_metric(self, return_periods: list[int]) -> pd.DataFrame: - """Compute a DataFrame of the estimated impacts for a list of return periods, for each snapshot. + """Compute a DataFrame of the estimated impacts for a list + of return periods, for each snapshot. Parameters ---------- diff --git a/climada/trajectories/constants.py b/climada/trajectories/constants.py index c315f17761..969e585531 100644 --- a/climada/trajectories/constants.py +++ b/climada/trajectories/constants.py @@ -33,7 +33,7 @@ DEFAULT_PERIOD_INDEX_NAME = "date" -DEFAULT_RP = [20, 50, 100] +DEFAULT_RP = (20, 50, 100) """Default return periods to use when computing return period impact estimates.""" DEFAULT_ALLGROUP_NAME = "All" diff --git a/climada/trajectories/static_trajectory.py b/climada/trajectories/static_trajectory.py index 281887f347..42a9e8b84a 100644 --- a/climada/trajectories/static_trajectory.py +++ b/climada/trajectories/static_trajectory.py @@ -22,6 +22,7 @@ """ import logging +from typing import Iterable import pandas as pd @@ -37,8 +38,6 @@ MEASURE_COL_NAME, METRIC_COL_NAME, RETURN_PERIOD_METRIC_NAME, - RISK_COL_NAME, - RP_VALUE_PREFIX, ) from climada.trajectories.impact_calc_strat import ( ImpactCalcComputation, @@ -79,10 +78,14 @@ class StaticRiskTrajectory(RiskTrajectory): Currently: - - eai, expected impact (per exposure point within a period of 1/frequency unit of the hazard object) + - eai, expected impact (per exposure point within a period of 1/frequency + unit of the hazard object) - aai, average annual impact (aggregated eai over the whole exposure) - - aai_per_group, average annual impact per exposure subgroup (defined from the exposure geodataframe) - - return_periods, estimated impacts aggregated over the whole exposure for different return periods + - aai_per_group, average annual impact per exposure subgroup (defined from + the exposure geodataframe) + - return_periods, estimated impacts aggregated over the whole exposure for + different return periods + """ _DEFAULT_ALL_METRICS = [ @@ -93,9 +96,9 @@ class StaticRiskTrajectory(RiskTrajectory): def __init__( self, - snapshots_list: list[Snapshot], + snapshots_list: Iterable[Snapshot], *, - return_periods: list[int] = DEFAULT_RP, + return_periods: Iterable[int] = DEFAULT_RP, all_groups_name: str = DEFAULT_ALLGROUP_NAME, risk_disc_rates: DiscRates | None = None, impact_computation_strategy: ImpactComputationStrategy | None = None, @@ -146,6 +149,7 @@ def impact_computation_strategy(self, value, /): def _generic_metrics( self, + /, metric_name: str | None = None, metric_meth: str | None = None, **kwargs, @@ -195,7 +199,7 @@ def _generic_metrics( attr_name = f"_{metric_name}_metrics" if getattr(self, attr_name) is not None: - LOGGER.debug(f"Returning cached {attr_name}") + LOGGER.debug("Returning cached %s", attr_name) return getattr(self, attr_name) with log_level(level="WARNING", name_prefix="climada"): @@ -240,10 +244,10 @@ def eai_metrics(self, **kwargs) -> pd.DataFrame: This computation may become quite expensive for big areas with high resolution. """ - df = self._compute_metrics( + metric_df = self._compute_metrics( metric_name=EAI_METRIC_NAME, metric_meth="calc_eai_gdf", **kwargs ) - return df + return metric_df def aai_metrics(self, **kwargs) -> pd.DataFrame: """Return the average annual impacts for each date. diff --git a/climada/trajectories/trajectory.py b/climada/trajectories/trajectory.py index 5675521710..06088b3eca 100644 --- a/climada/trajectories/trajectory.py +++ b/climada/trajectories/trajectory.py @@ -23,7 +23,7 @@ import datetime import logging -from abc import ABC +from abc import ABC, abstractmethod import pandas as pd @@ -57,6 +57,13 @@ class RiskTrajectory(ABC): + """Base abstract class for risk trajectory objects. + + See concrete implementation :class:`StaticRiskTrajectory` and + :class:`InterpolatedRiskTrajectory` for more details. + + """ + _grouper = [MEASURE_COL_NAME, METRIC_COL_NAME] """Results dataframe grouper used in most `groupby()` calls.""" @@ -71,19 +78,12 @@ def __init__( all_groups_name: str = DEFAULT_ALLGROUP_NAME, risk_disc_rates: DiscRates | None = None, ): - """Base abstract class for risk trajectory objects. - - See concrete implementation :class:`StaticRiskTrajectory` and - :class:`InterpolatedRiskTrajectory` for more details. - - """ - self._reset_metrics() self._snapshots = sorted(snapshots_list, key=lambda snap: snap.date) self._all_groups_name = all_groups_name self._return_periods = return_periods - self.start_date = min([snapshot.date for snapshot in snapshots_list]) - self.end_date = max([snapshot.date for snapshot in snapshots_list]) + self.start_date = min((snapshot.date for snapshot in snapshots_list)) + self.end_date = max((snapshot.date for snapshot in snapshots_list)) self._risk_disc_rates = risk_disc_rates def _reset_metrics(self) -> None: @@ -100,6 +100,7 @@ def _reset_metrics(self) -> None: for metric in self.POSSIBLE_METRICS: setattr(self, "_" + metric + "_metrics", None) + @abstractmethod def _generic_metrics( self, /, metric_name: str, metric_meth: str, **kwargs ) -> pd.DataFrame: @@ -115,7 +116,9 @@ def _generic_metrics( - :method:`_compute_metrics` """ - ... + raise NotImplementedError( + f"'_generic_metrics' must be implemented by subclasses of {self.__class__.__name__}" + ) def _compute_metrics( self, /, metric_name: str, metric_meth: str, **kwargs @@ -175,13 +178,13 @@ def risk_disc_rates(self, value, /): @classmethod def npv_transform( - cls, df: pd.DataFrame, risk_disc_rates: DiscRates + cls, metric_df: pd.DataFrame, risk_disc_rates: DiscRates ) -> pd.DataFrame: """Apply provided discount rate to the provided metric `DataFrame`. Parameters ---------- - df : pd.DataFrame + metric_df : pd.DataFrame The `DataFrame` of the metric to discount. risk_disc_rates : DiscRate The discount rate to apply. @@ -197,20 +200,20 @@ def _npv_group(group, disc): start_date = group.index.get_level_values(DATE_COL_NAME).min() return cls._calc_npv_cash_flows(group, start_date, disc) - df = df.set_index(DATE_COL_NAME) + metric_df = metric_df.set_index(DATE_COL_NAME) grouper = cls._grouper - if GROUP_COL_NAME in df.columns: + if GROUP_COL_NAME in metric_df.columns: grouper = [GROUP_COL_NAME] + grouper - df[RISK_COL_NAME] = df.groupby( + metric_df[RISK_COL_NAME] = metric_df.groupby( grouper, dropna=False, as_index=False, group_keys=False, observed=True, )[RISK_COL_NAME].transform(_npv_group, risk_disc_rates) - df = df.reset_index() - return df + metric_df = metric_df.reset_index() + return metric_df @staticmethod def _calc_npv_cash_flows( @@ -248,21 +251,23 @@ def _calc_npv_cash_flows( "cash_flows must be a pandas Series with a PeriodIndex or DatetimeIndex" ) - df = cash_flows.to_frame(name="cash_flow") # type: ignore - df["year"] = df.index.year + metric_df = cash_flows.to_frame(name="cash_flow") # type: ignore + metric_df["year"] = metric_df.index.year # Merge with the discount rates based on the year - tmp = df.merge( + tmp = metric_df.merge( pd.DataFrame({"year": disc_rates.years, "rate": disc_rates.rates}), on="year", how="left", ) - tmp.index = df.index - df = tmp.copy() - df["discount_factor"] = (1 / (1 + df["rate"])) ** ( - df.index.year - start_date.year + tmp.index = metric_df.index + metric_df = tmp.copy() + metric_df["discount_factor"] = (1 / (1 + metric_df["rate"])) ** ( + metric_df.index.year - start_date.year ) # Apply the discount factors to the cash flows - df["npv_cash_flow"] = df["cash_flow"] * df["discount_factor"] - return df["npv_cash_flow"] + metric_df["npv_cash_flow"] = ( + metric_df["cash_flow"] * metric_df["discount_factor"] + ) + return metric_df["npv_cash_flow"] From 1ec88bf5b4779687402a41fc6af00db24d60e852 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Mon, 5 Jan 2026 16:04:03 +0100 Subject: [PATCH 41/61] Fixes type hints --- climada/trajectories/trajectory.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/climada/trajectories/trajectory.py b/climada/trajectories/trajectory.py index 06088b3eca..75c30b9aa1 100644 --- a/climada/trajectories/trajectory.py +++ b/climada/trajectories/trajectory.py @@ -24,6 +24,7 @@ import datetime import logging from abc import ABC, abstractmethod +from typing import Iterable import pandas as pd @@ -72,9 +73,9 @@ class RiskTrajectory(ABC): def __init__( self, - snapshots_list: list[Snapshot], + snapshots_list: Iterable[Snapshot], *, - return_periods: list[int] = DEFAULT_RP, + return_periods: Iterable[int] = DEFAULT_RP, all_groups_name: str = DEFAULT_ALLGROUP_NAME, risk_disc_rates: DiscRates | None = None, ): @@ -137,7 +138,7 @@ def _compute_metrics( ) @property - def return_periods(self) -> list[int]: + def return_periods(self) -> Iterable[int]: """The return period values to use when computing risk period metrics. Notes From 68ee822e28039a77e245881aaa787412cbc56d0b Mon Sep 17 00:00:00 2001 From: spjuhel Date: Mon, 5 Jan 2026 18:08:27 +0100 Subject: [PATCH 42/61] Pylint compliance --- climada/trajectories/calc_risk_metrics.py | 363 +++++++----------- .../trajectories/interpolated_trajectory.py | 182 +++++---- 2 files changed, 246 insertions(+), 299 deletions(-) diff --git a/climada/trajectories/calc_risk_metrics.py b/climada/trajectories/calc_risk_metrics.py index 6635f89a3b..ed618bf62e 100644 --- a/climada/trajectories/calc_risk_metrics.py +++ b/climada/trajectories/calc_risk_metrics.py @@ -29,6 +29,7 @@ import datetime import itertools import logging +import re import numpy as np import pandas as pd @@ -393,7 +394,8 @@ class CalcRiskMetricsPeriod: date_idx: pd.PeriodIndex The date index for the different interpolated points between the two snapshots interpolation_strategy: InterpolationStrategy, optional - The approach used to interpolate impact matrices in between the two snapshots, linear by default. + The approach used to interpolate impact matrices in between the two snapshots, + linear by default. impact_computation_strategy: ImpactComputationStrategy, optional The method used to calculate the impact from the (Haz,Exp,Vul) of the two snapshots. Defaults to ImpactCalc @@ -408,8 +410,9 @@ class CalcRiskMetricsPeriod: def __init__( self, - snapshot0: Snapshot, - snapshot1: Snapshot, + snapshot_start: Snapshot, + snapshot_end: Snapshot, + *, time_resolution: str, interpolation_strategy: InterpolationStrategyBase, impact_computation_strategy: ImpactComputationStrategy, @@ -426,29 +429,32 @@ def __init__( snapshot1 : Snapshot The `Snapshot` at the end of the risk period. time_resolution : str, optional - One of pandas date offset strings or corresponding objects. See :func:`pandas.period_range`. + One of pandas date offset strings or corresponding objects. + See :func:`pandas.period_range`. time_points : int, optional Number of periods to generate for the PeriodIndex. interpolation_strategy: InterpolationStrategy, optional - The approach used to interpolate impact matrices in between the two snapshots, linear by default. + The approach used to interpolate impact matrices in + between the two snapshots, linear by default. impact_computation_strategy: ImpactComputationStrategy, optional - The method used to calculate the impact from the (Haz,Exp,Vul) of the two snapshots. + The method used to calculate the impact from the (Haz,Exp,Vul) + of the two snapshots. Defaults to ImpactCalc """ LOGGER.debug("Instantiating new CalcRiskPeriod.") - self._snapshot0 = snapshot0 - self._snapshot1 = snapshot1 + self._snapshot_start = snapshot_start + self._snapshot_end = snapshot_end self.date_idx = self._set_date_idx( - date1=snapshot0.date, - date2=snapshot1.date, + date1=snapshot_start.date, + date2=snapshot_end.date, freq=time_resolution, name=DEFAULT_PERIOD_INDEX_NAME, ) self.interpolation_strategy = interpolation_strategy self.impact_computation_strategy = impact_computation_strategy - self.measure = None # Only possible to set with apply_measure to make sure snapshots are consistent + self.measure = None # Only possible to set with apply_measure() self._group_id_E0 = ( np.array(self.snapshot_start.exposure.gdf[GROUP_ID_COL_NAME].values) @@ -469,15 +475,8 @@ def _reset_impact_data(self): for fut in list(itertools.product([0, 1], repeat=3)): setattr(self, f"_E{fut[0]}H{fut[1]}V{fut[2]}", None) - for fut in list(itertools.product([0, 1], repeat=2)): - setattr(self, f"_imp_mats_H{fut[0]}V{fut[1]}", None) - setattr(self, f"_per_date_eai_H{fut[0]}V{fut[1]}", None) - setattr(self, f"_per_date_aai_H{fut[0]}V{fut[1]}", None) - - self._eai_gdf = None self._per_date_eai = None self._per_date_aai = None - self._per_date_return_periods_H0, self._per_date_return_periods_H1 = None, None @staticmethod def _set_date_idx( @@ -521,12 +520,12 @@ def _set_date_idx( @property def snapshot_start(self) -> Snapshot: """The `Snapshot` at the start of the risk period.""" - return self._snapshot0 + return self._snapshot_start @property def snapshot_end(self) -> Snapshot: """The `Snapshot` at the end of the risk period.""" - return self._snapshot1 + return self._snapshot_end @property def date_idx(self) -> pd.PeriodIndex: @@ -539,18 +538,20 @@ def date_idx(self, value, /): raise ValueError("Not a PeriodIndex") self._date_idx = value # Avoids weird hourly data - self._time_points = len(self.date_idx) self._time_resolution = self.date_idx.freq self._reset_impact_data() @property def time_points(self) -> int: """The numbers of different time points (periods) in the risk period.""" - return self._time_points + return len(self.date_idx) @property def time_resolution(self) -> str: - """The time resolution of the risk periods, expressed as a pandas period frequency string.""" + """The time resolution of the risk periods, expressed as + a pandas period frequency string. + + """ return self._time_resolution # type: ignore @time_resolution.setter @@ -611,9 +612,9 @@ def apply_measure(self, measure: Measure) -> "CalcRiskMetricsPeriod": risk_period = CalcRiskMetricsPeriod( snap0, snap1, - self.time_resolution, - self.interpolation_strategy, - self.impact_computation_strategy, + time_resolution=self.time_resolution, + interpolation_strategy=self.interpolation_strategy, + impact_computation_strategy=self.impact_computation_strategy, ) risk_period.measure = measure @@ -624,7 +625,10 @@ def apply_measure(self, measure: Measure) -> "CalcRiskMetricsPeriod": @lazy_property def E0H0V0(self) -> Impact: - """Impact object corresponding to starting exposure, starting hazard and starting vulnerability.""" + """Impact object corresponding to starting exposure, + starting hazard and starting vulnerability. + + """ return self.impact_computation_strategy.compute_impacts( self.snapshot_start.exposure, self.snapshot_start.hazard, @@ -633,7 +637,10 @@ def E0H0V0(self) -> Impact: @lazy_property def E1H0V0(self) -> Impact: - """Impact object corresponding to future exposure, starting hazard and starting vulnerability.""" + """Impact object corresponding to future exposure, + starting hazard and starting vulnerability. + + """ return self.impact_computation_strategy.compute_impacts( self.snapshot_end.exposure, self.snapshot_start.hazard, @@ -642,7 +649,10 @@ def E1H0V0(self) -> Impact: @lazy_property def E0H1V0(self) -> Impact: - """Impact object corresponding to starting exposure, future hazard and starting vulnerability.""" + """Impact object corresponding to starting exposure, + future hazard and starting vulnerability. + + """ return self.impact_computation_strategy.compute_impacts( self.snapshot_start.exposure, self.snapshot_end.hazard, @@ -651,7 +661,10 @@ def E0H1V0(self) -> Impact: @lazy_property def E1H1V0(self) -> Impact: - """Impact object corresponding to future exposure, future hazard and starting vulnerability.""" + """Impact object corresponding to future exposure, + future hazard and starting vulnerability. + + """ return self.impact_computation_strategy.compute_impacts( self.snapshot_end.exposure, self.snapshot_end.hazard, @@ -660,7 +673,10 @@ def E1H1V0(self) -> Impact: @lazy_property def E0H0V1(self) -> Impact: - """Impact object corresponding to starting exposure, starting hazard and future vulnerability.""" + """Impact object corresponding to starting exposure, + starting hazard and future vulnerability. + + """ return self.impact_computation_strategy.compute_impacts( self.snapshot_start.exposure, self.snapshot_start.hazard, @@ -669,7 +685,10 @@ def E0H0V1(self) -> Impact: @lazy_property def E1H0V1(self) -> Impact: - """Impact object corresponding to future exposure, starting hazard and future vulnerability.""" + """Impact object corresponding to future exposure, + starting hazard and future vulnerability. + + """ return self.impact_computation_strategy.compute_impacts( self.snapshot_end.exposure, self.snapshot_start.hazard, @@ -678,7 +697,10 @@ def E1H0V1(self) -> Impact: @lazy_property def E0H1V1(self) -> Impact: - """Impact object corresponding to starting exposure, future hazard and future vulnerability.""" + """Impact object corresponding to starting exposure, + future hazard and future vulnerability. + + """ return self.impact_computation_strategy.compute_impacts( self.snapshot_start.exposure, self.snapshot_end.hazard, @@ -687,7 +709,10 @@ def E0H1V1(self) -> Impact: @lazy_property def E1H1V1(self) -> Impact: - """Impact object corresponding to future exposure, future hazard and future vulnerability.""" + """Impact object corresponding to future exposure, + future hazard and future vulnerability. + + """ return self.impact_computation_strategy.compute_impacts( self.snapshot_end.exposure, self.snapshot_end.hazard, @@ -707,95 +732,38 @@ def _interp_mats(self, start_attr, end_attr) -> list: start, end, self.time_points ) - @property - def imp_mats_H0V0(self) -> list: - """List of `time_points` impact matrices with changing exposure, starting hazard and starting vulnerability.""" - return self._interp_mats("E0H0V0", "E1H0V0") - - @property - def imp_mats_H1V0(self) -> list: - """List of `time_points` impact matrices with changing exposure, future hazard and starting vulnerability.""" - return self._interp_mats("E0H1V0", "E1H1V0") + def _imp_mats(self, invariant: str) -> list: + """List of `time_points` impact matrices with changing + exposure, and invariant hazard and vulnerability. - @property - def imp_mats_H0V1(self) -> list: - """List of `time_points` impact matrices with changing exposure, starting hazard and future vulnerability.""" - return self._interp_mats("E0H0V1", "E1H0V1") - - @property - def imp_mats_H1V1(self) -> list: - """List of `time_points` impact matrices with changing exposure, future hazard and future vulnerability.""" - return self._interp_mats("E0H1V1", "E1H1V1") - - ### The following are for risk contributions - - @property - def imp_mats_E0H0V0(self) -> list: - """List of `time_points` impact matrices with base exposure, base hazard and base vulnerability.""" - return [self.E0H0V0.imp_mat] * self.time_points + """ + if re.match(r"H[01]V[01]", invariant): + return self._interp_mats(f"E0{invariant}", f"E1{invariant}") - @property - def imp_mats_E0H1V0(self) -> list: - """List of `time_points` impact matrices with base exposure, future hazard and base vulnerability.""" - return [self.E0H1V0.imp_mat] * self.time_points + if re.match(r"E[01]H[01]V[01]", invariant): + return [getattr(self, invariant).imp_mat] * self.time_points - @property - def imp_mats_E0H0V1(self) -> list: - """List of `time_points` impact matrices with base exposure, base hazard and base vulnerability.""" - return [self.E0H0V1.imp_mat] * self.time_points + raise ValueError( + f"Unrecognised invariant format ({invariant}), should be H[01]V[01] | E[01]H[01]V[01]" + ) ############################### ############################### ########## Core EAI ########### - @property - def per_date_eai_H0V0(self) -> np.ndarray: - """Expected annual impacts for changing exposure, starting hazard and starting vulnerability.""" - return calc_per_date_eais( - self.imp_mats_H0V0, self.snapshot_start.hazard.frequency - ) - - @property - def per_date_eai_H1V0(self) -> np.ndarray: - """Expected annual impacts for changing exposure, future hazard and starting vulnerability.""" - return calc_per_date_eais( - self.imp_mats_H1V0, self.snapshot_end.hazard.frequency - ) - - @property - def per_date_eai_H0V1(self) -> np.ndarray: - """Expected annual impacts for changing exposure, starting hazard and future vulnerability.""" - return calc_per_date_eais( - self.imp_mats_H0V1, self.snapshot_start.hazard.frequency - ) + def _per_date_eais_interp(self, invariant: str) -> np.ndarray: + """Expected annual impacts for changing exposure, and fixed + hazard and vulnerability. - @property - def per_date_eai_H1V1(self) -> np.ndarray: - """Expected annual impacts for changing exposure, future hazard and future vulnerability.""" - return calc_per_date_eais( - self.imp_mats_H1V1, self.snapshot_end.hazard.frequency - ) - - @property - def per_date_eai_E0H0V0(self) -> np.ndarray: - """Expected annual impacts for base exposure, base hazard and base vulnerability.""" - return calc_per_date_eais( - self.imp_mats_E0H0V0, self.snapshot_start.hazard.frequency - ) - - @property - def per_date_eai_E0H1V0(self) -> np.ndarray: - """Expected annual impacts for base exposure, future hazard and base vulnerability.""" - return calc_per_date_eais( - self.imp_mats_E0H1V0, self.snapshot_end.hazard.frequency - ) - - @property - def per_date_eai_E0H0V1(self) -> np.ndarray: - """Expected annual impacts for base exposure, future hazard and base vulnerability.""" + """ return calc_per_date_eais( - self.imp_mats_E0H0V1, self.snapshot_start.hazard.frequency + self._imp_mats(invariant=invariant), + ( + self.snapshot_start.hazard.frequency + if "H0" in invariant + else self.snapshot_end.hazard.frequency + ), ) ############################## @@ -804,76 +772,23 @@ def per_date_eai_E0H0V1(self) -> np.ndarray: # Not required for final AAIs computation (we use final EAIs instead), # but could be useful in the future? - @property - def per_date_aai_H0V0(self) -> np.ndarray: - """Average annual impacts for changing exposure, starting hazard and starting vulnerability.""" - return calc_per_date_aais(self.per_date_eai_H0V0) - - @property - def per_date_aai_H1V0(self) -> np.ndarray: - """Average annual impacts for changing exposure, future hazard and starting vulnerability.""" - return calc_per_date_aais(self.per_date_eai_H1V0) - - @property - def per_date_aai_H0V1(self) -> np.ndarray: - """Average annual impacts for changing exposure, starting hazard and future vulnerability.""" - return calc_per_date_aais(self.per_date_eai_H0V1) - - @property - def per_date_aai_H1V1(self) -> np.ndarray: - """Average annual impacts for changing exposure, future hazard and future vulnerability.""" - return calc_per_date_aais(self.per_date_eai_H1V1) - - @property - def per_date_aai_E0H0V0(self) -> np.ndarray: - """Average annual impacts for base exposure, base hazard and base vulnerability.""" - return calc_per_date_aais(self.per_date_eai_E0H0V0) - - @property - def per_date_aai_E0H1V0(self) -> np.ndarray: - """Average annual impacts for base exposure, base hazard and base vulnerability.""" - return calc_per_date_aais(self.per_date_eai_E0H1V0) - - @property - def per_date_aai_E0H0V1(self) -> np.ndarray: - """Average annual impacts for base exposure, base hazard and base vulnerability.""" - return calc_per_date_aais(self.per_date_eai_E0H0V1) + def _per_date_aais_interp(self, invariant: str) -> np.ndarray: + """Average periodic impacts for specified invariant.""" + return calc_per_date_aais(self._per_date_eais_interp(invariant=invariant)) ############################# ######### Core RPs ######### - def per_date_return_periods_H0V0(self, return_periods: list[int]) -> np.ndarray: - """Estimated impacts per dates for given return periods, with changing exposure, starting hazard and starting vulnerability.""" + def _per_date_return_periods( + self, invariant: str, return_periods: list[int] + ) -> np.ndarray: return calc_per_date_rps( - self.imp_mats_H0V0, - self.snapshot_start.hazard.frequency, - self.date_idx.freqstr[0], - return_periods, - ) - - def per_date_return_periods_H1V0(self, return_periods: list[int]) -> np.ndarray: - """Estimated impacts per dates for given return periods, with changing exposure, future hazard and starting vulnerability.""" - return calc_per_date_rps( - self.imp_mats_H1V0, - self.snapshot_end.hazard.frequency, - self.date_idx.freqstr[0], - return_periods, - ) - - def per_date_return_periods_H0V1(self, return_periods: list[int]) -> np.ndarray: - """Estimated impacts per dates for given return periods, with changing exposure, starting hazard and future vulnerability.""" - return calc_per_date_rps( - self.imp_mats_H0V1, - self.snapshot_start.hazard.frequency, - self.date_idx.freqstr[0], - return_periods, - ) - - def per_date_return_periods_H1V1(self, return_periods: list[int]) -> np.ndarray: - """Estimated impacts per dates for given return periods, with changing exposure, future hazard and future vulnerability.""" - return calc_per_date_rps( - self.imp_mats_H1V1, - self.snapshot_end.hazard.frequency, + self._imp_mats(invariant=invariant), + ( + self.snapshot_start.hazard.frequency + if "H0" in invariant + else self.snapshot_end.hazard.frequency + ), self.date_idx.freqstr[0], return_periods, ) @@ -883,13 +798,13 @@ def per_date_return_periods_H1V1(self, return_periods: list[int]) -> np.ndarray: # Actual results - def calc_eai(self) -> np.ndarray: + def _calc_eai(self) -> np.ndarray: """Compute the EAIs at each date of the risk period (including changes in exposure, hazard and vulnerability).""" per_date_eai_H0V0, per_date_eai_H1V0, per_date_eai_H0V1, per_date_eai_H1V1 = ( - self.per_date_eai_H0V0, - self.per_date_eai_H1V0, - self.per_date_eai_H0V1, - self.per_date_eai_H1V1, + self._per_date_eais_interp("H0V0"), + self._per_date_eais_interp("H1V0"), + self._per_date_eais_interp("H0V1"), + self._per_date_eais_interp("H1V1"), ) per_date_eai_V0 = self.interpolation_strategy.interp_over_hazard_dim( per_date_eai_H0V0, per_date_eai_H1V0 @@ -906,30 +821,37 @@ def calc_eai(self) -> np.ndarray: @lazy_property def per_date_eai(self) -> np.ndarray: - """Expected annual impacts per date with changing exposure, changing hazard and changing vulnerability""" - return self.calc_eai() + """Expected annual impacts per date with changing + exposure, changing hazard and changing vulnerability. + + """ + return self._calc_eai() @lazy_property def per_date_aai(self) -> np.ndarray: - """Average annual impacts per date with changing exposure, changing hazard and changing vulnerability.""" + """Average annual impacts per date with changing + exposure, changing hazard and changing vulnerability. + + """ return calc_per_date_aais(self.per_date_eai) #################################### ######## Tidying results ########### def calc_eai_gdf(self) -> pd.DataFrame: - """Convenience function returning a DataFrame (with both datetime and coordinates ids) from `per_date_eai`. + """Convenience function returning a DataFrame from `per_date_eai`. This dataframe can easily be merged with one of the snapshot exposure geodataframe. Notes ----- - The DataFrame from the starting snapshot is used as a basis (notably for `value` and `group_id`). + The DataFrame from the starting snapshot is used as a basis + (notably for `value` and `group_id`). """ - df = pd.DataFrame(self.per_date_eai, index=self.date_idx) - df = df.reset_index().melt( + metric_df = pd.DataFrame(self.per_date_eai, index=self.date_idx) + metric_df = metric_df.reset_index().melt( id_vars=DEFAULT_PERIOD_INDEX_NAME, var_name=COORD_ID_COL_NAME, value_name=RISK_COL_NAME, @@ -937,10 +859,10 @@ def calc_eai_gdf(self) -> pd.DataFrame: if GROUP_ID_COL_NAME in self.snapshot_start.exposure.gdf: eai_gdf = self.snapshot_start.exposure.gdf[[GROUP_ID_COL_NAME]] eai_gdf[COORD_ID_COL_NAME] = eai_gdf.index - eai_gdf = eai_gdf.merge(df, on=COORD_ID_COL_NAME) + eai_gdf = eai_gdf.merge(metric_df, on=COORD_ID_COL_NAME) eai_gdf = eai_gdf.rename(columns={GROUP_ID_COL_NAME: GROUP_COL_NAME}) else: - eai_gdf = df + eai_gdf = metric_df eai_gdf[GROUP_COL_NAME] = pd.NA eai_gdf[GROUP_COL_NAME] = pd.Categorical( @@ -954,7 +876,10 @@ def calc_eai_gdf(self) -> pd.DataFrame: return eai_gdf def calc_aai_metric(self) -> pd.DataFrame: - """Compute a DataFrame of the AAI at each dates of the risk period (including changes in exposure, hazard and vulnerability).""" + """Compute a DataFrame of the AAI at each dates of the risk period + (including changes in exposure, hazard and vulnerability). + + """ aai_df = pd.DataFrame( index=self.date_idx, columns=[RISK_COL_NAME], data=self.per_date_aai ) @@ -970,12 +895,14 @@ def calc_aai_metric(self) -> pd.DataFrame: return aai_df def calc_aai_per_group_metric(self) -> pd.DataFrame | None: - """Compute a DataFrame of the AAI distinguised per group id in the exposures, at each dates of the risk period (including changes in exposure, hazard and vulnerability). + """Compute a DataFrame of the AAI distinguised per group id in the exposures, + at each dates of the risk period (including changes in exposure, hazard and vulnerability). Notes ----- - If group ids changes between starting and ending snapshots of the risk period, the AAIs are linearly interpolated (with a warning for transparency). + If group ids changes between starting and ending snapshots of the risk period, + the AAIs are linearly interpolated (with a warning for transparency). """ if len(self._group_id_E0) < 1 or len(self._group_id_E1) < 1: @@ -998,7 +925,8 @@ def calc_aai_per_group_metric(self) -> pd.DataFrame | None: )[RISK_COL_NAME].sum() if not np.array_equal(self._group_id_E0, self._group_id_E1): LOGGER.warning( - "Group id are changing between present and future snapshot. Per group AAI will be linearly interpolated." + "Group id are changing between present and future snapshot." + " Per group AAI will be linearly interpolated." ) eai_fut_groups = eai_gdf.copy() eai_fut_groups[GROUP_COL_NAME] = pd.Categorical( @@ -1035,10 +963,10 @@ def calc_return_periods_metric(self, return_periods: list[int]) -> pd.DataFrame: # currently mathematicaly wrong, but approximatively correct, to be reworked when concatenating the impact matrices for the interpolation per_date_rp_H0V0, per_date_rp_H1V0, per_date_rp_H0V1, per_date_rp_H1V1 = ( - self.per_date_return_periods_H0V0(return_periods), - self.per_date_return_periods_H1V0(return_periods), - self.per_date_return_periods_H0V1(return_periods), - self.per_date_return_periods_H1V1(return_periods), + self._per_date_return_periods("H0V0", return_periods), + self._per_date_return_periods("H1V0", return_periods), + self._per_date_return_periods("H0V1", return_periods), + self._per_date_return_periods("H1V1", return_periods), ) per_date_rp_V0 = self.interpolation_strategy.interp_over_hazard_dim( per_date_rp_H0V0, per_date_rp_H1V0 @@ -1071,18 +999,19 @@ def calc_risk_contributions_metric(self) -> pd.DataFrame: """ aai_changes_hazard_only = self.interpolation_strategy.interp_over_hazard_dim( - self.per_date_aai_E0H0V0, self.per_date_aai_E0H1V0 + self._per_date_aais_interp("E0H0V0"), self._per_date_aais_interp("E0H1V0") ) aai_changes_vulnerability_only = ( self.interpolation_strategy.interp_over_vulnerability_dim( - self.per_date_aai_E0H0V0, self.per_date_aai_E0H0V1 + self._per_date_aais_interp("E0H0V0"), + self._per_date_aais_interp("E0H0V1"), ) ) - df = pd.DataFrame( + metric_df = pd.DataFrame( { CONTRIBUTION_TOTAL_RISK_NAME: self.per_date_aai, CONTRIBUTION_BASE_RISK_NAME: self.per_date_aai[0], - CONTRIBUTION_EXPOSURE_NAME: self.per_date_aai_H0V0 + CONTRIBUTION_EXPOSURE_NAME: self._per_date_aais_interp("H0V0") - self.per_date_aai[0], CONTRIBUTION_HAZARD_NAME: aai_changes_hazard_only - self.per_date_aai[0], @@ -1091,13 +1020,15 @@ def calc_risk_contributions_metric(self) -> pd.DataFrame: }, index=self.date_idx, ) - df[CONTRIBUTION_INTERACTION_TERM_NAME] = df[CONTRIBUTION_TOTAL_RISK_NAME] - ( - df[CONTRIBUTION_BASE_RISK_NAME] - + df[CONTRIBUTION_EXPOSURE_NAME] - + df[CONTRIBUTION_HAZARD_NAME] - + df[CONTRIBUTION_VULNERABILITY_NAME] + metric_df[CONTRIBUTION_INTERACTION_TERM_NAME] = metric_df[ + CONTRIBUTION_TOTAL_RISK_NAME + ] - ( + metric_df[CONTRIBUTION_BASE_RISK_NAME] + + metric_df[CONTRIBUTION_EXPOSURE_NAME] + + metric_df[CONTRIBUTION_HAZARD_NAME] + + metric_df[CONTRIBUTION_VULNERABILITY_NAME] ) - df = df.melt( + metric_df = metric_df.melt( value_vars=[ CONTRIBUTION_BASE_RISK_NAME, CONTRIBUTION_EXPOSURE_NAME, @@ -1109,13 +1040,15 @@ def calc_risk_contributions_metric(self) -> pd.DataFrame: value_name=RISK_COL_NAME, ignore_index=False, ) - df.reset_index(inplace=True) - df[GROUP_COL_NAME] = pd.Categorical( - [pd.NA] * len(df), categories=self._groups_id + metric_df.reset_index(inplace=True) + metric_df[GROUP_COL_NAME] = pd.Categorical( + [pd.NA] * len(metric_df), categories=self._groups_id + ) + metric_df[MEASURE_COL_NAME] = ( + self.measure.name if self.measure else NO_MEASURE_VALUE ) - df[MEASURE_COL_NAME] = self.measure.name if self.measure else NO_MEASURE_VALUE - df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit - return df + metric_df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit + return metric_df #################################### diff --git a/climada/trajectories/interpolated_trajectory.py b/climada/trajectories/interpolated_trajectory.py index af194ec01b..1ac064a336 100644 --- a/climada/trajectories/interpolated_trajectory.py +++ b/climada/trajectories/interpolated_trajectory.py @@ -24,7 +24,7 @@ import datetime import itertools import logging -from typing import cast +from typing import Iterable, cast import matplotlib as mpl import matplotlib.dates as mdates @@ -106,11 +106,17 @@ class InterpolatedRiskTrajectory(RiskTrajectory): Currently: - - eai, expected impact (per exposure point within a period of 1/frequency unit of the hazard object) + - eai, expected impact (per exposure point within a period of 1/frequency + unit of the hazard object) - aai, average annual impact (aggregated eai over the whole exposure) - - aai_per_group, average annual impact per exposure subgroup (defined from the exposure geodataframe) - - return_periods, estimated impacts aggregated over the whole exposure for different return periods - - risk_contributions, estimated contribution part of, respectively exposure, hazard, vulnerability and their interaction to the change in risk over the considered period + - aai_per_group, average annual impact per exposure subgroup (defined from + the exposure geodataframe) + - return_periods, estimated impacts aggregated over the whole exposure for + different return periods + - risk_contributions, estimated contribution part of, respectively exposure, + hazard, vulnerability and their interaction to the change in risk over the + considered period + """ _DEFAULT_ALL_METRICS = [ @@ -121,11 +127,10 @@ class InterpolatedRiskTrajectory(RiskTrajectory): def __init__( self, - snapshots_list: list[Snapshot], + snapshots_list: Iterable[Snapshot], *, - return_periods: list[int] = DEFAULT_RP, + return_periods: Iterable[int] = DEFAULT_RP, time_resolution: str = DEFAULT_TIME_RESOLUTION, - all_groups_name: str = DEFAULT_ALLGROUP_NAME, risk_disc_rates: DiscRates | None = None, interpolation_strategy: InterpolationStrategyBase | None = None, impact_computation_strategy: ImpactComputationStrategy | None = None, @@ -160,12 +165,12 @@ def __init__( super().__init__( snapshots_list, return_periods=return_periods, - all_groups_name=all_groups_name, + all_groups_name=DEFAULT_ALLGROUP_NAME, risk_disc_rates=risk_disc_rates, ) self._risk_metrics_up_to_date: bool = False - self.start_date = min([snapshot.date for snapshot in snapshots_list]) - self.end_date = max([snapshot.date for snapshot in snapshots_list]) + self.start_date = min((snapshot.date for snapshot in snapshots_list)) + self.end_date = max((snapshot.date for snapshot in snapshots_list)) self._risk_metrics_calculators = self._reset_risk_metrics_calculators( self._snapshots, time_resolution, @@ -261,9 +266,9 @@ def pairwise(container: list): >>> list(pairwise([1, 2, 3, 4])) [(1, 2), (2, 3), (3, 4)] """ - a, b = itertools.tee(container) - next(b, None) - return zip(a, b) + first, second = itertools.tee(container) + next(second, None) + return zip(first, second) return [ CalcRiskMetricsPeriod( @@ -280,6 +285,7 @@ def pairwise(container: list): def _generic_metrics( self, + /, metric_name: str | None = None, metric_meth: str | None = None, **kwargs, @@ -326,65 +332,80 @@ def _generic_metrics( f"{metric_name} not implemented ({self.POSSIBLE_METRICS})." ) - # Construct the attribute name for storing the metric results attr_name = f"_{metric_name}_metrics" if getattr(self, attr_name) is not None: - LOGGER.debug(f"Returning cached {attr_name}") + LOGGER.debug("Returning cached %s, ", attr_name) return getattr(self, attr_name) - LOGGER.debug(f"Computing {attr_name}") + LOGGER.debug("Computing %s", attr_name) with log_level(level="WARNING", name_prefix="climada"): tmp = [ getattr(calc_period, metric_meth)(**kwargs) for calc_period in self._risk_metrics_calculators ] - # Notably for per_group_aai being None: try: tmp = pd.concat(tmp) - if len(tmp) == 0: + except ValueError as exc: + if str(exc) == "All objects passed were None": return pd.DataFrame() - except ValueError as e: - if str(e) == "All objects passed were None": - return pd.DataFrame() - else: - raise e + raise exc - else: - tmp = tmp.set_index(INDEXING_COLUMNS) - if COORD_ID_COL_NAME in tmp.columns: - tmp = tmp.set_index([COORD_ID_COL_NAME], append=True) - - # When more than 2 snapshots, there are duplicated rows, we need to remove them. - tmp = tmp[~tmp.index.duplicated(keep="first")] - tmp = tmp.reset_index() - if self._all_groups_name not in tmp[GROUP_COL_NAME].cat.categories: - tmp[GROUP_COL_NAME] = tmp[GROUP_COL_NAME].cat.add_categories( - [self._all_groups_name] - ) - tmp[GROUP_COL_NAME] = tmp[GROUP_COL_NAME].fillna(self._all_groups_name) - - if metric_name == CONTRIBUTIONS_METRIC_NAME and len(self._snapshots) > 2: - # If there is more than one Snapshot, we need to update the - # contributions from previous periods for continuity - # and to set the base risk from the first period - # This is not elegant, but we need the concatenated metrics from each period, - # so we can't do it in the calculators, and we need - # to do it before caching in the private attribute - tmp = self._risk_contributions_post_treatment(tmp) - - if self._risk_disc_rates: - LOGGER.debug("Found risk discount rate. Computing NPV.") - tmp = self.npv_transform(tmp, self._risk_disc_rates) - - tmp = reorder_dataframe_columns(tmp, DEFAULT_DF_COLUMN_PRIORITY) - if CONFIG.trajectory_caching.bool(): - LOGGER.debug("All computing done, caching value.") - setattr(self, attr_name, tmp) - return getattr(self, attr_name) - else: - return tmp + if len(tmp) == 0: + return pd.DataFrame() + + tmp = self._metric_post_treatment(tmp, metric_name) + + if CONFIG.trajectory_caching.bool(): + LOGGER.debug("All computing done, caching value.") + setattr(self, attr_name, tmp) + return getattr(self, attr_name) + + return tmp + + def _metric_post_treatment( + self, metric_df: pd.DataFrame, metric_name: str + ) -> pd.DataFrame: + # Notably for per_group_aai being None: + metric_df = self._avoid_duplicates(metric_df) + metric_df = self._handle_group_categories(metric_df) + if metric_name == CONTRIBUTIONS_METRIC_NAME and len(self._snapshots) > 2: + # If there is more than one Snapshot, we need to update the + # contributions from previous periods for continuity + # and to set the base risk from the first period + # This is not elegant, but we need the concatenated metrics from each period, + # so we can't do it in the calculators, and we need + # to do it before caching in the private attribute + metric_df = self._risk_contributions_post_treatment(metric_df) + + if self._risk_disc_rates: + LOGGER.debug("Found risk discount rate. Computing NPV.") + metric_df = self.npv_transform(metric_df, self._risk_disc_rates) + + metric_df = reorder_dataframe_columns(metric_df, DEFAULT_DF_COLUMN_PRIORITY) + return metric_df + + def _avoid_duplicates(self, metric_df: pd.DataFrame) -> pd.DataFrame: + metric_df = metric_df.set_index(INDEXING_COLUMNS) + if COORD_ID_COL_NAME in metric_df.columns: + metric_df = metric_df.set_index([COORD_ID_COL_NAME], append=True) + + # When more than 2 snapshots, there are duplicated rows, we need to remove them. + metric_df = metric_df[~metric_df.index.duplicated(keep="first")] + metric_df = metric_df.reset_index() + return metric_df + + def _handle_group_categories(self, metric_df: pd.DataFrame) -> pd.DataFrame: + if self._all_groups_name not in metric_df[GROUP_COL_NAME].cat.categories: + metric_df[GROUP_COL_NAME] = metric_df[GROUP_COL_NAME].cat.add_categories( + [self._all_groups_name] + ) + metric_df[GROUP_COL_NAME] = metric_df[GROUP_COL_NAME].fillna( + self._all_groups_name + ) + + return metric_df def _compute_period_metrics( self, metric_name: str, metric_meth: str, **kwargs @@ -585,15 +606,15 @@ def _get_risk_periods( and end_date >= period.snapshot_end.date ) ] - else: - return [ - period - for period in risk_periods - if not ( - start_date >= period.snapshot_end.date - or end_date <= period.snapshot_start.date - ) - ] + + return [ + period + for period in risk_periods + if not ( + start_date >= period.snapshot_end.date + or end_date <= period.snapshot_start.date + ) + ] @staticmethod def _identify_continuous_periods(group, time_unit): @@ -614,25 +635,16 @@ def _identify_continuous_periods(group, time_unit): @classmethod def _date_to_period_agg( cls, - df: pd.DataFrame, + metric_df: pd.DataFrame, grouper: list[str], time_unit: str = "year", colname: str | list[str] = RISK_COL_NAME, ) -> pd.DataFrame: """Group per date risk metric to periods.""" - def conditional_agg(group): - try: - if "rp" in group.name[2]: - return group.mean() - else: - return group.sum() - except IndexError: - return group.sum() - - df_sorted = df.sort_values(by=grouper + [DATE_COL_NAME]) + df_sorted = metric_df.sort_values(by=grouper + [DATE_COL_NAME]) - if GROUP_COL_NAME in df.columns and GROUP_COL_NAME not in grouper: + if GROUP_COL_NAME in metric_df.columns and GROUP_COL_NAME not in grouper: grouper = [GROUP_COL_NAME] + grouper # Apply the function to identify continuous periods @@ -677,18 +689,18 @@ def conditional_agg(group): def per_period_risk_metrics( self, - metrics: list[str] = [ + metrics: Iterable[str] = ( AAI_METRIC_NAME, RETURN_PERIOD_METRIC_NAME, AAI_PER_GROUP_METRIC_NAME, - ], + ), **kwargs, ) -> pd.DataFrame: """Return a tidy dataframe of the risk metrics with the total for each different period (pair of snapshots).""" - df = self.per_date_risk_metrics(metrics=metrics, **kwargs) + metric_df = self.per_date_risk_metrics(metrics=metrics, **kwargs) return self._date_to_period_agg( - df, grouper=self._grouper + [UNIT_COL_NAME], **kwargs + metric_df, grouper=self._grouper + [UNIT_COL_NAME], **kwargs ) def _calc_waterfall_plot_data( @@ -709,6 +721,8 @@ def _calc_waterfall_plot_data( )[RISK_COL_NAME].unstack() return risk_contributions + # Acceptable given it is a plotting function + # pylint: disable=too-many-locals def plot_time_waterfall( self, ax=None, @@ -766,7 +780,7 @@ def plot_time_waterfall( labels=positive_contrib.columns, colors=[csequence[color_index[col]] for col in positive_contrib.columns], ) - if not (negative_contrib.empty): + if not negative_contrib.empty: ax.stackplot( negative_contrib.index.to_timestamp(), # type: ignore [negative_contrib[col] for col in negative_contrib.columns], From 36e078d12c1845d336beba5e935bcfac573c7d50 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 6 Jan 2026 10:06:59 +0100 Subject: [PATCH 43/61] pylint compliance --- .../trajectories/interpolated_trajectory.py | 38 ++++++++++++------- 1 file changed, 25 insertions(+), 13 deletions(-) diff --git a/climada/trajectories/interpolated_trajectory.py b/climada/trajectories/interpolated_trajectory.py index 1ac064a336..22c73cfa01 100644 --- a/climada/trajectories/interpolated_trajectory.py +++ b/climada/trajectories/interpolated_trajectory.py @@ -226,7 +226,8 @@ def time_resolution(self) -> str: def time_resolution(self, value, /): if not isinstance(value, str): raise ValueError( - 'time_resolution should be a valid pandas Period frequency string (e.g., `"Y"`, `"M"`, `"D"`).' + "time_resolution should be a valid pandas Period" + ' frequency string (e.g., `"Y"`, `"M"`, `"D"`).' ) self._reset_metrics() for rmcalc in self._risk_metrics_calculators: @@ -410,11 +411,14 @@ def _handle_group_categories(self, metric_df: pd.DataFrame) -> pd.DataFrame: def _compute_period_metrics( self, metric_name: str, metric_meth: str, **kwargs ) -> pd.DataFrame: - """Helper method to compute total metrics per period (i.e. whole ranges between pairs of consecutive snapshots).""" - df = self._generic_metrics( + """Helper method to compute total metrics per period + (i.e. whole ranges between pairs of consecutive snapshots). + + """ + metric_df = self._generic_metrics( metric_name=metric_name, metric_meth=metric_meth, **kwargs ) - return self._date_to_period_agg(df, grouper=self._grouper) + return self._date_to_period_agg(metric_df, grouper=self._grouper) def eai_metrics(self, **kwargs) -> pd.DataFrame: """Return the estimated annual impacts at each exposure point for each date. @@ -477,11 +481,16 @@ def risk_contributions_metrics(self, **kwargs) -> pd.DataFrame: This method returns the contributions of the change in risk at each date: - - The 'base risk', i.e., the risk without change in hazard or exposure, compared to trajectory's earliest date. - - The 'exposure contribution', i.e., the additional risks due to change in exposure (only) - - The 'hazard contribution', i.e., the additional risks due to change in hazard (only) - - The 'vulnerability contribution', i.e., the additional risks due to change in vulnerability (only) - - The 'interaction contribution', i.e., the additional risks due to the interaction term + - The 'base risk', i.e., the risk without change in hazard or exposure, + compared to trajectory's earliest date. + - The 'exposure contribution', i.e., the additional risks due to change + in exposure (only) + - The 'hazard contribution', i.e., the additional risks due to change + in hazard (only) + - The 'vulnerability contribution', i.e., the additional risks due to + change in vulnerability (only) + - The 'interaction contribution', i.e., the additional risks due to the + interaction term """ @@ -696,7 +705,10 @@ def per_period_risk_metrics( ), **kwargs, ) -> pd.DataFrame: - """Return a tidy dataframe of the risk metrics with the total for each different period (pair of snapshots).""" + """Return a tidy dataframe of the risk metrics with the total + for each different period (pair of snapshots). + + """ metric_df = self.per_date_risk_metrics(metrics=metrics, **kwargs) return self._date_to_period_agg( @@ -889,11 +901,11 @@ def plot_waterfall( "tab:blue", ], ) - for i in range(len(values)): + for i, val in enumerate(values): ax.text( labels[i], # type: ignore - values[i] + bottoms[i], - f"{values[i]:.0e}", + val + bottoms[i], + f"{val:.0e}", ha="center", va="bottom", color="black", From ad2e77450b1faea09cad53eb36941fe61eb28f1a Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 6 Jan 2026 10:29:19 +0100 Subject: [PATCH 44/61] ref only for apply measure --- climada/trajectories/snapshot.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/climada/trajectories/snapshot.py b/climada/trajectories/snapshot.py index 24a90ca0e1..8d9a74ef6f 100644 --- a/climada/trajectories/snapshot.py +++ b/climada/trajectories/snapshot.py @@ -191,7 +191,7 @@ def _convert_to_date(date_arg) -> datetime.date: raise TypeError("date_arg must be an int, str, or datetime.date") - def apply_measure(self, measure: Measure) -> "Snapshot": + def apply_measure(self, measure: Measure, ref_only: bool = False) -> "Snapshot": """Create a new snapshot by applying a Measure object. This method creates a new `Snapshot` object by applying a measure on @@ -211,6 +211,11 @@ def apply_measure(self, measure: Measure) -> "Snapshot": LOGGER.debug("Applying measure %s on snapshot %s", measure.name, id(self)) exp, impfset, haz = measure.apply(self.exposure, self.impfset, self.hazard) snap = Snapshot( - exposure=exp, hazard=haz, impfset=impfset, date=self.date, measure=measure + exposure=exp, + hazard=haz, + impfset=impfset, + date=self.date, + measure=measure, + ref_only=ref_only, ) return snap From 25fbcdaed93965ea0d8c44d5fc6bc21be4af3180 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 6 Jan 2026 10:35:22 +0100 Subject: [PATCH 45/61] adds API references rst files --- doc/api/climada/climada.rst | 1 + doc/api/climada/climada.trajectories.rst | 7 +++++++ doc/api/climada/climada.trajectories.snapshot.rst | 7 +++++++ 3 files changed, 15 insertions(+) create mode 100644 doc/api/climada/climada.trajectories.rst create mode 100644 doc/api/climada/climada.trajectories.snapshot.rst diff --git a/doc/api/climada/climada.rst b/doc/api/climada/climada.rst index 557532912f..2e8d053946 100644 --- a/doc/api/climada/climada.rst +++ b/doc/api/climada/climada.rst @@ -7,4 +7,5 @@ Software documentation per package climada.engine climada.entity climada.hazard + climada.trajectories climada.util diff --git a/doc/api/climada/climada.trajectories.rst b/doc/api/climada/climada.trajectories.rst new file mode 100644 index 0000000000..28c035e20e --- /dev/null +++ b/doc/api/climada/climada.trajectories.rst @@ -0,0 +1,7 @@ + +climada\.trajectories module +============================ + +.. toctree:: + + climada.trajectories.snapshot diff --git a/doc/api/climada/climada.trajectories.snapshot.rst b/doc/api/climada/climada.trajectories.snapshot.rst new file mode 100644 index 0000000000..ba0faf57ac --- /dev/null +++ b/doc/api/climada/climada.trajectories.snapshot.rst @@ -0,0 +1,7 @@ +climada\.trajectories\.snapshot module +---------------------------------------- + +.. automodule:: climada.trajectories.snapshot + :members: + :undoc-members: + :show-inheritance: From cf40e8f3e4d085ab354af90b4b2e04d6d59b8e9b Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 6 Jan 2026 10:41:10 +0100 Subject: [PATCH 46/61] API references files --- doc/api/climada/climada.trajectories.impact_calc_strat.rst | 7 +++++++ doc/api/climada/climada.trajectories.rst | 1 + 2 files changed, 8 insertions(+) create mode 100644 doc/api/climada/climada.trajectories.impact_calc_strat.rst diff --git a/doc/api/climada/climada.trajectories.impact_calc_strat.rst b/doc/api/climada/climada.trajectories.impact_calc_strat.rst new file mode 100644 index 0000000000..1bf211b4c0 --- /dev/null +++ b/doc/api/climada/climada.trajectories.impact_calc_strat.rst @@ -0,0 +1,7 @@ +climada\.trajectories\.impact_calc_strat module +---------------------------------------- + +.. automodule:: climada.trajectories.impact_calc_strat + :members: + :undoc-members: + :show-inheritance: diff --git a/doc/api/climada/climada.trajectories.rst b/doc/api/climada/climada.trajectories.rst index 28c035e20e..883078074f 100644 --- a/doc/api/climada/climada.trajectories.rst +++ b/doc/api/climada/climada.trajectories.rst @@ -5,3 +5,4 @@ climada\.trajectories module .. toctree:: climada.trajectories.snapshot + climada.trajectories.impact_calc_strat From 76e237f2d22e28eef32f548cf6812f28e727a0eb Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 6 Jan 2026 10:44:03 +0100 Subject: [PATCH 47/61] API reference files --- doc/api/climada/climada.trajectories.interpolation.rst | 7 +++++++ doc/api/climada/climada.trajectories.rst | 7 +++++++ 2 files changed, 14 insertions(+) create mode 100644 doc/api/climada/climada.trajectories.interpolation.rst create mode 100644 doc/api/climada/climada.trajectories.rst diff --git a/doc/api/climada/climada.trajectories.interpolation.rst b/doc/api/climada/climada.trajectories.interpolation.rst new file mode 100644 index 0000000000..98e1ec7b32 --- /dev/null +++ b/doc/api/climada/climada.trajectories.interpolation.rst @@ -0,0 +1,7 @@ +climada\.trajectories\.interpolation module +---------------------------------------- + +.. automodule:: climada.trajectories.interpolation + :members: + :undoc-members: + :show-inheritance: diff --git a/doc/api/climada/climada.trajectories.rst b/doc/api/climada/climada.trajectories.rst new file mode 100644 index 0000000000..ca449199d5 --- /dev/null +++ b/doc/api/climada/climada.trajectories.rst @@ -0,0 +1,7 @@ + +climada\.trajectories module +============================ + +.. toctree:: + + climada.trajectories.interpolation From 183783f2b432d8f6372f724bc72e8e61eabb3555 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 6 Jan 2026 10:48:29 +0100 Subject: [PATCH 48/61] API references files --- doc/api/climada/climada.trajectories.rst | 1 + .../climada/climada.trajectories.trajectories.rst | 15 +++++++++++++++ 2 files changed, 16 insertions(+) create mode 100644 doc/api/climada/climada.trajectories.trajectories.rst diff --git a/doc/api/climada/climada.trajectories.rst b/doc/api/climada/climada.trajectories.rst index 883078074f..67b37809a6 100644 --- a/doc/api/climada/climada.trajectories.rst +++ b/doc/api/climada/climada.trajectories.rst @@ -5,4 +5,5 @@ climada\.trajectories module .. toctree:: climada.trajectories.snapshot + climada.trajectories.trajectories climada.trajectories.impact_calc_strat diff --git a/doc/api/climada/climada.trajectories.trajectories.rst b/doc/api/climada/climada.trajectories.trajectories.rst new file mode 100644 index 0000000000..4abe8acb15 --- /dev/null +++ b/doc/api/climada/climada.trajectories.trajectories.rst @@ -0,0 +1,15 @@ +climada\.trajectories\.static_trajectory module +---------------------------------------- + +.. automodule:: climada.trajectories.static_trajectory + :members: + :undoc-members: + :show-inheritance: + +climada\.trajectories\.trajectory module +---------------------------------------- + +.. automodule:: climada.trajectories.trajectory + :members: + :undoc-members: + :show-inheritance: From b7d39d3a7c02c943e007a7b679dcaa717c075f8e Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 6 Jan 2026 10:53:10 +0100 Subject: [PATCH 49/61] updates API reference --- doc/api/climada/climada.trajectories.trajectories.rst | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/doc/api/climada/climada.trajectories.trajectories.rst b/doc/api/climada/climada.trajectories.trajectories.rst index 4abe8acb15..35583b89d8 100644 --- a/doc/api/climada/climada.trajectories.trajectories.rst +++ b/doc/api/climada/climada.trajectories.trajectories.rst @@ -6,6 +6,14 @@ climada\.trajectories\.static_trajectory module :undoc-members: :show-inheritance: +climada\.trajectories\.static_trajectory module +---------------------------------------- + +.. automodule:: climada.trajectories.interpolated_trajectory + :members: + :undoc-members: + :show-inheritance: + climada\.trajectories\.trajectory module ---------------------------------------- From b8ef41a42991767ea2fa50f6c9b90037dcd1f8f8 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 6 Jan 2026 10:59:20 +0100 Subject: [PATCH 50/61] On The Dangers of Copy Pasting (Juhel 2026) --- climada/trajectories/snapshot.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/climada/trajectories/snapshot.py b/climada/trajectories/snapshot.py index 8d9a74ef6f..05d948793f 100644 --- a/climada/trajectories/snapshot.py +++ b/climada/trajectories/snapshot.py @@ -87,7 +87,7 @@ def __init__( self._exposure = exposure if ref_only else copy.deepcopy(exposure) self._hazard = hazard if ref_only else copy.deepcopy(hazard) self._impfset = impfset if ref_only else copy.deepcopy(impfset) - self._measure = measure if ref_only else copy.deepcopy(impfset) + self._measure = measure if ref_only else copy.deepcopy(measure) self._date = self._convert_to_date(date) @classmethod From 30e2d0efe49716d32f04b11e30b514210c44c889 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 6 Jan 2026 11:29:20 +0100 Subject: [PATCH 51/61] Adds warnings for direct __init__ call --- climada/trajectories/snapshot.py | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/climada/trajectories/snapshot.py b/climada/trajectories/snapshot.py index 05d948793f..233cc15696 100644 --- a/climada/trajectories/snapshot.py +++ b/climada/trajectories/snapshot.py @@ -26,6 +26,7 @@ import copy import datetime import logging +import warnings from climada.entity.exposures import Exposures from climada.entity.impact_funcs import ImpactFuncSet @@ -83,7 +84,15 @@ def __init__( measure: Measure | None, date: int | datetime.date | str, ref_only: bool = False, + _from_factory: bool = False, ) -> None: + if not _from_factory: + warnings.warn( + "Direct instantiation of 'Snapshot' is discouraged. " + "Use 'Snapshot.from_triplet()' instead.", + UserWarning, + stacklevel=2, + ) self._exposure = exposure if ref_only else copy.deepcopy(exposure) self._hazard = hazard if ref_only else copy.deepcopy(hazard) self._impfset = impfset if ref_only else copy.deepcopy(impfset) @@ -137,6 +146,7 @@ def from_triplet( measure=None, date=date, ref_only=ref_only, + _from_factory=True, ) @property @@ -191,7 +201,7 @@ def _convert_to_date(date_arg) -> datetime.date: raise TypeError("date_arg must be an int, str, or datetime.date") - def apply_measure(self, measure: Measure, ref_only: bool = False) -> "Snapshot": + def apply_measure(self, measure: Measure) -> "Snapshot": """Create a new snapshot by applying a Measure object. This method creates a new `Snapshot` object by applying a measure on @@ -216,6 +226,7 @@ def apply_measure(self, measure: Measure, ref_only: bool = False) -> "Snapshot": impfset=impfset, date=self.date, measure=measure, - ref_only=ref_only, + ref_only=False, + _from_factory=True, ) return snap From ffbf31eca1086d8a0320a30ec09b3f7e33666561 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 6 Jan 2026 11:31:13 +0100 Subject: [PATCH 52/61] Shifts tests to pytest format (and updates them) --- climada/trajectories/test/test_snapshot.py | 247 ++++++++++++--------- 1 file changed, 141 insertions(+), 106 deletions(-) diff --git a/climada/trajectories/test/test_snapshot.py b/climada/trajectories/test/test_snapshot.py index 4e3b465d8e..e3c2eb0e9c 100644 --- a/climada/trajectories/test/test_snapshot.py +++ b/climada/trajectories/test/test_snapshot.py @@ -1,9 +1,9 @@ import datetime -import unittest from unittest.mock import MagicMock import numpy as np import pandas as pd +import pytest from climada.entity.exposures import Exposures from climada.entity.impact_funcs import ImpactFunc, ImpactFuncSet @@ -12,121 +12,156 @@ from climada.trajectories.snapshot import Snapshot from climada.util.constants import EXP_DEMO_H5, HAZ_DEMO_H5 +# --- Fixtures --- + + +@pytest.fixture(scope="module") +def shared_data(): + """Load heavy HDF5 data once per module to speed up tests.""" + exposure = Exposures.from_hdf5(EXP_DEMO_H5) + hazard = Hazard.from_hdf5(HAZ_DEMO_H5) + impfset = ImpactFuncSet( + [ + ImpactFunc( + "TC", + 3, + intensity=np.array([0, 20]), + mdd=np.array([0, 0.5]), + paa=np.array([0, 1]), + ) + ] + ) + return exposure, hazard, impfset -class TestSnapshot(unittest.TestCase): - - def setUp(self): - # Create mock objects for testing - self.mock_exposure = Exposures.from_hdf5(EXP_DEMO_H5) - self.mock_hazard = Hazard.from_hdf5(HAZ_DEMO_H5) - self.mock_impfset = ImpactFuncSet( - [ - ImpactFunc( - "TC", - 3, - intensity=np.array([0, 20]), - mdd=np.array([0, 0.5]), - paa=np.array([0, 1]), - ) - ] - ) - self.mock_measure = MagicMock(spec=Measure) - self.mock_measure.name = "Test Measure" - - # Setup mock return values for measure.apply - self.mock_modified_exposure = MagicMock(spec=Exposures) - self.mock_modified_hazard = MagicMock(spec=Hazard) - self.mock_modified_impfset = MagicMock(spec=ImpactFuncSet) - self.mock_measure.apply.return_value = ( - self.mock_modified_exposure, - self.mock_modified_impfset, - self.mock_modified_hazard, - ) - def test_init_with_int_date(self): - snapshot = Snapshot( - exposure=self.mock_exposure, - hazard=self.mock_hazard, - impfset=self.mock_impfset, - date=2023, - ) - self.assertEqual(snapshot.date, datetime.date(2023, 1, 1)) - - def test_init_with_str_date(self): - snapshot = Snapshot( - exposure=self.mock_exposure, - hazard=self.mock_hazard, - impfset=self.mock_impfset, - date="2023-01-01", - ) - self.assertEqual(snapshot.date, datetime.date(2023, 1, 1)) - - def test_init_with_date_object(self): - date_obj = datetime.date(2023, 1, 1) - snapshot = Snapshot( - exposure=self.mock_exposure, - hazard=self.mock_hazard, - impfset=self.mock_impfset, - date=date_obj, - ) - self.assertEqual(snapshot.date, date_obj) - - def test_init_with_invalid_date(self): - with self.assertRaises(ValueError): - Snapshot( - exposure=self.mock_exposure, - hazard=self.mock_hazard, - impfset=self.mock_impfset, - date="invalid-date", - ) +@pytest.fixture +def mock_context(shared_data): + """Provides the exposure/hazard/impfset and a pre-configured mock measure.""" + exp, haz, impf = shared_data - def test_init_with_invalid_type(self): - with self.assertRaises(TypeError): - Snapshot( - exposure=self.mock_exposure, - hazard=self.mock_hazard, - impfset=self.mock_impfset, - date=2023.5, # type: ignore - ) + # Setup Mock Measure + mock_measure = MagicMock(spec=Measure) + mock_measure.name = "Test Measure" - def test_properties(self): - snapshot = Snapshot( - exposure=self.mock_exposure, - hazard=self.mock_hazard, - impfset=self.mock_impfset, - date=2023, - ) + modified_exp = MagicMock(spec=Exposures) + modified_haz = MagicMock(spec=Hazard) + modified_imp = MagicMock(spec=ImpactFuncSet) - # We want a new reference - self.assertIsNot(snapshot.exposure, self.mock_exposure) - self.assertIsNot(snapshot.hazard, self.mock_hazard) - self.assertIsNot(snapshot.impfset, self.mock_impfset) + mock_measure.apply.return_value = (modified_exp, modified_imp, modified_haz) - # But we want equality - pd.testing.assert_frame_equal(snapshot.exposure.gdf, self.mock_exposure.gdf) + return { + "exp": exp, + "haz": haz, + "imp": impf, + "measure": mock_measure, + "mod_exp": modified_exp, + "mod_haz": modified_haz, + "mod_imp": modified_imp, + } - self.assertEqual(snapshot.hazard.haz_type, self.mock_hazard.haz_type) - self.assertEqual(snapshot.hazard.intensity.nnz, self.mock_hazard.intensity.nnz) - self.assertEqual(snapshot.hazard.size, self.mock_hazard.size) - self.assertEqual(snapshot.impfset, self.mock_impfset) +# --- Tests --- - def test_apply_measure(self): - snapshot = Snapshot( - exposure=self.mock_exposure, - hazard=self.mock_hazard, - impfset=self.mock_impfset, - date=2023, + +def test_not_from_factory_warning(mock_context): + """Test that direct __init__ call raises a warning""" + with pytest.warns(UserWarning): + Snapshot( + exposure=mock_context["exp"], + hazard=mock_context["haz"], + impfset=mock_context["imp"], + measure=None, + date=2001, ) - new_snapshot = snapshot.apply_measure(self.mock_measure) - self.assertIsNotNone(new_snapshot.measure) - self.assertEqual(new_snapshot.measure.name, "Test Measure") # type: ignore - self.assertEqual(new_snapshot.exposure, self.mock_modified_exposure) - self.assertEqual(new_snapshot.hazard, self.mock_modified_hazard) - self.assertEqual(new_snapshot.impfset, self.mock_modified_impfset) + +@pytest.mark.parametrize( + "input_date,expected", + [ + (2023, datetime.date(2023, 1, 1)), + ("2023-01-01", datetime.date(2023, 1, 1)), + (datetime.date(2023, 1, 1), datetime.date(2023, 1, 1)), + ], +) +def test_init_valid_dates(mock_context, input_date, expected): + """Test various valid date input formats using parametrization.""" + snapshot = Snapshot.from_triplet( + exposure=mock_context["exp"], + hazard=mock_context["haz"], + impfset=mock_context["imp"], + date=input_date, + ) + assert snapshot.date == expected + + +def test_init_invalid_date_format(mock_context): + with pytest.raises(ValueError): + Snapshot.from_triplet( + exposure=mock_context["exp"], + hazard=mock_context["haz"], + impfset=mock_context["imp"], + date="invalid-date", + ) -if __name__ == "__main__": - TESTS = unittest.TestLoader().loadTestsFromTestCase(TestSnapshot) - unittest.TextTestRunner(verbosity=2).run(TESTS) +def test_init_invalid_date_type(mock_context): + with pytest.raises(TypeError): + Snapshot.from_triplet(exposure=mock_context["exp"], hazard=mock_context["haz"], impfset=mock_context["imp"], date=2023.5) # type: ignore + + +def test_properties(mock_context): + snapshot = Snapshot.from_triplet( + exposure=mock_context["exp"], + hazard=mock_context["haz"], + impfset=mock_context["imp"], + date=2023, + ) + + # Check that it's a deep copy (new reference) + assert snapshot.exposure is not mock_context["exp"] + assert snapshot.hazard is not mock_context["haz"] + + assert snapshot.measure is None + + # Check data equality + pd.testing.assert_frame_equal(snapshot.exposure.gdf, mock_context["exp"].gdf) + assert snapshot.hazard.haz_type == mock_context["haz"].haz_type + assert snapshot.impfset == mock_context["imp"] + + +def test_reference(mock_context): + snapshot = Snapshot.from_triplet( + exposure=mock_context["exp"], + hazard=mock_context["haz"], + impfset=mock_context["imp"], + date=2023, + ref_only=True, + ) + + # Check that it is a reference + assert snapshot.exposure is mock_context["exp"] + assert snapshot.hazard is mock_context["haz"] + assert snapshot.impfset is mock_context["imp"] + assert snapshot.measure is None + + # Check data equality + pd.testing.assert_frame_equal(snapshot.exposure.gdf, mock_context["exp"].gdf) + assert snapshot.hazard.haz_type == mock_context["haz"].haz_type + assert snapshot.impfset == mock_context["imp"] + + +def test_apply_measure(mock_context): + snapshot = Snapshot( + exposure=mock_context["exp"], + hazard=mock_context["haz"], + impfset=mock_context["imp"], + measure=None, + date=2023, + ) + new_snapshot = snapshot.apply_measure(mock_context["measure"]) + + assert new_snapshot.measure is not None + assert new_snapshot.measure.name == "Test Measure" + assert new_snapshot.exposure == mock_context["mod_exp"] + assert new_snapshot.hazard == mock_context["mod_haz"] + assert new_snapshot.impfset == mock_context["mod_imp"] From 59ba2918e7c7c8d5616cc19fc1c7901b5f583976 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 6 Jan 2026 12:00:10 +0100 Subject: [PATCH 53/61] updates tests --- climada/trajectories/test/test_snapshot.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/climada/trajectories/test/test_snapshot.py b/climada/trajectories/test/test_snapshot.py index e3c2eb0e9c..cecfa39395 100644 --- a/climada/trajectories/test/test_snapshot.py +++ b/climada/trajectories/test/test_snapshot.py @@ -95,7 +95,7 @@ def test_init_valid_dates(mock_context, input_date, expected): def test_init_invalid_date_format(mock_context): - with pytest.raises(ValueError): + with pytest.raises(ValueError, match="String must be in the format"): Snapshot.from_triplet( exposure=mock_context["exp"], hazard=mock_context["haz"], @@ -105,7 +105,9 @@ def test_init_invalid_date_format(mock_context): def test_init_invalid_date_type(mock_context): - with pytest.raises(TypeError): + with pytest.raises( + TypeError, match=r"date_arg must be an int, str, or datetime.date" + ): Snapshot.from_triplet(exposure=mock_context["exp"], hazard=mock_context["haz"], impfset=mock_context["imp"], date=2023.5) # type: ignore @@ -151,11 +153,10 @@ def test_reference(mock_context): def test_apply_measure(mock_context): - snapshot = Snapshot( + snapshot = Snapshot.from_triplet( exposure=mock_context["exp"], hazard=mock_context["haz"], impfset=mock_context["imp"], - measure=None, date=2023, ) new_snapshot = snapshot.apply_measure(mock_context["measure"]) From 77b76c44b5f8fb39ed925e5df3ba3a5b222df472 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 6 Jan 2026 12:00:21 +0100 Subject: [PATCH 54/61] apply_measure already makes copies --- climada/trajectories/snapshot.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/climada/trajectories/snapshot.py b/climada/trajectories/snapshot.py index 233cc15696..cf93171e0e 100644 --- a/climada/trajectories/snapshot.py +++ b/climada/trajectories/snapshot.py @@ -226,7 +226,7 @@ def apply_measure(self, measure: Measure) -> "Snapshot": impfset=impfset, date=self.date, measure=measure, - ref_only=False, + ref_only=True, # Avoid unecessary copies of new objects _from_factory=True, ) return snap From 71d23d9182641dc7fc2ad7277f06e1ad16c120a8 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Wed, 7 Jan 2026 16:52:55 +0100 Subject: [PATCH 55/61] fix --- climada/trajectories/snapshot.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/climada/trajectories/snapshot.py b/climada/trajectories/snapshot.py index 8d9a74ef6f..05d948793f 100644 --- a/climada/trajectories/snapshot.py +++ b/climada/trajectories/snapshot.py @@ -87,7 +87,7 @@ def __init__( self._exposure = exposure if ref_only else copy.deepcopy(exposure) self._hazard = hazard if ref_only else copy.deepcopy(hazard) self._impfset = impfset if ref_only else copy.deepcopy(impfset) - self._measure = measure if ref_only else copy.deepcopy(impfset) + self._measure = measure if ref_only else copy.deepcopy(measure) self._date = self._convert_to_date(date) @classmethod From fc3825e4eab3f33f3866bc2a97253cef8a72e188 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Wed, 7 Jan 2026 16:53:13 +0100 Subject: [PATCH 56/61] naming, type hint --- climada/util/dataframe_handling.py | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/climada/util/dataframe_handling.py b/climada/util/dataframe_handling.py index b5ac6bef97..6a5c37a95a 100644 --- a/climada/util/dataframe_handling.py +++ b/climada/util/dataframe_handling.py @@ -23,8 +23,8 @@ def reorder_dataframe_columns( - df: pd.DataFrame, priority_order: list[str], keep_remaining: bool = True -) -> pd.DataFrame | pd.Series: + dataframe: pd.DataFrame, priority_order: list[str], keep_remaining: bool = True +) -> pd.DataFrame: """ Applies a column priority list to a DataFrame to reorder its columns. @@ -34,7 +34,7 @@ def reorder_dataframe_columns( Parameters ---------- - df: pd.DataFrame + dataframe: pd.DataFrame The input DataFrame. priority_order: list[str] A list of strings defining the desired column @@ -49,15 +49,17 @@ def reorder_dataframe_columns( pd.DataFrame: The DataFrame with columns reordered according to the priority list. """ - present_priority_columns = [col for col in priority_order if col in df.columns] + present_priority_columns = [ + col for col in priority_order if col in dataframe.columns + ] new_column_order = present_priority_columns if keep_remaining: remaining_columns = [ - col for col in df.columns if col not in present_priority_columns + col for col in dataframe.columns if col not in present_priority_columns ] new_column_order.extend(remaining_columns) - return df[new_column_order] + return dataframe[new_column_order] From 8053554499a1bfab9e20d7032868bc745ea0c012 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Wed, 7 Jan 2026 16:53:35 +0100 Subject: [PATCH 57/61] better type hint --- climada/trajectories/interpolated_trajectory.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/climada/trajectories/interpolated_trajectory.py b/climada/trajectories/interpolated_trajectory.py index 22c73cfa01..b5d40560b2 100644 --- a/climada/trajectories/interpolated_trajectory.py +++ b/climada/trajectories/interpolated_trajectory.py @@ -501,7 +501,7 @@ def risk_contributions_metrics(self, **kwargs) -> pd.DataFrame: **kwargs, ) - def _risk_contributions_post_treatment(self, df) -> pd.DataFrame: + def _risk_contributions_post_treatment(self, df: pd.DataFrame) -> pd.DataFrame: """Post treat the risk contributions metrics. When more than two snapshots are provided, the total risk of the previous pair @@ -555,7 +555,7 @@ def _risk_contributions_post_treatment(self, df) -> pd.DataFrame: def per_date_risk_metrics( self, - metrics: list[str] | None = None, + metrics: Iterable[str] | None = None, ) -> pd.DataFrame: """Returns a DataFrame of risk metrics for each dates From fa3ae248299ae183add6d5bf2fc8c8daae34e539 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Wed, 7 Jan 2026 16:53:52 +0100 Subject: [PATCH 58/61] fix lsp complaints about type hints --- climada/trajectories/calc_risk_metrics.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/climada/trajectories/calc_risk_metrics.py b/climada/trajectories/calc_risk_metrics.py index ed618bf62e..39dac9c347 100644 --- a/climada/trajectories/calc_risk_metrics.py +++ b/climada/trajectories/calc_risk_metrics.py @@ -310,7 +310,7 @@ def calc_aai_per_group_metric(self) -> pd.DataFrame | None: ].copy() aai_per_group_df = eai_pres_groups.groupby( [DATE_COL_NAME, GROUP_COL_NAME], as_index=False, observed=True - )[RISK_COL_NAME].sum() + ).agg({RISK_COL_NAME: "sum"}) aai_per_group_df[METRIC_COL_NAME] = AAI_METRIC_NAME aai_per_group_df[MEASURE_COL_NAME] = ( self.measure.name if self.measure else NO_MEASURE_VALUE @@ -922,7 +922,7 @@ def calc_aai_per_group_metric(self) -> pd.DataFrame | None: ].copy() aai_per_group_df = eai_pres_groups.groupby( [DEFAULT_PERIOD_INDEX_NAME, GROUP_COL_NAME], as_index=False, observed=True - )[RISK_COL_NAME].sum() + ).agg({RISK_COL_NAME: "sum"}) if not np.array_equal(self._group_id_E0, self._group_id_E1): LOGGER.warning( "Group id are changing between present and future snapshot." @@ -935,10 +935,10 @@ def calc_aai_per_group_metric(self) -> pd.DataFrame | None: ) aai_fut_groups = eai_fut_groups.groupby( [DEFAULT_PERIOD_INDEX_NAME, GROUP_COL_NAME], as_index=False - )[RISK_COL_NAME].sum() + ).agg({RISK_COL_NAME: "sum"}) aai_per_group_df[RISK_COL_NAME] = linear_interp_arrays( - aai_per_group_df[RISK_COL_NAME].values, - aai_fut_groups[RISK_COL_NAME].values, + aai_per_group_df[RISK_COL_NAME].to_numpy(), + aai_fut_groups[RISK_COL_NAME].to_numpy(), ) aai_per_group_df[METRIC_COL_NAME] = AAI_METRIC_NAME From 4f7c3367ebe55ba4a63b1137c4077fe6a6a2273a Mon Sep 17 00:00:00 2001 From: spjuhel Date: Wed, 7 Jan 2026 17:22:59 +0100 Subject: [PATCH 59/61] Removed unused attribute --- climada/trajectories/interpolated_trajectory.py | 1 - 1 file changed, 1 deletion(-) diff --git a/climada/trajectories/interpolated_trajectory.py b/climada/trajectories/interpolated_trajectory.py index b5d40560b2..bdd27405b1 100644 --- a/climada/trajectories/interpolated_trajectory.py +++ b/climada/trajectories/interpolated_trajectory.py @@ -168,7 +168,6 @@ def __init__( all_groups_name=DEFAULT_ALLGROUP_NAME, risk_disc_rates=risk_disc_rates, ) - self._risk_metrics_up_to_date: bool = False self.start_date = min((snapshot.date for snapshot in snapshots_list)) self.end_date = max((snapshot.date for snapshot in snapshots_list)) self._risk_metrics_calculators = self._reset_risk_metrics_calculators( From 26ac5889b7a61cae7663c6418eec58fa1f6a1386 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 8 Jan 2026 10:25:28 +0100 Subject: [PATCH 60/61] Fix name in docstring --- climada/trajectories/interpolated_trajectory.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/climada/trajectories/interpolated_trajectory.py b/climada/trajectories/interpolated_trajectory.py index bdd27405b1..006dff8af6 100644 --- a/climada/trajectories/interpolated_trajectory.py +++ b/climada/trajectories/interpolated_trajectory.py @@ -135,7 +135,7 @@ def __init__( interpolation_strategy: InterpolationStrategyBase | None = None, impact_computation_strategy: ImpactComputationStrategy | None = None, ): - """Initialize a new `StaticRiskTrajectory`. + """Initialize a new `InterpolatedRiskTrajectory`. Parameters ---------- From b04a5e3abf42744ed793acb7a45c205d2a0aed4b Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 8 Jan 2026 10:32:16 +0100 Subject: [PATCH 61/61] Removes low level thingy from high level interface (and docs) --- climada/trajectories/interpolated_trajectory.py | 4 ---- climada/trajectories/trajectory.py | 3 +-- 2 files changed, 1 insertion(+), 6 deletions(-) diff --git a/climada/trajectories/interpolated_trajectory.py b/climada/trajectories/interpolated_trajectory.py index 006dff8af6..86ca490479 100644 --- a/climada/trajectories/interpolated_trajectory.py +++ b/climada/trajectories/interpolated_trajectory.py @@ -149,9 +149,6 @@ def __init__( It must be a valid pandas string used to define periods, e.g., "Y" for years, "M" for months, "3M" for trimester, etc. Defaults to `DEFAULT_TIME_RESOLUTION` ("Y"). - all_groups_name: str, optional - The string to use to define all exposure points subgroup. - Defaults to `DEFAULT_ALLGROUP_NAME` ("All"). risk_disc_rates: DiscRates, optional The discount rate to apply to future risk. Defaults to None. interpolation_strategy: InterpolationStrategyBase, optional @@ -165,7 +162,6 @@ def __init__( super().__init__( snapshots_list, return_periods=return_periods, - all_groups_name=DEFAULT_ALLGROUP_NAME, risk_disc_rates=risk_disc_rates, ) self.start_date = min((snapshot.date for snapshot in snapshots_list)) diff --git a/climada/trajectories/trajectory.py b/climada/trajectories/trajectory.py index 75c30b9aa1..b48b11a339 100644 --- a/climada/trajectories/trajectory.py +++ b/climada/trajectories/trajectory.py @@ -76,12 +76,11 @@ def __init__( snapshots_list: Iterable[Snapshot], *, return_periods: Iterable[int] = DEFAULT_RP, - all_groups_name: str = DEFAULT_ALLGROUP_NAME, risk_disc_rates: DiscRates | None = None, ): self._reset_metrics() self._snapshots = sorted(snapshots_list, key=lambda snap: snap.date) - self._all_groups_name = all_groups_name + self._all_groups_name = DEFAULT_ALLGROUP_NAME self._return_periods = return_periods self.start_date = min((snapshot.date for snapshot in snapshots_list)) self.end_date = max((snapshot.date for snapshot in snapshots_list))