Repository: aidotse/PASEOS (language: python)

Issue:
Update run_tests.yml
black and flake8 disagreement on white spaces before colon.

# Description

Summary of changes

* Ignore flake complaint about white space before/after colon



Discussion / hints:

Fix patch:
diff --git a/examples/visualization/example_animation.py b/examples/visualization/example_animation.py
deleted file mode 100644
index 8ffd6a2f..00000000
--- a/examples/visualization/example_animation.py
+++ /dev/null
@@ -1,42 +0,0 @@
-import sys
-
-sys.path.append("../..")
-import paseos
-from paseos.visualization.space_animation import SpaceAnimation
-from paseos.actors.spacecraft_actor import SpacecraftActor
-from paseos.actors.actor_builder import ActorBuilder
-import pykep as pk
-
-
-def animation():
-    """Animate a single satellite in orbit around earth and save to file paseos_test.mp4"""
-    # Define central body
-    earth = pk.planet.jpl_lp("earth")
-
-    # Define local actor
-    sat1 = ActorBuilder.get_actor_scaffold(
-        "sat1", SpacecraftActor, [10000000, 0, 0], pk.epoch(0)
-    )
-    ActorBuilder.set_orbit(sat1, [10000000, 0, 0], [0, 8000.0, 0], pk.epoch(0), earth)
-    ActorBuilder.set_power_devices(sat1, 500, 10000, 1)
-    # init simulation
-    sim = paseos.init_sim(sat1)
-
-    sat2 = ActorBuilder.get_actor_scaffold(
-        "sat2", SpacecraftActor, [10000000, 0, 0], pk.epoch(0)
-    )
-    ActorBuilder.set_orbit(sat2, [0, 10000000, 0], [0, 0, 8000.0], pk.epoch(0), earth)
-    sim.add_known_actor(sat2)
-
-    sat3 = ActorBuilder.get_actor_scaffold(
-        "sat3", SpacecraftActor, [0, -10000000, 0], pk.epoch(0)
-    )
-    ActorBuilder.set_orbit(sat3, [0, -10000000, 0], [0, 0, 8000.0], pk.epoch(0), earth)
-    sim.add_known_actor(sat3)
-
-    anim = SpaceAnimation(sim)
-    anim.animate(sim, dt=200, steps=400, name="paseos_test")
-
-
-if __name__ == "__main__":
-    animation()
diff --git a/examples/visualization/example_interactive_plot.py b/examples/visualization/example_interactive_plot.py
deleted file mode 100644
index eb3cc03c..00000000
--- a/examples/visualization/example_interactive_plot.py
+++ /dev/null
@@ -1,52 +0,0 @@
-import sys
-
-sys.path.append("../..")
-
-import paseos
-from paseos.visualization.space_animation import SpaceAnimation
-from paseos.actors.spacecraft_actor import SpacecraftActor
-from paseos.actors.actor_builder import ActorBuilder
-import pykep as pk
-from loguru import logger
-
-
-def interactive_plot():
-    """Animate two satellites in orbit around earth in interactive mode"""
-    logger.remove()
-    logger.add(sys.stderr, level="INFO")  # using DEBUG level will create tons of text
-
-    # Define central body
-    earth = pk.planet.jpl_lp("earth")
-
-    # Define local actor
-    sat1 = ActorBuilder.get_actor_scaffold(
-        "sat1", SpacecraftActor, [10000000, 0, 0], pk.epoch(0)
-    )
-    ActorBuilder.set_orbit(sat1, [10000000, 0, 0], [0, 8000.0, 0], pk.epoch(0), earth)
-    ActorBuilder.set_power_devices(sat1, 500, 10000, 1)
-
-    # init simulation
-    sim = paseos.init_sim(sat1)
-
-    sat2 = ActorBuilder.get_actor_scaffold(
-        "sat2", SpacecraftActor, [10000000, 0, 0], pk.epoch(0)
-    )
-    ActorBuilder.set_orbit(sat2, [0, 10000000, 0], [0, 0, 8000.0], pk.epoch(0), earth)
-    sim.add_known_actor(sat2)
-
-    sat3 = ActorBuilder.get_actor_scaffold(
-        "sat3", SpacecraftActor, [0, -10000000, 0], pk.epoch(0)
-    )
-    ActorBuilder.set_orbit(sat3, [0, -10000000, 0], [0, 0, 8000.0], pk.epoch(0), earth)
-    sim.add_known_actor(sat3)
-
-    anim = SpaceAnimation(sim)
-
-    dt = 300  # time step in seconds
-    for t in range(400):
-        anim.animate(sim, dt)
-        plt.pause(0.01)
-
-
-if __name__ == "__main__":
-    interactive_plot()
diff --git a/examples/visualization/example_jupyter.ipynb b/examples/visualization/example_jupyter.ipynb
index ff328992..36d98b24 100644
--- a/examples/visualization/example_jupyter.ipynb
+++ b/examples/visualization/example_jupyter.ipynb
@@ -4,14 +4,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Visualization of PASEOS"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### First load the necessary packages"
+    "# Visualization of PASEOS\n",
+    "\n",
+    "First load the necessary packages"
    ]
   },
   {
@@ -23,88 +18,1082 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "\u001b[32m16:53:38\u001b[0m|PASEOS-\u001b[34mDEBUG\u001b[0m| \u001b[34m\u001b[1mSetting LogLevel to DEBUG\u001b[0m\n",
-      "\u001b[32m16:53:38\u001b[0m|PASEOS-\u001b[34mDEBUG\u001b[0m| \u001b[34m\u001b[1mLoaded module.\u001b[0m\n"
+      "\u001b[32m13:26:10\u001b[0m|PASEOS-\u001b[34mDEBUG\u001b[0m| \u001b[34m\u001b[1mSetting LogLevel to DEBUG\u001b[0m\n",
+      "\u001b[32m13:26:10\u001b[0m|PASEOS-\u001b[34mDEBUG\u001b[0m| \u001b[34m\u001b[1mLoaded module.\u001b[0m\n"
      ]
     }
    ],
    "source": [
     "%load_ext autoreload\n",
     "%autoreload 2\n",
+    "\n",
+    "# If you haven't installed PASEOS\n",
     "import sys\n",
     "sys.path.append(\"../..\")\n",
     "\n",
+    "# We use pykep for orbit determination\n",
+    "import pykep as pk\n",
+    "\n",
     "import paseos\n",
-    "from paseos import SpaceAnimation\n",
     "from paseos.actors.spacecraft_actor import SpacecraftActor\n",
     "from paseos.actors.actor_builder import ActorBuilder\n",
-    "import pykep as pk"
+    "paseos.set_log_level(\"INFO\")"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Create a PASEOS object. Add a local actor as satellite 1 and a known actor as satellite 2."
+    "For animations in notebooks you currently need to use `%matplotlib notebook`. This is supported by Jupyter Notebook, but, e.g., VSCode currently does not support this."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 2,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\u001b[32m16:53:39\u001b[0m|PASEOS-\u001b[34mDEBUG\u001b[0m| \u001b[34m\u001b[1mAdded orbit to actor sat1\u001b[0m\n",
-      "\u001b[32m16:53:39\u001b[0m|PASEOS-\u001b[34mDEBUG\u001b[0m| \u001b[34m\u001b[1mAdded power device. MaxBattery=10000Ws, CurrBattery=500Ws, ChargingRate=1W to actor sat1\u001b[0m\n",
-      "\u001b[32m16:53:39\u001b[0m|PASEOS-\u001b[34mDEBUG\u001b[0m| \u001b[34m\u001b[1mInitializing simulation.\u001b[0m\n",
-      "\u001b[32m16:53:39\u001b[0m|PASEOS-\u001b[34mDEBUG\u001b[0m| \u001b[34m\u001b[1mLoading default cfg...\u001b[0m\n",
-      "\u001b[32m16:53:39\u001b[0m|PASEOS-\u001b[34mDEBUG\u001b[0m| \u001b[34m\u001b[1mAdded orbit to actor sat2\u001b[0m\n",
-      "\u001b[32m16:53:39\u001b[0m|PASEOS-\u001b[34mDEBUG\u001b[0m| \u001b[34m\u001b[1mAdding actor:sat2\u001b[0m\n",
-      "\u001b[32m16:53:39\u001b[0m|PASEOS-\u001b[34mDEBUG\u001b[0m| \u001b[34m\u001b[1mCurrent actors: dict_keys([])\u001b[0m\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    " # Define central body\n",
-    "earth = pk.planet.jpl_lp(\"earth\")\n",
-    "\n",
-    "# Define local actor\n",
-    "sat1 = ActorBuilder.get_actor_scaffold(\n",
-    "    \"sat1\", SpacecraftActor, [10000000, 0, 0], pk.epoch(0)\n",
-    ")\n",
-    "ActorBuilder.set_orbit(sat1, [10000000, 0, 0], [0, 8000.0, 0], pk.epoch(0), earth)\n",
-    "ActorBuilder.set_power_devices(sat1, 500, 10000, 1)\n",
-    "\n",
-    "# init simulation\n",
-    "sim = paseos.init_sim(sat1)\n",
-    "\n",
-    "sat2 = ActorBuilder.get_actor_scaffold(\n",
-    "        \"sat2\", SpacecraftActor, [10000000, 0, 0], pk.epoch(0)\n",
-    "    )\n",
-    "ActorBuilder.set_orbit(sat2, [0, 10000000, 0], [0, 0, 8000.0], pk.epoch(0), earth)\n",
-    "sim.add_known_actor(sat2)"
+    "%matplotlib notebook"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Step the simulation in time and visualize the actors."
+    "Create a PASEOS object. Add some actors"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 3,
    "metadata": {},
+   "outputs": [],
+   "source": [
+    " # Define central body\n",
+    "earth = pk.planet.jpl_lp(\"earth\")\n",
+    "sat1 = ActorBuilder.get_actor_scaffold(\n",
+    "        \"sat1\", SpacecraftActor, [0, 0, 0], pk.epoch(0)\n",
+    "    )\n",
+    "sat2 = ActorBuilder.get_actor_scaffold(\n",
+    "    \"sat2\", SpacecraftActor, [0, 0, 0], pk.epoch(0)\n",
+    ")\n",
+    "\n",
+    "# Define local actor\n",
+    "sat3 = ActorBuilder.get_actor_scaffold(\n",
+    "    \"sat3\", SpacecraftActor, [10000000, 0, 0], pk.epoch(0)\n",
+    ")\n",
+    "ActorBuilder.set_orbit(sat3, [-10000000, 0.1, 0.1], [0, 8000.0, 0], pk.epoch(0), earth)\n",
+    "ActorBuilder.set_power_devices(sat3, 500, 10000, 1)\n",
+    "\n",
+    "sat4 = ActorBuilder.get_actor_scaffold(\n",
+    "    \"sat4\", SpacecraftActor, [10000000, 0, 0], pk.epoch(0)\n",
+    ")\n",
+    "ActorBuilder.set_orbit(sat4, [0, 10000000, 0], [0, 0, 8000.0], pk.epoch(0), earth)\n",
+    "\n",
+    "\n",
+    "ActorBuilder.set_orbit(\n",
+    "    sat1,\n",
+    "    position=[10000000, 1e-3, 1e-3],\n",
+    "    velocity=[1e-3, 8000, 1e-3],\n",
+    "    epoch=pk.epoch(0),\n",
+    "    central_body=earth,\n",
+    ")\n",
+    "ActorBuilder.set_orbit(\n",
+    "    sat2,\n",
+    "    position=[10000000, 1e-3, 1e-3],\n",
+    "    velocity=[1e-3, -8000, 1e-3],\n",
+    "    epoch=pk.epoch(0),\n",
+    "    central_body=earth,\n",
+    ")\n",
+    "\n",
+    "# Add communication link\n",
+    "ActorBuilder.add_comm_device(sat1, device_name=\"link1\", bandwidth_in_kbps=1)\n",
+    "ActorBuilder.add_comm_device(sat2, device_name=\"link1\", bandwidth_in_kbps=2)\n",
+    "ActorBuilder.set_power_devices(sat1, 500, 10000, 1)\n",
+    "ActorBuilder.set_power_devices(sat2, 500, 10000, 1)\n",
+    "sim = paseos.init_sim(sat1)\n",
+    "sim.add_known_actor(sat2)\n",
+    "sim.add_known_actor(sat3)\n",
+    "sim.add_known_actor(sat4)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "application/javascript": [
+       "/* Put everything inside the global mpl namespace */\n",
+       "/* global mpl */\n",
+       "window.mpl = {};\n",
+       "\n",
+       "mpl.get_websocket_type = function () {\n",
+       "    if (typeof WebSocket !== 'undefined') {\n",
+       "        return WebSocket;\n",
+       "    } else if (typeof MozWebSocket !== 'undefined') {\n",
+       "        return MozWebSocket;\n",
+       "    } else {\n",
+       "        alert(\n",
+       "            'Your browser does not have WebSocket support. ' +\n",
+       "                'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
+       "                'Firefox 4 and 5 are also supported but you ' +\n",
+       "                'have to enable WebSockets in about:config.'\n",
+       "        );\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n",
+       "    this.id = figure_id;\n",
+       "\n",
+       "    this.ws = websocket;\n",
+       "\n",
+       "    this.supports_binary = this.ws.binaryType !== undefined;\n",
+       "\n",
+       "    if (!this.supports_binary) {\n",
+       "        var warnings = document.getElementById('mpl-warnings');\n",
+       "        if (warnings) {\n",
+       "            warnings.style.display = 'block';\n",
+       "            warnings.textContent =\n",
+       "                'This browser does not support binary websocket messages. ' +\n",
+       "                'Performance may be slow.';\n",
+       "        }\n",
+       "    }\n",
+       "\n",
+       "    this.imageObj = new Image();\n",
+       "\n",
+       "    this.context = undefined;\n",
+       "    this.message = undefined;\n",
+       "    this.canvas = undefined;\n",
+       "    this.rubberband_canvas = undefined;\n",
+       "    this.rubberband_context = undefined;\n",
+       "    this.format_dropdown = undefined;\n",
+       "\n",
+       "    this.image_mode = 'full';\n",
+       "\n",
+       "    this.root = document.createElement('div');\n",
+       "    this.root.setAttribute('style', 'display: inline-block');\n",
+       "    this._root_extra_style(this.root);\n",
+       "\n",
+       "    parent_element.appendChild(this.root);\n",
+       "\n",
+       "    this._init_header(this);\n",
+       "    this._init_canvas(this);\n",
+       "    this._init_toolbar(this);\n",
+       "\n",
+       "    var fig = this;\n",
+       "\n",
+       "    this.waiting = false;\n",
+       "\n",
+       "    this.ws.onopen = function () {\n",
+       "        fig.send_message('supports_binary', { value: fig.supports_binary });\n",
+       "        fig.send_message('send_image_mode', {});\n",
+       "        if (fig.ratio !== 1) {\n",
+       "            fig.send_message('set_device_pixel_ratio', {\n",
+       "                device_pixel_ratio: fig.ratio,\n",
+       "            });\n",
+       "        }\n",
+       "        fig.send_message('refresh', {});\n",
+       "    };\n",
+       "\n",
+       "    this.imageObj.onload = function () {\n",
+       "        if (fig.image_mode === 'full') {\n",
+       "            // Full images could contain transparency (where diff images\n",
+       "            // almost always do), so we need to clear the canvas so that\n",
+       "            // there is no ghosting.\n",
+       "            fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "        }\n",
+       "        fig.context.drawImage(fig.imageObj, 0, 0);\n",
+       "    };\n",
+       "\n",
+       "    this.imageObj.onunload = function () {\n",
+       "        fig.ws.close();\n",
+       "    };\n",
+       "\n",
+       "    this.ws.onmessage = this._make_on_message_function(this);\n",
+       "\n",
+       "    this.ondownload = ondownload;\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype._init_header = function () {\n",
+       "    var titlebar = document.createElement('div');\n",
+       "    titlebar.classList =\n",
+       "        'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n",
+       "    var titletext = document.createElement('div');\n",
+       "    titletext.classList = 'ui-dialog-title';\n",
+       "    titletext.setAttribute(\n",
+       "        'style',\n",
+       "        'width: 100%; text-align: center; padding: 3px;'\n",
+       "    );\n",
+       "    titlebar.appendChild(titletext);\n",
+       "    this.root.appendChild(titlebar);\n",
+       "    this.header = titletext;\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n",
+       "\n",
+       "mpl.figure.prototype._init_canvas = function () {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var canvas_div = (this.canvas_div = document.createElement('div'));\n",
+       "    canvas_div.setAttribute(\n",
+       "        'style',\n",
+       "        'border: 1px solid #ddd;' +\n",
+       "            'box-sizing: content-box;' +\n",
+       "            'clear: both;' +\n",
+       "            'min-height: 1px;' +\n",
+       "            'min-width: 1px;' +\n",
+       "            'outline: 0;' +\n",
+       "            'overflow: hidden;' +\n",
+       "            'position: relative;' +\n",
+       "            'resize: both;'\n",
+       "    );\n",
+       "\n",
+       "    function on_keyboard_event_closure(name) {\n",
+       "        return function (event) {\n",
+       "            return fig.key_event(event, name);\n",
+       "        };\n",
+       "    }\n",
+       "\n",
+       "    canvas_div.addEventListener(\n",
+       "        'keydown',\n",
+       "        on_keyboard_event_closure('key_press')\n",
+       "    );\n",
+       "    canvas_div.addEventListener(\n",
+       "        'keyup',\n",
+       "        on_keyboard_event_closure('key_release')\n",
+       "    );\n",
+       "\n",
+       "    this._canvas_extra_style(canvas_div);\n",
+       "    this.root.appendChild(canvas_div);\n",
+       "\n",
+       "    var canvas = (this.canvas = document.createElement('canvas'));\n",
+       "    canvas.classList.add('mpl-canvas');\n",
+       "    canvas.setAttribute('style', 'box-sizing: content-box;');\n",
+       "\n",
+       "    this.context = canvas.getContext('2d');\n",
+       "\n",
+       "    var backingStore =\n",
+       "        this.context.backingStorePixelRatio ||\n",
+       "        this.context.webkitBackingStorePixelRatio ||\n",
+       "        this.context.mozBackingStorePixelRatio ||\n",
+       "        this.context.msBackingStorePixelRatio ||\n",
+       "        this.context.oBackingStorePixelRatio ||\n",
+       "        this.context.backingStorePixelRatio ||\n",
+       "        1;\n",
+       "\n",
+       "    this.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
+       "\n",
+       "    var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n",
+       "        'canvas'\n",
+       "    ));\n",
+       "    rubberband_canvas.setAttribute(\n",
+       "        'style',\n",
+       "        'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n",
+       "    );\n",
+       "\n",
+       "    // Apply a ponyfill if ResizeObserver is not implemented by browser.\n",
+       "    if (this.ResizeObserver === undefined) {\n",
+       "        if (window.ResizeObserver !== undefined) {\n",
+       "            this.ResizeObserver = window.ResizeObserver;\n",
+       "        } else {\n",
+       "            var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n",
+       "            this.ResizeObserver = obs.ResizeObserver;\n",
+       "        }\n",
+       "    }\n",
+       "\n",
+       "    this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n",
+       "        var nentries = entries.length;\n",
+       "        for (var i = 0; i < nentries; i++) {\n",
+       "            var entry = entries[i];\n",
+       "            var width, height;\n",
+       "            if (entry.contentBoxSize) {\n",
+       "                if (entry.contentBoxSize instanceof Array) {\n",
+       "                    // Chrome 84 implements new version of spec.\n",
+       "                    width = entry.contentBoxSize[0].inlineSize;\n",
+       "                    height = entry.contentBoxSize[0].blockSize;\n",
+       "                } else {\n",
+       "                    // Firefox implements old version of spec.\n",
+       "                    width = entry.contentBoxSize.inlineSize;\n",
+       "                    height = entry.contentBoxSize.blockSize;\n",
+       "                }\n",
+       "            } else {\n",
+       "                // Chrome <84 implements even older version of spec.\n",
+       "                width = entry.contentRect.width;\n",
+       "                height = entry.contentRect.height;\n",
+       "            }\n",
+       "\n",
+       "            // Keep the size of the canvas and rubber band canvas in sync with\n",
+       "            // the canvas container.\n",
+       "            if (entry.devicePixelContentBoxSize) {\n",
+       "                // Chrome 84 implements new version of spec.\n",
+       "                canvas.setAttribute(\n",
+       "                    'width',\n",
+       "                    entry.devicePixelContentBoxSize[0].inlineSize\n",
+       "                );\n",
+       "                canvas.setAttribute(\n",
+       "                    'height',\n",
+       "                    entry.devicePixelContentBoxSize[0].blockSize\n",
+       "                );\n",
+       "            } else {\n",
+       "                canvas.setAttribute('width', width * fig.ratio);\n",
+       "                canvas.setAttribute('height', height * fig.ratio);\n",
+       "            }\n",
+       "            canvas.setAttribute(\n",
+       "                'style',\n",
+       "                'width: ' + width + 'px; height: ' + height + 'px;'\n",
+       "            );\n",
+       "\n",
+       "            rubberband_canvas.setAttribute('width', width);\n",
+       "            rubberband_canvas.setAttribute('height', height);\n",
+       "\n",
+       "            // And update the size in Python. We ignore the initial 0/0 size\n",
+       "            // that occurs as the element is placed into the DOM, which should\n",
+       "            // otherwise not happen due to the minimum size styling.\n",
+       "            if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n",
+       "                fig.request_resize(width, height);\n",
+       "            }\n",
+       "        }\n",
+       "    });\n",
+       "    this.resizeObserverInstance.observe(canvas_div);\n",
+       "\n",
+       "    function on_mouse_event_closure(name) {\n",
+       "        return function (event) {\n",
+       "            return fig.mouse_event(event, name);\n",
+       "        };\n",
+       "    }\n",
+       "\n",
+       "    rubberband_canvas.addEventListener(\n",
+       "        'mousedown',\n",
+       "        on_mouse_event_closure('button_press')\n",
+       "    );\n",
+       "    rubberband_canvas.addEventListener(\n",
+       "        'mouseup',\n",
+       "        on_mouse_event_closure('button_release')\n",
+       "    );\n",
+       "    rubberband_canvas.addEventListener(\n",
+       "        'dblclick',\n",
+       "        on_mouse_event_closure('dblclick')\n",
+       "    );\n",
+       "    // Throttle sequential mouse events to 1 every 20ms.\n",
+       "    rubberband_canvas.addEventListener(\n",
+       "        'mousemove',\n",
+       "        on_mouse_event_closure('motion_notify')\n",
+       "    );\n",
+       "\n",
+       "    rubberband_canvas.addEventListener(\n",
+       "        'mouseenter',\n",
+       "        on_mouse_event_closure('figure_enter')\n",
+       "    );\n",
+       "    rubberband_canvas.addEventListener(\n",
+       "        'mouseleave',\n",
+       "        on_mouse_event_closure('figure_leave')\n",
+       "    );\n",
+       "\n",
+       "    canvas_div.addEventListener('wheel', function (event) {\n",
+       "        if (event.deltaY < 0) {\n",
+       "            event.step = 1;\n",
+       "        } else {\n",
+       "            event.step = -1;\n",
+       "        }\n",
+       "        on_mouse_event_closure('scroll')(event);\n",
+       "    });\n",
+       "\n",
+       "    canvas_div.appendChild(canvas);\n",
+       "    canvas_div.appendChild(rubberband_canvas);\n",
+       "\n",
+       "    this.rubberband_context = rubberband_canvas.getContext('2d');\n",
+       "    this.rubberband_context.strokeStyle = '#000000';\n",
+       "\n",
+       "    this._resize_canvas = function (width, height, forward) {\n",
+       "        if (forward) {\n",
+       "            canvas_div.style.width = width + 'px';\n",
+       "            canvas_div.style.height = height + 'px';\n",
+       "        }\n",
+       "    };\n",
+       "\n",
+       "    // Disable right mouse context menu.\n",
+       "    this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n",
+       "        event.preventDefault();\n",
+       "        return false;\n",
+       "    });\n",
+       "\n",
+       "    function set_focus() {\n",
+       "        canvas.focus();\n",
+       "        canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    window.setTimeout(set_focus, 100);\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function () {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var toolbar = document.createElement('div');\n",
+       "    toolbar.classList = 'mpl-toolbar';\n",
+       "    this.root.appendChild(toolbar);\n",
+       "\n",
+       "    function on_click_closure(name) {\n",
+       "        return function (_event) {\n",
+       "            return fig.toolbar_button_onclick(name);\n",
+       "        };\n",
+       "    }\n",
+       "\n",
+       "    function on_mouseover_closure(tooltip) {\n",
+       "        return function (event) {\n",
+       "            if (!event.currentTarget.disabled) {\n",
+       "                return fig.toolbar_button_onmouseover(tooltip);\n",
+       "            }\n",
+       "        };\n",
+       "    }\n",
+       "\n",
+       "    fig.buttons = {};\n",
+       "    var buttonGroup = document.createElement('div');\n",
+       "    buttonGroup.classList = 'mpl-button-group';\n",
+       "    for (var toolbar_ind in mpl.toolbar_items) {\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) {\n",
+       "            /* Instead of a spacer, we start a new button group. */\n",
+       "            if (buttonGroup.hasChildNodes()) {\n",
+       "                toolbar.appendChild(buttonGroup);\n",
+       "            }\n",
+       "            buttonGroup = document.createElement('div');\n",
+       "            buttonGroup.classList = 'mpl-button-group';\n",
+       "            continue;\n",
+       "        }\n",
+       "\n",
+       "        var button = (fig.buttons[name] = document.createElement('button'));\n",
+       "        button.classList = 'mpl-widget';\n",
+       "        button.setAttribute('role', 'button');\n",
+       "        button.setAttribute('aria-disabled', 'false');\n",
+       "        button.addEventListener('click', on_click_closure(method_name));\n",
+       "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
+       "\n",
+       "        var icon_img = document.createElement('img');\n",
+       "        icon_img.src = '_images/' + image + '.png';\n",
+       "        icon_img.srcset = '_images/' + image + '_large.png 2x';\n",
+       "        icon_img.alt = tooltip;\n",
+       "        button.appendChild(icon_img);\n",
+       "\n",
+       "        buttonGroup.appendChild(button);\n",
+       "    }\n",
+       "\n",
+       "    if (buttonGroup.hasChildNodes()) {\n",
+       "        toolbar.appendChild(buttonGroup);\n",
+       "    }\n",
+       "\n",
+       "    var fmt_picker = document.createElement('select');\n",
+       "    fmt_picker.classList = 'mpl-widget';\n",
+       "    toolbar.appendChild(fmt_picker);\n",
+       "    this.format_dropdown = fmt_picker;\n",
+       "\n",
+       "    for (var ind in mpl.extensions) {\n",
+       "        var fmt = mpl.extensions[ind];\n",
+       "        var option = document.createElement('option');\n",
+       "        option.selected = fmt === mpl.default_extension;\n",
+       "        option.innerHTML = fmt;\n",
+       "        fmt_picker.appendChild(option);\n",
+       "    }\n",
+       "\n",
+       "    var status_bar = document.createElement('span');\n",
+       "    status_bar.classList = 'mpl-message';\n",
+       "    toolbar.appendChild(status_bar);\n",
+       "    this.message = status_bar;\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n",
+       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
+       "    // which will in turn request a refresh of the image.\n",
+       "    this.send_message('resize', { width: x_pixels, height: y_pixels });\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.send_message = function (type, properties) {\n",
+       "    properties['type'] = type;\n",
+       "    properties['figure_id'] = this.id;\n",
+       "    this.ws.send(JSON.stringify(properties));\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.send_draw_message = function () {\n",
+       "    if (!this.waiting) {\n",
+       "        this.waiting = true;\n",
+       "        this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
+       "    var format_dropdown = fig.format_dropdown;\n",
+       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
+       "    fig.ondownload(fig, format);\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_resize = function (fig, msg) {\n",
+       "    var size = msg['size'];\n",
+       "    if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n",
+       "        fig._resize_canvas(size[0], size[1], msg['forward']);\n",
+       "        fig.send_message('refresh', {});\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n",
+       "    var x0 = msg['x0'] / fig.ratio;\n",
+       "    var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n",
+       "    var x1 = msg['x1'] / fig.ratio;\n",
+       "    var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n",
+       "    x0 = Math.floor(x0) + 0.5;\n",
+       "    y0 = Math.floor(y0) + 0.5;\n",
+       "    x1 = Math.floor(x1) + 0.5;\n",
+       "    y1 = Math.floor(y1) + 0.5;\n",
+       "    var min_x = Math.min(x0, x1);\n",
+       "    var min_y = Math.min(y0, y1);\n",
+       "    var width = Math.abs(x1 - x0);\n",
+       "    var height = Math.abs(y1 - y0);\n",
+       "\n",
+       "    fig.rubberband_context.clearRect(\n",
+       "        0,\n",
+       "        0,\n",
+       "        fig.canvas.width / fig.ratio,\n",
+       "        fig.canvas.height / fig.ratio\n",
+       "    );\n",
+       "\n",
+       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n",
+       "    // Updates the figure title.\n",
+       "    fig.header.textContent = msg['label'];\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n",
+       "    fig.rubberband_canvas.style.cursor = msg['cursor'];\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_message = function (fig, msg) {\n",
+       "    fig.message.textContent = msg['message'];\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n",
+       "    // Request the server to send over a new figure.\n",
+       "    fig.send_draw_message();\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n",
+       "    fig.image_mode = msg['mode'];\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n",
+       "    for (var key in msg) {\n",
+       "        if (!(key in fig.buttons)) {\n",
+       "            continue;\n",
+       "        }\n",
+       "        fig.buttons[key].disabled = !msg[key];\n",
+       "        fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n",
+       "    if (msg['mode'] === 'PAN') {\n",
+       "        fig.buttons['Pan'].classList.add('active');\n",
+       "        fig.buttons['Zoom'].classList.remove('active');\n",
+       "    } else if (msg['mode'] === 'ZOOM') {\n",
+       "        fig.buttons['Pan'].classList.remove('active');\n",
+       "        fig.buttons['Zoom'].classList.add('active');\n",
+       "    } else {\n",
+       "        fig.buttons['Pan'].classList.remove('active');\n",
+       "        fig.buttons['Zoom'].classList.remove('active');\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function () {\n",
+       "    // Called whenever the canvas gets updated.\n",
+       "    this.send_message('ack', {});\n",
+       "};\n",
+       "\n",
+       "// A function to construct a web socket function for onmessage handling.\n",
+       "// Called in the figure constructor.\n",
+       "mpl.figure.prototype._make_on_message_function = function (fig) {\n",
+       "    return function socket_on_message(evt) {\n",
+       "        if (evt.data instanceof Blob) {\n",
+       "            var img = evt.data;\n",
+       "            if (img.type !== 'image/png') {\n",
+       "                /* FIXME: We get \"Resource interpreted as Image but\n",
+       "                 * transferred with MIME type text/plain:\" errors on\n",
+       "                 * Chrome.  But how to set the MIME type?  It doesn't seem\n",
+       "                 * to be part of the websocket stream */\n",
+       "                img.type = 'image/png';\n",
+       "            }\n",
+       "\n",
+       "            /* Free the memory for the previous frames */\n",
+       "            if (fig.imageObj.src) {\n",
+       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
+       "                    fig.imageObj.src\n",
+       "                );\n",
+       "            }\n",
+       "\n",
+       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
+       "                img\n",
+       "            );\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        } else if (\n",
+       "            typeof evt.data === 'string' &&\n",
+       "            evt.data.slice(0, 21) === 'data:image/png;base64'\n",
+       "        ) {\n",
+       "            fig.imageObj.src = evt.data;\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        var msg = JSON.parse(evt.data);\n",
+       "        var msg_type = msg['type'];\n",
+       "\n",
+       "        // Call the  \"handle_{type}\" callback, which takes\n",
+       "        // the figure and JSON message as its only arguments.\n",
+       "        try {\n",
+       "            var callback = fig['handle_' + msg_type];\n",
+       "        } catch (e) {\n",
+       "            console.log(\n",
+       "                \"No handler for the '\" + msg_type + \"' message type: \",\n",
+       "                msg\n",
+       "            );\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        if (callback) {\n",
+       "            try {\n",
+       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
+       "                callback(fig, msg);\n",
+       "            } catch (e) {\n",
+       "                console.log(\n",
+       "                    \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n",
+       "                    e,\n",
+       "                    e.stack,\n",
+       "                    msg\n",
+       "                );\n",
+       "            }\n",
+       "        }\n",
+       "    };\n",
+       "};\n",
+       "\n",
+       "// from https://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
+       "mpl.findpos = function (e) {\n",
+       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
+       "    var targ;\n",
+       "    if (!e) {\n",
+       "        e = window.event;\n",
+       "    }\n",
+       "    if (e.target) {\n",
+       "        targ = e.target;\n",
+       "    } else if (e.srcElement) {\n",
+       "        targ = e.srcElement;\n",
+       "    }\n",
+       "    if (targ.nodeType === 3) {\n",
+       "        // defeat Safari bug\n",
+       "        targ = targ.parentNode;\n",
+       "    }\n",
+       "\n",
+       "    // pageX,Y are the mouse positions relative to the document\n",
+       "    var boundingRect = targ.getBoundingClientRect();\n",
+       "    var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n",
+       "    var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n",
+       "\n",
+       "    return { x: x, y: y };\n",
+       "};\n",
+       "\n",
+       "/*\n",
+       " * return a copy of an object with only non-object keys\n",
+       " * we need this to avoid circular references\n",
+       " * https://stackoverflow.com/a/24161582/3208463\n",
+       " */\n",
+       "function simpleKeys(original) {\n",
+       "    return Object.keys(original).reduce(function (obj, key) {\n",
+       "        if (typeof original[key] !== 'object') {\n",
+       "            obj[key] = original[key];\n",
+       "        }\n",
+       "        return obj;\n",
+       "    }, {});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.mouse_event = function (event, name) {\n",
+       "    var canvas_pos = mpl.findpos(event);\n",
+       "\n",
+       "    if (name === 'button_press') {\n",
+       "        this.canvas.focus();\n",
+       "        this.canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    var x = canvas_pos.x * this.ratio;\n",
+       "    var y = canvas_pos.y * this.ratio;\n",
+       "\n",
+       "    this.send_message(name, {\n",
+       "        x: x,\n",
+       "        y: y,\n",
+       "        button: event.button,\n",
+       "        step: event.step,\n",
+       "        guiEvent: simpleKeys(event),\n",
+       "    });\n",
+       "\n",
+       "    /* This prevents the web browser from automatically changing to\n",
+       "     * the text insertion cursor when the button is pressed.  We want\n",
+       "     * to control all of the cursor setting manually through the\n",
+       "     * 'cursor' event from matplotlib */\n",
+       "    event.preventDefault();\n",
+       "    return false;\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n",
+       "    // Handle any extra behaviour associated with a key event\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.key_event = function (event, name) {\n",
+       "    // Prevent repeat events\n",
+       "    if (name === 'key_press') {\n",
+       "        if (event.key === this._key) {\n",
+       "            return;\n",
+       "        } else {\n",
+       "            this._key = event.key;\n",
+       "        }\n",
+       "    }\n",
+       "    if (name === 'key_release') {\n",
+       "        this._key = null;\n",
+       "    }\n",
+       "\n",
+       "    var value = '';\n",
+       "    if (event.ctrlKey && event.key !== 'Control') {\n",
+       "        value += 'ctrl+';\n",
+       "    }\n",
+       "    else if (event.altKey && event.key !== 'Alt') {\n",
+       "        value += 'alt+';\n",
+       "    }\n",
+       "    else if (event.shiftKey && event.key !== 'Shift') {\n",
+       "        value += 'shift+';\n",
+       "    }\n",
+       "\n",
+       "    value += 'k' + event.key;\n",
+       "\n",
+       "    this._key_event_extra(event, name);\n",
+       "\n",
+       "    this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n",
+       "    return false;\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n",
+       "    if (name === 'download') {\n",
+       "        this.handle_save(this, null);\n",
+       "    } else {\n",
+       "        this.send_message('toolbar_button', { name: name });\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n",
+       "    this.message.textContent = tooltip;\n",
+       "};\n",
+       "\n",
+       "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n",
+       "// prettier-ignore\n",
+       "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n",
+       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
+       "\n",
+       "mpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
+       "\n",
+       "mpl.default_extension = \"png\";/* global mpl */\n",
+       "\n",
+       "var comm_websocket_adapter = function (comm) {\n",
+       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
+       "    // object with the appropriate methods. Currently this is a non binary\n",
+       "    // socket, so there is still some room for performance tuning.\n",
+       "    var ws = {};\n",
+       "\n",
+       "    ws.binaryType = comm.kernel.ws.binaryType;\n",
+       "    ws.readyState = comm.kernel.ws.readyState;\n",
+       "    function updateReadyState(_event) {\n",
+       "        if (comm.kernel.ws) {\n",
+       "            ws.readyState = comm.kernel.ws.readyState;\n",
+       "        } else {\n",
+       "            ws.readyState = 3; // Closed state.\n",
+       "        }\n",
+       "    }\n",
+       "    comm.kernel.ws.addEventListener('open', updateReadyState);\n",
+       "    comm.kernel.ws.addEventListener('close', updateReadyState);\n",
+       "    comm.kernel.ws.addEventListener('error', updateReadyState);\n",
+       "\n",
+       "    ws.close = function () {\n",
+       "        comm.close();\n",
+       "    };\n",
+       "    ws.send = function (m) {\n",
+       "        //console.log('sending', m);\n",
+       "        comm.send(m);\n",
+       "    };\n",
+       "    // Register the callback with on_msg.\n",
+       "    comm.on_msg(function (msg) {\n",
+       "        //console.log('receiving', msg['content']['data'], msg);\n",
+       "        var data = msg['content']['data'];\n",
+       "        if (data['blob'] !== undefined) {\n",
+       "            data = {\n",
+       "                data: new Blob(msg['buffers'], { type: data['blob'] }),\n",
+       "            };\n",
+       "        }\n",
+       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
+       "        ws.onmessage(data);\n",
+       "    });\n",
+       "    return ws;\n",
+       "};\n",
+       "\n",
+       "mpl.mpl_figure_comm = function (comm, msg) {\n",
+       "    // This is the function which gets called when the mpl process\n",
+       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
+       "\n",
+       "    var id = msg.content.data.id;\n",
+       "    // Get hold of the div created by the display call when the Comm\n",
+       "    // socket was opened in Python.\n",
+       "    var element = document.getElementById(id);\n",
+       "    var ws_proxy = comm_websocket_adapter(comm);\n",
+       "\n",
+       "    function ondownload(figure, _format) {\n",
+       "        window.open(figure.canvas.toDataURL());\n",
+       "    }\n",
+       "\n",
+       "    var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n",
+       "\n",
+       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
+       "    // web socket which is closed, not our websocket->open comm proxy.\n",
+       "    ws_proxy.onopen();\n",
+       "\n",
+       "    fig.parent_element = element;\n",
+       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
+       "    if (!fig.cell_info) {\n",
+       "        console.error('Failed to find cell for figure', id, fig);\n",
+       "        return;\n",
+       "    }\n",
+       "    fig.cell_info[0].output_area.element.on(\n",
+       "        'cleared',\n",
+       "        { fig: fig },\n",
+       "        fig._remove_fig_handler\n",
+       "    );\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_close = function (fig, msg) {\n",
+       "    var width = fig.canvas.width / fig.ratio;\n",
+       "    fig.cell_info[0].output_area.element.off(\n",
+       "        'cleared',\n",
+       "        fig._remove_fig_handler\n",
+       "    );\n",
+       "    fig.resizeObserverInstance.unobserve(fig.canvas_div);\n",
+       "\n",
+       "    // Update the output cell to use the data from the current canvas.\n",
+       "    fig.push_to_output();\n",
+       "    var dataURL = fig.canvas.toDataURL();\n",
+       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
+       "    // the notebook keyboard shortcuts fail.\n",
+       "    IPython.keyboard_manager.enable();\n",
+       "    fig.parent_element.innerHTML =\n",
+       "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+       "    fig.close_ws(fig, msg);\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.close_ws = function (fig, msg) {\n",
+       "    fig.send_message('closing', msg);\n",
+       "    // fig.ws.close()\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n",
+       "    // Turn the data on the canvas into data in the output cell.\n",
+       "    var width = this.canvas.width / this.ratio;\n",
+       "    var dataURL = this.canvas.toDataURL();\n",
+       "    this.cell_info[1]['text/html'] =\n",
+       "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function () {\n",
+       "    // Tell IPython that the notebook contents must change.\n",
+       "    IPython.notebook.set_dirty(true);\n",
+       "    this.send_message('ack', {});\n",
+       "    var fig = this;\n",
+       "    // Wait a second, then push the new image to the DOM so\n",
+       "    // that it is saved nicely (might be nice to debounce this).\n",
+       "    setTimeout(function () {\n",
+       "        fig.push_to_output();\n",
+       "    }, 1000);\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function () {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var toolbar = document.createElement('div');\n",
+       "    toolbar.classList = 'btn-toolbar';\n",
+       "    this.root.appendChild(toolbar);\n",
+       "\n",
+       "    function on_click_closure(name) {\n",
+       "        return function (_event) {\n",
+       "            return fig.toolbar_button_onclick(name);\n",
+       "        };\n",
+       "    }\n",
+       "\n",
+       "    function on_mouseover_closure(tooltip) {\n",
+       "        return function (event) {\n",
+       "            if (!event.currentTarget.disabled) {\n",
+       "                return fig.toolbar_button_onmouseover(tooltip);\n",
+       "            }\n",
+       "        };\n",
+       "    }\n",
+       "\n",
+       "    fig.buttons = {};\n",
+       "    var buttonGroup = document.createElement('div');\n",
+       "    buttonGroup.classList = 'btn-group';\n",
+       "    var button;\n",
+       "    for (var toolbar_ind in mpl.toolbar_items) {\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) {\n",
+       "            /* Instead of a spacer, we start a new button group. */\n",
+       "            if (buttonGroup.hasChildNodes()) {\n",
+       "                toolbar.appendChild(buttonGroup);\n",
+       "            }\n",
+       "            buttonGroup = document.createElement('div');\n",
+       "            buttonGroup.classList = 'btn-group';\n",
+       "            continue;\n",
+       "        }\n",
+       "\n",
+       "        button = fig.buttons[name] = document.createElement('button');\n",
+       "        button.classList = 'btn btn-default';\n",
+       "        button.href = '#';\n",
+       "        button.title = name;\n",
+       "        button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n",
+       "        button.addEventListener('click', on_click_closure(method_name));\n",
+       "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
+       "        buttonGroup.appendChild(button);\n",
+       "    }\n",
+       "\n",
+       "    if (buttonGroup.hasChildNodes()) {\n",
+       "        toolbar.appendChild(buttonGroup);\n",
+       "    }\n",
+       "\n",
+       "    // Add the status bar.\n",
+       "    var status_bar = document.createElement('span');\n",
+       "    status_bar.classList = 'mpl-message pull-right';\n",
+       "    toolbar.appendChild(status_bar);\n",
+       "    this.message = status_bar;\n",
+       "\n",
+       "    // Add the close button to the window.\n",
+       "    var buttongrp = document.createElement('div');\n",
+       "    buttongrp.classList = 'btn-group inline pull-right';\n",
+       "    button = document.createElement('button');\n",
+       "    button.classList = 'btn btn-mini btn-primary';\n",
+       "    button.href = '#';\n",
+       "    button.title = 'Stop Interaction';\n",
+       "    button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n",
+       "    button.addEventListener('click', function (_evt) {\n",
+       "        fig.handle_close(fig, {});\n",
+       "    });\n",
+       "    button.addEventListener(\n",
+       "        'mouseover',\n",
+       "        on_mouseover_closure('Stop Interaction')\n",
+       "    );\n",
+       "    buttongrp.appendChild(button);\n",
+       "    var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n",
+       "    titlebar.insertBefore(buttongrp, titlebar.firstChild);\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype._remove_fig_handler = function (event) {\n",
+       "    var fig = event.data.fig;\n",
+       "    if (event.target !== this) {\n",
+       "        // Ignore bubbled events from children.\n",
+       "        return;\n",
+       "    }\n",
+       "    fig.close_ws(fig, {});\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function (el) {\n",
+       "    el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function (el) {\n",
+       "    // this is important to make the div 'focusable\n",
+       "    el.setAttribute('tabindex', 0);\n",
+       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
+       "    // off when our div gets focus\n",
+       "\n",
+       "    // location in version 3\n",
+       "    if (IPython.notebook.keyboard_manager) {\n",
+       "        IPython.notebook.keyboard_manager.register_events(el);\n",
+       "    } else {\n",
+       "        // location in version 2\n",
+       "        IPython.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function (event, _name) {\n",
+       "    // Check for shift+enter\n",
+       "    if (event.shiftKey && event.which === 13) {\n",
+       "        this.canvas_div.blur();\n",
+       "        // select the cell after this one\n",
+       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
+       "        IPython.notebook.select(index + 1);\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
+       "    fig.ondownload(fig, null);\n",
+       "};\n",
+       "\n",
+       "mpl.find_output_cell = function (html_output) {\n",
+       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
+       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
+       "    // IPython event is triggered only after the cells have been serialised, which for\n",
+       "    // our purposes (turning an active figure into a static one), is too late.\n",
+       "    var cells = IPython.notebook.get_cells();\n",
+       "    var ncells = cells.length;\n",
+       "    for (var i = 0; i < ncells; i++) {\n",
+       "        var cell = cells[i];\n",
+       "        if (cell.cell_type === 'code') {\n",
+       "            for (var j = 0; j < cell.output_area.outputs.length; j++) {\n",
+       "                var data = cell.output_area.outputs[j];\n",
+       "                if (data.data) {\n",
+       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
+       "                    data = data.data;\n",
+       "                }\n",
+       "                if (data['text/html'] === html_output) {\n",
+       "                    return [cell, data, j];\n",
+       "                }\n",
+       "            }\n",
+       "        }\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "// Register the function which deals with the matplotlib target/channel.\n",
+       "// The kernel may be null if the page has been refreshed.\n",
+       "if (IPython.notebook.kernel !== null) {\n",
+       "    IPython.notebook.kernel.comm_manager.register_target(\n",
+       "        'matplotlib',\n",
+       "        mpl.mpl_figure_comm\n",
+       "    );\n",
+       "}\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<img src=\"data:image/png;base64,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\" width=\"999.4166666666666\">"
+      ],
       "text/plain": [
-       "<Figure size 1440x720 with 3 Axes>"
+       "<IPython.core.display.HTML object>"
       ]
      },
      "metadata": {},
@@ -112,29 +1101,35 @@
     }
    ],
    "source": [
-    "from IPython import display\n",
-    "from loguru import logger\n",
-    "import time \n",
-    "\n",
-    "logger.remove() \n",
-    "logger.add(sys.stderr, level=\"INFO\")# using DEBUG level will create tons of text\n",
-    "\n",
-    "anim = SpaceAnimation(sim)\n",
-    "\n",
-    "dt = 100  # time step in seconds\n",
-    "for x in range(100):\n",
-    "    anim.animate(sim, dt)\n",
-    "    display.display(anim.fig) \n",
-    "    time.sleep(0.01)\n",
-    "    display.clear_output(wait=True)\n"
+    "# Plot current status of PASEOS and get a plotter\n",
+    "plotter = paseos.plot(sim, paseos.PlotType.SpacePlot)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "# Run some operations and inbetween update PASEOS\n",
+    "for i in range(100):\n",
+    "    sim.advance_time(10)\n",
+    "    plotter.update(sim)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "scrolled": true
+   },
    "outputs": [],
-   "source": []
+   "source": [
+    "# Write an animation of the next 50 steps a 100s to a file called test.mp4\n",
+    "plotter.animate(sim,dt=100,steps=50,save_to_file=\"test\")"
+   ]
   }
  ],
  "metadata": {
@@ -153,11 +1148,11 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.13"
+   "version": "3.10.6"
   },
   "vscode": {
    "interpreter": {
-    "hash": "c8b3884ef4975b24ae31ba806df12dea7ed374822ed6db6e89bbfd74664ee269"
+    "hash": "cec805858b69cacb2b7ad611a1d16c309b9d5c2fd3283013a8f0cd0423ba3fc5"
    }
   }
  },
diff --git a/paseos/__init__.py b/paseos/__init__.py
index ccfbed87..fb478185 100644
--- a/paseos/__init__.py
+++ b/paseos/__init__.py
@@ -4,7 +4,7 @@
 
 from .utils.set_log_level import set_log_level
 from .paseos import PASEOS
-from .visualization.space_animation import SpaceAnimation
+from .visualization.plot import plot, PlotType
 from .actors.actor_builder import ActorBuilder
 from .actors.spacecraft_actor import SpacecraftActor
 from .actors.ground_station_actor import GroundstationActor
@@ -29,4 +29,10 @@ def init_sim(local_actor: BaseActor):
     return sim
 
 
-__all__ = ["ActorBuilder", "GroundstationActor", "SpacecraftActor", "SpaceAnimation"]
+__all__ = [
+    "ActorBuilder",
+    "GroundstationActor",
+    "plot",
+    "PlotType",
+    "SpacecraftActor",
+]
diff --git a/paseos/visualization/animation.py b/paseos/visualization/animation.py
index fae544d1..1be4e97d 100644
--- a/paseos/visualization/animation.py
+++ b/paseos/visualization/animation.py
@@ -35,7 +35,7 @@ def _plot_actors(self) -> None:
         pass
 
     @abstractmethod
-    def _update(self, sim: PASEOS) -> None:
+    def update(self, sim: PASEOS) -> None:
         """Function to update all the objects in the animation
 
         Args:
diff --git a/paseos/visualization/plot.py b/paseos/visualization/plot.py
new file mode 100644
index 00000000..e9a6faf8
--- /dev/null
+++ b/paseos/visualization/plot.py
@@ -0,0 +1,21 @@
+from enum import Enum
+
+from ..paseos import PASEOS
+from .space_animation import SpaceAnimation
+
+
+class PlotType(Enum):
+    """Describes the different plot types
+    1 - SpacePlot
+    """
+
+    SpacePlot = 1
+
+
+def plot(sim: PASEOS, plot_type: PlotType):
+    if plot_type is PlotType.SpacePlot:
+        return SpaceAnimation(sim)
+    else:
+        raise ValueError(
+            f"PlotType {plot_type} not known. Available are {[e for e in PlotType]}"
+        )
diff --git a/paseos/visualization/space_animation.py b/paseos/visualization/space_animation.py
index 2ec95e09..058b79e6 100644
--- a/paseos/visualization/space_animation.py
+++ b/paseos/visualization/space_animation.py
@@ -1,4 +1,3 @@
-import pykep as pk
 import numpy as np
 from dotmap import DotMap
 from typing import List
@@ -6,7 +5,6 @@
 import matplotlib.animation as animation
 from matplotlib.artist import Artist
 from matplotlib.colors import LinearSegmentedColormap
-from matplotlib import gridspec
 from mpl_toolkits.axes_grid1 import make_axes_locatable
 from loguru import logger
 
@@ -20,7 +18,7 @@
 class SpaceAnimation(Animation):
     """This class visualizes the central body, local actor and known actors over time."""
 
-    def __init__(self, sim: PASEOS, n_trajectory: int = 10) -> None:
+    def __init__(self, sim: PASEOS, n_trajectory: int = 32) -> None:
         """Initialize the space animation object
 
         Args:
@@ -28,55 +26,82 @@ def __init__(self, sim: PASEOS, n_trajectory: int = 10) -> None:
             n_trajectory (int): number of samples in tail of actor
         """
         super().__init__(sim)
-        logger.trace("Initializing animation")
+        logger.debug("Initializing animation")
         # Create list of objects to be plotted
         current_actors = self._make_actor_list(sim)
         self._norm_coeff = self._local_actor._central_body.radius
 
-        local_time_d = self._local_actor.local_time.mjd2000
         for known_actor in current_actors:
-            pos, _ = known_actor.get_position_velocity(pk.epoch(local_time_d))
+            pos, _ = known_actor.get_position_velocity(self._local_actor.local_time)
             pos_norm = [x / self._norm_coeff for x in pos]
             self.objects.append(DotMap(actor=known_actor, positions=np.array(pos_norm)))
 
-        # create figures
-        # create grid for different subplots
-        spec = gridspec.GridSpec(
-            ncols=2,
-            nrows=1,
-            width_ratios=[2.5, 1],
-            wspace=0.5,
-            hspace=0.5,
-            height_ratios=[1],
-        )
-
-        # Create figure for 3d animation
-        self.fig = plt.figure(figsize=plt.figaspect(0.5) * 2)
-        self.ax_3d = plt.subplot(spec[0], projection="3d")
-        self.ax_3d.set_title(self._sec_to_ddhhmmss(local_time_d / pk.SEC2DAY))
-        self.ax_3d.get_xaxis().set_ticks([])
-        self.ax_3d.get_yaxis().set_ticks([])
-        self.ax_3d.get_zaxis().set_ticks([])
-        self.n_trajectory = n_trajectory  # how many samples from histories to visualize
-        self._textbox_offset = 0.1  # how many samples from histories to visualize
-
-        # Create figure for LOS
-        self.ax_los = plt.subplot(spec[1])
-        xaxis = np.arange(len(current_actors))
-        self.ax_los.set_xticks(xaxis)
-        self.ax_los.set_yticks(xaxis)
-        self.ax_los.set_xticklabels(current_actors)
-        self.ax_los.set_yticklabels(current_actors)
-        self.ax_los.figure.set_size_inches(10, 10)
+        with plt.style.context("dark_background"):
+
+            # Create figure for 3d animation
+            self.fig, default_ax = plt.subplots(
+                1,
+                2,
+                figsize=(10, 5),
+                facecolor="black",
+                dpi=100,
+                layout="constrained",
+                gridspec_kw={"width_ratios": [3.5, 1]},
+            )
 
-        # plot the objects
-        self._plot_central_body()
-        self._plot_actors()
-        los_matrix = self._get_los_matrix(current_actors)
-        self._plot_los(los_matrix)
+            # Removing defaultax to add projection
+            default_ax[0].remove()
+            self.ax_3d = plt.subplot(121, projection="3d")
+
+            # Get rid of the panes
+            self.ax_3d.xaxis.set_pane_color((1.0, 1.0, 1.0, 0.0))
+            self.ax_3d.yaxis.set_pane_color((1.0, 1.0, 1.0, 0.0))
+            self.ax_3d.zaxis.set_pane_color((1.0, 1.0, 1.0, 0.0))
+
+            # Get rid of the spines
+            self.ax_3d.xaxis.line.set_color((1.0, 1.0, 1.0, 0.0))
+            self.ax_3d.yaxis.line.set_color((1.0, 1.0, 1.0, 0.0))
+            self.ax_3d.zaxis.line.set_color((1.0, 1.0, 1.0, 0.0))
+            self.ax_3d.get_xaxis().set_ticks([])
+            self.ax_3d.get_yaxis().set_ticks([])
+            self.ax_3d.get_zaxis().set_ticks([])
+
+            # how many samples from histories to visualize
+            self.n_trajectory = n_trajectory
+            self._textbox_offset = 0.1
+
+            # Create figure for LOS
+            default_ax[1].remove()
+            self.ax_los = plt.subplot(122)
+            xaxis = np.arange(len(current_actors))
+            self.ax_los.set_position([0.75, 0.7, 0.2, 0.2])
+            self.ax_los.set_xticks(xaxis)
+            self.ax_los.set_yticks(xaxis)
+            self.ax_los.set_xticklabels(current_actors, fontsize=8)
+            self.ax_los.set_yticklabels(current_actors, fontsize=8)
+
+            # plot the objects
+            self._plot_central_body()
+            self._plot_actors()
+            los_matrix = self._get_los_matrix(current_actors)
+            self._plot_los(los_matrix)
+
+            # Write text labels
+            self.date_label = plt.annotate(
+                self._local_actor.local_time,
+                xy=(0.01, 0.01),
+                xycoords="figure fraction",
+            )
+            self.time_label = plt.annotate(
+                f"t={sim._state.time:<10.2e}",
+                xy=(0.99, 0.01),
+                xycoords="figure fraction",
+                horizontalalignment="right",
+            )
 
-        plt.ion()
-        plt.show()
+            plt.ion()
+            plt.show()
+            plt.pause(0.0001)
 
     def _plot_central_body(self) -> None:
         """Plot the central object as a sphere of radius 1"""
@@ -87,7 +112,7 @@ def _plot_central_body(self) -> None:
         x = np.cos(u) * np.sin(v)
         y = np.sin(u) * np.sin(v)
         z = np.cos(v)
-        self.ax_3d.plot_surface(x, y, z, color="grey", alpha=0.4)
+        self.ax_3d.plot_surface(x, y, z, color="blue", alpha=0.5)
 
     def _get_los_matrix(self, current_actors: List[BaseActor]) -> np.ndarray:
         """Compute line-of-sight (LOS) between all actors
@@ -121,8 +146,6 @@ def _populate_textbox(self, actor: BaseActor) -> str:
         """
         info_str = f"{actor.name}"
         if isinstance(actor, SpacecraftActor):
-            # TODO: enable both text and icons in textbox
-
             if actor.battery_level_in_Ws is not None:
                 battery_level = actor.battery_level_ratio * 100
                 info_str += f"\nBattery: {battery_level:.0f}%"
@@ -130,10 +153,15 @@ def _populate_textbox(self, actor: BaseActor) -> str:
             for name in actor.communication_devices.keys():
                 info = actor.communication_devices[name]
                 info_str += f"\nCommDevice1: {info.bandwidth_in_kbps} kbps"
-
         elif isinstance(actor, GroundstationActor):
             # TODO: implement textbox for groundstation
-            pass
+            raise NotImplementedError(
+                "SpacePlot is currently not implemented for actor type" + type(actor)
+            )
+        else:
+            raise NotImplementedError(
+                "SpacePlot is currently not implemented for actor type" + type(actor)
+            )
 
         return info_str
 
@@ -143,8 +171,8 @@ def _plot_los(self, los_matrix: np.ndarray) -> None:
         Args:
             los_matrix (np.ndarray): matrix telling what satellites can see each other.
         """
-        # Create new colormap, with white for two
-        colors = [(255, 0, 0), (255, 255, 255), (0, 255, 0)]
+        # Create new colormap, with black for two
+        colors = [(255, 0, 0), (0, 0, 0), (0, 255, 0)]
         new_map = LinearSegmentedColormap.from_list("new_map", colors, N=3)
         self._los_plot = self.ax_los.matshow(los_matrix, cmap=new_map, vmin=0, vmax=1)
 
@@ -156,15 +184,20 @@ def _plot_los(self, los_matrix: np.ndarray) -> None:
 
     def _plot_actors(self) -> None:
         """Plots all the actors"""
+        logger.trace("Updating actors.")
+
         for obj in self.objects:
             data = obj.positions
             if data.ndim == 1:
                 data = data[..., np.newaxis].T
             n_points = np.minimum(data.shape[0], self.n_trajectory)
 
+            logger.trace(f"Position for object: {data}")
             if "plot" in obj.keys():
                 # spacecraft and ground stations behave differently and are plotted separately
                 if isinstance(obj.actor, SpacecraftActor):
+                    logger.trace("Updating SpacecraftActor.")
+
                     # update trajectory
                     obj.plot.trajectory.set_data(data[-n_points:, :2].T)
                     obj.plot.trajectory.set_3d_properties(data[-n_points:, 2].T)
@@ -190,7 +223,7 @@ def _plot_actors(self) -> None:
                         data[0, 0],
                         data[0, 1],
                         data[0, 2],
-                        "*",
+                        "x",
                         color=trajectory.get_color(),
                     )[0]
                     actor_info = self._populate_textbox(obj.actor)
@@ -200,9 +233,10 @@ def _plot_actors(self) -> None:
                             data[0, 1] + self._textbox_offset,
                             data[0, 2] + self._textbox_offset,
                             actor_info,
-                            bbox=dict(facecolor="mediumspringgreen"),
+                            # bbox=dict(facecolor="mediumspringgreen"),
                             verticalalignment="bottom",
                             clip_on=True,
+                            fontsize=8,
                         )
 
                     else:
@@ -211,14 +245,19 @@ def _plot_actors(self) -> None:
                             data[0, 1] + self._textbox_offset,
                             data[0, 2] + self._textbox_offset,
                             actor_info,
-                            bbox=dict(facecolor="white"),
+                            # bbox=dict(facecolor="white"),
+                            color="lightskyblue",
                             verticalalignment="bottom",
                             clip_on=True,
+                            fontsize=8,
                         )
 
                 elif isinstance(obj.actor, GroundstationActor):
                     # TODO: implement initial rendering of groundstation object
-                    pass
+                    raise NotImplementedError(
+                        "SpacePlot is currently not implemented for actor type"
+                        + type(obj.actor)
+                    )
 
         self.ax_3d.set_box_aspect(
             (
@@ -243,24 +282,23 @@ def _make_actor_list(self, sim: PASEOS) -> List[BaseActor]:
             current_actors = [sim.local_actor]
         return current_actors
 
-    def _update(self, sim: PASEOS) -> None:
+    def update(self, sim: PASEOS, creating_animation=False) -> None:
         """Updates the animation with the current actor information
 
         Args:
             sim (PASEOS): simulation object.
+            creating_animation (bool): If currently creating an animation. Then draw_idle will be used. Defaults to False.
         """
         logger.trace("Updating animation")
-        local_time_d = self._local_actor.local_time.mjd2000
         # NOTE: the actors in sim are unique so make use of sets
         objects_in_plot = set([obj.actor for obj in self.objects])
         current_actors = set(self._make_actor_list(sim))
 
-        objects_to_remove = list(
-            objects_in_plot.difference(current_actors)
-        )  # if objects do not exist in known actors, remove from plot next update.
-        objects_to_add = list(
-            current_actors.difference(objects_in_plot)
-        )  # if known_actor does not exist in objects, add the actors and update in plot
+        # if objects do not exist in known actors, remove from plot next update.
+        objects_to_remove = list(objects_in_plot.difference(current_actors))
+
+        # if known_actor does not exist in objects, add the actors and update in plot
+        objects_to_add = list(current_actors.difference(objects_in_plot))
 
         plot_objects_to_remove = [
             x for x in self.objects if x.actor in objects_to_remove
@@ -279,7 +317,9 @@ def _update(self, sim: PASEOS) -> None:
         for known_actor in current_actors:
             for obj in self.objects:
                 if obj.actor == known_actor:
-                    pos, _ = known_actor.get_position_velocity(pk.epoch(local_time_d))
+                    pos, _ = known_actor.get_position_velocity(
+                        self._local_actor.local_time
+                    )
                     pos_norm = [x / self._norm_coeff for x in pos]
                     if "positions" in obj:
                         if obj.positions.shape[0] > self.n_trajectory:
@@ -316,16 +356,24 @@ def _update(self, sim: PASEOS) -> None:
         xaxis = np.arange(len(current_actors))
         self.ax_los.set_xticks(xaxis)
         self.ax_los.set_yticks(xaxis)
-        self.ax_los.set_xticklabels(current_actors)
-        self.ax_los.set_yticklabels(current_actors)
-        self.fig.canvas.draw_idle()
+        self.ax_los.set_xticklabels(current_actors, fontsize=8)
+        self.ax_los.set_yticklabels(current_actors, fontsize=8)
+
+        if creating_animation:
+            self.fig.canvas.draw_idle()
+        else:
+            self.fig.canvas.draw()
+        plt.pause(0.0001)
 
-        # TODO: understand why we sometimes get
-        # "RuntimeError: bad lexical cast: source type value could not be interpreted as target"
+        # on some systems the below line throws an error. presumably due to pykep?
         try:
-            self.ax_3d.set_title(self._local_actor.local_time)
-        except:
-            logger.trace("Animation title could not be updated")
+            self.date_label.set_text(self._local_actor.local_time)
+        except RuntimeError:
+            logger.trace("Animation date label could not be updated.")
+
+        self.time_label.set_text(f"t={sim._state.time:<10.2e}")
+
+        logger.debug("Plot updated.")
 
     def _animate(self, sim: PASEOS, dt: float) -> List[Artist]:
         """Advances the time of sim, updates the plot, and returns the axis objects
@@ -338,7 +386,7 @@ def _animate(self, sim: PASEOS, dt: float) -> List[Artist]:
             List[Artist]: list of Artist objects
         """
         sim.advance_time(dt)
-        self._update(sim)
+        self.update(sim, creating_animation=True)
         return self.ax_3d.get_children() + self.ax_los.get_children()
 
     def _animation_wrapper(self, step: int, sim: PASEOS, dt: float) -> List[Artist]:
@@ -354,16 +402,18 @@ def _animation_wrapper(self, step: int, sim: PASEOS, dt: float) -> List[Artist]:
         """
         return self._animate(sim, dt)
 
-    def animate(self, sim: PASEOS, dt: float, steps: int = 1, name: str = None) -> None:
+    def animate(
+        self, sim: PASEOS, dt: float, steps: int = 1, save_to_file: str = None
+    ) -> None:
         """Animates paseos for a given number of steps with dt in each step.
 
         Args:
             sim (PASEOS): simulation object.
             dt (float): size of time step
             steps (int, optional): number of steps to animate. Defaults to 1.
-            name (str, optional): filename to save the animation. Defaults to None.
+            save_to_file (str, optional): filename to save the animation. Defaults to None.
         """
-        if name is None:
+        if save_to_file is None:
             self._animate(sim, dt)
         else:
             anim = animation.FuncAnimation(
@@ -377,4 +427,4 @@ def animate(self, sim: PASEOS, dt: float, steps: int = 1, name: str = None) -> N
                 interval=20,
                 blit=True,
             )  # blit means to only redraw parts that changed
-            anim.save(f"{name}.mp4", writer="ffmpeg", fps=10)
+            anim.save(f"{save_to_file}.mp4", writer="ffmpeg", fps=30)


Test patch:
diff --git a/.github/workflows/run_tests.yml b/.github/workflows/run_tests.yml
index dac37152..5873bdb8 100644
--- a/.github/workflows/run_tests.yml
+++ b/.github/workflows/run_tests.yml
@@ -24,7 +24,7 @@ jobs:
     - name: Lint with flake8
       run: |
         pip install flake8
-        flake8 . --count --show-source --statistics --max-line-length=127 --ignore=E402,W503
+        flake8 . --count --show-source --statistics --max-line-length=127 --ignore=E402,W503,E203
 
   build: