ModelingTutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modeling Tutorial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Import packages\n",
    "import polars as pl\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import scipy as sp\n",
    "import matplotlib.pyplot as plt\n",
    "import itertools\n",
    "from collections import Counter\n",
    "\n",
    "# For plotting\n",
    "import seaborn as sns\n",
    "\n",
    "sns.set_theme(style=\"ticks\")\n",
    "sns.axes_style(\"darkgrid\")\n",
    "sns.set_theme()\n",
    "\n",
    "from IPython.display import display, HTML\n",
    "\n",
    "# For storing DataFrames\n",
    "import pickle\n",
    "\n",
    "import sys\n",
    "from os import getcwd\n",
    "sys.path.append(getcwd())\n",
    "import MultiStagePackage.OptMSPfunctions as msp\n",
    "from MultiStagePackage.models import *\n",
    "\n",
    "from itertools import islice\n",
    "import collections\n",
    "from ast import literal_eval\n",
    "\n",
    "# For optimization\n",
    "from pygmo import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model design\n",
    "\n",
    "The following models below show how you can modify the provided models (the comments with 'ADD' show what was changed):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Models:\n",
    "- Second product (```P2```)\n",
    "- Second substrate (```S2```)\n",
    "- Oxygen **only** in the second model (```O_2```) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Prepare data\n",
    "\n",
    "## Models\n",
    "# Taken from models.py \n",
    "\n",
    "def model1(t, y):\n",
    "    # Measurement-based parameters: \n",
    "    mu  = 0.13\n",
    "    r_S = 16.13\n",
    "    r_P = 26.11\n",
    "    r_S2 = 15.00                # ADD new substrates reaction coefficient\n",
    "    r_P2 = 2.0                  # ADD new product reaction coefficient\n",
    "    r_O_2 = 0.0                 # ADD oxygen reaction coefficient\n",
    "\n",
    "    # Check for values smaller 0\n",
    "    for i in range(len(y)):\n",
    "        if(y[i]<0.0):\n",
    "            y[i] = 0.0\n",
    "\n",
    "    if(y[S]>0.001): \n",
    "        dXdt =   mu*y[X]\n",
    "        dSdt = - r_S*y[X]\n",
    "        dPdt =   r_P*y[X]\n",
    "        dS2dt = - r_S2*y[X]       # ADD the second substrate to the ODE model\n",
    "        dP2dt =  r_P2*y[X]        # ADD the second product to the ODE model\n",
    "        dO_2dt = r_O_2*y[X]       # ADD oxygen to the ODE model\n",
    "    \n",
    "    # Case in which substrate was all taken up\n",
    "    else:\n",
    "        dXdt = 0\n",
    "        dSdt = 0\n",
    "        dPdt = 0\n",
    "        dS2dt = 0               # ADD \n",
    "        dP2dt = 0               # ADD \n",
    "        dO_2dt = 0             # ADD \n",
    "\n",
    "    if(dXdt<0.0):\n",
    "        print(dXdt)\n",
    "    \n",
    "    dydt = [dXdt, dSdt, dPdt, dS2dt, dP2dt, dO_2dt]     # ADD\n",
    "    return(dydt)\n",
    "\n",
    "def model2(t, y):\n",
    "    # Measurement-based parameters:\n",
    "    mu  = 0.06\n",
    "    r_S = 22.86\n",
    "    r_P = 41.25  \n",
    "    r_S2 = 30.00                # ADD new substrates reaction coefficient\n",
    "    r_P2 = 10.0                 # ADD new product reaction coefficient\n",
    "    r_O_2 = 2.0                 # ADD oxygen reaction coefficient \n",
    "\n",
    "    # Check for values smaller 0\n",
    "    for i in range(len(y)):\n",
    "        if(y[i]<0.0):\n",
    "            y[i] = 0.0\n",
    "\n",
    "    if(y[S]>0.001):\n",
    "        dXdt =   mu*y[X]\n",
    "        dSdt = - r_S*y[X]\n",
    "        dPdt =   r_P*y[X]\n",
    "        dS2dt = -r_S2*y[X]       # ADD the species in ODE model\n",
    "        dP2dt =  r_P2*y[X]       # ADD the species in ODE model\n",
    "        dO_2dt = r_O_2*y[X]      # ADD oxygen to the ODE model\n",
    "\n",
    "    else:\n",
    "        dXdt = 0\n",
    "        dSdt = 0\n",
    "        dPdt = 0\n",
    "        dS2dt = 0               # ADD\n",
    "        dP2dt = 0               # ADD\n",
    "        dO_2dt = 0             # ADD\n",
    "    if(dXdt<0.0):\n",
    "        print(dXdt)\n",
    "    \n",
    "    dydt = [dXdt, dSdt, dPdt, dS2dt,dP2dt,dO_2dt]      # ADD\n",
    "    return(dydt)\n",
    "\n",
    "\n",
    "models = [model1, model2]\n",
    "\n",
    "## initial conditions\n",
    "X_0 = 0.1    # gDW/L\n",
    "S_0 = 100.0  # mmol/L \n",
    "P_0 = 0.0    # mmol/L\n",
    "\n",
    "S2_0 = 500                      # ADD \n",
    "P2_0 = 700                      # ADD\n",
    "O_2_0 = 0.0                     # ADD\n",
    "\n",
    "s = np.array([X_0, S_0, P_0, S2_0, P2_0, O_2_0])     # ADD\n",
    "\n",
    "## Indexing\n",
    "X, S, P, S2, P2, O_2 = (i for i in range(len(s)))    # ADD"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Event definition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def event_sub0(t,y):\n",
    "    if(y[S] <= 0.001):\n",
    "        return 0    # 0 that event triggers\n",
    "    return 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test integration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.13882838e-01 9.82774601e+01 2.78831468e+00 4.98398134e+02\n",
      " 7.00213582e+02 0.00000000e+00]\n",
      "[1.06183655e-01 9.76440276e+01 4.25126257e+00 4.96908173e+02\n",
      " 7.01030609e+02 2.06121822e-01]\n",
      "CPU times: user 10 ms, sys: 5.68 ms, total: 15.7 ms\n",
      "Wall time: 15.1 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "times = [0, 1]  # Input time points\n",
    "combi = [0, 1]   # Models\n",
    "s = np.array([X_0, S_0, P_0, S2_0, P2_0, O_2_0])\n",
    "\n",
    "# Test model1\n",
    "result_num = sp.integrate.solve_ivp(models[int(combi[0])],t_span=[times[0], times[1]],y0=s,t_eval=[times[1]],dense_output=True,max_step=0.01,).y.T\n",
    "print(result_num[0])\n",
    "\n",
    "# Test model2\n",
    "result_num = sp.integrate.solve_ivp(models[int(combi[1])],t_span=[times[0], times[1]],y0=s,t_eval=[times[1]],dense_output=True,max_step=0.01,).y.T\n",
    "print(result_num[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test BruteForce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "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 th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Index</th>\n",
       "      <th>Times</th>\n",
       "      <th>Models</th>\n",
       "      <th>End_T</th>\n",
       "      <th>End_X</th>\n",
       "      <th>End_S</th>\n",
       "      <th>End_P</th>\n",
       "      <th>finished</th>\n",
       "      <th>Vol_P</th>\n",
       "      <th>Y_SubInput</th>\n",
       "      <th>Y_SubUsed</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>72</th>\n",
       "      <td>73</td>\n",
       "      <td>(0.0, 10.75, 24.0)</td>\n",
       "      <td>[1, 2]</td>\n",
       "      <td>16.402</td>\n",
       "      <td>0.568</td>\n",
       "      <td>0.001</td>\n",
       "      <td>173.427</td>\n",
       "      <td>2</td>\n",
       "      <td>10.574</td>\n",
       "      <td>1.734</td>\n",
       "      <td>1.734</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>(0.0, 5.25, 24.0)</td>\n",
       "      <td>[1, 1]</td>\n",
       "      <td>16.952</td>\n",
       "      <td>0.906</td>\n",
       "      <td>0.001</td>\n",
       "      <td>161.871</td>\n",
       "      <td>2</td>\n",
       "      <td>9.549</td>\n",
       "      <td>1.619</td>\n",
       "      <td>1.619</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>98</th>\n",
       "      <td>99</td>\n",
       "      <td>(0.0, 5.0, 24.0)</td>\n",
       "      <td>[2, 1]</td>\n",
       "      <td>19.004</td>\n",
       "      <td>0.833</td>\n",
       "      <td>0.001</td>\n",
       "      <td>164.347</td>\n",
       "      <td>2</td>\n",
       "      <td>8.648</td>\n",
       "      <td>1.643</td>\n",
       "      <td>1.643</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>185</th>\n",
       "      <td>186</td>\n",
       "      <td>(0.0, 12.5, 24.0)</td>\n",
       "      <td>[2, 2]</td>\n",
       "      <td>21.463</td>\n",
       "      <td>0.362</td>\n",
       "      <td>0.001</td>\n",
       "      <td>180.445</td>\n",
       "      <td>2</td>\n",
       "      <td>8.407</td>\n",
       "      <td>1.804</td>\n",
       "      <td>1.804</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     Index               Times  Models   End_T  End_X  End_S    End_P  \\\n",
       "72      73  (0.0, 10.75, 24.0)  [1, 2]  16.402  0.568  0.001  173.427   \n",
       "1        2   (0.0, 5.25, 24.0)  [1, 1]  16.952  0.906  0.001  161.871   \n",
       "98      99    (0.0, 5.0, 24.0)  [2, 1]  19.004  0.833  0.001  164.347   \n",
       "185    186   (0.0, 12.5, 24.0)  [2, 2]  21.463  0.362  0.001  180.445   \n",
       "\n",
       "    finished   Vol_P  Y_SubInput  Y_SubUsed  \n",
       "72         2  10.574       1.734      1.734  \n",
       "1          2   9.549       1.619      1.619  \n",
       "98         2   8.648       1.643      1.643  \n",
       "185        2   8.407       1.804      1.804  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "t_start = 0\n",
    "t_end = 24\n",
    "min_duration = 5\n",
    "n_stages = 2\n",
    "combis = list(itertools.product([0, 1], [0, 1]))  \n",
    "den=4\n",
    "\n",
    "MSP_2Stage = msp.do_brute_force_num(combis=combis,                  # list of combinations to test\n",
    "                                    models=models,                  # list with model functions\n",
    "                                    n_stages=n_stages,              # maximum of stages to test\n",
    "                                    t_start=t_start,                # start time\n",
    "                                    t_end=t_end,                    # end time\n",
    "                                    min_duration=min_duration,      # minimal duration of one phase\n",
    "                                    s=s,                            # initial values of species\n",
    "                                    events=[event_sub0],            # event function for denoting real end time of fermentation (here when no substrate is present anymore; in other use cases different)\n",
    "                                    density=den,                    # density or step time (how frequent the switching times are sampled -> see for more information OptMSP_SupportFunctions.ipynb notebook)\n",
    "                                    indexes=[X, S, P])              # indexes \n",
    "\n",
    "display(MSP_2Stage.sort_values([\"Vol_P\"], ascending=[False]).dropna(axis=0).drop_duplicates(subset=\"Models\", keep=\"first\")[:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test Optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Fevals:          ppar:            bw:            dx:            df:      Violated:    Viol. Norm:        ideal1:\n",
      "      1         0.3564       0.891251        2.81321        1.39567              0              0       -9.54854\n",
      "     51         0.6764     0.00281838        15.8693    1.26135e-05              0              0       -9.54855\n"
     ]
    }
   ],
   "source": [
    "## 1.) Volumetric productivity\n",
    "def volprod(simulation, indexes, initial_values, tstart, tend):\n",
    "    return simulation[P]/(simulation[-2]-tstart)\n",
    "\n",
    "## 2.) Define the algorithm that will be used (in our case IHS) with the number of generations (fitness function evaluations) and a seed for reproducibility\n",
    "# Note: per default there are always 10 evaluations so the total number of fitness function evaluations is 10 + the number of you pass to the gen attribute\n",
    "algo_ihs = algorithm(ihs(gen=100, seed=12345))  \n",
    "algo_ihs.set_verbosity(50)  # output best performing each 50th generation\n",
    "\n",
    "## 3.) Define optimization problem\n",
    "# Defining the problem through creating a msp.Optimizer object\n",
    "problem_sim_volP = problem(\n",
    "    decorator_problem(\n",
    "        msp.Optimizer(\n",
    "            s=s,                                # initial values of species\n",
    "            models=models,                      # list of functions of the models \n",
    "            indexes=[X, S, P],                  # indexes to denote at which position in the model are biomass, substrate and product (default is [0,1,2]; -> see for more information ModelingTutorial.ipynb notebook)\n",
    "            tstart=0,                           # start time of process\n",
    "            tend=24,                            # end time of process\n",
    "            max_stage=2,                        # The maximum stages the user wants to test out (optimal solution might turn out to not have as many stages)\n",
    "            min_duration=1,                     # minimal duration of each sub-process/module\n",
    "            objective=volprod,                  # Objective function \n",
    "            optmod=\"max\",                       # Maximization or minimization? (\"max\" or \"min\")\n",
    "            calc_option=msp.numeric_option,     # Numeric models as imput\n",
    "            events=[event_sub0],                # event function for denoting real end time of fermentation (here when no substrate is present anymore; in other use cases different)\n",
    "        ),\n",
    "        fitness_decorator=msp.f_log_decor,\n",
    "    )\n",
    ")\n",
    "# Define a relative tolerance that \n",
    "problem_sim_volP.c_tol = 1e-3\n",
    "\n",
    "## 4.) Starting the optimization\n",
    "res_opt = algo_ihs.evolve(population(problem_sim_volP, size=10, seed=12345))  # start with 10 candidate solutions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No constraints found.\n"
     ]
    }
   ],
   "source": [
    "# 1) Extract the log out of the optimization object (we exclude the first row since this is a initialization row and does not have the same format as the other rows):\n",
    "log = pd.DataFrame(res_opt.problem.extract(decorator_problem).dv_log)[1:] \n",
    "\n",
    "# 2) Do extraction for the number of best combinations you choose:\n",
    "best_res = msp.do_opt_to_df(  df=log,     # log dataframe from optimization\n",
    "                                n_best=1)  # Number of best performing processes that are returned\n",
    "\n",
    "# 3) Convert the solutions from best_res_num into the same format as in the brute force solution dataframe:\n",
    "df=msp.do_convert(opt_res=best_res,             # Output from do_opt_to_df()\n",
    "                    models_num=models,          # models (in numeric form)\n",
    "                    t_start=0, \n",
    "                    t_end=20, \n",
    "                    s=s, \n",
    "                    events=[event_sub0], \n",
    "                    indexes=[X, S, P])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "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 th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Index</th>\n",
       "      <th>Times</th>\n",
       "      <th>Models</th>\n",
       "      <th>End_T</th>\n",
       "      <th>End_X</th>\n",
       "      <th>End_S</th>\n",
       "      <th>End_P</th>\n",
       "      <th>finished</th>\n",
       "      <th>Vol_P</th>\n",
       "      <th>Y_SubInput</th>\n",
       "      <th>Y_SubUsed</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>[0.0, 7.989, 20.0]</td>\n",
       "      <td>[1, 2]</td>\n",
       "      <td>17.015</td>\n",
       "      <td>0.486</td>\n",
       "      <td>0.0</td>\n",
       "      <td>176.239</td>\n",
       "      <td>2</td>\n",
       "      <td>10.358</td>\n",
       "      <td>1.762</td>\n",
       "      <td>1.762</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Index               Times  Models   End_T  End_X  End_S    End_P finished  \\\n",
       "0      1  [0.0, 7.989, 20.0]  [1, 2]  17.015  0.486    0.0  176.239        2   \n",
       "\n",
       "    Vol_P  Y_SubInput  Y_SubUsed  \n",
       "0  10.358       1.762      1.762  "
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array and two offsets from the bottom left corner of the image\n",
      "  alpha: scalar or None\n",
      "  animated: bool\n",
      "  backgroundcolor: color\n",
      "  bbox: dict with properties for `.patches.FancyBboxPatch`\n",
      "  clip_box: `.Bbox`\n",
      "  clip_on: bool\n",
      "  clip_path: Patch or (Path, Transform) or None\n",
      "  color or c: color\n",
      "  figure: `.Figure`\n",
      "  fontfamily or family: {FONTNAME, 'serif', 'sans-serif', 'cursive', 'fantasy', 'monospace'}\n",
      "  fontproperties or font or font_properties: `.font_manager.FontProperties` or `str` or `pathlib.Path`\n",
      "  fontsize or size: float or {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}\n",
      "  fontstretch or stretch: {a numeric value in range 0-1000, 'ultra-condensed', 'extra-condensed', 'condensed', 'semi-condensed', 'normal', 'semi-expanded', 'expanded', 'extra-expanded', 'ultra-expanded'}\n",
      "  fontstyle or style: {'normal', 'italic', 'oblique'}\n",
      "  fontvariant or variant: {'normal', 'small-caps'}\n",
      "  fontweight or weight: {a numeric value in range 0-1000, 'ultralight', 'light', 'normal', 'regular', 'book', 'medium', 'roman', 'semibold', 'demibold', 'demi', 'bold', 'heavy', 'extra bold', 'black'}\n",
      "  gid: str\n",
      "  horizontalalignment or ha: {'left', 'center', 'right'}\n",
      "  in_layout: bool\n",
      "  label: object\n",
      "  linespacing: float (multiple of font size)\n",
      "  math_fontfamily: str\n",
      "  mouseover: bool\n",
      "  multialignment or ma: {'left', 'right', 'center'}\n",
      "  parse_math: bool\n",
      "  path_effects: `.AbstractPathEffect`\n",
      "  picker: None or bool or float or callable\n",
      "  position: (float, float)\n",
      "  rasterized: bool\n",
      "  rotation: float or {'vertical', 'horizontal'}\n",
      "  rotation_mode: {None, 'default', 'anchor'}\n",
      "  sketch_params: (scale: float, length: float, randomness: float)\n",
      "  snap: bool or None\n",
      "  text: object\n",
      "  transform: `.Transform`\n",
      "  transform_rotates_text: bool\n",
      "  url: str\n",
      "  usetex: bool or None\n",
      "  verticalalignment or va: {'bottom', 'baseline', 'center', 'center_baseline', 'top'}\n",
      "  visible: bool\n",
      "  wrap: bool\n",
      "  x: float\n",
      "  y: float\n",
      "  zorder: float\n",
      "  agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array and two offsets from the bottom left corner of the image\n",
      "  alpha: scalar or None\n",
      "  animated: bool\n",
      "  backgroundcolor: color\n",
      "  bbox: dict with properties for `.patches.FancyBboxPatch`\n",
      "  clip_box: `.Bbox`\n",
      "  clip_on: bool\n",
      "  clip_path: Patch or (Path, Transform) or None\n",
      "  color or c: color\n",
      "  figure: `.Figure`\n",
      "  fontfamily or family: {FONTNAME, 'serif', 'sans-serif', 'cursive', 'fantasy', 'monospace'}\n",
      "  fontproperties or font or font_properties: `.font_manager.FontProperties` or `str` or `pathlib.Path`\n",
      "  fontsize or size: float or {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}\n",
      "  fontstretch or stretch: {a numeric value in range 0-1000, 'ultra-condensed', 'extra-condensed', 'condensed', 'semi-condensed', 'normal', 'semi-expanded', 'expanded', 'extra-expanded', 'ultra-expanded'}\n",
      "  fontstyle or style: {'normal', 'italic', 'oblique'}\n",
      "  fontvariant or variant: {'normal', 'small-caps'}\n",
      "  fontweight or weight: {a numeric value in range 0-1000, 'ultralight', 'light', 'normal', 'regular', 'book', 'medium', 'roman', 'semibold', 'demibold', 'demi', 'bold', 'heavy', 'extra bold', 'black'}\n",
      "  gid: str\n",
      "  horizontalalignment or ha: {'left', 'center', 'right'}\n",
      "  in_layout: bool\n",
      "  label: object\n",
      "  linespacing: float (multiple of font size)\n",
      "  math_fontfamily: str\n",
      "  mouseover: bool\n",
      "  multialignment or ma: {'left', 'right', 'center'}\n",
      "  parse_math: bool\n",
      "  path_effects: `.AbstractPathEffect`\n",
      "  picker: None or bool or float or callable\n",
      "  position: (float, float)\n",
      "  rasterized: bool\n",
      "  rotation: float or {'vertical', 'horizontal'}\n",
      "  rotation_mode: {None, 'default', 'anchor'}\n",
      "  sketch_params: (scale: float, length: float, randomness: float)\n",
      "  snap: bool or None\n",
      "  text: object\n",
      "  transform: `.Transform`\n",
      "  transform_rotates_text: bool\n",
      "  url: str\n",
      "  usetex: bool or None\n",
      "  verticalalignment or va: {'bottom', 'baseline', 'center', 'center_baseline', 'top'}\n",
      "  visible: bool\n",
      "  wrap: bool\n",
      "  x: float\n",
      "  y: float\n",
      "  zorder: float\n",
      "  agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array and two offsets from the bottom left corner of the image\n",
      "  alpha: scalar or None\n",
      "  animated: bool\n",
      "  backgroundcolor: color\n",
      "  bbox: dict with properties for `.patches.FancyBboxPatch`\n",
      "  clip_box: `.Bbox`\n",
      "  clip_on: bool\n",
      "  clip_path: Patch or (Path, Transform) or None\n",
      "  color or c: color\n",
      "  figure: `.Figure`\n",
      "  fontfamily or family: {FONTNAME, 'serif', 'sans-serif', 'cursive', 'fantasy', 'monospace'}\n",
      "  fontproperties or font or font_properties: `.font_manager.FontProperties` or `str` or `pathlib.Path`\n",
      "  fontsize or size: float or {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}\n",
      "  fontstretch or stretch: {a numeric value in range 0-1000, 'ultra-condensed', 'extra-condensed', 'condensed', 'semi-condensed', 'normal', 'semi-expanded', 'expanded', 'extra-expanded', 'ultra-expanded'}\n",
      "  fontstyle or style: {'normal', 'italic', 'oblique'}\n",
      "  fontvariant or variant: {'normal', 'small-caps'}\n",
      "  fontweight or weight: {a numeric value in range 0-1000, 'ultralight', 'light', 'normal', 'regular', 'book', 'medium', 'roman', 'semibold', 'demibold', 'demi', 'bold', 'heavy', 'extra bold', 'black'}\n",
      "  gid: str\n",
      "  horizontalalignment or ha: {'left', 'center', 'right'}\n",
      "  in_layout: bool\n",
      "  label: object\n",
      "  linespacing: float (multiple of font size)\n",
      "  math_fontfamily: str\n",
      "  mouseover: bool\n",
      "  multialignment or ma: {'left', 'right', 'center'}\n",
      "  parse_math: bool\n",
      "  path_effects: `.AbstractPathEffect`\n",
      "  picker: None or bool or float or callable\n",
      "  position: (float, float)\n",
      "  rasterized: bool\n",
      "  rotation: float or {'vertical', 'horizontal'}\n",
      "  rotation_mode: {None, 'default', 'anchor'}\n",
      "  sketch_params: (scale: float, length: float, randomness: float)\n",
      "  snap: bool or None\n",
      "  text: object\n",
      "  transform: `.Transform`\n",
      "  transform_rotates_text: bool\n",
      "  url: str\n",
      "  usetex: bool or None\n",
      "  verticalalignment or va: {'bottom', 'baseline', 'center', 'center_baseline', 'top'}\n",
      "  visible: bool\n",
      "  wrap: bool\n",
      "  x: float\n",
      "  y: float\n",
      "  zorder: float\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<module 'matplotlib.pyplot' from '/home/jbauer/miniconda3/envs/twostage/lib/python3.8/site-packages/matplotlib/pyplot.py'>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x1500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "msp.do_custom_plot(df=df, \n",
    "                   models_num=models, \n",
    "                   s=s, \n",
    "                   title=\"Title\",\n",
    "                   events=[event_sub0],\n",
    "                   indexes=[X,S,P])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Change the yield calculations and plotting to substrate 2 and product 2\n",
    "\n",
    "Also if you want make the end of integration (the event function) now dependent on substrate 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "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 th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Index</th>\n",
       "      <th>Times</th>\n",
       "      <th>Models</th>\n",
       "      <th>End_T</th>\n",
       "      <th>End_X</th>\n",
       "      <th>End_S</th>\n",
       "      <th>End_P</th>\n",
       "      <th>finished</th>\n",
       "      <th>Vol_P</th>\n",
       "      <th>Y_SubInput</th>\n",
       "      <th>Y_SubUsed</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>355</th>\n",
       "      <td>356</td>\n",
       "      <td>(0.0, 23.0, 24.0)</td>\n",
       "      <td>[2, 2]</td>\n",
       "      <td>24.0</td>\n",
       "      <td>0.362</td>\n",
       "      <td>368.768</td>\n",
       "      <td>743.744</td>\n",
       "      <td>inf</td>\n",
       "      <td>30.989</td>\n",
       "      <td>1.487</td>\n",
       "      <td>5.667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>265</th>\n",
       "      <td>266</td>\n",
       "      <td>(0.0, 22.75, 24.0)</td>\n",
       "      <td>[2, 1]</td>\n",
       "      <td>24.0</td>\n",
       "      <td>0.362</td>\n",
       "      <td>368.768</td>\n",
       "      <td>743.744</td>\n",
       "      <td>inf</td>\n",
       "      <td>30.989</td>\n",
       "      <td>1.487</td>\n",
       "      <td>5.667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>89</th>\n",
       "      <td>90</td>\n",
       "      <td>(0.0, 1.0, 24.0)</td>\n",
       "      <td>[1, 2]</td>\n",
       "      <td>24.0</td>\n",
       "      <td>0.372</td>\n",
       "      <td>369.426</td>\n",
       "      <td>743.204</td>\n",
       "      <td>inf</td>\n",
       "      <td>30.967</td>\n",
       "      <td>1.486</td>\n",
       "      <td>5.692</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>(0.0, 1.25, 24.0)</td>\n",
       "      <td>[1, 1]</td>\n",
       "      <td>24.0</td>\n",
       "      <td>0.906</td>\n",
       "      <td>407.006</td>\n",
       "      <td>712.399</td>\n",
       "      <td>inf</td>\n",
       "      <td>29.683</td>\n",
       "      <td>1.425</td>\n",
       "      <td>7.661</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     Index               Times  Models  End_T  End_X    End_S    End_P  \\\n",
       "355    356   (0.0, 23.0, 24.0)  [2, 2]   24.0  0.362  368.768  743.744   \n",
       "265    266  (0.0, 22.75, 24.0)  [2, 1]   24.0  0.362  368.768  743.744   \n",
       "89      90    (0.0, 1.0, 24.0)  [1, 2]   24.0  0.372  369.426  743.204   \n",
       "1        2   (0.0, 1.25, 24.0)  [1, 1]   24.0  0.906  407.006  712.399   \n",
       "\n",
       "    finished   Vol_P  Y_SubInput  Y_SubUsed  \n",
       "355      inf  30.989       1.487      5.667  \n",
       "265      inf  30.989       1.487      5.667  \n",
       "89       inf  30.967       1.486      5.692  \n",
       "1        inf  29.683       1.425      7.661  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def event_sub0_2(t,y):\n",
    "    if(y[S2] <= 0.001): # <- CHANGE HERE THE INDEX\n",
    "        return 0    \n",
    "    return 1\n",
    "\n",
    "t_start = 0\n",
    "t_end = 24\n",
    "min_duration = 1\n",
    "n_stages = 2\n",
    "combis = list(itertools.product([0, 1], [0, 1]))  \n",
    "den=4\n",
    "\n",
    "MSP_2Stage = msp.do_brute_force_num(combis=combis,                  \n",
    "                                    models=models,               \n",
    "                                    n_stages=n_stages,           \n",
    "                                    t_start=t_start,          \n",
    "                                    t_end=t_end,         \n",
    "                                    min_duration=min_duration,   \n",
    "                                    s=s,                         \n",
    "                                    events=[event_sub0_2],           \n",
    "                                    density=den,                \n",
    "                                    indexes=[X, S2, P2]) # <- CHANGE HERE THE INDEXES \n",
    "\n",
    "display(MSP_2Stage.sort_values([\"Vol_P\"], ascending=[False]).dropna(axis=0).drop_duplicates(subset=\"Models\", keep=\"first\")[:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Fevals:          ppar:            bw:            dx:            df:      Violated:    Viol. Norm:        ideal1:\n",
      "      1        0.35064       0.988553        15.5613        1.30604              0              0       -30.9893\n",
      "     51        0.38264       0.555904        15.1325    3.75279e-06              0              0       -30.9893\n",
      "    101        0.41464       0.312608        10.4275    5.46369e-06              0              0       -30.9893\n",
      "    151        0.44664       0.175792              0              0              0              0       -30.9893\n",
      "    201        0.47864      0.0988553              0              0              0              0       -30.9893\n",
      "    251        0.51064      0.0555904              0              0              0              0       -30.9893\n",
      "    301        0.54264      0.0312608              0              0              0              0       -30.9893\n",
      "    351        0.57464      0.0175792       0.308301    4.97381e-07              0              0       -30.9894\n",
      "    401        0.60664     0.00988553       0.658172    3.75635e-07              0              0       -30.9894\n",
      "    451        0.63864     0.00555904       0.159996     1.9507e-07              0              0       -30.9894\n",
      "    501        0.67064     0.00312608       0.159996     1.9507e-07              0              0       -30.9894\n",
      "    551        0.70264     0.00175792              0              0              0              0       -30.9894\n",
      "    601        0.73464    0.000988553              0              0              0              0       -30.9894\n",
      "    651        0.76664    0.000555904              0              0              0              0       -30.9894\n",
      "    701        0.79864    0.000312608              0              0              0              0       -30.9894\n",
      "    751        0.83064    0.000175792              0              0              0              0       -30.9894\n",
      "    801        0.86264    9.88553e-05              0              0              0              0       -30.9894\n",
      "    851        0.89464    5.55904e-05     0.00109485    8.61481e-08              0              0       -30.9894\n",
      "    901        0.92664    3.12608e-05     0.00109485    8.61481e-08              0              0       -30.9894\n",
      "    951        0.95864    1.75792e-05     0.00109485    8.61481e-08              0              0       -30.9894\n",
      "No constraints found.\n"
     ]
    }
   ],
   "source": [
    "## 1.) \n",
    "def volprod(simulation, indexes, initial_values, tstart, tend):\n",
    "    return simulation[P2]/(simulation[-2]-tstart)                    # <- CHANGE HERE THE INDEX\n",
    "\n",
    "## 2.) \n",
    "algo_ihs = algorithm(ihs(gen=1000, seed=12345))  \n",
    "algo_ihs.set_verbosity(50)  \n",
    "\n",
    "## 3.) \n",
    "problem_sim_volP = problem(\n",
    "    decorator_problem(\n",
    "        msp.Optimizer(\n",
    "            s=s,                                \n",
    "            models=models,                      \n",
    "            indexes=[X, S2, P2], # <- CHANGE HERE THE INDEXES                 \n",
    "            tstart=0,                         \n",
    "            tend=24,                            \n",
    "            max_stage=2,                       \n",
    "            min_duration=1,         \n",
    "            objective=volprod,             \n",
    "            optmod=\"max\",                     \n",
    "            calc_option=msp.numeric_option,    \n",
    "            events=[event_sub0_2],      # <- CHANGE HERE FUNCTION       \n",
    "        ),\n",
    "        fitness_decorator=msp.f_log_decor,\n",
    "    )\n",
    ")\n",
    " \n",
    "problem_sim_volP.c_tol = 1e-3\n",
    "\n",
    "## 4.) \n",
    "res_opt = algo_ihs.evolve(population(problem_sim_volP, size=10, seed=12345))  \n",
    "\n",
    "log = pd.DataFrame(res_opt.problem.extract(decorator_problem).dv_log)[1:] \n",
    "best_res = msp.do_opt_to_df(  df=log,     \n",
    "                                n_best=1) \n",
    "df=msp.do_convert(opt_res=best_res,\n",
    "                    models_num=models,\n",
    "                    t_start=0, \n",
    "                    t_end=20, \n",
    "                    s=s, \n",
    "                    events=[event_sub0_2],  # <- CHANGE HERE FUNCTION\n",
    "                    indexes=[X, S2, P2])     # <- CHANGE HERE THE INDEXES   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "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 th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Index</th>\n",
       "      <th>Times</th>\n",
       "      <th>Models</th>\n",
       "      <th>End_T</th>\n",
       "      <th>End_X</th>\n",
       "      <th>End_S</th>\n",
       "      <th>End_P</th>\n",
       "      <th>finished</th>\n",
       "      <th>Vol_P</th>\n",
       "      <th>Y_SubInput</th>\n",
       "      <th>Y_SubUsed</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>[0.0, 14.306, 20.0]</td>\n",
       "      <td>[2, 2]</td>\n",
       "      <td>20.0</td>\n",
       "      <td>0.332</td>\n",
       "      <td>383.994</td>\n",
       "      <td>738.669</td>\n",
       "      <td>inf</td>\n",
       "      <td>36.933</td>\n",
       "      <td>1.477</td>\n",
       "      <td>6.368</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Index                Times  Models  End_T  End_X    End_S    End_P  \\\n",
       "0      1  [0.0, 14.306, 20.0]  [2, 2]   20.0  0.332  383.994  738.669   \n",
       "\n",
       "  finished   Vol_P  Y_SubInput  Y_SubUsed  \n",
       "0      inf  36.933       1.477      6.368  "
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Change objective function to yield"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "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 th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Index</th>\n",
       "      <th>Times</th>\n",
       "      <th>Models</th>\n",
       "      <th>End_T</th>\n",
       "      <th>End_X</th>\n",
       "      <th>End_S</th>\n",
       "      <th>End_P</th>\n",
       "      <th>finished</th>\n",
       "      <th>Vol_P</th>\n",
       "      <th>Y_SubInput</th>\n",
       "      <th>Y_SubUsed</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>295</th>\n",
       "      <td>296</td>\n",
       "      <td>(0.0, 21.5, 24.0)</td>\n",
       "      <td>[2, 2]</td>\n",
       "      <td>21.463</td>\n",
       "      <td>0.362</td>\n",
       "      <td>0.001</td>\n",
       "      <td>180.445</td>\n",
       "      <td>1</td>\n",
       "      <td>8.407</td>\n",
       "      <td>1.804</td>\n",
       "      <td>1.804</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>212</th>\n",
       "      <td>213</td>\n",
       "      <td>(0.0, 21.5, 24.0)</td>\n",
       "      <td>[2, 1]</td>\n",
       "      <td>21.463</td>\n",
       "      <td>0.362</td>\n",
       "      <td>0.001</td>\n",
       "      <td>180.445</td>\n",
       "      <td>1</td>\n",
       "      <td>8.407</td>\n",
       "      <td>1.804</td>\n",
       "      <td>1.804</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>65</th>\n",
       "      <td>66</td>\n",
       "      <td>(0.0, 1.0, 24.0)</td>\n",
       "      <td>[1, 2]</td>\n",
       "      <td>20.721</td>\n",
       "      <td>0.372</td>\n",
       "      <td>0.001</td>\n",
       "      <td>180.125</td>\n",
       "      <td>2</td>\n",
       "      <td>8.693</td>\n",
       "      <td>1.801</td>\n",
       "      <td>1.801</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>23</td>\n",
       "      <td>(0.0, 6.5, 24.0)</td>\n",
       "      <td>[1, 1]</td>\n",
       "      <td>16.952</td>\n",
       "      <td>0.906</td>\n",
       "      <td>0.001</td>\n",
       "      <td>161.871</td>\n",
       "      <td>2</td>\n",
       "      <td>9.549</td>\n",
       "      <td>1.619</td>\n",
       "      <td>1.619</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     Index              Times  Models   End_T  End_X  End_S    End_P finished  \\\n",
       "295    296  (0.0, 21.5, 24.0)  [2, 2]  21.463  0.362  0.001  180.445        1   \n",
       "212    213  (0.0, 21.5, 24.0)  [2, 1]  21.463  0.362  0.001  180.445        1   \n",
       "65      66   (0.0, 1.0, 24.0)  [1, 2]  20.721  0.372  0.001  180.125        2   \n",
       "22      23   (0.0, 6.5, 24.0)  [1, 1]  16.952  0.906  0.001  161.871        2   \n",
       "\n",
       "     Vol_P  Y_SubInput  Y_SubUsed  \n",
       "295  8.407       1.804      1.804  \n",
       "212  8.407       1.804      1.804  \n",
       "65   8.693       1.801      1.801  \n",
       "22   9.549       1.619      1.619  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "t_start = 0\n",
    "t_end = 24\n",
    "min_duration = 1\n",
    "n_stages = 2\n",
    "combis = list(itertools.product([0, 1], [0, 1]))  \n",
    "den=4\n",
    "\n",
    "MSP_2Stage = msp.do_brute_force_num(combis=combis,                  \n",
    "                                    models=models,               \n",
    "                                    n_stages=n_stages,           \n",
    "                                    t_start=t_start,          \n",
    "                                    t_end=t_end,         \n",
    "                                    min_duration=min_duration,   \n",
    "                                    s=s,                         \n",
    "                                    events=[event_sub0],           \n",
    "                                    density=den,                \n",
    "                                    indexes=[X, S, P]) \n",
    "\n",
    "## Change in Brute force only the way you filter the end dataframe (here now filtered after yield (Y_SubInput)): \n",
    "display(MSP_2Stage.sort_values([\"Y_SubInput\"], ascending=[False]).dropna(axis=0).drop_duplicates(subset=\"Models\", keep=\"first\")[:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Fevals:          ppar:            bw:            dx:            df:      Violated:    Viol. Norm:        ideal1:\n",
      "      1        0.35064       0.988553        7.29266       0.185739              0              0       -1.80446\n",
      "     51        0.38264       0.555904        6.12079    4.21885e-15              0              0       -1.80446\n",
      "    101        0.41464       0.312608              0              0              0              0       -1.80446\n",
      "    151        0.44664       0.175792              0              0              0              0       -1.80446\n",
      "    201        0.47864      0.0988553              0              0              0              0       -1.80446\n",
      "    251        0.51064      0.0555904              0              0              0              0       -1.80446\n",
      "    301        0.54264      0.0312608              0              0              0              0       -1.80446\n",
      "    351        0.57464      0.0175792              0              0              0              0       -1.80446\n",
      "    401        0.60664     0.00988553       0.117843    3.10862e-15              0              0       -1.80446\n",
      "    451        0.63864     0.00555904       0.117843    3.10862e-15              0              0       -1.80446\n",
      "    501        0.67064     0.00312608              0              0              0              0       -1.80446\n",
      "    551        0.70264     0.00175792              0              0              0              0       -1.80446\n",
      "    601        0.73464    0.000988553              0              0              0              0       -1.80446\n",
      "    651        0.76664    0.000555904              0              0              0              0       -1.80446\n",
      "    701        0.79864    0.000312608              0              0              0              0       -1.80446\n",
      "    751        0.83064    0.000175792              0              0              0              0       -1.80446\n",
      "    801        0.86264    9.88553e-05              0              0              0              0       -1.80446\n",
      "    851        0.89464    5.55904e-05              0              0              0              0       -1.80446\n",
      "    901        0.92664    3.12608e-05              0              0              0              0       -1.80446\n",
      "    951        0.95864    1.75792e-05              0              0              0              0       -1.80446\n",
      "No constraints found.\n"
     ]
    },
    {
     "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 th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Index</th>\n",
       "      <th>Times</th>\n",
       "      <th>Models</th>\n",
       "      <th>End_T</th>\n",
       "      <th>End_X</th>\n",
       "      <th>End_S</th>\n",
       "      <th>End_P</th>\n",
       "      <th>finished</th>\n",
       "      <th>Vol_P</th>\n",
       "      <th>Y_SubInput</th>\n",
       "      <th>Y_SubUsed</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>[0.0, 3.223, 20.0]</td>\n",
       "      <td>[2, 2]</td>\n",
       "      <td>20.0</td>\n",
       "      <td>0.332</td>\n",
       "      <td>383.994</td>\n",
       "      <td>738.669</td>\n",
       "      <td>inf</td>\n",
       "      <td>36.933</td>\n",
       "      <td>1.477</td>\n",
       "      <td>6.368</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Index               Times  Models  End_T  End_X    End_S    End_P finished  \\\n",
       "0      1  [0.0, 3.223, 20.0]  [2, 2]   20.0  0.332  383.994  738.669      inf   \n",
       "\n",
       "    Vol_P  Y_SubInput  Y_SubUsed  \n",
       "0  36.933       1.477      6.368  "
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## 1.) \n",
    "def product_yield(simulation, indexes, initial_values, tstart, tend):   # HERE NEW OBJECTIVE FUNCTION\n",
    "    return simulation[P]/(initial_values[S]-simulation[S])              \n",
    "\n",
    "## 2.) \n",
    "algo_ihs = algorithm(ihs(gen=1000, seed=12345))  \n",
    "algo_ihs.set_verbosity(50)  \n",
    "\n",
    "## 3.) \n",
    "problem_sim_volP = problem(\n",
    "    decorator_problem(\n",
    "        msp.Optimizer(\n",
    "            s=s,                                \n",
    "            models=models,                      \n",
    "            indexes=[X, S, P],     \n",
    "            tstart=0,                         \n",
    "            tend=24,                            \n",
    "            max_stage=2,                       \n",
    "            min_duration=1,         \n",
    "            objective=product_yield,    # <- HERE ADD NEW OBJECTIVE FUNCTION     \n",
    "            optmod=\"max\",                     \n",
    "            calc_option=msp.numeric_option,    \n",
    "            events=[event_sub0],            \n",
    "        ),\n",
    "        fitness_decorator=msp.f_log_decor,\n",
    "    )\n",
    ")\n",
    "problem_sim_volP.c_tol = 1e-3\n",
    "\n",
    "## 4.) \n",
    "res_opt = algo_ihs.evolve(population(problem_sim_volP, size=10, seed=12345))  \n",
    "\n",
    "log = pd.DataFrame(res_opt.problem.extract(decorator_problem).dv_log)[1:] \n",
    "best_res = msp.do_opt_to_df(  df=log,     \n",
    "                                n_best=1) \n",
    "df=msp.do_convert(opt_res=best_res,\n",
    "                    models_num=models,\n",
    "                    t_start=0, \n",
    "                    t_end=20, \n",
    "                    s=s, \n",
    "                    events=[event_sub0], \n",
    "                    indexes=[X, S2, P2])     # <- CHANGE HERE THE INDEXES   \n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For other possible implementations of models and corresponding optimizations see the case studies:\n",
    "\n",
    "- CaseStudy_gotsmy2023: Optimization for volumetric productivity in a fed batch setup\n",
    "- CaseStudy_klamt2018: Optimization for volumetric productivity with yield constraint (also incorporates the option with auxiliary variables!)\n",
    "- CaseStudy_wichmann2023: Optimization for volumetric productivity with 3-stage implementation\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "twostage",
   "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.8.15"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}