iqm-pulse 12.6.1__py3-none-any.whl → 12.7.1__py3-none-any.whl

iqm/pulse/builder.py

@@ -15,8 +15,7 @@
 
 from __future__ import annotations
 
-from collections import defaultdict
-from collections.abc import Iterable
+from collections.abc import Iterable, Sequence
 import copy
 from dataclasses import dataclass, field, replace
 import itertools
@@ -56,6 +55,7 @@ from iqm.pulse.playlist.instructions import (
     Instruction,
     IQPulse,
     MultiplexedIQPulse,
+    ReadoutMetrics,
     ReadoutTrigger,
     RealPulse,
     ThresholdStateDiscrimination,
@@ -492,6 +492,10 @@ class ScheduleBuilder:
         """Probe line channel for the probe line ``component`` belongs to.
 
         See :meth:`.get_drive_channel`.
+
+        Args:
+            component: name of a QPU component (typically qubit) to probe
+
         """
         probe_line = self.chip_topology.component_to_probe_line.get(component, None)
         if probe_line is None:
@@ -1038,7 +1042,7 @@ class ScheduleBuilder:
 
     def timeboxes_to_front_padded_playlist(
         self, boxes: Iterable[TimeBox], *, neighborhood: int = 0
-    ) -> tuple[Playlist, dict[str, set[str]]]:
+    ) -> tuple[Playlist, ReadoutMetrics]:
         """Temporary helper function, for converting a sequence of TimeBoxes to a Playlist.
 
         Each individual TimeBox in ``boxes`` is resolved into a Schedule, and then
@@ -1057,8 +1061,7 @@ class ScheduleBuilder:
                 blocks only the defined locus components and any other components which have occupied channels.
 
         Returns:
-            playlist that implements ``boxes`` and the mapping from readout labels to the set of used measurement
-            implementations (of the format ``<QuantumOp name>.<impl name>``).
+            playlist that implements ``boxes`` and the readout metrics for that playlist.
 
         """
         schedules = [self.resolve_timebox(box, neighborhood=neighborhood).cleanup() for box in boxes]
@@ -1102,7 +1105,7 @@ class ScheduleBuilder:
             playlist that implements ``boxes``
 
         """
-        return self.build_playlist(self.timebox_to_schedule(box, neighborhood=neighborhood) for box in boxes)[0]
+        return self.build_playlist([self.timebox_to_schedule(box, neighborhood=neighborhood) for box in boxes])[0]
 
     def timebox_to_schedule(
         self,
@@ -1453,8 +1456,8 @@ class ScheduleBuilder:
                 schedule.append(ch, Block(T))
 
     def build_playlist(  # noqa: PLR0915
-        self, schedules: Iterable[Schedule], finish_schedules: bool = True
-    ) -> tuple[Playlist, dict[str, set[str]]]:
+        self, schedules: Sequence[Schedule], finish_schedules: bool = True
+    ) -> tuple[Playlist, ReadoutMetrics]:
         """Build a playlist from a number of instruction schedules.
 
         This involves compressing the schedules so that no duplicate information
@@ -1468,8 +1471,7 @@ class ScheduleBuilder:
                 unless some process has already finalised them before calling this function.
 
         Returns:
-            playlist containing the schedules and the mapping from readout labels to the set of used measurement
-            implementations (of the format ``<QuantumOp name>.<impl name>``).
+            playlist containing the schedules and the readout metrics for this playlist.
 
         Raises:
             ValueError: if the schedules contain channels with non-uniform sampling rates
@@ -1492,6 +1494,7 @@ class ScheduleBuilder:
 
         pl = Playlist()
         mapped_instructions: dict[str, dict[int | Instruction, Any]] = {}
+        readout_metrics = ReadoutMetrics(num_segments=len(schedules))
 
         def _append_to_schedule(sc_schedule: SC_Schedule, channel_name: str, instr: Instruction) -> None:
             """Append ``instr`` to ``sc_schedule`` into the channel``channel_name``."""
@@ -1517,15 +1520,15 @@ class ScheduleBuilder:
 
                 # add the schedules in the playlist
 
-        label_to_implementation: dict[str, set[str]] = defaultdict(set)
-
         def _map_instruction(inst: Instruction) -> sc_instructions.Instruction:
             """TODO only necessary until SC has been updated to use the iqm.pulse Instruction class."""
             operation: Any
 
             def _map_acquisition(acq: AcquisitionMethod) -> sc_instructions.AcquisitionMethod:
-                if acq.implementation is not None:
-                    label_to_implementation[acq.label].add(acq.implementation)
+                if isinstance(acq, TimeTrace):
+                    return sc_instructions.TimeTrace(
+                        label=acq.label, delay_samples=acq.delay_samples, duration_samples=acq.duration_samples
+                    )
                 if isinstance(acq, ThresholdStateDiscrimination):
                     return sc_instructions.ThresholdStateDiscrimination(
                         label=acq.label,
@@ -1540,10 +1543,7 @@ class ScheduleBuilder:
                         delay_samples=acq.delay_samples,
                         weights=_map_instruction(acq.weights).operation,
                     )
-                if isinstance(acq, TimeTrace):
-                    return sc_instructions.TimeTrace(
-                        label=acq.label, delay_samples=acq.delay_samples, duration_samples=acq.duration_samples
-                    )
+
                 raise ValueError(f"Unknown AcquisitionMethod {acq}")
 
             if isinstance(inst, Wait):
@@ -1587,7 +1587,7 @@ class ScheduleBuilder:
             return sc_instructions.Instruction(duration_samples=int(inst.duration), operation=operation)
 
         # NOTE that there is no implicit right-alignment or equal duration for schedules, unlike in old-style playlists!
-        for schedule in schedules:
+        for seg_idx, schedule in enumerate(schedules):
             finished_schedule = self._finish_schedule(schedule) if finish_schedules else schedule
             sc_schedule = SC_Schedule()
             for channel_name, segment in finished_schedule.items():
@@ -1596,6 +1596,8 @@ class ScheduleBuilder:
                 pl.add_channel(channel)
                 prev_wait = None
                 for instruction in segment:
+                    if isinstance(instruction, ReadoutTrigger):
+                        readout_metrics.extend(instruction, seg_idx)
                     # convert all NONSOLID instructions into Waits
                     if finish_schedules and (isinstance(instruction, NONSOLID) or isinstance(instruction, Wait)):
                         if instruction.duration > 0:
@@ -1614,7 +1616,7 @@ class ScheduleBuilder:
                 if prev_wait:
                     _append_to_schedule(sc_schedule, channel_name, prev_wait)
             pl.segments.append(sc_schedule)
-        return pl, label_to_implementation
+        return pl, readout_metrics
 
     def _set_gate_implementation_shortcut(self, op_name: str) -> None:
         """Create shortcut for `self.get_implementation(<op_name>, ...)` as `self.<op_name>(...)`.

iqm/pulse/gate_implementation.py

@@ -602,7 +602,7 @@ class SinglePulseGate(GateImplementation):
         return self.builder.channels[self.channel].duration_to_seconds(self.pulse.duration)
 
 
-def init_subclass_composite(gate_class: type[CompositeGate]) -> None:
+def init_subclass_composite(gate_class: type[CompositeGate]) -> None:  # noqa: D103
     if not gate_class.registered_gates:
         # this would be pointless
         raise ValueError(f"CompositeGate {gate_class.__name__} has no registered gates.")

iqm/pulse/gates/__init__.py

@@ -49,7 +49,12 @@ from iqm.pulse.gates.cz import (
 from iqm.pulse.gates.default_gates import _implementation_library, _quantum_ops_library
 from iqm.pulse.gates.delay import Delay
 from iqm.pulse.gates.flux_multiplexer import FluxMultiplexer_SampleLinear
-from iqm.pulse.gates.measure import Measure_Constant, Measure_Constant_Qnd, Shelved_Measure_Constant
+from iqm.pulse.gates.measure import (
+    Fast_Measure_Constant,
+    Measure_Constant,
+    Measure_Constant_Qnd,
+    Shelved_Measure_Constant,
+)
 from iqm.pulse.gates.move import MOVE_CRF_CRF, MOVE_SLEPIAN_CRF, MOVE_TGSS_CRF
 from iqm.pulse.gates.prx import (
     Constant_PRX_with_smooth_rise_fall,
@@ -105,6 +110,7 @@ _exposed_implementations: dict[str, type[GateImplementation]] = {
         FluxPulseGate_CRF_CRF,
         Measure_Constant,
         Measure_Constant_Qnd,
+        Fast_Measure_Constant,
         Shelved_Measure_Constant,
         PRX_ModulatedDRAGCosineRiseFall,
         MOVE_CRF_CRF,

iqm/pulse/gates/default_gates.py

@@ -38,7 +38,11 @@ from iqm.pulse.gates.cz import (
 )
 from iqm.pulse.gates.delay import Delay
 from iqm.pulse.gates.flux_multiplexer import FluxMultiplexer_SampleLinear
-from iqm.pulse.gates.measure import Measure_Constant, Shelved_Measure_Constant
+from iqm.pulse.gates.measure import (
+    Fast_Measure_Constant,
+    Measure_Constant,
+    Shelved_Measure_Constant,
+)
 from iqm.pulse.gates.move import MOVE_CRF_CRF, MOVE_SLEPIAN_CRF, MOVE_TGSS_CRF
 from iqm.pulse.gates.prx import (
     PRX_DRAGCosineRiseFall,
@@ -68,6 +72,7 @@ _implementation_library: dict[str, dict[str, type[GateImplementation]]] = {
     "delay": {"wait": Delay},
     "measure": {
         "constant": Measure_Constant,
+        "fast_constant": Fast_Measure_Constant,
     },
     "measure_fidelity": {
         "constant": Measure_Constant,

iqm/pulse/gates/measure.py

@@ -32,6 +32,7 @@ from iqm.pulse.gate_implementation import (
     Locus,
     OILCalibrationData,
 )
+from iqm.pulse.playlist import Schedule, Segment
 from iqm.pulse.playlist.channel import ProbeChannelProperties
 from iqm.pulse.playlist.instructions import (
     AcquisitionMethod,
@@ -44,7 +45,7 @@ from iqm.pulse.playlist.instructions import (
     TimeTrace,
 )
 from iqm.pulse.playlist.waveforms import Constant, Samples
-from iqm.pulse.timebox import MultiplexedProbeTimeBox, SchedulingStrategy, TimeBox
+from iqm.pulse.timebox import MultiplexedProbeTimeBox, ProbeTimeBoxes, SchedulingStrategy, TimeBox
 
 if TYPE_CHECKING:  # pragma: no cover
     from iqm.pulse.builder import ScheduleBuilder
@@ -53,6 +54,7 @@ if TYPE_CHECKING:  # pragma: no cover
 DEFAULT_INTEGRATION_KEY = "readout.result"
 DEFAULT_TIME_TRACE_KEY = "readout.time_trace"
 FEEDBACK_KEY = "feedback"
+TIMING_TOLERANCE = 1e-12
 
 
 class Measure_CustomWaveforms(CustomIQWaveforms):
@@ -301,16 +303,17 @@ class Measure_CustomWaveforms(CustomIQWaveforms):
                     for c in self.locus
                 ]
                 probe_timebox = functools.reduce(lambda x, y: x + y, probe_timeboxes)
-            probe_timebox.neighborhood_components[0] = copy(self._neighborhood_components)
-            if feedback_key:
-                # Block all the virtual channels from the probes involved in self.locus as we cannot know what AWG
-                # might be listening to the sent bits. NOTE: No Waits are added, the channels are just blocked in
-                # scheduling, so the impact to performance is negligible
-                probelines = {self.builder.chip_topology.component_to_probe_line[q] for q in self.locus}
-                for probe in probelines:
-                    probe_timebox.neighborhood_components[0].update(
-                        set(self.builder.get_virtual_feedback_channels(probe))
-                    )
+            if isinstance(probe_timebox, TimeBox):  # FIXME: not needed once the measure implementations are cleaned up
+                probe_timebox.neighborhood_components[0] = copy(self._neighborhood_components)
+                if feedback_key:
+                    # Block all the virtual channels from the probes involved in self.locus as we cannot know what AWG
+                    # might be listening to the sent bits. NOTE: No Waits are added, the channels are just blocked in
+                    # scheduling, so the impact to performance is negligible
+                    probelines = {self.builder.chip_topology.component_to_probe_line[q] for q in self.locus}
+                    for probe in probelines:
+                        probe_timebox.neighborhood_components[0].update(
+                            set(self.builder.get_virtual_feedback_channels(probe))
+                        )
             self._multiplexed_timeboxes[args] = probe_timebox
         return self._multiplexed_timeboxes[args]
 
@@ -876,11 +879,6 @@ class ShelvedMeasureTimeBox(TimeBox):
         return super().__radd__(other)
 
 
-SHELVED_OFFSET_TOLERANCE = 1e-12
-"""Tolerance for the absolute value of shelved measure ``second_prx_12_offset`` calibration value 
-being considered zero."""
-
-
 class Shelved_Measure_CustomWaveforms(Measure_CustomWaveforms, CompositeGate):
     """Base class for shelved readout.
 
@@ -945,7 +943,7 @@ class Shelved_Measure_CustomWaveforms(Measure_CustomWaveforms, CompositeGate):
                 # schedule the shelved box to get an atomic schedule
                 shelved_atom = deepcopy(self.builder.resolve_timebox(shelved_box, neighborhood=0))
                 offset = self.calibration_data["second_prx_12_offset"]
-                if self.calibration_data["do_prx_12"] and abs(offset) > SHELVED_OFFSET_TOLERANCE:
+                if self.calibration_data["do_prx_12"] and abs(offset) > TIMING_TOLERANCE:
                     drive_channel_name = self.builder.get_drive_channel(self.locus[0])
                     drive_channel = self.builder.channels[drive_channel_name]
                     offset_sign = offset / abs(offset)
@@ -998,3 +996,123 @@ class Shelved_Measure_Constant(Shelved_Measure_CustomWaveforms, wave_i=Constant,
 
     A measure gate implemented as a constant waveform is surrounded by two `prx_12` gates.
     """
+
+
+class Fast_Measure_CustomWaveforms(Measure_CustomWaveforms):
+    """Measure implementation that blocks locus qubits for a shorter duration than the probes.
+
+    The locus qubits are blocked only for the physical probe pulse duration plus (calibratable) extra dead time that
+    can be used to take into account e.g. ring down delay of waiting the readout resonator to empty itself. The probe
+    channels are still blocked as in ``Measure_CustomWaveforms``, i.e. for the duration of
+    ``acquisition_delay + integration_length + integration_dead_time``.
+    """
+
+    root_parameters = Measure_CustomWaveforms.root_parameters | {
+        "locus_deadtime": Setting(
+            Parameter("locus_deadtime", "Locus dead time after the probe pulse", unit="s"),
+            0.0,
+        ),
+    }
+
+    def probe_timebox(  # type: ignore[override]
+        self, key: str = "", feedback_key: str = "", do_acquisition: bool = True, **kwargs
+    ) -> ProbeTimeBoxes:
+        """Otherwise the same as ``Measure_CustomWaveforms.probe_timebox``, but returns two TimeBoxes, the
+        actual MultiplexedProbeTimeBox and the rest of the probe-blocking wait time in its own TimeBox. This
+        allows the "tetris logic" in scheduling to block the locus qubits for a shorter duration.
+        """
+        args = (key, feedback_key, do_acquisition)
+        if args not in self._multiplexed_timeboxes:
+            if len(self.locus) == 1:
+                probe = self.builder.chip_topology.component_to_probe_line[self.locus[0]]
+                probe_channel = self.builder.get_probe_channel(self.locus[0])
+                try:
+                    drive_channel = self.builder.get_drive_channel(self.locus[0])
+                except KeyError:
+                    drive_channel = ""
+
+                combined_probe_timebox = super().probe_timebox(
+                    key, feedback_key, do_acquisition=do_acquisition, **kwargs
+                )
+                readout_trigger = combined_probe_timebox.atom[probe_channel][0]  # type: ignore[index]
+                actual_probe_duration = readout_trigger.probe_pulse.duration
+
+                # MultiplexedProbeTimeBox that has the minimum possible duration
+                if self.calibration_data["locus_deadtime"] > TIMING_TOLERANCE:
+                    deadtime = self.builder.channels[probe_channel].duration_to_int_samples(
+                        self.calibration_data["locus_deadtime"]
+                    )
+                else:
+                    deadtime = 0
+                # Must be: ReadoutTrigger.duration > ReadoutTrigger.probe_pulse.duration so if they would match, we
+                # need to add a minimum offset to make it hold, i.e. the smallest granularity allowed by the probe
+                # channel
+                probe_granularity = self.builder.channels[probe_channel].instruction_duration_granularity
+                offset = max(deadtime, probe_granularity)
+
+                truncated_readout_trigger = replace(readout_trigger, duration=actual_probe_duration + offset)
+                physical_probe_box = MultiplexedProbeTimeBox.from_readout_trigger(
+                    truncated_readout_trigger,
+                    probe_channel,
+                    locus_components=self.locus,
+                    label=f"Physical probe box of {self.__class__.__name__} on {self.locus}",
+                    block_channels=[drive_channel] if drive_channel else [],
+                    block_duration=truncated_readout_trigger.duration if drive_channel else 0,
+                )
+                physical_probe_box.neighborhood_components[0] = combined_probe_timebox.neighborhood_components[0].copy()
+                # extra Blocks (integration etc) for the probe channel
+                extra_block_duration = max(combined_probe_timebox.atom.duration - truncated_readout_trigger.duration, 0)  # type:ignore[union-attr]
+                virtual_extra_wait_box = TimeBox.atomic(
+                    Schedule({probe_channel: Segment([Block(extra_block_duration)])}),
+                    locus_components=[probe],
+                    label=f"Virtual probe extra wait box of {self.__class__.__name__} on {self.locus}",
+                )
+                virtual_extra_wait_box.neighborhood_components[0] = {probe}
+                final_boxes = ProbeTimeBoxes([physical_probe_box, virtual_extra_wait_box])
+            else:
+                # FIXME: all the return types in the measure impls need to be cleaned up
+                final_boxes = super().probe_timebox(key, feedback_key, do_acquisition=do_acquisition, **kwargs)  # type:ignore[assignment]
+            if feedback_key:
+                probelines = {self.builder.chip_topology.component_to_probe_line[q] for q in self.locus}
+                for probe in probelines:
+                    final_boxes[1].neighborhood_components[0].update(
+                        set(self.builder.get_virtual_feedback_channels(probe))
+                    )
+            self._multiplexed_timeboxes[args] = final_boxes  # type:ignore[assignment]
+            return final_boxes  # type:ignore[return-value]
+        return self._multiplexed_timeboxes[args]  # type:ignore[return-value]
+
+    def _call(self, key: str = "", feedback_key: str = "") -> list[TimeBox]:  # type:ignore[override]
+        """The same as ``Measure_CustomWaveforms._call``, i.e. wrap the "naked" multiplexable probe_timeboxes
+        into a composite TimeBox.
+        """
+        probe_box, wait_box = self.probe_timebox(key, feedback_key, do_acquisition=True)
+        final_box = TimeBox.composite([probe_box], label=f"Readout on {self.locus}")
+        final_box.neighborhood_components[0] = final_box.children[0].neighborhood_components[0]
+        return [final_box, wait_box]
+
+    def _get_probe_timebox_for_time_trace(self, key: str = "", feedback_key: str = "") -> TimeBox:
+        """Get the probe TimeBox for TimeTrace. This is just a single MultiplexedProbeTimeBox which has the full
+        probe duration (including integration). The faster logic wrt. qubit blocking is not important in the context of
+        TimeTraces.
+        """
+        # FIXME: not needed once we align the return types of all these measure gates
+        # Then we can make this method also shorter for the locus qubits
+        probe_boxes = self.probe_timebox(key, feedback_key, do_acquisition=True)
+        total_box = TimeBox.composite(self.probe_timebox(key, feedback_key, do_acquisition=True))
+        probe_schedule = self.builder.resolve_timebox(total_box, neighborhood=0)
+        atomic_probe_box = MultiplexedProbeTimeBox.atomic(
+            probe_schedule,
+            label=f"Time Trace atomic probe box of {self.__class__.__name__} on {self.locus}",
+            locus_components=probe_boxes[0].locus_components,
+        )
+        atomic_probe_box.neighborhood_components[0] = probe_boxes[0].neighborhood_components[0]
+        return atomic_probe_box  # type:ignore[return-value]
+
+
+class Fast_Measure_Constant(Fast_Measure_CustomWaveforms, wave_i=Constant, wave_q=Constant):  # type:ignore[call-arg]
+    """Implementation of a faster measure with constant i and q waveforms.
+
+    Does not block the drive and flux channels of the locus qubits during the integration, but just during the probe
+    pulse and extra calibrated dead time after it.
+    """

iqm/pulse/playlist/instructions.py

@@ -15,9 +15,11 @@
 
 from __future__ import annotations
 
+from collections.abc import Callable
 import dataclasses
 from dataclasses import dataclass, field
 import random
+import re
 
 from iqm.pulse.playlist.waveforms import Waveform
 
@@ -271,3 +273,122 @@ class ReadoutTrigger(Instruction):
             ),
             acquisitions=self.acquisitions + other.acquisitions,
         )
+
+
+@dataclass
+class ReadoutMetrics:
+    """Aggregates the necessary readout metrics needed for return data processing."""
+
+    num_segments: int
+    """Number of segments in the Playlist this ReadoutMetrics object represents."""
+    integration_occurrences: dict[str, list[int]] = field(default_factory=dict)
+    """Map each integration readout label (of the format ``"<component>__<readout key>"``) to its number of occurrences
+    in each Playlist segment."""
+    timetrace_occurrences: dict[str, list[int]] = field(default_factory=dict)
+    """Map each time trace label (of the format ``"<component>__<readout key>"``) to its number of occurrences in each
+    Playlist segment."""
+    timetrace_lengths: dict[str, int] = field(default_factory=dict)
+    """Map each time trace label (of the format ``"<component>__<readout key>"``) to its number of time trace samples.
+    """
+    implementations: dict[str, set[str]] = field(default_factory=dict)
+    """Map each integration or time trace readout label to its implementations (of the format 
+    ``"<measure gate name>.<implementation name>"``)."""
+
+    def extend(self, trigger: ReadoutTrigger, seg_idx: int) -> None:
+        """Extend the metrics with a ReadoutTrigger in a given Playlist Segment.
+
+        Args:
+            trigger: The readout trigger.
+            seg_idx: The index of the Playlist segment ``trigger`` belongs to.
+
+        """
+        for acq in trigger.acquisitions:
+            if isinstance(acq, TimeTrace):
+                occurrences = self.timetrace_occurrences
+                if acq.label in self.timetrace_lengths:
+                    if self.timetrace_lengths[acq.label] != acq.duration_samples:
+                        raise ValueError(f"Time trace length mismatch in label {acq.label}")
+                else:
+                    self.timetrace_lengths[acq.label] = acq.duration_samples
+            else:
+                occurrences = self.integration_occurrences
+            if acq.label not in occurrences:
+                occurrences[acq.label] = [0] * self.num_segments
+            occurrences[acq.label][seg_idx] += 1
+            if acq.implementation is not None:
+                if acq.label not in self.implementations:
+                    self.implementations[acq.label] = set()
+                self.implementations[acq.label].add(acq.implementation)
+
+    def filter_out(
+        self,
+        labels: list[str] | None = None,
+        components: list[str] | None = None,
+        keys: list[str] | None = None,
+    ) -> None:
+        """Filter out labels from the contents in self.
+
+        Args:
+            labels: The labels to filter out.
+            components: The components to filter out (all labels for these components will be removed).
+            keys: The keys to filter out (all components with these keys will be removed).
+
+        """
+        labels = labels if labels else []
+        components = components if components else []
+        keys = keys if keys else []
+        for field_name in ["integration_occurrences", "timetrace_occurrences", "timetrace_lengths", "implementations"]:
+            field = getattr(self, field_name)
+            field_copy = field.copy()
+            for label, contents in field.items():
+                component, key = re.split("__[_]*", label)
+                if component in components or key in keys or label in labels:
+                    del field_copy[label]
+            setattr(self, field_name, field_copy)
+
+    def get_labels(self, integration: bool = True, timetrace: bool = True) -> set[str]:
+        """Get all the labels in self
+
+        Args:
+            integration: Whether to get integration labels.
+            timetrace: Whether to get time-trace labels.
+
+        Returns:
+            The applicable labels in self.
+
+        """
+        return self._get(lambda label: label, integration=integration, timetrace=timetrace)
+
+    def get_components(self, integration: bool = True, timetrace: bool = True) -> set[str]:
+        """Get all components in the labels in self
+
+        Args:
+            integration: Whether to get components from the integration labels.
+            timetrace:  Whether to get components from the time-trace labels.
+
+        Returns:
+            The applicable components in self.
+
+        """
+        return self._get(lambda label: re.split("__[_]*", label)[0], integration=integration, timetrace=timetrace)
+
+    def get_keys(self, integration: bool = True, timetrace: bool = True) -> set[str]:
+        """Get all readout keys in the labels in self
+
+        Args:
+            integration: Whether to get readout keys from the integration labels.
+            timetrace:  Whether to get readout keys from the time-trace labels.
+
+        Returns:
+            The applicable readout keys in self.
+
+        """
+        return self._get(lambda label: re.split("__[_]*", label)[1], integration=integration, timetrace=timetrace)
+
+    def _get(self, func: Callable, integration: bool = True, timetrace: bool = True) -> set[str]:
+        contents = []
+        if integration:
+            contents += [func(label) for label in self.integration_occurrences]
+        if timetrace:
+            contents += [func(label) for label in self.timetrace_occurrences]
+        return set(contents)

iqm/pulse/timebox.py

@@ -122,8 +122,9 @@ class TimeBox:
      this ``TimeBox`` for any reason.
     """
 
-    @staticmethod
+    @classmethod
     def composite(
+        cls,
         boxes: Iterable[TimeBox | Iterable[TimeBox]],
         *,
         label: str = "",
@@ -155,7 +156,7 @@ class TimeBox:
             locus_components = set.union(*(box.locus_components for box in children))
         else:
             locus_components = set()
-        return TimeBox(
+        return cls(
             label=label,
             locus_components=locus_components,
             atom=None,
@@ -363,6 +364,8 @@ class MultiplexedProbeTimeBox(TimeBox):
                 scheduling_algorithm=self.scheduling_algorithm,
                 neighborhood_components=neighborhood_components,
             )
+        if isinstance(other, ProbeTimeBoxes):
+            return self + other[0]
         return super().__add__(other)
 
     @staticmethod
@@ -401,3 +404,61 @@ class MultiplexedProbeTimeBox(TimeBox):
             scheduling_algorithm=SchedulingAlgorithm.HARD_BOUNDARY,
         )
         return box
+
+
+class ProbeTimeBoxes(list):
+    """Allows multiplexing lists of probe TimeBoxes with each other and ``MultiplexedProbeTimeBox``es.
+
+    The first element is a ``MultiplexedProbeTimeBox`` and the second an atomic ``TimeBox`` containing ``Block``
+    instructions on probe channels (corresponding to e.g. the integration time).
+
+    If ``A`` is a ``ProbeTimeBoxes`` and ``B`` is a ``ProbeTimeBoxes``, then ``A+B`` is also a ProbeTimeBoxes instance
+    with the timings adjusted correctly and the ``MultiplexedProbeTimeBox``es in each multiplexed together.
+    If ``A`` is a ``ProbeTimeBoxes`` and ``B`` is a ``MultiplexedProbeTimeBox`` where the probe instructions are
+    multiplexed together and the duration is ``max(A[0].duration, B.duration)`` (the addition is symmetric).
+    Otherwise (if ``B`` is a list of ``Timebox``es or a non-probe ``TimeBox``), ``A+B`` works like
+    ``TimeBox.__add__``.
+    """
+
+    # FIXME: does not yet work with ShelvedProbeTimeBox
+    # All the measure gates should probably eventually return lists of TimeBoxes (that's the only way to "tetris"
+    # schedule stuff) and we should extend that to cover all the use cases, including Shelved.
+
+    def __init__(self, timeboxes: list[TimeBox]):
+        super().__init__(timeboxes)
+        if len(self) != 2:
+            raise ValueError(
+                "ProbeTimeBoxes instances must have exactly two elements, the first being the "
+                "MultiplexedProbeTimebox of the physical probe channels and the second the "
+                " extra Blocks in the probe channels."
+            )
+        if not isinstance(self[0], TimeBox) or self[0].atom is None or not isinstance(self[0], MultiplexedProbeTimeBox):
+            raise ValueError("The first child must be an atomic MultiplexedProbeTimeBox.")
+        if not isinstance(self[1], TimeBox) or self[1].atom is None:
+            raise ValueError(
+                "The second child must be an atomic TimeBox containing the extra Waits in the probe channels."
+            )
+
+    def __add__(self, other: TimeBox | list[TimeBox]) -> TimeBox | list[TimeBox]:  # type: ignore[override]
+        """Multiplex ``self`` with other ``ProbeTimeBoxes`` instances or with ``MultiplexedProbeTimeBox`` instances."""
+        if isinstance(other, ProbeTimeBoxes):
+            duration_self = sum(child.atom.duration for child in self)
+            duration_probe_self = self[0].atom.duration
+            duration_other = sum(child.atom.duration for child in other)
+            duration_probe_other = other[0].atom.duration
+            extra_wait_duration = max(duration_self, duration_other) - max(duration_probe_self, duration_probe_other)
+            extra_wait_channels = [*self[1].atom.channels(), *other[1].atom.channels()]
+            probe_box = self[0] + other[0]
+            extra_wait_box = TimeBox.atomic(
+                Schedule({ch: Segment([Block(extra_wait_duration)]) for ch in extra_wait_channels}),
+                locus_components=set(self[1].locus_components).union(other[1].locus_components),
+                label="Virtual probe channel Block",
+            )
+            if 0 in self[1].neighborhood_components and 0 in other[1].neighborhood_components:
+                extra_wait_box.neighborhood_components[0] = (
+                    self[1].neighborhood_components[0].union(other[1].neighborhood_components[0])
+                )
+            return ProbeTimeBoxes([probe_box, extra_wait_box])
+        if isinstance(other, MultiplexedProbeTimeBox):
+            return self[0] + other
+        return list(self) + other

{iqm_pulse-12.6.1.dist-info → iqm_pulse-12.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-pulse
-Version: 12.6.1
+Version: 12.7.1
 Summary: A Python-based project for providing interface and implementations for control pulses.
 Author-email: IQM Finland Oy <info@meetiqm.com>
 License: Apache License
@@ -204,7 +204,7 @@ License: Apache License
            WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
            See the License for the specific language governing permissions and
            limitations under the License.
-Project-URL: Documentation, https://iqm-finland.github.io/docs/iqm-pulse/
+Project-URL: Documentation, https://docs.meetiqm.com/iqm-pulse/
 Project-URL: Homepage, https://pypi.org/project/iqm-pulse/
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3 :: Only
@@ -213,7 +213,6 @@ Classifier: Intended Audience :: Science/Research
 Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
-Requires-Dist: iqm-exa-common <28,>=27
 Requires-Dist: iqm-data-definitions <3.0,>=2.18
 Requires-Dist: python-rapidjson ==1.20
 Requires-Dist: jinja2 ==3.0.3
@@ -226,7 +225,7 @@ IQM Pulse library
 
 A Python-based project for providing interface and implementations for control pulses.
 
-See `API documentation <https://iqm-finland.github.io/docs/iqm-pulse/>`_.
+See `API documentation <https://docs.meetiqm.com/iqm-pulse/>`_.
 
 Copyright
 ---------

{iqm_pulse-12.6.1.dist-info → iqm_pulse-12.7.1.dist-info}/RECORD

@@ -1,23 +1,23 @@
 iqm/pulse/__init__.py,sha256=aQhtfbLQgr_1IvbZLH1MCuf0aFomokeu7DSjxuDWZC4,978
 iqm/pulse/base_utils.py,sha256=ll3k8wbVxjHi6XcVo3PEWIjHx5QjG1C-yH218zTG8jU,2657
-iqm/pulse/builder.py,sha256=uL2MsAvRs1dJfe2mVNrrHEqUoBBTJlABt0KmBtB6hl0,78294
+iqm/pulse/builder.py,sha256=TByM0GSq13eim2vL3I1uBMU7otzheHAIzsVYxyZXSUc,78179
 iqm/pulse/circuit_operations.py,sha256=P83gevhGcaY4DaopGKO3CHN_CnWAPfEu-MHoLkqhu5Y,24847
-iqm/pulse/gate_implementation.py,sha256=nyoP54-VWKx9rO8MW5ZqCRPjsMTKfJFu_6cgabxJSj4,39843
+iqm/pulse/gate_implementation.py,sha256=LuQuzv45X1iAOAe2UGegu--oFdrudVPCAwvXGgt7sAE,39857
 iqm/pulse/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 iqm/pulse/quantum_ops.py,sha256=cV13V1t2rj9lgNKXgGZXMcNgEPJ7oraHL6eJJTlLvWk,14825
 iqm/pulse/scheduler.py,sha256=62gH3AcxmsgmShcmtNaiCqFLRl1Wll6Q24zIkhw_-XM,22768
-iqm/pulse/timebox.py,sha256=VbNgxYsXP-Plx4FAX9b2v_CThJJh9dBzFun3E5jzP7o,17249
+iqm/pulse/timebox.py,sha256=qk3QkNKukbys0K8bEEP1fHGMQswCTudsagg-a9WBQhM,20904
 iqm/pulse/utils.py,sha256=UjB5AHgDOj_5nm-Rt6Ql9GJpjV3OrtwpEVzysXhQghY,7466
 iqm/pulse/validation.py,sha256=U392B1QtX2nRNAD2j1eThrim1VH18SNKGYAYUVR9_q4,10781
-iqm/pulse/gates/__init__.py,sha256=l07iD52FiKKQyVFwswRapZMqEE0XfILSc4aZ5sXGJo4,8811
+iqm/pulse/gates/__init__.py,sha256=Rjynol8PAJ5QWeAFCaGQRfw0w3_p3MFlWE898lojWNc,8886
 iqm/pulse/gates/barrier.py,sha256=WhYV70lf4lh4Wa9UZuMk2lp9JbUQIu8lzewRC2P7pNE,2546
 iqm/pulse/gates/conditional.py,sha256=mY7b4HmznFF5VUAXrbK7tDxCP4n2pASINa3TJHjHA6o,6872
 iqm/pulse/gates/cz.py,sha256=2-LqAMG08dOReQp8K517zTkMmhDfwXhEXPqTPyjppDk,33519
-iqm/pulse/gates/default_gates.py,sha256=JwdrCh_Blee4mMWZ8v8ymw3Ep0fZBvw9wuaLR3rjDXA,8073
+iqm/pulse/gates/default_gates.py,sha256=bmlHWWSKvzdl35YBJlYHaqLagqaYbgJSmqdspuwZpjs,8161
 iqm/pulse/gates/delay.py,sha256=nST9dY2JFp_mpKhiSfsYa5yL4hFKcNJSAyCzXjhauQg,3767
 iqm/pulse/gates/enums.py,sha256=ATwb6vZYpfgQ1gQyFPW53JyIKrdAP3FPHm6jV-t9OAk,2532
 iqm/pulse/gates/flux_multiplexer.py,sha256=sk84ItEvkx7Z0pCHt8MCCczBe7_BHNvqS4_oeNghZw8,9757
-iqm/pulse/gates/measure.py,sha256=3gxMjUvQrum9ZVnm8rvRHqPUQYqOCnD3IsgnrP-vECY,51968
+iqm/pulse/gates/measure.py,sha256=0vD-GEcS5CUOIl7HR42ekFO2ILHT0TBcNpBB2NFKHK8,59354
 iqm/pulse/gates/move.py,sha256=siy9SBIFohknYV6zEJuUZv03cDEOiS53p9jFYm-5WAA,17470
 iqm/pulse/gates/prx.py,sha256=gWT4vEL6BZvRNOkwlxSg_V8nq7baFgh2K-V8q3bqLjI,25203
 iqm/pulse/gates/reset.py,sha256=JzUurqhncTQ3Ti9tJyQHSybSXZsGslV0K-Dz5GRliPI,7066
@@ -28,7 +28,7 @@ iqm/pulse/playlist/__init__.py,sha256=XW-7Po_vCzhkk1Js06K8P-5srPpBuPHkqpc1yhL_Zx
 iqm/pulse/playlist/channel.py,sha256=RKFaLfdL436LOw-sNvcNVhNEQrQDoCWJsN8k2p479OQ,17180
 iqm/pulse/playlist/fast_drag.py,sha256=80Knv0Q9IaGiVdc0TrHlxNi1zJtTUZvWIVO38reYcA0,19600
 iqm/pulse/playlist/hd_drag.py,sha256=JYRy3aPu0LD9y0H3UncOiWI39eV9-TARvgLonNUsaO0,13562
-iqm/pulse/playlist/instructions.py,sha256=z9umJqFLTsSd26EuzW-X5raWVHGpSLds9s4m8tDAV-E,10249
+iqm/pulse/playlist/instructions.py,sha256=uCZX5uKO5XV8fnQQO-_GwMXKcRFsHCu7hdL3YQwBI_4,15559
 iqm/pulse/playlist/playlist.py,sha256=7MIX4iRfh2Nit8AnpNyqv5A5ZmK7JR-v201DXVL6kUk,685
 iqm/pulse/playlist/schedule.py,sha256=ToaHKgDxNxLUQalI2TAMMld-EH5Im9rZNktQkXhOyBk,18037
 iqm/pulse/playlist/waveforms.py,sha256=w5Kgpo7VJwsaCUUKOu3rf5pNmN7Jw2jVLTn3hH-k0R4,23973
@@ -39,8 +39,8 @@ iqm/pulse/playlist/visualisation/templates/static/logo.png,sha256=rbfQZ6_UEaztpY
 iqm/pulse/playlist/visualisation/templates/static/moment.min.js,sha256=4iQZ6BVL4qNKlQ27TExEhBN1HFPvAvAMbFavKKosSWQ,53324
 iqm/pulse/playlist/visualisation/templates/static/vis-timeline-graph2d.min.css,sha256=svzNasPg1yR5gvEaRei2jg-n4Pc3sVyMUWeS6xRAh6U,19837
 iqm/pulse/playlist/visualisation/templates/static/vis-timeline-graph2d.min.js,sha256=OqCqCyA6JnxPz3PGXq_P_9VuSqWptgNt5Ev3T-xjefQ,570288
-iqm_pulse-12.6.1.dist-info/LICENSE.txt,sha256=R6Q7eUrLyoCQgWYorQ8WJmVmWKYU3dxA3jYUp0wwQAw,11332
-iqm_pulse-12.6.1.dist-info/METADATA,sha256=YFmqgzW0EOBqKVCAYvmretZ9LwjM8Mq-RHJk7DrivK8,14551
-iqm_pulse-12.6.1.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
-iqm_pulse-12.6.1.dist-info/top_level.txt,sha256=NB4XRfyDS6_wG9gMsyX-9LTU7kWnTQxNvkbzIxGv3-c,4
-iqm_pulse-12.6.1.dist-info/RECORD,,
+iqm_pulse-12.7.1.dist-info/LICENSE.txt,sha256=R6Q7eUrLyoCQgWYorQ8WJmVmWKYU3dxA3jYUp0wwQAw,11332
+iqm_pulse-12.7.1.dist-info/METADATA,sha256=TpcZsymL50pnJKrIgF86AZW_IZm0IiD02PD1f8V9zvI,14492
+iqm_pulse-12.7.1.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+iqm_pulse-12.7.1.dist-info/top_level.txt,sha256=NB4XRfyDS6_wG9gMsyX-9LTU7kWnTQxNvkbzIxGv3-c,4
+iqm_pulse-12.7.1.dist-info/RECORD,,