From c2899db08a66c07b8197456118d725a0485eec22 Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Wed, 9 Aug 2023 12:13:50 +0200 Subject: [PATCH 01/44] petals compatibility test fix pythonpath --- script/jenkins/petals_regression_test/Jenkinsfile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/script/jenkins/petals_regression_test/Jenkinsfile b/script/jenkins/petals_regression_test/Jenkinsfile index 22b3bef5b..56a8b0241 100644 --- a/script/jenkins/petals_regression_test/Jenkinsfile +++ b/script/jenkins/petals_regression_test/Jenkinsfile @@ -14,7 +14,7 @@ pipeline { cp ~/jobs/petals_install_env/workspace/climada.conf climada.conf python script/jenkins/set_config.py test_directory ~/jobs/petals_install_env/workspace/climada_petals - pytest --junitxml=tests_xml/tests.xml ~/jobs/petals_install_env/workspace/climada_petals + PYTHONPATH=.:$PYTHONPATH pytest --junitxml=tests_xml/tests.xml ~/jobs/petals_install_env/workspace/climada_petals git checkout climada.conf ''' From 9a30fd4f94a1ffa1644164a29e6413721b5696c1 Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Thu, 10 Aug 2023 16:28:54 +0200 Subject: [PATCH 02/44] test_vec_ras: fix erroneous test --- climada/hazard/centroids/test/test_vec_ras.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/climada/hazard/centroids/test/test_vec_ras.py b/climada/hazard/centroids/test/test_vec_ras.py index fa55ffe2a..40d16a2cf 100644 --- a/climada/hazard/centroids/test/test_vec_ras.py +++ b/climada/hazard/centroids/test/test_vec_ras.py @@ -617,8 +617,9 @@ def test_from_vector_file(self): # Test reading values from file with incompatible geometry shp_file = shapereader.natural_earth(resolution='10m', category='cultural', name='populated_places_simple') - with self.assertRaises(ValueError): - centr.values_from_vector_files(shp_file, val_names=['pop_min', 'pop_max']) + with self.assertRaises(ValueError) as ve: + centr.values_from_vector_files([shp_file], val_names=['pop_min', 'pop_max']) + self.assertIn('could not be broadcast together with shapes', str(ve.exception)) def test_from_raster_file_wrong_fail(self): """Test from_raster_file with wrong centroids""" From bf306468938925ff1c53834067256d4733d590fe Mon Sep 17 00:00:00 2001 From: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> Date: Thu, 10 Aug 2023 16:34:23 +0200 Subject: [PATCH 03/44] Fix bug in centroids natural earth feature test (#768) * Fix natural earth data test in centroids * Pass argument as list. * Make sure `allclose` does not throw a broadcasting error. * Update CHANGELOG.md --------- Co-authored-by: Emanuel Schmid <51439563+emanuel-schmid@users.noreply.github.com> --- CHANGELOG.md | 1 + climada/hazard/centroids/centr.py | 19 ++++++++++++------- climada/hazard/centroids/test/test_vec_ras.py | 6 ++++-- 3 files changed, 17 insertions(+), 9 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 80908618e..7e1f4795e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -62,6 +62,7 @@ Removed: - `util.lines_polys_handler` solve polygon disaggregation issue in metre-based projection [#666](https://github.com/CLIMADA-project/climada_python/pull/666) - Problem with `pyproj.CRS` as `Impact` attribute, [#706](https://github.com/CLIMADA-project/climada_python/issues/706). Now CRS is always stored as `str` in WKT format. +- Correctly handle assertion errors in `Centroids.values_from_vector_files` and fix the associated test [#768](https://github.com/CLIMADA-project/climada_python/pull/768/) ### Deprecated diff --git a/climada/hazard/centroids/centr.py b/climada/hazard/centroids/centr.py index 5183995b3..ae124d151 100644 --- a/climada/hazard/centroids/centr.py +++ b/climada/hazard/centroids/centr.py @@ -575,19 +575,24 @@ def values_from_vector_files(self, file_names, val_names=None, dst_crs=None): Sparse array of shape (len(val_name), len(geometry)). """ if val_names is None: - val_names = ['intensity'] + val_names = ["intensity"] values = [] for file_name in file_names: tmp_lat, tmp_lon, tmp_geometry, data = u_coord.read_vector( - file_name, val_names, dst_crs=dst_crs) - if not (u_coord.equal_crs(tmp_geometry.crs, self.geometry.crs) - and np.allclose(tmp_lat, self.lat) - and np.allclose(tmp_lon, self.lon)): - raise ValueError('Vector data inconsistent with contained vector.') + file_name, val_names, dst_crs=dst_crs + ) + try: + assert u_coord.equal_crs(tmp_geometry.crs, self.geometry.crs) + np.testing.assert_allclose(tmp_lat, self.lat) + np.testing.assert_allclose(tmp_lon, self.lon) + except AssertionError as exc: + raise ValueError( + "Vector data inconsistent with contained vector" + ) from exc values.append(sparse.csr_matrix(data)) - return sparse.vstack(values, format='csr') + return sparse.vstack(values, format="csr") def read_mat(self, *args, **kwargs): """This function is deprecated, use Centroids.from_mat instead.""" diff --git a/climada/hazard/centroids/test/test_vec_ras.py b/climada/hazard/centroids/test/test_vec_ras.py index 40d16a2cf..a4ec17f7e 100644 --- a/climada/hazard/centroids/test/test_vec_ras.py +++ b/climada/hazard/centroids/test/test_vec_ras.py @@ -617,9 +617,11 @@ def test_from_vector_file(self): # Test reading values from file with incompatible geometry shp_file = shapereader.natural_earth(resolution='10m', category='cultural', name='populated_places_simple') - with self.assertRaises(ValueError) as ve: + with self.assertRaises(ValueError) as cm: centr.values_from_vector_files([shp_file], val_names=['pop_min', 'pop_max']) - self.assertIn('could not be broadcast together with shapes', str(ve.exception)) + self.assertIn( + "Vector data inconsistent with contained vector", str(cm.exception) + ) def test_from_raster_file_wrong_fail(self): """Test from_raster_file with wrong centroids""" From 0dc240f4f29aa584f0ca2e298b5752c13f7b3985 Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Fri, 11 Aug 2023 14:52:39 +0200 Subject: [PATCH 04/44] exposures: extend _metadata --- climada/entity/exposures/base.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/climada/entity/exposures/base.py b/climada/entity/exposures/base.py index 904612f77..599dee624 100644 --- a/climada/entity/exposures/base.py +++ b/climada/entity/exposures/base.py @@ -121,7 +121,7 @@ class Exposures(): TC. There might be different hazards defined: centr_TC, centr_FL, ... Computed in method assign_centroids(). """ - _metadata = ['tag', 'ref_year', 'value_unit', 'meta'] + _metadata = ['tag', 'ref_year', 'value_unit', 'meta', 'description'] vars_oblig = ['value', 'latitude', 'longitude'] """Name of the variables needed to compute the impact.""" From ad89e3db936b47b71758046ed0b61952b8cec8d7 Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Fri, 11 Aug 2023 15:44:50 +0200 Subject: [PATCH 05/44] fix copy failure due to changed _metadata --- climada/entity/exposures/base.py | 1 + 1 file changed, 1 insertion(+) diff --git a/climada/entity/exposures/base.py b/climada/entity/exposures/base.py index 599dee624..c43464f79 100644 --- a/climada/entity/exposures/base.py +++ b/climada/entity/exposures/base.py @@ -172,6 +172,7 @@ def __init__(self, *args, meta=None, tag=None, ref_year=DEF_REF_YEAR, self.ref_year = self.meta.get('ref_year', DEF_REF_YEAR) if ref_year is None else ref_year self.value_unit = (self.meta.get('value_unit', DEF_VALUE_UNIT) if value_unit is None else value_unit) + self.description = kwargs.pop('description') if 'description' in kwargs else None # remaining generic attributes from derived classes for mda in type(self)._metadata: From 015fdbf94a2f1aba77acad81da9f884e9bc385b8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20R=C3=B6=C3=B6sli?= Date: Thu, 17 Aug 2023 13:56:45 +0200 Subject: [PATCH 06/44] Fix hardcoded text elements in the plots of the forecast class (#769) * fix hardcoded text elements * format forecast module * rework tests of forecast module * Update CHANGELOG.md --------- Co-authored-by: Thomas Roosli Co-authored-by: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> --- CHANGELOG.md | 1 + climada/engine/forecast.py | 43 +++++++++++++------- climada/engine/test/test_forecast.py | 61 +++++++++++++++++++++------- 3 files changed, 77 insertions(+), 28 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7e1f4795e..baf6e46f2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -63,6 +63,7 @@ Removed: - `util.lines_polys_handler` solve polygon disaggregation issue in metre-based projection [#666](https://github.com/CLIMADA-project/climada_python/pull/666) - Problem with `pyproj.CRS` as `Impact` attribute, [#706](https://github.com/CLIMADA-project/climada_python/issues/706). Now CRS is always stored as `str` in WKT format. - Correctly handle assertion errors in `Centroids.values_from_vector_files` and fix the associated test [#768](https://github.com/CLIMADA-project/climada_python/pull/768/) +- Text in `Forecast` class plots can now be adjusted [#769](https://github.com/CLIMADA-project/climada_python/issues/769) ### Deprecated diff --git a/climada/engine/forecast.py b/climada/engine/forecast.py index 6549b5fe4..02d470b62 100644 --- a/climada/engine/forecast.py +++ b/climada/engine/forecast.py @@ -313,6 +313,7 @@ def calc(self, force_reassign=False): def plot_imp_map( self, run_datetime=None, + explain_str=None, save_fig=True, close_fig=False, polygon_file=None, @@ -321,13 +322,17 @@ def plot_imp_map( figsize=(9, 13), adapt_fontsize=True, ): - """plot a map of the impacts + """ plot a map of the impacts Parameters ---------- run_datetime : datetime.datetime, optional Select the used hazard by the run_datetime, default is first element of attribute run_datetime. + explain_str : str, optional + Short str which explains type of impact, explain_str is included + in the title of the figure. + default is 'mean building damage caused by wind' save_fig : bool, optional Figure is saved if True, folder is within your configurable save_dir and filename is derived from the method summary_str() @@ -372,7 +377,7 @@ def plot_imp_map( "run_start": ( run_datetime.strftime("%d.%m.%Y %HUTC +") + lead_time_str + "d" ), - "explain_text": ("mean building damage caused by wind"), + "explain_text": "mean building damage caused by wind" if explain_str is None else explain_str, "model_text": "CLIMADA IMPACT", } fig, axes = self._plot_imp_map( @@ -526,15 +531,24 @@ def _plot_imp_map( return fig, axis_sub def plot_hist( - self, run_datetime=None, save_fig=True, close_fig=False, figsize=(9, 8) + self, + run_datetime=None, + explain_str=None, + save_fig=True, + close_fig=False, + figsize=(9, 8), ): - """plot histogram of the forecasted impacts all ensemble members + """ plot histogram of the forecasted impacts all ensemble members Parameters ---------- run_datetime : datetime.datetime, optional Select the used hazard by the run_datetime, default is first element of attribute run_datetime. + explain_str : str, optional + Short str which explains type of impact, explain_str is included + in the title of the figure. + default is 'total building damage' save_fig : bool, optional Figure is saved if True, folder is within your configurable save_dir and filename is derived from the method summary_str() @@ -603,7 +617,7 @@ def plot_hist( axes.xaxis.set_ticks(x_ticks) axes.xaxis.set_ticklabels(x_ticklabels) plt.xticks(rotation=15, horizontalalignment="right") - plt.xlim([(10**-0.25) * bins[0], (10**0.25) * bins[-1]]) + plt.xlim([(10 ** -0.25) * bins[0], (10 ** 0.25) * bins[-1]]) lead_time_str = "{:.0f}".format( self.lead_time(run_datetime).days @@ -614,7 +628,7 @@ def plot_hist( "run_start": ( run_datetime.strftime("%d.%m.%Y %HUTC +") + lead_time_str + "d" ), - "explain_text": ("total building damage"), + "explain_text": ("total building damage") if explain_str is None else explain_str, "model_text": "CLIMADA IMPACT", } title_position = { @@ -656,8 +670,9 @@ def plot_hist( plt.text( 0.75, 0.85, - "mean damage:\nCHF " - + self._number_to_str(self._impact[haz_ind].at_event.mean()), + "mean impact:\n " + + self._number_to_str(self._impact[haz_ind].at_event.mean()) + + ' ' + self._impact[haz_ind].unit, horizontalalignment="center", verticalalignment="center", transform=axes.transAxes, @@ -740,7 +755,7 @@ def plot_exceedence_prob( The default is (9, 13) adapt_fontsize : bool, optional If set to true, the size of the fonts will be adapted to the size of the figure. - Otherwise the default matplotlib font size is used. Default is True. + Otherwise, the default matplotlib font size is used. Default is True. Returns ------- @@ -750,10 +765,10 @@ def plot_exceedence_prob( if run_datetime is None: run_datetime = self.run_datetime[0] haz_ind = np.argwhere(np.isin(self.run_datetime, run_datetime))[0][0] - wind_map_file_name = ( + exceedence_map_file_name = ( self.summary_str(run_datetime) + "_exceed_" + str(threshold) + "_map.jpeg" ) - wind_map_file_name_full = FORECAST_PLOT_DIR / wind_map_file_name + exceedence_map_file_name_full = FORECAST_PLOT_DIR / exceedence_map_file_name lead_time_str = "{:.0f}".format( self.lead_time(run_datetime).days + self.lead_time(run_datetime).seconds / 60 / 60 / 24 @@ -783,7 +798,7 @@ def plot_exceedence_prob( adapt_fontsize=adapt_fontsize, ) if save_fig: - plt.savefig(wind_map_file_name_full) + plt.savefig(exceedence_map_file_name_full) if close_fig: plt.clf() plt.close(fig) @@ -974,7 +989,7 @@ def plot_warn_map( Figure is not drawn if True. The default is False. adapt_fontsize : bool, optional If set to true, the size of the fonts will be adapted to the size of the figure. - Otherwise the default matplotlib font size is used. Default is True. + Otherwise, the default matplotlib font size is used. Default is True. Returns ------- @@ -1086,7 +1101,7 @@ def _plot_warn( decision_dict_functions[aggregation] = np.mean else: raise ValueError( - "Parameter area_aggregation of " + "Parameter " + aggregation + " of " + "Forecast.plot_warn_map() must eiter be " + "a float between [0..1], which " + "specifys a quantile. or 'sum' or 'mean'." diff --git a/climada/engine/test/test_forecast.py b/climada/engine/test/test_forecast.py index 3ca7f06e5..460656ac3 100644 --- a/climada/engine/test/test_forecast.py +++ b/climada/engine/test/test_forecast.py @@ -104,7 +104,8 @@ class TestPlot(unittest.TestCase): def test_Forecast_plot(self): """Test cplotting functions from the Forecast class""" - #hazard + ## given a forecast based on hazard exposure and vulnerability + #hazard haz1 = StormEurope.from_cosmoe_file( HAZ_DIR.joinpath('storm_europe_cosmoe_forecast_vmax_testfile.nc'), run_datetime=dt.datetime(2018,1,1), @@ -149,8 +150,10 @@ def test_Forecast_plot(self): for f in source: if f['properties']['adm0_a3'] == 'CHE': sink.write(f) - #test plotting functions + ## test plotting functions + # should save plot without failing forecast.plot_imp_map(run_datetime=dt.datetime(2017,12,31), + explain_str='test text', polygon_file=str(cantons_file), save_fig=True, close_fig=True) map_file_name = (forecast.summary_str(dt.datetime(2017,12,31)) + @@ -158,12 +161,30 @@ def test_Forecast_plot(self): '.jpeg') map_file_name_full = Path(FORECAST_PLOT_DIR) / map_file_name map_file_name_full.absolute().unlink(missing_ok=False) - forecast.plot_hist(run_datetime=dt.datetime(2017,12,31), - save_fig=False, close_fig=True) - forecast.plot_exceedence_prob(run_datetime=dt.datetime(2017,12,31), - threshold=5000, save_fig=False, close_fig=True) - - + #should contain title strings + ax = forecast.plot_hist(run_datetime=dt.datetime(2017,12,31), + explain_str='test text', + save_fig=False, close_fig=False) + title_artists = ax.get_figure().get_children() + title_texts = [x.get_text() for x in title_artists if isinstance(x, plt.Text)] + self.assertIn('test text', title_texts) + self.assertIn('Wed 03 Jan 2018 00-24UTC', title_texts) + self.assertIn('31.12.2017 00UTC +3d', title_texts) + #should contain average impact in axes + artists = ax.get_children() + texts = [x.get_text() for x in artists if type(x) == plt.Text] + self.assertIn('mean impact:\n 26 USD', texts) + ax.get_figure().clf() + #should contain title strings + ax = forecast.plot_exceedence_prob(run_datetime=dt.datetime(2017,12,31), + threshold=5000, explain_str='test text exceedence', + save_fig=False, close_fig=False)[0][0] + title_artists = ax.get_figure().get_children() + title_texts = [x.get_text() for x in title_artists if isinstance(x, plt.Text)] + self.assertIn('test text exceedence', title_texts) + self.assertIn('Wed 03 Jan 2018 00-24UTC', title_texts) + self.assertIn('31.12.2017 00UTC +3d', title_texts) + ax.get_figure().clf() forecast.plot_warn_map(str(cantons_file), decision_level = 'polygon', thresholds=[100000,500000, @@ -187,9 +208,10 @@ def test_Forecast_plot(self): close_fig=True) forecast.plot_hexbin_ei_exposure() plt.close() - with self.assertRaises(ValueError): + # should fail because of invalid decision_level + with self.assertRaises(ValueError) as cm: forecast.plot_warn_map(str(cantons_file), - decision_level = 'test_fail', + decision_level='test_fail', probability_aggregation=0.2, area_aggregation=0.2, title="Building damage warning", @@ -197,9 +219,13 @@ def test_Forecast_plot(self): save_fig=False, close_fig=True) plt.close() - with self.assertRaises(ValueError): + self.assertIn( + "Parameter decision_level", str(cm.exception) + ) + # should fail because of invalid probability_aggregation + with self.assertRaises(ValueError) as cm: forecast.plot_warn_map(str(cantons_file), - decision_level = 'exposure_point', + decision_level='exposure_point', probability_aggregation='test_fail', area_aggregation=0.2, title="Building damage warning", @@ -207,9 +233,13 @@ def test_Forecast_plot(self): save_fig=False, close_fig=True) plt.close() - with self.assertRaises(ValueError): + self.assertIn( + "Parameter probability_aggregation", str(cm.exception) + ) + # should fail because of invalid area_aggregation + with self.assertRaises(ValueError) as cm: forecast.plot_warn_map(str(cantons_file), - decision_level = 'exposure_point', + decision_level='exposure_point', probability_aggregation=0.2, area_aggregation='test_fail', title="Building damage warning", @@ -217,6 +247,9 @@ def test_Forecast_plot(self): save_fig=False, close_fig=True) plt.close() + self.assertIn( + "Parameter area_aggregation", str(cm.exception) + ) # Execute Tests From ef410e1cc1c346d04efa4b2b722efe96a72a136a Mon Sep 17 00:00:00 2001 From: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> Date: Mon, 21 Aug 2023 16:59:59 +0200 Subject: [PATCH 07/44] Make `Impact.impact_at_reg` support all zero impacts (#773) * Fix a bug where impact_at_reg would not work for all zero impacts * Update CHANGELOG.md --- CHANGELOG.md | 1 + climada/engine/impact.py | 2 +- climada/engine/test/test_impact.py | 8 ++++++-- 3 files changed, 8 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index baf6e46f2..af490e7ed 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -64,6 +64,7 @@ Removed: - Problem with `pyproj.CRS` as `Impact` attribute, [#706](https://github.com/CLIMADA-project/climada_python/issues/706). Now CRS is always stored as `str` in WKT format. - Correctly handle assertion errors in `Centroids.values_from_vector_files` and fix the associated test [#768](https://github.com/CLIMADA-project/climada_python/pull/768/) - Text in `Forecast` class plots can now be adjusted [#769](https://github.com/CLIMADA-project/climada_python/issues/769) +- `Impact.impact_at_reg` now supports impact matrices where all entries are zero [#773](https://github.com/CLIMADA-project/climada_python/pull/773) ### Deprecated diff --git a/climada/engine/impact.py b/climada/engine/impact.py index c8ec350f8..c1cbb8fc2 100644 --- a/climada/engine/impact.py +++ b/climada/engine/impact.py @@ -434,7 +434,7 @@ def impact_at_reg(self, agg_regions=None): Contains the aggregated data per event. Rows: Hazard events. Columns: Aggregation regions. """ - if self.imp_mat.nnz == 0: + if np.prod(self.imp_mat.shape) == 0: raise ValueError( "The aggregated impact cannot be computed as no Impact.imp_mat was " "stored during the impact calculation" diff --git a/climada/engine/test/test_impact.py b/climada/engine/test/test_impact.py index 698a8bcd6..454df92d0 100644 --- a/climada/engine/test/test_impact.py +++ b/climada/engine/test/test_impact.py @@ -562,9 +562,13 @@ def test_admin0(self): def test_no_imp_mat(self): """Check error if no impact matrix is stored""" - # Test error when no imp_mat is stored - self.imp.imp_mat = sparse.csr_matrix((0, 0)) + # A matrix with only zeros should work! + self.imp.imp_mat = sparse.csr_matrix(np.zeros_like(self.imp.imp_mat.toarray())) + at_reg = self.imp.impact_at_reg(["A", "A"]) + self.assertEqual(at_reg["A"].sum(), 0) + # An empty matrix should not work + self.imp.imp_mat = sparse.csr_matrix((0, 0)) with self.assertRaises(ValueError) as cm: self.imp.impact_at_reg() self.assertIn("no Impact.imp_mat was stored", str(cm.exception)) From 8e0d8516b3421afd843e0e5058655fed62c1463a Mon Sep 17 00:00:00 2001 From: "Chahan M. Kropf" Date: Mon, 28 Aug 2023 14:27:26 +0200 Subject: [PATCH 08/44] Update multiprocessing in unsequa (#763) * Update pandas iteritems to items * Change pd append to concat * Fix minimal chunksize at 1 * Remove not needed parallel pool chunksize argument * Remove global matplotlib styles * Remove deprecated tot_value from unsequa * Add chunked version of parallel computing * Remove deprecated numpy vstack of objects * Feature/order samples unsequa (#766) * Allow to set loglevel * Add method to sort samples * Add advanced examples for unsequa * Remove logging control * Remove unecessary output prints * Update CHANGELOG.md --------- Co-authored-by: Chahan Kropf Co-authored-by: emanuel-schmid Co-authored-by: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> --- CHANGELOG.md | 6 + climada/engine/unsequa/calc_base.py | 170 +- climada/engine/unsequa/calc_cost_benefit.py | 216 +- climada/engine/unsequa/calc_impact.py | 204 +- climada/engine/unsequa/input_var.py | 1 + climada/engine/unsequa/test/test_unsequa.py | 34 +- climada/engine/unsequa/unc_output.py | 35 +- doc/tutorial/climada_engine_unsequa.ipynb | 3164 ++++++++++--------- 8 files changed, 2152 insertions(+), 1678 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index af490e7ed..a72897732 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -30,6 +30,7 @@ Removed: - Added method `Exposures.centroids_total_value` to replace the functionality of `Exposures.affected_total_value`. This method is temporary and deprecated. [#702](https://github.com/CLIMADA-project/climada_python/pull/702) - New method `climada.util.api_client.Client.purge_cache`: utility function to remove outdated files from the local file system to free disk space. ([#737](https://github.com/CLIMADA-project/climada_python/pull/737)) +- Added advanced examples in unsequa tutorial for coupled input variables and for handling efficiently the loading of multiple large files [#766](https://github.com/CLIMADA-project/climada_python/pull/766) ### Changed @@ -57,6 +58,7 @@ Removed: - `list_dataset_infos` from `climada.util.api_client.Client`: the `properties` argument, a `dict`, can now have `None` as values. Before, only strings and lists of strings were allowed. Setting a particular property to `None` triggers a search for datasets where this property is not assigned. [#752](https://github.com/CLIMADA-project/climada_python/pull/752) - Reduce memory requirements of `TropCyclone.from_tracks` [#749](https://github.com/CLIMADA-project/climada_python/pull/749) - Support for different wind speed and pressure units in `TCTracks` when running `TropCyclone.from_tracks` [#749](https://github.com/CLIMADA-project/climada_python/pull/749) +- Changed the parallel package from Pathos to Multiproess in the unsequa module [#763](https://github.com/CLIMADA-project/climada_python/pull/763) ### Fixed @@ -65,6 +67,9 @@ Removed: - Correctly handle assertion errors in `Centroids.values_from_vector_files` and fix the associated test [#768](https://github.com/CLIMADA-project/climada_python/pull/768/) - Text in `Forecast` class plots can now be adjusted [#769](https://github.com/CLIMADA-project/climada_python/issues/769) - `Impact.impact_at_reg` now supports impact matrices where all entries are zero [#773](https://github.com/CLIMADA-project/climada_python/pull/773) +- upgrade pathos 0.3.0 -> 0.3.1 issue [#761](https://github.com/CLIMADA-project/climada_python/issues/761) (for unsequa module [#763](https://github.com/CLIMADA-project/climada_python/pull/763)) +- Fix bugs with pandas 2.0 (iteritems -> items, append -> concat) (fix issue [#700](https://github.com/CLIMADA-project/climada_python/issues/700) for unsequa module) [#763](https://github.com/CLIMADA-project/climada_python/pull/763)) +- Remove matplotlib styles in unsequa module (fixes issue [#758](https://github.com/CLIMADA-project/climada_python/issues/758)) [#763](https://github.com/CLIMADA-project/climada_python/pull/763) ### Deprecated @@ -77,6 +82,7 @@ Removed: - `Centroids.set_raster_from_pix_bounds` [#721](https://github.com/CLIMADA-project/climada_python/pull/721) - `requirements/env_developer.yml` environment specs. Use 'extra' requirements when installing the Python package instead [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - `Impact.tag` attribute. This change is not backwards-compatible with respect to the files written and read by the `Impact` class [#743](https://github.com/CLIMADA-project/climada_python/pull/743) +- `impact.tot_value ` attribute removed from unsequa module [#763](https://github.com/CLIMADA-project/climada_python/pull/763) ## v3.3.2 diff --git a/climada/engine/unsequa/calc_base.py b/climada/engine/unsequa/calc_base.py index 21aad6865..456352cf9 100644 --- a/climada/engine/unsequa/calc_base.py +++ b/climada/engine/unsequa/calc_base.py @@ -21,6 +21,7 @@ import logging import copy +import itertools import datetime as dt @@ -47,6 +48,31 @@ class Calc(): Names of the required uncertainty variables. _metric_names : tuple(str) Names of the output metrics. + + Notes + ----- + Parallelization logics: for computation of the uncertainty users may + specify a number N of processes on which to perform the computations in + parallel. Since the computation for each individual sample of the + input parameters is independent of one another, we implemented a simple + distribution on the processes. + + 1. The samples are divided in N equal sub-sample chunks + 2. Each chunk of samples is sent as one to a node for processing + + Hence, this is equivalent to the user running the computation N times, + once for each sub-sample. + Note that for each process, all the input variables must be copied once, + and hence each parallel process requires roughly the same amount of memory + as if a single process would be used. + + This approach differs from the usual parallelization strategy (where individual + samples are distributed), because each sample requires the entire input data. + With this method, copying data between processes is reduced to a minimum. + + Parallelization is currently not available for the sensitivity computation, + as this requires all samples simoultenaously in the current implementation + of the SaLib library. """ _input_var_names = () @@ -126,7 +152,7 @@ def distr_dict(self): distr_dict.update(input_var.distr_dict) return distr_dict - def est_comp_time(self, n_samples, time_one_run, pool=None): + def est_comp_time(self, n_samples, time_one_run, processes=None): """ Estimate the computation time @@ -154,8 +180,7 @@ def est_comp_time(self, n_samples, time_one_run, pool=None): "\n If computation cannot be reduced, consider using" " a surrogate model https://www.uqlab.com/", time_one_run) - ncpus = pool.ncpus if pool else 1 - total_time = n_samples * time_one_run / ncpus + total_time = n_samples * time_one_run / processes LOGGER.info("\n\nEstimated computaion time: %s\n", dt.timedelta(seconds=total_time)) @@ -354,11 +379,118 @@ def sensitivity(self, unc_output, sensitivity_method = 'sobol', return sens_output +def _multiprocess_chunksize(samples_df, processes): + """Divides the samples into chunks for multiprocesses computing + + The goal is to send to each processing node an equal number + of samples to process. This make the parallel processing anologous + to running the uncertainty assessment independently on each nodes + for a subset of the samples, instead of distributing individual samples + on the nodes dynamically. Hence, all the heavy input variables + are copied/sent once to each node only. + + Parameters + ---------- + samples_df : pd.DataFrame + samples dataframe + processes : int + number of processes + + Returns + ------- + int + the number of samples in each chunk + """ + return np.ceil( + samples_df.shape[0] / processes + ).astype(int) + +def _transpose_chunked_data(metrics): + """Transposes the output metrics lists from one list per + chunk of samples to one list per output metric + + [ [x1, [y1, z1]], [x2, [y2, z2]] ] -> + [ [x1, x2], [[y1, z1], [y2, z2]] ] + + Parameters + ---------- + metrics : list + list of list as returned by the uncertainty mapings + + Returns + ------- + list + list of climada output uncertainty + + See Also + -------- + calc_impact._map_impact_calc + map for impact uncertainty + calc_cost_benefits._map_costben_calc + map for cost benefit uncertainty + """ + return [ + list(itertools.chain.from_iterable(x)) + for x in zip(*metrics) + ] + +def _sample_parallel_iterator(samples, chunksize, **kwargs): + """ + Make iterator over chunks of samples + with repeated kwargs for each chunk. + + Parameters + ---------- + samples : pd.DataFrame + Dataframe of samples + **kwargs : arguments to repeat + Arguments to repeat for parallel computations + + Returns + ------- + iterator + suitable for methods _map_impact_calc and _map_costben_calc + + """ + def _chunker(df, size): + """ + Divide the dataframe into chunks of size number of lines + """ + for pos in range(0, len(df), size): + yield df.iloc[pos:pos + size] + + return zip( + _chunker(samples, chunksize), + *(itertools.repeat(item) for item in kwargs.values()) + ) + def _calc_sens_df(method, problem_sa, sensitivity_kwargs, param_labels, X, unc_df): + """Compute the sensitifity indices + + Parameters + ---------- + method : str + SALib sensitivity method name + problem_sa :dict + dictionnary for sensitivty method for SALib + sensitivity_kwargs : kwargs + passed on to SALib.method.analyse + param_labels : list(str) + list of name of uncertainty input parameters + X : numpy.ndarray + array of input parameter samples + unc_df : DataFrame + Dataframe containing the uncertainty values + + Returns + ------- + DataFrame + Values of the sensitivity indices + """ sens_first_order_dict = {} sens_second_order_dict = {} - for (submetric_name, metric_unc) in unc_df.iteritems(): + for (submetric_name, metric_unc) in unc_df.items(): Y = metric_unc.to_numpy() if X is not None: sens_indices = method.analyze(problem_sa, X, Y, @@ -404,6 +536,21 @@ def _calc_sens_df(method, problem_sa, sensitivity_kwargs, param_labels, X, unc_d def _si_param_first(param_labels, sens_indices): + """Extract the first order sensivity indices from SALib ouput + + Parameters + ---------- + param_labels : list(str) + name of the unceratinty input parameters + sens_indices : dict + sensitivity indidices dictionnary as produced by SALib + + Returns + ------- + si_names_first_order, param_names_first_order: list, list + Names of the sensivity indices of first order for all input parameters + and Parameter names for each sentivity index + """ n_params = len(param_labels) si_name_first_order_list = [ @@ -421,6 +568,21 @@ def _si_param_first(param_labels, sens_indices): def _si_param_second(param_labels, sens_indices): + """Extract second order sensitivity indices + + Parameters + ---------- + param_labels : list(str) + name of the unceratinty input parameters + sens_indices : dict + sensitivity indidices dictionnary as produced by SALib + + Returns + ------- + si_names_second_order, param_names_second_order, param_names_second_order_2: list, list, list + Names of the sensivity indices of second order for all input parameters + and Pairs of parameter names for each 2nd order sentivity index + """ n_params = len(param_labels) si_name_second_order_list = [ key diff --git a/climada/engine/unsequa/calc_cost_benefit.py b/climada/engine/unsequa/calc_cost_benefit.py index 1679a628c..7b903c5c5 100644 --- a/climada/engine/unsequa/calc_cost_benefit.py +++ b/climada/engine/unsequa/calc_cost_benefit.py @@ -23,13 +23,18 @@ import logging import time -from functools import partial -from typing import Optional, Union +import itertools +from typing import Optional, Union import pandas as pd +import numpy as np +import pathos.multiprocessing as mp +# use pathos.multiprocess fork of multiprocessing for compatibility +# wiht notebooks and other environments https://stackoverflow.com/a/65001152/12454103 from climada.engine.cost_benefit import CostBenefit from climada.engine.unsequa import Calc, InputVar, UncCostBenefitOutput +from climada.engine.unsequa.calc_base import _sample_parallel_iterator, _multiprocess_chunksize, _transpose_chunked_data from climada.util import log_level from climada.hazard import Hazard from climada.entity import Entity @@ -50,13 +55,13 @@ class CalcCostBenefit(Calc): ---------- value_unit : str Unit of the exposures value - haz_input_var : climada.engine.uncertainty.input_var.InputVar + haz_input_var : InputVar or Hazard Present Hazard uncertainty variable - ent_input_var : climada.engine.uncertainty.input_var.InputVar + ent_input_var : InputVar or Entity Present Entity uncertainty variable - haz_unc_fut_Var: climada.engine.uncertainty.input_var.InputVar + haz_unc_fut_Var: InputVar or Hazard Future Hazard uncertainty variable - ent_fut_input_var : climada.engine.uncertainty.input_var.InputVar + ent_fut_input_var : InputVar or Entity Future Entity uncertainty variable _input_var_names : tuple(str) Names of the required uncertainty variables @@ -127,7 +132,11 @@ def __init__( - def uncertainty(self, unc_data, pool=None, **cost_benefit_kwargs): + def uncertainty(self, + unc_sample, + processes=1, + chunksize=None, + **cost_benefit_kwargs): """ Computes the cost benefit for each sample in unc_output.sample_df. @@ -145,13 +154,17 @@ def uncertainty(self, unc_data, pool=None, **cost_benefit_kwargs): Parameters ---------- - unc_data : climada.engine.uncertainty.unc_output.UncOutput + unc_sample : climada.engine.uncertainty.unc_output.UncOutput Uncertainty data object with the input parameters samples - pool : pathos.pools.ProcessPool, optional - Pool of CPUs for parralel computations. Default is None. - The default is None. + processes : int, optional + Number of CPUs to use for parralel computations. + The default is 1 (not parallel) cost_benefit_kwargs : keyword arguments Keyword arguments passed on to climada.engine.CostBenefit.calc() + chunksize: int, optional + Size of the sample chunks for parallel processing. + Default is equal to the number of samples divided by the + number of processes. Returns ------- @@ -165,55 +178,49 @@ def uncertainty(self, unc_data, pool=None, **cost_benefit_kwargs): If no sampling parameters defined, the uncertainty distribution cannot be computed. + Notes + ----- + Parallelization logic is described in the base class + here :py:class:`~climada.engine.unsequa.calc_base.Calc` + See Also -------- climada.engine.cost_benefit: - Compute risk and adptation option cost benefits. + compute risk and adptation option cost benefits. """ - if unc_data.samples_df.empty: + if unc_sample.samples_df.empty: raise ValueError("No sample was found. Please create one first" + "using UncImpact.make_sample(N)") - samples_df = unc_data.samples_df.copy(deep=True) + # copy may not be needed, but is kept to prevent potential + # data corruption issues. The computational cost should be + # minimal as only a list of floats is copied. + samples_df = unc_sample.samples_df.copy(deep=True) + + if chunksize is None: + chunksize = _multiprocess_chunksize(samples_df, processes) unit = self.value_unit LOGGER.info("The freq_curve is not saved. Please " "change the risk_func (see climada.engine.cost_benefit) " "if return period information is needed") + one_sample = samples_df.iloc[0:1] start = time.time() - one_sample = samples_df.iloc[0:1].iterrows() - cb_metrics = map(self._map_costben_calc, one_sample) - [imp_meas_present, - imp_meas_future, - tot_climate_risk, - benefit, - cost_ben_ratio] = list(zip(*cb_metrics)) + self._compute_cb_metrics(one_sample, cost_benefit_kwargs, chunksize=1, processes=1) elapsed_time = (time.time() - start) - self.est_comp_time(unc_data.n_samples, elapsed_time, pool) + self.est_comp_time(unc_sample.n_samples, elapsed_time, processes) #Compute impact distributions - with log_level(level='ERROR', name_prefix='climada'): - if pool: - LOGGER.info('Using %s CPUs.', pool.ncpus) - chunksize = max(min(unc_data.n_samples // pool.ncpus, 100), 1) - cb_metrics = pool.map(partial(self._map_costben_calc, **cost_benefit_kwargs), - samples_df.iterrows(), - chunksize=chunksize) - - else: - cb_metrics = map(partial(self._map_costben_calc, **cost_benefit_kwargs), - samples_df.iterrows()) - - #Perform the actual computation - with log_level(level='ERROR', name_prefix='climada'): - [imp_meas_present, - imp_meas_future, - tot_climate_risk, - benefit, - cost_ben_ratio] = list(zip(*cb_metrics)) #Transpose list of list + [ + imp_meas_present, + imp_meas_future, + tot_climate_risk, + benefit, + cost_ben_ratio + ] = self._compute_cb_metrics(samples_df, cost_benefit_kwargs, chunksize, processes) # Assign computed impact distribution data to self tot_climate_risk_unc_df = \ @@ -248,8 +255,10 @@ def uncertainty(self, unc_data, pool=None, **cost_benefit_kwargs): in zip(imp_metric_names, metrics) } met_dic.update(dic_tmp) - df_imp_meas = df_imp_meas.append( - pd.DataFrame(met_dic), ignore_index=True + df_imp_meas = pd.concat( + [df_imp_meas, pd.DataFrame(met_dic)], + ignore_index=True, + sort=False ) im_periods[name + '_unc_df'] = df_imp_meas cost_benefit_kwargs = { @@ -266,48 +275,113 @@ def uncertainty(self, unc_data, pool=None, **cost_benefit_kwargs): unit=unit, cost_benefit_kwargs=cost_benefit_kwargs) - def _map_costben_calc(self, param_sample, **kwargs): - """ - Map to compute cost benefit for all parameter samples in parallel + def _compute_cb_metrics( + self, samples_df, cost_benefit_kwargs, chunksize, processes + ): + """Compute the uncertainty metrics Parameters ---------- - param_sample : pd.DataFrame.iterrows() - Generator of the parameter samples - kwargs : - Keyword arguments passed on to climada.engine.CostBenefit.calc() + samples_df : pd.DataFrame + dataframe of input parameter samples + cost_benefit_kwargs: kwargs + arguments to be passed to the cost_benefit.calc method + chunksize : int + size of the samples chunks + processes : int + number of processes to use Returns ------- list - icost benefit metrics list for all samples containing - imp_meas_present, imp_meas_future, tot_climate_risk, - benefit, cost_ben_ratio - + values of impact metrics per sample """ + with log_level(level='ERROR', name_prefix='climada'): + p_iterator = _sample_parallel_iterator( + samples=samples_df, + chunksize=chunksize, + ent_input_var=self.ent_input_var, + haz_input_var=self.haz_input_var, + ent_fut_input_var=self.ent_fut_input_var, + haz_fut_input_var=self.haz_fut_input_var, + cost_benefit_kwargs=cost_benefit_kwargs + ) + if processes>1: + with mp.Pool(processes=processes) as pool: + LOGGER.info('Using %s CPUs.', processes) + cb_metrics = pool.starmap( + _map_costben_calc, p_iterator + ) + else: + cb_metrics = itertools.starmap( + _map_costben_calc, p_iterator + ) + + #Perform the actual computation + with log_level(level='ERROR', name_prefix='climada'): + return _transpose_chunked_data(cb_metrics) + + +def _map_costben_calc( + sample_chunks, ent_input_var, haz_input_var, + ent_fut_input_var, haz_fut_input_var, cost_benefit_kwargs + ): + """ + Map to compute cost benefit for all parameter samples in parallel - # [1] only the rows of the dataframe passed by pd.DataFrame.iterrows() - haz_samples = param_sample[1][self.haz_input_var.labels].to_dict() - ent_samples = param_sample[1][self.ent_input_var.labels].to_dict() - haz_fut_samples = param_sample[1][self.haz_fut_input_var.labels].to_dict() - ent_fut_samples = param_sample[1][self.ent_fut_input_var.labels].to_dict() + Parameters + ---------- + sample_chunks : pd.DataFrame + Dataframe of the parameter samples + haz_input_var : InputVar + Hazard uncertainty variable or Hazard for the present Hazard + in climada.engine.CostBenefit.calc + ent_input_var : InputVar + Entity uncertainty variable or Entity for the present Entity + in climada.engine.CostBenefit.calc + haz_fut_input_var: InputVar + Hazard uncertainty variable or Hazard for the future Hazard + ent_fut_input_var : InputVar + Entity uncertainty variable or Entity for the future Entity + in climada.engine.CostBenefit.calc + cost_benefit_kwargs : + Keyword arguments passed on to climada.engine.CostBenefit.calc() + + Returns + ------- + list + icost benefit metrics list for all samples containing + imp_meas_present, imp_meas_future, tot_climate_risk, + benefit, cost_ben_ratio - haz = self.haz_input_var.evaluate(**haz_samples) - ent = self.ent_input_var.evaluate(**ent_samples) - haz_fut = self.haz_fut_input_var.evaluate(**haz_fut_samples) - ent_fut = self.ent_fut_input_var.evaluate(**ent_fut_samples) + """ + + uncertainty_values = [] + for _, sample in sample_chunks.iterrows(): + haz_samples = sample[haz_input_var.labels].to_dict() + ent_samples = sample[ent_input_var.labels].to_dict() + haz_fut_samples = sample[haz_fut_input_var.labels].to_dict() + ent_fut_samples = sample[ent_fut_input_var.labels].to_dict() + + haz = haz_input_var.evaluate(**haz_samples) + ent = ent_input_var.evaluate(**ent_samples) + haz_fut = haz_fut_input_var.evaluate(**haz_fut_samples) + ent_fut = ent_fut_input_var.evaluate(**ent_fut_samples) cb = CostBenefit() ent.exposures.assign_centroids(haz, overwrite=False) if ent_fut: ent_fut.exposures.assign_centroids(haz_fut if haz_fut else haz, overwrite=False) cb.calc(hazard=haz, entity=ent, haz_future=haz_fut, ent_future=ent_fut, - save_imp=False, assign_centroids=False, **kwargs) - + save_imp=False, assign_centroids=False, **cost_benefit_kwargs) # Extract from climada.impact the chosen metrics - return [cb.imp_meas_present, - cb.imp_meas_future, - cb.tot_climate_risk, - cb.benefit, - cb.cost_ben_ratio - ] + uncertainty_values.append([ + cb.imp_meas_present, + cb.imp_meas_future, + cb.tot_climate_risk, + cb.benefit, + cb.cost_ben_ratio + ]) + + # Transpose list + return list(zip(*uncertainty_values)) diff --git a/climada/engine/unsequa/calc_impact.py b/climada/engine/unsequa/calc_impact.py index 0ac099607..a82f5cae5 100644 --- a/climada/engine/unsequa/calc_impact.py +++ b/climada/engine/unsequa/calc_impact.py @@ -24,19 +24,27 @@ import logging import time from typing import Union +import itertools import pandas as pd import numpy as np +import pathos.multiprocessing as mp +# use pathos.multiprocess fork of multiprocessing for compatibility +# wiht notebooks and other environments https://stackoverflow.com/a/65001152/12454103 from climada.engine import ImpactCalc from climada.engine.unsequa import Calc, InputVar, UncImpactOutput +from climada.engine.unsequa.calc_base import ( + _sample_parallel_iterator, + _multiprocess_chunksize, + _transpose_chunked_data, +) from climada.entity import Exposures, ImpactFuncSet from climada.hazard import Hazard from climada.util import log_level LOGGER = logging.getLogger(__name__) - class CalcImpact(Calc): """ Impact uncertainty caclulation class. @@ -54,18 +62,18 @@ class CalcImpact(Calc): Compute eai_exp or not value_unit : str Unit of the exposures value - exp_input_var : climada.engine.uncertainty.input_var.InputVar + exp_input_var : InputVar or Exposures Exposure uncertainty variable - impf_input_var : climada.engine.uncertainty.input_var.InputVar + impf_input_var : InputVar if ImpactFuncSet Impact function set uncertainty variable - haz_input_var: climada.engine.uncertainty.input_var.InputVar + haz_input_var: InputVar or Hazard Hazard uncertainty variable _input_var_names : tuple(str) Names of the required uncertainty input variables ('exp_input_var', 'impf_input_var', 'haz_input_var') _metric_names : tuple(str) Names of the impact output metrics - ('aai_agg', 'freq_curve', 'at_event', 'eai_exp', 'tot_value') + ('aai_agg', 'freq_curve', 'at_event', 'eai_exp') """ _input_var_names = ( @@ -79,8 +87,7 @@ class CalcImpact(Calc): 'aai_agg', 'freq_curve', 'at_event', - 'eai_exp', - 'tot_value', + 'eai_exp' ) """Names of the cost benefit output metrics""" @@ -120,7 +127,8 @@ def uncertainty(self, rp=None, calc_eai_exp=False, calc_at_event=False, - pool=None + processes=1, + chunksize=None ): """ Computes the impact for each sample in unc_data.sample_df. @@ -140,7 +148,6 @@ def uncertainty(self, unc_output.freq_curve_unc_df unc_output.eai_exp_unc_df unc_output.at_event_unc_df - unc_output.tot_value_unc_df unc_output.unit Parameters @@ -156,9 +163,13 @@ def uncertainty(self, calc_at_event : boolean, optional Toggle computation of the impact for each event. The default is False. - pool : pathos.pools.ProcessPool, optional - Pool of CPUs for parralel computations. - The default is None. + processes : int, optional + Number of CPUs to use for parralel computations. + The default is 1 (not parallel) + chunksize: int, optional + Size of the sample chunks for parallel processing. + Default is equal to the number of samples divided by the + number of processes. Returns ------- @@ -172,9 +183,15 @@ def uncertainty(self, If no sampling parameters defined, the distribution cannot be computed. + Notes + ----- + Parallelization logic is described in the base class + here :py:class:`~climada.engine.unsequa.calc_base.Calc` + See Also -------- - climada.engine.impact: Compute risk. + climada.engine.impact: + compute impact and risk. """ @@ -182,8 +199,14 @@ def uncertainty(self, raise ValueError("No sample was found. Please create one first" "using UncImpact.make_sample(N)") + + # copy may not be needed, but is kept to prevent potential + # data corruption issues. The computational cost should be + # minimal as only a list of floats is copied.''' samples_df = unc_sample.samples_df.copy(deep=True) + if chunksize is None: + chunksize = _multiprocess_chunksize(samples_df, processes) unit = self.value_unit if rp is None: @@ -193,32 +216,22 @@ def uncertainty(self, self.calc_eai_exp = calc_eai_exp self.calc_at_event = calc_at_event + one_sample = samples_df.iloc[0:1] start = time.time() - one_sample = samples_df.iloc[0:1].iterrows() - imp_metrics = map(self._map_impact_calc, one_sample) - [aai_agg_list, freq_curve_list, - eai_exp_list, at_event_list, tot_value_list] = list(zip(*imp_metrics)) + self._compute_imp_metrics( + one_sample, chunksize=1, processes=1 + ) elapsed_time = (time.time() - start) - self.est_comp_time(unc_sample.n_samples, elapsed_time, pool) - - #Compute impact distributions - with log_level(level='ERROR', name_prefix='climada'): - if pool: - LOGGER.info('Using %s CPUs.', pool.ncpus) - chunksize = max(min(unc_sample.n_samples // pool.ncpus, 100), 1) - imp_metrics = pool.map(self._map_impact_calc, - samples_df.iterrows(), - chunksize=chunksize) - - else: - imp_metrics = map(self._map_impact_calc, - samples_df.iterrows()) + self.est_comp_time(unc_sample.n_samples, elapsed_time, processes) - #Perform the actual computation - with log_level(level='ERROR', name_prefix='climada'): - [aai_agg_list, freq_curve_list, - eai_exp_list, at_event_list, - tot_value_list] = list(zip(*imp_metrics)) + [ + aai_agg_list, + freq_curve_list, + eai_exp_list, + at_event_list + ] = self._compute_imp_metrics( + samples_df, chunksize=chunksize, processes=processes + ) # Assign computed impact distribution data to self aai_agg_unc_df = pd.DataFrame(aai_agg_list, @@ -226,17 +239,8 @@ def uncertainty(self, freq_curve_unc_df = pd.DataFrame(freq_curve_list, columns=['rp' + str(n) for n in rp]) eai_exp_unc_df = pd.DataFrame(eai_exp_list) - # Setting to sparse dataframes is not compatible with .to_hdf5 - # if np.count_nonzero(df_eai_exp.to_numpy()) / df_eai_exp.size < 0.5: - # df_eai_exp = df_eai_exp.astype(pd.SparseDtype("float", 0.0)) - #eai_exp_unc_df = df_eai_exp + # Note: sparse dataframes are not used as they are not nativel y compatible with .to_hdf5 at_event_unc_df = pd.DataFrame(at_event_list) - # Setting to sparse dataframes is not compatible with .to_hdf5 - # if np.count_nonzero(df_at_event.to_numpy()) / df_at_event.size < 0.5: - # df_at_event = df_at_event.astype(pd.SparseDtype("float", 0.0)) - #at_event_unc_df = df_at_event - tot_value_unc_df = pd.DataFrame(tot_value_list, - columns = ['tot_value']) if calc_eai_exp: exp = self.exp_input_var.evaluate() @@ -250,53 +254,113 @@ def uncertainty(self, freq_curve_unc_df=freq_curve_unc_df, eai_exp_unc_df=eai_exp_unc_df, at_event_unc_df=at_event_unc_df, - tot_value_unc_df=tot_value_unc_df, coord_df=coord_df ) - - def _map_impact_calc(self, sample_iterrows): - """ - Map to compute impact for all parameter samples in parrallel + def _compute_imp_metrics(self, samples_df, chunksize, processes): + """Compute the uncertainty metrics Parameters ---------- - sample_iterrows : pd.DataFrame.iterrows() - Generator of the parameter samples + samples_df : pd.DataFrame + dataframe of input parameter samples + chunksize : int + size of the samples chunks + processes : int + number of processes to use Returns ------- - : list - impact metrics list for all samples containing aai_agg, rp_curve, - eai_exp (np.array([]) if self.calc_eai_exp=False) and at_event - (np.array([]) if self.calc_at_event=False). - + list + values of impact metrics per sample """ + #Compute impact distributions + with log_level(level='ERROR', name_prefix='climada'): + p_iterator = _sample_parallel_iterator( + samples=samples_df, + chunksize=chunksize, + exp_input_var=self.exp_input_var, + impf_input_var=self.impf_input_var, + haz_input_var=self.haz_input_var, + rp=self.rp, + calc_eai_exp=self.calc_eai_exp, + calc_at_event=self.calc_at_event, + ) + if processes > 1: + with mp.Pool(processes=processes) as pool: + LOGGER.info('Using %s CPUs.', processes) + imp_metrics = pool.starmap( + _map_impact_calc, p_iterator + ) + else: + imp_metrics = itertools.starmap( + _map_impact_calc, p_iterator + ) + + #Perform the actual computation + with log_level(level='ERROR', name_prefix='climada'): + return _transpose_chunked_data(imp_metrics) - # [1] only the rows of the dataframe passed by pd.DataFrame.iterrows() - exp_samples = sample_iterrows[1][self.exp_input_var.labels].to_dict() - impf_samples = sample_iterrows[1][self.impf_input_var.labels].to_dict() - haz_samples = sample_iterrows[1][self.haz_input_var.labels].to_dict() - exp = self.exp_input_var.evaluate(**exp_samples) - impf = self.impf_input_var.evaluate(**impf_samples) - haz = self.haz_input_var.evaluate(**haz_samples) +def _map_impact_calc( + sample_chunks, exp_input_var, impf_input_var, haz_input_var, + rp, calc_eai_exp, calc_at_event + ): + """ + Map to compute impact for all parameter samples in parallel + + Parameters + ---------- + sample_chunks : pd.DataFrame + Dataframe of the parameter samples + exp_input_var : InputVar or Exposures + Exposure uncertainty variable + impf_input_var : InputVar if ImpactFuncSet + Impact function set uncertainty variable + haz_input_var: InputVar or Hazard + Hazard uncertainty variable + rp : list(int) + List of the chosen return periods. + calc_eai_exp : bool + Compute eai_exp or not + calc_at_event : bool + Compute eai_exp or not + + Returns + ------- + : list + impact metrics list for all samples containing aai_agg, rp_curve, + eai_exp (np.array([]) if self.calc_eai_exp=False) and at_event + (np.array([]) if self.calc_at_event=False). + + """ + uncertainty_values = [] + for _, sample in sample_chunks.iterrows(): + exp_samples = sample[exp_input_var.labels].to_dict() + impf_samples = sample[impf_input_var.labels].to_dict() + haz_samples = sample[haz_input_var.labels].to_dict() + + exp = exp_input_var.evaluate(**exp_samples) + impf = impf_input_var.evaluate(**impf_samples) + haz = haz_input_var.evaluate(**haz_samples) exp.assign_centroids(haz, overwrite=False) imp = ImpactCalc(exposures=exp, impfset=impf, hazard=haz)\ - .impact(assign_centroids=False, save_mat=False) + .impact(assign_centroids=False, save_mat=False) # Extract from climada.impact the chosen metrics - freq_curve = imp.calc_freq_curve(self.rp).impact + freq_curve = imp.calc_freq_curve(rp).impact - if self.calc_eai_exp: + if calc_eai_exp: eai_exp = imp.eai_exp else: eai_exp = np.array([]) - if self.calc_at_event: + if calc_at_event: at_event= imp.at_event else: at_event = np.array([]) - return [imp.aai_agg, freq_curve, eai_exp, at_event, imp.tot_value] + uncertainty_values.append([imp.aai_agg, freq_curve, eai_exp, at_event]) + + return list(zip(*uncertainty_values)) diff --git a/climada/engine/unsequa/input_var.py b/climada/engine/unsequa/input_var.py index 2e31da657..b0ca91ff6 100644 --- a/climada/engine/unsequa/input_var.py +++ b/climada/engine/unsequa/input_var.py @@ -229,6 +229,7 @@ def var_to_inputvar(var): return InputVar(func=lambda: var, distr_dict={}) + @staticmethod def haz(haz_list, n_ev=None, bounds_int=None, bounds_frac=None, bounds_freq=None): """ diff --git a/climada/engine/unsequa/test/test_unsequa.py b/climada/engine/unsequa/test/test_unsequa.py index 501c37e9d..cd1912a18 100755 --- a/climada/engine/unsequa/test/test_unsequa.py +++ b/climada/engine/unsequa/test/test_unsequa.py @@ -28,7 +28,6 @@ import matplotlib.pyplot as plt import scipy as sp -from pathos.pools import ProcessPool as Pool from tables.exceptions import HDF5ExtError from climada.entity import ImpactFunc, ImpactFuncSet @@ -37,7 +36,7 @@ from climada.hazard import Hazard from climada.engine.unsequa import InputVar, CalcImpact, UncOutput, CalcCostBenefit -from climada.util.constants import (EXP_DEMO_H5, HAZ_DEMO_H5, ENT_DEMO_TODAY, ENT_DEMO_FUTURE, +from climada.util.constants import (EXP_DEMO_H5, HAZ_DEMO_H5, ENT_DEMO_TODAY, ENT_DEMO_FUTURE, TEST_UNC_OUTPUT_IMPACT, TEST_UNC_OUTPUT_COSTBEN) from climada.util.api_client import Client @@ -344,7 +343,7 @@ def test_init_pass(self): ) self.assertTupleEqual( unc_calc._metric_names, - ('aai_agg', 'freq_curve', 'at_event', 'eai_exp', 'tot_value') + ('aai_agg', 'freq_curve', 'at_event', 'eai_exp') ) self.assertEqual(unc_calc.value_unit, exp_iv.evaluate().value_unit) self.assertTrue( @@ -409,10 +408,6 @@ def test_calc_uncertainty_pass(self): unc_data.aai_agg_unc_df.size, unc_data.n_samples ) - self.assertEqual( - unc_data.tot_value_unc_df.size, - unc_data.n_samples - ) self.assertEqual( unc_data.freq_curve_unc_df.size, @@ -429,14 +424,9 @@ def test_calc_uncertainty_pool_pass(self): unc_calc = CalcImpact(exp_unc, impf_unc, haz) unc_data = unc_calc.make_sample(N=2) - pool = Pool(nodes=2) - try: - unc_data = unc_calc.uncertainty(unc_data, calc_eai_exp=False, - calc_at_event=False, pool=pool) - finally: - pool.close() - pool.join() - pool.clear() + unc_data = unc_calc.uncertainty( + unc_data, calc_eai_exp=False, calc_at_event=False, processes=4 + ) self.assertEqual(unc_data.unit, exp_dem().value_unit) self.assertListEqual(unc_calc.rp, [5, 10, 20, 50, 100, 250]) @@ -447,10 +437,6 @@ def test_calc_uncertainty_pool_pass(self): unc_data.aai_agg_unc_df.size, unc_data.n_samples ) - self.assertEqual( - unc_data.tot_value_unc_df.size, - unc_data.n_samples - ) self.assertEqual( unc_data.freq_curve_unc_df.size, @@ -667,15 +653,9 @@ def test_calc_uncertainty_pool_pass(self): ent_iv, _ = make_costben_iv() _, _, haz_iv = make_input_vars() unc_calc = CalcCostBenefit(haz_iv, ent_iv) - unc_data = unc_calc.make_sample( N=2) + unc_data = unc_calc.make_sample(N=2) - pool = Pool(nodes=2) - try: - unc_data = unc_calc.uncertainty(unc_data, pool=pool) - finally: - pool.close() - pool.join() - pool.clear() + unc_data = unc_calc.uncertainty(unc_data, processes=2) self.assertEqual(unc_data.unit, ent_dem().exposures.value_unit) diff --git a/climada/engine/unsequa/unc_output.py b/climada/engine/unsequa/unc_output.py index 08e0a0bc4..d80e0f5b0 100644 --- a/climada/engine/unsequa/unc_output.py +++ b/climada/engine/unsequa/unc_output.py @@ -64,14 +64,6 @@ 'ff' : ['ff'], } -plt.style.use('seaborn-white') -params = {'legend.fontsize': 'x-large', - 'axes.labelsize': 'x-large', - 'axes.titlesize':'x-large', - 'xtick.labelsize':'x-large', - 'ytick.labelsize':'x-large'} -mpl.rcParams.update(params) - class UncOutput(): """ @@ -120,6 +112,24 @@ def __init__(self, samples_df, unit=None): self.samples_df = samples_df self.unit = unit + def order_samples(self, by_parameters): + """ + Function to sort the samples dataframe. + + Note: the unc_output.samples_df is ordered inplace. + + Parameters + ---------- + by_parameters : list[string] + List of the uncertainty parameters to sort by (ordering in list is kept) + + Returns + ------- + None. + + """ + self.samples_df.sort_values(by=by_parameters, inplace=True, axis=0) + def get_samples_df(self): return getattr(self, 'samples_df') @@ -649,7 +659,7 @@ def plot_rp_uncertainty(self, orig_list=None, figsize=(16, 6), axes=None): prop_cycle = plt.rcParams['axes.prop_cycle'] colors = prop_cycle.by_key()['color'] - for n, (_name, values) in enumerate(unc_df.iteritems()): + for n, (_name, values) in enumerate(unc_df.items()): values = u_cmv(values, m_unit, n_sig_dig=4) count, division = np.histogram(values, bins=100) count = count / count.max() @@ -1092,7 +1102,7 @@ class UncImpactOutput(UncOutput): """Extension of UncOutput specific for CalcImpact, returned by the uncertainty() method. """ def __init__(self, samples_df, unit, aai_agg_unc_df, freq_curve_unc_df, eai_exp_unc_df, - at_event_unc_df, tot_value_unc_df, coord_df): + at_event_unc_df, coord_df): """Constructor Uncertainty output values from impact.calc for each sample @@ -1115,9 +1125,6 @@ def __init__(self, samples_df, unit, aai_agg_unc_df, freq_curve_unc_df, eai_exp_ at_event_unc_df : pandas.DataFrame Each row contains the values of at_event for one sample (row of samples_df) - tot_value_unc_df : pandas.DataFrame - Each row contains the value of tot_value for one sample (row of - samples_df) coord_df : pandas.DataFrame Coordinates of the exposure """ @@ -1130,8 +1137,6 @@ def __init__(self, samples_df, unit, aai_agg_unc_df, freq_curve_unc_df, eai_exp_ self.eai_exp_sens_df = None self.at_event_unc_df = at_event_unc_df self.at_event_sens_df = None - self.tot_value_unc_df = tot_value_unc_df - self.tot_value_sens_df = None self.coord_df = coord_df diff --git a/doc/tutorial/climada_engine_unsequa.ipynb b/doc/tutorial/climada_engine_unsequa.ipynb index 142274328..b5db54953 100644 --- a/doc/tutorial/climada_engine_unsequa.ipynb +++ b/doc/tutorial/climada_engine_unsequa.ipynb @@ -20,23 +20,8 @@ "toc": true }, "source": [ - "\n", - "## Contents\n", - "\n", - "- [Uncertainty and sensitivity analysis](#Uncertainty-and-sensitivity-analysis)\n", - "- [Unsequa Module Structure](#Unsequa-Module-Structure)\n", - "- [InputVar](#InputVar)\n", - " - [Example - custom continuous uncertainty parameter](#Example---custom-continuous-uncertainty-parameter)\n", - " - [ Example - custom categorical uncertainty parameter](#Example---custom-categorical-uncertainty-parameter)\n", - "- [UncOutput](#UncOutput)\n", - " - [Example from file](#Example-from-file)\n", - "- [CalcImpact](#CalcImpact)\n", - " - [Set the InputVars](#Set-the-Inputvars)\n", - " - [Compute uncertainty and sensitivity using default methods](#Compute-uncertainty-and-sensitivity-using-default-methods)\n", - " - [A few non-default parameters](#A-few-non-default-parameters)\n", - "- [CalcCostBenefit](#CalcCostBenefit)\n", - " - [Set the InputVars](#Set-the-Input-Vars)\n", - " - [Compute cost benefit uncertainty and sensitivity using default methods](#Compute-cost-benefit-uncertainty-and-sensitivity-using-default-methods)" + "

Table of Contents

\n", + "
" ] }, { @@ -166,8 +151,8 @@ "execution_count": 1, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:09:45.518273Z", - "start_time": "2022-01-10T20:09:42.210411Z" + "end_time": "2023-08-03T11:57:46.604222Z", + "start_time": "2023-08-03T11:57:41.913838Z" } }, "outputs": [ @@ -175,7 +160,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2022-01-10 21:09:45,445 - climada.entity.exposures.base - INFO - Reading /Users/ckropf/climada/demo/data/exp_demo_today.h5\n" + "2023-08-03 13:57:46,512 - climada.entity.exposures.base - INFO - Reading /Users/ckropf/climada/demo/data/exp_demo_today.h5\n" ] } ], @@ -194,8 +179,8 @@ "execution_count": 2, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:09:45.523530Z", - "start_time": "2022-01-10T20:09:45.520287Z" + "end_time": "2023-08-03T11:57:46.614953Z", + "start_time": "2023-08-03T11:57:46.610164Z" } }, "outputs": [], @@ -213,8 +198,8 @@ "execution_count": 3, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:09:46.006543Z", - "start_time": "2022-01-10T20:09:45.525249Z" + "end_time": "2023-08-03T11:57:46.645171Z", + "start_time": "2023-08-03T11:57:46.619390Z" } }, "outputs": [], @@ -234,8 +219,8 @@ "execution_count": 4, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:09:46.013806Z", - "start_time": "2022-01-10T20:09:46.009105Z" + "end_time": "2023-08-03T11:57:46.659207Z", + "start_time": "2023-08-03T11:57:46.650628Z" }, "scrolled": true }, @@ -261,8 +246,8 @@ "execution_count": 5, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:09:46.022947Z", - "start_time": "2022-01-10T20:09:46.015478Z" + "end_time": "2023-08-03T11:57:46.676106Z", + "start_time": "2023-08-03T11:57:46.662971Z" } }, "outputs": [ @@ -285,16 +270,16 @@ "execution_count": 6, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:09:46.122758Z", - "start_time": "2022-01-10T20:09:46.024177Z" + "end_time": "2023-08-03T11:57:46.896851Z", + "start_time": "2023-08-03T11:57:46.678120Z" } }, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAT4AAADCCAYAAADQH67mAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAASq0lEQVR4nO3da0yT1wPH8R8XEbqiIHJZRJ0SsSITGFCNTv0rb7Ys6syiBpQsXmLcIolX6FCnYr1Np1GZ9zk2dG7qnHNumi0sM7IYRRARBANeEGUqKlUI0BY4/xeLjSjSYh8scH6fxBc8PX04p2d895RCcRJCCBARScTZ0RMgInrdGD4ikg7DR0TSYfiISDqujvrEdXV1yM/Ph6+vL1xcXBw1DSLqZBoaGlBRUYHQ0FC4u7s3O8Zh4cvPz8fUqVMd9emJqJM7cOAAoqKimr3NYeHz9fUF8N/kAgICHDUNIupk7t69i6lTp1oa0xyHhe/p09uAgAAEBgY6ahpE1Em19C00vrhBRNJh+IhIOgwfEUmH4SMi6TB8RCQdho+IpMPwEZF0GD4ikg7DR0TSYfiISDoMHxFJh+EjIukwfEQkHYaPiKTD8BERjh07hkGDBuHy5csAgKqqKowePRrr16+3el+z2YyNGzdixIgRiIyMxMyZM3H9+nUAwM2bNxEWFoZvvvnGMn7OnDmYPHkyGhoasG3bNsyZMwd6vR4REREYNWoU0tLS2mSNz7Lp/fhycnIQGxvb5JhKpcLFixdfGHv37l2sWbMG586dg6urK0aPHg2dTodu3bopM2OiDuan7Ns4dKHstX/eyVG98VGkbe91+eGHH+LkyZNYvnw5jhw5gjVr1kCtVmP+/PlW77t161acPn0amzdvho+PDw4ePIj4+HicOnUKb731FhISErB161a8//77OHv2LM6ePYtjx45Z3i8vMzMTo0ePxqFDh1BQUIDPP/8c3bt3x8SJE+1af0tsCt+1a9cQHByMffv2WY45O794sdjQ0IBPP/0UPXr0wHfffQej0YgVK1YgKSkJO3bsUG7WRKS4lStX4oMPPkBiYiJOnTqFH3/8EW5ubi3ep66uDmlpaUhLS0NkZCQAYOnSpThz5gx++eUXTJs2DdOnT8epU6ewbNkyXLp0CYsWLUK/fv0s53B3d8f69euhVqsxYMAAFBQU4Pvvv3d8+IqLizFgwIAW38oZAK5cuYKCggJkZmZaxi5ZsgRxcXF48uQJr/pISh9FBtp85eVIAQEBWLBgAVJSUjB79mwMHjzY6n1u3boFk8mEmTNnwsnJyXLcaDTixo0bAP57J+Q1a9ZgwoQJCAsLw7Rp05qcY9CgQVCr1ZaPhwwZgsOHDyu0qubZFL6SkhK88847VscFBgZiz549TQL59MEwGo2vOEUiel2Kiorg4uKCc+fOobGxsdlnds9qaGgAAOzbtw8+Pj5Nbns2ZlevXoWTkxNKSkpw//59+Pv7W257/i3ibfm89rLp7MXFxSgqKsL48eMxatQoLFy4EBUVFS+M8/b2xqhRo5ocS0tLQ9++fa1eLRKRY509exZHjx7Frl27UFpaatOLDH369IGrqysePXqEvn37om/fvujTpw+2bduGvLw8AMCjR4+wevVqJCYmQqPRYPny5U3OUVxcDJPJZPn48uXL0Gg0iq7teVbDV1VVhfv376O+vh56vR4bNmzAnTt3MGvWLJjN5hbvu3v3bvzxxx9ITk5WbMJEpLza2losXboUsbGxGDlyJBYuXIgtW7agtLS0xfu98cYbiI2NxerVq3H69GmUlpYiJSUFGRkZCAoKAgCkpKTgzTffRHx8PFasWIHMzEwcP37cco4HDx5g5cqVuH79On7++WccOnQIH3/8cZuuF8IGVVVVor6+3vJxRUWF0Gg04p9//nnpfVJTU0VwcLD49ttvm729rKxMBAcHi7KyMlumQERtSK/Xi3fffVdUVVUJIYRobGwUU6ZMEVOnThWNjY0t3tdoNIq1a9eK4cOHiyFDhojJkyeLrKwsIYQQf/75p9BoNOLSpUuW8Rs3bhRarVY8ePBAbN26VYwbN06sWLFChIWFiZiYGHHkyBG71mJLW2wKX3OGDRsmfvrpp2Zv0+v1YuDAgeLAgQN2TY6IOretW7eKiRMnKnpOW9pi9alubm4uIiIiUF5ebjlWXl6OyspKy6Xss7Zs2YL9+/dj3bp1iIuLU/bylIhIAVZf1Q0JCYGfnx+Sk5Oh0+lgMpmg1+uh1WoRFhYGg8EAAPDy8sKVK1ewc+dOzJgxAyNGjGjyAoi3tzdcXR3298uJ6BUMHTq0yQsPz9PpdJgyZcprnJEynIQQwtqgsrIyrF27FllZWRBCYOzYsUhOToaXlxfi4+MBAOnp6di8eTN27tzZ7Dl+/fVXBAcHWz6+ffs2YmJikJGRgcDA9v8zTkQyKisrQ2Nj40tv79GjBzw9PV/jjKyzpS02ha8tMHxE1BZsaQvfpICIpMPwEZF0GD4ikg7DR0TSYfiISDoMHxFJh+EjIukwfEQkHYaPiKTD8BGRdBg+IpIOw0dE0mH4iEg6DB8RSYfhIyLpMHxEJB2Gj4ikw/ARkXQYPiKSDsNHRNJh+IhIOgwfEUmH4SMi6TB8RCQdho+IpMPwEZF0GD4ikg7DR0TSYfiISDoMHxFJh+EjIukwfEQkHYaPiKTD8BGRdBg+IpIOw0dE0mH4iEg6DB8RSYfhIyLpMHxEJB2Gj4ikw/ARkXQYPiKSDsNHRNJh+IhIOgwfEUmH4SMi6bjaMignJwexsbFNjqlUKly8ePGFsfX19Vi3bh1OnDiBhoYGTJgwAYmJiXBzc1NmxkREdrIpfNeuXUNwcDD27dtnOebs3PzF4qZNm3DmzBns2LEDZrMZOp0OXbp0QVJSkjIzJiKyk01PdYuLizFgwAD4+vpa/vn4+Lwwzmg04uDBg0hKSkJERAS0Wi2WLl2KH374AXV1dYpPnojoVdgUvpKSEvTv39/quMLCQtTU1CA6OtpyTKvVoqamBoWFha8+SyIiBdn0VLe4uBgqlQrjx4+HwWBAdHQ0dDodfH19m4y7d+8eVCoVPD09LcfUajU8PDxw9+5duyb6U/ZtHLpQZtc5iKjjmRzVGx9FBip6TqtXfFVVVbh//z7q6+uh1+uxYcMG3LlzB7NmzYLZbG4ytra2ttkXMdzc3GAymZSbNRGRHaxe8Xl6eiI7OxseHh5wcXEBAKSmpmLkyJHIysrC8OHDLWPd3d2bDZzJZIKHh4ddE/0oMlDx6hORnGz6Hp9arbZEDwB69uwJLy+vF56+BgQEoKamBtXV1ZZj1dXVqK2thb+/v0JTJiKyj9Xw5ebmIiIiAuXl5ZZj5eXlqKysRFBQUJOxGo0GKpUK2dnZlmPnz5+HSqWCRqNRcNpERK/OavhCQkLg5+eH5ORkFBUVIS8vD/PmzYNWq0VYWBgMBgMMBgOA/57qTpo0CSkpKbhw4QKysrKg1+sRFxeHrl27tvVaiIhsYvV7fG5ubti7dy/Wrl2L+Ph4CCEwduxYJCcnAwASEhIAAOnp6QCARYsWoa6uDnPmzIGLiwvGjRuH+fPnt+ESiIhax0kIIRzxiW/fvo2YmBhkZGQgMJAvWhCRMmxpC9+kgIikw/ARkXQYPiKSDsNHRNJh+IhIOgwfEUmH4SMi6TB8RCQdho+IpMPwEZF0GD4ikg7DR0TSYfiISDoMHxFJh+EjIukwfEQkHYaPiKTD8BGRdBg+IpIOw0dE0mH4iEg6DB8RSYfhIyLpMHxEJB2Gj4ikw/ARkXQYPiKSDsNHRNJh+IhIOgwfEUmH4SMi6TB8RCQdho+IpMPwEZF0GD4ikg7DR0TSYfiISDoMHxFJh+EjIukwfEQkHYaPiKTD8BGRdBg+IpIOw0dE0mH4iEg6DB8RSYfhIyLpMHxEJJ1WhW/Tpk0YO3bsS2+vrq5GcnIyhg0bhmHDhkGn0+Hx48d2T5KISEk2hy8/Px9ff/11i2NSUlJw9epV7N27F3v37sXVq1exdOlSuydJRKQkm8JnMpnw2WefISIiosVxf/31F6ZPn47Q0FCEhoZixowZyMzMVGSiRERKsSl8X331Ffr06YP33nuvxXHdu3fHiRMnUFVVherqavz22294++23FZkoEZFSrIavoKAAhw4dwooVK6yebOXKlcjLy0N0dDSio6NRUlKCL7/8Uol5EhEppsXwmUwm6HQ6JCYmwtfX1+rJSktLERQUhLS0NKSlpaFbt25YvHgxhBCKTZiIyF6uLd24fft2+Pv7Y+LEiVZPVFpailWrVuHkyZPo168fAGDbtm2IiYnB+fPnMXToUGVmTERkpxbDd/z4cVRUVFhe1DCbzaivr0dERAT27NmDqKgoy9iCggK4ublZogcAvXr1gre3N8rKyhg+Imo3Wgxfeno66uvrLR8fP34chw8fRnp6Ovz9/ZuM9fPzg9FoxI0bNyzxe/DgAQwGA/r06dMGUyciejUthq9Xr15NPvb29oarqyv69u0LADAYDAAALy8vhIeHY/DgwUhOTsaSJUvg7OyMdevWITQ0tMmVIRGRo9n1K2sJCQlISEgAALi6umL37t3o1asXZs+ejZkzZ8LPzw+7du2CszN/M46I2g8n4aCXXG/fvo2YmBhkZGQgMDDQEVMgok7IlrbwUoyIpMPwEZF0GD4ikg7DR0TSYfiISDoMHxFJh+EjIukwfEQkHYaPiKTD8BGRdBg+IpIOw0dE0mH4iEg6Lb4fX1tqaGgAANy9e9dRUyCiTuhpU542pjkOC19FRQUAYOrUqY6aAhF1YhUVFZY3TX6ew96Pr66uDvn5+fD19YWLi4sjpkBEnVBDQwMqKioQGhoKd3f3Zsc4LHxERI7CFzeISDoMHxFJx6Hhq6+vh16vx7BhwxAdHQ29Xg+TydTsWIPBgEWLFmHo0KEYOXIkUlNT0djY+Ernag+UXHtOTg4GDhzY5N/Tv4Xc3gkhMGvWLOzfv/+lY6w9Vh1t759SYu2dfe+tjX3VvXfYq7oAsGnTJpw5cwY7duyA2WyGTqdDly5dkJSU9MLYhIQEPHr0CNu3b0eXLl2wZMkSGI1GLFy4sNXnag+UXPu1a9cQHByMffv2We7TEf6yXWNjI/R6Pc6cOYP//e9/Lx1n7bHqaHsPKLf2zr731sa+8t4LB6mrqxPh4eEiIyPDciwjI0OEh4eL2traJmMLCgpEcHCwKCgosBzLyckRoaGhoqamplXnag+UXLsQQqxevVrMnz//9UxeIbdu3RKxsbFizJgxIioqSqSnpzc7ztpj1dH2Xgjl1i5E5957a2Pt2XuH/a+hsLAQNTU1iI6OthzTarWoqalBYWFhk7GlpaVwd3dHSEiI5digQYNgMpmQn5/fqnO1B0quHQBKSkrQv3//1zN5heTm5iI4OBhHjx6Fp6fnS8dZe6w62t4Dyq0d6Nx7b22sPXvvsKe69+7dg0qlarIYtVoNDw+PF36bo2fPnqirq0NlZSW8vb0BAP/++y8A4OHDh3BycrL5XO2BkmsHgOLiYqhUKowfPx4GgwHR0dHQ6XTw9fV9TStqvXHjxmHcuHFWx1l7rJydnTvU3gPKrR3o3HtvbWxrvo6e57ArvtraWri5ub1w3M3N7YVvToaFhaF3795Yvnw5njx5AoPBgHXr1sHV1RVms7lV52oPlFx7VVUV7t+/b/km74YNG3Dnzh3MmjULZrP5dS2pzVh7rDra3reGtbV19r23xp69d9gVn7u7e7OTM5lM8PDwaHLMzc0NqampWLBgAbRaLTw8PDB37lxcvnwZarUaRqPR5nO1B0qu3dPTE9nZ2fDw8LD8BkxqaipGjhyJrKwsDB8+/LWsqa1Ye6waGxs71N63hrW1d/a9t6Y1X0fPc1j4AgICUFNTg+rqaqjVagBAdXU1amtr4e/v/8J4jUaD33//HQ8fPoRarUZDQwO++OIL9O7dG9XV1a06l6MpuXYAlnM81bNnT3h5ebXbp3qtYe2xEkJ0qL1vDVv+O+nMe29Na7+OnuWwp7oajQYqlQrZ2dmWY+fPn4dKpYJGo2ky9vHjx4iLi8OdO3fg4+ODrl274u+//4avry+CgoJada72QMm15+bmIiIiAuXl5Zb7lJeXo7KyEkFBQa9tTW3F2mPV0fa+NaytrbPvvTX27L3Dwufu7o5JkyYhJSUFFy5cQFZWFvR6PeLi4tC1a1cYDAYYDAYAQPfu3WE0GrF27VrcvHkTmZmZSElJwdy5c+Hk5GT1XO2NkmsPCQmBn58fkpOTUVRUhLy8PMybNw9arRZhYWGOXegrenb91h6rjrb31rRm7Z19762xa+/t/qEcOxiNRrFs2TIRGRkptFqtWLVqlTCbzUIIIaZNmyamTZtmGXvr1i0xY8YMER4eLsaOHfvCz/60dK72SMm137p1S3zyySciKipKREZGisWLF4vKysrXuRy7jBkzpsmanl+/tb3taHv/LHvX3tn3vqWxQrz63vPdWYhIOu3/d1uIiBTG8BGRdBg+IpIOw0dE0mH4iEg6DB8RSYfhIyLpMHxEJJ3/AyECSe5xBvkdAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -308,14 +293,18 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "heading_collapsed": true + }, "source": [ "### Example - custom categorical uncertainty parameter " ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "Suppose we want to test different exponents (m=1,2 ; n=1,2) for the LitPop exposure for the country Switzerland." ] @@ -325,9 +314,10 @@ "execution_count": 7, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:09:46.127975Z", - "start_time": "2022-01-10T20:09:46.124217Z" - } + "end_time": "2023-08-03T11:57:46.904751Z", + "start_time": "2023-08-03T11:57:46.900228Z" + }, + "hidden": true }, "outputs": [], "source": [ @@ -346,38 +336,15 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:09:52.803853Z", - "start_time": "2022-01-10T20:09:46.129406Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2022-02-11 16:29:34,770 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "53.1kKB [00:25, 2.07kKB/s] \n" - ] + "end_time": "2023-08-03T11:57:57.533389Z", + "start_time": "2023-08-03T11:57:46.907556Z" }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2022-02-11 16:30:05,073 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n", - "2022-02-11 16:30:07,529 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n", - "2022-02-11 16:30:10,199 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n" - ] - } - ], + "hidden": true + }, + "outputs": [], "source": [ "# A faster method would be to first create a dictionnary with all the exposures. This however\n", "# requires more memory and precomputation time (here ~3-4mins)\n", @@ -394,12 +361,13 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:09:52.812480Z", - "start_time": "2022-01-10T20:09:52.806391Z" - } + "end_time": "2023-08-03T11:57:57.541937Z", + "start_time": "2023-08-03T11:57:57.535710Z" + }, + "hidden": true }, "outputs": [], "source": [ @@ -417,12 +385,13 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:09:52.821317Z", - "start_time": "2022-01-10T20:09:52.817337Z" - } + "end_time": "2023-08-03T11:57:57.557449Z", + "start_time": "2023-08-03T11:57:57.552753Z" + }, + "hidden": true }, "outputs": [ { @@ -443,26 +412,27 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:09:56.977646Z", - "start_time": "2022-01-10T20:09:52.824533Z" - } + "end_time": "2023-08-03T11:58:02.034735Z", + "start_time": "2023-08-03T11:57:57.560037Z" + }, + "hidden": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "2022-01-10 21:09:52,830 - climada.util.coordinates - INFO - Raster from resolution 0.04166666000000063 to 0.04166666000000063.\n" + "2023-08-03 13:57:57,563 - climada.util.coordinates - INFO - Raster from resolution 0.04166666000000063 to 0.04166666000000063.\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAD5CAYAAAC3f4QDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOy9eZxlVXnu/11rD2equaq7eu5m6GYQwZZGREGNRk0QNQh687uSgThwc6M3TiCtCZNGiQExEoeENBfTqIle9dpRDBcHNFFBQFAbsaWBbui5qqtrOtMe1vr9carq7LX2qa7qsbphP59PQe991l577XG9+32f93mF1lqTIUOGDBkyZMiQ4TkDOdcDyJAhQ4YMGTJkyHB0kRmAGTJkyJAhQ4YMzzFkBmCGDBkyZMiQIcNzDJkBmCFDhgwZMmTI8BxDZgBmyJAhQ4YMGTI8x5AZgBkyZMiQIUOGDM8xHJAB+MlPfpJXvvKVAHz961/nlFNOafn3wAMPpLa99dZbp22/Y8cOAO66667UbxdddNFUH3fccQcve9nLuOKKKxgbGwPg/vvv55RTTmHdunWpfd55551T482QIUOGDBkyZMjQgDvbhhs3bmTdunX09/cDcOGFF3LBBRcYbdauXcvY2BirV69Obf9nf/Zn/OEf/uHUslKKd7zjHaxYsYJFixYB8MQTT3D++edz4403NgfoNoa4bds2vvOd7/C5z32O7373u3zhC1/gXe9611S7W2+9lde+9rUsWbJktoeUIUOGDBkyZMjwnMSsDMAgCFi7di2rV6+e8tbl83ny+fxUm3vuuYf777+fu+66a8poS6JUKlEqlaaW77jjDgYGBrjzzjun1j3++OOsWrWKefPmpbavVCr09PSwatUqtmzZwsaNG43fe3p6uP7667nttttmc0gZMmTIkCFDhgzPWczKAPzMZz7DsmXLOO+887j99ttTv0dRxE033cTll1/O0qVLZ+xvbGyMz33uc7zvfe+jo6Njav3mzZtTXsVJrFq1ivb2ds466ywWLFjA+vXrjd+vvfZarrjiCu666y4uvPDC2RwWAMPDw4yPj8+6fYYMGTJkyJBhbtDW1kZXV1fL3+Z6Pt/f2I5FzGgAPvroo3zlK19hw4YN3H333S3b3H333ezZs4e3ve1ts9rpl7/8ZYrFIpdccsnUujAM2bp1K/fddx/r1q2jXq9zwQUXcOWVV9Le3g7AJz7xCa6++mo6OztxHMfoc82aNVx66aV87GMf4/zzzzcMy+kwPDzMa17zGkZGRmY17gwZMmTIkCHD3KGzs5P/9//+X8rQGh4e5jW/+yJGxsTcDIzpx3asYr8GYBAEXH311Vx11VUtw7KT+NKXvsSb3vQmOjs7Z9yhUop//dd/5Y/+6I+MUPGWLVuIogjXdbnlllvYs2cPN954I+95z3uMBI+enp5p+77yyiv5wQ9+wE033cQNN9ww41jGx8cZGRnhi1/8IgsWLKBWqxlh7QzHB54r1+1rX/saTz75JFdeeeVcD+Ww4Xi/dvV6nU996lMA/Pmf//msPjxbYcOGDTz00EMUCgUuuugizjjjjKnf4jjmM5/5DAMDAwAIIRBC8L73vW9W79wjgeP9uj2XcTxfu127dvHWt76V8fHxlJE1Pj7OyJjgX26NWTC9uXLkxjYAf/zukZZjO1axXwPws5/9LP39/Vx88cXTttm9ezcPPvggH/zgB2e1w0ceeYSdO3fyhje8wVi/cuVK7rvvPrq7uwE47bTT6Onp4dJLL2XLli2sWLFixr47OztZu3YtH/jAB3jjG984q/EAdHV10dvbS71eJ5fLzXq7DMcGnivX7c1vfjO33norvb29cz2Uw4bj/dp94QtfYN68efzlX/4lvu8fdD+XX345l19++bS/X3/99cbyxz/+cR566CHe/OY3H/Q+DwXH+3V7LuN4vna1Wm3GNr19MfMXHIXBWAg1gDNTs2MK+zUAN2zYwMDAwFRWbxiGRFHE6tWrue2221izZg0/+tGPWLhwIWeeeeasdvjDH/6Q1atX09fXl/pt0vibxMknnww0jMzZGIAAF110Ed/4xje45ppruPTSS2e1zTtOfz9u5DNvRS8DW/bOapsMxw6eK9dN5uDEP+3jDaU/nuuhHDYcz9dO+nDi5X1s++Ywl173duO3+oXnMHCWN7WsJdT6Y0N4S0udFuKSesb9vuwHu2hrq/LQ537L+j/990M5hIPG8Xzdnus4nq9d5AZwwv7baDSKmZ+jww3N3IWeDxb7NQDXr19PFEVTyxs2bOCrX/0q69evn5KDefjhh1mzZs2sd/jII49wzjnnpNbfc889/NVf/RX33nsvhUIBaPAPpZSzNv4mcd111/H617/eyDDOkOF4R//LO9DxXI8iwyR61pRQdU0w6hO96iyU25wARpe7xIkom3Y0uhQbBp6bi/Fz4dSyEOC7zfctQKwkQdh8TS/fMk5bZ41HoyWMX7wSgNyIou1rD4LKbo4MGWI0sT76BuDx+PTt1wBcvHixsdzd3Y3ruixfvnxq3aZNm3jNa17Tcvvh4WEcx5lK4phs3ypssWbNGlzXZe3atbz73e9mYGCAa6+9lksuuWTK2Jwtli5dyl/8xV9w0003pY4hQ4bjDW5JsuQPunAKkh13Dc/1cJ7z8LslfS9pp7jEY+/Pyoj2dnZckCP2m5OOlg2jb2rZ0fhtATJhAPa2l1lQGp1alkLT7VdwRLNNNfbYVu5C6YZx2f9onaggcH5/kE7ZcB8+tW0eqza46DDmpMt7EZOGqIZgJGbfzyuMPV4/IuciQ4ZjDWqOPIDqqO/x0DFrIejpsHfv3mmJyO9+97tZvHjxlLBzHMcMDw+3bN/d3c26deu48cYbefOb30wul+Oiiy46aML75Zdfzre+9a2piiEZMhyvWPqmLlSoeepfBlHBXI/muYuu5xfoXl3AKUjCkZjt3xqhuj3E6W+feePDhF0v9DjpP+osvzdg6ytNIn/vOUUAnvzCINKTeO2S7tUl+n+nnfkvb2dsc50992bvwwzPbig0cWYAzgoHZABedtllXHbZZca6e++9d9r2tlaf4zj85je/mbb9qaeeyh133HEgQ+Lcc89l06ZNqfWu6/LNb37zgPrKkOFYhFOQ7PrBSGb8zSH6f6ed9pU5Rn5TY+/PxlEzc9GPCKKi5KnfzXHi/6uT3xujHEHHeJ1cn6TrzCLhaIyqgaopojFFdUdD4qrrrAI9ZxdpO7GX3d8bpbw1nGFPGTIcnwi1IpyDEHCon2UcwAwZMsw9VKjJ97lUt2WT9lGHEMhcjtKKHMOPhQw9pEAWkaXmy14U8mgBBgfcngummRtkItwrhTbCv5NQ1sRSa3cIC4IVP2h8EZzIbnhdCSEFuW4X2dkOkemPGN0MlT01ll5YYOHvdTLyWMTgT8bRkck5zJDheIdmbrxxR9/kPHRkBmCGDMc4orIi3+8B1bkeynMObv98nnnrSbTVd9J9RpVfvOR5xHmIc4nXvQDlWq9/qdHJjF9Ho5UwJqacG9GXKxubFWRgGIWhchit5VGJ7screZ4+u6mHqpVAlxOv8rPAqUhkaBqOz9+zC1EZZ7BQZMvvdNHmurjff2jW58I4PK/hVZS+IBqPCccU4WhMNHo8BsIyPJsQz1EI+FmXBJIhQ4a5x/hTdbrPKlJY4mVewKMNxyFsgwGvwLzhccI2TVzUqKQBqEHWTWNrRo/gBCRJD6AyjL9JxEqgE15AFUt0nOhQgNtp8gMizyUOTY2ZJ9x25j9RpiOoEZdi4px/wBOA1ylZ/Pou+hZ3MzQAOtJIVyAcYUraKFCxRkcaFTT+4ppCBbqlq6S+N2LfI9kHToZDR6wbf3Ox3+MNmQGYIcMxjqEHKhQWeiy+sBMVaJ7+2j6isczTcjRx4tg+AF4wuIMdXW1sn9c2623dKKKzUqOzUqGtGlGoxbiRQrQpWO7BqhAOXkN61hgp5fl/Zyzj7Kf2cO6TuwkWuQwscqnumCEMLKG0wqf9hBxtJ+Wo7YnYtmGYXY+10JKT4LVLvE4Ht03itTk4RQe3KJA5idvW2hJuOymH2+Ew8KOsLnuGQ0MWAp49MgMwQ4bjANs3jICEpX/QxfL/1sPT/2eIcDgzAo8Wft67iKXlEbrrVc7cvYdT9u7l0YV97O4stWzfWa1xyuBeuqs1BI3JIXYEoSep+5K679BejeGhPNyfBwnqv43AEU4oVlLywEkLyAchL354gMWv70IFmnAsJhiKQYCTF0hf4vgCpyiRvgAF4bhi8Kdlhn9VZd6KaarRKAhHFOHIgd2bxaUei36/k45VZmazjjVRWREOx9QGQ8pP1Qn2Zfd9hukRajFRlePo7/d4Q2YAZshwvEDBM18fZsnFXSz9g26evOP4VPM/HlH1fH7b1SgwKvyQMwYHeOEzuwl2SLZ3tvFMvhtHaeZVyywpj1CMIsY8n1/3zmNHqR3lScTiKtJpGi/LSkOcsr1h2PNQDpV3eHysB5WIF5dDn/FKbiKm3EBUcyE0Q8CRY5UUCSUiMttoV8NEiLmWd3mktIx5m8t0dpQpFurkVkQN74mSREpSV5JaxWffSBuhmqhqchJwItR7i1T3Vhpdt7DHYl+gneb+tYTA8v5pB4MnuVsHtNeDRH+aogppc6v4iyK6l0f0ntNGFDns3dvG8HAbIPGGa6hHfp0eRIbnJBRiTvh46tlWCSRDhgzHHrZ9c5gT/6SXRa/rYMe3R2feIMNhReS6/Hz5Atwo4pTd+1g6PMYJqnEdFIJ9XoFfdi2m6jbium4FlGeRxJVi5V110LmGe7CgCXHYvLePKGpaRSqWhGO+EV8SgUTE1mQzg8dDSyBvTosjp8WMnVgACs39uUwZidAwGkVbBCTCxEqgfMX2eqI/y/vhlwJ8v7lN3os4e/4zRpZzl1uh6DS5i7GW3LtnJeWgGQ/fPFLCeaKZ8OJHEaeMDDDfG2HeglF2F0rsGO+j85H9H3+G5w7iOTIA48wAzJAhwxGHgu3fGmHpm7roOD3H6K+zKg/7gyxKpIC4rtCHUfUkcl0eXTyPRxfMJz8oWxthSiEBZRX9daMJz9lrKvDTPCzP5Fhmg8B1+VXvQlCK5eMjLC8Ps1BuoX5JF4P3laluz5KknutQWhhZ80dzv8cbMgMwQ4bjEPWBiL0PVph/fjvSkwz/4rmdQel3N6peeB0Sp+A0eGyulZkK6Bii8ZhgX0x9KGLogcrhG4RSLKqPsqIyhK9Nf8AzxU4eU0VwGsuRL4ny4D3twlsmpGBU9jqeNaRka0c3Wzu6Wfh0lZPiLSy+qJO4phneWGXfw5XjszRDhkNGFgKePbI3ToYMxyn2PVSBWNN3bon8fJdd9zw3y3x1nJ5j/gXtROOacFxR26MIRhXBsKa+V6EmHaSOpm2ZQ3GJg9/pUlzmU1iYY+d3mx5UVbEMQqWQIUaIU4dmxFPEghPKgyytDCPRDPht7Mh3UHU8atJlYX2UVeODdD1c5r6ze2Gihq+IISwI1IThV1cOdgGDKfmXWUjKpNDKC2L1o6X9u07v6yC9KdryiCjd8IVOItQOoXZm3G6m4x11Cuz4jxrSg941OXpeUKT37CKV7RGD99eIxkHHCh1mpXSeCwi1nKMkkKO/z0NFZgBmyHAcY98jVYLRmIW/2wGYBqDbIfE6HLySZPyp+qGXknMxqGBzBelDz5oSbSfkcEsSBDzR1cPjpzW5YqoQIwqWH0CZlkTnWJ2XPLqbwY8vZG9nAV1zOP26rUS7dk+1iXYPsHyd6UoSUk4ZcQAdz3fpWVHlyc4uHu/pASlROYX2G4IUT9LGjiDPKx57htWPjPCzU/tBKUQEvxlYwNZfdkx0rBGJRI3GOnDbzLBmNOqbCR4ac3lqW3NG0tJcJ7sCHNc8RyqWhgGmFaiaNU0oAAl1p7kfx9yXiiWxbK6r1D0eGVhstMm5Ea40z+2+SoFYNc+tFJpgnnnTibrJgRw9SVC9+oWg4UkArVlYG2WFO8SypR4Vx2N71IP4p0dJWdgZnnWYOw/g8YfMAMyQ4ThHYYGHVtB9dpHiIg+/28HJNwwjFAhH4BTGD0lot/OMPPNe2oaOIRyOUJFGhaBDPfFvjaoragMR5aeOjKfFbZcsfE0HuT4XVdeMP1Vn7Ik6Qb2LTR/rxCk2PXntpRpdhWbBXqUFse1Z6od9Qy7n/GaAgRM8nplXAtdyiamYePee6cdUkvQs6+W3Xb08Ob9rYq1uZNy6zSmh5kp+esoCztu0i1c+vA03Vigh2NbWgahN7FOALsaGx0tIjZAKMYMXzNaP1gIrMSNt+Eip8DxzqgwxbSSFk97UPo9apNpoux8lqUemt09p8BJZ0Q3uljBtNKHBrrISmn1rX1P3zTZbaGcL7ZRqdU7fvZeV8W7U5T2MbqoxeH/5mPiQSaKwyCXf7yE9wfhTAfWBY2yAxxFiLTMh6FkiMwAzZDgOkZvn0nFanuIiD6+zMbF2P79AMBwz9tsa408F1HZH9L6oSNeZxUMy/tpPyTHvpW0M3ldGhYrS0hzCFUhPICa4dsIRCAe6XyAZ/lWFwZ8eRm4dUFzmsej3OgmGY575+rAxQTrzDr7fp9bkWfJonZ5nQuY/OQyvAxX0Eo0rVJSsWqEbRsfEslOQOHmBk5dEVdja1c1MsdKRthw/eP5iztyyl7GCx5O9XShhx2AzHE6U8zkeWL6I0tPw/Ec20nlanq7nFajuChn48TjB3rkt4NX1/AK9LyoiXIGqa7TWdK8uEtc02zfsyzQPExAu5BfNbLIo5Jx4447HK5UZgBkyHCfwex16X1SiuNhHOI0awbVdIQM/GafydDr70W2TdJ1ZZOjhgzfGul9QoPfcEkM/r0wlmuwv67j3RUU6Ty8cVgOw4/Qc889vZ/S3dfbce5h5jlKy7fkFtj2/wFg1z0kfGqKQHyY/30N4MOWOExP/mlgM9kYEIzH1vRFh0Amnz253dd/lgVX9jYVIIrKk1aMDKdn7syp77xuntNyn90Ulll3aTTSuGHqkwuijtZn7OMxY+HsdlJb77Hukwt4HEkkrEpa8sYulb+rhiXWDR31cxxrcdsnSN3Xh5CXVcpUn799/+ywEPHtkBmCGDMcw3MWLqLxyPicVdpMTETXtsVV1ssPphC4JXcCpDX6XVDEviZ4EIELgoCnj85vzTkacK1n41ceJBwZmtV+/z2X+S0vk+z22lXvZvepkWNX4TShT/FdokBMM6ECGdOeeof2ylYYsgojBf3I3OjDDw50LckRdEzp0QiBO7scvRvhuhOvESKHRwNBoG7v9FfAaELFZT7ZWckCqFL3LSfDLHIDYDEEGsUMUJzT3lGDotGXkhhc2YqEhE/w669U+GY/NA4sh7HCJClaoMq9w8mYYT1scRFUDneC7IWjwAJMhYEeTy0WIRIw3bneIc4nttEDFVhhWCXNGkpBrqxt9txdrtOdMY360lidOjLNa94nHPPPwY4GIxBTvUDtmuBsglwvJ+6Z1q5RMLdetdUHgGudJa4HMmdO5dpWVhaORVpg4rjvG8QddHuKsUxFKUQW2/RacPTvoPUMx/yVtzDuvjfEn6wz8ZAx1FGzBZf+tG69Nsu3/DlPbbYV7VUPr8+R39OH3OnPupZxrSBecvOSZrw9T3leBE/bfvpEEcvQzckM9V0XoDh6ZAZghwzEKWZT0v0pQKG5DzIvhVeOU2uCNpUd4RfFxo2270Agt+OKXX8JTW+bhAo4Tc+F5v+Cj5/0fhhzBVQ+8AywDUOagsNAnP9/F73HxOhzcUqP8VzAcs+PHLuE/jPHCtq1T24xHPuNhbmpZacnuShuxktSBkZ+69Poj5sFokEU/JXXS0V1ALZgwQgSExSq1gmSg6DHSXmJvZ44xkYNkqDRyUsaNcJVhOAgg56R5VMkEh2roUqk1RYeVEmx7jUbECYNHgVMzjRQ9YahNLTugO0LDuCq212gvJLKLtaAWuub+Rc4wtqBh8CXhOIruohm+78ibRpsGQsu4Ha/mCIPmuXbcmKW9jSzlSSwpDdOfawqJx0i2VnqoRM1zsqfcRn130RxjJBBSIIKJsXsgPJOn2FWq0p1vjjtSkuFawfgoqNR9Q/QaIKx66ESCh/Rjim3N4xVCk/ciPKdpFHlS0Vcwawg/NdxDLWhex4qj2fmyToMruejukF33bAbG6H5Bga7nFzjxT/qoD0YM/nR85hrJB4m+84r4HQ5P/stgM0PdxsT9rerHIbHsMCPYpwhHFQte3cETX5k5sqCQcyLKrOasCvHB47AagJ/85Cf51re+xfe//32+/vWvs3bt2pbt7rzzTs4555zU+rvuuov3vve9xrqVK1fyrW99C4A77riD22+/ndNOO42bbrqJ9vZ27r//fv74j/+Yq666ire97W2p/dx+++18//vfP0xHmCHD0cGiCzsoLvEJoxh9UQVnwcyxQinhj976EwAG95a494encd/PTuZH/3UqpfYaS08bJF7YiVuUOAWJ9MRUokhcV0RlRTAUMfZ4xMivq6h6wwN5oPjteW2pdeWaz4r3jBA9s81YP28FDGxplLST+Ty//fgLEP0JF4wWUJtGZDlDhsOEfY9U2fdIlfwCl77z2lj8+i7immJ4Y60ht3SYkF/o0nVmkd33jk1v/MGUfqXbLonGm0aF2y5RoZrZS2kq7hz3eObrQ5z4x310npFnR3n/bWNkOuHrKCCe4SUVBAGXXHIJ73vf+/id3/kdAMIw5OMf/zjf/va3Abjkkkt4//vfj+Ok5ZGOBA6bAbhx40bWrVtHf3+D33LhhRdywQUXGG3Wrl3L2NgYq1evbtnHE088wfnnn8+NN97YHKDbGOK2bdv4zne+w+c+9zm++93v8oUvfIF3vetdU+1uvfVWXvva17JkyZLDdUgZMswJpA+lZTm01oyOFenpHj7gPvp6y1z6pgcBeGpLLw/9egm7n+5CArU9EfXBiNrukNpA9KyaKDJkOBTUdkVs+8Yw0oe+89roeUGB3hcWqe4JGX6kQvmZ8KCfF7/PZcnruxjfXGds0wzVexRUtgUseUMX0biiPhCRX+DiFBqWoQo1wVBEdUdIXNVEVYUKFH63S8eqPH6Pw5YvDRGNPTseblWH8taAthNysHGGtohU5Z2jAbWfG6NWq/G+972P3/72t8b6T37yk/z0pz/ln/7pnyiXy1x11VV0dnZyxRVXHOnhAofJAAyCgLVr17J69Wp27NgBQD6fJ5/PT7W55557uP/++7nrrrumjDobjz/+OKtWrWLevHRaX6VSoaenh1WrVrFlyxY2bjTvgp6eHq6//npuu+22w3FIGTLMGVQAj//TAPPOK9H3fIF62IcXH1gWb5wgxC1bPkhuyQj/91/Ox3koSSp3kb75LGqbSOd7NMhwifFpOSHqO7GMQGthhDeFrUsC6JyHyOWMdcL3p9aJfK6ZbDG5zX6OcX+QQiMTY5gMPbYaV3PMTPDwkivTqietxJKFFRZuNR6B1SbVj06PzzqOyb6SoVSlRaqNsPpqJSPTIMvPYqK0xKC1fZ5a9T0h6TK1zZTEyyw8M/tpMrm9XXbLXpbCPGYhGqF64zg8F+H5xnY6boSWVQR7/rPKnv+s0nGKT//L2ygu9NFaoyPdMMr2RlR2BJS3hMQVBQ5IhwYlQUqEbGSudp6Wp+3EPG6bpPx0wK7vzS6Race3R3E7JX1rSvg9LuWtAYM/HQcBHacWKK3w6Tg1P5GBLxACVKQJhmN0DKXlPiMbj35yy5GC2y4pj83Mhwy1Q5BSOD/ymI53+Oijj/LBD34w5dWr1+t8+ctf5lOf+hRnnXUWAO9///u5+eabecc73oGUR/4YDosB+JnPfIZly5Zx3nnncfvtt6d+j6KIm266icsvv5ylS5dO28/mzZtTXsNJrFq1ivb2ds466ywWLFjA+vXrjd+vvfZarrjiCu666y4uvPDCQzugDBnmEIUlHp2n5htf9RoKhYAOrxn38EXEUJw3tqmIyDAChuIiu6LOqeVAO+Q/touxoH9qXawkQYI7prRgeLRInEiMkFKzLB7iidG+qXWjQY7xmmnI1WueMbl7fkQp30z4yPshv72+CxV3T60TQlPxS2wPFjS3y5WRCQHhOJbEsWtaghpE0rhAkyuGyETSR1exSl/e5IU1DNfmdgW3wJBjfrWPOgplJSEkz0crOELT2V41DK6+Ypme3P5Dh8NBgdG6eR1tQy7vhpzVvd1YV5QBnmhOhApBJfYNY+7RkYXsKTdD8VoLBsdLRj/12GVvzlw3VC0SJRIzKoGHLkZNK1hohNRo30MXJq6vmEhwSYx9955OdtOZ7BohzWNzvBjXSh5x82aZFSG1cT0AqoGZlDIO7C2bPMXeUoWeQvP8q85RwkXmBLzp5H68obOb+1KCvl/FuBVzTANAR307sXLYPtBHz+4t5Lsjcr0upeU+8y8QCCHSH08TiGuayjMB+x4uH7CsSzSiWhqMw7+o7rf846LXddB3bhvV7cGzRkrG73YZeHRmjVH7A/VoYbr6w/fddx+vetWr+PM///MpQw/gscceo1qtsmbNmql1a9asYWBggKeffpoVK1Yc4REfBgPw0Ucf5Stf+QobNmzg7rvvbtnm7rvvZs+ePSmOXhJhGLJ161buu+8+1q1bR71e54ILLuDKK6+kvb0dgE984hNcffXVdHZ2pqzpNWvWcOmll/Kxj32M888/n46OjkM9tAwZ5gSLf78TFTU8DePjBXpfuANHmC9xm+QcIHESE1BNewzH5qT42nmPGi/GUDuMJQxJheCxsQVGEgBAOfQJEiW7gsghDM3nL45Nnp5SZkF2KeCEBYOp4+iXHbTpRsKI0oKdox1GZq4QExm/ya/rFi9ax1GGAehKRU5aVS60ue+K9FOVKDw3TnmTomj/fBwpFTnXTBjIOyEl1wzzOZZxF1kGaWOM5nKbV6fdqRnJG+1ODU809xcjyUnTS5t3+oxEickklCRCJalH5rpIScLE+ddaTBhuCW+io5GuQk6ez4ksZKOCSCghTrrgQHvmuXbctGEirX1NjiEJpUzvntakjHQhtHFNXBHTXTINpp19HQRe4kNGCepbHZST9uQMxh0sLuwlaJOM3S8YfujYLru449ujLHpdJ8ve3NOQmfnZ4dXlPNpw2yXCgfGnAli2/7az9mwfZqhp4hXT2T27d++mWCzS1tb8UJuMfu7ateuoGICHdJaCIODqq6/mqquuahm2ncSXvvQl3vSmN9HZ2Tltmy1bthBFEa7rcsstt3DdddfxwAMP8J73vMdo19PTMy1B8sorr0RrzU033XRQx5Ph+IPf59L34hILXt3Q1NofnKKksMhF7r/ZnKO8NUC6gq1fG2b7rnkchUhAhgwZ9oOBegf12OP0rmeO+ffHJHZ8e4Q9/zlG9+oi7atyM29wDKPztDxxTTMbgb94ourPXPwdCKrVKr5v3kyTy0FwdOpWH5IH8LOf/Sz9/f1cfPHF07bZvXs3Dz74IB/84Af329fKlSu577776O5uhIhOO+00enp6uPTSS9myZcusrOHOzk7Wrl3LBz7wAd74xjfO+jh6lnSRo0DP4q5Zb5Nh7uB1SbrPKuJ3OjgFScEp4Xc5LFntNMuSBQqBQOYF0mt8PQIN58IEpymqKsafqlPbFaIVuEWJW5RUtgVElSObdtr5vHyD0AzUh2JGHqsS7mu83fyqT1dPicVnSMrzSrTpPjzdfPPlYg9he6VETNJz4qgSedVtNFGYoRFPS7ROyLkg6BVdlIQZYitJa9nxqVjcqcgqGeZ6MUWn2UYI6JAe0vIAdovm168SgNtGnJB8iaUkyPumB1BZIWBHU3QFIuHN65OSbuuLXFleUyEKOE7BWNfm+imPUyRm8AAKRYdjvkp7haQL87w51ngEBXLCnJitaCdFEdKmaojEtgUR4CY8gAoJytxXr+hCOc3wrtaCimtes5LjUbQ8hwUnR5TwC4Q4VHyLt+lo+r1k6HpChzABLUT6YDzz+D0vSnkBbQ8opMPiwtJK1LpxnyQxT0JJNCdRV8R0YIbbF3klwlzinGhBd5eDm2v97A+xipNLu3n+/xey/dti/1m8xwqq4AzkWfX6Tp7+2jAAPYu78LoddF0d8ffc4cKCM9vxOxyWvjRmx47f7LdtoxLIseMBnA75fD5l6E0uFwqFVpscdhySAbhhwwYGBgamsnrDMCSKIlavXs1tt93GmjVr+NGPfsTChQs588wzZ+xv0vibxMknnww0jMjZukMvuugivvGNb3DNNddw6aWXzmqboW3DuFHDRT4pSZHh2EX/q3up5yrs2l5idChHV1eJ3UMS4cR0dFTwfYXnxhBrwppLvSqpVTziupwwJBT5UkTH/DqlBSH5xY0HV+sYKWPCUonB7Q0KgVMOiB/ddNiPoe2CHoZH6pSrRYptAcUXaeLYQWuB60Zs2Rqxq30pQ70Ri+IxK6GhTEGYIai8CI0CSAModiiLp6fTj3uMGRoaE4KaNNuNi5xhFI1Ln/GE4aKBSpgnGWGVscYJzc/1UhTiJHhgnhMTeC57VGMMWgsGA2mE85QSBLXINAClbvxNDUCzwBs2Qqzt7iiBO9zsp4VhocnhyJzRJhRFo22sJON103ByHWWITEuhKfjmeay5FcrCtBBs47fi5Clb16gWe8b+69QZEUPmuGWFfKKESIykgjnGfZTYEzf3FynJSK1giGWXqFOyxJrLQWQINsdaEDhm6DTnR7T7JcZk8x60k1fGK3kiiyZgJ0k6oWqIeifQMnloBs+KEDpV09gXI8SJ8+9KhbauR1D0GBUJCoQS7OnrwKklOIhWRHpT3MlLBrdSfLnLjuEeRqol8gMB3PfL/Y5xLrF3F5z4J31U9BhOSVA6t4u4rEDDtm+OpIWoj0Hs+8o+5p3XhlwWw479t420Q6iPjoyKud8Da79gwQIqlQrlcplSqfGxNjCh0zqppnKkcUgG4Pr164mi5s2zYcMGvvrVr7J+/fqpA3j44YcNkuN0uOeee/irv/or7r333inr99FHH0VKecCx8Ouuu47Xv/713HnnnQe0XYbjA8NqHu1yL5vO7mRfqcDiYo5tIgBHwiTxPJC4I+btLWKzgoWWjb9JnLV7J73VCj970QIm466F3YKFjzmgDq8a/+DPyvS/ooOhxT73zVtELgxZOjJKzg3YuqJEpeQCIYV8he21LoMDVo19agmPjyMURRkYBsZg2M7T1R5jn9XY9BIVnJAe3xTV6vBqlNxkhqlMZZ06UpFP8KtiJalUciTTN6OqSxSYRklQ8A3DzfUjOtt9hqPm124QOIax19IjVIjwcgl+l6tY2TVgcP66vArd7v55T/l8mOLO7Qy6TLFi5bN5bJ6xridXMfh9jtC0uzNnWzqWBeSJmJLT9AAoBLuq7USJyUsKTd0Szw61YyaBTEN6tz1nQd1NVSOxBaTtbG7fjZjXY4p6LyyOstgtsoR9E8eh6HBNI/GXI4vZV2te11hJxqqmsRvUPeLAHLeXi4wkIKUEccLbrTUNoejk/ejH9HVY97Ffo93iYHoWJ/Tl/ZspJs5/rCVbFvdSj5vnO9KSmvXc7IkU836oWeoMspRBxk7wqFcL+03KmEuoGpS3BCx8bQdaQ3V7yOavDrLgVR0seWMX2zYMU9t1bBuB0ahi592j6M4Q5u+/bSMce/Q9gLE+sGSbU089lUKhwEMPPcTLXvYyAB588EH6+vpYtmwGouNhwiGdpcWLF7N8+fKpv+7ublzXZfny5VMSMJs2bWLlypUttx8eHmZsrPEVuWbNGlzXZe3atTzxxBPcd999fPjDH+aSSy45YGt46dKl/MVf/AXbtm2buXGG4w61So49bUXOeWYnJEKjQjT/DggCOutV+itlfjl/QcOQtOVADjPGNtUZ2NrGiuHG5Fr3PB6f18uvVvZOGH8Zjjc4qKm/YxLHR7RvzjEpIWQb0FNwJQOvcnjmLYKBCwR1x6X3nBInva33mOXa7bx7lM3/NMgTtw0yeH8ZFOy6Z5Txp+oseUMX+QXHxzsnLs98EzcqgRz9vwMNO+fzeS699FI+8pGP8NBDD/HTn/6Um2++mT/5kz852NNzwDjiZvLevXunTf5497vfzd/8zd8AjfDvunXrGB4e5s1vfjPvfe97ednLXsY111xzUPu9/PLLOfXUUw963BmObTy0uB8BnDA0OmPb2WDF8DA1x2WwVJq58WFCoT0gyjI8MmQ4PiEltcWShxYv4ol/HmRsc53+V7Sz/L91I4vHx3O9654xxp88vozAmTCpQTkXfweKK6+8khe/+MW84x3v4H3vex8XX3wxb3/724/AWWmNw3rFL7vsMi677DJj3b333jtte1vL79RTT+WOO+44oH2ee+65bNqU5mi5rss3v/nNA+orw/GDjnqA0Bo/ipkuX8p+HoUt6pvw8m1r76C/spN8GFDzjnya38LXdlDqCXh4fn9aaPgAEeuJ2peWOLOd9DC5vtW/jTbJfqZ5sdlCxIcLQkBKTk2A7b46YC/vLOEIhUqEYKfz5iX5hhKdajdbL2AybD+5X2kda4ycVX8HGvZqxa2z181KuHkapPSzZ6MBLWweoJ24M/kMJ0WuG/9OeuxaiWe3Qmw9M3AQ97MA4fkM/CRg3y8Clr6pg74XtTHw4yYtQMfxYaeRHC7s+u4YC34Xlryhi23/Pkxt57EdDp4Jkx65udjvTLBtlVwux0c+8hE+8pGPHKlh7RfPDpM/w3MGbqek/4QBVm4JGSgU2dwxj8VVCb5EJyZTkVM4y0xekG1YKCWJq41HYHevz/iIy8ueeZpyzmVbX4ntPW0EnUWEFMxE75BFid8hGxnIdd2o1xliEN9z81w6n1egtMxD+pJtv+lm15klY9yFYkAh1zRpPUcxXDczwoaDAlvKJr/PnrT21QrsGzN1AHN+ZCQv5LyI3kK6bq+NamQmJsTKrLUZK5m2tm0IEI4ikeCL42hcR+FNaDtIoSnmglQlkErJNMjzfmhwECc1/5Icr2rsp7hzOWlObG1OPZWY0ebUIEGLU1rS1m1xyURscPCkUCzyhg0jrdHG0gYUJt+wonOMGjqMkqf8eYSqOYAYyXBoXv+d9U6jTaAcBqrmdRwqF6nVm9w1FUtU2eSyBRWXwMpCxjGrkwhPGcLQADknokvnGJvIqnVl3EKHMKTkmfzCzpzJk9yXK6S0CbsKNUO/EMC1rpEjlWHQFd2A5UUzUWa+P0pRNp+jivLZXDHJY78cWUw5NO+tMLZztc1nSwpNf3EMPzHGE16wnSfXN6NN83+6m9Hf6eLJ/9HVHPNv2lh23U84VrHru2P0vwqWvL6LrV8ZIhw+RmkMs0Ck5RwlgRx/5ywzADMc08gvcOk4JY/f4+K1S5yCJKzHPDhvEfsKRYRKFCBIvrmlppjfv5ZSGDtUE/IV/3X2AtrKAaduGeGkXaOcsn0EDYQXt7Pt2yOoyQoBEjpOyTXG1e0iPWGWy9qPLRSNK8pbA/Y+UEE9byFamhOu4yi8RHUKR6qUZydUomF0JftVpt9ovJYjqCYm/AlupLSEj6ueaRTYk61CpBIFYm3u/2A9gEJoHKlwEi/OvBu1LOGWRN6NyDmmAWgbcgphePIApDY9dY025nm0p39HxHRaWbD2vjwR0y7NNiVZN4xEB0XeMgh9FRuZ2wpJm1MjFM3Xcl27KF0yzkM58o3EhEhJRu3KLIFrJk8oUvI5KYFtQHvaqOihhTSEsIXQjQ8AJNHEuZNat/R+ONa95ltJGGXHJ7aSUnJuZBjyrlTkHdO49GVsXIM2N6DPM6u+9Dhl8pZRmoTSknLoM163ZHgs60+moggNbmDyOVlSGuaUjj3NRg+0UeyqsvSk3VOrvj3+/Gnc28cOdn9vDK/dYcnru3hq/dDMGxyjsOWujuZ+jzdkBmCGYxoLX92BcAS1gYixx2sM/6pGfMpp7FtVnHnjg8B4yefB5zVEzaVSLNgUc/rYDlb8YTfVbSF+X8MQ1THUByOGfl6huiOkPjBN2MQBmZNIr1HWKYkjmGOSIUOGuYLC8CIfTwhHY/yu43TwE4gRqUpJR2u/xxsyAzDDMQ3hCQbvG2f0180w3NF6zJSU7CkVKX11lHkvKZCf51LbHbLru1Xqe2bJk4lBVdSxmheaIUOGw43j0AAsnegz//w2nLxk9w+P3TJ3vecW2bFn/230HNUC1nOwz0NFZgBmOOYgfeg9t432lTmkK6i1LUW+oMnVKS9tkamrMGuPqpmzslpFY1Rk8tmUA+L0VQwOKZiMiiwUiMXmwx63+WirhqhOxI+E1shAGTsdXV6AZFhMNEj3rcK7xr4sDh40Qr7Jw6nXXXRkhY4d1yDYay2oWULAAlIh2EpgholbifV6fmScz9jRxJ5Z0zdfDIxEgGIuoM2P6VQNbpgUmg7frHurEKnaxK6IDQ6WROMJZSVUSEJtn0enUbFkaoWZBOAIhSdiY/+TGovGsQozTO2LiJKsG+HjvAhTIV/PCh2HIiRIVBlRSPIiMjhwjlKpmsL2cQW4+G5sJGw4jkIlhKCVECBBJy6SiEVKGkaEpv6R1pqgbk4TQ9UinTrPnomkBkcqKpF5jwzVStQSdYaF0OlayEqmQqyOUEZ9ZlfEqRBwzgoBuyI2dDEBRuIiY6rZZjzOMxbmjcSncuBTqVvVWhwzNcqRCt81Q9cNiZg05QCAzS6iLtAnhcdPQFA2Ii1xVfHE7YPoYzQHpLDEo+0kH2YwAGMt50gH8Li54lPIDMAMxxQKi1wWv66LONCMbKwysquTx//HPAw6l0lTavDbQgmJqgJapvljDZHb5rJS0khKAKDuIIKEAZjTPPGWTmN/2gHlJXlSkF8+Rj5hTHmOMowUpQV79rUTJ4wyrQOExYFSSlBPcK4cIVNcqjB2iOJkP4LRfUXTAI7kxGTeRBxIw30a5dJuiqQIb6NvqJZzZpk3P8bzm7OEEDCvY9wwioSloyaFpuSaYtWdfo1VvsuY2DvVZok/ZHDnYiSDYbsxprp2jSSIVqgon3pkvt5GY8/KcC4aBoFE05czjyMnI/oLIwZXLy9D/MQYPRGxwjXFknMCfCvtNba+OCT1lNHa444bxr1yZCrBwhPdlOMmd60eu41EncSxxEpSS1zLOJZUPdc0+JTTMAInocEJBIlDQzk0KuhMQmgGqy65UoHtE8aTkBrpWQZRJNOl4CwDsNRRoy1vGrd5J8JP8DvzTkiPVWUlJyODyxkj2ReZlJDdQYdxHstRjm3jpsj30HAbcSVxjwiNU7SM+1xEW878AHCFShnz9dhF7pL4/+kTr4yR3ccu1y8FBTvvGWXhqzsoLPSoPDM9d3KuUFjksvj3OxncNDJj27lLAjk2s7z3h8wAzHDMoLTCZ+FrOhjbXGf39xthCHdJd2tR5qP8frW58zaESBPGk5BiwmpNZlii0cchb2S2mFZI91mKI/X976BnxS+y5WNmhQPdpJVX/TDKAB2vkI9L/B/7xMtiwpeGHJty0NOj/GRAOKpoX5k/IAPQ73Xwu13Gt9ThCHkOu84s0PfiEmNP1Bn8SRlO2H/7g9XkO1TMxT4PFZkBmOGYgNsmWfjqDkYeqzHwn+Mzb5AhQ4YMxwDcB1zcR12iMyOiFx6j8dNZIBqfIQHEhcW/30mud0L5YOKLRytYINupD0Y8843hVM3nA4Vwoe8lbRSX+HhtEjQMPVxh6IHKrCyWY1kH8FhDZgBmOCaw+A1d1IeiaY0/qRT5KKIQhuSjiHwUUQpDemsV5rW3syCo8/DS+QRe85ZOi9qm+z0sqgxH+MOv1Zdl8tiUnlDHPYpfoMno5iQnUFgh35lwUB6rCdgvW1soebqvcZO7JWf91T4biYcjlehzRLMLbdHF2UBP/k1sfAie3uR93Ipb2gpKC5Lcjdl6fI6Eh8b/ro/cLgkuCFAnNe+AFEXhOPAODT1cYfHrOul4Xp5wOKbv3BK5XhetNNWdIYWFHirU7PtllfpgSG13iJqI4OcXuCx5YxeFBS7VHQdvBOcXuCx5QxdxXVN5OmDP4zWq2w4sJK3nyAN4KKLpc4XMAMww53A7JV67JIw1y/+wG+kJhCsQjkDIgBVbN0+11TQI7UoIQinZUepgoKeP7me28MrfPs1TvZ1smt+NLDvU93aYO7JDybqhe2sgr9GJlSqn0D3mC01IjUi0EUBbvm5w/jwnpuQ1uUNKC8olz9DUiyKHWsVMcKiO5tOWRIqnKHEq5kqvLox5WDkTmm6ThypA55VxwEJAvWaR4N04Zdx1d48b4e22XJ12v8ndckXMyvYBg7sXaieVvDIe5wwOXsEJgDR5P2mkhcplR73LPHzlUrcmWDvrz5OxodUmhaI/VzEM02rspcSiPRGnkmAerSzeb5u8DHGK2hB+7pUVOqUt/OwYxlxFeYwqUwh6d9hp8JdiLako35jQcjIyRK1D1yG0Mh87c1WCuHlstdhli+oxJqlA+miLBCsjxzAEhQa3bH1IVV3cwMOtNK6d8jSqx+KOxtI0KGOBHDev2XjZZdxN7gz2trUhEzqYvh/RUzQ1FsuBb3BgIyWpVS2x8EJgJNPEShJGlp5lzYHQuNkbrwiLBxtYOpjbxrsA6H28zqLtIc+80mXe0qbIdaglj/3T8+h6ornu1OFx1DGsAQhQ3RYy9PMK81/aBgJqu0N2fm8Ur92hY1Wesc119vyw9Qd6bVfjfoyrB/8ZJH1YfFEX408F7Lrn4Et8NqogzYUOYGYAZshw4IigujNsVNGoaeJqTFTRRGWFLvbw+FsWU/McmKybqyHpyFlcKPKLlctZMbSPU3cP0Vuuct+ixXjj5u2tJTN6PJSnzYQTCV7eNACl1ClBZdeqTuAKhZ+YpJUW+G5sGFJai5TXQ4fCTOZoAaciccvmC07EliPG18SO5V2RGuGY49bJfQnQSpodSSh4kZGZ2e7X6UoQ8x2h6fdGUwZgRZmTcowkShhuyfbJ7bAMoLpyDQOortwpEWKY3gPkWseakxGOkXSRFoK2PZdKC6oqXRow6b0sOAFllcMRTWO2XdYMOz5GULOI6TXtEZI29mwD0DZSizIwRaZ1oxIKNNflZIRymx8g5cjH82JUIjEjdBTaqkWthVWyTYNVQKXRJgBZb66IlEhtZyacCGRgXyOJds3zHTqecY/GkcOYVRlkvJJHJQxAFYtUlZOqFgRW9q62k1JiYSZhTTo0rXvAzsqvTiz3bS4zuMhnrMtlXuJ3pSXdj1UQP/1Fcx3HB4YemAi1Whj+RbVF6yY6TmskigUjB3+kS/6gm7iqDsn4AwiVJFRH3wCci30eKjIDMMOcIyortm9ond3lLpHUXW9WDPstfV3sbi/yis3bOHnfPp525s28UYYMGTIcIGSk8GuaHSflcDn+sj8PN3pf1MbY5vpBW7q95xbxOx22fOnQK5DoOaoEojMOYIYMcwMnUiyojHPi4DBKCLZ0diKzXJIMGTIcAZz4cIXYFdQ6XNqe4wZg+6ocTk6w50cHJyDdvipH9wuK7L53jKh86L7SrBLI7JEZgBmOaeh6QOkZYYRlhab5pakUZ3bu4vSRPSghGPN87lu0GKU9LCoPQreI+rb6aNPmv5PhJgCtNLFIhlehGro4iR1GSqZEl4PIIbI4gCo0w4IilIjIepHYxxEJRAueoDFsN80BdPIx0gqnWVJ1DSHcZDKH1OSs+ryuiA1RXzkhUyKTOnSIlKCzHaatK48KPuMioWknXWNfkZKUI9/g1wSxQ6RtDuD+X75SKIZDk19YVy6BFV61w62t+raFgKVyGY6LRni5KOr4hladYCzB9wMYVXkqKpdoI1MitqF2qMZmCFppMWO95Ea92gQHzhHkvciovRt4HlFoJc/40pDzELGYlTCwfR8Ji1yrUSCsez0WqfyRuC4NAfUoloyJgtEmrLmmxmAszGdGNDJTDcqdFsTWc4xKC2FrrAQrJQy+IUrx/PvHaBuJeOyF7USxZNdwB1ueSUQbFJw2OvacMQv7zi0x/lT9oASku19QoPfcEkM/rzC2qT7zBrNAJgMze2QGYIZjGvHAAPM/N9jyN+nDsjd3Uyx2c391MYO9E2Kw+yAnwSoOgMacqGxB58lGwuLgRTU31caeOIZDxyCPS6kYyZkTfr3uNjh2k8cWOMhRs293XCCTk5nFdwRApRMvw3ZtJBrGBY1uT4g1S82C3hEjMQVIGalRC05cb75srCs4IYVEdQaJblTesIaZTyRBxAgi7RjZkeXIpxJ3MZgYuG8RziLlMFQzRX5DJQ1DWghtJOAAeI5PLiEorLVge4uwUCux8OQ6Ryo6/ZrRJu+GxjgD5fLw+HLDKBzKt7HI22dsNxybxzGm8tQTN2msJaORdc8ojz31ttSYk2N0pWqIbCduyi6vYlyjUDtUOs1kkm1OF6Ouub/A1cTJ+y+UeFbyROp+FKS4pV4uwkmsCwMXNWIKUTs1gQytbO5Kq0nUfJBzFpdPS41OPkYCwrxjGKG6BU9QhMJ41rWYELBOQMWSaOIjza9FnPfzfUil+cnZ86iUPKiA98sSq/72/obVOQFb9PvZDOlLqjsPLFNX5mDRhV3k57vs+a9xRh+tzbzRLBFrmfpAPBo4HiuBHNCIP/nJT/LKV74SgK9//euccsopLf8eeOCBlttv3ryZt73tbaxZs4aXv/zl/O3f/i31etPqv+uuu1J9XXTRRVO/33HHHbzsZS/jiiuuYGys4W6+//77OeWUU1i3bl1qf3feeefUeDMcx9Da+Ot+YYGT397LiX/aCwq2f2uEsirM3M/xAk3ayGy1biZMiU/PbqP9yXBI9NTf4cSkwZX8O6h+DmKbVvtqua5FaEdNZN0q3SzLl1xnY1K2ZlKjbGpZp71+0411uvMz3TlzhJr6mw5CmH+HEwfT78EoyqS2aSn3dGgH1zlS54Kf7SH0JD98cX/D+EtCxeZ76jkEFSq8jtkZXLIoWfCqdk78kz7couTprwwdVuMPINZizv6ON8zaA7hx40bWrVtHf38/ABdeeCEXXHCB0Wbt2rWMjY2xevXq1Pblcpl3vOMdnHvuufzbv/0bAwMDfPjDHyYMQ/7qr/4KgCeeeILzzz+fG2+8sTlAtzHEbdu28Z3vfIfPfe5zfPe73+ULX/gC73rXu6ba3Xrrrbz2ta9lyZIlB3D4GY43LHtzN363w+D9ZUYfq6ICmHdC31wPK0OGDM9S5GsR5/xiL3u7czz8/N65Hs4xAb9bsuDVnXgdDkLA8C/3nyVcWu7R+6I2/B6HuKIY+Mk4IxsPr+E3iek+wo405mKfh4pZGYBBELB27VpWr17Njh07AMjn8+TzzfDBPffcw/33389dd901ZbQl8eMf/5ixsTFuuOEGfN/npJNO4i//8i/5yEc+MmUAPv7446xatYp589LZm5VKhZ6eHlatWsWWLVvYuHGj8XtPTw/XX389t9122+yPPsNxhY7TcvhdDlv+dRgtS4iij1MEp7MD5RnqIWnJF2jw5JLrxES7maCsvlp94CeFcSe7t1wTQmC6K4RO68POcky2k0FLazupTc/LAbhWkh4lKfSE8G7z91gLI5QrhaKmPMPTJNEokQyJNTxlyb4VgkgLQy9QCgeZOLgo4WGbOtYWX9pOi9rD2tpXrNLCz7MRrFZaGF5A+3xM9p9ETXnUtOklssWrlZYtvYt2O2kdW6tjiO1rhOlVtHmD0Ahv23JGSG3WNLS1MyfXSZqVIERa0siuuz1rD5wWiBn8ufYl04j0AxELI5yrY5HOUNX2+0CnnmMRKc57cIDxosvPz+hrUDKeYyUObUgflr6pm3BUsedHY4w92boMXGmFT8eqPIXFHtITVHeHPPP1MeoDR7ZaSiYEPXvMygD8zGc+w7JlyzjvvPO4/fbbU79HUcRNN93E5ZdfztKlS1v2cdZZZ/GZz3wG3zcJzUEQoJRCSsnmzZtTXsVJrFq1ivb2ds466ywWLFjA+vXrjd+vvfZarrjiCu666y4uvPDC2RxWhuMMHacWqO4JiU49jSf+W2lqfblQZCiooBMvZqFIJVNoVxuTmZYa7Zsvc1k1kzBEDDqy9AQ93RBVTkBVrUepBO15Mw3ZmZyoJ1ATHqFnbhe2SYRKTKSORuesmcvVSN+imFvvHtdRuF6zjZgwIpIcPyk0jjXZhrFjjDGMHRxh8sRiLVMiz1udHmO5w6/R6Zlf+AO1NsPgGa4VyNU62DExUQvR4E4mD0VpQb3mGS/XfCEg7zUnEUcqlrXvMzh4e6rtDNeatIBYSfaNFg0tOM+PKOZNTmRHvo6TMIpiJdlTNjl4PYUKXbmmx0Mph8FamzHp7Kq2k3cWTS27Muak4qCh37c3LDEcmrxA20jzZMyJRZMDOxoVjGSVSEv21YvGuQ2VQ9kxK9L25UwupxSaUYunutPpMASTg7pHXJGG0aUlxHlNNGF0aa9hOCWvURQ4U9w5AB3JRg6IndBk258BHExpHacmrGUPZNMA11KnOMFRUYOlQ6hrTlOGUyku+PUuYiH4z5WLYFyCAKcYpQ3n5xAWv74L6UnqewPaV+bpOrOAk5NNAf/Jj28FwWjM6GNVBh+sHLFawTYaQtBzkATybMwCfvTRR/nKV77Chg0buPvuu1u2ufvuu9mzZw9ve9vbpu2nv79/KnwMEMcx//Iv/8ILX/hCpJSEYcjWrVu57777WLduHfV6nQsuuIArr7yS9vZ2AD7xiU9w9dVX09nZieOYnIM1a9Zw6aWX8rGPfYzzzz+fjg6rCkSG4x5+p8Pwxio65xCXEpN0XqG1meKrRXpyaXgFTZHjGT1jWhgGGUxD8bG9Err1NJZal/KuaCMLEkmqXIlwVaoSSapbqQ1PxXQ8rJmySSHt3VFapMRxQ+EYfQWxi3JND5ydCRxPCDErNWkAasDMnlYq/TXf6ktbCoVnVP7QprdRN4SAkwZgw0s180u74VGwl02PoH0+Iu0QJDaanBySk0RMCw9gi3vLNgqlUGZJuwlPoj0m25Nr8zddoQyBb2gY03FSHHpi36085/vzVGvLkzfd89AKKQ+fnWE8CweciLE4tCJl7AkNquXOGute+pud5MKIHzxvSaP03IFycJ+lqA9GeO0O+fkucU0TjSlquyOi8ZhwTBGOxIQjESqYua8jgUhJHLsU31Ha7/GG/RqAQRBw9dVXc9VVV7UMy07iS1/6Em9605vo7Oyc9Y5vuOEGNm3axL/9278BsGXLFqIownVdbrnlFvbs2cONN97Ie97zHiPBo6enZ7ouufLKK/nBD37ATTfdxA033DDrsWQ4PhBVVKNY+f7pJhkyZMhwSDhj6yCdtZC6K7ELiDzXseeH49OWhDsWoFtITh2t/R5v2K8B+NnPfpb+/n4uvvjiadvs3r2bBx98kA9+8IOz2mEcx1x//fV87Wtf41Of+hSnn346ACtXruS+++6ju7sbgNNOO42enh4uvfRStmzZwooVK2bsu7Ozk7Vr1/KBD3yAN77xjbMaT4bjB1FZ4fe4sH2uR5IhQ4ZnK07YPcKyoXF+vryP03bs49Ubt/Gbhd081T97B0eGuUMWAp499msAbtiwgYGBgams3jAMiaKI1atXc9ttt7FmzRp+9KMfsXDhQs4888wZdxaGIe9///v5/ve/z9///d/zu7/7u8bvk8bfJE4++WSgYWTOxgAEuOiii/jGN77BNddcw6WXXjqrbXqWdJGjQM/irlm1z3D0IEslnPMWMK9rBM+J2Vduwz+hl8WFaCqm1O/lU+EZoUU6LOurVDg19cy2kw7z2CEoqQ2NM4A4dIzQsOvHdFtK1PMspZq651J2LG0ya9eOp+gqmVw6R2iDpwZQi1wrnOmgtGtt5yESgxQaXIsZ35+LUiFH3zFDG+NhjnJCnLjB07NCLl5EoM1xd1hf5Z70KXp5U1RZWrI1WhBZdA/X9fAT59+Rig5lhjNrtAHNE66EoD3nG5dWACTCVELohr5fYv8eULKuY0nnKUSm7lnBOnwXjZPQhXO0IghyyMT5dmOfUty8RlJofBkb519ohROZdJZ87CMTIa6cFgiRMzwQJfLkE6QriaZdmtfDlSXaEvef0hIvXyBIcF4jXzTqcCcQBw7zHR+dT/BQtcklRGOKNWtwPMe4tE4epHXeWpSHTmE2IeAoZ4aotQMqZ26ochptvQ/cWPHisuLJlUtx+tr57aL5nP7MEC8eqxLki6AFHb92cBJRiNLuEHfF8ZMdfDzPc3Wq7JihTSYEPXvs1wBcv349UdR8iWzYsIGvfvWrrF+/forP9/DDD7NmzZpZ7ezDH/4wP/rRj/jHf/xHXvrSlxq/3XPPPfzVX/0V9957L4VC48X96KOPIqWctfE3ieuuu47Xv/713HnnnbNqP7RtGDdqFMAe2LL3gPaV4cihuMxj/tkS132KrXGRX/XOJ+hzUX4ZHScYxY5me1BNk4Wsidt1Q5xEgXit09UBCoUAz5l5FrIzHsfCgvEC8HREJTQn3JIfGEZKiEO1aBqARS809t/u1Tiz03R5KkQqw3NbrYsoYRTUYpexwLQ4R2t5oxKEIzVuYl9SaJbmhyk5JnknsMzSwXone2rNxAilBeNjeYNf5+ZiSoUkB1GnEizKkU+n8tmlmuEk2YJgaRukQmnDkHWkxtejyATnblcoGLQKC8TUDCM9DNxU8o7IxSZ30tGUimZHRRGQU+Y9kndDc5zaHLfUmn310OJcWqx4De2ybnL1NNglJapxYCTzKC2oWcZ2nTqFhDS3K2J8Z9zI1K7GHaY4tYBhUSdIWGWOo8kVzHHuGO7AVTG73UZSSRxJGGshspz8tlACaWkFu5X0uv1IFjYwcWpm4gmG7abIu3Yg9pWRKEYIxGZHq5/cw0C5xv3t3VBvzAkn7xnkCd9le60CsaDj3wYINj81tc0cUd0OCcfrPBe5AZyw/zaZATh77NcAXLx4sbHc3d2N67osX758at2mTZt4zWte03L74eFhHMehvb2d733ve3zzm9/kmmuuYdWqVQwMDEy16+vrY82aNbiuy9q1a3n3u9/NwMAA1157LZdccomRPDIbLF26lL/4i7/gpptuSh1DhmMfxWUe8y9ox22TVAcEP165nFo+K1qTIUOGIwc3ilg4XOHhFaauaN1zaK+FoBRw9JMLMhwYYpVWKTha+z3ecMgj3rt377TJH+9+97v5m7/5GwC+853vAI3kj/PPP9/4q1QqdHd3s27dOoaHh3nzm9/Me9/7Xl72spdxzTXXHNS4Lr/8ck499dSDO6gMcwK3Q7L8/+th0e93EuyLeHL9ELt/5hG00JXMkCFDhsOJM7fupe467OwxZX9+fsI8pNa84rGMfHw8QJFQHTiqf60xPj7Ohz70IV784hfz4he/mA9+8IPs27fvaJ6SaXFAM+tll13GZZddZqy79957p22f1Oq76aabuOmmm/bb/6mnnsodd9xxIEPi3HPPZdOmTan1ruvyzW9+84D6yjB36H5Bgd4Xlajvi9nyf6qoGiAK6ELuYGTBGrAIXxpTQkS3EG9uJQ2SFnTWhlYuQiOkQia+p4RoJd9hSnE4UrUUIjblPGb3jeYInZa0sCCEKQ49naCtTWa2hZhtyZGp85psZ8uQTDOemSCFnpXmWqSkcS4jJWdXkcsQ5t7/OJL/FtayLafSSnbFvtZKCyNsL4Ui1DKlzejOGBedPUzqwMz3VqtwmtYirYgi7BVpHLR+covtWgmop3dob2Np0Uht0ES6KgG7uosmdSSShHGOe09cyu8+vpVTn9mHiJ+7GoDHA461EPD111/Pli1bptRM/vqv/5q//uu/5h/+4R+O5vBaInOtZJhbSFh6cRe5XpfB+8tsPeMshv9XQsHf0SjPqpjh6PTELTEF+pSA2DJkRn2bTpVKCqkqqCXWSalot5IwOvJ1FhZHjXVDxaIxuXoyJu+YBKduv4ormyOoxh57ZLvRZjzIUY+bRoErlCH6C1B0AjodUwsn1A5hohTKLt1BJWzysqTQdOZrKaMksoyAvbUSNsLYDHsNVQpUyibpXwdmmZVQuw1u2ASEhK5iFS9x/EUP2tw6nXHz/NYj19Dc892YU7v3GOPeWe1gX0LkWWvBbwfnG5c/qHvEQWLcQpMvBY0kkwk4hSCZJ4LWgjBwjTPkOIr2fN0w3voK43T6zTFLNF1exWhTdAJyosmdC7XDE5U+w+DbWe5g76h5vj3PvEMLfsjzencZxy+FMl/cIm0kKoSRqCNjTU6aCT6RTldGCWPHSAJRGkaq5rUOAhcl5VSlDR2LiZrTiUbOxMAmh6g1MpBmolbcuo7vjNKcjvWtISFODlFo4jxGgofyNbIjND6AiqUauQQn2PuFQvaG9C1oPttjD/Vx4j88DsD4C2F5dZintg7tf4AZ5hTHWiWQ73//+1x//fU873nPAxrRyYONbB5uZAZghjnFsku7cUuSLV8eIhpTRC8ShB22gvPB9S1sz4Ul6NzKa6GVMKuFTPiuDG1mock5zck91gLfiVHaFCK2vUKujMnJ5naRcow2ky+tVAkzJA62hyntcfIS5q1t6CktkJjZw5Pr7Hb2yzNSZitle9daeFLRpuhyq4sohUZqs8yZEBppuW58GRkiz67lOY0nknlUYn/KEn2e7NIWxDa9kBorJ2Fqf/aya4hOK+O6AuRERD6R4TCZEWwLb8eRaVwLYY4pmkhSOhiJCVsI2l7Xqnh9yh7TwjivjZWT7vTEcisPoN39LIy7lpjFNtpK+LId0ogJcfTEKlcqfDeRKR1r4hLmugjiCb56aWEv1R0hqFmkKmeYMxxrHsDu7m6+9a1v8fKXvxwhBN/61rc444wzjvLoWiMzADPMGRa9rlFMfMuXhogrWVglQ4YMcwehp69u0vfSEsKBnd8dbd0gwzGDWEvEXCSBTHPz3HDDDVx11VWcc845QCNJ9ctf/vLRHNq0yAzADEcdbrtk8YTx9/TX9mXGX4YMGeYc1Q5J/+MBI4u91G9eR0Pns31ljrFN9RZbZzhWoOdICHq6SiBPPfUUJ5xwArfccgtRFPGxj32MD33oQ/zTP/3TIe1v3759/OpXv2Lv3r0IIZg3bx6nn356Sk95f8gMwAxHDer8M+k5sUxfYZRa7LFpeCH13z/ZaDO2AlQxKTArcMrml5UWIL1ECM5VCD82Yj46lIiauZ0dEkZMFLJPwleIRMjP8yNO6BoyQnedXo0leTOL62nRY3D1Ii2pRL7RZqBmZhfWYo+hatFYV677RsgtjCXP5M0HuuQGdHmVqWWlBUNhiTDBL9tbKzFmcbcqdXM8qoUOorRCaY2EF3NdUHdRofW1qzBjbkIbcXOtoRz4hAlRZw2UhEOQ4BjWQ5ODpzSUo5wR8q5GXoqn5jgKo4St0MTSDC17rimyLKXCswS9lTKTgCYFv+1ayMlwT6Rdfjs+3+hnQX6Mef7Y1HKonUbdY7s+r7X/MDRDwkoJHh82y3B6TpwKJQfx/uVJBDBULxrbVSMvxe+s1H0jNKyUJIrSfQupEZPnV6h06Dg0Q/BCtp4cbaeJ0Gl+n7Z2H+e1sU4LsDTPUb6Z4KHdtHi76yicxPnYfpbPyT+q0TEQUp7vGuPb/cNxFryijf6XtTP/gnZGN9UY+M9jtxzacxlKi/S7/ijt18bTTz/NRz/6Ub7zne9M6RnfcsstvO51r+OXv/zlrApoJBHHMd/+9rdZv349GzduxPM8Ojo6UEoxMjICwJlnnsl//+//nde97nVIuX9PaGYAZjgqyC9w6X/+bhwUv17ZwfZFJVy3Tk+baUi55QKq3vwCjyMJ475p3AllkOUdN8b1TV5OqF1kYIn82gXiJagIg6ukSiZPK++HvKT7ScMAaZc1FnjDzTFqiUJQSZDuh4JSKqFiPCgZWlFh5FCumkZZHDrGxBl4Hls90wAseiHtnmk4joV54wU0VC5SGc8ZbXRokvCJ04kyuObEiQDHEgJWgQOB9WKx+4mFQcIXSlCp+9QSxrUAOj2HesKYCyPH5EAqyXBQMK5JJfSoW0ZJSrzbjSFnMvpyXmQYcnk3ouA220wadsn9ixZVV8Dk5FVjjyeG+gzDKeh2jXtGaZlKuhCAm0hCUEoSVMwMh1g47KiZHinXj3DdZt9aC4K6da8LDMKdAPZaCSYNY5f0dgloDco2LkXD+BMT11eiEb55j8Shg058XGgpEdppmZlvwMFYqVyIiwlDTkDUrtCuKZYtrPsv9WHnKeNcQ+OeySX4fqofxhZLTrivxhMX+ShfThmAqqLYcVcj/Nv9ggK955Twux22bxixjyDDHEPr6RMyjvR+bWzcuBHf941iFieffDL5fJ5t27YdkAH4wAMPcN1119HX18cb3/hGbr75ZpYuXYoQk9xxzeOPP84DDzzAF7/4Rf7hH/6BG264gXPPPXfaPjMDMMORhYSFr+mgtNxnyM3z8LntKPf4E8zMkCHDsx87X+xy0r8H9D8YsfMlfss2+x6pMr6lzrJLe1h6SRfPfG346A4yw34RKwnHiBB0f38/tVqNLVu2TBmB27Zto1arsWzZsgPq//bbb+eWW25h1apVLX8XQrBq1SpWrVrFW9/6Vn7961/z6U9/er8GYDYTZzgiyPe7zLugjZP+rI/CAo/t/z7MLzoXZ8ZfhgwZjl1IyZ4XurRvV8hgem5yOKzY+q9D+F0OC1/TMW27DEcfkzIwR/uvldfxrLPO4nnPex5r167l0UcfZePGjXzgAx/gRS960QFnAn/uc5+b1vhrhdNPP53Pf/7z+22TeQAzHFYseHU7bSc0xJvjimb08ZC9D4QgcmjH5Ji14pe1lOkQYAeLDHe7avHwtZK4EGb/GkzJl2miBjHC+FKKkYQ26WgWsEWmVUqrooWgMmluyUFLHLSQa0lJ5WiLhMXEsq3f0ULhJdmXPgjtnqYMTuv1yWU7TNsK9no7lCtb3H+OVMaX/OQ2drvYvo4tjiVKENXixEQxiVmdIS1ax5aSTabkWBIrBRZtQqfkXLRKy2W0UG5Jh4lbkN3t57blOIV127S4rWbCVHt7f7PZf4v7qFXJsH2LfRYSIcbEfscXjSsGfjLO/PPbp2+U4aijEQKem/3acF2Xf/zHf+TGG2/k7W9/O0IIXv7yl3P11Vcf9H7Gx8f51a9+xa5duwiCgHw+T39/P2eccQZtbW0zd5Ac30GPIkOGFsjP8xh/KmDPzgX85l1dcL6G/w4IWLp8J8va9+13+3LgESQEfAWSuKhMAVkliHc1OXBxIU9cN/k9QtDYLgHtK5Pf1gICiBJE/Frgsb3ebejwuVKxXZq8vPEoR5wwE+vKpRqa3K2h0aLBp1KRQFetR9AaXhQJRnNmMkecl4agstaCMHZSk7lMcPC0BuoOSSVsEQmcwDIKkKZRLCGOrZnb1Yicmagj9nkkpQmVJ82qK0CQdwxSshAQ4JocQEuIOY4ctg6Z51opU/NPCE3O4qC15+t05Zti2VJo+vNjBi/PE4qctJT/LGdOqB321NvNpA8lGQ6a918QO4SxY0wATw93sWPU7Mw2QILIIUzwVLWe4GTahprFZQ1jSWQlNOjIMmQCmeLF2TKY7pjEr1j7cjCudexrIkuXUxVjlNMUgpaOxrfOv4olcfKEeJqgS5n67aHALnLijQlk8h5VIJP3aCtDz9FQsDigdWmex1BSszixYeCmknAmcRoVhoZKuDPkeYw+VmfeS9vpen6B4V9V9984w1FBg587B0kg0+xz3rx53HzzzYfcf7Va5cYbb+RrX/saWmu6urrwfZ8gCBgeHsZxHC655BLWrl2L77emL9jIDMAMhwcO9L2oiFOUoDQ651GcVzY8fn2FcUquKaEQWFUupOWlE5P/ST5bChJFFhoVBSKRMly0Z73cHT2jAdjYOPFP3SjXpZKDUlDRVvJGCzZFKjNSSVSUMIri9CQNDW9NYgGlpOHNalWublZeQd0wnich1ERiTBL2uZ70Ghp6yYkMUECriXZW3zppAEx4pMyvZI2mdegkufsoclocvz1oE65U+AlxZik0BScwPHmeiPGsE5A0rAFqykNiegoD7Rqeo1jLFPG8IUxtZaHbXkQrA1tD2g2dFFyehAKdytYwtxVWJRzRoh8nEDiB1XUq4VcQ2fdoi0doxrJ+YiJzN3lLzEJPudW4mz9MDXFWz7W2DOvGR0QL3taeCgKoel7KQG2FYCiidIKfGYDHCGZ6pxzJ/R5JfPSjH+Xhhx/mf//v/83q1atx3YTqRBTx85//nOuuu46PfvSj3HDDDbPqMyNkZThk5PtdTvjvPXSeVmDs8Rp7/mts5o0yZMiQ4RjDvMEqZ27axzMLitQKs/OPeJ0OlW3BzA0zHBXESszZ35HEf/zHf3DjjTdyzjnnGMYfNELNL3rRi7jxxhu5++67Z91n5gHMcFBwipJFv99BrtcFAeGYYuu/7UVNvAeP/vdXhgwZMhw8nv+bIRbuqbJjfoHHVnXPvAEg8yB9wcivM+/fMYNpEjKOxn6PJAqFAtXq/u+zkZGRGbX/ksgMwAwHjNzyeSz5PQhDl60D3ZSrBaKCi35Ds015gUMxN2iEhiqRb4ghKy0JrJiT0qY2Wiw0kWdyALUjiN1EuC2vUJ5VWV6CtHTPhGOGiXQsUGVL9b8QIV2z3bZKl7HsOxF5x+SOFZzQEJWtxS610Hy87KQTIXWDl5iEo43jkBP6ZcnzKIROnbc2v26KHAudSjgYG/MwSgpLkQr5tcr1kDVpvttiYQpBa3BCkzCvEMhEgEELCKueEToWjiIW0uBcCqlopRls8AmtcKemcazJc+RIRZvXpBs4QrPAH8VLhIUddKqmcl2lq0AobOFnaYhuh7EzQVvYX5gaHEcbY5RSoxLEPAkoS89SK9HgbiYRSCOU3xKxSIVYZWglfMRglZhGyHQOkFCY9IpZEuyNsD0tEip0awqCLfKc6je0QreydZTYCAu7mlybST9JXqPVv9xL776Ah57fzVBvHjFxYqYrDQcN42/5W3qIxhSqNn27DEcX9vvhqO73COIP//AP+cAHPsD//J//k7PPPpv58+dPcQAHBwd56KGH+Pu//3ve8pa3zLrPzADMcGBwYPGrBaMljx+fsXBqdVfvCMVcMwzSLjRFzwyLjAU59lZMceTAEvR1pCLvN42rKHaI8rbIrcZJGIk536FNl40Jx5WKgm8aaXaVg1rVR4ybb3hVbFT/SO7riaFeo43vRnTkzcmkvziGmzAmxsMctaBpTEwaMAZXytVIa8LP5UKDNymFJueZBHsptFH5QQAr2ocMzls159GVK0wtR1ry6GAJEttpV9vzfyMpJLlSg1u2EgWEnc4J0hxiw5BIGhwCYuWaots5Rew4xImkn3xbZFRs0Fo0koIMA1CYCa9aoJSYEkQFyDkR8/wmg9+VilPyO8nL6UN1sZbsiroIrdITkTIFnKuRR82oRDJ5bRPHpkQjeWZyjKLxYZM8bUJoq/KKxi+YVySOHCJLwNsdd3ESBocWoC27VVuGnNDg1CwDMCLFcdPavLRikt95oNm6QtMyDmAkc01wd/cz7lZ8fqcu0InEEO2AsgxJnVeNj6nJbfIxi3tGjI+kwfES9YmPtN59AbsW5Kl1SkNkezqSlN/nsvQPuojGYrb+n/0ntmU4upirSiBH2uv4rne9i66uLm6//Xauv/56432ntWbx4sW8853v5E//9E9n3WdmAGY4IOTnuUhH8/CJvTM3zpAhQ4bjALv7c8zfU2fhzhpaQOwIQk8Q1kcQr2wnGI4JhiKckqRtRY7iEg9VV4xuqtF3bgm3KHGKEicvcXKNiTmua4J9MeWn64w/UUdHMwwiw2GBPogPlsO23yOMyy67jMsuu4zBwUF2795NtVoln8+zYMEC+vr6Dri/OTUAP/nJT/Ktb32L73//+3z9619n7dq1LdvdeeednHPOOXz729/mpptuYuHChdx8880sXLiQbdu28apXvYq3vvWtXHPNNcZ2P/jBD/gf/+N/sGnTpqNxOM8J1HZFBFWHcx4f4IdnLZ7r4WTIkCHDIeOxM7p4DJCRoms4pG0spFiNKewWlOa7FJf6SF+A0oQjMbXdIU7BoXt1ERVqVF0T1xTB3oioEqMVeO0Ofo9LaXk7/a9oR4eaYDSmtjNk/Kk61R2ZRXgkoLREzEElEL0/vsBhRl9f30EZfDbmzADcuHEj69ato7+/H4ALL7yQCy64wGizdu1axsbGWL16NfV6nc9//vPccsst/OY3v+HTn/40H//4x6fafvnLX+aNb3wjZ5111lE9juciamWPjmINYgUThFNb5FbQWnjV1iKz0RCHbi5L0eBNabtNkktGo81BOeAFza/FiQ5mkhhptDF16JQWhg5UK6kWuzsh0gLDQphhYvv3SSTPtSP0hNCwTPwujfFMtZ8hvKZpIep7MF+2Lfherda1EhpuxfebTXgl2Y/SwpDmkRM/xtZL2rFioMo6j/FE/V7z3FqCzi0ErGfjDRCixblOtZnoyL5O9nW0YUdgJ7uxx9UqSivMfwt94JSqltfLvgd0i/EcBMQBcL5mkktSrmSoL8dQX0MzUFY6WPJPD87csd6/XozMQ9uJOUpLXNpOzNP5vEKDFlFreAkr20PGN4dE5Zl1Z3SUGY4zYQ4cgMcl5sQADIKAtWvXsnr1anbs2AFAPp8nn28K3t5zzz3cf//93HXXXbiuS61WI5/PT5VC+clPfmL0uXDhQv76r/+ar3/966kU6QyHD/NeWqKjr8bD/f04I00tvDGvQC2X5Lyli8irSBhaXNJVdHZWjDZ9xQqlBHlfCk1nf80whCItKUfNffeKLvJhxdBmq0Uee8tNsd7GmCwOlNTEHRZ5KBYEVc9oEzmmDl0gXYPfB7Bn1FRgj2NJbPEbfT8y+inlA1Z1DxhtcjLCTWjRVWOPPdV2Y+yjQY7RiikO/Vs136h0obQwKlpoLZD5GJ1IcNFKoJMcLA1aOilivs0dm2w7CaEbXC5Dmi1uwS8bF8Y8rXyJG3u4lYlrKaAaSIO7hRaIwNLL8xTCSp6pWUkRe3MltnldU8uuVMz35xm6f7YOYKgdHhxdQT1uvj8qkc/mvX2G8HQcS+M+1hMcxCSENLUDNbpxDRPrCn6I75qTue+YJz+IHQaEeW+FSiBriXOi0tfIrQtTK3MymcO6bhbdkaiIeY9I0oZaINE1B11rnKfY0VSwxMoDaegQEkr8EZPLKAOwdbhtIWot0mOUgXketSCVFBPmhHEfaQWjtXwqmSrJr1VaUK36xrMWrYjYunaN0bdbw+DJyhC88swmx57kgoKirtHnjdO+oErXwoDeNY0P3UC7lOMcI1GJfXGpIc4+OeYYur/zGPHwyIz7e66iVTWlo7PjVjVyDh+++MUvzrrtW9/61lm1mxNL6TOf+QzLli3jvPPO4/bbb0/9HkURN910E5dffjlLly4FoK2tjZe85CWcc845tLW1sW7dOmObD33oQ7zvfe/j9ttv553vfOdROY7nEmQOFvxuJ8XFHrsea2PwhHZjgtGRJE7W+dWiMQkkEZkTwOQ71M7ezDvNjl0Z05cbNypx1JWLTHRUIiCvQgKRqCihnJTQrhDaFJkW2jQ2JoduV2JwtDEpSJUW8VWxTBmYKWeL0EaCg+/E9Phlo40nYsNwcIRmSKa9Asn9C9FIphHCMpRsg1eANjynLbIcpeXumfQkzazzm/bu2BmeVoIBotFmMoFECxCRNAWkNWAlCuCYHxIInaqeESthiIwrHVNXHipxjpSQBsk/1A7lyKcWN437euSmklCUkqaHT7c+1zO5t4TQeIlrK4Qm56S9O451j4aORifXTdzUhgGuwNK0bi36nTwMMXGvJ7NwJ39IbqaE6c1ToGIzCxslLGHwiazkpAEYpceo7IzeVk502+MnddoBZ92PWjd02lqWmpzsJtF2CrmY+nxzo6gsTcGBukD5dsctxmOhrgsM62aiFkoxv16mR5VplzW6vQonsIcYQQ2fEfIM6TZwUmrdGZKYIw7gkd7nD37wA3784x/T0dFBqVSatp0Q4tg1AB999FG+8pWvsGHDhmkFC++++2727NnD2972NmP9e9/7Xi6//HKKxWKq1MmyZcv48z//cz7zmc/w+7//+1OGY4ZDg3Ch/xXttJ2YI6ootn9rmHrPoXMPMmTIkCFDAlKyV7azVzRrC/sqpI8xunSFeYyziBH2roJ9P53DcR7jeLZ6AP/5n/+Za6+9lv/6r//iG9/4Bh0dHTNvNAOOKlMyCAKuvvpqrrrqKubNmzdtuy996Uu86U1vorOzM/XbZP27Vnj729/O0qVLue666w7XkJ+7kDD/5W2c9Gd9FBZ57Pr+GFvuHMqIyxkyZMhwlBBIjx2yh187S3jAORGFoGulpLQ8rVeZoQGlxJz9HWlce+219Pf386lPfeqw9HdUPYCf/exn6e/v5+KLL562ze7du3nwwQf54Ac/eMD9e57H9ddfz1vf+lb+/d//nba2tpk3AnqWdJGjQM/irgPe57MNbn8fHac5tM8PUApGthWoDBcorhQUVzba1OfnWVwwNd1CEUNk+cDteEtRGULAjqtY2GYKGHf5eQqJEIcUGj8qGN3EUZ5aQlC6LtqIg3ojfjSBvJL0S/Ml6TrKGFIsJWGbY4alpCnWC+nwnkagrPqotni0FArXEqJuL5ohv04/ZLlrHltOmAb2GDli13T3F9wiRd9cJ6zsGo1AWWGxovDMTz4BKdVlKUw+lQaZs0KAsTD5fRpckQ5B2iKD2jU/zJULfcW8cR9FnjYFfDVIK6NPC422j9e6Zl6Yww2avDQHzVjNwzVCfgo3ERdVSLp0B5FIiDw7EtGWM/oOQhcVJfiVQFwzw8SN4sDNRaFBRqYOoCei1PWWsXUfxZK+uGCGl4SLdIxMKaR5G+EKkPbbfaYQlYAo17guyXW2m0BJzXyRR06E07UAbd1sjXsoQZsQ4BcsnqibDktr19gM7UBsf++3SFxKcRldZXAZQeNF5nVslYDT4TpGOFk7Aqz7n5xjPCNOXeC3cKXYTqhWQtjp+syY/EIFIsGTLOdOYGFxiO5Luth5X+N4dLVGvG84PYBpcKzMc05vD7RPvscUhd6YjsUhXl6hFYzt8hh9xrz49WicHXt+s/+O59ADeKQhpeRv//Zv+cUvfnFY+juqBuCGDRsYGBhg9erVAIRhSBRFrF69mttuu401a9bwox/9iIULF3LmmWce1D7OPvts3vKWt/Dxj3+cq666albbDG0bxo0ayQgDW/Ye1H6PW0goLfUprfDJL/DwuoYIheCRcjfbZDcslIQnmZtoJyQuW4K6lTR3R9uVN/rr5PPN7Yq5kP7OJ402Ngeurly21dqNNjsreZ7e3XwxLPY9nilHJg9MaoTTTCYRQpMrhAYHD0A55kNbzJnE/CByGRk3Ce5RzYNRq8pHW4xI8vsKIQuLo0abeZ176HCbCr6dbpWl+Z1GG1/EyMQMMBB1sCU6wWgzWu9lV2zOnNWxvMmLi4VJwgdEbFdUacGBbPUOS5HwHZxqkt8F+UGRMvjsjOOoYNlIHqg8bK82E4F03WwjJhIcWk6eCSjXJBiGXYpnakmepGZbVDCqtdgZ1lJoil4lvb5kEu7Hym1UEhVDosghHCrOmNGqPet5yMc4eet+tK6ZjkAOm5kSbjVKCSjbO/dGBa5dnWIWHKWwPW0AKmuWEBrckmBgvLEDLUFZx2YLiosYvHGjSUMI2r6OnnWPuI37Zr9owWWMQ924JyYhQdkZttImpQJeYBiGbj6kt7vJ09VaMEib8QFA6FEct0vqzGwP2ElSQoM7DiJBMHUrkBttNhwG3J4KWsMT/Q0t1tI2id7yxP53ZuFYmOfU8mXsOznPUjHIAjmCQLOjWmD3WBedToX+0iCsyvNYsIjJrxBVi61smjTmSgfwaO1z6dKlh43idlQNwPXr1xMlUtg3bNjAV7/6VdavXz8lB/Pwww+zZs2a6bqYFT7wgQ/w/e9/n1tvvfWQ+nk2wu+WtK/MU1jk43c5De+OgrCsqA+EDET9PLWoa0reJUOGDBkyHDvIOSE7xp8NQvyKM5xnKFJnm+phh+pCThjWI6rErrCTM/PPsMrfxW+DRQfW9bNcB2ZSPcWGEALP8+jp6ZlVTeCjagAuXmwKB3d3d+O6LsuXL59at2nTJl7zmtcc0n46Ojr40Ic+xHvf+95D6ufZgLaTc7SfnCPX5+IWZUJ7KmLfL6uMba4RJb4wg99rz4y/DBkyZDhGIYWmGrbmwR8vcDsky1btRCH4RbyMOunjCfD5dW0xz8tvY4W3my1h/6z6nqtawEfT6Hz1q1+NmqBdTKomJEvDeZ7Ha1/7Wq6//nqKxWLLPuAYLAW3d+/elskfB4oLL7yQb37zm9x7772HPqjjDG6bpO/FJUorcgjJRDmikPGnAqrb7SQOATJRH1bSOgwopvn3gaDFdkoLI+Rmi+xOCiy3Et41MMMDfyB1GmcSi01hUvLDkJhJhxidmWKEs92dJWejdXr/jX/PcByzHc4sZGC0SEu8TNtXYpvDApNu1uxfW20stLr3ZouUWHWqQYsxtghjzygYPfG7fesklw/7XGedt9nctq3aGHy/aY7jgMczMabU75YqkK1d2DIsqK2LcpjP40Fdo1b3SZLZQuP9XY39qfVzYescFCZfWhKWXtxNGLo84i7FIJlax18hz2+Dhazyd9LlVNgUFDGFs9LQlgTRUcNR3OdHP/pRPv/5z/PhD3+YF77whQD86le/4iMf+QgXX3wx55xzDjfddBOf+MQn9psUO6cG4GRduyQO1GBbsmTJtKXe/vEf//Fgh3ZcouOUHN0vLOF1SKKq4BnRyw7RCT0SekCfjjkBS0GcM9cFHRAVzTe3Td4XMcgwrXtl8rs0qsNUou1qr9Keb/LyHKnYVukyutm4fRHhSIKsrUkJASO1QfBW+cZtLAzhV4GuWckDBXPCl0KTy5kGcbnuE9eaX6NxLIkCi++nBPjmW7qrp2yIyvYUKjy/q+mmd1Asy+0ln1C+9USMnxJnayQjNNtE9HrmKy8ouoSqabQrLRhylGHAhKFDmBy3Bj2Um9LcgwbBPam5p4VGtEVIN8mCF+lKHZGEipkoYgv4xj4ok3OP8nQLfpcimiSLaYE3ZieYiLRYsJvmnCnfmgg1qEri+AUM6I7UrJzk3Amp6e0ex0uIMcdKUgk8w+CrVX3iJAdMCXC1cZ6ccYlTn2lCcIzxaAlBX2ysE5HErZr9OFXRInnC4g66NJ7tqRWQoMROrbPhljGuo2rFwZsQh57cXkYgLCFqGZkJHpNC1DMagNZ3jFZpsWgZtR57Et6Y9UISoK3IRlTE5AmKxvlPcpe1L8kl7gelRYNHnPxIFRjP1eRxGItyIsHFWmdvEhUnBjK5zjHHvUiON3QBO5ud5fZ5Nk33mIN7wnLGzmp48E7o3onw6vyyvhTlJbVjm8b71HZ1TbVe4FcsY0XHACd5e2aiALZMrjkqOIr7/PSnP83f/d3fGXS58847j49+9KO8//3v5x3veAdXX30173znO49dAzDD4UPbSTnmv6Kd8taAHXeNo9sXsuWPeszsOJuYLCEq2BOpLTKbTuZAipQ4r/0VqgXIZBasAM+NjclVCm2I7gKEZQ932EluZmTBAShPEJcSArqRaCQqGLNL+ivQNmSE0LiWyLJSgiiZ4alk+ssu9YXeqChQ8JoDbfPq9Lim4dbu1MhbByOtzAllpVw6QpOTkVHWzZcRBbfZj9IC342JreoUcSIrW0/+xxZQNi61SFWwQOiU9zQSumVJMcO4k+nJVZsJ1437StJMMtEatEDEM5zvif6mfhY0BK5te8u6biqUpsGlzEQZLSGKpXH8sZKEofmaVEo0jODE+GyHq6CFUdCC9J88aVqCiIX5zE5kU9sZ1oaRLFp7Eg0DQ1v/nwa2YSlJJytMFjQRiT5TCQ1xCwPwICZIMV3fM1RMa2kkWveHcjGyebWkcb7tb9sWYtGpg2nlobWbzOTJhFQ2s3JNwzFCNq6Jq6beFcoRx7wBqPM+1W6HTlGmzauxMVhCnJPopAqBnvgINTaczIx32LJvATKaTeh7mpDAEcfR2+fo6GhLMehcLsfw8DAAnZ2dVKvV/faTkb2eJeg9p0hlW8DO/xglHJm5nmSGDBkyZDi+sJsOIiQvkFtwOcY1WWWjBnISBREQI1OlA2eLUM1C/1DP4d9RwgUXXMA111zD448/PrXut7/9Lddffz3nn38+YRjypS99iVNPPXW//WQewGcB3E6J1+mw/Tsjcz2UDBkyZMhwxCB5RC3nDPkMZ8st7NMl9sjuuR6UgXy/y+LXdzElp6lBRSMs9UZx0ERH2u/0HOAA3nDDDbz3ve/l9a9/PblcDq01QRDwile8guuvv57//M//5P/+3//L5z//+f32kxmAzwLMf2kbUUWiVpwy9WjVewooD8PHqyeTFSaXW+h3tUoCsTXHRJTmZSk3zWkxO4bRcp5KvenC17pRV9Xou+6Y4T0aWnFGV542NNW0p5FObHIAHZ2SpXMcZYT3hNDELWq4GgKxUiE9K5QohRnynugzGSoNYpehyHTReyImZ5+4GVBXHuOxSaZTWuImYmBKCFwnNmoBax0Te8llCFyd+kq1r62quig75G/Lp9WlGSqcPO79vf80SEs6UimBU5U4leY4ZSzSoTPrLaUcbd5rIn3fpjQOJ2OQyTHGAkKTgD46XkglhsQVawCBNM+bFsjA1Cp0KgInGX0RE4LGSZ5kTqMSES0tQHQEyMS4VeCgqr5xTmTYOixqLEdWCFrTEAufyUthR99bZBhMiXyr5rId7k7x/VqFqKcJgZrPVnpMqXWtwq3CaiJa3Edeg/Ji9JtTiAQH1nFj4sQ7SmlBFDqoIEFTiUR6jC2CMHZSiGgVbm6xnbLiu1pLfsFyehjjBDFI9wnbiP5kPsGopLzHobzbSWmAJuEu7sAVbeh9w8TDh+40kKUSsqsTACevWPzKmNqgYOARFxVBvlfjLc9T7fWJtWRc5Rslx6WVKKdb30cHgxmTq44AjqbJ2dHRwbp169iyZQubNm3CcRxWrlw5pajykpe8hJ/85CdGZnArZAbgswBeh0M5X+DJt3RNrZuWF5WAdjSqaBN8SFWCcKpmhXYZTZCsEwg6zElZ6PTkEewqEifFeeOGYK1xLCVzUlSuRnVGJr/KUThe4iXteRTdusHni7Ugisw3p+/GSIvzF0Rp9kxSLFoIjbQSRZQSxHFSZLjx/zAxUYyFOZ4YN2sm7/HaTcNNC+qWyq4n00khtpEKDY5hEmNujjBuHovnxEZSitKCgWIOnUioEaHALVucw5qbNhJtAzAUKV5myyxga5L2xkVqYsyFkE/cS8ojZdxFbdZHirDbaKvqA+BpnKJ53bR9q0cSd8y8/mLIzHhwYshVTaO0FS/NPi5vXOMmDEDtQHmheZKCHoXb12zkOppT5u/Bd5rj3lcvsjnqN6wiGbkpw93+rnCr4AT7N+RbQpoGmGhhqIgYnAicyX0qcGzR6VawjUtJioRkG8nTGo4W37JFLpXJSXUgtNQwwnaNSgpxCyh1Vw0heEdqgthMuFKjHjLxHnPqIiWW7bTgKWpzVy15gq14krFdiWfCuB6kg0E66IzKzMuN0T6/Ru/8kHlnBI1EEe0zFhcYjNuoJkKuTneRgZPb6PlFGzx86AagWNTP2PMa77pT+p6mrjw2eUvQ51pJeInnQaIRCnQymVCDE5ofKTLW6IQRo2cwaCb7ebYngQDU63UeeOABNm/ejFKKwcFBuru76ejoIJ+fXYg9MwCfBRi8v8zC17h01SoM5xNvubngwR4EDpM6ynEBQ+KmxQWKtThouRgjeWE6bQg7UcbGc+haTIeZqo4cSciDdXlkeM5iRJYYU8Wp+9QlYn48Rqes0OeOssAdBiDQLmWdQ4oF7EIc9gwAXwb4TsxjAwvR3hymFzyLS8FN4qmnnuJtb3sblUqF008/HaUU//7v/84//MM/8MUvftHQVt4fMgPwWYDyUwFDqsQLB3byo8XLiVJFQDNkyJAhw3MBES67VDe740luoKJdVumR47TLGgu9QTy/ym63gxaO04NGe77SCJHPJlHjSOIgM84Px35bIY5jPvWpT/H1r3+der3OBRdcwLXXXktXV9dB7+pv/uZvOO2007jpppsoFBpRi0qlwgc/+EE+/vGPz8j9m0SWBfwsweaoHyXghJHhQ+toOu+HIB3Wm01fxl/rjSc/2CZDO8by5L73gwMZkhTNvyONSVHryb9WXjm7DTS8d8m/2ezH7mta2Cf3SGaxHa6+n0NeSbVfIu30mKI46tahxSOJ48KDn3yXTP1pa3miidBTf0cUR+28ScZUia1RPxuD5WwKFuGgOOGsQbpeUGgSn1v9zRqK3uIY9cibXZh2OhyOczKZBDIXfy1w8803841vfIO/+7u/Y/369WzZsoVrrrnmkA7xwQcf5D3vec+U8QdQLBZ517vexc9+9rNZ95O5ip41kIx5OTqDCTKOmEjwsO9Ji1/jjljibC3ax0VlktcVxHmLlxIKg8ArAoGz1+QhBJ2KuNAMcWlP459SNl60uu5CgkvnCE2pYGUPYCaP5LwQn8gw6mSLF0nOi3ASHEABuFIZ+6+5scFdVFoY+nqT+7Z1sEcr5rEKodkj24x1NicyjiVB3XwEi6W6oZUohMZ3ze/0Nj+g3WuSrpSWVEOPMMFLDCKXerJvLRAVx+COyUDg2AK+ITO+hFtx4FK5LSotFp7qW4CtISc0Ka6aPcZWXLLIjvoEkth+vVnEeFmVqcQUtyxSZH3lmfsUUXputO837QriXDIpCbQ3wctNjCeqNb0lkdQM1wvG9a+EHjIXW/eOa5wzGUF+r8mdavDE7EFZi45IJRikkrkEONY5EjFIn6kkF6HAqZudt9IOtLlseFaCg5g4T8nENVcbQtRCk9IBFHFDHNs4Dt/sR+U0YW9kWKv5zjqFXPPghNA8r28XbW5z3XjkM1RvJnNFSjIY9Rgi305VYGm1I6K0Vqb9XWYnymgBYbswj1+SSq6TMSlOtn1DKnf661/1PZ6srmBFdS8Lz4WOs7vYsbeXct1W/Ibik/uIN21ujtl1UeeeQZybvHCKXF+dlV078EXMo7WFhCVh6vtNA6E0Ik4k5U0mKhltzHX27y1xDHEAx8fHWb9+PbfccgsveclLAPjgBz/IddddRxiGeN7BeUs7OzsZHR1NrR8bGzugPjMD8FkEX8WUvYkMCkGK0N1Yn3yYRFow1Z5I5URGpbXOSt7FiYQxcYtIYOkgE3QIdCLBAl+xuHPEMMD2VkpUg+YNLIQm75lk/lgJQwFLCN0QRzUEW0XalhXa4NdJoY3JFiDnxESJg9OAttIHdQvvQBw7DWHh/cDOeFaRQFfNvqtSEyYMPik1SpnH7whNKTFJKQSxkkb/cSyJkwkuunFNRNJItwWFSU+ujZXWcqsXrLVOkk66sAWNbUHhycpcxjeKaEHwT42nce8ZHxKKlMFnC0ynjlWnnwch0xVNpiphTG3HlDE7tcqauLUUaKlTk7lOJnM4ZiIRNISohQSMii3meRRqIuHjACc9bepiT4tUhrEy7x2hdPo+UpjjkS0MklY8NCvKoB0rU5fJLOhmI+GkP0AagvbN5djXOKXQuHXaizVKfvM5kkLTnxujmLB4XVFkPMwllhsvVdsAFZE1xhax1dT7yDLkxKRz3jYA7Qoi1rPWsnynAG2vVM32WgqednvZU+7g5MIuVvTvJtaS4bjIcFRiOC4CkvyAlUwgJEGXR769Rn9xmJJXQwDjOsdv60upuwmVh+RHU6uEF6z7r1Xo9mAMuWPIAHzwwQdxHIeXv/zlU+te/OIX8x//8R+HtKtXv/rVXHfddXz84x/njDPOAGDjxo3ccMMNvOpVr5p1P5kB+CxBiSqlKOSx7nlzPZQMGTJkyHAcIMLlN9UlSBSL/CG63DI97jgCiLUkPMUh6mpHReDkBbleF6dtC4JGPeJt430MqPaER/AYwTFCS9i6dSsLFizge9/7Hp/97GfZt28fF1xwAWvXrqW9vf2g+33ve9/L//pf/4tLL70U328Y3WEY8qpXvYoPfehDs+4nMwCfDZBwmr+DwXzRzALOkCFDhgwZZoBCsi3oY1vQkHPJEdDjjdFDGb/HbXjCI01le8Rw3wL2UWLKfevtP/Jx1HEMZQGXy2X27NnD5z//edauXYvjOHzsYx/jfe97H7fddttB76pUKrFu3Toef/xxNm/ejO/7nHTSSaxYseKA+skMwGcB5r2khAYenrdg6pnUkNYBtLlTaJRjhkqVp01NK6kRRVOHT8cCXTO/+Bo6bAnunNCEbRYvJacgodcmHEU9do3QndJWKFdofCtMGwlJFJv7r1t6fgJLZBQoeiG5hMaaKxVdfsVoMxoUCBLEpFA51KxasJGShKG5vzg24+2thEhVYPEtI4EIRKpNlOinFRnddVzKVk1M14kNfqPSgsg1VcAjV5tjjGf5nmwRlpkxVNOKfmqHZmQLjlOrd3err3mLyypiDB6UiEiHF21B87jFzuxQrmgITyf3J9MPUiPknHxGZINjN7XsMBE6TNzbEcTJmsKxZqRSMK5jGDnEVfNe80JhhmVVmifW6pzNVL+5JaYLpyVCtVoIk9s4sZ2w2tvJAakwuWi9ruXArSHGVpg49jG0IbWvU/JKUSwNjT8B7Kx1kkuQmfcFBXaWO5r9KolTNbmzMibFeYut6yGUToWpU+LlosFdNN+/GMLsYoLKkbrXWlz/dHhVN/vQLep5J/i4AT674l7Gnynhb97ZbON5jHW1of0ETaYF1cjmzbaCtu5joUFaofTGM5x4jmbFLWR2mpeHGy326bou5XKZG2+8caos28c+9jEuvvhitm7dOmu5FoDNmzen1gkhWLlyJQBRFE21Ofnkk2fVZ2YAPgvQcWqBbaobnZjwtaPR/gyzgBbEFnlHdAeUSk2RYVcq5reNG0bIULXIwM5Os5+iMgurO5pooWm4Sd8UYpZSs69iEo+l0Iags+so+gplQx9tJChQTlQUUUpSHs+jExwv6Sk62prKo0JolrXto88fn1rX6VZZXdxi7P/XtcXsC5uk771hid1jKwwSfr3uEpatouQ2/0+n1znjZgUJoRuJGEmEShjVWbSjiXKOwfEO6p5hlAqhWdg+ZvAZq75H2W+OMVaSwbKHdpIzhUQn9aSTmcGJMbYUhrbXzcC7aZXcoZ0Gv2lSNSKZBZ7cLpVQYE+uNMR4DX5rLFIis/YY0xzACX6dxcGKC6Y1o6xKHI3dCvP4RfO4JpdtI9Wpgkh+SAio1NuMfYlY4FXMe8Qbt4SXNUS5dPJKEkKnhaFbGQ72tRVCpz5mlCtQspnAIQTEvnWvh9rkgEoMTh40jDRlP0ZW4pp2gFbRxeSxupqwmBw00B4hE2LxUmhcz3wf1UOXIDKnwIfLi43lWsVHDzU5gEJD2y6BU0s8o1KkeHpR0Ty3Tl2QHzRPZNgujHtES6j1KVPUvMXHUC52DC6vctM8zVRSVuI5mnqmWjyzTmAahtX+HJWFK4w2sW8aoMoR5rUVEHTOnMzi1sBJvn8UOIH5HKU4s/pwCtccecyfPx8wDbITTzwRgB07dhyQAXjRRRchhEBbD2Sy2ofWGiEEjz322Kz6zAzA4xy95xZBa3aIrsPW5wHLHwjT+zdnOAi3v3M4ySIzdWWP7wB2failjZ49khb7gXF+ZzGgY2HMs8RMZdXmFMfAo99yDIfpnj/q5/5YOJ+TSGfSHfy2h4icrLO8Ywf3z7TbYygJ5Oyzzwbg17/+NWeeeSYAjz/+OABLliw5oO6/973vHdr4WiAzAI9zdJ5eYHhjFc7MJB0zZMiQIcOzD13eGCeU9rB33J+58THEAVy6dCm/93u/x4c//GE+8pGP4Lou11xzDS9/+ctZunTpAXW/c+dO1qxZc0DbPPDAA5xzzjnT/n5AVsMnP/lJXvnKV04tx3HMzTffzEtf+lLWrFnDe9/7XoaHh1tue+utt3LKKae0/NuxYwcAd911V+q3iy66aKqPO+64g5e97GVcccUVjI2NAXD//fdzyimnsG7dutQ+77zzTmO8z0ZoBfl+j6NJerC5dQeLVoXmDzdmEnSNj6nP7YPHEffwzRGmvUVE4m/ajTHDXMfgKTIO4xgc3zEBTfpa7q/N1DpxUMaA1sL4e9ZgNufxGMWK0gD7ghJPlRfM3Ng+zqP51wI33ngjZ599Nu985zv5kz/5E1auXMnNN998oKeAf/7nf+aKK67gxz/+MXE8fSg8jmO++93v8md/9mczJprM2gO4ceNG1q1bR39//9S6m2++mQ0bNvB3f/d3dHd386EPfYhrrrmGT3/606nt/+zP/ow//MM/nFpWSvGOd7yDFStWsGjRIgCeeOIJzj//fG688cbmAN3GELdt28Z3vvMdPve5z/Hd736XL3zhC7zrXe+aanfrrbfy2te+9oDdqsc7tn9rmKUXd/N8tvHTWpNPoCUp0o0qKHSCX4bQ6JJpOHZ1VFjQPja17MuYMzp34CRIT9uq3YzXckZYsjKaRwcWe3vcvL1i6ZjSbAICz/yiE55COuYYK3VT2DKOJVEi6aPuuThuFRL6eb4fU/RDw1itxh5DQSmx7PO4Y75QNlfmMxI2eYmjQZ563TOOVcVOyvCQZcckNEetRZaT3DEtSGk1ykCgkpfEBS3N7zSRj2jLN8kzjtA8r3MnBadJ/Am1Qz3BJo+Uw4+jE6gnuIPVkTx6PHFuhUY7IsW7ceotCOW2EHSkUxw4G8rKFtROen5WfpoDiE2ed0G55ttWWhp/TiBa8uCM5SjNnXIr1rEJcKtWUXtLrHjyfCT7l3WLcyfAzVljEukxase6t1pMKq3EurWbbpom5ltJMC24nHbywORxJhM4piqOJO9lW1Bamd4F5UCcwzi2oFMTt5k3kqwJg0ssQ/C3m527NfO6KU8QWooaYSBM/UANsTY17Ww9wcZxmv04Kn2PxDlSCT6x5ZiK2kzNRxmY57AxblIJUCmXjBJpHczJtslx289sYGozOnXIjTY6KsQxpb1x4/63hJWVbz+4Fr9Pa5QnjfPUkktqaRxiPzNMPDNJIWjVOP+tTG6lBVWVm1VYuRXf+KhgGgOwUChw3XXXcd111x1S95///Oe55557+MQnPsHOnTs599xzOfHEE+nu7kZrzdDQEL/5zW/4xS9+QX9/P3/+53/OhRdeuN8+Z2UABkHA2rVrWb169ZS37kAVrkulEqVSc/K94447GBgY4M4775xa9/jjj7Nq1SrmzUtr2VUqFXp6eli1ahVbtmxh48aNxu89PT1cf/31h5RafTwi2Buz63ujLHhNl1GJQ0uBDi3yusKyNjTSIkYX/ZAOv8kwLzgh/d4oXoJ1XFMeBT8k+e6oOjnzAY8nstUMQnn6ZWuLBWsNcTLrTUBNCYN6ojWG6LKSEiHASYhMO1KlRJ4jJamL5i0vhWY8NieFsTBvCL9WIw9lpfRpTSqZRkSYVTZCi6hP2kjQspEnYhgmtjhzLFoKTOesaiHdXoU2x6wOEibe3LGWtOfrRhJO3fcA8znVlsjxrISCk6TyqZUtKI+Wx25q2ZhMdIrKJ0SaGJ6clIQG7AlHt64GY4zbOteTWYj2hGsQ1YHYS5P+U2T6UBsVNPRBuvi0aCRdzNhuhliObmFsykinkmCM/9M4J6oF7ysl4N1iiKaxO3HNDGNfo3PmC0CHjjkANVFlI7HKqZvjVl46CUXmhJGENVlBJAmnbgqjA2lRZUEqw1lLM1NXO3bCj06rKSAaBjDmdvtTaZga92w4iPbHjmW4ylDjVBsnTdYVTlUhYm2/xlBeOuPGbmOLVbcSoU4ZYa3uT/tDUje2bXWIldin1x9lu+hp8Wu632OFA3i48epXv5pXv/rVPPDAA9x77708/PDD7N27FyEE8+bN43nPex5XXHHFrEPFszIAP/OZz7Bs2TLOO+88br/9duDQFK7Hxsb43Oc+x/ve9z46Opop9ps3b+aCCy5ouc2qVatob2/nrLPOYsGCBaxfv974/dprr+WKK67grrvumtHqfbZBOILjzqefIUOGDBkyzAJbK/M4o+MZcjJgbKbGz2IDcBLnnHPOfrl9s8WMHMBHH32Ur3zlKyn3ZVLh+g1veAMXXHABH/rQh6a4efvDl7/8ZYrFIpdccsnUujAM2bp1K/fddx+/93u/x+/8zu9wzTXXGP194hOf4L/+67+45557WLzYTNdfs2YNl156KR/72Mda1sh7tkLmGjqAlVS9qgwZMmTIkOH4R4BPrCUdbmXGtlMUhTn4O96wXw9gEARcffXVXHXVVamw7MEqXCul+Nd//Vf+6I/+aIrfB7BlyxaiKMJ1XW655Rb27NnDjTfeyHve8x4jwaOnZ3oX8JVXXskPfvADbrrpJm644YYZD/54hdM/H93fRdfiGt1LqsShZKOz2Aw5CDP8C6B9jcgn4wIa1zfjIrEWRgg0iB12Bp14ieKWg/U2o14vgI6kWXu1hc5UI7ySJErRshaoEXESurXygBUW0VoYoapYSWqWxtdYkKeWCJ1WpGfoCwIMBwUqYZPQU4tclM0TahGSFcrUYRNKpHhyqRq7usl7mWqjMfUDhU4Jv8aReWyOVITaQSXiMqF2UiFgAGmHnGydLas+rNaN8Nb+NOYAZGiuFHG6Hqq9PBVuNq6lHROnZZg4JaBrcwIjgVEwuhVvMTT10oQGt5pulypQH6U5bylOaGCK2jbCpDYHkJkhQNix7Jmeh4k2rYSX7WWb7zgr7pQ9nAPxuCQf/0CgLX6lUzU5b25V4NStaxumx23fWyLG0HNEWALLNPhnspUQeHK4drhzsplF2zB19wTSN0OwIm5hINjvR9G4t4zQtcKsYd2KbkF6WUQYlCCZ1KAUjZestqLtU6dihvuyFZWlpTC7RQmS9nnULd590+y/0x3HEYoo9eC1gKb1S+pI49lmAH72s5+lv7+fiy++OL3hQSpcP/LII+zcuZM3vOENxvqVK1dy33330d3dDcBpp51GT08Pl156KVu2bJlViZPOzk7Wrl3LBz7wAd74xjfO2H4SPUu6yFGgZ3HXrLeZKxQWuLSd30vBCdDCZ2dfF08saqdQ9imF5qyYEr6dV6G7I5E8gCbvhcZzurfSRXV4/tRyXSh+XV1iZJlW6j5dY6aAc3csMWqKCBAWLycuxGAkeIDMzSzsKaRZ1lwpgUqMer5TaHDnEpkaIgZZMfsOqpA8RWUN+2zjTgvjOfaVYKGyKngIIJlMo8HLeYjEJCAxclLMbSc3E6REbiOvKbA71d7qJwoUTrlZ8k84ChWUib0EB1BJ4kRHkXbol+3UEx9dpVwBOkwOZIq8PXkwCcQ5jcrb5E1z0R138KxgQG7InKhjH7rzeWNdVJj53a29tMFnCwi7ZYk3ntwI3LI5cTkReNXmcQgNXi02DD6htUFUhwk+nWPe65FvnSQJWPe/nYShnBZcQvuecSDM25kJLew9a0WrCiuxVZ1BhqaRAA3DNdmXkpAKLmiYX8w3DZwWxvXkPqc2EQ1xZONBrk/8JeCNm4aTE2pc6/wLoY3nJnYkNYsnGTimwac8iHrNbCI57qaE2EVEKnnBNhxzk4ba5DYpAxDioAVPrmS2aXWf69jkRbcUYjdfvcjYHA8aSqMKJ5m5VtAw8aj3dBcmEtDSCV/GfT05RmucyqrGoZ00T1X55naaFoZ00TwWocEpYBxvjoBFuSFKss7ecDFOPDNr7ViqBHKsY79nc8OGDQwMDLB69WqgEaaNoojVq1fz9re/HThwhesf/vCHrF69mr6+vtRvk8bfJCb73r1796xr3F100UV84xvf4JprruHSSy+d1TZD24Zxo4ZreWDL3lltc7ThdUqW/EE3Ti5meGSEn51eYte8iTeKqqDrEdLKOrUz3ERYJoybs6IUmjZtvoF3xzGVhAdQSkV7bLYpRz7jddMAEnWZ/lK1MjNjERul4BAgbRZ2CwjHMgBj0SirlsAOVTalUISZFAItPCmQTvAA482sFaia7TrAzDDQ4JW9hor9BGTQyCjdH7QkXUEgThs39kdv5CqcQvOaiFgxIoaQornDUDhURKJaCoLdqkgt8QLdFypIGECTX+62d8WeqGKlUclZusVM5lYd/HHzfijs0yljLyrBjrFmxZYoAu2kr1MSjXJZ5rVWcdoA9MfM/XtjpjfPq4D3/7f353GeVPW9P/48p6o+a+89PfvGNgxgQASCokASchNiMIaIyU3kmh83BpMoNwE3BhRQFEdlxJCLEv3hw2RMTOKNGkTQKLhGQTGKsm+zMNMz0z2992er5ZzvH9XdnzpVNd09Mz3T3TP1ejxa+dScOnWqTtU573Per/frXTENwNywjwxi740XC1SwpGEUayEIClZyd0+YZZRj7uQqW5jGRYohpS3wSskJN7FxlZZlJTpRi4lI1agBGNulhImI72iAhQVB3ACdcHftGalO/Y7vwIHZRi3BC8z7j0ccA+RGtLlz5WmcaswAjO3IBnlJVUqj7oYws4wEeY3fEjMAazEDUCcjrMNMNeY2WWFMmDvHKnyWUfjuzLvEqQZg2owcNwBTdtYNA1RD60CAXT/wIq1vfzUMFIy1cVYGYLyMFQZGRRGP+NYiWXfY/5HFlgp34CfbKVG8ovQiYzWHJ90ljKgiqj4zxex44ADOFablAG7dupX77ruPr3zlK3zlK1/hrW99K0uXLuUrX/kKv/VbvwWECteTmI3C9c9//vNU8uI3v/lNzj//fGq15mTwxBNPIKU86ATHt9xyC7t37zYijBcz2k7Ns+6PuvBGAp7//+/nqeqapvGXIUOGDBkyHGPossbQCB6vr2NEzX6+EzA/HMAj9yhSMT4+zj//8z/zwQ9+kMHBQb7zne+wa9eug6pjWgNw1apVrFu3buqvs7MT27ZZt24dp5xyypTC9c9//nMef/zxhML18PBwIijkmWeemUpeHMW5556Lbdts2rSJF154gYcffpgbb7yRN7zhDYb24GywZs0a3va2tx30w1hwsGHl77Sx9NdaGfxZlV1fGV6U28wHxGJkzc4HFvpjyvpxbjAPtKWjDs387dBkOGqYiyHBn0nb6EDQ8/h3lLBt2zYuvfRS/vEf/5F/+Zd/oVKp8NWvfpXXv/71/PznP591PYeVCm7z5s185CMf4eqrryYIAi655BLe9773Tf37Nddcw6pVq6aEnYMgYHh4mPb29kRdnZ2d3HPPPWzevJk3vvGN5PN5LrvsMt71rncdUtuuuuoq7rvvvllFJS8kiHPOQJ8mWV4YosVq4GvJL+0VjFxQglBukfpSjaqaXSc9U0BVCwgKynT5KMloPZLYHPCU+ZHVXQcvmqAei0ZMiFkrgcjF3GICMzhCaNPdC1hFHztCjFNKhKLKETg5s4zWgiDmpnWVDY3IMSHRvmXqdVkaGXP5+g3LIFjrQCCq5vWFbwZvyECQqybdInFtMLtqnicUyQk9Rp4WCjNQAUJidMx1lxRZlfhuwSjzLftUnMhzayk06C6aPmhLKgp284KWHeAn7kMaLiYtobE0MO7X6aqzpqsZaa+0YKyeR0V8WqO5MiIqjqbArpsE/zQh6FCcefr7l42ky00OmYWcCtiViHtJQ25MG4O0XVfYURe40liNAGIuRumZPjflYEbTTATqGN5NWyY5eDEh6IQLmJDzFoWOaSBC+ruVmHAVGOrlItS9M67l6gR3Le1aMtYmocN+mjpXJ7mECYhk5dJPuq7tmkkTEIHGcmMu+QDj3oQCp2Lem9cqEvmzZSzgTcuYL11PjqORQ0HS5Wo1YsFDgU68j2gRowkk32Ntp7iBY/0RF9yebKdRJjD7SGhCWoRtfkdTpzsClROhCzjRxhhtSCdd7vHfCJGgEmgZ026VoGZhIUUFtQvCPaRMTccDB/BDH/oQv/M7v8ONN944RdGbDH79yEc+whe+8IVZ1XNQBuCVV17JlVdeOfV7JoXruFafZVk8/fTTB6x/48aNfO5znzuYJnH++efzzDPPJI7bts1//Md/HFRd8wlZkiz51TItG/qRUjNu5Xk8v5z+Uiu1lX5yhI3x6xIvvQXaju1La2Fk0BBCG5khAHzfQkfq1lqgvfgMrJF2zAC0hTlxSrAKZpsLBc8QZ/aVpBYzwGw7oOA0z1MaGjGxYiEwRJdFIELDzuA8Jocb7UvzGfkSq2reWzzCUAQCuxKrKGWglHHyeAoSQTmaxKAhBcmJI24k1OKzP9SGitQifdIo2zjSrNySChl5/jIWTQsTHMDohKdB55QRvNNarnNCW5MrG2jBHrvdMABrtRzKsY16gnxMeHcyejA6T6UYNwm+WwAiNnHbVdMIsqsaOyrErUODzxDHdVVo8Bl1K+M9DkWmYxOgVOhIJwmRbLfW2mi40KEwcDQyV9mxvtXhomimiGtm426Kl0mbyP0kB1CLGE8vLkw+VVfkeIqRIrRpbGspDGFsmAhCiT1byzXFiUWgE9+I8JX5jCxtZl2BcDEcNwBji51gou3GeXEOrMYQsJ80fkXkucmUiHftmx2QZlwpMCOV09qT9vxjEIHJm5ysI369SWNPWSIMQJIpZeK8xSD5rqUtNuJKDTJI+W7j9xFb/JljnWI5I1Ti6tkZgJBKd+ONNxrHhBBcddVVBxUAe1g7gBkOHx2/UqT9ZUWcNklQVQyMtvHUuiWoRMx8hgwZMmTIcGyjTJ3TCTOOPROsmFmsOI75ohgcxWsWCgWGhoY44YQTjOPbt283Mq7NhMwAnCe0bsiz9MJWEFB9yaX3gXG8YUXjd07KjL8MGTJkyHAcQvEydlMhx5OsQhy8+UdadPnRQJxycCTxB3/wB9x6661T3tfBwUGeffZZPvShD/G6171u1vVkBuBRhNXRjtVZZPkrA3JtMLpDMPhLCeSg3IJdhmoxThQB4cmE7EgCKeLE8W9HCG1Io4iUr0RKjYjm4kUn+G4JTLoy4xzAmA9A69Bd2Pyd5On4vkUj0i6tBW5M8kX5KfdqacNNKWxFLme6oOueRM9ALI4LryZcQpDqf5uJpzN5LJ7XU8QegIg9E0FyYBFqQuh4shpBKHAY4VN6js1Yo0mokSJ0AUf73Pdlwk2TEAeWhHSDSBsansNQo6lDqBCMuzl0pDLfs7Ci/ZSyKp/KKxrjCsUR52ClaaNJL8avDGIuz0nXnaEVGXMvpmj+oTVCxeU0Ys8t7jZNgRYTnKvovcY15iZcqYc8kcT5pdEmpjwzy9MJZkkiF7NMFzSPctPC93H6RgutEzIgQukD1K1jv6etOrx+XBrFBRkZNiwLGjHetNWQCddpmgs4OvylZXyIv8OTbYrJoiapBNqkBITH4q5ssz1pXMJ43t9UHOD9THPnpoozTwetTckxMfHtifixZJvizSriIaXmabUCkNg1TW68eWLgBowzA46DHcC//uu/RgjBm9/8ZhqNBn/0R3+Ebdv88R//Mddee+2s68kMwKOIlkt76OkYoSZsflJYRf2MHJxhlolnYhABFPpNjatUbSZHm4ReC0TRHN1bynXaixGx4AnyfhSFnEch12QiS6loK5g6gDXPYf9wi9kATyIiKsva1uicSSDxfcswEoJAJvT86nWLuo4EOCgQ9bDM5HNJjGVaUOyqUS40SUZ522d52UwJ+FTfMhr1plEUCBKkF6smsCK3G05u8QumIM1IjE8Kvk4xAGO3Mpkd4wC/ASwXg9+mBUjPNvo/KFkMjka4kwLIK0MLUbsSEbl9oSEoalR0MhFgj1jGvVR0mScbzaFDa4Ffs412WiM2uZHY5BbLhqCsUBzYj0x60hMJQyYuKC09DENNaMiNxrhjKmkAOhXfFHn2NSIW4CEaJgtfBBpRM9//oLMcBhBMFRJTwrrRY2ZFEyLXkT7ySwKD4qQnhJCj/a2SgSGTZY3qY++fUzF5cULpMOAlTuCPccCCnDQ+CW0J/HyM7xqAnVdTGooyALsa10o0+WXaAhGY45j0kwagXVNmv8WMxLiBBCGXMz9sHleWTRBpt7IhN5wzyqQt7qSX8o3Gyignzp3TCe6c5Zrvn/QxdflS6g3bFO/YpJHol+ILkGQ9aSLz6cFESYNzunNInjLx2zwofdDGBylMgXtIcAABPHIEZcn6YJCdjR46nhpF/aLJ8fftBqxLtinenpl4k0cEOvVxHRFYlsW1117LX/3VX7Fz506CIGDt2rWUSqWZT44gMwCPAnLdFit/px2rPMKL+SXsync2/zHNAEhDfFdothc35iRt7vodIOVC6s7gbJaC2hwUo/8362AuHSNvazGrVWj83qTQs2tzvJ5DcR8cYLfviMp6xN6H9N1FcwdO61nuLh0g8MD4Gd3Jnfyf2PVmhcgkMO1zP9R/OxQcoclDp0zmid2W+Md9GO9QfCcNZRo3WpA0COM4wD8LDvI70bH/P5hrHcKWaGLHc9IoiD3vVGNGH/j3rHGgMeFgywAi+fGZC4wjPdYcZex1O1iVH2QsKIBSGCvS+G58Go6DHcDnn39+6r+FENi2TW9v79SxaIKO6ZAZgEcYyy9ppeXkPLW9Hs8Nraf/jMLMJ2XIkCFDhgzHIfZ6ndgy4MRCH9XTHBrFEn5F4Y8rqpVZZI46lEX8XOAo7gBedtllCCFCtQGYilQXQiCl5PHHH59VPZkBeIRQXp9j2W+0ArDn66NUdrio351FIusMGTJkyJBhkcDCx7YChAhljFyVm/mkGbCrsYRxv8DafD/5DQWELRCWoO467PjRDCcfBzuADz74oPE7CAJ27tzJ3/7t33LNNdfMup7MAJwjyJefTm1FGSl91vf0U8w3GPLKbKsthQskXADjayT1rohbBrBjAqahyKlZd5A3D2g7QV1DWyZ5WzsayzFJ/8WcR2uuyWfylUy4SQu2Ry6qFYemZJsCXn5B0lGoGce2Wd14kZy5QoCM5XQNfIsgokOoNcmlmi8NjT80yJiArXI0qtR0BeicorXYoD3fJMblbZ92x+Q7tpXqVCJBMHXLwS+ZDzKoWiZ/ZCLPp+GGSlthxn+LMDjCKGLFnDk6xb0V46+kuqlU8nqiYB4TARNCZ01YwyZPT/oiVVMwDmlS4LBcCz1gZqSPp++1aiLM6zmBNN4qkNSZi4tlT+Y5jRzLjyqcinnBuFgxIvaN6JDzZ/jAU1yLquAkjomSOaFpS8S4WjpBt1I5iXKipEyNUzV5USFXKR4YEatIHyDAIFYmLuhsuRrZSN5fPMAjoQNnx3K9imSAhVDanGRT2qjsWN1pPDUpTJ4YYd5hMwhLgzu9209bwnzWTGgsxuVL4yLLk/cRQTwXciLoQoDXYgp4W67AGYv3a1LQOhEoEzdUBKGeavQ+HGHm2RWEnMwZOOHxPOwy0FgT78PkPc2GKxfvV1v6dObGaXFqFB0XWyalmj1lsWN0KRW/OUZoqZGxNukZYqdG/RaeHSviRHb9fH90mjMmK+aYNwBXrVqVOLZ27VpaW1u5/vrrueiii2ZVT2YAzhHqy8uU142xjgE8bH5mr2FoecF4w72yRhWimQcEwjMnAQmmWO7kRBYZhJStUbnkhGcMCrZGWqYBmLMCClZzFFRSGOK9AB35GuWYYmveSm67d+bMLBP9lTIV0WS0ay3MzCCACgQ6mCkKV5giz5MGQtQosDEtDivMcFG0m/dWsD3yseiNkuOZ3DUt8HLmJKBtbUyAklgwQbRN0yAcYGOGeywKVGiTSxcWIp27FL2+1olJSihT1Z8U48KqxbKceGbAC4RK/NF6poRvo8+/Zmb0CLMOmPVILznhBjnMET/FiE7lbgXm/dp1TW7U7NuEAeJMqkxHrqWTBP84tGOacqE4bUws3A0QfrxTYj+ViBmbAss1F2mhkZRsw8FC6KSgsvR14lgcadGrkwLBZsGURUp8YRKfyePjkUiWC4/FxgiFIY4spBnxbtQ1+dsSKCdeJmldxAMsUqPJY4EpWoKK8O004Xsc3+SKLhvC7zG2kEtbtKUY8srBaLeyhRHMApNBKLFz4/caX5F4Yup71BOGvwim91na0qOzUKGcq1G0m8ae0gI3sBlzS4w2Sow2ikxOUBKf9R19nNyxh8f2n9hsjwZNyvOfAW6bRb2zeTOqUYC+6c+Zzfh8RDAf14whn88bXMCZkBmAcwCnXbJu1S4cfF6ik5fkkjkZ2DNkyJAhQ4ajibJdY33nPiyhUFrQCBxG3dLEXxExzeSmsHlxeDlnLt2OxEfNh4lxHOwA/tM//VPiWKVS4Stf+QrnnHPOrOvJDMDDRNd5JbpeUaLuSn7GCfgye6QZMmTIkGFxYm1HHw3f4cWhFSiR1AqdCa25kPsxL8YfhxChvghxzz33JI45jsOZZ56Z6QAeLSy9uIW2Uwv0fWeM/pNPwD05oo1mkdyWT5MYEBhCy1oKU7/pQNyp+FcZz+s6iy9ACk2LY/oAW+0GZds8Zs1ibztnBzQiuWi1Bs8z/RAi9Kc2D2gSAtZa6oQ2WeozMHhjgrpvU7Gafhk3IToFFTdH1W06a1zXNrQLIeTOJNyEcZeTTB6bKjv5n1YsGTskkr9PCrjO5JZMXEYIk982wemJc5USbYu7hVNWyqnaZGlu2Rnd1LFzJtxihg5cEHKurHrE5R7LqTwl8ht/RnHXXULfThuvyFR7Yyrb2jJ3M+KcONLypUqBiGrcxTX/Jo4Z5030T2IyTeun2SDulRVmn8R1+NKupaVIiMWH5eIFU/iVEfexIOUZCZPuMHXtae7vQENWsu74iSEtQhs5e5PixHEuY1qe4zTh5UQ7Y8LLMp4/e/JeUiggxu+UmMAgJ4znHzhJekXaeXEk3ofoGBr57zhNJW83cGTA8wMr0VpgucrIexyeM/21u8ujNIIYl1YnX/XZQKeMNTOfNMtyc42jeM2HHnpoTurJDMDDQOspBfY/UmH0mQb18yxqy6Nf3ISobQTCB6uaJCsbv3MpX0r8xUojVDsK7AgR2dKJ5OfxgI+y7XJ+24vG8Q6rQptsBk8ECMaCIkFkprBQFGIEr/EgT3+9KQ495hXYPdRulLELHlbkWoEWeJ5tjJMuoO1IoIgKr5iY8CvNMlJZ7NvTQZ9tjtw6SjrWIGqWyS/0Bflxs4xdJZEdIM2Qiwv4Ss+cOII8eC2xCSC2KJAeOGNm3XYtxlWKD4CEk0QQVRMSoYCzNniiJDgplisMfmmayHUqdybBk0pOePFAEaGT/CLHjBtC+tBa1bQPRhYOaQZJ7BlYDW0KOgcaZ7BqTLjasdA58+NSdkxQ3YoFaggI8jLxfcUnbssWaM9cyFh180GqnMQvN+vWUuAXTKNIJeNNEhBaJ42LNGM7xufz85LA0WaZGEKjIG7cpjQintGHkCsY/S4S30ia4RS3I4OkEHTi2VsCvzSD6aAnnlOk/61GkoMah1NRicAM5ZgcyCAvE/3kjJtGmF3TFIZV0uCKNlGC22o+XK9sBpMgwmNRozxt0WC5GN+W9EJerHE9EetLiylB7yAXinvn/GSg0Iq2IVzfRtWsMABwxwjB0y9wMFCvKuOcUaDVqTDmhfxAoZMczDTEF1NWnLfpzlzHfMrAHEl897vfnXXZiy++eFblMgPwMOCPB7RvLDD8y1pixXsoq535gBTa2OHLiQBpWA4SKZQ54AgVKwNWTHhZHuBriAalTAoVJzZQpmWXJ4tM7TZFAzyUmEj1EYESid2l2Ub0Gv98oF2c+I7HDMT4qWNzNXBM89LNekBM2fFMPfcQ25zot5RdmETU66zbHt8Wm8WJKf2REGuOZ2ecxcedSHE3+fsQB4aDntBS3tlEHfFduoOpO3ovenbPJFHNXL73KXXNmEIuVRk9bfdzNgZo8toz7vbG3gctxNROcfPYzJefNVJ2AE0oWgo19g51RRqgTSHmWWDgJ1WKp5Y5sX0fAL6yqHo5+ivtVL3iDGfPARTzE5BxhK/51re+dVblhBA89dRTsyqbGYCHgd0PjLD28k5O/NNunvQbQH7GczJkyJAhQ4aFBcWJy/cCgsHxlhlLz1AVL/SuxitLinadzvw4rU6Nk7r2MlRrYddoz5y0+ECYS5t5IeHpp5+e8zrnNFb14x//OL/xG78x9TsIArZs2cKrX/1qzj33XK699lqGh4cPeP7999/PqaeeavxddtllU//+uc99josuuoi3vvWtjI2FCUIfeeQRTj311FRS5Oc//3mjPXMNf0Tx4j8O4I8pXlZ6CTmbNDUZMmTIkCHDAkEpX+O0NS+Rs32e37OCuTQLan6B3soSnh1cw4tDy+gsjrOxZycrWvfTURijozBGT2mYFa37Wd3WT09piHxcm+pgoefxbwbEbaTDge/77Nu3j97eXnp7e9m9ezfbtm3jvvvum3Udc7YD+Pjjj3PPPfewbNmyqWNbtmzh3nvv5WMf+xidnZ3ccMMN3HTTTdx5552pdbzwwgu85jWvYfPmzc0G2mETd+3axQMPPMCnPvUpvvWtb/EP//APvP3tb58q93d/93f89m//NqtXr56rW5oVymtz5LosRlRxQq8pfAu0Eglx2jS+S5A3OX86p9H2DIakrREx5V0n7yMjIseOE3BC16Dhil1WHKXNbvL7SpZLmzSJWQXhJfh9cXevh0VFmbudgTY1BRWCIEXzT8nmMSE0LUXzY3ccH6WaZYJA0sjnTE+NJ5HVCE/QmhQ5nn7dZ7kmd00okSIOGztJJHmaQS7k3EUhbdO9nCBqa5Cu2T7pJbl0WpAIgonfVpAHP+ZJ0TE3mPQxhVcn+I0GBzBl0BIieb0kdytJHo9DBEkuZWFEGdw9ZzSg1fKo7xmfaDS4PeUEnyzOHZKBThzz280Uiypv4Rdimn7WzPsCsyLYW4IgF3mPA40Vy7Nr14JEUIZXto3HrZwYl1MnA14SeoJMcDCjcqJWkl8WBoFE6wFnXKe8IzEOXOwZpXG3ptqom2USIsdxpJXRyfcoyMkZJbRSdTFj35HTUAmeqFU3CyWEoAX4LY7B+Qz1FCNNFuBUTZ6g5WmshtkoZQvjO9aWwItxGetdwuAXaglem0qK/Md0OZ1RUyxbuhONj8Byk/c2GRenZPjfXkmyrHWQ5blhhv0S2yrLyM2CpzcTdBBQenqfweVWnS1UVpV4qn8NK1sH6ShU6S6Nh/nJCecOrQVtssqKliEAAi1xA5uql2fcLTLWKGDPxjicJw7gTIyTNBvpUPGd73yHG264gaGhocS/tbW1GRtn02FODEDXddm0aRNnn332lAjh+Pg4W7du5Y477uCCCy4A4D3veQ+33HILnufhOEkG9HPPPceGDRvo6UluEVerVbq6utiwYQPbt29P5Lrr6uri/e9/P5/5zGfm4pZmhY6ziix5ZZmRx2s8vfEUVDQIQ4VRadNFS2oJ2o4ZgPkAWYgNVLF5S0qFFTMSc06YjmcSRcfn1NZ9Bi+v3aoZxp0jgoSxVxAeuVgKiVwsfK6icwzrsnFMaYmKjFQqRQg6QKIig7JtK8o5U3S6GBN09ZRkGPPj8ho2uhEl2GvsqjCCbrRITubxQI1wUjLLpJLl4wOyPSFqHD0mYwPuRP3G9eMRrsEBgi7i3LHYhKgcUNHsMCkrUKFE4t6sBmZEXwrfjWQMRBJpq9240RiLlAwNkAAZCZ5w+qsQjMGOiUHMsnCstahCJKOMThp7ypamMScEQdE2DNegaOEX4xG+pnEbRm/OsEhjkisWrSd+syIR9SndwDBulC0T/EotY4EgaTw2RSKrg44ZLtoCv2zem8pjjkeBmDAmm2XsuoZYoJqKqxdosIgtbuIR1yl9lHYfiWwts0VqQIn5/sfF2u2aKdYtfYU1Yi52tWOZg6sQqJxlvFs6JeApgZjAuBZM5GbVkWNJQWe/rI1gMi0h6PATaXWiTVQafN8xFnK2EKjoMKonFrvxxy0j/y+hMz/KcjnM82opA7INUYLcmD+rnaxpoTX+9p3GIfuEdbCqiK9sdo4sPfCpQgCKou3SmqtSztVpy1fpKo4hgFqtxt4Zr8/h38OhYJprptlIh4MtW7ZwwQUX8L//9//mT//0T7nrrrvYv38/H/7wh7n++utnXc+c7PXeddddrF27lksvvXTq2KOPPoplWUY0yitf+Uq+/vWvpxp/AM8//zwnnnhi6r9t2LCB1tZWzjrrLLZs2cKVV15p/PvNN9/M97//fe6///45uKOZ0XNhC0teWWb/Dyv0/1flqFwzQ4YMGTJkmAssEWNUyDNA23w3JQZJzS/QV+1i2/BKntq/jl/2ncgv+tbz9MDaGc+eTHF31P+mMQDTbKTDwfbt2/mrv/orTj/9dM444wxqtRqvfe1ruemmm1LpcAfCYRuATzzxBP/2b//GLbfcYhzfsWMHy5cv58EHH+T3fu/3uPDCC7nhhhumuHtxeJ7Hjh07ePjhh7n00kv59V//dW666Saj/Ec/+lF+8IMf8M1vfjORC+/cc8/liiuu4LbbbmN0dBb5Ag8DneeUaD+twJ6vjzD8y9rMJ2TIkCFDhgwLCFJogkWVsmqWbZ1rXt/B/KXgQDbS4aBYLGJZoWvqxBNP5JlnngHgjDPOYNu2bbOu57BcwK7rcv311/Pud7874batVCr09fVx9913s2nTJizL4rbbbuO6665LddNu374d3/exbZs77riDvr4+Nm/ezN/8zd8YFm1XV1fi3Em8613v4tvf/ja33347H/jABw7n1g6I8gk5us8tsf+/BfVqB9bEbSuHhLs3rs2lJ7bep34LQok7Q+Qsqd8nZExyxdLI2DHbCrAi59lS0VC24QIeoch4xOfgTLh2ZcTvNSoLCbdwLuYDqSuHQd+MFKv4OUN8OVAyoYVgWcq4N8cKKNjmtQIt8ZX5oVuWMlzAvmVq3iEJrxPNvZkWCpbm3k2R+DBOS+HEhTy9ZD2J/o96Wyd+zyh5Epe0SLlWAmKi3khlIiaFMHX9mOc4weXTpls4Tc8vLYl8XK4iFHA2L6aFyTHTjoXIFRHlCf+VFGHe3Sh3Ksw+al7LEmZ+XpGiQ2el9G3MBaxT7iNNUiShwxckdQhnhA5dztHHLf2kVl3cbc9Uv8UbFSmS9o5KHaMu6NC1GalGWSkc1BTuoI6XUcTkSpL5g9Pem7m3NRS2DMhbHvmcT9XN4/ohN0MEGhlxAQtfQRAXxrQgzjfV2nzdhAj9rgcBMdlfKvo9xp7HgXgWIkn5iX60IuXENLmZxPeYRi8gqVwiG8r8br1kHvhDgh9g1WYRJJkiqm7Am7mO+dIBTLvmdDbS4eD888/n7rvv5oYbbuD000/nX//1X7nqqqv48Y9/TEvL7KO4D8sA/OQnP8myZcu4/PLLkxXbNpVKhc2bN7Nx40YAbrvtNi6//HJ27NjBunXrjPKnnHIKDz/8MJ2dnQCcdtppdHV1ccUVV7B9+3bWr18/Y3va29vZtGkT73znO3n9618/6/voWt1BniJdqzqmLee0CVZe2sHIWIm+PzY7s92Ctui7a4FaEuMuFRTkzBdYxrh8pVKDtkJzVhBCU7BiIrOAjn31BQucSBBIoGwGxjYYgRkD42UaDVN5VHmxUVlqRMRIk0LT2V4x9PuUkvixAA8vsFCRAc8B1hbExAQOAk1nuUrJad5byfE4p63PMEB3NzoZjxDsAmUxUAiM+xjzNANO8z6WOTa5AWm+zCmTe1COTUIiVNqPwqlh8GuQyYCLIA9+m9knwpfGaCo9gV0x+8iG2OQClMy6hR8rI5OJ5wMn5HhNQU8EeEQNTt9MKAMgC8lBKv6MLD85cVueKbKrpUDFjSvLtJwtpbEilWsBwfqiaVye1EahtUBpuBmYFA9KQGNwuQCCghVmTDBuxPypbEE0GYwWoG2znPDAjgrL6vBeTS5lyF2Mwqp5yEaUhCXRy0xOrHakYaRqIejW5juiawIdCwwKYgYJckKcOM7vi9ybssDtMA2BoKRR+YgBFAjsFmlyAGshL9S4ft6sR2iwYk4OuwEd5QJeQTTLxAR6w0CVAxutcCg0LcWq0hCtuRoidrbWAiEqQIU9w50Ez2hErR75d43sEnSeAYVOqA/BwPaywTcNGy6Tdlo8o4cjDUNFg7kgmTgx+q4HBUm11TLOqZXM71hL0C2NxPgbDfjTCoJaERkRtJcOOPFhvBj7tjVM7hn0tBZAwgoKDNDK8olBSLrQubcXVWt2uFYK1ndz2BB1up7fOXO5GdCgxv6ZFhILiAM4nY10OHjnO9/JX/zFX/DFL36RN73pTfzDP/wD55xzDp7nHb1UcPfeey/9/f2cffbZQOjG9X2fs88+m7e85S0AnHzyyVPlJ/l9vb29CQMQmDL+JjF57r59+2ZlAAJcdtllfPnLX+amm27iiiuumNU5g7uGsf0qAP3bB1LLyByc8Bvd7Hm6n+31U9i1vmoWcM3xTTNB1I8O3CJAxLZlZCzXTWtQx6NqVFTEM3byfCUNgwighGsEb/hIBnxzUtrnQqPetHi0Fmg3ti1ime0RlmasUDUCU5UGPzDNCz+QRvSuSFkO+XqcFpozjkcd3+o17q0mPcZU0yryhMUAHiryIIeDIvti5PW+cY0ToWLGgxC0AN/D2BXRciLzSgR2xYwM1hYEQWxyVRo/H1sZ+8JIPSUbAmfcHKnsamzHRSQjjC0X00iwYllHCHebg0gwh9Bgj5sBR9KNTe56MoMGxnlxA1B6OrGTaddjO3BSJAJj4jtwVkNjV6NRIAK3VRoBFJPX2TfcfN9lzABNCx7wSxK/ENvxSzMAY1kWlGNOylZDY8cyIdj15PVzoyYx3h53kfXISyJEGFAQvX7OCg2FqfYJgoJl7kBaIjRKIwgccwtIC5LBA0XzeSsH6rEMQr7UqOiLpMCpWmakckVgNW2kcEHkxXYAg9BQjMKuaQhg70S/pRmAlps0AFOD9GdKOzeBsl3jpNa9+BV4cl8nNTdPw3dQE1mCwghjxakrdtOo+wztljDcpA+1roclZ0GlBvt+Ch0boH+PRBVjK0AZX9noRJtUzjZ3YKWAWPR0PFDIK9uM5813pFISBJEFj5ag3ToyYvAJqYw0h1oL/Jo2At6kC864+V1ZtRQDMHKtPcNV1jHM47ThTsw3VgO8F/tR1djctoDg2y6cMH2ZeDq/o4W0a05nI33mM5/h3HPPPaRrrVu3jgceeIBarUY+n+eLX/wijzzyCB0dHZx11lmzruewDMCtW7fi+82J8N577+WLX/wiW7duxXVd7rzzTp588knOPPNMIIzyBVKlWr75zW/y3ve+l+985zsUi+GWyxNPPIGUctbG3yRuueUWXve61/H5z3/+EO/MhN0iWfMHHQQNze57R+C35qTaDBkyZMgwAySKk9v2UvHyPD+2HOnLA8gQSYYqLfS0jZA/22LvdwEV7nwveQUMPQnDTwN2aADOT7qIhQOFYAnj9HJgWtWixALaAZzORjocOZjXv/71vO51r+Oyyy6jWCxSKBRmnf4tisMyAOOBGJ2dndi2PbW7d+mll3LjjTdy6623Yts2N910ExdffDFr1qwBYHh4GMuyaG1t5dxzz8W2bTZt2sQ111xDf38/N998M294wxsO+kGtWbOGt73tbdx+++2JNh4sZEmy/o+7cId8XvrK8GHVlSFDhgwZDg4nt/USaMnzY8uZiRDbN9rJaK3ICV17Wf97UNsHhSXgjU0YfwAT87G0j28TcC/trGWQPB7bOHxtuoUCwTxxAFOOzWQjHSp+93d/l/vvv5+Pf/zjnH322Vx22WVceumlCS/qTDiiqeA2b97MRz7yEa6++mqCIOCSSy7hfe9739S/X3PNNaxatYrNmzfT2dnJPffcw+bNm3njG99IPp/nsssu413vetchXfuqq67ivvvuO2DU8WzRdVYB5Wl2/r/hqWOhxlzMvWGHxOspSNClwHgTcyWPUqEp2CSEpr1YN1ygaeirmKTOkfEi7licGJZkgouYm1SXAnLCo2u0QfuYi+0rAi1RUqIEBFIQ2AIlBa4t2d9WmJ14LmB/v53yXpPzZbhbhWDHBSValo9PHWspNDi1pd3gilXjhDegZJtagY3Axsk1V1W2rQiKGC5YEYQu1yjiJHwtzHMmyySCOZT5cUsPQ4gaQpdvQmQ3now+jYgdPxYnMKuUwACYyqM89TsuQyBSSPcpQRDxInHXqlBgeea9Ca0R0XuLBXcAeCVBoz1CNxDgl0RC1LbWLqlE3KdWQydmZcvDDF5wDuA6j0IfIKAiUpHlpp8nYvc6I4TAb80Z7mXlCHTULZ6yKyF9DVH3thDIeLJ7AaohTO5kYAoIh3xAk4Pp1QVBwby+5cb6UZEIJgmfbcQFqVICPJRAO01uavj5mtcSgUYm7tf8ra2kWzguTt6VH6Vkuzw1uBoxQTEpbx9HViK+6xQ37c6KoGOjprQcqr3Q/xgJyFZBIJPjjdGeQBnalWG7Y5EackLnMYKgYNIdgrxIilWPg9Uw3f2uzCe4q/FBIjcmjbqklzLWxL5/EXlEk9qiO3QXSxmlg1pqINGixQLaATxSuPrqq7n66qvZuXMnDzzwAF/84hf50Ic+xKtf/eqpncHZQGg9mxHu2MSuXbu45JJLWLltI7afo2d9d4IDmF9qs+byDrZ/YRB/NBwI3EvPY+dvxzg/BWUKeFqafGvDGCfayzXa882By7EC1pcHjSCIvfU2hhpNDpyvJPtGWo0AC7e/RL7PvL4dD15QipXBCN1Bhbz2yOkAa+IN1QI8SxLIkDcmJyL2wrEmDNuQE+KmSoBXkNRaJeMdNkPLHCotEl9HJndgxWYHHv5F8/pCIItF4/fO/3MWtVObxDSn6PHbJz0V4zdaeLEZx1fmvfY3Wtg+1FzprLBaef45iV2L8mIEuWHjtNBIjw5yKUaSiBmAWqaIPjsQFGKcp7owo27jmTBICkETM5IBZCPGJUkpoyzz2NSkqc1jxoSj0/ltcd6Kss1nIgMoDCmTOxhok5cnwCub/Da3VeC2x7hsBRIGx8rWIr3jtUgbSUQvxyc3Lc16Qn6beW/ST2aeiPOyLFcnuGtT5+PTmqtTtusURYOcE2BZYTBS4Er8mmBgRwm/bqMdi9qKssn3dWKGkwa7GgsA81Rq0IuBNOO61UZFBNO1DA336PP3yyLBHU3LThN/H902neAlxtuUHxSsLhTZMyGsLDQJw9WpaqPfhAqfdfQ9CnIiscAUgclB3dD5Ep6y2TayYqotrT94kaC/n+lgdbSDc2Djbv3vw94dHQzTbv5DLKNLmEGk+SFrIdA5aRjkWsaMfcBttQyeprbAj3M5SyK2SAavhaRSRAx2HfM7Thlr0gzryflhRXvYd6erXbRR51HW40sbq6Hp+cJjC54D2HvC0zz44IMJKtnkfF4+70+Qhdaj3jZVH6Pyk39ObduRRrVa5Qtf+AJ33XUXtVqNp556albnHdEdwGMBjT4f5WnKa3OMPF6f+YT5hlKs9wdY5Y8g0IyJPGOyyJjMs29ljtGVTBGdZwoCsV2f5WN1ltfHKY8GrHixwepnw2fg24JGUTLeZjPcZSMsa14WXRkyzBVacxWWlYYoOeG2oCaMQvdci2otR6ORw7YD8tIlX/ZY8/IRdj3WjuvPIn9chkOAomB79A4fAY6aAstREN85O16gFB3UGKKEL48tM2AhBYEcSdRqNb797W/z9a9/ne9973v09PTw5je/mde97nWzruPY6vkjBNXQFHocRli4BqBUipMb/SwLRtEIdtsdbLe7jKi28ZJCyNkn2vZzNruXlql26mYUsFIURhVt+wLahj3aBz169jSQL6vA6UvwawpvOKDe5zO2TeNnSVIyLHC058dY07ofKTRVL8/2kWWMukVAIgIdysAkooAbrDxjjFW/Msq2n82dvleGJgpWaJ25ca2mOYAOCNNpHq8GoJQ8qVZyGr28Qm2nnxb64ruhixXHgQv4mmuu4fvf/z7lcplLL72Uz33uc7z85S8/6HoyA3AGdL6ihF2WNPbPIIgZ+k2bv6XGsswlQc4KyNsR7lpKkkkpNFElqpn4gbby2Tjaz9LGOD6S7U43u6yOpJwBYNUEwWjELaJDV6nZgCSXcViWDVe2BnYvEbBk8oBgw11VSn0vUFztUOhxaDutQOfZAr+q2fW1GmrCtRnND6yVYMwvGPerEAQx/4VKuIRNyRk10bgZOSw6KdUzG8S7QMckZsJGmCvA1FVojF+WuL5mwg8fOXSAe0q8FvHzUgZBLZPu5WTFyXO0FIZYuTTFjIBkDlltCAU3jyWuKVKORc9J4zLG+EoiLS4g5f4TunRasbZ1Hx2FKoO1VnaNdadWJl1lcMyEpxA+7HuizLpXjSBU+tgQ19NL3KcUMAsR6YR2Y1xkWYsEn4/4OyqSvMnUvoj3m44ptWimxKIn3Zdag7Aw2qSFiJEpxawEs7Vs1lPTeWp+jlO6enlhZDm1oDD7j1ZpUAdO4qsCie0odGxNL6Qwch0LkaQOhPcWPWmWY0/K+2jIIjExRkbLxL+Pifc6MdbEbzX+raU8t2FZ5mdqHSfSzwpGWGMPof+4jF8r4lcU3qimMaio7Q3wm9RtVGVhr+oXkhD0kUKxWOTOO+/k1a9+9VRGkENBZgDOgO7zSgghcNolwgZ9ADtQFH0K5Saj3LIUK9tGDT28DW19rC80OYaetni+utTQ9CtbLsVyc1naCGz2jrQSH63zvstpo310eTVcafFMYSl9cvoV3IlfGsd6esdsbtvETC+YVqjxChXfp7Jj4hkIgd1VZNVvFVn7eyW2f7GGUwE50nzl/IrFd91TjKqko4wsJ5alaS/XjOdYaeSojhamftdzebTlhrqLEwiLxwI8vJgBJkjynWIQAVj15HnxuhMfv0py0FQuxguTCe56SO6PDdypyejj3K1WneQOxSby3LBJRLdccMa1cU7IyzLPqyyPB4GQmFDi7Q5ypoC1FuC3aGNxIZRA5SJ8Sh2S4uNGqtdi1p3IcuCDM2Y+JxloZIwD6VSUEdSxfsleSvkG2/uWUWkUsZjQXIzUbdcU1o+fDMUgIwiUDlU3z++kXN9HlXajb8M2xjhgxViGG1cnjAvpmm0Mn1OMXzcWYEczqogw6CAKuy4Ng085gspK8/3zS9r4ZrSY4DLHbeA4T9SR1HNQLemJ9pEQPddygqsWudfC/sAUFLdsghgH0G012/1LVnOG2M2Gjl626272qU7a89MHbgAEo6NMl1VCNTqwLIXKmTcbX6SIAEQxSrid0GA03kcRHw4Is/NE3/XkeADSCLgJy4kZecpW3eRSWu4EBzYCr2QKoYeBKhNVaqb6oSEcnmIlADY+yxijVHIptHgUlvm0iACJRiEYVmW2VZfR+ZVfLmwj8DjYAfzoRz86J/VkBuAMeP4z++k6p0THGUXaTy9S2+vRqxskUzhgGClCaCypjB08RwQ4qbO5CYmGGsi9ElxYPVBFeFCu+LRWPPI1ha00NWnzi/bl7C+0JoNA0uqte+HAeJSgavDSV2uc+KYSskBi5aqVQPvxAVijjBlIhQZyZFRUSprRvLP88OKGi0g7N2XOiO/kpa70Ulb3h7QiPNRIvPguRIzaOVX3wdaftruhSBigid29+Hki7Nv47lK0S1Lna5FeV/xaqYNvzGiNpuMqF6q0FOs837uCupdv1pNWjecfcDcpcDW59jBTip7G4DhQOxO7hAfC1EOCySjbKVjJCFOhtBnhrlP6Mb7bN7loiHoANImOmUppmUjHaNZlRJwLkdi5DNMXmruE8fdIIfklazidXXSLCntlJ7PGNAODchWyrFJ3l40qJtNMGsfiERYzN+WAY0bsmaHMx63jzxWSEf+T77ZRtykMP5sx0sem14o9Xx3qMPYwyglyP2OFPEGKd2mhYT52ABcjMgNwJigY/EmVwZ9UKa11WHJ+Cyd17WHlCzaPrlpOpZCfuY5Zwvqlhf2CjRgTEAAScgJOoBJG4zqS8Rabna1lhrxW6vbMK+F5x0RO2nz3wh80Mhw/8HwbpWFNTz/P9R5GxJ7WszIAMhweHAJqzN14FzQ0dtvxrAI4eygk++hgOSN0yBrpubIWDo6XIJC5QGYAHgSqOz127hxCvfZslm7o58Idu3h82RJ2dUzvep0Jco8k990cuKBWKvyNPsEJAeShoWx+tmcVQST3bpoMzEKF3QpI8EYX4deR4ZiF6+fY2dfDuqXTy4nMCA1iFlqZGQ4PDgEDc2gASksYfOQMM0FRxGNHsIQcg/PdmOmRogt51K67yJAZgIcA5/lRXsqtpNEyxMv0fkpP2jxzUYmOpcNTZSyhKVhmDt9hr8RzEYKVakjkN4rYfeCt0IxfpLALAU5kKTHsFsl/s83Ix5kbVzjjpoKt5aqkGyAG2Td01JTvra5OauedwAkr9uL6irGzT6DRBcqJcIBsjcwFxg6KZQdY0VyYQuMHMpFbWDrK+G/d5hnBI6pqYY+bRrLlmjwxLZN5dmVAQodOx7QBlW3y2yDpXhNKJLS5/LgOnsQQ9IWQD6dt0wUXF6sWQTJ4R8eCMCbPnTqHMFDDcC9ZmGLBTGgexu9lBmpBGtJcayp2byIQBDlFMPnAtcCuiIQr2Bk3f6cF3DhVkxdlNxRWzXzbrUaUX6dYtXKAuusY9bS8OIrwI+c1XAI9i68mxtUUElIlViP3FopuR4IA9IR4edx17U9//ZADGO9HkdChs+sxt2yK4apiHEgsjYgFs+lAoGw99S2LYOI9jn5/Nsioxp014QaO3NxkgJFZOanufC2a2qRzAZlPBptBMhezUDoZiHeIQR9xzUfLNXmqWgikr5PUiUOgcliuuTMdOCIx1miZIvIdv9VAIwI4lb0oBKO6PBX7t1BxPASBzBUyA/AQEDz7AsVnX2AMKP9mKyes6+XFkQ10FyNJ7dEULHPmHPEKDDTK4b9XFcseCAMB+/4HeEvC0bKkXJzIgDvu5ln+/54l2H/4G++HMI8fMqzuFk44sZe8CvhZ2yrGljk0OhU6YgBiaeycSV5ynABLmhNOoJLuY8tunmdZAaW2OjLCXao6efyhQuws0yjTVjjhGQNsXIh5IroyWkY54McooDqW9kCoCV5WhLsV5E0OnJaYzwMIOn2kYz4TFecgVW2sivlMRGAGasQjntETAS9RIV47bJOB+KPWYbL5RBBMrJyMZQuJQwvQhQARMQC1EmhboScbpULDRRpZL8AZM7ljlhcj1GtwqqZYtTPuY4+na3yUO2ssXRvKJW3ra6bAEkrDM9sI6rOXe5I5gTuioJUYv00j0rhzEQQ5YQg6T3JkjYWcBimkGVCrdBjlOlWvCIN3jHdUmFG/IgxmMtozmUEkAq8NgwMoLI1TNJ+j25BoS0+9u1pOGBfRAA87JnI8we3TketpGQ+mSPJ0JzFOgW4xzktqyZzstIw8WWPpRQ6nFHazb6yD0YlxWdmmUSSDWe4Sptn6se/REE8nDHAzjfDp78uRLksLI+RzHo7wcQiwUIgCMBEg7SuLRuDQX21nbOKeJuFNRLiHlOqwf+Li4PEWtKk6p4k92AQ8qQ8vrepRw3EQBDJXyAzAw8Teh8Y4+c+XINXs99bsEcXSb0BQhn2/DdjHFj8u122x5qIarrb5Ycf6Y05oNMPig1Pw6FoxTrndRUjN+FCe3n3dqNLhvZvCFrgDARxd4f/jDjt1N2eJl7DnaBk7+lSDxvJuutaPs66zD6UFe0a72EfHnNQ/V5AolhUH6cqP44gAX1vUcajoPDXtUKVAw3UoNnxy0qPsNCjbdU5o34evLPZVOhioHxpFaa23n7VqiBFd5BlWoJAzZGJeGMg4gLNHNjMfJnpe3YIOZp9UPNen6HkI3CXQ/xuk6vUtdqz8nXa8iuBHa9cdk/eXYXFhxUlDlNobeK5kaG+Zob0lQELp8N5Nuxye747MQSMzTIs6eTws1soB5kqApFHL8eLgSkCxsnWQVe0DjI4XqBL3HMwdpPRZ192PlIpRr0Rvo4s03Z2e/ChL8qPkLY9AS0a8EntrnTR0DrdFGKdIQPs2VQoMu2EKNEv5rGodYFXrAK6yGaKFg0GLqrHWH+J52cN+dXgc96MNoefJAMx2AI8vOB2S9tML7H1wDP5/MibgnHwD87s1Hd8V1FfD0IXhhxun7Q27RfpV82PdP15mrT560i1zAbss6f+FA+tjbsr41vwEV3cm9Yy4S1gDMmJYCpny8YmkeyOuqXWgBOipOlxRr1yKxEpcmy5Nd2NKPuMA7QEQlkJY5s3E7y2wVSL5fJjP2eSTxT1lSWFmnZh7EsnntZhw3UUOWSTOU3Fx4ng1U9IhEffiZKHJgpMuwRQpDkM+aBZeOS0EWijWnDpIruiz8+kuvGqMuBlopBfhks5CqLjZeEHHy4sENQ1Shm7ZqDtTJ/UM06RY4jIwoXvddAsjdUz3OcaTPIDodkLiJe25JfrMDI7QUs/ocU1126Yc0yLWhNlw6SLoV60sk6NUmJsAOOGriRzGgr0D3ZTsBieW+niistYseAgTe0JySmuk8Nm4Yhe+sqi7OZYUR1laGmHcLzDuFchJn7LdIG95aARjXoHt40upqYhBKkIuc/RBSk8n3MtK2rw0toyctZvl5SGGqukG4IGe/3pvgKrI0a/bsSPJoyxPw0F4u+YFWRDIrJEZgIeBVb/bQb3PZ/z5BkFBs7bcjI5SWlKLpDCSL0py37PwT/FRr/ZpBwItJlJONbH7K+tZ/W8vTv1eq/oJBoeO+L3MJcaea9DzK4JC4BpSNcIThuGmbY3vmq+gZSmciAFkW4qe8rhBxI5z4rqFz8hYgBc0J4Zc3qex0gyUCYYcI3hCTBL3jQAPc+LWdpLvpxyNysUG3FyKMRXjBYZ5ls3fVsHk+61fNkB7rhnxI4XGjhnAdd+h5jffLYXghV09aG/6Ha2gZkE0oMTW6HxMQC5hoYCqWWYQTDnAioiVC0DaZj2+bxE0mv0hBHR2jWNH+K11z8YJcjgTuXfRAjVoGwOpkAKv1bRAc2MaK0JLE5P8qmgbc7DuVwaxrIDnd6/Ezzs4tYZxH7ndQwS9e412q8bMqRJluYwoFmg5UVDr18hyiXxfzeh/lbPRESNdWwKv1TaMsiAvEsFEtXyyD0XMupNeLJjJArfVtK78ohlgJBRhIFnk/qUX/jULgRqSKCeSZcfReDEenPBl2KETx0OxdFN3LjemDZFxgPoSMwrBz4vkIg3Shc+BEUqslMMwRwYgjz1LIWJs97XZrPuDEt1qjJFGaDAJrRNBUImAK51ss+WqROaTjrZw7/KFbSsAidtm01YaZ2lhmCWFUZSWVP08u6vdjPomf28SMtB0fnMbaiwSGaVjRpll4Z6/Eb9kMTzewoqOweaYJpp/WnJAIfxWVWdHvpv2Z3wK33/SuJaqVtNPWiDIgkBmj8wAPER0nVfCLkl2/r8Jo0/E07Yp4z9zP8gRbAzwX+k15wkR7hRGU505VY2/x5yUFhv2PTRGfnmRc62XeKR9HV6UAxjbAZzN6tqWythdje9kOEIR45MjREr0YnxXRE3uQkVPNOsOU5ElAyUSUa7xFHppOy4SY5QQlk6IhzsyMIKH5MQxsxpt7DD72kLERZYxrxWGUUL0gaftAJLYyRPhDlT0WEqaQ9tWxr1oLVBWdJdWY0lt7OZaQiMkU8E7KjpJRe5By+kDTOKQ0ueUlb0I4Jndq1DKDtsWT73mB+hZGHwpFwBHYpdg+NkwalQoZUaPW8rcyTsAUiM842XiRWKLlqn3WsSOxQn+8W8kZdcuLjIcijWnROrGz0v5rhMpFGdI6Zfapgjy0jeCSA4X2jMXiN6Az+h4N6vb9jPaF+aCPuB7F3tG8ewtqPh3FHoydCy34bDXyrDXehCNBl2tTZ+JQ4ipQKJAy+YTm8W7Fv1HR/s0fLWws36kIQsCmTUygtYhwC5Lus4usf/hCmoW84f1XDgSe796/GQe7324gCssLhjexpLG2Hw3J8NxAtvyOHXVbrQSPL1rNSqRAHdu0HESaB+8xcXOWNRYIsao6iMrfr97XzdSaE7u3sPsmd2zQ8O1E3JWRxqeP3nNg7uXXbkOVrvD5Gx35sILDJM7gPPxt9iQGYCHgOW/1YY3GjD8eD10hQgxLZdFdU3sDqSoS6jEsvhYgeTH7evZk2vjZZW9nD62J9wlOYLQzN/ib1YQ2nDBwMROpdBHfWI4KCzgpk1CErC6u49TV+3G9Rye7V1FClFxzq7XshZqUQ3phcj/masPYqbzZ7OLeaDxUZD4JtIg8WmVNfYHB7FbdkiQPNu/krzlcfrSl+guDTM3hqBi+dIhfD++LavNvzlGzSuggS5n3HwfZrjUjkI3Y7LAiWv3Uj5hEWSciiBMgzg/f4sNB7U8/vjHP859993HQw89BEAQBHziE5/gS1/6Eo1GgwsvvJCbb76Zjo6O1POff/55PvzhD/PYY49RLpd57Wtfy9/8zd+Qz4dqvPfffz/XXnutcc4pp5zCfffdB8DnPvc5PvvZz3Laaadx++2309rayiOPPMKb3/xm3v3ud/Nnf/Znxrmf//zn+exnPzvV3rlCYanDT17WzcBl66eOnb3ueZY6zZ2uhrbpa7SGfLVO6C6D9Z0Cg/9jTpuyYKF697Lu/0kaQrCns8jyM8e5eGeN75y8FjXJAxSmoDNgaPlBaCCVYqtQX0ncyM6O1oK6Z+FG+IRBIFFuVIgsFHk2xHpT2h3kTZ6elhCUYq5kW0M8iXs+MNpuWYp8IcKTE5py3sWKGXpxfl9HvkbRmn6nWCHwI/49N7BQngVuNMKFpAuqIk03pQIZm5BCwV7zvDhPyM9pVCQzTZoRmzBqNYxV88Yz8j2LFmHjTooxa7ADkL4ZBBHkzXvJWw16nAolq0HBcsmJAKtd4QeS3QPdDFeSRoIINNa2vRBx+QaH4v4FUAqnRTPwi3Bhp5VAeAHRyAypNbjNl01bAlkylbhlAVMsXITagMnGmz99m2TwRsxGsavJ8xKTfgqVQQQCEdFYFAhEjFuqiwEUfciF72kQCOpO/MWRNGrRCJekS1q6JMTS7apO5QCe5vTiaZu+oI0ejmzYtatyPNW3lpVtA6xoG2JF6zA1L8dYrUjdy6EkE65oEdpsE7IjeuK3RiCD8N2QlqajrUJ7WwWlBdt2rJi6Tusv+xCV2gHbkQqt8ccPziVb93IsLwwzMNwCSPJSUxhW+AUxIUY+AWEK3P/CWcWpbh8rfgtGGiV2DveQtmdU3jaGeuypg7uPI43FZ4vNC2ZtAD7++OPcc889LFvWFE7dsmUL9957Lx/72Mfo7Ozkhhtu4KabbuLOO+9MnF+pVPjzP/9zzj//fP71X/+V/v5+brzxRjzP473vfS8AL7zwAq95zWvYvHlzs4F22MRdu3bxwAMP8KlPfYpvfetb/MM//ANvf/vbp8r93d/9Hb/927/N6tVHVpCrvC6HFvBbFz5hHC9Jl0KEUa2UwFdyKmBh8FWw5FvgjwpUy7G669eEqtfhuTCYpQK8+FNY+5ZlvHrHLr6/bnXIo5oM+pxh9yvkvOnoAeqBOXAFgTSMEh00SepTxdS0mwzhebFI3ajg7RQsjYgarkJjO2a6kFwuoKVgGhidhRq5CJ9PIRIBLTnpJzMPpCB6ntYT92o0yfw9SVSPGgrSE1jR+UeEGRzi4rxByYxCJU5v0iI0+GZoc+BbqMi9BYEMsxFM9pOaCMCJc8csyAU+G0f30enVsNAEeYmnLerKYdhvoTaSp9Y4sHyH0KBGRw+N85dWmYDaPj2R61qHf5H3RgQaHdnxFlqEQQHRMkobWV6mujT2/NN4qYkmxQxA6WM+xxQD7EBvmTBf7TAveaQeYWmkEyAn/kEHAuWZofJ+yWy4FpgZbgA7dmNCk/qBLpdDlIXLY+5aQB6VKFSFZNdoD7tGullSHKWtWKWnbcRc5MyyLj+QjFWK7Nkbk3wZGsEfOPJp1V4a7OHkpb2cXtrFM8OrkJ7GcjXKEshon4hwodJ8vyTP5ZfT57VyWn4Ppy17iSf1yoRMTn6osLBcifPljl2ERuesDEDXddm0aRNnn302vb29AIyPj7N161buuOMOLrjgAgDe8573cMstt+B5Ho5jRnz913/9F2NjY3zgAx8gl8tx0kkn8dd//dfceuutUwbgc889x4YNG+jp6Um0oVqt0tXVxYYNG9i+fTuPP/648e9dXV28//3v5zOf+czBP4WDQOspeRo4MxeMwVsaZp3o/Llm4DVHoGELHNqHn7OWc/wdnL1nHz9btWLmkzJkAFZUh9k41o8rbbaXOumvdpKLBEEKBTn3AKGjRwCFJRPBAUcztc5xihwea+0BdgWdNMjNYQjIbCEZGO9gYLxj6kjckE5kbwFkQyWM8vmC6+d4pn81G3p2c2b3DurOOvYdhMk2Rokf6xM4nT2cKXbxjF7GEEfaFX8YiGXKOarXXWSY1Vtw1113sXbtWi699NKpY48++iiWZXHxxRdPHXvlK1/J17/+9YTxB3DWWWdx1113kcuZfALXdVETK7rnn3+eE088MbUNGzZsoLW1lbPOOostW7Zw5ZVXGv9+88038/3vf5/7779/Nrd0yMgvdRg9RKHQofOg9FKYCQQAXyErC2SUOArwhc0jq1awrFJl3dDwfDcnwyLAGcN7OW2sn52lDv6r5wR2tHQ3KQTzBJljUa72FyNOc3ZT0w69Qfd8N2VRw1c2jw+uZbDeworyEKd2vESOgwnwkDzJKvp0KxtEH9YCXv1MZgKZj7/Fhhl3AJ944gn+7d/+jXvvvZdvfOMbU8d37NjB8uXLefDBB/nkJz/J0NAQF154IZs2baK1Nbk6WLZsmeE+DoKAf/zHf+QVr3gFUko8z2PHjh08/PDD3HPPPVOcwne9611T9X30ox/l+uuvp729Hcsyl2HnnnsuV1xxBbfddhuvec1raGtrO7QHsmolwUpzsAlKNnqCuyNLuxlvt1jimJGtJelSEM0PqqrytDt1VGTN2jjBxn3WYsX9mqCksCbklGrrFaOvDv/7YIRRFxu0JXAmCD7VvI22krNoEEiDC620wNemyLavZMJNalmKICJNonVM8w6ICxqHbYr9tmP5ei0m9Psirh9bY0VyGAuhyRc8o015x6c9b0b9lGzX4Pz5SjLu5Y0yw27JlLwB4x0CqHg5Km5zIRUoiXAlIqpxqDDuX2iwq6ZbWPpgxT2ieZMXJgDlG9Q1hD/p8msWqtdyxjPyGza6Zg4vKvYc8SXCthD1iXI61JOb5IWdXO1jmTvGL52VjKgyuQnql1PRWI1IfyjIjXjTkuilp+ZshV7dq8Kls0XoHtUKgiCmsQjExigRc53LIEWHL6enxhoIn3ucl6kcUnM2G9eKu9JN9ZHmsdgnomyNdmK/8zHJn1yA4wTkJgTygkDi+mblQV4mrx+7lnRNTq4m5EBO5ovu1OPktc9/u+s5KtAKZ9TF8iLvrSL5XglhPv+UHUDhBTMHBXhHzoiyxxoIv9lvQcHC7bDZVelBjzi08CJnlnayU3WzR3dONHrivYn2U+wWXqSHLiqcTB/PsPKItf+wkAlBzxrTGoCu63L99dfz7ne/O+GWrVQq9PX1cffdd7Np0yYsy+K2227juuuum5Ub9gMf+ADPPPMM//qv/wrA9u3b8X0f27a544476OvrY/PmzfzN3/wN99xzz9R5XV1dB6zzXe96F9/+9re5/fbb+cAHPjBjG9Kw79J1OFf0Tf22hOZ/rHia0sRM+dI9a7lo/dO8rsV0QecF5CID95gKeWtRrtYut4vB15XR2yzkDge9wYXdNsVnHAqFCZFQ+9i1AFXB55xd++jtLrFvVR4RZ4ADjaqDjkwmMhcw1GoaRZZUFCKBEo7wKeaEYYDVNCg3Gb1mGHxSowrmR6vtGFHQ0lhFs53FosvS1qYPUgrNsuIY+cj9lO0GS3PmIqGuHON96Hdb2VtpM8bYgdGyGSmoBTq2slQNC1E3A1wKfZYhWCtUzLgAivs1MkLwn9R9a54UCgqraNVSIJSIGQ8SL2olaIGKdaVTE9iVJAfT+B1AuShpHY0IeI81gwBWFEYZ9kvkHxcs0xHx2dhAKz0FP3sK7R94Qp3ToXmCX1deCZWXJtozFiPmt7VALhKoNLlrGTEK7KrCqkcWLVKgpWXoSWoLvBbzOXptmiDihNCCBE9V+GFAR/MACT1L6QqkF6u7XaGjIuc5RUtn89kLoekq1ViRK2KrUAMn0JLhmiloP5wv4UeCsLQmwclFOuiqeSzUPw6P/cr+QUZ0ISEWf8SgNfz4l3PGZ5vpnTtipAWt0T99wriP3Lo1uOeFBpuvHZ4ZXsOS8jBrCwMM1lrxsScMdD3tJkQrdWwUfRzaBsvRQCYEPXtM+2V98pOfZNmyZVx++eXJE22bSqXC5s2b2bhxIwC33XYbl19+OTt27GDdunWpdQZBwPvf/37+/d//nU984hOcfvrpQBjt+/DDD9PZGa5GTjvtNLq6urjiiivYvn0769evn/Fm2tvb2bRpE+985zt5/etfP2P5SXSt7iBPka5VHSzvKtExXqR7u0dhJEDlJZRPYnzcwq/ZtOZh47l7CHwz2MQXICIGYKA0ZdWDF5k5W3U7iiKcQPhHEUoSsaOIVjmQsKK9SNf6Y9PdcbozhtXdRf/GHlZJiRAaKyYg7GvbMNKko1giPKyI9WAJTV54U7tS7bSy3BK4kRMbjo1fNF310o5tQwiNys9gAEqN5QTGobydoyvihpRCs0RI7Mj2WlG7tChzd8/RtmEA+pRZapm75Tm7hBLmzpGKTZxay0R2iHyLNCOcFaZBqCEfxNKdTUQwRuGVzewMWk5MyiJaBvyimZstbstLIYhlq0PGZzwFPYVmHwkNttU0FH1rDevtEVa11dm3q50gLqExeZ6nYF0XOjg6PEBZLFDwC5z8m4LebwWh4HNst4+WErrYXIBoIfHb88brp63Q6GtWLKh3Woky8Uw0bjnkEzfrnti5jlblYwSYQIoB6AhEbAfSKyrTmHQUZcesp8Oy6RaFqTTfvpYU7XwYjDR5+7k8vogtZGLdY5ecA6YKd4KA1eUiT5aWs3ykebNCQ9fqdvz88aOpOhewV7ZR6A5fpO6O8JtTdplSWXBeW5Vt7nK0mNhdTjUAFUsYY4WoMqaXU2Apkyzu9qUW4ijNWQ1q9M6m4CI0xuYD0xqA9957L/39/Zx99tkAeJ6H7/ucffbZvOUtbwHg5JNPnio/yd/r7e1NNQA9z+Md73gHDz30EH/7t3/Lb/7mbxr/Pmn8TWKy7n379s3KAAS47LLL+PKXv8xNN93EFVdcMatzBncNU+506VnfwprRXyIf1FRaBL3LbIrVgGC0SqGzQcsrximvq5Ar7sOy9xt12AKciAFoKU1dFvAis+mY8BkmkuJnFMT9ZfAaaMIdpT0jNYLtA7Nq92LCkleVaAzt59svX0ndC0NPhdRYOmYAunYzKhSQOsBRo9hRA1AqCtqb2hXUwN5A0PCbr3PNc/BrMYkZT5huOqnDHLYRaFuZ7h2psaRvjIkF28VX5g6gxQhOxJpyRYO8TNkBjNQ0hMu+wNyl3O/phKGTMAAbFqJuSr4UxqffARQaCkMz7AACrieIaidrKfBibiEPjSdTDMBI1VZNhC7nCOIGoAhCI3XPaG2qjc6YnmrTXnIUvTY25PbQ0jXArhe7qFWS/FvpBrBjcNodwLmELJXY35dn/e9b5F8Ge3+g8BuxobQtQJeahouWEs/1Y8adQFuRSFkpqGElKAiebz7HhqWJ2rqTO4CGAejNwgCM7wAKjZtT6OgiQSlafXN301VVCtqnX4c+eU9ZjAQFwwAc8XxjBxAt0LH7sKsOVi3V2uBlQ3vY59Z4TiiKQ5EdSA3BrhH8PcfeGHkkYesSIyub+YD3DVQJHIGsB3Rbw+ytt4UGYM5cI5eos4JhukUFgeYF3cILlIBmnzT66sijNGf5tjuxeXJgCK2TmVmOAubjmoeLaQ3ArVu34kcG1XvvvZcvfvGLbN26Fdd1ufPOO3nyySc588wzgTCKFzigFMuNN97I9773Pf7+7/+eV7/61ca/ffOb3+S9730v3/nOdygWQ3fCE088gZRy1sbfJG655RZe97rX8fnPf35W5df8YQfl1hKOJXnB62Dw9S6T2xeOFXDG8hcpyTlWRH/CQTySh06FvqJyTEtyF5bbdJxZ4pnCUur55CunD5H4OLWbdux6zeeeVhJVfUir+1Cf5REa+1xy7HhuGSvW7GfV+iFefGoZSi2Aj0XBrm8ELHuNxZrfkTSGNOO7YHQbSe7pfGA2TVgAzUzDstooy+rjPNm+dL6bcsxDaYEUinY5jhYCH2inTqeoUMRFAC4Wu3QnvXSwGCYqEcyPsH489/NiwLQG4KpVq4zfnZ2d2LY9tbt36aWXcuONN3Lrrbdi2zY33XQTF198MWvWrAFgeHgYy7JobW3lwQcf5D/+4z+46aab2LBhA/39TRn9JUuWcO6552LbNps2beKaa66hv7+fm2++mTe84Q1G8MhssGbNGt72trdx++23J+4hDb2tnfR2rWZ5WwsvdI2yxtlPdEYbCwoEkWW5p23yscGzVVqURHM3p0UE/Hb5ecPDdt/oqQz+uAPxeA48gT7LhXMWX6qdg8XyS9qo7vLo39AOjeaCQgN+QxsTkahLY1dCWzYv+j1mEIKlcPLNelY6LfjWIDm7uS3i2RZejBcVFJLuXZkzt6VsWyFiOyVxIywIJENVk/PkBZaR51YKzbPCnMCG60W8iFZhtZ6nvt+sxx6zEu7UOEQAMrorqCcI9ZF2Sg+surnb51SVsQOopSCIuvcEKAu0Hd2VIpFnFh0GgkydpiE3JI3dRMtNBpiIwIyCsFwo1jTlQTVVr1035TPCczR7dnRywml9rD5xPzufixkGR3nlreoNhOvijsFL/w+K63J0nV2m63To/hXwa5rxfXUG+xyIGKtBXhou3yAvUJHnP5kmNroeChyB24bx/BsrPfJtzYdrWYrO8syCwvGnNF7P43rmFJCLFcrnfNZ1DhnHlhXGWC5baBehhl3Fz/NCsMSgNwzpEjq6AxgIZFUm8gxHtQFb3DobhgbocmvsKHWwp9ROebdm6Xf3GH0cDJrtyTAz1L5+2h8OP6zW1W3Ud43SOGUZ4+sKrABOzjfzzwdIxnWBXjrYTygePQnpQ88jg9CIzFsj40eOz3go0MyPC/gA19y7dy+33XYbjzzyCLZtc/HFF3P99dcfcqDqXOKw2LWbN2/mIx/5CFdffTVBEHDJJZfwvve9b+rfr7nmGlatWsXmzZt54IEHgDD4Ix6g8d///d90dnZyzz33sHnzZt74xjeSz+e57LLLeNe73nVIbbvqqqu47777GBubOQ/t9rMK0FkncCza7PHEv3vaMly5gZbE2UgFYeNEOC+OsCjJ0CB0Xcm//+epPPXYSgQCfYoH5zcO8+kvDpTWOtgtkp3/Pog4KUZMh0SAg2wIw7hAQCBi0aS2puFFMmHkHYKyJGc3fZ5S6sQOh8gphBW1LsCyzaErlwuQEUNOKYnnmb2ttcD1zTZVXG0YgEqLxM7myHgBFUTeo5qFM2LWbY+L1EwIcRgLXE3iHBHEsixokL5Gus0TQ9X/uJvQDAKZTNEV36Q1rq8Edt1sg/RBejF3s6mVjV3XOFrhVJoGoOWa0bpiYjAXWrDruW7Wn97PkuUjDOyZx8FTBcZ7W92maYyWQQrssqZzI7St9uhYP0h12GHv060g5YTLN1KNLYzMH5MGoAGZzE7jtLgsaWu6ZR0rYH3roBEoZcvAyDoTaGFkzwEYapSo+CYFYaRewI8sUko5j+686QLucKq0SRspQjegFOG7b7zJk+LkUzcLlisSk6SW0Nqo8/L+vRQCn5pl89OuVQznQ76a1QD/xe1kODyoeh21azcAvl3H3zWAvaKLIdXCT2snAaS6gOMQCvTOXtQs5tV5g2aeooCTh5RSvO1tb6Ozs5N//Md/pNFocMstt/Ce97yHT33qU0e/jTEclAly5ZVXGvp7xWKRW265hVtuuSW1/NatW6f++/bbb+f222+ftv6NGzfyuc997mCaxPnnn88zzzyTOG7bNv/xH/9xUHXNNYZHc/zrA6fx+LNLKOQD1p7fy7ZT2xfDLvqcoefVrVR3eaiUPMgZMhwMfM9m30ttLFszyvhwgUZt4eUo9SuC/p8CbS3klwmWbxxj/XmD9D7bQS3K/80whXP6eqlbNo8sX4+v7ektkAwZZsBCigJ+6qmnePzxx/nBD34wpaRy44038id/8ieMjo7O+y7gcbAHNT/43k9W88Wvb6S9tc6Vv/ck55+1h38Z62TbaPt8N+2oobDCxmmT7L53eL6bkuEYwdhgme7l47R1V+nftfAMwCjqYzm2/6ST5RvHWH3aMLkx2FftnPnE4wgrxkexleLHq1ajpExIF2XIcPCYJx3AlC3AlStX8pnPfCY1u1ljLtJSHiYyA5DQzYeSKC3xfIua19Q4i7r1JlHXDoPKdN15NKaEoL/8lVfwyyfWcNmvvcClF22bKvPDsZN5aNsp07alazB5vcUI4eRY8qp23BGgbSl2W7iwF42YNpyI/faFES2qBciGNJZXOhAmz15K/EDiRqJntQZysSjgXGAKSAuNbcfKSFN2OY1MrJRAqTgJwCyrtUDFggG8mmO4xUTDMmQ4hJ7k95n1prpfY81KqNCnjH9axPX8Zj5n8rjJLzRdmVOiw1GPr8Tgt4XnaVPk2xYoS6AmOIdCa6hrkwOoNNILjAFdeQLbChBe+KCEF6DmMw2TVuD7oRzMBETdnVLP3vezIi2rHJZuGEZL6BufMALjrvVJF3CU3jmRmzp6d0KHecYnIYUm0IKoWFH83Zt0ARsyRCkvgyWVQV2QQuNF3nUpFJUgz7jKMyJC/uqIV2S0XjB0toNxG2u8Wb8IBFYsKlzZARuG9jNQKIXZXTTkhwTReLvC8IJilx1TkFWX/Ij5fJUjpt2AlT5wlOSWDhUi0Ih5IAGmBYF0dnZy0UUXGcc+97nPsW7dulSj8GgjMwABXRWovE0QWNQaRWo0ifnCUTSW2UYU8LZGDzsaSxL1KBf2//ty/BGHda/fyf848wWi/t5vfeU81n/k0enbssA/rtnCWr4UZ6nLbjrpvTzUiNIWlPaYGSTidlRCLHhKqy4aGAIqIjJXaLWo+kUapSbpzbIUXT2jRl3lnGcY9Do2kUI4UUYnQNe3qMekWgLXQldjCwAd4zcpTIkNDcVhafDyRJCSiSPFfREfWELB4FiZWOYHoUxZEMHEc8M8KGeKXNNgx9z3opKUGInDL4V6gVFYdWH0b1AFT0jcRngzQmvyAx4yEigklMbaP2oagDWNLb3wOECgUHEy6dGE1gRDscCEgUHj59iuEu6StazqGkBr6K90ThjJkUIC/JLZtyqX5AAKJak0mu+kawVU/ZyxuBl1CzSCiBC1FlQ9x3i387ZP3jYjjkqOB05zVWILxbiXR050nNKSl8Y72UcH+4JQVmSsnmdsZ5thzXY8JykYi1lzV6bdHmdNy34sNI/1LJ+4L1j9H73421+KnHZsLIgXIoInnqH4ZHx1OQM/SauEdNaCwwILAoni05/+NN/85je5++67j3x7ZoHMAGT6fkt71wMtE5aKN2Az+OVlCEuz5MpeSh3JqDwRgPaO/ahfAJlTWGj2yhjnMW7cpDzfhAEULxM3kib/exbcoegkqSZ+q0PgHIn4OYk2xgzCyd9p7Z4OaYNZGsdlFnVpMYfKH/HrpVUcbeSBJHtE5FgaeTvlAwxcyC3gXPSpUIrhaivYsKptAK0Fe0jJahR/rUTyGByadNKhyi1BaPgZdRH57AC0SAYmpdhuS3LDrCgMYQvFoFXil8uWmrmdlQJ1bCyCFwUS39vif/YLVQfwrrvu4s477+S9730vv/Zrv3Z0GjUDMgMQiMrRS6XoHGuQCwKsQGGjCII840gKJ9exO80Vs/Kh+vNWxn/SjrOsQefv9x9Q3f54QuvagACJL7NXLMNcQlHsUdT3L86PbLDWhkCzsm0Qvy7p5XjgBCqW54dYVhhBoBlyW3ip1s3wuhyuffQn6gzHOBZgLuAPfehDbN26lZtuuok3velNR7FR0yObnYGXv9hPpzXM0nILo8Mj4epWTHCmBOi9BeoiT+3RNkRO46xokFtVp/5sGX/AAUtTevkYba8aMepV6IRczPECd1Ri4eMoH+94NgKziMY5Rc/LfYSAvp8v3ndqoNaOEJo1rQN4gaCfjvlu0hGCYnVhgCX5UDJkf6ONXfUujisZhAxHH1O0oXm4bgr+9m//ln/6p39i8+bN/P7v//5RbdJMWLyj6BxCaE1fe5HBpZ08vq4V3448Fl/Q84iFXddIfJbmR2ijQsvuPE6PS8dr+ymsS0bz/NfQyXzm7tcZ6bnW/nB4Xt7L+UCtz6IBvELtoKJyVESeEb/AoF2adlfQqpspzBAxntRUQaMI+BIVNJ+uk9OsajM5gHZMLK8eOOyvmkS1aiNHENFBUyqp56eVSLi3ZEMYvDihSAR4ONXYvSnM1GyEPD0dCYxJcyvIQJs5XJmdnamcGYJAJr20cRd87FrC1waXUUuoLTPrDooavxjR81Maq27mK5ZemArQnkjZJzQ4QzVELfI9aQ1eeLFCt6K8XLH3EZvFZkQo16P8WC9YYbsbQN+vtnNi1350INlPuhyEUGHKtiiCgRwVu/lRVAT8dL/pExeWSriO4wLnhaJLKZZT17bMQCmlBfurZjLiSi2PFi30TXBcA9dKpP3zWwJeFuxAotnhdLJbd1IcNZu07NEG9liTEiM0qP4sxVuGw4RSiPmYaVXymk8++SR33303b3nLW3j1q19tJMCYTKwxn8gMQOBnJy1Ft7eyKl/Cb1SNfxOeYMl9zxLsDwemCrDt7RfwhqsfmrbO3ko7K+55DFVpiqgeL8bfJH4pVrOaQUrapVtXWOaOTgkR+0ga0qZqOezMdzFuhzlepQdWIxpyipEvFVLEcieLRw0woenIVYkjymVSWhqitwCeZxkGIFokd/ZTeHnSF0YHi2BC+DZaxjXFkSejfqfqEhO3MIOIlVBJ4Wfi2TpSoCxhRConoonTztfJIBQZJK/vF7UpcpzX6Hw04GaikUagCkjVFKwWSiOqdaglRSPLqxRLXgHVvYTu38W2ta4C/Akh3kmMrDwLt0NyktVHTnkT7uCU6PLYwGFXk3w8hHmeymsjy4aWGh3LjONZioaVHJWigVKub1GLBJxoDW7NwbesZv5jVxpGqlSKV47tQEnBD3pOQEmJVYfioDL6P79jkOD5pkrCfHH3MxxjWEAu4G984xsopfj0pz/Npz/9aePfvvrVr7Jhw4aj1bpUZAZghiMGVzq8KJpp/IIcaBRtqk57UKNVNWgJXM4Zf4neXBvPlQ4u5V+GYx92UbHsleC0wfhO2P8zjqlRa7fuBgWr5DBrGMKtWYzIIi/mluDKtK3vhY+XD/UitOa/lp5gBnhkyHA0MF87LSnXvfbaa7n22muPfltmiWNoKM2wKCAlo7LEqF0Kdc8sWNoY5bTaPp4v9LDYXHsZjhQU3S+H1nXgjcKub4JfPTbfjd26m91BNyVRpzs3RreqcH59OzXhsEN18RKme7fguby8by8tnkvdsvmvVWtR1sJ5Nu1unafblmTGX4Z5QZgJZD6igI/6JQ8bmQEIOPttaNg4ZZtcxXwkVl1AYJr2uRHN13tPn7bO3r2dnKr75rytiwa+T35EGXw25ZjuWy3BL2jWe4N4SKQnQ35bVD2EFH5bmqtShQLRzctLqrE8p/FcqBUvl8jpGwQS5c8wcamU5LgxaZaEe1Uny6TKwujk7SXuP8VXFncTpsqHxI6pFD1B5YCOPpLQv2i0W2mNoY8uJsShddTlKBBR170SWC4GJ1YETLmuC1aDFS0D5F/VQNoauxBKwPU/CpXdsUYGgSFGq1O4N4sBVs0jP9p8Zr7Is6tUYJfooUCDtdYAp+p9bNjRx0ChSMOyyAcBPbUqFcfhFz3LOG1gPxfu3sELHZ2MOXkCKZAahK9o5CWVQvgNCC3QKWLZVmzWytm+cUwIndDK9D0bIUBYYTlta4KCnnonJZqxfN44R2jIjZkuYOGZigoZMswJtErl4x2V6y4yZAYgsObOx7GDPD3rusjvMAVcUZogpt3X+YWfIP59+jRUp6peVP34TYDr79lLx7/sn7aM7GjnhDdIAiV5fs9KOpVHo90iyEdEnycSlBvZEVIMQKsqUX7zHzw/z5P2cqNMo+agI/w+HQjwzMlNBKZ+n5YanJjl5gsjCALAagiTF6fAivLr9YTocpQnmKKVZrmkZ4cw2giWpxPHzAMh5y8K5ZgBJkFR4EZiD7QAv1Wb19PgjJnPxGoI7JjMZbF/4qKRawW5Ji9NKCjvUYnnpjqhszTKmvJ+6oGDX5ME1YBqH9T2QNqOsBodM7i1ixXqsadoffzAZMYBYOjENQSX51hRHaPFdVFC8Hj3Uva0hh03nC9yVv8eTh0cQGptSCqKif9/qbOVJ1b1IBrSeLlEh6a9aI5RJ7QNULaa452nJSNe0SjzotNNSTmU/eZLoLsjfb8TilaD8Yigvl2F4n8+ho4YfX6m95fhSEDPE5t0oQtkpyAzAAHtumh/4v9nkZ9P+z7az1avM2GmZ5Rr8REix+6BbvyJrAVpac5mf0HTSkyL3tXRDBZpcgGx6wst0Ojpw2xT2jtbd0C8XOpu3yzrjusuR90gk5JGqULDUxUkd1wFyXNIOxZvk4oZt5PPNTFIKlaX97Ov1s7eSjftj+2DalJE3bzW4htoU6H1jN+I8DXb2rvY1pkiGg24ts2PV6xJ9IfKa7QMWD08zst691PwfX66emWy/tjLJNFTWT8ALAQy1rky9LGZAUXRNIgCcoEyZxdNuGubGX0ZjjQUc6h4fxBYhMNSRtLIMG9wh8EPJAXn+MiOkiGJku0igD217vluyrEHKdnV1caPTlzJkvEar9q264i7xorjPlYAe1vLMxfOkOEIYDITyHz8LTZkBmCGeYUUysxPm+G4giP9Q0rFl2H2GCkVeHTtcjrqDdrrM3s4DgXSVax+ocorfjjMaIdNPbc4I5gzHAOYlIGZj79FhswFnGFeIQTUGyFhfFnHIN1tY4CmpnPs99vYQxtxbTShTEFlmYf8mDS4ayoncevmLkTcnTmlwxeBdE0un5agnBhPMEWHTwSY7uSY11hM1BXNtZ7GGRZJ/d5EORnoxPW1ZXogAkcQRHn4AoKCGfThF8DtMActlTP5jkKJUIcx0gZtgYoKcWtwxrXRAMvTpug1YNdVgvOYUwFaC+y6RiiNHqugx8aYDscT/ULvH2Td/R3hhzIdYkv53guKVNc3O+CMvfsZLzqMrLSAcMe9s7VKT3HcOO+E0n467Sa/0tMWQznzO+rKVSmpOmvdIezv5xC7LUQgUBYMLM3x1K+00nm/oOupZj1W1UMFmfs3w1GAUsyPFkzK4L3AMa8G4Mc//nHuu+8+HnooFFUOgoBPfOITfOlLX6LRaHDhhRdy880309HRAcDXvvY1br/9dlasWMGWLVtYsWIFu3bt4pJLLuFNb3oTN910k1H/t7/9bf7iL/6CZ5555mjfWoZZIlCS9cv2oXQoUryn3kVNOvTYo6xx9rOMYX6q1uBbzVc1YQD6kIvZDEEOREzkOSjo5J53bNFm1cwAj6kglJmgUrh5MbphyMOL8qaS1YiUSM1EMG+cX8dElo9o0K0TGnxR+EUS2TqC8gyTsprgE8a4gsQMWcvVRpucqiI30nyQWghUTiY4jkXbZaxqh9lFAo2u14/r4Kk4gtFR5A9+ftDn5U9/FdWJKN2TeocpN3y+f8ES8sXmh9Oer9PuNJ+1FIoVzjDddtModLVFIZYKZpk1zPiP2qj+dxGrEOD86hgPFdfj5yZeCi1o3+4ifvjY1DmLLz4yw6KFnvqfo49FZgDOmwv48ccf55577jGObdmyhS9/+ct87GMfY+vWrWzfvn3KqGs0Gtx9993ccccd/N7v/R533nmnce4XvvAFHnvsMTIsLjyzcxUv9ffQN9LO0zvXsq/RyaBq5Rl3FT+vrwfglZXttPuLP+ozQxI5x6PmzsbCznAo+JVt+zm1d4Qn13biFuZmvb/v+8sYebGNFRft5bQ/f5bCWdWm8Zchw3wjcwHPGvPy1bquy6ZNmzj77LOnjo2Pj7N161ZuueUWLrjgAk477TTe85738Oyzz+J5Hp7nUSgU2LBhAxs3bqQSk4FYsWIF73vf+/CPI/fQsQHJaK3MwGgHKvY6+tj83F/LgF3mrGov6+pZntBjCXmngWMFjMRyzWaYA2jFBU/tYfVAhZ+c3MP25em5hg8Foy+2Ul5dpfusoTmrM0OGOYPS8/e3yDAvLuC77rqLtWvX8qpXvYrPfvazADz66KNYlsXFF188Ve6Vr3wlX//61wFwHIcLLriA8847j5aWlsTu4Q033MB1113HZz/7Wa6++uqjdzMZDhk6UNj1wNCm07YItfgmf1uCF+zljIlhTnT30+HWeIKV6BgvLyHfkpKvVgSmYyDhsp3kBGqzTFy7DpJyLbOSr4lp+gmdUk/iQinVpLmbtXluqlRMvI0a41mnQomEyznBgdShi/fgpPAV65f2UXO7qNQzA3CucSa7yNc8vvuyFVSLOYTUOI75QVhSmZIvQhMgcSNJnT1tU9dmQEf5pArVl5ZQCBykhEGvzNj+cvNl1rCiHiOAZshwtKDnkQO4yHDUDcAnnniCf/u3f+Pee+/lG9/4xtTxHTt2sHz5ch588EE++clPMjQ0xIUXXsimTZtobQ1TIV177bVcddVVlEolcjnTbbR27Vr+8i//krvuuovf+Z3fYc2aNUf1vjIcPNTYGPL7vzCO2TJuEUmQYkLQVrLqtZrzeZH/ttbiyuY74IxrpN80QJQdZp6IwiuLRJaLOJdOeqZxIzRI1zRstAwN0yiCPCbnT4KReESEZUREh1AFYBuq0yBjhqtQYDdmM7CY/DotRfLegpiXopZUmY62b+r6FdO2s6s6IQStZXjN6PWnw5ol+7GsgN79S4AZdP8yHBTaTstTxuU7Zy+nXrCQBFhOwGk9+0INvwl05aq02ibfcjwo4EUMwBG/xAvVHjNS/0xYuVPw9PfW450T8P0XT+K0dz5niDyrWsbjzDBPUCo9wu5IIz7gLgIcVRew67pcf/31vPvd76anp8f4t0qlQl9fH3fffTebNm1iy5YtPPnkk1x33XVGuY6OjoTxN4m3vOUtrFmzhltuueVI3UKGuYYKjL9Jke2pPy8U59aNBo29NV78h/0EDcG5wQ56glFgMvdj8o/YX/xYWpnEjptuBl1E/2aq+5CQFhRyoDYe6rVibZ7p74D3NkMb0pVdFOVClZNX7Ka1VGX7vmWZBNBcw4KeV7fSK9qpxzh/Umhsoab+4gLPk1BaTv1BmA0k0KL5JwTeSQHOkzZBINCBQI1XUJXmXyb4nGHekHEAZ42jugP4yU9+kmXLlnH55ZcnG2LbVCoVNm/ezMaNGwG47bbbuPzyy9mxYwfr1q2bsX7HcXj/+9/Pm970Jr761a/S0tIyq3Z1re4gT5GuVR0HdT8Z5gfu3lWwRvOreoxtVitOSwGncyLV2gSUJfAL5nl+CXRMviS+ay98c7dLKJBxnWppyqBAGClsGD3xHUBCuZq4K9WKtdEumNG0IgDLjTZy8r+jvmQIHHMHMCgIvJgWr8qbbdRWGC0dRcKLq8C2MIw8OwdWngNC4tPRUqelxyeX83GcAMsKpiKJXa+dPUOdtLQ6dHc204VJpcmt7URVsqCQQ8WyX2/BabHZVl7LqlzzxbXsgG46sCIvfCtFStp8uUsqjx15AZXK0UWneREFbbIVp8Uit99jVa5Mz7oudCbzsiiwmOe5BjV6ZyqkWZTG2HzgqBqA9957L/39/VPBH57n4fs+Z599Nm95y1sAOPnkk6fKn3jiiQD09vbOygAEOOecc/jDP/xDPvzhD/Pud797VucM7hrG9qsA9G/PAg0WOqxiF72VHs709pNjJ32ixMBQNeEC9mLUMt8XhlGWZgBKL8VIayRdwMqO5dlNMa7iBqDVIGHc2XWzbrtmavzJAKyGojVfYWXbIDkrdLMpLfCUTd1zqHh5histNHTTcPKLAjfG7wsKKQZgwbx+3AWMAqeCaQDWNHbVLCbxOTnXR5usTuWg9XxJtWrTcB2qtTzjXglvygfvTfxB3/7qxL1q8juHUDPoAGZIh8xBR17SqMP6+uNUHrHYs6TEi6tasPKaZQxjR154RQ1fmMLQRTmKE3kBK7rAYESHU+6D0rdz1MoOe87Yj79Usfv5Lko7Bo8rfcbFjsU6z/m2CyfMUGjeduMWn9F5VA3ArVu3GlG69957L1/84hfZunUrruty55138uSTT3LmmWcC8NxzzwGwevXqg7rOO9/5Th566CH+7u/+bu4an2HhoG+A5Q8XGC6UWXP6ACueH2Y0sPHzEQ7agfLeRo8piFGgsCsayzN5eXZj+g9bC6gtkYZRqLW52wjhbyMIRIIX4coJPWEkBub1Sk6N9Z19jDWKbB9ailaC1kKNcq5BwXZpzddYKYYACLSkoWyq5BkMigyIMkraoKHcq4yAFj8v8Fpj+ZLjFEwF+WFTwFn62qjHtnxO634JH8mL7jKGVZnSbp/ic30TJQKgSk7WycXED0vjbZR3j049tOAIZao4HqBceOFz/dgtNo0/OpWO3Cgn7Rpjw85RRlodhAAdoUbvd8v0NUwvyR6rDSfS2bXAYbARrqQ6H/fpelJRWyrYeZFNvyxDDVQtyyeQYQEh4wDOGkf1y121apXxu7OzE9u2p3b3Lr30Um688UZuvfVWbNvmpptu4uKLLz7ogI62tjZuuOEGrr322jlre4aFg2BgEAYGaQC1jnZ61g3xwovd+AVr+hMFiewc8d29XEVjRYIuwh1A88MWgTYEm7UUuK05Y9WpUlSetTRdrFpiBqWQiMmg1a5wUuteRupldg4vnTo+UM0xMLkLJ0JXbtFyaXOqlO06rXaNrmCcDfRRIcfzchm5PolVa+7u+CWLums2QFsYUdlCaYr7/YRRGsXJ63bT0Da/bDR36Z1xD3/HSwc8Z6oNqht/ke5GLESoOrh1nz6rnRfOCHeElw7UOGn3KG3flmBLvNWa2tkB4/k8467pyxcxDoDWgkYQfldrto9RbxE8dX6Z5arAiBfu4ApXohehBEaGYxRaHfGc16mQi88AXFDqnZs3b+acc87h6quv5k//9E855ZRT2LJlyyHV9drXvpZf+7Vfm9sGZlhw2PPgGHZZkrcX/86RrXxWWQOc3rKTs9te4BVtL3BS616Gai2G8ZcOSVUV2Nvo4oXKSn7hrudHuZP5hb0KjeAs9RIre/rnvM0528WxA56srZq5cIZ5QV93kR+fs4SBP1bUz1BYfYK2L9ss+dHBcfZePLdIrqZ52bcyUfYMCxiZDuCsMa9791deeSVXXnnl1O9iscgtt9xyUFG8q1evPmCqt7//+78/3CZmWOBQVYU3FrC8Y5gRtTj15Nr8KqfW+ihqj8AWjPtFeuudVIM8vm9jHYZtOyZLPJZbS7c/xqkte3HWBeza0TPziTNASp9ysUG5VEdpgcrSii982NA4S9E4S2H3QvlBh2W5Bvt+ZZqIngiqnTa/uLSFl39tnLY9HntnWpNkyDAP0Fqj58EFrBdh4Ek2amdY9Bj+ZZ2W033sio+PmTPYgE5G+E4ebx6LReEqnXR/6uQ5h4JWv8ap9X2UlMeILPDL0krsPTZ2rVmfpXTCTZ2K+IAnpBGEMqJbeHHPck5cvZdVa/vZvXPSCFQUpIernEQmlulw8ro9WFKjtaBSy2PXlaH9J7xgEVKiEqlwlQAADtdJREFUjx3YVY0ebQYFebbihZYlWJNuqhIse1mN1Y+7DJzs4BfT+14IjRX9aBzByFKLVc+5PLtEgZRoW2OvXA4RfncwNIxuLP5d+QyLEPO2G7f4RrzMAMyw6FHt9WjZaPEr5Z38srIWHxvL04kADwDlRLh5kxktovPbuMIeb2YxEEpjVafPaqCFQASz20UBKPt1Ntb3UVYuYzLPj8vrqFs50LDm0X2obTNz52aEFIgoD1FK9BknscNdyvqT+jh5426UFthW03AMtKSi8gwGZQb9tgMahFIGWFLzzLZVKGUhA037T59CRSb8qChwhqOPns//jKX/FpPTsUyO7PN/eRo95ec58Tt1nv3tAsIS2NLUB7SkYlnJjMredV4rqx6BM79RYd/6HLnu/bxwewfI5vuy+lOrsL7933N+XxkyzIj5igLOdgAzZDi6yPfYrL28g6HREbSWnFnewXO15YyrcnJnTgtz507rFOFnbWrhTacpJRXlLhc0NIRDBQcfSRq11lY+K9xRlrpjtCiXcZnn0dJaqnaMhO+F4tdzAaPVQiC0xm3keP6Z5bR3VBEFTb/VRk0VyOHSnR+j3amyNjfA+tz+KZFmUQ4fgeuFki6lYmjoqUnJGA1qQqw7w8KAqtehPn02DunDi79WYOMDNdb+qMFLrykkywidEIxWOcmzv9pC8acVlr/YYNWzDV7GGI2i5OnzyzRabJSTZ4aQrAwZjgxUAPOiSbn4dDAzAzDDooUswJrf76C2z+OpgbXUuyzW5/vZUNzLXreDvV7XEblueUmd7tVV7IIKbUMNy+S4UUa7gsATKASWVlhoAgTjMs9PS2uo2MnJ9mhBBTZDA21hFHBXOAS45NjT6KbX70YLQQ6XNrsKSmCPKXIyoFSsUSy41Bs5duxuZ4HFkGU4BKicZNtr8pz43QZdz3mMnjo7s813JM+d15SQyVUCNv54nNN/NM7PLmk7Us3NkGFGaKXQ8xAFrDMZmAwZjh5WXdaBNxYw8kgFTlsKSLY3ljEWFFmf76e1rcZzoyuYC0MlX/ZoX1Gj1OkiLagOO/Q+1YbfsEEIBs5qxy+ChU8Bn7zlYzs+eeXTkDZ7c634wk5m2ligcMmx38+FMjCVUAZmYDib2I9F1Lpt+jcELPulx/gJAnIHn57PLVs8/upWzvnWCGuerjM8983MkGF2mK9MIItkbI8iMwAzLErkui3y3TY7/mWQjs5OSs8PUiyF7lQFbO9cyppT9nNm5w721jroqx/kjpVUdHRWaG2vkS96CAF+QzK6r8DgzpJZl9Z0PjUOkSAIbVn4OYdJJtwSfNDT8+KE1uih4dm38WCgNdaeQSy7ucPj5BwKe2I8MSlNHUCtEeO16QNdtMbPOH+LDssfqTE4vAKAMaBTvEjbjwX5/9HczZZC0WKblATVImhTFo4eSdSpCtAmGgw6B29EZsgwJ5ivIJADrO49z+PDH/4wX/va1wB4wxvewDve8Q4sa/5JEpkBmGHxQcKq322n3ufjjSjohODZF8wiq1byyyVrWVvez4rSMCtKQ1TJUw1yVESeCjmE1lgijHTM41MSDcrLXfK2h2UrtBLUazb7Xywz1p/ngAZkoJG/eC7kXU1AwCFxoI4ki8TfPWMWzQQW4aI2wywhv/szlny3+XvknDLdryxTzo82ywiNjE1sZatBi5K0ikHjuKqCV+2ic+MoL/wwowdkmCeoYH7yUov0a3784x/nRz/6EZ/+9KepVCq8+93vpr29nbe+9a1HuYFJZAYgsPXFu1i9ejW1Wo1isTjzCRnmDa7rsnnzZkZHR7nt07eRy+Vm7DelFD/4wQ947LHH2L9/P2NjY7iuCwJEMdypcByHcrlMZ+cyVq1axUUXXcSKFSuO1m0dt8i+uYWD7du387GPfYw7zv7XGcum9dvNN9+MXqL5wO9+Cn73SLUyw+FiMX9zu3bt4pJLLpm+kJ6nVHAp12w0GnzhC1/gE5/4BGeddRYA73jHO9iyZQt//ud/jpTzu1DKDMAMiwJKKb71rW/x1a9+lUKhwKZNm8jlcjOfCEgpueiii7jooouOcCszZFi8yOfzhyxm+4UvfIHBwUE++MEPznGrMmQ4OGil5yU1Ydo1n3rqKWq1Gueee+7UsXPPPZf+/n527tzJ+vXrj2ILk8gMQGD37t0A1Ot1CoX5i87MYCIIAl588UV++MMfsn37dpRSvOY1r+E3f/M3qdVq7Nq1C8j6bTEj67uFgy9/+ctYljX1XU2HaL89//zz/Od//id/+Id/yNjYGGNjYzOcnWE+sZi/ub17985YxrfceQkC8a2kXuy+ffsolUq0tDQj5nt6QhH+vXv3ZgbgfKKtLYxqfPOb3zzPLckwW/zgBz9g8+bN892MDBmOWfznf/7nIZ33wx/+cI5bkiFDEu3t7YZBNYmWlhba29vp44WUs44O4m2r1WoJT9Xkb9edG73Xw8FxbwD+5Cc/YXR0dObCGTJkyJAhQ4Z5RUtLCx0dHYnjHR0d/Od//ifj4+PJk44S4m0rFAoJQ2/y90LgYR7XBiCERuDkTmCGDBkyZMiQYXGio6Mj1TicLyxfvpxqtUqlUqFcLgPQ398PwLJly+azaUAm5Z8hQ4YMGTJkyDDn2LhxI8VikZ/+9KdTxx599FGWLFnC2rVr57FlITIDMEOGDBkyZMiQYY5RKBS44ooruPXWW/npT3/Kj370I7Zs2cKf/umfznfTABD6UOP+M2TIkCFDhgwZMhwQjUaDD37wg3zta18jn89zxRVXcO211867BiAcBwZgEAR84hOf4Etf+hKNRoMLL7yQm2++mY6ODr72ta9x++23s2LFCrZs2cKKFStmFJr8p3/6J0PTJ8ORwZe+9CU2bdqU+m+f//zn6evry/puAWN8fJzbbruNhx56CICLL76Y66+/ns7Ozuy7W8AYHh7mgx/8IN///vfJ5XL80R/9EX/1V3+FlDLrtwUI13V5wxvewHXXXcev//qvAzOnHsv6McMkjvkgkC1btnDvvffysY99jM7OTm644QZuuukmPvaxj3H33Xdzxx138PTTT3PnnXfy4Q9/eOq8rVu3csIJJyTqW0gE02MZr33ta7nwwguNY5s2bWJsbIzTTz+dD3zgA1nfLWC8//3vZ/v27dxzzz0AvO997+N973sfW7Zsyb67BYxrrrmGoaEhPvWpT2HbNu9973tpNBq8/e1vz/ptgaFer3Pdddfx7LPPGsenSz3WaDSyfswwhWPaABwfH2fr1q3ccccdXHDBBQC85z3v4ZZbbsF1XQqFAhs2bACSGlYdHR1Tgo0Zjj4KhYIhVvrNb36TRx55hPvvvx+tddZ3CxwPPfQQ73//+znjjDMAuOqqq7jpppvwPC/ruwWKJ554gh//+Md85Stf4bTTTgPg1ltv5corr+Stb31r1m8LCE888QTvec97pnb1JjFT6rHs+8sQxTFtAD766KNYlsXFF188deyVr3wlX//61wG44IILOO+882hpaZnaqciw8OD7PrfffjtXXXUVa9asAbK+W+jo7Ozkvvvu4+KLL0YIwX333cfLXvYyWlpasr5boNi5cyeFQmHK+AM49dRTcV2XJ598Muu3BYSHH36YSy65hL/8y7+cMvRgdqnHsn7MMIlj2gDcsWMHy5cv58EHH+STn/wkQ0NDXHjhhWzatInW1lauvfZarrrqKkql0qzzymY4+vjGN75BX18ff/ZnfzZ1LOu7hY0PfOADvPvd7+a8884DYM2aNXzhC18Asr5bqFiyZAn1ep3BwUG6urqAZprMwcHBrN8WEKJjYRSzST2W9WOGSRzTBmClUqGvr4+7776bTZs2YVkWt912G9dddx2f+cxngANzG974xjcmonROOOEEvvSlLx3pZmeI4Z//+Z/5gz/4A9rb243jWd8tXGzbto0TTjiBO+64A9/3ue2227jhhhv49Kc/DWR9txBx1llnsWbNGm6++WY++MEPopTitttuw7ZtPC/Mc5r128LGbFOPZf2YAY5xA9C2bSqVCps3b2bjxo0A3HbbbVx++eXs2LGDdevWHfDcO++8M5Go2XGcI9ncDCnYt28fjz76KO95z3tmfU7Wd/OLnTt38sEPfpAHHnhgqh/uuOMOfvd3f5df/OIXnHnmmQc8N+u7+UMul+P//t//y3XXXcf5559PsVjk7W9/O0899VRq7tUosn5bGDjc1GNZPx5fOKYNwKVLlwJw8sknTx078cQTAejt7Z3WAFyxYsW0/57h6OB73/seK1asmNZoiCPru/nF448/Ti6XMyaSk08+mUKhwK5du6bty6zv5hcbN27k/vvvZ2BggJaWFoIg4KMf/egU9/ZAyPptYeBwU49l/Xh8Yf6VCI8gzjnnHACefPLJqWPPPfccAKtXr56XNmU4OPzsZz/L9KcWGZYtW0a9Xmf79u1Tx3bt2kW9Xl8Q6Y8ypGNkZIQ/+ZM/obe3l+7ubvL5PN/5znfo6enhpJNOmu/mZZgFFnrqsQwLC8f0DuCaNWu49NJLufHGG7n11luxbZubbrqJiy++eMYV7fDw8NTKKYpyuUypVDpSTc4QwzPPPMNv/dZvHdQ5Wd/NL8466yzOOOMMNm3axHvf+1601nzwgx/kV3/1V3nZy1427blZ380f2tvbaTQabN68mXe84x3s2LGD97///Vx77bUIIaY9N+u3hYFo6rHNmzfjuu5BpR7L+vH4wjFtAAJs3ryZj3zkI1x99dUEQcAll1zC+973vhnP+1//63+lHn/HO97B1VdfPdfNzHAADAwMJII/ZkLWd/ML27b5+7//ezZv3sxb3vIWhBBTmUBmQtZ384tPfOIT3HLLLfz+7/8+XV1d/J//83/4n//zf854XtZvCwfvete7aDQa/Pmf//lU6rG3vOUtszo368fjC8d8KrgMGTJkyJAhQ4YMJo5pDmCGDBkyZMiQIUOGJDIDMEOGDBkyZMiQ4ThDZgBmyJAhQ4YMGTIcZ8gMwAwZMmTIkCFDhuMMmQGYIUOGDBkyZMhwnCEzADNkyJAhQ4YMGY4zZAZghgwZMmTIkCHDcYbMAMyQIUOGDBkyZDjO8P8Bq/HkxYiatW4AAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -475,19 +445,20 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:09:57.127443Z", - "start_time": "2022-01-10T20:09:56.979316Z" - } + "end_time": "2023-08-03T11:58:02.296648Z", + "start_time": "2023-08-03T11:58:02.036611Z" + }, + "hidden": true }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -500,14 +471,18 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "heading_collapsed": true + }, "source": [ "## UncOutput " ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "The `UncOutput` class is used to store data from sampling, uncertainty and sensitivity analysis. An UncOutput object can be saved and loaded from .hdf5. The classes `UncImpactOuput` and `UncCostBenefitOutput` are extensions of `UncOutput` specific for `CalcImpact` and `CalcCostBenefit`, respectively." ] @@ -518,7 +493,8 @@ "ExecuteTime": { "end_time": "2021-08-24T09:13:12.855902Z", "start_time": "2021-08-24T09:13:12.848615Z" - } + }, + "hidden": true }, "source": [ "**Data attributes**" @@ -526,7 +502,9 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "| Attribute | Type | Description |\n", "| --- | --- | --- |\n", @@ -535,7 +513,6 @@ "| *UncImpactOutput* | | |\n", "| | | |\n", "| aai_agg_unc_df | pandas.dataframe | Uncertainty data for `aai_agg`|\n", - "| tot_value_unc_df| pandas.dataframe | Uncertainty data for `tot_value`. |\n", "| freq_curve_unc_df | pandas.dataframe | Uncertainty data for `freq_curve`. One return period per column.|\n", "| eai_exp_unc_df | pandas.dataframe | Uncertainty data for `eai_exp`. One exposure point per column.|\n", "| at_event_unc_df | pandas.dataframe | Uncertainty data for `at_event`. One event per column.|\n", @@ -556,7 +533,8 @@ "ExecuteTime": { "end_time": "2021-08-24T09:13:25.319589Z", "start_time": "2021-08-24T09:13:25.315834Z" - } + }, + "hidden": true }, "source": [ "**Metadata and input data attributes**\n", @@ -566,7 +544,9 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "| Attribute | Type | Description |\n", "| --- | --- | --- |\n", @@ -582,36 +562,33 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "### Example from file " ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "Here we show an example loaded from file. In the sections below this class is extensively used and further examples can be found." ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 13, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:09:57.232327Z", - "start_time": "2022-01-10T20:09:57.129679Z" - } + "end_time": "2023-08-03T11:58:02.373485Z", + "start_time": "2023-08-03T11:58:02.298723Z" + }, + "hidden": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "https://climada.ethz.ch/data-api/v1/dataset\tdata_type=None\tlimit=100000\tname=test_unc_output_impact\tstatus=test_dataset\tversion=None\n" - ] - } - ], + "outputs": [], "source": [ "# Download the test file from the API\n", "# Requires internet connection\n", @@ -624,19 +601,20 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 14, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:09:57.347330Z", - "start_time": "2022-01-10T20:09:57.234307Z" - } + "end_time": "2023-08-03T11:58:02.490565Z", + "start_time": "2023-08-03T11:58:02.375912Z" + }, + "hidden": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "2022-07-06 20:49:01,375 - climada.engine.unsequa.unc_output - INFO - Reading /Users/evelynm/climada/data/unc_output/unc_output_impact/test_unc_output_impact/v1/test_unc_output_impact.hdf5\n" + "2023-08-03 13:58:02,377 - climada.engine.unsequa.unc_output - INFO - Reading /Users/ckropf/climada/data/unc_output/unc_output_impact/test_unc_output_impact/v1/test_unc_output_impact.hdf5\n" ] } ], @@ -648,19 +626,20 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 15, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:09:57.816798Z", - "start_time": "2022-01-10T20:09:57.349069Z" - } + "end_time": "2023-08-03T11:58:03.060914Z", + "start_time": "2023-08-03T11:58:02.492871Z" + }, + "hidden": true }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -668,27 +647,20 @@ } ], "source": [ - "unc_imp.plot_uncertainty(metric_list=['aai_agg', 'tot_value'], figsize=(12,5));" + "unc_imp.plot_uncertainty(metric_list=['aai_agg'], figsize=(12,5));" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 16, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:09:57.896979Z", - "start_time": "2022-01-10T20:09:57.818042Z" - } + "end_time": "2023-08-03T11:58:03.124126Z", + "start_time": "2023-08-03T11:58:03.063366Z" + }, + "hidden": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "https://climada.ethz.ch/data-api/v1/dataset\tdata_type=None\tlimit=100000\tname=test_unc_output_costben\tstatus=test_dataset\tversion=None\n" - ] - } - ], + "outputs": [], "source": [ "# Download the test file from the API\n", "# Requires internet connection\n", @@ -701,19 +673,20 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 17, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:09:58.001701Z", - "start_time": "2022-01-10T20:09:57.899455Z" - } + "end_time": "2023-08-03T11:58:03.218940Z", + "start_time": "2023-08-03T11:58:03.126055Z" + }, + "hidden": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "2022-07-06 20:49:04,789 - climada.engine.unsequa.unc_output - INFO - Reading /Users/evelynm/climada/data/unc_output/unc_output_costben/test_unc_output_costben/v1/test_unc_output_costben.hdf5\n" + "2023-08-03 13:58:03,127 - climada.engine.unsequa.unc_output - INFO - Reading /Users/ckropf/climada/data/unc_output/unc_output_costben/test_unc_output_costben/v1/test_unc_output_costben.hdf5\n" ] } ], @@ -725,12 +698,13 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 18, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:09:58.028476Z", - "start_time": "2022-01-10T20:09:58.003571Z" - } + "end_time": "2023-08-03T11:58:03.249395Z", + "start_time": "2023-08-03T11:58:03.220866Z" + }, + "hidden": true }, "outputs": [ { @@ -904,57 +878,57 @@ "" ], "text/plain": [ - " Mangroves Benef Beach nourishment Benef Seawall Benef \\\n", - "35 2.375510e+08 1.932608e+08 234557.682554 \n", + " Mangroves Benef Beach nourishment Benef Seawall Benef \n", + "35 2.375510e+08 1.932608e+08 234557.682554 \\\n", "36 9.272772e+07 7.643803e+07 9554.257314 \n", "37 1.464219e+08 1.179927e+08 192531.748810 \n", "38 9.376369e+07 7.722882e+07 10681.112247 \n", "39 9.376369e+07 7.722882e+07 10681.112247 \n", "\n", - " Building code Benef Mangroves CostBen Beach nourishment CostBen \\\n", - "35 1.584398e+08 6.347120 10.277239 \n", + " Building code Benef Mangroves CostBen Beach nourishment CostBen \n", + "35 1.584398e+08 6.347120 10.277239 \\\n", "36 5.501366e+07 16.260133 25.984286 \n", "37 8.979471e+07 10.297402 16.833137 \n", "38 5.555413e+07 12.965484 20.736269 \n", "39 5.555413e+07 16.080478 25.718218 \n", "\n", - " Seawall CostBen Building code CostBen no measure - risk - future \\\n", - "35 4.350910e+04 66.742129 6.337592e+08 \n", + " Seawall CostBen Building code CostBen no measure - risk - future \n", + "35 4.350910e+04 66.742129 6.337592e+08 \\\n", "36 1.068151e+06 192.217876 2.200547e+08 \n", "37 5.300629e+04 117.764285 3.591788e+08 \n", "38 7.703765e+05 153.475031 2.222165e+08 \n", "39 9.554617e+05 190.347852 2.222165e+08 \n", "\n", - " no measure - risk_transf - future ... \\\n", - "35 0.0 ... \n", + " no measure - risk_transf - future ... \n", + "35 0.0 ... \\\n", "36 0.0 ... \n", "37 0.0 ... \n", "38 0.0 ... \n", "39 0.0 ... \n", "\n", - " Beach nourishment - cost_ins - future Seawall - risk - future \\\n", - "35 1 6.335246e+08 \n", + " Beach nourishment - cost_ins - future Seawall - risk - future \n", + "35 1 6.335246e+08 \\\n", "36 1 2.200451e+08 \n", "37 1 3.589863e+08 \n", "38 1 2.222058e+08 \n", "39 1 2.222058e+08 \n", "\n", - " Seawall - risk_transf - future Seawall - cost_meas - future \\\n", - "35 0 1.020539e+10 \n", + " Seawall - risk_transf - future Seawall - cost_meas - future \n", + "35 0 1.020539e+10 \\\n", "36 0 1.020539e+10 \n", "37 0 1.020539e+10 \n", "38 0 8.228478e+09 \n", "39 0 1.020539e+10 \n", "\n", - " Seawall - cost_ins - future Building code - risk - future \\\n", - "35 1 4.753194e+08 \n", + " Seawall - cost_ins - future Building code - risk - future \n", + "35 1 4.753194e+08 \\\n", "36 1 1.650410e+08 \n", "37 1 2.693841e+08 \n", "38 1 1.666624e+08 \n", "39 1 1.666624e+08 \n", "\n", - " Building code - risk_transf - future Building code - cost_meas - future \\\n", - "35 0 1.057461e+10 \n", + " Building code - risk_transf - future Building code - cost_meas - future \n", + "35 0 1.057461e+10 \\\n", "36 0 1.057461e+10 \n", "37 0 1.057461e+10 \n", "38 0 8.526172e+09 \n", @@ -970,7 +944,7 @@ "[5 rows x 29 columns]" ] }, - "execution_count": 20, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -1002,11 +976,11 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 19, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:12:31.077029Z", - "start_time": "2022-01-10T20:12:26.290169Z" + "end_time": "2023-08-03T11:58:03.313925Z", + "start_time": "2023-08-03T11:58:03.252329Z" } }, "outputs": [ @@ -1014,10 +988,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "2022-07-06 21:15:51,600 - climada.hazard.base - INFO - Reading /Users/evelynm/climada/demo/data/tc_fl_1990_2004.h5\n", - "2022-07-06 21:15:51,643 - climada.entity.exposures.base - INFO - Reading /Users/evelynm/climada/demo/data/exp_demo_today.h5\n", - "2022-07-06 21:15:51,714 - climada.entity.exposures.base - INFO - Matching 50 exposures with 2500 centroids.\n", - "2022-07-06 21:15:51,718 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n" + "2023-08-03 13:58:03,258 - climada.hazard.base - INFO - Reading /Users/ckropf/climada/demo/data/tc_fl_1990_2004.h5\n", + "2023-08-03 13:58:03,286 - climada.entity.exposures.base - INFO - Reading /Users/ckropf/climada/demo/data/exp_demo_today.h5\n", + "2023-08-03 13:58:03,306 - climada.entity.exposures.base - INFO - Matching 50 exposures with 2500 centroids.\n", + "2023-08-03 13:58:03,307 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n" ] } ], @@ -1064,31 +1038,22 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 20, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:12:31.243592Z", - "start_time": "2022-01-10T20:12:31.080076Z" + "end_time": "2023-08-03T11:58:03.583185Z", + "start_time": "2023-08-03T11:58:03.315873Z" } }, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2022-07-06 21:15:51,732 - climada.entity.impact_funcs.base - WARNING - For intensity = 0, mdd != 0 or paa != 0. Consider shifting the origin of the intensity scale. In impact.calc the impact is always null at intensity = 0.\n" - ] - }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -1099,11 +1064,11 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 21, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:12:31.264407Z", - "start_time": "2022-01-10T20:12:31.244994Z" + "end_time": "2023-08-03T11:58:03.591398Z", + "start_time": "2023-08-03T11:58:03.585492Z" } }, "outputs": [], @@ -1129,19 +1094,19 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 22, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:12:31.372669Z", - "start_time": "2022-01-10T20:12:31.266932Z" + "end_time": "2023-08-03T11:58:03.793861Z", + "start_time": "2023-08-03T11:58:03.593678Z" } }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1171,11 +1136,11 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 23, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:09:58.303866Z", - "start_time": "2022-01-10T20:09:58.299067Z" + "end_time": "2023-08-03T11:58:03.808020Z", + "start_time": "2023-08-03T11:58:03.799037Z" } }, "outputs": [], @@ -1194,11 +1159,11 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 24, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:09:59.030811Z", - "start_time": "2022-01-10T20:09:58.305737Z" + "end_time": "2023-08-03T11:58:05.118435Z", + "start_time": "2023-08-03T11:58:03.810704Z" } }, "outputs": [ @@ -1206,7 +1171,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2022-07-06 21:15:53,716 - climada.engine.unsequa.calc_base - INFO - Effective number of made samples: 1536\n" + "2023-08-03 13:58:05,110 - climada.engine.unsequa.calc_base - INFO - Effective number of made samples: 1536\n" ] }, { @@ -1291,7 +1256,7 @@ "1535 0.876684 0.790617 53.662109 2.080078 4.539062" ] }, - "execution_count": 6, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -1310,19 +1275,19 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 25, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:10:00.108143Z", - "start_time": "2022-01-10T20:09:59.032215Z" + "end_time": "2023-08-03T11:58:06.593742Z", + "start_time": "2023-08-03T11:58:05.121207Z" } }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1342,11 +1307,11 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 26, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:10:07.977028Z", - "start_time": "2022-01-10T20:10:00.110174Z" + "end_time": "2023-08-03T11:58:19.586495Z", + "start_time": "2023-08-03T11:58:06.596075Z" } }, "outputs": [ @@ -1354,10 +1319,13 @@ "name": "stdout", "output_type": "stream", "text": [ - " ... \n", - "2022-07-06 21:15:59,545 - climada.engine.unsequa.calc_base - INFO - \n", + "2023-08-03 13:58:06,602 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2023-08-03 13:58:06,604 - climada.engine.impact_calc - INFO - Calculating impact for 250 assets (>0) and 216 events.\n", + "2023-08-03 13:58:06,605 - climada.engine.impact_calc - INFO - cover and/or deductible columns detected, going to calculate insured impact\n", + "2023-08-03 13:58:06,611 - climada.engine.impact - WARNING - The Impact.tot_value attribute is deprecated.Use Exposures.affected_total_value to calculate the affected total exposure value based on a specific hazard intensity threshold\n", + "2023-08-03 13:58:06,612 - climada.engine.unsequa.calc_base - INFO - \n", "\n", - "Estimated computaion time: 0:00:25.036800\n", + "Estimated computaion time: 0:00:21.811200\n", "\n" ] } @@ -1380,11 +1348,11 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 27, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:10:07.983175Z", - "start_time": "2022-01-10T20:10:07.979382Z" + "end_time": "2023-08-03T11:58:19.593106Z", + "start_time": "2023-08-03T11:58:19.588476Z" } }, "outputs": [ @@ -1394,7 +1362,7 @@ "['aai_agg', 'freq_curve', 'tot_value']" ] }, - "execution_count": 9, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -1406,11 +1374,11 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 28, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:10:07.996479Z", - "start_time": "2022-01-10T20:10:07.990319Z" + "end_time": "2023-08-03T11:58:19.608246Z", + "start_time": "2023-08-03T11:58:19.602600Z" } }, "outputs": [ @@ -1472,7 +1440,7 @@ "1535 1.848139e+09" ] }, - "execution_count": 10, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -1491,11 +1459,11 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 29, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:10:08.007916Z", - "start_time": "2022-01-10T20:10:07.997827Z" + "end_time": "2023-08-03T11:58:19.618733Z", + "start_time": "2023-08-03T11:58:19.609952Z" } }, "outputs": [ @@ -1581,7 +1549,7 @@ "1535 1.848139e+09 5.294874e+10 7.395191e+10 9.609003e+10 5.760281e+11" ] }, - "execution_count": 11, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } @@ -1599,19 +1567,19 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 30, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:10:09.058521Z", - "start_time": "2022-01-10T20:10:08.009813Z" + "end_time": "2023-08-03T11:58:21.031168Z", + "start_time": "2023-08-03T11:58:19.620870Z" } }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1624,11 +1592,11 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 31, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:10:09.294429Z", - "start_time": "2022-01-10T20:10:09.060409Z" + "end_time": "2023-08-03T11:58:21.449828Z", + "start_time": "2023-08-03T11:58:21.033584Z" } }, "outputs": [ @@ -1641,9 +1609,9 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1668,14 +1636,31 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 32, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:10:09.373898Z", - "start_time": "2022-01-10T20:10:09.295659Z" + "end_time": "2023-08-03T11:58:21.532951Z", + "start_time": "2023-08-03T11:58:21.452246Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/ckropf/opt/anaconda3/envs/climada_333_shapely2/lib/python3.9/site-packages/pandas/core/dtypes/common.py:1687: DeprecationWarning: Converting `np.inexact` or `np.floating` to a dtype is deprecated. The current result is `float64` which is not strictly correct.\n", + " npdtype = np.dtype(dtype)\n", + "/Users/ckropf/opt/anaconda3/envs/climada_333_shapely2/lib/python3.9/site-packages/pandas/core/dtypes/common.py:1687: DeprecationWarning: Converting `np.inexact` or `np.floating` to a dtype is deprecated. The current result is `float64` which is not strictly correct.\n", + " npdtype = np.dtype(dtype)\n", + "/Users/ckropf/opt/anaconda3/envs/climada_333_shapely2/lib/python3.9/site-packages/pandas/core/dtypes/common.py:1687: DeprecationWarning: Converting `np.inexact` or `np.floating` to a dtype is deprecated. The current result is `float64` which is not strictly correct.\n", + " npdtype = np.dtype(dtype)\n", + "/Users/ckropf/opt/anaconda3/envs/climada_333_shapely2/lib/python3.9/site-packages/pandas/core/dtypes/common.py:1687: DeprecationWarning: Converting `np.inexact` or `np.floating` to a dtype is deprecated. The current result is `float64` which is not strictly correct.\n", + " npdtype = np.dtype(dtype)\n", + "/Users/ckropf/opt/anaconda3/envs/climada_333_shapely2/lib/python3.9/site-packages/pandas/core/dtypes/common.py:1687: DeprecationWarning: Converting `np.inexact` or `np.floating` to a dtype is deprecated. The current result is `float64` which is not strictly correct.\n", + " npdtype = np.dtype(dtype)\n" + ] + } + ], "source": [ "output_imp = calc_imp.sensitivity(output_imp)" ] @@ -1689,11 +1674,11 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 33, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:10:09.378951Z", - "start_time": "2022-01-10T20:10:09.375335Z" + "end_time": "2023-08-03T11:58:21.539626Z", + "start_time": "2023-08-03T11:58:21.535288Z" } }, "outputs": [ @@ -1703,7 +1688,7 @@ "['aai_agg', 'freq_curve', 'tot_value']" ] }, - "execution_count": 15, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } @@ -1714,11 +1699,11 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 34, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:10:09.387414Z", - "start_time": "2022-01-10T20:10:09.380746Z" + "end_time": "2023-08-03T11:58:21.549400Z", + "start_time": "2023-08-03T11:58:21.542078Z" } }, "outputs": [ @@ -1782,6 +1767,7 @@ " 69\n", " S2_conf\n", " k\n", + " k\n", " NaN\n", " \n", " \n", @@ -1797,7 +1783,7 @@ "69 S2_conf k k NaN" ] }, - "execution_count": 16, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } @@ -1815,11 +1801,11 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 35, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:10:09.404036Z", - "start_time": "2022-01-10T20:10:09.389175Z" + "end_time": "2023-08-03T11:58:21.564807Z", + "start_time": "2023-08-03T11:58:21.551832Z" } }, "outputs": [ @@ -1923,7 +1909,7 @@ "4 S1 k None 0.213491 0.189862 0.134867 0.095861 0.000000" ] }, - "execution_count": 17, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } @@ -1941,11 +1927,11 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 36, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:10:09.421703Z", - "start_time": "2022-01-10T20:10:09.405393Z" + "end_time": "2023-08-03T11:58:21.579391Z", + "start_time": "2023-08-03T11:58:21.566526Z" } }, "outputs": [ @@ -2025,7 +2011,7 @@ "4 tot_value x_exp None 1.005253" ] }, - "execution_count": 18, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" } @@ -2040,24 +2026,24 @@ "source": [ "The value of the sensitivity indices can be plotted for each metric that is one-dimensional (`eai_exp` and `at_event` are not shown in this plot). \n", "\n", - "As expected, the `tot_value` of the exposure is only dependent on the exposure parameter `x_exp`. We further see that both the errors in `freq_curve` and in `aai_agg` are mostly determined by `x_exp` and `v_half`. Finally, we see small differences in the sensitivity of the different return periods." + "We see that both the errors in `freq_curve` and in `aai_agg` are mostly determined by `x_exp` and `v_half`. Finally, we see small differences in the sensitivity of the different return periods." ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 37, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:10:09.831408Z", - "start_time": "2022-01-10T20:10:09.423264Z" + "end_time": "2023-08-03T11:58:22.457213Z", + "start_time": "2023-08-03T11:58:21.581245Z" } }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABJoAAAMWCAYAAAC5vOyrAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC+/ElEQVR4nOzde1zUVf7H8feAgCIqkkZBtlrGaCleU1NTUxOjMqVWMMXUVWvDS3lJzPKXmOmmSQK2dtlSE10yb1uhXbzVbpqwWnlJzLtoIoooiHKd3x8uUxODgX6BAV7Px2MfPznnfM98Bn7i6T3ne74mi8ViEQAAAAAAAHCDnCq6AAAAAAAAAFQNBE0AAAAAAAAwBEETAAAAAAAADEHQBAAAAAAAAEMQNAEAAAAAAMAQBE0AAAAAAAAwBEETAAAAAAAADEHQBAAAAAAAAEPUqOgCHEX79u2Vk5Ojhg0bVnQpAACgjKSmpsrV1VWJiYkVXYpDYj0EAEDVV9brIYKm/8nOzlZ+fn5FlwEAAMpQXl6eLBZLRZfhsFgPAQBQ9ZX1eoig6X9uvvlmSdLGjRsruBIAAFBWevXqVdElODTWQwAAVH1lvR7ijCYAAAAAAAAYgqAJAAAAAAAAhiBoAgAAAAAAgCEImgAAAAAAAGAIgiYAAAAAAAAYgqAJAAAAAAAAhiBoAgAAAAAAgCEImgAAAAAAAGAIgiYAAAAAAAAYgqAJAAAAAAAAhiBoAgAAAAAAgCEImgAAAAAAAGAIgiYAAAAAAAAYgqAJQLWUlZUls9kss9msrKysii4HAACgUmJNBeD3CJoAAAAAAABgCIImAAAAAAAAGIKgCQCAamD16tUym81avHhxRZcCAABQaQ0aNMh6u+jv/7dixQqbsZcvX9abb76pBx98UP7+/goMDFRsbKwsFksFVV8+alR0AQAAlEbj8M8quoRrOjrn4Youwa7mzZtrzJgxat26dUWXAgAAHAzrq5L7+eef1aRJEz38cNGaWrRoYf1zfn6+xo8fr61bt6p79+4KCAjQ119/rYiICCUnJ2vKlCnlWXa5ImgCAKAaaN68uZo3b17RZaAU8vLytGzZMn300UdKTk5Ww4YNFRQUpNGjR8vFxeUPrz9w4IDefPNNJSQk6MqVK2rcuLGGDBmi4ODgcqgeAICqJzk5WRkZGXr88cc1duzYa46Nj4/X1q1bNWrUKE2aNEmSNH78eI0cOVIffPCB+vfvL7PZXB5llztunQMAAHBAERERmj17tjw9PTV06FB5e3srKipKEydO/MNrDxw4oODgYG3ZskXdunXToEGDlJWVpenTp2vu3LnlUD0AAFVPUlKSJMnPz+8Px8bGxsrFxUVPP/20tc3FxUXPPfecLBaLVq1aVWZ1VjSCJgAAHFBSUpImT56s7t27q0WLFmrbtq1CQkK0fv16m3HJycmaPn26evfurZYtW6pNmzYKCgpSbGyszTgjzmhKTEzUmDFj1LVrV7Vo0UL33nuvhg8frm3bthUZe/z4cU2YMEGdO3dWmzZtNGrUKB06dEgPPvigQkNDbcaePXtW06dP1/33369WrVrpySef1M6dOzVs2DD17NnzuuutzHbu3Km4uDgFBgZq+fLlmjRpkmJjY9W/f399/vnn2rJlyzWvj4qKUlZWlqKiovTGG2/oxRdf1L/+9S/dcccdev/993XixInyeSMAADiI0NBQ9ezZU5s2bVL37t3VqlUrjR8/XmazWZMmTdK2bdsUFBQkf39/9ezZU5GRkcrOzraZozBouuuuu675Wjk5Odq9e7fMZrPq1Klj0+fv769atWopISHB2DfoQAiaAABwMD/++KMGDhyoLVu2qGvXrho+fLi6du2q3bt367nnntPGjRslXQ2ZHn/8ca1bt06tW7fWsGHD9OCDD+rQoUOKiIjQ0qVLDavpq6++UmhoqL7//nv17t1bTz31lNq0aaNt27bpL3/5i/bt22cde/ToUQUHB2v9+vXWgOzEiRN68sknlZ6ebjNvWlqannzyScXFxemuu+7S4MGDdeXKFT311FM6dOiQYfVXNoVBYVhYmLXNZDJpwoQJMplMWrly5TWv3717t+rVq6fevXtb22rXrq1HH31UBQUF2r17d9kUDgCAAzt//rwmTpyoDh06aMCAAWrfvr2kqwHSqFGjVLt2bQ0ePFj16tXTokWLNHr0aBUUFFivLwyadu3apaCgILVu3Vr333+/Xn31VV28eNE67uTJk8rLy9Ptt99epAZnZ2fdcsstOnLkSBm/24rDGU0AADiYBQsWKC8vT6tXr9add95pbd+wYYPGjx+vzz77TL169dI777yj9PR0vf/+++rSpYt1XGhoqJ544gl99tlnGjp0qCE1zZs3T3Xr1tXatWvVoEEDa/s//vEPvf7661q/fr3uvvtuSdJrr72mtLQ0RUZGKjAwUJL0/PPPa9iwYfrvf/9rM290dLSOHTumSZMmadSoUZKkgoICTZgwQevXr5evr68h9Vc2iYmJ8vLyUtOmTW3avb291bhx4z/8FLRu3bpKTU3VhQsXVK9ePWt7SkqKJKl+/frGFw0AgIPLysrS8OHDFR4ebm179dVXdeDAAQ0ePFjTp0+XdPWcxAkTJujzzz/X2rVrFRQUJOnXoCk6OloBAQFq3769duzYoQ8//FDbtm3TP//5T9WpU8f6wdrvdzMVqlOnjo4cOaK8vDzVqFH1Yhl2NAEA4GCGDRumuXPn2oRMktSpUydJV3cBSVK/fv00a9Ysm5BJklq2bKnatWtbx92ogoICTZw4Ua+//rpNyGSvprS0NH3zzTdq27atNWSSJFdXV+tBmIXy8vL06aefytfXV8OHD7e2Ozk56YUXXpCzs7Mh9Vc2OTk5On36tBo1amS339fXVxcuXLjmzzckJET5+fmaOHGijh07pszMTK1evVqrVq1S8+bN1aFDh7IqH0AlkpWVZX0se1ZWVkWXA5SLPn36FGlzd3fX+PHjrV/XqFFDL7zwgkwmkz755BNJV9dDdevWVfPmzfXZZ59p1qxZevHFF7V69WoFBwfr4MGDioqKknR1jSNdXf/YU9j++1vzqoqqF50BAFDJ3X///ZKk1NRU7d+/X8ePH9ehQ4e0a9cuSVcflytJ7du3V/v27ZWenq6ffvpJx48f1+HDh/XDDz8oKytLnp6ehtTj5OSkBx98UNLVreA///yzjh07poMHD1p31hRuK9+7d68KCgrUunXrIvO0atXK5lO748eP6+LFi7rvvvuKfJrn4+OjW265xZD6K5uSfAoqSRkZGfLy8rI7ZvDgwXJyctKsWbNsFtRdunTRG2+8UW1DPAAAbrvttiJtZrPZZgdw4TgvLy/t379f0tX10EcffVTkWicnJ02ZMkWffPKJ1q9fr2nTpsnNzU2SlJuba7eGnJwcmUwm1apV60bfjkMiaAIAwMH88ssvmjlzpjZt2iSLxSJnZ2c1btxY7du3tzkL6cKFC5o9e7Y+/fRT5ebmymQyqVGjRurQoYN1a7dRkpKS9Oqrr2rHjh2Srj41pWnTpvL399eRI0dksVgkXT37QFKRnU/S1TMJfhuMXGusJN188806c+aMoe+jMjDiU9Dvv/9eb7/9tlxcXPTwww+rTp06+vbbb/Xtt98qJiZGL730kkwmk/HFAwDg4GrWrFmkzdvb2+7YBg0a6PDhw384Z+3atfWnP/1JP/30k65cuWINrTIzM+2Oz8jIkLu7u5ycquZNZgRNAAA4EIvFotGjR+vgwYMaNWqUAgIC5OfnJ1dXV6WlpSkuLs46dvLkydq6dasGDhyoAQMGqFmzZnJ3d5ckxcfHG1ZTZmamRowYoYyMDE2aNEndunXTnXfeqRo1amj37t1at26ddayHh4f1GnsuXbp0XWOrk8IF8LU+BZVU7KegmZmZevrpp1VQUKDVq1erSZMm1vkmT56sZcuW6a677lJISEgZVA8AQOVT3Ic3mZmZ1h3iFy9e1MGDB1W/fn3rv62/deXKFTk5OcnFxUW+vr5ycXFRcnJykXH5+fk6ffp0kSMSqpKqGZ8BAFBJ7d+/XwcOHNCDDz6oiRMnqkWLFtYdLAcPHpR0NYy6ePGitm7dqhYtWmjmzJlq27atNWQ6efKksrKyrLuMbtT27dt19uxZDR48WKNGjZLZbLbe6vbbmiTpnnvukclk0o8//lhknoMHD9qER3fccYfc3d3tjr148WKVfhrLtXh4eMjJyeman4JKxd9at3HjRqWnpys0NNRmIezi4qKXX35ZkvTxxx8bXDUAAJXXnj17bJ4uJ119gMapU6fk7+8vSdq3b58GDRqkv/3tb0WuP3PmjJKTk9W8eXM5OzurRo0aatWqlfbt21fk3/Mff/xRly9fVps2bcruDVUwgiYAABxI4T39586ds2lPT0+3Lmzy8vLk6uoqZ2dnXbx40brDRbr6aVpERISk4nfEGFXTqVOnFB0dba1Jurr1vEuXLvr222+1detW69icnBzNnTvX5noXFxc9+uijOnLkiFasWGFtLygo0Ny5cw2rv7JxdXWVj4+P3U9BJSk5OVn169cv9gyu06dPS5LdT0pvuukm1a9fX7/88oth9QIAUNmlpqbqvffes36dm5ur1157TRaLxfrEuXbt2unmm2/W119/bT1KQLq6xpk5c6Zyc3M1ePBga3v//v2Vk5NjXSsVzrtgwQJJ0p///OeyflsVhlvnAABwIE2aNJG/v78SExP15JNPqm3btjp//ry++uor5eTkqFatWjp//rxq1qypBx98UBs2bNCf//xndenSRVlZWdq8ebPOnj2revXqKSMjQwUFBTd8/3+7du3k6+urdevW6fz582rWrJl++eUXbdy4UW5ubjKZTNYDrCVp2rRpCg4O1l//+lf17t1b3t7e+ve//209k+m39Tz33HP65ptv9Morr2jTpk264447lJiYqMOHD6tmzZpV9uyCP9KuXTutW7dOR44csdmVlJKSomPHjqlHjx7FXnvTTTdJkt0dYRcuXFB6errMZrPhNQMoX1lZWdYdEbt27bLuagVQerVr11ZUVJS+++473Xnnndq+fbuSkpL0yCOPqHfv3pKufkA2c+ZMhYWFacSIEerbt688PT317bff6tChQ3r44YetoZQkBQUFadWqVVq8eLEOHDige+65R998843279+vESNGVOl/i6vn6g0AAAdlMpn01ltvKSgoSMnJyVq6dKkSEhLUrVs3rVq1Sl26dNHRo0d1/PhxzZo1S0899ZQyMjK0bNkyffPNN2rZsqVWrFih/v3768qVK/ruu+9uuCZ3d3d98MEH6tOnj/bt26cPP/xQe/fuVb9+/fSvf/1LzZo1U2JiovW2uDvuuEMrVqxQ9+7d9e2332rlypX605/+pCVLlkiyPVvIy8tLK1as0KOPPqoff/xRK1askLu7u5YuXaratWtX2aex/JH+/ftLkiIjI61b+S0Wi+bPny+LxaLg4OBir33ggQdUq1YtLVu2TCdOnLC25+fna86cObJYLHr44YfLtH4AACqTRo0a6b333lNqaqr++c9/Ki8vTy+++GKR3dg9evRQbGysOnfurC1btiguLk41atTQyy+/rHnz5tk8aMPZ2Vnvvfeehg0bpkOHDmnp0qXKz8/X9OnTNXny5PJ+i+XKZDHqAIdKrlevXpKunmsAoOrjU0CgbBQUFOjEiRPy8fGRi4uLTd+JEyfUu3dvDRo0SK+88ook6fjx47rllluKPGEtJydHbdu21X333ad3333XsPoq07/3zz//vOLj4+Xv76+OHTtq165dSkxMVEBAgBYsWGBdzBZuyR87dqz12lWrVumll15SrVq1FBAQoLp162r79u3av3+/OnTooH/84x92n2pXmb4/QHVnxFrGUeYAKpLZbFazZs1sHm5S1ZX1v/fcOgcAAAxjMpnUv39/eXt761//+pdNmPGPf/xDktSxY0dr27PPPquUlBRt3LhRdevWtbYvWbJEubm5NmOrm9dff11NmzbVmjVrtGTJEvn4+GjcuHEaNWqUzSemMTExkmyDpscff1y+vr5699139eWXX+rKlStq1KiRxo8fr5EjR9oNmQAAAIxA0AQAQDXz3Xff2Rxi+UeeeuopmxDoWkwmk0JCQvT++++rX79+6tatm5ydnbVz5059//336tq1q/r27WsdHxISopkzZ+rRRx9Vr169VKtWLe3bt0/ffvutzGazQkNDS/3+qgoXFxeFhYUpLCzsmuOSkpLstnfq1EmdOnUqi9IAAACKRdAEAEA1s2PHDusumJIYMGBAiYMmSZo8ebLuuOMOrVy5UmvWrFFeXp5uu+02TZw4UcOHD7fZjTNkyBDdfPPN+vDDDxUfH6+srCzdeuutevrpp/X0009bn3gHAACAyoGgCQCAambs2LE2t1kZzcnJSX/+859L/NjePn36qE+fPmVWDwAAQHGK2xmM68dT5wAAAAAAAGAIgiYAAAAAAAAYgqAJAAAAAAAAhiBoAgAAAAAAgCEImgAAAAAAAGAIgiYAAAAAAAAYgqAJAAAAAAAAhiBoAgAAAAAAgCEImgAAAAAAAGAIgiYAAAAAAIBS2rx5s8xms3766Se7/ZcvX9abb76pBx98UP7+/goMDFRsbKwsFkuRsXl5eVq8eLECAwPl7++vXr16aeHChcrNzS3rt2G4GhVdAAAAAAAAqECv1KvoCq7tlQsVXUERhw4d0tSpU4vtz8/P1/jx47V161Z1795dAQEB+vrrrxUREaHk5GRNmTLFZnxERITi4uLUrl079ezZUzt37lRUVJSSkpIUFRVV1m/HUOxoAgAAAAAAKKHt27dr8ODBOn/+fLFj4uPjtXXrVo0aNUrvvPOOJk2apFWrVqlTp0764IMPlJSUZB27c+dOxcXFKTAwUMuXL9ekSZMUGxur/v376/PPP9eWLVvK4V0Zh6AJAAAAAADgD1y5ckUvvfSShg8fLovFonvuuafYsbGxsXJxcdHTTz9tbXNxcdFzzz0ni8WiVatW2YyVpLCwMGubyWTShAkTZDKZtHLlyjJ4N2WHoAkAAAAAAFRpoaGh6tmzpzZt2qTu3burVatWGj9+vMxmsyZNmqRt27YpKChI/v7+6tmzpyIjI5WdnW0zx9mzZ7Vy5Up1795d//rXv+Tn52f3tXJycrR7926ZzWbVqVPHps/f31+1atVSQkKCtS0xMVFeXl5q2rSpzVhvb281btzYZmxlQNAEAAAAAACqvPPnz2vixInq0KGDBgwYoPbt20uSkpKSNGrUKNWuXVuDBw9WvXr1tGjRIo0ePVoFBQXW6+vVq6fly5dr0aJF8vb2LvZ1Tp48qby8PN1+++1F+pydnXXLLbfoyJEjkq6GUqdPn1ajRo3szuXr66sLFy4oLS3tRt56ueIwcAAAAAAAUOVlZWVp+PDhCg8Pt7a9+uqrOnDggAYPHqzp06dLuvoEuAkTJujzzz/X2rVrFRQUJEmqU6eO2rVr94evk56ebh1vT506dXTkyBHl5eWVaKwkZWRkyMvLq0Tvs6KxowkAAAAAAFQLffr0KdLm7u6u8ePHW7+uUaOGXnjhBZlMJn3yySelfo28vDxJkqurq93+wvbs7OxSja0s2NEEAAAAAACqhdtuu61Im9lsVr169YqM8/Ly0v79+0v9Gm5ubpKk3Nxcu/05OTkymUyqVauWNUC61lhJqlWrVqnrqCgOuaMpLy9PixcvVmBgoPz9/dWrVy8tXLiw2G/872VnZysmJkYBAQFq2bKlevfurddee00XL14s48oBAAAAAICjqlmzZpG24s5batCggTIyMkr9GoWhVWZmpt3+jIwMubu7y8nJSR4eHnJycrrmWKn4W+sckUMGTREREZo9e7Y8PT01dOhQeXt7KyoqShMnTvzDa3NzczVy5EhFR0erQYMGCg0N1a233qolS5Zo5MiR1jQQAAAAAACguNvSMjMz5enpWer5fH195eLiouTk5CJ9+fn5On36tJo0aSLp6q1xPj4+dsdKUnJysurXr39ddVQUhwuadu7cqbi4OAUGBmr58uWaNGmSYmNj1b9/f33++efasmXLNa9funSpduzYoeHDhys2NlYvvPCCPvzwQw0ePFg//PCD4uPjy+eNAAAAAAAAh7dnzx6bp8tJUkpKik6dOiV/f/9Sz1ejRg21atVK+/btK7JT6ccff9Tly5fVpk0ba1u7du2UmppqfRLdb2s4duyYWrduXeoaKpLDBU2xsbGSpLCwMGubyWTShAkTZDKZtHLlyj+83tfXt8jupxEjRmjAgAHWeyUBAAAAAABSU1P13nvvWb/Ozc3Va6+9JovFYn3iXGn1799fOTk5io6Otpl3wYIFkqQ///nPNmMlKTIy0hp4WSwWzZ8/XxaLRcHBwddVQ0VxuMPAExMT5eXlpaZNm9q0e3t7q3HjxkpISCj22oMHD+rkyZMKDQ2Vi4uLTd9tt92mOXPmlEnNAAAAAACgcqpdu7aioqL03Xff6c4779T27duVlJSkRx55RL17976uOYOCgrRq1SotXrxYBw4c0D333KNvvvlG+/fv14gRI2Q2m61jO3furMDAQMXHxys4OFgdO3bUrl27lJiYqICAAPXo0cOgd1o+HGpHU05Ojk6fPq1GjRrZ7ff19dWFCxeUlpZmt//AgQOSpLvuuktbt25VSEiIWrVqpa5du2rOnDnKysoqs9oBAAAAAEDl06hRI7333ntKTU3VP//5T+Xl5enFF1/U3Llzr3tOZ2dnvffeexo2bJgOHTqkpUuXKj8/X9OnT9fkyZOLjH/99dc1btw4nT9/XkuWLNHZs2c1btw4zZs3TyaT6UbeXrlzqB1N6enpkoo/Tb2wPSMjQ15eXkX6z5w5I0navHmztmzZom7duikkJEQ7duzQBx98oB9//FFLliwpstsJAAAAAIBq65ULFV1Bmfvwww+v2d+pUyf961//KtWcc+bMueadUx4eHpo6daqmTp36h3O5uLgoLCzM5hihysqhgqa8vDxJV09dt6ewvbgT4S9fvizpatA0c+ZMDRw4UNLVU90nTJigDRs2aMWKFRo6dKjRpQMAAAAAAFR7DnXrXM2aNSVdPSDLnpycHElSrVq17PY7OV19O82bN7eGTNLVLWsvvPCCJPHUOQAAAAAAgDLiUEGTh4eHnJycijz+r1BGRoak4m+t8/DwkCTdfffdRfp8fX1Vt25dnThxwqBqAQAAAAAA8FsOdeucq6urfHx8lJycbLc/OTlZ9evXl6enp93+xo0bS/r1Frzfy8vLU926dY0oFQAAAAAAVHJJSUkVXUKV41A7miSpXbt2Sk1N1ZEjR2zaU1JSdOzYMbVu3brYa/39/eXq6qqEhATl5+fb9B06dEhZWVlq1qxZWZQNAAAAAABQ7Tlc0NS/f39JUmRkpAoKCiRJFotF8+fPl8ViUXBwcLHX1qlTRw899JBOnTqld99919qem5trfSxhUFBQ2RUPAAAAAABQjTnUrXOS1LlzZwUGBio+Pl7BwcHq2LGjdu3apcTERAUEBKhHjx7WsdHR0ZKksWPHWtumTJmi77//XpGRkUpISJCfn5+2bdumn376SYGBgerVq1d5vyUAAAAAAIBqweGCJkl6/fXX1bRpU61Zs0ZLliyRj4+Pxo0bp1GjRslkMlnHxcTESLINmm666SbFxcVp4cKF+vLLL7Vjxw75+vpq8uTJGj58eLm/FwAAAAAAgOrCIYMmFxcXhYWFKSws7Jrjiju0q379+nrppZf00ksvlUV5AAAAAAAAsMPhzmgCAAAAAABA5UTQBAAAAAAAAEMQNAEAAAAAAMAQBE0AAAAAAAAwhEMeBg4AAAAAAOBo9uzZo7feekv//e9/denSJd1yyy3q27evnn32Wbm7u9uMnTRpkj755BO784waNUqTJk2yfp2Xl6dly5bpo48+UnJysho2bKigoCCNHj1aLi4uZfqejEbQBAAAAABANdZyScuKLuGadj+1u6JLkCRt375dI0eOlCQFBATo5ptvVkJCgt59911t375dsbGxcnNzs45PSkpSgwYNFBISUmSudu3a2XwdERGhuLg4tWvXTj179tTOnTsVFRWlpKQkRUVFle0bMxhBEwAAAAAAwB+IiIiQxWLRihUr5O/vL0myWCyaPn26PvroIy1fvlzDhw+XJOXm5urIkSPq0aOHxo4de815d+7cqbi4OAUGBioyMtI6b3h4uNauXastW7aoR48eZfrejMQZTQAAAAAAANdw+PBhHTp0SL169bKGTJJkMpkUFhYmSfr666+t7YcOHVJubq78/Pz+cO7Y2FhJss5TOO+ECRNkMpm0cuVKo95GuSBoAgAAAAAAVVpoaKh69uypTZs2qXv37mrVqpXGjx8vs9msSZMmadu2bQoKCpK/v7969uypyMhIZWdnW6+vXbu2Jk+erMcff7zI3K6urpKkrKwsa1tSUpIk6a677vrD2hITE+Xl5aWmTZvatHt7e6tx48ZKSEi4rvdcUQiaAAAAAABAlXf+/HlNnDhRHTp00IABA9S+fXtJV0OhUaNGqXbt2ho8eLDq1aunRYsWafTo0SooKJB0NfQZOXKkunfvXmTejRs3SpJNUFQYNB09elQhISFq06aN7rvvPoWHhyslJcU6LicnR6dPn1ajRo3s1uzr66sLFy4oLS3NmG9COeCMJgAAAAAAUOVlZWVp+PDhCg8Pt7a9+uqrOnDggAYPHqzp06dLuvoEuAkTJujzzz/X2rVrFRQUVOyc586d04IFCyRJAwcOtLYXBk2LFi3Sgw8+qDZt2uiHH37QmjVr9O9//1sfffSRfHx8lJ6eLkmqU6eO3fkL2zMyMuTl5XX9b74csaMJAAAAAABUC3369CnS5u7urvHjx1u/rlGjhl544QWZTCZ98sknxc6VkZGh0aNHKzU1VYMHD1arVq2sfTVr1lTjxo318ccfa968eZoyZYqWL1+u5557TqmpqXr11VclXQ21pF9vv/u9wvbf3sbn6NjRBAAAAAAAqoXbbrutSJvZbFa9evWKjPPy8tL+/fvtzpOWlqaRI0dq79696tatm6ZOnWrTv3DhQrvXPf300/r444+1detWXbp0STVr1pR09Sl19uTk5EiSatWqde035kDY0QQAAAAAAKqFwmDnt7y9ve2ObdCggTIyMoq0nzhxQoMGDdLevXv1wAMPKCYmRi4uLiV6fScnJzVr1kx5eXk6ffq0PDw85OTkpMzMTLvjC1+/uFvrHBFBEwAAAAAAqLaKuy0tMzNTnp6eNm379+9XSEiIjh49qv79+ysmJkZubm42Yy5fvqzvv/++2N1QV65ckSS5ubnJ1dVVPj4+Sk5Otjs2OTlZ9evXL1KHIyNoAgAAAAAA1daePXusT5crlJKSolOnTsnf39/aduzYMY0YMUJnz57V8OHDNWfOHNWoUfREorNnzyo4OFiTJ08u0nf58mXt27dPXl5e8vX1lSS1a9dOqampOnLkSJEajh07ptatWxvwLssPQRMAAIADysvL0+LFixUYGCh/f3/16tVLCxcuLPYMh9/Lzs5WTEyMAgIC1LJlS/Xu3VuvvfaaLl68WMaVAwBQuaSmpuq9996zfp2bm6vXXntNFovF+sS5goICTZw4UefOndPQoUMVHh4uk8lkd75GjRqpRYsWOnDggP71r39Z2y0Wi9544w2lpaVp0KBB1uv79+8vSYqMjLQGXhaLRfPnz5fFYlFwcHBZvO0yw2HgAAAADigiIkJxcXFq166devbsqZ07dyoqKkpJSUmKioq65rW5ubkaOXKkduzYofbt26tXr17avXu3lixZou+//17Lli0r9uk2AGBPyyUt7bZbcizWP3eI7SCTq/3/8N791O4yqQswQu3atRUVFaXvvvtOd955p7Zv366kpCQ98sgj6t27tyTpq6++0u7du+Xq6ip3d3dFR0cXmadBgwYaNGiQJGnGjBkKDQ3VCy+8oC+++EK+vr5KTEzUnj17dO+99+qZZ56xXte5c2cFBgYqPj5ewcHB6tixo3bt2qXExEQFBASoR48e5fJ9MApBEwAAgIPZuXOn4uLiFBgYqMjISElXP9kMDw/X2rVrtWXLlmsuOpcuXaodO3Zo+PDhCg8Pt7ZHREQoNjZW8fHx1k9PAQCo7ho1aqSpU6fqtddeU0JCgm677Ta9+OKLCg0NtY5JSEiQdPUpcIsWLbI7T7NmzaxBU4sWLfTxxx8rKipK27dv15YtW+Tr66tx48Zp1KhRRT7wef3119W0aVOtWbNGS5YskY+Pj3VscTunHBVBEwAAgIOJjY2VJIWFhVnbTCaTJkyYoHXr1mnlypXXDJpiY2Pl6+uriRMn2rSPGDFCWVlZRQ4tBQBUb9Vhx9mHH354zf5OnTrZ3Ob2e9OmTdO0adNK9Zp33nmnFixYUKKxLi4uCgsLs/m3v7IiaAIAAHAwiYmJ8vLyUtOmTW3avb291bhxY+unqvYcPHhQJ0+eVGhoaJFHLd92222aM2dOmdQMAAAgcRg4AACAQ8nJydHp06fVqFEju/2+vr66cOGC0tLS7PYfOHBAknTXXXdp69atCgkJUatWrdS1a1fNmTNHWVlZZVY7AAAAQRMAAIADSU9PlyTVqVPHbn9he0ZGht3+M2fOSJI2b96sp59+WnXr1lVISIgaNmyoDz74QCNHjizxk+sAAABKi1vnAAAAHEheXp4kFftUuML27Oxsu/2XL1+WdDVomjlzpgYOHChJys/P14QJE7RhwwatWLFCQ4cONbp0AAAqnaSkpIouocohaAIAAHAgNWvWlKRidx3l5ORIkmrVqmW338np6ob15s2bW0MmSXJ2dtYLL7ygDRs2KD4+nqAJqE5eqWe/Pc8kyfvqn1/zkWpYip+jye2GlwWgaiJoAuCwGod/VnaT52Wr8JlLd0/fINUo2ycwHZ3zcJnOD6Dq8PDwkJOTkzIzM+32F94yV9ytdR4eHpKku+++u0ifr6+v6tatqxMnThhULQAAgC3OaAIAAHAgrq6u8vHxUXJyst3+5ORk1a9fX56ennb7GzduLOnXW/B+Ly8vz7prCgAAwGgETQAAAA6mXbt2Sk1N1ZEjR2zaU1JSdOzYMbVu3brYa/39/eXq6qqEhATl5+fb9B06dEhZWVlq1qxZWZQNAABA0AQAAOBo+vfvL0mKjIxUQUGBJMlisWj+/PmyWCwKDg4u9to6derooYce0qlTp/Tuu+9a23NzczV37lxJUlBQUNkVDwAAqjXOaAIAAHAwnTt3VmBgoOLj4xUcHKyOHTtq165dSkxMVEBAgHr06GEdGx0dLUkaO3astW3KlCn6/vvvFRkZqYSEBPn5+Wnbtm366aefFBgYqF69epX3WwIAANUEQRMAAIADev3119W0aVOtWbNGS5YskY+Pj8aNG6dRo0bJZDJZx8XExEiyDZpuuukmxcXFaeHChfryyy+1Y8cO+fr6avLkyRo+fHi5vxcAAFB9EDQBAAA4IBcXF4WFhSksLOya45KSkuy2169fXy+99JJeeumlsigPAADALs5oAgAAAAAAgCEImgAAAAAAAGAIgiYAAAAAAAAYgqAJAAAAAAAAhiBoAgAAAAAAgCEImgAAAAAAAGAIgiYAAAAAAAAYokZFFwAAAAAAsK9x+Gf2O/Ky5fa/P949fYNUw83+OElHaxpfFwAUhx1NAAAAAAAAMARBEwAAAAAAAAxB0AQAAAAAAABDEDQBAAAAAADAEARNAAAAAAAAMARBEwAAAAAAAAxB0AQAAAAAAABDEDQBAAAAAADAEARNAAAAAAAAMARBEwAAAAAAAAxB0AQAAAAAAABDEDQBAAAAAADAEARNAAAAAAAAMARBEwAAAAAAAAxB0AQAAAAAAABDEDQBAAAAAADAEARNAAAAAAAAMARBEwAAAAAAAAxB0AQAAAAAAABDEDQBAAAAAADAEARNAAAAAAAAMARBEwAAAAAAAAxB0AQAAAAAAABDOGTQlJeXp8WLFyswMFD+/v7q1auXFi5cqNzc3FLPVVBQoIEDB8psNpdBpQAAAAAAACjkkEFTRESEZs+eLU9PTw0dOlTe3t6KiorSxIkTSz3X4sWL9cMPP5RBlQAAAAAAAPitGhVdwO/t3LlTcXFxCgwMVGRkpCTJYrEoPDxca9eu1ZYtW9SjR48SzXX8+HEtWLCgDKsFAAAAAABAIYfb0RQbGytJCgsLs7aZTCZNmDBBJpNJK1euLNE8FotF06ZNU4MGDXTnnXeWSa0AAAAAAAD4lcMFTYmJifLy8lLTpk1t2r29vdW4cWMlJCSUaJ4VK1Zox44dmjlzpmrWrFkWpQIAAAAAAOA3HCpoysnJ0enTp9WoUSO7/b6+vrpw4YLS0tKuOc8vv/yiefPmKSgoSJ07dy6LUgEAAAAAAPA7DhU0paenS5Lq1Kljt7+wPSMj45rzTJ8+XbVq1VJ4eLih9QEAAAAAAKB4DnUYeF5eniTJ1dXVbn9he3Z2drFzrF27Vl9//bUWLFigevXqGV8kAAAAAAAA7HKoHU2FZynl5uba7c/JyZEk1apVy27/2bNnNXv2bPXu3Vt9+/YtmyIBAAAAAABgl0MFTR4eHnJyclJmZqbd/sJb5oq7tS4iIkL5+fmaPn16mdUIAAAAAAAA+xzq1jlXV1f5+PgoOTnZbn9ycrLq168vT09Pu/2ff/65JKlbt252+81ms3x9fbVp0yZD6gUAAAAAAMCvHCpokqR27dpp3bp1OnLkiJo0aWJtT0lJ0bFjx9SjR49irx0zZozd9ri4OKWmpmrMmDHF7oYCAAAAAADAjXG4oKl///5at26dIiMj9eabb8rJyUkWi0Xz58+XxWJRcHBwsdeOHTvWbvvmzZuVmppabD8AAAAAAABunMMFTZ07d1ZgYKDi4+MVHBysjh07ateuXUpMTFRAQIDNjqbo6GhJxQdMAAAAAAAAKD8OFzRJ0uuvv66mTZtqzZo1WrJkiXx8fDRu3DiNGjVKJpPJOi4mJkYSQRMAAAAAAIAjcMigycXFRWFhYQoLC7vmuKSkpBLNt3r1aiPKAgAAAAAAwDU4VXQBAAAAAAAAqBoImgAAAAAAAGAIgiYAAAAAAAAYgqAJAAAUKysrS2azWWazWVlZWRVdDgAAABwcQRMAAAAAAAAMUeKnzo0ZM+a6XsBkMik6Ovq6rgUAAHAk5bkeysvL07Jly/TRRx8pOTlZDRs2VFBQkEaPHi0XF5dSzVVQUKCQkBD98MMPJX5qLwAAwPUocdB0+vRp7dmzRyaTSRaLpcQvYDKZrqswAAAAR1Oe66GIiAjFxcWpXbt26tmzp3bu3KmoqCglJSUpKiqqVHMtXrxYP/zwQ6lrAAAAKK0SB00rV67UzJkztXz5cnXt2lUzZswoy7oAAAAcTnmth3bu3Km4uDgFBgYqMjJSkmSxWBQeHq61a9dqy5Yt6tGjR4nmOn78uBYsWFAmdQIAAPxeiYMmk8mk6dOnKzMzU5988ol27NihAQMGlGVtAAAADqW81kOxsbGSpLCwMJvXnjBhgtatW6eVK1eWKGiyWCyaNm2aGjRoIDc3Nx06dMjwWgEAAH6r1IeBz5w5U76+vpo7d64uXbpUFjUBAAA4tLJeDyUmJsrLy0tNmza1aff29lbjxo2VkJBQonlWrFihHTt2aObMmapZs6bhdQIAAPxeqYMmNzc3zZw5U927d+cwSQAAUC2V5XooJydHp0+fVqNGjez2+/r66sKFC0pLS7vmPL/88ovmzZunoKAgde7c2dAaAQAAilPiW+d+67777tN9991ndC0AAACVRlmth9LT0yVJderUsdtf2J6RkSEvL69i55k+fbpq1aql8PBww2sEgEImV5NcX3St6DIAOJBS72i6lpycHB07doxb6gAAQLV1o+uhvLw8SZKrq/3/cCtsz87OLnaOtWvX6uuvv9bLL7+sevXqXVcdAAAA16PUQdPmzZs1depU7d+/36b9zTffVMeOHdW3b1916NBBEyZMsH4iBwAAUJWU5Xqo8Cyl3Nxcu/05OTmSpFq1atntP3v2rGbPnq3evXurb9++pXptAACAG1WqW+deeeUVxcXFSZJ69OihZs2aSZIiIyP19ttvy8nJSV26dJHFYtGGDRv0888/a9WqVcV+IgcAAFDZlPV6yMPDQ05OTsrMzLTbn5GRIan4W+siIiKUn5+v6dOnl/atAQAA3LASB02bNm3SP//5T919992aOHGi2rdvL0lKSUnRP/7xD5lMJr366qsKCgqSJG3cuFFhYWFaunSpRo4cWTbVAwAAlKPyWA+5urrKx8dHycnJdvuTk5NVv359eXp62u3//PPPJUndunWz2282m+Xr66tNmzaVqB4AAIDSKHHQ9PHHH8vT01NLly6Vh4eHtX3Dhg3Ky8vTn/70J+uiSpJ69eqltm3basOGDQRNAACgSiiv9VC7du20bt06HTlyRE2aNLG2p6Sk6NixY+rRo0ex144ZM8Zue1xcnFJTUzVmzJhid0MBAADcqBIHTT/++KN69Ohhs6iSpG+//VYmk0k9e/Ysck2rVq308ccf33iVAAAADqC81kP9+/fXunXrFBkZqTfffFNOTk6yWCyaP3++LBaLgoODi7127Nixdts3b96s1NTUYvsBVD/uNSxKGnS6ossAUMWUOGi6cOGCbr75Zpu2goIC/fe//5Uku4/3rVGjRrEHWQIAAFQ25bUe6ty5swIDAxUfH6/g4GB17NhRu3btUmJiogICAmx2NEVHR0sqPmACAAAoTyUOmurUqaPz58/btO3Zs0eZmZlycXGxnlHwW0ePHlX9+vVvvEoAAAAHUJ7roddff11NmzbVmjVrtGTJEvn4+GjcuHEaNWqUTCaTdVxMTIwkgiYAAOAYShw0tWzZUt9++63y8/Pl7OwsSfr0008lSR06dJC7u7vN+NTUVP373//W/fffb2C5AAAAFac810MuLi4KCwtTWFjYNcclJSWVaL7Vq1eXugYAAIDScirpwIEDB+rkyZN6/vnnlZCQoOXLl+uf//ynTCaThgwZYjM2LS1Nzz33nK5cuaJ+/foZXjQAAEBFYD0EAABwbSXe0dSrVy8NHjxYsbGx+vLLLyVJFotFTz75pB544AHruGeeeUbbtm1Tdna2+vbtq969extfNQAAQAVgPQQAAHBtJQ6aJOnll19WQECANm/erLy8PHXp0qXI43UPHz6s2rVra/To0frrX/9qZK0AAAAVjvUQAABA8UoVNElXzx/o0KFDsf2rV68u8shfAACAqoT1EAAAgH0lPqOppFhUAQCA6o71EAAAqK4MD5oAAAAAAABQPRE0AQAAAAAAwBClPqMJAKqEGm7KHjC/oqsAAAAAgCqFHU0AAAAAAAAwBEETAAAAAAAADEHQBAAAAAAAqqSsrCyZzWaZzWZlZWVVdDnVAkETAAAAAAAADEHQBAAAAAAAAEMQNAEAAAAAAMAQBE0AAAAAAAAwBEETAAAAAAAADEHQBAAAAAAAAEMQNAEAAAAAAMAQBE0AAAAAAAAwRI2KLgAAAAAAUEo13JQ9YH5FVwEARbCjCQAAAAAAAIYgaAIAAAAAAIAhCJoAAAAAAABgCIImAAAAAAAAGIKgCQAAAAAAAIYgaAIAAAAAAIAhCJoAAAAAAABgCIImAAAAAAAAGIKgCQAAAAAAAIYgaAIAAAAAAIAhCJoAAAAAAABgCIImAAAAAACAYmRlZclsNstsNisrK6uiy3F4BE0AAAAAAAAwBEETAAAAAAAADEHQBAAAAAAAAEMQNAEAAAAAAMAQBE0AAAAAAAAwBEETAAAAAAAADEHQBAAAAAAAAEMQNAEAAAAAAMAQBE0AAAAAAAAwhEMGTXl5eVq8eLECAwPl7++vXr16aeHChcrNzS3R9Xv27NGzzz6rjh07qkWLFurdu7fmzZunrKysMq4cAAAAAACg+nLIoCkiIkKzZ8+Wp6enhg4dKm9vb0VFRWnixIl/eO327dsVEhKir7/+Wl27dlVoaKg8PT317rvvaujQocrOzi6HdwAAAAAAAFD91KjoAn5v586diouLU2BgoCIjIyVJFotF4eHhWrt2rbZs2aIePXoUe31ERIQsFotWrFghf39/6/XTp0/XRx99pOXLl2v48OHl8VYAAAAAAACqFYcLmmJjYyVJYWFh1jaTyaQJEyZo3bp1WrlyZbFB0+HDh3Xo0CEFBARYQ6bC68PCwvTRRx/p66+/JmgCAFQpjcM/K7vJ87Ll9r8/3j19g1TD7ZrDb9TROQ+X6fwAAAAoWw4XNCUmJsrLy0tNmza1aff29lbjxo2VkJBQ7LW1a9fW5MmTdddddxXpc3V1lSTOaQIAAAAAACgjDhU05eTk6PTp02rVqpXdfl9fXx05ckRpaWny8vIq0u/t7a2RI0favXbjxo2SVCTAAgAAAAAAgDEc6jDw9PR0SVKdOnXs9he2Z2RklGrec+fOacGCBZKkgQMHXn+BAAAAAAAAKJZDBU15eXmSfr3N7fcK20vz5LiMjAyNHj1aqampGjx4cLG7pQAAAAAAAHBjHCpoqlmzpiQpNzfXbn9OTo4kqVatWiWaLy0tTU899ZT27Nmjbt26aerUqcYUCgAAAAAAgCIcKmjy8PCQk5OTMjMz7fYX3jJX3K11v3XixAkNGjRIe/fu1QMPPKCYmBi5uLgYWi8AAAAAAAB+5VBBk6urq3x8fJScnGy3Pzk5WfXr15enp+c159m/f79CQkJ09OhR9e/fXzExMXJzK9vHMQMAAAAAAFR3DhU0SVK7du2UmpqqI0eO2LSnpKTo2LFjat269TWvP3bsmEaMGKGzZ89q+PDhmjNnjmrUcKiH6wEAAPyhvLw8LV68WIGBgfL391evXr20cOHCYo8Y+L09e/bo2WefVceOHdWiRQv17t1b8+bNU1ZWVhlXDgAAqjOHC5r69+8vSYqMjFRBQYEkyWKxaP78+bJYLAoODi722oKCAk2cOFHnzp3T0KFDFR4eLpPJVB5lAwAAGCoiIkKzZ8+Wp6enhg4dKm9vb0VFRWnixIl/eO327dsVEhKir7/+Wl27dlVoaKg8PT317rvvaujQoaV6sAoAAEBpONxWn86dOyswMFDx8fEKDg5Wx44dtWvXLiUmJiogIEA9evSwjo2OjpYkjR07VpL01Vdfaffu3XJ1dZW7u7u1/7caNGigQYMGlct7AQAAuB47d+5UXFycAgMDFRkZKenqB2/h4eFau3attmzZYrMm+r2IiAhZLBatWLFC/v7+1uunT5+ujz76SMuXL9fw4cPL460AAIBqxuGCJkl6/fXX1bRpU61Zs0ZLliyRj4+Pxo0bp1GjRtnsUIqJiZH0a9CUkJAg6erT6RYtWmR37mbNmhE0AQAAhxYbGytJCgsLs7aZTCZNmDBB69at08qVK4sNmg4fPqxDhw4pICDAGjIVXh8WFqaPPvpIX3/9NUETAAAoEw4ZNLm4uCgsLMxmcWVPUlKSzdfTpk3TtGnTyrI0AACAMpeYmCgvLy81bdrUpt3b21uNGze2frhmT+3atTV58mTdddddRfpcXV0liXOaAAAoZ1lZWWrTpo0kadeuXXJ3d6/gisqOQwZNAAAA1VVOTo5Onz6tVq1a2e339fXVkSNHlJaWJi8vryL93t7eGjlypN1rN27cKElFAiwAAACjONxh4AAAANVZenq6JKlOnTp2+wvbMzIySjXvuXPntGDBAknSwIEDr79AAACAayBoAgAAcCB5eXmSfr3N7fcK20vz5LiMjAyNHj1aqampGjx4cLG7pQAAAG4UQRMAAIADqVmzpiQpNzfXbn9OTo4kqVatWiWaLy0tTU899ZT27Nmjbt26aerUqcYUCgAAYAdBEwAAgAPx8PCQk5OTMjMz7fYX3jJX3K11v3XixAkNGjRIe/fu1QMPPKCYmBi5uLgYWi8AAMBvETQBAAA4EFdXV/n4+Cg5Odluf3JysurXry9PT89rzrN//36FhITo6NGj6t+/v2JiYuTm5lYGFQMAAPyKp84B5aA6PcoSAHDj2rVrp3Xr1unIkSNq0qSJtT0lJUXHjh1Tjx49rnn9sWPHNGLECJ07d07Dhw/XlClTZDKZyrhqAAAqTuPwz+x35GWr8GOWu6dvkGoU/6HL0TkPG19YNcSOJgAAAAfTv39/SVJkZKQKCgokSRaLRfPnz5fFYlFwcHCx1xYUFGjixIk6d+6chg4dqvDwcEImAABQbtjRBAAA4GA6d+6swMBAxcfHKzg4WB07dtSuXbuUmJiogIAAmx1N0dHRkqSxY8dKkr766ivt3r1brq6ucnd3t/b/VoMGDTRo0KByeS8AAKB6IWgCAABwQK+//rqaNm2qNWvWaMmSJfLx8dG4ceM0atQomx1KMTExkn4NmhISEiRdfTrdokWL7M7drFkzgiYAAFAmCJoAAAAckIuLi8LCwhQWFnbNcUlJSTZfT5s2TdOmTSvL0gAAAIrFGU0AAAAAHF5WVpbMZrPMZrOysrIquhwAQDEImgAAAAAAAGAIgiYAAAAAAAAYgqAJAAAAAAAAhiBoAgAAAAAAgCEImgAAAACUOQ7zBoDqgaAJAAAAwDUREgEASoqgCQAAAAAAAIYgaAIAAAAAAIAhCJoAAAAAAABgCIImAAAAAAAAGIKgCQAAAAAAAIYgaAIAAAAAAIAhalR0AQAAAAAAABXulXr22/NMkryv/vk1H6mG5RpzXDC8rMqGHU0AAAAAAAAwBEETAAAAAAAADEHQBAAAAAAAAEMQNAEAAAAAAMAQBE0AAAAAAAAwBEETAAAAAAAADEHQBAAAAAAAAEMQNAEAAAAAAMAQBE0AAAAAAAAwBEETAAAAAAAADEHQBAAAAAAAAEMQNAEAAAAAAMAQBE0AAAAAAAAwRI2KLgAAAAAACrVc0tJuuyXHYv1zh9gOMrmaip1j91O7Da8LAEqC32HsaAIAAAAAAIBBCJoAAAAAAABgCG6dAwAAAGCMV+oV35dnkuR99c+v+Ug1LPbHNbnd8LIAAOWHoAmQ1Dj8s7J9gbxsuf3vj3dP3yDVcLvm8BtxdM7DZTY3AAAAAADXwq1zAAAAAAAAMARBEwAAAAAAAAzBrXMAAAAArn2UQAmPATha0/i6AACVCzuaAAAAAAAAYAiCJgAAAAAAABiCW+cAAEDxargpe8D8iq4CAAAAlQQ7mgAAAAAAAGAIgiYAAAAAAAAYgqAJAAAAAAAAhiBoAgA4jKysLJnNZpnNZmVlZVV0OQAAAABKiaAJAAAAAAAAhiBoAgAAAAAAgCEImgAAAAAAAGAIgiYAAAAAAAzAeZMAQRMAAAAAAAAMUqOiCwAAAAAcTVZWltq0aSNJ2rVrl9zd3Su4IgDAdanhpuwB8yu6imqFHU1VDFs1AQBAZWbEWob1EIDKjN+DqOwImgAAAAAAAGAIgiYAAAAAAAAYgqAJAAAAAAAAhnDIoCkvL0+LFy9WYGCg/P391atXLy1cuFC5ubkluj49PV0RERHq2bOnWrVqpaCgIMXHx5dx1QAAAMZhPQQAACojhwyaIiIiNHv2bHl6emro0KHy9vZWVFSUJk6c+IfXZmVlacSIEVqxYoVatWqlwYMH6+LFi3r++ee1bNmycqgeAADgxrEeAgAAlVGNii7g93bu3Km4uDgFBgYqMjJSkmSxWBQeHq61a9dqy5Yt6tGjR7HXL126VHv37tUrr7yiQYMGSZKeffZZhYSEaN68eXrooYd00003lcdbAQAAuC6shwDAcTUO/6z4zrxsuf3vj3dP3yDVcLM77Oich40vDHAQDhc0xcbGSpLCwsKsbSaTSRMmTNC6deu0cuXKay6sli9froYNG2rgwIHWNg8PDz3zzDOaOHGiPv30Uz311FNlVj8AVGXXXFgZoYSLMyOwwIMjYz0EFGVyNcn1RdeKLgMwxiv1iu/LM0nyvvrn13ykGpZi5rhgeFmAERwuaEpMTJSXl5eaNm1q0+7t7a3GjRsrISGh2GuPHz+ulJQUBQQEyNnZ2aavY8eOkqSEhAQWVgAAwKGxHkJV5F7DoqRBpyu6DKDKaLmkZbF9lpxfw6kOsR1kcjXZHbf7qd2G1wU41BlNOTk5On36tBo1amS339fXVxcuXFBaWprd/uPHj0uSbr/99iJ9DRs2lJubm44cOWJcwQAAAAZjPQQAACozhwqa0tPTJUl16tSx21/YnpGRcc3r69ata7ffw8Oj2GsBAAAcAeshAABQmTnUrXN5eXmSJFdX+/deF7ZnZ2df9/WXL1++0TJvWJmeccL5JgAAVGrVZT0Ex3OttV1WVpbafDJVkrQvoq/c3d2LGXnjZ8ZwI48tY9bc/FyMVOZ/V7KypJVtrv75xVNSMXNc62eSlZWlNvOuzrFj8I5r1FF1lOnflRL+TKTify7V6WfiUEFTzZo1JUm5ubl2+3NyciRJtWrVstvv5uZmM87e9Y7wwyzLgKbkv9jwW2UdmvFzuT6EmY6HvyuOib8rVUt1WQ8BAICqyaGCJg8PDzk5OSkzM9Nuf+E27+K2kterd/Xk/uKuz8zM5FG+AADAobEegiNyd3dXUlJSRZcBAKgEHOqMJldXV/n4+Cg5Odluf3JysurXry9PT0+7/Y0bN7aO+70zZ84oOztbTZo0MapcAAAAw7EeAgAAlZlDBU2S1K5dO6WmphZ5GkpKSoqOHTum1q1bF3utj4+PfHx89N///lcFBQU2fTt27JAktWnTxvCaAQAAjMR6CACqr8IdhElJSdzq7CD4mZSOwwVN/fv3lyRFRkZaF0cWi0Xz58+XxWJRcHDwNa/v16+fTp8+rWXLllnbMjMztWjRItWsWVOPPfZYmdUOAABgBNZDAFA5OUog4Sh1oHpyqDOaJKlz584KDAxUfHy8goOD1bFjR+3atUuJiYkKCAhQjx49rGOjo6MlSWPHjrW2jRo1Shs2bNCsWbOUkJCgRo0a6YsvvtCJEyf08ssvy8vLq7zfEgAAQKmwHgIAoGqpTmfdOdyOJkl6/fXXNW7cOJ0/f15LlizR2bNnNW7cOM2bN08mk8k6LiYmRjExMTbXenh4KDY2Vo8//rgSExO1fPly1a1bV/Pnz9eQIUPK+60AAABcF9ZDAACgMnK4HU2S5OLiorCwMIWFhV1zXHFpYIMGDfTaa6+VRWnAdalO6TUAwBishwAAQGXkkEETAKB6IpQFAAAAKjeCJgAAADgMAmcAACo3giYAAABUKYRVAABUHIKmKoaFFQAAwI1jTQUAwPVxyKfOAQAAAAAAoPIhaAIAAAAAAIAhCJoAAAAAAABgCIImAAAAAAAAGIKgCQAAAAAAAIYgaAIAAAAAAIAhCJoAAAAAAABgCIImAAAAAAAAGIKgCQAAAAAAAIYgaAIAAAAAAIAhCJoAAAAAAABgCIImAAAAAAAAGKJGRRfgKM6cOaP8/Hz16tWroksBAABl5JdffpGzs3NFl+GwWA8BAFD1lfV6iB1N/+Pm5qYaNcjdAACoymrUqCE3N7eKLsNhsR4CAKDqK+v1kMlisVjKbHYAAAAAAABUG+xoAgAAAAAAgCEImgAAAAAAAGAIgiYAAAAAAAAYgqAJKEMpKSl666239MQTT6hz585q2bKlevTooYkTJ2rHjh0VXV61Ex0dLbPZrK+++srQeb/77juZzWbNmjXLpn316tXq06ePWrRooc6dO+vo0aOGvm511LNnT7Vv376iy6g2wsPDZTab9dNPP1V0KQAqMdZDjoX1UOXHeqj8sBa6PjxWBCgj69ev14svvqisrCy1atVKgYGBqlWrlo4dO6ZNmzbp008/1dChQzVt2rSKLhVl4NChQ5o2bZrc3d01aNAgOTs7y8fHp6LLqvSGDh2qnJycii4DAFBCrIeqN9ZDZYP1EBwdQRNQBv7zn//oueee00033aR33nlH9957r03/mTNnNG7cOC1dulQtWrTQY489VkGVoqz89NNPKigo0JAhQ/T8889XdDlVxrBhwyq6BABACbEeAuuhssF6CI6OW+cAg+Xk5Oill16Sk5OT/v73vxdZVEnSzTffrMjISLm6uuq9996rgCpR1go/Zapfv34FVwIAQPljPQSJ9RBQXRE0lbPExEQ1a9ZMPXr00KVLl6ztOTk5CgwMVPPmzZWYmFjqeXNycvT2228rMDBQLVu21H333aeJEyfqxIkT1jHnz59Xly5ddPfdd2vv3r0210+dOlVms1mLFi2SdPVearPZrG+++UYLFizQ/fffrzZt2ig4OFibN2++zndfPXz99dc6deqUevbsqVatWhU77tZbb9Vf/vIXPfzww8rPzy/HCiuHmTNnymw269///neRvu+//15ms1kzZsy4rrmzs7MVGRmpBx54QC1btlTfvn314YcfymKx2Iy7dOmSYmJi9Nhjj6lNmzZq2bKl+vTpo7/97W82f39/r2fPnpo6daokafbs2TKbzYqOjr6uWiuDkv6swsPDdffddystLU3h4eHq2LGj2rRpo7/85S86fvy4cnJyNHfuXHXt2lVt27ZVaGio9u/fbzPf788kKPxdtW3bNv3jH/9Qnz591LJlS/Xu3VtvvfUWf7fKwP79+3XvvfeqQ4cOnFeA68JaqHpgPWQM1kOVB+uh6oO10B8jaCpn7du315AhQ/TLL7/Y/KJdsGCBDh06pBEjRpT6YLfc3FyNGjVK8+fPV506dTRkyBB169ZNX375pZ544gkdOHBA0tVPEv7v//5P+fn5+r//+z8VFBRIkrZu3arVq1erTZs2GjVqlM3ckZGR+sc//qFu3brp0Ucf1dGjR/XXv/5Vq1atusHvRNVVeLBiz549/3Dsc889p2eeeUbOzs5lXVal069fP0lSfHx8kb7PPvtMkvToo49e19yzZs1SXFycunfvrieeeELnzp3Tq6++qiVLlljH5OXlafjw4YqJiVHDhg315JNP6vHHH9eVK1f0/vvva8qUKcXOP3ToUPXq1UuS1LVrV40ZM0YdOnS4rlorg9L8rCwWi5566int3r1bQUFBatu2rf7973/r6aef1rhx47R+/Xr17dtX999/v3bs2KHRo0fr8uXLf1jD3LlzFRMTo3bt2unJJ5/UlStXtGDBAr3zzjsGvlMcO3ZMf/nLX1RQUKD33ntPzZs3r+iSUAmxFqoeWA8Zg/VQ5cF6qHpgLVRCFpS7rKwsS69evSx333235aeffrJ8//33lubNm1seeeQRS3Z2dqnne/fddy1+fn6WN954w6Z9z549lnvuucfyxBNP2LQ/99xzFj8/P8uyZcssFy9etNx///2W1q1bW44ePWods2rVKoufn5+lefPmll27dlnbjx8/bunQoYOlffv2lgsXLpS61upg0KBBFj8/P8sPP/xQ0aVUen369LHce++9lpycHGtbfn6+pWvXrpaePXuWer6oqCiLn5+fpVu3bpYzZ85Y2/fs2WMxm82WRx55xNr26aefWvz8/Czz58+3mSMjI8PSpUsXS/PmzS1ZWVkWi8Vi2b59u8XPz8/y6quvWscV/h364IMPSl1nZVSSn9WUKVMsfn5+lj//+c82v+uCg4Mtfn5+lp49e1oyMjKs7YXjt2zZYm174IEHLO3atbN+Xfh9bteunc3vsBMnTljuueceS/fu3cvi7VYbhT+Dffv2WU6fPm154IEHLK1bt7YkJiZWdGmo5FgLVX2sh4zDeqjyYD1U9bAWuj7saKoAtWrV0qxZs5Sfn6+ZM2fqxRdflJOTk+bOnStXV9dSz/fxxx+rbt26GjdunE37Pffco759++rHH3/Uzz//bG1/+eWX5eXlpaioKL388stKSUnRlClT9Kc//anI3IGBgWrdurX160aNGik0NFQXL17Uli1bSl1rdXDu3DlJUt26dYv0ffbZZ4qOji7yv0OHDpV3mZXCo48+qgsXLujbb7+1tiUmJurMmTN65JFHrnvegQMHqmHDhtav77nnHvn4+Cg5Odnadvfdd+vVV1/VU089ZXOth4eHWrRoofz8fF24cOG6a6hqSvOzGjRokM3vujZt2kiSgoOD5eHhYW0vvNXi5MmTf/j6ffr0sfkddtttt+nOO+/UL7/8ouzs7Ot7U7BKT0/XiBEjdO7cOf39739Xu3btKrokVHKshao+1kPGYT1UebAeqrpYC5UOT52rIB07dtSgQYO0fPlySdKkSZPUrFmzUs9z6dIlHTlyRA0bNtTf//73Iv1nz56VdPWJD3fddZckycvLS9OnT9dzzz2n9evXq1u3bgoJCbE7v73trS1btpR09d7Uwi2i+FX9+vV19OhRXbx4sUjfZ599po0bNxZpb968ue68887yKK9S6devn6Kjo7V+/Xp1795d0q9bj2/k//fs/YeEp6enzT/gTZo0UZMmTZSdna0ffvhBR44c0dGjR7Vv3z599913ksT97r9Rmp/V7bffbvO1u7u7pKuLod9yc3OTpBI9vrdx48ZF2urUqWO9vnAuXJ8XXnhBZ86ckY+Pj/z9/Su6HFQRrIWqNtZDxmE9VHmwHqq6WAuVDkFTBerTp491cVWYYJdWZmamJCk1NVUxMTHFjvv9Jw1dunRR7dq1denSpWu+tre3d5G2wk8+Cl8btnx9fbVr1y4dPXq0yC+ht956y+br6Ojoa/7cqrvbb79drVu31saNG5WTkyMnJyd98cUXuueee25oIVqzZs0/HFNQUKC3335bH3zwgfXvT4MGDdSmTRs1atRIP//8c5HDMquz0vysChdSv3c9uxiuda3JZJIkfk4GSEtLU/fu3bV161ZFR0df80wOoDRYC1VdrIeMw3qo8mA9VHWxFiodbp2rINnZ2YqIiFDNmjVVs2ZNvfzyy9e1nbHwF1T79u2VlJRU7P9CQ0Ntrnvttdd06dIleXp6atGiRTp8+LDd+a9cuVKkLSMjQ9LVTzxQVOGhh4WHYOLG9OvXTxcvXtR//vMfbd++XWlpadd96GVpvP/++3rzzTdlNpv1zjvvaNu2bfrPf/6jmJgY+fr6lvnrV0YV9bNC2ZsxY4aio6N1++23a8mSJdq3b19Fl4QqgLVQ1cZ6yFishyoP1kNVE2uh0iFoqiALFizQ4cOHFRYWpqefflqHDx++rsd91qlTR76+vjp48KDdxdnatWsVHR1t82jfrVu3as2aNeratasWLlyonJwcvfjii9Ynr/zWjz/+WKRt165dksSWwWL07NlTt9xyi7788ss/fDyzve85bAUGBsrFxUUbN27Uhg0b5OTkpMDAwDJ/3U8++UTOzs76+9//ru7du8vLy0vS1U+DCs+Q4JMhWxX1s0LZu+eee+Tm5qaXXnpJ+fn51v8L3AjWQlUb6yFjsR6qPFgPVU2shUqHoKkC/Pjjj1q8eLH8/Pw0fPhwjRw5UnfccYfef/99u4uZPzJgwAClp6dr/vz5Nr/oDx48qIiICL3//vvWT9wyMjI0ffp01axZU6+88orat2+voKAg7dq1S0uXLi0y90cffWRzMOOxY8e0ZMkSNWzYUF26dCn9m68Gatasqb/97W+SpLCwMLuf5OXm5io2NlaLFy+W9OuWVhRVv359de3aVVu2bNHmzZvVqVMnu7cxGK1mzZrKz89XWlqaTftbb71l/Y+VvLy8Mq+jMqmonxXKT/fu3fXggw9q7969+vDDDyu6HFRirIWqPtZDxmI9VHmwHqraWAuVDGc0lbOcnBxNnTpVBQUFmjFjhlxcXCRd3YoXGhqqadOmadWqVaW6N3f06NH65ptvtHjxYiUkJOjee+/VxYsXtWHDBl2+fFlz5syxHgL32muv6fTp05o4caIaNWokSZo8ebI2bdqkyMhIPfDAAzYHAzo5OWngwIHq27evLBaLvvjiC125ckUxMTGqVauWgd+ZqqVTp05atGiRpkyZorCwMDVp0kQdOnRQvXr19Msvv+ibb75Renq6ateurfDwcPXo0aOiS3Zo/fr10+bNmyVJEydOLLfX/P777zVo0CA99NBDcnFx0Xfffae9e/fqpptu0rlz55Senl4utVQmFfGzQvmaNm2a/vOf/2jBggUKCAjQrbfeWtEloZJhLVR9sB4yFuuhyoP1UNXGWuiPsaOpnEVHR+vgwYMaOHCg2rZta23v0KGDgoKCdODAgSIHJP4RNzc3LV26VGPHjtWVK1e0fPlybd26VW3bttWSJUvUv39/SdI333yj1atXWz89LFS/fn1NmTJFV65c0bRp02w+CXzmmWcUGhqqzZs36/PPP1erVq20bNkyFgIl0L17d61fv15Tp06Vl5eXNm3apA8++EDbtm3T3XffralTp2rr1q0aPny4nJ2dK7pch9arVy95eHjIzc1Nffr0KZfXfPLJJzV9+nR5enpq5cqV+uSTT1S7dm3Nnz9fERERkq7eegFbFfGzQvm69dZb9eyzzyorK0szZsyo6HJQCbEWql5YDxmH9VDlwXqoamMt9MdMFm6qhR2rV6/W1KlTNXXqVA0bNqyiywEAAChXrIUAALg+7GgCAAAAAACAITijycEkJydrzZo1JR7fu3dvNW/evAwrAhwTf1cAoGri9ztQcvx9AeCICJoczMmTJxUTE1Pi8b6+vvxjgWqJvysAUDXx+x0oOf6+AHBEnNEEAAAAAAAAQ3BGEwAAAAAAAAxB0AQAAAAAAABDEDQBAAAAAADAEARNAAAAAAAAMARBEwAAAAAAAAxB0ARUI8nJyTKbzQoNDa3oUuzatm2bdu/eXdFlVErr16/XiRMnKroMAAAcHuuhqov1EOAYCJoAOIR//vOfGjZsmFJSUiq6lErnjTfe0HPPPafMzMyKLgUAANwA1kPXj/UQ4DgImgA4hNTU1IouodLiewcAQNXAv+nXj+8d4DgImgAAAAAAAGAIgiagmis8pyA6OlobN27UE088IX9/f91333166aWXlJaWZjPebDZr0qRJ2rZtm4KCguTv76+ePXsqMjJS2dnZRcY+9thjRV5z9erVMpvNWrx4sSQpNDRUMTExkqSwsDCZzeZr1hwaGqpu3bopOTlZo0ePVps2bdS5c2dNnjxZp06dKjI+KSlJkydPVvfu3dWiRQu1bdtWISEhWr9+vc248PBwmc1m/fDDDwoICFDLli0VEhIii8UiSdq0aZNGjhypTp066Z577lGnTp3017/+VXv37i1S34MPPqgTJ04oLCxM7dq1U/v27TV+/HilpaXp4sWLevnll9WxY0d16NBBzzzzjJKTk4vUvXfvXj377LPq2LGj/P399dhjj2nFihXWeiSpZ8+eWrNmjSSpf//+6tmzp7XPYrFoxYoVGjBggPz9/XXvvffqmWee0b59++z+POLj4zV06FC1aNFCDzzwAGccAACqDdZDv2I9xHoIuFE1KroAAI5h8+bNeuutt9SjRw917NhR//nPf7Ry5UqdPHlSH3zwgc3YpKQkjRo1Sm3atNHgwYO1fft2LVq0SN9//70++OADOTmVLsMeMGCAJGnHjh0KDAzUHXfc8YfXXLlyRUOHDpWLi4tCQkJ0+PBh/etf/9J3332nlStXytvbW5L0448/KjQ0VK6ururTp4+8vLx07Ngxbdy4Uc8995xcXV3Vq1cvm7n/+te/qlWrVurWrZvc3d1lMpn04Ycf6tVXX9Xtt9+uRx55RC4uLtq9e7c2bdqk7du3a8OGDdbXlKTMzEw9+eSTuvXWWxUcHKz//ve/2rBhg9LS0pSVlaXs7GwNGDBAP//8szZv3qwzZ87o448/tn7vtm7dqjFjxsjFxUUBAQGqX7++/v3vf+uVV17Rvn37NHPmTEnS0KFDtWbNGu3fv1/BwcE237spU6Zo3bp18vPzU0hIiC5fvqz169crJCREb7/9tu677z6b9/3qq6/K29tbQ4cOVXJysho1alSqnyMAAJUd66FfsR5iPQRcNwuAauPEiRMWPz8/y5AhQ4q0+fn5WeLj463tOTk5locfftji5+dnOXbsmLW9cOyMGTOsbbm5uZaxY8da/Pz8LKtWrbIZ269fvyJ1rFq1yuLn52f54IMPrG1RUVEWPz8/y5dffvmH72PIkCEWPz8/y+OPP265fPmytX3x4sUWPz8/y5QpU6xtI0aMsNx9992WgwcP2syxfv16i5+fn+X555+3tk2ZMsXi5+dnGTNmjM3Y7OxsS9u2bS19+vSxXLp0yaZvxowZFj8/P8uKFSuK1BcWFmYpKCiwfo969Ohh8fPzswQHB1uys7OLjP/5558tFovFkpWVZenUqZOlc+fOlpMnT1rH5efnW8aPH2/x8/OzbNmypUjd+/bts7bFx8db/Pz8LJMmTbLk5eVZ20+cOGHp0KGDpVu3bpacnByLxfLrz6Nbt26WrKysYr/vAABUBayHfsV6iPUQUBa4dQ6AJKlRo0Z66KGHrF+7uLhYP+E5evSozVh3d3eNHz/e+nWNGjX0wgsvyGQy6ZNPPimXeiVpwoQJqlmzpvXr0NBQ3X777fr888+Vk5MjSRo2bJjmzp2rO++80+baTp06SVKRrfCS1KdPH5uv8/PzNXPmTM2aNUvu7u4lnmfo0KEymUySrn6PWrZsaa3T1dXVOq5Vq1aSpJMnT0q6uiU9LS1Nf/nLX+Tj42Md5+TkpOeff16StGrVKvvflP/5+OOPJUlTp06Vs7Oztf22225TSEiITp8+rf/85z8213Tr1k21atW65rwAAFRlrId+xXoIwPXi1jkAkqTGjRsXaatTp44kWRcphcxms+rVq2fTdtttt8nLy0v79+8vsxp/y2QyqX379jZtTk5Ouueee7R+/XodP35cTZs21f333y/p6pNI9u/fr+PHj+vQoUPatWuXpKuLpt+77bbbbL6uVauWAgMDJUlHjhzRoUOHdPz4cR04cEDfffedJKmgoKDIPH/6059svi5clP1+fjc3N0lSbm6uJGnPnj3W/xsdHV1kXmdn5z/8Pu/du1dubm6KjY0t0nfkyBFJ0k8//aQePXpY239fFwAA1Q3roV+xHgJwvQiaAEiSzSdKhQo/ffq93957/1sNGjTQ4cOHDa2rOPXr17dbc4MGDSRJGRkZkqRffvlFM2fO1KZNm2SxWOTs7KzGjRurffv2RQ6BLPTbTwULJSQkaPbs2daDLmvWrCmz2awWLVro1KlTNgdSFiru0zB7df9WYe2fffZZsWMuXLjwh3Pk5eVZDxUtyRyFCzwAAKor1kO/Yj0E4HoRNAEotd8/TaVQZmamPD09bdrsLTguX758wzVcuXKl2BokydPTUxaLRaNHj9bBgwc1atQoBQQEyM/PT66urkpLS1NcXFyJXuvkyZMaNWqUXF1dNWPGDHXo0EGNGzeWk5OTNmzYoC+++OKG389vFX7St3jx4iIHVJZmjtq1a2vLli0GVgYAAAqxHmI9BMA+zmgCUGp79uwpsjU6JSVFp06dkr+/v7XNxcVFWVlZRa4/fvx4kbbiPi0sTlZWlg4dOlSkfdeuXfL09NTtt9+u/fv368CBA3rwwQc1ceJEtWjRwvrp2cGDByXZX/j93pdffqnLly9r/PjxCgkJ0R133GF9Gkpp5impZs2aSVKRxwRLUnp6umbNmqW1a9da2+x975o1a6bTp0/r7NmzRfo2b96syMjIctvWDwBAVcR6iPUQAPsImgCUWmpqqt577z3r17m5uXrttddksVgUFBRkbb/jjjuUnJysn3/+2dp28uRJm0VBocIDGgvvyy+JefPm2ZyXsGTJEh09elT9+vWTs7OzdevzuXPnbK5LT0/X3/72N0lSXl7eH75O4dbx3y9S9u/fryVLlpR4npJ68MEH5eHhoXfffVfHjh2z6Zs7d66WLl1q027vezdgwABZLBbNnDnT5nt05swZvfLKK3r77bc56BIAgBvAeugq1kMAfo9b5wCUWu3atRUVFaXvvvtOd955p7Zv366kpCQ98sgj6t27t3XcwIEDNXPmTA0dOlSPPPKIsrOztX79evn5+SkxMdFmzltuuUWStGjRIu3bt09jxoz5w3vkd+7cqccff1z33XefDh06pH//+99q2rSpxo0bJ0lq0qSJ/P39lZiYqCeffFJt27bV+fPn9dVXXyknJ0e1atXS+fPn//D9PvDAA3rjjTf09ttv6/Dhw7r99tt17Ngxbd682XpAaHp6emm+hddUp04dvfrqq5o0aZIee+wx9e7dWzfffLN27Nih3bt365577tFf/vIX6/jC793rr7+uTp06acyYMRowYIA2btyoDRs2KCkpSV27dlVeXp7Wr1+v9PR0Pffcc0UO5wQAACXHeoj1EAD72NEEoNQaNWqk9957T6mpqfrnP/+pvLw8vfjii5o7d67NuCFDhujFF19U3bp1tWLFCm3btk1PP/20XnzxxSJzBgYG6qGHHtKxY8e0fPly66Ntr2XJkiW6+eabFRcXp59//llDhw7VihUrrIsdk8mkt956S0FBQUpOTtbSpUuVkJCgbt26adWqVerSpYuOHj1qd+v6b3l7e+uDDz7Qfffdp+3btys2NlZHjhxRaGio1q9fL09PT33zzTeGbhd/6KGHtGzZMnXq1EnffPONli1bpkuXLumvf/2rlixZIg8PD+vYJ598Ul26dNGPP/6oDz/8UJcuXZLJZFJUVJSmTZummjVrauXKlVq/fr2aNm2q6Oho/fWvfzWsVgAAqiPWQ6yHANhnshj5mwBAlWc2m9WsWTOtW7euwmoIDQ3Vjh07lJCQoLp161ZYHQAAoHpiPQQAxWNHEwAAAAAAAAxB0AQAAAAAAABDEDQBAAAAAADAEJzRBAAAAAAAAEOwowkAAAAAAACGIGgCAAAAAACAIQiaAAAAAAAAYAiCJgAAAAAAABiCoAkAAAAAAACGIGgCAAAAAACAIQiaAAAAAAAAYAiCJgAAAAAAABiCoAkAAAAAAACGIGgCAAAAAACAIQiaAAAAAAAAYAiCJgAAAAAAABiCoAkAAAAAAACGIGgCAAAAAACAIQiaAAAAHFxKSoratWunxYsXl/ia9PR0RUREqGfPnmrVqpWCgoIUHx9fdkUCAABIqlHRBQAAAKB4ly5d0tixY5WZmVnia7KysjRixAj99NNP6tu3r2699VZ98cUXev7555WWlqYhQ4aUYcUAAKA6Y0cTAACAgzp16pRCQ0P1ww8/lOq6pUuXau/evZo+fboiIyP1wgsvaO3atbrrrrs0b948nTt3rowqBgAA1R1BEwAAgANavHixHnnkEe3fv1+dOnUq1bXLly9Xw4YNNXDgQGubh4eHnnnmGV2+fFmffvqp0eUCAABIImgCAABwSEuXLpWvr6+WLVumxx57rMTXHT9+XCkpKWrbtq2cnZ1t+jp27ChJSkhIMLRWAACAQpzRBAAA4IBmzJihzp07y9nZWUePHi3xdcePH5ck3X777UX6GjZsKDc3Nx05csSoMgEAAGwQNP1P+/btlZOTo4YNG1Z0KQAAoIykpqbK1dVViYmJFV3KH7r//vuv67r09HRJUt26de32e3h4KCMjw24f6yEAAKq+sl4PETT9T3Z2tvLz8yu6DAAAUIby8vJksVgquowylZeXJ0lydXW12+/q6qrLly/b7WM9BABA1VfW6yGCpv+5+eabJUkbN26s4EoAAEBZ6dWrV0WXUObc3NwkSTk5OXb7c3Jy5O7ubreP9RAAAFVfWa+HOAwcAACgCqlXr54kKTMz025/ZmamPDw8yrMkAABQjRA0AQAAVCGNGzeWJCUnJxfpO3PmjLKzs9WkSZNyrgoAAFQXBE0AAABViI+Pj3x8fPTf//5XBQUFNn07duyQJLVp06YiSgMAANWAwwdNKSkpateunRYvXnxd1xcUFGjgwIEym83GFgYAAOCg+vXrp9OnT2vZsmXWtszMTC1atEg1a9bUY489VoHVAQCAqsyhDwO/dOmSxo4dW+wZAyWxePFi/fDDDwZWBQAA4Diio6MlSWPHjrW2jRo1Shs2bNCsWbOUkJCgRo0a6YsvvtCJEyf08ssvy8vLq6LKBQAAVZzD7mg6deqUQkNDbygkOn78uBYsWGBgVQAAAI4lJiZGMTExNm0eHh6KjY3V448/rsTERC1fvlx169bV/PnzNWTIkAqqFAAAVAcOuaNp8eLFioqK0pUrV9SpUydt37691HNYLBZNmzZNDRo0kJubmw4dOlQGlQIAAJS9oKAgBQUF2e1LSkqy296gQQO99tprZVkWAABAEQ65o2np0qXy9fXVsmXLrvsMgRUrVmjHjh2aOXOmatasaXCFAAAAAAAA+D2H3NE0Y8YMde7cWc7Ozjp69Gipr//ll180b948BQUFqXPnzsYXCAAAAAAAgCIcMmi6//77b+j66dOnq1atWgoPDzeoIgAAAAAAAPwRhwyabsTatWv19ddfa8GCBapXr15FlwMAAAAAAFBtOOQZTdfr7Nmzmj17tnr37q2+fftWdDkAAAAAAADVSpUKmiIiIpSfn6/p06dXdCkAAAAAAADVTpW6de7zzz+XJHXr1s1uv9lslq+vrzZt2lSeZQEAAAAAAFQLVSpoGjNmjN32uLg4paamasyYMapTp045V1W+srKy1KZNG0nSrl275O7uXsEVAQAAAACA6qJKBU1jx461275582alpqYW2w8AAAAAAIAbV6nPaIqOjlZ0dHRFlwEAQInt3btX//nPf67r2pycHC1evNjYgm5QdHS0zGazvvrqq4ouBQAAAA6gUu9oiomJkVT8TiYAQOXROPyzii7hmo7OefiG59i6daueeeYZTZkyRV26dCn19aGhoTp06JCGDRt2w7UAAAAAZcHhg6agoCAFBQXZ7UtKSirRHKtXrzayJAAArsu5c+dUUFBw3denpqYaWA0AAABgvEp96xwAAAAAAAAcB0ETAADlIDw8XFOnTpUkzZ49W2azWcnJyZKkdevWaeDAgWrVqpXatGmjwYMHa+PGjdZrk5OTZTabdfLkSWVkZMhsNis8PLxUr//+++/LbDYrLi6uSF9KSoqaN2+u0aNH27zm9OnT1bt3b7Vs2VJt2rRRUFCQYmNj//C1zGazHnvssSLtq1evltlsLnLOVGpqql555RV169ZNLVq0UM+ePTV37lxlZmaW6j0CAACg4hE0AQBQDnr37q1evXpJkrp27aoxY8aobt26mjlzpl544QX98ssveuyxx/TQQw/p0KFDevbZZ/X2229LkurWrasxY8aoTp06cnV11ZgxY9S7d+9Svf4jjzwiJycnxcfHF+lbv369CgoK9Oijj0q6GjI9/vjjWrdunVq3bq1hw4bpwQcf1KFDhxQREaGlS5fe4HfjV6dOndITTzyhuLg4tWjRQsOGDdMdd9yh9957T6GhocrKyjLstQAAAFD2HP6MJgAAqoLevXvr4sWL2rhxo+6//34NGzZM3333nZYtW6Z77rlH//jHP1S/fn1JV3cYDR48WG+++aa6d++uZs2aaezYsVqzZo0uXrx4XQ/BuPnmm9WpUyd99913OnfunG666SZrX3x8vNzd3a1B2DvvvKP09HS9//77NoeWh4aG6oknntBnn32moUOH3uB35KpXXnlFKSkpeuedd9StWzdr+7JlyzRz5kwtXLhQkydPNuS1AAAAUPbY0QQAQAVZu3atJGnKlCnWkEmSvL29NW7cOBUUFGjVqlWGvV6/fv2Un5+vDRs2WNtOnjypH374Qb169ZK7u7t13KxZs4o8Ga9ly5aqXbu20tLSDKnnzJkz+vrrr9WjRw+bkEmSBg8erFtvvZUHegAAAFQy7GgCAKCCJCUlycnJSW3atCnS165dO0nS/v37DXu9Pn36aMaMGdqwYYMGDx4sSfrss88kXQ2XCrVv317t27dXenq6fvrpJx0/flyHDx/WDz/8oKysLHl6ehpSz759+2SxWHT+/HlFR0cX6XdxcdEvv/yilJQUeXt7G/KaAAAAKFsETQAAVJDMzEy5ubnJ1dW1SN/NN98sSbpy5Yphr1e7dm317NlT69ev15kzZ3TzzTcrPj5eN910kzp37mwdd+HCBc2ePVuffvqpcnNzZTKZ1KhRI3Xo0EFJSUmG1XPx4kVJ0vfff6/vv/++2HHp6ekETQAAAJUEQRMAABWkdu3aunz5sjIyMlSnTh2bvsIQxqjdQ4X69eunzz77TF988YW6dOmin376SaGhoapR49clweTJk7V161YNHDhQAwYMULNmzay31dk7TNwei8VSpO3y5cs2XxfO+eyzz2r8+PHX+5YAAADgQDijCQCAcmIymWy+btasmSRp586dRcYmJCRIkpo2bWpoDV27dpWXl5c2btxoPaup8Glz0tWAa+vWrWrRooVmzpyptm3bWgOhkydPKisry26I9FsuLi52nxZ3/Phxm68L3//evXvtzhMVFaV33nlHOTk5JX+DAAAAqFAETQAAlBNnZ2dJUl5eniSpf//+kqQ33nhD58+ft45LSUlRZGSknJycbM5OqlGjhvXa61WjRg0FBgYqISFBn376qf70pz+pVatW1n5XV1c5Ozvr4sWLNgHPlStXFBERIUnKzc295mvccccdSk5O1s8//2xtO3nypPXw80K33XabOnTooK1bt+rLL7+06Vu7dq0WLlyorVu32r21EAAAAI6JW+cAACgnt9xyiyRpxYoVunDhgoYMGaLQ0FB9+OGH6tevnx544AHl5+dr48aNOn/+vJ5//nk1b97cer23t7eOHTumF154QZ07d7YGVaXVr18/LVu2TAcPHtSYMWNs+mrWrKkHH3xQGzZs0J///Gd16dJFWVlZ2rx5s86ePat69eopIyNDBQUFcnKy/3nVwIEDNXPmTA0dOlSPPPKIsrOztX79evn5+SkxMdFmbEREhJ588kmNHTtW3bp1U9OmTXXkyBFt2bJF9erV0//93/9d13sEAABAxWBHEwAA5eTee+/V4MGDlZ6ermXLlunQoUN66aWXNGfOHN1yyy1at26dPv/8c5nNZr399tt65plnbK6fPHmy7rrrLsXHx2vdunXXXUerVq3UuHFjSba3zRWaNWuWnnrqKWVkZGjZsmX65ptv1LJlS61YsUL9+/fXlStX9N133xU7/5AhQ/Tiiy+qbt26WrFihbZt26ann35aL774YpGxTZo00erVq/XnP/9Z+/fv19KlS5WUlKTHHntMK1eulJ+f33W/TwAAAJQ/k+WPDlqoJnr16iVJ2rhxYwVXcmOysrKsj8netWuX9VwNAABQdf69Lyt8fwAAqPrK+t97djQBAAAAAADAEJzRBABAJZScnKw1a9aUeHzv3r1tznsCAAAAygJBEwAAldDJkycVExNT4vG+vr4ETQAAAChzBE0AAFRCHTt2VFJSUkWXAQAAANjgjCYAAAAAAAAYgqAJAAAAAAAAhiBoAgAAAAAAgCEImgAAAAAAAGAIgiYAAAAAAAAYgqAJAAAAAAAAhiBoAgAAAAAAgCEImgAAAAAAAGAIgiYAAAAAAAAYgqAJAAAAAAAAhiBoAgAAAAAAgCEImgAAAAAAAGAIhw+aUlJS1K5dOy1evLjE1+zZs0fPPvusOnbsqBYtWqh3796aN2+esrKyyq5QAAAAAACAaq5GRRdwLZcuXdLYsWOVmZlZ4mu2b9+ukSNHSpICAgJ08803KyEhQe+++662b9+u2NhYubm5lVXJAAAAAAAA1ZbDBk2nTp3SmDFjtHfv3lJdFxERIYvFohUrVsjf31+SZLFYNH36dH300Udavny5hg8fXhYlAwAAAAAAVGsOeevc4sWL9cgjj2j//v3q1KlTia87fPiwDh06pF69ellDJkkymUwKCwuTJH399deG1wsAAAAAAAAH3dG0dOlS+fr6asaMGTp69Ki2b99eoutq166tyZMn66677irS5+rqKkmc0wQAAAAAAFBGHDJomjFjhjp37ixnZ2cdPXq0xNd5e3tbz2f6vY0bN0qSmjZtakSJAAAAAAAA+B2HDJruv/9+Q+c7d+6cFixYIEkaOHCgoXMDAAAAAADgKoc8o8lIGRkZGj16tFJTUzV48GC1atWqoksCAAAAAACokqp00JSWlqannnpKe/bsUbdu3TR16tSKLgkAAKBE8vLytHjxYgUGBsrf31+9evXSwoULlZubW6LrDxw4oGeffVb33nuvWrZsqUcffVRxcXFlXDUAAKjuqmzQdOLECQ0aNEh79+7VAw88oJiYGLm4uFR0WQAAACUSERGh2bNny9PTU0OHDpW3t7eioqI0ceLEP7z2wIEDCg4O1pYtW9StWzcNGjRIWVlZmj59uubOnVsO1QMAgOrKIc9oulH79+/XX/7yF509e1b9+/fXrFmzVKNGlXyrAACgCtq5c6fi4uIUGBioyMhISZLFYlF4eLjWrl2rLVu2qEePHsVeHxUVpaysLC1cuFC9e/eWJI0fP15PPPGE3n//fYWEhKhRo0bl8VYAAEA1U+V2NB07dkwjRozQ2bNnNXz4cM2ZM4eQCQAAVCqxsbGSpLCwMGubyWTShAkTZDKZtHLlymtev3v3btWrV88aMklS7dq19eijj6qgoEC7d+8um8IBAEC1V6WCpoKCAk2cOFHnzp3T0KFDFR4eLpPJVNFlAQAAlEpiYqK8vLzUtGlTm3Zvb281btxYCQkJ17y+bt26yszM1IULF2zaU1JSJEn169c3tmAAAID/qdRbfaKjoyVJY8eOlSR99dVX2r17t1xdXeXu7m7t/60GDRpo0KBB5VonAABASeXk5Oj06dPFPinX19dXR44cUVpamry8vOyOCQkJUUREhCZOnKiXX35ZN910k7744gutWrVKzZs3V4cOHcryLQAAgGqsUgdNMTExkn4Nmgo/3cvJydGiRYvsXtOsWTOCJgAA4LDS09MlSXXq1LHbX9iekZFRbNA0ePBgOTk5adasWerTp4+1vUuXLnrjjTfk7OxsbNEAAAD/4/BBU1BQkIKCguz2JSUl2Xw9bdo0TZs2rTzKAgAAKBN5eXmSJFdXV7v9he3Z2dnFzvH999/r7bfflouLix5++GHVqVNH3377rb799lvFxMTopZde4ngBAABQJhw+aAIAAKhOatasKUnKzc2125+TkyNJqlWrlt3+zMxMPf300yooKNDq1avVpEkT63yTJ0/WsmXLdNdddykkJKQMqgcAANVdlToMHAAAoLLz8PCQk5OTMjMz7fZnZGRIKv7Wuo0bNyo9PV2hoaHWkEmSXFxc9PLLL0uSPv74Y4OrBgAAuIqgCQAAwIG4urrKx8dHycnJdvuTk5NVv359eXp62u0/ffq0JOnOO+8s0nfTTTepfv36+uWXXwyrFwAA4LcImgAAABxMu3btlJqaqiNHjti0p6Sk6NixY2rdunWx1950002SVORaSbpw4YLS09PVoEEDQ+sFAAAoRNAEAADgYPr37y9JioyMVEFBgSTJYrFo/vz5slgsCg4OLvbaBx54QLVq1dKyZct04sQJa3t+fr7mzJkji8Wihx9+uEzrBwAA1ReHgQMAADiYzp07KzAwUPHx8QoODlbHjh21a9cuJSYmKiAgQD169LCOjY6OliSNHTtW0tUdTS+//LJeeuklPfbYYwoICFDdunW1fft27d+/Xx06dNCwYcMq4F0BAIDqgKAJAADAAb3++utq2rSp1qxZoyVLlsjHx0fjxo3TqFGjZDKZrONiYmIk/Ro0SdLjjz8uX19fvfvuu/ryyy915coVNWrUSOPHj9fIkSPl6upa7u8HAABUDwRNAAAADsjFxUVhYWEKCwu75rikpCS77Z06dVKnTp3KojQAAIBicUYTAAAAAAAADEHQBAAAAAAAAEMQNAEAAAAAAMAQBE0AAAAAAAAwBEETAAAAAAAADEHQBAAAAAAAAEMQNAEAAAAAAMAQBE0AAAAAAAAwBEETAAAAAAAADEHQBAAAAAAAAEMQNAEAAAAAAMAQBE0AAAAAAAAwBEETAAAAAAAADEHQBAAAAAAAAEMQNAEAAAAAAMAQBE0AAAAAAAAwBEETAAAAAAAADEHQBAAAAAAAAEMQNAEAAAAAAMAQBE0AAAAAAAAwBEETAAAAAAAADOHwQVNKSoratWunxYsXl/ia9PR0RUREqGfPnmrVqpWCgoIUHx9fdkUCAAAAAABANSq6gGu5dOmSxo4dq8zMzBJfk5WVpREjRuinn35S3759deutt+qLL77Q888/r7S0NA0ZMqQMKwYAAAAAAKi+HHZH06lTpxQaGqoffvihVNctXbpUe/fu1fTp0xUZGakXXnhBa9eu1V133aV58+bp3LlzZVQxAAAAAABA9eaQQdPixYv1yCOPaP/+/erUqVOprl2+fLkaNmyogQMHWts8PDz0zDPP6PLly/r000+NLhcAAAAAAABy0KBp6dKl8vX11bJly/TYY4+V+Lrjx48rJSVFbdu2lbOzs01fx44dJUkJCQmG1goAAAAAAICrHPKMphkzZqhz585ydnbW0aNHS3zd8ePHJUm33357kb6GDRvKzc1NR44cMapMAAAAAAAA/IZDBk3333//dV2Xnp4uSapbt67dfg8PD2VkZFxvWYZpHP5Z2U2ely23//3x7ukbpBpu1xx+I47OebjM5gYAAAAAAJWPQ946d73y8vIkSa6urnb7XV1dlZ2dXZ4lAQAAAAAAVBtVKmhyc7u6eycnJ8duf05Ojtzd3cuzJAAAAAAAgGqjSgVN9erVkyRlZmba7c/MzJSHh0d5lgQAAAAAAFBtVKmgqXHjxpKk5OTkIn1nzpxRdna2mjRpUs5VAQAAAAAAVA9VKmjy8fGRj4+P/vvf/6qgoMCmb8eOHZKkNm3aVERpAAAAAAAAVV6VCpokqV+/fjp9+rSWLVtmbcvMzNSiRYtUs2ZNPfbYYxVYHQAAAAAAQNVVo6ILuBHR0dGSpLFjx1rbRo0apQ0bNmjWrFlKSEhQo0aN9MUXX+jEiRN6+eWX5eXlVVHlAgAAAAAAVGmVekdTTEyMYmJibNo8PDwUGxurxx9//P/bu/eoqqr9//+vjYKooOAlPkH60STQUsxL4i1FMVEqQ2oIZnDSvFSomWRiXr6JeTnpkRQsPXoSTPSQpvY5pZZ5yS4akFpqqeUFxRRRDipqXPfvD3/s3LJRlI1s5fkYo3EGc665eC/m2e7Ni7nmUmpqqlasWKE6depo7ty5euGFFyqpUgAAAAAAgHufza9oCg4OVnBwsMW+gwcPWmxv0KCBZsyYUZFlAQAAAAAA4Dp39YomAAAAAAAA2A6CJgAAAAAAAFgFQRMAAAAAAACsgqAJAAAAAAAAVkHQBAAAAAAAAKsgaAIAAAAAAIBVEDQBAAAAAADAKgiaAAAAAAAAYBUETQAAAAAAALAKgiYAAAAAAABYBUETAAAAAAAArIKgCQAAAAAAAFZB0AQAAGCDCgoKFB8fr8DAQPn4+Mjf318LFixQfn5+mcbn5uYqLi5OAQEBatWqlXr16qUZM2bowoULFVw5AACoygiaAAAAbFB0dLRmzpwpFxcXhYeHy83NTfPnz1dkZORNx+bn52vo0KGKjY1VgwYNFBYWpvvvv18JCQkaOnSo8vLy7sAVAACAqqh6ZRcAAAAAc7t27VJSUpICAwMVExMjSTIajYqKitK6deu0bds2+fn5lTp+2bJlSk5O1uDBgxUVFWVqj46OVmJiotavX6+goKAKvgoAAFAVsaIJAADAxiQmJkqSIiIiTG0Gg0Fjx46VwWDQqlWrbjrew8OjxOqnIUOGqH///qpRo4b1iwYAABArmgAAAGxOamqq6tWrJ09PT7N2Nzc3NWnSRCkpKaWO/f3333Xy5EmFhYXJ3t7erO+BBx7QrFmzKqRmAAAAiRVNAAAANiUvL0+nT59Wo0aNLPZ7eHjo/PnzysrKsth/6NAhSdJDDz2kr7/+WqGhoWrdurW6du2qWbNm6fLlyxVWOwAAAEETAACADcnOzpYkOTs7W+wvbr948aLF/jNnzkiStm7dqhEjRqhOnToKDQ1Vw4YNtXTpUg0dOrTMT64DAAC4Vdw6BwAAYEMKCgokSQ4ODhb7i9tzc3Mt9l+5ckXS1aBp2rRpGjBggCSpsLBQY8eO1caNG7Vy5UqFh4dbu3QAAABWNAEAANgSR0dHSSp11VFeXp4kqWbNmhb77eyufrxr0aKFKWSSpGrVqunNN9+UJK1fv95q9QIAAFyLoAkAAMCGODk5yc7OTjk5ORb7i2+ZK+3WOicnJ0nSww8/XKLPw8NDderU0YkTJ6xULQAAgDmCJgAAABvi4OAgd3d3paenW+xPT0+Xq6urXFxcLPY3adJE0l+34F2voKDAtGoKAADA2giaAAAAbEy7du2UmZmpo0ePmrVnZGQoLS1Njz76aKljfXx85ODgoJSUFBUWFpr1HT58WJcvX1bz5s0romwAAACCJgAAAFsTFBQkSYqJiVFRUZEkyWg0au7cuTIajQoJCSl1rLOzs/r27as//vhDixcvNrXn5+dr9uzZkqTg4OCKKx4AAFRpPHUOAADAxnTu3FmBgYFav369QkJC5Ovrq927dys1NVUBAQHy8/MzHRsbGytJGjVqlKlt/Pjx2rNnj2JiYpSSkiIvLy/t2LFDv/76qwIDA+Xv73+nLwkAAFQRBE0AAAA26N1335Wnp6fWrl2rhIQEubu7a/To0Ro2bJgMBoPpuLi4OEnmQVP9+vWVlJSkBQsWaNOmTUpOTpaHh4fGjRunwYMH3/FrAQAAVQdBEwAAgA2yt7dXRESEIiIibnjcwYMHLba7urpq0qRJmjRpUkWUBwAAYJFN7tFUUFCg+Ph4BQYGysfHR/7+/lqwYIHy8/PLNP7QoUN69dVX9dhjj6lVq1Z6+umnlZSUVMFVAwAAAAAAVG02GTRFR0dr5syZcnFxUXh4uNzc3DR//nxFRkbedOyhQ4cUEhKibdu2qVu3bho4cKAuX76sKVOmmDbABAAAAAAAgPXZ3K1zu3btUlJSkgIDAxUTEyPp6lNWoqKitG7dOm3bts1sA8zrzZ8/X5cvX9aCBQvUq1cvSdJrr72m5557Th9++KFCQ0PVqFGjO3EpAAAAAAAAVYrNrWhKTEyUJLP9CAwGg8aOHSuDwaBVq1bdcPzevXtVt25dU8gkSbVr19bTTz+toqIi7d27t2IKBwAAAAAAqOJsLmhKTU1VvXr15Onpadbu5uamJk2aKCUl5Ybj69Spo5ycHJ0/f96sPSMjQ9LVjTEBAAAAAABgfTYVNOXl5en06dOl3trm4eGh8+fPKysrq9RzhIaGqrCwUJGRkUpLS1NOTo7WrFmjTz75RC1atFCHDh0qqnwAAAAAAIAqzab2aMrOzpYkOTs7W+wvbr948aLq1atn8ZhBgwbJzs5O06dPV+/evU3tXbp00T/+8Q9Vq1bNukUDAAAAAABAko2taCooKJAkOTg4WOwvbs/NzS31HHv27NGiRYtkb2+voKAghYWFqVmzZvr+++8VFxcno9Fo/cIBAAAAAABgWyuaHB0dJUn5+fkW+/Py8iRJNWvWtNifk5OjESNGqKioSGvWrFHTpk1N5xs3bpyWL1+uhx56SKGhoRVQPQAAAAAAQNVmUyuanJycZGdnp5ycHIv9Fy9elFT6rXWbN29Wdna2wsLCTCGTJNnb22vy5MmSpNWrV1u5agAAAAAAAEg2FjQ5ODjI3d1d6enpFvvT09Pl6uoqFxcXi/2nT5+WJDVr1qxEX/369eXq6qpTp05ZrV4AAAAAAAD8xaaCJklq166dMjMzdfToUbP2jIwMpaWl6dFHHy11bP369SWpxFhJOn/+vLKzs9WgQQOr1gsAAAAAAICrbC5oCgoKkiTFxMSoqKhIkmQ0GjV37lwZjUaFhISUOrZHjx6qWbOmli9frhMnTpjaCwsLNWvWLBmNRj355JMVWj8AAAAAAEBVZVObgUtS586dFRgYqPXr1yskJES+vr7avXu3UlNTFRAQID8/P9OxsbGxkqRRo0ZJurqiafLkyZo0aZKeeeYZBQQEqE6dOtq5c6cOHDigDh066MUXX6yEqwIAAAAAALj32VzQJEnvvvuuPD09tXbtWiUkJMjd3V2jR4/WsGHDZDAYTMfFxcVJ+itokqRnn31WHh4eWrx4sTZt2qQ///xTjRo10muvvaahQ4fKwcHhjl8PAAAAAABAVWCTQZO9vb0iIiIUERFxw+MOHjxosb1jx47q2LFjRZQGAAAAAACAUtjcHk0AAAAAAAC4O5V5RdPIkSNv6xsYDAbTXkoAAAAAAAC4d5U5aDp9+rT27dsng8Ego9FY5m9w7Z5KAAAAAAAAuHeVOWhatWqVpk2bphUrVqhr166aOnVqRdYFAAAAAACAu0yZgyaDwaApU6YoJydH//nPf5ScnKz+/ftXZG0AAAAAAAC4i9zyZuDTpk2Th4eHZs+erUuXLlVETQAAAAAAALgL3XLQVKNGDU2bNk3du3fXwYMHK6ImAAAAAAAA3IXKfOvctTp16qROnTpZuxYAAAAAAADcxW55RdON5OXlKS0tjVvqAAAAAAAAqqBbDpq2bt2qCRMm6MCBA2bt7733nnx9fdWnTx916NBBY8eOVXZ2trXqBAAAAAAAgI27pVvn3n77bSUlJUmS/Pz81Lx5c0lSTEyMFi1aJDs7O3Xp0kVGo1EbN27Ub7/9pk8++UQODg7WrxwAAAAAAAA2pcwrmrZs2aJ///vfatGihZYsWSI/Pz9JUkZGhv71r3/JYDDonXfe0ZIlS/Svf/1LsbGx+u2337Rs2bKKqh0AAAAAAAA2pMxB0+rVq+Xi4qJly5apS5cuqlGjhiRp48aNKigoUOPGjRUcHGw63t/fX23bttXGjRutXzUAAAAAAABsTpmDpp9//ll+fn5ycnIya//+++9lMBjUs2fPEmNat26ttLS08lcJAAAAAAAAm1fmoOn8+fO67777zNqKior0448/SpI6depUYkz16tWVn59fzhIBAAAAAABwNyhz0OTs7Kz//ve/Zm379u1TTk6Oqlevrvbt25cYc+zYMbm6upa/SgAAAAAAANi8MgdNrVq10vfff6/CwkJT22effSZJ6tChg2rVqmV2fGZmpr799lu1atXKSqUCAAAAAADAlpU5aBowYIBOnjyp119/XSkpKVqxYoX+/e9/y2Aw6IUXXjA7NisrS2PGjNGff/6pfv36Wb1oAAAAAAAA2J7qZT3Q399fgwYNUmJiojZt2iRJMhqNev7559WjRw/TcS+//LJ27Nih3Nxc9enTR7169bJ+1QAAAAAAALA5ZQ6aJGny5MkKCAjQ1q1bVVBQoC5dusjPz8/smCNHjqh27doaPny4XnnlFWvWCgAAAAAAABt2S0GTdHU/pg4dOpTav2bNGjk5OZWrKAAAAAAAANx9yrxHU1kRMgEAAAAAAFRNVg+aAAAAAAAAUDURNAEAAAAAAMAqCJoAAAAAAABgFQRNAAAAAAAAsAqCJgAAAAAAAFgFQRMAAAAAAACsgqAJAAAAAAAAVmGTQVNBQYHi4+MVGBgoHx8f+fv7a8GCBcrPzy/T+NzcXMXFxSkgIECtWrVSr169NGPGDF24cKGCKwcAAAAAAKi6bDJoio6O1syZM+Xi4qLw8HC5ublp/vz5ioyMvOnY/Px8DR06VLGxsWrQoIHCwsJ0//33KyEhQUOHDlVeXt4duAIAAAAAAICqp3plF3C9Xbt2KSkpSYGBgYqJiZEkGY1GRUVFad26ddq2bZv8/PxKHb9s2TIlJydr8ODBioqKMrVHR0crMTFR69evV1BQUAVfRSWqXkO5/edWdhUAAAAAAKAKsrkVTYmJiZKkiIgIU5vBYNDYsWNlMBi0atWqm4738PAosfppyJAh6t+/v2rUqGH9ogEAAAAAAGB7QVNqaqrq1asnT09Ps3Y3Nzc1adJEKSkppY79/fffdfLkSfXs2VP29vZmfQ888IBmzZqlvn37VkjdAAAA1lTePSuvVVRUpAEDBsjb27sCKgUAAPiLTQVNeXl5On36tBo1amSx38PDQ+fPn1dWVpbF/kOHDkmSHnroIX399dcKDQ1V69at1bVrV82aNUuXL1+usNoBAACsqTx7Vl4vPj5eP/30UwVUCQAAYM6mgqbs7GxJkrOzs8X+4vaLFy9a7D9z5owkaevWrRoxYoTq1Kmj0NBQNWzYUEuXLtXQoUNv66+AAAAAd9K1e1auWLFCb7zxhhITExUUFKQvvvhC27ZtK/O5jh8/rnnz5lVcsQAAANewqaCpoKBAkuTg4GCxv7g9NzfXYv+VK1ckXQ2aoqOj9c9//lMTJkzQ6tWr1adPH/34449auXJlBVQOAABgPeXds7KY0WjUxIkT1aBBAzVr1qxCagUAALiWTQVNjo6OklTqqqO8vDxJUs2aNS3229ldvZwWLVpowIABpvZq1arpzTfflCStX7/eavUCAABUhPLsWXmtlStXKjk5WdOmTTN9zgIAAKhINhU0OTk5yc7OTjk5ORb7i2+ZK+3WOicnJ0nSww8/XKLPw8NDderU0YkTJ6xULQAAgPWVd8/KYqdOndKcOXMUHByszp07V0SpAAAAJdhU0OTg4CB3d3elp6db7E9PT5erq6tcXFws9jdp0kTSX7fgXa+goIC/5gEAAJtW3j0ri02ZMkU1a9ZUVFSUVesDAAC4EZsKmiSpXbt2yszM1NGjR83aMzIylJaWpkcffbTUsT4+PnJwcFBKSooKCwvN+g4fPqzLly+refPmFVE2AACAVZR3z0pJWrdunbZv367Jkyerbt261i8SAACgFDYXNAUFBUmSYmJiVFRUJOnqRpZz586V0WhUSEhIqWOdnZ3Vt29f/fHHH1q8eLGpPT8/X7Nnz5YkBQcHV1zxAAAA5VTePSvPnj2rmTNnqlevXurTp0/FFAkAAFCK6pVdwPU6d+6swMBArV+/XiEhIfL19dXu3buVmpqqgIAA+fn5mY6NjY2VJI0aNcrUNn78eO3Zs0cxMTFKSUmRl5eXduzYoV9//VWBgYHy9/e/05cEAABQZuXdszI6OlqFhYWaMmVKhdUIAABQGpsLmiTp3Xfflaenp9auXauEhAS5u7tr9OjRGjZsmAwGg+m4uLg4SeZBU/369ZWUlKQFCxZo06ZNSk5OloeHh8aNG6fBgwff8WsBAAC4FeXds/KLL76QJHXr1s1iv7e3tzw8PLRlyxar1AsAAHAtmwya7O3tFRERoYiIiBsed/DgQYvtrq6umjRpkiZNmlQR5QEAAFSodu3a6dNPP9XRo0fVtGlTU3vxnpXXrvC+3siRIy22JyUlKTMzUyNHjix1NRQAAEB52WTQBAAAUJUFBQXp008/VUxMjN577z3Z2dmVec/Ka1d6X2vr1q3KzMwstR8AAMAaCJoAAABsTHn3rAQAAKgsBE0AAAA2qDx7VgIAAFQWgiYAAAAbVN49K6+3Zs0aa5QFAABwQ3aVXQAAAAAAAADuDQRNAAAAAAAAsAqCJgAAAAAAAFgFQRMAAAAAAACsgqAJAAAAAAAAVkHQBAAAAAAAAKsgaAIAAAAAAIBVEDQBAAAAAADAKgiaAAAAAAAAYBUETQAAAAAAALAKgiYAAAAAAABYBUETAAAAAAAArIKgCQAAAAAAAFZB0AQAAAAAAACrIGgCAAAAAACAVRA0AQAAAAAAwCoImgAAAAAAAGAVBE0AAAAAAACwCoImAAAAAAAAWAVBEwAAAAAAAKyCoAkAAAAAAABWQdAEAAAAAAAAqyBoAgAAAAAAgFUQNAEAAAAAAMAqCJoAAAAAAABgFTYZNBUUFCg+Pl6BgYHy8fGRv7+/FixYoPz8/Fs+V1FRkQYMGCBvb+8KqBQAAAAAAADFbDJoio6O1syZM+Xi4qLw8HC5ublp/vz5ioyMvOVzxcfH66effqqAKgEAAAAAAHCt6pVdwPV27dqlpKQkBQYGKiYmRpJkNBoVFRWldevWadu2bfLz8yvTuY4fP6558+ZVYLUAAAAAAAAoZnMrmhITEyVJERERpjaDwaCxY8fKYDBo1apVZTqP0WjUxIkT1aBBAzVr1qxCagUAAAAAAMBfbC5oSk1NVb169eTp6WnW7ubmpiZNmiglJaVM51m5cqWSk5M1bdo0OTo6VkSpAAAAAAAAuIZNBU15eXk6ffq0GjVqZLHfw8ND58+fV1ZW1g3Pc+rUKc2ZM0fBwcHq3LlzRZQKAAAAAACA69hU0JSdnS1JcnZ2tthf3H7x4sUbnmfKlCmqWbOmoqKirFofAAAAAAAASmdTm4EXFBRIkhwcHCz2F7fn5uaWeo5169Zp+/btmjdvnurWrWv9IgEAAAAAAGCRTa1oKt5LKT8/32J/Xl6eJKlmzZoW+8+ePauZM2eqV69e6tOnT8UUCQAAAAAAAItsKmhycnKSnZ2dcnJyLPYX3zJX2q110dHRKiws1JQpUyqsRgAAAAAAAFhmU7fOOTg4yN3dXenp6Rb709PT5erqKhcXF4v9X3zxhSSpW7duFvu9vb3l4eGhLVu2WKVeAAAAAAAA/MWmgiZJateunT799FMdPXpUTZs2NbVnZGQoLS1Nfn5+pY4dOXKkxfakpCRlZmZq5MiRpa6GAgAAAAAAQPnYXNAUFBSkTz/9VDExMXrvvfdkZ2cno9GouXPnymg0KiQkpNSxo0aNsti+detWZWZmltoPAAAAAACA8rO5oKlz584KDAzU+vXrFRISIl9fX+3evVupqakKCAgwW9EUGxsrqfSACQAAAAAAAHeOzQVNkvTuu+/K09NTa9euVUJCgtzd3TV69GgNGzZMBoPBdFxcXJwkgiYAAAAAAABbYJNBk729vSIiIhQREXHD4w4ePFim861Zs8YaZQEAAAAAAOAG7Cq7AAAAAAAAANwbCJoAAAAAAABgFQRNAAAAAAAAsAqCJgAAAAAAAFgFQRMAAAAAAACsgqAJAAAAAAAAVkHQBAAAAAAAAKsgaAIAAAAAAIBVEDQBAADYoIKCAsXHxyswMFA+Pj7y9/fXggULlJ+fX6bx+/bt06uvvipfX1+1bNlSvXr10pw5c3T58uUKrhwAAFRlBE0AAAA2KDo6WjNnzpSLi4vCw8Pl5uam+fPnKzIy8qZjd+7cqdDQUG3fvl1du3ZVWFiYXFxctHjxYoWHhys3N/cOXAEAAKiKqld2AQAAADC3a9cuJSUlKTAwUDExMZIko9GoqKgorVu3Ttu2bZOfn1+p46Ojo2U0GrVy5Ur5+PiYxk+ZMkUff/yxVqxYocGDB9+JSwEAAFUMK5oAAABsTGJioiQpIiLC1GYwGDR27FgZDAatWrWq1LFHjhzR4cOH5e/vbwqZiscXn2/79u0VVDkAAKjqWNEEAABgY1JTU1WvXj15enqatbu5ualJkyZKSUkpdWzt2rU1btw4PfTQQyX6HBwcJIl9mgAAQIUhaAIAALAheXl5On36tFq3bm2x38PDQ0ePHlVWVpbq1atXot/NzU1Dhw61OHbz5s2SVCLAAgAAsBZunQMAALAh2dnZkiRnZ2eL/cXtFy9evKXznjt3TvPmzZMkDRgw4PYLBAAAuAGCJgAAABtSUFAg6a/b3K5X3H4rT467ePGihg8frszMTA0aNKjU1VIAAADlRdAEAABgQxwdHSVJ+fn5Fvvz8vIkSTVr1izT+bKysvS3v/1N+/btU7du3TRhwgTrFAoAAGABQRMAAIANcXJykp2dnXJyciz2F98yV9qtddc6ceKEBg4cqP3796tHjx6Ki4uTvb29VesFAAC4FkETAACADXFwcJC7u7vS09Mt9qenp8vV1VUuLi43PM+BAwcUGhqqY8eOKSgoSHFxcapRo0YFVAwAAPAXgiYAAAAb065dO2VmZuro0aNm7RkZGUpLS9Ojjz56w/FpaWkaMmSIzp49q8GDB2vWrFmqXp2HDQMAgIpH0AQAAGBjgoKCJEkxMTEqKiqSJBmNRs2dO1dGo1EhISGlji0qKlJkZKTOnTun8PBwRUVFyWAw3ImyAQAAxJ+2AAAAbEznzp0VGBio9evXKyQkRL6+vtq9e7dSU1MVEBAgPz8/07GxsbGSpFGjRkmSvvrqK+3du1cODg6qVauWqf9aDRo00MCBA+/ItQAAgKqFoAkAAMAGvfvuu/L09NTatWuVkJAgd3d3jR49WsOGDTNboRQXFyfpr6ApJSVF0tWn0y1cuNDiuZs3b07QBAAAKgRBEwAAgA2yt7dXRESEIiIibnjcwYMHzb6eOHGiJk6cWJGlAQAAlIo9mgAAAAAAAGAVBE0AAAAAAACwCoImAAAAAAAAWAVBEwAAAAAAAKzCJoOmgoICxcfHKzAwUD4+PvL399eCBQuUn59fpvH79u3Tq6++Kl9fX7Vs2VK9evXSnDlzdPny5QquHAAAAAAAoOqyyaApOjpaM2fOlIuLi8LDw+Xm5qb58+crMjLypmN37typ0NBQbd++XV27dlVYWJhcXFy0ePFihYeHKzc39w5cAQAAAAAAQNVTvbILuN6uXbuUlJSkwMBAxcTESJKMRqOioqK0bt06bdu2TX5+fqWOj46OltFo1MqVK+Xj42MaP2XKFH388cdasWKFBg8efCcuBQAAAAAAoEqxuRVNiYmJkqSIiAhTm8Fg0NixY2UwGLRq1apSxx45ckSHDx+Wv7+/KWQqHl98vu3bt1dQ5QAAAAAAAFWbza1oSk1NVb169eTp6WnW7ubmpiZNmiglJaXUsbVr19a4ceP00EMPlehzcHCQJPZpAgAAAAAAqCA2FTTl5eXp9OnTat26tcV+Dw8PHT16VFlZWapXr16Jfjc3Nw0dOtTi2M2bN0tSiQALAAAAAAAA1mFTt85lZ2dLkpydnS32F7dfvHjxls577tw5zZs3T5I0YMCA2y8QAAAAAAAApbKpoKmgoEDSX7e5Xa+4/VaeHHfx4kUNHz5cmZmZGjRoUKmrpQAAAAAAAFA+NhU0OTo6SpLy8/Mt9ufl5UmSatasWabzZWVl6W9/+5v27dunbt26acKECdYpFAAAAAAAACXYVNDk5OQkOzs75eTkWOwvvmWutFvrrnXixAkNHDhQ+/fvV48ePRQXFyd7e3ur1gsAAAAAAIC/2FTQ5ODgIHd3d6Wnp1vsT09Pl6urq1xcXG54ngMHDig0NFTHjh1TUFCQ4uLiVKNGjQqoGAAAAAAAAMVsKmiSpHbt2ikzM1NHjx41a8/IyFBaWpoeffTRG45PS0vTkCFDdPbsWQ0ePFizZs1S9eo29XA9AAAAAACAe5LNBU1BQUGSpJiYGBUVFUmSjEaj5s6dK6PRqJCQkFLHFhUVKTIyUufOnVN4eLiioqJkMBjuRNkAAAAAAABVns0t9encubMCAwO1fv16hYSEyNfXV7t371ZqaqoCAgLk5+dnOjY2NlaSNGrUKEnSV199pb1798rBwUG1atUy9V+rQYMGGjhw4B25FgAAAAAAgKrE5oImSXr33Xfl6emptWvXKiEhQe7u7ho9erSGDRtmtkIpLi5O0l9BU0pKiqSrT6dbuHChxXM3b96coAkAAAAAAKAC2GTQZG9vr4iICEVERNzwuIMHD5p9PXHiRE2cOLEiSwMAAAAAAEApbG6PJgAAAAAAANydCJoAAAAAAABgFQRNAAAAAAAAsAqCJgAAAAAAAFgFQRMAAAAAAACsgqAJAAAAAAAAVkHQBAAAAAAAAKsgaAIAAAAAAIBVEDQBAAAAAADAKgiaAAAAAAAAYBUETQAAAAAAALAKgiYAAAAAAABYBUETAAAAAAAArIKgCQAAAAAAAFZB0AQAAAAAAACrIGgCAAAAAACAVRA0AQAAAAAAwCoImgAAAAAAAGAVBE0AAAAAAACwCoImAAAAAAAAWAVBEwAAAAAAAKyCoAkAAAAAAABWQdAEAAAAAAAAqyBoAgAAAAAAgFUQNAEAAAAAAMAqCJoAAAAAAABgFQRNAAAAAAAAsAqCJgAAAAAAAFgFQRMAAAAAAACswiaDpoKCAsXHxyswMFA+Pj7y9/fXggULlJ+fX6bx2dnZio6OVs+ePdW6dWsFBwdr/fr1FVw1AACA9fB5CAAA3I1sMmiKjo7WzJkz5eLiovDwcLm5uWn+/PmKjIy86djLly9ryJAhWrlypVq3bq1BgwbpwoULev3117V8+fI7UD0AAED58XkIAADcjapXdgHX27Vrl5KSkhQYGKiYmBhJktFoVFRUlNatW6dt27bJz8+v1PHLli3T/v379fbbb2vgwIGSpFdffVWhoaGaM2eO+vbtq/r169+JSwEAALgtfB4CAAB3K5tb0ZSYmChJioiIMLUZDAaNHTtWBoNBq1atuuH4FStWqGHDhhowYICpzcnJSS+//LKuXLmizz77rGIKBwAAsBI+DwEAgLuVzQVNqampqlevnjw9Pc3a3dzc1KRJE6WkpJQ69vjx48rIyFDbtm1VrVo1sz5fX19JuuF4AAAAW8DnIQAAcLeyqaApLy9Pp0+fVqNGjSz2e3h46Pz588rKyrLYf/z4cUlS48aNS/Q1bNhQNWrU0NGjR61XMAAAgJXxeQgAANzNbCpoys7OliQ5Oztb7C9uv3jx4g3H16lTx2K/k5NTqWMBAABsAZ+HAADA3cymNgMvKCiQJDk4OFjsL27Pzc297fFXrlyx2HfmzBkVFhbK39//lmq+HQ5Zlyv8e9wJ/ilzK7sEAABuyalTp0rcTmZrqsrnIQAAUDkq+vOQTQVNjo6OkqT8/HyL/Xl5eZKkmjVrWuyvUaOG2XGWxteqVavUsaWNs7ZG9SzXAAAAKlb16tVLDWBsRVX5PAQAACpHRX8esqmgycnJSXZ2dsrJybHYX7zMu7Sl5HXr1pWkUsfn5OSU+ijf1NTUWy0XAADA6vg8BAAA7mY2tUeTg4OD3N3dlZ6ebrE/PT1drq6ucnFxsdjfpEkT03HXO3PmjHJzc9W0aVNrlQsAAGB1fB4CAAB3M5sKmiSpXbt2yszMLPE0lIyMDKWlpenRRx8tday7u7vc3d31448/qqioyKwvOTlZktSmTRur1wwAAGBNfB4CAAB3K5sLmoKCgiRJMTExpg9HRqNRc+fOldFoVEhIyA3H9+vXT6dPn9by5ctNbTk5OVq4cKEcHR31zDPPVFjtwPUyMjL0/vvv67nnnlPnzp3VqlUr+fn5KTIy0vRhH3dObGysvL299dVXX1n1vD/88IO8vb01ffp0s/Y1a9aod+/eatmypTp37qxjx45Z9ftWRT179lT79u0ru4wqIyoqSt7e3vr1118ru5Qqx9qfhwoKCrRo0SJFRUVJkhISErRgwYJS94G6XnZ2tqKjo9WzZ0+1bt1awcHBWr9+/W1eHYoVFBQoPj5egYGB8vHxkb+//y3Ny759+/Tqq6/K19dXLVu2VK9evTRnzhxdvnxvPHimMpR3Tq5VVFSkAQMGyNvbuwIqrVrKOy+5ubmKi4tTQECAWrVqpV69emnGjBm6cOFCBVd+7yrvnBw6dEivvvqqHnvsMbVq1UpPP/20kpKSKrjqqiMjI0Pt2rVTfHx8mcdY873epvZokqTOnTsrMDBQ69evV0hIiHx9fbV7926lpqYqICBAfn5+pmNjY2MlSaNGjTK1DRs2TBs3btT06dOVkpKiRo0a6csvv9SJEyc0efJk1atX705fEqqoDRs26K233tLly5fVunVrBQYGqmbNmkpLS9OWLVv02WefKTw8XBMnTqzsUlEBDh8+rIkTJ6pWrVoaOHCgqlWrJnd398ou664XHh7ORsWoEqz9eej48eM6cOCA6dy5ubmaP3++Dh48qPnz59+wlsuXL2vIkCH69ddf1adPH91///368ssv9frrrysrK0svvPCC9X8AVUR0dLSSkpLUrl079ezZU7t27SrzvOzcuVNDhw6VJAUEBOi+++5TSkqKFi9erJ07dyoxMdG0MTzKrjxzcr34+Hj99NNPFVRp1VKeecnPz9fQoUOVnJys9u3by9/fX3v37lVCQoL27Nmj5cuX2/xDImxReebk0KFDCgkJUW5urvr27av69etr8+bNmjJlio4fP65x48bdoau4N126dEmjRo0qda9GS6z+Xm+0QXl5eca4uDijv7+/sWXLlsbevXsb4+LijLm5uWbHeXl5Gb28vEqMz8zMNE6YMMHYsWNHY+vWrY39+/c3fvbZZ3eqfMD47bffGr28vIydOnUyJicnl+jPyMgwhoSEGL28vIzr1q2rhAqrpvnz5xu9vLyMmzZtsup5d+7cafTy8jK+8847prb//Oc/Ri8vL+PcuXOt+r2AO2n8+PFGLy8v4y+//FLZpVRJ1vo81L59e6OXl5exffv2ps9DRUVFxjfffNPo5eVl3Lp16w3r+OCDD4xeXl7GFStWmNouXrxofPLJJ42tW7c2nj17tvwXWwX9+OOPRi8vL+OYMWNMbbcyL3379jU+/PDDxp9++sls/KRJk4xeXl7GDz/8sKJKv2eVd06ulZaWZvTx8Sn19YmyK++8LFmyxOjl5WWcOXOmWfvUqVONXl5exrVr11ZA1fe28s5JREREic/kOTk5xj59+hibN29uPH78eEWVfs87efKksX///qZ/e5YuXVqmcdZ+r7e5W+ckyd7eXhEREfrqq6+0d+9effHFF4qIiCiRNB88eFAHDx4sMb5BgwaaMWOGduzYoT179mjNmjV68skn71T5qOLy8vI0adIk2dnZ6YMPPtBjjz1W4pj77rtPMTExcnBw0JIlSyqhSlS04lU3rq6ulVwJgLuVtT4PdevWTZK0cuVK0+chg8GgsWPHymAwaNWqVTesY8WKFWrYsKEGDBhganNyctLLL7+sK1eu6LPPPivvpVZJiYmJkqSIiAhTW1nn5ciRIzp8+LD8/f3l4+NjNr74fNu3b6+gyu9d5ZmTaxmNRk2cOFENGjRQs2bNKqTWqqS885KYmCgPDw9FRkaatQ8ZMkT9+/dn5d9tKO+c7N27V3Xr1lWvXr1MbbVr19bTTz+toqIi7d27t2IKv8fFx8frqaee0oEDB9SxY8dbGmvt93qbDJruZampqWrevLn8/Px06dIlU3teXp4CAwPVokWL23q0cF5enhYtWqTAwEC1atVKnTp1UmRkpE6cOGE65r///a+6dOmihx9+WPv37zcbP2HCBHl7e2vhwoWSru4t4+3trW+++Ubz5s3T448/rjZt2igkJERbt269zauvGrZv364//vjDdG9rae6//3699NJLevLJJ1VYWHgHK7w7TJs2Td7e3vr2229L9O3Zs0fe3t6aOnXqbZ07NzdXMTEx6tGjh1q1aqU+ffroo48+ktFoNDvu0qVLiouL0zPPPKM2bdqoVatW6t27t/7+97+bvX6v17NnT02YMEGSNHPmTHl7e5tubbkXlXWuoqKi9PDDDysrK0tRUVHy9fVVmzZt9NJLL+n48ePKy8vT7Nmz1bVrV7Vt21ZhYWGmW32KXb9HU/G/VTt27NC//vUv9e7d27T3wvvvv89rqwIcOHBAjz32mDp06MDeTXeJ1NRU1atXT56enmbtbm5uatKkiVJSUkode/z4cWVkZKht27aqVq2aWZ+vr68k3XA8Sleeealdu7bGjRunZ599tkRfcRDJPk23rjxzcq2VK1cqOTlZ06ZNk6OjY0WUWqWUZ15+//13nTx5Uj179pS9vb1Z3wMPPKBZs2apb9++FVL3vay8r5U6deooJydH58+fN2vPyMiQxB9qb9eyZcvk4eGh5cuX39Le1BXxXk/QdIe1b99eL7zwgk6dOmX2i+e8efN0+PBhDRky5JY3us3Pz9ewYcM0d+5cOTs764UXXlC3bt20adMmPffcczp06JCkqy/Y//f//p8KCwv1//7f/zNtLvr1119rzZo1atOmjYYNG2Z27piYGP3rX/9St27d9PTTT+vYsWN65ZVX9Mknn5TzJ3HvKt5oumfPnjc9dsyYMXr55ZdLvKBxdSNbSRY3oPv8888lSU8//fRtnXv69OlKSkpS9+7d9dxzz+ncuXN65513lJCQYDqmoKBAgwcPVlxcnBo2bKjnn39ezz77rP788099+OGHGj9+fKnnDw8Pl7+/vySpa9euGjlypDp06HBbtd4NbmWujEaj/va3v2nv3r0KDg5W27Zt9e2332rEiBEaPXq0NmzYoD59+ujxxx9XcnKyhg8fritXrty0htmzZysuLk7t2rXT888/rz///FPz5s3TP//5TyteKdLS0vTSSy+pqKhIS5YsUYsWLSq7JNxEXl6eTp8+rUaNGlns9/Dw0Pnz55WVlWWx//jx45Kkxo0bl+hr2LChatSoUeLJeLi58s6Lm5ubhg4dqu7du5fo27x5sySV+AUQN1beOSl26tQpzZkzR8HBwercuXNFlFqllHdein8Peuihh/T1118rNDRUrVu3VteuXTVr1iwC2dtgjddKaGioCgsLFRkZqbS0NOXk5GjNmjX65JNP1KJFi3v6c3NFmjp1qtatW6e2bdve0riKeK+3uc3Aq4LIyEht27ZNH330kYKCgpSbm6ulS5fKy8tLr7322i2fLyEhQTt37tSIESM0duxYU3t4eLhCQkI0ceJE0/LF3r17mzYXXblypfr166fJkyerVq1a+vvf/14i8Dhw4IBWrFhheozysGHD9Nxzz2nWrFl64oknVKdOndv/Qdyjil+oDz30UCVXcndr3bq1mjRpoq+++kpTp041/RWqqKhIGzdu1AMPPHDL/4gWs7e31+rVq9WwYUNJ0nPPPadnn31Wn3zyiV588UVJ0hdffKGffvpJL7/8sl5//XXT2DfeeEN9+vTRli1bdOXKFdWsWbPE+V988UXVqVNHmzdv1uOPP246572qrHP18ccfq6ioSDVr1jTbeDM0NFS7d+9WXl6e/u///k9OTk6Srj7xbO3atUpOTrb4y9S1jh8/rnXr1ul///d/JUlhYWHq06ePkpKS9Morr1Tg1VcdGRkZGjx4sC5fvqwlS5aY3a4D25WdnS1JcnZ2tthf3H7x4kWLD0wpHl/a+72Tk5MuXrxY/kKrmPLOS2nOnTunefPmSZLZ7Q+4OWvNyZQpU1SzZk3TEx5RPuWdlzNnzkiStm7dqm3btqlbt24KDQ1VcnKyli5dqp9//lkJCQklVjuhdNZ4rQwaNEh2dnaaPn26evfubWrv0qWL/vGPf/BH+Nv0+OOP39a4inivZ0VTJahZs6amT5+uwsJCTZs2TW+99Zbs7Ow0e/bs23riwerVq1WnTh2NHj3arP2RRx5Rnz599PPPP+u3334ztRc/fW/+/PmaPHmyMjIyNH78eNMvaNcKDAw0hUyS1KhRI4WFhenChQvatm3bLddaFZw7d06S5Rfq559/rtjY2BL/HT58+E6XeVd4+umndf78eX3//femttTUVJ05c0ZPPfXUbZ93wIABppBJuvpacXd3V3p6uqnt4Ycf1jvvvKO//e1vZmOdnJzUsmVLFRYWlljuW5XdylwNHDjQ7N+6Nm3aSJJCQkJMIZMk062nJ0+evOn37927t9m/YQ888ICaNWumU6dOKTc39/YuCibZ2dkaMmSIzp07pw8++EDt2rWr7JJQRgUFBZJU6ueL4vbSXidlGc9r7NaVd14suXjxooYPH67MzEwNGjTohrfvoyRrzMm6deu0fft2TZ48WXXr1rV+kVVQeeeleFX01q1bFR0drX/+85+aMGGCVq9erT59+ujHH3/UypUrK6Dye5c1Xit79uzRokWLZG9vr6CgIIWFhalZs2b6/vvvFRcXV2I7C1SsinivZ0VTJfH19dXAgQO1YsUKSVdXSTRv3vyWz3Pp0iUdPXpUDRs21AcffFCi/+zZs5KkX3/91bTCpl69epoyZYrGjBmjDRs2mJJ9SywtW2zVqpWkq6udim+ZwV9cXV117NgxXbhwoUTf559/blrSfq0WLVqwWaQF/fr1U2xsrDZs2GBa0VJ8K1Z5/r9nKVR1cXExCzSaNm2qpk2bKjc3Vz/99JOOHj2qY8eO6ZdfftEPP/wgSez/c41bmavrl+XWqlVL0tVw6FrFm3MWb6x+I02aNCnRVvwXtby8PDb6LKc333xTZ86ckbu7OyuZ7jLF+8Pk5+db7C9+fVlanSnd/HWYl5dneg2j7Mo7L9fLysrS0KFDtX//fnXr1s20TyDKrrxzcvbsWc2cOVO9evVSnz59KqbIKqi882Jnd3VdRYsWLcxW+VWrVk1vvvmmNm7cqPXr1ys8PNyaZd/TyjsnOTk5GjFihIqKirRmzRo1bdrUdL5x48Zp+fLleuihh0r9/RTWVxHv9QRNlah3796moKn4L/q3KicnR5KUmZmpuLi4Uo+7fuVFly5dVLt2bV26dOmG39vNza1EW/FKkOLvDXMeHh7avXu3jh07VuIXsvfff9/s69jY2BvOW1XXuHFjPfroo9q8ebPy8vJkZ2enL7/8Uo888ki5grmybMxZVFSkRYsWaenSpabXT4MGDdSmTRs1atRIv/32G39tucatzFVpb1S3s6LzRmMNBoMkMU9WkJWVpe7du+vrr79WbGzsDfcog21xcnKSnZ1dqe/ZxUvhS7sFonhVRmnjc3JyVL9+fStUWrWUd16udeLECQ0dOlTHjh1Tjx49NG/ePG4Dug3lnZPo6GgVFhZqypQpFVZjVVTeeSleKf3www+X6PPw8FCdOnXMHp6EmyvvnGzevFnZ2dmKiIgwhUzS1a0tJk+erA0bNmj16tUETXdQRbzXc+tcJcnNzVV0dLQcHR3l6OioyZMn39bS8+Jf2Nq3b296vLGl/8LCwszGzZgxQ5cuXZKLi4sWLlyoI0eOWDz/n3/+WaKt+B8PFxeXW663KijeBLp4U3CUT79+/XThwgV999132rlzp7Kysm57E/Bb8eGHH+q9996Tt7e3/vnPf2rHjh367rvvFBcXJw8Pjwr//nejyporVLypU6cqNjZWjRs3VkJCgn755ZfKLgll5ODgUOLW4Gulp6fL1dW11Pf04tWClsafOXNGubm5Zr8ooGzKOy/FDhw4oNDQUB07dkxBQUGKi4tjBedtKu+cfPHFF7p48aK6desmb29v03/FT3r29vYu04NiYM5a/4YV3xp0vYKCAp4MeIvKOyenT5+WJIt/NK5fv75cXV116tQpq9WLm6uI93qCpkoyb948HTlyRBERERoxYoSOHDlyW48/d3Z2loeHh37//XeLQdW6desUGxtrltR//fXXWrt2rbp27aoFCxYoLy9Pb731lukpdNf6+eefS7Tt3r1bkrh9ohQ9e/bU//zP/2jTpk1KTU294bGWfuYwFxgYKHt7e23evFkbN26UnZ2dAgMDK/z7/uc//1G1atX0wQcfqHv37qbNDI1Go2lPLVbKmKusuULFe+SRR1SjRg1NmjRJhYWFpv/F3aFdu3bKzMws8cSYjIwMpaWlme3FeD13d3e5u7vrxx9/LPGelZycLOn2V2VXdeWZF+nqUyCHDBmis2fPavDgwZo1a5aqV+dmhfIoz5yMHDnS4n/FdwKMHDmS27NuU3nmxcfHRw4ODkpJSSnxvnX48GFdvnz5trYvqerKMyfFK2MsPcXs/Pnzys7OVoMGDaxaL26sIt7rCZoqwc8//6z4+Hh5eXlp8ODBGjp0qB588EF9+OGHFoOdm+nfv7+ys7M1d+5cs198f//9d0VHR+vDDz80JcoXL17UlClT5OjoqLffflvt27dXcHCwdu/erWXLlpU498cff2y2UXVaWpoSEhLUsGFDdenS5dYvvgpwdHTU3//+d0lSRESExZVN+fn5SkxMVHx8vKS/bvFBSa6ururatau2bdumrVu3qmPHjhZv6bQ2R0dHFRYWlng06/vvv28Kbkv761hVVVlzhTune/fueuKJJ7R//3599NFHlV0OyigoKEiSFBMTY/oAaTQaTZ8bQkJCbji+X79+On36tJYvX25qy8nJ0cKFC+Xo6Khnnnmmwmq/l5VnXoqKihQZGalz584pPDxcUVFRfJawgvLMyahRoyz+d99995n67/Wn0FaU8syLs7Oz+vbtqz/++EOLFy82tefn52v27NmSpODg4Ior/h5Vnjnp0aOH6QnE1y6GKCws1KxZs2Q0GvXkk09WaP0oydrv9fzZ4w7Ly8vThAkTVFRUZPYY8KlTpyosLEwTJ07UJ598ckt7lQwfPlzffPON4uPjlZKSoscee0wXLlzQxo0bdeXKFc2aNct0j+yMGTN0+vRpRUZGqlGjRpKkcePGacuWLYqJiVGPHj3MNkq2s7PTgAED1KdPHxmNRn355Zf6888/FRcXV+YNKquijh07auHChRo/frzp/uMOHTqobt26OnXqlL755htlZ2erdu3aioqKkp+fX2WXbNP69eunrVu3SpIiIyPv2Pfcs2ePBg4cqL59+8re3l4//PCD9u/fr/r16+vcuXOmR4HiL5UxV7izJk6cqO+++07z5s1TQECA7r///souCTfRuXNnBQYGav369QoJCZGvr692796t1NRUBQQEmL0HFa+uHjVqlKlt2LBh2rhxo6ZPn66UlBQ1atRIX375pU6cOGF6ki1uXXnm5auvvtLevXvl4OCgWrVqWVwV36BBAw0cOPCOXMu9oryvFVSM8s7L+PHjtWfPHsXExCglJUVeXl7asWOHfv31VwUGBpq2vUDZlWdO6tevr8mTJ2vSpEl65plnFBAQoDp16mjnzp06cOCAOnToQChbwe7Eez1B0x0WGxur33//XSEhIWrbtq2pvUOHDgoODtaaNWv0/vvva8yYMWU+Z40aNbRs2TItWbJE69ev14oVK+Ts7Ky2bdtq+PDh8vX1lSR98803WrNmjWklVTFXV1eNHz9eUVFRmjhxotlfqV9++WWdP39eH3/8sXJzc/Xoo49q1KhRN13Ojat/+d+wYYM+/fRTffnll9qyZYuys7NVt25dPfzww+revbueffbZMm30WdX5+/vLyclJ+fn56t279x35ns8//7wkacWKFVq1apWcnZ3VtGlTzZ07VzVq1FBERIS+/vprbhm5TmXMFe6s+++/X6+++qrmzJmjqVOnauHChZVdEsrg3Xfflaenp9auXauEhAS5u7tr9OjRGjZsmNlKmOIHVFz74dPJyUmJiYmaO3eutm7dqm+++UYPPvig5s6dy1+dy+l25yUlJUXS1T9glvYabN68OUHTbSjPawUVpzzzUr9+fSUlJWnBggXatGmTkpOT5eHhoXHjxpn9ToRbU545efbZZ+Xh4aHFixdr06ZN+vPPP9WoUSO99tprGjp0aLkeEIObuxPv9QYjm4zAgjVr1mjChAmaMGECiTIAAAAAACgT9mgCAAAAAACAVXDrnI1JT0/X2rVry3x8r1691KJFiwqsCLBNvFYAAAAAwPYQNNmYkydPmu6ZLAsPDw9+eUaVxGsFAAAAAGwPezQBAAAAAADAKtijCQAAAAAAAFZB0AQAAAAAAACrIGgCAAAAAACAVRA0AQAAAAAAwCoImgAAAAAAAGAVBE1AFZKeni5vb2+FhYVVdikW7dixQ3v37q3sMu5KGzZs0IkTJyq7DAAAAABVHEETAJvw73//Wy+++KIyMjIqu5S7zj/+8Q+NGTNGOTk5lV0KAAAAgCqOoAmATcjMzKzsEu5a/OwAAAAA2AqCJgAAAAAAAFgFQRNQxRXv2xQbG6vNmzfrueeek4+Pjzp16qRJkyYpKyvL7Hhvb2+98cYb2rFjh4KDg+Xj46OePXsqJiZGubm5JY595plnSnzPNWvWyNvbW/Hx8ZKksLAwxcXFSZIiIiLk7e19w5rDwsLUrVs3paena/jw4WrTpo06d+6scePG6Y8//ihx/MGDBzVu3Dh1795dLVu2VNu2bRUaGqoNGzaYHRcVFSVvb2/99NNPCggIUKtWrRQaGiqj0ShJ2rJli4YOHaqOHTvqkUceUceOHfXKK69o//79Jep74okndOLECUVERKhdu3Zq3769XnvtNWVlZenChQuaPHmyfH191aFDB7388stKT08vUff+/fv16quvytfXVz4+PnrmmWe0cuVKUz2S1LNnT61du1aSFBQUpJ49e5r6jEajVq5cqf79+8vHx0ePPfaYXn75Zf3yyy8W52P9+vUKDw9Xy5Yt1aNHD/Z8AgAAAHDLqld2AQBsw9atW/X+++/Lz89Pvr6++u6777Rq1SqdPHlSS5cuNTv24MGDGjZsmNq0aaNBgwZp586dWrhwofbs2aOlS5fKzu7WMuz+/ftLkpKTkxUYGKgHH3zwpmP+/PNPhYeHy97eXqGhoTpy5Ij+7//+Tz/88INWrVolNzc3SdLPP/+ssLAwOTg4qHfv3qpXr57S0tK0efNmjRkzRg4ODvL39zc79yuvvKLWrVurW7duqlWrlgwGgz766CO98847aty4sZ566inZ29tr79692rJli3bu3KmNGzeavqck5eTk6Pnnn9f999+vkJAQ/fjjj9q4caOysrJ0+fJl5ebmqn///vrtt9+0detWnTlzRqtXrzb97L7++muNHDlS9vb2CggIkKurq7799lu9/fbb+uWXXzRt2jRJUnh4uNauXasDBw4oJCTE7Gc3fvx4ffrpp/Ly8lJoaKiuXLmiDRs2KDQ0VIsWLVKnTp3Mrvudd96Rm5ubwsPDlZ6erkaNGt3SPAIAAAAAQRMASVdXz7z33nvq27evJGnMmDHq37+/vv/+ex0/flyNGzc2HXvo0CENGjRIU6ZMkSQVFBRo7Nix+uKLL7Ru3ToFBwff0vcODg7WyZMnlZycrCeffFK9evW66Zjz58+rcePGWr58uRwdHSVJCQkJmjFjhmJiYjRr1ixJ0rx581RQUKA1a9aoWbNmpvEbN27Ua6+9ps8//7xE0NSuXTvFxsaavs7Ly9N7772nJk2aaO3atapVq5apLzo6WomJidq6datCQ0NN7VlZWXriiScUGxsrg8GggoICPfHEE0pOTlabNm20cuVKOTg4SLq6Aio5OVlHjhyRp6enrly5oqioKNWpU0erVq2Su7u7JOmNN97Q2LFj9fHHH6tXr17q3r27XnzxRR04cEAHDhzQwIED1aJFC0lXn0L36aefql+/fpo1a5aqVasmSRoxYoSeffZZRUVF6auvvpK9vb2pZnt7e61YsUI1a9Ysw6wBAAAAQEncOgdAktSoUSNTyCRdDR2KV7wcO3bM7NhatWrptddeM31dvXp1vfnmmzIYDPrPf/5zR+qVpLFjx5pCJulqYNO4cWN98cUXysvLkyS9+OKLmj17tlnIJEkdO3aUpBK3BkpS7969zb4uLCzUtGnTNH36dLOQ6WbnCQ8Pl8FgkHT1Z9SqVStTncUhkyS1bt1aknTy5ElJV2/Ry8rK0ksvvWQKmSTJzs5Or7/+uiTpk08+sfxD+f+tXr1akjRhwgRTyCRJDzzwgEJDQ3X69Gl99913ZmO6detGyAQAAACgXFjRBECS1KRJkxJtzs7OkmQKbYp5e3urbt26Zm0PPPCA6tWrpwMHDlRYjdcyGAxq3769WZudnZ0eeeQRbdiwQcePH5enp6cef/xxSVefzHbgwAEdP35chw8f1u7duyVdDZGu98ADD5h9XbNmTQUGBkqSjh49qsOHD+v48eM6dOiQfvjhB0lSUVFRifP87//+r9nXxSHV9eevUaOGJCk/P1+StG/fPtP/Xruyqli1atVu+nPev3+/atSoocTExBJ9R48elST9+uuv8vPzM7VfXxcAAAAA3CqCJgCSZLbCpljxapzrXbsX0bUaNGigI0eOWLWu0ri6ulqsuUGDBpKkixcvSpJOnTqladOmacuWLTIajapWrZqaNGmi9u3bl9gUu9i1q6SKpaSkaObMmaaNvx0dHeXt7a2WLVvqjz/+MNugu1hpq4Ms1X2t4to///zzUo85f/78Tc9RUFBg2mS9LOcoDrwAAAAA4HYRNAG4Zdc/Xa5YTk6OXFxczNosBTBXrlwpdw1//vlnqTVIkouLi4xGo4YPH67ff/9dw4YNU0BAgLy8vOTg4KCsrCwlJSWV6XudPHlSw4YNk4ODg6ZOnaoOHTqoSZMmsrOz08aNG/Xll1+W+3quVbzyKT4+vsSG3bdyjtq1a2vbtm1WrAwAAAAAbow9mgDcsn379pW4VSwjI0N//PGHfHx8TG329va6fPlyifHHjx8v0Vba6qnSXL58WYcPHy7Rvnv3brm4uKhx48Y6cOCADh06pCeeeEKRkZFq2bKlaTXR77//LslyEHa9TZs26cqVK3rttdcUGhqqBx980PR0uFs5T1k1b95ckkyrp66VnZ2t6dOna926daY2Sz+75s2b6/Tp0zp79myJvq1btyomJuaO3eYIAAAAoOogaAJwyzIzM7VkyRLT1/n5+ZoxY4aMRqPZE+cefPBBpaen67fffjO1nTx50iwkKVa8YXXxPkVlMWfOHLP9oxISEnTs2DH169dP1apVM90Kdu7cObNx2dnZ+vvf/y7p6hPzbqb4VrrrQ5sDBw4oISGhzOcpqyeeeEJOTk5avHix0tLSzPpmz56tZcuWmbVb+tn1799fRqNR06ZNM/sZnTlzRm+//bYWLVrExt8AAAAArI5b5wDcstq1a2v+/Pn64Ycf1KxZM+3cuVMHDx7UU089pV69epmOGzBggKZNm6bw8HA99dRTys3N1YYNG+Tl5aXU1FSzc/7P//yPJGnhwoX65ZdfNHLkyJvuGbRr1y49++yz6tSpkw4fPqxvv/1Wnp6eGj16tCSpadOm8vHxUWpqqp5//nm1bdtW//3vf/XVV18pLy9PNWvW1H//+9+bXm+PHj30j3/8Q4sWLdKRI0fUuHFjpaWlaevWraYN07Ozs2/lR3hDzs7Oeuedd/TGG2/omWeeUa9evXTfffcpOTlZe/fu1SOPPKKXXnrJdHzxz+7dd99Vx44dNXLkSPXv31+bN2/Wxo0bdfDgQXXt2lUFBQXasGGDsrOzNWbMmBKblQMAAABAebGiCcAta9SokZYsWaLMzEz9+9//VkFBgd566y3Nnj3b7LgXXnhBb731lurUqaOVK1dqx44dGjFihN56660S5wwMDFTfvn2VlpamFStW6OTJkzetIyEhQffdd5+SkpL022+/KTw8XCtXrjSFPwaDQe+//76Cg4OVnp6uZcuWKSUlRd26ddMnn3yiLl266NixYxZv5buWm5ubli5dqk6dOmnnzp1KTEzU0aNHFRYWpg0bNsjFxUXffPONVW+f69u3r5YvX66OHTvqm2++0fLly3Xp0iW98sorSkhIkJOTk+nY559/Xl26dNHPP/+sjz76SJcuXZLBYND8+fM1ceJEOTo6atWqVdqwYYM8PT0VGxurV155xWq1AgAAAEAxg9GavxkBuOd5e3urefPm+vTTTyuthrCwMCUnJyslJUV16tSptDoAAAAAAOZY0QQAAAAAAACrIGgCAAAAAACAVRA0AQAAAAAAwCrYowkAAAAAAABWwYomAAAAAAAAWAVBEwAAAAAAAKyCoAkAAAAAAABWQdAEAAAAAAAAqyBoAgAAAAAAgFUQNAEAAAAAAMAqCJoAAAAAAABgFQRNAAAAAAAAsAqCJgAAAAAAAFjF/weJm4GRrpwndAAAAABJRU5ErkJggg==", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -2078,19 +2064,19 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 38, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:10:10.227584Z", - "start_time": "2022-01-10T20:10:09.832865Z" + "end_time": "2023-08-03T11:58:23.209868Z", + "start_time": "2023-08-03T11:58:22.459782Z" } }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -2110,19 +2096,19 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 39, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:10:10.998304Z", - "start_time": "2022-01-10T20:10:10.229541Z" + "end_time": "2023-08-03T11:58:24.428272Z", + "start_time": "2023-08-03T11:58:23.212055Z" } }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -2149,11 +2135,11 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 40, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:12:35.889556Z", - "start_time": "2022-01-10T20:12:35.445653Z" + "end_time": "2023-08-03T11:58:25.951160Z", + "start_time": "2023-08-03T11:58:24.430789Z" } }, "outputs": [ @@ -2161,7 +2147,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2022-07-06 20:57:53,268 - climada.engine.unsequa.calc_base - INFO - Effective number of made samples: 1000\n" + "2023-08-03 13:58:25,948 - climada.engine.unsequa.calc_base - INFO - Effective number of made samples: 1000\n" ] } ], @@ -2175,19 +2161,19 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 41, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:12:37.901378Z", - "start_time": "2022-01-10T20:12:36.891469Z" + "end_time": "2023-08-03T11:58:28.073212Z", + "start_time": "2023-08-03T11:58:25.954868Z" } }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -2200,11 +2186,11 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 42, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:12:44.098243Z", - "start_time": "2022-01-10T20:12:38.756106Z" + "end_time": "2023-08-03T11:58:38.966759Z", + "start_time": "2023-08-03T11:58:28.076017Z" }, "scrolled": true }, @@ -2213,624 +2199,609 @@ "name": "stdout", "output_type": "stream", "text": [ - "2022-07-06 21:17:20,981 - climada.engine.unsequa.calc_base - INFO - Effective number of made samples: 1000\n", - " ... \n", - "2022-07-06 21:17:21,044 - climada.engine.unsequa.calc_base - INFO - \n", + "2023-08-03 13:58:29,176 - climada.engine.unsequa.calc_base - INFO - Effective number of made samples: 1000\n", + "2023-08-03 13:58:29,183 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2023-08-03 13:58:29,186 - climada.engine.impact_calc - INFO - Calculating impact for 250 assets (>0) and 216 events.\n", + "2023-08-03 13:58:29,187 - climada.engine.impact_calc - INFO - cover and/or deductible columns detected, going to calculate insured impact\n", + "2023-08-03 13:58:29,199 - climada.engine.impact - WARNING - The Impact.tot_value attribute is deprecated.Use Exposures.affected_total_value to calculate the affected total exposure value based on a specific hazard intensity threshold\n", + "2023-08-03 13:58:29,200 - climada.engine.unsequa.calc_base - INFO - \n", "\n", - "Estimated computaion time: 0:00:02.412500\n", + "Estimated computaion time: 0:00:05.650000\n", "\n", - " ... \n", - "2022-07-06 21:17:21,263 - climada.entity.impact_funcs.base - WARNING - For intensity = 0, mdd != 0 or paa != 0. Consider shifting the origin of the intensity scale. In impact.calc the impact is always null at intensity = 0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:21,375 - climada.entity.impact_funcs.base - WARNING - For intensity = 0, mdd != 0 or paa != 0. Consider shifting the origin of the intensity scale. In impact.calc the impact is always null at intensity = 0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:21,440 - climada.entity.impact_funcs.base - WARNING - For intensity = 0, mdd != 0 or paa != 0. Consider shifting the origin of the intensity scale. In impact.calc the impact is always null at intensity = 0.\n" + "Time passed with pool: 9.783061027526855\n" ] - }, + } + ], + "source": [ + "# Compute also the distribution of the metric `eai_exp`\n", + "# To speed-up the comutations, we can use more than one process \n", + "# Note that for large dataset a single process might be more efficient\n", + "import time\n", + "\n", + "calc_imp2 = CalcImpact(exp_iv, impf_iv, haz)\n", + "output_imp2 = calc_imp2.make_sample(N=1000, sampling_method='latin')\n", + "\n", + "start = time.time()\n", + "output_imp2 = calc_imp2.uncertainty(output_imp2, rp = [50, 100, 250], calc_eai_exp=True, calc_at_event=True, processes=4)\n", + "end = time.time()\n", + "time_passed = end-start\n", + "print(f'Time passed with pool: {time_passed}')" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T11:58:38.980434Z", + "start_time": "2023-08-03T11:58:38.971826Z" + } + }, + "outputs": [], + "source": [ + "from climada.engine.unsequa import CalcImpact\n", + "import time" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T11:58:53.470000Z", + "start_time": "2023-08-03T11:58:38.984769Z" + } + }, + "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - " ... \n", - "2022-07-06 21:17:21,478 - climada.entity.impact_funcs.base - WARNING - For intensity = 0, mdd != 0 or paa != 0. Consider shifting the origin of the intensity scale. In impact.calc the impact is always null at intensity = 0.\n" + "2023-08-03 13:58:40,759 - climada.engine.unsequa.calc_base - INFO - Effective number of made samples: 1000\n", + "2023-08-03 13:58:40,770 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2023-08-03 13:58:40,773 - climada.engine.impact_calc - INFO - Calculating impact for 250 assets (>0) and 216 events.\n", + "2023-08-03 13:58:40,775 - climada.engine.impact_calc - INFO - cover and/or deductible columns detected, going to calculate insured impact\n", + "2023-08-03 13:58:40,787 - climada.engine.impact - WARNING - The Impact.tot_value attribute is deprecated.Use Exposures.affected_total_value to calculate the affected total exposure value based on a specific hazard intensity threshold\n", + "2023-08-03 13:58:40,788 - climada.engine.unsequa.calc_base - INFO - \n", + "\n", + "Estimated computaion time: 0:00:26.300000\n", + "\n", + "Time passed without pool: 12.707012176513672\n" ] - }, + } + ], + "source": [ + "calc_imp2 = CalcImpact(exp_iv, impf_iv, haz)\n", + "output_imp2 = calc_imp2.make_sample(N=1000, sampling_method='latin')\n", + "\n", + "start2 = time.time()\n", + "output_imp2 = calc_imp2.uncertainty(output_imp2, rp = [50, 100, 250], calc_eai_exp=True, calc_at_event=True)\n", + "end2 = time.time()\n", + "time_passed_nopool = end2-start2\n", + "print(f'Time passed without pool: {time_passed_nopool}')" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T11:58:53.489875Z", + "start_time": "2023-08-03T11:58:53.473025Z" + } + }, + "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - " ... \n", - "2022-07-06 21:17:21,573 - climada.engine.impact - INFO - Calculating damage for 50 assets (>0) and 216 events.\n" + "2023-08-03 13:58:53,476 - climada.engine.impact_calc - INFO - Calculating impact for 250 assets (>0) and 216 events.\n", + "2023-08-03 13:58:53,478 - climada.engine.impact_calc - INFO - cover and/or deductible columns detected, going to calculate insured impact\n" ] + } + ], + "source": [ + "# Add the original value of the impacts (without uncertainty) to the uncertainty plot\n", + "from climada.engine import ImpactCalc\n", + "imp = ImpactCalc(exp_base, impf_func(), haz).impact(assign_centroids=False)\n", + "aai_agg_o = imp.aai_agg\n", + "freq_curve_o = imp.calc_freq_curve([50, 100, 250]).impact\n", + "orig_list = [aai_agg_o] + list(freq_curve_o) +[1]" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T11:58:55.128642Z", + "start_time": "2023-08-03T11:58:53.492920Z" }, + "code_folding": [] + }, + "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:21,614 - climada.entity.impact_funcs.base - WARNING - For intensity = 0, mdd != 0 or paa != 0. Consider shifting the origin of the intensity scale. In impact.calc the impact is always null at intensity = 0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:21,690 - climada.entity.impact_funcs.base - WARNING - For intensity = 0, mdd != 0 or paa != 0. Consider shifting the origin of the intensity scale. In impact.calc the impact is always null at intensity = 0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:21,775 - climada.engine.impact - INFO - Calculating damage for 50 assets (>0) and 216 events.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:21,840 - climada.engine.impact - INFO - Exposures matching centroids found in centr_TC\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:21,911 - climada.engine.impact - INFO - Calculating damage for 50 assets (>0) and 216 events.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:21,968 - climada.entity.impact_funcs.base - WARNING - For intensity = 0, mdd != 0 or paa != 0. Consider shifting the origin of the intensity scale. In impact.calc the impact is always null at intensity = 0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:22,040 - climada.engine.impact - INFO - Exposures matching centroids found in centr_TC\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:22,130 - climada.engine.impact - INFO - Exposures matching centroids found in centr_TC\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:22,195 - climada.engine.impact - INFO - Calculating damage for 50 assets (>0) and 216 events.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:22,282 - climada.engine.impact - INFO - Calculating damage for 50 assets (>0) and 216 events.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:22,371 - climada.entity.impact_funcs.base - WARNING - For intensity = 0, mdd != 0 or paa != 0. Consider shifting the origin of the intensity scale. In impact.calc the impact is always null at intensity = 0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:22,432 - climada.engine.impact - INFO - Calculating damage for 50 assets (>0) and 216 events.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:22,496 - climada.entity.impact_funcs.base - WARNING - For intensity = 0, mdd != 0 or paa != 0. Consider shifting the origin of the intensity scale. In impact.calc the impact is always null at intensity = 0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:22,568 - climada.engine.impact - INFO - Calculating damage for 50 assets (>0) and 216 events.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:22,639 - climada.entity.impact_funcs.base - WARNING - For intensity = 0, mdd != 0 or paa != 0. Consider shifting the origin of the intensity scale. In impact.calc the impact is always null at intensity = 0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:22,703 - climada.engine.impact - INFO - Exposures matching centroids found in centr_TC\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:22,762 - climada.entity.impact_funcs.base - WARNING - For intensity = 0, mdd != 0 or paa != 0. Consider shifting the origin of the intensity scale. In impact.calc the impact is always null at intensity = 0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:22,847 - climada.engine.impact - INFO - Calculating damage for 50 assets (>0) and 216 events.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:22,920 - climada.engine.impact - INFO - Exposures matching centroids found in centr_TC\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:22,996 - climada.entity.impact_funcs.base - WARNING - For intensity = 0, mdd != 0 or paa != 0. Consider shifting the origin of the intensity scale. In impact.calc the impact is always null at intensity = 0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:23,087 - climada.engine.impact - INFO - Exposures matching centroids found in centr_TC\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:23,189 - climada.engine.impact - INFO - Exposures matching centroids found in centr_TC\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:23,273 - climada.engine.impact - INFO - Calculating damage for 50 assets (>0) and 216 events.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:23,347 - climada.engine.impact - INFO - Calculating damage for 50 assets (>0) and 216 events.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:23,442 - climada.engine.impact - INFO - Calculating damage for 50 assets (>0) and 216 events.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:23,518 - climada.entity.impact_funcs.base - WARNING - For intensity = 0, mdd != 0 or paa != 0. Consider shifting the origin of the intensity scale. In impact.calc the impact is always null at intensity = 0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:23,598 - climada.engine.impact - INFO - Calculating damage for 50 assets (>0) and 216 events.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:23,678 - climada.engine.impact - INFO - Exposures matching centroids found in centr_TC\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:23,756 - climada.engine.impact - INFO - Calculating damage for 50 assets (>0) and 216 events.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:23,824 - climada.engine.impact - INFO - Calculating damage for 50 assets (>0) and 216 events.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:23,892 - climada.entity.impact_funcs.base - WARNING - For intensity = 0, mdd != 0 or paa != 0. Consider shifting the origin of the intensity scale. In impact.calc the impact is always null at intensity = 0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:23,967 - climada.engine.impact - INFO - Exposures matching centroids found in centr_TC\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:24,049 - climada.engine.impact - INFO - Calculating damage for 50 assets (>0) and 216 events.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:24,114 - climada.engine.impact - INFO - Calculating damage for 50 assets (>0) and 216 events.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:24,227 - climada.entity.impact_funcs.base - WARNING - For intensity = 0, mdd != 0 or paa != 0. Consider shifting the origin of the intensity scale. In impact.calc the impact is always null at intensity = 0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:24,311 - climada.engine.impact - INFO - Calculating damage for 50 assets (>0) and 216 events.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:24,407 - climada.entity.impact_funcs.base - WARNING - For intensity = 0, mdd != 0 or paa != 0. Consider shifting the origin of the intensity scale. In impact.calc the impact is always null at intensity = 0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:24,473 - climada.entity.impact_funcs.base - WARNING - For intensity = 0, mdd != 0 or paa != 0. Consider shifting the origin of the intensity scale. In impact.calc the impact is always null at intensity = 0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:24,560 - climada.engine.impact - INFO - Exposures matching centroids found in centr_TC\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:24,644 - climada.entity.impact_funcs.base - WARNING - For intensity = 0, mdd != 0 or paa != 0. Consider shifting the origin of the intensity scale. In impact.calc the impact is always null at intensity = 0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:24,716 - climada.engine.impact - INFO - Exposures matching centroids found in centr_TC\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:24,805 - climada.entity.impact_funcs.base - WARNING - For intensity = 0, mdd != 0 or paa != 0. Consider shifting the origin of the intensity scale. In impact.calc the impact is always null at intensity = 0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:24,887 - climada.entity.impact_funcs.base - WARNING - For intensity = 0, mdd != 0 or paa != 0. Consider shifting the origin of the intensity scale. In impact.calc the impact is always null at intensity = 0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:24,960 - climada.engine.impact - INFO - Calculating damage for 50 assets (>0) and 216 events.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:25,028 - climada.entity.impact_funcs.base - WARNING - For intensity = 0, mdd != 0 or paa != 0. Consider shifting the origin of the intensity scale. In impact.calc the impact is always null at intensity = 0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:25,108 - climada.entity.impact_funcs.base - WARNING - For intensity = 0, mdd != 0 or paa != 0. Consider shifting the origin of the intensity scale. In impact.calc the impact is always null at intensity = 0.\n" - ] - }, + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot the aai_agg and freq_curve uncertainty only\n", + "# use logarithmic x-scale\n", + "output_imp2.plot_uncertainty(metric_list=['aai_agg', 'freq_curve'], orig_list=orig_list, log=True, figsize=(12,8));" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T12:00:06.079414Z", + "start_time": "2023-08-03T11:58:55.131655Z" + } + }, + "outputs": [], + "source": [ + "# Use the method 'rbd_fast' which is recommend in pair with 'latin'. In addition, change one of the kwargs \n", + "# (M=15) of the salib sampling method.\n", + "output_imp2 = calc_imp2.sensitivity(output_imp2, sensitivity_method='rbd_fast', sensitivity_kwargs = {'M': 15})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since we computed the distribution and sensitivity indices for the total impact at each exposure point, we can plot a map of the largest sensitivity index in each exposure location. For every location, the most sensitive parameter is `v_half`, meaning that the average annual impact at each location is most sensitivity to the ucnertainty in the impact function slope scaling parameter." + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T12:00:12.112044Z", + "start_time": "2023-08-03T12:00:06.099744Z" + } + }, + "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:25,184 - climada.entity.impact_funcs.base - WARNING - For intensity = 0, mdd != 0 or paa != 0. Consider shifting the origin of the intensity scale. In impact.calc the impact is always null at intensity = 0.\n" - ] - }, + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "output_imp2.plot_sensitivity_map();" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T12:00:12.133901Z", + "start_time": "2023-08-03T12:00:12.115402Z" + } + }, + "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-07-06 21:17:25,310 - climada.engine.impact - INFO - Calculating damage for 50 assets (>0) and 216 events.\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", + "
metricparamparam2si
4545v_halfNone0.472143
4646v_halfNone0.472143
4747v_halfNone0.472143
4848v_halfNone0.467659
4949v_halfNone0.472143
\n", + "
" + ], + "text/plain": [ + " metric param param2 si\n", + "45 45 v_half None 0.472143\n", + "46 46 v_half None 0.472143\n", + "47 47 v_half None 0.472143\n", + "48 48 v_half None 0.467659\n", + "49 49 v_half None 0.472143" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "output_imp2.get_largest_si(salib_si='S1', metric_list=['eai_exp']).tail()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## CalcCostBenefit" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2021-09-23T14:32:01.173184Z", + "start_time": "2021-09-23T14:32:01.169411Z" + } + }, + "source": [ + "The uncertainty and sensitivity analysis for CostBenefit is completely analogous to the Impact case. It is slightly more complex as there are more input variables." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Set the Input Vars " + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T12:00:12.180767Z", + "start_time": "2023-08-03T12:00:12.138310Z" + } + }, + "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - " ... \n", - "Time passed with pool: 4.468854188919067\n" + "2023-08-03 14:00:12,145 - climada.hazard.base - INFO - Reading /Users/ckropf/climada/demo/data/tc_fl_1990_2004.h5\n" ] } ], "source": [ - "# Compute also the distribution of the metric `eai_exp`\n", - "# To speed-up the comutations, we use a ProcessPool for parallel computations\n", - "from pathos.pools import ProcessPool as Pool\n", - "import time\n", + "import copy\n", + "from climada.util.constants import ENT_DEMO_TODAY, ENT_DEMO_FUTURE, HAZ_DEMO_H5\n", + "from climada.entity import Entity\n", + "from climada.hazard import Hazard\n", + "\n", + "# Entity today has an uncertainty in the total asset value\n", + "def ent_today_func(x_ent):\n", + " #In-function imports needed only for parallel computing on Windows\n", + " from climada.entity import Entity \n", + " from climada.util.constants import ENT_DEMO_TODAY \n", + " entity = Entity.from_excel(ENT_DEMO_TODAY)\n", + " entity.exposures.ref_year = 2018\n", + " entity.exposures.gdf.value *= x_ent\n", + " return entity\n", "\n", - "calc_imp2 = CalcImpact(exp_iv, impf_iv, haz)\n", - "output_imp2 = calc_imp2.make_sample(N=1000, sampling_method='latin')\n", + "# Entity in the future has a +- 10% uncertainty in the cost of all the adapatation measures\n", + "def ent_fut_func(m_fut_cost):\n", + " #In-function imports needed only for parallel computing on Windows\n", + " from climada.entity import Entity \n", + " from climada.util.constants import ENT_DEMO_FUTURE \n", + " entity = Entity.from_excel(ENT_DEMO_FUTURE)\n", + " entity.exposures.ref_year = 2040 \n", + " for meas in entity.measures.get_measure('TC'):\n", + " meas.cost *= m_fut_cost\n", + " return entity\n", "\n", - "start = time.time()\n", - "pool = Pool()\n", - "output_imp2 = calc_imp2.uncertainty(output_imp2, rp = [50, 100, 250], calc_eai_exp=True, calc_at_event=True, pool=pool)\n", - "pool.close() #Do not forget to close your pool!\n", - "pool.join()\n", - "pool.clear()\n", - "end = time.time()\n", - "time_passed = end-start\n", - "print(f'Time passed with pool: {time_passed}')" + "haz_base = Hazard.from_hdf5(HAZ_DEMO_H5)\n", + "# The hazard intensity in the future is also uncertainty by a multiplicative factor\n", + "def haz_fut(x_haz_fut, haz_base):\n", + " #In-function imports needed only for parallel computing on Windows\n", + " import copy \n", + " from climada.hazard import Hazard \n", + " from climada.util.constants import HAZ_DEMO_H5 \n", + " haz = copy.deepcopy(haz_base)\n", + " haz.intensity = haz.intensity.multiply(x_haz_fut)\n", + " return haz\n", + "from functools import partial\n", + "haz_fut_func = partial(haz_fut, haz_base=haz_base)\n" ] }, { - "cell_type": "code", - "execution_count": 23, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "from climada.engine.unsequa import CalcImpact\n", - "import time" + "Check that costs for measures are changed as desired." ] }, { "cell_type": "code", - "execution_count": 24, - "metadata": {}, + "execution_count": 51, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T12:00:12.789398Z", + "start_time": "2023-08-03T12:00:12.184147Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "2022-07-06 21:17:06,510 - climada.engine.unsequa.calc_base - INFO - Effective number of made samples: 1000\n", - " ... \n", - "2022-07-06 21:17:06,522 - climada.engine.unsequa.calc_base - INFO - \n", "\n", - "Estimated computaion time: 0:00:10.200000\n", - "\n", - "Time passed without pool: 4.289993047714233\n" + "The cost for m_fut_cost=1 are [1311768360.8515418, 1728000000.0, 8878779433.630093, 9200000000.0]\n", + "The cost for m_fut_cost=0.5 are [655884180.4257709, 864000000.0, 4439389716.815046, 4600000000.0]\n" ] } ], "source": [ - "calc_imp2 = CalcImpact(exp_iv, impf_iv, haz)\n", - "output_imp2 = calc_imp2.make_sample(N=1000, sampling_method='latin')\n", - "\n", - "start2 = time.time()\n", - "output_imp2 = calc_imp2.uncertainty(output_imp2, rp = [50, 100, 250], calc_eai_exp=True, calc_at_event=True)\n", - "end2 = time.time()\n", - "time_passed_nopool = end2-start2\n", - "print(f'Time passed without pool: {time_passed_nopool}')" + "costs_1 = [meas.cost for meas in ent_fut_func(1).measures.get_measure('TC')]\n", + "costs_05 = [meas.cost for meas in ent_fut_func(0.5).measures.get_measure('TC')]\n", + "print(f\"\\nThe cost for m_fut_cost=1 are {costs_1}\\n\"\n", + " f\"The cost for m_fut_cost=0.5 are {costs_05}\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define the InputVars" ] }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 52, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:12:47.708117Z", - "start_time": "2022-01-10T20:12:47.690068Z" + "end_time": "2023-08-03T12:00:12.802267Z", + "start_time": "2023-08-03T12:00:12.793743Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ... \n", - "2022-01-10 21:12:47,699 - climada.engine.impact - INFO - Calculating damage for 50 assets (>0) and 216 events.\n" - ] - } - ], + "outputs": [], "source": [ - "# Add the original value of the impacts (without uncertainty) to the uncertainty plot\n", - "from climada.engine import ImpactCalc\n", - "imp = ImpactCalc(exp_base, impf_func(), haz).impact(assign_centroids=False)\n", - "aai_agg_o = imp.aai_agg\n", - "freq_curve_o = imp.calc_freq_curve([50, 100, 250]).impact\n", - "orig_list = [aai_agg_o] + list(freq_curve_o) +[1]" + "import scipy as sp\n", + "from climada.engine.unsequa import InputVar\n", + "\n", + "haz_today = haz_base\n", + "\n", + "haz_fut_distr = {\"x_haz_fut\": sp.stats.uniform(1, 3),\n", + " }\n", + "haz_fut_iv = InputVar(haz_fut_func, haz_fut_distr)\n", + "\n", + "ent_today_distr = {\"x_ent\": sp.stats.uniform(0.7, 1)}\n", + "ent_today_iv = InputVar(ent_today_func, ent_today_distr)\n", + "\n", + "ent_fut_distr = {\"m_fut_cost\": sp.stats.norm(1, 0.1)}\n", + "ent_fut_iv = InputVar(ent_fut_func, ent_fut_distr)" ] }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 53, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:12:49.278123Z", - "start_time": "2022-01-10T20:12:48.525437Z" - }, - "code_folding": [] + "end_time": "2023-08-03T12:00:12.959984Z", + "start_time": "2023-08-03T12:00:12.804842Z" + } }, "outputs": [ { "data": { - "image/png": "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", + "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", + "
latitudelongitudevaluedeductiblecoverimpf_TCValue_2010
026.933899-80.1287991.671301e+1001.392750e+1015.139301e+09
126.957203-80.0982841.511528e+1001.259606e+1014.647994e+09
226.783846-80.7489471.511528e+1001.259606e+1014.647994e+09
326.645524-80.5507041.511528e+1001.259606e+1014.647994e+09
426.897796-80.5969291.511528e+1001.259606e+1014.647994e+09
\n", + "
" + ], "text/plain": [ - "
" + " latitude longitude value deductible cover impf_TC \n", + "0 26.933899 -80.128799 1.671301e+10 0 1.392750e+10 1 \\\n", + "1 26.957203 -80.098284 1.511528e+10 0 1.259606e+10 1 \n", + "2 26.783846 -80.748947 1.511528e+10 0 1.259606e+10 1 \n", + "3 26.645524 -80.550704 1.511528e+10 0 1.259606e+10 1 \n", + "4 26.897796 -80.596929 1.511528e+10 0 1.259606e+10 1 \n", + "\n", + " Value_2010 \n", + "0 5.139301e+09 \n", + "1 4.647994e+09 \n", + "2 4.647994e+09 \n", + "3 4.647994e+09 \n", + "4 4.647994e+09 " ] }, + "execution_count": 53, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ - "# plot the aai_agg and freq_curve uncertainty only\n", - "# use logarithmic x-scale\n", - "output_imp2.plot_uncertainty(metric_list=['aai_agg', 'freq_curve'], orig_list=orig_list, log=True, figsize=(12,8));" + "ent_avg = ent_today_iv.evaluate()\n", + "ent_avg.exposures.gdf.head()" ] }, { - "cell_type": "code", - "execution_count": 50, - "metadata": { - "ExecuteTime": { - "end_time": "2022-01-10T20:12:50.192029Z", - "start_time": "2022-01-10T20:12:49.843958Z" - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/ckropf/opt/anaconda3/envs/climada_310/lib/python3.8/site-packages/SALib/analyze/rbd_fast.py:106: RuntimeWarning: invalid value encountered in double_scalars\n", - " return D1 / V\n" - ] - } - ], + "cell_type": "markdown", + "metadata": {}, "source": [ - "# Use the method 'rbd_fast' which is recommend in pair with 'latin'. In addition, change one of the kwargs \n", - "# (M=15) of the salib sampling method.\n", - "output_imp2 = calc_imp2.sensitivity(output_imp2, sensitivity_method='rbd_fast', sensitivity_kwargs = {'M': 15})" + "### Compute cost benefit uncertainty and sensitivity using default methods " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Since we computed the distribution and sensitivity indices for the total impact at each exposure point, we can plot a map of the largest sensitivity index in each exposure location. For every location, the most sensitive parameter is `v_half`, meaning that the average annual impact at each location is most sensitivity to the ucnertainty in the impact function slope scaling parameter." + "For examples of how to use non-defaults please see the [impact example](###Compute-uncertainty-and-sensitivity-using-default-methods )" ] }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 54, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:12:54.191848Z", - "start_time": "2022-01-10T20:12:51.694564Z" + "end_time": "2023-08-03T12:00:13.085529Z", + "start_time": "2023-08-03T12:00:12.963156Z" } }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "output_imp2.plot_sensitivity_map();" + "from climada.engine.unsequa import CalcCostBenefit\n", + "\n", + "unc_cb = CalcCostBenefit(haz_input_var=haz_today, ent_input_var=ent_today_iv,\n", + " haz_fut_input_var=haz_fut_iv, ent_fut_input_var=ent_fut_iv)" ] }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 55, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:12:54.212554Z", - "start_time": "2022-01-10T20:12:54.194557Z" + "end_time": "2023-08-03T12:00:13.121927Z", + "start_time": "2023-08-03T12:00:13.087709Z" } }, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2023-08-03 14:00:13,114 - climada.engine.unsequa.calc_base - INFO - Effective number of made samples: 50\n" + ] + }, { "data": { "text/html": [ @@ -2852,238 +2823,271 @@ " \n", " \n", " \n", - " metric\n", - " param\n", - " param2\n", - " si\n", + " x_ent\n", + " x_haz_fut\n", + " m_fut_cost\n", " \n", " \n", " \n", " \n", " 45\n", - " 45\n", - " v_half\n", - " None\n", - " 0.479974\n", + " 1.35625\n", + " 2.96875\n", + " 0.813727\n", " \n", " \n", " 46\n", - " 46\n", - " v_half\n", - " None\n", - " 0.479974\n", + " 1.04375\n", + " 2.96875\n", + " 0.813727\n", " \n", " \n", " 47\n", - " 47\n", - " v_half\n", - " None\n", - " 0.479974\n", + " 1.35625\n", + " 2.03125\n", + " 0.813727\n", " \n", " \n", " 48\n", - " 48\n", - " v_half\n", - " None\n", - " 0.475221\n", + " 1.35625\n", + " 2.96875\n", + " 0.899001\n", " \n", " \n", " 49\n", - " 49\n", - " v_half\n", - " None\n", - " 0.479974\n", + " 1.04375\n", + " 2.03125\n", + " 0.899001\n", " \n", " \n", "\n", "" ], "text/plain": [ - " metric param param2 si\n", - "45 45 v_half None 0.479974\n", - "46 46 v_half None 0.479974\n", - "47 47 v_half None 0.479974\n", - "48 48 v_half None 0.475221\n", - "49 49 v_half None 0.479974" + " x_ent x_haz_fut m_fut_cost\n", + "45 1.35625 2.96875 0.813727\n", + "46 1.04375 2.96875 0.813727\n", + "47 1.35625 2.03125 0.813727\n", + "48 1.35625 2.96875 0.899001\n", + "49 1.04375 2.03125 0.899001" ] }, - "execution_count": 12, + "execution_count": 55, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "output_imp2.get_largest_si(salib_si='S1', metric_list=['eai_exp']).tail()" + "output_cb= unc_cb.make_sample(N=10, sampling_kwargs={'calc_second_order':False})\n", + "output_cb.get_samples_df().tail()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## CalcCostBenefit" + "For longer computations, it is possible to use a pool for parallel computation." ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": { "ExecuteTime": { - "end_time": "2021-09-23T14:32:01.173184Z", - "start_time": "2021-09-23T14:32:01.169411Z" - } + "end_time": "2023-08-03T12:00:33.857265Z", + "start_time": "2023-08-03T12:00:13.124046Z" + }, + "scrolled": true }, + "outputs": [], "source": [ - "The uncertainty and sensitivity analysis for CostBenefit is completely analogous to the Impact case. It is slightly more complex as there are more input variables." + "\n", + "#without pool\n", + "output_cb = unc_cb.uncertainty(output_cb)\n", + "\n", + "#with pool\n", + "output_cb = unc_cb.uncertainty(output_cb, processes=4)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Set the Input Vars " + "The output of `CostBenefit.calc` is rather complex in its structure. The metrics dictionary inherits this complexity." ] }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 57, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:12:58.089282Z", - "start_time": "2022-01-10T20:12:58.053471Z" + "end_time": "2023-08-03T12:00:33.867733Z", + "start_time": "2023-08-03T12:00:33.861208Z" } }, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "2022-01-10 21:12:58,058 - climada.hazard.base - INFO - Reading /Users/ckropf/climada/demo/data/tc_fl_1990_2004.h5\n" - ] + "data": { + "text/plain": [ + "['imp_meas_present',\n", + " 'imp_meas_future',\n", + " 'tot_climate_risk',\n", + " 'benefit',\n", + " 'cost_ben_ratio']" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "import copy\n", - "from climada.util.constants import ENT_DEMO_TODAY, ENT_DEMO_FUTURE, HAZ_DEMO_H5\n", - "from climada.entity import Entity\n", - "from climada.hazard import Hazard\n", - "\n", - "# Entity today has an uncertainty in the total asset value\n", - "def ent_today_func(x_ent):\n", - " #In-function imports needed only for parallel computing on Windows\n", - " from climada.entity import Entity \n", - " from climada.util.constants import ENT_DEMO_TODAY \n", - " entity = Entity.from_excel(ENT_DEMO_TODAY)\n", - " entity.exposures.ref_year = 2018\n", - " entity.exposures.gdf.value *= x_ent\n", - " return entity\n", - "\n", - "# Entity in the future has a +- 10% uncertainty in the cost of all the adapatation measures\n", - "def ent_fut_func(m_fut_cost):\n", - " #In-function imports needed only for parallel computing on Windows\n", - " from climada.entity import Entity \n", - " from climada.util.constants import ENT_DEMO_FUTURE \n", - " entity = Entity.from_excel(ENT_DEMO_FUTURE)\n", - " entity.exposures.ref_year = 2040 \n", - " for meas in entity.measures.get_measure('TC'):\n", - " meas.cost *= m_fut_cost\n", - " return entity\n", - "\n", - "haz_base = Hazard.from_hdf5(HAZ_DEMO_H5)\n", - "# The hazard intensity in the future is also uncertainty by a multiplicative factor\n", - "def haz_fut(x_haz_fut, haz_base):\n", - " #In-function imports needed only for parallel computing on Windows\n", - " import copy \n", - " from climada.hazard import Hazard \n", - " from climada.util.constants import HAZ_DEMO_H5 \n", - " haz = copy.deepcopy(haz_base)\n", - " haz.intensity = haz.intensity.multiply(x_haz_fut)\n", - " return haz\n", - "from functools import partial\n", - "haz_fut_func = partial(haz_fut, haz_base=haz_base)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Check that costs for measures are changed as desired." + "#Top level metrics keys\n", + "macro_metrics = output_cb.uncertainty_metrics\n", + "macro_metrics" ] }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 58, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:12:59.932811Z", - "start_time": "2022-01-10T20:12:59.500919Z" + "end_time": "2023-08-03T12:00:33.887774Z", + "start_time": "2023-08-03T12:00:33.870471Z" } }, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "The cost for m_fut_cost=1 are [1311768360.8515418, 1728000000.0, 8878779433.630093, 9200000000.0]\n", - "The cost for m_fut_cost=0.5 are [655884180.4257709, 864000000.0, 4439389716.815046, 4600000000.0]\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/ckropf/opt/anaconda3/envs/climada_310/lib/python3.8/site-packages/openpyxl/worksheet/_reader.py:312: UserWarning: Unknown extension is not supported and will be removed\n", - " warn(msg)\n" - ] + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Mangroves BenefBeach nourishment BenefSeawall BenefBuilding code BenefMangroves CostBenBeach nourishment CostBenSeawall CostBenBuilding code CostBen
458.670468e+096.722992e+096.214684e+083.926190e+100.1231100.20915111.6255330.190676
468.549601e+096.624301e+096.214684e+083.920155e+100.1248500.21226711.6255330.190969
471.455086e+101.152385e+106.206260e+071.901856e+100.0733580.122018116.4131270.393631
488.670468e+096.722992e+096.214684e+083.926190e+100.1360110.23106912.8438260.210657
491.443000e+101.142516e+106.206260e+071.895821e+100.0817240.135970128.6125930.436265
\n", + "
" + ], + "text/plain": [ + " Mangroves Benef Beach nourishment Benef Seawall Benef \n", + "45 8.670468e+09 6.722992e+09 6.214684e+08 \\\n", + "46 8.549601e+09 6.624301e+09 6.214684e+08 \n", + "47 1.455086e+10 1.152385e+10 6.206260e+07 \n", + "48 8.670468e+09 6.722992e+09 6.214684e+08 \n", + "49 1.443000e+10 1.142516e+10 6.206260e+07 \n", + "\n", + " Building code Benef Mangroves CostBen Beach nourishment CostBen \n", + "45 3.926190e+10 0.123110 0.209151 \\\n", + "46 3.920155e+10 0.124850 0.212267 \n", + "47 1.901856e+10 0.073358 0.122018 \n", + "48 3.926190e+10 0.136011 0.231069 \n", + "49 1.895821e+10 0.081724 0.135970 \n", + "\n", + " Seawall CostBen Building code CostBen \n", + "45 11.625533 0.190676 \n", + "46 11.625533 0.190969 \n", + "47 116.413127 0.393631 \n", + "48 12.843826 0.210657 \n", + "49 128.612593 0.436265 " + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "costs_1 = [meas.cost for meas in ent_fut_func(1).measures.get_measure('TC')]\n", - "costs_05 = [meas.cost for meas in ent_fut_func(0.5).measures.get_measure('TC')]\n", - "print(f\"\\nThe cost for m_fut_cost=1 are {costs_1}\\n\"\n", - " f\"The cost for m_fut_cost=0.5 are {costs_05}\");" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Define the InputVars" - ] - }, - { - "cell_type": "code", - "execution_count": 55, - "metadata": { - "ExecuteTime": { - "end_time": "2022-01-10T20:13:01.740776Z", - "start_time": "2022-01-10T20:13:01.734227Z" - } - }, - "outputs": [], - "source": [ - "import scipy as sp\n", - "from climada.engine.unsequa import InputVar\n", - "\n", - "haz_today = haz_base\n", - "\n", - "haz_fut_distr = {\"x_haz_fut\": sp.stats.uniform(1, 3),\n", - " }\n", - "haz_fut_iv = InputVar(haz_fut_func, haz_fut_distr)\n", - "\n", - "ent_today_distr = {\"x_ent\": sp.stats.uniform(0.7, 1)}\n", - "ent_today_iv = InputVar(ent_today_func, ent_today_distr)\n", - "\n", - "ent_fut_distr = {\"m_fut_cost\": sp.stats.norm(1, 0.1)}\n", - "ent_fut_iv = InputVar(ent_fut_func, ent_fut_distr)" + "# The benefits and cost_ben_ratio are available for each measure\n", + "output_cb.get_uncertainty(metric_list=['benefit', 'cost_ben_ratio']).tail()" ] }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 59, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:13:02.702830Z", - "start_time": "2022-01-10T20:13:02.600643Z" + "end_time": "2023-08-03T12:00:33.913186Z", + "start_time": "2023-08-03T12:00:33.890497Z" } }, "outputs": [ @@ -3108,304 +3112,519 @@ " \n", " \n", " \n", - " latitude\n", - " longitude\n", - " value\n", - " deductible\n", - " cover\n", - " impf_TC\n", - " Value_2010\n", + " no measure - risk - present\n", + " no measure - risk_transf - present\n", + " no measure - cost_meas - present\n", + " no measure - cost_ins - present\n", + " Mangroves - risk - present\n", + " Mangroves - risk_transf - present\n", + " Mangroves - cost_meas - present\n", + " Mangroves - cost_ins - present\n", + " Beach nourishment - risk - present\n", + " Beach nourishment - risk_transf - present\n", + " Beach nourishment - cost_meas - present\n", + " Beach nourishment - cost_ins - present\n", + " Seawall - risk - present\n", + " Seawall - risk_transf - present\n", + " Seawall - cost_meas - present\n", + " Seawall - cost_ins - present\n", + " Building code - risk - present\n", + " Building code - risk_transf - present\n", + " Building code - cost_meas - present\n", + " Building code - cost_ins - present\n", " \n", - " \n", - " \n", - " \n", - " 0\n", - " 26.933899\n", - " -80.128799\n", - " 1.671301e+10\n", + " \n", + " \n", + " \n", + " 45\n", + " 1.040893e+08\n", + " 0.0\n", " 0\n", - " 1.392750e+10\n", + " 0\n", + " 5.197409e+07\n", + " 0\n", + " 1.311768e+09\n", + " 1\n", + " 6.153578e+07\n", + " 0\n", + " 1.728000e+09\n", + " 1\n", + " 1.040893e+08\n", + " 0\n", + " 8.878779e+09\n", + " 1\n", + " 7.806698e+07\n", + " 0\n", + " 9.200000e+09\n", " 1\n", - " 5.139301e+09\n", " \n", " \n", - " 1\n", - " 26.957203\n", - " -80.098284\n", - " 1.511528e+10\n", + " 46\n", + " 8.010560e+07\n", + " 0.0\n", " 0\n", - " 1.259606e+10\n", + " 0\n", + " 3.999849e+07\n", + " 0\n", + " 1.311768e+09\n", + " 1\n", + " 4.735703e+07\n", + " 0\n", + " 1.728000e+09\n", + " 1\n", + " 8.010560e+07\n", + " 0\n", + " 8.878779e+09\n", + " 1\n", + " 6.007920e+07\n", + " 0\n", + " 9.200000e+09\n", " 1\n", - " 4.647994e+09\n", " \n", " \n", - " 2\n", - " 26.783846\n", - " -80.748947\n", - " 1.511528e+10\n", + " 47\n", + " 1.040893e+08\n", + " 0.0\n", " 0\n", - " 1.259606e+10\n", + " 0\n", + " 5.197409e+07\n", + " 0\n", + " 1.311768e+09\n", + " 1\n", + " 6.153578e+07\n", + " 0\n", + " 1.728000e+09\n", + " 1\n", + " 1.040893e+08\n", + " 0\n", + " 8.878779e+09\n", + " 1\n", + " 7.806698e+07\n", + " 0\n", + " 9.200000e+09\n", " 1\n", - " 4.647994e+09\n", " \n", " \n", - " 3\n", - " 26.645524\n", - " -80.550704\n", - " 1.511528e+10\n", + " 48\n", + " 1.040893e+08\n", + " 0.0\n", " 0\n", - " 1.259606e+10\n", + " 0\n", + " 5.197409e+07\n", + " 0\n", + " 1.311768e+09\n", + " 1\n", + " 6.153578e+07\n", + " 0\n", + " 1.728000e+09\n", + " 1\n", + " 1.040893e+08\n", + " 0\n", + " 8.878779e+09\n", + " 1\n", + " 7.806698e+07\n", + " 0\n", + " 9.200000e+09\n", " 1\n", - " 4.647994e+09\n", " \n", " \n", - " 4\n", - " 26.897796\n", - " -80.596929\n", - " 1.511528e+10\n", + " 49\n", + " 8.010560e+07\n", + " 0.0\n", " 0\n", - " 1.259606e+10\n", + " 0\n", + " 3.999849e+07\n", + " 0\n", + " 1.311768e+09\n", + " 1\n", + " 4.735703e+07\n", + " 0\n", + " 1.728000e+09\n", + " 1\n", + " 8.010560e+07\n", + " 0\n", + " 8.878779e+09\n", + " 1\n", + " 6.007920e+07\n", + " 0\n", + " 9.200000e+09\n", " 1\n", - " 4.647994e+09\n", " \n", " \n", "\n", "" ], "text/plain": [ - " latitude longitude value deductible cover impf_TC \\\n", - "0 26.933899 -80.128799 1.671301e+10 0 1.392750e+10 1 \n", - "1 26.957203 -80.098284 1.511528e+10 0 1.259606e+10 1 \n", - "2 26.783846 -80.748947 1.511528e+10 0 1.259606e+10 1 \n", - "3 26.645524 -80.550704 1.511528e+10 0 1.259606e+10 1 \n", - "4 26.897796 -80.596929 1.511528e+10 0 1.259606e+10 1 \n", + " no measure - risk - present no measure - risk_transf - present \n", + "45 1.040893e+08 0.0 \\\n", + "46 8.010560e+07 0.0 \n", + "47 1.040893e+08 0.0 \n", + "48 1.040893e+08 0.0 \n", + "49 8.010560e+07 0.0 \n", "\n", - " Value_2010 \n", - "0 5.139301e+09 \n", - "1 4.647994e+09 \n", - "2 4.647994e+09 \n", - "3 4.647994e+09 \n", - "4 4.647994e+09 " + " no measure - cost_meas - present no measure - cost_ins - present \n", + "45 0 0 \\\n", + "46 0 0 \n", + "47 0 0 \n", + "48 0 0 \n", + "49 0 0 \n", + "\n", + " Mangroves - risk - present Mangroves - risk_transf - present \n", + "45 5.197409e+07 0 \\\n", + "46 3.999849e+07 0 \n", + "47 5.197409e+07 0 \n", + "48 5.197409e+07 0 \n", + "49 3.999849e+07 0 \n", + "\n", + " Mangroves - cost_meas - present Mangroves - cost_ins - present \n", + "45 1.311768e+09 1 \\\n", + "46 1.311768e+09 1 \n", + "47 1.311768e+09 1 \n", + "48 1.311768e+09 1 \n", + "49 1.311768e+09 1 \n", + "\n", + " Beach nourishment - risk - present \n", + "45 6.153578e+07 \\\n", + "46 4.735703e+07 \n", + "47 6.153578e+07 \n", + "48 6.153578e+07 \n", + "49 4.735703e+07 \n", + "\n", + " Beach nourishment - risk_transf - present \n", + "45 0 \\\n", + "46 0 \n", + "47 0 \n", + "48 0 \n", + "49 0 \n", + "\n", + " Beach nourishment - cost_meas - present \n", + "45 1.728000e+09 \\\n", + "46 1.728000e+09 \n", + "47 1.728000e+09 \n", + "48 1.728000e+09 \n", + "49 1.728000e+09 \n", + "\n", + " Beach nourishment - cost_ins - present Seawall - risk - present \n", + "45 1 1.040893e+08 \\\n", + "46 1 8.010560e+07 \n", + "47 1 1.040893e+08 \n", + "48 1 1.040893e+08 \n", + "49 1 8.010560e+07 \n", + "\n", + " Seawall - risk_transf - present Seawall - cost_meas - present \n", + "45 0 8.878779e+09 \\\n", + "46 0 8.878779e+09 \n", + "47 0 8.878779e+09 \n", + "48 0 8.878779e+09 \n", + "49 0 8.878779e+09 \n", + "\n", + " Seawall - cost_ins - present Building code - risk - present \n", + "45 1 7.806698e+07 \\\n", + "46 1 6.007920e+07 \n", + "47 1 7.806698e+07 \n", + "48 1 7.806698e+07 \n", + "49 1 6.007920e+07 \n", + "\n", + " Building code - risk_transf - present \n", + "45 0 \\\n", + "46 0 \n", + "47 0 \n", + "48 0 \n", + "49 0 \n", + "\n", + " Building code - cost_meas - present Building code - cost_ins - present \n", + "45 9.200000e+09 1 \n", + "46 9.200000e+09 1 \n", + "47 9.200000e+09 1 \n", + "48 9.200000e+09 1 \n", + "49 9.200000e+09 1 " ] }, - "execution_count": 16, + "execution_count": 59, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "ent_avg = ent_today_iv.evaluate()\n", - "ent_avg.exposures.gdf.head()" + "# The impact_meas_present and impact_meas_future provide values of the cost_meas, risk_transf, risk, \n", + "# and cost_ins for each measure\n", + "output_cb.get_uncertainty(metric_list=['imp_meas_present']).tail()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Compute cost benefit uncertainty and sensitivity using default methods " + "We can plot the distributions for the top metrics or our choice." + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T12:00:35.497893Z", + "start_time": "2023-08-03T12:00:33.916462Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# tot_climate_risk and benefit\n", + "output_cb.plot_uncertainty(metric_list=['benefit'], figsize=(12,8));" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "For examples of how to use non-defaults please see the [impact example](###Compute-uncertainty-and-sensitivity-using-default-methods )" + "Analogously to the impact example, now that we have a metric distribution, we can compute the sensitivity indices. Since we used the default sampling method, we can use the default sensitivity analysis method. However, since we used `calc_second_order = False` for the sampling, we need to specify the same for the sensitivity analysis." ] }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 61, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:13:05.501816Z", - "start_time": "2022-01-10T20:13:05.404743Z" + "end_time": "2023-08-03T12:00:35.632065Z", + "start_time": "2023-08-03T12:00:35.500390Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/ckropf/opt/anaconda3/envs/climada_333_shapely2/lib/python3.9/site-packages/pandas/core/dtypes/common.py:1687: DeprecationWarning: Converting `np.inexact` or `np.floating` to a dtype is deprecated. The current result is `float64` which is not strictly correct.\n", + " npdtype = np.dtype(dtype)\n", + "/Users/ckropf/opt/anaconda3/envs/climada_333_shapely2/lib/python3.9/site-packages/pandas/core/dtypes/common.py:1687: DeprecationWarning: Converting `np.inexact` or `np.floating` to a dtype is deprecated. The current result is `float64` which is not strictly correct.\n", + " npdtype = np.dtype(dtype)\n", + "/Users/ckropf/opt/anaconda3/envs/climada_333_shapely2/lib/python3.9/site-packages/pandas/core/dtypes/common.py:1687: DeprecationWarning: Converting `np.inexact` or `np.floating` to a dtype is deprecated. The current result is `float64` which is not strictly correct.\n", + " npdtype = np.dtype(dtype)\n", + "/Users/ckropf/opt/anaconda3/envs/climada_333_shapely2/lib/python3.9/site-packages/pandas/core/dtypes/common.py:1687: DeprecationWarning: Converting `np.inexact` or `np.floating` to a dtype is deprecated. The current result is `float64` which is not strictly correct.\n", + " npdtype = np.dtype(dtype)\n", + "/Users/ckropf/opt/anaconda3/envs/climada_333_shapely2/lib/python3.9/site-packages/pandas/core/dtypes/common.py:1687: DeprecationWarning: Converting `np.inexact` or `np.floating` to a dtype is deprecated. The current result is `float64` which is not strictly correct.\n", + " npdtype = np.dtype(dtype)\n" + ] + } + ], "source": [ - "from climada.engine.unsequa import CalcCostBenefit\n", + "output_cb = unc_cb.sensitivity(output_cb, sensitivity_kwargs={'calc_second_order':False})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The sensitivity indices can be plotted. For the default method 'sobol', by default the 'S1' sensitivity index is plotted.\n", "\n", - "unc_cb = CalcCostBenefit(haz_input_var=haz_today, ent_input_var=ent_today_iv,\n", - " haz_fut_input_var=haz_fut_iv, ent_fut_input_var=ent_fut_iv)" + "Note that since we have quite a few measures, the plot must be adjusted a bit or dropped. Also see that for many metrics, the sensitivity to certain uncertainty parameters appears to be 0. However, this result is to be treated with care. Indeed, we used for demonstration purposes a rather too low number of samples, which is indicated by large confidence intervals (vertical black lines) for most sensitivity indices. For a more robust result the analysis should be repeated with more samples." ] }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 62, "metadata": { "ExecuteTime": { - "end_time": "2022-01-10T20:13:07.537792Z", - "start_time": "2022-01-10T20:13:07.346409Z" + "end_time": "2023-08-03T12:00:36.659813Z", + "start_time": "2023-08-03T12:00:35.635106Z" } }, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2022-01-10 21:13:07,531 - climada.engine.unsequa.calc_base - INFO - Effective number of made samples: 50\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", - "
x_entx_haz_futm_fut_cost
451.2634773.0712891.012517
461.6580083.0712891.012517
471.2634771.3720701.012517
481.2634773.0712891.067757
491.6580081.3720701.067757
\n", - "
" - ], + "image/png": "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", "text/plain": [ - " x_ent x_haz_fut m_fut_cost\n", - "45 1.263477 3.071289 1.012517\n", - "46 1.658008 3.071289 1.012517\n", - "47 1.263477 1.372070 1.012517\n", - "48 1.263477 3.071289 1.067757\n", - "49 1.658008 1.372070 1.067757" + "
" ] }, - "execution_count": 18, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "output_cb= unc_cb.make_sample(N=10, sampling_kwargs={'calc_second_order':False})\n", - "output_cb.get_samples_df().tail()" + "#plot only certain metrics\n", + "axes = output_cb.plot_sensitivity(metric_list=['cost_ben_ratio','tot_climate_risk','benefit'], figsize=(12,8));" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "For longer computations, it is possible to use a pool for parallel computation." + "## Advanced examples" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Coupled variables" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this example, we show how you can define correlated input variables. Suppose your exposures and hazards are conditioned on the same Shared Socio-economic Pathway (SSP). Then, you want that only exposures and hazard belonging to the same SSP are present in each sample.\n", + "\n", + "In order to achieve this, you must simply define an uncertainty parameter that shares the same name and the same distribution for both the exposures and the hazard uncertainty variables." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Many scenarios of hazards and exposures" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this example we look at the case where many scenarios are tested in the uncertainty analysis. For instance, suppose you have data for different Shared Socio-economic Pathways (SSP) and different Climate Change projections. From the SSPs, you have a number of Exposures, saved to files. From the climate projections, you have a number of Hazards, saved to file.\n", + "\n", + "The task is to sample from the SSPs and the Climate change scenarios for the uncertainty and sensitivity analysis efficiently.\n", + "\n", + "For demonstration purposes, we will use below as exposures files the litpop for three countries, and for tha hazard files the winter storms for the same three countries. Instead of having SSPs, we now want to only combine exposures and hazards of the same countries.\n" ] }, { "cell_type": "code", - "execution_count": 68, - "metadata": { - "ExecuteTime": { - "end_time": "2022-01-10T20:13:22.501919Z", - "start_time": "2022-01-10T20:13:10.484095Z" - }, - "scrolled": true - }, + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "from climada.util.api_client import Client\n", + "client = Client()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, "outputs": [], "source": [ - "from pathos.pools import ProcessPool as Pool\n", + "def get_litpop(iso):\n", + " return client.get_litpop(country=iso)\n", "\n", - "#without pool\n", - "output_cb = unc_cb.uncertainty(output_cb)\n", "\n", - "#with pool\n", - "#pool = Pool()\n", - "#output_cb = unc_cb.uncertainty(output_cb, pool=pool)\n", - "#pool.close() #Do not forget to close your pool!\n", - "#pool.join()\n", - "#pool.clear()\n", - "#If you have issues with the pool in jupyter, please restart the kernel or use without pool." + "def get_ws(iso):\n", + " properties = {\n", + " 'country_iso3alpha': iso,\n", + " }\n", + " return client.get_hazard('storm_europe', properties=properties)\n" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "The output of `CostBenefit.calc` is rather complex in its structure. The metrics dictionary inherits this complexity." + "#Define list of exposures and/or of hazard files\n", + "\n", + "exp_list = [get_litpop(iso) for iso in ['CHE', 'DEU', 'ITA']]\n", + "haz_list = [get_ws(iso) for iso in ['CHE', 'DEU', 'ITA']]\n", + "for exp, haz in zip(exp_list, haz_list):\n", + " exp.gdf['impf_WS'] = 1\n", + " exp.assign_centroids(haz)" ] }, { "cell_type": "code", - "execution_count": 60, - "metadata": { - "ExecuteTime": { - "end_time": "2022-01-10T20:13:23.980404Z", - "start_time": "2022-01-10T20:13:23.976645Z" - } - }, + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "#Define the input variable \n", + "from climada.entity import ImpactFuncSet, Exposures\n", + "from climada.entity.impact_funcs.storm_europe import ImpfStormEurope\n", + "from climada.hazard import Hazard\n", + "from climada.engine.unsequa import InputVar\n", + "import scipy as sp\n", + "import copy\n", + "\n", + "def exp_func(cnt, x_exp, exp_list=exp_list):\n", + " exp = exp_list[int(cnt)].copy()\n", + " exp.gdf.value *= x_exp\n", + " return exp\n", + "\n", + "exp_distr = {\"x_exp\": sp.stats.uniform(0.9, 0.2),\n", + " \"cnt\": sp.stats.randint(low=0, high=len(exp_list)) #use the same parameter name accross input variables\n", + " }\n", + "exp_iv = InputVar(exp_func, exp_distr)\n", + "\n", + "\n", + "def haz_func(cnt, i_haz, haz_list=haz_list):\n", + " haz = copy.deepcopy(haz_list[int(cnt)]) #use the same parameter name accross input variables \n", + " haz.intensity *= i_haz\n", + " return haz\n", + "\n", + "haz_distr = {\"i_haz\": sp.stats.norm(1, 0.2),\n", + " \"cnt\": sp.stats.randint(low=0, high=len(haz_list))\n", + " }\n", + "haz_iv = InputVar(haz_func, haz_distr)\n", + "\n", + "impf = ImpfStormEurope.from_schwierz()\n", + "impf_set = ImpactFuncSet()\n", + "impf_set.append(impf)\n", + "impf_iv = InputVar.impfset([impf_set], bounds_mdd = [0.9, 1.1])" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "['imp_meas_present',\n", - " 'imp_meas_future',\n", - " 'tot_climate_risk',\n", - " 'benefit',\n", - " 'cost_ben_ratio']" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "2023-08-04 16:34:35,948 - climada.engine.unsequa.calc_base - WARNING - \n", + "\n", + "The input parameter cnt is shared among at least 2 input variables. Their uncertainty is thus computed with the same samples for this input paramter.\n", + "\n", + "\n" + ] } ], "source": [ - "#Top level metrics keys\n", - "macro_metrics = output_cb.uncertainty_metrics\n", - "macro_metrics" + "from climada.engine.unsequa import CalcImpact\n", + "\n", + "calc_imp = CalcImpact(exp_iv, impf_iv, haz_iv)" ] }, { "cell_type": "code", - "execution_count": 61, - "metadata": { - "ExecuteTime": { - "end_time": "2022-01-10T20:13:24.420911Z", - "start_time": "2022-01-10T20:13:24.408233Z" + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2023-08-04 16:34:35,987 - climada.engine.unsequa.calc_base - INFO - Effective number of made samples: 40\n" + ] } - }, + ], + "source": [ + "output_imp = calc_imp.make_sample(N=2**2, sampling_kwargs={'skip_values': 2**3})\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, "outputs": [ { "data": { @@ -3428,97 +3647,59 @@ " \n", " \n", " \n", - " Mangroves Benef\n", - " Beach nourishment Benef\n", - " Seawall Benef\n", - " Building code Benef\n", - " Mangroves CostBen\n", - " Beach nourishment CostBen\n", - " Seawall CostBen\n", - " Building code CostBen\n", + " x_exp\n", + " cnt\n", + " MDD\n", + " i_haz\n", " \n", " \n", " \n", " \n", - " 45\n", - " 8.814039e+09\n", - " 6.914137e+09\n", - " 7.514788e+08\n", - " 4.050774e+10\n", - " 0.150690\n", - " 0.253051\n", - " 11.962963\n", - " 0.229960\n", + " 35\n", + " 0.9875\n", + " 0.0\n", + " 1.0375\n", + " 1.097755\n", " \n", " \n", - " 46\n", - " 8.966634e+09\n", - " 7.038734e+09\n", - " 7.514788e+08\n", - " 4.058393e+10\n", - " 0.148126\n", - " 0.248572\n", - " 11.962963\n", - " 0.229528\n", + " 36\n", + " 1.0625\n", + " 1.0\n", + " 1.0375\n", + " 1.097755\n", " \n", " \n", - " 47\n", - " 3.768293e+09\n", - " 3.046279e+09\n", - " 4.742905e+06\n", - " 2.438938e+09\n", - " 0.352464\n", - " 0.574350\n", - " 1895.444529\n", - " 3.819348\n", + " 37\n", + " 1.0625\n", + " 0.0\n", + " 0.9375\n", + " 1.097755\n", " \n", " \n", - " 48\n", - " 8.814039e+09\n", - " 6.914137e+09\n", - " 7.514788e+08\n", - " 4.050774e+10\n", - " 0.158911\n", - " 0.266857\n", - " 12.615625\n", - " 0.242506\n", + " 38\n", + " 1.0625\n", + " 0.0\n", + " 1.0375\n", + " 1.097755\n", " \n", " \n", - " 49\n", - " 3.920888e+09\n", - " 3.170876e+09\n", - " 4.742905e+06\n", - " 2.515132e+09\n", - " 0.357228\n", - " 0.581884\n", - " 1998.854177\n", - " 3.905703\n", + " 39\n", + " 1.0625\n", + " 0.0\n", + " 1.0375\n", + " 1.097755\n", " \n", " \n", "\n", "" ], "text/plain": [ - " Mangroves Benef Beach nourishment Benef Seawall Benef \\\n", - "45 8.814039e+09 6.914137e+09 7.514788e+08 \n", - "46 8.966634e+09 7.038734e+09 7.514788e+08 \n", - "47 3.768293e+09 3.046279e+09 4.742905e+06 \n", - "48 8.814039e+09 6.914137e+09 7.514788e+08 \n", - "49 3.920888e+09 3.170876e+09 4.742905e+06 \n", - "\n", - " Building code Benef Mangroves CostBen Beach nourishment CostBen \\\n", - "45 4.050774e+10 0.150690 0.253051 \n", - "46 4.058393e+10 0.148126 0.248572 \n", - "47 2.438938e+09 0.352464 0.574350 \n", - "48 4.050774e+10 0.158911 0.266857 \n", - "49 2.515132e+09 0.357228 0.581884 \n", - "\n", - " Seawall CostBen Building code CostBen \n", - "45 11.962963 0.229960 \n", - "46 11.962963 0.229528 \n", - "47 1895.444529 3.819348 \n", - "48 12.615625 0.242506 \n", - "49 1998.854177 3.905703 " + " x_exp cnt MDD i_haz\n", + "35 0.9875 0.0 1.0375 1.097755\n", + "36 1.0625 1.0 1.0375 1.097755\n", + "37 1.0625 0.0 0.9375 1.097755\n", + "38 1.0625 0.0 1.0375 1.097755\n", + "39 1.0625 0.0 1.0375 1.097755" ] }, "execution_count": 21, @@ -3527,19 +3708,36 @@ } ], "source": [ - "# The benefits and cost_ben_ratio are available for each measure\n", - "output_cb.get_uncertainty(metric_list=['benefit', 'cost_ben_ratio']).tail()" + "# as we can see, there is only a single input parameter \"cnt\" to select the country for both the exposures and the hazard\n", + "output_imp.samples_df.tail()" ] }, { "cell_type": "code", - "execution_count": 62, - "metadata": { - "ExecuteTime": { - "end_time": "2022-01-10T20:13:24.785741Z", - "start_time": "2022-01-10T20:13:24.767120Z" + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2023-08-04 16:34:36,224 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for WS\n", + "2023-08-04 16:34:36,227 - climada.engine.impact_calc - INFO - Calculating impact for 8397 assets (>0) and 4260 events.\n", + "2023-08-04 16:34:37,042 - climada.engine.unsequa.calc_base - INFO - \n", + "\n", + "Estimated computaion time: 0:00:10.300000\n", + "\n" + ] } - }, + ], + "source": [ + "output_imp = calc_imp.uncertainty(output_imp)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, "outputs": [ { "data": { @@ -3561,336 +3759,307 @@ "\n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", " \n", + " \n", + " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", "
no measure - risk - presentno measure - risk_transf - presentno measure - cost_meas - presentno measure - cost_ins - presentMangroves - risk - presentMangroves - risk_transf - presentMangroves - cost_meas - presentMangroves - cost_ins - presentBeach nourishment - risk - presentBeach nourishment - risk_transf - presentBeach nourishment - cost_meas - presentBeach nourishment - cost_ins - presentSeawall - risk - presentSeawall - risk_transf - presentSeawall - cost_meas - presentSeawall - cost_ins - presentBuilding code - risk - presentBuilding code - risk_transf - presentBuilding code - cost_meas - presentBuilding code - cost_ins - present
459.696915e+070.004.841883e+0701.311768e+0915.732646e+0701.728000e+0919.696915e+0708.878779e+0917.272686e+0709.200000e+091
461.272486e+080.006.353802e+0701.311768e+0917.522713e+0701.728000e+0911.272486e+0808.878779e+0919.543644e+0709.200000e+091
479.696915e+070.004.841883e+0701.311768e+0915.732646e+0701.728000e+0919.696915e+0708.878779e+0917.272686e+0709.200000e+091aai_agg
489.696915e+070.004.841883e+0701.311768e+0915.732646e+0701.728000e+0919.696915e+0708.878779e+0917.272686e+0709.200000e+091351.254818e+07
491.272486e+080.006.353802e+0701.311768e+0917.522713e+0701.728000e+0911.272486e+0808.878779e+0919.543644e+0709.200000e+091365.340193e+08
371.219989e+07
381.350121e+07
391.350121e+07
\n", "" ], "text/plain": [ - " no measure - risk - present no measure - risk_transf - present \\\n", - "45 9.696915e+07 0.0 \n", - "46 1.272486e+08 0.0 \n", - "47 9.696915e+07 0.0 \n", - "48 9.696915e+07 0.0 \n", - "49 1.272486e+08 0.0 \n", - "\n", - " no measure - cost_meas - present no measure - cost_ins - present \\\n", - "45 0 0 \n", - "46 0 0 \n", - "47 0 0 \n", - "48 0 0 \n", - "49 0 0 \n", - "\n", - " Mangroves - risk - present Mangroves - risk_transf - present \\\n", - "45 4.841883e+07 0 \n", - "46 6.353802e+07 0 \n", - "47 4.841883e+07 0 \n", - "48 4.841883e+07 0 \n", - "49 6.353802e+07 0 \n", - "\n", - " Mangroves - cost_meas - present Mangroves - cost_ins - present \\\n", - "45 1.311768e+09 1 \n", - "46 1.311768e+09 1 \n", - "47 1.311768e+09 1 \n", - "48 1.311768e+09 1 \n", - "49 1.311768e+09 1 \n", - "\n", - " Beach nourishment - risk - present \\\n", - "45 5.732646e+07 \n", - "46 7.522713e+07 \n", - "47 5.732646e+07 \n", - "48 5.732646e+07 \n", - "49 7.522713e+07 \n", - "\n", - " Beach nourishment - risk_transf - present \\\n", - "45 0 \n", - "46 0 \n", - "47 0 \n", - "48 0 \n", - "49 0 \n", - "\n", - " Beach nourishment - cost_meas - present \\\n", - "45 1.728000e+09 \n", - "46 1.728000e+09 \n", - "47 1.728000e+09 \n", - "48 1.728000e+09 \n", - "49 1.728000e+09 \n", - "\n", - " Beach nourishment - cost_ins - present Seawall - risk - present \\\n", - "45 1 9.696915e+07 \n", - "46 1 1.272486e+08 \n", - "47 1 9.696915e+07 \n", - "48 1 9.696915e+07 \n", - "49 1 1.272486e+08 \n", - "\n", - " Seawall - risk_transf - present Seawall - cost_meas - present \\\n", - "45 0 8.878779e+09 \n", - "46 0 8.878779e+09 \n", - "47 0 8.878779e+09 \n", - "48 0 8.878779e+09 \n", - "49 0 8.878779e+09 \n", - "\n", - " Seawall - cost_ins - present Building code - risk - present \\\n", - "45 1 7.272686e+07 \n", - "46 1 9.543644e+07 \n", - "47 1 7.272686e+07 \n", - "48 1 7.272686e+07 \n", - "49 1 9.543644e+07 \n", - "\n", - " Building code - risk_transf - present \\\n", - "45 0 \n", - "46 0 \n", - "47 0 \n", - "48 0 \n", - "49 0 \n", - "\n", - " Building code - cost_meas - present Building code - cost_ins - present \n", - "45 9.200000e+09 1 \n", - "46 9.200000e+09 1 \n", - "47 9.200000e+09 1 \n", - "48 9.200000e+09 1 \n", - "49 9.200000e+09 1 " + " aai_agg\n", + "35 1.254818e+07\n", + "36 5.340193e+08\n", + "37 1.219989e+07\n", + "38 1.350121e+07\n", + "39 1.350121e+07" ] }, - "execution_count": 22, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# The impact_meas_present and impact_meas_future provide values of the cost_meas, risk_transf, risk, \n", - "# and cost_ins for each measure\n", - "output_cb.get_uncertainty(metric_list=['imp_meas_present']).tail()" + "output_imp.aai_agg_unc_df.tail()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "We can plot the distributions for the top metrics or our choice." + "### Input variable: Repeated loading of files made efficient" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Loading Hazards or Exposures from file is a rather lengthy operation. Thus, we want to minimize the reading operations, ideally reading each file only once. Simultaneously, Hazard and Exposures can be large in memory, and thus we would like to have at most one of each loaded at a time. Thus, we do not want to use the list capacity from the helper method InputVar.exposures and InputVar.hazard.\n", + "\n", + "For demonstration purposes, we will use below as exposures files the litpop for three countries, and for tha hazard files the winter storms for the same three countries. Note that this does not make a lot of sense for an uncertainty analysis. For your use case, please replace the set of exposures and/or hazard files with meaningful sets, for instance sets of exposures for different resolutions or hazards for different model runs.\n" ] }, { "cell_type": "code", - "execution_count": 63, - "metadata": { - "ExecuteTime": { - "end_time": "2022-01-10T20:13:26.501526Z", - "start_time": "2022-01-10T20:13:25.856731Z" - } - }, + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from climada.util.api_client import Client\n", + "client = Client()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def get_litpop_path(iso):\n", + " properties = {\n", + " 'country_iso3alpha': iso,\n", + " 'res_arcsec': '150',\n", + " 'exponents': '(1,1)',\n", + " 'fin_mode': 'pc'\n", + " }\n", + " litpop_datasets = client.list_dataset_infos(data_type='litpop', properties=properties)\n", + " ds = litpop_datasets[0]\n", + " download_dir, ds_files = client.download_dataset(ds)\n", + " return ds_files[0]\n", + "\n", + "def get_ws_path(iso):\n", + " properties = {\n", + " 'country_iso3alpha': iso,\n", + " }\n", + " hazard_datasets = client.list_dataset_infos(data_type='storm_europe', properties=properties)\n", + " ds = hazard_datasets[0]\n", + " download_dir, ds_files = client.download_dataset(ds)\n", + " return ds_files[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "#Define list of exposures and/or of hazard files\n", + "\n", + "f_exp_list = [get_litpop_path(iso) for iso in ['CHE', 'DEU', 'ITA']]\n", + "f_haz_list = [get_ws_path(iso) for iso in ['CHE', 'DEU', 'ITA']]" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "#Define the input variable for the loading files\n", + "#The trick is to not reload a file if it is already in memory. This is done using a global variable.\n", + "from climada.entity import ImpactFunc, ImpactFuncSet, Exposures\n", + "from climada.hazard import Hazard\n", + "from climada.engine.unsequa import InputVar\n", + "import scipy as sp\n", + "import copy\n", + "\n", + "def exp_func(f_exp, x_exp, filename_list=f_exp_list):\n", + " filename = filename_list[int(f_exp)]\n", + " global exp_base\n", + " if 'exp_base' in globals():\n", + " if isinstance(exp_base, Exposures):\n", + " if exp_base.gdf.filename != str(filename):\n", + " exp_base = Exposures.from_hdf5(filename)\n", + " exp_base.gdf.filename = str(filename)\n", + " else:\n", + " exp_base = Exposures.from_hdf5(filename)\n", + " exp_base.gdf.filename = str(filename)\n", + "\n", + " exp = exp_base.copy()\n", + " exp.gdf.value *= x_exp\n", + " return exp\n", + "\n", + "exp_distr = {\"x_exp\": sp.stats.uniform(0.9, 0.2),\n", + " \"f_exp\": sp.stats.randint(low=0, high=len(f_exp_list))\n", + " }\n", + "exp_iv = InputVar(exp_func, exp_distr)\n", + "\n", + "\n", + "def haz_func(f_haz, i_haz, filename_list=f_haz_list):\n", + " filename = filename_list[int(f_haz)]\n", + " global haz_base\n", + " if 'haz_base' in globals():\n", + " if isinstance(haz_base, Hazard):\n", + " if haz_base.filename != str(filename):\n", + " haz_base = Hazard.from_hdf5(filename)\n", + " haz_base.filename = str(filename)\n", + " else:\n", + " haz_base = Hazard.from_hdf5(filename)\n", + " haz_base.filename = str(filename)\n", + "\n", + " haz = copy.deepcopy(haz_base)\n", + " haz.intensity *= i_haz\n", + " return haz\n", + "\n", + "haz_distr = {\"i_haz\": sp.stats.norm(1, 0.2),\n", + " \"f_haz\": sp.stats.randint(low=0, high=len(f_haz_list))\n", + " }\n", + "haz_iv = InputVar(haz_func, haz_distr)\n", + "\n", + "\n", + "def impf_func(G=1, v_half=84.7, vmin=25.7, k=3, _id=1):\n", + " \n", + " def xhi(v, v_half, vmin):\n", + " return max([(v - vmin), 0]) / (v_half - vmin)\n", + "\n", + " def sigmoid_func(v, G, v_half, vmin, k):\n", + " return G * xhi(v, v_half, vmin)**k / (1 + xhi(v, v_half, vmin)**k)\n", + "\n", + " #In-function imports needed only for parallel computing on Windows\n", + " import numpy as np \n", + " from climada.entity import ImpactFunc, ImpactFuncSet \n", + " imp_fun = ImpactFunc()\n", + " imp_fun.haz_type = 'WS'\n", + " imp_fun.id = _id\n", + " imp_fun.intensity_unit = 'm/s'\n", + " imp_fun.intensity = np.linspace(0, 150, num=100)\n", + " imp_fun.mdd = np.repeat(1, len(imp_fun.intensity))\n", + " imp_fun.paa = np.array([sigmoid_func(v, G, v_half, vmin, k) for v in imp_fun.intensity])\n", + " imp_fun.check()\n", + " impf_set = ImpactFuncSet()\n", + " impf_set.append(imp_fun)\n", + " return impf_set\n", + "\n", + "impf_distr = {\n", + " \"G\": sp.stats.truncnorm(0.5, 1.5),\n", + " \"v_half\": sp.stats.uniform(35, 65),\n", + " \"vmin\": sp.stats.uniform(0, 15),\n", + " \"k\": sp.stats.uniform(1, 4)\n", + " }\n", + "impf_iv = InputVar(impf_func, impf_distr)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, "outputs": [ { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "2023-08-04 16:30:48,177 - climada.entity.exposures.base - INFO - Reading /Users/ckropf/climada/data/exposures/litpop/LitPop_150arcsec_DEU/v2/LitPop_150arcsec_DEU.hdf5\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/ckropf/opt/anaconda3/envs/climada_333_shapely2/lib/python3.9/pickle.py:1717: UserWarning: Unpickling a shapely <2.0 geometry object. Please save the pickle again; shapely 2.1 will not have this compatibility.\n", + " setstate(state)\n" + ] } ], "source": [ - "# tot_climate_risk and benefit\n", - "output_cb.plot_uncertainty(metric_list=['benefit'], figsize=(12,8));" + "from climada.engine.unsequa import CalcImpact\n", + "\n", + "calc_imp = CalcImpact(exp_iv, impf_iv, haz_iv)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Analogously to the impact example, now that we have a metric distribution, we can compute the sensitivity indices. Since we used the default sampling method, we can use the default sensitivity analysis method. However, since we used `calc_second_order = False` for the sampling, we need to specify the same for the sensitivity analysis." + "Now that the samples have been generated, it is crucial to oder the samples in order to minimize the number of times files have to be loaded. In this case, loading the hazards take more time than loading the exposures. We thus sort first by hazards (which then each have to be loaded one single time), and then by exposures (which have to be each loaded once for each hazard).\n" ] }, { "cell_type": "code", - "execution_count": 64, - "metadata": { - "ExecuteTime": { - "end_time": "2022-01-10T20:13:27.485425Z", - "start_time": "2022-01-10T20:13:27.393598Z" - } - }, + "execution_count": 6, + "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "/Users/ckropf/opt/anaconda3/envs/climada_310/lib/python3.8/site-packages/SALib/analyze/sobol.py:87: RuntimeWarning: invalid value encountered in true_divide\n", - " Y = (Y - Y.mean()) / Y.std()\n", - "/Users/ckropf/opt/anaconda3/envs/climada_310/lib/python3.8/site-packages/SALib/analyze/sobol.py:137: RuntimeWarning: invalid value encountered in double_scalars\n", - " return np.mean(B * (AB - A), axis=0) / np.var(np.r_[A, B], axis=0)\n", - "/Users/ckropf/opt/anaconda3/envs/climada_310/lib/python3.8/site-packages/SALib/analyze/sobol.py:137: RuntimeWarning: invalid value encountered in true_divide\n", - " return np.mean(B * (AB - A), axis=0) / np.var(np.r_[A, B], axis=0)\n", - "/Users/ckropf/opt/anaconda3/envs/climada_310/lib/python3.8/site-packages/SALib/analyze/sobol.py:143: RuntimeWarning: invalid value encountered in double_scalars\n", - " return 0.5 * np.mean((A - AB) ** 2, axis=0) / np.var(np.r_[A, B], axis=0)\n", - "/Users/ckropf/opt/anaconda3/envs/climada_310/lib/python3.8/site-packages/SALib/analyze/sobol.py:143: RuntimeWarning: invalid value encountered in true_divide\n", - " return 0.5 * np.mean((A - AB) ** 2, axis=0) / np.var(np.r_[A, B], axis=0)\n" + "2023-08-04 16:29:49,588 - climada.engine.unsequa.calc_base - INFO - Effective number of made samples: 72\n" ] } ], "source": [ - "output_cb = unc_cb.sensitivity(output_cb, sensitivity_kwargs={'calc_second_order':False})" + "# Ordering of the samples by hazard first and exposures second\n", + "output_imp = calc_imp.make_sample(N=2**2, sampling_kwargs={'skip_values': 2**3})\n", + "output_imp.order_samples(by=['f_haz', 'f_exp'])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The sensitivity indices can be plotted. For the default method 'sobol', by default the 'S1' sensitivity index is plotted.\n", - "\n", - "Note that since we have quite a few measures, the plot must be adjusted a bit or dropped. Also see that for many metrics, the sensitivity to certain uncertainty parameters appears to be 0. However, this result is to be treated with care. Indeed, we used for demonstration purposes a rather too low number of samples, which is indicated by large confidence intervals (vertical black lines) for most sensitivity indices. For a more robust result the analysis should be repeated with more samples." + "We can verify how the samples are ordered. In the graph below, it is confirmed that the hazard are ordered, and thus the hazards will be loaded once each. The exposures on the other changes at most once per hazard." ] }, { "cell_type": "code", - "execution_count": 66, - "metadata": { - "ExecuteTime": { - "end_time": "2022-01-10T20:13:29.297598Z", - "start_time": "2022-01-10T20:13:28.834311Z" - } - }, + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "e = output_imp.samples_df['f_exp'].values\n", + "h = output_imp.samples_df['f_haz'].values" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that due to the very small number of samples chosen here for illustrative purposes, not all combinations of hazard and exposures are part of the samples. This is due to the nature of the Sobol sequence (default sampling method).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", "text/plain": [ - "
" + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHFCAYAAAAaD0bAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABxg0lEQVR4nO3dd3xT1fsH8E+apGkLbbFAB9CWsvcWKMgSCrLEHzL88mUpogjKqIpUkOWoCkIBAUWRioOhDEFBKDKVggItyPgiKFDEVoZCGV1Jzu+P9t42NG0TaJLem8/79coLcnNzc26S3j59znnO0QghBIiIiIjciIerG0BERETkbAyAiIiIyO0wACIiIiK3wwCIiIiI3A4DICIiInI7DICIiIjI7TAAIiIiIrfDAIiIiIjcDgMgIiIicjsMgFTuwIEDGDhwIEJCQuDp6Yng4GAMGDAAiYmJpXL86tWrY+TIkaVyrNKSnZ2NMWPGICQkBFqtFs2aNXN1k8iJ4uPjodFocP78+WL3GzlyJMqXL++cRjnB+fPnodFoEB8fXyrHW7RoEWrVqgVPT09oNBpcv34dI0eORPXq1S32c8U1oCxed1xh5syZ0Gg0rm6GYulc3QBynEWLFmHixIlo3bo13n33XYSHhyMlJQWLFy/GQw89hAULFuD55593dTNL3dKlS/Hhhx9i0aJFaNmypap+yRE5Q3JyMsaPH4+nn34aI0aMgE6ng6+vL1577TVMmDDB1c3Dhg0b4Ofn5+pmkMIxAFKpn376CRMnTkSvXr2wYcMG6HT5H/UTTzyB//u//8OECRPQvHlztG/fvsjj3LlzBz4+Ps5oMkwmE4xGIwwGw30d5/jx4/D29lZlcOcIGRkZ8Pb2dnUzyAbO+nk8ceIEAGD06NFo3bq1vL1mzZoOf21bNG/e3NVNIBVgF5hKxcbGQqPRYOnSpRbBDwDodDosWbIEGo0Gb7/9trxdSqceOXIEAwYMwAMPPCBf8HJycjB58mQEBwfDx8cHDz30EH7++Werr52WloZnn30W1apVg6enJyIiIjBr1iwYjUZ5Hyld/+677+KNN95AREQEDAYDdu3aVeQ5ZWZmIiYmBhEREfD09ETVqlUxbtw4XL9+Xd5Ho9Hg448/RkZGBjQajU1dAjt27EDXrl3h5+cHHx8ftG/fHj/88IP8+JkzZ+Dn54eBAwdaPG/nzp3QarV47bXX5G3Vq1dHnz59sGHDBjRp0gReXl6oUaMGFi5cWOh1U1JSMHToUAQGBsJgMKB+/fp47733YDabLfZbunQpmjZtivLly8PX1xf16tXDq6++Kj9eVBrcWleQ1L7169ejefPm8PLywqxZswDY9rnZ0p6izJo1C23atEFAQAD8/PzQokULLF++HHevxyy18fvvv0eLFi3g7e2NevXq4ZNPPil0zAMHDqB9+/bw8vJClSpVEBMTg5ycnBLbUtDZs2fRq1cvlC9fHqGhoXjxxReRlZVld9ul99varXPnzvJ+ixcvRseOHREYGIhy5cqhcePGePfddwu1u3PnzmjUqBH27t2Ldu3awcfHB0899RQA4K+//sKgQYPg6+sLf39/DB48GGlpaYXO7Y8//sATTzyBKlWqwGAwICgoCF27dkVycnKR70fnzp0xdOhQAECbNm2g0Wjk7iZrXWDWpKen46WXXrL4WZ04cSJu375tsd9XX32FNm3awN/fHz4+PqhRo4Z8jsW5uwts9+7d0Gg0WLVqFaZOnYoqVarAz88P3bp1w+nTp0s83pUrV/DMM88gNDQUBoMBlStXRvv27bFjxw55n4SEBPTr1w/VqlWDl5cXatWqhWeffRZXr161OJb083js2DEMHDgQ/v7+CAgIQHR0NIxGI06fPo1HHnkEvr6+qF69Ot59912L50vn8vnnnyM6OhrBwcHw9vZGp06dkJSUVOK5AMCaNWsQGRmJcuXKoXz58ujRo0eh597Ld0NtmAFSIZPJhF27dqFVq1aoVq2a1X1CQ0PRsmVL7Ny5EyaTCVqtVn6sf//+eOKJJzBmzBj5gjV69GisXLkSL730EqKionD8+HH0798fN2/etDhuWloaWrduDQ8PD0yfPh01a9ZEYmIi3njjDZw/fx4rVqyw2H/hwoWoU6cO5s6dCz8/P9SuXdtqe4UQeOyxx/DDDz8gJiYGHTp0wLFjxzBjxgwkJiYiMTERBoMBiYmJeP3117Fr1y7s3LkTQPF/tX7++ecYPnw4+vXrh08//RR6vR4ffvghevTogW3btqFr166oXbs2PvroIzzxxBNYuHAhxo8fj7S0NAwZMgQdOnTAzJkzLY6ZnJyMiRMnYubMmQgODsYXX3yBCRMmIDs7Gy+99BKA3Atuu3btkJ2djddffx3Vq1fHt99+i5deegm///47lixZAgBYvXo1xo4dixdeeAFz586Fh4cHzp49i5MnTxZ5TiU5cuQITp06hWnTpiEiIgLlypWz+XO7n/acP38ezz77LMLCwgDkBi8vvPACLl26hOnTp1vse/ToUbz44ouYMmUKgoKC8PHHH2PUqFGoVasWOnbsCAA4efIkunbtiurVqyM+Ph4+Pj5YsmQJvvzyS5vfi5ycHDz66KMYNWoUXnzxRezduxevv/46/P39LdpkS9t79+5daGxdYmIioqOj0bBhQ3nb77//jiFDhsjBwdGjR/Hmm2/if//7X6EgLzU1FUOHDsXkyZPx1ltvwcPDAxkZGejWrRv++usvxMbGok6dOvjuu+8wePDgQufXq1cvmEwmvPvuuwgLC8PVq1exf/9+iz8a7rZkyRKsWrUKb7zxBlasWIF69eqhcuXKNr+nd+7cQadOnfDnn3/i1VdfRZMmTXDixAlMnz4dv/76K3bs2AGNRoPExEQMHjwYgwcPxsyZM+Hl5YULFy7IP7f34tVXX0X79u3x8ccfIz09Ha+88gr69u2LU6dOWVzj7jZs2DAcOXIEb775JurUqYPr16/jyJEjuHbtmrzP77//jsjISDz99NPw9/fH+fPnMW/ePDz00EP49ddfodfrLY45aNAgDB06FM8++ywSEhLkIHfHjh0YO3YsXnrpJXz55Zd45ZVXUKtWLfTv37/QubRo0QIff/wxbty4gZkzZ6Jz585ISkpCjRo1ijyXt956C9OmTcOTTz6JadOmITs7G3PmzEGHDh3w888/o0GDBgDu7buhOoJUJy0tTQAQTzzxRLH7DR48WAAQf//9txBCiBkzZggAYvr06Rb7nTp1SgAQkyZNstj+xRdfCABixIgR8rZnn31WlC9fXly4cMFi37lz5woA4sSJE0IIIc6dOycAiJo1a4rs7OwSz+n7778XAMS7775rsX3NmjUCgFi2bJm8bcSIEaJcuXIlHvP27dsiICBA9O3b12K7yWQSTZs2Fa1bt7bY/txzzwlPT0+RmJgoHn74YREYGCj++usvi33Cw8OFRqMRycnJFtujoqKEn5+fuH37thBCiClTpggA4uDBg4VeQ6PRiNOnTwshhHj++edFhQoVij0P6XO724oVKwQAce7cOYv2abVa+fgSWz83W9pjC5PJJHJycsTs2bNFxYoVhdlstmijl5eXRVsyMjJEQECAePbZZ+VtgwcPFt7e3iItLU3eZjQaRb169QqdtzUjRowQAMTatWsttvfq1UvUrVv3ntpe0P/+9z9RsWJF0aVLF5GVlVXssVauXCm0Wq34559/5Mc6deokAIgffvjB4jlLly4VAMQ333xjsX306NECgFixYoUQQoirV68KACIuLq7IcymK9N355ZdfLLaPGDFChIeHW2wLDw+3uAbExsYKDw+PQs/9+uuvBQCxZcsWIUT+d+v69et2t+/u19y1a5cAIHr16mWx39q1awUAkZiYWOzxypcvLyZOnGjz65vNZpGTkyMuXLhQ6LOQfh7fe+89i+c0a9ZMABDr16+Xt+Xk5IjKlSuL/v37FzqXFi1aWHy3zp8/L/R6vXj66acLvZYkJSVF6HQ68cILL1i89s2bN0VwcLAYNGiQEOL+vhtqwi4wNyby0vd3d588/vjjFvelbqn//ve/FtsHDRpUqHvt22+/RZcuXVClShUYjUb51rNnTwDAnj17LPZ/9NFHC/3lZI30V+HdlR8DBw5EuXLlLLqsbLV//378888/GDFihEVbzWYzHnnkEfzyyy8WKfv58+ejYcOG6NKlC3bv3o3PP/8cISEhhY7bsGFDNG3a1GLbkCFDkJ6ejiNHjsjn06BBA4vxFdL5CSHk823dujWuX7+O//znP/jmm28KpdvvRZMmTVCnTh2LbbZ+bvfTnp07d6Jbt27w9/eHVquFXq/H9OnTce3aNVy+fNli32bNmsnZFgDw8vJCnTp1cOHCBXnbrl270LVrVwQFBcnbtFqt1UxIUTQaDfr27WuxrUmTJhavY2/bgdxM6COPPIKQkBBs2LABnp6e8mNJSUl49NFHUbFiRflYw4cPh8lkwm+//WZxnAceeAAPP/ywxbZdu3bB19cXjz76qMX2IUOGWNwPCAhAzZo1MWfOHMybNw9JSUmFulcd4dtvv0WjRo3QrFkzi+9Sjx49oNFosHv3bgDAgw8+CCD3OrJ27VpcunTpvl/77vekSZMmAFDo87xb69atER8fjzfeeAMHDhyw2o16+fJljBkzBqGhodDpdNDr9QgPDwcAnDp1qtD+ffr0sbhfv359aDQa+WcKyB2OUKtWLavtGzJkiMW1OTw8HO3atSt2mMC2bdtgNBoxfPhwi/fey8sLnTp1kt97V303yhoGQCpUqVIl+Pj44Ny5c8Xud/78efj4+CAgIMBi+92/1KU0cHBwsMV2nU6HihUrWmz7+++/sXnzZuj1eoub1AVw9y9MawGENdeuXYNOpyuUitdoNAgODrZIVdvq77//BgAMGDCgUHvfeecdCCHwzz//yPsbDAYMGTIEmZmZaNasGaKioqwe9+73qeA2qZ3Xrl2zeu5VqlSx2G/YsGH45JNPcOHCBTz++OMIDAxEmzZtkJCQYPf5Sqy9rq2f27225+eff0b37t0BAB999BF++ukn/PLLL5g6dSqA3IHYBd39vQJy3/+C+127dq3Y99oWPj4+8PLyKvQ6mZmZ99z2mzdvolevXsjJycHWrVvh7+8vP5aSkoIOHTrg0qVLWLBgAfbt24dffvkFixcvtnosa5/VtWvXLIK+os5bo9Hghx9+QI8ePfDuu++iRYsWqFy5MsaPH1+o67o0/f333zh27Fih75Kvry+EEPJ3qWPHjti4caP8C7tatWpo1KgRVq1adc+vfff3RiqouPt9vduaNWswYsQIfPzxx4iMjERAQACGDx8uj6sym83o3r071q9fj8mTJ+OHH37Azz//jAMHDhR5/Luvq56enla/b56enhbfN0lR3+3irnXSNe3BBx8s9P6vWbNGfu9d9d0oazgGSIW0Wi26dOmC77//Hn/++afVcUB//vknDh8+jJ49exbqG787IyRdVNLS0lC1alV5u9FoLPTDWKlSJTRp0gRvvvmm1bZJv+CLeq2iVKxYEUajEVeuXLEIgoQQSEtLk/+atEelSpUA5E4X0LZtW6v7FPxFc/z4cUyfPh0PPvggfvnlF8ybNw/R0dGFnmNtMKq0TXovK1asiNTU1EL7/fXXXxZtA4Ann3wSTz75JG7fvo29e/dixowZ6NOnD3777TeEh4fLF9SsrCyLCrqisjPW3nN7PreS2mPN6tWrodfr8e2331r8Ati4caPV/W1RsWLFYt/r0mJP23NycvD444/j999/x759+wr97G3cuBG3b9/G+vXrLd6rogaeWvusKlasaLUAwdp5h4eHY/ny5QCA3377DWvXrsXMmTORnZ2NDz74wOpr3q9KlSrB29vb6qB16XFJv3790K9fP2RlZeHAgQOIjY3FkCFDUL16dURGRjqkfUW1KS4uDnFxcUhJScGmTZswZcoUXL58Gd9//z2OHz+Oo0ePIj4+HiNGjJCfd/bsWYe1qajvtrU/DiTSe/v1118X+bMoccV3o6xhBkilYmJiIITA2LFjYTKZLB4zmUx47rnnIIRATExMiceSKli++OILi+1r164tVCHUp08fHD9+HDVr1kSrVq0K3e4OgGzVtWtXALmDlgtat24dbt++LT9uj/bt26NChQo4efKk1ba2atVK7rq4ffs2Bg4ciOrVq2PXrl14/vnnMWXKFBw8eLDQcU+cOIGjR49abPvyyy/h6+uLFi1ayOdz8uRJuUtMsnLlSmg0GnTp0qXQccuVK4eePXti6tSpyM7OlkuVpaqcY8eOWey/efNmm9+Le/ncimqPNRqNBjqdziLYzsjIwGeffWZzG+/WpUsX/PDDD/JfvUDud3vNmjX3fExr7Gn7qFGjsHv3bqxfv17ufrn7WAAsAlUhBD766COb29OlSxfcvHkTmzZtsthe0uDvOnXqYNq0aWjcuHGh711p6tOnD37//XdUrFjR6nfJWhWZwWBAp06d8M477wCAzdVOjhAWFobnn38eUVFR8vtk7XMDgA8//NBh7Vi1apVFleGFCxewf/9+i4rCu/Xo0QM6nQ6///57kdc0a5z13ShrmAFSqfbt2yMuLg4TJ07EQw89hOeffx5hYWHyRIgHDx5EXFwc2rVrV+Kx6tevj6FDhyIuLg56vR7dunXD8ePH5cqtgmbPno2EhAS0a9cO48ePR926dZGZmYnz589jy5Yt+OCDD4qsTCtOVFQUevTogVdeeQXp6elo3769XAXWvHlzDBs2zO5jli9fHosWLcKIESPwzz//YMCAAQgMDMSVK1dw9OhRXLlyBUuXLgUAjBkzBikpKfj5559Rrlw5vPfee0hMTMQTTzyBpKQkVKhQQT5ulSpV8Oijj2LmzJkICQnB559/joSEBLzzzjvyHC6TJk3CypUr0bt3b8yePRvh4eH47rvvsGTJEjz33HPyGJ3Ro0fD29sb7du3R0hICNLS0hAbGwt/f38569WrVy8EBARg1KhRmD17NnQ6HeLj43Hx4kWb3wtbPzdb2mNN7969MW/ePAwZMgTPPPMMrl27hrlz597XnE/Tpk3Dpk2b8PDDD2P69Onw8fHB4sWLC5Va3y9b2z5nzhx89tlneOGFF1CuXDm5ewQA/Pz80KBBA0RFRcHT0xP/+c9/MHnyZGRmZmLp0qX4999/bW7P8OHDMX/+fAwfPhxvvvkmateujS1btmDbtm0W+x07dgzPP/88Bg4ciNq1a8PT0xM7d+7EsWPHMGXKlPt7U4oxceJErFu3Dh07dsSkSZPQpEkTmM1mpKSkYPv27XjxxRfRpk0bTJ8+HX/++Se6du2KatWq4fr161iwYAH0ej06derksPbd7caNG+jSpQuGDBmCevXqwdfXF7/88gu+//57uTKrXr16qFmzJqZMmQIhBAICArB58+b76oouyeXLl/F///d/GD16NG7cuIEZM2bAy8ur2D9aq1evjtmzZ2Pq1Kn4448/8Mgjj+CBBx7A33//LV+7Zs2a5bLvRpnjqtHX5ByJiYliwIABIigoSOh0OhEYGCj69+8v9u/fX2hfqaLgypUrhR7LysoSL774oggMDBReXl6ibdu2IjExsVA1hhBCXLlyRYwfP15EREQIvV4vAgICRMuWLcXUqVPFrVu3hBD5VWBz5syx+VwyMjLEK6+8IsLDw4VerxchISHiueeeE//++6/FfrZWgUn27NkjevfuLQICAoRerxdVq1YVvXv3Fl999ZUQQoiPPvrIorpGcvbsWeHn5ycee+wxeVt4eLjo3bu3+Prrr0XDhg2Fp6enqF69upg3b16h171w4YIYMmSIqFixotDr9aJu3bpizpw5wmQyyft8+umnokuXLiIoKEh4enqKKlWqiEGDBoljx45ZHOvnn38W7dq1E+XKlRNVq1YVM2bMEB9//LHVKrDevXtbfR9s+dxsbY81n3zyiahbt64wGAyiRo0aIjY2VixfvtzmNnbq1El06tTJYttPP/0k2rZtKwwGgwgODhYvv/yyWLZsmc1VYNa+J9aq6mxpu1RVZu1WsN2bN28WTZs2FV5eXqJq1ari5ZdfFlu3bhUAxK5duyzOt2HDhlbb/ueff4rHH39clC9fXvj6+orHH39c7N+/3+J7+vfff4uRI0eKevXqiXLlyony5cuLJk2aiPnz5wuj0Vjse3M/VWBCCHHr1i0xbdo0UbduXeHp6Sn8/f1F48aNxaRJk+SqvW+//Vb07NlTVK1aVXh6eorAwEDRq1cvsW/fvmLbZu01pcop6WdWIl1n7v7ZLSgzM1OMGTNGNGnSRPj5+Qlvb29Rt25dMWPGDLlqUwghTp48KaKiooSvr6944IEHxMCBA0VKSooAIGbMmCHvV9R1tKjv292fs3Qun332mRg/fryoXLmyMBgMokOHDuLQoUMWzy2qAnTjxo2iS5cuws/PTxgMBhEeHi4GDBggduzYIYS4v++GmmiEuGsWMiK6Z9WrV0ejRo3w7bffuropRKRAu3fvRpcuXfDVV19hwIABrm6OqnEMEBEREbkdBkBERETkdtgFRkRERG6HGSAiIiJyOwyAiIiIyO0wACIiIiK3w4kQrTCbzfjrr7/g6+tr81INRERE5FpCCNy8eRNVqlSBh0fxOR4GQFb89ddfCA0NdXUziIiI6B5cvHixxFUHGABZ4evrCyD3Dbx7qQciIiIqm9LT0xEaGir/Hi8OAyArpG4vPz8/BkBEREQKY8vwFQ6CJiIiIrfDAIiIiIjcDgMgIiIicjscA0RERKpkMpmQk5Pj6mZQKfP09CyxxN0WDICIiEhVhBBIS0vD9evXXd0UcgAPDw9ERETA09Pzvo7DAIiIiFRFCn4CAwPh4+PDCW1VRJqoODU1FWFhYff12TIAIiIi1TCZTHLwU7FiRVc3hxygcuXK+Ouvv2A0GqHX6+/5OBwETUREqiGN+fHx8XFxS8hRpK4vk8l0X8dhAERERKrDbi/1Kq3PlgEQERERuR2XBkCxsbF48MEH4evri8DAQDz22GM4ffp0ic/bs2cPWrZsCS8vL9SoUQMffPBBoX3WrVuHBg0awGAwoEGDBtiwYYMjToGIiIgUyKUB0J49ezBu3DgcOHAACQkJMBqN6N69O27fvl3kc86dO4devXqhQ4cOSEpKwquvvorx48dj3bp18j6JiYkYPHgwhg0bhqNHj2LYsGEYNGgQDh486IzTIiIiojJOI4QQrm6E5MqVKwgMDMSePXvQsWNHq/u88sor2LRpE06dOiVvGzNmDI4ePYrExEQAwODBg5Geno6tW7fK+zzyyCN44IEHsGrVqhLbkZ6eDn9/f9y4cYOLoZJVZrPAXzcyXN0MskOl8gZ46bWFH7h1BTDys1SLzGwjzl25jYjwcHh5GVzdHELuwHSr1VoaD0BrfxVXZmYmzp07h4iICHh5eVk8Zs/v7zJVBn/jxg0AQEBAQJH7JCYmonv37hbbevTogeXLl8tvcmJiIiZNmlRon7i4OKvHzMrKQlZWlnw/PT39Hs+A3MXTKw9h5/8uu7oZZIdAXwP2vNwF3p4FgqDDnwKbx7uuUVT6yocC7d8D/skBdMobCC2EwJyln+KDz9Yh9fJV1IkIw2sTR+Px3l0R9cRz0Om02Pr5+9BoNLh+4yaadBuMYY/3wptTnsfu/YfQZeAz+PbTBXj17fdx+o8LaNqgDj6e8xoa168tv8a6737A9LlLcfb8RYQEVsILTz6BF8cMkx9fEr8W8z/6AhdT/4a/b3l0aN0cX380BwBQvU1vTHx6CCaO/q+8f7OoJ/DYI50x88UxAABN1RZYGvsqtu76CTv2HcRLY4Zh1kvPYfP2PZg570Oc+O0PVAmqjBGD+2PqW/Og0+WGIjNnzsQnn3yCv//+GxUrVsSAAQOwcOFCh73XZSYAEkIgOjoaDz30EBo1alTkfmlpaQgKCrLYFhQUBKPRiKtXryIkJKTIfdLS0qweMzY2FrNmzbr/kyC3cfjCvwAAT60HWGxS9mUZzbh8MwuXrmegVmD5/Af+/Dn3X432nv4SpTJIa0DuD6V0y/39kmF0TWeHt05jV9XStHcWY/3WnVga+ypqR4Rh74EjGDp+GipXfACfxr2Oxt0GYuHy1Zjw9BCMmfImgioH5AUe+ef78htxWDB7MoIrV8Srb7+PR5+chN/2bYRer8fhYycxaMwrmBn9LAY/2gP7Dx3F2FdjUfGBChg5+FEcOnoC46fPwWcLX0e7Vk3xz/V07Dt4RD52Ls1d9wtvm/HeB4iNeQHzZ74ErdYD23YnYuj417Bw9svo0KYFfr/wJ5555U2gXEXMmDEDX3/9NebPn4/Vq1ejYcOGSEtLw9GjR+/tTbdRmQmAnn/+eRw7dgw//vhjifve/WWSevEKbre2T1FfwpiYGERHR8v309PTERoaanPbyf1k5uTOP7Hr5c6oWsHbxa2hkrR6IwFXb2XDaDZbPpCTmftvjzeBts85v2FU+jIzgXPngMAIIK97JCPbiAbTt7mkOSdn94CPp22/am/fvo15H32BnTt3IjIyEgBQI7IPfjyRgg/X7cSXX36JD5d9jGHDhuHvTB027/gRSUlJ0IfXyT1ApesAgBmvxyJq8GAAwKfNu6JatWrYcPAcBg0ahHkvz0HXrl3x2pwlAIA6HfrhZOotzPl4DUZOmo6UA3+gXLly6DPsefj6+iIcQPPuT+Q3UusJ+FcFqjTL36b3BnyDLbYNGTocT0XPlO8Pe6kjpsS8ihETY/LOC3jdWB6TJ0/GjBkzkJKSguDgYHTr1g16vR5hYWFo3bq1rW/zPSkTZfAvvPACNm3ahF27dqFatWrF7hscHFwok3P58mXodDp51s+i9rk7KyQxGAzw8/OzuBEVxWwWyDLm/iL10pWJHyEqgS5v4USj6a4sQE7e2B+dF4hc7eTJk8jMzERUVBTKly8v31auXInff/8dADBw4ED0798fsbGxeO+991CnTp1Cx5GCJyB3SEndunXlcbOnTp1C+/btLfZv3749zpw5A5PJhKioKISHh6NGjRoYNmwYvvjiC9y5c8fuc2nVqpXF/cOHD2P27NkW5zV69Gikpqbizp07GDhwIDIyMlCjRg2MHj0aGzZsgNFotPt17eHSDJAQAi+88AI2bNiA3bt3IyIiosTnREZGYvPmzRbbtm/fjlatWsmDrCIjI5GQkGAxDmj79u1o165d6Z4AuaVMY/7soxbjSajM0nrkZn+N5rsDoLwLu56zBquZt16Lk7N7uOy1bWXOy1B+9913qFq1qsVjBkPugO47d+7g8OHD0Gq1OHPmjM3HlnpArPWGFKyF8vX1xZEjR7B7925s374d06dPx8yZM/HLL7+gQoUK8PDwwN21U9Ls2wWVK1eu0LnNmjUL/fv3L7Svl5cXQkNDcfr0aSQkJGDHjh0YO3Ys5syZgz179tzXchfFcWkANG7cOHz55Zf45ptv4OvrK2dt/P394e2d260QExODS5cuYeXKlQByK77ef/99REdHY/To0UhMTMTy5cstqrsmTJiAjh074p133kG/fv3wzTffYMeOHTZ1rxGVJDMnvxvFS8cASAn02rwAyHRXF5gxrwtMz25MNdNoNDZ3Q7mSNHddSkoKOnXqZHWfF198ER4eHti6dSt69eqF3r174+GHH7bY58CBAwgLCwMA/Pvvv/jtt99Qr149+TXu/l24f/9+1KlTB1pt7vVMp9OhW7du6NatG2bMmIEKFSpg586d6N+/PypXrozU1FT5uenp6Th37lyJ59aiRQucPn0atWrVKnIfb29vPProo3j00Ucxbtw41KtXD7/++itatGhR4vHvhUu/EUuXLgUAdO7c2WL7ihUrMHLkSABAamoqUlJS5MciIiKwZcsWTJo0CYsXL0aVKlWwcOFCPP744/I+7dq1w+rVqzFt2jS89tprqFmzJtasWYM2bdo4/JxI/TLyxv946jzg4cER0Eqg0+Z2geUU6gKTMkAMgMj1fH198dJLL2HSpEkwm8146KGHkJ6ejv3796N8+fKoVKkSPvnkEyQmJqJFixaYMmUKRowYgWPHjuGBBx6QjzN79mxUrFgRQUFBmDp1KipVqoTHHnsMQG4A9eCDD+L111/H4MGDkZiYiPfffx9LluSOCfr222/xxx9/oGPHjnjggQewZcsWmM1m1K1bFwDw8MMPIz4+Hn379sUDDzyA1157TQ6cijN9+nT06dMHoaGhGDhwIDw8PHDs2DH8+uuveOONNxAfHw+TyYQ2bdrAx8cHn332Gby9vREeHl76b7REUCE3btwQAMSNGzdc3RQqg878fVOEv/KtaDJzm6ubQjbqMX+PCH/lW7H3t8uWDyxqJcQMPyHO7XNNw6jUZWRkiJMnT4qMjAxXN+WemM1msWDBAlG3bl2h1+tF5cqVRY8ePcTu3btFUFCQeOutt+R9c3JyROvWrcWgQYOEEELs2rVLABCbN28WDRs2FJ6enuLBBx8UycnJFq/x9ddfiwYNGgi9Xi/CwsLEnDlz5Mf27dsnOnXqJB544AHh7e0tmjRpItasWSM/fuPGDTFo0CDh5+cnQkNDRXx8vGjatKmYMWOGvA8AsWHDhkLn9v3334t27doJb29v4efnJ1q3bi2WLVsmhBBiw4YNok2bNsLPz0+UK1dOtG3bVuzYscPqe1TcZ2zP7+8yNRFiWcGJEKk4xy/dQJ9FPyLYzwsHXu3q6uaQDfou+hG/XrqBFSMfRJd6gfkPzG8M3EgBRu8EqrZ0XQOp1BQ3SZ7a7d69G126dMG///6LChUquLo5DlNaEyGyhIXITlIJvJeePz5KocsbA5Rz9xggqQtMxy4wInfDKziRnTLkAIgDoJVClzdWy1SoCiyvDJ5jgIjcTtkfFk9UxkhVYCyBVw5pHqCcggGQEPlrgLEMnlSgc+fOhUrUqWjMABHZSc4AsQReMXTWyuBN2YDIu693r7EiRMQAiMhumdm5ARAzQMqh11qZCTqnwOy2zAARuR0GQER2kmaCtmeGV3ItaQxQTsG1wKTxPx46LoRK5IYYABHZKSMvA2RgFZhiWM8ASeuAcQA0kTviFZzITtIYIGaAlMPqWmCsACNyawyAiOwkV4ExAFIMq4OgGQARuTUGQER2yuQ8QIqjzyuDt8gAGRkAUdnSuXNnTJw40dXNsEn16tURFxfn6mbcFwZARHbKYBWY4lidCZoZICK3xgCIyE5SFRgzQMpRbBk8S+CJrDKZTDCbzSXvqFAMgIjsJGWAuBaYclgvg8/Me5CTIFLZYTabMXnyZAQEBCA4OBgzZ86UH5s3bx4aN26McuXKITQ0FGPHjsWtW7fkxzt37gyNRlPodv78eZueHx8fjwoVKuDbb79FgwYNYDAYcOHCBVy+fBl9+/aFt7c3IiIi8MUXXxRq98yZMxEWFgaDwYAqVapg/PjxDnuPSguXwiCyE6vAlEeb1wVmspoBYheY6glhOfGlM+l9AI3G5t0//fRTREdH4+DBg0hMTMTIkSPRvn17REVFwcPDAwsXLkT16tVx7tw5jB07FpMnT8aSJUsAAOvXr0d2drZ8rHHjxuHEiRMICgoCgBKfDwB37txBbGwsPv74Y1SsWBGBgYEYOHAgLl68iJ07d8LT0xPjx4/H5cuX5ed8/fXXmD9/PlavXo2GDRsiLS0NR48evd93zuEYABHZKZMBkOJYHQSdw3XA3EbOHeCtKq557Vf/AjzL2bx7kyZNMGPGDABA7dq18f777+OHH35AVFSUxQDpiIgIvP7663juuefkACYgIEB+fP78+di5cycOHjwIb+/cIL+k5wNATk4OlixZgqZNmwIAfvvtN2zduhUHDhxAmzZtAADLly9H/fr15eekpKQgODgY3bp1g16vR1hYGFq3bm3zObsKc/hEdpLK4DkGSDmsDoKWq8DYBUZlR5MmTSzuh4SEyNmWXbt2ISoqClWrVoWvry+GDx+Oa9eu4fbt2xbP2bp1K6ZMmYI1a9agTp068nZbnu/p6WnRhlOnTkGn06FVq1bytnr16qFChQry/YEDByIjIwM1atTA6NGjsWHDBhiNxlJ5PxyJGSAiO2WwDF5xip0Jmhkg9dP75GZiXPXa9uyut1yWRaPRwGw248KFC+jVqxfGjBmD119/HQEBAfjxxx8xatQo5OTkyPufPHkSTzzxBN5++210795d3m7r8729vaEp0GUnrS6vKaYbLzQ0FKdPn0ZCQgJ27NiBsWPHYs6cOdizZ0+h8ylLGAAR2Yll8MpT7FpgHAOkfhqNXd1QZdGhQ4dgNBrx3nvvwSOvS3ft2rUW+1y7dg19+/ZF//79MWnSJLufb039+vVhNBpx6NAhuVvr9OnTuH79usV+3t7eePTRR/Hoo49i3LhxqFevHn799Ve0aNHiXk/Z4RgAEdkpy8gqMKXRcS0wUriaNWvCaDRi0aJF6Nu3L3766Sd88MEHFvv0798f3t7emDlzJtLS0uTtlStXtun51tStWxePPPIIRo8ejWXLlkGn02HixInyuCIgt3rMZDKhTZs28PHxwWeffQZvb2+Eh4eX3hvgALyCE9lJzgCxC0wxpAyQiWuBkUI1a9YM8+bNwzvvvINGjRrhiy++QGxsrMU+e/fuxYkTJ1C9enWEhITIt4sXL9r0/KKsWLECoaGh6NSpE/r3749nnnkGgYGB8uMVKlTARx99hPbt26NJkyb44YcfsHnzZlSsWLFU34PSphFSBx/J0tPT4e/vjxs3bsDPz8/VzaEyRAiBmq9ugVkAP7/aFYF+HECrBF8cvICpG46je4MgLBueN5hzzTDg1Cag11yg9WjXNpBKTWZmJs6dO4eIiAh4efHnU42K+4zt+f3NDBCRHXJMAlISwcAMkGJYXwssbyJEZoCI3BIDICI7SBVgALvAlIRrgRHR3RgAEdlBmgRR66GBXmv77K7kWtYHQXMtMCJ3xgCIyA4FZ4Eubl4MKlv0eYOgjdbWAmMGiMgtMQAiskP+JIj80VESrTQPkLUMEMvgVYn1PepVWp8tr+JEdshfCZ7jf5REmgmaZfDqJ808fOeOixY/JYeTFnzVau/vOsyJEInsIK0DxgHQylL8IGiOAVITrVaLChUqyOtn+fj4sLtaRcxmM65cuQIfHx/odPcXwjAAIrJDJtcBUySd1TJ4LoaqVsHBwQAgB0GkLh4eHggLC7vvwJYBEJEdMnI4C7QSSRV7RikDZDICpuy8B5kBUhuNRoOQkBAEBgZaLPRJ6uDp6SmvZ3Y/XBoA7d27F3PmzMHhw4eRmpqKDRs24LHHHity/5EjR+LTTz8ttL1BgwY4ceIEgNw1SZ588slC+2RkZHBWULpvcgaIC6EqilQGLw+ClrI/AMcAqZhWq73vcSKkXi4dBH379m00bdoU77//vk37L1iwAKmpqfLt4sWLCAgIwMCBAy328/Pzs9gvNTWVwQ+VCrkKTMf6ASXR3V0GL5XAA4CO1wYid+TSDFDPnj3Rs2dPm/f39/eHv7+/fH/jxo34999/C2V8NBqN3AdMVJrkhVCZAVIUaRC0XAVWsASeA2SJ3JKi/4xdvnw5unXrhvDwcIvtt27dQnh4OKpVq4Y+ffogKSmp2ONkZWUhPT3d4kZkTZaRVWBKJA2ClrvAWAJP5PYUGwClpqZi69atePrppy2216tXD/Hx8di0aRNWrVoFLy8vtG/fHmfOnCnyWLGxsXJ2yd/fH6GhoY5uPikU5wFSpkKDoI0MgIjcnWIDoPj4eFSoUKHQoOm2bdti6NChaNq0KTp06IC1a9eiTp06WLRoUZHHiomJwY0bN+TbxYsXHdx6UqoMlsErkjwI2swMEBHlUmQZvBACn3zyCYYNGwZPT89i9/Xw8MCDDz5YbAbIYDDAYDCUdjNJhTJZBq9I8lpgUgZIXgiVARCRu1JkBmjPnj04e/YsRo0aVeK+QggkJycjJCTECS0jteNaYMokrQVmFoDZLPKrwLgOGJHbcmkG6NatWzh79qx8/9y5c0hOTkZAQADCwsIQExODS5cuYeXKlRbPW758Odq0aYNGjRoVOuasWbPQtm1b1K5dG+np6Vi4cCGSk5OxePFih58PqZ+cAWIVmKJIXWBA7mzQnuwCI3J7Lg2ADh06hC5dusj3o6OjAQAjRoxAfHw8UlNTkZKSYvGcGzduYN26dViwYIHVY16/fh3PPPMM0tLS4O/vj+bNm2Pv3r1o3bq1406E3Ia0FhjHACmLNAgayJ0LyFPuAuMs0ETuyqUBUOfOnYtd1j4+Pr7QNn9//2JX+Z0/fz7mz59fGs0jKoRVYMqkKzBtfo5JAMa8LjCuA0bktjiQgcgOXAtMmSwyQCZzgUHQzAARuSsGQER2YBWYMmk0GnkgtNEsWAZPRAyAiOyRySowxZICoByTOT8A4jpgRG6LV3EiO3AiROWS5gIyWWSA2AVG5K4YABHZgYuhKpc8G7SJXWBExACIyC6ZRpbBK5W8HpjZzJmgiYgBEJGtTGaBbK4Gr1hSKbzRogyeARCRu2IARGQjaQA0wABIiXTagoOgWQZP5O4YABHZqGAAZNDxR0dpdNbK4FkFRuS2eBUnspFUAWbQecDDQ1PC3lTWSIOgjSZWgRERAyAim3EhVGXLzwCZWQVGRAyAiGwlL4SqYwCkRHqrGSB2gRG5KwZARDbKYAZI0SwGQRvZBUbk7hgAEdmIK8Erm14qg+daYEQEBkBENuM6YMomZ4CMpvwyeB0DICJ3xSs5kY0yuBK8okmLoZpzsvI3MgNE5LYYABHZKJMBkKJJg6A1UvcXwACIyI0xACKykVwFxkHQiqSTM0C3czd46AGt3oUtIiJXYgBEZCOpC4xl8MokZYCQw3XAiIgBEJHNpCowb0/+2CiRNAiaK8ETEcAAiMhmmUaOAVIyaTV4jZEl8ETEAIjIZpmcB0jRpDFAchcYS+CJ3BoDICIbyWOAGAApktQF5mFiBoiIGAAR2UyqAmMXmDJJg6A9uBI8EYEBEJHNmAFSNqkLTGOSqsC4ECqRO2MARGQjeSJEVoEpkk7KABlZBk9EDICIbMaZoJVNnzcGSMuV4IkIDICIbCZ1gRkYACmStBaYh1mqAmMXGJE7YwBEZCN5IkQGQIokDYLWyl1gzAARuTMGQEQ2YhWYskmDoHVmjgEiIgZARDbLZBWYokmDoLUmBkBE5OIAaO/evejbty+qVKkCjUaDjRs3Frv/7t27odFoCt3+97//Wey3bt06NGjQAAaDAQ0aNMCGDRsceBbkLjI4CFrRpEHQzAAREeDiAOj27dto2rQp3n//fbued/r0aaSmpsq32rVry48lJiZi8ODBGDZsGI4ePYphw4Zh0KBBOHjwYGk3n9yIECI/A8QyeEWS1gLTmbJyNzAAInJrOle+eM+ePdGzZ0+7nxcYGIgKFSpYfSwuLg5RUVGIiYkBAMTExGDPnj2Ii4vDqlWr7qe55MayTWaYRe7/2QWmTNIYIL2Za4ERkULHADVv3hwhISHo2rUrdu3aZfFYYmIiunfvbrGtR48e2L9/f5HHy8rKQnp6usWNqKDMbLP8f3aBKZO0FpheMANERAoLgEJCQrBs2TKsW7cO69evR926ddG1a1fs3btX3ictLQ1BQUEWzwsKCkJaWlqRx42NjYW/v798Cw0Nddg5kDJlGnO7v3QeGrmcmpRFGgQtZ4BYBk/k1lzaBWavunXrom7duvL9yMhIXLx4EXPnzkXHjh3l7RqNxuJ5QohC2wqKiYlBdHS0fD89PZ1BEFmQ5gBi95dy6fO6wDzlDBAnQiRyZ4r/U7Zt27Y4c+aMfD84OLhQtufy5cuFskIFGQwG+Pn5WdyICuJCqMonZYA8zVIAxAwQkTtTfACUlJSEkJAQ+X5kZCQSEhIs9tm+fTvatWvn7KaRimRwIVTFk8YAeXIMEBHBxV1gt27dwtmzZ+X7586dQ3JyMgICAhAWFoaYmBhcunQJK1euBJBb4VW9enU0bNgQ2dnZ+Pzzz7Fu3TqsW7dOPsaECRPQsWNHvPPOO+jXrx+++eYb7NixAz/++KPTz4/UQy6B1zEDpFRSFZhBCoBYBUbk1lwaAB06dAhdunSR70vjcEaMGIH4+HikpqYiJSVFfjw7OxsvvfQSLl26BG9vbzRs2BDfffcdevXqJe/Trl07rF69GtOmTcNrr72GmjVrYs2aNWjTpo3zToxUR14J3pMBkFJJ8wB5Ijt3AzNARG5NI4QQrm5EWZOeng5/f3/cuHGD44EIAPDdsVSM+/IIWkcEYO2zka5uDt2DQ+f/wRMf7MNZr+G5GyafA3wCXNsoIipV9vz+5oAGIhtwHTDl02k94CVlfwBmgIjcHAMgIhvkrwPGHxml0nlo4IWcAhtYBk/kzng1J7JBJhdCVTy91gNemgIl8MXMDUZE6scAiMgG7AJTPq2HBt5SFxizP0RujwEQkQ04EaLy6bUaeIOTIBJRLgZARDbIyFsMlWXwymUxCJoDoIncHgMgIhtIi6FyIkTl0nto4K2RAiB2gRG5OwZARDbIzOZSGEqXmwHK7QITOnaBEbk7Xs2JbJDBKjDF02k1cheYYAaIyO0xACKyAavAlE9XoAvMzHXAiNweAyAiG7AKTPl0Hh5yFZhZywwQkbtjAERkg4ycvCowBkCKpdfmzwTNDBARMQAiskEWV4NXPI1GAx+PvC4wLQMgInfHAIjIBvldYPyRUTKfvKUwTFqDi1tCRK7GqzmRDTKyOQZIDXw0uV1gJo4BInJ7DICIbMDFUNXBJ68KzMgAiMjtMQAiskFm3iBoZoCUTSqDN3owACJydwyAiEpgMgtkm1gFpgbSavDsAiMiBkBEJZC6vwBWgSmdlAHKYQaIyO0xACIqQUaBAMig44+MkklrgeV4sAqMyN3xak5UgvwKMA9oNBoXt4buh7QWGAMgImIARFSCLCMrwNRCCoCyNewCI3J3DICISpCRzQowtTDIXWCeLm4JEbkaAyCiEmRwDiDVMAhmgIgoFwMgohJkciV41TCI3AxQtoZjgIjcHQMgohJwHTCVMJvlLrAssAuMyN3xik5UgkyuBK8Oxkz5v1nsAiNyewyAiEoglcFzDJDCFQyAoHdhQ4ioLGAARFQCKQNkYACkbDl3AADZQotswc+SyN0xACIqQUYO1wFThZwMAEAmDDDmre1GRO6LARBRCVgGrxJ5AVAGPGE0Cxc3hohczaUB0N69e9G3b19UqVIFGo0GGzduLHb/9evXIyoqCpUrV4afnx8iIyOxbds2i33i4+Oh0WgK3TIzM4s4KlHxslgFpg5SBkgwACIiFwdAt2/fRtOmTfH+++/btP/evXsRFRWFLVu24PDhw+jSpQv69u2LpKQki/38/PyQmppqcfPyYtUH3RtmgFQibwxQBrvAiAiAzpUv3rNnT/Ts2dPm/ePi4izuv/XWW/jmm2+wefNmNG/eXN6u0WgQHBxcWs0kNycvhsoyeGXLqwLLhCdyTMwAEbk7Ref0zWYzbt68iYCAAIvtt27dQnh4OKpVq4Y+ffoUyhDdLSsrC+np6RY3IkmmMW8tMB0DIEXLywBlwhNGMzNARO5O0QHQe++9h9u3b2PQoEHytnr16iE+Ph6bNm3CqlWr4OXlhfbt2+PMmTNFHic2Nhb+/v7yLTQ01BnNJ4WQ5wFiBkjZpEHQwhNGZoCI3J5iA6BVq1Zh5syZWLNmDQIDA+Xtbdu2xdChQ9G0aVN06NABa9euRZ06dbBo0aIijxUTE4MbN27It4sXLzrjFEghMjkGSB3kKjADB0ETkWvHAN2rNWvWYNSoUfjqq6/QrVu3Yvf18PDAgw8+WGwGyGAwwGDg4ohkXSarwNRBngfIk4Ogici+DFBOTg66dOmC3377zVHtKdGqVaswcuRIfPnll+jdu3eJ+wshkJycjJCQECe0jtQog6vBq0OBMvgcZoCI3J5dGSC9Xo/jx49Do9GUyovfunULZ8+ele+fO3cOycnJCAgIQFhYGGJiYnDp0iWsXLkSQG7wM3z4cCxYsABt27ZFWloaAMDb2xv+/v4AgFmzZqFt27aoXbs20tPTsXDhQiQnJ2Px4sWl0mZyPyyDVwljgS4wZoCI3J7dOf3hw4dj+fLlpfLihw4dQvPmzeUS9ujoaDRv3hzTp08HAKSmpiIlJUXe/8MPP4TRaMS4ceMQEhIi3yZMmCDvc/36dTzzzDOoX78+unfvjkuXLmHv3r1o3bp1qbSZ3E+WtBQGB0ErW8GZoDkImsjt2T0GKDs7Gx9//DESEhLQqlUrlCtXzuLxefPm2Xyszp07Q4iiL0Tx8fEW93fv3l3iMefPn4/58+fb3AaikrALTCWkMnh2gRER7iEAOn78OFq0aAEAhcYClVbXGFFZIpfBMwBStpzciRAz4AkT5wEicnt2B0C7du1yRDuIyiQhBDKNzACpgjwRooEzQRPRvc8DdPbsWWzbtg0ZGbn96sV1ZREpVZbRDOmrzTJ4hSu4GCoHQRO5Pbuv6NeuXUPXrl1Rp04d9OrVC6mpqQCAp59+Gi+++GKpN5DIlaQ5gABmgBSv4CBojgEicnt2B0CTJk2CXq9HSkoKfHx85O2DBw/G999/X6qNI3K1zLwKML1WA72WGSBFK1AGn8MMEJHbs3sM0Pbt27Ft2zZUq1bNYnvt2rVx4cKFUmsYUVkgV4BxIVTls5gJmhkgIndndwB0+/Zti8yP5OrVq1xOglRHqgDz4hxAylegDF6wC4zI7dmd0+/YsaM8MzOQW/puNpsxZ84cdOnSpVQbR+RqUgUYS+BVQC6DN8DIMngit2d3BmjOnDno3LkzDh06hOzsbEyePBknTpzAP//8g59++skRbSRymcxsLoSqGnIXmB5e7AIjcnt2X9UbNGiAY8eOoXXr1oiKisLt27fRv39/JCUloWbNmo5oI5HLcB0wFcnrAssQHARNRPeQAQKA4OBgzJo1q7TbQlTmSFVgLIFXOFMOIHKD2Qx4wotjgIjc3j0FQP/++y+WL1+OU6dOQaPRoH79+njyyScREBBQ2u0jcimuA6YSedkfAMhiFRgR4R66wPbs2YOIiAgsXLgQ//77L/755x8sXLgQERER2LNnjyPaSOQy7AJTibzxPwIaZEHPQdBEZH8GaNy4cRg0aBCWLl0KrTb3l4LJZMLYsWMxbtw4HD9+vNQbSeQqWVIAxDJ4ZZMCIJ03AA0zQERkfwbo999/x4svvigHPwCg1WoRHR2N33//vVQbR+RqGawCUwc5APLKvctB0ERuz+6reosWLXDq1KlC20+dOoVmzZqVRpuIygyOAVIJKQDSewMA1wIjItu6wI4dOyb/f/z48ZgwYQLOnj2Ltm3bAgAOHDiAxYsX4+2333ZMK4lcRKoC4xgghTNKGaDcWezZBUZENgVAzZo1g0ajgRD5F43JkycX2m/IkCEYPHhw6bWOyMWYAVKJvAwQ9HldYBwETeT2bAqAzp075+h2EJVJmawCUwepDD6vC0wIwGQW0HpoXNgoInIlmwKg8PBwR7eDqEziYqgqkbcOmEafv5Cz0WyG1oOfK5G7uqeJEC9duoSffvoJly9fhvmuVPL48eNLpWFEZYG0GKqXjlVgipaXAdLkZYCA3HFAhnu6AhKRGtj9479ixQqMGTMGnp6eqFixIjSa/BSyRqNhAESqImWAOA+QwuWNAdJ4WgZAROS+7A6Apk+fjunTpyMmJgYeHvyrmNSNY4BUIq8KrGAXGAdCE7k3uyOYO3fu4IknnmDwQ26Bi6GqhJQB0nvLA5+ZASJyb3ZHMaNGjcJXX33liLYQlTksg1cJuQzeG7q8AIizQRO5N7u7wGJjY9GnTx98//33aNy4MfR6vcXj8+bNK7XGEbkaF0NVCbkM3gd6rQeyjGaYOBs0kVuzOwB66623sG3bNtStWxcACg2CJlKTzByuBaYKeWXw0HtBp83rAuMYICK3ZncANG/ePHzyyScYOXKkA5pDVLZkcjV4dSiQAdLljV/M4RggIrdm95+1BoMB7du3d0RbiMoUo8ks/5JkF5jCWRkDxEHQRO7N7gBowoQJWLRokSPaQlSmZBrzu0g4CFrh8srgofOWu8BYBk/k3uzuAvv555+xc+dOfPvtt2jYsGGhQdDr168vtcYRuZI0CSIAGDgTtLIVyADptbmfJTNARO7N7qt6hQoV0L9/f3Tq1AmVKlWCv7+/xc0ee/fuRd++fVGlShVoNBps3LixxOfs2bMHLVu2hJeXF2rUqIEPPvig0D7r1q1DgwYNYDAY0KBBA2zYsMGudhEBlpMgcoC/wlnrAmMGiMit3dNSGKXl9u3baNq0KZ588kk8/vjjJe5/7tw59OrVC6NHj8bnn3+On376CWPHjkXlypXl5ycmJmLw4MF4/fXX8X//93/YsGEDBg0ahB9//BFt2rQptbaT+nEAtIrIAZAPdFojAGaAiNydS5cC7NmzJ3r27Gnz/h988AHCwsIQFxcHAKhfvz4OHTqEuXPnygFQXFwcoqKiEBMTAwCIiYnBnj17EBcXh1WrVpX6OVDZcyvLiOt3su/7OCn/5FYOWV0I1WwG0v+879cgJ8m+lfuv3gt67W0AzACR/YQQ+OtGJoRg8FwaPHUeCPT1ctnr2x0ARUREFNsd8Mcff9xXg4qTmJiI7t27W2zr0aMHli9fjpycHOj1eiQmJmLSpEmF9pGCJmuysrKQlZUl309PTy/VdpPznLt6G4/E7UWWsfR+uVkdAL3qCeDMtlJ7DXISnTe0HrmBLcvgyV7jvjyCLb+muboZqtEirALWj3VdVbndAdDEiRMt7ufk5CApKQnff/89Xn755dJql1VpaWkICgqy2BYUFASj0YirV68iJCSkyH3S0or+0sbGxmLWrFkOaTM518m/0pFlNEOjATy19z9w2UOjQd+mVQo/cPFg7r9aT0DDAdKKENwEqFgTeo9/AbALjOx36Hzud8dT6wEOC7x/+lK4Rt8PuwOgCRMmWN2+ePFiHDp06L4bVJK7s09SKrK4GamFEMVmrWJiYhAdHS3fT09PR2hoaGk0l5xMGrfTsXZlfPpUa8e9kDFvZuEXjgAV+F1REs4ETfdKur5sndgBNSuXd3Fr6H6VWvjVs2dPrFu3rrQOZ1VwcHChTM7ly5eh0+lQsWLFYve5OytUkMFggJ+fn8WNlCnDGUtXmM35AZDe23GvQw6hYxk83aPMnNygmfOCqUOp/Zb4+uuvERAQUFqHsyoyMhIJCQkW27Zv345WrVrJ8xEVtU+7du0c2jYqGzKdsXipNKkewABIgfQsg6d7YDILZJtyvzOcGV4d7O4Ca968uUV3khACaWlpuHLlCpYsWWLXsW7duoWzZ8/K98+dO4fk5GQEBAQgLCwMMTExuHTpElauXAkAGDNmDN5//31ER0dj9OjRSExMxPLlyy2quyZMmICOHTvinXfeQb9+/fDNN99gx44d+PHHH+09VVIgp5SuSwtrAoCOAZDSyDNBMwNEdpCuLQADILWwOwB67LHHLO57eHigcuXK6Ny5M+rVq2fXsQ4dOoQuXbrI96VxOCNGjEB8fDxSU1ORkpIiPx4REYEtW7Zg0qRJWLx4MapUqYKFCxdazCHUrl07rF69GtOmTcNrr72GmjVrYs2aNZwDyE1IXWAGnSMDoLyFNbUGwIMDoJVGWgzVaGIGiGyXkcOZ4dXG7gBoxowZpfbinTt3LnY+hfj4+ELbOnXqhCNHjhR73AEDBmDAgAH32zxSoIzsvBS1QzNA+bMKk/LkD4JmBohsJy2NY9B5wMODJWBqcE8TIZrNZpw9exaXL1+G+a5+9I4dO5ZKw4juRabRiWOA9D6Oew1yGCkDxC4wskeWkTPDq43dAdCBAwcwZMgQXLhwoVD2RqPRwGQyFfFMIsfLzHZCFZicAXLdDKZ07/RSBohdYGQHKbvs5cjudXIquwOgMWPGoFWrVvjuu+8QEhLCRSKpTMlwRhWYNAaIGSBFYhcY3YsMrg2oOnYHQGfOnMHXX3+NWrVqOaI9RPclU54HyAlVYBwDpEjyIGiWwZMdnHJtIaeyu5+gTZs2FqXrRGVJhlMCoLwMkI5dYEqU3wXGDBDZzimTrJJT2Z0BeuGFF/Diiy8iLS0NjRs3licglDRp0qTUGkdkr4wcJ0xUlsNB0Eqm5SBougdOmWSVnMruAEiac+epp56St2k0Gnm9LQ6CJlfKckY/PZfBUDQ91wKje8AASH3sDoDOnTvniHYQlQqnpKnlQdAMgJSIZfB0LzKyOQZIbewOgMLDwx3RDqJS4ZSLFCdCVDSpCszEDBDZIYMLoaoOR3ORqjglTc0xQIrGQdB0L/LXGeSvTbXgJ0mqkumMv9KkAIhVYIokd4FxHiCyg1wGz4kQVYMBEKmGySyQbXJGFRjHACmZjjNB0z3gRIjqwwCIVCOzwGrNzqkCYxeYEnEQNN0LToSoPvcUAF2/fh0ff/wxYmJi8M8//wAAjhw5gkuXLpVq44jskVEgADLouBYYWadjGTzdAw6CVh+7q8COHTuGbt26wd/fH+fPn8fo0aMREBCADRs24MKFC1i5cqUj2klUoowCC6E6dI06rgWmaHq5CowZILKddH3hPEDqYfefydHR0Rg5ciTOnDkDL6/8v4B79uyJvXv3lmrjiOzhtInKWAavaPldYMwAke1YBaY+dn+Sv/zyC5599tlC26tWrYq0tLRSaRTRvXBKBRhQoAqMAZASsQye7gWrwNTH7gDIy8sL6enphbafPn0alStXLpVGEd2LDGaAyAZalsHTPZBnmWcVmGrYHQD169cPs2fPRk5ODoDcdcBSUlIwZcoUeZ0wIldwykrwACdCVDiWwdO9cNofWOQ0dgdAc+fOxZUrVxAYGIiMjAx06tQJtWrVgq+vL958801HtJHIJpnOWAcMAIysAlMyfV4GiF1gZI8sVoGpjt1VYH5+fvjxxx+xc+dOHDlyBGazGS1atEC3bt0c0T4im2U6a6IydoEpGsvg6V4wA6Q+dgdAkocffhgPP/xwabaF6L44pUxVCJbBK5w8CJpjgMgOLINXH5sCoIULF9p8wPHjx99zY4juh5QBMjjyAmXKAURe5oBrgSmSjl1gZCchBDKNTupiJ6exKQCaP3++TQfTaDQMgMhlpJlanbIOGMAMkEJpPXIzQJwHiGyVZTRD5MXLrAJTD5sCoHPnzjm6HUT3zSl99NL4H40W0Ood9zrkMHptXgaIXWBkI4t1BtkFphrM5ZFqZDljELSxQAm8I5fbIIeRBkEzA0S2kiZZ1Xlo5ACalM+mDFB0dDRef/11lCtXDtHR0cXuO2/evFJpGJG95HmAuBAqFUMqg+daYGQrp80xRk5lUwCUlJQkT3x45MiRIheadOgClEQlkBdDdWQGiCXwiqfjUhhkp/yFlhkAqYlNAdCCBQvg5+cHANi9e7cj20N0zzKNzhgEzVmglU7uAuM8QGQjqQKMC6Gqi02fZvPmzXH16lUAQI0aNXDt2jWHNoroXjjlrzR5IVR2gSmVVAYvBLvByDaZ2VwIVY1sCoAqVKggV4KdP38eZv7lRGVQplOqwDgJotJJGSCAA6HJNhnOmmWenMqmAOjxxx9Hp06dEBERAY1Gg1atWqFGjRpWb/ZasmQJIiIi4OXlhZYtW2Lfvn1F7jty5EhoNJpCt4YNG8r7xMfHW90nMzPT7raRsmQ6Y6CiMe97xDFAiiUNggZYCk+2yeQ6YKpk0xigZcuWoX///jh79izGjx+P0aNHw9fX975ffM2aNZg4cSKWLFmC9u3b48MPP0TPnj1x8uRJhIWFFdp/wYIFePvtt+X7RqMRTZs2xcCBAy328/Pzw+nTpy22eXmxy0LtMpyxGKqcAWIApFQFM0BcEZ5swSowdbJ5LbBHHnkEAHD48GFMmDChVAKgefPmYdSoUXj66acBAHFxcdi2bRuWLl2K2NjYQvv7+/vD399fvr9x40b8+++/ePLJJy3202g0CA4Ovu/2kbI4dSJEBkCKpfMoEAAxA0Q2yL+2cBC0mtj9aa5YsaJUgp/s7GwcPnwY3bt3t9jevXt37N+/36ZjLF++HN26dUN4eLjF9lu3biE8PBzVqlVDnz59kJSUVOxxsrKykJ6ebnEj5cmSlsJgGTwVQ6PRyEEQS+HJFllcCV6VXBbOXr16FSaTCUFBQRbbg4KCkJaWVuLzU1NTsXXrVjl7JKlXrx7i4+OxadMmrFq1Cl5eXmjfvj3OnDlT5LFiY2Pl7JK/vz9CQ0Pv7aTIpZySpparwBgAKRnXAyN7cB4gdXJ5Pu/uyROFEDZNqBgfH48KFSrgscces9jetm1bDB06FE2bNkWHDh2wdu1a1KlTB4sWLSryWDExMbhx44Z8u3jx4j2dC7mWdJFiFxiVhOuBkT04BkidbB4DVNoqVaoErVZbKNtz+fLlQlmhuwkh8Mknn2DYsGHw9PQsdl8PDw88+OCDxWaADAYDDAaD7Y2nMkcIIU9W5tgqME6EqAb5s0EzA0Qly3RG9zo5ncsyQJ6enmjZsiUSEhIstickJKBdu3bFPnfPnj04e/YsRo0aVeLrCCGQnJyMkJCQ+2ovlW1ZRjNE3h/zjq0C41pgaiBNhpjDMUBkg/x1BhkAqYnLMkBA7iKrw4YNQ6tWrRAZGYlly5YhJSUFY8aMAZDbNXXp0iWsXLnS4nnLly9HmzZt0KhRo0LHnDVrFtq2bYvatWsjPT0dCxcuRHJyMhYvXuyUcyLXkOYAAhw9BogTIaqBPi8DxJmgyRbyJKtcCkNVXBoADR48GNeuXcPs2bORmpqKRo0aYcuWLXJVV2pqKlJSUiyec+PGDaxbtw4LFiyweszr16/jmWeeQVpaGvz9/dG8eXPs3bsXrVu3dvj5kOtIKWq9ViOP73CIHE6EqAZcD4zs4ZRZ5snpXBoAAcDYsWMxduxYq4/Fx8cX2ubv7487d+4Uebz58+dj/vz5pdU8UginpailDBDXAlM0qQuMZfBkC+n6YmAApCrM55EqyGWqjh6kyNXgVSF/HiBmgKhkTqkwJadjAESqIFWAOfwCxbXAVEGX102awzFAZINMY14VGAMgVWEARKqQme2EdcAArgWmEnqWwZMdMjkRoioxACJVcMo6YAAnQlQJuQuMGSCyQQarwFSJnyapgtNmamUZvCpIXWAcBE224EzQ6sQAiFRBKoN3fACUNwaIVWCKlp8BYhcYlSyTAZAqMQAiVXBKF5jZBJiycv/PDJCiyYOgmQEiG3AeIHViAESqIA1SdOhaPdL4H4BjgBROzzJ4spHRZJYDZQZA6sIAiFQhP0XtwK+0VAIPsAtM4fJngmYGiIonlcAD7AJTGwZApApOGaRYcBZoD/7oKJnUBWZiBohKIE2CCAAGHX/u1YSfJqmCU8YAsQReNfQsgycbFcwue+R9b0gdGACRKjilCkwKgHQMgJRO68FB0GQbVoCpFwMgUgWnVGkwA6QanAmabOW0SVbJ6RgAkSo4ZTFUToKoGhwETbbiQqjqxQCIVEFaDNXLkYMU5YVQWQGmdDoPaSZoZoCoeFIVmIEBkOowACJVyHDmPEDsAlM8qQvMxAwQlSA/A8Rfl2rDT5RUwTljgNgFphacCZpsJV9bHPnHFbkEAyBSBakKzLEBkNQFxgyQ0nEtMLIVl8FQLwZApApSpYZD++nliRAZACmdjmXwZCOnXFvIJRgAkSpwIkSyh45l8GQjlsGrFwMgUgWn9NMbGQCphTwPEAdBUwmc0r1OLsEAiFTBKYuhMgOkGvldYMwAUfGccm0hl+AnSopnNJnlsRzOqQJjAKR0LIMnW3EiRPViAESKJ01UBjh6LTCpCoxl8ErHMniylZwBYhm86jAAIsWT/kLTaACDI2eClhdD5UzQSqdlGTzZSBoE7aVjAKQ2DIBI8TILXKA0Go3jXogTIapG/mKozABR8TgRonoxACLFc9oFysiJENWCg6DJVqwCUy8GQKR4+SlqB3+dOQhaNVgGT7bKYBWYavETJcWTxgA5fJAiy+BVQ14NngEQlUC+vjADpDoMgEjxpCowh6eouRaYanAmaLJVppFl8GrFAIgUz2l/oXEtMNWQM0AcBE0lyGQGSLVcHgAtWbIEERER8PLyQsuWLbFv374i9929ezc0Gk2h2//+9z+L/datW4cGDRrAYDCgQYMG2LBhg6NPg1zIaas1swtMNaQMUA7L4KkEGawCUy2XBkBr1qzBxIkTMXXqVCQlJaFDhw7o2bMnUlJSin3e6dOnkZqaKt9q164tP5aYmIjBgwdj2LBhOHr0KIYNG4ZBgwbh4MGDjj4dcpH8qeodeIESosBaYCyDVzqWwZOtWAWmXi4NgObNm4dRo0bh6aefRv369REXF4fQ0FAsXbq02OcFBgYiODhYvmm1+V/MuLg4REVFISYmBvXq1UNMTAy6du2KuLg4B58NuYpTqjRM2YDIyxboORGi0uV3gTEDREUTQsjXFwOrwFTHZZ9odnY2Dh8+jO7du1ts7969O/bv31/sc5s3b46QkBB07doVu3btsngsMTGx0DF79OhR7DGzsrKQnp5ucSPlyHBGF5g0/gdgBkgFdCyDJxtkFVhmhxkg9XFZAHT16lWYTCYEBQVZbA8KCkJaWprV54SEhGDZsmVYt24d1q9fj7p166Jr167Yu3evvE9aWppdxwSA2NhY+Pv7y7fQ0ND7ODNyNjlF7cg+eqkCzEMHaPWOex1yCr2WZfBUMql7HeAgaDXSuboBdy9dIIQocjmDunXrom7duvL9yMhIXLx4EXPnzkXHjh3v6ZgAEBMTg+joaPl+eno6gyAFccoYIFaAqYq0FhhngqbiSNllnYdGDppJPVz2iVaqVAlarbZQZuby5cuFMjjFadu2Lc6cOSPfDw4OtvuYBoMBfn5+FjdSDqeUwbMCTFX0LIMnG0jXFnZ/qZPLAiBPT0+0bNkSCQkJFtsTEhLQrl07m4+TlJSEkJAQ+X5kZGShY27fvt2uY5KyOGcMEAMgNckfA8QMEBVNLrBgCbwqubQLLDo6GsOGDUOrVq0QGRmJZcuWISUlBWPGjAGQ2zV16dIlrFy5EkBuhVf16tXRsGFDZGdn4/PPP8e6deuwbt06+ZgTJkxAx44d8c4776Bfv3745ptvsGPHDvz4448uOUdyvExnVIEZGQCpiTwPkEmU2EVO7ksaX8h1wNTJpQHQ4MGDce3aNcyePRupqalo1KgRtmzZgvDwcABAamqqxZxA2dnZeOmll3Dp0iV4e3ujYcOG+O6779CrVy95n3bt2mH16tWYNm0aXnvtNdSsWRNr1qxBmzZtnH5+5BxOmQiRGSBVkbrAAMAsAC3jH7LCaZOskku4fBD02LFjMXbsWKuPxcfHW9yfPHkyJk+eXOIxBwwYgAEDBpRG80gBnDJTq7wSPEvg1UBXIOLJMZmh9eAvOCqMY4DUjXk9UjwpTW3QOaEMXsdJENVAVyADxFJ4Koq0EKqBAZAqMQAixZP/SnNKBohdYGpQMAPE2aCpKMwAqRsDIFI8544BYheYGug8CnaBMQNE1nEMkLoxACLFc24VGLvA1ECj0chBEEvhqSisAlM3fqqkeM6dB4gZILXQcUV4KoFTCizIZRgAkeJlOGUpDJbBq408GzQHQVMRnHJtIZdhAESKJoQokKZ2QgDEtcBUQytngNgFRtY5ZZ1BchkGQKRoWcb8X16OrQJjBkhtpFJ4DoKmonAQtLoxACJFk8pUAcBL58CvM8vgVUfP9cCoBCyDVzcGQKRo0kRlnloP6LSOrALLmwiRg6BVo+B6YETWyN3rHAStSgyASNGkv9AMji5TzWEZvNrIg6A5BoiKIA+CdmR2mVyGnyopmlNK4AGuBaZCUgbIxCowKgLL4NWNARApmpSidvgFSloLjGOAVEMrDYJmAERFyOIgaFVjAESKJpepOnIhVCA/A8QyeNXQswyeSsB5gNSNARApmjQGyOGDFFkGrzrSUhgcBE1FYQCkbgyASNGkKjBvRw+CNnIpDLWRqgZZBk9FkbvYGQCpEgMgUjQ5A+TwQdCsAlMbPdcCoxJkZjthoWVyGX6qpGhOmanVbAJM2bn/ZwZINXRcC4xKwCowdWMARIrmlBS1lP0BOAZIRaQxQBwETdbkmMxycMwuMHViAESKJv2FZnBWAKRjF5hayDNBMwNEVkjZZYCDoNWKARApmlMmQixYAq/ROO51yKnkQdDMAJEVGQUCIANnglYlfqqkaPIYIE9nrAPG7i810XtwEDQVLatA97qGf/ioEgMgUjSnTITIleBVScoA5bAMnqzInwOIvybVip8sKZpUBu/QKg1OgqhKUhm8iRkgskK+tnD8j2oxACJFk6rAHDpIkQGQKmk9OAiaiiZnl1kCr1oMgEjRnDJVvRQAcR0wVZHnAeIgaLIiw1nrDJLLMAAiRXNOFRgzQGokzwTNDBBZkclJEFWPARApmlOqwORB0JwFWk3kQdDMAJEVTvnjilyKARApmlOqwOQyeE6CqCYsg6fi5I8v5K9JteInS4qW4YyBiswAqVL+avAMgKgwpy20TC7DAIgULSPbiWuBcQyQqmi5FhgVg11g6ufyAGjJkiWIiIiAl5cXWrZsiX379hW57/r16xEVFYXKlSvDz88PkZGR2LZtm8U+8fHx0Gg0hW6ZmZmOPhVygSynVoGxC0xNOAiaiuOUawu5lEsDoDVr1mDixImYOnUqkpKS0KFDB/Ts2RMpKSlW99+7dy+ioqKwZcsWHD58GF26dEHfvn2RlJRksZ+fnx9SU1Mtbl5e/OWlRs6tAmMXmJpIZfAcBE3WZLAKTPV0rnzxefPmYdSoUXj66acBAHFxcdi2bRuWLl2K2NjYQvvHxcVZ3H/rrbfwzTffYPPmzWjevLm8XaPRIDg42KFtJ9fLMZnlv97ZBUb2kjNAHARNVjhljjFyKZdlgLKzs3H48GF0797dYnv37t2xf/9+m45hNptx8+ZNBAQEWGy/desWwsPDUa1aNfTp06dQhuhuWVlZSE9Pt7hR2ZdZcLVmR1ZqGBkAqVH+IGhmgKgwVoGpn8s+2atXr8JkMiEoKMhie1BQENLS0mw6xnvvvYfbt29j0KBB8rZ69eohPj4emzZtwqpVq+Dl5YX27dvjzJkzRR4nNjYW/v7+8i00NPTeToqcSvoLTaMBDDpHzgPEAEiNdNJSGMwAkRUcBK1+Lg9tNRqNxX0hRKFt1qxatQozZ87EmjVrEBgYKG9v27Ythg4diqZNm6JDhw5Yu3Yt6tSpg0WLFhV5rJiYGNy4cUO+Xbx48d5PiJwms0AFmC3fmXvGMnhV0udlgEwcBE1WZHIxVNVz2RigSpUqQavVFsr2XL58uVBW6G5r1qzBqFGj8NVXX6Fbt27F7uvh4YEHH3yw2AyQwWCAwWCwvfFUJmQandRHn5NXQcgqMFWRF0PlIGiywmnXF3IZl2WAPD090bJlSyQkJFhsT0hIQLt27Yp83qpVqzBy5Eh8+eWX6N27d4mvI4RAcnIyQkJC7rvNVLZkOOsvNGaAVIll8FQcToSofi6tAouOjsawYcPQqlUrREZGYtmyZUhJScGYMWMA5HZNXbp0CStXrgSQG/wMHz4cCxYsQNu2beXskbe3N/z9/QEAs2bNQtu2bVG7dm2kp6dj4cKFSE5OxuLFi11zkuQw+VUaDo7jOQZIlbgaPBUnI28QNMvg1culAdDgwYNx7do1zJ49G6mpqWjUqBG2bNmC8PBwAEBqaqrFnEAffvghjEYjxo0bh3HjxsnbR4wYgfj4eADA9evX8cwzzyAtLQ3+/v5o3rw59u7di9atWzv13MjxnLZas7wWGAMgNdFpOQiaipbFQdCq59IACADGjh2LsWPHWn1MCmoku3fvLvF48+fPx/z580uhZVTWOWUhVKBAFxgDIDXRswyeiuG0DDO5DD9ZUiynzdTKLjBVksrgOQaIrGEZvPoxACLFyp+ozIEXKCG4FIZK6TgTNBUjkzNBqx4DIFIsp1RpGLMA5P2CZBm8qnAQNBXFbBbO+QOLXIoBEClWforakbNA38n/P7vAVEUeBM0uMLpLljE/KGYVmHoxACLFckqVhlQB5qEHtHrHvQ45nTwImhkgukvBdQa9HLnMDrkUP1lSLKes1swB0KolD4LmGCC6i3Rt0Ws18qK5pD78ZEmxnBMAsQRerfLL4BkAkSWnXFvI5RgAkWJlOmOm1hxOgqhWWrkMnl1gZCmTJfBugQEQKZb8V5oj++ilDJCOAZDaFJwJWghmgSgfS+DdAwMgUqzMbCdMhMgxQKql98i//JnYDUYFZGTnZZcZAKkaAyBSrEyjM+YB4iSIaiVlgACOAyJLcgaIJfCqxgCIFMspEyHKGSBOgqg2+gLVPTkshacCnNK9Ti7HT5cUKyPHCWlqVoGpllQGD7ALjCw5bZ1BcikGQKRYWc64SMlVYOwCUxttgQAoh3MBUQFOmWSVXI4BEClWfpraCV1gXAdMdTQaTYEV4dkFRvk4D5B7YABEipWfpnZCGTwzQKrEFeHJGqkKjAGQujEAIsVyylwdRk6EqGZSKTwHQVNBUoUpu8DUjQEQKZLZLOSZoLkUBt0rOQPEQdBUQH6FKX9Fqhk/XVKkLGP+X+yOrQLjRIhqppNXhGcARPm4FIZ7YABEiiSN/wGYAaJ7x0HQZA3L4N0DAyBSJOkvNE+th0U5c6mTyuC5FpgqFVwPjEgiXV8MzACpGgMgUqT8MlUHf4XZBaZq0iBoIwdBUwFOmWSVXI4BEClShjMWQgVYBq9yHARN1sgLLTMAUjUGQKRIWc5YCBUoUAbPiRDVSMcyeLIif6Fl/opUM366pEjSRGUO/wuNGSBV03MiRLIigxkgt8AAiBTJaVPVcwyQqmk92AVGhcnXF1aBqRoDIFKkTKcNgmYVmJrJ8wCxDJ4KkCdZdeQ6g+RyDIBIkTKcNVEZ5wFSNXaBkTWZnAfILTAAIkVyygXKZATMObn/ZwCkShwETdY47Q8scikGQKRIcheYI1PUxoz8/zMAUiU9y+DpLjkmM0x53wdWgakbP11SJKkKzKGDFHMKBEA6lsGrkY4TIdJdnLbMDrmcywOgJUuWICIiAl5eXmjZsiX27dtX7P579uxBy5Yt4eXlhRo1auCDDz4otM+6devQoEEDGAwGNGjQABs2bHBU88lFnJKiLlgCr3HgchvkMlpmgOgu0iSIGg1g0Ln8VyQ5kEs/3TVr1mDixImYOnUqkpKS0KFDB/Ts2RMpKSlW9z937hx69eqFDh06ICkpCa+++irGjx+PdevWyfskJiZi8ODBGDZsGI4ePYphw4Zh0KBBOHjwoLNOi5zAKas1SxVg7P5SLb0HB0GTpcwCy2Bo+IePqulc+eLz5s3DqFGj8PTTTwMA4uLisG3bNixduhSxsbGF9v/ggw8QFhaGuLg4AED9+vVx6NAhzJ07F48//rh8jKioKMTExAAAYmJisGfPHsTFxWHVqlXOObEiZGXewT9/X3RpG9TCfD0FVXEFlU2+wHUHBSj/ns/9lyXwqiWVwV+9nYU//73j4tZQWXDhn9sA2P3lDlwWAGVnZ+Pw4cOYMmWKxfbu3btj//79Vp+TmJiI7t27W2zr0aMHli9fjpycHOj1eiQmJmLSpEmF9pGCJmuysrKQlZUl309PT7fzbGxz7ngi6n3b3yHHdjezAcz2AvBz3s2RuAyGakmDoD/c8wc+3POHi1tDZYkXu79Uz2UB0NWrV2EymRAUFGSxPSgoCGlpaVafk5aWZnV/o9GIq1evIiQkpMh9ijomAMTGxmLWrFn3eCa200CDTKF3+Ou4C41GA71WAw9Hpqk1HkCjAY47PrlUt/pB2Ho8TV76gAjIHf/Tr3lVVzeDHMylXWAACvWxCiGK7Xe1tv/d2+09ZkxMDKKjo+X76enpCA0NLbnxdqrb6mGg1dVSPy4R3Zuu9YOQPL17yTsSkeq4LACqVKkStFptoczM5cuXC2VwJMHBwVb31+l0qFixYrH7FHVMADAYDDAYDPdyGkRERKRALuvk9PT0RMuWLZGQkGCxPSEhAe3atbP6nMjIyEL7b9++Ha1atYJery92n6KOSURERO7HpV1g0dHRGDZsGFq1aoXIyEgsW7YMKSkpGDNmDIDcrqlLly5h5cqVAIAxY8bg/fffR3R0NEaPHo3ExEQsX77corprwoQJ6NixI9555x3069cP33zzDXbs2IEff/zRJedIREREZY9LA6DBgwfj2rVrmD17NlJTU9GoUSNs2bIF4eHhAIDU1FSLOYEiIiKwZcsWTJo0CYsXL0aVKlWwcOFCuQQeANq1a4fVq1dj2rRpeO2111CzZk2sWbMGbdq0cfr5ERERUdmkEdIoYpKlp6fD398fN27cgJ+fn6ubQ0RERDaw5/c3JzogIiIit8MAiIiIiNwOAyAiIiJyOwyAiIiIyO0wACIiIiK3wwCIiIiI3A4DICIiInI7DICIiIjI7TAAIiIiIrfj0qUwyippcuz09HQXt4SIiIhsJf3etmWRCwZAVty8eRMAEBoa6uKWEBERkb1u3rwJf3//YvfhWmBWmM1m/PXXX/D19YVGoynVY6enpyM0NBQXL150u3XG3PncAfc+f3c+d8C9z9+dzx1w7/N3xbkLIXDz5k1UqVIFHh7Fj/JhBsgKDw8PVKtWzaGv4efn53Y/DBJ3PnfAvc/fnc8dcO/zd+dzB9z7/J197iVlfiQcBE1ERERuhwEQERERuR0GQE5mMBgwY8YMGAwGVzfF6dz53AH3Pn93PnfAvc/fnc8dcO/zL+vnzkHQRERE5HaYASIiIiK3wwCIiIiI3A4DICIiInI7DICIiIjI7TAAcqIlS5YgIiICXl5eaNmyJfbt2+fqJjnE3r170bdvX1SpUgUajQYbN260eFwIgZkzZ6JKlSrw9vZG586dceLECdc0tpTFxsbiwQcfhK+vLwIDA/HYY4/h9OnTFvuo+fyXLl2KJk2ayBOfRUZGYuvWrfLjaj73u8XGxkKj0WDixInyNjWf/8yZM6HRaCxuwcHB8uNqPncAuHTpEoYOHYqKFSvCx8cHzZo1w+HDh+XH1Xz+1atXL/TZazQajBs3DkAZPndBTrF69Wqh1+vFRx99JE6ePCkmTJggypUrJy5cuODqppW6LVu2iKlTp4p169YJAGLDhg0Wj7/99tvC19dXrFu3Tvz6669i8ODBIiQkRKSnp7umwaWoR48eYsWKFeL48eMiOTlZ9O7dW4SFhYlbt27J+6j5/Ddt2iS+++47cfr0aXH69Gnx6quvCr1eL44fPy6EUPe5F/Tzzz+L6tWriyZNmogJEybI29V8/jNmzBANGzYUqamp8u3y5cvy42o+93/++UeEh4eLkSNHioMHD4pz586JHTt2iLNnz8r7qPn8L1++bPG5JyQkCABi165dQoiye+4MgJykdevWYsyYMRbb6tWrJ6ZMmeKiFjnH3QGQ2WwWwcHB4u2335a3ZWZmCn9/f/HBBx+4oIWOdfnyZQFA7NmzRwjhfucvhBAPPPCA+Pjjj93m3G/evClq164tEhISRKdOneQASO3nP2PGDNG0aVOrj6n93F955RXx0EMPFfm42s//bhMmTBA1a9YUZrO5TJ87u8CcIDs7G4cPH0b37t0ttnfv3h379+93Uatc49y5c0hLS7N4LwwGAzp16qTK9+LGjRsAgICAAADudf4mkwmrV6/G7du3ERkZ6TbnPm7cOPTu3RvdunWz2O4O53/mzBlUqVIFEREReOKJJ/DHH38AUP+5b9q0Ca1atcLAgQMRGBiI5s2b46OPPpIfV/v5F5SdnY3PP/8cTz31FDQaTZk+dwZATnD16lWYTCYEBQVZbA8KCkJaWpqLWuUa0vm6w3shhEB0dDQeeughNGrUCIB7nP+vv/6K8uXLw2AwYMyYMdiwYQMaNGjgFue+evVqHDlyBLGxsYUeU/v5t2nTBitXrsS2bdvw0UcfIS0tDe3atcO1a9dUf+5//PEHli5ditq1a2Pbtm0YM2YMxo8fj5UrVwJQ/2df0MaNG3H9+nWMHDkSQNk+d64G70QajcbivhCi0DZ34Q7vxfPPP49jx47hxx9/LPSYms+/bt26SE5OxvXr17Fu3TqMGDECe/bskR9X67lfvHgREyZMwPbt2+Hl5VXkfmo9/549e8r/b9y4MSIjI1GzZk18+umnaNu2LQD1nrvZbEarVq3w1ltvAQCaN2+OEydOYOnSpRg+fLi8n1rPv6Dly5ejZ8+eqFKlisX2snjuzAA5QaVKlaDVagtFu5cvXy4UFaudVBWi9vfihRdewKZNm7Br1y5Uq1ZN3u4O5+/p6YlatWqhVatWiI2NRdOmTbFgwQLVn/vhw4dx+fJltGzZEjqdDjqdDnv27MHChQuh0+nkc1Tr+d+tXLlyaNy4Mc6cOaP6zz4kJAQNGjSw2Fa/fn2kpKQAcI+fewC4cOECduzYgaefflreVpbPnQGQE3h6eqJly5ZISEiw2J6QkIB27dq5qFWuERERgeDgYIv3Ijs7G3v27FHFeyGEwPPPP4/169dj586diIiIsHhc7edvjRACWVlZqj/3rl274tdff0VycrJ8a9WqFf773/8iOTkZNWrUUPX53y0rKwunTp1CSEiI6j/79u3bF5ru4rfffkN4eDgA9/m5X7FiBQIDA9G7d295W5k+dxcNvnY7Uhn88uXLxcmTJ8XEiRNFuXLlxPnz513dtFJ38+ZNkZSUJJKSkgQAMW/ePJGUlCSX/L/99tvC399frF+/Xvz666/iP//5T5koiSwNzz33nPD39xe7d++2KAu9c+eOvI+azz8mJkbs3btXnDt3Thw7dky8+uqrwsPDQ2zfvl0Ioe5zt6ZgFZgQ6j7/F198UezevVv88ccf4sCBA6JPnz7C19dXvsap+dx//vlnodPpxJtvvinOnDkjvvjiC+Hj4yM+//xzeR81n78QQphMJhEWFiZeeeWVQo+V1XNnAOREixcvFuHh4cLT01O0aNFCLo1Wm127dgkAhW4jRowQQuSWhM6YMUMEBwcLg8EgOnbsKH799VfXNrqUWDtvAGLFihXyPmo+/6eeekr+jleuXFl07dpVDn6EUPe5W3N3AKTm85fmdtHr9aJKlSqif//+4sSJE/Ljaj53IYTYvHmzaNSokTAYDKJevXpi2bJlFo+r/fy3bdsmAIjTp08XeqysnrtGCCFcknoiIiIichGOASIiIiK3wwCIiIiI3A4DICIiInI7DICIiIjI7TAAIiIiIrfDAIiIiIjcDgMgIiIicjsMgIiIijBy5Eg89thjrm4GETkAAyAiIiJyOwyAiIiIyO0wACKiMuHrr79G48aN4e3tjYoVK6Jbt264ffs2fvnlF0RFRaFSpUrw9/dHp06dcOTIEYvnajQafPjhh+jTpw98fHxQv359JCYm4uzZs+jcuTPKlSuHyMhI/P777/JzZs6ciWbNmuHDDz9EaGgofHx8MHDgQFy/fr3INgoh8O6776JGjRrw9vZG06ZN8fXXX8uP//vvv/jvf/+LypUrw9vbG7Vr18aKFStK/b0iovvHAIiIXC41NRX/+c9/8NRTT+HUqVPYvXs3+vfvDyEEbt68iREjRmDfvn04cOAAateujV69euHmzZsWx3j99dcxfPhwJCcno169ehgyZAieffZZxMTE4NChQwCA559/3uI5Z8+exdq1a7F582Z8//33SE5Oxrhx44ps57Rp07BixQosXboUJ06cwKRJkzB06FDs2bMHAPDaa6/h5MmT2Lp1K06dOoWlS5eiUqVKpfxuEVGpcO1arEREQhw+fFgAEOfPny9xX6PRKHx9fcXmzZvlbQDEtGnT5PuJiYkCgFi+fLm8bdWqVcLLy0u+P2PGDKHVasXFixflbVu3bhUeHh4iNTVVCCHEiBEjRL9+/YQQQty6dUt4eXmJ/fv3W7Rn1KhR4j//+Y8QQoi+ffuKJ5980o4zJyJXYQaIiFyuadOm6Nq1Kxo3boyBAwfio48+wr///gsAuHz5MsaMGYM6derA398f/v7+uHXrFlJSUiyO0aRJE/n/QUFBAIDGjRtbbMvMzER6erq8LSwsDNWqVZPvR0ZGwmw24/Tp04XaePLkSWRmZiIqKgrly5eXbytXrpS71p577jmsXr0azZo1w+TJk7F///5SeHeIyBF0rm4AEZFWq0VCQgL279+P7du3Y9GiRZg6dSoOHjyIcePG4cqVK4iLi0N4eDgMBgMiIyORnZ1tcQy9Xi//X6PRFLnNbDYX2Q5pH+nfgqTnfffdd6hatarFYwaDAQDQs2dPXLhwAd999x127NiBrl27Yty4cZg7d67N7wUROQczQERUJmg0GrRv3x6zZs1CUlISPD09sWHDBuzbtw/jx49Hr1690LBhQxgMBly9erVUXjMlJQV//fWXfD8xMREeHh6oU6dOoX0bNGgAg8GAlJQU1KpVy+IWGhoq71e5cmWMHDkSn3/+OeLi4rBs2bJSaSsRlS5mgIjI5Q4ePIgffvgB3bt3R2BgIA4ePIgrV66gfv36qFWrFj777DO0atUK6enpePnll+Ht7V0qr+vl5YURI0Zg7ty5SE9Px/jx4zFo0CAEBwcX2tfX1xcvvfQSJk2aBLPZjIceegjp6enYv38/ypcvjxEjRmD69Olo2bIlGjZsiKysLHz77beoX79+qbSViEoXAyAicjk/Pz/s3bsXcXFxSE9PR3h4ON577z307NkTwcHBeOaZZ9C8eXOEhYXhrbfewksvvVQqr1urVi30798fvXr1wj///INevXphyZIlRe7/+uuvIzAwELGxsfjjjz9QoUIFtGjRAq+++ioAwNPTEzExMTh//jy8vb3RoUMHrF69ulTaSkSlSyOEEK5uBBGRs82cORMbN25EcnKyq5tCRC7AMUBERETkdhgAERERkdthFxgRERG5HWaAiIiIyO0wACIiIiK3wwCIiIiI3A4DICIiInI7DICIiIjI7TAAIiIiIrfDAIiIiIjcDgMgIiIicjsMgIiIiMjt/D/nnETXFuZJigAAAABJRU5ErkJggg==", + "text/plain": [ + "
" ] }, "metadata": {}, @@ -3898,8 +4067,21 @@ } ], "source": [ - "#plot only certain metrics\n", - "axes = output_cb.plot_sensitivity(metric_list=['cost_ben_ratio','tot_climate_risk','benefit'], figsize=(12,8));" + "plt.plot(e, label='exposures');\n", + "plt.plot(h, label='hazards');\n", + "plt.xlabel('samples');\n", + "plt.ylabel('file number');\n", + "plt.title('Order of exposures and hazards files in samples');\n", + "plt.legend(loc='upper right');" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "output_imp = calc_imp.uncertainty(output_imp)" ] } ], @@ -3921,7 +4103,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.12" + "version": "3.8.13" }, "latex_envs": { "LaTeX_envs_menu_present": true, @@ -3954,7 +4136,7 @@ "height": "calc(100% - 180px)", "left": "10px", "top": "150px", - "width": "463.2px" + "width": "222.2px" }, "toc_section_display": true, "toc_window_display": true From 402fa2420c5bc94ba2bb2a25a3265dd88758671a Mon Sep 17 00:00:00 2001 From: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> Date: Mon, 28 Aug 2023 16:35:54 +0200 Subject: [PATCH 09/44] Update installation instructions (#776) * Add installing climada-petals to simple install instructions * Update VSCode instructions for pytest * Update changelog --------- Co-authored-by: Chahan Kropf --- CHANGELOG.md | 1 + doc/guide/install.rst | 50 +++++++++++++++++++++++++++++-------------- 2 files changed, 35 insertions(+), 16 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index a72897732..7e5bdd001 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -59,6 +59,7 @@ Removed: - Reduce memory requirements of `TropCyclone.from_tracks` [#749](https://github.com/CLIMADA-project/climada_python/pull/749) - Support for different wind speed and pressure units in `TCTracks` when running `TropCyclone.from_tracks` [#749](https://github.com/CLIMADA-project/climada_python/pull/749) - Changed the parallel package from Pathos to Multiproess in the unsequa module [#763](https://github.com/CLIMADA-project/climada_python/pull/763) +- Updated installation instructions to use conda for core and petals [#776](https://github.com/CLIMADA-project/climada_python/pull/776) ### Fixed diff --git a/doc/guide/install.rst b/doc/guide/install.rst index 8fa54aecd..617aab4d9 100644 --- a/doc/guide/install.rst +++ b/doc/guide/install.rst @@ -37,11 +37,31 @@ 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 `. - If you want to install `CLIMADA Petals`_, also follow these. Both approaches are not mutually exclusive. After successful installation, you may switch your setup at any time. +.. _petals-notes: + +Notes on the CLIMADA Petals Package +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +CLIMADA is divided into two packages, CLIMADA Core (`climada_python `_) and CLIMADA Petals (`climada_petals `_). +The Core contains all the modules necessary for probabilistic impact, averted damage, uncertainty and forecast calculations. +Data for hazard, exposures and impact functions can be obtained from the :doc:`CLIMADA Data API `. +Hazard and Exposures subclasses are included as demonstrators only. + +.. attention:: CLIMADA Petals is **not** a standalone module and requires CLIMADA Core to be installed! + +CLIMADA Petals contains all the modules for generating data (e.g., ``TC_Surge``, ``WildFire``, ``OpenStreeMap``, ...). +New modules are developed and tested here. +Some data created with modules from Petals is available to download from the :doc:`Data API `. +This works with just CLIMADA Core installed. +CLIMADA Petals can be used to generate additional data of this type, or to have a look at the tutorials for all data types available from the API. + +Both :ref:`installation approaches ` mentioned above support CLIMADA Petals. +If you are unsure whether you need Petals, you can install the Core first and later add Petals in both approaches. + .. _install-simple: ------------------- @@ -77,6 +97,12 @@ These instructions will install the most recent stable version of CLIMADA withou In the end, you should see an "Ok". If so, great! You are good to go. +#. *Optional:* Install CLIMADA Petals into the environment: + + .. code-block:: shell + + conda install -n climada_env -c conda-forge climada-petals + .. _install-advanced: --------------------- @@ -191,18 +217,7 @@ Instructions for running the test scripts can be found in the :doc:`Testing and Install CLIMADA Petals (Optional) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -CLIMADA is divided into two repositories, CLIMADA Core (`climada_python `_) and CLIMADA Petals (`climada_petals `_). -The Core contains all the modules necessary for probabilistic impact, averted damage, uncertainty and forecast calculations. -Data for hazard, exposures and impact functions can be obtained from the :doc:`CLIMADA Data API `. -Hazard and Exposures subclasses are included as demonstrators only. - -.. attention:: CLIMADA Petals is **not** a standalone module and requires CLIMADA Core to be installed! - -CLIMADA Petals contains all the modules for generating data (e.g., ``TC_Surge``, ``WildFire``, ``OpenStreeMap``, ...). -New modules are developed and tested here. -Some data created with modules from Petals is available to download from the :doc:`Data API `. -This works with just CLIMADA Core installed. -CLIMADA Petals can be used to generate additional data of this type, or to have a look at the tutorials for all data types available from the API. +If you are unsure whether you need Petals, see the :ref:`notes above `. To install CLIMADA Petals, we assume you have already installed CLIMADA Core with the :ref:`advanced instructions ` above. @@ -294,13 +309,16 @@ For further information, refer to the VSCode docs on `Workspaces ` before proceeding. #. In the left sidebar, select the "Testing" symbol, and click on *Configure Python Tests*. -#. Select "unittest" as test framework and then select the ``test*`` pattern for test discovery. +#. Select "pytest" as test framework and then select ``climada`` as the directory containing the test files. -#. The "Test Explorer" will display the tree structure of modules, files, test classes and individuals tests. +#. Select "Testing" in the Activity Bar on the left or through *View* > *Testing*. + The "Test Explorer" in the left sidebar will display the tree structure of modules, files, test classes and individual tests. You can run individual tests or test subtrees by clicking the Play buttons next to them. #. By default, the test explorer will show test output for failed tests when you click on them. From 39c8eb1422d55bf1990dba820ea924e04cf819da Mon Sep 17 00:00:00 2001 From: "Chahan M. Kropf" Date: Wed, 30 Aug 2023 09:48:05 +0200 Subject: [PATCH 10/44] Remove pandas append to concat (#777) Co-authored-by: Chahan Kropf --- climada/util/test/test_lines_polys_handler.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/climada/util/test/test_lines_polys_handler.py b/climada/util/test/test_lines_polys_handler.py index 3eb55855d..070da95e3 100644 --- a/climada/util/test/test_lines_polys_handler.py +++ b/climada/util/test/test_lines_polys_handler.py @@ -24,6 +24,7 @@ import numpy as np import geopandas as gpd +import pandas as pd import copy from shapely.geometry import Point @@ -366,7 +367,7 @@ def test_calc_geom_impact_points(self): def test_calc_geom_impact_mixed(self): """ test calc_geom_impact() with a mixed exp (points, lines and polygons) """ # mixed exposures - gdf_mix = GDF_LINE.append(GDF_POLY).append(GDF_POINT).reset_index(drop=True) + gdf_mix = pd.concat([GDF_LINE, GDF_POLY, GDF_POINT]).reset_index(drop=True) exp_mix = Exposures(gdf_mix) imp1 = u_lp.calc_geom_impact( @@ -444,7 +445,7 @@ def test_calc_geom_impact_mixed(self): def test_impact_pnt_agg(self): """Test impact agreggation method""" - gdf_mix = GDF_LINE.append(GDF_POLY).append(GDF_POINT).reset_index(drop=True) + gdf_mix = pd.concat([GDF_LINE, GDF_POLY, GDF_POINT]).reset_index(drop=True) exp_mix = Exposures(gdf_mix) exp_pnt = u_lp.exp_geom_to_pnt( From b729e891db5640d0a3b0a97a33ee0338dacd7c1f Mon Sep 17 00:00:00 2001 From: Emanuel Schmid <51439563+emanuel-schmid@users.noreply.github.com> Date: Wed, 30 Aug 2023 13:43:28 +0200 Subject: [PATCH 11/44] Remove Tag from Hazard (#767) * remove tag from hazard * remove tag from hazard * remove tag from hazard * pylint * don't keep any tag traces, not even for backwards compatitbility * unused import removed * remove tags from tutorial * set pythonpath for compatibility test * hazard.base: remove tag traces * changelog: removed hazard.tag --- CHANGELOG.md | 1 + climada/engine/test/test_forecast.py | 2 +- climada/entity/measures/test/test_base.py | 1 - climada/hazard/base.py | 68 +++++----------------- climada/hazard/storm_europe.py | 19 +----- climada/hazard/test/test_base.py | 71 +---------------------- climada/hazard/test/test_trop_cyclone.py | 9 --- climada/hazard/trop_cyclone.py | 6 -- climada/test/test_hazard.py | 8 +-- doc/tutorial/climada_hazard_Hazard.ipynb | 1 - 10 files changed, 22 insertions(+), 164 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7e5bdd001..905ff4cda 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -83,6 +83,7 @@ Removed: - `Centroids.set_raster_from_pix_bounds` [#721](https://github.com/CLIMADA-project/climada_python/pull/721) - `requirements/env_developer.yml` environment specs. Use 'extra' requirements when installing the Python package instead [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - `Impact.tag` attribute. This change is not backwards-compatible with respect to the files written and read by the `Impact` class [#743](https://github.com/CLIMADA-project/climada_python/pull/743) +- `Hazard.tag` attribute. This change is not backwards-compatible with respect to the files written and read by the `Hazard` class [#767](https://github.com/CLIMADA-project/climada_python/pull/767) - `impact.tot_value ` attribute removed from unsequa module [#763](https://github.com/CLIMADA-project/climada_python/pull/763) ## v3.3.2 diff --git a/climada/engine/test/test_forecast.py b/climada/engine/test/test_forecast.py index 460656ac3..b207bc464 100644 --- a/climada/engine/test/test_forecast.py +++ b/climada/engine/test/test_forecast.py @@ -81,7 +81,7 @@ def test_Forecast_calc_properties(self): def test_Forecast_init_raise(self): """Test calc and propety functions from the Forecast class""" #hazard with several event dates - storms = StormEurope.from_footprints(WS_DEMO_NC, description='test_description') + storms = StormEurope.from_footprints(WS_DEMO_NC) #exposure data = {} data['latitude'] = np.array([1, 2, 3]) diff --git a/climada/entity/measures/test/test_base.py b/climada/entity/measures/test/test_base.py index 7b6d7b399..048dc39f1 100644 --- a/climada/entity/measures/test/test_base.py +++ b/climada/entity/measures/test/test_base.py @@ -182,7 +182,6 @@ def test_change_all_hazard_pass(self): hazard = Hazard('TC') new_haz = meas._change_all_hazard(hazard) - self.assertEqual(new_haz.tag.file_name, ref_haz.tag.file_name) self.assertEqual(new_haz.haz_type, ref_haz.haz_type) self.assertTrue(np.array_equal(new_haz.frequency, ref_haz.frequency)) self.assertTrue(np.array_equal(new_haz.date, ref_haz.date)) diff --git a/climada/hazard/base.py b/climada/hazard/base.py index 98e8f8667..30cfeb0c0 100644 --- a/climada/hazard/base.py +++ b/climada/hazard/base.py @@ -26,8 +26,8 @@ import itertools import logging import pathlib -import warnings from typing import Union, Optional, Callable, Dict, Any, List +import warnings import geopandas as gpd import h5py @@ -42,7 +42,6 @@ from scipy import sparse import xarray as xr -from climada.util.tag import Tag from climada.hazard.centroids.centr import Centroids import climada.util.plot as u_plot import climada.util.checker as u_check @@ -113,8 +112,6 @@ class Hazard(): (wild fire). Note: The acronym is used as reference to the hazard when centroids of multiple hazards are assigned to an ``Exposures`` object. - tag : Tag - information about the source units : str units of the intensity centroids : Centroids @@ -145,8 +142,7 @@ class Hazard(): """Intensity threshold per hazard used to filter lower intensities. To be set for every hazard type""" - vars_oblig = {'tag', - 'units', + vars_oblig = {'units', 'centroids', 'event_id', 'frequency', @@ -155,7 +151,7 @@ class Hazard(): } """Name of the variables needed to compute the impact. Types: scalar, str, list, 1dim np.array of size num_events, scipy.sparse matrix of shape - num_events x num_centroids, Centroids and Tag.""" + num_events x num_centroids, Centroids.""" vars_def = {'date', 'orig', @@ -183,8 +179,7 @@ def __init__(self, date: Optional[np.ndarray] = None, orig: Optional[np.ndarray] = None, intensity: Optional[sparse.csr_matrix] = None, - fraction: Optional[sparse.csr_matrix] = None, - **tag_kwargs): + fraction: Optional[sparse.csr_matrix] = None): """ Initialize values. @@ -218,9 +213,6 @@ def __init__(self, fraction : sparse.csr_matrix, optional fraction of affected exposures for each event at each centroid. Defaults to empty matrix. - tag_kwargs - Keyword-arguments for creating the HazardTag. ``haz_type`` is also passed - to the Tag constructor. Examples -------- @@ -234,7 +226,6 @@ def __init__(self, """ self.haz_type = haz_type - self.tag = Tag(**tag_kwargs) self.units = units self.centroids = centroids if centroids is not None else Centroids() # following values are defined for each event @@ -359,7 +350,6 @@ def from_raster(cls, files_intensity, files_fraction=None, attrs=None, hazard_kwargs = dict() if haz_type is not None: hazard_kwargs["haz_type"] = haz_type - hazard_kwargs["file_name"] = str(files_intensity) + ' ; ' + str(files_fraction) centroids = Centroids.from_raster_file( files_intensity[0], src_crs=src_crs, window=window, geometry=geometry, dst_crs=dst_crs, @@ -503,7 +493,7 @@ def from_xarray_raster( The type identifier of the hazard. Will be stored directly in the hazard object. intensity_unit : str - The physical units of the intensity. Will be stored in the ``hazard.tag``. + The physical units of the intensity. intensity : str, optional Identifier of the `xarray.DataArray` containing the hazard intensity data. coordinate_vars : dict(str, str), optional @@ -1025,8 +1015,7 @@ def from_vector(cls, files_intensity, files_fraction=None, attrs=None, raise ValueError('Number of intensity files differs from fraction files:' f' {len(files_intensity)} != {len(files_fraction)}') - hazard_kwargs = dict( - file_name=str(files_intensity) + ' ; ' + str(files_fraction)) + hazard_kwargs = {} if haz_type is not None: hazard_kwargs["haz_type"] = haz_type @@ -1222,15 +1211,13 @@ def read_mat(self, *args, **kwargs): self.__dict__ = Hazard.from_mat(*args, **kwargs).__dict__ @classmethod - def from_mat(cls, file_name, description='', var_names=None): + def from_mat(cls, file_name, var_names=None): """Read climada hazard generate with the MATLAB code in .mat format. Parameters ---------- file_name : str absolute file name - description : str, optional - description of the data var_names : dict, optional name of the variables in the file, default: DEF_VAR_MAT constant @@ -1256,10 +1243,9 @@ def from_mat(cls, file_name, description='', var_names=None): pass centroids = Centroids.from_mat(file_name, var_names=var_names['var_cent']) - attrs = cls._read_att_mat(data, file_name, var_names, centroids, description) + attrs = cls._read_att_mat(data, file_name, var_names, centroids) haz = cls(haz_type=u_hdf5.get_string(data[var_names['var_name']['per_id']]), centroids=centroids, - file_name=str(file_name), **attrs ) except KeyError as var_err: @@ -1273,15 +1259,13 @@ def read_excel(self, *args, **kwargs): self.__dict__ = Hazard.from_excel(*args, **kwargs).__dict__ @classmethod - def from_excel(cls, file_name, description='', var_names=None, haz_type=None): + def from_excel(cls, file_name, var_names=None, haz_type=None): """Read climada hazard generated with the MATLAB code in Excel format. Parameters ---------- file_name : str absolute file name - description : str, optional - description of the data var_names (dict, default): name of the variables in the file, default: DEF_VAR_EXCEL constant haz_type : str, optional @@ -1302,7 +1286,7 @@ def from_excel(cls, file_name, description='', var_names=None, haz_type=None): if not var_names: var_names = DEF_VAR_EXCEL LOGGER.info('Reading %s', file_name) - hazard_kwargs = dict(file_name=file_name, description=description) + hazard_kwargs = {} if haz_type is not None: hazard_kwargs["haz_type"] = haz_type try: @@ -1829,8 +1813,6 @@ def write_hdf5(self, file_name, todense=False): for (var_name, var_val) in self.__dict__.items(): if var_name == 'centroids': self.centroids.write_hdf5(hf_data.create_group(var_name)) - elif var_name == 'tag': - var_val.to_hdf5(hf_data) elif isinstance(var_val, sparse.csr_matrix): if todense: hf_data.create_dataset(var_name, data=var_val.toarray()) @@ -1887,21 +1869,11 @@ def from_hdf5(cls, file_name): hazard_kwargs = dict() with h5py.File(file_name, 'r') as hf_data: for (var_name, var_val) in haz.__dict__.items(): - if var_name != 'tag' and var_name not in hf_data.keys(): + if var_name not in hf_data.keys(): continue if var_name == 'centroids': hazard_kwargs["centroids"] = Centroids.from_hdf5( hf_data.get(var_name)) - elif var_name == 'tag': - # legacy behavior: haz_type used to be part of the hazard tag - if "haz_type" in hf_data.keys(): - haz_type = u_hdf5.to_string( - hf_data.get("haz_type")[0]) - if haz_type: - hazard_kwargs["haz_type"] = haz_type - tag = Tag.from_hdf5(hf_data) - hazard_kwargs["file_name"] = tag.file_name - hazard_kwargs["description"] = tag.description 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): @@ -2143,7 +2115,7 @@ def _cen_return_inten(inten, freq, inten_th, return_periods): return inten_fit @staticmethod - def _read_att_mat(data, file_name, var_names, centroids, description): + def _read_att_mat(data, file_name, var_names, centroids): """Read MATLAB hazard's attributes.""" attrs = dict() attrs["frequency"] = np.squeeze(data[var_names['var_name']['freq']]) @@ -2183,12 +2155,6 @@ def _read_att_mat(data, file_name, var_names, centroids, description): file_name, data[var_names['var_name']['ev_name']]) except KeyError: attrs["event_name"] = list(attrs["event_id"]) - attrs["description"] = description - try: - comment = u_hdf5.get_string(data[var_names['var_name']['comment']]) - attrs["description"] += ' ' + comment - except KeyError: - pass try: datenum = data[var_names['var_name']['datenum']].squeeze() @@ -2249,7 +2215,6 @@ def append(self, *others): - All centroids are combined together using `Centroids.union`. - Lists, 1-dimensional arrays (NumPy) and sparse CSR matrices (SciPy) are concatenated. Sparse matrices are concatenated along the first (vertical) axis. - - All `tag` attributes are appended to `self.tag`. For any other type of attribute: A ValueError is raised if an attribute of that name is not defined in all of the non-empty hazards at least. However, there is no check that the @@ -2316,11 +2281,6 @@ def append(self, *others): raise ValueError(f"Attribute {attr_name} is not shared by all hazards. " "The hazards are incompatible and cannot be concatenated.") - # append all tags (to keep track of input files and descriptions) - for haz in haz_list: - if haz.tag is not self.tag: - self.tag.append(haz.tag) - # map individual centroids objects to union centroids = Centroids.union(*[haz.centroids for haz in haz_list]) hazcent_in_cent_idx_list = [ @@ -2357,7 +2317,7 @@ def concat(cls, haz_list): and then applies the `append` method. Please refer to the docs of `Hazard.append` for caveats and limitations of the concatenation procedure. - For centroids, tags, lists, arrays and sparse matrices, the remarks in `Hazard.append` + For centroids, lists, arrays and sparse matrices, the remarks in `Hazard.append` apply. All other attributes are copied from the first object in `haz_list`. Note that `Hazard.concat` can be used to concatenate hazards of a subclass. The result's @@ -2389,7 +2349,7 @@ def concat(cls, haz_list): # to save memory, only copy simple attributes like # "units" that are not explicitly handled by Hazard.append if not (isinstance(attr_val, (list, np.ndarray, sparse.csr_matrix)) - or attr_name in ["tag", "centroids"]): + or attr_name in ["centroids"]): setattr(haz_concat, attr_name, copy.deepcopy(attr_val)) haz_concat.append(*haz_list) return haz_concat diff --git a/climada/hazard/storm_europe.py b/climada/hazard/storm_europe.py index 682e1614b..ffa7a9676 100644 --- a/climada/hazard/storm_europe.py +++ b/climada/hazard/storm_europe.py @@ -36,7 +36,6 @@ from climada.util.config import CONFIG from climada.hazard.base import Hazard from climada.hazard.centroids.centr import Centroids -from climada.util.tag import Tag from climada.util.files_handler import get_file_names from climada.util.dates_times import (datetime64_to_ordinal, last_year, @@ -120,7 +119,7 @@ def read_footprints(self, *args, **kwargs): self.__dict__ = StormEurope.from_footprints(*args, **kwargs).__dict__ @classmethod - def from_footprints(cls, path, description=None, ref_raster=None, centroids=None, + def from_footprints(cls, path, ref_raster=None, centroids=None, files_omit='fp_era20c_1990012515_701_0.nc', combine_threshold=None, intensity_thres=None): """Create new StormEurope object from WISC footprints. @@ -135,9 +134,6 @@ def from_footprints(cls, path, description=None, ref_raster=None, centroids=None path to a single netCDF WISC footprint, or a folder containing only footprints, or a globbing pattern to one or more footprints. - description : str, optional - description of the events, defaults - to 'WISC historical hazard set' ref_raster : str, optional Reference netCDF file from which to construct a new barebones Centroids instance. Defaults to @@ -202,12 +198,6 @@ def from_footprints(cls, path, description=None, ref_raster=None, centroids=None np.max([(last_year(haz.date) - first_year(haz.date)), 1]) ) - if description is None: - description = "WISC historical hazard set." - haz.tag = Tag( - description=description, - ) - if combine_threshold is not None: LOGGER.info('Combining events with small difference in date.') difference_date = np.diff(haz.date) @@ -376,8 +366,6 @@ def from_cosmoe_file(cls, fp_file, run_datetime, event_date=None, frequency=np.divide( np.ones_like(event_id), np.unique(ncdf.epsd_1).size), - description=description, - file_name="Hazard set not saved, too large to pickle", ) # close netcdf file @@ -513,8 +501,7 @@ def from_icon_grib(cls, run_datetime, event_date=None, model_name='icon-eu-eps', frequency=np.divide( np.ones_like(event_id), np.unique(stacked.number).size), - description=description, - file_name="Hazard set not saved, too large to pickle") + ) haz.check() # delete generated .grib2 and .4cc40.idx files @@ -839,8 +826,6 @@ def generate_prob_storms(self, reg_id=528, spatial_shift=4, ssi_args=None, # years frequency=np.divide(np.repeat(self.frequency, N_PROB_EVENTS), N_PROB_EVENTS), - file_name='Hazard set not saved by default', - description='WISC probabilistic hazard set according to Schwierz et al.', orig=(event_id % 100 == 0), ) new_haz.check() diff --git a/climada/hazard/test/test_base.py b/climada/hazard/test/test_base.py index 503170fe7..284c0d692 100644 --- a/climada/hazard/test/test_base.py +++ b/climada/hazard/test/test_base.py @@ -32,7 +32,6 @@ import climada.util.dates_times as u_dt from climada.util.constants import DEF_FREQ_UNIT, HAZ_TEMPLATE_XLS, HAZ_DEMO_FL import climada.util.coordinates as u_coord -from climada.util.tag import Tag from climada.test import get_test_file import climada.hazard.test as hazard_test @@ -76,8 +75,6 @@ def dummy_hazard(): frequency=np.array([0.1, 0.5, 0.5, 0.2]), frequency_unit='1/week', units='m/s', - file_name="file1.mat", - description="Description 1", ) class TestLoader(unittest.TestCase): @@ -243,9 +240,7 @@ def test_equal_same(self): self.assertTrue((haz1.intensity != haz2.intensity).nnz == 0) self.assertTrue((haz1.fraction != haz2.fraction).nnz == 0) self.assertEqual(haz1.units, haz2.units) - self.assertEqual(haz1.tag.file_name, haz2.tag.file_name) self.assertEqual(haz1.haz_type, haz2.haz_type) - self.assertEqual(haz1.tag.description, haz2.tag.description) def test_same_events_same(self): """Append hazard with same events and diff centroids. After removing @@ -272,8 +267,6 @@ def test_same_events_same(self): fraction=fraction, intensity=intensity, units="m/s", - file_name="file2.mat", - description="Description 2" ) haz1.append(haz2) @@ -300,12 +293,7 @@ def test_same_events_same(self): self.assertTrue(np.array_equal(haz1.frequency, haz_res.frequency)) self.assertEqual(haz1.frequency_unit, haz_res.frequency_unit) self.assertEqual(haz_res.units, haz1.units) - - self.assertEqual(haz1.tag.file_name, - haz_res.tag.file_name + haz2.tag.file_name) self.assertEqual(haz1.haz_type, haz_res.haz_type) - self.assertEqual(haz1.tag.description, - haz_res.tag.description + haz2.tag.description) class TestSelect(unittest.TestCase): """Test select method.""" @@ -316,7 +304,6 @@ def test_select_event_name(self): sel_haz = haz.select(event_names=['ev4', 'ev1']) self.assertTrue(np.array_equal(sel_haz.centroids.coord, haz.centroids.coord)) - self.assertEqual(sel_haz.tag, haz.tag) self.assertEqual(sel_haz.units, haz.units) self.assertTrue(np.array_equal(sel_haz.event_id, np.array([4, 1]))) self.assertTrue(np.array_equal(sel_haz.date, np.array([4, 1]))) @@ -340,7 +327,6 @@ def test_select_event_id(self): sel_haz = haz.select(event_id=[4, 1]) self.assertTrue(np.array_equal(sel_haz.centroids.coord, haz.centroids.coord)) - self.assertEqual(sel_haz.tag, haz.tag) self.assertEqual(sel_haz.units, haz.units) self.assertTrue(np.array_equal(sel_haz.event_id, np.array([4, 1]))) self.assertTrue(np.array_equal(sel_haz.date, np.array([4, 1]))) @@ -364,7 +350,6 @@ def test_select_event_id(self): sel_haz = haz.select(event_id=np.array([4, 1])) self.assertTrue(np.array_equal(sel_haz.centroids.coord, haz.centroids.coord)) - self.assertEqual(sel_haz.tag, haz.tag) self.assertEqual(sel_haz.units, haz.units) self.assertTrue(np.array_equal(sel_haz.event_id, np.array([4, 1]))) self.assertTrue(np.array_equal(sel_haz.date, np.array([4, 1]))) @@ -388,7 +373,6 @@ def test_select_orig_pass(self): sel_haz = haz.select(orig=True) self.assertTrue(np.array_equal(sel_haz.centroids.coord, haz.centroids.coord)) - self.assertEqual(sel_haz.tag, haz.tag) self.assertEqual(sel_haz.units, haz.units) self.assertTrue(np.array_equal(sel_haz.event_id, np.array([1, 4]))) self.assertTrue(np.array_equal(sel_haz.date, np.array([1, 4]))) @@ -410,7 +394,6 @@ def test_select_syn_pass(self): sel_haz = haz.select(orig=False) self.assertTrue(np.array_equal(sel_haz.centroids.coord, haz.centroids.coord)) - self.assertEqual(sel_haz.tag, haz.tag) self.assertEqual(sel_haz.units, haz.units) self.assertTrue(np.array_equal(sel_haz.event_id, np.array([2, 3]))) self.assertTrue(np.array_equal(sel_haz.date, np.array([2, 3]))) @@ -432,7 +415,6 @@ def test_select_date_pass(self): sel_haz = haz.select(date=(2, 4)) self.assertTrue(np.array_equal(sel_haz.centroids.coord, haz.centroids.coord)) - self.assertEqual(sel_haz.tag, haz.tag) self.assertEqual(sel_haz.units, haz.units) self.assertTrue(np.array_equal(sel_haz.event_id, np.array([2, 3, 4]))) self.assertTrue(np.array_equal(sel_haz.date, np.array([2, 3, 4]))) @@ -458,7 +440,6 @@ def test_select_date_str_pass(self): sel_haz = haz.select(date=('0001-01-02', '0001-01-03')) self.assertTrue(np.array_equal(sel_haz.centroids.coord, haz.centroids.coord)) - self.assertEqual(sel_haz.tag, haz.tag) self.assertEqual(sel_haz.units, haz.units) self.assertTrue(np.array_equal(sel_haz.event_id, np.array([2, 3]))) self.assertTrue(np.array_equal(sel_haz.date, np.array([2, 3]))) @@ -480,7 +461,6 @@ def test_select_date_and_orig_pass(self): sel_haz = haz.select(date=(2, 4), orig=False) self.assertTrue(np.array_equal(sel_haz.centroids.coord, haz.centroids.coord)) - self.assertEqual(sel_haz.tag, haz.tag) self.assertEqual(sel_haz.units, haz.units) self.assertTrue(np.array_equal(sel_haz.event_id, np.array([2, 3]))) self.assertTrue(np.array_equal(sel_haz.date, np.array([2, 3]))) @@ -532,7 +512,6 @@ def test_select_reg_id_pass(self): self.assertTrue(np.array_equal(sel_haz.centroids.coord.squeeze(), haz.centroids.coord[2, :])) - self.assertEqual(sel_haz.tag, haz.tag) self.assertEqual(sel_haz.units, haz.units) self.assertTrue(np.array_equal(sel_haz.event_id, np.array([2, 3]))) self.assertTrue(np.array_equal(sel_haz.date, np.array([2, 3]))) @@ -556,7 +535,6 @@ def test_select_tight_pass(self): self.assertTrue(np.array_equal(sel_haz.centroids.coord.squeeze(), haz.centroids.coord[:-1, :])) - self.assertEqual(sel_haz.tag, haz.tag) self.assertEqual(sel_haz.units, haz.units) self.assertTrue(np.array_equal(sel_haz.event_id, haz.event_id)) self.assertTrue(np.array_equal(sel_haz.date, haz.date)) @@ -580,7 +558,6 @@ def test_select_tight_pass(self): self.assertTrue(np.array_equal(sel_haz.centroids.coord.squeeze(), haz.centroids.coord[:-1, :])) - self.assertEqual(sel_haz.tag, haz.tag) self.assertEqual(sel_haz.units, haz.units) self.assertTrue(np.array_equal(sel_haz.event_id, haz.event_id)) self.assertTrue(np.array_equal(sel_haz.date, haz.date)) @@ -609,7 +586,6 @@ def test_select_tight_pass(self): self.assertTrue(np.array_equal(sel_haz.centroids.coord.squeeze(), haz.centroids.coord)) - self.assertEqual(sel_haz.tag, haz.tag) self.assertEqual(sel_haz.units, haz.units) self.assertTrue(np.array_equal(sel_haz.event_id, haz.event_id)) self.assertTrue(np.array_equal(sel_haz.date, haz.date)) @@ -643,9 +619,7 @@ def _check_hazard(hazard): self.assertTrue((hazard.intensity != haz1_orig.intensity).nnz == 0) self.assertTrue((hazard.fraction != haz1_orig.fraction).nnz == 0) self.assertEqual(hazard.units, haz1_orig.units) - self.assertEqual(hazard.tag.file_name, haz1_orig.tag.file_name) self.assertEqual(hazard.haz_type, haz1_orig.haz_type) - self.assertEqual(hazard.tag.description, haz1_orig.tag.description) haz1 = Hazard.from_excel(HAZ_TEMPLATE_XLS, haz_type='TC') haz2 = Hazard('TC') @@ -673,8 +647,6 @@ def test_same_centroids_extend(self): [8.3, 4.1, 4.0], [9.3, 9.2, 1.7]]) haz2 = Hazard('TC', - file_name='file2.mat', - description='Description 2', centroids=haz1.centroids, event_id=np.array([5, 6, 7, 8]), event_name=['ev5', 'ev6', 'ev7', 'ev8'], @@ -711,19 +683,13 @@ def test_same_centroids_extend(self): self.assertEqual(haz1.centroids.size, 3) self.assertTrue(np.array_equal(haz1.centroids.coord, haz2.centroids.coord)) - self.assertEqual(haz1.tag.file_name, - haz1_orig.tag.file_name + haz2.tag.file_name) self.assertEqual(haz1.haz_type, haz1_orig.haz_type) - self.assertEqual(haz1.tag.description, - haz1_orig.tag.description + haz2.tag.description) def test_incompatible_type_fail(self): """Raise error when append two incompatible hazards.""" haz1 = dummy_hazard() haz2 = dummy_hazard() haz2.haz_type = 'WS' - haz2.tag = Tag(file_name='file2.mat', - description='Description 2') with self.assertRaises(ValueError) as cm: haz1.append(haz2) @@ -758,8 +724,6 @@ def test_all_different_extend(self): haz2 = Hazard('TC', date=np.ones((4,)), orig=np.ones((4,)), - file_name='file2.mat', - description='Description 2', centroids=Centroids.from_lat_lon( np.array([7, 9, 11]), np.array([8, 10, 12])), event_id=np.array([5, 6, 7, 8]), @@ -796,11 +760,7 @@ def test_all_different_extend(self): self.assertEqual(haz1.centroids.size, 6) self.assertEqual(haz1_orig.units, haz1.units) self.assertEqual(haz1_orig.frequency_unit, haz1.frequency_unit) - self.assertEqual(haz1.tag.file_name, - haz1_orig.tag.file_name + haz2.tag.file_name) self.assertEqual(haz1.haz_type, haz1_orig.haz_type) - self.assertEqual(haz1.tag.description, - haz1_orig.tag.description + haz2.tag.description) def test_same_events_append(self): """Append hazard with same events (and diff centroids). @@ -815,8 +775,6 @@ def test_same_events_append(self): [8.33, 4.11, 4.4], [9.33, 9.22, 1.77]]) haz2 = Hazard('TC', - file_name='file2.mat', - description='Description 2', centroids=Centroids.from_lat_lon( np.array([7, 9, 11]), np.array([8, 10, 12])), event_id=haz1.event_id, @@ -858,18 +816,12 @@ def test_same_events_append(self): self.assertEqual(haz1_ori.frequency_unit, haz1.frequency_unit) self.assertEqual(haz1_ori.units, haz1.units) - self.assertEqual(haz1.tag.file_name, - haz1_ori.tag.file_name + haz2.tag.file_name) self.assertEqual(haz1.haz_type, haz1_ori.haz_type) - self.assertEqual(haz1.tag.description, - haz1_ori.tag.description + haz2.tag.description) def test_concat_pass(self): """Test concatenate function.""" haz_1 = Hazard("TC", - file_name='file1.mat', - description='Description 1', centroids=Centroids.from_lat_lon( np.array([1, 3, 5]), np.array([2, 4, 6])), event_id=np.array([1]), @@ -883,8 +835,6 @@ def test_concat_pass(self): units='m/s',) haz_2 = Hazard("TC", - file_name='file2.mat', - description='Description 2', centroids=Centroids.from_lat_lon( np.array([1, 3, 5]), np.array([2, 4, 6])), event_id=np.array([1]), @@ -918,8 +868,6 @@ def test_concat_pass(self): self.assertEqual(haz.event_name, ['ev1', 'ev2']) self.assertTrue(np.array_equal(haz.centroids.coord, haz_1.centroids.coord)) self.assertTrue(np.array_equal(haz.centroids.coord, haz_2.centroids.coord)) - self.assertEqual(haz.tag.file_name, ['file1.mat', 'file2.mat']) - self.assertEqual(haz.tag.description, ['Description 1', 'Description 2']) def test_append_new_var_pass(self): """New variable appears if hazard to append is empty.""" @@ -957,8 +905,6 @@ def test_change_centroids(self): cent1 = Centroids(lat=lat, lon=lon, on_land=on_land) haz_1 = Hazard('TC', - file_name='file1.mat', - description='Description 1', centroids=cent1, event_id=np.array([1]), event_name=['ev1'], @@ -983,7 +929,6 @@ def test_change_centroids(self): self.assertTrue(np.array_equal(haz_2.event_id, np.array([1]))) self.assertTrue(np.array_equal(haz_2.event_name, ['ev1'])) self.assertTrue(np.array_equal(haz_2.orig, [True])) - self.assertEqual(haz_2.tag.description, ['Description 1']) """Test error for projection""" lat3, lon3 = np.array([0.5, 3]), np.array([-0.5, 3]) @@ -1002,8 +947,6 @@ def test_change_centroids_raster(self): cent1 = Centroids(lat=lat, lon=lon, on_land=on_land) haz_1 = Hazard('TC', - file_name='file1.mat', - description='Description 1', centroids=cent1, event_id=np.array([1]), event_name=['ev1'], @@ -1030,7 +973,6 @@ def test_change_centroids_raster(self): self.assertTrue(np.array_equal(haz_4.event_id, np.array([1]))) self.assertTrue(np.array_equal(haz_4.event_name, ['ev1'])) self.assertTrue(np.array_equal(haz_4.orig, [True])) - self.assertEqual(haz_4.tag.description, ['Description 1']) class TestStats(unittest.TestCase): @@ -1096,7 +1038,7 @@ def test_hazard_pass(self): # Read demo excel file description = 'One single file.' - hazard = Hazard.from_excel(HAZ_TEMPLATE_XLS, description=description, haz_type='TC') + hazard = Hazard.from_excel(HAZ_TEMPLATE_XLS, haz_type='TC') # Check results n_events = 100 @@ -1145,9 +1087,6 @@ def test_hazard_pass(self): self.assertTrue(np.all(hazard.orig)) - # tag hazard - self.assertEqual(hazard.tag.file_name, [str(HAZ_TEMPLATE_XLS)]) - self.assertEqual(hazard.tag.description, [description]) self.assertEqual(hazard.haz_type, 'TC') class TestReaderMat(unittest.TestCase): @@ -1205,10 +1144,6 @@ def test_hazard_pass(self): self.assertFalse(hazard.orig[10651]) self.assertFalse(hazard.orig[4818]) - # tag hazard - self.assertEqual(hazard.tag.file_name, [str(HAZ_TEST_MAT)]) - self.assertEqual(hazard.tag.description, - [' TC hazard event set, generated 14-Nov-2017 10:09:05']) self.assertEqual(hazard.haz_type, 'TC') class TestHDF5(unittest.TestCase): @@ -1233,7 +1168,6 @@ class CustomID: # Load the file again and compare to previous instance hazard_read = Hazard.from_hdf5(file_name) - self.assertEqual(hazard.tag.description, hazard_read.tag.description) self.assertTrue(np.array_equal(hazard.date, hazard_read.date)) self.assertTrue(np.array_equal(hazard_read.event_id, np.array([]))) # Empty array @@ -1306,14 +1240,13 @@ def test_clear(self): haz1.frequency_unit = "1/m" haz1.foo = np.arange(10) haz1.clear() - self.assertEqual(list(vars(haz1.tag).values()), [[], []]) self.assertEqual(haz1.haz_type, '') self.assertEqual(haz1.units, '') self.assertEqual(haz1.frequency_unit, DEF_FREQ_UNIT) self.assertEqual(haz1.centroids.size, 0) self.assertEqual(len(haz1.event_name), 0) for attr in vars(haz1).keys(): - if attr not in ['tag', 'haz_type', 'units', 'event_name', 'pool', 'frequency_unit']: + if attr not in ['haz_type', 'units', 'event_name', 'pool', 'frequency_unit']: self.assertEqual(getattr(haz1, attr).size, 0) self.assertIsNone(haz1.pool) diff --git a/climada/hazard/test/test_trop_cyclone.py b/climada/hazard/test/test_trop_cyclone.py index ddf7a4128..d5271753c 100644 --- a/climada/hazard/test/test_trop_cyclone.py +++ b/climada/hazard/test/test_trop_cyclone.py @@ -92,8 +92,6 @@ def test_set_one_pass(self): store_windfields=True, metric=metric) self.assertEqual(tc_haz.haz_type, 'TC') - self.assertEqual(tc_haz.tag.description, []) - self.assertEqual(tc_haz.tag.file_name, ['Name: 1951239N12334']) self.assertEqual(tc_haz.units, 'm/s') self.assertEqual(tc_haz.centroids.size, 296) self.assertEqual(tc_haz.event_id.size, 1) @@ -204,8 +202,6 @@ def test_set_one_file_pass(self): tc_haz.check() self.assertEqual(tc_haz.haz_type, 'TC') - self.assertEqual(tc_haz.tag.description, []) - self.assertEqual(tc_haz.tag.file_name, ['Name: 1951239N12334']) self.assertEqual(tc_haz.units, 'm/s') self.assertEqual(tc_haz.centroids.size, 296) self.assertEqual(tc_haz.event_id.size, 1) @@ -232,8 +228,6 @@ def test_two_files_pass(self): tc_haz.check() self.assertEqual(tc_haz.haz_type, 'TC') - self.assertEqual(tc_haz.tag.description, []) - self.assertEqual(tc_haz.tag.file_name, ['Name: 1951239N12334']) # distinct file names self.assertEqual(tc_haz.units, 'm/s') self.assertEqual(tc_haz.centroids.size, 296) self.assertEqual(tc_haz.event_id.size, 1) @@ -433,9 +427,6 @@ def test_apply_criterion_track(self): self.assertFalse( np.allclose(tc.intensity[2, :].toarray(), tc_cc.intensity[2, :].toarray())) self.assertTrue(np.allclose(tc.frequency, tc_cc.frequency)) - self.assertEqual( - tc_cc.tag.description, - 'climate change scenario for year 2050 and RCP 45 from Knutson et al 2015.') def test_apply_criterion_track(self): """Test _apply_criterion function.""" diff --git a/climada/hazard/trop_cyclone.py b/climada/hazard/trop_cyclone.py index 83ee960ef..24caa7b62 100644 --- a/climada/hazard/trop_cyclone.py +++ b/climada/hazard/trop_cyclone.py @@ -43,7 +43,6 @@ import climada.util.constants as u_const import climada.util.coordinates as u_coord import climada.util.plot as u_plot -from climada.util.tag import Tag LOGGER = logging.getLogger(__name__) @@ -181,7 +180,6 @@ def from_tracks( tracks: TCTracks, centroids: Optional[Centroids] = None, pool: Optional[pathos.pools.ProcessPool] = None, - description: str = '', model: str = 'H08', ignore_distance_to_coast: bool = False, store_windfields: bool = False, @@ -334,7 +332,6 @@ def from_tracks( haz.intensity_thres = intensity_thres LOGGER.debug('Compute frequency.') haz.frequency_from_tracks(tracks.data) - haz.tag.append(Tag(description=description)) return haz def apply_climate_scenario_knu( @@ -378,8 +375,6 @@ def apply_climate_scenario_knu( chg_int_freq = get_knutson_criterion() scale_rcp_year = calc_scale_knutson(ref_year, rcp_scenario) haz_cc = self._apply_knutson_criterion(chg_int_freq, scale_rcp_year) - haz_cc.tag = Tag(description=f'climate change scenario for year {ref_year}' - f' and RCP {rcp_scenario} from Knutson et al 2015.') return haz_cc def set_climate_scenario_knu(self, *args, **kwargs): @@ -572,7 +567,6 @@ def from_single_track( ) new_haz = cls(haz_type=HAZ_TYPE) - new_haz.tag = Tag(file_name=f'Name: {track.name}') new_haz.intensity_thres = intensity_thres new_haz.intensity = intensity_sparse if store_windfields: diff --git a/climada/test/test_hazard.py b/climada/test/test_hazard.py index c659830be..d82ab1da3 100644 --- a/climada/test/test_hazard.py +++ b/climada/test/test_hazard.py @@ -146,7 +146,7 @@ def _test_first(haz): # Load first entry storms = StormEurope.from_footprints( - WS_DEMO_NC[0], description="test_description" + WS_DEMO_NC[0] ) _test_first(storms) @@ -155,7 +155,7 @@ def _test_first(haz): _test_first(storms) # Now load both - storms = StormEurope.from_footprints(WS_DEMO_NC, description="test_description") + storms = StormEurope.from_footprints(WS_DEMO_NC) self.assertEqual(storms.haz_type, "WS") self.assertEqual(storms.units, "m/s") @@ -280,12 +280,8 @@ def test_write_read_pass(self): haz_read = Hazard.from_hdf5(file_name) - self.assertEqual(hazard.tag.file_name, haz_read.tag.file_name) - self.assertIsInstance(haz_read.tag.file_name, list) self.assertEqual(hazard.haz_type, haz_read.haz_type) self.assertIsInstance(haz_read.haz_type, str) - self.assertEqual(hazard.tag.description, haz_read.tag.description) - self.assertIsInstance(haz_read.tag.description, list) self.assertEqual(hazard.units, haz_read.units) self.assertIsInstance(haz_read.units, str) self.assertTrue( diff --git a/doc/tutorial/climada_hazard_Hazard.ipynb b/doc/tutorial/climada_hazard_Hazard.ipynb index 9347caec5..9c250c4dd 100644 --- a/doc/tutorial/climada_hazard_Hazard.ipynb +++ b/doc/tutorial/climada_hazard_Hazard.ipynb @@ -22,7 +22,6 @@ "\n", "| Mandatory variables             | Data Type                                    | Description                                        |\n", "| :- | :- | :- |\n", - "| tag |`Tag()`| information about the source|\n", "| units |(str)| units of the intensity|\n", "| centroids |`Centroids()`| centroids of the events|\n", "| event_id |(np.array)| id (>0) of each event|\n", From c7157aa78e583e6d8962f1c04b81d7f9c3501318 Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Wed, 30 Aug 2023 13:45:25 +0200 Subject: [PATCH 12/44] .github release action update --- .github/scripts/make_release.py | 2 +- .github/workflows/make-release.yml | 4 ++-- .github/workflows/postrelease-setup-devbranch.yml | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/scripts/make_release.py b/.github/scripts/make_release.py index 01d166713..5c6260d4d 100644 --- a/.github/scripts/make_release.py +++ b/.github/scripts/make_release.py @@ -1,7 +1,7 @@ #!/usr/bin/env python3 """This script is part of the GitHub CI make-release pipeline -It reads the version number from climada/_version.py and then uses the `gh` cli +It reads the version number from climada*/_version.py and then uses the `gh` cli to create the new release. """ diff --git a/.github/workflows/make-release.yml b/.github/workflows/make-release.yml index c8dab5790..affd6044d 100644 --- a/.github/workflows/make-release.yml +++ b/.github/workflows/make-release.yml @@ -28,10 +28,10 @@ jobs: with: token: ${{ secrets.PERSONAL_ACCESS_TOKEN }} - name: Prepare new release - run: .github/scripts/prepare_release.py ${{ inputs.level }} + run: python .github/scripts/prepare_release.py ${{ inputs.level }} env: GITHUB_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }} - name: Publish - run: .github/scripts/make_release.py + run: python .github/scripts/make_release.py env: GITHUB_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }} diff --git a/.github/workflows/postrelease-setup-devbranch.yml b/.github/workflows/postrelease-setup-devbranch.yml index 176a07644..f8c4b764a 100644 --- a/.github/workflows/postrelease-setup-devbranch.yml +++ b/.github/workflows/postrelease-setup-devbranch.yml @@ -19,6 +19,6 @@ jobs: with: token: ${{ secrets.PERSONAL_ACCESS_TOKEN }} - name: Update files - run: .github/scripts/setup_devbranch.sh + run: bash .github/scripts/setup_devbranch.sh env: GITHUB_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }} From d9b925c12feb0cb28a410104011957e8ee39e016 Mon Sep 17 00:00:00 2001 From: Emanuel Schmid <51439563+emanuel-schmid@users.noreply.github.com> Date: Thu, 31 Aug 2023 08:39:25 +0200 Subject: [PATCH 13/44] Remove Tag from Exposures (#756) * exposures.base: remove tag from Exposures * doc: remove tag from Exposures tutorial * Entity: no more __str__ overriding * remove tag from Exposures * remove dead code * cosmetics * LitPop remove tag, replaced by novel _metadata attribute `description` Overriding plot_scatter and plot_hexbin to keep custom plot titles unchanged * PEP8 * reaction to out of the blue failing of readthedocs to build * adjust readthedocs environment * add output secction to prevent readthedocs from buildiing * changelog updated * chanchangelog updated * Make description an attribute of Exposures, not just LitPop crop_production, black_marble and spam_agrar also depend on it * exposures.plots: skip standard title formatting * forcast: revert dead code removal * exposures.base.plots: title must not be None * remove remaining traces of Exposures.tag * remove remaining traces of Exposures.tag --- CHANGELOG.md | 3 + climada/entity/entity_def.py | 13 +- climada/entity/exposures/base.py | 65 ++++--- climada/entity/exposures/litpop/litpop.py | 47 +++-- climada/entity/exposures/test/test_base.py | 15 +- climada/entity/exposures/test/test_mat.py | 1 - climada/entity/measures/test/test_base.py | 9 +- climada/entity/test/test_entity.py | 27 +-- climada/test/test_api_client.py | 12 +- climada/test/test_litpop_integr.py | 6 +- climada/test/test_plot.py | 9 +- doc/tutorial/1_main_climada.ipynb | 60 +++---- doc/tutorial/climada_entity_DiscRates.ipynb | 5 +- doc/tutorial/climada_entity_Exposures.ipynb | 8 +- doc/tutorial/climada_entity_LitPop.ipynb | 186 -------------------- 15 files changed, 116 insertions(+), 350 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 905ff4cda..027197ccf 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -30,6 +30,7 @@ Removed: - Added method `Exposures.centroids_total_value` to replace the functionality of `Exposures.affected_total_value`. This method is temporary and deprecated. [#702](https://github.com/CLIMADA-project/climada_python/pull/702) - New method `climada.util.api_client.Client.purge_cache`: utility function to remove outdated files from the local file system to free disk space. ([#737](https://github.com/CLIMADA-project/climada_python/pull/737)) +- New attribute `climada.entity.exposures.Exposures.description`: used for setting the default title in plots from plotting mathods `plot_hexbin` and `plot_scatter`. [#756](https://github.com/CLIMADA-project/climada_python/pull/756) - Added advanced examples in unsequa tutorial for coupled input variables and for handling efficiently the loading of multiple large files [#766](https://github.com/CLIMADA-project/climada_python/pull/766) ### Changed @@ -58,6 +59,7 @@ Removed: - `list_dataset_infos` from `climada.util.api_client.Client`: the `properties` argument, a `dict`, can now have `None` as values. Before, only strings and lists of strings were allowed. Setting a particular property to `None` triggers a search for datasets where this property is not assigned. [#752](https://github.com/CLIMADA-project/climada_python/pull/752) - Reduce memory requirements of `TropCyclone.from_tracks` [#749](https://github.com/CLIMADA-project/climada_python/pull/749) - Support for different wind speed and pressure units in `TCTracks` when running `TropCyclone.from_tracks` [#749](https://github.com/CLIMADA-project/climada_python/pull/749) +- The title of plots created by the `Exposures` methods `plot_hexbin` and `plot_scatter` can be set as a method argument. [#756](https://github.com/CLIMADA-project/climada_python/pull/756) - Changed the parallel package from Pathos to Multiproess in the unsequa module [#763](https://github.com/CLIMADA-project/climada_python/pull/763) - Updated installation instructions to use conda for core and petals [#776](https://github.com/CLIMADA-project/climada_python/pull/776) @@ -83,6 +85,7 @@ Removed: - `Centroids.set_raster_from_pix_bounds` [#721](https://github.com/CLIMADA-project/climada_python/pull/721) - `requirements/env_developer.yml` environment specs. Use 'extra' requirements when installing the Python package instead [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - `Impact.tag` attribute. This change is not backwards-compatible with respect to the files written and read by the `Impact` class [#743](https://github.com/CLIMADA-project/climada_python/pull/743) +- `Exposures.tag` attribute. This change is not backwards-compatible with respect to the files written and read by the `Exposures` class [#756](https://github.com/CLIMADA-project/climada_python/pull/756) - `Hazard.tag` attribute. This change is not backwards-compatible with respect to the files written and read by the `Hazard` class [#767](https://github.com/CLIMADA-project/climada_python/pull/767) - `impact.tot_value ` attribute removed from unsequa module [#763](https://github.com/CLIMADA-project/climada_python/pull/763) diff --git a/climada/entity/entity_def.py b/climada/entity/entity_def.py index b908d5709..542ca2992 100755 --- a/climada/entity/entity_def.py +++ b/climada/entity/entity_def.py @@ -25,7 +25,6 @@ from typing import Optional import pandas as pd -from climada.util.tag import Tag from climada.entity.impact_funcs.impact_func_set import ImpactFuncSet from climada.entity.disc_rates.base import DiscRates from climada.entity.measures.measure_set import MeasureSet @@ -106,7 +105,7 @@ def read_mat(self, *args, **kwargs): self.__dict__ = Entity.from_mat(*args, **kwargs).__dict__ @classmethod - def from_excel(cls, file_name, description=''): + def from_excel(cls, file_name): """Read csv or xls or xlsx file following climada's template. Parameters @@ -125,15 +124,14 @@ def from_excel(cls, file_name, description=''): """ exp = Exposures(pd.read_excel(file_name)) - exp.tag = Tag(file_name=file_name, description=description) - dr = DiscRates.from_excel(file_name) + disc_rates = DiscRates.from_excel(file_name) impf_set = ImpactFuncSet.from_excel(file_name) meas_set = MeasureSet.from_excel(file_name) return cls( exposures=exp, - disc_rates=dr, + disc_rates=disc_rates, impact_func_set=impf_set, measure_set=meas_set, ) @@ -178,8 +176,3 @@ def __setattr__(self, name, value): if not isinstance(value, DiscRates): raise ValueError("Input value is not (sub)class of DiscRates.") super().__setattr__(name, value) - - def __str__(self): - return 'Exposures: \n' + self.exposures.tag.__str__() - - __repr__ = __str__ diff --git a/climada/entity/exposures/base.py b/climada/entity/exposures/base.py index c43464f79..0f12cfc86 100644 --- a/climada/entity/exposures/base.py +++ b/climada/entity/exposures/base.py @@ -37,7 +37,6 @@ import cartopy.crs as ccrs from climada.hazard import Hazard -from climada.util.tag import Tag import climada.util.hdf5_handler as u_hdf5 from climada.util.constants import ONE_LAT_KM, DEF_CRS, CMAP_RASTER import climada.util.coordinates as u_coord @@ -84,8 +83,8 @@ class Exposures(): Attributes ---------- - tag : climada.util.tag.Tag - metada - information about the source data + description : str + metadata - description of content and origin of the data ref_year : int metada - reference year value_unit : str @@ -121,7 +120,7 @@ class Exposures(): TC. There might be different hazards defined: centr_TC, centr_FL, ... Computed in method assign_centroids(). """ - _metadata = ['tag', 'ref_year', 'value_unit', 'meta', 'description'] + _metadata = ['description', 'ref_year', 'value_unit', 'meta'] vars_oblig = ['value', 'latitude', 'longitude'] """Name of the variables needed to compute the impact.""" @@ -142,7 +141,7 @@ def crs(self): # In case of gdf without geometry, empty or before set_geometry_points was called return self.meta.get('crs') - def __init__(self, *args, meta=None, tag=None, ref_year=DEF_REF_YEAR, + def __init__(self, *args, meta=None, description=None, ref_year=DEF_REF_YEAR, value_unit=DEF_VALUE_UNIT, crs=None, **kwargs): """Creates an Exposures object from a GeoDataFrame @@ -154,8 +153,8 @@ def __init__(self, *args, meta=None, tag=None, ref_year=DEF_REF_YEAR, Named arguments of the GeoDataFrame constructor, additionally meta : dict, optional Metadata dictionary. Default: {} (empty dictionary) - tag : climada.entity.exposures.tag.Tag, optional - Exposures tag. Defaults to the entry of the same name in `meta` or an empty Tag object. + description : str, optional + Default: None ref_year : int, optional Reference Year. Defaults to the entry of the same name in `meta` or 2018. value_unit : str, optional @@ -168,11 +167,10 @@ def __init__(self, *args, meta=None, tag=None, ref_year=DEF_REF_YEAR, self.meta = {} if meta is None else meta if not isinstance(self.meta, dict): raise ValueError("meta must be a dictionary") - self.tag = self.meta.get('tag', Tag()) if tag is None else tag + self.description = self.meta.get('description') if description is None else description self.ref_year = self.meta.get('ref_year', DEF_REF_YEAR) if ref_year is None else ref_year self.value_unit = (self.meta.get('value_unit', DEF_VALUE_UNIT) if value_unit is None else value_unit) - self.description = kwargs.pop('description') if 'description' in kwargs else None # remaining generic attributes from derived classes for mda in type(self)._metadata: @@ -501,7 +499,6 @@ def from_raster(cls, file_name, band=1, src_crs=None, window=None, Exposures """ exp = cls() - exp.tag = Tag(file_name=file_name) meta, value = u_coord.read_raster(file_name, [band], src_crs, window, geometry, dst_crs, transform, width, height, resampling) @@ -521,7 +518,7 @@ def from_raster(cls, file_name, band=1, src_crs=None, window=None, def plot_scatter(self, mask=None, ignore_zero=False, pop_name=True, buffer=0.0, extend='neither', axis=None, figsize=(9, 13), - adapt_fontsize=True, **kwargs): + adapt_fontsize=True, title=None, **kwargs): """Plot exposures geometry's value sum scattered over Earth's map. The plot will we projected according to the current crs. @@ -546,17 +543,19 @@ def plot_scatter(self, mask=None, ignore_zero=False, pop_name=True, adapt_fontsize : bool, optional If set to true, the size of the fonts will be adapted to the size of the figure. Otherwise the default matplotlib font size is used. Default is True. + title : str, optional + a title for the plot. If not set `self.description` is used. kwargs : optional arguments for scatter matplotlib function, e.g. - cmap='Greys'. Default: 'Wistia' + cmap='Greys' Returns ------- cartopy.mpl.geoaxes.GeoAxesSubplot """ crs_epsg, _ = u_plot.get_transformation(self.crs) - title = "\n".join(self.tag.description) - cbar_label = f'Value ({self.value_unit})' + if title is None: + title = self.description or "" if mask is None: mask = np.ones((self.gdf.shape[0],), dtype=bool) if ignore_zero: @@ -566,8 +565,13 @@ def plot_scatter(self, mask=None, ignore_zero=False, pop_name=True, value = self.gdf.value[mask][pos_vals].values coord = np.stack([self.gdf.latitude[mask][pos_vals].values, self.gdf.longitude[mask][pos_vals].values], axis=1) - return u_plot.geo_scatter_from_array(value, coord, cbar_label, title, - pop_name, buffer, extend, + return u_plot.geo_scatter_from_array(array_sub=value, + geo_coord=coord, + var_name=f'Value ({self.value_unit})', + title=title, + pop_name=pop_name, + buffer=buffer, + extend=extend, proj=crs_epsg, axes=axis, figsize=figsize, @@ -576,7 +580,7 @@ def plot_scatter(self, mask=None, ignore_zero=False, pop_name=True, def plot_hexbin(self, mask=None, ignore_zero=False, pop_name=True, buffer=0.0, extend='neither', axis=None, figsize=(9, 13), - adapt_fontsize=True, **kwargs): + adapt_fontsize=True, title=None, **kwargs): """Plot exposures geometry's value sum binned over Earth's map. An other function for the bins can be set through the key reduce_C_function. The plot will we projected according to the current crs. @@ -605,6 +609,8 @@ def plot_hexbin(self, mask=None, ignore_zero=False, pop_name=True, If set to true, the size of the fonts will be adapted to the size of the figure. Otherwise the default matplotlib font size is used. Default is True. + title : str, optional + a title for the plot. If not set `self.description` is used. kwargs : optional arguments for hexbin matplotlib function, e.g. `reduce_C_function=np.average`. @@ -615,8 +621,8 @@ def plot_hexbin(self, mask=None, ignore_zero=False, pop_name=True, cartopy.mpl.geoaxes.GeoAxesSubplot """ crs_epsg, _ = u_plot.get_transformation(self.crs) - title = "\n".join(self.tag.description) - cbar_label = f'Value ({self.value_unit})' + if title is None: + title = self.description or "" if 'reduce_C_function' not in kwargs: kwargs['reduce_C_function'] = np.sum if mask is None: @@ -628,9 +634,17 @@ def plot_hexbin(self, mask=None, ignore_zero=False, pop_name=True, value = self.gdf.value[mask][pos_vals].values coord = np.stack([self.gdf.latitude[mask][pos_vals].values, self.gdf.longitude[mask][pos_vals].values], axis=1) - return u_plot.geo_bin_from_array(value, coord, cbar_label, title, - pop_name, buffer, extend, proj=crs_epsg, - axes=axis, figsize=figsize, adapt_fontsize=adapt_fontsize, + return u_plot.geo_bin_from_array(array_sub=value, + geo_coord=coord, + var_name=f'Value ({self.value_unit})', + title=title, + pop_name=pop_name, + buffer=buffer, + extend=extend, + proj=crs_epsg, + axes=axis, + figsize=figsize, + adapt_fontsize=adapt_fontsize, **kwargs) def plot_raster(self, res=None, raster_res=None, save_tiff=None, @@ -842,6 +856,9 @@ def from_hdf5(cls, file_name): for key, val in metadata.items(): if key in type(exp)._metadata: # pylint: disable=protected-access setattr(exp, key, val) + if key == 'tag': # for backwards compatitbility with climada <= 3.x + descriptions = [u_hdf5.to_string(x) for x in getattr(val, 'description', [])] + exp.description = "\n".join(descriptions) if descriptions else None return exp def read_mat(self, *args, **kwargs): @@ -1158,7 +1175,7 @@ def add_sea(exposures, sea_res, scheduler=None): ref_year=exposures.ref_year, value_unit=exposures.value_unit, meta=exposures.meta, - tag=exposures.tag + description=exposures.description, ) @@ -1217,5 +1234,3 @@ def _read_mat_metadata(exposures, data, file_name, var_names): file_name, data[var_names['var_name']['uni']][0][0]) except KeyError: exposures.value_unit = DEF_VALUE_UNIT - - exposures.tag = Tag(file_name) diff --git a/climada/entity/exposures/litpop/litpop.py b/climada/entity/exposures/litpop/litpop.py index 8fe0509f2..c60de6da8 100644 --- a/climada/entity/exposures/litpop/litpop.py +++ b/climada/entity/exposures/litpop/litpop.py @@ -29,7 +29,6 @@ import climada.util.coordinates as u_coord import climada.util.finance as u_fin -from climada.util.tag import Tag from climada.entity.exposures.litpop import nightlight as nl_util from climada.entity.exposures.litpop import gpw_population as pop_util from climada.entity.exposures.base import Exposures, INDICATOR_IMPF, DEF_REF_YEAR @@ -81,7 +80,7 @@ def from_countries(cls, countries, res_arcsec=30, exponents=(1,1), data_dir=SYSTEM_DIR): """Init new LitPop exposure object for a list of countries (admin 0). - Sets attributes `ref_year`, `tag`, `crs`, `value`, `geometry`, `meta`, + Sets attributes `ref_year`, `crs`, `value`, `geometry`, `meta`, `value_unit`, `exponents`,`fin_mode`, `gpw_version`, and `admin1_calc`. Parameters @@ -183,19 +182,19 @@ def from_countries(cls, countries, res_arcsec=30, exponents=(1,1), LOGGER.warning('Some countries could not be identified and are ignored: ' '%s. Litpop only initiated for: %s', countries_out, countries_in) - tag = Tag(description=f'LitPop Exposure for {countries_in} at {res_arcsec} as, ' - f'year: {reference_year}, financial mode: {fin_mode}, ' - f'exp: {exponents}, admin1_calc: {admin1_calc}') + description = (f'LitPop Exposure for {countries_in} at {res_arcsec} as,' + f' year: {reference_year}, financial mode: {fin_mode},' + f' exp: {exponents}, admin1_calc: {admin1_calc}') exp = cls( data=Exposures.concat(litpop_list).gdf, crs=litpop_list[0].crs, ref_year=reference_year, - tag=tag, value_unit=get_value_unit(fin_mode), - exponents = exponents, - gpw_version = gpw_version, - fin_mode = fin_mode, + exponents=exponents, + gpw_version=gpw_version, + fin_mode=fin_mode, + description=description ) try: @@ -429,9 +428,9 @@ def from_shape_and_countries(cls, shape, countries, res_arcsec=30, exponents=(1, else: raise NotImplementedError('Not implemented for `shape` of type {type(shape)}') - exp.tag.append(Tag(description=f'LitPop Exposure for custom shape in {countries} at ' - f'{res_arcsec} as, year: {reference_year}, financial mode: ' - f'{fin_mode}, exp: {exponents}, admin1_calc: {admin1_calc}')) + exp.description = (f'LitPop Exposure for custom shape in {countries} at' + f' {res_arcsec} as, year: {reference_year}, financial mode:' + f' {fin_mode}, exp: {exponents}, admin1_calc: {admin1_calc}') exp.set_gdf(gdf.reset_index()) try: @@ -473,7 +472,7 @@ def from_shape( """init LitPop exposure object for a custom shape. Requires user input regarding the total value to be disaggregated. - Sets attributes `ref_year`, `tag`, `crs`, `value`, `geometry`, `meta`, + Sets attributes `ref_year`, `crs`, `value`, `geometry`, `meta`, `value_unit`, `exponents`,`fin_mode`, `gpw_version`, and `admin1_calc`. This method can be used to initiated LitPop Exposure for sub-national @@ -542,21 +541,21 @@ def from_shape( elif total_value is not None: raise TypeError("total_value must be int, float or None.") - tag = Tag(description = f'LitPop Exposure for custom shape at {res_arcsec} as, ' \ - f'year: {reference_year}, exp: {exponents}') + description = (f'LitPop Exposure for custom shape at {res_arcsec} as,' + f' year: {reference_year}, exp: {exponents}') litpop_gdf[INDICATOR_IMPF] = 1 exp = cls( - data=litpop_gdf, - crs=litpop_gdf.crs, - ref_year=reference_year, - tag=tag, - value_unit=value_unit, - exponents = exponents, - gpw_version = gpw_version, - fin_mode = None, - ) + data=litpop_gdf, + crs=litpop_gdf.crs, + ref_year=reference_year, + value_unit=value_unit, + exponents=exponents, + gpw_version=gpw_version, + fin_mode=None, + description=description + ) if min(len(exp.gdf.latitude.unique()), len(exp.gdf.longitude.unique())) > 1: #if exp.gdf.shape[0] > 1 and len(exp.gdf.latitude.unique()) > 1: diff --git a/climada/entity/exposures/test/test_base.py b/climada/entity/exposures/test/test_base.py index 7c0ddf346..79f0f5110 100644 --- a/climada/entity/exposures/test/test_base.py +++ b/climada/entity/exposures/test/test_base.py @@ -31,7 +31,6 @@ from climada.entity.exposures.base import Exposures, INDICATOR_IMPF, \ INDICATOR_CENTR, add_sea, DEF_REF_YEAR, DEF_VALUE_UNIT from climada.entity import LitPop -from climada.util.tag import Tag from climada.hazard.base import Hazard, Centroids from climada.util.constants import ENT_TEMPLATE_XLS, ONE_LAT_KM, DEF_CRS, HAZ_DEMO_FL import climada.util.coordinates as u_coord @@ -294,7 +293,6 @@ def test_read_template_pass(self): exp_df = Exposures(df) # set metadata exp_df.ref_year = 2020 - exp_df.tag = Tag(ENT_TEMPLATE_XLS, 'ENT_TEMPLATE_XLS') exp_df.value_unit = 'XSD' exp_df.check() @@ -305,7 +303,6 @@ def test_io_hdf5_pass(self): exp_df.check() # set metadata exp_df.ref_year = 2020 - exp_df.tag = Tag(ENT_TEMPLATE_XLS, 'ENT_TEMPLATE_XLS') exp_df.value_unit = 'XSD' file_name = DATA_DIR.joinpath('test_hdf5_exp.h5') @@ -324,8 +321,7 @@ def test_io_hdf5_pass(self): self.assertDictEqual(exp_df.meta, exp_read.meta) self.assertTrue(u_coord.equal_crs(exp_df.crs, exp_read.crs)) self.assertTrue(u_coord.equal_crs(exp_df.gdf.crs, exp_read.gdf.crs)) - self.assertEqual(exp_df.tag.file_name, exp_read.tag.file_name) - self.assertEqual(exp_df.tag.description, exp_read.tag.description) + self.assertEqual(exp_df.description, exp_read.description) np.testing.assert_array_equal(exp_df.gdf.latitude.values, exp_read.gdf.latitude.values) np.testing.assert_array_equal(exp_df.gdf.longitude.values, exp_read.gdf.longitude.values) np.testing.assert_array_equal(exp_df.gdf.value.values, exp_read.gdf.value.values) @@ -433,8 +429,7 @@ def test_copy_pass(self): self.assertTrue(u_coord.equal_crs(exp_copy.crs, exp.crs)) self.assertEqual(exp_copy.ref_year, exp.ref_year) self.assertEqual(exp_copy.value_unit, exp.value_unit) - self.assertEqual(exp_copy.tag.description, exp.tag.description) - self.assertEqual(exp_copy.tag.file_name, exp.tag.file_name) + self.assertEqual(exp_copy.description, exp.description) np.testing.assert_array_equal(exp_copy.gdf.latitude.values, exp.gdf.latitude.values) np.testing.assert_array_equal(exp_copy.gdf.longitude.values, exp.gdf.longitude.values) @@ -448,8 +443,7 @@ def test_to_crs_inplace_pass(self): self.assertTrue(u_coord.equal_crs(exp.crs, 'epsg:3395')) self.assertEqual(exp.ref_year, DEF_REF_YEAR) self.assertEqual(exp.value_unit, DEF_VALUE_UNIT) - self.assertEqual(exp.tag.description, []) - self.assertEqual(exp.tag.file_name, []) + self.assertEqual(exp.description, None) def test_to_crs_pass(self): """Test to_crs function copy.""" @@ -462,8 +456,7 @@ def test_to_crs_pass(self): self.assertTrue(u_coord.equal_crs(exp_tr.crs, 'epsg:3395')) self.assertEqual(exp_tr.ref_year, DEF_REF_YEAR) self.assertEqual(exp_tr.value_unit, DEF_VALUE_UNIT) - self.assertEqual(exp_tr.tag.description, []) - self.assertEqual(exp_tr.tag.file_name, []) + self.assertEqual(exp_tr.description, None) def test_constructor_pass(self): """Test initialization with input GeoDataFrame""" diff --git a/climada/entity/exposures/test/test_mat.py b/climada/entity/exposures/test/test_mat.py index 20ca26cdd..a4b30bab3 100644 --- a/climada/entity/exposures/test/test_mat.py +++ b/climada/entity/exposures/test/test_mat.py @@ -78,7 +78,6 @@ def test_read_demo_pass(self): self.assertEqual(expo.ref_year, 2016) self.assertEqual(expo.value_unit, 'USD') - self.assertEqual(expo.tag.file_name, [str(ENT_TEST_MAT)]) class TestObligatories(unittest.TestCase): """Test reading exposures obligatory values.""" diff --git a/climada/entity/measures/test/test_base.py b/climada/entity/measures/test/test_base.py index 048dc39f1..a232a0734 100644 --- a/climada/entity/measures/test/test_base.py +++ b/climada/entity/measures/test/test_base.py @@ -165,8 +165,7 @@ def test_change_exposures_impf_pass(self): self.assertEqual(new_exp.ref_year, exp.ref_year) self.assertEqual(new_exp.value_unit, exp.value_unit) - self.assertEqual(new_exp.tag.file_name, exp.tag.file_name) - self.assertEqual(new_exp.tag.description, exp.tag.description) + self.assertEqual(new_exp.description, exp.description) self.assertTrue(np.array_equal(new_exp.gdf.value.values, exp.gdf.value.values)) self.assertTrue(np.array_equal(new_exp.gdf.latitude.values, exp.gdf.latitude.values)) self.assertTrue(np.array_equal(new_exp.gdf.longitude.values, exp.gdf.longitude.values)) @@ -203,8 +202,7 @@ def test_change_all_exposures_pass(self): self.assertEqual(new_exp.ref_year, ref_exp.ref_year) self.assertEqual(new_exp.value_unit, ref_exp.value_unit) - self.assertEqual(new_exp.tag.file_name, ref_exp.tag.file_name) - self.assertEqual(new_exp.tag.description, ref_exp.tag.description) + self.assertEqual(new_exp.description, ref_exp.description) self.assertTrue(np.array_equal(new_exp.gdf.value.values, ref_exp.gdf.value.values)) self.assertTrue(np.array_equal(new_exp.gdf.latitude.values, ref_exp.gdf.latitude.values)) self.assertTrue(np.array_equal(new_exp.gdf.longitude.values, ref_exp.gdf.longitude.values)) @@ -270,8 +268,7 @@ def test_filter_exposures_pass(self): # unchanged meta data self.assertEqual(res_exp.ref_year, exp.ref_year) self.assertEqual(res_exp.value_unit, exp.value_unit) - self.assertEqual(res_exp.tag.file_name, exp.tag.file_name) - self.assertEqual(res_exp.tag.description, exp.tag.description) + self.assertEqual(res_exp.description, exp.description) self.assertTrue(u_coord.equal_crs(res_exp.crs, exp.crs)) self.assertFalse(hasattr(exp.gdf, "crs")) self.assertFalse(hasattr(res_exp.gdf, "crs")) diff --git a/climada/entity/test/test_entity.py b/climada/entity/test/test_entity.py index c1f4e01fb..54ab7aa72 100644 --- a/climada/entity/test/test_entity.py +++ b/climada/entity/test/test_entity.py @@ -58,15 +58,10 @@ def test_default_pass(self): def test_from_mat(self): """Read entity from mat file produced by climada.""" entity_mat = Entity.from_mat(ENT_TEST_MAT) - self.assertEqual(entity_mat.exposures.tag.file_name, [str(ENT_TEST_MAT)]) + self.assertIsInstance(entity_mat.exposures, Exposures) self.assertIsInstance(entity_mat.disc_rates, DiscRates) self.assertIsInstance(entity_mat.measures, MeasureSet) - self.assertTrue(isinstance(entity_mat.impact_funcs, ImpactFuncSet)) - - def test_from_excel(self): - """Read entity from an xls file following the template.""" - entity_xls = Entity.from_excel(ENT_TEMPLATE_XLS) - self.assertEqual(entity_xls.exposures.tag.file_name, [str(ENT_TEMPLATE_XLS)]) + self.assertIsInstance(entity_mat.impact_funcs, ImpactFuncSet) class TestCheck(unittest.TestCase): @@ -110,24 +105,6 @@ def test_wrongDisc_fail(self): self.assertIn('DiscRates', str(cm.exception)) -class TestStringRepr(unittest.TestCase): - """Test the representation dunder methods of Entity""" - def setUp(self): - self.entity = Entity() - self.entity.exposures.tag.description = ["foo", "bar"] - - def test_str(self): - """Test Entity.__str__""" - out = str(self.entity) - self.assertIn("Exposures", out) - self.assertIn("Description: foo + bar", out) - - def test_repr(self): - """Test Entity.__repr__""" - out = repr(self.entity) - self.assertIn("Exposures", out) - self.assertIn("Description: foo + bar", out) - # Execute Tests if __name__ == "__main__": TESTS = unittest.TestLoader().loadTestsFromTestCase(TestReader) diff --git a/climada/test/test_api_client.py b/climada/test/test_api_client.py index 2d9f5352d..9e8b11141 100644 --- a/climada/test/test_api_client.py +++ b/climada/test/test_api_client.py @@ -149,10 +149,8 @@ def test_get_exposures(self): dump_dir=DATA_DIR) self.assertEqual(len(exposures.gdf), 5782) self.assertEqual(np.unique(exposures.gdf.region_id), 40) - self.assertEqual(exposures.tag.description, - ["LitPop Exposure for ['AUT'] at 150 as, year: 2018, financial mode: pop, exp: [0, 1], admin1_calc: False"]) - self.assertEqual(exposures.tag.file_name, - []) + self.assertEqual(exposures.description, + "LitPop Exposure for ['AUT'] at 150 as, year: 2018, financial mode: pop, exp: [0, 1], admin1_calc: False") def test_get_exposures_fails(self): client = Client() @@ -205,10 +203,8 @@ def test_get_litpop(self): litpop = client.get_litpop(country='LUX', version='v1', dump_dir=DATA_DIR) self.assertEqual(len(litpop.gdf), 188) self.assertEqual(np.unique(litpop.gdf.region_id), 442) - self.assertEqual(litpop.tag.description, - ["LitPop Exposure for ['LUX'] at 150 as, year: 2018, financial mode: pc, exp: [1, 1], admin1_calc: False"]) - self.assertEqual(litpop.tag.file_name, - []) + self.assertEqual(litpop.description, + "LitPop Exposure for ['LUX'] at 150 as, year: 2018, financial mode: pc, exp: [1, 1], admin1_calc: False") def test_get_litpop_fail(self): client = Client() diff --git a/climada/test/test_litpop_integr.py b/climada/test/test_litpop_integr.py index f8fb2d989..23f459ee4 100644 --- a/climada/test/test_litpop_integr.py +++ b/climada/test/test_litpop_integr.py @@ -70,9 +70,9 @@ def test_switzerland300_pass(self): # confirm that the total value is equal to GDP * (income_group+1): self.assertAlmostEqual(ent.gdf.value.sum()/gdp('CHE', 2016)[1], (income_group('CHE', 2016)[1] + 1)) - self.assertIn("LitPop Exposure for ['CHE'] at 300 as, year: 2016", ent.tag.description[0]) - self.assertIn('income_group', ent.tag.description[0]) - self.assertIn('1, 1', ent.tag.description[0]) + self.assertIn("LitPop Exposure for ['CHE'] at 300 as, year: 2016", ent.description) + self.assertIn('income_group', ent.description) + self.assertIn('1, 1', ent.description) self.assertTrue(u_coord.equal_crs(ent.crs, 'epsg:4326')) self.assertEqual(ent.meta['width'], 54) self.assertEqual(ent.meta['height'], 23) diff --git a/climada/test/test_plot.py b/climada/test/test_plot.py index f03eebf1f..ea58c8ce7 100644 --- a/climada/test/test_plot.py +++ b/climada/test/test_plot.py @@ -34,7 +34,6 @@ from climada.hazard import Hazard, Centroids from climada.util.constants import HAZ_DEMO_MAT, ENT_DEMO_TODAY, TEST_UNC_OUTPUT_COSTBEN from climada.util.api_client import Client -from climada.util.tag import Tag apiclient = Client() ds = apiclient.get_dataset_info(name=TEST_UNC_OUTPUT_COSTBEN, status='test_dataset') @@ -115,13 +114,13 @@ def test_exposures_value_pass(self): myexp = pd.read_excel(ENT_DEMO_TODAY) myexp = Exposures(myexp) myexp.check() - myexp.tag = Tag(description='demo_today') + myexp.description = 'demo_today' myax = myexp.plot_hexbin() - self.assertIn('demo_today', myax.get_title()) + self.assertEqual('demo_today', myax.get_title()) - myexp.tag = Tag() + myexp.description = None myax = myexp.plot_hexbin() - self.assertNotIn('demo_today', myax.get_title()) + self.assertEqual('', myax.get_title()) myexp.plot_scatter() myexp.plot_basemap() diff --git a/doc/tutorial/1_main_climada.ipynb b/doc/tutorial/1_main_climada.ipynb index 8e6ca9d6a..c8a8b269d 100644 --- a/doc/tutorial/1_main_climada.ipynb +++ b/doc/tutorial/1_main_climada.ipynb @@ -165,7 +165,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2022-03-09T16:14:07.505695Z", @@ -256,7 +256,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -291,7 +291,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -329,7 +329,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -369,7 +369,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "metadata": { "ExecuteTime": { "end_time": "2022-03-09T16:16:32.680624Z", @@ -403,7 +403,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -432,7 +432,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -507,7 +507,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -603,7 +603,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -637,7 +637,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -653,7 +653,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -704,7 +704,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -746,7 +746,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -755,7 +755,7 @@ "Text(0.5, 1.0, 'TC: Modified impact function')" ] }, - "execution_count": 11, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" }, @@ -801,7 +801,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -846,7 +846,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -910,7 +910,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -954,23 +954,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 18, "metadata": {}, "outputs": [ - { - "ename": "NameError", - "evalue": "name 'Optional' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/var/folders/r5/6rbkr9r16mg86237m11wqn500000gn/T/ipykernel_65266/1555313014.py\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mclimada\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mentity\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mEntity\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/Documents/Climada/climada_python/climada/entity/__init__.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 24\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;34m.\u001b[0m\u001b[0mdisc_rates\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 25\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;34m.\u001b[0m\u001b[0mmeasures\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 26\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0;34m.\u001b[0m\u001b[0mentity_def\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/Documents/Climada/climada_python/climada/entity/entity_def.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 33\u001b[0m \u001b[0mLOGGER\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlogging\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetLogger\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 34\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 35\u001b[0;31m \u001b[0;32mclass\u001b[0m \u001b[0mEntity\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 36\u001b[0m \"\"\"Collects exposures, impact functions, measures and discount rates.\n\u001b[1;32m 37\u001b[0m \u001b[0mDefault\u001b[0m \u001b[0mvalues\u001b[0m \u001b[0mset\u001b[0m \u001b[0mwhen\u001b[0m \u001b[0mempty\u001b[0m \u001b[0mconstructor\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Climada/climada_python/climada/entity/entity_def.py\u001b[0m in \u001b[0;36mEntity\u001b[0;34m()\u001b[0m\n\u001b[1;32m 53\u001b[0m def __init__(\n\u001b[1;32m 54\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m \u001b[0mexposures\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mExposures\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 56\u001b[0m \u001b[0mdisc_rates\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mDiscRates\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 57\u001b[0m \u001b[0mimpact_func_set\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mImpactFuncSet\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mNameError\u001b[0m: name 'Optional' is not defined" - ] - } ], "source": [ "from climada.entity import Entity\n", @@ -1015,7 +1001,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -1044,7 +1030,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -1083,7 +1069,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -1125,7 +1111,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -1165,7 +1151,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 23, "metadata": {}, "outputs": [ { diff --git a/doc/tutorial/climada_entity_DiscRates.ipynb b/doc/tutorial/climada_entity_DiscRates.ipynb index 3337fca5d..c88cdc18f 100644 --- a/doc/tutorial/climada_entity_DiscRates.ipynb +++ b/doc/tutorial/climada_entity_DiscRates.ipynb @@ -15,7 +15,6 @@ "\n", "This class contains the discount rates for every year and discounts given values. Its attributes are:\n", "\n", - " * tag (Tag): information about the source data\n", " * years (np.array): years\n", " * rates (np.array): discount rates for each year (between 0 and 1)\n", "\n", @@ -137,8 +136,8 @@ "\n", "# Fill DataFrame from Excel file\n", "file_name = ENT_TEMPLATE_XLS # provide absolute path of the excel file\n", + "print('Read file:', ENT_TEMPLATE_XLS)\n", "disc = DiscRates.from_excel(file_name)\n", - "print('Read file:', disc.tag.file_name)\n", "disc.plot();" ] }, @@ -214,7 +213,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13 | packaged by conda-forge | (default, Mar 25 2022, 06:05:47) \n[Clang 12.0.1 ]" + "version": "3.9.16" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/doc/tutorial/climada_entity_Exposures.ipynb b/doc/tutorial/climada_entity_Exposures.ipynb index b4cb3adb0..c2c3990dc 100644 --- a/doc/tutorial/climada_entity_Exposures.ipynb +++ b/doc/tutorial/climada_entity_Exposures.ipynb @@ -78,7 +78,7 @@ "| Metadata variables | Data Type | Description |\n", "| :-------------------- | :------------ | :------------------------------------------------------------------------------------- |\n", "| `crs` | str or int | coordinate reference system, see GeoDataFrame.crs |\n", - "| `tag` | Tag | information about the source data |\n", + "| `description` | str | describing origin and content of the exposures data |\n", "| `ref_year` | int | reference year |\n", "| `value_unit` | str | unit of the exposures' values |\n", "| `meta` | dict | dictionary containing corresponding raster properties (if any):
width, height, crs and transform must be present at least (transform needs to contain upper left corner!).
Exposures might not contain all the points of the corresponding raster. |\n" @@ -212,8 +212,6 @@ "text": [ "\n", "\u001b[1;03;30;30mexp looks like:\u001b[0m\n", - "tag: File: \n", - " Description: \n", "ref_year: 2018\n", "value_unit: USD\n", "meta: {'crs': 'EPSG:4326'}\n", @@ -347,8 +345,6 @@ "text": [ "\n", "\u001b[1;03;30;30mexp_gpd looks like:\u001b[0m\n", - "tag: File: \n", - " Description: \n", "ref_year: 2018\n", "value_unit: USD\n", "meta: {'crs': \n", @@ -1656,7 +1652,7 @@ "\n", "## Write (Save) Exposures\n", "\n", - "Exposures can be saved in any format available for `GeoDataFrame` (see fiona.supported_drivers) and `DataFrame` ([pandas IO tools](https://pandas.pydata.org/pandas-docs/stable/io.html)). Take into account that in many of these formats the metadata (e.g. variables `ref_year`, `value_unit` and `tag`) will not be saved. Use instead the format hdf5 provided by `Exposures` methods `write_hdf5()` and `from_hdf5()` to handle all the data." + "Exposures can be saved in any format available for `GeoDataFrame` (see fiona.supported_drivers) and `DataFrame` ([pandas IO tools](https://pandas.pydata.org/pandas-docs/stable/io.html)). Take into account that in many of these formats the metadata (e.g. variables `ref_year` and `value_unit`) will not be saved. Use instead the format hdf5 provided by `Exposures` methods `write_hdf5()` and `from_hdf5()` to handle all the data." ] }, { diff --git a/doc/tutorial/climada_entity_LitPop.ipynb b/doc/tutorial/climada_entity_LitPop.ipynb index d3872275c..f41885ced 100644 --- a/doc/tutorial/climada_entity_LitPop.ipynb +++ b/doc/tutorial/climada_entity_LitPop.ipynb @@ -458,17 +458,6 @@ "Florida index: 20\n" ] }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n" - ] - }, { "name": "stdout", "output_type": "stream", @@ -536,17 +525,6 @@ "execution_count": 7, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n" - ] - }, { "name": "stdout", "output_type": "stream", @@ -603,17 +581,6 @@ "execution_count": 8, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n" - ] - }, { "name": "stdout", "output_type": "stream", @@ -627,17 +594,6 @@ "\n" ] }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n" - ] - }, { "name": "stdout", "output_type": "stream", @@ -760,154 +716,12 @@ "2021-10-19 17:04:31,363 - climada.entity.exposures.litpop.gpw_population - WARNING - Reference year: 2018. Using nearest available year for GPW data: 2020\n" ] }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n", - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n", - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n", - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n", - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n", - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n", - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n", - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n", - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n", - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n", - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n", - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n", - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n", - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n", - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n", - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n", - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n", - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n", - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n", - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n", - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n", - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n", - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n", - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n", - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n", - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n", - "$CONDA_PREFIX/lib/python3.8/site-packages/pyproj/crs/crs.py:68: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ "Done.\n" ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "$CLIMADA_SRC/climada/util/coordinates.py:1129: UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " countries['area'] = countries.geometry.area\n" - ] } ], "source": [ From 0a1f70581da986a76d7541b6596e25f1d26750b4 Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Thu, 31 Aug 2023 09:05:32 +0200 Subject: [PATCH 14/44] litpop test: break local environment interference --- .../entity/exposures/test/test_nightlight.py | 29 ++++++++++--------- 1 file changed, 15 insertions(+), 14 deletions(-) diff --git a/climada/entity/exposures/test/test_nightlight.py b/climada/entity/exposures/test/test_nightlight.py index beaca1a84..f7158ac77 100644 --- a/climada/entity/exposures/test/test_nightlight.py +++ b/climada/entity/exposures/test/test_nightlight.py @@ -84,12 +84,12 @@ def test_get_required_nl_files(self): """ get_required_nl_files return a boolean matrix of 0 and 1 indicating which tile of NASA nighlight files are needed giving a bounding box. This test check a few configuration of tiles - and check that a value error is raised if the bounding box are + and check that a value error is raised if the bounding box are incorrect """ # incorrect bounds: bounds size =! 4, min lon > max lon, min lat > min lat - BOUNDS = [(20, 30, 40), - (120, -20, 110, 30), + BOUNDS = [(20, 30, 40), + (120, -20, 110, 30), (-120, 50, 130, 10)] # correct bounds bounds_c1 = (-120, -20, 0, 40) @@ -98,13 +98,13 @@ def test_get_required_nl_files(self): for bounds in BOUNDS: with self.assertRaises(ValueError) as cm: - + nightlight.get_required_nl_files(bounds = bounds) self.assertEqual('Invalid bounds supplied. `bounds` must be tuple' ' with (min_lon, min_lat, max_lon, max_lat).', str(cm.exception)) - + # test first correct bounds configurations req_files = nightlight.get_required_nl_files(bounds = bounds_c1) bool = np.array_equal(np.array([1, 1, 1, 1, 1, 1, 0, 0]), req_files) @@ -117,7 +117,7 @@ def test_get_required_nl_files(self): req_files = nightlight.get_required_nl_files(bounds = bounds_c3) bool = np.array_equal(np.array([0, 0, 0, 0, 0, 0, 1, 0]), req_files) self.assertTrue(bool) - + def test_check_nl_local_file_exists(self): """ Test that an array with the correct number of already existing files is produced, the LOGGER messages logged and the ValueError raised. """ @@ -127,13 +127,13 @@ def test_check_nl_local_file_exists(self): nightlight.check_nl_local_file_exists(required_files = np.array([0, 0, 1, 1])) self.assertIn('The parameter \'required_files\' was too short and is ignored', cm.output[0]) - - # check logger message: not all files are available + + # check logger message: not all files are available with self.assertLogs('climada.entity.exposures.litpop.nightlight', level='DEBUG') as cm: nightlight.check_nl_local_file_exists() - self.assertIn('Not all satellite files available. ' - f'Found 5 out of 8 required files in {Path(SYSTEM_DIR)}', cm.output[0]) - + self.assertIn('Not all satellite files available. Found ', cm.output[0]) + self.assertIn(f' out of 8 required files in {Path(SYSTEM_DIR)}', cm.output[0]) + # check logger message: no files found in checkpath check_path = Path('climada/entity/exposures') with self.assertLogs('climada.entity.exposures.litpop.nightlight', level='INFO') as cm: @@ -141,7 +141,7 @@ def test_check_nl_local_file_exists(self): nightlight.check_nl_local_file_exists(check_path=check_path) self.assertIn(f'No satellite files found locally in {check_path}', cm.output[0]) - + # test raises with wrong path check_path = Path('/random/wrong/path') with self.assertRaises(ValueError) as cm: @@ -149,9 +149,10 @@ def test_check_nl_local_file_exists(self): self.assertEqual(f'The given path does not exist: {check_path}', str(cm.exception)) - # test that files_exist is correct + # test that files_exist is correct files_exist = nightlight.check_nl_local_file_exists() - self.assertEqual(int(sum(files_exist)), 5) + self.assertGreaterEqual(int(sum(files_exist)), 3) + self.assertLessEqual(int(sum(files_exist)), 8) # Execute Tests if __name__ == "__main__": From 6db2b8c8439b4f448b355154549e794512045214 Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Thu, 31 Aug 2023 15:48:02 +0200 Subject: [PATCH 15/44] requirments/env_climada: canonical dependency updates --- requirements/env_climada.yml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/requirements/env_climada.yml b/requirements/env_climada.yml index 50c6c3f3f..ec1f11ce4 100644 --- a/requirements/env_climada.yml +++ b/requirements/env_climada.yml @@ -4,7 +4,7 @@ channels: - defaults dependencies: - bottleneck>=1.3 - - cartopy>=0.21 + - cartopy>=0.22 - cfgrib>=0.9.9,<0.9.10 # 0.9.10 cannot read the icon_grib files from https://opendata.dwd.de - contextily>=1.3 - dask>=2023 @@ -31,13 +31,13 @@ dependencies: - rasterio>=1.3 - requests>=2.31 - salib>=1.4 - - scikit-learn>=1.2 - - scipy>=1.10 + - scikit-learn>=1.3 + - scipy>=1.11 - sparse>=0.14 - statsmodels>=0.14 - tabulate>=0.9 - - tqdm>=4.65 + - tqdm>=4.66 - unittest-xml-reporting>=3.2 - - xarray>=2023.5 + - xarray>=2023.8 - xlrd>=2.0 - xlsxwriter>=3.1 From c8678ac4ea926e0a786ef44df9ca90f6fb3a4a52 Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Fri, 1 Sep 2023 10:49:38 +0200 Subject: [PATCH 16/44] CHANGELOG: dependency changes --- CHANGELOG.md | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 027197ccf..997750977 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,13 +13,47 @@ Added: - `pytest` [#726](https://github.com/CLIMADA-project/climada_python/pull/726) - `pytest-cov` [#726](https://github.com/CLIMADA-project/climada_python/pull/726) - `pytest-subtests` [#726](https://github.com/CLIMADA-project/climada_python/pull/726) +- `unittest-xml-reporting` Changed: +- `cartopy` >=0.20.0,<0.20.3 → >=0.21 +- `cfgrib` >=0.9.7,<0.9.10 → =0.9.9 +- `contextily` >=1.0 → >=1.3 +- `dask` >=2.25 → >=2023 +- `eccodes` [auto] → =2.27 +- `gdal` !=3.4.1 → >=3.6 +- `geopandas` >=0.8 → >=0.13 +- `h5py` >=2.10 → >=3.8 +- `haversine` >=2.3 → >=2.8 +- `matplotlib` >=3.2,< 3.6 → >=3.7 +- `netcdf4` >=1.5 → >=1.6 +- `numba` >=0.51,!=0.55.0 → >=0.57 +- `openpyxl` >=3.0 → >=3.1 +- `pandas-datareader` >=0.9 → >=0.10 +- `pathos` >=0.2 → >=0.3 +- `pint` >=0.15 → >=0.22 +- `proj` !=9.0.0 → >=9.1 +- `pycountry` >=20.7 → >=22.3 +- `pytables` >=3.6 → >=3.7 +- `rasterio` >=1.2.7,<1.3 → >=1.3 +- `requests` >=2.24 → >=2.31 +- `salib` >=1.3.0 → >=1.4 +- `scikit-learn` >=1.0 → >=1.2 +- `scipy` >=1.6 → >=1.10 +- `sparse` >=0.13 → >=0.14 +- `statsmodels` >=0.11 → >=0.14 +- `tabulate` >=0.8 → >=0.9 +- `tqdm` >=4.48 → >=4.65 +- `xarray` >=0.13 → >=2023.5 +- `xlrd` >=1.2 → >=2.0 +- `xlsxwriter` >=1.3 → >=3.1 + Removed: - `nbsphinx` [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - `pandoc` [#712](https://github.com/CLIMADA-project/climada_python/pull/712) +- `xmlrunner` ### Added From 00e1e7e0405cce48646f7d61057ba773fa3da285 Mon Sep 17 00:00:00 2001 From: Emanuel Schmid <51439563+emanuel-schmid@users.noreply.github.com> Date: Fri, 1 Sep 2023 12:25:16 +0200 Subject: [PATCH 17/44] Tag Removal Modules Structure Rearranged (#779) * completely remove hazard.tag class * isolate deprecated entity.tag class * entity.tag: update pydoc * changelog: consolidate with regard to tag removal --- CHANGELOG.md | 20 ++- climada/entity/{tag.py => tag/__init__.py} | 3 +- climada/{util => entity/tag}/tag.py | 7 +- climada/{util => entity/tag}/test/test_tag.py | 2 +- climada/hazard/tag.py | 120 ------------------ climada/hazard/test/test_tag.py | 113 ----------------- 6 files changed, 18 insertions(+), 247 deletions(-) rename climada/entity/{tag.py => tag/__init__.py} (94%) rename climada/{util => entity/tag}/tag.py (95%) rename climada/{util => entity/tag}/test/test_tag.py (98%) delete mode 100644 climada/hazard/tag.py delete mode 100644 climada/hazard/test/test_tag.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 997750977..ade22ac4b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -64,7 +64,8 @@ Removed: - Added method `Exposures.centroids_total_value` to replace the functionality of `Exposures.affected_total_value`. This method is temporary and deprecated. [#702](https://github.com/CLIMADA-project/climada_python/pull/702) - New method `climada.util.api_client.Client.purge_cache`: utility function to remove outdated files from the local file system to free disk space. ([#737](https://github.com/CLIMADA-project/climada_python/pull/737)) -- New attribute `climada.entity.exposures.Exposures.description`: used for setting the default title in plots from plotting mathods `plot_hexbin` and `plot_scatter`. [#756](https://github.com/CLIMADA-project/climada_python/pull/756) +- New attribute `climada.hazard.Hazard.haz_type`: used for assigning impacts to hazards. In previous versions this information was stored in the now removed `climada.hazard.tag.Tag` class. [#736](https://github.com/CLIMADA-project/climada_python/pull/736) +- New attribute `climada.entity.exposures.Exposures.description`: used for setting the default title in plots from plotting mathods `plot_hexbin` and `plot_scatter`. In previous versions this information was stored in the deprecated `climada.entity.tag.Tag` class. [#756](https://github.com/CLIMADA-project/climada_python/pull/756) - Added advanced examples in unsequa tutorial for coupled input variables and for handling efficiently the loading of multiple large files [#766](https://github.com/CLIMADA-project/climada_python/pull/766) ### Changed @@ -86,7 +87,6 @@ Removed: - Use `pytest` for executing tests [#726](https://github.com/CLIMADA-project/climada_python/pull/726) - Users can opt-out of the climada specific logging definitions and freely configure logging to their will, by setting the config value `logging.managed` to `false`. [#724](https://github.com/CLIMADA-project/climada_python/pull/724) - Add option to read additional variables from IBTrACS when using `TCTracks.from_ibtracs_netcdf` [#728](https://github.com/CLIMADA-project/climada_python/pull/728) -- The `haz_type` attribute has been moved from `climada.hazard.tag.Tag` to `climada.hazard.Hazard` itself. [#736](https://github.com/CLIMADA-project/climada_python/pull/736) - New file format for `TCTracks` I/O with better performance. This change is not backwards compatible: If you stored `TCTracks` objects with `TCTracks.write_hdf5`, reload the original data and store them again. [#735](https://github.com/CLIMADA-project/climada_python/pull/735) - Add option to load only a subset when reading TC tracks using `TCTracks.from_simulations_emanuel`. [#741](https://github.com/CLIMADA-project/climada_python/pull/741) - Set `save_mat` to `False` in the `unsequa` module [#746](https://github.com/CLIMADA-project/climada_python/pull/746) @@ -112,16 +112,22 @@ Removed: - `Centroids.from_geodataframe` and `Centroids.from_pix_bounds` [#721](https://github.com/CLIMADA-project/climada_python/pull/721) - `Impact.tot_value`: Use `Exposures.affected_total_value` to compute the total value affected by a hazard intensity above a custom threshold [#702](https://github.com/CLIMADA-project/climada_python/pull/702) -- `climada.hazard.tag.Tag` and `climada.entity.tag.Tag`. [#736](https://github.com/CLIMADA-project/climada_python/pull/736). They were unified into `climada.util.tag.Tag`. Note: the latter is to be deprecated and removed in a future version as well. +- `climada.entity.tag.Tag`. [#779](https://github.com/CLIMADA-project/climada_python/pull/779). The class is not used anymore but had to be kept for reading Exposures HDF5 files that were created with previous versions of CLIMADA. ### Removed - `Centroids.set_raster_from_pix_bounds` [#721](https://github.com/CLIMADA-project/climada_python/pull/721) - `requirements/env_developer.yml` environment specs. Use 'extra' requirements when installing the Python package instead [#712](https://github.com/CLIMADA-project/climada_python/pull/712) -- `Impact.tag` attribute. This change is not backwards-compatible with respect to the files written and read by the `Impact` class [#743](https://github.com/CLIMADA-project/climada_python/pull/743) -- `Exposures.tag` attribute. This change is not backwards-compatible with respect to the files written and read by the `Exposures` class [#756](https://github.com/CLIMADA-project/climada_python/pull/756) -- `Hazard.tag` attribute. This change is not backwards-compatible with respect to the files written and read by the `Hazard` class [#767](https://github.com/CLIMADA-project/climada_python/pull/767) -- `impact.tot_value ` attribute removed from unsequa module [#763](https://github.com/CLIMADA-project/climada_python/pull/763) +- The `climada.entitity.tag.Tag` class, together with `Impact.tag`, `Exposures.tag`, `ImpactFuncSet.tag`, `MeasuresSet.tag`, `Hazard.tag` attributes. + This may break backwards-compatibility with respect to the files written and read by the `Impact` class. + [#736](https://github.com/CLIMADA-project/climada_python/pull/736), + [#743](https://github.com/CLIMADA-project/climada_python/pull/743), + [#753](https://github.com/CLIMADA-project/climada_python/pull/753), + [#754](https://github.com/CLIMADA-project/climada_python/pull/754), + [#756](https://github.com/CLIMADA-project/climada_python/pull/756), + [#767](https://github.com/CLIMADA-project/climada_python/pull/767), + [#779](https://github.com/CLIMADA-project/climada_python/pull/779) +- `impact.tot_value` attribute removed from unsequa module [#763](https://github.com/CLIMADA-project/climada_python/pull/763) ## v3.3.2 diff --git a/climada/entity/tag.py b/climada/entity/tag/__init__.py similarity index 94% rename from climada/entity/tag.py rename to climada/entity/tag/__init__.py index 531064c97..4d386fd09 100644 --- a/climada/entity/tag.py +++ b/climada/entity/tag/__init__.py @@ -21,7 +21,7 @@ from deprecation import deprecated -from climada.util.tag import Tag as _Tag +from .tag import Tag as _Tag # deprecating the whole class instead of just the constructor (s.b.) would be preferable @@ -31,7 +31,6 @@ # @deprecated(details="This class is not supported anymore.") class Tag(_Tag): """kept for backwards compatibility with climada <= 3.3 - use ``climada.util.tag.Tag`` instead """ @deprecated(details="This class is not supported anymore and will be removed in the next" " version of climada.") diff --git a/climada/util/tag.py b/climada/entity/tag/tag.py similarity index 95% rename from climada/util/tag.py rename to climada/entity/tag/tag.py index 1d166c324..4ec1a2bef 100644 --- a/climada/util/tag.py +++ b/climada/entity/tag/tag.py @@ -19,12 +19,10 @@ Define Tag class. """ from __future__ import annotations - from pathlib import Path from typing import Union, List -import h5py -__all__ = ['Tag'] +import h5py STR_DT = h5py.special_dtype(vlen=str) @@ -42,7 +40,8 @@ def _distinct_list_of_str(list_of_str: list, arg: Union[list, str, object]): class Tag(): - """Source data tag for Exposures, DiscRates, ImpactFuncSet, MeasureSet. + """Deprecated since climada 4.*. This class is only used for unpickling, e.g., when reading + Exposures hdf5 data files that have been created with climada <=3.*. Attributes ---------- diff --git a/climada/util/test/test_tag.py b/climada/entity/tag/test/test_tag.py similarity index 98% rename from climada/util/test/test_tag.py rename to climada/entity/tag/test/test_tag.py index 9077285d6..8dc37590d 100644 --- a/climada/util/test/test_tag.py +++ b/climada/entity/tag/test/test_tag.py @@ -21,7 +21,7 @@ import unittest -from climada.util.tag import Tag +from climada.entity.tag import Tag class TestAppend(unittest.TestCase): """Test loading funcions from the Hazard class""" diff --git a/climada/hazard/tag.py b/climada/hazard/tag.py deleted file mode 100644 index 8373d589f..000000000 --- a/climada/hazard/tag.py +++ /dev/null @@ -1,120 +0,0 @@ -""" -This file is part of CLIMADA. - -Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. - -CLIMADA is free software: you can redistribute it and/or modify it under the -terms of the GNU General Public License as published by the Free -Software Foundation, version 3. - -CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY -WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A -PARTICULAR PURPOSE. See the GNU General Public License for more details. - -You should have received a copy of the GNU General Public License along -with CLIMADA. If not, see . - ---- - -Define (deprecated) Tag class. -""" - -__all__ = ['Tag'] - -import logging -from pathlib import Path - -from deprecation import deprecated - -LOGGER = logging.getLogger(__name__) - - -@deprecated(details="This class is not supported anymore and will be removed in the next version of climada.") -class Tag(object): - """Contain information used to tag a Hazard. - - Attributes - ---------- - file_name : str or list(str) - name of the source file(s) - haz_type : str - acronym defining the hazard type (e.g. 'TC') - description : str or list(str) - description(s) of the data - """ - - def __init__(self, - haz_type: str = '', - file_name: str = '', - description: str = ''): - """Initialize values. - - Parameters - ---------- - haz_type : str - acronym of the hazard type (e.g. 'TC'). - file_name : str or list(str), optional - file name(s) to read - description : str or list(str), optional - description of the data - """ - self.haz_type = haz_type - self.file_name = file_name - self.description = description - - def append(self, tag): - """Append input Tag instance information to current Tag.""" - if self.haz_type == '': - self.haz_type = tag.haz_type - if tag.haz_type != self.haz_type: - raise ValueError("Hazards of different type can't be appended: %s != %s." - % (self.haz_type, tag.haz_type)) - - # add file name if not present in tag - if self.file_name == '': - self.file_name = tag.file_name - self.description = tag.description - elif tag.file_name == '': - return - else: - if not isinstance(self.file_name, list): - self.file_name = [self.file_name] - if not isinstance(tag.file_name, list): - to_add = [tag.file_name] - else: - to_add = tag.file_name - self.file_name.extend(to_add) - - if not isinstance(self.description, list): - self.description = [self.description] - if not isinstance(tag.description, list): - to_add = [tag.description] - else: - to_add = tag.description - self.description.extend(to_add) - - def join_file_names(self): - """Get a string with the joined file names.""" - if not isinstance(self.file_name, list): - join_file = Path(self.file_name).stem - else: - join_file = ' + '.join([ - Path(single_name).stem - for single_name in self.file_name - ]) - return join_file - - def join_descriptions(self): - """Get a string with the joined descriptions.""" - if not isinstance(self.file_name, list): - join_desc = self.description - else: - join_desc = ' + '.join([file for file in self.description]) - return join_desc - - def __str__(self): - return ' Type: ' + self.haz_type + '\n File: ' + \ - self.join_file_names() + '\n Description: ' + \ - self.join_descriptions() - - __repr__ = __str__ diff --git a/climada/hazard/test/test_tag.py b/climada/hazard/test/test_tag.py deleted file mode 100644 index fcac66a2e..000000000 --- a/climada/hazard/test/test_tag.py +++ /dev/null @@ -1,113 +0,0 @@ -""" -This file is part of CLIMADA. - -Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. - -CLIMADA is free software: you can redistribute it and/or modify it under the -terms of the GNU General Public License as published by the Free -Software Foundation, version 3. - -CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY -WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A -PARTICULAR PURPOSE. See the GNU General Public License for more details. - -You should have received a copy of the GNU General Public License along -with CLIMADA. If not, see . - ---- - -Test Tag class -""" - -import unittest - -from climada.hazard.tag import Tag as TagHazard - -class TestAppend(unittest.TestCase): - """Test loading funcions from the Hazard class""" - - def test_append_right_pass(self): - """Appends an other tag correctly.""" - tag1 = TagHazard('TC', 'file_name1.mat', 'dummy file 1') - self.assertEqual('file_name1.mat', tag1.file_name) - self.assertEqual('dummy file 1', tag1.description) - self.assertEqual('TC', tag1.haz_type) - - tag2 = TagHazard('TC', 'file_name2.mat', 'dummy file 2') - - tag1.append(tag2) - - self.assertEqual(['file_name1.mat', 'file_name2.mat'], tag1.file_name) - self.assertEqual(['dummy file 1', 'dummy file 2'], tag1.description) - self.assertEqual('TC', tag1.haz_type) - - def test_append_wrong_pass(self): - """Appends an other tag correctly.""" - tag1 = TagHazard('TC', 'file_name1.mat', 'dummy file 1') - tag2 = TagHazard('EQ', 'file_name2.mat', 'dummy file 2') - with self.assertRaises(ValueError) as cm: - tag1.append(tag2) - self.assertIn("Hazards of different type can't be appended: TC != EQ.", str(cm.exception)) - - def test_equal_same(self): - """Appends an other tag correctly.""" - tag1 = TagHazard('TC', 'file_name1.mat', 'dummy file 1') - tag2 = TagHazard('TC', 'file_name1.mat', 'dummy file 1') - tag1.append(tag2) - self.assertEqual(['file_name1.mat', 'file_name1.mat'], tag1.file_name) - self.assertEqual(['dummy file 1', 'dummy file 1'], tag1.description) - self.assertEqual('TC', tag1.haz_type) - - def test_append_empty(self): - """Appends an other tag correctly.""" - tag1 = TagHazard('TC', 'file_name1.mat', 'dummy file 1') - tag2 = TagHazard(haz_type='TC') - - tag1.append(tag2) - self.assertEqual('file_name1.mat', tag1.file_name) - self.assertEqual('dummy file 1', tag1.description) - - tag1 = TagHazard('TC') - tag2 = TagHazard('TC', 'file_name1.mat', 'dummy file 1') - - tag1.append(tag2) - self.assertEqual('file_name1.mat', tag1.file_name) - self.assertEqual('dummy file 1', tag1.description) - -class TestJoin(unittest.TestCase): - """Test joining functions and string formation Tag class.""" - - def test_one_str_pass(self): - """Test __str__ method with one file""" - tag = TagHazard('TC', 'file_name1.mat', 'dummy file 1') - self.assertEqual(str(tag), ' Type: TC\n File: file_name1\n Description: dummy file 1') - - def test_teo_str_pass(self): - """Test __str__ method with one file""" - tag1 = TagHazard('TC', 'file1.mat', 'desc1') - tag2 = TagHazard('TC', 'file2.xls', 'desc2') - tag1.append(tag2) - self.assertEqual(str(tag1), - ' Type: TC\n File: file1 + file2\n Description: desc1 + desc2') - - def test_join_names_pass(self): - """Test join_file_names function.""" - tag1 = TagHazard('TC', 'file1', 'desc1') - tag2 = TagHazard('TC', 'file2', 'desc2') - tag1.append(tag2) - join_name = tag1.join_file_names() - self.assertEqual('file1 + file2', join_name) - - def test_join_descr_pass(self): - """Test join_descriptions function.""" - tag1 = TagHazard('TC', 'file1', 'desc1') - tag2 = TagHazard('TC', 'file2', 'desc2') - tag1.append(tag2) - join_desc = tag1.join_descriptions() - self.assertEqual('desc1 + desc2', join_desc) - -# Execute Tests -if __name__ == "__main__": - TESTS = unittest.TestLoader().loadTestsFromTestCase(TestAppend) - TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestJoin)) - unittest.TextTestRunner(verbosity=2).run(TESTS) From 62c53977e219df3694499efaf05b4ee5b002cd18 Mon Sep 17 00:00:00 2001 From: climada Date: Fri, 1 Sep 2023 10:55:39 +0000 Subject: [PATCH 18/44] 'Automated update v4.3.1' --- CHANGELOG.md | 38 +++++++++++--------------------------- climada/_version.py | 2 +- doc/misc/README.md | 8 +++++++- setup.py | 2 +- 4 files changed, 20 insertions(+), 30 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ade22ac4b..95c129008 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,22 +1,17 @@ # Changelog -## Unreleased +## 4.3.1 -Release date: YYYY-MM-DD - -Code freeze date: YYYY-MM-DD +Release date: 2023-09-01 ### Dependency Updates Added: - - `pytest` [#726](https://github.com/CLIMADA-project/climada_python/pull/726) - `pytest-cov` [#726](https://github.com/CLIMADA-project/climada_python/pull/726) - `pytest-subtests` [#726](https://github.com/CLIMADA-project/climada_python/pull/726) - `unittest-xml-reporting` - Changed: - - `cartopy` >=0.20.0,<0.20.3 → >=0.21 - `cfgrib` >=0.9.7,<0.9.10 → =0.9.9 - `contextily` >=1.0 → >=1.3 @@ -48,9 +43,7 @@ Changed: - `xarray` >=0.13 → >=2023.5 - `xlrd` >=1.2 → >=2.0 - `xlsxwriter` >=1.3 → >=3.1 - Removed: - - `nbsphinx` [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - `pandoc` [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - `xmlrunner` @@ -63,7 +56,7 @@ Removed: - 'Extra' requirements `doc`, `test`, and `dev` for Python package [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - Added method `Exposures.centroids_total_value` to replace the functionality of `Exposures.affected_total_value`. This method is temporary and deprecated. [#702](https://github.com/CLIMADA-project/climada_python/pull/702) - New method `climada.util.api_client.Client.purge_cache`: utility function to remove outdated files from the local file system to free disk space. - ([#737](https://github.com/CLIMADA-project/climada_python/pull/737)) +([#737](https://github.com/CLIMADA-project/climada_python/pull/737)) - New attribute `climada.hazard.Hazard.haz_type`: used for assigning impacts to hazards. In previous versions this information was stored in the now removed `climada.hazard.tag.Tag` class. [#736](https://github.com/CLIMADA-project/climada_python/pull/736) - New attribute `climada.entity.exposures.Exposures.description`: used for setting the default title in plots from plotting mathods `plot_hexbin` and `plot_scatter`. In previous versions this information was stored in the deprecated `climada.entity.tag.Tag` class. [#756](https://github.com/CLIMADA-project/climada_python/pull/756) - Added advanced examples in unsequa tutorial for coupled input variables and for handling efficiently the loading of multiple large files [#766](https://github.com/CLIMADA-project/climada_python/pull/766) @@ -119,14 +112,14 @@ Removed: - `Centroids.set_raster_from_pix_bounds` [#721](https://github.com/CLIMADA-project/climada_python/pull/721) - `requirements/env_developer.yml` environment specs. Use 'extra' requirements when installing the Python package instead [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - The `climada.entitity.tag.Tag` class, together with `Impact.tag`, `Exposures.tag`, `ImpactFuncSet.tag`, `MeasuresSet.tag`, `Hazard.tag` attributes. - This may break backwards-compatibility with respect to the files written and read by the `Impact` class. - [#736](https://github.com/CLIMADA-project/climada_python/pull/736), - [#743](https://github.com/CLIMADA-project/climada_python/pull/743), - [#753](https://github.com/CLIMADA-project/climada_python/pull/753), - [#754](https://github.com/CLIMADA-project/climada_python/pull/754), - [#756](https://github.com/CLIMADA-project/climada_python/pull/756), - [#767](https://github.com/CLIMADA-project/climada_python/pull/767), - [#779](https://github.com/CLIMADA-project/climada_python/pull/779) +This may break backwards-compatibility with respect to the files written and read by the `Impact` class. +[#736](https://github.com/CLIMADA-project/climada_python/pull/736), +[#743](https://github.com/CLIMADA-project/climada_python/pull/743), +[#753](https://github.com/CLIMADA-project/climada_python/pull/753), +[#754](https://github.com/CLIMADA-project/climada_python/pull/754), +[#756](https://github.com/CLIMADA-project/climada_python/pull/756), +[#767](https://github.com/CLIMADA-project/climada_python/pull/767), +[#779](https://github.com/CLIMADA-project/climada_python/pull/779) - `impact.tot_value` attribute removed from unsequa module [#763](https://github.com/CLIMADA-project/climada_python/pull/763) ## v3.3.2 @@ -136,7 +129,6 @@ Release date: 2023-03-02 ### Dependency Updates Removed: - - `pybufrkit` [#662](https://github.com/CLIMADA-project/climada_python/pull/662) ## v3.3.1 @@ -155,18 +147,11 @@ Patch-relaese with altered base config file so that the basic installation test Release date: 2023-02-17 -Code freeze date: 2023-02-05 - -### Description - ### Dependency Changes new: - - sparse (>=0.13) for [#578](https://github.com/CLIMADA-project/climada_python/pull/578) - updated: - - **python 3.9** - python 3.8 will still work, but python 3.9 is now the default version for [installing climada](https://climada-python.readthedocs.io/en/latest/tutorial/climada_installation_step_by_step.html) ([#614](https://github.com/CLIMADA-project/climada_python/pull/614)) - contextily >=1.0 (no longer restricted to <1.2 as `contextily.sources` has been replaced in [#517](https://github.com/CLIMADA-project/climada_python/pull/517)) - cartopy >=0.20.0,<0.20.3 (>=0.20.3 has an issue with geographic crs in plots) @@ -248,4 +233,3 @@ updated: - `climada.enginge.impact.Impact.calc()` and `climada.enginge.impact.Impact.calc_impact_yearset()` [#436](https://github.com/CLIMADA-project/climada_python/pull/436). -### Removed diff --git a/climada/_version.py b/climada/_version.py index 1571c99a7..376d9ccc2 100644 --- a/climada/_version.py +++ b/climada/_version.py @@ -1 +1 @@ -__version__ = '3.3.2-dev' +__version__ = '4.3.1' diff --git a/doc/misc/README.md b/doc/misc/README.md index cc314f610..369cecb58 100644 --- a/doc/misc/README.md +++ b/doc/misc/README.md @@ -15,7 +15,13 @@ This is the Python (3.8+) version of CLIMADA - please see https://github.com/dav ## Getting started -CLIMADA runs on Windows, macOS and Linux. It can be installed from sources or - in case of climada_python - directly with pip. See the [installation guide](https://climada-python.readthedocs.io/en/latest/guide/install.html) for instructions. +CLIMADA runs on Windows, macOS and Linux. +The released versions of the CLIMADA core can be installed directly through Anaconda: +```shell +conda install -c conda-forge climada +``` +It is **highly recommended** to install CLIMADA into a **separate** Anaconda environment. +See the [installation guide](https://climada-python.readthedocs.io/en/latest/guide/install.html) for further information. Follow the [tutorial](https://climada-python.readthedocs.io/en/latest/tutorial/1_main_climada.html) `climada_python-x.y.z/doc/tutorial/1_main_climada.ipynb` in a Jupyter Notebook to see what can be done with CLIMADA and how. diff --git a/setup.py b/setup.py index 875e7756c..39821d104 100644 --- a/setup.py +++ b/setup.py @@ -33,7 +33,7 @@ setup( name='climada', - version='3.3.2-dev', + version='4.3.1', description='CLIMADA in Python', From cfefe53002d4055f73fafde73f7f0d77f9e6a03b Mon Sep 17 00:00:00 2001 From: climada Date: Fri, 1 Sep 2023 10:56:18 +0000 Subject: [PATCH 19/44] setup develop branch for v4.3.1-dev --- CHANGELOG.md | 50 ++++++++++++++++++++++++--------------------- climada/_version.py | 2 +- doc/misc/README.md | 8 +++++++- setup.py | 2 +- 4 files changed, 36 insertions(+), 26 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ade22ac4b..0e7a8c38b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,17 +6,32 @@ Release date: YYYY-MM-DD Code freeze date: YYYY-MM-DD +### Description + +### Dependency Changes + +### Added + +### Changed + +### Fixed + +### Deprecated + +### Removed + +## 4.3.1 + +Release date: 2023-09-01 + ### Dependency Updates Added: - - `pytest` [#726](https://github.com/CLIMADA-project/climada_python/pull/726) - `pytest-cov` [#726](https://github.com/CLIMADA-project/climada_python/pull/726) - `pytest-subtests` [#726](https://github.com/CLIMADA-project/climada_python/pull/726) - `unittest-xml-reporting` - Changed: - - `cartopy` >=0.20.0,<0.20.3 → >=0.21 - `cfgrib` >=0.9.7,<0.9.10 → =0.9.9 - `contextily` >=1.0 → >=1.3 @@ -48,9 +63,7 @@ Changed: - `xarray` >=0.13 → >=2023.5 - `xlrd` >=1.2 → >=2.0 - `xlsxwriter` >=1.3 → >=3.1 - Removed: - - `nbsphinx` [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - `pandoc` [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - `xmlrunner` @@ -63,7 +76,7 @@ Removed: - 'Extra' requirements `doc`, `test`, and `dev` for Python package [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - Added method `Exposures.centroids_total_value` to replace the functionality of `Exposures.affected_total_value`. This method is temporary and deprecated. [#702](https://github.com/CLIMADA-project/climada_python/pull/702) - New method `climada.util.api_client.Client.purge_cache`: utility function to remove outdated files from the local file system to free disk space. - ([#737](https://github.com/CLIMADA-project/climada_python/pull/737)) +([#737](https://github.com/CLIMADA-project/climada_python/pull/737)) - New attribute `climada.hazard.Hazard.haz_type`: used for assigning impacts to hazards. In previous versions this information was stored in the now removed `climada.hazard.tag.Tag` class. [#736](https://github.com/CLIMADA-project/climada_python/pull/736) - New attribute `climada.entity.exposures.Exposures.description`: used for setting the default title in plots from plotting mathods `plot_hexbin` and `plot_scatter`. In previous versions this information was stored in the deprecated `climada.entity.tag.Tag` class. [#756](https://github.com/CLIMADA-project/climada_python/pull/756) - Added advanced examples in unsequa tutorial for coupled input variables and for handling efficiently the loading of multiple large files [#766](https://github.com/CLIMADA-project/climada_python/pull/766) @@ -119,14 +132,14 @@ Removed: - `Centroids.set_raster_from_pix_bounds` [#721](https://github.com/CLIMADA-project/climada_python/pull/721) - `requirements/env_developer.yml` environment specs. Use 'extra' requirements when installing the Python package instead [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - The `climada.entitity.tag.Tag` class, together with `Impact.tag`, `Exposures.tag`, `ImpactFuncSet.tag`, `MeasuresSet.tag`, `Hazard.tag` attributes. - This may break backwards-compatibility with respect to the files written and read by the `Impact` class. - [#736](https://github.com/CLIMADA-project/climada_python/pull/736), - [#743](https://github.com/CLIMADA-project/climada_python/pull/743), - [#753](https://github.com/CLIMADA-project/climada_python/pull/753), - [#754](https://github.com/CLIMADA-project/climada_python/pull/754), - [#756](https://github.com/CLIMADA-project/climada_python/pull/756), - [#767](https://github.com/CLIMADA-project/climada_python/pull/767), - [#779](https://github.com/CLIMADA-project/climada_python/pull/779) +This may break backwards-compatibility with respect to the files written and read by the `Impact` class. +[#736](https://github.com/CLIMADA-project/climada_python/pull/736), +[#743](https://github.com/CLIMADA-project/climada_python/pull/743), +[#753](https://github.com/CLIMADA-project/climada_python/pull/753), +[#754](https://github.com/CLIMADA-project/climada_python/pull/754), +[#756](https://github.com/CLIMADA-project/climada_python/pull/756), +[#767](https://github.com/CLIMADA-project/climada_python/pull/767), +[#779](https://github.com/CLIMADA-project/climada_python/pull/779) - `impact.tot_value` attribute removed from unsequa module [#763](https://github.com/CLIMADA-project/climada_python/pull/763) ## v3.3.2 @@ -136,7 +149,6 @@ Release date: 2023-03-02 ### Dependency Updates Removed: - - `pybufrkit` [#662](https://github.com/CLIMADA-project/climada_python/pull/662) ## v3.3.1 @@ -155,18 +167,11 @@ Patch-relaese with altered base config file so that the basic installation test Release date: 2023-02-17 -Code freeze date: 2023-02-05 - -### Description - ### Dependency Changes new: - - sparse (>=0.13) for [#578](https://github.com/CLIMADA-project/climada_python/pull/578) - updated: - - **python 3.9** - python 3.8 will still work, but python 3.9 is now the default version for [installing climada](https://climada-python.readthedocs.io/en/latest/tutorial/climada_installation_step_by_step.html) ([#614](https://github.com/CLIMADA-project/climada_python/pull/614)) - contextily >=1.0 (no longer restricted to <1.2 as `contextily.sources` has been replaced in [#517](https://github.com/CLIMADA-project/climada_python/pull/517)) - cartopy >=0.20.0,<0.20.3 (>=0.20.3 has an issue with geographic crs in plots) @@ -248,4 +253,3 @@ updated: - `climada.enginge.impact.Impact.calc()` and `climada.enginge.impact.Impact.calc_impact_yearset()` [#436](https://github.com/CLIMADA-project/climada_python/pull/436). -### Removed diff --git a/climada/_version.py b/climada/_version.py index 1571c99a7..5e25203df 100644 --- a/climada/_version.py +++ b/climada/_version.py @@ -1 +1 @@ -__version__ = '3.3.2-dev' +__version__ = '4.3.1-dev' diff --git a/doc/misc/README.md b/doc/misc/README.md index cc314f610..369cecb58 100644 --- a/doc/misc/README.md +++ b/doc/misc/README.md @@ -15,7 +15,13 @@ This is the Python (3.8+) version of CLIMADA - please see https://github.com/dav ## Getting started -CLIMADA runs on Windows, macOS and Linux. It can be installed from sources or - in case of climada_python - directly with pip. See the [installation guide](https://climada-python.readthedocs.io/en/latest/guide/install.html) for instructions. +CLIMADA runs on Windows, macOS and Linux. +The released versions of the CLIMADA core can be installed directly through Anaconda: +```shell +conda install -c conda-forge climada +``` +It is **highly recommended** to install CLIMADA into a **separate** Anaconda environment. +See the [installation guide](https://climada-python.readthedocs.io/en/latest/guide/install.html) for further information. Follow the [tutorial](https://climada-python.readthedocs.io/en/latest/tutorial/1_main_climada.html) `climada_python-x.y.z/doc/tutorial/1_main_climada.ipynb` in a Jupyter Notebook to see what can be done with CLIMADA and how. diff --git a/setup.py b/setup.py index 875e7756c..9532cc9d5 100644 --- a/setup.py +++ b/setup.py @@ -33,7 +33,7 @@ setup( name='climada', - version='3.3.2-dev', + version='4.3.1-dev', description='CLIMADA in Python', From 29c45f7f9f366c3e8275f3f2f5551b6ed2c93f06 Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Fri, 1 Sep 2023 13:09:21 +0200 Subject: [PATCH 20/44] undo --- CHANGELOG.md | 38 +++++++++++++++++++++++++++----------- climada/_version.py | 2 +- doc/misc/README.md | 8 +------- setup.py | 2 +- 4 files changed, 30 insertions(+), 20 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 95c129008..ade22ac4b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,17 +1,22 @@ # Changelog -## 4.3.1 +## Unreleased -Release date: 2023-09-01 +Release date: YYYY-MM-DD + +Code freeze date: YYYY-MM-DD ### Dependency Updates Added: + - `pytest` [#726](https://github.com/CLIMADA-project/climada_python/pull/726) - `pytest-cov` [#726](https://github.com/CLIMADA-project/climada_python/pull/726) - `pytest-subtests` [#726](https://github.com/CLIMADA-project/climada_python/pull/726) - `unittest-xml-reporting` + Changed: + - `cartopy` >=0.20.0,<0.20.3 → >=0.21 - `cfgrib` >=0.9.7,<0.9.10 → =0.9.9 - `contextily` >=1.0 → >=1.3 @@ -43,7 +48,9 @@ Changed: - `xarray` >=0.13 → >=2023.5 - `xlrd` >=1.2 → >=2.0 - `xlsxwriter` >=1.3 → >=3.1 + Removed: + - `nbsphinx` [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - `pandoc` [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - `xmlrunner` @@ -56,7 +63,7 @@ Removed: - 'Extra' requirements `doc`, `test`, and `dev` for Python package [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - Added method `Exposures.centroids_total_value` to replace the functionality of `Exposures.affected_total_value`. This method is temporary and deprecated. [#702](https://github.com/CLIMADA-project/climada_python/pull/702) - New method `climada.util.api_client.Client.purge_cache`: utility function to remove outdated files from the local file system to free disk space. -([#737](https://github.com/CLIMADA-project/climada_python/pull/737)) + ([#737](https://github.com/CLIMADA-project/climada_python/pull/737)) - New attribute `climada.hazard.Hazard.haz_type`: used for assigning impacts to hazards. In previous versions this information was stored in the now removed `climada.hazard.tag.Tag` class. [#736](https://github.com/CLIMADA-project/climada_python/pull/736) - New attribute `climada.entity.exposures.Exposures.description`: used for setting the default title in plots from plotting mathods `plot_hexbin` and `plot_scatter`. In previous versions this information was stored in the deprecated `climada.entity.tag.Tag` class. [#756](https://github.com/CLIMADA-project/climada_python/pull/756) - Added advanced examples in unsequa tutorial for coupled input variables and for handling efficiently the loading of multiple large files [#766](https://github.com/CLIMADA-project/climada_python/pull/766) @@ -112,14 +119,14 @@ Removed: - `Centroids.set_raster_from_pix_bounds` [#721](https://github.com/CLIMADA-project/climada_python/pull/721) - `requirements/env_developer.yml` environment specs. Use 'extra' requirements when installing the Python package instead [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - The `climada.entitity.tag.Tag` class, together with `Impact.tag`, `Exposures.tag`, `ImpactFuncSet.tag`, `MeasuresSet.tag`, `Hazard.tag` attributes. -This may break backwards-compatibility with respect to the files written and read by the `Impact` class. -[#736](https://github.com/CLIMADA-project/climada_python/pull/736), -[#743](https://github.com/CLIMADA-project/climada_python/pull/743), -[#753](https://github.com/CLIMADA-project/climada_python/pull/753), -[#754](https://github.com/CLIMADA-project/climada_python/pull/754), -[#756](https://github.com/CLIMADA-project/climada_python/pull/756), -[#767](https://github.com/CLIMADA-project/climada_python/pull/767), -[#779](https://github.com/CLIMADA-project/climada_python/pull/779) + This may break backwards-compatibility with respect to the files written and read by the `Impact` class. + [#736](https://github.com/CLIMADA-project/climada_python/pull/736), + [#743](https://github.com/CLIMADA-project/climada_python/pull/743), + [#753](https://github.com/CLIMADA-project/climada_python/pull/753), + [#754](https://github.com/CLIMADA-project/climada_python/pull/754), + [#756](https://github.com/CLIMADA-project/climada_python/pull/756), + [#767](https://github.com/CLIMADA-project/climada_python/pull/767), + [#779](https://github.com/CLIMADA-project/climada_python/pull/779) - `impact.tot_value` attribute removed from unsequa module [#763](https://github.com/CLIMADA-project/climada_python/pull/763) ## v3.3.2 @@ -129,6 +136,7 @@ Release date: 2023-03-02 ### Dependency Updates Removed: + - `pybufrkit` [#662](https://github.com/CLIMADA-project/climada_python/pull/662) ## v3.3.1 @@ -147,11 +155,18 @@ Patch-relaese with altered base config file so that the basic installation test Release date: 2023-02-17 +Code freeze date: 2023-02-05 + +### Description + ### Dependency Changes new: + - sparse (>=0.13) for [#578](https://github.com/CLIMADA-project/climada_python/pull/578) + updated: + - **python 3.9** - python 3.8 will still work, but python 3.9 is now the default version for [installing climada](https://climada-python.readthedocs.io/en/latest/tutorial/climada_installation_step_by_step.html) ([#614](https://github.com/CLIMADA-project/climada_python/pull/614)) - contextily >=1.0 (no longer restricted to <1.2 as `contextily.sources` has been replaced in [#517](https://github.com/CLIMADA-project/climada_python/pull/517)) - cartopy >=0.20.0,<0.20.3 (>=0.20.3 has an issue with geographic crs in plots) @@ -233,3 +248,4 @@ updated: - `climada.enginge.impact.Impact.calc()` and `climada.enginge.impact.Impact.calc_impact_yearset()` [#436](https://github.com/CLIMADA-project/climada_python/pull/436). +### Removed diff --git a/climada/_version.py b/climada/_version.py index 376d9ccc2..1571c99a7 100644 --- a/climada/_version.py +++ b/climada/_version.py @@ -1 +1 @@ -__version__ = '4.3.1' +__version__ = '3.3.2-dev' diff --git a/doc/misc/README.md b/doc/misc/README.md index 369cecb58..cc314f610 100644 --- a/doc/misc/README.md +++ b/doc/misc/README.md @@ -15,13 +15,7 @@ This is the Python (3.8+) version of CLIMADA - please see https://github.com/dav ## Getting started -CLIMADA runs on Windows, macOS and Linux. -The released versions of the CLIMADA core can be installed directly through Anaconda: -```shell -conda install -c conda-forge climada -``` -It is **highly recommended** to install CLIMADA into a **separate** Anaconda environment. -See the [installation guide](https://climada-python.readthedocs.io/en/latest/guide/install.html) for further information. +CLIMADA runs on Windows, macOS and Linux. It can be installed from sources or - in case of climada_python - directly with pip. See the [installation guide](https://climada-python.readthedocs.io/en/latest/guide/install.html) for instructions. Follow the [tutorial](https://climada-python.readthedocs.io/en/latest/tutorial/1_main_climada.html) `climada_python-x.y.z/doc/tutorial/1_main_climada.ipynb` in a Jupyter Notebook to see what can be done with CLIMADA and how. diff --git a/setup.py b/setup.py index 39821d104..875e7756c 100644 --- a/setup.py +++ b/setup.py @@ -33,7 +33,7 @@ setup( name='climada', - version='4.3.1', + version='3.3.2-dev', description='CLIMADA in Python', From 39f05e546fbb0d1045a77532d1817c3115a8a215 Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Fri, 1 Sep 2023 13:12:21 +0200 Subject: [PATCH 21/44] undo --- CHANGELOG.md | 50 +++++++++++++++++++++------------------------ climada/_version.py | 2 +- doc/misc/README.md | 8 +------- setup.py | 2 +- 4 files changed, 26 insertions(+), 36 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 0e7a8c38b..ade22ac4b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,32 +6,17 @@ Release date: YYYY-MM-DD Code freeze date: YYYY-MM-DD -### Description - -### Dependency Changes - -### Added - -### Changed - -### Fixed - -### Deprecated - -### Removed - -## 4.3.1 - -Release date: 2023-09-01 - ### Dependency Updates Added: + - `pytest` [#726](https://github.com/CLIMADA-project/climada_python/pull/726) - `pytest-cov` [#726](https://github.com/CLIMADA-project/climada_python/pull/726) - `pytest-subtests` [#726](https://github.com/CLIMADA-project/climada_python/pull/726) - `unittest-xml-reporting` + Changed: + - `cartopy` >=0.20.0,<0.20.3 → >=0.21 - `cfgrib` >=0.9.7,<0.9.10 → =0.9.9 - `contextily` >=1.0 → >=1.3 @@ -63,7 +48,9 @@ Changed: - `xarray` >=0.13 → >=2023.5 - `xlrd` >=1.2 → >=2.0 - `xlsxwriter` >=1.3 → >=3.1 + Removed: + - `nbsphinx` [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - `pandoc` [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - `xmlrunner` @@ -76,7 +63,7 @@ Removed: - 'Extra' requirements `doc`, `test`, and `dev` for Python package [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - Added method `Exposures.centroids_total_value` to replace the functionality of `Exposures.affected_total_value`. This method is temporary and deprecated. [#702](https://github.com/CLIMADA-project/climada_python/pull/702) - New method `climada.util.api_client.Client.purge_cache`: utility function to remove outdated files from the local file system to free disk space. -([#737](https://github.com/CLIMADA-project/climada_python/pull/737)) + ([#737](https://github.com/CLIMADA-project/climada_python/pull/737)) - New attribute `climada.hazard.Hazard.haz_type`: used for assigning impacts to hazards. In previous versions this information was stored in the now removed `climada.hazard.tag.Tag` class. [#736](https://github.com/CLIMADA-project/climada_python/pull/736) - New attribute `climada.entity.exposures.Exposures.description`: used for setting the default title in plots from plotting mathods `plot_hexbin` and `plot_scatter`. In previous versions this information was stored in the deprecated `climada.entity.tag.Tag` class. [#756](https://github.com/CLIMADA-project/climada_python/pull/756) - Added advanced examples in unsequa tutorial for coupled input variables and for handling efficiently the loading of multiple large files [#766](https://github.com/CLIMADA-project/climada_python/pull/766) @@ -132,14 +119,14 @@ Removed: - `Centroids.set_raster_from_pix_bounds` [#721](https://github.com/CLIMADA-project/climada_python/pull/721) - `requirements/env_developer.yml` environment specs. Use 'extra' requirements when installing the Python package instead [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - The `climada.entitity.tag.Tag` class, together with `Impact.tag`, `Exposures.tag`, `ImpactFuncSet.tag`, `MeasuresSet.tag`, `Hazard.tag` attributes. -This may break backwards-compatibility with respect to the files written and read by the `Impact` class. -[#736](https://github.com/CLIMADA-project/climada_python/pull/736), -[#743](https://github.com/CLIMADA-project/climada_python/pull/743), -[#753](https://github.com/CLIMADA-project/climada_python/pull/753), -[#754](https://github.com/CLIMADA-project/climada_python/pull/754), -[#756](https://github.com/CLIMADA-project/climada_python/pull/756), -[#767](https://github.com/CLIMADA-project/climada_python/pull/767), -[#779](https://github.com/CLIMADA-project/climada_python/pull/779) + This may break backwards-compatibility with respect to the files written and read by the `Impact` class. + [#736](https://github.com/CLIMADA-project/climada_python/pull/736), + [#743](https://github.com/CLIMADA-project/climada_python/pull/743), + [#753](https://github.com/CLIMADA-project/climada_python/pull/753), + [#754](https://github.com/CLIMADA-project/climada_python/pull/754), + [#756](https://github.com/CLIMADA-project/climada_python/pull/756), + [#767](https://github.com/CLIMADA-project/climada_python/pull/767), + [#779](https://github.com/CLIMADA-project/climada_python/pull/779) - `impact.tot_value` attribute removed from unsequa module [#763](https://github.com/CLIMADA-project/climada_python/pull/763) ## v3.3.2 @@ -149,6 +136,7 @@ Release date: 2023-03-02 ### Dependency Updates Removed: + - `pybufrkit` [#662](https://github.com/CLIMADA-project/climada_python/pull/662) ## v3.3.1 @@ -167,11 +155,18 @@ Patch-relaese with altered base config file so that the basic installation test Release date: 2023-02-17 +Code freeze date: 2023-02-05 + +### Description + ### Dependency Changes new: + - sparse (>=0.13) for [#578](https://github.com/CLIMADA-project/climada_python/pull/578) + updated: + - **python 3.9** - python 3.8 will still work, but python 3.9 is now the default version for [installing climada](https://climada-python.readthedocs.io/en/latest/tutorial/climada_installation_step_by_step.html) ([#614](https://github.com/CLIMADA-project/climada_python/pull/614)) - contextily >=1.0 (no longer restricted to <1.2 as `contextily.sources` has been replaced in [#517](https://github.com/CLIMADA-project/climada_python/pull/517)) - cartopy >=0.20.0,<0.20.3 (>=0.20.3 has an issue with geographic crs in plots) @@ -253,3 +248,4 @@ updated: - `climada.enginge.impact.Impact.calc()` and `climada.enginge.impact.Impact.calc_impact_yearset()` [#436](https://github.com/CLIMADA-project/climada_python/pull/436). +### Removed diff --git a/climada/_version.py b/climada/_version.py index 5e25203df..1571c99a7 100644 --- a/climada/_version.py +++ b/climada/_version.py @@ -1 +1 @@ -__version__ = '4.3.1-dev' +__version__ = '3.3.2-dev' diff --git a/doc/misc/README.md b/doc/misc/README.md index 369cecb58..cc314f610 100644 --- a/doc/misc/README.md +++ b/doc/misc/README.md @@ -15,13 +15,7 @@ This is the Python (3.8+) version of CLIMADA - please see https://github.com/dav ## Getting started -CLIMADA runs on Windows, macOS and Linux. -The released versions of the CLIMADA core can be installed directly through Anaconda: -```shell -conda install -c conda-forge climada -``` -It is **highly recommended** to install CLIMADA into a **separate** Anaconda environment. -See the [installation guide](https://climada-python.readthedocs.io/en/latest/guide/install.html) for further information. +CLIMADA runs on Windows, macOS and Linux. It can be installed from sources or - in case of climada_python - directly with pip. See the [installation guide](https://climada-python.readthedocs.io/en/latest/guide/install.html) for instructions. Follow the [tutorial](https://climada-python.readthedocs.io/en/latest/tutorial/1_main_climada.html) `climada_python-x.y.z/doc/tutorial/1_main_climada.ipynb` in a Jupyter Notebook to see what can be done with CLIMADA and how. diff --git a/setup.py b/setup.py index 9532cc9d5..875e7756c 100644 --- a/setup.py +++ b/setup.py @@ -33,7 +33,7 @@ setup( name='climada', - version='4.3.1-dev', + version='3.3.2-dev', description='CLIMADA in Python', From 84cef4fa6d7541ea3bbf2a307ca07ea5cf23aeb2 Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Fri, 1 Sep 2023 13:53:30 +0200 Subject: [PATCH 22/44] github actions prepare release fix listings --- .github/scripts/prepare_release.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/scripts/prepare_release.py b/.github/scripts/prepare_release.py index a18c823c3..11b824e52 100644 --- a/.github/scripts/prepare_release.py +++ b/.github/scripts/prepare_release.py @@ -111,7 +111,7 @@ def update_changelog(nvn): if "release date: " in line.lower(): today = time.strftime("%Y-%m-%d") lines[i] = f"Release date: {today}" - changelog.write("\n".join(lines).replace("\n\n", "\n")) + changelog.write(re.sub("\n+$", "\n", "\n".join(lines))) changelog.write("\n") return GitFile('CHANGELOG.md') From 77afd861bc1c817da093a2827d969dec9750344e Mon Sep 17 00:00:00 2001 From: climada Date: Fri, 1 Sep 2023 11:54:44 +0000 Subject: [PATCH 23/44] 'Automated update v4.3.3' --- CHANGELOG.md | 29 +++++++++++------------------ climada/_version.py | 2 +- doc/misc/README.md | 8 +++++++- setup.py | 2 +- 4 files changed, 20 insertions(+), 21 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ade22ac4b..ed4e64631 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,10 +1,8 @@ # Changelog -## Unreleased +## 4.3.3 -Release date: YYYY-MM-DD - -Code freeze date: YYYY-MM-DD +Release date: 2023-09-01 ### Dependency Updates @@ -63,7 +61,7 @@ Removed: - 'Extra' requirements `doc`, `test`, and `dev` for Python package [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - Added method `Exposures.centroids_total_value` to replace the functionality of `Exposures.affected_total_value`. This method is temporary and deprecated. [#702](https://github.com/CLIMADA-project/climada_python/pull/702) - New method `climada.util.api_client.Client.purge_cache`: utility function to remove outdated files from the local file system to free disk space. - ([#737](https://github.com/CLIMADA-project/climada_python/pull/737)) +([#737](https://github.com/CLIMADA-project/climada_python/pull/737)) - New attribute `climada.hazard.Hazard.haz_type`: used for assigning impacts to hazards. In previous versions this information was stored in the now removed `climada.hazard.tag.Tag` class. [#736](https://github.com/CLIMADA-project/climada_python/pull/736) - New attribute `climada.entity.exposures.Exposures.description`: used for setting the default title in plots from plotting mathods `plot_hexbin` and `plot_scatter`. In previous versions this information was stored in the deprecated `climada.entity.tag.Tag` class. [#756](https://github.com/CLIMADA-project/climada_python/pull/756) - Added advanced examples in unsequa tutorial for coupled input variables and for handling efficiently the loading of multiple large files [#766](https://github.com/CLIMADA-project/climada_python/pull/766) @@ -119,14 +117,14 @@ Removed: - `Centroids.set_raster_from_pix_bounds` [#721](https://github.com/CLIMADA-project/climada_python/pull/721) - `requirements/env_developer.yml` environment specs. Use 'extra' requirements when installing the Python package instead [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - The `climada.entitity.tag.Tag` class, together with `Impact.tag`, `Exposures.tag`, `ImpactFuncSet.tag`, `MeasuresSet.tag`, `Hazard.tag` attributes. - This may break backwards-compatibility with respect to the files written and read by the `Impact` class. - [#736](https://github.com/CLIMADA-project/climada_python/pull/736), - [#743](https://github.com/CLIMADA-project/climada_python/pull/743), - [#753](https://github.com/CLIMADA-project/climada_python/pull/753), - [#754](https://github.com/CLIMADA-project/climada_python/pull/754), - [#756](https://github.com/CLIMADA-project/climada_python/pull/756), - [#767](https://github.com/CLIMADA-project/climada_python/pull/767), - [#779](https://github.com/CLIMADA-project/climada_python/pull/779) +This may break backwards-compatibility with respect to the files written and read by the `Impact` class. +[#736](https://github.com/CLIMADA-project/climada_python/pull/736), +[#743](https://github.com/CLIMADA-project/climada_python/pull/743), +[#753](https://github.com/CLIMADA-project/climada_python/pull/753), +[#754](https://github.com/CLIMADA-project/climada_python/pull/754), +[#756](https://github.com/CLIMADA-project/climada_python/pull/756), +[#767](https://github.com/CLIMADA-project/climada_python/pull/767), +[#779](https://github.com/CLIMADA-project/climada_python/pull/779) - `impact.tot_value` attribute removed from unsequa module [#763](https://github.com/CLIMADA-project/climada_python/pull/763) ## v3.3.2 @@ -155,10 +153,6 @@ Patch-relaese with altered base config file so that the basic installation test Release date: 2023-02-17 -Code freeze date: 2023-02-05 - -### Description - ### Dependency Changes new: @@ -248,4 +242,3 @@ updated: - `climada.enginge.impact.Impact.calc()` and `climada.enginge.impact.Impact.calc_impact_yearset()` [#436](https://github.com/CLIMADA-project/climada_python/pull/436). -### Removed diff --git a/climada/_version.py b/climada/_version.py index 1571c99a7..a748043f5 100644 --- a/climada/_version.py +++ b/climada/_version.py @@ -1 +1 @@ -__version__ = '3.3.2-dev' +__version__ = '4.3.3' diff --git a/doc/misc/README.md b/doc/misc/README.md index cc314f610..369cecb58 100644 --- a/doc/misc/README.md +++ b/doc/misc/README.md @@ -15,7 +15,13 @@ This is the Python (3.8+) version of CLIMADA - please see https://github.com/dav ## Getting started -CLIMADA runs on Windows, macOS and Linux. It can be installed from sources or - in case of climada_python - directly with pip. See the [installation guide](https://climada-python.readthedocs.io/en/latest/guide/install.html) for instructions. +CLIMADA runs on Windows, macOS and Linux. +The released versions of the CLIMADA core can be installed directly through Anaconda: +```shell +conda install -c conda-forge climada +``` +It is **highly recommended** to install CLIMADA into a **separate** Anaconda environment. +See the [installation guide](https://climada-python.readthedocs.io/en/latest/guide/install.html) for further information. Follow the [tutorial](https://climada-python.readthedocs.io/en/latest/tutorial/1_main_climada.html) `climada_python-x.y.z/doc/tutorial/1_main_climada.ipynb` in a Jupyter Notebook to see what can be done with CLIMADA and how. diff --git a/setup.py b/setup.py index 875e7756c..1e1747a49 100644 --- a/setup.py +++ b/setup.py @@ -33,7 +33,7 @@ setup( name='climada', - version='3.3.2-dev', + version='4.3.3', description='CLIMADA in Python', From f5bcf3d3abad7d040b653a77bbed65095a364fd8 Mon Sep 17 00:00:00 2001 From: climada Date: Fri, 1 Sep 2023 11:55:20 +0000 Subject: [PATCH 24/44] setup develop branch for v4.3.3-dev --- CHANGELOG.md | 41 +++++++++++++++++++++++++++-------------- climada/_version.py | 2 +- doc/misc/README.md | 8 +++++++- setup.py | 2 +- 4 files changed, 36 insertions(+), 17 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ade22ac4b..e2a2d7fe0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,24 @@ Release date: YYYY-MM-DD Code freeze date: YYYY-MM-DD +### Description + +### Dependency Changes + +### Added + +### Changed + +### Fixed + +### Deprecated + +### Removed + +## 4.3.3 + +Release date: 2023-09-01 + ### Dependency Updates Added: @@ -63,7 +81,7 @@ Removed: - 'Extra' requirements `doc`, `test`, and `dev` for Python package [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - Added method `Exposures.centroids_total_value` to replace the functionality of `Exposures.affected_total_value`. This method is temporary and deprecated. [#702](https://github.com/CLIMADA-project/climada_python/pull/702) - New method `climada.util.api_client.Client.purge_cache`: utility function to remove outdated files from the local file system to free disk space. - ([#737](https://github.com/CLIMADA-project/climada_python/pull/737)) +([#737](https://github.com/CLIMADA-project/climada_python/pull/737)) - New attribute `climada.hazard.Hazard.haz_type`: used for assigning impacts to hazards. In previous versions this information was stored in the now removed `climada.hazard.tag.Tag` class. [#736](https://github.com/CLIMADA-project/climada_python/pull/736) - New attribute `climada.entity.exposures.Exposures.description`: used for setting the default title in plots from plotting mathods `plot_hexbin` and `plot_scatter`. In previous versions this information was stored in the deprecated `climada.entity.tag.Tag` class. [#756](https://github.com/CLIMADA-project/climada_python/pull/756) - Added advanced examples in unsequa tutorial for coupled input variables and for handling efficiently the loading of multiple large files [#766](https://github.com/CLIMADA-project/climada_python/pull/766) @@ -119,14 +137,14 @@ Removed: - `Centroids.set_raster_from_pix_bounds` [#721](https://github.com/CLIMADA-project/climada_python/pull/721) - `requirements/env_developer.yml` environment specs. Use 'extra' requirements when installing the Python package instead [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - The `climada.entitity.tag.Tag` class, together with `Impact.tag`, `Exposures.tag`, `ImpactFuncSet.tag`, `MeasuresSet.tag`, `Hazard.tag` attributes. - This may break backwards-compatibility with respect to the files written and read by the `Impact` class. - [#736](https://github.com/CLIMADA-project/climada_python/pull/736), - [#743](https://github.com/CLIMADA-project/climada_python/pull/743), - [#753](https://github.com/CLIMADA-project/climada_python/pull/753), - [#754](https://github.com/CLIMADA-project/climada_python/pull/754), - [#756](https://github.com/CLIMADA-project/climada_python/pull/756), - [#767](https://github.com/CLIMADA-project/climada_python/pull/767), - [#779](https://github.com/CLIMADA-project/climada_python/pull/779) +This may break backwards-compatibility with respect to the files written and read by the `Impact` class. +[#736](https://github.com/CLIMADA-project/climada_python/pull/736), +[#743](https://github.com/CLIMADA-project/climada_python/pull/743), +[#753](https://github.com/CLIMADA-project/climada_python/pull/753), +[#754](https://github.com/CLIMADA-project/climada_python/pull/754), +[#756](https://github.com/CLIMADA-project/climada_python/pull/756), +[#767](https://github.com/CLIMADA-project/climada_python/pull/767), +[#779](https://github.com/CLIMADA-project/climada_python/pull/779) - `impact.tot_value` attribute removed from unsequa module [#763](https://github.com/CLIMADA-project/climada_python/pull/763) ## v3.3.2 @@ -155,10 +173,6 @@ Patch-relaese with altered base config file so that the basic installation test Release date: 2023-02-17 -Code freeze date: 2023-02-05 - -### Description - ### Dependency Changes new: @@ -248,4 +262,3 @@ updated: - `climada.enginge.impact.Impact.calc()` and `climada.enginge.impact.Impact.calc_impact_yearset()` [#436](https://github.com/CLIMADA-project/climada_python/pull/436). -### Removed diff --git a/climada/_version.py b/climada/_version.py index 1571c99a7..377f2c036 100644 --- a/climada/_version.py +++ b/climada/_version.py @@ -1 +1 @@ -__version__ = '3.3.2-dev' +__version__ = '4.3.3-dev' diff --git a/doc/misc/README.md b/doc/misc/README.md index cc314f610..369cecb58 100644 --- a/doc/misc/README.md +++ b/doc/misc/README.md @@ -15,7 +15,13 @@ This is the Python (3.8+) version of CLIMADA - please see https://github.com/dav ## Getting started -CLIMADA runs on Windows, macOS and Linux. It can be installed from sources or - in case of climada_python - directly with pip. See the [installation guide](https://climada-python.readthedocs.io/en/latest/guide/install.html) for instructions. +CLIMADA runs on Windows, macOS and Linux. +The released versions of the CLIMADA core can be installed directly through Anaconda: +```shell +conda install -c conda-forge climada +``` +It is **highly recommended** to install CLIMADA into a **separate** Anaconda environment. +See the [installation guide](https://climada-python.readthedocs.io/en/latest/guide/install.html) for further information. Follow the [tutorial](https://climada-python.readthedocs.io/en/latest/tutorial/1_main_climada.html) `climada_python-x.y.z/doc/tutorial/1_main_climada.ipynb` in a Jupyter Notebook to see what can be done with CLIMADA and how. diff --git a/setup.py b/setup.py index 875e7756c..fd0379135 100644 --- a/setup.py +++ b/setup.py @@ -33,7 +33,7 @@ setup( name='climada', - version='3.3.2-dev', + version='4.3.3-dev', description='CLIMADA in Python', From e598677db851e03add0c7bf31e712015956b8240 Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Fri, 1 Sep 2023 14:02:54 +0200 Subject: [PATCH 25/44] undo --- CHANGELOG.md | 41 ++++++++++++++--------------------------- climada/_version.py | 2 +- doc/misc/README.md | 8 +------- setup.py | 2 +- 4 files changed, 17 insertions(+), 36 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index e2a2d7fe0..ade22ac4b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,24 +6,6 @@ Release date: YYYY-MM-DD Code freeze date: YYYY-MM-DD -### Description - -### Dependency Changes - -### Added - -### Changed - -### Fixed - -### Deprecated - -### Removed - -## 4.3.3 - -Release date: 2023-09-01 - ### Dependency Updates Added: @@ -81,7 +63,7 @@ Removed: - 'Extra' requirements `doc`, `test`, and `dev` for Python package [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - Added method `Exposures.centroids_total_value` to replace the functionality of `Exposures.affected_total_value`. This method is temporary and deprecated. [#702](https://github.com/CLIMADA-project/climada_python/pull/702) - New method `climada.util.api_client.Client.purge_cache`: utility function to remove outdated files from the local file system to free disk space. -([#737](https://github.com/CLIMADA-project/climada_python/pull/737)) + ([#737](https://github.com/CLIMADA-project/climada_python/pull/737)) - New attribute `climada.hazard.Hazard.haz_type`: used for assigning impacts to hazards. In previous versions this information was stored in the now removed `climada.hazard.tag.Tag` class. [#736](https://github.com/CLIMADA-project/climada_python/pull/736) - New attribute `climada.entity.exposures.Exposures.description`: used for setting the default title in plots from plotting mathods `plot_hexbin` and `plot_scatter`. In previous versions this information was stored in the deprecated `climada.entity.tag.Tag` class. [#756](https://github.com/CLIMADA-project/climada_python/pull/756) - Added advanced examples in unsequa tutorial for coupled input variables and for handling efficiently the loading of multiple large files [#766](https://github.com/CLIMADA-project/climada_python/pull/766) @@ -137,14 +119,14 @@ Removed: - `Centroids.set_raster_from_pix_bounds` [#721](https://github.com/CLIMADA-project/climada_python/pull/721) - `requirements/env_developer.yml` environment specs. Use 'extra' requirements when installing the Python package instead [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - The `climada.entitity.tag.Tag` class, together with `Impact.tag`, `Exposures.tag`, `ImpactFuncSet.tag`, `MeasuresSet.tag`, `Hazard.tag` attributes. -This may break backwards-compatibility with respect to the files written and read by the `Impact` class. -[#736](https://github.com/CLIMADA-project/climada_python/pull/736), -[#743](https://github.com/CLIMADA-project/climada_python/pull/743), -[#753](https://github.com/CLIMADA-project/climada_python/pull/753), -[#754](https://github.com/CLIMADA-project/climada_python/pull/754), -[#756](https://github.com/CLIMADA-project/climada_python/pull/756), -[#767](https://github.com/CLIMADA-project/climada_python/pull/767), -[#779](https://github.com/CLIMADA-project/climada_python/pull/779) + This may break backwards-compatibility with respect to the files written and read by the `Impact` class. + [#736](https://github.com/CLIMADA-project/climada_python/pull/736), + [#743](https://github.com/CLIMADA-project/climada_python/pull/743), + [#753](https://github.com/CLIMADA-project/climada_python/pull/753), + [#754](https://github.com/CLIMADA-project/climada_python/pull/754), + [#756](https://github.com/CLIMADA-project/climada_python/pull/756), + [#767](https://github.com/CLIMADA-project/climada_python/pull/767), + [#779](https://github.com/CLIMADA-project/climada_python/pull/779) - `impact.tot_value` attribute removed from unsequa module [#763](https://github.com/CLIMADA-project/climada_python/pull/763) ## v3.3.2 @@ -173,6 +155,10 @@ Patch-relaese with altered base config file so that the basic installation test Release date: 2023-02-17 +Code freeze date: 2023-02-05 + +### Description + ### Dependency Changes new: @@ -262,3 +248,4 @@ updated: - `climada.enginge.impact.Impact.calc()` and `climada.enginge.impact.Impact.calc_impact_yearset()` [#436](https://github.com/CLIMADA-project/climada_python/pull/436). +### Removed diff --git a/climada/_version.py b/climada/_version.py index 377f2c036..1571c99a7 100644 --- a/climada/_version.py +++ b/climada/_version.py @@ -1 +1 @@ -__version__ = '4.3.3-dev' +__version__ = '3.3.2-dev' diff --git a/doc/misc/README.md b/doc/misc/README.md index 369cecb58..cc314f610 100644 --- a/doc/misc/README.md +++ b/doc/misc/README.md @@ -15,13 +15,7 @@ This is the Python (3.8+) version of CLIMADA - please see https://github.com/dav ## Getting started -CLIMADA runs on Windows, macOS and Linux. -The released versions of the CLIMADA core can be installed directly through Anaconda: -```shell -conda install -c conda-forge climada -``` -It is **highly recommended** to install CLIMADA into a **separate** Anaconda environment. -See the [installation guide](https://climada-python.readthedocs.io/en/latest/guide/install.html) for further information. +CLIMADA runs on Windows, macOS and Linux. It can be installed from sources or - in case of climada_python - directly with pip. See the [installation guide](https://climada-python.readthedocs.io/en/latest/guide/install.html) for instructions. Follow the [tutorial](https://climada-python.readthedocs.io/en/latest/tutorial/1_main_climada.html) `climada_python-x.y.z/doc/tutorial/1_main_climada.ipynb` in a Jupyter Notebook to see what can be done with CLIMADA and how. diff --git a/setup.py b/setup.py index fd0379135..875e7756c 100644 --- a/setup.py +++ b/setup.py @@ -33,7 +33,7 @@ setup( name='climada', - version='4.3.3-dev', + version='3.3.2-dev', description='CLIMADA in Python', From fec939c6a911171a756d8a5154f24a718f4fd19e Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Fri, 1 Sep 2023 14:04:00 +0200 Subject: [PATCH 26/44] undo --- .github/scripts/prepare_release.py | 2 +- CHANGELOG.md | 29 ++++++++++++++++++----------- climada/_version.py | 2 +- doc/misc/README.md | 8 +------- setup.py | 2 +- 5 files changed, 22 insertions(+), 21 deletions(-) diff --git a/.github/scripts/prepare_release.py b/.github/scripts/prepare_release.py index 11b824e52..a18c823c3 100644 --- a/.github/scripts/prepare_release.py +++ b/.github/scripts/prepare_release.py @@ -111,7 +111,7 @@ def update_changelog(nvn): if "release date: " in line.lower(): today = time.strftime("%Y-%m-%d") lines[i] = f"Release date: {today}" - changelog.write(re.sub("\n+$", "\n", "\n".join(lines))) + changelog.write("\n".join(lines).replace("\n\n", "\n")) changelog.write("\n") return GitFile('CHANGELOG.md') diff --git a/CHANGELOG.md b/CHANGELOG.md index ed4e64631..ade22ac4b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,8 +1,10 @@ # Changelog -## 4.3.3 +## Unreleased -Release date: 2023-09-01 +Release date: YYYY-MM-DD + +Code freeze date: YYYY-MM-DD ### Dependency Updates @@ -61,7 +63,7 @@ Removed: - 'Extra' requirements `doc`, `test`, and `dev` for Python package [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - Added method `Exposures.centroids_total_value` to replace the functionality of `Exposures.affected_total_value`. This method is temporary and deprecated. [#702](https://github.com/CLIMADA-project/climada_python/pull/702) - New method `climada.util.api_client.Client.purge_cache`: utility function to remove outdated files from the local file system to free disk space. -([#737](https://github.com/CLIMADA-project/climada_python/pull/737)) + ([#737](https://github.com/CLIMADA-project/climada_python/pull/737)) - New attribute `climada.hazard.Hazard.haz_type`: used for assigning impacts to hazards. In previous versions this information was stored in the now removed `climada.hazard.tag.Tag` class. [#736](https://github.com/CLIMADA-project/climada_python/pull/736) - New attribute `climada.entity.exposures.Exposures.description`: used for setting the default title in plots from plotting mathods `plot_hexbin` and `plot_scatter`. In previous versions this information was stored in the deprecated `climada.entity.tag.Tag` class. [#756](https://github.com/CLIMADA-project/climada_python/pull/756) - Added advanced examples in unsequa tutorial for coupled input variables and for handling efficiently the loading of multiple large files [#766](https://github.com/CLIMADA-project/climada_python/pull/766) @@ -117,14 +119,14 @@ Removed: - `Centroids.set_raster_from_pix_bounds` [#721](https://github.com/CLIMADA-project/climada_python/pull/721) - `requirements/env_developer.yml` environment specs. Use 'extra' requirements when installing the Python package instead [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - The `climada.entitity.tag.Tag` class, together with `Impact.tag`, `Exposures.tag`, `ImpactFuncSet.tag`, `MeasuresSet.tag`, `Hazard.tag` attributes. -This may break backwards-compatibility with respect to the files written and read by the `Impact` class. -[#736](https://github.com/CLIMADA-project/climada_python/pull/736), -[#743](https://github.com/CLIMADA-project/climada_python/pull/743), -[#753](https://github.com/CLIMADA-project/climada_python/pull/753), -[#754](https://github.com/CLIMADA-project/climada_python/pull/754), -[#756](https://github.com/CLIMADA-project/climada_python/pull/756), -[#767](https://github.com/CLIMADA-project/climada_python/pull/767), -[#779](https://github.com/CLIMADA-project/climada_python/pull/779) + This may break backwards-compatibility with respect to the files written and read by the `Impact` class. + [#736](https://github.com/CLIMADA-project/climada_python/pull/736), + [#743](https://github.com/CLIMADA-project/climada_python/pull/743), + [#753](https://github.com/CLIMADA-project/climada_python/pull/753), + [#754](https://github.com/CLIMADA-project/climada_python/pull/754), + [#756](https://github.com/CLIMADA-project/climada_python/pull/756), + [#767](https://github.com/CLIMADA-project/climada_python/pull/767), + [#779](https://github.com/CLIMADA-project/climada_python/pull/779) - `impact.tot_value` attribute removed from unsequa module [#763](https://github.com/CLIMADA-project/climada_python/pull/763) ## v3.3.2 @@ -153,6 +155,10 @@ Patch-relaese with altered base config file so that the basic installation test Release date: 2023-02-17 +Code freeze date: 2023-02-05 + +### Description + ### Dependency Changes new: @@ -242,3 +248,4 @@ updated: - `climada.enginge.impact.Impact.calc()` and `climada.enginge.impact.Impact.calc_impact_yearset()` [#436](https://github.com/CLIMADA-project/climada_python/pull/436). +### Removed diff --git a/climada/_version.py b/climada/_version.py index a748043f5..1571c99a7 100644 --- a/climada/_version.py +++ b/climada/_version.py @@ -1 +1 @@ -__version__ = '4.3.3' +__version__ = '3.3.2-dev' diff --git a/doc/misc/README.md b/doc/misc/README.md index 369cecb58..cc314f610 100644 --- a/doc/misc/README.md +++ b/doc/misc/README.md @@ -15,13 +15,7 @@ This is the Python (3.8+) version of CLIMADA - please see https://github.com/dav ## Getting started -CLIMADA runs on Windows, macOS and Linux. -The released versions of the CLIMADA core can be installed directly through Anaconda: -```shell -conda install -c conda-forge climada -``` -It is **highly recommended** to install CLIMADA into a **separate** Anaconda environment. -See the [installation guide](https://climada-python.readthedocs.io/en/latest/guide/install.html) for further information. +CLIMADA runs on Windows, macOS and Linux. It can be installed from sources or - in case of climada_python - directly with pip. See the [installation guide](https://climada-python.readthedocs.io/en/latest/guide/install.html) for instructions. Follow the [tutorial](https://climada-python.readthedocs.io/en/latest/tutorial/1_main_climada.html) `climada_python-x.y.z/doc/tutorial/1_main_climada.ipynb` in a Jupyter Notebook to see what can be done with CLIMADA and how. diff --git a/setup.py b/setup.py index 1e1747a49..875e7756c 100644 --- a/setup.py +++ b/setup.py @@ -33,7 +33,7 @@ setup( name='climada', - version='4.3.3', + version='3.3.2-dev', description='CLIMADA in Python', From 06adcea99327ac2976a8194e0fe569a91b2b1949 Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Fri, 1 Sep 2023 14:31:13 +0200 Subject: [PATCH 27/44] github actions prepare release fix version number --- .github/scripts/prepare_release.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/.github/scripts/prepare_release.py b/.github/scripts/prepare_release.py index a18c823c3..5947f150d 100644 --- a/.github/scripts/prepare_release.py +++ b/.github/scripts/prepare_release.py @@ -39,8 +39,11 @@ def bump_version_number(version_number: str, level: str) -> str: major, minor, patch = version_number.split(".") if level == "major": major = str(int(major)+1) + minor = "0" + patch = "0" elif level == "minor": minor = str(int(minor)+1) + patch = "0" elif level == "patch": patch = str(int(patch)+1) else: @@ -111,7 +114,7 @@ def update_changelog(nvn): if "release date: " in line.lower(): today = time.strftime("%Y-%m-%d") lines[i] = f"Release date: {today}" - changelog.write("\n".join(lines).replace("\n\n", "\n")) + changelog.write(re.sub("\n+$", "\n", "\n".join(lines))) changelog.write("\n") return GitFile('CHANGELOG.md') @@ -214,7 +217,7 @@ def prepare_new_release(level): else: raise new_version_number = bump_version_number(last_version_number, level) - + raise Exception(new_version_number) update_setup(new_version_number).gitadd() update_version(new_version_number).gitadd() update_changelog(new_version_number).gitadd() From 4e51484c1254322cf1850170c6d0217ab66c191d Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Fri, 1 Sep 2023 14:34:57 +0200 Subject: [PATCH 28/44] stop debugging --- .github/scripts/prepare_release.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/scripts/prepare_release.py b/.github/scripts/prepare_release.py index 5947f150d..bce483b6f 100644 --- a/.github/scripts/prepare_release.py +++ b/.github/scripts/prepare_release.py @@ -217,7 +217,7 @@ def prepare_new_release(level): else: raise new_version_number = bump_version_number(last_version_number, level) - raise Exception(new_version_number) + update_setup(new_version_number).gitadd() update_version(new_version_number).gitadd() update_changelog(new_version_number).gitadd() From e864dde5114e81ecc878b0303054691d6c252c59 Mon Sep 17 00:00:00 2001 From: climada Date: Fri, 1 Sep 2023 12:36:15 +0000 Subject: [PATCH 29/44] setup develop branch for v4.0.0-dev --- CHANGELOG.md | 41 +++++++++++++++++++++++++++-------------- climada/_version.py | 2 +- doc/misc/README.md | 8 +++++++- setup.py | 2 +- 4 files changed, 36 insertions(+), 17 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ade22ac4b..2c270940c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,24 @@ Release date: YYYY-MM-DD Code freeze date: YYYY-MM-DD +### Description + +### Dependency Changes + +### Added + +### Changed + +### Fixed + +### Deprecated + +### Removed + +## 4.0.0 + +Release date: 2023-09-01 + ### Dependency Updates Added: @@ -63,7 +81,7 @@ Removed: - 'Extra' requirements `doc`, `test`, and `dev` for Python package [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - Added method `Exposures.centroids_total_value` to replace the functionality of `Exposures.affected_total_value`. This method is temporary and deprecated. [#702](https://github.com/CLIMADA-project/climada_python/pull/702) - New method `climada.util.api_client.Client.purge_cache`: utility function to remove outdated files from the local file system to free disk space. - ([#737](https://github.com/CLIMADA-project/climada_python/pull/737)) +([#737](https://github.com/CLIMADA-project/climada_python/pull/737)) - New attribute `climada.hazard.Hazard.haz_type`: used for assigning impacts to hazards. In previous versions this information was stored in the now removed `climada.hazard.tag.Tag` class. [#736](https://github.com/CLIMADA-project/climada_python/pull/736) - New attribute `climada.entity.exposures.Exposures.description`: used for setting the default title in plots from plotting mathods `plot_hexbin` and `plot_scatter`. In previous versions this information was stored in the deprecated `climada.entity.tag.Tag` class. [#756](https://github.com/CLIMADA-project/climada_python/pull/756) - Added advanced examples in unsequa tutorial for coupled input variables and for handling efficiently the loading of multiple large files [#766](https://github.com/CLIMADA-project/climada_python/pull/766) @@ -119,14 +137,14 @@ Removed: - `Centroids.set_raster_from_pix_bounds` [#721](https://github.com/CLIMADA-project/climada_python/pull/721) - `requirements/env_developer.yml` environment specs. Use 'extra' requirements when installing the Python package instead [#712](https://github.com/CLIMADA-project/climada_python/pull/712) - The `climada.entitity.tag.Tag` class, together with `Impact.tag`, `Exposures.tag`, `ImpactFuncSet.tag`, `MeasuresSet.tag`, `Hazard.tag` attributes. - This may break backwards-compatibility with respect to the files written and read by the `Impact` class. - [#736](https://github.com/CLIMADA-project/climada_python/pull/736), - [#743](https://github.com/CLIMADA-project/climada_python/pull/743), - [#753](https://github.com/CLIMADA-project/climada_python/pull/753), - [#754](https://github.com/CLIMADA-project/climada_python/pull/754), - [#756](https://github.com/CLIMADA-project/climada_python/pull/756), - [#767](https://github.com/CLIMADA-project/climada_python/pull/767), - [#779](https://github.com/CLIMADA-project/climada_python/pull/779) +This may break backwards-compatibility with respect to the files written and read by the `Impact` class. +[#736](https://github.com/CLIMADA-project/climada_python/pull/736), +[#743](https://github.com/CLIMADA-project/climada_python/pull/743), +[#753](https://github.com/CLIMADA-project/climada_python/pull/753), +[#754](https://github.com/CLIMADA-project/climada_python/pull/754), +[#756](https://github.com/CLIMADA-project/climada_python/pull/756), +[#767](https://github.com/CLIMADA-project/climada_python/pull/767), +[#779](https://github.com/CLIMADA-project/climada_python/pull/779) - `impact.tot_value` attribute removed from unsequa module [#763](https://github.com/CLIMADA-project/climada_python/pull/763) ## v3.3.2 @@ -155,10 +173,6 @@ Patch-relaese with altered base config file so that the basic installation test Release date: 2023-02-17 -Code freeze date: 2023-02-05 - -### Description - ### Dependency Changes new: @@ -248,4 +262,3 @@ updated: - `climada.enginge.impact.Impact.calc()` and `climada.enginge.impact.Impact.calc_impact_yearset()` [#436](https://github.com/CLIMADA-project/climada_python/pull/436). -### Removed diff --git a/climada/_version.py b/climada/_version.py index 1571c99a7..b23e59d45 100644 --- a/climada/_version.py +++ b/climada/_version.py @@ -1 +1 @@ -__version__ = '3.3.2-dev' +__version__ = '4.0.0-dev' diff --git a/doc/misc/README.md b/doc/misc/README.md index cc314f610..369cecb58 100644 --- a/doc/misc/README.md +++ b/doc/misc/README.md @@ -15,7 +15,13 @@ This is the Python (3.8+) version of CLIMADA - please see https://github.com/dav ## Getting started -CLIMADA runs on Windows, macOS and Linux. It can be installed from sources or - in case of climada_python - directly with pip. See the [installation guide](https://climada-python.readthedocs.io/en/latest/guide/install.html) for instructions. +CLIMADA runs on Windows, macOS and Linux. +The released versions of the CLIMADA core can be installed directly through Anaconda: +```shell +conda install -c conda-forge climada +``` +It is **highly recommended** to install CLIMADA into a **separate** Anaconda environment. +See the [installation guide](https://climada-python.readthedocs.io/en/latest/guide/install.html) for further information. Follow the [tutorial](https://climada-python.readthedocs.io/en/latest/tutorial/1_main_climada.html) `climada_python-x.y.z/doc/tutorial/1_main_climada.ipynb` in a Jupyter Notebook to see what can be done with CLIMADA and how. diff --git a/setup.py b/setup.py index 875e7756c..eb2e29637 100644 --- a/setup.py +++ b/setup.py @@ -33,7 +33,7 @@ setup( name='climada', - version='3.3.2-dev', + version='4.0.0-dev', description='CLIMADA in Python', From b8bfbce3315e1957c9d239c236e2f80742b3ed97 Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Wed, 6 Sep 2023 17:04:12 +0200 Subject: [PATCH 30/44] leave a note about future deprecations (pandas 2.1) --- climada/engine/test/test_impact_data.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/climada/engine/test/test_impact_data.py b/climada/engine/test/test_impact_data.py index 65738c501..4fe2de39e 100644 --- a/climada/engine/test/test_impact_data.py +++ b/climada/engine/test/test_impact_data.py @@ -144,7 +144,7 @@ def test_emdat_impact_event_2020(self): self.assertEqual(2000, df['reference_year'].min()) def test_emdat_impact_yearlysum_no_futurewarning(self): - """Ensure that no FutureWarning is issued""" + """Ensure that no FutureWarning about `DataFrame.append` being deprecated is issued""" with warnings.catch_warnings(): # Make sure that FutureWarning will cause an error warnings.simplefilter("error", category=FutureWarning) @@ -156,6 +156,8 @@ def test_emdat_impact_yearlysum_no_futurewarning(self): reference_year=None, imp_str="Total Affected", ) + # TODO: pandas 2.1 will eventually raise a FutureWarning here, + # but about array concatenation of empty entries. fix it! def test_emdat_affected_yearlysum(self): """test emdat_impact_yearlysum yearly impact data extraction""" From ee4e853e1117d0c92e4a6b36fbbfe752166518a8 Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Thu, 7 Sep 2023 14:39:04 +0200 Subject: [PATCH 31/44] change versioning of develop: increase patch number by one otherwise the >=x.x configuration in petals setup doesn't work --- .github/scripts/setup_devbranch.py | 5 +++-- setup.py | 2 +- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/.github/scripts/setup_devbranch.py b/.github/scripts/setup_devbranch.py index 96ab60dbb..001390fa0 100644 --- a/.github/scripts/setup_devbranch.py +++ b/.github/scripts/setup_devbranch.py @@ -104,8 +104,9 @@ def setup_devbranch(): Just changes files, all `git` commands are in the setup_devbranch.sh file. """ main_version = get_last_version().strip('v') - - dev_version = f"{main_version}-dev" + semver = main_version.split(".") + semver[-1] = f"{int(semver[-1]) + 1}-dev" + dev_version = ".".join(semver) update_setup(dev_version) update_version(dev_version) diff --git a/setup.py b/setup.py index eb2e29637..7fa60b9e0 100644 --- a/setup.py +++ b/setup.py @@ -33,7 +33,7 @@ setup( name='climada', - version='4.0.0-dev', + version='4.0.1-dev', description='CLIMADA in Python', From 9b08d1fc5630bd58e5b73473d06b3281a575af53 Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Thu, 7 Sep 2023 14:41:55 +0200 Subject: [PATCH 32/44] relieve pandas <2 renstriction --- requirements/env_climada.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements/env_climada.yml b/requirements/env_climada.yml index ec1f11ce4..aaba3bba9 100644 --- a/requirements/env_climada.yml +++ b/requirements/env_climada.yml @@ -17,7 +17,7 @@ dependencies: - netcdf4>=1.6 - numba>=0.57 - openpyxl>=3.1 - - pandas>=1.5,<2.0 # 2.0 removed append and iteritems from DataFrame + - pandas>=1.5 - pandas-datareader>=0.10 - pathos>=0.3 - pint>=0.22 From 525842d42857839d77314361e913ae0824ea6924 Mon Sep 17 00:00:00 2001 From: "Chahan M. Kropf" Date: Mon, 11 Sep 2023 11:10:34 +0200 Subject: [PATCH 33/44] Doc/update readme (#778) * Add detailed citation recommendations * Small tweaks in readme * Remove preprint citation * Update README.md Co-authored-by: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> * Update README.md Co-authored-by: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> * Update README.md Co-authored-by: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> * Update README.md Co-authored-by: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> * Add citation guide * Update citation guide * Make citation guide an RST document. * Add table for recommended publications. * Rename REFERENCES.bib to climada_publications.bib * Add citation guide to documentation toctree. * Add documentation link for citation guide to README.md * Copy README.md to doc/misc/README.md --------- Co-authored-by: Chahan Kropf Co-authored-by: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> Co-authored-by: emanuel-schmid --- README.md | 28 +++++------- doc/index.rst | 3 ++ doc/misc/README.md | 28 +++++------- doc/misc/citation.rst | 42 ++++++++++++++++++ doc/misc/climada_publications.bib | 73 +++++++++++++++++++++++++++++++ 5 files changed, 138 insertions(+), 36 deletions(-) create mode 100644 doc/misc/citation.rst create mode 100644 doc/misc/climada_publications.bib diff --git a/README.md b/README.md index 908af1486..56f37a948 100644 --- a/README.md +++ b/README.md @@ -6,7 +6,8 @@ CLIMADA stands for **CLIM**ate **ADA**ptation and is a probabilistic natural catastrophe impact model, that also calculates averted damage (benefit) thanks to adaptation measures of any kind (from grey to green infrastructure, behavioural, etc.). -As of today, CLIMADA provides global coverage of major climate-related extreme-weather hazards at high resolution via a [data API](https://climada.ethz.ch/data-api/v1/docs), namely (i) tropical cyclones, (ii) river flood, (iii) agro drought and (iv) European winter storms, all at 4km spatial resolution - wildfire to be added soon. For all hazards, historic and probabilistic event sets exist, for some also under select climate forcing scenarios (RCPs) at distinct time horizons (e.g. 2040). See also [papers](https://github.com/CLIMADA-project/climada_papers) for details. +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). CLIMADA is divided into two parts (two repositories): @@ -15,30 +16,32 @@ CLIMADA is divided into two parts (two repositories): It is recommend for new users to begin with the core (1) and the [tutorials](https://github.com/CLIMADA-project/climada_python/tree/main/doc/tutorial) therein. -This is the Python (3.8+) version of CLIMADA - please see https://github.com/davidnbresch/climada for backward compatibility (MATLAB). +This is the Python (3.9+) version of CLIMADA - please see [here](https://github.com/davidnbresch/climada) for backward compatibility with the MATLAB version. ## Getting started CLIMADA runs on Windows, macOS and Linux. The released versions of the CLIMADA core can be installed directly through Anaconda: + ```shell conda install -c conda-forge climada ``` + It is **highly recommended** to install CLIMADA into a **separate** Anaconda environment. See the [installation guide](https://climada-python.readthedocs.io/en/latest/guide/install.html) for further information. -Follow the [tutorial](https://climada-python.readthedocs.io/en/latest/tutorial/1_main_climada.html) `climada_python-x.y.z/doc/tutorial/1_main_climada.ipynb` in a Jupyter Notebook to see what can be done with CLIMADA and how. +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. ## Documentation -Documentation is available on Read the Docs: +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). -Note that all the documentations has two versions,'latest' and 'stable', and explicit version numbers, such as 'v3.1.1', in the url path. 'latest' is created from the 'develop' branch and has the latest changes by developers, 'stable' from the latest release. For more details about documentation versions, please have a look at [here](https://readthedocs.org/projects/climada-python/versions/). 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) CLIMADA petals: @@ -50,23 +53,12 @@ The documentation can also be [built locally](https://climada-python.readthedocs ## Citing CLIMADA -If you use CLIMADA please cite (in general, in particular for academic work) : - -The [used version](https://zenodo.org/search?page=1&size=20&q=climada) - -and/or the following published articles: +See the [Citation Guide](https://climada-python.readthedocs.io/en/latest/misc/citation.html). -Aznar-Siguan, G. and Bresch, D. N., 2019: CLIMADA v1: a global weather and climate risk assessment platform, Geosci. Model Dev., 12, 3085–3097, https://doi.org/10.5194/gmd-12-3085-2019 +Please use the following logo if you are presenting results obtained with or through CLIMADA: -Bresch, D. N. and Aznar-Siguan, G., 2021: CLIMADA v1.4.1: towards a globally consistent adaptation options appraisal tool, Geosci. Model Dev., 14, 351-363, https://doi.org/10.5194/gmd-14-351-2021 - -Please see all CLIMADA-related scientific publications in our [repository of scientific publications](https://github.com/CLIMADA-project/climada_papers) and cite according to your use of select features, be it hazard set(s), exposure(s) ... - -In presentations or other graphical material, as well as in reports etc., where applicable, please add the logo as follows:\ ![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) -As key link, please use https://wcr.ethz.ch/research/climada.html, as it will last and provides a bit of an intro, especially for those not familiar with GitHub - plus a nice CLIMADA infographic towards the bottom of the page - ## Contributing See the [Contribution Guide](CONTRIBUTING.md). diff --git a/doc/index.rst b/doc/index.rst index 61a2d00bb..a76c98c6c 100644 --- a/doc/index.rst +++ b/doc/index.rst @@ -10,6 +10,8 @@ CLIMADA stands for CLIMate ADAptation and is a probabilistic natural catastrophe CLIMADA is primarily developed and maintained by the `Weather and Climate Risks Group `_ at `ETH Zürich `_. +If you use CLIMADA for your own scientific work, please reference the appropriate publications according to the :doc:`misc/citation`. + This is the documentation of the CLIMADA core module which contains all functionalities necessary for performing climate risk analysis and appraisal of adaptation options. Modules for generating different types of hazards and other specialized applications can be found in the `CLIMADA Petals `_ module. Jump right in: @@ -111,3 +113,4 @@ Jump right in: Changelog List of Authors Contribution Guide + misc/citation diff --git a/doc/misc/README.md b/doc/misc/README.md index 369cecb58..d39bb6700 100644 --- a/doc/misc/README.md +++ b/doc/misc/README.md @@ -2,7 +2,8 @@ CLIMADA stands for **CLIM**ate **ADA**ptation and is a probabilistic natural catastrophe impact model, that also calculates averted damage (benefit) thanks to adaptation measures of any kind (from grey to green infrastructure, behavioural, etc.). -As of today, CLIMADA provides global coverage of major climate-related extreme-weather hazards at high resolution via a [data API](https://climada.ethz.ch/data-api/v1/docs), namely (i) tropical cyclones, (ii) river flood, (iii) agro drought and (iv) European winter storms, all at 4km spatial resolution - wildfire to be added soon. For all hazards, historic and probabilistic event sets exist, for some also under select climate forcing scenarios (RCPs) at distinct time horizons (e.g. 2040). See also [papers](https://github.com/CLIMADA-project/climada_papers) for details. +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). CLIMADA is divided into two parts (two repositories): @@ -11,30 +12,32 @@ CLIMADA is divided into two parts (two repositories): It is recommend for new users to begin with the core (1) and the [tutorials](https://github.com/CLIMADA-project/climada_python/tree/main/doc/tutorial) therein. -This is the Python (3.8+) version of CLIMADA - please see https://github.com/davidnbresch/climada for backward compatibility (MATLAB). +This is the Python (3.9+) version of CLIMADA - please see [here](https://github.com/davidnbresch/climada) for backward compatibility with the MATLAB version. ## Getting started CLIMADA runs on Windows, macOS and Linux. The released versions of the CLIMADA core can be installed directly through Anaconda: + ```shell conda install -c conda-forge climada ``` + It is **highly recommended** to install CLIMADA into a **separate** Anaconda environment. See the [installation guide](https://climada-python.readthedocs.io/en/latest/guide/install.html) for further information. -Follow the [tutorial](https://climada-python.readthedocs.io/en/latest/tutorial/1_main_climada.html) `climada_python-x.y.z/doc/tutorial/1_main_climada.ipynb` in a Jupyter Notebook to see what can be done with CLIMADA and how. +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. ## Documentation -Documentation is available on Read the Docs: +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). -Note that all the documentations has two versions,'latest' and 'stable', and explicit version numbers, such as 'v3.1.1', in the url path. 'latest' is created from the 'develop' branch and has the latest changes by developers, 'stable' from the latest release. For more details about documentation versions, please have a look at [here](https://readthedocs.org/projects/climada-python/versions/). 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) CLIMADA petals: @@ -46,23 +49,12 @@ The documentation can also be [built locally](https://climada-python.readthedocs ## Citing CLIMADA -If you use CLIMADA please cite (in general, in particular for academic work) : - -The [used version](https://zenodo.org/search?page=1&size=20&q=climada) - -and/or the following published articles: +See the [Citation Guide](https://climada-python.readthedocs.io/en/latest/misc/citation.html). -Aznar-Siguan, G. and Bresch, D. N., 2019: CLIMADA v1: a global weather and climate risk assessment platform, Geosci. Model Dev., 12, 3085–3097, https://doi.org/10.5194/gmd-12-3085-2019 +Please use the following logo if you are presenting results obtained with or through CLIMADA: -Bresch, D. N. and Aznar-Siguan, G., 2021: CLIMADA v1.4.1: towards a globally consistent adaptation options appraisal tool, Geosci. Model Dev., 14, 351-363, https://doi.org/10.5194/gmd-14-351-2021 - -Please see all CLIMADA-related scientific publications in our [repository of scientific publications](https://github.com/CLIMADA-project/climada_papers) and cite according to your use of select features, be it hazard set(s), exposure(s) ... - -In presentations or other graphical material, as well as in reports etc., where applicable, please add the logo as follows:\ ![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) -As key link, please use https://wcr.ethz.ch/research/climada.html, as it will last and provides a bit of an intro, especially for those not familiar with GitHub - plus a nice CLIMADA infographic towards the bottom of the page - ## Contributing See the [Contribution Guide](CONTRIBUTING.md). diff --git a/doc/misc/citation.rst b/doc/misc/citation.rst new file mode 100644 index 000000000..cfc7d6650 --- /dev/null +++ b/doc/misc/citation.rst @@ -0,0 +1,42 @@ +============== +Citation Guide +============== + +If you use CLIMADA for your work, please cite the appropriate publications. +A list of all CLIMADA code related articles is available on `Zotero `_ and can be downloaded as single Bibtex file: :download:`climada_publications.bib` + + +Publications by Module +---------------------- + +If you use specific tools and modules of CLIMADA, please cite the appropriate publications presenting these modules according to the following table: + +.. list-table:: + :widths: 1 3 + :header-rows: 1 + + * - Module or tool used + - Publication to cite + * - *Any* + - The `Zenodo archive `_ of the CLIMADA version you are using + * - :doc:`Impact calculations ` + - Aznar-Siguan, G. and Bresch, D. N. (2019): CLIMADA v1: A global weather and climate risk assessment platform, Geosci. Model Dev., 12, 3085–3097, https://doi.org/10.5194/gmd-14-351-2021 + * - :doc:`Cost-benefit analysis ` + - Bresch, D. N. and Aznar-Siguan, G. (2021): CLIMADA v1.4.1: Towards a globally consistent adaptation options appraisal tool, Geosci. Model Dev., 14, 351–363, https://doi.org/10.5194/gmd-14-351-2021 + * - :doc:`Uncertainty and sensitivity analysis ` + - Kropf, C. M. et al. (2022): Uncertainty and sensitivity analysis for probabilistic weather and climate-risk modelling: an implementation in CLIMADA v.3.1.0. Geosci. Model Dev. 15, 7177–7201, https://doi.org/10.5194/gmd-15-7177-2022 + * - :doc:`Lines and polygons exposures ` *or* `Open Street Map exposures `_ + - Mühlhofer, E., et al. (2023): OpenStreetMap for Multi-Faceted Climate Risk Assessments https://eartharxiv.org/repository/view/5615/ + * - :doc:`LitPop exposures ` + - Eberenz, S., et al. (2020): Asset exposure data for global physical risk assessment. Earth System Science Data 12, 817–833, https://doi.org/10.3929/ethz-b-000409595 + +Please find the code to reprocduce selected CLIMADA-related scientific publications in our `repository of scientific publications `_. + +Links and Logo +-------------- + +In presentations or other graphical material, as well as in reports etc., where applicable, please add the following logo: :download:`climada_logo_QR.png `: + +.. image:: https://github.com/CLIMADA-project/climada_python/blob/main/doc/guide/img/CLIMADA_logo_QR.png?raw=true + +As key link, please use https://wcr.ethz.ch/research/climada.html, as it provides a brief introduction especially for those not familiar with GitHub. diff --git a/doc/misc/climada_publications.bib b/doc/misc/climada_publications.bib new file mode 100644 index 000000000..f00b9cc16 --- /dev/null +++ b/doc/misc/climada_publications.bib @@ -0,0 +1,73 @@ +@article{Aznar-Siguan2019, + title = {{{CLIMADA}} v1: A Global Weather and Climate Risk Assessment Platform}, + shorttitle = {{{CLIMADA}} V1}, + author = {{Aznar-Siguan}, Gabriela and Bresch, David N.}, + year = {2019}, + journal = {Geoscientific Model Development}, + volume = {12}, + number = {7}, + pages = {3085--3097}, + publisher = {{Copernicus GmbH}}, + issn = {1991-959X}, + doi = {10.5194/gmd-12-3085-2019} +} + +@article{Bresch2021, + title = {{{CLIMADA}} v1.4.1: Towards a Globally Consistent Adaptation Options Appraisal Tool}, + shorttitle = {{{CLIMADA}} v1.4.1}, + author = {Bresch, David N. and {Aznar-Siguan}, Gabriela}, + year = {2021}, + journal = {Geoscientific Model Development}, + volume = {14}, + number = {1}, + pages = {351--363}, + publisher = {{Copernicus GmbH}}, + issn = {1991-959X}, + doi = {10.5194/gmd-14-351-2021} +} + +@article{Eberenz2020, + title = {Asset Exposure Data for Global Physical Risk Assessment}, + author = {Eberenz, Samuel and Stocker, Dario and R{\"o}{\"o}sli, Thomas and Bresch, David N.}, + year = {2020}, + journal = {Earth System Science Data}, + volume = {12}, + number = {2}, + pages = {817--833}, + publisher = {{Copernicus GmbH}}, + issn = {1866-3508}, + doi = {10.5194/essd-12-817-2020} +} + +@article{Kropf2022c, + title = {Uncertainty and Sensitivity Analysis for Probabilistic Weather and Climate-Risk Modelling: An Implementation in {{CLIMADA}} v.3.1.0}, + shorttitle = {Uncertainty and Sensitivity Analysis for Probabilistic Weather and Climate-Risk Modelling}, + author = {Kropf, Chahan M. and Ciullo, Alessio and Otth, Laura and Meiler, Simona and Rana, Arun and Schmid, Emanuel and McCaughey, Jamie W. and Bresch, David N.}, + year = {2022}, + journal = {Geoscientific Model Development}, + volume = {15}, + number = {18}, + pages = {7177--7201}, + publisher = {{Copernicus GmbH}}, + issn = {1991-959X}, + doi = {10.5194/gmd-15-7177-2022} +} + +@article{Muhlhofer2023b, + title = {{{OpenStreetMap}} for {{Multi-Faceted Climate Risk Assessments}}}, + author = {M{\"u}hlhofer, Evelyn and Kropf, Chahan M. and Bresch, David N. and Koks, Elco E.}, + year = {2023}, + publisher = {{EarthArXiv}}, + url = {https://eartharxiv.org/repository/view/5615/} +} + +@article{Muhlhofer2023c, + title = {A Generalized Natural Hazard Risk Modelling Framework for Infrastructure Failure Cascades}, + author = {M{\"u}hlhofer, Evelyn and Koks, Elco E. and Kropf, Chahan M. and Sansavini, Giovanni and Bresch, David N.}, + year = {2023}, + journal = {Reliability Engineering \& System Safety}, + volume = {234}, + pages = {109194}, + issn = {0951-8320}, + doi = {10.1016/j.ress.2023.109194} +} From 4f3a73c803b47aaa6775a9c4762aad3b34d31251 Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Mon, 18 Sep 2023 15:26:21 +0200 Subject: [PATCH 34/44] move test_xy.py files to scrpt directory --- Makefile | 4 ++-- test_data_api.py => script/jenkins/test_data_api.py | 0 test_notebooks.py => script/jenkins/test_notebooks.py | 0 3 files changed, 2 insertions(+), 2 deletions(-) rename test_data_api.py => script/jenkins/test_data_api.py (100%) rename test_notebooks.py => script/jenkins/test_notebooks.py (100%) diff --git a/Makefile b/Makefile index 7364ab949..0e1f5491c 100644 --- a/Makefile +++ b/Makefile @@ -29,11 +29,11 @@ install_test : ## Test installation was successful .PHONY : data_test data_test : ## Test data APIs - python test_data_api.py + python script/jenkins/test_data_api.py .PHONY : notebook_test notebook_test : ## Test notebooks in doc/tutorial - python test_notebooks.py + python script/jenkins/test_notebooks.py .PHONY : integ_test integ_test : ## Integration tests execution with xml reports diff --git a/test_data_api.py b/script/jenkins/test_data_api.py similarity index 100% rename from test_data_api.py rename to script/jenkins/test_data_api.py diff --git a/test_notebooks.py b/script/jenkins/test_notebooks.py similarity index 100% rename from test_notebooks.py rename to script/jenkins/test_notebooks.py From 7dede0222e48d2817def07f96fb3b965d58e1060 Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Mon, 18 Sep 2023 16:33:03 +0200 Subject: [PATCH 35/44] move test_xy.py files to scrpt directory --- Makefile | 2 +- script/jenkins/test_data_api.py | 4 +++- script/jenkins/test_notebooks.py | 40 ++++++++++++++++---------------- 3 files changed, 24 insertions(+), 22 deletions(-) diff --git a/Makefile b/Makefile index 0e1f5491c..57c5a7035 100644 --- a/Makefile +++ b/Makefile @@ -33,7 +33,7 @@ data_test : ## Test data APIs .PHONY : notebook_test notebook_test : ## Test notebooks in doc/tutorial - python script/jenkins/test_notebooks.py + python script/jenkins/test_notebooks.py report .PHONY : integ_test integ_test : ## Integration tests execution with xml reports diff --git a/script/jenkins/test_data_api.py b/script/jenkins/test_data_api.py index ed047a739..42e910374 100644 --- a/script/jenkins/test_data_api.py +++ b/script/jenkins/test_data_api.py @@ -122,4 +122,6 @@ def test_icon_centroids_download(self): # Execute Tests if __name__ == '__main__': TESTS = unittest.TestLoader().loadTestsFromTestCase(TestDataAvail) - xmlrunner.XMLTestRunner(output=str(Path(__file__).parent.joinpath('tests_xml'))).run(TESTS) + from sys import argv + outputdir = argv[1] if len(argv) > 1 else str(Path.cwd().joinpath('tests_xml')) + xmlrunner.XMLTestRunner(output=outputdir).run(TESTS) diff --git a/script/jenkins/test_notebooks.py b/script/jenkins/test_notebooks.py index 1f89fce34..4fc4ca14d 100644 --- a/script/jenkins/test_notebooks.py +++ b/script/jenkins/test_notebooks.py @@ -10,8 +10,6 @@ import climada -NOTEBOOK_DIR = Path(__file__).parent.joinpath('doc', 'tutorial') -'''The path to the notebook directories.''' BOUND_TO_FAIL = '# Note: execution of this cell will fail' '''Cells containing this line will not be executed in the test''' @@ -19,6 +17,7 @@ EXCLUDED_FROM_NOTEBOOK_TEST = ['climada_installation_step_by_step.ipynb'] '''These notebooks are excluded from being tested''' + class NotebookTest(unittest.TestCase): '''Generic TestCase for testing the executability of notebooks @@ -117,10 +116,17 @@ def test_notebook(self): os.chdir(cwd) -def main(): +def main(install_dir): + import xmlrunner + + sys.path.append(str(install_dir)) + + notebook_dir = install_dir.joinpath('doc', 'tutorial') + '''The path to the notebook directories.''' + # list notebooks in the NOTEBOOK_DIR notebooks = [f.absolute() - for f in sorted(NOTEBOOK_DIR.iterdir()) + for f in sorted(notebook_dir.iterdir()) if os.path.splitext(f)[1] == ('.ipynb') and not f.name in EXCLUDED_FROM_NOTEBOOK_TEST] @@ -132,22 +138,16 @@ class NBTest(NotebookTest): pass setattr(NBTest, test_name, NBTest.test_notebook) suite.addTest(NBTest(test_name, notebook.parent, notebook.name)) - # run the tests depending on the first input argument: None or 'report'. - # write xml reports for 'report' - if sys.argv[1:]: - arg = sys.argv[1] - if arg == 'report': - import xmlrunner - outdirstr = str(Path(__file__).parent.joinpath('tests_xml')) - xmlrunner.XMLTestRunner(output=outdirstr).run(suite) - else: - jd, nb = os.path.split(arg) - unittest.TextTestRunner(verbosity=2).run(NotebookTest('test_notebook', jd, nb)) - # with no argument just run the test - else: - unittest.TextTestRunner(verbosity=2).run(suite) + # run the tests and write xml reports to tests_xml + output_dir = install_dir.joinpath('tests_xml') + xmlrunner.XMLTestRunner(output=str(output_dir)).run(suite) if __name__ == '__main__': - sys.path.append(str(Path.cwd())) - main() + if sys.argv[1] == 'report': + install_dir = Path(sys.argv[2]) if len(sys.argv) > 2 else Path.cwd() + main(install_dir) + + else: + jd, nb = os.path.split(sys.argv[1]) + unittest.TextTestRunner(verbosity=2).run(NotebookTest('test_notebook', jd, nb)) From 19da0d24e6a96ca03538c00ca6e7ebdb2ab69ab6 Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Mon, 18 Sep 2023 17:43:44 +0200 Subject: [PATCH 36/44] Lines Polygons Tutorial: from_footprint's signature has changed --- doc/tutorial/climada_entity_Exposures_polygons_lines.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/tutorial/climada_entity_Exposures_polygons_lines.ipynb b/doc/tutorial/climada_entity_Exposures_polygons_lines.ipynb index e4c004d9f..4adad4439 100644 --- a/doc/tutorial/climada_entity_Exposures_polygons_lines.ipynb +++ b/doc/tutorial/climada_entity_Exposures_polygons_lines.ipynb @@ -509,7 +509,7 @@ ], "source": [ "# define hazard\n", - "storms = StormEurope.from_footprints(WS_DEMO_NC, description='test_description')\n", + "storms = StormEurope.from_footprints(WS_DEMO_NC)\n", "# define impact function\n", "impf = ImpfStormEurope.from_welker()\n", "impf_set = ImpactFuncSet([impf])" From e9d88733631c09b6cf70f0e630e3dfc52eda1bff Mon Sep 17 00:00:00 2001 From: Emanuel Schmid <51439563+emanuel-schmid@users.noreply.github.com> Date: Tue, 19 Sep 2023 16:35:57 +0200 Subject: [PATCH 37/44] Move repository data into package (#781) * move package data * Update CHANGELOG.md * docs: adapt notebooks --- CHANGELOG.md | 2 ++ climada/__init__.py | 6 +++--- {data => climada/data}/demo/SC22000_VE__M1.grd.gz | Bin {data => climada/data}/demo/atl_prob_nonames.mat | Bin .../data}/demo/demo_emdat_impact_data_2020.csv | 0 {data => climada/data}/demo/demo_future_TEST.xlsx | Bin {data => climada/data}/demo/demo_today.xlsx | Bin .../data}/demo/earth_engine/dresden.tif | Bin .../demo/earth_engine/population-density_median.tif | Bin {data => climada/data}/demo/exp_demo_today.h5 | Bin {data => climada/data}/demo/fp_lothar_crop-test.nc | Bin {data => climada/data}/demo/fp_xynthia_crop-test.nc | Bin .../demo/ibtracs_global_intp-None_1992230N11325.csv | 0 {data => climada/data}/demo/nl_rails.gpkg | Bin {data => climada/data}/demo/tc_fl_1990_2004.h5 | Bin .../data}/system/FAOSTAT_data_country_codes.csv | 0 .../data}/system/GDP_TWN_IMF_WEO_data.csv | 0 .../data}/system/GLB_NatID_grid_0360as_adv_2.mat | Bin {data => climada/data}/system/GSDP/AUS_GSDP.xls | Bin {data => climada/data}/system/GSDP/BRA_GSDP.xls | Bin {data => climada/data}/system/GSDP/CAN_GSDP.xls | Bin {data => climada/data}/system/GSDP/CHE_GSDP.xls | Bin {data => climada/data}/system/GSDP/CHN_GSDP.xls | Bin {data => climada/data}/system/GSDP/DEU_GSDP.xls | Bin {data => climada/data}/system/GSDP/FRA_GSDP.xls | Bin {data => climada/data}/system/GSDP/IDN_GSDP.xls | Bin {data => climada/data}/system/GSDP/IND_GSDP.xls | Bin {data => climada/data}/system/GSDP/JPN_GSDP.xls | Bin {data => climada/data}/system/GSDP/MEX_GSDP.xls | Bin {data => climada/data}/system/GSDP/TUR_GSDP.xls | Bin {data => climada/data}/system/GSDP/USA_GSDP.xls | Bin {data => climada/data}/system/GSDP/ZAF_GSDP.xls | Bin .../data}/system/NatEarth_Centroids_150as.hdf5 | Bin .../data}/system/NatEarth_Centroids_360as.hdf5 | Bin {data => climada/data}/system/NatID_grid_0150as.nc | Bin {data => climada/data}/system/NatRegIDs.csv | 0 .../data}/system/WEALTH2GDP_factors_CRI_2016.csv | 0 {data => climada/data}/system/entity_template.xlsx | Bin {data => climada/data}/system/hazard_template.xlsx | Bin {data => climada/data}/system/rcp_db.xls | Bin .../data}/system/tc_impf_cal_v01_EDR.csv | 0 .../data}/system/tc_impf_cal_v01_RMSF.csv | 0 .../data}/system/tc_impf_cal_v01_TDR1.0.csv | 0 .../data}/system/tc_impf_cal_v01_TDR1.5.csv | 0 doc/guide/Guide_Euler.ipynb | 2 +- doc/tutorial/1_main_climada.ipynb | 2 +- doc/tutorial/climada_entity_DiscRates.ipynb | 2 +- doc/tutorial/climada_entity_Exposures.ipynb | 2 +- doc/tutorial/climada_entity_ImpactFuncSet.ipynb | 2 +- doc/tutorial/climada_entity_MeasureSet.ipynb | 2 +- doc/tutorial/climada_hazard_Hazard.ipynb | 2 +- doc/tutorial/climada_hazard_TropCyclone.ipynb | 4 ++-- setup.py | 12 +++++------- 53 files changed, 19 insertions(+), 19 deletions(-) rename {data => climada/data}/demo/SC22000_VE__M1.grd.gz (100%) mode change 100755 => 100644 rename {data => climada/data}/demo/atl_prob_nonames.mat (100%) rename {data => climada/data}/demo/demo_emdat_impact_data_2020.csv (100%) rename {data => climada/data}/demo/demo_future_TEST.xlsx (100%) rename {data => climada/data}/demo/demo_today.xlsx (100%) rename {data => climada/data}/demo/earth_engine/dresden.tif (100%) mode change 100755 => 100644 rename {data => climada/data}/demo/earth_engine/population-density_median.tif (100%) mode change 100755 => 100644 rename {data => climada/data}/demo/exp_demo_today.h5 (100%) rename {data => climada/data}/demo/fp_lothar_crop-test.nc (100%) rename {data => climada/data}/demo/fp_xynthia_crop-test.nc (100%) rename {data => climada/data}/demo/ibtracs_global_intp-None_1992230N11325.csv (100%) rename {data => climada/data}/demo/nl_rails.gpkg (100%) rename {data => climada/data}/demo/tc_fl_1990_2004.h5 (100%) rename {data => climada/data}/system/FAOSTAT_data_country_codes.csv (100%) rename {data => climada/data}/system/GDP_TWN_IMF_WEO_data.csv (100%) rename {data => climada/data}/system/GLB_NatID_grid_0360as_adv_2.mat (100%) rename {data => climada/data}/system/GSDP/AUS_GSDP.xls (100%) rename {data => climada/data}/system/GSDP/BRA_GSDP.xls (100%) rename {data => climada/data}/system/GSDP/CAN_GSDP.xls (100%) rename {data => climada/data}/system/GSDP/CHE_GSDP.xls (100%) rename {data => climada/data}/system/GSDP/CHN_GSDP.xls (100%) rename {data => climada/data}/system/GSDP/DEU_GSDP.xls (100%) rename {data => climada/data}/system/GSDP/FRA_GSDP.xls (100%) rename {data => climada/data}/system/GSDP/IDN_GSDP.xls (100%) rename {data => climada/data}/system/GSDP/IND_GSDP.xls (100%) rename {data => climada/data}/system/GSDP/JPN_GSDP.xls (100%) rename {data => climada/data}/system/GSDP/MEX_GSDP.xls (100%) rename {data => climada/data}/system/GSDP/TUR_GSDP.xls (100%) rename {data => climada/data}/system/GSDP/USA_GSDP.xls (100%) rename {data => climada/data}/system/GSDP/ZAF_GSDP.xls (100%) rename {data => climada/data}/system/NatEarth_Centroids_150as.hdf5 (100%) rename {data => climada/data}/system/NatEarth_Centroids_360as.hdf5 (100%) rename {data => climada/data}/system/NatID_grid_0150as.nc (100%) mode change 100755 => 100644 rename {data => climada/data}/system/NatRegIDs.csv (100%) rename {data => climada/data}/system/WEALTH2GDP_factors_CRI_2016.csv (100%) rename {data => climada/data}/system/entity_template.xlsx (100%) rename {data => climada/data}/system/hazard_template.xlsx (100%) rename {data => climada/data}/system/rcp_db.xls (100%) rename {data => climada/data}/system/tc_impf_cal_v01_EDR.csv (100%) rename {data => climada/data}/system/tc_impf_cal_v01_RMSF.csv (100%) rename {data => climada/data}/system/tc_impf_cal_v01_TDR1.0.csv (100%) rename {data => climada/data}/system/tc_impf_cal_v01_TDR1.5.csv (100%) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2c270940c..9d60ac6bc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -14,6 +14,8 @@ Code freeze date: YYYY-MM-DD ### Changed +- Rearranged file-system structure: `data` directory moved into `climada` package directory. [#781](https://github.com/CLIMADA-project/climada_python/pull/781) + ### Fixed ### Deprecated diff --git a/climada/__init__.py b/climada/__init__.py index f3f7245dc..8fc4b8764 100755 --- a/climada/__init__.py +++ b/climada/__init__.py @@ -28,7 +28,7 @@ GSDP_DIR = SYSTEM_DIR.joinpath('GSDP') REPO_DATA = { - 'data/system': [ + 'climada/data/system': [ ISIMIP_GPWV3_NATID_150AS, GLB_CENTROIDS_MAT, ENT_TEMPLATE_XLS, @@ -44,12 +44,12 @@ SYSTEM_DIR.joinpath('tc_impf_cal_v01_EDR.csv'), SYSTEM_DIR.joinpath('tc_impf_cal_v01_RMSF.csv'), ], - 'data/system/GSDP': [ + 'climada/data/system/GSDP': [ GSDP_DIR.joinpath(f'{cc}_GSDP.xls') for cc in ['AUS', 'BRA', 'CAN', 'CHE', 'CHN', 'DEU', 'FRA', 'IDN', 'IND', 'JPN', 'MEX', 'TUR', 'USA', 'ZAF'] ], - 'data/demo': [ + 'climada/data/demo': [ ENT_DEMO_TODAY, ENT_DEMO_FUTURE, EXP_DEMO_H5, diff --git a/data/demo/SC22000_VE__M1.grd.gz b/climada/data/demo/SC22000_VE__M1.grd.gz old mode 100755 new mode 100644 similarity index 100% rename from data/demo/SC22000_VE__M1.grd.gz rename to climada/data/demo/SC22000_VE__M1.grd.gz diff --git a/data/demo/atl_prob_nonames.mat b/climada/data/demo/atl_prob_nonames.mat similarity index 100% rename from data/demo/atl_prob_nonames.mat rename to climada/data/demo/atl_prob_nonames.mat diff --git a/data/demo/demo_emdat_impact_data_2020.csv b/climada/data/demo/demo_emdat_impact_data_2020.csv similarity index 100% rename from data/demo/demo_emdat_impact_data_2020.csv rename to climada/data/demo/demo_emdat_impact_data_2020.csv diff --git a/data/demo/demo_future_TEST.xlsx b/climada/data/demo/demo_future_TEST.xlsx similarity index 100% rename from data/demo/demo_future_TEST.xlsx rename to climada/data/demo/demo_future_TEST.xlsx diff --git a/data/demo/demo_today.xlsx b/climada/data/demo/demo_today.xlsx similarity index 100% rename from data/demo/demo_today.xlsx rename to climada/data/demo/demo_today.xlsx diff --git a/data/demo/earth_engine/dresden.tif b/climada/data/demo/earth_engine/dresden.tif old mode 100755 new mode 100644 similarity index 100% rename from data/demo/earth_engine/dresden.tif rename to climada/data/demo/earth_engine/dresden.tif diff --git a/data/demo/earth_engine/population-density_median.tif b/climada/data/demo/earth_engine/population-density_median.tif old mode 100755 new mode 100644 similarity index 100% rename from data/demo/earth_engine/population-density_median.tif rename to climada/data/demo/earth_engine/population-density_median.tif diff --git a/data/demo/exp_demo_today.h5 b/climada/data/demo/exp_demo_today.h5 similarity index 100% rename from data/demo/exp_demo_today.h5 rename to climada/data/demo/exp_demo_today.h5 diff --git a/data/demo/fp_lothar_crop-test.nc b/climada/data/demo/fp_lothar_crop-test.nc similarity index 100% rename from data/demo/fp_lothar_crop-test.nc rename to climada/data/demo/fp_lothar_crop-test.nc diff --git a/data/demo/fp_xynthia_crop-test.nc b/climada/data/demo/fp_xynthia_crop-test.nc similarity index 100% rename from data/demo/fp_xynthia_crop-test.nc rename to climada/data/demo/fp_xynthia_crop-test.nc diff --git a/data/demo/ibtracs_global_intp-None_1992230N11325.csv b/climada/data/demo/ibtracs_global_intp-None_1992230N11325.csv similarity index 100% rename from data/demo/ibtracs_global_intp-None_1992230N11325.csv rename to climada/data/demo/ibtracs_global_intp-None_1992230N11325.csv diff --git a/data/demo/nl_rails.gpkg b/climada/data/demo/nl_rails.gpkg similarity index 100% rename from data/demo/nl_rails.gpkg rename to climada/data/demo/nl_rails.gpkg diff --git a/data/demo/tc_fl_1990_2004.h5 b/climada/data/demo/tc_fl_1990_2004.h5 similarity index 100% rename from data/demo/tc_fl_1990_2004.h5 rename to climada/data/demo/tc_fl_1990_2004.h5 diff --git a/data/system/FAOSTAT_data_country_codes.csv b/climada/data/system/FAOSTAT_data_country_codes.csv similarity index 100% rename from data/system/FAOSTAT_data_country_codes.csv rename to climada/data/system/FAOSTAT_data_country_codes.csv diff --git a/data/system/GDP_TWN_IMF_WEO_data.csv b/climada/data/system/GDP_TWN_IMF_WEO_data.csv similarity index 100% rename from data/system/GDP_TWN_IMF_WEO_data.csv rename to climada/data/system/GDP_TWN_IMF_WEO_data.csv diff --git a/data/system/GLB_NatID_grid_0360as_adv_2.mat b/climada/data/system/GLB_NatID_grid_0360as_adv_2.mat similarity index 100% rename from data/system/GLB_NatID_grid_0360as_adv_2.mat rename to climada/data/system/GLB_NatID_grid_0360as_adv_2.mat diff --git a/data/system/GSDP/AUS_GSDP.xls b/climada/data/system/GSDP/AUS_GSDP.xls similarity index 100% rename from data/system/GSDP/AUS_GSDP.xls rename to climada/data/system/GSDP/AUS_GSDP.xls diff --git a/data/system/GSDP/BRA_GSDP.xls b/climada/data/system/GSDP/BRA_GSDP.xls similarity index 100% rename from data/system/GSDP/BRA_GSDP.xls rename to climada/data/system/GSDP/BRA_GSDP.xls diff --git a/data/system/GSDP/CAN_GSDP.xls b/climada/data/system/GSDP/CAN_GSDP.xls similarity index 100% rename from data/system/GSDP/CAN_GSDP.xls rename to climada/data/system/GSDP/CAN_GSDP.xls diff --git a/data/system/GSDP/CHE_GSDP.xls b/climada/data/system/GSDP/CHE_GSDP.xls similarity index 100% rename from data/system/GSDP/CHE_GSDP.xls rename to climada/data/system/GSDP/CHE_GSDP.xls diff --git a/data/system/GSDP/CHN_GSDP.xls b/climada/data/system/GSDP/CHN_GSDP.xls similarity index 100% rename from data/system/GSDP/CHN_GSDP.xls rename to climada/data/system/GSDP/CHN_GSDP.xls diff --git a/data/system/GSDP/DEU_GSDP.xls b/climada/data/system/GSDP/DEU_GSDP.xls similarity index 100% rename from data/system/GSDP/DEU_GSDP.xls rename to climada/data/system/GSDP/DEU_GSDP.xls diff --git a/data/system/GSDP/FRA_GSDP.xls b/climada/data/system/GSDP/FRA_GSDP.xls similarity index 100% rename from data/system/GSDP/FRA_GSDP.xls rename to climada/data/system/GSDP/FRA_GSDP.xls diff --git a/data/system/GSDP/IDN_GSDP.xls b/climada/data/system/GSDP/IDN_GSDP.xls similarity index 100% rename from data/system/GSDP/IDN_GSDP.xls rename to climada/data/system/GSDP/IDN_GSDP.xls diff --git a/data/system/GSDP/IND_GSDP.xls b/climada/data/system/GSDP/IND_GSDP.xls similarity index 100% rename from data/system/GSDP/IND_GSDP.xls rename to climada/data/system/GSDP/IND_GSDP.xls diff --git a/data/system/GSDP/JPN_GSDP.xls b/climada/data/system/GSDP/JPN_GSDP.xls similarity index 100% rename from data/system/GSDP/JPN_GSDP.xls rename to climada/data/system/GSDP/JPN_GSDP.xls diff --git a/data/system/GSDP/MEX_GSDP.xls b/climada/data/system/GSDP/MEX_GSDP.xls similarity index 100% rename from data/system/GSDP/MEX_GSDP.xls rename to climada/data/system/GSDP/MEX_GSDP.xls diff --git a/data/system/GSDP/TUR_GSDP.xls b/climada/data/system/GSDP/TUR_GSDP.xls similarity index 100% rename from data/system/GSDP/TUR_GSDP.xls rename to climada/data/system/GSDP/TUR_GSDP.xls diff --git a/data/system/GSDP/USA_GSDP.xls b/climada/data/system/GSDP/USA_GSDP.xls similarity index 100% rename from data/system/GSDP/USA_GSDP.xls rename to climada/data/system/GSDP/USA_GSDP.xls diff --git a/data/system/GSDP/ZAF_GSDP.xls b/climada/data/system/GSDP/ZAF_GSDP.xls similarity index 100% rename from data/system/GSDP/ZAF_GSDP.xls rename to climada/data/system/GSDP/ZAF_GSDP.xls diff --git a/data/system/NatEarth_Centroids_150as.hdf5 b/climada/data/system/NatEarth_Centroids_150as.hdf5 similarity index 100% rename from data/system/NatEarth_Centroids_150as.hdf5 rename to climada/data/system/NatEarth_Centroids_150as.hdf5 diff --git a/data/system/NatEarth_Centroids_360as.hdf5 b/climada/data/system/NatEarth_Centroids_360as.hdf5 similarity index 100% rename from data/system/NatEarth_Centroids_360as.hdf5 rename to climada/data/system/NatEarth_Centroids_360as.hdf5 diff --git a/data/system/NatID_grid_0150as.nc b/climada/data/system/NatID_grid_0150as.nc old mode 100755 new mode 100644 similarity index 100% rename from data/system/NatID_grid_0150as.nc rename to climada/data/system/NatID_grid_0150as.nc diff --git a/data/system/NatRegIDs.csv b/climada/data/system/NatRegIDs.csv similarity index 100% rename from data/system/NatRegIDs.csv rename to climada/data/system/NatRegIDs.csv diff --git a/data/system/WEALTH2GDP_factors_CRI_2016.csv b/climada/data/system/WEALTH2GDP_factors_CRI_2016.csv similarity index 100% rename from data/system/WEALTH2GDP_factors_CRI_2016.csv rename to climada/data/system/WEALTH2GDP_factors_CRI_2016.csv diff --git a/data/system/entity_template.xlsx b/climada/data/system/entity_template.xlsx similarity index 100% rename from data/system/entity_template.xlsx rename to climada/data/system/entity_template.xlsx diff --git a/data/system/hazard_template.xlsx b/climada/data/system/hazard_template.xlsx similarity index 100% rename from data/system/hazard_template.xlsx rename to climada/data/system/hazard_template.xlsx diff --git a/data/system/rcp_db.xls b/climada/data/system/rcp_db.xls similarity index 100% rename from data/system/rcp_db.xls rename to climada/data/system/rcp_db.xls diff --git a/data/system/tc_impf_cal_v01_EDR.csv b/climada/data/system/tc_impf_cal_v01_EDR.csv similarity index 100% rename from data/system/tc_impf_cal_v01_EDR.csv rename to climada/data/system/tc_impf_cal_v01_EDR.csv diff --git a/data/system/tc_impf_cal_v01_RMSF.csv b/climada/data/system/tc_impf_cal_v01_RMSF.csv similarity index 100% rename from data/system/tc_impf_cal_v01_RMSF.csv rename to climada/data/system/tc_impf_cal_v01_RMSF.csv diff --git a/data/system/tc_impf_cal_v01_TDR1.0.csv b/climada/data/system/tc_impf_cal_v01_TDR1.0.csv similarity index 100% rename from data/system/tc_impf_cal_v01_TDR1.0.csv rename to climada/data/system/tc_impf_cal_v01_TDR1.0.csv diff --git a/data/system/tc_impf_cal_v01_TDR1.5.csv b/climada/data/system/tc_impf_cal_v01_TDR1.5.csv similarity index 100% rename from data/system/tc_impf_cal_v01_TDR1.5.csv rename to climada/data/system/tc_impf_cal_v01_TDR1.5.csv diff --git a/doc/guide/Guide_Euler.ipynb b/doc/guide/Guide_Euler.ipynb index db3bff221..ee6ddccd9 100644 --- a/doc/guide/Guide_Euler.ipynb +++ b/doc/guide/Guide_Euler.ipynb @@ -111,7 +111,7 @@ "{\n", " \"local_data\": {\n", " \"system\": \"/cluster/work/climate/USERNAME/climada/data\",\n", - " \"demo\": \"/cluster/project/climate/USERNAME/climada_python/data/demo\",\n", + " \"demo\": \"/cluster/project/climate/USERNAME/climada/data/demo\",\n", " \"save_dir\": \"/cluster/work/climate/USERNAME/climada/results\"\n", " }\n", "}\n", diff --git a/doc/tutorial/1_main_climada.ipynb b/doc/tutorial/1_main_climada.ipynb index c8a8b269d..8c78b96fa 100644 --- a/doc/tutorial/1_main_climada.ipynb +++ b/doc/tutorial/1_main_climada.ipynb @@ -480,7 +480,7 @@ "\n", "The entity class is a container class that stores exposures and impact functions (vulnerability curves) needed for a risk calculation, and the discount rates and adaptation measures for an adaptation cost-benefit analysis.\n", "\n", - "As with Hazard objects, Entities can be read from files or created through code. The Excel template can be found in `climada_python/data/system/entity_template.xlsx`.\n", + "As with Hazard objects, Entities can be read from files or created through code. The Excel template can be found in `climada_python/climada/data/system/entity_template.xlsx`.\n", "\n", "In this tutorial we will create an Exposure object using the LitPop economic exposure module, and load a pre-defined wind damage function." ] diff --git a/doc/tutorial/climada_entity_DiscRates.ipynb b/doc/tutorial/climada_entity_DiscRates.ipynb index c88cdc18f..3d33797d1 100644 --- a/doc/tutorial/climada_entity_DiscRates.ipynb +++ b/doc/tutorial/climada_entity_DiscRates.ipynb @@ -87,7 +87,7 @@ "source": [ "## Read discount rates of an Excel file\n", "\n", - "Discount rates defined in an excel file following the template provided in sheet `discount` of `climada_python/data/system/entity_template.xlsx` can be ingested directly using the method `from_excel()`." + "Discount rates defined in an excel file following the template provided in sheet `discount` of `climada_python/climada/data/system/entity_template.xlsx` can be ingested directly using the method `from_excel()`." ] }, { diff --git a/doc/tutorial/climada_entity_Exposures.ipynb b/doc/tutorial/climada_entity_Exposures.ipynb index c2c3990dc..ee6dac22f 100644 --- a/doc/tutorial/climada_entity_Exposures.ipynb +++ b/doc/tutorial/climada_entity_Exposures.ipynb @@ -883,7 +883,7 @@ "### Exposures from an excel file\n", "\n", "If you manually collect exposure data, Excel may be your preferred option. \n", - "In this case, it is easiest if you format your data according to the structure provided in the template `climada_python/data/system/entity_template.xlsx`, in the sheet `assets`." + "In this case, it is easiest if you format your data according to the structure provided in the template `climada_python/climada/data/system/entity_template.xlsx`, in the sheet `assets`." ] }, { diff --git a/doc/tutorial/climada_entity_ImpactFuncSet.ipynb b/doc/tutorial/climada_entity_ImpactFuncSet.ipynb index 05989b913..b59aead9f 100644 --- a/doc/tutorial/climada_entity_ImpactFuncSet.ipynb +++ b/doc/tutorial/climada_entity_ImpactFuncSet.ipynb @@ -442,7 +442,7 @@ "source": [ "#### Reading impact functions from an Excel file\n", "\n", - "Impact functions defined in an excel file following the template provided in sheet `impact_functions` of `climada_python/data/system/entity_template.xlsx` can be ingested directly using the method `from_excel()`." + "Impact functions defined in an excel file following the template provided in sheet `impact_functions` of `climada_python/climada/data/system/entity_template.xlsx` can be ingested directly using the method `from_excel()`." ] }, { diff --git a/doc/tutorial/climada_entity_MeasureSet.ipynb b/doc/tutorial/climada_entity_MeasureSet.ipynb index 5170f02c4..aae3aaeac 100644 --- a/doc/tutorial/climada_entity_MeasureSet.ipynb +++ b/doc/tutorial/climada_entity_MeasureSet.ipynb @@ -21,7 +21,7 @@ " * name (str): name of the action\n", " * haz_type (str): related hazard type (peril), e.g. TC\n", " * color_rgb (np.array): integer array of size 3. Gives color code of this measure in RGB\n", - " * cost (float): discounted cost (in same units as assets). Needs to be provided by the user. See the example provided in `climada_python/data/system/entity_template.xlsx` sheets `_measures_details` and `_discounting_sheet` to see how the discounting is done.\n", + " * cost (float): discounted cost (in same units as assets). Needs to be provided by the user. See the example provided in `climada_python/climada/data/system/entity_template.xlsx` sheets `_measures_details` and `_discounting_sheet` to see how the discounting is done.\n", " \n", "Related to a measure's impact:\n", " * hazard_set (str): file name of hazard to use\n", diff --git a/doc/tutorial/climada_hazard_Hazard.ipynb b/doc/tutorial/climada_hazard_Hazard.ipynb index 9c250c4dd..2375b5d97 100644 --- a/doc/tutorial/climada_hazard_Hazard.ipynb +++ b/doc/tutorial/climada_hazard_Hazard.ipynb @@ -224,7 +224,7 @@ " \n", "## Part 2: Read hazards from other data\n", "\n", - "- excel: Hazards can be read from Excel files following the template in `climada_python/data/system/hazard_template.xlsx` using the `from_excel()` method. \n", + "- excel: Hazards can be read from Excel files following the template in `climada_python/climada/data/system/hazard_template.xlsx` using the `from_excel()` method. \n", "- MATLAB: Hazards generated with CLIMADA's MATLAB version (.mat format) can be read using `from_mat()`.\n", "- vector data: Use `Hazard`'s `from_vector`-constructor to read shape data (all formats supported by [fiona](https://fiona.readthedocs.io/en/latest/manual.html)).\n", "- hdf5: Hazards generated with the CLIMADA in Python (.h5 format) can be read using `from_hdf5()`." diff --git a/doc/tutorial/climada_hazard_TropCyclone.ipynb b/doc/tutorial/climada_hazard_TropCyclone.ipynb index e6c18d0e9..f7940b866 100644 --- a/doc/tutorial/climada_hazard_TropCyclone.ipynb +++ b/doc/tutorial/climada_hazard_TropCyclone.ipynb @@ -99,9 +99,9 @@ " \n", "## a) Load TC tracks from historical records\n", "\n", - "The best-track historical data from the International Best Track Archive for Climate Stewardship ([IBTrACS](https://www.ncdc.noaa.gov/ibtracs/)) can easily be loaded into CLIMADA to study the historical records of TC events. The constructor `from_ibtracs_netcdf()` generates the `Datasets` for tracks selected by [IBTrACS](https://www.ncdc.noaa.gov/ibtracs/) id, or by basin and year range. To achieve this, it downloads the first time the [IBTrACS data v4 in netcdf format](https://www.ncei.noaa.gov/data/international-best-track-archive-for-climate-stewardship-ibtracs/v04r00/access/netcdf/) and stores it in `climada_python/data/system`. The tracks can be accessed later either using the attribute `data` or using `get_track()`, which allows to select tracks by its name or id. Use the method `append()` to extend the `data` list.\n", + "The best-track historical data from the International Best Track Archive for Climate Stewardship ([IBTrACS](https://www.ncdc.noaa.gov/ibtracs/)) can easily be loaded into CLIMADA to study the historical records of TC events. The constructor `from_ibtracs_netcdf()` generates the `Datasets` for tracks selected by [IBTrACS](https://www.ncdc.noaa.gov/ibtracs/) id, or by basin and year range. To achieve this, it downloads the first time the [IBTrACS data v4 in netcdf format](https://www.ncei.noaa.gov/data/international-best-track-archive-for-climate-stewardship-ibtracs/v04r00/access/netcdf/) and stores it in `~/climada/data/`. The tracks can be accessed later either using the attribute `data` or using `get_track()`, which allows to select tracks by its name or id. Use the method `append()` to extend the `data` list.\n", "\n", - "If you get an error downloading the IBTrACS data, try to manually access [https://www.ncei.noaa.gov/data/international-best-track-archive-for-climate-stewardship-ibtracs/v04r00/access/netcdf/](https://www.ncei.noaa.gov/data/international-best-track-archive-for-climate-stewardship-ibtracs/v04r00/access/netcdf/), click on the file `IBTrACS.ALL.v04r00.nc` and copy it to `climada_python/data/system`.\n", + "If you get an error downloading the IBTrACS data, try to manually access [https://www.ncei.noaa.gov/data/international-best-track-archive-for-climate-stewardship-ibtracs/v04r00/access/netcdf/](https://www.ncei.noaa.gov/data/international-best-track-archive-for-climate-stewardship-ibtracs/v04r00/access/netcdf/), click on the file `IBTrACS.ALL.v04r00.nc` and copy it to `~/climada/data/`.\n", "\n", "To visualize the tracks use `plot()`.\n" ] diff --git a/setup.py b/setup.py index 7fa60b9e0..61444de6a 100644 --- a/setup.py +++ b/setup.py @@ -2,7 +2,7 @@ """ from pathlib import Path -from setuptools import find_packages, setup +from setuptools import setup, find_namespace_packages here = Path(__file__).parent.absolute() @@ -48,9 +48,6 @@ license='OSI Approved :: GNU Lesser General Public License v3 (GPLv3)', classifiers=[ - # 3 - Alpha - # 4 - Beta - # 5 - Production/Stable 'Development Status :: 4 - Beta', 'Programming Language :: Python :: 3.9', 'Topic :: Scientific/Engineering :: Atmospheric Science', @@ -60,8 +57,6 @@ keywords='climate adaptation', - packages=find_packages() + ['data'], - install_requires=[ 'bottleneck', 'cartopy', @@ -104,5 +99,8 @@ "dev": DEPS_DOC + DEPS_TEST }, - include_package_data=True + packages=find_namespace_packages(include=['climada*']), + + setup_requires=['setuptools_scm'], + include_package_data=True, ) From 36953fcd5dce887bbe80cbfb975c9fc1bf8a412e Mon Sep 17 00:00:00 2001 From: Emanuel Schmid <51439563+emanuel-schmid@users.noreply.github.com> Date: Wed, 20 Sep 2023 08:54:01 +0200 Subject: [PATCH 38/44] Fix empty data frame concatenation in emdat_impact_yearlysum (#783) * engine.impact_data.emdat_impact_yearlysum: fix concatenation of empty datasets * changelog * undo previous commit * Use DataFrame.from_records for initializing This avoids creating an empty dataframe. --------- Co-authored-by: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> --- climada/engine/impact_data.py | 64 +++++++++++++++---------- climada/engine/test/test_impact_data.py | 2 - 2 files changed, 40 insertions(+), 26 deletions(-) diff --git a/climada/engine/impact_data.py b/climada/engine/impact_data.py index f8cde2838..805773220 100644 --- a/climada/engine/impact_data.py +++ b/climada/engine/impact_data.py @@ -802,30 +802,46 @@ def emdat_impact_yearlysum(emdat_file_csv, countries=None, hazard=None, year_ran df_data[imp_str + " scaled"] = scale_impact2refyear(df_data[imp_str].values, df_data.Year.values, df_data.ISO.values, reference_year=reference_year) - out = pd.DataFrame(columns=['ISO', 'region_id', 'year', 'impact', - 'impact_scaled', 'reference_year']) - for country in df_data.ISO.unique(): - country = u_coord.country_to_iso(country, "alpha3") - if not df_data.loc[df_data.ISO == country].size: - continue - all_years = np.arange(min(df_data.Year), max(df_data.Year) + 1) - data_out = pd.DataFrame(index=np.arange(0, len(all_years)), - columns=out.columns) - df_country = df_data.loc[df_data.ISO == country] - for cnt, year in enumerate(all_years): - data_out.loc[cnt, 'year'] = year - data_out.loc[cnt, 'reference_year'] = reference_year - data_out.loc[cnt, 'ISO'] = country - data_out.loc[cnt, 'region_id'] = u_coord.country_to_iso(country, "numeric") - data_out.loc[cnt, 'impact'] = \ - np.nansum(df_country[df_country.Year.isin([year])][imp_str]) - data_out.loc[cnt, 'impact_scaled'] = \ - np.nansum(df_country[df_country.Year.isin([year])][imp_str + " scaled"]) - if '000 US' in imp_str: # EM-DAT damages provided in '000 USD - data_out.loc[cnt, 'impact'] = data_out.loc[cnt, 'impact'] * 1e3 - data_out.loc[cnt, 'impact_scaled'] = data_out.loc[cnt, 'impact_scaled'] * 1e3 - out = pd.concat([out, data_out]) - out = out.reset_index(drop=True) + + def country_df(df_data): + for data_iso in df_data.ISO.unique(): + country = u_coord.country_to_iso(data_iso, "alpha3") + + df_country = df_data.loc[df_data.ISO == country] + if not df_country.size: + continue + + # Retrieve impact data for all years + all_years = np.arange(min(df_data.Year), max(df_data.Year) + 1) + data_out = pd.DataFrame.from_records( + [ + ( + year, + np.nansum(df_country[df_country.Year.isin([year])][imp_str]), + np.nansum( + df_country[df_country.Year.isin([year])][ + imp_str + " scaled" + ] + ), + ) + for year in all_years + ], + columns=["year", "impact", "impact_scaled"] + ) + + # Add static data + data_out["reference_year"] = reference_year + data_out["ISO"] = country + data_out["region_id"] = u_coord.country_to_iso(country, "numeric") + + # EMDAT provides damage data in 1000 USD + if "000 US" in imp_str: + data_out["impact"] = data_out["impact"] * 1e3 + data_out["impact_scaled"] = data_out["impact_scaled"] * 1e3 + + yield data_out + + out = pd.concat(list(country_df(df_data)), ignore_index=True) return out diff --git a/climada/engine/test/test_impact_data.py b/climada/engine/test/test_impact_data.py index 4fe2de39e..ccb3d966a 100644 --- a/climada/engine/test/test_impact_data.py +++ b/climada/engine/test/test_impact_data.py @@ -156,8 +156,6 @@ def test_emdat_impact_yearlysum_no_futurewarning(self): reference_year=None, imp_str="Total Affected", ) - # TODO: pandas 2.1 will eventually raise a FutureWarning here, - # but about array concatenation of empty entries. fix it! def test_emdat_affected_yearlysum(self): """test emdat_impact_yearlysum yearly impact data extraction""" From d8eaf55a7d7b3294d45dc773b5c8f7baaf633a38 Mon Sep 17 00:00:00 2001 From: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> Date: Wed, 20 Sep 2023 08:58:09 +0200 Subject: [PATCH 39/44] Use GitHub actions for unit testing (#745) * Add GitHub Actions and Dockerfile for test environment * Fix env var query in github workflow * Revert "Fix env var query in github workflow" This reverts commit dc37cec82c4d2749a10e517dcbe33a489c5a6be2. * Try specifying Docker tag with variables * Hardcode Docker Hub namespace * Conditionally run jobs and try to fix unittest job * Fix syntax error in github workflow * Do not call make in github workflow * Try fixing the shell inside Docker container for github workflow * Call micromamba directly in github workflow * Use 'micromamba install' because 'update' does not update pip deps * Split GitHub workflows * Consolidate GitHub Workflows * Try fixing syntax for GitHub workflow expression * Fix typo in docker workflow * Fix list input for docker.yml workflow * Run all tests in GitHub workflow * Do not use 'defaults' in workflow * Fix stray 'defaults' in workflow * Rename testing steps * Do not use multiprocessing for integration tests * Revert climada.conf to 9302bf2a * Revert "Do not use multiprocessing for integration tests" This reverts commit 9be863270d43b840536c4752ab7298807c03e5ca. The command does not actually use multiprocessing but makes coverage aware of multiprocessing used by the called tests. * Skip failing integration tests for now * Add action to publish test results * Run pipeline on branches and pull requests * Grant permissions from top-level job * Use other XML test reports for displaying results * Add new workflow using micromamba directly * Add data and notebook tests to new workflow * Separately build conda environment This avoids building a new environment for every job. * Add integration tests and separate test result reporting * Fix missing 'runs-on' * ci: Add ipython to extra requirements * ci: Fix publish results * Fix permissions. * Fix path to artifacts. * Remove all but the mamba pipelines * Run test matrix with different Python versions Remove version pip for Python in environment specs. * Fix Python version parsing in CI * Add linting job to CI * Skip integration tests in GitHub CI * Use custom conda environment cache key in CI * Add matchers and custom linting step to CI * Ignore pylint errors in CI * ci: Debug matcher path * ci: Lint with ruff * ci: Fix Python target version for ruff * ci: Add permissions for publishing checks to test job * Revert "ci: Lint with ruff" This reverts commits 41bb4c2e2fe29a2c1ed0afd85bf93904f7f3fb49 and 60ee28fb2bab149ab5559ef319a17173ca4a3e8f. * Update CI configuration * Use new micromamba action. * Do not lint. * Upload coverage reports as artifacts. * Report test results for every Python version individually. * Stop testing Python 3.11 due to incompatibilities with dataclass * Revert "Stop testing Python 3.11 due to incompatibilities with dataclass" This reverts commit 6ed83e65c72da24a556d78a3addbd4ed45692807. * Set environment caching for GitHub workflow * Remove unused files * Fix mutable default values in ImpactFreqCurve * Fix Nightlight and LitPop tests * Move file checks to integration tests. They require file downloads. * Fix assertion for almost equal arrays. * Fix accuracy in default Emanuel impact func test * Improve names in Github CI * Disallow Python 3.11 for Climada The unsequa module throws segmentation faults while unit testing. * Try testing Python v3.11 again * Improve GitHub Actions documentation * Add introduction to GitHub Actions to the docs. * Add information to the CI guide. * Improve comments in the ci.yml workflow definition. --- .github/workflows/ci.yml | 70 +++++++++++++++++++ climada/engine/impact.py | 6 +- climada/entity/exposures/test/test_litpop.py | 2 +- .../entity/exposures/test/test_nightlight.py | 52 -------------- climada/entity/impact_funcs/test/test_tc.py | 39 +++++++---- climada/test/test_nightlight.py | 52 ++++++++++++++ ...e_Continuous_Integration_and_Testing.ipynb | 7 +- doc/guide/github-actions.rst | 29 ++++++++ doc/index.rst | 1 + requirements/env_climada.yml | 2 +- setup.py | 2 + 11 files changed, 189 insertions(+), 73 deletions(-) create mode 100644 .github/workflows/ci.yml create mode 100644 doc/guide/github-actions.rst diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 000000000..686ec1e9a --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,70 @@ +name: GitHub CI + +# Execute this for every push +on: [push] + +# Use bash explicitly for being able to enter the conda environment +defaults: + run: + shell: bash -l {0} + +jobs: + build-and-test: + name: Build Env, Install, Unit Tests + runs-on: ubuntu-latest + permissions: + # For publishing results + checks: write + + # Run this test for different Python versions + strategy: + # Do not abort other tests if only a single one fails + fail-fast: false + matrix: + python-version: ["3.9", "3.10", "3.11"] + + steps: + - + name: Checkout Repo + uses: actions/checkout@v3 + - + # Store the current date to use it as cache key for the environment + name: Get current date + id: date + run: echo "date=$(date +%Y-%m-%d)" >> "${GITHUB_OUTPUT}" + - + name: Create Environment with Mamba + uses: mamba-org/setup-micromamba@v1 + with: + environment-name: climada_env_${{ matrix.python-version }} + environment-file: requirements/env_climada.yml + create-args: >- + python=${{ matrix.python-version }} + make + init-shell: >- + bash + # Persist environment for branch, Python version, single day + cache-environment-key: env-${{ github.ref }}-${{ matrix.python-version }}-${{ steps.date.outputs.date }} + - + name: Install CLIMADA + run: | + python -m pip install ".[test]" + - + name: Run Unit Tests + run: | + make unit_test + - + name: Publish Test Results + uses: EnricoMi/publish-unit-test-result-action@v2 + if: always() + with: + junit_files: tests_xml/tests.xml + check_name: "Unit Test Results Python ${{ matrix.python-version }}" + comment_mode: "off" + - + name: Upload Coverage Reports + if: always() + uses: actions/upload-artifact@v3 + with: + name: coverage-report-unittests-py${{ matrix.python-version }} + path: coverage/ diff --git a/climada/engine/impact.py b/climada/engine/impact.py index c1cbb8fc2..68033641f 100644 --- a/climada/engine/impact.py +++ b/climada/engine/impact.py @@ -21,7 +21,7 @@ __all__ = ['ImpactFreqCurve', 'Impact'] -from dataclasses import dataclass +from dataclasses import dataclass, field import logging import copy import csv @@ -1785,10 +1785,10 @@ class ImpactFreqCurve(): """Impact exceedence frequency curve. """ - return_per : np.array = np.array([]) + return_per : np.ndarray = field(default_factory=lambda: np.empty(0)) """return period""" - impact : np.array = np.array([]) + impact : np.ndarray = field(default_factory=lambda: np.empty(0)) """impact exceeding frequency""" unit : str = '' diff --git a/climada/entity/exposures/test/test_litpop.py b/climada/entity/exposures/test/test_litpop.py index 851c910fb..d8ec001cd 100644 --- a/climada/entity/exposures/test/test_litpop.py +++ b/climada/entity/exposures/test/test_litpop.py @@ -317,7 +317,7 @@ def test_gridpoints_core_calc_offsets_exp_rescale(self): self.assertEqual(result_array.shape, results_check.shape) self.assertAlmostEqual(result_array.sum(), tot) self.assertEqual(result_array[1,2], results_check[1,2]) - np.testing.assert_array_almost_equal_nulp(result_array, results_check) + np.testing.assert_allclose(result_array, results_check) def test_grp_read_pass(self): """test _grp_read() to pass and return either dict with admin1 values or None""" diff --git a/climada/entity/exposures/test/test_nightlight.py b/climada/entity/exposures/test/test_nightlight.py index f7158ac77..f7b83b6a4 100644 --- a/climada/entity/exposures/test/test_nightlight.py +++ b/climada/entity/exposures/test/test_nightlight.py @@ -56,22 +56,6 @@ def test_required_files(self): self.assertRaises(ValueError, nightlight.get_required_nl_files, (-90, 90)) - def test_check_files_exist(self): - """Test check_nightlight_local_file_exists""" - # If invalid directory is supplied it has to fail - try: - nightlight.check_nl_local_file_exists( - np.ones(np.count_nonzero(BM_FILENAMES)), 'Invalid/path')[0] - raise Exception("if the path is not valid, check_nl_local_file_exists should fail") - except ValueError: - pass - files_exist = nightlight.check_nl_local_file_exists( - np.ones(np.count_nonzero(BM_FILENAMES)), SYSTEM_DIR) - self.assertTrue( - files_exist.sum() > 0, - f'{files_exist} {BM_FILENAMES}' - ) - def test_download_nightlight_files(self): """Test check_nightlight_local_file_exists""" # Not the same length of arguments @@ -118,42 +102,6 @@ def test_get_required_nl_files(self): bool = np.array_equal(np.array([0, 0, 0, 0, 0, 0, 1, 0]), req_files) self.assertTrue(bool) - def test_check_nl_local_file_exists(self): - """ Test that an array with the correct number of already existing files - is produced, the LOGGER messages logged and the ValueError raised. """ - - # check logger messages by giving a to short req_file - with self.assertLogs('climada.entity.exposures.litpop.nightlight', level='WARNING') as cm: - nightlight.check_nl_local_file_exists(required_files = np.array([0, 0, 1, 1])) - self.assertIn('The parameter \'required_files\' was too short and is ignored', - cm.output[0]) - - # check logger message: not all files are available - with self.assertLogs('climada.entity.exposures.litpop.nightlight', level='DEBUG') as cm: - nightlight.check_nl_local_file_exists() - self.assertIn('Not all satellite files available. Found ', cm.output[0]) - self.assertIn(f' out of 8 required files in {Path(SYSTEM_DIR)}', cm.output[0]) - - # check logger message: no files found in checkpath - check_path = Path('climada/entity/exposures') - with self.assertLogs('climada.entity.exposures.litpop.nightlight', level='INFO') as cm: - # using a random path where no files are stored - nightlight.check_nl_local_file_exists(check_path=check_path) - self.assertIn(f'No satellite files found locally in {check_path}', - cm.output[0]) - - # test raises with wrong path - check_path = Path('/random/wrong/path') - with self.assertRaises(ValueError) as cm: - nightlight.check_nl_local_file_exists(check_path=check_path) - self.assertEqual(f'The given path does not exist: {check_path}', - str(cm.exception)) - - # test that files_exist is correct - files_exist = nightlight.check_nl_local_file_exists() - self.assertGreaterEqual(int(sum(files_exist)), 3) - self.assertLessEqual(int(sum(files_exist)), 8) - # Execute Tests if __name__ == "__main__": TESTS = unittest.TestLoader().loadTestsFromTestCase(TestNightLight) diff --git a/climada/entity/impact_funcs/test/test_tc.py b/climada/entity/impact_funcs/test/test_tc.py index c469b12a1..e2db9e609 100644 --- a/climada/entity/impact_funcs/test/test_tc.py +++ b/climada/entity/impact_funcs/test/test_tc.py @@ -39,21 +39,30 @@ def test_default_values_pass(self): self.assertTrue(np.array_equal(imp_fun.intensity, np.arange(0, 121, 5))) self.assertTrue(np.array_equal(imp_fun.paa, np.ones((25,)))) self.assertTrue(np.array_equal(imp_fun.mdd[0:6], np.zeros((6,)))) - self.assertTrue(np.array_equal(imp_fun.mdd[6:10], - np.array([0.0006753419543492556, 0.006790495604105169, - 0.02425254393374475, 0.05758706257339458]))) - self.assertTrue(np.array_equal(imp_fun.mdd[10:15], - np.array([0.10870556455111065, 0.1761433569521351, - 0.2553983618763961, 0.34033822528795565, - 0.4249447743109498]))) - self.assertTrue(np.array_equal(imp_fun.mdd[15:20], - np.array([0.5045777092933046, 0.576424302849412, - 0.6393091739184916, 0.6932203123193963, - 0.7388256596555696]))) - self.assertTrue(np.array_equal(imp_fun.mdd[20:25], - np.array([0.777104531116526, 0.8091124649261859, - 0.8358522190681132, 0.8582150905529946, - 0.8769633232141456]))) + np.testing.assert_allclose( + imp_fun.mdd[6:25], + [ + 0.0006753419543492556, + 0.006790495604105169, + 0.02425254393374475, + 0.05758706257339458, + 0.10870556455111065, + 0.1761433569521351, + 0.2553983618763961, + 0.34033822528795565, + 0.4249447743109498, + 0.5045777092933046, + 0.576424302849412, + 0.6393091739184916, + 0.6932203123193963, + 0.7388256596555696, + 0.777104531116526, + 0.8091124649261859, + 0.8358522190681132, + 0.8582150905529946, + 0.8769633232141456, + ], + ) def test_values_pass(self): """Compute mdr interpolating values.""" diff --git a/climada/test/test_nightlight.py b/climada/test/test_nightlight.py index ce571cef2..caa05820d 100644 --- a/climada/test/test_nightlight.py +++ b/climada/test/test_nightlight.py @@ -254,6 +254,58 @@ def test_untar_noaa_stable_nighlight(self): self.assertIn('found more than one potential intensity file in', cm.output[0]) path_tar.unlink() + def test_check_nl_local_file_exists(self): + """ Test that an array with the correct number of already existing files + is produced, the LOGGER messages logged and the ValueError raised. """ + + # check logger messages by giving a to short req_file + with self.assertLogs('climada.entity.exposures.litpop.nightlight', level='WARNING') as cm: + nightlight.check_nl_local_file_exists(required_files = np.array([0, 0, 1, 1])) + self.assertIn('The parameter \'required_files\' was too short and is ignored', + cm.output[0]) + + # check logger message: not all files are available + with self.assertLogs('climada.entity.exposures.litpop.nightlight', level='DEBUG') as cm: + nightlight.check_nl_local_file_exists() + self.assertIn('Not all satellite files available. Found ', cm.output[0]) + self.assertIn(f' out of 8 required files in {Path(SYSTEM_DIR)}', cm.output[0]) + + # check logger message: no files found in checkpath + check_path = Path('climada/entity/exposures') + with self.assertLogs('climada.entity.exposures.litpop.nightlight', level='INFO') as cm: + # using a random path where no files are stored + nightlight.check_nl_local_file_exists(check_path=check_path) + self.assertIn(f'No satellite files found locally in {check_path}', + cm.output[0]) + + # test raises with wrong path + check_path = Path('/random/wrong/path') + with self.assertRaises(ValueError) as cm: + nightlight.check_nl_local_file_exists(check_path=check_path) + self.assertEqual(f'The given path does not exist: {check_path}', + str(cm.exception)) + + # test that files_exist is correct + files_exist = nightlight.check_nl_local_file_exists() + self.assertGreaterEqual(int(sum(files_exist)), 3) + self.assertLessEqual(int(sum(files_exist)), 8) + + def test_check_files_exist(self): + """Test check_nightlight_local_file_exists""" + # If invalid directory is supplied it has to fail + try: + nightlight.check_nl_local_file_exists( + np.ones(np.count_nonzero(BM_FILENAMES)), 'Invalid/path')[0] + raise Exception("if the path is not valid, check_nl_local_file_exists should fail") + except ValueError: + pass + files_exist = nightlight.check_nl_local_file_exists( + np.ones(np.count_nonzero(BM_FILENAMES)), SYSTEM_DIR) + self.assertTrue( + files_exist.sum() > 0, + f'{files_exist} {BM_FILENAMES}' + ) + # Execute Tests if __name__ == "__main__": TESTS = unittest.TestLoader().loadTestsFromTestCase(TestNightlight) diff --git a/doc/guide/Guide_Continuous_Integration_and_Testing.ipynb b/doc/guide/Guide_Continuous_Integration_and_Testing.ipynb index fa6383471..ce1800d50 100644 --- a/doc/guide/Guide_Continuous_Integration_and_Testing.ipynb +++ b/doc/guide/Guide_Continuous_Integration_and_Testing.ipynb @@ -299,7 +299,12 @@ "\n", "- All tests must pass before submitting a pull request.\n", "- Integration tests don't run on feature branches in Jenkins, therefore developers are requested to run them locally.\n", - "- After a pull request was accepted and the changes are merged to the develop branch, integration tests may still fail there and have to be addressed." + "- After a pull request was accepted and the changes are merged to the develop branch, integration tests may still fail there and have to be addressed.\n", + "\n", + "#### GitHub Actions\n", + "\n", + "We adopted test automation via GitHub Actions in an experimental state.\n", + "See [GitHub Actions CI](github-actions.rst) for details." ] }, { diff --git a/doc/guide/github-actions.rst b/doc/guide/github-actions.rst new file mode 100644 index 000000000..efaddc276 --- /dev/null +++ b/doc/guide/github-actions.rst @@ -0,0 +1,29 @@ +================= +GitHub Actions CI +================= + +CLIMADA has been using a private Jenkins instance for automated testing (Continuous Integration, CI), see :doc:`Guide_Continuous_Integration_and_Testing`. +We recently adopted `GitHub Actions `_ for automated unit testing. +GitHub Actions is a service provided by GitHub, which lets you configure CI/CD pipelines based on YAML configuration files. +GitHub provides servers which ample computational resources to create software environments, install software, test it, and deploy it. +See the `GitHub Actions Overview `_ for a technical introduction, and the `Workflow Syntax `_ for a reference of the pipeline definitions. + +The CI results for each pull request can be inspected in the "Checks" tab. +For GitHub Actions, users can inspect the logs of every step for every job. + +.. note:: + + As of CLIMADA v4.0, the default CI technology remains Jenkins. + GitHub Actions CI is currently considered experimental for CLIMADA development. + +--------------------- +Unit Testing Pipeline +--------------------- + +This pipeline is defined by the ``.github/workflows/ci.yml`` file. +It contains a single job which will create a CLIMADA environment with Mamba for multiple Python versions, install CLIMADA, run the unit tests, and report the test coverage as well as the simplified test results. +The job has a `strategy `_ which runs it for multiple times for different Python versions. +This way, we make sure that CLIMADA is compatible with all currently supported versions of Python. + +The coverage reports in HTML format will be uploaded as job artifacts and can be downloaded as ZIP files. +The test results are simple testing summaries that will appear as individual checks/jobs after the respective job completed. diff --git a/doc/index.rst b/doc/index.rst index a76c98c6c..58bb92f1f 100644 --- a/doc/index.rst +++ b/doc/index.rst @@ -103,6 +103,7 @@ Jump right in: Performance and Best Practices Coding Conventions Building the Documentation + guide/github-actions .. toctree:: diff --git a/requirements/env_climada.yml b/requirements/env_climada.yml index aaba3bba9..6f1726f4f 100644 --- a/requirements/env_climada.yml +++ b/requirements/env_climada.yml @@ -26,7 +26,7 @@ dependencies: - pycountry>=22.3 - pyepsg>=0.4 - pytables>=3.7 - - python=3.9 + - python>=3.9,<3.12 - pyxlsb>=1.0 - rasterio>=1.3 - requests>=2.31 diff --git a/setup.py b/setup.py index 61444de6a..7cccbdad9 100644 --- a/setup.py +++ b/setup.py @@ -57,6 +57,8 @@ keywords='climate adaptation', + python_requires=">=3.9,<3.12", + install_requires=[ 'bottleneck', 'cartopy', From b0cca35e361cf6d8ac608db7441adf4bedf1c6fb Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Wed, 20 Sep 2023 10:35:57 +0200 Subject: [PATCH 40/44] notebook_test: don't fail on `EventPools` --- script/jenkins/test_notebooks.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/script/jenkins/test_notebooks.py b/script/jenkins/test_notebooks.py index 4fc4ca14d..870aff386 100644 --- a/script/jenkins/test_notebooks.py +++ b/script/jenkins/test_notebooks.py @@ -92,7 +92,7 @@ def test_notebook(self): and not ln.startswith('ask_ok(') and not ln.startswith('pool') # by convention Pool objects are called pool and not ln.strip().endswith('?') - and not 'Pool(' in ln # prevent Pool object creation + and re.search(r'(\W|^)Pool\(', ln) # prevent Pool object creation ]) # execute the python code From e792768340467cd281a1921326ceca540a76f15b Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Wed, 20 Sep 2023 11:55:20 +0200 Subject: [PATCH 41/44] test_notebooks: fix broken cell filter --- script/jenkins/test_notebooks.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/script/jenkins/test_notebooks.py b/script/jenkins/test_notebooks.py index 870aff386..bb0420194 100644 --- a/script/jenkins/test_notebooks.py +++ b/script/jenkins/test_notebooks.py @@ -92,7 +92,7 @@ def test_notebook(self): and not ln.startswith('ask_ok(') and not ln.startswith('pool') # by convention Pool objects are called pool and not ln.strip().endswith('?') - and re.search(r'(\W|^)Pool\(', ln) # prevent Pool object creation + and not re.search(r'(\W|^)Pool\(', ln) # prevent Pool object creation ]) # execute the python code From 185ef967cdd6a37510421b7d1a69871ed7e4f20d Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Tue, 26 Sep 2023 16:21:09 +0200 Subject: [PATCH 42/44] env_climada: pin python to 3.9, upgrade matplotlib, geopandas and pandas --- requirements/env_climada.yml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/requirements/env_climada.yml b/requirements/env_climada.yml index 6f1726f4f..42d77e533 100644 --- a/requirements/env_climada.yml +++ b/requirements/env_climada.yml @@ -10,14 +10,14 @@ dependencies: - dask>=2023 - eccodes>=2.27,<2.28 # 2.28 changed some labels, in particular: gust -> i20fg - gdal>=3.6 - - geopandas>=0.13 + - geopandas>=0.14 - h5py>=3.8 - haversine>=2.8 - - matplotlib>=3.7 + - matplotlib-base>=3.8 - netcdf4>=1.6 - numba>=0.57 - openpyxl>=3.1 - - pandas>=1.5 + - pandas>=2.1 - pandas-datareader>=0.10 - pathos>=0.3 - pint>=0.22 @@ -26,7 +26,7 @@ dependencies: - pycountry>=22.3 - pyepsg>=0.4 - pytables>=3.7 - - python>=3.9,<3.12 + - python=3.9 - pyxlsb>=1.0 - rasterio>=1.3 - requests>=2.31 From 49937dd3c17831fc3c0862cd486142c1294b5a4e Mon Sep 17 00:00:00 2001 From: Emanuel Schmid <51439563+emanuel-schmid@users.noreply.github.com> Date: Tue, 26 Sep 2023 17:30:35 +0200 Subject: [PATCH 43/44] Antimeridian issue in `get_country_code` (#785) * define longitudinal extent by biggest gap rather than min/max * normalize all the way * coordinates.get_country_code: use laton_boudaries instead * coordinates.get_country_code: swap extent order * changelog --- CHANGELOG.md | 2 ++ climada/util/coordinates.py | 5 ++--- climada/util/test/test_coordinates.py | 1 + 3 files changed, 5 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 9d60ac6bc..79ed90e60 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -18,6 +18,8 @@ Code freeze date: YYYY-MM-DD ### Fixed +- `climada.util.coordinates.get_country_code` bug, occurring with non-standard longitudinal coordinates around the anti-meridian. [#770](https://github.com/CLIMADA-project/climada_python/issues/770) + ### Deprecated ### Removed diff --git a/climada/util/coordinates.py b/climada/util/coordinates.py index 60b6b9602..2699344da 100644 --- a/climada/util/coordinates.py +++ b/climada/util/coordinates.py @@ -1539,9 +1539,8 @@ def get_country_code(lat, lon, gridded=False): method='nearest', fill_value=0) region_id = region_id.astype(int) else: - extent = (lon.min() - 0.001, lon.max() + 0.001, - lat.min() - 0.001, lat.max() + 0.001) - countries = get_country_geometries(extent=extent) + (lon_min, lat_min, lon_max, lat_max) = latlon_bounds(lat, lon, 0.001) + countries = get_country_geometries(extent=(lon_min, lon_max, lat_min, lat_max)) with warnings.catch_warnings(): # in order to suppress the following # UserWarning: Geometry is in a geographic CRS. Results from 'area' are likely diff --git a/climada/util/test/test_coordinates.py b/climada/util/test/test_coordinates.py index 552b6c47d..46c39456d 100644 --- a/climada/util/test/test_coordinates.py +++ b/climada/util/test/test_coordinates.py @@ -492,6 +492,7 @@ def test_country_to_iso(self): self.assertEqual(u_coord.country_natid2iso(natid_list), al3_list) self.assertEqual(u_coord.country_natid2iso(natid_list[1]), al3_list[1]) + class TestAssign(unittest.TestCase): """Test coordinate assignment functions""" From 1dae5a7cdb779528a90a13bc14b2d21f269ad891 Mon Sep 17 00:00:00 2001 From: climada Date: Wed, 27 Sep 2023 11:48:20 +0000 Subject: [PATCH 44/44] setup develop branch for v4.0.2-dev --- CHANGELOG.md | 31 +++++++++++++++++++++++++++---- climada/_version.py | 2 +- setup.py | 2 +- 3 files changed, 29 insertions(+), 6 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 79ed90e60..483fe8bc7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -14,16 +14,39 @@ Code freeze date: YYYY-MM-DD ### Changed -- Rearranged file-system structure: `data` directory moved into `climada` package directory. [#781](https://github.com/CLIMADA-project/climada_python/pull/781) - ### Fixed -- `climada.util.coordinates.get_country_code` bug, occurring with non-standard longitudinal coordinates around the anti-meridian. [#770](https://github.com/CLIMADA-project/climada_python/issues/770) - ### Deprecated ### Removed +## 4.0.1 + +Release date: 2023-09-27 + +### Dependency Changes + +Added: + +- `matplotlib-base` None → >=3.8 + +Changed: + +- `geopandas` >=0.13 → >=0.14 +- `pandas` >=1.5,<2.0 → >=2.1 + +Removed: + +- `matplotlib` >=3.7 + +### Changed + +- Rearranged file-system structure: `data` directory moved into `climada` package directory. [#781](https://github.com/CLIMADA-project/climada_python/pull/781) + +### Fixed + +- `climada.util.coordinates.get_country_code` bug, occurring with non-standard longitudinal coordinates around the anti-meridian. [#770](https://github.com/CLIMADA-project/climada_python/issues/770) + ## 4.0.0 Release date: 2023-09-01 diff --git a/climada/_version.py b/climada/_version.py index b23e59d45..d9cfbbef3 100644 --- a/climada/_version.py +++ b/climada/_version.py @@ -1 +1 @@ -__version__ = '4.0.0-dev' +__version__ = '4.0.2-dev' diff --git a/setup.py b/setup.py index 7cccbdad9..1aff5d0ca 100644 --- a/setup.py +++ b/setup.py @@ -33,7 +33,7 @@ setup( name='climada', - version='4.0.1-dev', + version='4.0.2-dev', description='CLIMADA in Python',