{ "cells": [ { "cell_type": "markdown", "id": "e6b78a3e", "metadata": {}, "source": [ "(sec-tutorial-schedulegettable)=\n", "\n", "# Tutorial: ScheduleGettable\n", "\n", "```{seealso}\n", "The complete source code of this tutorial can be found in\n", "\n", "{nb-download}`ScheduleGettable.ipynb`\n", "```\n", "\n", "This tutorial covers the {class}`~quantify_scheduler.gettables.ScheduleGettable` in-depth. If you're looking for more information on how to set up an experiment in general, please see {ref}`sec-tutorial-experiment`.\n", "\n", "The {class}`~quantify_scheduler.gettables.ScheduleGettable` forms the top-level interface to {mod}`quantify_scheduler`. Under the hood, it uses `quantify-scheduler` modules to compile {ref}`Schedules `, run them on your hardware and retrieve measurement data from the hardware. As the {class}`~quantify_scheduler.gettables.ScheduleGettable` uses functions that return {class}`~quantify_scheduler.schedules.schedule.Schedule`s, you can dynamically set function parameters during experiments.\n", "\n", "For those familiar with [quantify-core](https://quantify-os.org/docs/quantify-core), the interface of the {class}`~quantify_scheduler.gettables.ScheduleGettable` is also designed to be used as a [gettable](https://quantify-os.org/docs/quantify-core/dev/user/concepts.html#settables-and-gettables) for [MeasurementControl](https://quantify-os.org/docs/quantify-core/dev/user/concepts.html#measurement-control). This is convenient for large, possibly multi-dimensional measurement loops, as is demonstrated in {ref}`2D (and ND) measurement loops`.\n", "\n", "Two things are always required when using a {class}`~quantify_scheduler.gettables.ScheduleGettable`: a {ref}`QuantumDevice ` and a function that returns a {class}`~quantify_scheduler.schedules.schedule.Schedule`. We will set these up in a few example scenarios below and show how to use the {class}`~quantify_scheduler.gettables.ScheduleGettable`. More commonly used schedule functions are also included in `quantify-scheduler` out of the box. You can find them in {mod}`~.quantify_scheduler.schedules.spectroscopy_schedules`, {mod}`~.quantify_scheduler.schedules.timedomain_schedules` and {mod}`~.quantify_scheduler.schedules.trace_schedules`.\n", "\n", "(sec-schedulegettable-1dsweep-usage)=\n", "\n", "## 1D iterative measurement loop\n", "\n", "\n", "```{admonition} Setup and hardware configuration\n", "The device setup and hardware configuration for this tutorial can be viewed in the collapsed code cells. In places where you would communicate with actual hardware, dummy objects have been used. If you want to learn more about how to set up the {class}`~quantify_scheduler.device_under_test.quantum_device.QuantumDevice` and hardware configuration, please see our other tutorials, in particular {ref}`sec-tutorial-experiment` and {ref}`sec-tutorial-compiling`.\n", "```" ] }, { "cell_type": "code", "execution_count": 1, "id": "4adfb1c7", "metadata": { "mystnb": { "code_prompt_show": "Set up the quantum device, dummy hardware and hardware configuration" }, "tags": [ "hide-cell" ] }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_1985/1151456847.py:2: DeprecationWarning: This package has reached its end of life. It is no longer maintained and will not receive any further updates or support. For further developments, please refer to the new Quantify repository: https://gitlab.com/quantify-os/quantify.All existing functionalities can be accessed via the new Quantify repository.\n", " from quantify_core.data import handling as dh\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Data will be saved in:\n", "/root/quantify-data\n" ] } ], "source": [ "from qblox_instruments import Cluster, ClusterType\n", "from quantify_core.data import handling as dh\n", "\n", "from quantify_scheduler import BasicTransmonElement, InstrumentCoordinator, QuantumDevice\n", "from quantify_scheduler.qblox import ClusterComponent, start_dummy_cluster_armed_sequencers\n", "\n", "# First, don't forget to set the data directory!\n", "dh.set_datadir() # change me!\n", "\n", "# We define a single transmon qubit as an element (BasicTransmonElement) of the\n", "# QuantumDevice, and populate the parameters with some reasonable values.\n", "\n", "# Device parameters\n", "ACQ_DELAY = 100e-9\n", "FREQ_01 = 4e9\n", "READOUT_AMP = 0.1\n", "READOUT_FREQ = 4.3e9\n", "PI_PULSE_AMP = 0.15\n", "LO_FREQ_QUBIT = 3.9e9\n", "LO_FREQ_READOUT = 4.5e9\n", "\n", "single_qubit_device = QuantumDevice(\"single_qubit_device\")\n", "\n", "q0 = BasicTransmonElement(\"q0\")\n", "single_qubit_device.add_element(q0)\n", "\n", "# Assign device parameters to transmon element\n", "q0.measure.pulse_amp(READOUT_AMP)\n", "q0.clock_freqs.readout(READOUT_FREQ)\n", "q0.clock_freqs.f01(FREQ_01)\n", "q0.measure.acq_delay(ACQ_DELAY)\n", "q0.rxy.amp180(PI_PULSE_AMP)\n", "\n", "# For this example, we will set up a Qblox cluster hardware setup with two modules: a\n", "# QRM-RF and a QCM-RF.\n", "\n", "# Note: if you are connecting to an actual cluster, you would provide the\n", "# 'identifier' argument (the ip address, device name or serial number) instead\n", "# of the 'dummy_cfg' argument.\n", "cluster = Cluster(\n", " \"cluster\",\n", " dummy_cfg={\n", " 1: ClusterType.CLUSTER_QRM_RF,\n", " 2: ClusterType.CLUSTER_QCM_RF,\n", " },\n", ")\n", "\n", "ic_cluster = ClusterComponent(cluster)\n", "\n", "# Temporarily fixing dummy cluster's deficiency.\n", "cluster.start_sequencer = lambda : start_dummy_cluster_armed_sequencers(ic_cluster)\n", "\n", "# We create an InstrumentCoordinator to control the cluster and add it to the\n", "# QuantumDevice.\n", "\n", "instrument_coordinator = InstrumentCoordinator(\"instrument_coordinator\")\n", "instrument_coordinator.add_component(ic_cluster)\n", "\n", "single_qubit_device.instr_instrument_coordinator(instrument_coordinator.name)\n", "\n", "# A basic hardware configuration will be used for the two cluster modules.\n", "\n", "hardware_cfg = {\n", " \"version\": \"0.2\",\n", " \"config_type\": \"quantify_scheduler.backends.qblox_backend.QbloxHardwareCompilationConfig\",\n", " \"hardware_description\": {\n", " f\"{cluster.name}\": {\n", " \"instrument_type\": \"Cluster\",\n", " \"modules\": {\n", " \"1\": {\n", " \"instrument_type\": \"QRM_RF\"\n", " },\n", " \"2\": {\n", " \"instrument_type\": \"QCM_RF\"\n", " }\n", " },\n", " \"ref\": \"internal\"\n", " }\n", " },\n", " \"hardware_options\": {\n", " \"modulation_frequencies\": {\n", " \"q0:res-q0.ro\": {\n", " \"lo_freq\": LO_FREQ_READOUT\n", " },\n", " \"q0:mw-q0.01\": {\n", " \"lo_freq\": LO_FREQ_QUBIT\n", " }\n", " }\n", " },\n", " \"connectivity\": {\n", " \"graph\": [\n", " [f\"{cluster.name}.module1.complex_output_0\", \"q0:res\"],\n", " [f\"{cluster.name}.module1.complex_input_0\", \"q0:res\"],\n", " [f\"{cluster.name}.module2.complex_output_0\", \"q0:mw\"]\n", " ]\n", " }\n", "}\n", "\n", "\n", "# This hardware configuration should also be added to the quantum device.\n", "single_qubit_device.hardware_config(hardware_cfg)" ] }, { "cell_type": "markdown", "id": "d90bf9c5", "metadata": {}, "source": [ "For this experiment, we have set up a basic {class}`~quantify_scheduler.device_under_test.quantum_device.QuantumDevice` called `single_qubit_device`, representing a single transmon qubit.\n", "\n", "We'll now define the schedule function. A valid schedule function must contain a `repetitions` (integer) parameter (see {ref}`Repetitions`), and can contain any number of additional parameters. It must return a {class}`~quantify_scheduler.schedules.schedule.Schedule` object.\n", "\n", "The schedule function can be parameterized to loop over different values. The parameters can be scalars or arrays. For example, the schedule function defined below takes an array of values for the parameter `times`. This is called a _batched_ measurement, as will be explained further in this tutorial." ] }, { "cell_type": "code", "execution_count": 2, "id": "d629acfd", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler import Schedule\n", "from quantify_scheduler.operations import Measure, Reset, X\n", "\n", "def t1_sched(times, repetitions=1):\n", " schedule = Schedule(\"T1\", repetitions)\n", " for i, tau in enumerate(times):\n", " schedule.add(Reset(\"q0\"), label=f\"Reset {i}\")\n", " schedule.add(X(\"q0\"), label=f\"pi {i}\")\n", " # Measure tau seconds after the start of the X gate\n", " schedule.add(\n", " Measure(\"q0\"),\n", " ref_pt=\"start\",\n", " rel_time=tau,\n", " label=f\"Measurement {i}\",\n", " )\n", " return schedule" ] }, { "cell_type": "markdown", "id": "2d38ec6d", "metadata": {}, "source": [ "Now, let's create the {class}`~quantify_scheduler.gettables.ScheduleGettable`. The {class}`~quantify_scheduler.gettables.ScheduleGettable` provides a convenient way to compile and execute schedules in just a few lines of code. The parameters can be set directly, with arrays and scalars, or through QCoDeS parameters, as shown below." ] }, { "cell_type": "code", "execution_count": 3, "id": "2ab417d1", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "from qcodes.instrument.parameter import ManualParameter\n", "\n", "from quantify_scheduler import ScheduleGettable\n", "\n", "# The points we want to measure.\n", "times = np.linspace(start=1.6e-7, stop=4.976e-5, num=125)\n", "\n", "# As QCoDeS parameter:\n", "time = ManualParameter(\"sample\", label=\"Sample time\", unit=\"s\")\n", "# Set the parameter. This can be done even after defining the gettable!\n", "time(times)\n", "\n", "# Or as array:\n", "time = times\n", "\n", "# Configure the gettable\n", "gettable = ScheduleGettable(\n", " quantum_device=single_qubit_device,\n", " schedule_function=t1_sched,\n", " schedule_kwargs={\"times\": time},\n", " batched=True\n", ")" ] }, { "cell_type": "markdown", "id": "4dc6aa10", "metadata": {}, "source": [ "Note that `batched=True` here. This means we are doing a _batched_ measurement, which simply means that we tell the {class}`~quantify_scheduler.gettables.ScheduleGettable` to expect an array of values in the acquisition result. In this case, our schedule function creates one schedule for an array of times, and it includes an acquisition (the {class}`~quantify_scheduler.operations.gate_library.Measure` operation) for each point." ] }, { "cell_type": "code", "execution_count": 4, "id": "51d725db", "metadata": { "mystnb": { "code_prompt_show": "Provide the dummy hardware with acquisition data" }, "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "import xarray\n", "\n", "from quantify_scheduler.waveforms import soft_square\n", "\n", "from qblox_instruments import DummyScopeAcquisitionData, DummyBinnedAcquisitionData\n", "\n", "\n", "soft_sq_samples = round(q0.measure.integration_time() * 1e9)\n", "soft_sq_times = np.arange(soft_sq_samples)\n", "soft_sq = soft_square(t=soft_sq_times, amp=0.5)\n", "scope_data_real = np.zeros(16384) # Scope trace acquires 16384 points\n", "scope_data_real[:soft_sq_samples] = soft_sq\n", "scope_data_real += np.random.randn(16384) / 500 # add some \"noise\"\n", "\n", "# Create dummy scope data with the soft square pulse on the I path and noise on\n", "# the Q path\n", "scope_data = list(zip(scope_data_real, np.random.randn(16384) / 500))\n", "\n", "dummy_scope_acquisition_data = DummyScopeAcquisitionData(\n", " data=scope_data, out_of_range=(False, False), avg_cnt=(0, 0)\n", " )\n", "\n", "ic_cluster.instrument.set_dummy_scope_acquisition_data(\n", " slot_idx=1, sequencer=None, data=dummy_scope_acquisition_data\n", ")\n", "\n", "\n", "# Dataset with T1 experiment data\n", "example_dataset = xarray.open_dataset(\"../examples/dataset.hdf5\")\n", "\n", "def get_dummy_binned_acquisition_data(real: float, imag: float):\n", " return DummyBinnedAcquisitionData(data=(real, imag), thres=0, avg_cnt=0)\n", "\n", "ic_cluster.instrument.set_dummy_binned_acquisition_data(\n", " slot_idx=1,\n", " sequencer=0,\n", " acq_index_name=\"0\",\n", " data=[\n", " get_dummy_binned_acquisition_data(float(re) * 1024, float(im) * 1024)\n", " for re, im in zip(example_dataset[\"y0\"], example_dataset[\"y1\"])\n", " ],\n", ")" ] }, { "cell_type": "markdown", "id": "7d4e5df0", "metadata": {}, "source": [ "Let's now run the experiment and retrieve the acquisitions using the {meth}`~quantify_scheduler.gettables.ScheduleGettable.get` method." ] }, { "cell_type": "code", "execution_count": 5, "id": "3f87d48e", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "\n", "data = gettable.get()\n", "\n", "plt.plot(times, data[0], '.', label=\"real\")\n", "plt.plot(times, data[1], '.', label=\"imaginary\")\n", "plt.legend()\n", "plt.xlabel(\"Idle time (s)\")\n", "plt.ylabel(\"Voltage (V)\")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "569e17f5", "metadata": {}, "source": [ "Note that the data used here is the same as in {ref}`sec-tutorial-experiment`. The example dataset can be downloaded {download}`here <../examples/dataset.hdf5>`.\n", "\n", "As we defined 125 points in our `times` array which were measured in 125 different `acq_index`es, the acquisition result also contains 125 _I_ values (in `data[0][:]`) and 125 _Q_ values (in `data[1][:]`). The general format of the data returned by the {class}`~quantify_scheduler.gettables.ScheduleGettable` is also explained in the {ref}`user guide `.\n", "\n", "## Trace measurement\n", "\n", "The previous experiment's acquisition results had one data point for each acquisition in the schedule. For a trace measurement, the data format is slightly different. To illustrate this, let us set up an experiment with a trace measurement." ] }, { "cell_type": "code", "execution_count": 6, "id": "c487c11a", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler.operations import IdlePulse, SoftSquarePulse\n", "\n", "\n", "def trace_schedule(pulse_amp, acq_delay, port=\"q0:res\", clock=\"q0.ro\", repetitions=1):\n", " schedule = Schedule(\"Trace a pulse\", repetitions=repetitions)\n", "\n", " schedule.add(\n", " SoftSquarePulse(\n", " duration=q0.measure.integration_time(),\n", " amp=pulse_amp,\n", " port=port,\n", " clock=clock,\n", " ),\n", " label=\"trace_pulse\",\n", " )\n", "\n", " # Add acq_delay to compensate for time-of-flight of the pulse\n", " schedule.add(\n", " Measure(q0.name, acq_protocol=\"Trace\"),\n", " ref_pt=\"start\",\n", " rel_time=acq_delay,\n", " label=\"acquisition\"\n", " )\n", "\n", " return schedule" ] }, { "cell_type": "markdown", "id": "1ec3a440", "metadata": {}, "source": [ "Again, we define the gettable and run the experiment." ] }, { "cell_type": "code", "execution_count": 7, "id": "043188ec", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.9/site-packages/quantify_scheduler/backends/qblox/compiler_abc.py:632: RuntimeWarning: Operation is interrupting previous Pulse because it starts before the previous ends, offending operation: Pulse \"UpdateParameters\" (t0=1.0000000000000001e-07, duration=0)\n", " warnings.warn(\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "gettable = ScheduleGettable(\n", " quantum_device=single_qubit_device,\n", " schedule_function=trace_schedule,\n", " schedule_kwargs={\n", " \"pulse_amp\": 0.5,\n", " \"acq_delay\": 100e-9,\n", " },\n", " batched=True,\n", ")\n", "\n", "data = gettable.get()\n", "\n", "plt.plot(np.arange(1000)/1e9, data[0], '.', label=\"real\")\n", "plt.plot(np.arange(1000)/1e9, data[1], '.', label=\"imaginary\")\n", "plt.legend()\n", "plt.xlabel(\"Time (s)\")\n", "plt.ylabel(\"Voltage (V)\")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "2adc3fd4", "metadata": {}, "source": [ "This time, there is only one acquisition operation in the schedule. The measurement result contains two arrays: one for the _I_ values (`data[0][:]`), and one for the _Q_ values (`data[1][:]`) of the acquired trace.\n", "\n", "## MeasurementControl\n", "\n", "Iterating through different parameters can be done with some help from `quantify-core` as well, through the {class}`~quantify_core.measurement.control.MeasurementControl` class. The {class}`~quantify_core.measurement.control.MeasurementControl` uses settables (parameters to vary in an experiment) and gettables (in this case, our {class}`~quantify_scheduler.gettables.ScheduleGettable`). The settable must be a class that implements `set()`, such as a QCoDeS {class}`~qcodes.parameters.ManualParameter`.\n", "\n", "In this example, the settable is the `time` object, and the setpoints are a numpy array of values (`times`). These are added to the {class}`~quantify_core.measurement.control.MeasurementControl` as shown, together with the {class}`~quantify_scheduler.gettables.ScheduleGettable`. The {class}`~quantify_core.measurement.control.MeasurementControl` object will be in charge of setting the setpoints, and retrieving the measurement results through the gettable." ] }, { "cell_type": "code", "execution_count": 8, "id": "d4b59f00", "metadata": {}, "outputs": [], "source": [ "from quantify_core.measurement.control import MeasurementControl\n", "\n", "\n", "measurement_control = MeasurementControl(\"measurement_control\")\n", "\n", "# Configure the settable\n", "time = ManualParameter(\"sample\", label=\"Sample time\", unit=\"s\")\n", "time.batched = True\n", "\n", "times = np.linspace(start=1.6e-7, stop=4.976e-5, num=125)\n", "\n", "# Configure the gettable\n", "gettable = ScheduleGettable(\n", " quantum_device=single_qubit_device,\n", " schedule_function=t1_sched,\n", " schedule_kwargs={\"times\": time},\n", " batched=True\n", ")\n", "\n", "# Configure MeasurementControl\n", "measurement_control.settables(time)\n", "measurement_control.setpoints(times)\n", "measurement_control.gettables(gettable)" ] }, { "cell_type": "markdown", "id": "6d6bd457", "metadata": {}, "source": [ "The experiment is set to run fully in _batched_ mode. When using {class}`~quantify_core.measurement.control.MeasurementControl`, settables and gettables can be either batched (an array of points is set for each measurement iteration) or iterative (only one point is set per iteration). Combinations of batched and iterative settables are possible, as explained in detail in the [quantify-core documentation](https://quantify-os.org/docs/quantify-core/dev/user/concepts.html#mixing-iterative-and-batched-settables).\n", "\n", "Settables and gettables are batched if they have the attribute `batched=True`. In {class}`~quantify_scheduler.gettables.ScheduleGettable`, this can be controlled through the `batched` argument when creating the class. For other classes, the attribute can be added dynamically if needed, as shown above for the `time` parameter.\n", "\n", "With both the gettable and the settable having `batched=True`, the {class}`~quantify_core.measurement.control.MeasurementControl` knows that it should set the entire `times` array as the settable's value (instead of repeating the experiment for each value in the array). All data points are measured without interruption and all measurement results are returned in one go. Now, let's run the experiment and retrieve the data." ] }, { "cell_type": "code", "execution_count": 9, "id": "580985c4", "metadata": { "tags": [ "hide-output" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Starting batched measurement...\n", "Iterative settable(s) [outer loop(s)]:\n", "\t --- (None) --- \n", "Batched settable(s):\n", "\t sample \n", "Batch size limit: 125\n", "\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "eaa174b6f0b24fd89dfa5d8577f3414b", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Completed: 0%| [ elapsed time: 00:00 | time left: ? ] it" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "dataset = measurement_control.run()" ] }, { "cell_type": "markdown", "id": "c7ceaea5", "metadata": {}, "source": [ "The {class}`~quantify_core.measurement.control.MeasurementControl` class processes the data returned by the {class}`~quantify_scheduler.gettables.ScheduleGettable`, and turns it into a {class}`~xarray.Dataset`. More information on the format of this dataset can be found in the [quantify-core documentation](https://quantify-os.org/docs/quantify-core/dev/user/concepts.html#dataset)." ] }, { "cell_type": "code", "execution_count": 10, "id": "b3c0c5cd", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 3kB\n",
       "Dimensions:  (dim_0: 125)\n",
       "Coordinates:\n",
       "    x0       (dim_0) float64 1kB 1.6e-07 5.6e-07 9.6e-07 ... 4.936e-05 4.976e-05\n",
       "Dimensions without coordinates: dim_0\n",
       "Data variables:\n",
       "    y0       (dim_0) float64 1kB -1.166 -1.141 -1.109 ... -0.737 -0.7305 -1.164\n",
       "    y1       (dim_0) float64 1kB 0.2569 0.2138 0.2035 ... -0.2533 -0.247 0.2671\n",
       "Attributes:\n",
       "    tuid:                             20260319-141824-189-95dba5\n",
       "    name:                             \n",
       "    grid_2d:                          False\n",
       "    grid_2d_uniformly_spaced:         False\n",
       "    1d_2_settables_uniformly_spaced:  False
" ], "text/plain": [ " Size: 3kB\n", "Dimensions: (dim_0: 125)\n", "Coordinates:\n", " x0 (dim_0) float64 1kB 1.6e-07 5.6e-07 9.6e-07 ... 4.936e-05 4.976e-05\n", "Dimensions without coordinates: dim_0\n", "Data variables:\n", " y0 (dim_0) float64 1kB -1.166 -1.141 -1.109 ... -0.737 -0.7305 -1.164\n", " y1 (dim_0) float64 1kB 0.2569 0.2138 0.2035 ... -0.2533 -0.247 0.2671\n", "Attributes:\n", " tuid: 20260319-141824-189-95dba5\n", " name: \n", " grid_2d: False\n", " grid_2d_uniformly_spaced: False\n", " 1d_2_settables_uniformly_spaced: False" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dataset" ] }, { "cell_type": "markdown", "id": "cd5a1078", "metadata": {}, "source": [ "The dataset coordinates and data variables are named as generic `x` and `y` parameters. You can click on the 'Show/Hide attributes' button next to the coordinates and variables to see what they refer to.\n", "\n", "(sec-tutorial-schedulegettable-repetitions)=\n", "## Repetitions\n", "\n", "Repetition defines how many times the defined schedule will run on the hardware. Running the schedule multiple times can be useful for example if the user would like to reduce errors of acquisitions by averaging the result of multiple measurements.\n", "\n", "There are multiple ways the repetitions can be set. They are not completely independent of each other, and which setting will be taken into account depends on how you create and use the schedule.\n", "\n", "1. {class}`~quantify_scheduler.device_under_test.quantum_device.QuantumDevice`: via `cfg_sched_repetitions` (by default it is `1024`),\n", "2. schedule function: via the `repetitions` function argument,\n", "3. {class}`~quantify_scheduler.schedules.schedule.Schedule` object: via the `repetitions` function argument of its constructor, or via its `repetitions` attribute directly,\n", "4. ({class}`~quantify_scheduler.gettables.ScheduleGettable`: currently, it is not possible to supply `repetitions` via `schedule_kwargs`).\n", "\n", "Ultimately, the {class}`~quantify_scheduler.schedules.schedule.Schedule` object is what governs the repetitions, via its `repetitions` attribute.\n", "\n", "When using a schedule function, the `repetitions` function argument sets the repetitions, provided that the schedule function passes it to the `Schedule` object. This is true for the pre-defined schedules, see {mod}`!quantify_scheduler.schedules`.\n", "\n", "However, if the experiment is run using `ScheduleGettable`, this `repetitions` function argument is set to `QuantumDevice.cfg_sched_repetitions`. Hence, typically, the schedule will run `QuantumDevice.cfg_sched_repetitions` times.\n", "\n", "### Possible mistake: ignoring `repetitions` argument\n", "\n", "Keep in mind that the schedule function should pass the `repetitions` argument to the `Schedule` initializer, otherwise both `QuantumDevice.cfg_sched_repetitions` and the `repetitions` argument of the schedule function will be ignored. For example, in the following setup, the `repetitions` will always be `1` (default for the `Schedule` object), even if `cfg_sched_repetitions` is set to `2`." ] }, { "cell_type": "code", "execution_count": 11, "id": "7bc186cc", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler import QuantumDevice, ScheduleGettable\n", "\n", "def schedule_function(q0: str, repetitions: int):\n", " schedule = Schedule(\"Example schedule\")\n", " schedule.add(Measure(q0))\n", " return schedule\n", "\n", "quantum_device = QuantumDevice(name=\"quantum_sample\")\n", "quantum_device.cfg_sched_repetitions(2)\n", "\n", "schedule_gettable = ScheduleGettable(\n", " quantum_device=quantum_device,\n", " schedule_function=schedule_function,\n", " schedule_kwargs={\"q0\": \"q0\"},\n", ")" ] }, { "cell_type": "markdown", "id": "a91862e6", "metadata": {}, "source": [ "### Possible mistake: ignoring `cfg_sched_repetitions` default value\n", "\n", "Also note, that the default value of the `repetitions` argument of the schedule function will be ignored if `ScheduleGettable` is used, and it will be set to `QuantumDevice.cfg_sched_repetitions`. For example, in the following setup, `repetitions` will be `1024` (default for `QuantumDevice`), even if the default argument for `repetitions` is `2`." ] }, { "cell_type": "code", "execution_count": 12, "id": "028b1cfe", "metadata": { "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "quantum_device.close()" ] }, { "cell_type": "code", "execution_count": 13, "id": "8223c5c1", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler import QuantumDevice, ScheduleGettable\n", "\n", "def schedule_function(q0: str, repetitions: int = 2):\n", " schedule = Schedule(\"Example schedule\", repetitions=repetitions)\n", " schedule.add(Measure(q0))\n", " return schedule\n", "\n", "quantum_device = QuantumDevice(name=\"quantum_sample\")\n", "\n", "schedule_gettable = ScheduleGettable(\n", " quantum_device=quantum_device,\n", " schedule_function=schedule_function,\n", " schedule_kwargs={\"q0\": \"q0\"},\n", ")" ] }, { "cell_type": "markdown", "id": "6de45a15", "metadata": {}, "source": [ "(sec-schedulegettable-2dsweep-usage)=\n", "\n", "## 2D (and ND) measurement loops" ] }, { "cell_type": "code", "execution_count": 14, "id": "a1dff43d", "metadata": { "mystnb": { "code_prompt_show": "Set up the quantum device, dummy hardware and hardware configuration" }, "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "from qblox_instruments import Cluster, ClusterType, DummyBinnedAcquisitionData\n", "\n", "from quantify_scheduler import BasicTransmonElement, InstrumentCoordinator, QuantumDevice\n", "from quantify_scheduler.qblox import ClusterComponent\n", "\n", "\n", "single_qubit_device.close_all()\n", "\n", "# Device parameters\n", "Q0_ACQ_DELAY = 100e-9\n", "Q0_FREQ_01 = 4e9\n", "Q0_READOUT_AMP = 0.1\n", "Q0_READOUT_FREQ = 4.3e9\n", "Q0_PI_PULSE_AMP = 0.15\n", "Q0_LO_FREQ_QUBIT = 3.9e9\n", "Q0_LO_FREQ_READOUT = 4.5e9\n", "\n", "Q1_ACQ_DELAY = 120e-9\n", "Q1_FREQ_01 = 4.1e9\n", "Q1_READOUT_AMP = 0.1\n", "Q1_READOUT_FREQ = 3.8e9\n", "Q1_PI_PULSE_AMP = 0.15\n", "Q1_LO_FREQ_QUBIT = 4.1e9\n", "Q1_LO_FREQ_READOUT = 3.8e9\n", "\n", "two_qubit_device = QuantumDevice(\"two_qubit_device\")\n", "\n", "q0 = BasicTransmonElement(\"q0\")\n", "q0.measure.acq_channel(0)\n", "q0.measure.pulse_amp(Q0_READOUT_AMP)\n", "q0.clock_freqs.readout(Q0_READOUT_FREQ)\n", "q0.clock_freqs.f01(Q0_FREQ_01)\n", "q0.measure.acq_delay(Q0_ACQ_DELAY)\n", "q0.rxy.amp180(Q0_PI_PULSE_AMP)\n", "\n", "q1 = BasicTransmonElement(\"q1\")\n", "q1.measure.acq_channel(1) # Note that we're specifying that measurements on q1 should use a different measurement channel\n", "q1.measure.pulse_amp(Q1_READOUT_AMP)\n", "q1.clock_freqs.readout(Q1_READOUT_FREQ)\n", "q1.clock_freqs.f01(Q1_FREQ_01)\n", "q1.measure.acq_delay(Q1_ACQ_DELAY)\n", "q1.rxy.amp180(Q1_PI_PULSE_AMP)\n", "\n", "two_qubit_device.add_element(q0)\n", "two_qubit_device.add_element(q1)\n", "\n", "# We will need to adjust the hardware configuration.\n", "\n", "# Note: if you are connecting to an actual cluster, you would provide the\n", "# 'identifier' argument (the ip address, device name or serial number) instead\n", "# of the 'dummy_cfg' argument.\n", "cluster = Cluster(\n", " \"cluster\",\n", " dummy_cfg={\n", " 1: ClusterType.CLUSTER_QRM_RF,\n", " 2: ClusterType.CLUSTER_QCM_RF,\n", " 3: ClusterType.CLUSTER_QRM_RF,\n", " 4: ClusterType.CLUSTER_QCM_RF,\n", " },\n", ")\n", "\n", "ic_cluster = ClusterComponent(cluster)\n", "\n", "# Temporarily fixing dummy cluster's deficiency.\n", "cluster.start_sequencer = lambda : start_dummy_cluster_armed_sequencers(ic_cluster)\n", "\n", "instrument_coordinator = InstrumentCoordinator(\"instrument_coordinator\")\n", "instrument_coordinator.add_component(ic_cluster)\n", "\n", "two_qubit_device.instr_instrument_coordinator(instrument_coordinator.name)\n", "\n", "hardware_cfg = {\n", " \"version\": \"0.2\",\n", " \"config_type\": \"quantify_scheduler.backends.qblox_backend.QbloxHardwareCompilationConfig\",\n", " \"hardware_description\": {\n", " f\"{cluster.name}\": {\n", " \"instrument_type\": \"Cluster\",\n", " \"modules\": {\n", " \"1\": {\n", " \"instrument_type\": \"QRM_RF\"\n", " },\n", " \"2\": {\n", " \"instrument_type\": \"QCM_RF\"\n", " },\n", " \"3\": {\n", " \"instrument_type\": \"QRM_RF\"\n", " },\n", " \"4\": {\n", " \"instrument_type\": \"QCM_RF\"\n", " }\n", " },\n", " \"ref\": \"internal\"\n", " }\n", " },\n", " \"hardware_options\": {\n", " \"modulation_frequencies\": {\n", " \"q0:res-q0.ro\": {\n", " \"lo_freq\": Q0_LO_FREQ_READOUT\n", " },\n", " \"q0:mw-q0.01\": {\n", " \"lo_freq\": Q0_LO_FREQ_QUBIT\n", " },\n", " \"q1:res-q1.ro\": {\n", " \"lo_freq\": Q1_LO_FREQ_READOUT\n", " },\n", " \"q1:mw-q1.01\": {\n", " \"lo_freq\": Q1_LO_FREQ_QUBIT\n", " }\n", " }\n", " },\n", " \"connectivity\": {\n", " \"graph\": [\n", " [f\"{cluster.name}.module1.complex_output_0\", \"q0:res\"],\n", " [f\"{cluster.name}.module1.complex_input_0\", \"q0:res\"],\n", " [f\"{cluster.name}.module2.complex_output_0\", \"q0:mw\"],\n", " [f\"{cluster.name}.module3.complex_output_0\", \"q1:res\"],\n", " [f\"{cluster.name}.module3.complex_input_0\", \"q1:res\"],\n", " [f\"{cluster.name}.module4.complex_output_0\", \"q1:mw\"]\n", " ]\n", " }\n", "}\n", "\n", "\n", "two_qubit_device.hardware_config(hardware_cfg)\n", "\n", "ic_cluster.instrument.set_dummy_binned_acquisition_data(\n", " slot_idx=1, sequencer=0, acq_index_name=\"0\", data=[DummyBinnedAcquisitionData(data=(0.0, 0.0), thres=0, avg_cnt=0)]\n", ")\n", "ic_cluster.instrument.set_dummy_binned_acquisition_data(\n", " slot_idx=3, sequencer=0, acq_index_name=\"0\", data=[DummyBinnedAcquisitionData(data=(0.0, 0.0), thres=0, avg_cnt=0)]\n", ")" ] }, { "cell_type": "markdown", "id": "b5168fb5", "metadata": {}, "source": [ "2D and higher-dimensional measurement loops are easy to realize. Below we show an example Chevron experiment, which is a type of two-qubit experiment often performed on transmon qubits. The experiment includes a square pulse, and we want to vary both its amplitude and duration in a 2D grid. We have already set up a two-qubit {class}`~quantify_scheduler.device_under_test.quantum_device.QuantumDevice` under the variable name `two_qubit_device`.\n", "\n", "We define simple schedule below with a parameterized amplitude and duration of the square pulse. `duration` and `amp` are scalars, so for each measurement point the schedule will be recompiled." ] }, { "cell_type": "code", "execution_count": 15, "id": "c5b6d611", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler import Schedule\n", "from quantify_scheduler.operations import Measure, Reset, SquarePulse, X, X90\n", "\n", "def chevron_schedule_not_batched(duration, amp, repetitions=1):\n", " sched = Schedule(\"Chevron Experiment\", repetitions=repetitions)\n", "\n", " acq_idx = 0\n", "\n", " reset = sched.add(Reset(\"q0\", \"q1\"))\n", " sched.add(X(\"q0\"), ref_op=reset, ref_pt=\"end\") # Start at the end of the reset\n", " # We specify a clock for tutorial purposes, Chevron experiments do not necessarily use modulated square pulses\n", " square = sched.add(SquarePulse(amp=amp, duration=duration, port=\"q0:mw\", clock=\"q0.01\"))\n", " sched.add(X90(\"q0\"), ref_op=square) # Start at the end of the square pulse\n", " sched.add(X90(\"q1\"), ref_op=square)\n", " sched.add(Measure(\"q0\"), label=f\"M q0 {acq_idx}\")\n", " sched.add(\n", " Measure(\"q1\"),\n", " label=f\"M q1 {acq_idx}\",\n", " ref_pt=\"start\", # Start at the same time as the other measure\n", " )\n", "\n", " return sched" ] }, { "cell_type": "markdown", "id": "dc726347", "metadata": {}, "source": [ "We set up a non-batched measurement with {class}`~quantify_core.measurement.control.MeasurementControl` and a {class}`~quantify_scheduler.gettables.ScheduleGettable`. For this {class}`~quantify_scheduler.gettables.ScheduleGettable`, notice the keyword argument `num_channels=2`, which is needed since we specified in the quantum device elements that the measurements on `\"q0\"` and `\"q1\"` should end up in two different channels.\n", "\n", "In addition, we used another new argument in the {class}`~quantify_scheduler.gettables.ScheduleGettable`: `real_imag=False`. `real_imag` can be used to transform the acquisition data. If it is `True` (the default), the I and Q values will be returned, and if it is `False`, the data will be transformed to the absolute value and the phase (in degrees, in the interval `(-180, 180]`)." ] }, { "cell_type": "code", "execution_count": 16, "id": "6cdd3fe5", "metadata": { "tags": [ "hide-output" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Starting iterative measurement...\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "ecad9c6007774f3583483b82239409cf", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Completed: 0%| [ elapsed time: 00:00 | time left: ? ] it" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "measurement_control = MeasurementControl(\"measurement_control\")\n", "\n", "# Configure the settables\n", "duration = ManualParameter(\"duration\", label=\"Duration\", unit=\"s\")\n", "duration.batched = False\n", "\n", "durations = np.linspace(start=20e-9, stop=60e-9, num=6)\n", "\n", "amplitude = ManualParameter(\"amplitude\", label=\"Amplitude\", unit=\"V\")\n", "amplitude.batched = False\n", "\n", "amplitudes = np.linspace(start=0.1, stop=1.0, num=10)\n", "\n", "# Configure the gettable\n", "gettable = ScheduleGettable(\n", " quantum_device=two_qubit_device,\n", " schedule_function=chevron_schedule_not_batched,\n", " schedule_kwargs={\"duration\": duration, \"amp\": amplitude},\n", " batched=False,\n", " real_imag=False,\n", " num_channels=2,\n", ")\n", "\n", "# Configure MeasurementControl\n", "measurement_control.settables([duration, amplitude])\n", "measurement_control.setpoints_grid([durations, amplitudes]) # note: setpoints_grid instead of setpoints\n", "measurement_control.gettables(gettable)\n", "\n", "# Run!\n", "dataset = measurement_control.run()\n", "dset_grid = dh.to_gridded_dataset(dataset)" ] }, { "cell_type": "code", "execution_count": 17, "id": "5f999241", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 2kB\n",
       "Dimensions:  (x0: 6, x1: 10)\n",
       "Coordinates:\n",
       "  * x0       (x0) float64 48B 2e-08 2.8e-08 3.6e-08 4.4e-08 5.2e-08 6e-08\n",
       "  * x1       (x1) float64 80B 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0\n",
       "Data variables:\n",
       "    y0       (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
       "    y1       (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
       "    y2       (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
       "    y3       (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
       "Attributes:\n",
       "    tuid:                             20260319-141825-198-bf4151\n",
       "    name:                             \n",
       "    grid_2d:                          False\n",
       "    grid_2d_uniformly_spaced:         True\n",
       "    1d_2_settables_uniformly_spaced:  False\n",
       "    xlen:                             6\n",
       "    ylen:                             10
" ], "text/plain": [ " Size: 2kB\n", "Dimensions: (x0: 6, x1: 10)\n", "Coordinates:\n", " * x0 (x0) float64 48B 2e-08 2.8e-08 3.6e-08 4.4e-08 5.2e-08 6e-08\n", " * x1 (x1) float64 80B 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0\n", "Data variables:\n", " y0 (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", " y1 (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", " y2 (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", " y3 (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", "Attributes:\n", " tuid: 20260319-141825-198-bf4151\n", " name: \n", " grid_2d: False\n", " grid_2d_uniformly_spaced: True\n", " 1d_2_settables_uniformly_spaced: False\n", " xlen: 6\n", " ylen: 10" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dset_grid" ] }, { "cell_type": "markdown", "id": "39fce42e", "metadata": {}, "source": [ "As expected, this dataset contains double the amount of coordinates and data variables (note that the actual data has been mocked and set to 0.0). The two coordinates refer to the settables, `duration` and `amplitude`. With `real_imag` now set to `False`, the data variables contain the magnitude and phase (as opposed to the I and Q voltages) for measurements on `\"q0\"` and `\"q1\"`.\n", "\n", "### Batched 2D experiment\n", "\n", "Since this measurement is not batched, it's rather slow. Let's make this faster with (partial) batching.\n", "\n", "We will batch the amplitudes together, so we change the amplitudes parameter in the schedule function to an array." ] }, { "cell_type": "code", "execution_count": 18, "id": "ac5cdb8b", "metadata": { "mystnb": { "code_prompt_show": "Provide the dummy hardware with acquisition data" }, "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "from qblox_instruments import DummyBinnedAcquisitionData\n", "\n", "\n", "def get_dummy_binned_acquisition_data(real: float, imag: float):\n", " return DummyBinnedAcquisitionData(data=(real, imag), thres=0, avg_cnt=0)\n", "\n", "ic_cluster.instrument.set_dummy_binned_acquisition_data(\n", " slot_idx=1, sequencer=0, acq_index_name=\"0\", data=[get_dummy_binned_acquisition_data(re * 10, im * 10) for re, im in zip(range(-5, 5), range(5, -5, -1))]\n", ")\n", "ic_cluster.instrument.set_dummy_binned_acquisition_data(\n", " slot_idx=3, sequencer=0, acq_index_name=\"0\", data=[get_dummy_binned_acquisition_data(re * 10, im * 10) for re, im in zip(range(-5, 5), range(5, -5, -1))]\n", ")" ] }, { "cell_type": "code", "execution_count": 19, "id": "b3feafca", "metadata": {}, "outputs": [], "source": [ "def chevron_schedule_batched(duration, amps, repetitions=1):\n", " sched = Schedule(\"Chevron Experiment\", repetitions=repetitions)\n", "\n", " acq_idx = 0\n", "\n", " for amp in amps:\n", " reset = sched.add(Reset(\"q0\", \"q1\"))\n", " sched.add(X(\"q0\"), ref_op=reset, ref_pt=\"end\")\n", " square = sched.add(SquarePulse(amp=amp, duration=duration, port=\"q0:mw\", clock=\"q0.01\"))\n", " sched.add(X90(\"q0\"), ref_op=square)\n", " sched.add(X90(\"q1\"), ref_op=square)\n", " sched.add(Measure(\"q0\"), label=f\"M q0 {acq_idx}\")\n", " sched.add(\n", " Measure(\"q1\"),\n", " label=f\"M q1 {acq_idx}\",\n", " ref_pt=\"start\",\n", " )\n", "\n", " acq_idx += 1\n", "\n", " return sched" ] }, { "cell_type": "markdown", "id": "b49fce84", "metadata": {}, "source": [ "We specify that we want to batch the amplitudes by setting ``amplitude.batched = True`` and ``batched=True``as keyword argument for the gettable. Finally, we run this experiment just as before." ] }, { "cell_type": "code", "execution_count": 20, "id": "f6d8a325", "metadata": { "tags": [ "hide-output" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Starting batched measurement...\n", "Iterative settable(s) [outer loop(s)]:\n", "\t duration \n", "Batched settable(s):\n", "\t amplitude \n", "Batch size limit: 60\n", "\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "17acccb24de54db2a8c4fb02f18b445e", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Completed: 0%| [ elapsed time: 00:00 | time left: ? ] it" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Configure the settables\n", "duration = ManualParameter(\"duration\", label=\"Duration\", unit=\"s\")\n", "duration.batched = False\n", "\n", "durations = np.linspace(start=20e-9, stop=60e-9, num=6)\n", "\n", "amplitude = ManualParameter(\"amplitude\", label=\"Amplitude\", unit=\"V\")\n", "amplitude.batched = True\n", "\n", "amplitudes = np.linspace(start=0.1, stop=1.0, num=10)\n", "\n", "# Configure the gettable\n", "gettable = ScheduleGettable(\n", " quantum_device=two_qubit_device,\n", " schedule_function=chevron_schedule_batched,\n", " schedule_kwargs={\"duration\": duration, \"amps\": amplitude},\n", " batched=True,\n", " real_imag=False,\n", " data_labels=[\"Magnitude Q0\", \"Phase Q0\", \"Magnitude Q1\", \"Phase Q1\"],\n", " num_channels=2,\n", ")\n", "\n", "# Configure MeasurementControl\n", "measurement_control.settables([duration, amplitude])\n", "measurement_control.setpoints_grid([durations, amplitudes])\n", "measurement_control.gettables(gettable)\n", "\n", "# Run!\n", "dataset = measurement_control.run()\n", "dset_grid = dh.to_gridded_dataset(dataset)" ] }, { "cell_type": "code", "execution_count": 21, "id": "3fb5b2b1", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 2kB\n",
       "Dimensions:  (x0: 6, x1: 10)\n",
       "Coordinates:\n",
       "  * x0       (x0) float64 48B 2e-08 2.8e-08 3.6e-08 4.4e-08 5.2e-08 6e-08\n",
       "  * x1       (x1) float64 80B 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0\n",
       "Data variables:\n",
       "    y0       (x0, x1) float64 480B 0.07071 0.05657 0.04243 ... 0.04243 0.05657\n",
       "    y1       (x0, x1) float64 480B 135.0 135.0 135.0 135.0 ... -45.0 -45.0 -45.0\n",
       "    y2       (x0, x1) float64 480B 0.07071 0.05657 0.04243 ... 0.04243 0.05657\n",
       "    y3       (x0, x1) float64 480B 135.0 135.0 135.0 135.0 ... -45.0 -45.0 -45.0\n",
       "Attributes:\n",
       "    tuid:                             20260319-141830-902-d21fcb\n",
       "    name:                             \n",
       "    grid_2d:                          False\n",
       "    grid_2d_uniformly_spaced:         True\n",
       "    1d_2_settables_uniformly_spaced:  False\n",
       "    xlen:                             6\n",
       "    ylen:                             10
" ], "text/plain": [ " Size: 2kB\n", "Dimensions: (x0: 6, x1: 10)\n", "Coordinates:\n", " * x0 (x0) float64 48B 2e-08 2.8e-08 3.6e-08 4.4e-08 5.2e-08 6e-08\n", " * x1 (x1) float64 80B 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0\n", "Data variables:\n", " y0 (x0, x1) float64 480B 0.07071 0.05657 0.04243 ... 0.04243 0.05657\n", " y1 (x0, x1) float64 480B 135.0 135.0 135.0 135.0 ... -45.0 -45.0 -45.0\n", " y2 (x0, x1) float64 480B 0.07071 0.05657 0.04243 ... 0.04243 0.05657\n", " y3 (x0, x1) float64 480B 135.0 135.0 135.0 135.0 ... -45.0 -45.0 -45.0\n", "Attributes:\n", " tuid: 20260319-141830-902-d21fcb\n", " name: \n", " grid_2d: False\n", " grid_2d_uniformly_spaced: True\n", " 1d_2_settables_uniformly_spaced: False\n", " xlen: 6\n", " ylen: 10" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dset_grid" ] }, { "cell_type": "markdown", "id": "cf63316d", "metadata": {}, "source": [ "The shape of the dataset is no different from the previous (non-batched) experiment, but the metadata is a little different. Some coordinates and data variables now have the `batched=True` attribute. We also introduced another keyword argument: the `data_labels`. These `data_labels` are picked up by the {class}`~quantify_core.measurement.control.MeasurementControl`and end up in the {class}`xarray.Dataset` as the \"long_name\" of attributes. For example, `\"y0\"`s label can be accessed through `dataset[\"y0\"].attrs[\"long_name\"]`. The various plotting features of `quantify-core` will use this name to get labels for the figure axes." ] } ], "metadata": { "file_format": "mystnb", "kernelspec": { "display_name": "python3", "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.25" }, "source_map": [ 6, 34, 141, 149, 166, 170, 195, 199, 247, 251, 263, 273, 299, 303, 322, 332, 356, 364, 369, 373, 375, 401, 417, 423, 430, 445, 451, 588, 594, 617, 623, 660, 662, 672, 692, 714, 718, 754, 756 ], "widgets": { "application/vnd.jupyter.widget-state+json": { "state": { "05e1a51a70f247b481564b44ec0d16b1": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "bar_color": null, "description_width": "" } }, "1472313a6bbd47c5b7a788239344e74f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null } }, "17acccb24de54db2a8c4fb02f18b445e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_8c563404f69c4080bd0190d7622288a8", "IPY_MODEL_2fa2e5090c6d4d1b93c43aef23e5aca2", "IPY_MODEL_9ddca7b496884484b1ef95d0cbeb652f" ], "layout": "IPY_MODEL_ab64309baf1e4c9a8c98ae545c65869f", "tabbable": null, "tooltip": null } }, "2939fa64480348228d177efafee8f88f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "2d596e686de744ee88e80bdb2d95bc44": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null } }, "2fa2e5090c6d4d1b93c43aef23e5aca2": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_6fa61f3b81cf432da337f1c2fb91e0b7", "max": 100.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_ed88d1b7ed9b476582e2ccabd6701d56", "tabbable": null, "tooltip": null, "value": 100.0 } }, "3247746626014129b3f9b924c9c06efa": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "41b0b92c60d14ba9b60af3567b381dc3": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "518f1d3b3f7d45569f7c7bca1533ca48": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_9a2f54b1499d4245b5d14af856066389", "placeholder": "​", "style": "IPY_MODEL_aaf2591d6d694eeca3911ea1b0b15726", "tabbable": null, "tooltip": null, "value": "Completed: 100%" } }, "51ff8a421e8a48b38d0f852acabe7aad": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_cc65adde128049468ba6a21b26999848", "max": 100.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_ddc0c19277ab4769aeaaef1ee639dc5b", "tabbable": null, "tooltip": null, "value": 100.0 } }, "53a131af25244c1fb3d3a16af627fced": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_a1eb710e438f41b1a0e78b6e74335a6a", "placeholder": "​", "style": "IPY_MODEL_600c3df7644f4adc98e11eddf41f6194", "tabbable": null, "tooltip": null, "value": "Completed: 100%" } }, "5b2171a41116459e94a0c785ddab4a33": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_8dd3ddf8191544008e33340fef6f10d2", "placeholder": "​", "style": "IPY_MODEL_cb820c95e9dc46428043ca3c22b739c5", "tabbable": null, "tooltip": null, "value": " [ elapsed time: 00:00 | time left: 00:00 ]  last batch size: 125" } }, "600c3df7644f4adc98e11eddf41f6194": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null } }, "688523cd91674d65b41ac1b5129e342a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_a5b1c4c15fee49d99d5d7395961cb171", "max": 100.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_05e1a51a70f247b481564b44ec0d16b1", "tabbable": null, "tooltip": null, "value": 100.0 } }, "6fa61f3b81cf432da337f1c2fb91e0b7": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "79ad8ca0c20b44f7973e547247055d85": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null } }, "7f990870b844405ea64356b2c78af790": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_3247746626014129b3f9b924c9c06efa", "placeholder": "​", "style": "IPY_MODEL_2d596e686de744ee88e80bdb2d95bc44", "tabbable": null, "tooltip": null, "value": " [ elapsed time: 00:05 | time left: 00:00 ] " } }, "8c563404f69c4080bd0190d7622288a8": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_2939fa64480348228d177efafee8f88f", "placeholder": "​", "style": "IPY_MODEL_1472313a6bbd47c5b7a788239344e74f", "tabbable": null, "tooltip": null, "value": "Completed: 100%" } }, "8dd3ddf8191544008e33340fef6f10d2": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "8e24e5d8caeb43dcabcbd07df5245e63": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "9a2f54b1499d4245b5d14af856066389": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "9ddca7b496884484b1ef95d0cbeb652f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_a0d2877b17594bc7a3459b0a88bc6321", "placeholder": "​", "style": "IPY_MODEL_79ad8ca0c20b44f7973e547247055d85", "tabbable": null, "tooltip": null, "value": " [ elapsed time: 00:00 | time left: 00:00 ]  last batch size: 10" } }, "a0d2877b17594bc7a3459b0a88bc6321": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "a1eb710e438f41b1a0e78b6e74335a6a": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "a5b1c4c15fee49d99d5d7395961cb171": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "aaf2591d6d694eeca3911ea1b0b15726": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null } }, "ab64309baf1e4c9a8c98ae545c65869f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "cb820c95e9dc46428043ca3c22b739c5": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null } }, "cc65adde128049468ba6a21b26999848": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "ddc0c19277ab4769aeaaef1ee639dc5b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "bar_color": null, "description_width": "" } }, "eaa174b6f0b24fd89dfa5d8577f3414b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_518f1d3b3f7d45569f7c7bca1533ca48", "IPY_MODEL_51ff8a421e8a48b38d0f852acabe7aad", "IPY_MODEL_5b2171a41116459e94a0c785ddab4a33" ], "layout": "IPY_MODEL_8e24e5d8caeb43dcabcbd07df5245e63", "tabbable": null, "tooltip": null } }, "ecad9c6007774f3583483b82239409cf": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_53a131af25244c1fb3d3a16af627fced", "IPY_MODEL_688523cd91674d65b41ac1b5129e342a", "IPY_MODEL_7f990870b844405ea64356b2c78af790" ], "layout": "IPY_MODEL_41b0b92c60d14ba9b60af3567b381dc3", "tabbable": null, "tooltip": null } }, "ed88d1b7ed9b476582e2ccabd6701d56": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "bar_color": null, "description_width": "" } } }, "version_major": 2, "version_minor": 0 } } }, "nbformat": 4, "nbformat_minor": 5 }