LabOne Q User Manual

https://docs.zhinst.com/labone_q_user_manual/
Admin
LabOne Q is a Python-based domain-specific language designed to control complex quantum computing...
Tokens:487,615
Snippets:5,254
Trust Score:10
Update:2 months ago
Show doc for...
Tokens:
Raw
### Import LabOne Q Example Helpers

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/04_quantum_processing_unit/tutorials/01_quantum_elements.ipynb

Imports necessary packages for generating device setups in LabOne Q examples.

```python
from __future__ import annotations

import laboneq.serializers

# Import required packages
from laboneq.contrib.example_helpers.generate_device_setup import (
    generate_device_setup,
)
```

--------------------------------

### Programmatic Device Setup with Instrument Options

Source: https://docs.zhinst.com/labone_q_user_manual/release_notes/previous_versions.html

Example of programmatically constructing a device setup, emphasizing the requirement to include instrument options. This can be done via the 'options' field or the `device_options` argument.

```python
device_setup = DeviceSetup(
    instruments=[
        {
            "name": "hdawg_1",
            "device_options": {"port_width": 1000},
            "options": {"னமாக": True}
        }
    ]
)
```

--------------------------------

### Using generate_device_setup Helper Function

Source: https://docs.zhinst.com/labone_q_user_manual/release_notes/previous_versions.html

Demonstrates the usage of the `generate_device_setup` helper function from `contrib` to automatically query instruments for installed options when constructing a device setup.

```python
from zhinst.laboneqt.contrib.device_setup_helpers import generate_device_setup

setup = generate_device_setup(connection_info=connection_info, device_ids=device_ids)
```

--------------------------------

### Programmatic Device Setup Generation

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/00_device_setup/tutorials/00_device_setup.ipynb

Generate a large-scale device setup programmatically by adding instruments and connections. This example demonstrates setting up a PQSC and multiple SHFSG instruments for controlling 64 qubits.

```python
scaled_setup = DeviceSetup("my_scaled_setup")
scaled_setup.add_dataserver(host="111.22.33.44", port="8004")
scaled_setup.add_instruments(
    PQSC(uid="pqsc", address="dev10001", reference_clock_source="internal")
)
```

```python
for i in range(8):
    scaled_setup.add_instruments(SHFSG(uid=f"shfsg_{i}", address=f"dev1212{i}"))
    scaled_setup.add_connections(
        f"shfsg_{i}",
        *[
            create_connection(
                to_signal=f"q{i * 8 + _}/drive", ports=f"SGCHANNELS/{_}/OUTPUT"

```

--------------------------------

### Setup Demonstration Device

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/10_advanced_topics/tutorials/06_context_based_dsl.ipynb

Configure the device setup and helper functions for simulation.

```python
# Example device setup creator:
from laboneq.contrib.example_helpers.generate_device_setup import (
    generate_device_setup_qubits,
)

# Helpers:
from laboneq.contrib.example_helpers.plotting.plot_helpers import plot_simulation
```

--------------------------------

### Generate Device Setup and Qubits

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/08_openqasm/tutorials/00_program_to_experiment.ipynb

Generates a device setup and qubit objects using a helper function. This setup is used for subsequent examples.

```python
from laboneq.contrib.example_helpers.generate_device_setup import (
    generate_device_setup_qubits,
)

# Select the number of qubits
number_of_qubits = 3

# Generate the device setup and the qubit objects using a helper function
device_setup, qubits = generate_device_setup_qubits(
    number_qubits=number_of_qubits,
    pqsc=[{"serial": "DEV10001"}],
    hdawg=[
        {
            "serial": "DEV8001",
            "zsync": 0,
            "number_of_channels": 8,
            "options": None,
        }
    ],
    shfqa=[
        {
            "serial": "DEV12001",
            "zsync": 1,
            "readout_multiplex": 6,
            "options": None,
        }
    ],
    shfsg=[
        {
            "serial": "DEV12002",
            "zsync": 2,
            "number_of_channels": 8,
            "options": None,
        }
    ],
    include_flux_lines=True,
    server_host="localhost",
    setup_name=f"my_{number_of_qubits}_tunable_qubit_setup",
)
```

--------------------------------

### Configure Device Setup

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/05_experiment/tutorials/00_experiment_definition_reference.ipynb

Load a device setup from a descriptor, specifying server details and setup name. This is a prerequisite for running experiments.

```python
device_setup = DeviceSetup.from_descriptor(
    descriptor,
    server_host="111.22.33.44",
    server_port="8004",
    setup_name="ZI_QCCS",
)
calibrate_devices(device_setup)
```

--------------------------------

### Initialize Device Setup and Qubits

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/how-to-guides/sources/04_qasm/01_VQE_Qiskit.ipynb

Setup the hardware configuration and initialize qubit objects using a helper function.

```python
# specify the number of qubits you want to use
number_of_qubits = 2

# generate the device setup and the qubit objects using a helper function
device_setup, qubits = generate_device_setup_qubits(
    number_qubits=number_of_qubits,
    pqsc=[{"serial": "DEV10001"}],
    hdawg=[{"serial": "DEV8001", "number_of_channels": 8, "options": None}],
    shfqc=[
        {
            "serial": "DEV12001",
            "number_of_channels": 6,
            "readout_multiplex": 6,
            "options": None,
        }
    ],
    include_flux_lines=True,
    server_host="localhost",
    setup_name=f"my_{number_of_qubits}_tuneable_qubit_setup",
)

q0, q1 = qubits[:2]
```

--------------------------------

### Create and Configure a Spin Locking Experiment

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/reference/contrib/experiments/spin_locking.html

Example demonstrating the setup of a QPU and the creation of a spin locking experiment with specific sweep lengths and options.

```python
options = {
    "count": 10,
    "transition": "ge",
    "averaging_mode": "cyclic",
    "acquisition_type": "integration_trigger",
    "cal_traces": True,
}
options = TuneupExperimentOptions(**options)
setup = DeviceSetup()
qpu = QPU(
    setup=DeviceSetup("my_device"),
    qubits=[TunableTransmonQubit("q0"), TunableTransmonQubit("q1")],
    quantum_operations=TunableTransmonOperations(),
)
create_experiment(
    qpu=qpu,
    qubits=["q0", "q1"],
    lengths=[[1e-6, 5e-6, 10e-6], [1e-6, 5e-6, 10e-6]]
    options=options,
)
```

--------------------------------

### Initialize a demonstration QuantumPlatform and Device Setup

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/tutorials/sources/writing_experiments.ipynb

Sets up a pre-configured QuantumPlatform with tunable-transmon qubits and a corresponding Device_Setup. This is useful for testing and development when a custom setup is not yet available.

```python
# Create a demonstration QuantumPlatform for a six-tunable-transmon QPU:
qt_platform = demo_platform(n_qubits=3)

# The platform contains a setup, which is an ordinary LabOne Q DeviceSetup:
setup = qt_platform.setup

# And a tunable-transmon QPU:
qpu = qt_platform.qpu

# Inside the QPU, we have quantum elements, which is a list of six LabOne Q Application
# Library TunableTransmonQubit qubits:
qubits = qpu.quantum_elements
```

--------------------------------

### Device Setup Configuration

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/how-to-guides/sources/02_spin_qubits/03_UHFLI_pulsed_acquisition.ipynb

Initializes the device setup using a descriptor string and applies the calibration.

```python
descriptor = """\
instruments:
  HDAWG:
  - address: DEV8434
    uid: device_hdawg
    interface: usb
  UHFLI:
  - address: DEV2283
    uid: device_uhfli
    # interface: usb
connections:
  device_hdawg:
    - iq_signal: q0/drive_line
      ports: [SIGOUTS/4, SIGOUTS/5]
    - rf_signal: q0/coulomb_line_1
      ports: [SIGOUTS/0]
    - rf_signal: q0/coulomb_line_2
      ports: [SIGOUTS/1]
"""

device_setup = DeviceSetup.from_descriptor(
    descriptor,
    server_host="your_ip_address",
    server_port=8004,
    setup_name="MySetup",
)
calibrate_devices(device_setup)
```

--------------------------------

### Configuring Device Setup

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/how-to-guides/sources/01_superconducting_qubits/02_pulse_sequences/01_tuneup/16_Flux_scope_experiment_shfsg_shfqa_shfqc_hdawg.ipynb

Generates the device setup and qubit objects for the experiment.

```python
# specify the number of qubits you want to use
number_of_qubits = 2

# generate the device setup and the qubit objects using a helper function
device_setup, qubits = generate_device_setup_qubits(
    number_qubits=number_of_qubits,
    pqsc=[{"serial": "DEV10001"}],
    hdawg=[
        {
            "serial": "DEV8001",
            "number_of_channels": 8,
            "options": None,
        }
    ],
    shfqc=[
        {
            "serial": "DEV12001",
            "number_of_channels": 6,
            "readout_multiplex": 6,
            "options": None,
        }
    ],
    multiplex_drive_lines=True,
    include_flux_lines=True,
    server_host="localhost",
    setup_name=f"my_{number_of_qubits}_tunable_qubit_setup",
)

q0, q1 = qubits[:2]
```

--------------------------------

### Initialize Device Setup and Signals

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/how-to-guides/sources/03_color_centers/00_shfsg_basic_experiments.ipynb

Initializes the device setup and retrieves the address of the first instrument and the logical signals for 'q0'. This is a preparatory step before establishing a session.

```python
device_setup = create_device_setup()
shfsg_address = device_setup.instruments[0].address

q0 = device_setup.logical_signal_groups["q0"].logical_signals
```

--------------------------------

### Install LabOne Q Applications Library

Source: https://docs.zhinst.com/labone_q_user_manual/getting_started/installation.html

Installs the Applications Library for ready-to-use solutions. Run this within your Python environment.

```bash
pip install --upgrade laboneq_applications
```

--------------------------------

### Install Benchmark Package

Source: https://docs.zhinst.com/labone_q_user_manual/core/benchmarking/benchmarking.html

Install the standalone benchmarking package from the source folder. This requires an existing LabOne Q installation (minimum version 2.41.0).

```bash
uv pip install -e .
```

--------------------------------

### Define device setup and connect to session

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/10_advanced_topics/tutorials/07_PRNG_usage.ipynb

Configures the device setup, including adding a data server and instruments like SHFQC, and establishes connections for signal routing. A minimal calibration is also applied.

```python
device_setup = DeviceSetup(uid="my_QCCS")

device_setup.add_dataserver(host="localhost", port="8004")

device_setup.add_instruments(
    SHFQC(uid="device_shfqc", address="dev12345", device_options="SHFQC/QC6CH")
)

device_setup.add_connections(
    "device_shfqc",
    create_connection(to_signal="q0/drive_line", ports="SGCHANNELS/0/OUTPUT"),
    create_connection(to_signal="q0/measure_line", ports="QACHANNELS/0/OUTPUT"),
    create_connection(to_signal="q0/acquire_line", ports="QACHANNELS/0/INPUT"),
)

# set a minimal calibration to device setup
drive_lo = Oscillator(frequency=1e9)
measure_lo = Oscillator(frequency=4e9)
cal = Calibration()
cal["/logical_signal_groups/q0/drive_line"] = SignalCalibration(
    local_oscillator=drive_lo
)
cal["/logical_signal_groups/q0/measure_line"] = SignalCalibration(

```

--------------------------------

### Configuring device setup

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/how-to-guides/sources/02_spin_qubits/01_QCoDeS_sweeps.ipynb

Defines the device setup using a YAML-style descriptor string.

```python
descriptor = """\
instruments:
  MFLI:
  - address: DEV5534
    uid: device_mfli
"""

device_setup = DeviceSetup.from_descriptor(
    descriptor,
    server_host="your_ip_address",
    server_port=8004,
    setup_name="MySetup",
)
```

--------------------------------

### Device Setup

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/how-to-guides/sources/02_spin_qubits/00_neartime_callback_sweeps.ipynb

Configuration of the device setup using a descriptor string and connection to the server.

```python
descriptor = """\
instruments:
  MFLI:
  - address: DEV5534
    uid: device_mfli
"""

device_setup = DeviceSetup.from_descriptor(
    descriptor,
    server_host="your_ip_address",
    server_port=8004,
    setup_name="MySetup",
)
```

```python
class EmulatedMFLI(MagicMock):
    """An dummy MFLI for emulation mode."""

    def __float__(self):
        return 0

    def __array__(self):
        return np.array(0)
```

```python
# create and connect to session
session = Session(device_setup=device_setup)
session.connect(do_emulation=True)
```

--------------------------------

### LabOne Q Imports

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/how-to-guides/sources/01_superconducting_qubits/02_pulse_sequences/01_tuneup/01_cw_resonator_spec_shfsg_shfqa_shfqc.ipynb

Imports necessary modules from `laboneq.simple` and helper functions for generating device setups and plotting results. This is the standard starting point for LabOne Q experiments.

```python
import time
from pathlib import Path

# Helpers:
from laboneq.contrib.example_helpers.generate_device_setup import (
    generate_device_setup_qubits,
)
from laboneq.contrib.example_helpers.plotting.plot_helpers import plot_results

# LabOne Q:
from laboneq.simple import *
```

--------------------------------

### Device Setup with PQSC, SHFQA, and SHFsg

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/00_device_setup/tutorials/00_device_setup.ipynb

Configures a device setup including a PQSC, SHFQA, and SHFsg. This setup is useful for complex experiments requiring multiple instruments.

```python
descriptor = """\
instruments:
  SHFSG:
  - address: DEV10001
    uid: shfsg
    options: SHFQA2/16W
  PQSC:
  - address: DEV10000
    uid: pqsc
    options: PQSC
connections:
  shfsg:
    - iq_signal: q0/drive
      ports: SGCHANNELS/0/OUTPUT
  shfqa:
    - iq_signal: q0/measure
      ports: QACHANNELS/0/OUTPUT
    - acquire_signal: q0/acquire
      ports: QACHANNELS/0/INPUT
"""

device_setup_pqsc_shf_instruments = DeviceSetup.from_descriptor(
    descriptor,
    server_host="111.22.33.44",
    server_port="8004",
)
```

--------------------------------

### Create a tunable transmon setup

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/tutorials/sources/getting_started.ipynb

Uses a helper function to quickly create a dummy setup for prototyping transmon qubits in emulation mode.

```python
from laboneq_applications.qpu_types.tunable_transmon.demo_qpus import (
    tunable_transmon_setup,
)

setup = tunable_transmon_setup(n_qubits=3)
```

--------------------------------

### Create Device Setup from Descriptor

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/how-to-guides/sources/02_spin_qubits/02_MFLI_cw_acquisition.ipynb

Initializes a device setup using a descriptor string, specifying instruments (MFLI, HDAWG) and their connections. It also includes calibration of devices.

```python
descriptor = """
instruments:
  MFLI:
  - address: DEV5534
    uid: device_mfli
  HDAWG:
  - address: DEV8434
    uid: device_hdawg
    interface: usb
connections:
  device_hdawg:
    - iq_signal: q0/drive_line
      ports: [SIGOUTS/4, SIGOUTS/5]
    - rf_signal: q0/coulomb_line_1
      ports: [SIGOUTS/0]
    - rf_signal: q0/coulomb_line_2
      ports: [SIGOUTS/1]
    # - external_clock_signal
"""

device_setup = DeviceSetup.from_descriptor(
    descriptor,
    server_host="your_ip_address",
    server_port=8004,
    setup_name="MySetup",
)
calibrate_devices(device_setup)
```

--------------------------------

### Initialize Device Setup and Calibration

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/how-to-guides/sources/01_superconducting_qubits/02_pulse_sequences/02_advanced_qubit_experiments/02_active_qudit_reset_shfsg_shfqa_shfqc.ipynb

Initializes the device setup and retrieves/sets calibration parameters for active reset. This is crucial for defining the experimental parameters for qubit control.

```python
active_reset_calibration = Calibration()
active_reset_calibration["/logical_signal_groups/q0/measure"] = (
    device_setup.get_calibration()["/logical_signal_groups/q0/measure"]
)
active_reset_calibration["/logical_signal_groups/q3/measure"] = (
    device_setup.get_calibration()["/logical_signal_groups/q0/measure"]
)
active_reset_calibration["/logical_signal_groups/q0/acquire"] = (
    device_setup.get_calibration()["/logical_signal_groups/q0/acquire"]
)
active_reset_calibration["/logical_signal_groups/q0/acquire"].oscillator = None

device_setup.set_calibration(active_reset_calibration)
```

--------------------------------

### Import Helper for Device Setup and Qubits

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/04_quantum_processing_unit/tutorials/00_quantum_operations.ipynb

Imports the necessary helper function to generate a device setup and qubits for quantum experiments.

```python
from __future__ import annotations  # needed for type setting in python 3.9

from laboneq.contrib.example_helpers.generate_device_setup import (
    generate_device_setup_qubits,
)
```

--------------------------------

### Create DeviceSetup from Descriptor String

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/00_device_setup/concepts/index.html

Instantiate a DeviceSetup object using a descriptor string, specifying server host, port, and a setup name. This method is useful for defining setups directly within your code.

```python
device_setup = DeviceSetup.from_descriptor(
    descriptor,
    server_host="111.22.33.44",
    server_port="8004",
    setup_name="ZI_QCCS",
)

```

--------------------------------

### Create Device Setup Function

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/how-to-guides/sources/03_color_centers/00_shfsg_basic_experiments.ipynb

A function to create a device setup, accepting a descriptor and server host. This is a boilerplate function for setting up LabOne Q experiments.

```python
def create_device_setup(
    descriptor=descriptor_shfsg_nv,
    serverhost="localhost",
):

```

--------------------------------

### Generate Device Setup

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/how-to-guides/sources/04_qasm/02_RandomizedBenchmarking_from_Qiskit.ipynb

Initializes the device setup using a helper function. Adjust device identifiers to match your specific hardware configuration.

```python
# generate the device setup using a helper function
from laboneq.contrib.example_helpers.generate_device_setup import (
    generate_device_setup,
)

setup = generate_device_setup(

```

--------------------------------

### Example marker configuration

Source: https://docs.zhinst.com/labone_q_user_manual/core/reference/dsl/experiment.html

Example dictionary structure for the marker argument in the play command.

```python
marker={"marker1": {"enable": True}}
```

--------------------------------

### Create Device Setup

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/how-to-guides/sources/03_color_centers/00_shfsg_basic_experiments.ipynb

Creates a device setup from a YAML descriptor. Ensure the server host and port are correctly specified. This function is used to initialize the connection to the SHFSG.

```python
device_setup = DeviceSetup.from_descriptor(
        yaml_text=descriptor,
        server_host=serverhost,
        server_port="8004",
        setup_name="SHFSG_Standalone",
    )
    calibrate_devices(device_setup)
    return device_setup
```

--------------------------------

### Trigger state bit field examples

Source: https://docs.zhinst.com/labone_q_user_manual/core/reference/dsl/experiment.html

Examples of bit field values for trigger signals.

```python
    {"state": 1}  # raise trigger signal 1
    {"state": 0b10}  # raise trigger signal 2 (on supported devices)
    {"state": 0b11}  # raise both trigger signals
```

--------------------------------

### Generate a custom device setup

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/tutorials/sources/getting_started.ipynb

Configures a specific instrument setup including PQSC, HDAWG, and SHFQC instruments with custom options.

```python
from laboneq.contrib.example_helpers.generate_device_setup import (
    generate_device_setup,
)

# specify the number of qubits you want to use
number_of_qubits = 3

# generate the device setup using a helper function
setup = generate_device_setup(
    number_qubits=number_of_qubits,
    pqsc=[{"serial": "DEV10001"}],
    hdawg=[
        {
            "serial": "DEV8001",
            "number_of_channels": 8,
            "options": "HDAWG8/CNT/MF/ME",
        }
    ],
    shfqc=[
        {
            "serial": "DEV12001",
            "number_of_channels": 6,
            "readout_multiplex": 3,
            "options": "SHFQC/QC6CH/PLUS/RTR",
        }
    ],
    include_flux_lines=True,
    multiplex_drive_lines=True,  # adds drive_ef
    server_host="localhost",
    setup_name="my_setup",
)
```

--------------------------------

### Define Setup with PQSC, HDAWG, UHFQA

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/00_device_setup/concepts/index.html

Use this descriptor to define a setup including a PQSC for synchronization, an HDAWG for control, and a UHFQA for readout. It also includes dataserver configuration. Ensure ZSync port assignments on the PQSC match the actual setup to avoid errors.

```yaml
descriptor = """
dataservers:
  my_qccs_system:
    host: 127.0.0.1
    port: 8004
    instruments: [device_hdawg, device_uhfqa, device_pqsc]
instruments:
  HDAWG:
  - address: DEV8000
    uid: device_hdawg
  UHFQA:
  - address: DEV2000
    uid: device_uhfqa
  PQSC:
  - address: DEV10000
    uid: device_pqsc
connections:
  device_hdawg:
    - iq_signal: q0/drive_line
      ports: [SIGOUTS/0, SIGOUTS/1]
    - rf_signal: q0/flux_line
      ports: [SIGOUTS/2]
    - to: device_uhfqa
      port: DIOS/0
  device_uhfqa:
    - iq_signal: q0/measure_line
      ports: [SIGOUTS/0, SIGOUTS/1]
    - acquire_signal: q0/acquire_line
"""

```

--------------------------------

### Linear Frequency Sweep Example

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/03_sections_pulses/tutorials/03_frequency_sweep_examples.ipynb

This example demonstrates how to set up and simulate a linear frequency sweep. It defines the start, stop, and count for the sweep parameters and then calls the simulation function.

```python
# Linear frequency sweep parameters
freq_sweep_linear = LinearSweepParameter(
    uid="linear_frequency",
    start=50e6,  # -50 MHz relative to LO (6.95 GHz)
    stop=100e6,  # +50 MHz relative to LO (7.05 GHz)
    count=5,  # 101 frequency points (1 MHz steps)
)

compile_and_simulate_experiment(freq_sweep_linear)
```

--------------------------------

### Load Setup and QPU from File

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/how-to-guides/sources/01_superconducting_qubits/01_workflows/04_amplitude_rabi.ipynb

Alternative method to load existing DeviceSetup and QPU configurations from JSON files.

```python
from laboneq import serializers

setup = serializers.load(full_path_to_device_setup_file)
qpu = serializers.load(full_path_to_qpu_file)

qubits = qpu.quantum_elements
```

--------------------------------

### Set up Demo Platform and Session

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/tutorials/sources/experiment_workflow_automation.ipynb

Initializes a demo platform with six qubits, sets up the QPU and qubits, and establishes a connected session for emulation.

```python
qt_platform = demo_platform(n_qubits=6)
setup = qt_platform.setup
qpu = qt_platform.qpu
qubits = qpu.quantum_elements
session = Session(setup)
session.connect(do_emulation=True)
```

--------------------------------

### list_calibratables()

Source: https://docs.zhinst.com/labone_q_user_manual/core/reference/dsl/experiment.html

Return a dictionary of calibration creation information for the device setup signals mapped to this experiment.

```APIDOC
## list_calibratables()

### Description
Return a dictionary of calibration creation information for the device setup signals mapped to this experiment.

### Returns
- **calibratables** (dict[str, dict]) - A dictionary of calibratable signal UIDs and their corresponding creation information.
```

--------------------------------

### Python Imports for LabOne Q Examples

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/how-to-guides/sources/01_superconducting_qubits/02_pulse_sequences/01_tuneup/12_length_rabi_experiment_shfsg_shfqa_shfqc_hdawg.ipynb

Imports necessary helper functions for device setup and plotting, along with core LabOne Q functionalities.

```python
# Helpers:
from laboneq.contrib.example_helpers.generate_device_setup import (
    generate_device_setup_qubits,
)
from laboneq.contrib.example_helpers.plotting.plot_helpers import *

# LabOne Q:
from laboneq.simple import *
```

--------------------------------

### Python Imports for LabOne Q Examples

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/how-to-guides/sources/01_superconducting_qubits/02_pulse_sequences/01_tuneup/09_e-f_gate_tuneup_shfsg_shfqc.ipynb

Imports necessary helper functions for device setup and plotting, along with the core LabOne Q library.

```python
# Helpers:
from laboneq.contrib.example_helpers.generate_device_setup import (
    generate_device_setup_qubits,
)
from laboneq.contrib.example_helpers.plotting.plot_helpers import plot_simulation

# LabOne Q:
from laboneq.simple import *
```

--------------------------------

### Calibrate Devices Function

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/10_advanced_topics/tutorials/01_neartime_callbacks.ipynb

A function to modify calibration settings on a given device setup. This example shows how to access and set parameters for qubit drive lines.

```python
# functions that modifies the calibration on a given device setup


def calibrate_devices(device_setup):
    ## qubit 0
    # calibration setting for drive line for qubit 0
    device_setup.logical_signal_groups["q0"].logical_signals[
        "drive_line"
    ]
```

--------------------------------

### QuantumElement.from_device_setup()

Source: https://docs.zhinst.com/labone_q_user_manual/core/reference/dsl/quantum.html

Creates a list of quantum elements from a device setup.

```APIDOC
## QuantumElement.from_device_setup(device_setup, qubit_uids=None, parameters=None)

### Description
Create a list of quantum elements from a device setup.

### Parameters
- **device_setup** (DeviceSetup) - Required - The device setup to create the quantum elements from.
- **qubit_uids** (list[str] | None) - Optional - The set of logical signal group uids to create qubits from. Default: None
- **parameters** (dict[str, QuantumParameters | dict[str, Any]] | None) - Optional - A dictionary mapping quantum element UIDs to the parameters for that quantum element. Default: None

### Returns
- **list[QuantumElement]** - A list of quantum elements.
```

--------------------------------

### Import necessary libraries for LabOne Q

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/10_advanced_topics/tutorials/04_advanced_sweeping_examples.ipynb

Imports standard libraries and specific modules from LabOne Q for experiment setup, DSL, and plotting. Ensure these are installed in your environment.

```python
from __future__ import annotations

import numpy as np

from laboneq.contrib.example_helpers.plotting.plot_helpers import plot_simulation
from laboneq.dsl.experiment.builtins import *
from laboneq.simple import *
```

--------------------------------

### reset_calibration(calibration=None)

Source: https://docs.zhinst.com/labone_q_user_manual/core/reference/dsl/experiment.html

Resets the signal calibration for all device setup signals mapped in the experiment.

```APIDOC
## reset_calibration(calibration=None)

### Description
Reset the experiment calibration. Resets the signal calibration for all device setup signals mapped in this experiment.

### Parameters
- **calibration** (Calibration | None) - Optional - The calibration to apply after resetting the experiment calibration.
```

--------------------------------

### Import LabOne Q Packages

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/03_sections_pulses/tutorials/00_section_tutorial.ipynb

Import necessary modules from the LabOne Q library for creating experiments and generating device setups. Ensure LabOne Q is installed.

```python
# Import required packages
from laboneq.contrib.example_helpers.generate_device_setup import (
    generate_device_setup_qubits,
)
from laboneq.simple import * 
```

--------------------------------

### QuantumPlatform(setup, qpu)

Source: https://docs.zhinst.com/labone_q_user_manual/core/reference/dsl/quantum.html

Initializes a quantum hardware platform by combining a DeviceSetup and a QPU.

```APIDOC
## QuantumPlatform(setup, qpu)

### Description
Initializes a new quantum hardware platform, which provides the logical description of a quantum device and the control hardware needed to compile experiments.

### Parameters
- **setup** (DeviceSetup) - Required - The DeviceSetup describing the control hardware.
- **qpu** (QPU) - Required - The QPU describing the parameters and topology of the quantum device.
```

--------------------------------

### Handle Duplicate Instrument IDs

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/00_device_setup/tutorials/00_device_setup.ipynb

Attempting to add an instrument with an ID that already exists in the device setup will raise a LabOneQException. This example demonstrates how to catch this expected exception.

```python
try:
    device_setup.add_instruments(PQSC(uid="pqsc"))
except:
    print("LabOneQException as expected: Instrument already in device setup")
```

--------------------------------

### Fire a trigger pulse

Source: https://docs.zhinst.com/labone_q_user_manual/core/reference/dsl/experiment.html

Example of firing a trigger pulse on a specific signal line within a section.

```python
    with exp.section(..., trigger={"drive_line": {"state": 0b01}}):
        ...
```

--------------------------------

### LabOne Q Imports and Helper Functions

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/how-to-guides/sources/01_superconducting_qubits/02_pulse_sequences/01_tuneup/01_spec_uhfqa_hdawg.ipynb

Imports necessary modules from `laboneq.simple` and helper functions for device setup and plotting. Ensure these imports are present before running the examples.

```python
from pathlib import Path

# Helpers:
from laboneq.contrib.example_helpers.generate_device_setup import (
    generate_device_setup_qubits,
)
from laboneq.contrib.example_helpers.plotting.plot_helpers import (
    plot_results,
    plot_simulation,
)

# LabOne Q:
from laboneq.simple import *
```

--------------------------------

### Python Imports for LabOne Q Examples

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/how-to-guides/sources/01_superconducting_qubits/02_pulse_sequences/01_tuneup/14_Ramsey_experiment_sampled_pulse_shfsg_shfqa_shfqc_hdawg.ipynb

Imports necessary libraries including NumPy and helper functions for device setup and plotting, along with core LabOne Q functionalities.

```python
import numpy as np

# Helpers:
from laboneq.contrib.example_helpers.generate_device_setup import (
    generate_device_setup_qubits,
)
from laboneq.contrib.example_helpers.plotting.plot_helpers import *

# LabOne Q:
from laboneq.simple import *
```

--------------------------------

### from_yaml

Source: https://docs.zhinst.com/labone_q_user_manual/core/reference/dsl/device.html

Constructs the device setup from a provided YAML file path.

```APIDOC
## from_yaml

### Description
Construct the device setup from a YAML file.

### Parameters
- **filepath** (str) - Required - Path to the YAML file containing the device description.
- **server_host** (str) - Optional - Server host of the setup that should be created.
- **server_port** (str) - Optional - Port of the server that should be created.
- **setup_name** (str) - Optional - Name of the setup that should be created.
```

--------------------------------

### Device Descriptor for PQSC and SHF Instruments

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/00_device_setup/tutorials/00_device_setup.ipynb

A device descriptor example for setups using SHF series instruments (SHFSG, SHFQA, SHFQC), highlighting their single-port requirement per signal line due to integrated conversion.

```yaml
descriptor = """\
instruments:
  SHFSG:
  - address: DEV12000
    uid: shfsg
    options: SHFSG8/RTR
  SHFQA:
  - address: DEV12001
    uid: shfqa

```

--------------------------------

### Initialize DeviceSetup

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/00_device_setup/tutorials/00_device_setup.ipynb

Creates a new DeviceSetup instance, typically named after the system it represents, like "ZI_QCCS".

```python
device_setup = DeviceSetup("ZI_QCCS")
```

--------------------------------

### Connect and Run Experiment

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/05_experiment/tutorials/00_experiment_definition_reference.ipynb

Establish a session with the device setup and connect to the server, optionally enabling emulation. Then, run the defined experiment and retrieve the results.

```python
session = Session(device_setup=device_setup)
session.connect(do_emulation=True)
my_results = session.run(exp)
```

--------------------------------

### Device Setup for a Single HDAWG

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/00_device_setup/tutorials/00_device_setup.ipynb

Configures a device setup for a standalone HDAWG. This setup is used when only an HDAWG is needed for signal generation.

```python
descriptor = """\
instruments:
  HDAWG:
  - address: dev8000
    uid: hdawg
    options: HDAWG8/CNT/MF/ME/PC/SKW/IQ
connections:
  hdawg:
    - iq_signal: q0/drive
      ports: [SIGOUTS/0, SIGOUTS/1]
    - rf_signal: q0/flux
      ports: [SIGOUTS/2]
"""

device_single_hdawg = DeviceSetup.from_descriptor(
    descriptor,
    server_host="111.22.33.44",
    server_port="8004",
)
```

--------------------------------

### Connect Session and Run Experiment

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/how-to-guides/sources/02_spin_qubits/04_HDAWG_pulse_sequences.ipynb

Establishes a connection to the device setup, sets the signal map for the experiment, and runs the compiled experiment. Ensure `DO_EMULATION` is set appropriately.

```python
# create and connect to session
session = Session(device_setup=device_setup)
session.connect(do_emulation=DO_EMULATION)

# set signal map
exp.set_signal_map(map_q0)

_ = session.run(exp)
```

--------------------------------

### Install scikit-optimize

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/how-to-guides/sources/01_superconducting_qubits/02_pulse_sequences/02_advanced_qubit_experiments/03_neartime_gate_fidelity_optimization.ipynb

Installs the scikit-optimize package required for this notebook.

```python
# Package installation for this notebook
%pip install scikit-optimize
```

--------------------------------

### Create a demo QuantumPlatform

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/tutorials/sources/experiment_workflows.ipynb

Initializes a demonstration QuantumPlatform for a tunable-transmon QPU with a specified number of qubits. This is used for running experiments in emulation mode.

```python
# Create a demonstration QuantumPlatform for a tunable-transmon QPU:
qt_platform = demo_platform(n_qubits=6)

```

--------------------------------

### Load Qubits from Device Setup

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/04_quantum_processing_unit/tutorials/01_quantum_elements.ipynb

Load qubit objects from a previously generated device setup. Ensure the `Transmon` class matches the quantum element type in your setup.

```python
qubits = Transmon.from_device_setup(device_setup)
```

--------------------------------

### Create Device Setup from Descriptor

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/00_device_setup/tutorials/00_device_setup.ipynb

Construct a `DeviceSetup` instance from a device descriptor string. This method allows for defining instruments, their addresses, UIDs, options, and connections in a human-readable format. Ensure the server host and port are correctly specified.

```python
descriptor = """\
instruments:
  PQSC:
  - address: dev10001
    uid: pqsc
    options: PQSC
  SHFQA:
  - address: dev12000
    uid: shfqa
    options: SHFQA4
  SHFSG:
  - address: dev12001
    uid: shfsg
    options: SHFSG8/RTR
connections:
  shfsg:
    - iq_signal: q0/drive
      ports: SGCHANNELS/0/OUTPUT
  shfqa:
    - iq_signal: q0/measure
      ports: QACHANNELS/0/OUTPUT
    - acquire_signal: q0/acquire
      ports: QACHANNELS/0/INPUT
"""

device_setup_from_descriptor = DeviceSetup.from_descriptor(
    descriptor,
    server_host="111.22.33.44",
    server_port="8004",
)
```

--------------------------------

### Device Setup with SHFQA LRT Option

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/10_advanced_topics/tutorials/10_long_readout_time.ipynb

Generates a device setup including qubits, specifying the SHFQA instrument with the 'SHFQA4/LRT' option enabled. This setup is for a tuneable qubit system.

```python
# specify the number of qubits you want to use
number_of_qubits = 2

# generate the device setup and the qubit objects using a helper function
device_setup, qubits = generate_device_setup_qubits(
    number_qubits=number_of_qubits,
    pqsc=[{"serial": "DEV10056"}],
    shfsg=[
        {
            "serial": "DEV12001",
            "zsync": 1,
            "number_of_channels": 8,
            "options": "SHFSG8/RTR",
        }
    ],
    shfqa=[
        {
            "serial": "DEV12002",
            "zsync": 2,
            "number_of_channels": 4,
            "readout_multiplex": 6,
            "options": "SHFQA4/LRT",
        }
    ],
    include_flux_lines=False,
    server_host="localhost",
    setup_name=f"my_{number_of_qubits}_tuneable_qubit_setup",
)

q0, q1 = qubits[:2]
```

--------------------------------

### Generate Device Setup

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/02_logical_signals/tutorials/01_calibration.ipynb

Generates a device setup for a specified number of qubits, configuring instruments like PQSC, HDAWG, SHFQA, and SHFSG. This setup is a prerequisite for creating calibrations.

```python
# specify the number of qubits you want to use
number_of_qubits = 1

# generate the device setup and the qubit objects using a helper function
device_setup, qubits = generate_device_setup_qubits(
    number_qubits=number_of_qubits,
    pqsc=[{"serial": "DEV10001"}],
    hdawg=[
        {
            "serial": "DEV8001",
            "number_of_channels": 8,
            "options": None,
        }
    ],
    shfqa=[
        {
            "serial": "DEV12001",
            "readout_multiplex": 6,
            "options": None,
        }
    ],
    shfsg=[
        {
            "serial": "DEV12002",
            "number_of_channels": 8,
            "options": None,
        }
    ],
    include_flux_lines=True,
    server_host="localhost",
    setup_name=f"my_{number_of_qubits}_tunable_qubit_setup",
)
```

--------------------------------

### Initialize LabOne Q Session with Emulation

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/10_advanced_topics/tutorials/00_output_simulator.ipynb

Initializes a LabOne Q session with the generated device setup. Set `do_emulation=True` to use the output simulator without hardware.

```python
use_emulation = True

# create a session
session = Session(device_setup)
# connect to session
session.connect(do_emulation=use_emulation)
```

--------------------------------

### Device Setup with Single HDAWG and Single UHFQA

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/00_device_setup/tutorials/00_device_setup.ipynb

Configures a device setup for a single HDAWG and a single UHFQA. This setup is suitable for experiments that require both signal generation and measurement capabilities.

```python
descriptor = """\
instruments:
  HDAWG:
  - address: dev8000
    uid: hdawg
    options: HDAWG8/CNT/MF/ME/PC/SKW/IQ
  UHFQA:
  - address: dev2000
    uid: uhfqa
    options: UHFQA/AWG/DIG/RUB
connections:
  hdawg:
    - iq_signal: q0/drive
      ports: [SIGOUTS/0, SIGOUTS/1]
    - to: uhfqa
      port: DIOS/0
  uhfqa:
    - iq_signal: q0/measure
      ports: [SIGOUTS/0, SIGOUTS/1]
    - acquire_signal: q0/acquire
"""

device_setup_small = DeviceSetup.from_descriptor(
    descriptor,
    server_host="111.22.33.44",
    server_port="8004",
)
```

--------------------------------

### Configure Device Setup and Session

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/03_sections_pulses/tutorials/04_subsampling.ipynb

Sets up a LabOne Q device configuration, including connecting to a data server, defining an HDAWG instrument, setting up signal connections, and applying calibration. Finally, it establishes a session with the LabOne data server, enabling emulation.

```python
# Create the `DeviceSetup` and add the information about the data server it should connect to.
device_setup = DeviceSetup("ZI_HDAWG")
device_setup.add_dataserver(
    host="localhost",
    port="8004",
)

# Create a `HDAWG` instrument, which was imported from `laboneq.simple`, and add it to the `DeviceSetup`.
# When creating the instrument instance, you need to specify the device ID under `address`; for example, `dev8123`.

hdawg = HDAWG(
    uid="hdawg",
    interface="1GbE",
    address="dev8123",
    device_options="HDAWG8/MF/ME/CNT/PC",
    reference_clock_source="internal",
)
device_setup.add_instruments(hdawg)

# Create a flux lines for a qubit (signal type is "rf")
device_setup.add_connections(
    "hdawg",
    create_connection(to_signal="q0/flux", ports="SIGOUTS/0", type="rf"),
)

# Configure the `Calibration` of the signal lines of the `DeviceSetup`.
config = Calibration()
config["q0/flux"] = SignalCalibration(voltage_offset=0.0, range=5.0)

# Apply the configuration to the DeviceSetup
device_setup.set_calibration(config)

# Connect to the LabOne data server via the LabOne Q Session
session = Session(device_setup)
session.connect(do_emulation=True)  # do_emulation=True when at a physical setup
```

--------------------------------

### Create a Resonator Spectroscopy Experiment

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/reference/experiments/resonator_spectroscopy.html

Demonstrates how to configure options, define the QPU, and initialize a resonator spectroscopy experiment.

```python
options = {
    "count": 10,
    "spectroscopy_reset_delay": 3e-6
}
options = TuneupExperimentOptions(**options)
setup = DeviceSetup("my_device")
qpu = QPU(
    quantum_elements=[TunableTransmonQubit("q0"), TunableTransmonQubit("q1")],
    quantum_operations=TunableTransmonOperations(),
)
create_experiment(
    qpu=qpu,
    qubit="q0",
    frequencies=np.linspace(7.1e9, 7.6e9, 501),
    options=options,
)
```

--------------------------------

### OpenQASM Exception Example

Source: https://docs.zhinst.com/labone_q_user_manual/core/reference/openqasm3.html

An example of an OpenQASM exception highlighting an error in the source code.

```text
Unknown identifier 'frame0'
|          play(frame0, 10ns);
           ^
```

--------------------------------

### Connect to LabOne Q Session

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/tutorials/sources/getting_started.ipynb

Initializes a session with the setup. Set do_emulation to False when using real hardware.

```python
from laboneq.simple import Session

session = Session(setup)
session.connect(do_emulation=True)
```

--------------------------------

### Connect to Session

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/how-to-guides/sources/04_qasm/02_RandomizedBenchmarking_from_Qiskit.ipynb

Initialize a session with the device setup.

```python
session = Session(setup)
```

--------------------------------

### Generate SHFQC Device Setup

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/10_advanced_topics/tutorials/09_signal_muting.ipynb

Creates a device setup for SHFQC instruments, specifying the number of qubits and instrument configurations.

```python
# specify the number of qubits you want to use
number_of_qubits = 6

# generate the device setup and the qubit objects using a helper function
device_setup, qubits = generate_device_setup_qubits(
    number_qubits=number_of_qubits,
    pqsc=[{"serial": "DEV10001"}],
    hdawg=[{"serial": "DEV8001", "zsync": 0, "number_of_channels": 8, "options": None}],
    shfqc=[
        {
            "serial": "DEV12001",
            "zsync": 1,
            "number_of_channels": 6,
            "readout_multiplex": 6,
            "options": None,
        }
    ],
    include_flux_lines=True,
    server_host="localhost",
    setup_name=f"my_{number_of_qubits}_tuneable_qubit_setup",
)
```

--------------------------------

### Initialize and Inspect Workflow Options

Source: https://docs.zhinst.com/labone_q_user_manual/applications_library/how-to-guides/sources/01_superconducting_qubits/01_workflows/01_resonator_spectroscopy.ipynb

Create the options class for the resonator spectroscopy experiment and display the current configuration fields.

```python
options = resonator_spectroscopy.experiment_workflow.options()
workflow.show_fields(options)
```

--------------------------------

### Specify Number of Qubits

Source: https://docs.zhinst.com/labone_q_user_manual/core/functionality_and_concepts/04_quantum_processing_unit/tutorials/00_quantum_operations.ipynb

Sets the desired number of qubits for the quantum setup. This variable is used in the device setup generation.

```python
# specify the number of qubits you want to use
number_of_qubits = 3
```
Tokens:
Raw