099_debug.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "noted-barbados",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "%pylab is deprecated, use %matplotlib inline and import the required libraries.\n",
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "%pylab inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "suffering-associate",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pyndamics3  version  0.0.31\n"
     ]
    }
   ],
   "source": [
    "from pyndamics3 import Simulation\n",
    "from pyndamics3.fit import fit,Parameter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "moving-circuit",
   "metadata": {},
   "outputs": [],
   "source": [
    "import lmfit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eligible-income",
   "metadata": {},
   "outputs": [],
   "source": [
    "t=array([7,14,21,28,35,42,49,56,63,70,77,84],float)\n",
    "h=array([17.93,36.36,67.76,98.10,131,169.5,205.5,228.3,247.1,250.5,253.8,254.5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "saving-galaxy",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 864x576 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sim=Simulation()\n",
    "sim.add(\"h'=a\",1,plot=True)\n",
    "sim.add_data(t=t,h=h,plot=True)\n",
    "sim.params(a=1)\n",
    "sim.run(0,90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "extended-george",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<h2>Fit Statistics</h2><table><tr><td>fitting method</td><td>leastsq</td><td></td></tr><tr><td># function evals</td><td>12</td><td></td></tr><tr><td># data points</td><td>12</td><td></td></tr><tr><td># variables</td><td>2</td><td></td></tr><tr><td>chi-square</td><td> 5339.27222</td><td></td></tr><tr><td>reduced chi-square</td><td> 533.927222</td><td></td></tr><tr><td>Akaike info crit.</td><td> 77.1752558</td><td></td></tr><tr><td>Bayesian info crit.</td><td> 78.1450691</td><td></td></tr></table><h2>Variables</h2><table><tr><th> name </th><th> value </th><th> standard error </th><th> relative error </th><th> initial value </th><th> min </th><th> max </th><th> vary </th></tr><tr><td> a </td><td>  3.45220277 </td><td>  0.27604199 </td><td> (8.00%) </td><td> 1 </td><td>  0.00000000 </td><td>         inf </td><td> True </td></tr><tr><td> initial_h </td><td>  6.28727440 </td><td>  14.2212935 </td><td> (226.19%) </td><td> 10 </td><td>  0.00000000 </td><td>         inf </td><td> True </td></tr></table><h2>Correlations (unreported correlations are < 0.100)</h2><table><tr><td>a</td><td>initial_h</td><td>-0.8832</td></tr></table>"
      ],
      "text/plain": [
       "<lmfit.minimizer.MinimizerResult>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results=fit(sim,\n",
    "   Parameter('a',value=1,min=0),\n",
    "   Parameter('initial_h',value=10,min=0))\n",
    "\n",
    "results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "demographic-alloy",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "%pylab is deprecated, use %matplotlib inline and import the required libraries.\n",
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "%pylab inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91c4fdd4-0254-4513-b780-2a06aa8d7810",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyndamics3 import Struct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c002661-9b61-4d46-b12a-cbc9e18554a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# copied from http://be150.caltech.edu/2018/handouts/l12_stochastic_simulation.html\n",
    "\n",
    "import numba\n",
    "\n",
    "@numba.jit(nopython=True)\n",
    "def _sample_discrete(probs, probs_sum):\n",
    "    q = np.random.rand() * probs_sum\n",
    "\n",
    "    i = 0\n",
    "    p_sum = 0.0\n",
    "    while p_sum < q:\n",
    "        p_sum += probs[i]\n",
    "        i += 1\n",
    "    return i - 1\n",
    "\n",
    "\n",
    "class Stochastic_Simulation(object):\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.components=[]\n",
    "        self.equations=[]\n",
    "        self.initial_values={}\n",
    "        self.current_values={}\n",
    "        self.ν=None\n",
    "        self.state_change_strings=[]\n",
    "        self.rate_equations=[]\n",
    "        self.quasi=[]\n",
    "        self._params={}\n",
    "        self._params_keys=()\n",
    "        self._params_vals=()\n",
    "    \n",
    "    def params(self,**kwargs):\n",
    "        self._params.update(kwargs)\n",
    "        self._params_keys=tuple(self._params.keys())\n",
    "        self._params_vals=tuple([self._params[_] for _ in self._params_keys])\n",
    "        \n",
    "    def add(self,component_change_equation,rate_equation=None,plot=False,quasi=None,**kwargs):\n",
    "        \n",
    "        \n",
    "        if \"=\" in component_change_equation:\n",
    "            self.equations.append(component_change_equation)\n",
    "            return \n",
    "        \n",
    "        component_change_equation=component_change_equation.replace('+',' +')\n",
    "        component_change_equation=component_change_equation.replace('-',' -')\n",
    "        \n",
    "        parts=component_change_equation.split()\n",
    "        for part in parts:\n",
    "            if not (part.startswith('-') or part.startswith('+')):\n",
    "                raise SyntaxError(\"State change strings must start with + or -: %s\" % component_change_equation)\n",
    "            name=part[1:]\n",
    "            if name not in self.components:\n",
    "                self.components.append(name)\n",
    "            \n",
    "        self.state_change_strings.append(component_change_equation)            \n",
    "        self.rate_equations.append(rate_equation)\n",
    "        self.initial_values.update(kwargs)\n",
    "        self.current_values.update(kwargs)\n",
    "        self.quasi.append(quasi)\n",
    "\n",
    "    def initialize(self):\n",
    "        import numba\n",
    "        import numpy as np\n",
    "        num_components=len(self.components)\n",
    "        num_reactions=len(self.rate_equations)\n",
    "        self.ν=np.zeros((num_reactions,num_components),int)\n",
    "        \n",
    "        for j,(state_change,rate) in enumerate(zip(self.state_change_strings,self.rate_equations)):\n",
    "            parts=state_change.split()\n",
    "            for part in parts:\n",
    "                if not (part.startswith('-') or part.startswith('+')):\n",
    "                    raise SyntaxError(\"State change strings must start with + or -: %s\" % component_change_equation)\n",
    "                name=part[1:]\n",
    "                if part[0]=='-':\n",
    "                    val=-1\n",
    "                else:\n",
    "                    val=+1\n",
    "                \n",
    "                i=self.components.index(name)\n",
    "                self.ν[j,i]=val\n",
    "                    \n",
    "\n",
    "        for c in self.initial_values:\n",
    "            if not c in self.components:\n",
    "                raise ValueError(\"%s not in components values.\" % c)\n",
    "                    \n",
    "        for c in self.components:\n",
    "            if not c in self.initial_values:\n",
    "                raise ValueError(\"%s not in initial values.\" % c)\n",
    "            \n",
    "            \n",
    "        #func_str=\"@numba.jit(nopython=True)\\ndef _propensity_function(population, args):\\n\"\n",
    "        func_str=\"@numba.jit(nopython=True)\\ndef _propensity_function_abcde(population, args):\\n\"\n",
    "\n",
    "        func_str+=\"    \"\n",
    "        \n",
    "        if len(self.components)>1:        \n",
    "            func_str+=\",\".join(self.components) + \" = population\\n\"\n",
    "        else:\n",
    "            func_str+=self.components[0] + \", = population\\n\"\n",
    "                        \n",
    "        if self._params_keys:\n",
    "            func_str+=\"    \"\n",
    "            if len(self._params_keys)>1:        \n",
    "                func_str+=\",\".join(self._params_keys)+ \" = args\\n\"\n",
    "            else:\n",
    "                func_str+=self._params_keys[0]+ \", = args\\n\"\n",
    "            \n",
    "        func_str+=\"    \"+\"\\n\"\n",
    "\n",
    "        for eq in self.equations:\n",
    "            func_str+=\"    \"+eq+\"\\n\"\n",
    "\n",
    "\n",
    "        func_str+=\"    \"+\"\\n\"\n",
    "\n",
    "\n",
    "        func_str+=\"    \"+\"val = np.array([\\n\"\n",
    "        for a in self.rate_equations:\n",
    "            func_str+=\"        \"+a+\",\\n\"\n",
    "        func_str+=\"    \"+\"],float)\\n\"\n",
    "\n",
    "        for qi,q in enumerate(self.quasi):\n",
    "            if not q:\n",
    "                continue\n",
    "                \n",
    "            func_str+=\"    \"+f\"if ({q}):\\n\"\n",
    "            func_str+=\"    \"+\"    \"+f\"val[{qi}]=0\\n\"\n",
    "        \n",
    "            func_str+=\"    \"+f\"if ((A==0) or (B==0)):\\n\"\n",
    "            func_str+=\"    \"+\"    \"+f\"raise ValueError()\\n\"\n",
    "                \n",
    "        \n",
    "        func_str+=\"    \"+\"return val\"\n",
    "        \n",
    "        \n",
    "        self.func_str=func_str\n",
    "            \n",
    "        exec (func_str,globals())                      \n",
    "        self.propensity_function=_propensity_function_abcde\n",
    "        \n",
    "    def run(self,t_max,Nsims=1,num_iterations=1001,):\n",
    "        from tqdm import tqdm\n",
    "        \n",
    "        \n",
    "        if self.ν is None:\n",
    "            self.initialize()\n",
    "\n",
    "        _propensity_function=self.propensity_function\n",
    "        \n",
    "        \n",
    "        @numba.jit(nopython=True)\n",
    "        def _ssa(update, population_0, time_points, args):\n",
    "            # Initialize output\n",
    "            pop_out = np.empty((len(time_points), update.shape[1]), dtype=np.int64)\n",
    "\n",
    "            # Initialize and perform simulation\n",
    "            i_time = 1\n",
    "            i = 0\n",
    "            t = time_points[0]\n",
    "            population = population_0.copy()\n",
    "            pop_out[0,:] = population\n",
    "            extinction_time=-1.0\n",
    "            previous_t=t\n",
    "            while i < len(time_points):\n",
    "                while t < time_points[i_time]:\n",
    "                    # draw the event and time step\n",
    "                    event, dt = _draw(population, args)\n",
    "\n",
    "                    # Update the population\n",
    "                    population_previous = population.copy()\n",
    "                    population += update[event,:]\n",
    "\n",
    "                    # Increment time\n",
    "                    previous_t=t\n",
    "                    t += dt\n",
    "\n",
    "\n",
    "                if dt==1e500 and extinction_time<0.0:\n",
    "                    extinction_time=previous_t\n",
    "\n",
    "                # Update the index (Have to be careful about types for Numba)\n",
    "                i = np.searchsorted((time_points > t).astype(np.int64), 1)\n",
    "\n",
    "                # Update the population\n",
    "                for j in np.arange(i_time, min(i, len(time_points))):\n",
    "                    pop_out[j,:] = population_previous\n",
    "\n",
    "                # Increment index\n",
    "                i_time = i\n",
    "\n",
    "            return pop_out,extinction_time\n",
    "        \n",
    "        @numba.jit(nopython=True)\n",
    "        def _draw(population, args):\n",
    "            \"\"\"\n",
    "            Draws a reaction and the time it took to do that reaction.\n",
    "\n",
    "            Assumes that there is a globally scoped function\n",
    "            `prop_func` that is Numba'd with nopython=True.\n",
    "            \"\"\"\n",
    "            # Compute propensities\n",
    "            props = _propensity_function(population, args)\n",
    "\n",
    "            # Sum of propensities\n",
    "            props_sum = np.sum(props)\n",
    "\n",
    "            if props_sum==0:\n",
    "                time=1e500\n",
    "                rxn=0\n",
    "            else:\n",
    "\n",
    "                # Compute time\n",
    "                time = np.random.exponential(1 / props_sum)\n",
    "\n",
    "                # Draw reaction given propensities\n",
    "                rxn = _sample_discrete(props, props_sum)\n",
    "\n",
    "            return rxn, time\n",
    "\n",
    "        \n",
    "        self.all_storage=[]\n",
    "        \n",
    "        disable=Nsims==1\n",
    "        \n",
    "        population_0=np.array([self.initial_values[c] for c in self.components], dtype=int)\n",
    "        time_points=np.linspace(0,t_max,num_iterations)        \n",
    "        args = np.array(self._params_vals)\n",
    "        n_simulations = Nsims\n",
    "\n",
    "        # Initialize output array\n",
    "        pops = np.empty((n_simulations, len(time_points), len(population_0)), dtype=int)\n",
    "        extinction_time=np.empty(n_simulations,dtype=np.float64)\n",
    "\n",
    "        # Run the calculations\n",
    "        for _i in tqdm(range(n_simulations),disable=disable):\n",
    "            pops[_i,:,:],extinction_time[_i] = _ssa(self.ν, \n",
    "                                        population_0, time_points, args=args)            \n",
    "\n",
    "        self.t=time_points\n",
    "        self.extinction_times=extinction_time\n",
    "        D={}\n",
    "        for _i,c in enumerate(self.components):\n",
    "            v=pops[:,:,_i]\n",
    "            if v.shape[0]==1:\n",
    "                v=v.ravel()\n",
    "                \n",
    "            setattr(self, c,v)\n",
    "            D[c]=v\n",
    "        \n",
    "        for eq in self.equations:\n",
    "            exec(eq,D)\n",
    "            name=eq.split('=')[0].strip()\n",
    "            setattr(self, name,D[name])\n",
    "\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9eb7d986-8538-4021-b3dd-ed2018bfce49",
   "metadata": {},
   "outputs": [],
   "source": [
    "# β=0.2\n",
    "# γ=0.1\n",
    "# So=990\n",
    "# Io=10\n",
    "\n",
    "# stoch_sim=sim=Stochastic_Simulation()\n",
    "# sim.add(\"+A\",'A',A=1)\n",
    "# sim.add(\"-A\",'A**2/10')\n",
    "# sim.run(10,Nsims=100)\n",
    "\n",
    "# for i in range(100):    \n",
    "#     plot(sim.t,sim.A[i],'b-o',alpha=0.05)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f7cb7f3b-2005-4f25-87a8-ab17d2f978f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# β=0.2\n",
    "# γ=0.1\n",
    "# So=990\n",
    "# Io=10\n",
    "\n",
    "# stoch_sim=sim=Stochastic_Simulation()\n",
    "# sim.add(\"+A\",'A',A=1)\n",
    "# sim.add(\"-A\",'A**2/10',quasi='A==1')\n",
    "# sim.run(10,Nsims=100)\n",
    "\n",
    "# for i in range(100):    \n",
    "#     plot(sim.t,sim.A[i],'b-o',alpha=0.05)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57cc21ca-b56d-4cae-a326-6d059a0570ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "def _simfunc(_vec,t,_sim):\n",
      "    initial_h=_sim.initial_value['h']\n",
      "\n",
      "    a=_sim.original_params['a']\n",
      "\n",
      "    h=_vec[0]\n",
      "\n",
      "\n",
      "    _diff=[]\n",
      "    _val=a\n",
      "    _diff.append(_val)\n",
      "\n",
      "    return _diff\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(sim.func_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d948bed6-7c9e-4c6c-b521-b500776387ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "@numba.jit(nopython=True)\n",
    "def _propensity_function_abcde(population, args):\n",
    "    A, = population\n",
    "    \n",
    "    \n",
    "    val = np.array([\n",
    "        A,\n",
    "        A**2/10,\n",
    "    ],float)\n",
    "    return val"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7da4f879-51c9-485c-91e6-b920d78fd45b",
   "metadata": {},
   "source": [
    "## Is there a problem with X'=0?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7d36027-3126-4b0d-abc7-b99bf82c7f9f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyndamics3 import Simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d9a9c3d1-a664-4d9e-9342-ed91cdca2175",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sim=Simulation()\n",
    "sim.add(\"X'=0\",5,plot=True)\n",
    "sim.params(α=5)\n",
    "sim.run(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "88633631-d5ee-4708-a829-d424696d73f4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'α': 5}"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sim.original_params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4df8b0f-ae11-4212-b84b-a0b40ac5a641",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyndamics3.chem import ChemSimulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fb322fc6-675d-4a69-a5b8-6bcb0cf17262",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['D'] k1 ['D', 'M']\n",
      "['M'] k2 ['M', 'P']\n",
      "['M'] k3 ['ϕ']\n",
      "['P'] k4 ['ϕ']\n",
      "Components ['D', 'M', 'P', 'ϕ']\n",
      "Parameters ['k1', 'k2', 'k3', 'k4']\n",
      "diffeqs [\"D' = 0\", \"M' =  +k1*D -k3*M\", \"P' =  +k2*M -k4*P\"]\n"
     ]
    }
   ],
   "source": [
    "sim=ChemSimulation(\n",
    "\"\"\"\n",
    "D --k1--> D+M\n",
    "M --k2--> M+P\n",
    "M --k3--> ϕ\n",
    "P --k4--> ϕ\n",
    "\"\"\",D=1,M=0,ϕ=0,P=0,k1=.01,k3=0.00577,k4=0.0001925,k2=20*0.00577)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3cede28-3e04-4050-93a0-404e8bd3e84c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'from_values': <function pyndamics3.core.array_wrap.<locals>.what(*args, **kw)>,\n",
       " 'sin': <function pyndamics3.core.array_wrap.<locals>.what(*args, **kw)>,\n",
       " 'cos': <function pyndamics3.core.array_wrap.<locals>.what(*args, **kw)>,\n",
       " 'exp': <function pyndamics3.core.array_wrap.<locals>.what(*args, **kw)>,\n",
       " 'tan': <function pyndamics3.core.array_wrap.<locals>.what(*args, **kw)>,\n",
       " 'abs': <function pyndamics3.core.array_wrap.<locals>.what(*args, **kw)>,\n",
       " 'floor': <function pyndamics3.core.array_wrap.<locals>.what(*args, **kw)>,\n",
       " 'ceil': <function pyndamics3.core.array_wrap.<locals>.what(*args, **kw)>,\n",
       " 'radians': <function pyndamics3.core.array_wrap.<locals>.what(*args, **kw)>,\n",
       " 'degrees': <function pyndamics3.core.array_wrap.<locals>.what(*args, **kw)>,\n",
       " 'sinh': <function pyndamics3.core.array_wrap.<locals>.what(*args, **kw)>,\n",
       " 'cosh': <function pyndamics3.core.array_wrap.<locals>.what(*args, **kw)>,\n",
       " 'tanh': <function pyndamics3.core.array_wrap.<locals>.what(*args, **kw)>,\n",
       " 'arccos': <function pyndamics3.core.array_wrap.<locals>.what(*args, **kw)>,\n",
       " 'arcsin': <function pyndamics3.core.array_wrap.<locals>.what(*args, **kw)>,\n",
       " 'arctan': <function pyndamics3.core.array_wrap.<locals>.what(*args, **kw)>,\n",
       " 'arctan2': <function pyndamics3.core.array_wrap.<locals>.what(*args, **kw)>,\n",
       " 'min': <function pyndamics3.core.array_wrap.<locals>.what(*args, **kw)>,\n",
       " 'max': <function pyndamics3.core.array_wrap.<locals>.what(*args, **kw)>,\n",
       " 'sqrt': <function pyndamics3.core.array_wrap.<locals>.what(*args, **kw)>,\n",
       " 'log': <function pyndamics3.core.array_wrap.<locals>.what(*args, **kw)>,\n",
       " 'log10': <function pyndamics3.core.array_wrap.<locals>.what(*args, **kw)>,\n",
       " 'mean': <function pyndamics3.core.array_wrap.<locals>.what(*args, **kw)>,\n",
       " 'median': <function pyndamics3.core.array_wrap.<locals>.what(*args, **kw)>,\n",
       " 'pi': 3.141592653589793,\n",
       " 'inf': inf,\n",
       " 'k1': 0.01,\n",
       " 'k2': 0.1154,\n",
       " 'k3': 0.00577,\n",
       " 'k4': 0.0001925}"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sim.myparams"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f2404f0-45af-4912-9fb3-29a01898a9a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "sim.run(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "937b783e-008e-4833-87be-472175a4fa5e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"D'=0\\nM'=+k1*D -k3*M\\nP'=+k2*M -k4*P\\nk1=0.01\\nk2=0.1154\\nk3=0.00577\\nk4=0.0001925\\n\""
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sim.equations()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "117f7512-cbf9-4e0f-a233-3c89f3567a41",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "def _simfunc(_vec,t,_sim):\n",
      "    initial_D=_sim.initial_value['D']\n",
      "    initial_M=_sim.initial_value['M']\n",
      "    initial_P=_sim.initial_value['P']\n",
      "\n",
      "    k1=_sim.original_params['k1']\n",
      "    k2=_sim.original_params['k2']\n",
      "    k3=_sim.original_params['k3']\n",
      "    k4=_sim.original_params['k4']\n",
      "\n",
      "    D=_vec[0]\n",
      "    M=_vec[1]\n",
      "    P=_vec[2]\n",
      "\n",
      "\n",
      "    _diff=[]\n",
      "    _val=0\n",
      "    _diff.append(_val)\n",
      "    _val=+k1*D -k3*M\n",
      "    _diff.append(_val)\n",
      "    _val=+k2*M -k4*P\n",
      "    _diff.append(_val)\n",
      "\n",
      "    return _diff\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(sim.func_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7b7c7f06-19d5-4ba2-87ab-8019d6191aff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D'=0\n",
      "M'=+k1*D -k3*M\n",
      "P'=+k2*M -k4*P\n",
      "k1=0.01\n",
      "k2=0.1154\n",
      "k3=0.00577\n",
      "k4=0.0001925\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(sim.equations())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bae4d880-80e6-465a-a5bd-c22ca822940a",
   "metadata": {},
   "outputs": [],
   "source": [
    "sim.params()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d897d098-f349-45ad-b5f1-f672ec5b74c5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "861bef39-6c79-4f72-bebd-1a0f8a211486",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "python3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}