AirCondition.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SoSyM Submission -- AirCondition example\n",
    "\n",
    "## Entity scaffolding and Resources"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from crestdsl.model import *\n",
    "\n",
    "# Resources require a unit and domain\n",
    "watt = Resource(unit=\"Watt\",domain=REAL)  \n",
    "celsius = Resource(\"Celsius\", INTEGER)\n",
    "onoffSwitch = Resource(\"Switch\", [\"on\",\"off\"])\n",
    "colour = Resource(\"Colour\",[\"red\",\"green\"])\n",
    "time = Resource(\"Time\", REAL)\n",
    "\n",
    "class AirCon(Entity):\n",
    "    temperature = Input(celsius, 24)\n",
    "    switch = Input(onoffSwitch, \"off\")\n",
    "    coolingpower = Output(watt, 0)\n",
    "    statuslight = Output(colour, \"red\")\n",
    "\n",
    "    on = State()\n",
    "    off = current = State()\n",
    "\n",
    "my_new_ac = AirCon()\n",
    "my_other_ac = AirCon()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding transitions, updates and influences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DynamicAirCon(AirCon):\n",
    "    # add the ontime port\n",
    "    ontime = Local(time, 0)\n",
    "  \n",
    "    # A transition created by a transition object\n",
    "    off_to_on = Transition(source=\"off\", target=\"on\", guard=(lambda self: self.temperature.value > 22 and self.switch.value == \"on\" and self.ontime.value <= 0))\n",
    "    \n",
    "    # Another transition, this time using the decorator\n",
    "    @transition(source=\"on\", target=\"off\")\n",
    "    def on_to_off(self):\n",
    "        return self.temperature.value <= 22 or self.switch.value == \"off\" or self.ontime.value >= 30\n",
    "    \n",
    "    # update ontime\n",
    "    ontime_when_on = Update(state=\"on\", target=ontime, function=(lambda self, dt: self.ontime.value + dt))  \n",
    "    \n",
    "    # An update via decorator\n",
    "    @update(state=\"off\", target=\"ontime\")\n",
    "    def ontime_when_off(self, dt):\n",
    "        new_time = self.ontime.value - 5 * dt\n",
    "        return max(0, new_time)\n",
    "    \n",
    "    # Adding an update as object\n",
    "    cooling_when_off = Update(state=\"off\", target=\"coolingpower\", function=(lambda self, dt: 0))  \n",
    "    \n",
    "    # An update via decorator\n",
    "    @update(state=\"on\", target=\"coolingpower\")\n",
    "    def cooling_when_on(self, dt):\n",
    "        return (self.temperature.value - 22) * 50\n",
    "    \n",
    "    @influence(source=\"switch\", target=\"statuslight\")\n",
    "    def light_influence(value):\n",
    "        if value == \"on\":\n",
    "            return \"green\"\n",
    "        else:\n",
    "            return \"red\"\n",
    "        \n",
    "dyn_ac = DynamicAirCon()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "    <iframe id=\"iframe_5b331e02-71fc-4836-b649-a250675eb57f\" style=\"padding:0px;\" width=\"100%\" height=\"100%\" id=\"map\" srcdoc=\"\n",
       "    <html>\n",
       "\n",
       "<head>\n",
       "    <meta name=&quot;viewport&quot; content=&quot;width=device-width, initial-scale=1&quot;>\n",
       "    <script src=&quot;https://code.jquery.com/jquery-3.3.1.slim.min.js&quot;\n",
       "        integrity=&quot;sha256-3edrmyuQ0w65f8gfBsqowzjJe2iM6n0nKciPUp8y+7E=&quot; crossorigin=&quot;anonymous&quot;></script>\n",
       "    <link rel=&quot;stylesheet&quot; type=&quot;text/css&quot;\n",
       "        href=&quot;https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/vs.min.css&quot; />\n",
       "    <script src=&quot;https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js&quot;></script>\n",
       "    <script src=&quot;https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/languages/python.min.js&quot;></script>\n",
       "    <script type=&quot;text/javascript&quot;> mxBasePath = 'https://jgraph.github.io/mxgraph/javascript/src/'; </script>\n",
       "    <script type=&quot;text/javascript&quot; src=&quot;https://jgraph.github.io/mxgraph/javascript/src/js/mxClient.js&quot;></script>\n",
       "    <script type='text/javascript' src='https://cdn.jsdelivr.net/npm/elkjs@0.3.0/lib/elk.bundled.js'></script>\n",
       "    <script src=&quot;https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.1.2/rollups/sha256.js&quot;></script>\n",
       "    <script src=&quot;http://pablojs.com/downloads/pablo.min.js&quot;></script>\n",
       "\n",
       "    <style type=&quot;text/css&quot;>\n",
       "        .flow {\n",
       "            stroke-dasharray: 8;\n",
       "            animation: dash 1.2s linear;\n",
       "            animation-iteration-count: infinite;\n",
       "        }\n",
       "\n",
       "        @keyframes dash {\n",
       "            to {\n",
       "                stroke-dashoffset: -16;\n",
       "            }\n",
       "        }\n",
       "    </style>\n",
       "    <script type=&quot;text/javascript&quot;>\n",
       "        window.CREST_DEBUG = false;\n",
       "    \n",
       "        let zoomIn_icon = &quot;data:image/gif;base64,R0lGODlhEAAQAOZvAITL9QqWBgCBAI6VmLHiyP+FVOTj4//////6+f7+/v+VbO7u7gCRALvt0+zr64WertfW1ZLR8//9/QiVBQmWBZmhpJPT9pmmpq/jwcrIx7y7u4/S/f+fRrzrxY7L7Im20palq9HPz/+IW4iOkLKRcKShodra2ozQ/H632pejqJzU7crpz/b39v/ab3h0c8vq0Pz49/6DVfr6+rHM1dv92cv3//2JYLzoyv+qToGgs9//2dz//4Wfr7Hr/+Tj4v/aar/v09/p7o22z/+Xbbe7v8fnz3t4dwmVBv+aQ/L//5GgqMHm1/WtXfaSQ5CVmIe72//TYYepwaaprJTV+vD3/9jW1oSrwwCTAKywsdTT07bP1qrgwf/39aClpL2Ta8rwxPDv77C6wJOanfLy8qHf/v+sULSxr5ual7Csqp7Z9/Pz88HvxautsP/5+IfG7f///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEAAG8ALAAAAAAQABAAAAeSgG+Cg4SFgwchXSliaGOGggkaWjtrPSpOC49VM0k6V0tpFiWPUjU0XwEvQFM8YIYgHQxHFBMCGEIQhhVkNysBRQRPUQaGZh4RDQIEbhsDj2oDAABbKCcPRmEwhg5nOR9WIy5UXjEIjz4ZWTJEJFA4Im2Pgyw2HC1lBVzyghIKSD9MlOwbNKRJEDYDB13AYiKhoUAAOw==&quot;;\n",
       "        let zoomOut_icon = &quot;data:image/gif;base64,R0lGODlhEAAQAOZxAPL//46VmITL9f/6+eTj43eXrejm5P7+/oWerv+FVOTj4o7M7YW83IWfr4fG7YTH7JoSAO7u7tTT04iOkJmmpv/ab//9/Xh0c/+fRnt4d//aapLR87y7u7HM1ZPT9oepwYmhsfb39pGgqIXI8ezr64m20rHr/6QVAMrIx9jW1tLz+9HPz6XE2I22z5zU7ZCVmN/p7oGgs/aSQ/6DVbTi9rSxr/z4957Z97KRcJTV+o7O9f/39f+Xbf/5+PDv7+nm5I7L7PLy8tfW1aaprJmhpIzQ/KHf/v+aQ48OAJejqHUFAP+sUJalq/WtXdz//8vb4LC6wI+lsre7v8v3/6ywsYOdsPr6+sr2//+qTnyqyPD3/9ra2v+IW4/S/aShoZual72Ta//TYa7K2pOanZLO7vPz8/+VbLbP1rnr/7jP3KutsISrw/2JYKClpLCsqv///4MKAP///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEAAHEALAAAAAAQABAAAAeSgHGCg4SFg28rbUljbkGGggccZ05XJi4vEY8pHQAAKjQ3Hl6PQ1MGP09pLDkNPoZMaCcQSHBKDC1ChkRGYlEgVQVZHwSGNUAbZAsPDl0Bj2UBAgIjOkUIGVA2hiRfMSVrExdaYDMDjwooElZSOGFYXD2PgyFsGBVLCTvyghZmRxpNROwbxEMGDDUDB1GgsiWhoUAAOw==&quot;;\n",
       "        let zoomDefault_icon = &quot;data:image/gif;base64,R0lGODlhEAAQAOZzAI6VmP+Xbb28vBUdIsjp9////6bb/aTa/Ly7u4m20oiPkvPz8xojJxwiJP+FVKre+6rc+L7l9SAmKKra9qnY8oOJjITL9bXe9JrR7qCem7Hd8SEkJNfW1YSrw9ra2v/aatjW1qywsautsOz7/Y22z/b39o20wvT//3d9fU1qeUhmd0JhdPaSQ4XI8f/9/f/ab/+aQ7C6wPz49//39c3v+YWerv2JYJKQkP/TYYWTmP+IW4+Skv+VbJ2Zl+7u7v/5+Jual/+sUPLy8pCVmJSXmdHPz/+fRo7O9RgfI/r6+qvj/uzr67e7v8Po+PWtXXt4d3iWrNH4/8vKyvD3/9Lz+7rS2t/p7rOysbrj9L7U26nX8r2Ta/7+/hYeI8Ht/+Tj45GgqJmmprHr/47M7Xh0c4aRlcr2/4iOkP6DVfDv74Ggs/+qTrKRcP/6+Z7W963b+Nz//xQcIneNnP///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEAAHMALAAAAAAQABAAAAeSgHOCg4SFgwVFO2UVPUKGglwIWXBmYhpDPo8gVSgnVE0pEDePRFEbIxIEXQ9yaYY5Xg00JhEDEyQchgpKSFgMF3FvUF+GGRgqFGNaKwYAjwsAbhYtRwc1TzEyhktAagkdZ2RTW2htj1JXAklMbDhrOj+PgyU2Ri9BDjPygi48MB9OwOwbFICFFREDB4UJ4SGhoUAAOw==&quot;;\n",
       "        let print_icon = &quot;data:image/gif;base64,R0lGODlhEAAQAPYAACsrKzU1NUVFRU5OTllZWWRkZGZmZmtra3BwcHJycnV1dXZ2dnd3d3l5eXp6ent7e35+fn9/f4m0f4rHe4KBgoKCgoKDgoODg4eFh4aGhoiIiIyMjI2NjZCOkIySmIyUnI6Wn5CQkJCTlpmZmZubnJ2dnZSukJGcqJKisZKjs6Gio6KjoqioqKipq62tra+wsKmxt6iwubGysrKysrW1tbe8tri4uLm5uLq6ur+/vpHCipyzyaC2zLLM5sDAwMLCwsLExcfHx8jIyMvLys3Nzc/Pz9DPz8rS2dDQ0NHQ0NLR0tPT09XV1dTZ0tfX2NjY2Nvb29zc3N3d3d7e3t/f38zd7MLa8MDb9sLi/8fk/8zl/87m/tXn+9Ho/9Po/9jq/93t/+Dg4OHh4eLi4uPj4+Xl5ebm5ufn5+vr6+zs7O3t7e7u7u/v7+Dw/+Xx/+Ty/+nx+er0//Dw8PHx8fD09/f39/b3+ff4+PD4//b6/fT5//j4+Pv7+/39/f7+/gAAACH5BAEAAH8AIf8LSW1hZ2VNYWdpY2sNZ2FtbWE9MC40NTQ1NQAsAAAAABAAEAAAB7yAf4J/RUxOQIOJg1J3d3l5cDGKiTJ0eHFvbVWTiUdvYF9cWiicgjFcXVpZWDulfx5WVz08KR8yM4ouPy0nHyIqNkpnaEsrgjZPT0w5Q1RocnJqTRM6F385Z2NSUGRsaGZSSjUSJhZ/OFRjZtpSRT80LCQdGAl/QmpSTE9URSwjGxYiLBD4J0gfPnPaycAQ4cGCBAseGPjDwcaYO33qCNGwIOKCAgISGShBZA4SDA8ODADgykIIAgFcyUwUCAA7&quot;;\n",
       "        let outline_icon = &quot;data:image/gif;base64,R0lGODlhEAAQANUpAP816bfc/3Gl2GGQvHGm2M3m/8Dg/+Hv/+fz/wAw//826tLp//826drs/7Ta/+32/7ve//P5/2KRvWKQvP///7TZ/7fb//z+/9rt/8bj/8zl//j7/+Hx/8fk/+Dv/9Tq//P4/8fl/wClAACkAAAx/66urnKm2K+vrwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEAACkALAAAAAAQABAAAAZzwJRwSCwaj8efcsk0/goZE8RSkfwcv+JvAehCAoOl1qTomkyDwSRL/B0YCkbIMApgtYiDaVEQiepsQz9nZyOGf4FCPyAPJBwNfiMGiSk/GyQJJB4YIhodlD8kmKICBAICoBQXBBEPCAQNH6BMtJRIt7hCQQA7&quot;\n",
       "        let enterGroup_icon = &quot;data:image/gif;base64,R0lGODlhEAAQANUAAP797/765P321f765f311P755f3wwv3ww/zww/711P711fvgjvvhjvzlnfvknfvlnf3qr/zqr/3qsPzqsPvdg/zgjr2EFryDFrR6E7F4E7Z8FLZ9FLR6FLR7FLyCFrl/Fbh/FbuBFrqBFqluEKtwEapwEaluEa91Eq1yEq91E6dsEKZrEP///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEAACwALAAAAAAQABAAAAZiQJZwSCwaWavk6khUUZ4UFVM4glJMUxbJWsqirKjsyZrKZioLRiVz5HQ4mMbD4YBjOEQNZLKXTCQRfhtFHwcHBgYIhgcgRyEEBAoCAgkiUxcDAQUFHlksFgAAFp5CFqOkWUEAOw==&quot;;\n",
       "        let exitGroup_icon = &quot;data:image/gif;base64,R0lGODlhEAAQANUAAP797/765P321f765f311P755f3wwv3ww/zww/711P711fvgjvvhjvzlnfvknfvlnf3qr/zqr/3qsPzqsPvdg/zgjr2EFryDFrR6E7F4E7Z8FLZ9FLR6FLR7FLyCFrl/Fbh/FbuBFrqBFqluEKtwEapwEaluEa91Eq1yEq91E6dsEKZrEP///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEAACwALAAAAAAQABAAAAZgQJZwSCwahRbL0WgBAJRLoadQCAwuUVFCIFAQCKEj6EBGGAzkT3EzkUQk7QlEriFyMBiOw/Fo5DscRxkVDAsVGVEsKRSMFCeJKI0UKIklkiSJJpIjiSqSKoksK6MroaFBADs=&quot;;\n",
       "        let homeGroup_icon = &quot;data:image/gif;base64,R0lGODlhEAAQAMQVAOvw+aGknJuhoYOSsIuWq5CaqIKRsJWdpO7z+ufu+YOSsd7o+Nzn99/p+OHq+OTs+e3y+ubu+erw+a2wp555Fv///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEAABUALAAAAAAQABAAAAVkICVWZClSZXVObHumJyTLyJsGUq4DQJCSgkjkJEwISK/D47FqsV4FhyM2g9RGhIYWp8vxfCcGIygsR4wqkUGhXLqXhzSqEpXapYVfJavtNxYEP2FihDZIagoDAwYDhnJ6jnp6IQA7&quot;;\n",
       "        let plot_icon = &quot;data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEASABIAAD/2wBDAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQH/wAALCAAKABABAREA/8QAFwAAAwEAAAAAAAAAAAAAAAAAAAQICv/EACIQAAAGAgICAwAAAAAAAAAAAAECAwQFBgcIABIRExQVIv/aAAgBAQAAPwDX3O7IZSYrndVvS/Yy61fsItZ6NlsC12SkGwD+HrWl3jMlYtjdBYoexFCYjYmUEhi+6OQOPTicbsFnK9n+mo+n+YaNJOQFE1sz7MYoptJrwnDqMg8Z0rJOQrpZPi+falEwVfTLInIVspNRKSovkbB4c//Z&quot;;\n",
       "        let exitPlot_icon = &quot;data:image/gif;base64,R0lGODlhDAAMAIAAAP///0RERCH5BAAAAAAALAAAAAAMAAwAAAIdjI8Hy23w2JtR1bQiVDlIvnVIt3llqKFm4yRuUAAAOw==&quot;;\n",
       "        let exportImage_icon = &quot;data:image/gif;base64,R0lGODlhEAAQAPZCAABeAwBgBQ9tGwtxKBh3LTB2LzJ2MF0+HmZLLG9XOnFYPF98TXheRGF9T3pmTHxqUzyeZm6DWHCPcDS80TvB1Ee4pkC7uXidlX6knHG/qUC+zEfH1V3LyljT22jLxWjXzWXa3HPYyHPc1Xbd4nXh3Hzl4oBoT4NtVIVzXYt5ZZB7ZpWBbJqGc7W7ZP63HfO4J8myS//DHunENoOpn4Wroqabjq+mm7GonrWtpL64sp7Rm4ff44js2IPl5Izy5pXl6Zn769XV1dXV1QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEAAEIALAAAAAAQABAAAAf+gEJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCNSgoKCgoKCgoKSkrKCgoKykIDw8PDw8oKCkoKA8PCQgpDxMTGR4dHSMlPT8+IxcIKQ8TMC4vISQeHyQkPTsXCikPGy8uMTokJSUeJCU7MwwpDxMtLjIkJD4+Pj0lO4A0DykPFBseICQ+PkA8ISQ9NCcqDxQWFRUfIhACAAABBBInKQ8DAAAAAQEBAQEBAQENJykOAQEBAAEAAQEBAQEADQ8pDgYGBQUGBgYGBgYFBREOKQcHBwgKJigrLCwsKicMCTk2NjY3Nzg4ODg4ODg4NzdCQkJCQkJCQkJCQkIGgEJCQkKBADs=&quot;\n",
       "        let xInitCoord = null;\n",
       "        let yInitCoord = null;\n",
       "        let parents = [];\n",
       "        let level = null;\n",
       "        let enterGroupFlag = false;\n",
       "        let outlineWnd;\n",
       "        let lastRemovedOnUpdate = {};\n",
       "        const numberOfPointsForRedrawingEdges = 3;\n",
       "\n",
       "        const objToArray = (obj) => {\n",
       "            return Object.keys(obj).map(function (key) {\n",
       "                return obj[key];\n",
       "            });\n",
       "        }\n",
       "\n",
       "        const setStylesForRoot = (graph) => {\n",
       "            let style = graph.getStylesheet().getDefaultVertexStyle();\n",
       "            style = mxUtils.clone(style);\n",
       "            style[mxConstants.STYLE_SHAPE] = mxConstants.SHAPE_RECTANGLE;\n",
       "            style[mxConstants.STYLE_FILLCOLOR] = '#FFFFFF';\n",
       "            style[mxConstants.STYLE_STROKEWIDTH] = 0;\n",
       "            style[mxConstants.STYLE_STROKECOLOR] = &quot;#FFFFFF&quot;;\n",
       "            graph.getStylesheet().putCellStyle('root', style);\n",
       "        }\n",
       "\n",
       "        const setStylesForEntity = (graph) => {\n",
       "            let style = graph.getStylesheet().getDefaultVertexStyle();\n",
       "            style = mxUtils.clone(style);\n",
       "            style[mxConstants.STYLE_SHAPE] = mxConstants.SHAPE_SWIMLANE;\n",
       "            graph.getStylesheet().putCellStyle('entity', style);\n",
       "        }\n",
       "\n",
       "        const setStylesForOutputPort = (graph) => {\n",
       "            let style = graph.getStylesheet().getDefaultVertexStyle();\n",
       "            style = mxUtils.clone(style);\n",
       "            style[mxConstants.STYLE_FILLCOLOR] = '#fcc5b3';\n",
       "            style[mxConstants.STYLE_SHAPE] = 'output';\n",
       "            style[mxConstants.STYLE_OVERFLOW] = 'width';\n",
       "            style[mxConstants.STYLE_SPACING_RIGHT] = OutputShape.prototype.extrude / 2;\n",
       "            graph.getStylesheet().putCellStyle('output', style);\n",
       "        }\n",
       "\n",
       "        const setStylesForLocalAndMidpoints = (graph) => {\n",
       "            let style = graph.getStylesheet().getDefaultVertexStyle();\n",
       "            style = mxUtils.clone(style);\n",
       "            style[mxConstants.STYLE_FILLCOLOR] = '#d2ceef';\n",
       "            style[mxConstants.STYLE_OVERFLOW] = 'width';\n",
       "            graph.getStylesheet().putCellStyle('local', style);\n",
       "            style = mxUtils.clone(style);\n",
       "            style[mxConstants.STYLE_RESIZABLE] = 0;\n",
       "            graph.getStylesheet().putCellStyle('midpoint', style);\n",
       "        }\n",
       "\n",
       "        const setStylesForInput = (graph) => {\n",
       "            let style = graph.getStylesheet().getDefaultVertexStyle();\n",
       "            style = mxUtils.clone(style);\n",
       "            style[mxConstants.STYLE_FILLCOLOR] = '#b5fed9';\n",
       "            style[mxConstants.STYLE_SHAPE] = 'input';\n",
       "            style[mxConstants.STYLE_OVERFLOW] = 'width';\n",
       "            style[mxConstants.STYLE_SPACING_LEFT] = InputShape.prototype.extrude / 2;\n",
       "            graph.getStylesheet().putCellStyle('input', style);\n",
       "        }\n",
       "\n",
       "        const setStylesForEmbeddedGraph = (graph) => {\n",
       "            let style = graph.getStylesheet().getDefaultVertexStyle();\n",
       "            style = mxUtils.clone(style);\n",
       "            style[mxConstants.STYLE_SHAPE] = 'embeddedGraph';\n",
       "            style[mxConstants.STYLE_SPACING_TOP] = BoxShape.prototype.extrude;\n",
       "            style[mxConstants.STYLE_SPACING_RIGHT] = BoxShape.prototype.extrude;\n",
       "            style[mxConstants.STYLE_GRADIENTCOLOR] = '#FFFFFF';\n",
       "            style[mxConstants.STYLE_SHADOW] = true;\n",
       "            graph.getStylesheet().putCellStyle('embeddedGraph', style);\n",
       "        }\n",
       "\n",
       "        const setStylesForStates = (graph) => {\n",
       "            let style = graph.getStylesheet().getDefaultVertexStyle();\n",
       "            style = mxUtils.clone(style);\n",
       "            style[mxConstants.STYLE_SHAPE] = mxConstants.SHAPE_ELLIPSE;\n",
       "            style[mxConstants.STYLE_FILLCOLOR] = '#e2cbc1';\n",
       "            graph.getStylesheet().putCellStyle('state', style);\n",
       "\n",
       "            // currentstate\n",
       "            style = mxUtils.clone(style);\n",
       "            style[mxConstants.STYLE_SHAPE] = mxConstants.SHAPE_DOUBLE_ELLIPSE;\n",
       "            graph.getStylesheet().putCellStyle('currentstate', style);\n",
       "        }\n",
       "\n",
       "        const setStylesForEdges = (graph) => {\n",
       "            let style = graph.getStylesheet().getDefaultEdgeStyle();\n",
       "            style[mxConstants.STYLE_CURVED] = 1;\n",
       "            style[mxConstants.STYLE_FONTCOLOR] = 'black';\n",
       "            style[mxConstants.STYLE_STROKECOLOR] = 'black';\n",
       "            style[mxConstants.STYLE_STROKEWIDTH] = '1';\n",
       "\n",
       "            style = mxUtils.clone(style);\n",
       "            style[mxConstants.STYLE_DASHED] = true;\n",
       "            style[mxConstants.STYLE_DASH_PATTERN] = &quot;7 3&quot;;\n",
       "            style[mxConstants.STYLE_FIX_DASH] = '1';\n",
       "\n",
       "            graph.getStylesheet().putCellStyle('update', style);\n",
       "\n",
       "            style = mxUtils.clone(style);\n",
       "            style[mxConstants.STYLE_DASH_PATTERN] = &quot;2 2&quot;;\n",
       "            graph.getStylesheet().putCellStyle('action', style);\n",
       "        }\n",
       "\n",
       "        const setStyles = (graph) => {\n",
       "            setStylesForRoot(graph);\n",
       "            setStylesForEntity(graph);\n",
       "            setStylesForOutputPort(graph);\n",
       "            setStylesForLocalAndMidpoints(graph);\n",
       "            setStylesForInput(graph);\n",
       "            setStylesForEmbeddedGraph(graph);\n",
       "            setStylesForStates(graph);\n",
       "            setStylesForEdges(graph);\n",
       "        }\n",
       "\n",
       "        const setGraphGeneralFeatures = (graph) => {\n",
       "            graph.setTooltips(true);\n",
       "            graph.setConnectable(false);\n",
       "            graph.setCellsDisconnectable(false);  // stop edges from disconnecting\n",
       "            graph.setDisconnectOnMove(false);  // stop edges from disconnecting\n",
       "            graph.setCellsEditable(false);\n",
       "            graph.setResizeContainer(false);\n",
       "            graph.setHtmlLabels(true);\n",
       "            graph.isEdgeLabelsMovable(false);\n",
       "            graph.setAllowDanglingEdges(false);\n",
       "            graph.setCellsBendable(true);\n",
       "            graph.graphHandler.setRemoveCellsFromParent(false);\n",
       "            graph.gridSize = 25;\n",
       "        }\n",
       "\n",
       "        const setOulineWindowGeneralFeatures = (outlineWnd) => {\n",
       "            outlineWnd.setMaximizable(false);\n",
       "            outlineWnd.setScrollable(false);\n",
       "            outlineWnd.setResizable(true);\n",
       "            outlineWnd.setVisible(false);\n",
       "        }\n",
       "\n",
       "        const setStylesForToolbarContainer = (tbContainer) => {\n",
       "            tbContainer.style.position = 'absolute';\n",
       "            tbContainer.style.overflow = 'hidden';\n",
       "            tbContainer.style.padding = '2px';\n",
       "            tbContainer.style.left = '0px';\n",
       "            tbContainer.style.top = '0px';\n",
       "            tbContainer.style.width = '24px';\n",
       "            tbContainer.style.bottom = '0px';\n",
       "        }\n",
       "\n",
       "        const createPopupMenu = (graph, menu, cell, evt) => {\n",
       "            if (cell != null) {\n",
       "                if (cell.getChildCount() > 0 && cell.style != &quot;embeddedGraph&quot;) {\n",
       "                    menu.addItem('Enter Group', enterGroup_icon, function () {\n",
       "                        enterGroupFlag = true;\n",
       "                        graph.enterGroup(cell);\n",
       "                    });\n",
       "                }\n",
       "                if (enterGroupFlag === true) {\n",
       "                    menu.addItem('Exit Group', exitGroup_icon, function () {\n",
       "                        graph.exitGroup();\n",
       "                    });\n",
       "                    menu.addItem('Exit ALL Groups', homeGroup_icon, function () {\n",
       "                        enterGroupFlag = false;\n",
       "                        graph.home();\n",
       "                    });\n",
       "                }\n",
       "                if (cell.style === &quot;embeddedGraph&quot;) {\n",
       "                    menu.addItem('Plot', plot_icon, function () {\n",
       "                        let elkgraphEmbedded = cell.childrenGraph;\n",
       "                        let root = {\n",
       "                            'id': 'root',\n",
       "                            'label': { 'label': '', 'text': '' },\n",
       "                            'children': [elkgraphEmbedded],\n",
       "                            'edges': [],\n",
       "                            'cresttype': 'root'\n",
       "                        }\n",
       "                        parents.push(cell.parentGraph);\n",
       "                        if (outlineWnd.isVisible()) {\n",
       "                            outlineWnd.setVisible(false);\n",
       "                        }\n",
       "                        document.getElementById(&quot;outlineContainer&quot;).innerHTML = &quot;&quot;;\n",
       "                        document.getElementById(&quot;graphContainer&quot;).innerHTML = &quot;&quot;;\n",
       "                        mxgraph_main(root);\n",
       "                    });\n",
       "                }\n",
       "                if (parents.length > 0) {\n",
       "                    menu.addItem('Exit Plot', exitPlot_icon, function () {\n",
       "                        enterGroupFlag = false;\n",
       "                        if (outlineWnd.isVisible()) {\n",
       "                            outlineWnd.setVisible(false);\n",
       "                        }\n",
       "                        document.getElementById(&quot;outlineContainer&quot;).innerHTML = &quot;&quot;;\n",
       "                        document.getElementById(&quot;graphContainer&quot;).innerHTML = &quot;&quot;;\n",
       "                        mxgraph_main(parents.pop());\n",
       "                    });\n",
       "                }\n",
       "            }\n",
       "            menu.addSeparator();\n",
       "        };\n",
       "\n",
       "        const setClassForCurrentState = (graph, cells, onChanges) => {\n",
       "            if (typeof cells === &quot;undefined&quot;) {\n",
       "                return;\n",
       "            }\n",
       "            let tempStr = &quot;&quot;;\n",
       "            let tempView;\n",
       "            objToArray(cells).forEach((cell) => {\n",
       "                if (onChanges === true) {\n",
       "                    tempStr = &quot;&quot; + cell.style;\n",
       "                    if (tempStr.split(&quot;;&quot;)[0] === &quot;update&quot; && cell.source.style === &quot;currentstate&quot;) {\n",
       "                        tempView = graph.view.getState(cell);\n",
       "                        if (typeof tempView != &quot;undefined&quot;) {\n",
       "                            tempView.shape.node.getElementsByTagName('path')[1].setAttribute('class', 'flow');\n",
       "                        }\n",
       "                    }\n",
       "                } else if (onChanges === false) {\n",
       "                    if (cell.style === &quot;update&quot; && cell.source.style === &quot;currentstate&quot;) {\n",
       "                        tempView = graph.view.getState(cell);\n",
       "                        if (typeof tempView != &quot;undefined&quot;) {\n",
       "                            tempView.shape.node.getElementsByTagName('path')[1].setAttribute('class', 'flow');\n",
       "                        }\n",
       "                    }\n",
       "                }\n",
       "            });\n",
       "        }\n",
       "\n",
       "        /**\n",
       "        Define a new shape. Based on this:\n",
       "        https://github.com/jgraph/mxgraph-js/blob/master/javascript/examples/shape.html\n",
       "        */\n",
       "        function OutputShape() {\n",
       "            mxCylinder.call(this);\n",
       "        };\n",
       "        mxUtils.extend(OutputShape, mxCylinder);\n",
       "        OutputShape.prototype.extrude = 10;\n",
       "        OutputShape.prototype.redrawPath = function (path, x, y, w, h, isForeground) {\n",
       "            let dy = this.extrude * this.scale;\n",
       "            let dx = this.extrude * this.scale;\n",
       "            if (isForeground) {\n",
       "            } else {\n",
       "                path.moveTo(0, 0);\n",
       "                path.lineTo(w, 0);\n",
       "                path.lineTo(w + dx, h / 2);\n",
       "                path.lineTo(w, h);\n",
       "                path.lineTo(0, h);\n",
       "                path.lineTo(0, 0);\n",
       "                path.close();\n",
       "            }\n",
       "        };\n",
       "        mxCellRenderer.registerShape('output', OutputShape);\n",
       "\n",
       "        function InputShape() {\n",
       "            mxCylinder.call(this);\n",
       "        };\n",
       "        mxUtils.extend(InputShape, mxCylinder);\n",
       "        InputShape.prototype.extrude = 10;\n",
       "        InputShape.prototype.redrawPath = function (path, x, y, w, h, isForeground) {\n",
       "            let dy = this.extrude * this.scale;\n",
       "            let dx = this.extrude * this.scale;\n",
       "            if (isForeground) {\n",
       "            } else {\n",
       "                path.moveTo(0 - dx, 0);\n",
       "                path.lineTo(w, 0);\n",
       "                path.lineTo(w, h);\n",
       "                path.lineTo(0 - dx, h);\n",
       "                path.lineTo(0, h / 2);\n",
       "                path.lineTo(0 - dx, 0);\n",
       "                path.close();\n",
       "            }\n",
       "        };\n",
       "        mxCellRenderer.registerShape('input', InputShape);\n",
       "        // END INPUT DEFINITION\n",
       "\n",
       "        //embedded graph shape\n",
       "        function BoxShape() {\n",
       "            mxCylinder.call(this);\n",
       "        };\n",
       "        mxUtils.extend(BoxShape, mxCylinder);\n",
       "        BoxShape.prototype.extrude = 10;\n",
       "        BoxShape.prototype.redrawPath = function (path, x, y, w, h, isForeground) {\n",
       "            var dy = this.extrude * this.scale;\n",
       "            var dx = this.extrude * this.scale;\n",
       "\n",
       "            if (isForeground) {\n",
       "                path.moveTo(0, dy);\n",
       "                path.lineTo(w - dx, dy);\n",
       "                path.lineTo(w, 0);\n",
       "                path.moveTo(w - dx, dy);\n",
       "                path.lineTo(w - dx, h);\n",
       "            }\n",
       "            else {\n",
       "                path.moveTo(0, dy);\n",
       "                path.lineTo(dx, 0);\n",
       "                path.lineTo(w, 0);\n",
       "                path.lineTo(w, h - dy);\n",
       "                path.lineTo(w - dx, h);\n",
       "                path.lineTo(0, h);\n",
       "                path.lineTo(0, dy);\n",
       "                path.lineTo(dx, 0);\n",
       "                path.close();\n",
       "            }\n",
       "        };\n",
       "        mxCellRenderer.registerShape('embeddedGraph', BoxShape);\n",
       "        //end embedded graph definition\n",
       "\n",
       "        const showModalWindow = (graph, evt, title, content, width, height) => {\n",
       "            let background = document.createElement('div');\n",
       "            background.style.position = 'absolute';\n",
       "            background.style.left = '0px';\n",
       "            background.style.top = '0px';\n",
       "            background.style.right = '0px';\n",
       "            background.style.bottom = '0px';\n",
       "            background.style.background = 'black';\n",
       "            background.style.overflow = 'scroll';\n",
       "\n",
       "            mxUtils.setOpacity(background, 50);\n",
       "            document.body.appendChild(background);\n",
       "\n",
       "            if (mxClient.IS_IE) {\n",
       "                new mxDivResizer(background);\n",
       "            }\n",
       "\n",
       "            let x = Math.max(100, evt.offsetX - width / 2);\n",
       "            let y = Math.max(10, evt.offsetY);\n",
       "            let wnd = new mxWindow(title, content, x, y, width, height, false, true);\n",
       "            wnd.setScrollable(true);\n",
       "            wnd.setClosable(true);\n",
       "\n",
       "            // Fades the background out after after the window has been closed\n",
       "            wnd.addListener(mxEvent.DESTROY, function (evt) {\n",
       "                graph.setEnabled(true);\n",
       "                mxEffects.fadeOut(background, 50, true, 10, 30, true);\n",
       "            });\n",
       "\n",
       "            // close if we click on gray background\n",
       "            background.onclick = function () {\n",
       "                wnd.destroy();\n",
       "            }\n",
       "\n",
       "            graph.setEnabled(false);\n",
       "            graph.tooltipHandler.hide();\n",
       "            wnd.setVisible(true);\n",
       "\n",
       "            $('pre code').each(function (i, block) {\n",
       "                hljs.highlightBlock(block);\n",
       "            });\n",
       "        };\n",
       "\n",
       "        const fitAndCenterGraph = (container, graph) => {\n",
       "            let iframeWidth = iframe.getBoundingClientRect().width;\n",
       "            let graphbounds = graph.getGraphBounds();\n",
       "            let graphWidth = graphbounds.width;\n",
       "            let graphHeight = graphbounds.height;\n",
       "            let ratio = iframeWidth / graphWidth;\n",
       "            let wantedContainerHeight = graphHeight * ratio;\n",
       "            container.style.height = wantedContainerHeight + 'px';\n",
       "            if (iframeWidth < graphWidth) {\n",
       "                graph.fit();\n",
       "            }\n",
       "            graph.center();\n",
       "            iframe.style.height = (wantedContainerHeight + 10) + 'px';\n",
       "\n",
       "            if (xInitCoord === null && yInitCoord === null) {\n",
       "                xInitCoord = graph.getGraphBounds().x;\n",
       "                yInitCoord = graph.getGraphBounds().y;\n",
       "            } else {\n",
       "                graph.view.setTranslate(xInitCoord, yInitCoord);\n",
       "            }\n",
       "        }\n",
       "\n",
       "        //redrawing edges\n",
       "        class Point {\n",
       "            constructor(x, y) {\n",
       "                this.x = x;\n",
       "                this.y = y;\n",
       "            }\n",
       "        }\n",
       "\n",
       "        const calcMiddle = (a, b) => {\n",
       "            return new Point((a.x + b.x) / 2, (a.y + b.y) / 2);\n",
       "        }\n",
       "\n",
       "        const calcPoints = (left, right, source, target, pointsNewEdge) => {\n",
       "            if (left === right) {\n",
       "                return;\n",
       "            }\n",
       "            let middle = Math.floor((left + right) / 2);\n",
       "            pointsNewEdge[middle] = calcMiddle(source, target);\n",
       "            calcPoints(left, middle, source, pointsNewEdge[middle], pointsNewEdge);\n",
       "            calcPoints(middle + 1, right, pointsNewEdge[middle], target, pointsNewEdge);\n",
       "        }\n",
       "\n",
       "        const keepEdgeAndMoveTarget = (edge, sourcePoint, targetPoint, length) => {\n",
       "            edge.geometry.points[length - 1].y = targetPoint.y;\n",
       "            if (length > 1) {\n",
       "                edge.geometry.points[length - 1].x = (targetPoint.x + edge.geometry.points[length - 2].x) / 2;\n",
       "            } else {\n",
       "                edge.geometry.points[length - 1].x = (targetPoint.x + sourcePoint.x) / 2;\n",
       "            }\n",
       "        }\n",
       "\n",
       "        const removeAndRedrawEdge = (graph, oldEdge, source, target, targetPoint, sourcePoint, numberOfPoints) => {\n",
       "            let newEdge = oldEdge;\n",
       "            let cells = [];\n",
       "            cells.push(oldEdge);\n",
       "            graph.removeCells(cells, false);\n",
       "            let edge = graph.insertEdge(graph.getDefaultParent(), newEdge.id, newEdge.value, source, target, newEdge.style);\n",
       "            let pointsNewEdge = [];\n",
       "            calcPoints(0, numberOfPoints, sourcePoint, targetPoint, pointsNewEdge);\n",
       "            let points = [];\n",
       "            for (let i = 0; i < pointsNewEdge.length; i++) {\n",
       "                points.push(new mxPoint(pointsNewEdge[i].x, pointsNewEdge[i].y));\n",
       "            }\n",
       "            edge.geometry.points = points;\n",
       "        }\n",
       "\n",
       "        const calcTargetPoint = (edge, target) => {\n",
       "            let targetX;\n",
       "            let targetY;\n",
       "            if (edge.target.parent.parent.style === &quot;root&quot;) {\n",
       "                targetX = edge.target.geometry.x;\n",
       "                targetY = edge.target.geometry.y + (target.geometry.height / 2);\n",
       "            } else {\n",
       "                targetX = edge.target.parent.geometry.x + edge.target.geometry.x;\n",
       "                targetY = edge.target.parent.geometry.y + edge.target.geometry.y + (target.geometry.height / 2);\n",
       "            }\n",
       "            return new Point(targetX, targetY);\n",
       "        }\n",
       "\n",
       "        const calcSourcePoint = (edge, source) => {\n",
       "            let sourceX;\n",
       "            let sourceY;\n",
       "            if (edge.source.parent.parent.style === &quot;root&quot;) {\n",
       "                sourceX = edge.source.geometry.x;\n",
       "                sourceY = edge.source.geometry.y + (source.geometry.height / 2);\n",
       "            } else {\n",
       "                sourceX = edge.source.parent.geometry.x + edge.source.geometry.x;\n",
       "                sourceY = edge.source.parent.geometry.y + edge.source.geometry.y + (source.geometry.height / 2);\n",
       "            }\n",
       "            return new Point(sourceX, sourceY);\n",
       "        }\n",
       "        /////\n",
       "\n",
       "        //standardizeSVG\n",
       "        const makeSVG = (tag, attrs) => {\n",
       "            let el = document.createElementNS('http://www.w3.org/2000/svg', tag);\n",
       "            for (let k in attrs)\n",
       "                el.setAttribute(k, attrs[k]);\n",
       "            return el;\n",
       "        }\n",
       "\n",
       "        const standardizeSvg = (forSvg) => {\n",
       "            const svg = document.getElementsByTagName(&quot;svg&quot;)[0];\n",
       "            let customSvg = document.createElementNS('http://www.w3.org/2000/svg', &quot;svg&quot;);\n",
       "            let foreignObjects = null;\n",
       "            let stringOnLines = null;\n",
       "            let textElement = null;\n",
       "            customSvg.setAttribute('style', svg.style.cssText);\n",
       "            customSvg.innerHTML = svg.innerHTML;\n",
       "            if (forSvg === true) {\n",
       "                foreignObjects = customSvg.getElementsByTagName(&quot;foreignObject&quot;);\n",
       "                for (let i = foreignObjects.length - 1; i >= 0; i--) {\n",
       "                    if (foreignObjects[i].children[0].innerHTML.indexOf(&quot;<br>&quot;) != -1) {\n",
       "                        stringOnLines = foreignObjects[i].children[0].innerHTML.replace(/<br>/g, &quot;-#temp#-&quot;);\n",
       "                    }\n",
       "                    textElement = makeSVG('text', { x: 0, style: &quot;fill: #774400; font-family: Arial,Helvetica; font-size: 11px; font-weight: bold; alignment-baseline: central&quot; });\n",
       "                    if (stringOnLines != null) {\n",
       "                        textElement.setAttribute('y', 0);\n",
       "                        let strArr = stringOnLines.split(&quot;-#temp#-&quot;);\n",
       "                        for (let j = 0; j < strArr.length; j++) {\n",
       "                            if (j === 0) {\n",
       "                                strArr[j] = strArr[j].replace(/\\s/g, '');\n",
       "                            }\n",
       "                            let tspan = makeSVG('tspan', { x: 8, dy: &quot;1.2em&quot; });\n",
       "                            tspan.textContent = strArr[j];\n",
       "                            textElement.appendChild(tspan);\n",
       "                        }\n",
       "                        stringOnLines = null;\n",
       "                    } else {\n",
       "                        textElement.setAttribute('y', 10);\n",
       "                        textElement.textContent = foreignObjects[i].children[0].innerText;\n",
       "                    }\n",
       "                    foreignObjects[i].parentNode.appendChild(textElement);\n",
       "                    foreignObjects[i].parentNode.removeChild(foreignObjects[i]);\n",
       "                }\n",
       "            }\n",
       "            let newInnerHTML = customSvg.innerHTML.replace(/url\\(about:srcdoc#mx-gradient-c3d9ff-1-ffffff-1-s-0\\)/g, &quot;#c3d9ff&quot;);\n",
       "            customSvg.innerHTML = newInnerHTML;\n",
       "            return customSvg;\n",
       "        }\n",
       "\n",
       "        const plot = (elkgraph) => {\n",
       "            let graph;\n",
       "            let container = document.getElementById('graphContainer');\n",
       "            let outline = document.getElementById('outlineContainer');\n",
       "            let outln;\n",
       "            let toolbarContainer;\n",
       "            let toolbar;\n",
       "\n",
       "            if (!mxClient.isBrowserSupported()) {\n",
       "                mxUtils.error('Browser is not supported!', 200, false);\n",
       "            }\n",
       "            else {\n",
       "                mxEvent.disableContextMenu(container);\n",
       "                graph = new mxGraph(container);\n",
       "                setGraphGeneralFeatures(graph);\n",
       "\n",
       "                graph.popupMenuHandler.factoryMethod = function (menu, cell, evt) {\n",
       "                    return createPopupMenu(graph, menu, cell, evt);\n",
       "                };\n",
       "\n",
       "                //setting up the outline\n",
       "                //i have to figure out how to handle mouseUp for outline -- or to\n",
       "                //find another way to zoom and see the graph\n",
       "                outln = new mxOutline(graph, outline);\n",
       "                outlineWnd = new mxWindow('Outline', outline, 100, 100, 180, 140, false);\n",
       "                setOulineWindowGeneralFeatures(outlineWnd);\n",
       "\n",
       "                //setGraphStyles\n",
       "                setStyles(graph);\n",
       "\n",
       "                toolbarContainer = document.createElement('div');\n",
       "                setStylesForToolbarContainer(toolbarContainer);\n",
       "                document.body.appendChild(toolbarContainer);\n",
       "                toolbar = new mxToolbar(toolbarContainer);\n",
       "                toolbar.addItem('Zoom In', zoomIn_icon, function (evt) {\n",
       "                    graph.zoomIn();\n",
       "                    //setClassForCurrentState(graph, graph.getModel().cells, true);\n",
       "                });\n",
       "                toolbar.addItem('Zoom Out', zoomOut_icon, function (evt) {\n",
       "                    graph.zoomOut();\n",
       "                    //setClassForCurrentState(graph, graph.getModel().cells, true);\n",
       "                });\n",
       "                toolbar.addItem('Actual Size', zoomDefault_icon, function (evt) {\n",
       "                    fitAndCenterGraph(container, graph);\n",
       "                    setClassForCurrentState(graph, graph.getModel().cells, true);\n",
       "                });\n",
       "                toolbar.addItem('Poster Print', print_icon, function (evt) {\n",
       "                    let pageCount = mxUtils.prompt('Enter maximum page count', '1');\n",
       "                    if (pageCount != null) {\n",
       "                        let scale = mxUtils.getScaleForPageCount(pageCount, graph);\n",
       "                        let preview = new mxPrintPreview(graph, scale);\n",
       "                        preview.open();\n",
       "                    }\n",
       "                });\n",
       "                toolbar.addItem('Outline', outline_icon, function (evt) {\n",
       "                    if (outlineWnd.isVisible()) {\n",
       "                        outlineWnd.setVisible(false);\n",
       "                    } else {\n",
       "                        outlineWnd.setVisible(true);\n",
       "                        outln.update(true);\n",
       "                    }\n",
       "                });\n",
       "                toolbar.addItem('Export Graph as SVG', exportImage_icon, function (evt) {\n",
       "                    let svgElement = standardizeSvg(true);\n",
       "                    let data = new XMLSerializer().serializeToString(svgElement);\n",
       "                    let imgData = 'data:image/svg+xml;base64,' + window.btoa(data);\n",
       "                    let a = document.createElement(&quot;a&quot;);\n",
       "                    a.style = &quot;display:none&quot;;\n",
       "                    a.download = &quot;graph.svg&quot;;\n",
       "                    a.href = imgData;\n",
       "                    document.body.appendChild(a);\n",
       "                    a.click();\n",
       "                    document.body.removeChild(a);\n",
       "                });\n",
       "                if (navigator.userAgent.indexOf(&quot;Chrome&quot;) === -1) {\n",
       "                    toolbar.addItem('Export Graph as PNG', exportImage_icon, function (evt) {\n",
       "                        let svgElement = standardizeSvg(false);\n",
       "                        let canvas = document.createElement('canvas');\n",
       "                        var bounds = graph.getGraphBounds();\n",
       "                        svgElement.setAttribute('width', bounds.width);\n",
       "                        svgElement.setAttribute('height', bounds.height);\n",
       "                        canvas.width = bounds.width;\n",
       "                        canvas.height = bounds.height;\n",
       "                        let data = new XMLSerializer().serializeToString(svgElement);\n",
       "                        let win = window.URL || window.webkitURL || window;\n",
       "                        let img = new Image();\n",
       "                        let blob = new Blob([data], { type: 'image/svg+xml' });\n",
       "                        let url = win.createObjectURL(blob);\n",
       "                        img.onload = function () {\n",
       "                            canvas.getContext('2d').drawImage(img, 0, 0);\n",
       "                            win.revokeObjectURL(url);\n",
       "                            let uri = canvas.toDataURL('image/png');\n",
       "                            let a = document.createElement(&quot;a&quot;);\n",
       "                            document.body.appendChild(a);\n",
       "                            a.style = &quot;display: none&quot;;\n",
       "                            a.href = uri;\n",
       "                            a.download = 'graph.png';\n",
       "                            a.click();\n",
       "                            window.URL.revokeObjectURL(uri);\n",
       "                            document.body.removeChild(a);\n",
       "                        };\n",
       "                        img.src = url;\n",
       "                    });\n",
       "                }\n",
       "\n",
       "                graph.getTooltipForCell = function (cell) {\n",
       "                    if (cell.value.text) {\n",
       "                        return '<b>' + cell.value.text + '</b>';\n",
       "                    } else {\n",
       "                        return '<b>' + cell.value.label + '</b>';\n",
       "                    }\n",
       "                }\n",
       "\n",
       "                graph.getLabel = function (cell) {\n",
       "                    if (cell.isEdge()) {\n",
       "                        return '';\n",
       "                    }\n",
       "                    if (cell.style === &quot;embeddedGraph&quot; || cell.style === &quot;entity&quot;) {\n",
       "                        return '<b>' + cell.value.label + '</b>';\n",
       "                    }\n",
       "                    return cell.value.label;\n",
       "                }\n",
       "\n",
       "                let highlightable = [&quot;state&quot;, &quot;currentstate&quot;, &quot;transition&quot;, &quot;local&quot;, &quot;input&quot;, &quot;output&quot;];\n",
       "                let movable = [&quot;state&quot;, &quot;currentstate&quot;, &quot;local&quot;, &quot;input&quot;, &quot;output&quot;, &quot;entity&quot;, &quot;embeddedGraph&quot;];\n",
       "\n",
       "                graph.getSelectionModel().addListener(mxEvent.CHANGE, function (sender, evt) {\n",
       "                    graph.getModel().beginUpdate();\n",
       "                    evt.consume();\n",
       "                    try {\n",
       "                        let remove = evt.properties.added;\n",
       "                        if (typeof remove != &quot;undefined&quot;) {\n",
       "                            for (let i = 0; i < remove.length; i++) {\n",
       "                                let rem = remove[i];\n",
       "                                if ((Object.entries(lastRemovedOnUpdate).length != 0 && lastRemovedOnUpdate.id === rem.id)\n",
       "                                    && (lastRemovedOnUpdate.x != rem.geometry.x || lastRemovedOnUpdate.y != rem.geometry.y)) {\n",
       "                                    let target; //mxCell\n",
       "                                    let targetPoint; //Point\n",
       "                                    let source;\n",
       "                                    let sourcePoint;\n",
       "                                    let edge;\n",
       "                                    if (lastRemovedOnUpdate.style === &quot;entity&quot; || lastRemovedOnUpdate.style === &quot;embeddedGraph&quot;) {\n",
       "                                        let children = rem.children;\n",
       "                                        for (let j = 0; j < children.length; j++) {\n",
       "                                            if (children[j].edges != null) {\n",
       "                                                for (let k = 0, index = 0; k < children[j].edges.length; k++) {\n",
       "                                                    //if the edge is inside the entity\n",
       "                                                    if (children[j].edges[k].source.parent === rem && children[j].edges[k].target.parent === rem) {\n",
       "                                                        continue;\n",
       "                                                    }\n",
       "                                                    target = graph.getModel().getCell(children[j].edges[k].target.id);\n",
       "                                                    source = graph.getModel().getCell(children[j].edges[k].source.id);\n",
       "                                                    edge = children[j].edges[k];\n",
       "                                                    targetPoint = calcTargetPoint(edge, target);\n",
       "                                                    sourcePoint = calcSourcePoint(edge, source);\n",
       "                                                    let len = children[j].edges[k].geometry.points.length;\n",
       "                                                    if ((edge.geometry.points[len - 1].x > targetPoint.x && target.style === &quot;input&quot;)\n",
       "                                                        || (edge.geometry.points[0].x < sourcePoint.x && source.style === &quot;output&quot;)) {\n",
       "                                                        removeAndRedrawEdge(graph, edge, source, target, targetPoint, sourcePoint, numberOfPointsForRedrawingEdges);\n",
       "                                                    } else {\n",
       "                                                        keepEdgeAndMoveTarget(edge, sourcePoint, targetPoint, len);\n",
       "                                                    }\n",
       "                                                }\n",
       "                                            }\n",
       "                                        }\n",
       "                                    }\n",
       "                                    lastRemovedOnUpdate = {};\n",
       "                                }\n",
       "                                if (highlightable.indexOf(rem.getStyle()) < 0) {\n",
       "                                    continue;\n",
       "                                }\n",
       "                                if (rem.edges) {\n",
       "                                    rem.edges.forEach(function (edge) {\n",
       "                                        graph.setCellStyles(mxConstants.STYLE_STROKECOLOR, 'black', [edge]);\n",
       "                                        graph.setCellStyles(mxConstants.STYLE_FONTCOLOR, 'black', [edge]);\n",
       "                                        graph.setCellStyles(mxConstants.STYLE_STROKEWIDTH, '1', [edge]);\n",
       "                                    });\n",
       "                                }\n",
       "                            }\n",
       "                        }\n",
       "                        let added = evt.properties.removed;\n",
       "                        if (typeof added != &quot;undefined&quot;) {\n",
       "                            if (movable.indexOf(added[0].getStyle()) >= 0) {\n",
       "                                lastRemovedOnUpdate.style = added[0].getStyle();\n",
       "                                lastRemovedOnUpdate.id = added[0].id;\n",
       "                                lastRemovedOnUpdate.x = added[0].geometry.x;\n",
       "                                lastRemovedOnUpdate.y = added[0].geometry.y;\n",
       "                            }\n",
       "                            for (let i = 0; i < added.length; i++) {\n",
       "                                let add = added[i];\n",
       "                                if (highlightable.indexOf(add.getStyle()) < 0) {\n",
       "                                    continue;\n",
       "                                }\n",
       "                                if (add.edges) {\n",
       "                                    add.edges.forEach(function (edge) {\n",
       "                                        if (edge.source.id == add.id) {\n",
       "                                            graph.setCellStyles(mxConstants.STYLE_STROKECOLOR, 'blue', [edge]);\n",
       "                                            graph.setCellStyles(mxConstants.STYLE_FONTCOLOR, 'blue', [edge]);\n",
       "                                            graph.setCellStyles(mxConstants.STYLE_STROKEWIDTH, '2', [edge]);\n",
       "\n",
       "                                        } else if (edge.target.id == add.id) {\n",
       "                                            graph.setCellStyles(mxConstants.STYLE_STROKECOLOR, 'red', [edge]);\n",
       "                                            graph.setCellStyles(mxConstants.STYLE_FONTCOLOR, 'red', [edge]);\n",
       "                                            graph.setCellStyles(mxConstants.STYLE_STROKEWIDTH, '2', [edge]);\n",
       "                                        }\n",
       "                                    });\n",
       "                                }\n",
       "                            }\n",
       "                        }\n",
       "                    }\n",
       "                    catch (err) {\n",
       "                        console.log(err);\n",
       "                    }\n",
       "                    finally {\n",
       "                        graph.getModel().endUpdate();\n",
       "                        graph.refresh();\n",
       "                        setClassForCurrentState(graph, graph.getModel().cells, true);\n",
       "                    }\n",
       "                });\n",
       "\n",
       "                // Shift + click for adding/removing bendpoints\n",
       "                mxEdgeHandler.prototype.addEnabled = true;\n",
       "                mxEdgeHandler.prototype.removeEnabled = true;\n",
       "\n",
       "                graph.dblClick = function (evt, cell) {\n",
       "                    // Do not fire a DOUBLE_CLICK event here as mxEditor will\n",
       "                    // consume the event and start the in-place editor.    \n",
       "                    if (graph.isCellFoldable(cell) && cell.style != &quot;root&quot;) {\n",
       "                        if (graph.isCellCollapsed(cell)) {\n",
       "                            graph.foldCells(false, false, null, true);\n",
       "                            setClassForCurrentState(graph, graph.getModel().cells, true);\n",
       "                        } else {\n",
       "                            graph.foldCells(true, false, null, true);\n",
       "                            setClassForCurrentState(graph, graph.getModel().cells, true);\n",
       "                        }\n",
       "                    }\n",
       "\n",
       "                    if (this.isEnabled() && !mxEvent.isConsumed(evt) && cell != null) {\n",
       "                        if (cell.isEdge()) {\n",
       "                            var content = document.createElement('div');\n",
       "                            console.log(cell);\n",
       "                            if (cell.value.code) {\n",
       "                                content.innerHTML = cell.value.code;\n",
       "                            } else {\n",
       "                                content.innerHTML = this.convertValueToString(cell);\n",
       "                            }\n",
       "                            showModalWindow(this, evt, 'SourceCode', content, 800, 300);\n",
       "                        }\n",
       "                    }\n",
       "                    // Disables any default behaviour for the double click\n",
       "                    mxEvent.consume(evt);\n",
       "                };\n",
       "                let parent = graph.getDefaultParent();\n",
       "                parent.setStyle(&quot;root&quot;);\n",
       "\n",
       "                // Adds cells to the model in a single step\n",
       "                graph.getModel().beginUpdate();\n",
       "                try {\n",
       "                    addRecursively(graph, parent, elkgraph);\n",
       "                }\n",
       "                finally {\n",
       "                    graph.getModel().endUpdate();\n",
       "                    fitAndCenterGraph(container, graph);\n",
       "                    setClassForCurrentState(graph, graph.getModel().cells, false);\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "\n",
       "        /******************************\n",
       "                 GRAPH CREATION\n",
       "         ******************************/\n",
       "        function addRecursively(graph, parent, elknode) {\n",
       "            let root = addNode(graph, parent, elknode);\n",
       "            if (elknode.children) {\n",
       "                elknode.children.forEach(function (child) {\n",
       "                    addRecursively(graph, root, child);\n",
       "                });\n",
       "            }\n",
       "            if (elknode.ports) {\n",
       "                elknode.ports.forEach(function (port) {\n",
       "                    addRecursively(graph, root, port);\n",
       "                });\n",
       "            }\n",
       "            if (elknode.edges) {\n",
       "                elknode.edges.forEach(function (edge) {\n",
       "                    addEdge(graph, root, edge);\n",
       "                });\n",
       "            }\n",
       "        }\n",
       "\n",
       "        function addNode(graph, parent, elknode) {\n",
       "            let style = elknode.cresttype;\n",
       "            if (elknode.cresttype == &quot;midpoint&quot;) {\n",
       "                return null;\n",
       "            }\n",
       "            if (elknode.cresttype == 'state' && elknode.currentstate) {\n",
       "                style = 'currentstate';\n",
       "            }\n",
       "            // TODO: we need to be aware that the height of an entity needs to be X pixels higher\n",
       "            // and that we also need to displace all x coordinates by that much\n",
       "            let vertex = graph.insertVertex(parent, elknode.id, elknode.label, elknode.x, elknode.y, elknode.width, elknode.height, style);\n",
       "            if (elknode.cresttype === &quot;embeddedGraph&quot;) {\n",
       "                vertex.childrenGraph = elknode.childrenGraph;\n",
       "                vertex.parentGraph = elknode.parentGraph;\n",
       "            }\n",
       "            return vertex;\n",
       "        }\n",
       "\n",
       "        function addEdge(graph, parent, elknode) {\n",
       "            let style = elknode.cresttype;\n",
       "            let source = graph.getModel().getCell(elknode.sources[0]);\n",
       "            let target = graph.getModel().getCell(elknode.targets[0]);\n",
       "            let edge = graph.insertEdge(parent, elknode.id, elknode.label, source, target, style);\n",
       "            // for transitions add action attachment point\n",
       "            if (style === &quot;transition&quot;) {\n",
       "                let mid = graph.insertVertex(edge, elknode.id + &quot;_mid&quot;, &quot;mid&quot;, 0, 0, 0, 0, 'strokeColor=green;rounded=1;', true);\n",
       "            }\n",
       "            let points = edge.geometry.points || []; // read original\n",
       "\n",
       "            if (elknode.sections && elknode.sections.length > 0) {\n",
       "                section = elknode.sections[0];\n",
       "                if (section.bendPoints) {\n",
       "                    for (let i = 0; i < section.bendPoints.length; i++) {\n",
       "                        points.push(new mxPoint(section.bendPoints[i].x, section.bendPoints[i].y));\n",
       "                    }\n",
       "                }\n",
       "                points.push(new mxPoint(section.endPoint.x, section.endPoint.y));\n",
       "            }\n",
       "            edge.geometry.points = points;  // write back\n",
       "        }\n",
       "\n",
       "        function mxgraph_main(elkgraph) {\n",
       "            const elk = new ELK({\n",
       "                defaultLayoutOptions: {\n",
       "                    'elk.algorithm': 'layered',\n",
       "                    'elk.direction': 'RIGHT',\n",
       "                    'elk.padding': '[top=50,left=50,bottom=50,right=50]',\n",
       "                    'elk.layered.spacing.nodeNodeBetweenLayers': 50,\n",
       "                    'elk.edgeRouting': 'POLYLINE',\n",
       "                    'elk.layered.unnecessaryBendpoints': true\n",
       "                }\n",
       "            });\n",
       "            let templateForEmbeddedGraph = function (id, childrenGraph, parentGraph, height) {\n",
       "                this.id = id;\n",
       "                this.width = 300;\n",
       "                this.height = height;\n",
       "                this.cresttype = 'embeddedGraph';\n",
       "                this.childrenGraph = childrenGraph;\n",
       "                this.parentGraph = parentGraph;\n",
       "                console.log(&quot;XXX&quot;, id, childrenGraph, parentGraph);\n",
       "                // this.label = { 'label': childrenGraph.label, 'text': '' };\n",
       "                this.label = childrenGraph.label;\n",
       "            }\n",
       "            let childrenOfFirstEntity = elkgraph.children[0].children;\n",
       "            let ports = null;\n",
       "            let height = null;\n",
       "            if (level === 3) {\n",
       "                if (typeof childrenOfFirstEntity != &quot;undefined&quot;) {\n",
       "                    for (let i = 0; i < childrenOfFirstEntity.length; i++) {\n",
       "                        let thirdLevelChildrens = childrenOfFirstEntity[i].children;\n",
       "                        if (typeof thirdLevelChildrens != &quot;undefined&quot;) {\n",
       "                            for (let j = 0; j < thirdLevelChildrens.length; j++) {\n",
       "                                if (thirdLevelChildrens[j].cresttype === &quot;entity&quot;) {\n",
       "                                    if (typeof thirdLevelChildrens[j].ports != &quot;undefined&quot;) {\n",
       "                                        ports = thirdLevelChildrens[j].ports;\n",
       "                                        height = ports.length;\n",
       "                                    }\n",
       "                                    let template = new templateForEmbeddedGraph(CryptoJS.SHA256(thirdLevelChildrens[j].id).toString(), thirdLevelChildrens[j], elkgraph, (height * 100) / 2);\n",
       "                                    thirdLevelChildrens[j] = {};\n",
       "                                    thirdLevelChildrens[j] = template;\n",
       "                                    if (ports != null) {\n",
       "                                        thirdLevelChildrens[j].ports = ports;\n",
       "                                        ports = null;\n",
       "                                    }\n",
       "                                }\n",
       "                            }\n",
       "                        }\n",
       "                    }\n",
       "                }\n",
       "            } else if (level === 2) {\n",
       "                if (typeof childrenOfFirstEntity != &quot;undefined&quot;) {\n",
       "                    for (let i = 0; i < childrenOfFirstEntity.length; i++) {\n",
       "                        if (childrenOfFirstEntity[i].cresttype === &quot;entity&quot;) {\n",
       "                            if (typeof childrenOfFirstEntity[i].ports != &quot;undefined&quot;) {\n",
       "                                ports = childrenOfFirstEntity[i].ports;\n",
       "                                height = ports.length;\n",
       "                            }\n",
       "                            let template = new templateForEmbeddedGraph(CryptoJS.SHA256(childrenOfFirstEntity[i].id).toString(), childrenOfFirstEntity[i], elkgraph, (height * 100) / 2);\n",
       "                            childrenOfFirstEntity[i] = {};\n",
       "                            childrenOfFirstEntity[i] = template;\n",
       "                            if (ports != null) {\n",
       "                                childrenOfFirstEntity[i].ports = ports;\n",
       "                                ports = null;\n",
       "                            }\n",
       "                        }\n",
       "                    }\n",
       "                }\n",
       "            }\n",
       "            elk.layout(elkgraph)\n",
       "                .then(function (graph_after_layout) {\n",
       "                    if(window.CREST_DEBUG){\n",
       "                        console.log(&quot;Graph after Layout&quot;, graph_after_layout);\n",
       "                    }\n",
       "                    plot(graph_after_layout);\n",
       "                });\n",
       "        }\n",
       "    </script>\n",
       "    <script type='text/javascript'>\n",
       "        const iframe = window.parent.document.getElementById('iframe_5b331e02-71fc-4836-b649-a250675eb57f');\n",
       "        main = function () {\n",
       "            elkgraph = {'id': 'root', 'label': {'label': '', 'text': ''}, 'children': [{'id': '139635440587608', 'label': {'label': ' | DynamicAirCon', 'text': ''}, 'children': [{'id': '139636171807824', 'label': {'label': 'off'}, 'width': 75, 'height': 75, 'cresttype': 'state', 'currentstate': 1}, {'id': '139636171807992', 'label': {'label': 'on'}, 'width': 75, 'height': 75, 'cresttype': 'state', 'currentstate': 0}, {'id': '139636171808160', 'label': {'label': 'ontime<br />0 (Time)', 'text': '<h3>ontime</h3><p>0 (Time)</p>'}, 'width': 75, 'height': 30, 'cresttype': 'local'}, {'id': '139636171808048_mid', 'label': {'label': '', 'text': '<h3>off_to_on</h3><p>midpoint</p>'}, 'width': 1, 'height': 1, 'cresttype': 'midpoint'}, {'id': '139636171807712_mid', 'label': {'label': '', 'text': '<h3>on_to_off</h3><p>midpoint</p>'}, 'width': 1, 'height': 1, 'cresttype': 'midpoint'}], 'ports': [{'id': '139636171807376', 'label': {'label': 'switch<br />off (Switch)', 'text': '<h3>switch</h3><p>off (Switch)</p>'}, 'width': 75, 'height': 30, 'cresttype': 'input'}, {'id': '139636171808216', 'label': {'label': 'temperature<br />24 (Celsius)', 'text': '<h3>temperature</h3><p>24 (Celsius)</p>'}, 'width': 75, 'height': 30, 'cresttype': 'input'}, {'id': '139636171806424', 'label': {'label': 'coolingpower<br />0 (Watt)', 'text': '<h3>coolingpower</h3><p>0 (Watt)</p>'}, 'width': 75, 'height': 30, 'cresttype': 'output'}, {'id': '139636171808104', 'label': {'label': 'statuslight<br />red (Colour)', 'text': '<h3>statuslight</h3><p>red (Colour)</p>'}, 'width': 75, 'height': 30, 'cresttype': 'output'}], 'edges': [{'id': '139636171808048', 'label': {'label': 'off_to_on', 'text': '<h3>off_to_on</h3><h4>from state off --> to state on</h4>', 'code': '<pre style=&quot;font-size:1.2em;&quot;><code class=&quot;python&quot;>off_to_on = Transition(source=&quot;off&quot;, target=&quot;on&quot;, guard=(lambda self: self.temperature.value > 22 and self.switch.value == &quot;on&quot; and self.ontime.value <= 0))\\n</code></pre>'}, 'sources': ['139636171807824'], 'targets': ['139636171807992'], 'cresttype': 'transition'}, {'id': '139636171807712', 'label': {'label': 'on_to_off', 'text': '<h3>on_to_off</h3><h4>from state on --> to state off</h4>', 'code': '<pre style=&quot;font-size:1.2em;&quot;><code class=&quot;python&quot;>@transition(source=&quot;on&quot;, target=&quot;off&quot;)\\ndef on_to_off(self):\\n    return self.temperature.value <= 22 or self.switch.value == &quot;off&quot; or self.ontime.value >= 30\\n</code></pre>'}, 'sources': ['139636171807992'], 'targets': ['139636171807824'], 'cresttype': 'transition'}, {'id': '139636171808440', 'label': {'label': 'light_influence', 'text': '<h3>light_influence</h3><h4>reads port .switch --> writes port .statuslight</h4>', 'code': '<pre style=&quot;font-size:1.2em;&quot;><code class=&quot;python&quot;>@influence(source=&quot;switch&quot;, target=&quot;statuslight&quot;)\\ndef light_influence(value):\\n    if value == &quot;on&quot;:\\n        return &quot;green&quot;\\n    else:\\n        return &quot;red&quot;\\n</code></pre>'}, 'sources': ['139636171807376'], 'targets': ['139636171808104'], 'cresttype': 'influence'}, {'id': '139636171806312', 'label': {'label': 'cooling_when_off', 'text': '<h3>cooling_when_off</h3><h4>state off --> writes port .coolingpower</h4>', 'code': '<pre style=&quot;font-size:1.2em;&quot;><code class=&quot;python&quot;>cooling_when_off = Update(state=&quot;off&quot;, target=&quot;coolingpower&quot;, function=(lambda self, dt: 0))  \\n</code></pre>'}, 'sources': ['139636171807824'], 'targets': ['139636171806424'], 'cresttype': 'update'}, {'id': '139636171806816', 'label': {'label': 'cooling_when_on', 'text': '<h3>cooling_when_on</h3><h4>state on --> writes port .coolingpower</h4>', 'code': '<pre style=&quot;font-size:1.2em;&quot;><code class=&quot;python&quot;>@update(state=&quot;on&quot;, target=&quot;coolingpower&quot;)\\ndef cooling_when_on(self, dt):\\n    return (self.temperature.value - 22) * 50\\n</code></pre>'}, 'sources': ['139636171807992'], 'targets': ['139636171806424'], 'cresttype': 'update'}, {'id': '139636171807152', 'label': {'label': 'ontime_when_off', 'text': '<h3>ontime_when_off</h3><h4>state off --> writes port .ontime</h4>', 'code': '<pre style=&quot;font-size:1.2em;&quot;><code class=&quot;python&quot;>@update(state=&quot;off&quot;, target=&quot;ontime&quot;)\\ndef ontime_when_off(self, dt):\\n    new_time = self.ontime.value - 5 * dt\\n    return max(0, new_time)\\n</code></pre>'}, 'sources': ['139636171807824'], 'targets': ['139636171808160'], 'cresttype': 'update'}, {'id': '139636171807936', 'label': {'label': 'ontime_when_on', 'text': '<h3>ontime_when_on</h3><h4>state on --> writes port .ontime</h4>', 'code': '<pre style=&quot;font-size:1.2em;&quot;><code class=&quot;python&quot;>ontime_when_on = Update(state=&quot;on&quot;, target=ontime, function=(lambda self, dt: self.ontime.value + dt))  \\n</code></pre>'}, 'sources': ['139636171807992'], 'targets': ['139636171808160'], 'cresttype': 'update'}], 'cresttype': 'entity', 'width': 300, 'height': 200}], 'edges': [], 'cresttype': 'root'};\n",
       "            level = 1;\n",
       "            if(window.CREST_DEBUG){\n",
       "                console.log(&quot;Graph as JSON&quot;, elkgraph);\n",
       "            }\n",
       "            mxgraph_main(elkgraph);\n",
       "        };\n",
       "    </script>\n",
       "</head>\n",
       "\n",
       "<body onload='main()' style=&quot;margin:0px;overflow:hidden;&quot;>\n",
       "    <div id=&quot;outlineContainer&quot; style=&quot;height:100%;width:100%;&quot;></div>\n",
       "    <div id='graphContainer'\n",
       "        style='position:absolute;overflow:hidden;left:24px;top:0px;right:0px;bottom:0px;cursor:default;'></div>\n",
       "</body>\n",
       "\n",
       "</html>\n",
       "    \" />\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from crestdsl.ui import plot\n",
    "plot(DynamicAirCon())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simulation example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "ERROR:crestdsl.simulation.interactivesimulator:There is an error in the 'colored' package. They use 'fileno'. I guess we have to wait for a fix.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DynamicAirCon.off 0\n",
      "DynamicAirCon.on 0 on\n",
      "DynamicAirCon.on 10\n",
      "DynamicAirCon.off 30\n"
     ]
    }
   ],
   "source": [
    "from crestdsl.simulation import Simulator\n",
    "system = DynamicAirCon() # create system\n",
    "sim = Simulator(system) # init simulator\n",
    "sim.stabilise()  # fsm state is off\n",
    "print(system.current, system.ontime.value)\n",
    "\n",
    "system.switch.value = \"on\" # modify input\n",
    "sim.stabilise() # state: on\n",
    "print(system.current, system.ontime.value, system.switch.value)\n",
    "sim.advance(10) # ontime: 10\n",
    "print(system.current, system.ontime.value)\n",
    "sim.advance(20) # ontime: 30, state: off\n",
    "print(system.current, system.ontime.value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple verification with convenience API"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:crestdsl.verification.verifier:Caution: No end time set for formula. This means statespace will be explored until exhausted (possibly forever !!)\n",
      "WARNING:crestdsl.verification.verifier:Caution: No end time set for formula. This means statespace will be explored until exhausted (possibly forever !!)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "from crestdsl.verification import check, is_possible, always, before\n",
    "\n",
    "system = DynamicAirCon()\n",
    "system.switch.value = \"on\"  # turn on the AC\n",
    "chk = check(system.ontime) == 25\n",
    "\n",
    "# model checking\n",
    "print(is_possible(chk).check()) # True\n",
    "print(always(chk).check()) # False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Expert API"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from crestdsl.verification import tctl, check, StateSpace, ModelChecker\n",
    "\n",
    "# define a system and check\n",
    "system = DynamicAirCon()\n",
    "system.switch.value = \"on\"  # turn on the AC\n",
    "chk = check(system) == system.on\n",
    "reach_within_30 = tctl.EF(chk, tctl.Interval(end=30))\n",
    "\n",
    "# explore state space and model checking\n",
    "statespace = StateSpace(system)\n",
    "statespace.explore()\n",
    "mc = ModelChecker(statespace)\n",
    "mc.check(reach_within_30)"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}