{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# 1. Confined Aquifer Test - Oude Korendijk\n", "**This example is taken from Kruseman et al. 1970**" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Step 1: Loading packages" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import pandas as pd\n", "\n", "import ttim as ttm\n", "\n", "plt.rcParams[\"figure.figsize\"] = (5, 3) # default figure size" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Introduction and Conceptual Model\n", "\n", "TTim is a semi-analytical model of transient groundwater flow systems (Bakker, 2013). It applies the Laplace-transform analytic element method to solve for groundwater flow in a variety of hydrogeological features. One of the many applications of TTim is the analysis of aquifer tests. In this series of Jupyter Notebooks, we demonstrate the capabilities to model and calibrate aquifer tests in different hydrogeological conditions.\n", "\n", "In this example, we will use the pumping test data from Oude Korendijk (Kruseman et al. 1970) to demonstrate how TTim can be used to model and analyze pumping tests. Furthermore, we reproduce the work of Yang (2020) and compare the performance of TTim with other transient well hydraulics software AQTESOLV (Duffield, 2007) and MLU (Carlson and Randall, 2012).\n", "\n", "Oude Korendijk is a polder area south of Rotterdam, the Netherlands. The stratigraphy can be summarised by:\n", "* the presence in the first 18 m depth of an impermeable layer,\n", "* followed by a 7 m succession of coarse gravel and sands, which are considered as the aquifer layer,\n", "* and finally, a layer of fine sands and clayey sediments that are deemed impermeable.\n", "\n", "The well screens the whole thickness of the aquifer. Drawdowns were taken from piezometers installed 30 and 90 m away from the well. Pumping at the well has been taken with a constant discharge of 788 m3/d for almost 14 hours.\n", "\n", "The conceptual model of the area is a single layer confined aquifer located at 18 m below surface and 7 m thickness. At $t=0$, the pumping starts at a constant discharge of 788 m3/d and drawdowns are recorded at two piezometers, 30 and 90 meters away, respectively. The figure below summarises the conceptualization of the problem\n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [ "hide-input" ] }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "##Now printing the conceptual model figure:\n", "\n", "fig = plt.figure(figsize=(8, 3))\n", "ax = fig.add_subplot(1, 1, 1)\n", "# sky\n", "sky = plt.Rectangle((-10, 0), width=110, height=3, fc=\"b\", zorder=0, alpha=0.1)\n", "ax.add_patch(sky)\n", "\n", "# Aquifer:\n", "ground = plt.Rectangle(\n", " (-10, -25),\n", " width=110,\n", " height=25,\n", " fc=np.array([209, 179, 127]) / 255,\n", " zorder=0,\n", " alpha=0.9,\n", ")\n", "ax.add_patch(ground)\n", "\n", "# Confining bed:\n", "confining_unit = plt.Rectangle(\n", " (-10, -18),\n", " width=110,\n", " height=18,\n", " fc=np.array([100, 100, 100]) / 255,\n", " zorder=0,\n", " alpha=0.7,\n", ")\n", "ax.add_patch(confining_unit)\n", "well = plt.Rectangle(\n", " (-2, -25), width=4, height=25, fc=np.array([200, 200, 200]) / 255, zorder=1\n", ")\n", "ax.add_patch(well)\n", "\n", "# Wellhead\n", "wellhead = plt.Rectangle(\n", " (-2.5, 0), width=5, height=1.5, fc=np.array([200, 200, 200]) / 255, zorder=2, ec=\"k\"\n", ")\n", "ax.add_patch(wellhead)\n", "\n", "# Screen for the well:\n", "screen = plt.Rectangle(\n", " (-2, -25),\n", " width=4,\n", " height=7,\n", " fc=np.array([200, 200, 200]) / 255,\n", " alpha=1,\n", " zorder=2,\n", " ec=\"k\",\n", " ls=\"--\",\n", ")\n", "screen.set_linewidth(2)\n", "ax.add_patch(screen)\n", "pumping_arrow = plt.Arrow(x=2.5, y=0.75, dx=4, dy=0, color=\"#00035b\")\n", "ax.add_patch(pumping_arrow)\n", "ax.text(x=6.5, y=0.75, s=r\"$ Q = 788$ m$^3$/d\", fontsize=\"large\")\n", "# Piezometers\n", "piez1 = plt.Rectangle(\n", " (29, -25), width=2, height=25, fc=np.array([200, 200, 200]) / 255, zorder=1\n", ")\n", "piez2 = plt.Rectangle(\n", " (89, -25), width=2, height=25, fc=np.array([200, 200, 200]) / 255, zorder=1\n", ")\n", "screen_piez_1 = plt.Rectangle(\n", " (29, -25),\n", " width=2,\n", " height=7,\n", " fc=np.array([200, 200, 200]) / 255,\n", " alpha=1,\n", " zorder=2,\n", " ec=\"k\",\n", " ls=\"--\",\n", ")\n", "screen_piez_1.set_linewidth(2)\n", "screen_piez_2 = plt.Rectangle(\n", " (89, -25),\n", " width=2,\n", " height=7,\n", " fc=np.array([200, 200, 200]) / 255,\n", " alpha=1,\n", " zorder=2,\n", " ec=\"k\",\n", " ls=\"--\",\n", ")\n", "screen_piez_2.set_linewidth(2)\n", "ax.add_patch(piez1)\n", "ax.add_patch(piez2)\n", "ax.add_patch(screen_piez_1)\n", "ax.add_patch(screen_piez_2)\n", "# last line\n", "line = plt.Line2D(xdata=[-10, 100], ydata=[0, 0], color=\"k\")\n", "ax.add_line(line)\n", "ax.text(x=30, y=0.75, s=\"P30\", fontsize=\"large\")\n", "ax.text(x=90, y=0.75, s=\"P90\", fontsize=\"large\")\n", "ax.set_xlim([-10, 100])\n", "ax.set_ylim([-25, 3]);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Step 2: Setting basic parameters for the model" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "H = 7 # aquifer thickness in meters, m\n", "zt = -18 # top boundary of aquifer, m\n", "zb = zt - H # bottom boundary of aquifer, m\n", "Q = 788 # constant discharge, m3/d" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## Step 3: Creating a TTim conceptual model\n", "\n", "In this example, we are using the ModelMaq model to conceptualize our aquifer. ModelMaq defines the aquifer system as a stacked vertical sequence of aquifers and leaky layers (aquifer-leaky layer, aquifer-leaky layer, etc). Aquifers are conceptualized as having no vertical resistance (Dupuit approximation), with constant hydraulic conductivity and storage. Aquitard layers are approximated as having only vertical flow. They are characterized by the parameter resistance to vertical flow and by having no storage.\n", "\n", "In the model construction, we have to set the parameters for each layer (which consists of an aquifer layer and an aquitard layer).\n", "\n", "For our one-layer model we have to set:\n", "\n", "- The hydraulic conductivity: ```kaq``` this is a list/array with a float element for every aquifer, for example: ```[kaq0,kaq1]```. We can also set a float value, in this case, the same ```kaq``` is assumed for every layer.\n", "- The top and bottom of each aquifer: ```z``` defined by a list/array ```[zt0,zb0,zt1,zb1,...]```, where the inputs are a sequence of top and bottoms of the aquifer layers.\n", "- The specific storage: ```Saq```. The input is a list/array with a float element for every aquifer, for example: ```[Saq0, Saq1]```. We can also set a float value. In this case, the same ```Saq``` is assumed for every layer.\n", "- The minimum time for which TTim solve the groundwater flow: ```tmin```, a float.\n", "- And the maximum time: ```tmax```, float.\n", "\n", "Optional parameters:\n", "\n", "- TTim automatically assumes the ```topboundary``` is confined (```topboundary = 'conf'```). If we assign: ```topboundary = 'semi'``` This means that we assume the layer on top of the uppermost aquifer is a leaky layer, and we must also characterize it. Thus, even though we have only one aquifer, we have to set an additional element to the ```z``` array, which is the top of the aquitard formation:\n", "\n", " * For example: ```z = [0,zt,zb]```. 0 is the depth of the aquitard overlying the aquifer, ```zt``` and ```zb``` are the top and bottom of the aquifer. \n", "\n", " * We would also specify the leaky-layer parameters ```c``` and ```Sll``` (see below). \n", "\n", "- ```phreatictop```: Is a boolean (True/False). If ```True```, the first element in ```Saq``` is considered phreatic storage (Specific Yield) and it is not multiplied by the layer thickness. The default value is ```False``` in ```ModelMaq```. Generally, this parameter is set to ```True``` only in unconfined aquifers.\n", "\n", "In case of more than one layer model, or when ```topboundary = 'semi'```, we would also have to set the resistance to vertical flow ```c```, and the storage ```Sll``` of the aquitard portions. An example of this configuration can be seen in the notebook [Confined 4 - Schroth](confined4_schroth.ipynb)\n", "\n", "To represent our pumping well, we will use the ```Well``` feature.\n", "\n", "Wells, in TTim, are features with specified discharge. The well may be screened in multiple layers. In case the screen is in more than one layer, TTim distributes the discharge across the layers such that the head inside the well is the same in all screened layers. The wellbore storage and skin effect may be taken into account.\n", "\n", "The discharge of the well acting on layer $n$ is computed inside TTim with the expression (Bakker, 2013):\n", "\n", "$$ Q_n = 2\\pi r_wH_n\\frac{h_n-h_w}{c_e} $$\n", "\n", "where, $Q_n$ is the discharge at layer $n$, which is a positive value for water being pumped, $r_w$ is the radius of the well, $H_n$ is the layer thickness, $h_n$ is the head just outside the well, and $h_w$ is the head inside the well. $c_e$ is the entry resistance that can be defined in TTim by the skin resistance of the well (see notebook [Confined 2 - Grindley](confined2_grindley.ipynb) for more details)\n", "\n", "For the well we have to set:\n", "- The TTim model: ```ml``` where the well is added to\n", "- The x and y location: ```xw, yw```, floats\n", "- The pumping scheme is defined by a list (```tsandQ```) where each element is a tuple representing a new stress condition with the starting time and the discharge rate, in our case: ```(0, Q)``` meaning that pumping begins at t = 0 with pumping rate Q\n", "- The layers where it is screened: ```layers```. This argument can be set as an integer (one layer) or a list/array of integers (multi-screen well).\n", "\n", "Optional parameters for the ```Well``` object are:\n", "- The well radius: ```rw```, a float, if not specified a value of 0.1 m is assumed.\n", "- the skin resistance of the well: ```res```. If not specified, it is set to 0. An example of setting up the skin resistance is seen in the notebook : [Confined 2 - Grindley](confined2_grindley.ipynb).\n", "- The radius of the caisson: ```rc```. The radius of the caisson is the parameter used to account for wellbore storage in the simulation. If not specified, this value is set to ```None``` and TTim will ignore wellbore storage. TTim considers the wellbore storage by solving the water balance inside the well with the expression (Bakker, 2013):\n", "$$\\pi r_c^2 \\frac{dh_w}{dt} = \\sum_nQ_n-Q_w $$\n", "where: $Q_n$ and $Q_w$ are the inflows and outflows in the well, $h_w$ is the head inside the well and $r_c$ is the radius of the caisson.\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# unkonwn parameters: kaq, Saq\n", "ml = ttm.ModelMaq(kaq=60, z=[zt, zb], Saq=1e-4, tmin=1e-5, tmax=1)\n", "w = ttm.Well(ml, xw=0, yw=0, rw=0.2, tsandQ=[(0, Q)], layers=0)\n", "\n", "# Here we are setting everything in meters for length and days for time" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The last step in our model creation is to \"solve\" the model:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "self.neq 1\n", "solution complete\n" ] } ], "source": [ "ml.solve()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Step 4: Load data of two observation wells:" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The preferred method of loading data into TTim is to use numpy arrays.\n", "\n", "The data is in a text file where the first column is the time data in ***minutes*** and the second column is the drawdown in ***meters***\n", "\n", "We load the data as a numpy array for each piezometer. We then separate time and drawdown into two different 1d arrays. We also convert time data from minutes to days" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "# time and drawdown of piezometer 30m away from pumping well\n", "data1 = np.loadtxt(\"data/piezometer_h30.txt\", skiprows=1)\n", "t1 = data1[:, 0] / 60 / 24 # convert min to days\n", "h1 = data1[:, 1]\n", "r1 = 30\n", "# time and drawdown of piezometer 90m away from pumping well\n", "data2 = np.loadtxt(\"data/piezometer_h90.txt\", skiprows=1)\n", "t2 = data2[:, 0] / 60 / 24 # convert min to days\n", "h2 = data2[:, 1]\n", "r2 = 90" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Step 5: Calibration" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Model Calibration is done in TTim using the ```Calibrate``` object. TTim calibrates the parameters by minimizing an objective function using a non-linear least-squares fitting algorithm. The objective function used is the sum of the squares of the residuals calculated as:\n", "\n", "$$\\sum_n (h_o - h_c)^2$$,\n", "\n", "where $h_0$ is the observed heads and $h_c$ is the calculated heads by the model.\n", "\n", "and TTim uses ```lmfit```, a python package for non-linear least-squares minimization (Newville et al. 2014), to find the optimal parameters that minimize the residuals.\n", "\n", "For the calibration of our groundwater model, we proceed by creating a calibration object with the ```Calibrate``` class. The ```Calibrate``` object takes the model ```ml``` as argument.\n", "We then set the parameters we are adjusting:\n", "- Hydraulic conductivity: ```kaq0``` (Hydraulic conductivity of layer 0)\n", "- Specific Storage ```Saq0``` (Specific Storage of layer 0)\n", "\n", "with the ```.set_parameter``` method.\n", "\n", "- ```.set_parameter``` takes two arguments:\n", "- ```name``` is the parameter name, a string, where the letters define the parameter. The possible values are \"kaq\", \"Saq\" or 'c', and they represent hydraulic conductivity, Specific storage and resistance to vertical flow, respectively. The letters are followed by a number, that define the layer of that parameter. For the example ```\"kaq0\"``` means the hydraulic conductivity of the layer 0. In our multilayer model we can extend the numbering to adjust one parameters for various layers in that case, we write the number of the first layer followed by a underline \"_\" and the number of the last layer, for example ```kaq0_1```, which means the hydraulic conductivity for layers 0 to 1\n", " - ```initial```is the initial guess value for the fitting algorithm.\n", "\n", "We can also add the optional parameters:\n", "- ```pmin``` and ```pmax```, which are floats that define the minimum and maximum possible values for the parameter. If not set, TTim assume their values are -inf and inf, respectively.\n", "\n", "The other method for adjusting parameters, ```.set_parameter_by_reference``` is later explained in [step 6.3](#step_6_3).\n", "\n", "We add the observation data using the ```.series``` method. The arguments are:\n", " - ```name```: string with the observation name\n", " - ```x``` and ```y```: float positions of the observation\n", " - ```t```: the array of observation times\n", " - ```h```: the array of observed drawdowns\n", " - ```layer```: integer. The layer of the observation (0 indexed)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### Step 5.1: Calibration with Observation from Piezometer 1 (30 m from well)\n", "\n", "We begin calibrating using only the data from observation 1:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "ca1 = ttm.Calibrate(ml) # Calibrate object\n", "ca1.set_parameter(name=\"kaq0\", initial=10) # Setting parameters\n", "ca1.set_parameter(name=\"Saq0\", initial=1e-4)\n", "ca1.series(name=\"obs1\", x=r1, y=0, t=t1, h=h1, layer=0) # Adding observations" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The ```fit``` method is used to run the least-squares algorithm (```lmfit```) for finding the optimal parameter values:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "..................................\n", "Fit succeeded.\n" ] } ], "source": [ "ca1.fit(\n", " report=False\n", ") # Fitting the model. We can hide the message below setting report = False" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The optimal parameters and their related fit statistics are saved inside the ```Calibrate``` object as a DataFrame in the ```.parameters``` attribute:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
optimalstdperc_stdpminpmaxinitialparray
kaq068.6394051.4382682.095397-infinf10.0000[68.6394051606159]
Saq00.0000160.0000029.845150-infinf0.0001[1.607160696374144e-05]
\n", "
" ], "text/plain": [ " optimal std perc_std pmin pmax initial \\\n", "kaq0 68.639405 1.438268 2.095397 -inf inf 10.0000 \n", "Saq0 0.000016 0.000002 9.845150 -inf inf 0.0001 \n", "\n", " parray \n", "kaq0 [68.6394051606159] \n", "Saq0 [1.607160696374144e-05] " ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ca1.parameters" ] }, { "cell_type": "markdown", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "The calibration RMSE can be accessed with the ```.rmse``` method:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "rmse: 0.03166018365112287\n" ] } ], "source": [ "print(\"rmse:\", ca1.rmse())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Finally, we can access the model drawdowns by asking the calibrated model to compute the heads at the well location and time intervals specified by the sampled data.\n", "\n", "For this, we use the ```.head``` method in the model object, in our case, ```ml```.\n", "\n", "The arguments are:\n", "* the positions ```x``` and ```y``` of the piezometric well (or any other point of interest). In our case, our well is located at position ```x= r1``` and ```y = 0```.\n", "* the time intervals, defined by the numpy array ```t```, for the computation of the heads. In our case, this is defined by the variable ```t1```.\n", "\n", "* Another optional input is ```layers```, which can be a list, integer or an array defining the model layers. When we do not assign anything, the head is computed for all layers.\n", "\n", "The output is a numpy array with dimensions ```(nl,nt)```, where ```nl``` is the number of layers and ```nt``` is the number of time intervals.\n" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(1, 34)" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "hm1 = ml.head(x=r1, y=0, t=t1) # Using the head method to calculate model resuts\n", "hm1.shape # Demonstration of the output shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Plotting the model Results" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# matplotlib plot for calibration,\n", "plt.semilogx(t1, h1, \".\", label=\"obs at 30 m\") # Plotting the observed drawdown\n", "plt.semilogx(t1, hm1[0], label=\"ttim at 30 m\") # Simulated drawdown\n", "plt.xlabel(\"time [d]\")\n", "plt.ylabel(\"drawdown [m]\")\n", "plt.title(\"ttim analysis for Oude Korendijk - Piezometer 30 m\")\n", "plt.legend()\n", "plt.grid()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Step 5.2. Calibrate model Parameters with Observation Well 2 (90 m distance)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We proceed to calibrate using only the data from observation well 2. Details on the procedures can be reviewed in [***step 5.1***](#step_5_1)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ ".........................................\n", "Fit succeeded.\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
optimalstdperc_stdpminpmaxinitialparray
kaq071.5821661.5739822.198846-infinf10.0000[71.58216612015345]
Saq00.0000290.0000026.657679-infinf0.0001[2.910742855968684e-05]
\n", "
" ], "text/plain": [ " optimal std perc_std pmin pmax initial \\\n", "kaq0 71.582166 1.573982 2.198846 -inf inf 10.0000 \n", "Saq0 0.000029 0.000002 6.657679 -inf inf 0.0001 \n", "\n", " parray \n", "kaq0 [71.58216612015345] \n", "Saq0 [2.910742855968684e-05] " ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ca2 = ttm.Calibrate(ml)\n", "ca2.set_parameter(name=\"kaq0\", initial=10)\n", "ca2.set_parameter(name=\"Saq0\", initial=1e-4)\n", "ca2.series(name=\"obs2\", x=r2, y=0, t=t2, h=h2, layer=0)\n", "ca2.fit()\n", "ca2.parameters" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "rmse: 0.022718720768954242\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAekAAAE/CAYAAABiqTulAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABlnUlEQVR4nO3dd3xN9xvA8c/NXpKITBGJaEUQo2ZsWlttUiNmqVVF7bY/lNYqtYpWVc3SGi1KzERrz1q1awsRIyERIvn+/rjNrSvzRnae9+uVFzn3e8557j335rnnOzVKKYUQQgghchyj7A5ACCGEEEmTJC2EEELkUJKkhRBCiBxKkrQQQgiRQ0mSFkIIIXIoSdJCCCFEDiVJWgghhMihJEkLIYQQOZQkaSGEECKHytNJet++fYwbN45Hjx4lemzevHn8+OOPibZfvXoVjUaT5GN5iZeXF927d8+UY48bNw6NRpMhx3r+/Dl9+/bFzc0NY2NjypcvnyHHTYlSipUrV1K/fn0KFiyIubk53t7eDBgwgBs3bmT4+UJCQtBoNISEhGTI8RLew1999ZXe9ri4OHr27IlGo+GLL77IkHNlpVffs0m9bkm997y8vGjevHmmx/fjjz+i0Wh0PyYmJhQpUoQePXpw69YtXbnu3bvj5eWV6fHkFLdv32bcuHH89ddfWXre0NBQunfvjrOzMxYWFpQtW5ZFixYlWTYsLIzu3bvj6OiIlZUV/v7+7Ny5M0vjTZbKw6ZNm6YAdeXKlUSPlS5dWtWpUyfR9piYGLV//34VFhaW+QFmI09PT9WtW7dMOfaNGzfU/v37M+RYM2fOVICaM2eO2rdvnzp58mSGHDc5cXFxKiAgQAGqY8eO6tdff1XBwcFq1qxZqkiRIsre3l7t2bMnQ88ZHBysABUcHJwhx7ty5YoC1LRp03Tbnj17ptq0aaOMjIzUvHnzMuQ8We3V92xERITav3+/ioiI0G1L6r3n6empmjVrlunxLV68WAFq8eLFav/+/WrXrl1q3LhxytzcXBUrVkw9efJEKaXUpUuX1LFjxzI9npzi8OHDutclqzx69Eh5e3urIkWKqMWLF6ugoCDVrVs3Bajp06frlY2JiVFlypRRRYoUUcuXL1fbtm1TLVu2VCYmJiokJCTLYk6OSfZ9PciZzM3NqVatWnaHkasVKVKEIkWKZMixTp8+jaWlJQMHDsyQ4wE8ffoUS0vLJB+bMmUKq1evZvLkyYwcOVK3vW7dugQEBFC1alXatm3LuXPnsLe3z7CYMlNUVBStWrVi9+7drFixgvfee++1jxkXF8eLFy8wNzfPgAjTx9bWNtFnNSPfe+lVpkwZKlWqBEC9evWIi4tjwoQJ/Prrr3Tu3JnixYtna3x5xdOnT7GwsEiy1m7+/Pn8888/HDlyhIoVKwLQqFEjQkND+d///kfPnj11n99FixZx+vRp9u3bh7+/P6C9buXKlWPEiBEcPHgwy55TUvJsdfe4ceMYPnw4AMWKFdNVQYWEhODl5cWZM2fYvXu3bntC9VNS1d0JVWgnT56kffv22NnZ4eDgwNChQ3nx4gXnz5+ncePGFChQAC8vL6ZOnZqmGL/55htq166Ns7Mz1tbW+Pn5MXXqVGJjY/XK1a1blzJlynD48GFq1aqFlZUV3t7eTJ48mfj4eF25mJgYPv74Y8qXL6+L0d/fn99++y3FOJ48eYK9vT0ffPBBoseuXr2KsbEx06ZNAyA6Opphw4ZRrFgxLCwscHBwoFKlSvz000+JXq+X7dq1i7p161KoUCEsLS0pWrQobdu2JTo6Otm4NBoN33//PU+fPtVdp4TrEhMTw+jRoylWrBhmZma4u7szYMCARE0bCVWd69ato0KFClhYWDB+/Pgkz/f8+XOmTZuGr68vI0aMSPS4i4sLkyZN4u7du3rVZsk1HdStW5e6devqbTt37hyNGzfGysoKR0dH+vbty+PHj5OMZ8eOHbz99tvY2tpiZWVFjRo1DK6Ce/jwIe+88w579+7l119/TZSgr1+/TpcuXXB2dsbc3BxfX1+mT5+u975K+ExMnTqViRMnUqxYMczNzQkODgbgyJEjtGjRAgcHBywsLKhQoQI///yz3nkSqoKDg4Pp168fjo6OFCpUiDZt2nD79m29srGxsYwYMQJXV1esrKyoWbMmhw4dSvTc0lrdnZR58+ZhYmLC2LFjUy37uhK+SFy7dg1IurpbKcW8efMoX748lpaWFCxYkHbt2vHPP//oyiQ836R+Xj5efHw8U6dOpWTJkpibm+Ps7EzXrl25efOm3jkT/q7s37+f6tWrY2lpiZeXF4sXLwbg999/56233sLKygo/Pz+CgoISPbeLFy/SqVMnvffPN998oxdz5cqVAejRo4cu3nHjxunKGPL+2bZtGz179sTJyQkrKyuePXuW5Gu+d+9eXFxcdAk6QfPmzYmKitJ7LuvXr8fHx0eXoAFMTEzo0qULhw4d0muqSEpGvI4pyu5b+cxy48YN9eGHHypArVu3Tu3fv19XNXbs2DHl7e2tKlSooNueUP2UUFX4ctXM2LFjFaB8fHzUhAkT1Pbt29WIESMUoAYOHKhKliypZs+erbZv36569OihALV27dpUYxwyZIiaP3++CgoKUrt27VJff/21cnR0VD169NArV6dOHVWoUCH15ptvqgULFqjt27er/v37K0AtWbJEV+7Ro0eqe/fuatmyZWrXrl0qKChIDRs2TBkZGemVUypx1eGQIUOUtbW1evTokV654cOHKwsLCxUeHq6UUuqDDz5QVlZWasaMGSo4OFht2rRJTZ48Wc2ZMyfR65XgypUrysLCQjVo0ED9+uuvKiQkRK1YsUIFBgaqhw8fJvv67N+/XzVt2lRZWlrqrlNYWJiKj49XjRo1UiYmJuqzzz5T27ZtU1999ZWytrZWFSpUUDExMXrP083NTXl7e6sffvhBBQcHq0OHDiV5vn379ilAjRw5MtmYHj9+rIyMjFSjRo2SfS0T1KlTR69J5c6dO8rZ2Vm5u7urxYsXq82bN6vOnTurokWLJqruXrZsmdJoNKpVq1Zq3bp1auPGjap58+bK2NhY7dixI9n4lPrvPTx06FBVpkwZZWdnp/78889E5cLCwpS7u7tycnJSCxYsUEFBQWrgwIEKUP369Ut0PHd3d1WvXj21Zs0atW3bNnXlyhW1a9cuZWZmpmrVqqVWr16tgoKCVPfu3RN9hhKqgr29vdWHH36otm7dqr7//ntVsGBBVa9ePb24unXrpjQajRo+fLjatm2bmjFjhnJ3d1e2trZ6r3NSzQSvvvcSrk9CdXd8fLz6+OOPlampaYZXvyY8x8OHD+ttnzVrlgLUd999p3t+np6eemV69+6tTE1N1ccff6yCgoLUypUrVcmSJZWLi4u6c+eOUuq/6v2Xf5YuXapMTU1V06ZNdcfq06eP7m9TUFCQWrBggXJyclIeHh7q3r17unIJf1d8fHzUokWL1NatW1Xz5s0VoMaPH6/8/PzUTz/9pDZv3qyqVaumzM3N1a1bt3T7nzlzRtnZ2Sk/Pz+1dOlStW3bNvXxxx8rIyMjNW7cOF3MCa/Lp59+qov7xo0bSill8PvH3d1d9enTR23ZskWtWbNGvXjxIslr0bBhQ1W0aNFE27/99lsFqNGjR+u2ubq6qvbt2ycqu2nTJgWorVu3JnmOjHodU5Nnk7RS6WuTTilJv9qWUb58ed2XgASxsbHKyclJtWnTxqBY4+LiVGxsrFq6dKkyNjZWDx480D1Wp04dBaiDBw/q7VOqVCm9ZPGqFy9eqNjYWNWrVy9VoUIFvcdeTSyXL19WRkZG6uuvv9Zte/r0qSpUqJDel4YyZcqoVq1apfhcXv1DuWbNGgWov/76K8X9ktKtWzdlbW2tty0oKEgBaurUqXrbV69erffHUCnt8zQ2Nlbnz59P9VyrVq1SgFqwYEGK5VxcXJSvr6/eOdKSpEeOHKk0Gk2i16FBgwZ6ySYqKko5ODiod999V69cXFycKleunKpSpUqK8SW8hxN+tm3blmS5UaNGJfm+6tevn9JoNLrXLOF4xYsXV8+fP9crW7JkSVWhQgUVGxurt7158+bKzc1NxcXFKaX++yPbv39/vXJTp05VgAoNDVVKKXX27FkFqCFDhuiVW7FihQJeK0lHR0ertm3bKjs7u1S/6KRHwnM8cOCAio2NVY8fP1abNm1STk5OqkCBArpk+2qS3r9/f5J/X27cuKEsLS3ViBEjkjzf3bt3lbe3typdurTuy27C6/fq63zw4EEFqDFjxui2JfxdOXLkiG7b/fv3lbGxsbK0tNRLJH/99ZcC1OzZs3XbGjVqpIoUKaLXJ0AppQYOHKgsLCx0f8NSapM29P3TtWvXJF+LVw0ePFgZGRmpa9eu6W0PDAxUgOrTp49um6mpqfrggw8SHSPhS/vKlStTPNfrvo6pybPV3Znh1R6ivr6+aDQamjRpottmYmLCG2+8oavaSsnx48dp0aIFhQoVwtjYGFNTU7p27UpcXBwXLlzQK+vq6kqVKlX0tpUtWzbReX755Rdq1KiBjY0NJiYmmJqasmjRIs6ePZtiLN7e3jRv3px58+ah/l1ifOXKldy/f1+vPbhKlSps2bKFUaNGERISwtOnT1N9nuXLl8fMzIw+ffqwZMkSvSq89Ni1axdAoirm9u3bY21tnahKuGzZspQoUeK1zvkypVS6eq8HBwdTunRpypUrp7e9U6dOer/v27ePBw8e0K1bN168eKH7iY+Pp3Hjxhw+fJioqKhUz9eoUSPMzc0ZOnQo9+7dS/T4rl27KFWqVKL3Vffu3VFK6V7nBC1atMDU1FT3+6VLlzh37hydO3cG0Iu1adOmhIaGcv78+UTHeFnZsmWB/6qCE6rQE46ZoEOHDpiYpL8Lzf3796lfvz6HDh1iz549vP3226nuEx8fr/ec4uLi0nSuatWqYWpqSoECBWjevDmurq5s2bIFFxeXJMtv2rQJjUZDly5d9M7n6upKuXLlkuz1HxUVRbNmzYiJiWHLli269tWE1+/Vz0aVKlXw9fVN9Nlwc3PTqxJ2cHDA2dmZ8uXLU7hwYd12X19f4L/rFBMTw86dO2ndujVWVlaJrn1MTAwHDhxI8XVKz/unbdu2KR4zQZ8+fTA1NaVz586cOXOG+/fv880337B69WoAjIz0U19Kn+e0fNbT+zqmhSRpAzg4OOj9bmZmhpWVFRYWFom2x8TEpHis69evU6tWLW7dusWsWbP4888/OXz4sK4959XkV6hQoUTHMDc31yu3bt06OnTogLu7O8uXL2f//v0cPnyYnj17phoPwEcffcTFixfZvn07oG0z9/f356233tKVmT17NiNHjuTXX3+lXr16ODg40KpVKy5evJjscYsXL86OHTtwdnZmwIABFC9enOLFizNr1qxUY0rK/fv3MTExwcnJSW+7RqPB1dWV+/fv6213c3NL03GLFi0KwJUrV5ItExUVRXh4OB4eHgZGrY3b1dU10fZXt929exeAdu3aYWpqqvczZcoUlFI8ePAg1fO98847rF+/nosXL1KvXj3CwsISxZPUa5PwRyW11zEhzmHDhiWKs3///gCEh4fr7fPq+zih41nC+zjhnK++JiYmJkl+BtLqwoULHDx4kCZNmlCmTJk07fP555/rPae0dvhaunQphw8f5vjx49y+fZuTJ09So0aNZMvfvXsXpRQuLi6JXscDBw4keg1fvHhBu3btuHDhAps3b9Z7Lya8fsld11ev6at/00D79yupv3WA7u/I/fv3efHiBXPmzEkUc9OmTYHE1z6p5w2GvX/S+ln29fVl/fr1XLt2jTJlyuDo6MiUKVOYPn06AO7u7rqyhQoVSvS6ALrPWFKv0avS+zqmhfTuzia//vorUVFRrFu3Dk9PT9321xlLuHz5cooVK8bq1av1vv0l17niVfXr16dMmTLMnTsXGxsbjh07xvLly/XKWFtbM378eMaPH8/du3d1d9Xvvvsu586dS/bYtWrVolatWsTFxXHkyBHmzJnD4MGDcXFxMbi3caFChXjx4gX37t3TS9RKKe7cuaPrqJIgrXe9FStWpGDBgmzYsIFJkyYlud+GDRuIj4+nQYMGum0WFhZJvsbh4eE4OjrqxX3nzp1E5V7dlrDPnDlzkh1pkNxd2auaNGnCb7/9RqtWrahXrx67du3S7VuoUCFCQ0MT7ZPQkevl2CHx65jw+OjRo2nTpk2S5/fx8UlTnAkSEvGdO3f0/pC+ePEiyT+kaeXv70/79u3p1asXoO39++rd1Kv69OmjV3uW1p7svr6+ut7daeHo6IhGo+HPP/9M8hyvbuvTpw87d+5k8+bNiWplEl6/0NDQRL3cb9++neiaplfBggUxNjYmMDCQAQMGJFmmWLFiKR4jPe8fQ2qwmjRpwrVr17h06RIvXrygRIkSug5ptWvX1pXz8/Pj1KlTifZP2JbWL3WZJU8n6Ve/pb/6WFqqajNLwpvt5Q+gUoqFCxe+1jHNzMz03sh37txJtXf3ywYNGkTfvn2JiIjAxcWF9u3bJ1vWxcWF7t27c+LECWbOnEl0dDRWVlYpHt/Y2JiqVatSsmRJVqxYwbFjxwxO0m+//TZTp05l+fLlDBkyRLd97dq1REVFpakqMylmZmYMHz6cMWPGMG3atEQ9vMPCwhg9ejQuLi68//77uu1eXl6cPHlSr+yFCxc4f/683h/FevXqMXXqVE6cOKH3x3XlypV6+9aoUQN7e3v+/vvvDBl61qhRI3777TdatmypS9Surq68/fbbTJo0iWPHjunVlixduhSNRkO9evVSPK6Pjw9vvvkmJ06c4Msvv3ztOAFdb/gVK1boVR/+/PPPvHjx4rWO3a1bN6ytrenUqRNRUVEsWbIEY2PjZMsXLlxYr6oyszRv3pzJkydz69YtOnTokGLZTz/9lMWLF7NkyRLeeeedRI/Xr18f0H5hf/nL6uHDhzl79iyffPJJhsRsZWVFvXr1OH78OGXLltXdISYlub/DmfH+eZVGo+HNN98EtKM3Zs2aRfny5fWSdOvWrenfvz8HDx6katWqgPZL4fLly6latWqWvAdSkqeTtJ+fHwCzZs2iW7dumJqa4uPjQ4ECBfDz82PVqlWsXr0ab29vLCwsdOWzQoMGDTAzM6Njx46MGDGCmJgY5s+fz8OHD9N9zIShRv3796ddu3bcuHGDCRMm4ObmlmJ19Mu6dOnC6NGj+eOPP/j0008TffiqVq1K8+bNKVu2LAULFuTs2bMsW7YMf3//ZBP0ggUL2LVrF82aNaNo0aLExMTwww8/ACT5hyY1DRo0oFGjRowcOZLIyEhq1KjByZMnGTt2LBUqVCAwMNDgYyYYOXIkJ06c0P0bEBCAnZ0dJ0+eZNq0aTx+/JhNmzZhZ2en2ycwMJAuXbrQv39/2rZty7Vr15g6dWqi6vjBgwfzww8/0KxZMyZOnIiLiwsrVqxIVANhY2PDnDlz6NatGw8ePKBdu3Y4Oztz7949Tpw4wb1795g/f75Bz6thw4Zs2LBBL1EPGTKEpUuX0qxZMz7//HM8PT35/fffmTdvHv369UtTO/63335LkyZNaNSoEd27d8fd3Z0HDx5w9uxZjh07xi+//GJQnL6+vnTp0oWZM2diamrKO++8w+nTp/nqq6+wtbU16FhJadeuHVZWVrRr146nT5/y008/pZhgskKNGjXo06cPPXr04MiRI9SuXRtra2tCQ0PZs2cPfn5+9OvXj19++YUvvviCdu3aUaJECb02X3NzcypUqICPjw99+vRhzpw5GBkZ0aRJE65evcpnn32Gh4eH3pfa1zVr1ixq1qxJrVq16NevH15eXjx+/JhLly6xceNGXZ+G4sWLY2lpyYoVK/D19cXGxkb3BSij3z8v+/DDD3XDPv/55x9mz57NzZs32b17t165nj178s0339C+fXsmT56Ms7Mz8+bN4/z58+zYseO1XqMMkeYuZrnU6NGjVeHChZWRkZFeT9CrV6+qhg0bqgIFCihA19sypd7dLw9fUCrpnsdKaXv7lS5dOtXYNm7cqMqVK6csLCyUu7u7Gj58uNqyZUuiHqvJHS+poRyTJ09WXl5eytzcXPn6+qqFCxcm2+M1uRnHunfvrkxMTNTNmzcTPTZq1ChVqVIlVbBgQWVubq68vb3VkCFDdEO0lErcw3b//v2qdevWytPTU5mbm6tChQqpOnXqqA0bNqT6GiX3Gj99+lSNHDlSeXp6KlNTU+Xm5qb69euXaEhXemabio+PVytWrFB169ZV9vb2yszMTBUrVkz169cvUW/RhPJTp05V3t7eysLCQlWqVEnt2rUrUe9upZT6+++/VYMGDZSFhYVycHBQvXr1Ur/99luSM47t3r1bNWvWTDk4OChTU1Pl7u6umjVrpn755ZcU409qxrEEO3bsUJaWlsrHx0fdunVLXbt2TXXq1EkVKlRImZqaKh8fHzVt2jRdr9rUjqeUUidOnFAdOnRQzs7OytTUVLm6uqr69evr9ZJPbnhSUj20nz17pj7++GPl7OysLCwsVLVq1dT+/fsTvWfTMwTr5X1tbGxU48aNVXR0dLKvpSGSe46vSupzq5RSP/zwg6pataqytrZWlpaWqnjx4qpr1666XsMJzy2pn5ePFxcXp6ZMmaJKlCihTE1NlaOjo+rSpYtu2FOC5P6uJPeZAdSAAQP0tl25ckX17NlTubu7K1NTU+Xk5KSqV6+uJk6cqFfup59+UiVLllSmpqYKUGPHjtU99jrvn5S0bNlSubm56Y7ZvXt3dfXq1STL3rlzR3Xt2lU5ODjo3nPbt29P03ky4nVMiebfnYQAtFVCXl5e1KxZM9GEAkLkdEOGDGHZsmWpdloSIrfI09XdIu3u3bvH+fPnWbx4MXfv3mXUqFHZHZIQaRYWFsb+/ftZt26d3sxRQuR2MgRLANqp62rVqsWWLVuYN2+eXkciIXK6zZs307lzZ9588810D+0TIieS6m4hhBAih5I7aSGEECKHkiQthBBC5FCSpIUQQogcSnp3pyI+Pp7bt29ToECBdC2qIIQQIm9QSvH48WMKFy6c6rSyGUWSdCpu376drsUUhBBC5E03btxINDd6ZpEknYoCBQoA2oti6LSEsbGxbNu2jYYNG+ot8SfyB7n++Ztc/7wnMjISDw8PXV7ICrkuSc+bN49p06YRGhpK6dKlmTlzJrVq1Uq2/O7duxk6dChnzpyhcOHCjBgxgr59+6b5fAlV3La2tulK0lZWVtja2sqHNB+S65+/yfXPu7Ky6TNXdRxbvXo1gwcP5pNPPuH48ePUqlWLJk2acP369STLX7lyhaZNm1KrVi2OHz/OmDFjGDRoEGvXrs3iyIUQQgjD5aokPWPGDHr16sX777+Pr68vM2fOxMPDI9kVgRYsWEDRokWZOXMmvr6+vP/++/Ts2ZOvvvoqiyMXQgghDJdrqrufP3/O0aNHE80p3bBhQ/bt25fkPvv376dhw4Z62xo1asSiRYuIjY1Nsgrq2bNnPHv2TPd7ZGQkoK26io2NNSjmhPKG7ifyBrn++Ztc/7wnO65lrknS4eHhxMXF4eLiorfdxcWFO3fuJLnPnTt3kiz/4sULwsPDcXNzS7TPpEmTGD9+fKLt27ZtS3a95NRs3749XfuJvEGuf85kYpL5f/5MTEwIDg7O9POIjBEXF0dKM2VHR0dnYTRauSZJJ3i1wV4plWIjflLlk9qeYPTo0QwdOlT3e0JvvoYNG6ar49j27dtp0KCBdBzJh+T650zPnz/nxo0bxMfHZ+p5lFLExMRgYWEhcyzkIra2tjg7Oyd5zRJqVrNSrknSjo6OGBsbJ7prDgsLS3S3nMDV1TXJ8iYmJhQqVCjJfczNzTE3N0+03dTUNN1/aE1NTQmPfsGV8CiKOVrjZmeZruOI3Ol13jsiYymluH37NiYmJpk+IUV8fDxPnjzBxsYmyya+EOmnlCI6OpqwsDCMjY2TrGnNjs9xrknSZmZmVKxYke3bt9O6dWvd9u3bt9OyZcsk9/H392fjxo1627Zt20alSpWy9MX+5ehNPv3tb+IVGGlgUhs/AioXNegYoRFPJckL8ZpevHhBdHQ0hQsXTnfzVVrFx8fz/PlzLCwsJEnnEpaW2r+tYWFhODs7Y2xsnM0R5aIkDTB06FACAwOpVKkS/v7+fPfdd1y/fl037nn06NHcunWLpUuXAtC3b1/mzp3L0KFD6d27N/v372fRokX89NNPWRbzo2cw/t8EDRCvYMy609Qu4ZTmZLv68HVGrzull+Rrl3CSpC2EgeLi4gDtl34hkpLw5S02NlaStKECAgK4f/8+n3/+OaGhoZQpU4bNmzfj6ekJQGhoqN6Y6WLFirF582aGDBnCN998Q+HChZk9ezZt27bNspjvxWh0CTpBnFJcDY9OU3INjXiqS9CgTfKj1p5Co+G17syFyM+kjVgkJ6e9N3JVkgbo378//fv3T/KxH3/8MdG2OnXqcOzYsUyOKnlOFgqjfxNqAmONBi/HtFW1XQmPSpTkFaBe485cCCFE7iANJZnM3hwmtiyF8b/fzow1Gr5sUybNCbWYozVGqXyxS7gzF0LkTyEhIWg0Gh49epTdoYgMJkk6C7SvWIQ9o+rxU+9q7BlVz6CqaTc7Sya18dMleSPg1ZxtyJ25EEJkBEO+GPz888+UL18eKysrPD09mTZtWqIyu3fvpmLFilhYWODt7c2CBQsyIercJ9dVd+dWbnaW6a6ODqhclNolnLgaHo2XoxV/XLjHmHWniVPK4DtzIYTISlu2bKFz587MmTOHhg0bcvbsWd5//30sLS0ZOHAg8N86C71792b58uXs3buX/v374+TklKV9iHIiuZPOCk/uwq4v4M6p/xqTDeRmZ4l/8UK42VkSULmowXfmoRFP2Xc5nNCIp+k6vxBCX1Z+pp49e8agQYNwdnbGwsKCmjVrcvjw4UTl9u7dS7ly5bCwsKBq1aqcOnVK99i1a9d49913KViwINbW1pQuXZrNmzcne87ly5dTqVIlChQogKurK506dSIsLAyAq1evUq9ePQAKFiyIRqOhe/fuSR5n2bJltGrVir59++Lt7U2zZs0YOXIkU6ZM0U0ulZ51FhLu5Ldu3UqFChWwtLSkfv36hIWFsWXLFnx9fbG1taVjx47ZMlNYRpE76SxgdO53+GOq9qdgMSjVAnxbgvtbkM6ehIbcmSc1hEt6gwuRfln9mRoxYgRr165lyZIleHp6MnXqVBo1asSlS5dwcHDQlRs+fDizZs3C1dWVMWPG0KJFCy5cuICpqSkDBgzg+fPn/PHHH1hbW/P3339jY2OT7DmfP3/OhAkT8PHxISwsjCFDhtC9e3c2b96Mh4cHa9eupW3btpw/fx5bW1vdGONXPXv2LNGYdEtLS27evMm1a9fw8vJK1zoLCcaNG8fcuXOxsrKiQ4cOdOjQAXNzc1auXMmTJ09o3bo1c+bMYeTIkWl5qXMcuZPOAqpQcSjZHEws4OEV2DsLvq8PX5eGLSPh6l6Ij8uUcyc1hGvMutNyRy1EOmX1ZyoqKor58+czbdo0mjRpQqlSpVi4cCGWlpYsWrRIr+zYsWNp0KABfn5+LFmyhLt377J+/XoArl+/To0aNfDz88Pb25vmzZtTu3btZM/bs2dPmjRpgre3N9WqVWP27Nls2bKFJ0+eYGxsrPty4OzsjKurK3Z2dkkep1GjRqxbt46dO3cSHx/PhQsXmDlzJqAdNgupr7OQkokTJ1KjRg0qVKhAr1692L17N/Pnz6dChQrUqlWLdu3a5er50yVJZwFVrA68twKGX4b2P0LpNmBmA5G34OAC+LEpTC8JGwfD5V0Ql3ErrSQ1hOvl3uBSDS6EYVL7TGW0y5cvExsbS40aNXTbTE1NqVKlCmfPntUr6+/vr/u/g4MDPj4+ujKDBg3SJbSxY8dy8uTJFM97/PhxWrZsiaenJwUKFKBu3boAenNRpEXv3r0ZOHAgzZs3x8zMjGrVqvHee+8B6E0WYug6CwnKli2r+7+LiwtWVlZ4e3vrbUuops+NJElnJXMbKN0a2i/WJuz3foJyHcHCDqLC4OhiWNYavnoTfu0P54PgxbPUj5uCpIZwJfQGX334OjUm76LTwoPUmLyL1YcN+/AJkR+l9JnKDMklq9QWF0qQUOb999/nn3/+ITAwkFOnTlGpUiXmzJmT5D5RUVE0bNgQGxsbli9fzuHDh3V35M+fPzcofo1Gw5QpU3jy5AnXrl3jzp07VKlSBQAvLy8gfessJHi5Klyj0SSqGtdoNJm+mEpmkiSdXUwtoGRTaL0Ahl2CLmvhrW5g5QhPH8JfK+CnAJhaHNb0hDO/wnPDv6m/OoQroTc4INXgQqRDcp+pzBph8cYbb2BmZsaePXt022JjYzly5Ai+vr56ZQ8cOKD7/8OHD7lw4QIlS5bUbfPw8KBv376sW7eOjz/+mIULFyZ5znPnzhEeHs7kyZOpVasWJUuWTHQ3mjC1asJUq6kxNjbG3d0dMzMzfvrpJ/z9/XF2dga0NQCvLumaHess5ETScSwnMDGDN97R/jT/Gq7tg7Mb4OxGeBwKp9dqf8wKQKmWUC4APGtCGiftf3UIl5udJfsuh7/WdKVC5GdJfaYyi7W1Nf369WP48OE4ODhQtGhRpk6dSnR0NL169dIr+/nnn1OoUCFcXFz45JNPcHR0pFWrVgAMHjyYJk2aUKJECR4+fMiuXbsSJfkERYsWxczMjDlz5tC3b19Onz7NhAkT9Mp4enqi0WjYtGkTTZs2xdLSMsmOaOHh4axZs4a6desSExPD4sWL+eWXX9i9e7euTE5YZyGnkjvpnMbIGIrVgqbTYMjf0GsHVP8Q7IrC88fw13JY8i7M9IOdn8ODf9J02JeHcEHWV9kJkde8+pnKTJMnT6Zt27YEBgby1ltvcenSJbZu3UrBggUTlfvoo4+oWLEioaGhbNiwQe+Od8CAAfj6+tK4cWN8fHyYN29ekudzcnLixx9/5JdffqFUqVJMnjw50XAod3d3xo8fz6hRo3BxcdGNeU7KkiVLqFSpEjVq1ODMmTOEhIToqrzhv3UWQkJCKF++PBMmTMjydRZyKo1S6Ry4m09ERkZiZ2dHREQEtra2Bu0bGxvL5s2badq06etX2cTHw40DcGKVtur7WcR/jxWrra0qL9lcW42eRqsPX080KYoMzco4GXr9RYaIiYnhypUrFCtWDAuLtH9W0iM+Pp7IyEhsbW1lqcpcJKX3yOvkg/SS6u7cwsgIPKtrf5pMhQtb4NgybW/wK39ofywLQtn34K2u4FIq1UOmtcpO1rIWQojsIUk6NzK10PYSL90aHl2H48u1P5G34OB87U+RytpkXbqNtld5MlKbFEUmQhFCiOwjdTC5nX1RqDcGBp+Czmu0Vd5GJnDzMGz4EKb7wIZBcPOowVOSykQoQgiRveROOq8wMoY3G2h/Ht+FEz/BsaXw4DIcW6L9cSsHVfpAmbZgmnq1dUqTNki1txBCZD65k86LCrhAzcHw4VHo/jv4dQBjcwg9Ab8NgBmlYPtYbVV5CtLSA1xmLBNCiMwjSTov02jAqya0XQhDz8I748DOA54+gL0zYVY5+KkTXA5Osio8tUkbZMYyIYTIXFLdnV9YF4KaQ6D6ILgQBAe/hSu74fzv2h/n0uA/APzagYm5brfkeoAn115du4STVIULIUQGkTvp/MbIGEo2g24bYMAhqPw+mFpD2Bn4rT98XQZ2T4Oo+7pdkpq0IasXGRBCiPxIknR+5uQDzabD0DPwzngoUFi70EfwRO0ympuGQPjFJHdNqb1a2qmFECJjSJIW2klQag6GwSehzUJtL/AXT+HIDzC3EqwMgKt79Nqtk2uv/uPCPWmnFiIb1a1bl8GDB2d3GCKDSJIW/zE2hbIdoM9uba9wn6aARtuG/WMzWNQAzm7STlGKtr16z6h6/NS7GntG1aN2CScZVy1EJkgq8YaEhKDRaHj06JHe9nXr1iVaDCMr/Pjjj9jb26ep7DfffIOvry+Wlpb4+PiwdOnSRGXWrl1LqVKlMDc3p1SpUrqlMvMbSdIisYRe4R1/goFHoFJP7RCum4dhdWeYVxWOr4AXz/Xaq6WdWojs5+DgQIECBbI7jGTNnz+f0aNHM27cOM6cOcP48eMZMGAAGzdu1JXZv38/AQEBBAYGcuLECQIDA+nQoQMHDx7MxsizhyRpkTLHN7TLZw45DbU+BnM7CL+g7WQ2uzzsnwfPngCyspYQmaF79+7s3r2bWbNmodFo0Gg0XL16lXr16gFQsGBBNBoN3bt3BxLfdXt5eTFx4kS6du2KjY0Nnp6e/Pbbb9y7d4+WLVtiY2ODn58fR44cSTGOGTNm4Ofnh7W1NR4eHvTv358nT7Sf/ZCQEHr06EFERIQuxnHjxiV5nGXLlvHBBx8QEBCAt7c37733Hr169WLKlCm6MjNnzqRBgwaMHj2akiVLMnr0aN5++21mzpyZbHwJd/KbNm3Cx8cHKysr2rVrR1RUFEuWLMHLy4uCBQvy4YcfpnkN7JxAkrRIGxtnePt/2mTd4HOwcdHOFb51NMwsA7un4mb2LMVx1ULkOErB86jM+4mNTv6xNE7TO2vWLPz9/enduzehoaGEhobi4eHB2rVrATh//jyhoaHMmjUr2WN8/fXX1KhRg+PHj9OsWTMCAwPp2rUrXbp04dixY7zxxht07dqVlBZFNDIyYvbs2Zw+fZolS5awa9cuRowYAUD16tWZOXMmtra2uhiHDRuW5HGePXuWaHUpS0tLDh06RGxsLKC9k27YsKFemUaNGrFv374UX6vo6Ghmz57NqlWrCAoKIiQkhDZt2rB582Y2b97MsmXL+O6771izZk2Kx8lJZJy0MIyFLdT4CKp8ACdXwd7Z2qlHg7+AvbMJqNKbuoN68k+0VYorawmRI8RGw5eFM+XQRoB9SgXG3AYz61SPY2dnh5mZGVZWVri6uuq2Ozg4AODs7JxqW3DTpk354IMPAPjf//7H/PnzqVy5Mu3btwdg5MiR+Pv7c/fuXb1zvOzlu/NixYoxYcIE+vXrx7x58zAzM8POzg6NRpPs/gkaNWrE999/T6tWrXjrrbc4evQoP/zwA7GxsYSHh+Pm5sadO3dwcXHR28/FxYU7d+6keOzY2Fjmz59P8eLFAWjXrh3Lli3j7t272NjYUKpUKerVq0dwcDABAQEpHiunkDtpkT6mFlCxOww8DO1+AOdS8Pwx7JmByw9V8L80AzfjJ9kdpRACKFu2rO7/CcnPz88v0bawsLBkjxEcHEyDBg1wd3enQIECdO3alfv37xMVFWVQLJ999hlNmjShWrVqmJqa0rJlS11VvbGxsa6cRqPfdqaUSrTtVVZWVroEnfC8vLy8sLGx0duW0vPMaeROWrweI2Ptgh2lWmvXuP5jGtw+DvvnaodwVX5fe+dt7ZjiYWTNapEtTK20d7SZID4+nsjHj7EtUAAjoyTuh0yzrq+Gqamp7v8JiS6pbfH/jtx41bVr12jatCl9+/ZlwoQJODg4sGfPHnr16qWrok4rS0tLfvjhB7799lvu3r2Lm5sb3333HQUKFMDRUft3wtXVNdFdc1hYWKK765SeZ8LzSmpbcs8zJ5IkLTKGkZF2JjOfpnBpJ4R8CbeOwr7ZcHgRVOmtnZLUulCiXWXNapFtNJo0VTmnS3w8mMZpj59UkjaAmZlZos5OZmZmAFnSCerIkSO8ePGC6dOn675w/Pzzz6nGmBJTU1OKFCkCwKpVq2jevLnu2P7+/mzfvp0hQ4boym/bto3q1au/7lPJdaS6W2QsjQbefAfe3wmdfobCFSA26t8FPcrCjvEQ/UBXXNasFiJ1Xl5eHDx4kKtXrxIeHk58fDyenp5oNBo2bdrEvXv3dD2tM0Px4sV58eIFc+bM4Z9//mHZsmUsWLAgUYxPnjxh586dhIeHEx2d9NDLCxcusHz5ci5evMihQ4d47733OH36NF9++aWuzEcffcS2bduYMmUK586dY8qUKezYsSNfTtIiSVpkDo0GSjSC3sHQcRW4loXnT2DPDJhZFnZOgOgHMrZaiDQYNmwYxsbGlCpVCicnJ65fv467uzvjx49n1KhRuLi4MHDgwEw7f/ny5ZkxYwZTpkyhTJkyrFixgkmTJumVqV69On379iUgIAAnJyemTp2a5LHi4uKYPn065cqVo0GDBsTExLBv3z68vLz0jrVq1SoWL15M2bJl+fHHH1m9ejVVq1bNtOeYU2lUSn3uBZGRkdjZ2REREYGtra1B+8bGxrJ582aaNm2aqF0k31EKzm+GkElw55R2m7ktj8v3otYfvjxS/3XsMNZo2DOqXq5vm5brn/PExMRw5coVihUrlmgYUEaLj48nMjISW1vbpNukRY6U0nvkdfJBesk7R2QNjUbbZt3nDwhYDi5l4FkkBQ5+zSHrjxlishZbomRstRBCvESStMhaRkbg+y588Cd0WArOpTB78ZiPTNZyzPZjjtc/TUA5becyWU1LCJHfSe9ukT2MjKBUSyj5Lpz9DUImY3LvHLZ7v4C/FnLUqxedj5UkRplKj28hRL4ld9IiexkZQenW0G8ftP4O7D0hKoyKZyaxw+xj2hr9ASpeenwLIfIlSdIiZzAyhnIBMPAIl6tO4K6yp4gmnOlmC9hsNprammNcvWfYzEZCJEf6y4rk5LT3hiRpkbOYmGFVvTd1n8/ky9iOPFLWlDS6wWKzabwV3BluHMruCEUuljDt5PPnz7M5EpFTJYzvzikjMqRNWuQ4bnaWjGtTkTHrzFn1rB79TTbxvtlWzG8dgEUNoGRzeHssOJXI7lBFLmNiYoKVlRX37t3D1NQ0U4dGxcfH8/z5c2JiYmQIVi6glCI6OpqwsDDs7e315hHPTpKkRY4UULkotUs4cTU8Gi/HFpjwQDvG+q8VcG6Tdsx1hUCoOwpsM2cVI5H3aDQa3NzcuHLlCteuXcvUcymlePr0KZaWlqkuDCFyDnt7+1RX8spKkqRFjuVmZ/nSeGl3aDkX/AfCzs/h/O9wbAmcXA3V+kGNwYQ+N5dFOkSqzMzMePPNNzO9yjs2NpY//viD2rVr55iqU5EyU1PTHHMHnUCStMhdnEtCx5Vw/QBsHws3DsCer3l2cBE/PH2XpS8aEKsxkyFbIkVGRkaZPuOYsbExL168wMLCQpK0SDdpKBG5U9Fq0DMIOq4i1qEE5rGRfGKygl3mH9NCs4dP1p2UIVtCiFxPkrTIvTQa8GnC4SabGB7bh9vKAXfNfWaazWOd6ac8OBOc3REKIcRrkSQtcr1izrasja9LvWczmBobwGNlSVmjK5Te1hF+6gThF7M7RCGESJdck6QfPnxIYGAgdnZ22NnZERgYyKNHj5ItHxsby8iRI/Hz88Pa2prChQvTtWtXbt++nXVBiyzhZmfJpDZ+vNCYMy+uJW8//5qLngGgMdZ2MJtXDTYPh6jw7A5VCCEMkms6jnXq1ImbN28SFBQEQJ8+fQgMDGTjxo1Jlo+OjubYsWN89tlnlCtXjocPHzJ48GBatGjBkSNHsjJ0kQX0h2xZ4WbXEe59rO1cdmELHPoOTqyCWh9D1b5gmrmdhoQQIiPkiiR99uxZgoKCOHDggG7R74ULF+Lv78/58+fx8fFJtI+dnR3bt2/X2zZnzhyqVKnC9evXKVpUev7mNfpDtgAnH+i0Cv7ZDds+hTsnYcdYOLwI3hkLZdpq27WFECKHyhVJev/+/djZ2ekSNEC1atWws7Nj3759SSbppERERKDRaLC3t0+2zLNnz3j27Jnu98jISEBbfR4bG2tQ3AnlDd1PZDCP6tBzB5pTv2AcMhFNxHVY24tne77BuMlklPtbmXJauf75m1z/vCc7rmWuSNJ37tzB2dk50XZnZ2fu3LmTpmPExMQwatQoOnXqhK2tbbLlJk2axPjx4xNt37ZtG1ZWVmkP+iWv3tGL7FKAI9YTsHuwlX4mG7C+ewx+bMh1hxqcLdyBGNOCmXJWuf75m1z/vCNhXu+slK1Jety4cUkmxJcdPnwYIMlp9ZRSaZpuLzY2lvfee4/4+HjmzZuXYtnRo0czdOhQ3e+RkZF4eHjQsGHDFJN7cufdvn07DRo0kMkMcoDQiBiGTP+DeNWan+PqMsJ0Ne2M/6Dog714PP6L+BqDia/aD0wypr1arn/+Jtc/70moWc1K2ZqkBw4cyHvvvZdiGS8vL06ePMndu3cTPXbv3j1cXFxS3D82NpYOHTpw5coVdu3alWqiNTc3x9zcPNF2U1PTdH/QXmdfkXFuRkQQ/+8qdGEUZFhsX5a9eIfl7uspEH4c45AvMP5rGTScCL4tMqy9Wq5//ibXP+/IjuuYrUna0dERR0fHVMv5+/sTERHBoUOHqFKlCgAHDx4kIiKC6tWrJ7tfQoK+ePEiwcHBFCpUKMNiF7lPMUdrjDToEjXAad7kSZfNFLi+SdsT/NF1+LkreNaExpPArWz2BSyEyPfSlKTfesuwjjUajYYNGzbg7u6erqBe5evrS+PGjenduzfffvstoB2C1bx5c71OYyVLlmTSpEm0bt2aFy9e0K5dO44dO8amTZuIi4vTtV87ODhgZmaWIbGJ3CNhPPWYdaeJUwpjjYYv25TBzd4K7DtAyWawd5b259oe+LY2VOwG9T8D69S/TAohREZLU5L+66+/+Pjjj7GxsUm1rFKKyZMn6/WQzggrVqxg0KBBNGzYEIAWLVowd+5cvTLnz58nIiICgJs3b7JhwwYAypcvr1cuODiYunXrZmh8IndIPJ76pSFbZtZQbwxU6KK9qz6zDo7+CKfXQ50RUKUPmMiXOyFE1klzdffw4cOT7GGdlOnTp6c7oOQ4ODiwfPnyFMso9V89ppeXl97vQiRINJ76VfZFof1iqNIbgkZB6AnY9gkcXQyNvoQ3G8r4aiFElkjTtKBXrlzByckpzQf9+++/8fT0THdQQuQIntWhdzC0mAvWTnD/EqzsAMvbwr3z2R2dECIfSFOS9vT0TNNQpwQeHh45buFsIdLFyBjeCoQPj0GNj8DIFC7vhHn+sGUkRD/I7giFEHlYunp3x8TEcPLkScLCwoiPj9d7rEWLFhkSmBA5ioUtNPgc3uoG2z7TLtxxcAGcXA31PoGKPcA4V8wNJITIRQz+qxIUFETXrl0JD0+8opBGoyEuLi5DAhMiRypUHDquhMvBEDQa7p2FzcPgyA/aIVvedbM7QiFEHmLwUpUDBw6kffv2hIaGEh8fr/cjCVrkG8XrQd890PQrsCwIYX/D0pawOlA71loIITKAwUk6LCyMoUOHpjrTlxB5nrGJtgf4h8eIKt8LpTGCsxtgbhXYPRVexGR3hEKIXM7gJN2uXTtCQkIyIRQhcqfVZ57gd/BtmsR8ycH4kvDiKQR/gcm3NXB9dBRkKKAQIp0MbpOeO3cu7du3588//8TPzy/RXKaDBg3KsOCEyOlCI54yet0p4hWcoygBzz+jpfEBZhRcg/Gja1R9NIv4Vaeg6VRwfDO7wxVC5DIGJ+mVK1eydetWLC0tCQkJ0RuapdFoJEmLfOVKeJTeXOCg4bc4fzo170Ol64tg/1yM/9mlHbLl3x9qjwDz1GfuE0IISEeS/vTTT/n8888ZNWoURkYG15YLkacktWiHsUZDUTcn4ot/yu6Hhan/fBtGl3do5wQ/+Qs0mgil28isZUKIVBmcZZ8/f05AQIAkaCH4b9EO438Trm7Rjn+nHY2ycCXuvVXQcTXYe8Lj27CmJyxtAWHnsjN0IUQuYPCddLdu3Vi9ejVjxozJjHiEyHVSXLQjgU9j8K4De2fDnhlw5Q9YUAOq9oW6o8C8QNYHLoTI8QxO0nFxcUydOpWtW7dStmzZRB3HZsyYkWHBCZFbpLZoR2jEU66ER1GswiDcygVA0BjtrGX758KpNdDoCyjTVqrAhRB6DE7Sp06dokKFCgCcPn1a7zFD5vcWIr/45ehNPv3tb+IVGGlgUhs/AjquhAvbYMsIeHgF1vaCI4uh2Vfg7JvdIQshcgiDk3RwcHBmxCFEnvToGYz/N0GDtoPZmHWnqV3CCbcSDaFYbdg/B/6YDtf2wPwaUK2fVIELIYB0dBwTQqTdvRjNK0O0IE4proZHa38xtYDaw2HgIfB9F1Sctgp8bmU4vU4mQhEin0tTkm7Tpg2RkZFpPmjnzp0JCwtLd1BC5BVOFgqjV1qBjDUavByt9DfaF4WA5dBlLTh4w+NQWNMDlrWC8EtZFq8QImdJU5L+7bffuHfvHpGRkan+REREsHHjRp48eZLZsQuR49mbw8SWpZIdopXIG+9Av/1QdwwYm8M/ITDfH3ZNhOfRWRe4ECJHSFObtFKKEiVKZHYsQuRJ7SsWoZ6va8pDtF5magF1R0LZ9rB5BFzaDn9M065d3WSadjiXECJfSFOSTk9nMXd3d4P3ESKvSm2IVpIcvKHzL3BuE2wZpV0C86cA8GkKjSdDQc/MCVYIkWOkKUnXqVMns+MQQvDSeGpHa21S12i0HcqK19cuf7l/LpzfDJeDofYwqP4hmJhnd9hCiEwivbuFyCFWH75Ojcm76LTwIDUm72L14ev/PWhmDQ3GQ9+94FVLuxzmrgnaIVv/hGRbzEKIzCVJWogc4OUlL+G/8dShEU/1CzqXhG4boc1CsHaG+xdhaUvtfOCRoVkfuBAiU0mSFiIHSLzk5SvjqV+m0UDZDjDwMFT5ADRGcHqtdmz1/nkQ9yJrghZCZDpJ0kLkAAlLXr4syfHUL7O0h6ZToXcwuFeE549h62j4rg5cP5ip8QohsoYkaSFygNSWvExR4fLQawe8Owss7OHuafihIfw2AKLuZ2rcQojMZfDc3Xfv3mXYsGHs3LmTsLAw1CvTFsbFxWVYcELkJ2la8jI5RkZQsTuUbA47xsLx5dqfc79Dg8+hfBdtGSFErmJwku7evTvXr1/ns88+w83NTVa+EiIDpWs89cusHaHlN1ChK2waAmFnYMOHcHwFNP8aXEplXLBCiExncJLes2cPf/75J+XLl8+EcIQQGaJoVfhgNxxcAMGT4MYB+LYW+A+AOiO1Q7qEEDmewfVfHh4eiaq4hRA5kLGpdrKTAQe11eDxL2DvLPimKpzbnN3RCSHSwOAkPXPmTEaNGsXVq1czIRwhRIaz94D3VkDHVWBXFCJuwKqO8FNH7VSjQogcy+Dq7oCAAKKjoylevDhWVlaYmprqPf7gwYMMC04IkYF8mkCx2trFOvbN0U4v+k+Itvrbf4D2zlsIkaMYnKS//vpr6SwmRG5lZg3vjIOyAbBpKFzfp+0NfvJnbceyolWzO0IhxEvS1btbCJGzJVqo41XOvtBjM/y1ArZ9pu0F/kND7TCud8aBZcGsDlkIkQSD26Q7d+7MwoULuXDhQmbEI4R4TSku1PEyjQYqdIGBR7TjqAGO/qidXvTkzyAdRIXIdgYnaRsbG6ZPn07JkiUpXLgwHTt2ZMGCBZw7dy4z4hNCGCDNC3W8zLoQtPoGuv8OjiUg6h6s6w3LWsH9y1kStxAiaQYn6W+//ZZz585x+/ZtZsyYgZ2dHbNmzaJ06dK4ubllRoxCiDQyaKGOV3nVhL57oP6nYGKh7VQ2zx9CpsCLZ5kSrxAiZemeJ7BAgQIULFiQggULYm9vj4mJCa6urhkZmxDCQIYu1BEa8ZR9l8P/u9M2MYfaw6H/fiheH+KeQciX2nWrr/yZydELIV5lcJIeOXIk1apVw9HRkU8//ZTnz58zevRo7t69y/HjxzMjRiFEGhmyUEeKbdcO3tBlHbRd9N+61Uuaw/q+EBWeVU9HiHzP4N7d06ZNw8nJibFjx9KyZUt8fX0zIy4hRDqlZaGO5Nqua5dw+q+8RgN+7eCNd2Dn53DkBzjxE1wIkkU7hMgiBn/Cjh8/zieffMKhQ4eoXbs2rq6uBAQEMH/+fM6ePZsZMQohDORmZ4l/8ULJLtZhUNu1pT00nwG9toOLHzx9qF2048dmECafeSEyk8FJuly5cgwaNIh169Zx7949tm7dipWVFYMGDaJMmTKZEaMQIoMZ2nYNgEdl6BMCDSeCqZV2IpQFNWHHeIhNofe4ECLdDK7uBu3ddEhICCEhIfz5559ERkZSvnx56tWrl9HxCSEyQULb9Zh1p4lTKsW2az3GJtpFO0q1gi0jtFOL7pkBZ9ZpZywrXj9L4hcivzA4SRcsWJAnT55Qrlw56tatS+/evalduza2traZEZ8QIpOkpe06WfYe0PEnOLsJNg+Hh1dhWWvwaw+NJoGNU6bFLUR+YnCSXrZsmSRlIfIINztLw5Lzq3ybg3cd2PUFHPoWTv0CF7drO5ZVCJSOZUK8JoM/Qc2bN9cl6Js3b3Lr1q0MD0oIkYuYF4Amk+H9neBaFmIewcZB8GNTCJOZCIV4HQYn6fj4eD7//HPs7Ozw9PSkaNGi2NvbM2HCBOLj4zMjRgAePnxIYGAgdnZ22NnZERgYyKNHj9K8/wcffIBGo2HmzJmZFqMQ+Zr7W9A7GBp+8W/Hsv3ajmW7JkJsTHZHJ0SuZHCS/uSTT5g7dy6TJ0/m+PHjHDt2jC+//JI5c+bw2WefZUaMAHTq1Im//vqLoKAggoKC+OuvvwgMDEzTvr/++isHDx6kcOHCmRafEIJ/O5YNhAEHoURjiI/Vrl893187zagQwiAGt0kvWbKE77//nhYtWui2lStXDnd3d/r3788XX3yRoQECnD17lqCgIA4cOEDVqtr1bhcuXIi/vz/nz5/Hx8cn2X1v3brFwIED2bp1K82aNcvw2IQQSbAvCh1XwdkNsHkEPPgHlraEsu9Boy/A2jG7IxQiVzD4TvrBgweULFky0faSJUvy4MGDDAnqVfv378fOzk6XoAGqVauGnZ0d+/btS3a/+Ph4AgMDGT58OKVLl86U2ITIzxLN/f0yjQZKtYSBh6BKH0ADJ1fB3EpwfLkshSlEGhh8J12uXDnmzp3L7Nmz9bbPnTuXcuXKZVhgL7tz5w7Ozs6Jtjs7O3Pnzp1k95syZQomJiYMGjQozed69uwZz579t+JPZGQkALGxscTGxhoQNbryhu4n8oa8fv1/OXqTT3/7m3gFRhqY2LIU7SsWSVzQ2AoafImmVFuMNw9FE3YGfhtA/PEVxDWZDo5vZn3wWSCvX//8KDuupcFJeurUqTRr1owdO3bg7++PRqNh37593Lhxg82bNxt0rHHjxjF+/PgUyxw+fBgAjUaT6DGlVJLbAY4ePcqsWbM4duxYsmWSMmnSpCRj2rZtG1ZWKczGlILt27enaz+RN+TF6//oGYw7ZoxC+9mKV/DJr2eIvX4Se/Pk99MU/pjiJlvxCV2PyfV9qO9qcdGlORdd3iXeyDSLos9aefH651fR0WlY8jWDaZQyvM7p9u3bfPPNN5w7dw6lFKVKlaJ///4Gd8wKDw8nPDzlFXW8vLxYuXIlQ4cOTdSb297enq+//poePXok2m/mzJkMHToUo5fGacbFxWFkZISHhwdXr15N8nxJ3Ul7eHgQHh5u8Njw2NhYtm/fToMGDTA1zZt/gETy8vL1P/DPAwIXH0m0fXnPSlQt5pD6AR5dxzhoBEaXdwCgCr1BXJPpKM8aGR1qtsnL1z+/ioyMxNHRkYiIiCybKyRd04IWLlw4QzqIOTo64uiYegcSf39/IiIiOHToEFWqVAHg4MGDREREUL169ST3CQwM5J133tHb1qhRIwIDA5NM6gnMzc0xN098K2BqapruD9rr7Ctyv7x4/d9wtcVIg94iHcYaDcVdbNP2XJ2KQ5c1cGY9bBmJ5v4lTJa3hApdoMEEsEpDos8l8uL1z6+y4zqmKUmfPHkyzQcsW7ZsuoNJjq+vL40bN6Z37958++23APTp04fmzZvr9ewuWbIkkyZNonXr1hQqVIhChQrpHcfU1BRXV9cUe4MLIVKX7rm/X6bRQJk22vm+d4yDo4u1HcoubNVOLerXTltGiHwsTUm6fPnyaDSaRG3ACTXlL2+Li4vL4BC1VqxYwaBBg2jYsCEALVq0YO7cuXplzp8/T0RERKacXwih77Xm/n6ZpT28OxPKBsCmwXDvHKx7H06shGYzwKFYBkYtRO6SpiR95coV3f+PHz/OsGHDGD58OP7+/oB2iNT06dOZOnVq5kQJODg4sHz58hTLpNa8nlw7tBAifV537u/QiKdcCY+imKM1bp7+8MGfsHeWdgKUy7tgnj/UHQX+A8BYqoxF/pOmJO3p6an7f/v27Zk9ezZNmzbVbStbtiweHh589tlntGrVKsODFELkPasPX2f0ulO6IVyT2vgRULko1BkOpVtr76qv/gk7xsKpNdBiFrhXzO6whchSBk9mcurUKYoVS1z9VKxYMf7+++8MCUoIkbeFRjzVJWjQdkAbs+70f5OiOL4B3TZCy3lgWRDunoKFb8OWkfDscfYFLkQWMzhJ+/r6MnHiRGJi/psw/9mzZ0ycOBFfX98MDU4IkTddCY/S6xkOEKcUV8NfGoeq0UCFzjDwiLa9GgUHF8A3VeGcYXMyCJFbGTwEa8GCBbz77rt4eHjoZhg7ceIEGo2GTZs2ZXiAQoi8p5ijdZJDuLwc/5swSK+9us13/3YsGwKPrsGqjuDbAppMBVu3bHgGQmQNg5N0lSpVuHLlCsuXL9dNZhIQEECnTp2wtrbOjBiFEHlMakO4km6vfhv6H4DdU2DfHO3iHf+EwDvjoGIPMDK4YlCIHC9dk5lYWVnRp0+fjI5FCJGPJDeEK7n26tolnHCzs4IG47VjqDd+BLeOwu9D4eRqeHcWOEuTm8hbDP7qWbhwYTp16sR3333HhQsXMiMmIUQ+4WZniX/xQnrDuNLUXu3qB722a6u7zWzgxkFYUAt2ToDYGITIKwxO0tOnT8fW1pYZM2ZQsmRJ3NzceO+991iwYAFnz57NjBiFEPlIQnv1y15trwbAyBiqfgADDoJPU4iPhT+/gvnV4cqfWRewEJnI4CTdsWNHFixYwLlz5wgNDeXrr7/GxMSEDz/8kDJlymRGjEKIfCShvdr435kMU51y1K4IvLcSOiwFG1d4cBmWNIffBkB05qxxL0RWSVeb9JMnT9izZw+7d+8mJCSE48eP4+fnR506dTI6PiFEPmTwlKMaDZRqCd51Ycd4OLLov3nAG0+GMm1lHnCRKxmcpKtWrcrJkycpU6YMdevWZcyYMdSqVQt7e/tMCE8IkV8ZOuWodshWLMVqfYFb2Q6wYRCEn4e1veDEKmg2HQp6pn4gIXIQg6u7L168iJWVFd7e3nh7e/PGG29IghZCZKvVh69TY/IuOi08SI3Ju1h9tzD0/RPqfQLGZnBpO8yrBvvmQtyL7A5XiDQzOEk/ePCA4OBgatSowY4dO6hTpw6urq4EBASwYMGCzIhRCCGSlewUo1HxUGcE9NsHnjUgNhq2fQLf14fbf2VrzEKkVbpG/5ctW5ZBgwaxdu1atmzZQpMmTVi3bh0DBgzI6PiEECJFqQ7ZcnwTum2Cd2eDhR2EnoCF9WDrJ/A8KusDFsIABifp48eP8/XXX9OyZUscHByoVq0ap06d4qOPPmLDhg2ZEaMQQiQrTUO2jIygYjcYcFi7wpaKh/1ztUthXtqZtQELYQCDO45VrlyZChUqUKdOHXr37k3t2rWxtbXNjNiEECJVqU0xqqeAC7T/Ecp1hE1DtfOAL2+jnRe80Zdg7Zjl8QuREoOT9IMHDyQpCyFyFIOHbJVopJ0EZddE7cpaJ1fDxe3aRF3uPRmuJXIMg6u7JUELIXKipKYYTUpoxFP2XQ4nNMYYmkyG93eCSxl4+gB+7QvLWsGDf7ImaCFSYfCddFxcHF9//TU///wz169f5/nz53qPP3ggM/wIIXKmpFfXqgh9QrQra+2eol1Za54/1B0F/gPB2DS7wxb5mMF30uPHj2fGjBl06NCBiIgIhg4dSps2bTAyMmLcuHGZEKIQQry+ZIdqRTzVJuJaQ7XDtYrVhhcxsGMcfFcPbh3L1rhF/mZwkl6xYgULFy5k2LBhmJiY0LFjR77//nv+97//ceDAgcyIUQghXluaVtcqVBy6boCW88DCHu6egu/fhqAx8OxJlsYrBKQjSd+5cwc/Pz8AbGxsiIiIAKB58+b8/vvvGRudEEJkkDSvrqXREOrdhsPNt/LU59/hWge+0VaBX9yRdQELQTqSdJEiRQgNDQXgjTfeYNu2bQAcPnwYc3PzjI1OCCEySFpX10qYYrT98suUPtme3ZXngZ0HRFyHFW1h7fvw5F52PAWRDxnccax169bs3LmTqlWr8tFHH9GxY0cWLVrE9evXGTJkSGbEKIQQGSK1oVpJtVv33FOQvUNDcD06Aw7Oh1O/wKUd0PALKN9JhmuJTGVwkp48ebLu/+3atcPDw4O9e/fyxhtv0KJFiwwNTgghMlpKq2sl1259JVKDa+Mvwa8tbPhI21b9W3/t+Op3Z4KDd+YHLvIlg6q7Y2Nj6dGjB//8898YwqpVqzJ06FBJ0EKIXC/Vdmv3itAnGN4ZByYWcGU3zKsOe2bK6loiUxiUpE1NTVm/fn1mxSKEENkqTe3WxqZQc8hLw7Wewo6xsLAu3D6ePYGLPCtdbdK//vorQ4cOzYx4hBAiW6Wl3fpKeBTFHAvj1nUD/LUSto6BO6dgYX2o1h/qjQGNWTY9A5GXGJyk33jjDSZMmMC+ffuoWLEi1tbWeo8PGjQow4ITQojskFy7ddIzlnWGNxtC0Cg4vUa7utbZDWiaTM+GyEVeY3CS/v7777G3t+fo0aMcPXpU7zGNRiNJWgiRJyU3Y1ntEk642TlBu0Xa1bR+HwqPrmPyU3veKlgdoquCnWv2Bi9yLYOT9JUrVzIjDiGEyNFSmrFMd9ddoiF4HoBdE1EHF+DxcB9qgT80nqRN4DJcSxjI4MlMhBAiP0rzjGXmNtBkMnHdtxJh4YHm6QNY/4F23eqHV7MsXpE3pOlO2pBOYjNmzEh3MEIIkVMl9Pwes+40cUolO2NZAuX+FrtLjqeZ/T8Y/zkNLu/STi1abwxU7QfGBldkinwoTe+S48f1hxUcPXqUuLg4fHx8ALhw4QLGxsZUrFgx4yMUQogcIrWe369SGhPiawzmvldTzLcMwe7uQdj2KZxaAy1mg1u5LIpc5FZpStLBwcG6/8+YMYMCBQqwZMkSChYsCMDDhw/p0aMHtWrVypwohRAih0hpxrKk/HL0Jp/+dpV4NYj3jEP43HIVZqF/aZfBrD4Q6owCM6vUDiPyKYPbpKdPn86kSZN0CRqgYMGCTJw4kenTZciBEEIkePQMPv3t7387nGlYFVePWlFTefrmu6DiYO8smF8d/gnJ5khFTmVwko6MjOTu3buJtoeFhfH48eMMCUoIIfKCezGaRD3C7yo7/qo2CzquAlt3eHgFlraEX/tD9IPsCVTkWAYn6datW9OjRw/WrFnDzZs3uXnzJmvWrKFXr160adMmM2IUQohcyclCJd8j3KcJ9D8AlXsDGvhrBcytrG2vVirJ44n8x+AkvWDBApo1a0aXLl3w9PTE09OTzp0706RJE+bNm5cZMQohRK5kbw4TW5ZKfi5wC1to9hX03ApOJSE6HNb2gpUB8OhGNkYucgqDxwBYWVkxb948pk2bxuXLl1FK8cYbbySaHlQIIQS0r1iEer6uKfcIL1oVPviDxzunYX1wFkYXt8K8vfD2/6Dy+2BknPWBixwh3ZOZWFtbU7ZsWcqVKycJWgghUuBmZ4l/8UIp9gpfffwu5UIq0ODpFxyJLwHPn8CWEbCoIdz9OwujFTmJzDgmhBDZ7OV5wS8rd9o//x+fxfYk3swGbh2Bb2vDri8gNia7QxVZTJK0EEJks1fnBVcYsSzuHY433wo+TSE+Fv6YCgtqwrV92ReoyHKSpIUQIpslNy94Yc/i8N5KaL8EbFzg/kVY3AQ2DYGYiOwJVmQpSdJCCJHNEuYFT7IXuEYDpVvBgIPwVlftDkd+gG+qwtlN2Re0yBIyw7sQQuQAqc4LblkQWswBvw6w8SN4cBlWdwbfd6HJNLB1y57ARabKNXfSDx8+JDAwEDs7O+zs7AgMDOTRo0ep7nf27FlatGiBnZ0dBQoUoFq1aly/fj3zAxZCCAOlpRc4xWpBv71QcyhojOHsRu1d9dEfIT4e0HZE23c5nNCIp1kTuMg0ueZOulOnTty8eZOgoCAA+vTpQ2BgIBs3bkx2n8uXL1OzZk169erF+PHjsbOz4+zZs1hYWGRV2EIIkfFMLeGdsVCmDWz4EG4f195dn/yZzV4jGbjtCfEKjDQwqY0fAZWLZnfEIp1yRZI+e/YsQUFBHDhwgKpVqwKwcOFC/P39OX/+vG7JzFd98sknNG3alKlTp+q2eXt7Z0nMQgiR6Vz94P2dcHAB7JoI1/by9tW29DVqzXdxzXmhTBiz7jS1SzgZtHKXyDlyRXX3/v37sbOz0yVogGrVqmFnZ8e+fUkPR4iPj+f333+nRIkSNGrUCGdnZ6pWrcqvv/6aRVELIUQWMDIG/wHQfz8PC9fCXBPLCNOf2Wj2CeU0l4hTiqvh0dkdpUinXHEnfefOHZydnRNtd3Z25s6dO0nuExYWxpMnT5g8eTITJ05kypQpBAUF0aZNG4KDg6lTp06S+z179oxnz57pfo+MjAQgNjaW2NhYg+JOKG/ofiJvkOufv2X59bdx53HrlXw+cxKfmSzF1+gG68zGsiSuMUUsK8r7MANkx2uYrUl63LhxjB8/PsUyhw8fBkCj0SR6TCmV5HbQ3kkDtGzZkiFDhgBQvnx59u3bx4IFC5JN0pMmTUoypm3btmFllb6F2bdv356u/UTeINc/f8vq62/u6U+Df/z4xHQFbYz30NNkC9E/HuawR3fu2ZbN0ljymujorK+RyNYkPXDgQN57770Uy3h5eXHy5Mkk17C+d+8eLi4uSe7n6OiIiYkJpUqV0tvu6+vLnj17kj3f6NGjGTp0qO73yMhIPDw8aNiwIba2tinG+qrY2Fi2b99OgwYNMDU1NWhfkfvJ9c/fsuv6NwX6R8Rw/cHbhD0+iNMfY7CKuEH1y18R79eBuHcmgFUhXfnQiBiu3Y/Gs5AVbnbSqTYlCTWrWSlbk7SjoyOOjo6plvP39yciIoJDhw5RpUoVAA4ePEhERATVq1dPch8zMzMqV67M+fPn9bZfuHABT0/PZM9lbm6Oubl5ou2mpqbp/qC9zr4i95Prn79lx/Uv6mhKUccCQAsoUx+Cv4AD8zE69TNGl3dC48ng157VR27o5gyXnuCpy47Pca7oOObr60vjxo3p3bs3Bw4c4MCBA/Tu3ZvmzZvr9ewuWbIk69ev1/0+fPhwVq9ezcKFC7l06RJz585l48aN9O/fPzuehhBCZD1zG2g8Cd7fAc6lIPo+rOtNzJLWzFm3SzdneLyCMetOy9jqHCZXJGmAFStW4OfnR8OGDWnYsCFly5Zl2bJlemXOnz9PRMR/89m2bt2aBQsWMHXqVPz8/Pj+++9Zu3YtNWvWzOrwhRAiexWpBH12Q/1PwdgMi6vBbDUbQQ/jLRih7cMjPcFznlzRuxvAwcGB5cuXp1hGKZVoW8+ePenZs2dmhSWEELmHiRnUHg6+LXn264dY3zrAWNNltDTex8jY3lzCEy/H9HWQFZkj19xJCyGEyCBOJTDvtYUjZT7jsbKkvNFlNpl9wobSwbhZJT1iRmQPSdJCCJEfGRlRqd0wovvs44FHQ0w1cZS+9F2ya1bLfODZI9dUdwshhMh4Lu7e0OsX+HsDbB7235rVFXtAg/FgYcfqw9elF3g2kTtpIYQQUKrFv2tWd9P+fnQxfFOVB0fX6RI0SC/wrCZJWgghhJZlQWgxG7ptAofi8DgUh409mGMyEyce6opJL/CsI0laCCGEvpfWrFYaY5oZH2Kn+XACjIMBhbFGI73As4gkaSGEEIn9u2a15oPdPLArha0mmimmC1ll9gWzGxWQpS+ziCRpIYQQyXP1w2HQn0TWHkucsQXVjP6m2Z528OcMiPtvVSjp/Z05pHe3EEKIlBmbYFt/KJRvDZuGwD/BsHM8nFkHLeaw+lYh6f2dSeROWgghRNo4FIPA9dBqgbaT2Z1TqIX1ifhtFGbqGSC9vzOaJGkhhBBpp9FA+Y4w4DCUaYdGxdPH5He2mY2ghtEpQHp/ZyRJ0kIIIQxn4wTtFvGg5TJuq0IUNbrHCrNJTDNZgIMmSnp/ZxBJ0kIIIdLNoUIL9jf+naVxDYlXGtqb/MG+AiNxu7EZklj0SBhGkrQQQojX0tbflwbDlnKm8c/EOryJxfMHsKYn/NQRIm6muK/0Ck+Z9O4WQgjx2tzsLHHzbwiV68Cer+GPr+DCFri6B94ZC5V6gZH+faHMCZ46uZMWQgiRcUzMoe4o6LsHilSB54+1C3csbgz3zuuKhUY8lTnB00CStBBCiIznXBJ6boWmX4GZDdw4qF0GM2QKvHjOlfAoXYJO8HKvcKkG15LqbiGEEJnDyAiq9IYSjeH3oXBxG4R8CWfWU+LtrzDSoJeoE+YEl2rw/8idtBBCiMxl7wGdfoa2i8DKEe6dxXFVc4J8fqeARjsJirFGw5dtygBINfhLJEkLIYTIfBoN+LWDgYehXEdAUeLqCo47fsqWpjHsGVWPgMpFU60Gz28kSQshhMg6Vg7QegF0WQf2RTF5fAvfXT1x2/EhRIVTzNEaI43+Lq8ujZmf2qslSQshhMh6b7wN/Q+A/0DQGMGpX2BuZdyubmBS6zIYa7SZOqEaPGFpzNWHr1Nj8i46LTxIjcm7WH34enY+i0wnHceEEEJkDzNraPQFlGkDGwbB3dOwvg8Bxd+mXr9JXI51xMvRSpegkxu2VbuEU55d31rupIUQQmQv94rQJwTqfwbG5nB5J87L6uIfthq3Ama6YvmxvVqStBBCiOxnbAq1h0G/veBZA2KjYetoWNQA7p4BSFN7NSRus87NbdhS3S2EECLncHwTum2CYz/C9rFw6yh8WxtqDsGt1jAmtfFjzLrTxCmVqL0aEk812rqCO+uP38q1Y64lSQshhMhZjIygUs9/J0EZBud/hz+mwd+/EfDubGqPqsfV8Gi99mpIus167bFbusdzYxu2VHcLIYTImWwLw3sroMNSsHGB8AuwuDFuf36Cv7tJokSbVJv1q3JbG7YkaSGEEDmXRgOlWsKAg1AhULvtyCL4phqc26xXNKk261cl1Yadk0mSFkIIkfNZFoSWc6HbRnDwhse3YVVH+KU7PAkDtMtlTmrjpzfGuu1b7smOuc4NpE1aCCFE7lGsNvTbByGTYd8cOLMeLgdDoy+hfCcCKheldgknvTbrYY18kmzDzg3kTloIIUTuYmoJDcZD713gWhZiHsFv/WFZK3hwBTc7S/yLF9Il5Fd/z00kSQshhMidCpeH3sHwzngwsYB/QmCev/YOO+5FdkeXISRJCyGEyL2MTaDmYG0VuFctePEUtn0Ki96BO6eyO7rXJklaCCFE7leouLZTWYs5YG4Ht4/Dt3Vgx3iIzX0zjSWQJC2EECJv0Gjgra4w8BD4tgAVB3tmwPwacHVPdkeXLpKkhRBC5C0FXCFgGQQsBxtXeHAZlrwLD/7J7sgMJkOwhBBC5E2+72rbqXeMAyNj7fjqXEaStBBCiLzL0h7enQnx8dkdSbpIdbcQQoi8zyh3prvcGbUQQgiRD0iSFkIIIXIoSdJCCCFEDiVJWgghhMihJEkLIYQQOZQkaSGEECKHknHSqVBKARAZGWnwvrGxsURHRxMZGYmpqWlGhyZyOLn++Ztc/7wnIQ8k5IWsIEk6FY8fPwbAw8MjmyMRQgiREzx+/Bg7O7ssOZdGZeVXglwoPj6e27dvU6BAATQaDZUrV+bw4cNJln31scjISDw8PLhx4wa2trZZFXKapfRcsvO46dk/rfukpZwh1zilx/Lr9c+IYxu6v1x/w8n1N7xMpUqV2LVrF4ULF8YoiyZHkTvpVBgZGVGkSBHd78bGxsl+4JJ7zNbWNkd+SFN6Ltl53PTsn9Z90lIuPdc4pcfy2/XPiGMbur9cf8PJ9Te8jImJiV4+yArSccxAAwYMSNdjOVFmxfu6x03P/mndJy3l0nuN5fpn3LEN3V+uv+Hk+hteJjuusVR3Z6LIyEjs7OyIiIjIkd+kReaS65+/yfUXGUHupDORubk5Y8eOxdzcPLtDEdlArn/+JtdfZAS5kxZCCCFyKLmTFkIIIXIoSdJCCCFEDiVJWgghhMihJEkLIYQQOZQkaSGEECKHkiSdQzx+/JjKlStTvnx5/Pz8WLhwYXaHJLLQjRs3qFu3LqVKlaJs2bL88ssv2R2SyGKtW7emYMGCtGvXLrtDETmIDMHKIeLi4nj27BlWVlZER0dTpkwZDh8+TKFChbI7NJEFQkNDuXv3LuXLlycsLIy33nqL8+fPY21tnd2hiSwSHBzMkydPWLJkCWvWrMnucEQOIXfSOYSxsTFWVlYAxMTEEBcXl6XLoYns5ebmRvny5QFwdnbGwcGBBw8eZG9QIkvVq1ePAgUKZHcYIoeRJJ1Gf/zxB++++y6FCxdGo9Hw66+/Jiozb948ihUrhoWFBRUrVuTPP/806ByPHj2iXLlyFClShBEjRuDo6JhB0YvXlRXXP8GRI0eIj4+X5VFzkKy8/kK8TJJ0GkVFRVGuXDnmzp2b5OOrV69m8ODBfPLJJxw/fpxatWrRpEkTrl+/ritTsWJFypQpk+jn9u3bANjb23PixAmuXLnCypUruXv3bpY8N5G6rLj+APfv36dr16589913mf6cRNpl1fUXIhElDAao9evX622rUqWK6tu3r962kiVLqlGjRqXrHH379lU///xzekMUmSizrn9MTIyqVauWWrp0aUaEKTJJZn7+g4ODVdu2bV83RJGHyJ10Bnj+/DlHjx6lYcOGetsbNmzIvn370nSMu3fvEhkZCWhXz/njjz/w8fHJ8FhFxsuI66+Uonv37tSvX5/AwMDMCFNkkoy4/kIkxyS7A8gLwsPDiYuLw8XFRW+7i4sLd+7cSdMxbt68Sa9evVBKoZRi4MCBlC1bNjPCFRksI67/3r17Wb16NWXLltW1dy5btgw/P7+MDldksIy4/gCNGjXi2LFjREVFUaRIEdavX0/lypUzOlyRy0iSzkAajUbvd6VUom3JqVixIn/99VcmRCWyyutc/5o1axIfH58ZYYks8jrXH2Dr1q0ZHZLIA6S6OwM4OjpibGyc6FtzWFhYom/XIu+R65+/yfUXmUmSdAYwMzOjYsWKbN++XW/79u3bqV69ejZFJbKKXP/8Ta6/yExS3Z1GT5484dKlS7rfr1y5wl9//YWDgwNFixZl6NChBAYGUqlSJfz9/fnuu++4fv06ffv2zcaoRUaR65+/yfUX2SY7u5bnJsHBwQpI9NOtWzddmW+++UZ5enoqMzMz9dZbb6ndu3dnX8AiQ8n1z9/k+ovsInN3CyGEEDmUtEkLIYQQOZQkaSGEECKHkiQthBBC5FCSpIUQQogcSpK0EEIIkUNJkhZCCCFyKEnSQgghRA4lSVoIIYTIoSRJC5HHhISEoNFoePToUZafW6PRoNFosLe3T7HcuHHjKF++vN7vCfvOnDkzU2MUIjeRJC1ELla3bl0GDx6st6169eqEhoZiZ2eXLTEtXryYCxcuGLTPsGHDCA0NpUiRIpkUlRC5kyywIUQeY2Zmhqura7ad397eHmdnZ4P2sbGxwcbGBmNj40yKSojcSe6khcilunfvzu7du5k1a5auqvjq1auJqrt//PFH7O3t2bRpEz4+PlhZWdGuXTuioqJYsmQJXl5eFCxYkA8//JC4uDjd8Z8/f86IESNwd3fH2tqaqlWrEhISkq5YJ0+ejIuLCwUKFKBXr17ExMRkwCsgRN4nSVqIXGrWrFn4+/vTu3dvQkNDCQ0NxcPDI8my0dHRzJ49m1WrVhEUFERISAht2rRh8+bNbN68mWXLlvHdd9+xZs0a3T49evRg7969rFq1ipMnT9K+fXsaN27MxYsXDYrz559/ZuzYsXzxxRccOXIENzc35s2b91rPXYj8Qqq7hcil7OzsMDMzw8rKKtXq7djYWObPn0/x4sUBaNeuHcuWLePu3bvY2NhQqlQp6tWrR3BwMAEBAVy+fJmffvqJmzdvUrhwYUDbbhwUFMTixYv58ssv0xznzJkz6dmzJ++//z4AEydOZMeOHXI3LUQayJ20EPmAlZWVLkEDuLi44OXlhY2Njd62sLAwAI4dO4ZSihIlSujai21sbNi9ezeXL1826Nxnz57F399fb9urvwshkiZ30kLkA6ampnq/azSaJLfFx8cDEB8fj7GxMUePHk3UmevlxC6EyFySpIXIxczMzPQ6e2WUChUqEBcXR1hYGLVq1XqtY/n6+nLgwAG6du2q23bgwIHXDVGIfEGStBC5mJeXFwcPHuTq1avY2Njg4OCQIcctUaIEnTt3pmvXrkyfPp0KFSoQHh7Orl278PPzo2nTpmk+1kcffUS3bt2oVKkSNWvWZMWKFZw5cwZvb+8MiVWIvEzapIXIxYYNG4axsTGlSpXCycmJ69evZ9ixFy9eTNeuXfn444/x8fGhRYsWHDx4MNke5MkJCAjgf//7HyNHjqRixYpcu3aNfv36ZVicQuRlGqWUyu4ghBB5g0ajYf369bRq1Spd+3t5eTF48OBEs6gJkV/JnbQQIkN17NjR4Ok9v/zyS2xsbDK0JkCIvEDupIUQGebSpUsAGBsbU6xYsTTv9+DBAx48eACAk5NTts07LkROI0laCCGEyKGkulsIIYTIoSRJCyGEEDmUJGkhhBAih5IkLYQQQuRQkqSFEEKIHEqStBBCCJFDSZIWQgghcihJ0kIIIUQOJUlaCCGEyKH+D3qRcfmQ8aD9AAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "print(\"rmse:\", ca2.rmse())\n", "hm2 = ml.head(r2, 0, t2)\n", "plt.semilogx(t2, h2, \".\", label=\"obs at 90 m\")\n", "plt.semilogx(t2, hm2[0], label=\"ttim at 90 m\")\n", "plt.xlabel(\"time [d]\")\n", "plt.ylabel(\"drawdown [m]\")\n", "plt.title(\"ttim analysis for Oude Korendijk - Piezometer 90 m\")\n", "plt.legend()\n", "plt.grid()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Step 5.3. Calibrate model with two datasets simultaneously" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here we explore the ability of TTim to calibrate the model using more than one observation location.\n", "\n", "We achieve this by calling the method ```.series``` multiple times to the ```Calibrate``` object:" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ ".................................\n", "Fit succeeded.\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
optimalstdperc_stdpminpmaxinitialparray
kaq066.0892911.6549892.504171-infinf10.0000[66.08929067179805]
Saq00.0000250.0000029.451956-infinf0.0001[2.540871621501991e-05]
\n", "
" ], "text/plain": [ " optimal std perc_std pmin pmax initial \\\n", "kaq0 66.089291 1.654989 2.504171 -inf inf 10.0000 \n", "Saq0 0.000025 0.000002 9.451956 -inf inf 0.0001 \n", "\n", " parray \n", "kaq0 [66.08929067179805] \n", "Saq0 [2.540871621501991e-05] " ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ca = ttm.Calibrate(ml)\n", "ca.set_parameter(name=\"kaq0\", initial=10)\n", "ca.set_parameter(name=\"Saq0\", initial=1e-4)\n", "ca.series(name=\"obs1\", x=r1, y=0, t=t1, h=h1, layer=0) # Adding well 1\n", "ca.series(name=\"obs2\", x=r2, y=0, t=t2, h=h2, layer=0) # Adding well 2\n", "ca.fit()\n", "ca.parameters" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "rmse: 0.050059911747508554\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "print(\"rmse:\", ca.rmse())\n", "hs1 = ml.head(r1, 0, t1)\n", "hs2 = ml.head(r2, 0, t2)\n", "plt.semilogx(t1, h1, \".\", label=\"obs at 30m\")\n", "plt.semilogx(t1, hs1[0], label=\"ttim at 30 m\")\n", "plt.semilogx(t2, h2, \".\", label=\"obs at 90m\")\n", "plt.semilogx(t2, hs2[0], label=\"ttim at 90m\")\n", "plt.xlabel(\"time(d)\")\n", "plt.ylabel(\"drawdown(m)\")\n", "plt.title(\"ttim analysis for Oude Korendijk - Piezometers at 30 and 90 m\")\n", "plt.legend()\n", "plt.grid()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Step 6. Calibrate Model with Wellbore Storage\n", "\n", "In this continuation, we investigate whether adding wellbore storage improves the fit." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Step 6.1. Reload the model" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "# unknown parameters: kaq, Saq and rc\n", "ml1 = ttm.ModelMaq(kaq=60, z=[zt, zb], Saq=1e-4, tmin=1e-5, tmax=1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Step 6.2. Define new Well object with wellbore storage" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, besides the parameters explained in [Step 3](#step_3), we have to add the radius of the caisson (```rc```)" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "self.neq 1\n", "solution complete\n" ] } ], "source": [ "w1 = ttm.Well(ml1, xw=0, yw=0, rw=0.2, rc=0.2, tsandQ=[(0, Q)], layers=0)\n", "ml1.solve()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### Step 6.3. Calibrate using only the data from observation well 1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The parameters not cited in the ```.set_paramater``` method, must be calibrated with the ```.set_parameter_by_reference``` method.\n", "\n", "Here we use the method ```.set_parameter_by_reference``` to calibrate the ```rc``` parameter in our well.\n", "\n", "```.set_parameter_by_reference``` takes the following arguments:\n", "* ```name```: a string of the parameter name\n", "* ```parameter```: numpy-array with the parameter to be optimized. It should be specified as a reference, for example, in our case: ```w1.rc[0:]``` referencing to the parameter ```rc``` in object ```w1```.\n", "* ```initial```: float with the initial guess for the parameter value.\n", "* ```pmin``` and ```pmax```: floats with the minimum and maximum values allowed. If not specified, these will be defined as ```-np.inf``` and ```np.inf```.\n" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "...............................................................................................................................................................................................................................................................................................................................\n", "Fit succeeded.\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
optimalstdperc_stdpminpmaxinitialparray
kaq080.9453831.723784e+002.129564-infinf10.0000[80.94538333007124]
Saq00.0000057.903658e-0714.505522-infinf0.0001[5.448723763446817e-06]
rc-0.3039641.744327e-025.738597-infinf0.2000[-0.3039640167051798]
\n", "
" ], "text/plain": [ " optimal std perc_std pmin pmax initial \\\n", "kaq0 80.945383 1.723784e+00 2.129564 -inf inf 10.0000 \n", "Saq0 0.000005 7.903658e-07 14.505522 -inf inf 0.0001 \n", "rc -0.303964 1.744327e-02 5.738597 -inf inf 0.2000 \n", "\n", " parray \n", "kaq0 [80.94538333007124] \n", "Saq0 [5.448723763446817e-06] \n", "rc [-0.3039640167051798] " ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ca3 = ttm.Calibrate(ml1)\n", "ca3.set_parameter(name=\"kaq0\", initial=10)\n", "ca3.set_parameter(name=\"Saq0\", initial=1e-4)\n", "ca3.set_parameter_by_reference(\n", " name=\"rc\", parameter=w1.rc[0:], initial=0.2\n", ") # , pmin=0.01)\n", "ca3.series(name=\"obs1\", x=r1, y=0, t=t1, h=h1, layer=0)\n", "ca3.fit()\n", "ca3.parameters" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "rmse: 0.015273838865273018\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "print(\"rmse:\", ca3.rmse())\n", "hm3 = ml1.head(r1, 0, t1)\n", "plt.semilogx(t1, h1, \".\", label=\"obs at 30 m\")\n", "plt.semilogx(t1, hm3[0], label=\"ttim at 30 m\")\n", "plt.xlabel(\"time(d)\")\n", "plt.ylabel(\"drawdown(m)\")\n", "plt.title(\"ttim analysis for Oude Korendijk - Piezometer 30 m and Wellbore Storage\")\n", "plt.legend()\n", "plt.grid()" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "...............................................................................................................................................................................................................................................................................................................................\n", "Fit succeeded.\n" ] } ], "source": [ "ca3.fit_lmfit()" ] }, { "cell_type": "markdown", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "### Step 6.4. Calibrate using only the data from observation well 2\n", "\n", "Here we repeat the step 6.3 for well 2" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "....................................................................................\n", "Fit succeeded.\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
optimalstdperc_stdpminpmaxinitialparray
kaq088.2878231.484918e+001.681906-infinf10.0000[88.28782298814623]
Saq00.0000119.442731e-078.311813-infinf0.0001[1.1360615243112807e-05]
rc0.6746593.064973e-024.5429950.01inf0.2000[0.6746591458251263]
\n", "
" ], "text/plain": [ " optimal std perc_std pmin pmax initial \\\n", "kaq0 88.287823 1.484918e+00 1.681906 -inf inf 10.0000 \n", "Saq0 0.000011 9.442731e-07 8.311813 -inf inf 0.0001 \n", "rc 0.674659 3.064973e-02 4.542995 0.01 inf 0.2000 \n", "\n", " parray \n", "kaq0 [88.28782298814623] \n", "Saq0 [1.1360615243112807e-05] \n", "rc [0.6746591458251263] " ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ca4 = ttm.Calibrate(ml1)\n", "ca4.set_parameter(name=\"kaq0\", initial=10)\n", "ca4.set_parameter(name=\"Saq0\", initial=1e-4)\n", "ca4.set_parameter_by_reference(name=\"rc\", parameter=w1.rc[0:], initial=0.2, pmin=0.01)\n", "ca4.series(name=\"obs2\", x=r2, y=0, t=t2, h=h2, layer=0)\n", "ca4.fit()\n", "ca4.parameters" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "rmse: 0.006219520494372699\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "print(\"rmse:\", ca4.rmse())\n", "hm4 = ml1.head(r2, 0, t2)\n", "plt.semilogx(t2, h2, \".\", label=\"obs at 90 m\")\n", "plt.semilogx(t2, hm4[0], label=\"ttim at 90 m\")\n", "plt.xlabel(\"time [d]\")\n", "plt.ylabel(\"drawdown [m]\")\n", "plt.title(\"ttim analysis for Oude Korendijk - Piezometer 90 m and Wellbore Storage\")\n", "plt.legend()\n", "plt.grid()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Step 6.5. Calibrate model with two datasets simultaneously\n", "\n", "Following the same logic from steps 6.3 to 6.4 and the calibration from step 5.3, we can now check the calibration using both wells and wellbore storage." ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "........................................................................\n", "Fit succeeded.\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
optimalstdperc_stdpminpmaxinitialparray
kaq066.0880241.6701222.527117-infinf10.0000[66.0880240001346]
Saq00.0000250.0000029.669129-infinf0.0001[2.5405869311639107e-05]
rc0.0100030.015804157.9904290.01inf0.2000[0.010003111933319042]
\n", "
" ], "text/plain": [ " optimal std perc_std pmin pmax initial \\\n", "kaq0 66.088024 1.670122 2.527117 -inf inf 10.0000 \n", "Saq0 0.000025 0.000002 9.669129 -inf inf 0.0001 \n", "rc 0.010003 0.015804 157.990429 0.01 inf 0.2000 \n", "\n", " parray \n", "kaq0 [66.0880240001346] \n", "Saq0 [2.5405869311639107e-05] \n", "rc [0.010003111933319042] " ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ca0 = ttm.Calibrate(ml1)\n", "ca0.set_parameter(name=\"kaq0\", initial=10)\n", "ca0.set_parameter(name=\"Saq0\", initial=1e-4)\n", "ca0.set_parameter_by_reference(name=\"rc\", parameter=w1.rc[0:], initial=0.2, pmin=0.01)\n", "ca0.series(name=\"obs1\", x=r1, y=0, t=t1, h=h1, layer=0)\n", "ca0.series(name=\"obs2\", x=r2, y=0, t=t2, h=h2, layer=0)\n", "ca0.fit()\n", "ca0.parameters" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "rmse: 0.050065003351326486\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "print(\"rmse:\", ca0.rmse())\n", "hs1 = ml1.head(r1, 0, t1)\n", "hs2 = ml1.head(r2, 0, t2)\n", "plt.semilogx(t1, h1, \".\", label=\"obs at 30m\")\n", "plt.semilogx(t1, hs1[0], label=\"ttim at 30 m\")\n", "plt.semilogx(t2, h2, \".\", label=\"obs at 90m\")\n", "plt.semilogx(t2, hs2[0], label=\"ttim at 90m\")\n", "plt.xlabel(\"time [d]\")\n", "plt.ylabel(\"drawdown [m]\")\n", "plt.title(\"ttim analysis for Oude Korendijk\")\n", "plt.legend()\n", "plt.grid()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Step 7. Comparison of Results" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Step 7.1. Comparison of model performance and Results with and without wellbore storage" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 7.1.1. RMSE of the two conceptual models" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The following table summarises the RMSE values of the obtained models with and without wellbore storage." ] }, { "cell_type": "code", "execution_count": 26, "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", "
RMSE of two conceptual models
 obs 30 mobs 90 mobs simultaneously
without rc0.0316600.0227190.050060
with rc0.0152740.0062200.050065
\n" ], "text/plain": [ "" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t0 = pd.DataFrame(\n", " columns=[\"obs 30 m\", \"obs 90 m\", \"obs simultaneously\"],\n", " index=[\"without rc\", \"with rc\"],\n", ")\n", "t0.loc[\"without rc\", \"obs 30 m\"] = ca1.rmse()\n", "t0.loc[\"without rc\", \"obs 90 m\"] = ca2.rmse()\n", "t0.loc[\"without rc\", \"obs simultaneously\"] = ca.rmse()\n", "t0.loc[\"with rc\", \"obs 30 m\"] = ca3.rmse()\n", "t0.loc[\"with rc\", \"obs 90 m\"] = ca4.rmse()\n", "t0.loc[\"with rc\", \"obs simultaneously\"] = ca0.rmse()\n", "\n", "t0.style.set_caption(\"RMSE of two conceptual models\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Adding wellbore storage improved the fit performance when used drawdown data of the individual observation wells. However, when calibrated the model with both datasets simultaneously, ```rc``` was adjusted to the minimum value. Adding rc did not improve the performance much in this case." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 7.1.2. Model comparisons" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can see the summaries of the hydraulic conductivities in the following table.\n", "\n", "We will access the parameter values by accessing the ```.parameters``` attribute of each ```Calibrate``` object." ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "editable": true, "jupyter": { "source_hidden": true }, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Preparing the DataFrame:\n", "t1 = pd.DataFrame(\n", " columns=[\"kaq - opt\", \"kaq - min\", \"kaq - max\", \"W. Storage\", \"Calib. Dataset\"]\n", ")\n", "w_storage = [\n", " \"without rc\",\n", " \"without rc\",\n", " \"without rc\",\n", " \"with rc\",\n", " \"with rc\",\n", " \"with rc\",\n", "]\n", "obs_dataset = [\n", " \"obs 30 m\",\n", " \"obs 90 m\",\n", " \"obs simultaneously\",\n", " \"obs 30 m\",\n", " \"obs 90 m\",\n", " \"obs simultaneously\",\n", "]\n", "\n", "# Looping through all calibration objects and fetching the desired values\n", "for calib, w_sto, obs_dts in zip(\n", " [ca1, ca2, ca, ca3, ca4, ca0], w_storage, obs_dataset, strict=False\n", "):\n", " p = calib.parameters # Accessing the parameters Dataframe inside the Calibrate object\n", " tab = pd.DataFrame(\n", " [\n", " [\n", " p.loc[\"kaq0\", \"optimal\"],\n", " 2 * p.loc[\"kaq0\", \"std\"],\n", " 2 * p.loc[\"kaq0\", \"std\"],\n", " w_sto,\n", " obs_dts,\n", " ]\n", " ],\n", " columns=[\"kaq - opt\", \"kaq - min\", \"kaq - max\", \"W. Storage\", \"Calib. Dataset\"],\n", " )\n", " t1 = pd.concat(\n", " (t1 if not t1.empty else None, tab)\n", " ) # empty rows not allowed in Pandas > 2.1\n", "\n", "# Plotting\n", "groups = t1.groupby(\"W. Storage\")\n", "for name, group in groups:\n", " plt.errorbar(\n", " x=group[\"Calib. Dataset\"],\n", " y=group[\"kaq - opt\"],\n", " yerr=[group[\"kaq - min\"], group[\"kaq - max\"]],\n", " marker=\"o\",\n", " linestyle=\"\",\n", " markersize=12,\n", " label=name,\n", " )\n", "plt.legend()\n", "plt.title(\"Error bar plot of calibrated hydraulic conductivities\")\n", "plt.ylabel(\"K [m/d]\")\n", "plt.xlabel(\"Calibration Dataset\")\n", "plt.grid()" ] }, { "cell_type": "markdown", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "The Errorbar plot shows that the Hydraulic Conductivities calculated are significantly higher with wellbore storage than without when considering the individual wells datasets for calibration.\n", "\n", "As for the dataset using both obs wells at the same time, the calibration results have no significant differences.\n", "\n", "Both scenarios with and without wellbore storage showed lower values for the calibrated model using both observations, calibration with a single well are overestimated." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Step 7.2. Compare TTim to results of K&dR, AQTEOLV and MLU:" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The final important step is to compare the data obtained from this model with the data from other Aquifer Analysis software. Yang (2020) compared TTim results with the published results in Kruseman and de Ridder (1990), here abbreviated to K&dR, and with the results obtained from the software AQTESOLV (Duffield, 2007) and MLU (Carlson & Randall, 2012)." ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
Comparison of Model Results with different Softwares
 k [m/d]Ss [1/m]RMSE
K&dR55.7142900.000170-
TTim66.0892910.0000250.050060
AQTESOLV66.0860000.0000250.050060
MLU66.8500000.0000240.050830
\n" ], "text/plain": [ "" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t = pd.DataFrame(\n", " columns=[\"k [m/d]\", \"Ss [1/m]\", \"RMSE\"], index=[\"K&dR\", \"TTim\", \"AQTESOLV\", \"MLU\"]\n", ")\n", "t.loc[\"TTim\"] = np.append(ca.parameters[\"optimal\"].values, ca.rmse())\n", "t.loc[\"AQTESOLV\"] = [66.086, 2.541e-05, 0.05006]\n", "t.loc[\"MLU\"] = [66.850, 2.400e-05, 0.05083]\n", "t.loc[\"K&dR\"] = [55.71429, 1.7e-4, \"-\"]\n", "t.style.set_caption(\"Comparison of Model Results with different Softwares\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Results show good agreement between different analysis programs, including TTim. The values from Kruseman and de Ridder (1990) were obtained through Thiem's approximation. They seem to be an underestimation, as the pumping never reached steady-state conditions." ] }, { "cell_type": "markdown", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "## References\n", "\n", "* Bakker, M. Semi-analytic modeling of transient multi-layer flow with TTim. Hydrogeol J 21, 935–943 (2013). https://doi.org/10.1007/s10040-013-0975-2\n", "* Carlson F, Randall J (2012) MLU: a Windows application for the analysis of aquifer tests and the design of well fields in layered systems. Ground Water 50(4):504–510\n", "* Duffield, G.M., 2007. AQTESOLV for Windows Version 4.5 User's Guide, HydroSOLVE, Inc., Reston, VA.\n", "* Newville, M.,Stensitzki, T., Allen, D.B., Ingargiola, A. (2014) LMFIT: Non Linear Least-Squares Minimization and Curve Fitting for Python.https://dx.doi.org/10.5281/zenodo.11813. https://lmfit.github.io/lmfit-py/intro.html (last access: August,2021).\n", "* Kruseman, G.P., De Ridder, N.A., Verweij, J.M., 1970. Analysis and evaluationof pumping test data. volume 11. International institute for land reclamation and improvement The Netherlands.\n", "* Yang, Xinzhu (2020) Application and comparison of different methodsfor aquifer test analysis using TTim. Master Thesis, Delft University of Technology (TUDelft), Delft, The Netherlands." ] } ], "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.11.4" } }, "nbformat": 4, "nbformat_minor": 4 }