Devices live in a vacuum
Data does not

from qm.qua import program, declare, for_, for_each_, stream_processing
import xarray as xr
import numpy as np

# Import Pelagic methods
from pelagic.vessel.roots import SCQRoot
from pelagic.control.fetching.streams import StreamManager
from pelagic.analysis.units.parameter_converter import unit

u = unit(coerce_to_integer=True)

# Load the Pelagic intermediate representation of the device
machine = SCQRoot.load(r"example/state")
qubits = machine.qubits
# Generate the StreamManager and extract its AxisTracker
stm = StreamManager()
axt = stm.axis_tracker


n_averages = 500
amplitudes = np.linspace(0.1,0.3,13)

# time_us: their coordinates in us.
# time_ticks: controller durations
time_us = np.linspace(4 * u.ns, 5.124 * u.us, 161)
time_coords = xr.Coordinates({
    "time": xr.DataArray(time_us, dims="time", attrs={"units": "us"})
})
time_ticks = u.to_units(time_us, 'ns')

with program() as prog:
    n, t = declare(int), declare(int)
    a = declare(qua.fixed)
    for qubit in qubits:
        stm.add_iq_stream(
            name=qubit.name, unit="mV", return_types="I",
            mean_axis="averages",
        )

    with axt.add_axis(for_(n, 0, n < n_averages, n + 1), name="averages"):
        with axt.add_axis(for_each_(a, amplitudes), name="drive_amplitude", unit="V"):
	        # OPX1000 native unit is ns, but we want to save according to a useful scale
            with axt.add_axis(for_each_(t, time_ticks), name="time", coords=time_coords):
                for qubit in qubits:
                    # Experiment-specific reset, drive, and readout.
                    # This example supplies calibrated I/Q in volts.
                    I, Q = qubit.measure("readout")
                    stm[qubit.name].save(1000 * I, 1000 * Q)

    with stream_processing():
        stm.process()

# After submitting the program to your controller:
ds = stm.fetch_dataset(job)