docs/tutorials/ensemble_modeling.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ensemble Modeling\n",
    "This notebook demonstrates how **MASSpy** can be used to generate an ensemble of models. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:23:09.862059Z",
     "iopub.status.busy": "2020-10-20T20:23:09.860987Z",
     "iopub.status.idle": "2020-10-20T20:23:12.293823Z",
     "shell.execute_reply": "2020-10-20T20:23:12.294309Z"
    }
   },
   "outputs": [],
   "source": [
    "# Disable gurobi logging output for this notebook.\n",
    "try:\n",
    "    import gurobipy\n",
    "    gurobipy.setParam(\"OutputFlag\", 0)\n",
    "except ImportError:\n",
    "    pass\n",
    "\n",
    "import logging\n",
    "logging.getLogger(\"\").setLevel(\"CRITICAL\")\n",
    "\n",
    "# Configure roadrunner to allow for more output rows\n",
    "import roadrunner\n",
    "roadrunner.Config.setValue(\n",
    "    roadrunner.Config.MAX_OUTPUT_ROWS, 1e6)\n",
    "\n",
    "from mass import MassConfiguration, Simulation\n",
    "from mass.test import create_test_model\n",
    "\n",
    "mass_config = MassConfiguration()\n",
    "mass_config.decimal_precision = 12 # Round 12 places after decimal\n",
    "\n",
    "# Load the model\n",
    "reference_model = create_test_model(\"Glycolysis\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generating Data for Ensembles\n",
    "\n",
    "In addition to loading external sources of data for use (e.g., loading excel sheets), sampling can be used to get valid data for the generation of ensembles. As an example, a small set of samples are generated for use in this notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Utilizing [COBRApy flux sampling](https://cobrapy.readthedocs.io/en/latest/sampling.html#), the following flux samples are used in generating the ensemble of models. All steady state flux values are set to allow to deviation by up to 80% of their defined baseline values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:23:12.299023Z",
     "iopub.status.busy": "2020-10-20T20:23:12.298257Z",
     "iopub.status.idle": "2020-10-20T20:23:12.300432Z",
     "shell.execute_reply": "2020-10-20T20:23:12.300880Z"
    }
   },
   "outputs": [],
   "source": [
    "from cobra.sampling import sample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:23:12.309082Z",
     "iopub.status.busy": "2020-10-20T20:23:12.308394Z",
     "iopub.status.idle": "2020-10-20T20:23:12.508731Z",
     "shell.execute_reply": "2020-10-20T20:23:12.509193Z"
    }
   },
   "outputs": [],
   "source": [
    "flux_percent_deviation = 0.8\n",
    "for reaction in reference_model.reactions:\n",
    "    flux = reaction.steady_state_flux\n",
    "    reaction.bounds = sorted([\n",
    "        round(flux * (1 - flux_percent_deviation),\n",
    "              mass_config.decimal_precision),\n",
    "        round(flux * (1 + flux_percent_deviation),\n",
    "              mass_config.decimal_precision)])\n",
    "    \n",
    "flux_samples = sample(reference_model, n=10, seed=25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Utilizing [MASSpy concentration sampling](./thermo_concentrations.ipynb#Concentration-Sampling), the following concentration samples are used in generating the ensemble of models. All concentration values are set to allow deviation by up to 80% of their defined baseline values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:23:12.513606Z",
     "iopub.status.busy": "2020-10-20T20:23:12.512919Z",
     "iopub.status.idle": "2020-10-20T20:23:12.536251Z",
     "shell.execute_reply": "2020-10-20T20:23:12.537444Z"
    }
   },
   "outputs": [],
   "source": [
    "from mass.thermo import ConcSolver, sample_concentrations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:23:12.633327Z",
     "iopub.status.busy": "2020-10-20T20:23:12.588465Z",
     "iopub.status.idle": "2020-10-20T20:23:12.876459Z",
     "shell.execute_reply": "2020-10-20T20:23:12.876899Z"
    }
   },
   "outputs": [],
   "source": [
    "conc_solver = ConcSolver(\n",
    "    reference_model,\n",
    "    excluded_metabolites=[\"h_c\", \"h2o_c\"],\n",
    "    equilibrium_reactions=[\"ADK1\"],\n",
    "    constraint_buffer=1e-7)\n",
    "\n",
    "conc_solver.setup_sampling_problem(\n",
    "    conc_percent_deviation=0.8,\n",
    "    Keq_percent_deviation=0)\n",
    "\n",
    "conc_samples = sample_concentrations(conc_solver, n=10, seed=25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because there are 10 flux data sets and 10 concentration data sets being passed to the function, there are $10 * 10 = 100$ models generated in total."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating an Ensemble"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:23:12.880989Z",
     "iopub.status.busy": "2020-10-20T20:23:12.880357Z",
     "iopub.status.idle": "2020-10-20T20:23:12.883239Z",
     "shell.execute_reply": "2020-10-20T20:23:12.882757Z"
    }
   },
   "outputs": [],
   "source": [
    "from mass.simulation import ensemble, generate_ensemble_of_models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generating new models\n",
    "\n",
    "The `ensemble` submodule has two functions for creating models from `pandas.DataFrame` objects:\n",
    "\n",
    "* The `create_models_from_flux_data()` function creates an ensemble of models from a `DataFrame` containing flux data, where rows correspond to samples and columns correspond to reaction identifiers.\n",
    "* The `create_models_from_concentration_data()` function creates an ensemble of models from a `DataFrame` containing concentration data, where rows correspond to samples and columns correspond to metabolite identifiers.\n",
    "\n",
    "The functions can be used separately or together to generate models. In this example, an ensemble of 100 models is generated by utilizing both mode; generation methods. \n",
    "\n",
    "First, the 10 flux samples are used to generate 10 models with varying flux states from a single reference `MassModel`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:23:12.890096Z",
     "iopub.status.busy": "2020-10-20T20:23:12.889348Z",
     "iopub.status.idle": "2020-10-20T20:23:13.886027Z",
     "shell.execute_reply": "2020-10-20T20:23:13.886633Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flux_models = ensemble.create_models_from_flux_data(\n",
    "    reference_model, data=flux_samples)\n",
    "len(flux_models)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `list` of models are passed to the `create_models_from_concentration_data()` function along with the concentration samples to create models with varying concentration states. By treating each of the 10 models with varying flux states as a reference model in addition to providing 10 concentration samples, 100 total models are generated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:23:13.893073Z",
     "iopub.status.busy": "2020-10-20T20:23:13.892380Z",
     "iopub.status.idle": "2020-10-20T20:23:22.637412Z",
     "shell.execute_reply": "2020-10-20T20:23:22.637924Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conc_models = []\n",
    "for ref_model in flux_models:\n",
    "    conc_models += ensemble.create_models_from_concentration_data(\n",
    "        ref_model, data=conc_samples)\n",
    "len(conc_models)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generating models does not always ensure that the models are thermodynamically feasible. The `ensure_positive_percs()` function is used to calculate PERCs (pseudo-elementary rate constants) for all reactions provided to the `reactions` argument. Those that produce all positive PERCs are separated from those that produce at least one negative PERC, and two lists that contain the seperated models are returned.\n",
    "\n",
    "If the `update_values` argument is set to `True`, PERC values are updated for models that produce all positive PERCs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:23:22.666873Z",
     "iopub.status.busy": "2020-10-20T20:23:22.666250Z",
     "iopub.status.idle": "2020-10-20T20:23:45.066523Z",
     "shell.execute_reply": "2020-10-20T20:23:45.067076Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Models with positive PERCs: 100\n",
      "Models with negative PERCs: 0\n"
     ]
    }
   ],
   "source": [
    "# Exclude boundary reactions from PERC calculations for the example\n",
    "reactions_to_check_percs = [\n",
    "    r.id for r in reference_model.reactions\n",
    "    if r not in reference_model.boundary]\n",
    "\n",
    "positive, negative = ensemble.ensure_positive_percs(\n",
    "    models=conc_models, reactions=reactions_to_check_percs, \n",
    "    update_values=True)\n",
    "\n",
    "print(\"Models with positive PERCs: {0}\".format(len(positive)))\n",
    "print(\"Models with negative PERCs: {0}\".format(len(negative)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `ensure_steady_state()` function is used to ensure that models are able to reach a steady state. If `update_values=True`, models that reach a steady state are updated with the new steady state values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:23:45.128817Z",
     "iopub.status.busy": "2020-10-20T20:23:45.084041Z",
     "iopub.status.idle": "2020-10-20T20:24:28.345802Z",
     "shell.execute_reply": "2020-10-20T20:24:28.346203Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "mass/simulation/simulation.py:828 \u001b[1;31mUserWarning\u001b[0m: Unable to find a steady state for one or more models. Check the log for more details.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reached steady state: 90\n",
      "No steady state reached: 10\n"
     ]
    }
   ],
   "source": [
    "feasible, infeasible = ensemble.ensure_steady_state(\n",
    "    models=positive, strategy=\"simulate\",\n",
    "    update_values=True, decimal_precision=True)\n",
    "\n",
    "print(\"Reached steady state: {0}\".format(len(feasible)))\n",
    "print(\"No steady state reached: {0}\".format(len(infeasible)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `perturbations` argument of the `ensure_steady_state()` method is used to check that models are able to reach a steady state with a given perturbation. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:24:28.441726Z",
     "iopub.status.busy": "2020-10-20T20:24:28.394327Z",
     "iopub.status.idle": "2020-10-20T20:25:10.530193Z",
     "shell.execute_reply": "2020-10-20T20:25:10.529490Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "mass/simulation/simulation.py:828 \u001b[1;31mUserWarning\u001b[0m: Unable to find a steady state for one or more models. Check the log for more details.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reached steady state: 88\n",
      "No steady state reached: 2\n"
     ]
    }
   ],
   "source": [
    "feasible, infeasible = ensemble.ensure_steady_state(\n",
    "    models=feasible, strategy=\"simulate\",\n",
    "    perturbations={\"kf_ATPM\": \"kf_ATPM * 1.5\"},\n",
    "    update_values=False, decimal_precision=True)\n",
    "\n",
    "print(\"Reached steady state: {0}\".format(len(feasible)))\n",
    "print(\"No steady state reached: {0}\".format(len(infeasible)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All models returned as \"feasible\" are considered to be thermodynamically feasible and able to reach a steady state, even with the given disturbance."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simulating an Ensemble of Models\n",
    "\n",
    "Once an ensemble of models is generated, the `Simulation` object can be used to simulate the ensemble of models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:25:10.625413Z",
     "iopub.status.busy": "2020-10-20T20:25:10.578938Z",
     "iopub.status.idle": "2020-10-20T20:25:11.154410Z",
     "shell.execute_reply": "2020-10-20T20:25:11.154961Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully loaded MassModel 'Glycolysis' into RoadRunner.\n"
     ]
    }
   ],
   "source": [
    "sim = Simulation(reference_model, verbose=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Three criteria must be met to add additional models to an existing `Simulation` object:\n",
    "\n",
    "1. The model must have ODEs equivalent to those of the `Simulation.reference_model`.\n",
    "2. All models must have unique identifiers.\n",
    "3. Numerical values that are necessary for simulation must already be defined for a model.\n",
    "\n",
    "If the criteria are met, additional models can be loaded into the `Simulation` using the `add_models()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:25:11.270003Z",
     "iopub.status.busy": "2020-10-20T20:25:11.218653Z",
     "iopub.status.idle": "2020-10-20T20:25:42.235725Z",
     "shell.execute_reply": "2020-10-20T20:25:42.236236Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of models added: 88\n",
      "Number of models total: 89\n"
     ]
    }
   ],
   "source": [
    "sim.add_models(models=feasible)\n",
    "print(\"Number of models added: {0}\".format(len(feasible)))\n",
    "print(\"Number of models total: {0}\".format(len(sim.models)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `simulate()` method is used to simulate multiple models. By default, all loaded models are simulated, including the `reference_model`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:25:42.241262Z",
     "iopub.status.busy": "2020-10-20T20:25:42.240645Z",
     "iopub.status.idle": "2020-10-20T20:25:45.720515Z",
     "shell.execute_reply": "2020-10-20T20:25:45.720931Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ConcSols returned: 89\n",
      "FluxSols returned: 89\n"
     ]
    }
   ],
   "source": [
    "conc_sol_list, flux_sol_list = sim.simulate(time=(0, 1000))\n",
    "print(\"ConcSols returned: {0}\".format(len(conc_sol_list)))\n",
    "print(\"FluxSols returned: {0}\".format(len(flux_sol_list)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To simulate a subset of the models, a list of models or their identifiers can be provided to the `simulate()` method. For example, to simulate the subset of models with identical concentration states but different flux states:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:25:45.726248Z",
     "iopub.status.busy": "2020-10-20T20:25:45.725654Z",
     "iopub.status.idle": "2020-10-20T20:25:45.998122Z",
     "shell.execute_reply": "2020-10-20T20:25:45.998607Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ConcSols returned: 7\n",
      "FluxSols returned: 7\n"
     ]
    }
   ],
   "source": [
    "model_subset = [model for model in sim.models if model.endswith(\"_C0\")]\n",
    "conc_sol_list, flux_sol_list = sim.simulate(\n",
    "    models=model_subset, time=(0, 1000))\n",
    "print(\"ConcSols returned: {0}\".format(len(conc_sol_list)))\n",
    "print(\"FluxSols returned: {0}\".format(len(flux_sol_list)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar to the `simulate()` method, the `find_steady_state()` method can be used to determine a steady state for each model in an ensemble or subset of models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:25:46.003535Z",
     "iopub.status.busy": "2020-10-20T20:25:46.002847Z",
     "iopub.status.idle": "2020-10-20T20:25:46.283455Z",
     "shell.execute_reply": "2020-10-20T20:25:46.282977Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ConcSols returned: 7\n",
      "FluxSols returned: 7\n"
     ]
    }
   ],
   "source": [
    "conc_sol_list, flux_sol_list = sim.find_steady_state(\n",
    "    models=model_subset, strategy=\"simulate\")\n",
    "print(\"ConcSols returned: {0}\".format(len(conc_sol_list)))\n",
    "print(\"FluxSols returned: {0}\".format(len(flux_sol_list)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If an exception occurs for a model during steady state determination or simulation (e.g., no steady state exists), the MassSolution objects that correspond to the failed model will return empty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:25:46.375229Z",
     "iopub.status.busy": "2020-10-20T20:25:46.331991Z",
     "iopub.status.idle": "2020-10-20T20:25:48.069904Z",
     "shell.execute_reply": "2020-10-20T20:25:48.070443Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ConcSols returned: 2\n",
      "FluxSols returned: 2\n",
      "Solutions for Glycolysis: True\n",
      "Solutions for Glycolysis_F0_C0: False\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "mass/simulation/simulation.py:828 \u001b[1;31mUserWarning\u001b[0m: Unable to find a steady state for one or more models. Check the log for more details.\n"
     ]
    }
   ],
   "source": [
    "# Create a simulation with the reference model and an infeasible one \n",
    "infeasible_sim = Simulation(reference_model)\n",
    "infeasible_sim.add_models(infeasible[0])\n",
    "\n",
    "conc_sol_list, flux_sol_list = infeasible_sim.find_steady_state(\n",
    "    strategy=\"simulate\", perturbations={\"kf_ATPM\": \"kf_ATPM * 1.5\"})\n",
    "\n",
    "print(\"ConcSols returned: {0}\".format(len(conc_sol_list)))\n",
    "print(\"FluxSols returned: {0}\".format(len(flux_sol_list)))\n",
    "\n",
    "for model, sol in zip(sim.models, conc_sol_list):\n",
    "    print(\"Solutions for {0}: {1}\".format(str(model), bool(sol)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualizing Ensemble Results\n",
    "\n",
    "Through visualization features of **MASSPy**, the results of simulating the ensemble can be visualized using the `plot_ensemble_time_profile()` and `plot_ensemble_phase_portrait()` functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:25:48.075756Z",
     "iopub.status.busy": "2020-10-20T20:25:48.073615Z",
     "iopub.status.idle": "2020-10-20T20:25:48.078109Z",
     "shell.execute_reply": "2020-10-20T20:25:48.078875Z"
    }
   },
   "outputs": [],
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "from mass.visualization import (\n",
    "    plot_ensemble_phase_portrait, plot_ensemble_time_profile)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list of `MassSolution` objects is required to use an ensemble visualization function. The output of `simulate()` method for an ensemble of models can be placed into the functions directly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:25:48.126878Z",
     "iopub.status.busy": "2020-10-20T20:25:48.082342Z",
     "iopub.status.idle": "2020-10-20T20:32:14.130605Z",
     "shell.execute_reply": "2020-10-20T20:32:14.131058Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully loaded MassModel 'Glycolysis' into RoadRunner.\n"
     ]
    }
   ],
   "source": [
    "sim = Simulation(reference_model, verbose=True)\n",
    "sim.add_models(models=feasible)\n",
    "\n",
    "conc_sol_list, flux_sol_list = sim.simulate(\n",
    "    models=feasible, time=(0, 1000),\n",
    "    perturbations={\"kf_ATPM\": \"kf_ATPM * 1.5\"},\n",
    "    decimal_precision=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `plot_ensemble_time_profile()` function works in a manner similar to the `plot_time_profile()` function described in [Time Profiles](./plot_visualization.ipynb#Time-Profiles). The minimal input required is a list of `MassSolution` objects and an iterable that contains strings or objects with identifiers that correspond to keys of the `MassSolution`. The plotted solution lines represent the average (mean) solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:32:14.149448Z",
     "iopub.status.busy": "2020-10-20T20:32:14.148804Z",
     "iopub.status.idle": "2020-10-20T20:32:21.679753Z",
     "shell.execute_reply": "2020-10-20T20:32:21.679256Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fad769df110>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "plot_ensemble_time_profile(\n",
    "    conc_sol_list, observable=reference_model.metabolites,\n",
    "    interval_type=None,\n",
    "    legend=\"right outside\", plot_function=\"semilogx\",\n",
    "    xlabel=\"Time (hrs)\", ylabel=\"Concentrations (mM)\",\n",
    "    title=\"Mean Concentrations (N={0})\".format(len(conc_sol_list)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because the plotted lines are the mean solution values over time for the ensemble, there is some uncertainty associated with the solutions. The `interval_type` argument can be specified to plot the results with a confidence interval. For example, to plot the mean PYK flux with a 95% confidence interval:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:32:21.699071Z",
     "iopub.status.busy": "2020-10-20T20:32:21.698408Z",
     "iopub.status.idle": "2020-10-20T20:32:22.376791Z",
     "shell.execute_reply": "2020-10-20T20:32:22.377252Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fad74fe0090>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "plot_ensemble_time_profile(\n",
    "    flux_sol_list, observable=[\"PYK\"], legend=\"best\", \n",
    "    interval_type=\"CI=95\", # Shading for 95% confidence\n",
    "    plot_function=\"semilogx\", xlabel=\"Time (hrs)\",\n",
    "    ylabel=\"Flux (mM/hr)\",\n",
    "    title=\"Mean PYK Flux (N={0})\".format(len(flux_sol_list)),\n",
    "    color=\"red\", mean_line_alpha=1,  # Default opacity of mean line\n",
    "    interval_fill_alpha=0.5,   # Default opacity for interval shading\n",
    "    interval_border_alpha=0.5)  # Default opacity of border lines\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Setting  `interval_type=\"range\"` causes shading between the minimum and maximum solution values. The `mean_line_alpha`, `interval_fill_alpha`, and `interval_border_alpha` kwargs are used to control the opacity of the mean solution, interval borders, and interval shading, respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:32:22.395007Z",
     "iopub.status.busy": "2020-10-20T20:32:22.394193Z",
     "iopub.status.idle": "2020-10-20T20:32:23.037929Z",
     "shell.execute_reply": "2020-10-20T20:32:23.038400Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fad763df710>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "plot_ensemble_time_profile(\n",
    "    flux_sol_list, observable=[\"PYK\"],\n",
    "    interval_type=\"range\", # Shading from min to max value\n",
    "    legend=\"best\", plot_function=\"semilogx\",\n",
    "    xlabel=\"Time (hrs)\", ylabel=\"Flux (mM/hr)\",\n",
    "    title=\"Mean PYK Flux (N={0})\".format(len(flux_sol_list)),\n",
    "    color=\"red\", mean_line_alpha=0.6,  # For opacity of mean line\n",
    "    interval_fill_alpha=0.3, # For lighter interval shading\n",
    "    interval_border_alpha=1  # For darker border lines\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Relative deviations are plotted using the `deviation` kwarg. The `deviation_zero_centered` kwarg is used to shift the results to deviate from 0., and the `deviation_normalization` kwarg is used to normalize each solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:32:23.071542Z",
     "iopub.status.busy": "2020-10-20T20:32:23.070690Z",
     "iopub.status.idle": "2020-10-20T20:32:31.679241Z",
     "shell.execute_reply": "2020-10-20T20:32:31.679768Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, (ax1, ax2) = plt.subplots(nrows=2, ncols=1, figsize=(12, 8))\n",
    "\n",
    "# Plot all relative flux deviations\n",
    "plot_ensemble_time_profile(\n",
    "    flux_sol_list, observable=reference_model.reactions,\n",
    "    interval_type=None, ax=ax1, legend=\"right outside\",\n",
    "    plot_function=\"semilogx\", xlabel=\"Time (hrs)\",\n",
    "    ylabel=(\"Relative Deviation\\n\" +\\\n",
    "            r\"($\\frac{v - v_{0}}{v_{max} - v_{min}}$)\"),\n",
    "    title=\"Mean Flux Deviations (N={0})\".format(len(flux_sol_list)),\n",
    "    deviation=True,\n",
    "    deviation_zero_centered=True,  # Center around 0\n",
    "    deviation_normalization=\"range\")  # Normalized by value range\n",
    "\n",
    "# Plot PYK relative flux deviations\n",
    "plot_ensemble_time_profile(\n",
    "    flux_sol_list, observable=[\"PYK\"],\n",
    "    interval_type=\"CI=99\",  # 99% confidence interval\n",
    "    ax=ax2, legend=\"lower right\",\n",
    "    plot_function=\"semilogx\", xlabel=\"Time (hrs)\",\n",
    "    ylabel=(\"Relative Deviation\\n\" +\\\n",
    "            r\"($\\frac{v - v_{0}}{v_{0}}$)\"),\n",
    "    title=\"Average PYK Flux Deviation (N={0})\".format(\n",
    "        len(flux_sol_list)),\n",
    "    color=\"red\", deviation=True,\n",
    "    deviation_zero_centered=True,  # Center around 0\n",
    "    deviation_normalization=\"initial value\")  # Normalized by init. value\n",
    "\n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `plot_ensemble_phase_portrait()` function works in a manner similar to the `plot_phase_portrait()` function described in [Phase Portraits](./plot_visualization.ipynb#Phase-Portraits). The `plot_ensemble_phase_portrait()` function plots the mean solutions for the two ensemble simulation results against each other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:32:31.699472Z",
     "iopub.status.busy": "2020-10-20T20:32:31.698820Z",
     "iopub.status.idle": "2020-10-20T20:32:32.620464Z",
     "shell.execute_reply": "2020-10-20T20:32:32.620917Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fad76b303d0>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAb4AAAE/CAYAAAA5YaaUAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3xUZb7H8c8vjRA6IbRAElQQkGqiiCDFAti7sHpVvLpYr3p1XV332rCsrnd1lbXA2vciqNh1QRARwYIC0rtAlNBCQgk1ZZ77x5nggAmZJJNMkvm+X695Zeac55zndxLIL885TzHnHCIiIpEiKtwBiIiIVCclPhERiShKfCIiElGU+EREJKIo8YmISERR4hMRkYiixCciIhFFiU9KZGZfmtl2M6vn//yime32v/LNrCDg82QzSzMzF7BtvZndE3A+Z2ZbzSwmYFusf1u1DyY1szPMbIaZ5ZlZjpktMLO7zSz+sHIj/bEPP2z7IDPz+a81z8xWmtk1/n2Hfy+2mNknZnZGdV6jiJRMiU9+w8zSgFMAB5wH4Jy7wTnX0DnXEHgMeKv4s3PuzIDDm/rL/A6438yGBezbDgSWPdO/rVqZ2aXAJOBNINU5lwgMB9oB7Q8rfjWQC1xVwqk2+q+1MXA38E8z6xqwv/h70ROYBrxvZiNDeS0iUn5KfFKSq4DvgNfwfvGXm3PuW2Ap0C1g8784NIFcBbxR2jn8LbBJh217xsye9b8faWZr/S2udWZ2RVlxmZkBTwGjnXP/dM7l+uNd6Zz7L+fc6oCyqcBAYBQw1Mxal3Ktzjn3AV4S71rC/s3OuWeAB4EnzEz/70TCSP8BpSRXAeP9r6Fm1qo8B5unH3Ac8GPArg+AAWbW1Mya4bUqPzzCqSYCZ5lZI/95o4HLgDfNrAHwLHCmc64RcDKwIIjwjsVr2b0bRNmrgLnOuXeB5UCJidXMoszsQqApsPgI53sPaOmPQUTCRIlPDmFm/YFU4G3n3DzgJ+DycpxiG96twZeAe5xz0wP27Qc+xrutOBz4yL+tRM65TGA+cKF/06nAXufcd/7PPqCbmdV3zm1yzi0NIr4W/q+bizeY2UQz22Fme83syoCyV+HdDsX/9fDbnW3NbIf/mh8ArnTOrTxC3Rv9X5sHEaeIVBElPjnc1cBU59w2/+c3Kd/tzhbOuWbOuS7OuWdL2P8GXgI54m3OAG/iPS8ELwG/CeCc24OXPG8ANpnZp2bWOYjz5fi/tine4Jwb4ZxripdkowH8LdYOeK3O4ji6m1mvgHNtdM41dc41d871cs5N5MiS/V9zg4hTRKqIEp8cZGb18W4lDjSzzWa2GfhvoKeZ9QxRNbPwkk4rYHYQ5d8BBplZO7yWX3ELDOfcZ865M/znWwH8M4jzrQSygIvKKHc1YMAC//dhTsD2iroQ2OqPQUTCJKbsIhJBLgCKgO5AfsD2t/FaaHdWtgLnnDOzcwPel1U+28y+BF4F1jnnlgP4nzueBHwO7AN24936LOt8PjO7E68H5i683p07gGPwkjH+IQ2X4XVq+TTg8IvxeqreFfQF/xrrpXi3Q29zzpUZp4hUHbX4JNDVwKvOuZ/9PRE3O+c2A/8Arggcg1cZzrmlQT6PK/YmcDoBrT28f7t34D03y8XrfXkjgJmdYma7j1D/W3iJ7T+AX/Ce0b0NjMNrYV6Al0zfOOz78AreH4vDSjzxb+0wsz14HV7OAi51zr0S5LEiUkVMC9GKiEgkUYtPREQiSpmJz8zizex7M1toZkvN7KESyow0s2z/tE8LzOy6gH1Xm9lq/6syHQNEREQqrcxbnf6ZLho453abWSxeT7zbAsZS4Z+GKcM5d8thxzYH5gIZeNNfzQPSnXPVPk2ViIgIBNHi80/HVNxRINb/CvbB4FBgmnMu15/sphF8xwAREZGQC+oZn5lFm9kCvDFI05xzc0oodrGZLTKzSWZWPNFvMl6vuWIb+HUQr4iISLULqnu6c64I6GVmTfFmmO/mnFsSUORjYIJz7oCZXQ+8jje9VNDMbBTeuCkaNGiQ3rlzMJNwiIgEb968educc0nhjkPCq1zjspxzO8xsBt7tyiUB23MCir0E/NX/PgsYFLCvHfBlKecehzeOioyMDDd37tzyhCYiUiYzywx3DBJ+wfTqTPK39IqntDoDb3qowDJtAj6ehzeTPcBnwBAza+afjX+If5uIiEhYBNPiawO87l8SJgpv1v5PzGw03pItHwG3mtl5QCHeLBojAZxzuWb2MPCD/1yji9c/ExERCYcaOXOLbnWKSFUws3nOuYxwxyHhpUmqRUpRUFDAhg0b2L+/1CUDpYaKj4+nXbt2xMbGhjsUqYGU+ERKsWHDBho1akRaWhplrSIhNYdzjpycHDZs2ECHDh3CHY7UQJqrU6QU+/fvJzExUUmvljEzEhMT1VKXUinxiRyBkl7tpJ+bHIkSn0gN98EHH2BmrFjhjSLq06cPvXr1IiUlhaSkJHr16kWvXr1Yv349aWlpdO/enR49ejBkyBA2b94MQFpaGqeccsoh5+3VqxfdunWr0tifeuopOnfuTPfu3enZsyd33HEHBQUFB/cvWLAAM2PKlCmHHBcdHX0wvksvvZS9e/cesv24446jZ8+e/O1vf8Pn07q+Uj5KfCI13IQJE+jfvz8TJkwAYM6cOSxYsIDRo0czfPhwFixYwIIFC0hLSwNgxowZLFq0iIyMDB577LGD58nLy+OXX7wZBJcvX/6bekLtxRdfZOrUqXz33XcsXryYH374gZYtW7Jv375Sr61Y/fr1WbBgAUuWLCEuLo4XX3zxkO1Lly5l2rRpTJ48mYce+s2CMSJHpMQnUoPt3r2b2bNn8/LLLzNx4sRyHTtgwADWrFlz8PNll13GW2+9BXgJ53e/+12Jx40YMYJPP/304OeRI0cyadIkli5dyoknnkivXr3o0aMHq1evPmL9jz76KC+88AJNmzYFIC4ujnvuuYfGjRsDXieUd955h9dee41p06aV+kzulFNOOeQ6irVs2ZJx48bxj3/8g5o4LEtqLiU+kRrsww8/ZNiwYXTq1InExETmzZsX9LGffPIJ3bt3P/j54osv5r333gPg448/5txzzy3xuOHDh/P2228DkJ+fz/Tp0zn77LN58cUXue2221iwYAFz586lXbt2pda9a9cudu/efcReld988w0dOnTg6KOPZtCgQYck22KFhYVMnjz5kOsIdNRRR1FUVMTWrVtLrUfkcBrOIBKMebfD9gWhPWezXpD+9yMWmTBhArfddhvgtcQmTJhAenr6EY8ZPHgw0dHR9OjRg0ceeeTg9sTERJo1a8bEiRPp0qULCQkJJR5/5plnctttt3HgwAGmTJnCgAEDqF+/Pn379uXRRx9lw4YNXHTRRXTs2DHoS/3ss8+4++672bFjB2+++SYnn3wyEyZMYMSIEQev7Y033uDiiy8GYN++ffTq1QvwWnzXXntt0HWJlEWJT6SGys3N5YsvvmDx4sWYGUVFRZgZTz755BF7Lc6YMYMWLVqUuG/48OHcfPPNvPbaa6UeHx8fz6BBg/jss8946623Dianyy+/nD59+vDpp59y1llnMXbsWE49teRFWBo3bkzDhg1Zt24dHTp0YOjQoQwdOpRzzjmH/Px8ioqKePfdd/nwww959NFHD469y8vLo1GjRgef5ZVl7dq1REdH07JlyzLLihRT4hMJRhkts6owadIkrrzySsaOHXtw28CBA5k1axYDBgyo0DkvvPBCNm3axNChQ9m4cWOp5YYPH85LL73E3LlzDybJtWvXctRRR3Hrrbfy888/s2jRolITH8Cf/vQnbrzxRiZOnEjTpk1xzh18jjd9+nR69OjBZ5/9Omf91Vdfzfvvv89VV10V1LVkZ2dzww03cMstt2j4gpSLnvGJ1FATJkzgwgsvPGTbxRdf/JsekOXRqFEj7r77buLi4o5YbsiQIcycOZPTTz/9YNm3336bbt260atXL5YsWXIwQZ111lklJtEbb7yR0047jT59+tCjRw/69etH79696d27d4WvrfgW6HHHHcfpp5/OkCFDeOCBB8rzLRDRJNUipVm+fDldunQJdxhSQSX9/DRJtYBafCIiEmGU+EREJKIo8YmISERR4hM5gpr4DFzKpp+bHIkSn0gp4uPjycnJ0S/RWqZ4TGB8fHy4Q5EaSuP4RErRrl07NmzYQHZ2drhDkXIqXoFdpCRKfCKliI2N1QreInWQbnWKiEhEUeITEZGIUmbiM7N4M/vezBaa2VIz+82qj2Z2h5ktM7NFZjbdzFID9hWZ2QL/66NQX4CIiEh5BPOM7wBwqnNut5nFArPNbLJz7ruAMj8CGc65vWZ2I/BXYLh/3z7nXK/Qhi0iIlIxZbb4nGe3/2Os/+UOKzPDObfX//E7QN2pRESkRgrqGZ+ZRZvZAmArMM05N+cIxa8FJgd8jjezuWb2nZldUIlYRUREKi2o4QzOuSKgl5k1Bd43s27OuSWHlzOz/wAygIEBm1Odc1lmdhTwhZktds79VMKxo4BRACkpKRW4FBERkbKVq1enc24HMAMYdvg+Mzsd+DNwnnPuQMAxWf6va4Evgd6lnHuccy7DOZeRlJRUnrBERESCFkyvziR/Sw8zqw+cAaw4rExvYCxe0tsasL2ZmdXzv28B9AOWhS58ERGR8gnmVmcb4HUzi8ZLlG875z4xs9HAXOfcR8CTQEPgHTMD+Nk5dx7QBRhrZj7/sY8755T4REQkbMpMfM65RZRwe9I5d3/A+9NLOfYboHtlAhQREQklzdwiIiIRRYlPREQiihKfiIhEFCU+ERGJKEp8IiISUZT4REQkoijxiYhIRFHiExGRiKLEJyIiEUWJT0REIooSn4iIRBQlPhERiShKfCIiElGU+EREJKIo8YmISERR4hMRkYiixCciIhFFiU9ERCKKEp+IiEQUJT4REYkoSnwiIhJRlPhERCSilJn4zCzezL43s4VmttTMHiqhTD0ze8vM1pjZHDNLC9j3J//2lWY2NLThi4iIlE8wLb4DwKnOuZ5AL2CYmZ10WJlrge3OuWOAp4EnAMysKzACOA4YBjxvZtGhCl5ERKS8ykx8zrPb/zHW/3KHFTsfeN3/fhJwmpmZf/tE59wB59w6YA1wYkgiFxERqYCgnvGZWbSZLQC2AtOcc3MOK5IM/ALgnCsEdgKJgdv9Nvi3iYiIhEVQic85V+Sc6wW0A040s26hDsTMRpnZXDObm52dHerTi4iIAOXs1emc2wHMwHteFygLaA9gZjFAEyAncLtfO/+2ks49zjmX4ZzLSEpKKk9YIiIiQQumV2eSmTX1v68PnAGsOKzYR8DV/veXAF8455x/+wh/r88OQEfg+1AFLyIiUl4xQZRpA7zu740ZBbztnPvEzEYDc51zHwEvA/8yszVALl5PTpxzS83sbWAZUAjc7JwrqooLERERCYZ5DbOaJSMjw82dOzfcYYhIHWNm85xzGeGOQ8JLM7eIiEhEUeITEZGIosQnIiIRRYlPREQiihKfiIhEFCU+ERGJKEp8IiISUZT4REQkoijxiYhIRFHiExGRiKLEJyIiEUWJT0REIooSn4iIRBQlPhERiShKfCIiElGU+EREJKIo8YmISERR4hMRkYiixCciIhFFiU9ERCKKEp+IiEQUJT4REYkoMWUVMLP2wBtAK8AB45xzzxxW5i7gioBzdgGSnHO5ZrYeyAOKgELnXEbowhcRESmfMhMfUAjc6Zybb2aNgHlmNs05t6y4gHPuSeBJADM7F/hv51xuwDkGO+e2hTJwERGRiijzVqdzbpNzbr7/fR6wHEg+wiG/AyaEJjwREZHQKtczPjNLA3oDc0rZnwAMA94N2OyAqWY2z8xGVSxMERGR0AjmVicAZtYQL6Hd7pzbVUqxc4GvD7vN2d85l2VmLYFpZrbCOfdVCecfBYwCSElJCfoCREREyiOoFp+ZxeIlvfHOufeOUHQEh93mdM5l+b9uBd4HTizpQOfcOOdchnMuIykpKZiwREREyq3MxGdmBrwMLHfOPXWEck2AgcCHAdsa+DvEYGYNgCHAksoGLSIiUlHB3OrsB1wJLDazBf5t9wIpAM65F/3bLgSmOuf2BBzbCnjfy53EAG8656aEInAREZGKKDPxOedmAxZEudeA1w7bthboWcHYREQEmDdvXsuYmJiXgG5o4pGy+IAlhYWF16Wnp28tqUDQnVtERCQ8YmJiXmrdunWXpKSk7VFRUS7c8dRkPp/PsrOzu27evPkl4LySyugvBxGRmq9bUlLSLiW9skVFRbmkpKSdeK3jkstUYzwiIlIxUUp6wfN/r0rNb0p8IiJSpm3btkU//vjjQY81W7FiRVyPHj06p6SkdDv77LOP2r9/f5l9RaqLEp+ISB3zc+7e5jNWbus+ZWl2+oyV27r/nLu3eWXPmZOTE/3yyy+3DLb8HXfc0e6WW27Z8vPPPy9p0qRJ4TPPPNOisjGEihKfiEgd8nPu3uYrNu9JPVDo4gAOFLq4FZv3pFY2+d15553tfvnll3qdO3fuev3117c7Ulmfz8e3337b6JprrtkO8J//+Z85H3/8cdPK1B9K6tUpIlKH/JS9N9nnDm3U+BxRP2XvTU5pnpBb2nFl+dvf/rbhnHPOqb9ixYpl27dvj+rcuXPXksqNHz9+bdu2bQsbNWpUFBsbC0BaWlr+li1b4ipad6gp8YmI1CHFLb1gt1dEs2bNfCtWrFhW2v5NmzbV6NxSo4MTEZHyqRdj+SUluXoxlh+qOrZv3x7Vt2/fziXtGz9+/NrevXvvz8vLiy4oKCA2Npb169fHtWrVKmT1V5YSn0QuXxFsmQ6bpkLOHNibBdH1oEVf6HYfNOwQ7ghFyu3opISsFZv3pAbe7owyfEcnJWRV5rxNmjQp2rNnTxSU3eIDOOmkk/JeffXVZqNGjdr+yiuvJJ5zzjk7KlN/KKlzi0SePb/Awv+BD1NhxlBYNQZwXsJr3Bky34KpfWHfpnBHKlJuKc0Tcju3bpBZ3MKrF2P5nVs3yKzM8z2A1q1bF6Wnp+/u2LHjcWV1bgHvmeCYMWNap6SkdNu+fXvMbbfdtq0y9YeSWnwSOfb8DEv/AmtfBlcEbYZB+jPQ9iyIqf9ruR1LYHIvWP0C9BgdvnhFKiileUJuZRNdST7++ON1wZbt2rVr/uLFi5eHOoZQUOKTui9/Oyx6ANb4FxI56lo47h5okFpy+abdoElX2L6g5P0iUqsp8Und5SvyWncL7/WS39HXwXH/Aw3al32sc2DRVR+jiFQ7JT6pm7YvgDnXQe48aDkA0p+FZkGukFV0APJWQ5uhVRujiISFEp/ULUX5sPQR71levUQ4eQKkDgcrxzSB2bPAdwCS+lddnCISNkp8UnfkzoNvR8LOJZB2JaT/HepVYJam9W9CTEO1+ETqKCU+qf2cD5Y/6Q1RiG8JAz+G5HMqdq792yBzAnS4+tCeniJSZ2gcn9Rue7PgizNgwT3Q7gI4e0nFkx7AyqehaD8ce2voYhSpA6piWaLNmzdH9+nTp1NCQkLvq666KiW0EZdOiU9qrw0fweSesO076PMS9H8b4ppV/Hz7NsPKZyB1hDecQaSW+jZze/OHP1/T/Y+frkx/+PM13b/N3F4jlyVKSEhwo0eP3vjggw9uqGx85aHEJ7WPrxB+vBu+Oh8SUuDM+XD0teXrwFKS+XeCrwC6PxSaOEXC4NvM7c0/XpadmnegKA4g70BR3MfLslMrm/yqYlmixo0b+4YOHbo7Pj7eV5nYykvP+KR22bcZvv4dbP0Sjrne68ASHV/5826aBplvQrf7oXGnyp9PJEw+X52TXOhzhzRqCn0u6vPVOcl9U5tpWSKCSHxm1h54A2gFOGCcc+6Zw8oMAj4Eiqezec85N9q/bxjwDBANvOScezxk0Utk2Tobvr4M8nfASa/DUVeF5rxF++GHm6DhMXDcn0JzTpEwKW7pBbu9IiJhWaJC4E7n3HwzawTMM7NpzrnDL3qWc+6QXgVmFg08B5wBbAB+MLOPSjhW5MhWvwhz/wsapMHQz6Bp99Cde/GDsHsNnDotNK1HkTBqVC86v6Qk16hetJYl8isz8TnnNgGb/O/zzGw5kAwEk7xOBNY459YCmNlE4PwgjxXxnrnNux1WP+9NJn3ymxDXJHTn3zwdlv3Ve0bY+vTQnVckTE7vmJj18bLs1MDbnTFR5ju9Y6KWJfIrV+cWM0sDegNzStjd18wWmtlkMzvOvy0Z+CWgzAb/NpGyHcjxlg1a/Tx0uQsGfBTapLc/G769Ehof663SIFIH9E1tlntu16TM4hZeo3rR+ed2TcqszPM9CN2yROPHj29y++23ty0ul5yc3P2+++5rP2nSpMRWrVr1mDdvXpXfdgn6PqyZNQTeBW53zu06bPd8INU5t9vMzgI+ADqWJxAzGwWMAkhJqbbhHFJT7VwGM8+FvRtC+zyvmPPBdyPhQC4MmgIxDUJ7fpEw6pvaLLeyia4koViW6Iorrth5xRVX7Cz+nJWVtThU8QUrqBafmcXiJb3xzrn3Dt/vnNvlnNvtf/9vINbMWgBZQOBU+O38237DOTfOOZfhnMtISgp6jKTURVu+hKknQ+EeOH1m6JMewPK/wcZ/w/F/g2Y9Qn9+Eamxykx8ZmbAy8By59xTpZRp7S+HmZ3oP28O8APQ0cw6mFkcMAL4KFTBSx20/k2YMQTqt4Whc6DFSaGvY+NkWHgPpFwKHW8K/flFpEYL5lZnP+BKYLGZFa/MeS+QAuCcexG4BLjRzAqBfcAI55wDCs3sFuAzvOEMrzjnlob4GqQucA6WPe6tnddyIAx4v3KzsJRm5wr4egQ07QEnvVr5Qe8iUusE06tzNnDE3w7OuX8A/yhl37+Bf1coOokMvkKYezOsGQepl8NJr0B0vdDXk7/dm+0lqh4M+FDP9UQiVI0eZCgRoGA3fD3ce97W9U/Q8xGwKphJz1cAs0fAnnVw6hfQQB2oRCKVEp+Ez74t8OVZsGMBnPAidLy+aupxDr6/HjZP9SazbqkFZkUimSaplvDY8zN8fgrsWuGNz6uqpAew6H5Y+6o3D+fR11ZdPSJ1WHmXJXrssceSUlJSuplZ+pGmMBszZkxiampqt9TU1G5jxoxJDE20R6bEJ9Vv10qY1t8bQH7qNEg+u+rqWv0iLH3ES3jdH6y6ekRqkA8WbGx+/gtzuvf/31np578wp/sHCzZW+7JEAwcO3D1t2rRVbdu2LXWqsi1btkQ/8cQTbb///vvlc+fOXf7EE0+0zc7Ojq5srGVR4pPqtX0BTDsFfAfg9C8h6eSqq2vDh16nmbZnebdS1YNTIsAHCzY2f3bGutScPflxADl78uOenbEutbLJrzzLEgH069dv37HHHnvE+Tk/+OCDJgMGDNjVqlWroqSkpKIBAwbseu+990I4PVPJ9IxPqk/21/Dl2RDbGE79vGqX/9n8OcweDs0zvAVqo/RPXSLDq9/+kpxf5DukUZNf5It69dtfki/o1bZaliVKT0/fH8w5s7KyYtu1a3cwOSYnJ+dnZWXFVjTGYOm3gVSPTVPhqwshoZ13e7Mqe1VunQUzz/cS66B/a9iCRJTill6w2ysimEmqazIlPql6v7znDRpv3BUGfwb1W1VdXdu+91qVDdrD4GlQr1qelYvUGIkN4vJLSnKJDeKqbVmiYFt8ycnJBTNnzmxU/DkrKytu4MCBeaGKszRKfFK1Mt+Cb66AxD4w6FOIa1p1dW1f4K3mEJ8Ep06v2gQrUkNd07d91rMz1qUG3u6Mi47yXdO3fbUuSxSMCy64YOfo0aOTizu0zJw5s/HTTz+9obLnLYs6t0jVWT8BvrkcWpzstfSqMuntXAZfnAGxjbykl6DVryQyXdCrbe6tgztkFrfwEhvE5d86uENmZZ7vQfmXJXrkkUdatmrVqseWLVvievbs2XX48OGpAF999VVC8ftWrVoV3XXXXRvT09O7pKend/njH/+4sVWrVkWViTMY5k2pWbNkZGS4uXPnhjsMqYx14+G7qyDpFBj4CcQ2DM15fQUQddiz710rYfpgb6D66V9B43KtiCURxMzmOecywh1HeS1cuHB9z549t4U7jtpk4cKFLXr27JlW0j61+CT01v3Ln/QGeLc3K5v0ig7A6rHwaTeYGAc//vHXfTuXweeDwBX5e4oq6YnIkekZn4TW2tfhu2ug1WAY+DHEJFTufJumwg83w+413tAEi4LN0719O5bAF6cBUXDal9CkS2WjF5EIoBafhM7aN7yk1/q0yie9/B3w9RVeZxUzGDQZ+rzs3c5MPhu2L/Jub1qMNxBeSU9EgqQWn4RG5lsw5xpodao392ZM/Yqfa+tX8M2VsG+jN81Y13vAor1pzuKaQctBXtKLSYDTZkCjY0J1FSISAZT4pPJ++cAbstCiHwz8sOJJz1cEix+ApY9Bw6PhjK+hxYneviWPQM4c6HwHzL4EYhrB6TOg4VGhuw4RiQhKfFI5GyfD15d5z98GfVLxWVIO5HqD3DdPg6NGQvqYXzvFbJrmJcT4Vt5itfWS4LQvoGFaqK5CRCKInvFJxW3+AmZdBE26weAp3hycFbF9EUzJgK0z4cR/wkmv/pr0dq/1EqLzwf4t0CANzpitpCdSzUK1LJHP52PkyJHtU1JSunXq1Knr7NmzS+wMMGvWrIROnTp1TUlJ6TZy5Mj2Pp8vFJcBKPFJRWV/AzPPhYbHwOCpFR+cnvk2TO0Lvv1w+kw45rpf9+3fBjPOhHz/uNvEk7wyCW0rH79IHfbq9NXNu976fvcWV01I73rr+91fnb66xixL9M477zRZu3Zt/Pr165e88MILmTfddFOJE/fedNNNqS+88ELm+vXrl6xduzZ+0qRJFfzL+reU+KT8diz25sNMSPYmnI5vUf5zOAeLR8PXw73JpIfNgxYn/bq/cA/MPAfyVnmfW5/h1VWv0v9/Req0V6evbv7nN+enbtmxP84BW3bsj/vzm/NTK5v8QrUs0Ycfftj0iiuuyImKiuK0007bs2vXrpjMzMxDZqXIzMyM3b17d9Rpp522JyoqiiuuuCLngw8+aFaZ+APpGZ+Uz+513mxzikQAACAASURBVBCDmASvpVe/dfnP4SuA70fB2te8z7tWQHT9Q/fPHu51ZgFofwmc/H8QXa/S4YvUdU9+uCT5QMGhyxIdKPBFPfnhkuRrTusY9mWJNm3aFJuWlnYwIbZp0yY/MzMzNjU1taB4W2ZmZmybNm0Ofk5NTc3ftGlTyJYrUuKT4O3b4s2HWbQfTp9VsedsBbu8mVa2//jrtqL93nAF+DXpbfzU+3z0tXDCWIiq8kWZReqErTv2l7j8UGnbK6LOL0tkZu2BN4BWgAPGOeeeOazMFcDdgAF5wI3OuYX+fev924qAwto4T54A+Tvhy2Gwb5M3NVjT48p/jn2b4cMUL7kBtDoNtkyHHg97k0v7Cr01+4qTXte7oedftHK6SDm0bBqfv6WEJNeyaXyNWJaoTZs2BevXrz8Y36ZNm+ICW3sAqampBYEtvMzMzLjAFmBlBdPiKwTudM7NN7NGwDwzm+acC8z264CBzrntZnYmMA7oE7B/sHNOE6zWVoX74KvzYOdSGPAxJPUt/zl2r4ePOvz6Of1Z+PEuaDnQS3C+QpgxBLbM8Paf8Dx0vDEk4YtEkrvO75b15zfnpwbe7qwXG+W76/xuNWJZovPOO2/H888/3/L3v/997owZMxo0atSoqKTE17BhQ9/06dMbDB48eM/48eMTb7755q2ViT9QmZ1bnHObnHPz/e/zgOVA8mFlvnHObfd//A4o88Gn1BK+Qm84wdZZcNIb0HZo+c+xcwUTHx9Cp7FXkvDkTXR65RYmTnzVW439lHe9Cab/3ePXpDfwYyU9AWDjjv18uSqHKUuz+XJVDht3BLW+aUS75rSOuY9efnxmq6bx+Qa0ahqf/+jlx2dW5vkehG5Zossuu2xnamrqgdTU1G433nhj6nPPPZdZfEzgc8Pnnnsu84YbbkhLTU3tlpaWduDSSy/dWZn4A5VrWSIzSwO+Aro553aVUuYPQGfn3HX+z+uA7Xi3Scc658aVctwoYBRASkpKemZmZknFpDo5B3OuhbWvQsZz0Omm8p8jdz4TnxrBzZ8NZm/hr8+mE2IKeO5P5zLi3IHwbuKvtz+Hfg+JJ4ToAqRWcT7Yu8Ebr5m/nY37GrNkXwd8AX+fRxl0a9uItk3jK1SFliWKHEdalijozi1m1hB4F7j9CElvMHAt0D9gc3/nXJaZtQSmmdkK59xXhx/rT4jjwFuPL9i4pAotfshLet0eqFjS2/Y9TO3D/bOuPCTpAewtjOX+f37LiP3n/rrxvLXQsAMSAQp2Q+4PsG2O93XXSshbA74DB4us6jIPX9yhN6V8DlZt3VPhxCcCQSY+M4vFS3rjnXPvlVKmB/AScKZzLqd4u3Muy/91q5m9D5yI12qUmmzta7DkIW/6sO4PlP/4nB9gqveYd8OuRiUW2bB5x68fLt4G9RLLX4/UDs4HufO9Ke42TYGc77xt4E2C0KQrtD0TGnWE+DYQ14z92SXfTdtfELoZPCQyBdOr04CXgeXOuadKKZMCvAdc6ZxbFbC9ARDlnMvzvx8CjA5J5FJ1Nn8Oc34PrU+HE8eVv1dlzlz4zD+5dL0k2rWoxy/bftuhrF3jPKjfFs77CaL1F3yd4yuC7FmQOQF+eR8OZAPmzeva9V5I6geJJ5Y6KUH8jpwSk1x8rObdkMoJpsXXD7gSWGxmC/zb7gVSAJxzLwL3A4nA816ePDhsoRXwvn9bDPCmc25KSK9AQmvHYph1sbe+Xf9JEFXOMaO58+Az/zO66AQ4eymj66/n5offZO/+XztuJcQUMPqiWLhgg4Yr1DU7FsNPr8LPb3lLS0UnQLvzoO050GYIxAc33WOnlg1YsjEPX8CDjyjztotURpmJzzk3G2983pHKXAdcV8L2tUDPCkcn1WtvFnx5FsQ0hIGfQlyT8h2f+6M32XSxc1ZAfBIjzkoC57j/by+zYXsM7RrnMXpkD0Zc84fQxi/hU7gXfn4H1oyFbd9CVJx36zL1d5B8ToVW7Sh+jrdq6x72F/iIj42iU8sGer4nlaaZW8RTkOfNv5m/A86YBQ3al+/4XatgWr9fP5+9/Ndz5G9nxM4+jCj+02jYPGh+fEjCljDbkwkrnvE6QRXsgMbHwvFPQYerQvLMtm3TeCU6CTndLBf/NGGXws4l0P8daNarfMfv3QBfnA5F+7zPg6dCE/+kDtnfwKSAZzgXZSvp1QW58+Hry+Gjo2HVGGg7DE770vuDp/N/q6NSHVQdyxKNGTMmMTU1tVtqamq3MWPGlPiPaMuWLdEnn3xyx9TU1G4nn3xyx+zs7HLPZ6jEJzDvNtj0GZzwovcLrDwO5HiTVu/9xft8/N+hzRneGMAf7/61FZjYB0bkV2wlB6kZnIONU2D6aTAlHbI+gWNv94ah9JsArQbqeW0N8c93ZjXvcMa93RN635Le4Yx7u//znVk1flmiLVu2RD/xxBNtv//+++Vz585d/sQTT7QtKak98MADbQYNGpSXmZm5ZNCgQXn3339/uWfK163OSLfqeVj9AnS569C18IJRuBe+PJtJy5vy8KpnyNrfguQfGnDfeXO5ZFPAIPQTXoSO14c2bqk+znnzpy5+0Ou8VD8Zev0VjhlV/ufAUuX++c6s5n/833dT9+cXRgFs3rYr7o//+24qwO8vPaXCs7cELks0cODAXWPHjt1wpPL9+vXbV9L20pYlmjJlSqMBAwbsatWqVRHAgAEDdr333ntNrr/++kNinjJlStOZM2euBLj++utzBg4ceCxQrunYlPgi2ebPYd6tXm+7nn8p37HOB99ezaTFMdy+5Dr2+bwlgzbk7OX215dAt5O5pO03cM5Kb709qX2c88bdLX7QG2Te8Cjo8wqkXQHRIZvoX0LssXGTk4uTXrH9+YVRj42bnFyZxFfVyxJlZWXFtmvX7uD25OTk/KysrN90K8/JyYkpntuzffv2BTk5OeXOY0p8kWrXaph1KTTuDP3Gl3/Zn0X3wy+TeHjdKweTXrF9vno8/NNILrn9c4ipX8oJpMZyzrv1vfhBb03EBmnQ52XocGX5h7dItduybVeJf5WUtr0iasqyRFFRUVgFbq8r8UWi/B3w1bkQFeNNCB3buHzH//IBLH0Ujr6OrCkl97jL2tNQSa822joLFtztDUlISPEmMOhwtVp4tUirFo3zN5eQ5Fq1aFyjlyVKTk4umDlz5sFpnrKysuIGDhyYd/jxiYmJhcUL12ZmZsY2b968sLzxq3NLpPEVegu97l4Lp7xX/rkx92Z5E1c3T4eM50huVnILIDkxocTtUkPtXAYzz4PPB8Cen73nsueuhmN+r6RXy9w76sys+LiYQ6a8iY+L8d076syQL0tU0utISQ+8ZYnGjx+f6PP5mD59+sFliS644IKdM2fObJydnR2dnZ0dPXPmzMYXXHDBb1ZkGDp06I6xY8cmAowdOzZx2LBhO35by5Ep8UWaBXfD5qlwwgvQ8pTyHz/vNm/F9PRnYOG93Nf+WepHHzikSP24aO67VPMW1Ap7s2DOdfDv7rB1pves99xVXmckJbxa6feXnpL71z9cnNm6ReN8A1q3aJz/1z9cnFmZ53tQ9csStWrVquiuu+7amJ6e3iU9Pb3LH//4x43FHV2GDx+e+tVXXyUAPPTQQ5tmzJjRODU1tduXX37Z+KGHHtpU3msp17JE1SUjI8PNnTs33GHUPT+/A7Mvg07/BRnPlv/4/O2/jsmLru8lwKNGMunA7Tz8wTqycvaSnJjAfZf25JKT00IauoRY/k5Y9gSs/Lu3HmLHm6Hbn+v8+DstSxQ5QrIskdRyO5fDd/8JLfpC7/+t2DmiG3gTDO9e68292OVuaNKZS4BLBvYIabgSGvOzdjJl5TZ27Cukaf0YhnVsyvF7/g+WPuyNwUy9HHo+ouWgJKIo8UWCgt3exNPR9aH/2xW/hRUdB8N+CG1sUmXmZ+3k3cVbKCjy7urs2FfIuws3wL5pHJ/YG3o9oVl0JCIp8dV1znnPcPJWwuBpkFDmrXmpI6as3HYw6RUrsHimNHmc40/tFqaoRMJPnVvqulVjvOVhejwKrU8NdzRSjXbsK7mX944CjcWrhXw+n0/zwQXJ/70qdcViJb66LPtrmH8ntDsfut4d7mikuhTlw4qnaeorubNb0/q60VMLLcnOzm6i5Fc2n89n2dnZTYAlpZXR/4C6at8Wrwdng1Q46TVNHhwJnPMmjv7xTshbzbAWf+bdov+gIOB3ZWy0MexYTRRe2xQWFl63efPmlzZv3twNNVjK4gOWFBYWljr5sBJfXeQrhK9HeMMPhkyGuKbhjkiq2s4V3hjLzVO9aegG/Zvj254Jh/fqPLYFxydrYunaJj09fStwXrjjqCuU+OqiRf8DW7+Ek16HZhpmUKcV7ILFo2HlM94q58f/HTrddHBOzeOTmyjRiRxGia+u+eUDb2DyMTfAUVeFOxqpKs4H6/7lzcSzfyscfS30fBTig14uTSRiKfHVJbtWw3dXQ/MTIP3v4Y5GqkrOXJj7X5DzHSSe5E00nnhC2ceJCKDEV3cU7oHZF3u3uE6ZBNH1yj5Gapf9W2HhvfDTK17L7qTXvKWCTH0dRMpDia8ucA6+vwF2LIHBU6BBSrgjklDyFcDqF7w1EAv3QOc7oPv95V9OSkSAILrFmll7M5thZsvMbKmZ3VZCGTOzZ81sjZktMrPjA/ZdbWar/a+rQ30BAqx5Edb/H3R/CNoMCXc0Ekqbv4DJvb0em4l94KzFcPz/KumJVEIwLb5C4E7n3HwzawTMM7NpzrnA1XfPBDr6X32AF4A+ZtYceADIAJz/2I+cc9tDehWRbNsc75di27O82fWlbtiTCfP/AL9MggYdYMAHkHyexmOKhECZic85twnY5H+fZ2bLgWQgMPGdD7zhvDWOvjOzpmbWBhgETHPO5QKY2TRgGDAhpFcRqfZnw+xLoH4y9P2XnvXUBYX7YPmTsOxx73P30dDlD1rNXiSEyvWMz8zSgN7AnMN2JQO/BHze4N9W2vaSzj0KGAWQkqJnVGXyFcE3l3vJb8g3UK95uCOSynAONnwA8++APesh5TLo/aSe14pUgaCbCGbWEHgXuN05tyvUgTjnxjnnMpxzGUlJSaE+fd2z+EHY/Dmc8JyWlqntdi6DGUNg1kUQ0xBO+wL6v6WkJ1JFgmrxmVksXtIb75x7r4QiWUD7gM/t/Nuy8G53Bm7/siKBSoCsT2DpI96g5aOvDXc0UlH5O70/YFaNgZhGkD4GOt4AUepsLVKVgunVacDLwHLn3FOlFPsIuMrfu/MkYKf/2eBnwBAza2ZmzYAh/m1SUXk/wTdXQrPe3i9KqX2czxuL90knb6qxo6+Fc1fBsbco6YlUg2D+l/UDrgQWm9kC/7Z7gRQA59yLwL+Bs4A1wF7gGv++XDN7GChetnt0cUcXqYDCPTDrQq8TyynvqsNDbbTtO2/Wldy50OJkGDRZt6pFqlkwvTpnA0fsQ+3vzXlzKfteAV6pUHTyK+fgu2th51Lvl2XDDuGOSMpj32ZYcA+sex3qt4G+/wdpl2t4gkgY6L5KbbHib95K6j3/okHqtUlRPqx61ltBwbcfut4Dx90LsY3CHZlIxFLiqw02f+7Nwt/+Yq2kXptsnOJNLpC3CtqeA8c/BY07hjsqkYinxFfT7cn0FpVt3BlOelW3xmqDvDXeeLysj6FRRxj4KSSfFe6oRMRPia8mK8iDmed5kxSf8r5uj9V0Bbth6WPebemoOOj1BBx7O0THhTsyEQmgxFdT+Qph9nCvM8vAT6Fxp3BHJKVxDjInwI93wb6NkHYl9HocEtqGOzIRKYESX001/79h02Q44QVoOzTc0Uhpcn+EebdC9mxong7934Gkk8MdlYgcgRJfTbRyDKz6h7fuWscbwh2NlGT/Nlj0P7BmHNRLhBP/CUddA1HR4Y5MRMqgxFfTZH0K82/3lqDp9ddwRyOH8xXCmrGw6D4o2AXH3grdH4C4ZuGOTESCpMRXk2xf6PXgbNoT+r2p1kNNs+VL77bmjsXQ6lRIfxaaHhfuqESknJT4aoq9G+DLsyG2CQz8GGIahDsiKbZ7Hfz4R/+isKnedHHtLtTQEpFaSomvJijY5SW9gl1wxixIKHHJQqluBbv8wxOeBouB7g/5F4VNCHdkIlIJSnzh5iuAWZd4a7IN+hSa9Qx3ROIrgrWveJ1X9m+FDldBz8f0B4lIHaHEF07OwffXw+Zp0OcVzcFZE2yZAfNuhx2LvNUTBn4CiSeEOyoRCSElvnBa8jCsfRW6PQBHXxPuaCJb3hpvAPqGD7zneP3egpRL9RxPpA5S4guXta/D4gegw9Ved3gJj/wdsOQRbwWFqHreLc1jb9dahyJ1mBJfOGz+HOZcB61PhxPHqVURDr5C+OmfsOh+OJDjDT7v+Yi3Vp6I1GlKfNVt+yL46iJo0gX6T9IExuGwaaq3esLOpdByIBz/NDTvHe6oRKSaKPFVp31bYOY5ENsYBv0b4pqEO6LIsnMF/PgH2PgpNDxK4/FEIpQSX3UpOgCzLoID2+CMryGhXbgjihz7tsCSh7x5NaMTvKngjr0VouuFOzIRCQMlvurgHPxwI2z7Bvq/rdtq1aVwL6x4CpY9AUX74JgboPv9EN8y3JGJSBgp8VWHlc/6hy3c53WRl6rlK4J1r3sTSe/b6N3O7PUXaHxsuCMTkRqgzMRnZq8A5wBbnXPdSth/F3BFwPm6AEnOuVwzWw/kAUVAoXMuI1SB1xqbpsKPd0C7C6D7g+GOpu7b+BksuMubSDqxjzcer2X/cEclIjVIMC2+14B/AG+UtNM59yTwJICZnQv8t3MuN6DIYOfctkrGWTvtXuutot7kOOj7L7CocEdUd21f4E0kvXma13FFA9BFpBRlJj7n3Fdmlhbk+X4HTKhMQHVG0X6Y5b+tOeBDiG0Y3njqqr0bYOH/wLo3vDXxjn8aOt6ojisiUqqQPeMzswRgGHBLwGYHTDUzB4x1zo0LVX013vw7Yft8L+k17BDuaOqe/J1ep5WVT4PzeasmHPcnLQgrImUKZeeWc4GvD7vN2d85l2VmLYFpZrbCOfdVSQeb2ShgFEBKSkoIwwqDzLdg9fPeL+N254U7mrqlaD+seh6WPebNuJJ6OfR8FBqmhTsyEaklQvnQaQSH3eZ0zmX5v24F3gdOLO1g59w451yGcy4jKSkphGFVs12rvOnIWpzszfsooeErgp9ehY87wY93QrN0GDYX+o1X0hORcglJi8/MmgADgf8I2NYAiHLO5fnfDwFGh6K+GstXAN9cAVFx0G8iRMWGO6LazznY8CEs+rO3ZmHzE+Ck16D1qeGOTERqqWCGM0wABgEtzGwD8AAQC+Cce9Ff7EJgqnNuT8ChrYD3zetVFwO86ZybErrQa6Clf4HcudD/HWjQPtzR1H5bv4IF98C2b70xeP0nQfuL1FNTRColmF6dvwuizGt4wx4Ct60FImc58Zy53vp6aVdAyiXhjqZ2274QFvwJNk2G+slw4j/hqJEQpfkWRKTy9JskFAr3wbdXQXwryBgT7mhqr7yfvDUK178JsU2g1xPQ6b+0Np6IhJQSXygsug92LYfBn6k7fUXs+dlbDHbtK97z0a53Q9c/6nspIlVCia+ycn/0xpIdMwraDAl3NLXLvk2w9DFv1QSAjjd5Y/G0GKyIVCElvsrwFcH310O9FtDr8XBHU3vsz4blf4VV//BWQj/qGuj2P9Cglo/fFJFaQYmvMtaMhdwfoO//6bZcMPK3w/K/wcpnoGgvpP0HdLsfGh0d7shEJIIo8VVU/nbv2V6rwZB2ebijqdkK8rxkt/x/oWAnpFzmrVTRpEu4IxORCKTEV1FLHvGS3/F/17iy0hTkebczV/zNm16s3fnQ/SFoFjmjXESk5lHiq4i8NbBqDBx9LTTrEe5oap78nd73Z8XTkJ8Lbc70WngtSp2xTkSk2ijxVcTiB71u9z0eDnckNUv+Dm+1+RVPQ8EOaHsOdL8fEk8Id2QiIgcp8ZXXrlWQOQE6/wHqtw53NDVD/nZY8XfvOV7BTkg+z0t4zdPDHZmIyG8o8ZXXkkcgKh663BnuSMLvQC6seMpr5RXmQbsLodt90Lx3uCMTESmVEl957MmEzPFw7O0Q3zLc0YTP3o1ewlszFgp3Q/uLvYSnTisiUgso8ZXHav9iFMfeHt44wiXvJ2/g+drXwBVCygg47h5o2j3ckYmIBE2JL1hF++Gnf0K7CyJvyaHtC2HZ4/Dz22CxcNR/Qte7oOFR4Y5MRKTclPiC9fO73li0jjeHO5Lqk/21t8bgxk8hpiF0vhM6/7fm0hSRWk2JL1i/vAMJ7aDVoHBHUrWcD7I+9mZZyZ7tzUPa42HodLOmZROROkGJLxgFebBxChxzPVhUuKOpGoX7YN0bXqeVvFXQIBXSn4Gjr4OYhHBHJyISMkp8wdj4b/AdqJsrq+/PhlXPwern4MA2aJ4B/d6C9hdpxXMRqZP0my0YGyd7t/xanBzuSEJnxxJv/N36f3kdd5LPhS5/gKRTNPeoiNRpSnzB2PYNJPWDqOhwR1I5viLI+sibR3PLDIiOh7QrofMd0KRzuKMTEakWSnxlKciDvNVw1MhwR1JxB3Lhp5dg9fPeIPyEFOj1hDfJdr3EcEcnIlKtlPjKsnud97VRx/DGURHbF8Cq52H9/0HRPmg5CI5/2rutqed3IhKhyvztZ2avAOcAW51z3UrYPwj4EPBnCN5zzo327xsGPANEAy855x4PUdzVZ1+W97V+u/DGEayC3ZA5EdaM81aHj67vrXR+7H9phhUREYJr8b0G/AN44whlZjnnzgncYGbRwHPAGcAG4Acz+8g5t6yCsYZH0X7va0z98MZRltz5XrJbP96bP7PJcZD+LHT4D42/ExEJUGbic859ZWZpFTj3icAa59xaADObCJwP1K7EFxXnfS3cF944SnIgx2vdrX0Vcud5rbvU4XD0KGhxknpnioiUIFQPevqa2UJgI/AH59xSIBn4JaDMBqBPiOqrPgn+W5x7fwb6hjUUAIoOeFOIrfuX99VXAE17QPoYf+uuabgjFBGp0UKR+OYDqc653WZ2FvABUO6eIGY2ChgFkJKSEoKwQqRxF4hOgK2zvNZUODgfZH/j3cb8+S1v4df41tDpVuhwpZYDEhEph0onPufcroD3/zaz582sBZAFBC5j0M6/rbTzjAPGAWRkZLjKxhUy0XHQZij8PBF6PwExDaqnXl8hZM+CnyfBhvdh3ybvVma7C6HDVdD6NPXMFBGpgEr/5jSz1sAW55wzsxOBKCAH2AF0NLMOeAlvBHB5ZesLiy53ecln4X2Q/lTV1VOQ5w0sz/rEq+/ANi/ZtT3LW+w1+RyIbVR19YuIRIBghjNMAAYBLcxsA/AAEAvgnHsRuAS40cwKgX3ACOecAwrN7BbgM7zhDK/4n/3VPkl9odMtsPJpiE+Crvcc7DgyddlWxs5ez9ZdB2jZuB7X909jSNcgV2d3Pm+tu02fwaYp3gwxvgJvCaDkc71k13ZY9bUyRUQigHk5qmbJyMhwc+fODXcYhyrKh+9GQuYEaDkAuj/I1JwuPDH1Jw4U+g4WqxcTxd1DOpac/A7kQs73sO1b75UzBwr8d4qb9vSSXJuh0KKfd4tVRELKzOY55zLCHYeElx4SBSs6Dk4eDy0HwqL7YPqpjN36LgcKkw4pdqDQx9gZSxkS/Rbk74A96yFvJexa6d26BG9poybdIfV33hygrc+A+q2r/5pERCKQEl95mEHH671hAxs+ZuukFiUW27ovCubd6n2IbwWNj/U6pTQ+Fpr1hsQT9KxORCRMlPgqIqYBpI2gZePv2bLrwG92t2wYAxdlQ1wTiIoNQ4AiIlKaOrqcePW4vn8a9WIO/RbWi4ni+gEdIb6Fkp6ISA2kFl8lFHdgqXCvThERqXZKfJU0pGtLJToRkVpEtzpFRCSiKPGJiEhEUeITEZGIosQnIiIRRYlPREQiihKfiIhEFCU+ERGJKEp8IiISUZT4REQkoijxiYhIRFHiExGRiKLEJyIiEUWJT0REIooSn4iIRBRzzoU7ht8ws2wgs4qraQFsq+I6amr9kXzt4a4/kq+9JtR/rHOuURjrlxqgRq7H55xLquo6zGyucy6jquupifVH8rWHu/5IvvaaUn+46paaQ7c6RUQkoijxiYhIRInkxDcuguuP5GsPd/2RfO2qX2qEGtm5RUREpKpEcotPREQiUJ1LfGb2ipltNbMlpewfZGY7zWyB/3V/wL5hZrbSzNaY2T1VVP9dAXUvMbMiM2vu37fezBb795W795mZtTezGWa2zMyWmtltJZQxM3vWf42LzOz4gH1Xm9lq/+vqKqr/Cn+9i83sGzPrGbCvwtcfZN1V9rMPsv6q/NnHm9n3ZrbQX/9DJZSpZ2Zv+a9xjpmlBez7k3/7SjMbWgV13+H/3iwys+lmlhqwryjg+/JR+a486PpHmll2QD3XBeyr1L97qYWcc3XqBQwAjgeWlLJ/EPBJCdujgZ+Ao4A4YCHQNdT1H1b2XOCLgM/rgRaVuPY2wPH+942AVYdfA3AWMBkw4CRgjn97c2Ct/2sz//tmVVD/ycXnBc4srr+y1x9k3VX2sw+m/ir+2RvQ0P8+FpgDnHRYmZuAF/3vRwBv+d939V9zPaCD/3sRHeK6BwMJ/vc3Ftft/7y7otddjvpHAv8o4dhK/7vXq/a96lyLzzn3FZBbgUNPBNY459Y65/KBicD5VVz/74AJ5a3jCHVvcs7N97/PA5YDyYcVOx94w3m+A5qaWRtgKDDNOZfrnNsOTAOGhbp+59w3/vMDfAe0K9dFVqLuI6j0z74C9Yf6Z++cc7v9H2P9r8Mf4J8PvO5/Pwk4zczMv32ic+6Ac24dsAbvexKyup1zM5xze/0fQ/ZzD7b+I6j0v3upfepc4gtSX/9tkclmdpx/WzLwS0CZDQT/BraM1QAAA6pJREFUi7PczCwB7z/YuwGbHTDVzOaZ2ahKnj8N6I3312+g0q4zpNd/hPoDXYvX+iwWkusvo+4q/9mXde1V9bM3s2gzWwBsxftlXurP3jlXCOwEEgnB9QdRd6DDf+7xZjbXzL4zswvKU28567/Yf6t1kpm192+r1v/3UjPUyJlbqth8INU5t9vMzgI+ADqGIY5zga+dc4Gtw/7OuSyz/2/n7EJsiqI4/vuHpCFM46t8lweNROQBJfKgaKQ8zAMPnqSRPFMUL8qLJ1EohBplCk0+CqUkvE0zKYMSL2omTSF1WR72vubcy8yc656DcdavTne3zz73f9bd55zVXmvdo+nAXUnP4wqyJiRNJDxU95vZQEbnm6m+pPWEB+DaRHfd9o+gnfvcp/ztc5l7M/sKLJM0BeiQtMTMfplrzpq02pJ2ACuBdYnuedH2hcA9SV1m9jJj/RvAFTP7Imk3YeW7oTYrnf+Fwq34zGygHBYxs05gnKQm4B0wJzF0duzLi1aqQl1m9i5+vgc6qCHcVEbSOMKD95KZXfvFkKHszMT+FPpIWgqcAbaaWV+5v177R9LOe+7T2B7JZe4T3/UBuM/PIbsfdkoaC0wG+sjw2h9GG0kbgYNAi5l9SRxTtv0V8ICwWv4thtI3s76E5hlgRWz/6fve+RfIO4n4NzZgPkMXt8xk8P+Lq4A3hOT4WEJiewGDBQ7NWevH/ZMJecCGRF8DMCnRfgRsqlFXwAXgxDBjNlNZ3PIk9jcCrwkJ/qmx3ZiD/lxCDml1VX9d9qfUzm3u0+jnPPfTgCmxPQF4CGypGtNGZXFLe2w3U1nc8orailvSaC8nFM0squqfCoyP7SbgBbUXFqXRn5VobwMeZ3Xd+zb6tv8u1CnpCqF6r0nSW+AwIdmNmZ0CtgN7JJWAz0CrhTugJGkvcJtQ5XfOzLpz0Idw490xs4+JQ2cQQjQQHsSXzexWjfJrgJ1AV8x3ABwgOJuyfiehsrMX+ATsivv6JR0FnsbjjlhlKC4r/UOEvNLJaGvJwkuL67U/jXaec59GH/Kb+1nAeUljCJGcdjO7KekI8MzMrgNngYuSegnOtzWeW7ekdqAHKAFtFkKHWWofByYCV6Odb8ysBVgMnJb0LR57zMx6crB9n6SWaF8/ocozq+veGWX4m1scx3GcQlG4HJ/jOI5TbNzxOY7jOIXCHZ/jOI5TKNzxOY7jOIXCHZ/jOI5TKNzxOY7jOIXCHZ/jOI5TKNzxOY7jOIXiOxp384cEwCpkAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(5, 5))\n",
    "\n",
    "# Createt time points and colors for the time points\n",
    "time_points = [0, 1e-1, 1e0, 1e1, 1e2]\n",
    "time_point_colors = [\n",
    "    mpl.colors.to_hex(c)\n",
    "    for c in mpl.cm.Blues(np.linspace(0.3, 1, len(time_points)))]\n",
    "\n",
    "# Plot the phase portrait\n",
    "plot_ensemble_phase_portrait(\n",
    "    flux_sol_list, x=\"ATPM\", y=\"GAPD\", ax=ax, legend=\"upper right\",\n",
    "    xlim=(1.3, 3.5), ylim=(1.3, 3.5),\n",
    "    title=\"ATPM vs. GAPD\",\n",
    "    color=\"orange\", linestyle=\"-\",\n",
    "    annotate_time_points=time_points,\n",
    "    annotate_time_points_color=time_point_colors,\n",
    "    annotate_time_points_legend=\"right outside\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fast Ensemble Creation\n",
    "\n",
    "Another function utilized for ensemble creation is the `generate_ensemble_of_models()` function. The `generate_ensemble_of_models()` function is a way to streamline the generation of models for an ensemble with increased performance gains at the cost of user control and increased overhead for setup. Consequently, the `generate_ensemble_of_models()` function may be a more desirable function to use when generating a large number of models. \n",
    "\n",
    "The `generate_ensemble_of_models()` function requires a single `MassModel` as a reference model, and sample data as a `pandas.DataFrame` for the `flux_data` and `conc_data` arguments.\n",
    "\n",
    "* For `flux_data` columns are reaction identifiers, and rows are samples of steady state fluxes.\n",
    "* For `conc_data` columns are metabolite identifiers, and rows are samples of concentrations (initial conditions).\n",
    "\n",
    "At least one of the above arguments must be provided for the function to work. After generating the models, a list that contains the model objects is returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:32:32.627640Z",
     "iopub.status.busy": "2020-10-20T20:32:32.626913Z",
     "iopub.status.idle": "2020-10-20T20:32:42.283942Z",
     "shell.execute_reply": "2020-10-20T20:32:42.284384Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total models generated: 100\n"
     ]
    }
   ],
   "source": [
    "# Generate the ensemble\n",
    "models = generate_ensemble_of_models(\n",
    "    reference_model=reference_model, \n",
    "    flux_data=flux_samples,\n",
    "    conc_data=conc_samples)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To ensure that the PERCs for certain reactions are positive, a `list` of reactions to check can be provided to the `ensure_positive_percs` argument. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:32:42.292075Z",
     "iopub.status.busy": "2020-10-20T20:32:42.291333Z",
     "iopub.status.idle": "2020-10-20T20:33:15.404378Z",
     "shell.execute_reply": "2020-10-20T20:33:15.404931Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total models generated: 100\n",
      "Feasible: 100\n",
      "Infeasible, negative PERCs: 0\n"
     ]
    }
   ],
   "source": [
    "# Exclude boundary reactions from PERC calculations for the example\n",
    "reactions_to_check_percs = [\n",
    "    r.id for r in reference_model.reactions\n",
    "    if r not in reference_model.boundary]\n",
    "\n",
    "# Generate the ensemble\n",
    "ensemble = generate_ensemble_of_models(\n",
    "    reference_model=reference_model, \n",
    "    flux_data=flux_samples,\n",
    "    conc_data=conc_samples,\n",
    "    ensure_positive_percs=reactions_to_check_percs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To ensure that all models can reach a steady state with their new values, a strategy for finding the steady state can be provided to the `strategy` argument. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:33:15.494099Z",
     "iopub.status.busy": "2020-10-20T20:33:15.451835Z",
     "iopub.status.idle": "2020-10-20T20:33:55.589777Z",
     "shell.execute_reply": "2020-10-20T20:33:55.590213Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "mass/simulation/simulation.py:828 \u001b[1;31mUserWarning\u001b[0m: Unable to find a steady state for one or more models. Check the log for more details.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total models generated: 100\n",
      "Feasible: 90\n",
      "Infeasible, negative PERCs: 0\n",
      "Infeasible, no steady state found: 10\n"
     ]
    }
   ],
   "source": [
    "# Generate the ensemble\n",
    "models = generate_ensemble_of_models(\n",
    "    reference_model=reference_model, \n",
    "    flux_data=flux_samples,\n",
    "    conc_data=conc_samples,\n",
    "    ensure_positive_percs=reactions_to_check_percs,\n",
    "    strategy=\"simulate\",\n",
    "    decimal_precision=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To ensure that all models can reach a steady state with their new values after a given perturbation, in addition to passing a value to the `strategy` argument, one or more perturbations can be given to the `perturbations` argument. The `perturbations` argument takes a `list` of dictionaries, each containing perturbations formatted as described in [Dynamic Simulation](./dynamic_simulation.ipynb#Perturbing-a-Model).\n",
    "\n",
    "If it is desirable to return the models that were not deemed 'feasible', the `return_infeasible` kwarg can be set to `True` to return a second list that contains only models deemed 'infeasible'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-20T20:33:55.681850Z",
     "iopub.status.busy": "2020-10-20T20:33:55.638144Z",
     "iopub.status.idle": "2020-10-20T20:34:50.494198Z",
     "shell.execute_reply": "2020-10-20T20:34:50.493643Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "mass/simulation/simulation.py:828 \u001b[1;31mUserWarning\u001b[0m: Unable to find a steady state for one or more models. Check the log for more details.\n",
      "mass/simulation/simulation.py:828 \u001b[1;31mUserWarning\u001b[0m: Unable to find a steady state for one or more models. Check the log for more details.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total models generated: 100\n",
      "Feasible: 88\n",
      "Infeasible, negative PERCs: 0\n",
      "Infeasible, no steady state found: 10\n",
      "Infeasible, no steady state with pertubration 1: 2\n",
      "Infeasible, no steady state with pertubration 2: 0\n"
     ]
    }
   ],
   "source": [
    "feasible, infeasible = generate_ensemble_of_models(\n",
    "    reference_model=reference_model, \n",
    "    flux_data=flux_samples,\n",
    "    conc_data=conc_samples,\n",
    "    ensure_positive_percs=reactions_to_check_percs,\n",
    "    strategy=\"simulate\",\n",
    "    perturbations=[\n",
    "        {\"kf_ATPM\": \"kf_ATPM * 1.5\"},\n",
    "        {\"kf_ATPM\": \"kf_ATPM * 0.85\"}],\n",
    "    return_infeasible=True,\n",
    "    decimal_precision=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that perturbations are not applied all at once; each `dict` provided corresponds to a new attempt to find a steady state. For example, two dictionaries passed to the `perturbations` argument indicate that three steady state determinations are performed, once for the model without any perturbations and once for each `dict` provided.\n",
    "\n",
    "Generally it is recommended to utilize the functions in the `ensemble` submodule to generate small ensembles while experimenting with various settings, and then to utilize the `generate_ensemble_of_models` function to generate the larger ensemble."
   ]
  }
 ],
 "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.7.9"
  },
  "nbsphinx": {
   "timeout": -1
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}