{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Toy model\n",
    "\n",
    "We have built a toy model showing the difference between the model outputs when we consider the status of the population or not in a feedback loop from a ligand to a receptor. \n",
    "The model can be interpreted as a cell differentiation between two cell types T1 and T2. \n",
    "\n",
    "The input node I activates a node A, which drives the differntiation into a T1 cell type. In parallel, the node A activates a ligand L, which in turn triggers a receptor R that drives the T2 cell type. To insure mutual exclusivity between the cell types, T2 is only activated in the absence of A and T1 is inhibited by some components of the cascade leading to the T2 cell type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To simulate both cases considering a unique cell (or a population of homogeneous cells), or taking into account the status of the population (some cells may release L, some may not), we use a single model. We define a parameter `$InnerOn` to distinguish between the two cases: a unique cell or a MetaCell."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The update of the receptor R depends on an external parameter `$innerOn`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<script type=\"text/javascript\" id=\"colomoto-setup-5688057\" class=\"to-be-removed\">\n",
       "        if (typeof Jupyter != 'undefined') {\n",
       "            \n",
       "function detect_import(cell, module) {\n",
       "    var code = cell.get_text();\n",
       "    code = code.replace(/\\\\\\n/g, \"\");\n",
       "    var lines = code.split(\"\\n\");\n",
       "    var r_simple = new RegExp(\"^(\"+module+\")$\");\n",
       "    var r_alias = new RegExp(\"^\"+module+\"\\\\s+as\\\\s+(\\\\w+)$\");\n",
       "    for (var i = 0; i < lines.length; ++i) {\n",
       "        if (/^import\\s/.test(lines[i])) {\n",
       "            code = lines[i].substr(7);\n",
       "            var parts = code.split(\",\")\n",
       "            for (var j = 0; j < parts.length; ++j) {\n",
       "                code = parts[j].trim();\n",
       "                var m = code.match(r_simple);\n",
       "                if (!m) {\n",
       "                    m = code.match(r_alias);\n",
       "                }\n",
       "                if (m) {\n",
       "                    return m[1];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "    return module;\n",
       "}\n",
       "\n",
       "function colomoto_replace_call(cell, orig, dest, args, comment=false) {\n",
       "    var call_regexp = new RegExp(\"\\\\.\"+orig.replace(\".\",\"\\\\.\")+\"\\\\(\");\n",
       "    var call_replacer = new RegExp(\"\\\\.\"+orig.replace(\".\",\"\\\\.\")\n",
       "                    + \"\\\\(\\\\s*([^\\\\)]*)?\\\\)\");\n",
       "    var code = cell.get_text();\n",
       "    var lines = code.split(\"\\n\");\n",
       "    if (args) {\n",
       "        var strargs = \", \"+args.join(\", \");\n",
       "    } else {\n",
       "        var strargs = \"\";\n",
       "    }\n",
       "    for (var i = 0; i < lines.length; ++i) {\n",
       "        if (call_regexp.test(lines[i])) {\n",
       "            var code = \"\"\n",
       "            if (comment) {\n",
       "                code += \"#\"+lines[i]+\"\\n\";\n",
       "            }\n",
       "            code += lines[i].replace(call_replacer, \".\"+dest+\"($1\"+strargs+\")\")\n",
       "            lines[i] = code;\n",
       "        }\n",
       "    }\n",
       "    cell.set_text(code)\n",
       "}\n",
       "\n",
       "function colomoto_upload(Jupyter, ssid, input, py_callback_name, orig, dest) {\n",
       "\n",
       "    function callback(out_data) {\n",
       "        var cell_element = $(\"#\"+ssid).parents('.cell');\n",
       "        var cell_idx = Jupyter.notebook.get_cell_elements().index(cell_element);\n",
       "        var cell = Jupyter.notebook.get_cell(cell_idx);\n",
       "\n",
       "        var filename = out_data.content.text;\n",
       "\n",
       "        var code = cell.get_text();\n",
       "        code = code.replace(new RegExp(\"\\\\b\" + orig.replace('.', '\\\\.')\n",
       "                    + \"\\\\(\\\\s*((\\\\w+)=[^\\\\)]*)?\\\\)\"),\n",
       "                dest+\"(\\\"\"+filename+\"\\\",$1)\");\n",
       "        code = code.replace('\",)', '\")')\n",
       "        cell.set_text(code);\n",
       "\n",
       "        Jupyter.notebook.select(cell_idx);\n",
       "        Jupyter.notebook.execute_cell_and_select_below();\n",
       "    }\n",
       "\n",
       "    if (! (window.File && window.FileReader && window.FileList && window.Blob)) {\n",
       "        alert(\"Interactive file upload is not supported by your browser.\");\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    input.disabled = true;\n",
       "    input.style.cursor = \"wait\";\n",
       "    input.parentElement.style.cursor = \"wait\";\n",
       "\n",
       "    var f = input.files[0];\n",
       "    var reader = new FileReader();\n",
       "    reader.onload = (function(f) {\n",
       "        return function (e) {\n",
       "            var obj = {\n",
       "                content: e.target.result,\n",
       "                name: f.name\n",
       "            };\n",
       "\n",
       "            //var pycb = py_callback_name+\"(\"+JSON.stringify(obj)+\")\"\n",
       "            // hack/workaround:\n",
       "            // it seems that Jupyter does not like very long lines\n",
       "            // so we split the data in chunks\n",
       "            var chunk_length = 100;\n",
       "            var pycb = \"__colomoto_upload_name = \" + JSON.stringify(obj.name) + \"\\n\";\n",
       "            pycb += \"__colomoto_upload_content = \\\\\\n\";\n",
       "            for (var i = 0; i < obj.content.length; i += chunk_length) {\n",
       "                pycb += \"\\\"\" + obj.content.substr(i, chunk_length)+\"\\\"\\\\\\n\"\n",
       "            }\n",
       "            pycb += \"\\n\"\n",
       "            pycb += py_callback_name+\"({'name':__colomoto_upload_name, 'content': __colomoto_upload_content})\\n\";\n",
       "            pycb += \"del __colomoto_upload_name, __colomoto_upload_content\"\n",
       "\n",
       "            IPython.notebook.kernel.execute(pycb, {iopub: {output: callback}});\n",
       "        };\n",
       "    })(f);\n",
       "    reader.readAsDataURL(f);\n",
       "}\n",
       "\n",
       "function resolve_function(tool_api, funcname) {\n",
       "    if (tool_api.hasOwnProperty(funcname)) {\n",
       "        return tool_api[funcname];\n",
       "    } else {\n",
       "        return window[funcname];\n",
       "    }\n",
       "}\n",
       "\n",
       "function colomoto_extension(Jupyter, ssid, name, menu, toolbar, tool_api) {\n",
       "\n",
       "    function insert_snippet_code(snippet) {\n",
       "        var cell = Jupyter.notebook.get_selected_cell();\n",
       "        Jupyter.notebook.edit_mode();\n",
       "        cell.code_mirror.replaceSelection(snippet, 'around');\n",
       "        //cell.focus_editor();\n",
       "    }\n",
       "\n",
       "    /**\n",
       "        from https://github.com/moble/jupyter_boilerplate/blob/master/main.js\n",
       "    */\n",
       "    function callback_insert_snippet (evt) {\n",
       "        // this (or event.currentTarget, see below) always refers to the DOM\n",
       "        // element the listener was attached to - see\n",
       "        // http://stackoverflow.com/questions/12077859\n",
       "        insert_snippet_code($(evt.currentTarget).data('snippet-code'));\n",
       "    }\n",
       "    function build_menu_element (menu_item_spec, direction) {\n",
       "        // Create the menu item html element\n",
       "        var element = $('<li/>');\n",
       "\n",
       "        if (typeof menu_item_spec == 'string') {\n",
       "            if (menu_item_spec != '---') {\n",
       "                return element.html(menu_item_spec)\n",
       "                        .addClass('ui-state-disabled')\n",
       "                        .attr({\"style\": \"padding:2px .4em\"})\n",
       "                       ;\n",
       "            }\n",
       "            return element.addClass('divider');\n",
       "        }\n",
       "\n",
       "        var a = $('<a/>')\n",
       "            .attr('href', '#')\n",
       "            .html(menu_item_spec.name)\n",
       "            .appendTo(element);\n",
       "        if (menu_item_spec.hasOwnProperty('snippet')) {\n",
       "            var snippet = menu_item_spec.snippet;\n",
       "            if (typeof snippet == 'string' || snippet instanceof String) {\n",
       "                snippet = [snippet];\n",
       "            }\n",
       "            a.attr({\n",
       "                'title' : \"\", // Do not remove this, even though it's empty!\n",
       "                'data-snippet-code' : snippet.join('\\n'),\n",
       "            })\n",
       "            .on('click', callback_insert_snippet)\n",
       "            .addClass('snippet');\n",
       "        }\n",
       "        else if (menu_item_spec.hasOwnProperty('internal-link')) {\n",
       "            a.attr('href', menu_item_spec['internal-link']);\n",
       "        }\n",
       "        else if (menu_item_spec.hasOwnProperty('external-link')) {\n",
       "            a.empty();\n",
       "            a.attr('href', menu_item_spec['external-link']);\n",
       "            a.attr({\n",
       "                'target' : '_blank',\n",
       "                'title' : 'Opens in a new window',\n",
       "            });\n",
       "            $('<i class=\"fa fa-external-link menu-icon pull-right\"/>').appendTo(a);\n",
       "            $('<span/>').html(menu_item_spec.name).appendTo(a);\n",
       "        }\n",
       "\n",
       "        if (menu_item_spec.hasOwnProperty('sub-menu')) {\n",
       "            element\n",
       "                .addClass('dropdown-submenu')\n",
       "                .toggleClass('dropdown-submenu-left', direction === 'left');\n",
       "            var sub_element = $('<ul class=\"dropdown-menu\"/>')\n",
       "                .toggleClass('dropdown-menu-compact', menu_item_spec.overlay === true) // For space-saving menus\n",
       "                .appendTo(element);\n",
       "\n",
       "            var new_direction = (menu_item_spec['sub-menu-direction'] === 'left') ? 'left' : 'right';\n",
       "            for (var j=0; j<menu_item_spec['sub-menu'].length; ++j) {\n",
       "                var sub_menu_item_spec = build_menu_element(menu_item_spec['sub-menu'][j], new_direction);\n",
       "                if(sub_menu_item_spec !== null) {\n",
       "                    sub_menu_item_spec.appendTo(sub_element);\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "\n",
       "        return element;\n",
       "    }\n",
       "\n",
       "    function menu_setup (menu_item_specs, sibling, insert_before_sibling) {\n",
       "        for (var i=0; i<menu_item_specs.length; ++i) {\n",
       "            var menu_item_spec;\n",
       "            if (insert_before_sibling) {\n",
       "                menu_item_spec = menu_item_specs[i];\n",
       "            } else {\n",
       "                menu_item_spec = menu_item_specs[menu_item_specs.length-1-i];\n",
       "            }\n",
       "            var direction = (menu_item_spec['menu-direction'] == 'left') ? 'left' : 'right';\n",
       "            var menu_element = build_menu_element(menu_item_spec, direction);\n",
       "            // We need special properties if this item is in the navbar\n",
       "            if ($(sibling).parent().is('ul.nav.navbar-nav')) {\n",
       "                menu_element\n",
       "                    .addClass('dropdown')\n",
       "                    .removeClass('dropdown-submenu dropdown-submenu-left');\n",
       "                menu_element.children('a')\n",
       "                    .addClass('dropdown-toggle')\n",
       "                    .attr({\n",
       "                        'id': name+'_menu',\n",
       "                        'data-toggle' : 'dropdown',\n",
       "                        'aria-expanded' : 'false'\n",
       "                    });\n",
       "            }\n",
       "\n",
       "            // Insert the menu element into DOM\n",
       "            menu_element[insert_before_sibling ? 'insertBefore': 'insertAfter'](sibling);\n",
       "        }\n",
       "    }\n",
       "    /** end from */\n",
       "\n",
       "\n",
       "    function self_cleanup() {\n",
       "        var cell_element = $(\"script[class='to-be-removed']\").parents('.cell');\n",
       "        var cell_idx = Jupyter.notebook.get_cell_elements().index(cell_element);\n",
       "        var cell = Jupyter.notebook.get_cell(cell_idx);\n",
       "        var to_remove = -1;\n",
       "        for (var i = 0; i < cell.output_area.outputs.length; ++i) {\n",
       "            var oa = cell.output_area.outputs[i];\n",
       "            if (oa.output_type == \"display_data\"\n",
       "                && typeof oa.data[\"text/html\"] != 'undefined'\n",
       "                && oa.data[\"text/html\"].indexOf(' class=\"to-be-removed\"') >= 0) {\n",
       "                to_remove = i;\n",
       "                break;\n",
       "            }\n",
       "        }\n",
       "        if (to_remove == -1) {\n",
       "            console.log(\"cannot find toberemoved\");\n",
       "        } else {\n",
       "            cell.output_area.outputs.splice(to_remove, 1);\n",
       "        }\n",
       "    }\n",
       "\n",
       "    function toolbar_setup(actions) {\n",
       "        var buttons = [];\n",
       "        for (var i = 0; i < actions.length; ++i) {\n",
       "            var setup = actions[i].setup;\n",
       "            if (typeof setup.handler == 'string') {\n",
       "                setup.handler = resolve_function(tool_api, setup.handler);\n",
       "            }\n",
       "            buttons.push(Jupyter.actions.register(actions[i].setup,\n",
       "                actions[i].name, name));\n",
       "        }\n",
       "        $(\"#\"+name+\"-toolbar\").remove();\n",
       "        Jupyter.toolbar.add_buttons_group(buttons, name+\"-toolbar\");\n",
       "    }\n",
       "\n",
       "    function replace_menu_snippets(menu_spec, orig, dest) {\n",
       "        if (menu_spec.hasOwnProperty(\"snippet\")) {\n",
       "            var snippet = menu_spec.snippet;\n",
       "            if (typeof snippet == \"string\" || snippet instanceof String) {\n",
       "                menu_spec[\"snippet\"] = snippet.replace(orig, dest);\n",
       "            } else {\n",
       "                for (var i = 0; i < snippet.length; ++i) {\n",
       "                    menu_spec[\"snippet\"][i] = snippet[i].replace(orig, dest);\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "        if (menu_spec.hasOwnProperty(\"sub-menu\")) {\n",
       "            for (var i = 0; i < menu_spec[\"sub-menu\"].length; ++i) {\n",
       "                replace_menu_snippets(menu_spec[\"sub-menu\"][i], orig, dest);\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "\n",
       "    function load_ipython_extension() {\n",
       "\n",
       "        var mycellelt = $(\"#\"+ssid).parents('.cell');\n",
       "        var myidx = Jupyter.notebook.get_cell_elements().index(mycellelt);\n",
       "        var import_cell = Jupyter.notebook.get_cell(myidx);\n",
       "\n",
       "        var alias = detect_import(import_cell, name);\n",
       "        tool_api.module_alias = alias;\n",
       "        if (alias && alias != name) {\n",
       "            var orig = new RegExp(\"\\\\b\"+name+\"\\\\b\", \"g\");\n",
       "            replace_menu_snippets(menu, orig, alias);\n",
       "        }\n",
       "\n",
       "        if (toolbar) {\n",
       "            toolbar_setup(toolbar);\n",
       "        }\n",
       "\n",
       "        $(\"#\"+name+\"_menu\").parent().remove();\n",
       "        if (menu) {\n",
       "            menu_setup([menu], $(\"#help_menu\").parent(), true);\n",
       "        }\n",
       "\n",
       "        if (tool_api.hasOwnProperty(\"post_install_callback\")) {\n",
       "            tool_api.post_install_callback();\n",
       "        }\n",
       "\n",
       "        setTimeout(self_cleanup, 5000);\n",
       "    };\n",
       "\n",
       "    load_ipython_extension();\n",
       "}\n",
       "\n",
       "function resolve_toolbar_handlers(tool_api, toolbar_spec) {\n",
       "    for (var i = 0; i < toolbar_spec.length; ++i) {\n",
       "        func = resolve_function(tool_api, toolbar_spec[i][\"setup\"][\"handler\"]);\n",
       "        toolbar_spec[i][\"setup\"][\"handler\"] = func;\n",
       "    }\n",
       "    return toolbar_spec\n",
       "}\n",
       "\n",
       "\n",
       "    var minibn_jsapi = {  };\n",
       "    colomoto_extension(Jupyter, \"colomoto-setup-5688057\", \"minibn\", null, null, minibn_jsapi);\n",
       "     }</script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<script type=\"text/javascript\" id=\"colomoto-setup-9932360\" class=\"to-be-removed\">\n",
       "        if (typeof Jupyter != 'undefined') {\n",
       "            \n",
       "    var mymodule_jsapi = {  };\n",
       "    colomoto_extension(Jupyter, \"colomoto-setup-9932360\", \"mymodule\", {\"name\": \"MaBoSS\", \"sub-menu\": [{\"name\": \"Load MaBoSS file\", \"snippet\": [\"masim = maboss.load(\\\"filename.bnd\\\", \\\"filename.cfg\\\")\"]}, {\"name\": \"Network\", \"sub-menu\": [{\"name\": \"Set istate\", \"snippet\": [\"maboss.wg_set_istate(masim)\"]}, {\"name\": \"Get initial state\", \"snippet\": [\"masim.get_initial_state()\"]}]}, {\"name\": \"Simulation\", \"sub-menu\": [{\"name\": \"Create mutant\", \"snippet\": [\"maboss.wg_make_mutant(masim)\"]}, {\"name\": \"Run\", \"snippet\": [\"simres = masim.run()\"]}, {\"name\": \"Set initial states\", \"snippet\": [\"masim.network.set_istate([\\\"mygenelist\\\"],{})\"]}, {\"name\": \"Set output\", \"snippet\": [\"maboss.wg_set_output(masim)\"]}]}, {\"name\": \"Results\", \"sub-menu\": [{\"name\": \"Save results\", \"snippet\": [\"simres.save(\\\"filename\\\")\"]}, {\"name\": \"Plot piechart\", \"snippet\": [\"simres.plot_piechart()\"]}, {\"name\": \"Plot trajectory\", \"snippet\": [\"simres.plot_trajectory()\"]}]}, {\"name\": \"Conversion\", \"sub-menu\": [{\"name\": \"Convert to biolqm\", \"snippet\": [\"biolqm_model = maboss.to_biolqm(masim)\"]}, {\"name\": \"Convert to minibn\", \"snippet\": [\"minibn_model = maboss.to_minibn(masim)\"]}]}, \"---\", {\"name\": \"Documentation\", \"external-link\": \"http://pymaboss.readthedocs.io\"}]}, null, mymodule_jsapi);\n",
       "     }</script><style type=\"text/css\">\n",
       "    #mymodule_menu {\n",
       "        color: green;\n",
       "        background-color: white;\n",
       "    }\n",
       "    </style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Node I {\n",
      "\n",
      "\n",
      "\trate_up = 0.0;\n",
      "\trate_down = 0.0;\n",
      "}\n",
      "Node A {\n",
      "\n",
      "\tlogic = (I | A);\n",
      "\trate_up = @logic ? 1.0 : 0.0;\n",
      "\trate_down = @logic ? 0.0 : 1.0;\n",
      "}\n",
      "\n",
      "Node L {\n",
      "\n",
      "\tlogic = (A | L);\n",
      "\trate_up = @logic ? 1.0 : 0.0;\n",
      "\trate_down = @logic ? 0.0 : 1.0;\n",
      "}\n",
      "\n",
      "Node R {\n",
      "\n",
      "\n",
      "\trate_up = $innerOn ? (L | R) : $outerL;\n",
      "\trate_down = $innerOn ? (!(L | R)) : 0.0 ;\n",
      "}\n",
      "\n",
      "Node T1 {\n",
      "\n",
      "\tlogic = ((A & (!T2)) | T1);\n",
      "\trate_up = @logic ? 1.0 : 0.0;\n",
      "\trate_down = @logic ? 0.0 : 1.0;\n",
      "}\n",
      "\n",
      "Node T2 {\n",
      "\n",
      "\tlogic = ((R & (!A)) | T2);\n",
      "\trate_up = @logic ? 1.0 : 0.0;\n",
      "\trate_down = @logic ? 0.0 : 1.0;\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "import maboss\n",
    "\n",
    "# Set up the required files\n",
    "bnd_file =\"ToyModelUP.bnd\"\n",
    "cfg_file = \"ToyModelUP.cfg\"\n",
    "upp_file = \"ToyModelUP.upp\"\n",
    "\n",
    "# Load and show the MaBoSS model\n",
    "model_maboss = maboss.load(bnd_file,cfg_file)\n",
    "model_maboss.print_bnd()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The activation of R depends on the ligand L:\n",
    "- If `$innerOn` is set at 1, R is activated by the state of L inside the cell.\n",
    "- If `$innerOn` is set at 0, R is activated by the population state of L, through the update function of `$outerL` described in the `upp` file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "$outerL u= 5*p[(L) = (1)];\n",
      "steps = 20;\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Show the upp file\n",
    "with open(upp_file, 'r') as ufile:\n",
    "    print(ufile.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us consider the two cases. Note that the case \"innerOn\" (single cell simulation) is equivalent to the simulation using MaBoSS since no variables are updated, i.e. the parameter `$outerL` is not used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_maboss = maboss.load(bnd_file,cfg_file)\n",
    "\n",
    "# Model of a single cell\n",
    "model_maboss_innerOn = maboss.copy_and_update_parameters(model_maboss,{\"$innerOn\":1})\n",
    "model_upmaboss_innerOn = maboss.UpdatePopulation(model_maboss_innerOn, upp_file)\n",
    "\n",
    "# Model of a population of cells\n",
    "model_maboss_innerOff = maboss.copy_and_update_parameters(model_maboss,{\"$innerOn\":0})\n",
    "model_upmaboss_innerOff = maboss.UpdatePopulation(model_maboss_innerOff, upp_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 92 ms, sys: 132 ms, total: 224 ms\n",
      "Wall time: 1.22 s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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": [
    "%time ur = model_upmaboss_innerOn.run()\n",
    "\n",
    "ur.results[-1].plot_piechart()\n",
    "ur.results[-1]._piefig.savefig(\"On_pop_pie.pdf\")\n",
    "\n",
    "traj = ur.get_nodes_stepwise_probability_distribution()\n",
    "p = traj.plot()\n",
    "p.get_figure().savefig(\"On_pop_traj.pdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 97 ms, sys: 165 ms, total: 262 ms\n",
      "Wall time: 1.34 s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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": [
    "%time ur = model_upmaboss_innerOff.run()\n",
    "\n",
    "ur.results[-1].plot_piechart()\n",
    "ur.results[-1]._piefig.savefig(\"Off_pop_pie.pdf\")\n",
    "\n",
    "traj = ur.get_nodes_stepwise_probability_distribution()\n",
    "p = traj.plot()\n",
    "p.get_figure().savefig(\"Off_pop_traj.pdf\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The node T2 can only be activated if the node R is updated according to the population state of L. This is true because in the model where every reaction can take place inside the cell, if R is present, then A is present as well and inhibits T2 cell type. In the case of the population model, there will be some cells that will have L active (activated by another cell) and A inactive, allowing the differentiation into T2 cell type. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load and show the MaBoSS model\n",
    "model_maboss = maboss.load(bnd_file,cfg_file)\n",
    "model_maboss_20 = maboss.copy_and_update_parameters(model_maboss, {'max_time':20})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 3.43 ms, sys: 10.9 ms, total: 14.3 ms\n",
      "Wall time: 242 ms\n"
     ]
    }
   ],
   "source": [
    "%time tr = model_maboss_20.run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}