From 4010812fd494c00ec5818c70b27839eee1bd703a Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 7 Apr 2026 09:34:52 +0200 Subject: [PATCH 01/44] Adds cost income --- climada/entity/measures/cost_income.py | 415 +++++++++++++++++++++++++ 1 file changed, 415 insertions(+) create mode 100644 climada/entity/measures/cost_income.py diff --git a/climada/entity/measures/cost_income.py b/climada/entity/measures/cost_income.py new file mode 100644 index 0000000000..564bbd251f --- /dev/null +++ b/climada/entity/measures/cost_income.py @@ -0,0 +1,415 @@ +""" +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 the Cash Flows class. +""" + +# Define default discount rates +# DISC_RATES = DiscRates(years=np.arange(1900, 2100), rates=np.ones(np.arange(1900, 2100).size)) + +from datetime import datetime +from typing import Any, List, Optional, Tuple + +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd + +from climada.entity.measures.measure_config import CostIncomeConfig + + +class CostIncome: + """ + Manages costs and incomes related to a measure over time. + + Income are stored a positive numbers and costs as negative + ones. + + Attributes + ---------- + freq : str + Frequency of the cash flows (e.g., 'Y', 'M', 'D'). + mkt_price_year : datetime + The reference year for market prices. + cost_growth_rate : float + Yearly growth rate of costs. + init_cost : float + Initial implementation cost (stored as negative). + periodic_cost : float + Recurring cost per period (stored as negative). + periodic_income : float + Recurring income per period. + income_growth_rate : float + Yearly growth rate of income. + custom_cash_flows : pd.DataFrame, optional + User-defined cash flows indexed by date. + """ + + def __init__( + self, + *, + mkt_price_year: Optional[int] = None, + init_cost: float = 0.0, + periodic_cost: float = 0.0, + periodic_income: float = 0.0, + cost_yearly_growth_rate: float = 0.0, + income_yearly_growth_rate: float = 0.0, + custom_cash_flows: Optional[pd.DataFrame] = None, + freq: str = "Y", + ): + """Initialize CostIncome with parameters.""" + self.freq = freq + self.mkt_price_year = datetime(mkt_price_year or datetime.today().year, 1, 1) + self.cost_growth_rate = cost_yearly_growth_rate + + self.init_cost = -abs(init_cost) + self.periodic_cost = -abs(periodic_cost) + self.periodic_income = abs(periodic_income) + + self.income_growth_rate = income_yearly_growth_rate + + if custom_cash_flows is not None: + self.custom_cash_flows = self._prepare_custom_flows(custom_cash_flows) + else: + self.custom_cash_flows = None + + def _prepare_custom_flows(self, df: pd.DataFrame) -> pd.DataFrame: + """Process and resample custom cash flow dataframe.""" + df = df.copy() + if "cost" in df.columns: + df["cost"] = -df["cost"].abs() + if "date" in df.columns: + df["date"] = pd.to_datetime(df["date"]) + df = df.set_index("date") + return df.resample(self.freq).sum() + + @classmethod + def from_config(cls, config: CostIncomeConfig) -> "CostIncome": + df = None + if config.custom_cash_flows is not None: + df = pd.DataFrame(config.custom_cash_flows) + df["date"] = pd.to_datetime(df["date"]) + return cls( + mkt_price_year=config.mkt_price_year, + init_cost=config.init_cost, + periodic_cost=config.periodic_cost, + periodic_income=config.periodic_income, + cost_yearly_growth_rate=config.cost_yearly_growth_rate, + income_yearly_growth_rate=config.income_yearly_growth_rate, + custom_cash_flows=df, + freq=config.freq, + ) + + @classmethod + def from_dict(cls, d: dict) -> "CostIncome": + return cls.from_config( + CostIncomeConfig( + mkt_price_year=d.get("mkt_price_year"), + init_cost=d.get("init_cost", 0.0), + periodic_cost=d.get("periodic_cost", 0.0), + periodic_income=d.get("periodic_income", 0.0), + cost_yearly_growth_rate=d.get("cost_yearly_growth_rate", 0.0), + income_yearly_growth_rate=d.get("income_yearly_growth_rate", 0.0), + freq=d.get("freq", "Y"), + custom_cash_flows=d.get("custom_cash_flows"), + ) + ) + + @classmethod + def from_yaml(cls, path: str) -> "CostIncome": + import yaml + + with open(path) as f: + return cls.from_dict(yaml.safe_load(f)["cost_income"]) + + @staticmethod + def _freq_to_days(freq: str) -> str: + """ + Convert a frequency string to the equivalent number of days. + + Parameters: + ----------- + freq : str + A frequency string (e.g., 'D' for daily, 'M' for monthly, 'Y' for yearly). + + Returns: + -------- + float + The equivalent number of days for the given frequency string. + """ + try: + # Convert the frequency string to a DateOffset object + offset = pd.tseries.frequencies.to_offset(freq) + + # Calculate the number of days by applying the offset to a base date + base_date = pd.Timestamp("2000-01-01") + end_date = base_date + offset + + # Return the difference in days + return f"{(end_date - base_date).days}d" + except ValueError: + raise ValueError(f"Invalid frequency string: {freq}") + + def _get_width_days(self) -> float: + """Return the number of days in the current frequency.""" + ref = pd.Timestamp("2000-01-01") + offset = pd.tseries.frequencies.to_offset(self.freq) + return float(((ref + offset) - ref).days) + + def _get_custom_val(self, date, column: str) -> float: + if self.custom_cash_flows is not None: + return self.custom_cash_flows.loc[date, column] + + raise AttributeError("No custom cash flow is defined.") + + def _calc_at_date( + self, impl_date: pd.Timestamp, curr_date: pd.Timestamp + ) -> Tuple[float, float, float]: + """Calculate cash flows for a single timestamp.""" + # Calculate growth factor based on years from market price reference + years_passed = (curr_date - self.mkt_price_year).days / 365.0 + + cost_factor = (1 + self.cost_growth_rate) ** years_passed + inc_factor = (1 + self.income_growth_rate) ** years_passed + + if curr_date < impl_date: + cost, income = 0.0, 0.0 + elif curr_date == impl_date: + cost = self.init_cost * cost_factor + income = self.periodic_income * inc_factor + else: + cost = self.periodic_cost * cost_factor + income = self.periodic_income * inc_factor + + c_cost = self._get_custom_val(curr_date, "cost") + c_inc = self._get_custom_val(curr_date, "income") + + total_cost = cost + c_cost + total_inc = income + c_inc + return (total_inc + total_cost), total_cost, total_inc + + def calc_cash_flows( + self, impl_date: Any, start_date: Any, end_date: Any, disc: Optional[Any] = None + ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: + """ + Calculate net cash flows, costs, and incomes over a period. + + Parameters + ---------- + impl_date : Any + Date the measure is implemented. + start_date : Any + Start of the calculation period. + end_date : Any + End of the calculation period. + disc : DiscRates, optional + Discount rates object to calculate Net Present Value. + + Returns + ------- + Tuple[np.ndarray, np.ndarray, np.ndarray] + (net, costs, incomes) + """ + impl_ts = pd.Timestamp(impl_date) + periods = pd.period_range(start=start_date, end=end_date, freq=self.freq) + + results = [self._calc_at_date(impl_ts, p.start_time) for p in periods] + net, costs, incs = map(np.array, zip(*results)) + + if disc is not None: + # Vectorized discounting + years = np.array([p.year for p in periods]) + # Note: Assumes disc.rates is indexed/aligned with disc.years + rate_map = dict(zip(disc.years, disc.rates)) + factors = np.array( + [ + 1 + / (1 + rate_map.get(yr, 0.0)) + ** (yr - pd.Timestamp(start_date).year) + for yr in years + ] + ) + # Handle potential length mismatch if years aren't in disc + valid = np.array([yr in rate_map for yr in years]) + return ( + net[valid] * factors[valid], + costs[valid] * factors[valid], + incs[valid] * factors[valid], + ) + + return net, costs, incs + + def calc_total( + self, impl_date: Any, start_date: Any, end_date: Any, disc: Optional[Any] = None + ) -> Tuple[float, float, float]: + """ + Calculate the total or net present value of the cash flows over a given period + + Parameters: + ----------- + impl_year: int + the year the measure is implemented + + start_year: int + the start year of the period + + end_year: int + the end year of the period + + disc: DiscRates object + the discount rates (required if discounted is True) + + Returns: + -------- + Tuple[float, float, float] + the total net, cost, and income present values over the given period + """ + + net_cash_flows, costs, incomes = self.calc_cash_flows( + impl_date, start_date, end_date, disc=disc + ) + return np.sum(net_cash_flows), np.sum(costs), np.sum(incomes) + + def plot_cash_flows( + self, + impl_date: Any, + start_date: Any, + end_date: Any, + disc: Optional[Any] = None, + to_plot: List[str] = ["net", "cost", "income"], + ): + """ + Plot the cash flows over a given period. + + Parameters: + ----------- + impl_date: datetime + The date the measure is implemented. + start_date: datetime + The start date of the period. + end_date: datetime + The end date of the period. + disc: DiscRates object + The discount rates (optional). + to_plot: list + List of strings indicating which cash flows to plot. Options are 'net', 'cost', 'income'. + """ + # Calculate the cash flows over the given period + net_cash_flows, costs, incomes = self.calc_cash_flows( + impl_date, start_date, end_date, disc=disc + ) + + # Plot the cash flows with colors + date_range = pd.date_range( + start=start_date, end=end_date, freq=self._freq_to_days(self.freq) + ) + width = self._get_width_days() * 0.8 # 80% width for visibility + fig, ax = plt.subplots() + + if "cost" in to_plot: + ax.bar(date_range, costs, color="red", label="Cost", width=width) + if "income" in to_plot: + ax.bar( + date_range, + incomes, + color="blue", + label="Income", + alpha=0.7, + width=width, + ) + if "net" in to_plot: + ax.bar( + date_range, + net_cash_flows, + color="blue", + edgecolor="red", + hatch="//", + label="Net", + alpha=0.5, + width=width, + ) + + ax.xaxis_date() # <---- treat x-ticks as datetime + fig.autofmt_xdate() + plt.xlabel("Date") + plt.ylabel("Cash Flow") + plt.title("Discounted Cash Flows" if disc else "Cash Flows") + plt.legend() + plt.show() + return ax + + def to_dataframe( + self, impl_date: Any, start_date: Any, end_date: Any, disc: Optional[Any] = None + ) -> pd.DataFrame: + """Return cash flows as a formatted DataFrame.""" + net, costs, incs = self.calc_cash_flows( + impl_date, start_date, end_date, disc=disc + ) + periods = pd.period_range(start=start_date, end=end_date, freq=self.freq) + + return pd.DataFrame( + {"date": periods, "net": net, "cost": costs, "income": incs} + ) + + @staticmethod + def comb_cost_income(cost_incomes: list["CostIncome"]) -> "CostIncome": + """Sum costs and incomes from all measures.""" + first_ci = cost_incomes[0] + + if not all( + [ + first_ci.mkt_price_year.year == c.mkt_price_year.year + for c in cost_incomes + ] + ): + raise ValueError( + "Measure cost incomes have different market price years, combination is not possible." + ) + + if not all( + [first_ci.cost_growth_rate == c.cost_growth_rate for c in cost_incomes] + ): + raise ValueError( + "Measure cost incomes have different cost_growth_rate, combination is not possible." + ) + + if not all( + [first_ci.income_growth_rate == c.income_growth_rate for c in cost_incomes] + ): + raise ValueError( + "Measure cost incomes have different income_growth_rate, combination is not possible." + ) + + return CostIncome( + mkt_price_year=first_ci.mkt_price_year.year, + cost_yearly_growth_rate=first_ci.cost_growth_rate, + init_cost=sum(c.init_cost for c in cost_incomes), + periodic_cost=sum(c.periodic_cost for c in cost_incomes), + periodic_income=sum(c.periodic_income for c in cost_incomes), + income_yearly_growth_rate=first_ci.income_growth_rate, + ) + + @staticmethod + def from_kwargs(kwargs) -> "CostIncome": + """Extracts financial keys from the excel row data.""" + return CostIncome( + init_cost=kwargs.get("init_cost", 0.0), + periodic_cost=kwargs.get("periodic_cost", 0.0), + periodic_income=kwargs.get("periodic_income", 0.0), + income_yearly_growth_rate=kwargs.get("income_yearly_growth_rate", 0.0), + cost_yearly_growth_rate=kwargs.get("cost_yearly_growth_rate", 0.0), + ) From 2580d0795141301d87bc68383e40223565800b3b Mon Sep 17 00:00:00 2001 From: spjuhel Date: Wed, 8 Apr 2026 09:56:14 +0200 Subject: [PATCH 02/44] Adds main file --- climada/entity/measures/base.py | 427 ++++++++++++++++++++++++++++++++ 1 file changed, 427 insertions(+) create mode 100755 climada/entity/measures/base.py diff --git a/climada/entity/measures/base.py b/climada/entity/measures/base.py new file mode 100755 index 0000000000..bdcf5ed5fe --- /dev/null +++ b/climada/entity/measures/base.py @@ -0,0 +1,427 @@ +""" +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 Measure class. +""" + +from __future__ import annotations + +from pandas.tseries.offsets import BaseOffset + +__all__ = ["Measure"] + +import copy +import inspect +import logging +from functools import wraps +from typing import TYPE_CHECKING, Any, Optional, Tuple, TypeVar + +import pandas as pd + +from climada.entity.measures.measure_config import MeasureConfig + +from .cost_income import CostIncome + +if TYPE_CHECKING: + from climada.entity.exposures.base import Exposures + from climada.entity.impact_funcs.impact_func_set import ImpactFuncSet + from climada.entity.measures.types import ( + ExposuresChange, + HazardChange, + ImpfsetChange, + ) + from climada.hazard.base import Hazard + + T = TypeVar("T", Exposures, ImpactFuncSet, Hazard) + +LOGGER = logging.getLogger(__name__) + +# TODO: risk transfer? + +T = TypeVar("T", Exposures, ImpactFuncSet, Hazard) + + +# This function will moved in helper.py in a future PR which will +# add IO based on MeasureConfig dataclasses +def identity_function(x: T, **_kwargs: Any) -> T: + return x + + +def allow_kwargs(func): + @wraps(func) + def wrapper(*args, **kwargs): + # Get the names of arguments the original function accepts + params = inspect.signature(func).parameters + + # Filter kwargs to only include what the function can handle + # (Unless the function already has **kwargs in its signature) + if any(p.kind == p.VAR_KEYWORD for p in params.values()): + return func(*args, **kwargs) + + filtered_kwargs = {k: v for k, v in kwargs.items() if k in params} + return func(*args, **filtered_kwargs) + + return wrapper + + +class Measure: + """ + Contains a measure to be applied to a set of exposures, impact functions, and hazard. + + Attributes + ---------- + name : str + Name of the measure. + exposures_change : callable + Function to change exposures. + impfset_change : callable + Function to change impact function set. + hazard_change : callable + Function to change hazard. + sub_measures : list of str, optional + List of measure names that this measure is a combination of. + cost_income : climada.entity.measures.cost_income.CostIncome + Cost and income object associated with the measure. + implementation_duration : pd.DateOffset, optional + Duration of implementation before the measure is fully functional. + """ + + def __init__( + self, + name: str, + *, + exposures_changes: ExposuresChange = identity_function, + impfset_changes: ImpfsetChange = identity_function, + hazard_changes: HazardChange = identity_function, + sub_measures: Optional[list[str]] = None, + cost_income: Optional[CostIncome] = None, + implementation_duration: Optional[BaseOffset] = None, + color_rgb: Optional[Tuple[float, float, float]] = None, + _config: Optional[MeasureConfig] = None, + ): + """ + Initialize a new Measure object. + + Parameters + ---------- + name : str + Name of the measure. + exposures_change : callable, optional + Transformation function for Exposures. Defaults to identity. + impfset_change : callable, optional + Transformation function for ImpactFuncSet. Defaults to identity. + hazard_change : callable, optional + Transformation function for Hazard. Defaults to identity. + sub_measures : list of str, optional + Names of component measures. + cost_income : CostIncome, optional + Financial data. If None, an empty CostIncome is initialized. + implementation_duration : pd.DateOffset, optional + Time offset for full implementation. + """ + + self.name = name + self.exposures_changes = allow_kwargs(exposures_changes) + self.hazard_changes = allow_kwargs(hazard_changes) + self.impfset_changes = allow_kwargs(impfset_changes) + self.sub_measures = sub_measures + self.cost_income = cost_income if cost_income is not None else CostIncome() + self.implementation_duration = implementation_duration + self.color_rgb = (0, 0, 0) if color_rgb is None else color_rgb + self._config = _config + + # DONE always provide exp, impfset and hazard as kwargs by default + # Have a precedence system (if users provide their own it takes over) + # TODO Check that it works + + @property + def is_serializable(self) -> bool: + return self._config is not None + + def apply_exposures_changes( + self, exposures: Exposures, enforce_copy: bool = True, **kwargs + ) -> Exposures: + """Apply the changes from the measure to the given exposures object. + + This method applies the `exposures_changes` function of the measure to + the provided `exposures` object. If `enforce_copy` is True (default), a + deep copy of the exposures is created before modification to ensure + immutability of the original object. + + Parameters + ---------- + exposures : Exposures + The input exposures object to be transformed. + enforce_copy : bool, optional + If True (default), creates a deep copy of `exposures` before applying + changes, provided the transformation function is not the identity function. + If False, the original object may be modified in-place depending on the + behavior of `exposures_changes`. + **kwargs : dict, optional + Additional keyword arguments passed directly to the `exposures_changes` + function. + + Returns + ------- + Exposures + The resulting exposures object after the transformation has been applied. + If `enforce_copy` was True, this is a new object. + + Notes + ----- + The deep copy operation is skipped if `enforce_copy` is False or if + `self.exposures_changes` is the identity function, optimizing performance + when no actual changes are expected or when in-place modification is desired. + """ + + changed_exp = ( + copy.deepcopy(exposures) + if enforce_copy and self.exposures_changes is not identity_function + else exposures + ) + try: + return self.exposures_changes(changed_exp, **kwargs) + except TypeError as exc: + # Check if it's a missing argument error + if "missing" in str(exc) and "required positional argument" in str(exc): + raise TypeError( + f"The function to apply to the exposures requires additional arguments\ + that were not provided.\n" + f"Please check the function signature or the helper used and provide the\ + required arguments " + "via kwargs_exposures.\n" + f"Original error: {exc}" + ) from exc + raise + + def apply_impfset_changes( + self, impfset: ImpactFuncSet, enforce_copy: bool = True, **kwargs + ) -> ImpactFuncSet: + """Apply the changes from the measure to the given impfset object. + + This method applies the `impfset_changes` function of the measure to + the provided `impfset` object. If `enforce_copy` is True (default), a + deep copy of the impfset is created before modification to ensure + immutability of the original object. + + Parameters + ---------- + impfset : ImpactFuncSet + The input impfset object to be transformed. + enforce_copy : bool, optional + If True (default), creates a deep copy of `impfset` before applying + changes, provided the transformation function is not the identity function. + If False, the original object may be modified in-place depending on the + behavior of `impfset_changes`. + **kwargs : dict, optional + Additional keyword arguments passed directly to the `impfset_changes` + function. + + Returns + ------- + ImpactFuncSet + The resulting impfset object after the transformation has been applied. + If `enforce_copy` was True, this is a new object. + + Notes + ----- + The deep copy operation is skipped if `enforce_copy` is False or if + `self.impfset_changes` is the identity function, optimizing performance + when no actual changes are expected or when in-place modification is desired. + """ + + changed_impfset = ( + copy.deepcopy(impfset) + if enforce_copy and self.impfset_changes is not identity_function + else impfset + ) + try: + return self.impfset_changes(changed_impfset, **kwargs) + except TypeError as exc: + # Check if it's a missing argument error + if "missing" in str(exc) and "required positional argument" in str(exc): + raise TypeError( + f"The function to apply to the impact function set requires\ + additional arguments that were not provided.\n" + f"Please check the function signature or the helper used\ + and provide the required arguments via kwargs_impfset.\n" + f"Original error: {exc}" + ) from exc + raise + + def apply_hazard_changes( + self, hazard: Hazard, enforce_copy: bool = True, **kwargs + ) -> Hazard: + """Apply the changes from the measure to the given hazard object. + + This method applies the `hazard_changes` function of the measure to + the provided `hazard` object. If `enforce_copy` is True (default), a + deep copy of the hazard is created before modification to ensure + immutability of the original object. + + Parameters + ---------- + hazard : Hazard + The input hazard object to be transformed. + enforce_copy : bool, optional + If True (default), creates a deep copy of `hazard` before applying + changes, provided the transformation function is not the identity function. + If False, the original object may be modified in-place depending on the + behavior of `hazard_changes`. + **kwargs : dict, optional + Additional keyword arguments passed directly to the `hazard_changes` + function. + + Returns + ------- + Hazard + The resulting hazard object after the transformation has been applied. + If `enforce_copy` was True, this is a new object. + + Notes + ----- + The deep copy operation is skipped if `enforce_copy` is False or if + `self.hazard_changes` is the identity function, optimizing performance + when no actual changes are expected or when in-place modification is desired. + """ + changed_hazard = ( + copy.deepcopy(hazard) + if enforce_copy and self.hazard_changes is not identity_function + else hazard + ) + try: + return self.hazard_changes(changed_hazard, **kwargs) + except TypeError as exc: + # Check if it's a missing argument error + if "missing" in str(exc) and "required positional argument" in str(exc): + raise TypeError( + f"The function to apply to the hazard requires\ + additional arguments that were not provided.\n" + f"Please check the function signature or the helper used\ + and provide the required arguments via kwargs_hazard.\n" + f"Original error: {exc}" + ) from exc + raise + + def apply( + self, + exposures: Exposures, + impfset: ImpactFuncSet, + hazard: Hazard, + enforce_copy: bool = True, + **kwargs, + ) -> Tuple[Exposures, ImpactFuncSet, Hazard]: + """Apply all measure transformations to the provided entity triplet. + + This method applies the measure changes across all three + risk parts: exposures, impact function set, and hazard data. + + The method implements a flexible keyword arguments merging strategy + where the original (exposures, impact function set, hazard) triplet is + provided as default context to each transformation, which can then be + overridden by entity-specific kwargs dictionaries. This enables + transformation requiring the information from other parts (for + instance, removing events based on impact threshold) + + Parameters + ---------- + exposures : Exposures + The input exposures object to be transformed. + impfset : ImpactFuncSet + The impact function set to be transformed. + hazard : Hazard + The hazard data to be transformed. + enforce_copy : bool, optional + If True (default), creates deep copies of entities before applying + changes, provided the transformation functions are not identity functions. + If False, entities may be modified in-place depending on the behavior + of the underlying transformation methods. + **kwargs : dict, optional + Additional keyword arguments for configuring transformations. Supports + nested dictionaries for entity-specific customization: + + * ``kwargs_exposures``: Dict of kwargs passed to `apply_exposures_changes` + * ``kwargs_impfset``: Dict of kwargs passed to `apply_impfset_changes` + * ``kwargs_hazard``: Dict of kwargs passed to `apply_hazard_changes` + + Each nested dict is merged with the default triplet context (exposures, + impfset, hazard), allowing transformations to access related entities + while permitting entity-specific overrides. + + Returns + ------- + Tuple[Exposures, ImpactFuncSet, Hazard] + A tuple containing the transformed entities in the order: + (changed_exposures, changed_impfset, changed_hazard). If `enforce_copy` + was True, these are new objects; otherwise, they may reference the + original inputs or modified versions thereof. + + Notes + ----- + The kwargs merging follows this priority order: + + 1. Default context: The original triplet (exposures, impfset, hazard) + 2. Entity-specific overrides: Values from ``kwargs_exposures``, + ``kwargs_impfset``, or ``kwargs_hazard`` respectively + + This ensures that each transformation receives full context about all entities + while allowing fine-grained control over individual transformations. + + The transformation order is: exposures → hazard → impact function set. + Each transformation is independent, so changes to one entity do not affect + the others during processing. + """ + + default_kwargs = { + "base_exposures": exposures, + "base_impfset": impfset, + "base_hazard": hazard, + } + # Always provide the triplet by default, and overwrite by custom kwargs. + kwargs_exp = default_kwargs | kwargs.get("kwargs_exposures", {}) + kwargs_impfset = default_kwargs | kwargs.get("kwargs_impfset", {}) + kwargs_hazard = default_kwargs | kwargs.get("kwargs_hazard", {}) + changed_exposures = self.apply_exposures_changes( + exposures, enforce_copy, **kwargs_exp + ) + changed_hazard = self.apply_hazard_changes( + hazard, enforce_copy, **kwargs_hazard + ) + changed_impfset = self.apply_impfset_changes( + impfset, enforce_copy, **kwargs_impfset + ) + return changed_exposures, changed_impfset, changed_hazard + + def calc_impact(self, exposures, impfset, hazard): + from climada.engine.impact_calc import ( + ImpactCalc, # pylint: disable=import-outside-toplevel + ) + + new_exp, new_impfs, new_haz = self.apply(exposures, impfset, hazard) + if new_haz.centr_exp_col not in new_exp.gdf.columns: + LOGGER.warning( + "No assigned hazard centroids in exposure object after the " + "application of the measure. The centroids will be assigned during impact " + "calculation. This is potentiall costly. To silence this warning, make sure " + "that centroids are assigned to all exposures." + ) + new_exp.assign_centroids(new_haz) + imp = ImpactCalc(new_exp, new_impfs, new_haz).impact( + save_mat=False, assign_centroids=False + ) + return imp.calc_risk_transfer(0, 0) From ff6733eb1ad166d55d55157cc3d347b1e44339f1 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 9 Apr 2026 10:30:36 +0200 Subject: [PATCH 03/44] Docstringyfies and cleans up a bit --- climada/entity/measures/cost_income.py | 282 ++++++++++++++++++------- 1 file changed, 209 insertions(+), 73 deletions(-) diff --git a/climada/entity/measures/cost_income.py b/climada/entity/measures/cost_income.py index 564bbd251f..bda1d6ac2a 100644 --- a/climada/entity/measures/cost_income.py +++ b/climada/entity/measures/cost_income.py @@ -16,19 +16,17 @@ --- -Define the Cash Flows class. +Define the CostIncome class to handle the cash flow of measures. """ -# Define default discount rates -# DISC_RATES = DiscRates(years=np.arange(1900, 2100), rates=np.ones(np.arange(1900, 2100).size)) - from datetime import datetime -from typing import Any, List, Optional, Tuple +from typing import Any, List, Optional, Tuple, cast import matplotlib.pyplot as plt import numpy as np import pandas as pd +from climada.entity.disc_rates.base import DiscRates from climada.entity.measures.measure_config import CostIncomeConfig @@ -41,22 +39,22 @@ class CostIncome: Attributes ---------- - freq : str - Frequency of the cash flows (e.g., 'Y', 'M', 'D'). - mkt_price_year : datetime + mkt_price_year : datetime, default to today's year. The reference year for market prices. - cost_growth_rate : float - Yearly growth rate of costs. init_cost : float Initial implementation cost (stored as negative). periodic_cost : float Recurring cost per period (stored as negative). periodic_income : float Recurring income per period. - income_growth_rate : float + cost_yearly_growth_rate : float + Yearly growth rate of costs. + income_yearly_growth_rate : float Yearly growth rate of income. custom_cash_flows : pd.DataFrame, optional User-defined cash flows indexed by date. + freq : str + Frequency of the cash flows (e.g., 'Y', '3M', '7D'). """ def __init__( @@ -71,7 +69,28 @@ def __init__( custom_cash_flows: Optional[pd.DataFrame] = None, freq: str = "Y", ): - """Initialize CostIncome with parameters.""" + """Initialize CostIncome with parameters. + + Parameters + ---------- + mkt_price_year : datetime, default to today's year. + The reference year for market prices. + init_cost : float + Initial implementation cost (stored as negative). + periodic_cost : float + Recurring cost per period (stored as negative). + periodic_income : float + Recurring income per period. + cost_yearly_growth_rate : float + Yearly growth rate of costs. + income_yearly_growth_rate : float + Yearly growth rate of income. + custom_cash_flows : pd.DataFrame, optional + User-defined cash flows indexed by date. + freq : str + Frequency of the cash flows (e.g., 'Y', '3M', '7D'). + """ + self.freq = freq self.mkt_price_year = datetime(mkt_price_year or datetime.today().year, 1, 1) self.cost_growth_rate = cost_yearly_growth_rate @@ -88,7 +107,21 @@ def __init__( self.custom_cash_flows = None def _prepare_custom_flows(self, df: pd.DataFrame) -> pd.DataFrame: - """Process and resample custom cash flow dataframe.""" + """Process and resample custom cash flow dataframe + + Enforce costs as negative numbers and date to the correct frequency. + + Parameters + ---------- + df : pd.DataFrame + Custom cashflow + + Returns + ------- + pd.DataFrame + Processed custom cashflow + """ + df = df.copy() if "cost" in df.columns: df["cost"] = -df["cost"].abs() @@ -99,6 +132,17 @@ def _prepare_custom_flows(self, df: pd.DataFrame) -> pd.DataFrame: @classmethod def from_config(cls, config: CostIncomeConfig) -> "CostIncome": + """Create a `CostIncome` from a `CostIncomeConfig`. + + Parameters + ---------- + config : CostIncomeConfig + + Returns + ------- + CostIncome + """ + df = None if config.custom_cash_flows is not None: df = pd.DataFrame(config.custom_cash_flows) @@ -115,22 +159,47 @@ def from_config(cls, config: CostIncomeConfig) -> "CostIncome": ) @classmethod - def from_dict(cls, d: dict) -> "CostIncome": + def from_dict(cls, args_dict: dict) -> "CostIncome": + """Create a `CostIncome` from a dictionary. + + Parameters + ---------- + args_dict : dict + + Returns + ------- + CostIncome + """ + return cls.from_config( CostIncomeConfig( - mkt_price_year=d.get("mkt_price_year"), - init_cost=d.get("init_cost", 0.0), - periodic_cost=d.get("periodic_cost", 0.0), - periodic_income=d.get("periodic_income", 0.0), - cost_yearly_growth_rate=d.get("cost_yearly_growth_rate", 0.0), - income_yearly_growth_rate=d.get("income_yearly_growth_rate", 0.0), - freq=d.get("freq", "Y"), - custom_cash_flows=d.get("custom_cash_flows"), + mkt_price_year=args_dict.get("mkt_price_year"), + init_cost=args_dict.get("init_cost", 0.0), + periodic_cost=args_dict.get("periodic_cost", 0.0), + periodic_income=args_dict.get("periodic_income", 0.0), + cost_yearly_growth_rate=args_dict.get("cost_yearly_growth_rate", 0.0), + income_yearly_growth_rate=args_dict.get( + "income_yearly_growth_rate", 0.0 + ), + freq=args_dict.get("freq", "Y"), + custom_cash_flows=args_dict.get("custom_cash_flows"), ) ) @classmethod def from_yaml(cls, path: str) -> "CostIncome": + """Create a `CostIncome` from a yaml file. + + Parameters + ---------- + path : str + Path to the yaml file. + + Returns + ------- + CostIncome + """ + import yaml with open(path) as f: @@ -151,6 +220,7 @@ def _freq_to_days(freq: str) -> str: float The equivalent number of days for the given frequency string. """ + try: # Convert the frequency string to a DateOffset object offset = pd.tseries.frequencies.to_offset(freq) @@ -166,20 +236,71 @@ def _freq_to_days(freq: str) -> str: def _get_width_days(self) -> float: """Return the number of days in the current frequency.""" + ref = pd.Timestamp("2000-01-01") offset = pd.tseries.frequencies.to_offset(self.freq) return float(((ref + offset) - ref).days) - def _get_custom_val(self, date, column: str) -> float: - if self.custom_cash_flows is not None: - return self.custom_cash_flows.loc[date, column] - - raise AttributeError("No custom cash flow is defined.") - def _calc_at_date( self, impl_date: pd.Timestamp, curr_date: pd.Timestamp ) -> Tuple[float, float, float]: - """Calculate cash flows for a single timestamp.""" + r"""Calculate cash flows for a single timestamp. + + Computes the total cash flow, total cost, and total income for a given + evaluation date, accounting for growth rates applied to base costs and + incomes, as well as any custom cash flow overrides. + + The calculation applies compound growth to both costs and incomes based + on the number of years elapsed since the market price reference date + (`self.mkt_price_year`). Different base amounts are used depending on + whether the current date is before, at, or after the implementation date. + + Parameters + ---------- + impl_date : pd.Timestamp + The implementation date that determines which cost/income regime + applies. Dates before this use zero base amounts; at or after this + date use the initialized or periodic amounts respectively. + curr_date : pd.Timestamp + The evaluation date for which cash flows are being calculated. This + is compared against `impl_date` to determine the applicable base + amounts and is also used to index into `custom_cash_flows` if present. + + Returns + ------- + Tuple[float, float, float] + A tuple containing: + + * total_cash_flow : float + Net cash flow for the period, calculated as `total_income + total_cost`. + Note: Costs are typically negative values in financial contexts, + so this represents the net position. + * total_cost : float + Total cost amount for the period, including both standard and + custom cost components. + * total_income : float + Total income amount for the period, including both standard and + custom income components. + + Notes + ----- + Growth calculations use compound interest formula: + + .. math:: + factor = (1 + rate)^{years\_passed} + + where `years_passed` is computed as `(curr_date - mkt_price_year).days / 365.0`. + + Cost and income regimes: + + - **Before impl_date**: Both base cost and income are zero + - **At impl_date**: Uses `init_cost` for cost and `periodic_income` for income + - **After impl_date**: Uses `periodic_cost` for cost and `periodic_income` for income + + Custom cash flows (if `self.custom_cash_flows` is not None) are added + on top of the calculated standard amounts. Missing dates in the custom + cash flow DataFrame will raise a KeyError. + """ # Calculate growth factor based on years from market price reference years_passed = (curr_date - self.mkt_price_year).days / 365.0 @@ -195,46 +316,69 @@ def _calc_at_date( cost = self.periodic_cost * cost_factor income = self.periodic_income * inc_factor - c_cost = self._get_custom_val(curr_date, "cost") - c_inc = self._get_custom_val(curr_date, "income") + if self.custom_cash_flows is not None: + c_cost = cast(float, self.custom_cash_flows.loc[curr_date, "cost"]) + c_inc = cast(float, self.custom_cash_flows.loc[curr_date, "income"]) + else: + c_cost, c_inc = 0.0, 0.0 total_cost = cost + c_cost total_inc = income + c_inc return (total_inc + total_cost), total_cost, total_inc def calc_cash_flows( - self, impl_date: Any, start_date: Any, end_date: Any, disc: Optional[Any] = None + self, impl_date, start_date, end_date, disc_rates: Optional[DiscRates] = None ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: - """ - Calculate net cash flows, costs, and incomes over a period. + """Calculate net cash flows, costs, and incomes over a period. + + Computes cash flow metrics across a specified date range by iterating + through each period. Optionally + applies discounting to calculate Net Present Value (NPV) when discount + rates are provided. + + The method creates a period range based on the configured frequency + (`self.freq`) and evaluates cash flows at the start time of each period. + Results are returned as NumPy arrays for efficient downstream processing. Parameters ---------- - impl_date : Any - Date the measure is implemented. - start_date : Any - Start of the calculation period. - end_date : Any - End of the calculation period. - disc : DiscRates, optional - Discount rates object to calculate Net Present Value. + impl_date : + The implementation date that determines which cost/income regime + applies. + start_date : + The beginning of the calculation period. + end_date : + The end of the calculation period. + disc_rates : DiscRates, optional + An object containing discount rate information for NPV calculations. Returns ------- Tuple[np.ndarray, np.ndarray, np.ndarray] - (net, costs, incomes) + A tuple containing three NumPy arrays of equal length: + + * net : np.ndarray + Net cash flow for each period (income + cost). May be discounted + if `disc_rates` is provided. + * costs : np.ndarray + Total costs for each period. May be discounted if `disc_rates` + is provided. + * incomes : np.ndarray + Total incomes for each period. May be discounted if `disc_rates` + is provided. """ + impl_ts = pd.Timestamp(impl_date) periods = pd.period_range(start=start_date, end=end_date, freq=self.freq) results = [self._calc_at_date(impl_ts, p.start_time) for p in periods] net, costs, incs = map(np.array, zip(*results)) - if disc is not None: + if disc_rates is not None: # Vectorized discounting years = np.array([p.year for p in periods]) # Note: Assumes disc.rates is indexed/aligned with disc.years - rate_map = dict(zip(disc.years, disc.rates)) + rate_map = dict(zip(disc_rates.years, disc_rates.rates)) factors = np.array( [ 1 @@ -254,24 +398,21 @@ def calc_cash_flows( return net, costs, incs def calc_total( - self, impl_date: Any, start_date: Any, end_date: Any, disc: Optional[Any] = None + self, impl_date, start_date, end_date, disc: Optional[DiscRates] = None ) -> Tuple[float, float, float]: """ - Calculate the total or net present value of the cash flows over a given period + Calculate the total or net present value of the cash flows over a given period. Parameters: ----------- - impl_year: int - the year the measure is implemented - - start_year: int - the start year of the period - + impl_date: + The date the measure is implemented. + start_year: + The start date of the period. end_year: int - the end year of the period - - disc: DiscRates object - the discount rates (required if discounted is True) + The end year of the period. + disc: DiscRates, optional + The discount rates to apply. Returns: -------- @@ -280,7 +421,7 @@ def calc_total( """ net_cash_flows, costs, incomes = self.calc_cash_flows( - impl_date, start_date, end_date, disc=disc + impl_date, start_date, end_date, disc_rates=disc ) return np.sum(net_cash_flows), np.sum(costs), np.sum(incomes) @@ -308,9 +449,10 @@ def plot_cash_flows( to_plot: list List of strings indicating which cash flows to plot. Options are 'net', 'cost', 'income'. """ + # Calculate the cash flows over the given period net_cash_flows, costs, incomes = self.calc_cash_flows( - impl_date, start_date, end_date, disc=disc + impl_date, start_date, end_date, disc_rates=disc ) # Plot the cash flows with colors @@ -353,11 +495,11 @@ def plot_cash_flows( return ax def to_dataframe( - self, impl_date: Any, start_date: Any, end_date: Any, disc: Optional[Any] = None + self, impl_date, start_date, end_date, disc_rates: Optional[DiscRates] = None ) -> pd.DataFrame: """Return cash flows as a formatted DataFrame.""" net, costs, incs = self.calc_cash_flows( - impl_date, start_date, end_date, disc=disc + impl_date, start_date, end_date, disc_rates=disc_rates ) periods = pd.period_range(start=start_date, end=end_date, freq=self.freq) @@ -367,7 +509,12 @@ def to_dataframe( @staticmethod def comb_cost_income(cost_incomes: list["CostIncome"]) -> "CostIncome": - """Sum costs and incomes from all measures.""" + """Combine multiple CostIncomes together. + + Combination sums the costs and incomes from all provided CostIncome + objects. + """ + first_ci = cost_incomes[0] if not all( @@ -402,14 +549,3 @@ def comb_cost_income(cost_incomes: list["CostIncome"]) -> "CostIncome": periodic_income=sum(c.periodic_income for c in cost_incomes), income_yearly_growth_rate=first_ci.income_growth_rate, ) - - @staticmethod - def from_kwargs(kwargs) -> "CostIncome": - """Extracts financial keys from the excel row data.""" - return CostIncome( - init_cost=kwargs.get("init_cost", 0.0), - periodic_cost=kwargs.get("periodic_cost", 0.0), - periodic_income=kwargs.get("periodic_income", 0.0), - income_yearly_growth_rate=kwargs.get("income_yearly_growth_rate", 0.0), - cost_yearly_growth_rate=kwargs.get("cost_yearly_growth_rate", 0.0), - ) From 66a3f70a38ed11e58558ed115361a4c1e2ee9720 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 9 Apr 2026 12:01:55 +0200 Subject: [PATCH 04/44] Fix resampling issues, few docstring adjustments --- climada/entity/measures/cost_income.py | 25 ++++++++++++++++++------- 1 file changed, 18 insertions(+), 7 deletions(-) diff --git a/climada/entity/measures/cost_income.py b/climada/entity/measures/cost_income.py index bda1d6ac2a..305047f007 100644 --- a/climada/entity/measures/cost_income.py +++ b/climada/entity/measures/cost_income.py @@ -55,6 +55,7 @@ class CostIncome: User-defined cash flows indexed by date. freq : str Frequency of the cash flows (e.g., 'Y', '3M', '7D'). + """ def __init__( @@ -128,7 +129,17 @@ def _prepare_custom_flows(self, df: pd.DataFrame) -> pd.DataFrame: if "date" in df.columns: df["date"] = pd.to_datetime(df["date"]) df = df.set_index("date") - return df.resample(self.freq).sum() + match self.freq: + case "Y": + resampling_freq = "YS" + case "M": + resampling_freq = "MS" + case "Q": + resampling_freq = "QS" + case _: + resampling_freq = self.freq + + return df.resample(resampling_freq).sum() @classmethod def from_config(cls, config: CostIncomeConfig) -> "CostIncome": @@ -248,19 +259,19 @@ def _calc_at_date( Computes the total cash flow, total cost, and total income for a given evaluation date, accounting for growth rates applied to base costs and - incomes, as well as any custom cash flow overrides. + incomes, as well as the custom cash flow if provided. The calculation applies compound growth to both costs and incomes based on the number of years elapsed since the market price reference date - (`self.mkt_price_year`). Different base amounts are used depending on - whether the current date is before, at, or after the implementation date. + (`self.mkt_price_year`). Parameters ---------- impl_date : pd.Timestamp The implementation date that determines which cost/income regime - applies. Dates before this use zero base amounts; at or after this - date use the initialized or periodic amounts respectively. + applies. Dates before this use have no cost or income; "at the date" uses + the implementation cost, and dates after use the initialized or + periodic amounts respectively. curr_date : pd.Timestamp The evaluation date for which cash flows are being calculated. This is compared against `impl_date` to determine the applicable base @@ -294,7 +305,7 @@ def _calc_at_date( Cost and income regimes: - **Before impl_date**: Both base cost and income are zero - - **At impl_date**: Uses `init_cost` for cost and `periodic_income` for income + - **At impl_date**: Uses `init_cost` for cost - **After impl_date**: Uses `periodic_cost` for cost and `periodic_income` for income Custom cash flows (if `self.custom_cash_flows` is not None) are added From 1a1c97dc1c5f08a2c07b27e31157adcb9cea0992 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 9 Apr 2026 12:02:44 +0200 Subject: [PATCH 05/44] Removes periodic income from implementation period for consistency --- climada/entity/measures/cost_income.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/climada/entity/measures/cost_income.py b/climada/entity/measures/cost_income.py index 305047f007..df0641358e 100644 --- a/climada/entity/measures/cost_income.py +++ b/climada/entity/measures/cost_income.py @@ -322,7 +322,7 @@ def _calc_at_date( cost, income = 0.0, 0.0 elif curr_date == impl_date: cost = self.init_cost * cost_factor - income = self.periodic_income * inc_factor + income = 0.0 else: cost = self.periodic_cost * cost_factor income = self.periodic_income * inc_factor From 5822a697bee394624b299d4c1cacc760072f17d0 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 9 Apr 2026 12:03:07 +0200 Subject: [PATCH 06/44] Removes discount rate logic (to be handled in StaticAppraiser) --- climada/entity/measures/cost_income.py | 66 +++++--------------------- 1 file changed, 13 insertions(+), 53 deletions(-) diff --git a/climada/entity/measures/cost_income.py b/climada/entity/measures/cost_income.py index df0641358e..60c9c8f8eb 100644 --- a/climada/entity/measures/cost_income.py +++ b/climada/entity/measures/cost_income.py @@ -338,14 +338,12 @@ def _calc_at_date( return (total_inc + total_cost), total_cost, total_inc def calc_cash_flows( - self, impl_date, start_date, end_date, disc_rates: Optional[DiscRates] = None + self, impl_date, start_date, end_date ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: """Calculate net cash flows, costs, and incomes over a period. Computes cash flow metrics across a specified date range by iterating - through each period. Optionally - applies discounting to calculate Net Present Value (NPV) when discount - rates are provided. + through each period. The method creates a period range based on the configured frequency (`self.freq`) and evaluates cash flows at the start time of each period. @@ -360,8 +358,6 @@ def calc_cash_flows( The beginning of the calculation period. end_date : The end of the calculation period. - disc_rates : DiscRates, optional - An object containing discount rate information for NPV calculations. Returns ------- @@ -369,14 +365,11 @@ def calc_cash_flows( A tuple containing three NumPy arrays of equal length: * net : np.ndarray - Net cash flow for each period (income + cost). May be discounted - if `disc_rates` is provided. + Net cash flow for each period (income + cost). * costs : np.ndarray - Total costs for each period. May be discounted if `disc_rates` - is provided. + Total costs for each period. * incomes : np.ndarray - Total incomes for each period. May be discounted if `disc_rates` - is provided. + Total incomes for each period. """ impl_ts = pd.Timestamp(impl_date) @@ -384,35 +377,11 @@ def calc_cash_flows( results = [self._calc_at_date(impl_ts, p.start_time) for p in periods] net, costs, incs = map(np.array, zip(*results)) - - if disc_rates is not None: - # Vectorized discounting - years = np.array([p.year for p in periods]) - # Note: Assumes disc.rates is indexed/aligned with disc.years - rate_map = dict(zip(disc_rates.years, disc_rates.rates)) - factors = np.array( - [ - 1 - / (1 + rate_map.get(yr, 0.0)) - ** (yr - pd.Timestamp(start_date).year) - for yr in years - ] - ) - # Handle potential length mismatch if years aren't in disc - valid = np.array([yr in rate_map for yr in years]) - return ( - net[valid] * factors[valid], - costs[valid] * factors[valid], - incs[valid] * factors[valid], - ) - return net, costs, incs - def calc_total( - self, impl_date, start_date, end_date, disc: Optional[DiscRates] = None - ) -> Tuple[float, float, float]: + def calc_total(self, impl_date, start_date, end_date) -> Tuple[float, float, float]: """ - Calculate the total or net present value of the cash flows over a given period. + Calculate the total value of the cash flows over a given period. Parameters: ----------- @@ -422,17 +391,15 @@ def calc_total( The start date of the period. end_year: int The end year of the period. - disc: DiscRates, optional - The discount rates to apply. Returns: -------- Tuple[float, float, float] - the total net, cost, and income present values over the given period + the total net, cost, and income values over the given period. """ net_cash_flows, costs, incomes = self.calc_cash_flows( - impl_date, start_date, end_date, disc_rates=disc + impl_date, start_date, end_date ) return np.sum(net_cash_flows), np.sum(costs), np.sum(incomes) @@ -441,7 +408,6 @@ def plot_cash_flows( impl_date: Any, start_date: Any, end_date: Any, - disc: Optional[Any] = None, to_plot: List[str] = ["net", "cost", "income"], ): """ @@ -455,15 +421,13 @@ def plot_cash_flows( The start date of the period. end_date: datetime The end date of the period. - disc: DiscRates object - The discount rates (optional). to_plot: list List of strings indicating which cash flows to plot. Options are 'net', 'cost', 'income'. """ # Calculate the cash flows over the given period net_cash_flows, costs, incomes = self.calc_cash_flows( - impl_date, start_date, end_date, disc_rates=disc + impl_date, start_date, end_date ) # Plot the cash flows with colors @@ -500,18 +464,14 @@ def plot_cash_flows( fig.autofmt_xdate() plt.xlabel("Date") plt.ylabel("Cash Flow") - plt.title("Discounted Cash Flows" if disc else "Cash Flows") + plt.title("Cash Flows") plt.legend() plt.show() return ax - def to_dataframe( - self, impl_date, start_date, end_date, disc_rates: Optional[DiscRates] = None - ) -> pd.DataFrame: + def to_dataframe(self, impl_date, start_date, end_date) -> pd.DataFrame: """Return cash flows as a formatted DataFrame.""" - net, costs, incs = self.calc_cash_flows( - impl_date, start_date, end_date, disc_rates=disc_rates - ) + net, costs, incs = self.calc_cash_flows(impl_date, start_date, end_date) periods = pd.period_range(start=start_date, end=end_date, freq=self.freq) return pd.DataFrame( From 971a77255722f51e0b624f2a019f2e33eafe7147 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 9 Apr 2026 12:07:12 +0200 Subject: [PATCH 07/44] Adds unit tests --- .../entity/measures/test/test_cost_income.py | 397 ++++++++++++++++++ 1 file changed, 397 insertions(+) create mode 100644 climada/entity/measures/test/test_cost_income.py diff --git a/climada/entity/measures/test/test_cost_income.py b/climada/entity/measures/test/test_cost_income.py new file mode 100644 index 0000000000..bf546b9b91 --- /dev/null +++ b/climada/entity/measures/test/test_cost_income.py @@ -0,0 +1,397 @@ +""" +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 the CostIncome class. +""" + +from datetime import datetime +from unittest.mock import MagicMock, patch + +import numpy as np +import pandas as pd +import pytest + +from climada.entity.disc_rates.base import DiscRates +from climada.entity.measures.cost_income import CostIncome + +# --------------------------------------------------------------------------- +# Helpers +# --------------------------------------------------------------------------- + + +def make_disc_rates(years=None, rates=None): + """Build a minimal DiscRates stub.""" + dr = MagicMock(spec=DiscRates) + dr.years = np.array(years or list(range(2020, 2031))) + dr.rates = np.array(rates or [0.05] * len(dr.years)) + return dr + + +# --------------------------------------------------------------------------- +# __init__ / construction +# --------------------------------------------------------------------------- + + +class TestInit: + def test_defaults(self): + ci = CostIncome() + assert ci.init_cost == 0.0 + assert ci.periodic_cost == 0.0 + assert ci.periodic_income == 0.0 + assert ci.cost_growth_rate == 0.0 + assert ci.income_growth_rate == 0.0 + assert ci.freq == "Y" + assert ci.custom_cash_flows is None + + def test_costs_stored_negative(self): + ci = CostIncome(init_cost=100, periodic_cost=50) + assert ci.init_cost == -100.0 + assert ci.periodic_cost == -50.0 + + def test_costs_already_negative_stay_negative(self): + ci = CostIncome(init_cost=-200, periodic_cost=-30) + assert ci.init_cost == -200.0 + assert ci.periodic_cost == -30.0 + + def test_income_stored_positive(self): + ci = CostIncome(periodic_income=-80) + assert ci.periodic_income == 80.0 + + def test_mkt_price_year_default_is_current_year(self): + ci = CostIncome() + assert ci.mkt_price_year.year == datetime.today().year + + def test_mkt_price_year_custom(self): + ci = CostIncome(mkt_price_year=2015) + assert ci.mkt_price_year.year == 2015 + + def test_custom_cash_flows_processed(self): + df = pd.DataFrame( + { + "date": ["2020-01-01", "2020-06-01"], + "cost": [100, 200], + "income": [50, 60], + } + ) + ci = CostIncome(custom_cash_flows=df, freq="Y") + # After resampling to yearly, should have one row per year + assert isinstance(ci.custom_cash_flows, pd.DataFrame) + assert "cost" in ci.custom_cash_flows.columns + # Costs should be negative after processing + assert (ci.custom_cash_flows["cost"] <= 0).all() + + +# --------------------------------------------------------------------------- +# from_dict / from_config / from_yaml +# --------------------------------------------------------------------------- + + +class TestFromDict: + def test_basic(self): + d = { + "mkt_price_year": 2020, + "init_cost": 500, + "periodic_cost": 100, + "periodic_income": 200, + "cost_yearly_growth_rate": 0.02, + "income_yearly_growth_rate": 0.03, + "freq": "Y", + } + ci = CostIncome.from_dict(d) + assert ci.init_cost == -500.0 + assert ci.periodic_income == 200.0 + assert ci.cost_growth_rate == 0.02 + + def test_defaults_for_missing_keys(self): + ci = CostIncome.from_dict({}) + assert ci.init_cost == 0.0 + assert ci.freq == "Y" + + def test_with_custom_cash_flows(self): + d = { + "freq": "Y", + "custom_cash_flows": [ + {"date": "2021-01-01", "cost": 100, "income": 50}, + ], + } + ci = CostIncome.from_dict(d) + assert ci.custom_cash_flows is not None + + +class TestFromYaml: + def test_from_yaml(self, tmp_path): + yaml_content = """ +cost_income: + mkt_price_year: 2020 + init_cost: 1000 + periodic_cost: 200 + periodic_income: 300 + cost_yearly_growth_rate: 0.01 + income_yearly_growth_rate: 0.02 + freq: Y +""" + p = tmp_path / "ci.yaml" + p.write_text(yaml_content) + ci = CostIncome.from_yaml(str(p)) + assert ci.init_cost == -1000.0 + assert ci.periodic_income == 300.0 + + +# --------------------------------------------------------------------------- +# _freq_to_days +# --------------------------------------------------------------------------- + + +class TestFreqToDays: + def test_yearly(self): + result = CostIncome._freq_to_days("Y") + assert result == "365d" + + def test_monthly(self): + result = CostIncome._freq_to_days("M") + assert result == "30d" + + def test_daily(self): + result = CostIncome._freq_to_days("D") + assert result == "1d" + + def test_invalid(self): + with pytest.raises(ValueError): + CostIncome._freq_to_days("INVALID_FREQ_XYZ") + + +# --------------------------------------------------------------------------- +# _get_width_days +# --------------------------------------------------------------------------- + + +class TestGetWidthDays: + def test_yearly(self): + ci = CostIncome(freq="Y") + assert ci._get_width_days() == 365.0 + + def test_daily(self): + ci = CostIncome(freq="D") + assert ci._get_width_days() == 1.0 + + +# --------------------------------------------------------------------------- +# _calc_at_date +# --------------------------------------------------------------------------- + + +class TestCalcAtDate: + def test_before_impl_date_is_zero(self): + ci = CostIncome(mkt_price_year=2020, init_cost=1000, periodic_income=500) + impl = pd.Timestamp("2021-01-01") + curr = pd.Timestamp("2020-01-01") + net, cost, inc = ci._calc_at_date(impl, curr) + assert net == 0.0 + assert cost == 0.0 + assert inc == 0.0 + + def test_at_impl_date_uses_init_cost(self): + ci = CostIncome(mkt_price_year=2021, init_cost=1000, periodic_income=0) + impl = pd.Timestamp("2021-01-01") + net, cost, inc = ci._calc_at_date(impl, impl) + assert cost == pytest.approx(-1000.0, rel=1e-3) + assert inc == pytest.approx(0.0) + + def test_after_impl_date_uses_periodic_cost(self): + ci = CostIncome(mkt_price_year=2020, periodic_cost=200, periodic_income=0) + impl = pd.Timestamp("2021-01-01") + curr = pd.Timestamp("2022-01-01") + net, cost, inc = ci._calc_at_date(impl, curr) + assert cost < 0 + assert abs(cost) == 200 + + def test_income_growth_applied(self): + ci = CostIncome( + mkt_price_year=2020, periodic_income=100, income_yearly_growth_rate=0.10 + ) + impl = pd.Timestamp("2020-01-01") + curr = pd.Timestamp("2021-01-01") + _, _, inc = ci._calc_at_date(impl, curr) + expected = 100 * (1.10**1.0) + assert inc == pytest.approx(expected, rel=1e-2) + + def test_net_equals_income_plus_cost(self): + ci = CostIncome(mkt_price_year=2020, periodic_cost=100, periodic_income=150) + impl = pd.Timestamp("2020-01-01") + curr = pd.Timestamp("2021-01-01") + net, cost, inc = ci._calc_at_date(impl, curr) + assert net == pytest.approx(cost + inc) + + def test_custom_cash_flows_added(self): + df = pd.DataFrame( + { + "date": ["2021-01-01"], + "cost": [500.0], + "income": [200.0], + } + ) + ci = CostIncome(mkt_price_year=2021, custom_cash_flows=df, freq="Y") + print(ci.custom_cash_flows) + impl = pd.Timestamp("2021-01-01") + curr = pd.Timestamp("2021-01-01") + net, cost, inc = ci._calc_at_date(impl, curr) + assert inc == pytest.approx(200.0, rel=1e-3) + assert cost == pytest.approx(-500.0, rel=1e-3) + + +# --------------------------------------------------------------------------- +# calc_cash_flows +# --------------------------------------------------------------------------- + + +class TestCalcCashFlows: + def test_returns_three_arrays(self): + ci = CostIncome(mkt_price_year=2020, periodic_income=100) + net, costs, incs = ci.calc_cash_flows("2020-01-01", "2020-01-01", "2025-01-01") + assert isinstance(net, np.ndarray) + assert isinstance(costs, np.ndarray) + assert isinstance(incs, np.ndarray) + + def test_length_matches_periods(self): + ci = CostIncome(freq="Y") + net, costs, incs = ci.calc_cash_flows("2020-01-01", "2020-01-01", "2024-01-01") + periods = pd.period_range("2020-01-01", "2024-01-01", freq="Y") + assert len(net) == len(periods) + + def test_zero_cost_income(self): + ci = CostIncome() + net, costs, incs = ci.calc_cash_flows("2020-01-01", "2020-01-01", "2023-01-01") + np.testing.assert_array_equal(net, 0.0) + + def test_nonzero_cost_income(self): + ci = CostIncome( + mkt_price_year=2020, init_cost=5000, periodic_cost=200, periodic_income=1000 + ) + net, cost, income = ci.calc_cash_flows( + impl_date="2020-01-01", start_date="2019-01-01", end_date="2025-01-01" + ) + np.testing.assert_array_equal( + net, [0.0, -5000.0, 800.0, 800.0, 800.0, 800.0, 800.0] + ) + np.testing.assert_array_equal( + cost, [0.0, -5000.0, -200.0, -200.0, -200.0, -200.0, -200.0] + ) + np.testing.assert_array_equal( + income, [0.0, 0.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0] + ) + + +# --------------------------------------------------------------------------- +# calc_total +# --------------------------------------------------------------------------- + + +class TestCalcTotal: + def test_total_is_sum_of_cash_flows(self): + ci = CostIncome(mkt_price_year=2020, periodic_income=100, periodic_cost=50) + net_arr, cost_arr, inc_arr = ci.calc_cash_flows( + "2020-01-01", "2020-01-01", "2024-01-01" + ) + total_net, total_cost, total_inc = ci.calc_total( + "2020-01-01", "2020-01-01", "2024-01-01" + ) + assert total_net == pytest.approx(float(np.sum(net_arr))) + assert total_cost == pytest.approx(float(np.sum(cost_arr))) + assert total_inc == pytest.approx(float(np.sum(inc_arr))) + + def test_returns_floats(self): + ci = CostIncome() + result = ci.calc_total("2020-01-01", "2020-01-01", "2022-01-01") + assert all(isinstance(v, (float, np.floating)) for v in result) + + +# --------------------------------------------------------------------------- +# to_dataframe +# --------------------------------------------------------------------------- + + +class TestToDataframe: + def test_columns(self): + ci = CostIncome(periodic_income=100) + df = ci.to_dataframe("2020-01-01", "2020-01-01", "2023-01-01") + assert set(df.columns) == {"date", "net", "cost", "income"} + + def test_row_count(self): + ci = CostIncome(freq="Y") + df = ci.to_dataframe("2020-01-01", "2020-01-01", "2022-01-01") + expected = len(pd.period_range("2020-01-01", "2022-01-01", freq="Y")) + assert len(df) == expected + + +# --------------------------------------------------------------------------- +# comb_cost_income +# --------------------------------------------------------------------------- + + +class TestCombCostIncome: + def test_costs_are_summed(self): + ci1 = CostIncome(mkt_price_year=2020, init_cost=100, periodic_cost=50) + ci2 = CostIncome(mkt_price_year=2020, init_cost=200, periodic_cost=30) + combined = CostIncome.comb_cost_income([ci1, ci2]) + assert combined.init_cost == -300.0 + assert combined.periodic_cost == -80.0 + + def test_incomes_are_summed(self): + ci1 = CostIncome(mkt_price_year=2020, periodic_income=100) + ci2 = CostIncome(mkt_price_year=2020, periodic_income=200) + combined = CostIncome.comb_cost_income([ci1, ci2]) + assert combined.periodic_income == 300.0 + + def test_mismatched_mkt_price_year_raises(self): + ci1 = CostIncome(mkt_price_year=2020) + ci2 = CostIncome(mkt_price_year=2021) + with pytest.raises(ValueError, match="market price years"): + CostIncome.comb_cost_income([ci1, ci2]) + + def test_mismatched_cost_growth_rate_raises(self): + ci1 = CostIncome(mkt_price_year=2020, cost_yearly_growth_rate=0.02) + ci2 = CostIncome(mkt_price_year=2020, cost_yearly_growth_rate=0.05) + with pytest.raises(ValueError, match="cost_growth_rate"): + CostIncome.comb_cost_income([ci1, ci2]) + + def test_mismatched_income_growth_rate_raises(self): + ci1 = CostIncome(mkt_price_year=2020, income_yearly_growth_rate=0.01) + ci2 = CostIncome(mkt_price_year=2020, income_yearly_growth_rate=0.03) + with pytest.raises(ValueError, match="income_growth_rate"): + CostIncome.comb_cost_income([ci1, ci2]) + + def test_single_element_list(self): + ci = CostIncome(mkt_price_year=2020, init_cost=500, periodic_income=100) + combined = CostIncome.comb_cost_income([ci]) + assert combined.init_cost == -500.0 + assert combined.periodic_income == 100.0 + + def test_preserves_growth_rates(self): + ci1 = CostIncome( + mkt_price_year=2020, + cost_yearly_growth_rate=0.02, + income_yearly_growth_rate=0.03, + ) + ci2 = CostIncome( + mkt_price_year=2020, + cost_yearly_growth_rate=0.02, + income_yearly_growth_rate=0.03, + ) + combined = CostIncome.comb_cost_income([ci1, ci2]) + assert combined.cost_growth_rate == 0.02 + assert combined.income_growth_rate == 0.03 From 243cbacdc95380a0ed8c347f1e932fd62fdb80ae Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 9 Apr 2026 14:24:10 +0200 Subject: [PATCH 08/44] Adds nice __repr__ --- climada/entity/measures/cost_income.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/climada/entity/measures/cost_income.py b/climada/entity/measures/cost_income.py index 60c9c8f8eb..1d205f093c 100644 --- a/climada/entity/measures/cost_income.py +++ b/climada/entity/measures/cost_income.py @@ -107,6 +107,21 @@ def __init__( else: self.custom_cash_flows = None + def __repr__(self) -> str: + lines = [ + "CostIncome(", + f" mkt_price_year = {self.mkt_price_year.year}", + f" freq = {self.freq!r}", + f" init_cost = {self.init_cost:,.2f}", + f" periodic_cost = {self.periodic_cost:,.2f}", + f" periodic_income = {self.periodic_income:,.2f}", + f" cost_yearly_growth_rate = {self.cost_growth_rate:.2%}", + f" income_yearly_growth_rate = {self.income_growth_rate:.2%}", + f" custom_cash_flows = {None if self.custom_cash_flows is None else f'DataFrame({len(self.custom_cash_flows)} rows)'}", + ")", + ] + return "\n".join(lines) + def _prepare_custom_flows(self, df: pd.DataFrame) -> pd.DataFrame: """Process and resample custom cash flow dataframe From a17f2e27ce8cd4d479f973be2ce28250e248a705 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 9 Apr 2026 14:26:08 +0200 Subject: [PATCH 09/44] Improves freq handling, nicer plot --- climada/entity/measures/cost_income.py | 157 +++++++++++++++---------- 1 file changed, 94 insertions(+), 63 deletions(-) diff --git a/climada/entity/measures/cost_income.py b/climada/entity/measures/cost_income.py index 1d205f093c..33ece8de1c 100644 --- a/climada/entity/measures/cost_income.py +++ b/climada/entity/measures/cost_income.py @@ -144,17 +144,22 @@ def _prepare_custom_flows(self, df: pd.DataFrame) -> pd.DataFrame: if "date" in df.columns: df["date"] = pd.to_datetime(df["date"]) df = df.set_index("date") - match self.freq: + + freq = self._make_offset_compat(self.freq) + return df.resample(freq).sum() + + @staticmethod + def _make_offset_compat(freq: str, start=True) -> str: + suffix = "S" if start else "E" + match freq: case "Y": - resampling_freq = "YS" + return "Y" + suffix case "M": - resampling_freq = "MS" + return "M" + suffix case "Q": - resampling_freq = "QS" + return "Q" + suffix case _: - resampling_freq = self.freq - - return df.resample(resampling_freq).sum() + return freq @classmethod def from_config(cls, config: CostIncomeConfig) -> "CostIncome": @@ -231,8 +236,8 @@ def from_yaml(cls, path: str) -> "CostIncome": with open(path) as f: return cls.from_dict(yaml.safe_load(f)["cost_income"]) - @staticmethod - def _freq_to_days(freq: str) -> str: + @classmethod + def _freq_to_days(cls, freq: str) -> str: """ Convert a frequency string to the equivalent number of days. @@ -249,6 +254,7 @@ def _freq_to_days(freq: str) -> str: try: # Convert the frequency string to a DateOffset object + freq = cls._make_offset_compat(freq, start=False) offset = pd.tseries.frequencies.to_offset(freq) # Calculate the number of days by applying the offset to a base date @@ -264,7 +270,8 @@ def _get_width_days(self) -> float: """Return the number of days in the current frequency.""" ref = pd.Timestamp("2000-01-01") - offset = pd.tseries.frequencies.to_offset(self.freq) + freq = self._make_offset_compat(self.freq, start=False) + offset = pd.tseries.frequencies.to_offset(freq) return float(((ref + offset) - ref).days) def _calc_at_date( @@ -342,7 +349,10 @@ def _calc_at_date( cost = self.periodic_cost * cost_factor income = self.periodic_income * inc_factor - if self.custom_cash_flows is not None: + if ( + self.custom_cash_flows is not None + and curr_date in self.custom_cash_flows.index + ): c_cost = cast(float, self.custom_cash_flows.loc[curr_date, "cost"]) c_inc = cast(float, self.custom_cash_flows.loc[curr_date, "income"]) else: @@ -423,66 +433,87 @@ def plot_cash_flows( impl_date: Any, start_date: Any, end_date: Any, - to_plot: List[str] = ["net", "cost", "income"], + figsize: Tuple[int, int] = (12, 7), + title: Optional[str] = None, ): - """ - Plot the cash flows over a given period. + """Plot periodic and cumulative cash flows over a given period. - Parameters: - ----------- - impl_date: datetime + Displays a two-panel figure: + - Top panel: stacked bar chart of costs and incomes per period, + with a net cash flow line overlay. + - Bottom panel: cumulative net cash flow over time. + + Parameters + ---------- + impl_date : The date the measure is implemented. - start_date: datetime - The start date of the period. - end_date: datetime - The end date of the period. - to_plot: list - List of strings indicating which cash flows to plot. Options are 'net', 'cost', 'income'. + start_date : + Start of the evaluation period. + end_date : + End of the evaluation period. + figsize : tuple, optional + Figure size as (width, height). Default is (12, 7). + title : str, optional + Overall figure title. Defaults to 'Cash Flow Analysis'. + + Returns + ------- + plt.Figure """ + net, costs, incomes = self.calc_cash_flows(impl_date, start_date, end_date) + periods = pd.period_range(start=start_date, end=end_date, freq=self.freq) + dates = [p.start_time for p in periods] + cumulative_net = np.cumsum(net) - # Calculate the cash flows over the given period - net_cash_flows, costs, incomes = self.calc_cash_flows( - impl_date, start_date, end_date - ) + width = pd.Timedelta(days=self._get_width_days() * 0.6) - # Plot the cash flows with colors - date_range = pd.date_range( - start=start_date, end=end_date, freq=self._freq_to_days(self.freq) + fig, (ax_bar, ax_cum) = plt.subplots( + 2, + 1, + figsize=figsize, + sharex=True, + gridspec_kw={"height_ratios": [3, 1], "hspace": 0.08}, ) - width = self._get_width_days() * 0.8 # 80% width for visibility - fig, ax = plt.subplots() - - if "cost" in to_plot: - ax.bar(date_range, costs, color="red", label="Cost", width=width) - if "income" in to_plot: - ax.bar( - date_range, - incomes, - color="blue", - label="Income", - alpha=0.7, - width=width, - ) - if "net" in to_plot: - ax.bar( - date_range, - net_cash_flows, - color="blue", - edgecolor="red", - hatch="//", - label="Net", - alpha=0.5, - width=width, - ) - ax.xaxis_date() # <---- treat x-ticks as datetime - fig.autofmt_xdate() - plt.xlabel("Date") - plt.ylabel("Cash Flow") - plt.title("Cash Flows") - plt.legend() - plt.show() - return ax + # --- top panel: stacked bars + net line --- + ax_bar.bar( + dates, incomes, width=width, color="#4C9BE8", label="Income", zorder=2 + ) + ax_bar.bar(dates, costs, width=width, color="#E8604C", label="Cost", zorder=2) + ax_bar.plot( + dates, + net, + color="black", + linewidth=1.5, + marker="o", + markersize=4, + label="Net", + zorder=3, + ) + ax_bar.axhline(0, color="black", linewidth=0.6, linestyle="--", zorder=1) + + ax_bar.set_ylabel("Cash flow") + ax_bar.legend(frameon=False, fontsize=9) + ax_bar.spines[["top", "right"]].set_visible(False) + ax_bar.tick_params(axis="x", which="both", bottom=False) + ax_bar.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"{x:,.0f}")) + + # --- bottom panel: cumulative net --- + # dates = dates.append() + positive = np.maximum(cumulative_net, 0) + negative = np.minimum(cumulative_net, 0) + ax_cum.fill_between(dates, positive, alpha=0.25, color="#4C9BE8", step="mid") + ax_cum.fill_between(dates, negative, alpha=0.25, color="#E8604C", step="mid") + # ax_cum.plot(dates, cumulative_net, color="black", linewidth=1.5, zorder=3) + ax_cum.axhline(0, color="black", linewidth=0.6, linestyle="--", zorder=1) + + ax_cum.set_ylabel("Cumulative net") + ax_cum.spines[["top", "right"]].set_visible(False) + ax_cum.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"{x:,.0f}")) + + fig.autofmt_xdate(rotation=30, ha="right") + fig.suptitle(title or "Cash Flow Analysis", fontsize=13, y=1.01) + return (ax_bar, ax_cum) def to_dataframe(self, impl_date, start_date, end_date) -> pd.DataFrame: """Return cash flows as a formatted DataFrame.""" From abe1fdffe0a126c11a4ece74f75f95776cc5dc0a Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 9 Apr 2026 14:26:43 +0200 Subject: [PATCH 10/44] Adds test for freq manipulations --- climada/entity/measures/test/test_cost_income.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/climada/entity/measures/test/test_cost_income.py b/climada/entity/measures/test/test_cost_income.py index bf546b9b91..f9d6667db3 100644 --- a/climada/entity/measures/test/test_cost_income.py +++ b/climada/entity/measures/test/test_cost_income.py @@ -185,6 +185,14 @@ def test_yearly(self): ci = CostIncome(freq="Y") assert ci._get_width_days() == 365.0 + def test_3yearly(self): + ci = CostIncome(freq="3Y") + assert ci._get_width_days() == 3 * 365.0 + + def test_monthly(self): + ci = CostIncome(freq="M") + assert ci._get_width_days() == 30.0 + def test_daily(self): ci = CostIncome(freq="D") assert ci._get_width_days() == 1.0 From 1513c115b37f20b9d56deff06eab488d33f63234 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 9 Apr 2026 14:28:14 +0200 Subject: [PATCH 11/44] Adds tutorial file --- doc/user-guide/climada_cost_income.ipynb | 1020 ++++++++++++++++++++++ 1 file changed, 1020 insertions(+) create mode 100644 doc/user-guide/climada_cost_income.ipynb diff --git a/doc/user-guide/climada_cost_income.ipynb b/doc/user-guide/climada_cost_income.ipynb new file mode 100644 index 0000000000..bf1834140e --- /dev/null +++ b/doc/user-guide/climada_cost_income.ipynb @@ -0,0 +1,1020 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2147f042", + "metadata": {}, + "source": [ + "(cost-income-tutorial)=\n", + "# Measure cash flows with `CostIncome`\n", + "\n", + "This notebook introduces the `CostIncome` class from CLIMADA, which is used to model the financial cash flows of adaptation or risk-reduction measures over time.\n", + "\n", + "A `CostIncome` object tracks:\n", + "- **Initial (one-off) costs** — the upfront implementation cost\n", + "- **Periodic costs** — recurring expenses (e.g., maintenance)\n", + "- **Periodic income** — recurring revenues (e.g., insurance savings, avoided losses)\n", + "- **Growth rates** — how costs and incomes evolve over time\n", + "- **Custom cash flows** — arbitrary user-defined flows (layered on top)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "a73bc8d1", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Adjust the import path if running outside the CLIMADA package tree\n", + "from climada.entity.measures.cost_income import CostIncome" + ] + }, + { + "cell_type": "markdown", + "id": "a97e1043", + "metadata": {}, + "source": [ + "## Quickstart\n", + "\n", + "The simplest way to create a `CostIncome` is by passing keyword arguments directly.\n", + "\n", + "| Parameter | Meaning | Sign convention |\n", + "|---|---|---|\n", + "| `init_cost` | One-off implementation cost | stored negative |\n", + "| `periodic_cost` | Recurring cost each period | stored negative |\n", + "| `periodic_income` | Recurring income each period | stored positive |\n", + "| `mkt_price_year` | Reference year for price levels | — |\n", + "| `freq` | Period frequency (e.g. `'Y'`, `'M'`, `'Q'`) | — |\n", + "\n", + "```{note} **Sign convention**\n", + "`CostIncome` stores costs as negative numbers internally.\n", + "```\n", + "\n", + "```{note}\n", + "Financial values in `CostIncome` are currently unitless (no currency is specified)\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4ba16743", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CostIncome(\n", + " mkt_price_year = 2020\n", + " freq = 'Y'\n", + " init_cost = -20,000.00\n", + " periodic_cost = -5,000.00\n", + " periodic_income = 12,000.00\n", + " cost_yearly_growth_rate = 0.00%\n", + " income_yearly_growth_rate = 0.00%\n", + " custom_cash_flows = None\n", + ")\n" + ] + } + ], + "source": [ + "ci = CostIncome(\n", + " mkt_price_year=2020,\n", + " init_cost=20_000, # 50 000 upfront\n", + " periodic_cost=5_000, # 5 000 / year maintenance\n", + " periodic_income=12_000, # 8 000 / year in avoided losses\n", + " freq=\"Y\", # annual cash flows\n", + ")\n", + "\n", + "print(ci)" + ] + }, + { + "cell_type": "markdown", + "id": "3c9a8398", + "metadata": {}, + "source": [ + "## Calculating cash flows\n", + "\n", + "Three methods are available:\n", + "\n", + "| Method | Returns |\n", + "|---|---|\n", + "| `calc_cash_flows(impl_date, start_date, end_date)` | Three `np.ndarray`: net, costs, incomes |\n", + "| `calc_total(...)` | Three scalars: summed net, cost, income |\n", + "| `to_dataframe(...)` | A tidy `pd.DataFrame` |\n", + "\n", + "The `impl_date` is when the measure is *deployed*. Cash flows before this date are zero; the initial cost lands on `impl_date`; periodic flows start the following period." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "25bf1e1f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Period | Net | Cost | Income\n", + "---------------------------------------------\n", + "2020 | 0 | 0 | 0\n", + "2021 | 0 | 0 | 0\n", + "2022 | -20000 | -20000 | 0\n", + "2023 | 7000 | -5000 | 12000\n", + "2024 | 7000 | -5000 | 12000\n", + "2025 | 7000 | -5000 | 12000\n", + "2026 | 7000 | -5000 | 12000\n", + "2027 | 7000 | -5000 | 12000\n", + "2028 | 7000 | -5000 | 12000\n", + "2029 | 7000 | -5000 | 12000\n", + "2030 | 7000 | -5000 | 12000\n" + ] + } + ], + "source": [ + "impl_date = \"2022-01-01\"\n", + "start_date = \"2020-01-01\"\n", + "end_date = \"2030-01-01\"\n", + "\n", + "net, costs, incomes = ci.calc_cash_flows(impl_date, start_date, end_date)\n", + "\n", + "print(\"Period | Net | Cost | Income\")\n", + "print(\"-\" * 45)\n", + "periods = pd.period_range(start=start_date, end=end_date, freq=\"Y\")\n", + "for p, n, c, i in zip(periods, net, costs, incomes):\n", + " print(f\"{p} | {n:>9.0f} | {c:>9.0f} | {i:>6.0f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "971ce0dd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total net : 36000\n", + "Total cost : -60000\n", + "Total income : 96000\n" + ] + } + ], + "source": [ + "total_net, total_cost, total_income = ci.calc_total(impl_date, start_date, end_date)\n", + "print(f\"Total net : {total_net:>10.0f}\")\n", + "print(f\"Total cost : {total_cost:>10.0f}\")\n", + "print(f\"Total income : {total_income:>10.0f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f3fd0c35", + "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", + "
datenetcostincome
020200.00.00.0
120210.00.00.0
22022-20000.0-20000.00.0
320237000.0-5000.012000.0
420247000.0-5000.012000.0
520257000.0-5000.012000.0
620267000.0-5000.012000.0
720277000.0-5000.012000.0
820287000.0-5000.012000.0
920297000.0-5000.012000.0
1020307000.0-5000.012000.0
\n", + "
" + ], + "text/plain": [ + " date net cost income\n", + "0 2020 0.0 0.0 0.0\n", + "1 2021 0.0 0.0 0.0\n", + "2 2022 -20000.0 -20000.0 0.0\n", + "3 2023 7000.0 -5000.0 12000.0\n", + "4 2024 7000.0 -5000.0 12000.0\n", + "5 2025 7000.0 -5000.0 12000.0\n", + "6 2026 7000.0 -5000.0 12000.0\n", + "7 2027 7000.0 -5000.0 12000.0\n", + "8 2028 7000.0 -5000.0 12000.0\n", + "9 2029 7000.0 -5000.0 12000.0\n", + "10 2030 7000.0 -5000.0 12000.0" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = ci.to_dataframe(impl_date, start_date, end_date)\n", + "df" + ] + }, + { + "cell_type": "markdown", + "id": "612c0b66", + "metadata": {}, + "source": [ + "## Visualising cash flows\n", + "\n", + "`plot_cash_flows` draws a bar chart. You can choose which series to display via the `to_plot` argument." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "315fc0ac", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(, )" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABAgAAAJyCAYAAABJ8PKHAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAfwRJREFUeJzt3Qd4lMXWwPGTTgIh9NCL9I70DkoTBBRUEJQmqNgBUUCkqYCiIl6l2gAFwSt6LaAURaRYkA7SiXQINSGU1P2eM7j7JSEJSdjNtv/veZbdfetk9s2SOe/MGR+LxWIRAAAAAADg1XydXQAAAAAAAOB8BAgAAAAAAAABAgAAAAAAQIAAAAAAAAAQIAAAAAAAAAQIAAAAAACAQZJCAAAAAABAgAAAAAAAABAgAAAAAAAABAgAAHB9v/zyi/j4+MjcuXNz5HytW7eWsmXL5si53M0///xjPovx48c79Dx6jv79+zv0HAAApEYOAgAAMuHatWvy3nvvSatWraRgwYISEBAgRYoUkQ4dOsgHH3wgsbGxLl+P2uhM7+HoBq89NW3alAY0AAAO4O+IgwIA4Gl3je+++275+++/5c4775QRI0ZI4cKF5dy5c+bu/uDBg2Xjxo0yZ84ccXW1atWSF154Ic3l7mD37t3y22+/ScWKFeW///2v/Oc//5G8efOKp7l69ar4+fk5uxgAAC9DgAAAgJv0HOjcubPs3btXvvjiC3nggQdSrB8+fLjs3LlTVqxY4Rb1WKxYMXn44YfFXX300UeSO3duWbBggTRs2FAWLVokjz32mHiaXLlyObsIAAAvxBADAABu0iDdtWuXDBs27IbggFWNGjXMeqs///zTjB+vVKmShISESGhoqDRr1ky+/vrrG/Y9evSoDBw4UMqUKSNBQUFm+EKDBg3MsIW0fPjhh1KtWjWzre4zZcqUHPv81q9fL3fddZfky5dPgoODpXbt2mbYhcVisW3z2Wefme7/2rPCKjExUcLCwszy33//3bZch2Vo/fTt2zdT54+Pj5dPP/1U7r//flNHGiDQzyejPArHjh2THj16SP78+U1gQYeE7Nu3L8W2ly5dkpdfflkaNWokhQoVMnVboUIFGTlypFy5ciXDMp0+fVoCAwPloYceSnP9s88+a35u6znPnz9vrpXy5cubIICWS3tvTJw48aY5CJYuXWqGuGjvFd23ePHi0rVrV3N9AgBgD/QgAAAgA9qNXT3++OOZricNBGiDsFevXlKyZEkzFGHevHnSvXt3c+e7d+/eZruEhARp166dHD9+XJ544gmpXLmyREdHmx4Jv/76qzz66KMpjjtz5kyJjIyUQYMGmQa3NsZ1uIOew3rMzDSyz549m2KZr6+vFChQIMP9li1bJvfcc49pQA8ZMsQ0bJcsWWIawDt27LANr2jTpo15/umnn0wjXenwC/259Dy6vHHjxma5DhXQrvQ6bCMzvvvuO/Pz9+vXz7zX56eeesrUlwZpUrt8+bJpUDdp0kQmTZokERER8u6775qfQ/exduHX+tdAgwaAtKGvy9esWWOCL1u2bJHly5enW6bw8HBzvK+++kouXLhg6iV5AEQ/75YtW5pgkdJz6Ger15MGWPTn12tFAyqjR49O9zxaHg0G1KxZ0wQuNEhz8uRJWb16tdm/evXqmapDAAAyZAEAAOkqUKCAJTQ0NEs1FBMTc8Oyy5cvWypVqmSpWrWqbdm2bdv01rtlypQpGR5v9erVZrtixYpZLly4kOKYhQoVsjRu3DhT5dJjpPUICwtLsV2rVq0sZcqUsb1PSEgw77Uejh49mmL5XXfdZY6xfv162/LKlStbmjRpYns/ceJES968eS1du3a13HHHHbblY8aMMfsePnw4U+Xv1KmTpWzZspakpCTz/vz585agoCDL0KFDb9hWfwY99htvvJFiuda1Lv/xxx9ty2JjYy3x8fE3HOPll1822/7xxx+2ZREREWbZuHHjbMtWrFhhlr333nsp9l+0aJFZPn/+fPP+4sWL5v2TTz55059Vt+vXr5/tvf6MuiwyMvKm+wIAkF0MMQAAIAN65zurSfC0K7uVdlHXHgT6rHfKNcmeHlNpLwD1888/m67qNzNgwABz59hKu+fr3fj9+/dnumz169eXlStXpnh88803Ge6zefNmOXz4sOnyrr0VrPRO+0svvWRe6x10K/05tdeAdt23/nzam6B9+/ayYcMGk9fBuly78pcuXfqm5da7/HonX4cjaPd7pXfr9a66DjuIi4u7YR/tsaA9HJKz9lZIXmc6RMDf39/Wq0N7Amgvi7Zt25plf/zxR4Zl0+1uu+22G4Y76Hv9jHVIhNJhGTo0QIdZaOLLrLB+7tqjRcsIAIAjECAAACADGhywNnQzS7vBa+I87X6uwQLtlq/jxmfNmmXWX7x40TxrDoGxY8eaBIc6nrxu3bpmhoHk4/ST00ZoapqzQAMQmaXba4M2+UO74Wfk0KFD5jmtbuza5T35NtZGuDZitSu9drPXoIAu04e+11wG2v1fczVYhyTczNy5c00uA53i8MCBA7aHBh60Mf/tt9/esI/Waepkf/rzq9R1NmPGDJMLQPMP6HAL/bysQyQ0YJARDVjocJCtW7eaYIrSgIoOp9AhCxoYsAYidIiD5gwoV66cySXx9NNPmyDNzeh29erVM0MqtHwdO3Y0x8pMYAkAgMwiQAAAQAa0Aax3/A8ePJipekpKSjJ5BTTngN7tXrx4sfz444+mEWjNE6DbWE2YMME0dHW6Ph2n/sknn5gx86nvfCtnTXuXPAlhZtxxxx2m0awNZGueAQ0EVK1a1cyioMvXrl1r8iFkJv+Anl/rRWmSRJ3i0PrQBrNKK1lhRvWV/Gd6++23zXG0bLNnzzbJAPXz0qBE6s8ro94dAQEBJomk0vLqfpovIjkNHGnvAd1OEy1qvgrtWdGtW7cMz6NBAQ2oaC6C5557zvRIef755801kzwhJAAAt4IkhQAAZEC7h2ujTGcVeP31129aV5qwb/v27aZngDb+k7M2HlPTu8naQNWH3mHXpHc6O8DQoUPNOmfTjPsqrWz5muwv+TbWu/R6N14DAdqDQntSWJMIakBAl2twQIMIGky4GW0Aa4BGgyYtWrS4Yb0mS9QpKHXGguRDIDJLkz3qjAc//PCDGZZgpYGdzNKfUYc7LFy4UN58800TXNAeIbfffvsN2xYtWtTMXKEPDQpo74OPP/7YXGcZ1YeWTRMe6kPpcBXtVTBu3DizLwAAt4oeBAAAZEAbcXrnW+8yJx9nnzoooOuT37VOfdddG9KppzmMiooyDeXktIu7tSu/TonnCrShq8MhtFeE5gKw0sbt5MmTzWu9A56cBgK0Xr788ssUvQT09aZNm8yQAO2doV35b0Z7B2jjWPMdaMAm9UNnVdCyWO/4Z5V+ZhqsSP6Z6RCJzASEUvcO0M908ODBZohB6t4Detc/9bSJ+nPVqVPnpp936pknlPYe0Ck0XeU6AQC4P3oQAACQAR0//v3338vdd98t9913nxmzr13CNa+AjmPXO7c6BaB1SkINJmgDX6fI08agTl2o09Bp13W9i24do650ijptVOpxrY09Hceu2+odeGvD0dm0Aa1j9LVng3aL1yn6NEGgBkz059efXXMDJKeBgHfeeUf27Nkjw4cPty3XoQaaS0DrRBv2N6P5GrSHQPPmzc1d+rQ0bNjQ9BzQu/A6VaA1iWFmaZBh1KhRZly/TkWpQ0q0J4AOGcgKHVqieSK0R4JeN6mnntSfWfM9aDBFrxHtaaH1o9NXar4Ea1LEtGgdaw8JvfY0WKM9TTRhoea70LwVAADYAwECAABuQht9etdbhxnoHXG9a66JC7WRrHfXdfnDDz9sa0zrGHZtFOsdd03Gp4EBfb1t27YUAYLatWubBqk2shcsWGAazqVKlTL7aqPPWTkH0tKpUycT0Hj11Vdl6tSppoGqOQA0Ud4zzzxzw/baENaZAfROfPIeBNq41frUpIaZyT+gDXWd9cA6E0BaNCCg9ah5HLSMmTluclrX2ntAeyro+H4dAtCzZ0+TV0ATCWaWlkN7DWhPhwceeMA2S4WVfraPPPKIKaPOHKE/lwYGNFfFyJEjb9g+uT59+pgeEnodnTlzxiTPrFKliqmfXr16ZennBQAgPT4612G6awEAAJBpb731lgk46AwOaeVLAADAlREgAAAAsAPtLaFDSnRqxbQSOgIA4OoYYgAAAHALIiIizHSOOmxAh05ot38AANwRAQIAAIBboDkkNF+BJq7U6S3JCQAAcFcMMQAAAAAAAOJLHQAAAAAAAAIEAAAAAACAAAEAAAAAACBAAAAAAAAACBAAAAAAAAACBAAAAAAAwCBJIQAAAAAAIEAAAAAAAAAIEAAAAAAAAAIEAAAAAACAAAEAAAAAADBIUggAAAAAAAgQAAAAAAAAAgQAAAAAAIAAAQAAAAAAIEAAAAAAAAAMkhQCAAAAAAACBAAAAAAAgAABAAAAAAAgQAAAAAAAAAgQAAAAAAAAgySFAAAAAACAAAEAAAAAACBAAAAAAAAACBAAAAAAAAACBAAAAAAAwCBJIQAAAAAAIEAAAAAAAAAIEAAAAAAAAAIEAAAAAACAAAEAAAAAADBIUggAAAAAAAgQAAAAAAAAAgQAAAAAAIAAAQAAAAAAIEAAAAAAAAAMkhQCAAAAAAACBAAAAAAAgAABAAAAAAAgQAAAAAAAAAgQAAAAAAAAgySFAAAAAACAAAEAAAAAACBAAAAAAAAACBAAAAAAAAACBAAAAAAAwCBJIQAAAAAAIEAAAAAAAAAIEAAAAAAAAAIEAAAAAACAAAEAAAAAADBIUggAAAAAAAgQAAAAAAAAAgQAAAAAAIAAAQAAAAAAIEAAAAAAAAAMkhQCAAAAAAACBAAAAAAAgAABAAAAAAAgQAAAAAAAAAgQAAAAAAAAgySFAAAAAACAAAEAAAAAACBAAAAAAAAACBAAAAAAAAACBAAAAAAAwCBJIQAAAAAAIEAAAAAAAAAIEAAAAAAAAAIEAAAAAACAAIETWCwWiY6ONs8AAAAAALgKkhTmsEuXLklYWJh5BgAAAADAVRAgAAAAAAAABAgAAAAAAAABAgAAAAAAQIAAAAAAAAAQIAAAAAAAAAZJCgEAAAAAAAECAAAAAABAgAAAAAAAABAgAAAAAAAABAgAAAAAAIBBkkIAAAAAAECAAAAAAAAAECBAFrVu3Vr8/Pxk+/bttmUXL14UHx8f+eeffzK1/7Rp06h3AAAAAHAxDDHwIF999ZXUrl1bgoODzbO+d4T8+fPLqFGjHHJsAAAAAIBzECBwURaLRS5fvpzpx8KFC+W+++6THTt2yLVr18yzvtflmdlfz5dZTz75pGzYsEF+/fXXNNcvWrRIatWqJfny5ZMGDRqYbdXzzz8va9eulREjRkiePHmkY8eOdqsvAAAAAMCt8bFkpWWIWxYdHS1hYWESFRUlefPmTXc7bbRrIzqnxMTESO7cuTM1RODee++Vq1evynfffWca/zrEQHsVREREyN9//y2PPfaYfPvtt1KnTh353//+J48++qjs27dPChYsaNt/yJAhOfJzAd6oy4enxZ19Nyjcqeen/qg/rj/3/P3ld5f6cyauP+rPU9CDANmiDfzDhw+bAEBy06dPlxdeeEHq1q0rvr6+0r17d6lSpYosW7aMmgYAAAAAF+bv7AIgbSEhIeaufmY1btxYdu3alWKogCYOrFGjhvz222+ZOl9WaJ6DcePGyUsvvWSGDVhpokJdpuus4uPj5fjx41k6PgAAAAAgZxEgcFHauM9Ml3+rCRMmmJwDup8GCazPujwrx8mKgQMHytSpU2XevHm2ZaVKlZJnnnlGBg8enOY+2qsAAAAAAOB6aK15CO3Kv2TJEpMcMFeuXOZZZzHo1q2bw86p0x1OnDhRJk2aZFv29NNPy5tvvimbNm0yAYorV67IqlWr5NixY2Z9eHi4HDx40GFlAgAAAABkDwECDwsSbN261SQQ1GdHBgestNdChQoVbO87d+4sr7/+uklMqIkLy5UrJ++++64kJSXZchdowEBnONBtAQAAAACugSEGyJJffvnlhmW///57ivcPPPCAeaSlUaNGsnv3bmodAAAAAFwMPQgAAAAAAAABAgAAAAAAQIAAAAAAAAAQIAAAAAAAAAQIAAAAAACAQZJCAAAAAABAgAAAAAAAABAgAAAAAAAABAgAAAAAAIDyd7Vq+PXXX+XNN9+UTZs2ycmTJ+Xrr7+We++917beYrHIhAkTZM6cOXLhwgVp1KiRTJ8+XapXr57hcZcsWSJjxoyRgwcPSvny5WXixInSrVu3FNvMmDHDnFvPq8ebNm2atGjR4pbPfSu6fHhaHO27QeEOPwcAAAAAwLW5XJLCy5cvS+3ateX9999Pc/2UKVNk6tSpZv3GjRulaNGi0q5dO7l06VK6x/ztt9+kZ8+e0qdPH9m2bZt57tGjh/zxxx+2bRYvXixDhgyR0aNHy5YtW0xgoGPHjnLkyJFbOrenad26tQmcAAAAAAA8i8sFCLRR/tprr0n37t1vWKd38LVxqo14XV+jRg2ZN2+eXLlyRRYuXJjuMXUfbciPGjVKqlSpYp7btGmToqGrDf+BAwfKoEGDpGrVqmZdqVKlZObMmbd0bgAAAAAA3IHLBQgyEhERIadOnZL27dvblgUFBUmrVq1kw4YNGfYgSL6P6tChg22fuLg4M6Qh9Tb63rpNds8dGxsr0dHRKR6e4JdffpF8+fLJhx9+aAIpBQsWlBdffDHFNitXrjTDMHS7YsWKyeTJk23rPvvsMxOI0XXNmzc3vTaS91IYMWKECeLkzp1bGjduLMePH5fx48dL4cKFpWTJkmboiZUGb/7zn/+Y4I8eT/ffvXt3DtUEAAAAAHgGtwoQaANdhYenHDOv763r0tsvo33Onj0riYmJGW6T3XNrozgsLMz20Ma0p9ChFTt27JD9+/fLunXrTD4GDRwobfDfc889Jmhw5swZ2bNnj9xxxx1m3dq1a+WJJ56Q2bNnm3X333+/CdhERUXZjr1gwQJ599135dy5cyZIoEM+tP40P8S4cePk0Ucflfj4eLOt9vL46KOP5LvvvjOfpfbw6NKliwn8AAAAAAA8MEBg5ePjk+K93kFOvSw7+9hrm+R0OIM2fK2Po0ePiqfQn10DILly5TK9AZo2bWp6YihN5Pjggw/KfffdJwEBAaZxrz0B1Pz58+Xhhx+Wli1bmnWa+yF//vyydOlS27F1vQ7j0GPrMa5evSpDhw4Vf39/eeihh0zg4PDhw2ZbDUy88sorUrFiRbP+2WefNdsnzzEBAAAAAPCgAIEmBVSp79hHRkbecGc/9X4Z7VOoUCHx8/PLcJvsnluHIeTNmzfFw1PozxISEmJ7r3f6rQkbtfGuDfa0HDt2TMqWLZtiWbly5cxyK2t9Kz1H8jq2njMmJsY8//PPPyagoMMLrA+dZSL58QAAAAAAHhQg0EakNhx1bLuVdiNfs2aNuXudniZNmqTYR61YscK2T2BgoNSrV++GbfS9dZvsnttblSlTRg4cOJDmOs0hoI365PS9Ls8OHbbx3//+Vy5evGh7aPLIXr16Zet4AAAAAOCNXC5AoHeFt27dah7W5ID6Wqcb1K782h190qRJJkndzp07pX///uaOcu/evdM95nPPPWcCAm+88YYZC6/Pq1atMseyGjZsmEm49/HHH5sEd9qdXc85ePBgsz675/ZWmiPg888/N3WVkJBghlf8/vvvZp3e7dccA+vXrzfr3nvvPTNkoFOnTtk611NPPSVjx46VvXv3mveaCPKbb77xquknAQAAAOBW+YuL+euvv2zJ7KwNd9WvXz+ZO3euSXqn48uffPJJ041cs+Rr4z80NNS2jzbc9Y60NWGe3uFftGiRvPzyyzJmzBgpX768LF682Oxr1bNnT9NI1bHsmghPx78vW7bM3Am3ysy57e27QekPX3BldevWlSVLlpj61s8uT548JlCjeQh05gcNCui0kta6/uGHH8zQgOx4+umnzRARTU6oOR7089CZEe688067/1wAAAAA4Kl8LJppzsPoNHf60GnxXI3e3daEfXpH3ZPyEQBwHV0+PC3uzNmBUeqP+uP6c8/fX353qT9n4vqj/jyFy/UguFXarfzgwYPy/fffO7soAAAAAAC4DY8LEGj3ck+aShAAAAAAAK9MUggAAAAAAHIeAQIAAAAAAECAAAAAAAAAECAAAAAAAAAECAAAAAAAAAECAAAAAADgmdMceprTA7o4/Bzhn3zn8HMAAAAAAFwbsxggW9atWycdO3aU/PnzS758+aR27doyZcoUiYuLy3aN+vj4yNatW/lEAAAAAMAJCBAgy77//nsTHOjQoYPs379fLl68KIsXL5a///5bTp48SY0CAAAAgBsiQIAssVgs8uyzz8qIESNkyJAhUqhQIbO8SpUqMnfuXClTpoz89ddf0qxZM9OzoFq1avL555/b9t+8ebM0btxY8ubNa/bt0uX6EIqGDRua56ZNm0qePHlk0qRJfDIAAAAAkIPIQYAs0R4DERER0qtXrzTXa2+Cu+66S8aNGyeDBw+WDRs2yN133y2lS5c2QYOnn37aBAV0eXx8vPzxxx9mvz///NMMMdDlderU4VMBAAAAgBxGDwJkyZkzZ8xziRIl0ly/dOlSKVy4sDzzzDMSEBAgrVq1kt69e8u8efPMel12+PBhOXHihAQFBUnLli35BAAAAADABRAgQJZYhxQcP348zfXHjh2TsmXLplh22223meXq448/lmvXrkm9evXMsIT333+fTwAAAAAAXAABAmRJpUqVTABg0aJFaa4vWbKk/PPPPymW6ZAEXa7Kly8v8+fPl1OnTsmHH34ow4cPl02bNpl1OsQAAAAAAOAcBAiQJdqIf++99+T11183z+fOnTPL9+3bJwMHDpTmzZtLZGSkzJgxQxISEmTt2rWycOFC6du3r9lOgwOnT582x9EpEn19fcXf/3oqjPDwcDl48CCfCAAAAAA4AUkKXVz4J9+Jq+ncubP88MMP8tprr8mYMWPMMk1C2KdPHylWrJhZpzMcjBo1SooXLy4zZ840gQO1atUqefHFFyUmJsYEBN58802pXbu2Wffqq6+aGRIGDRpkZkkYOXKkU39OAAAAAPAmBAiQLdrg//HHH9Ncp1MW6mwEadEeBOnRwIA+AAAAAAA5jwABACBTTm5eKvu+e1sunzoouYuWl0pdnpdide+m9jKJ+rs11B/15yxce9SfM3H9UX85zcdisVhy/KxeLDo6WsLCwiQqKkry5s3r7OIA8EBdPjztkD9QNs0cqIlIRMx/G5pU1CIVOw+TAhUa2vVcr3TML8409ocLdj/m+QN/yv7vp9rqjfqj/rj+7I/fXerPmbj+3KD+/v0bpt4TH9n9Bsd3g8LFUxAgyGEECAC4Y4BgzYQ75dLx3f8GBwAAANyQj4+Elqgqrcb9bNfDfudBAQKGGAAAbkqHFaQdHPCRvKWq27UGbyvo3P+aDp1LsPsxo4/u+rfnQGrUH/XH9Wcv/O5Sf87E9ecm9WexXP+bBukiQAAAuCnNOXDp2O6U/9H6+EjeEtWk5dhVHhWFz7EeGNQf9cf1Z1f87lJ/zsT15z71l6doBbufy5P4OrsAAADXpwkJUwcH9D/cimY5MlV/+geK1hv1l73rj/rLNuqPunMWrj3qz5m4/rKHAAEA4KY0mU+uAiXMax8/fzN+r94TH0uxup2ovUzWnyZF0nrz9Q+i/rKI+rs11B915yxce9SfM3H9ZQ9DDAAAN3Xl7BG5dv64+Pj6Sbu3d0hgbufONOCuf6gwLST1x/Xnfvjdpf64/twXv79ZRw8CAMBNnd62wjznr9CQ4AAAAICHIkAAAMh0gCC8dntqCwAAwEMRIAAAZCj+SrSc2/ebeR1euwO1BQAA4KEIEAAAMnRm12qxJMZL7qIVJE/4bdQWAACAhyJAAADI0OntK80zwwsAAAA8GwECAEC6khITJHL7KvM6vBb5BwAAADwZAQIAQLouHNwo8VcuSkCeApK/fH1qCgAAwIMRIAAApOv0tuXmuUiNO8XXz5+aAgAA8GAECAAA6Tq97d/8A3WYvQAAAMDTESAAAKQp5tQBuXz6oPj4BUjhaq2pJQAAAA/ndgGC8ePHi4+PT4pH0aJFM9xnzZo1Uq9ePcmVK5fcdtttMmvWrBu2WbJkiVSrVk2CgoLM89dff33DNjNmzJBy5cqZ4+jx1q5da9efDQBcyeltK8xzocrNJCA41NnFAQAAgIO5XYBAVa9eXU6ePGl77NixI91tIyIipFOnTtKiRQvZsmWLvPTSS/Lss8+agIDVb7/9Jj179pQ+ffrItm3bzHOPHj3kjz/+sG2zePFiGTJkiIwePdocR4/XsWNHOXLkiMN/XgBwZoCgSO12fAAAAABewC0DBP7+/qbXgPVRuHDhdLfV3gKlS5eWadOmSdWqVWXQoEHyyCOPyFtvvWXbRte1a9dORo0aJVWqVDHPbdq0Mcutpk6dKgMHDjT763F0XalSpWTmzJkO/3kBIKfFxZyX8wf+NK/DazO9IQAAgDdwywDB/v37pXjx4qa7/4MPPiiHDh1Kd1vtHdC+fco/bjt06CB//fWXxMfHZ7jNhg0bzOu4uDjZtGnTDdvoe+s26YmNjZXo6OgUDwBwdZE7fhKxJEloyWoSUrCUs4sDAACAHOB2AYJGjRrJ/PnzZfny5fLBBx/IqVOnpGnTpnLu3Lk0t9f14eHhKZbp+4SEBDl79myG2+hypdslJiZmuE16Jk+eLGFhYbaH9joAAHcZXlC0NrMXAAAAeAu3CxDouP/77rtPatasKW3btpWlS5ea5fPmzUt3H01kmJzFYrlheVrbpF6WmW1S0+EKUVFRtsfRo0dv+jMCgDMlJcTJmV2rzWvyDwAAAHgPf3FzuXPnNsECHXaQFs1RkPouf2RkpMljULBgwQy3sfYYKFSokPj5+WW4TXp0VgR9AIC7OLfvN0m4FiNBYUUkX5k6zi4OAAAAcojb9SBIa4z/7t27pVixYmmub9KkiaxcuTLFshUrVkj9+vUlICAgw2106IIKDAw00xqm3kbfW7cBAE9xeuty81ykVjvx8XX7/yYAAADgqT0Ihg8fLl26dDEzE+gd/Ndee80k/uvXr1+a2w8ePFjef/99GTZsmDz66KMmIeFHH30kn3/+uW2b5557Tlq2bClvvPGG3HPPPfLNN9/IqlWrZN26dbZtdH+d/lADCxpQmDNnjpniUI8PAJ5Ch06d3k7+AQAAAG/kdgGCY8eOSa9evUziQJ3esHHjxvL7779LmTJlzPrx48fL3Llz5Z9//jHvdaaDZcuWydChQ2X69Olm9oP//Oc/Jo+BlfYCWLRokbz88ssyZswYKV++vCxevNgkRLTq2bOnSYT4yiuvyMmTJ6VGjRrmuNbzAoAnuHR8t1w9d0x8A3JJoSrNnV0cAAAA5CC3CxBoQz4jGhho3bp1imWtWrWSzZs3Z7jf/fffbx4ZefLJJ80DADx99oLC1VqKX1CIs4sDAACAHOR2AYKbWbNmjfz666/OLgYAuKXT26z5B9o7uygAAADIYR4XIIiIiHB2EQDALV2LipSLEVvM6/Ba7ZxdHAAAAOQw0lMDAIzI7ddnagkrW0dy5ct4ClcAAAB4HgIEAIAU+QeK1u5AjQAAAHghAgQAAEmMuypndl/P3xJem/wDAAAA3ogAAQBAzu5eK0lxVyW4QAkJLVmNGgEAAPBCBAgAALbhBUVqtxcfHx9qBAAAwAsRIAAAL2dJSpLT/yYoJP8AAACA9yJAAABeLurwNomNOi1+QbmlQKUmzi4OAAAAnIQAAQB4udPbrw8vKFy9tfgFBDm7OAAAAHASAgQA4OVOb2V6QwAAABAgAACvdvXcMYk+tkvEx1eK1Gzj7OIAAADAiehBAABezDq8oED5BhIYWtDZxQEAAIATESAAAC92etv12QuK1G7n7KIAAADAyQgQAICXSrgWI+f2rjevmd4QAAAABAgAwEud2fWLJCXESUiRcpK7aAVnFwcAAABORoAAALzU6W3W2Qvai4+Pj7OLAwAAACcjQAAAXsiSlCiRO1aZ10Vqt3d2cQAAAOACCBAAgBe6cGiTxMWcl4CQfFKgfENnFwcAAAAugAABAHih01uXm+fCNe4UX/8AZxcHAAAALoAAAQB4odPb/80/UIfhBQAAALiOAAEAeJnLkRESc3K/+Pj5S+Hqdzq7OAAAAHARBAgAwEtnLyhYqYkEhOR1dnEAAADgIggQAICXOb3tev6BIrUYXgAAAID/R4AAALxI3OWLcn7/H+Z1ONMbAgAAIBkCBADgRc7s/FksSYkSWryy5C5cxtnFAQAAgAshQAAAXph/ILx2B2cXBQAAAC6GAAEAeImkhHiJ3Pmzec3wAgAAAKRGgAAAvITmHki4Gi2BoYUkX7nbnV0cAAAAuBgCBADgZbMXhNdqKz6+fs4uDgAAAFwMAQIA8AIWi+X/AwTkHwAAAEAaCBAAgBeIObFXrpw9Ir7+QVKoWktnFwcAAAAuiAABAHiB09tXmudCVZuLf1BuZxcHAAAALogAAQB4Vf6B9s4uCgAAAFwUAQIA8HCx0WfkwqFN5nWRWu2cXRwAAAC4KAIEAODhInes0iyFEla6lgQXKO7s4gAAAMBFESAAAA93etv1/APhtRleAAAAgPQRIAAAD5YYf03O7FptXhMgAAAAQEYIEGTDjBkzpFy5cpIrVy6pV6+erF27NjuHAQCHO7dnvSTGXZVc+YpJ3tI1qXEAAACkiwBBFi1evFiGDBkio0ePli1btkiLFi2kY8eOcuTIkaweymt99dVXUrt2bQkODjbP+h7UHxw8e0HtduLj40M1AwAAIF3+6a9CWqZOnSoDBw6UQYMGmffTpk2T5cuXy8yZM2Xy5MlU2k1oMOC+++4zDRWLxSI7duww7//73/9Kt27dqL+b+Prrr+WBBx64of6WLFki3bt3p/6Qgl4j/59/oAO1AwAAgAwRIMiCuLg42bRpk4wcOTLF8vbt28uGDRvS3Cc2NtY8rKKjo8WbTZgwwda4VdZnbfQi85LXn9bnK6+8QoAAN4g+skOuXTwpfkEhUrBKM2oIAAAAGSJAkAVnz56VxMRECQ8PT7Fc3586dSrNfbRXgTaKU2vQoIH4+flJr1695KmnnpLmzZvb1v39998ydOhQ0zNBvfzyy1KhQgXp37+/eV++fHn57rvvpEuXLnLw4EGzbO7cuXLgwAF57bXXzPsOHTrIO++8I9WqVbMdd926dTJ9+nT5/PPPzXs9r27XtWtX8z5//vyyfv166devn2zcuNHWY0INGzbMVu558+ZJs2bN5MKFC2bZt99+a8qqx1YZ/Ux6x9vauIV9aH1q/f744492+5xc4dpb3ai8W18i3fedd/jvU3qfk7Xu3tq6TzRDSofwvPLxn0+Lu6g29SDX3i1o9onzrj39jviwkLi1hSG9nPp/7ofrr9e/2xr0HddeNnHtue+1p98RH66/3rvYXf1Za4xT2xru/t3Xb20Bp117Wfmc9Jg342OhtZZpJ06ckBIlSpjeAk2aNLEtnzhxonz66aeyZ8+eTPUgKFWqlERFRUnevHnF22jOgdRBAr0DXr16dVmzZo1Ty+YOWrZsaX6xU9dfrVq1ZOvWreJJTg/oIu4s/JPvnF537b9bK9vPRck7zWpLr4qlxF04s+4U1x71x/Xn3t997orvPuqP6899hTv5bxd7ogdBFhQqVMjc9U/dWyAyMvKGXgVWQUFB5oHrxo0blyIHgfVZu8gXKFCAaroJrafk9af0WesVSO7E5asmOKBpCduWLELlAAAA4KaYxSALAgMDzbSGK1deT/plpe+bNm2alUN5LU2kpwn19I63ThOpz5q4kASFWa8/X9/rv7733HMP9YcbrDwaaZ7rFc4vhYMJUgIAAODm6EGQRTqWpE+fPlK/fn0zzGDOnDlmisPBgwdn9VBe3cgl4/6t15+OOdIxXTre69q1aybgAlitOHbaPHcolXbvJgAAACA1AgRZ1LNnTzl37pzp6n3y5EmpUaOGLFu2TMqUKZPVQwG3pFOnTiafxdGjR+XLL7+Uhx9+mBqFcTk+QdadOGtetyNAAAAAgExiiEE2PPnkk/LPP/+Y5IM67aEmjgNymubDeOyxx8zrmTNn8gHA5tcTZyU2KUnKhIZI5Xx5qBkAAAA4JkDw0EMPmW71+/bty+quAOxs4MCB4u/vb2bW2L59O/ULY/nR68ML2pcMNwktAQAAAIcECPLkyWPmdqxSpYoUL17czNk4a9asNKf4A+BYxYoVk3vvvde81t9DIDExUVZa8w+UJv8AAAAAHBggmD17tgkGnDhxwgQKwsLC5N133zXz2GtjBUDOeuKJJ8zzp59+KpcuXaL6vdyff/4p567FSd4Af2kUztShAAAAyIEcBKGhoZI/f37zyJcvn+nmXLRo0eweDkA23XHHHVKpUiWJiYmRhQsXUo9eTme3UHeWLCIB/06FCQAAAGRGlv96HDFihDRu3FgKFSokL7/8ssTFxcmoUaPk9OnTsmXLlqweDsAt0jHm1mk2NVmhxWKhTr3Yt99+a57bM3sBAAAAHD3N4ZtvvimFCxeWcePGyT333CNVq1bN6iEA2Fm/fv3kpZdekm3btskff/xhgnjwPhEREbJr1y7x8/GRO0sUdnZxAAAA4Ok9CLSXwOjRo804V53eT4cV9OzZ09y53L17t2NKCSBDBQoUML+HiikPvZd1eIHmHsgXFOjs4gAAAMDTAwS1a9eWZ599Vr766is5c+aMLF++XEJCQsyyGjVqOKaUADKdrHDx4sVy7tw5asyLhxd0YHgBAAAAcmKIgbUXwS+//GIea9eulejoaKlTp45JlgbAORo2bCi33367+f2cN2+eDBs2jI/Ci0RFRcmaNWvMa/IPAAAAIEd6EOisBdoQWbBggVSsWFHmz58v58+fl7/++svkJwDg/GSFs2bNkqSkJD4KL/Ljjz9KQkKCyQtTLm9uZxcHAAAA3tCDQOda19wDefPmdUyJAGRb7969Zfjw4bJ//375+eefpW3bttSml+Uf6NKli0jk384uDgAAALyhB0Hnzp1twYFjx47J8ePHHVEuANmQJ08e6dOnj60XAbyD9hxYtmzZ/wcIAAAAgJwIEGi35VdeeUXCwsKkTJkyUrp0acmXL5+8+uqrdGkGXChZ4f/+9z85ceKEs4uDHLB+/Xq5cOGCFCxYUJo0aUKdAwAAIGcCBDrF4fvvvy+vv/66SYa2efNmmTRpkrz33nsyZsyY7JUCgN3obCLNmzeXxMRE+eijj6hZL5q94O677xY/Pz9nFwcAAADeEiDQ7OgffvihuUtZq1YtM+3hk08+KR988IHMnTvXMaUEkCXWZIVz5swx3c/huSwWiy1A0LVrV2cXBwAAAN4UINAZC6pUqXLDcl2m6wA43/333y+FChUyeUKWLl3q7OLAgfbu3SsHDhyQwMBAad++PXUNAACAnAsQaI8BHWKQmi7TdQCcLygoSAYMGGBek6zQO2YvuOOOOyQ0NNTZxQEAAIA3TXM4ZcoUM8511apVJhmWzr2+YcMGOXr0qC2LNgDne/zxx+XNN9+U5cuXy6FDh+S2225zdpHgANbhBcxeAAAAgBzvQdCqVSvZt2+fdOvWTS5evGiGFXTv3t10c23RosUtFwiAfZQvX146dOhgxqhrLgJ4nrNnz5oArSJAAAAAgBzvQaCKFy8uEydOvOWTA3B8skLtQaCzGUyYMMEMPYDn0F5bOvWsDu/SKWcBAAAAhwcItm/fnukD6swGAFxD586dpWTJkiZZ4ZIlS6R3797OLhIckH+A2QsAAACQYwGCOnXqmFwD2lU5I7qNzr0OwDX4+/vLo48+KuPGjTPJCgkQeI7Y2Fj58ccfzWuGFwAAACDHAgQRERF2ORmAnDdw4EB55ZVXZO3atbJz506pUaMGH4MHWLNmjcTExEixYsWkXr16zi4OAAAAvCVJoSYkzJs3r5QpU0bmzZsnhQsXNq/TegBwLSVKlJB77rnHvJ49e7aziwM7z16gw0h8fbOcbxYAAAC4Qab+qty9e7dcvnzZvNZEZ3rXCoB7JStU8+fP5/fXA+hwL/IPAAAAwGk5CAYMGCDNmzc3f5i+9dZbkidPnjS3HTt2rL3LCOAWtWnTRipUqCAHDhyQzz//3OQlgPvSxLFHjhyR4OBg89kCAAAAORYgmDt3rkly9v3335tEhD/88INJfpaariNAALge7YKuvQiGDx8uM2fOlEGDBpnfV7gna++Bdu3amSABAAAAkGMBgsqVK8uiRYtsDY2ffvpJihQpYpcCAMgZ/fv3l9GjR8uWLVtk48aN0rBhQ6rezfMPMHsBAAAA7CnLma2SkpIIDgBuqGDBgtKjRw/zWnsRwD2dPHnSBHisCQoBAAAAeyH1NeCFyQq1R9CFCxecXRxkgw71UtoDpGjRotQhAAAA7IYAAeBFmjRpIrVq1ZJr166ZKUvhfpi9AAAAAI5CgADwIpqY8IknnjCvZ82aZWYlgfu4cuWKrFy50rwm/wAAAADsjQAB4GUeeughM03p3r175ZdffnF2cZAFmiBWe3+UKVNGatasSd0BAADANQIEcXFxcuzYMTMXd/IHANcWGhoqDz/8sHlNskL3nb2AaSoBAADg9ADB/v37pUWLFmbubb2LVa5cOfMoW7aseQbgPskKv/76azl16pSzi4NMziBjTVDYtWtX6gwAAAB255+dudT9/f3NH6rFihXjLhbghmrXrm0SFv7222/y0UcfyejRo51dJNzEX3/9ZYI52gOkVatW1BcAAACcHyDYunWrbNq0SapUqWL/0gDIMZqsUAMEc+bMkZEjR4qfnx+17wazF9x1110SGBjo7OIAAADAA2V5iEG1atXk7NmzjikNgBzzwAMPSIECBUzukB9++IGad6P8AwAAAIDTAgTR0dG2xxtvvCEvvviiyX5+7ty5FOv04Wg6xEGTcyV/NG7c+Kb7LVmyxAQ3goKCzLOOvU5txowZJo9Crly5pF69erJ27doU63VKuPHjx0vx4sVNDobWrVvLrl277PrzATlFr/MBAwaY1yQrdG2HDx+W7du3i6+vr3Tq1MnZxQEAAIA3Bwjy5csn+fPnN4927drJ77//Lm3atJEiRYrYllu3yQnaxfbkyZO2x7JlyzLcXrtR9+zZU/r06SPbtm0zzz169JA//vjDts3ixYtlyJAhZiz2li1bTCLGjh07ppiZYcqUKTJ16lR5//33ZePGjVK0aFFTH5cuXXLozws4yuOPP26etQfBP//8Q0W7+PCCZs2aScGCBZ1dHAAAAHhzDoLVq1eLK9FeANo4z6xp06aZhvyoUaPMe31es2aNWf7555+bZdrwHzhwoAwaNMi2z/Lly82d1cmTJ5veA7pMAwjdu3c328ybN0/Cw8Nl4cKFtoYW4E4qVqwobdu2lVWrVplcBJMmTXJ2kZBBgIDZCwAAAOD0AIGrZczW4Q3ae0F7LWjZJk6caN5n1INg6NChKZZ16NDBNPhVXFycSbyoidqSa9++vWzYsMG8joiIMBnEdVnyQIWeX7dJL0AQGxtrHlY5MQwDyGqyQg0Q6GwGOoSGBHiuRb8zrEFa8g8AAADApWYx+PHHHyVPnjzSvHlz83769OnywQcfmHH9+trRwwy0278mVytTpoxptI8ZM0buvPNO08DXBntatGGvd/qT0/fW+d816WJiYmKG21if09pGxwenR3sfTJgwIZs/LeB42ujUKUt1uI7m5tDhOHAdK1askPj4eKlUqZJUrlw5U/uEf3K9xwGyh/q7NdQf9ecsXHvUnzNx/VF/XjuLwQsvvGC7C75jxw4ZNmyYSZp16NAh89qeFixYYIIR1ocmDdTGy9133y01atQwDRsdO71v3z5ZunRphsfSZIbJ6ZCB1MvstU1yOpwhKirK9jh69OhNf24gJwUEBMijjz5qXpOs0PUwewEAAABctgeB3rXX3gLWmQG0ka7jljdv3mz37No63rZRo0a29yVKlLhhG73zqb0J9u/fn+5xNF+BtQeAVWRkpK03QKFChcwc8BltY815oNvoOdPaJi3aqyG9ng2Aq9DcG6+99prJzbF7926pWrWqs4sEEUlISLAlYSX/AAAAAFyuB4GOT75y5Yp5reOWrWPydT51e4+vDw0NlQoVKtgeOrVgajrVot6VT95oT61JkyaycuXKG7rtNm3a1PYz6bSGqbfR99ZtdPpDDRIk30ZzF2iDyroN4K5KlSplG98+a9YsZxcHyfKn6HecDt3iewYAAAAuFyDQ3AM6lODVV1+VP//803T3V9rNv2TJkuJIMTExMnz4cPNHs07JpskKtVGjPQC6deuW7n7PPfecCQi88cYbsmfPHvOswQ2d1tBKf6YPP/xQPv74Y3MHVZMa6hSHgwcPNut1GIFur70ldJz2zp07pX///hISEiK9e/d26M8N5FSyQuvsHJcvX6bSXWj2Av2e9ffPcocvAAAAwLEBgvfff9/8ofrll1+a8crWbv+aC+Cuu+4SR9JhAJr34J577jEJu/r162eeNWCgvQ2stOHeunVr23u987Zo0SL55JNPpFatWjJ37lxZvHhxiuELmttAZzV45ZVXpE6dOvLrr7+arr06fMHqxRdfNEGCJ598UurXry/Hjx83gYfk5wbclU4Fetttt5lcGfr7AdcJEDB7AQAAAHKCj0Wz7HkYDQ7oQ6dsczU6DCMsLMw0wvLmzevs4gApTJkyRUaMGGECYBs3bnRq7ZwecH3Ig7dmM9a8KhoA1SSSZ86cMd8bAAAAgEv1IEju6tWrpsGb/OFsly5dkoMHD5qhCACyZsCAASYnx19//WUecH7vgVatWhEcAAAAgGsGCHRs8tNPPy1FihQxUw9q8qzkD2fT7v6atFDLBiBrChcuLPfff795TbJC15jekNkLAAAA4LIBAh2H//PPP8uMGTPM9H2a2G/ChAlSvHhxmT9/vmNKCSDHkxUuXLhQLl68SM07wfnz52XdunXmNfkHAAAA4LIBAu32qsEBvcuoyQpbtGghL7/8ssnuv2DBAseUEkCOadasmVSvXt0MIfr000+peSfQpK+JiYlSs2ZNKVu2LJ8BAAAAXDNAoHe2ypUrZ15rkj19b53+UDP/A3BvOqWntReBzlTigXlMXR6zFwAAAMAtAgQ6Ddo///xjXlerVk2++OIL2x+0+fLls38JAeS4Pn36SO7cuWX37t2ydu1aPoEcFBcXZ3oQKPIPAAAAwKUDBJrlfNu2beb1qFGjbLkIhg4dKi+88IIjygggh2nvoN69e9t6ESDnaEBGZ4QJDw+XBg0aUPUAAADIMf5Z3UEDAVZ33HGH7Nmzx0yHVr58ealdu7a9ywfASXSYwQcffCBLliyR06dPmwYrcm72gs6dO4uv7y3NRAsAAABkyS3/9Vm6dGnp3r07wQHAw9x+++3SsGFDiY+Pl08++cTZxfEKmu+B/AMAAABw+QCBTm2oOQe062tqUVFRJus5Y5UBz2JNVjh79myTVR+OtWvXLomIiJBcuXJJ27ZtqW4AAAC4ZoBg2rRp8uijj5qxyamFhYXJ448/LlOnTrV3+QA4Uc+ePU3yUU1Munz5cj4LB7P2HmjTpo1JEgkAAAC4ZIBAExPedddd6a5v3769bNq0yV7lAuACgoODpX///ub1rFmznF0cr8k/0KVLF2cXBQAAAF4o0wECTVIWEBCQ7np/f385c+aMvcoFwEUMHjzYPC9dulSOHDni7OJ4LP2O/eOPP2wJCgEAAACXDRCUKFFCduzYke767du3S7FixexVLgAuonLlymbGkqSkJDOrARxDAzCapLBevXrm+xYAAABw2QBBp06dZOzYsXLt2rUb1l29elXGjRvHXS/Aw5MVfvjhh2ZWAzgu/0DXrl2pXgAAADiFj0VvWWWy+2vdunXFz89Pnn76aXNX0cfHR3bv3i3Tp083Gc43b97MXOk3obNAaFJHnfkhrYSPgCvSoIBOaXrq1Cn54osv5IEHHnD4OU8PcO9x+OGfXG/wZ4YGXgsWLChXrlwx36M6xSQAAADgsj0IwsPDZcOGDVKjRg0ZNWqUdOvWTe6991556aWXzLL169cTHAA8lOYfGThwoHlNskL702lkNThQsmRJqVOnjgPOAAAAANgxQKDKlCkjy5Ytk7Nnz5pkWr///rt5rcvKli2blUMBcDOPPfaY+Pr6msbs3r17nV0cj529QHtmAQAAAC4fILDKnz+/NGjQQBo2bGheA/B8OsRAc5Go2bNnO7s4HkNHeZF/AAAAAG4bIADg3ckK586da5KT4tZpzoETJ05I7ty5pXXr1lQpAAAAnIYAAYBM69ChgxlOdOHCBVm8eDE1ZwfW3gNat7ly5aJOAQAA4DQECABkms5iorkIFMkK7Z9/AAAAAHAmAgQAsuSRRx4xsxpootItW7ZQe7fg2LFjpg41MeHdd99NXQIAAMCpCBAAyBKd8rR79+7mNb0I7DO8oEmTJlK4cGGuRAAAADgVAQIA2U5WuGDBAomOjqYGs4nZCwAAAOBKCBAAyLKWLVtK1apV5fLly/Lpp59Sg9kQExMjP/30k3lN/gEAAAC4AgIEALJMx8wPHjzYNszAYrFQi1m0cuVKiYuLk/Lly5tgCwAAAOBsBAgAZEvfvn0lJCREdu7cKevXr6cWb2H2Ag24AAAAAM5GgABAtuTLl0969eplXs+cOZNazILExERZunSped21a1fqDgAAAC6BAAGAbLMOM/jyyy/lzJkz1GQm6RSRWl9hYWHSvHlz6g0AAAAugQABgGyrX7++eehY+k8++YSazOLsBZ06dZKAgADqDQAAAC6BAAEAu/QimD17tiQlJVGbWcw/AAAAALgKAgQAbsmDDz5ousofOnTIZOZHxg4ePCh///23+Pv7y1133UV1AQAAwGUQIABwS3Lnzi39+vUzr0lWmPnhBS1atJD8+fNz9QEAAMBlECAAcMsef/xxW+P32LFj1GgmAgTMXgAAAABXQ4AAwC2rVq2atGrVyuQg+OCDD6jRdFy8eFF+/fVX85r8AwAAAHA1BAgA2DVZoQYI4uPjqdU0/Pjjj5KQkGACKuXLl6eOAAAA4FIIEACwi+7du0uRIkXk5MmTtm70SInZCwAAAODKXCpA8NVXX0mHDh2kUKFC4uPjI1u3br1hm9jYWHnmmWfMNpocTcfxZmbM84wZM6RcuXKSK1cuqVevnqxduzbFeovFIuPHj5fixYtLcHCwtG7dWnbt2mWXcwPeIDAwUAYOHGhek6zwRtqr4ocffjCvyT8AAAAAV+RSAYLLly9Ls2bN5PXXX093myFDhsjXX38tixYtknXr1klMTIx07txZEhMT091n8eLFZr/Ro0fLli1bTPbwjh07ypEjR2zbTJkyRaZOnSrvv/++bNy4UYoWLSrt2rWTS5cu3dK5AW/y2GOPmeDeqlWrZP/+/c4ujkvR7wzNQaABxkaNGjm7OAAAAIBrBwj69OkjY8eOlbZt26a5PioqSj766CN5++23zTa33367fPbZZ7Jjxw7TIEmPNvz1zuagQYOkatWqMm3aNClVqpTtLqf2HtBlGkDQbtI1atSQefPmyZUrV2ThwoW3dG7Am5QtW9YE39Ts2bOdXRyXYh12oUFFPz8/ZxcHAAAAcO0Awc1s2rTJdNNt3769bZkOCdAG/YYNG9LcJy4uzuyXfB+l7637REREyKlTp1JsExQUZLKyW7fJzrmtwxKio6NTPABvSFb4ySefyLVr15xdHJegQUjyDwAAAMDVuVWAQBvxOs45f/78KZaHh4ebdWk5e/asGQKg26S3j/X5Zttk9dxq8uTJEhYWZntozwXAk3Xq1ElKly4t58+fl//+97/OLo5L2LNnjxw8eNB8h6QOVgIAAADi7QGCBQsWSJ48eWyP1EkDs3p3Tsc9ZyT1+rT2ycw2WT33qFGjzPAE6+Po0aMZHg9wd9p9XnMRKJIVphxecOedd5rvOwAAAMAVOS1AoFm8dZYC66N+/fo33UcTB+qQgQsXLqRYHhkZecPdfytNCKYNltR3+ZPvo8dVN9smq+e2DlXImzdvigfg6TTnh7+/v/z222+ybds28XbW4QXMXgAAAABX5rQAQWhoqFSoUMH20KkFb0anJwwICJCVK1falumc6zt37pSmTZumuY926dX9ku+j9L11H53+UAMAybfRYMCaNWts22Tn3IC30t+nbt26mdezZs0Sb3bmzBkTKLEmKAQAAABclb+4EB2zrFMPnjhxwrzfu3evrbGhDx3Dr3cmn3/+eSlYsKAUKFBAhg8fLjVr1kx35gM1bNgwM0OC9lJo0qSJzJkzx5zHmkxNhwjoFIaTJk2SihUrmoe+DgkJkd69e5ttsntuwFvp75fmINDZPnQaUQ0KeqNly5ZJUlKSmfmEHCQAAABwZf6u1g13wIABtvcPPvigeR43bpyMHz/evH7nnXdM1+UePXrI1atXpU2bNjJ37twU04a1bt3aTLemy1XPnj3l3Llz8sorr5i7/jrzgP7RXqZMGds+L774ojnek08+aYYR6DzlK1asSNGoycy5AVx3xx13SOXKlU2gT3OOWANy3pp/oEuXLs4uCgAAAJAhH4tm2fMwGhzQgEL//v3F1eg0h9obQRMWko8Anm7atGkydOhQqVWrlsk1crOkn8mdHuDeDerwT74z05xqHpSYmBj566+/zFAlAAAAwFW51TSHmZ1OTO/69+3b19lFAbye/h7mypVLtm/fLr///rvX1ccvv/xiggPFixeXunXrOrs4AAAAgHcFCKpUqSI7duwQX1+P+9EAt6O5OqxDhbxxykPr7AU6vCArvScAAAAAZ6AVDcChrLkHvvjiC5MLxFvo6C3yDwAAAMCdECAA4FANGzY0Gfx1PL41cag32LZtmxw9etTMhnLnnXc6uzgAAADATREgAOBQ2rX+iSeeMK9nzZplpvzzBtbeA+3atZPg4GBnFwcAAAC4KQIEAByuV69eJnnogQMH5Oeff/aq/ANdu3Z1dlEAAACATCFAAMDh8uTJY5tZxBuSFZ66cs1Ma6i9J+6++25nFwcAAADIFAIEAHI0WeE333wjx48f9+haX3n0tHlu1KiRhIeHO7s4AAAAQKYQIACQI2rUqCHNmzeXxMRE+eijjzy61lf8GyDQ6Q0BAAAAd0GAAECOsSYrnDNnjiQkJHhkzV9JSJS1J8+a1+QfAAAAgDshQAAgx9x3331SqFAhM8Rg6dKlHlnza0+ckWuJSVK2bFmpXr26s4sDAAAAZBoBAgA5JigoSB555BGPTla4/N/hBdp7QJMUAgAAAO6CAAGAHPX444+b5+XLl8vBgwc9qvaTLBZZeTTSvCb/AAAAANwNAQIAOeq2226TDh062HIReJKtZy/KmWuxEhrgLy1btnR2cQAAAIAsIUAAwGnJCj/++GOJjY31uNkL7ihRWAIDA51dHAAAACBLCBAAyHF33323lCxZUs6ePStffvmlx+UfaF8q3NlFAQAAALKMAAGAHOfv7y+PPvqoeT1r1iyP+ASOXLoiuy9cEj8fH2lTsoiziwMAAABkGQECAE4xaNAg8fPzk3Xr1smOHTvc/lNYcex674EGRfJL/iCGFwAAAMD9ECAA4BTFixeXe+65x7yePXu2238KK/8dXtCB4QUAAABwUwQIADg9WeH8+fMlJibGbT+JS3HxsuHUOfOa/AMAAABwVwQIADjNnXfeKRUqVJBLly7JwoUL3faTWH3ijMQnWaRC3txSPiyPs4sDAAAAZAsBAgBO4+vrK4MHD7YlK7RYLG75aaw4cn14QTuGFwAAAMCNESAA4FT9+/eXoKAg2bJli/z5559u92kkJCXJT8cjzesOpZneEAAAAO6LAAEApypYsKD06NHDbac83Bh5QS7Exkv+oACpXzi/s4sDAAAAZBsBAgAuk6xw0aJFcv78eXEnK/6dvaBNySLi78tXKgAAANwXf80CcLrGjRtLrVq15Nq1azJv3jxxxwABsxcAAADA3REgAOB0Pj4+tl4E7pSs8EBUjByMviwBvj5yR/HCzi4OAAAAcEsIEABwCQ899JDkyZNH9u3bJ6tXrxZ36j3QtGhBCQ0McHZxAAAAgFtCgACASwgNDZWHH37YvJ45c6a4A4YXAAAAwJMQIADgMgYPHmye//e//8npK9fElZ2/Fid/Rl5PqEj+AQAAAHgCAgQAXEbt2rWlSZMmkpCQIAv3HxVX9vPxSEmyiFTLHyql8oQ4uzgAAADALSNAAMClWJMVfrbvsCRqC9xFLWf2AgAAAHgYAgQAXMoDDzwgBQoUkOOXr8lPxyPFFcUlJsnq42fMa4YXAAAAwFMQIADgUnLlyiUDBgwwr+fu+Udc0e+nz0lMfIIUCQ6SOoXyObs4AAAAgF0QIADgch5//HHzrHfpD1+6Iq46vKBdySLi6+Pj7OIAAAAAdkGAAIDLqVixorQsVkgs/+YicCUWi4XpDQEAAOCRCBAAcEn9qpQxzzqbgY75dxV7Ll6SozFXJZefr7QoXtjZxQEAAAA8M0Dw1VdfSYcOHaRQoULi4+MjW7duvWGb1q1bm3XJHw8++OBNjz1jxgwpV66cGd9cr149Wbt27Q13BcePHy/FixeX4OBgc55du3al2CY2NlaeeeYZU77cuXNL165d5dixY3b4yQGkpsn/ioYEyblrcbLs8EmXqaAV/w4vaFGskIT4+zm7OAAAAIBnBgguX74szZo1k9dffz3D7R599FE5efKk7TF79uwMt1+8eLEMGTJERo8eLVu2bJEWLVpIx44d5ciRI7ZtpkyZIlOnTpX3339fNm7cKEWLFpV27drJpUuXbNvoMb7++mtZtGiRrFu3TmJiYqRz586SmJhoh58eQHIBvr7Su2Jp83ruXtcZZrD8yPUAQYfS4c4uCgAAAOC5AYI+ffrI2LFjpW3bthluFxISYhrw1kdYWFiG22vDf+DAgTJo0CCpWrWqTJs2TUqVKiUzZ8609R7QZRpA6N69u9SoUUPmzZsnV65ckYULF5ptoqKi5KOPPpK3337blO/222+Xzz77THbs2CGrVq2yYy0AsHq4Umnx8/GR30+fl70X/z9Y5yyRV67JlrMXzet2JQkQAAAAwLO4VIAgsxYsWGC6+VevXl2GDx+e4i5/anFxcbJp0yZp3759iuX6fsOGDeZ1RESEnDp1KsU2QUFB0qpVK9s2eoz4+PgU2+hwBA0mWLdJiw5LiI6OTvEAkDnFcwdL+1JFzOv5LtCLYNWxSJM4sU6hMAkPyeXs4gAAAADeHSB46KGH5PPPP5dffvlFxowZI0uWLDF3/dNz9uxZMwQgPDzl3T59r0EBZX2+2TaBgYGSP3/+dLdJy+TJk00PB+tDey4AyLy+la8nK/zvgWNyOT7BJfIPaH4EAAAAwNP4OrMXQJ48eWyP1EkDM8o/oF389c69Jif88ssvTRf/zZs3Z7ifJjNMTocVpF6WmW1Su9k2o0aNMsMTrI+jR49meDwAKbUqXljKhIZIdHyCfBNxwmnVczUhUdacOGNedyhV1GnlAAAAADwuQKAzAOgsBdZH/fr1s3WcunXrSkBAgOzfvz/N9ToUwc/P74a7/JGRkbYeA5rHQN1sGx2ucOHChXS3SYsOVcibN2+KB4DM8/XxkT6VnJ+scN3Js3I1MUlK5M4l1fKHOq0cAAAAgMcFCEJDQ6VChQq2h04tmB06FaHmBihWrFia63VYgE5ruHLlyhTL9X3Tpk3Na53+UAMAybfRYMCaNWts2+gxNBCRfBudQWHnzp22bQA4xoMVS0mgr69sPxclW/9NEujM4QU361kEAAAAuCN/cSHnz583Uw+eOHG9G/HevXvNs3W2goMHD5qhCZ06dTI9A/7++295/vnnzYwCOj1ieoYNG2ZmSNBeCk2aNJE5c+aY8wwePNis1z/2dQrDSZMmScWKFc1DX+tsCb179zbbaP4AnQlBz1ewYEEpUKCASZBYs2bNm866AODWFMoVJF3KFpMlh47LvL2HpU6hfDlapUkWi6w8Rv4BAAAAeDaXChB8++23MmDAANt7zTGgxo0bJ+PHjze9AX766Sd59913JSYmxiT8u/vuu816HUZg1bp1aylbtqzMnTvXvO/Zs6ecO3dOXnnlFXPXX/MXLFu2TMqUuZ78TL344oty9epVefLJJ80wgkaNGsmKFStMTwerd955R/z9/aVHjx5m2zZt2phzJD83AMclK9QAwf8OHZdx9atKvqDAHKtq7blw6kqs5Pb3k6ZFC+bYeQEAAICc5GPRLHseRoMDGlDo37+/uBqd5lB7I2jCQvIRAOk7PaBLivf6VXXHN7/KnouX5LWG1WVQtXI5Vn1TtuyVqdv2y91lispHd2QuX0r4J985vFwAAACAV09zeDN79uwxd/379u3r7KIAsCMdCmSd8lCHGeRkbNOaf4DZCwAAAODJPC5AUKVKFdmxY4f4+nrcjwZ4vQfKl5AQfz/ZHxUjv50+nyP1cfzyVdl5Plp8fUTalCzi9Z8BAAAAPBetaABuIzQwQO67rYR5PW/P4RztPdCgcAEpmCvn8h4AAAAAOY0AAQC3Yh1msOzISTlzNTbHAgTtStF7AAAAAJ6NAAEAt1KzYJjULZRP4pMs8vn+ow49V0x8gqw/ec68Jv8AAAAAPB0BAgBu24tg/t7DkpjkuGSFa06ckbikJCkXGiIVwnI77DwAAACAKyBAAMDt3FOuuOQLDJBjl6/K6hORDjvP8iPXhxe0L13UzKIAAAAAeDICBADcTrC/n/SsUNKhyQq1Z8KqY9eDD+2ZvQAAAABegAABALfU599hBtqIPxpzxe7H33TmgpyPjTM9FRqGF7D78QEAAABXQ4AAgFuqEJZHmhcrKJqBYMG+Iw6bveDOkoUlwJevSgAAAHg+/uoF4PbJChfsOypxiUl2PfbyfwME7UsVtetxAQAAAFdFgACA2+pYuqgUCQ6SM9di5cejp+x23Ijoy7I/Kkb8fXzkzhKF7XZcAAAAwJURIADgtrTr/0MVS9s9WaF1eEGTogUlb2CA3Y4LAAAAuDICBADc2kOVSouvj8j6U+dk/8UYuwYI2pcqYpfjAQAAAO6AAAEAt1YyT7C0LRluXn+679Z7EVyMjZPfT583r9uXun5cAAAAwBsQIADg9vpWvj7MYPGBY3IlIfGWjrX6+BlJtFikcr5QKROa204lBAAAAFwfAQIAbu+O4kWkVJ5giYqLl28iTthp9gKGFwAAAMC7ECAA4Pb8fH2kb6XrUx7O35v9YQbxSUny87FI87oD0xsCAADAyxAgAOARHqxYSgJ8fWTL2Yuy/VxUto7xx+nzEh2fIAVzBcrthfLZvYwAAACAKyNAAMAjFA4OkrvLFLulXgTW2QvalQw3vRIAAAAAb0KAAIDH6Ff5+jCDJYeOS3RcfJb2tVgs5B8AAACAVyNAAMBjNA4vIJXy5ZGrCYny34PHsrTvvqgYOXzpigT5+kqr4oUdVkYAAADAVREgAOAxfHx8pO+/vQjm7z1iegVk1ooj14cXNCtWUHIH+DusjAAAAICrIkAAwKM8cFtJCfb3k70XL8kfkeczvd+KY9cDBMxeAAAAAG9FgACARwkLCpBu5YpnKVnhmaux8lfkBfO6XakiDi0fAAAA4KoIEADw2GSF3/9zSs5ei73p9j8dixQdjFCrYJgUzx2cAyUEAAAAXA8BAgAep3ahfFK7YJjEJSXJ5/uP3nT7lf8OL2hXkt4DAAAA8F4ECAB4pH5Vrvci+HTvEUnKIFnhtYREWX38jHndoXTRHCsfAAAA4GoIEADwSPeULS55A/zlSMwV+eXfAEBaNpw6J1cSEqVYSC6pWSBvjpYRAAAAcCUECAB4JJ2qsEeFkjdNVrj86L/DC0qFm2kSAQAAAG9FgACAx+r7b7JCncLw+OWrN6y3WCyy8t8AQXtmLwAAAICXI0AAwGNVyhcqTcILSJJF5LN9R25Yv/N8tJy4ck2C/f2kedFCTikjAAAA4CoIEADwaP2qlDXPC/cdkfikpBTrVvzbe6B18UKSy9/PKeUDAAAAXAUBAgAerVPpolIoV6Ccvhory49cDwikzj/QvhSzFwAAAAAECAB4tEA/X+ldsbR5PS9ZssKTl6/K9nNRomkJ25Ys4sQSAgAAAK6BAAEAj/dwpdImELD25Fk5GBVjlq08Fmme6xXOL4WDg5xcQgAAAMD5CBAA8HilQ0Pkzn97Ccz/N1mhNf9A+1LhTi0bAAAA4CoIEADwCv3+nfLwiwNH5fy1OFl74qx5T4AAAAAAcLEAQXx8vIwYMUJq1qwpuXPnluLFi0vfvn3lxIkTKbaLjY2VZ555RgoVKmS269q1qxw7duymx58xY4aUK1dOcuXKJfXq1ZO1a9feMB/6+PHjzXmDg4OldevWsmvXLrucG4DztSlRRErkDpYLsfHywm/bJTYpSUrnCZHK+fI4u2gAAACAS3CZAMGVK1dk8+bNMmbMGPP81Vdfyb59+0wjPLkhQ4bI119/LYsWLZJ169ZJTEyMdO7cWRITE9M99uLFi81+o0ePli1btkiLFi2kY8eOcuTI/8+LPmXKFJk6daq8//77snHjRilatKi0a9dOLl26dEvnBuAa/Hx9pE+l68kKlx4+ZZ5j4uNl2ZHrrwEAAABv52PRW+cuShvqDRs2lMOHD0vp0qUlKipKChcuLJ9++qn07NnTbKM9DEqVKiXLli2TDh06pHmcRo0aSd26dWXmzJm2ZVWrVpV7771XJk+ebHoPaM8BDQBoLwZrb4Hw8HB544035PHHH8/2uVOLjo6WsLAwc7y8efPaoZYAz3R6QBe7H3PhviMybMN223tNXKhfgB/dUU/uLlPMrucK/+Q7ux4PAAAA8JoeBGnRRrSPj4/ky5fPvN+0aZMZitC+fXvbNtqwr1GjhmzYsCHNY8TFxZn9ku+j9L11n4iICDl16lSKbYKCgqRVq1a2bbJzbmugQYMCyR8AnOPD3REp3lv+DRK8vXUfHwkAAAC8nr+r1sC1a9dk5MiR0rt3b9uddm3EBwYGSv78+VNsq3f6dV1azp49a4YA6Dbp7WN9Tmsb7b2Q3XMr7aEwYcKELPzkABx1B/5QcPANyzRIcOhqPHf8AQAA4PWc1oNgwYIFkidPHtsjedJAvVP/4IMPSlJSkkkueDM6REB7GmQk9fq09snMNlk996hRo0xPCOvj6NGjGR4PgONUqlQpzd/7ypUrU+0AAADwek4LEGjywa1bt9oe9evXtwUHevToYbr9r1y5MsU4fU0cqEMGLly4kOJYkZGRN9z9t9IZB/z8/G64y598Hz2uutk2WT23daiC/gzJHwCcY9y4cSmCevqs73U5AAAA4O2cFiAIDQ2VChUq2B46taA1OLB//35ZtWqVFCxYMMU+Oj1hQECACRxYnTx5Unbu3ClNmzZN8zw6LED3S76P0vfWfXT6Qw0AJN9GgwFr1qyxbZOdcwNwLd27d5clS5ZIrVq1zJSn+qwzpnTr1s3ZRQMAAACczmVyECQkJMj9999vpjj8/vvvTd4A6x39AgUKmIa+Zv8fOHCgPP/88yZ4oMuHDx8uNWvWlLZt26Z77GHDhkmfPn1ML4UmTZrInDlzzBSHgwcPtt1F1BkMJk2aJBUrVjQPfR0SEmJyIKjsnhuA6wUJ9AEAAADARQMEx44dk2+//da8rlOnTop1q1evltatW5vX77zzjvj7+5ueBlevXpU2bdrI3LlzzTACK922bNmyZrnSaQnPnTsnr7zyirnrrzMP6NSEZcqUse3z4osvmuM9+eSTZhiBTo24YsUK09PBKjPnBgAAAADAHflYdACuh9HgwPjx46V///7ianSaQ+2NoAkLyUcAAAAAABBvz0HgKHv27DF3/fv27evsogAAAAAA4DY8sgeBK6MHAQAAAADAFXlcDwIAAAAAAJB1BAgAAAAAAAABAgAAAAAAQIAAAAAAAAAQIAAAAAAAAAQIAAAAAACA4X/9CTnFOqukTncIAAAAAEBOCQ0NFR8fn3TXEyDIYZcuXTLPpUqVyulTAwAAAAC8WFRUlOTNmzfd9T4W6y1t5IikpCQ5ceLETSM3AAAAAADY083aoQQIAAAAAACA+FIHAAAAAACAAAEAAAAAACBAAAAAAAAACBAAAAAAAAACBAAAAAAAgAABAAAAAAAwSFIIAAAAAAAIEAAAAAAAAAIEAAAAAACAAAEAAAAAACBAAAAAAAAADJIUAgAAAAAAAgQAAAAAAIAAAQAAAAAAIECQ8ywWi0RHR5tnAAAAAABcBTkIctilS5ckLCzMPAMAAAAA4CoIEAAAAAAAAAIEAAAAAACAAAEAAAAAABARf2oBAAAAAJBdsQkWSUxy3STsfr4+EuTv4+xieGaA4MiRI1KqVCnx8UlZwZqV/+jRo1K6dGl7lg8AAAAA4MLBgW3HY+VqgusGCIL9faR2iSCCBI4IEJQrV05OnjwpRYoUSbH8/PnzZl1iYmJWDwkAAAAAcEPac0CDAwG+PhLo53p36eMSr5fveg8H1yuf2wcItKdA6t4DKiYmRnLlymWvcgEAAAAA3IQGB1y1G3+8Cw9/cNsAwbBhw8yzBgfGjBkjISEhtnXaa+CPP/6QOnXqOKaUAAAAAADANQIEW7ZssfUg2LFjhwQGBtrW6evatWvL8OHDHVNKAAAAAADgGgGC1atXm+cBAwbIu+++K3nz5nVkuQAAAAAAQA7yzeoOn3zyiQkOHDhwQJYvXy5Xr1619SwAAAAAAABeEiDQ2QratGkjlSpVkk6dOpkZDdSgQYPk+eefd0QZAQAAAACAqwUIhgwZIgEBAXLkyJEUiQp79uwpP/74o73LBwAAAAAAXHGawxUrVpihBSVLlkyxvGLFinL48GF7lg0AAAAAALhqD4LLly+n6DlgdfbsWQkKCrJXuQAAAAAAgCsHCFq2bCnz58+3vffx8ZGkpCR588035Y477rB3+QAAAAAAgCsOMdBAQOvWreWvv/6SuLg4efHFF2XXrl0meeH69esdU0oAAAAAcJDYBIskJjErW3brDl4cIKhWrZps375dZs6cKX5+fmbIQffu3eWpp56SYsWKOaaUAAAAAOCgBu6247FylYZutl2Lt0hooD0/FTiLj8ViIeSTg6KjoyUsLEyioqIkb968OXlqAAAAAKlciUuSjUdjJcDXRwL9fKifbPD1EQlw0brTANDl+CRpUCpIQgKzPMLe62S5B4G6ePGi/PnnnxIZGWnyDyTXt29fe5UNAAAAAHKEBgeC/F2zkQu4bIDgu+++k4ceesgMLQgNDTVJCq30NQECAAAAAADcT5b7WDz//PPyyCOPyKVLl0xPggsXLtgemqgQAAAAAAB4QYDg+PHj8uyzz0pISIhjSgQAAAAAAFw/QNChQwczxSEAAAAAAPDiHAR33323vPDCC/L3339LzZo1JSAgIMX6rl272rN8AAAAAADAFac59PVNv9OBJilMTEy0R7k8FtMcAgAAAK43zWHuAF9mMfBATHPo4B4Eqac1BAAAAAAAXpiDAAAAAAAAeB4CBAAAAAAAIOtDDAAAAAC43jjrxKQspRZDsroD4IIBgsmTJ8tXX30le/bskeDgYGnatKm88cYbUrlyZds2mlNxwoQJMmfOHLlw4YI0atRIpk+fLtWrV8/w2EuWLJExY8bIwYMHpXz58jJx4kTp1q1bim1mzJghb775ppw8edIcb9q0adKiRYtbPjcAAADgyAbutuOxcpWGbrZdi7dIaKA9PxXAPbnUEIM1a9bIU089Jb///rusXLlSEhISpH379nL58mXbNlOmTJGpU6fK+++/Lxs3bpSiRYtKu3bt5NKlS+ke97fffpOePXtKnz59ZNu2bea5R48e8scff9i2Wbx4sQwZMkRGjx4tW7ZsMYGBjh07ypEjR27p3AAAAIAjac8BDQ4E+PqYTPw8sl4HhXP7SYCfDxcqvF6WpzlUehf+k08+Mc/vvvuuFClSRH788UcpVaqUXe+mnzlzxhxbAwctW7Y0d/CLFy9uGvIjRoww28TGxkp4eLjpafD444+neRwNDuj0gj/88INt2V133SX58+eXzz//3LzX3gB169aVmTNn2rapWrWq3HvvvaZnQ3bPnRrTHAIAAMCemKYPSB/THDq4B4E21mvWrGnuvutwgJiYGLN8+/btMm7cOLGnqKgo81ygQAHzHBERIadOnTK9CqyCgoKkVatWsmHDhgx7ECTfR3Xo0MG2T1xcnGzatOmGbfS9dZvsnluDCBoUSP4AAAAAAMDtAwQjR46U1157zQwBCAz8/4E6d9xxh2mI24vesR82bJg0b95catSoYZZpA13pXfvk9L11XVp0XUb7nD17VhITEzPcJrvn1t4HYWFhtof2sgAAAAAAwO0DBDt27LghuZ8qXLiwnDt3zl7lkqefftr0SrAOAUjOx8fnhmBC6mXZ2cde2yQ3atQo0xPC+jh69GiG5QQAAAAAwC0CBPny5TNZ/lPTxH4lSpSwS6GeeeYZ+fbbb2X16tVSsmRJ23JNCqhS37GPjIy84c5+crpfRvsUKlRI/Pz8Mtwmu+fWYQh58+ZN8QAAAAAAwO0DBL179zZJ+rShrHfOk5KSZP369TJ8+HDp27fvLRVG78ZrzwHNbfDzzz9LuXLlUqzX99pQ1+ENVpo/QPMi6JSI6WnSpEmKfdSKFSts++hQiXr16t2wjb63bpPdcwMAAAAA4A78s7rDxIkTpX///qa3gDboq1WrZsbva+Dg5ZdfvqXC6BSHCxculG+++UZCQ0Ntd+t17H5wcLAJSOgsApMmTZKKFSuah74OCQkx50/Pc889Z2ZB0NkG7rnnHnP8VatWybp162zbaL4Dnf6wfv36JqAwZ84cM8Xh4MGDzfrsnhsAAAAAAI+d5lDpFIc6rEB7ENx+++2mwXzLhUlnLL9OqahBCaXFnTBhgsyePVsuXLhgpiecPn26LZGh0m3/+ecf+eWXX2zLvvzySxPAOHTokJQvX94EOrp3757iPDNmzJApU6aYIRR6vHfeeccEFqwyc+6bYZpDAAAA2BPTHALpY5pDBwcItEu9Tu3nylq3bm0e48ePF1dDgAAAAAD2RIAASB8BAgfnIGjXrp2ULl3aTHe4c+dOcTWXLl0yvRs0JwIAAAAAAHBQDoITJ07IokWLzPSD2h1fu9c//PDDZhx+8hkHnEVzFzCVIAAAgHve6UtMytboV/H2egMAp+YgUBERESapoAYL9uzZY8br6+wDSB9DDAAAANJu5G47HitXaexmy7V4ixTO7ScBfmnn9AK8FUMMcjBAoHQGgx9++EHGjBkj27dvN++RPgIEAAAA6Y+jD/D1kUAauVnm6yMEB4A0ECBw8BADq/Xr18uCBQvM7ADXrl2Trl27mmn/AAAAgOzS4ECQP3fBAcAtAgQvvfSSGVKguQjatm0r06ZNk3vvvVdCQkIcU0IAAAAAAOB6AYJffvnFzBDQs2dPKVSokGNKBQAAAAAAXDtAsGHDBseUBAAAAAAAuHaA4Ntvv5WOHTtKQECAeZ0RzUUAAAAAAAA8cBYDX19fOXXqlBQpUsS8TvdgPj7MYnATzGIAAACQ/iwGuQN8SVIIwG6YxcABPQiSkpLSfA0AAAAAADxD+t0B0jF//nyJjY29YXlcXJxZBwAAAAAAvCBAMGDAAImKirph+aVLl8w6AAAAAADgBQECTVmguQZSO3bsmISFhdmrXAAAAAAAwBWnObz99ttNYEAfbdq0EX///981MTFRIiIi5K677nJUOQEAANwiGVZi0k3zPyOdugMAuEmA4N577zXPW7dulQ4dOkiePHls6wIDA6Vs2bJy3333OaaUAAAAbtDA3XY8Vq7S0M22a/EWCQ2056cCAHBIgGDcuHHmWQMBPXv2lFy5cmXpRAAAAJ5Mew5ocCDA10cC/W4cjomb0+BAAHUHAK4fILDq16+fY0oCAADgATQ4EORPgAAA4AUBAs038M4778gXX3whR44cMdMbJnf+/Hl7lg8AAAAAALjiLAYTJkyQqVOnSo8ePcx0h8OGDZPu3buLr6+vjB8/3jGlBAAAAAAArhUgWLBggXzwwQcyfPhwM5NBr1695MMPP5SxY8fK77//7phSAgAAAAAA1woQnDp1SmrWrGle60wG2otAde7cWZYuXWr/EgIAAAAAANcLEJQsWVJOnjxpXleoUEFWrFhhXm/cuFGCgoLsX0IAAAAAAOB6AYJu3brJTz/9ZF4/99xzMmbMGKlYsaL07dtXHnnkEUeUEQAAAAAAOJiPxWKx3MoBNO/Ahg0bTG+Crl272q9kHio6OlrCwsLM0Iy8efM6uzgAAMBOrsQlycajsZI7wJdpDgHARcQmWORyfJI0KBUkIYFZvj/udbI8zWFqjRs3Ng8AAAAAAODhAYJvv/020wf0hl4EM2bMkDfffNPkYqhevbpMmzZNWrRo4exiAQAAAADg2ADBvffem6mD+fj4SGJioniyxYsXy5AhQ0yQoFmzZjJ79mzp2LGj/P3331K6dGlnFw8AgFvuipmYdEujD7267gAA8OocBN6mUaNGUrduXZk5c6ZtWdWqVU0QZfLkyTfdnxwEAABXbuBuOx4rV2noZtu1eIsUzu0nAX4+9vxoAADZRA6CHM5B4E3i4uJk06ZNMnLkyBTL27dvbxI1piU2NtY8kgcIcN2l89ESl6xu4GF8fUUCmPoUcCdxCRaJi7osfolJ4u9LAzc7grXaEn0k3u6fDgAgOxITLeLrq81e/i51SIDglVdeyXD92LFjxVOdPXvWDKEIDw9PsVzfnzp1Ks19tFfBhAkTbljeoEED8fPzk169eslTTz0lzZs3t63T4QpDhw6V5cuXm/cvv/yymSWif//+5n358uXlu+++ky5dusjBgwfNsrlz58qBAwfktddeM+87dOgg77zzjlSrVs123HXr1sn06dPl888/N+/1vLqdNW9E/vz5Zf369dKvXz/ZuHGjWTZ16lTzPGzYMFu5582bZ4ZXXLhwwZajQsuqx1aZ+ZlefOFFCYn3lZcmjTfvS5UoKTPfmCZPjBgiR48fM8smvTRejhw/KrPmfWTeN2vYREY9+7x0fvh+23E/m/GRLPzqC1m26vpxe3XvIc0bNpGnRg417/OG5pWFMz+WkRPHys7df5tlI565/rO88d71n61G1Wry+uhXpPcTj0j0pesBnOmvvyPr/vxNPv/qC/O+U9sO0rt7D3n4yYG2c3//2Zcy+T9vy/o/fzPvB/cbKKVLlOJnsn5OD90nYkkydbPwrXdlwXffyNI1P5v3D3W+R5rXayBPTHj5+ueUJ1QWvf0fGfH267Jj316zbOSjT5jn1z+43lunZqXK8sbzI+XB55+V6JhLZtnMca/Juk0bZcH335j3d7e6Ux7qco/0Hv6c7XNaNvsTmTRnhtlOPfHgw1KmeAkZOfUN8750seIya/xEGTx+tBw5eeL6OYeNkMMnjsvMRZ+Z91rWlx57Ujo9PsB2XH4mPidPvfY+W/qtWMRX2t/ZXu7v+oA8NuRR27kXf/yFTJ0xVf7463fzfsBDj0ipEqXklSnX/58rUbyETH3tHRn28lA5fuK4WTb2xXFy9PhR+WTBx+Z9o/qNZdiTw6TnIz1sx50z7QP58tv/yoqfV5j3999zvzSu30SGj3nevA8NDZUP3/1Ixr8xXnbvvf5dPmTwEPM8bdY081y1cjUZP2K8DHpuoFy6dP1neuvVt+X3v36TL7/50rznZ+Jz4trj94nvCO/8Lte2xvKVK6TLfQ+4bfvpZTu0CfWYdh9icPvtt6d4Hx8fLxEREeLv728KuXnzZvFUJ06ckBIlSpjeAk2aNLEtnzhxonz66aeyZ8+eTPUgKFWqFNMc0oPAs8XFStLh/SJ+/iIBgc4uDYDMio8T36RECbqtokggd1oAAJ7BLzBIgsNCnV0Mz+xBsGXLlhuWaaNXIxndunUTT1aoUCFz1z91b4HIyMgbehVYBQUFmQduFFogL9XioZKuXpHYU77imytYfLj+AbdhifWTpGuXJahAfvENDnF2cQAAQA7ztcdB8ubNa4YejBkzRjxZYGCg1KtXT1auXJliub5v2rSp08oFAAAAAIDLJCm8ePGi6Tbv6XQsSZ8+faR+/fpmmMGcOXPkyJEjMnjwYGcXDQAAAACAnAsQ/Oc//0nxXlMYnDx50ozBv+uuu8TT9ezZU86dO2d6TOjPXaNGDVm2bJmUKVPG2UUDAAAAACDbspyksFy5cine+/r6SuHCheXOO++UUaNGmeyUSJ/mawgLCyNJITw/B8H2jeKbKzc5CAA3YomNvZ6DoFYDchAAAOCFstyDQGcsAAAAAAAAnsUuSQoBAAAAAICX9SC4du2avPfee7J69WozvV9SUlKK9Zs3b7Zn+QAAAAAAgCsGCB555BEzrd/9998vDRs2FB8fH8eUDACAbLDEx4ukCl4jk3WXEEdVAQDgxbIcIFi6dKnJ2t+sWTPHlAgAgFsIDiSePyM+uXJRh9nkExQsPn5+1B8AAF4oywGCEiVKMFMBAMA1JSWZ4EBglVriExjk7NK4JQ0OUHcAAHinLAcI3n77bRkxYoTMmjVLypQp45hSAQBwC7SB6xscQh0CAAA4MkBQv359k6jwtttuk5CQEAkICEix/vz581k9JAAAAAAAcLcAQa9eveT48eMyadIkCQ8PJ0khAAAAAADeGCDYsGGD/Pbbb1K7dm3HlAgAAAAAAOQ436zuUKVKFbl69apjSgMAAAAAANwjQPD666/L888/L7/88oucO3dOoqOjUzwAAAAAAIAXDDG46667zHObNm1SLLdYLCYfQWJiov1KBwAAAAAAXDNAsHr1aseUBAAAAAAAuE+AoFWrVo4pCQAAAAAAcJ8Awa+//prh+pYtW95KeQAAAAAAgDsECFq3bn3DMs09YEUOAgC4dZb4eJGkJKoyq/WWEEedAQAA5FSA4MKFCynex8fHy5YtW2TMmDEyceLE7JYDAJAsOJB4/oz45MpFnWSDT1Cw+Pj5UXcAAACODhCEhYXdsKxdu3YSFBQkQ4cOlU2bNmX1kACA5JKSTHAgsEot8QkMom6ySIMD1BsAAEAOBAjSU7hwYdm7d6+9DgcAXk8bub7BIV5fDwAAAHDRAMH27dtTvLdYLHLy5El5/fXXpXbt2vYsGwAAAAAAcNUAQZ06dUxSQg0MJNe4cWP5+OOP7Vk2AAAAAADgqgGCiIiIFO99fX3N8IJcJNMCAAAAAMB7AgRlypRxTEkAAAAAAIDT+GZ2w59//lmqVasm0dHRN6yLioqS6tWry9q1a+1dPgAAAAAA4EoBgmnTpsmjjz4qefPmTXPqw8cff1ymTp1q7/IBAAAAAABXChBs27ZN7rrrrnTXt2/fXjZt2pTtgsTHx8uIESOkZs2akjt3bilevLj07dtXTpw4kWK72NhYeeaZZ6RQoUJmu65du8qxY8duevwZM2ZIuXLlTK6EevXq3dDbQZMujh8/3pw3ODhYWrduLbt27bLLuQEAAAAA8JgAwenTpyUgICDd9f7+/nLmzJlsF+TKlSuyefNmGTNmjHn+6quvZN++faYRntyQIUPk66+/lkWLFsm6deskJiZGOnfuLImJiekee/HixWa/0aNHy5YtW6RFixbSsWNHOXLkiG2bKVOmmB4Q77//vmzcuFGKFi0q7dq1k0uXLt3SuQEAAAAAcAc+ltTzFaajfPny8tZbb0m3bt3SXK8N+uHDh8uhQ4fsVjhtqDds2FAOHz4spUuXNrkOdMaETz/9VHr27Gm20R4GpUqVkmXLlkmHDh3SPE6jRo2kbt26MnPmTNuyqlWryr333iuTJ082vQe054AGALQXg7W3QHh4uLzxxhtm+ER2z52a5nDQIRl6vLSGawCeIOnqFYndvlF8c+UWn6AgZxfH7VhiYyXp2mUJqtVAfINDnF0cAAAAeIlMz2LQqVMnGTt2rLnznnpKw6tXr8q4cePM3XR70ka0j4+P5MuXz7zXIQw6FEGHM1hpw75GjRqyYcOGNBvpcXFxZr+RI0emWK7H0H2sUzeeOnUqxXGDgoKkVatWZhsNEGTn3NZAgz6s0kryCHgqS0Kcs4vglqg3AAAAuHSA4OWXXza9BCpVqiRPP/20VK5c2TTed+/eLdOnTzfd7LULv71cu3bNNOp79+5tu9OujfjAwEDJnz9/im31Tr+uS8vZs2dN2XSb9PaxPqe1jfZeyO65lfZQmDBhQhZ+csD9+fj5iU9QsFhir4olId7ZxXFLWn9ajwAAAIDLBQi0Iax3yp944gkZNWqU6ZavNEigd881CWDqBnZGFixYYO7MW/3www8mN4DSO/UPPvigJCUlmePejJZFy5GR1OvT2icz22T13FpXw4YNS9GDQIclAJ7MJzBIgqrVFgv5OW4tyBLI8AwAAAC4YIBAlSlTxoy3v3Dhghw4cMA0jitWrHjDXfXM0OSDmhvAqkSJErbgQI8ePUy3/59//jnFOH1NHKhDBvT8yc8ZGRkpTZs2TfM8OuOAn5/fDXf5dR9rQEOPq3SbYsWKpbtNVs9tHaqgD8DbaOM24/AaAAAAALecxSA5bSA3aNDAJBDMTnBAhYaGSoUKFWwPnVrQGhzYv3+/rFq1SgoWLJhiH52eUGdSWLlypW3ZyZMnZefOnek20nVYgO6XfB+l76376PSHGgBIvo0GA9asWWPbJjvnBgAAAADAI3sQOFJCQoLcf//9ZorD77//3uQNsN71L1CggGnoa/b/gQMHyvPPP2+CB7pcZ06oWbOmtG3bNt1jaxf/Pn36SP369aVJkyYyZ84cM8Xh4MGDzXodIqAzGEyaNMn0iNCHvg4JCTE5EFR2z52adWgGyQoBAAAAADlJb9RnOIze4iIiIiK05ZzmY/Xq1bbtrl69ann66actBQoUsAQHB1s6d+5sOXLkSIpjtWrVytKvX78Uy6ZPn24pU6aMJTAw0FK3bl3LmjVrUqxPSkqyjBs3zlK0aFFLUFCQpWXLlpYdO3ak2CYz576Zo0ePpvtz8qAOuAa4BrgGuAa4BrgGuAa4BrgGuAa4BrgGxEF1EBUVlWF71Uf/EQ9TtmxZGT9+vPTv319cjSZePHHixM0jNx7Omqzx6NGjKfJMAFx/8GR894HrD96I7z5w/bmOm7VDXWaIgb3s2bPH/NB9+/YVV+Tr6yslS5Z0djFchgYHCBCA6w/ehu8+cP3BG/HdB64/1+dxAYIqVarIjh07nF0MAAAAAAA8fxYDAAAAAADgWQgQwCmCgoJk3Lhx5hng+oO34LsPXH/wRnz3gevPfXhkkkIAAAAAAJA19CAAAAAAAAAECAAAAAAAAAECAAAAAABAgAAAAAAAABAgAAAAAAAABkkK4RBMjgFn4doDAADwDvzdZ38ECGB3kZGRcunSJdt7fnGRU6KioiQxMZFrD05x4MABWblyJbWPHLdv3z4ZPHiwrF27ltpHjjt69Khs2rRJTpw4Qe0jR9HmcAwCBLCbhIQEGThwoDRs2FDatm0rDz30kJw9e1Z8fHyoZThUfHy8PPXUU9KpUyfzePXVV02ggGsPOWX79u1SqVIl6dWrlxw+fJiKR45ISkqSoUOHSp06deTy5cspgvNATvzf+/jjj0vdunXlkUcekdq1a8v69eupeDgcbQ7HIkAAu/2i9u/fX/7++2+ZN2+e+SNZ/2Du3r277N69m1qGw+gd22rVqsmuXbvkhRdekFKlSsmCBQtk/PjxZj09WJAT4uLipEOHDhIQECBTpkyh0pEjfvjhB9m4caN5/vTTT02A1IrvPjhSTEyM3H///bJ//35ZsWKFfPHFFyZQMGbMGK4/OBRtDscjQAC7OHnypPz555/mLm6rVq3MHQ1tuB06dEhmzpwpp0+fpqZhd9HR0eaPEm2Y6fV27733muvtwQcfNH80X7lyhV4EyBGbN2+W/Pnzm+DUnDlzzPch4Ggffvih6T2g/++uWbPGNM7mzp0rR44c4bsPDqU3hPQGkF5zt99+u1SuXFkeeOABCQ0NNT1b6MEHR6HN4XgECGAX586dk2PHjknjxo3N+9jYWClatKiMGjXKRJZ//fVXahp2p8MImjdvLoMGDTJ3bvWOWWBgoFy7dk2uXr0qISEh3EWDwyS/QxsUFCRlypSRO++8Uxo0aCATJkywBbEAR1x7OpxAh/G1adNGXnvtNRMY3bFjh4wdO9Zch9999x0VD4cOL9C8K/rdp/RanD59uhQvXlw+/vhj838w4Ai0ORyPAAGyTO+OffDBByka/RUrVjQBgc8+++z6heV7/dLSHgUaTdbujxo0AOxx7emdMqV3bPv27WvuoCm9a2FNVnjbbbeZ19zFgKOuP722rNec9iDQLrdKexH8+OOP0rFjR9O7Zc+ePXwIsPu1p/+3aiNNexFoksKvvvpKvvzyS5MDo3z58qaRxrUHR/3d16xZM2ndurUMGDDAfNeFh4ebvwM1SK83h/r162cCVsCt0CF7L730kukdaqW9VfR6o83hQBYgkxYuXGgpUqSIpUmTJpY6depYChcubJk4caJZFxUVZXnxxRctlSpVspw+fdosu3r1qnmeN2+eJV++fLb3gD2vvYSEBNt2SUlJ5rlRo0aWDz/8MMUywJ7X36RJk8y62NhY8/zggw9aVq1aZV5/8MEHluDgYEtAQIDlyy+/pOLhkGtPffTRRxYfHx/zf29kZKRt+a+//mopVqyYZcOGDdQ+HPJ/r4qJibHs37/f0rRpU8tbb71lW75lyxbLbbfdZvniiy+ofWTLggULzPWm194DDzxg/k997LHHzLro6GjaHA5GgACZ/kWtXbu2ZdasWeb98ePHLe+//74ld+7cJjigVq5caWnQoIHlySefTNEwW716tfkPZtu2bdQ27Hrt6X8SqUVERJj/VPbs2WNbdvDgQfOcmJjIJwCHXH/9+vWz9OnTx3wH6vX36quvWvLnz5/ij2bA3v/v7ty509K6dWtLtWrVLCdPnrTtqwH5PHnyWP773/9S6XDod9/mzZstlStXNgEq6999Grjn+w/ZpUF2DUjNnj3bvI+PjzfXowYJLl26ZJbR5nAshhjgZj1MzLN2Y2zUqJHpzq10jJl26y5RooRJVKN0LHjv3r3NLAZff/212UfplDeaZb5mzZrUNux67aU1Q4Z27daZDLQL2pYtW8y+mhtDs95ah74A9rz+dKyt5hpYtmyZmeZVr7uXX35ZRowYYWbW+Oeff6hwOOS7r0qVKjJkyBA5ePCgzJo1S44fP26Wf/vtt+b/3JYtW1LzcOj/vZrrR2cyOHr0qG1In+a/KFeunMmFAWSWdcieXnfDhw83s6Mpf39/OX/+vDz66KOSK1cus6xp06amzaFJWWlzOICDAxBwU5s2bbJcuHDB9v7ixYspunKrrVu3WooWLWo5f/68bZm1209oaKilVatWtm5B06dPN+vp7g1HXXvWa+uZZ56x3H///ZahQ4dafH19LQMHDrRcu3aNiodDv/v+/PNPy65du1Jsp9fdlClT6LkCh1576j//+Y+lePHi5k5ut27dzF3e5F3BAUddf+fOnbP06tXLEhISYhk8eLClb9++5m/AsWPH8jcfMv3dp9dbcsnbCyNHjrT4+/tbqlSpYnoWfPrpp6ZXQVxcnGX48OG0ORzA3xFBB7ivJUuWmLsRmpVWo8eaZEYTDWoyEGt0z3oX9ueffzaJkDRRnM4BrolpNGnSG2+8YbJ479y500xvqMm79C6HImEcHHXtWRPG6Z0zneJLp/3SBEnaewVw1HefJl/VffQ7LzVdrj0IAEf+v6ueeeYZ03tF/7/VO7mvv/66VKpUiYqHw6+/AgUKyEcffWR67kVGRprt/vrrL64/ZPna0x4DTzzxhEl2ab32Fi1aJL///rt8/vnnZrnOjKbbhIWFSZcuXeTNN980PQ5oc9iZI6IOcE8bN2400blp06aZfAEzZswwY2mfeOIJEyG2juHWqJ3SuxRPPfWUk0sNT2Cva08j0JMnT7YsX748x38GuC+++8C1B29k7+8+63aAPa49pflWUl9XpUuXtkyYMIFKdiAG5MI23kwjvjpNl05ZU6tWLROhGzdunBlPO2PGDLONRpH1ofts377dTG2jdIqlXr16mTsXgLOuPY0ojxw5Utq3b8+HgBy//gBnffcBrnD96VhxwF7XntKeydbrSvfVnD6a96JQoUJUtAMRIICt239ERITpEpb8C167+9SrV09++OEH2bVr1/WLxtdXNm7caH5B69ata7oH6S/3uXPnpEiRItQonHLtFS5cmJpHlvDdB2fh2oMzcf3BXa695EOTL168aIYU6PCXe+65xwml9x4ECLzQypUr5dlnn5V3331X/vzzT9vyZs2ayYYNG+TUqVPmfWJiouTOndv8EuovqI77sdJs3TreRzPF6/F0pgJdr+OIAGdce9bMtgDffXA1/L8Lrj94o1v97tNcF4sXLzb5fKpXry6bNm2SmTNnmtk04DgECLzIyZMnTUKPhx9+2EwXoklltCu29RdWX5ctW9YkGUwetWvXrp25c3vgwAHbsQICAkz3Hp1eRKN8GvEDuPbgivjuA9cevBHffXD3a0+HFegNoL1795oggyYsrFq1Kh+sozkywQFcx+XLly39+vWz9OzZ03Lo0CHb8gYNGlj69+9vXut0NvPnzzdTw61fvz7F/g899JCldevWtveRkZE5WHq4M649cP3BG/HdB64/eCN7f/dpokzkLHoQeAkds63d/3V8T7ly5SQhIcEs79y5s+zevdu89vPzkx49epjuPYMGDZI1a9aYyJ12/9m/f7+JAlox3htce3AHfPeBaw/eiO8+eMq1Z51mEznHR6MEOXg+OJHOMapDA5R+7Nqdp0+fPhIcHCxz5syxLbt27ZrJUvv3339LnTp1zHjv0qVLyxdffGHmuQW49uBO+O4D1x68Ed994NpDdhAg8HItW7aURx55xET5NECQlJRkonqnT58209loxngdI9S7d29nFxUehmsPXH/wRnz3gesP3ojvPvdBgMCLHTp0SJo2bSpLly61JRnUbKGBgYHOLho8HNceuP7gjfjuA9cfvBHffe6FQR1eyDqqZN26dZInTx5bcGDChAny3HPPSWRkpJNLCE/FtQeuP3gjvvvA9QdvxHefe/J3dgGQ86xTiehUI/fdd5+Zo/Sxxx6TK1euyKeffipFihThYwHXHjwO333g2oM34rsPXHvICoYYeClNRFizZk05ePCgGVKgvQdGjBjh7GLBC3DtgesP3ojvPnD9wRvx3ed+CBB4sXbt2knFihVl6tSpkitXLmcXB16Eaw9cf/BGfPeB6w/eiO8+90KAwIslJiaaGQsArj14E777wLUHb8R3H7j2kBkECAAAAAAAALMYAAAAAAAAAgQAAAAAAIAAAQAAAAAAIEAAAAAAAAAM3+tPAAAAAADAmxEgAAAAAAAABAgAAAAAAAABAgAAAAAAQIAAAAAAAAAQIAAAAAAAAKL+DwDn5rGa8bABAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ci.plot_cash_flows(\n", + " impl_date,\n", + " start_date,\n", + " end_date,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "4bb73614", + "metadata": {}, + "source": [ + "## Growth rates\n", + "\n", + "Costs and incomes can grow year-over-year using compound-interest factors anchored to `mkt_price_year`.\n", + "\n", + "$$\\text{value}(t) = \\text{base} \\times (1 + r)^{\\frac{t - t_0}{365}}$$\n", + "\n", + "Pass `cost_yearly_growth_rate` and / or `income_yearly_growth_rate` (as decimals, e.g. `0.02` for 2 %)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b69f1ae7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(, )" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ci_growth = CostIncome(\n", + " mkt_price_year=2020,\n", + " init_cost=50_000,\n", + " periodic_cost=5_000,\n", + " periodic_income=8_000,\n", + " cost_yearly_growth_rate=0.02, # costs grow 2% / year\n", + " income_yearly_growth_rate=0.03, # income grows 3% / year\n", + " freq=\"Y\",\n", + ")\n", + "\n", + "ci_growth.plot_cash_flows(impl_date, start_date, end_date)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "067c07aa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " No growth With growth\n", + "Net 36000 -19821\n", + "Cost -60000 -97569\n", + "Income 96000 77748\n" + ] + } + ], + "source": [ + "# Compare totals with and without growth\n", + "no_growth = ci.calc_total(impl_date, start_date, end_date)\n", + "with_growth = ci_growth.calc_total(impl_date, start_date, end_date)\n", + "\n", + "labels = [\"Net\", \"Cost\", \"Income\"]\n", + "print(f\"{'':15s} {'No growth':>12s} {'With growth':>12s}\")\n", + "for label, ng, wg in zip(labels, no_growth, with_growth):\n", + " print(f\"{label:15s} {ng:>12.0f} {wg:>12.0f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "1408d2db", + "metadata": {}, + "source": [ + "## Custom cash flows\n", + "\n", + "For irregular or one-off flows, pass a `pd.DataFrame` with columns `date`, `cost`, and/or `income`.\n", + "\n", + "These are **added on top** of any periodic amounts; dates not present in the DataFrame simply contribute zero." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "c469839c-e2e2-43e9-ac33-93de7f04a6d9", + "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", + "
datenetcostincome
020200.00.00.0
120210.00.00.0
22022-50000.0-50000.00.0
320233000.0-5000.08000.0
42024-7000.0-15000.08000.0
520253000.0-5000.08000.0
6202618000.0-5000.023000.0
720273000.0-5000.08000.0
82028-17000.0-25000.08000.0
920293000.0-5000.08000.0
1020303000.0-5000.08000.0
\n", + "
" + ], + "text/plain": [ + " date net cost income\n", + "0 2020 0.0 0.0 0.0\n", + "1 2021 0.0 0.0 0.0\n", + "2 2022 -50000.0 -50000.0 0.0\n", + "3 2023 3000.0 -5000.0 8000.0\n", + "4 2024 -7000.0 -15000.0 8000.0\n", + "5 2025 3000.0 -5000.0 8000.0\n", + "6 2026 18000.0 -5000.0 23000.0\n", + "7 2027 3000.0 -5000.0 8000.0\n", + "8 2028 -17000.0 -25000.0 8000.0\n", + "9 2029 3000.0 -5000.0 8000.0\n", + "10 2030 3000.0 -5000.0 8000.0" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "custom_flows = pd.DataFrame(\n", + " {\n", + " \"date\": [\"2024-01-01\", \"2026-01-01\", \"2028-01-01\"],\n", + " \"cost\": [10_000, 0, 20_000], # extra one-off costs\n", + " \"income\": [0, 15_000, 0], # extra one-off income\n", + " }\n", + ")\n", + "\n", + "ci_custom = CostIncome(\n", + " mkt_price_year=2020,\n", + " init_cost=50_000,\n", + " periodic_cost=5_000,\n", + " periodic_income=8_000,\n", + " custom_cash_flows=custom_flows,\n", + " freq=\"Y\",\n", + ")\n", + "ci_custom.to_dataframe(impl_date, start_date, end_date)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "11f21296", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(, )" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ci_custom.plot_cash_flows(impl_date, start_date, end_date)" + ] + }, + { + "cell_type": "markdown", + "id": "f1f011b6", + "metadata": {}, + "source": [ + "## Sub-annual frequencies\n", + "\n", + "`freq` accepts any pandas-compatible period string. Common options:\n", + "\n", + "| `freq` | Meaning |\n", + "|---|---|\n", + "| `\"Y\"` | Annual |\n", + "| `\"Q\"` | Quarterly |\n", + "| `\"M\"` | Monthly |\n", + "| `\"7D\"` | Every 7 days |\n", + "\n", + "```{note}\n", + "The periodic amounts are interpreted as **per-period** values, not annualised.\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "277e6948", + "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", + "
datenetcostincome
02022-01-5000.0-5000.00.0
12022-02200.0-500.0700.0
22022-03200.0-500.0700.0
32022-04200.0-500.0700.0
42022-05200.0-500.0700.0
52022-06200.0-500.0700.0
62022-07200.0-500.0700.0
72022-08200.0-500.0700.0
82022-09200.0-500.0700.0
92022-10200.0-500.0700.0
102022-11200.0-500.0700.0
112022-12200.0-500.0700.0
\n", + "
" + ], + "text/plain": [ + " date net cost income\n", + "0 2022-01 -5000.0 -5000.0 0.0\n", + "1 2022-02 200.0 -500.0 700.0\n", + "2 2022-03 200.0 -500.0 700.0\n", + "3 2022-04 200.0 -500.0 700.0\n", + "4 2022-05 200.0 -500.0 700.0\n", + "5 2022-06 200.0 -500.0 700.0\n", + "6 2022-07 200.0 -500.0 700.0\n", + "7 2022-08 200.0 -500.0 700.0\n", + "8 2022-09 200.0 -500.0 700.0\n", + "9 2022-10 200.0 -500.0 700.0\n", + "10 2022-11 200.0 -500.0 700.0\n", + "11 2022-12 200.0 -500.0 700.0" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ci_monthly = CostIncome(\n", + " mkt_price_year=2022,\n", + " init_cost=5_000,\n", + " periodic_cost=500,\n", + " periodic_income=700,\n", + " freq=\"M\",\n", + ")\n", + "\n", + "df_monthly = ci_monthly.to_dataframe(\n", + " impl_date=\"2022-01-01\",\n", + " start_date=\"2022-01-01\",\n", + " end_date=\"2022-12-01\",\n", + ")\n", + "df_monthly" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "03a80747", + "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": [ + "ci_monthly.plot_cash_flows(\n", + " \"2022-01-01\",\n", + " \"2022-01-01\",\n", + " \"2022-12-01\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "10191dfd", + "metadata": {}, + "source": [ + "## Combining multiple CostIncome objects\n", + "\n", + "`CostIncome.comb_cost_income()` aggregates a list of `CostIncome` objects into a single one by summing costs and incomes.\n", + "\n", + "```{warning}\n", + "All objects must share the same `mkt_price_year`, `cost_growth_rate`, and `income_growth_rate`.\n", + "```\n", + "\n", + "```{note}\n", + "`custom_cash_flows` are **not** carried over to the combined object. Merge custom flows manually beforehand if needed.\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "666fd82b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CostIncome(\n", + " mkt_price_year = 2020\n", + " freq = 'Y'\n", + " init_cost = -50,000.00\n", + " periodic_cost = -5,000.00\n", + " periodic_income = 8,000.00\n", + " cost_yearly_growth_rate = 0.00%\n", + " income_yearly_growth_rate = 0.00%\n", + " custom_cash_flows = None\n", + ")\n" + ] + } + ], + "source": [ + "ci_a = CostIncome(\n", + " mkt_price_year=2020,\n", + " init_cost=30_000,\n", + " periodic_cost=2_000,\n", + " periodic_income=4_000,\n", + " freq=\"Y\",\n", + ")\n", + "\n", + "ci_b = CostIncome(\n", + " mkt_price_year=2020,\n", + " init_cost=20_000,\n", + " periodic_cost=3_000,\n", + " periodic_income=4_000,\n", + " freq=\"Y\",\n", + ")\n", + "\n", + "ci_combined = CostIncome.comb_cost_income([ci_a, ci_b])\n", + "\n", + "print(ci_combined)" + ] + }, + { + "cell_type": "markdown", + "id": "8a15baaf", + "metadata": {}, + "source": [ + "## Loading from dict / YAML\n", + "\n", + "### From a Python dictionary" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "eeac2088", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CostIncome(\n", + " mkt_price_year = 2020\n", + " freq = 'Y'\n", + " init_cost = -50,000.00\n", + " periodic_cost = -5,000.00\n", + " periodic_income = 8,000.00\n", + " cost_yearly_growth_rate = 2.00%\n", + " income_yearly_growth_rate = 3.00%\n", + " custom_cash_flows = None\n", + ")\n" + ] + } + ], + "source": [ + "config_dict = {\n", + " \"mkt_price_year\": 2020,\n", + " \"init_cost\": 50_000,\n", + " \"periodic_cost\": 5_000,\n", + " \"periodic_income\": 8_000,\n", + " \"cost_yearly_growth_rate\": 0.02,\n", + " \"income_yearly_growth_rate\": 0.03,\n", + " \"freq\": \"Y\",\n", + "}\n", + "\n", + "ci_from_dict = CostIncome.from_dict(config_dict)\n", + "print(ci_from_dict)" + ] + }, + { + "cell_type": "markdown", + "id": "0b2a868e", + "metadata": {}, + "source": [ + "### From a YAML file\n", + "\n", + "Create a YAML file structured as follows, then load it with `CostIncome.from_yaml`.\n", + "\n", + "```yaml\n", + "# measure_cost.yaml\n", + "cost_income:\n", + " mkt_price_year: 2020\n", + " init_cost: 50000\n", + " periodic_cost: 5000\n", + " periodic_income: 8000\n", + " cost_yearly_growth_rate: 0.02\n", + " income_yearly_growth_rate: 0.03\n", + " freq: \"Y\"\n", + " # Optional custom flows:\n", + " # custom_cash_flows:\n", + " # - date: \"2024-01-01\"\n", + " # cost: 10000\n", + " # income: 0\n", + "```" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:climada_env_dev]", + "language": "python", + "name": "conda-env-climada_env_dev-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 53ccaf7477808db1d618c325e5d6b78c6cd86953 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 9 Apr 2026 15:05:47 +0200 Subject: [PATCH 12/44] Includes notebook in documentation index --- doc/user-guide/adaptation.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/user-guide/adaptation.rst b/doc/user-guide/adaptation.rst index a7424da05b..647eddc7ac 100644 --- a/doc/user-guide/adaptation.rst +++ b/doc/user-guide/adaptation.rst @@ -9,6 +9,6 @@ These guides show everything you need to know in order to evaluate adapation opt .. Adaptation measures in CLIMADA Using measure configurations - .. Defining measure cash flows + Defining measure cash flows .. Cost benefit evaluation .. Adapation planning evaluation From a9fd1c699f0e03575c3e6b5af4bc3c2eafcdd68a Mon Sep 17 00:00:00 2001 From: spjuhel Date: Fri, 10 Apr 2026 09:25:41 +0200 Subject: [PATCH 13/44] Updates changelog --- CHANGELOG.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 58775e3ef1..36ccd483c0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,7 +12,8 @@ Code freeze date: YYYY-MM-DD ### Added -- Better type hints and overloads signatures for ImpactFuncSet [#1250](https://github.com/CLIMADA-project/climada_python/pull/1250) +- Better type hints and overloads signatures for `ImpactFuncSet` [#1250](https://github.com/CLIMADA-project/climada_python/pull/1250) +- Adds `CostIncome` class and related tutorial for future new `Measure` class. [#1277](https://github.com/CLIMADA-project/climada_python/pull/1277) ### Changed - Updated Impact Calculation Tutorial (`doc.climada_engine_Impact.ipynb`) [#1095](https://github.com/CLIMADA-project/climada_python/pull/1095). From 1c55e444de4706a57913a732419f11d70e3eb803 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Fri, 10 Apr 2026 09:36:29 +0200 Subject: [PATCH 14/44] Adds `types.py` --- climada/entity/measures/base.py | 2 -- climada/entity/measures/types.py | 10 ++++++++++ 2 files changed, 10 insertions(+), 2 deletions(-) create mode 100644 climada/entity/measures/types.py diff --git a/climada/entity/measures/base.py b/climada/entity/measures/base.py index bdcf5ed5fe..6beedcd914 100755 --- a/climada/entity/measures/base.py +++ b/climada/entity/measures/base.py @@ -31,8 +31,6 @@ from functools import wraps from typing import TYPE_CHECKING, Any, Optional, Tuple, TypeVar -import pandas as pd - from climada.entity.measures.measure_config import MeasureConfig from .cost_income import CostIncome diff --git a/climada/entity/measures/types.py b/climada/entity/measures/types.py new file mode 100644 index 0000000000..1ad90986b1 --- /dev/null +++ b/climada/entity/measures/types.py @@ -0,0 +1,10 @@ +from collections.abc import Callable +from typing import Concatenate + +from climada.entity.exposures.base import Exposures +from climada.entity.impact_funcs.impact_func_set import ImpactFuncSet +from climada.hazard.base import Hazard + +HazardChange = Callable[Concatenate[Hazard, ...], Hazard] +ImpfsetChange = Callable[Concatenate[ImpactFuncSet, ...], ImpactFuncSet] +ExposuresChange = Callable[Concatenate[Exposures, ...], Exposures] From 7f72bd4953011b74bd94d1b58644f0d639c8a388 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Fri, 10 Apr 2026 11:01:14 +0200 Subject: [PATCH 15/44] Adds and improves docstrings --- climada/entity/measures/base.py | 153 +++++++++++++++++++++++++------- 1 file changed, 120 insertions(+), 33 deletions(-) diff --git a/climada/entity/measures/base.py b/climada/entity/measures/base.py index 6beedcd914..1cb9829c6e 100755 --- a/climada/entity/measures/base.py +++ b/climada/entity/measures/base.py @@ -54,13 +54,56 @@ T = TypeVar("T", Exposures, ImpactFuncSet, Hazard) +# Note for review: # This function will moved in helper.py in a future PR which will -# add IO based on MeasureConfig dataclasses +# add I/O based on MeasureConfig dataclasses def identity_function(x: T, **_kwargs: Any) -> T: + """Identity function + + Returns the provided parameter. Usefull to design measures without effect + on some of the risk components (Hazard, Exposures, Impact Function) + """ return x def allow_kwargs(func): + """ + Decorator that allows a function to accept (and silently ignore) keyword arguments. + + If the wrapped function already accepts ``**kwargs``, it is called unchanged. + Otherwise, any keyword arguments not present in the function's signature are + filtered out before the call, preventing ``TypeError`` from unexpected keywords. + + The functions used by `Measure` objects to apply changes on ``Exposures``, ``Hazard``, + and ``ImpactFuncSet`` always receive ``base_exposure, base_hazard, base_impfset`` as + keyword arguments. This decorator is applied to users-defined functions and prevent + them from not accepting these kwargs and raising a ``TypeError``. + + Parameters + ---------- + func : callable + The function to wrap. + + Returns + ------- + callable + A wrapped version of `func` that accepts keyword arguments. + + Examples + -------- + >>> @allow_kwargs + ... def greet(name, greeting="Hello"): + ... return f"{greeting}, {name}!" + >>> greet("Alice", greeting="Hi", unused_param="ignored") + 'Hi, Alice!' + + >>> @allow_kwargs + ... def add(a, b): + ... return a + b + >>> add(1, 2, extra=99) + 3 + """ + @wraps(func) def wrapper(*args, **kwargs): # Get the names of arguments the original function accepts @@ -79,17 +122,46 @@ def wrapper(*args, **kwargs): class Measure: """ - Contains a measure to be applied to a set of exposures, impact functions, and hazard. + Contains a measure to be applied to a set of exposures, impact functions, + and hazard. + + A ``Measure`` represents a single adaptation or risk-reduction action. It + holds three (optional) transformation functions, one each for + :class:`Exposures`, :class:`ImpactFuncSet`, and :class:`Hazard`, that are + can be applied to a triplet of ``(Exposures, ImpactFuncSet, Hazard)``, to + reflect the effect of the measure. + + It also holds a `CostIncome` object to define the financial aspects of the + measure (see :class:`CostIncome` and :ref:`cost-income-tutorial`). + + Finally it holds an `implementation_duration` attribute, in the form of a + pandas ``DateOffset``, which is used when the time dimension is considered. + + Notes + ----- + + The only requirement for each function is to return an object of the same + class (e.g. :class:`Hazard` for ``hazard_change``). Functions can accept + keyword arguments to enable advanced effect (depending on a year of + application for instance). These arguments can be passed when the + :class:`Measure` is applied (see :py:meth:`~Measure.apply`). Note that for + convenience, each functions receive the by default "base" ``(Exposures, + ImpactFuncSet, Hazard)`` triplet as keyword arguments (`base_exposure`, + `base_impfset`, `base_hazard`). + + If the ``Measure`` was defined from a ``MeasureConfig`` object, the + configuration is stored and the measure can be serialized to a file. + (see :ref:`measure-config-tutorial` and :ref:`measure-tutorial`). Attributes ---------- name : str Name of the measure. - exposures_change : callable + exposures_change : ExposuresChange Function to change exposures. - impfset_change : callable + impfset_change : ImpfsetChange Function to change impact function set. - hazard_change : callable + hazard_change : HazardChange Function to change hazard. sub_measures : list of str, optional List of measure names that this measure is a combination of. @@ -149,18 +221,24 @@ def __init__( @property def is_serializable(self) -> bool: + """Returns True if the ``Measure`` was created from + a ``MeasureConfig`` object and can be serialized. + """ + return self._config is not None def apply_exposures_changes( self, exposures: Exposures, enforce_copy: bool = True, **kwargs ) -> Exposures: - """Apply the changes from the measure to the given exposures object. + """Apply the changes from the measure to the given :class:`Exposures` object. This method applies the `exposures_changes` function of the measure to - the provided `exposures` object. If `enforce_copy` is True (default), a + the provided :class:`Exposures` object. If ``enforce_copy`` is True (default), a deep copy of the exposures is created before modification to ensure immutability of the original object. + Additional keyword arguments to the function can be passed directly. + Parameters ---------- exposures : Exposures @@ -177,7 +255,7 @@ def apply_exposures_changes( Returns ------- Exposures - The resulting exposures object after the transformation has been applied. + The resulting :class:`Exposures` object after the transformation has been applied. If `enforce_copy` was True, this is a new object. Notes @@ -210,12 +288,13 @@ def apply_exposures_changes( def apply_impfset_changes( self, impfset: ImpactFuncSet, enforce_copy: bool = True, **kwargs ) -> ImpactFuncSet: - """Apply the changes from the measure to the given impfset object. + """ + Apply the changes from the measure to the given :class:`ImpactFuncSet` object. This method applies the `impfset_changes` function of the measure to - the provided `impfset` object. If `enforce_copy` is True (default), a - deep copy of the impfset is created before modification to ensure - immutability of the original object. + the provided :class:`ImpactFuncSet` object. If `enforce_copy` is True + (default), a deep copy of the impfset is created before modification to + ensure immutability of the original object. Parameters ---------- @@ -223,9 +302,9 @@ def apply_impfset_changes( The input impfset object to be transformed. enforce_copy : bool, optional If True (default), creates a deep copy of `impfset` before applying - changes, provided the transformation function is not the identity function. - If False, the original object may be modified in-place depending on the - behavior of `impfset_changes`. + changes, provided the transformation function is not the identity + function. If False, the original object may be modified in-place + depending on the behavior of `impfset_changes`. **kwargs : dict, optional Additional keyword arguments passed directly to the `impfset_changes` function. @@ -233,14 +312,15 @@ def apply_impfset_changes( Returns ------- ImpactFuncSet - The resulting impfset object after the transformation has been applied. - If `enforce_copy` was True, this is a new object. + The resulting :class:`ImpactFuncSet` after the transformation has + been applied. If `enforce_copy` was True, this is a new object. Notes ----- The deep copy operation is skipped if `enforce_copy` is False or if `self.impfset_changes` is the identity function, optimizing performance - when no actual changes are expected or when in-place modification is desired. + when no actual changes are expected or when in-place modification is + desired. """ changed_impfset = ( @@ -265,10 +345,11 @@ def apply_impfset_changes( def apply_hazard_changes( self, hazard: Hazard, enforce_copy: bool = True, **kwargs ) -> Hazard: - """Apply the changes from the measure to the given hazard object. + """ + Apply the changes from the measure to the given :class:`Hazard` object. - This method applies the `hazard_changes` function of the measure to - the provided `hazard` object. If `enforce_copy` is True (default), a + This method applies the `hazard_changes` function of the measure to the + provided :class:`Hazard` object. If `enforce_copy` is True (default), a deep copy of the hazard is created before modification to ensure immutability of the original object. @@ -278,9 +359,9 @@ def apply_hazard_changes( The input hazard object to be transformed. enforce_copy : bool, optional If True (default), creates a deep copy of `hazard` before applying - changes, provided the transformation function is not the identity function. - If False, the original object may be modified in-place depending on the - behavior of `hazard_changes`. + changes, provided the transformation function is not the identity + function. If False, the original object may be modified in-place + depending on the behavior of `hazard_changes`. **kwargs : dict, optional Additional keyword arguments passed directly to the `hazard_changes` function. @@ -288,15 +369,17 @@ def apply_hazard_changes( Returns ------- Hazard - The resulting hazard object after the transformation has been applied. - If `enforce_copy` was True, this is a new object. + The resulting hazard object after the transformation has been + applied. If `enforce_copy` was True, this is a new object. Notes ----- The deep copy operation is skipped if `enforce_copy` is False or if `self.hazard_changes` is the identity function, optimizing performance - when no actual changes are expected or when in-place modification is desired. + when no actual changes are expected or when in-place modification is + desired. """ + changed_hazard = ( copy.deepcopy(hazard) if enforce_copy and self.hazard_changes is not identity_function @@ -324,17 +407,21 @@ def apply( enforce_copy: bool = True, **kwargs, ) -> Tuple[Exposures, ImpactFuncSet, Hazard]: - """Apply all measure transformations to the provided entity triplet. + """Apply all measure transformations to the provided triplet of + :class:`Exposures`, :class:`ImpactFuncSet`, :class:`Hazard`. This method applies the measure changes across all three risk parts: exposures, impact function set, and hazard data. The method implements a flexible keyword arguments merging strategy - where the original (exposures, impact function set, hazard) triplet is - provided as default context to each transformation, which can then be - overridden by entity-specific kwargs dictionaries. This enables - transformation requiring the information from other parts (for - instance, removing events based on impact threshold) + where the original triplet is provided as default context to each + transformation, which can then be overridden by entity-specific kwargs + dictionaries. This enables transformation requiring the information + from other risk components (for instance, removing events based on impact + threshold) or additional information (for instance, effect depending on + year of implementation). + + Refer to :ref:`measure-tutorial` for more details. Parameters ---------- From d787844f3d6b86201ab1dd5e0d973789788478ae Mon Sep 17 00:00:00 2001 From: spjuhel Date: Fri, 10 Apr 2026 11:29:45 +0200 Subject: [PATCH 16/44] Adds class to rst index --- doc/api/climada/measures.rst | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/doc/api/climada/measures.rst b/doc/api/climada/measures.rst index 62f8b2d949..d0557c58e3 100644 --- a/doc/api/climada/measures.rst +++ b/doc/api/climada/measures.rst @@ -12,3 +12,11 @@ climada\.entity\.measures\.measure_config module :members: :undoc-members: :show-inheritance: + +climada\.entity\.measures\.cost_income module +--------------------------------------------- + +.. automodule:: climada.entity.measures.cost_income + :members: + :undoc-members: + :show-inheritance: From ef39bde4cbfc769dac0e62b44b1bb81bed717c29 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Fri, 10 Apr 2026 11:35:30 +0200 Subject: [PATCH 17/44] Adds class to rst index --- doc/api/climada/climada.entity.measures.rst | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/doc/api/climada/climada.entity.measures.rst b/doc/api/climada/climada.entity.measures.rst index 62f8b2d949..82207c7a9a 100644 --- a/doc/api/climada/climada.entity.measures.rst +++ b/doc/api/climada/climada.entity.measures.rst @@ -12,3 +12,11 @@ climada\.entity\.measures\.measure_config module :members: :undoc-members: :show-inheritance: + +climada\.entity\.measures\.cost_income module +------------------------------------------------ + +.. automodule:: climada.entity.measures.cost_income + :members: + :undoc-members: + :show-inheritance: From 89fd0150dd17a7215f907631ef488b310af7188d Mon Sep 17 00:00:00 2001 From: spjuhel Date: Fri, 10 Apr 2026 11:37:53 +0200 Subject: [PATCH 18/44] Adds modules to rst index --- doc/api/climada/climada.entity.measures.rst | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/doc/api/climada/climada.entity.measures.rst b/doc/api/climada/climada.entity.measures.rst index 82207c7a9a..5f97f72bd4 100644 --- a/doc/api/climada/climada.entity.measures.rst +++ b/doc/api/climada/climada.entity.measures.rst @@ -5,6 +5,15 @@ climada\.entity\.measures package This package implements the new way of defining measures. For the previous way, see :ref:`climada.entity._legacy_measures` +climada\.entity\.measures\.base module +-------------------------------------- + +.. automodule:: climada.entity.measures.base + :members: + :undoc-members: + :show-inheritance: + + climada\.entity\.measures\.measure_config module ------------------------------------------------ @@ -14,9 +23,17 @@ climada\.entity\.measures\.measure_config module :show-inheritance: climada\.entity\.measures\.cost_income module ------------------------------------------------- +--------------------------------------------- .. automodule:: climada.entity.measures.cost_income :members: :undoc-members: :show-inheritance: + +climada\.entity\.measures\.types module +--------------------------------------- + +.. automodule:: climada.entity.measures.types + :members: + :undoc-members: + :show-inheritance: From 0003869c13e1458ee7869b0da7e98c47f15e8928 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 21 Apr 2026 11:21:39 +0200 Subject: [PATCH 19/44] Improves custom cash flows, updates tests --- climada/entity/measures/cost_income.py | 64 ++++++++++++++--- .../entity/measures/test/test_cost_income.py | 72 ++++++++++++------- 2 files changed, 100 insertions(+), 36 deletions(-) diff --git a/climada/entity/measures/cost_income.py b/climada/entity/measures/cost_income.py index 33ece8de1c..9b61b25437 100644 --- a/climada/entity/measures/cost_income.py +++ b/climada/entity/measures/cost_income.py @@ -20,13 +20,12 @@ """ from datetime import datetime -from typing import Any, List, Optional, Tuple, cast +from typing import Any, Optional, Tuple, cast import matplotlib.pyplot as plt import numpy as np import pandas as pd -from climada.entity.disc_rates.base import DiscRates from climada.entity.measures.measure_config import CostIncomeConfig @@ -101,11 +100,7 @@ def __init__( self.periodic_income = abs(periodic_income) self.income_growth_rate = income_yearly_growth_rate - - if custom_cash_flows is not None: - self.custom_cash_flows = self._prepare_custom_flows(custom_cash_flows) - else: - self.custom_cash_flows = None + self.custom_cash_flows = custom_cash_flows def __repr__(self) -> str: lines = [ @@ -122,6 +117,21 @@ def __repr__(self) -> str: ] return "\n".join(lines) + @property + def custom_cash_flows(self) -> pd.DataFrame | None: + return self._custom_cash_flows + + @custom_cash_flows.setter + def custom_cash_flows(self, value, /): + if value is None: + self._custom_cash_flows = None + + else: + if not isinstance(value, pd.DataFrame): + raise ValueError("Custom cash flows only accept pandas DataFrame.") + + self._custom_cash_flows = self._prepare_custom_flows(value) + def _prepare_custom_flows(self, df: pd.DataFrame) -> pd.DataFrame: """Process and resample custom cash flow dataframe @@ -138,9 +148,18 @@ def _prepare_custom_flows(self, df: pd.DataFrame) -> pd.DataFrame: Processed custom cashflow """ + if "date" not in df.columns: + raise ValueError("No 'date' column found in custom cash flow DataFrame.") + + if "cost" not in df.columns and "income" not in df.columns: + raise ValueError( + "No 'cost' or 'income' column found in custom cash flow DataFrame." + ) + df = df.copy() if "cost" in df.columns: df["cost"] = -df["cost"].abs() + if "date" in df.columns: df["date"] = pd.to_datetime(df["date"]) df = df.set_index("date") @@ -274,7 +293,7 @@ def _get_width_days(self) -> float: offset = pd.tseries.frequencies.to_offset(freq) return float(((ref + offset) - ref).days) - def _calc_at_date( + def calc_at_date( self, impl_date: pd.Timestamp, curr_date: pd.Timestamp ) -> Tuple[float, float, float]: r"""Calculate cash flows for a single timestamp. @@ -397,10 +416,12 @@ def calc_cash_flows( Total incomes for each period. """ - impl_ts = pd.Timestamp(impl_date) + # 'Trick' to make sure that e.g., impl_date "2020-01-05" falls in + # period "2020-01" if freq is "M" + impl_ts = pd.Timestamp(str(impl_date)).to_period(self.freq).start_time periods = pd.period_range(start=start_date, end=end_date, freq=self.freq) - results = [self._calc_at_date(impl_ts, p.start_time) for p in periods] + results = [self.calc_at_date(impl_ts, p.start_time) for p in periods] net, costs, incs = map(np.array, zip(*results)) return net, costs, incs @@ -558,11 +579,32 @@ def comb_cost_income(cost_incomes: list["CostIncome"]) -> "CostIncome": "Measure cost incomes have different income_growth_rate, combination is not possible." ) + if not all([first_ci.freq == c.freq for c in cost_incomes]): + raise ValueError( + "Measure cost incomes have different period frequencies, combination is not possible." + ) + + try: + custom_cash_flows = cast( + pd.DataFrame, + pd.concat([c.custom_cash_flows for c in cost_incomes]) # type: ignore + .groupby(level=0) + .sum() + .reset_index(), + ) + except ValueError as err: + if str(err) == "All objects passed were None": + custom_cash_flows = None + else: + raise err + return CostIncome( mkt_price_year=first_ci.mkt_price_year.year, - cost_yearly_growth_rate=first_ci.cost_growth_rate, init_cost=sum(c.init_cost for c in cost_incomes), periodic_cost=sum(c.periodic_cost for c in cost_incomes), periodic_income=sum(c.periodic_income for c in cost_incomes), + cost_yearly_growth_rate=first_ci.cost_growth_rate, income_yearly_growth_rate=first_ci.income_growth_rate, + freq=first_ci.freq, + custom_cash_flows=custom_cash_flows, ) diff --git a/climada/entity/measures/test/test_cost_income.py b/climada/entity/measures/test/test_cost_income.py index f9d6667db3..edc35528a8 100644 --- a/climada/entity/measures/test/test_cost_income.py +++ b/climada/entity/measures/test/test_cost_income.py @@ -20,32 +20,14 @@ """ from datetime import datetime -from unittest.mock import MagicMock, patch import numpy as np import pandas as pd import pytest +from pandas.testing import assert_frame_equal -from climada.entity.disc_rates.base import DiscRates from climada.entity.measures.cost_income import CostIncome -# --------------------------------------------------------------------------- -# Helpers -# --------------------------------------------------------------------------- - - -def make_disc_rates(years=None, rates=None): - """Build a minimal DiscRates stub.""" - dr = MagicMock(spec=DiscRates) - dr.years = np.array(years or list(range(2020, 2031))) - dr.rates = np.array(rates or [0.05] * len(dr.years)) - return dr - - -# --------------------------------------------------------------------------- -# __init__ / construction -# --------------------------------------------------------------------------- - class TestInit: def test_defaults(self): @@ -208,7 +190,7 @@ def test_before_impl_date_is_zero(self): ci = CostIncome(mkt_price_year=2020, init_cost=1000, periodic_income=500) impl = pd.Timestamp("2021-01-01") curr = pd.Timestamp("2020-01-01") - net, cost, inc = ci._calc_at_date(impl, curr) + net, cost, inc = ci.calc_at_date(impl, curr) assert net == 0.0 assert cost == 0.0 assert inc == 0.0 @@ -216,7 +198,7 @@ def test_before_impl_date_is_zero(self): def test_at_impl_date_uses_init_cost(self): ci = CostIncome(mkt_price_year=2021, init_cost=1000, periodic_income=0) impl = pd.Timestamp("2021-01-01") - net, cost, inc = ci._calc_at_date(impl, impl) + net, cost, inc = ci.calc_at_date(impl, impl) assert cost == pytest.approx(-1000.0, rel=1e-3) assert inc == pytest.approx(0.0) @@ -224,7 +206,7 @@ def test_after_impl_date_uses_periodic_cost(self): ci = CostIncome(mkt_price_year=2020, periodic_cost=200, periodic_income=0) impl = pd.Timestamp("2021-01-01") curr = pd.Timestamp("2022-01-01") - net, cost, inc = ci._calc_at_date(impl, curr) + net, cost, inc = ci.calc_at_date(impl, curr) assert cost < 0 assert abs(cost) == 200 @@ -234,7 +216,7 @@ def test_income_growth_applied(self): ) impl = pd.Timestamp("2020-01-01") curr = pd.Timestamp("2021-01-01") - _, _, inc = ci._calc_at_date(impl, curr) + _, _, inc = ci.calc_at_date(impl, curr) expected = 100 * (1.10**1.0) assert inc == pytest.approx(expected, rel=1e-2) @@ -242,7 +224,7 @@ def test_net_equals_income_plus_cost(self): ci = CostIncome(mkt_price_year=2020, periodic_cost=100, periodic_income=150) impl = pd.Timestamp("2020-01-01") curr = pd.Timestamp("2021-01-01") - net, cost, inc = ci._calc_at_date(impl, curr) + net, cost, inc = ci.calc_at_date(impl, curr) assert net == pytest.approx(cost + inc) def test_custom_cash_flows_added(self): @@ -257,7 +239,7 @@ def test_custom_cash_flows_added(self): print(ci.custom_cash_flows) impl = pd.Timestamp("2021-01-01") curr = pd.Timestamp("2021-01-01") - net, cost, inc = ci._calc_at_date(impl, curr) + net, cost, inc = ci.calc_at_date(impl, curr) assert inc == pytest.approx(200.0, rel=1e-3) assert cost == pytest.approx(-500.0, rel=1e-3) @@ -403,3 +385,43 @@ def test_preserves_growth_rates(self): combined = CostIncome.comb_cost_income([ci1, ci2]) assert combined.cost_growth_rate == 0.02 assert combined.income_growth_rate == 0.03 + + def test_merges_custom_cash_flows(self): + df1 = pd.DataFrame( + { + "date": ["2020-01-01", "2020-03-01"], + "cost": [100, 200], + "income": [50, 60], + } + ) + df2 = pd.DataFrame( + { + "date": ["2020-01-01", "2020-03-01", "2020-04-01"], + "cost": [100, 200, 300], + "income": [50, 60, 70], + } + ) + + expected = pd.DataFrame( + { + "date": ["2020-01", "2020-02", "2020-03", "2020-04"], + "cost": [-200, 0, -400, -300], + "income": [100, 0, 120, 70], + } + ) + + expected["date"] = pd.to_datetime(expected["date"]) + expected = expected.set_index("date") + expected = expected.resample("MS").sum() + + ci1 = CostIncome( + mkt_price_year=2020, periodic_income=100, freq="M", custom_cash_flows=df1 + ) + ci2 = CostIncome( + mkt_price_year=2020, periodic_cost=50, freq="M", custom_cash_flows=df2 + ) + + combined = CostIncome.comb_cost_income([ci1, ci2]) + print(combined.custom_cash_flows) + print(expected) + pd.testing.assert_frame_equal(combined.custom_cash_flows, expected) From 22c45b169fe97060bec865268693ef7cc4dee62d Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 21 Apr 2026 11:31:12 +0200 Subject: [PATCH 20/44] Updates tutorial --- doc/user-guide/climada_cost_income.ipynb | 647 ++++++++++++++++------- 1 file changed, 462 insertions(+), 185 deletions(-) diff --git a/doc/user-guide/climada_cost_income.ipynb b/doc/user-guide/climada_cost_income.ipynb index bf1834140e..fd53c2585e 100644 --- a/doc/user-guide/climada_cost_income.ipynb +++ b/doc/user-guide/climada_cost_income.ipynb @@ -8,7 +8,15 @@ "(cost-income-tutorial)=\n", "# Measure cash flows with `CostIncome`\n", "\n", - "This notebook introduces the `CostIncome` class from CLIMADA, which is used to model the financial cash flows of adaptation or risk-reduction measures over time.\n", + "This notebook introduces the `CostIncome` class from CLIMADA, which is used to model the financial cash flows of adaptation or risk-reduction measures over time." + ] + }, + { + "cell_type": "markdown", + "id": "a97e1043", + "metadata": {}, + "source": [ + "## Quickstart\n", "\n", "A `CostIncome` object tracks:\n", "- **Initial (one-off) costs** — the upfront implementation cost\n", @@ -21,34 +29,197 @@ { "cell_type": "code", "execution_count": 1, - "id": "a73bc8d1", + "id": "eca21610-32a8-477d-999e-54255557a3cc", "metadata": {}, - "outputs": [], + "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", + "
datenetcostincome
020200.0000000.0000000.000000
120210.0000000.0000000.000000
22022-9705.636889-9705.6368890.000000
320232940.807977-4901.3466297842.154606
420242970.216057-4950.3600957920.576152
520253000.000000-5000.0000008000.000000
620263030.000000-5050.0000008080.000000
720273060.300000-5100.5000008160.800000
820283090.903000-5151.5050008242.408000
920293121.897135-5203.1618928325.059028
1020303153.116107-5255.1935118408.309618
\n", + "
" + ], + "text/plain": [ + " date net cost income\n", + "0 2020 0.000000 0.000000 0.000000\n", + "1 2021 0.000000 0.000000 0.000000\n", + "2 2022 -9705.636889 -9705.636889 0.000000\n", + "3 2023 2940.807977 -4901.346629 7842.154606\n", + "4 2024 2970.216057 -4950.360095 7920.576152\n", + "5 2025 3000.000000 -5000.000000 8000.000000\n", + "6 2026 3030.000000 -5050.000000 8080.000000\n", + "7 2027 3060.300000 -5100.500000 8160.800000\n", + "8 2028 3090.903000 -5151.505000 8242.408000\n", + "9 2029 3121.897135 -5203.161892 8325.059028\n", + "10 2030 3153.116107 -5255.193511 8408.309618" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(, )" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "import pandas as pd\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", + "from climada.entity.measures.cost_income import CostIncome\n", + "\n", + "ci = CostIncome(\n", + " mkt_price_year=2025,\n", + " init_cost=10_000, # 10 000 upfront\n", + " periodic_cost=5_000, # 5 000 / year maintenance\n", + " periodic_income=8_000, # 8 000 / year in avoided losses\n", + " cost_yearly_growth_rate=0.01,\n", + " income_yearly_growth_rate=0.01,\n", + " freq=\"Y\", # annual cash flows\n", + ")\n", "\n", - "# Adjust the import path if running outside the CLIMADA package tree\n", - "from climada.entity.measures.cost_income import CostIncome" + "impl_date = \"2022-01-01\"\n", + "start_date = \"2020-01-01\"\n", + "end_date = \"2030-01-01\"\n", + "\n", + "\n", + "display(ci.to_dataframe(impl_date, start_date, end_date))\n", + "ci.plot_cash_flows(impl_date, start_date, end_date)" ] }, { "cell_type": "markdown", - "id": "a97e1043", + "id": "e75b7d54-6785-48af-9134-6dc4b564a76d", "metadata": {}, "source": [ - "## Quickstart\n", + "## Defining a `CostIncome`\n", "\n", "The simplest way to create a `CostIncome` is by passing keyword arguments directly.\n", "\n", - "| Parameter | Meaning | Sign convention |\n", - "|---|---|---|\n", - "| `init_cost` | One-off implementation cost | stored negative |\n", - "| `periodic_cost` | Recurring cost each period | stored negative |\n", - "| `periodic_income` | Recurring income each period | stored positive |\n", - "| `mkt_price_year` | Reference year for price levels | — |\n", - "| `freq` | Period frequency (e.g. `'Y'`, `'M'`, `'Q'`) | — |\n", + "| Parameter | Meaning |\n", + "|---|---|\n", + "| `init_cost` | One-off implementation cost |\n", + "| `periodic_cost` | Recurring cost each period |\n", + "| `periodic_income` | Recurring income each period |\n", + "| `mkt_price_year` | Reference year for cost/income growth rates |\n", + "| `cost_yearly_growth_rate` | Growth rate for costs |\n", + "| `income_yearly_growth_rate` | Growth rate for costs |\n", + "| `freq` | Period frequency (e.g. `'Y'` for yearly, `'M'` for monthly, `'Q'` for quaterly)
see more [here](https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#period-aliases))\n", "\n", "```{note} **Sign convention**\n", "`CostIncome` stores costs as negative numbers internally.\n", @@ -62,36 +233,21 @@ { "cell_type": "code", "execution_count": 2, - "id": "4ba16743", + "id": "41147b9d-9fef-4e58-9070-b384a5377f59", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CostIncome(\n", - " mkt_price_year = 2020\n", - " freq = 'Y'\n", - " init_cost = -20,000.00\n", - " periodic_cost = -5,000.00\n", - " periodic_income = 12,000.00\n", - " cost_yearly_growth_rate = 0.00%\n", - " income_yearly_growth_rate = 0.00%\n", - " custom_cash_flows = None\n", - ")\n" - ] - } - ], + "outputs": [], "source": [ + "from climada.entity.measures.cost_income import CostIncome\n", + "\n", "ci = CostIncome(\n", - " mkt_price_year=2020,\n", - " init_cost=20_000, # 50 000 upfront\n", + " mkt_price_year=2025,\n", + " init_cost=10_000, # 10 000 upfront\n", " periodic_cost=5_000, # 5 000 / year maintenance\n", - " periodic_income=12_000, # 8 000 / year in avoided losses\n", + " periodic_income=8_000, # 8 000 / year in avoided losses\n", + " cost_yearly_growth_rate=0.01,\n", + " income_yearly_growth_rate=0.01,\n", " freq=\"Y\", # annual cash flows\n", - ")\n", - "\n", - "print(ci)" + ")" ] }, { @@ -101,15 +257,19 @@ "source": [ "## Calculating cash flows\n", "\n", - "Three methods are available:\n", + "Three methods are available to calculate cash flows:\n", "\n", "| Method | Returns |\n", "|---|---|\n", "| `calc_cash_flows(impl_date, start_date, end_date)` | Three `np.ndarray`: net, costs, incomes |\n", - "| `calc_total(...)` | Three scalars: summed net, cost, income |\n", - "| `to_dataframe(...)` | A tidy `pd.DataFrame` |\n", + "| `calc_total(impl_date, start_date, end_date)` | Three scalars: summed net, cost, income |\n", + "| `to_dataframe(impl_date, start_date, end_date)` | A tidy `pd.DataFrame` |\n", "\n", - "The `impl_date` is when the measure is *deployed*. Cash flows before this date are zero; the initial cost lands on `impl_date`; periodic flows start the following period." + "The `impl_date` is when the measure is *deployed*. Cash flows before this date are zero; the initial cost lands on `impl_date`; periodic flows start the following period.\n", + "\n", + "```{note}\n", + "Dates should follow the standard format \"yyyy-mm-dd\" or be an integer representing the year.\n", + "```" ] }, { @@ -126,58 +286,48 @@ "---------------------------------------------\n", "2020 | 0 | 0 | 0\n", "2021 | 0 | 0 | 0\n", - "2022 | -20000 | -20000 | 0\n", - "2023 | 7000 | -5000 | 12000\n", - "2024 | 7000 | -5000 | 12000\n", - "2025 | 7000 | -5000 | 12000\n", - "2026 | 7000 | -5000 | 12000\n", - "2027 | 7000 | -5000 | 12000\n", - "2028 | 7000 | -5000 | 12000\n", - "2029 | 7000 | -5000 | 12000\n", - "2030 | 7000 | -5000 | 12000\n" + "2022 | -9706 | -9706 | 0\n", + "2023 | 2941 | -4901 | 7842\n", + "2024 | 2970 | -4950 | 7921\n", + "2025 | 3000 | -5000 | 8000\n", + "2026 | 3030 | -5050 | 8080\n", + "2027 | 3060 | -5100 | 8161\n", + "2028 | 3091 | -5152 | 8242\n", + "2029 | 3122 | -5203 | 8325\n", + "2030 | 3153 | -5255 | 8408\n", + "---------------------------------------------\n", + "Total net : 14662\n", + "Total cost : -50318\n", + "Total income : 64979\n", + "---------------------------------------------\n" ] } ], "source": [ + "import pandas as pd\n", + "\n", "impl_date = \"2022-01-01\"\n", "start_date = \"2020-01-01\"\n", "end_date = \"2030-01-01\"\n", "\n", "net, costs, incomes = ci.calc_cash_flows(impl_date, start_date, end_date)\n", + "total_net, total_cost, total_income = ci.calc_total(impl_date, start_date, end_date)\n", "\n", "print(\"Period | Net | Cost | Income\")\n", "print(\"-\" * 45)\n", "periods = pd.period_range(start=start_date, end=end_date, freq=\"Y\")\n", "for p, n, c, i in zip(periods, net, costs, incomes):\n", - " print(f\"{p} | {n:>9.0f} | {c:>9.0f} | {i:>6.0f}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "971ce0dd", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total net : 36000\n", - "Total cost : -60000\n", - "Total income : 96000\n" - ] - } - ], - "source": [ - "total_net, total_cost, total_income = ci.calc_total(impl_date, start_date, end_date)\n", + " print(f\"{p} | {n:>9.0f} | {c:>9.0f} | {i:>6.0f}\")\n", + "print(\"-\" * 45)\n", "print(f\"Total net : {total_net:>10.0f}\")\n", "print(f\"Total cost : {total_cost:>10.0f}\")\n", - "print(f\"Total income : {total_income:>10.0f}\")" + "print(f\"Total income : {total_income:>10.0f}\")\n", + "print(\"-\" * 45)" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "f3fd0c35", "metadata": {}, "outputs": [ @@ -212,107 +362,106 @@ " \n", " 0\n", " 2020\n", - " 0.0\n", - " 0.0\n", - " 0.0\n", + " 0.000000\n", + " 0.000000\n", + " 0.000000\n", " \n", " \n", " 1\n", " 2021\n", - " 0.0\n", - " 0.0\n", - " 0.0\n", + " 0.000000\n", + " 0.000000\n", + " 0.000000\n", " \n", " \n", " 2\n", " 2022\n", - " -20000.0\n", - " -20000.0\n", - " 0.0\n", + " -9705.636889\n", + " -9705.636889\n", + " 0.000000\n", " \n", " \n", " 3\n", " 2023\n", - " 7000.0\n", - " -5000.0\n", - " 12000.0\n", + " 2940.807977\n", + " -4901.346629\n", + " 7842.154606\n", " \n", " \n", " 4\n", " 2024\n", - " 7000.0\n", - " -5000.0\n", - " 12000.0\n", + " 2970.216057\n", + " -4950.360095\n", + " 7920.576152\n", " \n", " \n", " 5\n", " 2025\n", - " 7000.0\n", - " -5000.0\n", - " 12000.0\n", + " 3000.000000\n", + " -5000.000000\n", + " 8000.000000\n", " \n", " \n", " 6\n", " 2026\n", - " 7000.0\n", - " -5000.0\n", - " 12000.0\n", + " 3030.000000\n", + " -5050.000000\n", + " 8080.000000\n", " \n", " \n", " 7\n", " 2027\n", - " 7000.0\n", - " -5000.0\n", - " 12000.0\n", + " 3060.300000\n", + " -5100.500000\n", + " 8160.800000\n", " \n", " \n", " 8\n", " 2028\n", - " 7000.0\n", - " -5000.0\n", - " 12000.0\n", + " 3090.903000\n", + " -5151.505000\n", + " 8242.408000\n", " \n", " \n", " 9\n", " 2029\n", - " 7000.0\n", - " -5000.0\n", - " 12000.0\n", + " 3121.897135\n", + " -5203.161892\n", + " 8325.059028\n", " \n", " \n", " 10\n", " 2030\n", - " 7000.0\n", - " -5000.0\n", - " 12000.0\n", + " 3153.116107\n", + " -5255.193511\n", + " 8408.309618\n", " \n", " \n", "\n", "" ], "text/plain": [ - " date net cost income\n", - "0 2020 0.0 0.0 0.0\n", - "1 2021 0.0 0.0 0.0\n", - "2 2022 -20000.0 -20000.0 0.0\n", - "3 2023 7000.0 -5000.0 12000.0\n", - "4 2024 7000.0 -5000.0 12000.0\n", - "5 2025 7000.0 -5000.0 12000.0\n", - "6 2026 7000.0 -5000.0 12000.0\n", - "7 2027 7000.0 -5000.0 12000.0\n", - "8 2028 7000.0 -5000.0 12000.0\n", - "9 2029 7000.0 -5000.0 12000.0\n", - "10 2030 7000.0 -5000.0 12000.0" + " date net cost income\n", + "0 2020 0.000000 0.000000 0.000000\n", + "1 2021 0.000000 0.000000 0.000000\n", + "2 2022 -9705.636889 -9705.636889 0.000000\n", + "3 2023 2940.807977 -4901.346629 7842.154606\n", + "4 2024 2970.216057 -4950.360095 7920.576152\n", + "5 2025 3000.000000 -5000.000000 8000.000000\n", + "6 2026 3030.000000 -5050.000000 8080.000000\n", + "7 2027 3060.300000 -5100.500000 8160.800000\n", + "8 2028 3090.903000 -5151.505000 8242.408000\n", + "9 2029 3121.897135 -5203.161892 8325.059028\n", + "10 2030 3153.116107 -5255.193511 8408.309618" ] }, - "execution_count": 5, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "df = ci.to_dataframe(impl_date, start_date, end_date)\n", - "df" + "ci.to_dataframe(impl_date, start_date, end_date)" ] }, { @@ -322,12 +471,14 @@ "source": [ "## Visualising cash flows\n", "\n", - "`plot_cash_flows` draws a bar chart. You can choose which series to display via the `to_plot` argument." + "`plot_cash_flows` draws a bar chart of the cash flows. The top panel of the plot shows costs, incomes and net values for each period, while the bottom panel shows the cumulated net value.\n", + "\n", + "Figure size and title can be customized directly in the method. The method returns a tuple with the two matplotlib axes objects." ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "315fc0ac", "metadata": {}, "outputs": [ @@ -337,15 +488,15 @@ "(, )" ] }, - "execution_count": 6, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -357,6 +508,8 @@ " impl_date,\n", " start_date,\n", " end_date,\n", + " figsize=(16, 7),\n", + " title=\"Custom title for cash flow plot\",\n", ")" ] }, @@ -367,7 +520,7 @@ "source": [ "## Growth rates\n", "\n", - "Costs and incomes can grow year-over-year using compound-interest factors anchored to `mkt_price_year`.\n", + "Costs and incomes can grow year-over-year using compound-interest factors anchored to the `mkt_price_year` attribute.\n", "\n", "$$\\text{value}(t) = \\text{base} \\times (1 + r)^{\\frac{t - t_0}{365}}$$\n", "\n", @@ -376,7 +529,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "b69f1ae7", "metadata": {}, "outputs": [ @@ -386,13 +539,13 @@ "(, )" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -403,12 +556,12 @@ ], "source": [ "ci_growth = CostIncome(\n", - " mkt_price_year=2020,\n", - " init_cost=50_000,\n", + " mkt_price_year=2025,\n", + " init_cost=10_000,\n", " periodic_cost=5_000,\n", " periodic_income=8_000,\n", - " cost_yearly_growth_rate=0.02, # costs grow 2% / year\n", - " income_yearly_growth_rate=0.03, # income grows 3% / year\n", + " cost_yearly_growth_rate=0.15,\n", + " income_yearly_growth_rate=0.10,\n", " freq=\"Y\",\n", ")\n", "\n", @@ -417,7 +570,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "067c07aa", "metadata": {}, "outputs": [ @@ -426,9 +579,9 @@ "output_type": "stream", "text": [ " No growth With growth\n", - "Net 36000 -19821\n", - "Cost -60000 -97569\n", - "Income 96000 77748\n" + "Net 14662 17138\n", + "Cost -50318 -58474\n", + "Income 64979 75612\n" ] } ], @@ -457,7 +610,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "id": "c469839c-e2e2-43e9-ac33-93de7f04a6d9", "metadata": {}, "outputs": [ @@ -506,8 +659,8 @@ " \n", " 2\n", " 2022\n", - " -50000.0\n", - " -50000.0\n", + " -10000.0\n", + " -10000.0\n", " 0.0\n", " \n", " \n", @@ -574,7 +727,7 @@ " date net cost income\n", "0 2020 0.0 0.0 0.0\n", "1 2021 0.0 0.0 0.0\n", - "2 2022 -50000.0 -50000.0 0.0\n", + "2 2022 -10000.0 -10000.0 0.0\n", "3 2023 3000.0 -5000.0 8000.0\n", "4 2024 -7000.0 -15000.0 8000.0\n", "5 2025 3000.0 -5000.0 8000.0\n", @@ -585,7 +738,7 @@ "10 2030 3000.0 -5000.0 8000.0" ] }, - "execution_count": 9, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -600,8 +753,8 @@ ")\n", "\n", "ci_custom = CostIncome(\n", - " mkt_price_year=2020,\n", - " init_cost=50_000,\n", + " mkt_price_year=2025,\n", + " init_cost=10_000,\n", " periodic_cost=5_000,\n", " periodic_income=8_000,\n", " custom_cash_flows=custom_flows,\n", @@ -612,7 +765,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "id": "11f21296", "metadata": {}, "outputs": [ @@ -622,13 +775,13 @@ "(, )" ] }, - "execution_count": 10, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABAgAAAJyCAYAAABJ8PKHAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAApIhJREFUeJzs3Qd4FFXXwPGTnhASei+hN+m9F+m9SBGUooAgoiKgiIAgKigq4CuCIigWFFCKgKCAItJBuhRpoYfeAoTU/Z5zcfdLIEASkmzJ//c8y+7OzuzcTEKyc+acc90sFotFAAAAAABAmuZu7wEAAAAAAAD7I0AAAAAAAAAIEAAAAAAAAAIEAAAAAACAAAEAAAAAACBAAAAAAAAADJoUAgAAAAAAAgQAAAAAAIAAAQAAAAAAIEAAAIDj+/PPP8XNzU1mzZqVKvurX7++FChQIFX25WyOHTtmvhdjxoxJ0f3oPnr16pWi+wAA4G70IAAAIAFu374tn3zyidSrV0+yZMkiXl5ekj17dmnatKl88cUXEh4e7vDHUU8673dL6RPe5FSzZk1OoAEASAGeKfGmAAC42lXjli1byr59++Txxx+XYcOGSbZs2eTSpUvm6n7//v1l69atMn36dHF0ZcuWlVdffTXe5c5g//79snHjRilatKj8+OOP8r///U8CAwPF1YSFhYmHh4e9hwEASGMIEAAA8JDMgVatWsm///4r8+bNk06dOsV5fejQofLPP//IihUrnOI45sqVS55++mlxVjNnzhR/f3+ZPXu2VK1aVebMmSPPPfecuBpfX197DwEAkAZRYgAAwENOSPfu3SuDBw++JzhgVbp0afO61ZYtW0z9eLFixSRdunQSEBAgtWrVkoULF96z7cmTJ6V3794SFBQkPj4+pnyhSpUqpmwhPjNmzJBSpUqZdXWbCRMmpNr3b/369dKsWTPJmDGj+Pn5Sbly5UzZhcVisa3z3XffmfR/zaywio6OlgwZMpjlmzZtsi3Xsgw9Pj169EjQ/iMjI+Xbb7+Vjh07mmOkAQL9/jyoj8KpU6ekc+fOkilTJhNY0JKQgwcPxlk3NDRURo4cKdWqVZOsWbOaY1ukSBF5/fXX5datWw8c07lz58Tb21ueeuqpeF9/6aWXzNdt3efly5fNz0rhwoVNEEDHpdkb77777kN7EPzyyy+mxEWzV3Tb3LlzS5s2bczPJwAAyYEMAgAAHkDT2FW/fv0SfJw0EKAnhF27dpW8efOaUoSvv/5aOnToYK58d+vWzawXFRUljRs3ltOnT8vzzz8vxYsXl+vXr5uMhL/++kv69u0b532nTZsm58+flz59+pgTbj0Z13IH3Yf1PRNykn3x4sU4y9zd3SVz5swP3G7ZsmXStm1bcwI9aNAgc2I7f/58cwK8Z88eW3lFw4YNzf3vv/9uTtKVll/o16X70eXVq1c3y7VUQFPptWwjIZYsWWK+/p49e5rnev/CCy+Y46VBmrvdvHnTnFDXqFFDxo0bJ8HBwfLxxx+br0O3sabw6/HXQIMGgPREX5evWbPGBF927Nghv/32233HlCNHDvN+CxYskCtXrpjjEjsAot/vunXrmmCR0n3o91Z/njTAol+//qxoQGXEiBH33Y+OR4MBZcqUMYELDdKEhITI6tWrzfaPPfZYgo4hAAAPZAEAAPeVOXNmS0BAQKKO0I0bN+5ZdvPmTUuxYsUsJUuWtC3btWuXXnq3TJgw4YHvt3r1arNerly5LFeuXInznlmzZrVUr149QePS94jvliFDhjjr1atXzxIUFGR7HhUVZZ7rcTh58mSc5c2aNTPvsX79etvy4sWLW2rUqGF7/u6771oCAwMtbdq0sTRo0MC2fNSoUWbb48ePJ2j8LVq0sBQoUMASExNjnl++fNni4+NjeeWVV+5ZV78Gfe/3338/znI91rr8119/tS0LDw+3REZG3vMeI0eONOtu3rzZtiw4ONgsGz16tG3ZihUrzLJPPvkkzvZz5swxy7/55hvz/OrVq+b5gAEDHvq16no9e/a0PdevUZedP3/+odsCAJBUlBgAAPAAeuU7sU3wNJXdSlPUNYNA7/VKuTbZ0/dUmgWg/vjjD5Oq/jDPPPOMuXJspen5ejX+0KFDCR5b5cqVZeXKlXFuP//88wO32b59uxw/ftykvGu2gpVeaX/jjTfMY72CbqVfp2YNaOq+9evTbIImTZrIhg0bTF8H63JN5c+fP/9Dx61X+fVKvpYjaPq90qv1elVdyw4iIiLu2UYzFjTDITZrtkLsY6YlAp6enrasDs0E0CyLRo0amWWbN29+4Nh0vUKFCt1T7qDP9XusJRFKyzK0NEDLLLTxZWJYv++a0aJjBAAgJRAgAADgATQ4YD3RTShNg9fGeZp+rsECTcvXuvHPPvvMvH716lVzrz0E3nzzTdPgUOvJK1asaGYYiF2nH5uehN5NexZoACKhdH09oY190zT8Bzl69Ki5jy+NXVPeY69jPQnXk1hNpdc0ew0K6DK96XPtZaDp/9qrwVqS8DCzZs0yvQx0isPDhw/bbhp40JP5xYsX37ONHtO7m/3p16/uPmZTp041vQC0/4CWW+j3y1oioQGDB9GAhZaD7Ny50wRTlAZUtJxCSxY0MGANRGiJg/YMKFiwoOklMXDgQBOkeRhdr1KlSqakQsfXvHlz814JCSwBAJBQBAgAAHgAPQHWK/5HjhxJ0HGKiYkxfQW054Be7Z47d678+uuv5iTQ2idA17F66623zImuTtendepfffWVqZm/+8q3ste0d7GbECZEgwYNzEmzniBb+wxoIKBkyZJmFgVdvnbtWtMPISH9B3T/elyUNknUKQ6tNz1hVvE1K3zQ8Yr9NX300UfmfXRsn3/+uWkGqN8vDUrc/f16UHaHl5eXaSKpdLy6nfaLiE0DR5o9oOtpo0XtV6GZFe3bt3/gfjQooAEV7UXw8ssvm4yUIUOGmJ+Z2A0hAQB4FDQpBADgATQ9XE/KdFaB995776HHShv27d6922QG6Ml/bNaTx7vp1WQ9QdWbXmHXpnc6O8Arr7xiXrM37biv4uuWr83+Yq9jvUqvV+M1EKAZFJpJYW0iqAEBXa7BAQ0iaDDhYfQEWAM0GjSpU6fOPa9rs0SdglJnLIhdApFQ2uxRZzxYvny5KUuw0sBOQunXqOUO33//vXzwwQcmuKAZIRUqVLhn3Zw5c5qZK/SmQQHNPvjyyy/Nz9mDjoeOTRse6k1puYpmFYwePdpsCwDAoyKDAACAB9CTOL3yrVeZY9fZ3x0U0NdjX7W++6q7nkjfPc3htWvXzIlybJribk3l1ynxHIGe6Go5hGZFaC8AKz25HT9+vHmsV8Bj00CAHpeffvopTpaAPt62bZspCdDsDE3lfxjNDtCTY+13oAGbu286q4KOxXrFP7H0e6bBitjfMy2RSEhA6O7sAP2e9u/f35QY3J09oFf97542Ub+u8uXLP/T7fffME0qzB3QKTUf5OQEAOD8yCAAAeACtH1+6dKm0bNlSnnjiCVOzrynh2ldA69j1yq1OAWidklCDCXqCr1Pk6cmgTl2o09Bp6rpeRbfWqCudok5PKvV9rSd7Wseu6+oVeOuJo73pCbTW6Gtmg6bF6xR92iBQAyb69evXrr0BYtNAwKRJk+TAgQMydOhQ23ItNdBeAnpM9MT+YbRfg2YI1K5d21ylj0/VqlVN5oBehdepAq1NDBNKgwzDhw83df06FaWWlGgmgJYMJIaWlmifCM1I0J+bu6ee1K9Z+z1oMEV/RjTTQo+PTl+p/RKsTRHjo8dYMyT0Z0+DNZppog0Ltd+F9q0AACA5ECAAAOAh9KRPr3prmYFeEder5tq4UE+S9eq6Ln/66adtJ9Naw64nxXrFXZvxaWBAH+/atStOgKBcuXLmhFRPsmfPnm1OnPPly2e21ZM+e/UciE+LFi1MQOPtt9+WiRMnmhNU7QGgjfJefPHFe9bXE2GdGUCvxMfOINCTWz2e2tQwIf0H9ERdZz2wzgQQHw0I6HHUPg46xoS8b2x6rDV7QDMVtL5fSwC6dOli+gpoI8GE0nFo1oBmOnTq1Mk2S4WVfm+fffZZM0adOUK/Lg0MaK+K119//Z71Y+vevbvJkNCfowsXLpjmmSVKlDDHp2vXron6egEAuB83nevwvq8CAAAgwT788EMTcNAZHOLrlwAAgCMjQAAAAJAMNFtCS0p0asX4GjoCAODoKDEAAAB4BMHBwWY6Ry0b0NIJTfsHAMAZESAAAAB4BNpDQvsVaONKnd6SngAAAGdFiQEAAAAAABB3jgEAAAAAACBAAAAAAAAACBAAAAAAAAACBAAAAAAAgAABAAAAAAAgQAAAAAAAAAyaFAIAAAAAAAIEAAAAAACAAAEAAAAAACBAAAAAAAAACBAAAAAAAACDJoUAAAAAAIAAAQAAAAAAIEAAAAAAAAAIEAAAAAAAAAIEAAAAAADAoEkhAAAAAAAgQAAAAAAAAAgQAAAAAAAAAgQAAAAAAIAAAQAAAAAAMGhSCAAAAAAACBAAAAAAAAACBAAAAAAAgAABAAAAAAAgQAAAAAAAAAyaFAIAAAAAAAIEAAAAAACAAAEAAAAAACBAAAAAAAAACBAAAAAAAACDJoUAAAAAAIAAAQAAAAAAIEAAAAAAAAAIEAAAAAAAAAIEAAAAAADAoEkhAAAAAAAgQAAAAAAAAAgQAAAAAAAAAgQAAAAAAIAAAQAAAAAAMGhSCAAAAAAACBAAAAAAAAACBAAAAAAAgAABAAAAAAAgQAAAAAAAAAyaFAIAAAAAAAIEAAAAAACAAAEAAAAAACBAAAAAAAAACBAAAAAAAACDJoUAAAAAAIAAAQAAAAAAIEAAAAAAAAAIEAAAAAAAAAIEAAAAAADAoEkhAAAAAAAgQAAAAAAAAAgQAAAAAAAAAgQAAAAAAIAAAQAAAAAAMGhSCAAAAAAACBAAAAAAAAACBAAAAAAAgAABAAAAAAAgQAAAAAAAAAyaFAIAAAAAAAIEAAAAAACAAAEAAAAAACBAAAAAAAAACBDYgcVikevXr5t7AAAAAAAcBU0KU1loaKhkyJDB3AMAAAAA4CgIEAAAAAAAAAIEAAAAAACAAAEAAAAAACBAAAAAAAAACBAAAAAAAACDJoUAAAAAAIAAAQAAAAAAIEAAAAAAAAAIEAAAAAAAAAIEAAAAAADAoEkhAAAAAAAgQAAAAAAAAAgQAAAAAAAg9evXFw8PD9m9e7ftaFy9elXc3Nzk2LFjCdp+8uTJTn0kKTEAAAAAADisBQsWSLly5cTPz8/c6/OUkilTJhk+fLikVQQIAAAAAACpxmKxyM2bNxN0+/777+WJJ56QPXv2yO3bt829PtflCX0P3V9CDRgwQDZs2CB//fVXvK/PmTNHypYtKxkzZpQqVaqYddWQIUNk7dq1MmzYMEmfPr00b95cnJGbJTFHC4/s+vXrkiFDBrl27ZoEBgZyRAEAgE3rGeec+mgs6ZPD3kMA4AT0pF1PolPLjRs3xN/fP0ElAu3atZOwsDBZsmSJOfnXEgPNKggODpZ9+/bJc889J4sXL5by5cvLokWLpG/fvnLw4EHJkiWLbftBgwaJsyKDAAAAAACA/+gJ/vHjx00AILZPP/1UXn31ValYsaK4u7tLhw4dpESJErJs2TJxFZ72HgAAAAAAIO1Ily6duaqfENWrV5e9e/fGKRPQpoGlS5eWjRs3Jnh/ieHn5yejR4+WN954w5QNWGmjQl2mr1lFRkbK6dOnxVUQIAAAAAAApBo9wU9Iyr966623TM8B3UaDBNZ7XZ7Q90iK3r17y8SJE+Xrr7+2LcuXL5+8+OKL0r9//3i30awCZ+f8XwEAAAAAwCVpGv/8+fNNY0BfX19zr7MYtG/fPkX36+HhIe+++66MGzfOtmzgwIHywQcfyLZt20yQ4tatW7Jq1So5deqUeT1Hjhxy5MgRcWYECAAAAAAADh0k2Llzp2keqPcpHRyw0syFIkWK2J63atVK3nvvPdOYUBsXFixYUD7++GOJiYmx9S7QgIHOcKDrOiNmMUhlzGIAAADuh1kMAAD2RAYBAAAAAAAgQAAAAAAAABwsQDB+/HipUqWKBAQESPbs2aVdu3by77//xllHm0GMGTNGcufObaafqF+/vpn24mG0sUWpUqXEx8fH3C9cuPCedaZOnWrqSLT5RaVKleJMafEo+wYAAAAAwNE5VIBgzZo18sILL8imTZtk5cqVEhUVJU2aNJGbN2/a1pkwYYKZbmLKlCmydetWyZkzpzRu3FhCQ0Pv+746P2aXLl2ke/fusmvXLnPfuXNn2bx5s22duXPnmqYSI0aMkB07dkidOnWkefPmcuLEiUfaNwAAAAAAzsChmxReuHDBZBJo4KBu3brmCr5evdcT+WHDhpl1wsPDzXQS77//vvTr1y/e99HggDYHXL58uW1Zs2bNTOfJH374wTyvVq2aVKxYUaZNm2Zbp2TJkiaLQTMbkrrvu9GkEAAA3A9NCgEA9uRQGQR3u3btmrnPnDmzuQ8ODpazZ8+arAIrLRmoV6+ebNiw4YEZBLG3UU2bNrVtExERYeayvHsdfW5dJ6n71iCCBgVi3wAAAAAAcDQOGyDQK/aDBw+W2rVrS+nSpc0yPUFXetU+Nn1ufS0++tqDtrl48aJER0c/cJ2k7luzDzJkyGC75cuXL0FfPwAAAAAAqclhAwQDBw6U3bt320oAYnNzc7snmHD3sqRsk1zrxDZ8+HCTCWG9nTx58oHjBAAAAADAHjzFAb344ouyePFi+euvvyRv3ry25doUUOkV+1y5ctmWnz9//p4r+7Hpdndf5Y+9TdasWcXDw+OB6yR131qGoDcAAAAAAByZQwUI9Gq8Bgd0CsI///zTTDkYmz7XE3Wd4aBChQq2/gHaxFAbBd5PjRo1zDavvPKKbdmKFSukZs2a5rG3t7eZ1lDXad++vW0dfd62bdtH2jcAAAAAwD6NWZf0uf/FXDh4gECnOPz+++/l559/loCAANsVfa3d9/PzM6n8OovAuHHjpGjRouamj9OlSyfdunW77/u+/PLLZhYEPZHXE359/1WrVsm6dets62i/A53+sHLlyiagMH36dDPFYf/+/c3rSd03AAAAAMDx1a9f38xip+d9aZVDBQisUwzqNya2r776Snr16mUev/baaxIWFiYDBgyQK1eumOkJNRtAAwpWuu6xY8dMFoLSTIE5c+bIyJEjZdSoUVK4cGGZO3eu2Tb2VIiXLl2SsWPHSkhIiGmMuGzZMgkKCrKtk5B9AwAAOJqQ7b/IwSUfyc2zR8Q/Z2Ep1nqI5KrY0t7DAgA4GHdHKzGI72YNDliv5I8ZM8acxN++fduk+FtnObDS4MDdQYaOHTvKgQMHTFnA/v37pUOHDvfsX0/8dVudmlCnPdSsg9gSsm8AAABHCw5sm9ZbQk/vl5iocHOvz3U5AOBef/75p2TMmFFmzJhhZqHLkiWLuVgcm5ae6wVjXU971OnsdVbfffedlCxZ0ryms/Lt2LHD9pqepw4bNkwaNmwo/v7+Ur16dTl9+rQ5z8yWLZvpwacl91Z6Pvy///1PSpQoYd5Pt9fz2TQRIEgOoaGhcuTIERk6dKi9hwIAAGB3mjkg4qafMu8s0Hs3t/+WAwDud165Z88eOXTokClN//TTT20Z6nrCr6XrGjS4cOGCuRDdoEED89ratWvl+eefl88//9y8pheqmzZtama0s5o9e7Z8/PHHJoNdgwR16tQxZfV6IXr06NHSt29fiYyMtGXZz5w5U5YsWSIXL140F7pbt25tLnynBJcLEGi6v04lmD59ensPBQAAwO5uhBzSqEDchRaLKTcAAMTPYrGYrABfX1+TDaBl65plrrRf3ZNPPilPPPGEeHl5mZN7zQRQ33zzjTz99NMmG11f034GmTJlkl9++f+sLX1dM9H1vfU9tIxdG+p7enrKU089ZQIHx48fN+tqYELL4LUHnr7+0ksvmfU3b96cIt86lwsQAAAA4I6T638QS3RUvIfDP3vc2aIAAP8vMDDQNKS30iv9mlWg9ORdT9jjc+rUKSlQoECcZTojni630tnxrHQfOXL8/0wL1n3euHHD3GsJvAYUtLzAetN+eLHfz2WbFAIAAODRxURFyr4fx8ixP2b+/0K3WGUGOl3zzSsSGnJQAnIV45ADQCIEBQXJ4cOH431NewjoSX1s+lyXJ4X2QJg8ebI0a9YsVb5HZBAAAAC4kPDQi7JpUmdbcKBY66FSsd8MCchTUtw9fcQ/eyHxSp9Zwq+dk/XjWsjZnb/Ze8gA4FT69u0rP/zwg2kmGBUVZfoLbNq0ybymV/u1x8D69evNa5988okpGWjRokWS9vXCCy/Im2++Kf/++695fv36dfn5559t2QzJjQwCAAAAF3Ht+G75e+ozEnb5tHj6ppfyvadIzvJ3rjrlrtzKtl749Quy7fO+cvngJvn7055SrM2rUrTlK+LmzrUjAKlnSZ//T613JhUrVpT58+fLqFGjpGfPnqb/3csvv2z6ENSrV88EBXr37m2aDmqvgeXLl5vSgKQYOHCgeHh4mOaE2mtPe+7pzAiPP/64pAQ3i3ZfQKrRiI82sdAok9a1AAAAWLWecS7JB+PUpvmy+5shEhN522QJVB4464HlA6YMYd5oObb6S/M8R/nmUqH3JyawkNY+7AMA7iBMDAAA4MRioqNMv4GdM18wwYHsZRpK7RHLH9pbwN3TS0p3Gyflek0Sd09vObdzuawb10JunDuaamMHADgWAgQAAABOKuLGZdnycTc5uuIz87xIi0FSZeA34pUuQ4LfI1+trlLj1UXikzGn3Ag5KOvebSbn9qxKwVEDABwVAQIAAAAndP3UPnMyf3H/X+Lhk04q9v9CSrR/XdzcPRL9XpkKVZQ6I1dIpsJVJCrsumz9pLscXv6JmQccAJB2ECAAAABwMmf+Xizrx7eUWxdPSLqs+aXW679I7kqtH+k9fTNklxpD50v+ut3NdIgHFrwr2z9/TqLCbybbuAEAjo0AAQAAgJOwxETL/v9O3KMjwiRrqXpSe+RvEpi3ZLK8v/YiKNv9Aynz9ARx8/CSkG1LZP34VnLzwvFkeX8AgGMjQAAAAOAEIm5elS2fPC1Hln9inhdqOkCqvjRbvP0zJfu+gur1MNkEPoHZJPT0flPKcGHfX8m+HwCAYyFAAAAA4OBCTx+QdeOay4V/Vou7t59U6DNNSnV8U9w9PFNsn5mLVJXaI1dIxoIVJPLmFdk8+Uk5smIafQkAwIURIAAAAHBgZ3csl3Xab+B8sPhlziO1hi2WPNXap8q+/TLlkhqvLpS8NbtofYPs//Et2THjBYkOv5Uq+wcApK6UCzsDAAAgySwxMXJwyYdyaOlE8zxL8ZpSsd908QnImqpH1cPLV8r1miwZgsrKvrlvypktC+TG2UNSecCXki5LvlQdCwDXcu6ZR2uumhA5vlqS4vtwJWQQAAAAOJjIsFD5e+oztuBAwYZ9pdqguakeHLByc3OTgo/3lmqD54l3+sxy/cQeWfdOU7n473q7jAcAUsq6deukefPmkilTJsmYMaOUK1dOJkyYIBEREY/0O3Tnzp3iDAgQAAAAOJAbZw/L+nEt5Nyu38Td00fKPfOxPPbk2+Lu6WXvoUnW4rXuzJqQv4xE3Lgsmyd2luDfZ9CXAIBLWLp0qQkONG3aVA4dOiRXr16VuXPnyr59+yQkJETSAgIEAAAADuLc7pWmGaGm8PtmzCU1X1sk+bT+34FoWUGt136WPNWeMNMu7p0zUnbNGiTRkbftPTQASDKLxSIvvfSSDBs2TAYNGiRZs97J2CpRooTMmjVLgoKC5O+//5ZatWqZzIJSpUrJDz/8YNt++/btUr16dQkMDDTbtm59p3yiatWq5r5mzZqSPn16GTdunEN/l+hBAAAA4AAfTPVD49Ypo/SJZC5STSo9P8NMM+iIPHzSSfneUyRD/jKy76excmrDXAk986+car1E8ubNa+/hAUCiacZAcHCwdO3aNd7XNZugWbNmMnr0aOnfv79s2LBBWrZsKfnz5zdBg4EDB5qggC6PjIyUzZs3m+22bNliSgx0efny5R3+O0MGAQAAgB3duHFDOnXqJCNHjjTBgaD6PaX6kB8dNjhgpR94CzXpL9UGzREv/0xy7dhOqVy5sqxfT18CAM7nwoUL5j5Pnjzxvv7LL79ItmzZ5MUXXxQvLy+pV6+edOvWTb7++mvzui47fvy4nDlzRnx8fKRu3brijAgQAAAA2MmRI0ekRo0aMn/+fPPhskz3D6XMU++Lu6e303xPspWqK7VH/CoBeUrKuXPnpEGDBvL555/be1gAkCjWkoLTp0/H+/qpU6ekQIECcZYVKlTILFdffvml3L59WypVqmTKEqZMmeKU3wECBAAAAHbw22+/mSvu//zzj+TKlUvWrFkjQXWfdsrvhX+2IKk1fKnJhNDUWk2/7devn4SHh9t7aACQIMWKFTMBgDlz5sT7upZPHTt2LM4yLUmwllUVLlxYvvnmGzl79qzMmDFDhg4dKtu2bbNlXDkLAgQAAACp3G/ggw8+kBYtWpia1mrVqpnGV5pJ4Mw8ffxNt+/x48ebD8PTp0+Xxx9/PM10/gbg3PT31ieffCLvvfeeub906ZJZfvDgQendu7fUrl1bzp8/L1OnTpWoqChZu3atfP/999KjRw+zngYHNItK30enSHR3dxdPzzst/3LkyGEyxpyBm0X/SiHVXL9+XTJkyCDXrl0zHS4BAEDacevWLfNB03qF6tlnnzUfNrVeVbWecU6c2ZI+Ocz98uXLTaMv/byTO3duWbBggQmEAICjW7dunbzzzjuyadMm81ybEHbv3l1efvll2blzp5nhYO/eveZ324gRI+Tpp+9kfmmgYMWKFaavjAYEBg8eLC+88IJ5TTMKtLmh/g3QWRJef/11cVQECFIZAQIAANImTU1t3769+YCpV5U+/vhjef755+OknrpKgMDaEbxt27ayf/9+8fb2ls8++0yeeeYZu44PAPBglBgAAACksD/++MP0G9DggHbB/v3332XAgAFOVZeaWEWLFjXTfLVr104iIiJMtoR2/9YeBQAAx0SAAAAAIIVoJefkyZOlSZMmpp5Vu1tr0ypnnf4qsQICAswMDW+99ZZ5rl29GzVqZOp4AQCOhwABAABACggLC5NevXrJK6+8ItHR0aaGVZta5cuXL00db23U9eabb8rPP/9sAgZ//fWXyaawdvcGADgOAgQAAADJ7OTJkyZLQLtae3h4mCyCr7/+Wvz8/NLssW7Tpo0pOdCpxPT4aEfw7777zt7DAgDEQoAAAAAgGWmWgF4h16kLs2TJIr/99pvpfu3K/QYSqmTJkrJlyxZp2bKl3L5922RVDBkyxEwZBgCwPwIEAAAAydRvQKcsfPzxx02Nfbly5WTr1q3SsGFDjm8sOt3z4sWLzfRgauLEidKsWTPbnOMAAPtxuACB1qW1bt3azCupkfZFixbd88d3zJgx5nVN06tfv76Zh/JhtEFOqVKlzDzDer9w4cJ71tE/6gULFhRfX1/TREivACTHvgEAgGsLDw+Xvn37mjmv9Wp4ly5dZP369eZzBeLvS6DzjP/444/i7+9vZnXQrItdu3ZxuADAjhwuQHDz5k0Tcdcut/GZMGGCiTTr6xqVz5kzpzRu3FhCQ0Pv+54bN240f6g1jU3/8Oh9586dTR2c1dy5c2XQoEEmmr1jxw6pU6eONG/eXE6cOPFI+wYAAK7tzJkz5qLBzJkzzYmvfl744YcfzIkvHqxjx47mc1qhQoXk2LFjUrNmTZk3bx6HDQDsxM2il8UdlGYQ6JV+nT9X6VD16r2eyA8bNswWsc+RI4e8//770q9fv3jfR4MD169fl+XLl9uWaSpbpkyZzB9wVa1aNalYsaJMmzYtTp2c7nv8+PFJ3vfddByaWnft2jUJDAx8hKMDAADsTU9uO3ToIGfPnpWMGTPKnDlzpGnTpkl+v9YzzokzW9InR5K2u3z5sjz55JOycuVK81w/a7377rumwSMAIA1nEDxIcHCw+QOscwlbaclAvXr1ZMOGDQ/84x17G6V/vK3bREREmKl27l5Hn1vXSeq+NYigQYHYNwAA4PxmzJhhPgfo54PHHnvMZBc+SnAgLcucObMsW7ZMXn31VfNcL75oI8MrV67Ye2gAkKY4VYBA/wArvWofmz63vna/7R60zcWLF838xA9aJ6n71uwDzRiw3tLa3McAALgavbAwYMAA03MgMjLSZBDoxYgiRYrYe2hOzdPT01aeob2edPaHKlWq0O8JAFKRUwUIrO6eJkjT/x82dVBCtkmudWIbPny4KSew3nTeXwAA4JzOnTtnZiXQkkT9+29ttBcQEGDvobkMLTXQ7MygoCA5cuSIVK9ePd7m0gCANB4g0KaA6u4r9jqV0N1X9u/e7kHbZM2a1dS4PWidpO5byxC010DsGwAAcD5aQqCzHK1bt878PbdO1aeNCZG8ypcvL3///bc0aNBAbty4YbI03nzzTYmJieFQA0AKcqq/aDpVkJ6oWxvYWNP81qxZY7re3k+NGjXibKNWrFhh28bb29v8wb97HX1uXSep+wYAAM7vm2++MTMcnT59WooXLy5btmyRVq1a2XtYLk0v4GiZwcsvv2yev/3229K2bVuTkQkASBme4mA0Snz48GHbc20OuHPnTtO8Jn/+/GYWgXHjxknRokXNTR+nS5dOunXrdt/31D8sdevWNQ1v9A/Lzz//LKtWrTJXAKwGDx5spj/UOXg1oDB9+nQzxWH//v3N65pGmJR9AwAA56U9BrRx3scff2yet27dWr799lvTVwgpz8vLSyZPniwVKlQwM0YtXbrUzDyln+U0UAMAcPEAgTWdLPaJu+rZs6fMmjVLXnvtNQkLCzPNgbSzrf6R0GyA2LV/vXr1MnPp/vnnn+a5XuHXaYdGjhwpo0aNksKFC8vcuXPNtrGnQrx06ZKMHTtWQkJCpHTp0qabrta/WSVk3wAAwDVcuHDBfD5YvXq1ea4p7qNHj6akwA70c2CpUqVMqcG///4rVatWldmzZ5PFAQDJzM2iXfZcTP369c1tzJgx4mh0mkO96qDpcfQjAADAMe3YsUPat28vx48fl/Tp05sSA32e0lrPOCfObEmf+/dlSq4mkR07djRZoJrdqRd23njjDYI2AJAWexAkRGhoqOl4O3ToUHsPBQAAOCGdZq9WrVomOKBTF27atClVggN4OG0M/fvvv5tsTr3GpZmhnTp1Mp//AAAuWGLwqDTdn6kEAaRlXIHk+PHzlzSWmGgpdXiyfPDBB+Z5s2bN5Pvvv5dMmTLZ9ZgiLm0u/emnn5q+BBooWLBggSk7yN5thvhnL+i0hyulsy8ehr8dHD9+/pLO3v9/k5PLZRAAAAAkVsTNK7L542624MDrr79uGuIRHHBcffr0MbNJ5cqVS/bu3Svr3m0m5/+50y8CAJA0BAgAAECadv3UfnNyeXHfGjM7kTYyHj9+vHh4eNh7aHgInXlKG1xr4+jIW9dky/+eksO/TjHlBwCAxCNAAAAA0qwz25bI+vdayq0Lx8UvSz7ZsGGDdO7c2d7DQiLkzp3bZBLkq91N60TkwPx3ZMcX/SUq/CbHEQASiQABAABIc7TfwIGF42X7Z30lOvyWZC1ZR+qM/E3KlStn76EhCXx8fKRsj4+k9FPviZuHp5zZ+rNseK+NCfwAABKOAAEAAEhTNBV965SecnjZx+Z5oSb9perLP4h3+sz2HhoegU57WKB+L6k++CfxDsgq10/tlbVaOrJ/LccVABKIAAEAAEgzQkMOyrp3m8v5PavE3ctXyveeIqU6jRF3D5eb2CnNylKsuskGyRBUViK1+eTkJ+Xoqun0JQCABCBAAAAA0oSzO3+V9eNayM3zR8U3cx6pOexnyVu9o72HhRTgp9/f136WPNU7mnKSfXPflJ1fvijREWEcbwB4AAIEAADApVliYuTg4g/l7097SdTtG5JZrzCP+FUyBtFvwJV5ePtJ+Wc/kVJd3hY3dw85vekn2TChrYRdPm3voQGAwyJAAAAAXFZkWKj8Pe1ZObjkQ/O8QINnpforP4pPYDZ7Dw2p1JegUKO+Um3QXPFKn1muHd8ta99pIpcObuT4A0A8CBAAAACXdOPsEVk/voWc2/mruHt6S7lek6R0t3Hi7ull76EhlWUtWdtkjQTmfUwiQi/Jpomd5NjqL+lLAAB3IUAAAABczrk9q2TduOZyI+SQ+GTMKTVeXST5anW197BgR+my5pdary+R3FXaiSU6Sv75/g3Z/fVgiY4M5/sCAP8hQAAAAFyGxWKRw8v+J1s/6S5RYdclU+EqUmfkCslUqKK9hwYH4OGTTir0nSYlO44ScXOXk+t/kI0ftJfbV8/ae2gA4BAIEAAAAJcQdfumbP+8rxxYOE4jBZK/bnepMXS++GbIbu+hwcH6EhRu+oJUfWm2eKXLIFeDt5u+BFeO/G3voQGA3REgAAAATu/mheOy/r1WErJtqbh5eEmZpydI2e4fmN4DQHyyl24gtUf8KgG5i0v4tfOy4YP2cvyv7zhYANI0AgQAAMCpXdi3Rta901RCT+83sxNo1kBQvR72HhacgH/2glJr+DLJWbGlWKIjZc+3Q2XPd69JTFSEvYcGAHZBgAAAADhtv4Ejv02VzZO7SuStq5KxYAWpPXKFZC5S1d5DgxPx9PWXSv1nSPF2r2v9gRxf841s/Kij3L523t5DA4BUR4AAAAA4nejwW7Jjxguy/6exIpYYyVuzi9R4daH4Zcpl76HBSfsSFG05SKq88LV4+gXIlcNbTFbK1eAd9h4aAKQqAgQAAMCp3Lp0UtZPaCtntiwQN3cPeazru1Ku12Tx8PK199Dg5HKUayK131gu/jmLyO2rIbJhQjs5uWGuvYcFAKnGM/V2BQBwZiHbf5GDSz6Sm2ePiH/OwlKs9RDJVbGlvYeFNPbzdyPkkFgsMSIx0eKdPrNU7P+FZC1ey97DgwtJn7OI1B6+THZ+OVDO7Vohu756Wfb9+JZE377J7z6kOv72cvxSGwECAECCPqBsm9ZbE3G18ltCT+03zys9P5MgAVLx5y+uYu2GERxAivBKFyiVB8yS7dP7Sci2JRJ547JZzu8+2Pdv7z7zPEf5puKfo3Cy7uu1g/5iT/t230z297x57oic2/mb7bk2suWzy8MRIAAAPJReudXmXTq3/B137v/9eQIBAqQoS0yM7J375r0vaDO5P7+WAvV68h1AinBzd5cb547YTs7++4k0P3v6O5EMKqTK317rz10ssU96k8sHyf+Wjkc/w/D/96EIEAAAHkrLCv4/OPD/bpz5Vw79MlkKNuornj72vfoA15y+8MD8d+X25dP3vmix3Pm5BFLQnZ+xu3738bOHVHIj5GC8y7X3iv7dTU7ty9j3b/jCPcmfQRC86guxxETHXcj/34ciQAAAeCjtOaCpjfH5d9F7cmz1l1Ks1RDJV7ubuHt6cUTxSLRz/IGF4+Ti/rV3FsTJXvmPm5upFQdS/Hff6f33/Py5e3pLTHSUuHvwURop49zulWKJjrr3BTc3CchdQkp1GpOs+/uwTw6xp39nnEv297yw7697///yt+OhmMUAAPBQ2pAwDj1hE5GCjfpJuqz5Jfzaedkze5isGV1Pzmz92cxPDyTWjbNHZNtnfWTduOYmOODm4SUFG/aVsj0nxvm5swYMit79cwmkxO++/9KS//vhM/9G3Q6V3d8MMSUwQHK79O8G2fZZrAwBfvclz/9f/nYkCAECAMBDZchf5v//cHh6S0CeklLp+S/lsS5vSf2315lp5rwDssjN80dNU6917zb7/6u/wEPcvnpWdn/7qqwZXVdCti01H+LyVO8oDd5ZL489+bbkr9XVNMTUnzt3Tx/bz1+uii04tkhR2mcgzs9e3pJSuNlAk+J9asNc2ffjGAKiSFZXj++SrVN6SEzkbTPtZsXnpvO7L7n+//K3I0HIiwIAPJRmBagsxWtJjaHz47ymAYOCj/eWfDW7yNEVn8mRFdPk2vFdsmliJ8laqp6U7DBCMgSV5SjjHpG3rsnhX6dI8O8zJCYizCzLXqaRlOjwhgTmLXXPBz2awsEe4vvZS5+rqJn+MHjVdPFKl+HeLCsgCUJDDsrmyV0l6vYNyVyshlR87nPx8PaT3FXacDyTiL8diUeAAADwUKc3LzD3eap1uP8fFN/0UqzNUAmq31MOLfvYdJi/uG+NrN23RnJXaSfF270u/tkLcLQh0RFhpm/F4WWfSOStq+aIZCpcWUp0GClZilXnCMHhaUA08tZ12Td3lBxc/IEJEhRs2Mfew4ITu3XxhGye2MVMqZkhqJxUGfiNCQ4AqY0AAQDgga6f2m+a/Gg9eM67rqLFxycwm5R+8h1TO37w5wlyessCObN1kYRsXyr563aXYq0Gm3WQ9mhTt1Mb5snBJR/K7StnzLL0uYpJiQ4jTCqtm63OG3B8hRr1NQGuQ0s+kr1zRpogQd4anew9LDih29fOy6ZJXeT21RCTnVLt5e/Fyy/A3sNCGkWAAADwQGe2LDT32cs0FG//jAk+Wv7ZgqRCn0+lUJPn5cDCd+XCP6vl+OqvTN1uocb9pFCTAXwASiO0aeXZHcvl30Xj5UbIIbPMN3MeKd7mVXNCpfXcgDMq1nqoKZU59vsM2TVrkHj6BUjO8s3sPSw4kYibV2Xz5Cfl1vlg8cuST6q9Ms/09AHshSaFSTB16lQpWLCg+Pr6SqVKlWTtWhpxAXDdEzvNAFB5qrZP0ntkyF9aqr38g1QfOl8yFqwg0eG35NDSSbL6jWpydNUXEh0ZnsyjhqN1417/XivZNu1ZExzw8s9kpufSBoT5aj1JcABOTbNeHus81gS6dL717Z/3k4sH1tl7WHASUeE3ZesnT5tphDWzrvrgeeKXKZe9h4U0jgBBIs2dO1cGDRokI0aMkB07dkidOnWkefPmcuLEiZT5DrmgBQsWSLly5cTPz8/c63Nw/OCYrhz5W8IunRIPH3/JUbbxI71X1uK1pNbwZaajsH+OwhJx47Kp3/1zVG05tfFH8+EaruP6yb2y+eOusvHDDnL16DZTS1ukxSB5fNxmKdSkv3h4+dp7iECycHN3l7I9J0mO8s0kJipctk7pKVeDd3B08UAaHP976rPm76xXuowmc8A/e0GOGuyOAEEiTZw4UXr37i19+vSRkiVLyuTJkyVfvnwybdq0lPkOuRgNBjzxxBOyZ88euX37trnX5wQJOH5wTNbsgZwVmouHT7pkudqmHYXrvbVGynT/UHwy5JCwSydl55cvyl9vN5Zze1YxZZiTu3nhuOyY8YL89XYjU1bi5uFpGlc2eHeTlGj/unilC7T3EIFk5+7hKRWf+8zM9BIdflM2/+8pCT3zL0ca9+3HsmPGANPIV/+2Vn1ptgTmLcnRgkOgB0EiREREyLZt2+T111+Ps7xJkyayYcOGeLcJDw83N6vr169LWvbWW2+ZEwRNW1bW+169eskXX3xh59E5vvXr15v72MdPj+fYsWOlQ4f7d5cHkiImKlJC/l780NkLkvphOqju05K3WgcJ/mOmHF7+iUmx3Pq/p6X+zuny/vvvS/XqdLN3JufPn5e3335b/pz2uViiI82y3FXa/jd7BVfF4Po0K6bKwK9l40cd5dqxnbJ50pNSc9jPki5rfnsPDQ7EEhMje74dKme3/2KmCa48YJZkKlzJ3sMCbNws1jMNPNSZM2ckT5485iStZs2atuXjxo2Tr7/+Wv79995I8ZgxY8xJ8d2KFSsmHh4e0rVrV3nhhRekdu3attf27dsnr7zyivz222/m+ciRI6VIkSLmJFoVLlxYlixZIq1bt5YjR46YZbNmzZLDhw/LO++8Y543bdpUJk2aJKVK/f880uvWrZNPP/1UfvjhB/Nc96vrtWlzZ27VTJkyma+tZ8+esnXrVlvGhBo8eLC5r1Klivlaa9WqJVeuXDHLFi9ebMaq760e9DV9/PHHXB1MAV5eXub7kFzfJ0f42VtdrbA4sw4HL6f4/6f7fZ+S69j9ceq8dFu1RbL4esvOzo3Eyz3lks6uhEfI/3Yfli/3H5PwmBizrH79+qZ8y8fHh589B/7Zy5kzp3Tp0kUuXbpk+/1eL3dWeaNiCSmXNeFNLR3F74272vVvboW5d46/s8rx1RK7/N7T79OMrOIQLt+OkHa/bpCDV29IgYB0srh5Tcme7uElNfzsOe/Pnv6OOPdM64eOUX9Hjtm6Tz7fFyzubiIz6leSFkGO0XPg+POj7Hqu4ey/+16LyWy3n73EfJ/0PR+GAEESAgSaLVCjRg3b8nfffVe+/fZbOXDgQIIyCLQk4dq1axIYmPbSLLXngJYVxI5L6RXwvHnzmitPeDD9xXD69Ol7jl/ZsmVl586dLnX4EvKH1tE/qDj7sRu4dof8dOS0PFMiSMZXLyOp4fTNMPk0IMj8gYuJiRF3d3d59tlnTbBVf/+mBn72Ekb/tn322WfmQ8jFixfNssqVK8uwzJ5SJ7eDnKk52f9dxc+faxy7kJth0mb5Bjl5I0xKZQqQBc1qSEYf7wduw8/eo3GG4zdx10GZsOOgefxx7XLSpUg+cRTOcPwcWQ47H7/kRIlBImTNmtVc9T979uw9aZU5cuSIdxu98qU33DF69GjTc8BaZmC918yC9u2T1iE9LQkICIhz/JTe63EFktOtqGhZfvzO77onCuVNtYObx99PZs6cKUOGDJE33nhDfv75Z5kxY4Z899138tJLL5kSL70CAfuJjo6W77//Xt588005duyYWVa0aFETLO/YsaOcf/bOlSIgLcvl7yfzmlSXNss2yL4rofL0qq0yt0k18ffio3daNWNfsC048HbVUg4VHABio0lhInh7e5tpDVeuXBlnuT6PXXKA+9M6+fnz55sr3jpNpN5rg0KCA4k7fmXK/P/VXD2J4vghua08eU5uRkVLvvR+Uilb6qeJayrcokWLTCqizhajTU0nTJgghQoVMvdhYWGpPqa0ToORv/zyi1SoUEF69OhhggO5cuUyWQR79+6VTp06meAlgDsKBvqboEAGby/5+8IV6b16m4RHM1tLWjTv8CkZuWWveTykXFHpW6qQvYcE3BcBgkTSWhK9mvXll1/K/v37TV2I1sj2798/sW+Vpk9yNR1eP+DrPSe3iT9+u3btMtNtqoMH70SjgeS08OjpOz9vhfLY9aRPg69r1qyRpUuXSunSpeXq1asybNgwc8VafxdHRUXZbWxpycaNG6VevXrSqlUrUyaWIUMGGT9+vKlz7Nevn+mDAuBepTIHyuxGVcXP00P+PHNBXvhrp0TH0P4rLfn1xFl5Zf0u87hvyYIytHwxew8JeCACBImkjZh0akPtGl++fHn566+/ZNmyZRIUFJTYtwIeiTZ4sTY5uXz5MkcTyeZqeIT8fvq8edy+YOrU/T+IBihatmxpAora5Cd//vymF0ffvn1NNs3ChQtpfppCtJlRu3btTKBm7dq1pmTu1VdflaNHj5pyj3TpHn3qS8DVVc6eSWY9Xlm83N1k6fEQeXXjbn5npRFrz1yU5/7cLtEWi3QpklfeqlqKTCs4PAIESTBgwACTWqkNmnTaw7p16yb/dwZ4CA1QadNHnX5zzpw5HC8km1+On5XIGItprFUiU4DDHFntAaOp7TpjjHYIzpIli2kOq1k11kwDJI+TJ0+a5pAagNE+ENossnfv3iZjQEs8MmfOzKEGEqFe7mwytW4F07n++0MnZezf+wkSuLjtF65Izz+2SkRMjLTIn1M+qllW3CnDghMgQAC4QBaBXlUFksuC/8oL2heyf/ZAfLR/iZZ36ZQ+I0aMMFexN23aZKZF1EyD3bt323uITkunKhw6dKgp4fjqq6/MTBJaBvbPP/+Ykg6dcQZA0rQukFs+rFHWPJ6296h8sufOtGRwPfuvXJduK7eYhr91c2WVafUqiGcKThUMJCd+UgEn9tRTT4mnp6ds2bLF9MQAkmNqrg1nL5nH7QrmdugDqnXwOsWeXtV+/vnnzf8FLfnS7BprEz0kzM2bN2XcuHGmCeRHH31kMuS054D2HtBGsiVLluRQAsmgW7H8Mrrynf9P47YfkFkH+D3lao5dvylPrtgsVyMiTZPfrx6vLD4eHvYeFpBgBAgAJ5Y9e3Zp3ry5eUwWAZLDouAzou2zqmXPLPnSO0d9uXbSnzp1qqmX79y5s0nb/fbbb6V48eKmmeeFCxfsPUSHFRkZKdOmTZMiRYqYbIzr16+b0iUNtKxevVqqV69u7yECLuf50oVlUNki5vHwTf/YmsLC+Z29dVs6r9gs58LCpUTGAPmuUVWmtoTTIUAAOLlevXqZez0h0vnJgUexMPiMuW9fyLGzB+KjafFz586VrVu3SqNGjUx/jo8//lgKFy4sb7/9tty4ccPeQ3QYWjqgx0qnk9S+OmfPnpWCBQvKd999J9u3bzeBR6YsBFLOsArFpVeJIBOQfXHtTjO1LJzb5dsR0nnFJjlx45YUCEhnprjM5ONt72EBiUaAAHByWnOtDcPOnDkjq1atsvdw4MQOXb0huy9dE083N1Mr66wqV64sK1eulBUrVkjFihUlNDRU3nzzTXOV/NNPPzWBg7RMj03VqlXlySefNOUZ2bJlk//973+m4aOWLWlDQgApSwNw46qVlg6FckuUxSJ9/9xmZsaCc9K/M91WbZaDV29IznQ+Mq9JdcmRztfewwKShE8BgJPTace6detmHlNmgEexMPhOmmu9PNkki6/zX/Vo3LixySbQWT40i+DcuXMycOBAc9Vcl+lV9LTk77//NpkVTZo0MTPwpE+fXsaMGWOaPb744ovi7e3833PAmWhH+49rl5dGebPL7egYad26tcnggXO5ffu2tG3bVnZevCaZfbxkbpPqkj/AOUr0gPgQIABcaDYDnQ/+2rVr9h4OnJDW7VvrYDs4eHPCxNCr4V26dDH9CTR7IEeOHOaEuGvXrlKlShVzNd3VHTx40PRm0K/3999/Fy8vL3n55Zfl6NGjMnr0aAkIcJypLIG0xsvdXb6oX0mq58hseoA0a9bMTOUK5+njon9jtGdLei9P+b5xNSmekd+pcG4ECAAXUKlSJXNVVKPY8+bNs/dw4IR2XromwaG3xM/DXZrlzymuRq+Oa629ptSPHTvWnBTrlTq9mq5X1fXquqsJCQmR/v37m98NP/74o0lp7t69uwkYTJ482ZQWALA/P08P+bZhFVMSpU1VNfvpxIkT9h4WHkKz0J599llZvHixyeb8+vHKUj5rRo4bnB4BAsAF6Ad/a7PCWbNm2Xs4cELW7IGm+XO6dMdlTasfNWqUySLQGQ40cKBX1fXqul4FOnTokDi7q1evyhtvvGHKKj7//HPTvFR7lezcuVO++eYbKVCggL2HCOAuAd5e8uuvv5rZV06ePGmCBOfPn+c4OXDWnWZiaWNXDw8PE4StlSurvYcFJAsCBICLePrpp0069YYNG1ziJAepJzrGYqY3VB0K5UkTh16vnk+aNMmk8upVdQ2yafaNXm1/beMeOXfrtjib21HRMvWfI1KoUCEZP368hIWFSY0aNUzjs6VLl0rZsmXtPUQAD/m9pGVP+fPnN5k+Wm5A2aBj0sa3U6ZMMX87tP+T9o8AXAUBAsBF6FzwTZs2NY9pVojE2HD2kpwPC5eM3l5SP3faSjvXq+l6VV2vrutV9qioKPnm3+NSfcFqeW/7AbkeESmOLiomRr4/dEJqLlgtY//eL1euXDGBjkWLFsn69eulTp069h4igATKly+fCRJosGDHjh3mxPPWrVscPwcyceJEeeedd8xjDRLo7C+AKyFAALhgs0I94UlrHdqRdAv+m72gdYFc4u2RNv8s6NV1vcq+Zs0aqZQto4RFRcvk3Yel+vw/5LO9R83VeUdMcV1+/Kw0+PkvGbx+t5y5dVvy+PvKl19+Kbt37zZdtfXqFgDnUqxYMfntt98kMDBQ1q5dK506dUrz07M6ipkzZ8qQIUPM43fffdf0tgFcTdr8JAi4KD0hyJAhg6lf1I66wMPoie8vx0LM4/ZppLzgQerWrStLW9SSrxpUlqIZ0svl8EgZs3Wf1Fr4p8w9fNKUYziCjWcvSetlG+SZ1X/LoWs3JJOPl4yuXFLWt28gzzzzjKmJBeC8KlSoIL/88ov4+fnJsmXLzAUA7ScC+/npp5/kueeeM4+HDh0qw4cP59sBl0SAAHAhvr6+8uSTT5rHlBkgIf44fV6uR0ZJrnS+Zpot3Gn62Twop6xuW1cm1ixrjs3pm2Hy8rpd0nDxX7Li5Dlz9d4e9l6+Lt1Wbpb2v26Uvy9cMd3PB5UtIpufeFyeL11YfD0JDACuonbt2jJ//nzx9PSUOXPmyMCBA+32uyet04yObt26mezMPn36yIQJE8jQgssiQAC4GOtsBvqhIjQ01N7DgYNbcPROc8J2BXOLO+nocXi6u0u3YvllQ4cGMrJSCcng7SUHroZKj9+3SrvlG2Xr+cup9n06HnpLXvhrhzRa/Jf8cfqCeLi5Sc/iQbKpQwN5vWIJCfT2SrWxAEg9zZs3N53yNXD52WefyYgRIzj8qUx7ubRv314iIyOlc+fO5vtA+RZcmZuFUGSqun79ukkB1660WlsGJDf9L12iRAnTAVlrkTXd2Bmde8a5OwLn+GqJOMPvo+zZs0t4eLhphlW+fHl7D8mhf/auhkfIlD1HZMb+YLkdfafHR7N8OWR4pRJSPGNAiozlQli4TN59yDROjPyvvKFtgdwyrGIxKRSY3ml/9gAkzvTp06Vfv37msV69fvXVV5P9EPJ3917awLZ+/frmc7vOKvHzzz+b6XEBV0YGAeBiNKptzSKgzAAPsnDhQhMcKFmypJQrV46D9RAZfbxlZOWSJqPgqaL5xN1N5NeT56TBz2tk0LpdpgwhudyIjJIPdvxrmiTO3H/MBAfq5c4qv7WqLZ/Xr3jf4AAA16S17++99555/Nprr8kXX3xh7yG5PL3QorNDaXDAWu5BcABpAQECwAVZ53XXjuzBwcH2Hg4c1Pfff2/uta6SdMmEy+3vJx/VKidr2taXlkE5RS/szzl8UmrOXy1vbd0nV8Ijkvw9CY+Olhn7gqXa/D/ko12H5GZUtJTLkkF+bFJd5japLuWyZkzyewNwbsOGDTPBAaXZBD/++KO9h+SytNlz48aN5fz58ya7bsmSJZIuXTp7DwtIFQQIABeUN29eadiwoW3KQ+Bu586dk1WrVpnHXbt25QAlQdGM6WVmg8ryS4taUiNHZgmPiZFpe49KtZ/+kE92H5ZbiZgaMcZikZ+OnJLaC/+UkVv2yqXbEVIo0F+m168ov7aqLXVyZ+V7BMBkEWg2gZYTPvXUU6Z5HpKXBgU0OHDixAnblJMZMxKcRdqR6ACB/jLSOihNuwHguGKXGWjXXSC2efPmmZ+LatWqSeHChTk4j6BS9kyyoFkNmd2oqpTKFGBmhXh3+wGpueAP+fbf4xL1gP9/+iF/1alzpvngwLU75eSNMMnh5yMTapSRNe3qSZsCucnuAGCj2V5Tp041zfK0aV6HDh1kw4YNHKFkYu018O+//0q+fPlk5cqVplcPkJZ4JnaD9OnTy8SJE6V///6SM2dOqVevnrlpAw9tjAbAMWjH3YCAAFNisG7dOjO/OxBfeQGS50N7w7zZpUGebLLg6Gl5b/u/cupmmLy6cY98tveoDK+ofx8tMnHXITly7aYUzuAv7QrmMdNMbjp3ZzaEQC9PGVimiPQpVVDSMV0hgPvw8PCQb7/91jSa/fXXX6VFixampJBeMo/m1q1b0rp1a9O0N1u2bCY4kD9/fn4OkeYkeRaDs2fPyp9//mlu+ktJMwo0whYSEpL8o3QhzGKA1KRz9c6cOdPMZKAzGjgTuimnnKNHj5qsAXd3dzl9+rQJ9iJ5f/a0l4DOPDBp12G5HKsngZsJE8Tl4+4uz5YsIC+VLSKZfB69OzazGABp54S2SZMmZhq+HDlyyNq1a6Vo0aJJfr+0/Hc3IiJC2rVrJ8uXLzezjOn5TYUKFZJ1fIDL9yDQK5OZMmUyN63L8fT05EMm4GB69uxp7rWR0c2bN+09HDhY9oD2qSA4kDJ8PDykb6lCsvmJBjK4XFETGJB4ggMZvb1kwxMNZHSVUskSHACQdmjTvKVLl5rMAe0ro3Xzp06dsvewnE50dLT06NHDBAf8/Pzkl19+ITiANM09KR1Uq1evLlmzZpWRI0eaiNvw4cPNLyZNyQHgOHRankKFCsmNGzdkwYIF9h4OHIAmjc2ePds8prwg5QV4e8lrFYqLl3v8f27DoqMlj79fKowEgCvSi3TaRE8zB44fP24yCi5evGjvYTnV38QBAwbI3LlzxcvLy3xW0s9OQFqW6ADBBx98YGqaR48ebbqjf/TRR9KmTRu6ewIOWhdtzSLQZoXArl275MCBA+Lj42P6VCB1FMngb8sisP3/1OWB6fkWAHgkWl6g9fJ58uSR/fv3S/PmzU1JKx5OL3Jq83X9vPTdd9+ZBoVAWpfoAIFmCYwYMUK2bNlimp5pemqXLl1k2rRp5pcSAMeiaXPqjz/+MFP2IG2zlhe0atVKMmTIYO/hpBlDyhcz5QVud/UiGFI+6fXCAGAVFBRkggSa4fv3339L27ZtJSwsjAP0kCkj33//ffP4888/NzNDAEhCgEDrnF566SWTgnPhwgWT1qQ1ULqsdOnSHFPAwRQoUMDMMqJpdNr1GGmXTmv4ww8/mMeUF6SulkG5ZGaDSlIyU4D4eLib+y8bVJIWQblSeSQAXFXJkiXNrAbaJ0yb7OkFPJ0KEff67LPPTPaANTu6b9++HCYgqdMcWrMIrDMYaMdUTWMqX768NGjQIClvByCF9erVy/x/1TKDN954g3nV0yid7lIbWGmHZp0WC6kfJNAbAKSUSpUqyZIlS6Rp06bm/tlnnzV/+3XWGtyhgXLtO6D0M9HQoUM5NEAsif5tobMWVK1a1TS50oYo2ofg8uXLJp1JI3AAHM8TTzwh/v7+cujQIdm4caO9hwM7lxfoz4Ovry/fBwBwQfXq1TOzF3l4eJi6+pdfftlkEULMDAVaemltTvjOO+9wWIBHDRBoivKlS5dMQODDDz80dax6NQqA40qfPr05KVQ0K0ybdMYZ/cCoKC8AANfWunVr8/dem+9NmTJFxowZI2ndmjVrpGPHjhIVFWX+Dn7yySdkVALJESCIHRDQVNXTp08n9i0A2KnMQM2ZM4fGRWnQihUrTLaXdrumHAwAXN9TTz1lToLV2LFjZfLkyZJWbdu2zQRNbt++bc5lZs2aRdkFkFwBAm1ypb9ktPu1dkzNnz+/meLw7bffNq8BcNyUQ/0/qz1Dfv75Z3sPB3YqL3jyySdN2ikAwPW98MIL5jO6euWVV+Srr76StEZnWdPpC0NDQ81noXnz5omXl5e9hwW4ToBApzjUVCWdGkSbFW7fvl3GjRtnIpSjRo16pMHozAjaVEWnaNGUqJ07d96zTnh4uLz44otmHa2pbtOmjclkeJipU6dKwYIFTd2tNnDR5oqxaS2Spl/lzp1b/Pz8TNf3vXv3Jsu+AUegDYqsUx5q5Bxpx40bN2xBIcoLACBt0c/ugwcPNo/79OkjCxculLTi2LFj0rhxY7l48aJUrlxZFi9ebD7nA0jGAIHWM82YMUOef/55KVu2rJn2UJt8fPHFF4980nHz5k2pVauWCT7cz6BBg8wvNk2T1o7c+sFXU4Wio6Pvu83cuXPNdvoLUoMaderUkebNm8eZE37ChAkyceJEE/zYunWr5MyZ0/xC0Wjjo+wbcCTWAIHOlUx5UNqhH4hu3bolhQsXlipVqth7OACAVKQX3bRvmM5ooNm+mkm2atUql/8enD171nyW1887OgXk8uXL6ZsGpESAQGtYS5Qocc9yXaavPYru3bvLm2++KY0aNYr39WvXrsnMmTPlo48+MutUqFDBdGfds2fPA3/R6Yl/7969TdRUf0FoDVa+fPlk2rRptuwBXaYBhA4dOkjp0qVNIEQ/UFvTcpO6b8CRFClSRGrXrm0+IOjPL9IG6+8xzR7QD4oAgLRFf/d//vnn5nOuNq1t166dbN68WVzVlStXTFby4cOHpUCBAubCiGYAA0iBAIFmDOhV9rvpMn0tpRuMREZGSpMmTWzLtCRAT+g3bNgQ7zb6S1C3i72N0ufWbYKDg02UMfY6Pj4+pk7Juk5S9m0tS9Ca79g3wJ569uxp7jUIxrRHrk/TKn/77TfzmPICAEi7PD09TcBYr6pr1q5m0/7zzz/iavRra9mypezevds05tXgQJ48eew9LMB1AwSaiv/ll19KqVKlbFfl9bGWF3zwwQeSkvQk3tvbWzJlyhRnuf7n19fu9+FYSwB0nfttY71/2DqJ3bcaP368aehovWnmAmBPnTp1MvV32rRHy2ng2n766SczpVPFihXjzf4CAKQdegFMe35Vr17dXGXXC19Hjx4VV6EX5tq3by8bN240n9k1OKDZkwBSMECgV9UPHjxo/vNdvXrVlBVoutK///5ravsTavbs2WZuduvt7qaBiaFXQR+WNnv36/Ftk5B1Ervv4cOHm/IE6+3kyZMPfD8gpWmgSv//WrMIkHbKCwAA0M/dv/zyi8mCDQkJMaWzZ86ccfoDo8FwndpRgwLaTHzZsmVSpkwZew8LcDqeSdlIU+vffffdR9qxzgBQrVo12/OEpP5o40AtGdCIZ+wr+efPn5eaNWvGu43WG+mUXndf5ddtrBkD+r5K18mVK9d910nsvq2RWr0BjqRXr17mxPGHH34wPTr4GXVN2ohVg68axOzSpYu9hwMAcBCZM2eWFStWmL5EmkGg9fo/lsktmXy8xRnFWCzy3HPPyfz5803G76JFi0yWBIAUyiDQGp6E3hIqICDApPxYbwmZckSnJ9R5SzUyaKWRT62fut9Juv6S0O1ib6P0uXUbnf5QAwCx19FgwJo1a2zrJGXfgKN6/PHHTVBOA15Lliyx93CQQnTGFWvmV968eTnOAAAbvSimjbb1Xj/PPrVyi9yMjHK6I6TZvG9t3SdfffWVmdJZL37cr+E5gGTKIChfvry5AvWwhma6zqNM+aflCnrFy5rmpGULSk/e9aap0dr3YMiQIZIlSxYT/Rw6dKhJH3rQLwKd+1VnSND5T2vUqCHTp083++nfv79t3DqF4bhx46Ro0aLmpo/TpUtnS8tN6r4BR6RZNfp/QqcU1TKDjh072ntISAGUFwAAHkQvkunFr7p168r2i5el1x9/y3eNqoiPh4fTHLhJuw/J5/uCzWOdcUxLnwGkcIBAu/yn1lzdzzzzjO25ztOqRo8eLWPGjDGPJ02aZLqwdu7cWcLCwqRhw4amQaKe8FjVr1/fTGmiy5Wm1l66dEnGjh1rrvprzZXWJQUFBdm2ee2118z7DRgwwFxV1fIHTb3STAerhOwbcKbZDDRAoPMCnzt37p4mnXBue/fulV27dpnMpyeeeMLewwEAOKjHHnvMfBZoUKumrA25KM+v2SHT61cUT/dEtypLdTP2B8uEHQfNY52yXEsoATwaN0sC5jnT7te///67qb3Xk2y9cq5X1x2VBgc0oOCIvyR0mkPNRtCGhYGBgfYeDtI4rc/TeZA/+ugjk2njSM4901qcWY6v7Fu6MWLECJMJpf1efv75Z7uOxdnwswcgLfqpaQ15atUWiYiJkS5F8sqkWuXE/SHNuu1p3uFT8tK6nebxkHJF5cOddwIFAB5NgkKDOh2azimq3nrrLblx44Y4qgMHDpir/j169LD3UACHZw2iaSZMAmKFcBL6vaS8AACQGHVyZ5XP61UUDzc3mXv4lIzZus9hPxv8euKsvLJ+l3nct2RBGVq+mL2HBKS9HgSa+q+dTvUXxYcffmimSInPm2++Kfak83zv2bPHrmMAnIWW32j/Df0/s3PnTqlQoYK9h4RksGnTJjl27JiZ5ql1a+fOxAAApJ7mQTllYq2y8vK6XTJ9X7Bk9PGSweUc6+R77ZmL8tyf2yXaYjGZDm9VLfXQackBJHOAQK8uah+ApUuXmv+AWqektfh309fsHSAAkHBaNtS2bVuZN2+e+X9OgMA1WLMH2rdv79DlYAAAx9OlSD65HhEpo7bsM/X9Gby9pHfJguIItl+4Ij3/2GrKIFrkzykf1Szr0GUQgMsGCIoXL26bLkunD9F+BNmzZ0/psQFIpWaFGiDQk8oPPvjATA0K5xUVFSVz5841j62zsAAAkBh9SxWSq+GR8tGuQzJi814TJOhY2L7T5e6/cl26rdwit6KipW6urDKtXgWnaKQIOJtE/6+KiYkhOAC4kCZNmphpRC9evGhm94Bz0wDuhQsXJGvWrEzBCgBIMq3r71OygHmsJQe/nThrt6N57PpNeXLFZrkaESmVsmWUrx6v7FRTMQLOhLAbkMZpudDTTz9tHn/99df2Hg6SqbxAp2PVKQ4BAEgKLR0eW/Ux6VQ4r6n317r/9SEXU/1gnr11Wzqv2CznwsKlRMYA+a5RVfH3SlASNIAkIEAAwJQZKO0zolef4ZzCwsJkwYIF5jHlBQCAR6X1/ZNqlZVm+XJIeEyM9Ph9q+y8eDXVDuzl2xHSecUmOXHjlhQISCdzm1STTD6UQgIpiQABACldurRUqlTJ1K//8MMPHBEnpQEenYY2KChIatSoYe/hAABcgNb5f1avotTKmUVuRkVLt5Wb5d+roSm+3xuRUdJt1WY5ePWG5EznI/OaVJcc6XxTfL9AWkeAAECcLALKDJy/vKBr166moSwAAMnB19NDvm5YRcpnzSCXwyNNP4ATobdS7ODejoqWniZb4Zpk9vGSuU2qS/4AZuUBUkOSP0FGRETIqVOn5MSJE3FuAJyTnlRqzfr27dtlz5499h4OEunKlSu2JpOUFwAAklt6L0/5vlE1KZYxvYTcui1dVmyS87duJ/t+ImNipN+a7bL+7CXx9/SQ2Y2rSfGMAcm+HwDJFCA4dOiQ1KlTR/z8/Ewaa8GCBc2tQIEC5h6Ac9Ku961atTKPySJwPtp7QAO3Wi5SpkwZew8HAOCCMvt6y9zG1SRfej8JDr0lT67cLNfCI5Pt/WMsFnlFZ0w4eU583N3lm4ZVpELWjMn2/gBSIEDQq1cvk7qqta7btm0zVxv1tmPHDnMPwHnp/2/13XffmX4EcL7yArIHAAApKZe/n+kHkM3XR/ZdCZWnf98iNyMf/TODxWKRkZv3yk9HT4uHm5t80aCS1MqVNVnGDCDhEj1HyM6dO01goESJEondFICDa968uWTLlk3OnTsnv/32m7Rs2dLeQ0ICnDlzRlavXm0rFQEAICUVDPQ3Mwq0/3WjbD1/Rfqs3mZ6FHh7JL3/zYQdB+XLA8fETUT+V7ucNMmXI1nHDCBhEv2/uFSpUnLxYurPgQog5WkPgqeeeso8njVrFofcScydO9dcealVq5Yp9wIAIKWVyhwosxtVFT9PD1l95oK8sHaHRMdYkvRen+09KpN2HzKPx1UvLU8UzpvMowWQrBkE169ftz1+//335bXXXpNx48aZOlc9oYgtMDAwwTsH4JizGUyePFkWL14sly9flsyZM9t7SHgIyguSV46vlvAzBwAJUDl7Jpn1eGV5etUWWXIsRAK9dsuHNcuKm5vmASTM9wdPyJit+8zj4RWLyzMlCHQDDh8gyJgxY5z/6HqlqmHDhnHW0WW6TnR0dPKPEkCqKV++vJQrV0527dolc+bMkQEDBnD0HdjBgwfl77//Fg8PD+nUqZO9hwMASGPq5c4mU+tWMDMPzD50UjL4eMmoSiUTFCRYcuyMDN242zx+/rFC8lKZIqkwYgCPHCCw1rYCSDtZBIMHDzazGRAgcGw//PCDuW/SpInpHwEAQGprXSC3hEZEyeANu2XqP0clk7e3vFj2wSf7q0+flwF/7RCtSniqaD55s3LCggoAHCBAUK9evRQeBgBHon0ItJRoy5Ytsn//filZsqS9h4R4aOYW5QUAAEfQrVh+uRYRKW/9vV/e3X5AAr29pGeJoHjX3Xr+sjy7eptExlikTYFcMqFG4soSADhQk8Jff/1V1q1bZ3v+6aefmpRknVrrypUryT0+AHaQPXt2M6OB0iwCOCadWlZLDPz8/KRt27b2Hg4AII17vnRhGfRf5sDrm/bIoqOn71ln7+Xr8tTKLRIWFS0N8mSTKXUqiIc7wQHAaQMEr776qq1p4Z49e0wacosWLeTo0aPmMQDX0KtXL3P/7bff0lvEQc2ePdvct2nTRgICAuw9HAAAZFiF4tKrRJDofAYD1+6UVafO2Y7KkWs3pMuKTXI9MkqqZs8kMxtUfqSpEQHYqcQgtuDgYDPVoZo/f760bt3azGigV7I0UADANbRs2dLMYHDmzBlZtWqVNG3a1N5DQizaEFabSCrN4AIAwBFoqcC4aqXlekSkLDh6Rp7542/J7e8nITdvS4zFIlEWi5TOHCjfNqwq6Tw97D1cAHdJdMjO29tbbt26ZR7rSYM2xlJ6IhF7OkQAzs3Hx0e6du1qHlNm4HjWrFkjISEhkilTJmnWrJm9hwMAgI27m5t8XLu8lM0SaPoMHA+9JRExMSY4oHqXLGBmOwDgAgGC2rVrm1KCt99+2zQw06uMSutg8+bNmxJjBGDnMoOFCxfKtWvX+D44EGtzwo4dO5rALQAAjsTL3V0iou8EBGLTbgNf7Au2y5gApECAYMqUKeLp6Sk//fSTTJs2TfLkyWOWL1++nKtYgIupVKmSKSm6ffu2zJs3z97DwX/Cw8PN72BFeQEAwFEFX795zzINGRyJZzkAJ+1BkD9/flm6dOk9yydNmpRcYwLgQHWEmkWgUx7OmjVL+vbta+8h4b+ArGZ0aIC2Tp06HBMAgEMqnMFf9l8JNUGB2BkERQLT23FUAB7kkdqGhoWFmb4DsW8AXMvTTz8t7u7usmHDBjl06JC9h4NY5QVPPvmkeHjQ4AkA4JiGlC9mggPWSQz1Xp8PKV/UziMDkGwBgps3b8rAgQPNPOnp06c3DbJi3wC4lly5ctlmMKBZof1pIHbJkiXmMeUFAABH1jIol8xsUElKZgoQHw93c/9lg0rSIiiXvYcGILkCBJpq/Mcff8jUqVNNl/MZM2bIW2+9Jblz55ZvvvkmsW8HwAn07NnT3Ov/8ZiYGHsPJ01btGiR6QlRvHhxqVChgr2HAwDAQ4MEf7StJ8e7tzD3BAcAFwsQ6JUrDQ5o52xtVqj1ryNHjpRx48bJ7NmzU2aUAOyqbdu2kiFDBjl58qSsXr2a74YDlBdo9oD2iAAAAADsFiC4fPmyFCxY0DwODAw0z63TH/7111/JNjAAjsPX19fUuyvKDOzn3LlzsmrVKvO4a9eudhwJAAAAXFGiAwSFChWSY8eOmcc6/Zl16jPNLMiYMWPyjxCAQ9DZDNT8+fMlNDTU3sNJk3788UeJjo6WKlWqSNGiNHgCAACAnQMEzzzzjOzatcs8Hj58uK0XwSuvvCKvvvpqMg8PgKOoVq2aFCtWTG7duiU//fSTvYcjab28AAAAALB7gEADAS+99JJ53KBBAzlw4ID88MMPsn37dnn55ZeTPJDIyEgZNmyYlClTRvz9/U3Twx49esiZM2firBceHi4vvviiZM2a1azXpk0bOXXq1EPfXwMZWhqhqdKVKlWStWvXxnndYrHImDFjzH79/Pykfv36snfv3mTZN+AKtN7d2qyQMoPUd/ToUdm4caOZcrJLly52GAEAAABcXaIDBHfLnz+/dOjQQcqVK/dI76NXJTXIMGrUKHO/YMECOXjwoDkJj23QoEGycOFCmTNnjqxbt05u3LghrVq1Mmm39zN37lyz3YgRI2THjh2msWLz5s3lxIkTtnUmTJggEydOlClTpsjWrVslZ86c0rhx4zip1EnZN+BKunfvbgIFa9askeDgYHsPJ03R3zvq8ccfN1NPAgAAAHYLEOjUhtpzQOfgvtu1a9fkscceu+eqfGJoh/SVK1dK586dzfRd1atXl08++US2bdtmO5HX/cycOVM++ugjadSokZni67vvvpM9e/bYGnfFR0/8e/fuLX369JGSJUvK5MmTJV++fDJt2jRb9oAu0wCCBjtKly5trpBq0MKa0pvUfQOuRP/fNGzY0DxmWtPUo7+jrLPEUF4AAAAAuwcI9AS6b9++ZuaC+E7u+/XrZ07Ek5OelOvVSmvzQw0WaClCkyZNbOtoSYCe0G/YsCHe94iIiDDbxd5G6XPrNnol9OzZs3HW0b4K9erVs62TlH1byxI0qBL7BrhCs0INosXExNh7OGmCBiL37dtnfi9pEBMAAACwa4BAGxM2a9bsvq/ribOeRCeX27dvy+uvv26ullmDEnoS7+3tLZkyZYqzbo4cOcxr8bl48aIpAdB17reN9f5h6yR232r8+PEmgGK96RVYwJm1b99eAgICTGBNS22Q8qyZTC1btjS/RwAAAAC7Bgh0/m0vL6/7vu7p6SkXLlxI8I41XTZ9+vS2W+zyBL1Sr3Ou69VJbS6YkPRbzTR4kLtfj2+bhKyT2H3rTA+aCWG9nTx58oHvBzi6dOnSmVIgNWvWLHsPx+Xp70FtBKsoLwAAAIBDBAjy5Mlj0lzvZ/fu3YlqnKXNB3fu3Gm7Va5c2RYc0JMPvTqpPQlilzRo40AtGbhy5Uqc9zp//vw9V/+tdMYBDw+Pe67yx95G31c9bJ3E7ltpSrB+DbFvgLOzzmbw448/ys2bN+09HJemJUzah0V/d7Ro0cLewwEAAIALS3CAQD+Yvvnmmyb1/25hYWEyevRo09E/oTRFuUiRIrabTi1oDQ4cOnTINP7LkiVLnG10ekLNYtDAgVVISIj8888/UrNmzXj3o2UBul3sbZQ+t26j0x9qACD2OhoM0E7t1nWSsm/AVdWuXVsKFSpkZvLQGUeQ8uUF2ntAf08CAAAAKcUzoSuOHDnSnAgUK1ZMBg4caGYa0NT6/fv3y6effmrq/HUWgKSKioqSjh07mikOly5dat7PekU/c+bM5kRfa291NoIhQ4aY4IEuHzp0qJQpU8bMLHA/gwcPNtOzaZZCjRo1ZPr06eaKXP/+/c3r+nXoFIbjxo2TokWLmps+1lRqa0pvUvcNuCL9P6NZBBoY1GaF+v8LyU+DpvPmzTOPKS8AAACAwwQINI1eU12ff/55U1evtffWE4WmTZuaXgEPSrV/mFOnTsnixYvN4/Lly8d5bfXq1VK/fn3zeNKkSabfgWYaaOaCTrmmddBaRmCl6xYoUMBWH92lSxe5dOmSjB071lz115kHli1bJkFBQbZtXnvtNfN+AwYMMGUE1apVkxUrVphMB6uE7BtIK3r06GECBDoFqgbc8ufPb+8huRz9HaS/u/R3a4MGDew9HAAAALg4N4v1TD8R9AT68OHDJkigV9vv7uxvbxocGDNmjG06Nkei0xxqNoI2LKQfAZydnrT++eef8s477zxSBlF8zj3TWpxZjq+WPPJ7PPXUU6bE4KWXXpKPP/44WcYFAEB8+LsLIFE9CGLTgECVKlWkatWqDhccOHDggLnqr1c3AaROs0ItM0hCrBEPoM0fFy1aZB5TXgAAAACHDRA4shIlSpjZFtzdXe5LAxyO9g3x9/c3jUU3btxo7+G4FC25unXrlmkGqcFYAAAAIKVxFg0gydKnTy9PPPGELYsAyT97gWYPaK8XAAAAIKURIADwSKy9PubMmWOad+LRaWPCX3/91TymvAAAAACphQABgEdSr149MyOINuD8+eefOZrJ4KeffjJTv+qMLiVLluSYAgAAIFUQIADwaL9E3N1tTUGtU4si+coLAAAAgNRCgADAI7MGCFauXCmnT5/miD6CkydPyl9//WUeP/nkkxxLAAAApBoCBAAeWZEiRaR27doSExMj3333HUf0EWgvB1W3bl3Jly8fxxIAAACphgABgGTRs2dP22wGFouFo/qI5QVPPfUUxxAAAACpigABgGTRqVMn8fPzk/3798vWrVs5qkmwb98+2blzp3h5edmmjwQAAABSCwECAMkiQ4YM0r59e1sWARLvhx9+MPfNmjWTLFmycAgBAACQqggQAEj2MgM90Q0PD+fIJoKWZTB7AQAAAOyJAAGAZNOwYUPJkyePXLlyRZYsWcKRTYQtW7bI0aNHxd/fX1q3bs2xAwAAQKojQAAg2Xh4eEj37t3NY8oMEseaPdCuXTsTJAAAAABSm5uFduOp6vr166ZW+9q1axIYGJi6OwdSwYEDB6RkyZImWHD69GnJkSNHkt7n3DPOfRU9x1cJz6CIioqSvHnzyrlz5+SXX36RFi1apOjYAAAAgPiQQQAgWZUoUUKqVasm0dHRMnv2bI5uAqxevdoEB7QxYePGjTlmAAAAsAsCBACSXa9evcz9rFmzTPM9JKy8oHPnzmaKQwAAAMAeCBAASHZdunQRHx8f2bNnj+zcuZMj/ABhYWEyf/5887hbt24cKwAAANgNAQIAyS5TpkzStm1bWxYB7k97DoSGhkr+/PmlZs2aHCoAAADYDQECACmiZ8+etvT5iIgIjvJDygu6du0q7u78SgYAAID98GkUQIpo0qSJ5MyZUy5evCjLli3jKMfj6tWrJoNAUV4AAAAAeyNAACBFeHp6ytNPP20ef/311xzleCxYsMBkVzz22GNSpkwZjhEAAADsigABgBQvM1i6dKlcuHCBI32f8gLNHnBzc+P4AAAAwK4IEABIMaVLl5ZKlSpJVFSU/PDDDxzpWEJCQuSPP/6w9R8AAAAA7I0AAYBUySKgzCCuuXPnisVikRo1akjBggX5KQQAAIDdESAAkKL06riXl5ds375d9uzZw9GOp7wAAAAAcAQECACkqKxZs0qrVq3MY7II7jh06JBs3bpVPDw8pFOnTvwEAgAAwCEQIACQ4nr16mXuv/vuO9OPIK2z9mNo1KiR5MiRw97DAQAAAAwCBABSXPPmzSVbtmxy7tw5+e2339L0Ede+A9bygqeeesrewwEAAABsCBAASHHag8B6Mjxr1qw0fcR37Ngh//77r/j6+kq7du3sPRwAAADAhgABgFSdzWDx4sVy+fLlNHvUrdkDbdq0kYCAAHsPBwAAALAhQAAgVZQvX17KlSsnERERMmfOnDR51KOjo239B5i9AAAAAI7GoQIEY8aMkRIlSoi/v79kypTJNPDavHlznHXCw8PlxRdfNJ3RdT29Cnfq1KmHvvfUqVPNXOOa1lupUiVZu3btPXXBuv/cuXOLn5+f1K9fX/bu3Zss+wYQN4sgrc5moL93zpw5IxkzZpRmzZrZezgAAACA4wYIihUrJlOmTDFzpa9bt04KFCggTZo0kQsXLtjWGTRokCxcuNBcgdR1bty4YaZQ0ytz9zN37lyz3YgRI0z9b506dUzTtBMnTtjWmTBhgkycONHsX6cfy5kzpzRu3FhCQ0Mfad8A/p9eNdep/bZs2SL79+9Ps+UFHTt2FB8fH3sPBwAAAIjDzaKXzh3U9evXJUOGDLJq1Spp2LChXLt2zXRC//bbb6VLly5mHb0aly9fPlm2bJk0bdo03vepVq2aVKxYUaZNm2ZbVrJkSdMgbPz48SZ7QDMHNAAwbNgwW7aATj/2/vvvS79+/ZK87/t9Tfp+gYGByXCUAOeimTdLliwx/9fee++9+6537pnW4sxyfLUkznP9nZIrVy65cuWK/PHHH9KgQQO7jQ0AAABw+AyC2LROefr06eZkWuuW1bZt2yQyMtJkFVjpiX3p0qVlw4YN930f3S72NkqfW7cJDg6Ws2fPxllHr+7Vq1fPtk5S9m09KdCgQOwbkJZZyww02JaWsm90ekcNDujvjbp169p7OAAAAIDjBwiWLl0q6dOnN70CJk2aJCtXrjQ1/0pP4r29vU1/gtj0Sr++Fp+LFy+akxBd537bWO8ftk5i9600Q0GDHNabZhwAaZmW5WTOnNlk4Gh2UForL3jyySdNmQUAAADgaOwWIJg9e7YJBFhv1qaBmna7c+dOc1Vem3h17txZzp8//8D30hIBNze3B65z9+vxbZOQdRK77+HDh5tyAuvt5MmTD3w/wNVpdk7Xrl3TVLNC7WWi0zsqZi8AAACAo3K3Zx2yBgKst8qVK5vlOjtAkSJFpHr16jJz5kzx9PQ090obB2rJgKbpxqYBhLuv/ltp9oFerbv7Kn/sbfR91cPWSey+rSdD2msg9g1I63r16mXutemnBs5c3aJFiyQsLMw0YtV+KAAAAIAjsluAICAgwAQCrDedWvB+V+i1jl/p9IReXl6m7MAqJCRE/vnnH6lZs2a822tZgG4Xexulz63b6PSHGgCIvY4GA9asWWNbJyn7BhA//f9UqlQpuX37tsybNy/NlBdo9sDDspIAAAAASes9CG7evClvvPGGbNq0SY4fPy7bt2+XPn36yKlTp6RTp05mHa3h7927twwZMkR+//13M2Xh008/LWXKlJFGjRrd970HDx4sM2bMkC+//NJMrfbKK6+YKQ779+9vXtcP7DqDwbhx48wVTT3p1yuc6dKls6UDJ3XfAO6l/+esWQSzZs1y6UOkWUbWwKK1tAIAAABwRJ7iILQM4MCBA6YmWRsLZsmSRapUqWJ6Ezz22GO29bRxoZYdaG8CTdnV6Q/1BCN206/69etLgQIFbCceOi3hpUuXZOzYseaqv848oFMTBgUF2bZ57bXXzPsNGDDAlBHo1IgrVqwwmQ6J2TeAhNEA2+uvv276jRw6dEiKFi3qkofuxx9/NI1StYxKSwwAAAAAR+Vm0Rx+F6PBgTFjxtiuUDoSneZQsxG07pp+BEjrWrRoIcuXL5cRI0bIO++8E+e1c8+0FmeW46sl5r5WrVomCDJx4kSTvQQAAAA4KocpMUgumoWgV/179Ohh76EAeIiePXua+2+++UZiYmJc7ngFBweb4ICWVGgmEwAAAODIXC5AUKJECdmzZ4+4u7vclwa4nLZt25qMGp3+c/Xq1eJq5syZY5u+NXfu3PYeDgAAAPBAnEUDsBtfX1958sknzWPtP+LKsxcAAAAAjo4AAQCHKDOYP3++hIaGusx3QzOZdEYUnWq1Q4cO9h4OAAAA8FAECADYVfXq1U13/1u3bslPP/3kctkD2ogxU6ZM9h4OAAAA8FAECADYlTbws2YRuEqZQYzFIj/88IN5/NRTT9l7OAAAAECCECAAYHfdu3c3gYI1a9aYzv/O7u/zV+T48eNmRpWWLVvaezgAAABAghAgAGB3+fLlk4YNG9qmPHR2C4JPm3vtPeDn52fv4QAAAAAJQoAAgEPo1auXrcwgJiZGnFVkTIwsDg4xj5m9AAAAAM6EAAEAh9C+fXuTkq8lBuvWrRNn9deZi3I5PEKyZ88ujz/+uL2HAwAAACQYAQIADiFdunTSuXNn83jWrFnirBYevVNe0KVLF/H09LT3cAAAAIAEI0AAwGFYZzP48ccf5WZklDibW1HRsuzEWfOY8gIAAAA4GwIEABxG7dq1pVChQnLjxg3bibYzWXHynAkS5E+fTqpVq2bv4QAAAACJQoAAgMPQqQ6tWQTzDp8SZy0v6FAot/laAAAAAGdCgACAQ+nRo4e5XxdyUU7dCBNncSU8Qv44fd48bl8oj72HAwAAACQaAQIADqVAgQJSv359sYjIT0ecJ4tg6bEQiYyxyGOZAqV4xgB7DwcAAABINAIEAByOrczgyCmxWDRU4PgW/Fde0L5QbnsPBQAAAEgSAgQAHE7Hjh0lnaeHHL1+U/6+cEUc3embYbLp3GXzuF1BygsAAADgnAgQAHA46dOnl5ZBuZymWeHPwWdMSUT1HJklb3o/ew8HAAAASBICBAAcUpciec39ouAzEhYVLc4we0F7sgcAAADgxAgQAHBINXNmkbz+fhIaGSW/nTgrjurg1VDZc/m6eLq5SasCd7IeAAAAAGdEgACAQ3J3c5NO/2URzHXgMoOFwWfMff082SSLr7e9hwMAAAAkGQECAA6rc+E7AYI1IRck5GaYOBqdYcFaXtChEM0JAQAA4NwIEABwWAUD/aVa9swSYxH56b8TcUey4+JVORZ6S/w8PaRpvhz2Hg4AAADwSAgQAHBonf8rM9DZDPSKvSNZePROeUGzfDnE38vT3sMBAAAAHgkBAgAOrXWBXOLr4S6Hrt0wV+wdRXSMxcywoCgvAAAAgCsgQADAoQV6e0mLoJzm8bwjjtOscP3Zi3Lhdrhk9vEyDQoBAAAAZ0eAAIDD61w4n7lfdPSMhEdHiyNY8F95QasCucXLnV+lAAAAcH58qgXg8Orkyiq50vnK1YhIWXHynL2HI7ejouWX4yHmcYdCue09HAAAACBZECAA4PA83N2kY+E8tmaF9vb76fMSGhklefx9pWr2zPYeDgAAAJAsCBAAcKoygz9OX5ALYeF2HcuC/6ZcbFcwj7i7udl1LAAAAIDLBwj69esnbm5uMnny5DjLw8PD5cUXX5SsWbOKv7+/tGnTRk6devgVxalTp0rBggXF19dXKlWqJGvXro3zuk6fNmbMGMmdO7f4+flJ/fr1Ze/evcmybwCPrmjG9FIxa0aJtlhk/n8n6PZwPSJSVp08bx4zewEAAABciUMGCBYtWiSbN282J+t3GzRokCxcuFDmzJkj69atkxs3bkirVq0k+gGNy+bOnWu2GzFihOzYsUPq1KkjzZs3lxMnTtjWmTBhgkycOFGmTJkiW7dulZw5c0rjxo0lNDT0kfYNIPl0KXIni2Du4ZMmqGcPy46flfCYGCmWMb2UyhRglzEAAAAAaSJAcPr0aRk4cKDMnj1bvLy84rx27do1mTlzpnz00UfSqFEjqVChgnz33XeyZ88eWbVq1X3fU0/8e/fuLX369JGSJUuarIR8+fLJtGnTzOt6oqHLNIDQoUMHKV26tHz99ddy69Yt+f777x9p3wCST9uCucTH3V32XwmVfy5ft8uhXRh8J3uhQ8E8JssJAAAAcBUOFSCIiYmR7t27y6uvviqPPfbYPa9v27ZNIiMjpUmTJrZlmmWgJ/QbNmyI9z0jIiLMdrG3Ufrcuk1wcLCcPXs2zjo+Pj5Sr1492zpJ2be1LOH69etxbgCSJqOPtzTNn8OWRZDazt+6LWtDLprH7Zm9AAAAAC7GoQIE77//vnh6espLL70U7+t6Eu/t7S2ZMmWKszxHjhzmtfhcvHjRlADoOvfbxnr/sHUSu281fvx4yZAhg+2mmQsAkq5zkbzmfsHRMxIRHZOqh/LnY2ckxiJSKVtGCQrwT9V9AwAAAC4bINASgvTp09tua9askY8//lhmzZqV6LRdLRF42DZ3vx7fNglZJ7H7Hj58uClPsN5Onkz9q56AK6mfO5tk9/ORy+ER8vupO80CU4sGJVT7QnemXAQAAABcid0CBDoDwM6dO203TdM/f/685M+f32QR6O348eMyZMgQKVCggNlGGwdqycCVK1fivJdud/fVfyudccDDw+Oeq/yxt9H3VQ9bJ7H7tpYqBAYGxrkBSDpPd3d54r8T9HlHUi/gFnz9puy4eFXc3UTaFri3gSoAAADg7OwWIAgICJAiRYrYbs8995zs3r07TtBAa/y1H8Fvv/1mttHpCbVx4cqVK23vExISIv/884/UrFkz3v1oWYBuF3sbpc+t2+j0hxoAiL2OBgM0q8G6TlL2DSBlywxWnjwvF2+Hp2pzwrq5skk2P59U2ScAAACQmjzFQWTJksXcYtMTcj1xL168uHmuNfw6G4FmFei6mTNnlqFDh0qZMmXMzAL3M3jwYNP8sHLlylKjRg2ZPn26meKwf//+5nUtEdApDMeNGydFixY1N32cLl066dat2yPtG0DyK5kpUMpmySC7L12TRUfPSJ9SBVP0MGsp0YIjdwIENCcEAACAq3KYAEFCTZo0yZQfdO7cWcLCwqRhw4amb4GWEVjVr1/flCXoctWlSxe5dOmSjB071lz115kHli1bJkFBQbZtXnvtNfN+AwYMMGUE1apVkxUrVphMh8TsG0DqZRFogGDekVMpHiDQKRUPX79pplhskf9OSRIAAADgatwsemnMxWhwYMyYMdKrVy9xNDrNoWYjaMNC+hEA93fumdYPPDyXbkdI+XkrJTLGIqvb1jVZBSnlra37ZNreo9IqKJfMaFApQdvk+GpJio0HAAAAcPlpDpPDgQMHzFX/Hj162HsoAFJQFl9vaZz3ToPQuYdPpdh+YiwWWRR8Z/aCDoVoTggAAADX5XIBghIlSsiePXvE3d3lvjQAd+nyX7PC+UdOS1RMTIocn03nLkvIrdsS6OUpj+fJzvcAAAAALouzaABO6/G82U0mwYXb4bL69IUU2cfCo3eaE7YskEt8Pek3AgAAANdFgACA0/Jyd5cnCuVJsTKDiOgYWXIsxDy27gcAAABwVQQIADi1zoXvlBmsOHlOroRHJOt7/3nmglyNiJQcfj5SI0fcaVgBAAAAV0OAAIBTK50lg5TKFCARMTG2ZoLJZcF/5QXtCuYWD3e3ZH1vAAAAwNEQIADg9LoUyWfu5yVjmcHNyCj57cRZ87g95QUAAABIAwgQAHB6HQrlEQ83N9lx8aocvBqaLO/564mzEhYdI4UC/aVclgzJ8p4AAACAIyNAAMDpZfPzkYZ5sydrFsGC/8oV2hfMLW5ulBcAAADA9REgAOBSzQp/OnpKomMsj/ReF2+Hy5//TZtIeQEAAADSCgIEAFxC43zZJZOPl5y9FS5/hdw5uU+qpcdCJNpikbJZMkiRDOmTbYwAAACAIyNAAMAl+Hh4mNkGkqPMYOHRM7beBgAAAEBaQYAAgMvNZrD8xFm5HhGZpPc4eeOWbD5/WbTrQNsCuZJ5hAAAAIDjIkAAwGXobAPFMqaX29ExsvjYnSyAxFr0X/ZAzZxZJJe/XzKPEAAAAHBcBAgAuAydbcCaRTA3iWUGC4JPm3vKCwAAAJDWECAA4FI6Fsoj7m4iW89fkaPXbyRq2/1Xrsv+K6Hi5e4mLYNyptgYAQAAAEdEgACAS8mRzlfq5c6WpGaF1uaEDfNkl4w+3ikyPgAAAMBRESAA4HKsZQY/HjklMRZLgraxWCyy4Oid8oL2zF4AAACANIgAAQCX0yxfDgn08pTTN2/L+pBLCdrm7wtX5NTNMPH39JDG+XKk+BgBAAAAR0OAAIDL8fX0kHYFc5vHc4+cTNA21uyB5kE5JZ2nR4qODwAAAHBEBAgAuKTO/5UZ/HL8rNyIjHrgupExOi1iiHncoWCeVBkfAAAA4GgIEABwSZWyZZTCgf4SFhUtS/47+b+ftWcuyqXbEZLF11vq5s6aamMEAAAAHAkBAgAuyc3NTToXyWsezzv84DKDBcF3ygvaFsgtnu78WgQAAEDaxCdhAC6rY+G84iYiG89dluOht+Jd51ZUtCw/ftY87sDsBQAAAEjDCBAAcFl5/P2kTq6stikP47Py5Dm5GRUt+dL7mbIEAAAAIK0iQADApXWxlRmckhiL5Z7XF/43e4FmD2hZAgAAAJBWESAA4NKaB+WS9F6ecuLGLdl87nKc166GR8jvp8+bx+2ZvQAAAABpHAECAC4tnaeHtC6QyzyeezhumYFOgRgZY5FSmQKkRKYAO40QAAAAcAwECACkmTKDJcfOyM3IKNvyBf+VF7SnOSEAAABAgACA66uWPbMEBaQzzQiXnbgzY0HIzTDZcPaSedyuYG47jxAAAACwPzIIALg8bT7YufD/NytUPx8LEct/wYN86dPZeYQAAACA/REgAJAmdPovQLAu5KKcuhEWq7yA7AEAAADA4QIEvXr1Mlf6Yt+qV68eZ53w8HB58cUXJWvWrOLv7y9t2rSRU6fin988tqlTp0rBggXF19dXKlWqJGvXro3zusVikTFjxkju3LnFz89P6tevL3v37k2WfQOwv/wB6aRmziwma+D9Hf/K7kvXxNPNTVoXIEAAAAAAOFyAQDVr1kxCQkJst2XLlsV5fdCgQbJw4UKZM2eOrFu3Tm7cuCGtWrWS6Ojo+77n3LlzzXYjRoyQHTt2SJ06daR58+Zy4sQJ2zoTJkyQiRMnypQpU2Tr1q2SM2dOady4sYSGhj7SvgE4DmuZwY9H7gT2fD3cZdO5O30IAAAAgLTOzaKXzh0og+Dq1auyaNGieF+/du2aZMuWTb799lvp0qWLWXbmzBnJly+fCSQ0bdo03u2qVasmFStWlGnTptmWlSxZUtq1ayfjx4832QOaOaABgGHDhtmyBXLkyCHvv/++9OvXL8n7vtv169clQ4YM5v0CAwMTfYyAtOLcM62T/T0XHDklA9butD130+whEZnZoJK0DLozFWJyyfHVkmR9PwAAACDNZRD8+eefkj17dilWrJj07dtXzp8/b3tt27ZtEhkZKU2aNLEt0xP70qVLy4YNG+J9v4iICLNd7G2UPrduExwcLGfPno2zjo+Pj9SrV8+2TlL2bQ00aFAg9g2AfUz550ic55b/ggQf7TzItwQAAABpnqcjHQFN++/UqZMEBQWZk/ZRo0bJ448/bk7O9YRdT+K9vb0lU6ZMcbbTK/36WnwuXrxoSgB0nfttY72Pb53jx4/b1knsvpVmKLz11luJOg4AUuYK/FE/v3uWaZDgaFgkV/wBAACQ5tktg2D27NmSPn16202bBmrqfsuWLc1V+datW8vy5cvl4MGD8ssvvzzwvbREQBsaPsjdr8e3TULWSey+hw8fbsoJrLeTJ08+8P0ApBzNTIrv/33x4sU57AAAAEjz7BYg0BkAdu7cabtVrlz5nnVy5cplsgkOHTpknmvjQC0ZuHLlSpz1tAzh7qv/VjrjgIeHxz1X+WNvo++rHrZOYvetNPNBew3EvgGwj9GjR8cJ6um9PtflAAAAQFpntwBBQECAFClSxHbTqQXvdunSJXPFXQMFSqcn9PLykpUrV9rW0ZkO/vnnH6lZs2a8+9GyAN0u9jZKn1u30ekPNQAQex0NBqxZs8a2TlL2DcCxdOjQQebPny9ly5Y1U57q/YIFC6R9+/b2HhoAAABgdw7Tg0CnDBwzZow88cQTJiBw7NgxeeONN0wGgPXDu3b/7927twwZMkSyZMkimTNnlqFDh0qZMmWkUaNG933vwYMHS/fu3U2WQo0aNWT69OlmisP+/fvbriLqDAbjxo2TokWLmps+TpcunXTr1u2R9g3A8YIEegMAAADgoAECLQPYs2ePfPPNN2aqQw0SNGjQQObOnWuyDawmTZoknp6e0rlzZwkLC5OGDRvKrFmzzPZW9evXlwIFCpjlSnsbaDbC2LFjzVV/7XGgUxNq+YLVa6+9Zt5vwIABpoxAp0ZcsWJFovcNAAAAAIAzcrNoAa6L0eCAZiP06tVLHI1Oc6jZCNqwkH4EAAAAAABJ6z0IUsqBAwfMVf8ePXrYeygAAAAAADgNl8wgcGRkEAAAAAAAHJHLZRAAAAAAAIDEI0AAAAAAAAAIEAAAAAAAAAIEAAAAAACAAAEAAAAAACBAAAAAAAAADM87d0gt1lkldbpDAAAAAABSS0BAgLi5ud33dQIEqSw0NNTc58uXL7V3DQAAAABIw65duyaBgYH3fd3NYr2kjVQRExMjZ86ceWjkBgAAAACA5PSw81ACBAAAAAAAQNw5BgAAAAAAgAABAAAAAAAgQAAAAAAAAAgQAAAAAAAAAgQAAAAAAIAAAQAAAAAAMGhSCAAAAAAACBAAAAAAAAACBAAAAAAAgAABAAAAAAAgQAAAAAAAAAyaFAIAAAAAAAIEAAAAAACAAAEAAAAAACBAkPosFotcv37d3AMAAAAA4CjoQZDKQkNDJUOGDOYeAAAAAABHQYAgCaZOnSoFCxYUX19fqVSpkqxduzb5vzMAAAAAAKQiAgSJNHfuXBk0aJCMGDFCduzYIXXq1JHmzZvLiRMnUuY7BAAAAABAKnCzUAyfKNWqVZOKFSvKtGnTbMtKliwp7dq1k/Hjxz90e+0/oCUG165dk8DAwKR8zwAAAAAASHaeyf+WrisiIkK2bdsmr7/+epzlTZo0kQ0bNsS7TXh4uLnFDhDgjtDL1yUi1rGBi3F3F/HysfcoAAAAkMZ5e3lIQICfvYfhHCyJdPz4cUtMTMw9y3WZvubKTp8+rVMPWNavXx9n+bvvvmspVqxYvNuMHj3abHP3TdcvWbKkZezYsZZLly6Zx9abGjRokO357NmzLZs3b7Y9b9WqlVlH763L9HVdz/pct1ex31f3o/uzPp8yZYrl0KFDtuc1a9Y02/To0cO2bPny5eZmfa6vKV3XukzfQ9/L+jwhX9NXX35lmfv515bCQQXNrX7NOpb9a7eZe+syff2DN9+xPe/RqZtZx/pcbxt/+cPyYu/+tucjXxlm+fWHRbbnFUqXM9u0bdbStmz6h5+Ym/W5vqbr6LrWZfoe+l7W57oP3Vfsfes2Oibrcx0rX1Os71P+ApbC+fKb2+a5Cy0vPd3L9vzN51+0rJjxje15hZKPWf5d9rulXcPGtmVfjB1vbtbn+pquo+tal+l76HtZn+s+dF/W53rTbXq2e8L2/MNX37D8OOlT2/MGVaubdfTeukxf1/Wsz3V7XSf2+/I18X3iZ4//T/yO4Hc5f5/4m8vnCOf4bFS/ei3LrZthTn3+NDsZzgkTItElBh4eHhISEiLZs2ePs/zSpUtmWXR0tLiqM2fOSJ48eUy2QI0aNWzL3333Xfn222/lwIEDCcogyJcvHyUGZBC4tohwiTl+SMTDU8TL296jAQAAQFoVGSmeMVGSoXJVcfdLZ+/RuF6JgcYT3Nzc7ll+48YN09XflWXNmtUESM6ePRtn+fnz5yVHjhzxbuPj42NuuFdAZnowuKqYsFsSftZd3H39xI2ffwAAANiJJTxcYm7f5Pgnd4Bg8ODB5l6DA6NGjZJ06f4/+qJZA5s3b5by5cuLK/P29jbTGq5cuVLat29vW67P27Zta9exAQAAAACQKgECndLPmkGwZ88ec7JspY/LlSsnQ4cOFVengZLu3btL5cqVTZnB9OnTzRSH/fv3t/fQAAAAAABI+QDB6tWrzf0zzzwjH3/8cZqdoq9Lly6m38LYsWNNL4bSpUvLsmXLJCgoyN5DAwAAAAAgyRLdpNDq8OHDcuTIEalbt674+fndtzcB4tImhRkyZKBJIVy/B8HureLu608PAgAAANi9B4FP2So0KUwAd0mky5cvS8OGDaVYsWLSokULcxVd9enTR4YMGZLYtwMAAAAAAM4YIBg0aJB4eXmZuvvYjQo19f7XX39N7vEBAAAAAABHnOZwxYoV8ttvv0nevHnjLC9atKgcP348OccGAAAAAAAcNYPg5s2bcTIHrC5evCg+zHcOAAAAAEDaCBBoU8JvvvnG9lwbE8bExMgHH3wgDRo0SO7xAQAAAAAARywx0EBA/fr15e+//5aIiAh57bXXZO/evaZ54fr161NmlAAAAAAAwLEyCEqVKiW7d++WqlWrSuPGjU3JQYcOHWTHjh1SuHDhlBklAAAAAABwrAwClTNnTnnrrbeSfzQAAAAAAMB5AgRXr16VLVu2yPnz503/gdh69OiRXGMDAAAAAACOGiBYsmSJPPXUU6a0ICAgwDQptNLHBAgAAAAAAEgDPQiGDBkizz77rISGhppMgitXrthu2qgQAAAAAACkgQDB6dOn5aWXXpJ06dKlzIgAAAAAAIDjBwiaNm1qpjgEAAAAAABpuAdBy5Yt5dVXX5V9+/ZJmTJlxMvLK87rbdq0Sc7xAQAAAACAVOBmsVgsidnA3f3+SQfapDA6Ojo5xuWyrl+/LhkyZJBr165JYGCgvYcDpIiYsFsSvnuruPv6i5uPD0cZAAAAdmEJD5eY2zfFp2wVcfejTD7ZMwjuntYQAAAAAACkwR4EAAAAAADA9RAgAAAAAAAABAgAAAAAAAABAgAAAAAAQIAAAAAAAAAkOUBw5MgRGTlypHTt2lXOnz9vlv3666+yd+9ejioAAAAAAGkhQLBmzRopU6aMbN68WRYsWCA3btwwy3fv3i2jR49OiTECAAAAAABHCxC8/vrr8s4778jKlSvF29vbtrxBgwaycePG5B4fAAAAAABwxADBnj17pH379vcsz5Ytm1y6dCm5xgUAAAAAABw5QJAxY0YJCQm5Z/mOHTskT548yTUuAAAAAADgyAGCbt26ybBhw+Ts2bPi5uYmMTExsn79ehk6dKj06NEjZUYJAAAAAAAcK0Dw7rvvSv78+U22gDYoLFWqlNStW1dq1qxpZjYAAAAAAABpIEDg5eUls2fPloMHD8q8efPku+++kwMHDsi3334rHh4eSR5IZGSkyUzQGRL8/f0ld+7cJiPhzJkzcdYLDw+XF198UbJmzWrWa9OmjZw6deqh7z916lQpWLCg+Pr6SqVKlWTt2rVxXrdYLDJmzBizXz8/P6lfv/490zYmdd8AAAAAALjkNIeqcOHC0rFjR+ncubMULVr0kQdy69Yt2b59u4waNcrc6xSKGoTQk/DYBg0aJAsXLpQ5c+bIunXrTBZDq1atJDo6+r7vPXfuXLPdiBEjTK+EOnXqSPPmzeXEiRO2dSZMmCATJ06UKVOmyNatWyVnzpzSuHFjCQ0NfaR9AwAAAADgDNwseuk8EXRqQz151l4ETz/9tJQuXTrFBqcn6lWrVpXjx4+bsoZr166Z2RI0W6FLly5mHc0wyJcvnyxbtkyaNm0a7/tUq1ZNKlasKNOmTbMtK1mypLRr107Gjx9vsgc0c0ADAJrFYM0WyJEjh7z//vvSr1+/JO/7btevX5cMGTKY9wsMDEyGowQ4npiwWxK+e6u4+/qLm4+PvYcDAACANMoSHi4xt2+KT9kq4u6Xzt7Dcb0MAj0pfu2110yKftmyZc1Nr76nRKq9nkRrI0SdOUFt27bNlCI0adLEto6e2GuQYsOGDfG+R0REhNku9jZKn1u3CQ4ONk0XY6/j4+Mj9erVs62TlH1bAw0aFIh9AwAAAADA6QMEWn8/cOBAM3PBkSNHzNX0b775RgoUKCCPP/54sg3s9u3b8vrrr5tMBeuVdj2J1wyGTJkyxVlXr/Tra/G5ePGiKQHQde63jfX+Yeskdt9KMxQ0Y8B604wDAAAAAACcPkAQmzb905P49957zzQXtPYnSAhtdJg+fXrbLXbTQL1S/+STT5opFLW54MNoiYBmGjzI3a/Ht01C1knsvocPH24yIay3kydPPvD9AAAAAABwqgCBZhAMGDBAcuXKZa7yP/bYY7J06dIEb6/NB3fu3Gm7Va5c2RYc0MaHmva/cuXKOHX62vtASwauXLkS573Onz9/z9X/2BkPOrvC3Vf5Y2+j76setk5i920tVdCvIfYNAAAAAACnDxC88cYbJnNAywm0eeDkyZPNibVOd6gzAyRUQECAFClSxHbTqQWtwYFDhw7JqlWrJEuWLHG20ekJdZpFDRxYhYSEyD///CM1a9aMdz9aFqDbxd5G6XPrNvr1aAAg9joaDNCMCOs6Sdk3AAAAAADOwjOxG/z5558ydOhQ03tAr84nl6ioKDNtok5xqJkI2jfAekU/c+bM5kRfa/h79+4tQ4YMMcEDXa5j0fKGRo0a3fe9Bw8eLN27dzdZCjVq1JDp06ebKQ779+9vXtcSAZ3BYNy4cWbKRr3p43Tp0pnsCJXUfQMAAAAA4JIBggd17H8UOgvC4sWLzePy5cvHeW316tVSv35983jSpEni6elpMg3CwsKkYcOGMmvWLFNGYKXratNEXa40mHHp0iUZO3asueqvMw/o1IRBQUG2bXRmBn0/LZvQMgKdGnHFihUm08EqIfsGAAAAAMAZuVm0y95D6Im7lg9oir31JP5BvQXsTYMDY8aMkV69eomj0WkONRtBGxbSjwCuKibsloTv3iruvv7i5uNj7+EAAAAgjbKEh0vM7ZviU7aKuPuls/dwXCODoF27dibdP3v27Obx/WiqvpYG2NOBAwfMVf8ePXrYdRwAAAAAALhcgECnG4zvsSMqUaKE7Nmzx97DAAAAAADAtWcx+OabbyQ8PPye5dr1X18DAAAAAABpIEDwzDPPmPr5u4WGhprXAAAAAABAGggQaE9D7TUQ3ywE2nwPAAAAAAC48DSHFSpUMIEBven0fjrdn5U2JgwODpZmzZql1DgBAAAAAIAjBAissxfs3LlTmjZtKunTp7e95u3tbaYWfOKJJ1JmlAAAAAAAwDECBKNHjzb3Ggjo0qWL+Pr6puS4AAAAAACAIwYIrHr27JkyIwEAAAAAAM4TINB+A5MmTZJ58+bJiRMnzPSGsV2+fDk5xwcAAAAAABxxFoO33npLJk6cKJ07dzbTHQ4ePFg6dOgg7u7uMmbMmJQZJQAAAAAAcKwMgtmzZ8sXX3whLVu2NMGCrl27SuHChaVs2bKyadMmeemll1JmpAAAAHBplshIkZgYew/DObm7i5uXl71HASCtBQjOnj0rZcqUMY91JgPNIlCtWrWSUaNGJf8IAQAAkCaCA9GXL4gbjbCTdvxu3xaPzNkIEgBI3QBB3rx5JSQkRPLnzy9FihSRFStWSMWKFWXr1q3i4+PzaKMBAABA2hQTY4ID3iXKips3nykTwxIRLhEHdpN9ASD1AwTt27eX33//XapVqyYvv/yyKTGYOXOmaVj4yiuvPPqIAAAAkGZpcMDdL529h+FUKMoAYLcAwXvvvWd73LFjR5NRsGHDBpNN0KZNm2QbGAAAAAAAcOAAwd2qV69ubgAAAAAAwMUDBIsXL07wG5JFAAAA0iq68D/CsYuKSMbvBAAgxQIE7dq1S9Cbubm5SXR0dJIGAgAA4Mzowv/o3Hz8xM3DIxneCQCQYgGCGOajBQAAeNgHJrrwPyINDjCDAQA4cQ8CAAAA/D+68AMA0kyAYOzYsQ98/c0333yU8QAAAAAAAGcIECxcuDDO88jISAkODhZPT08pXLgwAQIAAAAAANJCgGDHjh33LLt+/br06tVL2rdvn1zjAgAAAAAAqcg9Od4kMDDQlB6MGjUqOd4OAAAAAAA4Y4BAXb16Va5du5ZcbwcAAAAAABy5xOB///tfnOcWi0VCQkLk22+/lWbNmiXn2AAAAAAAgKNmEEyaNCnOTQMGf/75p/Ts2VOmT5+ebAPr16+fuLm5yeTJk+MsDw8PlxdffFGyZs0q/v7+0qZNGzl16tRD32/q1KlSsGBB8fX1lUqVKsnatWvvCXSMGTNGcufOLX5+flK/fn3Zu3dvsuwbAAAAAACXCxDojAWxb0eOHJFNmzbJuHHjJCAgIFkGtWjRItm8ebM5Wb/boEGDzEwKc+bMkXXr1smNGzekVatWEh0dfd/3mzt3rtluxIgRpslinTp1pHnz5nLixAnbOhMmTJCJEyfKlClTZOvWrZIzZ05p3LixhIaGPtK+AQAAAABIUz0Iksvp06dl4MCBMnv2bPHy8orzmvY4mDlzpnz00UfSqFEjqVChgnz33XeyZ88eWbVq1X3fU0/8e/fuLX369JGSJUuarIR8+fLJtGnTbNkDukwDCB06dJDSpUvL119/Lbdu3ZLvv//+kfYNAAAAAIBLBghu374tH3zwgbRo0UIqV64sFStWjHN7FDExMdK9e3d59dVX5bHHHrvn9W3btklkZKQ0adLEtkyzDPSEfsOGDfG+Z0REhNku9jZKn1u30UyIs2fPxlnHx8dH6tWrZ1snKfu2liXoNJCxbwAAAAAAOH2TwmeffVZWrlwpHTt2lKpVq5o+Acnl/fffF09PT3nppZfifV1P4r29vSVTpkxxlufIkcO8Fp+LFy+aEgBd537bWO/jW+f48eNJ3rcaP368vPXWWw/4qgEAAAAAcMIAwS+//CLLli2TWrVqPdKOtYRAGxHGft+PP/5Ytm/fnuigg5YIPGybu1+Pb5uErJPYfQ8fPlwGDx5se64ZBFreAAAAAACuwBIZqeng4ogsURH2HoJrBwjy5MmTLM0IdQaAatWq2Z7/+OOPcv78ecmfP79tmV75HzJkiOkPcOzYMdM4UEsGrly5EudKvm5Xs2bNePejMw54eHjcc5Vft7FmDOj7Kl0nV65c910nsfu2liroDQAAAABcMTgQffmCuPn6iqNy8/ETNw8Pew/DNQME2qRv2LBh8tlnn0lQUFCSd6xBhtiBhueee05at24dZ52mTZuangTPPPOMea7TE2rjQi1x6Ny5s1kWEhIi//zzj5mFID5aFqDb6Tbt27e3Ldfnbdu2NY91+kMNAOgybT6oNBiwZs0aU/aQ1H0DAAAAgEuLiTHBAe8SZcXN2zEvjGpwwFHH5vQBAm1MqI0KCxUqJOnSpbtnpoHLly8naSBZsmQxt9j0vfXEvXjx4uZ5hgwZzGwEmlWg62bOnFmGDh0qZcqUMTML3I+m+GugQcdeo0YNmT59upnisH///uZ1LRHQKQx1qsaiRYuamz7Wr69bt26PtG8AAAAAcHV6Au7ul87ew0BqBwi6du1qpiLUE2hNv0/OJoUJMWnSJNPIUK/ih4WFScOGDWXWrFmmjMCqfv36UqBAAbNcdenSRS5duiRjx441V/115gHtoxA7A+K1114z7zdgwABTRqDlDytWrIiT5ZCQfQMAAAAA4IzcLNplLxH0qvrGjRulXLly4qg0ODBmzBjp1auXOBptUqjZCNeuXZPAwEB7DwdIETFhtyR891Zx9/UXN3pwAEgjLOHhEnP7pviUrcJVNKQq/u7Cnvjdl8YzCEqUKGGunjuqAwcOmKv+PXr0sPdQAAAAADgBR+7C7+iYJSCNBwjee+89U4f/7rvvmvr7u3sQ2PuquAYw9uzZY9cxAAAAAHAOztCF39ExS0AaDhA0a9bM3Gv9fWxaqaD9CHRqQgAAAABwCk7Qhd/RMUtAGg4QrF69OmVGAgAAAAB2Qhd+IAkBgnr16nHcAAAAAABI6wGCv/7664Gv161b91HGAwAAAAAAnCFAUL9+/XuWae8BK3oQAMCjo5vyI3B3F7e7GugCQFpAN3mOG5DqAYIrV67EeR4ZGSk7duyQUaNGmZkNAACPhm7Kj3j8bt8Wj8zZCBIASFsN4nz8xBIeJpaoSHsPxynRhR9IYoAgQ4YM9yxr3Lix+Pj4yCuvvCLbtm1L7FsCAGKjm3KSWSLCJeLAbuayBpDmmuv5lConFmYTe7QgCzMYAIkPENxPtmzZ5N9//+WQAkAyoZty4sXw0wcgDf/N+P+iXwBIpQDB7t274zy3WCwSEhIi7733npQrVy6JwwAAAAAAAE4VIChfvrxpSqiBgdiqV68uX375ZXKODYCTo1kSxw0AAAAuHCAIDg6O89zd3d2UF/j6+ibnuAA4MZolJcMx9PEzxxEAAABw2ABBUFBQyowEgMugWVIyHEOaJcFOmGLzEY5dVEQyficAAHDgAMEff/whAwcOlE2bNklgYGCc165duyY1a9aUzz77TOrUqZMS4wTgZGiWBDgfpth8dGT/AADSRIBg8uTJ0rdv33uCA9apD/v16ycTJ04kQAAAgLNiis1HRvYPACBNBAh27dol77///n1fb9KkiXz44YfJNS4AAGAnTLEJAEDa5J7QFc+dOydeXl73fd3T01MuXLiQXOMCAAAAAACOGCDIkyeP7Nmz576v7969W3LlypVc4wIAAAAAAI5YYtCiRQt58803pXnz5vdMaRgWFiajR4/+v/buBabq8g3g+AOKd1a0RLM0tQFmM4lGFjZllbmarZuWaIqpmeSs3Cytlcbsaq1VCzQvLSO7kNVWKzNaTUvXILBMxOJiZkqw8AJeQIH3v+dp50xb/6V2fucIv+9nc4fzg6M/X57z/s7ved/3eWXMmDFenCMAAKeEavKnh3YDAMDfopxz7mSXGKSkpEiHDh1sN4OkpCSJioqSsrIyycnJkZaWFikpKZFevXp5f9ZtWH19vRV11J0f/qngIwDg9LmjTdK07UdxTUdoxv9Qhb/z4KFWhwAAAPjLSScI1M6dOyUrK0vWrVsngZdpkmD06NGSm5sr/fv39/Jc2wUSBADgfZLAtbTQzKeJKvwAAPjXKSUIAvbt2ycVFRWWJEhISJC4uDhvzq4dIkEAAAAAAGg3CQKcPhIEAAAAAIA2XaQQoRHIx2iiAAAAAACAcImNjbUyAf8PCYIwa2hosMe+ffuG+58GAAAAAPjYgX8pls8SgzBrbW2VPXv2/Gvmpr3TGRSaJNm1axe7OYD4g2/Q94H4gx/R94H4O3Mwg+AMEx0dLRdccEGkT+OModkrtnsE8Qe/oe8D8Qc/ou8D8Xfmi470CQAAAAAAgMgjQQAAAAAAAEgQIDI6d+4sCxcutEeA+INf0PeB+IMf0feB+Gs7KFIIAAAAAACYQQAAAAAAAEgQAAAAAAAAEgQAAAAAAIAEAQAAAAAAMGxzCAAAAAAASBDAG845mhYRQewBAAD4A5/7Qo8ZBAi52tpaaWhoCD7njYtwOXDggLS0tBB7iIiKigopKCig9RF2v/zyi8ycOVO++eYbWh9ht2vXLikuLpY9e/bQ+ggr7jm8QYIAIdPc3CzTpk2TK664Qq677jqZOHGi/PnnnxIVFUUrw1PHjh2TWbNmyY033mh/Fi1aZIkCYg/hsmXLFklMTJSMjAzZuXMnDY+waG1tlTlz5khycrIcOnTohOQ8EI5r77333ispKSkydepUGTp0qGzcuJGGh+e45/AWCQKE7I06ZcoU2bZtm6xatco+JOsH5ttuu03KyspoZXhGR2wHDx4spaWl8tBDD0nfvn1l9erV8sQTT9j3mcGCcDh69KiMHj1aYmJiZPHixTQ6wmLt2rVSVFRkj3l5eZYgDaDvg5cOHjwoY8eOlfLycvniiy8kPz/fEgWPP/448QdPcc/hPRIECInq6mopLCy0UdyRI0faiIbeuFVVVcmSJUukpqaGlkbI1dfX24cSvTHTeLvlllss3saPH28fmg8fPswsAoRFSUmJxMXFWXJq2bJl1h8CXluxYoXNHtDr7vr16+3m7I033pDffvuNvg+e0gEhHQDSmLvsssskKSlJxo0bJ7GxsTazhRl88Ar3HN4jQYCQqKurk99//12uvPJKe97U1CS9e/eWRx55xDLLGzZsoKURcrqM4Oqrr5bp06fbyK2OmHXq1EkaGxvlyJEj0q1bN0bR4JnjR2g7d+4sF154oVxzzTWSmpoq2dnZwSQW4EXs6XICXcZ37bXXypNPPmmJ0Z9++kkWLFhgcfjJJ5/Q8PB0eYHWXdG+T2ks5uTkSJ8+feT111+3azDgBe45vEeCAKdMR8eWL19+wk1/QkKCJQTeeuutvwIr+q/Q0hkFmk3W6Y+aNABCEXs6UqZ0xHby5Mk2gqZ01CJQrHDgwIH2NaMY8Cr+NLYCMaczCHTKrdJZBJ9//rnccMMNNrtl+/bt/BIQ8tjTa6vepOksAi1S+OGHH8qaNWusBsZFF11kN2nEHrz63Dd8+HBJT0+Xu+++2/q6Xr162edATdLr4FBmZqYlrID/QpfsPfroozY7NEBnq2i8cc/hIQecpLffftvFx8e7q666yiUnJ7uePXu6p556yr534MAB9/DDD7vExERXU1Njx44cOWKPq1atcmeffXbwORDK2Gtubg7+XGtrqz0OGzbMrVix4oRjQCjj7+mnn7bvNTU12eP48ePdl19+aV8vX77cde3a1cXExLg1a9bQ8PAk9tTKlStdVFSUXXtra2uDxzds2ODOO+88t2nTJlofnlx71cGDB115eblLS0tzL7zwQvD45s2b3cCBA11+fj6tj9OyevVqizeNvXHjxtk1dcaMGfa9+vp67jk8RoIAJ/1GHTp0qFu6dKk93717t3v11Vdd9+7dLTmgCgoKXGpqqrvvvvtOuDH7+uuv7QLz448/0toIaezpReLvduzYYReV7du3B49VVlbaY0tLC78BeBJ/mZmZbtKkSdYHavwtWrTIxcXFnfChGQj1dXfr1q0uPT3dDR482FVXVwdfqwn5Hj16uPfff59Gh6d9X0lJiUtKSrIEVeBznybu6f9wujTJrgmp1157zZ4fO3bM4lGTBA0NDXaMew5vscQA/zbDxB51GuOwYcNsOrfSNWY6rfv888+3QjVK14JPmDDBdjH46KOP7DVKt7zRKvNDhgyhtRHS2PunHTJ0arfuZKBT0DZv3myv1doYWvU2sPQFCGX86VpbrTXw2Wef2TavGnePPfaYzJs3z3bW+PXXX2lweNL3DRo0SB588EGprKyUpUuXyu7du+34xx9/bNfcESNG0PLw9NqrtX50J4Ndu3YFl/Rp/YsBAwZYLQzgZAWW7GnczZ0713ZHUx07dpS9e/fKPffcI126dLFjaWlpds+hRVm55/CAxwkItFHFxcVu3759wef79+8/YSq3+uGHH1zv3r3d3r17g8cC035iY2PdyJEjg9OCcnJy7PtM94ZXsReIrdmzZ7uxY8e6OXPmuOjoaDdt2jTX2NhIw8PTvq+wsNCVlpae8HMad4sXL2bmCjyNPfXKK6+4Pn362EjurbfeaqO8x08FB7yKv7q6OpeRkeG6devmZs6c6SZPnmyfARcsWMBnPpx036fxdrzj7xfmz5/vOnbs6AYNGmQzC/Ly8mxWwdGjR93cuXO55/BARy+SDmi7PvjgAxuN0Kq0mj3WIjNaaFCLgQSye4FR2K+++soKIWmhON0DXAvTaNGk5557zqp4b9261bY31OJdOsqhKBgHr2IvUDBOR850iy/d9ksLJOnsFcCrvk+Lr+prtM/7Oz2uMwgAL6+7avbs2TZ7Ra+3OpL77LPPSmJiIg0Pz+PvnHPOkZUrV9rMvdraWvu577//nvjDKceezhjIysqyYpeB2Hv33Xflu+++k3feeceO685o+jNnnXWW3HTTTfL888/bjAPuOULMi6wD2qaioiLLzr300ktWLyA3N9fW0mZlZVmGOLCGW7N2SkcpZs2aFeGzRnsQqtjTDPQzzzzj1q1bF/b/A9ou+j4Qe/CjUPd9gZ8DQhF7Suut/D2u+vXr57Kzs2lkD7EgF8H1Zprx1W26dMuaSy+91DJ0CxcutPW0ubm59jOaRdY/+potW7bY1jZKt1jKyMiwkQsgUrGnGeX58+fL9ddfzy8BYY8/IFJ9H3AmxJ+uFQdCFXtKZyYH4kpfqzV9tO7FueeeS0N7iAQBgtP+d+zYYVPCju/gdbrP5ZdfLmvXrpXS0tK/giY6WoqKiuwNmpKSYtOD9M1dV1cn8fHxtCgiEns9e/ak5XFK6PsQKcQeIon4Q1uJveOXJu/fv9+WFOjyl5tvvjkCZ+8fJAh8qKCgQO6//355+eWXpbCwMHh8+PDhsmnTJvnjjz/seUtLi3Tv3t3ehPoG1XU/AVqtW9f7aKV4/ft0pwL9vq4jAiIRe4HKtgB9H840XHdB/MGP/mvfp7Uu3nvvPavnc8kll0hxcbEsWbLEdtOAd0gQ+Eh1dbUV9LjrrrtsuxAtKqNTsQNvWP26f//+VmTw+KzdqFGjbOS2oqIi+HfFxMTY9B7dXkSzfJrxA4g9nIno+0DswY/o+9DWY0+XFegA0M8//2xJBi1YePHFF/OL9ZqXBQ5w5jh06JDLzMx0d955p6uqqgoeT01NdVOmTLGvdTubN99807aG27hx4wmvnzhxoktPTw8+r62tDePZoy0j9kD8wY/o+0D8wY9C3fdpoUyEFzMIfELXbOv0f13fM2DAAGlubrbjY8aMkbKyMvu6Q4cOcscdd9j0nunTp8v69estc6fTf8rLyy0LGMB6bxB7aAvo+0DswY/o+9BeYi+wzSbCJ0qzBGH89xBBuseoLg1Q+mvX6TyTJk2Srl27yrJly4LHGhsbrUrttm3bJDk52dZ79+vXT/Lz822fW4DYQ1tC3wdiD35E3wdiD6eDBIHPjRgxQqZOnWpZPk0QtLa2WlavpqbGtrPRivG6RmjChAmRPlW0M8QeiD/4EX0fiD/4EX1f20GCwMeqqqokLS1NPv3002CRQa0W2qlTp0ifGto5Yg/EH/yIvg/EH/yIvq9tYVGHDwVWlXz77bfSo0ePYHIgOztbHnjgAamtrY3wGaK9IvZA/MGP6PtA/MGP6Pvapo6RPgGEX2ArEd1q5Pbbb7c9SmfMmCGHDx+WvLw8iY+P59cCYg/tDn0fiD34EX0fiD2cCpYY+JQWIhwyZIhUVlbakgKdPTBv3rxInxZ8gNgD8Qc/ou8D8Qc/ou9re0gQ+NioUaMkISFBXnzxRenSpUukTwc+QuyB+IMf0feB+IMf0fe1LSQIfKylpcV2LACIPfgJfR+IPfgRfR+IPZwMEgQAAAAAAIBdDAAAAAAAAAkCAAAAAABAggAAAAAAAJAgAAAAAAAAJvqvBwAAAAAA4GckCAAAAAAAAAkCAAAAAABAggAAAAAAAJAgAAAAAAAAJAgAAAAAAICo/wEjdD+vwDIDaAAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -648,7 +801,9 @@ "source": [ "## Sub-annual frequencies\n", "\n", - "`freq` accepts any pandas-compatible period string. Common options:\n", + "`freq` accepts any [pandas-compatible period aliases string](https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#period-aliases).\n", + "\n", + "Common options:\n", "\n", "| `freq` | Meaning |\n", "|---|---|\n", @@ -658,13 +813,17 @@ "| `\"7D\"` | Every 7 days |\n", "\n", "```{note}\n", - "The periodic amounts are interpreted as **per-period** values, not annualised.\n", + "The periodic amounts are interpreted as **per-period** values. A periodic cost of 500 with a monthly frequency (\"M\"), means a cost of 500 per month. The growth rates however are always considered to be yearly.\n", + "```\n", + "\n", + "```{note}\n", + "The implementation, starting and ending dates are coerced to the period frequency. For instance `\"2022-01-05\"` with monthly frequency is considered as `\"2022-01\"`.\n", "```" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "id": "277e6948", "metadata": {}, "outputs": [ @@ -800,7 +959,7 @@ "11 2022-12 200.0 -500.0 700.0" ] }, - "execution_count": 11, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -815,16 +974,16 @@ ")\n", "\n", "df_monthly = ci_monthly.to_dataframe(\n", - " impl_date=\"2022-01-01\",\n", - " start_date=\"2022-01-01\",\n", - " end_date=\"2022-12-01\",\n", + " impl_date=\"2022-01-05\",\n", + " start_date=\"2022-01\",\n", + " end_date=\"2022-12\",\n", ")\n", "df_monthly" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "id": "03a80747", "metadata": {}, "outputs": [ @@ -834,7 +993,7 @@ "(, )" ] }, - "execution_count": 12, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, @@ -851,9 +1010,9 @@ ], "source": [ "ci_monthly.plot_cash_flows(\n", - " \"2022-01-01\",\n", - " \"2022-01-01\",\n", - " \"2022-12-01\",\n", + " \"2022-01\",\n", + " \"2022-01\",\n", + " \"2022-12\",\n", ")" ] }, @@ -871,39 +1030,144 @@ "```\n", "\n", "```{note}\n", - "`custom_cash_flows` are **not** carried over to the combined object. Merge custom flows manually beforehand if needed.\n", + "`custom_cash_flows` are merged by summing them together.\n", "```" ] }, { "cell_type": "code", - "execution_count": 13, - "id": "666fd82b", + "execution_count": 12, + "id": "39c99bd5-3a54-4d5c-bf0d-ffbb713ce1a8", "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "CostIncome(\n", - " mkt_price_year = 2020\n", - " freq = 'Y'\n", - " init_cost = -50,000.00\n", - " periodic_cost = -5,000.00\n", - " periodic_income = 8,000.00\n", - " cost_yearly_growth_rate = 0.00%\n", - " income_yearly_growth_rate = 0.00%\n", - " custom_cash_flows = None\n", - ")\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", + "
costincome
date
2022-01-01-20000
2023-01-0100
2024-01-01-100000
2025-01-0100
2026-01-01020000
2027-01-0100
2028-01-01-200000
2029-01-01-100000
\n", + "
" + ], + "text/plain": [ + " cost income\n", + "date \n", + "2022-01-01 -2000 0\n", + "2023-01-01 0 0\n", + "2024-01-01 -10000 0\n", + "2025-01-01 0 0\n", + "2026-01-01 0 20000\n", + "2027-01-01 0 0\n", + "2028-01-01 -20000 0\n", + "2029-01-01 -10000 0" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ + "import pandas as pd\n", + "\n", + "custom_flows_a = pd.DataFrame(\n", + " {\n", + " \"date\": [\"2024\", \"2026\", \"2028\"],\n", + " \"cost\": [10_000, 0, 20_000], # extra one-off costs\n", + " \"income\": [0, 15_000, 0], # extra one-off income\n", + " }\n", + ")\n", + "\n", + "custom_flows_b = pd.DataFrame(\n", + " {\n", + " \"date\": [\"2022\", \"2026\", \"2029\"],\n", + " \"cost\": [2_000, 0, 10_000], # extra one-off costs\n", + " \"income\": [0, 5_000, 0], # extra one-off income\n", + " }\n", + ")\n", + "\n", "ci_a = CostIncome(\n", " mkt_price_year=2020,\n", " init_cost=30_000,\n", " periodic_cost=2_000,\n", " periodic_income=4_000,\n", + " custom_cash_flows=custom_flows_a,\n", " freq=\"Y\",\n", ")\n", "\n", @@ -912,12 +1176,18 @@ " init_cost=20_000,\n", " periodic_cost=3_000,\n", " periodic_income=4_000,\n", + " custom_cash_flows=custom_flows_b,\n", " freq=\"Y\",\n", ")\n", "\n", "ci_combined = CostIncome.comb_cost_income([ci_a, ci_b])\n", + "ci_combined.plot_cash_flows(\n", + " \"2025\",\n", + " \"2020\",\n", + " \"2030\",\n", + ")\n", "\n", - "print(ci_combined)" + "ci_combined.custom_cash_flows" ] }, { @@ -932,7 +1202,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "id": "eeac2088", "metadata": {}, "outputs": [ @@ -975,7 +1245,7 @@ "source": [ "### From a YAML file\n", "\n", - "Create a YAML file structured as follows, then load it with `CostIncome.from_yaml`.\n", + "Create a YAML file structured as follows, then load it with `CostIncome.from_yaml()`.\n", "\n", "```yaml\n", "# measure_cost.yaml\n", @@ -992,6 +1262,13 @@ " # - date: \"2024-01-01\"\n", " # cost: 10000\n", " # income: 0\n", + "```\n", + "\n", + "---\n", + "\n", + "```python\n", + "# Inside Notebook or script\n", + "ci_from_yaml = CostIncome.from_yaml(\"measure_cost.yaml\")\n", "```" ] } From 7b9be554fcedd8afb8adc9e303e402482a7ebe32 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 21 Apr 2026 11:35:13 +0200 Subject: [PATCH 21/44] Removes advanced test debugging mechanisms --- climada/entity/measures/test/test_cost_income.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/climada/entity/measures/test/test_cost_income.py b/climada/entity/measures/test/test_cost_income.py index edc35528a8..04be3bbd10 100644 --- a/climada/entity/measures/test/test_cost_income.py +++ b/climada/entity/measures/test/test_cost_income.py @@ -236,7 +236,6 @@ def test_custom_cash_flows_added(self): } ) ci = CostIncome(mkt_price_year=2021, custom_cash_flows=df, freq="Y") - print(ci.custom_cash_flows) impl = pd.Timestamp("2021-01-01") curr = pd.Timestamp("2021-01-01") net, cost, inc = ci.calc_at_date(impl, curr) @@ -422,6 +421,4 @@ def test_merges_custom_cash_flows(self): ) combined = CostIncome.comb_cost_income([ci1, ci2]) - print(combined.custom_cash_flows) - print(expected) pd.testing.assert_frame_equal(combined.custom_cash_flows, expected) From 2ee944b34498caaef67ac5cff8c584579f79cf72 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 21 Apr 2026 11:49:42 +0200 Subject: [PATCH 22/44] Fixes remaining pylint remarks --- climada/entity/measures/cost_income.py | 39 +++++++++++++++++--------- 1 file changed, 25 insertions(+), 14 deletions(-) diff --git a/climada/entity/measures/cost_income.py b/climada/entity/measures/cost_income.py index 9b61b25437..01d5afe5d5 100644 --- a/climada/entity/measures/cost_income.py +++ b/climada/entity/measures/cost_income.py @@ -25,6 +25,7 @@ import matplotlib.pyplot as plt import numpy as np import pandas as pd +import yaml from climada.entity.measures.measure_config import CostIncomeConfig @@ -112,13 +113,21 @@ def __repr__(self) -> str: f" periodic_income = {self.periodic_income:,.2f}", f" cost_yearly_growth_rate = {self.cost_growth_rate:.2%}", f" income_yearly_growth_rate = {self.income_growth_rate:.2%}", - f" custom_cash_flows = {None if self.custom_cash_flows is None else f'DataFrame({len(self.custom_cash_flows)} rows)'}", + " custom_cash_flows = " + f"{None if self.custom_cash_flows is None else f'DataFrame({len(self.custom_cash_flows)} rows)'}", ")", ] return "\n".join(lines) @property def custom_cash_flows(self) -> pd.DataFrame | None: + """:obj:`pd.DataFrame` : Get or set the optional user-defined cash + flows. + + Input cash flow have to contain a "date" column as well as at least one + of "cost" and "income". The custom cash flow is coerced to the internal + period frequency. + """ return self._custom_cash_flows @custom_cash_flows.setter @@ -250,8 +259,6 @@ def from_yaml(cls, path: str) -> "CostIncome": CostIncome """ - import yaml - with open(path) as f: return cls.from_dict(yaml.safe_load(f)["cost_income"]) @@ -282,8 +289,8 @@ def _freq_to_days(cls, freq: str) -> str: # Return the difference in days return f"{(end_date - base_date).days}d" - except ValueError: - raise ValueError(f"Invalid frequency string: {freq}") + except ValueError as exc: + raise ValueError(f"Invalid frequency string: {freq}") from exc def _get_width_days(self) -> float: """Return the number of days in the current frequency.""" @@ -556,32 +563,36 @@ def comb_cost_income(cost_incomes: list["CostIncome"]) -> "CostIncome": first_ci = cost_incomes[0] if not all( - [ + ( first_ci.mkt_price_year.year == c.mkt_price_year.year for c in cost_incomes - ] + ) ): raise ValueError( - "Measure cost incomes have different market price years, combination is not possible." + "Measure cost incomes have different market price years," + " combination is not possible." ) if not all( - [first_ci.cost_growth_rate == c.cost_growth_rate for c in cost_incomes] + first_ci.cost_growth_rate == c.cost_growth_rate for c in cost_incomes ): raise ValueError( - "Measure cost incomes have different cost_growth_rate, combination is not possible." + "Measure cost incomes have different cost_growth_rate," + " combination is not possible." ) if not all( - [first_ci.income_growth_rate == c.income_growth_rate for c in cost_incomes] + first_ci.income_growth_rate == c.income_growth_rate for c in cost_incomes ): raise ValueError( - "Measure cost incomes have different income_growth_rate, combination is not possible." + "Measure cost incomes have different income_growth_rate," + " combination is not possible." ) - if not all([first_ci.freq == c.freq for c in cost_incomes]): + if not all(first_ci.freq == c.freq for c in cost_incomes): raise ValueError( - "Measure cost incomes have different period frequencies, combination is not possible." + "Measure cost incomes have different period frequencies," + " combination is not possible." ) try: From 95b3e173a3701934cacccab2f9715abe61320337 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 21 Apr 2026 14:05:27 +0200 Subject: [PATCH 23/44] Fixes type hint problem --- climada/entity/measures/base.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/climada/entity/measures/base.py b/climada/entity/measures/base.py index 1cb9829c6e..cafbc9d022 100755 --- a/climada/entity/measures/base.py +++ b/climada/entity/measures/base.py @@ -51,8 +51,6 @@ # TODO: risk transfer? -T = TypeVar("T", Exposures, ImpactFuncSet, Hazard) - # Note for review: # This function will moved in helper.py in a future PR which will From 289583524045f7b8c532e4497af5d0137a6fdc34 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 21 Apr 2026 14:05:39 +0200 Subject: [PATCH 24/44] Indentity_function check now based on __name__ --- climada/entity/measures/base.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/climada/entity/measures/base.py b/climada/entity/measures/base.py index cafbc9d022..bf25625b64 100755 --- a/climada/entity/measures/base.py +++ b/climada/entity/measures/base.py @@ -265,7 +265,7 @@ def apply_exposures_changes( changed_exp = ( copy.deepcopy(exposures) - if enforce_copy and self.exposures_changes is not identity_function + if enforce_copy and self.exposures_changes.__name__ != "identity_function" else exposures ) try: From c68dac8ecf133af62950203f9f441655687b1476 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 21 Apr 2026 14:14:18 +0200 Subject: [PATCH 25/44] Apply identity function fix to other methods --- climada/entity/measures/base.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/climada/entity/measures/base.py b/climada/entity/measures/base.py index bf25625b64..3e827af88b 100755 --- a/climada/entity/measures/base.py +++ b/climada/entity/measures/base.py @@ -323,7 +323,7 @@ def apply_impfset_changes( changed_impfset = ( copy.deepcopy(impfset) - if enforce_copy and self.impfset_changes is not identity_function + if enforce_copy and self.impfset_changes.__name__ != "identity_function" else impfset ) try: @@ -380,7 +380,7 @@ def apply_hazard_changes( changed_hazard = ( copy.deepcopy(hazard) - if enforce_copy and self.hazard_changes is not identity_function + if enforce_copy and self.hazard_changes.__name__ != "identity_function" else hazard ) try: From 4313ee62cf6716870b5bea2caf67f6c72e566299 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 21 Apr 2026 14:25:04 +0200 Subject: [PATCH 26/44] Adds unit and (some) integration tests --- climada/entity/measures/test/test_base.py | 368 ++++++++++++++++++++++ climada/test/test_measures.py | 306 ++++++++++++++++++ 2 files changed, 674 insertions(+) create mode 100644 climada/entity/measures/test/test_base.py create mode 100644 climada/test/test_measures.py diff --git a/climada/entity/measures/test/test_base.py b/climada/entity/measures/test/test_base.py new file mode 100644 index 0000000000..2020f83aa2 --- /dev/null +++ b/climada/entity/measures/test/test_base.py @@ -0,0 +1,368 @@ +""" +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 the Measure class. +""" + +import copy +from unittest.mock import MagicMock, patch + +import pytest + +from climada.entity.measures.base import Measure, allow_kwargs +from climada.entity.measures.cost_income import CostIncome + + +def _make_mock(): + """Return a simple MagicMock to stand in for Exposures / ImpactFuncSet / Hazard.""" + m = MagicMock() + m.__deepcopy__ = lambda self: copy.copy(self) # survive deepcopy + return m + + +class TestAllowKwargs: + def test_unknown_kwargs_are_filtered(self): + @allow_kwargs + def add(a, b): + return a + b + + assert add(1, 2, extra=99) == 3 + + def test_known_kwargs_are_passed(self): + @allow_kwargs + def greet(name, greeting="Hello"): + return f"{greeting}, {name}!" + + assert greet("Alice", greeting="Hi", unused="x") == "Hi, Alice!" + + def test_func_with_var_keyword_receives_all(self): + received = {} + + @allow_kwargs + def sink(**kwargs): + received.update(kwargs) + + sink(a=1, b=2) + assert received == {"a": 1, "b": 2} + + def test_positional_args_still_work(self): + @allow_kwargs + def mul(x, y): + return x * y + + assert mul(3, 4) == 12 + + def test_wraps_preserves_name(self): + def my_func(x): + return x + + wrapped = allow_kwargs(my_func) + assert wrapped.__name__ == "my_func" + + +class TestMeasureInit: + def test_name_is_set(self): + m = Measure("flood_barrier") + assert m.name == "flood_barrier" + + def test_default_cost_income_created(self): + m = Measure("test") + assert isinstance(m.cost_income, CostIncome) + + def test_provided_cost_income_used(self): + ci = CostIncome(init_cost=500) + m = Measure("test", cost_income=ci) + assert m.cost_income is ci + + def test_default_color_rgb(self): + m = Measure("test") + assert m.color_rgb == (0, 0, 0) + + def test_custom_color_rgb(self): + m = Measure("test", color_rgb=(1.0, 0.5, 0.0)) + assert m.color_rgb == (1.0, 0.5, 0.0) + + def test_sub_measures_default_none(self): + m = Measure("test") + assert m.sub_measures is None + + def test_sub_measures_stored(self): + m = Measure("combo", sub_measures=["a", "b"]) + assert m.sub_measures == ["a", "b"] + + def test_implementation_duration_stored(self): + from pandas.tseries.offsets import DateOffset + + offset = DateOffset(years=2) + m = Measure("test", implementation_duration=offset) + assert m.implementation_duration == offset + + def test_change_functions_wrapped_with_allow_kwargs(self): + def my_fn(obj): + return obj + + m = Measure("test", exposures_changes=my_fn) + # The wrapped function should not raise on extra kwargs + stub = _make_mock() + result = m.exposures_changes(stub, unexpected_kwarg=42) + assert result is stub + + +class TestIsSerializable: + def test_false_without_config(self): + m = Measure("test") + assert m.is_serializable is False + + def test_true_with_config(self): + mock_config = MagicMock() + m = Measure("test", _config=mock_config) + assert m.is_serializable is True + + +class TestApplyExposuresChanges: + def test_identity_does_not_deepcopy(self): + m = Measure("test") # defaults to identity_function + exp = _make_mock() + result = m.apply_exposures_changes(exp, enforce_copy=True) + assert result is exp # identity: no copy + + def test_custom_fn_deepcopies_when_enforce_copy(self): + copied = _make_mock() + original = _make_mock() + + def fn(obj, **kw): + return obj + + with patch( + "climada.entity.measures.base.copy.deepcopy", return_value=copied + ) as mock_dc: + m = Measure("test", exposures_changes=fn) + result = m.apply_exposures_changes(original, enforce_copy=True) + mock_dc.assert_called_once() + assert result is copied + + def test_no_deepcopy_when_enforce_copy_false(self): + original = _make_mock() + + def fn(obj, **kw): + return obj + + with patch("climada.entity.measures.base.copy.deepcopy") as mock_dc: + m = Measure("test", exposures_changes=fn) + m.apply_exposures_changes(original, enforce_copy=False) + mock_dc.assert_not_called() + + def test_kwargs_forwarded(self): + received = {} + + def fn(obj, **kwargs): + received.update(kwargs) + return obj + + m = Measure("test", exposures_changes=fn) + exp = _make_mock() + m.apply_exposures_changes(exp, enforce_copy=False, year=2030) + assert received.get("year") == 2030 + + def test_missing_required_arg_raises_type_error_with_message(self): + def fn(obj, required_arg): + return obj + + m = Measure("test", exposures_changes=fn) + with pytest.raises(TypeError, match="required positional argument"): + m.apply_exposures_changes(_make_mock(), enforce_copy=False) + + +class TestApplyImpfsetChanges: + def test_identity_returns_same_object(self): + m = Measure("test") + impfset = _make_mock() + result = m.apply_impfset_changes(impfset, enforce_copy=True) + assert result is impfset + + def test_custom_fn_deepcopies_when_enforce_copy(self): + copied = _make_mock() + + def fn(obj, **kw): + return obj + + with patch("climada.entity.measures.base.copy.deepcopy", return_value=copied): + m = Measure("test", impfset_changes=fn) + result = m.apply_impfset_changes(_make_mock(), enforce_copy=True) + assert result is copied + + def test_kwargs_forwarded(self): + received = {} + + def fn(obj, **kwargs): + received.update(kwargs) + return obj + + m = Measure("test", impfset_changes=fn) + m.apply_impfset_changes(_make_mock(), enforce_copy=False, scenario="rcp85") + assert received.get("scenario") == "rcp85" + + def test_missing_required_arg_raises_type_error_with_message(self): + def fn(obj, required_arg): + return obj + + m = Measure("test", impfset_changes=fn) + with pytest.raises(TypeError, match="required positional argument"): + m.apply_impfset_changes(_make_mock(), enforce_copy=False) + + +class TestApplyHazardChanges: + def test_identity_returns_same_object(self): + m = Measure("test") + hazard = _make_mock() + result = m.apply_hazard_changes(hazard, enforce_copy=True) + assert result is hazard + + def test_custom_fn_deepcopies_when_enforce_copy(self): + copied = _make_mock() + + def fn(obj, **kw): + return obj + + with patch("climada.entity.measures.base.copy.deepcopy", return_value=copied): + m = Measure("test", hazard_changes=fn) + result = m.apply_hazard_changes(_make_mock(), enforce_copy=True) + assert result is copied + + def test_no_deepcopy_when_enforce_copy_false(self): + def fn(obj, **kw): + return obj + + with patch("climada.entity.measures.base.copy.deepcopy") as mock_dc: + m = Measure("test", hazard_changes=fn) + m.apply_hazard_changes(_make_mock(), enforce_copy=False) + mock_dc.assert_not_called() + + def test_kwargs_forwarded(self): + received = {} + + def fn(obj, **kwargs): + received.update(kwargs) + return obj + + m = Measure("test", hazard_changes=fn) + m.apply_hazard_changes(_make_mock(), enforce_copy=False, intensity_scale=0.8) + assert received.get("intensity_scale") == 0.8 + + def test_missing_required_arg_raises_type_error_with_message(self): + def fn(obj, required_arg): + return obj + + m = Measure("test", hazard_changes=fn) + with pytest.raises(TypeError, match="required positional argument"): + m.apply_hazard_changes(_make_mock(), enforce_copy=False) + + +class TestApply: + def _make_measure_with_trackers(self): + """Return a Measure whose change functions record received kwargs.""" + exp_kwargs, haz_kwargs, impfset_kwargs = {}, {}, {} + + def track_exp(obj, **kw): + exp_kwargs.update(kw) + return obj + + def track_haz(obj, **kw): + haz_kwargs.update(kw) + return obj + + def track_impfset(obj, **kw): + impfset_kwargs.update(kw) + return obj + + m = Measure( + "tracker", + exposures_changes=track_exp, + hazard_changes=track_haz, + impfset_changes=track_impfset, + ) + return m, exp_kwargs, haz_kwargs, impfset_kwargs + + def test_returns_three_objects(self): + m = Measure("test") + exp, impfset, haz = _make_mock(), _make_mock(), _make_mock() + result = m.apply(exp, impfset, haz) + assert len(result) == 3 + + def test_default_triplet_context_passed_as_kwargs(self): + m, exp_kw, haz_kw, impfset_kw = self._make_measure_with_trackers() + exp, impfset, haz = _make_mock(), _make_mock(), _make_mock() + m.apply(exp, impfset, haz, enforce_copy=False) + + assert exp_kw["base_exposures"] is exp + assert exp_kw["base_impfset"] is impfset + assert exp_kw["base_hazard"] is haz + + def test_entity_specific_kwargs_override_defaults(self): + m, exp_kw, _, _ = self._make_measure_with_trackers() + exp, impfset, haz = _make_mock(), _make_mock(), _make_mock() + custom = _make_mock() + m.apply( + exp, + impfset, + haz, + enforce_copy=False, + kwargs_exposures={"base_exposures": custom}, + ) + assert exp_kw["base_exposures"] is custom + + def test_entity_specific_kwargs_not_leaked_to_other_functions(self): + m, exp_kw, haz_kw, _ = self._make_measure_with_trackers() + exp, impfset, haz = _make_mock(), _make_mock(), _make_mock() + m.apply( + exp, + impfset, + haz, + enforce_copy=False, + kwargs_exposures={"exp_only_param": 42}, + ) + assert "exp_only_param" not in haz_kw + assert "exp_only_param" in exp_kw + + def test_apply_with_all_identities_returns_originals(self): + m = Measure("test") # all identity functions + exp, impfset, haz = _make_mock(), _make_mock(), _make_mock() + new_exp, new_impfset, new_haz = m.apply(exp, impfset, haz) + assert new_exp is exp + assert new_impfset is impfset + assert new_haz is haz + + def test_apply_order_is_exposures_hazard_impfset(self): + """Verify the transformation order documented in the docstring.""" + call_order = [] + + def track(name): + def fn(obj, **kw): + call_order.append(name) + return obj + + return fn + + m = Measure( + "order_test", + exposures_changes=track("exposures"), + hazard_changes=track("hazard"), + impfset_changes=track("impfset"), + ) + m.apply(_make_mock(), _make_mock(), _make_mock(), enforce_copy=False) + assert call_order == ["exposures", "hazard", "impfset"] diff --git a/climada/test/test_measures.py b/climada/test/test_measures.py new file mode 100644 index 0000000000..d5f6c22649 --- /dev/null +++ b/climada/test/test_measures.py @@ -0,0 +1,306 @@ +""" +Integration tests for the Measure class. + +These tests use real CLIMADA objects (Exposures, ImpactFuncSet, Hazard) built +from the shared conftest fixtures. They verify that Measure transformations +produce analytically expected results rather than mocking internals. + +Expected impact values (from conftest docstring): + AAI = 18 + RP20 = 0 (event 1, freq 0.03) + RP50 = 0 (event 2, freq 0.01) + RP100 = 500 (event 3, freq 0.006 → 1000 * 0.5) + RP250 = 3750 (event 4, freq 0.004 → 15000 * 0.25) +""" + +import numpy as np +import pytest +from scipy.sparse import csr_matrix + +from climada.entity.measures.base import Measure +from climada.entity.measures.cost_income import CostIncome +from climada.test.conftest import HAZARD_TYPE + +# =========================================================================== +# apply() — structural / immutability tests +# =========================================================================== + + +class TestApplyStructural: + """Verify that apply() correctly transforms the risk triplet.""" + + def test_identity_measure_returns_equal_objects(self, exposures, impfset, hazard): + """An identity measure should return objects equal to the originals.""" + m = Measure("identity") + new_exp, new_impfset, new_haz = m.apply(exposures, impfset, hazard) + + assert new_exp.gdf["value"].tolist() == exposures.gdf["value"].tolist() + assert new_haz.intensity.nnz == hazard.intensity.nnz + assert list(new_impfset.get_func(haz_type=HAZARD_TYPE)) == list( + impfset.get_func(haz_type=HAZARD_TYPE) + ) + + def test_enforce_copy_true_does_not_mutate_originals( + self, exposures, impfset, hazard + ): + """With enforce_copy=True, the originals must not be mutated.""" + original_values = exposures.gdf["value"].copy() + + def double_values(exp, **kw): + exp.gdf["value"] *= 2 + return exp + + m = Measure("doubler", exposures_changes=double_values) + m.apply(exposures, impfset, hazard, enforce_copy=True) + + np.testing.assert_array_equal( + exposures.gdf["value"].values, original_values.values + ) + + def test_enforce_copy_false_mutates_original(self, exposures, impfset, hazard): + """With enforce_copy=False the change function receives the original object.""" + received_ids = [] + + def record_id(exp, **kw): + received_ids.append(id(exp)) + return exp + + m = Measure("recorder", exposures_changes=record_id) + m.apply(exposures, impfset, hazard, enforce_copy=False) + + assert received_ids[0] == id(exposures) + + def test_base_triplet_available_as_kwargs(self, exposures, impfset, hazard): + """Each change function receives base_exposures/impfset/hazard as kwargs.""" + received = {} + + def capture(**kwargs): + def fn(obj, **kw): + received.update(kw) + return obj + + return fn + + m = Measure( + "capture", + exposures_changes=capture(), + ) + m.apply(exposures, impfset, hazard, enforce_copy=False) + + assert "base_exposures" in received + assert "base_impfset" in received + assert "base_hazard" in received + + +# =========================================================================== +# Exposures transformations +# =========================================================================== + + +class TestExposuresTransformations: + """Measures that modify Exposures.""" + + def test_scale_values(self, exposures, impfset, hazard): + """Scaling exposure values by 0.5 should halve every entry.""" + + def scale_half(exp, **kw): + exp.gdf["value"] *= 0.5 + return exp + + m = Measure("scale_half", exposures_changes=scale_half) + new_exp, _, _ = m.apply(exposures, impfset, hazard) + + np.testing.assert_allclose( + new_exp.gdf["value"].values, exposures.gdf["value"].values * 0.5 + ) + + def test_zero_all_values(self, exposures, impfset, hazard): + """Zeroing all exposures should produce zero impacts downstream.""" + + def zero_exp(exp, **kw): + exp.gdf["value"] = 0.0 + return exp + + m = Measure("zero_exp", exposures_changes=zero_exp) + new_exp, _, _ = m.apply(exposures, impfset, hazard) + + assert new_exp.gdf["value"].sum() == 0.0 + + def test_exposures_change_uses_base_hazard_kwarg( + self, exposures, impfset, hazard_factory + ): + """Change function can inspect base_hazard via the default kwargs.""" + captured_haz = {} + + def fn(exp, base_hazard=None, **kw): + captured_haz["haz"] = base_hazard + return exp + + haz = hazard_factory() + m = Measure("haz_aware", exposures_changes=fn) + m.apply(exposures, impfset, haz, enforce_copy=False) + + assert captured_haz["haz"] is haz + + +# =========================================================================== +# Hazard transformations +# =========================================================================== + + +class TestHazardTransformations: + """Measures that modify the Hazard.""" + + def test_zero_intensity_eliminates_impacts( + self, exposures, impfset, hazard_factory + ): + """Setting hazard intensity to zero should yield zero impacts.""" + + def zero_intensity(haz, **kw): + haz.intensity = csr_matrix(haz.intensity.shape) + return haz + + haz = hazard_factory() + m = Measure("zero_haz", hazard_changes=zero_intensity) + new_exp, new_impfset, new_haz = m.apply(exposures, impfset, haz) + + assert new_haz.intensity.nnz == 0 + + def test_scale_intensity(self, exposures, impfset, hazard_factory): + """Halving hazard intensity should halve non-zero entries.""" + original_data = hazard_factory().intensity.data.copy() + + def half_intensity(haz, **kw): + haz.intensity = haz.intensity * 0.5 + return haz + + m = Measure("half_haz", hazard_changes=half_intensity) + _, _, new_haz = m.apply(exposures, impfset, hazard_factory()) + + np.testing.assert_allclose(new_haz.intensity.data, original_data * 0.5) + + +# =========================================================================== +# ImpactFuncSet transformations +# =========================================================================== + + +class TestImpfsetTransformations: + """Measures that modify the ImpactFuncSet.""" + + def test_scale_paa_to_zero_eliminates_impacts( + self, exposures, impfset_factory, hazard + ): + """Setting PAA to 0 should make all MDD-based impacts vanish.""" + + def zero_paa(ifs, **kw): + for func in ifs.get_func(haz_type=HAZARD_TYPE): + func.paa = np.zeros_like(func.paa) + return ifs + + impfset = impfset_factory() + m = Measure("zero_paa", impfset_changes=zero_paa) + _, new_impfset, _ = m.apply(exposures, impfset, hazard) + + for func in new_impfset.get_func(haz_type=HAZARD_TYPE): + np.testing.assert_array_equal(func.paa, 0) + + +# =========================================================================== +# Combined / multi-component transformations +# =========================================================================== + + +class TestCombinedTransformations: + """Measures that simultaneously affect more than one risk component.""" + + def test_combined_exposure_and_hazard_change( + self, exposures, impfset, hazard_factory + ): + """Both exposure and hazard transforms should be applied independently.""" + + def double_values(exp, **kw): + exp.gdf["value"] *= 2 + return exp + + def half_intensity(haz, **kw): + haz.intensity = haz.intensity * 0.5 + return haz + + haz = hazard_factory() + original_intensity_data = haz.intensity.data.copy() + + m = Measure( + "combined", + exposures_changes=double_values, + hazard_changes=half_intensity, + ) + new_exp, _, new_haz = m.apply(exposures, impfset, haz) + + np.testing.assert_allclose( + new_exp.gdf["value"].values, exposures.gdf["value"].values * 2 + ) + np.testing.assert_allclose( + new_haz.intensity.data, original_intensity_data * 0.5 + ) + + def test_kwargs_exposures_and_kwargs_hazard_routed_correctly( + self, exposures, impfset, hazard + ): + """kwargs_exposures and kwargs_hazard should reach the right function only.""" + exp_extra, haz_extra = {}, {} + + def track_exp(exp, my_exp_param=None, **kw): + exp_extra["val"] = my_exp_param + return exp + + def track_haz(haz, my_haz_param=None, **kw): + haz_extra["val"] = my_haz_param + return haz + + m = Measure("routed", exposures_changes=track_exp, hazard_changes=track_haz) + m.apply( + exposures, + impfset, + hazard, + enforce_copy=False, + kwargs_exposures={"my_exp_param": "exp_value"}, + kwargs_hazard={"my_haz_param": "haz_value"}, + ) + + assert exp_extra["val"] == "exp_value" + assert haz_extra["val"] == "haz_value" + + +# =========================================================================== +# CostIncome integration +# =========================================================================== + + +class TestCostIncomeIntegration: + """Verify that CostIncome financial data survives through Measure construction.""" + + def test_cost_income_attached(self, exposures, impfset, hazard): + ci = CostIncome(mkt_price_year=2020, init_cost=10_000, periodic_income=500) + m = Measure("with_ci", cost_income=ci) + assert m.cost_income is ci + + def test_total_cost_calculable_after_apply(self, exposures, impfset, hazard): + ci = CostIncome( + mkt_price_year=2020, + init_cost=10_000, + periodic_cost=1_000, + periodic_income=2_000, + ) + m = Measure("ci_measure", cost_income=ci) + m.apply(exposures, impfset, hazard) + + total_net, total_cost, total_inc = m.cost_income.calc_total( + impl_date="2020-01-01", + start_date="2020-01-01", + end_date="2030-01-01", + ) + # Over 10 years: init_cost once + 9 periodic_costs + 10 periodic_incomes + assert total_cost < 0 + assert total_inc > 0 + assert isinstance(total_net, float) From d35849efc0f534cdb38dcea5a52027b4fdfe96a2 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 21 Apr 2026 14:27:11 +0200 Subject: [PATCH 27/44] Changelog --- CHANGELOG.md | 1 + climada/entity/measures/test/test_cost_income.py | 1 - 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 1d83f88308..7e0ccc43a6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,6 +15,7 @@ Code freeze date: YYYY-MM-DD - Better type hints and overloads signatures for `ImpactFuncSet` [#1250](https://github.com/CLIMADA-project/climada_python/pull/1250) - Add inter- and extrapolation options to `ImpactFreqCurve` with method `interpolate` [#1252](https://github.com/CLIMADA-project/climada_python/pull/1252) - Adds `MeasureConfig` and related dataclasses for new `Measure` object retrocompatibility and (de)serialization capabilities [#1276](https://github.com/CLIMADA-project/climada_python/pull/1276) +- Adds new `Measure` class, implementing adaptation measures as closures. ### Changed - Updated Impact Calculation Tutorial (`doc.climada_engine_Impact.ipynb`) [#1095](https://github.com/CLIMADA-project/climada_python/pull/1095). diff --git a/climada/entity/measures/test/test_cost_income.py b/climada/entity/measures/test/test_cost_income.py index 04be3bbd10..66ebdc5afc 100644 --- a/climada/entity/measures/test/test_cost_income.py +++ b/climada/entity/measures/test/test_cost_income.py @@ -24,7 +24,6 @@ import numpy as np import pandas as pd import pytest -from pandas.testing import assert_frame_equal from climada.entity.measures.cost_income import CostIncome From 05cd6c40650d79ba6fba591668b8543b9ee554a4 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Mon, 11 May 2026 14:56:03 +0200 Subject: [PATCH 28/44] Rename base.py -> measure.py --- climada/entity/measures/{base.py => measure.py} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename climada/entity/measures/{base.py => measure.py} (100%) diff --git a/climada/entity/measures/base.py b/climada/entity/measures/measure.py similarity index 100% rename from climada/entity/measures/base.py rename to climada/entity/measures/measure.py From 8d6ef87e88539eb6be57d3294bc5da8da7290124 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Mon, 11 May 2026 14:58:40 +0200 Subject: [PATCH 29/44] propagates name change --- climada/entity/measures/measure_config.py | 2 +- .../test/{test_base.py => test_measure.py} | 16 ++++++++++------ climada/test/test_measures.py | 2 +- doc/api/climada/climada.entity.measures.rst | 2 +- 4 files changed, 13 insertions(+), 9 deletions(-) rename climada/entity/measures/test/{test_base.py => test_measure.py} (95%) diff --git a/climada/entity/measures/measure_config.py b/climada/entity/measures/measure_config.py index 7b63c728b8..ec88837d61 100644 --- a/climada/entity/measures/measure_config.py +++ b/climada/entity/measures/measure_config.py @@ -448,7 +448,7 @@ class MeasureConfig(ModifierConfig): This class is the primary entry point for defining measures in a declarative, file-based workflow and serves as the serialization - counterpart to :class:`~climada.entity.measures.base.Measure`. + counterpart to :class:`~climada.entity.measures.measure.Measure`. Parameters ---------- diff --git a/climada/entity/measures/test/test_base.py b/climada/entity/measures/test/test_measure.py similarity index 95% rename from climada/entity/measures/test/test_base.py rename to climada/entity/measures/test/test_measure.py index 2020f83aa2..2e5c20c288 100644 --- a/climada/entity/measures/test/test_base.py +++ b/climada/entity/measures/test/test_measure.py @@ -24,8 +24,8 @@ import pytest -from climada.entity.measures.base import Measure, allow_kwargs from climada.entity.measures.cost_income import CostIncome +from climada.entity.measures.measure import Measure, allow_kwargs def _make_mock(): @@ -149,7 +149,7 @@ def fn(obj, **kw): return obj with patch( - "climada.entity.measures.base.copy.deepcopy", return_value=copied + "climada.entity.measures.measure.copy.deepcopy", return_value=copied ) as mock_dc: m = Measure("test", exposures_changes=fn) result = m.apply_exposures_changes(original, enforce_copy=True) @@ -162,7 +162,7 @@ def test_no_deepcopy_when_enforce_copy_false(self): def fn(obj, **kw): return obj - with patch("climada.entity.measures.base.copy.deepcopy") as mock_dc: + with patch("climada.entity.measures.measure.copy.deepcopy") as mock_dc: m = Measure("test", exposures_changes=fn) m.apply_exposures_changes(original, enforce_copy=False) mock_dc.assert_not_called() @@ -201,7 +201,9 @@ def test_custom_fn_deepcopies_when_enforce_copy(self): def fn(obj, **kw): return obj - with patch("climada.entity.measures.base.copy.deepcopy", return_value=copied): + with patch( + "climada.entity.measures.measure.copy.deepcopy", return_value=copied + ): m = Measure("test", impfset_changes=fn) result = m.apply_impfset_changes(_make_mock(), enforce_copy=True) assert result is copied @@ -239,7 +241,9 @@ def test_custom_fn_deepcopies_when_enforce_copy(self): def fn(obj, **kw): return obj - with patch("climada.entity.measures.base.copy.deepcopy", return_value=copied): + with patch( + "climada.entity.measures.measure.copy.deepcopy", return_value=copied + ): m = Measure("test", hazard_changes=fn) result = m.apply_hazard_changes(_make_mock(), enforce_copy=True) assert result is copied @@ -248,7 +252,7 @@ def test_no_deepcopy_when_enforce_copy_false(self): def fn(obj, **kw): return obj - with patch("climada.entity.measures.base.copy.deepcopy") as mock_dc: + with patch("climada.entity.measures.measure.copy.deepcopy") as mock_dc: m = Measure("test", hazard_changes=fn) m.apply_hazard_changes(_make_mock(), enforce_copy=False) mock_dc.assert_not_called() diff --git a/climada/test/test_measures.py b/climada/test/test_measures.py index d5f6c22649..78fc2af85c 100644 --- a/climada/test/test_measures.py +++ b/climada/test/test_measures.py @@ -17,8 +17,8 @@ import pytest from scipy.sparse import csr_matrix -from climada.entity.measures.base import Measure from climada.entity.measures.cost_income import CostIncome +from climada.entity.measures.measure import Measure from climada.test.conftest import HAZARD_TYPE # =========================================================================== diff --git a/doc/api/climada/climada.entity.measures.rst b/doc/api/climada/climada.entity.measures.rst index 5f97f72bd4..426964c1c7 100644 --- a/doc/api/climada/climada.entity.measures.rst +++ b/doc/api/climada/climada.entity.measures.rst @@ -8,7 +8,7 @@ climada\.entity\.measures package climada\.entity\.measures\.base module -------------------------------------- -.. automodule:: climada.entity.measures.base +.. automodule:: climada.entity.measures.measure :members: :undoc-members: :show-inheritance: From 3ed1b5c54a551ebb6f1e123d9f0e6bb56d364b06 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 12 May 2026 15:34:47 +0200 Subject: [PATCH 30/44] Updates calc_impact code and docstring --- climada/entity/measures/measure.py | 29 +++++++++++++++++++++++++++-- 1 file changed, 27 insertions(+), 2 deletions(-) diff --git a/climada/entity/measures/measure.py b/climada/entity/measures/measure.py index 3e827af88b..156443360c 100755 --- a/climada/entity/measures/measure.py +++ b/climada/entity/measures/measure.py @@ -23,6 +23,8 @@ from pandas.tseries.offsets import BaseOffset +from climada.engine.impact import Impact + __all__ = ["Measure"] import copy @@ -490,7 +492,30 @@ def apply( ) return changed_exposures, changed_impfset, changed_hazard - def calc_impact(self, exposures, impfset, hazard): + def calc_impact( + self, exposures: Exposures, impfset: ImpactFuncSet, hazard: Hazard + ) -> Impact: + """Compute impact with the active measure. + + This convenience method allow to compute an ``Impact`` object from an + (Exposure, ImpactFuncSet, Hazard) triplet by first applying the measure + to that triplet. + + Parameters + ---------- + exposures : Exposures + The initial (no adaptation) exposures + impfset : ImpactFuncSet + The initial (no adaptation) impact function set + hazard : Hazard + The initial (no adaptation) hazard set + + Returns + ------- + Impact + The computed impact when the measure is in effect. + + """ from climada.engine.impact_calc import ( ImpactCalc, # pylint: disable=import-outside-toplevel ) @@ -507,4 +532,4 @@ def calc_impact(self, exposures, impfset, hazard): imp = ImpactCalc(new_exp, new_impfs, new_haz).impact( save_mat=False, assign_centroids=False ) - return imp.calc_risk_transfer(0, 0) + return imp # .calc_risk_transfer(0, 0) From 96f6f95df0c039a314f11eb3787e31fad07235ce Mon Sep 17 00:00:00 2001 From: spjuhel Date: Fri, 29 May 2026 10:21:42 +0200 Subject: [PATCH 31/44] Adds guide --- doc/user-guide/adaptation.rst | 2 +- doc/user-guide/climada_measures.ipynb | 267 ++++++++++++++++++++++++++ 2 files changed, 268 insertions(+), 1 deletion(-) create mode 100644 doc/user-guide/climada_measures.ipynb diff --git a/doc/user-guide/adaptation.rst b/doc/user-guide/adaptation.rst index 193e9c6b87..c719ff0dce 100644 --- a/doc/user-guide/adaptation.rst +++ b/doc/user-guide/adaptation.rst @@ -9,7 +9,7 @@ These guides show everything you need to know in order to evaluate adaptation op .. toctree:: :maxdepth: 1 - .. Adaptation measures in CLIMADA + Adaptation measures in CLIMADA Using measure configurations Defining measure cash flows .. Cost benefit evaluation diff --git a/doc/user-guide/climada_measures.ipynb b/doc/user-guide/climada_measures.ipynb new file mode 100644 index 0000000000..b8a0ae1090 --- /dev/null +++ b/doc/user-guide/climada_measures.ipynb @@ -0,0 +1,267 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cadaa7ff-dc17-4898-b781-35f92d2583e6", + "metadata": {}, + "source": [ + "(measure-tutorial)=\n", + "\n", + "# Defining Adaptation Measures with python functions" + ] + }, + { + "cell_type": "markdown", + "id": "c9170963-353e-4332-a8be-74ffbe78aa57", + "metadata": {}, + "source": [ + "The `Measure` object is the core component of the **Adaptation** module in CLIMADA. It acts as a wrapper for transformation logic, allowing you to model how specific interventions alter the risk landscape (like building sea walls, retrofitting houses, or implementing early warning systems).\n", + "\n", + "The primary purpose of a `Measure` is to modify one or more parts of the \"Risk Triplet\": **Exposures**, **Impact Functions**, and **Hazard**." + ] + }, + { + "cell_type": "markdown", + "id": "f8f9dc2c-81dd-409d-ab02-9be8b8a052c4", + "metadata": {}, + "source": [ + "## Quickstart" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "0685d8fb-68b6-4a65-a0b4-860e68a46c7d", + "metadata": {}, + "outputs": [], + "source": [ + "from climada.entity.measures.measure import Measure\n", + "from climada.entity.measures.cost_income import CostIncome\n", + "\n", + "\n", + "# Define one or more transformation function\n", + "# It must take an Exposures, Hazard or ImpactFuncSEt as the first argument\n", + "# and return an object of the same type.\n", + "def reduce_exposure_value(exposures, reduction_factor=0.2):\n", + " \"\"\"Reduces the value of all assets by a fixed percentage.\"\"\"\n", + " exposures.gdf[\"value\"] *= 1 - reduction_factor\n", + " return exposures\n", + "\n", + "\n", + "def sea_wall_protection(hazard, threshold=2.0):\n", + " \"\"\"Cuts off flood intensity below a certain threshold.\"\"\"\n", + " # intensity is typically a sparse matrix in CLIMADA hazards\n", + " hazard.intensity.data[hazard.intensity.data < threshold] = 0\n", + " return hazard\n", + "\n", + "\n", + "# Define financial aspects\n", + "cost_income = CostIncome(init_cost=1_000_000)\n", + "\n", + "# Initialize the Measure object\n", + "retrofitting_and_seawall = Measure(\n", + " name=\"Building Retrofit and seawall construction\",\n", + " exposures_changes=reduce_exposure_value,\n", + " hazard_changes=sea_wall_protection,\n", + " cost_income=cost_income,\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "66e0629f-da41-42e9-b3d5-02458c88d693", + "metadata": {}, + "source": [ + "The measure can then be used to create a new triplet corresponding to the modifications or to compute the impact directly:\n", + "\n", + "```python\n", + "new_exp, new_impf, new_haz = retrofitting.apply(exp, impf, haz, kwargs_hazard={'threshold': 3.5})\n", + "impact_with_measure = measure.calc_impact(exp, impf, haz)\n", + "\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "56bbbcd2-f92f-4697-8631-18b9a311d4da", + "metadata": {}, + "source": [ + "## Core logic of the Measure object\n", + "\n", + "When you initialize a `Measure`, you can provide one to three callables (python functions):\n", + "\n", + "1. **`exposures_changes`**: Modifies the `Exposures` object, the asset location, value, or metadata (e.g., relocating houses from a flood zone).\n", + "2. **`impfset_changes`**: Modifies the `ImpactFuncSet` object, the vulnerability of assets (e.g., updating an impact function because houses were elevated).\n", + "3. **`hazard_changes`**: Modifies the `Hazard` object, the intensity or frequency of events (e.g., a dam reducing flood depths).\n", + "\n", + "```{note}\n", + "By default, any component not explicitly defined uses the `identity_function`, which simply returns the input object without modification.\n", + "```\n", + "\n", + "The **only** requirement for these python functions is to **take** and **return** an `Exposures` object (or `ImpactFuncSet` or `Hazard`), which enable advanced modeling.\n", + "\n", + "Notably, the `apply()` method always passes the entire triplet (`base_exposures`, `base_impfset`, `base_hazard`) to every transformation function, so you can write complex logic.\n", + "\n", + "For example:\n", + "> \"Only reduce the exposure value (Exposure change) in areas where the peak water depth (Hazard context) exceeds 2 meters.\"\n", + "\n", + "Could be defined like this:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "63b37e27-f4d1-4a0c-8a45-f923aea903e2", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "\n", + "def reduce_exposure_by_depth(exposures, reduction_factor=0.2, threshold=2.0, **kwargs):\n", + " \"\"\"\n", + " Reduces asset value by a percentage, but only for assets located where\n", + " the peak hazard intensity (e.g., water depth) exceeds the threshold.\n", + " \"\"\"\n", + " # Retrieve the hazard context passed by Measure.apply\n", + " base_hazard = kwargs.get(\"base_hazard\")\n", + "\n", + " # Get the peak intensity for each centroid across all events\n", + " peak_depths = np.array(base_hazard.intensity.max(axis=0).todense()).flatten()\n", + "\n", + " # Ensure exposures are mapped to hazard centroids\n", + " if \"centr_ID\" not in exposures.gdf.columns:\n", + " exposures.assign_centroids(base_hazard)\n", + "\n", + " # Identify which exposure points meet the depth criteria\n", + " # 'centr_ID' maps each exposure row to a column index in\n", + " # the hazard intensity matrix\n", + " centr_indices = exposures.gdf[\"centr_ID\"].values\n", + " point_peak_depths = peak_depths[centr_indices]\n", + "\n", + " # We apply the reduction only where Depth > threshold\n", + " mask = point_peak_depths > threshold\n", + " exposures.gdf.loc[mask, \"value\"] *= 1 - reduction_factor\n", + "\n", + " return exposures" + ] + }, + { + "cell_type": "markdown", + "id": "d069e22e-1c31-44ef-a3db-62d3269f3900", + "metadata": {}, + "source": [ + "```python\n", + "# --- Usage Example ---\n", + "# Define the measure\n", + "flood_protection = Measure(\n", + " name=\"High-Threshold Value Protection\",\n", + " exposures_changes=reduce_exposure_by_depth\n", + ")\n", + "\n", + "# When you call apply, the `Hazard` haz is automatically passed to the function\n", + "# as 'base_hazard'\n", + "new_exp, _, _ = flood_protection.apply(\n", + " exp, impf, haz, \n", + " kwargs_exposures={'reduction_factor': 0.5, 'threshold': 2.0}\n", + ")\n", + "\n", + "# You can also overide this with another \"base\" hazard in the \n", + "# `kwarg_exposures` if you want:\n", + "new_exp, _, _ = flood_protection.apply(\n", + " exp, impf, haz, \n", + " kwargs_exposures={'base_hazard'= other_hazard,\n", + " 'reduction_factor': 0.5, 'threshold': 2.0}\n", + ")\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "ebf8620a-181d-4f3c-989f-e4373380032b", + "metadata": {}, + "source": [ + "```{note}\n", + "The functions you define yourself are automatically made to accept keyword arguments if they do not already.\n", + "```\n", + "\n", + "```{note}\n", + "The functions do not necessarily need to use the Exposures|Hazard|ImpactFuncSet object, but they still have to accept it as an argument.\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "fb888e10-5a94-4251-88be-5d92dfee2e0a", + "metadata": {}, + "source": [ + "### Deep copies\n", + "\n", + "To prevent accidental \"in-place\" modification of your baseline data, `Measure` utilizes `copy.deepcopy()`. \n", + "If `enforce_copy=True` in `apply()` (the default case), the object is cloned before the transformation function runs, ensuring the original objects remains untouched." + ] + }, + { + "cell_type": "markdown", + "id": "80c13c5a-0048-4b80-bd35-9faffae52cae", + "metadata": {}, + "source": [ + "### Measure cash flow (`CostIncome`)\n", + "\n", + "The `cost_income` attribute allows the measure to carry its own. It can notably store:\n", + "\n", + "* Initial investment costs.\n", + "* Maintenance costs over time.\n", + "* Potential indirect income generated by the measure.\n", + "\n", + "For more information and advanced usage see the [detailed tutorial on cost income object](cost-income-tutorial)." + ] + }, + { + "cell_type": "markdown", + "id": "26b926d2-1f27-416d-925c-53bfaa0cee27", + "metadata": {}, + "source": [ + "## Defining Measure using measure configuration" + ] + }, + { + "cell_type": "markdown", + "id": "99bb6869-30f0-49b5-9c56-8664fd85318a", + "metadata": {}, + "source": [ + "Defining adaptation measures with python functions can be a bit \\" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "01f29057-fc12-4787-92be-e4c506a054d1", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:climada_env_dev]", + "language": "python", + "name": "conda-env-climada_env_dev-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From a9e9c5fbf131a0de74aa43abfe9110b71efce830 Mon Sep 17 00:00:00 2001 From: Samuel Juhel <10011382+spjuhel@users.noreply.github.com> Date: Wed, 14 Oct 2026 17:30:12 +0200 Subject: [PATCH 32/44] Apply batched suggestions from code review Co-authored-by: Samuel Juhel <10011382+spjuhel@users.noreply.github.com> --- climada/entity/measures/measure.py | 30 ++++++++++++++++++------------ 1 file changed, 18 insertions(+), 12 deletions(-) diff --git a/climada/entity/measures/measure.py b/climada/entity/measures/measure.py index 156443360c..b565d6d293 100755 --- a/climada/entity/measures/measure.py +++ b/climada/entity/measures/measure.py @@ -125,9 +125,10 @@ class Measure: Contains a measure to be applied to a set of exposures, impact functions, and hazard. - A ``Measure`` represents a single adaptation or risk-reduction action. It - holds three (optional) transformation functions, one each for - :class:`Exposures`, :class:`ImpactFuncSet`, and :class:`Hazard`, that are + A ``Measure`` represents an adaptation or risk-reduction action + (or a bundle of actions considered as one). It holds three (optional) + transformation functions, one each for :class:`Exposures`, + :class:`ImpactFuncSet`, and :class:`Hazard`, that are can be applied to a triplet of ``(Exposures, ImpactFuncSet, Hazard)``, to reflect the effect of the measure. @@ -235,7 +236,7 @@ def apply_exposures_changes( This method applies the `exposures_changes` function of the measure to the provided :class:`Exposures` object. If ``enforce_copy`` is True (default), a deep copy of the exposures is created before modification to ensure - immutability of the original object. + preservation of the original object. Additional keyword arguments to the function can be passed directly. @@ -458,11 +459,13 @@ def apply( Notes ----- - The kwargs merging follows this priority order: - - 1. Default context: The original triplet (exposures, impfset, hazard) - 2. Entity-specific overrides: Values from ``kwargs_exposures``, - ``kwargs_impfset``, or ``kwargs_hazard`` respectively + Keyword arguments other than "kwargs_exposures", "kwargs_impfset", + "kwargs_hazard" are ignored. + + The base exposure, hazard, and impfset provided by default can + be overriden by explicitely providing a different value within + ``kwargs_exposures``, ``kwargs_impfset``, or ``kwargs_hazard`` + respectively. This ensures that each transformation receives full context about all entities while allowing fine-grained control over individual transformations. @@ -493,12 +496,12 @@ def apply( return changed_exposures, changed_impfset, changed_hazard def calc_impact( - self, exposures: Exposures, impfset: ImpactFuncSet, hazard: Hazard + self, exposures: Exposures, impfset: ImpactFuncSet, hazard: Hazard, **kwargs: dict, ) -> Impact: """Compute impact with the active measure. This convenience method allow to compute an ``Impact`` object from an - (Exposure, ImpactFuncSet, Hazard) triplet by first applying the measure + (Exposure, ImpactFuncSet, Hazard) triplet after having applied the measure to that triplet. Parameters @@ -509,6 +512,9 @@ def calc_impact( The initial (no adaptation) impact function set hazard : Hazard The initial (no adaptation) hazard set + kwargs: dict + Keyword arguments passed to the `impact()` method of `ImpactCalc` + (Currently `save_mat` and `assign_centroids`) Returns ------- @@ -530,6 +536,6 @@ def calc_impact( ) new_exp.assign_centroids(new_haz) imp = ImpactCalc(new_exp, new_impfs, new_haz).impact( - save_mat=False, assign_centroids=False + save_mat=kwargs.get("save_mat",False), assign_centroids=kwargs.get("assign_centroids",False) ) return imp # .calc_risk_transfer(0, 0) From 0f25f9663cab95b9c19fe3f4f394c6c0acdd210c Mon Sep 17 00:00:00 2001 From: spjuhel Date: Wed, 14 Oct 2026 17:32:01 +0200 Subject: [PATCH 33/44] Squashed commit of the following: MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit commit 45f888594c198a5995f7a2638768fbfc380310cf Merge: 6ba1f6f6 720b31d5 Author: spjuhel Date: Wed Oct 14 17:14:18 2026 +0200 Merge branch 'feature/option-appraisal-costincome' of github.com:CLIMADA-project/climada_python into feature/option-appraisal-costincome commit 6ba1f6f65892bfa74b642334a25a5c2ea0f44569 Author: spjuhel Date: Wed Oct 14 17:13:25 2026 +0200 fixes tests commit d2d891f38fe8621b4830f3545e3e68464aeb350f Author: spjuhel Date: Wed Oct 14 17:10:24 2026 +0200 other minor fixes commit bf7fb2eb6bc40d6733348bc5f7662830e5871820 Author: spjuhel Date: Wed Oct 14 16:50:52 2026 +0200 Fixes some linter issues, removes datetime commit b5da6bf8a563d7be2d768bdb3431807da6514b66 Author: spjuhel Date: Wed Oct 14 16:13:40 2026 +0200 Tuple -> tuple commit 720b31d54b0ee462277ca3ce87b0a3563a7098b4 Merge: d5778d92 c0fcc8da Author: emanuel-schmid Date: Wed Sep 23 17:57:36 2026 +0200 Merge branch 'develop' into feature/option-appraisal-costincome commit c0fcc8dacbdade2d83851db6ce0158c9524dfa96 Author: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> Date: Tue Sep 22 16:13:26 2026 +0200 Fix exposure coordinate extraction for `CalcDeltaImpact` (#1304) * Use final exposure for centroid coords * Fix querying exposure coords in CalcDeltaImpact --------- Co-authored-by: emanuel-schmid commit b158053e8929ce52bfd13027b1fc20d9e2bedf4b Author: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> Date: Tue Sep 15 16:49:20 2026 +0200 Trigger pipeline for pull requests (#1318) * Trigger pipeline for pull requests and pushes to main, develop, releases. * Add info on approving workflow runs to CONTRIBUTING.md commit dea46facc7856ed1c26adc1ee03e954c77d30c1b Author: emanuel-schmid Date: Fri Sep 4 11:03:56 2026 +0200 pin rasterio to 1.4 commit 4f4a1bd007d92bbafdde09e5dc6b5a391bd6b50e Author: emanuel-schmid Date: Thu Sep 3 19:33:41 2026 +0200 remove noaa nightlight test commit 697e8d610db891e71eced35f3f400546ef33187d Author: EnvDroneSense Date: Wed Sep 2 14:56:20 2026 +0200 Compute forecast quantiles block-wise to bound memory (#1313) Add `sparse_quantile_axis0` to densify sparse matrices blockwise before computing the column quantiles. --------- Co-authored-by: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> commit 9efa3862f36fb391ba181190b2764a6fce0941c5 Author: emanuel-schmid Date: Fri Aug 28 17:42:20 2026 +0200 fix damage commit 05481fdbb0682ba9054b4d035b6b00ef4fb1d57a Author: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> Date: Fri Aug 28 16:27:33 2026 +0200 Upgrade GitHub Actions and Python versions (#1281) * Upgrade actions and Python versions Python 3.11 to 3.13. * Upgrade Python version in pyproject.toml * docs: Update supported versions * pin pandas --------- Co-authored-by: emanuel-schmid commit 6b921e3fff4f07d0ef0db55485f3352bd073a1c3 Merge: 6c7e3c8d bd6b09a7 Author: emanuel-schmid Date: Fri Aug 28 13:40:30 2026 +0200 Merge branch 'develop' of github.com:CLIMADA-project/climada_python into develop commit bd6b09a765b90d358de918cb623861c0a251d3cf Author: ankurmahiwal118028 Date: Fri Aug 28 17:08:07 2026 +0530 Fix #814: raise clear error for empty Hazard in ImpactCalc.impact (#1290) * Raise clear error for empty Hazard in ImpactCalc.impact Computing impact with a Hazard containing zero events previously crashed deep inside ``np.array_split`` with the obscure message "number sections must be larger than 0". This adds an early guard in ``ImpactCalc.impact`` that raises a ``ValueError`` with a clear explanation when ``self.hazard.size == 0``. Closes #814 * Update climada/engine/test/test_impact_calc.py Co-authored-by: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> --------- Co-authored-by: Samuel Juhel <10011382+spjuhel@users.noreply.github.com> Co-authored-by: Emanuel Schmid <51439563+emanuel-schmid@users.noreply.github.com> Co-authored-by: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> commit 6c7e3c8df9faa98a8bead73dc49cd3246ae14ebf Merge: 54d100c8 ca00465c Author: emanuel-schmid Date: Fri Aug 28 13:33:06 2026 +0200 Merge branch 'develop' of github.com:CLIMADA-project/climada_python into develop commit ca00465c961b87f570b788d7a22bfa4e4fa9dd72 Author: Emanuel Schmid <51439563+emanuel-schmid@users.noreply.github.com> Date: Fri Aug 28 13:32:17 2026 +0200 fix future warning: H is deprecated (#1307) * use h (H is deprecated) * add comment to affine pin commit a694663a5aff5523c184523d890e9b4165f35c1b Author: Emanuel Schmid <51439563+emanuel-schmid@users.noreply.github.com> Date: Fri Aug 28 13:31:06 2026 +0200 fix fiona deprecation warning (#1308) * remove obsolete DEF_CRS_FIONA * add comment to affine pin commit 54d100c8f1ae0ffe9068fef018c003faf7b3f3f9 Merge: 5b03edb6 d2af3137 Author: emanuel-schmid Date: Fri Aug 28 13:05:56 2026 +0200 Merge branch 'develop' of github.com:CLIMADA-project/climada_python into develop commit d2af3137895e48f6d47f437ad4e8322c5ddc59df Author: Giovanni Cozzolongo <79092266+giovannicozzolongo@users.noreply.github.com> Date: Thu Aug 20 11:24:41 2026 +0200 Read forecast dates from xarray (#1310) Preserve explicitly mapped date variables in HazardForecast.from_xarray_raster. commit 5b03edb6e5f4e29984ab84910131213751047570 Author: emanuel-schmid Date: Wed Aug 19 11:02:31 2026 +0200 add comment to affine pin commit 80a29750eae7b1f5befac41f3988469e3e917c2f Author: emanuel-schmid Date: Wed Aug 19 10:36:03 2026 +0200 dependencies: pin affine to 2.4 commit 8100a31e5eeceb2ec8c11742672546df0520029e Author: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> Date: Wed Jul 15 12:18:41 2026 +0200 Use Zenodo for downloading distance to coastline dataset (#1301) commit cf0aa86f9431cc8dd76bba24040ddea17caf0316 Author: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> Date: Mon Jul 13 16:22:25 2026 +0200 Handle 0-dim arrays being passed to ordinal converter (#1300) commit 222a6e580e2e1051d4e0aaf6a625f19b834eac49 Author: emanuel-schmid Date: Fri Jun 19 16:11:18 2026 +0200 pin matplotlib to 3.10 commit 5d0a9851b69b909a13a953621b44266bc4322bcb Author: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> Date: Wed Jun 17 11:23:05 2026 +0200 Update installation guide (#1296) * Fix formatting errors. * Move switching branches to FAQ. * Fix some links. commit d5778d929ed910ef560cf674d472bf0cc35074bd Merge: a56dcc6d 7094124d Author: spjuhel Date: Wed Jun 10 15:13:21 2026 +0200 Merge remote-tracking branch 'origin/develop' into feature/option-appraisal-costincome commit 7094124dd21cdcea330a45a99b4268d7011dd4f8 Author: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> Date: Wed Jun 10 11:55:53 2026 +0200 Fix README links and update structure (#1101) * Fix README links and structure * Improve petals description --------- Co-authored-by: emanuel-schmid Co-authored-by: Chahan M. Kropf Co-authored-by: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> commit a1e7107092a06eead3be2b27a329d45e9387bcd2 Author: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> Date: Wed Jun 10 11:31:14 2026 +0200 Add forecast classes (#1115) * Add HazardForecast and ImpactForecast classes. * Add tests. * Add new forecast tutorial. --------- Co-authored-by: Evelyn Mühlhofer <42063186+Evelyn-M@users.noreply.github.com> Co-authored-by: Luca Severino <91593121+luseverin@users.noreply.github.com> Co-authored-by: Valentin Gebhart <60438839+ValentinGebhart@users.noreply.github.com> Co-authored-by: Chahan M. Kropf Co-authored-by: Chahan Kropf Co-authored-by: elianekobler <138141646+elianekobler@users.noreply.github.com> commit a56dcc6da8e9004264e5a1389a8021dcc02730c5 Author: spjuhel Date: Wed Jun 10 09:50:52 2026 +0200 removes tests for removed method commit 7e30183f58e25efeb456789286ce4104bc68ebff Merge: dd9c738d a99b10b8 Author: spjuhel Date: Wed Jun 10 09:36:03 2026 +0200 Merge remote-tracking branch 'origin/develop' into feature/option-appraisal-costincome commit a99b10b8551e99b6bc43e5333c3a7a26f47a290e Merge: 805e2da6 aae360f8 Author: Samuel Juhel <10011382+spjuhel@users.noreply.github.com> Date: Wed Jun 10 09:33:31 2026 +0200 MeasureConfig dataclasses [Option Appraisal Module] [Package 1: Measures] Split 1: Adds `MeasureConfig` dataclasses for serializable measure configuration. commit aae360f8243ce1fa61e1ea90013b768b3aa3d894 Merge: 92990e46 a423c783 Author: spjuhel Date: Wed Jun 10 09:12:00 2026 +0200 Merge remote-tracking branch 'origin/develop' into feature/option-appraisal-dataclasses commit 805e2da6f44b55d9e9fca049c4b1fea22d87a5a9 Author: Emanuel Schmid <51439563+emanuel-schmid@users.noreply.github.com> Date: Mon Jun 8 16:08:27 2026 +0200 Docs/pixi installation (#1295) * first draft * improvments * notice about windows * make installation instructions more concise, add comments * layout corrections * improve section order commit dd9c738de40151e84c34b3bc442001d1df513c9a Author: spjuhel Date: Fri May 29 11:59:34 2026 +0200 Adds test for custom cost incomes and cash flow computation commit f19198072e45c7d79a34b289a33d6297e9937728 Merge: d09d18f7 a423c783 Author: spjuhel Date: Fri May 29 10:11:15 2026 +0200 Merge remote-tracking branch 'origin/develop' into feature/option-appraisal-costincome commit 92990e4647cd2f61c2623ec06f0acfe07054d209 Merge: 8a4d13b7 5ae3f7fb Author: spjuhel Date: Fri May 29 10:10:34 2026 +0200 Merge remote-tracking branch 'origin/develop' into feature/option-appraisal-dataclasses commit 8a4d13b77e930fe460854556e2c4248a6e978ee9 Author: spjuhel Date: Fri May 29 10:10:06 2026 +0200 updates notebook outputs commit 6ef99a27819cbfaf17e5dabac0c6e8ef01dcd296 Author: spjuhel Date: Fri May 29 10:09:14 2026 +0200 Updates custom cash flow values commit d09d18f7d64c1e487b9c4969ed736091e0a2da22 Author: spjuhel Date: Fri May 29 10:01:30 2026 +0200 Removes method not in use commit 31656528c8e673d271fb6807fd3edf1686e9f0f9 Author: spjuhel Date: Fri May 29 09:57:37 2026 +0200 Removes double checks commit dc29f9b393ba519b3651cf727199a1a17ab8ca9e Author: spjuhel Date: Thu May 28 16:55:16 2026 +0200 Implement somes comments from Vale commit ee1e854aca0c202a2a3fab1bacfd35c0f5642bf8 Author: spjuhel Date: Thu May 28 16:06:58 2026 +0200 idem commit 1264c8e50ede2ffc1c1a0ee77d1f1da6a0e94b01 Author: spjuhel Date: Thu May 28 15:59:51 2026 +0200 Implements comments from Vale commit 991562da6ff860cf93c99ff78739f3fbfa2e5c59 Author: Valentin Gebhart Date: Fri May 22 08:15:13 2026 +0200 some typos and rephrasing commit 3e8c51aa6eb33f7947adbe1b7dff05ddcef32b24 Merge: 044b7f47 3133447a Author: spjuhel Date: Wed May 13 14:47:26 2026 +0200 Merge remote-tracking branch 'origin/develop' into feature/option-appraisal-costincome commit 044b7f479a6a17479949bb5a3ec654ff19133435 Merge: 2ee944b3 2b19cf89 Author: spjuhel Date: Wed May 13 14:43:27 2026 +0200 Merge branch 'develop' into feature/option-appraisal-costincome commit 7803112c086456585926a2b9436a749365284fa1 Merge: 0423a6f6 3133447a Author: spjuhel Date: Wed May 13 14:27:52 2026 +0200 Merge remote-tracking branch 'origin/develop' into feature/option-appraisal-dataclasses --- .github/workflows/ci.yml | 22 +- AUTHORS.md | 2 + CHANGELOG.md | 10 +- CONTRIBUTING.md | 5 + README.md | 31 +- climada/conf/climada.conf | 2 +- climada/engine/__init__.py | 1 + climada/engine/impact.py | 52 +- climada/engine/impact_calc.py | 58 +- climada/engine/impact_forecast.py | 507 +++++ climada/engine/test/test_impact.py | 40 +- climada/engine/test/test_impact_calc.py | 175 +- climada/engine/test/test_impact_forecast.py | 490 +++++ climada/engine/unsequa/calc_delta_climate.py | 6 +- climada/entity/measures/cost_income.py | 107 +- climada/entity/measures/measure_config.py | 5 +- .../entity/measures/test/test_cost_income.py | 81 +- climada/hazard/forecast.py | 544 +++++ climada/hazard/io.py | 10 +- climada/hazard/test/test_base.py | 42 +- climada/hazard/test/test_forecast.py | 636 ++++++ climada/hazard/test/test_tc_tracks.py | 2 +- climada/hazard/xarray.py | 28 +- climada/util/constants.py | 8 - climada/util/forecast.py | 254 +++ climada/util/test/test_forecast.py | 197 ++ doc/api/climada/climada.engine.rst | 8 + doc/api/climada/climada.hazard.rst | 8 + doc/api/climada/climada.util.rst | 8 + .../Guide_CLIMADA_Development.ipynb | 2 + doc/getting-started/install.rst | 120 +- doc/user-guide/climada_engine_Forecast.ipynb | 7 + .../climada_engine_ImpactForecast.ipynb | 1790 +++++++++++++++++ doc/user-guide/climada_measure_config.ipynb | 67 +- doc/user-guide/index.rst | 3 +- pyproject.toml | 2 +- requirements/env_climada.yml | 13 +- script/jenkins/test_data_api.py | 7 - 38 files changed, 5063 insertions(+), 287 deletions(-) create mode 100644 climada/engine/impact_forecast.py create mode 100644 climada/engine/test/test_impact_forecast.py create mode 100644 climada/hazard/forecast.py create mode 100644 climada/hazard/test/test_forecast.py create mode 100644 climada/util/forecast.py create mode 100644 climada/util/test/test_forecast.py create mode 100644 doc/user-guide/climada_engine_ImpactForecast.ipynb diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 59988c5327..cf6767dc34 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -1,7 +1,17 @@ name: GitHub CI -# Execute this for every push -on: [push] +# When to execute +on: + push: + # Pushes to important branches + branches: + - develop + - main + # Release tags + tags: + - v* + # Any pull request + pull_request: # Use bash explicitly for being able to enter the conda environment defaults: @@ -22,12 +32,12 @@ jobs: # Do not abort other tests if only a single one fails fail-fast: false matrix: - python-version: ["3.10", "3.11", "3.12"] + python-version: ["3.11", "3.12", "3.13"] steps: - name: Checkout Repo - uses: actions/checkout@v4 + uses: actions/checkout@v6 - # Store the current date to use it as cache key for the environment name: Get current date @@ -35,7 +45,7 @@ jobs: run: echo "date=$(date +%Y-%m-%d)" >> "${GITHUB_OUTPUT}" - name: Create Environment with Mamba - uses: mamba-org/setup-micromamba@v1 + uses: mamba-org/setup-micromamba@v3 with: environment-name: climada_env_${{ matrix.python-version }} environment-file: requirements/env_climada.yml @@ -63,7 +73,7 @@ jobs: - name: Upload Coverage Reports if: always() - uses: actions/upload-artifact@v4 + uses: actions/upload-artifact@v7 with: name: coverage-report-core-unittests-py${{ matrix.python-version }} path: coverage/ diff --git a/AUTHORS.md b/AUTHORS.md index 20abd4b0ec..49ecd1e246 100644 --- a/AUTHORS.md +++ b/AUTHORS.md @@ -37,3 +37,5 @@ * Samuel Juhel * Valentin Gebhart * Dahyann Araya +* Giovanni Cozzolongo +* Thomas Struys diff --git a/CHANGELOG.md b/CHANGELOG.md index ecbebda77c..5207f33a14 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,20 +12,28 @@ Code freeze date: YYYY-MM-DD ### Added -- Better type hints and overloads signatures for `ImpactFuncSet` [#1250](https://github.com/CLIMADA-project/climada_python/pull/1250) +- Support for ensemble forecast data as hazard via `HazardForecast` and `ImpactForecast`, see `doc.user_guide.climada_engine_ImpactForecast.ipynb` [#1115](https://github.com/CLIMADA-project/climada_python/pull/) +- Better type hints and overloads signatures for ImpactFuncSet [#1250](https://github.com/CLIMADA-project/climada_python/pull/1250) +- Adds `MeasureConfig` and related dataclasses for new `Measure` object retrocompatibility and (de)serialization capabilities [#1276](https://github.com/CLIMADA-project/climada_python/pull/1276) +- Adds `CostIncome` class and related tutorial for future new `Measure` class. [#1277](https://github.com/CLIMADA-project/climada_python/pull/1277) +- Better type hints and overloads signatures for ImpactFuncSet [#1250](https://github.com/CLIMADA-project/climada_python/pull/1250) - Add inter- and extrapolation options to `ImpactFreqCurve` with method `interpolate` [#1252](https://github.com/CLIMADA-project/climada_python/pull/1252) - Adds `MeasureConfig` and related dataclasses for new `Measure` object retrocompatibility and (de)serialization capabilities [#1276](https://github.com/CLIMADA-project/climada_python/pull/1276) - Adds new `Measure` class, implementing adaptation measures as closures. - Add `trajectory` module to ease the handling of multiple risk assessment at different point in time, and enable interpolation in between. [#1197](https://github.com/CLIMADA-project/climada_python/pull/1197), [#1198](https://github.com/CLIMADA-project/climada_python/pull/1198), [#1199](https://github.com/CLIMADA-project/climada_python/pull/1199), [#1200](https://github.com/CLIMADA-project/climada_python/pull/1197), [#1201](https://github.com/CLIMADA-project/climada_python/pull/1197) ### Changed + - Updated Impact Calculation Tutorial (`doc.climada_engine_Impact.ipynb`) [#1095](https://github.com/CLIMADA-project/climada_python/pull/1095). - Makes current `measure` module a legacy module, moving it to `_legacy_measure`, to retain compatibility with `CostBenefit` class and various tests. [#1274](https://github.com/CLIMADA-project/climada_python/pull/1274) +- `HazardForecast.quantile` and `ImpactForecast.quantile` compute quantiles block-wise instead of densifying the entire sparse matrix, greatly reducing peak memory. Results are unchanged. [#1203](https://github.com/CLIMADA-project/climada_python/issues/1203) ### Fixed +- Preserve explicitly mapped dates in `HazardForecast.from_xarray_raster` [#1305](https://github.com/CLIMADA-project/climada_python/issues/1305). - Fixed asset count in impact logging message [#1195](https://github.com/CLIMADA-project/climada_python/pull/1195). - `Hazard.from_raster_xarray` now returns a sparse matrix instead of a sparse array [#1261](https://github.com/CLIMADA-project/climada_python/pull/1261). +- `ImpactCalc.impact` now raises a clear `ValueError` when the supplied `Hazard` contains no events, instead of failing later inside `np.array_split` with an obscure message [#814](https://github.com/CLIMADA-project/climada_python/issues/814). - Fix TCTracks.from_FAST duplicate loading from year loop [#1269](github.com/CLIMADA-project/climada_python/pull/1269) ### Deprecated diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 2ee11385ff..f9fb23d755 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -61,6 +61,11 @@ To contribute follow these steps: This also works if you pushed to a fork instead of the main repository. Add a description and explanation of your changes and work through the pull request author checklist provided. Feel free to request reviews from specific team members. + + **NOTE:** If a pull request originates from a fork, a team member (usually the reviewer) will have to [approve workflow runs](https://docs.github.com/en/actions/how-tos/manage-workflow-runs/approve-runs-from-forks). + Before doing so, please carefully check the suggested changes for potentially harmful code. + If unsure, ask the core developers. + 9. After approval of the pull request, the branch is merged into `develop` and your changes will become part of the next CLIMADA release. ## Resources diff --git a/README.md b/README.md index 6c09a6f679..0de05dd9a4 100644 --- a/README.md +++ b/README.md @@ -8,17 +8,20 @@ option appraisal. Designed by a large scientific community, it helps reasearchers, policymakers, and businesses analyse the impacts of natural hazards and explore adaptation strategies. -As of today, CLIMADA provides global coverage of major climate-related extreme-weather hazards at high resolution (4x4km) via a [data API](https://climada.ethz.ch/data-api/v1/docs) For select hazards, historic and probabilistic events sets, for past, present and future climate exist at distinct time horizons. -You will find a repository containing scientific peer-reviewed articles that explain software components implemented in CLIMADA [here](https://github.com/CLIMADA-project/climada_papers). +## Overview CLIMADA is divided into two parts (two repositories): -1. the core [climada_python](https://github.com/CLIMADA-project/climada_python) contains all the modules necessary for the probabilistic impact, the averted damage, uncertainty and forecast calculations. Data for hazard, exposures and impact functions can be obtained from the [data API](https://github.com/CLIMADA-project/climada_python/blob/main/doc/tutorial/climada_util_api_client.ipynb). [Litpop](https://github.com/CLIMADA-project/climada_python/blob/main/doc/tutorial/climada_entity_LitPop.ipynb) is included as demo Exposures module, and [Tropical cyclones](https://github.com/CLIMADA-project/climada_python/blob/main/doc/tutorial/climada_hazard_TropCyclone.ipynb) is included as a demo Hazard module. -2. the petals [climada_petals](https://github.com/CLIMADA-project/climada_petals) contains all the modules for generating data (e.g., TC_Surge, WildFire, OpenStreeMap, ...). Most development is done here. The petals builds-upon the core and does not work as a stand-alone. +1. [Core (`climada_python`)](https://github.com/CLIMADA-project/climada_python) contains all modules necessary for computing probabilistic impact and averted damage, performing uncertainty and sensitivity analysis, and calibrating impact functions. Demonstration data for hazard, exposures and impact functions can be obtained from the [data API](https://github.com/CLIMADA-project/climada_python/blob/main/doc/user-guide/climada_util_api_client.ipynb). [Litpop](https://github.com/CLIMADA-project/climada_python/blob/main/doc/user-guide/climada_entity_LitPop.ipynb) is included as demo Exposures module, and [Tropical cyclones](https://github.com/CLIMADA-project/climada_python/blob/main/doc/user-guide/climada_hazard_TropCyclone.ipynb) is included as a demo Hazard module. +2. [Petals (`climada_petals`)](https://github.com/CLIMADA-project/climada_petals) contains all the modules for generating data (e.g., TC_Surge, WildFire, OpenStreeMap, ...) and advanced applications (e.g., CatBond simulation, Supply chain propagation, ...). Most development is done here. Petals is an extension of Core and does **not** work as a stand-alone module. -For new users, we recommend to begin with the core (1) and the [tutorials](https://github.com/CLIMADA-project/climada_python/tree/main/doc/tutorial) therein. +For new users, we recommend to begin with Core (1) and the [tutorials](https://github.com/CLIMADA-project/climada_python/tree/main/doc/user-guide) therein. -This is the Python version of CLIMADA - please see [here](https://github.com/davidnbresch/climada) for backward compatibility with the MATLAB version. +A [publication repository](https://github.com/CLIMADA-project/climada_papers) contains case-study examples from scientific, peer-reviewed articles that further illustrate the use of CLIMADA. + +CLIMADA provides global coverage of major climate-related extreme-weather hazards at high resolution (4x4km) via a [data API](https://climada.ethz.ch/data-api/v1/docs) for select hazards, historic and probabilistic events sets, for past, present and future climate exist at distinct time horizons. + +This is the Python version of CLIMADA - For backward compatibility with the MATLAB version please see https://github.com/davidnbresch/climada. ## Getting started @@ -31,25 +34,25 @@ mamba install -c conda-forge climada ``` It is **highly recommended** to install CLIMADA into a **separate** Conda environment. -See the [installation guide](https://climada-python.readthedocs.io/en/latest/guide/install.html) for further information. +See the [installation guide](https://climada-python.readthedocs.io/en/latest/getting-started/install.html) for further information. -Follow the [tutorials](https://climada-python.readthedocs.io/en/stable/tutorial/1_main_climada.html) in a Jupyter Notebook to see what can be done with CLIMADA and how. +Follow the [tutorials](https://climada-python.readthedocs.io/en/stable/user-guide/1_main_climada.html) in a Jupyter Notebook to see what can be done with CLIMADA and how. ## Documentation -The online documentation is available on [Read the Docs](https://climada-python.readthedocs.io/en/stable/).The documentation of each release version of CLIMADA can be accessed separately through the drop-down menu at the bottom of the left sidebar. Additionally, the version 'stable' refers to the most recent release (installed via `conda`), and 'latest' refers to the latest unstable development version (the `develop` branch). +The online documentation is available on [Read the Docs](https://climada-python.readthedocs.io/en/stable/). The documentation of each release version of CLIMADA can be accessed separately through the drop-down menu at the bottom of the left sidebar. Additionally, the version 'stable' refers to the most recent release (installed via `conda`), and 'latest' refers to the latest unstable development version (the `develop` branch). -CLIMADA python: +CLIMADA Core (`climada_python`): - [online (recommended)](https://climada-python.readthedocs.io/en/latest/) - [PDF file](https://climada-python.readthedocs.io/_/downloads/en/stable/pdf/) -- [core Tutorials on GitHub](https://github.com/CLIMADA-project/climada_python/tree/main/doc/tutorial) +- [Core tutorials on GitHub](https://github.com/CLIMADA-project/climada_python/tree/main/doc/user-guide) -CLIMADA petals: +CLIMADA Petals (`climada_petals`): - [online (recommended)](https://climada-petals.readthedocs.io/en/latest/) - [PDF file](https://climada-petals.readthedocs.io/_/downloads/en/stable/pdf/) -- [petals Tutorials on GitHub](https://github.com/CLIMADA-project/climada_petals/tree/main/doc/tutorial) +- [Petals tutorials on GitHub](https://github.com/CLIMADA-project/climada_petals/tree/main/doc/tutorial) The documentation can also be [built locally](https://climada-python.readthedocs.io/en/latest/README.html). @@ -59,7 +62,7 @@ See the [Citation Guide](https://climada-python.readthedocs.io/en/latest/misc/ci Please use the following logo if you are presenting results obtained with or through CLIMADA: -![https://github.com/CLIMADA-project/climada_python/blob/main/doc/guide/img/CLIMADA_logo_QR.png](https://github.com/CLIMADA-project/climada_python/blob/main/doc/guide/img/CLIMADA_logo_QR.png?raw=true) +![https://github.com/CLIMADA-project/climada_python/blob/main/doc/guide/img/CLIMADA_logo_QR.png](https://github.com/CLIMADA-project/climada_python/blob/main/doc/development/img/CLIMADA_logo_QR.png?raw=true) ## Contributing diff --git a/climada/conf/climada.conf b/climada/conf/climada.conf index d0573ff7a6..e0e1da75f7 100644 --- a/climada/conf/climada.conf +++ b/climada/conf/climada.conf @@ -52,7 +52,7 @@ }, "util": { "coordinates": { - "dist_to_coast_nasa_url": "https://oceancolor.gsfc.nasa.gov/docs/distfromcoast/GMT_intermediate_coast_distance_01d.zip", + "dist_to_coast_nasa_url": "https://zenodo.org/records/21130975/files/GMT_intermediate_coast_distance_01d.zip?download=1", "dist_to_coast_nasa_tif": "GMT_intermediate_coast_distance_01d.tif" } }, diff --git a/climada/engine/__init__.py b/climada/engine/__init__.py index ef8292f75d..1970f7706b 100755 --- a/climada/engine/__init__.py +++ b/climada/engine/__init__.py @@ -22,3 +22,4 @@ from .cost_benefit import * from .impact import * from .impact_calc import * +from .impact_forecast import ImpactForecast diff --git a/climada/engine/impact.py b/climada/engine/impact.py index e8042afef3..a4755c42e7 100644 --- a/climada/engine/impact.py +++ b/climada/engine/impact.py @@ -188,8 +188,7 @@ def __init__( ) if len(self.coord_exp) != len(self.eai_exp): raise AttributeError( - "Number of exposures points is different from" - "number of eai_exp values" + "Number of exposures points is different fromnumber of eai_exp values" ) if imp_mat is not None: self.imp_mat = imp_mat @@ -1226,8 +1225,9 @@ def plot_rp_imp( impacts_stats_vals = impacts_stats.values[:, 1:].T.astype(float) if not log10_scale: - min_impact, max_impact = np.nanmin(impacts_stats_vals), np.nanmax( - impacts_stats_vals + min_impact, max_impact = ( + np.nanmin(impacts_stats_vals), + np.nanmax(impacts_stats_vals), ) kwargs.update( { @@ -1419,6 +1419,8 @@ def write_attribute(group, name, value): def write_dataset(group, name, value): """Write a dataset""" + if name == "lead_time": + value = value.astype("timedelta64[ns]").astype("int64") group.create_dataset(name, data=value, dtype=_str_type_helper(value)) def write_dict(group, name, value): @@ -1459,7 +1461,6 @@ def write_csr(group, name, value): # Open file in write mode with h5py.File(file_path, "w") as file: - # Now write all attributes # NOTE: Remove leading underscore to write '_tot_value' as regular attribute for name, value in self.__dict__.items(): @@ -1600,13 +1601,18 @@ def from_excel(cls, file_name): def read_excel(self, *args, **kwargs): """This function is deprecated, use Impact.from_excel instead.""" LOGGER.warning( - "The use of Impact.read_excel is deprecated." - "Use Impact.from_excel instead." + "The use of Impact.read_excel is deprecated.Use Impact.from_excel instead." ) self.__dict__ = Impact.from_excel(*args, **kwargs).__dict__ @classmethod - def from_hdf5(cls, file_path: Union[str, Path]): + def from_hdf5( + cls, + file_path: Union[str, Path], + *, + add_scalar_attrs: Iterable[str] | None = None, + add_array_attrs: Iterable[str] | None = None, + ): """Create an impact object from an H5 file. This assumes a specific layout of the file. If values are not found in the @@ -1651,6 +1657,10 @@ def from_hdf5(cls, file_path: Union[str, Path]): ---------- file_path : str or Path The file path of the file to read. + add_scalar_attrs : Iterable of str, optional + Additional scalar attributes to read from file. Defaults to None. + add_array_attrs : Iterable of str, optional + Additional array attributes to read from file. Defaults to None. Returns ------- @@ -1659,7 +1669,6 @@ def from_hdf5(cls, file_path: Union[str, Path]): """ kwargs = dict() with h5py.File(file_path, "r") as file: - # Impact matrix if "imp_mat" in file: impact_matrix = file["imp_mat"] @@ -1679,7 +1688,10 @@ def from_hdf5(cls, file_path: Union[str, Path]): # Scalar attributes scalar_attrs = set( ("crs", "tot_value", "unit", "aai_agg", "frequency_unit", "haz_type") - ).intersection(file.attrs.keys()) + ) + if add_scalar_attrs is not None: + scalar_attrs = scalar_attrs.union(add_scalar_attrs) + scalar_attrs = scalar_attrs.intersection(file.attrs.keys()) kwargs.update({attr: file.attrs[attr] for attr in scalar_attrs}) # Array attributes @@ -1687,9 +1699,16 @@ def from_hdf5(cls, file_path: Union[str, Path]): # invalidated once we close the file. array_attrs = set( ("event_id", "date", "coord_exp", "eai_exp", "at_event", "frequency") - ).intersection(file.keys()) + ) + if add_array_attrs is not None: + array_attrs = array_attrs.union(add_array_attrs) + array_attrs = array_attrs.intersection(file.keys()) kwargs.update({attr: file[attr][:] for attr in array_attrs}) - + # correct lead_time attribut to timedelta + if "lead_time" in kwargs: + kwargs["lead_time"] = np.array(file["lead_time"][:]).astype( + "timedelta64[ns]" + ) # Special handling for 'event_name' because it should be a list of strings if "event_name" in file: # pylint: disable=no-member @@ -2196,9 +2215,12 @@ def stack_attribute(attr_name: str) -> np.ndarray: imp_mat = sparse.vstack(imp_mats) # Concatenate other attributes - kwargs = { - attr: stack_attribute(attr) for attr in ("date", "frequency", "at_event") - } + concat_attrs = { + name.lstrip("_") # Private attributes with getter/setter + for name, value in first_imp.__dict__.items() + if isinstance(value, np.ndarray) + }.difference(("event_id", "coord_exp", "eai_exp", "aai_agg")) + kwargs = {attr: stack_attribute(attr) for attr in concat_attrs} # Get remaining attributes from first impact object in list return cls( diff --git a/climada/engine/impact_calc.py b/climada/engine/impact_calc.py index 0f35bc904b..1e274ce445 100644 --- a/climada/engine/impact_calc.py +++ b/climada/engine/impact_calc.py @@ -29,6 +29,8 @@ from climada import CONFIG from climada.engine.impact import Impact +from climada.engine.impact_forecast import ImpactForecast +from climada.hazard.forecast import HazardForecast LOGGER = logging.getLogger(__name__) @@ -136,6 +138,15 @@ def impact( climada.entity.exposures.assign_centroids : assign centroids to exposures explicitly """ # TODO: consider refactoring, making use of Exposures.hazard_impf + # check that the hazard contains at least one event; an empty hazard + # otherwise produces an obscure error from ``np.array_split`` deeper in + # the calculation (see GH #814). + if self.hazard.size == 0: + raise ValueError( + "Impact calculation not possible. The hazard object contains " + "no events. Please provide a Hazard with at least one event." + ) + # check for compatibility of exposures and hazard type if all( name not in self.exposures.gdf.columns @@ -217,7 +228,7 @@ def _return_impact(self, imp_mat_gen, save_mat): Returns ------- - Impact + Impact or ImpactForecast Impact Object initialize from the impact matrix See Also @@ -230,12 +241,31 @@ def _return_impact(self, imp_mat_gen, save_mat): at_event, eai_exp, aai_agg = self.risk_metrics( imp_mat, self.hazard.frequency ) + if isinstance(self.hazard, HazardForecast): + eai_exp = np.full_like(eai_exp, np.nan, dtype=eai_exp.dtype) + aai_agg = np.nan + LOGGER.warning( + "eai_exp and aai_agg are undefined with forecasts. " + "Setting them to NaN arrays." + ) + else: + if isinstance(self.hazard, HazardForecast): + raise ValueError( + "Saving impact matrix is required when using HazardForecast." + "Please set save_mat=True." + ) imp_mat = None at_event, eai_exp, aai_agg = self.stitch_risk_metrics(imp_mat_gen) - return Impact.from_eih( + + impact = Impact.from_eih( self.exposures, self.hazard, at_event, eai_exp, aai_agg, imp_mat ) + if isinstance(self.hazard, HazardForecast): + return ImpactForecast.from_impact( + impact, self.hazard.lead_time, self.hazard.member + ) + return impact def _return_empty(self, save_mat): """ @@ -248,21 +278,37 @@ def _return_empty(self, save_mat): Returns ------- - Impact + Impact or ImpactForecast Empty impact object with correct array sizes. """ at_event = np.zeros(self.n_events) - eai_exp = np.zeros(self.n_exp_pnt) - aai_agg = 0.0 + if isinstance(self.hazard, HazardForecast): + eai_exp = np.full(self.n_exp_pnt, np.nan) + aai_agg = np.nan + else: + eai_exp = np.zeros(self.n_exp_pnt) + aai_agg = 0.0 + if save_mat: imp_mat = sparse.csr_matrix( (self.n_events, self.n_exp_pnt), dtype=np.float64 ) else: + if isinstance(self.hazard, HazardForecast): + raise ValueError( + "Saving impact matrix is required when using HazardForecast. " + "Please set save_mat=True." + ) imp_mat = None - return Impact.from_eih( + + impact = Impact.from_eih( self.exposures, self.hazard, at_event, eai_exp, aai_agg, imp_mat ) + if isinstance(self.hazard, HazardForecast): + return ImpactForecast.from_impact( + impact, self.hazard.lead_time, self.hazard.member + ) + return impact def minimal_exp_gdf( self, impf_col, assign_centroids, ignore_cover, ignore_deductible diff --git a/climada/engine/impact_forecast.py b/climada/engine/impact_forecast.py new file mode 100644 index 0000000000..c21700f875 --- /dev/null +++ b/climada/engine/impact_forecast.py @@ -0,0 +1,507 @@ +""" +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 Forecast variant of Impact. +""" + +import logging +from pathlib import Path +from typing import Iterable, Literal, Union + +import numpy as np +from scipy import sparse + +from ..util import log_level +from ..util.checker import size +from ..util.forecast import ( + ForecastMixin, + reduce_unique_selection, + sparse_quantile_axis0, +) +from .impact import Impact + +LOGGER = logging.getLogger(__name__) + + +class ImpactForecast(ForecastMixin, Impact): + """An impact object with forecast information""" + + def __init__( + self, + *, + lead_time: np.ndarray | None, + member: np.ndarray | None, + **impact_kwargs, + ): + """Initialize the impact forecast. + + Parameters + ---------- + lead_time : np.ndarray, optional + The lead time associated with each event entry, given as timedelta64 type + member : np.ndarray, optional + The ensemble member associated with each event entry, given as integers + impact_kwargs + Keyword-arguments passed to :py:class:`~climada.engine.impact.Impact`. + """ + super().__init__(lead_time=lead_time, member=member, **impact_kwargs) + self._check_sizes() + + @classmethod + def from_impact( + cls, impact: Impact, lead_time: np.ndarray | None, member: np.ndarray | None + ): + """Create an impact forecast from an impact object and forecast information. + + Parameters + ---------- + impact : Impact + The impact object whose data to use in the forecast object + lead_time : np.ndarray, optional + The lead time associated with each event entry, given as timedelta64 type + member : np.ndarray, optional + The ensemble member associated with each event entry, given as integers + """ + with log_level("ERROR", "climada.engine"): + return cls( + lead_time=lead_time, + member=member, + event_id=impact.event_id, + event_name=impact.event_name, + date=impact.date, + frequency=impact.frequency, + frequency_unit=impact.frequency_unit, + coord_exp=impact.coord_exp, + crs=impact.crs, + eai_exp=impact.eai_exp, + at_event=impact.at_event, + tot_value=impact.tot_value, + aai_agg=impact.aai_agg, + unit=impact.unit, + imp_mat=impact.imp_mat, + haz_type=impact.haz_type, + ) + + @property + def at_event(self): + """Get the total impact for each member/lead_time combination.""" + LOGGER.info( + "at_event gives the total impact for one specific combination of member and " + "lead_time." + ) + return self._at_event + + @at_event.setter + def at_event(self, value): + """Set the total impact for each member/lead_time combination.""" + self._at_event = value + + def local_exceedance_impact( + self, + return_periods=(25, 50, 100, 250), + method="interpolate", + min_impact=0, + log_frequency=True, + log_impact=True, + bin_decimals=None, + ): + """Not implemented for ImpactForecast. + + See Also + -------- + climada.engine.impact.Impact.local_exceedance_impact + + Raises + ------ + NotImplementedError + """ + + LOGGER.error("local_exceedance_impact is not defined for ImpactForecast") + raise NotImplementedError( + "local_exceedance_impact is not defined for ImpactForecast" + ) + + def local_return_period( + self, + threshold_impact=(1000.0, 10000.0), + method="interpolate", + min_impact=0, + log_frequency=True, + log_impact=True, + bin_decimals=None, + ): + """Not implemented for ImpactForecast. + + See Also + -------- + climada.engine.impact.Impact.local_return_period + + Raises + ------- + NotImplementedError + """ + + LOGGER.error("local_return_period is not defined for ImpactForecast") + raise NotImplementedError( + "local_return_period is not defined for ImpactForecast" + ) + + def calc_freq_curve(self, return_per=None): + """Computation of the impact exceedance frequency curve is not + implemented for ImpactForecast. + + See Also + -------- + climada.engine.impact.Impact.calc_freq_curve + + Raises + ------ + NotImplementedError + """ + + LOGGER.error("calc_freq_curve is not defined for ImpactForecast") + raise NotImplementedError("calc_freq_curve is not defined for ImpactForecast") + + @classmethod + def from_hdf5( + cls, + file_path: Union[str, Path], + *, + add_scalar_attrs: Iterable[str] | None = None, + add_array_attrs: Iterable[str] | None = None, + ): + """Create an ImpactForecast object from an H5 file. + + This assumes a specific layout of the file. If values are not found in the + expected places, they will be set to the default values for an ``Impact`` object. + + The following H5 file structure is assumed (H5 groups are terminated with ``/``, + attributes are denoted by ``.attrs/``):: + + file.h5 + ├─ at_event + ├─ coord_exp + ├─ eai_exp + ├─ event_id + ├─ event_name + ├─ frequency + ├─ imp_mat + ├─ lead_time + ├─ member + ├─ .attrs/ + │ ├─ aai_agg + │ ├─ crs + │ ├─ frequency_unit + │ ├─ haz_type + │ ├─ tot_value + │ ├─ unit + + As per the :py:func:`climada.engine.impact.Impact.__init__`, any of these entries + is optional. If it is not found, the default value will be used when constructing + the Impact. + + The impact matrix ``imp_mat`` can either be an H5 dataset, in which case it is + interpreted as dense representation of the matrix, or an H5 group, in which case + the group is expected to contain the following data for instantiating a + `scipy.sparse.csr_matrix `_:: + + imp_mat/ + ├─ data + ├─ indices + ├─ indptr + ├─ .attrs/ + │ ├─ shape + + Parameters + ---------- + file_path : str or Path + The file path of the file to read. + add_scalar_attrs : Iterable of str, optional + Additional scalar attributes to read from file. Defaults to None. + add_array_attrs : Iterable of str, optional + Additional array attributes to read from file. Defaults to None. + + Returns + ------- + imp : ImpactForecast + ImpactForecast with data from the given file + """ + array_attrs = {"member", "lead_time"} + if add_array_attrs is not None: + array_attrs = array_attrs.union(add_array_attrs) + return super().from_hdf5( + file_path, add_array_attrs=array_attrs, add_scalar_attrs=add_scalar_attrs + ) + + def _check_sizes(self): + """Check sizes of forecast data vs. impact data. + + Raises + ------ + ValueError + If the sizes of the forecast data do not match the + :py:attr:`~climada.engine.impact.Impact.event_id` + """ + num_entries = len(self.event_id) + size(exp_len=num_entries, var=self.member, var_name="Forecast.member") + size(exp_len=num_entries, var=self.lead_time, var_name="Forecast.lead_time") + + def select( + self, + event_ids=None, + event_names=None, + dates=None, + coord_exp=None, + reset_frequency=False, + member=None, + lead_time=None, + ): + """Select entries based on the parameters and return a new instance. + + The selection will contain the intersection of all given parameters. + + Parameters + ---------- + member : Sequence of ints + Ensemble members to select + lead_time : Sequence of numpy.timedelta64 + Lead times to select + + See Also + -------- + climada.engine.impact.Impact.select + """ + if member is not None or lead_time is not None: + mask_member = ( + self.idx_member(member) + if member is not None + else np.full_like(self.member, True, dtype=bool) + ) + mask_lead_time = ( + self.idx_lead_time(lead_time) + if lead_time is not None + else np.full_like(self.lead_time, True, dtype=bool) + ) + event_id_from_forecast_mask = np.asarray(self.event_id)[ + (mask_member & mask_lead_time) + ] + event_ids = ( + np.intersect1d(event_ids, event_id_from_forecast_mask) + if event_ids is not None + else event_id_from_forecast_mask + ) + + return super().select( + event_ids=event_ids, + event_names=event_names, + dates=dates, + coord_exp=coord_exp, + reset_frequency=reset_frequency, + ) + + def min(self, dim: Literal["member", "lead_time"] | None = None): + """Reduce the impact matrix and at_event to the minimum value. + + Parameters + ---------- + dim : "member", "lead_time", or None + Dimension to reduce over. If None, reduce over all data. + + Returns + ------- + ImpactForecast + An ImpactForecast object with the min impact matrix and at_event. + """ + if dim is not None: + rdim = self._reduce_iter_dim(dim) + with log_level("ERROR", "climada.engine.impact"): + return reduce_unique_selection( + self, + attr=rdim, + reduce_method="min", + concat_kws={"reset_event_ids": True}, + ) + + red_imp_mat = self.imp_mat.min(axis=0).tocsr() + red_at_event = np.array([red_imp_mat.sum()]) + return ImpactForecast( + frequency_unit=self.frequency_unit, + coord_exp=self.coord_exp, + crs=self.crs, + eai_exp=self.eai_exp, + at_event=red_at_event, + tot_value=self._tot_value, + aai_agg=self.aai_agg, + unit=self.unit, + imp_mat=red_imp_mat, + haz_type=self.haz_type, + **self._reduce_attrs("min"), + ) + + def max(self, dim: Literal["member", "lead_time"] | None = None): + """Reduce the impact matrix and at_event to the maximum value. + + Parameters + ---------- + dim : "member", "lead_time", or None + Dimension to reduce over. If None, reduce over all data. + + Returns + ------- + ImpactForecast + An ImpactForecast object with the max impact matrix and at_event. + """ + if dim is not None: + rdim = self._reduce_iter_dim(dim) + with log_level("ERROR", "climada.engine.impact"): + return reduce_unique_selection( + self, + attr=rdim, + reduce_method="max", + concat_kws={"reset_event_ids": True}, + ) + + red_imp_mat = self.imp_mat.max(axis=0).tocsr() + red_at_event = np.array([red_imp_mat.sum()]) + return ImpactForecast( + frequency_unit=self.frequency_unit, + coord_exp=self.coord_exp, + crs=self.crs, + eai_exp=self.eai_exp, + at_event=red_at_event, + tot_value=self._tot_value, + aai_agg=self.aai_agg, + unit=self.unit, + imp_mat=red_imp_mat, + haz_type=self.haz_type, + **self._reduce_attrs("max"), + ) + + def mean(self, dim: Literal["member", "lead_time"] | None = None): + """Reduce the impact matrix and at_event to the mean value. + + Parameters + ---------- + dim : "member", "lead_time", or None + Dimension to reduce over. If None, reduce over all data. + + Returns + ------- + ImpactForecast + An ImpactForecast object with the mean impact matrix and at_event. + """ + if dim is not None: + rdim = self._reduce_iter_dim(dim) + with log_level("ERROR", "climada.engine.impact"): + return reduce_unique_selection( + self, + attr=rdim, + reduce_method="mean", + concat_kws={"reset_event_ids": True}, + ) + + red_imp_mat = sparse.csr_matrix(self.imp_mat.mean(axis=0)) + red_at_event = np.array([red_imp_mat.sum()]) + return ImpactForecast( + frequency_unit=self.frequency_unit, + coord_exp=self.coord_exp, + crs=self.crs, + eai_exp=self.eai_exp, + at_event=red_at_event, + tot_value=self._tot_value, + aai_agg=self.aai_agg, + unit=self.unit, + imp_mat=red_imp_mat, + haz_type=self.haz_type, + **self._reduce_attrs("mean"), + ) + + def _quantile( + self, + q: float, + dim: Literal["member", "lead_time"] | None = None, + event_name: str | None = None, + ): + """Reduce the impact matrix and at_event to the quantile value.""" + if dim is not None: + rdim = self._reduce_iter_dim(dim) + with log_level("ERROR", "climada.engine.impact"): + return reduce_unique_selection( + self, + attr=rdim, + reduce_method="quantile", + q=q, + concat_kws={"reset_event_ids": True}, + ) + + red_imp_mat = sparse.csr_matrix(sparse_quantile_axis0(self.imp_mat, q)) + red_at_event = np.array([red_imp_mat.sum()]) + if event_name is None: + event_name = f"quantile_{q}" + return ImpactForecast( + frequency_unit=self.frequency_unit, + coord_exp=self.coord_exp, + crs=self.crs, + eai_exp=self.eai_exp, + at_event=red_at_event, + tot_value=self._tot_value, + aai_agg=self.aai_agg, + unit=self.unit, + imp_mat=red_imp_mat, + haz_type=self.haz_type, + **self._reduce_attrs(event_name), + ) + + def quantile(self, q: float, dim: Literal["member", "lead_time"] | None = None): + """Reduce the impact matrix and at_event to the quantile value. + + Parameters + ---------- + q : float + The quantile to compute, which must be between 0 and 1. + dim : "member", "lead_time", or None + The dimension to reduce when computing the quantile. If ``None`` (default), + this computes the centroid-wise quantile over the entire matrix. + + Returns + ------- + ImpactForecast + An ImpactForecast object with the quantile impact matrix and at_event. + """ + return self._quantile(q=q, dim=dim) + + def median(self, dim: Literal["member", "lead_time"] | None = None): + """Reduce the impact matrix and at_event to the median value. + + Parameters + ---------- + dim : "member", "lead_time", or None + The dimension to reduce when computing the median. If ``None`` (default), + this computes the centroid-wise median over the entire matrix. + + Returns + ------- + ImpactForecast + An ImpactForecast object with the median impact matrix and at_event. + + See Also + -------- + ImpactForecast.quantile + Function used to compute the median with ``q=0.5``. + """ + return self._quantile(q=0.5, dim=dim, event_name="median") diff --git a/climada/engine/test/test_impact.py b/climada/engine/test/test_impact.py index c79a264a22..1ee62880b9 100644 --- a/climada/engine/test/test_impact.py +++ b/climada/engine/test/test_impact.py @@ -47,26 +47,30 @@ STR_DT = h5py.special_dtype(vlen=str) -def dummy_impact(): - """Return an impact object for testing""" - return Impact( - event_id=np.arange(6) + 10, - event_name=[0, 1, "two", "three", 30, 31], - date=np.arange(6), - coord_exp=np.array([[1, 2], [1.5, 2.5]]), - crs=DEF_CRS, - eai_exp=np.array([7.2, 7.2]), - at_event=np.array([0, 2, 4, 6, 60, 62]), - frequency=np.array([1 / 6, 1 / 6, 1, 1, 1 / 30, 1 / 30]), - tot_value=7, - aai_agg=14.4, - unit="USD", - frequency_unit="1/month", - imp_mat=sparse.csr_matrix( +def impact_kwargs(): + return { + "event_id": np.arange(6) + 10, + "event_name": [0, 1, "two", "three", 30, 31], + "date": np.arange(6), + "coord_exp": np.array([[1, 2], [1.5, 2.5]]), + "crs": DEF_CRS, + "eai_exp": np.array([7.2, 7.2]), + "at_event": np.array([0, 2, 4, 6, 60, 62]), + "frequency": np.array([1 / 6, 1 / 6, 1, 1, 1 / 30, 1 / 30]), + "tot_value": 7, + "aai_agg": 14.4, + "unit": "USD", + "frequency_unit": "1/month", + "imp_mat": sparse.csr_matrix( np.array([[0, 0], [1, 1], [2, 2], [3, 3], [30, 30], [31, 31]]) ), - haz_type="TC", - ) + "haz_type": "TC", + } + + +def dummy_impact(): + """Return an impact object for testing""" + return Impact(**impact_kwargs()) def dummy_impact_yearly(): diff --git a/climada/engine/test/test_impact_calc.py b/climada/engine/test/test_impact_calc.py index 9e7b2e2cb2..e444a2b6e6 100644 --- a/climada/engine/test/test_impact_calc.py +++ b/climada/engine/test/test_impact_calc.py @@ -26,14 +26,18 @@ import geopandas as gpd import numpy as np +import pandas as pd +import pytest from scipy import sparse from climada import CONFIG from climada.engine import Impact, ImpactCalc from climada.engine.impact_calc import LOGGER as ILOG +from climada.engine.impact_forecast import ImpactForecast from climada.entity import Exposures, ImpactFunc, ImpactFuncSet, ImpfTropCyclone from climada.entity.entity_def import Entity from climada.hazard.base import Centroids, Hazard +from climada.hazard.forecast import HazardForecast from climada.test import get_test_file from climada.util.api_client import Client from climada.util.config import Config @@ -46,17 +50,103 @@ DATA_FOLDER.mkdir(exist_ok=True) -def check_impact(self, imp, haz, exp, aai_agg, eai_exp, at_event, imp_mat_array=None): - """Test properties of imapcts""" - self.assertEqual(len(haz.event_id), len(imp.at_event)) - self.assertIsInstance(imp, Impact) +@pytest.fixture(params=[50, 1, 0]) +def exposure(request): + n_exp = request.param + lats = np.linspace(-10, 10, n_exp) + lons = np.linspace(-10, 10, n_exp) + data = gpd.GeoDataFrame( + { + "impf_TC": 1, + "value": 1, + }, + index=range(n_exp), + geometry=gpd.points_from_xy(lons, lats), + crs="EPSG:4326", + ) + exposures = Exposures(data=data) + return exposures + + +@pytest.fixture +def hazard(exposure): + n_events = 10 + centroids = Centroids( + lat=exposure.gdf.geometry.x, + lon=exposure.gdf.geometry.y, + ) + intensity = sparse.csr_matrix( + np.ones((n_events, exposure.gdf.shape[0])) * 50 + ) # uniform intensity + haz = Hazard() + haz.event_id = np.arange(n_events) + haz.event_name = haz.event_id.tolist() + haz.haz_type = "TC" + haz.date = haz.event_id + haz.frequency_unit = "m/s" + haz.centroids = centroids + haz.intensity = intensity + haz.frequency = 1 / 10 * np.ones(n_events) # uniform frequency (10 n_events) + return haz + + +@pytest.fixture +def hazard_forecast(hazard): + n_events = hazard.size + lead_time = pd.timedelta_range("1h", periods=n_events).to_numpy() + member = np.arange(n_events) + haz_fc = HazardForecast.from_hazard( + hazard=hazard, + lead_time=lead_time, + member=member, + ) + return haz_fc + + +@pytest.fixture +def impact_func_set(exposure, hazard): + step_impf = ImpactFunc() + step_impf.id = 1 + try: + step_impf.id = exposure.data[f"impf_{hazard.haz_type}"].unique()[0] + except IndexError: + pass + step_impf.haz_type = hazard.haz_type + step_impf.name = "fixture step function" + step_impf.intensity_unit = "" + step_impf.intensity = np.array([0, 0.495, 0.4955, 0.5, 1, 10]) + step_impf.mdd = np.array([0, 0, 0, 1, 1, 1]) + step_impf.paa = np.sort(np.linspace(1, 1, num=6)) + return ImpactFuncSet([step_impf]) + + +# NOTE: Must be adapted to changes in exposure, hazard +@pytest.fixture +def impact_calc(exposure, hazard): + imp_mat = np.ones((len(hazard.event_id), exposure.gdf.shape[0])) + aai_agg = np.sum(exposure.gdf["value"]) * np.sum(hazard.frequency) + eai_exp = np.ones(exposure.gdf.shape[0]) * np.sum(hazard.frequency) + at_event = np.ones(hazard.size) * np.sum(exposure.gdf["value"]) + return { + "imp_mat": imp_mat, + "aai_agg": aai_agg, + "eai_exp": eai_exp, + "at_event": at_event, + } + + +def check_impact(imp, haz, exp, aai_agg, eai_exp, at_event, imp_mat_array=None): + """Test properties of impacts""" + # NOTE: Correctly compares NaNs! + assert len(haz.event_id) == len(imp.at_event) + assert isinstance(imp, Impact) np.testing.assert_allclose(imp.coord_exp[:, 0], exp.latitude) np.testing.assert_allclose(imp.coord_exp[:, 1], exp.longitude) - self.assertAlmostEqual(imp.aai_agg, aai_agg, 3) + np.testing.assert_allclose(imp.aai_agg, aai_agg, rtol=1e-3) np.testing.assert_allclose(imp.eai_exp, eai_exp, rtol=1e-5) np.testing.assert_allclose(imp.at_event, at_event, rtol=1e-5) if imp_mat_array is not None: - np.testing.assert_allclose(imp.imp_mat.toarray().ravel(), imp_mat_array.ravel()) + np.testing.assert_allclose(imp.imp_mat.todense(), imp_mat_array) class TestImpactCalc(unittest.TestCase): @@ -106,7 +196,7 @@ def test_apply_cover_to_mat(self): def test_error_handling_mismatch_haz_type(self): """Test error handling in case hazard type of hazard does not appear in impf_set or exposures""" - haz_tc = Hazard("TC") + haz_tc = Hazard("TC", event_id=np.array([1])) exp_tc = Exposures() exp_tc.gdf["impf_TC"] = 1 exp_ws = Exposures() @@ -147,10 +237,26 @@ def test_error_handling_mismatch_haz_type(self): "functions found for hazard type TC in impf_set.", ) + def test_error_handling_empty_hazard(self): + """An empty Hazard must raise a clear ValueError (see GH #814).""" + haz_empty = Hazard("TC") + exp = Exposures(data={"value": [1.0]}, lat=[10.0], lon=[10.0]) + exp.gdf["impf_TC"] = 1 + impf = ImpactFunc( + haz_type="TC", + id=1, + intensity=np.array([0, 20]), + paa=np.array([0, 1]), + mdd=np.array([0, 0.5]), + ) + impfset = ImpactFuncSet([impf]) + with self.assertRaisesRegex(ValueError, "no events"): + ImpactCalc(exp, impfset, haz_empty).impact() + def test_error_handling_mismatch_impf_ids(self): """Test error handling in case impf ids in exposures does not appear in impf_set""" - haz = Hazard("TC") + haz = Hazard("TC", event_id=np.array([1])) exp = Exposures() exp.gdf.loc[0, "impf_TC"] = 1 exp.gdf.loc[1, "impf_TC"] = 2 @@ -300,7 +406,7 @@ def test_calc_impact_RF_pass(self): ] ) # fmt: on - check_impact(self, impact, haz, exp, aai_agg, eai_exp, at_event, imp_mat_array) + check_impact(impact, haz, exp, aai_agg, eai_exp, at_event, imp_mat_array) def test_empty_impact(self): """Check that empty impact is returned if no centroids match the exposures""" @@ -311,11 +417,11 @@ def test_empty_impact(self): aai_agg = 0.0 eai_exp = np.zeros(len(exp.gdf)) at_event = np.zeros(HAZ.size) - check_impact(self, impact, HAZ, exp, aai_agg, eai_exp, at_event, None) + check_impact(impact, HAZ, exp, aai_agg, eai_exp, at_event, None) impact = icalc.impact(save_mat=True, assign_centroids=False) imp_mat_array = sparse.csr_matrix((HAZ.size, len(exp.gdf))).toarray() - check_impact(self, impact, HAZ, exp, aai_agg, eai_exp, at_event, imp_mat_array) + check_impact(impact, HAZ, exp, aai_agg, eai_exp, at_event, imp_mat_array) def test_single_event_impact(self): """Check impact for single event""" @@ -325,11 +431,11 @@ def test_single_event_impact(self): aai_agg = 0.0 eai_exp = np.zeros(len(ENT.exposures.gdf)) at_event = np.array([0]) - check_impact(self, impact, haz, ENT.exposures, aai_agg, eai_exp, at_event, None) + check_impact(impact, haz, ENT.exposures, aai_agg, eai_exp, at_event, None) impact = icalc.impact(save_mat=True, assign_centroids=False) imp_mat_array = sparse.csr_matrix((haz.size, len(ENT.exposures.gdf))).toarray() check_impact( - self, impact, haz, ENT.exposures, aai_agg, eai_exp, at_event, imp_mat_array + impact, haz, ENT.exposures, aai_agg, eai_exp, at_event, imp_mat_array ) def test_calc_impact_save_mat_pass(self): @@ -603,7 +709,47 @@ def test_single_exp_zero_mdr(self): imp = ImpactCalc(exp, impf_set, haz).impact( assign_centroids=False, save_mat=True ) - check_impact(self, imp, haz, exp, aai_agg, eai_exp, at_event, at_event) + check_impact(imp, haz, exp, aai_agg, eai_exp, at_event, np.array([at_event]).T) + + +class TestImpactCalcForecast: + """Test impact calc for forecast hazard""" + + @pytest.fixture + def impact_calc_forecast(self, impact_calc): + """Write NaNs to attributes that are not used""" + impact_calc["aai_agg"] = np.nan + impact_calc["eai_exp"] = np.full_like(impact_calc["eai_exp"], np.nan) + + def test_impact_forecast( + self, + exposure, + hazard_forecast, + impact_func_set, + impact_calc, + impact_calc_forecast, + ): + """Test that ImpactForecast is returned correctly""" + impact = ImpactCalc(exposure, impact_func_set, hazard_forecast).impact( + assign_centroids=True, save_mat=True + ) + # check that impact is indeed ImpactForecast + impact_calc["imp_mat_array"] = impact_calc.pop("imp_mat") + check_impact(imp=impact, haz=hazard_forecast, exp=exposure, **impact_calc) + assert isinstance(impact, ImpactForecast) + np.testing.assert_array_equal(impact.lead_time, hazard_forecast.lead_time) + assert impact.lead_time.dtype == hazard_forecast.lead_time.dtype + np.testing.assert_array_equal(impact.member, hazard_forecast.member) + + def test_impact_forecast_empty_impmat_error( + self, hazard_forecast, exposure, impact_func_set + ): + """Test that error is raised when trying to compute impact forecast + without saving impact matrix + """ + icalc = ImpactCalc(exposure, impact_func_set, hazard_forecast) + with pytest.raises(ValueError, match="Saving impact matrix is required"): + icalc.impact(assign_centroids=True, save_mat=False) class TestImpactMatrixCalc(unittest.TestCase): @@ -901,6 +1047,7 @@ def test_skip_mat(self, from_eih_mock): # Execute Tests if __name__ == "__main__": TESTS = unittest.TestLoader().loadTestsFromTestCase(TestImpactCalc) + TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestImpactCalcForecast)) TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestReturnImpact)) TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestImpactMatrix)) TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestImpactMatrixCalc)) diff --git a/climada/engine/test/test_impact_forecast.py b/climada/engine/test/test_impact_forecast.py new file mode 100644 index 0000000000..729ea0cf78 --- /dev/null +++ b/climada/engine/test/test_impact_forecast.py @@ -0,0 +1,490 @@ +""" +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 Forecast. +""" + +from unittest.mock import patch + +import numpy as np +import numpy.testing as npt +import pandas as pd +import pytest +from scipy.sparse import csr_matrix + +from climada.engine import Impact, ImpactForecast +from climada.util.forecast import sparse_quantile_axis0 + +from .test_impact import impact_kwargs as imp_kwargs + + +@pytest.fixture +def impact_kwargs(): + return imp_kwargs() + + +@pytest.fixture +def impact(impact_kwargs): + return Impact(**impact_kwargs) + + +@pytest.fixture +def lead_time(impact_kwargs): + return pd.timedelta_range( + start="1 day", periods=len(impact_kwargs["event_id"]) + ).to_numpy() + + +@pytest.fixture +def member(impact_kwargs): + return np.arange(len(impact_kwargs["event_id"])) + + +@pytest.fixture +def impact_forecast(impact, lead_time, member): + return ImpactForecast.from_impact(impact, lead_time=lead_time, member=member) + + +class TestImpactForecastInit: + + def assert_impact_kwargs(self, impact: Impact, **kwargs): + for key, value in kwargs.items(): + attr = getattr(impact, key) + if isinstance(value, (np.ndarray, list)): + npt.assert_array_equal(attr, value) + elif isinstance(value, csr_matrix): + npt.assert_array_equal(attr.todense(), value.todense()) + else: + assert attr == value + + def test_impact_forecast_init(self, impact_kwargs, lead_time, member): + forecast1 = ImpactForecast( + lead_time=lead_time, + member=member, + **impact_kwargs, + ) + npt.assert_array_equal(forecast1.lead_time, lead_time) + npt.assert_array_equal(forecast1.member, member) + self.assert_impact_kwargs(forecast1, **impact_kwargs) + + def test_impact_forecast_init_error(self, impact, impact_kwargs, lead_time, member): + with pytest.raises(ValueError, match="Forecast.lead_time"): + ImpactForecast(lead_time=lead_time[:-2], member=member, **impact_kwargs) + with pytest.raises(ValueError, match="Forecast.member"): + ImpactForecast.from_impact(impact, lead_time=lead_time, member=member[1:]) + + def test_impact_forecast_from_impact( + self, impact_forecast, impact_kwargs, lead_time, member + ): + npt.assert_array_equal(impact_forecast.lead_time, lead_time) + npt.assert_array_equal(impact_forecast.member, member) + self.assert_impact_kwargs(impact_forecast, **impact_kwargs) + + +class TestSelect: + + @pytest.mark.parametrize( + "var, var_select", + [("event_id", "event_ids"), ("event_name", "event_names"), ("date", "dates")], + ) + def test_base_class_select( + self, impact_forecast, lead_time, member, impact_kwargs, var, var_select + ): + """Check if Impact.select works on the derived class""" + select_mask = np.array([2, 1]) + result_select_mask = np.array([1, 2]) + if var == "date": + # Input to 'date' is begin and end date in order + select_mask = np.array([1, 3]) + result_select_mask = np.array([1, 2, 3]) + + var_value = np.array(impact_kwargs[var])[select_mask] + # event_name is a list, convert to numpy array for indexing + impact_fc = impact_forecast.select(**{var_select: var_value}) + # NOTE: Events keep their original order + npt.assert_array_equal( + impact_fc.event_id, + impact_forecast.event_id[result_select_mask], + ) + npt.assert_array_equal( + impact_fc.event_name, + np.array(impact_forecast.event_name)[result_select_mask], + ) + npt.assert_array_equal(impact_fc.date, impact_forecast.date[result_select_mask]) + npt.assert_array_equal( + impact_fc.frequency, impact_forecast.frequency[result_select_mask] + ) + npt.assert_array_equal(impact_fc.member, member[result_select_mask]) + npt.assert_array_equal(impact_fc.lead_time, lead_time[result_select_mask]) + npt.assert_array_equal( + impact_fc.imp_mat.todense(), + impact_forecast.imp_mat.todense()[result_select_mask], + ) + + def test_impact_forecast_select_exposure( + self, impact_forecast, lead_time, member, impact_kwargs + ): + """Check if Impact.select works on the derived class""" + exp_col = 0 + select_mask = np.array([exp_col]) + coord_exp = impact_kwargs["coord_exp"][select_mask] + impact_fc = impact_forecast.select(coord_exp=coord_exp) + npt.assert_array_equal(impact_fc.member, member) + npt.assert_array_equal(impact_fc.lead_time, lead_time) + npt.assert_array_equal( + impact_fc.imp_mat.todense(), impact_forecast.imp_mat.todense()[:, exp_col] + ) + + def test_derived_select_single(self, impact_forecast, lead_time, member): + imp_fc_select = impact_forecast.select(member=[2, 0]) + idx = np.array([0, 2]) + npt.assert_array_equal(imp_fc_select.event_id, impact_forecast.event_id[idx]) + npt.assert_array_equal(imp_fc_select.member, member[idx]) + npt.assert_array_equal(imp_fc_select.lead_time, lead_time[idx]) + + imp_fc_select = impact_forecast.select(lead_time=lead_time[np.array([2, 0])]) + npt.assert_array_equal(imp_fc_select.event_id, impact_forecast.event_id[idx]) + npt.assert_array_equal(imp_fc_select.member, member[idx]) + npt.assert_array_equal(imp_fc_select.lead_time, lead_time[idx]) + + def test_derived_select_intersections( + self, impact_forecast, lead_time, member, impact_kwargs + ): + imp_fc_select = impact_forecast.select(event_ids=[10, 14], member=[0, 1, 2]) + npt.assert_array_equal( + imp_fc_select.event_id, impact_forecast.event_id[np.array([0])] + ) + + imp_fc_select = impact_forecast.select( + event_ids=[10, 11, 13], member=[0, 1, 2], lead_time=lead_time[1:3] + ) + npt.assert_array_equal( + imp_fc_select.event_id, impact_forecast.event_id[np.array([1])] + ) + + # Test "outer" + impact_forecast2 = ImpactForecast( + lead_time=lead_time, + member=np.zeros_like(member, dtype="int"), + **impact_kwargs, + ) + imp_fc_select = impact_forecast2.select(event_ids=[10, 11, 13], member=[0]) + npt.assert_array_equal(imp_fc_select.event_id, [10, 11, 13]) + npt.assert_array_equal(imp_fc_select.member, [0, 0, 0]) + + def test_no_select(self, impact_forecast, impact_kwargs): + imp_fc_select = impact_forecast.select() + npt.assert_array_equal( + imp_fc_select.imp_mat.todense(), impact_forecast.imp_mat.todense() + ) + + num_centroids = len(impact_kwargs["coord_exp"]) + imp_fc_select = impact_forecast.select(event_names=["aaaaa", "foo"]) + assert imp_fc_select.imp_mat.shape == (0, num_centroids) + imp_fc_select = impact_forecast.select(event_ids=[-1, 1002]) + assert imp_fc_select.imp_mat.shape == (0, num_centroids) + imp_fc_select = impact_forecast.select(member=[-1]) + assert imp_fc_select.imp_mat.shape == (0, num_centroids) + imp_fc_select = impact_forecast.select(np.timedelta64("3", "Y")) + assert imp_fc_select.imp_mat.shape == (0, num_centroids) + + +def test_impact_forecast_concat(impact_forecast, member, lead_time): + """Check if Impact.concat works on the derived class""" + impact_fc = ImpactForecast.concat( + [impact_forecast, impact_forecast], reset_event_ids=True + ) + npt.assert_array_equal(impact_fc.member, np.concatenate([member, member])) + npt.assert_array_equal(impact_fc.lead_time, np.concatenate([lead_time, lead_time])) + npt.assert_array_equal( + impact_fc.event_id, np.arange(impact_fc.imp_mat.shape[0]) + 1 + ) + npt.assert_array_equal(impact_fc.event_name, impact_forecast.event_name * 2) + npt.assert_array_equal( + impact_fc.imp_mat.toarray(), + np.vstack( + (impact_forecast.imp_mat.toarray(), impact_forecast.imp_mat.toarray()) + ), + ) + + +def test_impact_forecast_blocked_methods(impact_forecast): + """Check if ImpactForecast.exceedance_freq_curve raises NotImplementedError""" + with pytest.raises(NotImplementedError): + impact_forecast.local_exceedance_impact(np.array([10, 50, 100])) + + with pytest.raises(NotImplementedError): + impact_forecast.local_return_period(np.array([10, 50, 100])) + + with pytest.raises(NotImplementedError): + impact_forecast.calc_freq_curve(np.array([10, 50, 100])) + + +@pytest.mark.parametrize("dense", [True, False]) +def test_write_read_hdf5(impact_forecast, tmp_path, dense): + + file_name = tmp_path / "test_impact_forecast.h5" + # replace dummy_impact event_names with strings + impact_forecast.event_name = [str(name) for name in impact_forecast.event_name] + impact_forecast.write_hdf5(file_name, dense_imp_mat=dense) + + def compare_attr(obj, attr): + actual = getattr(obj, attr) + expected = getattr(impact_forecast, attr) + if isinstance(actual, csr_matrix): + npt.assert_array_equal(actual.todense(), expected.todense()) + else: + npt.assert_array_equal(actual, expected) + + # Read ImpactForecast + impact_forecast_read = ImpactForecast.from_hdf5(file_name) + assert impact_forecast_read.lead_time.dtype.kind == np.dtype("timedelta64").kind + for attr in impact_forecast.__dict__.keys(): + compare_attr(impact_forecast_read, attr) + + # Read Impact + impact_read = Impact.from_hdf5(file_name) + for attr in impact_read.__dict__.keys(): + compare_attr(impact_read, attr) + assert "member" not in impact_read.__dict__ + assert "lead_time" not in impact_read.__dict__ + + +class TestReduce: + + @pytest.fixture + def imp_fc_stats(self, impact_kwargs, lead_time, member): + max_index = 4 + for key, val in impact_kwargs.items(): + if isinstance(val, (np.ndarray, list)): + impact_kwargs[key] = val[:max_index] + elif isinstance(val, csr_matrix): + impact_kwargs[key] = val[:max_index, :] + impact_kwargs["imp_mat"] = csr_matrix([[1, 0], [0, 1], [3, 2], [2, 5]]) + impact_kwargs["at_event"] = np.array([1, 1, 5, 7]) + return ImpactForecast( + lead_time=lead_time[:max_index], member=member[:max_index], **impact_kwargs + ) + + @pytest.fixture + def imp_fc_stats_dim_reduce(self, imp_fc_stats): + """Create hazard forecast where some members/leadtimes are duplicated""" + imp_fc_stats.member = np.array([1, 2, 1, 2]) + imp_fc_stats.lead_time = np.array( + [ + np.timedelta64(1, "h"), + np.timedelta64(2, "h"), + np.timedelta64(2, "h"), + np.timedelta64(1, "h"), + ] + ) + return imp_fc_stats + + @pytest.fixture + def q(self): + """Quantile to test""" + return 0.25 + + @pytest.fixture + def reduction_results(self): + return { + "min": {"imp_mat": [0, 0], "at_event": [0]}, + "mean": {"imp_mat": [1.5, 2], "at_event": [3.5]}, + "max": {"imp_mat": [3, 5], "at_event": [8]}, + "median": {"imp_mat": [1.5, 1.5], "at_event": [3]}, + "quantile": {"imp_mat": [0.75, 0.75], "at_event": [1.5]}, + } + + @pytest.fixture + def reduction_results_dim(self): + return { + "lead_time": { + "min": {"imp_mat": [[1, 0], [0, 1]], "at_event": [1, 1]}, + "mean": {"imp_mat": [[2, 1], [1, 3]], "at_event": [3, 4]}, + "median": {"imp_mat": [[2, 1], [1, 3]], "at_event": [3, 4]}, + "max": {"imp_mat": [[3, 2], [2, 5]], "at_event": [5, 7]}, + "quantile": {"imp_mat": [[1.5, 0.5], [0.5, 2]], "at_event": [2, 2.5]}, + }, + "member": { + "min": {"imp_mat": [[1, 0], [0, 1]], "at_event": [1, 1]}, + "mean": {"imp_mat": [[1.5, 2.5], [1.5, 1.5]], "at_event": [4, 3]}, + "median": {"imp_mat": [[1.5, 2.5], [1.5, 1.5]], "at_event": [4, 3]}, + "max": {"imp_mat": [[2, 5], [3, 2]], "at_event": [7, 5]}, + "quantile": { + "imp_mat": [[1.25, 1.25], [0.75, 1.25]], + "at_event": [2.5, 2], + }, + }, + } + + @pytest.mark.parametrize("attr", ["min", "mean", "max", "quantile", "median"]) + def test_reduce(self, imp_fc_stats, q, reduction_results, attr): + """Check mean, min, and max methods for ImpactForecast""" + kwargs = {"q": q} if attr == "quantile" else {} + imp_fc_reduced = getattr(imp_fc_stats, attr)(**kwargs) + + # assert imp_mat + npt.assert_array_equal( + imp_fc_reduced.imp_mat.toarray().squeeze(), + getattr(np, attr)(imp_fc_stats.imp_mat.toarray(), axis=0, **kwargs), + ) + npt.assert_array_equal( + imp_fc_reduced.imp_mat.toarray().squeeze(), + reduction_results[attr]["imp_mat"], + ) + npt.assert_array_equal( + imp_fc_reduced.at_event, reduction_results[attr]["at_event"] + ) + + # check that attributes where reduced correctly + attr_str = f"quantile_{q}" if attr == "quantile" else attr + npt.assert_array_equal(imp_fc_reduced.lead_time, [np.timedelta64("NaT")]) + npt.assert_array_equal(imp_fc_reduced.member, [-1]) + npt.assert_array_equal(imp_fc_reduced.event_name, [attr_str]) + npt.assert_array_equal(imp_fc_reduced.event_id, [1]) + npt.assert_array_equal(imp_fc_reduced.frequency, [1]) + npt.assert_array_equal(imp_fc_reduced.date, [0]) + + @pytest.mark.parametrize("quantile,reduce", [(0.0, "min"), (1.0, "max")]) + def test_quantile_min_max(self, imp_fc_stats, quantile, reduce): + """Compare min/max with quantiles 0/1""" + imp_fcst_quantile = imp_fc_stats.quantile(q=quantile) + imp_fcst_reduce = getattr(imp_fc_stats, reduce)() + npt.assert_array_equal( + imp_fcst_quantile.imp_mat.toarray(), imp_fcst_reduce.imp_mat.toarray() + ) + npt.assert_array_equal(imp_fcst_quantile.at_event, imp_fcst_reduce.at_event) + + def test_median_quantile(self, imp_fc_stats): + """Compare median with quantile 0.5""" + imp_fcst_median = imp_fc_stats.median() + imp_fcst_quantile = imp_fc_stats.quantile(q=0.5) + npt.assert_array_equal( + imp_fcst_median.imp_mat.toarray(), imp_fcst_quantile.imp_mat.toarray() + ) + npt.assert_array_equal(imp_fcst_median.at_event, imp_fcst_quantile.at_event) + npt.assert_array_equal( + imp_fcst_median.imp_mat.toarray().squeeze(), + np.median(imp_fc_stats.imp_mat.toarray(), axis=0), + ) + + @pytest.mark.parametrize("attr", ["min", "mean", "max", "median", "quantile"]) + @pytest.mark.parametrize("dim", ["lead_time", "member", "single"]) + def test_reduce_dim_unique_or_single(self, imp_fc_stats, q, attr, dim): + """Test that reduction over a dimension with all-unique values does nothing""" + kwargs = {"q": q} if attr == "quantile" else {} + if dim == "single": + imp_fc_stats = imp_fc_stats.select(event_ids=[imp_fc_stats.event_id[0]]) + dim = None + + imp_fc_stats_reduced = getattr(imp_fc_stats, attr)(dim=dim, **kwargs) + + npt.assert_array_equal(imp_fc_stats_reduced.member, imp_fc_stats.member) + npt.assert_array_equal(imp_fc_stats_reduced.lead_time, imp_fc_stats.lead_time) + npt.assert_array_equal( + imp_fc_stats_reduced.imp_mat.toarray(), + imp_fc_stats.imp_mat.toarray(), + ) + npt.assert_array_equal( + imp_fc_stats_reduced.at_event, + imp_fc_stats.at_event, + ) + if dim == "single": + npt.assert_array_equal( + imp_fc_stats_reduced.event_name, + imp_fc_stats.event_name, + ) + npt.assert_array_equal(imp_fc_stats_reduced.event_id, imp_fc_stats.event_id) + npt.assert_array_equal( + imp_fc_stats_reduced.frequency, imp_fc_stats.frequency + ) + npt.assert_array_equal(imp_fc_stats_reduced.date, imp_fc_stats.date) + + @pytest.mark.parametrize("attr", ["min", "mean", "max", "quantile", "median"]) + def test_reduce_dim_error(self, imp_fc_stats, q, attr): + """Check reduction error message for invalid dimension name""" + kwargs = {"q": q} if attr == "quantile" else {} + with pytest.raises(ValueError, match=r"Cannot reduce over dim \'invalid_dim\'"): + getattr(imp_fc_stats, attr)(dim="invalid_dim", **kwargs) + + @pytest.mark.parametrize("attr", ["min", "mean", "max", "median", "quantile"]) + @pytest.mark.parametrize("dim", ["lead_time", "member"]) + def test_reduce_dim( + self, imp_fc_stats_dim_reduce, q, reduction_results_dim, attr, dim + ): + """Check reduction for HazardForecast with dim argument""" + kwargs = {"q": q} if attr == "quantile" else {} + imp_fc_reduced = getattr(imp_fc_stats_dim_reduce, attr)(dim=dim, **kwargs) + + rdim = "member" if dim == "lead_time" else "lead_time" + unique_rdim = np.unique(getattr(imp_fc_stats_dim_reduce, rdim)) + npt.assert_array_equal(getattr(imp_fc_reduced, rdim), unique_rdim) + + if dim == "lead_time": + unique_rdim = [1, 2] + npt.assert_array_equal( + imp_fc_reduced.lead_time, [np.timedelta64("NaT"), np.timedelta64("NaT")] + ) + npt.assert_array_equal(imp_fc_reduced.member, unique_rdim) + else: + unique_rdim = [np.timedelta64(1, "h"), np.timedelta64(2, "h")] + npt.assert_array_equal( + imp_fc_reduced.lead_time, + unique_rdim, + ) + npt.assert_array_equal(imp_fc_reduced.member, [-1, -1]) + + imp_fc_expected = imp_fc_stats_dim_reduce.concat( + [ + getattr(imp_fc_stats_dim_reduce.select(**{rdim: val}), attr)( + dim=None, **kwargs + ) + for val in unique_rdim + ], + reset_event_ids=True, + ) + npt.assert_array_equal( + imp_fc_reduced.imp_mat.toarray().squeeze(), + reduction_results_dim[dim][attr]["imp_mat"], + ) + npt.assert_array_equal( + imp_fc_reduced.imp_mat.toarray(), + imp_fc_expected.imp_mat.toarray(), + ) + npt.assert_array_equal( + imp_fc_reduced.at_event, + reduction_results_dim[dim][attr]["at_event"], + ) + + +def test_quantile_uses_block_wise_helper(impact_forecast): + """quantile passes the impact matrix itself to the block-wise helper""" + expected = np.quantile(impact_forecast.imp_mat.toarray(), 0.5, axis=0) + + # wraps, so the real helper still runs and the result stays checkable + with patch( + "climada.engine.impact_forecast.sparse_quantile_axis0", + wraps=sparse_quantile_axis0, + ) as helper: + reduced = impact_forecast.quantile(0.5) + + helper.assert_called_once() + matrix, q = helper.call_args.args + assert matrix is impact_forecast.imp_mat + assert q == 0.5 + npt.assert_array_equal(reduced.imp_mat.toarray().squeeze(), expected) diff --git a/climada/engine/unsequa/calc_delta_climate.py b/climada/engine/unsequa/calc_delta_climate.py index 93fdfec969..97d45e8258 100644 --- a/climada/engine/unsequa/calc_delta_climate.py +++ b/climada/engine/unsequa/calc_delta_climate.py @@ -280,8 +280,10 @@ def uncertainty( at_event_unc_df = pd.DataFrame(at_event_list) if calc_eai_exp: - exp = self.exp_input_var.evaluate() - coord_df = exp.gdf[["latitude", "longitude"]] + exp = self.exp_final_input_var.evaluate() + coord_df = pd.DataFrame.from_dict( + {"latitude": exp.latitude, "longitude": exp.longitude} + ) else: coord_df = pd.DataFrame([]) diff --git a/climada/entity/measures/cost_income.py b/climada/entity/measures/cost_income.py index 01d5afe5d5..2e6d11951b 100644 --- a/climada/entity/measures/cost_income.py +++ b/climada/entity/measures/cost_income.py @@ -19,8 +19,7 @@ Define the CostIncome class to handle the cash flow of measures. """ -from datetime import datetime -from typing import Any, Optional, Tuple, cast +from typing import Any, Optional, cast import matplotlib.pyplot as plt import numpy as np @@ -39,7 +38,7 @@ class CostIncome: Attributes ---------- - mkt_price_year : datetime, default to today's year. + mkt_price_year : int, default to today's year. The reference year for market prices. init_cost : float Initial implementation cost (stored as negative). @@ -54,14 +53,15 @@ class CostIncome: custom_cash_flows : pd.DataFrame, optional User-defined cash flows indexed by date. freq : str - Frequency of the cash flows (e.g., 'Y', '3M', '7D'). + Periodicity (frequency) of the cash flows (e.g., 'Y', '3M', '7D'). + All pandas aliases are possible. See [pandas documentation](https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#period-aliases). """ def __init__( self, *, - mkt_price_year: Optional[int] = None, + mkt_price_year: int | None = None, init_cost: float = 0.0, periodic_cost: float = 0.0, periodic_income: float = 0.0, @@ -74,7 +74,7 @@ def __init__( Parameters ---------- - mkt_price_year : datetime, default to today's year. + mkt_price_year : int, default to today's year. The reference year for market prices. init_cost : float Initial implementation cost (stored as negative). @@ -93,7 +93,7 @@ def __init__( """ self.freq = freq - self.mkt_price_year = datetime(mkt_price_year or datetime.today().year, 1, 1) + self.mkt_price_year = mkt_price_year or pd.Timestamp.now().year self.cost_growth_rate = cost_yearly_growth_rate self.init_cost = -abs(init_cost) @@ -106,7 +106,7 @@ def __init__( def __repr__(self) -> str: lines = [ "CostIncome(", - f" mkt_price_year = {self.mkt_price_year.year}", + f" mkt_price_year = {self.mkt_price_year}", f" freq = {self.freq!r}", f" init_cost = {self.init_cost:,.2f}", f" periodic_cost = {self.periodic_cost:,.2f}", @@ -119,6 +119,13 @@ def __repr__(self) -> str: ] return "\n".join(lines) + @property + def _mkt_price_ts(self) -> pd.Timestamp: + """pd.Timestamp : First day of the market price reference year.""" + return cast( + pd.Timestamp, pd.Timestamp(year=self.mkt_price_year, month=1, day=1) + ) + @property def custom_cash_flows(self) -> pd.DataFrame | None: """:obj:`pd.DataFrame` : Get or set the optional user-defined cash @@ -166,12 +173,9 @@ def _prepare_custom_flows(self, df: pd.DataFrame) -> pd.DataFrame: ) df = df.copy() - if "cost" in df.columns: - df["cost"] = -df["cost"].abs() - - if "date" in df.columns: - df["date"] = pd.to_datetime(df["date"]) - df = df.set_index("date") + df["cost"] = -df["cost"].abs() + df["date"] = pd.to_datetime(df["date"]) + df = df.set_index("date") freq = self._make_offset_compat(self.freq) return df.resample(freq).sum() @@ -247,7 +251,8 @@ def from_dict(cls, args_dict: dict) -> "CostIncome": @classmethod def from_yaml(cls, path: str) -> "CostIncome": - """Create a `CostIncome` from a yaml file. + """Create a `CostIncome` from a yaml file of a `MeasureConfig` + object. Parameters ---------- @@ -262,36 +267,6 @@ def from_yaml(cls, path: str) -> "CostIncome": with open(path) as f: return cls.from_dict(yaml.safe_load(f)["cost_income"]) - @classmethod - def _freq_to_days(cls, freq: str) -> str: - """ - Convert a frequency string to the equivalent number of days. - - Parameters: - ----------- - freq : str - A frequency string (e.g., 'D' for daily, 'M' for monthly, 'Y' for yearly). - - Returns: - -------- - float - The equivalent number of days for the given frequency string. - """ - - try: - # Convert the frequency string to a DateOffset object - freq = cls._make_offset_compat(freq, start=False) - offset = pd.tseries.frequencies.to_offset(freq) - - # Calculate the number of days by applying the offset to a base date - base_date = pd.Timestamp("2000-01-01") - end_date = base_date + offset - - # Return the difference in days - return f"{(end_date - base_date).days}d" - except ValueError as exc: - raise ValueError(f"Invalid frequency string: {freq}") from exc - def _get_width_days(self) -> float: """Return the number of days in the current frequency.""" @@ -302,7 +277,7 @@ def _get_width_days(self) -> float: def calc_at_date( self, impl_date: pd.Timestamp, curr_date: pd.Timestamp - ) -> Tuple[float, float, float]: + ) -> tuple[float, float, float]: r"""Calculate cash flows for a single timestamp. Computes the total cash flow, total cost, and total income for a given @@ -317,9 +292,11 @@ def calc_at_date( ---------- impl_date : pd.Timestamp The implementation date that determines which cost/income regime - applies. Dates before this use have no cost or income; "at the date" uses + applies. Dates before this have no cost or income; "at the date" uses the implementation cost, and dates after use the initialized or periodic amounts respectively. + Note that if a custom cash flow is defined for `curr_date`, + before `impl_date`, it will be accounted for. curr_date : pd.Timestamp The evaluation date for which cash flows are being calculated. This is compared against `impl_date` to determine the applicable base @@ -327,7 +304,7 @@ def calc_at_date( Returns ------- - Tuple[float, float, float] + tuple[float, float, float] A tuple containing: * total_cash_flow : float @@ -361,7 +338,7 @@ def calc_at_date( cash flow DataFrame will raise a KeyError. """ # Calculate growth factor based on years from market price reference - years_passed = (curr_date - self.mkt_price_year).days / 365.0 + years_passed = (curr_date - self._mkt_price_ts).days / 365.0 cost_factor = (1 + self.cost_growth_rate) ** years_passed inc_factor = (1 + self.income_growth_rate) ** years_passed @@ -389,8 +366,8 @@ def calc_at_date( return (total_inc + total_cost), total_cost, total_inc def calc_cash_flows( - self, impl_date, start_date, end_date - ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: + self, impl_date: pd.Timestamp, start_date: pd.Timestamp, end_date: pd.Timestamp + ) -> tuple[np.ndarray, np.ndarray, np.ndarray]: """Calculate net cash flows, costs, and incomes over a period. Computes cash flow metrics across a specified date range by iterating @@ -402,17 +379,17 @@ def calc_cash_flows( Parameters ---------- - impl_date : + impl_date : pd.Timestamp The implementation date that determines which cost/income regime applies. - start_date : + start_date : pd.Timestamp The beginning of the calculation period. - end_date : + end_date : pd.Timestamp The end of the calculation period. Returns ------- - Tuple[np.ndarray, np.ndarray, np.ndarray] + tuple[np.ndarray, np.ndarray, np.ndarray] A tuple containing three NumPy arrays of equal length: * net : np.ndarray @@ -425,14 +402,15 @@ def calc_cash_flows( # 'Trick' to make sure that e.g., impl_date "2020-01-05" falls in # period "2020-01" if freq is "M" - impl_ts = pd.Timestamp(str(impl_date)).to_period(self.freq).start_time + impl_ts = pd.Timestamp(str(impl_date)) + impl_ts = cast(pd.Timestamp, impl_ts).to_period(self.freq).start_time periods = pd.period_range(start=start_date, end=end_date, freq=self.freq) results = [self.calc_at_date(impl_ts, p.start_time) for p in periods] net, costs, incs = map(np.array, zip(*results)) return net, costs, incs - def calc_total(self, impl_date, start_date, end_date) -> Tuple[float, float, float]: + def calc_total(self, impl_date, start_date, end_date) -> tuple[float, float, float]: """ Calculate the total value of the cash flows over a given period. @@ -447,7 +425,7 @@ def calc_total(self, impl_date, start_date, end_date) -> Tuple[float, float, flo Returns: -------- - Tuple[float, float, float] + tuple[float, float, float] the total net, cost, and income values over the given period. """ @@ -461,7 +439,7 @@ def plot_cash_flows( impl_date: Any, start_date: Any, end_date: Any, - figsize: Tuple[int, int] = (12, 7), + figsize: tuple[int, int] = (12, 7), title: Optional[str] = None, ): """Plot periodic and cumulative cash flows over a given period. @@ -486,7 +464,7 @@ def plot_cash_flows( Returns ------- - plt.Figure + tuple(plt.Axis, plt.Axis) """ net, costs, incomes = self.calc_cash_flows(impl_date, start_date, end_date) periods = pd.period_range(start=start_date, end=end_date, freq=self.freq) @@ -562,12 +540,7 @@ def comb_cost_income(cost_incomes: list["CostIncome"]) -> "CostIncome": first_ci = cost_incomes[0] - if not all( - ( - first_ci.mkt_price_year.year == c.mkt_price_year.year - for c in cost_incomes - ) - ): + if not all(first_ci.mkt_price_year == c.mkt_price_year for c in cost_incomes): raise ValueError( "Measure cost incomes have different market price years," " combination is not possible." @@ -610,7 +583,7 @@ def comb_cost_income(cost_incomes: list["CostIncome"]) -> "CostIncome": raise err return CostIncome( - mkt_price_year=first_ci.mkt_price_year.year, + mkt_price_year=first_ci.mkt_price_year, init_cost=sum(c.init_cost for c in cost_incomes), periodic_cost=sum(c.periodic_cost for c in cost_incomes), periodic_income=sum(c.periodic_income for c in cost_incomes), diff --git a/climada/entity/measures/measure_config.py b/climada/entity/measures/measure_config.py index ec88837d61..3342a808e0 100644 --- a/climada/entity/measures/measure_config.py +++ b/climada/entity/measures/measure_config.py @@ -382,9 +382,10 @@ class CostIncomeConfig(ModifierConfig): income_yearly_growth_rate : float, optional Annual growth rate applied to periodic income. Default is ``0.0``. freq : str, optional - Pandas period alias defining the period length (e.g. ``"Y"`` for - yearly, ``"M"`` for monthly). Default is ``"Y"``. + Pandas period alias defining the periodicity of the costs and incomes + (e.g. ``"Y"`` for yearly, ``"M"`` for monthly). Default is ``"Y"``. See [pandas documentation](https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#period-aliases). + Note that growth rates remain yearly, independently from the freq. custom_cash_flows : list of dict, optional Explicit cash flow schedule as a list of records with at minimum a ``"date"`` key (ISO 8601 string) and a value key. If provided, diff --git a/climada/entity/measures/test/test_cost_income.py b/climada/entity/measures/test/test_cost_income.py index 66ebdc5afc..ad95698dc7 100644 --- a/climada/entity/measures/test/test_cost_income.py +++ b/climada/entity/measures/test/test_cost_income.py @@ -55,11 +55,11 @@ def test_income_stored_positive(self): def test_mkt_price_year_default_is_current_year(self): ci = CostIncome() - assert ci.mkt_price_year.year == datetime.today().year + assert ci.mkt_price_year == datetime.today().year def test_mkt_price_year_custom(self): ci = CostIncome(mkt_price_year=2015) - assert ci.mkt_price_year.year == 2015 + assert ci.mkt_price_year == 2015 def test_custom_cash_flows_processed(self): df = pd.DataFrame( @@ -103,7 +103,7 @@ def test_defaults_for_missing_keys(self): assert ci.init_cost == 0.0 assert ci.freq == "Y" - def test_with_custom_cash_flows(self): + def test_with_custom_cash_flows_only(self): d = { "freq": "Y", "custom_cash_flows": [ @@ -133,29 +133,6 @@ def test_from_yaml(self, tmp_path): assert ci.periodic_income == 300.0 -# --------------------------------------------------------------------------- -# _freq_to_days -# --------------------------------------------------------------------------- - - -class TestFreqToDays: - def test_yearly(self): - result = CostIncome._freq_to_days("Y") - assert result == "365d" - - def test_monthly(self): - result = CostIncome._freq_to_days("M") - assert result == "30d" - - def test_daily(self): - result = CostIncome._freq_to_days("D") - assert result == "1d" - - def test_invalid(self): - with pytest.raises(ValueError): - CostIncome._freq_to_days("INVALID_FREQ_XYZ") - - # --------------------------------------------------------------------------- # _get_width_days # --------------------------------------------------------------------------- @@ -283,6 +260,38 @@ def test_nonzero_cost_income(self): income, [0.0, 0.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0] ) + def test_with_custom_cash_flows(self): + d = { + "freq": "Y", + "init_cost": 500, + "periodic_cost": 100, + "periodic_income": 200, + "custom_cash_flows": [ + {"date": "2021-01-01", "cost": 170, "income": 50}, + {"date": "2022-01-01", "cost": 180, "income": 50}, + {"date": "2025-01-01", "cost": 190, "income": 50}, + ], + } + ci = CostIncome.from_dict(d) + expected_net = np.array([0.0, -120.0, -630.0, 100, 100, -40]) + expected_costs = np.array([0.0, -170.0, -680.0, -100, -100, -290]) + expected_incomes = np.array( + [ + 0.0, + 50.0, + 50.0, + 200, + 200, + 250, + ] + ) + net, costs, incomes = ci.calc_cash_flows( + impl_date="2022", start_date="2020", end_date="2025" + ) + np.testing.assert_array_equal(net, expected_net) + np.testing.assert_array_equal(costs, expected_costs) + np.testing.assert_array_equal(incomes, expected_incomes) + # --------------------------------------------------------------------------- # calc_total @@ -387,9 +396,9 @@ def test_preserves_growth_rates(self): def test_merges_custom_cash_flows(self): df1 = pd.DataFrame( { - "date": ["2020-01-01", "2020-03-01"], - "cost": [100, 200], - "income": [50, 60], + "date": ["2019-11-01", "2020-01-01", "2020-03-01", "2020-05-01"], + "cost": [100, 200, 100, 50], + "income": [50, 60, 0, 0], } ) df2 = pd.DataFrame( @@ -402,9 +411,17 @@ def test_merges_custom_cash_flows(self): expected = pd.DataFrame( { - "date": ["2020-01", "2020-02", "2020-03", "2020-04"], - "cost": [-200, 0, -400, -300], - "income": [100, 0, 120, 70], + "date": [ + "2019-11", + "2019-12", + "2020-01", + "2020-02", + "2020-03", + "2020-04", + "2020-05", + ], + "cost": [-100, 0, -300, 0, -300, -300, -50], + "income": [50, 0, 110, 0, 60, 70, 0], } ) diff --git a/climada/hazard/forecast.py b/climada/hazard/forecast.py new file mode 100644 index 0000000000..836b4499a1 --- /dev/null +++ b/climada/hazard/forecast.py @@ -0,0 +1,544 @@ +""" +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 Forecast variant of Hazard. +""" + +import logging +import pathlib +from typing import Any, Dict, Literal, Optional + +import numpy as np +import xarray as xr +from packaging.version import Version +from scipy import sparse + +import climada.util.constants as u_const +from climada.hazard.base import Hazard +from climada.hazard.xarray import HazardXarrayReader +from climada.util.checker import size +from climada.util.forecast import ( + ForecastMixin, + reduce_unique_selection, + sparse_quantile_axis0, +) + +LOGGER = logging.getLogger(__name__) + +XARRAY_TIMEDELTA_BUG_BEGIN = Version("2025.04.0") +XARRAY_TIMEDELTA_BUG_END = Version("2025.07.0") + + +def xarray_has_timedelta_bug() -> bool: + """Return True if xarray contains the timedelta bug + + See https://docs.xarray.dev/en/stable/whats-new.html#id80 + """ + return (Version(xr.__version__) >= XARRAY_TIMEDELTA_BUG_BEGIN) and ( + Version(xr.__version__) < XARRAY_TIMEDELTA_BUG_END + ) + + +class HazardForecast(ForecastMixin, Hazard): + """A hazard object with forecast information""" + + def __init__( + self, + lead_time: np.ndarray | None = None, + member: np.ndarray | None = None, + **hazard_kwargs, + ): + """ + Initialize a HazardForecast object. + + Parameters + ---------- + lead_time : np.ndarray of np.timedelta64 or None, optional + Forecast lead times. Default is empty array. + member : np.ndarray or None, optional + Ensemble member identifiers as integers. Default is empty array. + **hazard_kwargs + keyword arguments to pass to :py:class:`~climada.hazard.base.Hazard` See + py:meth:`~climada.hazard.base.Hazard.__init__` for details. + """ + super().__init__(lead_time=lead_time, member=member, **hazard_kwargs) + self._check_sizes() + + @classmethod + def from_hazard(cls, hazard: Hazard, lead_time: np.ndarray, member: np.ndarray): + """ + Create a HazardForecast object from a Hazard object. + + Parameters + ---------- + hazard : Hazard + Hazard object to convert into a HazardForecast. + lead_time : np.ndarray of np.timedelta64 or None, optional + Forecast lead times. Default is empty array. + member : np.ndarray or None, optional + Ensemble member identifiers as integers. Default is empty array. + + Returns + ------- + HazardForecast + A HazardForecast object with the same attributes as the input hazard, + but with lead_time and member attributes set from instance of HazardForecast. + """ + return cls( + lead_time=lead_time, + member=member, + haz_type=hazard.haz_type, + pool=hazard.pool, + units=hazard.units, + centroids=hazard.centroids, + event_id=hazard.event_id, + frequency=hazard.frequency, + frequency_unit=hazard.frequency_unit, + orig=hazard.orig, + event_name=hazard.event_name, + date=hazard.date, + intensity=hazard.intensity, + fraction=hazard.fraction, + ) + + def _check_sizes(self): + """Check sizes of forecast data vs. hazard data. + + Raises + ------ + ValueError + If the sizes of the forecast data do not match the + :py:attr:`~climada.hazard.base.Hazard.event_id` + """ + num_entries = len(self.event_id) + size(exp_len=num_entries, var=self.member, var_name="Forecast.member") + size(exp_len=num_entries, var=self.lead_time, var_name="Forecast.lead_time") + + def min(self, dim: Literal["member", "lead_time"] | None = None): + """Reduce the intensity and fraction to the minimum value. + + Parameters + ---------- + dim : "member", "lead_time", or None + Dimension to reduce over. If None, reduce over all data. + + Returns + ------- + HazardForecast + A HazardForecast object with the min intensity and fraction. + + Warning + ------- + This reduces :py:attr:`~climada.hazard.base.Hazard.intensity` + and :py:attr:`~climada.hazard.base.Hazard.fraction` independently, possibly + leading to an inconsistent result: Reduced intensity and fraction values of a + single centroid might then originate from different events! + """ + if dim is not None: + rdim = self._reduce_iter_dim(dim) + return reduce_unique_selection(self, attr=rdim, reduce_method="min") + + red_intensity = self.intensity.min(axis=0).tocsr() + red_fraction = self.fraction.min(axis=0).tocsr() + return HazardForecast( + haz_type=self.haz_type, + pool=self.pool, + units=self.units, + centroids=self.centroids, + frequency_unit=self.frequency_unit, + intensity=red_intensity, + fraction=red_fraction, + **self._reduce_attrs("min"), + ) + + def max(self, dim: Literal["member", "lead_time"] | None = None): + """Reduce the intensity and fraction to the maximum value. + + Parameters + ---------- + dim : "member", "lead_time", or None + Dimension to reduce over. If None, reduce over all data. + + Returns + ------- + HazardForecast + A HazardForecast object with the max intensity and fraction. + + Warning + ------- + This reduces :py:attr:`~climada.hazard.base.Hazard.intensity` + and :py:attr:`~climada.hazard.base.Hazard.fraction` independently, possibly + leading to an inconsistent result: Reduced intensity and fraction values of a + single centroid might then originate from different events! + """ + if dim is not None: + rdim = self._reduce_iter_dim(dim) + return reduce_unique_selection(self, attr=rdim, reduce_method="max") + + red_intensity = self.intensity.max(axis=0).tocsr() + red_fraction = self.fraction.max(axis=0).tocsr() + return HazardForecast( + haz_type=self.haz_type, + pool=self.pool, + units=self.units, + centroids=self.centroids, + frequency_unit=self.frequency_unit, + intensity=red_intensity, + fraction=red_fraction, + **self._reduce_attrs("max"), + ) + + def mean(self, dim: Literal["member", "lead_time"] | None = None): + """Reduce the intensity and fraction to the mean value. + + Parameters + ---------- + dim : "member", "lead_time", or None + Dimension to reduce over. If None, reduce over all data. + + Returns + ------- + HazardForecast + A HazardForecast object with the mean intensity and fraction. + + Warning + ------- + This reduces :py:attr:`~climada.hazard.base.Hazard.intensity` + and :py:attr:`~climada.hazard.base.Hazard.fraction` independently, possibly + leading to an inconsistent result: Reduced intensity and fraction values of a + single centroid might then originate from different events! + """ + if dim is not None: + rdim = self._reduce_iter_dim(dim) + return reduce_unique_selection(self, attr=rdim, reduce_method="mean") + + red_intensity = sparse.csr_matrix(self.intensity.mean(axis=0)) + red_fraction = sparse.csr_matrix(self.fraction.mean(axis=0)) + return HazardForecast( + haz_type=self.haz_type, + pool=self.pool, + units=self.units, + centroids=self.centroids, + frequency_unit=self.frequency_unit, + intensity=red_intensity, + fraction=red_fraction, + **self._reduce_attrs("mean"), + ) + + def _quantile( + self, + q: float, + dim: Literal["member", "lead_time"] | None = None, + event_name: str | None = None, + ): + """Reduce intensity and fraction to the quantile value.""" + if dim is not None: + rdim = self._reduce_iter_dim(dim) + return reduce_unique_selection( + self, + attr=rdim, + reduce_method="quantile", + q=q, + ) + + red_intensity = sparse.csr_matrix(sparse_quantile_axis0(self.intensity, q)) + red_fraction = sparse.csr_matrix(sparse_quantile_axis0(self.fraction, q)) + if event_name is None: + event_name = f"quantile_{q}" + return HazardForecast( + haz_type=self.haz_type, + pool=self.pool, + units=self.units, + centroids=self.centroids, + frequency_unit=self.frequency_unit, + intensity=red_intensity, + fraction=red_fraction, + **self._reduce_attrs(event_name), + ) + + def quantile(self, q: float, dim: Literal["member", "lead_time"] | None = None): + """Reduce intensity and fraction to the quantile value. + + The quantile value is computed by taking the quantile of the impact matrix + along the event dimension axis (axis=0) and then taking the quantile of the + resulting array. + + Parameters + ---------- + q : float + The quantile to compute, between 0 and 1. + dim : "member", "lead_time", or None + The dimension to reduce when computing the quantile. If ``None`` (default), + this computes the centroid-wise quantile over the entire matrix. + + Returns + ------- + HazardForecast + A HazardForecast object with the quantile intensity and fraction. + + Warning + ------- + This reduces :py:attr:`~climada.hazard.base.Hazard.intensity` + and :py:attr:`~climada.hazard.base.Hazard.fraction` independently, possibly + leading to an inconsistent result: Reduced intensity and fraction values of a + single centroid might then originate from different events! + """ + return self._quantile(q=q, dim=dim) + + def median(self, dim: Literal["member", "lead_time"] | None = None): + """Reduce the intensity and fraction to the median value. + + The median value is computed by taking the median of the impact matrix along the + event dimension axis (axis=0) and then taking the median of the resulting array. + + Parameters + ---------- + dim : "member", "lead_time", or None + The dimension to reduce when computing the median. If ``None`` (default), + this computes the centroid-wise median over the entire matrix. + + Returns + ------- + HazardForecast + A HazardForecast object with the median intensity and fraction. + + Warning + ------- + This reduces :py:attr:`~climada.hazard.base.Hazard.intensity` + and :py:attr:`~climada.hazard.base.Hazard.fraction` independently, possibly + leading to an inconsistent result: Reduced intensity and fraction values of a + single centroid might then originate from different events! + """ + return self._quantile(q=0.5, event_name="median", dim=dim) + + @classmethod + def concat(cls, haz_list: list): + """Concatenate multiple HazardForecast instances and return a new object""" + if len(haz_list) == 0: + return cls() + hazard = Hazard.concat(haz_list) + lead_time = np.concatenate(tuple(haz.lead_time for haz in haz_list)) + member = np.concatenate(tuple(haz.member for haz in haz_list)) + return cls.from_hazard(hazard, lead_time=lead_time, member=member) + + def select( + self, + event_names=None, + event_id=None, + date=None, + orig=None, + reg_id=None, + extent=None, + reset_frequency=False, + member=None, + lead_time=None, + ): + """Select entries based on the parameters and return a new instance. + + The selection will contain the intersection of all given parameters. + + Parameters + ---------- + member : Sequence of ints + Ensemble members to select + lead_time : Sequence of numpy.timedelta64 + Lead times to select + + See Also + -------- + :py:meth:`~climada.hazard.base.Hazard.select` + """ + if member is not None or lead_time is not None: + mask_member = ( + self.idx_member(member) + if member is not None + else np.full_like(self.member, True, dtype=bool) + ) + mask_lead_time = ( + self.idx_lead_time(lead_time) + if lead_time is not None + else np.full_like(self.lead_time, True, dtype=bool) + ) + event_id_from_forecast_mask = np.asarray(self.event_id)[ + (mask_member & mask_lead_time) + ] + event_id = ( + np.intersect1d(event_id, event_id_from_forecast_mask) + if event_id is not None + else event_id_from_forecast_mask + ) + if event_id.size == 0: + raise ValueError( + "Empty selection for 'member', 'lead_time', and/or 'event_id'" + ) + + return super().select( + event_names=event_names, + event_id=event_id, + date=date, + orig=orig, + reg_id=reg_id, + extent=extent, + reset_frequency=reset_frequency, + ) + + @classmethod + def from_xarray_raster( + cls, + data: xr.Dataset | pathlib.Path | str, + hazard_type: str, + intensity_unit: str, + *, + intensity: Optional[str] = None, + coordinate_vars: Optional[Dict[str, str]] = None, + data_vars: Optional[Dict[str, str]] = None, + crs: str = u_const.DEF_CRS, + rechunk: bool = False, + open_dataset_kws: dict[str, Any] | None = None, + ): + """Read forecast hazard data from an xarray Dataset + + This extends the parent + :py:meth:`~climada.hazard.io.HazardIO.from_xarray_raster` to handle forecast + dimensions (lead_time and member). For forecast data, the "event" dimension is + constructed from the Cartesian product of lead_time and member dimensions, so + you don't need to specify an "event" coordinate. + + Parameters + ---------- + data : xarray.Dataset or Path or str + The filepath to read the data from or the already opened dataset + hazard_type : str + The type identifier of the hazard + intensity_unit : str + The physical units of the intensity + intensity : str, optional + Identifier of the DataArray containing the hazard intensity data + coordinate_vars : dict(str, str), optional + Mapping from default coordinate names to coordinate names in the data. + For HazardForecast, should include: + - ``"lead_time"``: name of the lead time coordinate (required) + - ``"member"``: name of the ensemble member coordinate (required) + - ``"longitude"``: name of longitude coordinate (default: "longitude") + - ``"latitude"``: name of latitude coordinate (default: "latitude") + + Note: The "event" coordinate is automatically constructed from lead_time + and member, so it should not be specified. + data_vars : dict(str, str), optional + Mapping from default variable names to variable names used in the data + to read. See :py:meth:`~climada.hazard.io.HazardIO.from_xarray_raster` for + details. To load forecast dates, map ``date`` to the corresponding + variable. Dates default to 0 when no date mapping is provided. + crs : str, optional + Coordinate reference system identifier. Defaults to "EPSG:4326". + rechunk : bool, optional + Rechunk the dataset before flattening. Defaults to ``False``. See + :py:meth:`~climada.hazard.io.HazardIO.from_xarray_raster` for details. + open_dataset_kws : dict, optional + Keyword arguments passed to xarray.open_dataset if data is a file path + + Returns + ------- + HazardForecast + A forecast hazard object with lead_time and member attributes populated + + See Also + -------- + :py:meth:`climada.hazard.io.HazardIO.from_xarray_raster` + Parent method documentation for standard hazard loading + """ + if xarray_has_timedelta_bug(): + LOGGER.warning( + "xarray version %s contains a bug that prevents proper timedelta " + "parsing. Consider updating to version %s or later, or downgrading to " + "before version %s", + xr.__version__, + XARRAY_TIMEDELTA_BUG_END, + XARRAY_TIMEDELTA_BUG_BEGIN, + ) + + # Open dataset if needed + if isinstance(data, (pathlib.Path, str)): + open_dataset_kws = open_dataset_kws or {} + open_dataset_kws = {"chunks": "auto"} | open_dataset_kws + dset = xr.open_dataset(data, **open_dataset_kws) + else: + dset = data + + if intensity is None: + data_var_names = list(dset.data_vars.keys()) + if len(data_var_names) == 0: + raise ValueError("Dataset has no data variables") + intensity = str(data_var_names[0]) + LOGGER.info( + "No intensity variable specified. Assuming intensity variable is '%s'", + intensity, + ) + + # Extract forecast coordinates + coordinate_vars = coordinate_vars or {} + for key in ["lead_time", "member"]: + if key not in coordinate_vars: + raise ValueError( + f"coordinate_vars must include '{key}' key. " + f"Available coordinates: {list(dset.coords.keys())}" + ) + leadtime_var = coordinate_vars["lead_time"] + member_var = coordinate_vars["member"] + + dset = dset.assign_coords( + event=( + (leadtime_var, member_var), + np.zeros((len(dset[leadtime_var]), len(dset[member_var]))), + ) + ) + + dset_squeezed = dset.squeeze() + + # Prepare coordinate_vars for parent call + parent_coord_vars = { + k: v for k, v in coordinate_vars.items() if k not in ["member", "lead_time"] + } + parent_coord_vars["event"] = "event" + + reader = HazardXarrayReader( + data=dset_squeezed, + coordinate_vars=parent_coord_vars, + intensity=intensity, + crs=crs, + data_vars=data_vars, + rechunk=rechunk, + ) + + kwargs = reader.get_hazard_kwargs() | { + "haz_type": hazard_type, + "units": intensity_unit, + "lead_time": reader.data_stacked[leadtime_var].to_numpy(), + "member": reader.data_stacked[member_var].to_numpy(), + } + + # Generate from lead_time/member + kwargs["event_name"] = [ + f"lt_{lt / np.timedelta64(1, 'h'):.0f}h_m_{m}" + for lt, m in zip(kwargs["lead_time"], kwargs["member"]) + ] + if not (data_vars or {}).get("date"): + kwargs["date"] = np.zeros_like(kwargs["date"], dtype=int) + + # Convert to HazardForecast with forecast attributes + return cls(**Hazard._check_and_cast_attrs(kwargs)) diff --git a/climada/hazard/io.py b/climada/hazard/io.py index 6f8bd01b09..03e608d050 100644 --- a/climada/hazard/io.py +++ b/climada/hazard/io.py @@ -917,6 +917,10 @@ def write_hdf5(self, file_name, todense=False): # Centroids have their own write_hdf5 method, # which is invoked at the end of this method (s.b.) continue + elif var_name == "lead_time": + hf_data.create_dataset( + var_name, data=var_val.astype("timedelta64[ns]").astype("int64") + ) elif isinstance(var_val, sparse.csr_matrix): if todense: hf_data.create_dataset(var_name, data=var_val.toarray()) @@ -987,7 +991,11 @@ def from_hdf5(cls, file_name): continue if var_name == "centroids": continue - if isinstance(var_val, np.ndarray) and var_val.ndim == 1: + if var_name == "lead_time": + hazard_kwargs[var_name] = np.array(hf_data.get(var_name)).astype( + "timedelta64[ns]" + ) + elif isinstance(var_val, np.ndarray) and var_val.ndim == 1: hazard_kwargs[var_name] = np.array(hf_data.get(var_name)) elif isinstance(var_val, sparse.csr_matrix): hf_csr = hf_data.get(var_name) diff --git a/climada/hazard/test/test_base.py b/climada/hazard/test/test_base.py index b4cbafd0e3..ea607893dd 100644 --- a/climada/hazard/test/test_base.py +++ b/climada/hazard/test/test_base.py @@ -46,27 +46,29 @@ """ +def hazard_kwargs(): + return { + "haz_type": "TC", + "pool": None, + "intensity": sparse.csr_matrix( + [[0.2, 0.3, 0.4], [0.1, 0.1, 0.01], [4.3, 2.1, 1.0], [5.3, 0.2, 0.0]] + ), + "fraction": sparse.csr_matrix( + [[0.02, 0.03, 0.04], [0.01, 0.01, 0.01], [0.3, 0.1, 0.0], [0.3, 0.2, 0.0]] + ), + "centroids": Centroids(lat=np.array([1, 3, 5]), lon=np.array([2, 4, 6])), + "event_id": np.array([1, 2, 3, 4]), + "event_name": ["ev1", "ev2", "ev3", "ev4"], + "date": np.array([1, 2, 3, 4]), + "orig": np.array([True, False, False, True]), + "frequency": np.array([0.1, 0.5, 0.5, 0.2]), + "frequency_unit": "1/week", + "units": "m/s", + } + + def dummy_hazard(): - fraction = sparse.csr_matrix( - [[0.02, 0.03, 0.04], [0.01, 0.01, 0.01], [0.3, 0.1, 0.0], [0.3, 0.2, 0.0]] - ) - intensity = sparse.csr_matrix( - [[0.2, 0.3, 0.4], [0.1, 0.1, 0.01], [4.3, 2.1, 1.0], [5.3, 0.2, 0.0]] - ) - - return Hazard( - "TC", - intensity=intensity, - fraction=fraction, - centroids=Centroids(lat=np.array([1, 3, 5]), lon=np.array([2, 4, 6])), - event_id=np.array([1, 2, 3, 4]), - event_name=["ev1", "ev2", "ev3", "ev4"], - date=np.array([1, 2, 3, 4]), - orig=np.array([True, False, False, True]), - frequency=np.array([0.1, 0.5, 0.5, 0.2]), - frequency_unit="1/week", - units="m/s", - ) + return Hazard(**hazard_kwargs()) class TestLoader(unittest.TestCase): diff --git a/climada/hazard/test/test_forecast.py b/climada/hazard/test/test_forecast.py new file mode 100644 index 0000000000..30e6c35165 --- /dev/null +++ b/climada/hazard/test/test_forecast.py @@ -0,0 +1,636 @@ +""" +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 Hazard Forecast. +""" + +import datetime as dt +from unittest.mock import patch + +import numpy as np +import numpy.testing as npt +import pandas as pd +import pytest +import xarray as xr +from scipy.sparse import csr_matrix + +from climada.hazard.base import Hazard +from climada.hazard.forecast import HazardForecast, xarray_has_timedelta_bug +from climada.hazard.test.test_base import hazard_kwargs +from climada.util.forecast import sparse_quantile_axis0 + +# See https://docs.xarray.dev/en/stable/whats-new.html#id80 +xarray_leadtime = pytest.mark.skipif( + xarray_has_timedelta_bug(), reason="xarray timedelta bug" +) + + +@pytest.fixture(scope="module") +def haz_kwargs(): + return hazard_kwargs() + + +@pytest.fixture +def hazard(haz_kwargs): + return Hazard(**haz_kwargs) + + +@pytest.fixture +def lead_time(haz_kwargs): + return pd.timedelta_range("1h", periods=len(haz_kwargs["event_id"])) + + +@pytest.fixture +def member(haz_kwargs): + return np.arange(len(haz_kwargs["event_id"])) + + +@pytest.fixture +def haz_fc(lead_time, member, haz_kwargs): + return HazardForecast( + lead_time=lead_time, + member=member, + **haz_kwargs, + ) + + +def assert_hazard_kwargs(hazard: Hazard, **kwargs): + for key, value in kwargs.items(): + attr = getattr(hazard, key) + if isinstance(value, (np.ndarray, list)): + npt.assert_array_equal(attr, value) + elif isinstance(value, csr_matrix): + npt.assert_array_equal(attr.todense(), value.todense()) + else: + assert attr == value + + +def test_init_hazard_forecast(haz_fc, member, lead_time, haz_kwargs): + assert isinstance(haz_fc, HazardForecast) + npt.assert_array_equal(haz_fc.lead_time, lead_time) + assert haz_fc.lead_time.dtype == lead_time.dtype + npt.assert_array_equal(haz_fc.member, member) + assert_hazard_kwargs(haz_fc, **haz_kwargs) + + +def test_init_hazard_forecast_error(hazard, member, lead_time, haz_kwargs): + with pytest.raises(ValueError, match="Forecast.lead_time"): + HazardForecast(lead_time=lead_time[:-2], member=member, **haz_kwargs) + with pytest.raises(ValueError, match="Forecast.member"): + HazardForecast.from_hazard(hazard, lead_time=lead_time, member=member[1:]) + + +def test_from_hazard(lead_time, member, hazard, haz_kwargs): + haz_fc_from_haz = HazardForecast.from_hazard( + hazard, lead_time=lead_time, member=member + ) + assert isinstance(haz_fc_from_haz, HazardForecast) + npt.assert_array_equal(haz_fc_from_haz.lead_time, lead_time) + npt.assert_array_equal(haz_fc_from_haz.member, member) + assert_hazard_kwargs(haz_fc_from_haz, **haz_kwargs) + + +class TestHazardForecastConcat: + def test_concat(self, haz_fc, lead_time, member, haz_kwargs): + haz_fc1 = haz_fc.select(event_id=[3]) + haz_fc2 = HazardForecast( + haz_type=haz_kwargs["haz_type"], frequency_unit=haz_kwargs["frequency_unit"] + ) # Empty hazard + haz_fc3 = haz_fc.select(event_id=[1, 2]) + haz_fc_concat = HazardForecast.concat([haz_fc1, haz_fc2, haz_fc3]) + assert isinstance(haz_fc_concat, HazardForecast) + npt.assert_array_equal( + haz_fc_concat.lead_time, np.concatenate((lead_time[2:3], lead_time[0:2])) + ) + npt.assert_array_equal( + haz_fc_concat.member, np.concatenate((member[2:3], member[0:2])) + ) + npt.assert_array_equal(haz_fc_concat.event_id, [3, 1, 2]) + + def test_empty_list(self): + haz_concat = HazardForecast.concat([]) + assert isinstance(haz_concat, HazardForecast) + assert haz_concat.size == 0 + npt.assert_array_equal(haz_concat.lead_time, []) + npt.assert_array_equal(haz_concat.event_id, []) + + def test_type_fail(self, haz_fc, hazard): + with pytest.raises(TypeError, match="different classes"): + HazardForecast.concat([haz_fc, hazard]) + with pytest.raises(TypeError, match="different classes"): + Hazard.concat([haz_fc, hazard]) + + +class TestXarrayReader: + @pytest.fixture() + def forecast_netcdf_file(self, tmp_path_factory): + """Create a NetCDF file with forecast data structure""" + tmpdir = tmp_path_factory.mktemp("forecast_data") + netcdf_path = tmpdir / "forecast_data.nc" + + crs = "EPSG:4326" + + n_eps = 5 + n_lead_time = 4 + n_lat = 3 + n_lon = 4 + + eps = np.array([3, 8, 13, 16, 20]) + ref_time = np.array([dt.datetime(2025, 12, 8, 6, 0, 0)], dtype="datetime64[ns]") + lead_time_vals = pd.timedelta_range( + "3h", periods=n_lead_time, freq="2h" + ).to_numpy() + lon = np.array([10.0, 10.5, 11.0, 11.5]) + lat = np.array([45.0, 45.5, 46.0]) + + valid_time = ref_time[0] + lead_time_vals + + np.random.seed(42) + intensity = np.random.rand(n_eps, 1, n_lead_time, n_lat, n_lon) * 10 + + # Create xarray Dataset + dset = xr.Dataset( + { + "__xarray_dataarray_variable__": ( + ["eps", "ref_time", "lead_time", "lat", "lon"], + intensity, + ), + }, + coords={ + "eps": eps, + "ref_time": ref_time, + "lead_time": lead_time_vals, + "lon": lon, + "lat": lat, + "valid_time": (["lead_time"], valid_time), + }, + ) + dset.to_netcdf(netcdf_path) + + return { + "path": netcdf_path, + "n_eps": n_eps, + "n_lead_time": n_lead_time, + "n_lat": n_lat, + "n_lon": n_lon, + "eps": eps, + "ref_time": ref_time[0], + "lead_time": lead_time_vals, + "lon": lon, + "lat": lat, + "crs": crs, + } + + @xarray_leadtime + def test_from_xarray_raster_basic(self, forecast_netcdf_file): + """Test basic loading of forecast hazard from xarray""" + haz_fc = HazardForecast.from_xarray_raster( + forecast_netcdf_file["path"], + hazard_type="PR", + intensity_unit="mm/h", + coordinate_vars={ + "longitude": "lon", + "latitude": "lat", + "lead_time": "lead_time", + "member": "eps", + }, + ) + + # Check that it's a HazardForecast instance + assert isinstance(haz_fc, HazardForecast) + + # Check dimensions - after stacking, we should have n_eps * n_lead_time events + expected_n_events = ( + forecast_netcdf_file["n_eps"] * forecast_netcdf_file["n_lead_time"] + ) + assert len(haz_fc.event_id) == expected_n_events + assert len(haz_fc.lead_time) == expected_n_events + assert len(haz_fc.member) == expected_n_events + + # Check that lead_time and member are correctly extracted + npt.assert_array_equal(np.unique(haz_fc.member), forecast_netcdf_file["eps"]) + + # Check intensity shape (events x centroids) + expected_n_centroids = ( + forecast_netcdf_file["n_lat"] * forecast_netcdf_file["n_lon"] + ) + assert haz_fc.intensity.shape == (expected_n_events, expected_n_centroids) + + # Check centroids + lat, lon = np.meshgrid( + forecast_netcdf_file["lat"], forecast_netcdf_file["lon"], indexing="ij" + ) + np.testing.assert_array_equal(haz_fc.centroids.lat, lat.flatten()) + np.testing.assert_array_equal(haz_fc.centroids.lon, lon.flatten()) + + @xarray_leadtime + def test_from_xarray_raster_event_names(self, forecast_netcdf_file): + """Test that event names are auto-generated from lead_time and member""" + haz_fc = HazardForecast.from_xarray_raster( + forecast_netcdf_file["path"], + hazard_type="PR", + intensity_unit="mm/h", + coordinate_vars={ + "longitude": "lon", + "latitude": "lat", + "lead_time": "lead_time", + "member": "eps", + }, + crs=forecast_netcdf_file["crs"], + ) + + # Check that event names are generated with lead_time in hours + expected_n_events = ( + forecast_netcdf_file["n_eps"] * forecast_netcdf_file["n_lead_time"] + ) + assert len(haz_fc.event_name) == expected_n_events + + event_names_expected = [ + f"lt_{lt / np.timedelta64(1, 'h'):.0f}h_m_{mm}" + for lt, mm in zip(haz_fc.lead_time, haz_fc.member) + ] + npt.assert_array_equal(haz_fc.event_name, event_names_expected) + + @pytest.mark.parametrize("data_vars", [None, {"date": ""}]) + @xarray_leadtime + def test_from_xarray_raster_dates(self, forecast_netcdf_file, data_vars): + """Test that dates default to 0 when no date coordinate is mapped""" + haz_fc = HazardForecast.from_xarray_raster( + forecast_netcdf_file["path"], + hazard_type="PR", + intensity_unit="mm/h", + coordinate_vars={ + "longitude": "lon", + "latitude": "lat", + "lead_time": "lead_time", + "member": "eps", + }, + data_vars=data_vars, + crs=forecast_netcdf_file["crs"], + ) + + # Check that all dates are 0 (undefined for forecast) + expected_n_events = ( + forecast_netcdf_file["n_eps"] * forecast_netcdf_file["n_lead_time"] + ) + npt.assert_array_equal(haz_fc.date, np.zeros(expected_n_events, dtype=int)) + + @xarray_leadtime + def test_from_xarray_raster_dates_from_data(self, forecast_netcdf_file): + """Test that an explicitly mapped date coordinate is preserved""" + haz_fc = HazardForecast.from_xarray_raster( + forecast_netcdf_file["path"], + hazard_type="PR", + intensity_unit="mm/h", + coordinate_vars={ + "longitude": "lon", + "latitude": "lat", + "lead_time": "lead_time", + "member": "eps", + }, + data_vars={"date": "valid_time"}, + crs=forecast_netcdf_file["crs"], + ) + + expected_dates = [ + pd.Timestamp(forecast_netcdf_file["ref_time"] + lead_time).toordinal() + for lead_time in haz_fc.lead_time + ] + npt.assert_array_equal(haz_fc.date, expected_dates) + + +class TestSelect: + @pytest.mark.parametrize( + "var, var_select", + [("event_id", "event_id"), ("event_name", "event_names"), ("date", "date")], + ) + def test_base_class_select( + self, haz_fc, lead_time, member, haz_kwargs, var, var_select + ): + """Check if Hazard.select works on the derived class""" + + select_mask = np.array([3, 1]) + result_select_mask = select_mask + if var == "date": + # Input to 'date' is begin and end date in order + select_mask = np.array([1, 3]) + result_select_mask = np.array([1, 2, 3]) + + var_value = np.array(haz_kwargs[var])[select_mask] + # event_name is a list, convert to numpy array for indexing + haz_fc_sel = haz_fc.select(**{var_select: var_value}) + # Note: order is preserved + npt.assert_array_equal( + haz_fc_sel.event_id, + haz_fc.event_id[result_select_mask], + ) + npt.assert_array_equal( + haz_fc_sel.event_name, + np.array(haz_fc.event_name)[result_select_mask], + ) + npt.assert_array_equal(haz_fc_sel.date, haz_fc.date[result_select_mask]) + npt.assert_array_equal( + haz_fc_sel.frequency, haz_fc.frequency[result_select_mask] + ) + npt.assert_array_equal(haz_fc_sel.member, member[result_select_mask]) + npt.assert_array_equal(haz_fc_sel.lead_time, lead_time[result_select_mask]) + npt.assert_array_equal( + haz_fc_sel.intensity.todense(), + haz_fc.intensity.todense()[result_select_mask], + ) + npt.assert_array_equal( + haz_fc_sel.fraction.todense(), + haz_fc.fraction.todense()[result_select_mask], + ) + + assert haz_fc_sel.centroids == haz_fc.centroids + + def test_derived_select_single(self, haz_fc, lead_time, member): + haz_fc_select = haz_fc.select(member=[3, 0]) + idx = np.array([0, 3]) + npt.assert_array_equal(haz_fc_select.event_id, haz_fc.event_id[idx]) + npt.assert_array_equal(haz_fc_select.member, member[idx]) + npt.assert_array_equal(haz_fc_select.lead_time, lead_time[idx]) + + haz_fc_select = haz_fc.select(lead_time=lead_time[np.array([3, 0])]) + npt.assert_array_equal(haz_fc_select.event_id, haz_fc.event_id[idx]) + npt.assert_array_equal(haz_fc_select.member, member[idx]) + npt.assert_array_equal(haz_fc_select.lead_time, lead_time[idx]) + + def test_derived_select_intersections(self, haz_fc, lead_time, member, haz_kwargs): + haz_fc_select = haz_fc.select(event_id=[1, 4], member=[0, 1, 2]) + npt.assert_array_equal(haz_fc_select.event_id, haz_fc.event_id[np.array([0])]) + + haz_fc_select = haz_fc.select( + event_id=[1, 2, 4], member=[0, 1, 2], lead_time=lead_time[1:3] + ) + npt.assert_array_equal(haz_fc_select.event_id, haz_fc.event_id[np.array([1])]) + + # Test "outer" + haz_fc2 = HazardForecast( + lead_time=lead_time, member=np.zeros_like(member, dtype="int"), **haz_kwargs + ) + haz_fc_select = haz_fc2.select(event_id=[1, 2, 4], member=[0]) + npt.assert_array_equal(haz_fc_select.event_id, [1, 2, 4]) + npt.assert_array_equal(haz_fc_select.member, [0, 0, 0]) + + def test_derived_select_null(self, haz_fc, haz_kwargs): + haz_fc_select = haz_fc.select() + assert_hazard_kwargs(haz_fc_select, **haz_kwargs) + + with pytest.raises(IndexError): + haz_fc.select(event_id=[-1]) + with pytest.raises(IndexError): + haz_fc.select(event_id=[]) + with pytest.raises(ValueError, match="Empty selection"): + haz_fc.select(member=[-1]) + with pytest.raises(ValueError, match="Empty selection"): + haz_fc.select( + lead_time=[np.timedelta64("2", "Y").astype("timedelta64[ns]")] + ) + + +def test_write_read_hazard_forecast(haz_fc, tmp_path): + + file_name = tmp_path / "test_hazard_forecast.h5" + + haz_fc.write_hdf5(file_name) + haz_fc_read = HazardForecast.from_hdf5(file_name) + + assert haz_fc_read.lead_time.dtype.kind == np.dtype("timedelta64").kind + + for key in haz_fc.__dict__.keys(): + if key in ["intensity", "fraction"]: + (haz_fc.__dict__[key] != haz_fc_read.__dict__[key]).nnz == 0 + else: + # npt.assert_array_equal also works for comparing int, float or list + npt.assert_array_equal(haz_fc.__dict__[key], haz_fc_read.__dict__[key]) + + +class TestReduce: + @pytest.fixture + def mat(self): + return np.array([[0, -1, 0], [1, 0, 0], [2, 1, 0], [3, 2, 1]], dtype="float") + + @pytest.fixture(autouse=True) + def haz_fc_custom_intensity_fraction(self, mat, haz_fc): + haz_fc.intensity = csr_matrix(mat) + haz_fc.fraction = csr_matrix(mat) + + @pytest.fixture + def haz_fc_dim_reduce(self, haz_fc): + """Create hazard forecast where some members/leadtimes are duplicated""" + haz_fc.member = np.array([1, 2, 1, 2]) + haz_fc.lead_time = np.array( + [ + np.timedelta64(1, "h"), + np.timedelta64(1, "h"), + np.timedelta64(2, "h"), + np.timedelta64(2, "h"), + ] + ) + return haz_fc + + @pytest.fixture + def q(self): + """Quantile to test""" + return 0.25 + + @pytest.fixture + def reduction_results(self): + return { + "min": [0, -1, 0], + "mean": [1.5, 0.5, 0.25], + "max": [3, 2, 1], + "median": [1.5, 0.5, 0.0], + "quantile": [0.75, -0.25, 0.0], + } + + @pytest.fixture + def reduction_results_dim(self): + return { + "lead_time": { + "min": [[0, -1, 0], [1, 0, 0]], + "mean": [[1, 0, 0], [2, 1, 0.5]], + "median": [[1, 0, 0], [2, 1, 0.5]], + "max": [[2, 1, 0], [3, 2, 1]], + "quantile": [[0.5, -0.5, 0], [1.5, 0.5, 0.25]], + }, + "member": { + "min": [[0, -1, 0], [2, 1, 0]], + "mean": [[0.5, -0.5, 0], [2.5, 1.5, 0.5]], + "median": [[0.5, -0.5, 0], [2.5, 1.5, 0.5]], + "max": [[1, 0, 0], [3, 2, 1]], + "quantile": [[0.25, -0.75, 0], [2.25, 1.25, 0.25]], + }, + } + + @pytest.mark.parametrize("attr", ["min", "mean", "max", "quantile", "median"]) + def test_reduce(self, haz_fc, q, reduction_results, attr): + """Check reduction methods for HazardForecast""" + kwargs = {"q": q} if attr == "quantile" else {} + haz_fcst_reduced = getattr(haz_fc, attr)(**kwargs) + + # Test by checking results + npt.assert_array_equal( + haz_fcst_reduced.intensity.toarray().squeeze(), reduction_results[attr] + ) + npt.assert_array_equal( + haz_fcst_reduced.fraction.toarray().squeeze(), reduction_results[attr] + ) + + # Test by calling the same numpy function on the dense array + npt.assert_array_equal( + haz_fcst_reduced.intensity.toarray().squeeze(), + getattr(np, attr)(haz_fc.intensity.toarray(), axis=0, **kwargs), + ) + npt.assert_array_equal( + haz_fcst_reduced.fraction.toarray().squeeze(), + getattr(np, attr)(haz_fc.fraction.toarray(), axis=0, **kwargs), + ) + + # Check that attributes where reduced correctly + attr_str = f"quantile_{q}" if attr == "quantile" else attr + npt.assert_array_equal(haz_fcst_reduced.lead_time, [np.timedelta64("NaT")]) + npt.assert_array_equal(haz_fcst_reduced.member, [-1]) + npt.assert_array_equal(haz_fcst_reduced.event_name, [attr_str]) + npt.assert_array_equal(haz_fcst_reduced.event_id, [1]) + npt.assert_array_equal(haz_fcst_reduced.frequency, [1]) + npt.assert_array_equal(haz_fcst_reduced.date, [0]) + npt.assert_array_equal(haz_fcst_reduced.orig, [True]) + + @pytest.mark.parametrize("quantile,reduce", [(0.0, "min"), (1.0, "max")]) + def test_quantile_min_max(self, haz_fc, quantile, reduce): + """Compare min/max with quantiles 0/1""" + haz_fcst_quantile = haz_fc.quantile(q=quantile) + haz_fcst_reduce = getattr(haz_fc, reduce)() + npt.assert_array_equal( + haz_fcst_quantile.intensity.todense(), haz_fcst_reduce.intensity.todense() + ) + + def test_median_quantile(self, haz_fc): + """Compare median with quantile 0.5""" + haz_fcst_median = haz_fc.median() + haz_fcst_quantile = haz_fc.quantile(q=0.5) + npt.assert_array_equal( + haz_fcst_median.intensity.todense(), haz_fcst_quantile.intensity.todense() + ) + npt.assert_array_equal( + haz_fcst_median.intensity.todense(), + np.median(haz_fc.intensity.todense(), axis=0), + ) + + def test_quantile_uses_block_wise_helper(self, haz_fc): + """quantile passes intensity and fraction themselves to the block-wise helper""" + # wraps, so the real helper still runs and the result stays checkable + with patch( + "climada.hazard.forecast.sparse_quantile_axis0", + wraps=sparse_quantile_axis0, + ) as helper: + reduced = haz_fc.quantile(0.5) + + assert helper.call_count == 2 + intensity_call, fraction_call = helper.call_args_list + assert intensity_call.args[0] is haz_fc.intensity + assert fraction_call.args[0] is haz_fc.fraction + assert intensity_call.args[1] == fraction_call.args[1] == 0.5 + npt.assert_array_equal( + reduced.intensity.toarray().squeeze(), + np.quantile(haz_fc.intensity.toarray(), 0.5, axis=0), + ) + + @pytest.mark.parametrize("attr", ["min", "mean", "max", "median", "quantile"]) + @pytest.mark.parametrize("dim", ["lead_time", "member", "single"]) + def test_reduce_dim_unique_or_single(self, haz_fc, q, attr, dim): + """Test that reduction over a dimension with all-unique values does nothing""" + kwargs = {"q": q} if attr == "quantile" else {} + if dim == "single": + haz_fc = haz_fc.select(event_id=[haz_fc.event_id[0]]) + dim = None + + haz_fc_reduced = getattr(haz_fc, attr)(dim=dim, **kwargs) + + npt.assert_array_equal(haz_fc_reduced.member, haz_fc.member) + npt.assert_array_equal(haz_fc_reduced.lead_time, haz_fc.lead_time) + npt.assert_array_equal( + haz_fc_reduced.intensity.todense(), haz_fc.intensity.todense() + ) + npt.assert_array_equal( + haz_fc_reduced.fraction.todense(), haz_fc.fraction.todense() + ) + if dim == "single": + npt.assert_array_equal(haz_fc_reduced.event_name, haz_fc.event_name) + npt.assert_array_equal(haz_fc_reduced.event_id, haz_fc.event_id) + npt.assert_array_equal(haz_fc_reduced.frequency, haz_fc.frequency) + npt.assert_array_equal(haz_fc_reduced.date, haz_fc.date) + npt.assert_array_equal(haz_fc_reduced.orig, haz_fc.orig) + + @pytest.mark.parametrize("attr", ["min", "mean", "max", "quantile", "median"]) + def test_reduce_dim_error(self, haz_fc, q, attr): + """Check reduction error message for invalid dimension name""" + kwargs = {"q": q} if attr == "quantile" else {} + with pytest.raises(ValueError, match=r"Cannot reduce over dim \'invalid_dim\'"): + getattr(haz_fc, attr)(dim="invalid_dim", **kwargs) + + @pytest.mark.parametrize("attr", ["min", "mean", "max", "median", "quantile"]) + @pytest.mark.parametrize("dim", ["lead_time", "member"]) + def test_reduce_dim(self, haz_fc_dim_reduce, q, reduction_results_dim, attr, dim): + """Check reduction for HazardForecast with dim argument""" + kwargs = {"q": q} if attr == "quantile" else {} + haz_fc_reduced = getattr(haz_fc_dim_reduce, attr)(dim=dim, **kwargs) + + rdim = "member" if dim == "lead_time" else "lead_time" + unique_rdim = np.unique(getattr(haz_fc_dim_reduce, rdim)) + npt.assert_array_equal(getattr(haz_fc_reduced, rdim), unique_rdim) + + if dim == "lead_time": + unique_rdim = [1, 2] + npt.assert_array_equal( + haz_fc_reduced.lead_time, [np.timedelta64("NaT"), np.timedelta64("NaT")] + ) + npt.assert_array_equal(haz_fc_reduced.member, unique_rdim) + else: + unique_rdim = [np.timedelta64(1, "h"), np.timedelta64(2, "h")] + npt.assert_array_equal( + haz_fc_reduced.lead_time, + unique_rdim, + ) + npt.assert_array_equal(haz_fc_reduced.member, [-1, -1]) + + haz_fc_expected = haz_fc_dim_reduce.concat( + [ + getattr(haz_fc_dim_reduce.select(**{rdim: val}), attr)( + dim=None, **kwargs + ) + for val in unique_rdim + ] + ) + npt.assert_array_equal( + haz_fc_reduced.intensity.toarray().squeeze(), + reduction_results_dim[dim][attr], + ) + npt.assert_array_equal( + haz_fc_reduced.fraction.toarray().squeeze(), + reduction_results_dim[dim][attr], + ) + npt.assert_array_equal( + haz_fc_reduced.intensity.todense(), haz_fc_expected.intensity.todense() + ) + npt.assert_array_equal( + haz_fc_reduced.fraction.todense(), haz_fc_expected.fraction.todense() + ) diff --git a/climada/hazard/test/test_tc_tracks.py b/climada/hazard/test/test_tc_tracks.py index 1dbf615c21..52535c34c7 100644 --- a/climada/hazard/test/test_tc_tracks.py +++ b/climada/hazard/test/test_tc_tracks.py @@ -60,7 +60,7 @@ "basin": ("time", ["NA", "NA", "NA", "NA"]), }, coords={ - "time": ("time", pd.date_range("2025-01-01", periods=4, freq="12H")), + "time": ("time", pd.date_range("2025-01-01", periods=4, freq="12h")), "lat": ("time", [-90, -89, -88, -87]), "lon": ("time", [-179, -169, -159, -149]), }, diff --git a/climada/hazard/xarray.py b/climada/hazard/xarray.py index 95b20eee5e..d9e90e47ee 100644 --- a/climada/hazard/xarray.py +++ b/climada/hazard/xarray.py @@ -94,7 +94,10 @@ def _date_to_ordinal_accessor(array: xr.DataArray, strict: bool = True) -> np.nd return _strict_positive_int_accessor(array) # Try transforming to ordinals - return np.array(u_dt.datetime64_to_ordinal(array.to_numpy())) + arr = array.to_numpy() + if arr.ndim == 0: + arr = np.array([arr]) + return np.array(u_dt.datetime64_to_ordinal(arr)) # Handle access errors except (ValueError, TypeError, AttributeError) as err: @@ -240,6 +243,9 @@ class HazardXarrayReader: ---------- data : xr.Dataset The data to be read as hazard. + data_stacked : xr.Dataset + The internally stacked (vectorized) version of ``data``. Only available after + calling :py:meth:`get_hazard_kwargs`. intensity : str The name of the variable containing the hazard intensity information. Default: ``"intensity"`` @@ -256,6 +262,7 @@ class HazardXarrayReader: """ data: xr.Dataset + data_stacked: xr.Dataset = field(init=False) intensity: str = "intensity" coordinate_vars: InitVar[dict[str, str] | None] = field(default=None, kw_only=True) data_vars: dict[str, str] | None = field(default=None, kw_only=True) @@ -346,7 +353,7 @@ def get_hazard_kwargs(self) -> dict[str, Any]: # preserve order. However, we want longitude to run faster than latitude. # So we use 'dict' without values, as 'dict' preserves insertion order # (dict keys behave like a set). - data = data.stack( + self.data_stacked = data.stack( event=self.data_dims["event"], lat_lon=list( dict.fromkeys( @@ -357,20 +364,20 @@ def get_hazard_kwargs(self) -> dict[str, Any]: # Transform coordinates into centroids centroids = Centroids( - lat=data[self.coords["latitude"]].to_numpy(), - lon=data[self.coords["longitude"]].to_numpy(), + lat=self.data_stacked[self.coords["latitude"]].to_numpy(), + lon=self.data_stacked[self.coords["longitude"]].to_numpy(), crs=self.crs, ) # Read the intensity data LOGGER.debug("Loading Hazard intensity from DataArray '%s'", self.intensity) - intensity_matrix = _to_csr_matrix(data[self.intensity]) + intensity_matrix = _to_csr_matrix(self.data_stacked[self.intensity]) # Create a DataFrame storing access information for each of data_vars # NOTE: Each row will be passed as arguments to # `load_from_xarray_or_return_default`, see its docstring for further # explanation of the DataFrame columns / keywords. - num_events = data.sizes["event"] + num_events = self.data_stacked.sizes["event"] data_ident = pd.DataFrame( data={ # The attribute of the Hazard class where the data will be stored @@ -386,10 +393,12 @@ def get_hazard_kwargs(self) -> dict[str, Any]: np.array(range(num_events), dtype=int) + 1, list( _year_month_day_accessor( - data[self.coords["event"]], strict=False + self.data_stacked[self.coords["event"]], strict=False ).flat ), - _date_to_ordinal_accessor(data[self.coords["event"]], strict=False), + _date_to_ordinal_accessor( + self.data_stacked[self.coords["event"]], strict=False + ), ], # The accessor for the data in the Dataset "accessor": [ @@ -413,10 +422,11 @@ def get_hazard_kwargs(self) -> dict[str, Any]: # Set the Hazard attributes for _, ident in data_ident.iterrows(): self.hazard_kwargs[ident["hazard_attr"]] = ( - _load_from_xarray_or_return_default(data=data, **ident) + _load_from_xarray_or_return_default(data=self.data_stacked, **ident) ) # Done! + LOGGER.debug("Hazard successfully loaded. Number of events: %i", num_events) self.hazard_kwargs.update(centroids=centroids, intensity=intensity_matrix) return self.hazard_kwargs diff --git a/climada/util/constants.py b/climada/util/constants.py index 90f352218b..c338c4e4c4 100644 --- a/climada/util/constants.py +++ b/climada/util/constants.py @@ -45,11 +45,6 @@ import matplotlib as mpl -# pylint: disable=unused-import -# without importing numpy ahead of fiona the debugger may run into an error -import numpy -from fiona.crs import from_epsg - from .config import CONFIG SYSTEM_DIR = CONFIG.local_data.system.dir(create=False) @@ -212,9 +207,6 @@ DEF_CRS = f"EPSG:{DEF_EPSG}" """Default coordinate reference system WGS 84, str, for pyproj and rasterio CRS.from_string()""" -DEF_CRS_FIONA = from_epsg(DEF_EPSG) -"""Default coordinate reference system WGS 84, dict, for fiona interface""" - cm_data1 = [ [0.00000000, 0.00000000, 0.00000000], [0.00032031, 0.00020876, 0.00015576], diff --git a/climada/util/forecast.py b/climada/util/forecast.py new file mode 100644 index 0000000000..993c9c88b3 --- /dev/null +++ b/climada/util/forecast.py @@ -0,0 +1,254 @@ +""" +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 ForecastMixin class. +""" + +from typing import Any, Literal, Mapping + +import numpy as np +from scipy import sparse + + +class ForecastMixin: + """Mixin class for forecast data. + + Attributes + ---------- + lead_time : np.ndarray + Array of forecast lead times, given as timedelta64 objects. + Represents the lead times of the forecasts. + member : np.ndarray + Array of ensemble member identifiers, given as integers. + Represents different forecast ensemble members. + """ + + def __init__( + self, + lead_time: np.ndarray | None = None, + member: np.ndarray | None = None, + **kwargs, + ): + """Initialize Forecast. + + Parameters + ---------- + lead_time : np.ndarray or None, optional + Forecast lead times. Default is empty array. + member : np.ndarray or None, optional + Ensemble member identifiers. Default is empty array. + """ + + self.lead_time = ( + np.asarray(lead_time) + if lead_time is not None + else np.array([], dtype="timedelta64[ns]") + ) + self.member = ( + np.asarray(member) if member is not None else np.array([], dtype="int") + ) + super().__init__(**kwargs) + + def idx_member(self, member: np.ndarray) -> np.ndarray: + """Return boolean array where self.member == member using numpy.isin() + + Parameters + ---------- + member : np.ndarray + Array of ensemble members (ints) for which to return an indexer + + Returns + ------- + np.ndarray + Boolean array where self.member is in member. + """ + + return np.isin(self.member, member) + + def idx_lead_time(self, lead_time: np.ndarray) -> np.ndarray: + """Return boolean array where self.lead_time == lead_time using numpy.isin() + + Parameters + ---------- + lead_time : np.ndarray + Array of lead times (numpy.timedelta64) for which to return an indexer + + Returns + ------- + np.ndarray + Boolean array where self.lead_time is in lead_time. + """ + + return np.isin(self.lead_time, lead_time) + + def _unique_or_default( + self, attr: str, default: np.typing.ArrayLike + ) -> np.typing.ArrayLike: + """Return the single unique value of an attribute or the default value""" + try: + if len(unique := np.unique(getattr(self, attr))) == 1: + return unique + except AttributeError: + pass + return default + + def _reduce_iter_dim( + self, dim: Literal["member", "lead_time"] + ) -> Literal["lead_time", "member"]: + """Return the dimension to iterate over when reducing over 'dim'""" + if dim == "member": + return "lead_time" + if dim == "lead_time": + return "member" + raise ValueError(f"Cannot reduce over dim '{dim}'") + + def _reduce_attrs(self, event_name: str, **attrs) -> dict[str, np.ndarray | list]: + """ + Reduce the attributes of a Forecast derived object to a single value. + + Attributes are modified as follows: + - lead_time: set to NaT + - member: set to -1 + - event_id: set to 0 + - event_name: set to the name of the reduction method (default) + - date: set to 0 + - frequency: set to 1 + + Parameters + ---------- + event_name : str + The event_name given to the reduced data. + """ + reduced_attrs = { + "lead_time": self._unique_or_default("lead_time", [np.timedelta64("NaT")]), + "member": self._unique_or_default("member", [-1]), + "event_id": self._unique_or_default("event_id", [1]), + "event_name": self._unique_or_default("event_name", [event_name]), + "date": self._unique_or_default("date", [0]), + "frequency": [1], + "orig": self._unique_or_default("orig", [True]), + } | attrs + + # Filter out attributes that the derived object does not have + reduced_attrs = { + key: np.asarray(val) + for key, val in reduced_attrs.items() + if key in self.__dict__ + } + reduced_attrs["event_name"] = reduced_attrs["event_name"].tolist() + + return reduced_attrs + + +def reduce_unique_selection( + forecast, + attr: str, + reduce_method: str, + *, + select_kwarg: str | None = None, + concat_kws: Mapping[str, Any] | None = None, + **kwargs, +): + """Select unique values of an attribute and perform a reduction over each selection. + + Parameters + ---------- + forecast : HazardForecast | ImpactForecast + Forecast object to reduce. + attr : str + Attribute to draw values for which to select and reduce the attribute. + reduce_method : str + Name of the attribute reduction method to call (e.g. 'min', 'mean'). + select_kwarg : str | None + Keyword argument to the select method (e.g. 'lead_time', 'member') of the + forecast object. If ``None`` (default), the value of ``attr`` is used. This + parameter exists because some parameters to select methods are called + differently than the corresponding attributes. + concat_kws + Mapping of keyword arguments to the concat method of the forecast. + kwargs + Keyword arguments to the reduction method. + + Returns + ------- + ForecastMixin + Forecast object with the attribute reduced by the reduction method + and selected by the unique values. + """ + concat_kws = {} if concat_kws is None else concat_kws + select_kwarg = attr if select_kwarg is None else select_kwarg + return forecast.concat( + [ + getattr(forecast.select(**{select_kwarg: [val]}), reduce_method)( + dim=None, **kwargs + ) + for val in np.unique(getattr(forecast, attr)) + ], + **concat_kws, + ) + + +def sparse_quantile_axis0( + matrix: sparse.spmatrix, + q: np.typing.ArrayLike, + max_memory_mb: float = 64.0, +) -> np.ndarray: + """Quantile along axis 0 of a sparse matrix, without densifying it whole. + + Equivalent to ``np.quantile(matrix.toarray(), q, axis=0)``, but densifies + only as many columns at a time as fit into ``max_memory_mb``, so peak + memory no longer scales with the number of columns. + + Implicit zeros count as values: a column of ``[0, 0, 0, -1, 9]`` has median + ``0.0``, not the ``4.0`` given by its two stored values alone. + + Parameters + ---------- + matrix : scipy.sparse.spmatrix + Matrix to reduce, of shape (n_rows, n_cols). + q : float or array_like of float + Quantile or sequence of quantiles, each between 0 and 1. + max_memory_mb : float, optional + Approximate memory budget for a single densified block, in megabytes. + At least one column is always densified, so a budget too small for a + single column still works. Default: 64.0. + + Returns + ------- + np.ndarray + Quantiles along axis 0, shaped as ``np.quantile`` would return them. + """ + csc = matrix.tocsc() + n_rows, n_cols = csc.shape + if n_cols == 0: + return np.quantile(csc.toarray(), q, axis=0) + column_bytes = max(n_rows * csc.dtype.itemsize, 1) + block = max(int(max_memory_mb * 1e6) // column_bytes, 1) + + # np.quantile sorts its input, so it copies unless allowed not to. Each block is + # a throwaway nothing else references, so it can be sorted in place: skipping the + # per-block copy measured about twice as fast, at no cost in peak memory. + return np.concatenate( + [ + np.quantile( + csc[:, start : start + block].toarray(), q, axis=0, overwrite_input=True + ) + for start in range(0, n_cols, block) + ], + axis=-1, + ) diff --git a/climada/util/test/test_forecast.py b/climada/util/test/test_forecast.py new file mode 100644 index 0000000000..596cc19812 --- /dev/null +++ b/climada/util/test/test_forecast.py @@ -0,0 +1,197 @@ +""" +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 ForecastMixin class. +""" + +from unittest.mock import patch + +import numpy as np +import numpy.testing as npt +import pandas as pd +import pytest +from scipy.sparse import csc_matrix, csr_matrix + +from climada.util.forecast import ForecastMixin, sparse_quantile_axis0 + + +def test_forecast_init(): + """Test initialization of ForecastMixin class.""" + forecast = ForecastMixin() + npt.assert_array_equal(forecast.lead_time, np.array([])) + npt.assert_array_equal(forecast.member, np.array([])) + + forecast = ForecastMixin(member=np.array([1, 2])) + npt.assert_array_equal(forecast.member, np.array([1, 2]), strict=True) + + forecast = ForecastMixin(lead_time=np.array([6, 12], dtype="timedelta64[h]")) + npt.assert_array_equal( + forecast.lead_time, np.array([6, 12], dtype="timedelta64[h]"), strict=True + ) + + forecast = ForecastMixin(lead_time=np.array([1, 2]), member=[3, 4]) + npt.assert_array_equal(forecast.lead_time, np.array([1, 2]), strict=True) + npt.assert_array_equal(forecast.member, np.array([3, 4]), strict=True) + assert isinstance(forecast.member, np.ndarray) + + # Test with datetime64 including seconds + lead_times_seconds = pd.timedelta_range(start="1 day", periods=4).to_numpy() + forecast = ForecastMixin(lead_time=lead_times_seconds, member=[1, 2, 3]) + npt.assert_array_equal(forecast.lead_time, lead_times_seconds, strict=True) + assert forecast.lead_time.dtype == np.dtype("timedelta64[ns]") + + +def test_idx_member(): + """Test idx_member method of ForecastMixin class.""" + forecast = ForecastMixin(member=np.array([1, 2, 3, 4])) + + idx = forecast.idx_member(1) + npt.assert_array_equal(idx, np.array([True, False, False, False]), strict=True) + + idx = forecast.idx_member(np.array([2, 4])) + npt.assert_array_equal(idx, np.array([False, True, False, True]), strict=True) + + idx = forecast.idx_member([2, 4]) + npt.assert_array_equal(idx, np.array([False, True, False, True]), strict=True) + + idx = forecast.idx_member(None) + npt.assert_array_equal(idx, np.array([False, False, False, False]), strict=True) + + # Try once with inconsitent types + forecast = ForecastMixin(member=np.array(["1", -2, np.nan])) + npt.assert_array_equal( + forecast.idx_member([np.nan, "1"]), np.array([True, False, True]), strict=True + ) + + +def test_idx_lead_time(): + """Test idx_lead_time method of ForecastMixin class.""" + forecast = ForecastMixin( + lead_time=pd.timedelta_range(start="1 day", periods=4).to_numpy() + ) + + idx = forecast.idx_lead_time( + pd.timedelta_range(start="1 day", periods=4).to_numpy()[::2] + ) + npt.assert_array_equal(idx, np.array([True, False, True, False]), strict=True) + + idx = forecast.idx_lead_time( + pd.timedelta_range(start="1 day", periods=4).to_numpy()[0] + ) + npt.assert_array_equal(idx, np.array([True, False, False, False]), strict=True) + + idx = forecast.idx_lead_time(None) + npt.assert_array_equal(idx, np.array([False, False, False, False]), strict=True) + + +class TestSparseQuantile: + """Block-wise sparse quantile helper (issue #1203)""" + + @pytest.mark.parametrize("q", [0.0, 0.25, 0.5, 0.9, 1.0]) + # 1e-9 forces one column per block, 5e-4 gives 3 columns so the last block + # is a partial remainder, 10.0 takes the whole matrix in one block + @pytest.mark.parametrize("max_memory_mb", [1e-9, 5e-4, 10.0]) + def test_matches_dense_quantile(self, q, max_memory_mb): + """Block-wise result must equal the dense reference exactly""" + rng = np.random.default_rng(0) + dense = rng.random((20, 37)) + dense[dense < 0.7] = 0.0 # sparse, with implicit zeros dominating + mat = csr_matrix(dense) + npt.assert_array_equal( + sparse_quantile_axis0(mat, q, max_memory_mb=max_memory_mb), + np.quantile(dense, q, axis=0), + ) + + def test_counts_implicit_zeros(self): + """A column of [0,0,0,-1,9] has median 0, not 4 (the stored-only answer)""" + mat = csr_matrix(np.array([[0.0], [0.0], [0.0], [-1.0], [9.0]])) + npt.assert_array_equal(sparse_quantile_axis0(mat, 0.5), [0.0]) + + def test_negative_values(self): + """Negative stored values must not be confused with implicit zeros""" + dense = np.array([[-3.0, 0.0], [0.0, -1.0], [2.0, 0.0]]) + npt.assert_array_equal( + sparse_quantile_axis0(csr_matrix(dense), 0.5), + np.quantile(dense, 0.5, axis=0), + ) + + def test_all_zero_column(self): + """An entirely empty column yields zero, not NaN""" + npt.assert_array_equal( + sparse_quantile_axis0(csr_matrix((4, 3)), 0.5), np.zeros(3) + ) + + def test_single_row(self): + """One event: the quantile is that event's values for any q""" + dense = np.array([[5.0, 0.0, -2.0]]) + npt.assert_array_equal(sparse_quantile_axis0(csr_matrix(dense), 0.3), dense[0]) + + @pytest.mark.parametrize("q", [-0.1, 1.5]) + def test_quantile_out_of_range(self, q): + """An out-of-range quantile must raise, not return nonsense""" + mat = csr_matrix(np.array([[1.0, 0.0], [0.0, 2.0]])) + with pytest.raises(ValueError, match="Quantiles must be in the range"): + sparse_quantile_axis0(mat, q) + + def test_no_columns(self): + """A matrix with no columns yields an empty result, not an error""" + npt.assert_array_equal( + sparse_quantile_axis0(csr_matrix((5, 0)), 0.5), np.empty(0) + ) + + @pytest.mark.parametrize("dtype", [np.float32, np.float64]) + def test_preserves_dtype(self, dtype): + """The result dtype must match the dense reference, not be forced to float64""" + dense = np.array([[1, 0], [0, 2], [3, 0]], dtype=dtype) + result = sparse_quantile_axis0(csr_matrix(dense), 0.5) + assert result.dtype == np.quantile(dense, 0.5, axis=0).dtype + + def test_multiple_quantiles(self): + """A sequence of quantiles returns one row per quantile, as np.quantile does""" + dense = np.array([[1.0, 0.0], [0.0, 2.0]]) + npt.assert_array_equal( + sparse_quantile_axis0(csr_matrix(dense), [0.25, 0.75]), + np.quantile(dense, [0.25, 0.75], axis=0), + ) + + @pytest.mark.parametrize("max_memory_mb", [0.0, -1.0, 1e-12]) + def test_degenerate_memory_budget(self, max_memory_mb): + """A useless budget must still give the right answer, never uninitialised memory""" + dense = np.array([[1.0, 0.0], [0.0, 2.0], [4.0, 3.0]]) + npt.assert_array_equal( + sparse_quantile_axis0(csr_matrix(dense), 0.5, max_memory_mb=max_memory_mb), + np.quantile(dense, 0.5, axis=0), + ) + + def test_densifies_blocks_not_whole_matrix(self): + """Only column blocks are densified, never the full matrix (issue #1203)""" + dense = np.zeros((6, 12)) + dense[1, 3] = 4.0 + dense[4, 9] = -2.0 + mat = csr_matrix(dense) + # the helper converts to CSC first, so csc_matrix is what densifies + with patch.object( + csc_matrix, "toarray", autospec=True, side_effect=csc_matrix.toarray + ) as spy: + sparse_quantile_axis0(mat, 0.5, max_memory_mb=1e-9) + + densified = [call.args[0].shape for call in spy.call_args_list] + assert densified, "no densification seen at all: the spy is not wired up" + assert ( + max(shape[1] for shape in densified) < mat.shape[1] + ), f"a block covered every column: {densified}" diff --git a/doc/api/climada/climada.engine.rst b/doc/api/climada/climada.engine.rst index f21024fdeb..c061307c13 100644 --- a/doc/api/climada/climada.engine.rst +++ b/doc/api/climada/climada.engine.rst @@ -52,3 +52,11 @@ climada\.engine\.impact\_data module :members: :undoc-members: :show-inheritance: + +climada\.engine\.impact\_forecast module +---------------------------------------- + +.. automodule:: climada.engine.impact_forecast + :members: + :undoc-members: + :show-inheritance: diff --git a/doc/api/climada/climada.hazard.rst b/doc/api/climada/climada.hazard.rst index cb58d5077b..eb012d3df8 100644 --- a/doc/api/climada/climada.hazard.rst +++ b/doc/api/climada/climada.hazard.rst @@ -79,3 +79,11 @@ climada\.hazard\.tc\_tracks\_synth module :members: :undoc-members: :show-inheritance: + +climada\.hazard\.forecast module +-------------------------------- + +.. automodule:: climada.hazard.forecast + :members: + :undoc-members: + :show-inheritance: diff --git a/doc/api/climada/climada.util.rst b/doc/api/climada/climada.util.rst index 9e4c037da4..c8ec158974 100644 --- a/doc/api/climada/climada.util.rst +++ b/doc/api/climada/climada.util.rst @@ -81,6 +81,14 @@ climada\.util\.finance module :undoc-members: :show-inheritance: +climada\.util\.forecast module +------------------------------ + +.. automodule:: climada.util.forecast + :members: + :undoc-members: + :show-inheritance: + climada\.util\.hdf5\_handler module ----------------------------------- diff --git a/doc/development/Guide_CLIMADA_Development.ipynb b/doc/development/Guide_CLIMADA_Development.ipynb index 18ff936407..743bb194a9 100644 --- a/doc/development/Guide_CLIMADA_Development.ipynb +++ b/doc/development/Guide_CLIMADA_Development.ipynb @@ -141,6 +141,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "(dev-pre-commit-hooks)=\n", + "\n", "### Pre-Commit Hooks\n", "\n", "Climada developer dependencies include pre-commit hooks to help ensure code linting and formatting.\n", diff --git a/doc/getting-started/install.rst b/doc/getting-started/install.rst index 96588b3fdd..9ef638b156 100644 --- a/doc/getting-started/install.rst +++ b/doc/getting-started/install.rst @@ -59,7 +59,7 @@ Windows * - **Supported Version** - ``3.11`` * - Allowed Versions - - ``3.10``, ``3.11``, ``3.12`` + - ``3.11``, ``3.12``, ``3.13`` .. _install-choice: @@ -74,7 +74,7 @@ Depening on your level of expertise, we provide two different approaches: * If you have never worked with a command line, or if you just want to give CLIMADA a try, follow the :ref:`simple instructions `. * If you want to use the very latest development version of CLIMADA or even develop new CLIMADA code, follow the :ref:`advanced instructions `. -Both approaches are not mutually exclusive. +Both approaches are **not** mutually exclusive. After successful installation, you may switch your setup at any time. .. _petals-notes: @@ -139,6 +139,52 @@ These instructions will install the most recent stable version of CLIMADA withou mamba install -n climada_env -c conda-forge climada-petals + .. attention:: + + On Windows, installing ``climada-petals`` with Conda/Mamba may be prohibited as it takes forever to resolve the dependency tree. + In these cases, `Pixi`_ is often the only reliable fallback (s.b.). + +.. _install-pixi: + +------------------------------------------- +Simple Instructions with Pixi (Alternative) +------------------------------------------- + +As an alternative to mamba `Pixi`_ can be used to install climada from conda-forge. +Pixi is a modern package manager, based on Conda, that offers much faster dependency resolution. + +#. Open the command line and create a new folder for your Pixi project: + + .. code-block:: shell + + pixi init climada_pixi + +#. Add CLIMADA from ``conda-forge``: + + .. code-block:: shell + + pixi add --manifest-path climada_pixi/pixi.toml climada + +#. Verify that everything is installed correctly by executing a single test: + + .. code-block:: shell + + # the pixi way to activate an environment + pixi shell --manifest-path climada_pixi/pixi.toml + # execute the test + python -m unittest climada.engine.test.test_impact + # the pixi way to deactivate an environment + exit + + Executing CLIMADA for the first time in a pixi environment will take quite some time because it will generate + a directory tree in your home/user directory. If this test passes, great! You are good to go. + +#. *Optional:* Install CLIMADA Petals into the same Pixi environment: + + .. code-block:: shell + + pixi add --manifest-path climada_pixi/pixi.toml climada-petals + .. _install-advanced: --------------------------------------------- @@ -146,6 +192,7 @@ Advanced Instructions: Installing from source --------------------------------------------- For advanced Python users or developers of CLIMADA, cloning the CLIMADA repository and installing the package from source. +Installing from source also allows you to :ref:`switch branches `. .. warning:: @@ -235,24 +282,6 @@ For advanced Python users or developers of CLIMADA, cloning the CLIMADA reposito If this test passes, great! You are good to go. -.. _change-branch: - -How to switch branch -^^^^^^^^^^^^^^^^^^^^^^ - -Advanced users, or reviewers, may also want to check the feature of a specific branch other than develop. -To do so, **assuming you did install CLIMADA in editable mode (`pip install` with the `-e` flag)**, you just have to: - -``` -git fetch -git checkout -git pull -``` - -This will work most of the time, except if the target branch defines new dependencies that you don't have already in your environment (as they will not get installed this way), in that case you can install these dependencies yourself, or create a new environment with the *new* requirements from the branch. - -If you did not install CLIMADA in editable mode, you can also reinstall CLIMADA from its folder after switching the branch (`pip install [-e] ./`). - .. _devdeps: Install Developer Dependencies (Optional) @@ -263,8 +292,7 @@ They are also not needed for using CLIMADA. However, if you want to develop CLIMADA, we strongly recommend you install them. With the ``climada_env`` activated, enter the workspace directory and then the CLIMADA repository as above. -Then, add the ``test`` extra specification to the ``pip install`` command (**mind the quotation marks**, -and see also `pip install examples `_): +Then, add the ``test`` extra specification to the ``pip install`` command (**mind the quotation marks**, and see also `pip install examples `_): .. code-block:: shell @@ -291,7 +319,7 @@ With the ``climada_env`` activated, execute pre-commit install -Please refer to the `guide on pre-commit hooks <../development/Guide_CLIMADA_Development.html#pre-commit-hooks>`_ for information on how to use this tool. +Please refer to the :ref:`guide on pre-commit hooks ` for information on how to use this tool. For executing the pre-defined test scripts in exactly the same way as they are executed by the automated CI pipeline, you will need ``make`` to be installed. On macOS and on Linux it is pre-installed. On Windows, it can easily be installed with Conda: @@ -300,7 +328,7 @@ On macOS and on Linux it is pre-installed. On Windows, it can easily be installe mamba install -n climada_env make -Instructions for running the test scripts can be found in the `Testing Guide <../development/Guide_Testing.html>`_. +Instructions for running the test scripts can be found in the :doc:`Testing Guide `. Install CLIMADA Petals (Optional) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -334,9 +362,9 @@ To install CLIMADA Petals, we assume you have already installed CLIMADA Core wit python -m pip install -e ./ ---------------------------------------- +------------ Code Editors ---------------------------------------- +------------ JupyterLab ^^^^^^^^^^ @@ -465,9 +493,9 @@ Therefore, we recommend installing Spyder in a *separate* environment, and then #. Set the Python interpreter used by Spyder to the one of ``climada_env``. Select *Preferences* > *Python Interpreter* > *Use the following interpreter* and paste the iterpreter path you copied from the ``climada_env``. ---------------------------------------- +----------------------------- Apps for working with CLIMADA ---------------------------------------- +----------------------------- To work with CLIMADA, you will need an application that supports Jupyter Notebooks. There are plugins available for nearly every code editor or IDE, but if you are unsure about which to choose, we recommend `JupyterLab `_, `Visual Studio Code `_ or `Spyder `_. @@ -523,8 +551,8 @@ Answers to frequently asked questions. .. _update-climada: -Updating CLIMADA -^^^^^^^^^^^^^^^^ +How to update CLIMADA? +^^^^^^^^^^^^^^^^^^^^^^ We recommend keeping CLIMADA up-to-date. To update, follow the instructions based on your :ref:`installation type `: @@ -552,6 +580,30 @@ To update, follow the instructions based on your :ref:`installation type ` from source. + +If you want to check out or review a specific feature, you may want to switch to a `Git branch `_ other than ``develop``. +To switch to a new branch, open a terminal and move to the CLIMADA repository. +Then fetch the latest changes from the remote, switch to the target branch, and update your local version: + +.. code-block:: shell + + cd /climada_python + git fetch + git checkout + git pull + +After switching, it is good practice to :ref:`update your environment `, as the dependency definitions might have been changed. +In rare cases, updating the environment might fail after switching a branch because the dependency updates are incompatible. +If this happens, create a new environment (see the :ref:`advanced instructions `). + +The above instructions also apply for CLIMADA Petals, but you have to ``cd`` into the ``climada_petals`` repository in the first step, of course. + .. _install-more-packages: Installing More Packages @@ -631,12 +683,12 @@ the level set to ``WARNING``. If you prefer another logging configuration, e.g., for using Climada embedded in another application, you can opt out of the default pre-configuration by setting the config value for -``logging.climada_style`` to ``false`` in the :doc:`configuration file <../development/Guide_Configuration>` +``logging.climada_style`` to ``false`` in the :doc:`configuration file ` ``climada.conf``. Changing the logging level can be done in multiple ways: -* Adjust the :doc:`configuration file <../development/Guide_Configuration>` ``climada.conf`` by setting a the value of the ``global.log_level`` property. +* Adjust the :doc:`configuration file ` ``climada.conf`` by setting a the value of the ``global.log_level`` property. This only has an effect if the ``logging.climada_style`` is set to ``true`` though. * Set a global logging level in your Python script: @@ -710,6 +762,9 @@ Terminal, Command Line `Mamba`_ The faster reimplementation of the ``conda`` package manager. +`Pixi`_ + The much faster modern package manager based on ``conda``. + Environment (Programming) A setup where only a specific set of modules and programs can interact. This is especially useful if you want to install programs with mutually incompatible requirements. @@ -737,4 +792,5 @@ IDE .. _Conda: https://docs.conda.io/en/latest/ .. _Mamba: https://mamba.readthedocs.io/en/latest/installation/mamba-installation.html .. _Miniforge: https://github.com/conda-forge/miniforge +.. _Pixi: https://pixi.sh/ .. _CLIMADA Petals: https://climada-petals.readthedocs.io/en/latest/ diff --git a/doc/user-guide/climada_engine_Forecast.ipynb b/doc/user-guide/climada_engine_Forecast.ipynb index f0d6b3a66a..c0a1dd90b8 100644 --- a/doc/user-guide/climada_engine_Forecast.ipynb +++ b/doc/user-guide/climada_engine_Forecast.ipynb @@ -5,6 +5,13 @@ "metadata": {}, "source": [ "# Forecast class\n", + "\n", + "```{warning}\n", + "\n", + "The standalone `Forecast` class has been superseded by the implementations of {py:class}`~climada.hazard.forecast.HazardForecast` and {py:class}`~climada.engine.impact_forecast.ImpactForecast`.\n", + "Their usage is explained in [another tutorial](climada_engine_ImpactForecast.ipynb).\n", + "```\n", + "\n", "This class deals with weather forecasts and uses CLIMADA ImpactCalc.impact() to forecast impacts of weather events on society. It mainly does one thing:\n", "- it contains all plotting and other functionality that are specific for weather forecasts, impact forecasts and warnings\n", "\n", diff --git a/doc/user-guide/climada_engine_ImpactForecast.ipynb b/doc/user-guide/climada_engine_ImpactForecast.ipynb new file mode 100644 index 0000000000..43cac61cdb --- /dev/null +++ b/doc/user-guide/climada_engine_ImpactForecast.ipynb @@ -0,0 +1,1790 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c729dd8c", + "metadata": {}, + "source": [ + "# Hazard forecasts and impacts forecasts\n", + "\n", + "In this tutorial, we showcase CLIMADA functionality to handle forecast data using the classes {py:class}`~climada.hazard.forecast.HazardForecast` and {py:class}`~climada.engine.impact_forecast.ImpactForecast`.\n", + "Exemplary forecast data will be downloaded from the Open Government Data (OGD) portal of MeteoSwiss." + ] + }, + { + "cell_type": "markdown", + "id": "dc2bc0cd", + "metadata": {}, + "source": [ + "## Table of Contents\n", + "\n", + "0. [Quickstart](#0-quickstart)\n", + "1. [Reading & processing forecast data](#1-reading--processing-forecast-data)\n", + " - 1.1 [Using MeteoSwiss Open Government Data weather forecasts](#11-using-meteoswiss-open-government-data-weather-forecasts)\n", + " - 1.2 [Using CLIMADA API demo data](#12-using-climada-api-demo-data)\n", + "2. [Impact Forecast calculation](#2-impact-forecast-calculation)\n", + "3. [Products based on ImpactForecast](#3-products-based-on-impactforecast)\n", + " - 3.1 [Per ensemble member, per lead time](#31-per-ensemble-member-per-lead-time)\n", + " - 3.2 [All ensemble members, per lead time](#32-all-ensemble-members-per-lead-time)\n", + " - 3.3 [All ensemble members and lead times](#33-all-ensemble-members-and-lead-times)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "19f95d2e", + "metadata": {}, + "outputs": [], + "source": [ + "# import necessary packages\n", + "from pathlib import Path\n", + "\n", + "import cartopy.crs as ccrs\n", + "import cartopy.feature as cfeature\n", + "import matplotlib.colors as mcolors\n", + "\n", + "# import numbers\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import xarray as xr\n", + "\n", + "# Import CLIMADA\n", + "from climada.engine import ImpactCalc, ImpactForecast\n", + "from climada.entity import ImpactFunc, ImpactFuncSet\n", + "from climada.entity.exposures.litpop import LitPop\n", + "from climada.hazard.forecast import HazardForecast\n", + "from climada.util.api_client import Client\n", + "\n", + "# Features for maps\n", + "admin1 = cfeature.NaturalEarthFeature(\n", + " category=\"cultural\", name=\"admin_1_states_provinces_lines\", scale=\"10m\"\n", + ")\n", + "lakes = cfeature.LAKES.with_scale(\"10m\")\n", + "borders = cfeature.BORDERS.with_scale(\"10m\")" + ] + }, + { + "cell_type": "markdown", + "id": "e7dfffcb", + "metadata": {}, + "source": [ + "## 0. Quickstart\n", + "\n", + "The next cell downloads some exemplary forecast data and loads it as a `HazardForecast` object.\n", + "It then demonstrates the capabilities of this class:\n", + "\n", + "* Computing reductions (in this case maximum) over the lead time or member dimensions.\n", + "* Regular impact calculation with `ImpactCalc` yielding an `ImpactForecast` object.\n", + "* More reductions and the use of other methods from `Impact`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bca55c2e", + "metadata": {}, + "outputs": [], + "source": [ + "def fix_lead_time(ds: xr.Dataset) -> xr.Dataset:\n", + " \"\"\"Make lead_time a valid timedelta\n", + "\n", + " Only needed for the pre-computed demonstrator data from the data API\n", + " \"\"\"\n", + " ds = ds.copy() # Shallow copy\n", + " ds[\"lead_time\"] = ds[\"time\"] - ds[\"forecast_reference_time\"]\n", + " return ds" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5e99f30c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-06-08 13:58:51,220 - climada.hazard.xarray - WARNING - Failed to read values of 'event' as dates. Hazard.event_name will be empty strings\n", + "2026-06-08 13:58:51,220 - climada.hazard.xarray - WARNING - Failed to read values of 'event' as dates or ordinals. Hazard.date will be ones only\n", + "2026-06-08 13:58:51,894 - climada.entity.exposures.litpop.litpop - INFO - \n", + " LitPop: Init Exposure for country: CHE (756)...\n", + "\n", + "2026-06-08 13:58:52,027 - climada.entity.exposures.litpop.litpop - INFO - \n", + " LitPop: Init Exposure for country: LIE (438)...\n", + "\n", + "2026-06-08 13:58:52,063 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n", + "2026-06-08 13:58:52,063 - climada.entity.exposures.base - INFO - category_id not set.\n", + "2026-06-08 13:58:52,063 - climada.entity.exposures.base - INFO - cover not set.\n", + "2026-06-08 13:58:52,063 - climada.entity.exposures.base - INFO - deductible not set.\n", + "2026-06-08 13:58:52,064 - climada.entity.exposures.base - INFO - centr_ not set.\n", + "2026-06-08 13:58:52,064 - climada.entity.exposures.base - INFO - Matching 70525 exposures with 27000 centroids.\n", + "2026-06-08 13:58:52,102 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100 degree\n", + "2026-06-08 13:58:52,120 - climada.entity.exposures.base - INFO - No specific impact function column found for hazard PR. Using the anonymous 'impf_' column.\n", + "2026-06-08 13:58:52,123 - climada.engine.impact_calc - INFO - Calculating impact for 69394 assets (>0) and 21 events.\n", + "2026-06-08 13:58:52,131 - climada.engine.impact_calc - WARNING - eai_exp and aai_agg are undefined with forecasts. Setting them to NaN arrays.\n", + "2026-06-08 13:58:52,144 - climada.engine.impact_forecast - INFO - at_event gives the total impact for one specific combination of member and lead_time.\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" + } + ], + "source": [ + "# Load example hazard data\n", + "client = Client()\n", + "ds_info_icon_fcst = client.get_dataset_info_by_uuid(\n", + " \"60229fa0-4d5d-4f39-876c-b4344579d6eb\"\n", + ")\n", + "_, path_to_forecast_nc = client.download_dataset(ds_info_icon_fcst)\n", + "\n", + "# Read data as HazardForecast object\n", + "ds = xr.open_dataset(path_to_forecast_nc[0])\n", + "ds = fix_lead_time(ds)\n", + "hazard_forecast = HazardForecast.from_xarray_raster(\n", + " ds,\n", + " hazard_type=\"PR\",\n", + " intensity_unit=\"mm/h\",\n", + " coordinate_vars={\n", + " \"longitude\": \"x\",\n", + " \"latitude\": \"y\",\n", + " \"lead_time\": \"lead_time\",\n", + " \"member\": \"realization\",\n", + " },\n", + " intensity=\"precipitation_amount_1hsum\",\n", + " crs=\"EPSG:2056\",\n", + " open_dataset_kws={\"decode_coords\": \"all\"},\n", + ")\n", + "# transform to EPSG:4326\n", + "hazard_forecast.centroids.gdf = hazard_forecast.centroids.gdf.to_crs(epsg=4326)\n", + "\n", + "# For each member, use the maximum intensity over the lead time\n", + "hazard_forecast = hazard_forecast.max(dim=\"lead_time\")\n", + "\n", + "# Read exposure for population\n", + "exp_che = LitPop.from_population(countries=[\"CHE\", \"LIE\"], res_arcsec=30)\n", + "# Assign centroids because hazard not on regular grid\n", + "exp_che.assign_centroids(hazard_forecast, threshold=100)\n", + "\n", + "# Define impact functions\n", + "threshold_for_affected = 50\n", + "imp_fun_precip = ImpactFunc.from_step_impf(\n", + " (0, threshold_for_affected, 200),\n", + " haz_type=\"PR\",\n", + " impf_id=1,\n", + " intensity_unit=\"mm/h\",\n", + " name=\"Severe Precipitation Step Function\",\n", + ")\n", + "impf_set = ImpactFuncSet([imp_fun_precip])\n", + "\n", + "# Compute impact (forecast)\n", + "impact_forecast = ImpactCalc(exp_che, impf_set, hazard_forecast).impact(\n", + " assign_centroids=False, save_mat=True\n", + ")\n", + "\n", + "# Compute quantile over remaining ensemble members and plot\n", + "impact_forecast_q075 = impact_forecast.quantile(0.92)\n", + "impact_forecast_q075.plot_hexbin_impact_exposure()" + ] + }, + { + "cell_type": "markdown", + "id": "7724938c", + "metadata": {}, + "source": [ + "\n", + "## 1. Reading & processing forecast data\n" + ] + }, + { + "cell_type": "markdown", + "id": "b8a13847", + "metadata": {}, + "source": [ + "### 1.1 Using MeteoSwiss Open Government Data weather forecasts\n", + "\n", + "This example retrieves the latest OGD forecast data from MeteoSwiss.\n", + "You can also skip this step and go to section 1.2 for using stored demo data from the CLIMADA API.\n", + "\n", + "Requires the package `meteodata-lab`, available via `pip`.\n", + "\n", + "You can find out all about data openly published here (info and notebooks on how to retrieve):\n", + "\n", + "Check out:\n", + "* https://github.com/MeteoSwiss/meteodata-lab and\n", + "* https://github.com/MeteoSwiss/opendata-nwp-demos/blob/main/01_retrieve_process_precip.ipynb\n", + "* https://www.meteoschweiz.admin.ch/service-und-publikationen/service/open-data.html\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "0678c808", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: meteodata-lab in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (0.7.2)\n", + "Requirement already satisfied: click<9.0.0,>=8.1.7 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from meteodata-lab) (8.3.3)\n", + "Requirement already satisfied: earthkit-data<1,>=0.11 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (0.20.0)\n", + "Requirement already satisfied: earthkit-meteo>=0.4.0 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from meteodata-lab) (0.6.2)\n", + "Requirement already satisfied: eccodes<2.40,>=2.38 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from meteodata-lab) (2.39.2)\n", + "Requirement already satisfied: eccodes-cosmo-resources-python<2.39,>=2.38 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from meteodata-lab) (2.38.3.1)\n", + "Requirement already satisfied: numpy<2.4.0,>=1.26.4 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from meteodata-lab) (2.2.6)\n", + "Requirement already satisfied: pydantic<3.0,>=2.0 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from meteodata-lab) (2.13.4)\n", + "Requirement already satisfied: pyyaml<7.0.0,>=6.0.1 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from meteodata-lab) (6.0.3)\n", + "Requirement already satisfied: setuptools in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from meteodata-lab) (82.0.1)\n", + "Requirement already satisfied: xarray>=2024 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from meteodata-lab) (2026.4.0)\n", + "Requirement already satisfied: cfgrib>=0.9.10.1 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (0.9.15.1)\n", + "Requirement already satisfied: dask in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (2026.3.0)\n", + "Requirement already satisfied: deprecation in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (2.1.0)\n", + "Requirement already satisfied: earthkit-utils<0.99,>=0.2 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (0.3.0)\n", + "Requirement already satisfied: entrypoints in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (0.4)\n", + "Requirement already satisfied: filelock in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (3.29.0)\n", + "Requirement already satisfied: jinja2 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (3.1.6)\n", + "Requirement already satisfied: jsonschema in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (4.26.0)\n", + "Requirement already satisfied: lru-dict in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (1.4.1)\n", + "Requirement already satisfied: markdown in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (3.10.2)\n", + "Requirement already satisfied: multiurl>=0.3.3 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (0.3.7)\n", + "Requirement already satisfied: netcdf4 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (1.7.4)\n", + "Requirement already satisfied: pandas in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (2.2.2)\n", + "Requirement already satisfied: pdbufr>=0.11 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (0.14.2)\n", + "Requirement already satisfied: tqdm>=4.63 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (4.67.3)\n", + "Requirement already satisfied: covjsonkit>=0.2.2 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (0.2.20)\n", + "Requirement already satisfied: array-api-compat in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from earthkit-utils<0.99,>=0.2->earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (1.15.0)\n", + "Requirement already satisfied: pint in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from earthkit-utils<0.99,>=0.2->earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (0.25.3)\n", + "Requirement already satisfied: attrs in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from eccodes<2.40,>=2.38->meteodata-lab) (26.1.0)\n", + "Requirement already satisfied: cffi in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from eccodes<2.40,>=2.38->meteodata-lab) (2.0.0)\n", + "Requirement already satisfied: findlibs in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from eccodes<2.40,>=2.38->meteodata-lab) (0.1.2)\n", + "Requirement already satisfied: annotated-types>=0.6.0 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from pydantic<3.0,>=2.0->meteodata-lab) (0.7.0)\n", + "Requirement already satisfied: pydantic-core==2.46.4 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from pydantic<3.0,>=2.0->meteodata-lab) (2.46.4)\n", + "Requirement already satisfied: typing-extensions>=4.14.1 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from pydantic<3.0,>=2.0->meteodata-lab) (4.15.0)\n", + "Requirement already satisfied: typing-inspection>=0.4.2 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from pydantic<3.0,>=2.0->meteodata-lab) (0.4.2)\n", + "Requirement already satisfied: orjson in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from covjsonkit>=0.2.2->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (3.11.9)\n", + "Requirement already satisfied: covjson-pydantic in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from covjsonkit>=0.2.2->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (0.7.0)\n", + "Requirement already satisfied: conflator in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from covjsonkit>=0.2.2->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (0.1.8)\n", + "Requirement already satisfied: scipy in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from covjsonkit>=0.2.2->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (1.17.1)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from pandas->earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (2.9.0.post0)\n", + "Requirement already satisfied: pytz>=2020.1 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from pandas->earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (2026.2)\n", + "Requirement already satisfied: tzdata>=2022.7 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from pandas->earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (2026.2)\n", + "Requirement already satisfied: requests in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from multiurl>=0.3.3->earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (2.33.1)\n", + "Requirement already satisfied: six>=1.5 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from python-dateutil>=2.8.2->pandas->earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (1.17.0)\n", + "Requirement already satisfied: packaging>=24.2 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from xarray>=2024->meteodata-lab) (26.2)\n", + "Requirement already satisfied: pycparser in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from cffi->eccodes<2.40,>=2.38->meteodata-lab) (2.22)\n", + "Requirement already satisfied: rich-argparse>1.0 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from conflator->covjsonkit>=0.2.2->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (1.8.0)\n", + "Requirement already satisfied: rich>=11.0.0 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from rich-argparse>1.0->conflator->covjsonkit>=0.2.2->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (15.0.0)\n", + "Requirement already satisfied: markdown-it-py>=2.2.0 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from rich>=11.0.0->rich-argparse>1.0->conflator->covjsonkit>=0.2.2->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (4.2.0)\n", + "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from rich>=11.0.0->rich-argparse>1.0->conflator->covjsonkit>=0.2.2->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (2.20.0)\n", + "Requirement already satisfied: mdurl~=0.1 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from markdown-it-py>=2.2.0->rich>=11.0.0->rich-argparse>1.0->conflator->covjsonkit>=0.2.2->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (0.1.2)\n", + "Requirement already satisfied: cloudpickle>=3.0.0 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from dask->earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (3.1.2)\n", + "Requirement already satisfied: fsspec>=2021.09.0 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from dask->earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (2026.4.0)\n", + "Requirement already satisfied: partd>=1.4.0 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from dask->earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (1.4.2)\n", + "Requirement already satisfied: toolz>=0.12.0 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from dask->earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (1.1.0)\n", + "Requirement already satisfied: locket in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from partd>=1.4.0->dask->earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (1.0.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from jinja2->earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (3.0.3)\n", + "Requirement already satisfied: jsonschema-specifications>=2023.03.6 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from jsonschema->earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (2025.9.1)\n", + "Requirement already satisfied: referencing>=0.28.4 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from jsonschema->earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (0.37.0)\n", + "Requirement already satisfied: rpds-py>=0.25.0 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from jsonschema->earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (2026.5.1)\n", + "Requirement already satisfied: cftime in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from netcdf4->earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (1.6.5)\n", + "Requirement already satisfied: certifi in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from netcdf4->earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (2026.4.22)\n", + "Requirement already satisfied: flexcache>=0.3 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from pint->earthkit-utils<0.99,>=0.2->earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (0.3)\n", + "Requirement already satisfied: flexparser>=0.4 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from pint->earthkit-utils<0.99,>=0.2->earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (0.4)\n", + "Requirement already satisfied: platformdirs>=2.1.0 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from pint->earthkit-utils<0.99,>=0.2->earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (4.9.6)\n", + "Requirement already satisfied: charset_normalizer<4,>=2 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from requests->multiurl>=0.3.3->earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (3.4.7)\n", + "Requirement already satisfied: idna<4,>=2.5 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from requests->multiurl>=0.3.3->earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (3.13)\n", + "Requirement already satisfied: urllib3<3,>=1.26 in /Users/ldr.riedel/miniforge3/envs/climada_env_3.12/lib/python3.12/site-packages (from requests->multiurl>=0.3.3->earthkit-data<1,>=0.11->earthkit-data[covjsonkit]<1,>=0.11->meteodata-lab) (2.6.3)\n" + ] + } + ], + "source": [ + "!pip install meteodata-lab" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5e058dee", + "metadata": {}, + "outputs": [], + "source": [ + "# optional packages for this section only\n", + "from earthkit.data import config\n", + "from meteodatalab import ogd_api\n", + "from meteodatalab.operators import time_operators as time_ops\n", + "\n", + "config.set(\"cache-policy\", \"user\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ed2c877d", + "metadata": {}, + "outputs": [], + "source": [ + "# Define target lead times for ICON-CH2-EPS: up 5d, here +0h, to +12h\n", + "lead_times = [f\"P0DT{i}H\" for i in np.arange(0, 13)]\n", + "model = \"ogd-forecasting-icon-ch2\"\n", + "nwp_vars = [\"TOT_PREC\", \"VMAX_10M\"] # precip. and wind; temperature: \"T_2M\"\n", + "reftime = \"latest\" # also try: 'latest'" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "02b21481", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " \r" + ] + } + ], + "source": [ + "dict_ens_data = {}\n", + "for var in nwp_vars:\n", + " req = ogd_api.Request(\n", + " collection=model,\n", + " variable=var,\n", + " ref_time=reftime,\n", + " perturbed=True, # ensembles\n", + " lead_time=lead_times,\n", + " )\n", + " dict_ens_data[var] = ogd_api.get_from_ogd(req)\n", + "\n", + "# We extract the hourly delta in total precipitation to receive the hourly precipitation\n", + "dict_ens_data[\"TOT_PREC\"] = time_ops.delta(\n", + " dict_ens_data[\"TOT_PREC\"], np.timedelta64(1, \"h\")\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "806f5224", + "metadata": {}, + "outputs": [], + "source": [ + "ds_icon_latest = xr.Dataset(dict_ens_data)\n", + "init_time_str = np.datetime_as_string(ds_icon_latest.ref_time.values[0], unit=\"h\")" + ] + }, + { + "cell_type": "markdown", + "id": "0f625329", + "metadata": {}, + "source": [ + "After loading the data as a netcdf file, we read it into a `HazardForecast` object (see next subsection for more details on the structuer of this class)." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "16be902b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-06-08 13:59:21,773 - climada.hazard.xarray - WARNING - Failed to read values of 'event' as dates. Hazard.event_name will be empty strings\n", + "2026-06-08 13:59:21,774 - climada.hazard.xarray - WARNING - Failed to read values of 'event' as dates or ordinals. Hazard.date will be ones only\n" + ] + } + ], + "source": [ + "haz_fc_icon_latest = HazardForecast.from_xarray_raster(\n", + " ds_icon_latest,\n", + " hazard_type=\"PR\",\n", + " intensity_unit=\"mm/h\",\n", + " coordinate_vars={\n", + " \"longitude\": \"lon\",\n", + " \"latitude\": \"lat\",\n", + " \"lead_time\": \"lead_time\",\n", + " \"member\": \"eps\",\n", + " },\n", + " intensity=\"TOT_PREC\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "1b166b20", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Forecasted hourly precipication (model: ogd-forecasting-icon-ch2) for init time 2026-06-08T06 (UTC),\\nmaximized over 20 ensemble members and 13 lead times (0 hours - 12 hours)')" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the maximum precipitation intensity for each pixel in the entire dataset\n", + "ax = haz_fc_icon_latest.plot_intensity(event=0)\n", + "lead_times = np.unique(haz_fc_icon_latest.lead_time).astype(\"timedelta64[h]\")\n", + "ax.set_title(\n", + " f\"Forecasted hourly precipication (model: {model}) for init time {init_time_str} \"\n", + " f\"(UTC),\\nmaximized over {len(np.unique(haz_fc_icon_latest.member))} ensemble \"\n", + " f\"members and {len(lead_times)} lead times ({lead_times[0]} - {lead_times[-1]})\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "5fa2d08f", + "metadata": {}, + "source": [ + "### 1.2 Using CLIMADA API demo data\n", + "\n", + "As an example, we load existing forecast data for an event including heavy precipitation and flooding on June 21, 2024 in in Misox, Switzerland.\n", + "\n", + "After loading the data as a netcdf file, we read it into a `HazardForecast` object." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "3b41585f", + "metadata": {}, + "outputs": [], + "source": [ + "# get the demo forecast netCDF file fcst_icon_seamless_2024-06-18_12_00.nc via CLIMADA API\n", + "client = Client()\n", + "ds_info_icon_fcst = client.get_dataset_info_by_uuid(\n", + " \"60229fa0-4d5d-4f39-876c-b4344579d6eb\"\n", + ")\n", + "_, path_to_forecast_nc = client.download_dataset(ds_info_icon_fcst)" + ] + }, + { + "cell_type": "markdown", + "id": "123d3ae7", + "metadata": {}, + "source": [ + "Load into `HazardForecast` file from NetCDF on disk." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "60d344d3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-06-08 13:59:40,792 - climada.hazard.xarray - WARNING - Failed to read values of 'event' as dates. Hazard.event_name will be empty strings\n", + "2026-06-08 13:59:40,793 - climada.hazard.xarray - WARNING - Failed to read values of 'event' as dates or ordinals. Hazard.date will be ones only\n" + ] + } + ], + "source": [ + "ds = xr.open_dataset(path_to_forecast_nc[0])\n", + "ds = fix_lead_time(ds)\n", + "hazard_forecast = HazardForecast.from_xarray_raster(\n", + " ds,\n", + " hazard_type=\"PR\",\n", + " intensity_unit=\"mm/h\",\n", + " coordinate_vars={\n", + " \"longitude\": \"x\",\n", + " \"latitude\": \"y\",\n", + " \"lead_time\": \"lead_time\",\n", + " \"member\": \"realization\",\n", + " },\n", + " intensity=\"precipitation_amount_1hsum\",\n", + " crs=\"EPSG:2056\",\n", + ")\n", + "# transform to EPSG:4326\n", + "hazard_forecast.centroids.gdf = hazard_forecast.centroids.gdf.to_crs(epsg=4326)" + ] + }, + { + "cell_type": "markdown", + "id": "d8505bf1", + "metadata": {}, + "source": [ + "`HazardForecast` objects include forecasts produced at a specific initializatio (or reference) time, but for several several lead times and several forecast ensemble members. For this, it includes the two array-like attributes:\n", + "- `member` to indicate the forecast ensemble member, and\n", + "- `lead_time` to indicate the lead time of the data,\n", + "\n", + "both of which can be used to select specific forecasts." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "690f6061", + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
event_idevent_namelead_timemember
01lt_0h_m_00 days 00:00:000
12lt_0h_m_10 days 00:00:001
23lt_0h_m_20 days 00:00:002
34lt_0h_m_30 days 00:00:003
45lt_0h_m_40 days 00:00:004
56lt_0h_m_50 days 00:00:005
67lt_0h_m_60 days 00:00:006
78lt_0h_m_70 days 00:00:007
89lt_0h_m_80 days 00:00:008
910lt_0h_m_90 days 00:00:009
1011lt_0h_m_100 days 00:00:0010
1112lt_0h_m_110 days 00:00:0011
1213lt_0h_m_120 days 00:00:0012
1314lt_0h_m_130 days 00:00:0013
1415lt_0h_m_140 days 00:00:0014
1516lt_0h_m_150 days 00:00:0015
1617lt_0h_m_160 days 00:00:0016
1718lt_0h_m_170 days 00:00:0017
1819lt_0h_m_180 days 00:00:0018
1920lt_0h_m_190 days 00:00:0019
2021lt_0h_m_200 days 00:00:0020
2122lt_1h_m_00 days 01:00:000
2223lt_1h_m_10 days 01:00:001
2324lt_1h_m_20 days 01:00:002
2425lt_1h_m_30 days 01:00:003
\n", + "
" + ], + "text/plain": [ + " event_id event_name lead_time member\n", + "0 1 lt_0h_m_0 0 days 00:00:00 0\n", + "1 2 lt_0h_m_1 0 days 00:00:00 1\n", + "2 3 lt_0h_m_2 0 days 00:00:00 2\n", + "3 4 lt_0h_m_3 0 days 00:00:00 3\n", + "4 5 lt_0h_m_4 0 days 00:00:00 4\n", + "5 6 lt_0h_m_5 0 days 00:00:00 5\n", + "6 7 lt_0h_m_6 0 days 00:00:00 6\n", + "7 8 lt_0h_m_7 0 days 00:00:00 7\n", + "8 9 lt_0h_m_8 0 days 00:00:00 8\n", + "9 10 lt_0h_m_9 0 days 00:00:00 9\n", + "10 11 lt_0h_m_10 0 days 00:00:00 10\n", + "11 12 lt_0h_m_11 0 days 00:00:00 11\n", + "12 13 lt_0h_m_12 0 days 00:00:00 12\n", + "13 14 lt_0h_m_13 0 days 00:00:00 13\n", + "14 15 lt_0h_m_14 0 days 00:00:00 14\n", + "15 16 lt_0h_m_15 0 days 00:00:00 15\n", + "16 17 lt_0h_m_16 0 days 00:00:00 16\n", + "17 18 lt_0h_m_17 0 days 00:00:00 17\n", + "18 19 lt_0h_m_18 0 days 00:00:00 18\n", + "19 20 lt_0h_m_19 0 days 00:00:00 19\n", + "20 21 lt_0h_m_20 0 days 00:00:00 20\n", + "21 22 lt_1h_m_0 0 days 01:00:00 0\n", + "22 23 lt_1h_m_1 0 days 01:00:00 1\n", + "23 24 lt_1h_m_2 0 days 01:00:00 2\n", + "24 25 lt_1h_m_3 0 days 01:00:00 3" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame.from_records(\n", + " {\n", + " \"member\": hazard_forecast.member,\n", + " \"lead_time\": hazard_forecast.lead_time,\n", + " \"event_name\": hazard_forecast.event_name,\n", + " \"event_id\": hazard_forecast.event_id,\n", + " }\n", + ").head(25)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "405f368f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Precipation Forecast for member 10 and lead time 78 hours')" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# select hazard forecast for a specific member and a specific lead time\n", + "test_member = 10\n", + "test_lead_time = np.timedelta64(78, \"h\")\n", + "\n", + "# plot\n", + "ax = hazard_forecast.select(\n", + " member=test_member,\n", + " lead_time=test_lead_time,\n", + ").plot_intensity(0)\n", + "ax.set_title(\n", + " f\"Precipation Forecast for member {test_member} and lead time \"\n", + " f\"{test_lead_time.astype('timedelta64[h]')}\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "665dc24c", + "metadata": {}, + "source": [ + "The two forecast attributes `member` and `lead_time` can be used to generate (centroid-wise) statistics by means of methods like, e.g.,\n", + "- `.max()` for the centroid-wise maximum of all lead times and ensemble members\n", + "- `.quantile(q=0.3, dim=\"member\")` for the 0.3-quantile of the hazard intensity over all ensemble members, for each lead time and centroid" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "f61e9d18", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", + " 17, 18, 19, 20])" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Reduce over dimension 'lead_time'\n", + "haz_max = hazard_forecast.max(dim=\"lead_time\")\n", + "haz_max.member" + ] + }, + { + "cell_type": "markdown", + "id": "cb0c6ec0", + "metadata": {}, + "source": [ + "This operation reduces over the dimension 'lead_time'.\n", + "The associated values are therefore set to placeholders; in this case, Not-a-Time (NaT)." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "6042eab2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(['NaT', 'NaT', 'NaT', 'NaT', 'NaT', 'NaT', 'NaT', 'NaT', 'NaT',\n", + " 'NaT', 'NaT', 'NaT', 'NaT', 'NaT', 'NaT', 'NaT', 'NaT', 'NaT',\n", + " 'NaT', 'NaT', 'NaT'], dtype=timedelta64)" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "haz_max.lead_time" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "8dad9c47", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the centroid-wise maximum over all lead times for 4 select members\n", + "fig, axes = plt.subplots(2, 2, subplot_kw={\"projection\": ccrs.Mercator()})\n", + "norm = mcolors.Normalize(vmin=0)\n", + "for idx, member in enumerate((0, 6, 12, 18)):\n", + " ax = axes.flat[idx]\n", + " haz_max.select(member=member).plot_intensity(0, axis=ax, norm=norm)\n", + " ax.set_title(f\"Member {member}\")" + ] + }, + { + "cell_type": "markdown", + "id": "0078ec6d", + "metadata": {}, + "source": [ + "We can also reduce over the 'member', leaving us with the ensemble median for each lead time." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "f654b44d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1]),\n", + " array([ 0, 3600000000000, 7200000000000, 10800000000000,\n", + " 14400000000000, 18000000000000, 21600000000000, 25200000000000,\n", + " 28800000000000, 32400000000000, 36000000000000, 39600000000000,\n", + " 43200000000000, 46800000000000, 50400000000000, 54000000000000,\n", + " 57600000000000, 61200000000000, 64800000000000, 68400000000000,\n", + " 72000000000000, 75600000000000, 79200000000000, 82800000000000,\n", + " 86400000000000, 90000000000000, 93600000000000, 97200000000000,\n", + " 100800000000000, 104400000000000, 108000000000000, 111600000000000,\n", + " 115200000000000, 118800000000000, 122400000000000, 126000000000000,\n", + " 129600000000000, 133200000000000, 136800000000000, 140400000000000,\n", + " 144000000000000, 147600000000000, 151200000000000, 154800000000000,\n", + " 158400000000000, 162000000000000, 165600000000000, 169200000000000,\n", + " 172800000000000, 176400000000000, 180000000000000, 183600000000000,\n", + " 187200000000000, 190800000000000, 194400000000000, 198000000000000,\n", + " 201600000000000, 205200000000000, 208800000000000, 212400000000000,\n", + " 216000000000000, 219600000000000, 223200000000000, 226800000000000,\n", + " 230400000000000, 234000000000000, 237600000000000, 241200000000000,\n", + " 244800000000000, 248400000000000, 252000000000000, 255600000000000,\n", + " 259200000000000, 262800000000000, 266400000000000, 270000000000000,\n", + " 273600000000000, 277200000000000, 280800000000000, 284400000000000,\n", + " 288000000000000, 291600000000000, 295200000000000, 298800000000000,\n", + " 302400000000000, 306000000000000, 309600000000000, 313200000000000,\n", + " 316800000000000, 320400000000000, 324000000000000, 327600000000000,\n", + " 331200000000000, 334800000000000, 338400000000000, 342000000000000,\n", + " 345600000000000, 349200000000000, 352800000000000, 356400000000000,\n", + " 360000000000000, 363600000000000, 367200000000000, 370800000000000,\n", + " 374400000000000, 378000000000000, 381600000000000, 385200000000000,\n", + " 388800000000000, 392400000000000, 396000000000000, 399600000000000,\n", + " 403200000000000, 406800000000000, 410400000000000],\n", + " dtype='timedelta64[ns]'))" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "haz_med = hazard_forecast.median(dim=\"member\")\n", + "haz_med.member, haz_med.lead_time" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "53988eff", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Median of members for Precipitation Forecast at lead time 78 hours')" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot median over member dimension for given a lead time\n", + "ax = haz_med.select(lead_time=test_lead_time).plot_intensity(0)\n", + "ax.set_title(\n", + " f\"Median of members for Precipitation Forecast at lead time {test_lead_time}\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "80320a31", + "metadata": {}, + "source": [ + "While most meteorological data come as `netCDF (.nc)`, `HazardForecast` objects can be \n", + "written to and read from `HDF5 (.h5)` files using the methods:\n", + "* `write_hdf5()`\n", + "* `from_hdf5()`" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "febfcc36", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-06-08 13:59:55,005 - climada.hazard.io - INFO - Writing /var/folders/9m/w030_m9j2j5gyjdjczm2tf680000gq/T/tmp87icnb4i/demo_hazard_forecast.h5\n", + "2026-06-08 13:59:55,145 - climada.hazard.centroids.centr - INFO - Writing /var/folders/9m/w030_m9j2j5gyjdjczm2tf680000gq/T/tmp87icnb4i/demo_hazard_forecast.h5\n", + "2026-06-08 13:59:55,270 - climada.hazard.io - INFO - Reading /var/folders/9m/w030_m9j2j5gyjdjczm2tf680000gq/T/tmp87icnb4i/demo_hazard_forecast.h5\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tempfile import TemporaryDirectory\n", + "\n", + "# write hazard forecast object to HDF5 file\n", + "with TemporaryDirectory() as tmpdir:\n", + " hazard_forecast.write_hdf5(Path(tmpdir) / \"demo_hazard_forecast.h5\")\n", + "\n", + " # read hazard forecast from HDF5 file\n", + " hazard_forecast_read = HazardForecast.from_hdf5(\n", + " Path(tmpdir) / \"demo_hazard_forecast.h5\"\n", + " )\n", + "\n", + "np.array_equal(\n", + " hazard_forecast_read.intensity.toarray(), hazard_forecast.intensity.toarray()\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "b6d37e42", + "metadata": {}, + "source": [ + "## 2. Impact Forecast calculation\n", + "\n", + "`HazardForecast` objects can be handed in to the standard `CLIMADA ImpactCalc` engine to produce `ImpactForecast` objects, consisting of one impact forecast per hazard forecast.\n", + "\n", + "\n", + "We exemplify this below by loading a population exposure layer for Switzerland and Liechtenstein, and by defining a step impact function. This impact function results in impacts describing how much population (how many people) are exposed to a precipitation of more than 50mm/h for the severe precipitation event in Misox loaded above." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "a71749bb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-06-08 13:59:55,450 - climada.entity.exposures.litpop.litpop - INFO - \n", + " LitPop: Init Exposure for country: CHE (756)...\n", + "\n", + "2026-06-08 13:59:55,586 - climada.entity.exposures.litpop.litpop - INFO - \n", + " LitPop: Init Exposure for country: LIE (438)...\n", + "\n", + "2026-06-08 13:59:55,622 - climada.entity.exposures.base - INFO - Hazard type not set in impf_\n", + "2026-06-08 13:59:55,623 - climada.entity.exposures.base - INFO - category_id not set.\n", + "2026-06-08 13:59:55,623 - climada.entity.exposures.base - INFO - cover not set.\n", + "2026-06-08 13:59:55,623 - climada.entity.exposures.base - INFO - deductible not set.\n", + "2026-06-08 13:59:55,623 - climada.entity.exposures.base - INFO - centr_ not set.\n", + "2026-06-08 13:59:55,630 - climada.entity.exposures.base - INFO - Matching 70525 exposures with 27000 centroids.\n", + "2026-06-08 13:59:55,667 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100 degree\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Read exposure for population\n", + "exp_che = LitPop.from_population(countries=[\"CHE\", \"LIE\"], res_arcsec=30)\n", + "# Assign centroids because hazard not on regular grid\n", + "exp_che.assign_centroids(hazard_forecast, threshold=100)\n", + "\n", + "# define impact functions\n", + "threshold_for_affected = 50\n", + "imp_fun_precip = ImpactFunc.from_step_impf(\n", + " (0, threshold_for_affected, 200),\n", + " haz_type=\"PR\",\n", + " impf_id=1,\n", + " intensity_unit=\"mm/h\",\n", + " name=\"Severe Precipitation Step Function\",\n", + ")\n", + "impf_set = ImpactFuncSet([imp_fun_precip])\n", + "impf_set.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "6f5b5fec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-06-08 13:59:55,763 - climada.entity.exposures.base - INFO - No specific impact function column found for hazard PR. Using the anonymous 'impf_' column.\n", + "2026-06-08 13:59:55,766 - climada.engine.impact_calc - INFO - Calculating impact for 69394 assets (>0) and 2415 events.\n", + "2026-06-08 13:59:55,930 - climada.engine.impact_calc - WARNING - eai_exp and aai_agg are undefined with forecasts. Setting them to NaN arrays.\n" + ] + } + ], + "source": [ + "# calculate impact\n", + "impact_forecast = ImpactCalc(exp_che, impf_set, hazard_forecast).impact(\n", + " assign_centroids=False, # assign_centroid=False because we do not want to reassign centroids\n", + ") # impact matrix is saved by default" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "0c3fbaa8", + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
event_idevent_namelead_timemember
01lt_0h_m_00 days 00:00:000
12lt_0h_m_10 days 00:00:001
23lt_0h_m_20 days 00:00:002
34lt_0h_m_30 days 00:00:003
45lt_0h_m_40 days 00:00:004
56lt_0h_m_50 days 00:00:005
67lt_0h_m_60 days 00:00:006
78lt_0h_m_70 days 00:00:007
89lt_0h_m_80 days 00:00:008
910lt_0h_m_90 days 00:00:009
1011lt_0h_m_100 days 00:00:0010
1112lt_0h_m_110 days 00:00:0011
1213lt_0h_m_120 days 00:00:0012
1314lt_0h_m_130 days 00:00:0013
1415lt_0h_m_140 days 00:00:0014
1516lt_0h_m_150 days 00:00:0015
1617lt_0h_m_160 days 00:00:0016
1718lt_0h_m_170 days 00:00:0017
1819lt_0h_m_180 days 00:00:0018
1920lt_0h_m_190 days 00:00:0019
2021lt_0h_m_200 days 00:00:0020
2122lt_1h_m_00 days 01:00:000
2223lt_1h_m_10 days 01:00:001
2324lt_1h_m_20 days 01:00:002
2425lt_1h_m_30 days 01:00:003
\n", + "
" + ], + "text/plain": [ + " event_id event_name lead_time member\n", + "0 1 lt_0h_m_0 0 days 00:00:00 0\n", + "1 2 lt_0h_m_1 0 days 00:00:00 1\n", + "2 3 lt_0h_m_2 0 days 00:00:00 2\n", + "3 4 lt_0h_m_3 0 days 00:00:00 3\n", + "4 5 lt_0h_m_4 0 days 00:00:00 4\n", + "5 6 lt_0h_m_5 0 days 00:00:00 5\n", + "6 7 lt_0h_m_6 0 days 00:00:00 6\n", + "7 8 lt_0h_m_7 0 days 00:00:00 7\n", + "8 9 lt_0h_m_8 0 days 00:00:00 8\n", + "9 10 lt_0h_m_9 0 days 00:00:00 9\n", + "10 11 lt_0h_m_10 0 days 00:00:00 10\n", + "11 12 lt_0h_m_11 0 days 00:00:00 11\n", + "12 13 lt_0h_m_12 0 days 00:00:00 12\n", + "13 14 lt_0h_m_13 0 days 00:00:00 13\n", + "14 15 lt_0h_m_14 0 days 00:00:00 14\n", + "15 16 lt_0h_m_15 0 days 00:00:00 15\n", + "16 17 lt_0h_m_16 0 days 00:00:00 16\n", + "17 18 lt_0h_m_17 0 days 00:00:00 17\n", + "18 19 lt_0h_m_18 0 days 00:00:00 18\n", + "19 20 lt_0h_m_19 0 days 00:00:00 19\n", + "20 21 lt_0h_m_20 0 days 00:00:00 20\n", + "21 22 lt_1h_m_0 0 days 01:00:00 0\n", + "22 23 lt_1h_m_1 0 days 01:00:00 1\n", + "23 24 lt_1h_m_2 0 days 01:00:00 2\n", + "24 25 lt_1h_m_3 0 days 01:00:00 3" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame.from_records(\n", + " {\n", + " \"member\": impact_forecast.member,\n", + " \"lead_time\": impact_forecast.lead_time,\n", + " \"event_name\": impact_forecast.event_name,\n", + " \"event_id\": impact_forecast.event_id,\n", + " }\n", + ").head(25)" + ] + }, + { + "cell_type": "markdown", + "id": "f216e6be", + "metadata": {}, + "source": [ + "## 3. Products based on ImpactForecast\n", + "\n", + "We can now analyse the impact forecasts by selecting specific ensemble member or lead times (or other impact attributes), or by computing statistics (min, max, quantile, mean) over the forecast dimensions `member` and `lead_time`.\n", + "\n", + "For the specific case of Misox, we will zoom in to the canton of Ticino which was most heavily affected." + ] + }, + { + "cell_type": "markdown", + "id": "c53712a0", + "metadata": {}, + "source": [ + "### 3.1 Per ensemble member, per lead time" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "dbe7bf12", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-06-08 13:59:55,979 - climada.engine.impact - INFO - The eai_exp and aai_agg are computed for the selected subset of events WITHOUT modification of the frequencies.\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Affected people from precip>50mm/h\\nfor member 10 and lead time 78 hours')" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# select for a specific member and a specific lead time and plot Ticino extent\n", + "\n", + "impact_forecast_1m_1lt = impact_forecast.select(\n", + " member=test_member,\n", + " lead_time=test_lead_time,\n", + ")\n", + "extent_ticino = [8.2, 9.3, 45.58, 47]\n", + "\n", + "fig = plt.figure()\n", + "ax = plt.axes(projection=ccrs.Mercator())\n", + "ax.add_feature(borders, linewidth=1)\n", + "ax.add_feature(admin1, edgecolor=\"gray\", linewidth=1.0, facecolor=\"none\")\n", + "ax.add_feature(lakes, facecolor=\"lightblue\")\n", + "\n", + "# plot impact forecast\n", + "impact_forecast_1m_1lt.plot_hexbin_impact_exposure(\n", + " event_id=impact_forecast_1m_1lt.event_id, pop_name=False, axis=ax\n", + ")\n", + "ax.set_extent(extent_ticino)\n", + "ax.set_title(\n", + " f\"Affected people from precip>{threshold_for_affected}mm/h\\nfor member \"\n", + " f\"{test_member} and lead time {test_lead_time.astype('timedelta64[h]')}\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "a4fee766", + "metadata": {}, + "source": [ + "### 3.2 All ensemble members, per lead time\n", + "\n", + "We can now easily compute the centroid-wise maximum impact over all lead times for each ensemble member." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "85532304", + "metadata": {}, + "outputs": [], + "source": [ + "imp_fct_all_mem_1lt = impact_forecast.max(dim=\"lead_time\")" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "2cdbf7bd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(\n", + " 3, 7, figsize=(20, 10), subplot_kw={\"projection\": ccrs.Mercator()}\n", + ")\n", + "fig.suptitle(f\"Affected people predicted by each member, at lead time {test_lead_time}\")\n", + "ax = ax.flatten()\n", + "for j, member in enumerate(imp_fct_all_mem_1lt.member):\n", + " ax[j].add_feature(borders, linewidth=1)\n", + " ax[j].add_feature(admin1, edgecolor=\"gray\", linewidth=1.0, facecolor=\"none\")\n", + " ax[j].add_feature(lakes, facecolor=\"lightblue\")\n", + "\n", + " # plot impact forecast\n", + " imp_fct_all_mem_1lt.plot_hexbin_impact_exposure(\n", + " event_id=imp_fct_all_mem_1lt.event_id[j],\n", + " pop_name=False,\n", + " axis=ax[j],\n", + " vmin=0,\n", + " vmax=110,\n", + " )\n", + " ax[j].set_extent(extent_ticino)\n", + " ax[j].set_title(f\"Member {j}\")" + ] + }, + { + "cell_type": "markdown", + "id": "c9eaa032", + "metadata": {}, + "source": [ + "Next, we can analyse the evolution of predicted number of affected people over Switzerland (member distribution shown as a histogram) with increasing forecast lead time." + ] + }, + { + "cell_type": "markdown", + "id": "300473fc", + "metadata": {}, + "source": [ + "### 3.3 All ensemble members and lead times" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "54e19cea", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-06-08 14:00:32,395 - climada.engine.impact - INFO - The eai_exp and aai_agg are computed for the selected subset of events WITHOUT modification of the frequencies.\n", + "2026-06-08 14:00:32,399 - climada.engine.impact - INFO - The eai_exp and aai_agg are computed for the selected subset of events WITHOUT modification of the frequencies.\n", + "2026-06-08 14:00:32,403 - climada.engine.impact - INFO - The eai_exp and aai_agg are computed for the selected subset of events WITHOUT modification of the frequencies.\n", + "2026-06-08 14:00:32,407 - climada.engine.impact - INFO - The eai_exp and aai_agg are computed for the selected subset of events WITHOUT modification of the frequencies.\n", + "2026-06-08 14:00:32,411 - climada.engine.impact - INFO - The eai_exp and aai_agg are computed for the selected subset of events WITHOUT modification of the frequencies.\n", + "2026-06-08 14:00:32,422 - climada.engine.impact - INFO - The eai_exp and aai_agg are computed for the selected subset of events WITHOUT modification of the frequencies.\n", + "2026-06-08 14:00:32,430 - climada.engine.impact - INFO - The eai_exp and aai_agg are computed for the selected subset of events WITHOUT modification of the frequencies.\n", + "2026-06-08 14:00:32,437 - climada.engine.impact - INFO - The eai_exp and aai_agg are computed for the selected subset of events WITHOUT modification of the frequencies.\n", + "2026-06-08 14:00:32,445 - climada.engine.impact - INFO - The eai_exp and aai_agg are computed for the selected subset of events WITHOUT modification of the frequencies.\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAApkAAAQnCAYAAACwv3dtAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAq3dJREFUeJzs/Ql4FGW+/39/Q5CAbBJwQwnIUUGQxYOgKAqIowIC4sIiAga3EVQQBkmUVcTgiIgDIiM6gsNhcX4Cg6AOyiLiNkAEcfQYoixBZFDBRGCIkPRzfe7zr366QxISKDpJ835dV12drq7uuruqu/qTe6mKCQQCAQMAAAB8VM7PFwMAAAAImQAAADgpqMkEAACA7wiZAAAA8B0hEwAAAL4jZAIAAMB3hEwAAAD4jpAJAAAA3xEyAQAAULIhc9asWRYTE1PgtHr1aivLVH69j//3//7fMZcdO3asW/Zk87b5tm3bgvPatWvnpuL46quvXJlDX6co8q5Lz1d5Jk2aZH56+umnbfHixQXuk9L+2Zo6dapdeOGFVqFCBVfeX375xUorbx/qs3Win+e5c+falClT7GSoV6+e3X333b693m+//Wa///3v7dxzz7XY2Fhr3ry5m793717r1auXnXXWWW4b3HLLLea3srSdSttns6h27drlPscbN24sseN1NPjwww+tR48edt5557njWfXq1e2qq66yl156yQ4cOBD2ubv55pvzfY3169cf934sS585P8TExLjPZ7R+tssfz5Nee+01a9iw4VHzGzVq5EeZcAzTp08v9jZSyBw3bpwLjDo4nMx1HW/IvP3224/6gf/v//5v++STT0r1Z0tf/EceecTuvfde69+/v5UvX96qVq1qZYnKftNNNx1XePryyy9tyJAhVtrpR/LPf/6z+4egRYsWVqVKFTd//PjxtmjRIvvLX/5i//Vf/2Xx8fG+r7ssbaeySj/EOsbp+Ob9A3Gin+9TzZgxY+zJJ590oVLfC30fDh48aB9//LELM2lpafb888+XdDFPObvK8Gf7uELmpZdeapdffrn/pUGRRCJw6cBy+umnl3i4q1atml155ZVWmv3rX/9yt/fdd5+1atXqpK7rP//5j1WqVMn31z3//PPdFM0U8rTtHnrooaPm68e0T58+JVY2nFynwue7OMf1/Pztb39zAfOee+6xmTNnhtWOdezY0R577DH3D39ZpONmxYoVS3WNX7R+tk9an0ztTB3M//rXv9oll1ziPtjNmjWzpUuXhi33448/2v3332916tSxuLg4O/PMM+3qq6+2999/P2w53e/QoYMLHXotLbNixYp8q42/+OILu+OOO1w1v2olhg4dakeOHLFvvvnGJX7VMuk/gj/+8Y/5lv3QoUPuOeecc477UWrbtq19/vnnRXrfCxYssNatW1vlypVdTcmNN95Y5Od++umn7n3py1C7dm1LTk62w4cPH7Vcfs3lqqXR9tU69f5U0/z444+7x9QMoO0h7du3D3Zv8JoH9Fr6x2HNmjXuP1ht3wEDBhS4LsnNzbUJEyZYQkKCK6/+6ci7P9SEl1+tad7qff2tZpjZs2cHy+ats6Dm8iVLlrjtrLLq/f7ud7876gDorUchsHfv3u7zcPbZZ7v3lpmZaUWh2i1tV71HfZa6d+9uX3/9ddi+uOuuu9zfV1xxhVtfYU2XXpn0mbj11lvd51nl0mvouxDKa45auHChXXbZZa4M+m9Wdu/ebQ888IA7uKhJ64ILLnCP6XOe9z9gNX1pG2k9PXv2dM891j4JrYHTdtbnSpP+i3711VeD733ZsmW2ffv2sG4zoc3TTz31lPsset/txMTEo96nPuP6AdP3TfuzTZs29s9//tOKSu9b2177R9tTtd8qYyAQCC6jcr3yyivuxyb0869bHVu0T/N2+ylq+cvCdvKaBHXMO9b3VtauXeuOt/rcaF06Lug9hPK233vvvefKq+2v416XLl3su+++K1KTflG6/qSnp7vXv+iii1xZ1IyrdWzevDm4jPZZy5Yt3d9a1tvGXjNkfp9vHcO0Pbztru4S/fr1s507dx5VRh0f161bZ9dcc40rQ/369W3ixInuNY5Fvyc6lus7qu+qyj9o0KCwLjVqwalbt26+r6fPtj7THn2u1cKkz5h+n2rUqOFagfJu88KO6/lRwNRr/elPf8r3WKDPwg033GB+8o7vc+bMKdJvrprhu3bt6j5r+vzquPjGG2/k+7lcvny5e7/6Pum9Z2dnF6tsW7ZssTvvvNN9LvT5UI558cUXj9q3w4YNc/vCyxs6Dvz9738/6vWysrJcRUTNmjXdMUJZRDXDRdlGxf1se78dylvaRtqmKr+Xv7SNdF/fV1WMaLsez7YukkAxvPbaazpqBz799NPA4cOHw6YjR46ELavl6tWrF2jVqlXgjTfeCLz99tuBdu3aBcqXLx/49ttvg8vdeOONgTPPPDPw8ssvB1avXh1YvHhxYPTo0YH58+cHl/nrX/8aiImJCdxyyy2BhQsXBt56663AzTffHIiNjQ28//77weXGjBnj1tugQYPA+PHjA++9917gsccec/MeeuihQMOGDQN/+tOf3PzExEQ3/8033ww+f9WqVW5enTp1At26dXPrmTNnTuDCCy8MVKtWLazc3rpCTZgwwZVzwIABgaVLl7qytm7dOlC5cuXAv/71r0K3rR4//fTTA40aNQrMmzcv8Pe//91tm4SEBLeerVu3Bpdt27atmzxaXss8/PDDgeXLl7ttMmPGjMAjjzziHt+zZ0/g6aefdsu8+OKLgU8++cRNmu+9Xnx8vHvfU6dOddvhgw8+yHddKoe3jdq0aeO239/+9rdAy5YtA6eddlrg448/Di7bv3//QN26dY96r3m3ncpSqVKlQKdOnYJl87aXt0906/mf//kfN++GG25wn5cFCxYEWrRoEahQoULgww8/zPfzoM+U9vvkyZMDcXFxbv8fi7fNevfuHVi2bFng9ddfD9SvXz9QvXr1QFpaWnC/jRw50i2n74fKnp6eXuBremXSdhk+fHjgH//4hyuTPiOXXXZZ4Lfffgsuq2XOPfdct86//OUvbhv885//DPzwww9u++vxP//5z25/6/Ou93X33XcHn3/w4MHAJZdc4sqr/ap16TPhfaZU3oL2iYwaNcrNu/XWW90+1mdLZdV8771fffXVgXPOOSe43zRJTk5O4KabbnLva9y4cW7bv/LKK4HzzjvPfcZVttDPib432h7eOrScvnN67Fj0nl999VW3Dk3aFvo8ab0elUufL833yrl79253q+2ubezNz8zMLFb5y8J2Ks73VsdhzdN3St8tfcf0XdO6Q4/L3u+BXlPHvHfeeccdx8866yw3b9++fWGf5fzKWNDxJfSzqWPRsGHDAv/v//0/9/eiRYvcb4H25f/+7/+6ZbTPvPLo++ht44yMjAI/3/fff3/wt+Hdd991x0z9FqnsP/74Y1gZa9asGbjooovcMtpHAwcOdM+dPXt2ods9NzfXHcf1u6fPg/bbpEmTgt/3Q4cOueV0vNfr6bVDff31126+frc89913n9s/2iYq99y5c91v29lnn+0+06HlLui4nteuXbvcenr27BkoKu1TfafyZgFNygh592N+ivObu3LlSneMv+aaa9znUu9d3/286/E+B/puaB/rc6nPTt6MUthnTt9ZHTebNGnijvvab9re5cqVC4wdOza43C+//OLKoIyi8qlMf/jDH9xyoZ+N3NzcQPv27d0xWjlBr6fPpI47Wrf+LsjxfLa1b84///zApZde6vKB8tcVV1zhPjf6LdTxSPlE36WLL77YfXZCjzVF3dZFcVwhM79JgS/shc1cwbOysoLz9AXQxk9JSQnOq1KlSmDIkCEFrvPAgQPui9KlS5ew+To4N2vWzIVYj7exn3vuubBlmzdv7uZro3r0RdABRT8MeT/w//3f/+0+FJ5t27a5nXPvvfcetS7Pjh073IFEQS/Ur7/+6n5cevToESiMvtw6aIYeJPSl0MHjWCFTB8kzzjij0NfXD0resBb6enpsxYoVRf4RqF27duA///lPcL72s/bT9ddfX+yQKTro5vcjlDdkar9r3fry6+/Q7awft6uuuuqo9fzxj38Me039QFSsWDFsH+elH0gv+IbSftaB4s477zzqe7Fu3boCXy9vmR599NGw+V5w1gHWo22n79U333wTtuwDDzzgvjfbt28Pm68fL72GF9Bfeukld18/YKH0I3WskPndd9+5dffp06fQ99O5c+d897H3j0/oP3GibaT506dPD/sRLWh7FCVkhtJnQt/tJ5980gWD0H2s19LnLC99vhs3bnxc5S8r26k439srr7zSfZf0nQo9FukHSz9c3jb1Pvfdu3cPW9dHH33k5j/11FO+hMy8VBb9M6bQF7o9vG2W33Pzfr697aljQajPPvvMzX/88cfDyqh5eiyU/glQgCyMfpzzOwbph1vzFcpFn1n9XoYeV0SVJPqx/+mnn9x9hYv8fuMUOHS80vJFOa7n5YXCpKSkQFFpnxaUB7ypqCGzKL+5+i1UMNe2CqUKJ/0z7v0eeJ/Lfv36Fel95PeZ037VZ10BL5R+a/XbsXfv3gI/myrfPffc48rqUdDVOl544YVAKAXOY4XM4n62vX2jz8POnTuD8zZu3OiW07ZSrvLon0jNX7JkSbG3dVEcV3P566+/7poOQqfPPvvsqOXUNBs6AEJNlap6VrORR1W1qrpVc5Gai/M2D6vDsUZ/akCFmgK9Sc0Kqm7WukNHvEneEW+qFlZ1svqVeDQ4Q6OBQ8viURV5aPWzmjHU3LBq1aoCt8k//vEPVy41t4SWU9XMqvo/1uhovbaap7SNPBoBq+bNY9E2VNOLmoRVTf/TTz9ZcamZ5Lrrrivy8mrq1XvzaD+rCUtNMzk5OXayqMuDmoD79u1r5cr9/z++an647bbb3GdI/Y5Cqco/VNOmTV0zx549ewpcj5re1bSat4lP3Tq0nfJrYiyOvP3/1KStz2Tez5jKevHFF4fNU5OHvlvqUhH6WfM+3x988IG71Wtpv+R9//p8H4uaQLUf1ax3PFTGM844w30mQsuoZiU1iXnfB+/9FrQ9imLlypV2/fXXu+YqfWdOO+00Gz16tP3888+F7mM/yl+WtlNRvrc6lupYruZXb2CUaLvqO6emZH0HQ+Utk46VOmYWdrwsDm0PDQxU/3A1N+v96lbNmaFdV4rDK1ve77eOpfq9yPv91r7I299a3838fj/yfjbzW4+6L6mp0luP3pO6zKhrjNeVR/tD3c26devmmli9z4t+m7Rs6OdF5VO3nry/M8U9rheXumzkzQKalBGK41i/ueoy8b//+7/Bz1roe+/UqZP98MMPR30u9XtwPPTboP2irlFqZs+7Lj2u35nQvqzq5qbvi/ajjj/qKhP62VxVwPe3KMfi46VjiLpmePS59rpRhPbL9eZ7n+Xj2da+D/xRoYoy8Mf7YoRS3wb9eIf2YVTAVH+pUaNGuR2lnau+Mvri/Pvf/3bL6aBXEIVQfWE9eUeH6oCkjRp6cPXmq59EXlpvfvM2bdpUYBm8cnp9J/IKDUT50Q9iQes9Fh389QFQZ219sRTAVQ5tV/VVLAqd1qU4Ciqr+pft37/f/eCfDNpOBZVXoUvvfd++fWFforyfQ30GJfRzWNz1KFyciLzbTwcnldNbrye/9euz9tZbb7mDWX68fzL0WqH/tBS07vx4/QGPt0O5yqh/fPQdO1YZC9sex6I+ieonpgOnPv9eH1WdDkt9Dwvbx36Uv6xsp6J+b3/99VfX56+gz31oWY71mnmXO17qq6e+cCNGjHD/sCs46XiqUbXHu3+P9f3OGx6L8ltW0Hq0j9QvMJQCVd5tpP6Dzz33nM2fP9/1t1bFhX7Q1Q8v9POi/ZPf91rUV/R4juvqoytbt2614tBx3o9BwMf6zfV+X//whz+4KT95K1eK+5vm0T7R76nOQqGpsHXpnwL9o6d/GoYPH+7KrP2tMRLqz5/3c5D3c1SUY/Hxyi8HFTZf4fl4t7XvIdNPtWrVcueP07Rjxw43oCMpKcnVQLz77rvucdHOLmiUcUFfuOOV38AIzSvsYO6VU+fY1H9hxaXXLmi9RaEDkSbVRKhWQqeiUI2uOhYXpTzFHXVXUFn1gfVqQBTq8+tsfTw1rR5vH+jgm5dqOPXjox+hE3Ws9Xj7+3hpW4X+l6mDmg5EeT9j+e0XrVu1KApR+fHCgF4rv4EhRflMeT+KqrlS7W1xqYxav77D+fFaOLz3W9D2OBb9ICtsq4Yn9J/I/M65ejLKX1a2U1G/t/oh1HeooM+9V+aivKZaijyFHQuO9V3SoBC1EKk2M+9zVQt8ot/vvP8g+PH9Dl2P9pH+GQkNmgqK2kahlRKqqVVtqU4RqJCpW32XQwfbqFw6Juhclt4/y6HyzivqcV2BrEmTJm6wTGEj0E+WY/3mevtDA6hUG5+fBg0ahN0/3pHk+v3wau4LaqHQIC7vs6m/VVkWur68n/Wa/9/nIO8xvqi/75F0PNu6zFzxR/9NaUS6at9SU1PdPFVD60Ci8zzqP6b8poJqAY7XvHnzwkam6r9aNdsXNgpSo8h1gP72228LLGdh1PypKnrvvwivuUQf3uJQja6aTZ944glXO+GdXqcotXfFof/gvP98RDUgql3T6Et9Qb0RbvpnIfQ9qUz6D/14agW8D7d+ZDWaN3QfKVy/+eabwRHnJ0qvoxF5OoiEUphQE5i6NpyI//mf/wm7r1F7OggV5ST7+ufBO+1Ofp8zL2TqM6X9on/cQmnbHYt+2LQf9R95YQrabyqjDqj6DOdXRu8g5b3fgrbHsejAru+d95kTlUfNjCeiqOUvK9upqN9bHT80mlnLhZZXLQT6LiiQ5e2+kbdMOlbqmBn6WdaxQGf9CKV/gIvS7KZ9nDc8aaT7999/HzavOMc4rwk57/dbTb1q5jzR77fHe52869GxSsesvOtRRYG6K2h0v/aLuomFfrb1edFxT+89v8+LguLxUkuiWoF0zt/QY6tHNd0KoSfDsX5z9T3Q2QVUs1nQ76tf5ybW74eOnRrdrn/m81uXFxT12fQuwBEaHPOOLm/fvn2+35WiHItPxu93Yfze1sdVk6kfuPwObPrRy9ssUBj1PdHGV78EnUZCBdeXXP/Vewla/12rFlNfNjWLq9lc/Tr1n6E2gm6PdYAvLgUjNdnrdAMqo2oF9Z+4kn1BdBDVKSAU7nQqCfUX1X9ECliqTdLB2zv9TH5GjhzpwoAOfupPpg+6mojy9jfNj8qpQKRArv9I9SFPSUlxTRnef8o6lYW8/PLLbjvr/eg/sOI0tYXSgU//DKgpSz9AzzzzjOt6EPoe1Z9U70VXU1FTgn7cdHqM/Pps6uCo/kQ6sOo9qIz5/bekWhZ1pVB/ER1w9R+//mt89tlnXbOjTiviB/1jo4OuTgOlWhT1d1UY0PvTttNn4kToR1zhSNtQ/whoXepTpaaXY9HnTM316rOkHwRtJ21bnabm7bffthkzZrgwoHLrxMm6Va2nDhx6PL+Qn9/nWe9dJ2TWgc07BZT+2VMNkreftd/0XvQd1AnOtX90ENI+1wFVfXgGDx7samhU46iQrv5J6mem75i63qh/mVoy9Lj6Vur4oitK6XREx9K5c2ebPHmyO4boVGjaR3pufrU8xVHU8peV7VSc762OHVpGx2Y1l+lHVKfM0foUBvLWEOlUJ2q6VpNhRkaGOwbqH8GBAwcGl1GtkMqveerSoxCh73FRfi/0PVe/ff1G6Ed/w4YN7vuetwZSvz86Dmp7anvpt0P/cHn/dIXSd0afF/22aF/oH3N9f/Q9VI30o48+an7QdlQFhJr6tZ11jFbY1vFDp4TRdgmlz4/2jW51XMvbl1PPV7kVRrXdr732WvfbohpZBVN9zh588MHjKqv2n96/Psvqk6fzZXonY1fw1YUMdEz3+zRGRf3N1fq1n7Q9tV30GVMm0D8FqpRS30i/vPDCC66/qf750vbU91z/kKm/on6jvL623inm9LlWNtHnX9tPv2HqM+zRNtO+0inI9Juu7/5HH31U5H+Gi/PZ9oOv29qv0eWaZs6cGVxW9wcNGnTUa4SOMtTpG37/+98HmjZt6k5XoNFQOt2MRkuFjn4SnXpBIzQ1ElKjznR6At3XqOm8o6xCTz9RnFGl3kg3nY5Ap3rR6HONJNYw/vXr1x9zRJc3UkunKtD70XP1fm+//fawUy0VRKMyNbJTz9OIdJ2qRKMPjzW6XKdK0Do1OlEjETWCVKPZv/jii7DXnzJlSuCCCy5wo2FDR6rlN7q2oHV5I/GeeeYZd8oVjcDTOjUSTafIyUunTtDofu1bna5h2rRp+W47jXzTaRV0Gic95q0zv1MYedtZp2TQSD/t2w4dOrjtF6qgz4P3OQ7dpgXR6WT0+dR71CktdJqNvKejOp7R5Rs2bHBnTNAo8apVq7rTJP373/8OW1afHX3G86P3pM+o9qe+D/pe6JQzTzzxRGD//v3B5TS68LbbbguuR3/rdDVFOYWR6PQdOs2NtrNeQ/s59HkaZanPt85uoFPchL6GRiZqxLvOAuE9X6MWNTp+y5YtweWys7Pd6UE0olnL6TugUbQFjUjOS6d30nFD3xt9xnT2Cp3SKO8+Ls7o8uKUvyxsp+J+b3UqsOuuu85tL313tS6dXia/z71Ox9K3b1/33rwzMuTdPho5rBHW2j8q++WXX+5Ok1KU0eU604NG6+p96/igUzCpfHmf643W17bTdyJ01G5+n2+NkNX20ClctHytWrUCd911V/DUMMf6fBR09oy8NJp/xIgRblmtR6NzH3zwwbBTPIXSCHOVVcfDwj7zOv55++e//uu/3Gjq0N+pwo7rhdFvrT6rKqfKq98ynYrv2WefDTtbTGHHp8JGQ4cqzm+ubNq0yf226bOgsul3Up9TnVrqeI7HhZ3RQPN1ai5lDa1LZdPZS0LPmiATJ050p2tUuXXKOOWg/D5vv/zyi3s9fU/0Of7d737nTsFVlNHlxf1sF7Rv8stl3vvX/i3uti6KmP9vxQAiQCfOVa2RauD96vcFHItq6dRyoRrAgjrzF5dqF1WjptYnrgCH46HWK9WYq2assMG9KLtKVZ9MAAAARAdCJgAAAHxHczkAAAB8R00mAAAAfEfIBAAAgO8ImQAAAPAdIRMAAAC+I2QCAADAd4RMAAAA+O64rl0OlDRdd3nXrl3uGud5r6UMADg+ugigrtOt62Lruu7AiSBkokxSwKxTp05JFwMAolJGRoadf/75JV0MlHGETJRJqsH0DoTVqlUr6eIAQFTIyspy/8B7x1jgRBAyUSZ5TeQKmIRMADg5x1jgRNDhAgAAAL4jZAIAAMB3NJfjlFUvaZlFk20TO5d0EQAACKImEwAAAL4jZAIAAMB3hEwAAAD4jpAJAAAA3xEyAQAA4DtCJgBEqXbt2tmQIUNK7Xp0wu/FixdbNDsV3iNQEEImAOCkGjt2rDVv3vyo+T/88IN17Nix1Gz9ZcuW2RVXXGGVKlWyWrVq2a233hr2+IoVK+yqq65yl1w899xzbcSIEXbkyJESKy9Q2hEyAQAl4pxzzrG4uLhSsfXffPNN69u3ryUmJtqmTZvso48+sjvvvDP4+BdffGGdOnWym266yT7//HObP3++LVmyxJKSkqw0Onz4cEkXASBkAsCp4rfffrPHHnvMzjvvPKtcubKrtVu9enXw8Z9//tl69+5t559/vp1++unWpEkTmzdvXthrHDhwwPr162dVqlRxtXnPPfdcoeucNWuWjRs3zgU3NR1r0ry8Tcnbtm1z99944w275pprXG1iy5YtLS0tzdatW2eXX365W6dC3o8//hi2jtdee80uueQSq1ixojVs2NCmT59erO2i2sjBgwfbs88+a7///e/t4osvtgYNGtjtt98eXEahsmnTpjZ69Gi78MILrW3btpaSkmIvvvii/frrr4W+/k8//WTdu3d32/Siiy5y4TTUBx98YK1atXKBW9tUwTW0hrRevXo2ZcqUsOeoZlg1xB5tuxkzZli3bt3cvn3qqads37591qdPHzvzzDPd9tS6ta2ASKEmEwBOEaqlUw2dApNq5u644w4X2rZs2eIeP3TokLVo0cKWLl1qX375pd1///2udu+zzz4Lvsbw4cNt1apVtmjRIlu+fLkLqRs2bChwnT179rRhw4ZZ48aNXfO4Js0ryJgxY2zkyJGWmppq5cuXd6FXwfiFF16wDz/80L799lsX9DwzZ860J554wiZMmGBff/21Pf300zZq1CibPXt2WJ/Ru+++u8B1al3ff/+9lStXzi677DIX9NSM/69//Su4THZ2tguxoRTctM0Ke/+ikN2jR49gbaiC3969e91jWq/mKVAriL/00kv26quvupBYXNp2CpmbN2+2AQMGuO3w1Vdf2TvvvOO2jV5b3QCASOGykgBwClA4U63kzp07rXbt2m7eH/7wB3v33Xdd7ZbCmWo4Nc/z8MMPu8f/9re/uVrP/fv3uwD0+uuv2+9+9zu3jMKcaj4LoiCmGkgFRjWPH4vWf+ONN7q/VbuokKm+kFdffbWbd8899wRrQmX8+PGuNtXrP3nBBRe4YPXnP//Z+vfv7+YlJCS44FiQ7777zt2qZnDy5Mmu5lCvqdpK1aTGx8e7Mqk2UdtQgXH37t3BIKjgXBgFXL0P0XaeOnWq/fOf/3QBX7WuderUsWnTprnaSNXE7tq1y/X3VJhW8C0qNe8rXHp27NjhQrNqgUXvC4gkQiYAnAJUWxcIBFxTcCjV0NWsWdP9nZOTYxMnTrQFCxa4GjY9pknNr15QVZN769atg89XAFPTsl/UJO05++yz3a2a7UPn7dmzx/2tZvOMjAwXPO+7777gMmpqrl69evC+QnFhcnNz3a1qRG+77Tb3t4K3wrMC9gMPPGA33HBDsDldtbtq2lZN4dq1ay02NrbI70nbUgOHvPegGkZtTwVMjwK1Ar3+IVBALiovTHoefPBB936071X+W265xQ1cAiKFkAkApwAFKYUhNe3mDUWqaRTV3j3//POuxk7BToFIpyZSsBSF1JPttNNOC/7tBa+887xQ6N2qyVw1raGOFfxCebWcjRo1Cs5TiKxfv76rDfQMHTrUHn30UVdzWaNGDdePNDk52dWeFvU95X0P2qahAdObF/r+VZuZd9vnN7DH+2fAoyb/7du3u1Hz77//vnXo0MEGDRpkkyZNOsYWAfxBn0wAOAWo2VQ1lapB08CV0MlrxlafR/Xpu+uuu6xZs2YuZHn9NUXLKjB9+umnwXkaXKIm5cJUqFDBrdtvqtVUE7+au/O+p2MFv1Dqh6pQ+c0334SFOIXIunXrhi2r4KfuBuoGoKZzNXX/93//93G/BwXbjz/+OCxE6r5qO/XeRAN3Qpvks7KybOvWrUV6fT1XzfVz5sxx/zy8/PLLx11WoLioyQSAU4CayTXgRCPDVWOp0KlRzytXrnS1lhp8onCmU/ko5KimTv0T1fdQI7e9Gk81TWvwj5rYFfLUxHysfoPqC6hQtHHjRtcErQDl16mL1I/ykUcesWrVqrmaOzXvr1+/3oVf1TyK3rMCm0aD50fPVTO4Bs4oNCpYqmlcNDjKo3nqR6n3u3DhQte1QKPhi1NrmtfAgQNd+FP/14ceesgFXZVDZfe263XXXef6oXbp0sXtFzXTF2Wd6tOpAK1BV9ouGtDl7UsgEgiZAHCKUD9DDVbRaG/1uVRQVH9ABUxReFEY1CAXnW5Ho8vVjy8zMzMsaKm/YNeuXV1Y1GuFPp4f9QtUKGvfvr398ssvrhyFjfYujnvvvdeVVeXSKHQ1GSs0h16BSE3exwrCer4GJ6m/5X/+8x/X/K4ArlDn0ShtjWJXYFNN79///vcTPpm8wu/bb7/tgrteU31cFeQ1wt6jJnnV1t58882ur6kGOxWlJlM1yHquamRV86pTQ+nMAkCkxAQi0ckG8Jmai3Sw1Y+baiGOR72kZVG1X7ZN7FzSRQBQxvlxbAU89MkEAACA7wiZAAAA8B0hEwAAAL4jZMJ3a9ascaMgdZqP0GsTh9IJiDVwQH1/NHjgyiuvDDsfHQAAKNsImfDdgQMH3ChJXSYtP7pqSJs2bdzl03TdY12vV6Na814XGAAAlF2cwgi+0yk9Cjuth86rp1Om/PGPfwzO00mfAQBA9KAmExGlS6npEmc6MbTOxXfWWWe589Hl16QeSuel06k1QicAAFB6ETIRUbqknU7krCtl6MoZy5cvt+7du9utt95qH3zwQYHP05U61H/Tm3RVDgAAUHoRMhHxmkzR9ZEfffRRa968uSUlJbkrWcyYMaPA5+mqFTo5sDdlZGREsNQAAKC46JOJiKpVq5a7dFujRo3C5ut6umvXri3webrOsV/XOgYAACcfNZmIKF1Lt2XLlvbNN9+EzU9LS7O6deuyNwAAiBLUZMJ36nOZnp4evL9161bbuHGjxcfHW0JCgg0fPtx69uxp1157rbVv397effdde+utt9zpjAAAQHQgZMJ369evd+HRM3ToUHfbv39/mzVrlhvoo/6XGszzyCOPWIMGDezNN990584EAADRgZAJ37Vr184CgUChywwYMMBNAAAgOtEnEwAAAL4jZAIAAMB3hEwAAAD4jpAJAAAA3xEyAQAA4DtCJgAAAHxHyAQAAIDvCJkAAADwHSETAAAAviNkwndr1qyxLl26WO3atS0mJsYWL14cfOzw4cM2YsQIa9KkiVWuXNkt069fP9u1axd7AgCAKELIhO8OHDhgzZo1s2nTph312MGDBy01NdVGjRrlbhcuXGhpaWnWtWtX9gQAAFGEa5fDdx07dnRTfqpXr27vvfde2LypU6daq1atbMeOHZaQkMAeAQAgChAyUeIyMzNds/oZZ5xR4DLZ2dlu8mRlZUWodAAA4HjQXI4SdejQIUtKSrI777zTqlWrVuByKSkprhbUm+rUqRPRcgIAgOIhZKLEaBBQr169LDc316ZPn17ossnJya7G05syMjIiVk4AAFB8NJejxAJmjx49bOvWrbZy5cpCazElLi7OTQAAoGwgZKLEAuaWLVts1apVVrNmTfYCAABRhpAJ3+3fv9/S09OD91VbuXHjRouPj3fnxbz99tvd6YuWLl1qOTk5tnv3brecHq9QoQJ7BACAKEDIhO/Wr19v7du3D94fOnSou+3fv7+NHTvWlixZ4u43b9487Hmq1WzXrh17BACAKEDIhO8UFAOBQIGPF/YYAACIDowuBwAAgO8ImQAAAPAdIRMAAAC+I2QCAADAd4RMAAAA+I6QCQAAAN8RMgEAAOA7QiYAAAB8R8gEAACA7wiZiLgjR47YyJEj7YILLrBKlSpZ/fr17cknn7Tc3Fz2BgAAUYLLSiLinnnmGZsxY4bNnj3bGjdu7K51npiYaNWrV7fBgwezRwAAiAKETETcJ598Yt26dbPOnTu7+/Xq1bN58+a5sAkAAKIDzeWIuDZt2tiKFSssLS3N3d+0aZOtXbvWOnXqxN4AACBKUJOJiBsxYoRlZmZaw4YNLTY21nJycmzChAnWu3fvAp+TnZ3tJk9WVlaESgsAAI4HNZmIuAULFticOXNs7ty5lpqa6vpmTpo0yd0WJCUlxfXZ9KY6depEtMwAAKB4YgKBQKCYzwFOiAJiUlKSDRo0KDjvqaeecsHzf//3f4tck6nXUY1otWrVjqsc9ZKWWTTZNvH/+rgCwPHSsVX/yJ/IsRXw0FyOiDt48KCVKxdeia5m88JOYRQXF+cmAABQNhAyEXFdunRxfTATEhLcKYw+//xzmzx5sg0YMIC9AQBAlCBkIuKmTp1qo0aNsoEDB9qePXusdu3a9sADD9jo0aPZGwAARAlCJiKuatWqNmXKFDcBAIDoxOhyAAAA+I6QCQAAAN8RMgEAAOA7QiYAAAB8R8gEAACA7wiZAAAA8B0hEwAAAL4jZAIAAMB3hEwAAAD4jpAJAAAA3xEyUeJSUlIsJibGhgwZUtJFAQAAPiFkokStW7fOXn75ZWvatCl7AgCAKELIRInZv3+/9enTx2bOnGk1atRgTwAAEEUImSgxgwYNss6dO9v1119/zGWzs7MtKysrbAIAAKVX+ZIuAE5N8+fPt9TUVNdcXtR+m+PGjTvp5QIAAP6gJhMRl5GRYYMHD7Y5c+ZYxYoVi/Sc5ORky8zMDE56DQAAUHpRk4mI27Bhg+3Zs8datGgRnJeTk2Nr1qyxadOmuabx2NjYsOfExcW5CQAAlA2ETERchw4dbPPmzWHzEhMTrWHDhjZixIijAiYAACh7CJmIuKpVq9qll14aNq9y5cpWs2bNo+YDAICyiT6ZAAAA8B01mSgVVq9eXdJFAAAAPqImEwAAAL4jZAIAAMB3hEwAAAD4jpAJAAAA3xEyAQAA4DtCJgAAAHxHyAQAAIDvCJkAAADwHSETAAAAviNkAgAAwHeETAAAAPiOkAkAAADflff/JYGTLycnx93u3LnTqlWrdlyvcSTrJ4sm2hYAcCKysrLCjrHAiSBkokxKT093t40bNy7popQadV4q6RIAiKZjbMuWLUu6GCjjYgKBQKCkCwEU1759+yw+Pt4yMjKOuyYTAHB0TWadOnVs7969VqNGDTYPTgg1mSiTYmNj3a0CJiETAE7OMRY4EQz8AQAAgO8ImQAAAPAdIRMAAAC+I2QCAADAd4RMAAAA+I6QCQAAAN8RMgEAAOA7QiYAAAB8R8gEgCjVrl07GzJkSKldT0xMjC1evNii2anwHoGCEDIBACfV2LFjrXnz5kfN/+GHH6xjx44lvvVXr17twmB+07p164LLDR482Fq0aGFxcXH5vh8A4bisJACgRJxzzjmlYstfddVVLvCGGjVqlL3//vt2+eWXB+cFAgEbMGCAffbZZ/bFF19YaXb48GE77bTTSroYOMVRkwkAp4jffvvNHnvsMTvvvPOscuXKdsUVV7haPM/PP/9svXv3tvPPP99OP/10a9Kkic2bNy/sNQ4cOGD9+vWzKlWq2LnnnmvPPfdcoeucNWuWjRs3zjZt2hSsHdS8vE3J27Ztc/ffeOMNu+aaa6xSpUrWsmVLS0tLc7WJCnta50033WQ//vhj2Dpee+01u+SSS6xixYrWsGFDmz59erG2S4UKFVzg9aaaNWvakiVLXKBUmTx/+tOfbNCgQVa/fv1ivf5PP/1k3bt3d9v0oosucq8d6oMPPrBWrVq5GlJt06SkJDty5Ejw8Xr16tmUKVPCnqOaVNUQe1TOGTNmWLdu3dy+feqpp2zfvn3Wp08fO/PMM9321Lq1rYBIIWQCwCkiMTHRPvroI5s/f76ribvjjjtcaNuyZYt7/NChQ645eOnSpfbll1/a/fffb3379nU1d57hw4fbqlWrbNGiRbZ8+XIXUjds2FDgOnv27GnDhg2zxo0bu9pCTZpXkDFjxtjIkSMtNTXVypcv70KvgvELL7xgH374oX377bc2evTo4PIzZ860J554wiZMmGBff/21Pf30064Wcvbs2WF9Ru++++4ibyeFQAXD4jynMArZPXr0cNu8U6dOLvjt3bvXPfb999+7eQrUCuIvvfSSvfrqqy4kFpe2nULm5s2bXUDWdvjqq6/snXfecdtGr12rVi1f3hNQJAGgDMrMzAzo46tbAPlr27ZtYPDgwe7v9PT0QExMTOD7778PW6ZDhw6B5OTkAjdhp06dAsOGDXN///rrr4EKFSoE5s+fH3z8559/DlSqVCm4nvyMGTMm0KxZs6Pm6zu8aNEi9/fWrVvd/VdeeSX4+Lx589y8FStWBOelpKQEGjRoELxfp06dwNy5c8Ned/z48YHWrVsH7/ft2zeQlJQUKKqOHTu6qbjvJz8q/8iRI4P39+/f7/bDO++84+4//vjj7v3k5uYGl3nxxRcDVapUCeTk5Lj7devWDTz//PNhr6v1qxyh6xkyZEjYMl26dAkkJiYGioNjK/xEn0wAOAWoZlBZ5OKLLw6bn52d7ZqHJScnxyZOnGgLFixwNWx6TJOaX0W1iGpyb926dfD58fHx1qBBA9/K2bRp0+DfZ599trtVs33ovD179ri/1WyekZFh99xzj913333BZdTUXL169eD9119/vcjr37lzp/3jH/9wzfYn4z1pW1atWjX4HlTDqO0Z2ix/9dVX2/79+11ZEhISirye0P6j8uCDD9ptt93m9v0NN9xgt9xyi+t/CkQKIRMATgG5ubkWGxvrmrZ1G0p9HUX9K59//nnX/0/BToFIpyZSsJT/qzA7uUIHq3jBK+88vRfvPXlN5upfGirveywq9VlU6O7atav5Je8AnND3oG0aGjC9ed5yUq5cuaO2vQb25OX9M+DRyP3t27fbsmXL3CCmDh06uD6lkyZN8umdAYUjZALAKeCyyy5zNZWqQdPAmvyoz6P69N11113uvoKQ+mtqUI1ceOGFLjB9+umnwRo2DS7R4Jy2bdsWOrBG6/abajU1iOm7775z/RxPlIKcQqYGNkVqZHajRo3szTffDAubH3/8savt1HsTDdwJHf2elZVlW7duLdLr67nqW6pJ+119agmZiBRCJgCcAtRMriCmAKUaS4VODW5ZuXKlq7XU4BOFSAUehZwaNWrY5MmTbffu3cGQqRpPNU0rqKi2TyFPg25U01YYjY5WKNq4caMbua4ApZHUftAI60ceecSqVavmau7UvL9+/XoXfocOHeqW0XtWYEtJSSn0tbQtVE69x/ykp6e7Zmxtk//85z/u/XhBUUH6eAwcONDVHD/88MP20EMP2TfffOMG8Kjs3na97rrr3Ij8Ll26uP2iAT1FqanVACkN5NKgK20XDejy9iUQCYRMADhFqJZOo5Y12lt9LhUU1R9QAVMUXhSybrzxRne6HY0uVz++zMzM4Gs8++yzLmipOVlhUa8V+nh+1C9w4cKF1r59e/vll19cOfwauX3vvfe6sqpcGoWuJmOF5tArEO3YseOYQVg0qlt9FgsKYlqXTjfkUVAXbTMF6eOh8Pv222+74N6sWTPXx1UhVyPsPcnJya629uabb3Z9TcePH1+kmkwFXz1Xp4fSKYxUk6kzCwCREqPRPxFbG+ATNRfpYKsfN9VgAAA4tqJ04TyZAAAA8B0hEwAAAL6jTyZOWfWSllk02Taxc0kXAQCAIGoy4bs1a9a4UZC1a9cOuzZxKJ2AWAMH1K9SgweuvPJK1zkfAABEB0ImfHfgwAE3SnLatGn5Pq6rhrRp08YaNmzornus6/VqVGvFihXZGwAARAmay+E7natOU0F0Xj2dMuWPf/xjcF79+vXZEwAARBFqMhFRuoKILnGmE0PrXHxnnXWWuxxcfk3qoXQiYZ22KHQCAAClFyETEaVL2ulEzhMnTrSbbrrJli9fbt27d7dbb7017CTHeelKHeq/6U116tSJaLkBAEDxEDIR8ZpM0fWRH330UWvevLklJSW5K1nMmDGjwOfpqhU68bo3ZWRkRLDUAACguOiTiYiqVauWlS9f3l3rN5Qu47Z27doCn6frHPt1rWMAAHDyUZOJiNK1dFu2bGnffPNN2Py0tDSrW7cuewMAgChBTSZ8pz6X6enpwftbt261jRs3Wnx8vCUkJNjw4cOtZ8+edu2111r79u3t3XfftbfeesudzggAAEQHQiZ8t379ehcePUOHDnW3/fv3t1mzZrmBPup/qcE8jzzyiDVo0MDefPNNd+5MAAAQHQiZ8F27du0sEAgUusyAAQPcBAAAohN9MgEAAOA7QiYAAAB8R8gEAACA7wiZAAAA8B0hEwAAAL4jZAIAAMB3hEwAAAD4jpAJAAAA3xEyAQAA4DtCJny3Zs0a69Kli9WuXdtiYmJs8eLFwccOHz5sI0aMsCZNmljlypXdMv369bNdu3axJwAAiCKETPjuwIED1qxZM5s2bdpRjx08eNBSU1Nt1KhR7nbhwoWWlpZmXbt2ZU8AABBFuHY5fNexY0c35ad69er23nvvhc2bOnWqtWrVynbs2GEJCQnsEQAAogAhEyUuMzPTNaufccYZBS6TnZ3tJk9WVlaESgcAAI4HzeUoUYcOHbKkpCS78847rVq1agUul5KS4mpBvalOnToRLScAACgeQiZKjAYB9erVy3Jzc2369OmFLpucnOxqPL0pIyMjYuUEAADFR3M5Sixg9ujRw7Zu3WorV64stBZT4uLi3AQAAMoGQiZKLGBu2bLFVq1aZTVr1mQvAAAQZQiZ8N3+/fstPT09eF+1lRs3brT4+Hh3Xszbb7/dnb5o6dKllpOTY7t373bL6fEKFSqwRwAAiAKETPhu/fr11r59++D9oUOHutv+/fvb2LFjbcmSJe5+8+bNw56nWs127dqxRwAAiAKETPhOQTEQCBT4eGGPAQCA6MDocgAAAPiOkAkAAADfETIBAADgO0ImAAAAfEfIBAAAgO8ImQAAAPAdIRMAAAC+I2QCAADAd4RMAAAA+I6QiYg7cuSIjRw50i644AKrVKmS1a9f35588knLzc1lbwAAECW4rCQi7plnnrEZM2bY7NmzrXHjxu5a54mJiVa9enUbPHgwewQAgChAyETEffLJJ9atWzfr3Lmzu1+vXj2bN2+eC5sAACA60FyOiGvTpo2tWLHC0tLS3P1NmzbZ2rVrrVOnTgU+Jzs727KyssImAABQelGTiYgbMWKEZWZmWsOGDS02NtZycnJswoQJ1rt37wKfk5KSYuPGjYtoOQEAwPGjJhMRt2DBApszZ47NnTvXUlNTXd/MSZMmuduCJCcnu2DqTRkZGREtMwAAKB5qMhFxw4cPt6SkJOvVq5e736RJE9u+fburrezfv3++z4mLi3MTAAAoG6jJRMQdPHjQypUL/+ip2ZxTGAEAED2oyUTEdenSxfXBTEhIcKcw+vzzz23y5Mk2YMAA9gYAAFGCkImImzp1qo0aNcoGDhxoe/bssdq1a9sDDzxgo0ePZm8AABAlCJmIuKpVq9qUKVPcBAAAohN9MgEAAOA7QiYAAAB8R8gEAACA7wiZAAAA8B0hEwAAAL4jZAIAAMB3hEwAAAD4jpAJAAAA3xEyAQAA4DtCJkpcSkqKxcTE2JAhQ0q6KAAAwCeETJSodevW2csvv2xNmzZlTwAAEEUImSgx+/fvtz59+tjMmTOtRo0a7AkAAKIIIRMlZtCgQda5c2e7/vrrj7lsdna2ZWVlhU0AAKD0Kl/SBcCpaf78+Zaamuqay4vab3PcuHEnvVwAAMAf1GQi4jIyMmzw4ME2Z84cq1ixYpGek5ycbJmZmcFJrwEAAEovajIRcRs2bLA9e/ZYixYtgvNycnJszZo1Nm3aNNc0HhsbG/acuLg4NwEAgLKBkImI69Chg23evDlsXmJiojVs2NBGjBhxVMAEAABlDyETEVe1alW79NJLw+ZVrlzZatasedR8AABQNhEyAeAkq5e0LKq28baJnUu6CADKAEImSoXVq1eXdBEAAICPGF0OAAAA3xEyAQAA4DtCJgAAAHxHyAQAAIDvCJkAAADwHSETAAAAviNkAgAAwHeETAAAAPiOk7EDUSKarirDFWUAoOyjJhMAAAC+I2QCAADAd4RMAAAA+I4+mSiTcnJy3O3OnTutWrVqx/UaR7J+8rlU8Iv2azSJts9atO0f/P9lZWWFHWOBExETCAQCJ/QKQAlYt26dtWrVim0PACfBP//5T2vZsiXbFieEkIkyad++fRYfH28ZGRnHXZMJADi6JrNOnTq2d+9eq1GjBpsHJ4TmcpRJsbGx7lYBk5AJACfnGAucCAb+AAAAwHeETAAAAPiOkAkAAADfETIBAADgO0ImAAAAfEfIBAAAgO8ImQAAAPAdIRMAAAC+I2QCAADAd4RMAIhS7dq1syFDhpTa9cTExNjixYstmp0K7xEoCCETAHBSjR071po3b37U/B9++ME6duxY4lt/9erVLgzmN61bt84t8/PPP9tNN91ktWvXtri4OHd974ceeshd6xtA/rh2OQCgRJxzzjmlYstfddVVLvCGGjVqlL3//vt2+eWXu/vlypWzbt262VNPPWVnnnmmpaen26BBg2zv3r02d+5cK20OHz5sp512WkkXA6c4ajIB4BTx22+/2WOPPWbnnXeeVa5c2a644gpXi+dRbV3v3r3t/PPPt9NPP92aNGli8+bNC3uNAwcOWL9+/axKlSp27rnn2nPPPVfoOmfNmmXjxo2zTZs2BWsHNS9vU/K2bdvc/TfeeMOuueYaq1SpkrVs2dLS0tJcbaLCntap2sQff/wxbB2vvfaaXXLJJVaxYkVr2LChTZ8+vVjbpUKFCi7welPNmjVtyZIlNmDAAFcmqVGjhj344IOuHHXr1rUOHTrYwIED7cMPPzzm6//000/WvXt3t00vuugi99qhPvjgA2vVqpWrIdU2TUpKsiNHjgQfr1evnk2ZMiXsOaoZVg2xR+WcMWOGC8LatwrD+/btsz59+rhQrO2pdWtbAZFCyASAU0RiYqJ99NFHNn/+fPviiy/sjjvucKFty5Yt7vFDhw5ZixYtbOnSpfbll1/a/fffb3379rXPPvss+BrDhw+3VatW2aJFi2z58uUupG7YsKHAdfbs2dOGDRtmjRs3drWFmjSvIGPGjLGRI0daamqqlS9f3oVeBeMXXnjBBbpvv/3WRo8eHVx+5syZ9sQTT9iECRPs66+/tqefftrVQs6ePTusz+jdd99d5O2kEKhgWNhzdu3aZQsXLrS2bdse8/UUsnv06OG2eadOnVzwUw2ofP/9926eArWC+EsvvWSvvvqqC4nFpW2nkLl582YXkLUdvvrqK3vnnXfcttFr16pVq9ivCxy3AFAGZWZmBvTx1S2A/LVt2zYwePBg93d6enogJiYm8P3334ct06FDh0BycnKBm7BTp06BYcOGub9//fXXQIUKFQLz588PPv7zzz8HKlWqFFxPfsaMGRNo1qzZUfP1HV60aJH7e+vWre7+K6+8Enx83rx5bt6KFSuC81JSUgINGjQI3q9Tp05g7ty5Ya87fvz4QOvWrYP3+/btG0hKSgoUVceOHd2Un169ern3q3J16dIl8J///KfQ19JyI0eODN7fv3+/2w/vvPOOu//444+795Obmxtc5sUXXwxUqVIlkJOT4+7XrVs38Pzzz4e9rrantmvoeoYMGRK2jMqXmJgYKA6OrfATfTIB4BSgmkFlkYsvvjhsfnZ2tmselpycHJs4caItWLDA1bDpMU1qfhXVIqrJvXXr1sHnx8fHW4MGDXwrZ9OmTYN/n3322e5Wzfah8/bs2eP+VrN5RkaG3XPPPXbfffcFl1FTc/Xq1YP3X3/99SKvf+fOnfaPf/zDNdvn5/nnn3c1ht988409/vjjNnTo0GM2z4e+J23LqlWrBt+Dahi1Pb1mebn66qtt//79riwJCQlFLrvXf9Sj5v3bbrvN7fsbbrjBbrnlFtf/FIgUQiYAnAJyc3MtNjbWNW3rNpT6Oor6VypEqf+fgp0CkU5NpGAp/1dhdnKFDlbxglfeeXov3nvymszVvzRU3vdYVOqzqNDdtWvXfB/3+m2q76eWU/9RNUurL2VR3lPe96BtGhowvXnect6go7zbXgN78vL+GfBo5P727dtt2bJlbhCT+pFqsNKkSZOOsRUAfxAyAeAUcNlll7maStWgKRjlR30e1afvrrvucvcVhNRfU4Nq5MILL3SB6dNPPw3WsGlwiQbnFNY3UQNrtG6/qVZTg5i+++4718/xRCnIKWRqYFNRRmZ7wU+1vcerUaNG9uabb4aFzY8//tjVduq9iQbuhI5+12mTtm7dWqTX13PVt1ST9rv61BIyESmETAA4BaiZXEFMAUo1lgqdGtyycuVKV2upwScKkQo8CjkaTT158mTbvXt3MGSqxlNN0woqqsVTyNOgG9W0FUajoxWKNm7c6EauK0BpJLUfNML6kUcesWrVqrmaOwW+9evXu/CrpmzRe1ZgS0lJKfS1tC1UTr3HvN5++23797//7QboaDtoQI0GJKlpW+/veGmEumqOH374YXfeTTXDqzleZfe263XXXedG5Hfp0sXtF9WcFqWmVgOkNJBLg660XTSgy9uXQCQQMgHgFKFaOo1a1mhv9blUUFR/QAVMUXhRyLrxxhvd6XY0ulz9+DIzM4Ov8eyzz7r+gmpOVljUa4U+nh/1C9RI7Pbt29svv/ziylGc0d6Fuffee11ZVS6FPjUZKzSHXoFox44dxwzColHd6rOYXxDTKYDULP/oo4+6wKaTsd96663udEMnQuFXAVbBvVmzZq6Pq0KuRth7kpOTXW3tzTff7Pqajh8/vkg1mapB1nN1eiiVXzWZOrMAECkxGv0TsbUBPlFzkQ62+nFTDQYAgGMrShfOkwkAAADfETIBAADgO0ImAAAAfEfIhO/WrFnjRkHWrl077NrEoXQCYg0cUL9KDR648sorXed8AAAQHQiZ8N2BAwfcKMlp06bl+7iuGtKmTRt3MmNd91jX69Wo1ooVK7I3AACIEowux8n9gMXE2KJFi9xpUDy9evVyJzr+61//etyvy+hyAPAfx1b4iZpMRJSuIKJLnOnE0DoX31lnneUuB5dfk3oonZdOB7/QCQAAlF6ETESULmmnEzlPnDjRbrrpJlu+fLl1797dndT4gw8+KPB5ulKH+m96k06EDAAASi+ayxHR5vJdu3a5K1z07t3b5s6dG1xOg4B0pY558+YVWJMZen1g1WQqaHIydgDwD83l8BOXlURE1apVy8qXL2+NGjUKm6/LuK1du7bA5+k6x35d6xgAAJx8NJcjonQt3ZYtW9o333wTNj8tLc3q1q3L3gAAIEpQkwnfqc9lenp68P7WrVtt48aNFh8fbwkJCTZ8+HDr2bOnXXvttda+fXt799137a233nKnMwIAANGBPpnwncKiwmNe/fv3t1mzZrm///KXv7jBPDt37rQGDRrYuHHjrFu3bhHtN1QvaZlFk20TO5d0EQCUcfTJhJ+oyYTv2rVrZ4FAoNBlBgwY4CYAABCd6JMJAAAA3xEyAQAA4DtCJgAAAHxHyAQAAIDvCJkAAADwHSETAAAAviNkAgAAwHeETAAAAPiOkAkAAADfETLhuzVr1liXLl2sdu3aFhMTY4sXLw4+dvjwYRsxYoQ1adLEKleu7Jbp16+f7dq1iz0BAEAUIWTCdwcOHLBmzZrZtGnTjnrs4MGDlpqaaqNGjXK3CxcutLS0NOvatSt7AgCAKMK1y+G7jh07uik/1atXt/feey9s3tSpU61Vq1a2Y8cOS0hIYI8AABAFCJkocZmZma5Z/YwzzihwmezsbDd5srKyIlQ6AABwPGguR4k6dOiQJSUl2Z133mnVqlUrcLmUlBRXC+pNderUiWg5AQBA8RAyUWI0CKhXr16Wm5tr06dPL3TZ5ORkV+PpTRkZGRErJwAAKD6ay1FiAbNHjx62detWW7lyZaG1mBIXF+cmAABQNhAyUWIBc8uWLbZq1SqrWbMmewEAgChDyITv9u/fb+np6cH7qq3cuHGjxcfHu/Ni3n777e70RUuXLrWcnBzbvXu3W06PV6hQgT0CAEAUIGTCd+vXr7f27dsH7w8dOtTd9u/f38aOHWtLlixx95s3bx72PNVqtmvXjj0CAEAUIGTCdwqKgUCgwMcLewwAAEQHRpcDAADAd4RMAAAA+I6QCQAAAN8RMgEAAOA7QiYAAAB8R8gEAACA7wiZAAAA8B0hEwAAAL4jZAIAAMB3hExE3JEjR2zkyJF2wQUXWKVKlax+/fr25JNPWm5uLnsDAIAowWUlEXHPPPOMzZgxw2bPnm2NGzd21zpPTEy06tWr2+DBg9kjAABEAUImIu6TTz6xbt26WefOnd39evXq2bx581zYBAAA0YHmckRcmzZtbMWKFZaWlubub9q0ydauXWudOnUq8DnZ2dmWlZUVNgEAgNKLmkxE3IgRIywzM9MaNmxosbGxlpOTYxMmTLDevXsX+JyUlBQbN25cRMsJAACOHzWZiLgFCxbYnDlzbO7cuZaamur6Zk6aNMndFiQ5OdkFU2/KyMiIaJkBAEDxUJOJiBs+fLglJSVZr1693P0mTZrY9u3bXW1l//79831OXFycmwAAQNlATSYi7uDBg1auXPhHT83mnMIIAIDoQU0mIq5Lly6uD2ZCQoI7hdHnn39ukydPtgEDBrA3AACIEoRMRNzUqVNt1KhRNnDgQNuzZ4/Vrl3bHnjgARs9ejR7AwCAKEHIRMRVrVrVpkyZ4iYAABCd6JMJAAAA3xEyAQAA4DtCJgAAAHxHyAQAAIDvCJkAAADwHSETAAAAviNkAgAAwHeETAAAAPiOkAkAAADfETJR4lJSUiwmJsaGDBlS0kUBAAA+IWSiRK1bt85efvlla9q0KXsCAIAoQshEidm/f7/16dPHZs6caTVq1GBPAAAQRQiZKDGDBg2yzp072/XXX3/MZbOzsy0rKytsAgAApVf5ki4ATk3z58+31NRU11xe1H6b48aNO+nlAgAA/qAmExGXkZFhgwcPtjlz5ljFihWL9Jzk5GTLzMwMTnoNAABQelGTiYjbsGGD7dmzx1q0aBGcl5OTY2vWrLFp06a5pvHY2Niw58TFxbkJAACUDYRMRFyHDh1s8+bNYfMSExOtYcOGNmLEiKMCJgAAKHsImYi4qlWr2qWXXho2r3LlylazZs2j5gMAgLKJkAlEiXpJyyxabJvYuaSLAAA4QYRMlAqrV68u6SIAAAAfMbocAAAAviNkAgAAwHeETAAAAPiOkAkAAADfETIBAADgO0ImAAAAfEfIBAAAgO8ImQAAAPAdJ2MHUOpE09WLUPpxhSng5KAmEwAAAL4jZAIAAMB3hEwAAAD4jj6ZKJNycnLc7c6dO61atWrH9RpHsn7yuVQAyiIdR/B/srKywo6xwIkgZKJMSk9Pd7eNGzcu6aIAKOPqvFTSJSidx9iWLVuWdDFQxsUEAoFASRcCKK59+/ZZfHy8ZWRkHHdNJgDg6JrMOnXq2N69e61GjRpsHpwQajJRJsXGxrpbBUxCJgCcnGMscCIY+AMAAADfETIBAADgO0ImAAAAfEfIBAAAgO8ImQAAAPAdIRMAAAC+I2QCAADAd4RMAAAA+I6QCQAAAN8RMgEgSrVr186GDBlSatcTExNjixcvtmh2KrxHoCCETADASTV27Fhr3rz5UfN/+OEH69ixY4lv/dWrV7swmN+0bt264HL5PT5jxowSLTtQmnHtcgBAiTjnnHNKxZa/6qqrXOANNWrUKHv//fft8ssvD5v/2muv2U033RS8X716dSuNDh8+bKeddlpJFwOnOGoyAeAU8dtvv9ljjz1m5513nlWuXNmuuOIKV4vn+fnnn6137952/vnn2+mnn25NmjSxefPmhb3GgQMHrF+/flalShU799xz7bnnnit0nbNmzbJx48bZpk2bgrV/mpe3KXnbtm3u/htvvGHXXHONVapUyVq2bGlpaWmuNlFhT+tUwPvxxx+PCn6XXHKJVaxY0Ro2bGjTp08v1napUKGCC7zeVLNmTVuyZIkNGDDAlSnUGWecEbasynksP/30k3Xv3t1t04suusi9dqgPPvjAWrVqZXFxcW6bJiUl2ZEjR4KP16tXz6ZMmRL2HNUMq4bY49WqduvWze3bp556yvbt22d9+vSxM88805VT69a2AiKFkAkAp4jExET76KOPbP78+fbFF1/YHXfc4ULbli1b3OOHDh2yFi1a2NKlS+3LL7+0+++/3/r27WufffZZ8DWGDx9uq1atskWLFtny5ctdSN2wYUOB6+zZs6cNGzbMGjdu7GoLNWleQcaMGWMjR4601NRUK1++vAu9CsYvvPCCffjhh/btt9/a6NGjg8vPnDnTnnjiCZswYYJ9/fXX9vTTT7tayNmzZ4f1Gb377ruLvJ0UAhUM83vOQw89ZLVq1XIBWKEuNzf3mK+nkN2jRw+3zTt16uSC3969e91j33//vZun11MQf+mll+zVV191IbG4tO0UMjdv3uwCsrbDV199Ze+8847bNnptlR2ImABQBmVmZgb08dUtgPy1bds2MHjwYPd3enp6ICYmJvD999+HLdOhQ4dAcnJygZuwU6dOgWHDhrm/f/3110CFChUC8+fPDz7+888/BypVqhRcT37GjBkTaNas2VHz9R1etGiR+3vr1q3u/iuvvBJ8fN68eW7eihUrgvNSUlICDRo0CN6vU6dOYO7cuWGvO378+EDr1q2D9/v27RtISkoKFFXHjh3dlJde9+OPPw58/vnngUmTJgVOP/10N68wKv/IkSOD9/fv3+/2wzvvvOPuP/744+795ObmBpd58cUXA1WqVAnk5OS4+3Xr1g08//zzYa+r7antGrqeIUOGhC3TpUuXQGJiYqA4OLbCT/TJBIBTgGoGlUUuvvjisPnZ2dmueVhycnJs4sSJtmDBAlfDpsc0qflVVIuoJvfWrVsHnx8fH28NGjTwrZxNmzYN/n322We7WzXbh87bs2eP+1vN5hkZGXbPPffYfffdF1xGTc2hfSVff/31Iq9/586d9o9//MM12+elGlaPN5DpySefDJt/rPekbVm1atXge1ANo7ZnaLP81Vdfbfv373dlSUhIKHLZ8/YfffDBB+22225z+/6GG26wW265xfU/BSKFkAkApwA168bGxrqmbd2GUl9HUf/K559/3vX/U7BTINKpiRQs5f8qzE6u0MEqXvDKO89rovZu1WSu/qWh8r7HolKfRYXurl27HnPZK6+80rKysuzf//53MBDnJ+8AnND3oG2at9+nt529+eXKlTtq22tgT17ePwMejdzfvn27LVu2zA1i6tChgw0aNMgmTZp0zPcG+IGQCQCngMsuu8zVVKoGTQNr8qM+j+rTd9ddd7n7CkLqr6lBNXLhhRe6wPTpp58Ga9g0uESDc9q2bVvowBqt228KdhrE9N1337l+jidKQU4hUwObijIy+/PPP3eDjTQY6Hg1atTI3nzzzbCw+fHHH7vaTr030cCd0NHvCrZbt24t0uvruepbqkn7XX1qCZmIFEImAJwC1EyuIKYApRpLhU4Nblm5cqWrtdTgE4VIBR6FnBo1atjkyZNt9+7dwZCpGk81TSuoqLZPIU+DblTTVhiNjlYo2rhxoxu5rgClkdR+0AjrRx55xKpVq+Zq7tS8v379ehd+hw4d6pbRe1ZgS0lJKfS1tC1UTr3HvN566y23LdS0rZHaGvyk967BUSfyXgYOHOhqjh9++GE3qOibb75xA3hUdm+7XnfddW5EfpcuXdx+0YCeotTUaoCUBnJp0JW2iwZ0efsSiARCJgCcIlRLp1HLGu2tPpcKigpNCpii8KKQdeONN7rT7ShAqR9fZmZm8DWeffZZ119QzckKi3qt0Mfzo36BCxcutPbt29svv/ziylGc0d6Fuffee11ZVS6NQleTsUJz6BWIduzYccwgLBrVrT6L+QUx1Wzq1EgKf6rhrV+/vuuPqebnE6Hw+/bbb7vg3qxZM9fHVSE3tJ9ncnKyq629+eabXV/T8ePHF6kmUzXIeq5OD6VgrJpMnVkAiJQYjf6J2NoAn6i5SAdb/bipBgMAwLEVpQvnyQQAAIDvCJkAAADwHSETvluzZo3roF67du2wy8aF0rnh1KdLTd7q16VTgajfFAAAiA6ETPhO1zZWB/Zp06bl+7hO6NymTRt3jWFdkk6XUtOAA50KBAAARAcG/uDkfsBiYtw1jjVC1dOrVy83UvOvf/3rcb8uA38AwH8cW+EnajIRUTr1h64+oXP26TQpZ511lrtSR35N6qF0jjcd/EInAABQenGeTESUrjaic+zp+sg6X98zzzxj7777rt16663u5MYFXTVEJ1EeN26cr2Wpl7TMosm2iZ1LuggAAARRk4mI8q7Xq0vXPfroo9a8eXNLSkpyJxmeMWNGgc/TCYV1TkxvysjIiGCpAQBAcVGTiYiqVauWlS9f3l2vN5SusLF27doCn6fLtvl1GToAAHDyUZOJiNJlzlq2bOmuzxsqLS3N6taty94AACBKUJMJ36nPZXp6evC+rrG7ceNGd03ehIQEd43enj172rXXXuuuZaw+mW+99ZY7nREAAIgOhEz4bv369S48eoYOHepu+/fvb7NmzbLu3bu7/pcazPPII49YgwYN7M0333TnzgQAANGBkAnftWvXzgKBQKHLDBgwwE0AACA60ScTAAAAviNkAgAAwHeETAAAAPiOkAkAAADfETIBAADgO0ImAAAAfEfIBAAAgO8ImQAAAPAdIRMAAAC+I2TCd2vWrLEuXbpY7dq1LSYmxhYvXhx87PDhwzZixAhr0qSJVa5c2S3Tr18/27VrF3sCAIAoQsiE7w4cOGDNmjWzadOmHfXYwYMHLTU11UaNGuVuFy5caGlpada1a1f2BAAAUYRrl8N3HTt2dFN+qlevbu+9917YvKlTp1qrVq1sx44dlpCQwB4BACAKUJOJEpeZmema1c8444ySLgoAAPAJNZkoUYcOHbKkpCS78847rVq1agUul52d7SZPVlZWhEoIAACOBzWZKDEaBNSrVy/Lzc216dOnF7psSkqKa2r3pjp16kSsnAAAoPgImSixgNmjRw/bunWr66NZWC2mJCcnu2Z1b8rIyIhYWQEAQPHRXI4SC5hbtmyxVatWWc2aNY/5nLi4ODcBAICygZAJ3+3fv9/S09OD91VbuXHjRouPj3fnxbz99tvd6YuWLl1qOTk5tnv3brecHq9QoQJ7BACAKEDIhO/Wr19v7du3D94fOnSou+3fv7+NHTvWlixZ4u43b9487Hmq1WzXrh17BACAKEDIhO8UFAOBQIGPF/YYAACIDgz8AQAAgO8ImQAAAPAdIRMAAAC+I2QCAADAd4RMAAAA+I6QCQAAAN8RMgEAAOA7QiYAAAB8R8gEAAAAIRMAAAClHzWZiLgjR47YyJEj7YILLrBKlSpZ/fr17cknn7Tc3Fz2BgAAUYJrlyPinnnmGZsxY4bNnj3bGjdubOvXr7fExESrXr26DR48mD0CAEAUIGQi4j755BPr1q2bde7c2d2vV6+ezZs3z4VNAAAQHWguR8S1adPGVqxYYWlpae7+pk2bbO3atdapU6cCn5OdnW1ZWVlhEwAAKL2oyUTEjRgxwjIzM61hw4YWGxtrOTk5NmHCBOvdu3eBz0lJSbFx48ZFtJwAAOD4UZOJiFuwYIHNmTPH5s6da6mpqa5v5qRJk9xtQZKTk10w9aaMjIyIlhkAABQPNZmIuOHDh1tSUpL16tXL3W/SpIlt377d1Vb2798/3+fExcW5CQAAlA3UZCLiDh48aOXKhX/01GzOKYwAAIge1GQi4rp06eL6YCYkJLhTGH3++ec2efJkGzBgAHsDAIAoQchExE2dOtVGjRplAwcOtD179ljt2rXtgQcesNGjR7M3AACIEoRMRFzVqlVtypQpbgIAANGJPpkAAADwHSETAAAAviNkAgAAwHeETAAAAPiOkAkAAADfETIBAADgO0ImAAAAfEfIBAAAgO8ImQAAAPAdIRMlLiUlxWJiYmzIkCElXRQAAOATQiZK1Lp16+zll1+2pk2bsicAAIgihEyUmP3791ufPn1s5syZVqNGDfYEAABRhJCJEjNo0CDr3LmzXX/99cdcNjs727KyssImAABQepUv6QLg1DR//nxLTU11zeVF7bc5bty4k14uAADgD2oyEXEZGRk2ePBgmzNnjlWsWLFIz0lOTrbMzMzgpNcAAAClFzWZiLgNGzbYnj17rEWLFsF5OTk5tmbNGps2bZprGo+NjQ17TlxcnJsAAEDZQMhExHXo0ME2b94cNi8xMdEaNmxoI0aMOCpgAgCAsoeQiYirWrWqXXrppWHzKleubDVr1jxqPgAAKJvokwkAAADfUZOJUmH16tUlXQQAAOAjajIBAADgO0ImAAAAfEfIBAAAgO/okwmg1KmXtMyiybaJnUu6CAAQcdRkAgAAwHeETAAAAPiOkAkAAADfETIBAADgOwb+AFEi2gbLRBP2TenGwCzg5KAmEwAAAL4jZAIAAMB3hEwAAAD4jj6ZKJNycnLc7c6dO61atWrH9RpHsn7yuVQAyiIdR/B/srKywo6xwIkgZKJMSk9Pd7eNGzcu6aIAKOPqvFTSJSidx9iWLVuWdDFQxsUEAoFASRcCKK59+/ZZfHy8ZWRkHHdNJgDg6JrMOnXq2N69e61GjRpsHpwQajJRJsXGxrpbBUxCJgCcnGMscCIY+AMAAADfETIBAADgO0ImAAAAfEfIBAAAgO8ImQAAAPAdIRMAAAC+I2QCAADAd4RMAAAA+I6QCQBRql27djZkyJBSu56YmBhbvHixRbNT4T0CBSFkAgBOqrFjx1rz5s2Pmv/DDz9Yx44dS3zrr1692oXB/KZ169a5ZWbNmlXgMnv27CnptwCUSlxWEgBQIs4555xSseWvuuoqF3hDjRo1yt5//327/PLL3f2ePXvaTTfdFLbM3XffbYcOHbKzzjrLSpvDhw/baaedVtLFwCmOmkwAOEX89ttv9thjj9l5551nlStXtiuuuMLV4nl+/vln6927t51//vl2+umnW5MmTWzevHlhr3HgwAHr16+fValSxc4991x77rnnCl2nagDHjRtnmzZtCtb8aV7epuRt27a5+2+88YZdc801VqlSJWvZsqWlpaW52kSFPa1TQe/HH38MW8drr71ml1xyiVWsWNEaNmxo06dPL9Z2qVChggu83lSzZk1bsmSJDRgwwJVJVJ7QZXRt75UrV9o999xzzNf/6aefrHv37m6bXnTRRe61Q33wwQfWqlUri4uLc9s0KSnJjhw5Eny8Xr16NmXKlLDnqGZYNcQelXPGjBnWrVs3t2+feuop27dvn/Xp08fOPPNMV36tW9sKiBRCJgCcIhITE+2jjz6y+fPn2xdffGF33HGHC21btmxxj6tWrkWLFrZ06VL78ssv7f7777e+ffvaZ599FnyN4cOH26pVq2zRokW2fPlyF1I3bNhQ4DpVAzhs2DBr3Lixqy3UpHkFGTNmjI0cOdJSU1OtfPnyLvQqGL/wwgv24Ycf2rfffmujR48OLj9z5kx74oknbMKECfb111/b008/7WohZ8+eHdZnVLWORaUQqGBY2HNef/11Fxpvv/32Y76eQnaPHj3cNu/UqZMLfnv37nWPff/9926eArWC+EsvvWSvvvqqC4nFpW2nkLl582YXkLUdvvrqK3vnnXfcttFr16pVq9ivCxy3AFAGZWZmBvTx1S2A/LVt2zYwePBg93d6enogJiYm8P3334ct06FDh0BycnKBm7BTp06BYcOGub9//fXXQIUKFQLz588PPv7zzz8HKlWqFFxPfsaMGRNo1qzZUfP1HV60aJH7e+vWre7+K6+8Enx83rx5bt6KFSuC81JSUgINGjQI3q9Tp05g7ty5Ya87fvz4QOvWrYP3+/btG0hKSgoUVceOHd1UmEaNGgUefPDBY76Wyj9y5Mjg/f3797v98M4777j7jz/+uHs/ubm5wWVefPHFQJUqVQI5OTnuft26dQPPP/982Otqe2q7hq5nyJAhYct06dIlkJiYGCgOjq3wE30yAeAUoJpBZZGLL744bH52drZrHpacnBybOHGiLViwwNWw6TFNan4V1SKqyb1169bB58fHx1uDBg18K2fTpk2Df5999tnuVs32ofO8gTZqNs/IyHBN1vfdd19wGTU1V69ePazWsah27txp//jHP1yzfUE++eQTV0NY1NcNfU/allWrVg2+B9Uwant6zfJy9dVX2/79+11ZEhISilx2r/+o58EHH7TbbrvN7fsbbrjBbrnlFtf/FIgUQiYAnAJyc3NdP0I1bes2lPo6ivpXPv/8867/n4KdApFOTaRgKf9XYXZyhQ5W8YJX3nl6L9578prM1b80VN73WFTqs6jQ3bVr1wKXeeWVV1yfSHUtKIq8A3BC34O2aWjA9OZ5y0m5cuWO2vYa2JOX98+ARyP3t2/fbsuWLXODmDp06GCDBg2ySZMmFancwIkiZALAKeCyyy5zNZWqQdPAmvyoz6P69N11113uvoKQ+mtqUI1ceOGFLjB9+umnwRo2DS7R4Jy2bdsWOrBG6/abajU1iOm7775z/RxPlIKcQqYGNhU0Mls1jKrlTElJMT80atTI3nzzzbCw+fHHH7vaTr030cCd0NHvWVlZtnXr1iK9vp6rvqWatN/Vp5aQiUghZALAKUDN5ApiClCqsVTo1OAWjZBWraUGnyhEKvAo5NSoUcMmT55su3fvDoZM1XiqaVpBRbV9CnkadKOatsJodLRC0caNG93IdQUojaT2g0ZYP/LII1atWjVXc6fm/fXr17vwO3ToULeM3rMC27GCobaFylnYiHF1JVBzvB+hVgYOHOhqjh9++GF76KGH7JtvvnEDeFR2b7ted911bkR+ly5d3H7RgJ6i1NRqgJRqWzXoSttFA7q8fQlEAiETAE4RqqXTqGWN9lafSwVF9QdUwBSFF4WsG2+80Y2c1uhy9ePLzMwMvsazzz7ravPUnKywqNcKfTw/6he4cOFCa9++vf3yyy+uHMUZ7V2Ye++915VV5dIodDUZKzSHXoFox44dxwzColHd6rNYWBDTMrfeeqsLe35Q+H377bddcG/WrJnr46qQqxH2nuTkZFdbe/PNN7u+puPHjy9STaZqkPVcnR5KpzBSTabOLABESoxG/0RsbYBP1Fykg61+3FSDAQDg2IrShfNkAgAAwHeETAAAAPiOkAkAAADfETLhuzVr1rhRkLVr1w67NnEonYBYAwfUr1KDB6688krXOR8AAEQHQiZ8d+DAATdKctq0afk+rquGtGnTxho2bOiue6zr9WpUa8WKFdkbAABECUaX4+R+wGJibNGiRe40KJ5evXq5Ex3/9a9/Pe7XZXQ5APiPYyv8RE0mIkpXENElznRiaJ2L76yzznKXg8uvST2UTiSsg1/oBAAASi9CJiJKl7TTiZwnTpxoN910ky1fvty6d+/uTm78wQcfFPg8XalD/Te9qU6dOhEtNwAAKB6ayxHR5vJdu3a5K1z07t3b5s6dG1xOg4B0pY558+YVWJOpyaOaTAVNTsYOAP6huRx+4rKSiKhatWpZ+fLlrVGjRmHzdRm3tWvXFvg8XefYr2sdAwCAk4/mckSUrqXbsmVL++abb8Lmp6WlWd26ddkbAABECWoy4Tv1uUxPTw/e37p1q23cuNHi4+MtISHBhg8fbj179rRrr73W2rdvb++++6699dZb7nRGAAAgOtAnE75TWFR4zKt///42a9Ys9/df/vIXN5hn586d1qBBAxs3bpx169atyOug3xAA+I9jK/xEyESZxIEQADi2onSjTyYAAAB8R8gEAACA7wiZAAAA8B0hEwAAAL4jZAIAAMB3hEwAAAD4jpAJAAAA3xEyAQAA4DtCJgAAAHxHyITv1qxZY126dLHatWtbTEyMLV68OPjY4cOHbcSIEdakSROrXLmyW6Zfv362a9cu9gQAAFGEkAnfHThwwJo1a2bTpk076rGDBw9aamqqjRo1yt0uXLjQ0tLSrGvXruwJAACiCNcux8n9gMXE2KJFi+yWW24pcJl169ZZq1atbPv27ZaQkFCk1+Xa5QDgP46t8FN5X18NOA6ZmZkujJ5xxhkFLpOdne2m0AMhAAAovQiZKFGHDh2ypKQku/POO61atWoFLpeSkmLjxo3zdd31kpZZNNk2sXNJFwEAgCD6ZKLEaBBQr169LDc316ZPn17ossnJya7G05syMjIiVk4AAFB81GSixAJmjx49bOvWrbZy5cpCazElLi7OTQAAoGwgZKLEAuaWLVts1apVVrNmTfYCAABRhpAJ3+3fv9/S09OD91VbuXHjRouPj3fnxbz99tvd6YuWLl1qOTk5tnv3brecHq9QoQJ7BACAKEDIhO/Wr19v7du3D94fOnSou+3fv7+NHTvWlixZ4u43b9487Hmq1WzXrh17BACAKEDIhO8UFAOBQIGPF/YYAACIDowuBwAAgO8ImQAAAPAdIRMAAAC+I2QCAADAd4RMAAAA+I6QCQAAAN8RMgEAAOA7QiYAAAB8R8gEAACA7wiZiLgjR47YyJEj7YILLrBKlSpZ/fr17cknn7Tc3Fz2BgAAUYLLSiLinnnmGZsxY4bNnj3bGjdu7K51npiYaNWrV7fBgwezRwAAiAKETETcJ598Yt26dbPOnTu7+/Xq1bN58+a5sAkAAKIDzeWIuDZt2tiKFSssLS3N3d+0aZOtXbvWOnXqVOBzsrOzLSsrK2wCAAClFzWZiLgRI0ZYZmamNWzY0GJjYy0nJ8cmTJhgvXv3LvA5KSkpNm7cuIiWEwAAHD9qMhFxCxYssDlz5tjcuXMtNTXV9c2cNGmSuy1IcnKyC6belJGREdEyAwCA4qEmExE3fPhwS0pKsl69ern7TZo0se3bt7vayv79++f7nLi4ODcBAICygZpMRNzBgwetXLnwj56azTmFEQAA0YOaTERcly5dXB/MhIQEdwqjzz//3CZPnmwDBgxgbwAAECUImYi4qVOn2qhRo2zgwIG2Z88eq127tj3wwAM2evRo9gYAAFGCkImIq1q1qk2ZMsVNAAAgOtEnEwAAAL4jZAIAAMB3hEwAAAD4jpAJAAAA3xEyAQAA4DtCJgAAAHxHyAQAAIDvCJkAAADwHSETAAAAviNkosSlpKRYTEyMDRkypKSLAgAAfELIRIlat26dvfzyy9a0aVP2BAAAUYSQiRKzf/9+69Onj82cOdNq1KjBngAAIIoQMlFiBg0aZJ07d7brr7/+mMtmZ2dbVlZW2AQAAEqv8iVdAJya5s+fb6mpqa65vKj9NseNG3fSywUAAPxBTSYiLiMjwwYPHmxz5syxihUrFuk5ycnJlpmZGZz0GgAAoPSiJhMRt2HDBtuzZ4+1aNEiOC8nJ8fWrFlj06ZNc03jsbGxYc+Ji4tzEwAAKBsImYi4Dh062ObNm8PmJSYmWsOGDW3EiBFHBUwAAFD2EDIRcVWrVrVLL700bF7lypWtZs2aR80HAABlEyETQKlTL2lZSRcBhdg2sTPbB8AxETJRKqxevbqkiwAAAHzE6HIAAAD4jpAJAAAA3xEyAQAA4Dv6ZAJRgsEyAIDShJpMAAAA+I6QCQAAAN8RMgEAAOA7QiYAAAB8x8AfAMApPciMKxgBJwc1mQAAAPAdIRMAAAC+I2QCAADAd/TJRJmUk5Pjbnfu3GnVqlU7rtc4kvWTz6UCUBbpOIL/k5WVFXaMBU4EIRNlUnp6urtt3LhxSRcFQBlX56WSLkHpPMa2bNmypIuBMi4mEAgESroQQHHt27fP4uPjLSMj47hrMgEAR9dk1qlTx/bu3Ws1atRg8+CEUJOJMik2NtbdKmASMgHg5BxjgRPBwB8AAAD4jpAJAAAA3xEyAQAA4DtCJgAAAHxHyAQAAIDvCJkAAADwHSETAAAAviNkAgAAwHeETAAAAPiOkAkAUapdu3Y2ZMiQUruemJgYW7x4sUWzU+E9AgUhZAIATqqxY8da8+bNj5r/ww8/WMeOHUt8669evdqFwfymdevWBZdbsWKFXXXVVVa1alU799xzbcSIEXbkyJESLTtQmhEyAQAl4pxzzrG4uLgS3/oKjgq8odO9995r9erVs8svv9wt88UXX1inTp3spptuss8//9zmz59vS5YssaSkJCuNDh8+XNJFAAiZAHCq+O233+yxxx6z8847zypXrmxXXHGFq8Xz/Pzzz9a7d287//zz7fTTT7cmTZrYvHnzwl7jwIED1q9fP6tSpYqrzXvuuecKXeesWbNs3LhxtmnTpmDtoOblbUretm2bu//GG2/YNddcY5UqVbKWLVtaWlqaq01U2NM6FfJ+/PHHsHW89tprdskll1jFihWtYcOGNn369GJtlwoVKrjA6001a9Z0AXLAgAGuTKJQ2bRpUxs9erRdeOGF1rZtW0tJSbEXX3zRfv3110Jf/6effrLu3bu7bXrRRRe51w71wQcfWKtWrVzg1jZVcA2tIVXYnTJlSthzVDOsGmKPyjljxgzr1q2b27dPPfWU7du3z/r06WNnnnmm255at7YVECnUZALAKSIxMdE++ugjF5hUM3fHHXe40LZlyxb3+KFDh6xFixa2dOlS+/LLL+3++++3vn372meffRZ8jeHDh9uqVats0aJFtnz5chdSN2zYUOA6e/bsacOGDbPGjRsHawk1ryBjxoyxkSNHWmpqqpUvX96FXgXjF154wT788EP79ttvXdDzzJw505544gmbMGGCff311/b000/bqFGjbPbs2WF9Ru++++4ibyeFQAXD0OdkZ2e7EBtKwU3brLD3LwrZPXr0CNaGKvjt3bvXPfb999+7eQrUCuIvvfSSvfrqqy4kFpe2nULm5s2bXUDWdvjqq6/snXfecdtGr12rVq1ivy5w3AJAGZSZmRnQx1e3APLXtm3bwODBg93f6enpgZiYmMD3338ftkyHDh0CycnJBW7CTp06BYYNG+b+/vXXXwMVKlQIzJ8/P/j4zz//HKhUqVJwPfkZM2ZMoFmzZkfN13d40aJF7u+tW7e6+6+88krw8Xnz5rl5K1asCM5LSUkJNGjQIHi/Tp06gblz54a97vjx4wOtW7cO3u/bt28gKSkpUFQdO3Z0U6h//OMfgXLlyrl1HTlyJLBz585AmzZtXPnyrj/vexw5cmTw/v79+91+eOedd9z9xx9/3L2f3Nzc4DIvvvhioEqVKoGcnBx3v27duoHnn38+7HW1PbVdQ9czZMiQsGW6dOkSSExMDBQHx1b4qfzxx1MAQFmhmkFlkYsvvjhsvmro1DwsOTk5NnHiRFuwYIGrYdNjmtT8KqpFVJN769atg8+Pj4+3Bg0a+FZONUl7zj77bHerZvvQeXv27HF/q9k8IyPD7rnnHrvvvvuCy6ipuXr16sH7r7/+epHXv3PnTvvHP/7hmu1D3XDDDfbss8/a73//e1e7q6Zt1RSuXbvWYmNji/yetC01cMh7D6ph1Pb0muXl6quvtv3797uyJCQkFLnsXv9Rz4MPPmi33Xab2/cq/y233OL6nwKRQsgEgFNAbm6uC0Nq2s0bitTXUdS/8vnnn3f9/xTsFIh0aiIFS/m/CrOT67TTTgv+7QWvvPP0Xrz35DWZq39pqGMFv4Koz6JCd9euXY96bOjQofboo4+6Jv8aNWq4fqTJycl2wQUXFPk95X0P2qahAdOb5y0n5cqVO2rb5zewx/tnwKOR+9u3b7dly5bZ+++/bx06dLBBgwbZpEmTjrEVAH8QMgHgFHDZZZe5mkrVoGlgTX7U51F9+u666y53X0FI/TU1qEY04EWB6dNPPw3WsGlwiQbnaCBMYQNrtG6/qVZTg5i+++4718/xRCnIKWRqYFPeYOhR8Ktdu7b7W4Oi6tSpY//93/993Ots1KiRvfnmm2Fh8+OPP3a1nXpvooE7CraerKws27p1a5FeX89V31JN2u/qU0vIRKQQMgHgFKBmcgUxBSjVWCp0anDLypUrXa2lBp8oRCrwKOSopm7y5Mm2e/fuYMhUjaeaphVUVNunkKdBN6ppK4xGRysUbdy40Y1cV4Dy69RFGmH9yCOPWLVq1VzNnZr3169f78Kvah5F71mBTaPBC6NtoXLqPeZHzeUaKKX3u3DhQte1QM3qx1trKgMHDnQ1xw8//LA99NBD9s0337gBPCq7t12vu+46NyK/S5cubr+omb4o69QAKQ3k0qArbRcN6PL2JRAJhEwAOEWolk6jljXaW30uFRTVH1ABUxReFLJuvPFGd7odjS5XP77MzMywoKX+gmpOVljUa4U+nh/1C1Qoa9++vf3yyy+uHMUZ7V0Ync9SZVW5NApdTcYKzaFXINqxY8cxg7BoVLf6LBYUxDRKW6PYFdiaNWtmf//730/4ZPIKv2+//bYL7npN9XFVyNUIe4+a5FVbe/PNN7u+puPHjy9STaZqkPVcNetrJLxqMnVmASBSYjT6J2JrA3yi5iIdbPXjphoMAADHVpQunCcTAAAAviNkAgAAwHeETAAAAPiOkAnfrVmzxo2C1Gk+Qq9NHEonINbAAfWr1OCBK6+80nXOBwAA0YGQCd8dOHDAjZKcNm1avo/rqiFt2rSxhg0buuse63q9GtWa97rAAACg7GJ0OU7uBywmxhYtWuROg+Lp1auXO9HxX//61+N+XUaXA4D/OLbCT9RkIqJ0BRFd4kwnhta5+M466yx3Obj8mtRD6bx0OviFTgAAoPQiZCKidEk7nchZV8rQlTOWL19u3bt3t1tvvdU++OCDAp+nK3Wo/6Y36VJuAACg9KK5HBFtLt+1a5e7wkXv3r1t7ty5weU0CEhX6tC1gAuqydTkUU2mgiYnYwcA/9BcDj9xWUlEVK1atax8+fLWqFGjsPm6jNvatWsLfJ6uc+zXtY4BAMDJR3M5IkrX0m3ZsqV98803YfPT0tKsbt267A0AAKIENZnwnfpcpqenB+9v3brVNm7caPHx8ZaQkGDDhw+3nj172rXXXmvt27e3d99919566y13OiMAABAd6JMJ3yksKjzm1b9/f5s1a5b7+y9/+YsbzLNz505r0KCBjRs3zrp161bkddBvCAD8x7EVfiJkokziQAgAHFtRutEnEwAAAL4jZAIAAMB3hEwAAAD4jtHlOGXVS1pm0WTbxM4lXQQAAIKoyQQAAIDvCJkAAADwHSETAAAAviNkAgAAwHeETAAAAPiOkAnfrVmzxrp06WK1a9e2mJgYW7x4cfCxw4cP24gRI6xJkyZWuXJlt0y/fv1s165d7AkAAKIIIRO+O3DggDVr1symTZt21GMHDx601NRUGzVqlLtduHChpaWlWdeuXdkTAABEEc6TCd917NjRTfmpXr26vffee2Hzpk6daq1atbIdO3ZYQkICewQAgChAyESJy8zMdM3qZ5xxRoHLZGdnu8mTlZUVodIBAIDjQXM5StShQ4csKSnJ7rzzTqtWrVqBy6WkpLhaUG+qU6dORMsJAACKh5CJEqNBQL169bLc3FybPn16ocsmJye7Gk9vysjIiFg5AQBA8dFcjhILmD169LCtW7faypUrC63FlLi4ODcBAICygZCJEguYW7ZssVWrVlnNmjXZCwAARBlCJny3f/9+S09PD95XbeXGjRstPj7enRfz9ttvd6cvWrp0qeXk5Nju3bvdcnq8QoUK7BEAAKIAIRO+W79+vbVv3z54f+jQoe62f//+NnbsWFuyZIm737x587DnqVazXbt27BEAAKIAIRO+U1AMBAIFPl7YYwAAIDowuhwAAAC+I2QCAADAd4RMAAAA+I6QCQAAAN8RMgEAAOA7QiYAAAB8R8gEAACA7wiZAAAA8B0hEwAAAL4jZCLijhw5YiNHjrQLLrjAKlWqZPXr17cnn3zScnNz2RsAAEQJLiuJiHvmmWdsxowZNnv2bGvcuLG71nliYqJVr17dBg8ezB4BACAKEDIRcZ988ol169bNOnfu7O7Xq1fP5s2b58ImAACIDjSXI+LatGljK1assLS0NHd/06ZNtnbtWuvUqVOBz8nOzrasrKywCQAAlF7UZCLiRowYYZmZmdawYUOLjY21nJwcmzBhgvXu3bvA56SkpNi4ceMiWk4AAHD8qMlExC1YsMDmzJljc+fOtdTUVNc3c9KkSe62IMnJyS6YelNGRkZEywwAAIqHmkxE3PDhwy0pKcl69erl7jdp0sS2b9/uaiv79++f73Pi4uLcBAAAygZqMhFxBw8etHLlwj96ajbnFEYAAEQPajIRcV26dHF9MBMSEtwpjD7//HObPHmyDRgwgL0BAECUIGQi4qZOnWqjRo2ygQMH2p49e6x27dr2wAMP2OjRo9kbAABECUImIq5q1ao2ZcoUNwEAgOhEn0wAAAD4jpAJAAAA3xEyAQAA4DtCJgAAAHxHyAQAAIDvCJkAAADwHSETAAAAviNkAgAAwHeETAAAAPiOkIkSl5KSYjExMTZkyJCSLgoAAPAJIRMlat26dfbyyy9b06ZN2RMAAEQRQiZKzP79+61Pnz42c+ZMq1GjBnsCAIAoQshEiRk0aJB17tzZrr/++mMum52dbVlZWWETAAAovcqXdAFwapo/f76lpqa65vKi9tscN27cSS8XAADwBzWZiLiMjAwbPHiwzZkzxypWrFik5yQnJ1tmZmZw0msAAIDSi5pMRNyGDRtsz5491qJFi+C8nJwcW7NmjU2bNs01jcfGxoY9Jy4uzk0AAKBsIGQi4jp06GCbN28Om5eYmGgNGza0ESNGHBUwAQBA2UPIRMRVrVrVLr300rB5lStXtpo1ax41HwAAlE2ETCBK1EtaZtFi28TOJV0EAMAJImSiVFi9enVJFwEAAPiI0eUAAADwHSETAAAAviNkAgAAwHf0yQRQ6kTTIKZoHMjE/gFQFNRkAgAAwHeETAAAAPiOkAkAAADfETIBAADgO0ImAAAAfEfIBAAAgO8ImQAAAPAdIRMAAAC+42TsKJNycnLc7c6dO61atWrH9RpHsn7yuVRA/vQ5jSbR9t2Jtv1zIrKyssKOscCJiAkEAoETegWgBKxbt85atWrFtgeAk+Cf//yntWzZkm2LE0LIRJm0b98+i4+Pt4yMjOOuyQQAHF2TWadOHdu7d6/VqFGDzYMTQnM5yqTY2Fh3q4BJyASAk3OMBU4EA38AAADgO0ImAAAAfEfIBAAAgO8ImQAAAPAdIRMAAAC+I2QCAADAd4RMAAAA+I6QCQAAAN8RMgEAAOA7QiYARKl27drZkCFDSu16YmJibPHixRbNToX3CBSEkAkAOKnGjh1rzZs3P2r+Dz/8YB07diwVWz8tLc26detmtWrVcpeqvfrqq23VqlVhywwePNhatGhhcXFx+b4fAOEImQCAEnHOOee4wFYadO7c2Y4cOWIrV660DRs2uBB588032+7du4PLBAIBGzBggPXs2dNKu8OHD5d0EQBCJgCcKn777Td77LHH7LzzzrPKlSvbFVdcYatXrw4+/vPPP1vv3r3t/PPPt9NPP92aNGli8+bNC3uNAwcOWL9+/axKlSp27rnn2nPPPVfoOmfNmmXjxo2zTZs2uaZjTZqXtyl527Zt7v4bb7xh11xzjVWqVMlatmzpahjXrVtnl19+uVvnTTfdZD/++GPYOl577TW75JJLrGLFitawYUObPn16sbbLTz/9ZOnp6ZaUlGRNmza1iy66yCZOnGgHDx60f/3rX8Hl/vSnP9mgQYOsfv36xX797t27u22q116yZEnY4x988IG1atXKBW5tU5VDgddTr149mzJlSthzFIJVQ+zRtpsxY4arjdW+feqpp2zfvn3Wp08fO/PMM9321Lq1rYBIoSYTAE4RiYmJ9tFHH9n8+fPtiy++sDvuuMOFti1btrjHDx065JqDly5dal9++aXdf//91rdvX/vss8+CrzF8+HDXjLxo0SJbvny5C6mq+SuIav2GDRtmjRs3ds3jmgqrCRwzZoyNHDnSUlNTrXz58i70Khi/8MIL9uGHH9q3335ro0ePDi4/c+ZMe+KJJ2zChAn29ddf29NPP22jRo2y2bNnh/UZvfvuuwtcZ82aNV1Iff31112IVsD785//bGeffbbbHidKIbtHjx5um3fq1MkFv71797rHvv/+ezdPgVpB/KWXXrJXX33VhcTi0rZTyNy8ebOrcdV2+Oqrr+ydd95x20avre4AQMQEgDIoMzMzoI+vbgHkr23btoHBgwe7v9PT0wMxMTGB77//PmyZDh06BJKTkwvchJ06dQoMGzbM/f3rr78GKlSoEJg/f37w8Z9//jlQqVKl4HryM2bMmECzZs2Omq/v8KJFi9zfW7dudfdfeeWV4OPz5s1z81asWBGcl5KSEmjQoEHwfp06dQJz584Ne93x48cHWrduHbzft2/fQFJSUqAwO3fuDLRo0cJto9jY2EDt2rUDn3/+ebHeT35U/pEjRwbv79+/363jnXfecfcff/xx935yc3ODy7z44ouBKlWqBHJyctz9unXrBp5//vmw19X6VY7Q9QwZMiRsmS5dugQSExMDxcGxFX4qH7k4CwAoKaoZVBa5+OKLw+ZnZ2e7mjzJyclxzcQLFixwNWx6TJOaX0W1iGpyb926dfD58fHx1qBBA9/KqeZqj2oSRc32ofP27Nnj/lazeUZGht1zzz123333BZdRTWT16tWD91VDWRhtl4EDB9pZZ53lakvVtPzKK6+4PplqqlcTtl/vSduyatWqwfegGkZtTzV3ezToaP/+/bZz505LSEgo8nrUpSDUgw8+aLfddpvb9zfccIPdcsstdtVVV53QewGKg5AJAKeA3Nxci42NdU3bug2lvo6i/pXPP/+86/+nYKdApFMTKVjK/1WYnVynnXZa8G8veOWdp/fivSevyVz9S0PlfY+F0WAfdRFQH0aNLBf163zvvfdcs7v6SPr1nvK+B23T0IDpzfOWk3Llyh217fMb2OP9M+DRyP3t27fbsmXL7P3337cOHTq4PqWTJk06ofcDFBUhEwBOAZdddpmrqVQNmgbW5Ee1eOrTd9ddd7n7CkLqr6n+inLhhRe6wPTpp58Ga9gUzDQ4p23btgWuu0KFCm7dflOtpgYxfffdd66f4/HSAB8vzIXSfS8MniyNGjWyN998Myxsfvzxx662U+9NNHBHfVk9WVlZtnXr1iK9vp6r/qiatN/Vp5aQiUghZOKUVS9pmUWTbRM7l3QRUIqpmVxBTCPDVWOp0KlRz6rFU62lBp8oRCrwKOTUqFHDJk+e7E7h44VM1XiqaVpBRU3sCnkadJM3nOWl0dEKRRs3bnQj1xWg/Dp1kUZYP/LII64GUjV3at5fv369C79Dhw51y+g9K7ClpKTk+xpqrtb77d+/vxtUpOZy1Y6qzDq1kUcj0NWMrW3yn//8x70fLygqSB8PNdOr5vjhhx+2hx56yL755hs3gEdl97brdddd50bkd+nSxZVTA3qKUlOr96KBSxp0pe2i2lpvXwKRQMgEgFOETl+jUcsa7a0+lwqKClgKmKLwomB14403utPtaHS5+vFlZmYGX+PZZ591Qatr164uLOq1Qh/Pj/oFLly40Nq3b2+//PKLK0dho72L495773VlVbk0Cl1NxgrNoVcg2rFjR6FBWCOu3333XReYFejUFK1g9ve//92aNWsWti6dbsijoC7aZgrSx0Ph9+2333bBXetSH1cFeY2w9yQnJ7vaWvURVV/T8ePHF6kmU8FXz9XpoRScVZOpMwsAkRKj0T8RWxvgEzUX6WCrHzevD1VxUZMJAP4fWwEP58kEAACA7wiZAAAA8B0hE75bs2aN66Beu3btsMvGhdK54dSnS80y6td15ZVXun5TAAAgOhAy4Ttdlk0d2KdNm5bv4zqhc5s2bdw1hnVJOl1KTQMOdN1hAAAQHRhdDt/pNCKaCqIRnBrN+sc//jE4r379+uwJAACiCDWZiCid2FhXn9A5+3SaFF3GTVfqyK9JHQAAlF2ETESUrjaic+zp+sg33XSTLV++3Lp372633npr2Pnn8tKJhHVqjdAJAACUXjSXI6K8S7Tp0nWPPvqo+7t58+buCiMzZswo8NJ0ulLHuHHjIlpWAABw/KjJRETpyhrly5d3l2ELpUudFTa6XFet0MmBvSkjIyMCpQUAAMeLmkxElC5z1rJlS3d93lBpaWlWt27dAp+n6xz7da1jAABw8hEy4Tv1uUxPTw/e1zV2N27c6K7Jm5CQ4K7R27NnT7v22mvdtYx1zeC33nrLnc4IAABEB0ImfLd+/XoXHj1Dhw51t/3797dZs2a5gT7qf6l+lo888og1aNDA3nzzTXfuTAAAEB0ImfBdu3btLBAIFLrMgAED3AQAAKITA38AAADgO0ImAAAAfEfIBAAAgO8ImQAAAPAdIRMAAAC+I2QCAADAd4RMAAAA+I6QCQAAAN8RMgEAAOA7QiYAAAB8R8iE79asWWNdunSx2rVrW0xMjC1evDj42OHDh23EiBHWpEkTq1y5slumX79+tmvXLvYEAABRhJAJ3x04cMCaNWtm06ZNO+qxgwcPWmpqqo0aNcrdLly40NLS0qxr167sCQAAokj5ki4Aok/Hjh3dlJ/q1avbe++9FzZv6tSp1qpVK9uxY4clJCREqJQAAOBkImSixGVmZrpm9TPOOKPAZbKzs93kycrKilDpAADA8aC5HCXq0KFDlpSUZHfeeadVq1atwOVSUlJcLag31alTJ6LlBAAAxUPIRInRIKBevXpZbm6uTZ8+vdBlk5OTXY2nN2VkZESsnAAAoPhoLkeJBcwePXrY1q1bbeXKlYXWYkpcXJybAABA2UDIRIkFzC1bttiqVausZs2a7AUAAKIMIRO+279/v6Wnpwfvq7Zy48aNFh8f786Lefvtt7vTFy1dutRycnJs9+7dbjk9XqFCBfYIAABRgJAJ361fv97at28fvD906FB3279/fxs7dqwtWbLE3W/evHnY81Sr2a5dO/YIAABRgJAJ3ykoBgKBAh8v7DEAABAdGF0OAAAA3xEyAQAA4DtCJgAAAHxHyAQAAIDvCJkAAADwHSETAAAAviNkAgAAwHeETAAAAPiOkAkAAADfETIRcUeOHLGRI0faBRdcYJUqVbL69evbk08+abm5uewNAACiBJeVRMQ988wzNmPGDJs9e7Y1btzYXes8MTHRqlevboMHD2aPAAAQBQiZiLhPPvnEunXrZp07d3b369WrZ/PmzXNhEwAARAeayxFxbdq0sRUrVlhaWpq7v2nTJlu7dq116tSpwOdkZ2dbVlZW2AQAAEovajIRcSNGjLDMzExr2LChxcbGWk5Ojk2YMMF69+5d4HNSUlJs3LhxES0nAAA4ftRkIuIWLFhgc+bMsblz51pqaqrrmzlp0iR3W5Dk5GQXTL0pIyMjomUGAADFQ00mIm748OGWlJRkvXr1cvebNGli27dvd7WV/fv3z/c5cXFxbgIAAGUDNZmIuIMHD1q5cuEfPTWbcwojAACiBzWZiLguXbq4PpgJCQnuFEaff/65TZ482QYMGMDeAAAgShAyEXFTp061UaNG2cCBA23Pnj1Wu3Zte+CBB2z06NHsDQAAogQhExFXtWpVmzJlipsAAEB0ok8mAAAAfEfIBAAAgO8ImQAAAPAdIRMAAAC+I2QCAADAd4RMAAAA+I6QCQAAAN8RMgEAAOA7QiYAAAB8R8hEiUtJSbGYmBgbMmRISRcFAAD4hJCJErVu3Tp7+eWXrWnTpuwJAACiCCETJWb//v3Wp08fmzlzptWoUYM9AQBAFCFkosQMGjTIOnfubNdff/0xl83OzrasrKywCQAAlF7lS7oAODXNnz/fUlNTXXN5Ufttjhs37qSXCwAA+IOaTERcRkaGDR482ObMmWMVK1Ys0nOSk5MtMzMzOOk1AABA6UVNJiJuw4YNtmfPHmvRokVwXk5Ojq1Zs8amTZvmmsZjY2PDnhMXF+cmAABQNhAyEXEdOnSwzZs3h81LTEy0hg0b2ogRI44KmAAAoOwhZCLiqlatapdeemnYvMqVK1vNmjWPmg8AAMom+mQCAADAd9RkolRYvXp1SRcBAAD4iJpMAAAA+I6QCQAAAN8RMgEAAOA7+mQCAIqlXtKyqNpi2yZ2LukiAFGJmkwAAAD4jpAJAAAA3xEyAQAA4DtCJgAAAHzHwB8ApQ4DSwCg7KMmEwAAAL4jZAIAAMB3hEwAAAD4jj6ZKJNycnLc7c6dO61atWrH9RpHsn6yaKJtES3YN6Ub+yd6ZWVlhR1jgRMREwgEAif0CkAJWLdunbVq1YptDwAnwT//+U9r2bIl2xYnhJCJMmnfvn0WHx9vGRkZx12TCQA4uiazTp06tnfvXqtRowabByeE5nKUSbGxse5WAZOQCQAn5xgLnAgG/gAAAMB3hEwAAAD4jpAJAAAA3xEyAQAA4DtCJgAAAHxHyAQAAIDvCJkAAADwHefJxCmrXtIyiybbJnYu6SIAABBETSYARKl27drZkCFDSu16YmJibPHixRbNToX3CBSEkAkAOKnGjh1rzZs3P2r+Dz/8YB07diwVWz8tLc26detmtWrVclcRu/rqq23VqlXBx3/++We76aabrHbt2hYXF+cuvfjQQw+5yzACyB8hEwBQIs455xwX2EqDzp0725EjR2zlypW2YcMGF4pvvvlm2717t3u8XLlyLoQuWbLEBdJZs2bZ+++/b7///e+tNDp8+HBJFwEgZALAqeK3336zxx57zM477zyrXLmyXXHFFbZ69eqw2rrevXvb+eefb6effro1adLE5s2bF/YaBw4csH79+lmVKlXs3HPPteeee67QdSqMjRs3zjZt2uSajjVpXt6m5G3btrn7b7zxhl1zzTVWqVIla9mypQt069ats8svv9ytU7WJP/74Y9g6XnvtNbvkkkusYsWK1rBhQ5s+fXqxtstPP/1k6enplpSUZE2bNrWLLrrIJk6caAcPHrR//etfbpkaNWrYgw8+6MpRt25d69Chgw0cONA+/PDDIr1+9+7d3TbVayuohvrggw+sVatWLnBrm6ocCryeevXq2ZQpU8KeoxCsGmKPtt2MGTNcENa+feqpp2zfvn3Wp08fO/PMM9321Lq1rYBIoSYTAE4RiYmJ9tFHH9n8+fPtiy++sDvuuMOFti1btrjHDx06ZC1atLClS5fal19+affff7/17dvXPvvss+BrDB8+3DUjL1q0yJYvX+5Cqmr+CtKzZ08bNmyYNW7c2DWPa9K8gowZM8ZGjhxpqampVr58eRd6FYxfeOEFF+i+/fZbGz16dHD5mTNn2hNPPGETJkywr7/+2p5++mkbNWqUzZ49O6zP6N13313gOmvWrOlC6uuvv+5CtALen//8Zzv77LPd9sjPrl27bOHChda2bVs7FoXsHj16uG3eqVMnF/z27t3rHvv+++/dPAVqBfGXXnrJXn31VRcSi0vbTiFz8+bNNmDAALcdvvrqK3vnnXfcttFrqzsAECmMLgeAU4DCmWold+7c6foVyh/+8Ad79913Xe2WwplqODXP8/DDD7vH//a3v7laz/3797sApDD2u9/9zi2jMKeaz4KoBk01kAqMah4/Fq3/xhtvdH8PHjzYhcwVK1a4PpJyzz33BGtCZfz48a429dZbb3X3L7jgAhesFBL79+/v5iUkJLgawoKoFvC9995zAa1q1aquaVwBU+/9jDPOCFtW5fn73/9u//nPf6xLly72yiuvHPM9KeDqeaLtPHXqVPvnP//pAr5qXdW/c9q0aa4cqolVgB0xYoQL0ypLUd15550uXHp27Nhhl112mat99WpEgUgiZALAKUA1g4FAwC6++OKw+dnZ2a4mT3Jyclwz8YIFC1wNmx7TpOZXL6iqyb1169bB58fHx1uDBg18K6eaqz0KeqJm+9B5e/bscX+r2TwjI8MFz/vuuy+4jGoiq1evHryvUFwYbRc1fZ911lmutlTBWOFRfTLVVB8aUJ9//nlXY/jNN9/Y448/bkOHDj1m83zoe9K2VJD13oNqGLU9FTA9CtQK9PqHQAG5qLww6VHz/m233eb2/Q033GC33HKLXXXVVUV+PeBEETIB4BSQm5trsbGxrmlbt6FU0yiqEVSIUv8/BTsFIp2aSMHSC2Mn22mnnRb82wteeefpvXjvyWsyV01rqLzvsTAa7KMuAurDqJHlouCo2k3V1KqPpEe1sZpU46hwrv6japYurKY0tPx534O2aWjA9OaFvn/VZubd9vkN7PH+GfBo5P727dtt2bJlbpCS+pEOGjTIJk2aVORtA5wIQiYAnALUbKqaStWgKRjlR7V4ajK+66673H0FIfXXVH9FufDCC11g+vTTT4M1bApmGpxTWN/EChUquHX7TbWaauL/7rvvXD/H46UBPpK3aVr3vTCYHy/4qbb3eDVq1MjefPPNsLD58ccfu9pOvTfRwB31ZfXotElbt24t0uvruWqu16T9rj61hExECiETAE4BaiZXENPIcNVYKnRq1LNq8VRrqcEnCpEKPAo5Gk09efJkdwofL2SqxlNN0woqqsVTyNOgm2P1G1RfQIWijRs3uv6bClB+nbpII6wfeeQRVwOpmjsFvvXr17vwq6Zs0XtWYEtJScn3NdRcrferPpzqB6nmctWOqsw6tZG8/fbb9u9//9sN0NF2UL9PDUhS0/aJ9HVUM71qjtX/VefdVDO8muNVdm+7Xnfdda4fqvqAqpyqOS1KTa3eiwYuadCVtotqa719CUQCIRMAThEa4KNRyxrtrT6XCooKWAqYovCiYKWBNzrdjkaXqx9fZmZm8DWeffZZ11+wa9euLizqtUIfz4/6BWokdvv27e2XX35x5ShstHdx3Hvvva6sKpdCn5qMFZpDr0CkATCFBWGNuNYgHwVmBTo1RSuYaYBPs2bN3DJe8Hz00UddYNNgHQ02Cm1KPx4KvwqwCu5al/q4KshrhL0nOTnZ1daqj6j6mmqwU1FqMlWDrOfq9FAqv2oydWYBIFJiApHoZAP4TM1FOtjqx83rQ1VcXLscAPw/tgIezpMJAAAA3xEyAQAA4DtCJgAAAHxHyITv1qxZ40ZB6qoiodcmDqUTEGvggPr+aPDAlVde6TrnAwCA6EDIhO907V+NktRl0vKjq4a0adPGncxY1z3W9Xo1qrVixYrsDQAAogSnMILvdK46TQXRaUJ0ypQ//vGPwXn169dnTwAAEEWoyURE6eoZusSZTgytc/HpWsG6HFx+TeqhdF46nVojdAIAAKUXIRMRpUva6UTOEydOtJtuusmWL19u3bt3dyc1/uCDDwp8nq7Uof6b3qQTIQMAgNKLkImI8q4DrOsj68oZzZs3d1fM0JUsZsyYUeDzdNUKnRzYmzIyMiJYagAAUFz0yURE6fJt5cuXt0aNGoXN1/V0165dW+DzdJ1jv651DAAATj5qMhFRupZuy5Yt7Ztvvgmbn5aWZnXr1mVvAAAQJajJhO/U5zI9PT14f+vWrbZx40aLj4+3hIQEGz58uPXs2dOuvfZaa9++vb377rv21ltvudMZAQCA6EDIhO/Wr1/vwqNn6NCh7rZ///42a9YsN9BH/S81mOeRRx6xBg0a2JtvvunOnQkAAKIDIRO+a9eunQUCgUKXGTBggJsAAEB0ok8mAAAAfEfIBAAAgO8ImQAAAPAdIRMAAAC+I2QCAADAd4RMAAAA+I6QCQAAAN8RMgEAAOA7QiYAAAB8R8iE79asWWNdunSx2rVrW0xMjC1evDj42OHDh23EiBHWpEkTq1y5slumX79+tmvXLvYEAABRhJAJ3x04cMCaNWtm06ZNO+qxgwcPWmpqqo0aNcrdLly40NLS0qxr167sCQAAogjXLofvOnbs6Kb8VK9e3d57772weVOnTrVWrVrZjh07LCEhgT0CAEAUIGSixGVmZrpm9TPOOKPAZbKzs93kycrKilDpAADA8aC5HCXq0KFDlpSUZHfeeadVq1atwOVSUlJcLag31alTJ6LlBAAAxUPIRInRIKBevXpZbm6uTZ8+vdBlk5OTXY2nN2VkZESsnAAAoPhoLkeJBcwePXrY1q1bbeXKlYXWYkpcXJybAABA2UDIRIkFzC1bttiqVausZs2a7AUAAKIMIRO+279/v6Wnpwfvq7Zy48aNFh8f786Lefvtt7vTFy1dutRycnJs9+7dbjk9XqFCBfYIAABRgJAJ361fv97at28fvD906FB3279/fxs7dqwtWbLE3W/evHnY81Sr2a5dO/YIAABRgJAJ3ykoBgKBAh8v7DEAABAdGF0OAAAA3xEyAQAA4DtCJgAAAHxHyAQAAIDvCJkAAADwHSETAAAAviNkAgAAwHeETAAAAPiOkAkAAADfETIRcUeOHLGRI0faBRdcYJUqVbL69evbk08+abm5uewNAACiBJeVRMQ988wzNmPGDJs9e7Y1btzYXes8MTHRqlevboMHD2aPAAAQBQiZiLhPPvnEunXrZp07d3b369WrZ/PmzXNhEwAARAeayxFxbdq0sRUrVlhaWpq7v2nTJlu7dq116tSpwOdkZ2dbVlZW2AQAAEovajIRcSNGjLDMzExr2LChxcbGWk5Ojk2YMMF69+5d4HNSUlJs3LhxES0nAAA4ftRkIuIWLFhgc+bMsblz51pqaqrrmzlp0iR3W5Dk5GQXTL0pIyMjomUGAADFQ00mIm748OGWlJRkvXr1cvebNGli27dvd7WV/fv3z/c5cXFxbgIAAGUDNZmIuIMHD1q5cuEfPTWbcwojAACiBzWZiLguXbq4PpgJCQnuFEaff/65TZ482QYMGMDeAAAgShAyEXFTp061UaNG2cCBA23Pnj1Wu3Zte+CBB2z06NHsDQAAogQhExFXtWpVmzJlipsAAEB0ok8mAAAAfEfIBAAAgO8ImQAAAPAdIRMAAAC+I2QCAADAd4RMAAAA+I6QCQAAAN8RMgEAAOA7QiYAAAB8R8hEiUtJSbGYmBgbMmRISRcFAAD4hJCJErVu3Tp7+eWXrWnTpuwJAACiCCETJWb//v3Wp08fmzlzptWoUYM9AQBAFCFkosQMGjTIOnfubNdff/0xl83OzrasrKywCQAAlF7lS7oAODXNnz/fUlNTXXN5Ufttjhs37qSXCwAA+IOaTERcRkaGDR482ObMmWMVK1Ys0nOSk5MtMzMzOOk1AABA6UVNJiJuw4YNtmfPHmvRokVwXk5Ojq1Zs8amTZvmmsZjY2PDnhMXF+cmAABQNhAyEXEdOnSwzZs3h81LTEy0hg0b2ogRI44KmAAAoOwhZCLiqlatapdeemnYvMqVK1vNmjWPmg8AAMom+mQCAADAd9RkolRYvXp1SRcBAAD4iJpMAAAA+I6QCQAAAN8RMgEAAOA7QiYAAAB8R8gEAACA7wiZAAAA8B0hEwAAAL4jZAIAAMB3hEwAAAD4jiv+AFGiXtIyixbbJnYu6SIAAE4QNZkAAADwHSETAAAAviNkAgAAwHf0yUSZlJOT42537txp1apVO67XOJL1k8+lgl+0XwFEXlZWVtgxFjgRhEyUSenp6e62cePGJV0UnAR1XmKzAiV9jG3ZsiU7ASckJhAIBE7sJYDI27dvn8XHx1tGRsZx12QCAI6uyaxTp47t3bvXatSowebBCaEmE2VSbGysu1XAJGQCwMk5xgIngoE/AAAA8B0hEwAAAL6juRynrGi6Qo5wlRwAQGlCTSYAAAB8R8gEAACA7wiZAAAA8B0hEwAAAL4jZAIAAMB3hEwAiFLt2rWzIUOGlNr1xMTE2OLFiy2anQrvESgIIRMAcFKNHTvWmjdvftT8H374wTp27Fgqtn5aWpp169bNatWq5a4idvXVV9uqVauOCox5pxkzZpRYmYHSjpAJACgR55xzjsXFxZWKrd+5c2c7cuSIrVy50jZs2OBC8c0332y7d+8OW+61115z4dib+vfvb6XR4cOHS7oIACETAE4Vv/32mz322GN23nnnWeXKle2KK66w1atXBx//+eefrXfv3nb++efb6aefbk2aNLF58+aFvcaBAwesX79+VqVKFTv33HPtueeeK3Sds2bNsnHjxtmmTZuCtX+al7cpedu2be7+G2+8Yddcc41VqlTJWrZs6WoY161bZ5dffrlb50033WQ//vjjUcHvkksusYoVK1rDhg1t+vTpxdouP/30k6Wnp1tSUpI1bdrULrroIps4caIdPHjQ/vWvf4Ute8YZZ7hw7E0qZ1Fev3v37m6b6rWXLFkS9vgHH3xgrVq1coFb21TlUOD11KtXz6ZMmRL2HIVg1RB7vFpV1cZq3z711FO2b98+69Onj5155pmunFq3thUQKdRkAsApIjEx0T766CObP3++ffHFF3bHHXe40LZlyxb3+KFDh6xFixa2dOlS+/LLL+3++++3vn372meffRZ8jeHDh7tm5EWLFtny5ctdSFXNX0F69uxpw4YNs8aNGwdr/zSvIGPGjLGRI0daamqqlS9f3oVeBeMXXnjBPvzwQ/v2229t9OjRweVnzpxpTzzxhE2YMMG+/vpre/rpp23UqFE2e/bssD6jd999d4HrrFmzpgupr7/+ugvRCnh//vOf7eyzz3bbI9RDDz3kmtQVgBXqcnNzj7ndFbJ79OjhtnmnTp1c8Nu7d6977Pvvv3fz9HoK4i+99JK9+uqrLiQWl7adQubmzZttwIABbjt89dVX9s4777hto9dW2YFI4bKSAHAKUDhTreTOnTutdu3abt4f/vAHe/fdd13tlsKZajg1z/Pwww+7x//2t7+5Ws/9+/e7AKQw9rvf/c4tozCnms+CqAZNNZAKjKr5Oxat/8Ybb3R/Dx482IXMFStWuD6Scs899wRrQmX8+PGuNvXWW2919y+44AIXrBQSvabshIQEV0NYENUCvvfeey6gVa1a1cqVK+cCpt67ai5D19WhQwf3nlQmhWfVUioUF0YBV+9DtJ2nTp1q//znP13AV61rnTp1bNq0aa4cqondtWuXjRgxwoVplaWo7rzzThcuPTt27LDLLrvM1QJ7NaJAJBEyAeAUoJrBQCBgF198cdj87OxsV5MnOTk5rpl4wYIFroZNj2lS86sXVNXk3rp16+Dz4+PjrUGDBr6VU83VHgU9UbN96Lw9e/a4v9VsnpGR4YLnfffdF1xGNZHVq1cP3lcoLoy2y8CBA+2ss85ytaUKka+88orrk6mmei+ghoZJbyDTk08+ecyQGfqetC0VZL33oBpGbU8FTI8CtQK9/iFQQC4qL0x6HnzwQbvtttvcvr/hhhvslltusauuuqrIrwecKEImAJwC1KwbGxvrmrZ1G0o1jaIaweeff971/1OwUyDSqYkULL0wdrKddtppwb+94JV3ntdE7d2qyVw1raHyvsfCaLCPugioD6NGlotqGFW7qZpa9ZHMz5VXXmlZWVn273//OxiIj/We8r4HbdPQgOnNC33/qs3Mu+3zG9jj/TPg0cj97du327Jly+z99993tbCDBg2ySZMmFbo9AL8QMgHgFKBmU9VUqgZNA2vyo1o8NRnfdddd7r6CkPprqr+iXHjhhS4wffrpp8EaNgUzDc5p27ZtgeuuUKGCW7ffFOzUxP/dd9+5fo7HSwN8JG/TtO4X1ufy888/d4ONQpvUi6tRo0b25ptvhoXNjz/+2NV26r2JBu6oL6tHwXbr1q1Fen09V831mrTf1aeWkIlIIWQCwClAzeQKYhoZrhpLhU71J1QtnmotNfhEIVKBRyGnRo0aNnnyZHcKHy9kqsZTTdMKKmpiV8jToJtj9RtUX0CFoo0b/3/t3X9MleX/x/E3oqASoFjTSH5of0imYZmsFEvUSiV0mZbWJula9msKlAmVKS5HP5izYepqLVuWuiWrNFeaqeTyDxEpqk1y+YNSc7bkhz9I4f7sfX0HAwW/ote5zzl3z8d2ezz3ue/jdZ373jkvr/u6rrvc9N/UAGVr6iIdYT1nzhzTAqktd3p5v7S01ITfnJwcs43WWQNbQUFBm++hl6u1vtqHU/tB6uVybR3VMuvURmrjxo3ms9Bt9XUd/KR118FR11IXvUyvLcfa/1UHFe3fv98M4NGyN32uo0ePNv1QMzIyTDl1QM+VtNRqXXTgkg660s9FW2ubjiXgBkImAPxH6AAfHbWsA1a0z6UGRQ1NGjCVhhcNVjrwRqfb0QCl/fiqq6ub3+Ptt982/QUnTpxowqK+V8vX26L9AouLiyUtLU1OnTplynG50d4d8eSTT5qyarl0FLpeMtbQ3PIORDoA5nJBWEdc6yAfDY0a6PRStAazL774QpKTk8022oKrl9A1/GnrZv/+/U1/TL38fC00/G7evNkEd/23tI+rBvmW/Tzz8vJMa632EdW+pjoA6UpaMrUFWffV6aE0GGtLps4sALglxHGjkw1gmV4u0i9b/XFr6kPVUYm5X3nquBx64/9aXADAn9+tQBPmyQQAAIB1hEwAAABYR8gEAACAdYRMWFdSUmJGQepdRVrem7glnYBYBw5o3x8dPKDzzWnnfAAA4A2ETFin9/7VUZJ6m7S26F1DUlNTze3T9L7Her9eHdWq880BAABvYAojWKdz1enSHp0mRKdMeeutt5rX6XQgAADAO2jJhKt0fjm9xZlODK1z8em9gvV2cG1dUm9JJxLWqTVaLgAAIHARMuEqvaWdTuT8xhtvyLhx42TLli3y0EMPyeTJk2Xnzp3t7qd36tD+m01LXFycq+UGAAAdQ8iEq5ruA6z3R87OzpYhQ4ZIbm6uuZPFqlWr2t1P71qhkwM3LVVVVS6WGgAAdBR9MuEqvX1b586dZeDAga3W6/10d+3a1e5+em9gW/c6BgAAvkdLJlyl99IdNmyY7N+/v9X6yspKSUhI4GgAAOARtGTCOu1zeeDAgebnBw8elPLycomJiZH4+HiZN2+ePProo3LPPfdIWlqafP3117Jx40YznREAAPAGQiasKy0tNeGxSU5OjnnMzMyU1atXm4E+2v9SB/PMmTNHBgwYIBs2bDBzZwIAAG8gZMK6UaNGieM4l91m1qxZZgEAAN5En0wAAABYR8gEAACAdYRMAAAAWEfIBAAAgHWETAAAAFhHyAQAAIB1hEwAAABYR8gEAACAdYRMAAAAWEfIhHUlJSWSkZEhsbGxEhISIp9//nnza+fPn5f58+fL4MGDJSIiwmwzY8YMOXr0KEcCAAAPIWTCutOnT0tycrIsX778ktfOnDkjZWVlsmDBAvNYXFwslZWVMnHiRI4EAAAewr3LYd348ePN0pbo6GjZunVrq3VFRUWSkpIiR44ckfj4eI4IAAAeQMiE31VXV5vL6j169Gh3m/r6erM0qampcal0AADganC5HH517tw5yc3Nlccee0yioqLa3a6goMC0gjYtcXFxrpYTAAB0DCETfqODgKZNmyaNjY2yYsWKy26bl5dnWjyblqqqKtfKCQAAOo7L5fBbwHzkkUfk4MGD8t133122FVOFh4ebBQAABAdCJvwWMH/77TfZvn279OrVi6MAAIDHEDJhXV1dnRw4cKD5ubZWlpeXS0xMjJkXc8qUKWb6ok2bNklDQ4McP37cbKevh4WFcUQAAPAAQiasKy0tlbS0tObnOTk55jEzM1MWLVokX375pXk+ZMiQVvtpq+aoUaM4IgAAeAAhE9ZpUHQcp93XL/caAADwBkaXAwAAwDpCJgAAAKwjZAIAAMA6QiYAAACsI2QCAADAOkImAAAArCNkAgAAwDpCJgAAAKwjZAIAAMA6QiZcd+HCBXn11VelX79+0q1bN+nfv78sXrxYGhsbORoAAHgEt5WE6958801ZtWqVfPTRR3Lrrbeae53PnDlToqOjZe7cuRwRAAA8gJAJ1+3evVsmTZok6enp5nliYqKsXbvWhE0AAOANXC6H61JTU2Xbtm1SWVlpnv/444+ya9cumTBhQrv71NfXS01NTasFAAAELloy4br58+dLdXW1JCUlSWhoqDQ0NMiSJUtk+vTp7e5TUFAg+fn5rpYTAABcPVoy4br169fLmjVr5NNPP5WysjLTN7OwsNA8ticvL88E06alqqrK1TIDAICOoSUTrps3b57k5ubKtGnTzPPBgwfL4cOHTWtlZmZmm/uEh4ebBQAABAdaMuG6M2fOSKdOrU89vWzOFEYAAHgHLZlwXUZGhumDGR8fb6Yw2rdvnyxdulRmzZrF0QAAwCMImXBdUVGRLFiwQJ599lk5ceKExMbGyuzZs+W1117jaAAA4BGETLguMjJSli1bZhYAAOBN9MkEAACAdYRMAAAAWEfIBAAAgHWETAAAAFhHyAQAAIB1hEwAAABYR8gEAACAdYRMAAAAWEfIBAAAgHWETPhdQUGBhISESFZWlr+LAgAALCFkwq/27Nkj7733ntx2220cCQAAPISQCb+pq6uTxx9/XN5//33p2bMnRwIAAA8hZMJvnnvuOUlPT5exY8f+v9vW19dLTU1NqwUAAASuzv4uAP6b1q1bJ2VlZeZy+ZX228zPz/d5uQAAgB20ZMJ1VVVVMnfuXFmzZo107dr1ivbJy8uT6urq5kXfAwAABC5aMuG6vXv3yokTJ2To0KHN6xoaGqSkpESWL19uLo2Hhoa22ic8PNwsAAAgOBAy4boxY8ZIRUVFq3UzZ86UpKQkmT9//iUBEwAABB9CJlwXGRkpgwYNarUuIiJCevXqdcl6AAAQnOiTCQAAAOtoyURA2LFjh7+LAAAALKIlEwAAANYRMgEAAGAdIRMAAADWETIBAABgHSETAAAA1hEyAQAAYB0hEwAAANYRMgEAAGAdIRMAAADWETIBAABgHSETAAAA1hEyAQAAYF1n+28J+J7jOOaxpqbmqt+jsf6MeMm1fBYA0PJ7pOk7FrgWhEwEpdraWvMYFxfn76IEjOhl/i4BAC99x0ZHR/u7GAhyIQ7/XUEQamxslKNHj0pkZKSEhIRIILcKaBCuqqqSqKgoCWZeqouiPoGN4+MfGgk0YMbGxkqnTvSow7WhJRNBSb/8+vbtK8FCQ5kXgpnX6qKoT2Dj+LiPFkzYwn9TAAAAYB0hEwAAANYRMgEfCg8Pl4ULF5rHYOeluijqE9g4PkDwY+APAAAArKMlEwAAANYRMgEAAGAdIRMAAADWETIBAEFv9erV0qNHD/GqRYsWyZAhQ/xdDKBDCJmAj6xYsUL69esnXbt2laFDh8r3338ftJ/1kiVLZPjw4dK9e/d2f8iPHDkiGRkZEhERIddff73MmTNH/v33X/FS+SsqKuTee++Vbt26yU033SSLFy/2+T2e3Sz7zp07zbmq52z//v1l1apV4oZgPr+C+dwCfI2QCfjA+vXrJSsrS1555RXZt2+fjBw5UsaPH29+bILFP//8I3V1debv+oM4depUeeaZZ9rctqGhQdLT0+X06dOya9cuWbdunWzYsEFeeOEF8Ur59TaH9913n7nd3p49e6SoqEgKCwtl6dKlnij7wYMHZcKECeZc1XP25ZdfNmFI38sXgvn8CuZzC3CV3rscgF0pKSnO008/3WpdUlKSk5ubG9Af9fnz551NmzY5U6dOdcLDw53y8vJWr3/44YdOdHT0Jftt3rzZ6dSpk/Pnn382r1u7dq15j+rqascL5V+xYoXZ99y5c83bFBQUOLGxsU5jY2PQl/2ll14y52hLs2fPdu66665rrpsbdbx435MnTzrDhg1zMjIynLNnzwb98Vm4cKGTnJzc/Prvv//u3HzzzeZ7pqGh4ZrrB/gCLZmAZdqysXfvXrn//vtbrdfnP/zwQ0B+3nqp7sUXXzT3g58xY4b06tVLtm/fLsnJyVe0/+7du2XQoEGmJabJAw88IPX19eaz8EL5dRu9nNlyMnrd5ujRo3Lo0KGgL7tuc/E5q9uUlpbK+fPnr7p+btWxpT/++MO0yCYlJUlxcbG5/O+lc+vnn3+WESNGmBbUlStXSqdO/JQjMHX2dwEArzl58qS5RNa7d+9W6/X58ePHJVD8/fff8sknn5gBE7/88ou5nK/9SB988EEJCwvr0HtpvS6ub8+ePc37+KrObpdfHxMTE1tt07SPvqb9b4O57G29jz6/cOGCOadvvPHGoDi/KisrzaXnSZMmyTvvvCMhISEd+rcC/dzSQKrlyMvLM+EXCGSETMBHLv5x0078V/OD5yva7ys/P9+0+Bw4cEDi4uKu6f3aqpsv6+yP8rd1TNvbNxjLbqt+/qrj2bNnJTU1VaZPn24C5tUK1OOjfbrHjh0rr7/+umRnZ19TmQA30MYOWKajR0NDQy9pYTlx4sQlLRr+9NRTT5kfKy3nwIED5YknnpBt27ZJY2Njh9+rT58+l9RXB0foZVZf1dnt8re1jR5T1dE6BmLZ29umc+fO5hJxR/nj/NLLzRrCvvrqK3PJ/GoF4vFRN9xwg6SkpJjBQzpYCAh0hEzAMr0MptPAbN26tdV6fa5TnQQK7SOmo9/18uI333xjfqAffvhhSUhIkNzcXHOZ8Erdfffdpp/YsWPHmtdt2bLFvKd+Fl4ov25TUlLSauoZ3UbLcfGlzmAsu25z8Tmr29x5553SpUuXDtXPH3VU2jfx448/NutGjx5t+jRejUA8PkqnN9q0aZPpY6p9Nmtra6+qfoBrfDKcCPiPW7dundOlSxfngw8+cH799VcnKyvLiYiIcA4dOuQEMh2FqyNfx40b54SGhjo//fSTWX/48GFn3759Tn5+vnPdddeZv+tSW1trXr9w4YIzaNAgZ8yYMU5ZWZnz7bffOn379nWef/55z5T/1KlTTu/evZ3p06c7FRUVTnFxsRMVFeUUFhZ6ouw6Wrl79+5Odna2OWf13NVz+LPPPrNSP1/XseXobh0JPmXKFGfAgAHOsWPHPHF8Wo4u1/dOTU11RowY0fzvAIGIkAn4yLvvvuskJCQ4YWFhzh133OHs3LkzqD5rnXKlaYqVzMxM7SB2ybJ9+/bm7fXHNj093enWrZsTExNjfkRbTsnihfJrsBg5cqSZfqZPnz7OokWLrExfFChl37Fjh3P77bebczYxMdFZuXKl9br5qo4XTyGkQXPy5MnOLbfc4vz1118BXfYrOT4XT2Gk4XL48OFmn7q6Oqv1A2wJ0T/cazcFAADAfwF9MgEAAGAdIRMAAADWETIBAABgHSETAAAA1hEyAQAAYB0hEwAAANYRMgEAAGAdIRMAAACETAAAAAQ+WjIBAABgHSETAAAA1hEyAQAAILb9DxdfLnv0WwZpAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "lead_time_window = np.timedelta64(1, \"h\") * np.arange(69, 87, 2)\n", + "n_lead_times = len(lead_time_window)\n", + "\n", + "fig, ax = plt.subplots(\n", + " nrows=n_lead_times,\n", + " ncols=1,\n", + " figsize=(4, 1.2 * n_lead_times),\n", + " sharex=True,\n", + " sharey=True,\n", + ")\n", + "ax = ax.flatten()\n", + "log_histogram_bins = np.arange(7)\n", + "\n", + "for j, lead_time in enumerate(lead_time_window):\n", + " imp_fct_all_mem_1lt = impact_forecast.select(lead_time=lead_time)\n", + " imp_per_member = imp_fct_all_mem_1lt.imp_mat.sum(axis=1)\n", + " ax[j].hist(np.log10(imp_per_member + 1), bins=log_histogram_bins, alpha=1)\n", + " ax[j].set_yticks([4, 8, 12, 16])\n", + " ax[j].text(\n", + " 0.98,\n", + " 0.90,\n", + " f\"lead time: {lead_time.astype('timedelta64[h]')}\",\n", + " ha=\"right\",\n", + " va=\"top\",\n", + " transform=ax[j].transAxes,\n", + " )\n", + "\n", + "ax[-1].set_xlabel(\"\")\n", + "\n", + "bin_centers = 0.5 * (log_histogram_bins[:-1] + log_histogram_bins[1:])\n", + "ax[-1].set_xticks(bin_centers)\n", + "ax[-1].set_xticklabels([\"0\", \"<10\", \"<100\", \"<1000\", \"<10k\", \"<100k\"])\n", + "\n", + "plt.suptitle(\n", + " \"Ensemble distribution of predicted affected population over CH per lead time\"\n", + ")\n", + "plt.tight_layout()\n", + "plt.subplots_adjust(hspace=0)" + ] + }, + { + "cell_type": "markdown", + "id": "04610114", + "metadata": {}, + "source": [ + "Attributes of an `ImpactForecast` object that do not make sense if impacts correspond to different ensemble members and lead times (instead of impacts of different events in a probabilistic event set as usual in `Impact` objects) are filled with NaNs." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "c5add4ea", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "average annual imact: nan\n", + "average annual impact per centroid: [nan nan nan ... nan nan nan]\n", + "2026-06-08 14:00:32,579 - climada.engine.impact_forecast - ERROR - calc_freq_curve is not defined for ImpactForecast\n", + "calc_freq_curve is not defined for ImpactForecast\n" + ] + } + ], + "source": [ + "print(\"average annual imact: \", impact_forecast.aai_agg)\n", + "print(\"average annual impact per centroid: \", impact_forecast.eai_exp)\n", + "try:\n", + " impact_forecast.calc_freq_curve()\n", + "except NotImplementedError as e:\n", + " print(e)" + ] + }, + { + "cell_type": "markdown", + "id": "7d1d2673", + "metadata": {}, + "source": [ + "`ImpactForecast` objects can be written to and read from hdf5 files:" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "9f5abbba", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-06-08 14:00:32,604 - climada.engine.impact_forecast - INFO - at_event gives the total impact for one specific combination of member and lead_time.\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# write hazard forecast object to h5 file\n", + "with TemporaryDirectory() as tmpdir:\n", + " impact_forecast.write_hdf5(Path(tmpdir) / \"demo_impact_forecast.h5\")\n", + "\n", + " # read hazard forecast from h5 file\n", + " imp_fct = ImpactForecast.from_hdf5(Path(tmpdir) / \"demo_impact_forecast.h5\")\n", + "\n", + "np.array_equal(impact_forecast.imp_mat.toarray(), imp_fct.imp_mat.toarray())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "climada_env_3.12", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/doc/user-guide/climada_measure_config.ipynb b/doc/user-guide/climada_measure_config.ipynb index 8fa4739bac..457d47e6e5 100644 --- a/doc/user-guide/climada_measure_config.ipynb +++ b/doc/user-guide/climada_measure_config.ipynb @@ -21,7 +21,8 @@ "\n", "The caveat of defining measure effects as python functions is that it cannot be serialized (written to a file), and also makes reading from a file a challenge.\n", "\n", - "In order to retain close that gap, the `measure` module now ships `MeasureConfig` objects, which handle the reading, writing and \"declarative\" defining of `Measure` objects.\n", + "In order to close that gap, the `measure` module now ships `MeasureConfig` objects which can be read from and written to files, and which enable \"declarative\" defining of `Measure` objects.\n", + "As such `MeasureConfig` objects re-implement and improve the workflow from the old `Measure` objects and handle the translation to the new `Measure` objects:\n", "\n", "`Measure` objects can be instantiated from `MeasureConfig` objects using `Measure.from_config()`.\n", "\n", @@ -30,7 +31,7 @@ "| `Measure` | `MeasureConfig` |\n", "|-----------|--------------------|\n", "| Is used for the actual computation | Is transformed into a `Measure` for actual computation |\n", - "| Uses python function to define what change to apply to the `Exposures`, `ImpactFuncSet`, `Hazard` objects | Define the changes (functions) to apply via the former way (scaling/shifting effect, alternate file loading, etc.) |\n", + "| Uses python functions to define what change to apply to the `Exposures`, `ImpactFuncSet`, `Hazard` objects | Defines the changes to apply using the (former) declarative way (scaling/shifting effect, alternate file loading, etc.) |\n", "| Accepts any possible effect as long as it can be defined as a python function | Is restricted to a set of defined effects |\n", "| Cannot be written to a file (unless it was created by a `MeasureConfig`) | Can easily be read from/written to a file (`.xlsx` or `.yaml`) |" ] @@ -50,7 +51,7 @@ "- `ExposuresModifierConfig`: Modifies exposure data (e.g., reassigning IDs or zeroing regions).\n", "- `CostIncomeConfig`: Handles the financial aspects, including initial costs and recurring income.\n", "\n", - "Note that everything can be defined and accessed directly from the `MeasureConfig` container, the underlying ones are there to keep things organized.\n", + "Note that all effects of a `MeasureConfig` can be directly defined from the `MeasureConfig` container (with `from_dict()`, the underlying ones are there to keep things organized.\n", "\n", "In the following we present each of these subclasses and the possibilities they offer." ] @@ -81,14 +82,14 @@ "| **Hazard** | `haz_int_mult` | `float` | Multiplier for hazard intensity (default: 1.0). |\n", "| | `haz_int_add` | `float` | Additive offset for hazard intensity (default: 0.0). |\n", "| | `new_hazard_path` | | Path to an HDF5 file to replace the current hazard. |\n", - "| | `impact_rp_cutoff` | `float` | Return period (years) threshold; events below this are ignored. |\n", + "| | `impact_rp_cutoff` | `float` | Return period (years) threshold; events with impacts below this threshold are ignored. |\n", "| **Impact Function**| `impf_ids` | `list` | Specific impact function IDs to modify (None = all). |\n", "| | `impf_mdd_mult` / `_add` | `float` | Scale or shift the Mean Damage Degree curve. |\n", "| | `impf_paa_mult` / `_add` | `float` | Scale or shift the Percentage of Assets Affected curve. |\n", "| | `impf_int_mult` / `_add` | `float` | Scale or shift the intensity axis of the function. |\n", "| | `new_impfset_path` | | Path to an Excel file to replace the impact function set. |\n", "| **Exposures** | `reassign_impf_id` | `dict` | Mapping `{haz_type: {old_id: new_id}}` for reclassification. |\n", - "| | `set_to_zero` | `list` | List of Region IDs where exposure value is set to 0. |\n", + "| | `set_to_zero` | `list` | List of exposures IDs where exposure value is set to 0. |\n", "| | `new_exposures_path` | | Path to an HDF5 file to replace the current exposures. |\n", "| **Cost & Income** | `init_cost` | `float` | One-time investment cost (absolute value). |\n", "| | `periodic_cost` | `float` | Recurring maintenance/operational costs. |\n", @@ -154,6 +155,18 @@ "print(meas_config)" ] }, + { + "cell_type": "markdown", + "id": "37a913e2-6517-45ee-b011-58de8d740d77", + "metadata": {}, + "source": [ + "```{note}\n", + "The string representation of a `MeasureConfig` object filters out the default values to avoid clutter.\n", + "\n", + "You can see all fields using `MeasureConfig.to_dict(omit_default=False)`\n", + "```" + ] + }, { "cell_type": "markdown", "id": "ac98393f-575f-4580-ac4a-dae578638916", @@ -163,7 +176,7 @@ "\n", "The `ImpfsetModifierConfig` is used to define how an adaptation measure changes the vulnerability (refer to the [impact functions tutorial](impact-functions-tutorial)).\n", "\n", - "When \"translated\" to a `Measure` object the `ImpfsetModifierConfig` populates the `impfset_change` attribute with a function that takes an `ImpactFuncSet` and returns a modified one, according to the specifications.\n", + "When \"translated\" to a `Measure` object, the `ImpfsetModifierConfig` populates the `impfset_change` attribute with a function that takes an `ImpactFuncSet` and returns a modified one, according to the specifications.\n", "\n", "```{note}\n", "Modifications are always applied to a specific hazard type (`haz_type` parameter).\n", @@ -218,12 +231,12 @@ "\n", "# 1. Scaling existing Impact Functions\n", "# Let's say we want to simulate a 20% reduction in MDD\n", - "# and a slight shift in the intensity threshold for Hazard 'TC'.\n", + "# and a horziontal translation of the impact function for Hazard 'TC'.\n", "impf_mod_scaling = ImpfsetModifierConfig(\n", " haz_type=\"TC\",\n", " impf_ids=[1, 2], # Apply only to specific function IDs\n", " impf_mdd_mult=0.8, # Reduce Mean Damage Degree by 20%\n", - " impf_int_add=5.0, # Shift intensity axis by 5 units (e.g., higher resistance)\n", + " impf_int_add=5.0, # Shift intensity array by 5 units, i.e. move impact function by 5 units to the right (e.g., higher resistance)\n", ")\n", "\n", "print(\"--- Scaling Config ---\")\n", @@ -248,7 +261,7 @@ "\n", "The `HazardModifierConfig` is used to define how an adaptation measure changes the hazard (refer to the [hazard tutorial](hazard-tutorial)).\n", "\n", - "When \"translated\" to a `Measure` object the `HazardModifierConfig` populates the `hazard_change` attribute with a function that takes a `Hazard` (possibly additional arguments, see below) and returns a modified one, according to the specifications.\n", + "When \"translated\" to a `Measure` object, the `HazardModifierConfig` populates the `hazard_change` attribute with a function that takes a `Hazard` (possibly additional arguments, see below) and returns a modified one, according to the specifications.\n", "\n", "```{note}\n", "Modifications are always applied to a specific hazard type (`haz_type` parameter).\n", @@ -268,12 +281,15 @@ "\n", "In that case the function changing the hazard (`Measure.hazard_change`) will be a function with the following signature:\n", "\n", - " f(hazard: Hazard, # The hazard to apply on\n", - " exposures: Exposures, # The exposure for the impact computation\n", - " impfset: ImpactFuncSet, # The impfset for the impact computation\n", - " base_hazard: Hazard, # The hazard for the impact computation\n", - " exposures_region_id: Optional[list[int]] = None, # Region id to filter to\n", - " ) -> Hazard\n", + " def hazard_change(\n", + " hazard: Hazard, # Hazard to apply change to\n", + " base_exposures: Exposures, # Exposure to use for impact computation\n", + " base_impfset: ImpactFuncSet, # Impfset to use for impact computation\n", + " base_hazard: Hazard, # Hazard to use for impact computation\n", + " exposures_region_id: Optional[list[int]] = None, # Exposures id to restrict the effect to\n", + " ) -> Hazard\n", + "\n", + "The base_<> triplet is provided by default when the measure is applied so you are not required to supply them if they should indeed be the base triplet before the measure is applied.\n", "```\n", "\n", "```{warning}\n", @@ -359,7 +375,7 @@ "\n", "The `ExposuresModifierConfig` is used to define how an adaptation measure changes the exposure (refer to the [exposure tutorial](exposure-tutorial)).\n", "\n", - "When \"translated\" to a `Measure` object the `ExposuresModifierConfig` populates the `exposures_change` attribute with a function that takes an `Exposures` and returns a modified one, according to the specifications.\n", + "When \"translated\" to a `Measure` object, the `ExposuresModifierConfig` populates the `exposures_change` attribute with a function that takes an `Exposures` and returns a modified one, according to the specifications.\n", "\n", "`ExposuresModifierConfig` allows you to modify the impact function assigned to different hazard, to set a list of points to 0 value, or to load a different Exposures:\n", "\n", @@ -402,7 +418,9 @@ "\n", "# 1. Changing existing Exposures\n", "exp_mod = ExposuresModifierConfig(\n", - " reassign_impf_id={\"TC\": {1: 2}}, # Remaps exposures points with impf_TC == 1 to 2.\n", + " reassign_impf_id={\n", + " \"TC\": {1: 2}\n", + " }, # Reassigns exposures points with impact function id impf_TC == 1 to 2.\n", " set_to_zero=[\n", " 0,\n", " 25,\n", @@ -427,7 +445,7 @@ "source": [ "## Defining the financial aspects of the measure\n", "\n", - "For in depth description of CostIncome objects, refer to the [related tutorial](cost-income-tutorial).\n", + "For in depth description of `CostIncome` objects, refer to the [related tutorial](cost-income-tutorial).\n", "\n", "```{note}\n", "The default for mkt_price_year if not provided is the current year.\n", @@ -460,7 +478,7 @@ "--- Custom Schedule Config ---\n", "CostIncomeConfig(\n", "\t\tNon default fields:\n", - "\t\t\tcustom_cash_flows=[{'date': '2024-01-01', 'value': -1000000}, {'date': '2029-01-01', 'value': -200000}, {'date': '2034-01-01', 'value': 500000}]\n", + "\t\t\tcustom_cash_flows=[{'date': '2024-01-01', 'cost': 1000000.0, 'income': 0.0}, {'date': '2029-01-01', 'cost': 200000.0, 'income': 0.0}, {'date': '2034-01-01', 'cost': 10000.0, 'income': 500000}]\n", ")\n" ] } @@ -470,13 +488,13 @@ "\n", "# This models a measure where costs increase by 2% annually,\n", "# but it generates 100k in yearly income which grows by 3%.\n", + "# By default, the periodicity of costs and income is yearly.\n", "growth_finance = CostIncomeConfig(\n", " init_cost=500_000.0,\n", " periodic_cost=20_000.0,\n", " cost_yearly_growth_rate=0.02,\n", " periodic_income=100_000.0,\n", " income_yearly_growth_rate=0.03,\n", - " freq=\"Y\",\n", ")\n", "\n", "print(\"\\n--- Growth & Income Config ---\")\n", @@ -485,11 +503,12 @@ "\n", "# Custom Cash Flow\n", "# If the investment isn't linear (e.g., a major retrofit in year 5),\n", - "# you can define a list of specific events.\n", + "# you can define a custom cash flow, with negative values representing\n", + "# net costs and positive ones net benefits.\n", "custom_schedule = [\n", - " {\"date\": \"2024-01-01\", \"value\": -1000000}, # Initial cost\n", - " {\"date\": \"2029-01-01\", \"value\": -200000}, # Mid-term overhaul\n", - " {\"date\": \"2034-01-01\", \"value\": 500000}, # Terminal value\n", + " {\"date\": \"2024-01-01\", \"cost\": 1000000.0, \"income\": 0.0},\n", + " {\"date\": \"2029-01-01\", \"cost\": 200000.0, \"income\": 0.0},\n", + " {\"date\": \"2034-01-01\", \"cost\": 10000.0, \"income\": 500000},\n", "]\n", "\n", "custom_finance = CostIncomeConfig(custom_cash_flows=custom_schedule)\n", diff --git a/doc/user-guide/index.rst b/doc/user-guide/index.rst index 014fc43f50..bd1b264f80 100644 --- a/doc/user-guide/index.rst +++ b/doc/user-guide/index.rst @@ -22,7 +22,8 @@ You can then go on to more specific tutorial about `Hazard `_, Adaptation appraisal Local exceedance intensities Uncertainty Quantification - climada_engine_Forecast + Forecasts climada_util_calibrate climada_util_api_client + Forecast class (outdated) How to cite CLIMADA <../misc/citation> diff --git a/pyproject.toml b/pyproject.toml index 3663d15f7c..541715a104 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -7,7 +7,7 @@ name = "climada" version = "6.1.1-dev" description = "Framework for climate risk assessment and adaptation option appraisal" readme = "README.md" -requires-python = ">=3.10,<3.13" +requires-python = ">=3.10,<3.14" license = { text = "GNU General Public License v3 (GPLv3)" } authors = [ { name = "ETH", email = "climada-info@sympa.ethz.ch" } diff --git a/requirements/env_climada.yml b/requirements/env_climada.yml index a7bd23305b..f49da989e2 100644 --- a/requirements/env_climada.yml +++ b/requirements/env_climada.yml @@ -3,6 +3,7 @@ channels: - conda-forge - nodefaults dependencies: + - affine>=2.4,<3.0 # see #1311, affine 3.0 cannot read metadata from hdf5 files written by climada < 6.1 - bayesian-optimization>=1.5,<2.0 - bottleneck>=1.6 - cartopy>=0.25 @@ -16,26 +17,28 @@ dependencies: - geopandas>=1.1 - h5py>=3.13 - haversine>=2.9 - - matplotlib-base>=3.10 + - matplotlib-base>=3.10,<3.11 # see #1298, https://github.com/matplotlib/matplotlib/issues/31926 - netcdf4>=1.7 - numba>=0.62 - numexpr>=2.13 - openpyxl>=3.1 - osm-flex>=1.1 # this is only required for running the tutorials, not for the CLIMADA package itself - - pandas>=2.3,<3.0 # petals does not run with 3.0 (... and issue #1215) + # petals requires pandas < 3.0 for python >=3.11 + # petals requires pandas < 2.3 for python >=3.12 (https://github.com/IndEcol/pymrio/issues/177) + - pandas>=2.2,<2.3 - pathos>=0.3 - peewee>=3.18 - pint>=0.24 - pip - - pyarrow>=20.0 # petals cannot be installed on win-64 with pyarrow 21.0 + - pyarrow>=20.0 - pycountry>=24.6 - pyproj>=3.7 - pytables>=3.10 # this is the name of the pypi 'tables' package on conda-forge - pyxlsb>=1.0 - - rasterio>=1.4 + - rasterio>=1.4,<1.5 # 1.4 compatible with python 3.11; discrepancies between 1.4 and 1.5, see #1316 - requests>=2.32 - rtree>=1.4 - - salib>=1.5.2 # see https://github.com/CLIMADA-project/climada_python/issues/1081 + - salib>=1.5.2 - scikit-learn>=1.7 - scipy>=1.15 - seaborn>=0.13 diff --git a/script/jenkins/test_data_api.py b/script/jenkins/test_data_api.py index 59f4fa942f..5db2bfa96e 100644 --- a/script/jenkins/test_data_api.py +++ b/script/jenkins/test_data_api.py @@ -45,13 +45,6 @@ class TestDataAvail(unittest.TestCase): """Test availability of data used through APIs""" - def test_noaa_nl_pass(self): - """Test NOAA nightlights used in BlackMarble.""" - file_down = download_file( - f"{CONFIG.exposures.litpop.nightlights.noaa_url.str()}/F101992.v4.tar" - ) - Path(file_down).unlink() - def test_nasa_nl_pass(self): """Test NASA nightlights used in BlackMarble and LitPop.""" req_files = np.zeros(len(BM_FILENAMES)) From 7e344856e52e091ad09d019ba600c58e72e4b0ce Mon Sep 17 00:00:00 2001 From: spjuhel Date: Wed, 14 Oct 2026 17:34:46 +0200 Subject: [PATCH 34/44] Removes unused `implementation_duration` --- climada/entity/measures/measure.py | 22 +++++++++------------- 1 file changed, 9 insertions(+), 13 deletions(-) diff --git a/climada/entity/measures/measure.py b/climada/entity/measures/measure.py index b565d6d293..a92634cc8b 100755 --- a/climada/entity/measures/measure.py +++ b/climada/entity/measures/measure.py @@ -135,9 +135,6 @@ class Measure: It also holds a `CostIncome` object to define the financial aspects of the measure (see :class:`CostIncome` and :ref:`cost-income-tutorial`). - Finally it holds an `implementation_duration` attribute, in the form of a - pandas ``DateOffset``, which is used when the time dimension is considered. - Notes ----- @@ -168,8 +165,6 @@ class (e.g. :class:`Hazard` for ``hazard_change``). Functions can accept List of measure names that this measure is a combination of. cost_income : climada.entity.measures.cost_income.CostIncome Cost and income object associated with the measure. - implementation_duration : pd.DateOffset, optional - Duration of implementation before the measure is fully functional. """ def __init__( @@ -181,7 +176,6 @@ def __init__( hazard_changes: HazardChange = identity_function, sub_measures: Optional[list[str]] = None, cost_income: Optional[CostIncome] = None, - implementation_duration: Optional[BaseOffset] = None, color_rgb: Optional[Tuple[float, float, float]] = None, _config: Optional[MeasureConfig] = None, ): @@ -202,8 +196,6 @@ def __init__( Names of component measures. cost_income : CostIncome, optional Financial data. If None, an empty CostIncome is initialized. - implementation_duration : pd.DateOffset, optional - Time offset for full implementation. """ self.name = name @@ -212,7 +204,6 @@ def __init__( self.impfset_changes = allow_kwargs(impfset_changes) self.sub_measures = sub_measures self.cost_income = cost_income if cost_income is not None else CostIncome() - self.implementation_duration = implementation_duration self.color_rgb = (0, 0, 0) if color_rgb is None else color_rgb self._config = _config @@ -460,8 +451,8 @@ def apply( Notes ----- Keyword arguments other than "kwargs_exposures", "kwargs_impfset", - "kwargs_hazard" are ignored. - + "kwargs_hazard" are ignored. + The base exposure, hazard, and impfset provided by default can be overriden by explicitely providing a different value within ``kwargs_exposures``, ``kwargs_impfset``, or ``kwargs_hazard`` @@ -496,7 +487,11 @@ def apply( return changed_exposures, changed_impfset, changed_hazard def calc_impact( - self, exposures: Exposures, impfset: ImpactFuncSet, hazard: Hazard, **kwargs: dict, + self, + exposures: Exposures, + impfset: ImpactFuncSet, + hazard: Hazard, + **kwargs: dict, ) -> Impact: """Compute impact with the active measure. @@ -536,6 +531,7 @@ def calc_impact( ) new_exp.assign_centroids(new_haz) imp = ImpactCalc(new_exp, new_impfs, new_haz).impact( - save_mat=kwargs.get("save_mat",False), assign_centroids=kwargs.get("assign_centroids",False) + save_mat=kwargs.get("save_mat", False), + assign_centroids=kwargs.get("assign_centroids", False), ) return imp # .calc_risk_transfer(0, 0) From f9f9009e0dd558e663c0bbd5022eae388764471a Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 15 Oct 2026 10:51:55 +0200 Subject: [PATCH 35/44] Typos --- climada/entity/measures/measure.py | 29 +++++++++++++++++------------ 1 file changed, 17 insertions(+), 12 deletions(-) diff --git a/climada/entity/measures/measure.py b/climada/entity/measures/measure.py index a92634cc8b..44da505d2e 100755 --- a/climada/entity/measures/measure.py +++ b/climada/entity/measures/measure.py @@ -75,7 +75,7 @@ def allow_kwargs(func): filtered out before the call, preventing ``TypeError`` from unexpected keywords. The functions used by `Measure` objects to apply changes on ``Exposures``, ``Hazard``, - and ``ImpactFuncSet`` always receive ``base_exposure, base_hazard, base_impfset`` as + and ``ImpactFuncSet`` always receive ``base_exposures, base_hazard, base_impfset`` as keyword arguments. This decorator is applied to users-defined functions and prevent them from not accepting these kwargs and raising a ``TypeError``. @@ -139,12 +139,12 @@ class Measure: ----- The only requirement for each function is to return an object of the same - class (e.g. :class:`Hazard` for ``hazard_change``). Functions can accept + class (e.g. :class:`Hazard` for ``hazard_changes``). Functions can accept keyword arguments to enable advanced effect (depending on a year of application for instance). These arguments can be passed when the :class:`Measure` is applied (see :py:meth:`~Measure.apply`). Note that for convenience, each functions receive the by default "base" ``(Exposures, - ImpactFuncSet, Hazard)`` triplet as keyword arguments (`base_exposure`, + ImpactFuncSet, Hazard)`` triplet as keyword arguments (`base_exposures`, `base_impfset`, `base_hazard`). If the ``Measure`` was defined from a ``MeasureConfig`` object, the @@ -155,11 +155,11 @@ class (e.g. :class:`Hazard` for ``hazard_change``). Functions can accept ---------- name : str Name of the measure. - exposures_change : ExposuresChange + exposures_changes : ExposuresChange Function to change exposures. - impfset_change : ImpfsetChange + impfset_changes : ImpfsetChange Function to change impact function set. - hazard_change : HazardChange + hazard_changes : HazardChange Function to change hazard. sub_measures : list of str, optional List of measure names that this measure is a combination of. @@ -186,11 +186,11 @@ def __init__( ---------- name : str Name of the measure. - exposures_change : callable, optional + exposures_changes : callable, optional Transformation function for Exposures. Defaults to identity. - impfset_change : callable, optional + impfset_changes : callable, optional Transformation function for ImpactFuncSet. Defaults to identity. - hazard_change : callable, optional + hazard_changes : callable, optional Transformation function for Hazard. Defaults to identity. sub_measures : list of str, optional Names of component measures. @@ -453,7 +453,7 @@ def apply( Keyword arguments other than "kwargs_exposures", "kwargs_impfset", "kwargs_hazard" are ignored. - The base exposure, hazard, and impfset provided by default can + The base exposures, hazard, and impfset provided by default can be overriden by explicitely providing a different value within ``kwargs_exposures``, ``kwargs_impfset``, or ``kwargs_hazard`` respectively. @@ -491,12 +491,17 @@ def calc_impact( exposures: Exposures, impfset: ImpactFuncSet, hazard: Hazard, + ignore_cover: bool = False, + ignore_deductible: bool = False, + save_mat: bool = True, + assign_centroids: bool = False, + enforce_copy: bool = True, **kwargs: dict, ) -> Impact: """Compute impact with the active measure. This convenience method allow to compute an ``Impact`` object from an - (Exposure, ImpactFuncSet, Hazard) triplet after having applied the measure + (Exposures, ImpactFuncSet, Hazard) triplet after having applied the measure to that triplet. Parameters @@ -524,7 +529,7 @@ def calc_impact( new_exp, new_impfs, new_haz = self.apply(exposures, impfset, hazard) if new_haz.centr_exp_col not in new_exp.gdf.columns: LOGGER.warning( - "No assigned hazard centroids in exposure object after the " + "No assigned hazard centroids in exposures object after the " "application of the measure. The centroids will be assigned during impact " "calculation. This is potentiall costly. To silence this warning, make sure " "that centroids are assigned to all exposures." From eb196eb6d8ba4be7baa83e2a5d3c145d4ec4453b Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 15 Oct 2026 10:52:25 +0200 Subject: [PATCH 36/44] Fixed calc_impact (kwargs, args for `ImpactCalc.impact()`, docstring) --- climada/entity/measures/measure.py | 40 ++++++++++++++++++++++++++---- 1 file changed, 35 insertions(+), 5 deletions(-) diff --git a/climada/entity/measures/measure.py b/climada/entity/measures/measure.py index 44da505d2e..55757b23ec 100755 --- a/climada/entity/measures/measure.py +++ b/climada/entity/measures/measure.py @@ -512,9 +512,37 @@ def calc_impact( The initial (no adaptation) impact function set hazard : Hazard The initial (no adaptation) hazard set + save_mat : bool, optional + if true, save the total impact matrix (events x exposures) + Default: True + assign_centroids : bool, optional + indicates whether centroids are assigned to the self.exposures object. + The default centroids assignment uses Euclidean distance and a threshold equal to + twice the highest resolution (smallest distance between any two nearest neighbours) + of the centroids (assuming a regular grid). + Recommendation: assign the centroids directly with control + over the distance metric and the distance threshold using + `exposure.assign_centroids(hazard)`. In this case, set assign_centroids to ``False``. + Centroids assignment is an expensive operation; set this to ``False`` to save + computation time if the hazards' centroids are already assigned to the exposures + object. + Default: True + ignore_cover : bool, optional + if set to True, the column 'cover' of the exposures GeoDataFrame, if present, is + ignored and the impact it not capped by the values in this column. + Default: False + ignore_deductible : bool, opotional + if set to True, the column 'deductible' of the exposures GeoDataFrame, if present, is + ignored and the impact it not reduced through values in this column. + Default: False + enforce_copy : bool, optional + If True (default), creates deep copies of entities before applying + changes, provided the transformation functions are not identity functions. + If False, entities may be modified in-place depending on the behavior + of the underlying transformation methods. kwargs: dict - Keyword arguments passed to the `impact()` method of `ImpactCalc` - (Currently `save_mat` and `assign_centroids`) + Keyword arguments passed to the `apply()` method when + applying the measure Returns ------- @@ -526,7 +554,9 @@ def calc_impact( ImpactCalc, # pylint: disable=import-outside-toplevel ) - new_exp, new_impfs, new_haz = self.apply(exposures, impfset, hazard) + new_exp, new_impfs, new_haz = self.apply( + exposures, impfset, hazard, enforce_copy=enforce_copy, **kwargs + ) if new_haz.centr_exp_col not in new_exp.gdf.columns: LOGGER.warning( "No assigned hazard centroids in exposures object after the " @@ -536,7 +566,7 @@ def calc_impact( ) new_exp.assign_centroids(new_haz) imp = ImpactCalc(new_exp, new_impfs, new_haz).impact( - save_mat=kwargs.get("save_mat", False), - assign_centroids=kwargs.get("assign_centroids", False), + save_mat=save_mat, + assign_centroids=assign_centroids, ) return imp # .calc_risk_transfer(0, 0) From b8492fe289330788daa4ead5176104068de7fe1b Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 15 Oct 2026 10:54:42 +0200 Subject: [PATCH 37/44] url typo --- doc/user-guide/climada_measure_config.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/user-guide/climada_measure_config.ipynb b/doc/user-guide/climada_measure_config.ipynb index 457d47e6e5..ebbeb6df79 100644 --- a/doc/user-guide/climada_measure_config.ipynb +++ b/doc/user-guide/climada_measure_config.ipynb @@ -17,7 +17,7 @@ "source": [ "## Introduction\n", "\n", - "CLIMADA uses `Measure` objects to model the effects of adaptation measures. `Measure` objects were formerly defined declaratively (via for instance, a shifting or scaling of the hazard intensity or a change of impact function), and are now defined as python functions to enable more flexibility on the possible changes (see the [tutorial on measure objects](measure-tutorial)'). \n", + "CLIMADA uses `Measure` objects to model the effects of adaptation measures. `Measure` objects were formerly defined declaratively (via for instance, a shifting or scaling of the hazard intensity or a change of impact function), and are now defined as python functions to enable more flexibility on the possible changes (see the [tutorial on measure objects](measure-tutorial)).\n", "\n", "The caveat of defining measure effects as python functions is that it cannot be serialized (written to a file), and also makes reading from a file a challenge.\n", "\n", From 6f450c6d16fb6d5020464689217bfa5a343654d7 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 15 Oct 2026 10:55:21 +0200 Subject: [PATCH 38/44] Tutorial update, advanced examples --- doc/user-guide/climada_measures.ipynb | 253 ++++++++++++++++++++++---- 1 file changed, 221 insertions(+), 32 deletions(-) diff --git a/doc/user-guide/climada_measures.ipynb b/doc/user-guide/climada_measures.ipynb index b8a0ae1090..8d2c9a7ba3 100644 --- a/doc/user-guide/climada_measures.ipynb +++ b/doc/user-guide/climada_measures.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "cadaa7ff-dc17-4898-b781-35f92d2583e6", + "id": "adc83a35", "metadata": {}, "source": [ "(measure-tutorial)=\n", @@ -12,7 +12,7 @@ }, { "cell_type": "markdown", - "id": "c9170963-353e-4332-a8be-74ffbe78aa57", + "id": "3dca8f82", "metadata": {}, "source": [ "The `Measure` object is the core component of the **Adaptation** module in CLIMADA. It acts as a wrapper for transformation logic, allowing you to model how specific interventions alter the risk landscape (like building sea walls, retrofitting houses, or implementing early warning systems).\n", @@ -22,7 +22,7 @@ }, { "cell_type": "markdown", - "id": "f8f9dc2c-81dd-409d-ab02-9be8b8a052c4", + "id": "f51842c7", "metadata": {}, "source": [ "## Quickstart" @@ -30,8 +30,8 @@ }, { "cell_type": "code", - "execution_count": 1, - "id": "0685d8fb-68b6-4a65-a0b4-860e68a46c7d", + "execution_count": null, + "id": "2c48b021", "metadata": {}, "outputs": [], "source": [ @@ -42,7 +42,7 @@ "# Define one or more transformation function\n", "# It must take an Exposures, Hazard or ImpactFuncSEt as the first argument\n", "# and return an object of the same type.\n", - "def reduce_exposure_value(exposures, reduction_factor=0.2):\n", + "def reduce_exposure_value_at_risk(exposures, reduction_factor=0.2):\n", " \"\"\"Reduces the value of all assets by a fixed percentage.\"\"\"\n", " exposures.gdf[\"value\"] *= 1 - reduction_factor\n", " return exposures\n", @@ -61,30 +61,31 @@ "# Initialize the Measure object\n", "retrofitting_and_seawall = Measure(\n", " name=\"Building Retrofit and seawall construction\",\n", - " exposures_changes=reduce_exposure_value,\n", + " exposures_changes=reduce_exposure_value_at_risk,\n", " hazard_changes=sea_wall_protection,\n", " cost_income=cost_income,\n", ")" ] }, { - "attachments": {}, "cell_type": "markdown", - "id": "66e0629f-da41-42e9-b3d5-02458c88d693", + "id": "02cd2812", "metadata": {}, "source": [ - "The measure can then be used to create a new triplet corresponding to the modifications or to compute the impact directly:\n", + "The measure can then be used either to create a new triplet corresponding to the situation with measure in effect\n", + "or to compute the impact directly (both lines are independant):\n", "\n", "```python\n", - "new_exp, new_impf, new_haz = retrofitting.apply(exp, impf, haz, kwargs_hazard={'threshold': 3.5})\n", - "impact_with_measure = measure.calc_impact(exp, impf, haz)\n", + "new_exp, new_impf, new_haz = retrofitting_and_seawall.apply(exp, impf, haz, kwargs_hazard={'threshold': 3.5})\n", "\n", + "# or directly:\n", + "impact_with_measure = retrofitting_and_seawall.calc_impact(exp, impf, haz, kwargs_hazard={'threshold': 3.5})\n", "```" ] }, { "cell_type": "markdown", - "id": "56bbbcd2-f92f-4697-8631-18b9a311d4da", + "id": "6f4650c6", "metadata": {}, "source": [ "## Core logic of the Measure object\n", @@ -96,14 +97,13 @@ "3. **`hazard_changes`**: Modifies the `Hazard` object, the intensity or frequency of events (e.g., a dam reducing flood depths).\n", "\n", "```{note}\n", - "By default, any component not explicitly defined uses the `identity_function`, which simply returns the input object without modification.\n", + "By default, changes are the `identity_function`, so if you do not provide a function e.g., \"exposures_changes\" the measure once applied will return the exposure unchanged.\n", "```\n", "\n", - "The **only** requirement for these python functions is to **take** and **return** an `Exposures` object (or `ImpactFuncSet` or `Hazard`), which enable advanced modeling.\n", + "The **only** requirement for these python functions is to **take** and **return** an `Exposures` object (or `ImpactFuncSet` or `Hazard` objects respectively). This enables high modeling flexibility where changes from an adaptation option can be modelled from a simple \"loading another file for the hazard or exposure\", to an advanced function.\n", "\n", - "Notably, the `apply()` method always passes the entire triplet (`base_exposures`, `base_impfset`, `base_hazard`) to every transformation function, so you can write complex logic.\n", + "One thing to note, is that the `apply()` method of a measure always passes the entire triplet (`base_exposures`, `base_impfset`, `base_hazard`, i.e., the risk triplet before the measure is applied) to every transformation function. This means you can easily write complex logic that relie on any of these component. For example:\n", "\n", - "For example:\n", "> \"Only reduce the exposure value (Exposure change) in areas where the peak water depth (Hazard context) exceeds 2 meters.\"\n", "\n", "Could be defined like this:" @@ -112,7 +112,7 @@ { "cell_type": "code", "execution_count": null, - "id": "63b37e27-f4d1-4a0c-8a45-f923aea903e2", + "id": "7cd53344", "metadata": {}, "outputs": [], "source": [ @@ -149,7 +149,7 @@ }, { "cell_type": "markdown", - "id": "d069e22e-1c31-44ef-a3db-62d3269f3900", + "id": "10a5ad67", "metadata": {}, "source": [ "```python\n", @@ -163,14 +163,18 @@ "# When you call apply, the `Hazard` haz is automatically passed to the function\n", "# as 'base_hazard'\n", "new_exp, _, _ = flood_protection.apply(\n", - " exp, impf, haz, \n", + " exp, impf, haz,\n", " kwargs_exposures={'reduction_factor': 0.5, 'threshold': 2.0}\n", ")\n", "\n", - "# You can also overide this with another \"base\" hazard in the \n", - "# `kwarg_exposures` if you want:\n", + "# You can also overide this with another \"base\" hazard in the\n", + "# `kwarg_exposures` if you want.\n", + "#\n", + "# This could be for instance if the flood protection is\n", + "# now defined not for the full probabilistic hazard set\n", + "# but for a specific event, or a subset.\n", "new_exp, _, _ = flood_protection.apply(\n", - " exp, impf, haz, \n", + " exp, impf, haz,\n", " kwargs_exposures={'base_hazard'= other_hazard,\n", " 'reduction_factor': 0.5, 'threshold': 2.0}\n", ")\n", @@ -179,7 +183,7 @@ }, { "cell_type": "markdown", - "id": "ebf8620a-181d-4f3c-989f-e4373380032b", + "id": "8baaf95c", "metadata": {}, "source": [ "```{note}\n", @@ -193,18 +197,18 @@ }, { "cell_type": "markdown", - "id": "fb888e10-5a94-4251-88be-5d92dfee2e0a", + "id": "a984d0a7", "metadata": {}, "source": [ "### Deep copies\n", "\n", - "To prevent accidental \"in-place\" modification of your baseline data, `Measure` utilizes `copy.deepcopy()`. \n", + "To prevent accidental \"in-place\" modification of your baseline data, `Measure` utilizes `copy.deepcopy()`.\n", "If `enforce_copy=True` in `apply()` (the default case), the object is cloned before the transformation function runs, ensuring the original objects remains untouched." ] }, { "cell_type": "markdown", - "id": "80c13c5a-0048-4b80-bd35-9faffae52cae", + "id": "6d58543f", "metadata": {}, "source": [ "### Measure cash flow (`CostIncome`)\n", @@ -220,7 +224,7 @@ }, { "cell_type": "markdown", - "id": "26b926d2-1f27-416d-925c-53bfaa0cee27", + "id": "b5c1873f", "metadata": {}, "source": [ "## Defining Measure using measure configuration" @@ -228,19 +232,204 @@ }, { "cell_type": "markdown", - "id": "99bb6869-30f0-49b5-9c56-8664fd85318a", + "id": "9a13d39e", + "metadata": {}, + "source": [ + "Defining adaptation measures with python functions can be a bit difficult if you are not too familiar with python.\n", + "In that case you can use `MeasureConfig` objects ([tutorial here](measure-config-tutorial))" + ] + }, + { + "cell_type": "markdown", + "id": "824e1dd3", + "metadata": {}, + "source": [ + "## Advanced examples of measures" + ] + }, + { + "cell_type": "markdown", + "id": "f1a15910-6de8-416f-982f-dd0e53fc13cf", "metadata": {}, "source": [ - "Defining adaptation measures with python functions can be a bit \\" + "Measures are often modelled as a fixed change. In practice, the effect of an adaptation action often depends on **when** it is evaluated (for instance, a relocation programme that is phased in over several years) or on **additional parameters** (regions targeted, share of value removed, protection threshold).\n", + "\n", + "The examples below illustrate three patterns:\n", + "\n", + "1. **Exposures**: a linear phase-in of asset relocation (`year`, `start_year`, `full_year`, `fraction`, `regions`).\n", + "2. **Impact functions**: a year-dependent reduction of the mean damage ratio.\n", + "3. **Hazard**: a step-function protection standard that needs the baseline impacts, and therefore the `base_*` triplet." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7e17dfb9-b760-48df-8878-be1d547290a3", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "\n", + "def phase_in(year, start_year, full_year):\n", + " \"\"\"Linear effectiveness ramp. (Helper function)\n", + "\n", + " Parameters\n", + " ----------\n", + " year : int\n", + " Year at which the measure is evaluated.\n", + " start_year : int\n", + " Year at which the measure starts having an effect.\n", + " full_year : int\n", + " Year at which the measure is fully effective.\n", + "\n", + " Returns\n", + " -------\n", + " float\n", + " Effectiveness in [0, 1].\n", + " \"\"\"\n", + " return float(np.clip((year - start_year) / (full_year - start_year), 0, 1))\n", + "\n", + "\n", + "def relocate_assets(exposures, *, year, start_year, full_year, fraction, regions):\n", + " \"\"\"Progressively remove asset value from exposed regions.\n", + "\n", + " Parameters\n", + " ----------\n", + " exposures : climada.entity.exposures.base.Exposures\n", + " Exposures to modify (already a copy if ``enforce_copy=True``).\n", + " year : int\n", + " Evaluation year.\n", + " start_year, full_year : int\n", + " Start and end of the linear phase-in.\n", + " fraction : float\n", + " Share of value removed once the measure is fully implemented.\n", + " regions : list of int\n", + " ``region_id`` values targeted by the measure.\n", + "\n", + " Returns\n", + " -------\n", + " climada.entity.exposures.base.Exposures\n", + " Exposures with reduced value in the targeted regions.\n", + " \"\"\"\n", + " ramp = phase_in(year, start_year, full_year)\n", + " mask = exposures.gdf[\"region_id\"].isin(regions)\n", + " exposures.gdf.loc[mask, \"value\"] *= 1 - fraction * ramp\n", + " return exposures\n", + "\n", + "\n", + "def flood_proofing(\n", + " impfset, *, year, start_year, full_year, reduction, haz_type=\"FL\", impf_id=1\n", + "):\n", + " \"\"\"Scale down the mean damage ratio of one impact function.\n", + "\n", + " Parameters\n", + " ----------\n", + " impfset : climada.entity.impact_funcs.impact_func_set.ImpactFuncSet\n", + " Impact function set to modify.\n", + " year : int\n", + " Evaluation year.\n", + " start_year, full_year : int\n", + " Start and end of the linear phase-in.\n", + " reduction : float\n", + " Relative MDD reduction once fully effective.\n", + " haz_type : str, optional\n", + " Hazard type of the targeted function.\n", + " impf_id : int, optional\n", + " Id of the targeted function.\n", + "\n", + " Returns\n", + " -------\n", + " climada.entity.impact_funcs.impact_func_set.ImpactFuncSet\n", + " Impact function set with the modified function.\n", + " \"\"\"\n", + " ramp = phase_in(year, start_year, full_year)\n", + " impf = impfset.get_func(haz_type=haz_type, fun_id=impf_id)\n", + " impf.mdd = impf.mdd * (1 - reduction * ramp)\n", + " return impfset\n", + "\n", + "\n", + "def protection_standard(\n", + " hazard, *, year, start_year, threshold, base_exposures, base_impfset, base_hazard\n", + "):\n", + " \"\"\"Remove events whose baseline impact is below a protection threshold.\n", + "\n", + " Parameters\n", + " ----------\n", + " hazard : climada.hazard.base.Hazard\n", + " Hazard to modify.\n", + " year : int\n", + " Evaluation year.\n", + " start_year : int\n", + " Year the protection is in place (no effect before).\n", + " threshold : float\n", + " Events with baseline total impact below this value are removed.\n", + " base_exposures, base_impfset, base_hazard\n", + " Unmodified triplet, provided by ``Measure.apply``.\n", + "\n", + " Returns\n", + " -------\n", + " climada.hazard.base.Hazard\n", + " Hazard without the protected events. Frequencies of the remaining\n", + " events are left unchanged.\n", + " \"\"\"\n", + " from climada.engine.impact_calc import ImpactCalc\n", + "\n", + " if year < start_year:\n", + " return hazard\n", + " imp = ImpactCalc(base_exposures, base_impfset, base_hazard).impact(\n", + " assign_centroids=False\n", + " )\n", + " return hazard.select(event_id=imp.event_id[imp.at_event >= threshold])" + ] + }, + { + "cell_type": "markdown", + "id": "937ded7c-05be-4708-ad08-8d366e287406", + "metadata": {}, + "source": [ + "The parameters can then be provided when the measure is applied, or the impact is computed:" ] }, { "cell_type": "code", "execution_count": null, - "id": "01f29057-fc12-4787-92be-e4c506a054d1", + "id": "fabfd29c-0b5e-442a-912f-3cbfac45f78d", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "from climada.entity.measures.measure import Measure\n", + "\n", + "meas_relocation = Measure(\n", + " \"relocation\",\n", + " exposures_changes=relocate_assets,\n", + ")\n", + "\n", + "meas_relocation_and_standard = Measure(\n", + " \"relocation_and_standard\",\n", + " exposures_changes=relocate_assets,\n", + " hazard_changes=protection_standard,\n", + ")\n", + "\n", + "exp_relocated, _, _ = meas_relocation.apply(\n", + " exp,\n", + " impfset,\n", + " haz,\n", + " kwargs_exposures=dict(\n", + " year=2030, start_year=2025, full_year=2045, fraction=0.3, regions=[1, 2]\n", + " ),\n", + ")\n", + "\n", + "imp_with_relocation_and_standards = meas_relocation_and_standard.calc_impact(\n", + " exp,\n", + " impfset,\n", + " haz,\n", + " kwargs_exposures=dict(\n", + " year=2030, start_year=2025, full_year=2045, fraction=0.3, regions=[1, 2]\n", + " ),\n", + " kwargs_hazard=dict(year=2030, start_year=2025, full_year=2045, threshold=100000),\n", + ")" + ] } ], "metadata": { From 48c6c434d05fe5c11532694f2e5eab0404f0e594 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 15 Oct 2026 11:01:44 +0200 Subject: [PATCH 39/44] Removes deprecated test --- climada/entity/measures/test/test_measure.py | 7 ------- 1 file changed, 7 deletions(-) diff --git a/climada/entity/measures/test/test_measure.py b/climada/entity/measures/test/test_measure.py index 2e5c20c288..828739debf 100644 --- a/climada/entity/measures/test/test_measure.py +++ b/climada/entity/measures/test/test_measure.py @@ -105,13 +105,6 @@ def test_sub_measures_stored(self): m = Measure("combo", sub_measures=["a", "b"]) assert m.sub_measures == ["a", "b"] - def test_implementation_duration_stored(self): - from pandas.tseries.offsets import DateOffset - - offset = DateOffset(years=2) - m = Measure("test", implementation_duration=offset) - assert m.implementation_duration == offset - def test_change_functions_wrapped_with_allow_kwargs(self): def my_fn(obj): return obj From 1951f62c8096bb560d7dce6d3607768f5060e4c5 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 15 Oct 2026 11:38:34 +0200 Subject: [PATCH 40/44] Removes implementation duration from MeasureConfig --- climada/entity/measures/measure_config.py | 7 ------- 1 file changed, 7 deletions(-) diff --git a/climada/entity/measures/measure_config.py b/climada/entity/measures/measure_config.py index 3342a808e0..f91583a039 100644 --- a/climada/entity/measures/measure_config.py +++ b/climada/entity/measures/measure_config.py @@ -465,10 +465,6 @@ class MeasureConfig(ModifierConfig): Configuration describing modifications to the exposures. cost_income : CostIncomeConfig Financial parameters associated with implementing this measure. - implementation_duration : str, optional - Pandas period alias (e.g. ``"2Y"``) representing the time before - the measure is fully operational. If ``None``, the measure takes - effect immediately. color_rgb : tuple of float, optional RGB colour triple in the range ``[0, 1]`` used for visualisation. If ``None``, defaults to black ``(0, 0, 0)``. @@ -480,7 +476,6 @@ class MeasureConfig(ModifierConfig): hazard_modifier: HazardModifierConfig exposures_modifier: ExposuresModifierConfig cost_income: CostIncomeConfig - implementation_duration: Optional[str] = None color_rgb: Optional[Tuple[float, float, float]] = None def __repr__(self) -> str: @@ -521,7 +516,6 @@ def to_dict(self, omit_default: bool = True) -> dict: **self.hazard_modifier.to_dict(omit_default), **self.exposures_modifier.to_dict(omit_default), **self.cost_income.to_dict(omit_default), - "implementation_duration": self.implementation_duration, "color_rgb": list(self.color_rgb) if self.color_rgb is not None else None, } @@ -554,7 +548,6 @@ def from_dict(cls, kwargs_dict: dict) -> "MeasureConfig": hazard_modifier=HazardModifierConfig.from_dict(kwargs_dict), exposures_modifier=ExposuresModifierConfig.from_dict(kwargs_dict), cost_income=CostIncomeConfig.from_dict(kwargs_dict), - implementation_duration=kwargs_dict.get("implementation_duration"), color_rgb=cls._normalize_color(kwargs_dict.get("color_rgb")), ) From c011051a0e8c8ad5eebdc10e0bcc2d4eee6e6ad2 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 15 Oct 2026 11:39:28 +0200 Subject: [PATCH 41/44] updates typehinting --- climada/entity/measures/measure_config.py | 33 ++++++++++++----------- 1 file changed, 18 insertions(+), 15 deletions(-) diff --git a/climada/entity/measures/measure_config.py b/climada/entity/measures/measure_config.py index f91583a039..e193106152 100644 --- a/climada/entity/measures/measure_config.py +++ b/climada/entity/measures/measure_config.py @@ -25,7 +25,10 @@ import warnings from dataclasses import MISSING, dataclass, field, fields from datetime import datetime -from typing import Any, Dict, Optional, Tuple +from typing import TYPE_CHECKING, Any + +if TYPE_CHECKING: + from climada.entity.measures.cost_income import CostIncome import numpy as np import pandas as pd @@ -288,12 +291,12 @@ class HazardModifierConfig(ModifierConfig): """ haz_type: str - haz_int_mult: Optional[float] = 1.0 - haz_int_add: Optional[float] = 0.0 - haz_freq_mult: Optional[float] = 1.0 - haz_freq_add: Optional[float] = 0.0 - new_hazard_path: Optional[str] = None - impact_rp_cutoff: Optional[float] = None + haz_int_mult: float | None = 1.0 + haz_int_add: float | None = 0.0 + haz_freq_mult: float | None = 1.0 + haz_freq_add: float | None = 0.0 + new_hazard_path: str | None = None + impact_rp_cutoff: float | None = None def __post_init__(self): config = self.to_dict() @@ -344,9 +347,9 @@ class ExposuresModifierConfig(ModifierConfig): modifier values. """ - reassign_impf_id: Optional[Dict[str, Dict[int | str, int | str]]] = None - set_to_zero: Optional[list[int]] = None - new_exposures_path: Optional[str] = None + reassign_impf_id: dict[str, dict[int | str, int | str]] | None = None + set_to_zero: list[int] | None = None + new_exposures_path: str | None = None def __post_init__(self): config = self.to_dict() @@ -392,17 +395,17 @@ class CostIncomeConfig(ModifierConfig): overrides the periodic cost/income logic. """ # noqa - mkt_price_year: Optional[int] = field(default_factory=lambda: datetime.today().year) + mkt_price_year: int | None = field(default_factory=lambda: datetime.today().year) init_cost: float = 0.0 periodic_cost: float = 0.0 periodic_income: float = 0.0 cost_yearly_growth_rate: float = 0.0 income_yearly_growth_rate: float = 0.0 freq: str = "Y" - custom_cash_flows: Optional[list[dict]] = None + custom_cash_flows: list[dict] | None = None @classmethod - def from_cost_income(cls, cost_income: "CostIncome") -> "CostIncomeConfig": + def from_cost_income(cls, cost_income: CostIncome) -> "CostIncomeConfig": """ Construct a :class:`CostIncomeConfig` from a live :class:`CostIncome` object. @@ -427,7 +430,7 @@ def from_cost_income(cls, cost_income: "CostIncome") -> "CostIncomeConfig": .to_dict(orient="records") ) return cls( - mkt_price_year=cost_income.mkt_price_year.year, # datetime → int + mkt_price_year=cost_income.mkt_price_year, init_cost=abs(cost_income.init_cost), # stored negative → positive periodic_cost=abs(cost_income.periodic_cost), periodic_income=cost_income.periodic_income, @@ -476,7 +479,7 @@ class MeasureConfig(ModifierConfig): hazard_modifier: HazardModifierConfig exposures_modifier: ExposuresModifierConfig cost_income: CostIncomeConfig - color_rgb: Optional[Tuple[float, float, float]] = None + color_rgb: tuple[float, float, float] | None = None def __repr__(self) -> str: """ From 587b0bc118c9fcf6b2db7dad423e807752928683 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 15 Oct 2026 11:43:06 +0200 Subject: [PATCH 42/44] Updates typehinting --- climada/entity/measures/measure.py | 16 +++++++--------- 1 file changed, 7 insertions(+), 9 deletions(-) diff --git a/climada/entity/measures/measure.py b/climada/entity/measures/measure.py index 55757b23ec..c5cc601cb7 100755 --- a/climada/entity/measures/measure.py +++ b/climada/entity/measures/measure.py @@ -21,8 +21,6 @@ from __future__ import annotations -from pandas.tseries.offsets import BaseOffset - from climada.engine.impact import Impact __all__ = ["Measure"] @@ -31,7 +29,7 @@ import inspect import logging from functools import wraps -from typing import TYPE_CHECKING, Any, Optional, Tuple, TypeVar +from typing import TYPE_CHECKING, Any, TypeVar from climada.entity.measures.measure_config import MeasureConfig @@ -174,10 +172,10 @@ def __init__( exposures_changes: ExposuresChange = identity_function, impfset_changes: ImpfsetChange = identity_function, hazard_changes: HazardChange = identity_function, - sub_measures: Optional[list[str]] = None, - cost_income: Optional[CostIncome] = None, - color_rgb: Optional[Tuple[float, float, float]] = None, - _config: Optional[MeasureConfig] = None, + sub_measures: list[str] | None = None, + cost_income: CostIncome | None = None, + color_rgb: tuple[float, float, float] | None = None, + _config: MeasureConfig | None = None, ): """ Initialize a new Measure object. @@ -398,7 +396,7 @@ def apply( hazard: Hazard, enforce_copy: bool = True, **kwargs, - ) -> Tuple[Exposures, ImpactFuncSet, Hazard]: + ) -> tuple[Exposures, ImpactFuncSet, Hazard]: """Apply all measure transformations to the provided triplet of :class:`Exposures`, :class:`ImpactFuncSet`, :class:`Hazard`. @@ -442,7 +440,7 @@ def apply( Returns ------- - Tuple[Exposures, ImpactFuncSet, Hazard] + tuple[Exposures, ImpactFuncSet, Hazard] A tuple containing the transformed entities in the order: (changed_exposures, changed_impfset, changed_hazard). If `enforce_copy` was True, these are new objects; otherwise, they may reference the From 76151e0e475a1015103a8817301fe45703f45b39 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 15 Oct 2026 11:43:19 +0200 Subject: [PATCH 43/44] Fixes arguments not used in calc_impact --- climada/entity/measures/measure.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/climada/entity/measures/measure.py b/climada/entity/measures/measure.py index c5cc601cb7..9c3c4cbc77 100755 --- a/climada/entity/measures/measure.py +++ b/climada/entity/measures/measure.py @@ -566,5 +566,7 @@ def calc_impact( imp = ImpactCalc(new_exp, new_impfs, new_haz).impact( save_mat=save_mat, assign_centroids=assign_centroids, + ignore_cover=ignore_cover, + ignore_deductible=ignore_deductible, ) return imp # .calc_risk_transfer(0, 0) From 7e3236c5989b6ac0748f1fb19c50544125cabfde Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 15 Oct 2026 14:49:00 +0200 Subject: [PATCH 44/44] Updates tests --- climada/entity/measures/test/test_measure.py | 111 ++++++++++++++++++ .../measures/test/test_measure_config.py | 5 - 2 files changed, 111 insertions(+), 5 deletions(-) diff --git a/climada/entity/measures/test/test_measure.py b/climada/entity/measures/test/test_measure.py index 828739debf..aa901d475e 100644 --- a/climada/entity/measures/test/test_measure.py +++ b/climada/entity/measures/test/test_measure.py @@ -363,3 +363,114 @@ def fn(obj, **kw): ) m.apply(_make_mock(), _make_mock(), _make_mock(), enforce_copy=False) assert call_order == ["exposures", "hazard", "impfset"] + + +class TestCalcImpact: + IMPACT_CALC = "climada.engine.impact_calc.ImpactCalc" + LOGGER = "climada.entity.measures.measure.LOGGER" + CENTR_COL = "centr_FL" + + def _make_triplet(self, with_centroids=True): + """Return mock (exposures, impfset, hazard) with a ``gdf.columns`` list.""" + exp, impfset, haz = _make_mock(), _make_mock(), _make_mock() + haz.centr_exp_col = self.CENTR_COL + exp.gdf.columns = ["value"] + ([self.CENTR_COL] if with_centroids else []) + return exp, impfset, haz + + def test_returns_impact_computed_on_transformed_triplet(self): + new_triplet = self._make_triplet() + m = Measure("test") + with ( + patch(self.IMPACT_CALC) as mock_calc, + patch.object(Measure, "apply", return_value=new_triplet), + ): + result = m.calc_impact(*self._make_triplet()) + + mock_calc.assert_called_once_with(*new_triplet) + assert result is mock_calc.return_value.impact.return_value + + def test_default_arguments_passed_to_impact(self): + with patch(self.IMPACT_CALC) as mock_calc: + Measure("test").calc_impact(*self._make_triplet(), enforce_copy=False) + + mock_calc.return_value.impact.assert_called_once_with( + save_mat=True, + assign_centroids=False, + ignore_cover=False, + ignore_deductible=False, + ) + + def test_custom_arguments_passed_to_impact(self): + with patch(self.IMPACT_CALC) as mock_calc: + Measure("test").calc_impact( + *self._make_triplet(), + ignore_cover=True, + ignore_deductible=True, + save_mat=False, + assign_centroids=True, + enforce_copy=False, + ) + + mock_calc.return_value.impact.assert_called_once_with( + save_mat=False, + assign_centroids=True, + ignore_cover=True, + ignore_deductible=True, + ) + + def test_enforce_copy_and_kwargs_forwarded_to_apply(self): + triplet = self._make_triplet() + kwargs_hazard = {"threshold": 3.5} + m = Measure("test") + with ( + patch(self.IMPACT_CALC), + patch.object(Measure, "apply", return_value=triplet) as mock_apply, + ): + m.calc_impact(*triplet, enforce_copy=False, kwargs_hazard=kwargs_hazard) + + mock_apply.assert_called_once_with( + *triplet, enforce_copy=False, kwargs_hazard=kwargs_hazard + ) + + def test_kwargs_reach_change_function_and_result_is_used(self): + exp, impfset, haz = self._make_triplet() + changed_haz = _make_mock() + changed_haz.centr_exp_col = self.CENTR_COL + received = {} + + def hazard_change(hazard, threshold): + received.update(hazard=hazard, threshold=threshold) + return changed_haz + + m = Measure("test", hazard_changes=hazard_change) + with patch(self.IMPACT_CALC) as mock_calc: + m.calc_impact( + exp, + impfset, + haz, + enforce_copy=False, + kwargs_hazard={"threshold": 3.5}, + ) + + assert received == {"hazard": haz, "threshold": 3.5} + mock_calc.assert_called_once_with(exp, impfset, changed_haz) + + def test_warns_and_assigns_centroids_when_missing(self): + exp, impfset, haz = self._make_triplet(with_centroids=False) + order = MagicMock() + order.attach_mock(exp.assign_centroids, "assign") + with patch(self.IMPACT_CALC) as mock_calc, patch(self.LOGGER) as mock_logger: + order.attach_mock(mock_calc.return_value.impact, "impact") + Measure("test").calc_impact(exp, impfset, haz, enforce_copy=False) + + mock_logger.warning.assert_called_once() + exp.assign_centroids.assert_called_once_with(haz) + assert [c[0] for c in order.mock_calls] == ["assign", "impact"] + + def test_no_warning_when_centroids_assigned(self): + exp, impfset, haz = self._make_triplet(with_centroids=True) + with patch(self.IMPACT_CALC), patch(self.LOGGER) as mock_logger: + Measure("test").calc_impact(exp, impfset, haz, enforce_copy=False) + + mock_logger.warning.assert_not_called() + exp.assign_centroids.assert_not_called() diff --git a/climada/entity/measures/test/test_measure_config.py b/climada/entity/measures/test/test_measure_config.py index 2fcd45113f..0c69414bbb 100644 --- a/climada/entity/measures/test/test_measure_config.py +++ b/climada/entity/measures/test/test_measure_config.py @@ -340,10 +340,6 @@ def test_from_dict_full(self, full_measure_dict): assert config.exposures_modifier.set_to_zero == full_measure_dict["set_to_zero"] assert config.cost_income.init_cost == full_measure_dict["init_cost"] assert config.color_rgb == tuple(full_measure_dict["color_rgb"]) - assert ( - config.implementation_duration - == full_measure_dict["implementation_duration"] - ) def test_from_dict_ignores_unknown_keys(self, minimal_measure_dict): d = {**minimal_measure_dict, "completely_unknown": 42} @@ -360,7 +356,6 @@ def test_to_dict_roundtrip(self, full_measure_dict): assert recovered.impfset_modifier == config.impfset_modifier assert recovered.exposures_modifier == config.exposures_modifier assert recovered.color_rgb == config.color_rgb - assert recovered.implementation_duration == config.implementation_duration def test_to_dict_color_rgb_none(self, minimal_measure_dict): config = MeasureConfig.from_dict(minimal_measure_dict)