Tutorial for the 2D acoustic wave with pressure velocity equations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tutorial for 2D acoustic with pressure-velocity equations with CG"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This tutorial focuses on the implementation on the 2D acoustic wave using pressure-velocity formulation:\n",
    "$$p\\frac{\\partial v}{\\partial t} + \\nabla p = f$$\n",
    "$$\\frac{1}{\\rho c^2} \\frac{\\partial p}{\\partial t} + \\nabla \\cdot v = g $$\n",
    "In order to simplify the problem we assume $\\rho = 1$ and $c = 1$ as constants.\n",
    "\n",
    "To arrive at a weak formulation we can seperate $u$ into $u_x$ and $u_y$ (arriving at three equations and multiply each by test functions $q_1$, $q_2$ and $q_3$.\n",
    "$$\\int_{\\Omega} \\frac{1}{c^2} \\frac{\\partial p}{\\partial t}q_1d\\vec{x} \n",
    " -\\int_{\\Omega} (u_x \\frac{\\partial q_1}{\\partial x} + u_y \\frac{\\partial q_1}{\\partial y})d\\vec{x} = \n",
    " \\int_{\\Omega}gq_1d\\vec{x}$$\n",
    " \n",
    "$$\\int_{\\Omega} \\frac{\\partial u_x}{\\partial t}q_2d\\vec{x} \n",
    "  - \\int_{\\Omega} p\\frac{\\partial q_2}{\\partial x}d\\vec{x} = 0 $$\n",
    "  \n",
    "$$\\int_{\\Omega} \\frac{\\partial u_y}{\\partial t}q_3d\\vec{x} \n",
    "  - \\int_{\\Omega} p\\frac{\\partial q_3}{\\partial y}d\\vec{x} = 0 $$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solving the forward problem in Firedrake\n",
    "Use the folowing to plot inside the jupyter notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calling all libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from firedrake import *\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's specify our output file for visualization in Paraview"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Output file\n",
    "output_file='output/VectorCG_convergence/Forward.pvd'\n",
    "outfile = File(output_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's first define our h and p variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "order=3\n",
    "mesh_size =10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating mesh\n",
    "Now we can build our simple unit square mesh with triangular elements (if we want quads we just have to add quadrilateral = True to the UnitSquareMesh function)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "mesh = UnitSquareMesh(mesh_size, mesh_size)\n",
    "x,y = SpatialCoordinate(mesh)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can visualize our mesh with the plot command"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\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('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",
       "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 = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(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 (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\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 = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\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 nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\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",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\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",
       "\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",
       "\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]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.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, 0, fig.canvas.width, fig.canvas.height);\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",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = 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.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",
       "            /* 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",
       "            evt.data.type = \"image/png\";\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",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\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(\"No handler for the '\" + msg_type + \"' message type: \", msg);\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(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://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",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\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",
       " * http://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",
       "    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",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\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",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             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",
       "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\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\n",
       "\n",
       "mpl.default_extension = \"png\";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.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",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['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 = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\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.get(0);\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",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\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).html('<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/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<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 () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\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) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('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",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\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('matplotlib', mpl.mpl_figure_comm);\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=\"639.8333333333334\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot(mesh);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since we are dealing with 3 spaces (for ux, uy, p) a simple FunctionSpace function isn't enough therefore we do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "CGOrder = FiniteElement('CG', triangle, order)\n",
    "element = MixedElement([CGOrder, CGOrder, CGOrder])\n",
    "V = FunctionSpace(mesh, element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Specifying source function and boundary conditions\n",
    "In order to have an analytical function for comparison we can use the so called 'method of manufactured solution'. First we impose a solution and boundary conditions to our system of equations. Then we use that 'solution' to calculate our source term. \n",
    "\n",
    "Our solution is \n",
    "$$ p = t^2 sin( \\pi x) sin (\\pi y) $$\n",
    "\n",
    "Which, after substituting on our original equations with Dirichlet Boundary conditions gives us:\n",
    "$$ g = sin( \\pi x) sin(\\pi y) (2t + \\frac{2 \\pi ^2 t^3}{3} )$$\n",
    "\n",
    "Since $g$ is time-dependent I will seperate it into a function of space times one of time and interpolate $gX = sin( \\pi x) sin(\\pi y)$ to our function space."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "sourceX = Function(V.sub(2)).interpolate(sin(pi*x)*sin(pi*y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dirichlet contidions are easy to implement in Firedrake:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "bcp = DirichletBC(V.sub(2),0.,\"on_boundary\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most dificulties can be solved by looking at the help file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class DirichletBC in module firedrake.bcs:\n",
      "\n",
      "class DirichletBC(builtins.object)\n",
      " |  Implementation of a strong Dirichlet boundary condition.\n",
      " |  \n",
      " |  :arg V: the :class:`.FunctionSpace` on which the boundary condition\n",
      " |      should be applied.\n",
      " |  :arg g: the boundary condition values. This can be a :class:`.Function` on\n",
      " |      ``V``, a :class:`.Constant`, an :class:`.Expression`, an\n",
      " |      iterable of literal constants (converted to an\n",
      " |      :class:`.Expression`), or a literal constant which can be\n",
      " |      pointwise evaluated at the nodes of\n",
      " |      ``V``. :class:`.Expression`\\s are projected onto ``V`` if it\n",
      " |      does not support pointwise evaluation.\n",
      " |  :arg sub_domain: the integer id(s) of the boundary region over which the\n",
      " |      boundary condition should be applied. The string \"on_boundary\" may be used\n",
      " |      to indicate all of the boundaries of the domain. In the case of extrusion\n",
      " |      the ``top`` and ``bottom`` strings are used to flag the bcs application on\n",
      " |      the top and bottom boundaries of the extruded mesh respectively.\n",
      " |  :arg method: the method for determining boundary nodes. The default is\n",
      " |      \"topological\", indicating that nodes topologically associated with a\n",
      " |      boundary facet will be included. The alternative value is \"geometric\",\n",
      " |      which indicates that nodes associated with basis functions which do not\n",
      " |      vanish on the boundary will be included. This can be used to impose\n",
      " |      strong boundary conditions on DG spaces, or no-slip conditions on HDiv spaces.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __init__(self, V, g, sub_domain, method='topological')\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  apply(self, r, u=None)\n",
      " |      Apply this boundary condition to ``r``.\n",
      " |      \n",
      " |      :arg r: a :class:`.Function` or :class:`.Matrix` to which the\n",
      " |          boundary condition should be applied.\n",
      " |      \n",
      " |      :arg u: an optional current state.  If ``u`` is supplied then\n",
      " |          ``r`` is taken to be a residual and the boundary condition\n",
      " |          nodes are set to the value ``u-bc``.  Supplying ``u`` has\n",
      " |          no effect if ``r`` is a :class:`.Matrix` rather than a\n",
      " |          :class:`.Function`. If ``u`` is absent, then the boundary\n",
      " |          condition nodes of ``r`` are set to the boundary condition\n",
      " |          values.\n",
      " |      \n",
      " |      \n",
      " |      If ``r`` is a :class:`.Matrix`, it will be assembled with a 1\n",
      " |      on diagonals where the boundary condition applies and 0 in the\n",
      " |      corresponding rows and columns.\n",
      " |  \n",
      " |  domain_args(...)\n",
      " |      The sub_domain the BC applies to.\n",
      " |  \n",
      " |  function_space(self)\n",
      " |      The :class:`.FunctionSpace` on which this boundary condition should\n",
      " |      be applied.\n",
      " |  \n",
      " |  homogenize(self)\n",
      " |      Convert this boundary condition into a homogeneous one.\n",
      " |      \n",
      " |      Set the value to zero.\n",
      " |  \n",
      " |  node_set(...)\n",
      " |      The subset corresponding to the nodes at which this\n",
      " |      boundary condition applies.\n",
      " |  \n",
      " |  nodes(...)\n",
      " |      The list of nodes at which this boundary condition applies.\n",
      " |  \n",
      " |  reconstruct(self, *, V=None, g=None, sub_domain=None, method=None)\n",
      " |  \n",
      " |  restore(self)\n",
      " |      Restore the original value of this boundary condition.\n",
      " |      \n",
      " |      This uses the value passed on instantiation of the object.\n",
      " |  \n",
      " |  set(self, r, val)\n",
      " |      Set the boundary nodes to a prescribed (external) value.\n",
      " |      :arg r: the :class:`Function` to which the value should be applied.\n",
      " |      :arg val: the prescribed value.\n",
      " |  \n",
      " |  set_value(self, val)\n",
      " |      Set the value of this boundary condition.\n",
      " |      \n",
      " |      :arg val: The boundary condition values.  See\n",
      " |          :class:`.DirichletBC` for valid values.\n",
      " |  \n",
      " |  zero(self, r)\n",
      " |      Zero the boundary condition nodes on ``r``.\n",
      " |      \n",
      " |      :arg r: a :class:`.Function` to which the\n",
      " |          boundary condition should be applied.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  function_arg\n",
      " |      The value of this boundary condition.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(DirichletBC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Defining our variables for integration in time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "q = 0.001 #Courant number\n",
    "T = 0.1 #Final time\n",
    "dt_stable = q/(mesh_size)\n",
    "ite = 1+int(T/dt_stable)\n",
    "dt = T/float(ite)\n",
    "h = dt\n",
    "dtc = Constant(dt)\n",
    "\n",
    "t = 0.0\n",
    "t_sim = t\n",
    "step = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAACkAAAAcCAYAAAD815boAAAABHNCSVQICAgIfAhkiAAAAs5JREFUWIXt1VuIVWUUB/Bfd7UGSzFFfPBhVPDGiFgJgoZoFx8KvEXgo4b4YD3ps+ClfKjwQRwRfYggiSy6gGggvhQ+OKIgiIZlIoOajqY13jo9rG9ztnv2nqPOGUbQPxz23mt93/r+Z63/Wh+PIFbhKK6m3y9YMKCMSvAO3kIrxmM9bmHqQJK6F1zCBwNNogpP4T3cxJSKNXOxB524gXPYi7f7m9wUXMNtdKnW5Ceo4U+0YwO243Dy9SueFZqcjo24iMmFNcsTwV1pfRHPVAWfmzauK9hfTfYaxhZ8X+A/TOiF9H7syH0/h/P4o4JgDzyde7+cni2FNWty78Pwe3ofjSX4Hid6OePJRCzDPIzAZ+IPLhCZ7sYhMbbui+R4MVa+xbt4KedbJcqyOWfbhB+FzlrwPua4W5cz0rMbHXpK4SAW4UKRLLwoSvpVztYuxD8z+RYn+6AU5NdCjF2ijDdESffjjcKarSnWbTH4Z+EF0XB7k+9AGUF4AnfwU/oeKf7txxiTNmfzLhP+oqpgvWBb2tutp8aHiCrURGIQeslQwxX1cq9OxD9PdurlXo3f8M0DkOxKzw51fWf4R2QTXikjSeiyRaR/Jb4UA/ZvkeVhmI9J+FQIP49NosS9IWuyrgp/1huDG5FcgaHuboqrieSH+As7Sw5ow5EGJH8WVZtYcj71RjpdFWCfuGvP4IeC7zSOiewVZ2mGTixrQBK+S0Q/Ktjnp/iXRZJKsVt9cM8u+DqS/V+8XLJ3VPIvFc13Xej29ZK1Y0QiakIem/G16PhbWFhFkHrnHSrxHUi+9oq9byb/QTGwW0XGOirWj8AWMbJuiutzj1zD9AfWimYYlbMtw9m+Bi4T7oOiTVyRnTlbK071NXCzSRbv3Wkad3tDNIvkEIzTU39NIdksvCaG/fM523DRSG19Dd6sTLbhpBg7GaaJcXK8SWc8xmM8NPgfgxKszJqaRBcAAAAASUVORK5CYII=\n",
      "text/latex": [
       "${w_h^36}$"
      ],
      "text/plain": [
       "Coefficient(WithGeometry(IndexedProxyFunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fe2aaa05be0>, FiniteElement('Lagrange', triangle, 3), name=None, index=2, component=None), Mesh(VectorElement(FiniteElement('Lagrange', triangle, 1), dim=2), 1)), 36)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(qx, qy, q) = TestFunctions(V)\n",
    "initial = Function(V.sub(0)).interpolate(0.*x*y)\n",
    "\n",
    "UP = Function(V)\n",
    "ux, uy, p   = UP.split()\n",
    "ux.assign(initial)\n",
    "uy.interpolate(initial)\n",
    "p.interpolate(initial)\n",
    "\n",
    "UP_prev = Function(V)\n",
    "ux_prev, uy_prev, p_prev = UP_prev.split()\n",
    "ux_prev.interpolate(pi*dt*dt*dt/3. * cos(pi*x)*sin(pi*y) )\n",
    "uy_prev.interpolate(pi*dt*dt*dt/3. * sin(pi*x)*cos(pi*y) )\n",
    "p_prev.interpolate( dt*dt          * sin(pi*x)*sin(pi*y))\n",
    "\n",
    "UP_fut = Function(V)\n",
    "ux_fut, uy_fut, p_fut = UP_fut.split()\n",
    "ux_fut.assign(ux)\n",
    "uy_fut.assign(uy)\n",
    "p_fut.assign(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The partial derivatives were implemented as trial functions, making it easies to implement other time integration methods such as Runge-Kutta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "dUP = Function(V)\n",
    "dux, duy, dp = dUP.split()\n",
    "K1 = Function(V)\n",
    "K2 = Function(V)\n",
    "K3 = Function(V)\n",
    "K4 = Function(V)\n",
    "\n",
    "dux_trial, duy_trial, dp_trial = TrialFunctions(V)\n",
    "\n",
    "params = {'ksp_type': 'preonly', 'pc_type': 'bjacobi', 'sub_pc_type': 'ilu'}\n",
    "\n",
    "runtime=0."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Solving our problem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1,(ite)):\n",
    "    t   = dt*i\n",
    "              \n",
    "    t1  = t\n",
    "    Ct1 = Constant(t1)\n",
    "    LHS = (dp_trial)*q*dx + dux_trial*qx*dx + duy_trial*qy*dx\n",
    "    RHS = ((ux*q.dx(0) + uy*q.dx(1))*dx + sourceX*(2*Ct1+2*pi**2*Ct1**3/3.)*q*dx) + \\\n",
    "            p*qx.dx(0)*dx + \\\n",
    "            p*qy.dx(1)*dx\n",
    "\n",
    "    solve(LHS == RHS, dUP, bcp) #Solve for du and dp\n",
    "    K1.assign(dUP)\n",
    "    d1UX, d1UY, d1P = K1.split()\n",
    "\n",
    "    # Updating answer\n",
    "    ux_fut.assign(ux_prev + 2.*dt*d1UX)\n",
    "    uy_fut.assign(uy_prev + 2.*dt*d1UY)\n",
    "    p_fut.assign( p_prev  + 2.*dt*d1P)\n",
    "\n",
    "    ux_prev.assign(ux)\n",
    "    uy_prev.assign(uy)\n",
    "    p_prev.assign(p) \n",
    "\n",
    "    ux.assign(ux_fut)\n",
    "    uy.assign(uy_fut)\n",
    "    p.assign( p_fut)\n",
    "\n",
    "    ux_fut.assign(ux_prev + 2.*dt*d1UX)\n",
    "    uy_fut.assign(uy_prev + 2.*dt*d1UY)\n",
    "    p_fut.assign( p_prev  + 2.*dt*d1P)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can plot our solution using a simple plot command. Note that when using higher-order nodal functions we have to specify the number of sampling points per element in the plot function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\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('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",
       "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 = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(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 (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\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 = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\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 nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\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",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\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",
       "\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",
       "\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]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.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, 0, fig.canvas.width, fig.canvas.height);\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",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = 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.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",
       "            /* 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",
       "            evt.data.type = \"image/png\";\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",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\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(\"No handler for the '\" + msg_type + \"' message type: \", msg);\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(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://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",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\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",
       " * http://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",
       "    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",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\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",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             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",
       "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\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\n",
       "\n",
       "mpl.default_extension = \"png\";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.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",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['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 = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\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.get(0);\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",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\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).html('<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/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<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 () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\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) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('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",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\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('matplotlib', mpl.mpl_figure_comm);\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=\"639.8333333333334\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot(p);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t final time =  0.1\n",
      "\t L2 Error =  5.143085831203134e-08\n"
     ]
    }
   ],
   "source": [
    "t_sim = t + dt\n",
    "print(\"\\t final time = \",t_sim)\n",
    "p_init  = Function(V.sub(2)).interpolate((t_sim**2)*sin(pi*x)*sin(pi*y))            \n",
    "L2_err  = sqrt(assemble((p - p_init)*(p - p_init)*dx))\n",
    "L2 = L2_err\n",
    "print(\"\\t L2 Error = \",L2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also plot the analytical solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\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('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",
       "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 = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(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 (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\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 = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\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 nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\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",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\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",
       "\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",
       "\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]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.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, 0, fig.canvas.width, fig.canvas.height);\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",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = 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.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",
       "            /* 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",
       "            evt.data.type = \"image/png\";\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",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\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(\"No handler for the '\" + msg_type + \"' message type: \", msg);\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(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://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",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\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",
       " * http://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",
       "    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",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\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",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             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",
       "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\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\n",
       "\n",
       "mpl.default_extension = \"png\";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.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",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['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 = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\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.get(0);\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",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\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).html('<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/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<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 () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\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) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('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",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\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('matplotlib', mpl.mpl_figure_comm);\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=\"639.8333333333334\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fe2cf1550f0>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(p_init);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}