{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ensemble MaBoSS simulations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-08-02T11:24:19.836682Z",
     "iopub.status.busy": "2024-08-02T11:24:19.836548Z",
     "iopub.status.idle": "2024-08-02T11:24:20.714175Z",
     "shell.execute_reply": "2024-08-02T11:24:20.713801Z",
     "shell.execute_reply.started": "2024-08-02T11:24:19.836666Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<script type=\"text/javascript\" id=\"colomoto-setup-8107857\" 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-8107857\", \"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-5354499\" class=\"to-be-removed\">\n",
       "        if (typeof Jupyter != 'undefined') {\n",
       "            \n",
       "    var mymodule_jsapi = {  };\n",
       "    colomoto_extension(Jupyter, \"colomoto-setup-5354499\", \"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"
    }
   ],
   "source": [
    "import maboss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simulating the ensemble"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-08-02T11:24:20.715096Z",
     "iopub.status.busy": "2024-08-02T11:24:20.714840Z",
     "iopub.status.idle": "2024-08-02T11:24:22.752157Z",
     "shell.execute_reply": "2024-08-02T11:24:22.751792Z",
     "shell.execute_reply.started": "2024-08-02T11:24:20.715083Z"
    }
   },
   "outputs": [],
   "source": [
    "simulation = maboss.Ensemble(\n",
    "    path=\"Invasion\",\n",
    "    use_physrandgen=0, \n",
    "    sample_count=100000, \n",
    "    thread_count=6,\n",
    "    max_time=50, time_tick=1,\n",
    "    outputs=['Apoptosis', 'CellCycleArrest', 'Invasion']\n",
    ")\n",
    "\n",
    "result = simulation.run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-08-02T11:24:22.752599Z",
     "iopub.status.busy": "2024-08-02T11:24:22.752491Z",
     "iopub.status.idle": "2024-08-02T11:24:22.825135Z",
     "shell.execute_reply": "2024-08-02T11:24:22.824696Z",
     "shell.execute_reply.started": "2024-08-02T11:24:22.752590Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "result.plot_piechart()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-08-02T11:24:22.825636Z",
     "iopub.status.busy": "2024-08-02T11:24:22.825509Z",
     "iopub.status.idle": "2024-08-02T11:24:22.938165Z",
     "shell.execute_reply": "2024-08-02T11:24:22.937776Z",
     "shell.execute_reply.started": "2024-08-02T11:24:22.825625Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "result.plot_trajectory()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12.3"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "metadata": {
     "collapsed": false
    },
    "source": []
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}