{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. How to Build a Model\n",
    "\n",
    "`Model` is composed of a set of `Species` and `ReactionRule`s.\n",
    "\n",
    "* `Species` describes a molecule entitie (e.g. a type or state of a protein) in the model. `Species` also has its attributes like the size.  \n",
    "* `ReactionRule` describes the interactions between `Species` (e.g. binding and unbinding)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from ecell4.prelude import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1. Species\n",
    "\n",
    "`Species` can be generated by giving its name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n"
     ]
    }
   ],
   "source": [
    "sp1 = Species(\"A\")\n",
    "print(sp1.serial())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are some naming conventions for the name of `Species`.\n",
    "This naming convention requires careful use of special symbols (e.g. parenthesis `()`, dot `.`, underbar `_`), numbers and blank.\n",
    "\n",
    "`Species` has a set of APIs for handling its attributes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "<ecell4_base.core.Quantity_Real object at 0x149ce5fde618>\n",
      "0.005\n",
      "\n",
      "True\n",
      "cytoplasm\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "sp1.set_attribute(\"radius\", 0.005)\n",
    "sp1.set_attribute(\"D\", 1)\n",
    "sp1.set_attribute(\"location\", \"cytoplasm\")\n",
    "print(sp1.has_attribute(\"radius\"))\n",
    "print(sp1.get_attribute(\"radius\"))\n",
    "print(sp1.get_attribute(\"radius\").magnitude)\n",
    "print(sp1.get_attribute(\"radius\").units)\n",
    "print(sp1.has_attribute(\"location\"))\n",
    "print(sp1.get_attribute(\"location\"))\n",
    "sp1.remove_attribute(\"radius\")\n",
    "print(sp1.has_attribute(\"radius\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The arguments in `set_attribute` is the name of attribute and its value. The name of an attribute is given as a string, and its value is a string, integer, float, or boolean. `get_attribute` returns the value set. For an integer or float attribute, `get_attribute` returns a quantity object, which is a pair of value (`magnitude`) and unit (`units`).\n",
    "\n",
    "There is a shortcut to set the attributes above at once because `radius`, `D` (a diffusion coefficient) and `location` are frequently used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp1 = Species(\"A\", 0.005, 1, \"cytoplasm\")  # serial, radius, D, location"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The equality between `Species` is just evaluated based on their `serial`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(Species(\"A\") == Species(\"B\"))\n",
    "print(Species(\"A\") == Species(\"A\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A Species consists of one or more UnitSpecies:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C\n",
      "C.A.B 3\n"
     ]
    }
   ],
   "source": [
    "sp1 = Species()\n",
    "usp1 = UnitSpecies(\"C\")\n",
    "print(usp1.serial())\n",
    "sp1.add_unit(usp1)\n",
    "sp1.add_unit(UnitSpecies(\"A\"))\n",
    "sp1.add_unit(UnitSpecies(\"B\"))\n",
    "print(sp1.serial(), len(sp1.units()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A `Species` can be reproduced from its `serial`. In the `serial`, all `UnitSpecies` are joined with the separator, dot `.`. The order of `UnitSpecies` affects the `Species` comparison."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C.A.B\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "sp1 = Species(\"C.A.B\")\n",
    "print(sp1.serial())\n",
    "print(Species(\"A.B.C\") == Species(\"C.A.B\"))\n",
    "print(Species(\"A.B.C\") == Species(\"A.B.C\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`UnitSpecies` can have sites. Sites consists of a `name`, `state` and `bond`, and are sorted automatically in `UnitSpecies`. `name` must be unique in a `UnitSpecies`. All the value have to be string. Do not include parenthesis, dot and blank, and not start from numbers except for `bond`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A(bs^_,ps=p^_,us=u)\n"
     ]
    }
   ],
   "source": [
    "usp1 = UnitSpecies(\"A\")\n",
    "usp1.add_site(\"us\", \"u\", \"\")\n",
    "usp1.add_site(\"ps\", \"p\", \"_\")\n",
    "usp1.add_site(\"bs\", \"\", \"_\")\n",
    "print(usp1.serial())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`UnitSpecies` can be also reproduced from its serial. Please be careful with the order of sites where a site with a state must be placed after sites with no state specification:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A(bs^_,ps=p^_,us=u)\n"
     ]
    }
   ],
   "source": [
    "usp1 = UnitSpecies()\n",
    "usp1.deserialize(\"A(bs^_, us=u, ps=p^_)\")\n",
    "print(usp1.serial())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, a site of `UnitSpecies` is available even in `Species`' serial."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A(bs^1, ps=u).A(bs, ps=p^1)\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "sp1 = Species(\"A(bs^1, ps=u).A(bs, ps=p^1)\")\n",
    "print(sp1.serial())\n",
    "print(len(sp1.units()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The information (`UnitSpecies` and its `site`) is used for rule-based modeling. The way of rule-based modeling in E-Cell4 is explained in [7. Introduction of Rule-based Modeling](tutorial7.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2. ReactionRule\n",
    "\n",
    "`ReactionRule` consists of `reactants`, `products` and `k`. `reactants` and `products` are a list of `Species`, and `k` is a kinetic rate given as a floating number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "rr1 = ReactionRule()\n",
    "rr1.add_reactant(Species(\"A\"))\n",
    "rr1.add_reactant(Species(\"B\"))\n",
    "rr1.add_product(Species(\"C\"))\n",
    "rr1.set_k(1.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a binding reaction from `A` and `B` to `C`. In this reaction definition, you don't need to set attributes to `Species`. The above series of operations can be written in one line using `create_binding_reaction_rule(Species(\"A\"), Species(\"B\"), Species(\"C\"), 1.0)`.\n",
    "\n",
    "You can use `as_string` function to check `ReactionRule`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A+B>C|1\n"
     ]
    }
   ],
   "source": [
    "rr1 = create_binding_reaction_rule(Species(\"A\"), Species(\"B\"), Species(\"C\"), 1.0)\n",
    "print(rr1.as_string())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also provide components to the constructor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A+B>C|1\n"
     ]
    }
   ],
   "source": [
    "rr1 = ReactionRule([Species(\"A\"), Species(\"B\")], [Species(\"C\")], 1.0)\n",
    "print(rr1.as_string())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basically `ReactionRule` represents a mass action reaction with the rate `k`. `ode` solver also supports rate laws thought it's under development yet. `ode.ODERatelaw` is explained in **6. How to Solve ODEs with Rate Law Functions** [local ipynb](tutorial6.ipynb) [readthedocs](http://ecell4.readthedocs.io/en/latest/tutorials/tutorial6.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.3. NetworkModel\n",
    "\n",
    "You have learned how to create some `Model` components. Next let's put the components in a `Model`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp1 = Species(\"A\", 0.005, 1)\n",
    "sp2 = Species(\"B\", 0.005, 1)\n",
    "sp3 = Species(\"C\", 0.01, 0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "rr1 = create_binding_reaction_rule(Species(\"A\"), Species(\"B\"), Species(\"C\"), 0.01)\n",
    "rr2 = create_unbinding_reaction_rule(Species(\"C\"), Species(\"A\"), Species(\"B\"), 0.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can put the `Species` and `ReactionRule` with `add_species_attribute` and `add_reaction_rule`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "m1 = NetworkModel()\n",
    "m1.add_species_attribute(sp1)\n",
    "m1.add_species_attribute(sp2)\n",
    "m1.add_species_attribute(sp3)\n",
    "m1.add_reaction_rule(rr1)\n",
    "m1.add_reaction_rule(rr2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we have a simple model with the binding and unbinding reactions. You can use `species_attributes` and `reaction_rules` to check the `Model`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'B', 'C']\n",
      "['A+B>C|0.01', 'C>A+B|0.3']\n"
     ]
    }
   ],
   "source": [
    "print([sp.serial() for sp in m1.species_attributes()])\n",
    "print([rr.as_string() for rr in m1.reaction_rules()])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `Species` attributes are required for the spatial `Model`, but not required for the nonspatial `Model` (i.e. `gillespie` or `ode`). The attribute pushed first has higher priority than one pushed later. You can also attribute a `Species` based on the attributes in a `Model`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "0.005\n"
     ]
    }
   ],
   "source": [
    "sp1 = Species(\"A\")\n",
    "print(sp1.has_attribute(\"radius\"))\n",
    "sp2 = m1.apply_species_attributes(sp1)\n",
    "print(sp2.has_attribute(\"radius\"))\n",
    "print(sp2.get_attribute(\"radius\").magnitude)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For your information, all functions related to `Species`, `ReactionRule` and `NetworkModel` above are also available on C++ in the same way.\n",
    "\n",
    "Finally, you can solve this model with `run_simulation` as explained in [1. Brief Tour of E-Cell4 Simulations](tutorial1.html) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEGCAYAAABiq/5QAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3deXxU9b3/8ddnspMEwhLWCAiigOxEwLWtG1ot0Fvbq/Vaqt5627q07ty2Lr2/tnq91WoXrdalWK24tlq1pYpr3QEBZadsQZYECCQhkGXm8/tjJhgphCFk5pCZ97OPeZw5J2d5D9JPDt/5nu/X3B0REUkfoaADiIhIcqnwi4ikGRV+EZE0o8IvIpJmVPhFRNJMZtAB4tGtWzfv379/0DFERNqVOXPmbHb34j23t4vC379/f2bPnh10DBGRdsXM1uxtu5p6RETSjAq/iEiaUeEXEUkzKvwiImlGhV9EJM0ktPCbWZGZPWVmS8xssZkda2ZdzOwlM1seW3ZOZAYREfmsRN/x3wX8zd0HAyOBxcA0YJa7DwJmxdZFRCRJElb4zawjcBLwAIC717v7NmAyMD2223RgSqIyvLzmZZ5Y+kSiTi8i0i4l8o5/AFABPGRmH5rZ/WaWD/Rw9w0AsWX3vR1sZpeY2Wwzm11RUdGqAC+uepHbZ99O5a7KVn4EEZHUk8jCnwmMAe5x99HADg6gWcfd73P3UncvLS7+lyeO43LpqEvZ2biTBz56oFXHi4ikokQW/nXAOnd/L7b+FNFfBJvMrBdAbFmeqAADiwbypYFfYsbSGZTXJuwyIiLtSsIKv7tvBMrM7KjYplOARcBzwNTYtqnAs4nKAPCdkd8h7GHuW3BfIi8jItJuJLpXz+XAo2a2ABgF/Ay4FTjNzJYDp8XWE6aksISvDPoKTy97mrLqskReSkSkXUho4Xf3ebF2+hHuPsXdK919i7uf4u6DYsuticwAcMmIS8gIZXDPvHsSfSkRkUNeWjy5271Dd74++Os8v/J5llUuCzqOiEig0qLwA1w8/GIKsgu4a+5dQUcREQlU2hT+TjmduHjYxbyx7g0+2PhB0HFERAKTNoUf4Pwh59O9Q3funHMn7h50HBGRQKRV4c/NzOXSUZeyYPMCZq2dFXQcEZFApFXhB5g0cBIDOg3grrl30RBpCDqOiEjSpV3hzwxlcuXYK1ldtZonlz4ZdBwRkaRLu8IP8LmSzzGu5zjumX8PVfVVQccREUmqtCz8ZsY1pdewvW479y+4P+g4IiJJlZaFH2BI1yFMGjiJRxY/wrrqdUHHERFJmrQt/ACXj76czFAmd869M+goIiJJk9aFv0d+D7559DeZuXomczbNCTqOiEhSpHXhB7hw2IX0zO/Jre/fSjgSDjqOiEjCpX3hz8vM4+qxV7Nk6xKeWfFM0HFERBIu7Qs/wMT+ExnbYyy/mvsrttdtDzqOiEhCqfAT7d45bdw0ttdv5575GrNfRFKbCn/M4C6DOWfQOcxYMoOlW5cGHUdEJGFU+Ju5fPTlFGYX8tP3fkrEI0HHERFJCBX+Zopyi7hq7FV8WP4hz/3zuaDjiIgkhAr/HiYfMZlRxaO4Y/Yd+qJXRFKSCv8eQhbiRxN+xPb67fxy7i+DjiMi0uZU+PfiqC5H8fXBX+fJZU8yr3xe0HFERNqUCv8+XDb6Mnrk9+DH7/yYhrAmbBGR1KHCvw/5WfncMOEGVmxbwQMfPxB0HBGRNpPQwm9mq83sIzObZ2azY9u6mNlLZrY8tuycyAwH46SSk5jYfyL3LbiPldtXBh1HRKRNJOOO/wvuPsrdS2Pr04BZ7j4ImBVbP2RNGzeN3Mxcfvz2j9W3X0RSQhBNPZOB6bH304EpAWSIW7e8blxbei1zy+cyY8mMoOOIiBy0RBd+B/5uZnPM7JLYth7uvgEgtuy+twPN7BIzm21msysqKhIcs2VTjpjC8X2O5865d1JWVRZoFhGRg5Xown+8u48BzgQuNbOT4j3Q3e9z91J3Ly0uLk5cwjiYGTcfezOZlskNb9+gJh8RadcSWvjdfX1sWQ78CRgHbDKzXgCxZXkiM7SVnvk9ufaYa5mzaQ6PLXks6DgiIq2WsMJvZvlmVtj0Hjgd+Bh4Dpga220q8GyiMrS1KUdM4cQ+J3LnnDtZtX1V0HFERFolkXf8PYB/mNl84H3gBXf/G3ArcJqZLQdOi623C2bGzcfdTE5mDtPenEZDRA92iUj7s9/Cb2ZfbXbn/iMze8bMxuzvOHdf6e4jY6+j3f2nse1b3P0Udx8UW249+I+RPN07dOfmY29m0ZZF3DNPk7aISPsTzx3/De5ebWYnABOJdsFM64p3ar9T+fIRX+b+j+5nzqY5QccRETkg8RT+cGx5FnCPuz8LZCcuUvtw/bjrKSks4Qdv/oDq+uqg44iIxC2ewv+Jmd0LfA140cxy4jwupeVn5XPLibewqXYTN719E+4edCQRkbjEU8C/BswEznD3bUAX4NqEpmonRhaP5IoxV/DSmpd4fOnjQccREYnLfgu/u9cS7Wt/QmxTI7A8kaHak28e/U1O6HMCt31wG0u2Lgk6jojIfsXTq+cm4Hrgv2ObsoBHEhmqPQlZiJ+e8FM653Tmmtevoaa+JuhIIiItiqep58vAJGAH7H4atzCRodqbLrlduO1zt7Gueh0//McPNaSDiBzS4in89R795tJh91O4soexPcZy1direKXsFR78+MGg44iI7FM8hf+JWK+eIjP7FvAy8LvExmqfLhh6AWf2P5Nfzv0lb3/ydtBxRET2Kp4vd38OPAU8DRwF3Ojuv0p0sPaoaUiHgUUDue7N6yir1hDOInLoias/vru/5O7Xuvs17v5SokO1Zx2yOnDXF+7C3bl81uV6uEtEDjn7LPxmVm1mVc2WVc3XkxmyvenbsS+/+PwvWFO1hmvfuJbGSGPQkUREdttn4Xf3Qnfv2GzZsfl6MkO2R+N6jeMHE37AW5+8xe2zbw86jojIbpn728HM+u5tu7uvbfs4qeWrR36VldtW8sjiR+jbsS/nDT4v6EgiIvsv/MALzd7nAocDS4GjE5IoxVxTeg3ratZxy3u30D2vO6f0OyXoSCKS5uLp1TO82WsQ0ekT/5H4aKkhI5TBbSfdxvDi4Vz3xnXM3TQ36EgikuYOeJRNd58LHJOALCkrLzOPX5/8a3oX9ObyVy5nReWKoCOJSBqLZ6yeq5q9rjGzPwIVSciWUjrnduaeU+8hJyOHS166hLIq9fEXkWDEc8df2OyVQ7TNf3IiQ6WqksISfnf672iINPCff/9PNu7YGHQkEUlD1h4mECktLfXZs2cHHaPNLNqyiItnXky3vG48dMZDdMvrFnQkEUlBZjbH3Uv33B5PU89LZlbUbL2zmc1s64DpZGjXodx96t1sqt3ERTMvoqJWLWcikjzxNPUUx2beAsDdK4HuiYuUHkZ3H83dp9zNxh0buWjmRWzasSnoSCKSJuKabL35Q1xm1o/YEM1ycEp7lnLvafdSXlvORTMvUpu/iCRFPIX/h8A/zOwPZvYH4A0+nY1LDtLo7qO597R72bprKxf89QJWbV8VdCQRSXHxPMD1N2AM8DjwBDDW3eNu4zezDDP70Myej60fbmbvmdlyM3vczLJbGz5VjOo+igcnPkh9uJ6pf53Kwi0Lg44kIiksni93DTgDGOPufwE6mNm4A7jG94DFzdb/F/hF7CngSuDiAzhXyhrSdQgPn/kweZl5XPS3i3hn/TtBRxKRFBVPU8/dwLFA0whj1cBv4jm5mZUAZwH3x9YNOJnoxC4A04EpB5A3pfXr2I+Hz3yY3gW9+e7L3+VPy/8UdCQRSUHxFP7x7n4psAt29+qJt3nmTuA6oGn28a7ANndvGqB+HdBnbwea2SVmNtvMZldUpE93xx75PXj4zIcZ12scN759I3fNvUuTt4tIm4qn8DeYWQafTrZezKeFfJ/M7Gyg3N3nNN+8l1332kPI3e9z91J3Ly0uLo4jZuoozC7k16f8mnOOPIf7P7qfq1+7mh0NO4KOJSIpIp7C/0vgT0B3M/sp0ZE5fxbHcccDk8xsNTCDaBPPnUQnbW8aDroEWH+godNBViiLGyfcyLWl1/Jq2auc/8L5rK3SFAgicvDi6dXzKNHmmluADcAUd38yjuP+291L3L0/cC7wirufD7wKnBPbbSrwbCuzpzwz4xtHf4N7T7uXLbu2cO4L5/J62etBxxKRdq6lOXe7NL2AcuAx4I/Apti21roeuMrMVhBt83/gIM6VFsb3Gs+Ms2dQUlDCZa9cxu2zb6ch0hB0LBFpp/Y5SJuZrSLa/r7Xdnl3H5DIYM2l2iBtrVUXruP/Pvg/Hl/6OCO6jeC2z91Gn4K9fjcuIrLPQdo0Omc7NHP1TG5++2YcZ9q4aUweOJloT1kRkU+1enTO2MGTzOznsdfZbR9PDsTE/hN5atJTDO4ymBveuoErX7uSrbu2Bh1LRNqJeJ7cvZXo07eLYq/vmdktiQ4mLetT0IcHTn+Aq8dezRvr3mDKn6fw/MrnaQ//ghORYO23qcfMFgCj3KNPEcX69H/o7iOSkA9QU8/+rKhcwU3v3MSCigUc3+d4bphwg9r+ReTgmnqAombvO7VNJGkrR3Q+gofPeJhp46Yxd9Ncpvx5Cr+d/1vqwnVBRxORQ1A8hf8W4EMz+72ZTQfmEN8DXJJEGaEMzh9yPs9NeY6TSk7iN/N+w5Q/T+GVta+o+UdEPiOuXj1m1gs4hmjXzvfcPakzhqip58C9u+FdbnnvFlZuX8nYHmO5pvQahnUbFnQsEUmiA+7OaWZjWjqhu89to2z7pcLfOg2RBp5Z9gx3z7+brbu2MrH/RL478rsMKEraIxgiEqDWFP4IsBBoGhqzeUdxd/eT2zzlPqjwH5wdDTt46OOH+MOiP7CzcSdfHPBFvj3i2/Tv1D/oaCKSQK0p/FcCXwG2Ex1k7U/uXpPQlPugwt82KndV8tDCh5ixZAa7GndxWr/TuHj4xQztOjToaCKSAK1+ctfMDic6CctkYA3wM3efl5CU+6DC37Y279zMo4sfZcaSGdQ01DCh1wQuGHoBJ/Q5gZDF29FLRA51BzVkg5kdTXSEzQuA69z9ibaPuG8q/IlRXV/NE0uf4I+L/0j5znL6dezHeYPP4+wBZ9MpR712Rdq71jT1DCBa7CcDZUSbe553912JDLo3KvyJ1RBp4KXVL/Ho4kdZsHkBORk5TOw/kXOOPIdRxaM0DpBIO9XaL3cXEB0vv4o9Zspy9zsSkHOvVPiTZ9GWRTy97GleWPUCOxp20LewL18a+CXOHnA2JYUlQccTkQPQmsJ/M/uYFhHA3X/cZun2Q4U/+Wobavn7mr/zl3/+hfc3vg/A8G7Dmdh/IhP7T6Rnfs+AE4rI/mhYZmm19TXr+euqvzJz9UwWb10MwLCuwzi578mc3PdkBnQaoOYgkUOQCr+0idXbV/Py2pd5de2rLNi8AIDe+b05seRETuhzAsf0PIb8rPyAU4oIqPBLApTXlvP6utd5c92bvLvhXXY27iTTMhnWbRjje42ntGcpI4tHkpeZF3RUkbTUmjb+77n7XWZ2vLu/lfCELVDhP/TVh+v5sPxD3tvwHu9ueJeFWxYS8QiZlsnQbkMZVTyKkcUjGVk8kh75PYKOK5IWWlP457n7KDOb6+4tjtuTaCr87U91fTXzyucxZ9Mc5pbPZeHmhdRH6gHontedod2GcnTXoxnSZQhHdTmKHh166HsCkTa2r8Kf2cIxi81sNVAcm4xl97mIjtWTtIlYpP0pzC7kxJITObHkRAAawg0s3rqYBRULWLhlIR9v/pjXyl7bvX/nnM4M6jyII4qO4IjORzCg0wAGdBpA59zOAX0CkdS1z8Lv7ueZWU9gJjApeZEkFWVlZDGieAQjij+9X6ipr2H5tuUs2bqEpVuXsrxyOX9e8WdqG2t371OUU0S/jv12vw4rPIySghJKCksoyinSvxJEWiHeIRuygSNjq0vdvSGhqfagpp70EfEIG3ZsYOW2lazavoqV21eytnota6rWUF5b/pl98zLz6J3fm14FveiV34seHXrQM78n3Tt03/0qyCrQLwdJW61p6mk68HPAw8Bqos08h5nZVHd/o81TStoLWYg+BX3oU9BndzNRk9qGWtbXrGddzTrKqstYX7Oe9TXr2bBjAws3L6SyrvJfzpebkUvXvK50y+tG19yudM7tTJfcLnTJ7UJRbhGdczpTlFNEp5xOdMrppF8Ukhb2W/iBO4DT3X0pgJkdCTwGjG3pIDPLBd4AcmLXecrdb4qN9jkD6ALMBS5w9/rWfwRJFx2yOnBE5+h3AHtTF65j045NlNeWU7GzgvLacjbv3MzmnZup2FlBWU0Z8yvmU1lXScQjez1HhmVQmF1Ix+yOdMzuSEF2AYXZhRRkFZCflU9BdgEFWQXkZeaRn5VPflY+HTI70CGrA3mZeZ955WTk6JeIHJLiKfxZTUUfwN2XmVlWHMfVASe7e01s/3+Y2V+Bq4BfuPsMM/stcDFwT2vCizSXk5FD34596duxb4v7RTxCdX01lbsqqayrZNuubWyv3872uuirqr6KqroqqhqqqKmvoby2nJr6GnY07mBHw44DytT0CyAnI+cz77MzssnJzCE7lL17PSuURXZGNtmhbLIysnYvMy3zs8tQJpmWGV02f8W2ZYQyyLToMsNir1AGIQuRaZmELLR7vennIQvtXjez3UtJTfEU/tlm9gDwh9j6+UQnXG+RR788aJq4JSv2cuBk4Oux7dOBm1HhlyQKWWh3005/+h/QseFImNrGWmobatnRuIPahlp2Nu6ktqGW2sbo+6bXrsZd1IXr2Nm4k7pwHXWNdewK76I+XE9duI6quirqw/XUR+qjy9j2hkgDDeEGGr0xMX8AByCE7f5f9H3zbTRbsvdtbrHzRDX/Of7ptH62xwvAmn39+Jntu98b4JjHzofHzt7Em63F3se+02z+K832WO7e3sLXn3s7fm/naPHYfZx/z3Ncf8qvOHrgMXGcOX7xFP7vAJcCV8QyvQHcHc/JzSyD6C+JI4DfAP8Etrnv/hu9Duizj2MvAS4B6Nu35Ts4kWTJCEWbggqzC4mEw+ysrWZnYxW76qqoq82iYWcGDXVG4y4nXBcmUt9IpD4EDeCNDg2OhcNYYyOhcCOhcAOhSAMZu19hMr2RDA8T8kbcGsEbwcJErBHzMG4RCEVoxGg0aDSjESNs0BBbRohuDwNhMxqBiFlsO0T49GcRIGIQxnAgbNGaFMaINHvvsf0iRMto03FObJtF94nuH+XNztH8FWl2PqfpOIudO/oewO3T9d3HW1PN/HQbzc695/bYpmb7Nf/V8Oky0rTjHsf6p5v/5Wd7W99T8181+9q3pXPsqqtt4aets9/C7+51RNv5D3gYZncPA6PMrAj4EzBkb7vt49j7gPsg2qvnQK8tsj+RcJiqygqqKzexY1sFddWbqa/eSri2Et+5Ddu1nVB9NVkNVWQ11pAdriUvXEOu76SD7yTfdpEPHMjIRPWeyS7Lpp5sGsiiIZRNg2UTtiwaLZuGjFzqQoVEQtmxVyYeytr9IiMbz8iCUBZkZGKxJaEsLCPW5JORRSgjE0IZhDKyIJRJKJSBZWQSysjEQhlYKBPLyCAUyiCUmYVZCAtlxH4eiu4fChEKNe0fIhTb38yi+4ZCmIWi1zLDzAiFQru37z6P2afHmWEhzfIWtHju+A+au28zs9eACUCRmWXG7vpLgPXJyCDpIRIOU7l5A9s2raVm81rqKjcSrt5IqKacrF2byanfSkHjNjpGttPRqykyp2gf59rhudRYPjtD+ewK5bMrsxPVub0JZ+UTySqA7ALIzsdyCwnlFJCZm09GTgFZeQVk5eaTnVdAdl4BObn55OR1IDevgOyMDLKT+ici8q8SVvjNrBhoiBX9POBU4H+BV4FziPbsmUp0oheRuNTX7WJT2XIq1y1jZ8UqIpVryKpZT4edGylqLKdbZAtdLUzXPY6rIp9toSJqMjqzJe9wNuZ2JpLXFcvvRmZ+F7IKu5HXqZi8jl0p6NSNwqKu5GdlH9DdvEh70WLhj7XR3+ru17bi3L2A6bFzhIAn3P15M1sEzDCznwAfAg+04tySwiLhMBvXLqdi9UfsXL8Y2/pP8mtW063uE7r7Zg4z57DYvg2eQUWoG5VZ3VlfOJI1Bb0IdepDVlEfOnTtTVH3vnTu3oeOuR3oGOinEjl0tFj43T1sZmPNzPwAx2929wXA6L1sXwmMO7CYkqoqKzbwyZL3qVnzIRkViymqWUFJ41p6Wz29Y/tsJ5+NmSWs6ziKVZ36k9n1cPJ7DqRrySC69exH78zM3fuKyP7F09TzIfCsmT0J7O7E7O7PJCyVpKTtlZtZM/91dqz+gNzyBfSuXUIPttA0DFsFndmYczjzu36ZUPfBFB52ND0HjKBzcS86BZpcJLXEU/i7AFuI9r9v4oAKv+yTRyJsWLOMT+a/jK95m+7bF9A/UkbTEG1l1puywlGs6jGc/L5jKBkyjuLiXhQHmlokPcTTnfPCZASR9q9i/WpWf/AirHyNw7bPoTeb6U20qWZ13tG80/0sCgYeR9/hx3NY52672+lFJLniGaTtSKJP1vZw92FmNgKY5O4/SXg6OaQ1NtSz9IOXqfror/Tc9AaHR1ZTDFRSyKqCMaw57Di6Dz+FfkeNYWRGRtBxRSQmnqae3wHXAvdC9EtbM/sjoMKfhnbuqGbJW8/SuPA5Bm1/i6OpocEzWJYzjHdLrqB41JkcfvR4xqjQixyy4in8Hdz9/T0GbAp+EBFJmrpdtSx64xnCHz3D0Kp/MNrq2E4+yzodT8aQsxh07CSO7tQl6JgiEqd4Cv9mMxtI05AVZucAGxKaSgLnkQhL577K9nceZvCWlxjNDiop5KOuE+kw6hwGTziDY7Jzgo4pIq0QT+G/lOiYOYPN7BNgFdEROiUFbd+yicUzf0fPFTMYHCljp2ezsNNJZI0+l6HHT2K8ir1IuxdPr56VwKlmlg+E3L068bEk2VbMf4vKV37JiG2zmGANLMs8kvePvpkhp06lVM04Iiklnl49XYGbgBMAN7N/AP/j7lsSHU4SKxIOM3/WY+TM/i1D6z+i1nOY1+0sun3uvzhyxHFBxxORBImnqWcG0TH4vxJbPx94nOiga9IONdTXMe/F+ylecA+jI2VsoJh3j7iSIWddxvjO3YKOJyIJFteTu+7+/5qt/8TMpiQqkCROY0M9c5//LSULfs0xvolVof7MHnsbo864kF5ZGixYJF3EU/hfNbNzgSdi6+cALyQukrS1SDjM3Bfvp+fcXzDON7A8cxDzjv0fRn7haxyuSTFE0s4+C7+ZVdM0iWV0gvRHYj8KEZ1L96aEp5OD9vFbfyHnlZspDa/gnxmHM2/CPYw85VzNgiSSxvZZ+N29MJlBpG19snIhFU9dzajad9hIMbPH3MqYsy4hpCdqRdJeXDNwxcbn6d98fw3LfGjauaOa+Y/dxOiyhykig3cGXsHor06jZ57mkhKRqHi6cz4IjAAW0jQRvYZlPiR99PozdH3teiZ4ObM7nUq/c2/n2N79g44lIoeYeO74J7j70IQnkVbbtnkjy/9wBcdsn8naUB8WnvYYpcd9MehYInKIiqfwv2NmQ919UcLTyAGbN2sGJW9ezyiv5p3DLmL0+T+hr5p1RKQF8RT+6USL/0agjmgvH3f3ES0fJolUU1XJoocuY1zl86wM9Wf7lx/n2OETgo4lIu1APIX/QeAC4CM+beOXAC2f9yZ5z/4npZFNvNP7G4yZ+r/k5HYIOpaItBPxFP617v5cwpPIfnkkwnuP38qYJbdTaZ1YcuYMjp1wRtCxRKSdiafwL4nNuPUXok09gLpzJltNVSXL7v0GE3a8wbwOE+h/8XSGdusZdCwRaYfiKfx5RAv+6c22qTtnEpUtn0/ksfMZEf6Edwddyfiv36gnb0Wk1eIZj//C1pzYzA4DHgZ6Ev1u4D53v8vMuhAd3bM/sBr4mrtXtuYa6WDerBkMfOP7NFoWS05/mAnHfynoSCLSzsXzANdDxKZdbM7dL9rPoY3A1e4+18wKgTlm9hLwTWCWu99qZtOAacD1B5w8xXkkwnuP/YRxy+5gZeYA8r/xGMP6HRV0LBFJAfE09Tzf7H0u8GVg/f4OcvcNxObmdfdqM1sM9AEmA5+P7TYdeA0V/s9obKhnzr3/xYTNzzC34ESGfPcx8vI1dJKItI14mnqebr5uZo8BLx/IRcysPzAaeA/oEfulgLtvMLPu+zjmEuASgL59+x7I5dq12prtLP/NOYzf+T7v9jyfcd/6lQZWE5E21ZpvCAcBcVdiMysAnga+7+5V8R7n7ve5e6m7lxYXF7ciZvuzfcsm1t45kWG1H/De0B8x4dt3q+iLSJuLp42/aVz+JhuJs2nGzLKIFv1Hm3X/3GRmvWJ3+72A8gPMnJLKP1lF7QOTGBBez/zjfsX4iRcEHUlEUlQ8TT2talw2MwMeABa7+x3NfvQcMBW4NbZ8tjXnTyXrVy2Bh79EcaSKZac9xJgTJgUdSURSWEszcLXYnOPua/dz7uOJDfVgZvNi235AtOA/YWYXA2uBr8YfN/V8snIhGQ9PIo+drJ/yJMNGnxR0JBFJcS3d8b/Ap1MvNnGgGOgOtNj47O7/2OPY5k45gIwpq2zFR2Q/Mpls6tn8b08xaMRxQUcSkTTQ0tSLw5uvx3rmXA+cCvwsoanSwLoVH5PzyCSyaKTynKcZOGx80JFEJE3st1ePmQ0ys98DfwXmAEPd/VeJDpbKNpatIOORKWTRwLavPcMAFX0RSaKW2viHAT8EjgZuAy5293CygqWqzRvLaHjwSxR5DZv+7SmOGHpM0JFEJM201MY/Hygj2tY/DhgX7agT5e5XJDZa6tleuZmq+86mZ2QLa7/4CINHnhB0JBFJQy0V/v2NxSMHYNfOHay7ZwqDwmUsPeUhho8/ff8HiYgkQEtf7k5PZpBUFgmHWfSb8xhT/xGzx/2c0pMmBx1JRNKYBnVPMI9EeP/ebzOm5nXePeJKSs/6VtCRRCTNqfAn2HuP38qE8id4t/u/M0N2jNEAAAsRSURBVP7rNwYdR0REhT+RFrz6FMcsuY0POxzHuP+6R7NmicghIZ5+/Eea2Swz+zi2PsLMfpT4aO3bmsVzOPy1y1id2Z8jv/OYRtkUkUNGPLegvwP+G2gAcPcFwLmJDNXebdu8kcwnzqPOcsif+iT5hUVBRxIR2S2ewt/B3d/fY1tjIsKkgnBjI2W/O4/iyBY2n/0gPfsOCjqSiMhnxFP4N5vZQGJj8pvZOcSmVJR/9f6DVzG8bi7zRtzA4FKNRScih5545ty9FLgPGGxmnwCrgP9IaKp26sOZ0zl2/XTe6zKJ8V/5ftBxRET2Kp6JWFYCp5pZPhBy9+rEx2p/1iydx5FvX8eyrCMZdcm9QccREdmneKZezAG+AvQHMpvG63H3/0losnZkV20NkcenUm/ZdPrmDHJyOwQdSURkn+Jp438WmEz0C90dzV4SM//+73B4ZDVln/sFPUoGBh1HRKRF8bTxl7j7GQlP0k7NfuF3jN/6HO/0+gbHfuGcoOOIiOxXPHf8b5vZ8P3vln4+WbmQwe/fwJKsoZRe+POg44iIxKWliVg+BiKxfS40s5VAHdF5dN3dRyQn4qGpob6Omj9eSKGFKLrgYbKyc4KOJCISl5aaevoAo5IVpL2Z/YcfcGzjUuaMu4OxekhLRNqRlgr/Kndfk7Qk7ciSD15m3NoH+KBoIsd88eKg44iIHJCWCn93M7tqXz909zsSkOeQV1NVSeGL32VTqJjBF/026DgiIgespcKfARQQbdOXmEW/v5yxkXKWffFxenfqEnQcEZED1lLh33AwD2mZ2YPA2UC5uw+LbesCPE70YbDVwNfcvbK110i2Ba89zbitf+HdXuczYfzEoOOIiLRKS905D/ZO//fAnv3/pwGz3H0QMCu23i5UbdtCj9euZU2ohFFT/y/oOCIirdZS4T+ooSXd/Q1g6x6bJwNNk7hPB6YczDWSacn0y+nmW6k7+zfk5uUHHUdEpNX2Wfjdfc+i3RZ6uPuG2Pk3AN33taOZXWJms81sdkVFRQKixG/Bq08xrvIF3u9zAUeO+XygWUREDtYhOwmsu9/n7qXuXlpcXBxYjh3V2yh+fRprQiWMvuDWwHKIiLSVZBf+TWbWCyC2LE/y9Q/YR49cTy8qqJ14h5p4RCQlJLvwPwdMjb2fSnTkz0PWsrmvc8zGx3mv6xSGqBePiKSIhBV+M3sMeAc4yszWmdnFwK3AaWa2HDgttn5IaqivI+OF77HFOjPkgrR8Vk1EUlQ8wzK3iruft48ftYuJaOfM+AkTwquYe+yvGVPUNeg4IiJt5pD9cjdIG9cuZ8Q/7+XDDscxZuIFQccREWlTKvx7sf7xKzGcnv9+Z9BRRETanAr/Hua/8gRjdrzJvAHfole/o4KOIyLS5lT4m9lVW0O3N3/EmlAJY8+9Meg4IiIJocLfzIczfkwf30T1ybeQnZMbdBwRkYRQ4Y/ZsGYpo9c8xJyCzzPshElBxxERSRgV/pgNT16LY/T599uDjiIiklAq/MDCt15gTM3rzOt3IT0POyLoOCIiCZX2hb+xoZ68WT9gA8WM1he6IpIG0r7wz/nTnQyIrGbD+B+S26Eg6DgiIgmX1oW/atsWjlz0KxZmD2f0xKn7P0BEJAWkdeFf+PiNdPJqcs66FQul9R+FiKSRtK1261cvZez6GcwpOp0jRp4QdBwRkaRJ28K/4elphAnR96u3BB1FRCSp0rLwL539CmOrX2HeYf9Bj5KBQccREUmqtCv8HokQmfkjNlPE8K+p+6aIpJ+0K/zzX3mcIQ0L+efQyyjo2DnoOCIiSZdWhT/c2EjR2z+lzHozZsoVQccREQlEWhX+OX+5m/6RMirGXUdWdk7QcUREApE2hX9XbQ395t/Jsswj9bCWiKS1tCn88575P3qwhYYv3KyHtUQkraVFBazatoXBK+5nQe4xHH38WUHHEREJVFoU/oVP/4wiauhw5s1BRxERCVzKF/7Kig2MWPsIc/NP0tAMIiIEVPjN7AwzW2pmK8xsWiKvtfSpH5NLHV3PvjmRlxERaTeSXvjNLAP4DXAmMBQ4z8yGJuJa5Z+sYtTGp5hbdDr9hoxNxCVERNqdIO74xwEr3H2lu9cDM4DJibjQqmduJoMIvSf/OBGnFxFpl4Io/H2Asmbr62LbPsPMLjGz2WY2u6KiolUX8qJ+zO59Pn0GDGldUhGRFJQZwDVtL9v8Xza43wfcB1BaWvovP4/HhAv+pzWHiYiktCDu+NcBhzVbLwHWB5BDRCQtBVH4PwAGmdnhZpYNnAs8F0AOEZG0lPSmHndvNLPLgJlABvCguy9Mdg4RkXQVRBs/7v4i8GIQ1xYRSXcp/+SuiIh8lgq/iEiaUeEXEUkzKvwiImnG3Fv1bFRSmVkFsKaVh3cDNrdhnPZAnzk96DOnvoP9vP3cvXjPje2i8B8MM5vt7qVB50gmfeb0oM+c+hL1edXUIyKSZlT4RUTSTDoU/vuCDhAAfeb0oM+c+hLyeVO+jV9ERD4rHe74RUSkGRV+EZE0k9KFP5mTugfNzA4zs1fNbLGZLTSz7wWdKVnMLMPMPjSz54POkgxmVmRmT5nZkth/72ODzpRoZnZl7O/1x2b2mJnlBp2prZnZg2ZWbmYfN9vWxcxeMrPlsWXntrhWyhb+ZE7qfohoBK529yHABODSFP+8zX0PWBx0iCS6C/ibuw8GRpLin93M+gBXAKXuPozocO7nBpsqIX4PnLHHtmnALHcfBMyKrR+0lC38JHFS90OBu29w97mx99VEi8G/zGWcasysBDgLuD/oLMlgZh2Bk4AHANy93t23BZsqKTKBPDPLBDqQgrP2ufsbwNY9Nk8GpsfeTwemtMW1UrnwxzWpeyoys/7AaOC9YJMkxZ3AdUAk6CBJMgCoAB6KNW/db2b5QYdKJHf/BPg5sBbYAGx3978Hmypperj7Boje3AHd2+KkqVz445rUPdWYWQHwNPB9d68KOk8imdnZQLm7zwk6SxJlAmOAe9x9NLCDNvrn/6Eq1q49GTgc6A3km9l/BJuqfUvlwp92k7qbWRbRov+ouz8TdJ4kOB6YZGariTblnWxmjwQbKeHWAevcvelfc08R/UWQyk4FVrl7hbs3AM8AxwWcKVk2mVkvgNiyvC1OmsqFP60mdTczI9ruu9jd7wg6TzK4+3+7e4m79yf63/cVd0/pO0F33wiUmdlRsU2nAIsCjJQMa4EJZtYh9vf8FFL8C+1mngOmxt5PBZ5ti5MGMuduMqThpO7HAxcAH5nZvNi2H8TmN5bUcjnwaOyGZiVwYcB5Esrd3zOzp4C5RHuvfUgKDt1gZo8Bnwe6mdk64CbgVuAJM7uY6C/Ar7bJtTRkg4hIeknlph4REdkLFX4RkTSjwi8ikmZU+EVE0owKv4hImknZ7pwirWFmXYkOhgXQEwgTHSIBoNbd0+XBIUlh6s4psg9mdjNQ4+4/DzqLSFtSU49InMysJrb8vJm9bmZPmNkyM7vVzM43s/fN7CMzGxjbr9jMnjazD2Kv44P9BCJRKvwirTOS6DwAw4k+MX2ku48jOjz05bF97gJ+4e7HAF8hTYaOlkOf2vhFWueDpuFyzeyfQNMwwR8BX4i9PxUYGh1eBoCOZlYYmy9BJDAq/CKtU9fsfaTZeoRP/38VAo51953JDCayP2rqEUmcvwOXNa2Y2agAs4jspsIvkjhXAKVmtsDMFgHfDjqQCKg7p4hI2tEdv4hImlHhFxFJMyr8IiJpRoVfRCTNqPCLiKQZFX4RkTSjwi8ikmb+P0QFscEdUFPxAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "run_simulation(10.0, model=m1, y0={'C': 60})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.4. Python Utilities to Build a Model\n",
    "\n",
    "As shown in [1. Brief Tour of E-Cell4 Simulations](tutorial1.html), E-Cell4 also provides the easier way to build a model using `with` statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "with species_attributes():\n",
    "    A | B | {'radius': 0.005, 'D': 1}\n",
    "    C | {'radius': 0.01, 'D': 0.5}\n",
    "\n",
    "with reaction_rules():\n",
    "    A + B == C | (0.01, 0.3)\n",
    "\n",
    "m1 = get_model()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For reversible reactions, `==` is available. In the `with` statement, undeclared variables are automaticaly assumed to be a `Species`. Any Python variables, functions and statement are available even in the `with` block."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import log\n",
    "\n",
    "ka, kd, kf = 0.01, 0.3, 0.1\n",
    "tau = 10.0\n",
    "\n",
    "with reaction_rules():\n",
    "    E0 + S == ES | (ka, kd)\n",
    "\n",
    "    if tau > 0:\n",
    "        ES > E1 + P | kf\n",
    "        E1 > E0 | log(2) / tau\n",
    "    else:\n",
    "        ES > E0 + P | kf\n",
    "\n",
    "m1 = get_model()\n",
    "del ka, kd, kf, tau"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Meanwhile, once some variable is declared even outside the block, you can not use its name as a `Species` as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TypeError(\"Argument 1 must be AnyCallable, ParseObj, InvExp or MulExp. 'int' was given [10].\")\n"
     ]
    }
   ],
   "source": [
    "A = 10\n",
    "\n",
    "try:\n",
    "    with reaction_rules():\n",
    "        A + B == C | (0.01, 0.3)\n",
    "except Exception as e:\n",
    "    print(repr(e))\n",
    "\n",
    "del A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is because `A + B == C` is evaluated as `10 + B == C` due to `A = 10`.\n",
    "\n",
    "In the absence of left or right hand side of `ReactionRule` like synthesis or degradation, you may want to describe like:\n",
    "\n",
    "\n",
    "```python\n",
    "with reaction_rules():\n",
    "    A > | 1.0  # XXX: will raise SyntaxError\n",
    "    > A | 1.0  # XXX: will raise SyntaxError\n",
    "```\n",
    "\n",
    "However, this is not accepted because of the syntax rule on Python. To describe this case, a special operator, tilde `~`, is available. `~` sets a stoichiometric coefficient of the following `Species` as zero, which means the `Species` is just ignored in the `ReactionRule`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['>A|2', 'A>|1']\n"
     ]
    }
   ],
   "source": [
    "with reaction_rules():\n",
    "    ~A > A | 2.0  # equivalent to `create_synthesis_reaction_rule`\n",
    "    A > ~A | 1.0  # equivalent to `create_degradation_reaction_rule`\n",
    "\n",
    "m1 = get_model()\n",
    "print([rr.as_string() for rr in m1.reaction_rules()])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following `Species`' name is not necessarily needed to be the same as others. The model above describes $[A]'=2-1\\times[A]$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from math import exp\n",
    "ret = run_simulation(10.0, model=m1)\n",
    "ret.plot('-', lambda t: 2.0 * (1 - exp(-t)), '--')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A chain of reactions can be described in one line. To split a line into two or more physical lines, wrap lines in a parenthesis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['E+S>ES|0.5', 'ES>E+S|1', 'ES>E+P|1.5']\n"
     ]
    }
   ],
   "source": [
    "with reaction_rules():\n",
    "    (E + S == ES | (0.5, 1.0)\n",
    "         > E + P | 1.5)\n",
    "\n",
    "m1 = get_model()\n",
    "print([rr.as_string() for rr in m1.reaction_rules()])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method uses global variables in `ecell4.util.decorator` (e.g. `REACTION_RULES`) to cache objects created in the `with` statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[<ecell4_base.core.ReactionRule object at 0x149ce5bad378>, <ecell4_base.core.ReactionRule object at 0x149ce5bad1f0>]\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "import ecell4.util.decorator\n",
    "\n",
    "with reaction_rules():\n",
    "    A + B == C | (0.01, 0.3)\n",
    "\n",
    "print(ecell4.util.decorator.REACTION_RULES)  #XXX: Only for debugging\n",
    "get_model()\n",
    "print(ecell4.util.decorator.REACTION_RULES)  #XXX: Only for debugging"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python decorator functions are also available. Decorator functions improve the modularity of the `Model`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(<ecell4_base.core.Species object at 0x149ce5c1b1b8>, False), (<ecell4_base.core.Species object at 0x149ce5c1b570>, False), (<ecell4_base.core.Species object at 0x149ce5c1b768>, False)]\n",
      "[<ecell4_base.core.ReactionRule object at 0x149ce5c1bb58>, <ecell4_base.core.ReactionRule object at 0x149ce5c1b260>]\n"
     ]
    }
   ],
   "source": [
    "@species_attributes\n",
    "def attrgen1(radius, D):\n",
    "    A | B | {'radius': radius, 'D': D}\n",
    "    C | {'radius': radius * 2, 'D': D * 0.5}\n",
    "\n",
    "@reaction_rules\n",
    "def rrgen1(kon, koff):\n",
    "    A + B == C | (kon, koff)\n",
    "\n",
    "attrs1 = attrgen1(0.005, 1)\n",
    "rrs1 = rrgen1(0.01, 0.3)\n",
    "print(attrs1)\n",
    "print(rrs1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In contrast to the `with` statement, do **not** add parentheses after the decorator here. The functions decorated by `reaction_rules` and `species_attributes` return a list of `ReactionRule`s and `Species` respectively. The list can be registered to `Model` at once by using `add_reaction_rules` and `add_species_attributes`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "m1 = NetworkModel()\n",
    "m1.add_species_attributes(attrs1)\n",
    "m1.add_reaction_rules(rrs1)\n",
    "print(m1.num_reaction_rules())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This method is modular and reusable relative to the way using `with` statement.\n",
    "\n",
    "The functions decorated by `species_attributes` and `reaction_rules` are also reusable in the `with` statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "K + KK > KK_K | 0.01\n",
      "KK_K > K + KK | 0.3\n",
      "KK_K > Kp + KK | 0.15\n",
      "Kp + PP > PP_Kp | 0.01\n",
      "PP_Kp > Kp + PP | 0.3\n",
      "PP_Kp > K + PP | 0.15\n"
     ]
    }
   ],
   "source": [
    "@reaction_rules\n",
    "def michaelis_menten(S, P, E, ES, kf, kr, kcat):\n",
    "    S + E == ES | (kf, kr)\n",
    "    ES > P + E | kcat\n",
    "\n",
    "with reaction_rules():\n",
    "    michaelis_menten(K, Kp, KK, KK_K, 0.01, 0.3, 0.15)\n",
    "    michaelis_menten(Kp, K, PP, PP_Kp, 0.01, 0.3, 0.15)\n",
    "\n",
    "m1 = get_model()\n",
    "show(m1)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Edit 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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}