{ "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/QCoDeS/Qcodes/blob/master/docs/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", "import qcodes as qc\n", "from qcodes.dataset import (\n", " Measurement,\n", " experiments,\n", " initialise_or_create_database_at,\n", " load_by_run_spec,\n", " load_or_create_experiment,\n", ")\n", "\n", "## Dummy instruments for generating synthetic data\n", "from qcodes.tests.instrument_mocks import (\n", " DummyInstrument, \n", " DummyInstrumentWithMeasurement\n", ")\n", "\n", "## Multidimensional scanning module\n", "from qcodes.utils.dataset.doNd import (\n", " dond, \n", " LinSweep\n", ")\n", "\n", "## Integrated plotting module\n", "from qcodes.dataset.plotting import plot_dataset\n", "\n", "## Using interactive widget\n", "from qcodes.interactive_widget import experiments_widget\n", "\n" ] }, { "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](index.rst#drivers), 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](index.rst#parameters)." ] }, { "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": [ "3.900914463406723" ] }, "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.tests.instrument_mocks.DummyInstrumentWithMeasurement',\n", " 'parameters': {'IDN': {'__class__': 'qcodes.instrument.parameter.Parameter',\n", " [...]\n", " 'inter_delay': 0,\n", " 'instrument': 'qcodes.tests.instrument_mocks.DummyInstrumentWithMeasurement',\n", " 'instrument_name': 'dmm',\n", " 'unit': ''},\n", " 'v1': {'__class__': 'qcodes.tests.instrument_mocks.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': '',\n", " 'inter_delay': 0,\n", " 'instrument': 'qcodes.tests.instrument_mocks.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\",\n", " 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": [ "" ] }, "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: 5. \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),\n", " (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 is 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: 6. Using 'qcodes.utils.dataset.doNd.dond'\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "25b2ffc8c9494339969339d9d4e8b43a", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/400 [00:00],\n", " [None])" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "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": [ "([,\n", " ],\n", " [,\n", " ])" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Plotting 2d dataset as heatmaps\n", "plot_dataset(dataset_2d)\n" ] }, { "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([ 5.17406540e+00, 2.82387282e+00, 1.64251257e+00, 9.12433784e-01,\n", " 6.48165625e-01, 2.99017094e-01, 2.16100981e-01, 2.32840929e-01,\n", " 1.43916272e-01, -4.14034297e-05]),\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([ 5.17406540e+00, 2.82387282e+00, 1.64251257e+00, 9.12433784e-01,\n", " 6.48165625e-01, 2.99017094e-01, 2.16100981e-01, 2.32840929e-01,\n", " 1.43916272e-01, -4.14034297e-05]),\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": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
dmm_v1
dac_ch1
0.0000005.174065
2.7777782.823873
5.5555561.642513
8.3333330.912434
11.1111110.648166
\n", "
" ], "text/plain": [ " dmm_v1\n", "dac_ch1 \n", "0.000000 5.174065\n", "2.777778 2.823873\n", "5.555556 1.642513\n", "8.333333 0.912434\n", "11.111111 0.648166" ] }, "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": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<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 5.174 2.824 1.643 ... 0.2328 0.1439 -4.14e-05\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:                     aaaaaaaa-0000-0000-0000-017f3ffa3563\n",
       "    run_timestamp:            2022-02-28 11:57:16\n",
       "    ...                       ...\n",
       "    captured_counter:         1\n",
       "    run_id:                   1\n",
       "    run_description:          {"version": 3, "interdependencies": {"paramspec...\n",
       "    parent_dataset_links:     []\n",
       "    run_timestamp_raw:        1646045836.6522214\n",
       "    completed_timestamp_raw:  1646305809.179036
" ], "text/plain": [ "\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 5.174 2.824 1.643 ... 0.2328 0.1439 -4.14e-05\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: aaaaaaaa-0000-0000-0000-017f3ffa3563\n", " run_timestamp: 2022-02-28 11:57:16\n", " ... ...\n", " captured_counter: 1\n", " run_id: 1\n", " run_description: {\"version\": 3, \"interdependencies\": {\"paramspec...\n", " parent_dataset_links: []\n", " run_timestamp_raw: 1646045836.6522214\n", " completed_timestamp_raw: 1646305809.179036" ] }, "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": "b54fd1fe98474a69bb255dba8c6a1006", "version_major": 2, "version_minor": 0 }, "text/plain": [ "VBox(children=(HTML(value='

QCoDeS experiments widget

'), Tab(children=(Output(),), _titles={'0': 'Info…" ] }, "metadata": {}, "output_type": "display_data" } ], "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](index.rst#writing-drivers)." ] }, { "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.9.7" }, "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": "

QCoDeS experiments widget

" } }, "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<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 }