From a31fb0345592f2672ece8f8526efee5bb74dc3e9 Mon Sep 17 00:00:00 2001 From: Rolf Hut Date: Thu, 14 Nov 2024 22:24:40 +0100 Subject: [PATCH] added first (wrong!!!) content. needs fixing, for now setting up structure --- README.md | 56 +- book/_toc.yml | 8 +- .../intro_BSc_GeltSteiger.md | 6 + .../overview_thesis_projects.md | 6 + .../example_model_run_HBV.ipynb | 669 +++++++++ .../example_model_run_pcrglobwb.ipynb | 1318 +++++++++++++++++ .../generate_clonemaps.ipynb | 115 ++ .../generate_forcing.ipynb | 322 ++++ .../pcrglobwb_uk_05min.ini | 466 ++++++ .../intro_tutorials_examples.md | 16 + 10 files changed, 2926 insertions(+), 56 deletions(-) create mode 100644 book/thesis_projects/BSc/2023_Q4_GeltSteiger_CEG/intro_BSc_GeltSteiger.md create mode 100644 book/thesis_projects/overview_thesis_projects.md create mode 100644 book/tutorials_examples/1_HBV_Caravan_ERA5/example_model_run_HBV.ipynb create mode 100644 book/tutorials_examples/2_HBV_PCRGlobWB_ERA5/example_model_run_pcrglobwb.ipynb create mode 100644 book/tutorials_examples/2_HBV_PCRGlobWB_ERA5/generate_clonemaps.ipynb create mode 100644 book/tutorials_examples/2_HBV_PCRGlobWB_ERA5/generate_forcing.ipynb create mode 100644 book/tutorials_examples/2_HBV_PCRGlobWB_ERA5/pcrglobwb_uk_05min.ini create mode 100644 book/tutorials_examples/intro_tutorials_examples.md diff --git a/README.md b/README.md index a110da5..ddacf5c 100644 --- a/README.md +++ b/README.md @@ -1,55 +1,3 @@ -# Your first TeachBook using the GitHub template +# This repo collect projects that showcase how eWatercycle works, including student projects. -The template allows you to start your own TeachBook and hosting that TeachBook online without knowledge on Git, the Jupyter book package, python or anaconda. It doesn't elaborate on the collaborative functionalities of Git or how to edit the book. Please look at our manual (https://teachbooks.tudelft.nl/jupyter-book-manual) to find more about that! - -## Features -- A github repository structure for making a [Jupyter Book](https://github.com/executablebooks/jupyter-book) (`/book`) -- An empty TeachBook containing an intro page on root, an example markdown page, an example jupyter notebook page, an example references page. and an example credits page. (`/book/_toc.yml`, `/book/_config.yml`, `/book/credits.md`, `/book/intro.md`, `/book/references.md`, `/book/some_content/overview.md`, `/book/some_content/text_and_code.ipynb`) -- A file ready for adding references (`references.bib`, `/book/references.md`) -- An example favicon (web browser icon) (`/book/figures/favicon.ico`, `book/_config.yml`.) -- An example logo (`/book/figures/TUDelft_logo_rgb.png`, `/book/config.yml`) -- The configuration files set ready to make your Jupyter Notebooks pages work with [live code using our sphinx-thebe extension](https://teachbooks.tudelft.nl/jupyter-book-manual/features/live_code.html) and our recommended settings (`/book/config.yml`) -- An example of setting up preprocessing your table of contents to hide certain draft chapters for eg. students (`_toc.yml`) -- A file containing all the recommended software packages (`requirements.txt`) -- A file containing the recommended license CC BY 4.0 (`LICENSE.md`) -- Our [GitHub workflow for publishing your TeachBook to GitHub Pages](https://github.com/TeachBooks/deploy-book-workflow) (`.github/workflow/call-deploy-book.yml`) -- A gitignore file containing standard python filetype to ignore (`.gitignore`) -- A readme containing information how to use the template, which can adjusted after using the template (`README.md`) - -## How to get started - -How to use the template is demonstrated in the figure below, all steps are elaborated on in the following step-by-step tutorial. - -![Demonstration for a public repository](figures/teachbooks-template.gif) -Video available [here](https://youtu.be/nN3Oi_MVvF0) - - -1. To get started making your TeachBook with our functionalities, use the [template TeachBook](https://github.com/TeachBooks/template) as template: - -![Use template](figures/use_template.png) - -2. Fill in a repository name, this name will be used in the future url of your book: - -![Create new repository](figures/create_new_repository.png) - -3. You can choose for `Private` only if you've GitHub Pro, GitHub Team, GitHub Enterprise Cloud, or GitHub Enterprise Server. Otherwise, you won't be able to publish your TeachBook online. - -4. (Only required for private repositories:) Create a Personal Access Token (classic) with at least the scopes `repo`, `read:org` and `gist` as described in the [github documentation](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens), and add this token with the name `GH_PAT` as a `Repository secret` or `Organization secret` (`Settings` > `Secrets and variables` > `Actions` > `Repository secrets` or `Organization secrets`). - -5. You need to activate GitHub pages so that your website is published to the internet. As long as you don't do this your TeachBook is not published online. Actually, now that you've taken this template our workflow tries to publish it to GitHub pages, which you didn't have the chance to activate yet. That's why you probably received an email with 'call-deploy-book: Some jobs were not successful' and you see the failed job under `Initial commit`. You can activate GitHub pages by setting the source for GitHub pages to GitHub Actions under `Settings` - `Pages` - `Build and deployment` - `Source` - `GitHub Actions`: - -![Activate GitHub Pages](figures/set_up_pages.png) - -6. Make an edit to the TeachBook by editing and committing changes to one of the files in the `book/` subdirectory (available under `Code`). Now checkout the progress of the publishing workflow under `Actions` - `All workflows` - `call-deploy-book` -``. Remember, the first commit which is there has failed because GitHub Pages wasn't activated at the time of `Initial commit`, you could also re-run that job if you don't want to make an edit. You can do so by running the workflow from `Actions` - `All workflows` - `call-deploy-book` - `Initial commit` - `Re-run all jobs` - `Re-run jobs`: - -![Action](figures/action_re-run.jpeg) - -7. When the workflow has finished, visit your build TeachBook at `https://.github.io/` (case sensitive). For our example it is [https://dummydocent.github.io/test_book_from_template/](https://dummydocent.github.io/test_book_from_template/) for the shown repository. These links are visible in the action's summary as well, as shown in the figure of step 4. - -Additional tip: -Set the repository website as your GitHub Pages website under `Code`- `About` - `Settings icon` - `Website` - `Use your GitHub Pages Website` - -![GitHub pages as website](figures/use_github_pages_website.png) - -## Contribute -This tool's repository is stored on [GitHub](https://github.com/TeachBooks/template). The `README.md` of the branch `manual_description` is also part of the [TeachBooks manual](https://teachbooks.tudelft.nl/jupyter-book-manual/external/template/README.html) as a submodule. If you'd like to contribute, you can create a fork and open a pull request on the [GitHub repository](https://github.com/TeachBooks/template). To update the `README.md` shown in the TeachBooks manual, create a fork and open a merge request for the [GitLab repository of the manual](https://gitlab.tudelft.nl/interactivetextbooks-citg/jupyter-book-manual). If you intent to clone the manual including its submodules, clone using: `git clone --recurse-submodules git@gitlab.tudelft.nl:interactivetextbooks-citg/jupyter-book-manual.git`. +TODO: better readme. \ No newline at end of file diff --git a/book/_toc.yml b/book/_toc.yml index a28474b..c8400d3 100644 --- a/book/_toc.yml +++ b/book/_toc.yml @@ -4,9 +4,13 @@ root: intro.md parts: - caption: Contents chapters: - - file: some_content/overview.md + - file: thesis_projects/overview.md sections: - - file: some_content/text_and_code.ipynb + - file: thesis_projects/BSc/2023_Q4_GeltSteiger_CET.ipynb + - file: tutorials_examples/intro_tutorials_examples.md + sections: + - file: tutorials_examples/1_HBV_Caravan_ERA5/example_model_run_HBV.ipynb + - file: tutorials_examples/2_HBV_PCRGlobWB_ERA5/example_model_run_pcrglobwb.ipynb - file: references.md - file: changelog.md - file: credits.md diff --git a/book/thesis_projects/BSc/2023_Q4_GeltSteiger_CEG/intro_BSc_GeltSteiger.md b/book/thesis_projects/BSc/2023_Q4_GeltSteiger_CEG/intro_BSc_GeltSteiger.md new file mode 100644 index 0000000..38bba9e --- /dev/null +++ b/book/thesis_projects/BSc/2023_Q4_GeltSteiger_CEG/intro_BSc_GeltSteiger.md @@ -0,0 +1,6 @@ +# Overview + +The projects listed here are the result of thesis work done by students. + +- Bachelor students: + - - ToDo: convert work Gelt \ No newline at end of file diff --git a/book/thesis_projects/overview_thesis_projects.md b/book/thesis_projects/overview_thesis_projects.md new file mode 100644 index 0000000..38bba9e --- /dev/null +++ b/book/thesis_projects/overview_thesis_projects.md @@ -0,0 +1,6 @@ +# Overview + +The projects listed here are the result of thesis work done by students. + +- Bachelor students: + - - ToDo: convert work Gelt \ No newline at end of file diff --git a/book/tutorials_examples/1_HBV_Caravan_ERA5/example_model_run_HBV.ipynb b/book/tutorials_examples/1_HBV_Caravan_ERA5/example_model_run_HBV.ipynb new file mode 100644 index 0000000..af9ff8d --- /dev/null +++ b/book/tutorials_examples/1_HBV_Caravan_ERA5/example_model_run_HBV.ipynb @@ -0,0 +1,669 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e9cd8d85-eb4a-45d6-925a-e3e770592043", + "metadata": {}, + "source": [ + "# Leven at Newby Bridge using HBV model in eWaterCycle\n", + "This notebook demonstrates how eWaterCycle is used to run a model.\n", + "For the EuroCSDMS workshop we, of course, choose the beautiful region we are in as a case study.\n", + "River discharge in river Leven is measured at the weirs at Newby Bridge, see the photo below.\n", + "This observational data is available in the CamelsGB dataset [(Coxon, 2020)](https://essd.copernicus.org/articles/12/2459/2020/).\n", + "The larger [Caravan](https://www.nature.com/articles/s41597-023-01975-w) (collection of Camels...) dataset is available through eWaterCycle and will be used below.\n", + "\n", + "![image](https://upload.wikimedia.org/wikipedia/commons/7/76/Weirs_on_the_River_Leven_at_Newby_Bridge_-_geograph.org.uk_-_5455774.jpg)\n", + "\n", + "*Weirs on the River Leven at Newby Bridge by G Laird*\n", + "\n", + "As a model we choose the classic [HBV model](https://hess.copernicus.org/articles/26/1371/2022/) for its simplicity. This nicely demonstrates how eWaterCycle works. More complex models are available through eWaterCycle, however:\n", + "\n", + "- these often require parameter sets specific to a region\n", + "- these are more computationally intensive to run and therefore unsuited for a short 45 minute workshop.\n", + "\n", + "Ask us about available models if you want to collaborate! " + ] + }, + { + "cell_type": "markdown", + "id": "641fbd17", + "metadata": {}, + "source": [ + "### HBV model structure\n", + "\n", + "The stucture of the HBV model is shown below.\n", + "Do note that the figure is missing a snow reservoir, however this has been implemented in the HBV model in this notebook.\n", + "\n", + "![image](../figures/hbv_model_label.png)\n", + "\n", + "*Image from the TU Delft course ENVM1502 - \"River Basin Hydrology\" by Markus Hrachowitz* \n" + ] + }, + { + "cell_type": "markdown", + "id": "e73ddde7-bde3-42e8-991a-8edd4825fd78", + "metadata": {}, + "source": [ + "## Starting up\n", + "To start up, we need to import eWaterCycle and a number of general Python libraries. 'Under the hood' eWaterCycle depends on a large number of other pieces of software, including but not limited to\n", + "\n", + "- [grpc4bmi](https://github.com/eWaterCycle/grpc4bmi), a 'translator' for BMI function calls between different programming languages and across containers. This library was build by the eWaterCycle team, but is available openly for anyone that can benefit from its functionality. \n", + "- apptainer, a container engine that runs the model-containers (Docker is supported too).\n", + "- [ESMValTool](https://github.com/ESMValGroup/ESMValTool), a climate data processing toolbox that originally intended to post-process climate data from CMIP projects for inclusion in IPCC reports, we adopted as tool for pre-processing climate data into forcing data for hydrological models\n", + "- Numerous hydrological models that are made available as plugins to eWaterCycle, see [eWaterCycle-leakybucket](https://github.com/eWaterCycle/ewatercycle-leakybucket) as an example. Note that plugins do not have to be owned and maintained by the eWaterCycle team: anyone with a model can make a plugin for eWaterCycle and make their model be available for others through the platform. \n", + "\n", + "Furthermore, eWaterCycle requires forcing data, obsrvational data and parameter sets to be available to users. If you want to install eWaterCycle on your own infrastructure, see the [eWaterCycle documentation](https://ewatercycle.readthedocs.io/en/latest/system_setup.html) or contact us." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ec7e710a-5aa4-40f9-a1cb-151e3cddbe04", + "metadata": { + "ExecuteTime": { + "end_time": "2024-03-07T14:21:32.492461800Z", + "start_time": "2024-03-07T14:21:31.890843300Z" + } + }, + "outputs": [], + "source": [ + "# general python\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\", category=UserWarning)\n", + "\n", + "import numpy as np\n", + "from pathlib import Path\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import xarray as xr\n", + "\n", + "#niceties\n", + "from rich import print" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4569a0f2-4bea-48cc-b5a4-ca5384e368c6", + "metadata": { + "ExecuteTime": { + "end_time": "2024-03-07T14:21:34.475126400Z", + "start_time": "2024-03-07T14:21:32.537461400Z" + } + }, + "outputs": [], + "source": [ + "# general eWaterCycle\n", + "import ewatercycle\n", + "import ewatercycle.models\n", + "import ewatercycle.forcing" + ] + }, + { + "cell_type": "markdown", + "id": "28ecd862-3e33-4001-9218-d025f6acc2ae", + "metadata": {}, + "source": [ + "## Choose region and time period: \n", + "The HBV model is a lumped hydrological model. It considers a catchment as a homogenious area and calculates the major hydrological processes in it. It requires spatially aggregated rainfall and potential evaporation as inputs (ie. forcings). To calculate its modelled discharge at the outlet of the catchment it also needs a set of parameters. Usually these paramters are calibrated using (historical) observational data, so this is also required. \n", + "\n", + "in eWaterCycle we provide access to the Caravan dataset, which contains all of the above data for all the catchments in the different Camels datasets. However, for two reasons, we don't use the rainfall and potential evaporation data from Caravan\n", + "\n", + "1. This allows us to demonstrate how to generate forcing data for any model from ERA5 (working on ERA5Land) and from CMIP data\n", + "2. There is a known problem with the caravan evaporation data and we want to avoid using it here.\n", + "\n", + "We thus only use the Caravan dataset to retreive \n", + "\n", + "- a shapefile of the region of interest, to be used as input for generating the forcing from ERA5\n", + "- the observational data of river discharge\n", + "\n", + "Using the interactive maps at [eWaterCycle caravan map](https://www.ewatercycle.org/caravan-map/) one can easily retrieve the identifier of the catchment.\n", + "\n", + "Note that changing the region below will work, but that the parameters that are loaded later in this notebook are calibrated specifically for this catchment!" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a5898939-54a6-40de-8a27-bbc793536248", + "metadata": {}, + "outputs": [], + "source": [ + "camelsgb_id = \"camelsgb_73010\"" + ] + }, + { + "cell_type": "markdown", + "id": "45b5fc86-ec75-46a8-9f40-4685444628e5", + "metadata": {}, + "source": [ + "We have to specify start and end date of the experiment that we want to do. For now we don't fuzz with diverences between calibration and validation periods (which officially of course is very bad...)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "03aea008-87ce-4d09-8d01-f12dfe6bb116", + "metadata": { + "ExecuteTime": { + "end_time": "2024-03-07T14:21:34.567126600Z", + "start_time": "2024-03-07T14:21:34.567126600Z" + } + }, + "outputs": [], + "source": [ + "experiment_start_date = \"1997-08-01T00:00:00Z\"\n", + "experiment_end_date = \"2000-08-31T00:00:00Z\"" + ] + }, + { + "cell_type": "markdown", + "id": "111bc65b-8299-43ba-95fd-e92df6b92707", + "metadata": {}, + "source": [ + "## Set up paths\n", + "\n", + "Since forcing files are often re-used between experiments it is a best practice to save those intermediate files for re-use between experiments. These logical save-points in workflows are called 'rustpunten' in Dutch. It is important to store data in 'rustpunten' in standard formats. Working with clearly defined 'rustpunten' is a key element in the design of good workflows in general and was instrumental in designing eWaterCycle in particular. \n", + "\n", + "Here we set up some paths to store the forcing files we generate in your own home directory. \n", + "\n", + "To speed up this workshop, we have already created the forcing files in a central location, which we also create pointers to here. If you want to run for a different region, you will have to generate the forcing yourself. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "eb5ed837-14aa-4629-b589-ffc33c24ba84", + "metadata": {}, + "outputs": [], + "source": [ + "forcing_path_caravan = Path.home() / \"forcing\" / camelsgb_id / \"caravan\"\n", + "forcing_path_caravan.mkdir(exist_ok=True, parents=True)\n", + "\n", + "prepared_forcing_path_caravan_central = Path(\"/data/eurocsdms-data/forcing/camelsgb_73010/caravan\")\n", + "\n", + "forcing_path_ERA5 = Path.home() / \"forcing\" / camelsgb_id / \"ERA5\"\n", + "forcing_path_ERA5.mkdir(exist_ok=True)\n", + "\n", + "prepared_forcing_path_ERA5_central = Path(\"/data/eurocsdms-data/forcing/camelsgb_73010/ERA5\")" + ] + }, + { + "cell_type": "markdown", + "id": "1171ca7e-d26a-4cbe-abb0-d741315a708c", + "metadata": {}, + "source": [ + "## Generate or load forcing\n", + "There are three options for creating forcing data objects:\n", + "\n", + "- generate from climate data such as ERA5 or CMIP. Note that if the directory you specify as destination already contains data this trying this will throw an error!\n", + "- load forcing data you generated previously by providing the location where it was stored\n", + "- load forcing data someone else (such as Rolf and Bart) generated previously by providing the location where it was stored\n", + "\n", + "First we will create a caravan forcing object, but as mentioned above, we will only use this for the discharge observations and the shape file of the region. After generating the object we show the fields it contains and plot the discharge data. \n", + "\n", + "The actual forcing object we will use in this example is the ERA5 based data.\n", + "\n", + "For both caravan and ERA5 based forcing, only one of the three options provided below should be used, use comments to select which one you want to use." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "19641ae0", + "metadata": {}, + "outputs": [], + "source": [ + "# # option one: generate forcing data\n", + "# camelsgb_forcing = ewatercycle.forcing.sources['CaravanForcing'].generate(\n", + "# start_time=experiment_start_date,\n", + "# end_time=experiment_end_date,\n", + "# directory=forcing_path_caravan,\n", + "# basin_id=camelsgb_id,\n", + "# )" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "35875c4f-d5f0-465c-b349-82580dbd71bd", + "metadata": {}, + "outputs": [], + "source": [ + "# option two: load data that you or someone else generated previously\n", + "camelsgb_forcing = ewatercycle.forcing.sources['CaravanForcing'].load(directory=prepared_forcing_path_caravan_central)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "2b696cee-5dbe-40de-bafb-6346f6265ff3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
CaravanForcing(\n",
+       "    start_time='1997-08-01T00:00:00Z',\n",
+       "    end_time='2000-08-31T00:00:00Z',\n",
+       "    directory=PosixPath('/data/eurocsdms-data/forcing/camelsgb_73010/caravan'),\n",
+       "    shape=PosixPath('/data/eurocsdms-data/forcing/camelsgb_73010/caravan/camelsgb_73010.shp'),\n",
+       "    filenames={\n",
+       "        'tasmax': 'camelsgb_73010_1997-08-01_2000-08-31_tasmax.nc',\n",
+       "        'evspsblpot': 'camelsgb_73010_1997-08-01_2000-08-31_evspsblpot.nc',\n",
+       "        'Q': 'camelsgb_73010_1997-08-01_2000-08-31_Q.nc',\n",
+       "        'tasmin': 'camelsgb_73010_1997-08-01_2000-08-31_tasmin.nc',\n",
+       "        'pr': 'camelsgb_73010_1997-08-01_2000-08-31_pr.nc',\n",
+       "        'tas': 'camelsgb_73010_1997-08-01_2000-08-31_tas.nc'\n",
+       "    }\n",
+       ")\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1;35mCaravanForcing\u001b[0m\u001b[1m(\u001b[0m\n", + " \u001b[33mstart_time\u001b[0m=\u001b[32m'1997-08-01T00:00:00Z'\u001b[0m,\n", + " \u001b[33mend_time\u001b[0m=\u001b[32m'2000-08-31T00:00:00Z'\u001b[0m,\n", + " \u001b[33mdirectory\u001b[0m=\u001b[1;35mPosixPath\u001b[0m\u001b[1m(\u001b[0m\u001b[32m'/data/eurocsdms-data/forcing/camelsgb_73010/caravan'\u001b[0m\u001b[1m)\u001b[0m,\n", + " \u001b[33mshape\u001b[0m=\u001b[1;35mPosixPath\u001b[0m\u001b[1m(\u001b[0m\u001b[32m'/data/eurocsdms-data/forcing/camelsgb_73010/caravan/camelsgb_73010.shp'\u001b[0m\u001b[1m)\u001b[0m,\n", + " \u001b[33mfilenames\u001b[0m=\u001b[1m{\u001b[0m\n", + " \u001b[32m'tasmax'\u001b[0m: \u001b[32m'camelsgb_73010_1997-08-01_2000-08-31_tasmax.nc'\u001b[0m,\n", + " \u001b[32m'evspsblpot'\u001b[0m: \u001b[32m'camelsgb_73010_1997-08-01_2000-08-31_evspsblpot.nc'\u001b[0m,\n", + " \u001b[32m'Q'\u001b[0m: \u001b[32m'camelsgb_73010_1997-08-01_2000-08-31_Q.nc'\u001b[0m,\n", + " \u001b[32m'tasmin'\u001b[0m: \u001b[32m'camelsgb_73010_1997-08-01_2000-08-31_tasmin.nc'\u001b[0m,\n", + " \u001b[32m'pr'\u001b[0m: \u001b[32m'camelsgb_73010_1997-08-01_2000-08-31_pr.nc'\u001b[0m,\n", + " \u001b[32m'tas'\u001b[0m: \u001b[32m'camelsgb_73010_1997-08-01_2000-08-31_tas.nc'\u001b[0m\n", + " \u001b[1m}\u001b[0m\n", + "\u001b[1m)\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(camelsgb_forcing)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "cc974bcb-5489-4af6-8cf9-cc0299adab97", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#quick plot of the discharge data. \n", + "ds_forcing = xr.open_dataset(camelsgb_forcing['Q'])\n", + "ds_forcing[\"Q\"].plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "663be219-1329-4621-8950-b5ef7dde9506", + "metadata": {}, + "outputs": [], + "source": [ + "# option one: generate forcing:\n", + "# ERA5_forcing = ewatercycle.forcing.sources[\"LumpedMakkinkForcing\"].generate(\n", + "# dataset=\"ERA5\",\n", + "# start_time=experiment_start_date,\n", + "# end_time=experiment_end_date,\n", + "# shape=camelsgb_forcing.shape,\n", + "# )\n", + "\n", + "# option two: load data that you or someone else generated previously\n", + "# this is needed because ERA5 forcing data is stored deep in a sub-directory\n", + "load_location = prepared_forcing_path_ERA5_central / \"work\" / \"diagnostic\" / \"script\" \n", + "ERA5_forcing = ewatercycle.forcing.sources[\"LumpedMakkinkForcing\"].load(directory=load_location)" + ] + }, + { + "cell_type": "markdown", + "id": "4787c692-3f9c-402b-9b48-93daeeb47926", + "metadata": {}, + "source": [ + "## Load parameters from calibration" + ] + }, + { + "cell_type": "markdown", + "id": "c4557dc0-b086-4230-8368-ef9b91cb2711", + "metadata": {}, + "source": [ + "The HBV model contains five \"stores\" where the water is stored and nine parameters that control the flow between those stores and in and out of the model.\n", + "We have already calibrated the model for our region of choice and saved the result in a csv file which we load below. If you have changed the region and have calibrated for your region, you need to point to your calibration results here." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "ed960ab6-b63a-4664-8306-b57c2ecf27ec", + "metadata": { + "ExecuteTime": { + "end_time": "2024-03-07T14:21:34.528887900Z", + "start_time": "2024-03-07T14:21:34.501125300Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
[\n",
+       "    ('Imax', 7.085),\n",
+       "    ('Ce', 0.837),\n",
+       "    ('Sumax', 76.373),\n",
+       "    ('Beta', 1.112),\n",
+       "    ('Pmax', 0.245),\n",
+       "    ('Tlag', 7.801),\n",
+       "    ('Kf', 0.096),\n",
+       "    ('Ks', 0.003),\n",
+       "    ('FM', 0.226)\n",
+       "]\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m[\u001b[0m\n", + " \u001b[1m(\u001b[0m\u001b[32m'Imax'\u001b[0m, \u001b[1;36m7.085\u001b[0m\u001b[1m)\u001b[0m,\n", + " \u001b[1m(\u001b[0m\u001b[32m'Ce'\u001b[0m, \u001b[1;36m0.837\u001b[0m\u001b[1m)\u001b[0m,\n", + " \u001b[1m(\u001b[0m\u001b[32m'Sumax'\u001b[0m, \u001b[1;36m76.373\u001b[0m\u001b[1m)\u001b[0m,\n", + " \u001b[1m(\u001b[0m\u001b[32m'Beta'\u001b[0m, \u001b[1;36m1.112\u001b[0m\u001b[1m)\u001b[0m,\n", + " \u001b[1m(\u001b[0m\u001b[32m'Pmax'\u001b[0m, \u001b[1;36m0.245\u001b[0m\u001b[1m)\u001b[0m,\n", + " \u001b[1m(\u001b[0m\u001b[32m'Tlag'\u001b[0m, \u001b[1;36m7.801\u001b[0m\u001b[1m)\u001b[0m,\n", + " \u001b[1m(\u001b[0m\u001b[32m'Kf'\u001b[0m, \u001b[1;36m0.096\u001b[0m\u001b[1m)\u001b[0m,\n", + " \u001b[1m(\u001b[0m\u001b[32m'Ks'\u001b[0m, \u001b[1;36m0.003\u001b[0m\u001b[1m)\u001b[0m,\n", + " \u001b[1m(\u001b[0m\u001b[32m'FM'\u001b[0m, \u001b[1;36m0.226\u001b[0m\u001b[1m)\u001b[0m\n", + "\u001b[1m]\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#load calibration constants\n", + "par_0 = np.loadtxt(\"/data/eurocsdms-data/calibration/calibration_\" + camelsgb_id + \".csv\", delimiter = \",\")\n", + "\n", + "param_names = [\"Imax\", \"Ce\", \"Sumax\", \"Beta\", \"Pmax\", \"Tlag\", \"Kf\", \"Ks\", \"FM\"]\n", + "print(list(zip(param_names, np.round(par_0, decimals=3))))" + ] + }, + { + "cell_type": "markdown", + "id": "324ab8b0-947b-4116-84d9-e476d46ddd98", + "metadata": {}, + "source": [ + "For the storages we can specify an array of starting values. If you don't the model will start 'empty' and needs some timesteps to 'fill up'. Especially for the rootzone storage it helps to not start empty. Note that all units are in mm:
" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "f70032e1-602a-4163-a338-2a3ff6264c00", + "metadata": { + "ExecuteTime": { + "end_time": "2024-03-07T14:21:34.494347400Z", + "start_time": "2024-03-07T14:21:34.484123900Z" + } + }, + "outputs": [], + "source": [ + "# Si, Su, Sf, Ss, Sp\n", + "s_0 = np.array([0, 100, 0, 5, 0])" + ] + }, + { + "cell_type": "markdown", + "id": "ff45d384-3549-414b-b8f2-793399161aaf", + "metadata": {}, + "source": [ + "## Setting up the model\n", + "Below we show the core use of eWaterCycle: to users models are objects. We stay as close as possible to the standard BMI functions, but make sure that under the hood eWaterCycle makes everything run. Getting a model to run requires three steps:\n", + "\n", + "1. creating a model object, an instance of the specific model class. This is provided by the different plugins. At the point of creation, the forcing object that will be used need to be passed to the model:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "d62a1be2-e5a1-4c82-aaf0-9ab2eeea14af", + "metadata": { + "ExecuteTime": { + "end_time": "2024-03-07T14:21:34.569218800Z", + "start_time": "2024-03-07T14:21:34.568127600Z" + } + }, + "outputs": [], + "source": [ + "model = ewatercycle.models.HBV(forcing=ERA5_forcing)" + ] + }, + { + "cell_type": "markdown", + "id": "60c0bd34", + "metadata": {}, + "source": [ + "2. creating a configuration file that contains all the information the model needs to initialize itself.\n", + " The format of the configuration file is very model specific. For example, the HBV configuration file contains information on:\n", + " - the location of forcing files\n", + " - the values of parameters and initial storages" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "ebbd898f-b3cc-4d03-8050-21067d31c1e8", + "metadata": { + "ExecuteTime": { + "end_time": "2024-03-07T14:21:34.948731400Z", + "start_time": "2024-03-07T14:21:34.568127600Z" + } + }, + "outputs": [], + "source": [ + "config_file, _ = model.setup(parameters=par_0, initial_storage=s_0)" + ] + }, + { + "cell_type": "markdown", + "id": "cdbb274a", + "metadata": {}, + "source": [ + "3. initializing starts the model container, creates all variables, and basically gets the model primed to start running." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "ba14b408-e446-45aa-b406-91dc35f40bc1", + "metadata": { + "ExecuteTime": { + "end_time": "2024-03-07T14:21:34.957732500Z", + "start_time": "2024-03-07T14:21:34.953733500Z" + } + }, + "outputs": [], + "source": [ + "model.initialize(config_file)" + ] + }, + { + "cell_type": "markdown", + "id": "1e320191-4ee4-4535-94f3-05e5afef96e2", + "metadata": {}, + "source": [ + "## Running the model\n", + "The basic loop that runs the model calls the ```model.update()``` to have the model progress one timestep and ```model.get_value()``` to extract information of interest. More complex experiment can interact with the model using, for example, ```model.set_value()``` to change values. In this way \n", + "\n", + "- multiple models can interact (including be coupled)\n", + "- models can be adjusted during runtime to incoming observations (ie. data assimilation)\n", + "- Effects not covered by the model can be calculated seperatly and included to create 'what if' experiments.\n", + "- and many more applications." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "579fe3d8-0418-4e76-9d66-9c1a938812cc", + "metadata": { + "ExecuteTime": { + "start_time": "2024-03-07T14:21:34.997729900Z" + } + }, + "outputs": [], + "source": [ + "Q_m = []\n", + "time = []\n", + "while model.time < model.end_time:\n", + " model.update()\n", + " Q_m.append(model.get_value(\"Q\")[0])\n", + " time.append(pd.Timestamp(model.time_as_datetime))" + ] + }, + { + "cell_type": "markdown", + "id": "b2a78bda-4e19-474f-8367-acec10c50f52", + "metadata": {}, + "source": [ + "After running the model we need to call ```model.finalize()``` to shut everything down, including the container. If we don't do this, the container will continue to be active, eating up system memory." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "a6fd6178-1059-497a-a91f-dd0fa983df2a", + "metadata": { + "ExecuteTime": { + "end_time": "2024-03-07T14:21:35.030728200Z", + "start_time": "2024-03-07T14:21:34.997729900Z" + } + }, + "outputs": [], + "source": [ + "model.finalize()" + ] + }, + { + "cell_type": "markdown", + "id": "9b88262e-c750-4f8e-a602-50c404969690", + "metadata": {}, + "source": [ + "## Process results\n", + "Finally, we use standard python libraries to visualize the results. We put the model output into a pandas Series to make plotting easier." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "ccde9dca-258d-409c-a602-d4abda553b32", + "metadata": { + "ExecuteTime": { + "start_time": "2024-03-07T14:21:34.997729900Z" + } + }, + "outputs": [], + "source": [ + "model_output = pd.Series(data=Q_m, name=\"Modelled_discharge\", index=time)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "02879a8d-c55f-4a74-a6cf-8154cffb3d0b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Discharge (mm/d)')" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjMAAAGpCAYAAAB4R7d6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAADrJElEQVR4nOydd3gU1d7Hv7M1PSGBkIQaOkgRBBVQioAUL4hcbHgVRLFiAwUsCBYsoIDlivdFBAuKXgWvHVEEC6CAIgiIIFUghPRkk+3z/jFzZs/MzuzOJLvJJjmf58mT3dkpZ2dm53zPrx2O53keDAaDwWAwGPUUU103gMFgMBgMBqMmMDHDYDAYDAajXsPEDIPBYDAYjHoNEzMMBoPBYDDqNUzMMBgMBoPBqNcwMcNgMBgMBqNew8QMg8FgMBiMeg0TMwwGg8FgMOo1TMwwGAwGg8Go1zAxE2Xmz58PjuNQUFBQq8cdMmQIhgwZEpV9Hz16FBzHYdWqVWHXJd+/NpkyZQqSkpJ0rdu2bVvMnz8/ug2qBVatWgWO43D06NGo7D+S9/GUKVPAcZzm37Zt26R1X3zxRVx44YVo2rQp7HY7WrdujWuuuQZ79+5V3fdLL72ELl26wG63Izc3F4899hg8Ho9snb///hv33nsvBg8ejLS0tLD38tdff43+/fsjISEBTZs2xZQpU5Cfny9bZ9OmTdU+/5WVlZg/fz42bdoU9Fm0rytDG/Kce+6558KuS64TzZAhQzTv8bZt20ap1Y0XS103gBEdXnnllajtOzs7G1u3bkX79u2jdgxGw2Xu3Lm47bbbgpaPHTsWdrsd/fr1k5YVFhZi9OjR6NWrF5o0aYLDhw/jmWeewQUXXICdO3eic+fO0roLFizA3LlzMWfOHFx66aXYvn07HnnkEZw8eRL/93//J6136NAhrF69Gueeey7GjBmDd999V7OtmzdvxujRo3HZZZfhf//7H/Lz8zF79mwMGzYMO3bsgN1ur/H5qKysxGOPPQYAQQOQyy67DFu3bkV2dnaNj8Oofdq1a4fVq1cHLY/EfcOQw8RMA6Vbt25R27fdbseFF14Ytf0zGjbt27cPEsKbN29GQUEBHnnkEZjNZmk56eQJgwcPxoUXXohu3bph9erVePzxxwEIoufJJ5/EtGnT8NRTTwEQhIHH48EjjzyCe++9V/pNDBo0CGfPngUA7NixI6SYeeCBB9CpUyd88MEHsFiEx2Vubi4GDhyI119/HbfffnsNz0ZomjVrhmbNmkX1GIzoER8fH/VnZVVVFeLj46N6jPoAczPVEidOnMCECROQkpKC1NRU/Otf/5IeqIT33nsPl156KbKzsxEfH4+uXbtizpw5cDgcsvUOHz6Ma665Bjk5ObDb7WjevDmGDRuGXbt2Seso3Uy0yXTx4sXIzc1FUlIS+vfvLzPr60HLzfTZZ5/h3HPPlUz8esyz0WTv3r0YNmwYEhMT0axZM0yfPh2VlZVhtzt58iRuueUWtGrVCjabDTk5OZg4cSLOnDkDAHA6nZg5cybOPfdcpKamIj09Hf3798f//ve/oH1xHIfp06dj5cqV6Ny5M+Lj49G3b19s27YNPM9j0aJF0rW45JJLcOjQoaB9fP311xg2bBhSUlKQkJCAgQMH4ptvvgn7PX799Vf84x//QGZmJux2O3JycnDZZZfh77//ltYpKSnBTTfdhPT0dCQlJeGyyy7D4cOHwXGcqvtNz31cHVasWAGO4zB16tSw65LOnYgLAPjyyy/hdDpx4403yta98cYbwfM8PvroI2mZyaTvsXfy5Els374d119/vexYAwYMQKdOnbBu3Tpd+wnF0aNHpe/z2GOPSW6IKVOmAFB3Mw0ZMgTdu3fH1q1bMWDAAMTHx6Nt27ZYuXIlAOF32KdPHyQkJKBHjx748ssvg4578OBBTJo0Sbo3unbtin//+9+ydUK5Sejf/u+//47LL78cTZo0QVxcHM4991y88cYbsn0RN9y7776Lhx9+GDk5OUhJScHw4cNx4MCBoPZV956PBn6/HwsWLEDr1q0RFxeHvn37RrQtWq54tWvftm1b/OMf/8DatWvRu3dvxMXFSYJfz3VoyDDLTC1xxRVX4KqrrsJtt92GvXv3Yu7cudi3bx9++uknWK1WAMIDZsyYMbj33nuRmJiIP/74A88++yx+/vlnbNy4UdrXmDFj4PP5sHDhQrRu3RoFBQXYsmULSkpKwrbj3//+N7p06YKlS5cCEEz+Y8aMwZEjR5Camlrt7/fNN9/g8ssvR//+/bFmzRqpfUQAhMPv98Pv94ddj+M42chdC4/HgzFjxuDWW2/FnDlzsGXLFjz55JM4duwYPvnkE2k9ZSzCyZMn0a9fP3g8Hjz00EPo2bMnCgsLsX79ehQXF6N58+ZwuVwoKirC/fffjxYtWsDtduPrr7/GhAkTsHLlStxwww2yfX766af49ddf8cwzz4DjOMyePRuXXXYZJk+ejMOHD+Pll19GaWkpZsyYgX/+85/YtWuX9HB7++23ccMNN+Dyyy/HG2+8AavViv/85z8YOXIk1q9fj2HDhql+f4fDgREjRiA3Nxf//ve/0bx5c+Tl5eHbb79FeXm5dM7Hjh2LHTt2YP78+ejTpw+2bt2KUaNGaZ5XPfexUUpLS/HBBx9g2LBhyM3NVV3H5/PB6/XiyJEjmDNnDjIzM2XC5ffffwcA9OjRQ7ZddnY2mjZtKn1uBLJNz549gz7r2bMnfvzxR+n9kCFDwPO84WNkZ2fjyy+/xKhRo3DTTTfh5ptvBoCw1pi8vDzceOONmDVrFlq2bImXXnoJU6dOxYkTJ/DBBx/goYceQmpqKh5//HGMHz8ehw8fRk5ODgBg3759GDBgAFq3bo3nn38eWVlZWL9+Pe6++24UFBRg3rx5AARXdVlZmey4c+fOxbfffiu59w4cOIABAwYgMzMTL774IjIyMvD2229jypQpOHPmDGbNmiXb/qGHHsLAgQPx2muvoaysDLNnz8bYsWOxf/9+6Xdd3Xue4PV6dZ17s9msK57v5ZdfRps2bbB06VL4/X4sXLgQo0ePxubNm9G/f38AQhwYEaB62mMymXSLaiW//PIL9u/fj0ceeQS5ublITEw0fB0aJDwjqsybN48HwN93332y5atXr+YB8G+//bbqdn6/n/d4PPzmzZt5APxvv/3G8zzPFxQU8AD4pUuXhjzu4MGD+cGDB0vvjxw5wgPge/TowXu9Xmn5zz//zAPg3333Xd3fiexr5cqV0rILLriAz8nJ4auqqqRlZWVlfHp6Oq/nNiPnKdxfmzZtwu5r8uTJPAD+hRdekC1fsGABD4D/4YcfNLedOnUqb7Va+X379oU9DsHr9fIej4e/6aab+N69e8s+A8BnZWXxFRUV0rKPPvqIB8Cfe+65vN/vl5YvXbqUB8Dv3r2b53medzgcfHp6Oj927FjZPn0+H9+rVy/+/PPPl5atXLmSB8AfOXKE53me37FjBw+A/+ijjzTb/dlnn/EA+GXLlsmWP/300zwAft68edKy6t7Heli2bFnYe9But0v3QKdOnYKuz7Rp03i73a66badOnfhLL71U9bPt27cH3csE8t22bt0a9Nktt9zC22y2EN9KP2fPng063wTldeV54bcNgN+xY4e0rLCwkDebzXx8fDx/8uRJafmuXbt4APyLL74oLRs5ciTfsmVLvrS0VHas6dOn83FxcXxRUZFqOxctWsQD4P/v//5PWnbNNdfwdrudP378uGzd0aNH8wkJCXxJSQnP8zz/7bff8gD4MWPGyNZ7//33ZefYyD2vhZ7niNY1pyHPOa3n2vDhw0NuT66T2t9NN90krUd+W0rUrn2bNm14s9nMHzhwQLau3uvQkGFuplriuuuuk72/6qqrYLFY8O2330rLDh8+jEmTJiErKwtmsxlWqxWDBw8GAOzfvx8AkJ6ejvbt22PRokVYvHgxfv31V10WDcJll10ms2yQUeexY8eq/d0cDge2b9+OCRMmIC4uTlqenJyMsWPH6trHLbfcgu3bt4f9o60q4VCe80mTJgGA7Jwr+eKLLzB06FB07do15L7/+9//YuDAgUhKSoLFYoHVasWKFSuk60QzdOhQJCYmSu/JvkePHi0bGZLl5Fps2bIFRUVFmDx5Mrxer/Tn9/sxatQobN++PcgFSejQoQOaNGmC2bNn49VXX8W+ffuC1tm8eTMA4V6kufbaazW/t5772CgrVqxARkYGrrjiCs11tmzZgq1bt+Ltt99GcnIyhg4dGpTRFGqUXZOMOq1taztLjyY7OxvnnXee9D49PR2ZmZk499xzJQsMEHxPOZ1OfPPNN7jiiiuQkJAgu6/GjBkDp9Op6nZ+9913MWvWLDzyyCOYNm2atHzjxo0YNmwYWrVqJVt/ypQpqKysxNatW2XLx40bJ3uvfP7U5J4n6HmObN++XfezSeu59t1338Hn84Xctn379qrHnjt3rq5jq9GzZ0906tRJtszodWiIMDdTLZGVlSV7b7FYkJGRgcLCQgBARUUFLr74YsTFxeHJJ59Ep06dkJCQIMUoVFVVARAeoN988w0ef/xxLFy4EDNnzkR6ejquu+46LFiwAMnJySHbkZGRIXtPourJ/qtDcXEx/H5/0HdU+95aZGVlITMzM+x6ejsQcn7V2kLOuRpnz55Fy5YtQ+577dq1uOqqq3DllVfigQceQFZWFiwWC5YtW4bXX389aP309HTZe5vNFnK50+kEAMlFN3HiRM22FBUVyYQSITU1FZs3b8aCBQvw0EMPobi4GNnZ2Zg2bRoeeeQRWK1WFBYWwmKxBLWjefPmmscLdx8bZffu3dixYwfuueeekBkeffr0AQBceOGFGDduHDp06ICHHnpIilPKyMiA0+lEZWUlEhISZNsWFRXJOn69kPtH7bsVFRUFnbfaRO3YNpst7D1VWFgIr9eLl156CS+99JLqvpXp999++y2mTJmCG264AU888YTss8LCQtVMKyKolOcu3POnJvc84dxzz9X8jEaPuxpQf4ZlZWXB7XajoqIipHuexNhEErXzbfQ6NESYmKkl8vLy0KJFC+m91+tFYWGh9OPeuHEjTp06hU2bNknWGACqcTBt2rTBihUrAAB//vkn3n//fcyfPx9utxuvvvpqdL+ICk2aNAHHccjLywv6TG2ZGo8//nhQ5ooabdq00VVzQ3l+6bYoH6g0zZo1kwXIqvH2228jNzcX7733nkxcuVyusO0yQtOmTQEItVO0MiJCCY8ePXpgzZo14Hkeu3fvxqpVq/D4448jPj4ec+bMQUZGBrxeb1DHHOqahbuPjULuYxIroofk5GR06dIFf/75p7SMxMrs2bMHF1xwgay9BQUF6N69u+G2kW327NmDMWPGyD7bs2dPtfZZ1zRp0gRmsxnXX3897rzzTtV16Lil3bt3Y/z48Rg8eDCWL18etG5GRgZOnz4dtPzUqVMAAvewXmp6zwPQHbu1cuVKzTgXGq3nms1m013PKhTE6uNyuWSCXqumk9qALtLXoT7CxEwtsXr1atno8P3334fX65UyjsgNqhyd/uc//wm5306dOuGRRx7Bhx9+iF9++SWyjdZJYmIizj//fKxduxaLFi2Sfpzl5eW63UK33HIL/vGPf4Rdz0h9htWrV+Puu++W3r/zzjsAgmt50IwePRpvvfUWDhw4IKthQsNxHGw2m+yhkpeXp5rNVBMGDhyItLQ07Nu3D9OnT6/2fjiOQ69evbBkyRKsWrVKuk8GDx6MhQsX4r333pOlGK9Zs0ZzX+HuYyO4XC68/fbbOP/88w0Jg4KCAuzZswcDBw6Ulo0aNQpxcXFYtWqVTMyQjJDx48cbbl+LFi1w/vnn4+2338b9998vjeS3bduGAwcO4N577zW8TzUiYR3VS0JCAoYOHYpff/0VPXv2lCw3ahw/fhyjR49Gu3bt8OGHH6qKhGHDhmHdunU4deqUzL315ptvIiEhwXBaciTu+e3bt+taTyvYXInWc+3iiy/Wbd0JBSmgt3v3blmNJSMu9Uhfh/oIEzO1xNq1a2GxWDBixAgpC6RXr15SvMKAAQPQpEkT3HbbbZg3bx6sVitWr16N3377Tbaf3bt3Y/r06bjyyivRsWNH2Gw2bNy4Ebt378acOXPq4qsBAJ544gmMGjUKI0aMwMyZM+Hz+fDss88iMTERRUVFYbfPycmR/Qhris1mw/PPP4+Kigr069dPymYaPXo0LrroIs3tHn/8cXzxxRcYNGgQHnroIfTo0QMlJSX48ssvMWPGDHTp0kVKjbzjjjswceJEnDhxAk888QSys7Nx8ODBiH2HpKQkvPTSS5g8eTKKioowceJEZGZm4uzZs/jtt99w9uxZLFu2THXbTz/9FK+88grGjx+Pdu3aged5rF27FiUlJRgxYgQAQQAMHDgQM2fORFlZGc477zxs3boVb775JgD1FOZw97ERPvroIxQVFWlaZUpLSzFixAhMmjQJHTt2RHx8PP7880+88MILcLlcUtYNILhdHnnkEcydOxfp6elS0bz58+fj5ptvDqq79MEHHwAQ4tQAod4MGWXTLo5nn30WI0aMwJVXXok77rgD+fn5mDNnDrp37x6UBq5k06ZNGDp0KObNmxeyynRycjLatGmD//3vfxg2bBjS09PRtGnTqFWJfeGFF3DRRRfh4osvxu233462bduivLwchw4dwieffCJlTo4ePRolJSV4+eWXg+KT2rdvj2bNmmHevHn49NNPMXToUDz66KNIT0/H6tWr8dlnn2HhwoWGMyRrcs8TIu3WMZvNGDFiBGbMmAG/349nn30WZWVluizJVVVVmqUviMAYM2YM0tPTcdNNN+Hxxx+HxWLBqlWrcOLECd1t1HsdNm/ejGHDhuHRRx/Fo48+Km1vsVgwePBgWcr5sGHDsHnzZt3ZYXVOXUcgN3RIpPrOnTv5sWPH8klJSXxycjJ/7bXX8mfOnJGtu2XLFr5///58QkIC36xZM/7mm2/mf/nlF1nk/ZkzZ/gpU6bwXbp04RMTE/mkpCS+Z8+e/JIlS2RZSlrZTIsWLQpqIzQyKbRQy2bieZ7/+OOP+Z49e/I2m41v3bo1/8wzz2hG6keTyZMn84mJifzu3bv5IUOG8PHx8Xx6ejp/++23y7KKtDhx4gQ/depUPisri7darXxOTg5/1VVXya7XM888w7dt25a32+18165d+eXLl6t+VwD8nXfeKVumdS1Ixsd///tf2fLNmzfzl112GZ+ens5brVa+RYsW/GWXXSZbT5n58Mcff/DXXnst3759ez4+Pp5PTU3lzz//fH7VqlWyfRcVFfE33ngjn5aWxickJPAjRozgt23bFpQNZuQ+1suIESP4xMREvqysTPVzp9PJ33zzzXzXrl35pKQk3mKx8C1btuT/9a9/8Xv37lXd5oUXXuA7deok3YPz5s3j3W530HoIkeWi5KuvvuIvvPBCPi4ujk9PT+dvuOEGXd/5k08+4QHwr776ath1v/76a753795S1tbkyZN5ntfOZjrnnHOC9tGmTRv+sssuU/2uavfg1KlT+RYtWvBWq5Vv1qwZP2DAAP7JJ5+Ubaf1R//29+zZw48dO5ZPTU3lbTYb36tXr6Bng9a9rfUs0XPPRxvStmeffZZ/7LHH+JYtW/I2m43v3bs3v379+rDbh8pmAsB7PB5p3Z9//pkfMGAAn5iYyLdo0YKfN28e/9prr6lmM6ldY543dh2Uz3sAsv6Cbn99geP5ahRHYDAYDZZ33nkH1113HX788UcMGDCgrptTb5k1axbeffddHDx4UJYNw2AwIg9zMzEYjZh3330XJ0+eRI8ePWAymbBt2zYsWrQIgwYNYkKmhnz77beYO3cuEzIMRi3ALDMMCZ7nw9ZN0Fs1k1E/+PTTTzF//nwcOnQIDocD2dnZGD9+PJ588kmkpKQY2peeKs70tAAMBoMRKZiYYUiQgMVQ6E1nZDQ+5s+fHzYo8siRI1ELbGUwGI0XJmYYEuXl5aqTvtHk5uZWu6YIo2Fz6tQpqa6FFuHSgRkMBqM6MDHDYDAYDAajXtPgHdh+vx+nTp1CcnIyi/VgMBgMBqOewPM8ysvLkZOTE3aW8QYvZk6dOhU0+RaDwWAwGIz6wYkTJ8LOmdfgxQyZePHEiROGszMYDAaDwWDUDWVlZWjVqlXYCZSBRiBmiGspJSWFiRkGg8FgMOoZekJEQjuhGAwGg8FgMGIcJmYYDAaDwWDUa5iYYTAYDAaDUa9p8DEzevH5fPB4PHXdDAYjalitVpjN5rpuBoPBYEScRi9meJ5HXl4eSkpK6ropDEbUSUtLQ1ZWFqu5xGAwGhSNXswQIZOZmYmEhAT2kGc0SHieR2VlJfLz8wEA2dnZddwiBoPBiByNWsz4fD5JyLD5hhgNnfj4eABAfn4+MjMzmcuJwWA0GBp1ADCJkUlISKjjljAYtQO511l8GIPBaEg0ajFDYK4lRmOB3esMBqMhwsQMg8FgMBiMeg0TMwwGg8FgMOo1dSpmli1bhp49e0rzJvXv3x9ffPGF9DnP85g/fz5ycnIQHx+PIUOGYO/evXXY4sbDpk2bwHGcoZT1tm3bYunSpdJ7juPw0Ucf1agdU6ZMwfjx46u9/ZAhQ3DvvfdK75VtrC7VOT8MRqPD6wY+uhPY80Fdt4TRwKlTMdOyZUs888wz2LFjB3bs2IFLLrkEl19+uSRYFi5ciMWLF+Pll1/G9u3bkZWVhREjRqC8vLwumx0TTJkyBRzH4bbbbgv67I477gDHcZgyZUrtNyzG2b59O2655Za6bgaD0Tj49S1g19vAhzfVdUsYDZw6FTNjx47FmDFj0KlTJ3Tq1AkLFixAUlIStm3bBp7nsXTpUjz88MOYMGECunfvjjfeeAOVlZV45513NPfpcrlQVlYm+2uotGrVCmvWrEFVVZW0zOl04t1330Xr1q3rsGWxS7NmzWI6e83tdtd1ExiMyFFxpq5bwGgkxEzMjM/nw5o1a+BwONC/f38cOXIEeXl5uPTSS6V17HY7Bg8ejC1btmju5+mnn0Zqaqr016pVK0Pt4HkelW5vrf/xPG/4nPXp0wetW7fG2rVrpWVr165Fq1at0Lt3b2mZy+XC3XffjczMTMTFxeGiiy7C9u3bZfv6/PPP0alTJ8THx2Po0KE4evRo0PG2bNmCQYMGIT4+Hq1atcLdd98Nh8Ohu70nT57E1VdfjSZNmiAjIwOXX3657Dg+nw8zZsxAWloaMjIyMGvWLEPnxeFw4IYbbkBSUhKys7Px/PPPB62jdDPNnz8frVu3ht1uR05ODu6++27pM5fLhVmzZqFVq1aw2+3o2LEjVqxYIdvfzp070bdvXyQkJGDAgAE4cOCA9Nlff/2Fyy+/HM2bN0dSUhL69euHr7/+Oqg9Tz75JKZMmYLU1FRMmzYNALB8+XK0atUKCQkJuOKKK7B48WKkpaXJtv3kk09w3nnnIS4uDu3atcNjjz0Gr9er+3wxGAxGQ6HOi+bt2bMH/fv3h9PpRFJSEtatW4du3bpJgqV58+ay9Zs3b45jx45p7u/BBx/EjBkzpPdlZWWGBE2Vx4duj643+C1qzr7HRyLBZvxy3HjjjVi5ciWuu+46AMDrr7+OqVOnYtOmTdI6s2bNwocffog33ngDbdq0wcKFCzFy5EgcOnQI6enpOHHiBCZMmIDbbrsNt99+O3bs2IGZM2fKjrNnzx6MHDkSTzzxBFasWIGzZ89i+vTpmD59OlauXBm2nZWVlRg6dCguvvhifPfdd7BYLHjyyScxatQo7N69GzabDc8//zxef/11rFixAt26dcPzzz+PdevW4ZJLLtF1Lh544AF8++23WLduHbKysvDQQw9h586dOPfcc1XX/+CDD7BkyRKsWbMG55xzDvLy8vDbb79Jn99www3YunUrXnzxRfTq1QtHjhxBQUGBbB8PP/wwnn/+eTRr1gy33XYbpk6dih9//BEAUFFRgTFjxuDJJ59EXFwc3njjDYwdOxYHDhyQWc4WLVqEuXPn4pFHHgEA/Pjjj7jtttvw7LPPYty4cfj6668xd+5c2XHXr1+Pf/3rX3jxxRdx8cUX46+//pLcZ/PmzdN1vhiMqFONQRqDUR3qXMx07twZu3btQklJCT788ENMnjwZmzdvlj5X1sXgeT5krQy73Q673R619sYa119/PR588EEcPXoUHMfhxx9/xJo1ayQx43A4sGzZMqxatQqjR48GIIz6N2zYgBUrVuCBBx7AsmXL0K5dOyxZsgQcx6Fz587Ys2cPnn32Wek4ixYtwqRJk6Rg2o4dO+LFF1/E4MGDsWzZMsTFxYVs55o1a2AymfDaa69J12/lypVIS0vDpk2bcOmll2Lp0qV48MEH8c9//hMA8Oqrr2L9en3CsqKiAitWrMCbb76JESNGAADeeOMNtGzZUnOb48ePIysrC8OHD4fVakXr1q1x/vnnAwD+/PNPvP/++9iwYQOGDx8OAGjXrl3QPhYsWIDBgwcDAObMmYPLLrsMTqcTcXFx6NWrF3r16iWt++STT2LdunX4+OOPMX36dGn5JZdcgvvvv196/8gjj2D06NHSsk6dOmHLli349NNPZcedM2cOJk+eLLXtiSeewKxZs5iYYcQQTMwwaoc6FzM2mw0dOnQAAPTt2xfbt2/HCy+8gNmzZwMQ5k6i55HJz88PstZEknirGfseHxm1/Yc6bnVo2rQpLrvsMrzxxhvgeR6XXXYZmjZtKn3+119/wePxYODAgdIyq9WK888/H/v37wcA7N+/HxdeeKFMJPbv3192nJ07d+LQoUNYvXq1tIznefj9fhw5cgRdu3YN2U6yfXJysmy50+nEX3/9hdLSUpw+fVp2XIvFgr59++pyNf31119wu92y7dPT09G5c2fNba688kosXboU7dq1w6hRozBmzBiMHTsWFosFu3btgtlsloSKFj179pRek/s0Pz8frVu3hsPhwGOPPYZPP/0Up06dgtfrRVVVFY4fPy7bR9++fWXvDxw4gCuuuEK27Pzzz5eJmZ07d2L79u1YsGCBtMzn88HpdKKysjKm44IYDAYj0tS5mFHC8zxcLhdyc3ORlZWFDRs2SPEfbrcbmzdvllkMIg3HcdVy99QlU6dOlUb6//73v2WfESEQysKlRyz4/X7ceuutspgSgp5gY7/fj/POO08mhgjNmjULu304qhNz1KpVKxw4cAAbNmzA119/jTvuuAOLFi3C5s2bpXmMwmG1WqXX5Hz6/X4Agttr/fr1eO6559ChQwfEx8dj4sSJQUG+iYmJQd9F7XrR+P1+PPbYY5gwYUJQm8JZyRiMWoO5mRi1RJ322g899BBGjx6NVq1aoby8XHKPfPnll+A4Dvfeey+eeuopdOzYER07dsRTTz2FhIQETJo0qS6bHXOMGjVK6iBHjpRblTp06ACbzYYffvhBOm8ejwc7duyQXEbdunULqgezbds22fs+ffpg7969khXNKH369MF7772HzMxMpKSkqK6TnZ2Nbdu2YdCgQQAAr9eLnTt3ok+fPmH336FDB1itVmzbtk0SV8XFxfjzzz9DWlfi4+Mxbtw4jBs3DnfeeSe6dOmCPXv2oEePHvD7/di8ebPkZjLK999/jylTpkhWloqKCtXAaiVdunTBzz//LFu2Y8cO2fs+ffrgwIED1b4eDEatwPvrugWMRkKdipkzZ87g+uuvx+nTp5GamoqePXviyy+/lGIeZs2ahaqqKtxxxx0oLi7GBRdcgK+++irIVdHYMZvNkstIORNyYmIibr/9djzwwANIT09H69atsXDhQlRWVuKmm4TaD7fddhuef/55zJgxA7feeit27tyJVatWyfYze/ZsXHjhhbjzzjsxbdo0JCYmYv/+/diwYQNeeumlsG287rrrsGjRIlx++eV4/PHH0bJlSxw/fhxr167FAw88gJYtW+Kee+7BM888g44dO6Jr165YvHix7qJ0SUlJuOmmm/DAAw8gIyMDzZs3x8MPPwyTSTthb9WqVfD5fLjggguQkJCAt956C/Hx8WjTpg0yMjIwefJkTJ06VQoAPnbsGPLz83HVVVfpalOHDh2wdu1ajB07FhzHYe7cuZLVJhR33XUXBg0ahMWLF2Ps2LHYuHEjvvjiC5m15tFHH8U//vEPtGrVCldeeSVMJhN2796NPXv24Mknn9TVPgaDwWgo1Glq9ooVK3D06FG4XC7k5+fj66+/loQMIJjt58+fj9OnT8PpdGLz5s3o3r17HbY4diFVlNV45pln8M9//hPXX389+vTpg0OHDmH9+vVo0qQJAMFN9OGHH+KTTz5Br1698Oqrr+Kpp56S7aNnz57YvHkzDh48iIsvvhi9e/fG3LlzZfFMoUhISMB3332H1q1bY8KECejatSumTp2Kqqoqqd0zZ87EDTfcgClTpqB///5ITk4Oih0JxaJFizBo0CCMGzcOw4cPx0UXXYTzzjtPc/20tDQsX74cAwcORM+ePfHNN9/gk08+QUZGBgChQvXEiRNxxx13oEuXLpg2bZqhVPQlS5agSZMmGDBgAMaOHYuRI0fqsjINHDgQr776KhYvXoxevXrhyy+/xH333SdzH40cORKffvopNmzYgH79+uHCCy/E4sWL0aZNG93tYzCiD3MzMWoHjq9OsEE9oqysDKmpqSgtLQ3q7J1OJ44cOYLc3FwWZ8CIaaZNm4Y//vgD33//fY32w+55Rq2yYR7w41Lh9fzSOm0Ko/4Rqv9WUr8iXRmMRsJzzz2HESNGIDExEV988QXeeOMNvPLKK3XdLAaj+vj9QAi3L4NRE5iYYdQLjh8/jm7duml+vm/fvgY1hcPPP/+MhQsXory8HO3atcOLL76Im2++ua6bxWAYhDL88z7EUNF5RgODiRlGvSAnJwe7du0K+XlD4v3336/rJjAYNYeOYvB7AbNVe10GowYwMcOoF1gsFpaGzGDUOxRihsGIEszmx2AwGIzooLTMMBhRgokZBoPBYEQfv6+uW8BowDAxw2AwGIzoQFcAZpYZRhRhYobBYDAY0YG5mRi1BBMzDAaDwYg+zM3EiCJMzDRw2rZti6VLl9Z1MyJGdb7PlClTMH78eOn9kCFDpEk2a8LRo0fBcVzIlHEGo3HDLDOM2oGJmXrKiRMncNNNNyEnJwc2mw1t2rTBPffcg8LCwrpuWsyzdu1aPPHEE3XdDAaj4UO7mZxsOgNG9GBiph5y+PBh9O3bF3/++SfeffddHDp0CK+++iq++eYb9O/fH0VFRXXWNp/Pp2tm6LokPT09pmded7vddd2E+oWnCig4WNetYKhCiRlHQd01g9HgYWJGCc8Dbkft/xmY7/POO++EzWbDV199hcGDB6N169YYPXo0vv76a5w8eRIPP/ywbP3y8nJMmjQJSUlJyMnJwUsvvST7fP78+WjdujXsdjtycnJw9913S5+53W7MmjULLVq0QGJiIi644AJs2rRJ+nzVqlVIS0vDp59+im7dusFut2P58uWIi4tDSUmJ7Dh33303Bg8eLL3fsmULBg0ahPj4eLRq1Qp33323bFbq/Px8jB07FvHx8cjNzcXq1avDnhufz4cZM2YgLS0NGRkZmDVrFpRzqSrdTK+88go6duyIuLg4NG/eHBMnTpQ+8/v9ePbZZ9GhQwfY7Xa0bt0aCxYskO3v8OHDGDp0KBISEtCrVy9s3bpV+qywsBDXXnstWrZsiYSEBPTo0QPvvvtuUHumT5+OGTNmoGnTptLM8R9//DE6duyI+Ph4DB06FG+88QY4jpOd13DnsFHwf0OAl/sChzfXdUsYoXCcresWMBowrAKwEk8l8FQdlMZ/6BRgSwy7WlFREdavX48FCxYgPj5e9llWVhauu+46vPfee3jllVfAcRwAYNGiRXjooYcwf/58rF+/Hvfddx+6dOmCESNG4IMPPsCSJUuwZs0anHPOOcjLy8Nvv/0m7fPGG2/E0aNHsWbNGuTk5GDdunUYNWoU9uzZg44dOwIAKisr8fTTT+O1115DRkYGWrZsiXnz5uHDDz/ETTfdBEAQGe+//z4ef/xxAMCePXswcuRIPPHEE1ixYgXOnj2L6dOnY/r06Vi5ciUAIdblxIkT2LhxI2w2G+6++27k5+eHPD/PP/88Xn/9daxYsQLdunXD888/j3Xr1uGSSy5RXX/Hjh24++678dZbb2HAgAEoKiqSzUz94IMPYvny5ViyZAkuuuginD59Gn/88YdsHw8//DCee+45dOzYEQ8//DCuvfZaHDp0CBaLBU6nE+eddx5mz56NlJQUfPbZZ7j++uvRrl07XHDBBdI+3njjDdx+++348ccfwfM8jh49iokTJ+Kee+7BzTffjF9//RX333+/7Lh6zmGj4Kx4Pfa8D7QbHHpdRu1CDyQqmQucEUX4Bk5paSkPgC8tLQ36rKqqit+3bx9fVVUVWOiq4Pl5KbX/56rQ9X22bdvGA+DXrVun+vnixYt5APyZM2d4nuf5Nm3a8KNGjZKtc/XVV/OjR4/meZ7nn3/+eb5Tp0682+0O2tehQ4d4juP4kydPypYPGzaMf/DBB3me5/mVK1fyAPhdu3bJ1rn77rv5Sy65RHq/fv163maz8UVFRTzP8/z111/P33LLLbJtvv/+e95kMvFVVVX8gQMHeAD8tm3bpM/379/PA+CXLFmidXr47Oxs/plnnpHeezwevmXLlvzll18uLRs8eDB/zz338DzP8x9++CGfkpLCl5WVBe2rrKyMt9vt/PLly1WPdeTIER4A/9prr0nL9u7dywPg9+/fr9nGMWPG8DNnzpS159xzz5WtM3v2bL579+6yZQ8//DAPgC8uLuZ5Pvw5VEP1nq/vkN/QutvruiUMJZ/OCFyf7xfXdWsY9YxQ/bcSZplRYk0QrCR1cdwIwIsjIWKVAYD+/fvL1unfv7+UEXTllVdi6dKlaNeuHUaNGoUxY8Zg7NixsFgs+OWXX8DzPDp16iTb3uVyISMjQ3pvs9nQs2dP2TrXXXcd+vfvj1OnTiEnJwerV6/GmDFj0KRJEwDAzp07cejQIZnriOd5+P1+HDlyBH/++ScsFgv69u0rfd6lSxekpaVpfvfS0lKcPn1a9n3JPngNN96IESPQpk0b6fuPGjUKV1xxBRISErB//364XC4MGzZM85gAZN89OzsbgOAi69KlC3w+H5555hm89957OHnyJFwuF1wuFxIT5VY4+nsCwIEDB9CvXz/ZsvPPP1/2Ptw57Nq1a8h2Nzj42I7VavQYcKUzGEZhYkYJx+ly99QVHTp0AMdx2LdvnyzdmPDHH3+gSZMmaNq0acj9ELHTqlUrHDhwABs2bMDXX3+NO+64A4sWLcLmzZvh9/thNpuxc+dOmM1m2fZJSUnS6/j4eJl4AoSOt3379lizZg1uv/12rFu3Tub68Pv9uPXWW2XxOYTWrVvjwIEDsnZGi+TkZPzyyy/YtGkTvvrqKzz66KOYP38+tm/fHuTG08JqDcwETNpLgqCff/55LFmyBEuXLkWPHj2QmJiIe++9NyjIVylueJ4P+u5KQRbuHDY6WB2T2IO+Z5nYZEQRJmbqGRkZGRgxYgReeeUV3HfffbIONy8vD6tXr8YNN9wg6wi3bdsm28e2bdvQpUsX6X18fDzGjRuHcePG4c4770SXLl2wZ88e9O7dGz6fD/n5+bj44osNt3XSpElYvXo1WrZsCZPJhMsuu0z6rE+fPti7d6/mTNhdu3aF1+vFjh07JIvEgQMHgoKKaVJTU5GdnY1t27Zh0KBBAACv14udO3eiT58+mttZLBYMHz4cw4cPx7x585CWloaNGzdizJgxiI+PxzfffIObb77Z8PcHgO+//x6XX345/vWvfwEQBMjBgwfDWk26dOmCzz//XLZsx44dsvfhzmGjg3WWMQgtZphlhhE9WDZTPeTll1+Gy+XCyJEj8d133+HEiRP48ssvMWLECLRo0SIo2+bHH3/EwoUL8eeff+Lf//43/vvf/+Kee+4BIGQjrVixAr///jsOHz6Mt956C/Hx8WjTpg06deqE6667DjfccAPWrl2LI0eOYPv27Xj22WeDOlo1rrvuOvzyyy9YsGABJk6ciLi4OOmz2bNnY+vWrbjzzjuxa9cuHDx4EB9//DHuuusuAEDnzp0xatQoTJs2DT/99BN27tyJm2++Oay15J577sEzzzyDdevW4Y8//sAdd9wRUgB9+umnePHFF7Fr1y4cO3YMb775Jvx+Pzp37oy4uDjMnj0bs2bNwptvvom//voL27Ztw4oVK8J+d0KHDh2wYcMGbNmyBfv378ett96KvLy8sNvdeuut+OOPPzB79mz8+eefeP/997Fq1SoAAetPuHPY6GBiJrZh14cRRZiYqYd07NgRO3bsQPv27XH11Vejffv2uOWWWzB06FBs3boV6enpsvVnzpyJnTt3onfv3njiiSfw/PPPY+TIkQCAtLQ0LF++HAMHDkTPnj3xzTff4JNPPpFiYlauXIkbbrgBM2fOROfOnTFu3Dj89NNPaNWqla529uvXD7t378Z1110n+6xnz57YvHkzDh48iIsvvhi9e/fG3LlzpZgTcuxWrVph8ODBmDBhAm655RZkZmaGPObMmTNxww03YMqUKejfvz+Sk5NxxRVXaK6flpaGtWvX4pJLLkHXrl3x6quv4t1338U555wDAJg7dy5mzpyJRx99FF27dsXVV18dNqOKZu7cuejTpw9GjhyJIUOGICsrS9U9qCQ3NxcffPAB1q5di549e2LZsmVSyr3dbgeg7xw2LtjIP+ZgbiZGLcHxWpGRDYSysjKkpqaitLQUKSkpss+cTieOHDmC3NxcmdWAwYhFFixYgFdffRUnTpyo9j4a5D0/P1X433UccPVbddsWhpxP7gF2rhJeD5oFXPJwyNUZDJpQ/bcSFjPDYMQor7zyCvr164eMjAz8+OOPWLRoEaZPn17XzYpd2Mg/9mCWGUYtwcQMgxGjHDx4EE8++SSKiorQunVrzJw5Ew8++GBdN6t68Dxw9Aeg+TlAQnr49at7DEYMw64PI3owMcNgxChLlizBkiVL6roZkWH3+8C6W4DkbGDmH+HXrw48S82OPZhlhlE7sABgBoMRffZ/LPwvPx29Y7DOMvZgbiZGLcHEDIKLkTEYDZUGfa+zzjK2YdeHEUUatZghlVsrKyvruCUMRu1A7nW6anGDgVUAjkFY0TxG7dCoY2bMZjPS0tKkuiEJCQlRL5/PYNQFPM+jsrIS+fn5SEtLC5qeokHARv6xB61f2PVhRJFGLWYAICsrCwAMFUJjMOoraWlp0j3f8GAj/5iGWWYYUaTRixmO45CdnY3MzEx4PJ66bg6DETWsVmvDtMgQ/GzkH3uwAGBG7dDoxQzBbDY37Ac9g9HQYZ1l7MGymRi1RKMOAGYwGA0I1lnGIEzMMGoHJmYYDEbDgHWWsQ27PowowsQMg8GIPrWRJcgqAMcezM3EqCWYmGEwGLVAbYgZ1lnGHkzMMGoHJmYYDEbDgHWWMQ5LzWZEDyZmGAxGw4CJmdiDZxWAGbVDnYqZp59+Gv369UNycjIyMzMxfvx4HDhwQLbOlClTwHGc7O/CCy+soxYzGIyYhXWWMQhzMzFqhzoVM5s3b8add96Jbdu2YcOGDfB6vbj00kvhcDhk640aNQqnT5+W/j7//PM6ajGDwYhZWGcZ27Drw4gidVo078svv5S9X7lyJTIzM7Fz504MGjRIWm6323WXYHe5XHC5XNL7srKyyDSWwWDENmyiydiDZTMxaomYipkpLS0FAKSnp8uWb9q0CZmZmejUqROmTZsWch6lp59+GqmpqdJfq1atotpmBoOhg1pJzWadZezBxAyjdogZMcPzPGbMmIGLLroI3bt3l5aPHj0aq1evxsaNG/H8889j+/btuOSSS2TWF5oHH3wQpaWl0t+JEydq6yswGIw6hcXMxBwsAJhRS8TM3EzTp0/H7t278cMPP8iWX3311dLr7t27o2/fvmjTpg0+++wzTJgwIWg/drsddrs96u1lMBgxBhv5xzbs+jCiSEyImbvuugsff/wxvvvuO7Rs2TLkutnZ2WjTpg0OHjxYS61jMBj1AtZZxiDMzcSoHerUzcTzPKZPn461a9di48aNyM3NDbtNYWEhTpw4gezs7FpoIYPBiDiuiujsl7kxYg8WAMyoJepUzNx55514++238c477yA5ORl5eXnIy8tDVVUVAKCiogL3338/tm7diqNHj2LTpk0YO3YsmjZtiiuuuKIum85gMKrLpqejtGMmZmIaPWLT52WilFEt6lTMLFu2DKWlpRgyZAiys7Olv/feew8AYDabsWfPHlx++eXo1KkTJk+ejE6dOmHr1q1ITk6uy6YzGAxDUNlM+fuicwjWCcYgBiwzXhewtDuwcnR0m8RokNRpzAwf5uETHx+P9evX11JrGAxGvYa5MWIPI26mk78A5aeFPwbDIDGTms1gMBg1gllmYpww18dkrp1mMBokTMwwGIxaJloF9JiYiT0MWGY4qjtiwpRhECZmGAxG7RKtasDMzRR7GHEzycQMu5YMYzAxw2AwGgZsNB/bGBEzbJ4thkGYmGEwGNGHzc3ECHd96JgZvze6bWE0OJiYYTAYtQxzMzUajMzNxFFihmeWGYYxmJhhMBgNBOZmij0MiBlmmWHUACZmGAxGw4DFzMQ2hmJmmJWNYQwmZhgMRi0TJdHBxEzsIXMzGXAdKS0zp3YBBzdEpEmMhklMzJrNYDAaEdESHSxmJgahrrWRDCWl8Pm/wcL/6TuAph1r3ixGg4NZZhgMRi1AB/1Gy4LCLDMxTTjLDC1ytWJmCv+KXHsYDQomZhgMRu0SLQsKczPFHrwRy4yOdZn1jaEBEzMMBqMWMFAJttqHYB1d7GHguusRPixlm6EBEzMMBiP60J1T1CwozDITc1TXMqMlWlhlYIYGTMwwGIzoY7YGXlsTonMMZpmJbQzFzDA3E8MYTMwwGIzoY7YFXlvjo3MM1tHFINXMZtIKAGbXmKEBEzMMBiP66MlUieQxGLGBoTozzM3EqD5MzDAYjOhDj6ij1iExMRPThKvqGyk3k88LHN8GeF3628ao9zAxw2Awoo9MzHiifwxGjFBNy0xNspm+nge8PhL4+K7w6zIaDEzMMBiM6CMTM2wSwUaDkWwmPa5IPVa9rS8L/3e/F35dRoOBiRkGgxF9asXNxIhpjNSI0VqXWd8YGjAxw2Awog+zzDRSqlsBmLpHqjtZJaNRwcQMg8GoBagOyRelmBlG7GFEiPAa1YJl7idmmWGow8QMg8GIPrWRms2IQapbAZjXWM7EDEMdJmYYDEb0YTEzDCMBwDLLDP2a3TsMdZiYYTAY0YfFzDROqhvvoulmYmKGoQ4TMwwGI/rURp0ZRmxjyM3k17FcQWUR8N711WkZowHAxAyDwYg+zDLDCBsATL+uhpvp63nA/o+r1TRG/YeJGQaDEX2Yq6BxopwvK2Q2Ug2zmcpOG2oao2Fhqc5GHo8HeXl5qKysRLNmzZCenh7pdjEYjIYEs8w0UhRihvdBcwytFQCs183EcUYbx2hA6LbMVFRU4D//+Q+GDBmC1NRUtG3bFt26dUOzZs3Qpk0bTJs2Ddu3b49mWxkMRn2F7oRYnZnGQ5BlJpRVTkc2U8jJRJmYaczoEjNLlixB27ZtsXz5clxyySVYu3Ytdu3ahQMHDmDr1q2YN28evF4vRowYgVGjRuHgwYPRbjeDwahPMMsMA9Cf0cRr1JxRiiMaZplp1OhyM23ZsgXffvstevToofr5+eefj6lTp+LVV1/FihUrsHnzZnTs2DGiDWUwGPUYFjPTSDFgmdHjZgoJEzONGV1i5r///a+undntdtxxxx01ahCDwWiAMMtM40RpSQlpmamhm4lZZho1LJuJwWDUArRlhsXMNFpCZSPpmZsplJuJWWYaNbosMxMmTNC9w7Vr11a7MQwGo4HCpjNopETAMqMXZplp1OiyzKSmpkp/KSkp+Oabb7Bjxw7p8507d+Kbb75Bampq1BrKYDDqMUpXQcgRNqPBYCibid6uOtlMjMaMLsvMypUrpdezZ8/GVVddhVdffRVmsxkA4PP5cMcddyAlJSU6rWQwGPUb5Ujb7wPM1SpzFeY4PBuhxzKhLDM1dTOx696oMRwz8/rrr+P++++XhAwAmM1mzJgxA6+//rqhfT399NPo168fkpOTkZmZifHjx+PAgQOydXiex/z585GTk4P4+HgMGTIEe/fuNdpsBoNRlyjFTLRmP66Oe4IRRSJQZ0a3+4mJmcaMYTHj9Xqxf//+oOX79++HP2Sp6mA2b96MO++8E9u2bcOGDRvg9Xpx6aWXwuFwSOssXLgQixcvxssvv4zt27cjKysLI0aMQHl5udGmMxiMukLNMlMbx2HULUaymTQtM1ouJwXMMtOoMWznvfHGGzF16lQcOnQIF154IQBg27ZteOaZZ3DjjTca2teXX34pe79y5UpkZmZi586dGDRoEHiex9KlS/Hwww9LQchvvPEGmjdvjnfeeQe33nqr0eYzGIy6wFCKbk2Ow8RMbFHduZm0XjPLDEMdw2LmueeeQ1ZWFpYsWYLTp4WJvbKzszFr1izMnDmzRo0pLS0FAGmupyNHjiAvLw+XXnqptI7dbsfgwYOxZcsWVTHjcrngcrmk92VlZTVqE4PBiABBgaBRqjXDxExso7sCMJubiWEMQ3MzAYDJZMKsWbNw8uRJlJSUoKSkBCdPnsSsWbNkcTRG4XkeM2bMwEUXXYTu3bsDAPLy8gAAzZs3l63bvHlz6TMlTz/9tCz7qlWrVtVuE4PBiBBBbqYoiQ4mZmILI9lMutxMrM4MQx3dYqZp06YYPXo0li1bhpMnTwIAUlJSIpbBNH36dOzevRvvvvtu0GecQnHzPB+0jPDggw+itLRU+jtx4kRE2sdgMGpAbQUAsxo2MUYkKgAzywwjPLrFzIEDBzBmzBh8+OGHaNeuHfr164cnnngCu3fvrnEj7rrrLnz88cf49ttv0bJlS2l5VlYWAARZYfLz84OsNQS73S6JrEiKLQaDUQNYAHDjo/Rv4NSv8mU1nZuJxcwwNNAtZtq0aYO77roLX3/9NfLz8zFjxgzs3bsXgwYNQm5uLu655x5s3LgRPp/+hxTP85g+fTrWrl2LjRs3Ijc3V/Z5bm4usrKysGHDBmmZ2+3G5s2bMWDAAN3HYTAYdQxLzW58fHxX8LKazs3ELDMMDao1N1NqaiquvfZarFmzBgUFBfjPf/4Dv9+PG2+8Ec2aNcPq1at17efOO+/E22+/jXfeeQfJycnIy8tDXl4eqqqqAAjupXvvvRdPPfUU1q1bh99//x1TpkxBQkICJk2aVJ2mMxiM2obngcKD8mVRs8ywCrExQ+FfwctqPDcTs8ww1KlxCU6LxYJLL70Ul156KV566SX8+uuv8Hr1ZSosW7YMADBkyBDZ8pUrV2LKlCkAgFmzZqGqqgp33HEHiouLccEFF+Crr75CcnJyTZvOYDBqgwNfBC+LlGUmKOWbWWZihsSmQMkx+TKWzcSIEtUSM06nE7t370Z+fr6sUB7HcRg7dqzu/fA6RlEcx2H+/PmYP39+dZrKYDDqmr++CV4WqWym2qpfwzBOYrPgZSFT8lmdGUb1MSxmvvzyS9xwww0oKCgI+ozjOEMxMwwGoxHgqgheFjHRwSwzMYslLnhZyABg+nU1xAyzzDRqDMfMTJ8+HVdeeSVOnz4Nv98v+2NChsFgBOFWETMsm6nhY1KpO1adAGAti00QTMw0ZgyLGZLJpJUazWAwGDLUxAyLmWn4cCrdS7UCgPVmM1Urn4XRQDB89SdOnIhNmzZFoSkMBqNBomaFidh0BkzMxCycUcsMvV51iubp2zWjYWI4Zubll1/GlVdeie+//x49evSA1WqVfX733XdHrHEMBqMBYFJ5zERrOgNWATh2ULXM1NTNxMQqQx3DYuadd97B+vXrER8fj02bNsmmFeA4jokZBoMhx2wNXhY1NxOrMxMzmFTETKjrXlM3EzPNNGoMi5lHHnkEjz/+OObMmQOT2s3KYDAYNKqWGZbN1OCJlGWGZTMxdGBYjbjdblx99dVMyDAYDH2oiRk2nUHDx2jMDJubiVEDDCuSyZMn47333otGWxiMyFNZBPz+IeCpquuWNF7U3EyRssywbKbYRS01W2+sFJubiWEQw24mn8+HhQsXYv369ejZs2dQAPDixYsj1jgGo8asngic3AmcfyswZmFdt6ZxElXLDKsAHLOouZl015lhFYAZxjAsZvbs2YPevXsDAH7//XfZZxxTxoxY4+RO4f+e95mYqStMapaZKFlQmGUmdlBzM4WsAFzDonms/2nUGBYz3377bTTawWBEF1ZQq+5Q62NY0byGT40sMyybiWEM9oRnNBLYg67OUBtMs2ymho+apaQ6lhnZnE0sZoahjmHLjNPpxEsvvYRvv/02aNZsAPjll18i1jgGI2KwB10dQvVGLc8H/v6Z1ZlprNR4biZmmWGoY1jMTJ06FRs2bMDEiRNx/vnnszgZRj2B3ad1BhEYwx8DDn4lvI7YdAYKWAXg2EFNWNZ2NhPPs4FMI8GwmPnss8/w+eefY+DAgdFoD4MRHVjMTB0idmocF7gOzM3UCFARM9WqAFwDywwTM40Gw0/4Fi1aIDk5ORptYTCiB3ug1R1SZ8QFao9ESnSwAODYRdUyE0U3k6plht0PjQXDYub555/H7NmzcezYsWi0h8GIEkzM1B20ZUYUM9FyB7HOK4aoiWVGQ8Ac2RwiLkpNzDC3Y2PBsJupb9++cDqdaNeuHRISEoKK5hUVFUWscQxGxGCWmbpD1TLD3EwNnkhZZpT7cZwFkjKDN2eWmUaNYTFz7bXX4uTJk3jqqafQvHlzFgDMqCfUwn365YPC/1FPR/9Y9YooWmaC3ExsJB47GLTMyNbTcDMBgM+tsY1R8cRoSBgWM1u2bMHWrVvRq1evaLSHwYgO0RbdzlJg2yvC64vvBxIzonu8+kRULTPKY7GReEwTKptJMwBYsY3XpbUDlUXsfmgsGI6Z6dKlC6qq2KR9jHpGbVoQvc7aO1a9oDazmVidmZhB7VpUxzKj3I+WmFE9HhMzjQXDYuaZZ57BzJkzsWnTJhQWFqKsrEz2x2DEJtEWM9T+/Z4oH6uewbKZGinUtek1Sfhf07mZgBCDBSZmGjOG3UyjRo0CAAwbNky2nOd5cBwHn4/5KBkxSLQtM/RD0xelgnD1llrMZmIxErEDESeD5wAucaBb07mZgBCWGRXhwsRMo4FNNMloJIQQM34/UHoCaNKm+runH5rMMiNHZpkRHznRqgDMOq8YQs29qPO6h3Iz+Qy4mZi4bTQYFjODBw+ORjsYjOgSyjLzvzuB394Bxr8KnHttzY/lY2JGDtWpRToAmLmZYhc192J1AoCD3EwsAJgRjK6YmePHjxva6cmTJ6vVGAajTvjtHeH/phqkVDPLjDZ0J8WmM2hEqLgXdbuZNF4DLACYoYouMdOvXz9MmzYNP//8s+Y6paWlWL58Obp37461a9dGrIEMRkTQ03nWJBOG3tarUQej0aJmmYlSJ8M6r9hB1TJTw7mZAIMxM8zN1FjQ5Wbav38/nnrqKYwaNQpWqxV9+/ZFTk4O4uLiUFxcjH379mHv3r3o27cvFi1ahNGjR0e73QyGMdSEirMU2LuOWqcGDz5ZALCWGbyRQndqUS+ax8RM7EBELKphmWHZTAxj6LLMpKen47nnnsOpU6ewbNkydOrUCQUFBTh48CAA4LrrrsPOnTvx448/MiHDiE3UHmqf3CP8EWrSwcrEDHMzySCCgzOx6QwaExGzzCiuqZYblwUAN2oMBQDHxcVhwoQJmDBhQrTaw2BEB7VOjrbKADXsYGk3E7PMyKnN6QyYmIkdqOtOxs2RKJqnWfpAzTLDiig2FgwXzWMw6iVqnZxJoeXDdbA+L7DyMuCL2aH3z9xMcthEk40T6dLozGbS62YyYplh90OjgYkZRuNA7aFmtinWCdPBHtkEHPsB+OlVlf1TD1Jm2lYQxekMmGUmhjGYzaTXzWRkokkWANxoYGKG0ThQtcxY5e9DjhoR2mQtS81mD1AZUZ3OQBlPwc59zGA0ZkazAnBN3ExM3DYWmJhhNA7URmhma/h1aLgQPxfZw5d1qHKiOZ0Bs8zELjWxzNDXlbmZGOFhYobROFB1MyktM2E6WDK6VD9A6GM1ZqI5nQFzM8Uuhi0z9Lah3ExaYkbl2jNLXaOhWmLmrbfewsCBA5GTk4Njx44BAJYuXYr//e9/EW0cgxEx1EZthi0zlJhRPiRZzEwIojmdgT/0e0YdohIrFfL66HQzaVbYZpaZxoxhMbNs2TLMmDEDY8aMQUlJiTRLdlpaGpYuXRrp9jEY1UdzrhcRTmFpMWKZUVoWwh2rMSMrmqenUzO0c41jMeqcSNWZUV5jTcsMEzONGcNi5qWXXsLy5cvx8MMPw2wOPNz79u2LPXv2GNrXd999h7FjxyInJwccx+Gjjz6SfT5lyhRwHCf7u/DCC402mdFYMSwwwnSEXCgxE8Is3uhRy2aKVACwUswwq1jsUJO5mUIFADPLDCMYw2LmyJEj6N27d9Byu90Oh8NhaF8OhwO9evXCyy+/rLnOqFGjcPr0aenv888/N9pkRmMl0gKDtswoH6gsm0kbVmemcRKtuZk0A4DV5mZi90NjwVAFYADIzc3Frl270KZNG9nyL774At26dTO0r9GjR4ed/sButyMrK8toMxkMRDwol85mCnooMzeTNqwCcIPkzD7g9C6g17VilV8lRi0z9Kah3EwaweNsOoNGjWEx88ADD+DOO++E0+kEz/P4+eef8e677+Lpp5/Ga6+9FvEGbtq0CZmZmUhLS8PgwYOxYMECZGZmaq7vcrngcgUqsJaVlUW8TYx6QjRdPyHdTOwBKiOalhkmZuqOZf2F//ZkoOvY4M+jVmdGa1Z65mZqzBgWMzfeeCO8Xi9mzZqFyspKTJo0CS1atMALL7yAa665JqKNGz16NK688kq0adMGR44cwdy5c3HJJZdg586dsNvtqts8/fTTeOyxxyLaDkY9JeJBuXTGktLNxLKZtGF1Zho0p3apixnVLLYQ10erzkxNJppkA4tGg2ExAwDTpk3DtGnTUFBQAL/fH9JSUhOuvvpq6XX37t3Rt29ftGnTBp999pnmZJcPPvggZsyYIb0vKytDq1atotI+RowTacsM/axkAcD6oTsZ4o5gFYAbPrIsthrUmdGdzcRiZhoz1RIzhKZNm0aqHbrIzs5GmzZtcPDgQc117Ha7ptWG0cgI+yAzmMYbKsiXuZnCo3eEboQgNxNLzY4dDNYX0hsA7HWG315tP4wGjWEx07t3b3AqwV4cxyEuLg4dOnTAlClTMHTo0Ig0kKawsBAnTpxAdnZ2xPfNaIhEumOjXUnKIET6M/YAlVGTEXr4nSvesnMfM8gscjWJmVFc08ObgMK/gIz2is3VKgCz+6GxYDg1e9SoUTh8+DASExMxdOhQDBkyBElJSfjrr7/Qr18/nD59GsOHD9dVDbiiogK7du3Crl27AAhp37t27cLx48dRUVGB+++/H1u3bsXRo0exadMmjB07Fk2bNsUVV1xh+IsyGiFB1WFrKG7o7UOlZrMOVQGrANw4qcF1V3MzcZRV76U+YbYJsYzRIDFsmSkoKMDMmTMxd+5c2fInn3wSx44dw1dffYV58+bhiSeewOWXXx5yXzt27JBZcEisy+TJk7Fs2TLs2bMHb775JkpKSpCdnY2hQ4fivffeQ3JystFmMxojapkudOE7o+JG5mZSxszQr5mbSUY0LTMsmyl2Uav8HMpSEs7NZEsEXCGyU5mYadQYFjPvv/8+du7cGbT8mmuuwXnnnYfly5fj2muvxeLFi8Pua8iQIeBDdCjr16832jwGI0BQcKg39JQE4XdIbRsiZoYFoSowmNVSnX1Lb9m5jzl0W2bCuJmsCdUQM+x+aCwYdjPFxcVhy5YtQcu3bNmCuLg4AIDf72dBuIy6J6hyqOLBplkWXcf+glKzmZtJE9W5mZhlpuGgMSA1apELNzeTLUG+vtLKwywzjRrDlpm77roLt912G3bu3Il+/fqB4zj8/PPPeO211/DQQw8BECwqalMeMBgSJceBslNA62jOtaUUMwpLjObsu1q7C+Fmko0q2WhQTjTnZlLsp7IIOPg10H6o3ArHiB6a1nUVi1woa6hWBhPtZqLxuQFTnPr2BGYlbTQYFjOPPPIIcnNz8fLLL+Ott94CAHTu3BnLly/HpEmTAAC33XYbbr/99si2lNGweO9fwOnfgHt/B9KiVAdIzc1Eo1UWXXuH2vuSCR02GpRRm3Mz/fKG8DfyaaD/HRE6BqNaqFlmQqZma1g3yWtbknx9nwuwUmKGVQBu1BgSM16vFwsWLMDUqVNx3XXXaa4XHx9f44YxGjgV+YH/URMzYVwQhi0zdDaTUsywuZm0oUboiHIAMGH3e0zM1DlqlplQv40w1s1ERV0zr2JaA9U6M6zuUGPBUMyMxWLBokWL4PMx0x2jhpAO33AQbjWOQQiyzETQzcSK5mlTm3MzScuZoIwqeqyPRmOlNC0z4n5MirG3zyV/zwKAGzWGA4CHDx+OTZs2RaEpjEYFeUAZtY4YO4j8LS1AeL4aDzq9bib2AJWjEjMTrWwmaTEbkUcVXYMQNcuMzgBgej3pXlEUa/XqETNM1DYWDMfMjB49Gg8++CB+//13nHfeeUhMlAdljRs3LmKNYzRgyEPGqHWkOscg0A/g6hw3VDaTVlopIzJ1ZgoOAT+9Clx0L5DaUmXfymOyaxBV9IiZGsXM0OvRbkoKPWKGDSwaDYbFDAnsVasjw3Ecc0Ex9CG5maJ4v4SahLA6FqFQM2MzN5M25NxwHGCqpmXm/wYD7gqg9AQw6b3gfQcdk12DqCITMzqsYIYtMypuJk7hSNDlZmKitrFgWMz4WaYGIyLUgpspVJ2ZalmEQrmZ2NxM2lCdUXUtM+4K4X/hIfV9K2Ej8uhi1M2kxzKjFQCs6WaiAoD/2gj8vV1ll+y32FgwHDPDYESEunYzVSfwmN5f0NxMzM2kSSQDgJMVk8wyN1PdoBrTokDtuoeczkAr7ox2M1GChrbMvKUxXx+z0DUaDFtmAMDhcGDz5s04fvw43G55etzdd98dkYYxGjhSAHAUs5lClbrXElE8H+ybpz8jhAoA/u0dYNyLgNmqv6kNGtIZQT5ZYER2rdWRMjETVWQDAy3BoBb4rbcCsC94OWcS/shnytTscPtkNGgMi5lff/0VY8aMQWVlJRwOB9LT01FQUICEhARkZmYyMcPQR62kZofIZtJybykno5R/qL4v5WeAULit3816WtnwkU4NXQG4miPmIJGiZZlhI/KookfMqFpmdAYAa2Uz0WJGGTNDGHgvkL8POPgVczc2Igy7me677z6MHTsWRUVFiI+Px7Zt23Ds2DGcd955eO6556LRRkZDhDzoatXNRD3YlJkQauuE2l+oAGAAKDoSvn2NBrWJJqvZyQSdd5aaXSfoctlGKGZG7f4BtH/DuYMAe4q4KbPQNRYMi5ldu3Zh5syZMJvNMJvNcLlcaNWqFRYuXCjNzcRghKVOLDPUA9LtUN8m5NwxoSaaVBxLWeCrMaNWPK26QdJ6LTNsRB5dQs5TRtapgWUGCNwjvIq7ChDmZlKDM0VhdnZGrGNYzFitVnBiTEHz5s1x/PhxAEBqaqr0msEIiyRm6iAAeO9HwNZ/a2yjc+QYKmYGYJMcyoigZUa5HUvNrns0f8Mqlhnw+oO2yTVUupkItGXGStU7I7E19D4YDR7Dw8fevXtjx44d6NSpE4YOHYpHH30UBQUFeOutt9CjR49otJHRICEBwBF42Pi8wLtXAyk5wLiXgo9BIALkv5O196V3Vt+wYoZZZiQiUTRP2peyw2PZTHWCnorX9LWhxb3fB5gtguXFZFJfX1rPCnVRBLllhg7ap0sAsPug0WDYMvPUU08hO1tIj3ziiSeQkZGB22+/Hfn5+fi///u/iDeQ0UCJZGr2sR+BQ18Dv7wpnwBSzTITLpZCb1GvoBm3mZtJG9oyI56X6roXg64PEzN1QqjMPiVK9xDvA376P2BhW+D0b9RyLcsM2Y8JuPadwOdaMTOcKSBu2H3QaDD8xO3bt6/0ulmzZvj8888j2iBGIyGSbqaSY4HXVcVAUjP5MehjhhNPIS0GBtxMymqljRnaMkPS1asrZtSuqZ71GBFGh5hRi5kBhN/YFw8Ir/93J3DbD8H7JOsBcjdT24uAXpOE8geybCalZaaGsVmMegd74jLqhkjWmXFXBl5XFgYfg+D3hj9etd1MSssMi5kJoGKZqa5FLkjMaKzHOrHooicAWMs9RMexeJzUcq26UIq5maxxwn9vCDcTCwBudBgWM2fOnMH111+PnJwcWCwWKauJ/DEYYeF5SA+oIHdNNaAfppUF1HFU3EzhLEF6i3qFs8woS683ZlQtMxESM6zOTN0Qap6yoHVULDME2roSNptJ7K7M9uBttSwz7D5oNBh2M02ZMgXHjx/H3LlzkZ2dLWU2MRi6CTn7dDWghYUs5VrFbB1OPOm1FIUTM9HM0qprDm4AmnYEmrTVuQFtmaHcTKGqLWsRrr4PgczlxIgONbLMUNvS1hUty4xybiaLLXhb+jZiAcCNEsNi5ocffsD333+Pc889NwrNYTQODAQP6oHeB+2+ULXMhBMzeueOUezHUyV/H81igHXJ0R+B1ROF1/NL9W0js8xQjxy/1/iUD0Gp2SECuvP3A5ld9e/b7xc7XjZAC08NY2YIdEaSZpFLhZtJ1TJDQQccs3pDjQbDbqZWrVqBZ9U1GTVBNmFjJMQM9cCiLSLK29TvC28x0Vs0TylWPJXy91oFveo7ebursZGKZQaonuDT62YCgO8X69+vuxJ4qTfwwVTjbWqMhPotBFYS/kkCkWQYaYgZrbnUlG4myTITws1U03pGjHqHYTGzdOlSzJkzB0ePHo1CcxiNAl0magPILDMhUrN5X/gOVHfRPMV6lUXy9w3VMpPQNPBa73dUi5kBqueK01tnBjCWUfbnF0DxUWDvWuNtaowYqjMjCg1iWdn4RGAdb6iYGQ03k2SZ0QoAZpaZaHLvml8x8JmNKK2MrWecLjdTkyZNZLExDocD7du3R0JCAqxWuZm4qKhIuTmDISeaMTP+cG6mMA+36mYzfbdQ/r6hipm41MDrinwgtYWOjbQsM17g7x3A+5OBkU8C51wRfldKN2ComAgjYobOqmHoQI+rWOEeItfq17epbenfq85sJosoZnRZZljMTCRxenz4aNcpAMBX+/JwZd9WddyiALrEzNKlS6PcDEajQuZmikCnLzNb0/tTS81WHK/7RODvn4GS44F1NI9jQIQ1VDcTfe30BtnKYifETBPeL5zDNdcBFXnAf6doixn6vAdZzkJYZkwGxIxW/AVDHaNzMxndJxAim0l0M+mpAMwsMxHlr7OB33xxZWw943SJmcmTQ5R/ZzCMosdEbQTNmBkVs7VSPCU1B+7dAyztKRTfq04AsNo2DdUyI6sRUqW9nnwj4R/pcExWQTz4PPr2QZ93I24mIyizalgQcGjo067XMhN2n+HmZhJRtcxQMMtM1CihXEsFFbElZgzHzHz++edYv3590PKvvvoKX3zxRUQaxWjoRNHNRMfMKIWS3xf84CWjd11l9jViZtS+Q0NNzaa/t1ZnIlvfDzjLxDdEzJBzbTTmBsHXNFRnZURQeik3U0MVopGkOjEz4Xcqf6uZzaRimZHnZrM6M1GirCrw2yh3xtbvxLCYmTNnDny+4BvE7/djzpw5EWkUo4ETaTeToZgZpZgRO1Y92Q9aRfPoh2rXccHLGhL0+fHqiDP5cCrgLBFek/6GpGf7vAjpJpKOGcIyE2p7PWKLQF+vhnrtIko1YmbC7lLLMqPMZlKxzMiOwTM3U5QoowRMmTMCyRsRxLCYOXjwILp16xa0vEuXLjh06FBEGsVo4EQ1m4kWM0rLjDdYPJGHnh7LjJYIo1/nDgpe1pAwapnZu456Q7mZAAOWmWq6mQ5+BSy/BMjbo+84BCZmwqMnfozcH0R8hN2n4r1fIWaCspk0AoB5ajZuZpmJKKUyy0w9FzOpqak4fPhw0PJDhw4hMTExIo1iNHCMzLirB5llJkxqdpBlxiz/X52JJiXhwgHWeMWyBoaseqvBDCCSlk3++zz6Yl5CipkQbiZPJXByJ7D+YR2NozrDhnrt9FCRD7w2XJ5xpIaeAQmpvWSJ13dsLctMUDaTWgVghZiRLDMsZiYcTo9+wVdWFbjW9d7NNG7cONx7773466+/pGWHDh3CzJkzMW7cuIg2jtFA0VVwywB+jWwm5YNMrWgeeejpMUtrxW6QkbzZFrA6NNTRvVHLDI09WfhveOZsHfMAhULPNjKrWwO9dnr45jHg7+3CbNYh0XFNSLo7mRgyHFrZTGT/5DcargIw72dF83Ty/o4T6DL3S3zy2yld69Nupor6bplZtGgREhMT0aVLF+Tm5iI3Nxddu3ZFRkYGnnvuuWi0kdHQiLibSW82k0qdGZPCzRQyZoZutyf4tdkmtzrUFw5uAN66Aig9GX5dozEzNPYU4b81QfjvqUSNY2b0WHbMOpI2mZgRUBZ/1ELPb9grZqrptcxoVgAW/5PfqvQbo4+rtMyYAq8Zmsz6QKjoffeaX3WtT7uZKt2xJRQNz82UmpqKLVu2YMOGDfjtt98QHx+Pnj17YtCgQdFoH6NBUltzM6nEzCgfbkFupmpMNEmOabYGMi3qUzYTmWvp03uB6/4bel1/DcSMLQkAUOqzIRVARVkpkgy7mQzUmSHoEZaRDkqvr+i9//W4iiXLTDXdTOReU1pmVOPb6FpEfhYAbBC9FQ7obKYqA+6p2sCwmAEAjuNw6aWX4tJLLwUAlJSURLJNjIZONAOAZa9VUrOVD0xDAcBhspnMVmrUWA9H92Wnw69TE8uMxQavz4/fz/ow0Az8dOA4hunZTk/MDGfWtqrpcYdpWd0aG9Vy/als4/cH3EC6xYzSMkOK5hHLjLKMgoYVNrEZczPpwOOT/5acHh/irGaNtQXoDCaHq567mZ599lm899570vurrroKGRkZaNGiBX777beINo7RQIl4arZGzIyam0n5wCQPPT1zuWhNkOmr524mgp4Hv9aMxzopqHCjEkIMRWlZCfS5mULVmRE/M4V4COtpJ3MzCei2zISpM0NPvGqpZswMuR/9lGAF1GOuyLZDHgLSWrO5mXRQ7JDf56dKwhewpC0zLq8fPn/sTDptWMz85z//QatWwnwMGzZswIYNG/DFF19g9OjReOCBByLeQEYDpNbmZtJhmSGjPPKA/GwG8HI/wFWucqAw2Uy0m6leihkd8QVGhSiJk2lxHgDgTJkTlRACOJ0OtXOsdkz6gckHvwcC11EN5mbSj97OP1wQPz1hZzjLjN8vVIJWTvLp14iZMdF1ihTtOWe8fF0WM6NJkWI6gpM6xAwdMwPElqvJsJvp9OnTkpj59NNPcdVVV+HSSy9F27ZtccEFF0S8gYwGSMSnM9CaNVsloDDIzUQKcYkPXGep8Lfnv0DfqYrtw7iZTNb6nc1kVMzocd9Y4wFXGTD2BQBAfrkLDl4QM36X3rmdVGIpSFAvrxi1q8EsM/rRLWbCuIoLDgZeh7KaAcL5/n6x9jE0Y2ZUrLDk98wxMRMOZQDviSIdlhlFOnal24ske7WiVSKOYctMkyZNcOLECQDAl19+ieHDhwMAeJ5XrQwciu+++w5jx45FTk4OOI7DRx99JPuc53nMnz8fOTk5iI+Px5AhQ7B3716jTWbEGtGcaFKWZWQgAFhZ2Mun8oDWiqtQjZmph6N7PQ9+o24mqSMSHjVlVR5UiW4mzu0wXmcGULgXYsTN9PdO4Pg249vFGrpjTBSTfyqvY2Iz4X+HEeF35XMDp1VCFLQsM6puJkVhPeZmCkuVQsycKQsdA+fy+uD0yH+Lyn3UJYbFzIQJEzBp0iSMGDEChYWFGD16NABg165d6NChg6F9ORwO9OrVCy+//LLq5wsXLsTixYvx8ssvY/v27cjKysKIESNQXq7TPM2IUSLsZtISR6oxMxoBwEGmcLVOViN2gy63Xh+zmQi6LDNaM5SH2ad4nis9PrhFg7DfozOAOOg6qsyMTs67GobFjMFr5/MCr10CvD4SqCo2tm2sEcpdR6NVrZdAznlyVvh9+TzqYlSKmQmRzSSJGOVkpiwAOBxKIXK2IrSllRTM4zggI1H4vTlcsXN+DduHlixZgrZt2+LEiRNYuHAhkpKEdMvTp0/jjjvuMLSv0aNHS2JICc/zWLp0KR5++GFMmDABAPDGG2+gefPmeOedd3DrrbcabTojVoi0m0nL/RMUM+NXCQAWfwLKIEU1i4FmOiotZhq4m8moZUYxqq50eeFG4BzxVj78NIQhLTPiZxEVMwavHS2uyvOA+CbGto8laDHjp6YFUKJ2Teh6PnRQfDh87oAlRbZPpWVGkc1E1jFbtN1MzDKjSaUi3qWgPIyYEV1MSXYLEu0WFDrcqPLETkaTYTFjtVpx//33By2/9957I9EeiSNHjiAvL09K/wYAu92OwYMHY8uWLZpixuVyweUKXJSysjLV9Rh1SKQrAGvtT83NpBxSSm4mZcaFmpgJYwHiuIbvZuKNupnknYzD7YOXFx47zbhScHR6N89rTEqoNZsy1WZy3gHhWhqdBbsmlhm6PW6HsW1jDdpC4nMDJq1MJOU1UXRqdFXscPjcoS0zyokm6Wvt96iLGRMrmhcOp8IyUxDWMiP8LlLirEiwiYOTGHIz6RIzH3/8MUaPHg2r1YqPP/445LqRmtIgLy8PANC8eXPZ8ubNm+PYsWOa2z399NN47LHHItIGRpSIdDaTViyLHjeTRwx6U5ZcV+3QDLiZ6qOY0TOPjd+gBUPRyVS5veBFy8wo83bFvr3yjkq5D+m4dLyS0In6rQmSz9xvjoOJFjNG68wYvXZ8QxIztHXFpT0VQShrGSCPIwuHz6MewB2uaB59XHpAQa/LLDOaVLqFc5eVEoe8MicKKkL/nkkmU2q8FXFWk7iP2Dm/usTM+PHjkZeXh8zMTIwfP15zPY7jDAcBh4NTjNR4ng9aRvPggw9ixowZ0vuysjIp+4oRI0S6aJ6mxURHADB56CotM2qdkla7peWcPJtJ09IQo0TDMkPWpywzFq3Hjs+tT8z4PUDBIaD4iNQGrykOxAbg4myIV64ftp01cTM1IDFDu3u8Ic6D0g0bJGYMuplULTPKonlEzFD3CDmO0nrDpjMIS5UYzNs6PQF5ZU6cDetmEq5xSrwFFhMRM/XMzeSnRmP+WpqFNCtLCBzLy8tDdna2tDw/Pz/IWkNjt9tht+uccp5RN2gVn6v+DgMvVTMcyHtFanb3fwI9rhReK8WMWnVbIzEz4OUpxPUBozEzoTo75T6pmJk4aIzWfW4AicCmZ4E/PgVu+B+QkK5umXlZqFuDjiOFppgDYsYPtVF+iPgPup1SOwxAb0sXi6uPyM5DqM4tkm4ml3rgsaZlhrq+QZYZk3wdFgCsSZUoRFqlJ+Dno0Wo8vjgcHmRqJFqTbuZyNWPJcuM4Wym2iI3NxdZWVnYsGGDtMztdmPz5s0YMGBAHbaMUWNqyzITajqDTqOAia8LnSUQnM2k2qFpuMdkMTM29XXqA7osGNVNzQ742N28lmVGPP6mp4C83cBXc8VjKjpOWmgeEp4PXnPg+vnUHmvhpl6IVMxMfRczemdFD+tmogpJhkPLzaQ10STHBU8/QltHAeZm0gEpeNc0yYZ4cRqDwhCupiKxYnCTBJsUMxNLqdmGho1+vx+rVq3C2rVrcfToUXAch9zcXEycOBHXX399SPePGhUVFTh06JD0/siRI9i1axfS09PRunVr3HvvvXjqqafQsWNHdOzYEU899RQSEhIwadIkQ8dhxBoxEDOjzJ5QZqCoPcjpTpX3B0b7vJplBkJnr3demlhATxG76mYzcQEfuy2kZYbizO/iPhRihk7pFq+nhwpUVa2w7nUCtoQQ7ayJm0mlgGJ9Ra9YDetmMhgArGbBDLLMUL9Zk1U4puRmYpYZoxCrSrzNjIwkG/4urkKBw4XWGfLfyb5TZXD7/FKAcLNkOwodLtk+YgHdYobneYwbNw6ff/45evXqhR49eoDneezfvx9TpkzB2rVrg4rehWPHjh0YOnSo9J7EukyePBmrVq3CrFmzUFVVhTvuuAPFxcW44IIL8NVXXyE5OdnQcRgxhnLiwHAuACP7k1UAVrPMKHzrhLg0+Xs1E7ua2wom9ZgZoP4FAYd0K4gY6fTp8yV2Lg63F4mhYmZk25ORuUKUqlhZ3JSY4XkewgidOr6nEkC6vrbWJABYj+stlqHDCAxZZpR1ZsRtdcfMqNwTyutPu5eCJobViJmppbCI+gixzMRbzchIFMTMpj/y8Vd+BSae1xIcx+F4YSXGvPg9TBzQMVPod5sm2aRt66WYWbVqFb777jt88803MgECABs3bsT48ePx5ptv4oYbbtB98CFDhogPHnU4jsP8+fMxf/583ftk1APULCYmHQ89zf2Fcf+YbcIDU2aZUVgRlZaZcNlMZB2zFbIHqckkPGjpUWOsUXYK+OQeYbqGzup1njQxImboDo5YZlw+uDTFjOJ8+bXETHDZdTdHixm/eA2o/YUr0BepAGA9gjCW0e1G1BsALIj7KrcPmjZKn0f9t6IVMwMELDnKyWMly4xS7DCUEBdRgs2MjCQhzvTFjYKnJDs1Hhd1bIr9eUJpEz8PHDgjFKvNTIlDoehyiqUAYN3D4XfffRcPPfRQkJABgEsuuQRz5szB6tWrI9o4RgMlyERdw04/XMyMVJXXhyDfOiE+Tf5e1c2kESegFEhSenaMjtK3vQIc/Ap495rgz5xh6jIZiS2h1yVixkMVzVOiPF9B8RAiKtfGxdGxSr7gkb6KANJsa00CgGNVwOpFd8yMirCXvZenZoesYeJzy7dXZiIpY2aAQMC+16m4z8hvkEx5UM+vRxQh1pU40TJD893BswCAv4uDfzcdMpMQH4N1ZnSLmd27d2PUqFGan48ePRq//aYyvwaDoSRU3ZBq7U/DRUAeguTBxodwM6W1AWxJ1H5UOjStOAFpn6SUeowXzlNWeTVT2X+nfgm9rSE3E/Wgk7KZQgUAK8UM2V4ZMxP8gHWCykbj/fAqH22GLDMq143ngfUPAz/9J/gzvQKgPsDrtDKFnGICgd+G+Fs4W+GCj9eIqfS5A9e+8xjgnCvEfYSwzJC51LwuhWWmngwoYoBKyTJjkSwzhMNnhRIDyvma7BYT2mYkIsEaewHAusVMUVFRyJTo5s2bo7i4ns9LwqgdgkRBDX8Q9IO17G9h1mv6OKSzDhUAbLYA9/0emCk7XDYT2R99HChGhbH6ILVTMWc+l9wUX3E29Lb0tQvXcau4mRzuEJYZZbyJVsyMK9h65KT2yfN+lHsUHWe4LCOtIHLCqV+BrS8DX8xS2dZgUHQsYzT1nqAUgIo4l7Iqj3qWGTkOOW/tLwmIba1sJiAwy72nStUCKO0jIqUfGiZOEjNjM6Fpktwyc6xQEDMllfJ74Jp+rWCzmJBgE85vLLmZdMfM+Hw+WCzaq5vNZni9sfPF6hMllW54/TyaJjWW+jgRdjMp93f6NyB3kIqbKYSYAYS4mTYDgR2vG3MzKSe5i/XJJmnLjNcl74yNdPqG3Exm+Pw8nB4/3JyGmAka3RM3g+K8q7jCXJS1x+/3wa/sOA2lZqt04kQgAwgqhmg0wyuWqa5lJijeSe56rXB5wcMEQGXg4nMH7jtrQnBatdpv1qrlZlJMeRCrv8EYgFhm4qxmtGwiz2A6VlQJv5+XJpd8YGRnnNsqDRfkCkH0pBZNhSt2+nxD2UxTpkzRLEhHz4fE0AfP89h04Cymv/ML/Dyw9o4B6JqdUtfNij7halTUdH+OAvly6cFGzc2kJmaAgPnakJtJ8bAlwYmx6maSVXlV/G5r2unL1pW7mYiP3q03m0krZqbsZNCmTn9g1G6GP9j6o+Kakh8r3GzgCosUXeafvn/ru5tJls1kIDVbKxNNFCblTq+2ZcbnDlwfWwI1rxJxM6mIGRIzo7TMgLmZ9FJFuZnaNU2Sfeb2+nG6zClNYdCySTwGdmgqfZ4aL/y+iNiJBXS7mSZPnozMzEykpqaq/mVmZhrKZGIAL35zCDeu2g6H24cqjw/vbT9R102qHSIeMyPuL15Mva0sFJcrLTN+7WwmAllXtVPSCHoMcjPF+IOUPv/KwNiwRd/o+CQDqdmcCZXiKM4Tys0km/NK0ZkR8n4P2pQWMybw8CqrANdUpMnOmWJffAghdHo38OZ44GSYWKRYobrZTGHcTBUhxYxHwzKjJwDYJW8LczPphk7NzkqNw6v/Og8rb+yHNmKdmb+LKiUxkxIv/82mJQjvS6pi5xmn2zKzcuXKaLajUfL+Drl42XmskcQchSu4Vd39JTYDqopCW2ZCuZmA0BNFatXWCLLMxPhkk7KKtYqOOZwFowap2Q5xJGi2aUxeqMxqkQJAFfdHabDor/IHrqcJfvh4kzxhLaz7LIxIoztFpZiRTb6pEMEf3AgUHgKObAbm1YPft940c605zpT7EX8T5S4vNvl7Yax5W/C+fG7ATYkZZcE7tQBgUozSqxEzE+uu3hiATs0GgFHdhSmElqcdxrHCSpwqrZJNLklD3pdUxs75jdnpDBo6DpcXJ0uEjuP9W/sDAI4UOELW3WkwRMvNFCe66NxiJVujMTMA5WbSUTRPeoArs5li3M0kK/KmtMxEUMxIx+EAjpOCBS1WuauaJ6rD51bUCdIQMyoxM05foKPjgGDLTE2zmejzFMoyo7TolZ0O3n8so7cAYFg3E/mdETeTBw95bsZv/nbB+/J5qNnr1WJmQlhmfnkLKKXcjsrUbDLhK0OG38/LUrNpctIEoXiqxCnNxxQkZkTLjMvrlwKJ6xomZuoIMs+F3WJCr1apAIRgKrK8QRMtN5NVDGIjnQ1ZTgQKPdGkppuJpHzqyGYigkfTMhOj15J+uCvFS1gxQ7/2hzbjKyeZFEeCVrvcMuMzi++1LDPKSs6uUiip9MkfZcEBwDUUafR5UQqjUPE2iRmhjxtrVNsyo3QzyS0zFU4vypGAV7zjgnZ1sqiUcjPFB1tVQllmTu4All8SWK50Mym/EwOAIEIIxDJDIGLmRFElykXXsFLMJNksMImPUGK9qWuYmKkjHOIoNclugd1ilnyQhY1BzEQ6m4k8WG2Jwn/S2ZARPRnFhZrOgCCN6HRYZsgoXCtmJlZN3KEmRjRimQFCCzZFJ+RwEcuMXMx4TPGBfdFWGPJah+WukoqZ4QHEc4rrV9MKwPR5Chkzoziu1n0Wq8hig4zEzCjdTETIimJGvPYmlekNPtl5FLxbSAWGLQHlXuF3dPxsifxY9LlMaRF47XEEXisHFEDs/g7rEDqlWmmZaZEm/D7355VLy5RixmTipGVMzDRyHC7RX2kXbqR0sQJjo7TM1HjkJD7sJMuM2CFLYoauM6MQHkqMZDMpLUD1JZtJloqt6JjDWTDCdWKyVeXnhfjo4+w20OffReZV8irEjNcpnHOpY9QO8av0yh9l6SiXr2Ao5VxFPNEdu9KVFMoyU9/mBqquZUYpGBRuJiJm0pKDJzWwwQPOG3AzbT0quBE37hXdR9IAhNqoWWf1dilTs4HYtZDWIcTFZLeYYDbJn4XZqcI1+lMUMwk2M6zmYKkQa3EzTMzUEWSUmigWH0pPaMRiJlIVgInpWWmZUZvOIFwAsNqoVLOsvkadmVh9iMoKo9UgABgII2bksQ4kADjBbg2IRgCVPHW+ZBWc/cI1JNeRrtCswOGTP5CLoVg3otlMinMUKmamvs3aHOq7yNYLl80kdzOVOYVrmJ4UPHN5MiihaY1HpRj/ZIMXfj+vbk1NbApVlFW4AZbRpEIVNWO2kuYpwuCCCB6lVYaQKvZZzDLTyCFiJkksPkQsM43CzRStuZlIZxdkmYkLvNedzaQjNTvIMqMUM7HxIw9CZpkxmJptyM0kP9fEtJ1gM8vETLlPQ8wAonVGbC9duViBw0NfTw63ue+Do3lfbPD1EZpd08BmmZgJZZkJ8Vl9CETVXQAwnJtJLmQrnMJ1zUhJDNpTCkeLmQS4eGEbK7xCzIbafGqqwpb63GQKxNjE6qCiDiFCJcGqJmbkAfqaYkayzMTG+WVipo4IjFIFMZMhlpMuqoiNGyOqRCs12yaO+iTLjPhAtRiwzNAuKaWLQNluchyl60rKZorRaxnSMhPOglF9NxM9FwzdGZV4qcwTpdXD69JpmZFfzwGDhsN881fYzvUQjlFawwk06c+VwihswT2R+lBQT7dlJoyo1XAzpacGX8NUTox5MduF4oqiZcbKeVFa6YFqzIzavRA0RUktVQE+eyCQWl5PkFy+KpaZ1HgrbJbAuVTWmCGksZgZBkBbZpQxM/XggVdTgh6EEUrN1oyZqYZlBtB+QBO8CjETS3VmQqbVhuiYDVtmQnxHhZuJFM1LtJsDwdoAyv2UZUYtu8of3jJT4TVhq68bACDu/Ml4cHRXxFnNyM0W3BH5xSUhvhQUdWbUgr91upKUn9GxG+FcXbGAP4yFimDQzVQuupmapgVXOG+GEuGFOBhxiPFPVniFjlItA9EWbOEJylCsjQlfj3wH/Pt84P36VTC2klhmVMQMx3HITA5YZ7QsMyRphYmZRk6FImamCYmZiZFgqugSacuMQsx4NAKAeR9UR3k0lPsjuFPTyGaKtbmZjm0Fnm4JbHlJ/fNIxszoGb1Lk0zSlplAZ+QElQ6vFFNeV6C91nhoBW6Xezjc6rkPBZetgG3kY9Lyc9pkAgDKystVtwtqq9Z3ChUzo9c1Ux/ETLVjZjSEv0mYk4tY5ZpRYqbCnAYAyORKhAXi77dCtLLZ4BMqzKrFzNgNWGaiKWZ+WCL8P7QheseIAk4SM6PiZgIgEzNpYdxMTMw0cqQAYEXMTHFDjZn5+jFg1T+EDitcJoRRpJgZLTGjZpnRyGaiAweDZnE2ms1UR9dy/YOCEPvqEfXPQ00sGbbDDTMip1GkZstiZig3QRUfwjJDx8yYLAHBqqDCa0IZEoGuY2WCtHWmWOfFUwWPL0RmUShrFSC/9qEsM1qxI0D9EDP09axRzEzgN0FPRtg8PU16XWISXidzVbJjO8QZz63wosJpIGamLtxMVfWgqrMK9CSTapCMJiAQEKyEZTMxAARupkTRzRRrJruI88Ni4Oj3wP6PI+9mklKzxdG+VxEzY6biYMK5mUwmyjwdzs0Ups5MXbmZNDp8iZDTGUQwAFjhaqiky6fTlhlOeFgWllVoWGbE+8Nklk/wSDdbnDVbOdJMTREsAXa4cbI4hNXJiGUmKGYmVHAwdW+Hi0eqa3hefj0jlM1ULgb/2iwmpCYHrvtZv8JtmCDMrVZOuZmEom0KyycgCJVu4+XbK3/TteFmokVVfQjwFgnlZgKA1hmBZ4gyIJiQJnoTSmKkz2Jipo6oUFhmJJUbQxN3RQVXeRQCgJWWGWXRPNp1JC7TsswA1CR2ys6nnmQzxaUGXqs9YGs0nYFGFWTVdeUVgEltpUS7JZBGDyCrqdCJnSosVbfMSGJG2zJDpi9QjjQ58TjxcCO/PFRbFedE+T1DiZ1QE03K6uaEq+FTx9CzygM1rAAcuPbkWZdst4CzBMRovkdec8bX/Up4fH6pmrOV8woWbK0ByFVvAGlttNtYG24mOo7LFcaVGUMoPQNK2jUNiM4WTYJrAwEB9xPLZmrkKFOzU+PFnP0YMdlFDa8rem4mrQBgquOUHtChKrNKokhhJdCqAKyMw4mlbCY11wZtSQgqmucMPcIMNyJXO45aajblzsvObAYAKHM4VMQMFQBsMsuvJYUbFthUCoDBIqwfB3fo4HpZCrVfu3MmbZJtSwkWpQDQG4MSCyjv11BB5OWnQm9LuRgrxODf5DhLYKAAIM+fKtukpN0/4HB54RHnP7aBiJkQhS4TmwVeK3+vteFmogs5usJkzMUQxFqWEqceDzOkcybirWakxltxQa76lBxNEmPLzaR71mxGZCGjlQSb3DJT7vLC5+eDH8oNBa8zekXziOvC5xYeplLgKDWaJ517SDEj7oeUWJeOQ2bhtsnTiJU+/bq2zNAds6s8WACEipkhHbnFBlUMuZlCpGZTFoC0dKFDcjudKmLGJY+9sai7mapgVzeZi26pOM4duoaTsrid1yk/B3wIAUifb5LSL5bxl7v0Ytwyo7yWWpYZrzs4uDyUm4kM3OIs8vpCSEABn4KmnCACilxmxFNiJlBnJkTQflxq8DJCbfwOlb+1eoJMYKrQLNmOT+4aCLPJpGm9IQPwYmaZadyQBztJzSZihucDqrlB4nUhOJuphlVSpQrACtEiiRmqA5RGxyHEIvGDuyqUBxL+iaP9oJgZzgSHy4sfjogTIQaVeK8ln3plQeC12gNWLSjVTLniQrlDDGUzKVKz3SSDTy460lOFuBa/1w2PR2kd0BcA7IZFPTNDXN8Od+gaTsp7MGj+JX/wZ39+BXw2M3hdWhTI3EwxbplRWmK0LDO0BaLzGOF/iGwmkpadZLfIZr4u4xNwjG8uvS90Cy4pWsw4tGJmCGop2oTamL2evr5Bz4vY4VRJFXz+wPNHdk006JCZjNym2ue3iRjnWe70whsquL6WYGKmjlD6LG0WkzSybLBBwIAYjxAtNxNlgfBQsRZmW8CtocsyI4oZt+LhRJ4FVmVMTeBhu+Dz/dhyRHzY0w/4D28GXrkw8qPz4mPAsouAXe+ITeGBwkOBz9VM32oVgK1xkAReyEDV6mczkZiZeJtZJuzi4wXBYYUXVU6l20tfADDAqYsZ0ZITjzCWmeqImXeuBLa/BmxfIV+XtmjUp5gZvZYZ+pp3GK6+LZ3NJFkB5C6NUiRhv7+19L7AKQwG3DwtZsLMdK/IavL7ecz+YDdufWsH/KZacDPJxExsupm2Hy3CgGc24l+v/QRe/N0Ra5nymhiBrj8TC30WEzN1hNLNBNABVXV/Y0QNryt6AcAmCzW3UlVgv5w5sNwTATeTVWmZCTxs9/xdCrc4snS5qA5xz3+Bs38ABz438MV08PkDwJk9wEe3i22uAJylgc/DWWaIm4l24YRKIa6Bm4mUUFearTnRnWPnPKhyqVhm/OEtM4BGmql4raycD8UVITK1lG4mpaBTEzOE0hOKNovfgefrl2VGcS2dTg3xRcSB2a4dZEtd+wqX8Fmy4rrv9rdDJRe4ngWVflS4fAHLDOcTnpOhYmYUAmfbkUK8t+ME1u89gwoxxTuqsWu0UFIOfmKEb/bnAwC2Hi7EmTLhHiTW/yQNN5MeLGaT5KYqjoE+i4mZOiLgZgrcTCkxVoQoKqgFmNbYDEz51IkLiLbMmCyBh25NYmaCZucOns6ADmAsr1QRBRX5Yb+NIZQdqbLNamKG7riJ8OFMKhYnFQxNZ6CYaFIS8ArRIQpNK7xwhrLMcCa59U0xi7ZqzAwVY1NRESKmIaxlhvreHqdc7JgUo1tyTpTCL5JWuTN7gT8iLIwV17KswoGfDheqrCf+XunBQ5CbKXDtJZeG2PF9edEHmOJ+APv5NuCp61NY6QkKAJbVmVH7zSrux32nAtaREpf4WTQnmozRmJlD+eVwe4Xz9ueZcmq5ILikDLMaiBkgUOy1NAaycJmYqSMq6NLuIqTWTKzk7UcMZcGxIDdThCwzdIfsqZRnwZDAQ6+ObCZSXdSteDgpZ+dWiZk5XeqU0oSrqkgxMOr7Hf0B2PpK8LxP1UX5ANUjZuhjk6JfnCnQ8YfqdKtlmeHg9fnhEh+uCTYLkNU9sJ4Yr2OFFy63Yn+eKrnlzUKJGbM8SFl1lCkTMyFGzmoBwGrfBRCsfpVUJ690YxD3TJBAiqBlZtkAYM21wOnfIrdPRfts8GDTn2eD15Pct9QgQfkb9lMBwIpgU1vLntjk7y18TInTQocbJZUeeBCYaNLhDhMzo/gdHykI3P8l5OtE081ED8RiJGZmy6ECDF/8He57bxcAIV6GcLxIsE5K1yREzIweSJ9V7Kj7PouJmTrA4/NLqpm2zMRaeeiIoQw4jZqY4SihobTM2ALLybpaSDEzGm4mC3UM4QPhLS+4UoibyeMWn6aFBwP7+ONToULvH5/o/HJhUHaYyuykcJaZyiLhPy1m9ExRoFVYUNa2wGSDpEgXIFpQLrwDGDwbuHmj1CHa4JW75khbZDEz2mJG1f9vMsEviiV3ldLSptJW6bihxIxL3kEqzznp4JT3daRiZujBQcFB7fWMIrabR6ACr+qzSLoe1hCWmcC1r5DKUAjXJzM5IDBLktpLr/PLnCiudEu/Hyu8opsphGXm/Gmyt3QtoSInscxE081Ex8zEhmXm49+EtPnP9pxGpduLk5SYIcJGK47JKLFUOI+JmTrAQZX3lsfMkFozdW+yiyjKWhsRT82mHnaSm6kqjJtJW8zw1nBuJmLBkBfNEz2HUjVar0d8sL5yYfBBSk4EL6sOyhRq5ey9akGJsvNNuegkIRiq0yUZXeI50OlmIrP0mk0c7BaTYCkb+hDQ8jzJamaDB2634l7wOim3hlUeADzyKcASh50t/gVA22TOi/eEM6SYoeKrgNAxM/Tkl2oQMRgkZiJkmaFjM0Jl8xhFvJY+qyDm7fAgr0TlXiDXw0yJGa1CgiZzUHxGS6oI258pA3Do3Dm41v0w/i6uQrHDLf1+AtMZyGNmeJ7H29uOYc6Hu3E2uSvQ72Zpf4UVgXaQ4nu1ls2ktOTWEfT0EftOlUlWGCAgZpSuv+pCMppioXAeqzNTB5AJ92xmk2yq9dSGOqVBUCpwpAOA6Q6Zivvwq/j2iQtFGecg7YrHur0lmACguKQYTWQfKgOA5TEzxI1C3Ew+ZZoxTaTiJ+iUap4HPDrcTGoChDMFXHGhspnIubbYhYe3ntm5xZR1QLDKcEohaSG1YDxwuxWdotcVSOc1W+WWmRZ98Pg5X+L1n4SRqJaY4axxgAsw+ZxwenzqgcKk87UlCgIwXDZTqHuWnF/lOpG65pUqcSyRQLQwVcVnIdlTDgvnR1WZyrHCWWZoKxc1NxNxaZDRPABkJMWB7z8dW7d9h+SSKhRXeqSYGTvnhcPlAcxyy8xX+87gkY9+ByBYYl5vERB0BVT6PdlP7aVmx4aYoeu+bP1Lfv1OllTB6fHBLaZS1zRmhiStxEKtGWaZqQMcKvEyQOxN3BUxwllmaiJmeB7qAcBVgY7WYqPEjGi5MKn/iI8UOLArX2jPiTxFsK7UkatnM7mIZUZ8iPpDdfR0LZiaQFtmPFUqlhmVB6yahYA+d3rqzOixzFCp2bJ5mZSIAdXxcMHrFe99i4q70GyTxcCcqrJKQgbQ9v9zYkXnOLjlD93yPOD0bnlbiaVDKWaUglyXmIlSzAw9uWG4ubSM4BDuyUp7MxTzgnWGq8gLXk+yzFjU46x4hZhRKdD21BU9MOqcLMwe3UUql1/u9GLvqdKACAHgcrvBK2Jm1vx8XPp84x/52PBXQMAXiJaZyf3bwMUrrLHRIAbrzJRVBdr0wyH5c+ZUaZX0G7CYuAjEzIhuphjos5iYqQPU0rKBBhwzoxzVRtLNJMtm4OSWGRKIabYHxIw7tJjZe6oMlRD24alSCgFlALA8ZsbjE/5zWnEENI4IiRnawuSuCB79B7nKoF4/pPQ4de7Ez9WyQGjLDBD62lGWGWliVZvKeSdVeuGGj4gZEoTtdQbOo9kqcw+eqJK72OiZfmk4URjFc255oOKb44H/XCwIGiK4lZlqyu8CiJly1XEzRcgyQ4vkSGZIiQLbYUnDWV6orGutOivVJpHwq7j9aKFGD16URfNEJl3QGq9efx7SE21IsFkkd8UfeeVSzAwguJpoy+vZche+Oyi08x89swEAnx4P3AfkPru6X2s4ISz3u6NY30cWABwblpkyqujqT0eEmLi+bQQb8+kSJ/LF9OwmibZgK6lBpKQVJmYaJ8p5mQgNNpuJfvC7HSp1Zmryfal9cZyGZcZOBbcSN5P6bLH7T5fBwccF2io7lHIOKLllxi1+nJ4qdMQmvwcercqYkbLMKM3cyg5UTcxoWYzIuSs6DMxPBZ7IALa9Kl8nyDKjrwKwg8zLZNe2zMRxHvBERNg0xExWD2mzsy75vtpQM/3K9x8QS5Jv31EAnN0vvP79w4BrhFhmQtaZqaqmmylCFgJZ8HEkxYzgkig3pSKfTwMANPEXo8yp+B50zIyaNU9hmZFNZ6BBW6rSbG5mwLlrhRccAjEz3+w/A5+fR6+WqXh5Uh+M65WDT/wDsCVjAgpGvgIAsFtM6JKVDK9JEDMVlSFipWqK7NkWK5aZ4OfpoE7NkGgzw+vn8etxwbKXnmALWs8oTaQAYOZmapSEczOp3Yz1Gvrh5ihQcTPVYDoDxYNTZjWhO0F6dltAU8wcyCuXLDN2f5VUgl84liIAWBEzI4bMICVJ6Iht8KC4QqOzd0Qo7oEeGborVGqbqLghtMzuxNqy+dnAsi9ny9eRxIwO6xM1oq4UfXAJVjXLTMCiYvWK7ZXEjCtgITLbgPbDgGHzgMv/LYuPGH9uDnq3lkU4Ud8rMNmkVNyrjJoosSI/IDxoEaX2XUib9FhmwqV7Vxf6mkfSzSRaFhxcIs4iDQDQjCuRBdUCUMxirgiGB+TnhppoUmtSQwAY0F6YzNBi4vDK9f1Agn3toL4rx+F70W0ypHMmAGBMjyz4YcLTuAnHcoSpFZom2WEycbDFCeLWEaq+UE2JsQrAPM8Hi08AF3dsio7NhWcgSbdPT6y5mGGp2Y2cIvHCN1EoY5LNFAsmu4hCP9wqC4JHrFquirN/Akt7At8t0t63UsyQGa/dFXI3E3FbEFTcTO/vOIFv/shHhWiZSYATeaV0B6SImfG5hBG9lM0kfG4WH6LxnAtF5RqjtYhZZhR1LpQdqKqbSUOAaMxILUeZzaRnOgNTaMsMVTsmzi+2V83NZBLdTBfPAHr/S5qe4Ib+bbD0mt7ak7OK3yuOo2Jm6Pum+Kh03s66hfvi92Nn5PsICgAO8b0lN1OUxEy0Jq8U213lN+OsaJnJ5EpkohGAwjJDCXsi+Kh70MtzUuXnUPMA3T6kA24d1A5LrzkXuc2SJLewnQucZx4ctokBrRd1bAoAaN9MuE+OFjqkeJmmyWJ2nF34Hbq0KhlHAuXvr45xuH3SHEzk5zCkczOc2yoNF7YTBOOmA5EUM6TPYpaZRslZsRZCs2S7bHnDjZmhHr68H3AoCnFpmew/vAkoOQZsfDLEvmkxwwVG1lUlgVXMNuw+q7BYKMRMYYULsz4QgkGJZSaJcyKvjOqAlEXzAFEwiTEz0qTaQhsS4EJpmcYDjg7irAm0MHFXBDo6KUZIzc2kYS3SmJFahmSZITEzxlKzVWNmTCbwYlZWIsSOR2aZoSxsFKTzykiU/46CUHMz0fdkRZ503n4+KVzvnw+eku0iyOKldl4JRLQExcxEw80UQcuMeJ4rfWbJzdSMK5HOc9DxTZSYAa9a+bjCHXgdys2UZLfgwTFd8Y+eOcIC8f6KQ+D+KnAI82txHNCjhRDT0yo9ARwnBA8fFCvdNkuyibsQxIxXGRQfSWIsm4lY9a1mDq9P6YfbBrfHC9f0BsdxkvWL0CSxZjVmACo1Owb6LCZm6gBpBJGkEDPijVHl8cHlreFM0rGEcoTqVJhjtUa5ekaddGdqtgU6QVIMDsC+sy5s+VvxQFaImd/+LpFe/6NvBwAqlhk1MUMFNJMAYPIQjYcLJRUanZ7XGZkYCmUAIulIiFvNiGVGS8zQqbbKmBk9Bfa4QMxMvFo2EwKVYJM58ZoTywxdL0hRJI9YDDKSwoww1dxMtNvIWSaJm0rRKuf3VMkDX4PETIhRuJaYiVTMjMzNFMFMHckyY5ECgDOh4maS3H4WxeSu4rWj7pdyt3AO46wmWM0GuhtqglDCXwXC/ttmJErp9XFWM7JThHV3HBMGCOS5ao8T2uZ3RTMAmK4zU/eWGRL8mxJnxZDOmZgzuos0SO7XNh026hqkhxsE6IB4Eyrddd9nMTFTy/j8PDbsE0zYrdLlZv1ku0VK1mhQ1plwrg+tuVOUriE1yGjIZBVGc2QbqhbHoSI3KniFC0URM0OsZUM6N8OdI88FIFhWTpfQozqxczNbA9VIPQHzOhmEWuLFomOcF+Xl1KSPQW2PgI9daZmRxEyK2D61mBkNAaI1IzVtRdKa0kEN2s1E4sQ0xAzZXxKxzBAx5qnStMwUagwKgvdNW2aImKHEibNEeukyBYSPLPZAKWb+O0X7ePXcMlPhMyNfrLDUjCvFWaWbibbMmG2QJoBUiRWqcBEXk0ErgJW4egP310FxXqGOmfLnQmsx8HvnUbmYscUlis2tpdRsT2V054HSAUnLTokPPt/xNjN6t06T3jcLNwjQQXKcRXJnldZxeAQTM7XM53tOI6/MCauZw+BOmbLPTCYu4GpqSHEzQaNahTlWy81kox5aWqZi4qcmnR/JRiFihjPhdJkH+WJAo4TCMkNG+c2S7NI+TByPwmJKjMjmgCJZL5VSB08sM7a4QLudZQELURDOEEJHL8q5YYIsM4rzxvPaGUiWePXlFVT8iJTRRb6/jpo0JnP48unEMgOxvXGp4v4d8hgNQLKYkGvWVK9lhqPcTLS1kLr/KnhxVA8PTpdqZOiEI9pihu4wIxkzI4oZh9cUsMxwxSqWmcD1OFFcBRdHzVQPyH4n5aKYMVyczRqIOyP8XSKcv3bN5GKmbYZwL5KsKXI/xCcIy3kj54jnhVT9UG5EGuU1jpT7uJoQN5PW+R7Yoan0un0zHYPFMJhMnBQ3U9czZ8e0mJk/fz44jpP9ZWVl1XWzasT2o0LnNqF3S2SlBo+EG2TcjHLeGylQTpT0Wm4mCzXipkbP8n2JwohYZGxiJ14ligizHWfLXTjiz5Zvx6lbZpol2wFrgjQ/TUmJilUCHBVo7ACx2JDpDOzxge3dFWTuIxWLBBXXU220YmaIZcZdEZyJQ5i4Ur4vLcuMgy4eKO7LRok5LYjliePCp+eKnZeZE/ef0lJsf0DM8CYr7ntvF4Y9vxl/na2QOtmMsJYZsc4MNAKAKcr9pBqxG6dLaBejETET7QDgKKVmi+12+EzI5wXLTCpXiZJSDbewyYL/fPcXKv2iyCQWEKpYYoUrdOeqieRmCtyvpaIgJnEahDYZ8ikdyP2QIIoZLlT5ACUHvxJqD739z/Dr8nzws6sqxOClFih3BdxMagzv2hyAULyyW05KRI4ZK1WAY1rMAMA555yD06dPS3979uyp6ybVCFKw6JwW6jdSWkOsAqzlZpJmstb4Ecg6ao1Ok1h5iIiR3EziQ8ViQ1mVB6d4efCb0jJDxEzTJDvAcfBZhM61vJweadHTJohixlMZlM2UaLfAaxY6UE+VaH2JU7nexDJzbCuwqCPw6Qz17xiKoJgZImbE88H75OeRFh9dxwE9rgq814qZocvn80oxE6Iz3fCo8H//J5JlRjOjRXnsJm2F/+5Kqf3HSjxY9+tJHC5wYNGXB6RpQcJaZqwB15Gqm4miCgHLzKkaW2aUk4BSYqYmmS9K10Yk+ONz4Oj3AIByjxllSIDHJJwLT6kiGFqKmbHi8FkHXBCeWeUkBZq2zIS77lqI14x2M5VVCedT6UJpq6gvlCkmViQmCb8Bk8+AiPztXeH/8a3h16XviXixLEBl3YqZgJtJ/Xx3y0nB1zMGYf29g2TTStSEWCmcF/NixmKxICsrS/pr1qxZXTepRpwVR5OZyeqjyZQGaZlRihnxQU7iLrRGTrJARw2zr5abiVhyTFaUOT0ohrLOjELMVMgzzHhxP1UV1KiUnp2bHIcqAkhiZhJsFvhE14afiBmzyvUmbfz1bcH6sWNFsBUrFDwvF4puFTcTaaPytdkmBHB2GB74TFPMUA9osn8bJeZ0IM3Po2mZkbu4fqlIE154qySLwdGSwP3w5V6hzL7NYgrfUVoC1pZitWwmCgcC8TWGLTPKaS6kySvFxywROdtfA55uAez5IPw+1fBFwTKz5lrpZbnXBICDO0541vrKFGnqVMxMcaUHTl7oFPMKS4TlVBZbWXXFDLHMcLRlRthvanxoywyJoUlKFJab/QYsM8mUBTdc/At9HZIEi0edW2bEAODkEDFKHTKT0Spdo8BkNYiV9OyYFzMHDx5ETk4OcnNzcc011+Dw4cMh13e5XCgrK5P9xRL55cIDTZmWTYilKdUjhrLjIK4hKe5CMXI6uRN44Vz56EjLh63lZiKIo8NK2OHmKVePIgC4QJEuz4nxOu6qcvj9pH4G5WYKaZkxgxc/9zsrAsfrOk7eRiJmSHwIABQfUf+eaihFokuRmq2Wnk3EB2l/z6sEd9M9vwXXmUkQ/esyMUMsM1S2kRaprYX/A+7SIWbkD9flvwUejH6xwN3xyuAHdFM9JdnF72WHG6VVHuF6allmSMwM51FPyw+FXXFOpEJ84vUmYuazmcL/D28Kv081omGZoSj1COeTSxCsDbyzBG4vdb6omJmz5S5p2oCSMvG3SLmZyO8qrCtQieQapMQMscwoXChtm8rvnebJghBKFi0zNr9b3v5Q0HF6Wq5tAn0dEsVBdl1bZpyhLTPRIFYq18e0mLngggvw5ptvYv369Vi+fDny8vIwYMAAFBZqV099+umnkZqaKv21atWqFlscGp7nA7EZSeqj4FTxJmzYlhmxcw2a40hk7S3Bnbqmm0lhmQkqjmcW0xU5lNDWmVBuJgCmOGHdeN5J/UgpN5MUM1MpLScxMwk2Czixc+aJ2OJMwD9XAHf/CnS7XFimFgD82xr176lG0NQFVNE8k0k9roWce/IZxwHdJwhuHYuiw0kSA9SrVCwzkpgLIWYSRTHU5iLKzaQVABz4PXhgwcbDFfDzQqdqcgquvr9dwaPJphqDAvm+AzEzfl5MX9WwgJWDuDecOFNm0DJDRKkyZoaevFKPKApHNCwzFJVeQehbRTGTzDvk50K87/ycBYUOF5yim8nhEH+LVOVnUobCcOaMipupVLQ6KC0zCTYLzm2VBkDIRjSJ6TXEMmPnPPrjOWgrcbiYNvr3p/ZbqQMky0yIasuRpokUAMwsM5qMHj0a//znP9GjRw8MHz4cn332GQDgjTfe0NzmwQcfRGlpqfR34sSJ2mpuWMpdXjjFymqalhkxb780BioqRoygmBmFm0mZ3qtWB0WrhgMJMiUjKpvc5AzOLPmRS3jqM0rMOD0+KUCVXBeTKIoSURUoGiZzMyUF2kUsM96AZcYkih0TcY9xJmEKgPR2gU6PPCzph+LRH4T/218DPpwWpsKuQsy4qGBfzhywfNHnTmmZodh2QiEYiRiRxcwI35VYnngqm0uzfSZLIABYy91AtcfFW+Dy8qiCvAM87hTulxTKupOhp4qp6P5JNAnnsrjSoypO/DChjBfakYyqQI0hntc3s7skZhTZTLTAjsTM2dEKABYhMTDmhDQAQApXidN0vSXxnnT5TeB5wCVep8pKImYCglpZlVc30uSggfNV4iQxM8H30Kv/Og/3De+EJy7vLi0zUbOlFyrTy7WgrZiGLDOimKnUHmjXBlLMjNGA6xowoltzzBvbDSPPqdvknJgWM0oSExPRo0cPHDx4UHMdu92OlJQU2V+sQEb/yXaLZvGwRpHNRB720oSNigey0lUEaJvTqZgZn5+HA8p6MiZptFICqlOhxAy5LjaLKfAQEEVRIueUPpe5meLThJdVxdLDvconjAgTbRaYxfTseF78bhz1UyNWHbUU3gohFgSfzQT2vA/sWq3+vQEVkVguq+0SiOtRs8zIxczJkios3aQQ/tIDmh5tCufgQKnwfTjehyI644tGcnlZqBFj+ABg0plWguoAzXacqBCOST80W+vx/YtWHyJmSirdqmLGZ7KhHKKY4SoDbqYtLwKHNoQ/TpBlhriZKBEdiYwmX4TdTAox+iffEjazCSZRzKTCIU9TF8WU0y9cDxcvFvskEzrSbiYpfd6omym4zoxDDEpTWmYAICs1DvcM7yiPBbGQYG43ihzVEDN6LTOcGUgUEwzq3M1U+5aZC9tl4MaBueijNTdaLVGvxIzL5cL+/fuRnZ0dfuUYhGQyNUvR/mGnxoj/MaJomei1LDNqxfK0YmYoN9MzX+xHz6d/lB+aM0l+5FKZmylw65NOKzPZHoi/EDugBLjULTMJ5OFVKD3UHD5hnwk2M8yiWJCKwNExOiQYWNnpAcGupzN71b83oB4zQwVfqgbpSi4+uQXrp8OFqOIVD8AkldGmeA4Ol5ng4gVhcuT43xrtE+5hL8ySRVKPZcYtihkTLQLaDECB2CHRYqZTlorwVSKO8hMkMeNRDQD2mmwolywzlSh3eoSJRklWlhp0VWIty4wljiqyGAFLiixmJgL7o35/Jy7/AE7YhUlwxe+jZZkhYobEzDirxPuMymbSqnYeFpXUbL9Y7kB3R01ipTgvCit0nifaihnOMkOspiZLYACmtz6NAfx+Hh6fvpifcilmpvbETKwQ02Lm/vvvx+bNm3HkyBH89NNPmDhxIsrKyjB58uS6blq1kDJmQvywG6RlRiNzRDPuQm3CwzABwH5rEpZ/fwQ+mCUfPgDwnFmaeM1npwJtKcvM0QJh323prAgbcTNRlhkCx1HBsYWSW8wLYZ+JdoskJBI5sROg68xYlGKGOj9VJfKRcvlp9e8NaMTMBKYQCOlmUlhmDuVXSJk8EsTNpBIzk1fulixdhWc12ii2r4oOLdCRzeTmLejeIgVxiQGrKt+kreQqOKdFCu4d3hETerfAP3rkqO9PZd8JnLD92QqXqsD2wCrFzNg4H+zwIK84TOeUTJnWlZYZSVhaqEynSIgZ6tngrTKWAacGJXYLmpwLQLyHiZiBA6dLaMuMeF19cjHjcSrdTIEA4LDp80qswW4mgEOy3aI9oagSKgZMCk4OB23FDFcAT5pmw6od/xcBFny+H+c8uh77ToVPZikLZwFtwMS0mPn7779x7bXXonPnzpgwYQJsNhu2bduGNm3a1HXTqgXpFDNTtCf0a5AVgJUWBAIJ+uR9ctO5Woqwljm9RHCNFJvTpUX01AV+8RY3mzhw8YF1ZGKmUOiw2tD1KoiY4aokESpzM9GWGXGE5oYwHYXdEqgQLFlmKDcTcaOUlpPsD7psvk8u3CpDPFBDZTNpupnUY2b+OlshzUskIbmZ6MKBQsdZ4fKjmBdGo6WFitRdqX3C96r0Ct895Pw8VABwanISXp/cDxa6krIpEV5RlGYk2nHv8E5YfPW5kiUzJFaS5iuImZPFVepihrPCgTip4GEyqnC2KEwMBH1PkUKFRLD4KTFDOrtIz8cF1LwDJb8tsw0OT8BVirg0AEAq55BbZsh1Fd2qbnEKCJ9L7mbyc6ZALSDDMTOia5CTu4cMWRyoe7yiXK+YMRIzQ1lBrSpW0Ajg8vqw4ocjcPv8eO2H0Jm8QCBmpjGKmZj+xmvWGMjsqAecKBJu9ByVyr8EkubWKCwzylgCs9h5mVUeWFqWmcJDAIDjXAtALIXv4OPQlBNGMT5e6DxT4izg49IAMrih6rAcLRS2y21KW2YCbqbD5YqqsZwpIGYcBUCKYB3wwoxEm0VwVZG5hrhgN9M3B0swBsAvR85gkJ+HWVlFlHbrhAooDJrI0EEF3dIZVw75OtT3IxzKr0CF0jJD3EzucqGwocUmWQHKPbxkmXGU5kMVHxEz4u5Czc9DdTxpyUlAShz8lJgp8Agj+7QEK2wWg2MwSyA1GxDig5AdfE+6eCt4mOCxJMHmLUcyV4niogLFvuLk4oEWRVoxMyaL3ArJmYwV4VMSdN2rgixthqAELkmhF9xMaQCAFKi7mYhItSUkA1UAiJgRRT/JRrNZTEg2XDRP+D4pZjfABwYlhsSMyQyPyQ6r34WKCp1ThxiKmaHcTESMRzggm57oNlxROq/PjyKHvMREYyKmLTMNjYP5wuigvWKiNBpimSmp8shn7a3PaFlm6JoOdAehVqxKTcw4S6VS+396A/NcVVKdMjlySrwV9njqgR8fCFYjbiZZ8S0SAAxnIGZGSs3mqEyfIsrNZEYCCewmbiY4A9uI7Dkj7M/sc2H/6bLgzqmCEgehRoc8ZYUhSFMImKnUbLpoXrBlpsrtw5ECh+y8ARCsDmTfxNUktrXcxaOYF2vxlCk6fAKJJRK/XsjRIu1atJCMssD1OOYQzqtWscmQiNfC5qsCwGtaZoh70ifGPySjEqXFlIutxXnA8PnyjYbNC/4OypgZWWenGLlXJ7spyDJTww6U3B/WhMCEoLSbiVMGAMuva4LoDjT7quD0+KT70id2L82S7OFrASkRz1eSSfhtEWuZ0Swdn1m49lUOnfXGjMTMSNeXcjNF2DJDi8hTJaGv89kKF/w8YDFxaBqBGbHrGzFtmWloHNKY9ZWGpGb7/Dwcbp/xypmxiNYo1GyD32SDye9WiBmVB7yamBGtMkhqjsNlgQ6dtjAQy0xynEV4QBNEIcXzPI5JlhlK7IiWm0SuSj2bKUF0L5Qeh1RnhrcEYkKsgWwoYROhM/b7eZyq4AGzUP/ipyNF6K4Ue/TEjlr1dQCqjkmSWInYBziJmDGhCnGIh2D+l+xCKjEzf+SVwc8D6UkJcHutsIGMOM2C6KssFP6Ss6QHeBnlZuK1MjhIpye6LkLey/QklyRAmhJcf5UK+8hM1rZqapKcA5gsMPtdyEYRTpYkymcXJwKQuEdsSUClkNHkIBOFprcDpm0U7oG4NCC7l3APkGJpAIJmj5Y6O3Ogs3M75L8HV3lwfZ9wqFlmqgvPA/83RHhtjRMCniFeKzFjLxUOFFQIhedsFpMkpsh1TUhKBQoE4V7ocKOF+P284m/PcLwMEEinF2NmiJhRy2QKhd+aAHiK4dIrZmgxEs4yQwcAk3s1L7LT7dD1fWTWMRVOiRWrm6fESbV2GhPMMlNLlDk9OCNmM4WyzMRZTbCJcQWRKA/99b4zuP3tnThSEPkoe91oWGaOlrhQ4RM6ONnMtmqjVbURT7nY6ae2xF9nhe83pHMzOKiYGTI6TImzIjme6gjFkWJBhRsVLi84DmjZJFjMJNN1ZojIstgD5csBoFSI2/HCHOiwiZtJkc10orgSDp/w2gYvfjlWrGKZocVMuXaAJ91Zkgwwkg1lMuO7o8I5+fnAcWp/wdlMv4uBhefkpMJlos6ByULFBomdujjqLnXzKBbdTDZ3CarcKtdYvO4VkptJr2VG7PwoV9ifRaHrM4XEYgMyOgAAzjEdxenSKvjJPdmyr7Ragp9kxgmWhmRUobKsWLYMHAecey3QvJsg7ugstaYdhf/kXlWLqVAGdLt0xnLQBImZGlgD6CDXkuOoEGe5lltmhP2T6uXEvVIuihlLvHAfJHBOIeBX/N5i2SXjmUyAJLYTRMsm+QUYztIR7yF3ZXViZsK4pujrS8f5nfzFQANDQzIxASH0gFjO1DgiWZgjN1VBfYKJmVqCWGWyUuI0ZzQFAI7j0CRR+Fx3oScNeJ7HnLW78cXveZj5/q4a7atmDVFxhwA4dNYpBcPmFVIPDjUxo1Y0T5oOIA1/5Akd8pXntYKDqk/i5Uk6pwVxfSchj2+CD/xDpSkKjonBvzmp8YizUh0T9SAvdLiF9WkXjS0R6BWYzwYQKtdKHbYyNVv87gfyyqXvbIcH+/PCuJl4v7a5mw4wlaZIEM8jZ8bufOHzo6cpN5CUyh4Q1L8eEzq0ni1T4YijRJrJHAhwzdsD/PaeNBoV3EzCMZtw5fi7WKVDJZ2eWzjXmplMgDyGhxyTWnZa3H213EwA0PpCAMD55gPw+HiUkYEClWUWxwsdpyk+4F5xOUqED+m5rpTc+h3wrw+B5ucI70nxQtrNRDq7MsWkjVrFIEOhdDPVxDLjoiwWfi9KqoTzkhJnlX4DyVwVOPilwRg5foUoZmzxwrmRyhjwRMwQy0w1rpkoHonAJPE3Ri0zpPilS4+YOb1bfj301pkxW+Wi9te3DbUxFKQ+E0Hm7lNw+KzQdlnsXyOCiZlagoiZDiGsMoQWacIo9e/imvnC/y6ukopW7f67FF6dtQoijtrkhwDK3IHMnlOF1AhRpdrqqbMqgbBix53vicPfxVWwmDhc1LEpeCoWx+snvnYrWuXkYJD3ZdzvniYEgSIwmlHO7xJIS62Ez88LpbqV1XO7jpVt4pFZZoR1LByVKg3gj7xyqciYHW4cLXDAp+ycaMsMoJ0iSneWRJyInZMfnDQDdCLnhMsrCh8ilBIz8duJEnz7Rz62HRbO7YXtMlCV2j6wf84ccKetfxBYd4v0sC9x+qUA4CaowAlVMSO0j2jykEGgxPIBAKkthP90VWDxPql2YGOzrgCA9lbBwlTiCM4yI1YAS5JgjWqCCvikWc+ptH4l2b2ADsPhEuMzwPsEgSHLZhI/O/uHfNtqWWaUYqYGlhmn3P1SJF6sjCSbFABshh9J9PQOYpsLvYIFzZ5AXLJOYQBG3Ezird80uRpuJnGW+Ti/8N0CMTPGxIxVtBqZvJVScLMmq/4hfx82ZoZyMzXtHLw8ApQ75W0+VaLtaiLPsnbNwvcxDREmZmqJM6K/kwiVUJAqlqodhAH2ngpYO7x+Hnt11CmICuShbpd3CMVOvzTjbnFpWfD6FKWlJVINBQlx5LQjT1h/fO8WSI23IiUlENzrEUd0aQlWWMwm5DYVHpIkGPugKDLbKx8AYueVZhIeEPnlruB4EyqIGFBaZuSjI57jcOtbO7B4w58BkWES5gqqqhJHvGLnIbPMANpVRekKpDa5m6nSy0t1Y+LhCjwExX0XcWm48j9bceOq7ThV6oTVzKFP6ybgmnYK7N9kCYgZBV7eJAUAp3EVOFGkIrxJsLB42UIGAMdRYialpfCfiushArB5iLIGIRHrwbQwlwAAisWsD3pEvd3fBXFWEyxJQhxME64cPOnsabGlwbPfUMUD3RWBaTnoANHj2+QbuWLIMgOgUCxMmJFoE4JwxfilFDgCmTXiPXbGLd5fYgBwPFxCGQPx9+sWBxLVs8zInxV+KWbGWAyh2R4QWvlloWNO4FK4lfRaZkxW4VyNeU7cLkx9GgMoLTN5IeJmJDHDLDOMaBKYoyT8KKWVGLtBUrmry+8n5Q8qMgKvdYibKcgywwdqrtBFrVQsMwlw4UCeYhQrPlSPibMpzxopjI6apgc6YI+fiBnhvHdsLnTAr24+jEuXbMb/fSfUbuiareisiIkdwkSSZ8qcwZlA8fKO3ksHABNhIuLwAOv3ChYXUpgtRUzbdrrEjpVkSJEpDQhak9cRi5dKzEyp0yfNAJ0AF46Te0m0+vx4xiybSfjcVmmIt5mRkNM1sHvOFPQdpe8KM8o44Zw1gYqbye+X2kcy20O6mWixIKa603E9pCowuX6GSRaqhmdCOJfFFSQw2wRcvw7FbS/DXZ670DTJDk4sTZ/BlSNRTPcP6WYS+Xh3HirEWj3uyjJq2o64QDaTQyFU3ZGImamBmKEtM1e/jULxOZVO5ryi3K3Wk9uA5zoBp3cBAPJcwjoJScK1S4RTsCaL191TEzETJ/89SgHAeuoK0UglFpwBN5le3OXqmZUE8hkRxET4hxNBBqhQWGbyQggyku3Uokn4AXNDhImZWuKsgbLerdKFm/FEDd1Mu06UAAj4UH/8q47EjF/dzVTu5iQxU1ZBjVDVxAznkrKOJMSU0go+Hs2S7VIxwuzMptIq4tx0UuBgx0yhDT8fKcKfZwLH7KIsiy+KESu8iIMb+WVVgRRYImYUVguZm4nM3SR914BwmD3+fGFzvhIm+OF0i709qSps1DJjsgQsM6I1oMTpl2KHEjmnIGa8bkkY7SiQdwrjegkCoknrc6RlhVXeIOuTdGiY4LYJ37GJmmWGuoZlJGYmVJ0ZuvMioo6ybpH7pNrxACmCmEn1FgLgUeIIpMxvRS9cV3o7ipCCjCS7dB1a2ByimEVQ56oGzwesYXlnCwJixhKnOrGn8MXqOACYxIjkDga6jpUyZrJILSyS0cQ5cPmfD8pcoGe9YmXlZDG+hXPheFEgW4vc8jWJmSH4q+lmCgQSuwIBzGrQ1uBRzwRehwoCpn9/QOC3EinLjLtScjNlic82rYymKrdPChautvWynsPETC1R7BDMhek6ZvklLo99p8qqXWvG6fHh56NCx3X/pYLF4vuDZ6UgsVqFWGZsCZDSVwG4eZPkZnI4aDETMK3ubDIagDCyOq60VIkjUiesskKEaWkBkVEkVmxLE8VM9xbqnVKn5goxY0uU4lxSUClzg/1y2oV+C77G8u1ykeEBlf6tsMyUVAnn4J99WmL0eQH/ehKq4CZiJlFDzGhZZqhsJl4xn1VJlU+qGxMPF/4uqgQcZ8X1LdhfIny3B0d3wVs3nY9/XShU1bZmdpT28XdhpbabCSbp4Z3MVeFUkcKFSYsZcUAc0jJDzxXVJFf4T4lfF6y4tFtz2C3qE7SGJUlwM5l5D5qgHMWimPHBhNve3ol9p4X2t2+aKGVwZZodSCZFD8O4mUqrPCh0uKXq0wWFBYFAdkuc+hQdgFB00ShKN1Oo9P1wUG10e/3SoCuHuMOpKQ1SfPJOuphPhtnEITFRWCcBTmHAIQoDl2iZaVadmBnKxSVQTSuPVMnbJc2Npwpt3epzAxVQX6K9DR0ADERWzHy/GHimNTqWCHPNEYtknkYAMLHYxFvNtTpjdizBxEwt4aDrN4She4tU2MzCJG3HCivB8zxW/ngEL288qFvc/Hq8BG6vH5nJdozpkYWhnZuB54GPfzsVfuNIQ82iS4+2fTBJ8SOVlRVB649zPYGtuXcBAOLhxokCxShWfAC5YEMzqv4IR1lFSOVQUlm5t2JmV7OJw9SBufIaNICQgksVDSstKZE+euG7v3G23IUF6/8CT32fcsQH4kIUlpkiUcy0zUgQUrvFCQqTURkQM0Q4KOvsaFUBpgJMd+XJ44yKq7ySm0myzPz2rvBhYiaOFAkPvwHtm+Lijs0CRc2s8fhv0zvwH+9l+N9xKwp86pYQH8wywVZWfFbRtkCHSywzIQOATSbg5o3A5E+AZDGjiqSFA7hvVE8smthLe/twWGySxSWLK0ZZpXCOS6p8smrbF7RLl47bhCtHMslGC+NmIvEKFaILsaioUGaZIfMXSZCOr+S4fPmPLwIvnw/k/a59MNKJEoFVnYwoAonrMVtxvKhSKKNjNQkxM4DMzeSivkNli4EoRCpS4izgRCGdABdOlVTB4xPuReJmapZUTUsBZQ0jlpkMozVrZG6mEJYZus6VJT7w+w3lMqIDgIHA7yESYmbjE4DfgzklQlFGYlHO0xBk5LtlpcYZL1DYQGBippaooCtrhiHOakbPlsJD5PuDZ7H1cCEe+2QfnvvqT/xyvETX8Q6JAa49W6aB4zhc0kWokKt3+4hCpWbzlLndCzOqROuBt5KyQokPax/MSEgWzoOJ43G6qES+X/EB5IRNnuVCdbKkzgwpRpieaMPNF+WiRVo8Pry9P/54YhTm/iMQJyKDymgqLRPNzZZ4HMwP1KLgvYGO8CTfjAoATpbPxyQW3WhL3CRiR5Sb7ANHzk9CwD0mI4ybiedM2JEnH60XVfpkAcDesweFByQAvqpYKgTYWqUmRdMR9+Fp73V4c+sxPLtZfaoCH0xISrCDF8+R2VUin0+MMtuXuoibKcy93/I8IHdQ4D0lCC/v2854vIQSsTZQU64U5U6hEy8T/ZAWE4cnxnfHP/u0lCxkyb5SJHPh3UxFDje2HxGukUOMmSktLZbmYSr3mfF/WxX1ZTK7Cf9LjsmXb3oaKDgA/DfEZLrEMkPOTyTEjMWO308K93i37JRAh0jmZ4IDlXzgN/Z35xsBiLFo4m/ayvlg4T0oLBfOmR8cbGYTUgwG7UpQ1jC+upYZsW0JnAsVJWe1Y2CIZcZsE4Q1eYY4dcyNZrLgh4MF+Oeq/eK+Kms+B5eijAVxg58oqlQd0BIx0zyl8VX+JTAxU0tUisWo9Fb0HdVdMIu/sfUYNh0IjHr1BvEeKZBXte2WI3Q6B89Uw0evhdsB/PkVUHAw9Hrij57nTMh3BtwEXt4Mm5gJYfVVBUbIYiftgRlJSYERcQllHRFWEMUMb0N6ItXRUXEeSssMADzyj274cc4lOK9NOqxmk/ZIhmQ0cRWoqBDcELwtAacov7XJH6gFJHMzmUyydF4iqqSYD7FzHN4uHhYy6QJliZCh6WYS63nAjDyv3M1UWOWTrF4JcCGlJJASzImxP+mJNtW6HUM7Z2J09yz4/Dx2F6k/InwwISXOKk3emYYKHCuiCo5JbiYOpS4heMLw5Hf0dBdq83UZRcxSyrGUgxPjOkrEtk0b1A7XX9gGFnNg3i2btxxNIP5eFNk1hLPlLgx9bhMWfC50ZA7RMuMoK5bE9t4zLhS4FO6xZl2E/8UKMUPiX5TLaYhFgHS41cmIIkiWGRv2iGKmZ8u0wOeUZcYTqCONEr/wPVPjrYLoEK0TGSjDmSJhP36YkJFkq76lQMUyI6sFpQfRanShaR/m/3Ul8MGN6utJVjTRvabHMkNVAH5o3R78ku+DT8yexKlfgB9fCK4rVPq3vlnOySSvAEzw45wWKTCbOFS4vKqBzCTLKauRxssATMzUGg4DlhkAuLpfKyTZLTiUXyFl3ADA4bP6KvmSYLfsVOHHSTrR06VO9Wqt1WHjk8A7VwJvjKVK/atAOg6nH0WewPf3wQxLnCBWkrgqqfZLwDJjQlqCXbLmVFaUyjJwSECuE4pOWUXMGK4cCkidWjpXjkqxHLrXJH9YfJsyHgCw2dxfOA4doEhZiEg7pOqc4qhzQAurJGYqrerBttqWGeFh6vJxOMPLt81z8HCII+l4zo0s78mgzduGqBT69IQe6Nw8GSW8evaQDyZBnIjnuglXIU3YKbQtEBxJMjJCxsyokdZasGBk9QzEMNQEsYPokFAJs1hTtkScZVgWAB6XJo2MW3OCZcprVXe3ffLbKZmbKjVNOB9VFaVSPMqxMn+wmylTtAaW/q1uLQhVq4SsL1lmalDd20uJmb8FEdKjBSXcRDHTzFKFOIidaLfLcSyxJwBxkGAySVavTK4Y3PGfAACH/VnVC/5VHFuAwz3DOmquqol4f7bkChDHu4D9H6uvRywzJOuMHFtHzIwXZsFFBxNKIdwnvneuBTY8Cnw6I7D+ng+AJecA3zymo91p0svmKEZGol16dpCyEjQkZqZ5iEmMGzpMzNQCPM9LMTOJNn0ji+Q4K649v1XQ8r90BvAWifUiSMBxkwSrFBgWFEhbXTqNFP6Xnw6qVyFDFDOlzoC1ABAsL+Y44m93BooEUhaHtASb5PeOh0vu9xYtM1VBYiaNPjiAMPEaWojz7mSgDE4xpsfFyR8Wj7uuAca9jFne2wAAmbSZVyaqODRNsiGZiB1x1Nku2ScV1vv3TwrREi6g0BMQc0ox4+HNcJsCQacZXOD67My+BoBK0DNFWoIN/5s+EKvuuFT1c2KZIXE+aVwFjhdSnSo1aiUu1uRQ2UxqmMzAbT8At2wSOsyaIs4C3tpWAZN4X5DA7M60mDEFUtLjOeF3dMap3vZfxYxBQKghldtCsKi6q8rAi6P9v8v9KOUVYqhZZ6HD9HuAjY8b+x7EikAsedVJ7yaIlhm/2SbVperRkhIR4m8p2+5CvDjrOEY9g1JRoEq/O7GOTyZXAlOZML3HLr5D9eZlIlBupvSkONw7vDpiRiWAXa3COJ15BuiMmSETbhIXmA0ua8DtCgD484vA+hufFP7/uDRssyWLGfD/7Z13fFRV+v8/d2oyk957QiAhoUNCB+kIoqJUEVdxVZriruLa1i8uu6LruiKuCtZVBBYVBH6uAuoCFkRpIiBVSoCQ3nubeX5/nHvv3CkJSZhkZpLzfr14MeXmzrnzzD3nOU9FrJAHXy+N3NNPysI8fKkYs978EZsOXZGDm8Nb07usg8CVmXagut4EsXp+sy0zAHDv8C52r13Ir2hWELCtMiMIgmydcVqfpi6jLK6AprIypB499YQyxaRuggpab7FGhVCrUGYsMTMBBi0ERQdrq6rIkmWGdPD3VkyaCouIj1jVtVWN10S3RIhQBo2JnUdKdx6fynaiF0vNuPdod+TWOqhQq1CqTFAhQdmVW5yoNfXl8FYzeX5/1UauvmK9lcYsM4qYoTwEWL8FDYL8fSFlgQQK4oIX3gtrDfMAXLsatZdWjdS4cIfvEVTM2iUqXAFwbJkhlQZVoiWwxZYZgCk0qlZmMNkiKjORmnKoRMtMrQnQqgUkhth8F0br+KWM0gbklNbAZCarwmW/XGGK5trfD8L3j49BUDD7zfiYK1Bfy76PnCognwKszx/RGwgSqy2LloxmI20c/MRKyU5wM5XWCaisM8FLq7IuIClaKMI1FdAKokVX640SMT5KyhKUssXChBKoa9l3Uky+12mZsSgzgrqV7ipH2Xi2rh9AYZmRsrgC2P/NsMxU1LP7NjHEp9FSBgAAZUHKa6HIrkpTn4NBp0YvMVRgzTfnMOT5XZi+Zh8OZBThT5uP4Ucx/CCCW2Y4bUmlGC8jCIChmZYZgKVH/mFcEqL8vfDanP4QBNZ4rKAZPZuKq6yVGQCIFxfTjEInKTOCYOkabJtOrEQMcK1uALLIMrk0QA29QSq4VS0XXiPJfEsqNlmKJn5voVYuDAXAEjNja5lRWxZNP6EScwbFte76xGuL0VXCIJrYK0zsc/rG+MuF9vaIMU0GndraAqRQqgiCzSIhvldTCr2ozNRAJxddY4NntVFQXeTYjSdOeNWkRZ7NYlkHDZLC/WSlKRjiAth9Mo7nsmtJasIy0xyYm4nJM1Aox2UrZUaMk1JZvg+Xd4AX3UwhKJYtM2YISInwY92grY4NtXr6+NbTGPLCLnR9ejuG/n0Xth7JRGFFrVxfp39cAFQqAWoxEytUKEVdDXsvv0ZAHiyLHHkFskXv1n+xF/JOWeSrdGd99QxweK39dUiF7qTigk4IAM6vYspdaiSLzZCR3EykUKi1BrmHk8UyI7mZSmBoYBaeYvJBSGvbTwDWcUqtjZlypFw4UmZsLDNFZtEF2wzLjNR7rEuIETofB3FvkmyVMXHXChBW1A56QrMRgtmEUd3Zb7Kgos6ueJ60eY0L6pxNJgGuzLQLcryMTtPi3cUjE5Kx76lxuKVvFGLEyo7XqhVDRHJdm0CFMiNl0tgVn7sepEm/Mr/xY8SFraoeyCLLjrcBavj5B7DToAZXHVpmLG4mI2pslBl2HXbKjIKufoRnb+nR0qtiiNcWpS2HQWCTR3ED+5zEUB88Mam71eGJoUZr+dpYZm7rH215z8fyvXmpzPIxZp0ia0Y03aOhxnFhNHECrjRpUQ0v1KotC2E91BjUJUjemUYJbOdWUCPgYkEl1CoB/WID7E7pkEZqrPh5aeXvKARlNgHA7PdnFmv1+Oo19gpDeyNaZvxMJdCIVgYT1Ogb6yC4N8jaKloHiyJGBPx7bwYOiBlMXUONllgp6fsQSmGqs5QOqNRalHi5Y3ew6DapLbVY35T1gva9Bvz3YWurp6neUrxRUmYcWWaImlfDRlRm8irZgtszyrYSdgD7qHp2LjNUgFonB6FKhSoly0y0phQBYtB0MXyt6j+1GGUGmbqV7ipHbqZrWGaq6hrw5gEmj7z8XPtjJURXaqnoteoSaoRPQKj9cZKbWKv4LmwrQduNx0bZyfgOvaL8Ean4PmODvDEzLcbqsM7aMRvgyky7YEnLvj5zubSzP3+NIOCK2gbUiU0lgwwKZUb8oV9ylmUGkBeIJpUZ0TJT1UA4TBZT6yUKR0Qo260YBdGFZDbLmSZeeh1bABVVSLMURaOkmIRa6KyylZR4NZS1PANCwmhxMxlFd1W+6E5KDvfB6O5huPjCTXj6phRE+Xth0ahuNh8eID+8sVc0hnZV7MzE8vooy4Ja/H5WzUmHMcCi7NXqAlnfF8Cxq0mc8CrMbKGt9rJkQEwf2AXzhiXI7pJIUZn5IYMtfBNSw5vfgbgxZcZbq4iVKEZuWa0luFxUSCVlJsDYyp21MxF/q4b6QughBk9Di36xDnbvkgtIpF5UZiTL2/GrpXhs01EALPvL8hmiZQYlMIvyqSUtQgIsCpOgDDaVXInFGY2Pu/C85bGy/YD0t44CgH/ZALzUFTj0b/v39r4CvJwCFF2Q40dyq5gy0z3CcVsPfX0JABafBkGQuzfLi6tomUnQlVusmORtKb7XGpQBwK1VZnQOArfLMu1fU1hmfjhXiJxaMcW+qJF5rbpYVlKk0gNdQozQ+zqwzJSLafkNCot6k5ZskhXWnaaB7LXjn0KlEvDqHf1xU+8IfLpoKL5/fCz+Pr0PvMX5LcrfyxKT1wnhykw7oLTMXA+SMiN14G4MySrjrVXDW+HWktxMzrXMiItvMywzlfWEH809cLz7Ejzd8AAG9EuDr18AACkAuMqqcqyPQZwopawilFvK5hNBkGJGqHHLzDU73zaFeG0B5mL4iMXTSkxe0KgE+bsUBAHzb+iKfU+Nw5Q+kdZ/r7DMeOtsxidZXcpz5GvuHRsMteJvrpQTytXihO4oPVuc8Mob2O+qwduyqN7UL54pcWLtGqPAFpjjOew7e+CGxGtdvYVGaqzEBHrLSlmk2MBRDi6XrWtsbIGGVi5GzkR0M6mqChFjFEvuCzqMSwmzPzbI+vuZmpaAX5ffiOPLb0RiKJN9ZZ0JsUHeWDxGocSKClOIUCqnwNdCa7Woq0iRqRSYwP4vvsj+d9DKAz++ZnksxctoDZbF3lEA8M6n2P+fP2L/3v/+whbY7X+SrQtFNWxBjrXt62PTLbyKdHjy02Ny3zf5uiTLjKpQjq2phu76lBll3SV1K+dOB5bw7CsX7Y9TWGZOZJXKWUkO54+MH4AXE+RA3mLxu+saamzErSUqMyalMtOExUdRwG+TSay7dH4XAGBQlyCsnpuGtHhmcVKrBLwyuy/S4wPx16m9Gj9nJ4ArM+2AnMl0nTEDyWJJa2U3bEcUOYiXASyWmazSatTUOyk9uzluJqlXiwkABCRO+wueeuYFrJzV11JuHDUoq2lAaaXF8uJno8wECuWWbC7FDd+g0tnHIok7ZKklQasQF2pDfRECBfa5FfBmvvHmuEyUJm7bbBxpV12ebd3jRaHMbDmaj6u1bDGoLnXw/Yo7/1JRmSFxQQFg2ckarXeKZSY1wnz16N9cFxPQqGUmPtgg78gjhBIAingskyW9HrA0+nQpxhAx5ZowOpIt4mN6xlm5YmWCrS0zy2/vL8f8DEqwyPXhsUnW95mozPgLVdCb2HdR09SiLioz5qIMFtjvSJnJO2V5rChyJ7ukHLmZmgpElcg/I1ebLqhmC3KMrTJjc54a0uOjgyxbSa9RyRk20u8gpM5SAqAG+utTZvwUm4PWWmYccPzUSUsZCAmFZeZEVpmcfeZtKrcuZdFQB3xwk9WfVpsEqAQgNsjg+HuXLDPKyt5NKTOK4N9fzN0s52ikoeikXpHYvGgYxvdwHKzfWeDKTDsgBQBfr5spLZ7dKL9cKbGut2JDsRgMFmhj2g8y6uCr14AI9l2OW4uszDThnxeVGTNUMOrUMOo18PXSsvgSUZnxVbEb/becEvnP/IziRCjGfQShHNmlNcxtp7ixvQw+9rFId/8/IG4YcPe267i2MECtg0BmJAnMNF1B3ugfF9DMv1f4z20nYyvLjKIsumInXAstSsC+n98yHBRRE3f+pfXsd6XyVyozouxtqgrXkhbjUsNblt3lH2311AwB84YlwKDTyApfAJVCiwZLELCiBgfASgO4HJVaVox9a9gCkxrrIMYBsPSHklDIb/bAWHhpVUiN9MMtYoNOGa8AmFXsWG+yWGaiA7yQHX8rAOCEWlFxWlRmtuzei+lr9oHMDjYZhecsbkZFkTvZhWKut043NtVbVxZurJllTZl8H0mxYNEBNjEXNopsNaTsSOCZKamsyCAgW2a0ZrHnFQnQ6b2ur0+Qb9soM2Eowo7jNhWZxe+BtF44nmmxzPihEmeUhUbL7Os1maBGQoiR9Q1rSplRupnKcxofoBgfZxK0KIQfalSiTEoduMc4MlyZaQckN9P1ZnN0DfVBoEGL2gYzjl8tafS4Qjkt2zqTQBAExIsVgaUKwY2x97cC/OWzE7hyrZo0UoR+Y/2DANnNZILKEjAoIU7IkhvnvEKZ8TVIygz7jAgt2+leyK+Qd1L1pEaAj4Ogt7BU4Pc7rMvjtxSVCvBnAXapalGZgTcGd2mkUq8tPoqF0t86UI8pM4J1cTS11irOphZaFBBTbnKu2vTwAWSffV49k7M+UKF0yJYZG2UGOtxi6w67FhOfA8J6AlNWAgu+g+rRk/jLrWJ3be8gOa4nBKUWy5lUxZkkZcYNLDOApbKq1BNJ4+X4OJ3Nb0qhLPePC8T+p8bjs4eG28djCYK13MEUyKgAb5huegUr6u/EgzWLUS/GtEmBxtHmXPx8uQRmRXsMJbs/X88sN0plRu8HuXGrMusm64j1H5cqFmBlVlxduRxvU0VeCDbqrNzS7HM0VgqxweiLd+5Ox8UXpuB3QxMsxxlDoWwiWw09ogMM19cnyEdhaXBUG6aVRAhF2HfeZr4S55OSOjVyympQrWaZfn5CNU5nKeo8Xf7R7nz1UKO/FHdl05MNgCXgWGmZKbnS+ABFi2u9Sg9AQIlOvF+bqgrN4cpMeyAFABuuM2ZGEAR5If3R9mZUIFlmghzshqW4m7NNtDWoqG3Aog2H8cG+DDz0n59hMlOjx8rKTJOWGabMmKFCqG3dCXEno0U9vFCL87kl8lsBspuJTabhGjbxns+vsCoY15xO5K3GnxUuDAWb0MphwPBujfRQssVXsWv3t0kPV2st/XkkVGo7y4xUDK+8wMHkJwaGZppDoRIAQ7BCYZKUGRvLzIxBiRjW3PFL+EUBi/cBA+8DIvtasmgApvCJVqZwoRincsTflaik1RObYtxGmZEUjRqp11YTqcO2MlO+ZdBCq3Y8fap8rGNwaqFDbJABUaHB2Ki5DRmmYHxy6Aoe/M/P+KmY3Y+xKhYQSjZupkovtqCrjm/G+v2XLcUI1Tr2e5GLuyliqopsYkKUmTPKGBAyywttJbwQbetiklC4e2LCgjHBkTtDrbGyRFZDh7uHxTs+X3NRZnZVtaK7uMQw1qwWsYMBAGEowZGMPOt5TZxPLpWx13olWgqWXrgiKiN5p4Fti+xOX63xw4JRYoxVk24mhaLaVMC3aJmpE9hvs8Jb3KSUNPE3HK7MtAcWN9P119kY3o0pDz+ca1yZKZTdTPYLiFQb5WR24xV7fzxfiHKxwufRzFL87fOTjQ9I3PkXF2TJzS3tEHdVtdAi1LYRmt5X3tkHogL7T7PdRwV5IUiqHioqTMFi4bdzeUplRtu2ykyAdRXm6cNSml+Yyi8SGLkUiE4Duo6xfz/cVpmxjpmpJS36prIePqqKXFTVKRa6L5YCOccAAFcoFEFGHVRSMKl0LsDOMjO+n03GlTMQd9DhQjHO5JSxRUK0xtWJykyQO2QzAYCfjYWsMcsMYG9Nay4+1ot9LbSICfSGSiVgYAJb7P689Vd8cSwbD+0oAQBEoRA61Fv6dIl8ox8LAOiv+g2vfHUG9bVibIfa+t6wsoyW2ii+yswZZWYUABSx51XkhdjARtJ6le4ebRMxML6W6w7yD8DcwdepzChpyvJ7LcY8A8zeANz5CUhrhEog3FT/P5zJUcxXomXmYin7/kemRKFeLcYYZovKyLGPHZ5+eK8kSzVtB8pMSa5oUVFal5pUZkT3pKjM1PiIv0PbDuscK7gy0w5Ii5DPdcbMAJB31YcvFTfaY0nqyxTmoLR1D1GZOdWEMvPDObYLktxiH+zLaNQSlGdiN7GvuRyrdzfScFI0gZeREZG2biZBkGNiuhiqYa5mO+ZyGOSMIWnC9jOz85zOLpcnn1roENyWyoxSQQAwuHuCw8MaZdwy4IHddkoFAPuJT2W9u31man+k92YKTxiK8Yuy4/nBd+WHmRTKKq0qlSN5sbOps6F3Qo8jW0TLTIymFDX1ZuYGFC0MYlPq6wsEdSZR/ayft4Uyo1j8TSTArNbJZeZnD7RWjgvghyrSQyUQRobYB/LuKGTn8heqYK4qwslM0UIhxURJQebK1H3bGBllcL6tMiNSBT1ighqRUXOVGUUAulrv5HonkiWtNWi9gNSbAe8ACKKVaYX23zh6RvFdiArExRLm/huZFCLfO4X5WTCbyUoppG4T5Mexfop53YEyU1+SxTqSK91M5VnWtWSIWObZV88AOx4HAAiidZMkCyF3MzUJV2bagYoWNplsisQQIyL8vFBnMuPQJcdl7uU+HQ7awUuWmYsFldY7fZG6BjN2/Mp2Ii/N6INZ6WxC//yYg0JTAI4UMp+4RjDjl7MZ7Ka3RTRtl8Lo2KohKisvTIpGkj9b/crIgB5SAS/RraFrqIAvqnA0swQkFcwjneNsFGdhk6LbWGZPq3CkzChcFGGBflYunEOXHPdoKoMRwT46ttDc9iYw/i8Wi5KNm8nKdO8sRFdcP1+24Dy99TiKK9jiUNXAphi3UWbCUq2fN+VmsrHKNZvoNPlhOQyIDjDIAdeTekVizdwBeHlmX3w0fwjUKhUugS2wM2LsNxh5JiPywRbVeCEXv2SIC6pah52/ZmNftni/Kd1MthWBlZkzjfRxqoIeMc2xzGiaZ5lpUulxJYq6M2Vnv7O8LhWgNGtYj60QIzSi4uPXUIQrxVWsuKFI/qjnUSU2cg3uMcpyHkXMm0SoUIqT32+1y0b6/vDPlicll1hNoH2vAdm/AADKiclDHZTAjil2kFLOkeHKTDvgrDozAIubkWI2HLmaiirrcDCDTWyO2sGH+uoR4qMHEXA6x35i+/JEDnLLahHqq8fY1DBM7sVu6N2n8xz2hPo5swpl4k0nVBfgVI4Di4+4qyojg9zF2wpRmYn3rsGjN7DP8/YNtJT/1/vIi3IXdT4KKupQUMzOWdPWlhmb4mlOtWzYKjOCyhKgCgAhSfJCEiYUy3JV+t4vhjI3hNwDp98cYISitogxVO4ADcC5ypg8Tua66uPFLAAHM4rx8o5fAQA1JgGC4EZl1pXy1PvJcRQOSb+PuUBTbm7ZZygUpjIy2DX0nNw7EtPTYjAkMRh7lo5Glx7pAIBhRvtMGQCoNDKlKl7IwynJMqPR489bf5VT900VipgSqYie2A4g88ol5JXX4K5392PDD2ccfkY5GexrzEgoY6Rs6s5YoSwNoHWSvJv6vNYwZaX8MD/3qmVOk1w70OGG5BAIggDBT9pIFOGXKyWWgoXT3sGvlf4YVbsSDxv+AV1MP8v5berhmAT2fNbpPwAFZ63e+8//DljidhzEHD5FDwIAdNG92Qt5p5waCN3R4MpMO1BazRafZldcvQZS3MyP561vgOo6E0b9Yw9qxbTtlEjHC1dfsSvu4Qz7nb5klZmZFgO9Ro2hXYOh16iQXVrjsFjfkSslKCD2OaFCKfb+5iBQT3IzwYjIAEeWGclUXogYL7HHSGSE9TGBzP8+JIiN4VIuU+SqobNu7uhs7CwzzlRmlHVotMzlFpIEpN7CFtKgRNky4ydU4/TlHDb5KUzuG+OXA0DjDf10BiBuqOJ5G1hmxLL8searzDwPoLaGLah10KJLsNEpVkmn4BthUU6mv+e4EaGEfzTwRAYw68OWfYYirbtBpcPvR9g3jJWICzbAS1ys/EtP271vDIpEaByLm0rS5KG6WuzHZVajsLIORWC/x5xcheVUdDOR6CI9e+ECBq3Yhb3nCpCdz+75Bp0i0Jy0yIe/de8wJcpAdUfuUglfpTLjJMvM77YCoanAnZucc76YdJh6TgcA6GpL8MkhFl+UVci+lxrocEOS6OoV46vihDz8dKHQUrBQ74djmaXIRyA08U0ow4C1IihSSExm2qo8ywbFQYuFU9UBAICI+O5srjDVAe+MA35e1+zL7UxwZaYdKJGUGSfV2hjWlU0ox6+WyooSwIrplYtWoNHdQxsNjB2SyJShny5YW3Zq6k3Yc5rtrif1YhOTl1aNgWKRMCmWRqLBZMbxzFLkiM0jI1CE7x0oMyT67AvIz6q3iIwUxFiRZ7mpfW0yJgKY33iAH5tQLuWySaCGdHLPqTbBtvqtTQPC60JZv0UK2FWpgdnrgZvFHaTeFyQVFqzLx+mcMksars4XGUXNaDDXa5rlM5pyq7QWsRuwqiQD6+7pj6dvSkEkmHxyKNDiLnQHBAG4YwPwl1IgeeK1j9f7tLxrt0JBSjTWy/dbo4SLae5Zv8gvPRe2Eubp/8b7f5oLY1xfAMB443noBHZ/S1VnS8SFMT9XUTdFtMwUGRIAAGPVv+Bt7ctIFLLgLVWC1vaWD8+lAET4G+wL5tmOD5ADux3SFspMdBrw4E/Nk1UzUYv3XaBQjn/sPIMzOeW4LM4nOi8jxkgVocXr7iFcYqnckmXGyw9Hr5QAAPo6Kj6pcO2qHSgzGSTGmAn5+O9Rcb4rz7Y7rhrMiu7jpbW4LnOPA+e+bsnldhq4MtMOlFQxhSPASZaZCH8vJIYaYSZgv0IhOZbJduxdQ41463dpjf25PLkeuFgkmzmJCN+cyUd1vQlR/l7oHW3ZuUlurb02bq0zueWorjchX8XejxIKcSCjyLq6sNksByCWqgLsU7MBi4Lw/T+BH19nj20Cb6XnqXqmLB27yIpO1UKH+KA2VGYAYNyz7P+4oYDGiS4tZYBpE+Z0QVwkIoRiplBK6bXegbhQwBauJhvMDbgHuOVVFoh8PXU/GsM3gll8yAQUX8SUPlGIFpicrlII+sQ42VXg7ii/Y2UJ+8aI7Mf+V6QfP7Po91D1ZhYEJN0IAEitPoxEgS16Ui8lyRViKr5icZmIMTO/qlLk801UH8Yq73cRLd4qP5ZaFK4qXTCeu61X4zVhlDV3HPU6kmgLN1NbIMaldfMqRWFlHea88xO8wOT0yOQ+ltpBkX0AAMPUJ1FYWACTuImo1/riiKjMOPxtRw9QfJb95ucwMTdkuuosth/PZjWHbCwzZkGDOmgsG4H+d1neVLqiOTJcmWlDCipqcaWoCiVVjadKt5bhonVGWfzp16tMmbm1bzSrRtkIPaL84OulQXltA45lloCI8MCHh7Bw/WEAwMSeEVYT2whRmfnxfAG+PpmL46LS9L+TLBhRFcAW5a56Vpn4YEYRi86vLgGqiyCIdWb8Q6IsFUOV9P+d5bFkyrWtwBrCOlRHN1yGRiXIfW+0Xgb7Ql/OZsQjzCVx22rnnleZJmxTZdcKUZHrJlzFlydyZcuMSe8vF6nrGdWEwqDWAmnzWI2YtkByjwHAgbcRHeCNnkY2xiwhDJN6trBIX0dgsFiPZOob1z7WJxQItSge0BqsFaKQbkA4s6TM13wBAMgsYxaaG4YOAQBEmLIsDWjFzKYjNdau2j7m07it9jN2COmxnOaD1DqkzH4O41KvUQp/1odAz9uB9N83foz0GwAcd3l3F0RLYj+vXPxevQMb6h9BPxXLbAoNVNxHoZbYp091f5EtM7sv1qCkqh4hPjqrTZ/MLa+yWKzp7wFR/e3ejh54CwBgkPosSqtq2QbFpiJwhVkHQEC6WPUdqbdY3ryezK4ODFdm2oDz+RV4YccpDH1hF0b+Yw+KRctMo3ENrUCylnx9MlfOIDomKjO9Y5o266tVAkYlsx3DzhM5+O+xbPzvFFNMDDo17hpiXSysZ5QfEkONqKwz4YEPD+GW1/dix/FsbBdLgkfFsUksxch89Xt/KwC+fxl4MZ517gWQSSHoFtlIv5iAWOD+XTav2dSoCGXKjKbgDIZ3C5F3UgF+7eDCEASg9wz7+JnrRa0BRjzKAoEnv9T4ceKE2Fu4iMOXilFazGRVCiOImFWmTeOGmoNUafngu0BZFlK8SgAAt40agrimrEYdlfF/AZb8zFKCm4Ny5+2oP9PwhwEAarB4uCrygk6jQp8+zAoQLRTiq1/EbBcxmPSXIh12mewXU4DFhqgG3gvhz7lA0gSHx1jRYyow84NGm44CsK5+m2cf/+M2RDCLS2DFOSzTrkOqisXNkN7PYiUDrKyw3VWZUIsNQv9ztAQAcM/QBMebM78o4L6v2JwxZDHQ5w6YFVlgUybfCuh84YMqpAqX8dnRLJaqrUDq6j5ZdPdDpbZYvhzVrOJwZcbZZJdWY+rrP+Ctby+g3mTJ/hEE5/anGd09FD56Da6WVOPw5WJU1jbIu/RejnYLNtzUm+2W3/v+Iv689TgAYErvSOxaOgrdwqyDXFUqAYtHWxdbW7ThZ5zJLYdWLSClO9tVJpguASDsOpUL7P6b1fH/NQ1F94gmgmdj0q0zTWzdTKIyg6oCPJEu4EntRwCArlEtrGbrbox/Fnj8IhDTuFtQUmZu0h6CFg04+hurN5FTyxQYKejWpYx5BnI5+wvfQFPOMnNGDnS8mHZ4tF52zSqbRJkx5cg1FW7dEbkURswdHAeDfxjqtEzB+OnQQZjqquUU4qPFWjzXcBfKR/4fC2RWWIluHpiMJyal2DdAvV7EApitTmtvD/wigZhBVi/l+feB8MBu+4DwG/5k9ZQg4LvLNVAJwKyBzbhGrTcw7S2oblzBnqt17LcRxwKHB6pO46sTuTCX2igzQj0Wj+6KJGUm3AO7gRn/BvrMbt51djK4MuNkPjpwBRW1DdBrVHh4XBLCxB1zSoTf9fUpscFLq5aDdDcduoITWWUgYunYjorl2TI+NRxdQoxoMBPKaxqQGGLEy7P6Ok6dBjAjLQabFw7FtgeHW6VCT+gRDmPiEECtg7HqKj7Sv4DUQvsAtdUNU+VA4kaRTNixg+19zTojEMwUqh77n5Bf9ulx4zWv1e251u8ifhig1sOXKnCbei+KzjN34NlyJgc5+8KVaHTAoPns8bFPWDsDQW3d0oHTOEGNZzwBsFPuJ6Wn4JkpPQBBgDqKWRo+rHsE1a+PAACQoEExGVFmiIfP2KXM+tdvLjD8D0Dvmeh34z3N6/zeUhZ8B/SdA0x52fnndiaJo+WHFD0QYY98b+0mkxj1pCU4H0A5eYOgwvBuIQh3UPqiUdLmAeOXA7etYc/jhwEA7tF9g/raKjSIysy/GyYBAMw3voDHJ6VYn8M/Gug1veUB6Z0Ersw4EbOZ8OnPrCHhP2b0waMTkvH23emY2CMcK2c5P15Bqia67UgWvj7JfK7NscoAgE6jwr/u6I/h3YJxe/9orLt/sH3TPBvSE4LQLzYAD4+z3PS/H96F7WbE/idDhF/xmu51+f3CqDEYVPMGVN7+6O8o8l/JkMXAnI+BmWsdvy8GQuIqW8zR987mm/E9Ge9AoC/bjb2kfRu3mZmyeLHWD/7eWozq7gbKDAAksIUUF/aw//2i7OpucJpgqhiT1XOa/Xs6g1UMR1xUJNRiIT611HsIgE/ZOQBAtS4QgIDeMf6WTZQgABP+Ckx/13EPIWcQ3gO4/U3nu2Sdjei2AwChKr/x49QaKytOvtj49fb+TcS4OUKlBkb8kbmeAKZYegWgC13Grep90JlYjNFLDbPwj9TNUA2x7wHFaRquzDiR/ReLkFlcDV+9BhN7MKtJv9gAvH13ulx515kMTAjCoIQg1JnMeOd75i9vSeZI7xh/bLh/CF6Z3Q/RLajQevfQeLw2pz823D8Y6ZK1ZchiQG0dt5ETOQ731C5FHgIxtV8jwb9KVCqg+ySrxnZWpNxk/fyGx5o9Zo8nbZ7dS9XQYVZ6TJPB3u1Kys1At/GW5wGNN2rkOKDfncD8by27d1uUirtBke7dfRIaIgdYHVpfxyra9mnm5qbTofcFbnyePW4qXg0Auo6VH16gKCSGGjGlpZ3nbfGNkEsmPKz7HADrMF8NL/Tv3adtsg47OFyZcSJfHGemwil9Its+w0Zk6cRkq+cj2iF+QhAE3NI3yrp7tDEEmPcFcPvbyPRlVqh3Lkfi16tl8NVr8IdxDky4LSV2iOVx6i0ti0nwdKLTmIlZ5LI5FBkJs/DIhOQm/qidUamAiSssz9XOixHrFAgC6x2lbcR9MXghs6gYQqzcJACgmfEu8hKmys+9zWynP7DLNVy7nZkhi1m82rVq2CgyuHr2G4xtDw53zgai6zgAQCyxdUMrmBBg0MrZo5yWwW3ATkSqfjs2pf3qAAxODMaCUYl469sLGNY1+NqunLYkdiAQOxBhqdPw6JufYGsWs0b97bZeCHZGJpdaA9z9/4BD7wOTXrj+83ka098D+t0Js8YIfVB/vOWrd2ocllMISwELBCYgove1jua0BGMIsPgn1p7CNlA1uCvC5n2IwvM/o+bj+/BixWT0jfGXC2xyHKBoctskxmDWBuHMDkRN/hPg5SQlPXmS1dP/5zcHr98yoN02wh0NgRw13HEzVq9ejZdeegnZ2dno2bMnVq1ahZEjRzbrb8vKyuDv74/S0lL4tWEa75WiKoz8xx6oVQKOLJsAP2f94JtJQUUtAg062Y/uaiprG7D1yFUkhhjlTt+cTkJxBlM4hy1puvw9p824UlSFcD+vtgny5TiPn9cBnz0E3P4W0PcOV4/G7WjJ+u32lpmPP/4Yf/zjH7F69WoMHz4cb731FiZPnoyTJ08iLs59fPJSGf/+sQHtrsgAzq1h4wyMeg3uGhJ/7QM5HY/ABGDCclePolMT6y6NPTlNM+B3zH2s4/K6XtxebV+5ciXuu+8+3H///UhNTcWqVasQGxuLNWsaCZJrR2rqTcgqqcavV0vlLKYbkt0ks4TD4XA47g9XZJyCW1tm6urqcPjwYTz55JNWr0+cOBH79u1z+De1tbWorbW0SS8rK2uTsa3631ms+t9vdq9LtV84HA6Hw+G0D25tmSkoKIDJZEJ4uHXfkPDwcOTk5Dj8mxdeeAH+/v7yv9jYtqlEKbmSNCoBYb56pEb6YcXtvZAc3kSVWw6Hw+FwOE7HrS0zErYZG0TUaBbHU089hUcffVR+XlZW1iYKzeyBsZieFgM/L437ZZRwOBwOh9OJcGtlJiQkBGq12s4Kk5eXZ2etkdDr9dDr2z4Y1qh366+Ow+FwOJxOg1u7mXQ6HdLS0vD119a9fr7++msMGzbMRaPicDgcDofjTri9eeHRRx/F7373O6Snp2Po0KF4++23cfnyZSxcuNDVQ+NwOBwOh+MGuL0yM3v2bBQWFuKvf/0rsrOz0atXL2zfvh3x8byGCYfD4XA4HA+pAHw9tFcFYA6Hw+FwOM6jJeu3W8fMcDgcDofD4VwLrsxwOBwOh8PxaLgyw+FwOBwOx6PhygyHw+FwOByPhiszHA6Hw+FwPBquzHA4HA6Hw/FouDLD4XA4HA7Ho3H7onnXi1RGp6yszMUj4XA4HA6H01ykdbs55fA6vDJTXl4OAG3SOZvD4XA4HE7bUl5eDn9//yaP6fAVgM1mM7KysuDr6wtBEJx23rKyMsTGxuLKlSsdsrJwR78+oONfY0e/PqDjX2NHvz6g419jR78+oO2ukYhQXl6OqKgoqFRNR8V0eMuMSqVCTExMm53fz8+vw/5AgY5/fUDHv8aOfn1Ax7/Gjn59QMe/xo5+fUDbXOO1LDISPACYw+FwOByOR8OVGQ6Hw+FwOB4NV2ZaiV6vx7PPPgu9Xu/qobQJHf36gI5/jR39+oCOf40d/fqAjn+NHf36APe4xg4fAMzhcDgcDqdjwy0zHA6Hw+FwPBquzHA4HA6Hw/FouDLD4XA4HA7Ho+HKDIfD4XA4HI+GKzOdCCnW+/3330dWVpaLR8NpDVyGng+XoefDZeh+cGWmEyEIAi5fvoz77rsPW7duRUNDg6uHxGkhXIaeT2eSYUdNlu1MMvQUuDLjgHPnzuHzzz8H0LFuxoaGBsTFxWHJkiVYuXIlzp075+ohtRnKyYXL0PPhMvQ88vLy5Ea/AJehJ2I2mwEAJpPJxSO5NlyZUVBXV4cFCxYgOTkZDz30EAA4tTmlKzGZTNBoWCuuV155BQUFBXj//fdRXV3t4pE5l7q6Ojz55JNYvHgxnn32WVRXV3MZehh1dXX45z//iXfffRc//PADAH4fehINDQ247777MGjQIIwfPx5z585FQUEBl6EHUV9fj8WLF2PBggUAcM0mj+6A+4+wnVi5ciX8/f1x6tQp/OEPf0BgYCDOnj3r6mE5DbVaDQAoLCyESqXC888/jzfeeANHjhxx8cicx7Zt2xAfH48DBw7Ay8sLL730EubPnw8i6hC7ws4gw08++QTR0dH47LPPsH79esyaNQvLli1DXV2dq4fmFDq6DBsaGjBv3jycPHkSa9euxZw5c3Ds2DFMmzYNp06dcvXwnEJHl+H+/fsxfvx4bN68GWvXrsUPP/wAQRDc3zpDnZyCggJKTU2lsLAw2rx5MxER7dq1i3x8fCgzM9PFo3MeV69epQkTJtA///lP+bWUlBSaMWMGFRUVuXBkzqGmpoYmT55MTz/9tPzatm3byGAwUHV1tQtH5jw6ugxLS0tp/Pjx9OKLLxIRUUVFBW3ZsoUEQaBVq1ZRVVWVi0d4/XR0GV6+fJmSkpJo3bp18mvZ2dkUHR1NS5YsoZycHBeOzjl0dBmuWrWK7rvvPtq+fTtNmzaNBg8e7OohNYtOr8yUlJTQzp07yWQyya9duXKFAgIC6OOPPyYiIrPZ7KrhtZi6urpG35s4cSLdcsstdODAASIi2rNnDwmCQJs3b/aoa1QijfvgwYPk7e1Nu3btkt9788036Y9//CNVVla6anitorPKcMeOHeTl5SVvIurq6qioqIjCw8Opf//+9NVXX7lymC2is8lQ4siRI+Tt7U2//fYbEbFNBhHR66+/Tt27d6dPPvnElcNrEZ1VhleuXKETJ04QEdHOnTspNDSU3n33XSIiqq+vd+XQmqRTKjPnzp2zUl4kpNfOnz9P/fr1o5UrV7b30FqNyWSiVatW0cMPP0xEbBLZvHkz5eXlycfs37+funfvTn/729/kBf7mm2+m9PR0unz5skvG3VrOnTtnN2nExMTQ7bffTtu3b6fHHnuMVCoV9enTh6Kiomj16tXyd+Guk01nl+GRI0coLCyMvvvuO/m1Y8eO0ZgxYygyMpKeeOIJeXF0VzqTDFesWEHLli2jjRs3yq/V1NRQfHw8Pfvss0RkrRCkp6fTvffey2XoRjiSoZKCggJasmQJxcbGUkNDAxG57/zZqZSZ9957j+Li4igtLY0GDx5M69evlxUYWwH16dOHlixZQkQkC9HdWbBgAQ0ePJj2799PmzZtIi8vL/r000+tjnn44Ydp2LBhtHPnTiJiJlO9Xk+vvPIK1dbWumLYLcJWhuvWrZMnzN27d9PixYtp0KBB1K1bN9q1axedOXOGnnvuOUpKSqK1a9e6ePTXpjPK8MMPPyQioqysLLrjjjsoIiKC1q1bRy+//DLp9Xpas2YNPfHEExQbG+vikTePji7D/fv3U1xcHA0YMIAmT55Mvr6+NH36dDp//jwRET322GOUnJxMubm5RESym3ft2rUUEBDgEW7fzijDGTNmyBY15Xq4f/9+SkpKoscee4yIyKEhwB3oNMrMqlWrqFu3brRx40bau3cvLVu2jFQqFb3xxhvyYmg2m2VBLVmyhIYMGeLKITcb6Yf3yy+/0MSJE+nee+8lIqLx48fTzJkz6cKFC/KxmZmZ1KVLF1q0aJE82Tz00EOk1Wrp4sWL7T72luBIhoIg0BtvvCFPHrW1tTRx4kQ7xaVnz55W8TTuRmeX4erVq8lsNlNubi7Nnj2bBg8eTElJSfT+++8TEdHRo0cpIiKCMjIyXHsBTdBZZPjoo4/SlClTiIgtbMePH6f4+HhauHAhlZSU0E8//UQDBgygxYsXE5Hle9mzZw+FhYXR0aNHXTb2a9HZZbho0SLKzs4mIssmvqqqil566SXy9/eX7789e/ZQaWmpawbfCJ1CmamsrKQJEybIpk/pBzty5EiKj4+nbdu2Wb1ORLR06VIaNmyYxwV0vfzyyzRgwADasWMHHTp0iCIiIujtt9+28nXOmzePunbtKu+IiYi2b9/uiuE2m2vJcOvWrUTEJpjAwEC6dOkSEbEbsqSkhNLT02nFihWuGHqL6YwyjI2NlWXY0NAgLw4STz/9NKWmplJ5eXl7DrnVdEQZms1mKikpoREjRtjt0levXk39+/enN998k4iIXnnlFTIYDLRlyxZ5o/Hcc8/R6NGj3dZNYUtnlGFaWhr961//svu7s2fP0ujRo2nQoEGUlpZGQUFBbqewdYrUbI1Gg8OHD6N79+4AgNraWgBAWFgY6uvrsWXLFuTn50MQBLnY2tixY3H48GGXjbmlkJh6fMcddyAxMRGvvfYa+vbtiylTpuDDDz/E0aNHAQA1NTUoKipCQUEBdu3ahcLCQgDA5MmTXTb25nAtGW7duhV5eXkIDAxEfHw8Fi5ciGPHjiEzMxNLly5FZWUlpk6d6spLuCadWYYmk0mWoVqtRlhYmPx3GRkZOHLkCObNmwcfHx+XjL25dDQZ/vzzzygtLQXAav34+/ujpqZGLoZXX18PALj//vvRpUsXbN++HVlZWXjwwQfx4IMP4p577sHEiRMxa9YsrFixAjNnzoQgCG5dKqEzyzA+Ph579uzBxYsXAViK5tXW1qKoqAgHDx7E4MGDkZ2djYSEhPa/mKZwqSrVBnzyySd0//3306pVq+jYsWPy63PmzKGUlBQ5U2L9+vU0ZswYuv/++yk5OZmOHDlidZ4vv/ySgoODaffu3e05/OtC2vFs2LCB0tPTafXq1ZSfn099+vShcePG0ZYtW+iZZ56hhx56iHbv3k0lJSUuHrFjWiPDpKQkOnr0KJnNZvruu+8oLCyMkpOTKSYmhsaMGSP7gt2dzixD2/twy5Yt9Oijj1JAQABNmjTJKgDTnekIMty8eTPFxMRQ165dKS4ujpYtWybL7NVXXyUfHx858FWyvHz66acUExNDP/zwg3yeTZs20bPPPksLFy6kU6dOtf+FtJLOLMPY2FgrGX7//fcUHx9PQ4YMoXPnzrX/hTSTDqPMFBQU0IwZMygiIoIWLlxII0aMoMjISNn8d/bsWUpMTKTExESKiooig8EgB3RpNBr64osviMjiJ8zMzJTT7jyN6upqmj9/Po0YMYIyMzPp22+/pZtvvpkSEhKoT58+tH//fvlYdwrmul4Zfv755/K5Ll++TAcOHOAybGecdR8SEf34449055130meffeaSa7lePFWGBw8epJSUFFq1ahUdPXqUVq9eTaGhobRo0SIqKSmhS5cuUdeuXWnBggVEZJ2xFBwcTO+9956rhu50uAxZnaAff/yx3a+hpXQYZWbTpk00aNAgq0J3U6dOpYSEBNkXf+XKFfryyy9p7dq1svDy8vIoMTGRNm3a5IphOx3phtq1axeNGDGCHnnkEfm906dPy4/d0W/NZcjgMvR8PFGG0ljWrFlDMTExVgGer7/+Og0aNIheeOEFIiJ64403SK1W07fffisfc/78eeratatd1o+nwmXoWXQYZeb222+nadOmERHJQYIffPABCYJA48aNk03Uttrzxx9/TCkpKXIEd0fiz3/+Mw0fPpy+/PJLq9fdNdWcy9AeLkPPx9Nk+Pjjj9PYsWOtik1WVFTQgw8+SEOGDKEzZ86Q2WymuXPnUkREBC1fvpyOHDlCCxYsoN69e9PVq1ddOPq2gcvQ/fHIAODvvvsOX375pVVn5KSkJJw4cQIA5CDB06dPY+zYsaipqcG2bdsAsIZZ+fn5OH36NF5//XU88sgjmDZtGkJCQtw6KK0lSNcxd+5caLVaHDlyxOrapN4iroTLsGm4DD0fd5fh119/jYcffhivvvoqDhw4IL8+fPhw7Nu3Dzk5OQBYY0Wj0YipU6dCpVLhiy++gCAIWL9+PWbOnImtW7di5syZOHjwIDZs2ICoqChXXZLT4TL0IFykRLWK/Px8uvvuu0kQBOrbt69Vatj58+cpNDSURo0aRS+++CINHTqUunTpQrt27aK+ffvS//3f/8nHHj58mG677Tbq0qWLVQ+RjoRkbhw6dKjsF3UHcyiXYfPhMvR83FGGWVlZdPPNN1NYWBjNnTuXevfuTf7+/nL8R3V1NaWkpND8+fOJyNqKNnLkSFq0aJH83GQyUWVlpZXbpaPBZegZeIxlpqGhAZs2bUJubi42btyI3377DR999JGc3pmYmIitW7ciOTkZH3/8MdLS0nDgwAGMHTsWffr0wcmTJ+VzDRgwAMuWLcOFCxdw1113ueqS2hRBEHD27FnU1NSgZ8+e8muuhMuwZXAZej7uJsOqqio89dRTMBqN+Omnn7B+/XocO3YMycnJWLNmDQBAq9Xi6aefxrvvvot9+/ZBpbIsE3FxcTh9+rT8XBAEGAwGOd2+I8Jl6CG4WptqCT/99BP997//JSKi5cuXU2hoqF1KNRFZlZLOzc2lXr160XPPPUdE7t0oy9k8//zztGTJEre6Zi7DlsFl6Pm4mwznz59PO3bsICKLHJYvX27VHbmmpoZuv/12Sk1NpW+++YbMZjNlZ2fToEGD5KaDnQkuQ/fHo5QZW9NeVFQUzZ8/n8rKyuzer66uprq6OrkypbLWRWfBnVIFJbgMWwaXoefjbjJUpuFKsrrrrrvogQcesHqturqaRo8eTWFhYTRx4kSKioqiIUOGeFQjRWfBZej+eJQyIyHt+D755BPSaDT01VdfWb2fmZlJq1evpvT0dAoKCqL//Oc/rhgmpwm4DD0fLsOOw8iRI+U+WGazWc7SycnJoa+++opWrFhBGzZscOEIOdeis8tQIPLs1IFhw4bBaDRiw4YNCAsLQ35+PkJDQ7Fx40ZkZWVh6dKlrh4i5xpwGXo+XIaey4ULFzBs2DB88cUXSEtLAwDU1dVBp9O5eGSc5sJlCGhcPYDW0tDQAI1Gg3feeQd9+/bFRx99hPPnz2Pv3r1Yu3Yt5syZ4+ohcq4Bl6Hnw2XouRARBEHA3r174ePjIy+Cy5cvR05ODpYvX27VI4vjfnAZWvB4ywwADBo0CIcOHUJcXBzeeust3Hjjja4eEqeFcBl6PlyGnslDDz0Eo9GI8ePHY/78+aiqqsK6deswceJEVw+N00y4DOFZ2Uy2nDt3jnr16kUGg6FDRmd3BrgMPR8uQ8+lurqaunXrRoIgkF6vp7///e+uHhKnhXAZMjzWzQSw6ovTp0/HE088AW9vb1cPh9MKuAw9Hy5Dz8XLywsJCQmYMGECVq5cCS8vL1cPidNCuAwZHcLNxOFwOJzWYTKZXF6Wn3N9cBlyZYbD4XA4HI6H4zHtDDgcDofD4XAcwZUZDofD4XA4Hg1XZjgcDofD4Xg0XJnhcDgcDofj0XBlhsPhcDgcjkfDlRkOh8PhcDgeDVdmOByOW/LNN99AEASUlJS4eigcDsfN4XVmOByOWzB69Gj069cPq1atAsC6/hYVFSE8PByCILh2cBwOx63x6HYGHA6n46LT6RAREeHqYXA4HA+Au5k4HI7LmTdvHr799lu8+uqrEAQBgiDggw8+sHIzffDBBwgICMDnn3+O7t27w2AwYMaMGaisrMTatWuRkJCAwMBALFmyBCaTST53XV0dHn/8cURHR8NoNGLw4MH45ptvXHOhHA6nTeCWGQ6H43JeffVVnD17Fr169cJf//pXAMCJEyfsjquqqsK//vUvfPTRRygvL8e0adMwbdo0BAQEYPv27bhw4QKmT5+OESNGYPbs2QCAe++9FxkZGfjoo48QFRWFrVu3YtKkSTh+/DiSkpLa9To5HE7bwJUZDofjcvz9/aHT6WAwGGTX0unTp+2Oq6+vx5o1a9C1a1cAwIwZM7Bu3Trk5ubCx8cHPXr0wJgxY7Bnzx7Mnj0b58+fx8aNG5GZmYmoqCgAwGOPPYadO3fi/fffx/PPP99+F8nhcNoMrsxwOByPwWAwyIoMAISHhyMhIQE+Pj5Wr+Xl5QEAfv75ZxARkpOTrc5TW1uL4ODg9hk0h8Npc7gyw+FwPAatVmv1XBAEh6+ZzWYAgNlshlqtxuHDh6FWq62OUypAHA7Hs+HKDIfDcQt0Op1V4K4z6N+/P0wmE/Ly8jBy5EinnpvD4bgPPJuJw+G4BQkJCdi/fz8yMjJQUFAgW1euh+TkZMydOxd33303tmzZgosXL+LgwYN48cUXsX37dieMmsPhuANcmeFwOG7BY489BrVajR49eiA0NBSXL192ynnff/993H333Vi6dCm6d++OW2+9Ffv370dsbKxTzs/hcFwPrwDM4XA4HA7Ho+GWGQ6Hw+FwOB4NV2Y4HA6Hw+F4NFyZ4XA4HA6H49FwZYbD4XA4HI5Hw5UZDofD4XA4Hg1XZjgcDofD4Xg0XJnhcDgcDofj0XBlhsPhcDgcjkfDlRkOh8PhcDgeDVdmOBwOh8PheDRcmeFwOBwOh+PR/H/DxhzNDCpRcwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model_output.plot()\n", + "ds_forcing[\"Q\"].plot(label=\"Observed discharge\")\n", + "plt.legend()\n", + "plt.ylabel(\"Discharge (mm/d)\")" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "b543aa67-dde1-4c50-b6ac-657c75eecf77", + "metadata": {}, + "outputs": [], + "source": [ + "#we want to also be able to use the output of this model run in different analyses. Therefore we save it as a NetCDF file\n", + "xr_model_output = model_output.to_xarray()\n", + "\n", + "xr_model_output.attrs['units'] = 'mm/d'\n", + "\n", + "# Save the xarray Dataset to a NetCDF file\n", + "xr_model_output.to_netcdf('~/river_discharge_data.nc')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ae07a4c6-c769-4483-a3b1-1a4775393ad2", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/book/tutorials_examples/2_HBV_PCRGlobWB_ERA5/example_model_run_pcrglobwb.ipynb b/book/tutorials_examples/2_HBV_PCRGlobWB_ERA5/example_model_run_pcrglobwb.ipynb new file mode 100644 index 0000000..850cd07 --- /dev/null +++ b/book/tutorials_examples/2_HBV_PCRGlobWB_ERA5/example_model_run_pcrglobwb.ipynb @@ -0,0 +1,1318 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e5442182", + "metadata": {}, + "source": [ + "![ewatercycle logo](https://raw.githubusercontent.com/eWaterCycle/ewatercycle/main/docs/examples/logo.png)\n", + "\n", + "# PCRGlobWB example use case\n", + "\n", + "This example shows how the [PCRGlobWB model](https://globalhydrology.nl/research/models/pcr-globwb-2-0/) can be used within the eWaterCycle system. It is assumed you have already seen [this tutorial notebook](../../example_model_run_HBV.ipynb) explaining how to run the simple HBV model for the River Leven at Newby Bridge. \n", + "\n", + "The PCRGlobWB model is an example of a distributed model where fluxes and stores in the balance are calculated for grid cells (often also called pixels). This requires both the forcing data as well as any parameters to also be spatially distributed. Depending on the complexity of the model, these datasets can be quite large in memory size.\n", + "\n", + "Here we will be running PCRGLobWB for Great Brittain and will extract discharge data at the location of the River Leven again, to compare with the HBV model run. We will also demonstrate how to interact with the state of the model, during runtime, showcasing the benefit of using the BMI interface when building experiments using models." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "424992ea", + "metadata": {}, + "outputs": [], + "source": [ + "# This cell is only used to suppress some distracting output messages\n", + "import warnings\n", + "\n", + "warnings.filterwarnings(\"ignore\", category=UserWarning)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cec50ce3", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "from cartopy import crs\n", + "from cartopy import feature as cfeature\n", + "import fiona\n", + "import shapely.geometry\n", + "from pyproj import Geod\n", + "#from rich import print\n", + "import pandas as pd\n", + "import xarray as xr\n", + "\n", + "import ewatercycle.forcing\n", + "import ewatercycle.models\n", + "import ewatercycle.parameter_sets" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3f186494-1f05-445d-8663-306591c87320", + "metadata": {}, + "outputs": [], + "source": [ + "station_latitude = 54.26935849558577 #Newby Bridge location from Google Maps\n", + "station_longitude = -2.9710855713537745 " + ] + }, + { + "cell_type": "markdown", + "id": "194f357f", + "metadata": {}, + "source": [ + "## Loading a parameter set" + ] + }, + { + "cell_type": "markdown", + "id": "1cdf38a2", + "metadata": {}, + "source": [ + "For this example we have prepared and hosted a global parameter set made by Utrecht University. For each model run, what needs to be specified to deliniate the region of interest is a \"clone map\". The config file has many options, one of which is the location of this clone map.\n", + "\n", + "Note that this is very specific to PCRGlobWB. For complex (and legacy) models like PCRGlobWB one needs to know quite detailed information about the model before being able to run it. However, using eWaterCycle does reduce the time for seting up the model and getting it to run." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "90f4e3ba", + "metadata": {}, + "outputs": [], + "source": [ + "parameter_set = ewatercycle.parameter_sets.ParameterSet(\n", + " name=\"custom_parameter_set\",\n", + " directory=\"/home/shared/pcrglobwb_global\",\n", + " config=\"./pcrglobwb_uk_05min.ini\",\n", + " target_model=\"pcrglobwb\",\n", + " supported_model_versions={\"setters\"},\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "fbabe50c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter set\n", + "-------------\n", + "name=custom_parameter_set\n", + "directory=/home/shared/pcrglobwb_global\n", + "config=pcrglobwb_uk_05min.ini\n", + "doi=N/A\n", + "target_model=pcrglobwb\n", + "supported_model_versions={'setters'}\n", + "downloader=None\n" + ] + } + ], + "source": [ + "print(parameter_set)" + ] + }, + { + "cell_type": "markdown", + "id": "1271ae04", + "metadata": {}, + "source": [ + "## Load forcing data\n", + "\n", + "For this example case, the forcing is generated in [this seperate notebook](generate_forcing.ipynb). This is a common practice when generating forcing takes considerable (CPU, memory, disk) resources. \n", + "\n", + "In the cell below, we load the pre-generated forcing. Note that in contrast with HBV, PCRGlobWB only needs temperature and precipitation as forcing inputs. HBV also needs potential evaporation. PCRGlobWB calculated potential and actual evaporation as part of its update step." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "870c4af6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "start_time='1997-08-01T00:00:00Z' end_time='2000-08-31T00:00:00Z' directory=PosixPath('/home/rhut/forcing/UK/work/diagnostic/script') shape=PosixPath('/home/rhut/forcing/UK/work/diagnostic/script/camelsgb_73010.shp') filenames={} precipitationNC='pcrglobwb_OBS6_ERA5_reanaly_1_day_pr_1997-2000_camelsgb_73010.nc' temperatureNC='pcrglobwb_OBS6_ERA5_reanaly_1_day_tas_1997-2000_camelsgb_73010.nc'\n" + ] + } + ], + "source": [ + "forcing = ewatercycle.forcing.sources[\"PCRGlobWBForcing\"].load(\n", + " directory=\"/home/rhut/forcing/UK/work/diagnostic/script\",\n", + ")\n", + "print(forcing)" + ] + }, + { + "cell_type": "markdown", + "id": "d5b82a92", + "metadata": {}, + "source": [ + "## Setting up the model\n", + "\n", + "Note that the model version and the parameterset versions should be compatible." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "08a4ed9e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "parameter_set=ParameterSet(name='custom_parameter_set', directory=PosixPath('/home/shared/pcrglobwb_global'), config=PosixPath('pcrglobwb_uk_05min.ini'), doi='N/A', target_model='pcrglobwb', supported_model_versions={'setters'}, downloader=None) forcing=PCRGlobWBForcing(start_time='1997-08-01T00:00:00Z', end_time='2000-08-31T00:00:00Z', directory=PosixPath('/home/rhut/forcing/UK/work/diagnostic/script'), shape=PosixPath('/home/rhut/forcing/UK/work/diagnostic/script/camelsgb_73010.shp'), filenames={}, precipitationNC='pcrglobwb_OBS6_ERA5_reanaly_1_day_pr_1997-2000_camelsgb_73010.nc', temperatureNC='pcrglobwb_OBS6_ERA5_reanaly_1_day_tas_1997-2000_camelsgb_73010.nc')\n" + ] + } + ], + "source": [ + "pcrglob = ewatercycle.models.PCRGlobWB(\n", + " parameter_set=parameter_set,\n", + " forcing=forcing\n", + ")\n", + "print(pcrglob)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a45eba5c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'setters'" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pcrglob.version" + ] + }, + { + "cell_type": "markdown", + "id": "a69e1212", + "metadata": {}, + "source": [ + "eWaterCycle exposes a selected set of configurable parameters. These can be modified in the `setup()` method." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "4a62965a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_items([('start_time', '1997-08-01T00:00:00Z'), ('end_time', '1997-08-01T00:00:00Z'), ('routing_method', 'accuTravelTime'), ('max_spinups_in_years', '0')])\n" + ] + } + ], + "source": [ + "print(pcrglob.parameters)" + ] + }, + { + "cell_type": "markdown", + "id": "2a27869b", + "metadata": {}, + "source": [ + "Calling `setup()` will start up the model container. Be careful with calling it multiple times!" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "cc852425", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "('/home/rhut/repos/eurocsdms_workshop/book/oneModel/additional/pcrglobwb/pcrglobwb_20241029_183731/pcrglobwb_ewatercycle.ini',\n", + " '/home/rhut/repos/eurocsdms_workshop/book/oneModel/additional/pcrglobwb/pcrglobwb_20241029_183731')" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cfg_file, cfg_dir = pcrglob.setup(\n", + " end_time=\"2000-08-31T00:00:00Z\",\n", + " max_spinups_in_years=0\n", + ")\n", + "cfg_file, cfg_dir" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "4456b5e2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_items([('start_time', '1997-08-01T00:00:00Z'), ('end_time', '2000-08-31T00:00:00Z'), ('routing_method', 'accuTravelTime'), ('max_spinups_in_years', '0')])\n" + ] + } + ], + "source": [ + "print(pcrglob.parameters)" + ] + }, + { + "cell_type": "markdown", + "id": "0480d34c", + "metadata": {}, + "source": [ + "Note that the parameters have been changed. A new config file which incorporates these updated parameters has been generated as well. If you want to see or modify any additional model settings, you can acces this file directly. When you're ready, pass the path to the config file to `initialize()`." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "87144041", + "metadata": {}, + "outputs": [], + "source": [ + "pcrglob.initialize(cfg_file)" + ] + }, + { + "cell_type": "markdown", + "id": "f16e18c7-88b1-4019-9281-44a4a51d21d0", + "metadata": {}, + "source": [ + "We prepare a small dataframe where we can store the discharge output from the model" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "664b32b6-2b4c-49f1-be5a-b451fceb9ecc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PCRGlobWB: Leven
time
1997-08-01 00:00:00+00:00NaN
1997-08-02 00:00:00+00:00NaN
1997-08-03 00:00:00+00:00NaN
1997-08-04 00:00:00+00:00NaN
1997-08-05 00:00:00+00:00NaN
\n", + "
" + ], + "text/plain": [ + " PCRGlobWB: Leven\n", + "time \n", + "1997-08-01 00:00:00+00:00 NaN\n", + "1997-08-02 00:00:00+00:00 NaN\n", + "1997-08-03 00:00:00+00:00 NaN\n", + "1997-08-04 00:00:00+00:00 NaN\n", + "1997-08-05 00:00:00+00:00 NaN" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "time = pd.date_range(pcrglob.start_time_as_isostr, pcrglob.end_time_as_isostr)\n", + "timeseries = pd.DataFrame(\n", + " index=pd.Index(time, name=\"time\"), columns=[\"PCRGlobWB: Leven\"]\n", + ")\n", + "timeseries.head()" + ] + }, + { + "cell_type": "markdown", + "id": "f0f4987f", + "metadata": {}, + "source": [ + "## Running the model\n", + "\n", + "Simply running the model from start to end is straightforward. At each time step we can retrieve information from the model." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "403d55e6", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2000-08-31T00:00:00Z\r" + ] + } + ], + "source": [ + "while pcrglob.time < pcrglob.end_time:\n", + " pcrglob.update()\n", + "\n", + " # Track discharge at station location\n", + " discharge_at_station = pcrglob.get_value_at_coords(\n", + " \"discharge\", lat=[station_latitude], lon=[station_longitude]\n", + " )\n", + " time = pcrglob.time_as_isostr\n", + " timeseries[\"PCRGlobWB: Leven\"][time] = discharge_at_station[0]\n", + "\n", + " # Show progress\n", + " print(time,end='\\r') # \"\\r\" clears the output before printing the next timestamp\n" + ] + }, + { + "cell_type": "markdown", + "id": "53a937e8", + "metadata": {}, + "source": [ + "## Interacting with the model" + ] + }, + { + "cell_type": "markdown", + "id": "3ce583fa", + "metadata": {}, + "source": [ + "PCRGlobWB exposes many variables. Just a few of them are shown here:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "23d55863", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['upper_soil_transpiration',\n", + " 'snow_water_equivalent',\n", + " 'total_runoff',\n", + " 'transpiration_from_irrigation',\n", + " 'fraction_of_surface_water',\n", + " 'bottom_elevation_of_uppermost_layer',\n", + " 'industry_water_withdrawal',\n", + " 'relativeGroundwaterHead',\n", + " 'total_fraction_water_allocation',\n", + " 'groundwater_volume_estimate']" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list(pcrglob.output_var_names)[-15:-5]" + ] + }, + { + "cell_type": "markdown", + "id": "bc3037d6", + "metadata": {}, + "source": [ + "Model fields can be fetched as xarray objects (or as flat numpy arrays using `get_value()`):" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "b37943a9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray (longitude: 29, latitude: 22)> Size: 5kB\n",
+       "array([[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
+       "        0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
+       "        0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 1.36099541e+00,\n",
+       "        1.14954865e+00, 1.63362265e+00, 5.81284702e-01, 1.03070605e+00,\n",
+       "        7.93194473e-01, 1.05944443e+00, 1.03646994e+00, 5.14641225e-01,\n",
+       "        5.14155090e-01, 1.09502316e-01],\n",
+       "       [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
+       "        0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
+       "        1.22899306e+00, 0.00000000e+00, 9.28414345e-01, 1.26675928e+00,\n",
+       "        0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 1.72627318e+00,\n",
+       "        5.43769693e+00, 4.03241968e+00, 1.58971059e+00, 1.55043983e+00,\n",
+       "        1.14820147e+00, 6.18921757e-01],\n",
+       "       [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
+       "        0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
+       "        0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
+       "        0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
+       "        2.72685178e-02, 9.35214138e+00, 3.50451380e-01, 1.46504626e-01,\n",
+       "        8.38614559e+00, 2.71886587e-01],\n",
+       "       [0.00000000e+00, 0.00000000e+00, 6.52777791e-01, 0.00000000e+00,\n",
+       "        0.00000000e+00, 1.04513891e-01, 0.00000000e+00, 0.00000000e+00,\n",
+       "...\n",
+       "        0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
+       "        0.00000000e+00, 0.00000000e+00],\n",
+       "       [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
+       "        0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
+       "        0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
+       "        0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
+       "        0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
+       "        0.00000000e+00, 0.00000000e+00],\n",
+       "       [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
+       "        0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
+       "        0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
+       "        0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
+       "        0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
+       "        0.00000000e+00, 0.00000000e+00],\n",
+       "       [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
+       "        0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
+       "        0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
+       "        1.59323442e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
+       "        0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
+       "        0.00000000e+00, 0.00000000e+00]])\n",
+       "Coordinates:\n",
+       "  * latitude   (latitude) float64 176B -5.958 -5.542 -5.125 ... 2.375 2.792\n",
+       "  * longitude  (longitude) float64 232B 49.04 49.46 49.88 ... 59.88 60.29 60.71
" + ], + "text/plain": [ + " Size: 5kB\n", + "array([[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 1.36099541e+00,\n", + " 1.14954865e+00, 1.63362265e+00, 5.81284702e-01, 1.03070605e+00,\n", + " 7.93194473e-01, 1.05944443e+00, 1.03646994e+00, 5.14641225e-01,\n", + " 5.14155090e-01, 1.09502316e-01],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 1.22899306e+00, 0.00000000e+00, 9.28414345e-01, 1.26675928e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 1.72627318e+00,\n", + " 5.43769693e+00, 4.03241968e+00, 1.58971059e+00, 1.55043983e+00,\n", + " 1.14820147e+00, 6.18921757e-01],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 2.72685178e-02, 9.35214138e+00, 3.50451380e-01, 1.46504626e-01,\n", + " 8.38614559e+00, 2.71886587e-01],\n", + " [0.00000000e+00, 0.00000000e+00, 6.52777791e-01, 0.00000000e+00,\n", + " 0.00000000e+00, 1.04513891e-01, 0.00000000e+00, 0.00000000e+00,\n", + "...\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 1.59323442e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00]])\n", + "Coordinates:\n", + " * latitude (latitude) float64 176B -5.958 -5.542 -5.125 ... 2.375 2.792\n", + " * longitude (longitude) float64 232B 49.04 49.46 49.88 ... 59.88 60.29 60.71" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "da = pcrglob.get_value_as_xarray(\"discharge\")\n", + "da.thin(5) # only show every 5th value in each dim" + ] + }, + { + "cell_type": "markdown", + "id": "b68de73f", + "metadata": {}, + "source": [ + "Xarray makes it very easy to plot the data. In the figure below, we add a cross at the location where we collected the discharge every timestep: Leven at Newby bridge." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "f30ab9b3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(dpi=120)\n", + "ax = fig.add_subplot(111, projection=crs.PlateCarree())\n", + "da.plot(ax=ax, cmap=\"GnBu\")\n", + "\n", + "# Overlay ocean and coastines\n", + "ax.add_feature(cfeature.OCEAN)\n", + "ax.add_feature(cfeature.RIVERS, color=\"k\")\n", + "ax.coastlines()\n", + "\n", + "# Add a red cross marker at the location of the Leven River at Newby Bridge\n", + "ax.scatter(station_longitude, station_latitude, s=250, c=\"r\", marker=\"x\", lw=2)" + ] + }, + { + "cell_type": "markdown", + "id": "418c4d74", + "metadata": {}, + "source": [ + "We can get (or set) the values at custom points as well:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "eb8a054b-44dc-4bdc-8179-c3796af26c2e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#extra\n", + "timeseries.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "e68ed4a2-82c9-482c-a51b-8973cd009091", + "metadata": {}, + "source": [ + "We of course want to compare this both to observations as well as to the result of the HBV model.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "f62de858-940c-46d2-b5ac-5b5268609911", + "metadata": {}, + "outputs": [], + "source": [ + "prepared_forcing_path_caravan_central = \"/data/eurocsdms-data/forcing/camelsgb_73010/caravan\"\n", + "camelsgb_forcing = ewatercycle.forcing.sources['CaravanForcing'].load(directory=prepared_forcing_path_caravan_central)\n", + "xr_camelsgb_forcing = xr.open_dataset(camelsgb_forcing['Q'])\n", + "xr_hbv_model_output = xr.open_dataset('~/river_discharge_data.nc')" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "05522b52-eb4a-458e-a44d-cda10229e0be", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "timeseries.plot()\n", + "xr_camelsgb_forcing[\"Q\"].plot(label=\"Observed discharge\")\n", + "xr_hbv_model_output['Modelled_discharge'].plot(label=\"modelled discharge HBV\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "id": "f66f7632-eed1-4a5d-8852-6f2f0bad8b42", + "metadata": {}, + "source": [ + "## HUH???\n", + "Oh, wait...\n", + "\n", + "PCRGlobWB reports in m3/s and HBV and the observation are in mm/day. So we need to multiply the HBV and observational data with the area of the catchment, devide by 1000 (to get to meters) and devide by 86400 to get from days to seconds." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "cc90867c-f285-4cbf-9ff3-2740ef5d8b27", + "metadata": {}, + "outputs": [], + "source": [ + "# flux_out_Q unit conversion factor from mm/day to m3/s\n", + "conversion_mmday2m3s = 1 / (1000 * 86400)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "94d8006d-a55e-4b10-bc4d-2041e58abff7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "248130958.76862004\n" + ] + } + ], + "source": [ + "shape = fiona.open(camelsgb_forcing.shape)\n", + "poly = [shapely.geometry.shape(p[\"geometry\"]) for p in shape][0]\n", + "geod = Geod(ellps=\"WGS84\")\n", + "poly_area, poly_perimeter = geod.geometry_area_perimeter(poly)\n", + "catchment_area_m2 = abs(poly_area)\n", + "print(catchment_area_m2)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "c2758841-e8c3-498f-9117-9f53f729179d", + "metadata": {}, + "outputs": [], + "source": [ + "xr_camelsgb_forcing[\"Q\"] = xr_camelsgb_forcing[\"Q\"] * conversion_mmday2m3s * catchment_area_m2\n", + "xr_hbv_model_output['Modelled_discharge'] = xr_hbv_model_output['Modelled_discharge']* conversion_mmday2m3s * catchment_area_m2" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "e8d6990b-344d-46c3-bd46-eeec8adcd0d2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "timeseries.plot()\n", + "xr_camelsgb_forcing[\"Q\"].plot(label=\"Observed discharge\")\n", + "xr_hbv_model_output['Modelled_discharge'].plot(label=\"modelled discharge HBV\")\n", + "plt.legend()\n" + ] + }, + { + "cell_type": "markdown", + "id": "88a81111-8def-4196-aad0-35b1ea3a1a06", + "metadata": {}, + "source": [ + "Still doesn't look to good for PCRGlobWB. This is because for this small area we are only looking at 10-ish pixels and most likely there is a big mismatch between the pixels that drain through the outlet in PCRGlobWB and the actual catchment. Please ask Rolf for details" + ] + }, + { + "cell_type": "markdown", + "id": "c3479c71", + "metadata": {}, + "source": [ + "## Cleaning up\n", + "\n", + "Models usually perform some \"wrap up tasks\" at the end of a model run, such as writing the last outputs to disk and releasing memory. In the case of eWaterCycle, another important teardown task is destroying the container in which the model was running. This can free up a lot of resources on your system. Therefore it is good practice to always call `finalize()` when you're done with an experiment." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "b5846be2", + "metadata": {}, + "outputs": [], + "source": [ + "pcrglob.finalize()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/book/tutorials_examples/2_HBV_PCRGlobWB_ERA5/generate_clonemaps.ipynb b/book/tutorials_examples/2_HBV_PCRGlobWB_ERA5/generate_clonemaps.ipynb new file mode 100644 index 0000000..d27cd58 --- /dev/null +++ b/book/tutorials_examples/2_HBV_PCRGlobWB_ERA5/generate_clonemaps.ipynb @@ -0,0 +1,115 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "61349563-68d3-4695-8c2c-24653662dffa", + "metadata": {}, + "outputs": [], + "source": [ + "import subprocess" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8f76339f-9809-4ff5-863c-1d274993001a", + "metadata": {}, + "outputs": [], + "source": [ + "# Catchment bounding boxes\n", + "clonemap_extents = {\n", + " \"UK\": {\"latitude\": (49, 61), \"longitude\": (-6, 22.5)},\n", + " \"Great_Kei\": {\"latitude\": (-34.5, -30.0), \"longitude\": (24.0, 30.0)},\n", + " \"Merrimack\": {\"latitude\": (40.5, 45.0), \"longitude\": (-73.5, -69.0)},\n", + " \"Meuse\": {\"latitude\": (46.5, 52.5), \"longitude\": (1.5, 7.5)},\n", + " \"Rhine\": {\"latitude\": (45.0, 54.0), \"longitude\": (3.0, 13.5)},\n", + " \"Savannah\": {\"latitude\": (30.0, 36), \"longitude\": (-85.5, -79.5)},\n", + "}\n", + "\n", + "# Set the extent of the forcing data suffiently larger than the clonemap.\n", + "esmvaltool_padding = 1.5 # degrees lat/lon" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "db657bd7", + "metadata": {}, + "outputs": [], + "source": [ + "def create_clonemap(lonmin, latmin, lonmax, latmax, forcing_resolution, catchment):\n", + " \"\"\"Create new clonemap compatible with forcing data resolution.\"\"\"\n", + " dlon = lonmax - lonmin\n", + " dlat = latmax - latmin\n", + "\n", + " msg = (\n", + " \"The clonemap extent divided by the forcing resolution must yield\"\n", + " \"an integer number of grid cells.\"\n", + " )\n", + " assert dlon % forcing_resolution == 0, f\"Longitudes not compatible. {msg}\"\n", + " assert dlat % forcing_resolution == 0, f\"Latitudes not compatible. {msg}\"\n", + "\n", + " clonemap_dir = (\n", + " \"/data/shared/parameter-sets/pcrglobwb_global/global_05min/cloneMaps\"\n", + " )\n", + " globalclonemap = clonemap_dir + \"/clone_global_05min.map\"\n", + " outputclonemap = f\"./{catchment.lower()}_05min.map\" # copy to clonemap dir after ensuring it is correct\n", + "\n", + " subprocess.call(\n", + " f\"gdal_translate -of PCRaster {globalclonemap} -projwin \"\n", + " f\"{lonmin} {latmax} {lonmax} {latmin} {outputclonemap}\",\n", + " shell=True,\n", + " )\n", + " return outputclonemap" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3afb9c1d-cecc-4e54-967f-40d16f85af5f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Input file size is 4320, 2160\n", + "0...10...20...30...40...50...60...70...80...90...100 - done.\n", + "./uk_05min.map\n" + ] + } + ], + "source": [ + "forcing_resolution = 0.75\n", + "for (catchment, extents) in clonemap_extents.items():\n", + " latmin, latmax = extents[\"latitude\"]\n", + " lonmin, lonmax = extents[\"longitude\"]\n", + " print(\n", + " create_clonemap(lonmin, latmin, lonmax, latmax, forcing_resolution, catchment)\n", + " )" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/book/tutorials_examples/2_HBV_PCRGlobWB_ERA5/generate_forcing.ipynb b/book/tutorials_examples/2_HBV_PCRGlobWB_ERA5/generate_forcing.ipynb new file mode 100644 index 0000000..02e4466 --- /dev/null +++ b/book/tutorials_examples/2_HBV_PCRGlobWB_ERA5/generate_forcing.ipynb @@ -0,0 +1,322 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Generate forcing in eWaterCycle with ESMValTool\n", + "\n", + "This notebooks shows how to generate forcing data for PCR-GLOBWB model using ERA5 data and [ESMValTool hydrological recipes](https://docs.esmvaltool.org/en/latest/recipes/recipe_hydrology.html#pcr-globwb). More information about data, configuration and installation instructions can be found in the [System setup](https://ewatercycle.readthedocs.io/en/latest/system_setup.html) in the eWaterCycle documentation." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import logging\n", + "import warnings\n", + "from pathlib import Path\n", + "warnings.filterwarnings(\"ignore\", category=UserWarning)\n", + "\n", + "logger = logging.getLogger(\"esmvalcore\")\n", + "logger.setLevel(logging.WARNING)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import xarray as xr\n", + "from rich import print\n", + "\n", + "import ewatercycle.forcing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Forcing for PCRGlobWB is created using the ESMValTool recipe. It produces one file per each variable: temperature, and precipitation. You can set the start and end date, and the region. See [eWaterCycle documentation](https://ewatercycle.readthedocs.io/en/latest/apidocs/ewatercycle.forcing.html#submodules) for more information. \n", + "\n", + "#### Bug:\n", + "A shape file needs to be provided to delineate the area of interest. However, the forcing generated in this way will fill a bounding box that is \"tight\" around the shapefile. PCRGlobWB needs forcing files to be (slightly) larger than the extend of the clonemap. We fix this with \"esmavaltool_padding below. Furhtermore, the number of pixels in the lat and lon directions need to be even for the interpolation algorithm that converts forcing data to the grid of the model. Therefore, we use the extract region and hard-code the extend of Great Brittain." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "prepared_forcing_path_caravan_central = Path(\"/data/eurocsdms-data/forcing/camelsgb_73010/caravan\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# option two: load data that you or someone else generated previously\n", + "camelsgb_forcing = ewatercycle.forcing.sources['CaravanForcing'].load(directory=prepared_forcing_path_caravan_central)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "esmvaltool_padding = 1.5\n", + "\n", + "pcrglobwb_forcing = ewatercycle.forcing.sources[\"PCRGlobWBForcing\"].generate(\n", + " dataset=\"ERA5\",\n", + " start_time=\"1997-08-01T00:00:00Z\",\n", + " end_time=\"2000-08-31T00:00:00Z\",\n", + " start_time_climatology=\"1997-08-01T00:00:00Z\",\n", + " end_time_climatology=\"1998-08-01T00:00:00Z\",\n", + " shape=camelsgb_forcing.shape,\n", + " extract_region={\n", + " \"start_longitude\": -6-esmvaltool_padding,\n", + " \"end_longitude\": 3+esmvaltool_padding,\n", + " \"start_latitude\": 49-esmvaltool_padding,\n", + " \"end_latitude\": 61+esmvaltool_padding,},\n", + " directory = \"/home/rhut/forcing/UK\"\n", + "\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
PCRGlobWBForcing(\n",
+       "    start_time='1997-08-01T00:00:00Z',\n",
+       "    end_time='2000-08-31T00:00:00Z',\n",
+       "    directory=PosixPath('/home/rhut/forcing/UK/work/diagnostic/script'),\n",
+       "    shape=PosixPath('/data/eurocsdms-data/forcing/camelsgb_73010/caravan/camelsgb_73010.shp'),\n",
+       "    filenames={},\n",
+       "    precipitationNC='pcrglobwb_OBS6_ERA5_reanaly_1_day_pr_1997-2000_camelsgb_73010.nc',\n",
+       "    temperatureNC='pcrglobwb_OBS6_ERA5_reanaly_1_day_tas_1997-2000_camelsgb_73010.nc'\n",
+       ")\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1;35mPCRGlobWBForcing\u001b[0m\u001b[1m(\u001b[0m\n", + " \u001b[33mstart_time\u001b[0m=\u001b[32m'1997-08-01T00:00:00Z'\u001b[0m,\n", + " \u001b[33mend_time\u001b[0m=\u001b[32m'2000-08-31T00:00:00Z'\u001b[0m,\n", + " \u001b[33mdirectory\u001b[0m=\u001b[1;35mPosixPath\u001b[0m\u001b[1m(\u001b[0m\u001b[32m'/home/rhut/forcing/UK/work/diagnostic/script'\u001b[0m\u001b[1m)\u001b[0m,\n", + " \u001b[33mshape\u001b[0m=\u001b[1;35mPosixPath\u001b[0m\u001b[1m(\u001b[0m\u001b[32m'/data/eurocsdms-data/forcing/camelsgb_73010/caravan/camelsgb_73010.shp'\u001b[0m\u001b[1m)\u001b[0m,\n", + " \u001b[33mfilenames\u001b[0m=\u001b[1m{\u001b[0m\u001b[1m}\u001b[0m,\n", + " \u001b[33mprecipitationNC\u001b[0m=\u001b[32m'pcrglobwb_OBS6_ERA5_reanaly_1_day_pr_1997-2000_camelsgb_73010.nc'\u001b[0m,\n", + " \u001b[33mtemperatureNC\u001b[0m=\u001b[32m'pcrglobwb_OBS6_ERA5_reanaly_1_day_tas_1997-2000_camelsgb_73010.nc'\u001b[0m\n", + "\u001b[1m)\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(pcrglobwb_forcing)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot forcing" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
<xarray.Dataset> Size: 22MB\n",
+       "Dimensions:    (time: 1826, lat: 61, lon: 49, bnds: 2)\n",
+       "Coordinates:\n",
+       "  * time       (time) datetime64[ns] 15kB 1996-01-02 1996-01-03 ... 2000-12-31\n",
+       "  * lat        (lat) float32 244B 62.5 62.25 62.0 61.75 ... 48.0 47.75 47.5\n",
+       "  * lon        (lon) float32 196B -7.499 -7.249 -6.999 ... 4.001 4.251 4.501\n",
+       "    height     float64 8B 2.0\n",
+       "Dimensions without coordinates: bnds\n",
+       "Data variables:\n",
+       "    tas        (time, lat, lon) float32 22MB 279.2 279.1 279.0 ... 272.8 272.7\n",
+       "    time_bnds  (time, bnds) datetime64[ns] 29kB 1996-01-01T12:00:00 ... 2000-...\n",
+       "    lat_bnds   (lat, bnds) float32 488B 62.62 62.38 62.38 ... 47.62 47.62 47.38\n",
+       "    lon_bnds   (lon, bnds) float32 392B -7.625 -7.375 -7.375 ... 4.375 4.625\n",
+       "Attributes:\n",
+       "    Conventions:  CF-1.7\n",
+       "    software:     Created with ESMValTool v2.11.0\n",
+       "    caption:      Forcings for the PCR-GLOBWB hydrological model.\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m<\u001b[0m\u001b[1;95mxarray.Dataset\u001b[0m\u001b[1m>\u001b[0m Size: 22MB\n", + "Dimensions: \u001b[1m(\u001b[0mtime: \u001b[1;36m1826\u001b[0m, lat: \u001b[1;36m61\u001b[0m, lon: \u001b[1;36m49\u001b[0m, bnds: \u001b[1;36m2\u001b[0m\u001b[1m)\u001b[0m\n", + "Coordinates:\n", + " * time \u001b[1m(\u001b[0mtime\u001b[1m)\u001b[0m datetime64\u001b[1m[\u001b[0mns\u001b[1m]\u001b[0m 15kB \u001b[1;36m1996\u001b[0m-\u001b[1;36m01\u001b[0m-\u001b[1;36m02\u001b[0m \u001b[1;36m1996\u001b[0m-\u001b[1;36m01\u001b[0m-\u001b[1;36m03\u001b[0m \u001b[33m...\u001b[0m \u001b[1;36m2000\u001b[0m-\u001b[1;36m12\u001b[0m-\u001b[1;36m31\u001b[0m\n", + " * lat \u001b[1m(\u001b[0mlat\u001b[1m)\u001b[0m float32 244B \u001b[1;36m62.5\u001b[0m \u001b[1;36m62.25\u001b[0m \u001b[1;36m62.0\u001b[0m \u001b[1;36m61.75\u001b[0m \u001b[33m...\u001b[0m \u001b[1;36m48.0\u001b[0m \u001b[1;36m47.75\u001b[0m \u001b[1;36m47.5\u001b[0m\n", + " * lon \u001b[1m(\u001b[0mlon\u001b[1m)\u001b[0m float32 196B \u001b[1;36m-7.499\u001b[0m \u001b[1;36m-7.249\u001b[0m \u001b[1;36m-6.999\u001b[0m \u001b[33m...\u001b[0m \u001b[1;36m4.001\u001b[0m \u001b[1;36m4.251\u001b[0m \u001b[1;36m4.501\u001b[0m\n", + " height float64 8B \u001b[1;36m2.0\u001b[0m\n", + "Dimensions without coordinates: bnds\n", + "Data variables:\n", + " tas \u001b[1m(\u001b[0mtime, lat, lon\u001b[1m)\u001b[0m float32 22MB \u001b[1;36m279.2\u001b[0m \u001b[1;36m279.1\u001b[0m \u001b[1;36m279.0\u001b[0m \u001b[33m...\u001b[0m \u001b[1;36m272.8\u001b[0m \u001b[1;36m272.7\u001b[0m\n", + " time_bnds \u001b[1m(\u001b[0mtime, bnds\u001b[1m)\u001b[0m datetime64\u001b[1m[\u001b[0mns\u001b[1m]\u001b[0m 29kB \u001b[1;36m1996\u001b[0m-\u001b[1;36m01\u001b[0m-01T\u001b[1;92m12:00:00\u001b[0m \u001b[33m...\u001b[0m \u001b[1;36m2000\u001b[0m-\u001b[33m...\u001b[0m\n", + " lat_bnds \u001b[1m(\u001b[0mlat, bnds\u001b[1m)\u001b[0m float32 488B \u001b[1;36m62.62\u001b[0m \u001b[1;36m62.38\u001b[0m \u001b[1;36m62.38\u001b[0m \u001b[33m...\u001b[0m \u001b[1;36m47.62\u001b[0m \u001b[1;36m47.62\u001b[0m \u001b[1;36m47.38\u001b[0m\n", + " lon_bnds \u001b[1m(\u001b[0mlon, bnds\u001b[1m)\u001b[0m float32 392B \u001b[1;36m-7.625\u001b[0m \u001b[1;36m-7.375\u001b[0m \u001b[1;36m-7.375\u001b[0m \u001b[33m...\u001b[0m \u001b[1;36m4.375\u001b[0m \u001b[1;36m4.625\u001b[0m\n", + "Attributes:\n", + " Conventions: CF-\u001b[1;36m1.7\u001b[0m\n", + " software: Created with ESMValTool v2.\u001b[1;36m11.0\u001b[0m\n", + " caption: Forcings for the PCR-GLOBWB hydrological model.\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
------------------------\n",
+       "
\n" + ], + "text/plain": [ + "------------------------\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
<xarray.Dataset> Size: 22MB\n",
+       "Dimensions:    (time: 1826, lat: 61, lon: 49, bnds: 2)\n",
+       "Coordinates:\n",
+       "  * time       (time) datetime64[ns] 15kB 1996-01-02 1996-01-03 ... 2000-12-31\n",
+       "  * lat        (lat) float32 244B 62.5 62.25 62.0 61.75 ... 48.0 47.75 47.5\n",
+       "  * lon        (lon) float32 196B -7.499 -7.249 -6.999 ... 4.001 4.251 4.501\n",
+       "Dimensions without coordinates: bnds\n",
+       "Data variables:\n",
+       "    pr         (time, lat, lon) float32 22MB 0.006571 0.006238 ... 2.133e-05\n",
+       "    time_bnds  (time, bnds) datetime64[ns] 29kB 1996-01-01T12:00:00 ... 2000-...\n",
+       "    lat_bnds   (lat, bnds) float32 488B 62.62 62.38 62.38 ... 47.62 47.62 47.38\n",
+       "    lon_bnds   (lon, bnds) float32 392B -7.625 -7.375 -7.375 ... 4.375 4.625\n",
+       "Attributes:\n",
+       "    Conventions:  CF-1.7\n",
+       "    software:     Created with ESMValTool v2.11.0\n",
+       "    caption:      Forcings for the PCR-GLOBWB hydrological model.\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m<\u001b[0m\u001b[1;95mxarray.Dataset\u001b[0m\u001b[1m>\u001b[0m Size: 22MB\n", + "Dimensions: \u001b[1m(\u001b[0mtime: \u001b[1;36m1826\u001b[0m, lat: \u001b[1;36m61\u001b[0m, lon: \u001b[1;36m49\u001b[0m, bnds: \u001b[1;36m2\u001b[0m\u001b[1m)\u001b[0m\n", + "Coordinates:\n", + " * time \u001b[1m(\u001b[0mtime\u001b[1m)\u001b[0m datetime64\u001b[1m[\u001b[0mns\u001b[1m]\u001b[0m 15kB \u001b[1;36m1996\u001b[0m-\u001b[1;36m01\u001b[0m-\u001b[1;36m02\u001b[0m \u001b[1;36m1996\u001b[0m-\u001b[1;36m01\u001b[0m-\u001b[1;36m03\u001b[0m \u001b[33m...\u001b[0m \u001b[1;36m2000\u001b[0m-\u001b[1;36m12\u001b[0m-\u001b[1;36m31\u001b[0m\n", + " * lat \u001b[1m(\u001b[0mlat\u001b[1m)\u001b[0m float32 244B \u001b[1;36m62.5\u001b[0m \u001b[1;36m62.25\u001b[0m \u001b[1;36m62.0\u001b[0m \u001b[1;36m61.75\u001b[0m \u001b[33m...\u001b[0m \u001b[1;36m48.0\u001b[0m \u001b[1;36m47.75\u001b[0m \u001b[1;36m47.5\u001b[0m\n", + " * lon \u001b[1m(\u001b[0mlon\u001b[1m)\u001b[0m float32 196B \u001b[1;36m-7.499\u001b[0m \u001b[1;36m-7.249\u001b[0m \u001b[1;36m-6.999\u001b[0m \u001b[33m...\u001b[0m \u001b[1;36m4.001\u001b[0m \u001b[1;36m4.251\u001b[0m \u001b[1;36m4.501\u001b[0m\n", + "Dimensions without coordinates: bnds\n", + "Data variables:\n", + " pr \u001b[1m(\u001b[0mtime, lat, lon\u001b[1m)\u001b[0m float32 22MB \u001b[1;36m0.006571\u001b[0m \u001b[1;36m0.006238\u001b[0m \u001b[33m...\u001b[0m \u001b[1;36m2.133e-05\u001b[0m\n", + " time_bnds \u001b[1m(\u001b[0mtime, bnds\u001b[1m)\u001b[0m datetime64\u001b[1m[\u001b[0mns\u001b[1m]\u001b[0m 29kB \u001b[1;36m1996\u001b[0m-\u001b[1;36m01\u001b[0m-01T\u001b[1;92m12:00:00\u001b[0m \u001b[33m...\u001b[0m \u001b[1;36m2000\u001b[0m-\u001b[33m...\u001b[0m\n", + " lat_bnds \u001b[1m(\u001b[0mlat, bnds\u001b[1m)\u001b[0m float32 488B \u001b[1;36m62.62\u001b[0m \u001b[1;36m62.38\u001b[0m \u001b[1;36m62.38\u001b[0m \u001b[33m...\u001b[0m \u001b[1;36m47.62\u001b[0m \u001b[1;36m47.62\u001b[0m \u001b[1;36m47.38\u001b[0m\n", + " lon_bnds \u001b[1m(\u001b[0mlon, bnds\u001b[1m)\u001b[0m float32 392B \u001b[1;36m-7.625\u001b[0m \u001b[1;36m-7.375\u001b[0m \u001b[1;36m-7.375\u001b[0m \u001b[33m...\u001b[0m \u001b[1;36m4.375\u001b[0m \u001b[1;36m4.625\u001b[0m\n", + "Attributes:\n", + " Conventions: CF-\u001b[1;36m1.7\u001b[0m\n", + " software: Created with ESMValTool v2.\u001b[1;36m11.0\u001b[0m\n", + " caption: Forcings for the PCR-GLOBWB hydrological model.\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
------------------------\n",
+       "
\n" + ], + "text/plain": [ + "------------------------\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for file_name in [pcrglobwb_forcing.temperatureNC, pcrglobwb_forcing.precipitationNC]:\n", + " dataset = xr.load_dataset(f\"{pcrglobwb_forcing.directory}/{file_name}\")\n", + " print(dataset)\n", + " print(\"------------------------\")\n", + " var = list(dataset.data_vars.keys())[0]\n", + " dataset[var].isel(time=-1).plot(cmap=\"coolwarm\", robust=True, size=5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.5" + }, + "metadata": { + "interpreter": { + "hash": "a8aa8210cb3d81d2b5c08b30572e78ad19bd30da92b4caf9890388bc07c5e3bf" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/book/tutorials_examples/2_HBV_PCRGlobWB_ERA5/pcrglobwb_uk_05min.ini b/book/tutorials_examples/2_HBV_PCRGlobWB_ERA5/pcrglobwb_uk_05min.ini new file mode 100644 index 0000000..66700a1 --- /dev/null +++ b/book/tutorials_examples/2_HBV_PCRGlobWB_ERA5/pcrglobwb_uk_05min.ini @@ -0,0 +1,466 @@ +[globalOptions] + +# Set the pcrglobwb output directory in an absolute path. +outputDir = /data/output +# Set the input directory map in an absolute path. +# - The input forcing and parameter directories and files will be relative to this. +inputDir = /data/input + +# Map of clone (must be provided in PCRaster maps) +# - Spatial resolution and coverage are based on this map: +cloneMap = global_05min/cloneMaps/uk_05min.map +# The area/landmask of interest: +# If None, area/landmask is limited for cells with ldd value. +landmask = global_05min/cloneMaps/uk_05min.map + + +# netcdf attributes for output files: +institution = Department of Physical Geography, Utrecht University +title = PCR-GLOBWB 2 output (not coupled to MODFLOW) +description = by Edwin H. Sutanudjaja (contact: e.h.sutanudjaja@uu.nl) + +startTime = 2002-01-01 +endTime = 2002-12-31 +# Format: YYYY-MM-DD ; The model runs on daily time step. + + +# spinning up options: +maxSpinUpsInYears = 0 +minConvForSoilSto = 0.0 +minConvForGwatSto = 0.0 +minConvForChanSto = 0.0 +minConvForTotlSto = 0.0 + + + +[meteoOptions] + +# Set the forcing temperature and precipitation files (relative to inputDir) +precipitationNC = global_05min/meteo/pcrglobwb_OBS6_ERA5_reanaly_1_day_pr_2002-2016_merrimack.nc +temperatureNC = global_05min/meteo/pcrglobwb_OBS6_ERA5_reanaly_1_day_tas_2002-2016_merrimack.nc + +# Method to calculate referencePotETP (reference potential evaporation+transpiration) +# options are "Hamon" and "Input" ; If "Input", the netcdf input file must be given: +referenceETPotMethod = Hamon +refETPotFileNC = 'test' + +# variable names in the forcing files (optional) +precipitationVariableName = pr +temperatureVariableName = tas +referenceEPotVariableName = potentialEvaporation + +# conversion constants and factors to correct forcing values (optional) so that the units are in m.day-1 and degree Celcius +precipitationConstant = 0.0 +precipitationFactor = 1.0 +temperatureConstant = -273.15 +temperatureFactor = 1.0 +referenceEPotConstant = 0.0 +referenceEPotFactor = 1.0 + + +[meteoDownscalingOptions] +# This section is for a 5 arcmin run, for downscaling meteorological forcing at 30 arcmin to 5 arcmin. + +downscalePrecipitation = True +downscaleTemperature = True +downscaleReferenceETPot = True + +# downscaling (based on the digital elevation model): +# The downscaling will be performed by providing the "cellIds" (meteoDownscaleIds) of lower resolution cells. +meteoDownscaleIds = global_05min/meteo/downscaling_from_30min/uniqueIds_30min.map +highResolutionDEM = global_05min/meteo/downscaling_from_30min/gtopo05min.map + +# lapse rates: +temperLapseRateNC = global_05min/meteo/downscaling_from_30min/temperature_slope.nc +precipLapseRateNC = global_05min/meteo/downscaling_from_30min/precipitation_slope.nc + +# downscaling criteria (TODO: remove these): +temperatCorrelNC = global_05min/meteo/downscaling_from_30min/temperature_correl.nc +precipitCorrelNC = global_05min/meteo/downscaling_from_30min/precipitation_correl.nc + +# windows length (unit: arc-degree) for smoothing/averaging forcing data (not recommended): +smoothingWindowsLength = 0 + + +[landSurfaceOptions] +debugWaterBalance = True + +numberOfUpperSoilLayers = 2 + +# soil and parameters +# - they are used for all land cover types, unless they are are defined in certain land cover type options +# (e.g. different/various soil types for agriculture areas) +topographyNC = global_05min/landSurface/topography/topography_parameters_5_arcmin_october_2015.nc +soilPropertiesNC = global_05min/landSurface/soil/soilProperties5ArcMin.nc + + +includeIrrigation = True + +# netcdf time series for historical expansion of irrigation areas (unit: hectares). +# Note: The resolution of this map must be consisten with the resolution of cellArea. +historicalIrrigationArea = global_05min/waterUse/irrigation/irrigated_areas/irrigationArea05ArcMin.nc + +# a pcraster map/value defining irrigation efficiency (dimensionless) - optional +irrigationEfficiency = global_30min/waterUse/irrigation/irrigation_efficiency/efficiency.map + + +includeDomesticWaterDemand = True +includeIndustryWaterDemand = True +includeLivestockWaterDemand = True + +# domestic, industrial and livestock water demand data (unit must be in m.day-1) +domesticWaterDemandFile = global_05min/waterUse/waterDemand/domestic/domestic_water_demand_version_april_2015.nc +industryWaterDemandFile = global_05min/waterUse/waterDemand/industry/industry_water_demand_version_april_2015.nc +livestockWaterDemandFile = global_05min/waterUse/waterDemand/livestock/livestock_water_demand_version_april_2015.nc + + +# desalination water supply (maximum/potential/capacity) +desalinationWater = global_05min/waterUse/desalination/desalination_water_version_april_2015.nc + + +# zone IDs (scale) at which allocations of groundwater and surface water (as well as desalinated water) are performed +allocationSegmentsForGroundSurfaceWater = global_05min/waterUse/abstraction_zones/abstraction_zones_60min_05min.map + +# pcraster maps defining the partitioning of groundwater - surface water source +# +# - predefined surface water - groundwater partitioning for irrigation demand (e.g. based on Siebert, Global Map of Irrigation Areas version 5) +irrigationSurfaceWaterAbstractionFractionData = global_05min/waterUse/source_partitioning/surface_water_fraction_for_irrigation/AEI_SWFRAC.map +# -- quality map +irrigationSurfaceWaterAbstractionFractionDataQuality = global_05min/waterUse/source_partitioning/surface_water_fraction_for_irrigation/AEI_QUAL.map +# +# - threshold values defining the preference for surface water source for irrigation purpose +# -- treshold to maximize surface water irrigation use (cells with irrSurfaceWaterAbstractionFraction above this will prioritize irrigation surface water use) +treshold_to_maximize_irrigation_surface_water = 0.50 +# -- treshold to minimize fossil water withdrawal for irrigation (cells with irrSurfaceWaterAbstractionFraction below this have no fossil withdrawal for irrigation) +treshold_to_minimize_fossil_groundwater_irrigation = 0.70 +# +# - predefined surface water - groundwater partitioning for non irrigation demand (e.g. based on McDonald, 2014) +maximumNonIrrigationSurfaceWaterAbstractionFractionData = global_30min/waterUse/source_partitioning/surface_water_fraction_for_non_irrigation/max_city_sw_fraction.map + + +[forestOptions] + +name = forest +debugWaterBalance = True + +# snow module properties +snowModuleType = Simple +freezingT = 0.0 +degreeDayFactor = 0.0025 +snowWaterHoldingCap = 0.1 +refreezingCoeff = 0.05 + +# other paramater values +minTopWaterLayer = 0.0 +minCropKC = 0.2 + +cropCoefficientNC = global_05min/landSurface/landCover/naturalTall/cropCoefficientForest.nc +interceptCapNC = global_05min/landSurface/landCover/naturalTall/interceptCapInputForest.nc +coverFractionNC = global_05min/landSurface/landCover/naturalTall/coverFractionInputForest.nc + +landCoverMapsNC = None +# If NC file is not provided, we have to provide the following pcraster maps: +fracVegCover = global_05min/landSurface/landCover/naturalTall/vegf_tall.map +minSoilDepthFrac = global_30min/landSurface/landCover/naturalTall/minf_tall_permafrost.map +maxSoilDepthFrac = global_30min/landSurface/landCover/naturalTall/maxf_tall.map +rootFraction1 = global_05min/landSurface/landCover/naturalTall/rfrac1_tall.map +rootFraction2 = global_05min/landSurface/landCover/naturalTall/rfrac2_tall.map +maxRootDepth = 1.0 +# Note: The maxRootDepth is not used for non irrigated land cover type. +# +# Parameters for the Arno's scheme: +arnoBeta = None +# If arnoBeta is defined, the soil water capacity distribution is based on this. +# If arnoBeta is NOT defined, maxSoilDepthFrac must be defined such that arnoBeta will be calculated based on maxSoilDepthFrac and minSoilDepthFrac. + +# initial conditions: +interceptStorIni = global_05min/initialConditions/interceptStor_forest_1999-12-31.map +snowCoverSWEIni = global_05min/initialConditions/snowCoverSWE_forest_1999-12-31.map +snowFreeWaterIni = global_05min/initialConditions/snowFreeWater_forest_1999-12-31.map +topWaterLayerIni = global_05min/initialConditions/topWaterLayer_forest_1999-12-31.map +storUppIni = global_05min/initialConditions/storUpp_forest_1999-12-31.map +storLowIni = global_05min/initialConditions/storLow_forest_1999-12-31.map +interflowIni = global_05min/initialConditions/interflow_forest_1999-12-31.map + + +[grasslandOptions] + +name = grassland +debugWaterBalance = True + +# snow module properties +snowModuleType = Simple +freezingT = 0.0 +degreeDayFactor = 0.0025 +snowWaterHoldingCap = 0.1 +refreezingCoeff = 0.05 + +# other paramater values +minTopWaterLayer = 0.0 +minCropKC = 0.2 + +cropCoefficientNC = global_05min/landSurface/landCover/naturalShort/cropCoefficientGrassland.nc +interceptCapNC = global_05min/landSurface/landCover/naturalShort/interceptCapInputGrassland.nc +coverFractionNC = global_05min/landSurface/landCover/naturalShort/coverFractionInputGrassland.nc + +landCoverMapsNC = None +# If NC file is not provided, we have to provide the following values: +fracVegCover = global_05min/landSurface/landCover/naturalShort/vegf_short.map +minSoilDepthFrac = global_30min/landSurface/landCover/naturalShort/minf_short_permafrost.map +maxSoilDepthFrac = global_30min/landSurface/landCover/naturalShort/maxf_short.map +rootFraction1 = global_05min/landSurface/landCover/naturalShort/rfrac1_short.map +rootFraction2 = global_05min/landSurface/landCover/naturalShort/rfrac2_short.map +maxRootDepth = 0.5 +# Note: The maxRootDepth is not used for non irrigated land cover type. +# +# Parameters for the Arno's scheme: +arnoBeta = None +# If arnoBeta is defined, the soil water capacity distribution is based on this. +# If arnoBeta is NOT defined, maxSoilDepthFrac must be defined such that arnoBeta will be calculated based on maxSoilDepthFrac and minSoilDepthFrac. + +# initial conditions: +interceptStorIni = global_05min/initialConditions/interceptStor_grassland_1999-12-31.map +snowCoverSWEIni = global_05min/initialConditions/snowCoverSWE_grassland_1999-12-31.map +snowFreeWaterIni = global_05min/initialConditions/snowFreeWater_grassland_1999-12-31.map +topWaterLayerIni = global_05min/initialConditions/topWaterLayer_grassland_1999-12-31.map +storUppIni = global_05min/initialConditions/storUpp_grassland_1999-12-31.map +storLowIni = global_05min/initialConditions/storLow_grassland_1999-12-31.map +interflowIni = global_05min/initialConditions/interflow_grassland_1999-12-31.map + + +[irrPaddyOptions] + +name = irrPaddy +debugWaterBalance = True + +# snow module properties +snowModuleType = Simple +freezingT = 0.0 +degreeDayFactor = 0.0025 +snowWaterHoldingCap = 0.1 +refreezingCoeff = 0.05 +# +landCoverMapsNC = None +# If NC file is not provided, we have to provide the following values: +fracVegCover = global_05min/landSurface/landCover/irrPaddy/fractionPaddy.map +minSoilDepthFrac = global_30min/landSurface/landCover/irrPaddy/minf_paddy_permafrost.map +maxSoilDepthFrac = global_30min/landSurface/landCover/irrPaddy/maxf_paddy.map +rootFraction1 = global_30min/landSurface/landCover/irrPaddy/rfrac1_paddy.map +rootFraction2 = global_30min/landSurface/landCover/irrPaddy/rfrac2_paddy.map +maxRootDepth = 0.5 +# +# Parameters for the Arno's scheme: +arnoBeta = None +# If arnoBeta is defined, the soil water capacity distribution is based on this. +# If arnoBeta is NOT defined, maxSoilDepthFrac must be defined such that arnoBeta will be calculated based on maxSoilDepthFrac and minSoilDepthFrac. +# +# other paramater values +minTopWaterLayer = 0.05 +minCropKC = 0.2 +cropDeplFactor = 0.2 +minInterceptCap = 0.0002 + +cropCoefficientNC = global_30min/landSurface/landCover/irrPaddy/Global_CropCoefficientKc-IrrPaddy_30min.nc + +# initial conditions: +interceptStorIni = global_05min/initialConditions/interceptStor_irrPaddy_1999-12-31.map +snowCoverSWEIni = global_05min/initialConditions/snowCoverSWE_irrPaddy_1999-12-31.map +snowFreeWaterIni = global_05min/initialConditions/snowFreeWater_irrPaddy_1999-12-31.map +topWaterLayerIni = global_05min/initialConditions/topWaterLayer_irrPaddy_1999-12-31.map +storUppIni = global_05min/initialConditions/storUpp_irrPaddy_1999-12-31.map +storLowIni = global_05min/initialConditions/storLow_irrPaddy_1999-12-31.map +interflowIni = global_05min/initialConditions/interflow_irrPaddy_1999-12-31.map + + +[irrNonPaddyOptions] + +name = irrNonPaddy +debugWaterBalance = True + +# snow module properties +snowModuleType = Simple +freezingT = 0.0 +degreeDayFactor = 0.0025 +snowWaterHoldingCap = 0.1 +refreezingCoeff = 0.05 +# +landCoverMapsNC = None +# If NC file is not provided, we have to provide the following values: +fracVegCover = global_05min/landSurface/landCover/irrNonPaddy/fractionNonPaddy.map +minSoilDepthFrac = global_30min/landSurface/landCover/irrNonPaddy/minf_nonpaddy_permafrost.map +maxSoilDepthFrac = global_30min/landSurface/landCover/irrNonPaddy/maxf_nonpaddy.map +rootFraction1 = global_30min/landSurface/landCover/irrNonPaddy/rfrac1_nonpaddy.map +rootFraction2 = global_30min/landSurface/landCover/irrNonPaddy/rfrac2_nonpaddy.map +maxRootDepth = 1.0 +# +# Parameters for the Arno's scheme: +arnoBeta = None +# If arnoBeta is defined, the soil water capacity distribution is based on this. +# If arnoBeta is NOT defined, maxSoilDepthFrac must be defined such that arnoBeta will be calculated based on maxSoilDepthFrac and minSoilDepthFrac. +# +# other paramater values +minTopWaterLayer = 0.0 +minCropKC = 0.2 +cropDeplFactor = 0.5 +minInterceptCap = 0.0002 + +cropCoefficientNC = global_30min/landSurface/landCover/irrNonPaddy/Global_CropCoefficientKc-IrrNonPaddy_30min.nc + +# initial conditions: +interceptStorIni = global_05min/initialConditions/interceptStor_irrNonPaddy_1999-12-31.map +snowCoverSWEIni = global_05min/initialConditions/snowCoverSWE_irrNonPaddy_1999-12-31.map +snowFreeWaterIni = global_05min/initialConditions/snowFreeWater_irrNonPaddy_1999-12-31.map +topWaterLayerIni = global_05min/initialConditions/topWaterLayer_irrNonPaddy_1999-12-31.map +storUppIni = global_05min/initialConditions/storUpp_irrNonPaddy_1999-12-31.map +storLowIni = global_05min/initialConditions/storLow_irrNonPaddy_1999-12-31.map +interflowIni = global_05min/initialConditions/interflow_irrNonPaddy_1999-12-31.map + + + + +[groundwaterOptions] + +debugWaterBalance = True + +groundwaterPropertiesNC = global_05min/groundwater/properties/groundwaterProperties5ArcMin.nc +# The file will containspecificYield (m3.m-3), kSatAquifer, recessionCoeff (day-1) +# +# - minimum value for groundwater recession coefficient (day-1) +minRecessionCoeff = 1.0e-4 + +# some options for constraining groundwater abstraction +limitFossilGroundWaterAbstraction = True +estimateOfRenewableGroundwaterCapacity = 0.0 +estimateOfTotalGroundwaterThickness = global_05min/groundwater/aquifer_thickness_estimate/thickness_05min.map +# minimum and maximum total groundwater thickness +minimumTotalGroundwaterThickness = 100. +maximumTotalGroundwaterThickness = None + +# annual pumping capacity for each region (unit: billion cubic meter per year), should be given in a netcdf file +pumpingCapacityNC = global_30min/waterUse/groundwater_pumping_capacity/regional_abstraction_limit.nc + +# initial conditions: +storGroundwaterIni = global_05min/initialConditions/storGroundwater_1999-12-31.map +storGroundwaterFossilIni = global_05min/initialConditions/storGroundwaterFossil_1999-12-31.map +# +# additional initial conditions for pumping behaviors +avgNonFossilGroundwaterAllocationLongIni = global_05min/initialConditions/avgNonFossilGroundwaterAllocationLong_1999-12-31.map +avgNonFossilGroundwaterAllocationShortIni = global_05min/initialConditions/avgNonFossilGroundwaterAllocationShort_1999-12-31.map +avgTotalGroundwaterAbstractionIni = global_05min/initialConditions/avgTotalGroundwaterAbstraction_1999-12-31.map +avgTotalGroundwaterAllocationLongIni = global_05min/initialConditions/avgTotalGroundwaterAllocationLong_1999-12-31.map +avgTotalGroundwaterAllocationShortIni = global_05min/initialConditions/avgTotalGroundwaterAllocationShort_1999-12-31.map +# +# additional initial conditions (needed only for MODFLOW run) +relativeGroundwaterHeadIni = global_05min/initialConditions/relativeGroundwaterHead_1999-12-31.map +baseflowIni = global_05min/initialConditions/baseflow_1999-12-31.map + +# zonal IDs (scale) at which zonal allocation of groundwater is performed +allocationSegmentsForGroundwater = global_05min/waterUse/abstraction_zones/abstraction_zones_30min_05min.map + +# assumption for the minimum transmissivity value (unit: m2/day) that can be extracted (via capillary rise and/or groundwater abstraction) - optional +minTransimissivityForProductiveAquifer = 50.0 +# - if None, abstraction and/or capillary rise can always occur everywhere and unlimited + + + +[routingOptions] + +debugWaterBalance = True + +# drainage direction map +lddMap = global_05min/routing/ldd_and_cell_area/lddsound_05min.map + +# cell area (unit: m2) +cellAreaMap = global_05min/routing/ldd_and_cell_area/cellsize05min.correct.map + +# routing method: #accuTravelTime or kinematicWave +routingMethod = accuTravelTime + +# manning coefficient +manningsN = 0.04 + +# Option for flood plain simulation +dynamicFloodPlain = False + +# manning coefficient for floodplain +floodplainManningsN = 0.07 + + +# channel gradient +gradient = global_05min/routing/channel_properties/channel_gradient.map + +# constant channel depth +constantChannelDepth = global_05min/routing/channel_properties/bankfull_depth.map + +# constant channel width (optional) +constantChannelWidth = global_05min/routing/channel_properties/bankfull_width.map + +# minimum channel width (optional) +minimumChannelWidth = global_05min/routing/channel_properties/bankfull_width.map + +# channel properties for flooding +bankfullCapacity = None +# - If None, it will be estimated from (bankfull) channel depth (m) and width (m) + + +# files for relative elevation (above minimum dem) +relativeElevationFiles = global_05min/routing/channel_properties/dzRel%04d.map +relativeElevationLevels = 0.0, 0.01, 0.05, 0.10, 0.20, 0.30, 0.40, 0.50, 0.60, 0.70, 0.80, 0.90, 1.00 + + +# composite crop factors for WaterBodies: +cropCoefficientWaterNC = global_30min/routing/kc_surface_water/cropCoefficientForOpenWater.nc +minCropWaterKC = 1.00 + + +# lake and reservoir parameters +waterBodyInputNC = global_05min/routing/surface_water_bodies/waterBodies5ArcMin.nc +onlyNaturalWaterBodies = False + + +# initial conditions: +waterBodyStorageIni = global_05min/initialConditions/waterBodyStorage_1999-12-31.map +channelStorageIni = global_05min/initialConditions/channelStorage_1999-12-31.map +readAvlChannelStorageIni = global_05min/initialConditions/readAvlChannelStorage_1999-12-31.map +avgDischargeLongIni = global_05min/initialConditions/avgDischargeLong_1999-12-31.map +avgDischargeShortIni = global_05min/initialConditions/avgDischargeShort_1999-12-31.map +m2tDischargeLongIni = global_05min/initialConditions/m2tDischargeLong_1999-12-31.map +avgBaseflowLongIni = global_05min/initialConditions/avgBaseflowLong_1999-12-31.map +riverbedExchangeIni = global_05min/initialConditions/riverbedExchange_1999-12-31.map +# +# initial condition of sub-time step discharge (needed for estimating number of time steps in kinematic wave methods) +subDischargeIni = global_05min/initialConditions/subDischarge_1999-12-31.map +# +avgLakeReservoirInflowShortIni = global_05min/initialConditions/avgLakeReservoirInflowShort_1999-12-31.map +avgLakeReservoirOutflowLongIni = global_05min/initialConditions/avgLakeReservoirOutflowLong_1999-12-31.map +# +# number of days (timesteps) that have been performed for spinning up initial conditions in the routing module (i.e. channelStorageIni, avgDischargeLongIni, avgDischargeShortIni, etc.) +timestepsToAvgDischargeIni = global_05min/initialConditions/timestepsToAvgDischarge_1999-12-31.map +# Note that: +# - maximum number of days (timesteps) to calculate long term average flow values (default: 5 years = 5 * 365 days = 1825) +# - maximum number of days (timesteps) to calculate short term average values (default: 1 month = 1 * 30 days = 30) + + + + +[reportingOptions] + +# output files that will be written in the disk in netcdf files: +# - daily resolution +#outDailyTotNC = temperature,precipitation,totalEvaporation,gwRecharge,totalRunoff,totalGroundwaterAbstraction,discharge,surfaceWaterStorage,interceptStor,snowFreeWater,snowCoverSWE,topWaterLayer,storUppTotal,storLowTotal,storGroundwater,totalWaterStorageThickness,channelStorage,surfaceWaterAbstraction,nonIrrGrossDemand,nonIrrWaterConsumption,irrPaddyWaterWithdrawal,domesticWaterWithdrawal,industryWaterWithdrawal,precipitation_at_irrigation,evaporation_from_irrigation,surfaceWaterStorage,dynamicFracWat,floodVolume,floodDepth,surfaceWaterLevel +outDailyTotNC = temperature,precipitation,totalEvaporation,gwRecharge,totalRunoff,totalGroundwaterAbstraction,discharge,surfaceWaterStorage,interceptStor,snowFreeWater,snowCoverSWE,topWaterLayer,storUppTotal,storLowTotal,storGroundwater,totalWaterStorageThickness,channelStorage,surfaceWaterAbstraction,nonIrrGrossDemand,nonIrrWaterConsumption,irrPaddyWaterWithdrawal,domesticWaterWithdrawal,industryWaterWithdrawal,precipitation_at_irrigation,evaporation_from_irrigation,surfaceWaterStorage,dynamicFracWat,surfaceWaterLevel +# - monthly resolution +outMonthTotNC = None +outMonthAvgNC = None +outMonthEndNC = None +# - annual resolution +outAnnuaTotNC = None +outAnnuaAvgNC = None +outAnnuaEndNC = None +# - monthly and annual maxima +outMonthMaxNC = None +outAnnuaMaxNC = None + +# netcdf format and zlib setup +formatNetCDF = NETCDF4 +zlib = True diff --git a/book/tutorials_examples/intro_tutorials_examples.md b/book/tutorials_examples/intro_tutorials_examples.md new file mode 100644 index 0000000..879e492 --- /dev/null +++ b/book/tutorials_examples/intro_tutorials_examples.md @@ -0,0 +1,16 @@ +# Tutorials and examples + +This chapter lists a number of example analyses designed by the eWaterCycle community to + +- Highlight the different potential uses of eWaterCycle in hydrological research +- Provide a starting point for researchers to start doing their own analyses +- Showcase best practices in designing and documenting Open and FAIR hydrological modelling analyses + +The examples are: + +## straightforward model runs +- Running the HBV model on a region from the Caravan dataset using input data from ERA5. +- Running the PCRGlobWB model on a region from the Caravan dataset using input data from ERA5. + +## model calibration +- calibrating the HBV model on a region from the Caravan dataset using input data from ERA5 and observations from the Caravan dataset. \ No newline at end of file