LabOne Q

https://github.com/zhinst/laboneq
Admin
LabOne Q is Zurich Instruments' Python-based software framework for quantum computing control,...
Tokens:125,924
Snippets:1,286
Trust Score:9
License:Apache-2.0
Update:5 months ago
Show doc for...
Tokens:
Raw
### Import Example Helpers

Source: https://github.com/zhinst/laboneq/blob/main/examples/05_experiment/07_context_based_dsl.ipynb

Imports helper functions for generating device setups and plotting simulation results, useful for demonstrations and testing.

```python
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

```

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

### Start LabOne Q Session

Source: https://github.com/zhinst/laboneq/blob/main/examples/05_experiment/09_output_router.ipynb

Initializes and connects to the LabOne Q session with the defined device setup, enabling emulation if specified.

```python
# start the session
my_session = Session(device_setup=device_setup)
my_session.connect(do_emulation=emulate)
```

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

### Install LabOne Q Benchmarks

Source: https://github.com/zhinst/laboneq/blob/main/laboneq-benchmark/README.md

Install the benchmarking package directly from source into an existing LabOne Q environment. Ensure LabOne Q is already installed.

```python
uv pip install -e .
```

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

### Get Default Device Setup and Calibrate

Source: https://github.com/zhinst/laboneq/blob/main/examples/01a_async_api/00_async_api_reference.ipynb

Retrieves the default device setup from the controller and applies calibration settings using the `calibrate_devices` function.

```python
device_setup = await controller.get_default_devicesetup()
calibrate_devices(device_setup)

```

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

### Import Libraries and Helpers

Source: https://github.com/zhinst/laboneq/blob/main/examples/03_sections_pulses/01_pulse_library.ipynb

Imports necessary libraries for LabOne Q, plotting, and device setup generation. Ensure these are installed and accessible.

```python
# LabOne Q:
import matplotlib.pyplot as plt
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 plot_simulation
from laboneq.simple import *

```

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

### Generate Device Setup

Source: https://github.com/zhinst/laboneq/blob/main/examples/04_quantum_processing_unit/01_quantum_elements.ipynb

Generates a device setup for a specified number of qubits and SHFQCs. Ensure server host and setup name are correctly configured.

```python
number_of_qubits = 2
device_setup = generate_device_setup(
    number_qubits=number_of_qubits,
    shfqc=[
        {
            "serial": "DEV12001",
            "zsync": 1,
            "number_of_channels": 6,
            "readout_multiplex": 6,
            "options": None,
        }
    ],
    include_flux_lines=False,
    server_host="localhost",
    setup_name=f"my_{number_of_qubits}_fixed_qubit_setup",
)
```

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

### Create and calibrate device setup

Source: https://github.com/zhinst/laboneq/blob/main/examples/05_experiment/02_neartime_callbacks.ipynb

Initializes the device setup from a descriptor and applies calibration settings. Emulation mode can be enabled to avoid actual device connection.

```python
# Emulation mode does not create connection to the devices
do_emulation = True


# Function returning a calibrated device setup
def create_device_setup():
    device_setup = DeviceSetup.from_descriptor(
        descriptor,
        server_host="111.22.33.44",  # ip address of the LabOne dataserver used to communicate with the instruments
        server_port="8004",  # port number of the dataserver - default is 8004
        setup_name="ZI_QCCS",  # setup name
    )
    calibrate_devices(device_setup)
    return device_setup


# create device setup
device_setup = create_device_setup()

```

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

### Generate Device Setup and Qubit Objects

Source: https://github.com/zhinst/laboneq/blob/main/examples/05_experiment/04_waveform_replacement.ipynb

Configures the device setup and creates qubit objects based on specified parameters. This is a prerequisite for setting up experiments.

```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,
    shfqc=[
        {
            "serial": "DEV12001",
            "zsync": 1,
            "number_of_channels": 6,
            "readout_multiplex": 6,
            "options": None,
        }
    ],
    include_flux_lines=False,
    server_host="localhost",
    setup_name=f"my_{number_of_qubits}_fixed_qubit_setup",
)

q0, q1 = qubits[:2]

```

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

### Create Device Setup

Source: https://github.com/zhinst/laboneq/blob/main/examples/05_experiment/13_experiment_chunking.ipynb

Defines a device setup with a single SHFSG instrument and its connection.

```python
from laboneq.simple import SHFSG, DeviceSetup, create_connection

setup = DeviceSetup("my_setup")
setup.add_dataserver(host="localhost", port="8004")
setup.add_instruments(SHFSG(uid="shfsg", address="dev12021"))
setup.add_connections(
    "shfsg", create_connection(to_signal="q0/drive_line", ports="SGCHANNELS/0/OUTPUT")
)
```

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

### Generate device setup for qubits

Source: https://github.com/zhinst/laboneq/blob/main/examples/05_experiment/01_output_simulator.ipynb

Configures the experimental setup, including PQSC, HDAWG, and SHFQc devices, and defines qubit objects. This setup is crucial for connecting to the LabOne session.

```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", "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}_fixed_qubit_setup",
)

q0, q1 = qubits[:2]

```

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

### Construct a simple device setup

Source: https://github.com/zhinst/laboneq/blob/main/examples/05_experiment/05_advanced_sweeping_examples.ipynb

Defines a basic device setup including dataserver connection, instruments, signal connections, and minimal calibration for a QCCS device.

```python
# construct a simple device setup
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="q1/drive_line", ports="SGCHANNELS/1/OUTPUT"),
    create_connection(to_signal="q2/drive_line", ports="SGCHANNELS/2/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 the 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/q1/drive_line"] = SignalCalibration(
    local_oscillator=drive_lo
)
cal["/logical_signal_groups/q2/drive_line"] = SignalCalibration(
    local_oscillator=drive_lo
)
cal["/logical_signal_groups/q0/measure_line"] = SignalCalibration(
    local_oscillator=measure_lo
)
cal["/logical_signal_groups/q0/acquire_line"] = SignalCalibration(
    local_oscillator=measure_lo
)
device_setup.set_calibration(cal)
```

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

### Import necessary libraries

Source: https://github.com/zhinst/laboneq/blob/main/examples/05_experiment/01_output_simulator.ipynb

Imports required libraries for LabOne Q, plotting, and device setup generation. Ensure these are installed and accessible.

```python
# LabOne Q:
import matplotlib.pyplot as plt
import numpy as np

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
from laboneq.simple import *

```

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

### Load Qubits from Device Setup

Source: https://github.com/zhinst/laboneq/blob/main/examples/04_quantum_processing_unit/01_quantum_elements.ipynb

Loads all qubit objects from a generated device setup. The `Transmon` class must match the qubit type in the setup.

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

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

### Initialize Device Setup from Descriptor

Source: https://github.com/zhinst/laboneq/blob/main/examples/00_device_setup/00_device_setup.ipynb

Construct a `DeviceSetup` instance using a device descriptor string, specifying server connection details.

```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",
)
```

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

### Generate Device Setup and Qubits

Source: https://github.com/zhinst/laboneq/blob/main/examples/07_openqasm/00_program_to_experiment.ipynb

Generates a device setup and qubit objects using a helper function for a specified number of qubits and instrument configurations.

```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",
)
```

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

### Initialize Device Setup

Source: https://github.com/zhinst/laboneq/blob/main/examples/01_session/00_session_reference.ipynb

Creates a DeviceSetup object from a descriptor and applies calibration. This is a prerequisite for configuring instruments.

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

```

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

### List Calibratables in Device Setup

Source: https://github.com/zhinst/laboneq/blob/main/examples/02_logical_signals/01_calibration.ipynb

Verify that logical signals have been calibrated by listing all calibratable logical signals in the device setup.

```python
list_ls_calibratables(device_setup)
```

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

### Import necessary modules for device setup

Source: https://github.com/zhinst/laboneq/blob/main/examples/04_quantum_processing_unit/00_quantum_operations.ipynb

Imports the required modules for generating device setups and qubits. Needed for Python 3.9+ type hinting.

```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,
)
```

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

### Generate Device Setup with Qubits

Source: https://github.com/zhinst/laboneq/blob/main/examples/05_experiment/07_context_based_dsl.ipynb

Creates a demonstration device setup with a specified number of qubits, configuring PQSC, HDAWG, and SHFQC modules, and optionally including flux lines.

```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", "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}_fixed_qubit_setup",
)

q0, q1 = qubits[:2]

```

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

### Programmatic Device Setup Generation

Source: https://github.com/zhinst/laboneq/blob/main/examples/00_device_setup/00_device_setup.ipynb

Construct a large-scale device setup programmatically by adding dataservers, instruments, and connections. This is useful for controlling a large number of 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"
            )
            for _ in range(8)
        ],
    )
```

```python
for i in range(8):
    scaled_setup.add_instruments(HDAWG(uid=f"hdawg_{i}", address=f"dev876{i}"))
    scaled_setup.add_connections(
        f"hdawg_{i}",
        *[
            create_connection(to_signal=f"q{i * 8 + _}/flux", ports=f"SIGOUTS/{_}")
            for _ in range(8)
        ],
    )
```

```python
for i in range(2):
    scaled_setup.add_instruments(SHFQA(uid=f"shfqa_{i}", address=f"dev1234{i}"))
    for j in range(4):
        scaled_setup.add_connections(
            f"shfqa_{i}",
            *[
                create_connection(
                    to_signal=f"q{i * 32 + j * 8 + _}/measure",
                    ports=f"QACHANNELS/{j}/OUTPUT",
                )
                for _ in range(8)
            ],
            *[
                create_connection(
                    to_signal=f"q{i * 32 + j * 8 + _}/acquire",
                    ports=f"QACHANNELS/{j}/INPUT",
                )
                for _ in range(8)
            ],
        )
```

```python
for lsg in scaled_setup.logical_signal_groups:
    print(lsg, *scaled_setup.logical_signal_groups[lsg].logical_signals.keys())
```

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

### Save Device Setup

Source: https://github.com/zhinst/laboneq/blob/main/examples/00_device_setup/00_device_setup.ipynb

Serialize a `DeviceSetup` instance to a human-readable JSON format and save it to a file.

```python
from laboneq.simple import load, save
```

```python
save(device_setup_from_descriptor, "saved_device_setup.json")
```

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

### Create Async Local Controller with Device Setup

Source: https://github.com/zhinst/laboneq/blob/main/examples/01a_async_api/00_async_api_reference.ipynb

Initializes an asynchronous local controller with a defined device setup. This is useful for emulating or directly controlling devices without a running data server.

```python
from laboneq.controller.api.async_local_controller import AsyncLocalController

descriptor = """
instruments:
  HDAWG:
  - address: DEV1001
    uid: device_hdawg
  UHFQA:
  - address: DEV2001
    uid: device_uhfqa
  PQSC:
  - address: DEV3001
    uid: device_pqsc
connections:
  device_hdawg:
    - iq_signal: q0/drive_line
      ports: [SIGOUTS/0, SIGOUTS/1]
    - iq_signal: q1/drive_line
      ports: [SIGOUTS/2, SIGOUTS/3]
    - rf_signal: q0/flux_line
      ports: [SIGOUTS/4]
    - rf_signal: q1/flux_line
      ports: [SIGOUTS/5]
    - to: device_uhfqa
      port: DIOS/0
  device_uhfqa:
    - iq_signal: q0/measure_line
      ports: [SIGOUTS/0, SIGOUTS/1]
    - acquire_signal: q0/acquire_line
    - iq_signal: q1/measure_line
      ports: [SIGOUTS/0, SIGOUTS/1]
    - acquire_signal: q1/acquire_line
"""
controller_device_setup = DeviceSetup.from_descriptor(
    descriptor,
    server_host="111.22.33.44",
    server_port="8004",
    setup_name="ZI_QCCS",
)
controller = await AsyncLocalController.create(
    device_setup=controller_device_setup,
    do_emulation=True,
)

```

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

### Create and Set Signal Calibration

Source: https://github.com/zhinst/laboneq/blob/main/examples/02_logical_signals/01_calibration.ipynb

Create a new Calibration instance for a specific logical signal and apply it to the device setup. This example calibrates the readout signal of logical signal group 'q0'.

```python
calibratable = device_setup.logical_signal_groups["q0"].logical_signals["measure"].path
calibration_item = SignalCalibration(
    oscillator=Oscillator(
        uid="q0_readout_acquire_osc",
        frequency=-250e6,
        modulation_type=ModulationType.AUTO,
    ),
    local_oscillator=Oscillator(
        uid="q0_readout_local_osc",
        frequency=6e9,
        modulation_type=ModulationType.AUTO,
    ),
    port_delay=4e-08,
    range=10,
)

device_setup.set_calibration(Calibration({calibratable: calibration_item}))
```

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

### Load Device Setup

Source: https://github.com/zhinst/laboneq/blob/main/examples/00_device_setup/00_device_setup.ipynb

Reconstruct a `DeviceSetup` object from a JSON file using the `load` functionality.

```python
loaded_device_setup = load("saved_device_setup.json")
```

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

### Define Device Setup and Connections

Source: https://github.com/zhinst/laboneq/blob/main/examples/05_experiment/09_output_router.ipynb

Sets up the device configuration, including dataserver, instruments (SHFSG, HDAWG, PQSC), and their interconnections using `create_connection`.

```python
emulate = True

# Add your device setup information here
device_setup = DeviceSetup("ZI_QCCS")
device_setup.add_dataserver(host="10.22.33.44", port="8004")
device_setup.add_instruments(
    SHFSG(uid="device_shfsg", address="dev12001", device_options="SHFSG8/RTR"),
    HDAWG(uid="device_hdawg", address="dev8001"),
    PQSC(uid="device_pqsc", address="dev10001"),
)
device_setup.add_connections(
    "device_shfsg",
    create_connection(to_signal="q0/drive_line", ports="SGCHANNELS/0/OUTPUT"),
    create_connection(to_signal="q1/drive_line", ports="SGCHANNELS/1/OUTPUT"),
    create_connection(to_signal="q2/drive_line", ports="SGCHANNELS/2/OUTPUT"),
)
device_setup.add_connections(
    "device_hdawg",
    create_connection(to_signal="q0/flux_line", ports="SIGOUTS/0"),
)
```

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

### Connect to Device and Emulate

Source: https://github.com/zhinst/laboneq/blob/main/examples/01_session/00_session_reference.ipynb

Establishes a connection to the device setup and enables emulation mode. Use this to test experiments without hardware.

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

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

### Generate Device Setup for Qubits

Source: https://github.com/zhinst/laboneq/blob/main/examples/05_experiment/10_signal_muting.ipynb

Creates a device setup instance for SHFQC instruments, specifying the number of qubits and instrument configurations. This helper function simplifies the process of defining the hardware topology.

```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",
)

```

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

### Define Device Setup for Qubits

Source: https://github.com/zhinst/laboneq/blob/main/examples/03_sections_pulses/01_pulse_library.ipynb

Generates a device setup for a specified number of qubits using a helper function. This includes configuring signal lines and options for the SHFQCs.

```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,
    shfqc=[
        {
            "serial": "DEV12001",
            "number_of_channels": 6,
            "readout_multiplex": 6,
            "options": None,
        }
    ],
    include_flux_lines=False,
    server_host="localhost",
    setup_name=f"my_{number_of_qubits}_fixed_qubit_setup",
)

```

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

### Generate Device Setup

Source: https://github.com/zhinst/laboneq/blob/main/examples/02_logical_signals/01_calibration.ipynb

Generates a device setup with specified qubits and instrument configurations. This function requires parameters like the number of qubits and instrument details (serial numbers, channels, etc.).

```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",
)
```

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

### Install Latest Stable LabOne Q

Source: https://github.com/zhinst/laboneq/blob/main/README.md

Installs the latest quarterly stable release of LabOne Q from PyPI. Use this for general development and production.

```sh
$ pip install --upgrade laboneq
```

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

### Add Multiple Instruments to Device Setup

Source: https://github.com/zhinst/laboneq/blob/main/examples/00_device_setup/00_device_setup.ipynb

Add SHFSG, SHFQA, and PQSC instruments to the device setup, specifying their UIDs, addresses, device options, and reference clock source.

```python
device_setup.add_instruments(
    SHFQA(uid="shfqa", address="dev12000", device_options="SHFQA4"),
    SHFSG(uid="shfsg", address="dev12001", device_options="SHFSG8/RTR"),
    PQSC(uid="pqsc", address="dev10001", reference_clock_source="internal"),
)
```

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

### Import LabOne Q Simple Module

Source: https://github.com/zhinst/laboneq/blob/main/examples/instrument_getting_started/00_getting_started_hdawg.ipynb

Imports necessary components from the laboneq.simple module for device setup and plotting.

```python
import numpy as np

from laboneq.contrib.example_helpers.plotting.plot_helpers import plot_simulation
from laboneq.simple import *

```

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

### Create and Add a Connection

Source: https://github.com/zhinst/laboneq/blob/main/examples/00_device_setup/00_device_setup.ipynb

Use `create_connection` to define a signal connection and `add_connection` to add it to the device setup.

```python
drive_line = create_connection(
    to_signal="q0/drive", ports="SGCHANNELS/0/OUTPUT", type="iq"
)
```

```python
device_setup.add_connections("shfsg", drive_line)
```

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

### Generate Device Setup and Qubits

Source: https://github.com/zhinst/laboneq/blob/main/examples/04_quantum_processing_unit/00_quantum_operations.ipynb

Generates the device setup configuration, including PQSC, HDAWG, and SHFQC components, along with Transmon qubits. This function configures multiplexing for drive and readout lines.

```python
# generate the device setup using a helper function
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": 3,
            "options": None,
        }
    ],
    include_flux_lines=True,
    multiplex_drive_lines=True,  # adds drive_ef
    server_host="localhost",
    setup_name="device_setup",
)
```

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

### PRNG Reseeding Example

Source: https://github.com/zhinst/laboneq/blob/main/examples/05_experiment/08_PRNG_usage.ipynb

This example demonstrates reseeding the PRNG with different values and ranges for two distinct loops. It maps signals and prepares the experiment for compilation and execution.

```python
pulses = [
    PlayPulse(signal="drive", pulse=const_pulse, amplitude=a)
    for a in np.linspace(0.1, 1, 10)
]


@experiment(signals=["drive", "measure", "acquire"])
def prng_reseeding_example():
    with acquire_loop_rt(4):
        # seed the PRNG with the value 0xCAFE, with a max. value of 9
        with prng_setup(seed=0xCAFE, range=10) as prng:
            with prng_loop(prng=prng, count=5) as prng_sample:
                play_indexed(pulses, prng_sample)
                # Readout _inside_ the first PRNG loop
                with section():
                    reserve("drive")
                    play("measure", const_pulse)
                    acquire("acquire", kernel=const_pulse, handle="h1")
                    delay("measure", 100e-9)

        # reseed the PRNG with a different value, e.g. 0xBEEF, and an upper value of 4
        with prng_setup(seed=0xBEEF, range=5) as prng2:
            with prng_loop(prng=prng2, count=10) as prng_sample2:
                play_indexed(pulses[::2], prng_sample2)
                # Readout _inside_ the second PRNG loop
                with section():
                    reserve("drive")
                    play("measure", const_pulse)
                    acquire("acquire", kernel=const_pulse, handle="h2")
                    delay("measure", 100e-9)


exp = prng_reseeding_example()
q0_ls = device_setup.logical_signal_groups["q0"].logical_signals
exp.map_signal("drive", q0_ls["drive_line"])
exp.map_signal("measure", q0_ls["measure_line"])
exp.map_signal("acquire", q0_ls["acquire_line"])
```

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

### Start and Stop Web Viewer

Source: https://github.com/zhinst/laboneq/blob/main/src/python/laboneq/automation/web_viewer/README.md

Import and use the `start_web_viewer` function to launch the viewer. Ensure to call `viewer.stop()` when finished.

```python
from laboneq.automation.web_viewer import start_web_viewer

viewer = start_web_viewer(automation, port=5000)
# ...
viewer.stop()
```

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

### Device Setup with SHFQA/LRT Option

Source: https://github.com/zhinst/laboneq/blob/main/examples/05_experiment/11_long_readout_time.ipynb

Configures the device setup, including qubits and instruments like SHFQA with the LRT option enabled. Ensure the serial numbers and instrument configurations match your hardware.

```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]
```

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

### Install LabOne Q Preview Release

Source: https://github.com/zhinst/laboneq/blob/main/README.md

Installs a preview release of LabOne Q, typically updated bi-weekly. These releases contain new features and bugfixes but do not receive backports.

```sh
$ pip install --upgrade --pre laboneq
```

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

### LabOne Q Session Setup for HDAWG

Source: https://github.com/zhinst/laboneq/blob/main/examples/03_sections_pulses/04_subsampling.ipynb

Configures and connects to a LabOne Q session with an HDAWG instrument. This setup is required before running experiments that utilize the instrument's capabilities.

```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 Uncalibrated DeviceSetup

Source: https://github.com/zhinst/laboneq/blob/main/examples/02_logical_signals/00_calibration_reference.ipynb

Creates a DeviceSetup object from a descriptor, specifying server details and a setup name. The initial DeviceSetup is uncalibrated.

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

```

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

### Import LabOne Q DSL Classes

Source: https://github.com/zhinst/laboneq/blob/main/examples/05_experiment/10_signal_muting.ipynb

Imports necessary classes from the LabOne Q DSL for creating device setups and experiments.

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

```

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

### Connect to LabOne Q Session

Source: https://github.com/zhinst/laboneq/blob/main/examples/instrument_getting_started/01_getting_started_shfqa_plus.ipynb

Establish a connection to the LabOne data server. Set `do_emulation=True` for emulation mode or `False` to connect to a physical setup.

```python
session = Session(device_setup)
session.connect(do_emulation=True)  # do_emulation=False when at a physical setup
```

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

### Get Calibration Object

Source: https://github.com/zhinst/laboneq/blob/main/examples/00_device_setup/00_device_setup.ipynb

Retrieve a calibration object containing current settings for instrument nodes from the device setup.

```python
device_setup.get_calibration()
```

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

### Import LabOne Q Components

Source: https://github.com/zhinst/laboneq/blob/main/examples/02_logical_signals/01_calibration.ipynb

Imports necessary components from LabOne Q for example helpers and the simple API.

```python
from laboneq.contrib.example_helpers.generate_device_setup import (
    generate_device_setup_qubits,
)
from laboneq.contrib.example_helpers.reference_experiments import (
    make_reference_experiment,
)
from laboneq.simple import *
```

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

### Add Data Server Information

Source: https://github.com/zhinst/laboneq/blob/main/examples/00_device_setup/00_device_setup.ipynb

Configure the LabOne data server connection details for the device setup.

```python
device_setup.add_dataserver(
    host="111.22.33.44",
    port="8004",
)
```

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

### Initialize DeviceSetup and Add Data Server

Source: https://github.com/zhinst/laboneq/blob/main/examples/instrument_getting_started/00_getting_started_hdawg.ipynb

Creates a DeviceSetup instance and configures the data server connection details. The connection is not established until Session.connect is called.

```python
device_setup = DeviceSetup("ZI_HDAWG")
device_setup.add_dataserver(
    host="localhost",
    port="8004",
)

```

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

### Create DeviceSetup and Add Dataserver

Source: https://github.com/zhinst/laboneq/blob/main/examples/instrument_getting_started/06_getting_started_shfqc_hdawg_pqsc.ipynb

Initializes a `DeviceSetup` for a system with specific instruments and configures the connection to the LabOne data server. The connection is not established until `Session.connect()` is called.

```python
device_setup = DeviceSetup("ZI_SHFQC+_HDAWG_PQSC")
device_setup.add_dataserver(
    host="localhost",
    port="8004",
)

```

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

### Import LabOne Q Packages

Source: https://github.com/zhinst/laboneq/blob/main/examples/05_experiment/06_declarative_dsl.ipynb

Import necessary libraries for LabOne Q experiments, including numpy and helper functions for device setup.

```python
# Import required packages
import numpy as np

from laboneq.contrib.example_helpers.generate_device_setup import \
    generate_device_setup_qubits
from laboneq.simple import *

```

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

### Instantiate DeviceSetup

Source: https://github.com/zhinst/laboneq/blob/main/examples/00_device_setup/00_device_setup.ipynb

Create a DeviceSetup instance with a specified user-defined ID for the QCCS.

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

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

### Import LabOne Q Packages

Source: https://github.com/zhinst/laboneq/blob/main/examples/03_sections_pulses/00_section_tutorial.ipynb

Imports necessary modules from the laboneq library for experiment definition and device setup.

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

```

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

### Initialize DeviceSetup and Add Data Server

Source: https://github.com/zhinst/laboneq/blob/main/examples/instrument_getting_started/07_getting_started_shfsg_shfqa_pqsc.ipynb

Creates a DeviceSetup instance and adds a data server connection. The connection is not established until Session.connect() is called.

```python
device_setup = DeviceSetup("ZI_SHFSG+_SHFQA+_PQSC")
device_setup.add_dataserver(
    host="localhost",
    port="8004",
)

```

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

### Retrieve Physical Channels

Source: https://github.com/zhinst/laboneq/blob/main/examples/05_experiment/01_output_simulator.ipynb

Gets references to physical channels corresponding to logical signals. This is useful for targeting specific signal paths within the device setup.

```python
# Get physical channel references via the logical signals
drive_iq_port = device_setup.logical_signal_by_uid(q0.uid + "/drive").physical_channel
flux_rf_port = device_setup.logical_signal_by_uid(q0.uid + "/flux").physical_channel
measure_iq_port = device_setup.logical_signal_by_uid(
    q0.uid + "/measure"
).physical_channel
acquire_port = device_setup.logical_signal_by_uid(q0.uid + "/acquire").physical_channel
```

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

### Initialize DeviceSetup and Add Data Server

Source: https://github.com/zhinst/laboneq/blob/main/examples/instrument_getting_started/05_getting_started_shfqa_hdawg_pqsc.ipynb

Creates a DeviceSetup instance and configures the connection to the LabOne data server. The connection is established upon calling Session.connect().

```python
device_setup = DeviceSetup("ZI_HDAWG_SHFQA+_PQSC")
device_setup.add_dataserver(
    host="localhost",
    port="8004",
)

```

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

### Get Baseline Calibration

Source: https://github.com/zhinst/laboneq/blob/main/examples/02_logical_signals/01_calibration.ipynb

Retrieves the baseline calibration object for the device setup. This calibration object represents the current hardware configuration and is essential for applying settings.

```python
calibration = device_setup.get_calibration()
```

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

### Create DeviceSetup and Add Data Server

Source: https://github.com/zhinst/laboneq/blob/main/examples/instrument_getting_started/04_getting_started_shfppc.ipynb

Initialize a DeviceSetup for a ZI_SHFPPC_SHFQA system and configure the data server connection. The connection is not established until Session.connect is called.

```python
device_setup = DeviceSetup("ZI_SHFPPC_SHFQA")
device_setup.add_dataserver(
    host="localhost",
    port="8004",
)

```

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

### Get Specific Calibration Item

Source: https://github.com/zhinst/laboneq/blob/main/examples/02_logical_signals/01_calibration.ipynb

Retrieves the baseline calibration for a specific calibration item, such as a logical signal group. Note that if the device setup is uncalibrated, this may return None.

```python
calibration_item = "logical_signal_groups/q0/acquire"
print(device_setup.get_calibration(calibration_item))
```

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

### Create DeviceSetup and add Data Server

Source: https://github.com/zhinst/laboneq/blob/main/examples/instrument_getting_started/01_getting_started_shfqa_plus.ipynb

Initialize a DeviceSetup for a ZI_SHFQA+ instrument and configure the data server connection. The connection is established later with Session.connect().

```python
device_setup = DeviceSetup("ZI_SHFQA+")
device_setup.add_dataserver(
    host="localhost",
    port="8004",
)

```

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

### Import Required Packages for LabOne Q

Source: https://github.com/zhinst/laboneq/blob/main/examples/04_quantum_processing_unit/01_quantum_elements.ipynb

Imports necessary modules from the LabOne Q library, including serializers and helpers for generating device setups. This is a common starting point for LabOne Q experiments.

```python
from __future__ import annotations

import laboneq.serializers

# Import required packages
from laboneq.contrib.example_helpers.generate_device_setup import \
    generate_device_setup
```

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

### Setting up Device and Session

Source: https://github.com/zhinst/laboneq/blob/main/examples/05_experiment/08_PRNG_usage.ipynb

Configures the device setup, including adding data servers and instruments, establishing connections, and setting up a minimal calibration. This is a prerequisite for connecting to the LabOne session.

```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(
    local_oscillator=measure_lo
)
cal["/logical_signal_groups/q0/acquire_line"] = SignalCalibration(
    local_oscillator=measure_lo
)
device_setup.set_calibration(cal)
```

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

### Start Web Viewer for Automation Graph

Source: https://github.com/zhinst/laboneq/blob/main/examples/06a_automation/00_automation.ipynb

Launches a web viewer to display the automation graph live. Access the graph by clicking the provided hyperlink.

```python
start_web_viewer(auto)
```

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

### Initialize DeviceSetup and Add Data Server

Source: https://github.com/zhinst/laboneq/blob/main/examples/instrument_getting_started/02_getting_started_shfsg_plus.ipynb

Creates a DeviceSetup instance for a ZI_SHFSG+ instrument and configures the data server connection. The connection is established later upon calling Session.connect().

```python
device_setup = DeviceSetup("ZI_SHFSG+")
device_setup.add_dataserver(
    host="111.22.33.44",
    port="8004",
)
```

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

### Initialize and connect to LabOne session

Source: https://github.com/zhinst/laboneq/blob/main/examples/05_experiment/01_output_simulator.ipynb

Creates a LabOne Q session using the generated device setup and connects to it, enabling emulation if `use_emulation` is set to True.

```python
use_emulation = True

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

```

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

### Create and Connect Session

Source: https://github.com/zhinst/laboneq/blob/main/examples/05_experiment/02_neartime_callbacks.ipynb

Initializes a LabOne Q session with the provided device setup and connects to the device, optionally enabling emulation mode. This is the entry point for running experiments.

```python
# create a session
session = Session(device_setup)
```

```python
# connect to session
session.connect(do_emulation=do_emulation)
# run experiment
my_results = session.run(exp)
```

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

### Create and Connect to LabOne Q Session

Source: https://github.com/zhinst/laboneq/blob/main/examples/03_sections_pulses/01_pulse_library.ipynb

Initializes a LabOne Q session with the defined device setup. Set `use_emulation` to `False` to connect to real hardware.

```python
use_emulation = True  # set to False to run on real hardware

session = Session(device_setup=device_setup)
session.connect(do_emulation=use_emulation)

```

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

### Device Setup: Single HDAWG

Source: https://github.com/zhinst/laboneq/blob/main/examples/00_device_setup/00_device_setup.ipynb

Defines a device setup for a standalone HDAWG instrument. Use this for single-instrument configurations where the HDAWG uses its internal reference clock.

```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",
)
```

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

### Set Calibration to Device Setup

Source: https://github.com/zhinst/laboneq/blob/main/examples/02_logical_signals/01_calibration.ipynb

Use this to set calibration objects directly to the device setup. Calibration objects can be applied repeatedly to fill or update calibratables.

```python
device_setup.set_calibration(calibration)
```

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

### Import LabOne Q Simple API

Source: https://github.com/zhinst/laboneq/blob/main/examples/00_device_setup/00_device_setup.ipynb

Import the necessary DeviceSetup class from the LabOne Q simple API.

```python
from laboneq.simple import *
```

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

### Device Setup: Single HDAWG and Single UHFQA

Source: https://github.com/zhinst/laboneq/blob/main/examples/00_device_setup/00_device_setup.ipynb

Defines a device setup with one HDAWG and one UHFQA, including instrument details and connections. Use this for multi-instrument configurations.

```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",
)
```

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

### Add Data Server to DeviceSetup

Source: https://github.com/zhinst/laboneq/blob/main/examples/instrument_getting_started/03_getting_started_shfqc_plus.ipynb

Create a DeviceSetup and add a data server connection. The connection is not established until Session.connect() is called.

```python
device_setup = DeviceSetup("ZI_SHFQC+")
device_setup.add_dataserver(
    host="111.22.33.44",
    port="8004",
)

```

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

### PRNG Setup and Sampling Structure

Source: https://github.com/zhinst/laboneq/blob/main/examples/05_experiment/08_PRNG_usage.ipynb

This structure demonstrates the basic usage of the PRNG in LabOne Q. It involves seeding the PRNG, looping for sampling, and matching the sampled values to control pulse execution.

```python
with prng_setup(seed=..., range=...) as prng:  # 1.
    with prng_loop(prng=prng, count=...) as prng_sample:  # 2.
        ...
        with match(prng_sample=prng_sample):  # 3.
            with case(0):
                play(...)
            with case(1):
                play(...)
            ...
```

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

### Initialize Experiment and Signals

Source: https://github.com/zhinst/laboneq/blob/main/examples/05_experiment/06_declarative_dsl.ipynb

Initializes a LabOne Q experiment and adds signal connections for drive, measure, and acquire channels, linking them to the device setup's logical signals.

```python
exp_ramsey = Experiment(uid="Ramsey_Experiment")
exp_ramsey.add_signal(
    "drive",
    connect_to=device_setup.logical_signal_groups["q0"].logical_signals["drive"],
)
exp_ramsey.add_signal(
    "measure",
    connect_to=device_setup.logical_signal_groups["q0"].logical_signals["measure"],
)
exp_ramsey.add_signal(
    "acquire",
    connect_to=device_setup.logical_signal_groups["q0"].logical_signals["acquire"],
)

```

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

### Check QCCS Cable Connectivity

Source: https://github.com/zhinst/laboneq/blob/main/src/python/laboneq/contrib/setup_installation_helpers/README.md

Use this script to verify the connectivity of your QCCS setup to external scopes or internal acquisition units via a loopback cable. It plays individual pulse sequences on each output channel. Ensure device setup, including output ranges and port modes, is configured before running.

```python
from laboneq.contrib.setup_installation_helpers.cable_checker import check_cable_experiment, Device

devices = {
    "DEV10001": Device(type="PQSC"),
    "DEV8004": Device(type="HDAWG8", zsync_port=1),
    "DEV8015": Device(type="HDAWG4", zsync_port=2),
    "DEV12012": Device(type="SHFQC", zsync_port=3),
}
experiment, device_setup = check_cable_experiment(
    devices=devices,
    server_host="11.22.33.44",
    server_port=8004,
    play_parallel=False,
    play_initial_trigger=False,
)

session = Session(device_setup)
session.connect()
session.run(experiment)
```

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

### Connect to LabOne Session with Emulation

Source: https://github.com/zhinst/laboneq/blob/main/examples/05_experiment/10_signal_muting.ipynb

Initializes a LabOne Q session and connects to the device, with an option to use emulation mode. Emulation is useful for testing without physical hardware.

```python
use_emulation = True

session = Session(device_setup)
session.connect(do_emulation=use_emulation)

```

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

### Get Source Code of Run Experiment Task

Source: https://github.com/zhinst/laboneq/blob/main/examples/06_workflow/00_tasks.ipynb

Retrieve the source code of the `run_experiment` task.

```python
# source code
run_experiment.src
```

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

### Get Source Code of Compile Experiment Task

Source: https://github.com/zhinst/laboneq/blob/main/examples/06_workflow/00_tasks.ipynb

Retrieve the source code of the `compile_experiment` task.

```python
# source code
compile_experiment.src
```

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

### Get Experiment Signal UIDs

Source: https://github.com/zhinst/laboneq/blob/main/examples/05_experiment/00_experiment_definition_reference.ipynb

Retrieves a list of all signal UIDs currently defined in the experiment.

```python
exp.experiment_signals_uids()
```

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

### Inspect Logical Signal

Source: https://github.com/zhinst/laboneq/blob/main/examples/instrument_getting_started/02_getting_started_shfsg_plus.ipynb

Retrieves and displays the details of a specific logical signal, such as 'q0/drive', from the device setup.

```python
device_setup.logical_signal_by_uid("q0/drive")
```

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

### Access Instrument by UID

Source: https://github.com/zhinst/laboneq/blob/main/examples/00_device_setup/00_device_setup.ipynb

Retrieve an instrument object from the device setup using its unique identifier (UID).

```python
device_setup.instrument_by_uid("shfqa")
```

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

### Import LabOne Q Library

Source: https://github.com/zhinst/laboneq/blob/main/examples/05_experiment/00_experiment_definition_reference.ipynb

Import the necessary LabOne Q library for experiment building. This is the first step in any LabOne Q script.

```python
from laboneq.simple import *

```

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

### Connect to Instruments and Compile Experiment

Source: https://github.com/zhinst/laboneq/blob/main/examples/05_experiment/06_declarative_dsl.ipynb

Open a session to connect to instruments or emulate the connection, then compile the experiment. Ensure the session is established before compilation.

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

```python
compiled_exp = session.compile(exp_ramsey)
```

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

### Get Experiment Signals

Source: https://github.com/zhinst/laboneq/blob/main/examples/04_quantum_processing_unit/01_quantum_elements.ipynb

Retrieves the experiment signals associated with a quantum element and their mapped logical signals.

```python
q0.experiment_signals()
```

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

### Access Operation Implementation

Source: https://github.com/zhinst/laboneq/blob/main/examples/04_quantum_processing_unit/00_quantum_operations.ipynb

Get the underlying function that implements the quantum operation via the `.op` attribute.

```python
qops.rx.op
```
Tokens:
Raw