{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<script src=\"https://code.jquery.com/ui/1.10.4/jquery-ui.min.js\" type=\"text/javascript\"></script>\n",
       "<script type=\"text/javascript\">function HoloViewsWidget(){\n",
       "}\n",
       "\n",
       "HoloViewsWidget.prototype.init_slider = function(init_val){\n",
       "\tif(this.load_json) {\n",
       "\t\tthis.from_json()\n",
       "\t} else {\n",
       "\t\tthis.update_cache();\n",
       "\t}\n",
       "}\n",
       "\n",
       "HoloViewsWidget.prototype.populate_cache = function(idx){\n",
       "    this.cache[idx].html(this.frames[idx]);\n",
       "    if (this.embed) {\n",
       "        delete this.frames[idx];\n",
       "    }\n",
       "}\n",
       "\n",
       "HoloViewsWidget.prototype.process_error = function(msg){\n",
       "\n",
       "}\n",
       "\n",
       "HoloViewsWidget.prototype.from_json = function() {\n",
       "\tvar data_url = this.json_path + this.id + '.json';\n",
       "\t$.getJSON(data_url, $.proxy(function(json_data) {\n",
       "\t\tthis.frames = json_data;\n",
       "\t\tthis.update_cache();\n",
       "\t\tthis.update(0);\n",
       "\t}, this));\n",
       "}\n",
       "\n",
       "HoloViewsWidget.prototype.dynamic_update = function(current){\n",
       "    function callback(msg){\n",
       "        /* This callback receives data from Python as a string\n",
       "         in order to parse it correctly quotes are sliced off*/\n",
       "        var data = msg.content.data['text/plain'].slice(1, -1);\n",
       "        this.frames[current] = data;\n",
       "        this.update_cache();\n",
       "        this.update(current);\n",
       "    }\n",
       "    if(!(current in this.cache)) {\n",
       "        var kernel = IPython.notebook.kernel;\n",
       "        callbacks = {iopub: {output: $.proxy(callback, this)}};\n",
       "        var cmd = \"holoviews.plotting.widgets.NdWidget.widgets['\" + this.id + \"'].update(\" + current + \")\";\n",
       "        kernel.execute(\"import holoviews;\" + cmd, callbacks, {silent : false});\n",
       "    } else {\n",
       "        this.update(current);\n",
       "    }\n",
       "}\n",
       "\n",
       "HoloViewsWidget.prototype.update_cache = function(){\n",
       "    var frame_len = Object.keys(this.frames).length;\n",
       "    for (var i=0; i<frame_len; i++) {\n",
       "        if(!this.load_json || this.dynamic)  {\n",
       "            frame = Object.keys(this.frames)[i];\n",
       "        } else {\n",
       "            frame = i;\n",
       "        }\n",
       "        if(!(frame in this.cache)) {\n",
       "            this.cache[frame] = $('<div />').appendTo(\"#\" + this.img_id).hide();\n",
       "            var cache_id = this.img_id+\"_\"+frame;\n",
       "            this.cache[frame].attr(\"id\", cache_id);\n",
       "            this.populate_cache(frame);\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "HoloViewsWidget.prototype.update = function(current){\n",
       "    if(current in this.cache) {\n",
       "        $.each(this.cache, function(index, value) {\n",
       "            value.hide();\n",
       "        });\n",
       "        this.cache[current].show();\n",
       "\t\tthis.wait = false;\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "function SelectionWidget(frames, id, slider_ids, keyMap, dim_vals, notFound, load_json, mode, cached, json_path, dynamic){\n",
       "    this.frames = frames;\n",
       "    this.fig_id = \"fig_\" + id;\n",
       "    this.img_id = \"_anim_img\" + id;\n",
       "    this.id = id;\n",
       "    this.slider_ids = slider_ids;\n",
       "    this.keyMap = keyMap\n",
       "    this.current_frame = 0;\n",
       "    this.current_vals = dim_vals;\n",
       "    this.load_json = load_json;\n",
       "    this.mode = mode;\n",
       "    this.notFound = notFound;\n",
       "    this.cached = cached;\n",
       "    this.dynamic = dynamic;\n",
       "    this.cache = {};\n",
       "\tthis.json_path = json_path;\n",
       "    this.init_slider(this.current_vals[0]);\n",
       "\tthis.queue = [];\n",
       "\tthis.wait = false;\n",
       "}\n",
       "\n",
       "SelectionWidget.prototype = new HoloViewsWidget;\n",
       "\n",
       "\n",
       "SelectionWidget.prototype.get_key = function(current_vals) {\n",
       "\tvar key = \"(\";\n",
       "    for (var i=0; i<this.slider_ids.length; i++)\n",
       "    {\n",
       "        val = this.current_vals[i];\n",
       "        if (!(typeof val === 'string')) {\n",
       "            if (val % 1 === 0) { var fixed = 1;}\n",
       "            else { var fixed = 10;}\n",
       "            val = val.toFixed(fixed)\n",
       "        }\n",
       "        key += \"'\" + val + \"'\";\n",
       "        if(i != this.slider_ids.length-1) { key += ', ';}\n",
       "        else if(this.slider_ids.length == 1) { key += ',';}\n",
       "    }\n",
       "    key += \")\";\n",
       "\treturn this.keyMap[key];\n",
       "}\n",
       "\n",
       "SelectionWidget.prototype.set_frame = function(dim_val, dim_idx){\n",
       "\tthis.current_vals[dim_idx] = dim_val;\n",
       "    var current = this.get_key(this.current_vals);\n",
       "    if(current === undefined && !this.dynamic) {\n",
       "        return\n",
       "    }\n",
       "\tif (this.dynamic || !this.cached) {\n",
       "\t\tif (this.time === undefined) {\n",
       "\t\t\t// Do nothing the first time\n",
       "\t\t} else if ((this.timed === undefined) || ((this.time + this.timed) > Date.now())) {\n",
       "\t\t\tvar key = this.current_vals;\n",
       "\t\t\tif (!this.dynamic) {\n",
       "\t\t\t\tkey = this.get_key(key);\n",
       "\t\t\t}\n",
       "\t\t\tthis.queue.push(key);\n",
       "\t\t\treturn\n",
       "\t\t}\n",
       "\t}\n",
       "\tthis.queue = [];\n",
       "\tthis.time = Date.now();\n",
       "    if(this.dynamic) {\n",
       "        this.dynamic_update(this.current_vals)\n",
       "        return;\n",
       "    }\n",
       "    this.current_frame = current;\n",
       "    if(this.cached) {\n",
       "        this.update(current)\n",
       "    } else {\n",
       "        this.dynamic_update(current)\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "/* Define the ScrubberWidget class */\n",
       "function ScrubberWidget(frames, num_frames, id, interval, load_json, mode, cached, json_path, dynamic){\n",
       "    this.img_id = \"_anim_img\" + id;\n",
       "    this.slider_id = \"_anim_slider\" + id;\n",
       "    this.loop_select_id = \"_anim_loop_select\" + id;\n",
       "    this.id = id;\n",
       "    this.fig_id = \"fig_\" + id;\n",
       "    this.interval = interval;\n",
       "    this.current_frame = 0;\n",
       "    this.direction = 0;\n",
       "    this.dynamic = dynamic;\n",
       "    this.timer = null;\n",
       "    this.load_json = load_json;\n",
       "    this.mode = mode;\n",
       "    this.cached = cached;\n",
       "    this.frames = frames;\n",
       "    this.cache = {};\n",
       "    this.length = num_frames;\n",
       "\tthis.json_path = json_path;\n",
       "    document.getElementById(this.slider_id).max = this.length - 1;\n",
       "    this.init_slider(0);\n",
       "\tthis.wait = false;\n",
       "\tthis.queue = [];\n",
       "}\n",
       "\n",
       "ScrubberWidget.prototype = new HoloViewsWidget;\n",
       "\n",
       "ScrubberWidget.prototype.set_frame = function(frame){\n",
       "\tthis.current_frame = frame;\n",
       "\twidget = document.getElementById(this.slider_id);\n",
       "    if (widget === null) {\n",
       "        this.pause_animation();\n",
       "        return\n",
       "    }\n",
       "    widget.value = this.current_frame;\n",
       "    if(this.cached) {\n",
       "        this.update(frame)\n",
       "    } else {\n",
       "        this.dynamic_update(frame)\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "ScrubberWidget.prototype.process_error = function(msg){\n",
       "\tif (msg.content.ename === 'StopIteration') {\n",
       "\t\tthis.pause_animation();\n",
       "\t\tthis.stopped = true;\n",
       "\t\tvar keys = Object.keys(this.frames)\n",
       "\t\tthis.length = keys.length;\n",
       "\t\tdocument.getElementById(this.slider_id).max = this.length-1;\n",
       "\t\tdocument.getElementById(this.slider_id).value = this.length-1;\n",
       "\t\tthis.current_frame = this.length-1;\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "ScrubberWidget.prototype.get_loop_state = function(){\n",
       "    var button_group = document[this.loop_select_id].state;\n",
       "    for (var i = 0; i < button_group.length; i++) {\n",
       "        var button = button_group[i];\n",
       "        if (button.checked) {\n",
       "            return button.value;\n",
       "        }\n",
       "    }\n",
       "    return undefined;\n",
       "}\n",
       "\n",
       "\n",
       "ScrubberWidget.prototype.next_frame = function() {\n",
       "\tif (this.dynamic || !this.cached) {\n",
       "\t\tif (this.wait) {\n",
       "\t\t\treturn\n",
       "\t\t}\n",
       "\t\tthis.wait = true;\n",
       "\t}\n",
       "\tif (this.dynamic && this.current_frame + 1 >= this.length) {\n",
       "\t\tthis.length += 1;\n",
       "        document.getElementById(this.slider_id).max = this.length-1;\n",
       "\t}\n",
       "    this.set_frame(Math.min(this.length - 1, this.current_frame + 1));\n",
       "}\n",
       "\n",
       "ScrubberWidget.prototype.previous_frame = function() {\n",
       "    this.set_frame(Math.max(0, this.current_frame - 1));\n",
       "}\n",
       "\n",
       "ScrubberWidget.prototype.first_frame = function() {\n",
       "    this.set_frame(0);\n",
       "}\n",
       "\n",
       "ScrubberWidget.prototype.last_frame = function() {\n",
       "    this.set_frame(this.length - 1);\n",
       "}\n",
       "\n",
       "ScrubberWidget.prototype.slower = function() {\n",
       "    this.interval /= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "}\n",
       "\n",
       "ScrubberWidget.prototype.faster = function() {\n",
       "    this.interval *= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "}\n",
       "\n",
       "ScrubberWidget.prototype.anim_step_forward = function() {\n",
       "    if(this.current_frame < this.length || (this.dynamic && !this.stopped)){\n",
       "        this.next_frame();\n",
       "    }else{\n",
       "        var loop_state = this.get_loop_state();\n",
       "        if(loop_state == \"loop\"){\n",
       "            this.first_frame();\n",
       "        }else if(loop_state == \"reflect\"){\n",
       "            this.last_frame();\n",
       "            this.reverse_animation();\n",
       "        }else{\n",
       "            this.pause_animation();\n",
       "            this.last_frame();\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "ScrubberWidget.prototype.anim_step_reverse = function() {\n",
       "    this.current_frame -= 1;\n",
       "    if(this.current_frame >= 0){\n",
       "        this.set_frame(this.current_frame);\n",
       "    } else {\n",
       "        var loop_state = this.get_loop_state();\n",
       "        if(loop_state == \"loop\"){\n",
       "            this.last_frame();\n",
       "        }else if(loop_state == \"reflect\"){\n",
       "            this.first_frame();\n",
       "            this.play_animation();\n",
       "        }else{\n",
       "            this.pause_animation();\n",
       "            this.first_frame();\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "ScrubberWidget.prototype.pause_animation = function() {\n",
       "    this.direction = 0;\n",
       "    if (this.timer){\n",
       "        clearInterval(this.timer);\n",
       "        this.timer = null;\n",
       "    }\n",
       "}\n",
       "\n",
       "ScrubberWidget.prototype.play_animation = function() {\n",
       "    this.pause_animation();\n",
       "    this.direction = 1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_forward();}, this.interval);\n",
       "}\n",
       "\n",
       "ScrubberWidget.prototype.reverse_animation = function() {\n",
       "    this.pause_animation();\n",
       "    this.direction = -1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_reverse();}, this.interval);\n",
       "}\n",
       "\n",
       "function extend(destination, source) {\n",
       "    for (var k in source) {\n",
       "        if (source.hasOwnProperty(k)) {\n",
       "            destination[k] = source[k];\n",
       "        }\n",
       "    }\n",
       "    return destination;\n",
       "}\n",
       "\n",
       "function update_widget(widget, values) {\n",
       "\tif (widget.hasClass(\"ui-slider\")) {\n",
       "\t\twidget.slider('option',\n",
       "\t\t\t\t\t  {'min': 0, 'max': values.length-1,\n",
       "\t\t\t\t\t   'dim_vals': values, 'value': 0,\n",
       "\t\t\t\t\t   'dim_labels': values})\n",
       "\t\twidget.slider('option', 'slide').call(widget, event, {'value': 0})\n",
       "\t} else {\n",
       "\t\twidget.empty();\n",
       "\t\tfor (var i=0; i<values.length; i++){\n",
       "\t\t\twidget.append($(\"<option>\", {\n",
       "\t\t\t\tvalue: i,\n",
       "\t\t\t\ttext: values[i]\n",
       "\t\t\t}))};\n",
       "\t\twidget.data('values', values);\n",
       "\t\twidget.data('value', 0);\n",
       "\t\twidget.trigger(\"change\");\n",
       "\t};\n",
       "}\n",
       "\n",
       "// Define MPL specific subclasses\n",
       "function MPLSelectionWidget() {\n",
       "\tSelectionWidget.apply(this, arguments);\n",
       "}\n",
       "\n",
       "function MPLScrubberWidget() {\n",
       "\tScrubberWidget.apply(this, arguments);\n",
       "}\n",
       "\n",
       "// Let them inherit from the baseclasses\n",
       "MPLSelectionWidget.prototype = Object.create(SelectionWidget.prototype);\n",
       "MPLScrubberWidget.prototype = Object.create(ScrubberWidget.prototype);\n",
       "\n",
       "// Define methods to override on widgets\n",
       "var MPLMethods = {\n",
       "\tinit_slider : function(init_val){\n",
       "\t\tif(this.load_json) {\n",
       "\t\t\tthis.from_json()\n",
       "\t\t} else {\n",
       "\t\t\tthis.update_cache();\n",
       "\t\t}\n",
       "\t\tthis.update(0);\n",
       "\t\tif(this.mode == 'nbagg') {\n",
       "\t\t\tthis.set_frame(init_val, 0);\n",
       "\t\t}\n",
       "\t},\n",
       "\tpopulate_cache : function(idx){\n",
       "\t\tvar cache_id = this.img_id+\"_\"+idx;\n",
       "\t\tif(this.mode == 'mpld3') {\n",
       "\t\t\tmpld3.draw_figure(cache_id, this.frames[idx]);\n",
       "\t\t} else {\n",
       "\t\t\tthis.cache[idx].html(this.frames[idx]);\n",
       "\t\t}\n",
       "\t\tif (this.embed) {\n",
       "\t\t\tdelete this.frames[idx];\n",
       "\t\t}\n",
       "\t},\n",
       "\tdynamic_update : function(current){\n",
       "\t\tif (this.dynamic) {\n",
       "\t\t\tcurrent = JSON.stringify(current);\n",
       "\t\t}\n",
       "\t\tfunction callback(msg){\n",
       "\t\t\t/* This callback receives data from Python as a string\n",
       "\t\t\t in order to parse it correctly quotes are sliced off*/\n",
       "\t\t\tif (msg.content.ename != undefined) {\n",
       "\t\t\t\tthis.process_error(msg);\n",
       "\t\t\t}\n",
       "\t\t\tif (msg.msg_type != \"execute_result\") {\n",
       "\t\t\t\tconsole.log(\"Warning: HoloViews callback returned unexpected data for key: (\", current, \") with the following content:\", msg.content)\n",
       "\t\t\t\tthis.time = undefined;\n",
       "\t\t\t\treturn\n",
       "\t\t\t}\n",
       "\t\t\tif (!(this.mode == 'nbagg')) {\n",
       "\t\t\t\tif(!(current in this.cache)) {\n",
       "\t\t\t\t\tvar data = msg.content.data['text/plain'].slice(1, -1);\n",
       "\t\t\t\t\tif(this.mode == 'mpld3'){\n",
       "\t\t\t\t\t\tdata = JSON.parse(data)[0];\n",
       "\t\t\t\t\t}\n",
       "\t\t\t\t\tthis.frames[current] = data;\n",
       "\t\t\t\t\tthis.update_cache();\n",
       "\t\t\t\t}\n",
       "\t\t\t\tthis.update(current);\n",
       "\t\t\t}\n",
       "\t\t\tthis.timed = (Date.now() - this.time) * 1.5;\n",
       "\t\t\tthis.wait = false;\n",
       "\t\t\tif (this.queue.length > 0) {\n",
       "\t\t\t\tvar current_vals = this.queue[this.queue.length-1];\n",
       "\t\t\t\tthis.time = Date.now();\n",
       "\t\t\t\tthis.dynamic_update(current_vals);\n",
       "\t\t\t\tthis.queue = [];\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t\tvar kernel = IPython.notebook.kernel;\n",
       "\t\tcallbacks = {iopub: {output: $.proxy(callback, this)}};\n",
       "\t\tvar cmd = \"holoviews.plotting.widgets.NdWidget.widgets['\" + this.id + \"'].update(\" + current + \")\";\n",
       "\t\tkernel.execute(\"import holoviews;\" + cmd, callbacks, {silent : false});\n",
       "\t}\n",
       "}\n",
       "\n",
       "// Extend MPL widgets with backend specific methods\n",
       "extend(MPLSelectionWidget.prototype, MPLMethods);\n",
       "extend(MPLScrubberWidget.prototype, MPLMethods);\n",
       "</script>\n",
       "\n",
       "\n",
       "<link rel=\"stylesheet\" href=\"https://code.jquery.com/ui/1.10.4/themes/smoothness/jquery-ui.css\">\n",
       "<style>div.hololayout {\n",
       "    display: flex;\n",
       "    align-items: center;\n",
       "    margin: 0;\n",
       "}\n",
       "\n",
       "div.holoframe {\n",
       "\twidth: 75%;\n",
       "}\n",
       "\n",
       "div.holowell {\n",
       "    display: flex;\n",
       "    align-items: center;\n",
       "    margin: 0;\n",
       "}\n",
       "\n",
       "form.holoform {\n",
       "    background-color: #fafafa;\n",
       "    border-radius: 5px;\n",
       "    overflow: hidden;\n",
       "\tpadding-left: 0.8em;\n",
       "    padding-right: 0.8em;\n",
       "    padding-top: 0.4em;\n",
       "    padding-bottom: 0.4em;\n",
       "}\n",
       "\n",
       "div.holowidgets {\n",
       "    padding-right: 0;\n",
       "\twidth: 25%;\n",
       "}\n",
       "\n",
       "div.holoslider {\n",
       "    min-height: 0 !important;\n",
       "    height: 0.8em;\n",
       "    width: 60%;\n",
       "}\n",
       "\n",
       "div.holoformgroup {\n",
       "    padding-top: 0.5em;\n",
       "    margin-bottom: 0.5em;\n",
       "}\n",
       "\n",
       "div.hologroup {\n",
       "    padding-left: 0;\n",
       "    padding-right: 0.8em;\n",
       "    width: 50%;\n",
       "}\n",
       "\n",
       ".holoselect {\n",
       "    width: 92%;\n",
       "    margin-left: 0;\n",
       "    margin-right: 0;\n",
       "}\n",
       "\n",
       ".holotext {\n",
       "    width: 100%;\n",
       "    padding-left:  0.5em;\n",
       "    padding-right: 0;\n",
       "}\n",
       "\n",
       ".holowidgets .ui-resizable-se {\n",
       "\tvisibility: hidden\n",
       "}\n",
       "\n",
       ".holoframe > .ui-resizable-se {\n",
       "\tvisibility: hidden\n",
       "}\n",
       "\n",
       ".holowidgets .ui-resizable-s {\n",
       "\tvisibility: hidden\n",
       "}\n",
       "</style>\n",
       "\n",
       "\n",
       "<div>\n",
       "<img src='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABkAAAAZCAIAAABLixI0AAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH3wkCDDIOi3cusgAABT1JREFUOMtVlclvG2UYh3/fMovHe53FThySNHZomrRJl6QR0AJdpVblQBEHJC4ciipxAgmO3PgPEP8BQkIsRUJUSF1oqGih0JY2CtnjOLGz2Em8xPbMeL6Pw9RJOprLjPT+5tH7Pu83JE7pqeHh8wMD2evfyXMXf/nxB2FZo6dPNzVHvvr6GxMQeOEigARswNzzUgK6x8NagPzS0nqxODQ62nLn1xMnX99/eLC3sGVROj2/IBxHABKgANlzM4ACTuMRAOecNREiAWtzc0NIEu/M37zVMTWeqlrpUDg1M7NTVgdkowwvxqGRRV1CE8jOznq7uhYAi2CpXtdVVQE4QAAdCAAGwAAJyEa9Amh7PsAihBBAABrg1XUfpe3bxTXb8XR0WJa1VSzWGyAcUAEVoIAARIMOQH2HC4AA6lKW8/n9Pm/Ahl4zV8fGTg0PtzQ3K3tA3GId8AO+BqZLt8sFQKE0GouRSkWtFM63KV0Vy1rJhN44k56cFFI6exJ3MBWANACVHS63aw5QtutVVT/4xWfHv/0ylytmHvx56sIFLxACfIABGIAf8ANRn++9y5evXrkS0XWXd5dLJWRfOHwspA1tr4iFtP3gD8/apjCtSDiyQYhZKNA94wOQTCQPhfzm9FTJH8jn84Tz3SyPlEQ4vf0Dt5/MPE5vpVObzQbxqvaDdL731MnWnh5pmsxxdE3rTCZfO3u2FbL6+2+hzpcKwXA2ldrNUgAVII7TMXhkZnzcAQTgAWI6sgV7YmKivLra1tFxMJk4Ho/r5fLy3btsYS7JHL1YoeHQKldKhcLzLNcdlRDOWDgczuVyOtDt4yN9gRYVmc161TTLmYw9P9e8OHcU5dG2fa3EmhNyKjGwROmzZ8+YqlIAKsDd9jtOenIy1t8vgDJQtuvYrjRT0kMQBRIUQxqSXkSDUIO0YAulvdfxGk/u33eVZs2EeBvu6gCjtKW7Oz81xQBhI73mtATQn/BuZ6wTrezsYX+1Jn+aNR8sl9Zb47l4/O+HD2u27QDgnHUQwhvKuFmRaLS2tkZsmwJSQpqIUzHYyynndx5t/1Vy5gXyhMhorEJIKpViQB0QnFNlZzkbdExRhBAckIAFbFXFetkpg94er004WK6jCniamrRAYHlmxhXFtWTXVfW50SQYDjvVKm+YHVMR10G5VAGrcWAohkEVpbC1RRo7QN2mS0BzuQiJHziwMTurAwrgBTo95NVjnshb3XaF9q1MTM7VeWNv6kJQgAISYAAHuARUQAHA2NCZM35KJ27c6KA4YiBXJlpVro5bkaGN2mStsCy8gAXobpyU7iFhAgxQAB40jMHh4WhnJ6nVpsfGVjOZUQMhi40k9K1FqQZI4ogffd3k33GPobTb5kCIFmriEYjgnABao60KwD68eCnz5PH0vXsr4+OsVIpRvNmpnLvQEozRpm5vxAP107dx+RMlvGTcmw7Xle6DwZlsdbZY05qbAq2ta9msCkhAcM4+yv+3uFZWAA+gA5pEaUOUnpaMohb+/BK7+j76r4IliFoyAv9EjsZ4ZbMmyOKqmdvciiWTL4+OUsY8mkY554d7okGyciuHqgQFVIABlkJ9fV44FLFrz8ecuIZ3u6offzD1fSnFmJSgle35mzcdVQ1Eo23B4Eh7lJdWNgZGohM/r5QAjZEoaDzi0TfKPlFDV/KF35mqs0NN1v3iRrqqAT7Xbdti6UXPImKZaf5SQiUBtAIG0OVXXnmnDUJWb9nET7D8VPba7pAJTKRnxPUpI+v0BXlApZPrlgDaCTke1VqaaLZC/wesjSVVF5Ac7QAAAABJRU5ErkJggg=='\n",
       "     style='width:25px;height:25px; border-radius:12px;'/>\n",
       "\n",
       "HoloViewsJS successfully loaded in this cell.\n",
       "</div>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from types import SimpleNamespace\n",
    "import scipy.linalg as la\n",
    "import holoviews as hv\n",
    "\n",
    "hv.notebook_extension()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# mgrid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src='data:image/png;base64,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' style='max-width:100%; margin: auto; display: block; '/>"
      ],
      "text/plain": [
       ":Layout\n",
       "   .Raster.I  :Raster   [x,y]   (z)\n",
       "   .Raster.II :Raster   [x,y]   (z)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%opts Raster (cmap='viridis' interpolation='sinc') [colorbar=True]\n",
    "N = 4\n",
    "\n",
    "x, y = np.mgrid[-N:N+1, -N:N+1]\n",
    "hv.Raster(np.rot90(x)) + hv.Raster(np.rot90(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# wave function from kwant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import kwant\n",
    "from kwant.continuum import discretize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "tb = discretize('k_x**2 + k_y**2 + Vx * x + Vy * y')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "syst = kwant.Builder()\n",
    "shape = lambda s: -20 < s.pos[0] < 20 and -10 < s.pos[1] < 10\n",
    "syst.fill(tb, shape, (0, 0));\n",
    "\n",
    "syst = syst.finalized()\n",
    "\n",
    "pars = SimpleNamespace(Vx=.03, Vy=0.05)\n",
    "ev, evec = la.eigh(syst.hamiltonian_submatrix(args=[pars]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW0AAAD5CAYAAADsgWTDAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nbSIiBWHQJiJSEAZtIiIF+f+VO1vXRGOdXgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fa7b75a1cf8>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wf = np.abs(evec[:, 0])**2\n",
    "kwant.plotter.map(syst, wf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "coords = np.array([s.pos for s in syst.sites])\n",
    "wf = kwant.plotter.mask_interpolate(coords, wf)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src='data:image/png;base64,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' style='max-width:100%; margin: auto; display: block; '/>"
      ],
      "text/plain": [
       "b':Raster   [x,y]   (z)'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%opts Raster (cmap='viridis' interpolation='sinc') [colorbar=True]\n",
    "\n",
    "hv.Raster(np.rot90(wf))"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda env:kwant]",
   "language": "python",
   "name": "conda-env-kwant-py"
  },
  "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.5.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}