{ "cells": [ { "cell_type": "markdown", "id": "40190364", "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": "d7720c57", "metadata": { "mystnb": { "code_prompt_show": "Set up the quantum device, dummy hardware and hardware configuration" }, "tags": [ "hide-cell" ] }, "outputs": [ { "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.device_under_test.quantum_device import QuantumDevice\n", "from quantify_scheduler.device_under_test.transmon_element import BasicTransmonElement\n", "from quantify_scheduler.instrument_coordinator import InstrumentCoordinator\n", "from quantify_scheduler.instrument_coordinator.components.qblox import ClusterComponent\n", "\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", "# 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", " \"backend\": \"quantify_scheduler.backends.qblox_backend.hardware_compile\",\n", " f\"{cluster.name}\": {\n", " \"ref\": \"internal\",\n", " \"instrument_type\": \"Cluster\",\n", " f\"{cluster.module1.name}\": {\n", " \"instrument_type\": \"QRM_RF\",\n", " \"complex_output_0\": {\n", " \"lo_freq\": LO_FREQ_READOUT,\n", " \"portclock_configs\": [\n", " {\n", " \"port\": \"q0:res\",\n", " \"clock\": \"q0.ro\",\n", " }\n", " ],\n", " },\n", " },\n", " f\"{cluster.module2.name}\": {\n", " \"instrument_type\": \"QCM_RF\",\n", " \"complex_output_0\": {\n", " \"lo_freq\": LO_FREQ_QUBIT,\n", " \"portclock_configs\": [\n", " {\n", " \"port\": \"q0:mw\",\n", " \"clock\": \"q0.01\",\n", " }\n", " ],\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": "512021f2", "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": "839b42e9", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler import Schedule\n", "from quantify_scheduler.operations.gate_library 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\", acq_index=i),\n", " ref_pt=\"start\",\n", " rel_time=tau,\n", " label=f\"Measurement {i}\",\n", " )\n", " return schedule" ] }, { "cell_type": "markdown", "id": "6994ff89", "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": "59962e4a", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "from qcodes.instrument.parameter import ManualParameter\n", "\n", "from quantify_scheduler.gettables 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": "a9c97961", "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": "44dd0181", "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": "12a4c3ff", "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": "892300b1", "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": "0d0e3988", "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": "2fa84825", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler.operations.pulse_library 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": "e9b53554", "metadata": {}, "source": [ "Again, we define the gettable and run the experiment." ] }, { "cell_type": "code", "execution_count": 7, "id": "a1763233", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.9/site-packages/quantify_scheduler/backends/qblox/compiler_abc.py:887: RuntimeWarning: Operation is interrupting previous Pulse because it starts before the previous ends, offending operation: Pulse \"Measure q0\" (t0=1e-07, duration=3e-07)\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": "d266f5f8", "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": "855006f5", "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": "928ce528", "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": "f8eb35f7", "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": "8c177011a45c47d5b89242c0962c6d8b", "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": "12b22bc2", "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": "a15cd8e5", "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:                             20240403-093743-351-db4e60\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: 20240403-093743-351-db4e60\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": "a08925dc", "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": "02b87974", "metadata": {}, "outputs": [], "source": [ "def schedule_function(q0: str, repetitions: int):\n", " schedule = Schedule(\"Example schedule\")\n", " schedule.add(Measure(q0, acq_index=0))\n", " return schedule\n", "\n", "from quantify_scheduler.device_under_test.quantum_device import QuantumDevice\n", "quantum_device = QuantumDevice(name=\"quantum_sample\")\n", "quantum_device.cfg_sched_repetitions(2)\n", "\n", "from quantify_scheduler.gettables import ScheduleGettable\n", "schedule_gettable = ScheduleGettable(\n", " quantum_device=quantum_device,\n", " schedule_function=schedule_function,\n", " schedule_kwargs={\"q0\": \"q0\"},\n", ")" ] }, { "cell_type": "markdown", "id": "63d8cb70", "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": "38d92d47", "metadata": { "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "quantum_device.close()" ] }, { "cell_type": "code", "execution_count": 13, "id": "12cf3bf6", "metadata": {}, "outputs": [], "source": [ "def schedule_function(q0: str, repetitions: int = 2):\n", " schedule = Schedule(\"Example schedule\", repetitions=repetitions)\n", " schedule.add(Measure(q0, acq_index=0))\n", " return schedule\n", "\n", "from quantify_scheduler.device_under_test.quantum_device import QuantumDevice\n", "quantum_device = QuantumDevice(name=\"quantum_sample\")\n", "\n", "from quantify_scheduler.gettables import ScheduleGettable\n", "schedule_gettable = ScheduleGettable(\n", " quantum_device=quantum_device,\n", " schedule_function=schedule_function,\n", " schedule_kwargs={\"q0\": \"q0\"},\n", ")" ] }, { "cell_type": "markdown", "id": "9c741c43", "metadata": {}, "source": [ "(sec-schedulegettable-2dsweep-usage)=\n", "\n", "## 2D (and ND) measurement loops" ] }, { "cell_type": "code", "execution_count": 14, "id": "76ce169a", "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.device_under_test.quantum_device import QuantumDevice\n", "from quantify_scheduler.device_under_test.transmon_element import BasicTransmonElement\n", "from quantify_scheduler.instrument_coordinator import InstrumentCoordinator\n", "from quantify_scheduler.instrument_coordinator.components.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", "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", " \"backend\": \"quantify_scheduler.backends.qblox_backend.hardware_compile\",\n", " f\"{cluster.name}\": {\n", " \"ref\": \"internal\",\n", " \"instrument_type\": \"Cluster\",\n", " f\"{cluster.module1.name}\": {\n", " \"instrument_type\": \"QRM_RF\",\n", " \"complex_output_0\": {\n", " \"lo_freq\": Q0_LO_FREQ_READOUT,\n", " \"portclock_configs\": [\n", " {\n", " \"port\": \"q0:res\",\n", " \"clock\": \"q0.ro\",\n", " }\n", " ],\n", " },\n", " },\n", " f\"{cluster.module2.name}\": {\n", " \"instrument_type\": \"QCM_RF\",\n", " \"complex_output_0\": {\n", " \"lo_freq\": Q0_LO_FREQ_QUBIT,\n", " \"portclock_configs\": [\n", " {\n", " \"port\": \"q0:mw\",\n", " \"clock\": \"q0.01\",\n", " }\n", " ],\n", " },\n", " },\n", " f\"{cluster.module3.name}\": {\n", " \"instrument_type\": \"QRM_RF\",\n", " \"complex_output_0\": {\n", " \"lo_freq\": Q1_LO_FREQ_READOUT,\n", " \"portclock_configs\": [\n", " {\n", " \"port\": \"q1:res\",\n", " \"clock\": \"q1.ro\",\n", " }\n", " ],\n", " },\n", " },\n", " f\"{cluster.module4.name}\": {\n", " \"instrument_type\": \"QCM_RF\",\n", " \"complex_output_0\": {\n", " \"lo_freq\": Q1_LO_FREQ_QUBIT,\n", " \"portclock_configs\": [\n", " {\n", " \"port\": \"q1:mw\",\n", " \"clock\": \"q1.01\",\n", " }\n", " ],\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": "98201650", "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": "b822d016", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler import Schedule\n", "from quantify_scheduler.operations.gate_library import Measure, Reset, X, X90\n", "from quantify_scheduler.operations.pulse_library import SquarePulse\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\", acq_index=acq_idx), label=f\"M q0 {acq_idx}\")\n", " sched.add(\n", " Measure(\"q1\", acq_index=acq_idx),\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": "29471ca9", "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": "d4bb7f71", "metadata": { "tags": [ "hide-output" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Starting iterative measurement...\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "3f28c1cc5a4e4b1db57bf8b9382644fa", "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": "f8e1d198", "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:                             20240403-093744-371-bd4ddb\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: 20240403-093744-371-bd4ddb\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": "61f1e345", "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": "78655d84", "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": "96b954f4", "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\", acq_index=acq_idx), label=f\"M q0 {acq_idx}\")\n", " sched.add(\n", " Measure(\"q1\", acq_index=acq_idx),\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": "36e3486a", "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": "3d481d2d", "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": "cb8767107b1a4a59bfb84d8d77570d28", "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": "2ac4fad9", "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:                             20240403-093748-897-efb483\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: 20240403-093748-897-efb483\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": "f589f466", "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.19" }, "source_map": [ 6, 34, 136, 144, 161, 165, 190, 194, 242, 246, 258, 268, 294, 298, 317, 327, 351, 359, 364, 368, 370, 396, 412, 418, 425, 440, 446, 586, 592, 616, 622, 659, 661, 671, 691, 713, 717, 753, 755 ], "widgets": { "application/vnd.jupyter.widget-state+json": { "state": { "0a6619660e3f4b7ea7855aaf09349c14": { "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_7cf11033a7be47e9b77b134629edfcbd", "placeholder": "​", "style": "IPY_MODEL_ed5af3bb5366438fb4dd6a2c9f3fb118", "tabbable": null, "tooltip": null, "value": " [ elapsed time: 00:00 | time left: 00:00 ]  last batch size: 10" } }, "22399a3c2ebc44e48d22410f3c354ca5": { "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_de8408d560b94919af6ce13ae091eb89", "placeholder": "​", "style": "IPY_MODEL_e0d6c8a175374d6aa782a4559f68e40e", "tabbable": null, "tooltip": null, "value": " [ elapsed time: 00:00 | time left: 00:00 ]  last batch size: 125" } }, "3f28c1cc5a4e4b1db57bf8b9382644fa": { "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_9a83d392c5f04300b8ecf6730590f3f7", "IPY_MODEL_a4b149b051e64a4383d42b28dac1d30a", "IPY_MODEL_fd8f2b8522d540d5bd207e5d34b2a7dc" ], "layout": "IPY_MODEL_4142e22f27f6460f8e7d8ed927be6566", "tabbable": null, "tooltip": null } }, "4142e22f27f6460f8e7d8ed927be6566": { "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 } }, "4b7494c13b1c4f17a1c60b99621907c8": { "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_6b313633a1bf433fabe0c6fdfb4fc263", "placeholder": "​", "style": "IPY_MODEL_fb3bbb779399412fa5e38a1c2f99f2e9", "tabbable": null, "tooltip": null, "value": "Completed: 100%" } }, "600b3e3d42e44032b2a216d1abc8c2bf": { "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 } }, "63c71e6e592648899d936399853c97b6": { "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 } }, "63c9ff5cdfe845fcbd3c212d4a0dbec6": { "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_e016e0e0ea9c4a63ad5d90674c0e4a9e", "placeholder": "​", "style": "IPY_MODEL_9e6398ae69a841b7bda1868c08e11e0e", "tabbable": null, "tooltip": null, "value": "Completed: 100%" } }, "6b313633a1bf433fabe0c6fdfb4fc263": { "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 } }, "6eb8cb7080fd4222912b61ab3ae0f644": { "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_600b3e3d42e44032b2a216d1abc8c2bf", "max": 100.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_b6b7604929964607a427cd70533075da", "tabbable": null, "tooltip": null, "value": 100.0 } }, "79484525581946f78e69f13120a1262e": { "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 } }, "7cf11033a7be47e9b77b134629edfcbd": { "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 } }, "7e13c43378804fb683c563cc8471fd2b": { "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_79484525581946f78e69f13120a1262e", "max": 100.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_ffb792568ccf4ee68e855cf89bcf5d0e", "tabbable": null, "tooltip": null, "value": 100.0 } }, "82cdeee69eb049a3afe7b9ead76743cb": { "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 } }, "840e9b6856c3457b8bca0f034510a069": { "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 } }, "8c177011a45c47d5b89242c0962c6d8b": { "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_4b7494c13b1c4f17a1c60b99621907c8", "IPY_MODEL_6eb8cb7080fd4222912b61ab3ae0f644", "IPY_MODEL_22399a3c2ebc44e48d22410f3c354ca5" ], "layout": "IPY_MODEL_82cdeee69eb049a3afe7b9ead76743cb", "tabbable": null, "tooltip": null } }, "8f5bfbb9b5f0456a99260a6d5d2ffb30": { "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 } }, "9a83d392c5f04300b8ecf6730590f3f7": { "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_63c71e6e592648899d936399853c97b6", "placeholder": "​", "style": "IPY_MODEL_e00cdc5bdae043e3a6d20ac9f9c32daf", "tabbable": null, "tooltip": null, "value": "Completed: 100%" } }, "9b642a42b81144eab940994cc664f0bc": { "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 } }, "9e6398ae69a841b7bda1868c08e11e0e": { "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 } }, "a4b149b051e64a4383d42b28dac1d30a": { "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_8f5bfbb9b5f0456a99260a6d5d2ffb30", "max": 100.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_b2dbf432c96c4b82978a55780db47737", "tabbable": null, "tooltip": null, "value": 100.0 } }, "a8b59cd9e0034b83bd038b6a0e7232ef": { "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 } }, "b2dbf432c96c4b82978a55780db47737": { "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": "" } }, "b6b7604929964607a427cd70533075da": { "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": "" } }, "cb8767107b1a4a59bfb84d8d77570d28": { "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_63c9ff5cdfe845fcbd3c212d4a0dbec6", "IPY_MODEL_7e13c43378804fb683c563cc8471fd2b", "IPY_MODEL_0a6619660e3f4b7ea7855aaf09349c14" ], "layout": "IPY_MODEL_9b642a42b81144eab940994cc664f0bc", "tabbable": null, "tooltip": null } }, "de8408d560b94919af6ce13ae091eb89": { "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 } }, "e00cdc5bdae043e3a6d20ac9f9c32daf": { "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 } }, "e016e0e0ea9c4a63ad5d90674c0e4a9e": { "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 } }, "e0d6c8a175374d6aa782a4559f68e40e": { "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 } }, "ed5af3bb5366438fb4dd6a2c9f3fb118": { "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 } }, "fb3bbb779399412fa5e38a1c2f99f2e9": { "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 } }, "fd8f2b8522d540d5bd207e5d34b2a7dc": { "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_a8b59cd9e0034b83bd038b6a0e7232ef", "placeholder": "​", "style": "IPY_MODEL_840e9b6856c3457b8bca0f034510a069", "tabbable": null, "tooltip": null, "value": " [ elapsed time: 00:03 | time left: 00:00 ] " } }, "ffb792568ccf4ee68e855cf89bcf5d0e": { "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 }