From de3ac23c7169fa28b850147e9cb6b0aca3cbab90 Mon Sep 17 00:00:00 2001
From: drs251 <danrstephan@gmail.com>
Date: Sun, 11 Mar 2018 16:58:46 +0100
Subject: [PATCH 1/4] XArrayInterface improvements: will now attempt to read
 units and dimension labels for all key and value dimensions, added test to
 make sure xarray.Datasets and xarray.DataArrays are treated equivalently

---
 holoviews/core/data/xarray.py  | 12 +++++++++-
 tests/core/data/testdataset.py | 41 ++++++++++++++++++++++++++++++++++
 2 files changed, 52 insertions(+), 1 deletion(-)

diff --git a/holoviews/core/data/xarray.py b/holoviews/core/data/xarray.py
index 92478e40f8..4649eaa159 100644
--- a/holoviews/core/data/xarray.py
+++ b/holoviews/core/data/xarray.py
@@ -80,6 +80,7 @@ def init(cls, eltype, data, kdims, vdims):
                                 cls)
             vdims = [vdim]
             data = data.to_dataset(name=vdim.name)
+
         if not isinstance(data, xr.Dataset):
             if kdims is None:
                 kdims = kdim_param.default
@@ -120,8 +121,9 @@ def init(cls, eltype, data, kdims, vdims):
                     for c in data.coords:
                         if c not in kdims and set(data[c].dims) == set(virtual_dims):
                             kdims.append(c)
+            vdims = [vd if isinstance(vd, Dimension) else Dimension(vd) for vd in vdims]
+            kdims = [kd if isinstance(kd, Dimension) else Dimension(kd) for kd in kdims]
 
-        kdims = [d if isinstance(d, Dimension) else Dimension(d) for d in kdims]
         not_found = []
         for d in kdims:
             if not any(d.name == k or (isinstance(v, xr.DataArray) and d.name in v.dims)
@@ -133,6 +135,14 @@ def init(cls, eltype, data, kdims, vdims):
             raise DataError("xarray Dataset must define coordinates "
                             "for all defined kdims, %s coordinates not found."
                             % not_found, cls)
+
+        # retrieve units and labels from Dataset:
+        for d in kdims + vdims:
+            d.unit = data[d.name].attrs.get('units')
+            label = data[d.name].attrs.get('long_name')
+            if label is not None:
+                d.label = label
+
         return data, {'kdims': kdims, 'vdims': vdims}, {}
 
 
diff --git a/tests/core/data/testdataset.py b/tests/core/data/testdataset.py
index 1d35fa4626..4bf3750f99 100644
--- a/tests/core/data/testdataset.py
+++ b/tests/core/data/testdataset.py
@@ -1572,6 +1572,47 @@ def test_xarray_dataset_with_scalar_dim_canonicalize(self):
         expected = np.array([[0, 1], [2, 3], [4, 5]])
         self.assertEqual(canonical, expected)
 
+    def test_xarray_dataset_names_and_units(self):
+        import xarray as xr
+        xs = [0.1, 0.2, 0.3]
+        ys = [0, 1]
+        zs = np.array([[0, 1], [2, 3], [4, 5]])
+        da = xr.DataArray(zs, coords=[('x_dim', xs), ('y_dim', ys)], name="data_name", dims=['y_dim', 'x_dim'])
+        da.attrs['long_name'] = "data long name"
+        da.attrs['units'] = "array_unit"
+        da.x_dim.attrs['units'] = "x_unit"
+        da.y_dim.attrs['long_name'] = "y axis long name"
+        dataset = Dataset(da)
+        self.assertEqual(dataset.get_dimension("x_dim"), Dimension("x_dim", unit="x_unit"))
+        self.assertEqual(dataset.get_dimension("y_dim"), Dimension("y_dim", label="y axis long name"))
+        self.assertEqual(dataset.get_dimension("data_name"),
+                         Dimension("data_name", label="data long name", unit="array_unit"))
+
+    def test_xarray_dataset_dataarray_vs_dataset(self):
+        import xarray as xr
+        xs = [0.1, 0.2, 0.3]
+        ys = [0, 1]
+        zs = np.array([[0, 1], [2, 3], [4, 5]])
+        da = xr.DataArray(zs, coords=[('x_dim', xs), ('y_dim', ys)], name="data_name", dims=['y_dim', 'x_dim'])
+        da.attrs['long_name'] = "data long name"
+        da.attrs['units'] = "array_unit"
+        da.x_dim.attrs['units'] = "x_unit"
+        da.y_dim.attrs['long_name'] = "y axis long name"
+        ds = da.to_dataset()
+        dataset_from_da = Dataset(da)
+        dataset_from_ds = Dataset(ds)
+        self.assertEqual(dataset_from_da, dataset_from_ds)
+        # same with reversed names:
+        da_rev = xr.DataArray(zs, coords=[('x_dim', xs), ('y_dim', ys)], name="data_name", dims=['x_dim', 'y_dim'])
+        da_rev.attrs['long_name'] = "data long name"
+        da_rev.attrs['units'] = "array_unit"
+        da_rev.x_dim.attrs['units'] = "x_unit"
+        da_rev.y_dim.attrs['long_name'] = "y axis long name"
+        ds_rev = da_rev.to_dataset()
+        dataset_from_da_rev = Dataset(da_rev)
+        dataset_from_ds_rev = Dataset(ds_rev)
+        self.assertEqual(dataset_from_da_rev, dataset_from_ds_rev)
+
     def test_dataset_array_init_hm(self):
         "Tests support for arrays (homogeneous)"
         raise SkipTest("Not supported")

From 182bc6097e0c27538088c11949d1a5e3d24fc8e4 Mon Sep 17 00:00:00 2001
From: drs251 <danrstephan@gmail.com>
Date: Thu, 15 Mar 2018 01:57:02 +0100
Subject: [PATCH 2/4] Added some documentation on using xarray with Dataset

---
 examples/user_guide/08-Gridded_Datasets.ipynb | 953 +++++++++++++++++-
 1 file changed, 950 insertions(+), 3 deletions(-)

diff --git a/examples/user_guide/08-Gridded_Datasets.ipynb b/examples/user_guide/08-Gridded_Datasets.ipynb
index 989ecd2bbb..cc7dc9cf30 100644
--- a/examples/user_guide/08-Gridded_Datasets.ipynb
+++ b/examples/user_guide/08-Gridded_Datasets.ipynb
@@ -9,9 +9,626 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
-   "outputs": [],
+   "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.comms = {};\n",
+       "HoloViewsWidget.comm_state = {};\n",
+       "\n",
+       "HoloViewsWidget.prototype.init_slider = function(init_val){\n",
+       "  if(this.load_json) {\n",
+       "    this.from_json()\n",
+       "  } else {\n",
+       "    this.update_cache();\n",
+       "  }\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",
+       "  var data_url = this.json_path + this.id + '.json';\n",
+       "  $.getJSON(data_url, $.proxy(function(json_data) {\n",
+       "    this.frames = json_data;\n",
+       "    this.update_cache();\n",
+       "    this.update(0);\n",
+       "  }, this));\n",
+       "}\n",
+       "\n",
+       "HoloViewsWidget.prototype.dynamic_update = function(current){\n",
+       "  if (current === undefined) {\n",
+       "    return\n",
+       "  }\n",
+       "  if(this.dynamic) {\n",
+       "    current = JSON.stringify(current);\n",
+       "  }\n",
+       "  function callback(initialized, msg){\n",
+       "    /* This callback receives data from Python as a string\n",
+       "       in order to parse it correctly quotes are sliced off*/\n",
+       "    if (msg.content.ename != undefined) {\n",
+       "      this.process_error(msg);\n",
+       "    }\n",
+       "    if (msg.msg_type != \"execute_result\") {\n",
+       "      console.log(\"Warning: HoloViews callback returned unexpected data for key: (\", current, \") with the following content:\", msg.content)\n",
+       "    } else {\n",
+       "      if (msg.content.data['text/plain'].includes('Complete')) {\n",
+       "        if (this.queue.length > 0) {\n",
+       "          this.time = Date.now();\n",
+       "          this.dynamic_update(this.queue[this.queue.length-1]);\n",
+       "          this.queue = [];\n",
+       "        } else {\n",
+       "          this.wait = false;\n",
+       "        }\n",
+       "        return\n",
+       "      }\n",
+       "    }\n",
+       "  }\n",
+       "  this.current = current;\n",
+       "  if ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null)) {\n",
+       "    var kernel = Jupyter.notebook.kernel;\n",
+       "    callbacks = {iopub: {output: $.proxy(callback, this, this.initialized)}};\n",
+       "    var cmd = \"holoviews.plotting.widgets.NdWidget.widgets['\" + this.id + \"'].update(\" + current + \")\";\n",
+       "    kernel.execute(\"import holoviews;\" + cmd, callbacks, {silent : false});\n",
+       "  }\n",
+       "}\n",
+       "\n",
+       "HoloViewsWidget.prototype.update_cache = function(force){\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) || force) {\n",
+       "      if ((frame in this.cache) && force) { this.cache[frame].remove() }\n",
+       "      this.cache[frame] = $('<div />').appendTo(\"#\"+\"_anim_img\"+this.id).hide();\n",
+       "      var cache_id = \"_anim_img\"+this.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",
+       "    this.wait = false;\n",
+       "  }\n",
+       "}\n",
+       "\n",
+       "HoloViewsWidget.prototype.init_comms = function() {\n",
+       "  if ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel !== undefined)) {\n",
+       "    var widget = this;\n",
+       "    comm_manager = Jupyter.notebook.kernel.comm_manager;\n",
+       "    comm_manager.register_target(this.id, function (comm) {\n",
+       "      comm.on_msg(function (msg) { widget.process_msg(msg) });\n",
+       "    });\n",
+       "  }\n",
+       "}\n",
+       "\n",
+       "HoloViewsWidget.prototype.process_msg = function(msg) {\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.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",
+       "  this.json_path = json_path;\n",
+       "  this.init_slider(this.current_vals[0]);\n",
+       "  this.queue = [];\n",
+       "  this.wait = false;\n",
+       "  if (!this.cached || this.dynamic) {\n",
+       "    this.init_comms()\n",
+       "  }\n",
+       "}\n",
+       "\n",
+       "SelectionWidget.prototype = new HoloViewsWidget;\n",
+       "\n",
+       "\n",
+       "SelectionWidget.prototype.get_key = function(current_vals) {\n",
+       "  var 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) { val = val.toFixed(1); }\n",
+       "      else { val = val.toFixed(10); val = val.slice(0, val.length-1);}\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",
+       "  return this.keyMap[key];\n",
+       "}\n",
+       "\n",
+       "SelectionWidget.prototype.set_frame = function(dim_val, dim_idx){\n",
+       "  this.current_vals[dim_idx] = dim_val;\n",
+       "  var key = this.current_vals;\n",
+       "  if (!this.dynamic) {\n",
+       "    key = this.get_key(key)\n",
+       "  }\n",
+       "  if (this.dynamic || !this.cached) {\n",
+       "    if ((this.time !== undefined) && ((this.wait) && ((this.time + 10000) > Date.now()))) {\n",
+       "      this.queue.push(key);\n",
+       "      return\n",
+       "    }\n",
+       "    this.queue = [];\n",
+       "    this.time = Date.now();\n",
+       "    this.current_frame = key;\n",
+       "    this.wait = true;\n",
+       "    this.dynamic_update(key)\n",
+       "  } else if (key !== undefined) {\n",
+       "    this.update(key)\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.slider_id = \"_anim_slider\" + id;\n",
+       "  this.loop_select_id = \"_anim_loop_select\" + id;\n",
+       "  this.id = 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",
+       "  this.json_path = json_path;\n",
+       "  document.getElementById(this.slider_id).max = this.length - 1;\n",
+       "  this.init_slider(0);\n",
+       "  this.wait = false;\n",
+       "  this.queue = [];\n",
+       "  if (!this.cached || this.dynamic) {\n",
+       "    this.init_comms()\n",
+       "  }\n",
+       "}\n",
+       "\n",
+       "ScrubberWidget.prototype = new HoloViewsWidget;\n",
+       "\n",
+       "ScrubberWidget.prototype.set_frame = function(frame){\n",
+       "  this.current_frame = frame;\n",
+       "  widget = 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.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",
+       "  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 - 1){\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",
+       "  if(this.current_frame > 0){\n",
+       "    this.previous_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",
+       "  if (widget.hasClass(\"ui-slider\")) {\n",
+       "    widget.slider('option', {\n",
+       "      min: 0,\n",
+       "      max: values.length-1,\n",
+       "      dim_vals: values,\n",
+       "      value: 0,\n",
+       "      dim_labels: values\n",
+       "\t})\n",
+       "    widget.slider('option', 'slide').call(widget, event, {value: 0})\n",
+       "  } else {\n",
+       "    widget.empty();\n",
+       "    for (var i=0; i<values.length; i++){\n",
+       "      widget.append($(\"<option>\", {\n",
+       "        value: i,\n",
+       "        text: values[i]\n",
+       "      }))\n",
+       "    };\n",
+       "    widget.data('values', values);\n",
+       "    widget.data('value', 0);\n",
+       "    widget.trigger(\"change\");\n",
+       "  };\n",
+       "}\n",
+       "\n",
+       "// Define MPL specific subclasses\n",
+       "function MPLSelectionWidget() {\n",
+       "    SelectionWidget.apply(this, arguments);\n",
+       "}\n",
+       "\n",
+       "function MPLScrubberWidget() {\n",
+       "    ScrubberWidget.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",
+       "    init_slider : function(init_val){\n",
+       "        if(this.load_json) {\n",
+       "            this.from_json()\n",
+       "        } else {\n",
+       "            this.update_cache();\n",
+       "        }\n",
+       "        this.update(0);\n",
+       "        if(this.mode == 'nbagg') {\n",
+       "            this.set_frame(init_val, 0);\n",
+       "        }\n",
+       "    },\n",
+       "    populate_cache : function(idx){\n",
+       "        var cache_id = \"_anim_img\"+this.id+\"_\"+idx;\n",
+       "        this.cache[idx].html(this.frames[idx]);\n",
+       "        if (this.embed) {\n",
+       "            delete this.frames[idx];\n",
+       "        }\n",
+       "    },\n",
+       "    process_msg : function(msg) {\n",
+       "        if (!(this.mode == 'nbagg')) {\n",
+       "            var data = msg.content.data;\n",
+       "            this.frames[this.current] = data;\n",
+       "            this.update_cache(true);\n",
+       "            this.update(this.current);\n",
+       "        }\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 class=\"logo-block\">\n",
+       "<img src='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n",
+       "AAAB+wAAAfsBxc2miwAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAA6zSURB\n",
+       "VHic7ZtpeFRVmsf/5966taWqUlUJ2UioBBJiIBAwCZtog9IOgjqACsogKtqirT2ttt069nQ/zDzt\n",
+       "tI4+CrJIREFaFgWhBXpUNhHZQoKBkIUASchWla1S+3ar7r1nPkDaCAnZKoQP/D7mnPOe9/xy76n3\n",
+       "nFSAW9ziFoPFNED2LLK5wcyBDObkb8ZkxuaoSYlI6ZcOKq1eWFdedqNzGHQBk9RMEwFAASkk0Xw3\n",
+       "ETacDNi2vtvc7L0ROdw0AjoSotQVkKSvHQz/wRO1lScGModBFbDMaNRN1A4tUBCS3lk7BWhQkgpD\n",
+       "lG4852/+7DWr1R3uHAZVQDsbh6ZPN7CyxUrCzJMRouusj0ipRwD2uKm0Zn5d2dFwzX1TCGhnmdGo\n",
+       "G62Nna+isiUqhkzuKrkQaJlPEv5mFl2fvGg2t/VnzkEV8F5ioioOEWkLG86fvbpthynjdhXYZziQ\n",
+       "x1hC9J2NFyi8vCTt91Fh04KGip0AaG9zuCk2wQCVyoNU3Hjezee9bq92duzzTmxsRJoy+jEZZZYo\n",
+       "GTKJ6SJngdJqAfRzpze0+jHreUtPc7gpBLQnIYK6BYp/uGhw9YK688eu7v95ysgshcg9qSLMo3JC\n",
+       "4jqLKQFBgdKDPoQ+Pltb8dUyQLpeDjeVgI6EgLIQFT5tEl3rn2losHVsexbZ3EyT9wE1uGdkIPcy\n",
+       "BGxn8QUq1QrA5nqW5i2tLqvrrM9NK6AdkVIvL9E9bZL/oyfMVd/jqvc8LylzRBKDJSzIExwhQzuL\n",
+       "QYGQj4rHfFTc8mUdu3E7yoLtbTe9gI4EqVgVkug2i5+uXGo919ixbRog+3fTbQ8qJe4ZOYNfMoTI\n",
+       "OoshUNosgO60AisX15aeI2PSIp5KiFLI9ubb1vV3Qb2ltwLakUCDAkWX7/nHKRmmGIl9VgYsUhJm\n",
+       "2NXjKYADtM1ygne9QQDIXlk49FBstMKx66D1v4+XuQr7vqTe0VcBHQlRWiOCbmmSYe2SqtL6q5rJ\n",
+       "zsTb7lKx3FKOYC4DoqyS/B5bvLPxvD9Qtf6saxYLQGJErmDOdOMr/zo96km1nElr8bmPOBwI9COv\n",
+       "HnFPRIwmkSOv9kcAS4heRsidOkpeWBgZM+UBrTFAXNYL5Vf2ii9c1trNzpYdaoVil3WIc+wdk+gQ\n",
+       "noie3ecCcxt9ITcLAPWt/laGEO/9U6PmzZkenTtsSMQ8uYywJVW+grCstAvCIaAdArAsIWkRDDs/\n",
+       "KzLm2YcjY1Lv0UdW73HabE9n6V66cxSzfEmuJssTpKGVp+0vHq73FwL46eOjpMpbRAnNmJFrGJNu\n",
+       "Ukf9Yrz+3rghiumCKNXXWPhLYcjxGsIpoCMsIRoFITkW8AuyM8jC1+/QLx4bozCEJIq38+1rtpR6\n",
+       "V/yzb8eBlRb3fo5l783N0CWolAzJHaVNzkrTzlEp2bQ2q3TC5gn6wpnoQAmwSiGh2GitnTmVMc5O\n",
+       "UyfKWUKCIsU7+fZDKwqdT6DDpvkzAX4/+AMFjk0tDp5GRXLpQ2MUmhgDp5gxQT8+Y7hyPsMi8uxF\n",
+       "71H0oebujHALECjFKaW9Lm68n18wXp2kVzIcABytD5iXFzg+WVXkegpAsOOYziqo0OkK76GyquC3\n",
+       "ltZAzMhhqlSNmmWTE5T6e3IN05ITFLM4GdN0vtZ3ob8Jh1NAKXFbm5PtLU/eqTSlGjkNAJjdgn/N\n",
+       "aedXa0tdi7+t9G0FIF49rtMSEgAs1kDLkTPO7ebm4IUWeyh1bKomXqlgMG6kJmHcSM0clYLJ8XtR\n",
+       "1GTnbV3F6I5wCGikAb402npp1h1s7LQUZZSMIfALFOuL3UUrfnS8+rez7v9qcold5tilgHbO1fjK\n",
+       "9ubb17u9oshxzMiUBKXWqJNxd+fqb0tLVs4lILFnK71H0Ind7uiPgACVcFJlrb0tV6DzxqqTIhUM\n",
+       "CwDf1/rrVhTa33/3pGPxJYdQ2l2cbgVcQSosdx8uqnDtbGjh9SlDVSMNWhlnilfqZk42Th2ZpLpf\n",
+       "xrHec5e815zrr0dfBZSwzkZfqsv+1FS1KUknUwPARVvItfKUY+cn57yP7qv07UE3p8B2uhUwLk09\n",
+       "e0SCOrK+hbdYHYLjRIl71wWzv9jpEoeOHhGRrJAzyEyNiJuUqX0g2sBN5kGK6y2Blp5M3lsB9Qh4\n",
+       "y2Ja6x6+i0ucmKgwMATwhSjdUu49tKrQ/pvN5d53ml2CGwCmJipmKjgmyuaXzNeL2a0AkQ01Th5j\n",
+       "2DktO3Jyk8f9vcOBQHV94OK+fPumJmvQHxJoWkaKWq9Vs+yUsbq0zGT1I4RgeH2b5wef7+c7bl8F\n",
+       "eKgoHVVZa8ZPEORzR6sT1BzDUAD/d9F78e2Tzv99v8D+fLVTqAKAsbGamKey1Mt9Ann4eH3gTXTz\n",
+       "idWtAJ8PQWOk7NzSeQn/OTHDuEikVF1R4z8BQCy+6D1aWRfY0tTGG2OM8rRoPaeIj5ZHzJxszElN\n",
+       "VM8K8JS5WOfv8mzRnQAKoEhmt8gyPM4lU9SmBK1MCQBnW4KONT86v1hZ1PbwSXPw4JWussVjtH9Y\n",
+       "NCoiL9UoH/6PSu8jFrfY2t36erQHXLIEakMi1SydmzB31h3GGXFDFNPaK8Rme9B79Ixrd0WN+1ij\n",
+       "NRQ/doRmuFLBkHSTOm5GruG+pFjFdAmorG4IXH1Qua6ASniclfFtDYt+oUjKipPrCQB7QBQ2lrgP\n",
+       "fFzm+9XWUtcqJ3/5vDLDpJ79XHZk3u8nGZ42qlj1+ydtbxysCezrydp6ugmipNJ7WBPB5tydY0jP\n",
+       "HaVNzs3QzeE4ZpTbI+ZbnSFPbVOw9vsfnVvqWnirPyCNGD08IlqtYkh2hjZ5dErEQzoNm+6ykyOt\n",
+       "Lt5/PQEuSRRKo22VkydK+vvS1XEKlhCJAnsqvcVvH7f/ZU2R67eXbMEGAMiIV5oWZWiWvz5Fv2xG\n",
+       "sjqNJQRvn3Rs2lji/lNP19VjAQDgD7FHhujZB9OGqYxRkZxixgRDVlqS6uEOFaJUVu0rPFzctrnF\n",
+       "JqijImVp8dEKVWyUXDk92zAuMZ6bFwpBU1HrOw6AdhQgUooChb0+ItMbWJitSo5Ws3IAOGEOtL53\n",
+       "0vHZih9sC4vtofZ7Qu6523V/fmGcds1TY3V36pUsBwAbSlxnVh2xLfAD/IAIMDf7XYIkNmXfpp2l\n",
+       "18rkAJAy9HKFaIr/qULkeQQKy9zf1JgDB2uaeFNGijo5QsUyacNUUTOnGO42xSnv4oOwpDi1zYkc\n",
+       "efUc3I5Gk6PhyTuVKaOGyLUAYPGIoY9Pu/atL/L92+4q9wbflRJ2Trpm/jPjdBtfnqB/dIThcl8A\n",
+       "KG7hbRuKnb8qsQsVvVlTrwQAQMUlf3kwJI24Z4JhPMtcfng5GcH49GsrxJpGvvHIaeem2ma+KSjQ\n",
+       "lIwUdYyCY8j4dE1KzijNnIP2llF2wcXNnsoapw9XxsgYAl6k+KzUXbi2yP3KR2ecf6z3BFsBICdW\n",
+       "nvnIaG3eHybqX7vbpEqUMT+9OL4Qpe8VON7dXuFd39v19FoAABRVePbGGuXTszO0P7tu6lghUonE\n",
+       "llRdrhArLvmKdh9u29jcFiRRkfLUxBiFNiqSU9icoZQHo5mYBI1MBgBH6wMNb+U7Pnw337H4gi1Y\n",
+       "ciWs+uks3Z9fztUvfzxTm9Ne8XXkvQLHNytOOZeiD4e0PgkAIAYCYknKUNUDSXEKzdWNpnil7r4p\n",
+       "xqkjTarZMtk/K8TQ6Qve78qqvXurGwIJqcOUKfUWHsm8KGvxSP68YudXq4pcj39X49uOK2X142O0\n",
+       "Tz5/u/7TVybqH0rSya6ZBwD21/gubbrgWdDgEOx9WUhfBaC2ibcEBYm7a7x+ukrBMNcEZggyR0TE\n",
+       "T8zUPjikQ4VosQZbTpS4vqizBKvqmvjsqnpfzaZyx9JPiz1/bfGKdgD45XB1zoIMzYbfTdS/NClB\n",
+       "Gct0USiY3YL/g0LHy/uq/Ef6uo5+n0R/vyhp17Klpge763f8rMu6YU/zrn2nml+2WtH+Z+5IAAFc\n",
+       "2bUTdTDOSNa9+cQY7YLsOIXhevEkCvzph7a8laecz/Un/z4/Ae04XeL3UQb57IwU9ZDr9UuKVajv\n",
+       "nxp1+1UVIo/LjztZkKH59fO3G/JemqCfmaCRqbqbd90ZZ8FfjtkfAyD0J/9+C2h1hDwsSxvGjNDc\n",
+       "b4zk5NfrSwiQblLHzZhg+Jf4aPlUwpDqkQqa9nimbt1/TDH8OitGMaQnj+RJS6B1fbF7SY1TqO5v\n",
+       "/v0WAADl1f7zokgS7s7VT2DZ7pegUjBM7mjtiDZbcN4j0YrHH0rXpCtY0qPX0cVL0rv5jv/ZXend\n",
+       "0u/EESYBAFBU4T4Qa5TflZOhTe7pmKpaP8kCVUVw1+yhXfJWvn1P3hnXi33JsTN6PnP3hHZ8Z3/h\n",
+       "aLHzmkNPuPj7Bc/F/Q38CwjTpSwQXgE4Vmwry9tpfq/ZFgqFMy4AVDtCvi8rvMvOmv0N4YwbVgEA\n",
+       "sPM72/KVnzfspmH7HQGCRLG2yL1+z8XwvPcdCbsAANh+xPzstgMtxeGKt+6MK3/tacfvwhWvIwMi\n",
+       "oKEBtm0H7W+UVfkc/Y1V0BhoPlDr/w1w/eu1vjIgAgDg22OtX6/eYfnEz/focrZTHAFR+PSs56/7\n",
+       "q32nwpjazxgwAQCwcU/T62t3WL7r6/jVRa6/byp1rei+Z98ZUAEAhEPHPc8fKnTU9nbgtnOe8h0l\n",
+       "9hcGIqmODLQAHCy2Xti6v/XNRivf43f4fFvIteu854+VHnR7q9tfBlwAAGz+pnndB9vM26UebAe8\n",
+       "SLHujPOTPVW+rwY+sxskAAC2HrA8t2Vvc7ffP1r9o+vwR2dcr92InIAbKKC1FZ5tB1tf+/G8p8sv\n",
+       "N/9Q5zd/XR34LYCwV5JdccMEAMDBk45DH243r/X4xGvqxFa/GNpS7n6rwOwNWwHVE26oAADYurf1\n",
+       "zx/utOzt+DMKYM0p17YtZZ5VNzqfsB2HewG1WXE8PoZ7gOclbTIvynZf9JV+fqZtfgs/8F/Nu5rB\n",
+       "EIBmJ+8QRMmpU7EzGRsf2FzuePqYRbzh/zE26EwdrT10f6r6o8HOYzCJB9Dpff8tbnGLG8L/A/WE\n",
+       "roTBs2RqAAAAAElFTkSuQmCC'\n",
+       "     style='height:25px; border-radius:12px; display: inline-block; float: left; vertical-align: middle'></img>\n",
+       "\n",
+       "\n",
+       "\n",
+       "\n",
+       "  <img src='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n",
+       "AAAFMAAABTABZarKtgAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAArNSURB\n",
+       "VFiFnVd5VFNXGv/ee0kgGyQhbFoXIKCFYEXEDVErTucMoKUOWA/VLsNSLPQgFTOdyrHPiIp1lFIQ\n",
+       "OlaPShEG3EpPcQmISCuV1bQ1CLKIULeQhJA9JO+9+UMT0x5aPfOdc895373f/e7v/t537/ddBF5Q\n",
+       "JBIJl81mJwCACEVRQBCEQhAEAQCgnghCURRCkmS7Wq2+WlJSYn0Rv8jzDHAcD0EQJIVGo5mFQuGF\n",
+       "jIyMu39kq1KpkOrq6gU6nS6aIAiGzWY7VVBQ0P9/AcjNzWXy+fxcOp2uiY+Przm0d6+n8dblv/Fo\n",
+       "kzM4SzYfPlRePvFnjnt6ehh1dXVv2mw2nlar/byoqMj8wgBwHBchCJIZEhJSeu1yHVi7vtu02t8+\n",
+       "NykQ7BMWoOUMhXQsXLv5IQAwSJJEEASxcDicoeTk5DtCoZBy9XX69Gnv3t7ebJIky3EcH3guAKlU\n",
+       "GoGiaOKWLVsOvhs7/9XXPMde3/IyIFbMnaPDuD5AUdQuOf2XlD0npTExMWYAgNbWVpZcLg8xGAzB\n",
+       "JEnSvby82tPT052LaTQatLy8fBtJkt/s3Lnz5h8CwHFcRKPRNu/YsePAjh072KTs0IGCxRg8RgUB\n",
+       "TGpSx6cmHgMAfNqN6Xa1GvJ/D35gYAAViURkcXHxUrPZHDRv3rxv4uLiDI7xPXv2bLdYLBUFBQWD\n",
+       "jj7M8ZGbm8tkMpmSrKysQiaTScXGxtpqL7dManT6tcu5mgEWWJyOhicozpk+c3NsbKzNFcBbWWEf\n",
+       "1Td9/upA30i3ZJv0h8bGxiSFQmFcuHDhOACAWCy+0d3dvX3lypUtzc3N9t8AiIuLk4SEhByLiooy\n",
+       "AgAcO3ZsNlPgH3Cttb35JZo+bCYXIQAA9MDiUW7sWS1KN687w6Mera2twa2trfMvXboUOS28Pyb1\n",
+       "U08McRtf/sXBSmt5cc35pqamVQqFwhoZGallMpnU/fv3e7RaberVq1d/AABAn1IfQqfTNRs3blQB\n",
+       "AFy+fJk7Nja2XCKRnD3dNSorusPq6NfTPR+gPiEEoLRFXO1tS2+zavv27ReftjNttyr0S1/j0rUP\n",
+       "PEJQwNwQYGgAACQSyXmNRhMtk8lYAAApKSlKDMP0+fn5QU4ACIKkxMfH1zjYuHnz5uspKSlOfdX7\n",
+       "u68fvOePcCzKQR4YVCgATGfa/F3pnzaHWOAXSDyaMCqH2+r8VXErP3D+snXr1tV2dXW94dATExOr\n",
+       "6XT6JgAAVCKRcDEMM4WHh9sAAHJyUqNu//wDymKx7AAAVVVVPiaTKXxByrYMvBsxEMSTwPXhuL+8\n",
+       "e/fu9fv371+flvbemogYNz+TnsBOFEwMFO8/KzEYDKFVVVX+AAChoaGT7u7ud48ePRro0DEMs+bl\n",
+       "5bFRNpud4O3tfdGBzq5uy/5wTUPM/q2zC9atmbVqeHg4Pi0t7WxGRoZFH5rw76I7LI8HqHfwPL7d\n",
+       "rfVagzw1NfW81t4ePUfsP/OrnWZ6fPSuUqFQSEkkkrOjo6OvuQR5q0ajiXLoPj4+lzgcTjwKACLH\n",
+       "9SqXy2kzhBO8haGo+UA2wZW+p880DxeveGt9aHx9fT09ctlq3sC0NT9e6xsbjuZblSxl7wKtVotM\n",
+       "m6PnXvlmZJBtX91CEMQsxyJsNlteXl4udugIghAajQYFAEhPTx9AEGQOimGY8y4oLt63KlJkdB4t\n",
+       "P282Z/c/dPrDH04ktJ9P2tfWXP3+2o1vHzunEp6Xq0lsGt08KzUrcSGTQ3n3XeefLCs5UqnT6Rap\n",
+       "VCoEACA7O/snvV4f5gJooLa2NsihoygKKEVRzquTND2OCpttGXdG1tOxwOlgzdvE9v30rV+m3W5I\n",
+       "2jfJNQmLH85QUUzPNTwvkAx0+vVGhq2/VV9fT+dyuZ01NTXOXQOA3fGxevXq2waDYY5r8KIoij5b\n",
+       "jzB5Cz2oKdOo0erOm+1tVuVtBMZXElNMRJR1fvvjx9iPLQ/RjpuB0Xu/Vp7YmH1864YNG3oNBkPw\n",
+       "VD7mzp1rJUnSzZUBmqsBggAgGFC/n6jVA+3WoN3tu1Gg39cg2tEx1Cg3CIJHsclxnl2HRorMN8Z0\n",
+       "fRW+vr7GJ36Q56Z5h9BIknzGAMJWtvdQYs0EZe3/FSwqk5tpXEMb1JoYD+n8xRdQJl/fMPEgzKhS\n",
+       "L40KCD7lGzg92qIyovpb3y/msT2un2psvFpWVvYyl8vtc1nDSXFXV5c7iqLOtEyS5LNBAADfWeKm\n",
+       "Ly4uuvR1++sfv51/P5sfnHm2/Iy+mBmwsaHJbpt+Q0jHSS7TZ/PSNVkNJ/973OxtemD1s91CPb12\n",
+       "h9MfvZsk5meo1eqo5ORkxTNWn7HR1tY2l8PhOAsUiqIolCRJcETtv/61qzNySYK5trZ2TCgUUiwW\n",
+       "S1FSUhLR+bA/kAzwXcAbHa/cFhrTXrJ/v+7IkSPu3Je4Xm5eboJv2wba5QbO5fQwxhsP679Y+nFO\n",
+       "jgAAoKSkJILFYjnBGI1G0YYNGwYBnqRoiqIQlKKojurq6gUAAAKBgKQoiuGYkJWVpTCZTOKmI1Xd\n",
+       "HwnDcm+cOnOMw+H0FxYWbqpvqv/r9EV+bky+O+/QoUPiqJRt9JphTLFHbKBCR87tWL9EPN9oNIZn\n",
+       "ZWUpXHaMCQQCEgCgsrIyEgBuoGq1+qpOp4t2GPH5/BvFxcVLHXpgYGDD8ePH/56Xl2cCAMjMzOxP\n",
+       "S0s7pWfow4RCbz/fAF9RT0+P9yeffHJySSqev+9nxLD1FaAlTR8vlJ8vxxzsFhUVLRMIBB0OvwaD\n",
+       "YRlFUdfQkpISK0EQ9J6eHgYAQEZGxl2z2Rw0MjJCBwBITk5+xOVyfzpw4ECSw5lQKKQIbxtJm4EN\n",
+       "8eZ7jPz0oNv+dK5FG/jq54eH+IFr/S1KabBy0UerAvI+++wzD4vFEpCWljYEACCTyVh2ux3FcXwS\n",
+       "BQCw2WxVdXV1bzrQRURE1FVVVTn1zMzM/pkzZ35/9OjRd0pLS19RqVQIy4/tCwDgOcPTQvFQEQBA\n",
+       "aWnpK0ERK2LbyVllN341GUJ4YDu8zD5bKyur7O+85tx9Z2fnO1ar9QjA04KkpaVFs2LFir8olcq7\n",
+       "YWFhJpFINNnX16drbGyMjY6Ovg0AIBaLjcuXL5d3d3d7XbhwIW704b3F479MeD1qVfJ5Og/bvb4R\n",
+       "LwaDMZabm9uwflNa/z/3HOIv5NsDEK7XS7FeevXPvYNLvm5S/GglCK5KpZorlUobXE8g5ObmMqVS\n",
+       "6UG1Wu1BURSHoijOiRMnwgoLC7coFAqBo+9Fm0KhEKStmvvto3TeucFN7pVJYbytarXaQyqVHsRx\n",
+       "3N15TF1BuBaljr4rV66wOzo63mAymXdzcnKuwwtIUVHRMqvVGkgQxMV7NXvyJijGvcNXB/7z5Zdf\n",
+       "bicI4gSO40NTAgD4bVnuODIAT2pElUq1FEEQO4fD6QsPD++fqixHEATj8/ntjoCrqKhwS0hIsJWV\n",
+       "leURBHEOx3G563pT3tn5+flBDAbjg6CgoMMpKSlK17GhoSFMJpMFPk04DJIkEQzDzCwW6+5UD5Oa\n",
+       "mhrfO3fufECS5GHXnf8pAAAAHMfdURTdimGYPjExsTo0NHTyj2ynEplMxurs7HyHIAiKJMlSHMct\n",
+       "U9k9N2vl5+cH0en0TRiGWX18fC65vnh+LxqNBq2oqFhgMpmi7XY7arVaj+zdu/fxn/l/4bSZl5fH\n",
+       "5nK5CQAQMtXznCRJePpEbwOAZhzHX4ix/wHzzC/tu64gcwAAAABJRU5ErkJggg=='\n",
+       "       style='height:15px; border-radius:12px; display: inline-block; float: left'></img>\n",
+       "  \n",
+       "\n",
+       "\n",
+       "</div>\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "import xarray as xr\n",
     "import numpy as np\n",
@@ -292,6 +909,323 @@
     "heatmap + heatmap.table()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Working with xarray data types\n",
+    "As demonstrated previously, `Dataset` comes with support for the `xarray` library, which offers a powerful way to work with multi-dimensional, regularly spaced data. In this example, we'll load an example dataset, turn it into a HoloViews `Dataset` and visualize it. First, let's have a look at the xarray dataset's contents:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<xarray.Dataset>\n",
+       "Dimensions:  (lat: 25, lon: 53, time: 2920)\n",
+       "Coordinates:\n",
+       "  * lat      (lat) float32 75.0 72.5 70.0 67.5 65.0 62.5 60.0 57.5 55.0 52.5 ...\n",
+       "  * lon      (lon) float32 200.0 202.5 205.0 207.5 210.0 212.5 215.0 217.5 ...\n",
+       "  * time     (time) datetime64[ns] 2013-01-01 2013-01-01T06:00:00 ...\n",
+       "Data variables:\n",
+       "    air      (time, lat, lon) float32 241.2 242.5 243.5 244.0 244.09999 ...\n",
+       "Attributes:\n",
+       "    Conventions:  COARDS\n",
+       "    title:        4x daily NMC reanalysis (1948)\n",
+       "    description:  Data is from NMC initialized reanalysis\\n(4x/day).  These a...\n",
+       "    platform:     Model\n",
+       "    references:   http://www.esrl.noaa.gov/psd/data/gridded/data.ncep.reanaly..."
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "xr_ds = xr.tutorial.load_dataset(\"air_temperature\")\n",
+    "xr_ds"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "It is trivial to turn this xarray Dataset into a Holoviews `Dataset` (the same also works for DataArray):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      ":Dataset   [lat,lon,time]   (air)\n"
+     ]
+    }
+   ],
+   "source": [
+    "hv_ds = hv.Dataset(xr_ds)[:, :, \"2013-01-01\"]\n",
+    "print(hv_ds)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We have used the usual slice notation in order to select one single day in the rather large dataset. Finally, let's visualize the dataset by converting it to a `HoloMap` of `Images` using the `to()` method. We need to specify which of the dataset's key dimensions will be consumed by the images (in this case \"lat\" and \"lon\"), where the remaing key dimensions will be associated with the HoloMap (here: \"time\"). We'll use the slice notation again to clip the longitude."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div class=\"hololayout row row-fluid\">\n",
+       "  <div class=\"holoframe\" id=\"display_areac9932301a366416cb159d1c02a207ba5\">\n",
+       "    <div id=\"_anim_imgc9932301a366416cb159d1c02a207ba5\">\n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    </div>\n",
+       "  </div>\n",
+       "  <div class=\"holowidgets\" id=\"widget_areac9932301a366416cb159d1c02a207ba5\">\n",
+       "    <form class=\"holoform well\" id=\"formc9932301a366416cb159d1c02a207ba5\">\n",
+       "      \n",
+       "      \n",
+       "      <div class=\"form-group control-group holoformgroup\" style=''>\n",
+       "        <label for=\"textInputc9932301a366416cb159d1c02a207ba5_Time\">\n",
+       "          <strong>Time:</strong>\n",
+       "        </label>\n",
+       "        <div class=\"holowell row row-fluid\">\n",
+       "          <div class=\"hologroup\">\n",
+       "            <input type=\"text\" class=\"holotext form-control input-small\"\n",
+       "                   id=\"textInputc9932301a366416cb159d1c02a207ba5_Time\" value=\"\" readonly>\n",
+       "          </div>\n",
+       "          <div class=\"holoslider\"\n",
+       "               id=\"_anim_widgetc9932301a366416cb159d1c02a207ba5_Time\"></div>\n",
+       "        </div>\n",
+       "      </div>\n",
+       "\t  <script>\n",
+       "\t    function init_slider() {\n",
+       "        // Slider JS Block START\n",
+       "        function loadcssfile(filename){\n",
+       "            var fileref=document.createElement(\"link\")\n",
+       "            fileref.setAttribute(\"rel\", \"stylesheet\")\n",
+       "            fileref.setAttribute(\"type\", \"text/css\")\n",
+       "            fileref.setAttribute(\"href\", filename)\n",
+       "            document.getElementsByTagName(\"head\")[0].appendChild(fileref)\n",
+       "        }\n",
+       "        loadcssfile(\"https://code.jquery.com/ui/1.10.4/themes/smoothness/jquery-ui.css\");\n",
+       "        /* Check if jQuery and jQueryUI have been loaded\n",
+       "           otherwise load with require.js */\n",
+       "        var jQuery = window.jQuery,\n",
+       "            // check for old versions of jQuery\n",
+       "            oldjQuery = jQuery && !!jQuery.fn.jquery.match(/^1\\.[0-4](\\.|$)/),\n",
+       "            jquery_path = '',\n",
+       "            paths = {},\n",
+       "            noConflict;\n",
+       "        var jQueryUI = jQuery.ui;\n",
+       "        // check for jQuery\n",
+       "        if (!jQuery || oldjQuery) {\n",
+       "            // load if it's not available or doesn't meet min standards\n",
+       "            paths.jQuery = jQuery;\n",
+       "            noConflict = !!oldjQuery;\n",
+       "        } else {\n",
+       "            // register the current jQuery\n",
+       "            define('jquery', [], function() { return jQuery; });\n",
+       "        }\n",
+       "        if (!jQueryUI) {\n",
+       "            paths.jQueryUI = \"https://code.jquery.com/ui/1.10.4/jquery-ui.min\"\n",
+       "        } else {\n",
+       "            define('jQueryUI', [], function() { return jQuery.ui; });\n",
+       "        }\n",
+       "        paths.underscore = \"https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.8.3/underscore-min\";\n",
+       "        var jquery_require = {\n",
+       "            paths: paths,\n",
+       "            shim: {\n",
+       "                \"jQueryUI\": {\n",
+       "                    exports:\"$\",\n",
+       "                    deps: ['jquery']\n",
+       "                },\n",
+       "                \"underscore\": {\n",
+       "                    exports: '_'\n",
+       "                }\n",
+       "            }\n",
+       "        }\n",
+       "        require.config(jquery_require);\n",
+       "        require([\"jQueryUI\", \"underscore\"], function(jUI, _){\n",
+       "            if (noConflict) $.noConflict(true);\n",
+       "            var vals = ['2013-01-01T00:00:00.000000000', '2013-01-01T06:00:00.000000000', '2013-01-01T12:00:00.000000000', '2013-01-01T18:00:00.000000000'];\n",
+       "            var next_vals = {};\n",
+       "            if (false && vals.constructor === Array) {\n",
+       "                var min = parseFloat(vals[0]);\n",
+       "                var max = parseFloat(vals[vals.length-1]);\n",
+       "                var step = 1;\n",
+       "                var labels = [min];\n",
+       "            } else {\n",
+       "                var min = 0;\n",
+       "                if (false) {\n",
+       "                    var max = Object.keys(vals).length - 1;\n",
+       "                } else {\n",
+       "                    var max = vals.length - 1;\n",
+       "                }\n",
+       "                var step = 1;\n",
+       "\t\t\t\tvar labels = ['2013-01-01 00:00:00', '2013-01-01 06:00:00', '2013-01-01 12:00:00', '2013-01-01 18:00:00'];\n",
+       "            }\n",
+       "\t\t\tfunction adjustFontSize(text) {\n",
+       "\t\t\t\tvar width_ratio = (text.parent().width()/8)/text.val().length;\n",
+       "\t\t\t\tvar size = Math.min(0.9, Math.max(0.6, width_ratio))+'em';\n",
+       "\t\t\t\ttext.css('font-size', size);\n",
+       "\t\t\t}\n",
+       "            var slider = $('#_anim_widgetc9932301a366416cb159d1c02a207ba5_Time');\n",
+       "\t\t\tslider.slider({\n",
+       "                animate: \"fast\",\n",
+       "                min: min,\n",
+       "                max: max,\n",
+       "                step: step,\n",
+       "                value: min,\n",
+       "                dim_vals: vals,\n",
+       "                dim_labels: labels,\n",
+       "                next_vals: next_vals,\n",
+       "                slide: function(event, ui) {\n",
+       "                    var vals = slider.slider(\"option\", \"dim_vals\");\n",
+       "                    var next_vals = slider.slider(\"option\", \"next_vals\");\n",
+       "                    var labels = slider.slider(\"option\", \"dim_labels\");\n",
+       "                    if (false) {\n",
+       "\t\t\t\t\t    var dim_val = ui.value;\n",
+       "\t\t\t\t\t    if (vals.constructor === Array) {\n",
+       "\t\t\t\t\t\t   var label = ui.value;\n",
+       "\t\t\t\t\t\t} else {\n",
+       "\t\t\t\t\t\t   var label = labels[ui.value];\n",
+       "\t\t\t\t\t\t}\n",
+       "                    } else {\n",
+       "                        var dim_val = vals[ui.value];\n",
+       "\t\t\t\t\t\tvar label = labels[ui.value];\n",
+       "                    }\n",
+       "\t\t\t\t\tvar text = $('#textInputc9932301a366416cb159d1c02a207ba5_Time');\n",
+       "\t\t\t\t\ttext.val(label);\n",
+       "\t\t\t\t\tadjustFontSize(text);\n",
+       "                    animc9932301a366416cb159d1c02a207ba5.set_frame(dim_val, 0);\n",
+       "                    if (Object.keys(next_vals).length > 0) {\n",
+       "                        var new_vals = next_vals[dim_val];\n",
+       "                        var next_widget = $('#_anim_widgetc9932301a366416cb159d1c02a207ba5_');\n",
+       "                        update_widget(next_widget, new_vals);\n",
+       "                    }\n",
+       "                }\n",
+       "            });\n",
+       "            slider.keypress(function(event) {\n",
+       "                if (event.which == 80 || event.which == 112) {\n",
+       "                    var start = slider.slider(\"option\", \"value\");\n",
+       "                    var stop =  slider.slider(\"option\", \"max\");\n",
+       "                    for (var i=start; i<=stop; i++) {\n",
+       "                        var delay = i*50;\n",
+       "                        $.proxy(function doSetTimeout(i) { setTimeout($.proxy(function() {\n",
+       "                            var val = {value:i};\n",
+       "                            slider.slider('value',i);\n",
+       "                            slider.slider(\"option\", \"slide\")(null, val);\n",
+       "                        }, slider), delay);}, slider)(i);\n",
+       "                    }\n",
+       "                }\n",
+       "                if (event.which == 82 || event.which == 114) {\n",
+       "                    var start = slider.slider(\"option\", \"value\");\n",
+       "                    var stop =  slider.slider(\"option\", \"min\");\n",
+       "                    var count = 0;\n",
+       "                    for (var i=start; i>=stop; i--) {\n",
+       "                        var delay = count*50;\n",
+       "                        count = count + 1;\n",
+       "                        $.proxy(function doSetTimeout(i) { setTimeout($.proxy(function() {\n",
+       "                            var val = {value:i};\n",
+       "                            slider.slider('value',i);\n",
+       "                            slider.slider(\"option\", \"slide\")(null, val);\n",
+       "                        }, slider), delay);}, slider)(i);\n",
+       "                    }\n",
+       "                }\n",
+       "            });\n",
+       "\t\t\tvar textInput = $('#textInputc9932301a366416cb159d1c02a207ba5_Time')\n",
+       "\t\t\ttextInput.val(labels[0]);\n",
+       "\t\t\tadjustFontSize(textInput);\n",
+       "        });\n",
+       "\t\t}\n",
+       "        $(document).ready(init_slider)\n",
+       "        // Slider JS Block END\n",
+       "        </script>\n",
+       "        \n",
+       "        \n",
+       "        </form>\n",
+       "    </div>\n",
+       "</div>\n",
+       "\n",
+       "\n",
+       "<script language=\"javascript\">\n",
+       "/* Instantiate the MPLSelectionWidget class. */\n",
+       "/* The IDs given should match those used in the template above. */\n",
+       "(function() {\n",
+       "\tif (jQuery.ui !== undefined) {\n",
+       "\t\t$(\"#display_areac9932301a366416cb159d1c02a207ba5\").resizable({\n",
+       "\t\t\tresize: function(event, ui) {\n",
+       "\t\t\t\t$(\"#widget_areac9932301a366416cb159d1c02a207ba5\").width($(this).parent().width()-ui.size.width);\n",
+       "\t\t\t}\n",
+       "\t\t});\n",
+       "\t\t$(\"#widget_areac9932301a366416cb159d1c02a207ba5\").resizable();\n",
+       "\t}\n",
+       "    var widget_ids = new Array(1);\n",
+       "    \n",
+       "    widget_ids[0] = \"_anim_widgetc9932301a366416cb159d1c02a207ba5_Time\";\n",
+       "    \n",
+       "    var frame_data = {\"0\": \"<img src='data:image/png;base64,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' style='max-width:100%; margin: auto; display: block; '/>\", \"1\": \"<img src='data:image/png;base64,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' style='max-width:100%; margin: auto; display: block; '/>\", \"2\": \"<img src='data:image/png;base64,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' style='max-width:100%; margin: auto; display: block; '/>\", \"3\": \"<img src='data:image/png;base64,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' style='max-width:100%; margin: auto; display: block; '/>\"};\n",
+       "    var dim_vals = ['2013-01-01T00:00:00.000000000'];\n",
+       "    var keyMap = {\"('2013-01-01T00:00:00.000000000',)\": 0, \"('2013-01-01T06:00:00.000000000',)\": 1, \"('2013-01-01T12:00:00.000000000',)\": 2, \"('2013-01-01T18:00:00.000000000',)\": 3};\n",
+       "    var notFound = \"<h2 style='vertical-align: middle>No frame at selected dimension value.<h2>\";\n",
+       "    function create_widget() {\n",
+       "        setTimeout(function() {\n",
+       "            animc9932301a366416cb159d1c02a207ba5 = new MPLSelectionWidget(frame_data, \"c9932301a366416cb159d1c02a207ba5\", widget_ids,\n",
+       "\t\t\t\tkeyMap, dim_vals, notFound, false, \"default\",\n",
+       "\t\t\t\ttrue, \"./json_figures/\", false);\n",
+       "        }, 0);\n",
+       "    }\n",
+       "    \n",
+       "    create_widget();\n",
+       "    \n",
+       "})();\n",
+       "</script>"
+      ],
+      "text/plain": [
+       ":HoloMap   [time]\n",
+       "   :Image   [lon,lat]   (air)"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%%opts Image [colorbar=True]\n",
+    "%%output size=200\n",
+    "hv_ds.to(hv.Image, kdims=[\"lon\", \"lat\"])[:, 220:320, :]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Note, that this approach immediately converts all available data to images, which will take up a lot of RAM for large datasets. For these situations, consider using a [DynamicMap](./06-Live_Data.ipynb) in conjunction with [xarray's dask support](http://xarray.pydata.org/en/stable/dask.html) instead.\n",
+    "\n",
+    "Additional examples of visualizing xarrays in the context of geographical data can be found in the GeoViews documentation: [Gridded Datasets I](http://geo.holoviews.org/Gridded_Datasets_I.html) and\n",
+    "[Gridded Datasets II](http://geo.holoviews.org/Gridded_Datasets_II.html). These guides also contain useful information on the interaction between xarray data structures and HoloViews Datasets in general."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -399,9 +1333,22 @@
   }
  ],
  "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",
-   "pygments_lexer": "ipython3"
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.4"
   }
  },
  "nbformat": 4,

From 5f6c7d3fb5090db0fdca1b301b02f935b95302d3 Mon Sep 17 00:00:00 2001
From: drs251 <danrstephan@gmail.com>
Date: Thu, 15 Mar 2018 02:52:14 +0100
Subject: [PATCH 3/4] Cleared notebook outputs

---
 examples/user_guide/08-Gridded_Datasets.ipynb | 887 +-----------------
 1 file changed, 8 insertions(+), 879 deletions(-)

diff --git a/examples/user_guide/08-Gridded_Datasets.ipynb b/examples/user_guide/08-Gridded_Datasets.ipynb
index cc7dc9cf30..e9b6f60dbe 100644
--- a/examples/user_guide/08-Gridded_Datasets.ipynb
+++ b/examples/user_guide/08-Gridded_Datasets.ipynb
@@ -9,626 +9,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
-   "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.comms = {};\n",
-       "HoloViewsWidget.comm_state = {};\n",
-       "\n",
-       "HoloViewsWidget.prototype.init_slider = function(init_val){\n",
-       "  if(this.load_json) {\n",
-       "    this.from_json()\n",
-       "  } else {\n",
-       "    this.update_cache();\n",
-       "  }\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",
-       "  var data_url = this.json_path + this.id + '.json';\n",
-       "  $.getJSON(data_url, $.proxy(function(json_data) {\n",
-       "    this.frames = json_data;\n",
-       "    this.update_cache();\n",
-       "    this.update(0);\n",
-       "  }, this));\n",
-       "}\n",
-       "\n",
-       "HoloViewsWidget.prototype.dynamic_update = function(current){\n",
-       "  if (current === undefined) {\n",
-       "    return\n",
-       "  }\n",
-       "  if(this.dynamic) {\n",
-       "    current = JSON.stringify(current);\n",
-       "  }\n",
-       "  function callback(initialized, msg){\n",
-       "    /* This callback receives data from Python as a string\n",
-       "       in order to parse it correctly quotes are sliced off*/\n",
-       "    if (msg.content.ename != undefined) {\n",
-       "      this.process_error(msg);\n",
-       "    }\n",
-       "    if (msg.msg_type != \"execute_result\") {\n",
-       "      console.log(\"Warning: HoloViews callback returned unexpected data for key: (\", current, \") with the following content:\", msg.content)\n",
-       "    } else {\n",
-       "      if (msg.content.data['text/plain'].includes('Complete')) {\n",
-       "        if (this.queue.length > 0) {\n",
-       "          this.time = Date.now();\n",
-       "          this.dynamic_update(this.queue[this.queue.length-1]);\n",
-       "          this.queue = [];\n",
-       "        } else {\n",
-       "          this.wait = false;\n",
-       "        }\n",
-       "        return\n",
-       "      }\n",
-       "    }\n",
-       "  }\n",
-       "  this.current = current;\n",
-       "  if ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null)) {\n",
-       "    var kernel = Jupyter.notebook.kernel;\n",
-       "    callbacks = {iopub: {output: $.proxy(callback, this, this.initialized)}};\n",
-       "    var cmd = \"holoviews.plotting.widgets.NdWidget.widgets['\" + this.id + \"'].update(\" + current + \")\";\n",
-       "    kernel.execute(\"import holoviews;\" + cmd, callbacks, {silent : false});\n",
-       "  }\n",
-       "}\n",
-       "\n",
-       "HoloViewsWidget.prototype.update_cache = function(force){\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) || force) {\n",
-       "      if ((frame in this.cache) && force) { this.cache[frame].remove() }\n",
-       "      this.cache[frame] = $('<div />').appendTo(\"#\"+\"_anim_img\"+this.id).hide();\n",
-       "      var cache_id = \"_anim_img\"+this.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",
-       "    this.wait = false;\n",
-       "  }\n",
-       "}\n",
-       "\n",
-       "HoloViewsWidget.prototype.init_comms = function() {\n",
-       "  if ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel !== undefined)) {\n",
-       "    var widget = this;\n",
-       "    comm_manager = Jupyter.notebook.kernel.comm_manager;\n",
-       "    comm_manager.register_target(this.id, function (comm) {\n",
-       "      comm.on_msg(function (msg) { widget.process_msg(msg) });\n",
-       "    });\n",
-       "  }\n",
-       "}\n",
-       "\n",
-       "HoloViewsWidget.prototype.process_msg = function(msg) {\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.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",
-       "  this.json_path = json_path;\n",
-       "  this.init_slider(this.current_vals[0]);\n",
-       "  this.queue = [];\n",
-       "  this.wait = false;\n",
-       "  if (!this.cached || this.dynamic) {\n",
-       "    this.init_comms()\n",
-       "  }\n",
-       "}\n",
-       "\n",
-       "SelectionWidget.prototype = new HoloViewsWidget;\n",
-       "\n",
-       "\n",
-       "SelectionWidget.prototype.get_key = function(current_vals) {\n",
-       "  var 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) { val = val.toFixed(1); }\n",
-       "      else { val = val.toFixed(10); val = val.slice(0, val.length-1);}\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",
-       "  return this.keyMap[key];\n",
-       "}\n",
-       "\n",
-       "SelectionWidget.prototype.set_frame = function(dim_val, dim_idx){\n",
-       "  this.current_vals[dim_idx] = dim_val;\n",
-       "  var key = this.current_vals;\n",
-       "  if (!this.dynamic) {\n",
-       "    key = this.get_key(key)\n",
-       "  }\n",
-       "  if (this.dynamic || !this.cached) {\n",
-       "    if ((this.time !== undefined) && ((this.wait) && ((this.time + 10000) > Date.now()))) {\n",
-       "      this.queue.push(key);\n",
-       "      return\n",
-       "    }\n",
-       "    this.queue = [];\n",
-       "    this.time = Date.now();\n",
-       "    this.current_frame = key;\n",
-       "    this.wait = true;\n",
-       "    this.dynamic_update(key)\n",
-       "  } else if (key !== undefined) {\n",
-       "    this.update(key)\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.slider_id = \"_anim_slider\" + id;\n",
-       "  this.loop_select_id = \"_anim_loop_select\" + id;\n",
-       "  this.id = 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",
-       "  this.json_path = json_path;\n",
-       "  document.getElementById(this.slider_id).max = this.length - 1;\n",
-       "  this.init_slider(0);\n",
-       "  this.wait = false;\n",
-       "  this.queue = [];\n",
-       "  if (!this.cached || this.dynamic) {\n",
-       "    this.init_comms()\n",
-       "  }\n",
-       "}\n",
-       "\n",
-       "ScrubberWidget.prototype = new HoloViewsWidget;\n",
-       "\n",
-       "ScrubberWidget.prototype.set_frame = function(frame){\n",
-       "  this.current_frame = frame;\n",
-       "  widget = 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.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",
-       "  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 - 1){\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",
-       "  if(this.current_frame > 0){\n",
-       "    this.previous_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",
-       "  if (widget.hasClass(\"ui-slider\")) {\n",
-       "    widget.slider('option', {\n",
-       "      min: 0,\n",
-       "      max: values.length-1,\n",
-       "      dim_vals: values,\n",
-       "      value: 0,\n",
-       "      dim_labels: values\n",
-       "\t})\n",
-       "    widget.slider('option', 'slide').call(widget, event, {value: 0})\n",
-       "  } else {\n",
-       "    widget.empty();\n",
-       "    for (var i=0; i<values.length; i++){\n",
-       "      widget.append($(\"<option>\", {\n",
-       "        value: i,\n",
-       "        text: values[i]\n",
-       "      }))\n",
-       "    };\n",
-       "    widget.data('values', values);\n",
-       "    widget.data('value', 0);\n",
-       "    widget.trigger(\"change\");\n",
-       "  };\n",
-       "}\n",
-       "\n",
-       "// Define MPL specific subclasses\n",
-       "function MPLSelectionWidget() {\n",
-       "    SelectionWidget.apply(this, arguments);\n",
-       "}\n",
-       "\n",
-       "function MPLScrubberWidget() {\n",
-       "    ScrubberWidget.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",
-       "    init_slider : function(init_val){\n",
-       "        if(this.load_json) {\n",
-       "            this.from_json()\n",
-       "        } else {\n",
-       "            this.update_cache();\n",
-       "        }\n",
-       "        this.update(0);\n",
-       "        if(this.mode == 'nbagg') {\n",
-       "            this.set_frame(init_val, 0);\n",
-       "        }\n",
-       "    },\n",
-       "    populate_cache : function(idx){\n",
-       "        var cache_id = \"_anim_img\"+this.id+\"_\"+idx;\n",
-       "        this.cache[idx].html(this.frames[idx]);\n",
-       "        if (this.embed) {\n",
-       "            delete this.frames[idx];\n",
-       "        }\n",
-       "    },\n",
-       "    process_msg : function(msg) {\n",
-       "        if (!(this.mode == 'nbagg')) {\n",
-       "            var data = msg.content.data;\n",
-       "            this.frames[this.current] = data;\n",
-       "            this.update_cache(true);\n",
-       "            this.update(this.current);\n",
-       "        }\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 class=\"logo-block\">\n",
-       "<img src='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n",
-       "AAAB+wAAAfsBxc2miwAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAA6zSURB\n",
-       "VHic7ZtpeFRVmsf/5966taWqUlUJ2UioBBJiIBAwCZtog9IOgjqACsogKtqirT2ttt069nQ/zDzt\n",
-       "tI4+CrJIREFaFgWhBXpUNhHZQoKBkIUASchWla1S+3ar7r1nPkDaCAnZKoQP/D7mnPOe9/xy76n3\n",
-       "nFSAW9ziFoPFNED2LLK5wcyBDObkb8ZkxuaoSYlI6ZcOKq1eWFdedqNzGHQBk9RMEwFAASkk0Xw3\n",
-       "ETacDNi2vtvc7L0ROdw0AjoSotQVkKSvHQz/wRO1lScGModBFbDMaNRN1A4tUBCS3lk7BWhQkgpD\n",
-       "lG4852/+7DWr1R3uHAZVQDsbh6ZPN7CyxUrCzJMRouusj0ipRwD2uKm0Zn5d2dFwzX1TCGhnmdGo\n",
-       "G62Nna+isiUqhkzuKrkQaJlPEv5mFl2fvGg2t/VnzkEV8F5ioioOEWkLG86fvbpthynjdhXYZziQ\n",
-       "x1hC9J2NFyi8vCTt91Fh04KGip0AaG9zuCk2wQCVyoNU3Hjezee9bq92duzzTmxsRJoy+jEZZZYo\n",
-       "GTKJ6SJngdJqAfRzpze0+jHreUtPc7gpBLQnIYK6BYp/uGhw9YK688eu7v95ysgshcg9qSLMo3JC\n",
-       "4jqLKQFBgdKDPoQ+Pltb8dUyQLpeDjeVgI6EgLIQFT5tEl3rn2losHVsexbZ3EyT9wE1uGdkIPcy\n",
-       "BGxn8QUq1QrA5nqW5i2tLqvrrM9NK6AdkVIvL9E9bZL/oyfMVd/jqvc8LylzRBKDJSzIExwhQzuL\n",
-       "QYGQj4rHfFTc8mUdu3E7yoLtbTe9gI4EqVgVkug2i5+uXGo919ixbRog+3fTbQ8qJe4ZOYNfMoTI\n",
-       "OoshUNosgO60AisX15aeI2PSIp5KiFLI9ubb1vV3Qb2ltwLakUCDAkWX7/nHKRmmGIl9VgYsUhJm\n",
-       "2NXjKYADtM1ygne9QQDIXlk49FBstMKx66D1v4+XuQr7vqTe0VcBHQlRWiOCbmmSYe2SqtL6q5rJ\n",
-       "zsTb7lKx3FKOYC4DoqyS/B5bvLPxvD9Qtf6saxYLQGJErmDOdOMr/zo96km1nElr8bmPOBwI9COv\n",
-       "HnFPRIwmkSOv9kcAS4heRsidOkpeWBgZM+UBrTFAXNYL5Vf2ii9c1trNzpYdaoVil3WIc+wdk+gQ\n",
-       "noie3ecCcxt9ITcLAPWt/laGEO/9U6PmzZkenTtsSMQ8uYywJVW+grCstAvCIaAdArAsIWkRDDs/\n",
-       "KzLm2YcjY1Lv0UdW73HabE9n6V66cxSzfEmuJssTpKGVp+0vHq73FwL46eOjpMpbRAnNmJFrGJNu\n",
-       "Ukf9Yrz+3rghiumCKNXXWPhLYcjxGsIpoCMsIRoFITkW8AuyM8jC1+/QLx4bozCEJIq38+1rtpR6\n",
-       "V/yzb8eBlRb3fo5l783N0CWolAzJHaVNzkrTzlEp2bQ2q3TC5gn6wpnoQAmwSiGh2GitnTmVMc5O\n",
-       "UyfKWUKCIsU7+fZDKwqdT6DDpvkzAX4/+AMFjk0tDp5GRXLpQ2MUmhgDp5gxQT8+Y7hyPsMi8uxF\n",
-       "71H0oebujHALECjFKaW9Lm68n18wXp2kVzIcABytD5iXFzg+WVXkegpAsOOYziqo0OkK76GyquC3\n",
-       "ltZAzMhhqlSNmmWTE5T6e3IN05ITFLM4GdN0vtZ3ob8Jh1NAKXFbm5PtLU/eqTSlGjkNAJjdgn/N\n",
-       "aedXa0tdi7+t9G0FIF49rtMSEgAs1kDLkTPO7ebm4IUWeyh1bKomXqlgMG6kJmHcSM0clYLJ8XtR\n",
-       "1GTnbV3F6I5wCGikAb402npp1h1s7LQUZZSMIfALFOuL3UUrfnS8+rez7v9qcold5tilgHbO1fjK\n",
-       "9ubb17u9oshxzMiUBKXWqJNxd+fqb0tLVs4lILFnK71H0Ind7uiPgACVcFJlrb0tV6DzxqqTIhUM\n",
-       "CwDf1/rrVhTa33/3pGPxJYdQ2l2cbgVcQSosdx8uqnDtbGjh9SlDVSMNWhlnilfqZk42Th2ZpLpf\n",
-       "xrHec5e815zrr0dfBZSwzkZfqsv+1FS1KUknUwPARVvItfKUY+cn57yP7qv07UE3p8B2uhUwLk09\n",
-       "e0SCOrK+hbdYHYLjRIl71wWzv9jpEoeOHhGRrJAzyEyNiJuUqX0g2sBN5kGK6y2Blp5M3lsB9Qh4\n",
-       "y2Ja6x6+i0ucmKgwMATwhSjdUu49tKrQ/pvN5d53ml2CGwCmJipmKjgmyuaXzNeL2a0AkQ01Th5j\n",
-       "2DktO3Jyk8f9vcOBQHV94OK+fPumJmvQHxJoWkaKWq9Vs+yUsbq0zGT1I4RgeH2b5wef7+c7bl8F\n",
-       "eKgoHVVZa8ZPEORzR6sT1BzDUAD/d9F78e2Tzv99v8D+fLVTqAKAsbGamKey1Mt9Ann4eH3gTXTz\n",
-       "idWtAJ8PQWOk7NzSeQn/OTHDuEikVF1R4z8BQCy+6D1aWRfY0tTGG2OM8rRoPaeIj5ZHzJxszElN\n",
-       "VM8K8JS5WOfv8mzRnQAKoEhmt8gyPM4lU9SmBK1MCQBnW4KONT86v1hZ1PbwSXPw4JWussVjtH9Y\n",
-       "NCoiL9UoH/6PSu8jFrfY2t36erQHXLIEakMi1SydmzB31h3GGXFDFNPaK8Rme9B79Ixrd0WN+1ij\n",
-       "NRQ/doRmuFLBkHSTOm5GruG+pFjFdAmorG4IXH1Qua6ASniclfFtDYt+oUjKipPrCQB7QBQ2lrgP\n",
-       "fFzm+9XWUtcqJ3/5vDLDpJ79XHZk3u8nGZ42qlj1+ydtbxysCezrydp6ugmipNJ7WBPB5tydY0jP\n",
-       "HaVNzs3QzeE4ZpTbI+ZbnSFPbVOw9vsfnVvqWnirPyCNGD08IlqtYkh2hjZ5dErEQzoNm+6ykyOt\n",
-       "Lt5/PQEuSRRKo22VkydK+vvS1XEKlhCJAnsqvcVvH7f/ZU2R67eXbMEGAMiIV5oWZWiWvz5Fv2xG\n",
-       "sjqNJQRvn3Rs2lji/lNP19VjAQDgD7FHhujZB9OGqYxRkZxixgRDVlqS6uEOFaJUVu0rPFzctrnF\n",
-       "JqijImVp8dEKVWyUXDk92zAuMZ6bFwpBU1HrOw6AdhQgUooChb0+ItMbWJitSo5Ws3IAOGEOtL53\n",
-       "0vHZih9sC4vtofZ7Qu6523V/fmGcds1TY3V36pUsBwAbSlxnVh2xLfAD/IAIMDf7XYIkNmXfpp2l\n",
-       "18rkAJAy9HKFaIr/qULkeQQKy9zf1JgDB2uaeFNGijo5QsUyacNUUTOnGO42xSnv4oOwpDi1zYkc\n",
-       "efUc3I5Gk6PhyTuVKaOGyLUAYPGIoY9Pu/atL/L92+4q9wbflRJ2Trpm/jPjdBtfnqB/dIThcl8A\n",
-       "KG7hbRuKnb8qsQsVvVlTrwQAQMUlf3kwJI24Z4JhPMtcfng5GcH49GsrxJpGvvHIaeem2ma+KSjQ\n",
-       "lIwUdYyCY8j4dE1KzijNnIP2llF2wcXNnsoapw9XxsgYAl6k+KzUXbi2yP3KR2ecf6z3BFsBICdW\n",
-       "nvnIaG3eHybqX7vbpEqUMT+9OL4Qpe8VON7dXuFd39v19FoAABRVePbGGuXTszO0P7tu6lghUonE\n",
-       "llRdrhArLvmKdh9u29jcFiRRkfLUxBiFNiqSU9icoZQHo5mYBI1MBgBH6wMNb+U7Pnw337H4gi1Y\n",
-       "ciWs+uks3Z9fztUvfzxTm9Ne8XXkvQLHNytOOZeiD4e0PgkAIAYCYknKUNUDSXEKzdWNpnil7r4p\n",
-       "xqkjTarZMtk/K8TQ6Qve78qqvXurGwIJqcOUKfUWHsm8KGvxSP68YudXq4pcj39X49uOK2X142O0\n",
-       "Tz5/u/7TVybqH0rSya6ZBwD21/gubbrgWdDgEOx9WUhfBaC2ibcEBYm7a7x+ukrBMNcEZggyR0TE\n",
-       "T8zUPjikQ4VosQZbTpS4vqizBKvqmvjsqnpfzaZyx9JPiz1/bfGKdgD45XB1zoIMzYbfTdS/NClB\n",
-       "Gct0USiY3YL/g0LHy/uq/Ef6uo5+n0R/vyhp17Klpge763f8rMu6YU/zrn2nml+2WtH+Z+5IAAFc\n",
-       "2bUTdTDOSNa9+cQY7YLsOIXhevEkCvzph7a8laecz/Un/z4/Ae04XeL3UQb57IwU9ZDr9UuKVajv\n",
-       "nxp1+1UVIo/LjztZkKH59fO3G/JemqCfmaCRqbqbd90ZZ8FfjtkfAyD0J/9+C2h1hDwsSxvGjNDc\n",
-       "b4zk5NfrSwiQblLHzZhg+Jf4aPlUwpDqkQqa9nimbt1/TDH8OitGMaQnj+RJS6B1fbF7SY1TqO5v\n",
-       "/v0WAADl1f7zokgS7s7VT2DZ7pegUjBM7mjtiDZbcN4j0YrHH0rXpCtY0qPX0cVL0rv5jv/ZXend\n",
-       "0u/EESYBAFBU4T4Qa5TflZOhTe7pmKpaP8kCVUVw1+yhXfJWvn1P3hnXi33JsTN6PnP3hHZ8Z3/h\n",
-       "aLHzmkNPuPj7Bc/F/Q38CwjTpSwQXgE4Vmwry9tpfq/ZFgqFMy4AVDtCvi8rvMvOmv0N4YwbVgEA\n",
-       "sPM72/KVnzfspmH7HQGCRLG2yL1+z8XwvPcdCbsAANh+xPzstgMtxeGKt+6MK3/tacfvwhWvIwMi\n",
-       "oKEBtm0H7W+UVfkc/Y1V0BhoPlDr/w1w/eu1vjIgAgDg22OtX6/eYfnEz/focrZTHAFR+PSs56/7\n",
-       "q32nwpjazxgwAQCwcU/T62t3WL7r6/jVRa6/byp1rei+Z98ZUAEAhEPHPc8fKnTU9nbgtnOe8h0l\n",
-       "9hcGIqmODLQAHCy2Xti6v/XNRivf43f4fFvIteu854+VHnR7q9tfBlwAAGz+pnndB9vM26UebAe8\n",
-       "SLHujPOTPVW+rwY+sxskAAC2HrA8t2Vvc7ffP1r9o+vwR2dcr92InIAbKKC1FZ5tB1tf+/G8p8sv\n",
-       "N/9Q5zd/XR34LYCwV5JdccMEAMDBk45DH243r/X4xGvqxFa/GNpS7n6rwOwNWwHVE26oAADYurf1\n",
-       "zx/utOzt+DMKYM0p17YtZZ5VNzqfsB2HewG1WXE8PoZ7gOclbTIvynZf9JV+fqZtfgs/8F/Nu5rB\n",
-       "EIBmJ+8QRMmpU7EzGRsf2FzuePqYRbzh/zE26EwdrT10f6r6o8HOYzCJB9Dpff8tbnGLG8L/A/WE\n",
-       "roTBs2RqAAAAAElFTkSuQmCC'\n",
-       "     style='height:25px; border-radius:12px; display: inline-block; float: left; vertical-align: middle'></img>\n",
-       "\n",
-       "\n",
-       "\n",
-       "\n",
-       "  <img src='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n",
-       "AAAFMAAABTABZarKtgAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAArNSURB\n",
-       "VFiFnVd5VFNXGv/ee0kgGyQhbFoXIKCFYEXEDVErTucMoKUOWA/VLsNSLPQgFTOdyrHPiIp1lFIQ\n",
-       "OlaPShEG3EpPcQmISCuV1bQ1CLKIULeQhJA9JO+9+UMT0x5aPfOdc895373f/e7v/t537/ddBF5Q\n",
-       "JBIJl81mJwCACEVRQBCEQhAEAQCgnghCURRCkmS7Wq2+WlJSYn0Rv8jzDHAcD0EQJIVGo5mFQuGF\n",
-       "jIyMu39kq1KpkOrq6gU6nS6aIAiGzWY7VVBQ0P9/AcjNzWXy+fxcOp2uiY+Przm0d6+n8dblv/Fo\n",
-       "kzM4SzYfPlRePvFnjnt6ehh1dXVv2mw2nlar/byoqMj8wgBwHBchCJIZEhJSeu1yHVi7vtu02t8+\n",
-       "NykQ7BMWoOUMhXQsXLv5IQAwSJJEEASxcDicoeTk5DtCoZBy9XX69Gnv3t7ebJIky3EcH3guAKlU\n",
-       "GoGiaOKWLVsOvhs7/9XXPMde3/IyIFbMnaPDuD5AUdQuOf2XlD0npTExMWYAgNbWVpZcLg8xGAzB\n",
-       "JEnSvby82tPT052LaTQatLy8fBtJkt/s3Lnz5h8CwHFcRKPRNu/YsePAjh072KTs0IGCxRg8RgUB\n",
-       "TGpSx6cmHgMAfNqN6Xa1GvJ/D35gYAAViURkcXHxUrPZHDRv3rxv4uLiDI7xPXv2bLdYLBUFBQWD\n",
-       "jj7M8ZGbm8tkMpmSrKysQiaTScXGxtpqL7dManT6tcu5mgEWWJyOhicozpk+c3NsbKzNFcBbWWEf\n",
-       "1Td9/upA30i3ZJv0h8bGxiSFQmFcuHDhOACAWCy+0d3dvX3lypUtzc3N9t8AiIuLk4SEhByLiooy\n",
-       "AgAcO3ZsNlPgH3Cttb35JZo+bCYXIQAA9MDiUW7sWS1KN687w6Mera2twa2trfMvXboUOS28Pyb1\n",
-       "U08McRtf/sXBSmt5cc35pqamVQqFwhoZGallMpnU/fv3e7RaberVq1d/AABAn1IfQqfTNRs3blQB\n",
-       "AFy+fJk7Nja2XCKRnD3dNSorusPq6NfTPR+gPiEEoLRFXO1tS2+zavv27ReftjNttyr0S1/j0rUP\n",
-       "PEJQwNwQYGgAACQSyXmNRhMtk8lYAAApKSlKDMP0+fn5QU4ACIKkxMfH1zjYuHnz5uspKSlOfdX7\n",
-       "u68fvOePcCzKQR4YVCgATGfa/F3pnzaHWOAXSDyaMCqH2+r8VXErP3D+snXr1tV2dXW94dATExOr\n",
-       "6XT6JgAAVCKRcDEMM4WHh9sAAHJyUqNu//wDymKx7AAAVVVVPiaTKXxByrYMvBsxEMSTwPXhuL+8\n",
-       "e/fu9fv371+flvbemogYNz+TnsBOFEwMFO8/KzEYDKFVVVX+AAChoaGT7u7ud48ePRro0DEMs+bl\n",
-       "5bFRNpud4O3tfdGBzq5uy/5wTUPM/q2zC9atmbVqeHg4Pi0t7WxGRoZFH5rw76I7LI8HqHfwPL7d\n",
-       "rfVagzw1NfW81t4ePUfsP/OrnWZ6fPSuUqFQSEkkkrOjo6OvuQR5q0ajiXLoPj4+lzgcTjwKACLH\n",
-       "9SqXy2kzhBO8haGo+UA2wZW+p880DxeveGt9aHx9fT09ctlq3sC0NT9e6xsbjuZblSxl7wKtVotM\n",
-       "m6PnXvlmZJBtX91CEMQsxyJsNlteXl4udugIghAajQYFAEhPTx9AEGQOimGY8y4oLt63KlJkdB4t\n",
-       "P282Z/c/dPrDH04ktJ9P2tfWXP3+2o1vHzunEp6Xq0lsGt08KzUrcSGTQ3n3XeefLCs5UqnT6Rap\n",
-       "VCoEACA7O/snvV4f5gJooLa2NsihoygKKEVRzquTND2OCpttGXdG1tOxwOlgzdvE9v30rV+m3W5I\n",
-       "2jfJNQmLH85QUUzPNTwvkAx0+vVGhq2/VV9fT+dyuZ01NTXOXQOA3fGxevXq2waDYY5r8KIoij5b\n",
-       "jzB5Cz2oKdOo0erOm+1tVuVtBMZXElNMRJR1fvvjx9iPLQ/RjpuB0Xu/Vp7YmH1864YNG3oNBkPw\n",
-       "VD7mzp1rJUnSzZUBmqsBggAgGFC/n6jVA+3WoN3tu1Gg39cg2tEx1Cg3CIJHsclxnl2HRorMN8Z0\n",
-       "fRW+vr7GJ36Q56Z5h9BIknzGAMJWtvdQYs0EZe3/FSwqk5tpXEMb1JoYD+n8xRdQJl/fMPEgzKhS\n",
-       "L40KCD7lGzg92qIyovpb3y/msT2un2psvFpWVvYyl8vtc1nDSXFXV5c7iqLOtEyS5LNBAADfWeKm\n",
-       "Ly4uuvR1++sfv51/P5sfnHm2/Iy+mBmwsaHJbpt+Q0jHSS7TZ/PSNVkNJ/973OxtemD1s91CPb12\n",
-       "h9MfvZsk5meo1eqo5ORkxTNWn7HR1tY2l8PhOAsUiqIolCRJcETtv/61qzNySYK5trZ2TCgUUiwW\n",
-       "S1FSUhLR+bA/kAzwXcAbHa/cFhrTXrJ/v+7IkSPu3Je4Xm5eboJv2wba5QbO5fQwxhsP679Y+nFO\n",
-       "jgAAoKSkJILFYjnBGI1G0YYNGwYBnqRoiqIQlKKojurq6gUAAAKBgKQoiuGYkJWVpTCZTOKmI1Xd\n",
-       "HwnDcm+cOnOMw+H0FxYWbqpvqv/r9EV+bky+O+/QoUPiqJRt9JphTLFHbKBCR87tWL9EPN9oNIZn\n",
-       "ZWUpXHaMCQQCEgCgsrIyEgBuoGq1+qpOp4t2GPH5/BvFxcVLHXpgYGDD8ePH/56Xl2cCAMjMzOxP\n",
-       "S0s7pWfow4RCbz/fAF9RT0+P9yeffHJySSqev+9nxLD1FaAlTR8vlJ8vxxzsFhUVLRMIBB0OvwaD\n",
-       "YRlFUdfQkpISK0EQ9J6eHgYAQEZGxl2z2Rw0MjJCBwBITk5+xOVyfzpw4ECSw5lQKKQIbxtJm4EN\n",
-       "8eZ7jPz0oNv+dK5FG/jq54eH+IFr/S1KabBy0UerAvI+++wzD4vFEpCWljYEACCTyVh2ux3FcXwS\n",
-       "BQCw2WxVdXV1bzrQRURE1FVVVTn1zMzM/pkzZ35/9OjRd0pLS19RqVQIy4/tCwDgOcPTQvFQEQBA\n",
-       "aWnpK0ERK2LbyVllN341GUJ4YDu8zD5bKyur7O+85tx9Z2fnO1ar9QjA04KkpaVFs2LFir8olcq7\n",
-       "YWFhJpFINNnX16drbGyMjY6Ovg0AIBaLjcuXL5d3d3d7XbhwIW704b3F479MeD1qVfJ5Og/bvb4R\n",
-       "LwaDMZabm9uwflNa/z/3HOIv5NsDEK7XS7FeevXPvYNLvm5S/GglCK5KpZorlUobXE8g5ObmMqVS\n",
-       "6UG1Wu1BURSHoijOiRMnwgoLC7coFAqBo+9Fm0KhEKStmvvto3TeucFN7pVJYbytarXaQyqVHsRx\n",
-       "3N15TF1BuBaljr4rV66wOzo63mAymXdzcnKuwwtIUVHRMqvVGkgQxMV7NXvyJijGvcNXB/7z5Zdf\n",
-       "bicI4gSO40NTAgD4bVnuODIAT2pElUq1FEEQO4fD6QsPD++fqixHEATj8/ntjoCrqKhwS0hIsJWV\n",
-       "leURBHEOx3G563pT3tn5+flBDAbjg6CgoMMpKSlK17GhoSFMJpMFPk04DJIkEQzDzCwW6+5UD5Oa\n",
-       "mhrfO3fufECS5GHXnf8pAAAAHMfdURTdimGYPjExsTo0NHTyj2ynEplMxurs7HyHIAiKJMlSHMct\n",
-       "U9k9N2vl5+cH0en0TRiGWX18fC65vnh+LxqNBq2oqFhgMpmi7XY7arVaj+zdu/fxn/l/4bSZl5fH\n",
-       "5nK5CQAQMtXznCRJePpEbwOAZhzHX4ix/wHzzC/tu64gcwAAAABJRU5ErkJggg=='\n",
-       "       style='height:15px; border-radius:12px; display: inline-block; float: left'></img>\n",
-       "  \n",
-       "\n",
-       "\n",
-       "</div>\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "import xarray as xr\n",
     "import numpy as np\n",
@@ -919,33 +302,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<xarray.Dataset>\n",
-       "Dimensions:  (lat: 25, lon: 53, time: 2920)\n",
-       "Coordinates:\n",
-       "  * lat      (lat) float32 75.0 72.5 70.0 67.5 65.0 62.5 60.0 57.5 55.0 52.5 ...\n",
-       "  * lon      (lon) float32 200.0 202.5 205.0 207.5 210.0 212.5 215.0 217.5 ...\n",
-       "  * time     (time) datetime64[ns] 2013-01-01 2013-01-01T06:00:00 ...\n",
-       "Data variables:\n",
-       "    air      (time, lat, lon) float32 241.2 242.5 243.5 244.0 244.09999 ...\n",
-       "Attributes:\n",
-       "    Conventions:  COARDS\n",
-       "    title:        4x daily NMC reanalysis (1948)\n",
-       "    description:  Data is from NMC initialized reanalysis\\n(4x/day).  These a...\n",
-       "    platform:     Model\n",
-       "    references:   http://www.esrl.noaa.gov/psd/data/gridded/data.ncep.reanaly..."
-      ]
-     },
-     "execution_count": 20,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "xr_ds = xr.tutorial.load_dataset(\"air_temperature\")\n",
     "xr_ds"
@@ -960,17 +319,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      ":Dataset   [lat,lon,time]   (air)\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "hv_ds = hv.Dataset(xr_ds)[:, :, \"2013-01-01\"]\n",
     "print(hv_ds)"
@@ -985,231 +336,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div class=\"hololayout row row-fluid\">\n",
-       "  <div class=\"holoframe\" id=\"display_areac9932301a366416cb159d1c02a207ba5\">\n",
-       "    <div id=\"_anim_imgc9932301a366416cb159d1c02a207ba5\">\n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    </div>\n",
-       "  </div>\n",
-       "  <div class=\"holowidgets\" id=\"widget_areac9932301a366416cb159d1c02a207ba5\">\n",
-       "    <form class=\"holoform well\" id=\"formc9932301a366416cb159d1c02a207ba5\">\n",
-       "      \n",
-       "      \n",
-       "      <div class=\"form-group control-group holoformgroup\" style=''>\n",
-       "        <label for=\"textInputc9932301a366416cb159d1c02a207ba5_Time\">\n",
-       "          <strong>Time:</strong>\n",
-       "        </label>\n",
-       "        <div class=\"holowell row row-fluid\">\n",
-       "          <div class=\"hologroup\">\n",
-       "            <input type=\"text\" class=\"holotext form-control input-small\"\n",
-       "                   id=\"textInputc9932301a366416cb159d1c02a207ba5_Time\" value=\"\" readonly>\n",
-       "          </div>\n",
-       "          <div class=\"holoslider\"\n",
-       "               id=\"_anim_widgetc9932301a366416cb159d1c02a207ba5_Time\"></div>\n",
-       "        </div>\n",
-       "      </div>\n",
-       "\t  <script>\n",
-       "\t    function init_slider() {\n",
-       "        // Slider JS Block START\n",
-       "        function loadcssfile(filename){\n",
-       "            var fileref=document.createElement(\"link\")\n",
-       "            fileref.setAttribute(\"rel\", \"stylesheet\")\n",
-       "            fileref.setAttribute(\"type\", \"text/css\")\n",
-       "            fileref.setAttribute(\"href\", filename)\n",
-       "            document.getElementsByTagName(\"head\")[0].appendChild(fileref)\n",
-       "        }\n",
-       "        loadcssfile(\"https://code.jquery.com/ui/1.10.4/themes/smoothness/jquery-ui.css\");\n",
-       "        /* Check if jQuery and jQueryUI have been loaded\n",
-       "           otherwise load with require.js */\n",
-       "        var jQuery = window.jQuery,\n",
-       "            // check for old versions of jQuery\n",
-       "            oldjQuery = jQuery && !!jQuery.fn.jquery.match(/^1\\.[0-4](\\.|$)/),\n",
-       "            jquery_path = '',\n",
-       "            paths = {},\n",
-       "            noConflict;\n",
-       "        var jQueryUI = jQuery.ui;\n",
-       "        // check for jQuery\n",
-       "        if (!jQuery || oldjQuery) {\n",
-       "            // load if it's not available or doesn't meet min standards\n",
-       "            paths.jQuery = jQuery;\n",
-       "            noConflict = !!oldjQuery;\n",
-       "        } else {\n",
-       "            // register the current jQuery\n",
-       "            define('jquery', [], function() { return jQuery; });\n",
-       "        }\n",
-       "        if (!jQueryUI) {\n",
-       "            paths.jQueryUI = \"https://code.jquery.com/ui/1.10.4/jquery-ui.min\"\n",
-       "        } else {\n",
-       "            define('jQueryUI', [], function() { return jQuery.ui; });\n",
-       "        }\n",
-       "        paths.underscore = \"https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.8.3/underscore-min\";\n",
-       "        var jquery_require = {\n",
-       "            paths: paths,\n",
-       "            shim: {\n",
-       "                \"jQueryUI\": {\n",
-       "                    exports:\"$\",\n",
-       "                    deps: ['jquery']\n",
-       "                },\n",
-       "                \"underscore\": {\n",
-       "                    exports: '_'\n",
-       "                }\n",
-       "            }\n",
-       "        }\n",
-       "        require.config(jquery_require);\n",
-       "        require([\"jQueryUI\", \"underscore\"], function(jUI, _){\n",
-       "            if (noConflict) $.noConflict(true);\n",
-       "            var vals = ['2013-01-01T00:00:00.000000000', '2013-01-01T06:00:00.000000000', '2013-01-01T12:00:00.000000000', '2013-01-01T18:00:00.000000000'];\n",
-       "            var next_vals = {};\n",
-       "            if (false && vals.constructor === Array) {\n",
-       "                var min = parseFloat(vals[0]);\n",
-       "                var max = parseFloat(vals[vals.length-1]);\n",
-       "                var step = 1;\n",
-       "                var labels = [min];\n",
-       "            } else {\n",
-       "                var min = 0;\n",
-       "                if (false) {\n",
-       "                    var max = Object.keys(vals).length - 1;\n",
-       "                } else {\n",
-       "                    var max = vals.length - 1;\n",
-       "                }\n",
-       "                var step = 1;\n",
-       "\t\t\t\tvar labels = ['2013-01-01 00:00:00', '2013-01-01 06:00:00', '2013-01-01 12:00:00', '2013-01-01 18:00:00'];\n",
-       "            }\n",
-       "\t\t\tfunction adjustFontSize(text) {\n",
-       "\t\t\t\tvar width_ratio = (text.parent().width()/8)/text.val().length;\n",
-       "\t\t\t\tvar size = Math.min(0.9, Math.max(0.6, width_ratio))+'em';\n",
-       "\t\t\t\ttext.css('font-size', size);\n",
-       "\t\t\t}\n",
-       "            var slider = $('#_anim_widgetc9932301a366416cb159d1c02a207ba5_Time');\n",
-       "\t\t\tslider.slider({\n",
-       "                animate: \"fast\",\n",
-       "                min: min,\n",
-       "                max: max,\n",
-       "                step: step,\n",
-       "                value: min,\n",
-       "                dim_vals: vals,\n",
-       "                dim_labels: labels,\n",
-       "                next_vals: next_vals,\n",
-       "                slide: function(event, ui) {\n",
-       "                    var vals = slider.slider(\"option\", \"dim_vals\");\n",
-       "                    var next_vals = slider.slider(\"option\", \"next_vals\");\n",
-       "                    var labels = slider.slider(\"option\", \"dim_labels\");\n",
-       "                    if (false) {\n",
-       "\t\t\t\t\t    var dim_val = ui.value;\n",
-       "\t\t\t\t\t    if (vals.constructor === Array) {\n",
-       "\t\t\t\t\t\t   var label = ui.value;\n",
-       "\t\t\t\t\t\t} else {\n",
-       "\t\t\t\t\t\t   var label = labels[ui.value];\n",
-       "\t\t\t\t\t\t}\n",
-       "                    } else {\n",
-       "                        var dim_val = vals[ui.value];\n",
-       "\t\t\t\t\t\tvar label = labels[ui.value];\n",
-       "                    }\n",
-       "\t\t\t\t\tvar text = $('#textInputc9932301a366416cb159d1c02a207ba5_Time');\n",
-       "\t\t\t\t\ttext.val(label);\n",
-       "\t\t\t\t\tadjustFontSize(text);\n",
-       "                    animc9932301a366416cb159d1c02a207ba5.set_frame(dim_val, 0);\n",
-       "                    if (Object.keys(next_vals).length > 0) {\n",
-       "                        var new_vals = next_vals[dim_val];\n",
-       "                        var next_widget = $('#_anim_widgetc9932301a366416cb159d1c02a207ba5_');\n",
-       "                        update_widget(next_widget, new_vals);\n",
-       "                    }\n",
-       "                }\n",
-       "            });\n",
-       "            slider.keypress(function(event) {\n",
-       "                if (event.which == 80 || event.which == 112) {\n",
-       "                    var start = slider.slider(\"option\", \"value\");\n",
-       "                    var stop =  slider.slider(\"option\", \"max\");\n",
-       "                    for (var i=start; i<=stop; i++) {\n",
-       "                        var delay = i*50;\n",
-       "                        $.proxy(function doSetTimeout(i) { setTimeout($.proxy(function() {\n",
-       "                            var val = {value:i};\n",
-       "                            slider.slider('value',i);\n",
-       "                            slider.slider(\"option\", \"slide\")(null, val);\n",
-       "                        }, slider), delay);}, slider)(i);\n",
-       "                    }\n",
-       "                }\n",
-       "                if (event.which == 82 || event.which == 114) {\n",
-       "                    var start = slider.slider(\"option\", \"value\");\n",
-       "                    var stop =  slider.slider(\"option\", \"min\");\n",
-       "                    var count = 0;\n",
-       "                    for (var i=start; i>=stop; i--) {\n",
-       "                        var delay = count*50;\n",
-       "                        count = count + 1;\n",
-       "                        $.proxy(function doSetTimeout(i) { setTimeout($.proxy(function() {\n",
-       "                            var val = {value:i};\n",
-       "                            slider.slider('value',i);\n",
-       "                            slider.slider(\"option\", \"slide\")(null, val);\n",
-       "                        }, slider), delay);}, slider)(i);\n",
-       "                    }\n",
-       "                }\n",
-       "            });\n",
-       "\t\t\tvar textInput = $('#textInputc9932301a366416cb159d1c02a207ba5_Time')\n",
-       "\t\t\ttextInput.val(labels[0]);\n",
-       "\t\t\tadjustFontSize(textInput);\n",
-       "        });\n",
-       "\t\t}\n",
-       "        $(document).ready(init_slider)\n",
-       "        // Slider JS Block END\n",
-       "        </script>\n",
-       "        \n",
-       "        \n",
-       "        </form>\n",
-       "    </div>\n",
-       "</div>\n",
-       "\n",
-       "\n",
-       "<script language=\"javascript\">\n",
-       "/* Instantiate the MPLSelectionWidget class. */\n",
-       "/* The IDs given should match those used in the template above. */\n",
-       "(function() {\n",
-       "\tif (jQuery.ui !== undefined) {\n",
-       "\t\t$(\"#display_areac9932301a366416cb159d1c02a207ba5\").resizable({\n",
-       "\t\t\tresize: function(event, ui) {\n",
-       "\t\t\t\t$(\"#widget_areac9932301a366416cb159d1c02a207ba5\").width($(this).parent().width()-ui.size.width);\n",
-       "\t\t\t}\n",
-       "\t\t});\n",
-       "\t\t$(\"#widget_areac9932301a366416cb159d1c02a207ba5\").resizable();\n",
-       "\t}\n",
-       "    var widget_ids = new Array(1);\n",
-       "    \n",
-       "    widget_ids[0] = \"_anim_widgetc9932301a366416cb159d1c02a207ba5_Time\";\n",
-       "    \n",
-       "    var frame_data = {\"0\": \"<img src='data:image/png;base64,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' style='max-width:100%; margin: auto; display: block; '/>\", \"1\": \"<img src='data:image/png;base64,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' style='max-width:100%; margin: auto; display: block; '/>\", \"2\": \"<img src='data:image/png;base64,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' style='max-width:100%; margin: auto; display: block; '/>\", \"3\": \"<img src='data:image/png;base64,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' style='max-width:100%; margin: auto; display: block; '/>\"};\n",
-       "    var dim_vals = ['2013-01-01T00:00:00.000000000'];\n",
-       "    var keyMap = {\"('2013-01-01T00:00:00.000000000',)\": 0, \"('2013-01-01T06:00:00.000000000',)\": 1, \"('2013-01-01T12:00:00.000000000',)\": 2, \"('2013-01-01T18:00:00.000000000',)\": 3};\n",
-       "    var notFound = \"<h2 style='vertical-align: middle>No frame at selected dimension value.<h2>\";\n",
-       "    function create_widget() {\n",
-       "        setTimeout(function() {\n",
-       "            animc9932301a366416cb159d1c02a207ba5 = new MPLSelectionWidget(frame_data, \"c9932301a366416cb159d1c02a207ba5\", widget_ids,\n",
-       "\t\t\t\tkeyMap, dim_vals, notFound, false, \"default\",\n",
-       "\t\t\t\ttrue, \"./json_figures/\", false);\n",
-       "        }, 0);\n",
-       "    }\n",
-       "    \n",
-       "    create_widget();\n",
-       "    \n",
-       "})();\n",
-       "</script>"
-      ],
-      "text/plain": [
-       ":HoloMap   [time]\n",
-       "   :Image   [lon,lat]   (air)"
-      ]
-     },
-     "execution_count": 31,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "%%opts Image [colorbar=True]\n",
     "%%output size=200\n",

From c3ba75024abf2dd70c7a92565a9998dab3963c46 Mon Sep 17 00:00:00 2001
From: drs251 <danrstephan@gmail.com>
Date: Thu, 15 Mar 2018 15:59:42 +0100
Subject: [PATCH 4/4] Included dynamic flag for .to()

---
 examples/user_guide/08-Gridded_Datasets.ipynb | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/user_guide/08-Gridded_Datasets.ipynb b/examples/user_guide/08-Gridded_Datasets.ipynb
index e9b6f60dbe..28147f5d5b 100644
--- a/examples/user_guide/08-Gridded_Datasets.ipynb
+++ b/examples/user_guide/08-Gridded_Datasets.ipynb
@@ -342,14 +342,14 @@
    "source": [
     "%%opts Image [colorbar=True]\n",
     "%%output size=200\n",
-    "hv_ds.to(hv.Image, kdims=[\"lon\", \"lat\"])[:, 220:320, :]"
+    "hv_ds.to(hv.Image, kdims=[\"lon\", \"lat\"], dynamic=False)[:, 220:320, :]"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Note, that this approach immediately converts all available data to images, which will take up a lot of RAM for large datasets. For these situations, consider using a [DynamicMap](./06-Live_Data.ipynb) in conjunction with [xarray's dask support](http://xarray.pydata.org/en/stable/dask.html) instead.\n",
+    "Here, we have explicitly specified the default behaviour `dynamic=False`, which returns a HoloMap. Note, that this approach immediately converts all available data to images, which will take up a lot of RAM for large datasets. For these situations, use `dynamic=True` to generate a [DynamicMap](./06-Live_Data.ipynb) instead. Additionally, [xarray features dask support](http://xarray.pydata.org/en/stable/dask.html), which is helpful when dealing with large amounts of data.\n",
     "\n",
     "Additional examples of visualizing xarrays in the context of geographical data can be found in the GeoViews documentation: [Gridded Datasets I](http://geo.holoviews.org/Gridded_Datasets_I.html) and\n",
     "[Gridded Datasets II](http://geo.holoviews.org/Gridded_Datasets_II.html). These guides also contain useful information on the interaction between xarray data structures and HoloViews Datasets in general."