iqm-pulse 9.4__py3-none-any.whl → 9.6__py3-none-any.whl

iqm/pulse/gates/__init__.py

@@ -66,6 +66,7 @@ from iqm.pulse.gates.reset import Reset_Conditional, Reset_Wait
 from iqm.pulse.gates.rz import (
     RZ_ACStarkShift_CosineRiseFall,
     RZ_ACStarkShift_smoothConstant,
+    RZ_PRX_Composite,
     RZ_Virtual,
     get_unitary_rz,
 )
@@ -88,6 +89,7 @@ _exposed_implementations: dict[str, type[GateImplementation]] = {
         PRX_HdDragSX,
         SXGate,
         UGate,
+        RZ_PRX_Composite,
         RZ_Virtual,
         CZ_CRF_ACStarkCRF,
         CZ_Slepian_ACStarkCRF,

iqm/pulse/gates/default_gates.py

@@ -47,6 +47,7 @@ from iqm.pulse.gates.prx import (
 from iqm.pulse.gates.reset import Reset_Conditional, Reset_Wait
 from iqm.pulse.gates.rz import (
     RZ_ACStarkShift_CosineRiseFall,
+    RZ_PRX_Composite,
     RZ_Virtual,
     get_unitary_rz,
 )
@@ -71,7 +72,7 @@ _default_implementations = {
     },
     "u": {"prx_u": UGate},
     "sx": {"prx_sx": SXGate},
-    "rz": {"virtual": RZ_Virtual},
+    "rz": {"virtual": RZ_Virtual, "prx_composite": RZ_PRX_Composite},
     "rz_physical": {"ac_stark_crf": RZ_ACStarkShift_CosineRiseFall},
     "cz": {
         "tgss": CZ_TruncatedGaussianSmoothedSquare,

iqm/pulse/gates/measure.py

@@ -573,3 +573,215 @@ class ProbePulse_CustomWaveforms(CustomIQWaveforms):
     @classmethod
     def get_locus_mapping_name(cls, operation_name: str, implementation_name: str) -> str:
         return PROBE_LINES_LOCUS_MAPPING
+
+
+class ProbePulse_CustomWaveforms_noIntegration(CustomIQWaveforms):
+    """Base class for implementing a probe line probe pulse with custom waveforms in the I and Q channels without
+    any integration.
+
+    Similar to the :class:`ProbePulse_CustomWaveforms` except that signal integration is removed.
+    """
+
+    root_parameters = {
+        "frequency": Parameter("", "Readout pulse frequency", "Hz"),
+        "duration": Parameter("", "Readout pulse duration", "s"),
+        "phase": Parameter("", "Readout pulse phase", "rad"),
+        "amplitude_i": Parameter("", "Readout channel I amplitude", ""),
+        "amplitude_q": Parameter("", "Readout channel Q amplitude", ""),
+    }
+
+    def __init__(
+        self, parent: QuantumOp, name: str, locus: Locus, calibration_data: OILCalibrationData, builder: ScheduleBuilder
+    ):
+        super().__init__(parent, name, locus, calibration_data, builder)
+
+        self._multiplexed_timeboxes: dict[tuple[str, str, bool], MultiplexedProbeTimeBox] = {}
+        """Cache for :meth:`probe_timebox`."""
+
+        if len(locus) == 1:  # factorizable gates only need calibration on 1-loci
+            self._probe_line: ProbeChannelProperties = self.builder.channels[
+                self.builder.get_probe_channel(self.locus[0])
+            ]
+            c_freq = self._probe_line.center_frequency
+            if_freq = (calibration_data["frequency"] - c_freq) / self._probe_line.sample_rate
+            self._duration = (
+                self._probe_line.duration_to_int_samples(
+                    self._probe_line.round_duration_to_granularity(calibration_data["duration"])
+                )
+                + self._probe_line.instruction_duration_granularity
+            )
+
+            waveform_params = self.convert_calibration_data(
+                calibration_data,
+                {k: v for k, v in self.parameters.items() if k not in self.root_parameters or k == "duration"},
+                self._probe_line,
+            )
+            root_params = {k: v for k, v in calibration_data.items() if k in self.root_parameters and k != "duration"}
+
+            probe_instruction = self._build_instructions(waveform_params, root_params, if_freq)
+            self._probe_instruction = probe_instruction
+            self._prio_calibration: OILCalibrationData | None = None
+        else:
+            # we need to store the possible cal_data == priority calibration in order to propagate it to the factored
+            # single-component measure calls in :meth:`probe_timebox`
+            self._prio_calibration = calibration_data or None
+
+    def _build_instructions(
+        self, waveform_params: OILCalibrationData, root_params: OILCalibrationData, if_freq: float
+    ) -> IQPulse:
+        """Builds a probe pulse and an acquisition method using the calibration data.
+
+        Subclasses may override this method if needed.
+        """
+        if self.dependent_waves:
+            wave_i = self.wave_i(**waveform_params)
+            wave_q = self.wave_q(**waveform_params)
+        else:
+            wave_i = self.wave_i(**waveform_params["i"])
+            wave_q = self.wave_q(**waveform_params["q"])
+
+        probe_pulse = IQPulse(
+            duration=waveform_params["n_samples"],
+            wave_i=wave_i,
+            wave_q=wave_q,
+            scale_i=root_params["amplitude_i"],
+            scale_q=root_params["amplitude_q"],
+            phase=root_params["phase"],
+            modulation_frequency=if_freq,
+        )
+
+        return probe_pulse
+
+    def probe_timebox(
+        self, key: str = "", feedback_key: str = "", do_acquisition: bool = False
+    ) -> MultiplexedProbeTimeBox:
+        """Returns a "naked" probe timebox that supports convenient multiplexing through
+        ``MultiplexedProbeTimeBox.__add__``.
+
+        This method can be used if the user wants to control the multiplexing explicitly. With two
+        ``MultiplexedProbeTimeBox``es ``A`` and ``B`` the result ``A + B`` has all the ``ReadoutTrigger`` instructions
+        on each probe channel of ``A`` and ``B`` multiplexed together and played simultaneously.
+
+        Args:
+            key: The readout results generated on this trigger will be assigned to
+                ``f"{qubit}__{key}"``, where ``qubit`` goes over the component names in ``self.locus``. If empty,
+                the key `"readout.result"` will be used to maintain backwards compatibility.
+            feedback_key: The signals generated by this measure operation are routed using this key for
+                fast feedback purposes. See :meth:`__call__`.
+            do_acquisition: if False, no acquisitions are added.
+
+        Returns:
+            MultiplexedProbeTimeBox containing the ReadoutTrigger instruction.
+
+        """
+        args = (key, feedback_key, do_acquisition)
+        # additional caching for probe timeboxes due to the fact that both ._call and .time_trace use this
+        if args not in self._multiplexed_timeboxes:
+            if len(self.locus) == 1:
+                multiplexed_iq = MultiplexedIQPulse(
+                    duration=self._probe_instruction.duration,
+                    entries=((self._probe_instruction, 0),),
+                )
+                readout_trigger = ReadoutTrigger(
+                    probe_pulse=multiplexed_iq,
+                    acquisitions=(),
+                    duration=self._duration,
+                )
+                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 = ""
+
+                if drive_channel:
+                    # drive channel must be blocked, to prevent DD insertion while measurement is taking place
+                    # unfortunately we must allow for different channel sample rates because of UHFQA
+                    channels = self.builder.channels
+                    drive_channel_props = channels[drive_channel]
+                    rt_duration_in_seconds = channels[probe_channel].duration_to_seconds(readout_trigger.duration)
+                    block_duration = drive_channel_props.duration_to_int_samples(
+                        drive_channel_props.round_duration_to_granularity(
+                            rt_duration_in_seconds, round_up=True, force_min_duration=True
+                        )
+                    )
+                    probe_timebox = MultiplexedProbeTimeBox.from_readout_trigger(
+                        readout_trigger=readout_trigger,
+                        probe_channel=probe_channel,
+                        locus_components=self.locus,
+                        label=f"{self.__class__.__name__} on {self.locus}",
+                        block_channels=[drive_channel],
+                        block_duration=block_duration,
+                    )
+                else:
+                    probe_timebox = MultiplexedProbeTimeBox.from_readout_trigger(
+                        readout_trigger=readout_trigger,
+                        probe_channel=probe_channel,
+                        locus_components=self.locus,
+                        label=f"{self.__class__.__name__} on {self.locus}",
+                    )
+            else:
+                probe_timeboxes = [
+                    self.builder.get_implementation(
+                        self.parent.name, (c,), impl_name=self.name, priority_calibration=self._prio_calibration
+                    ).probe_timebox(key, feedback_key, do_acquisition)
+                    for c in self.locus
+                ]
+                probe_timebox = functools.reduce(lambda x, y: x + y, probe_timeboxes)
+            probe_timebox.neighborhood_components[0] = set(
+                self.locus + (self.builder.chip_topology.component_to_probe_line[self.locus[0]],)
+            )
+
+            self._multiplexed_timeboxes[args] = probe_timebox
+        return self._multiplexed_timeboxes[args]
+
+    def _call(self, key: str = "", feedback_key: str = "") -> TimeBox:
+        """Returns a TimeBox containing the multiplexed simultaneous measurement.
+
+        If ``len(self.locus) == 1``, the TimeBox contains the measurement for just that component, otherwise
+        the measurements of components that belong to the same probeline are multiplexed together.
+
+        The returned :class:`.TimeBox` instances behave like any other TimeBox in scheduling and circuit
+        generation. With measurement TimeBoxes ``A`` and ``B`` the result ``A + B`` first plays the ``ReadoutTrigger``
+        instructions of ``A`` and only then those of ``B`` in each probe channel. If the multiplexing features of
+        :class:`.MultiplexedProbeTimeBox` are needed, the method :meth:`probe_timebox` can be used.
+
+        In scheduling, the returned TimeBox blocks the locus components and the probe
+        lines they are associated with.
+
+        Args:
+            key: Readout results generated on this trigger will be assigned to the acquisition labels
+                ``f"{qubit}__{key}"``, where ``qubit`` goes over the component names in ``self.locus``.
+                If empty, the key ``"readout.result"`` will be used to maintain backwards compatibility.
+            feedback_key: If the readout mode is "threshold", the results generated by this ``measure`` operation
+                are routed using the label ``f"{qubit}__{feedback_key}"`` for fast feedback purposes.
+                The signals are picked up by :class:`.ConditionalInstruction`s that have the same label.
+                The default value ``""`` means the signal is not routed anywhere. TODO: currently the HW does not
+                support multiple feedback keys per drive channel, so the actual key used will be ``FEEDBACK_KEY``
+                whenever any non-empty key is inputted. When the HW is improved, the actual key the user inputs
+                should be passed.
+
+        Returns:
+            TimeBox containing the :class:`.ReadoutTrigger` instruction.
+
+        """
+        final_box = TimeBox.composite(
+            [self.probe_timebox(key=key, feedback_key=feedback_key)], label=f"Readout on {self.locus}"
+        )
+        final_box.neighborhood_components[0] = final_box.children[0].neighborhood_components[0]
+        return final_box
+
+    def duration_in_seconds(self) -> float:
+        probe_timebox = self.probe_timebox()
+        readout_schedule = probe_timebox.atom
+        return readout_schedule.duration_in_seconds(self.builder.channels)
+
+    @classmethod
+    def get_locus_mapping_name(cls, operation_name: str, implementation_name: str) -> str:
+        return SINGLE_COMPONENTS_WITH_READOUT_LOCUS_MAPPING
+
+
+class Probe_Constant(ProbePulse_CustomWaveforms_noIntegration, wave_i=Constant, wave_q=Constant):  # type: ignore[call-arg]
+    """Implementation of a single-qubit projective, dispersive measurement in the Z basis.
+
+    Uses a constant probe pulse.
+    """

iqm/pulse/gates/rz.py

@@ -32,6 +32,7 @@ import numpy as np
 from exa.common.data.parameter import Parameter
 from iqm.pulse.gate_implementation import (
     SINGLE_COMPONENTS_WITH_DRIVE_LOCUS_MAPPING,
+    CompositeGate,
     GateImplementation,
     Locus,
     OILCalibrationData,
@@ -46,7 +47,7 @@ from iqm.pulse.utils import normalize_angle, phase_transformation
 if TYPE_CHECKING:  # pragma: no cover
     from iqm.pulse.builder import ScheduleBuilder
     from iqm.pulse.quantum_ops import QuantumOp
-    from iqm.pulse.timebox import TimeBox
+from iqm.pulse.timebox import TimeBox
 
 
 @lru_cache
@@ -245,3 +246,22 @@ class RZ_ACStarkShift_smoothConstant(
 
     def __call__(self):
         return super().__call__(angle=np.pi)
+
+
+class RZ_PRX_Composite(CompositeGate):
+    """RZ gate implemented as a sequence of PRX gates."""
+
+    registered_gates = ["prx"]
+
+    def __init__(self, parent, name, locus, calibration_data, builder):
+        super().__init__(parent, name, locus, calibration_data, builder)
+
+    def __call__(self, angle: float) -> TimeBox:
+        prx = self.build("prx", self.locus)
+        return TimeBox.composite(
+            [
+                prx.ry(np.pi / 2),
+                prx.rx(angle),
+                prx.ry(-np.pi / 2),
+            ]
+        )

{iqm_pulse-9.4.dist-info → iqm_pulse-9.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-pulse
-Version: 9.4
+Version: 9.6
 Summary: A Python-based project for providing interface and implementations for control pulses.
 Author-email: IQM Finland Oy <info@meetiqm.com>
 License: Apache License

{iqm_pulse-9.4.dist-info → iqm_pulse-9.6.dist-info}/RECORD

@@ -8,19 +8,19 @@ iqm/pulse/scheduler.py,sha256=jBi68_Y1RVNe3aDmP4wmudDs5vXCHZm-UXl3IpgNDDM,22738
 iqm/pulse/timebox.py,sha256=w3R6VafBXx_cGWrcvI_6x1e6JII_9v1vxQoRSGIjtXE,16591
 iqm/pulse/utils.py,sha256=HyTkMD0er_rZnvDZWM1WscOFxaxGMyRAW_Aw36b0Hdc,7998
 iqm/pulse/validation.py,sha256=-tZWrW201t4nbTQWeZ8M9DixzoN8B0Q63IP57BfDAz0,10733
-iqm/pulse/gates/__init__.py,sha256=2v1wRMyQlyzScBk2D3wit3C2qbPhUHpSJbGPfSUespY,12878
+iqm/pulse/gates/__init__.py,sha256=zMz1jDQg6EFsTreNu0NyhOWpecWnbAntrvSlJQa7Xoo,12926
 iqm/pulse/gates/barrier.py,sha256=WhYV70lf4lh4Wa9UZuMk2lp9JbUQIu8lzewRC2P7pNE,2546
 iqm/pulse/gates/conditional.py,sha256=3tW5kVt2M2xaTJxaixTErU5DTe91F0uE9BN9kopBEkQ,6242
 iqm/pulse/gates/cz.py,sha256=QgV-mn2aPDbfNplwEi18Lll4Zle-IELpn43IPM6Q_w8,20141
-iqm/pulse/gates/default_gates.py,sha256=nBVzyhU1Xj-jCuC-0e9OZPjOJShg7yFeS7oqeqPCrdw,9356
+iqm/pulse/gates/default_gates.py,sha256=kLNYjt-ZXYPvfBS1p8pi7e3gZz2UnMSWS4S2Xmj6omg,9413
 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=lnlynR_SWM6Wp7RjVcyParCSNKacKargEC5lLF5jwKU,9692
-iqm/pulse/gates/measure.py,sha256=VlcPufdl3tG2MNcRkUzKjBz5BFqVVqBOCn6-mPTRhoc,29518
+iqm/pulse/gates/measure.py,sha256=izqaO4Pxxb7THJhs6tx3QT_YCFDpdt8Mi30E-gwvM7g,40429
 iqm/pulse/gates/move.py,sha256=yKY-Et4YJV0KmcDwN0yE3oHgDtLL-Xfgy1G_InsJN0U,17182
 iqm/pulse/gates/prx.py,sha256=SaJHcVu-NURUBTF5LtmTwwK1qcCtXA89NA5VwJXBM1o,24504
 iqm/pulse/gates/reset.py,sha256=ZgliZd2yVJZuVyeVt6qnnVTt3CGb-cLCIWmoq4nS4lk,7574
-iqm/pulse/gates/rz.py,sha256=hd0tEbCUzA7sRRQ1PWwqJTmLL9ikvL2xYot6aBoq-yc,8856
+iqm/pulse/gates/rz.py,sha256=6iQudKjEhze0DkGDY1GZIJ7IW1QqxL7Fy74lTrJ4o8s,9416
 iqm/pulse/gates/sx.py,sha256=V8e94LHRLkXLjSSeuKxZQbhwgGDAWdQxsfhbYi4gtp8,1673
 iqm/pulse/gates/u.py,sha256=2kmbTYprrkVP4EbwGXNZcT5lzInjjOAvq8vk0lw57YY,5256
 iqm/pulse/playlist/__init__.py,sha256=XW-7Po_vCzhkk1Js06K8P-5srPpBuPHkqpc1yhL_Zx4,997
@@ -38,8 +38,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-9.4.dist-info/LICENSE.txt,sha256=R6Q7eUrLyoCQgWYorQ8WJmVmWKYU3dxA3jYUp0wwQAw,11332
-iqm_pulse-9.4.dist-info/METADATA,sha256=4e_r2lx7UPgyFrWWAlASRdH0t5F2KMMP1hF-ziuMWj0,14520
-iqm_pulse-9.4.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
-iqm_pulse-9.4.dist-info/top_level.txt,sha256=NB4XRfyDS6_wG9gMsyX-9LTU7kWnTQxNvkbzIxGv3-c,4
-iqm_pulse-9.4.dist-info/RECORD,,
+iqm_pulse-9.6.dist-info/LICENSE.txt,sha256=R6Q7eUrLyoCQgWYorQ8WJmVmWKYU3dxA3jYUp0wwQAw,11332
+iqm_pulse-9.6.dist-info/METADATA,sha256=PvoI-osxl1RWW5_IrkkNTiyl-1SEQYjCPFzWFHPNAaQ,14520
+iqm_pulse-9.6.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+iqm_pulse-9.6.dist-info/top_level.txt,sha256=NB4XRfyDS6_wG9gMsyX-9LTU7kWnTQxNvkbzIxGv3-c,4
+iqm_pulse-9.6.dist-info/RECORD,,