{ "cells": [ { "cell_type": "markdown", "id": "ee6bbf81", "metadata": {}, "source": [ "# Overview\n", "\n", "A quantify-core experiment typically consists of a data-acquisition loop in\n", "which one or more parameters are set and one or more parameters are measured.\n", "\n", "The core of Quantify can be understood by understanding the following concepts:\n", "\n", "- {ref}Instruments and Parameters\n", "- {ref}Measurement Control\n", "- {ref}Settables and Gettables\n", "- {ref}Data storage\n", "- {ref}Analysis\n", "\n", "## Code snippets\n", "\n", "{seealso}\n", "The complete source code of the examples on this page can be found in\n", "\n", "{nb-download}concepts.ipynb\n", "" ] }, { "cell_type": "code", "execution_count": 1, "id": "ba3aa975", "metadata": { "mystnb": { "code_prompt_show": "Import common utilities used in the examples" }, "tags": [ "hide-cell" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Data will be saved in:\n", "/root/quantify-data\n" ] } ], "source": [ "import tempfile\n", "from pathlib import Path\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import xarray as xr\n", "from qcodes import Instrument, ManualParameter, Parameter, validators\n", "from scipy.optimize import minimize_scalar\n", "\n", "import quantify_core.data.handling as dh\n", "from quantify_core.analysis import base_analysis as ba\n", "from quantify_core.analysis import cosine_analysis as ca\n", "from quantify_core.measurement import Gettable, MeasurementControl\n", "from quantify_core.utilities.dataset_examples import mk_2d_dataset_v1\n", "from quantify_core.utilities.examples_support import mk_cosine_instrument\n", "from quantify_core.utilities.inspect_utils import display_source_code\n", "\n", "dh.set_datadir(dh.default_datadir())\n", "meas_ctrl = MeasurementControl(\"meas_ctrl\")" ] }, { "cell_type": "markdown", "id": "2fd1ff2c", "metadata": {}, "source": [ "# Instruments and Parameters\n", "\n", "## Parameter\n", "\n", "A parameter represents a state variable of the system. Parameters:\n", "\n", "- can be gettable and/or settable;\n", "- contain metadata such as units and labels;\n", "- are commonly implemented using the QCoDeS {class}~qcodes.parameters.Parameter class.\n", "\n", "A parameter implemented using the QCoDeS {class}~qcodes.parameters.Parameter class\n", "is a valid {class}.Settable and {class}.Gettable and as such can be used directly in\n", "an experiment loop in the {class}.MeasurementControl (see subsequent sections).\n", "\n", "## Instrument\n", "\n", "An Instrument is a container for parameters that typically (but not necessarily)\n", "corresponds to a physical piece of hardware.\n", "\n", "Instruments provide the following functionality:\n", "\n", "- Container for parameters.\n", "- A standardized interface.\n", "- Logging of parameters through the {meth}~qcodes.instrument.Instrument.snapshot method.\n", "\n", "All instruments inherit from the QCoDeS {class}~qcodes.instrument.Instrument class.\n", "They are displayed by default in the {class}.InstrumentMonitor\n", "\n", "# Measurement Control\n", "\n", "The {class}.MeasurementControl (meas_ctrl) is in charge of the data-acquisition loop\n", "and is based on the notion that, in general, an experiment consists of the following\n", "three steps:\n", "\n", "1. Initialize (set) some parameter(s),\n", "2. Measure (get) some parameter(s),\n", "3. Store the data.\n", "\n", "quantify-core provides two helper classes, {class}.Settable and {class}.Gettable to aid\n", "in these steps, which are explored further in later sections of this article.\n", "\n", "{class}.MeasurementControl provides the following functionality:\n", "\n", "- standardization of experiments;\n", "- standardization data storage;\n", "- {ref}live plotting of the experiment ;\n", "- {math}n-dimensional sweeps;\n", "- data acquisition controlled iteratively or in batches;\n", "- adaptive sweeps (measurement points are not predetermined at the beginning of an experiment).\n", "\n", "## Basic example, a 1D iterative measurement loop\n", "\n", "Running an experiment is simple!\n", "Simply define what parameters to set, and get, and what points to loop over.\n", "\n", "In the example below we want to set frequencies on a microwave source and acquire the\n", "signal from the Qblox Pulsar readout module:" ] }, { "cell_type": "code", "execution_count": 2, "id": "32426643", "metadata": { "mystnb": { "code_prompt_show": "Initialize (mock) instruments" }, "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "mw_source1 = Instrument(\"mw_source1\")\n", "\n", "# NB: for brevity only, this not the proper way of adding parameters to QCoDeS instruments\n", "mw_source1.freq = ManualParameter(\n", " name=\"freq\",\n", " label=\"Frequency\",\n", " unit=\"Hz\",\n", " vals=validators.Numbers(),\n", " initial_value=1.0,\n", ")\n", "\n", "pulsar_QRM = Instrument(\"pulsar_QRM\")\n", "# NB: for brevity only, this not the proper way of adding parameters to QCoDeS instruments\n", "pulsar_QRM.signal = Parameter(\n", " name=\"sig_a\", label=\"Signal\", unit=\"V\", get_cmd=lambda: mw_source1.freq() * 1e-8\n", ")" ] }, { "cell_type": "code", "execution_count": 3, "id": "5b54a5de", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Starting iterative measurement...\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "db8fdef6dd654048bf0c04484c2064b6", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Completed: 0%| [ elapsed time: 00:00 | time left: ? ] it" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "meas_ctrl.settables(\n", " mw_source1.freq\n", ") # We want to set the frequency of a microwave source\n", "meas_ctrl.setpoints(np.arange(5e9, 5.2e9, 100e3)) # Scan around 5.1 GHz\n", "meas_ctrl.gettables(pulsar_QRM.signal) # acquire the signal from the pulsar QRM\n", "dset = meas_ctrl.run(name=\"Frequency sweep\") # run the experiment" ] }, { "cell_type": "markdown", "id": "8299856b", "metadata": {}, "source": [ "The {class}.MeasurementControl can also be used to perform more advanced experiments\n", "such as 2D scans, pulse-sequences where the hardware is in control of the acquisition\n", "loop, or adaptive experiments in which it is not known what data points to acquire in\n", "advance, they are determined dynamically during the experiment.\n", "Take a look at some of the tutorial notebooks for more in-depth examples on\n", "usage and application.\n", "\n", "## Control Mode\n", "\n", "Batched mode can be used to deal with constraints imposed by (hardware) resources or to reduce overhead.\n", "\n", "In **iterative mode** , the measurement control steps through each setpoint one at a time,\n", "processing them one by one.\n", "\n", "In **batched mode** , the measurement control vectorizes the setpoints such that they are processed in batches.\n", "The size of these batches is automatically calculated but usually dependent on resource\n", "constraints; you may have a device that can hold 100 samples but you wish to sweep over 2000 points.\n", "\n", "{note}\n", "The maximum batch size of the settable(s)/gettable(s) should be specified using the\n", ".batch_size attribute. If not specified infinite size is assumed and all setpoint\n", "are passed to the settable(s).\n", "\n", "\n", "{tip}\n", "In *Batched* mode it is still possible to perform outer iterative sweeps with an inner\n", "batched sweep.\n", "This is performed automatically when batched settables (.batched=True) are mixed\n", "with iterative settables (.batched=False). To correctly grid the points in this mode\n", "use {meth}.MeasurementControl.setpoints_grid.\n", "\n", "\n", "Control mode is detected automatically based on the .batched attribute of the\n", "settable(s) and gettable(s); this is expanded upon in subsequent sections.\n", "\n", "{note}\n", "All gettables must have the same value for the .batched attribute.\n", "Only when all gettables have .batched=True, settables are allowed to have mixed\n", ".batched attribute (e.g. settable_A.batched=True, settable_B.batched=False).\n", "\n", "\n", "Depending on which control mode the {class}.MeasurementControl is running in,\n", "the interfaces for Settables (their input interface) and Gettables\n", "(their output interface) are slightly different.\n", "\n", "It is also possible for batched gettables to return an array with a length less\n", "than the length of the setpoints, and similarly for the input of the Settables.\n", "This is often the case when working with resource-constrained devices, for\n", "example, if you have *n* setpoints but your device can load only less than *n*\n", "datapoints into memory. In this scenario, measurement control tracks how many\n", "datapoints were actually processed, automatically adjusting the size of the next\n", "batch." ] }, { "cell_type": "code", "execution_count": 4, "id": "1dbb3573", "metadata": { "mystnb": { "code_prompt_show": "Example" }, "tags": [ "hide-cell" ] }, "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 time \n", "Batch size limit: 5\n", "\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "bcff16b9d6864cb78852017153b6d376", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Completed: 0%| [ elapsed time: 00:00 | time left: ? ] it" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "[]" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "