{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dimension adaptive sampling tutorial\n",
    "\n",
    "Here, briefly describe the concept behind dimension-adaptive sparse grids, starting from a standard Stochastic Collocation (SC) campaign. Following this, a dimension adaptive EasyVVUQ script using a simple analytic test function is presented. We will assume you are familiar with the basics of EasyVVUQ.\n",
    "\n",
    "## Standard SC\n",
    "\n",
    "In a standard EasyVVUQ Campaign, a Stochastic Collocation sampler object might be created via::\n",
    "\n",
    "```python\n",
    "sampler = uq.sampling.SCSampler(vary=vary, polynomial_order=2)\n",
    "```\n",
    "Here the specified `polynomial_order`, and the number of inputs in `vary`, determine the\n",
    "number of samples, which increases exponentially fast with an increasing amount of inputs. This\n",
    "is the so-called *curse of dimensionality*. \n",
    "\n",
    "Basically, by setting `polynomial_order=2` we create a sampling plan through a single tensor product of one-dimensional quadrature nodes with order 3 for every input. It is this tensor product construction that leads to the exponential rise in cost. So if we have 2 inputs `x1` and `x2`, and our one-dimensional quadrature rule of order 2 produces 5 points, we obtain a total of 25 points in the `(x1, x2)` domain. Likewise, if `vary` contains 3 inputs, we would need to evaluate the computational model 125 times, and 10 inputs would require `5**10 = 9765625` model evaluations. For this reason, a standard SC campaign is rarely used beyond 6 or 7 inputs.\n",
    "\n",
    "## Sparse SC\n",
    "\n",
    "Sparse grids on the other hand, do not create a single tensor product, but build the sampling plan from the ground up by using a *linear combination of tensor products involving 1D quadrature rules of* ***different*** *orders*. \n",
    "\n",
    "For two inputs, we might for instance consider using 1D quadrature rules of order [0, 0], [0, 1] and [1, 0], where:\n",
    "\n",
    "    * [0, 0]: a single point in the 2D domain (x1, x2)\n",
    "    * [0, 1]: a line of 3 points with constant x1\n",
    "    * [1, 0]: a line of 3 points with constant x2\n",
    "\n",
    "In the case of sparse grids it is common to select a *nested* quadrature rule. This means that the quadrature\n",
    "rule of order p contains all points of the same rule of order p-1. When taking the linear combinations, a nested rule ensures that many points will conincide, which yields efficient sampling \n",
    "plans, especially in higher dimensions. If our nested 1D rule of order 1 and 2 generates the points [0.5] and [0, 0.5, 1] we obtain a sampling plan consisting of\n",
    "\n",
    "    * [0, 0]: [0.5, 0.5]\n",
    "    * [0, 1]: [0.5, 0.0], [0.5, 0.5], [0.5, 1.0]\n",
    "    * [1, 0]: [0.0, 0.5], [0.5, 0.5], [1.0, 0.5],\n",
    "\n",
    "which gives a total of 5 unique points, compared to a corresponding standard SC campaign with [1, 1], which would generate 9 unique points (`[0, 0.5, 1] x [0, 0.5, 1.0]`). Note that sparse grids do **not** circumvent the curse of dimensionality, although they can postpone its effect to higher dimensions.\n",
    "\n",
    "## Dimension-adaptive SC\n",
    "\n",
    "What we described above is an *isotropic* sparse grid, since the multi indices `[0, 0], [1, 0], [0,1]` result in a sampling plan where both inputs end up with the same number of samples. However, in practice model parameters are rarely equally important. The idea behind dimension-adaptive sampling is to build the sampling plan in an iterative fashion, find out which (combination of) parameters are important as we go, and then place more samples along those directions. This results in a anisotropic sampling plan, where the important inputs get relatively high number of samples. To find out which directions are important we need an appropriate error measure, and we need to split the quadrature order multi indices in an *accepted* and an *admissible* set. The accepted set is initialized to `[0, 0]` in 2D, i.e. we start with just a single code evaluation. Without going into detail, we can think of the admissible set as the candidate refinement directions, from which we must add a single entry to the accepted set at every iteration.\n",
    "\n",
    "In our 2D example, at the 1st iteration the candidate set consists of `[1, 0]` and `[0, 1]`. That is, we can either refine only `x1` or only `x2`. We must select the multi index which generates the highest error when added to the accepted set. There are a variety of error measures, the two main ones in EasyVVUQ are:\n",
    "\n",
    "1. the hierarchical surplus error, and\n",
    "2. a variance-based error.\n",
    "\n",
    "Roughly speaking, the surplus is an interpolation based error, which measures the difference between the code output and the corresponding SC polynomial surrogate, when evaluated at new sample locations. The variance-based error selects the direction in which the variance in the output changes the most. For more information we refer to the references below.\n",
    "\n",
    "Assume that `[1, 0]` generated the highest error, and so it is added to the accepted set, now consisting of `[0, 0]` and `[1, 0]`. This means that `x1` has more points than `x2`. Also, adding a multi index to the accepted set means that the admissible set changes. In this case, since `[1, 0]` has been accepted, `[2, 0]` has become admissible. Note that the new entry `[2, 0]` also requires new evaluations of the code, and so a new ensemble must be submitted. Again, if we use a nested rule, the grid of `[2, 0]` will have a partial overlap with the accepted points, so we only have to evaluate the code at the new points, *not* all points of `[2, 0]`.\n",
    "\n",
    "Thus, the admissible set now consists of `[0, 1]` and `[2, 0]`. Hence, we now have to option of refining `x1` again (to second order), or refining `x2` to first order. Assume the latter happens. As both `x1` and `x2` have been refined to 1st order, `[1, 1]` has become admissible. If accepted, this multi index results in a *simultaneous* refinement of both `x1` and `x2`. Note that `[1, 1]` represents a tensor product, and that therefore it is not the same as `[1, 0]` and `[0, 1]` taken together. We added this example to show that the algoritmn is not limited to one-at-a-time refinement.\n",
    "\n",
    "To conclude, every time a multi index is accepted, new indices become admissible, and the cycle repeats.\n",
    "\n",
    "## References\n",
    "\n",
    "Our description of the method here was rather limited, so for more information and applications of this (and similar) methods, see the following references:\n",
    "\n",
    "* T. Gerstner  and M. Griebel. \"Dimension–adaptive tensor–product quadrature.\" Computing 71.1 (2003): 65-87.\n",
    "* W. Edeling , H. Arabnejad , R. Sinclair, D. Suleimenova, K. Gopalakrishnan, B. Bosak, D. Groen, I. Mahmood, D. Crommelin, and Peter V Coveney, \"The Impact of Uncertainty on Predictions of the CovidSim Epidemiological Code\", Nature Computational Science, 1 (2), 2021.\n",
    "* D. Loukrezis, U. Römer, and H. De Gersem. \"Assessing the performance of Leja and Clenshaw-Curtis collocation for computational electromagnetics with random input data\". International Journal for Uncertainty Quantification , 9(1), 2019.\n",
    "* J.D. Jakeman, M.S. Eldred, G. Geraci, and A. Gorodetsky. \"Adaptive multi-index collocation for uncertainty quantification and sensitivity analysis\". Numerical Methods in Engineering , 121(6):1314-1343, 2020."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example\n",
    "\n",
    "Below we give an EasyVVUQ script for a dimension-adaptive campaign on a simple polynomial function with 20 uncertain inputs. The function is given by:\n",
    "\n",
    "```python\n",
    "    sol = 1.0\n",
    "    for i in range(d):\n",
    "        sol *= 3 * a[i] * theta[i]**2 + 1.0\n",
    "    return sol/2**d\n",
    "```\n",
    "\n",
    "Thus, it is just a product of quadratic polynomials. The coefficients `a[i]` are given by\n",
    "\n",
    "```python\n",
    "a = [1/(2*(i+1)) for i in range(d)]\n",
    "```\n",
    "Such that `a=[0.5, 0.25, 0.125, ..., 1/2**20]`. That is, we have imposed that `x1` is the most important, then `x2` etc. The variables near `x20` virtually do not contribute at all. We would like to pick up on this, and only refine the first couple of inputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:35:54.662443Z",
     "start_time": "2021-06-09T07:35:54.660674Z"
    }
   },
   "outputs": [],
   "source": [
    "#!pip install EasyVVUQ\n",
    "#!pip install future\n",
    "#!pip install fipy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:35:57.781098Z",
     "start_time": "2021-06-09T07:35:54.663891Z"
    }
   },
   "outputs": [],
   "source": [
    "import easyvvuq as uq\n",
    "import numpy as np\n",
    "import chaospy as cp\n",
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "from easyvvuq.actions import CreateRunDirectory, Encode, Decode, CleanUp, ExecuteLocal, Actions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Running an adaptive campaign starts exactly the same as creating a 'normal' SC campaign, with the exception of a few extra flags that are passed to the SC sampler object. We therefore start as usual with creating a Campaign,  encoder and decoder, and setting up the parameters space:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:35:57.809880Z",
     "start_time": "2021-06-09T07:35:57.782354Z"
    }
   },
   "outputs": [],
   "source": [
    "# The number of uncertain inputs\n",
    "d = 20\n",
    "\n",
    "#All parameters are between 0 and 1\n",
    "params = {}\n",
    "for i in range(d):\n",
    "    params[\"x%d\" % (i + 1)] = {\"type\": \"float\",\n",
    "                               \"min\": 0.0,\n",
    "                               \"max\": 1.0,\n",
    "                               \"default\": 0.5}\n",
    "    \n",
    "#also store the name of the output file and the stochastic dimension\n",
    "params[\"out_file\"] = {\"type\": \"string\", \"default\": \"output.csv\"}\n",
    "params[\"d\"] = {\"type\": \"integer\", \"default\": d}\n",
    "output_filename = params[\"out_file\"][\"default\"]\n",
    "output_columns = [\"f\"]\n",
    "\n",
    "# Create an encoder, decoder and collation element\n",
    "encoder = uq.encoders.GenericEncoder(\n",
    "    template_fname='poly_model.template',\n",
    "    delimiter='$',\n",
    "    target_filename='poly_in.json')\n",
    "\n",
    "\n",
    "decoder = uq.decoders.SimpleCSV(target_filename=output_filename,\n",
    "                                output_columns=output_columns)\n",
    "\n",
    "\n",
    "execute = ExecuteLocal('{}/poly_model.py poly_in.json'.format(os.getcwd()))\n",
    "\n",
    "\n",
    "actions = Actions(CreateRunDirectory('/tmp'), \n",
    "                  Encode(encoder), execute, Decode(decoder))\n",
    "\n",
    "\n",
    "# Create an EasyVVUQ campaign\n",
    "campaign = uq.Campaign(name='sc_adaptive', work_dir='/tmp', params=params, actions=actions)\n",
    "\n",
    "\n",
    "# All inputs are uniformly distributed\n",
    "vary = {}\n",
    "for i in range(d):\n",
    "    vary[\"x%d\" % (i + 1)] = cp.Uniform(0, 1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As mentioned, the sampler is a bit different:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:35:57.820269Z",
     "start_time": "2021-06-09T07:35:57.811263Z"
    }
   },
   "outputs": [],
   "source": [
    "sampler = uq.sampling.SCSampler(vary=vary, polynomial_order=1,\n",
    "                                quadrature_rule=\"C\",\n",
    "                                sparse=True, growth=True,\n",
    "                                midpoint_level1=True,\n",
    "                                dimension_adaptive=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here:\n",
    "\n",
    "* `polynomial_order=1`: do not change, will be adaptively increased for influential parameters. Technically, it'll change the quadrature order for different (combinations of) parameters).\n",
    "* `quadrature_rule=\"C\":`selects the Clenshaw Curtis quadrature rule. This is a common choice, although others are available.\n",
    "* `sparse = True`: selects a sparse grid. This is required.\n",
    "* `growth = True`: selects a nested quadrature rule (a quadrature rule such that a 1D rule of order p contains all points of the same rule of order p-1). Also not required, but is efficient in high dimensions. Note that this can only be selected with a subset of all quadrature rules in Chaospy, including Clenshaw Curtis.\n",
    "* `midpoint_level1=True`: this means that the first iteration of the dimension-adaptive sampler consists of a single sample. \n",
    "* `dimension_adaptive=True`: selects the dimension-adaptive sparse grid sampler (opposed to the isotropic sparse grid sampler, which treats each input the same)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:35:58.030632Z",
     "start_time": "2021-06-09T07:35:57.820969Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00,  4.80it/s]\n"
     ]
    }
   ],
   "source": [
    "# set the sampler, and draw the first sample\n",
    "campaign.set_sampler(sampler)\n",
    "campaign.execute().collate(progress_bar=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:35:58.050314Z",
     "start_time": "2021-06-09T07:35:58.031567Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>run_id</th>\n",
       "      <th>iteration</th>\n",
       "      <th>x1</th>\n",
       "      <th>x2</th>\n",
       "      <th>x3</th>\n",
       "      <th>x4</th>\n",
       "      <th>x5</th>\n",
       "      <th>x6</th>\n",
       "      <th>x7</th>\n",
       "      <th>x8</th>\n",
       "      <th>...</th>\n",
       "      <th>x14</th>\n",
       "      <th>x15</th>\n",
       "      <th>x16</th>\n",
       "      <th>x17</th>\n",
       "      <th>x18</th>\n",
       "      <th>x19</th>\n",
       "      <th>x20</th>\n",
       "      <th>out_file</th>\n",
       "      <th>d</th>\n",
       "      <th>f</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>0</th>\n",
       "      <th>0</th>\n",
       "      <th>0</th>\n",
       "      <th>0</th>\n",
       "      <th>0</th>\n",
       "      <th>0</th>\n",
       "      <th>0</th>\n",
       "      <th>0</th>\n",
       "      <th>0</th>\n",
       "      <th>...</th>\n",
       "      <th>0</th>\n",
       "      <th>0</th>\n",
       "      <th>0</th>\n",
       "      <th>0</th>\n",
       "      <th>0</th>\n",
       "      <th>0</th>\n",
       "      <th>0</th>\n",
       "      <th>0</th>\n",
       "      <th>0</th>\n",
       "      <th>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>...</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>output.csv</td>\n",
       "      <td>20</td>\n",
       "      <td>0.000003</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1 rows × 25 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "  run_id iteration   x1   x2   x3   x4   x5   x6   x7   x8  ...  x14  x15  \\\n",
       "       0         0    0    0    0    0    0    0    0    0  ...    0    0   \n",
       "0      1         0  0.5  0.5  0.5  0.5  0.5  0.5  0.5  0.5  ...  0.5  0.5   \n",
       "\n",
       "   x16  x17  x18  x19  x20    out_file   d         f  \n",
       "     0    0    0    0    0           0   0         0  \n",
       "0  0.5  0.5  0.5  0.5  0.5  output.csv  20  0.000003  \n",
       "\n",
       "[1 rows x 25 columns]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create an analysis class and run the analysis.\n",
    "campaign.get_collation_result()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:25:24.038863Z",
     "start_time": "2021-06-09T07:25:24.029219Z"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:35:58.129270Z",
     "start_time": "2021-06-09T07:35:58.052452Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/wouter/.local/lib/python3.7/site-packages/easyvvuq-1.1.2+4.g1dc8e9da-py3.7.egg/easyvvuq/analysis/sc_analysis.py:1118: RuntimeWarning: invalid value encountered in true_divide\n",
      "  S_u[u] = D_u[u] / D\n"
     ]
    }
   ],
   "source": [
    "# Create an analysis class and run the analysis.\n",
    "campaign.get_collation_result()\n",
    "analysis = uq.analysis.SCAnalysis(sampler=sampler, qoi_cols=output_columns)\n",
    "campaign.apply_analysis(analysis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A standard SC (or PCE) campaign would be over at this point. Except we have thus far only sampled a single point in the stochastic domain. To show this, we define the following function to plot 2D slices of the *accepted* points in the 20 dimensional input space. The `analysis.l_norm` array contains the accepted multi indices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:35:58.133424Z",
     "start_time": "2021-06-09T07:35:58.130702Z"
    },
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "def plot_grid_2D():\n",
    "    fig = plt.figure(figsize=[12,4])\n",
    "    ax1 = fig.add_subplot(131, xlim=[-0.05, 1.05], ylim=[-0.05, 1.05], xlabel='x1', ylabel='x2', title='(x1, x2) plane')\n",
    "    ax2 = fig.add_subplot(132, xlim=[-0.05, 1.05], ylim=[-0.05, 1.05], xlabel='x3', ylabel='x4', title='(x3, x4) plane')\n",
    "    ax3 = fig.add_subplot(133, xlim=[-0.05, 1.05], ylim=[-0.05, 1.05], xlabel='x19', ylabel='x20', title='(x19, x20) plane')\n",
    "    \n",
    "    accepted_grid = sampler.generate_grid(analysis.l_norm)\n",
    "    ax1.plot(accepted_grid[:,0], accepted_grid[:,1], 'o')\n",
    "    ax2.plot(accepted_grid[:,2], accepted_grid[:,3], 'o')\n",
    "    ax3.plot(accepted_grid[:,18], accepted_grid[:,19], 'o')\n",
    "    \n",
    "    plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:35:58.347980Z",
     "start_time": "2021-06-09T07:35:58.134669Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAGGCAYAAACqvTJ0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAABDGElEQVR4nO3de1jUZf7/8dcgJxWZUhNPRGjmsSxxNTVXLcPU7GCtVpjWWldaraeszfTrqVo62lnN0g67ZmamHZYUVk3x0CaKrqXV5glLUNEENAWB+/cHP9hGwAGEe2bg+biu+YN77s/M+x63+7XznpnPx2GMMQIAAAAAAAAs8vN0AQAAAAAAAKh5aEoBAAAAAADAOppSAAAAAAAAsI6mFAAAAAAAAKyjKQUAAAAAAADraEoBAAAAAADAOppSAAAAAAAAsI6mFAAAAAAAAKyjKQUAAAAAAADraErBZ8ycOVPt2rVTfn5+uY99+eWXNXjwYEVGRsrhcKh3796VX2AJUlNTNWXKFHXr1k0NGzZUaGiooqKiNG/ePOXl5bnMnT9/vpo1a6aTJ09Weh0Oh0PTp0+v9McFAG9T0aw4efKk7rjjDrVu3Vr16tVT3bp11b59ez311FNVsi+fy6FDh9SgQQM5HA59/PHHLveRFQBQMlvvFVauXKkePXqodu3acjqdGjRokL777rvzqLxsVq9erT//+c9q06aN6tatq2bNmunmm2/Wli1bSpy/detW9e3bVyEhIbrgggs0ePBg7dmzx2XOjz/+qMDAQG3durXS6+3du7e191zwbTSl4BMOHjyo5557TjNnzpSfX/n/Zzt37lzt379f1157rS666KIqqLBkW7Zs0fvvv6/rrrtO77//vpYuXapevXpp9OjRuv/++13mjhgxQnXr1tVzzz1nrT4AqE7OJyvOnDkjY4wmTJigpUuX6tNPP9Vtt92mmTNn6uabb66iikv20EMPKTg4uMT7yAoAKM7We4VPP/1U/fv3V6NGjbR06VLNnTtX//3vf9WzZ0/t3r37fJbg1pw5c7Rv3z6NHTtWcXFxeuWVV3T48GFdffXVWr16tcvc77//Xr1791ZOTo4++ugjLViwQD/++KN69uypI0eOFM277LLLFBMTo/Hjx1dp7cA5GcAHPPbYY6ZZs2YmLy+vQsf//rj27dubXr16VVJl53bs2DGTk5NTbPyhhx4ykkxKSorL+AsvvGCcTqc5efJkpdYhyUybNq1SHxMAvM35ZkVpjynJ7N69u9Ie81w+/vhjExISYt577z0jySxZsqTYHLICAFzZeq/QunVrc8UVV5j8/PyisX379pnAwEBz1113Vei5y+rQoUPFxrKyskxYWJi57rrrXMb/9Kc/mYYNG5qMjAyXOgMCAsxjjz3mMjcpKclIMhs2bKjUenv16mXtPRd8G9+UgtfLycnR/Pnzddddd7l88vHMM8/Iz89Pn3/+ucv8e+65R3Xq1NGOHTuKxiryicm5fPjhh3I4HHr99dddxqdNm6ZatWopISFBknThhRcqICCg2PFdunSRJP38888u4zExMcrMzNSHH37otobevXurQ4cOSkxM1NVXX63atWurWbNm+r//+79iPw0825EjR/Tggw+qXbt2CgkJUaNGjXTttdcqMTHRZd6+ffvkcDj0wgsvaNasWYqMjFRISIi6deumr7/+utjjJiUl6aabblL9+vUVHBysq666Sh999JHbtQDA+aqMrChJ4Sfm/v7+5a6prFlR6NixY3rooYf09NNP6+KLLy71cckKAPgfW+8Vjh49qh9++EH9+/eXw+EoGo+IiFCHDh20fPlyt/vq2YwxGjBggBo0aKCUlJSi8d9++03t27dX27Zti36u3ahRo2LHh4SEqF27djpw4EDRWG5urr744gvddtttCg0NdamzT58+WrZsmctjREVFqW3btpo7d67beqdPny6Hw6Hk5GQNHjxYoaGhcjqdGjZsmMs3sEozY8YMde3aVfXr11doaKg6deqk+fPnyxjjMu+SSy7RjTfeqBUrVqhTp06qXbu22rRpowULFhR7zLS0ND3wwANq3ry5AgMDFRkZqRkzZig3N9dtPfASnu6KAe6sW7fOSDJxcXEu4/n5+WbAgAHmwgsvNPv27TPGGLNgwQIjybz99tulPl5lfVNq1KhRJjAw0GzevNkYY8yqVauMn5+fmTJlittjR4wYYfz9/U16enqx+9q2bWsGDx7s9jF69eplGjRoYJo2bWpeffVVs3LlSjNmzBgjyTz00EMuc3XWp9/ff/+9GT16tPnwww/NV199Zb744gszcuRI4+fnZ9asWVM0b+/evUaSueSSS8wNN9xgli9fbpYvX24uv/xyc+GFF5rjx48XzV29erUJDAw0PXv2NIsXLzYrVqww99xzj5Fk3nnnHbfrAYDzUVlZkZ+fb86cOWMyMjLMl19+aRo3bmzuvPPOCtdVnqyIiYkxV199tcnLyzNr1qwp9ZtSxpAVAFDI1nuFgwcPGklm6tSpxe7r1q2bkWR++OGHctefnp5umjdvbrp27Vr0C4sRI0aY2rVrm//85z/nPPb48ePG6XSaW2+9tWjs+++/N5LMG2+8UWz+xIkTjcPhMKdOnXIZHz16tGnYsKHLN8BKMm3aNCPJREREmEcffdSsXLnSzJo1y9StW9dcddVVLr8QKembUvfcc4+ZP3++SUhIMAkJCebJJ580tWvXNjNmzHCZFxERYZo3b27atWtn3n//fbNy5Urzpz/9yUgya9euLZqXmppqwsPDTUREhHnzzTfNv/71L/Pkk0+aoKAgc88995xzLfAeNKXg9Z599lkjyaSlpRW7r3AT79Kli9m6daupU6eOGTZs2Dkfr7KaUqdPnzZXXXWViYyMNDt37jRhYWGmV69eJjc395zHrVy50vj5+Znx48eXeH9MTIwJCwtz+/y9evUyksynn37qMn7//fcbPz8/s3///qKxs99onC03N9ecOXPGXHfddS6hVvhG4/LLL3dZ1zfffGMkmUWLFhWNtWnTxlx11VXmzJkzLo994403miZNmlTqz2kA4GyVlRWLFi0ykopu9957b7F9rTzKmhVffPGFCQgIMDt27DDGGLdNKbICAArYeq+Ql5dn6tevX+yncr/++qupV6+ekWQ2btxYoTWsX7/e+Pv7m3HjxpWpcVYoJibG+Pv7m6SkpKKxDRs2FNt7C/3tb38zkszBgwddxt966y0jyezateucz1fYlDr7fczChQuNJPOPf/yjaMzdz/fy8vLMmTNnzMyZM02DBg1cGmIREREmODjYJaNOnTpl6tevbx544IGisQceeMCEhIS4zDOm4Gfuksx33313zvXAO/DzPXi9gwcPyuFwqGHDhsXua9CggRYvXqytW7eqe/fuuvjii8v01dPKEBQUpI8++khHjx5Vp06dZIzRokWLVKtWrVKP2bp1q4YMGaKrr75asbGxJc5p1KiRDh8+XKavnNarV0833XSTy9hdd92l/Px8rVu37pzHzp07V506dVJwcLD8/f0VEBCgVatWadeuXcXmDhw40GVdV1xxhSRp//79kqSffvpJ33//vWJiYiQVfG248DZgwAClpqbqhx9+cLseAKioysqKfv36afPmzVq9erWefvppLV26VLfddluFruYklS0rMjIy9MADD+ivf/2rOnToUKbHJSsAoICt9wp+fn566KGHtGrVKj355JM6fPiwfvrpJw0bNky//fZb0ZyK6NGjh55++mm9/PLLGj16tIYNG6aRI0ee85j/+7//08KFC/XSSy8pKiqq2P2//4mhu/sKfxr4yy+/lKnewn280JAhQ+Tv7681a9ac87jVq1erb9++cjqdqlWrlgICAjR16lQdPXpUhw8fdpl75ZVXuvyUPTg4WJdddllRpkjSF198oT59+qhp06YumdK/f39J0tq1a8u0HngWTSl4vVOnTikgIKDUZk/Xrl3Vvn17nT59WqNHj1bdunWt1XbppZeqZ8+eOn36tGJiYtSkSZNS5yYnJ+v6669Xq1atFBcXp6CgoBLnBQcHyxij06dPu33+sLCwYmONGzeWVPC799LMmjVLo0ePVteuXbV06VJ9/fXX2rx5s2644QadOnWq2PwGDRq4/F1Ye+HcQ4cOSZImTpyogIAAl9uDDz4oSUpPT3e7HgCoqMrKigsvvFCdO3dWnz599MQTT2jevHn67LPP9Omnn1a4NndZMXnyZAUEBOjhhx/W8ePHdfz4cZ04cUJSwXlFjh8/Xux8G2QFABSw+V5h6tSpGj9+vJ566imFhYWpVatWkqR7771XktSsWbMKP3ZMTIwCAwOVnZ2tRx999JxzZ8yYoaeeekpPP/20Hn74YZf7Cvfikvb3Y8eOyeFw6IILLnAZL7zia0l7e0kKM6SQv7+/GjRocM5M+eabbxQdHS1Jeuutt7RhwwZt3rxZkydPLvG5z84UqSBXfj/v0KFD+vzzz4tlSvv27SWRKb6i/GftBCxr2LChcnJydPLkyRJDZNq0adqxY4eioqI0depU3XjjjWrRooWV2t5++23985//VJcuXfT6669r6NCh6tq1a7F5ycnJ6tu3ryIiIhQfHy+n01nqYx47dkxBQUEKCQlx+/yF/wf/99LS0iSVvJEX+sc//qHevXtrzpw5LuNZWVlun7MkhZ9MTZo0SYMHDy5xTuvWrSv02ABQFlWVFYUXpvjxxx8rXJu7rPj222+1b9++Yv8nX5JGjBghSfr1119d3kSQFQBQwOZ7BX9/f82aNUszZ87U3r171bBhQzVp0kT9+vVTZGSkmjdvXqHHzcvLU0xMjC688EIFBQVp5MiR2rBhgwIDA4vNnTFjhqZPn67p06friSeeKHZ/y5YtVbt27RIv5LFjxw5deumlRU2oQseOHZOkEr9tVpK0tDSXBlxubq6OHj16zkz58MMPFRAQoC+++MLl+ZcvX16m5yxJw4YNdcUVV+jpp58u8f6mTZtW+LFhD9+Ugtdr06aNJGn37t3F7ktISFBsbKymTJmihIQEOZ1ODR06VDk5OVVe144dOzRmzBgNHz5ciYmJuuKKKzR06FD9+uuvLvO2bdumvn37qnnz5kpISNCFF154zsfds2eP2rVrV6YasrKy9Nlnn7mMffDBB/Lz89Mf//jHUo9zOBzFvqn1n//8R5s2bSrT856tdevWatWqlbZv367OnTuXeKtXr16FHhsAyqKqsqLwpwiXXnppheoqS1a8/PLLWrNmjcvtpZdeklRwpaM1a9YUaz6RFQBQwBPvFUJCQnT55ZerSZMm2rp1q1atWqWxY8dW+PGmTZumxMRELVy4UIsXL9b27dtL/LbUk08+qenTp2vKlCmaNm1aiY/l7++vQYMG6ZNPPnH5ECElJUVr1qwp8UOBPXv2yM/Pr8wfDCxcuNDl748++ki5ubnq3bt3qcc4HA75+/u7fKPt1KlT+vvf/16m5yzJjTfeqG+//VYtW7YsMVNoSvkIj57RCiiDlJQUI8m8+eabLuMHDx40jRo1Mn369Ck6MeqmTZtMQECAGTt2rMvczZs3myVLlpglS5aY8PBw065du6K/C6/GYcz/TtY6YsSIc9Z04sQJ06ZNG9OuXTtz4sQJY4wxu3fvNk6n09x8881F877//nvToEEDU79+ffP555+bTZs2udwOHz7s8rh5eXnG6XSaCRMmuH1dfn9Fpddee82sXLnSjB071kgyo0ePdpmrs05eO3XqVONwOMzUqVPNqlWrzOzZs03jxo1Ny5YtTURERLHX4/nnny/2/Gc/5urVq01QUJCJjo42H3zwgVm7dq1ZtmyZ+dvf/mZuv/12t+sBgPNxvlkxd+5cExMTY9577z2zevVq8/nnn5vHHnvM1K5d23Tv3t3lxNyVnRUlOdeJzskKAPgfm+8V1qxZY5577jmzYsUK8+WXX5oZM2aYOnXqmIEDBxa7gEXhScF/f7XSksTHxxs/Pz+XvbLwRN2ffPJJsbEbbrih2HuKTZs2uTzmrl27TEhIiPnjH/9o4uLizCeffGI6dOhgmjZtWuz9hzHGDBo0yHTq1Omcdf5+TYVX34uPjzcvvfSSCQkJMR07djTZ2dlFc88+0fmqVauMJHP77beb+Ph4s2jRIhMVFWVatWplJJm9e/cWzY2IiDADBw4s9vxnP+bBgwdNRESEadOmjZk9e7ZZtWqV+ec//2neeOMNM3DgQHPgwAG3a4Ln0ZSCT+jZs6cZMGBA0d+5ubmmV69eJiwszKSmprrMff75540ks2zZsqKxESNGuFxN6fe331+CeseOHUaSefzxx89Zz7Bhw0ydOnWKXdFhyZIlRpJ56aWXjDHGvPPOO6U+79nPbcz/NustW7a4fU169epl2rdvb7766ivTuXNnExQUZJo0aWKeeOKJYlc1OvtNQXZ2tpk4caJp1qyZCQ4ONp06dTLLly83I0aMqPAbDWOM2b59uxkyZIhp1KiRCQgIMI0bNzbXXnutmTt3rtv1AMD5Op+s2LBhg7nxxhtN06ZNTWBgoKlTp47p2LGjefLJJ83Jkyddjq3srCjJuZpSZAUAuLL1XmHDhg2ma9euJjQ01AQFBZkOHTqYF154weTk5BSr6ZFHHjEOh+OcV7QrbJxde+21Llcfzc/PN4MGDTIXXHBBUbOm8Gqqpd3OlpSUZK677jpTp04dExoaam655Rbz008/FZuXlZVl6tSpY1588cVS6yxU2JTasmWLGTRokAkJCTH16tUzd955pzl06JDL3JKuvrdgwQLTunVrExQUZFq0aGFiY2PN/PnzK9yUMsaYI0eOmDFjxpjIyEgTEBBg6tevb6KioszkyZOLPhCCd3MYc9aZMwEvtHTpUg0dOlT79+8/rxMIujN79mw99thj2r17d4knhq1qd999t/bs2aMNGza4ndu7d2+lp6fr22+/tVAZAHg/sqI4sgJATWBr/y+PLl26KCIiQkuWLPF0Kec0f/58jR07VgcOHHB7mpHp06drxowZOnLkSJnPPwW4wzml4BMGDx6sP/zhD4qNja3S51mzZo3GjBnjkTcZu3fv1uLFi/Xss89af24AqA7ICgComWzt/2WVmZmp7du3a+bMmZ4u5Zxyc3P17LPPatKkSW4bUkBV4ep78AkOh0NvvfWWPvvsM+Xn58vPr2r6qZ78JCMlJUWvv/66rrnmGo/VAAC+jKwAgJrJ1v5fVqGhocrOzvZoDWVx4MABDRs2TI888oinS0ENxs/3AAAAAAAAYB0/3wMAAAAAAIB1NKUAAAAAAABgHU0pAAAAAAAAWFfjTnSen5+vgwcPql69enI4HJ4uBwC8ijFGWVlZatq0qcdPEupJZAUAlI6sKEBWAEDpypoVNa4pdfDgQYWHh3u6DADwagcOHFDz5s09XYbHkBUA4B5ZQVYAgDvusqLGNaXq1asnqeCFCQ0N9XA1AOBdMjMzFR4eXrRX1lRkBQCUjqwoQFYAQOnKmhU1rilV+NXa0NBQwgMASlHTf4ZAVgCAe2QFWQEA7rjLipr7I3AAAAAAAAB4DE0pAAAAAAAAWEdTCgAAAAAAANbRlAIAAAAAAIB1NKUAAAAAAABgHU0pAAAAAAAAWEdTCgAAAAAAANZ5tCm1bt06DRo0SE2bNpXD4dDy5cvdHrN27VpFRUUpODhYLVq00Ny5c6u+UACAx5AVAAB3yAoA8E0ebUqdPHlSHTt21Ouvv16m+Xv37tWAAQPUs2dPJScn64knntCYMWO0dOnSKq4UAOApZAUAwB2yAgB8k78nn7x///7q379/mefPnTtXF198sV5++WVJUtu2bZWUlKQXXnhBt912WxVVCQDwJLICAOAOWQEAvsmnzim1adMmRUdHu4z169dPSUlJOnPmTInHZGdnKzMz0+UGAKi+yAoAgDtkBQB4B59qSqWlpSksLMxlLCwsTLm5uUpPTy/xmNjYWDmdzqJbeHi4jVIBAB5CVgAA3CErAMA7+FRTSpIcDofL38aYEscLTZo0SRkZGUW3AwcOVHmNAADPIisAAO6QFQDgeR49p1R5NW7cWGlpaS5jhw8flr+/vxo0aFDiMUFBQQoKCrJRHgDAC5AVAAB3yAoA8A4+9U2pbt26KSEhwWUsPj5enTt3VkBAgIeqAgB4E7ICAOAOWQEA3sGjTakTJ05o27Zt2rZtm6SCS7Nu27ZNKSkpkgq+Ijt8+PCi+aNGjdL+/fs1YcIE7dq1SwsWLND8+fM1ceJET5QPALCArAAAuENWAIBv8ujP95KSktSnT5+ivydMmCBJGjFihN59912lpqYWBYkkRUZGKi4uTuPHj9cbb7yhpk2b6tVXX+WyrQBQjZEVAAB3yAoA8E0OU3hGvxoiMzNTTqdTGRkZCg0N9XQ5AOBV2CML8DoAQOnYIwvwOgBA6cq6R/rUOaUAAAAAAABQPdCUAgAAAAAAgHU0pQAAAAAAAGAdTSkAAAAAAABYR1MKAAAAAAAA1tGUAgAAAAAAgHU0pQAAAAAAAGAdTSkAAAAAAABYR1MKAAAAAAAA1tGUAgAAAAAAgHU0pQAAAAAAAGAdTSkAAAAAAABYR1MKAAAAAAAA1tGUAgAAAAAAgHU0pQAAAAAAAGAdTSkAAAAAAABYR1MKAAAAAAAA1tGUAgAAAAAAgHU0pQAAAAAAAGAdTSkAAAAAAABYR1MKAAAAAAAA1tGUAgAAAAAAgHU0pQAAAAAAAGAdTSkAAAAAAABYR1MKAAAAAAAA1tGUAgAAAAAAgHU0pQAAAAAAAGAdTSkAAAAAAABYR1MKAAAAAAAA1tGUAgAAAAAAgHU0pQAAAAAAAGAdTSkAAAAAAABYR1MKAAAAAAAA1tGUAgAAAAAAgHU0pQAAAAAAAGAdTSkAAAAAAABYR1MKAAAAAAAA1tGUAgAAAAAAgHU0pQAAAAAAAGAdTSkAAAAAAABYR1MKAAAAAAAA1tGUAgAAAAAAgHU0pQAAAAAAAGAdTSkAAAAAAABY5/Gm1OzZsxUZGang4GBFRUUpMTHxnPMXLlyojh07qk6dOmrSpInuvfdeHT161FK1AABPICsAAO6QFQDgezzalFq8eLHGjRunyZMnKzk5WT179lT//v2VkpJS4vz169dr+PDhGjlypL777jstWbJEmzdv1n333We5cgCALWQFAMAdsgIAfJNHm1KzZs3SyJEjdd9996lt27Z6+eWXFR4erjlz5pQ4/+uvv9Yll1yiMWPGKDIyUtdcc40eeOABJSUlWa4cAGALWQEAcIesAADf5LGmVE5OjrZs2aLo6GiX8ejoaG3cuLHEY7p3766ff/5ZcXFxMsbo0KFD+vjjjzVw4EAbJQMALCMrAADukBUA4Ls81pRKT09XXl6ewsLCXMbDwsKUlpZW4jHdu3fXwoULNXToUAUGBqpx48a64IIL9Nprr5X6PNnZ2crMzHS5AQB8A1kBAHCHrAAA3+XxE507HA6Xv40xxcYK7dy5U2PGjNHUqVO1ZcsWrVixQnv37tWoUaNKffzY2Fg5nc6iW3h4eKXWDwCoemQFAMAdsgIAfI/DGGM88cQ5OTmqU6eOlixZoltvvbVofOzYsdq2bZvWrl1b7Ji7775bp0+f1pIlS4rG1q9fr549e+rgwYNq0qRJsWOys7OVnZ1d9HdmZqbCw8OVkZGh0NDQSl4VAPi2zMxMOZ1Or9kjyQoA8D5kRQGyAgBKV9as8Ng3pQIDAxUVFaWEhASX8YSEBHXv3r3EY3777Tf5+bmWXKtWLUkFn4SUJCgoSKGhoS43AIBvICsAAO6QFQDguzz6870JEybo7bff1oIFC7Rr1y6NHz9eKSkpRV+bnTRpkoYPH140f9CgQfrkk080Z84c7dmzRxs2bNCYMWPUpUsXNW3a1FPLAABUIbICAOAOWQEAvsnfk08+dOhQHT16VDNnzlRqaqo6dOiguLg4RURESJJSU1OVkpJSNP+ee+5RVlaWXn/9dT3yyCO64IILdO211+rZZ5/11BIAAFWMrAAAuENWAIBv8tg5pTzF234DDwDehD2yAK8DAJSOPbIArwMAlM7rzykFAAAAAACAmoumFAAAAAAAAKyjKQUAAAAAAADraEoBAAAAAADAOppSAAAAAAAAsI6mFAAAAAAAAKyjKQUAAAAAAADraEoBAAAAAADAOppSAAAAAAAAsI6mFAAAAAAAAKyjKQUAAAAAAADraEoBAAAAAADAOppSAAAAAAAAsI6mFAAAAAAAAKyjKQUAAAAAAADraEoBAAAAAADAOppSAAAAAAAAsI6mFAAAAAAAAKyjKQUAAAAAAADraEoBAAAAAADAOppSAAAAAAAAsI6mFAAAAAAAAKyjKQUAAAAAAADraEoBAAAAAADAOppSAAAAAAAAsI6mFAAAAAAAAKyjKQUAAAAAAADraEoBAAAAAADAOppSAAAAAAAAsI6mFAAAAAAAAKyjKQUAAAAAAADraEoBAAAAAADAOppSAAAAAAAAsI6mFAAAAAAAAKyjKQUAAAAAAADraEoBAAAAAADAOppSAAAAAAAAsI6mFAAAAAAAAKyjKQUAAAAAAADraEoBAAAAAADAOppSAAAAAAAAsI6mFAAAAAAAAKyjKQUAAAAAAADraEoBAAAAAADAOppSAAAAAAAAsM7jTanZs2crMjJSwcHBioqKUmJi4jnnZ2dna/LkyYqIiFBQUJBatmypBQsWWKoWAOAJZAUAwB2yAgB8j78nn3zx4sUaN26cZs+erR49eujNN99U//79tXPnTl188cUlHjNkyBAdOnRI8+fP16WXXqrDhw8rNzfXcuUAAFvICgCAO2QFAPgmhzHGeOrJu3btqk6dOmnOnDlFY23bttUtt9yi2NjYYvNXrFihO+64Q3v27FH9+vUr9JyZmZlyOp3KyMhQaGhohWsHgOrIG/dIsgIAvIs37pFkBQB4l7LukR77+V5OTo62bNmi6Ohol/Ho6Ght3LixxGM+++wzde7cWc8995yaNWumyy67TBMnTtSpU6dslAwAsIysAAC4Q1YAgO/y2M/30tPTlZeXp7CwMJfxsLAwpaWllXjMnj17tH79egUHB2vZsmVKT0/Xgw8+qGPHjpX6++/s7GxlZ2cX/Z2ZmVl5iwAAVCmyAgDgDlkBAL7L4yc6dzgcLn8bY4qNFcrPz5fD4dDChQvVpUsXDRgwQLNmzdK7775b6qcasbGxcjqdRbfw8PBKXwMAoGqRFQAAd8gKAPA9HmtKNWzYULVq1Sr26cXhw4eLfcpRqEmTJmrWrJmcTmfRWNu2bWWM0c8//1ziMZMmTVJGRkbR7cCBA5W3CABAlSIrAADukBUA4Ls81pQKDAxUVFSUEhISXMYTEhLUvXv3Eo/p0aOHDh48qBMnThSN/fjjj/Lz81Pz5s1LPCYoKEihoaEuNwCAbyArAADukBUA4Ls8+vO9CRMm6O2339aCBQu0a9cujR8/XikpKRo1apSkgk8jhg8fXjT/rrvuUoMGDXTvvfdq586dWrdunR599FH9+c9/Vu3atT21DABAFSIrAADukBUA4Js8dqJzSRo6dKiOHj2qmTNnKjU1VR06dFBcXJwiIiIkSampqUpJSSmaHxISooSEBP3lL39R586d1aBBAw0ZMkRPPfWUp5YAAKhiZAUAwB2yAgB8k8MYYzxdhE2ZmZlyOp3KyMjgK7cAcBb2yAK8DgBQOvbIArwOAFC6su6RHr/6HgAAAAAAAGoemlIAAAAAAACwjqYUAAAAAAAArKMpBQAAAAAAAOtoSgEAAAAAAMA6mlIAAAAAAACwjqYUAAAAAAAArKMpBQAAAAAAAOtoSgEAAAAAAMA6mlIAAAAAAACwjqYUAAAAAAAArKMpBQAAAAAAAOtoSgEAAACwavPmzYqJiVFkZKRq166tOnXqKDIyUjExMUpKSvJ0eQAAS/w9XQAAAACAmmP58uUaMmSIrrvuOo0dO1ZhYWEyxujw4cOKj49Xjx499NFHH+nmm2/2dKkAgCpGUwoAAACANVOmTNHMmTP1+OOPF7tv3LhxevbZZ/XEE0/QlAKAGoCf7wEAqtxXX32lU6dOeboMAIAX+OmnnzR48OBS77/lllu0e/duixUBADylXE2p7du366mnntLs2bOVnp7ucl9mZqb+/Oc/V2pxAIDqITo6Wvv27fN0GQAAL9CyZUstX7681Ps//fRTtWjRwl5BAACPKfPP9+Lj4zVo0CC1atVKWVlZmjZtmj766CP16dNHknTq1Cm99957WrBgQZUVC1Q3eflG3+w9psNZp9WoXrC6RNZXLT+Hp8sCKqxTp04ljufm5uq2225TcHCwJGnr1q02ywJ8GlmB6mbmzJm64447tHbtWkVHRyssLEwOh0NpaWlKSEhQfHy8PvzwQ0+XCfgUsgK+qsxNqenTp2vixIl6+umnZYzRCy+8oJtuuklLlizRDTfcUJU1AtXSim9TNePznUrNOF001sQZrGmD2umGDk08WBlQcTt27FDfvn119dVXF40ZY7R9+3b16dNHjRo18mB1gO8hK1Ad3XbbbVq3bp1eeeUVzZo1S2lpaZKkxo0bq1u3blq7dq26devm4SoB30FWwJc5jDGmLBOdTqe2bt2qli1bFo0tWrRI999/vxYtWqQuXbqoadOmysvLq7JiK0NmZqacTqcyMjIUGhrq6XJQQ634NlWj/7FVZ//HV/hZxpxhnQgQeMT57pEbNmzQiBEjFBMTo2nTpsnPr+BX4gEBAdq+fbvatWtX2SVXCbIC3oCsgLdijyzA6wBvQFbAW5V1jyzzOaWCgoJ0/Phxl7E777xT8+fP1x133KFly5ZVuFigJsnLN5rx+c5iwSGpaGzG5zuVl1+mfjHgVXr06KGtW7fqxx9/VLdu3ThRLVBBZAUAwB2yAtVBmZtSV155pdasWVNsfOjQoXr77bc1ZsyYSi0MqK6+2XvM5au1ZzOSUjNO65u9x+wVBVSi0NBQLVq0SKNGjdI111yjefPmyeHgnAZAeZAVqO64gBJw/sgKVAdlbkqNHj1av/zyS4n33XnnnXrvvff0xz/+sdIKA6qrw1mlB0dF5gHe6t5779W6dev09ttvKzc319PlAD6FrEB1Fh8fry5duujDDz/Us88+q7Zt27p8+F14ASUA50ZWoDooc1Pq1ltv1UsvvaR//etfJd5/55136o477qi0woDqqlG94EqdB3ijwqxo1aqVvv76a/36669q27atJOnNN9/0ZGmATyArUJ0VXkDp22+/1b59+/TYY4/ppptu0ooVKzxdGuBTyApUB2VuShUaOHCgHnnkEeXk5BSNHTlyRIMGDdKkSZMqtTigOuoSWV9NnMEq7cdMDhVcLaNLZH2bZQGV6vdZ4efnJ6fTqfT0dLICKCOyAtXZd999V/TzPIfDoUcffVTz5s3T7bffrs8//9zD1QG+g6xAdVDuptS6dev0+eef6w9/+IO+++47/fOf/1SHDh104sQJbd++vSpqBKqVWn4OTRtUcAWyswOk8O9pg9qplh/n4IHvIiuA80NWoDrjAkpA5SArUB2UuynVtWtXJScn64orrlBUVJRuvfVWPfLII1q9erXCw8Orokag2rmhQxPNGdZJjZ2uX6Vt7Azmsq2oFsgK4PyRFaiuuIASUHnICvg6/4oc9MMPP2jz5s1q3ry5Dh48qO+//16//fab6tatW9n1AdXWDR2a6Pp2jfXN3mM6nHVajeoVfLWWTzJQXZAVwPkjK1AdjR49WuvWrSvxvjvvvFOSNG/ePJslAT6NrIAvK/c3pZ555hl169ZN119/vb799ltt3ry56NPwTZs2VUWNQLVVy8+hbi0b6OYrm6lbywYEB6oNsgKoPGQFqhsuoARUPrICvqrcTalXXnlFy5cv12uvvabg4GC1b99e33zzjQYPHqzevXtXQYkAAF9DVgAA3OECSgCAcjelduzYof79+7uMBQQE6Pnnn1d8fHylFQYA8F1kBQDAHS6KAQAod1OqYcOGpd7Xq1ev8yoGAFA9kBUAAHe4KAYAoNxNKQAAAACoDL+/KIa/v3/RRTEAADUDTSkAAAAA1nFRDAAATSkAAAAA1nFRDACAv6cLAAAAAFDz7Nixo9g5CAsvinHjjTd6qCoAgE18UwoAAACAdVwUAwBAUwoAAAAAAADW0ZQCAAAAAACAdTSlAAAAAAAAYB1NKQAAAAAAAFhHUwoAAAAAAADW0ZQCAAAAAACAdTSlAAAAAAAAYB1NKQAAAAAAAFjn8abU7NmzFRkZqeDgYEVFRSkxMbFMx23YsEH+/v668sorq7ZAAIDHkRUAAHfICgDwPR5tSi1evFjjxo3T5MmTlZycrJ49e6p///5KSUk553EZGRkaPny4rrvuOkuVAgA8hawAALhDVgCAb3IYY4ynnrxr167q1KmT5syZUzTWtm1b3XLLLYqNjS31uDvuuEOtWrVSrVq1tHz5cm3btq3Mz5mZmSmn06mMjAyFhoaeT/kAUO144x5JVgCAd/HGPZKsAADvUtY90mPflMrJydGWLVsUHR3tMh4dHa2NGzeWetw777yj3bt3a9q0aWV6nuzsbGVmZrrcAAC+gawAALhDVgCA7/JYUyo9PV15eXkKCwtzGQ8LC1NaWlqJx/z3v//V448/roULF8rf379MzxMbGyun01l0Cw8PP+/aAQB2kBUAAHfICgDwXR4/0bnD4XD52xhTbEyS8vLydNddd2nGjBm67LLLyvz4kyZNUkZGRtHtwIED510zAMAusgIA4A5ZAQC+p2wfC1SBhg0bqlatWsU+vTh8+HCxTzkkKSsrS0lJSUpOTtbDDz8sScrPz5cxRv7+/oqPj9e1115b7LigoCAFBQVVzSIAAFWKrAAAuENWAIDv8tg3pQIDAxUVFaWEhASX8YSEBHXv3r3Y/NDQUO3YsUPbtm0ruo0aNUqtW7fWtm3b1LVrV1ulAwAsISsAAO6QFQDguzz2TSlJmjBhgu6++2517txZ3bp107x585SSkqJRo0ZJKviK7C+//KL3339ffn5+6tChg8vxjRo1UnBwcLFxAED1QVYAANwhKwDAN3m0KTV06FAdPXpUM2fOVGpqqjp06KC4uDhFRERIklJTU5WSkuLJEgEAHkZWAADcISsAwDc5jDHG00XYlJmZKafTqYyMDIWGhnq6HADwKuyRBXgdAKB07JEFeB0AoHRl3SM9fvU9AAAAAAAA1Dw0pQAAAAAAAGAdTSkAAAAAAABYR1MKAAAAAAAA1tGUAgAAAAAAgHU0pQAAAAAAAGAdTSkAAAAAAABYR1MKAAAAAAAA1tGUAgAAAAAAgHU0pQAAAAAAAGAdTSkAAAAAAABYR1MKAAAAAAAA1tGUAgAAAAAAgHU0pQAAAAAAAGAdTSkAAAAAAABYR1MKAAAAAAAA1tGUAgAAAAAAgHU0pQAAAAAAAGAdTSkAAAAAAABYR1MKAAAAAAAA1tGUAgAAAAAAgHU0pQAAAAAAAGAdTSkAAAAAAABYR1MKAAAAAAAA1tGUAgAAAAAAgHU0pQAAAAAAAGAdTSkAAAAAAABYR1MKAAAAAAAA1tGUAgAAAAAAgHU0pQAAAAAAAGAdTSkAAAAAAABYR1MKAAAAAAAA1tGUAgAAAAAAgHU0pQAAAAAAAGAdTSkAAAAAAABYR1MKAAAAAAAA1tGUAgAAAAAAgHU0pQAAAAAAAGAdTSkAAAAAAABYR1MKAAAAAAAA1tGUAgAAAAAAgHU0pQAAAAAAAGAdTSkAAAAAAABYR1MKAAAAAAAA1tGUAgAAAAAAgHUeb0rNnj1bkZGRCg4OVlRUlBITE0ud+8knn+j666/XRRddpNDQUHXr1k0rV660WC0AwBPICgCAO2QFAPgejzalFi9erHHjxmny5MlKTk5Wz5491b9/f6WkpJQ4f926dbr++usVFxenLVu2qE+fPho0aJCSk5MtVw4AsIWsAAC4Q1YAgG9yGGOMp568a9eu6tSpk+bMmVM01rZtW91yyy2KjY0t02O0b99eQ4cO1dSpU8s0PzMzU06nUxkZGQoNDa1Q3QBQXXnjHklWAIB38cY9kqwAAO9S1j3SY9+UysnJ0ZYtWxQdHe0yHh0drY0bN5bpMfLz85WVlaX69euXOic7O1uZmZkuNwCAbyArAADukBUA4Ls81pRKT09XXl6ewsLCXMbDwsKUlpZWpsd48cUXdfLkSQ0ZMqTUObGxsXI6nUW38PDw86obAGAPWQEAcIesAADf5fETnTscDpe/jTHFxkqyaNEiTZ8+XYsXL1ajRo1KnTdp0iRlZGQU3Q4cOHDeNQMA7CIrAADukBUA4Hv8PfXEDRs2VK1atYp9enH48OFin3KcbfHixRo5cqSWLFmivn37nnNuUFCQgoKCzrteAIB9ZAUAwB2yAgB8l8e+KRUYGKioqCglJCS4jCckJKh79+6lHrdo0SLdc889+uCDDzRw4MCqLhMA4EFkBQDAHbICAHyXx74pJUkTJkzQ3Xffrc6dO6tbt26aN2+eUlJSNGrUKEkFX5H95Zdf9P7770sqCI7hw4frlVde0dVXX130aUjt2rXldDo9tg4AQNUhKwAA7pAVAOCbPNqUGjp0qI4ePaqZM2cqNTVVHTp0UFxcnCIiIiRJqampSklJKZr/5ptvKjc3Vw899JAeeuihovERI0bo3XfftV0+AMACsgIA4A5ZAQC+yWGMMZ4uwqbMzEw5nU5lZGQoNDTU0+UAgFdhjyzA6wAApWOPLMDrAAClK+se6fGr7wEAAAAAAKDmoSkFAAAAAAAA62hKAQAAAAAAwDqaUgAAAAAAALCOphQAAAAAAACsoykFAAAAAAAA62hKAQAAAAAAwDqaUgAAAAAAALCOphQAAAAAAACsoykFAAAAAAAA62hKAQAAAAAAwDqaUgAAAAAAALCOphQAAAAAAACsoykFAAAAAAAA62hKAQAAAAAAwDqaUgAAAAAAALCOphQAAAAAAACsoykFAAAAAAAA62hKAQAAAAAAwDqaUgAAAAAAALCOphQAAAAAAACsoykFAAAAAAAA62hKAQAAAAAAwDqaUgAAAAAAALCOphQAAAAAAACsoykFAAAAAAAA62hKAQAAAAAAwDqaUgAAAAAAALCOphQAAAAAAACsoykFAAAAAAAA62hKAQAAAAAAwDqaUgAAAAAAALCOphQAAAAAAACsoykFAAAAAAAA62hKAQAAAAAAwDqaUgAAAAAAALCOphQAAAAAAACsoykFAAAAAAAA62hKAQAAAAAAwDqaUgAAAAAAALCOphQAAAAAAACsoykFAAAAAAAA62hKAQAAAAAAwDqaUgAAAAAAALDO402p2bNnKzIyUsHBwYqKilJiYuI5569du1ZRUVEKDg5WixYtNHfuXEuVAgA8hawAALhDVgCA7/FoU2rx4sUaN26cJk+erOTkZPXs2VP9+/dXSkpKifP37t2rAQMGqGfPnkpOTtYTTzyhMWPGaOnSpZYrBwDYQlYAANwhKwDANzmMMcZTT961a1d16tRJc+bMKRpr27atbrnlFsXGxhab/9e//lWfffaZdu3aVTQ2atQobd++XZs2bSrTc2ZmZsrpdCojI0OhoaHnvwgAqEa8cY8kKwDAu3jjHklWAIB3Kese6bFvSuXk5GjLli2Kjo52GY+OjtbGjRtLPGbTpk3F5vfr109JSUk6c+ZMldUKAPAMsgIA4A5ZAQC+y99TT5yenq68vDyFhYW5jIeFhSktLa3EY9LS0kqcn5ubq/T0dDVp0qTYMdnZ2crOzi76OzMzsxKqBwDYQFYAANwhKwDAd3n8ROcOh8Plb2NMsTF380saLxQbGyun01l0Cw8PP8+KAQC2kRUAAHfICgDwPR5rSjVs2FC1atUq9unF4cOHi31qUahx48Ylzvf391eDBg1KPGbSpEnKyMgouh04cKByFgAAqHJkBQDAHbICAHyXx5pSgYGBioqKUkJCgst4QkKCunfvXuIx3bp1KzY/Pj5enTt3VkBAQInHBAUFKTQ01OUGAPANZAUAwB2yAgB8l0d/vjdhwgS9/fbbWrBggXbt2qXx48crJSVFo0aNklTwacTw4cOL5o8aNUr79+/XhAkTtGvXLi1YsEDz58/XxIkTPbUEAEAVIysAAO6QFQDgmzx2onNJGjp0qI4ePaqZM2cqNTVVHTp0UFxcnCIiIiRJqampSklJKZofGRmpuLg4jR8/Xm+88YaaNm2qV199VbfddpunlgAAqGJkBQDAHbICAHyTwxSe0a+GyMzMlNPpVEZGBl+5BYCzsEcW4HUAgNKxRxbgdQCA0pV1j/T41fcAAAAAAABQ89CUAgAAAAAAgHU0pQAAAAAAAGAdTSkAAAAAAABYR1MKAAAAAAAA1tGUAgAAAAAAgHU0pQAAAAAAAGCdv6cLsM0YI0nKzMz0cCUA4H0K98bCvbKmIisAoHRkRQGyAgBKV9asqHFNqaysLElSeHi4hysBAO+VlZUlp9Pp6TI8hqwAAPfICrICANxxlxUOU8M+4sjPz9fBgwdVr149ORyOch2bmZmp8PBwHThwQKGhoVVUofdgvdVbTVpvTVqrdH7rNcYoKytLTZs2lZ9fzf2FN1lRdqy3eqtJ661Ja5XIispAVpQd663eatJ6a9JaJTtZUeO+KeXn56fmzZuf12OEhobWiP8BFmK91VtNWm9NWqtU8fXW5E+9C5EV5cd6q7eatN6atFaJrDgfZEX5sd7qrSattyatVararKi5H20AAAAAAADAY2hKAQAAAAAAwDqaUuUQFBSkadOmKSgoyNOlWMF6q7eatN6atFap5q3X29S015/1Vm81ab01aa1SzVuvt6lprz/rrd5q0npr0lolO+utcSc6BwAAAAAAgOfxTSkAAAAAAABYR1MKAAAAAAAA1tGUAgAAAAAAgHU0pc4ye/ZsRUZGKjg4WFFRUUpMTDzn/LVr1yoqKkrBwcFq0aKF5s6da6nSylGe9X7yySe6/vrrddFFFyk0NFTdunXTypUrLVZ7/sr771tow4YN8vf315VXXlm1BVai8q41OztbkydPVkREhIKCgtSyZUstWLDAUrXnr7zrXbhwoTp27Kg6deqoSZMmuvfee3X06FFL1Z6fdevWadCgQWratKkcDoeWL1/u9hhf36u8DVlBVpSErPB+ZMW5+fpe5W3ICrKiJGSF9yMrzq3S9yqDIh9++KEJCAgwb731ltm5c6cZO3asqVu3rtm/f3+J8/fs2WPq1Kljxo4da3bu3GneeustExAQYD7++GPLlVdMedc7duxY8+yzz5pvvvnG/Pjjj2bSpEkmICDAbN261XLlFVPe9RY6fvy4adGihYmOjjYdO3a0U+x5qshab7rpJtO1a1eTkJBg9u7da/7973+bDRs2WKy64sq73sTEROPn52deeeUVs2fPHpOYmGjat29vbrnlFsuVV0xcXJyZPHmyWbp0qZFkli1bds75vr5XeRuygqwoCVnh/ciKZeec7+t7lbchK8iKkpAV3o+sWHbO+VWxV9GU+p0uXbqYUaNGuYy1adPGPP744yXOf+yxx0ybNm1cxh544AFz9dVXV1mNlam86y1Ju3btzIwZMyq7tCpR0fUOHTrUTJkyxUybNs1nwqO8a/3yyy+N0+k0R48etVFepSvvep9//nnTokULl7FXX33VNG/evMpqrCplCQ9f36u8DVlBVpSErPB+ZMWyc87x9b3K25AVZEVJyArvR1YsO+ecqtir+Pne/5eTk6MtW7YoOjraZTw6OlobN24s8ZhNmzYVm9+vXz8lJSXpzJkzVVZrZajIes+Wn5+vrKws1a9fvypKrFQVXe8777yj3bt3a9q0aVVdYqWpyFo/++wzde7cWc8995yaNWumyy67TBMnTtSpU6dslHxeKrLe7t276+eff1ZcXJyMMTp06JA+/vhjDRw40EbJ1vnyXuVtyIoCZIUrsoKsqA58ea/yNmRFAbLCFVlBVlQHVbFX+VdGYdVBenq68vLyFBYW5jIeFhamtLS0Eo9JS0srcX5ubq7S09PVpEmTKqv3fFVkvWd78cUXdfLkSQ0ZMqQqSqxUFVnvf//7Xz3++ONKTEyUv7/v/KdSkbXu2bNH69evV3BwsJYtW6b09HQ9+OCDOnbsmNf//rsi6+3evbsWLlyooUOH6vTp08rNzdVNN92k1157zUbJ1vnyXuVtyIoCZMX/kBVkRXXhy3uVtyErCpAV/0NWkBXVRVXsVXxT6iwOh8Plb2NMsTF380sa91blXW+hRYsWafr06Vq8eLEaNWpUVeVVurKuNy8vT3fddZdmzJihyy67zFZ5lao8/7b5+flyOBxauHChunTpogEDBmjWrFl69913feJTDal86925c6fGjBmjqVOnasuWLVqxYoX27t2rUaNG2SjVI3x9r/I2ZAVZIZEVZEX14+t7lbchK8gKiawgK6qfyt6rfKdNW8UaNmyoWrVqFeuAHj58uFgnsFDjxo1LnO/v768GDRpUWa2VoSLrLbR48WKNHDlSS5YsUd++fauyzEpT3vVmZWUpKSlJycnJevjhhyUVbLDGGPn7+ys+Pl7XXnutldrLqyL/tk2aNFGzZs3kdDqLxtq2bStjjH7++We1atWqSms+HxVZb2xsrHr06KFHH31UknTFFVeobt266tmzp5566imv/jSyInx5r/I2ZEUBsqIAWUFWVCe+vFd5G7KiAFlRgKwgK6qTqtir+KbU/xcYGKioqCglJCS4jCckJKh79+4lHtOtW7di8+Pj49W5c2cFBARUWa2VoSLrlQo+ybjnnnv0wQcf+NTvZMu73tDQUO3YsUPbtm0ruo0aNUqtW7fWtm3b1LVrV1ull1tF/m179OihgwcP6sSJE0VjP/74o/z8/NS8efMqrfd8VWS9v/32m/z8XLe/WrVqSfpfp7868eW9ytuQFQXIigJkBVlRnfjyXuVtyIoCZEUBsoKsqE6qZK+q8CnSq6HCyz/Onz/f7Ny504wbN87UrVvX7Nu3zxhjzOOPP27uvvvuovmFl0McP3682blzp5k/f75PXrq1rOv94IMPjL+/v3njjTdMampq0e348eOeWkK5lHe9Z/Olq2SUd61ZWVmmefPm5vbbbzffffedWbt2rWnVqpW57777PLWEcinvet955x3j7+9vZs+ebXbv3m3Wr19vOnfubLp06eKpJZRLVlaWSU5ONsnJyUaSmTVrlklOTi66VG1126u8DVlBVpAVZIUvICs8i6wgK8gKssIXeENW0JQ6yxtvvGEiIiJMYGCg6dSpk1m7dm3RfSNGjDC9evVymf/VV1+Zq666ygQGBppLLrnEzJkzx3LF56c86+3Vq5eRVOw2YsQI+4VXUHn/fX/Pl8LDmPKvddeuXaZv376mdu3apnnz5mbChAnmt99+s1x1xZV3va+++qpp166dqV27tmnSpImJiYkxP//8s+WqK2bNmjXn/G+xOu5V3oasICtKQ1Z4N7KCrLCJrCArSkNWeDeywm5WOIypht8pAwAAAAAAgFfjnFIAAAAAAACwjqYUAAAAAAAArKMpBQAAAAAAAOtoSgEAAAAAAMA6mlIAAAAAAACwjqYUAAAAAAAArKMpBQAAAAAAAOtoSgEAAAAAAMA6mlIAAAAAAACwjqYU4AVSU1N11113qXXr1vLz89O4ceM8XRIAwMusX79ePXr0UIMGDVS7dm21adNGL730kqfLAgB4SFneQ5w5c0YzZ85Uy5YtFRwcrI4dO2rFihX2iwVKQVMK8ALZ2dm66KKLNHnyZHXs2NHT5QAAvFDdunX18MMPa926ddq1a5emTJmiKVOmaN68eZ4uDQDgAWV5DzFlyhS9+eabeu2117Rz506NGjVKt956q5KTky1XC5SMphRgwZEjR9S4cWP97W9/Kxr797//rcDAQMXHx+uSSy7RK6+8ouHDh8vpdHqwUgCAp7jLiquuukp33nmn2rdvr0suuUTDhg1Tv379lJiY6MGqAQBVpTLeQ/z973/XE088oQEDBqhFixYaPXq0+vXrpxdffNHWMoBzoikFWHDRRRdpwYIFmj59upKSknTixAkNGzZMDz74oKKjoz1dHgDAC5Q3K5KTk7Vx40b16tXLA9UCAKpaZbyHyM7OVnBwsMtY7dq1tX79+qooGSg3f08XANQUAwYM0P3336+YmBj94Q9/UHBwsJ555hlPlwUA8CJlyYrmzZvryJEjys3N1fTp03Xfffd5qFoAQFU73/cQ/fr106xZs/THP/5RLVu21KpVq/Tpp58qLy+vCqsGyo5vSgEWvfDCC8rNzdVHH32khQsXFvvUAgAAd1mRmJiopKQkzZ07Vy+//LIWLVrkoUoBADacz3uIV155Ra1atVKbNm0UGBiohx9+WPfee69q1apVhRUDZUdTCrBoz549OnjwoPLz87V//35PlwMA8ELusiIyMlKXX3657r//fo0fP17Tp0+3XyQAwJrzeQ9x0UUXafny5Tp58qT279+v77//XiEhIYqMjKyiaoHy4ed7gCU5OTmKiYnR0KFD1aZNG40cOVI7duxQWFiYp0sDAHiJ8maFMUbZ2dmWqwQA2FJZ7yGCg4PVrFkznTlzRkuXLtWQIUOqqGKgfGhKAZZMnjxZGRkZevXVVxUSEqIvv/xSI0eO1BdffCFJ2rZtmyTpxIkTOnLkiLZt26bAwEC1a9fOg1UDAGw6V1a88cYbuvjii9WmTRtJ0vr16/XCCy/oL3/5i4erBgBUlfN9D/Hvf/9bv/zyi6688kr98ssvmj59uvLz8/XYY495akmAC4cxxni6CKC6++qrr3T99ddrzZo1uuaaayRJKSkpuuKKKxQbG6vRo0fL4XAUOy4iIkL79u2zXC0AwBPcZUVubq7efPNN7d27V/7+/mrZsqXuv/9+PfDAA/Lz44wMAFDdVMZ7iLVr12r06NHas2ePQkJCNGDAAD3zzDNq2rSpzaUApaIpBQAAAAAAAOv4WA0AAAAAAADW0ZQCAAAAAACAdTSlAAAAAAAAYB1NKQAAAAAAAFhHUwoAAAAAAADW0ZQCAAAAAACAdTSlAAAAAAAAYB1NKQAAAAAAAFhHUwoAAAAAAADW0ZQCAAAAAACAdTSlAAAAAAAAYB1NKQAAAAAAAFj3/wDQpG3lPS0CKwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1200x400 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_grid_2D()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To refine the sampling plan, we need to:\n",
    "\n",
    "* Compute the candidate directions of the admissible set. This is done in the `look_ahead` subroutine.\n",
    "* Run the ensemble of the new points. This is done exactly the same as before.\n",
    "* Accept the direction with the highest error. This is done in the `adapt_dimension` subroutine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:35:58.389113Z",
     "start_time": "2021-06-09T07:35:58.358851Z"
    },
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "def refine_sampling_plan(number_of_refinements):\n",
    "        \"\"\"\n",
    "        Refine the sampling plan.\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "        number_of_refinements (int)\n",
    "           The number of refinement iterations that must be performed.\n",
    "\n",
    "        Returns\n",
    "        -------\n",
    "        None. The new accepted indices are stored in analysis.l_norm and the admissible indices\n",
    "        in sampler.admissible_idx.\n",
    "        \"\"\"\n",
    "        for i in range(number_of_refinements):\n",
    "            # compute the admissible indices\n",
    "            sampler.look_ahead(analysis.l_norm)\n",
    "\n",
    "            # run the ensemble\n",
    "            campaign.execute().collate(progress_bar=True)\n",
    "\n",
    "            # accept one of the multi indices of the new admissible set\n",
    "            data_frame = campaign.get_collation_result()\n",
    "            analysis.adapt_dimension('f', data_frame)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the subroutine above uses the surplus error by default. To select the variance-based error use `analysis.adapt_dimension('f', data_frame, method='var')` instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:36:02.035813Z",
     "start_time": "2021-06-09T07:35:58.424373Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 40/40 [00:01<00:00, 26.48it/s]\n"
     ]
    }
   ],
   "source": [
    "# refine the sampling plan once and then do the analysis to see the results.\n",
    "refine_sampling_plan(1)\n",
    "campaign.apply_analysis(analysis)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:36:02.236189Z",
     "start_time": "2021-06-09T07:36:02.036656Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x400 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the 2D slices again. Note that the most important input (x1) got refined.\n",
    "plot_grid_2D()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:36:02.852989Z",
     "start_time": "2021-06-09T07:36:02.238904Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 2/2 [00:00<00:00,  7.41it/s]\n"
     ]
    }
   ],
   "source": [
    "# repeat\n",
    "refine_sampling_plan(1)\n",
    "campaign.apply_analysis(analysis)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:36:03.041311Z",
     "start_time": "2021-06-09T07:36:02.853868Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x400 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Now x2 got refined. This makes sense as 3 point along x1 are already enough \n",
    "# to capture the second-order polynomial nature. This can also be seen by the printout of\n",
    "# the error above: \"Refinement error for l = (3, 1, 1, ..., 1) is 2.117582368135751e-22\".\n",
    "# This multi index is corresponds to refining x1 again, and the associated error is \n",
    "# practically zero, meaning that adding more points in the direction of x1 alone yields\n",
    "# no improvement.\n",
    "plot_grid_2D()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:36:03.982845Z",
     "start_time": "2021-06-09T07:36:03.043947Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 6/6 [00:00<00:00, 13.65it/s]\n"
     ]
    }
   ],
   "source": [
    "# again\n",
    "refine_sampling_plan(1)\n",
    "campaign.apply_analysis(analysis)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:36:04.390640Z",
     "start_time": "2021-06-09T07:36:03.983704Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x400 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# now x3 got refined to first order\n",
    "plot_grid_2D()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:37:03.107671Z",
     "start_time": "2021-06-09T07:36:04.391583Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 10/10 [00:00<00:00, 15.53it/s]\n",
      "0it [00:00, ?it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 14/14 [00:00<00:00, 19.33it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 18/18 [00:00<00:00, 22.05it/s]\n",
      "0it [00:00, ?it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 22/22 [00:00<00:00, 22.80it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 26/26 [00:01<00:00, 25.43it/s]\n",
      "0it [00:00, ?it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 30/30 [00:01<00:00, 27.00it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 34/34 [00:01<00:00, 28.27it/s]\n",
      "0it [00:00, ?it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 38/38 [00:01<00:00, 32.53it/s]\n",
      "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 8/8 [00:00<00:00, 15.55it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 42/42 [00:01<00:00, 28.10it/s]\n",
      "0it [00:00, ?it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 46/46 [00:01<00:00, 30.76it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 50/50 [00:01<00:00, 29.81it/s]\n",
      "0it [00:00, ?it/s]\n",
      "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 8/8 [00:00<00:00, 16.26it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 54/54 [00:02<00:00, 26.47it/s]\n"
     ]
    }
   ],
   "source": [
    "# we don't have to refine only one time. Here we perform multiple iterations\n",
    "refine_sampling_plan(20)\n",
    "campaign.apply_analysis(analysis)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:37:03.243198Z",
     "start_time": "2021-06-09T07:37:03.108639Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAGGCAYAAACqvTJ0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAABIWUlEQVR4nO3deXQUZfr28atDVpa0EiQQwBgQWRUlDAiILGIQEEV0QA0Cir4EddhER4RhiTpxxZ1NwGVERERQHAQygOwOO4OCOrIFTQIGJAlbIMnz/pFfMjbZOqG7ujv5fs7p40n1U933E+NzWXdXV9mMMUYAAAAAAACAhfw8XQAAAAAAAAAqH5pSAAAAAAAAsBxNKQAAAAAAAFiOphQAAAAAAAAsR1MKAAAAAAAAlqMpBQAAAAAAAMvRlAIAAAAAAIDlaEoBAAAAAADAcjSlAAAAAAAAYDmaUvAZ8fHxat68uXJzc8u87+uvv65+/fopKipKNptNXbp0cX2BRUhJSdGECRPUvn171apVS6GhoYqOjtasWbOUk5PjMHbOnDmqV6+eTp8+7fI6bDabJk+e7PLXBQBvU96sOH36tO699141adJENWrUULVq1dSiRQs999xzblmXS3L06FGFhYXJZrPps88+c3iOrACAoll1rLBixQp17NhRISEhstvt6tOnj77//vtLqNw5q1ev1kMPPaSmTZuqWrVqqlevnu68805t3769yPE7duxQ9+7dVb16dV122WXq16+fDhw44DDmp59+UmBgoHbs2OHyert06WLZMRd8G00p+ITk5GS99NJLio+Pl59f2f9sZ8yYocOHD6tbt2664oor3FBh0bZv364PP/xQt9xyiz788EMtWrRInTt31vDhw/XII484jB08eLCqVauml156ybL6AKAiuZSsuHDhgowxGjNmjBYtWqQvvvhCd999t+Lj43XnnXe6qeKiPfbYYwoODi7yObICAAqz6ljhiy++UM+ePVW7dm0tWrRIM2bM0H//+1916tRJ+/fvv5QplGr69Ok6dOiQRo4cqWXLlumNN97QsWPHdOONN2r16tUOY3/44Qd16dJF58+f16effqq5c+fqp59+UqdOnfTbb78VjLvmmmsUGxur0aNHu7V2oEQG8AFPPfWUqVevnsnJySnX/n/cr0WLFqZz584uqqxkJ06cMOfPny+0/bHHHjOSTFJSksP2V155xdjtdnP69GmX1iHJTJo0yaWvCQDe5lKzorjXlGT279/vstcsyWeffWaqV69uPvjgAyPJLFy4sNAYsgIAHFl1rNCkSRNz3XXXmdzc3IJthw4dMoGBgeb+++8v13s76+jRo4W2ZWZmmvDwcHPLLbc4bP/zn/9satWqZdLT0x3qDAgIME899ZTD2G3bthlJZuPGjS6tt3PnzpYdc8G3caYUvN758+c1Z84c3X///Q6ffLzwwgvy8/PT0qVLHcYPGTJEVatW1Z49ewq2lecTk5J88sknstlsevvttx22T5o0SVWqVFFiYqIk6fLLL1dAQECh/du2bStJ+uWXXxy2x8bGKiMjQ5988kmpNXTp0kUtW7bU+vXrdeONNyokJET16tXT3/72t0JfDbzYb7/9pkcffVTNmzdX9erVVbt2bXXr1k3r1693GHfo0CHZbDa98sormjp1qqKiolS9enW1b99e3377baHX3bZtm+644w7VrFlTwcHBuuGGG/Tpp5+WOhcAuFSuyIqi5H9i7u/vX+aanM2KfCdOnNBjjz2m559/XldeeWWxr0tWAMD/WHWscPz4cf3444/q2bOnbDZbwfbIyEi1bNlSS5YsKXVdvZgxRr169VJYWJiSkpIKtp85c0YtWrRQs2bNCr6uXbt27UL7V69eXc2bN9eRI0cKtmVnZ+urr77S3XffrdDQUIc6u3btqsWLFzu8RnR0tJo1a6YZM2aUWu/kyZNls9m0c+dO9evXT6GhobLb7Ro4cKDDGVjFmTJlitq1a6eaNWsqNDRUrVu31pw5c2SMcRh31VVX6fbbb9fy5cvVunVrhYSEqGnTppo7d26h10xNTdWwYcNUv359BQYGKioqSlOmTFF2dnap9cBLeLorBpRm3bp1RpJZtmyZw/bc3FzTq1cvc/nll5tDhw4ZY4yZO3eukWRmz55d7Ou56kypuLg4ExgYaLZu3WqMMWbVqlXGz8/PTJgwodR9Bw8ebPz9/U1aWlqh55o1a2b69etX6mt07tzZhIWFmYiICPPmm2+aFStWmBEjRhhJ5rHHHnMYq4s+/f7hhx/M8OHDzSeffGK++eYb89VXX5mhQ4caPz8/s2bNmoJxBw8eNJLMVVddZW677TazZMkSs2TJEnPttdeayy+/3Jw8ebJg7OrVq01gYKDp1KmTWbBggVm+fLkZMmSIkWTee++9UucDAJfCVVmRm5trLly4YNLT083XX39t6tSpY+67775y11WWrIiNjTU33nijycnJMWvWrCn2TCljyAoAyGfVsUJycrKRZCZOnFjoufbt2xtJ5scffyxz/WlpaaZ+/fqmXbt2Bd+wGDx4sAkJCTH/+c9/Stz35MmTxm63m7vuuqtg2w8//GAkmXfeeafQ+LFjxxqbzWbOnj3rsH348OGmVq1aDmeAFWXSpElGkomMjDRPPvmkWbFihZk6daqpVq2aueGGGxy+IVLUmVJDhgwxc+bMMYmJiSYxMdE8++yzJiQkxEyZMsVhXGRkpKlfv75p3ry5+fDDD82KFSvMn//8ZyPJrF27tmBcSkqKadCggYmMjDQzZ840//rXv8yzzz5rgoKCzJAhQ0qcC7wHTSl4vRdffNFIMqmpqYWey1/E27Zta3bs2GGqVq1qBg4cWOLruaopde7cOXPDDTeYqKgos3fvXhMeHm46d+5ssrOzS9xvxYoVxs/Pz4wePbrI52NjY014eHip79+5c2cjyXzxxRcO2x955BHj5+dnDh8+XLDt4gONi2VnZ5sLFy6YW265xSHU8g80rr32Wod5bdmyxUgy8+fPL9jWtGlTc8MNN5gLFy44vPbtt99u6tat69Kv0wDAxVyVFfPnzzeSCh4PPvhgoXWtLJzNiq+++soEBASYPXv2GGNMqU0psgIA8lh1rJCTk2Nq1qxZ6Ktyv//+u6lRo4aRZDZt2lSuOWzYsMH4+/ubUaNGOdU4yxcbG2v8/f3Ntm3bCrZt3Lix0Nqb7+9//7uRZJKTkx22v/vuu0aS2bdvX4nvl9+Uuvg4Zt68eUaS+eijjwq2lfb1vZycHHPhwgUTHx9vwsLCHBpikZGRJjg42CGjzp49a2rWrGmGDRtWsG3YsGGmevXqDuOMyfuauyTz/ffflzgfeAe+vgevl5ycLJvNplq1ahV6LiwsTAsWLNCOHTvUoUMHXXnllU6deuoKQUFB+vTTT3X8+HG1bt1axhjNnz9fVapUKXafHTt2qH///rrxxhuVkJBQ5JjatWvr2LFjTp1yWqNGDd1xxx0O2+6//37l5uZq3bp1Je47Y8YMtW7dWsHBwfL391dAQIBWrVqlffv2FRrbu3dvh3ldd911kqTDhw9Lkn7++Wf98MMPio2NlZR32nD+o1evXkpJSdGPP/5Y6nwAoLxclRU9evTQ1q1btXr1aj3//PNatGiR7r777nLdzUlyLivS09M1bNgw/fWvf1XLli2del2yAgDyWHWs4Ofnp8cee0yrVq3Ss88+q2PHjunnn3/WwIEDdebMmYIx5dGxY0c9//zzev311zV8+HANHDhQQ4cOLXGfv/3tb5o3b55ee+01RUdHF3r+j18xLO25/K8G/vrrr07Vm7+O5+vfv7/8/f21Zs2aEvdbvXq1unfvLrvdripVqiggIEATJ07U8ePHdezYMYex119/vcNX2YODg3XNNdcUZIokffXVV+ratasiIiIcMqVnz56SpLVr1zo1H3gWTSl4vbNnzyogIKDYZk+7du3UokULnTt3TsOHD1e1atUsq+3qq69Wp06ddO7cOcXGxqpu3brFjt25c6duvfVWNW7cWMuWLVNQUFCR44KDg2WM0blz50p9//Dw8ELb6tSpIynve+/FmTp1qoYPH6527dpp0aJF+vbbb7V161bddtttOnv2bKHxYWFhDj/n154/9ujRo5KksWPHKiAgwOHx6KOPSpLS0tJKnQ8AlJersuLyyy9XmzZt1LVrVz3zzDOaNWuWvvzyS33xxRflrq20rBg/frwCAgL0+OOP6+TJkzp58qROnTolKe+6IidPnix0vQ2yAgDyWHmsMHHiRI0ePVrPPfecwsPD1bhxY0nSgw8+KEmqV69euV87NjZWgYGBysrK0pNPPlni2ClTpui5557T888/r8cff9zhufy1uKj1/cSJE7LZbLrssssctuff8bWotb0o+RmSz9/fX2FhYSVmypYtWxQTEyNJevfdd7Vx40Zt3bpV48ePL/K9L84UKS9X/jju6NGjWrp0aaFMadGihSQyxVeU/aqdgMVq1aql8+fP6/Tp00WGyKRJk7Rnzx5FR0dr4sSJuv3229WwYUNLaps9e7b++c9/qm3btnr77bc1YMAAtWvXrtC4nTt3qnv37oqMjNTKlStlt9uLfc0TJ04oKChI1atXL/X98/8H/49SU1MlFb2Q5/voo4/UpUsXTZ8+3WF7ZmZmqe9ZlPxPpsaNG6d+/foVOaZJkyblem0AcIa7siL/xhQ//fRTuWsrLSu+++47HTp0qND/5EvS4MGDJUm///67w0EEWQEAeaw8VvD399fUqVMVHx+vgwcPqlatWqpbt6569OihqKgo1a9fv1yvm5OTo9jYWF1++eUKCgrS0KFDtXHjRgUGBhYaO2XKFE2ePFmTJ0/WM888U+j5Ro0aKSQkpMgbeezZs0dXX311QRMq34kTJySpyLPNipKamurQgMvOztbx48dLzJRPPvlEAQEB+uqrrxzef8mSJU69Z1Fq1aql6667Ts8//3yRz0dERJT7tWEdzpSC12vatKkkaf/+/YWeS0xMVEJCgiZMmKDExETZ7XYNGDBA58+fd3tde/bs0YgRIzRo0CCtX79e1113nQYMGKDff//dYdyuXbvUvXt31a9fX4mJibr88stLfN0DBw6oefPmTtWQmZmpL7/80mHbxx9/LD8/P918883F7mez2QqdqfWf//xHmzdvdup9L9akSRM1btxYu3fvVps2bYp81KhRo1yvDQDOcFdW5H8V4eqrry5XXc5kxeuvv641a9Y4PF577TVJeXc6WrNmTaHmE1kBAHk8caxQvXp1XXvttapbt6527NihVatWaeTIkeV+vUmTJmn9+vWaN2+eFixYoN27dxd5ttSzzz6ryZMna8KECZo0aVKRr+Xv768+ffro888/d/gQISkpSWvWrCnyQ4EDBw7Iz8/P6Q8G5s2b5/Dzp59+quzsbHXp0qXYfWw2m/z9/R3OaDt79qz+8Y9/OPWeRbn99tv13XffqVGjRkVmCk0pH+HRK1oBTkhKSjKSzMyZMx22Jycnm9q1a5uuXbsWXBh18+bNJiAgwIwcOdJh7NatW83ChQvNwoULTYMGDUzz5s0Lfs6/G4cx/7tY6+DBg0us6dSpU6Zp06amefPm5tSpU8YYY/bv32/sdru58847C8b98MMPJiwszNSsWdMsXbrUbN682eFx7Ngxh9fNyckxdrvdjBkzptTfyx/vqPTWW2+ZFStWmJEjRxpJZvjw4Q5jddHFaydOnGhsNpuZOHGiWbVqlZk2bZqpU6eOadSokYmMjCz0+3j55ZcLvf/Fr7l69WoTFBRkYmJizMcff2zWrl1rFi9ebP7+97+be+65p9T5AMCluNSsmDFjhomNjTUffPCBWb16tVm6dKl56qmnTEhIiOnQoYPDhbldnRVFKelC52QFAPyPlccKa9asMS+99JJZvny5+frrr82UKVNM1apVTe/evQvdwCL/ouB/vFtpUVauXGn8/Pwc1sr8C3V//vnnhbbddttthY4pNm/e7PCa+/btM9WrVzc333yzWbZsmfn8889Ny5YtTURERKHjD2OM6dOnj2ndunWJdf5xTvl331u5cqV57bXXTPXq1U2rVq1MVlZWwdiLL3S+atUqI8ncc889ZuXKlWb+/PkmOjraNG7c2EgyBw8eLBgbGRlpevfuXej9L37N5ORkExkZaZo2bWqmTZtmVq1aZf75z3+ad955x/Tu3dscOXKk1DnB82hKwSd06tTJ9OrVq+Dn7Oxs07lzZxMeHm5SUlIcxr788stGklm8eHHBtsGDBzvcTemPjz/egnrPnj1Gknn66adLrGfgwIGmatWqhe7osHDhQiPJvPbaa8YYY957771i3/fi9zbmf4v19u3bS/2ddO7c2bRo0cJ88803pk2bNiYoKMjUrVvXPPPMM4XuanTxQUFWVpYZO3asqVevngkODjatW7c2S5YsMYMHDy73gYYxxuzevdv079/f1K5d2wQEBJg6deqYbt26mRkzZpQ6HwC4VJeSFRs3bjS33367iYiIMIGBgaZq1aqmVatW5tlnnzWnT5922NfVWVGUkppSZAUAOLLqWGHjxo2mXbt2JjQ01AQFBZmWLVuaV155xZw/f75QTU888YSx2Wwl3tEuv3HWrVs3h7uP5ubmmj59+pjLLrusoFmTfzfV4h4X27Ztm7nllltM1apVTWhoqOnbt6/5+eefC43LzMw0VatWNa+++mqxdebLb0pt377d9OnTx1SvXt3UqFHD3Hfffebo0aMOY4u6+97cuXNNkyZNTFBQkGnYsKFJSEgwc+bMKXdTyhhjfvvtNzNixAgTFRVlAgICTM2aNU10dLQZP358wQdC8G42Yy66cibghRYtWqQBAwbo8OHDl3QBwdJMmzZNTz31lPbv31/khWHd7YEHHtCBAwe0cePGUsd26dJFaWlp+u677yyoDAC8H1lRGFkBoDKwav0vi7Zt2yoyMlILFy70dCklmjNnjkaOHKkjR46UepmRyZMna8qUKfrtt9+cvv4UUBquKQWf0K9fP/3pT39SQkKCW99nzZo1GjFihEcOMvbv368FCxboxRdftPy9AaAiICsAoHKyav13VkZGhnbv3q34+HhPl1Ki7Oxsvfjiixo3blypDSnAXbj7HnyCzWbTu+++qy+//FK5ubny83NPP9WTn2QkJSXp7bff1k033eSxGgDAl5EVAFA5WbX+Oys0NFRZWVkercEZR44c0cCBA/XEE094uhRUYnx9DwAAAAAAAJbj63sAAAAAAACwHE0pAAAAAAAAWI6mFAAAAAAAACxX6S50npubq+TkZNWoUUM2m83T5QCAVzHGKDMzUxERER6/SKgnkRUAUDyyIg9ZAQDFczYrKl1TKjk5WQ0aNPB0GQDg1Y4cOaL69et7ugyPISsAoHRkBVkBAKUpLSsqXVOqRo0akvJ+MaGhoR6uBgC8S0ZGhho0aFCwVlZWZAUAFI+syENWAEDxnM2KSteUyj+1NjQ0lPAAgGJU9q8hkBUAUDqygqwAgNKUlhWV90vgAAAAAAAA8BiaUgAAAAAAALAcTSkAAAAAAABYjqYUAAAAAAAALEdTCgAAAAAAAJajKQUAAAAAAADL+Xu6AF+Rk2u05eAJHcs8p9o1gtU2qqaq+FXu2+Di0qWfuaCH3t+i5PRzirAHa+6QtrJXDfB0WfBhrFVAxUNWAACAisqjZ0qtW7dOffr0UUREhGw2m5YsWVLqPmvXrlV0dLSCg4PVsGFDzZgxw+11Lv8uRTe9uFr3vfutRn6yS/e9+61uenG1ln+X4vb3RsXV+eXVahW/UtuTTiol/Zy2J51Uq/iV6vzyak+XBh9VUdcqX8kKwB3ICsA5ZAUA+CaPNqVOnz6tVq1a6e2333Zq/MGDB9WrVy916tRJO3fu1DPPPKMRI0Zo0aJFbqtx+XcpGv7RDqWkn3PYnpp+TsM/2uHzB3vwjM4vr9bh42eLfO7w8bMcbKDMKvJa5QtZAbgDWQE4j6wAAN/k0a/v9ezZUz179nR6/IwZM3TllVfq9ddflyQ1a9ZM27Zt0yuvvKK7777b5fXl5BpNWbpXpojnjCSbpClL9+rW5nX4egycln7mQrEHGfkOHz+r9DMX+HoGnFLR1ypvzwrAHcgKoGzICgDwTT51ofPNmzcrJibGYVuPHj20bds2Xbhwoch9srKylJGR4fBw1paDJwqddfBHRlJK+jltOXjC6dcEHnp/i0vHAaxVjqzOCsAdyArAvcgKAPAOPtWUSk1NVXh4uMO28PBwZWdnKy0trch9EhISZLfbCx4NGjRw+v2OZRZ/kFeecYAkJZfQPCjPOIC1ypHVWQG4A1kBuBdZAQDewaeaUpJkszl+9cQYU+T2fOPGjVN6enrB48iRI06/V+0awS4dB0hShN25vxdnxwGsVYVZmRWAO5AVgPuRFQDgeT7VlKpTp45SU1Mdth07dkz+/v4KCwsrcp+goCCFhoY6PJzVNqqm6tqDVdwVWGyS6trzbrkOOGvukLYuHQewVjmyOisAdyArAPciKwDAO/hUU6p9+/ZKTEx02LZy5Uq1adNGAQGuv8hnFT+bJvVpLkmFDvbyf57Up7lPXjgYnmOvGqDIsJASx0SGhXDhWjiNtcqR1VkBuANZAbgXWQEA3sGjTalTp05p165d2rVrl6S8W7Pu2rVLSUlJkvJOkR00aFDB+Li4OB0+fFhjxozRvn37NHfuXM2ZM0djx451W423tayr6QNbq85Fp8fXsQdr+sDWuq1lXbe9NyqutU92K/ZgIzIsRGuf7GZxRfB1FXmt8oWsANyBrACcR1YAgG+ymfwvT3vAN998o65duxbaPnjwYL3//vsaMmSIDh06pG+++abgubVr12r06NH6/vvvFRERob/+9a+Ki4tz+j0zMjJkt9uVnp5eplNuc3KNthw8oWOZ51S7Rt7XYCrLWQdwn/QzF/TQ+1uUnH5OEfZgzR3Slk+9cUkuda0q7xrpTr6UFYA7kBXwNt64RpIVAOBdnF0jPdqU8gTCAwCKxxqZh98DABSPNTIPvwcAKJ6za6RPXVMKAAAAAAAAFQNNKQAAAAAAAFiOphQAAAAAAAAsR1MKAAAAAAAAlqMpBQAAAAAAAMvRlAIAAAAAAIDlaEoBAAAAAADAcjSlAAAAAAAAYDmaUgAAAAAAALAcTSkAAAAAAABYjqYUAAAAAAAALEdTCgAAAAAAAJajKQUAAAAAAADL0ZQCAAAAAACA5WhKAQAAAAAAwHI0pQAAAAAAAGA5mlIAAAAAAACwHE0pAAAAAAAAWI6mFAAAAAAAACxHUwoAAAAAAACWoykFAAAAAAAAy9GUAgAAAAAAgOVoSgEAAAAAAMByNKUAAAAAAABgOZpSAAAAAAAAsBxNKQAAAAAAAFiOphQAAAAAAAAsR1MKAAAAAAAAlqMpBQAAAAAAAMvRlAIAAAAAAIDlaEoBAAAAAADAcjSlAAAAAAAAYDmaUgAAAAAAALAcTSkAAAAAAABYjqYUAAAAAAAALEdTCgAAAAAAAJajKQUAAAAAAADL0ZQCAAAAAACA5WhKAQAAAAAAwHI0pQAAAAAAAGA5mlIAAAAAAACwHE0pAAAAAAAAWI6mFAAAAAAAACxHUwoAAAAAAACW83hTatq0aYqKilJwcLCio6O1fv36EsfPmzdPrVq1UtWqVVW3bl09+OCDOn78uEXVAgA8gawAAJSGrAAA3+PRptSCBQs0atQojR8/Xjt37lSnTp3Us2dPJSUlFTl+w4YNGjRokIYOHarvv/9eCxcu1NatW/Xwww9bXDkAwCpkBQCgNGQFAPgmjzalpk6dqqFDh+rhhx9Ws2bN9Prrr6tBgwaaPn16keO//fZbXXXVVRoxYoSioqJ00003adiwYdq2bZvFlQMArEJWAABKQ1YAgG/yWFPq/Pnz2r59u2JiYhy2x8TEaNOmTUXu06FDB/3yyy9atmyZjDE6evSoPvvsM/Xu3duKkgEAFiMrAAClISsAwHd5rCmVlpamnJwchYeHO2wPDw9Xampqkft06NBB8+bN04ABAxQYGKg6derosssu01tvvVXs+2RlZSkjI8PhAQDwDWQFAKA0ZAUA+C6PX+jcZrM5/GyMKbQt3969ezVixAhNnDhR27dv1/Lly3Xw4EHFxcUV+/oJCQmy2+0FjwYNGri0fgCA+5EVAIDSkBUA4HtsxhjjiTc+f/68qlatqoULF+quu+4q2D5y5Ejt2rVLa9euLbTPAw88oHPnzmnhwoUF2zZs2KBOnTopOTlZdevWLbRPVlaWsrKyCn7OyMhQgwYNlJ6ertDQUBfPCgB8W0ZGhux2u9eskWQFAHgfsiIPWQEAxXM2Kzx2plRgYKCio6OVmJjosD0xMVEdOnQocp8zZ87Iz8+x5CpVqkjK+ySkKEFBQQoNDXV4AAB8A1kBACgNWQEAvsujX98bM2aMZs+erblz52rfvn0aPXq0kpKSCk6bHTdunAYNGlQwvk+fPvr88881ffp0HThwQBs3btSIESPUtm1bRUREeGoaAAA3IisAAKUhKwDAN/l78s0HDBig48ePKz4+XikpKWrZsqWWLVumyMhISVJKSoqSkpIKxg8ZMkSZmZl6++239cQTT+iyyy5Tt27d9OKLL3pqCgAANyMrAAClISsAwDd57JpSnuJt34EHAG/CGpmH3wMAFI81Mg+/BwAontdfUwoAAAAAAACVF00pAAAAAAAAWI6mFAAAAAAAACxHUwoAAAAAAACWoykFAAAAAAAAy9GUAgAAAAAAgOVoSgEAAAAAAMByNKUAAAAAAABgOZpSAAAAAAAAsBxNKQAAAAAAAFiOphQAAAAAAAAsR1MKAAAAAAAAlqMpBQAAAAAAAMvRlAIAAAAAAIDlaEoBAAAAAADAcjSlAAAAAAAAYDmaUgAAAAAAALAcTSkAAAAAAABYjqYUAAAAAAAALEdTCgAAAAAAAJajKQUAAAAAAADL0ZQCAAAAAACA5WhKAQAAAAAAwHI0pQAAAAAAAGA5mlIAAAAAAACwHE0pAAAAAAAAWI6mFAAAAAAAACxHUwoAAAAAAACWoykFAAAAAAAAy9GUAgAAAAAAgOVoSgEAAAAAAMByNKUAAAAAAABgOZpSAAAAAAAAsBxNKQAAAAAAAFiOphQAAAAAAAAsR1MKAAAAAAAAlqMpBQAAAAAAAMvRlAIAAAAAAIDlaEoBAAAAAADAcjSlAAAAAAAAYDmaUgAAAAAAALAcTSkAAAAAAABYjqYUAAAAAAAALEdTCgAAAAAAAJajKQUAAAAAAADLebwpNW3aNEVFRSk4OFjR0dFav359ieOzsrI0fvx4RUZGKigoSI0aNdLcuXMtqhYA4AlkBQCgNGQFAPgef0+++YIFCzRq1ChNmzZNHTt21MyZM9WzZ0/t3btXV155ZZH79O/fX0ePHtWcOXN09dVX69ixY8rOzra4cgCAVcgKAEBpyAoA8E02Y4zx1Ju3a9dOrVu31vTp0wu2NWvWTH379lVCQkKh8cuXL9e9996rAwcOqGbNmuV6z4yMDNntdqWnpys0NLTctQNAReSNayRZAQDexRvXSLICALyLs2ukx76+d/78eW3fvl0xMTEO22NiYrRp06Yi9/nyyy/Vpk0bvfTSS6pXr56uueYajR07VmfPnrWiZACAxcgKAEBpyAoA8F0e+/peWlqacnJyFB4e7rA9PDxcqampRe5z4MABbdiwQcHBwVq8eLHS0tL06KOP6sSJE8V+/zsrK0tZWVkFP2dkZLhuEgAAtyIrAAClISsAwHd5/ELnNpvN4WdjTKFt+XJzc2Wz2TRv3jy1bdtWvXr10tSpU/X+++8X+6lGQkKC7HZ7waNBgwYunwMAwL3ICgBAacgKAPA9HmtK1apVS1WqVCn06cWxY8cKfcqRr27duqpXr57sdnvBtmbNmskYo19++aXIfcaNG6f09PSCx5EjR1w3CQCAW5EVAIDSkBUA4Ls81pQKDAxUdHS0EhMTHbYnJiaqQ4cORe7TsWNHJScn69SpUwXbfvrpJ/n5+al+/fpF7hMUFKTQ0FCHBwDAN5AVAIDSkBUA4Ls8+vW9MWPGaPbs2Zo7d6727dun0aNHKykpSXFxcZLyPo0YNGhQwfj7779fYWFhevDBB7V3716tW7dOTz75pB566CGFhIR4ahoAADciKwAApSErAMA3eexC55I0YMAAHT9+XPHx8UpJSVHLli21bNkyRUZGSpJSUlKUlJRUML569epKTEzUX/7yF7Vp00ZhYWHq37+/nnvuOU9NAQDgZmQFAKA0ZAUA+CabMcZ4uggrZWRkyG63Kz09nVNuAeAirJF5+D0AQPFYI/PwewCA4jm7Rnr87nsAAAAAAACofGhKAQAAAAAAwHI0pQAAAAAAAGA5mlIAAAAAAACwHE0pAAAAAAAAWI6mFAAAAAAAACxHUwoAAAAAAACWoykFAAAAAAAAy9GUAgAAAAAAgOVoSgEAAAAAAMByNKUAAAAAAABgOZpSAAAAAAAAsBxNKQAAAACW2rp1q2JjYxUVFaWQkBBVrVpVUVFRio2N1bZt2zxdHgDAIv6eLgAAAABA5bFkyRL1799ft9xyi0aOHKnw8HAZY3Ts2DGtXLlSHTt21Keffqo777zT06UCANyMphQAAAAAy0yYMEHx8fF6+umnCz03atQovfjii3rmmWdoSgFAJcDX9wAAbvfNN9/o7Nmzni4DAOAFfv75Z/Xr16/Y5/v27av9+/dbWBEAwFPK1JTavXu3nnvuOU2bNk1paWkOz2VkZOihhx5yaXEAgIohJiZGhw4d8nQZAAAv0KhRIy1ZsqTY57/44gs1bNjQuoIAAB7j9Nf3Vq5cqT59+qhx48bKzMzUpEmT9Omnn6pr166SpLNnz+qDDz7Q3Llz3VasJ/2YnKleb61TjpGq2KRlf7lZTSJqeLos+Lh/7UjRw5/uKPh5dv/W6t66rgcrgq/z9FrVunXrIrdnZ2fr7rvvVnBwsCRpx44dRY7zdelnLuih97coOf2cIuzBmjukrexVAzxdFnzc2yv26JU1SQU/j+16pR7vca0HK4Kv8/RaFR8fr3vvvVdr165VTEyMwsPDZbPZlJqaqsTERK1cuVKffPKJZfUAFcGoeWu0ZM+Zgp/7XltVr8d29WBFgHNsxhjjzMAOHTqoa9euev7552WM0SuvvKL4+HgtXLhQt912m44ePaqIiAjl5OS4u+ZLkpGRIbvdrvT0dIWGhjq1z1VP/7PY5w690NtVpaGS4e8KruaKv6nyrJF/FBAQoO7du+vGG28s2GaM0bPPPqu4uDjVrl1bkjRp0qQyv7aVyvN76Pzyah0+XvgripFhIVr7ZDdXl4hKgqyAq7lirbrUrJCkzZs364033tDmzZuVmpoqSapTp47at2+vkSNHqn379uV6XSu54vcAuAJZAW/k7BrpdFPKbrdrx44datSoUcG2+fPn65FHHtH8+fPVtm3bCtmUKuk/8Hz8h46y4u8Kruaqv6lL/R/sjRs3avDgwYqNjdWkSZPk55f3LfGAgADt3r1bzZs3L/NrekJZfw/FHeTlozGF8iAr4GquWqtoxuTh9wBvQFbAWzm7Rjp9TamgoCCdPHnSYdt9992nOXPm6N5779XixYvLXay3+jE506XjACnvK3uuHAd401rVsWNH7dixQz/99JPat29fKS5Um37mQokHeZJ0+PhZpZ+5YFFFqAjeXrHHpeMA1iqg4hk1b41LxwGe4HRT6vrrr9eaNYX/mAcMGKDZs2drxIgRLi3MG/R6a51LxwGSHK4h5YpxgLetVaGhoZo/f77i4uJ00003adasWbLZbJa8tyc89P4Wl44DJDlcQ8oV4wBvW6u4gRJw6f54DSlXjAM8wemm1PDhw/Xrr78W+dx9992nDz74QDfffLPLCvMGOU59sdH5cQDgDt66Vj344INat26dZs+erezsbGvf3ELJ6edcOg4A3MGb1qqVK1eqbdu2+uSTT/Tiiy+qWbNmDh9+599ACQBQ8TndlLrrrrv02muv6V//+leRz99333269957XVaYN6ji5Af7zo4DAHfwxrUqPysaN26sb7/9Vr///ruaNWsmSZo5c6Z1hVggwh7s0nEA4A7etFZNnjxZY8eO1XfffadDhw7pqaee0h133KHly5e7/b0BAN7F6aZUvt69e+uJJ57Q+fPnC7b99ttv6tOnj8aNG+fS4jxt2V+cO/PL2XGAJM3u39ql4wBvXKv+mBV+fn6y2+1KS0urkFkxd0hbl44DJGls1ytdOg7wprXq+++/L/h6ns1m05NPPqlZs2bpnnvu0dKlS93+/kBF0ffaqi4dB3hCmZtS69at09KlS/WnP/1J33//vf75z3+qZcuWOnXqlHbv3u2OGj2mSUQNl44DJKl767ouHQd441pVmbLCXjVAkWEhJY6JDAuRvWqARRWhIni8x7UuHQd401pVGW+gBLjD67FdXToO8IQyN6XatWunnTt36rrrrlN0dLTuuusuPfHEE1q9erUaNGjgjho9qrTbZ3J7TZQHf1dwNW/7m6psWbH2yW7FHuw5e4t14GLe9t81fJ+3rFWV8QZKgLuQFfB1/uXZ6ccff9TWrVtVv359JScn64cfftCZM2dUrVo1V9fnFQ690Fs/Jmeq11vrlGPyrsuy7C83c4YULsmhF3rrXztSHO6yN7t/a86QQrl521pV2bJi7ZPdlH7mgh56f4uS088pwh6suUPacoYULsmhF3rr7RV7HO6yN7brlZwhhXLzhrVq+PDhWreu6DvC3nfffZKkWbNmWVYP4OsOvdBbo+atcbjLXt9rq3KGFHyCzRhTpvsxvfDCC5o0aZL+3//7f3r55Ze1f/9+DRw4UBkZGfroo4/Uvn17d9XqEhkZGbLb7UpPT1doaKinywEAr+KqNZKsAICKy1Vr5L/+9S917969yOdmzpypYcOGlfu1rUBWAEDxnF0jy/z1vTfeeENLlizRW2+9peDgYLVo0UJbtmxRv3791KVLl0upGQBQQZAVAIDSVKYbKAEAilbmptSePXvUs2dPh20BAQF6+eWXtXLlSpcVBgDwXWQFAKA0lemmGACAopW5KVWrVq1in+vcufMlFQMAqBjICgBAaSrbTTEAAIWVuSkFAAAAAK7wx5ti+Pv7F9wUAwBQOdCUAgAAAGC5F154Qe3bt9ett96q7777Tlu3bi04c2rz5s2eLg8AYAGaUgAAAAAsx00xAAD+ni4AAAAAQOWzZ8+eQtcgzL8pxu233+6hqgAAVuJMKQAAAACW46YYAACaUgAAAAAAALAcTSkAAAAAAABYjqYUAAAAAAAALEdTCgAAAAAAAJajKQUAAAAAAADL0ZQCAAAAAACA5WhKAQAAAAAAwHI0pQAAAAAAAGA5jzelpk2bpqioKAUHBys6Olrr1693ar+NGzfK399f119/vXsLBAB4HFkBACgNWQEAvsejTakFCxZo1KhRGj9+vHbu3KlOnTqpZ8+eSkpKKnG/9PR0DRo0SLfccotFlQIAPIWsAACUhqwAAN9kM8YYT715u3bt1Lp1a02fPr1gW7NmzdS3b18lJCQUu9+9996rxo0bq0qVKlqyZIl27drl9HtmZGTIbrcrPT1doaGhl1I+AFQ43rhGkhUA4F28cY0kKwDAuzi7RnrsTKnz589r+/btiomJcdgeExOjTZs2Fbvfe++9p/3792vSpElOvU9WVpYyMjIcHgAA30BWAABKQ1YAgO/yWFMqLS1NOTk5Cg8Pd9geHh6u1NTUIvf573//q6efflrz5s2Tv7+/U++TkJAgu91e8GjQoMEl1w4AsAZZAQAoDVkBAL7L4xc6t9lsDj8bYwptk6ScnBzdf//9mjJliq655hqnX3/cuHFKT08veBw5cuSSawYAWIusAACUhqwAAN/j3McCblCrVi1VqVKl0KcXx44dK/QphyRlZmZq27Zt2rlzpx5//HFJUm5urowx8vf318qVK9WtW7dC+wUFBSkoKMg9kwAAuBVZAQAoDVkBAL7LY2dKBQYGKjo6WomJiQ7bExMT1aFDh0LjQ0NDtWfPHu3atavgERcXpyZNmmjXrl1q166dVaUDACxCVgAASkNWAIDv8tiZUpI0ZswYPfDAA2rTpo3at2+vWbNmKSkpSXFxcZLyTpH99ddf9eGHH8rPz08tW7Z02L927doKDg4utB0AUHGQFQCA0pAVAOCbPNqUGjBggI4fP674+HilpKSoZcuWWrZsmSIjIyVJKSkpSkpK8mSJAAAPIysAAKUhKwDAN9mMMcbTRVgpIyNDdrtd6enpCg0N9XQ5AOBVWCPz8HsAgOKxRubh9wAAxXN2jfT43fcAAAAAAABQ+dCUAgAAAAAAgOVoSgEAAAAAAMByNKUAAAAAAABgOZpSAAAAAAAAsBxNKQAAAAAAAFiOphQAAAAAAAAsR1MKAAAAAAAAlqMpBQAAAAAAAMvRlAIAAAAAAIDlaEoBAAAAAADAcjSlAAAAAAAAYDmaUgAAAAAAALAcTSkAAAAAAABYjqYUAAAAAAAALEdTCgAAAAAAAJajKQUAAAAAAADL0ZQCAAAAAACA5WhKAQAAAAAAwHI0pQAAAAAAAGA5mlIAAAAAAACwHE0pAAAAAAAAWI6mFAAAAAAAACxHUwoAAAAAAACWoykFAAAAAAAAy9GUAgAAAAAAgOVoSgEAAAAAAMByNKUAAAAAAABgOZpSAAAAAAAAsBxNKQAAAAAAAFiOphQAAAAAAAAsR1MKAAAAAAAAlqMpBQAAAAAAAMvRlAIAAAAAAIDlaEoBAAAAAADAcjSlAAAAAAAAYDmaUgAAAAAAALAcTSkAAAAAAABYjqYUAAAAAAAALEdTCgAAAAAAAJajKQUAAAAAAADL0ZQCAAAAAACA5WhKAQAAAAAAwHI0pQAAAAAAAGA5mlIAAAAAAACwnMebUtOmTVNUVJSCg4MVHR2t9evXFzv2888/16233qorrrhCoaGhat++vVasWGFhtQAATyArAAClISsAwPd4tCm1YMECjRo1SuPHj9fOnTvVqVMn9ezZU0lJSUWOX7dunW699VYtW7ZM27dvV9euXdWnTx/t3LnT4soBAFYhKwAApSErAMA32YwxxlNv3q5dO7Vu3VrTp08v2NasWTP17dtXCQkJTr1GixYtNGDAAE2cONGp8RkZGbLb7UpPT1doaGi56gaAisob10iyAgC8izeukWQFAHgXZ9dIj50pdf78eW3fvl0xMTEO22NiYrRp0yanXiM3N1eZmZmqWbNmsWOysrKUkZHh8AAA+AayAgBQGrICAHyXx5pSaWlpysnJUXh4uMP28PBwpaamOvUar776qk6fPq3+/fsXOyYhIUF2u73g0aBBg0uqGwBgHbICAFAasgIAfJfHL3Rus9kcfjbGFNpWlPnz52vy5MlasGCBateuXey4cePGKT09veBx5MiRS64ZAGAtsgIAUBqyAgB8j7+n3rhWrVqqUqVKoU8vjh07VuhTjostWLBAQ4cO1cKFC9W9e/cSxwYFBSkoKOiS6wUAWI+sAACUhqwAAN/lsTOlAgMDFR0drcTERIftiYmJ6tChQ7H7zZ8/X0OGDNHHH3+s3r17u7tMAIAHkRUAgNKQFQDguzx2ppQkjRkzRg888IDatGmj9u3ba9asWUpKSlJcXJykvFNkf/31V3344YeS8oJj0KBBeuONN3TjjTcWfBoSEhIiu93usXkAANyHrAAAlIasAADf5NGm1IABA3T8+HHFx8crJSVFLVu21LJlyxQZGSlJSklJUVJSUsH4mTNnKjs7W4899pgee+yxgu2DBw/W+++/b3X5AAALkBUAgNKQFQDgm2zGGOPpIqyUkZEhu92u9PR0hYaGerocAPAqrJF5+D0AQPFYI/PwewCA4jm7Rnr87nsAAAAAAACofGhKAQAAAAAAwHI0pQAAAAAAAGA5mlIAAAAAAACwHE0pAAAAAAAAWI6mFAAAAAAAACxHUwoAAAAAAACWoykFAAAAAAAAy9GUAgAAAAAAgOVoSgEAAAAAAMByNKUAAAAAAABgOZpSAAAAAAAAsBxNKQAAAAAAAFiOphQAAAAAAAAsR1MKAAAAAAAAlqMpBQAAAAAAAMvRlAIAAAAAAIDlaEoBAAAAAADAcjSlAAAAAAAAYDmaUgAAAAAAALAcTSkAAAAAAABYjqYUAAAAAAAALEdTCgAAAAAAAJajKQUAAAAAAADL0ZQCAAAAAACA5WhKAQAAAAAAwHI0pQAAAAAAAGA5mlIAAAAAAACwHE0pAAAAAAAAWI6mFAAAAAAAACxHUwoAAAAAAACWoykFAAAAAAAAy9GUAgAAAAAAgOVoSgEAAAAAAMByNKUAAAAAAABgOZpSAAAAAAAAsBxNKQAAAAAAAFiOphQAAAAAAAAsR1MKAAAAAAAAlqMpBQAAAAAAAMvRlAIAAAAAAIDlaEoBAAAAAADAcjSlAAAAAAAAYDmaUgAAAAAAALCcx5tS06ZNU1RUlIKDgxUdHa3169eXOH7t2rWKjo5WcHCwGjZsqBkzZlhSZ06u0eb9x/XFrl+1ef9x5eQaS94XFVv6mQu6e9pGtU9YpbunbVT6mQueLgk+rqKuVb6SFYA7kBWAc8gKAPA9/p588wULFmjUqFGaNm2aOnbsqJkzZ6pnz57au3evrrzyykLjDx48qF69eumRRx7RRx99pI0bN+rRRx/VFVdcobvvvtttdS7/LkVTlu5VSvq5gm117cGa1Ke5bmtZ123vi4qt88urdfj42YKfU9LPqVX8SkWGhWjtk908WBl8VUVdq3wlKwB3ICsA55AVAOCbbMYYj32M3q5dO7Vu3VrTp08v2NasWTP17dtXCQkJhcb/9a9/1Zdffql9+/YVbIuLi9Pu3bu1efNmp94zIyNDdrtd6enpCg0NLXX88u9SNPyjHbr4l2T7v39OH9japw/24BkXH2RcjIMNlJWr1qqyrpFW8IWsANyBrIC38sY1kqwAAO/i7Brpsa/vnT9/Xtu3b1dMTIzD9piYGG3atKnIfTZv3lxofI8ePbRt2zZduOD6U9lzco2mLN1b6CBPUsG2KUv3Vpivx8Aa6WculHiQIUmHj5/l6xlwWkVeq3whKwB3ICsA55EVAOC7PNaUSktLU05OjsLDwx22h4eHKzU1tch9UlNTixyfnZ2ttLS0IvfJyspSRkaGw8NZWw6ecPgazMWM8k6j33LwhNOvCTz0/haXjgMq8lrlC1kBuANZATiPrAAA3+XxC53bbDaHn40xhbaVNr6o7fkSEhJkt9sLHg0aNHC6tmOZxR/klWccIEnJJTQPyjMOqAxrlTdnBeAOZAVQdmQFAPgejzWlatWqpSpVqhT69OLYsWOFPrXIV6dOnSLH+/v7KywsrMh9xo0bp/T09ILHkSNHnK6xdo1gl44DJCnC7tzfi7PjgIq8VvlCVgDuQFYAziMrAMB3eawpFRgYqOjoaCUmJjpsT0xMVIcOHYrcp3379oXGr1y5Um3atFFAQECR+wQFBSk0NNTh4ay2UTVV1x6s4j5fsSnvzlZto2o6/ZrA3CFtXToOqMhrlS9kBeAOZAXgPLICAHyXR7++N2bMGM2ePVtz587Vvn37NHr0aCUlJSkuLk5S3qcRgwYNKhgfFxenw4cPa8yYMdq3b5/mzp2rOXPmaOzYsW6pr4qfTZP6NJekQgd7+T9P6tNcVfyKPy0YuJi9aoAiw0JKHBMZFiJ71aL/hwi4WEVfq7w9KwB3ICuAsiErAMA3+XvyzQcMGKDjx48rPj5eKSkpatmypZYtW6bIyEhJUkpKipKSkgrGR0VFadmyZRo9erTeeecdRURE6M0339Tdd9/tthpva1lX0we21pSlex0uJFzHHqxJfZo7dYt14GJrn+xW7K2+ucU3yqMir1W+kBWAO5AVgPPICgDwTTaTf0W/SiIjI0N2u13p6ellOuU2J9doy8ETOpZ5TrVr5H0NxlfPOoD3SD9zQQ+9v0XJ6ecUYQ/W3CFt+dQbl+RS16ryrpEVDb8HeBOyAt6GNTIPvwcAKJ6za6RHz5TyJVX8bGrfqOiLHgLlZa8aoEWPdvR0GahAWKuAioesAAAAFZVHrykFAAAAAACAyommFAAAAAAAACxHUwoAAAAAAACWoykFAAAAAAAAy9GUAgAAAAAAgOVoSgEAAAAAAMBy/p4uwGrGGElSRkaGhysBAO+Tvzbmr5WVFVkBAMUjK/KQFQBQPGezotI1pTIzMyVJDRo08HAlAOC9MjMzZbfbPV2Gx5AVAFA6soKsAIDSlJYVNlPJPuLIzc1VcnKyatSoIZvNVqZ9MzIy1KBBAx05ckShoaFuqtB7MN+KrTLNtzLNVbq0+RpjlJmZqYiICPn5Vd5veJMVzmO+FVtlmm9lmqtEVrgCWeE85luxVab5Vqa5StZkRaU7U8rPz0/169e/pNcIDQ2tFH+A+ZhvxVaZ5luZ5iqVf76V+VPvfGRF2THfiq0yzbcyzVUiKy4FWVF2zLdiq0zzrUxzldybFZX3ow0AAAAAAAB4DE0pAAAAAAAAWI6mVBkEBQVp0qRJCgoK8nQplmC+FVtlmm9lmqtU+ebrbSrb75/5VmyVab6Vaa5S5Zuvt6lsv3/mW7FVpvlWprlK1sy30l3oHAAAAAAAAJ7HmVIAAAAAAACwHE0pAAAAAAAAWI6mFAAAAAAAACxHU+oi06ZNU1RUlIKDgxUdHa3169eXOH7t2rWKjo5WcHCwGjZsqBkzZlhUqWuUZb6ff/65br31Vl1xxRUKDQ1V+/bttWLFCgurvXRl/febb+PGjfL399f111/v3gJdqKxzzcrK0vjx4xUZGamgoCA1atRIc+fOtajaS1fW+c6bN0+tWrVS1apVVbduXT344IM6fvy4RdVemnXr1qlPnz6KiIiQzWbTkiVLSt3H19cqb0NWkBVFISu8H1lRMl9fq7wNWUFWFIWs8H5kRclcvlYZFPjkk09MQECAeffdd83evXvNyJEjTbVq1czhw4eLHH/gwAFTtWpVM3LkSLN3717z7rvvmoCAAPPZZ59ZXHn5lHW+I0eONC+++KLZsmWL+emnn8y4ceNMQECA2bFjh8WVl09Z55vv5MmTpmHDhiYmJsa0atXKmmIvUXnmescdd5h27dqZxMREc/DgQfPvf//bbNy40cKqy6+s812/fr3x8/Mzb7zxhjlw4IBZv369adGihenbt6/FlZfPsmXLzPjx482iRYuMJLN48eISx/v6WuVtyAqyoihkhfcjKxaXON7X1ypvQ1aQFUUhK7wfWbG4xPHuWKtoSv1B27ZtTVxcnMO2pk2bmqeffrrI8U899ZRp2rSpw7Zhw4aZG2+80W01ulJZ51uU5s2bmylTpri6NLco73wHDBhgJkyYYCZNmuQz4VHWuX799dfGbreb48ePW1Gey5V1vi+//LJp2LChw7Y333zT1K9f3201uosz4eHra5W3ISvIiqKQFd6PrFhc4hhfX6u8DVlBVhSFrPB+ZMXiEse4Y63i63v/5/z589q+fbtiYmIctsfExGjTpk1F7rN58+ZC43v06KFt27bpwoULbqvVFcoz34vl5uYqMzNTNWvWdEeJLlXe+b733nvav3+/Jk2a5O4SXaY8c/3yyy/Vpk0bvfTSS6pXr56uueYajR07VmfPnrWi5EtSnvl26NBBv/zyi5YtWyZjjI4eParPPvtMvXv3tqJky/nyWuVtyIo8ZIUjsoKsqAh8ea3yNmRFHrLCEVlBVlQE7lir/F1RWEWQlpamnJwchYeHO2wPDw9XampqkfukpqYWOT47O1tpaWmqW7eu2+q9VOWZ78VeffVVnT59Wv3793dHiS5Vnvn+97//1dNPP63169fL3993/lMpz1wPHDigDRs2KDg4WIsXL1ZaWpoeffRRnThxwuu//12e+Xbo0EHz5s3TgAEDdO7cOWVnZ+uOO+7QW2+9ZUXJlvPltcrbkBV5yIr/ISvIiorCl9cqb0NW5CEr/oesICsqCnesVZwpdRGbzebwszGm0LbSxhe13VuVdb755s+fr8mTJ2vBggWqXbu2u8pzOWfnm5OTo/vvv19TpkzRNddcY1V5LlWWf7e5ubmy2WyaN2+e2rZtq169emnq1Kl6//33feJTDals8927d69GjBihiRMnavv27Vq+fLkOHjyouLg4K0r1CF9fq7wNWUFWSGQFWVHx+Ppa5W3ICrJCIivIiorH1WuV77Rp3axWrVqqUqVKoQ7osWPHCnUC89WpU6fI8f7+/goLC3Nbra5QnvnmW7BggYYOHaqFCxeqe/fu7izTZco638zMTG3btk07d+7U448/LilvgTXGyN/fXytXrlS3bt0sqb2syvPvtm7duqpXr57sdnvBtmbNmskYo19++UWNGzd2a82XojzzTUhIUMeOHfXkk09Kkq677jpVq1ZNnTp10nPPPefVn0aWhy+vVd6GrMhDVuQhK8iKisSX1ypvQ1bkISvykBVkRUXijrWKM6X+T2BgoKKjo5WYmOiwPTExUR06dChyn/bt2xcav3LlSrVp00YBAQFuq9UVyjNfKe+TjCFDhujjjz/2qe/JlnW+oaGh2rNnj3bt2lXwiIuLU5MmTbRr1y61a9fOqtLLrDz/bjt27Kjk5GSdOnWqYNtPP/0kPz8/1a9f3631XqryzPfMmTPy83Nc/qpUqSLpf53+isSX1ypvQ1bkISvykBVkRUXiy2uVtyEr8pAVecgKsqIicctaVe5LpFdA+bd/nDNnjtm7d68ZNWqUqVatmjl06JAxxpinn37aPPDAAwXj82+HOHr0aLN3714zZ84cn7x1q7Pz/fjjj42/v7955513TEpKSsHj5MmTnppCmZR1vhfzpbtklHWumZmZpn79+uaee+4x33//vVm7dq1p3Lixefjhhz01hTIp63zfe+894+/vb6ZNm2b2799vNmzYYNq0aWPatm3rqSmUSWZmptm5c6fZuXOnkWSmTp1qdu7cWXCr2oq2VnkbsoKsICvICl9AVngWWUFWkBVkhS/whqygKXWRd955x0RGRprAwEDTunVrs3bt2oLnBg8ebDp37uww/ptvvjE33HCDCQwMNFdddZWZPn26xRVfmrLMt3PnzkZSocfgwYOtL7ycyvrv9498KTyMKftc9+3bZ7p3725CQkJM/fr1zZgxY8yZM2csrrr8yjrfN9980zRv3tyEhISYunXrmtjYWPPLL79YXHX5rFmzpsT/FiviWuVtyAqyojhkhXcjK8gKK5EVZEVxyArvRlZYmxU2YyrgOWUAAAAAAADwalxTCgAAAAAAAJajKQUAAAAAAADL0ZQCAAAAAACA5WhKAQAAAAAAwHI0pQAAAAAAAGA5mlIAAAAAAACwHE0pAAAAAAAAWI6mFAAAAAAAACxHUwoAAAAAAACWoykFeIGUlBTdf//9atKkifz8/DRq1ChPlwQA8DIbNmxQx44dFRYWppCQEDVt2lSvvfaap8sCAHiIM8cQFy5cUHx8vBo1aqTg4GC1atVKy5cvt75YoBg0pQAvkJWVpSuuuELjx49Xq1atPF0OAMALVatWTY8//rjWrVunffv2acKECZowYYJmzZrl6dIAAB7gzDHEhAkTNHPmTL311lvau3ev4uLidNddd2nnzp0WVwsUjaYUYIHffvtNderU0d///veCbf/+978VGBiolStX6qqrrtIbb7yhQYMGyW63e7BSAICnlJYVN9xwg+677z61aNFCV111lQYOHKgePXpo/fr1HqwaAOAurjiG+Mc//qFnnnlGvXr1UsOGDTV8+HD16NFDr776qlXTAEpEUwqwwBVXXKG5c+dq8uTJ2rZtm06dOqWBAwfq0UcfVUxMjKfLAwB4gbJmxc6dO7Vp0yZ17tzZA9UCANzNFccQWVlZCg4OdtgWEhKiDRs2uKNkoMz8PV0AUFn06tVLjzzyiGJjY/WnP/1JwcHBeuGFFzxdFgDAiziTFfXr19dvv/2m7OxsTZ48WQ8//LCHqgUAuNulHkP06NFDU6dO1c0336xGjRpp1apV+uKLL5STk+PGqgHncaYUYKFXXnlF2dnZ+vTTTzVv3rxCn1oAAFBaVqxfv17btm3TjBkz9Prrr2v+/PkeqhQAYIVLOYZ444031LhxYzVt2lSBgYF6/PHH9eCDD6pKlSpurBhwHk0pwEIHDhxQcnKycnNzdfjwYU+XAwDwQqVlRVRUlK699lo98sgjGj16tCZPnmx9kQAAy1zKMcQVV1yhJUuW6PTp0zp8+LB++OEHVa9eXVFRUW6qFigbvr4HWOT8+fOKjY3VgAED1LRpUw0dOlR79uxReHi4p0sDAHiJsmaFMUZZWVkWVwkAsIqrjiGCg4NVr149XbhwQYsWLVL//v3dVDFQNjSlAIuMHz9e6enpevPNN1W9enV9/fXXGjp0qL766itJ0q5duyRJp06d0m+//aZdu3YpMDBQzZs392DVAAArlZQV77zzjq688ko1bdpUkrRhwwa98sor+stf/uLhqgEA7nKpxxD//ve/9euvv+r666/Xr7/+qsmTJys3N1dPPfWUp6YEOLAZY4yniwAqum+++Ua33nqr1qxZo5tuukmSlJSUpOuuu04JCQkaPny4bDZbof0iIyN16NAhi6sFAHhCaVmRnZ2tmTNn6uDBg/L391ejRo30yCOPaNiwYfLz44oMAFDRuOIYYu3atRo+fLgOHDig6tWrq1evXnrhhRcUERFh5VSAYtGUAgAAAAAAgOX4WA0AAAAAAACWoykFAAAAAAAAy9GUAgAAAAAAgOVoSgEAAAAAAMByNKUAAAAAAABgOZpSAAAAAAAAsBxNKQAAAAAAAFiOphQAAAAAAAAsR1MKAAAAAAAAlqMpBQAAAAAAAMvRlAIAAAAAAIDlaEoBAAAAAADAcv8fc2KvDLwa2jYAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1200x400 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the slices again. Note that the (x1, x2) plane was refined simultaneously once \n",
    "# (by accepting the multi index of quadrature order [1, 1, 0, ... ,0])\n",
    "plot_grid_2D()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Post processing\n",
    "\n",
    "There are a number of post-processing step we can take. Below we show the 'adaptation table' which displays which multi indices were refined at every iteration. Note that at iteration 4, indeed both x1 and x2 were refined at the same time. At iteration 7, x1 and x3 were simultaneously refined to 1st order. It is clear that the algortihm focuses on (combinations of) important parameters first, and keeps the uninfluential parameters at order zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:37:03.488676Z",
     "start_time": "2021-06-09T07:37:03.281144Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "analysis.adaptation_table()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also make a histrogram which visualises the adaptation. This displays only a first-order information, i.e. only the maximum quadrature order per input. It therefore does not display that certain inputs were refined simultaneously:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:37:03.600563Z",
     "start_time": "2021-06-09T07:37:03.490218Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 400x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "analysis.adaptation_histogram()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get a list of the error magnitudes associated to the multi indices that were selected use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:37:03.605731Z",
     "start_time": "2021-06-09T07:37:03.601622Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.8226498377766707e-06,\n",
       " 1.0552183271338636e-06,\n",
       " 7.425610450201265e-07,\n",
       " 5.755736329821073e-07,\n",
       " 5.728328061583833e-07,\n",
       " 4.6625926082659077e-07,\n",
       " 4.050332972837051e-07,\n",
       " 3.9312055324594937e-07,\n",
       " 3.3981607144988786e-07,\n",
       " 3.124542579045724e-07,\n",
       " 2.992410181424385e-07,\n",
       " 2.673219762072451e-07,\n",
       " 2.543232331781408e-07,\n",
       " 2.4155600259690836e-07,\n",
       " 2.3449296158530413e-07,\n",
       " 2.203203100609163e-07,\n",
       " 2.1442939267960927e-07,\n",
       " 2.0251664864185235e-07,\n",
       " 1.8737521696769532e-07,\n",
       " 1.8535422079084905e-07,\n",
       " 1.808945703658052e-07,\n",
       " 1.7434041926559496e-07,\n",
       " 1.6322237353224039e-07]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "analysis.get_adaptation_errors()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This shows a nice monotonic decrease of the error. However, this is due to the fact that we have a simple polynomial test function, and the SC expansion is polynomial as well. More complex simulation codes can show non-monotonic behaviour."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To compute the mean and variance of the code output we use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:37:03.897220Z",
     "start_time": "2021-06-09T07:37:03.608384Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean = 4.5759e-06\n",
      "Standard deviation = 1.6954e-06\n"
     ]
    }
   ],
   "source": [
    "df = campaign.get_collation_result()\n",
    "results = analysis.analyse(df)\n",
    "print('Mean = %.4e' % results.describe('f', 'mean'))\n",
    "print('Standard deviation = %.4e' % results.describe('f', 'std'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, `'f'` is simply the name of our quantity of interest. We can also compute the exact moments in this case:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:37:03.900495Z",
     "start_time": "2021-06-09T07:37:03.898129Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exact mean = 4.9021e-06\n",
      "Exact standard deviation = 2.1302e-06\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1/(2*(i+1)) for i in range(d)])\n",
    "ref_mean = np.prod(a + 1) / 2**d\n",
    "ref_std = np.sqrt(np.prod(9 * a**2 / 5 + 2 * a + 1) / 2**(2 * d) - ref_mean**2)\n",
    "print('Exact mean = %.4e' % ref_mean)\n",
    "print('Exact standard deviation = %.4e' % ref_std)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that the estimates are fair, although not yet fully converged in this case. Note however that these results are computed only with the accepted set of multi indices. At the end, we can merge the accepted and admissible set (thereby using all samples), and recompute the results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:37:33.769114Z",
     "start_time": "2021-06-09T07:37:03.901351Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean = 4.8254e-06\n",
      "Standard deviation = 1.9298e-06\n"
     ]
    }
   ],
   "source": [
    "analysis.merge_accepted_and_admissible()\n",
    "df = campaign.get_collation_result()\n",
    "results = analysis.analyse(df)\n",
    "print('Mean = %.4e' % results.describe('f', 'mean'))\n",
    "print('Standard deviation = %.4e' % results.describe('f', 'std'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This improved our estimates. Note however, that if we would refine again from this point, the new admissble set will be very large, since we added *all* previous admissible indices to the accepted set. This opens up a wide range of possible new candidate directions, making the corresponding ensemble very large.\n",
    "\n",
    "Thus if we are still not happy about the result, we first have to undo the merging via `analysis.undo_merge()`, before refining again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:37:33.771302Z",
     "start_time": "2021-06-09T07:37:33.770024Z"
    }
   },
   "outputs": [],
   "source": [
    "# This will undo the merge, and reproduce the old results\n",
    "#analysis.undo_merge()\n",
    "#df = campaign.get_collation_result()\n",
    "#results = analysis.analyse(df)\n",
    "#print('Mean = %.4e' % results.describe('f', 'mean'))\n",
    "#print('Standard deviation = %.4e' % results.describe('f', 'std'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also display the Sobol sensitivity indices via:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-09T07:37:33.860757Z",
     "start_time": "2021-06-09T07:37:33.772045Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sobols = []\n",
    "# retrieve the Sobol indices from the results object\n",
    "params = list(sampler.vary.get_keys())\n",
    "for param in params:\n",
    "    sobols.append(results._get_sobols_first('f', param))\n",
    "# make a bar chart\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111, title='First-order Sobol indices')\n",
    "ax.bar(range(len(sobols)), height=np.array(sobols).flatten())\n",
    "ax.set_xticks(range(len(sobols)))\n",
    "ax.set_xticklabels(params)\n",
    "plt.xticks(rotation=90)\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the Sobol indices show the expected qualitative behaviour for this model, with x1 being the most important, followed by x2 etc."
   ]
  }
 ],
 "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.7.7"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}