docs/examples/basic_examples/15_minutes_to_QCoDeS.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 15 minutes to QCoDeS\n",
    "\n",
    "This short introduction is aimed for potential and new users to get the feel of the software. This is a fully functioning Jupyter notebook that will execute simple measurements using dummy instruments. Before you start with your first code using QCoDeS, make sure you have properly set up the Python environment as explained in [this document](../../start/index.rst#installation). If you would like to follow this as an interactive notebook, you may [download it from github](https://github.com/microsoft/Qcodes/blob/main/docs/examples/basic_examples/15_minutes_to_QCoDeS.ipynb) to run on your local system, or you may use~ the \"launch binder\" link to use it via a web interface."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "QCoDeS is a python-based data acquisition and handling framework to facilitate experiments in nanoelectronics. As highly configurable open source project, we envision that this system may suite the needs of a diverse range of experimental setups, acting as a common system for regular experimental work across the community.\n",
    "\n",
    "This guide offers a practical overview of QCoDeS, going from installation to experimental data handling in a single notebook. Along the way links are provided to assist you in the configuration of this software's features for your experiments."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Installation\n",
    "\n",
    "QCoDeS is readily installed via pip or conda package managers in your preferred environment. These are other installation options are further detailed [in our installation guide](../../start/index.rst#installation).\n",
    "\n",
    "Install via pip:\n",
    "\n",
    "> pip install qcodes\n",
    "\n",
    "Install via conda:\n",
    "\n",
    "> conda -c conda-forge install qcodes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Module imports\n",
    "\n",
    "A wide range of modules are available for QCoDeS, but for this example we will only import what is needed for a simple measurement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "import qcodes as qc\n",
    "\n",
    "## Multidimensional scanning module\n",
    "from qcodes.dataset import (\n",
    "    LinSweep,\n",
    "    Measurement,\n",
    "    dond,\n",
    "    experiments,\n",
    "    initialise_or_create_database_at,\n",
    "    load_by_run_spec,\n",
    "    load_or_create_experiment,\n",
    "    plot_dataset,\n",
    ")\n",
    "\n",
    "## Dummy instruments for generating synthetic data\n",
    "from qcodes.instrument_drivers.mock_instruments import (\n",
    "    DummyInstrument,\n",
    "    DummyInstrumentWithMeasurement,\n",
    ")\n",
    "\n",
    "## Using interactive widget\n",
    "from qcodes.interactive_widget import experiments_widget"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instruments\n",
    "\n",
    "`Instrument` class in QCoDeS is responsible for holding connections to hardware and controlling the instruments by its built in methods. For more information on instrument class we refer to the [detailed description here](../writing_drivers/Instruments.ipynb)  or the corresponding [api documentation](../../api/instrument/index.rst). \n",
    "\n",
    "Let us, now, create two dummy instruments: a digital-to-analog converter (`dac`) with two channels, and a digital multimeter (`dmm`) to measure the signals produced: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A dummy signal generator with two parameters ch1 and ch2\n",
    "dac = DummyInstrument(\"dac\", gates=[\"ch1\", \"ch2\"])\n",
    "\n",
    "# A dummy digital multimeter that generates a synthetic data depending\n",
    "# on the values set on the setter_instr, in this case the dummy dac\n",
    "dmm = DummyInstrumentWithMeasurement(\"dmm\", setter_instr=dac)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All instruments feature methods to enable you to inspect their configuration. We refer to this as a ``snapshot``. For convenience, methods are provided for a human readable version allowing us to take a glance at our digital multimeter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dmm:\n",
      "\tparameter value\n",
      "--------------------------------------------------------------------------------\n",
      "IDN :\tNone \n",
      "v1  :\t0 (V)\n",
      "v2  :\t0 (V)\n"
     ]
    }
   ],
   "source": [
    "dmm.print_readable_snapshot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see here, our dummy multimeter, `dmm`, has two `Parameters` (v1 and v2), that correspond the two channels of our dummy signal generator `dac`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parameters\n",
    "\n",
    "A QCoDeS `Parameter` is a value from an instrument that may get and/or set values by methods. Intuitively this is how QCoDeS communicates with most instrumentation, for example a digital multimeter contains settings (e.g. mode, range) and provide data (e.g. voltage, current). These methods are defined by [instrument drivers](../driver_examples/index.rst), that utilize the [parameter API](../../api/parameters/index.rst). \n",
    "\n",
    "In this example we are using dummy instruments with trivial `set` and `get` methods to generate synthetic data. \n",
    "\n",
    "For the `dac`, these settable `Parameters` are added in the instantiation of the `DummyInstrument` class (i.e. `ch1` and `ch2`).\n",
    "\n",
    "\n",
    "> dac = DummyInstrument('dac', **gates=['ch1', 'ch2']**)\n",
    "\n",
    "\n",
    "Similarly, the dummy digital multimeter, `dmm`, has gettable `Parameters` added by the instantiation of the `DummyInstrumentWithMeasurement` class defined by the output channels of the setter instrument (i.e. the dac). \n",
    "\n",
    "\n",
    "> dmm = DummyInstrumentWithMeasurement('dmm', **setter_instr=dac**)\n",
    "\n",
    "\n",
    "Instruments may vary in their instantiation (e.g. gates vs. setter_inst), but the `parameters` are the common interface for measurements in QCoDeS. \n",
    "\n",
    "For convenience QCoDeS provides a variety of parameter classes built in to accommodate a range of instruments: \n",
    "\n",
    "   - `Parameter` : Represents a single value at a given time (e.g. voltage, current), please refer to the [example parameter notebook](../Parameters/Parameters.ipynb).\n",
    "   \n",
    "   - `ParameterWithSetpoints`: Represents an array of values of all the same type that are returned all at once (e.g. a voltage vs. time waveform). This class is detailed in our [parameter with setpoint notebook](../Parameters/Simple-Example-of-ParameterWithSetpoints.ipynb) along with experimental use cases.\n",
    "\n",
    "   - `DelegateParameter`: It is intended for proxy-ing other parameters and is detailed in the [parameter API](../../api/parameters/index.rst). You can use different label, unit, etc in the delegated parameter as compared to the source parameter.\n",
    "\n",
    "These built in parameter classes are typically used as a wrapper for instrument communications. The user-facing `set` and `get` methods calling instrument facing `set_raw` and `get_raw` methods. Further examples of these parameters are discussed in our example [notebook on Parameters](../Parameters/index.rst)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example of setting and getting parameters\n",
    "\n",
    "In most cases, a settable parameter accepts its value as an argument of a simple function call. For our example, we will set the a value of 1.1 for the `ch1` parameter of our signal generator, `dac`, by providing the value to the instrument channel:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "dac.ch1(1.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, a gettable parameter will often return its value with a simple function call. In our example, we will read the value of our digital multimeter, `dmm`, like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.012942026563443"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dmm.v1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stations  \n",
    "\n",
    "A station is a collection of all the instruments and devices present in your experiment. As mentioned earlier, it can be thought of as a bucket where you can add your `Instruments`, `Parameters` and other components. Each of these terms has a definite meaning in QCoDeS and shall be explained in later sections. Once a station is properly configured, you can use its instances to access these components. We refer to tutorial on [Station](Station.ipynb) for more details.\n",
    "\n",
    "To organize our dummy instruments, we will first instantiate a station as so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "station = qc.Station()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding instruments to the station\n",
    "\n",
    "Every instrument that you are working with during an experiment should be added to a `Station`.  \n",
    "\n",
    "Here, we add the `dac` and `dmm` instruments by using our station's `add_component()` method: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'dmm'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "station.add_component(dac)\n",
    "station.add_component(dmm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inspecting the station\n",
    "\n",
    "For any experiment it is essential to have a record of the instrumental setup. To enable this, a `Station` has a `snapshot` method which provides a dictionary of its `Instruments` and their properties (e.g. `Parameters`) in a recursive manner.\n",
    "\n",
    "This data is typically saved with every experiment run with QCoDeS, but the `snapshot` method may be used on a station to inspect its status:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove the ``_ = `` part to see the full snapshot\n",
    "_ = station.snapshot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This generates a lengthy output. While we will truncate it for this tutorial, the nested dictionaries offer a human- and machine-readable description of the station and its attached instruments:\n",
    "\n",
    "```\n",
    "{'instruments': {'dmm': {'functions': {},\n",
    "   'submodules': {},\n",
    "   '__class__': 'qcodes.instrument_drivers.mock_instruments.DummyInstrumentWithMeasurement',\n",
    "   'parameters': {'IDN': {'__class__': 'qcodes.instrument.parameter.Parameter',\n",
    "    [...]\n",
    "     'inter_delay': 0,\n",
    "     'instrument': 'qcodes.instrument_drivers.mock_instruments.DummyInstrumentWithMeasurement',\n",
    "     'instrument_name': 'dmm',\n",
    "     'unit': ''},\n",
    "    'v1': {'__class__': 'qcodes.instrument_drivers.mock_instruments.DmmExponentialParameter',\n",
    "     'full_name': 'dmm_v1',\n",
    "     'value': 5.136319425854842,\n",
    "     'raw_value': 5.136319425854842,\n",
    "     'ts': '2021-03-29 18:47:16',\n",
    "     'label': 'Gate v1',\n",
    "     'name': 'v1',\n",
    "     'post_delay': 0,\n",
    "     'vals': '<Numbers -800<=v<=400>',\n",
    "     'inter_delay': 0,\n",
    "     'instrument': 'qcodes.instrument_drivers.mock_instruments.DummyInstrumentWithMeasurement',\n",
    "     'instrument_name': 'dmm',\n",
    "     'unit': 'V'},\n",
    "     [...]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Saving and loading configurations.\n",
    "\n",
    "The instantiation of the instruments, that is, setting up the proper initial values of the corresponding parameters and similar pre-specifications of a measurement constitutes the initialization portion of the code. In general, this portion can be quite long and tedious to maintain. These (and more) concerns can be solved by a [YAML configuration file](Station.ipynb#Using-Station-with-YAML-configuration-files) of the `Station` object. Further options for stations are detailed in the [station example](Station.ipynb#Default-Station).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Databases and experiments.\n",
    "\n",
    "With `Station` a working station, the next step is to set up a `database` in order to save our data to. In QCoDeS, we implement a SQLite3 database for this purpose. \n",
    "\n",
    "### Initialize or create a database\n",
    "\n",
    "Before starting a measurement, we first initialize a database. The location of the database is specified by the configuration object of the QCoDeS installation. The database is created with the latest supported version complying with the QCoDeS version that is currently under use. If a database already exists but an upgrade has been done to the QCoDeS, then that database can continue to be used and it is going to be upgraded to the latest version automatically at first connection.\n",
    "\n",
    "The initialization (or creation) of the database at a particular location is achieved via static function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "initialise_or_create_database_at(\"~/experiments_for_15_mins.db\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, QCoDeS only supports a single active database. The current database location is stored in the configuration data (i.e. qcodes.config). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'~/experiments_for_15_mins.db'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc.config.core.db_location"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load or create an experiment\n",
    "\n",
    "After initializing the database we create an `Experiment` object. This object contains the names of the experiment and sample, and acts as a manager for data acquired during measurement. The `load_or_create_experiment` function will return an existing experiment with the same name, but if no experiments are found, it will create a new one.\n",
    "\n",
    "For this example, we will call our experiment `tutorial_exp`:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "tutorial_exp = load_or_create_experiment(\n",
    "    experiment_name=\"tutorial_exp\", sample_name=\"synthetic data\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The path of the database for the `experiment` is the defined path in the QCoDeS configuration. First, `Experiment` loads the database in that path (or it creates one if there is no database in that path), and then saves the created experiment in that database. If an experiment with this name and sample name already exists this will be set as the default experiment for the rest of the session. Although loading or creating a database with the experiment is a user-friendly feature, we recommend users to initialize their database as shown earlier. This practice allows better control of the experiments and databases for measurements, avoiding unexpected outcomes in data management.\n",
    "\n",
    "The method shown above to load or create the experiment is the most versatile one. However there are other options discussed in the guide on databases."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Measurement Context Manager\n",
    "\n",
    "The `Measurement` object is used to obtain data from instruments in QCoDeS, as such it is instantiated with both an `experiment` (to handle data) and `station` to control the instruments. If these arguments are absent, the most recent experiment and station are used as defaults. A keyword argument `name` can also be set as any string value, this string will be used to identify the resulting dataset. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "context_meas = Measurement(exp=tutorial_exp, station=station, name=\"context_example\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is possible to instantiate a `measurement` prior to creating or loading an experiment, but this is not advisable.\n",
    "\n",
    "1. If the initialized `database` does not contain an `experiment`, then the instantiation will raise an error and halt your work.\n",
    "2. If the database already contains an `experiment`, then the instantiated `measurement`  will be added to the most recent `experiment` in the database without raising an error message or warning. This will lead to poor data management.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Registering parameters to measure\n",
    "\n",
    "QCoDeS features the ability to store the relationship between parameters (i.e. parameter `y` is dependent on `x`). This feature allows the intent of the measurement to be clearly recorded in the experimental records. In addition, the parameter dependency is used to define the coordinate axes when plotting the data using QCoDeS. The parameters which are being measured are first registered with the `measurement`. When registering a dependent parameter (i.e. y(x)) the independent parameter is declared as a setpoint. As a consequence, independent parameters must be registered prior to their corresponding dependent parameters. \n",
    "\n",
    "In our example, ``dac.ch1`` is the independent parameter and ``dmm.v1`` is the dependent parameter. So we register ``dmm.v1`` with the setpoint as ``dac.ch1``. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<qcodes.dataset.measurements.Measurement at 0x269813aafd0>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Register the independent parameter...\n",
    "context_meas.register_parameter(dac.ch1)\n",
    "# ...then register the dependent parameter\n",
    "context_meas.register_parameter(dmm.v1, setpoints=(dac.ch1,))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example measurement loop\n",
    "\n",
    "The QCoDeS measurement module provides a context manager for registering parameters to measure and store results. Within the context manager, measured data is periodically saved to the database as a background process.\n",
    "\n",
    "To conduct a simple measurement, we can create a simple loop inside the context manager which will control the instruments, acquire data, and store the results. \n",
    "\n",
    "> This is the a more user-configurable approach for acquiring data in QCoDeS. For more examples and details, refer to [Performing measurements using QCoDeS parameters and DataSet example](../DataSet/Performing-measurements-using-qcodes-parameters-and-dataset.ipynb)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting experimental run with id: 1. \n"
     ]
    }
   ],
   "source": [
    "# Time for periodic background database writes\n",
    "context_meas.write_period = 2\n",
    "\n",
    "with context_meas.run() as datasaver:\n",
    "    for set_v in np.linspace(0, 25, 10):\n",
    "        dac.ch1.set(set_v)\n",
    "        get_v = dmm.v1.get()\n",
    "        datasaver.add_result((dac.ch1, set_v), (dmm.v1, get_v))\n",
    "\n",
    "    # Convenient to have for plotting and data access\n",
    "    dataset = datasaver.dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `meas.run` method returns a context manager to control data acquisition and storage. Entering the context provides a `DataSaver` object, which we will store as the `datasaver` variable. Using a simple loop structure, we can use instruments' `set` and `get` methods to control the instrument and acquire data respectively. Then, we use the ``add_result`` method to validate the size of all the data points and store them intermittently into a write cache. Within every write-period of the measurement, the data of this cache is flushed to the database in the background."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using the doNd multi-dimensional measurement utility \n",
    "\n",
    "Qcodes also includes functions to produce multidimensional data sets with [optimized data handling](../DataSet/Using_doNd_functions_in_comparison_to_Measurement_context_manager_for_performing_measurements.ipynb); of these, ``dond`` (i.e. do n-dimensional facilitates collecting multidimensional data.  Similar optimizations can be made using the measurement context (see [measuring with shaped data](../DataSet/Performing-measurements-using-qcodes-parameters-and-dataset.ipynb#Specifying-shape-of-measurement)), but this approach simplifies the setup and readability of the code. \n",
    "\n",
    "> This is a more user-friendly way of acquiring multi-dimensional data in QCoDeS.\n",
    "\n",
    "We will first set up the measurement by defining the sweeps for each independent parameters, in our case the two channels of ``dac``:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setting up a doNd measurement\n",
    "sweep_1 = LinSweep(dac.ch1, -1, 1, 20, 0.01)\n",
    "sweep_2 = LinSweep(dac.ch2, -1, 1, 20, 0.01)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "This linear sweeps for `dac.ch1` and `dac.ch2` are defined by the endpoints of the sweep (-1 to 1 V), the number of steps (20) and a time delay between each step (0.01 s). This delay time is used to allow real instruments to equilibrate between each step in the sweep. Multiple types of sweeps are [included with QCoDeS](../DataSet/Using_doNd_functions_in_comparison_to_Measurement_context_manager_for_performing_measurements.ipynb) to enable a variety of sampling schemes. \n",
    "\n",
    "> When using `dond` we do not register parameters, this is done automatically by the function. With dond every dependent parameter depends on all sweep parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting experimental run with id: 2. Using 'qcodes.dataset.dond'\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "81da13aec98c45d48ef0401210230ab3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/400 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(dond_example #2@C:\\Users\\jenielse\\experiments_for_15_mins.db\n",
       " ------------------------------------------------------------\n",
       " dac_ch1 - numeric\n",
       " dac_ch2 - numeric\n",
       " dmm_v1 - numeric\n",
       " dmm_v2 - numeric,\n",
       " (None,),\n",
       " (None,))"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dond(\n",
    "    sweep_1,  # 1st independent parameter\n",
    "    sweep_2,  # 2nd independent parameter\n",
    "    dmm.v1,  # 1st dependent parameter\n",
    "    dmm.v2,  # 2nd dependent parameter\n",
    "    measurement_name=\"dond_example\",  # Set the measurement name\n",
    "    exp=tutorial_exp,  # Set the experiment to save data to.\n",
    "    show_progress=True,  # Optional progress bar\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ``dond`` function features a number of options (e.g. plotting, database write period, multithreading) which are further detailed in our [example notebooks](../DataSet/Using_doNd_functions_in_comparison_to_Measurement_context_manager_for_performing_measurements.ipynb#Handling-plot,-experiment,-and-measurement_name-with-doNd). For simple measurements, [do1d](../DataSet/Using_doNd_functions_in_comparison_to_Measurement_context_manager_for_performing_measurements.ipynb#do1d) and [do2d](../DataSet/Using_doNd_functions_in_comparison_to_Measurement_context_manager_for_performing_measurements.ipynb#do2d) provide a simpler interface with similar functionality for 1d and 2d acquisitions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exploring datasets and databases\n",
    "\n",
    "In this section we detail methods and functions for working with `DataSets`. In QCoDeS, all measured results are generally packaged and stored in the database as a `DataSet` object. While it isn't essential for running QCoDeS, we provide a [detailed walktrough notebook](../DataSet/DataSet-class-walkthrough.ipynb) to assist users in developing new data analysis methods."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List all datasets in a database."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The most direct way of finding our data is the `experiments` function; this queries the currently initialized `database` and prints the `experiments` and `datasets` contained inside. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[tutorial_exp#synthetic data#1@C:\\Users\\jenielse\\experiments_for_15_mins.db\n",
       " --------------------------------------------------------------------------\n",
       " 1-context_example-1-dac_ch1,dmm_v1-10\n",
       " 2-dond_example-2-dac_ch1,dac_ch2,dmm_v1,dmm_v2-800]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "experiments()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While this example database contains only a few experiments this number may grow significantly as you perform measurements on your nanoelectronic devices. \n",
    "\n",
    "While our example database contains only few experiments, in reality the database will contain several experiments containing many datasets. Often, you would like to load a dataset from a particular experiment for further analysis. Here we shall explore different ways to find and retrieve already measured dataset from the database."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List all the datasets in an experiment\n",
    "\n",
    "An experiment also contains the `datasets` produced by its `measurements`. Using the `data_sets` method we can print a list of these `datasets`, the parameters recorded, and the type of data obtained for each parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[context_example #1@C:\\Users\\jenielse\\experiments_for_15_mins.db\n",
       " ---------------------------------------------------------------\n",
       " dac_ch1 - numeric\n",
       " dmm_v1 - numeric,\n",
       " dond_example #2@C:\\Users\\jenielse\\experiments_for_15_mins.db\n",
       " ------------------------------------------------------------\n",
       " dac_ch1 - numeric\n",
       " dac_ch2 - numeric\n",
       " dmm_v1 - numeric\n",
       " dmm_v2 - numeric]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tutorial_exp.data_sets()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load the data set using one or more specifications"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to plot or analyze data, we will need to retrieve the `datasets`. While this can be done directly from the `experiment`, instrument environments are typically not used for analysis. Moreover, we may wish to compare data from separate `experiments` requiring us to load datasets separately.\n",
    "\n",
    "In QCoDeS, `datasets` can be obtained using simple criteria via the  `load_by_run_spec` function. For this example we will load our previous 1d and 2d datasets by their name and database id number: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_1d = load_by_run_spec(experiment_name=\"tutorial_exp\", captured_run_id=1)\n",
    "dataset_2d = load_by_run_spec(experiment_name=\"tutorial_exp\", captured_run_id=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While the arguments are optional, the function call will raise an error if more than one run matching the supplied specifications is found. If such an error occurs, the traceback will contain the specifications of the runs, as well. More examples of refined search criteria for data extraction are provided in [this example notebook](../DataSet/Extracting-runs-from-one-DB-file-to-another.ipynb#Uniquely-identifying-and-loading-runs).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting datasets\n",
    "\n",
    "Numerical data is typically difficult to understand when tabulated, so we would want to visualize it as a plot. QCoDeS includes an integrated plotting function, `plot_dataset`, that neatly visualizes our 1d and 2d `datasets`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([<Axes: title={'center': 'Run #1, Experiment tutorial_exp (synthetic data)'}, xlabel='Gate ch1 (V)', ylabel='Gate v1 (V)'>],\n",
       " [None])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting 1d dataset\n",
    "plot_dataset(dataset_1d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With 1d data a simple line plot will be generated with the dependent and independent parameters set to the respective X and Y axes. This works nicely because of the integration of the `instrument` (providing units) and the predefined dependency between `parameters` measured."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([<Axes: title={'center': 'Run #2, Experiment tutorial_exp (synthetic data)'}, xlabel='Gate ch1 (V)', ylabel='Gate ch2 (V)'>,\n",
       "  <Axes: title={'center': 'Run #2, Experiment tutorial_exp (synthetic data)'}, xlabel='Gate ch1 (V)', ylabel='Gate ch2 (V)'>],\n",
       " [<matplotlib.colorbar.Colorbar at 0x269836e5a10>,\n",
       "  <matplotlib.colorbar.Colorbar at 0x2698150a1d0>])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting 2d dataset as heatmaps\n",
    "plot_dataset(dataset_2d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With 2d data heat maps will be generated with the independent parameters set to the X and Y axes and the dependent parameter set as the color scale. Similar to the 1d case, this automatic visualization depends on the predefined `parameters` provided to the `dond` function. \n",
    "\n",
    ">For more detailed examples of plotting QCoDeS datasets, we have articles covering a variety of data types:\n",
    ">\n",
    "> - [Offline plotting tutorial](../DataSet/Offline%20Plotting%20Tutorial.ipynb)\n",
    "> - [Offline plotting with categorical data](../DataSet/Offline%20plotting%20with%20categorical%20data.ipynb)\n",
    "> - [Offline plotting with complex data](../DataSet/Offline%20plotting%20with%20complex%20data.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### QCoDeS measurements live plotting with Plottr\n",
    "\n",
    "Plottr supports and is recommended for live plotting QCoDeS measurements. This enables a direct visualization of an ongoing measurement to facilitate experimentalists. [How to use plottr with QCoDeS for live plotting](../plotting/How-to-use-Plottr-with-QCoDeS-for-live-plotting.ipynb) notebook contains more information."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get data of specific parameter of a dataset\n",
    "\n",
    "When designing a new analysis method for your nanoelectronic measurements, it may be useful to extract the data from an individual parameter obtained in a dataset. Using the `get_parameter_data` method included in `DataSet` we obtain a dictionary of the data for a single parameter.\n",
    "\n",
    "> Note that this method behaves differently for independent (e.g. `dac_ch1`) or dependent (e.g. `dmm_v1`) parameters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'dmm_v1': {'dmm_v1': array([ 4.99735887,  2.78803862,  1.72429108,  0.71747071,  0.3726567 ,\n",
       "          0.30341025,  0.18622251,  0.08445822, -0.05083793, -0.06316246]),\n",
       "  'dac_ch1': array([ 0.        ,  2.77777778,  5.55555556,  8.33333333, 11.11111111,\n",
       "         13.88888889, 16.66666667, 19.44444444, 22.22222222, 25.        ])}}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# All data for all parameters\n",
    "dataset_1d.get_parameter_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'dac_ch1': {'dac_ch1': array([ 0.        ,  2.77777778,  5.55555556,  8.33333333, 11.11111111,\n",
       "         13.88888889, 16.66666667, 19.44444444, 22.22222222, 25.        ])}}"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Data for independent parameter\n",
    "dataset_1d.get_parameter_data(\"dac_ch1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'dmm_v1': {'dmm_v1': array([ 4.99735887,  2.78803862,  1.72429108,  0.71747071,  0.3726567 ,\n",
       "          0.30341025,  0.18622251,  0.08445822, -0.05083793, -0.06316246]),\n",
       "  'dac_ch1': array([ 0.        ,  2.77777778,  5.55555556,  8.33333333, 11.11111111,\n",
       "         13.88888889, 16.66666667, 19.44444444, 22.22222222, 25.        ])}}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Data for dependent parameter\n",
    "dataset_1d.get_parameter_data(\"dmm_v1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We refer reader to [exporting data section of the performing measurements using QCoDeS parameters and dataset](../DataSet/Performing-measurements-using-qcodes-parameters-and-dataset.ipynb#Accessing-and-exporting-the-measured-data) and [Accessing data in DataSet notebook](../DataSet/Accessing-data-in-DataSet.ipynb) for further information on `get_parameter_data` method."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Export data to pandas dataframe\n",
    "\n",
    "Similarly, data stored within a QCoDeS database may be exported as pandas dataframes for analysis. This is accomplished by the `to_pandas_dataframe` method included in `DataSet`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>dmm_v1</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>dac_ch1</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0.000000</th>\n",
       "      <td>4.997359</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2.777778</th>\n",
       "      <td>2.788039</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5.555556</th>\n",
       "      <td>1.724291</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8.333333</th>\n",
       "      <td>0.717471</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11.111111</th>\n",
       "      <td>0.372657</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             dmm_v1\n",
       "dac_ch1            \n",
       "0.000000   4.997359\n",
       "2.777778   2.788039\n",
       "5.555556   1.724291\n",
       "8.333333   0.717471\n",
       "11.111111  0.372657"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = dataset_1d.to_pandas_dataframe()\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Export data to xarray"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's also possible to export data stored within a QCoDeS `dataset` to an `xarray.DataSet`. This can be achieved as so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div><svg style=\"position: absolute; width: 0; height: 0; overflow: hidden\">\n",
       "<defs>\n",
       "<symbol id=\"icon-database\" viewBox=\"0 0 32 32\">\n",
       "<path d=\"M16 0c-8.837 0-16 2.239-16 5v4c0 2.761 7.163 5 16 5s16-2.239 16-5v-4c0-2.761-7.163-5-16-5z\"></path>\n",
       "<path d=\"M16 17c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n",
       "<path d=\"M16 26c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n",
       "</symbol>\n",
       "<symbol id=\"icon-file-text2\" viewBox=\"0 0 32 32\">\n",
       "<path d=\"M28.681 7.159c-0.694-0.947-1.662-2.053-2.724-3.116s-2.169-2.030-3.116-2.724c-1.612-1.182-2.393-1.319-2.841-1.319h-15.5c-1.378 0-2.5 1.121-2.5 2.5v27c0 1.378 1.122 2.5 2.5 2.5h23c1.378 0 2.5-1.122 2.5-2.5v-19.5c0-0.448-0.137-1.23-1.319-2.841zM24.543 5.457c0.959 0.959 1.712 1.825 2.268 2.543h-4.811v-4.811c0.718 0.556 1.584 1.309 2.543 2.268zM28 29.5c0 0.271-0.229 0.5-0.5 0.5h-23c-0.271 0-0.5-0.229-0.5-0.5v-27c0-0.271 0.229-0.5 0.5-0.5 0 0 15.499-0 15.5 0v7c0 0.552 0.448 1 1 1h7v19.5z\"></path>\n",
       "<path d=\"M23 26h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n",
       "<path d=\"M23 22h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n",
       "<path d=\"M23 18h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n",
       "</symbol>\n",
       "</defs>\n",
       "</svg>\n",
       "<style>/* CSS stylesheet for displaying xarray objects in jupyterlab.\n",
       " *\n",
       " */\n",
       "\n",
       ":root {\n",
       "  --xr-font-color0: var(--jp-content-font-color0, rgba(0, 0, 0, 1));\n",
       "  --xr-font-color2: var(--jp-content-font-color2, rgba(0, 0, 0, 0.54));\n",
       "  --xr-font-color3: var(--jp-content-font-color3, rgba(0, 0, 0, 0.38));\n",
       "  --xr-border-color: var(--jp-border-color2, #e0e0e0);\n",
       "  --xr-disabled-color: var(--jp-layout-color3, #bdbdbd);\n",
       "  --xr-background-color: var(--jp-layout-color0, white);\n",
       "  --xr-background-color-row-even: var(--jp-layout-color1, white);\n",
       "  --xr-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n",
       "}\n",
       "\n",
       "html[theme=dark],\n",
       "body[data-theme=dark],\n",
       "body.vscode-dark {\n",
       "  --xr-font-color0: rgba(255, 255, 255, 1);\n",
       "  --xr-font-color2: rgba(255, 255, 255, 0.54);\n",
       "  --xr-font-color3: rgba(255, 255, 255, 0.38);\n",
       "  --xr-border-color: #1F1F1F;\n",
       "  --xr-disabled-color: #515151;\n",
       "  --xr-background-color: #111111;\n",
       "  --xr-background-color-row-even: #111111;\n",
       "  --xr-background-color-row-odd: #313131;\n",
       "}\n",
       "\n",
       ".xr-wrap {\n",
       "  display: block !important;\n",
       "  min-width: 300px;\n",
       "  max-width: 700px;\n",
       "}\n",
       "\n",
       ".xr-text-repr-fallback {\n",
       "  /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n",
       "  display: none;\n",
       "}\n",
       "\n",
       ".xr-header {\n",
       "  padding-top: 6px;\n",
       "  padding-bottom: 6px;\n",
       "  margin-bottom: 4px;\n",
       "  border-bottom: solid 1px var(--xr-border-color);\n",
       "}\n",
       "\n",
       ".xr-header > div,\n",
       ".xr-header > ul {\n",
       "  display: inline;\n",
       "  margin-top: 0;\n",
       "  margin-bottom: 0;\n",
       "}\n",
       "\n",
       ".xr-obj-type,\n",
       ".xr-array-name {\n",
       "  margin-left: 2px;\n",
       "  margin-right: 10px;\n",
       "}\n",
       "\n",
       ".xr-obj-type {\n",
       "  color: var(--xr-font-color2);\n",
       "}\n",
       "\n",
       ".xr-sections {\n",
       "  padding-left: 0 !important;\n",
       "  display: grid;\n",
       "  grid-template-columns: 150px auto auto 1fr 20px 20px;\n",
       "}\n",
       "\n",
       ".xr-section-item {\n",
       "  display: contents;\n",
       "}\n",
       "\n",
       ".xr-section-item input {\n",
       "  display: none;\n",
       "}\n",
       "\n",
       ".xr-section-item input + label {\n",
       "  color: var(--xr-disabled-color);\n",
       "}\n",
       "\n",
       ".xr-section-item input:enabled + label {\n",
       "  cursor: pointer;\n",
       "  color: var(--xr-font-color2);\n",
       "}\n",
       "\n",
       ".xr-section-item input:enabled + label:hover {\n",
       "  color: var(--xr-font-color0);\n",
       "}\n",
       "\n",
       ".xr-section-summary {\n",
       "  grid-column: 1;\n",
       "  color: var(--xr-font-color2);\n",
       "  font-weight: 500;\n",
       "}\n",
       "\n",
       ".xr-section-summary > span {\n",
       "  display: inline-block;\n",
       "  padding-left: 0.5em;\n",
       "}\n",
       "\n",
       ".xr-section-summary-in:disabled + label {\n",
       "  color: var(--xr-font-color2);\n",
       "}\n",
       "\n",
       ".xr-section-summary-in + label:before {\n",
       "  display: inline-block;\n",
       "  content: '►';\n",
       "  font-size: 11px;\n",
       "  width: 15px;\n",
       "  text-align: center;\n",
       "}\n",
       "\n",
       ".xr-section-summary-in:disabled + label:before {\n",
       "  color: var(--xr-disabled-color);\n",
       "}\n",
       "\n",
       ".xr-section-summary-in:checked + label:before {\n",
       "  content: '▼';\n",
       "}\n",
       "\n",
       ".xr-section-summary-in:checked + label > span {\n",
       "  display: none;\n",
       "}\n",
       "\n",
       ".xr-section-summary,\n",
       ".xr-section-inline-details {\n",
       "  padding-top: 4px;\n",
       "  padding-bottom: 4px;\n",
       "}\n",
       "\n",
       ".xr-section-inline-details {\n",
       "  grid-column: 2 / -1;\n",
       "}\n",
       "\n",
       ".xr-section-details {\n",
       "  display: none;\n",
       "  grid-column: 1 / -1;\n",
       "  margin-bottom: 5px;\n",
       "}\n",
       "\n",
       ".xr-section-summary-in:checked ~ .xr-section-details {\n",
       "  display: contents;\n",
       "}\n",
       "\n",
       ".xr-array-wrap {\n",
       "  grid-column: 1 / -1;\n",
       "  display: grid;\n",
       "  grid-template-columns: 20px auto;\n",
       "}\n",
       "\n",
       ".xr-array-wrap > label {\n",
       "  grid-column: 1;\n",
       "  vertical-align: top;\n",
       "}\n",
       "\n",
       ".xr-preview {\n",
       "  color: var(--xr-font-color3);\n",
       "}\n",
       "\n",
       ".xr-array-preview,\n",
       ".xr-array-data {\n",
       "  padding: 0 5px !important;\n",
       "  grid-column: 2;\n",
       "}\n",
       "\n",
       ".xr-array-data,\n",
       ".xr-array-in:checked ~ .xr-array-preview {\n",
       "  display: none;\n",
       "}\n",
       "\n",
       ".xr-array-in:checked ~ .xr-array-data,\n",
       ".xr-array-preview {\n",
       "  display: inline-block;\n",
       "}\n",
       "\n",
       ".xr-dim-list {\n",
       "  display: inline-block !important;\n",
       "  list-style: none;\n",
       "  padding: 0 !important;\n",
       "  margin: 0;\n",
       "}\n",
       "\n",
       ".xr-dim-list li {\n",
       "  display: inline-block;\n",
       "  padding: 0;\n",
       "  margin: 0;\n",
       "}\n",
       "\n",
       ".xr-dim-list:before {\n",
       "  content: '(';\n",
       "}\n",
       "\n",
       ".xr-dim-list:after {\n",
       "  content: ')';\n",
       "}\n",
       "\n",
       ".xr-dim-list li:not(:last-child):after {\n",
       "  content: ',';\n",
       "  padding-right: 5px;\n",
       "}\n",
       "\n",
       ".xr-has-index {\n",
       "  font-weight: bold;\n",
       "}\n",
       "\n",
       ".xr-var-list,\n",
       ".xr-var-item {\n",
       "  display: contents;\n",
       "}\n",
       "\n",
       ".xr-var-item > div,\n",
       ".xr-var-item label,\n",
       ".xr-var-item > .xr-var-name span {\n",
       "  background-color: var(--xr-background-color-row-even);\n",
       "  margin-bottom: 0;\n",
       "}\n",
       "\n",
       ".xr-var-item > .xr-var-name:hover span {\n",
       "  padding-right: 5px;\n",
       "}\n",
       "\n",
       ".xr-var-list > li:nth-child(odd) > div,\n",
       ".xr-var-list > li:nth-child(odd) > label,\n",
       ".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n",
       "  background-color: var(--xr-background-color-row-odd);\n",
       "}\n",
       "\n",
       ".xr-var-name {\n",
       "  grid-column: 1;\n",
       "}\n",
       "\n",
       ".xr-var-dims {\n",
       "  grid-column: 2;\n",
       "}\n",
       "\n",
       ".xr-var-dtype {\n",
       "  grid-column: 3;\n",
       "  text-align: right;\n",
       "  color: var(--xr-font-color2);\n",
       "}\n",
       "\n",
       ".xr-var-preview {\n",
       "  grid-column: 4;\n",
       "}\n",
       "\n",
       ".xr-index-preview {\n",
       "  grid-column: 2 / 5;\n",
       "  color: var(--xr-font-color2);\n",
       "}\n",
       "\n",
       ".xr-var-name,\n",
       ".xr-var-dims,\n",
       ".xr-var-dtype,\n",
       ".xr-preview,\n",
       ".xr-attrs dt {\n",
       "  white-space: nowrap;\n",
       "  overflow: hidden;\n",
       "  text-overflow: ellipsis;\n",
       "  padding-right: 10px;\n",
       "}\n",
       "\n",
       ".xr-var-name:hover,\n",
       ".xr-var-dims:hover,\n",
       ".xr-var-dtype:hover,\n",
       ".xr-attrs dt:hover {\n",
       "  overflow: visible;\n",
       "  width: auto;\n",
       "  z-index: 1;\n",
       "}\n",
       "\n",
       ".xr-var-attrs,\n",
       ".xr-var-data,\n",
       ".xr-index-data {\n",
       "  display: none;\n",
       "  background-color: var(--xr-background-color) !important;\n",
       "  padding-bottom: 5px !important;\n",
       "}\n",
       "\n",
       ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n",
       ".xr-var-data-in:checked ~ .xr-var-data,\n",
       ".xr-index-data-in:checked ~ .xr-index-data {\n",
       "  display: block;\n",
       "}\n",
       "\n",
       ".xr-var-data > table {\n",
       "  float: right;\n",
       "}\n",
       "\n",
       ".xr-var-name span,\n",
       ".xr-var-data,\n",
       ".xr-index-name div,\n",
       ".xr-index-data,\n",
       ".xr-attrs {\n",
       "  padding-left: 25px !important;\n",
       "}\n",
       "\n",
       ".xr-attrs,\n",
       ".xr-var-attrs,\n",
       ".xr-var-data,\n",
       ".xr-index-data {\n",
       "  grid-column: 1 / -1;\n",
       "}\n",
       "\n",
       "dl.xr-attrs {\n",
       "  padding: 0;\n",
       "  margin: 0;\n",
       "  display: grid;\n",
       "  grid-template-columns: 125px auto;\n",
       "}\n",
       "\n",
       ".xr-attrs dt,\n",
       ".xr-attrs dd {\n",
       "  padding: 0;\n",
       "  margin: 0;\n",
       "  float: left;\n",
       "  padding-right: 10px;\n",
       "  width: auto;\n",
       "}\n",
       "\n",
       ".xr-attrs dt {\n",
       "  font-weight: normal;\n",
       "  grid-column: 1;\n",
       "}\n",
       "\n",
       ".xr-attrs dt:hover span {\n",
       "  display: inline-block;\n",
       "  background: var(--xr-background-color);\n",
       "  padding-right: 10px;\n",
       "}\n",
       "\n",
       ".xr-attrs dd {\n",
       "  grid-column: 2;\n",
       "  white-space: pre-wrap;\n",
       "  word-break: break-all;\n",
       "}\n",
       "\n",
       ".xr-icon-database,\n",
       ".xr-icon-file-text2,\n",
       ".xr-no-icon {\n",
       "  display: inline-block;\n",
       "  vertical-align: middle;\n",
       "  width: 1em;\n",
       "  height: 1.5em !important;\n",
       "  stroke-width: 0;\n",
       "  stroke: currentColor;\n",
       "  fill: currentColor;\n",
       "}\n",
       "</style><pre class='xr-text-repr-fallback'>&lt;xarray.Dataset&gt;\n",
       "Dimensions:  (dac_ch1: 10)\n",
       "Coordinates:\n",
       "  * dac_ch1  (dac_ch1) float64 0.0 2.778 5.556 8.333 ... 16.67 19.44 22.22 25.0\n",
       "Data variables:\n",
       "    dmm_v1   (dac_ch1) float64 4.997 2.788 1.724 ... 0.08446 -0.05084 -0.06316\n",
       "Attributes: (12/14)\n",
       "    ds_name:                  context_example\n",
       "    sample_name:              synthetic data\n",
       "    exp_name:                 tutorial_exp\n",
       "    snapshot:                 {&quot;station&quot;: {&quot;instruments&quot;: {&quot;dac&quot;: {&quot;functions...\n",
       "    guid:                     52ed1f3d-0000-0000-0000-018d7de26889\n",
       "    run_timestamp:            2024-02-06 11:06:46\n",
       "    ...                       ...\n",
       "    captured_counter:         1\n",
       "    run_id:                   1\n",
       "    run_description:          {&quot;version&quot;: 3, &quot;interdependencies&quot;: {&quot;paramspec...\n",
       "    parent_dataset_links:     []\n",
       "    run_timestamp_raw:        1707214006.4253306\n",
       "    completed_timestamp_raw:  1707214006.4373317</pre><div class='xr-wrap' style='display:none'><div class='xr-header'><div class='xr-obj-type'>xarray.Dataset</div></div><ul class='xr-sections'><li class='xr-section-item'><input id='section-c254277f-a3f6-4ebc-b9da-ad9b0a43d435' class='xr-section-summary-in' type='checkbox' disabled ><label for='section-c254277f-a3f6-4ebc-b9da-ad9b0a43d435' class='xr-section-summary'  title='Expand/collapse section'>Dimensions:</label><div class='xr-section-inline-details'><ul class='xr-dim-list'><li><span class='xr-has-index'>dac_ch1</span>: 10</li></ul></div><div class='xr-section-details'></div></li><li class='xr-section-item'><input id='section-65d59637-5af5-44bf-aa78-d4d31228e7da' class='xr-section-summary-in' type='checkbox'  checked><label for='section-65d59637-5af5-44bf-aa78-d4d31228e7da' class='xr-section-summary' >Coordinates: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>dac_ch1</span></div><div class='xr-var-dims'>(dac_ch1)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>0.0 2.778 5.556 ... 22.22 25.0</div><input id='attrs-dbd8c10a-a8aa-4202-b2f1-063b52b98e8c' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-dbd8c10a-a8aa-4202-b2f1-063b52b98e8c' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-0402abd1-f907-443e-90b4-f2c8f5791856' class='xr-var-data-in' type='checkbox'><label for='data-0402abd1-f907-443e-90b4-f2c8f5791856' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>name :</span></dt><dd>dac_ch1</dd><dt><span>paramtype :</span></dt><dd>numeric</dd><dt><span>label :</span></dt><dd>Gate ch1</dd><dt><span>unit :</span></dt><dd>V</dd><dt><span>inferred_from :</span></dt><dd>[]</dd><dt><span>depends_on :</span></dt><dd>[]</dd><dt><span>units :</span></dt><dd>V</dd><dt><span>long_name :</span></dt><dd>Gate ch1</dd></dl></div><div class='xr-var-data'><pre>array([ 0.      ,  2.777778,  5.555556,  8.333333, 11.111111, 13.888889,\n",
       "       16.666667, 19.444444, 22.222222, 25.      ])</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-80e245d6-1da3-4c62-b422-3eb67df55c14' class='xr-section-summary-in' type='checkbox'  checked><label for='section-80e245d6-1da3-4c62-b422-3eb67df55c14' class='xr-section-summary' >Data variables: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span>dmm_v1</span></div><div class='xr-var-dims'>(dac_ch1)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>4.997 2.788 ... -0.05084 -0.06316</div><input id='attrs-de7dda45-c855-4ead-9f02-8be58e2cd8df' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-de7dda45-c855-4ead-9f02-8be58e2cd8df' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-58c22985-1c0f-4012-8b27-ec489e677901' class='xr-var-data-in' type='checkbox'><label for='data-58c22985-1c0f-4012-8b27-ec489e677901' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>name :</span></dt><dd>dmm_v1</dd><dt><span>paramtype :</span></dt><dd>numeric</dd><dt><span>label :</span></dt><dd>Gate v1</dd><dt><span>unit :</span></dt><dd>V</dd><dt><span>inferred_from :</span></dt><dd>[]</dd><dt><span>depends_on :</span></dt><dd>[&#x27;dac_ch1&#x27;]</dd><dt><span>units :</span></dt><dd>V</dd><dt><span>long_name :</span></dt><dd>Gate v1</dd></dl></div><div class='xr-var-data'><pre>array([ 4.99735887,  2.78803862,  1.72429108,  0.71747071,  0.3726567 ,\n",
       "        0.30341025,  0.18622251,  0.08445822, -0.05083793, -0.06316246])</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-c52562c7-30dd-4c7a-a719-eb03572ab414' class='xr-section-summary-in' type='checkbox'  ><label for='section-c52562c7-30dd-4c7a-a719-eb03572ab414' class='xr-section-summary' >Indexes: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-index-name'><div>dac_ch1</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-d981337e-c449-4c2e-a109-a1347eac998e' class='xr-index-data-in' type='checkbox'/><label for='index-d981337e-c449-4c2e-a109-a1347eac998e' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(Index([             0.0, 2.77777777777778, 5.55555555555556, 8.33333333333333,\n",
       "       11.1111111111111, 13.8888888888889, 16.6666666666667, 19.4444444444444,\n",
       "       22.2222222222222,             25.0],\n",
       "      dtype=&#x27;float64&#x27;, name=&#x27;dac_ch1&#x27;))</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-ccd2f209-414d-4ff8-a63c-1ea628bcff24' class='xr-section-summary-in' type='checkbox'  ><label for='section-ccd2f209-414d-4ff8-a63c-1ea628bcff24' class='xr-section-summary' >Attributes: <span>(14)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'><dt><span>ds_name :</span></dt><dd>context_example</dd><dt><span>sample_name :</span></dt><dd>synthetic data</dd><dt><span>exp_name :</span></dt><dd>tutorial_exp</dd><dt><span>snapshot :</span></dt><dd>{&quot;station&quot;: {&quot;instruments&quot;: {&quot;dac&quot;: {&quot;functions&quot;: {}, &quot;submodules&quot;: {}, &quot;parameters&quot;: {&quot;IDN&quot;: {&quot;__class__&quot;: &quot;qcodes.parameters.parameter.Parameter&quot;, &quot;full_name&quot;: &quot;dac_IDN&quot;, &quot;value&quot;: {&quot;vendor&quot;: &quot;QCoDeS&quot;, &quot;model&quot;: &quot;&lt;class &#x27;qcodes.instrument_drivers.mock_instruments.DummyInstrument&#x27;&gt;&quot;, &quot;serial&quot;: &quot;NA&quot;, &quot;firmware&quot;: &quot;NA&quot;}, &quot;raw_value&quot;: {&quot;vendor&quot;: &quot;QCoDeS&quot;, &quot;model&quot;: &quot;&lt;class &#x27;qcodes.instrument_drivers.mock_instruments.DummyInstrument&#x27;&gt;&quot;, &quot;serial&quot;: &quot;NA&quot;, &quot;firmware&quot;: &quot;NA&quot;}, &quot;ts&quot;: &quot;2024-02-06 11:06:41&quot;, &quot;vals&quot;: &quot;&lt;Anything&gt;&quot;, &quot;instrument&quot;: &quot;qcodes.instrument_drivers.mock_instruments.DummyInstrument&quot;, &quot;instrument_name&quot;: &quot;dac&quot;, &quot;inter_delay&quot;: 0, &quot;unit&quot;: &quot;&quot;, &quot;post_delay&quot;: 0, &quot;validators&quot;: [&quot;&lt;Anything&gt;&quot;], &quot;label&quot;: &quot;IDN&quot;, &quot;name&quot;: &quot;IDN&quot;}, &quot;ch1&quot;: {&quot;__class__&quot;: &quot;qcodes.parameters.parameter.Parameter&quot;, &quot;full_name&quot;: &quot;dac_ch1&quot;, &quot;value&quot;: 1.1, &quot;raw_value&quot;: 1.1, &quot;ts&quot;: &quot;2024-02-06 11:06:41&quot;, &quot;vals&quot;: &quot;&lt;Numbers -800&lt;=v&lt;=400&gt;&quot;, &quot;instrument&quot;: &quot;qcodes.instrument_drivers.mock_instruments.DummyInstrument&quot;, &quot;instrument_name&quot;: &quot;dac&quot;, &quot;inter_delay&quot;: 0, &quot;unit&quot;: &quot;V&quot;, &quot;post_delay&quot;: 0, &quot;validators&quot;: [&quot;&lt;Numbers -800&lt;=v&lt;=400&gt;&quot;], &quot;label&quot;: &quot;Gate ch1&quot;, &quot;name&quot;: &quot;ch1&quot;}, &quot;ch2&quot;: {&quot;__class__&quot;: &quot;qcodes.parameters.parameter.Parameter&quot;, &quot;full_name&quot;: &quot;dac_ch2&quot;, &quot;value&quot;: 0, &quot;raw_value&quot;: 0, &quot;ts&quot;: &quot;2024-02-06 11:06:41&quot;, &quot;vals&quot;: &quot;&lt;Numbers -800&lt;=v&lt;=400&gt;&quot;, &quot;instrument&quot;: &quot;qcodes.instrument_drivers.mock_instruments.DummyInstrument&quot;, &quot;instrument_name&quot;: &quot;dac&quot;, &quot;inter_delay&quot;: 0, &quot;unit&quot;: &quot;V&quot;, &quot;post_delay&quot;: 0, &quot;validators&quot;: [&quot;&lt;Numbers -800&lt;=v&lt;=400&gt;&quot;], &quot;label&quot;: &quot;Gate ch2&quot;, &quot;name&quot;: &quot;ch2&quot;}}, &quot;__class__&quot;: &quot;qcodes.instrument_drivers.mock_instruments.DummyInstrument&quot;, &quot;name&quot;: &quot;dac&quot;, &quot;label&quot;: &quot;dac&quot;}, &quot;dmm&quot;: {&quot;functions&quot;: {}, &quot;submodules&quot;: {}, &quot;parameters&quot;: {&quot;IDN&quot;: {&quot;__class__&quot;: &quot;qcodes.parameters.parameter.Parameter&quot;, &quot;full_name&quot;: &quot;dmm_IDN&quot;, &quot;value&quot;: {&quot;vendor&quot;: &quot;QCoDeS&quot;, &quot;model&quot;: &quot;&lt;class &#x27;qcodes.instrument_drivers.mock_instruments.DummyInstrumentWithMeasurement&#x27;&gt;&quot;, &quot;serial&quot;: &quot;NA&quot;, &quot;firmware&quot;: &quot;NA&quot;}, &quot;raw_value&quot;: {&quot;vendor&quot;: &quot;QCoDeS&quot;, &quot;model&quot;: &quot;&lt;class &#x27;qcodes.instrument_drivers.mock_instruments.DummyInstrumentWithMeasurement&#x27;&gt;&quot;, &quot;serial&quot;: &quot;NA&quot;, &quot;firmware&quot;: &quot;NA&quot;}, &quot;ts&quot;: &quot;2024-02-06 11:06:41&quot;, &quot;vals&quot;: &quot;&lt;Anything&gt;&quot;, &quot;instrument&quot;: &quot;qcodes.instrument_drivers.mock_instruments.DummyInstrumentWithMeasurement&quot;, &quot;instrument_name&quot;: &quot;dmm&quot;, &quot;inter_delay&quot;: 0, &quot;unit&quot;: &quot;&quot;, &quot;post_delay&quot;: 0, &quot;validators&quot;: [&quot;&lt;Anything&gt;&quot;], &quot;label&quot;: &quot;IDN&quot;, &quot;name&quot;: &quot;IDN&quot;}, &quot;v1&quot;: {&quot;__class__&quot;: &quot;qcodes.instrument_drivers.mock_instruments.DmmExponentialParameter&quot;, &quot;full_name&quot;: &quot;dmm_v1&quot;, &quot;value&quot;: 3.8786413447969306, &quot;raw_value&quot;: 3.8786413447969306, &quot;ts&quot;: &quot;2024-02-06 11:06:41&quot;, &quot;vals&quot;: &quot;&lt;Numbers -800&lt;=v&lt;=400&gt;&quot;, &quot;instrument&quot;: &quot;qcodes.instrument_drivers.mock_instruments.DummyInstrumentWithMeasurement&quot;, &quot;instrument_name&quot;: &quot;dmm&quot;, &quot;inter_delay&quot;: 0, &quot;unit&quot;: &quot;V&quot;, &quot;post_delay&quot;: 0, &quot;validators&quot;: [&quot;&lt;Numbers -800&lt;=v&lt;=400&gt;&quot;], &quot;label&quot;: &quot;Gate v1&quot;, &quot;name&quot;: &quot;v1&quot;}, &quot;v2&quot;: {&quot;__class__&quot;: &quot;qcodes.instrument_drivers.mock_instruments.DmmGaussParameter&quot;, &quot;full_name&quot;: &quot;dmm_v2&quot;, &quot;value&quot;: -1.704704956867535e-05, &quot;raw_value&quot;: -1.704704956867535e-05, &quot;ts&quot;: &quot;2024-02-06 11:06:41&quot;, &quot;vals&quot;: &quot;&lt;Numbers -800&lt;=v&lt;=400&gt;&quot;, &quot;instrument&quot;: &quot;qcodes.instrument_drivers.mock_instruments.DummyInstrumentWithMeasurement&quot;, &quot;instrument_name&quot;: &quot;dmm&quot;, &quot;inter_delay&quot;: 0, &quot;unit&quot;: &quot;V&quot;, &quot;post_delay&quot;: 0, &quot;validators&quot;: [&quot;&lt;Numbers -800&lt;=v&lt;=400&gt;&quot;], &quot;label&quot;: &quot;Gate v2&quot;, &quot;name&quot;: &quot;v2&quot;}}, &quot;__class__&quot;: &quot;qcodes.instrument_drivers.mock_instruments.DummyInstrumentWithMeasurement&quot;, &quot;name&quot;: &quot;dmm&quot;, &quot;label&quot;: &quot;dmm&quot;}}, &quot;parameters&quot;: {}, &quot;components&quot;: {}, &quot;config&quot;: null}}</dd><dt><span>guid :</span></dt><dd>52ed1f3d-0000-0000-0000-018d7de26889</dd><dt><span>run_timestamp :</span></dt><dd>2024-02-06 11:06:46</dd><dt><span>completed_timestamp :</span></dt><dd>2024-02-06 11:06:46</dd><dt><span>captured_run_id :</span></dt><dd>1</dd><dt><span>captured_counter :</span></dt><dd>1</dd><dt><span>run_id :</span></dt><dd>1</dd><dt><span>run_description :</span></dt><dd>{&quot;version&quot;: 3, &quot;interdependencies&quot;: {&quot;paramspecs&quot;: [{&quot;name&quot;: &quot;dac_ch1&quot;, &quot;paramtype&quot;: &quot;numeric&quot;, &quot;label&quot;: &quot;Gate ch1&quot;, &quot;unit&quot;: &quot;V&quot;, &quot;inferred_from&quot;: [], &quot;depends_on&quot;: []}, {&quot;name&quot;: &quot;dmm_v1&quot;, &quot;paramtype&quot;: &quot;numeric&quot;, &quot;label&quot;: &quot;Gate v1&quot;, &quot;unit&quot;: &quot;V&quot;, &quot;inferred_from&quot;: [], &quot;depends_on&quot;: [&quot;dac_ch1&quot;]}]}, &quot;interdependencies_&quot;: {&quot;parameters&quot;: {&quot;dmm_v1&quot;: {&quot;name&quot;: &quot;dmm_v1&quot;, &quot;paramtype&quot;: &quot;numeric&quot;, &quot;label&quot;: &quot;Gate v1&quot;, &quot;unit&quot;: &quot;V&quot;}, &quot;dac_ch1&quot;: {&quot;name&quot;: &quot;dac_ch1&quot;, &quot;paramtype&quot;: &quot;numeric&quot;, &quot;label&quot;: &quot;Gate ch1&quot;, &quot;unit&quot;: &quot;V&quot;}}, &quot;dependencies&quot;: {&quot;dmm_v1&quot;: [&quot;dac_ch1&quot;]}, &quot;inferences&quot;: {}, &quot;standalones&quot;: []}, &quot;shapes&quot;: null}</dd><dt><span>parent_dataset_links :</span></dt><dd>[]</dd><dt><span>run_timestamp_raw :</span></dt><dd>1707214006.4253306</dd><dt><span>completed_timestamp_raw :</span></dt><dd>1707214006.4373317</dd></dl></div></li></ul></div></div>"
      ],
      "text/plain": [
       "<xarray.Dataset>\n",
       "Dimensions:  (dac_ch1: 10)\n",
       "Coordinates:\n",
       "  * dac_ch1  (dac_ch1) float64 0.0 2.778 5.556 8.333 ... 16.67 19.44 22.22 25.0\n",
       "Data variables:\n",
       "    dmm_v1   (dac_ch1) float64 4.997 2.788 1.724 ... 0.08446 -0.05084 -0.06316\n",
       "Attributes: (12/14)\n",
       "    ds_name:                  context_example\n",
       "    sample_name:              synthetic data\n",
       "    exp_name:                 tutorial_exp\n",
       "    snapshot:                 {\"station\": {\"instruments\": {\"dac\": {\"functions...\n",
       "    guid:                     52ed1f3d-0000-0000-0000-018d7de26889\n",
       "    run_timestamp:            2024-02-06 11:06:46\n",
       "    ...                       ...\n",
       "    captured_counter:         1\n",
       "    run_id:                   1\n",
       "    run_description:          {\"version\": 3, \"interdependencies\": {\"paramspec...\n",
       "    parent_dataset_links:     []\n",
       "    run_timestamp_raw:        1707214006.4253306\n",
       "    completed_timestamp_raw:  1707214006.4373317"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xr_dataset = dataset_1d.to_xarray_dataset()\n",
    "xr_dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We refer to [example notebook on working with pandas](../DataSet/Working-With-Pandas-and-XArray.ipynb) and [Accessing data in DataSet notebook](../DataSet/Accessing-data-in-DataSet.ipynb) for further information."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Explore the data using an interactive widget"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Going beyond text-based review, we have also included a graphical widget to allow the easy exploration of our databases, with an interface for viewing the station snapshot, adding notes, or producing plots of the selected day.  \n",
    "\n",
    "> This widget uses [ipywidgets](https://ipywidgets.readthedocs.io/) to display an interactive elements and is only available when run in a Jupyter notebook. However, we do provide a quick, non-interactive demonstration video below as well.\n",
    "\n",
    "Here we will load our example database that we initialized earlier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1e68d30fdc8b4d018e74833721d1d88b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(HTML(value='<h1>QCoDeS experiments widget</h1>'), Tab(children=(Output(),), selected_index=0, t…"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "experiments_widget(sort_by=\"timestamp\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's a short video that summarizes the looks and the features:\n",
    "\n",
    "![video demo about experiments widget should show here](../../_static/experiments_widget.webp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Further Reading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### QCoDeS configuration  \n",
    "\n",
    "QCoDeS uses a JSON based configuration system. It is shipped with a default configuration. The default config file should not be overwritten. If you have any modifications, you should save the updated config file on your home directory or in the current working directory of your script/notebook. The QCoDeS config system first looks in the current directory for a config file and then in the home directory for one and only then - if no config files are found - it falls back to using the default one. The default config is located in `qcodes.config`. To know how to change and save the config please refer to the [documentation on config](Configuring_QCoDeS.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### QCoDeS instrument drivers\n",
    "We support and provide drivers for most of the instruments currently in use at the Microsoft stations. However, if more functionalities than the ones which are currently supported by drivers are required, one may update the driver or request the features form QCoDeS team. You are more than welcome to contribute and if you would like to have a quick overview on how to write instrument drivers, please refer to the [this notebook](../writing_drivers/Instruments.ipynb) as well as the other [example notebooks on writing drivers](../writing_drivers/index.rst)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### QCoDeS logging\n",
    "\n",
    "In every measurement session, it is highly recommended to have QCoDeS logging turned on. This will allow you to have all the logs in case troubleshooting is required. This feature is detailed further in an [example notebook](../logging/logging_example.ipynb) that describes all the logging features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "303px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {
     "008ddf0133984bfb8888c46f5d695058": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "00e8ffb3845244a69b263719aa57e420": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget046",
       "height": "auto",
       "width": "auto"
      }
     },
     "01c5308aba7a4834a06ba7d593d50d96": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "icon": "edit",
       "layout": "IPY_MODEL_6f13da93851f435fbf89903b1ed02702",
       "style": "IPY_MODEL_60158740f5f0440095a2278b8d81ec3f"
      }
     },
     "02688342bee349bc9a502c61bb6e54ee": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "027edb7bd197485586016be56b28afb4": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget010",
       "height": "auto",
       "width": "auto"
      }
     },
     "0330ce9fffd7464caffa02c5d562098c": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "05e2e78c0d2c4af59f6aeb5ab39ca3fc": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget020",
       "height": "auto",
       "width": "auto"
      }
     },
     "05fbe214ed884567b0212aeb6ad38a0a": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "layout": "IPY_MODEL_370bc6b7b21b478a85f61f18a6c6a034",
       "style": "IPY_MODEL_d83c36d75ef543f4bb1ccb50d195f49a",
       "value": "<h1>QCoDeS experiments widget</h1>"
      }
     },
     "0758a9c24fc3440c8e968c62f31a7aee": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "warning",
       "icon": "camera",
       "layout": "IPY_MODEL_3289abae8cbe4c34a56c50c280401346",
       "style": "IPY_MODEL_af39bcabe6244aafacaa554d7ab085ad",
       "tooltip": "Click to open this DataSet's snapshot in a tab above."
      }
     },
     "087a4a428a0f461c87b6cf60b76af561": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "0998dc2dfb684c82a0633ff940213a61": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "0ec061fdd0984e39b910f7ea0c48de13": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "0f2fddf476f745418a9df990f3f9a17a": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_0f426dbd46ed4ff686df6a573db07695"
       ],
       "layout": "IPY_MODEL_a9a391a937474c00ba4514a693a42635"
      }
     },
     "0f426dbd46ed4ff686df6a573db07695": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "icon": "edit",
       "layout": "IPY_MODEL_3039df826f914e1ea3cb775b4011b637",
       "style": "IPY_MODEL_b37660c9d149494aa9371319fc292fd3"
      }
     },
     "11a1a2ed661448f08f2109ad060497d1": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "warning",
       "icon": "camera",
       "layout": "IPY_MODEL_4c2c1ae6ea114479bed03156c71c888e",
       "style": "IPY_MODEL_4feabc18c39e4c23882501b1cc8afdfb",
       "tooltip": "Click to open this DataSet's snapshot in a tab above."
      }
     },
     "11f36f64bd59439387d7fa3db19f9d8a": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "128c6dfe8a9b4632bac7b876e8733f5c": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_a4b814ec91c04f688f4230e39b97551e"
       ],
       "layout": "IPY_MODEL_836e42125ddc48cc99d9ffd5ddf46fde"
      }
     },
     "12eaf3cff0824f5c994119746663e6c5": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget030",
       "height": "auto",
       "width": "auto"
      }
     },
     "147a4371064548de81777aadd9c1f6a7": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "14d6182280524c0f8a601a1bd1401858": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "15bc1b86c6fd40cc8a31c0d5208d2bac": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget032",
       "height": "auto",
       "width": "auto"
      }
     },
     "17287d588695469280f7a39b7703e46b": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_a9f1e7056ce64610b0eb3c4e9971656d"
       ],
       "layout": "IPY_MODEL_79e9d94197fa4493bffb5d98f85f95ac"
      }
     },
     "17d57a0564024383bbd6aedbe1940f9c": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "17e4fbccde4b460891c6c007b5c488a7": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "LabelModel",
      "state": {
       "layout": "IPY_MODEL_76a18359864348e0800558a63cdfb878",
       "style": "IPY_MODEL_bc2b8395fdbd4f889065a725730a32be"
      }
     },
     "1c3baf314eba4800b40f84db936d58d4": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "description_width": ""
      }
     },
     "2087c7b2d7674693bc40e3d4da5ff819": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget014",
       "height": "auto",
       "width": "auto"
      }
     },
     "20afd2c3b678489cb964ae40472c737c": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_a682f0c022634160adc91e0ed91c956a"
       ],
       "layout": "IPY_MODEL_3478ba9ca5124a82bf82ab72e93baa65"
      }
     },
     "20d63f170ff546b5a018a4e29a3ec5f6": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "216867e27c504bd7a4da7dbc01446e67": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget004",
       "height": "auto",
       "width": "auto"
      }
     },
     "2432aad361bd4f379eec5092b2132e42": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "25395f04f24e4bbc828c09052c8c29b0": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "25b2ffc8c9494339969339d9d4e8b43a": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_b63216b564384249886f456c0c5ecd19",
        "IPY_MODEL_cf7733e6a54849ea96225d63f3c8054d",
        "IPY_MODEL_2ed4c3dca6164f1ba10671765a24523f"
       ],
       "layout": "IPY_MODEL_e361a4ef4c854ee0b1ec0a37d01e7164"
      }
     },
     "27d69751bb064d5ebd2531f627b3946b": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "description": "6",
       "layout": "IPY_MODEL_ad3070cca3b14fb79f6aac004563f550",
       "style": "IPY_MODEL_93a16beb2eec495f9f2943bdeec97363",
       "tooltip": "6"
      }
     },
     "29c80aa1ee57452886fc32dd1b400413": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_4942910b4da94d808aaec177bd3b7b24"
       ],
       "layout": "IPY_MODEL_4c4bdf687f8248b6b185b4eba85f18ad"
      }
     },
     "2afb6a62ad5e40a2a7715b5595c06625": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "2b104c0aa79b44f7841cb76cb108f5ee": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "2dd62d894bef4b368b947b67c37c4342": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget019",
       "height": "max-content",
       "width": "auto"
      }
     },
     "2df53c8863e943caa7f8d5da6022233b": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "2ed4c3dca6164f1ba10671765a24523f": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "layout": "IPY_MODEL_0330ce9fffd7464caffa02c5d562098c",
       "style": "IPY_MODEL_de7788c7155c467ea88a16c58917e9c9",
       "value": " 400/400 [00:06&lt;00:00, 57.81it/s]"
      }
     },
     "2f18d8ea405147498982202832c3c736": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_aaf1bb2548144c0bb8266a610fbb7eae"
       ],
       "layout": "IPY_MODEL_05e2e78c0d2c4af59f6aeb5ab39ca3fc"
      }
     },
     "3039df826f914e1ea3cb775b4011b637": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "31598707a34b4ecdbfdb1e8f63afcc97": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "description": "tutorial_exp, synthetic data",
       "layout": "IPY_MODEL_3984994568164be59e3f3518e71fb431",
       "style": "IPY_MODEL_9c96711ff8a34f9796b4082c180d2cd8",
       "tooltip": "tutorial_exp, synthetic data"
      }
     },
     "31beebacd87f46d39a42fb1e57a4f219": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "icon": "edit",
       "layout": "IPY_MODEL_c85ac998e29f46adbaeaf443ba9edfa2",
       "style": "IPY_MODEL_950d86b90c194f9fae88c9174db8c587"
      }
     },
     "3289abae8cbe4c34a56c50c280401346": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget055",
       "height": "auto",
       "width": "auto"
      }
     },
     "328de8905bd04a6289167ea78a0a90f5": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "description": "3",
       "layout": "IPY_MODEL_14d6182280524c0f8a601a1bd1401858",
       "style": "IPY_MODEL_bcce46bc1b8b48bc904f0af11f7b60dd",
       "tooltip": "3"
      }
     },
     "3478ba9ca5124a82bf82ab72e93baa65": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget041",
       "height": "auto",
       "width": "auto"
      }
     },
     "352b62e8ec4049e086334d5677498858": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget040",
       "height": "auto",
       "width": "auto"
      }
     },
     "364e9d753eaa4dfeb8ec9881da4c1c8d": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "warning",
       "icon": "camera",
       "layout": "IPY_MODEL_7f4c13c5522b448c89be9d4a950b8107",
       "style": "IPY_MODEL_768d649ddd3b4b55bb09211c74d3e422",
       "tooltip": "Click to open this DataSet's snapshot in a tab above."
      }
     },
     "370bc6b7b21b478a85f61f18a6c6a034": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "37a44d09d04a4575b1406d0580acdcaf": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "info",
       "description": "MSMT Time",
       "layout": "IPY_MODEL_b7a8758809594a4e9460394e891923e4",
       "style": "IPY_MODEL_2df53c8863e943caa7f8d5da6022233b",
       "tooltip": "MSMT Time"
      }
     },
     "39831ad08d2a4c3e94af53d0e0c6888c": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "LabelModel",
      "state": {
       "layout": "IPY_MODEL_6ad129a08aa54e408fffcf1a9abddfdf",
       "style": "IPY_MODEL_a3e80aceaf6348a8b263e204c59fda50",
       "value": "dond_example"
      }
     },
     "3984994568164be59e3f3518e71fb431": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "3a7f26d3693d4ca9ae4b56d57c86d878": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "3cc263f6c9ee40f6b9062d631492b9b7": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_ed09e15f352b40b79fdfc02f281dbd69"
       ],
       "layout": "IPY_MODEL_7918e60c97a044fab57c4ad53cda47a2"
      }
     },
     "3d4b3aa3a28b4308a43c7acf685a4964": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "warning",
       "icon": "line-chart",
       "layout": "IPY_MODEL_b3d7726d6dba4ee3aebe9a4e710db51d",
       "style": "IPY_MODEL_a1ab6035508244e0bed7ac261c82e52c",
       "tooltip": "Click to open this DataSet's plot in a tab above."
      }
     },
     "3dafea22bc1246b89cfd2b796d6225fa": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget029",
       "height": "auto",
       "width": "auto"
      }
     },
     "3db7546506d54ab8b0c36f3217d914c4": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "3e24e41d532d4ed5a8140e59fa5529e6": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_d483c40cff4f4ab5b3e4187962bd084a"
       ],
       "layout": "IPY_MODEL_b8a994c9f2dd42cfb53b050e7e8ef18a"
      }
     },
     "3ecee6abbf7a47d3938943810b927503": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget021",
       "height": "auto",
       "width": "auto"
      }
     },
     "3ff70e610ed14a0a862adf4b2e45c3b8": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ProgressStyleModel",
      "state": {
       "description_width": ""
      }
     },
     "41aa75a2062d48a59a1e68d04e0b68fc": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "description": "2022-02-28 11:57:34",
       "layout": "IPY_MODEL_6fad272d9bda43159aea01dd2edcbb74",
       "style": "IPY_MODEL_b615332aa8fb43f39d2367f4aee425b2",
       "tooltip": "2022-02-28 11:57:34"
      }
     },
     "433081ea78ac4c9a9bc383de1de7fa81": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "4675b457d4f64f64b74fbd5fe7c5a96b": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget027",
       "height": "max-content",
       "width": "auto"
      }
     },
     "481220ee79594e3ca1a159a30e8a9d22": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "4942910b4da94d808aaec177bd3b7b24": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "icon": "edit",
       "layout": "IPY_MODEL_0998dc2dfb684c82a0633ff940213a61",
       "style": "IPY_MODEL_25395f04f24e4bbc828c09052c8c29b0"
      }
     },
     "4b266435b6db498e839a0ec12bd4ac82": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "warning",
       "icon": "camera",
       "layout": "IPY_MODEL_eb389048b3c34b08bc4e0f23a11fe16c",
       "style": "IPY_MODEL_3db7546506d54ab8b0c36f3217d914c4",
       "tooltip": "Click to open this DataSet's snapshot in a tab above."
      }
     },
     "4bf3ee61043f45348c91c7a650bcc93b": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget035",
       "height": "max-content",
       "width": "auto"
      }
     },
     "4c1c6c2e1292438cb04f14e599414cfa": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "info",
       "description": "Parameters",
       "layout": "IPY_MODEL_216867e27c504bd7a4da7dbc01446e67",
       "style": "IPY_MODEL_cb94d7f63f924bc7b36f93bd1403f579",
       "tooltip": "Parameters"
      }
     },
     "4c2c1ae6ea114479bed03156c71c888e": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget023",
       "height": "auto",
       "width": "auto"
      }
     },
     "4c4bdf687f8248b6b185b4eba85f18ad": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget054",
       "height": "auto",
       "width": "auto"
      }
     },
     "4c9f8e7a3d2b431b80051c830bc71bb1": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "warning",
       "icon": "camera",
       "layout": "IPY_MODEL_b828d008f3854a479c70a31c27e43bf2",
       "style": "IPY_MODEL_a598e9bbbf8c48afba9d3cf03bbcbd48",
       "tooltip": "Click to open this DataSet's snapshot in a tab above."
      }
     },
     "4d55591a0ef14ee6a003e464c21c7f0d": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "4f78af3dcb46462aa16655a24bf8b250": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "4fe14145069c469e84a642a596b91845": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "LabelModel",
      "state": {
       "layout": "IPY_MODEL_4675b457d4f64f64b74fbd5fe7c5a96b",
       "style": "IPY_MODEL_e2cf8578ecce4cb39578018f0498b6f5",
       "value": "dond_example"
      }
     },
     "4feabc18c39e4c23882501b1cc8afdfb": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "500f85484279432e80de8f4071fd92cb": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_9883da4c05f94777b2eb7bc2293a9963"
       ],
       "layout": "IPY_MODEL_b14f6772770e48ff96afbf70963ef0c9"
      }
     },
     "50594a62720045d489ec923113165026": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_6aa71e1ad22a49c9a2be50350a3c1012"
       ],
       "layout": "IPY_MODEL_d614d4ac5e97484db1e29f088d5ba152"
      }
     },
     "54008a8d811948699b21e8301550f815": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "description_width": ""
      }
     },
     "56b1b64ec7e745b3b2bb4e37d7643928": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget051",
       "height": "max-content",
       "width": "auto"
      }
     },
     "5757ab66a05f4916a063887fe59a0651": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "description": "2022-02-28 11:57:48",
       "layout": "IPY_MODEL_9f3f130dc9ce4ffbb7c435868cb6dd16",
       "style": "IPY_MODEL_e99a0e3dcbe944b893935efc759bc860",
       "tooltip": "2022-02-28 11:57:48"
      }
     },
     "576daa673aab4968941ae09c8579b77a": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget001",
       "height": "auto",
       "width": "auto"
      }
     },
     "5af9f35ecadb492fa6135c78efcf5643": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget003",
       "height": "auto",
       "width": "auto"
      }
     },
     "5c848bf7d44a4aaa9a76da7b3846b54b": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget006",
       "height": "auto",
       "width": "auto"
      }
     },
     "5eb33b3a7349456a893912bc050c5c98": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "LabelModel",
      "state": {
       "layout": "IPY_MODEL_4bf3ee61043f45348c91c7a650bcc93b",
       "style": "IPY_MODEL_dc41b8c20b924c69992aab2679c7281e",
       "value": "dond_example"
      }
     },
     "600eeff88ef94a20a9375ac6607b06aa": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "description": "2022-02-28 11:57:18",
       "layout": "IPY_MODEL_4f78af3dcb46462aa16655a24bf8b250",
       "style": "IPY_MODEL_bee6ade5f7934ae4b23262a0d1a1dc84",
       "tooltip": "2022-02-28 11:57:18"
      }
     },
     "60158740f5f0440095a2278b8d81ec3f": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "6084fbc7289d401da56bac80499dffc2": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget007",
       "height": "auto",
       "width": "auto"
      }
     },
     "6103c51820214fe2b5bd5374d27240c0": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "info",
       "description": "Plot",
       "layout": "IPY_MODEL_a4973b84eb104dea9e09732e1531ce99",
       "style": "IPY_MODEL_d84dfa93d8b247389969068a5f5a4b78",
       "tooltip": "Plot"
      }
     },
     "6128db78834e4611a710751ff1843dd6": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "LabelModel",
      "state": {
       "layout": "IPY_MODEL_56b1b64ec7e745b3b2bb4e37d7643928",
       "style": "IPY_MODEL_7e292ab8c3be488a9aac132b74eaf946",
       "value": "context_example"
      }
     },
     "6268f62313a64bd98783343a7c1f3fdd": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "description_width": ""
      }
     },
     "63b8ece8d4224a73aa9e5f723cd5a479": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget002",
       "height": "auto",
       "width": "auto"
      }
     },
     "64a3ee4e99754041b17f9b632e0e5dae": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "warning",
       "icon": "line-chart",
       "layout": "IPY_MODEL_e1eed0df78eb4eeb86f34ed3bfbf8ffd",
       "style": "IPY_MODEL_2b104c0aa79b44f7841cb76cb108f5ee",
       "tooltip": "Click to open this DataSet's plot in a tab above."
      }
     },
     "65447e8bc1d74eeab6ebfe275a2fdc32": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_b5bbe4a29c0c444e9d4ecd80c1668b70"
       ],
       "layout": "IPY_MODEL_8cee26896bdd490b93e2a2dd207d0776"
      }
     },
     "65e6bfef31824c1b85671ac123f090b5": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "67d5af1564084e268809bf0ba16a61c6": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_01c5308aba7a4834a06ba7d593d50d96"
       ],
       "layout": "IPY_MODEL_888e5650f5ba41408c0475552930a6e0"
      }
     },
     "681e09b457094933bde4c581d85c2719": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "description": "tutorial_exp, synthetic data",
       "layout": "IPY_MODEL_17d57a0564024383bbd6aedbe1940f9c",
       "style": "IPY_MODEL_9798fd1d5b784282a4067130d17106ab",
       "tooltip": "tutorial_exp, synthetic data"
      }
     },
     "6a53dc39b2aa4e7e957211cf5b35152d": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "6aa71e1ad22a49c9a2be50350a3c1012": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "description": "1",
       "layout": "IPY_MODEL_e7af9982173649ad8a6797293d609c8d",
       "style": "IPY_MODEL_65e6bfef31824c1b85671ac123f090b5",
       "tooltip": "1"
      }
     },
     "6ad129a08aa54e408fffcf1a9abddfdf": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget011",
       "height": "max-content",
       "width": "auto"
      }
     },
     "6b7d6b9e26c5435d85926636f980a776": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "description": "4",
       "layout": "IPY_MODEL_9981f390cc1140f6bf17a580b573eff4",
       "style": "IPY_MODEL_b37af9f4b6f041d1b34dce053d385c75",
       "tooltip": "4"
      }
     },
     "6d344637ec104ebb8a7aedb0fa28143f": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "6e80b6ef8d1d45ba996c923654206427": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "6ecb7c4aa402438e8c9e65d44d8c2921": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "6f13da93851f435fbf89903b1ed02702": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "6fad272d9bda43159aea01dd2edcbb74": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "71565ef3c8a84f58a7d456767a839514": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_41aa75a2062d48a59a1e68d04e0b68fc"
       ],
       "layout": "IPY_MODEL_d12d6cd5d1d54ce8a282a68cc8a5a9d8"
      }
     },
     "71f1f29cb08949b0b9f017e939047944": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "720a389ba6924e4984fd697ccbd9667b": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "731f2af140e540c18d8a56b71b291936": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "7357e0d879594701a22ccce54abffa05": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget053",
       "height": "auto",
       "width": "auto"
      }
     },
     "7382c646755a4e70ac7b9efe408b4ce3": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget013",
       "height": "auto",
       "width": "auto"
      }
     },
     "768d649ddd3b4b55bb09211c74d3e422": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "769165c9bf5c4cddb0d476d369300714": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "warning",
       "icon": "camera",
       "layout": "IPY_MODEL_91bf4503f19a45d5b44fc80b38dc3499",
       "style": "IPY_MODEL_2432aad361bd4f379eec5092b2132e42",
       "tooltip": "Click to open this DataSet's snapshot in a tab above."
      }
     },
     "76a18359864348e0800558a63cdfb878": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "max-content",
       "width": "auto"
      }
     },
     "76d07c2430f04baca1f727fc1f760f6d": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "info",
       "description": "Snapshot",
       "layout": "IPY_MODEL_6084fbc7289d401da56bac80499dffc2",
       "style": "IPY_MODEL_6e80b6ef8d1d45ba996c923654206427",
       "tooltip": "Snapshot"
      }
     },
     "78afa3e8e4554bd8aedbfb22a12005c7": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "7918e60c97a044fab57c4ad53cda47a2": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget028",
       "height": "auto",
       "width": "auto"
      }
     },
     "79e9d94197fa4493bffb5d98f85f95ac": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget017",
       "height": "auto",
       "width": "auto"
      }
     },
     "7c5edfb2e3c94d6f8aef4698e9933a22": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "7e292ab8c3be488a9aac132b74eaf946": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "description_width": ""
      }
     },
     "7e5f5164f5a140bd82a5b5f0a59fb861": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget034",
       "height": "auto",
       "width": "auto"
      }
     },
     "7e5fce5ea8d5486d80199bb76a7c3fb6": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "7f4c13c5522b448c89be9d4a950b8107": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget047",
       "height": "auto",
       "width": "auto"
      }
     },
     "7fb184f5049f4ba5b37178ac0b7f94df": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "8129f9ad5dd14e94a82e68a6c1393dfb": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget025",
       "height": "auto",
       "width": "auto"
      }
     },
     "836e42125ddc48cc99d9ffd5ddf46fde": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget036",
       "height": "auto",
       "width": "auto"
      }
     },
     "84ec39515cd9437b8057d26629056a06": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget024",
       "height": "auto",
       "width": "auto"
      }
     },
     "858137f00e7e4b2ba96cd8616e65e6b3": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_template_areas": "\"widget001 widget002 widget003 widget004 widget005 widget006 widget007 widget008\"\n\"widget009 widget010 widget011 widget012 widget013 widget014 widget015 widget016\"\n\"widget017 widget018 widget019 widget020 widget021 widget022 widget023 widget024\"\n\"widget025 widget026 widget027 widget028 widget029 widget030 widget031 widget032\"\n\"widget033 widget034 widget035 widget036 widget037 widget038 widget039 widget040\"\n\"widget041 widget042 widget043 widget044 widget045 widget046 widget047 widget048\"\n\"widget049 widget050 widget051 widget052 widget053 widget054 widget055 widget056\"",
       "grid_template_columns": "auto auto auto auto auto auto auto auto ",
       "grid_template_rows": "auto auto auto auto auto auto auto "
      }
     },
     "888e5650f5ba41408c0475552930a6e0": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget022",
       "height": "auto",
       "width": "auto"
      }
     },
     "88a3c74eada245d8b7ed05a6a78831ea": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "GridBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_ae6e85c41c494f6bbd0286a039d06119",
        "IPY_MODEL_c7add74fd66347de8ccdce40c7bee9ca",
        "IPY_MODEL_c94967c21c4f46838ed3a89531ba0a3e",
        "IPY_MODEL_4c1c6c2e1292438cb04f14e599414cfa",
        "IPY_MODEL_37a44d09d04a4575b1406d0580acdcaf",
        "IPY_MODEL_bce8868b7d94494fa665b444770cf1c5",
        "IPY_MODEL_76d07c2430f04baca1f727fc1f760f6d",
        "IPY_MODEL_6103c51820214fe2b5bd5374d27240c0",
        "IPY_MODEL_c4ca49a25e6d44879d705e24e9df03a9",
        "IPY_MODEL_e67d35fed95848e4a0b80fd98087a131",
        "IPY_MODEL_39831ad08d2a4c3e94af53d0e0c6888c",
        "IPY_MODEL_3e24e41d532d4ed5a8140e59fa5529e6",
        "IPY_MODEL_ffc8993272bf46e8be30f12153456757",
        "IPY_MODEL_996917dfe6184aea9ef602b762a47bcf",
        "IPY_MODEL_769165c9bf5c4cddb0d476d369300714",
        "IPY_MODEL_64a3ee4e99754041b17f9b632e0e5dae",
        "IPY_MODEL_17287d588695469280f7a39b7703e46b",
        "IPY_MODEL_c46238bd7f3b4b9c8884da9a418f9ccd",
        "IPY_MODEL_aac6d11c846c4b01bf89ea58cf34fd27",
        "IPY_MODEL_2f18d8ea405147498982202832c3c736",
        "IPY_MODEL_c97eb54facfe4b339ab99f54dbfbb796",
        "IPY_MODEL_67d5af1564084e268809bf0ba16a61c6",
        "IPY_MODEL_11a1a2ed661448f08f2109ad060497d1",
        "IPY_MODEL_e2485b5ac3614c1197eb3135562fa83e",
        "IPY_MODEL_ee4acd3ed9a24667bac0c5acc85e722b",
        "IPY_MODEL_b49bffa0c4a34ca2a2dde3b9be38d95c",
        "IPY_MODEL_4fe14145069c469e84a642a596b91845",
        "IPY_MODEL_3cc263f6c9ee40f6b9062d631492b9b7",
        "IPY_MODEL_cd2ef4071aae4d17a1b9702d2c23d312",
        "IPY_MODEL_f6b8a96d1e1149b2883669b4a95f8387",
        "IPY_MODEL_4b266435b6db498e839a0ec12bd4ac82",
        "IPY_MODEL_eab9b815257f48bab9cfb2fe8ab93b64",
        "IPY_MODEL_a44f4f88c4a04c3facf2f15e27abfba4",
        "IPY_MODEL_f4e1e0c09f214497b9d2bfc115b83e89",
        "IPY_MODEL_5eb33b3a7349456a893912bc050c5c98",
        "IPY_MODEL_128c6dfe8a9b4632bac7b876e8733f5c",
        "IPY_MODEL_71565ef3c8a84f58a7d456767a839514",
        "IPY_MODEL_0f2fddf476f745418a9df990f3f9a17a",
        "IPY_MODEL_4c9f8e7a3d2b431b80051c830bc71bb1",
        "IPY_MODEL_f2b41bc3a74f460dad79fa06305b5e4f",
        "IPY_MODEL_20afd2c3b678489cb964ae40472c737c",
        "IPY_MODEL_65447e8bc1d74eeab6ebfe275a2fdc32",
        "IPY_MODEL_8af7b96fbf8c42228d8426770abc2613",
        "IPY_MODEL_c45c167917f7489a844e3573493b7211",
        "IPY_MODEL_acac18f21e0b4da794c3980ed47fb4c7",
        "IPY_MODEL_bada311a0fcb4406881476130de7c38d",
        "IPY_MODEL_364e9d753eaa4dfeb8ec9881da4c1c8d",
        "IPY_MODEL_3d4b3aa3a28b4308a43c7acf685a4964",
        "IPY_MODEL_50594a62720045d489ec923113165026",
        "IPY_MODEL_e855dc5b6d6e4594b44ae704cf1cf2e1",
        "IPY_MODEL_6128db78834e4611a710751ff1843dd6",
        "IPY_MODEL_500f85484279432e80de8f4071fd92cb",
        "IPY_MODEL_e13caf1ab6d94a5c992a67cf00ac43e5",
        "IPY_MODEL_29c80aa1ee57452886fc32dd1b400413",
        "IPY_MODEL_0758a9c24fc3440c8e968c62f31a7aee",
        "IPY_MODEL_f0bb28f962404affadbaf4ee029d2a96"
       ],
       "layout": "IPY_MODEL_858137f00e7e4b2ba96cd8616e65e6b3"
      }
     },
     "891a18026b88422cbc2a517068849312": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget045",
       "height": "auto",
       "width": "auto"
      }
     },
     "8af7b96fbf8c42228d8426770abc2613": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "LabelModel",
      "state": {
       "layout": "IPY_MODEL_e3958e59bac849108b4aab3aeedc8360",
       "style": "IPY_MODEL_1c3baf314eba4800b40f84db936d58d4",
       "value": "dond_example"
      }
     },
     "8cc1824d659a403a888f975970e3a55d": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget018",
       "height": "auto",
       "width": "auto"
      }
     },
     "8cee26896bdd490b93e2a2dd207d0776": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget042",
       "height": "auto",
       "width": "auto"
      }
     },
     "91bf4503f19a45d5b44fc80b38dc3499": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget015",
       "height": "auto",
       "width": "auto"
      }
     },
     "93a16beb2eec495f9f2943bdeec97363": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "943b52812bca401c936cd1e04511633b": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "950d86b90c194f9fae88c9174db8c587": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "9798fd1d5b784282a4067130d17106ab": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "9870bec495844367b10e415e6b15dbaf": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "9883da4c05f94777b2eb7bc2293a9963": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "description": "dac_ch1,dmm_v1",
       "layout": "IPY_MODEL_9870bec495844367b10e415e6b15dbaf",
       "style": "IPY_MODEL_147a4371064548de81777aadd9c1f6a7",
       "tooltip": "dac_ch1,dmm_v1"
      }
     },
     "996917dfe6184aea9ef602b762a47bcf": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_c1fa2c45fb054cad815c361f2439de5d"
       ],
       "layout": "IPY_MODEL_2087c7b2d7674693bc40e3d4da5ff819"
      }
     },
     "9981f390cc1140f6bf17a580b573eff4": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "9b74947de3884b84806dbe3d95024955": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "9c96711ff8a34f9796b4082c180d2cd8": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "9cf0ea6c7dd2485895405871e2a7d2eb": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "9f3f130dc9ce4ffbb7c435868cb6dd16": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "9fffbfde565841b9a4717c042fe38e33": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "a146a24c7e644eb38b94aab50ced4c5e": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget026",
       "height": "auto",
       "width": "auto"
      }
     },
     "a1ab6035508244e0bed7ac261c82e52c": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "a24c6f2ee1664ba29dc38dc342a7e3ea": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "description": "tutorial_exp, synthetic data",
       "layout": "IPY_MODEL_7fb184f5049f4ba5b37178ac0b7f94df",
       "style": "IPY_MODEL_6a53dc39b2aa4e7e957211cf5b35152d",
       "tooltip": "tutorial_exp, synthetic data"
      }
     },
     "a3e80aceaf6348a8b263e204c59fda50": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "description_width": ""
      }
     },
     "a44f4f88c4a04c3facf2f15e27abfba4": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_328de8905bd04a6289167ea78a0a90f5"
       ],
       "layout": "IPY_MODEL_cfeb9d204da34f7897c14f93905630ae"
      }
     },
     "a4973b84eb104dea9e09732e1531ce99": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget008",
       "height": "auto",
       "width": "auto"
      }
     },
     "a4a3bbfad58043a991e52aedb63166e8": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "a4b814ec91c04f688f4230e39b97551e": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "description": "dac_ch1,dac_ch2,dmm_v1,dmm_v2",
       "layout": "IPY_MODEL_e1a3d66b73d24140bc71fcebdaa11f9f",
       "style": "IPY_MODEL_f489ac4b8fc34138b9609c095d6b690f",
       "tooltip": "dac_ch1,dac_ch2,dmm_v1,dmm_v2"
      }
     },
     "a598e9bbbf8c48afba9d3cf03bbcbd48": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "a682f0c022634160adc91e0ed91c956a": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "description": "2",
       "layout": "IPY_MODEL_9cf0ea6c7dd2485895405871e2a7d2eb",
       "style": "IPY_MODEL_008ddf0133984bfb8888c46f5d695058",
       "tooltip": "2"
      }
     },
     "a7f6501890af4745af2757af8eaeab41": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "icon": "edit",
       "layout": "IPY_MODEL_71f1f29cb08949b0b9f017e939047944",
       "style": "IPY_MODEL_d348013b254b43e09ec0f29dd2fbca8f"
      }
     },
     "a986474758014596ad5947f258d45d9b": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "description": "2022-02-28 11:57:16",
       "layout": "IPY_MODEL_731f2af140e540c18d8a56b71b291936",
       "style": "IPY_MODEL_dbe915b15eec4fe4adee4476082cfeaf",
       "tooltip": "2022-02-28 11:57:16"
      }
     },
     "a9a391a937474c00ba4514a693a42635": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget038",
       "height": "auto",
       "width": "auto"
      }
     },
     "a9a6761b89a249d098581e39120a3790": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "a9bc1604f489402797e1f8a95b97df18": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "description": "dac_ch1,dac_ch2,dmm_v1,dmm_v2",
       "layout": "IPY_MODEL_eb2c001accf044cf8c745155c55a3716",
       "style": "IPY_MODEL_20d63f170ff546b5a018a4e29a3ec5f6",
       "tooltip": "dac_ch1,dac_ch2,dmm_v1,dmm_v2"
      }
     },
     "a9f1e7056ce64610b0eb3c4e9971656d": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "description": "5",
       "layout": "IPY_MODEL_a9a6761b89a249d098581e39120a3790",
       "style": "IPY_MODEL_a4a3bbfad58043a991e52aedb63166e8",
       "tooltip": "5"
      }
     },
     "aac6d11c846c4b01bf89ea58cf34fd27": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "LabelModel",
      "state": {
       "layout": "IPY_MODEL_2dd62d894bef4b368b947b67c37c4342",
       "style": "IPY_MODEL_6268f62313a64bd98783343a7c1f3fdd",
       "value": "context_example"
      }
     },
     "aaf1bb2548144c0bb8266a610fbb7eae": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "description": "dac_ch1,dmm_v1",
       "layout": "IPY_MODEL_6d344637ec104ebb8a7aedb0fa28143f",
       "style": "IPY_MODEL_02688342bee349bc9a502c61bb6e54ee",
       "tooltip": "dac_ch1,dmm_v1"
      }
     },
     "aba60a869abd4035a559164540eb6c15": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget056",
       "height": "auto",
       "width": "auto"
      }
     },
     "acac18f21e0b4da794c3980ed47fb4c7": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_600eeff88ef94a20a9375ac6607b06aa"
       ],
       "layout": "IPY_MODEL_891a18026b88422cbc2a517068849312"
      }
     },
     "ad3070cca3b14fb79f6aac004563f550": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "ae6e85c41c494f6bbd0286a039d06119": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "info",
       "description": "Run ID",
       "layout": "IPY_MODEL_576daa673aab4968941ae09c8579b77a",
       "style": "IPY_MODEL_481220ee79594e3ca1a159a30e8a9d22",
       "tooltip": "Run ID"
      }
     },
     "af39bcabe6244aafacaa554d7ab085ad": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "b14f6772770e48ff96afbf70963ef0c9": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget052",
       "height": "auto",
       "width": "auto"
      }
     },
     "b32058de4d0944579546d25e4e3a0188": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget044",
       "height": "auto",
       "width": "auto"
      }
     },
     "b37660c9d149494aa9371319fc292fd3": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "b37af9f4b6f041d1b34dce053d385c75": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "b3d7726d6dba4ee3aebe9a4e710db51d": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget048",
       "height": "auto",
       "width": "auto"
      }
     },
     "b49bffa0c4a34ca2a2dde3b9be38d95c": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_681e09b457094933bde4c581d85c2719"
       ],
       "layout": "IPY_MODEL_a146a24c7e644eb38b94aab50ced4c5e"
      }
     },
     "b54fd1fe98474a69bb255dba8c6a1006": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_05fbe214ed884567b0212aeb6ad38a0a",
        "IPY_MODEL_f151427c40d04719a62d3dcc22288640",
        "IPY_MODEL_88a3c74eada245d8b7ed05a6a78831ea"
       ],
       "layout": "IPY_MODEL_fa2fc00423c0469f8feca94694951afc"
      }
     },
     "b5bbe4a29c0c444e9d4ecd80c1668b70": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "description": "tutorial_exp, synthetic data",
       "layout": "IPY_MODEL_e204dd991a30448e8e5d3479fd26f06d",
       "style": "IPY_MODEL_edf44fb784734c87b3c2c8aea6694f9d",
       "tooltip": "tutorial_exp, synthetic data"
      }
     },
     "b615332aa8fb43f39d2367f4aee425b2": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "b63216b564384249886f456c0c5ecd19": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "layout": "IPY_MODEL_bb0d97f5fbb1404da3de6aba5a2f9368",
       "style": "IPY_MODEL_54008a8d811948699b21e8301550f815",
       "value": "100%"
      }
     },
     "b7a8758809594a4e9460394e891923e4": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget005",
       "height": "auto",
       "width": "auto"
      }
     },
     "b828d008f3854a479c70a31c27e43bf2": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget039",
       "height": "auto",
       "width": "auto"
      }
     },
     "b8a994c9f2dd42cfb53b050e7e8ef18a": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget012",
       "height": "auto",
       "width": "auto"
      }
     },
     "b94a8b118ed74f06b73dc19e43627907": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "bada311a0fcb4406881476130de7c38d": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_31beebacd87f46d39a42fb1e57a4f219"
       ],
       "layout": "IPY_MODEL_00e8ffb3845244a69b263719aa57e420"
      }
     },
     "bb0d97f5fbb1404da3de6aba5a2f9368": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "bc2b8395fdbd4f889065a725730a32be": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "description_width": ""
      }
     },
     "bcce46bc1b8b48bc904f0af11f7b60dd": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "bce8868b7d94494fa665b444770cf1c5": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "info",
       "description": "Notes",
       "layout": "IPY_MODEL_5c848bf7d44a4aaa9a76da7b3846b54b",
       "style": "IPY_MODEL_c9f3fcf3b8e74dceb426eb6bcff9b431",
       "tooltip": "Notes"
      }
     },
     "bee6ade5f7934ae4b23262a0d1a1dc84": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "c0fb5841a2ea4cbc9fbfc40e372151e4": {
      "model_module": "@jupyter-widgets/output",
      "model_module_version": "1.0.0",
      "model_name": "OutputModel",
      "state": {
       "layout": "IPY_MODEL_720a389ba6924e4984fd697ccbd9667b",
       "outputs": [
        {
         "name": "stdout",
         "output_type": "stream",
         "text": "Plots and snapshots will show up here!\n"
        }
       ]
      }
     },
     "c1fa2c45fb054cad815c361f2439de5d": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "icon": "edit",
       "layout": "IPY_MODEL_e35163cdfcda4dc5ae0ec3876057c327",
       "style": "IPY_MODEL_dfdf6f57dcea4564913c3c8a36ffd347"
      }
     },
     "c45c167917f7489a844e3573493b7211": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_a9bc1604f489402797e1f8a95b97df18"
       ],
       "layout": "IPY_MODEL_b32058de4d0944579546d25e4e3a0188"
      }
     },
     "c46238bd7f3b4b9c8884da9a418f9ccd": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_f9dc3eaf321041e083caeb424b5920cc"
       ],
       "layout": "IPY_MODEL_8cc1824d659a403a888f975970e3a55d"
      }
     },
     "c4ca49a25e6d44879d705e24e9df03a9": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_27d69751bb064d5ebd2531f627b3946b"
       ],
       "layout": "IPY_MODEL_cc96f92055f74718b3def912a9c1b664"
      }
     },
     "c61bb50525844b1b8093bc304377dba4": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "c6856c062e80496dbcc3706af459011e": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "c7add74fd66347de8ccdce40c7bee9ca": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "info",
       "description": "Experiment",
       "layout": "IPY_MODEL_63b8ece8d4224a73aa9e5f723cd5a479",
       "style": "IPY_MODEL_3a7f26d3693d4ca9ae4b56d57c86d878",
       "tooltip": "Experiment"
      }
     },
     "c85ac998e29f46adbaeaf443ba9edfa2": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "c94967c21c4f46838ed3a89531ba0a3e": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "info",
       "description": "Name",
       "layout": "IPY_MODEL_5af9f35ecadb492fa6135c78efcf5643",
       "style": "IPY_MODEL_9b74947de3884b84806dbe3d95024955",
       "tooltip": "Name"
      }
     },
     "c97eb54facfe4b339ab99f54dbfbb796": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_d7ef591d31f8482b8243a3c50e69ecfe"
       ],
       "layout": "IPY_MODEL_3ecee6abbf7a47d3938943810b927503"
      }
     },
     "c9f3fcf3b8e74dceb426eb6bcff9b431": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "cb94d7f63f924bc7b36f93bd1403f579": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "cc96f92055f74718b3def912a9c1b664": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget009",
       "height": "auto",
       "width": "auto"
      }
     },
     "cd2ef4071aae4d17a1b9702d2c23d312": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_5757ab66a05f4916a063887fe59a0651"
       ],
       "layout": "IPY_MODEL_3dafea22bc1246b89cfd2b796d6225fa"
      }
     },
     "cf7733e6a54849ea96225d63f3c8054d": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "FloatProgressModel",
      "state": {
       "bar_style": "success",
       "layout": "IPY_MODEL_7c5edfb2e3c94d6f8aef4698e9933a22",
       "max": 400,
       "style": "IPY_MODEL_3ff70e610ed14a0a862adf4b2e45c3b8",
       "value": 400
      }
     },
     "cfeb9d204da34f7897c14f93905630ae": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget033",
       "height": "auto",
       "width": "auto"
      }
     },
     "d12d6cd5d1d54ce8a282a68cc8a5a9d8": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget037",
       "height": "auto",
       "width": "auto"
      }
     },
     "d1dbb7c269914b3096ddbe7479c91897": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "d348013b254b43e09ec0f29dd2fbca8f": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "d483c40cff4f4ab5b3e4187962bd084a": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "description": "dac_ch1,dac_ch2,dmm_v1,dmm_v2",
       "layout": "IPY_MODEL_943b52812bca401c936cd1e04511633b",
       "style": "IPY_MODEL_433081ea78ac4c9a9bc383de1de7fa81",
       "tooltip": "dac_ch1,dac_ch2,dmm_v1,dmm_v2"
      }
     },
     "d51c156ef8ee4fb29c371e8405702c21": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "d5898c27e1f94c8b9914cee2bb667122": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "d614d4ac5e97484db1e29f088d5ba152": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget049",
       "height": "auto",
       "width": "auto"
      }
     },
     "d7ef591d31f8482b8243a3c50e69ecfe": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "description": "2022-03-03 12:10:02",
       "layout": "IPY_MODEL_c61bb50525844b1b8093bc304377dba4",
       "style": "IPY_MODEL_0ec061fdd0984e39b910f7ea0c48de13",
       "tooltip": "2022-03-03 12:10:02"
      }
     },
     "d83c36d75ef543f4bb1ccb50d195f49a": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "description_width": ""
      }
     },
     "d84dfa93d8b247389969068a5f5a4b78": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "dbe915b15eec4fe4adee4476082cfeaf": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "dc41b8c20b924c69992aab2679c7281e": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "description_width": ""
      }
     },
     "de7788c7155c467ea88a16c58917e9c9": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "description_width": ""
      }
     },
     "dfdf6f57dcea4564913c3c8a36ffd347": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "e13caf1ab6d94a5c992a67cf00ac43e5": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_a986474758014596ad5947f258d45d9b"
       ],
       "layout": "IPY_MODEL_7357e0d879594701a22ccce54abffa05"
      }
     },
     "e1a3d66b73d24140bc71fcebdaa11f9f": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "e1eed0df78eb4eeb86f34ed3bfbf8ffd": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget016",
       "height": "auto",
       "width": "auto"
      }
     },
     "e204dd991a30448e8e5d3479fd26f06d": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "e2485b5ac3614c1197eb3135562fa83e": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "warning",
       "icon": "line-chart",
       "layout": "IPY_MODEL_84ec39515cd9437b8057d26629056a06",
       "style": "IPY_MODEL_2afb6a62ad5e40a2a7715b5595c06625",
       "tooltip": "Click to open this DataSet's plot in a tab above."
      }
     },
     "e2cf8578ecce4cb39578018f0498b6f5": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "description_width": ""
      }
     },
     "e35163cdfcda4dc5ae0ec3876057c327": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "e361a4ef4c854ee0b1ec0a37d01e7164": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "e3958e59bac849108b4aab3aeedc8360": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget043",
       "height": "max-content",
       "width": "auto"
      }
     },
     "e67d35fed95848e4a0b80fd98087a131": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_f1b4870e7cf74cc981643f003cc7c2e6"
       ],
       "layout": "IPY_MODEL_027edb7bd197485586016be56b28afb4"
      }
     },
     "e7af9982173649ad8a6797293d609c8d": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "e855dc5b6d6e4594b44ae704cf1cf2e1": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_a24c6f2ee1664ba29dc38dc342a7e3ea"
       ],
       "layout": "IPY_MODEL_fa381e10d2474c5f8ce4aac33729ffd9"
      }
     },
     "e99a0e3dcbe944b893935efc759bc860": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "eab9b815257f48bab9cfb2fe8ab93b64": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "warning",
       "icon": "line-chart",
       "layout": "IPY_MODEL_15bc1b86c6fd40cc8a31c0d5208d2bac",
       "style": "IPY_MODEL_11f36f64bd59439387d7fa3db19f9d8a",
       "tooltip": "Click to open this DataSet's plot in a tab above."
      }
     },
     "eb2c001accf044cf8c745155c55a3716": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "auto",
       "width": "auto"
      }
     },
     "eb389048b3c34b08bc4e0f23a11fe16c": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget031",
       "height": "auto",
       "width": "auto"
      }
     },
     "ed09e15f352b40b79fdfc02f281dbd69": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "description": "dac_ch1,dac_ch2,dmm_v1,dmm_v2",
       "layout": "IPY_MODEL_d1dbb7c269914b3096ddbe7479c91897",
       "style": "IPY_MODEL_d5898c27e1f94c8b9914cee2bb667122",
       "tooltip": "dac_ch1,dac_ch2,dmm_v1,dmm_v2"
      }
     },
     "edc7eeb74842474fbe330acc877fd046": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "description": "2022-03-03 12:10:02",
       "layout": "IPY_MODEL_6ecb7c4aa402438e8c9e65d44d8c2921",
       "style": "IPY_MODEL_d51c156ef8ee4fb29c371e8405702c21",
       "tooltip": "2022-03-03 12:10:02"
      }
     },
     "edf44fb784734c87b3c2c8aea6694f9d": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "ee4acd3ed9a24667bac0c5acc85e722b": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_6b7d6b9e26c5435d85926636f980a776"
       ],
       "layout": "IPY_MODEL_8129f9ad5dd14e94a82e68a6c1393dfb"
      }
     },
     "f0bb28f962404affadbaf4ee029d2a96": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "warning",
       "icon": "line-chart",
       "layout": "IPY_MODEL_aba60a869abd4035a559164540eb6c15",
       "style": "IPY_MODEL_7e5fce5ea8d5486d80199bb76a7c3fb6",
       "tooltip": "Click to open this DataSet's plot in a tab above."
      }
     },
     "f151427c40d04719a62d3dcc22288640": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "TabModel",
      "state": {
       "_titles": {
        "0": "Info"
       },
       "children": [
        "IPY_MODEL_c0fb5841a2ea4cbc9fbfc40e372151e4"
       ],
       "layout": "IPY_MODEL_b94a8b118ed74f06b73dc19e43627907"
      }
     },
     "f1b4870e7cf74cc981643f003cc7c2e6": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "description": "tutorial_exp, synthetic data",
       "layout": "IPY_MODEL_c6856c062e80496dbcc3706af459011e",
       "style": "IPY_MODEL_4d55591a0ef14ee6a003e464c21c7f0d",
       "tooltip": "tutorial_exp, synthetic data"
      }
     },
     "f2b41bc3a74f460dad79fa06305b5e4f": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "warning",
       "icon": "line-chart",
       "layout": "IPY_MODEL_352b62e8ec4049e086334d5677498858",
       "style": "IPY_MODEL_087a4a428a0f461c87b6cf60b76af561",
       "tooltip": "Click to open this DataSet's plot in a tab above."
      }
     },
     "f489ac4b8fc34138b9609c095d6b690f": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonStyleModel",
      "state": {}
     },
     "f4e1e0c09f214497b9d2bfc115b83e89": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_31598707a34b4ecdbfdb1e8f63afcc97"
       ],
       "layout": "IPY_MODEL_7e5f5164f5a140bd82a5b5f0a59fb861"
      }
     },
     "f6b8a96d1e1149b2883669b4a95f8387": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_a7f6501890af4745af2757af8eaeab41"
       ],
       "layout": "IPY_MODEL_12eaf3cff0824f5c994119746663e6c5"
      }
     },
     "f9dc3eaf321041e083caeb424b5920cc": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "success",
       "description": "tutorial_exp, synthetic data",
       "layout": "IPY_MODEL_78afa3e8e4554bd8aedbfb22a12005c7",
       "style": "IPY_MODEL_9fffbfde565841b9a4717c042fe38e33",
       "tooltip": "tutorial_exp, synthetic data"
      }
     },
     "fa2fc00423c0469f8feca94694951afc": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "fa381e10d2474c5f8ce4aac33729ffd9": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "widget050",
       "height": "auto",
       "width": "auto"
      }
     },
     "ffc8993272bf46e8be30f12153456757": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_edc7eeb74842474fbe330acc877fd046"
       ],
       "layout": "IPY_MODEL_7382c646755a4e70ac7b9efe408b4ce3"
      }
     }
    },
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}