{
 "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,  5.59it/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": [
      "/Volumes/Samsung8TB/dpc/GIT/EasyVVUQ/env/lib/python3.9/site-packages/easyvvuq-0.9.3+141.gf9780783.dirty-py3.9.egg/easyvvuq/analysis/sc_analysis.py:1097: 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": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "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:02<00:00, 13.91it/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 864x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "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,  6.65it/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": "iVBORw0KGgoAAAANSUhEUgAAA1gAAAEYCAYAAABBWFftAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAAitElEQVR4nO3de7RkdXnm8e9jA9oGtFVaRxoUNEjEiIJHvGaCugwXkwEZk3iJCINDSEJMZiYsUBOvo0hwEjVeCFEGjUbiRAYxoq2jUZMgSBMUbLW1xQvdHaURWlFboeGdP3YdLA6nzqV776pTdb6ftc6i9t6/2vtdVdTT+92XqlQVkiRJkqRdd49RFyBJkiRJk8IGS5IkSZJaYoMlSZIkSS2xwZIkSZKklthgSZIkSVJLbLAkSZIkqSU2WMtIkrOS/PGo6xgkyYOSfCXJPXdhHZXkF9usS9LimTeS2rTUM2VXJfl8kkftwvM/neTFbdaknWeDtUwkWQ2cAPz1Asefl2RDkjuSnNhiHW9M8vUktyT5apITppdV1feAfwJOaWt7koZvMXmTZO8k/5rk+0m2Jflckqe0XM/9k2xN8i/T88wbaXy0uQ+T5J5J/jLJliQ3J3l7kt1bqPERST7Uy5qbkqxNctCMMf8tyXeT/CDJ+TMO8LwReM2u1qGlwQZr+TgRuLSqti9w/BeB3wf+reU6fgz8BnBf4EXAm5M8uW/5+4DfbXmbkobrRBaeNz8C/guwGrgfcDbw4SS7tVjP2cBXZplv3kjj4UTa24c5E5gCfhl4BHAY8Kct1LgKuAQ4CHgQ8HngQ9MLkxzZ2/YzgP2BhwGv7nv+JcDTkjy4hVo0YjZYy8fRwGemJ5KckeTy6Z2YJL+XZH2SewFU1duq6pPATxezkSQP7x25Oaw3vU+SG5Mc0VvvK6vqq1V1R1VdAfwz8KS+VVwBPCzJQwes/4Ik5yb5RO8s2GfmGPusJFcn+WGS65O8qm/Z/r3Le16U5Du9Gl/et/weSc5M8o3ekfUPJLn/Yl4LaRlbcN5U1U+rakNV3QEEuJ2m0Zr38zZf3vTmPYlmR+p/z7IK80YaD23uw/wG8JaquqmqtgJvoTnIM695suzzVfWu3npvA/4SOCjJA3pPfxHwrqpaX1U3A6+laRzp1fxT4Crg1wZs+8Q0Z/v/qncG7KtJnjFg7MOTfKqXJzcmeV+SVX3Lv5XkT5Jc01vX30+/dr3lv57kC2muKrgsySELeX30czZYy8ejgQ190+cAtwJ/muRA4PXA7/Q+4Dutqr4BnAG8L8m9aXZqLqiqT88cm2Ql8Hhgfd/zdwAbgcfMsZkX0ATT3sAXaI5Cz+bHNJcUrAKeBfxekuNmjHkqzdGmZwCvSPLI3vyXAMcBvwrsA9wMvG2OmiT93KLzJsk1NDtDlwDvrKob5tvIfHmTZAXN5/Y0oGZ5vnkjjYc292HS++uf3jfJfRfw3MVs9z8C362q7/emH0VzZm3aF4EH9TVg0JxpnyuPngBcR5NHrwQuGnAwJsBZNHnySGA/4FUzxvwWcBRwAHAIvWavd8DqfJqz+w+guSzzkuzC/arLkQ3W8rEKuGV6one0+ASaf9gvAf68qq5uY0NV9TfA12mODj8YePmAoefSBMzaGfNv6dU7yEeq6rNV9bPeup+UZL9Z6vh0VV3bO1t2DfB+mh2Yfq+uqu1V9cVeLdPB9rvAy6tqU287rwKek3YvW5Im1SoWmTdVdQhwH+D5wL+wQPPkzUuAK6rqqjlWYd5IS98q2tuH+SjwR0lWJ/kPvXUA3Hu+Jy50u0n2pTlI8t/7Zu8J/KBvevrxXn3z5sujG4A3VdVtVfX3NE3ns2apc2NVfaKqftY7S/cX3D2P3lJVW6rqJuDDwGN78/8r8NdVdUVV3V5V7wZ+Bjxxjro0gw3W8nEzd/0QU1XfornJe3/aP1r6NzSX5fxVb4fhLpKc01v+W1U188jyXsC2OdZ9/fSDqvoRcBPNUZqZ23hCkn9Kc8PpD4BTaY769Ptu3+Of0AQgwEOB/9s7Pb6N5qjS7TTXVUua207lTe9ywfcDZyaZ6yjuTHfLmyT70OwEDTrAM828kZa+NvdhXgdcTXNG+jLgYuA2muZlXvNtN80XcnwceHsvz6b9iOYg0rTpx7f0zZsvjzbP2Gf6NrPn0QOTXJhkc5IfAu9lcXn0P6bzqJdJ+822HQ1mg7V8XENzM+edkhxDc//TJ2lOe7ciyZ7Am4B3Aa+aefo6yatprqf+tar64YxluwG/yF1Po89059Hj3rbuD2yZZdzf0Rxh2q+q7ktzxiyzjJvN9cDRVbWq7+9eVbV5gc+XlrNdzZvdaW4An9cceXM4zRmtLyf5LvBm4PA03+C1ovdc80YaD63tw/TOIp9WVWuq6mHA94Grqur2hTx/ru0muR9Nc3VJVb1uxlPXc9fL/x4DfK/vEkJoLuebK4/WJOnPlYcwex6dRXNZ9CFVdR/gd1hcHr1uRh7de0azqHnYYC0fl9J3ejjJ3jQ7JC+mufHyN3qhMb18j94NjwF2T3KvJPfoLTsiyd3uZ+jzZpqwejHwEZodjen1vpTmEqBnzgiVaYcD36qqb8+x/mOSPDXJHjT3RlxRVdfPMm4v4Kaq+mmSw3vbXahzgdeld0N771KCYxfxfGk5W3DeJHni9Oc5ycokZ9Ccubmit3xn8+ajNEeYH9v7ewXNUevH9u1ImTfSeGhzH2ZNmi/ESZInAn9Gcz/T9HMvSHLBbEXMk2X3obnl4V+r6sxZnv4e4OQkB/casT8F7txO7x6nxwGfmON1eCDwkiS7J/lNmobs0lnG7UVzxmxbkjXA6XOsc6a/AU7tnZVPkl9I8yU+e837TN3JBmv5eA/NjsLK3vR5wIeq6tJeo3My8M6+my0/DmwHntwbu53mhk1ojuh+braN9HYKjqK5PAaa648PS/KC3vTraY64fD3Jj3p/L+tbxQvoa8gG+DuaMLyJJoxeMGDc7wOvSXILzc7VB+ZZb7830xyN/njv+ZfT3FwqaX6LyZt70lxm831gM3AM8Kyqmj4qu1N507v34LvTfzT3O9zWezzNvJHGQ5v7MA+nuTTwx8C7gTOr6uN929oP+NcBdcy13WfTfHHXSX37Nz9K8hCAqvoY8Oc0lxd+u/f3yr51/yfg033ZN5srgAOBG2kudXzOgIPVr6b5+vkf0Bx4umiOdd5FVa2juQ/rrTSXZm6k79sOtTC5++0vmlRJXg/cUFVv2sX1vBP4P1U188spdkmSB9J8Deuhg74JqHdUaVNVtfGbFZI6Yt5IalNbmTLPNvaguUTvkGq+an1oklwBnFxVXxqw/ETgxVX11GHWpZ1jg6Wx4g6PpGExbyQtFTZY48VLBCVJkiSpJZ7BkiRJkqSWeAZLkiRJkloydr8Sv/fee9f+++8/6jIkLdBVV111Y1WtHnUdO8vMkcaHeSNpmAZlztg1WPvvvz/r1q0bdRmSFijJXL8xtOSZOdL4MG8kDdOgzPESQUmSJElqiQ2WJEmSJLXEBkuSJEmSWmKDJUmSJEktscGSJEmSpJZ01mAlOT/JDUm+NGB5krwlycYk1yQ5rKtatLRdfPVmnvKGT3HAmR/hKW/4FBdfvXnUJWkMmTmShsW8kTSXLs9gXQAcNcfyo4EDe3+nAO/osBYtURdfvZmXXnQtm7dtp4DN27bz0ouutcnSzrgAM0fScFyAeSNpgM4arKr6LHDTHEOOBd5TjcuBVUke3FU9WprOWbuB7bfdfpd522+7nXPWbhhRRRpXZo6kYTFvJM1llPdgrQGu75ve1Jt3N0lOSbIuybqtW7cOpTgNx5Zt2xc1X9oFZo6kYTFvpGVslA1WZplXsw2sqvOqaqqqplavXt1xWRqmfVatXNR8aReYOZKGxbyRlrFRNlibgP36pvcFtoyoFo3I6UcexMrdV9xl3srdV3D6kQeNqCJNMDNH0rCYN9IyNsoG6xLghN437TwR+EFV/fsI69EIHHfoGs46/tGsWbWSAGtWreSs4x/NcYfOeiWFtCvMHEnDYt5Iy9huXa04yfuBI4C9k2wCXgnsDlBV5wKXAscAG4GfACd1VYuWtuMOXWNDpV1m5kgaFvNG0lw6a7Cq6nnzLC/gD7ravqTlxcyRNCzmjaS5jPISQUmSJEmaKDZYkiRJktQSGyxJkiRJaokNliRJkiS1xAZLkiRJklpigyVJkiRJLbHBkiRJkqSW2GBJkiRJUktssCRJkiSpJTZYkiRJktQSGyxJkiRJaokNliRJkiS1xAZLkiRJklpigyVJkiRJLbHBkiRJkqSW2GBJkiRJUktssCRJkiSpJTZYkiRJktQSGyxJkiRJaokNliRJkiS1xAZLkiRJklpigyVJkiRJLbHBkiRJkqSW2GBJkiRJUktssCRJkiSpJTZYkiRJktQSGyxJkiRJaokNliRJkiS1xAZLkiRJklpigyVJkiRJLbHBkiRJkqSWdNpgJTkqyYYkG5OcOcvy+yb5cJIvJlmf5KQu65E0ucwbScNk5kgapLMGK8kK4G3A0cDBwPOSHDxj2B8AX66qxwBHAP8ryR5d1SRpMpk3kobJzJE0ly7PYB0ObKyq66rqVuBC4NgZYwrYK0mAPYGbgB0d1iRpMpk3kobJzJE0UJcN1hrg+r7pTb15/d4KPBLYAlwL/FFV3TFzRUlOSbIuybqtW7d2Va+k8dVa3oCZI2le7uNIGqjLBiuzzKsZ00cCXwD2AR4LvDXJfe72pKrzqmqqqqZWr17ddp2Sxl9reQNmjqR5uY8jaaAuG6xNwH590/vSHMXpdxJwUTU2At8EfqnDmiRNJvNG0jCZOZIG6rLBuhI4MMkBvZs6nwtcMmPMd4BnACR5EHAQcF2HNUmaTOaNpGEycyQNtFtXK66qHUlOA9YCK4Dzq2p9klN7y88FXgtckORamtPtZ1TVjV3VJGkymTeShsnMkTSXzhosgKq6FLh0xrxz+x5vAX6tyxokLQ/mjaRhMnMkDdLpDw1LkiRJ0nJigyVJkiRJLbHBkiRJkqSW2GBJkiRJUktssCRJkiSpJTZYkiRJktQSGyxJkiRJaokNliRJkiS1xAZLkiRJklpigyVJkiRJLbHBkiRJkqSW2GBJkiRJUktssCRJkiSpJTZYkiRJktQSGyxJkiRJaokNliRJkiS1xAZLkiRJklpigyVJkiRJLbHBkiRJkqSW2GBJkiRJUktssCRJkiSpJTZYkiRJktQSGyxJkiRJaokNliRJkiS1xAZLkiRJklpigyVJkiRJLbHBkiRJkqSW2GBJkiRJUktssCRJkiSpJTZYkiRJktQSGyxJkiRJakmnDVaSo5JsSLIxyZkDxhyR5AtJ1if5TJf1SJpc5o2kYTJzJA2yW1crTrICeBvwTGATcGWSS6rqy31jVgFvB46qqu8keWBX9UiaXOaNpGEycyTNpcszWIcDG6vquqq6FbgQOHbGmOcDF1XVdwCq6oYO65E0ucwbScNk5kgaqMsGaw1wfd/0pt68fo8A7pfk00muSnLCbCtKckqSdUnWbd26taNyJY2x1vIGzBxJ83IfR9JAXTZYmWVezZjeDXgc8CzgSODPkjzibk+qOq+qpqpqavXq1e1XKmnctZY3YOZImpf7OJIG6uweLJqjOfv1Te8LbJllzI1V9WPgx0k+CzwG+FqHdUmaPOaNpGEycyQN1OUZrCuBA5MckGQP4LnAJTPGfAj4lSS7Jbk38ATgKx3WJGkymTeShsnMkTRQZ2ewqmpHktOAtcAK4PyqWp/k1N7yc6vqK0k+BlwD3AG8s6q+1FVNkiaTeSNpmMwcSXNJ1cxLhpe2qampWrdu3ajLkLRASa6qqqlR17GzzBxpfJg3koZpUOZ0+kPDkiRJkrSc2GBJkiRJUktssCRJkiSpJTZYkiRJktQSGyxJkiRJaokNliRJkiS1xAZLkiRJklpigyVJkiRJLdlt1AVIkiQNU5LdgJOBZwP7AAVsAT4EvKuqbhtheZLGnA2WJElabv4W2Aa8CtjUm7cv8CLgvcBvj6QqSRPBBkuSJC03h1XVQTPmbQIuT/K1URQkaXLM2WAluQ+wuqq+MWP+IVV1TaeV7YKLr97MOWs3sGXbdvZZtZLTjzyI4w5dM+qyNIDv1/gY9nuV5PVV9bLONqBl5wmv+wTfu+XWO6cftNceXPHyZ46wIo3IzUl+E/hgVd0BkOQewG8CN4+0Mk0M82b5GthgJfkt4E3ADUl2B06sqit7iy8ADuu8up1w8dWbeelF17L9ttsB2LxtOy+96FoAd9qXIN+v8dH1e5XkLTNnAS9MsidAVb1klzeiZW3mzg7A9265lSe87hPu9Cw/zwXOBt6eZLqhWgX8U2+ZtEvMm+Vtrm8RfBnwuKp6LHAS8LdJju8tS9eF7axz1m64cwdw2vbbbuectRtGVJHm4vs1PobwXh0P3B9YB1zV++9tvcdXtbURLV8zd3bmm6/JVVXfqqrfrqrVwJOAJ1fVA3vzvjnq+jT+zJvlba4Ga0VV/TtAVX0eeBrw8iQvofm2nSVpy7bti5qv0fL9Gh9DeK8eCdwIHAX8v6p6N3BLVb2791iSWpPkPkkeXlXfr6ob++YfMsq6JI2/uRqsW5I8fHqi12wdARwLPKrjunbaPqtWLmq+Rsv3a3x0/V5V1S1V9cfAG4H3JvkT/K0+SR3o3QbxVeCDSdYneXzf4gtGU5WkSTHXzsvvAfdIcvD0jKq6hebo8ou7LmxnnX7kQazcfcVd5q3cfQWnHznzy4K0FPh+jY8hvlc/BZ4ObAf+BSDJEW1vRMvPg/baY1HzNdHG8jYIjQ/zZnkb2GBV1Rer6uvAB5KckcZK4C+A3x9ahYt03KFrOOv4R7Nm1UoCrFm1krOOf7RfmLBE+X6NjyG+Vx8ATgfeDpyS5K+As9reiJafK17+zLvt3PitXsvWWN4GofFh3ixvqZo7R5L8As037TwO2At4H3D29NeaDtvU1FStW7duFJuWtBOSXFVVU4sYb+ZI2ikLzZsklwEv7P8ZmiR7ARcDT62qe3ZX5WDmjTReBmXOQu5vuI3mUp2VwL2Ab45qR0fSsmDmSOraWN4GIWk8LKTBupJmZ+fxwFOB5yX5h06rkrScmTmSOjWut0FIGg8Df2i4z8lVNX2++rvAsUle2GFNkpY3M0fSsDyB5pLky/j5JclPGWlFksbevGew+nZ0+uf9bTflSFruzBxJQ+QlyZJa52/MSJKk5cpLkiW1biGXCEqSJE0iL0mW1DrPYEmSpGXJS5IldcEGS5IkSZJaYoMlSZIkSS2xwZIkSZKklthgSZIkSVJLbLAkSZIkqSWdNlhJjkqyIcnGJGfOMe7xSW5P8pwu65E0ucwbScNk5kgapLMGK8kK4G3A0cDBND/ed/CAcWcDa7uqRdJkM28kDZOZI2kuXZ7BOhzYWFXXVdWtwIXAsbOM+0Pgg8ANHdYiabKZN5KGycyRNFCXDdYa4Pq+6U29eXdKsgZ4NnDuXCtKckqSdUnWbd26tfVCJY291vKmN9bMkTQX93EkDdRlg5VZ5tWM6TcBZ1TV7XOtqKrOq6qpqppavXp1W/VJmhyt5Q2YOZLm5T6OpIF263Ddm4D9+qb3BbbMGDMFXJgEYG/gmCQ7quriDuuSNHnMG0nDZOZIGqjLButK4MAkBwCbgecCz+8fUFUHTD9OcgHwjwaPpJ1g3kgaJjNH0kCdNVhVtSPJaTTfnLMCOL+q1ic5tbd83vsgJGkhzBtJw2TmSJpLl2ewqKpLgUtnzJs1dKrqxC5rkTTZzBtJw2TmSBqk0x8aliRJkqTlxAZLkiRJklpigyVJkiRJLbHBkiRJkqSW2GBJkiRJUktssCRJkiSpJTZYkiRJktQSGyxJkiRJaokNliRJkiS1xAZLkiRJklpigyVJkiRJLbHBkiRJkqSW2GBJkiRJUktssCRJkiSpJTZYkiRJktQSGyxJkiRJaokNliRJkiS1xAZLkiRJklpigyVJkiRJLbHBkiRJkqSW2GBJkiRJUktssCRJkiSpJTZYkiRJktQSGyxJkiRJaokNliRJkiS1xAZLkiRJklpigyVJkiRJLbHBkiRJkqSW2GBJkiRJUktssCRJkiSpJTZYkiRJktSSThusJEcl2ZBkY5IzZ1n+giTX9P4uS/KYLuuRNLnMG0nDZOZIGqSzBivJCuBtwNHAwcDzkhw8Y9g3gV+tqkOA1wLndVWPpMll3kgaJjNH0ly6PIN1OLCxqq6rqluBC4Fj+wdU1WVVdXNv8nJg3w7rkTS5zBtJw2TmSBqoywZrDXB93/Sm3rxBTgY+OtuCJKckWZdk3datW1ssUdKEaC1vwMyRNC/3cSQN1GWDlVnm1awDk6fRhM8Zsy2vqvOqaqqqplavXt1iiZImRGt5A2aOpHm5jyNpoN06XPcmYL++6X2BLTMHJTkEeCdwdFV9v8N6JE0u80bSMJk5kgbq8gzWlcCBSQ5IsgfwXOCS/gFJHgJcBLywqr7WYS2SJpt5I2mYzBxJA3V2BquqdiQ5DVgLrADOr6r1SU7tLT8XeAXwAODtSQB2VNVUVzVJmkzmjaRhMnMkzSVVs14yvGRNTU3VunXrRl2GpAVKctU471SYOdL4MG8kDdOgzOn0h4YlSZIkaTmxwZIkSZKklthgSZIkSVJLbLAkSZIkqSU2WJIkSZLUEhssSZIkSWqJDZYkSZIktcQGS5IkSZJaYoMlSZIkSS2xwZIkSZKklthgSZIkSVJLbLAkSZIkqSU2WJIkSZLUEhssSZIkSWqJDZYkSZIktcQGS5IkSZJaYoMlSZIkSS2xwZIkSZKklthgSZIkSVJLbLAkSZIkqSU2WJIkSZLUEhssSZIkSWqJDZYkSZIktcQGS5IkSZJaYoMlSZIkSS2xwZIkSZKklthgSZIkSVJLbLAkSZIkqSU2WJIkSZLUEhssSZIkSWqJDZYkSZIktaTTBivJUUk2JNmY5MxZlifJW3rLr0lyWJf1aGm6+OrNPOUNn+KAMz/CU97wKS6+evOoS9IYMm8kDZOZI2mQzhqsJCuAtwFHAwcDz0ty8IxhRwMH9v5OAd7RVT1ami6+ejMvvehaNm/bTgGbt23npRdda5OlRTFvJA2TmSNpLl2ewToc2FhV11XVrcCFwLEzxhwLvKcalwOrkjy4w5q0xJyzdgPbb7v9LvO233Y756zdMKKKNKbMG0nDZOZIGqjLBmsNcH3f9KbevMWOIckpSdYlWbd169bWC9XobNm2fVHzpQFayxswcyTNy30cSQN12WBllnm1E2OoqvOqaqqqplavXt1KcVoa9lm1clHzpQFayxswcyTNy30cSQN12WBtAvbrm94X2LITYzTBTj/yIFbuvuIu81buvoLTjzxoRBVpTJk3kobJzJE0UJcN1pXAgUkOSLIH8FzgkhljLgFO6H3TzhOBH1TVv3dYk5aY4w5dw1nHP5o1q1YSYM2qlZx1/KM57tBZr9ySBjFvJA2TmSNpoN26WnFV7UhyGrAWWAGcX1Xrk5zaW34ucClwDLAR+AlwUlf1aOk67tA1NlTaJeaNpGEycyTNpbMGC6CqLqUJmP555/Y9LuAPuqxB0vJg3kgaJjNH0iCd/tCwJEmSJC0nNliSJEmS1BIbLEmSJElqiQ2WJEmSJLUkzT2Y4yPJVuDbCxy+N3Bjh+W0yVq7Ya3dWEytD62qsf31zEVkzqS+f6Nmrd2Y1FqXS97A5L6Ho2at3ZjUWmfNnLFrsBYjybqqmhp1HQthrd2w1m6MU63DMk6vibV2w1q7MU61DtM4vS7W2g1r7UYbtXqJoCRJkiS1xAZLkiRJkloy6Q3WeaMuYBGstRvW2o1xqnVYxuk1sdZuWGs3xqnWYRqn18Vau2Gt3djlWif6HixJkiRJGqZJP4MlSZIkSUNjgyVJkiRJLZmIBivJUUk2JNmY5MxZlifJW3rLr0ly2Cjq7NUyX60v6NV4TZLLkjxmFHX2apmz1r5xj09ye5LnDLO+GTXMW2uSI5J8Icn6JJ8Zdo19dcz3/8B9k3w4yRd7tZ40ojrPT3JDki8NWL5kPlfDZN50w7zpxrjkTa8WM2cG86Yb5k03zJs+VTXWf8AK4BvAw4A9gC8CB88YcwzwUSDAE4ErlnCtTwbu13t89FKutW/cp4BLgecs1VqBVcCXgYf0ph+4hGt9GXB27/Fq4CZgjxHU+h+Bw4AvDVi+JD5XS/D9WxKvi3kz0tfVvNm5es2cxb9/S+I1MW9G+rqaNztXb6d5MwlnsA4HNlbVdVV1K3AhcOyMMccC76nG5cCqJA8edqEsoNaquqyqbu5NXg7sO+Qapy3kdQX4Q+CDwA3DLG6GhdT6fOCiqvoOQFWNqt6F1FrAXkkC7EkTQDuGWyZU1Wd72x5kqXyuhsm86YZ5042xyRswc2Zh3nTDvOmGedNnEhqsNcD1fdObevMWO2YYFlvHyTTd8yjMW2uSNcCzgXOHWNdsFvK6PgK4X5JPJ7kqyQlDq+6uFlLrW4FHAluAa4E/qqo7hlPeoiyVz9UwmTfdMG+6MUl5A0vnszUs5k03zJtumDd9dmu9nOHLLPNmfvf8QsYMw4LrSPI0mgB6aqcVDbaQWt8EnFFVtzcHI0ZmIbXuBjwOeAawEvhcksur6mtdFzfDQmo9EvgC8HTg4cAnkvxzVf2w49oWa6l8robJvOmGedONScobWDqfrWExb7ph3nTDvOkzCQ3WJmC/vul9aTrjxY4ZhgXVkeQQ4J3A0VX1/SHVNtNCap0CLuyFz97AMUl2VNXFQ6nw5xb6/8CNVfVj4MdJPgs8Bhh2AC2k1pOAN1RzEfDGJN8Efgn4/HBKXLCl8rkaJvOmG+ZNNyYpb2DpfLaGxbzphnnTDfOm32Ju2FqKfzRN4nXAAfz8prpHzRjzLO56o9rnl3CtDwE2Ak9e6q/rjPEXMLqbQBfyuj4S+GRv7L2BLwG/vERrfQfwqt7jBwGbgb1H9Nruz+AbQJfE52oJvn9L4nUxb0b6upo3O1+zmbO4929JvCbmzUhfV/Nm52vuLG/G/gxWVe1IchqwluYbTM6vqvVJTu0tP5fmG2COoflg/4Smg16qtb4CeADw9t6Rkx1VNbVEa10SFlJrVX0lyceAa4A7gHdW1axfzTnqWoHXAhckuZbmg31GVd047FqTvB84Atg7ySbglcDufXUuic/VMJk3I611STBvumPm3JV5M9JalwTzpjtd5016XZokSZIkaRdNwrcISpIkSdKSYIMlSZIkSS2xwZIkSZKklthgSZIkSVJLbLAkSZIkqSU2WFoyknwsybYk/zjqWiRNriQPTXJVki8kufNrhCWpLYP2aZI8Pcm/JflSkncnGfufTNLd+TXtWjKSPIPmR/J+t6p+fdT1SJpMSfag+ffvZ0n2pPlhzidX1ZYRlyZpQsy2T5PkHsC3gWdU1deSvAb4dlW9a4SlqgOewdLQJXl8kmuS3CvJL/SOIP9yVX0SuGXU9UmaHLPlDfCIqvpZb8g98d9CSTtpkfs0DwB+VlVf601/AvjPQy1YQ+FpSQ1dVV2Z5BLgfwIrgfeO4lfHJU2+QXmTZD/gI8AvAqd79krSzljkPs2NwO5JpqpqHfAcYL8hlaohssHSqLwGuBL4KfCSEdciabLdLW+q6nrgkCT7ABcn+Yeq+t4Ia5Q0vha0T1NVleS5wF8muSfwcWDHcErUMHlZhEbl/sCewF7AvUZci6TJNjBvemeu1gO/MoK6JE2GBe/TVNXnqupXqupw4LPA14dQn4bMBkujch7wZ8D7gLNHXIukyXaXvEmyb5KVAEnuBzwF2DDC+iSNtwXv0yR5YO+/9wTOAM7tvDoNnZcIauiSnADsqKq/S7ICuCzJ04FXA78E7JlkE3ByVa0dZa2SxttseQM8CjgnSQEB3lhV146yTknjaSf2aU5P8us0JzneUVWfGlnx6oxf0y5JkiRJLfESQUmSJElqiQ2WJEmSJLXEBkuSJEmSWmKDJUmSJEktscGSJEmSpJbYYEmSJElSS2ywJEmSJKkl/x8Yh3dLPr5++AAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 864x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "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, 11.73it/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 864x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "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, 30.31it/s]\n",
      "0it [00:00, ?it/s]\n",
      "100%|██████████| 14/14 [00:00<00:00, 15.62it/s]\n",
      "100%|██████████| 18/18 [00:01<00:00, 16.83it/s]\n",
      "0it [00:00, ?it/s]\n",
      "100%|██████████| 22/22 [00:01<00:00, 14.01it/s]\n",
      "100%|██████████| 26/26 [00:02<00:00, 12.71it/s]\n",
      "0it [00:00, ?it/s]\n",
      "100%|██████████| 30/30 [00:02<00:00, 12.80it/s]\n",
      "100%|██████████| 34/34 [00:02<00:00, 12.10it/s]\n",
      "0it [00:00, ?it/s]\n",
      "100%|██████████| 38/38 [00:02<00:00, 14.02it/s]\n",
      "100%|██████████| 8/8 [00:00<00:00, 12.98it/s]\n",
      "100%|██████████| 42/42 [00:03<00:00, 13.05it/s]\n",
      "0it [00:00, ?it/s]\n",
      "100%|██████████| 46/46 [00:04<00:00, 11.35it/s]\n",
      "100%|██████████| 50/50 [00:03<00:00, 12.81it/s]\n",
      "0it [00:00, ?it/s]\n",
      "100%|██████████| 8/8 [00:00<00:00, 15.83it/s]\n",
      "100%|██████████| 54/54 [00:04<00:00, 12.35it/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": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "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 864x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "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 288x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "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 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "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",
   "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.9.4"
  },
  "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
}