diff --git a/example/2019-12-11_Interactive_TZPGs_calculator.ipynb b/example/2019-12-11_Interactive_TZPGs_calculator.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..b3c6db34ce890870153716ada433f4d2ac89d264
--- /dev/null
+++ b/example/2019-12-11_Interactive_TZPGs_calculator.ipynb
@@ -0,0 +1,898 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Cloning into 'TZPGcalc'...\n",
+ "remote: Enumerating objects: 10, done.\u001b[K\n",
+ "remote: Counting objects: 100% (10/10), done.\u001b[K\n",
+ "remote: Compressing objects: 100% (8/8), done.\u001b[K\n",
+ "remote: Total 10 (delta 2), reused 0 (delta 0)\u001b[K\n",
+ "Unpacking objects: 100% (10/10), done.\n"
+ ]
+ }
+ ],
+ "source": [
+ "!git clone https://in.xfel.eu/gitlab/SCS/TZPGcalc.git/"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "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 / mpl.ratio, fig.canvas.height / mpl.ratio);\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\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\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=\"900\">"
+ ],
+ "text/plain": [
+ "<IPython.core.display.HTML object>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "2857a27b5bef44d7b3cee485285b5f57",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "VBox(children=(Accordion(children=(VBox(children=(HBox(children=(Label(value='Energy (eV):'), FloatRangeSlider…"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "<TZPGcalc.TZPGcalc.TZPGcalc at 0x7f66c4509940>"
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "import numpy as np\n",
+ "%matplotlib notebook\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "import matplotlib as mpl\n",
+ "mpl.rcParams['savefig.dpi'] = 300\n",
+ "mpl.rcParams['figure.dpi'] = 150\n",
+ "mpl.rcParams['figure.constrained_layout.use'] = True\n",
+ "\n",
+ "from TZPGcalc import TZPGcalc\n",
+ "\n",
+ "TZPGcalc()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "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.9"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}